Pages persos Eric Meyer

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Le programme de chargement initial (Boot loader) ======

===== Rôle du programme de chargement initial =====

Ce programme sert au minimum à initialiser les premières fonctions vitales du processeur et de la carte lors de son démarrage, ainsi qu'à passer certaines informations au système d'exploitation qu'il pourra charger par la suite. On peut donc considérer qu'il a à la fois le rôle du BIOS et d'un programme (tel que Grub ou Lilo) résidant dans le secteur d'amorçage (MBR) du disque maître sur un ordinateur classique.\\ 
Au minimum, un le programme de chargement initial a les fonctionnalités suivantes ((Introduction to Das U-Boot, the universal open source bootloader. Par Curt Brune[[http://www.linuxdevices.com/articles/AT5085702347.html]])) : \\  
  * initialiser le matériel, spécialement le contrôleur de mémoire ;
  * fournir les paramètres de démarrages pour le noyau Linux ;
  * Démarrer le noyau Linux.
En plus, la plus part des programmes de chargement initial fournissent aussi des fonctionnalités de « confort » facilitant le développement, comme : \\ 
  * lire et écrire dans la mémoire à des emplacements arbitraires ;
  * télécharger de nouvelles images binaires dans la mémoire de la carte par un lien série ou Ethernet ;
  * copier des images binaires de la RAM vers la mémoire FLASH.
Dans ce document, nous allons nous attacher à l'utilisation de U-Boot((The DENX U-Boot and Linux Guide (DULG)[[http://www.denx.de/wiki/DULG/Manual]])). Programme de chargement initial développé et disponible gratuitement auprès de la société DENX.

===== Objectifs de ce document =====
Je vais ici expliquer les étapes de personnalisation de U-Boot version 2009.03 afin de l'utiliser avec la carte CPUAT91 et son kit de développement, le [[Linux embarqué:#Le matériel|KITAT91]] de la société [[http://www.eukrea.com/|Eukréa]]. Je montrerai comment construire une image de U-Boot pour cette carte. Ensuite, je donnerai une façon de charger l'image de U-Boot. Je donnerai aussi quelques explications sur la manipulation de cet outil. Enfin, une procédure de secours sera vue afin de pouvoir remettre la carte en état de marche au cas où un problème empêcherait la carte de démarrer normalement.

===== Prérequis =====

Avant d'utiliser U-Boot et de construire mon image du programme de chargement initial, Nous aurons besoin d'une chaine de développement croisée. j'utiliserai la chaine ELDK. [[Linux embarqué:Outil de compilation croisée|Voir le chapitre Outil de compilation croisée]].\\ 
J'utilise le système Linux Ubuntu 9.04.

===== Installation de U-Boot =====
Il est nécessaire d'avoir installé le programme //git// pour télécharger et manipuler les fichiers de U-Boot. \\ 
J'ai utilisé la commande suivante :\\ 
  $ git clone http://git.denx.de/u-boot.git /chemin/d/installation/de/uboot/u-boot 
où ///chemin/d/installation/de/uboot/u-boot// est un répertoire pas encore créé où nous souhaitons installer le programme.\\ 
Le développement de U-Boot utilise le programme de gestion de version et de distribution partagée qui s'appelle //git//. Pour de détail sur ce programme, voir le document //utilisation de git//((utilisation de git (document non mis en ligne actuellement, voir le site officiel http://git-scm.com/) )).

==== Version de U-Boot ====
Au moment où j'ai téléchargé U-Boot, la version stable était U-Boot-2009.03 de mars 2009.
Pour récupérer cette version, voici comment procéder. \\ 
Voir les versions :
  $ git tag -l 
  2009.01-rc2 
  DENX-2005-10-29-2350 
  LABEL_2002_11_05_0120 
  LABEL_2002_11_05_1735 
  LABEL_2002_11_10_2310 
  ...
  v1.3.3-rc3 
  v1.3.4 
  v1.3.4-rc1 
  v1.3.4-rc2 
  v2008.10 
  v2008.10-rc1 
  v2008.10-rc2 
  v2008.10-rc3 
  v2009.01 
  v2009.01-rc1 
  v2009.01-rc2 
  v2009.01-rc3 
  v2009.03 
  v2009.03-rc1 
  v2009.03-rc2 
  v2009.06-rc1 
  v2009.06-rc2

Extraire la version v2009.03 en créant une branche de développement spécifique : \\
  $ git checkout -b EM_cpuat91 v2009.03 
  Switched to a new branch "EM_cpuat91"

Maintenant, le répertoire de travail reflète le contenu du projet tel qu'il était lorsqu'il a eu le marqueur « v2009.01 », dans une nouvelle branche de projet appelée  « EM_cpuat91 ».\\ 
Nous pouvons commencer à travailler dans cette version.\\ 

===== Configuration de U-Boot pour la carte cible CPUAT91 =====

Le but étant de créer un fichier contenant le code binaire qui sera chargé sur la carte cible, il est nécessaire de préparer un emplacement sur le disque qui recevra les différents éléments nécessaires adaptés uniquement à cette cible et de créer la configuration adéquate. Plusieurs modifications et rajout de fichiers sont nécessaires au préalable. Je vais utiliser des rustines, ou "patch", qui ont été construites pour cette version de U-Boot. Le fichier README, dans le répertoire u-boot, nous renseigne sur comment utiliser U-Boot  de manière générale dans le cadre d'une architecture de carte déjà préparée. 

==== Applications des rustines ====
Les rustines (ou patch) servent à mettre à jour les différents fichiers qui ont été modifiés, crés et rajoutés pour les besoins du module CPUAT91 et de sa carte d'extension.\\ 
Vous pouvez télécharger le fichier archive qui les contients ici {{:linux_embarque:fichiers:rustines.tar|}}\\ 
Il faut maintenant désarchiver ces fichiers. Par exemple, vous pouvez effectuer les la commande suivante :\\ 
Désarchivez les fichiers //rustines.tar// \\ 
<code>$ tar -xvvf /répertoire/où/le/fichier/a/été/téléchargé/rustines.tar</code>
Appliquez les rustines à u-boot :\\
<code>$ git apply *.patch </code>


==== Préparations ====

  - Configurer le chemin des programmes de compilation. \\ Afin de configurer correctement les variables d'environnement nécessaires à l'exécution des commandes de construction, il faut adapter le contenu du fichier //config_env_uboot.sh//. Pour cela n'importe quel éditeur de texte fait l'affaire. Par exemple, si //gedit// est installé, nous pourrons taper dans le répertoire racine où U-Boot est installé : \\ <code>$ gedit config_env_uboot.sh &</code> Le //&// est ici pour permettre de continuer l'usage de la ligne de commande sur la console qui a appelée l'éditeur de texte. 
  - Mettre ce chemin  dans la variable //PATH// . \\ Dans notre cas, il s'agit du chemin de la chaine de compilation croisée ELDK installée dans le répertoire  // /chemin/d/installation/de/ELDK/ //. Repérer cette section du fichier :\\ <code>#mettez ici le chemin des binaires de votre chaine de compilation croisee 
#PATH=/chaine_compilation_croisee/usr/bin:$PATH 
PATH=/chemin/d/installation/de/ELDK/usr/bin:$PATH </code>
  - Exécuter le script //config_env_uboot.sh//.\\ Ce script crée un répertoire où nous y mettrons les résultats des opérations nécessaires dédiées à notre carte. Il s'appellera CPUAT91. et aura comme nom de variable d'environnement //BUILD_DIR//. Comme nous l'avons vu plus haut, il configure aussi la variable //PATH// avec le chemin des outils de compilation. Tapons la commande suivante : \\ <code>$ ./config_env_uboot.sh
Vous etes a present dans l environnement u-boot pour la carte CPUAT91
Tapper CTRL+D pour restaurer l environnement initial
</code> \\ Pour sortir ensuite de cet environnement spécifique, il suffira de taper simultanément la combinaison de touches CTRL+D.
  - S'assurer qu'il ne reste aucune trace de configuration précédente. \\ <code>$ make distclean</code>
  - Éventuellement, modifier les paramètres de configuration pour construire l'image binaire du programme de démarrage initial. Pour cela, quelques pistes sont données dans la section [[Programme de chargement initial#Quelques définitions dans "cpuat91.h" et "Makefile"]]

<box round red>Par la suite, quand nous aurons redémarré la machine, les variables d'environnements seront perdues. Elles n'ont pas non plus d'utilité en dehors de la construction de fichiers binaires pour cette cible. Exécuter le script //config_env_uboot.sh// à chaque fois que l'on souhaite revenir dans ce contexte.\\ 
<code>config_env_uboot.sh</code> ./</box>

===== Création du fichier binaire image =====

Maintenant, nous sommes prêt à compiler les données et créer une image binaire du programme de démarrage initial. Tapons donc les commandes suivantes :
<code>$ make cpuat91_config

... CPUAT91 Flash ... OK : 
Configuring for cpuat91 board...

$ make all
</code>

Si tout se passe bien, le fichier final, //u-boot.bin//, est créé. C'est l'image de ce qu'il va falloir charger dans la carte. Ce fichier se situe dans le répertoire de construction définit en variable d'environnement : //CPUAT91//. 


<box round red | **ATTENTION à la taille du fichier** >
En regardant la taille de ce fichier, il est nécessaire qu'elle soit **inférieure à 131072 octets**. Ce chiffre provenant de la taille du moniteur déterminé par la variable //CONFIG_SYS_MONITOR_LEN// définit ici avec la valeur hexadécimale 0x20000, ce qui vaut 131072 en décimal. Si la taille de notre image dépasse cette valeur, il faut revoir ce qui peut être retiré ou optimisé dans le projet afin de tenir dans cette taille mémoire, ou modifier le plan mémoire.
<code>$ cd CPUAT91
$ ls -l u-boot.bin

-rwxr-xr-x 1 emeyer data 108344 2009-05-25 14:41 u-boot.bin</code>
</box>

===== Installation de U-Boot sur la cible =====

Dans le cas de la carte CPUAT91, il y a déjà U-Boot avec une version plus ancienne d'installé. Nous allons voir comment la remplacer par la nouvelle version. \\ 
Le but est donc de remplacer le programme de démarrage actuel qui est en mémoire flash, par le nouveau que nous venons de compiler. Sa position finale sera à l'adresse 0x1000 0000 qui est le début de la moire flash((voir [[Linux embarque:Informations sur la carte CPUAT91#Plan mémoire]])). Cela se fait en plusieurs étapes; comme suit :
  - communiquer avec la carte CPUAT91 ;
  - télécharger le fichier binaire //u-boot.bin// en mémoire vive ;
  - transférer le bloc de mémoire vive correspondant au fichier u-boot.bin dans la mémoire flash ;
  - redémarrer la carte.

==== Communiquer par le câble série ====

Maintenant, il faut se connecter à la carte par le câble série relié au connecteur nommé //UART BDG// sur la carte d'extesion. On lance un programme de console série, tel que //kermit//. Voir les conseils sur l'installation de //kermit// et sa configuration adaptée à notre cas((Installation de Kermit, non mis en ligne actuellement)). D'après Denx, il se peut que le programme //minicom// crée des problèmes. Il n'est pas recommandé de l'utiliser.\\ 
<code>$ kermit -c
Connecting to /dev/ttyS0, speed 115200 
 Escape character: Ctrl-\ (ASCII 28, FS): enabled 
Type the escape character followed by C to get back, 
or followed by ? to see other options. 
----------------------------------------------------
</code>
Pour communiquer avec la carte, il faut appuyer sur le bouton //RST// afin de la redémarrer. Juste après, taper la touche //espace// pour éviter qu'elle n'essaie de charger un noyau Linux. Nous sommes maintenant dans l'environnement de U-Boot.
<code>U-Boot 1.2.0 (May 13 2008 - 00:19:45) 

DRAM:  32 MB 
Flash:  8 MB 
In:    serial 
Out:   serial 
Err:   serial 
Press SPACE to abort autoboot in 1 seconds 
CPUAT91=> 
</code>
En tappant simplement //?//, nous pouvons afficher la liste des commandes disponibles dans la configuration installée sur la carte.
<code>CPUAT91=> ? 
?       - alias for 'help' 
autoscr - run script from memory 
base    - print or set address offset 
boot    - boot default, i.e., run 'bootcmd' 
bootd   - boot default, i.e., run 'bootcmd' 
bootm   - boot application image from memory 
bootp	- boot image via network using BootP/TFTP protocol 
cmp     - memory compare 
coninfo - print console devices and information 
cp      - memory copy 
crc32   - checksum calculation 
dcache  - enable or disable data cache 
echo    - echo args to console 
eeprom  - EEPROM sub-system 
erase   - erase FLASH memory 
flinfo  - print FLASH memory information 
go      - start application at address 'addr' 
help    - print online help 
icache  - enable or disable instruction cache 
icrc32  - checksum calculation 
iloop   - infinite loop on address range 
imd     - i2c memory display 
imls    - list all images found in flash 
imm     - i2c memory modify (auto-incrementing) 
imw     - memory write (fill) 
inm     - memory modify (constant address) 
iprobe  - probe to discover valid I2C chip addresses 
itest	- return true/false on integer compare 
loadb   - load binary file over serial line (kermit mode) 
loady   - load binary file over serial line (ymodem mode) 
loop    - infinite loop on address range 
md      - memory display 
mii     - MII utility commands 
mm      - memory modify (auto-incrementing) 
mtest   - simple RAM test 
mw      - memory write (fill) 
nfs	- boot image via network using NFS protocol 
nm      - memory modify (constant address) 
ping	- send ICMP ECHO_REQUEST to network host 
printenv- print environment variables 
protect - enable or disable FLASH write protection 
rarpboot- boot image via network using RARP/TFTP protocol 
reset   - Perform RESET of the CPU 
run     - run commands in an environment variable 
saveenv - save environment variables to persistent storage 
setenv  - set environment variables 
tftpboot- boot image via network using TFTP protocol 
usb     - USB sub-system 
usbboot - boot from USB device 
version - print monitor version 
CPUAT91=> 
</code>

==== Téléchargement du fichier u-boot.bin en mémoire vive ====

Nous allons maintenant placer le code binaire contenu dans //u-boot.bin// dans la mémoire vive. Celle-ci commence à l'adresse 0x2000 0000. Par sécurité, et pour éviter d'écraser les variables en mémoire vive, nous transfèrerons le fichier à l'adresse 0x2100 0000.\\ 
Dans la console série, taper : \\ 
<code>CPUAT91=> loadb 21000000 
## Ready for binary (kermit) download to 0x21000000 at 115200 bps...
</code>
Ici, on va revenir à l'interface de Kermit, par la combinaison de touches //Ctrl//, //\// et //c// \\ 
<code>(Back at ...) 
---------------------------------------------------- 
C-Kermit 8.0.211, 10 Apr 2004, for Linux 
 Copyright (C) 1985, 2004, 
  Trustees of Columbia University in the City of New York. 
Type ? or HELP for help. 
(...) C-Kermit> 
</code>
Ensuite, nous initions le transfert du fuchier :\\ 
<code>(...) C-Kermit>send </répertoire/d/installation/de/u-boot>/CPUAT91/u-boot.bin
C-Kermit 8.0.211, 10 Apr 2004, <nom_de_machine> 

   Current Directory: </répertoire/d/installation/de/u-boot>/CPUAT91
Communication Device: /dev/ttyS0 
 Communication Speed: 115200 
              Parity: none 
         RTT/Timeout: 01 / 02 
             SENDING: </répertoire/d/installation/de/u-boot>/CPUAT91/u-boot.bin => u-boot.bin 
           File Type: BINARY 
           File Size: 108344 
        Percent Done: 80  //////////////////////////////////////// 
                          ...10...20...30...40...50...60...70...80...90..100 
 Estimated Time Left: 00:00:03 
  Transfer Rate, CPS: 7769 
        Window Slots: 1 of 1 
         Packet Type: D 
        Packet Count: 129 
       Packet Length: 999 
         Error Count: 0 
          Last Error: 
        Last Message:
</code>
Maintenant, revenons à la console série :
<code>(...) C-Kermit>connect 
Connecting to /dev/ttyS0, speed 115200 
 Escape character: Ctrl-\ (ASCII 28, FS): enabled 
Type the escape character followed by C to get back, 
or followed by ? to see other options. 
---------------------------------------------------- 
## Total Size      = 0x0001a738 = 108344 Bytes 
## Start Addr      = 0x21000000 
CPUAT91=>
</code>
Le fichier semble bien transféré. Une variable vient de se remplir avec le nombre d'octets transférés pour ce fichier : //filesize//. Pour l'afficher, taper :\\ 
<code>CPUAT91=> echo ${filesize} 
1A738
CPUAT91=>
</code>
La valeur 0x1A738 correspond bien aux 108344 octets contenus dans le fichier //u-boot.bin//.

==== Copie du programme en mémoire flash ====

Il faut à présent déprotéger le secteur de mémoire flash que nous désirons utiliser : 128 ko (0x20 000) à partir de l'adresse 0x1000 0000. Pour cela taper :\\ 
<code>CPUAT91=> protect off 10000000 1001FFFF 
. done 
Un-Protected 1 sectors 
CPUAT91=>
</code>
Il est nécessaire d'effacer cette zone mémoire avant d'y écrire dedans :\\ 
<code>CPUAT91=> erase 10000000 1001FFFF 

. done 
Erased 1 sectors 
CPUAT91=>
</code>
Il nous faut alors copier le contenu de la mémoire vive ou se situe le fichier //u-boot.bin// dans la zone mémoire flash préparée. Attention, il est nécessaire de préciser la taille de données à transférer :\\ 
<code>CPUAT91=> cp.b 21000000 10000000 ${filesize} 
Copy to Flash... done 
CPUAT91=> 
</code>
Enfin, reprotégeons la zone mémoire flash écrite :\\ 
<code>CPUAT91=> protect on 10000000 1001FFFF 
. done 
Protected 1 sectors 
CPUAT91=>
</code>

==== Redémarrage ====

Afin de vérifier que tout s'est bien passé, effectuons une remise à zéro du processeur (ne pas oublier de taper sur la touche //espace// pour arrêter le chargement d'un noyau) :\\ 
<code>CPUAT91=> reset 

U-Boot 2009.03-00005-gc38dfba-dirty (mai 25 2009 - 14:40:27) 

I2C:   ready 
DRAM:  32 MB 
Flash:  8 MB 
In:    serial 
Out:   serial 
Err:   serial 
Press SPACE to abort autoboot in 1 seconds 
CPUAT91=> 
</code>

==== Variables d'environnement en mémoire flash ====
Comme nous pourrons le voir dans la configuration telle que décrite dans le chapitre [[Programme de chargement initial#Quelques définitions dans "cpuat91.h" et "Makefile"]], les valeurs par défaut des variables d'environnement sont stockées en mémoire flash, dans un secteur autre que celui où se situe le programme u-boot((voir [[Linux embarque:Informations sur la carte CPUAT91#Plan mémoire]]))). Cela assure en cas de problème sur le programme, que ces valeurs spécifiques au module ne soient pas perdues. Par contre, si l'on désire utiliser les valeurs définies dans le programme, il faudra les y effacer puis les y remettre.\\ 
Il faut à présent déprotéger le secteur de mémoire flash que nous désirons utiliser : 128 ko (0x20 000) à partir de l'adresse 0x1002 0000. Pour cela taper :\\ 
<code>CPUAT91=> protect off 10020000 1002FFFF 
. done 
Un-Protected 1 sectors 
CPUAT91=>
</code>
On efface cette zone mémoire :\\ 
<code>CPUAT91=> erase 10020000 1003FFFF 

. done 
Erased 1 sectors 
CPUAT91=>
</code>
Reprotégeons la zone mémoire flash écrite :\\ 
<code>CPUAT91=> protect on 10020000 1003FFFF 
. done 
Protected 1 sectors 
CPUAT91=>
</code>
Re-démarrons le module et testons les variables d'environnement :\\
<code>CPUAT91=> reset
U-Boot 2009.03-00005-gc38dfba-dirty (mai 27 2009 - 13:52:33) 

I2C:   ready 
DRAM:  32 MB 
Flash:  8 MB 
*** Warning - bad CRC, using default environment 

In:    serial 
Out:   serial 
Err:   serial 
Press SPACE to abort autoboot in 1 seconds 
CPUAT91=> printenv 
bootargs=root=/dev/mtdblock2 rootfstype=jffs2 console=ttyS0,115200 mtdparts=physmap-flash.0:256k(u-boot),1408k(kernel),-(rootfs) mem=32M 
bootcmd=bootm 10040000 
bootdelay=1 
baudrate=115200 
ethaddr=46:8c:1b:1a:47:96
ipaddr=193.52.184.50 
serverip=193.52.184.195 
flub=tftp 21000000 u-boot_cpuat91.bin; protect off 10000000 1001FFFF; erase 10000000 1001FFFF; cp.b 21000000 10000000 ${filesize} 
flui=tftp 21000000 uImage_cpuat91; protect off 10040000 1019ffff; erase 10040000 1019ffff; cp.b 21000000 10040000 ${filesize} 
flrfs=tftp 21000000 rootfs_cpuat91.jffs2; protect off 101a0000 10ffffff; erase 101a0000 10ffffff; cp.b 21000000 101A0000 ${filesize} 
loadaddr=0x21000000 
stdin=serial 
stdout=serial 
stderr=serial 
ver=U-Boot 2009.03-00005-gc38dfba-dirty (mai 29 2009 - 13:33:45) 

Environment size: 774/131068 bytes
</code>
Enfin, sauvons les variables d'environnement en flash puis re-démarrons le module. \\ 
<code>CPUAT91=> saveenv 
Saving Environment to Flash... 
. done 
Un-Protected 1 sectors 
Erasing Flash... 
. done 
Erased 1 sectors 
Writing to Flash... done 
. done 
Protected 1 sectors 
CPUAT91=> reset 

U-Boot 2009.03-00005-gc38dfba-dirty (mai 29 2009 - 13:33:45) 

I2C:   ready 
DRAM:  32 MB 
Flash:  8 MB 
In:    serial 
Out:   serial 
Err:   serial 
Press SPACE to abort autoboot in 1 seconds
</code>
Normalement, nous devrions retrouver toutes les variables d'environnement comme définies dans le programme u-boot.

===== Copier un fichier dans la SDRAM par TFTP =====

TFTP (pour Trivial File Transfert Protocol) est un protocole simplifié de transfert de fichiers par le réseau. Pour l'installation, voir le chapitre à ce sujet((Installation de TFTP, non mis en ligne actuellement, se référer au site [[http://www.davidsudjiman.info/2006/03/27/installing-and-setting-tftpd-in-ubuntu/]])).\\ 
Par exemple, nous souhaitons maintenant transférer un fichier de test en mémoire vive.\\ 
Sur la machine servant de serveur //tftp//, créer ou copier le fichier à transférer dans la répertoire d'échange (peut varier en fonction de la configuration, voir le chapitre sur l'installation((Installation de TFTP, non mis en ligne actuellement, se référer au site [[http://www.davidsudjiman.info/2006/03/27/installing-and-setting-tftpd-in-ubuntu/]]))). Cas de la création d'un fichier de test :\\ 
<code>$ cd /tftpboot/
$ vim test3.txt
[insert]
BONJOUR TOUT LE MONDE
[esc]
[:wq]
</code>
changer les droits d'accès au fichier créé :
<code>$ chmod 777 test3.txt</code>
Maintenant, sur le module où U-Boot est installé, vérifier que nous avons la bonne adresse IP pour le serveur TFTP, la changer au besoin, récupérer le fichier en mémoire vive à l'adresse 0x21000000 et vérifier la présence des bonnes données : \\ 
<code>CPUAT91=> printenv serverip 
serverip=193.52.184.195
------
</code>
Si besoin : changer l'adresse IP du serveur tftp et la sauver s'il est nécessaire de la conserver à la prochaine RAZ : \\ 
<code>CPUAT91=> setenv serverip xxx.xxx.xxx.xxx
CPUAT91=> saveenv
------
<code>
Copier le fichier en mémoire vive :\\ 
<code>CPUAT91=> tftp 21000000 test3.txt 
Micrel KS8721 PHY detected : 100BT FD 
TFTP from server 193.52.184.195; our IP address is 193.52.184.50 
Filename 'test3.txt'. 
Load address: 0x21000000 
Loading: # 
done 
Bytes transferred = 22 (16 hex) 
CPUAT91=> md 21000000 
21000000: 4a4e4f42 2052554f 54554f54 20454c20    BONJOUR TOUT LE 
21000010: 444e4f4d e59f0a45 e59ff014 e59ff014    MONDE...........
...
</code>
Le fichier a bien été transféré.

===== Quelques définitions dans "cpuat91.h" et "Makefile" =====

Afin d'adapter certaines variables spécifiques aux besoins que nous avons, nous pouvons reprendre quelques déclarations inclues dans le fichier //cpuat91.h// qui se situe dans le répertoire ///chemin/d/installation/de/u-boot/include/configs/cpuat91//, ainsi que dans le fichier //Makefile// qui est dans le répertoire ///chemin/d/installation/de/u-boot// de U-Boot. \\ 
La plus part de ces déclarations sont faite dans le fichier //cpuat91.h//. Dans ce qui suit, si aucune indication particulière n'est donnée, ce sera donc dans ce fichier que nous trouverons la définition. \\ 
L'utilisation de //#define// permet de définir une variable et l'utilisation de //#undef// annule cette variable. \\ 
Il y a deux classes de variables de configuration : \\
  * Configuration _OPTIONS_: \\ Leurs noms commencent avec "CONFIG_" et elles sont modifiables par l'utilisateur.
  * Configuration _SETTINGS_: \\ Leurs noms commencent avec "CONFIG_SYS" et elles dépendent en particulier du matériel de la carte. Il n'est pas conseillé de les modifier pour une utilisation classique et sûre.

Ici, nous ne parlerons que des options de configurations car elles influerons sur l'utilisation de la carte, et non pas sur les paramètres matériels des composants. Nous pourrons voir certaines variables système, mais à des fins d'explications. Ces dernières ne doivent pas être modifiées.

=== Interface de la console : ===

Sélection du port série : \\ <code>#define CONFIG_DBGU</code> -> définit (port série utilisé pour communiquer avec la catre)
<code>#undef CONFIG_USART0</code> -> définition annulée
<code>#undef CONFIG_USART1</code> -> définition annulée


Autre \\ <code>#undef CONFIG_SILENT_CONSOLE</code> Quand ce paramètre est définit, tous les messages de la console (par U-Boot et linux) peuvent être tus avec la variable d'environnement //silent//. Voir le fichier //doc/README.silent// pour plus d'informations. Ici, ce ne sera pas le cas car cette variable est exclue.

=== Rapidité de la console : ===

<code>#define CONFIG_BAUDRATE 115200</code> Cette variable permet de configurer la vitesse de transmission de la console série. La vitesse doit être choisie parmi les valeurs définies par la variable système : <code>CONFIG_SYS_BAUDRATE_TABLE 	{ 115200, 19200, 38400, 57600, 9600 }</code>

=== Attente de démarrage : ===

La variable //CONFIG_BOOTDELAY// qui se trouve définie dans le fichier //Makefile//, exprimée en secondes, permet de retarder le démarrage automatique de l'image par défaut. Mise à -1, elle annule le démarrage automatique.\\ 
Les variables suivantes sont initialisées pour configurer le comportement au moment de l'attente de démarrage. La documentation se trouve dans le fichier //README.autoboot// du répertoire //doc///.\\ 
<code>#define CONFIG_AUTOBOOT_KEYED </code>
Indique que certaines options particulières sont activées durant l'attente de démarrage. \\ 
<code>#define CONFIG_AUTOBOOT_PROMPT "Press SPACE to abort autoboot in %d seconds\n",bootdelay</code>
Message affiché avant que le délai de démarrage //CONFIG_BOOTDELAY// ne soit appliqué. Si ce message n'est pas définit, rien ne s'affichera pour indiquer que //autoboot// est en fonction. \\ 
La variable //bootdelay// est une variable d'environnement fixée par la variable //CONFIG_BOOTDELAY//. \\ 
<code>#define CONFIG_AUTOBOOT_STOP_STR " "</code>
Définit une chaine de caractères à recevoir depuis la console pour interrompre l'autoboot. Si cette chaîne est reçue, la ligne de commande sera disponible et le restera.\\ 

<code>#define CONFIG_AUTOBOOT_DELAY_STR "d"</code>
Définit la chaine de caractères à recevoir depuis la console pour interrompre l'autoboot. Si cette chaîne est reçue, la ligne de commande sera disponible mais l'autboot pourra reprendre au cas où la variable //CONFIG_BOOT_RETRY_TIME// est définie (ce qui ne semble pas être le cas ici).

=== Commandes de l'autoboot : ===

<code>#define CONFIG_BOOTCOMMAND  "bootm 10040000"   /* autoboot command */</code>
Cette variable définit une chaîne de caractères qui est exécutée automatiquement quand aucun caractère n'est lu sur la console avant la fin de l'attente de démarrage, si ce délai a été défini. Elle définit le contenu de la variable d'environnement //bootcmd//. \\ 
Ici, on utilise la commande //bootm// qui démarrera une application qui est stockée en mémoire à l'adresse 0x1004000.

<code>#define CONFIG_BOOTARGS     "root=/dev/mtdblock2 rootfstype=jffs2 console=ttyS0,115200 mtdparts=physmap-flash.0:256k(u-boot),1408k(kernel),-(rootfs) mem=32M"   /* the boot command will set bootargs */ </code>
Cette variable définit une chaîne de caractères qui est utilisée comme argument lors de l'appel de la commande //bootm//. Elle définit le contenu de la variable d'environnement //bootargs//.

=== Fonctions du moniteur : ===

Voir les explications du fichier //README// dans le répertoire racine de l'installation de U-Boot.

=== Version de U-Boot : ===

<code>#define CONFIG_VERSION_VARIABLE	1</code>
Cette variable étant définie, une variable d'environnement //ver// va être initialisée et contiendra la version de U-Boot. Elle est visualisable par la commande //version// de la ligne de commande.

=== Support du Timestamp (horodatage) : ===

<code>#define CONFIG_TIMESTAMP</code>
Cette définition est mise avec les fonctions du moniteur dans ce fichier. Si défini, ce paramètre affiche la datation (date et heure) d'une image par l'appel d'une commande d'image telle que //bootm// ou //iminfo//.

=== Support de partitions : ===

<code>#define CONFIG_DOS_PARTITION	1 </code>
Si défini, ce paramètre indique le support du type de partition //DOS//.

=== Support de l'USB : ===

<code>#define CONFIG_USB_OHCI	1</code>
Si défini, ce paramètre indique le support de contrôleurs USB //OHCI//.
<code>#define CONFIG_USB_STORAGE	1</code>
Si défini, ce paramètre indique le support des périphériques USB de stockage.

=== Adresse Ethernet : ===

<code>#define CONFIG_ETHADDR 46:8c:1b:1a:47:96</code>
Si définie, cette variable contient une valeur par défaut de l'adresse Ethernet (ou MAC) à utiliser au cas où elle n'est pas déterminée automatiquement. Cette définition affecte la valeur de la variable d'environnement //ethaddr//. \\ 
<box round red | **Remarque** > Notre carte ne dispose d'adresse MAC configurée par défaut. Il est nécessaire de lui en attribuer une. Obtenir une adresse MAC officielle est hors de propos dans ce document. U-Boot dispose d'un outil permettant de générer des adresses MAC temporaires. Les sources de cet outil se trouvent dans le répertoire //tools// sous le nom de //gen_eth_addr//. Avant de l'utiliser, il faut le compiler. Par exemple, ou procéder ainsi : \\ 
<code>$ cd <répertoire_racine_u-boot>/tools
$ gcc -o /tmp/gen_eth_addr gen_eth_addr.c
$ /tmp/gen_eth_addr
0a:03:4a:c6:f3:a2 </code>
Il est possible alors d'utiliser cette adresse pour la variable d'environnement //ethaddr//.
</box>

=== Adresse IP : ===

<code>#define CONFIG_IPADDR 193.52.184.50</code>
Cette variable définit l'adresse IP à utiliser pour l'interface Ethernet par défaut. Elle définit la valeur de la variable d'environnement //ipaddr// qui est nécessaire pour la commande //tftpboot//.

=== Adresse IP du serveur : ===

<code>#define CONFIG_SERVERIP     193.52.184.195</code>
Cette variable définit la valeur par défaut de l'adresse IP pour le serveur TFTP à contacter lorsque la commande //tftpboot// est utilisée. Elle définit la valeur de la variable d'environnement //serverip//.

=== Support de l'I2C : ===

<code>#define CONFIG_HARD_I2C</code>
Si défini, ce paramètre sélectionne un contrôleur I2C matériel et active les commandes I2C en incluant le pilote approprié au CPU. Les commandes I2C seront utilisables en ligne de commande car la définition CONFIG_CMD_I2C existe (dans les fonctions du moniteur). Voir le fichier //common/cmd_i2c.c// pour une description de l'interface en ligne de commande.\\ 
//CONFIG_I2C_CMD_TREE// est une option recommandée qui place toutes les commandes I2C sous une seule commande racine //i2c//.  Elle n'est pas utilisée dans ce fichier.
<code>#define CONFIG_SYS_I2C_SPEED		0	/* not used */</code>
Cette définition est nécessaire pour le support de l'I2C. Elle fixe la fréquence en Hz à laquelle vous souhaitez que votre bus I2C fonctionne. Il semble que la fréquence n'a pas d'importance dans le cas de cette carte.
<code>#define CONFIG_SYS_I2C_SLAVE		0	/* not used */</code>
Cette définition est nécessaire pour le support de l'I2C. Elle définit l'adresse de ce noeud. Il semble que cette adresse n'a pas d'importance dans le cas de cette carte.

=== Récupération d'erreur : ===

<code>#define CONFIG_NET_RETRY_COUNT	20</code>
Si défini, ce paramètre définit le nombre de tentatives des opérations réseau, avant l'abandon. Si non défini, la valeur par défaut est 5.

=== Environnement par défaut : ===

<code>#define CONFIG_EXTRA_ENV_SETTINGS	\ 
	"flub=tftp 21000000 u-boot_cpuat91.bin; protect off 10000000 1001FFFF; " \ 
		"erase 10000000 1001FFFF; cp.b 21000000 10000000 ${filesize}\0" \ 
	"flui=tftp 21000000 uImage_cpuat91; protect off 10040000 1019ffff; erase " \ 
		"10040000 1019ffff; cp.b 21000000 10040000 ${filesize}\0" \ 
	"flrfs=tftp 21000000 rootfs_cpuat91.jffs2; protect off 101a0000 10ffffff; " \ 
		"erase 101a0000 10ffffff; cp.b 21000000 101A0000 ${filesize}\0" \ 
	"loadaddr=0x21000000\0"</code>
Cette définition existe dans ce fichier. Si défini, ce paramètre contient n'importe quel nombre de chaines de caractères à zéro terminal (utilise des paires //variable = valeur//) qui fera parti de l'environnement compilé par défaut dans l'image //boot//.


<box round red | **Attention** > Cette méthode est basée sur la connaissance concernant le format interne de la façon dont le code U-Boot stocke l'environnement. Ceci n'est pas une interface exportée officielle. Quoiqu'il y ai peu de chances que ce format change bientôt, il n'y a aucune garantie. Vous devez bien savoir ce que vous faites.\\ 
**NOTE :** trop d'usage de l'environnement par défaut n'est pas encouragé. Assurez vous d'avoir utilisé les autres moyens pour initialiser l'environnement comme la fonction d'autoscript ou la première commande boot.</box>

=== Support de modem : ===

<code>#undef CONFIG_MODEM_SUPPORT		/* disable modem initialization stuff */</code>
Ce paramètre étant exclu, il désactive le support pour les modems.
<code>#undef CONFIG_HWFLOW			/* don't include RTS/CTS flow control support	*/</code>
Ce paramètre étant exclu, il désactive les contrôles par les signaux RTS/CTS.

=== Initialisations de configuration : ===

<code>#undef CONFIG_SYS_LONGHELP </code>
Ce paramètre étant exclu, il désactive l'affichage de messages longs. Ceci est utile lorsqu'il y peu de mémoire disponible.
<code>#define CONFIG_SYS_PROMPT "CPUAT91=> "		/* Monitor Command Prompt */ </code>

=== Remarques sur les variables d'environnement : ===
<box round red>Il est à noter que, dans notre cas, les variables d'environnement sont stockées dans un autre secteur de la mémoire flash que le programme u-boot. Une fois le démarrage de U-Boot effectué, une copie de ces variables sont placées en mémoire vive. De ce fait, lorsque l'on copie l'image du programme u-boot dans la mémoire flash puis qu'il est exécuté, les variables d'environnement n'ont pas les valeurs définies dans le programme, mais celles qui sont restées dans le secteur où elles sont stockées. Pour revenir aux valeurs définies dans le programme, il faudra d'abord effacer le secteur de mémoire flash où les valeurs par défaut se trouvent, puis redémarrer le module et enfin re-enregistrer les variables dans la mémoire flash. Nous voyons comment faire dans le chapitre [[Programme de chargement initial#Variables d'environnement en mémoire flash]].</box>

===== Fichiers images =====

U-Boot utilise un format spécial d'image quand il charge soit l'image du noyau Linux, soit l'image du ramdisk ou encore d'autres images. Cette image contient entre autres de l'information sur la date de création, le système d'exploitation, le type de compression, le type d'image, le nom de l'image et les sommes de tests CRC32.\\ 
L'outil //mkimage// est utilisé pour créer ce type d'image ou pour afficher les informations qu'elle contient.
Quand on exécute la commande //make all//, ceci construit également l'outil //mkimage// (dans le répertoire //<cible>/tools///) qui est nécessaire pour créer une image au format utilisé par U-Boot.\\ 
Il est recommandé que vous copiez ce fichier dans un des répertoires contenu dans la variable PATH, par exemple dans le répertoire avec tous les autres outils de compilation croisée : // /répertoire/d/installation/de/eldk/usr/bin //dans notre cas.
<code>:$ cp </répertoire/d/installation/d/u-boot>/CPUAT91/tools/mkimage </répertoire/d/installation/de/eldk/usr/bin/></code>