Cross compilare per Arietta G25

Tra kernel ed eseguibili personalizzati.

arm926t è l’architettura per la quale vogliamo andare a creare eseguibili.

Partiamo dall’installazione del Cross compiler, e delle utilities.

sudo apt-get install libc6-armel-cross libc6-dev-armel-cross binutils-arm-linux-gnueabi libncurses5-dev

e poi:

$ sudo apt-get install gcc-arm-linux-gnueabi g++-arm-linux-gnueabi

A questo punto possiamo eseguire un breve test:

#include "stdio.h"
 
int main(void) {
  printf("Hello world !\n");
  return 0;
}

e di seguito:

$ arm-linux-gnueabi-gcc helloworld.c -o helloworld

Per il C++ il comando sarebbe sarebbe stato il seguente:

arm-linux-gnueabi-g++ helloworld.cc -o helloworld

Ed il sorgente questo:

#include "iostream"

using namespace std;

int main(int argc, char *argv[]) {
cout << "Hello world !" << endl;
return 0;
}

 

Kernel:
E’ arrivato il momento di provare a compilare un kernel ad hoc (scopiazzando le guide di acmesystems ovviamente!)

 

Scarichiamo i sorgenti:

$ wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.9.124.tar.xz

Decomprimiamo l’archivio:

$ tar xvfJ linux-4.9.124.tar.xz

e ci spostiamo nella cartella appena creata:

$ cd linux-4.9.124

Adesso scarichiamo la patch creata sempre da acmesystems contenente i defconfigs ed i files dts.

$ wget https://raw.githubusercontent.com/AcmeSystems/acmepatches/master/linux-4.9.patch

La applichiamo:

$ patch -p1 < linux-4.9.patch

A questo punto generiamo il file DTB a partire dal DTS gentilmente già fornito in dotazione.

$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- acme-arietta.dtb

Personalmente ho utilizzato una mia  versione del DTS.

Il percorso standard per i files dts è linux-4.9.124/arch/arm/boot/dts$

L’output del precedente comando creerà il file DTB proprio qui dove stava il DTS.
(N.B. Se dovesse servire ricordiamo di rinominare il DTB.
Il file DTB generato avrà lo stesso prefisso del DTS. Il bootloader di secondo livello (boot.bin) però andrà a cercare il DTB col seguente nome: acme-arietta.dtb pena questo messaggio):

AT91Bootstrap 3.7-00029-ge79aea3 (mar 20 ott 2015, 15.59.44, CEST)

1-Wire: Loading 1-Wire information ...
1-Wire: ROM Searching ... Done, 0x0 1-Wire chips found

WARNING: 1-Wire: No 1-Wire chip found

1-Wire: Using default information

1-Wire: SYS_GPBR2: 0x4010425, SYS_GPBR3: 0x8421

SD/MMC: Image: Read file zImage to 0x22000000
SD: Card Capacity: High or Extended
SD: Specification Version 3.0X
SD/MMC: dt blob: Read file acme-arietta.dtb to 0x21000000
SD: Card Capacity: High or Extended
SD: Specification Version 3.0X
*** FATFS: f_open, filename: [acme-arietta.dtb]: error
SD/MMC: Failed to load image

 

Per quanto riguarda il kernel vero e proprio applichiamo il defconfig che riteniamo più opportuno, ad esempio:

$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- acme-xterm-01_defconfig

e poi se necessario configuriamo secondo le nostre esigenze:

$ make ARCH=arm menuconfig

Salviamo a questo punto quello che diventerà il nostro defconfig:

$ make ARCH=arm savedefconfig

ed andiamo a copiarlo al suo posto:

$ cp defconfig arch/arm/configs/myboard_defconfig

E’ ora di compilare:

$ make -j8 ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- zImage

Se abbiamo optato per un kernel non monolitico (non è questo il mio caso) dovremo compilare anche i moduli:

$ make modules -j8 ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
$ make modules_install INSTALL_MOD_PATH=./modules ARCH=arm

Al primo avvio dovremo ricordarci di fare l’update delle dipendenze dei moduli col comando:

$ depmod -a

Non ci rimane che copiare i frutti del nostro lavoro in una microSD preformattata e con il bootloader (boot.bin) già pronto nella partizione di boot ed il rootfs già al suo posto..

Per quanto riguarda il DTB pasterà un semplice cp:

$ cp arch/arm/boot/dts/acme-arietta.dtb /media/$USER/BOOT/acme-arietta.dtb

Il kernel invece si troverà in arch/arm/boot/zImage, quindi:

$ cp arch/arm/boot/zImage /media/$USER/BOOT

E’ ora di trasferire anche i moduli:

$ sudo rsync -avc modules/lib/. /media/$USER/rootfs/lib/.

P.S.

Questo è il mio boot.bin per Arietta G25 256 MB.

 

Considerazioni sulla cross compilazione.

La “distribuzione” che attualmente gira sulla mia Arietta di prova è stata realizzata con buildroot e selezionando come Toolchain type la Buildroot toolchain.

 

Senza pormi alcun problema a tal riguardo ho cross compilato sul mio portatile il programma di esempio riportato in cima a queste note, il fatidico HelloWorld, che poi ho trasferito via scp direttamente su Arietta.

Ovviamente (per molti, ma evidentemente non per me) l’eseguibile non girava.
Il problema stava nel fatto che il compilatore utilizzato da buildroot utilizza le librerie uClibc mentre il cross compilatore installato sul portatile ha generato un eseguibile dipendente dalle proprie librerie.
Tutto è andato per il meglio utilizzando sempre sulla macchina host, il portatile, il compilatore utilizzato da buildroot durante la creazione del rootfs.

Quindi, con:

/home/antonino/sviluppo/buildroot-2020.02.1/output/host/bin/arm-buildroot-linux-uclibcgnueabi-gcc-8.4.0 helloworld.c -o HW

Tutto ha funzionato alla perfezione.

Posted in Digitale, Linux.

admin

Admin, per l'anagrafe Antonino Brisindi e per i colleghi radioamatori IZ0HEM,
nasce a Giugno del 1972.
Si cimenta in diverse discipline. Dal motociclismo all'elettronica.
Dalla meccanica delle chiavi inglesi al Jazz delle ance.
Dalla cucina dei fornelli alle dinamiche di volo ad ala mobile.
Interagisce con tutto quello che intercorre tra un 6502 ed un sistema embedded.
Capisce davvero poco di tutto quello che fa ed in questo periodo ama definirsi un pessimo system integrator! ;-)

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

*

code