Allez, c'est parti! Aujourd'hui, nous allons créer notre distribution embarquée pour l'IGEP. L'avantage sera majeur : nous intégrerons uniquement ce que nous voulons.

Cet article sera sujet à des modifications durant les prochains jours...




Dans cet article nous utiliserons un montage NFS et un serveur tftp pour faire nos tests. Je vous conseil donc très fortement de lire le post à ce sujet avant d'attaquer ce morceau ([IGEPv2] Kernel et Rootfs via tftp et nfs).

Nous utiliserons aussi Git, un gestionnaire de version. Si vous ne l'avez pas, installez le :
$ apt-get install git

Nous aurons aussi besoin de la librairie ncurses pour disposer d'une interface plus conviviale lors des menuconfig :
$ apt-get install libncurses5-dev




Préparation de notre environnement de travail


On va commencer par le plus simple, créer nos dossiers. Comme dans l'article précédent, nous allons suivre cette hiérarchie de dossier :
/srv/tftp/pebdev-dist/image-base/igep020/kernel/
/srv/nfs/pebdev-dist/image-base/igep020/rootfs/


Nous devrons utiliser le Bourne Shell, si vous êtes sur Debian :
$ dpkg-reconfigure dash
Répondre NON.





Chaîne de compilation croisée


Nous allons compiler sur notre PC des fichiers qui devront être exécutés sur une plate-forme ARM. Nous ne pouvons donc pas utiliser le compilateur gcc classique. Si nous le faisons, les fichiers pourront être exécutés uniquement sur une plate-forme i386 (un PC). En effet, le compilateur va transformer un code source en une suite d'instructions compréhensible par la plate-forme cible. Voila pourquoi nous devons utiliser un compilateur croisé, et dans notre cas, pour une cible ARM.

Notre choix se portera sur CodeSourcery G++ Lite. Ne vous posez pas de question sur le G++, c'est bien un compilateur C/C++ :)

Lien du projet G++ : CodeSourcery G++

Commencez par le télécharger :
  1. Allez sur la page de téléchargement.
  2. Sélectionnez GNU/Linux.
  3. Téléchargez la dernière version.
Ensuite nous l'installons :
$ chmod +x arm-2010q1-202-arm-none-linux-gnueabi.bin
$ mkdir /opt/codesourcery
$ chown peb /opt/codesourcery
$ ./arm-2010q1-202-arm-none-linux-gnueabi.bin
Rien de compliqué lors de l'installation. Notez juste que vous devez choisir une installation Custom pour définir le chemin d'installation /opt/codesourcery/.

Maintenant nous allons tester l'installation :
//On met à jour temporairement la variable PATH
$ export PATH=/opt/codesourcery/bin:$PATH

//Si vous souhaitez visualiser le résultat
$ echo PATH

//On regarde la version du compilateur
$ arm-none-linux-gnueabi-gcc -v
Normalement vous devriez avoir un pavé de texte qui s'affiche, si ce n'est pas le cas, c'est qu'il y a un problème avec l'installation ou que votre variable PATH n'a pas été mise à jour correctement...

Si vous fermez le terminal, les modifications faites sur la variable PATH seront perdues, pensez à la remettre à jour.
Sinon il existe une autre méthode plus rapide qui consiste à se loguer ainsi :
$ su - peb
Dans ce dernier cas, la variable sera ajoutée toute seule :)





Compilation d'un noyau de base


Attention aux âmes sensibles... On est entre nous, donc pour la préparation du noyau pour l'IGEP, on va bourrinner et en faire le strict minimum :p
Par là, comprenez que nous allons récupérer les sources d'un noyau linux omap, mais qu'on va le compiler en utilisant une configuration déjà préparée. Nous toucherons éventuellement 2,3 paramètres, mais attention, pas plus! ;)

Allez, on télécharge ce noyau omap qu'ISEE nous propose pour l'IGEP (http://git.igep.es/). Pour cela on va cloner le repo avec git (attention ça prend du temps : ~20min pour moi.NE PAS ETRE EN ROOT) :
$ cd /srv/tftp/pebdev-dist/image-base/igep020/kernel/
$ git clone git://git.igep.es/pub/scm/linux-omap-2.6.git

La première étape après le téléchargement, c'est de bien choisir le noyau que l'on souhaite :
$ cd linux-omap-2.6

//On regarde les différentes versions
$ git tag

//On choisi la dernière version
$ git checkout -b v2.6.35.9-0 v2.6.35.9-0

Juste avant, pour la compilation croisée, on doit configurer 2 variables :
$ export ARCH=arm
$ export CROSS_COMPILE=/opt/codesourcery/bin/arm-none-linux-gnueabi-
Cela permet de renseigner notre cible et le compilateur à utiliser.

Ensuite on charge la configuration pour notre carte. Pour cela on va chercher une configuration qui comporterait le mot igep :
$ cd linux-omap-2.6
$ make help | grep igep

Et là on cherche dans le résultat un fichier de configuration qui pourrait aller pour notre carte igep... et ça tombe bien! il y a un fichier qui se nomme igep0020_defconfig! On va donc utiliser cette configuration :)

Maintenant on charge le fichier de configuration :
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- igep0020_defconfig
On lance ensuite le menu de configuration :
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- menuconfig
A titre indicatif, ici on peut modifier la configuration du noyau. Bien sur nous, nous allons prendre soin de ne rien toucher, le fichier de configuration c'est chargé de tout ça^^

Donc c'est parti, on peut compiler (~45min) :
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- uImage modules
Note : si à la fin de la compilation un message vous indique que l'uImage n'a pas pu être générée parce qu'il manque le package qui va bien (et dont je ne me souviens pas du nom^^⁾, installez le et retapez la commande précédente.

Voila, nous avons notre noyau. Il se nomme uImage et se trouve dans :
/srv/tftp/pebdev-dist/image-base/igep020/kernel/linux-omap-2.6/arch/arm/boot/.

A noter aussi, le mot modules va nous permettre de générer les drivers que l'on pourra ajouter à la rootfs par la suite.






Rootfs de base avec BusyBox


Nous avons un noyau, nous pouvons donc nous attaquer à la rootfs. Dans un premier temps, nous allons mettre le strict minimum de sorte à avoir un shell.
Pour cela il existe un petit outils assez pratique : BusyBox.

On le télécharge avec Git (NE PAS ETRE EN ROOT), faites bien attention au chemin cible :
$ cd /srv/nfs/pebdev-dist/image-base/igep020/
$ git clone git://git.busybox.net/busybox
Si vous avez fermé votre terminal après la compilation du noyau, pensez bien à vous loguer correctement et à configurer les 2 variables pour la compilation :
$ export ARCH=arm
$ export CROSS_COMPILE=/opt/codesourcery/bin/arm-none-linux-gnueabi-
On lance ensuite le menu de configuration :
$ cd busybox/
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- menuconfig
Ensuite dans le menu BusyBox Settings > Build Options.
Cochez la case (touche espace) : [*] Build BusyBox as a static bianry
Complétez aussi la ligne pour la cross-compilation : (/opt/codesourcery/bin/arm-none-linux-gnueabi-) Cross Compiler prefix

Nous allons aussi changer le chemin d'installation, pour cela revenez au menu principal, est allez dans BusyBox Settings > Installation Options.
Pour l'option BusyBox installation prefix configurez le chemin suivant ../rootfs/

Nous n'avons que cela à configurer. Faites donc Exit le nombre de fois qu'il faut pour quitter le menu. Lorsqu'on vous le demande, enregistrez la nouvelle configuration.

Tout est prêt, nous pouvons compiler!
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- install
Nous avons notre rootfs dans /srv/nfs/pebdev-dist/image-base/igep020/rootfs/.

Nous ajoutons les modules du noyau :
$ cd /srv/tftp/pebdev-dist/image-base/igep020/kernel/linux-omap-2.6
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- modules_install INSTALL_MOD_PATH=/srv/nfs/pebdev-dist/image-base/igep020/rootfs/

Et enfin, pour terminer, nous ajoutons les noeuds de périphériques statiques. Pour cela nous utiliserons un petit programme que nous allons commencer par télécharger :
$ apt-get install makedev
Maintenant on l'utilise :
$ cd /srv/nfs/pebdev-dist/image-base/igep020/rootfs/
$ mkdir dev
$ cd dev/
$ su root
$ /sbin/MAKEDEV console
$ /sbin/MAKEDEV fb0
$ /sbin/MAKEDEV null
$ /sbin/MAKEDEV std
$ /sbin/MAKEDEV tty
$ /sbin/MAKEDEV ttyS
$ /sbin/MAKEDEV hd

Voila, notre rootfs est prête!





Test de la distribution par tftp et NFS


Si vous vous souvenez bien (cf. article précédent), la première chose à faire est de configurer le tftp et le nfs. Pour le tftp, nous n'avons rien à modifier sur le PC, par contre pour le nfs nous devons mettre à jour le chemin d'accès.

Pour cela on édite le fichier /etc/exports, on commente le chemin qui pointe vers la rootfs d'Android et on ajoute la ligne suivante :
# pebdev-dist image-base
/srv/nfs/pebdev-dist/image-base/igep020/rootfs/ 192.168.254.254(rw,no_root_squash,no_subtree_check,sync)
On redémarre le serveur nfs pour terminer :
$ /etc/init.d/nfs-kernel-server restart

On pense aussi à configurer l'adresse IP du PC :
$ ifconfig eth0 192.168.254.10

Maintenant on doit reconfigurer uboot. On branche la carte, on interrompt la séquence d'autoboot grâce à la liaison série (si cela ne vous parle pas, allez faire un tour sur l'article précédent), et on change les variables d'environnement qu'il faut :
//On change le nom de la distribution
$ setenv distro 'pebdev-dist'

//On change l'accès au noyau
$ setenv nfs-boot 'if ping ${serverip}; then run nfs-bootargs; tftp 0x80000000 ${distro}/${project}/${machine}/kernel/linux-omap-2.6/arch/arm/boot/uImage; bootm; fi;'

//On sauvegarde les variables
$ saveenv

Voila! Tout est prêt! On lance la commande run bootcmd à uboot pour voir le résultat...


Si vous branchez un clavier et que vous appuyez sur une touche vous aurez accès au shell.

Nous verrons dans un prochain article comment rendre notre roofs plus conviviale.

Si vous avez des questions, comme d'habitude, n'hésitez pas à utiliser les com ci-dessous ;)