Sommaire

Introduction

Définition de quelques termes

Informations sur le système

Nos outils : JTAG ICEBear et logiciels de Section5

Première application: faire clignoter une DEL!

U-Boot et outils associés

Utiliser U-Boot sur votre Blackfin

Sommaire de mon expérience

Annexe A: Sources

Annexe B: Documentation et liens

Annexe C: Remerciements

Version 1.1 de l’article et du document, en date du 21 août 2009.

Introduction

Le présent document explique comment j’ai porté U-Boot sur un Blackfin BF532 en utilisant un JTAG ICEBear et une machine virtuelle sous Ubuntu 9.04. Les informations contenues dans ce texte ne sont en aucun cas exclusives ou totalement nouvelles, tout comme je ne suis pas un guru Linux et un maître Blackfin. Le but est plutôt de simplifier la tâche à quelqu’un qui aurait à suivre un parcours similaire au mien et à regrouper les informations et les techniques que j’ai apprises en consultant divers sites, en expérimentant et en posant beaucoup de questions.

Initialement, mon développement s’est fait sous une machine Debian Etch 4.0 (sous VMWare Player) afin d’être le plus semblable possible au système de développement de Section5. Afin de rendre le tout plus accessible, j’ai reproduit ma démarche sous Ubuntu 9.04 et VirtualBox et j’ai consigné toutes mes étapes dans ce document. Les utilisateurs expérimentés de Linux me trouveront probablement redondant, mais je préfère fournir trop d’informations plutôt que pas assez. Vous y verrez d’ailleurs mes erreurs et la manière dont je m’en suis sorti. Je préfère expliquer le cheminement complet plutôt que simplement la solution finale afin d’aider un maximum de personnes à progresser plus rapidement.

Définition de quelques termes

Section5 : Petite compagnie Suisse qui produit et vend certains outils de développement pour Blackfin. Site web : http://section5.ch/ (plus précisément : http://section5.ch/embedded). Le responsable est Martin Strubel et peut être contacté par leur forum ou par email : strubel-@-section5-.-ch.

ICEBear : Adaptateur JTAG de Section5.

BFLoader : Utilitaire permettant de programmer la Flash d’une carte Blackfin (fourni par Section5, sources disponibles).

GDBProxy+Insight : Outils de débogage du Blackfin. Utilisés avec le ICEBear, ils permettent la programmation et le débogage (step-by-step, break point, register dump, etc.) Note : il est important d’utiliser la version disponible sur le site de Section5 et non celle de µCLinux si on veut une compatibilité avec le ICEBear !

Gigamodule : Carte électronique développée par l’équipe [Robot22], un groupe de finissants de Génie Électrique et Informatique de l’Université de Sherbrooke et moi. Le Gigamodule v0.1 est simplement composé d’un Blackfin BF532, d’une RAM parallèle (MT48LC32M16A2, 512Mb), d’une Flash SPI (AT45DB321, 32Mb), d’un convertisseur série USB (FT232) et de quelques périphériques et connecteurs. Elle sert de prototype à un système plus complexe de bus de communication haute-vitesse.

Informations sur le système

PC utilisé pour mon développement :

• Intel Core2Duo T5850 @ 2.16GHz
• 4.00GB RAM
• Windows Vista 64bits

Version des outils :

• U-Boot : 1.1.6-2008R1.5
• BFLoader : 1.3beta
• VirtualBox 3.0.4
• Ubuntu 9.04 32bits

Une machine virtuelle a été créée avec VirtualBox 3.0.4 et Ubuntu 9.04 32bits y a été installé. Toutes les informations présentes dans ce document se basent sur ce système.

Il est préférable de travailler comme root pour éviter les problèmes de permissions. Vous pouvez remarquer par le prompt quand je suis root ou pas ($ = user, # = root). Si vous travaillez comme user, il suffit de mettre sudo devant les commandes importantes.

jfduval@jfduval-desktop:~$ su Password: root@jfduval-desktop:/home/jfduval#

Note : Pour les utilisateurs de VirtualBox et d’Ubuntu, si la résolution de votre écran ne vous satisfait pas vous pouvez consulter ce site afin de régler le problème : http://www.linuxformat.co.uk/forums/viewtopic.php ?t=6438.

Nos outils : JTAG ICEBear et logiciels de Section5

C’est avec le JTAG ICEBear que nous allons pouvoir transférer notre code compilé dans la mémoire du Blackfin. La présente section explique l’installation des outils, le test et la modification de ces outils.

Installation des logiciels

Afin de pouvoir utiliser apt-get install pour télécharger et installer les paquets fournis par Section5, il faut modifier /etc/apt/sources.list :

jfduval@jfduval-desktop:/etc/apt$ cd /etc/apt/ jfduval@jfduval-desktop:/etc/apt$ ls apt.conf.d sources.list sources.list.d trusted.gpg secring.gpg sources.list~ trustdb.gpg trusted.gpg~ jfduval@jfduval-desktop:/etc/apt$ sudo gedit sources.list

On lui ajoute en bas du fichier la ligne suivante :

deb http://www.section5.ch/debian etch main non-free

On sauvegarde et ferme. On met à jour la liste des sources disponibles :

jfduval@jfduval-desktop:/etc/apt$ apt-get update

On peut maintenant installer la suite ICEBear :

jfduval@jfduval-desktop:~$ sudo apt-get install icebear-gdbproxy Reading package lists... Done Building dependency tree Reading state information... Done Some packages could not be installed. This may mean that you have requested an impossible situation or if you are using the unstable distribution that some required packages have not yet been created or been moved out of Incoming. The following information may help resolve the situation: The following packages have unmet dependencies: icebear-gdbproxy: Depends: libbfemu but it is not going to be installed Depends: libftdi0 (>= 0.7) but it is not installable Depends: libbfemu (>= 1.2) but it is not going to be installed E: Broken packages jfduval@jfduval-desktop:~$

Certaines dépendances ne sont pas résolues, on tente de corriger ça :

jfduval@jfduval-desktop:~$ sudo apt-get install libbfemu Reading package lists... Done Building dependency tree Reading state information... Done Some packages could not be installed. This may mean that you have requested an impossible situation or if you are using the unstable distribution that some required packages have not yet been created or been moved out of Incoming. The following information may help resolve the situation: The following packages have unmet dependencies: libbfemu: Depends: libftdi0 (>= 0.7) but it is not installable E: Broken packages jfduval@jfduval-desktop:~$ sudo apt-get install libftdi0 Reading package lists... Done Building dependency tree Reading state information... Done Package libftdi0 is not available, but is referred to by another package. This may mean that the package is missing, has been obsoleted, or is only available from another source E: Package libftdi0 has no installation candidate

Alors, la solution est d’aller télécharger directement le package libftdi0 sur un serveur Debian. On va à l’adresse suivante : http://packages.debian.org/etch/i386/libftdi0/download On double clique ensuite sur le .deb et on installe (tout se fait en GUI).

Ensuite, libbfemu s’installe correctement :

jfduval@jfduval-desktop:~/Desktop/libftdi-0.16$ sudo apt-get install libbfemu Reading package lists... Done Building dependency tree Reading state information... Done The following packages were automatically installed and are no longer required: linux-headers-2.6.28-11 linux-headers-2.6.28-11-generic Use 'apt-get autoremove' to remove them. The following NEW packages will be installed: libbfemu 0 upgraded, 1 newly installed, 0 to remove and 0 not upgraded. Need to get 62.2kB of archives. After this operation, 225kB of additional disk space will be used. WARNING: The following packages cannot be authenticated! libbfemu Install these packages without verification [y/N]? y Get:1 http://www.section5.ch etch/non-free libbfemu 1.3-2 [62.2kB] Fetched 62.2kB in 1s (41.2kB/s) Selecting previously deselected package libbfemu. (Reading database ... 121361 files and directories currently installed.) Unpacking libbfemu (from .../libbfemu_1.3-2_i386.deb) ... Setting up libbfemu (1.3-2) ... * Stopping kernel event manager... [ OK ] * Starting kernel event manager... [ OK ] Processing triggers for libc6 ... ldconfig deferred processing now taking place jfduval@jfduval-desktop:~/Desktop/libftdi-0.16$

Deuxième tentative d’installation de la suite ICEBear :

jfduval@jfduval-desktop:~/Desktop/libftdi-0.16$ sudo apt-get install icebear-gdbproxy Reading package lists... Done Building dependency tree Reading state information... Done The following packages were automatically installed and are no longer required: linux-headers-2.6.28-11 linux-headers-2.6.28-11-generic Use 'apt-get autoremove' to remove them. The following NEW packages will be installed: icebear-gdbproxy 0 upgraded, 1 newly installed, 0 to remove and 0 not upgraded. Need to get 38.4kB of archives. After this operation, 143kB of additional disk space will be used. WARNING: The following packages cannot be authenticated! icebear-gdbproxy Install these packages without verification [y/N]? y Get:1 http://www.section5.ch etch/non-free icebear-gdbproxy 0.8-5 [38.4kB] Fetched 38.4kB in 0s (41.1kB/s) Selecting previously deselected package icebear-gdbproxy. (Reading database ... 121368 files and directories currently installed.) Unpacking icebear-gdbproxy (from .../icebear-gdbproxy_0.8-5_i386.deb) ... Processing triggers for man-db ... Setting up icebear-gdbproxy (0.8-5) ... jfduval@jfduval-desktop:~/Desktop/libftdi-0.16$

On peut maintenant installer les autres packages : bfinsight, bfloader, bfin-elf-toolchain, libbfemu-dev. On utilise toujours la même commande sudo apt-get install nom_du_paquet.

Note : pour éliminer le message d’erreur d’authentification des sources, se référer à la section B.1 du ICEBear Manual afin de savoir comment installer la clé.

Une fois ces opérations effectuées, nous avons une chaîne complète pour utiliser le JTAG.

Test de la chaîne JTAG

Pour utiliser BFLoader, il suffit de taper la commande flashload. Pour avoir des informations sur la chaîne, il suffit de faire

jfduval@jfduval-desktop:~$ flashload -–info

Si vous obtenez :

Could not claim USB device, check permissions! Could not open ICEbear. Is it connected? Try replugging and make sure no other program is using it

C’est causé par le système udev présent dans les dernières versions de Debian et d’Ubuntu. En se basant sur les informations du ICEBear Manual, on va modifier les accès. Premièrement, on peut télécharger le package ICEBear distribution 1.2 sur http://www.section5.ch/software. Ouvrir l’archive, naviguer jusqu’à /ICEbear-linux-1.21beta/udev/ et extraire le fichier 45-icebear.rules ou aller sur http://www.section5.ch/forum/viewtopic.php ?f=1&t=58&p=169&hilit=ubuntu#p169 et télécharger http://www.section5.ch/dsp/icebear/45-icebear.rules.

On copie ensuite ce fichier dans le bon répertoire :

jfduval@jfduval-desktop:~/Desktop$ sudo mv 45-icebear.rules /etc/udev/rules.d/

et on redémarre le tout :

jfduval@jfduval-desktop:~/Desktop$ sudo /etc/init.d/udev restart * Stopping kernel event manager... [ OK ] * Starting kernel event manager... [ OK ] jfduval@jfduval-desktop:~/Desktop$

Personnellement j’ai encore des messages d’erreur, mais faire sudo avant flashload (ou travailler en root) me permet de bien détecter ma carte, alors tout est fonctionnel ! Une chaîne fonctionnelle devrait vous donner au minimum :

Number of devices in JTAG chain: 1 JTAG wait cycles: 0 Detected Device: BF-533(531,532) rev:5

Le reste des informations n’est peut-être pas pertinent, tout dépendant de votre hardware. Il faut en effet utiliser le bon backend pour que les données affichées soient cohérentes.

Atmel SPI Flash

Normalement, le programme BFLoader permet de charger le fichier .ldr obtenu par la compilation de U-Boot directement dans la Flash, qu’elle soit parallèle (sur le bus mémoire) ou SPI. Par contre, il s’avère que le driver SPI ne supporte que les Flash ST et compatibles, qui utilisent un protocole standard et des pages de 512 octets. Évidemment, afin d’augmenter le défi, la carte Gigamodule dispose d’une Flash Atmel qui utilise le protocole Dataflash (commandes plus évoluées et pages de 528 octets), ce qui rend impossible l’utilisation telle quelle de BFLoader. Le code de BFLoader a été modifié légèrement pour détecter les Flash Atmel. Par contre, refaire complètement le driver n’était pas assez nécessaire pour être fait, il existe d’autres possibilités pour programmer U-Boot dans la Flash que nous explorerons dans les prochaines sections.

Modification de BFLoader

Tel que mentionné dans le précédent paragraphe, il est possible de modifier BFLoader pour lui ajouter certaines fonctionnalités. Dans mon cas, la modification aura été d’ajouter un certain support pour les SPI Flash Atmel. Maintenant, plutôt que de mettre un simple message d’erreur, une AT45DB321D (ou toute autre Flash de la famille AT45DBxxxD) peut être détectée et ses caractéristiques sont affichées. Les informations qui suivent expliquent comment changer le backend spi_flash.dxe pour lui ajouter des fonctions.

Obtenir les sources

La première étape est d’obtenir les sources de BFLoader. On peut les télécharger ici : http://www.section5.ch/dsp/icebear/bfloader-1.3beta.tgz. Il suffit ensuite de faire Extract Here et on obtient un dossier BFLoader. Dans mon cas, son chemin d’accès est /home/jfduval/Desktop/bfloader/.

Compiler les sources

Avant de modifier quoi que ce soit, on va compiler pour s’assurer que tous nos outils soient corrects. Une fois placé dans le répertoire /home/jfduval/Desktop/bfloader/, on nettoie :

jfduval@jfduval-desktop:~$ cd Desktop/bfloader/ jfduval@jfduval-desktop:~/Desktop/bfloader$ make clean

Puis on compile :

jfduval@jfduval-desktop:~/Desktop/bfloader$ make all

En cas d’erreur de compilation avec un message comme de quoi libelf ne peut pas être trouvé, il faut faire (référence : /home/jfduval/Desktop/bfloader/README) :

root@jfduval-desktop:/home/jfduval/Desktop/bfloader# apt-get install libelfg0-dev

Ensuite, il est possible de compiler sans problèmes.

Modifier les sources

Je vais vous expliquer ici comment j’ai modifié quelques fichiers afin de changer facilement le backend spi_flash.dxe. Premièrement, afin de m’assurer que je modifiais bien ma version de BFLoader, j’ai ajouté mon nom dans le string s_version de /home/jfduval/Desktop/bfloader/main.c. Ainsi, je peux confirmer que j’exécute bien les sources que je modifie :

root@jfduval-desktop:/home/jfduval/Desktop/bfloader# ./flashload -–version bfloader/flashloader Version: 1.3beta (c) 2006, 2007 <hackfin@section5.ch>, modified by JFDuval 2009 root@jfduval-desktop:/home/jfduval/Desktop/bfloader#

Notez l’usage de l’opérateur ./ qui me permet de lancer la version locale de flashload et nom celle placée dans /apt/.

Ensuite, on peut modifier le champ AFP_Title de /home/jfduval/Desktop/bfloader/boards/spi_flash/main.c ainsi : *AFP_Title = "SPI flash programmer with limited Atmel support" ; Pour compiler un backend, il suffit de se placer dans son répertoire et de faire make. Il est toujours préférable de faire un make clean préalablement.

On teste :

root@jfduval-desktop:/home/jfduval/Desktop/bfloader#flashload --info –-backend=spi_flash.dxe Number of devices in JTAG chain: 1 JTAG wait cycles: 0 Detected Device: BF-533(531,532) rev:5 ------------------------------------------------------------------- Undetected Manufacturer ------------------------------------------------------------------- Driver title: SPI flash programmer for BF5[2,3]7 boards Description: <undetected> Manufacturer Code: 0xffffffff Device Code: 0xffffffff Number of sectors: 0x0 Bus width: 0x8 Buffer size: 0x4000 Flash size: 0x0 Error: Flash chip unsupported Possibly you are using the wrong loader or the chip is not recognized.

On comprend que la modification n’a pas été prise en compte, le Driver Title n’est pas celui qu’on vient de modifier. L’explication se trouve dans le fichier /home/jfduval/Desktop/bfloader/main.c, vers la ligne 189. Le chemin de recherche des backends pointe vers la « version APT » de BFLoader et non vers notre version modifiée. Il faut donc changer cela par : char prefix[FILESTR_SIZE] = "/home/jfduval/Desktop/bfloader/boards/spi_flash/" ;

Avant de tester, on nettoie (make clean) le répertoire /spi_flash/ et on supprime les exécutables .dxe. Après la compilation (make), on observe que seul bfloader.dxe sera créé dans le dossier. Si vous testez, vous obtiendrez :

root@jfduval-desktop:/home/jfduval/Desktop/bfloader# ./flashload --info –backend=spi_flash.dxe Number of devices in JTAG chain: 1 JTAG wait cycles: 0 Detecting device... Detected Device: BF-533(531,532) rev:5 Could not open file /home/jfduval/Desktop/bfloader/boards/spi_flash/spi_flash.dxe Error initializing Flash Loader

Il existe deux manières de régler ce problème. La première est, après chaque nouvelle compilation, de renommer bfloader.exe par spi_flash.dxe. La seconde manière, plus élégante à mon avis, est d’éditer le fichier /home/jfduval/Desktop/bfloader/bfloader.mk. On remplace :

NAME = bfloader

Par :

ifdef SPI_FLASH NAME = spi_flash else NAME = bfloader endif

Les détails de l’ajout de la détection des Flash Atmel ne seront pas expliqués ici. Si cet ajout vous intéresse, vous pouvez consulter directement ma version de main.c. Voici un exemple fonctionnel :

root@jfduval-desktop:/home/jfduval/Desktop/bfloader# ./flashload --info --backend=spi_flash.dxe --version bfloader/flashloader Version: 1.3beta (c) 2006, 2007 <hackfin@section5.ch>, modified by JFDuval 2009 Number of devices in JTAG chain: 1 JTAG wait cycles: 0 Detecting device... Detected Device: BF-533(531,532) rev:5 ------------------------------------------------------------ ------------------------------------------------------------ Driver title: SPI flash programmer with limited Atmel support Description : AT45DB321D Manufacturer Code: 0x1f Device Code: 0x1 Number of sectors: 0x200 Bus width: 0x8 Buffer size: 0x4000 Flash size: 0x2000000 ------------------------------------------------------------ Verify is on (default).

Première application: faire clignoter une DEL!

L’exemple qui suit se base sur le code Blinky fourni par Section5. Bien que de faire clignoter une DEL puisse sembler très simple, c’est une étape importante à accomplir. En effet, c’est ce qui nous permettra de tester notre hardware et nos outils.

Sources de Blinky et montage électronique

La première étape est évidemment de se procurer les sources de Blinky. Pour cela, il suffit de les télécharger ici : http://www.section5.ch/dsp/blackfin/blinky.tgz. On extraie ensuite le dossier blinky/.

Le montage électronique est très simple. Il suffit de mettre une DEL, avec une résistance de 300 à 500Ω en série, entre la pin PF2 et la masse. Le boot mode est 00 (sur le Gigamodule, les 2 jumpers sont mis en place).

Compiler Blinky

Pour cet exemple, on va compiler Blinky pour une carte Stamp BF533. On commence par se placer dans le bon répertoire :

root@jfduval-desktop:/home/jfduval/Desktop# cd blinky

On nettoie et on compile pour le Stamp :

root@jfduval-desktop:/home/jfduval/Desktop/blinky# make clean root@jfduval-desktop:/home/jfduval/Desktop/blinky# make BOARD=EZKIT_BF533 bfin-elf-gcc -x assembler-with-cpp -D__ADSPLPBLACKFIN__ -I../include -DBOARD_EZKIT_BF533 -g -c -o crt0.o crt0.asm bfin-elf-gcc -x assembler-with-cpp -D__ADSPLPBLACKFIN__ -I../include -DBOARD_EZKIT_BF533 -g -c -o auxiliaries.o auxiliaries.asm bfin-elf-gcc -I../include -g -DBOARD_EZKIT_BF533 -DBLINK_AND_WAIT -D__ADSPLPBLACKFIN__ -c -o main.o main.c In file included from /usr/lib/gcc/bfin-elf/4.1.2/../../../../bfin-elf/include/cdefBF533.h:24, from main.c:18: /usr/lib/gcc/bfin-elf/4.1.2/../../../../bfin-elf/include/cdefBF532.h:34:21: error: ccblkfn.h: No such file or directory make: *** [main.o] Error 1

La compilation a échoué, il manque un fichier ccblkfn.h. En effectuant une recherche de fichiers, on peut localiser le fichier /home/jfduval/Desktop/bfloader/include/ccblkfn.h. On en fait une copie dans le répertoire Include de la suite d’outils :

root@jfduval-desktop:/home/jfduval/Desktop/bfloader/include# cp ccblkfn.h /usr/bfin-elf/include/

On réessaie la compilation :

root@jfduval-desktop:/home/jfduval/Desktop/blinky# make clean rm -f *.o blink.dxe root@jfduval-desktop:/home/jfduval/Desktop/blinky# make BOARD=STAMP_BF533 bfin-elf-gcc -x assembler-with-cpp -D__ADSPLPBLACKFIN__ -I../include -DBOARD_STAMP_BF533 -g -c -o crt0.o crt0.asm bfin-elf-gcc -x assembler-with-cpp -D__ADSPLPBLACKFIN__ -I../include -DBOARD_STAMP_BF533 -g -c -o auxiliaries.o auxiliaries.asm bfin-elf-gcc -I../include -g -DBOARD_STAMP_BF533 -DBLINK_AND_WAIT -D__ADSPLPBLACKFIN__ -c -o main.o main.c bfin-elf-ld -T bftiny.x -o blink.dxe crt0.o auxiliaries.o main.o root@jfduval-desktop:/home/jfduval/Desktop/blinky#

Et ça fonctionne ! Vous avez maintenant une version compilée de Blinky. Par contre, dépendant du hardware sur lequel vous travaillez, il est possible que cette version ne soit pas compatible.

Modifier Blinky

Originalement, les exemples sont faits pour les cartes Stamp, EZKIT et autres. Pour tester Blinky sur le Gigamodule, j’ai effectué quelques modifications aux sources. Mon projet modifié se trouve dans le répertoire /home/jfduval/Desktop/blinky_mod/. Je ne justifierai pas tous les changements, car ces informations sont intrinsèquement liées au matériel que vous utilisez. Le but est plutôt de vous montrer en gros ce qui peut et doit être changé. Je n’ai pas pris le temps d’ajouter une nouvelle carte. J’ai plutôt trafiqué le EZKIT pour l’adapter au Gigamodule. Les principales modifications visent à changer le projet pour inclure le BF532, ajuster les fréquences et ajuster les adresses mémoires. Dans ma version, la DEL clignote à l’infini, plutôt qu’un certain nombre de cycles.

auxiliaries.asm

Original	Modifié
#include <defBF533.h>	#include <defBF532.h>
p0.l = LO(0xffa00000); p0.h = HI(0xffa00000);	p0.l = LO(0xffa08000); p0.h = HI(0xffa08000);

config.h

Original	Modifié
#if defined(BOARD_EZKIT_BF533) #define MASTER_CLOCK 27000000 #define SCLK_DIVIDER 4 #define VCO_MULTIPLIER 16 #define CCLK_DIVIDER 1	#if defined(BOARD_EZKIT_BF533) //Adapted for Gigamodule BF532 #define MASTER_CLOCK 25000000 #define SCLK_DIVIDER 5 #define VCO_MULTIPLIER 12 #define CCLK_DIVIDER 1
#define L1_DATA_SRAM_A 0xff800000	#define L1_DATA_SRAM_A 0xff804000

crt0.asm

Original	Modifié
#include <defBF533.h>	#include <defBF532.h>

main.c

Original	Modifié
#include <defBF533.h>	#include <defBF532.h>
#if defined(BOARD_EZKIT_BF533) #define pFlashA_PortB_Dir (volatile unsigned char *) 0x20270007 #define pFlashA_PortB_Data (volatile unsigned char *) 0x20270005 void do_blink(void) { int i; // Initialize EBIU async memory banks *pEBIU_AMBCTL0 = 0x7bb07bb0; *pEBIU_AMBCTL1 = 0x7bb07bb0; *pEBIU_AMGCTL = 0x000f; // init flash a port b direction *pFlashA_PortB_Dir = 0x3f; i = 0; int leds = 0x15; while (i < 40) { *pFlashA_PortB_Data = leds; delay(); leds ^= 0xff; i++; } }	#if defined(BOARD_EZKIT_BF533) //#define pFlashA_PortB_Dir (volatile unsigned char *) 0x20270007 //#define pFlashA_PortB_Data (volatile unsigned char *) 0x20270005 void do_blink(void) { /* int i; // Initialize EBIU async memory banks *pEBIU_AMBCTL0 = 0x7bb07bb0; *pEBIU_AMBCTL1 = 0x7bb07bb0; *pEBIU_AMGCTL = 0x000f; // init flash a port b direction *pFlashA_PortB_Dir = 0x3f; i = 0; int leds = 0x15; while (i < 40) { *pFlashA_PortB_Data = leds; delay(); leds ^= 0xff; i++; } */ int i; *pFIO_DIR = 0x001c; *pFIO_FLAG_D = 0x0008; *pFIO_INEN = 0x0160; // enable input for buttons i = 0; while(1){ //while (i < 20) { *pFIO_FLAG_T = 0x001c; delay(); //i++; } }

Vous disposez maintenant d’une version adaptée de Blinky.

Faire fonctionner Blinky sur le Blackfin

Sur une machine Ubuntu récente, il est fort probable que de faire :

jfduval@jfduval-desktop:~$ bfin-elf-insight

ne produise aucun résultat. Il existe un petit problème avec Insight, qu’on contournera en effectuant (source : http://www.section5.ch/forum/viewtopic.php ?f=1&t=70) cette commande :

jfduval@jfduval-desktop:~$ export GDBTK_LIBRARY=/usr/share/insight1.0 jfduval@jfduval-desktop:~$ bfin-elf-insight

On a maintenant une fenêtre Insight qui s’ouvre. Maintenant que ce problème est réglé, on peut fermer Insight et suivre la bonne procédure. Il faudra refaire cette exportation à chaque fois qu’une nouvelle console est ouverte.

Dans le répertoire blinky_mod/, j’ai créé un fichier texte intitulé cfg.gdbinit qui contient les informations suivantes :

file blink.dxe target remote 192.168.1.205:2000 set remotetimeout 999999 set remoteaddresssize 32 source /usr/share/gdbscripts/mmr.gdb source /usr/share/gdbscripts/init.gdb source /usr/share/gdbscripts/dump.gdb echo Initializing Target.. set prompt (bfin-jtag-gdb)\ define init_target set *$EBIU_SDGCTL = 0x809110CD set *$EBIU_SDBCTL = 0x0025 set *$EBIU_SDRRC = 0x01CF monitor reset load blink.dxe end

Ce fichier a été conçu en m’inspirant des exemples du ICEBear Manual et des différentes documentations existant sur le ICEBear, BFLoader et Blinky. Ce script permet d’automatiser certaines tâches répétitives.

ICEBear sur un second PC

Il existe plusieurs manières de procéder. À l’origine, j’ai éprouvé certains problèmes de stabilité avec les pilotes USB de ma machine virtuelle Debian Etch sous VMWare Player. J’ai donc décidé de connecter le ICEBear sur un PC Windows XP, qui est relié au mien par le réseau local. Ainsi, GDBProxy se connecte sur le second PC et tout fonctionne. Sur le PC XP, il suffit de télécharger la suite à l’adresse http://www.section5.ch/dsp/icebear/ICEbear-1.21-setup.exe et d’installer le tout. On peut ensuite lancer GDBProxy, qui devrait nous afficher la détection d’un Device et préciser qu’il attend sur le port 2000. Notez que vous pouvez aussi utiliser les Demos pour tester votre hardware.

On commence par se placer dans le bon répertoire puis on lance Insight (on a déjà GDBProxy qui attend sur l’autre machine) :

root@jfduval-desktop:~# cd /home/jfduval/Desktop/blinky_mod/ root@jfduval-desktop:/home/jfduval/Desktop/blinky_mod# /usr/bin/bfin-elf-insight blink.dxe

Portez attention au fait que pour lancer Insight je marque explicitement son chemin. Si on oublie ce « détail » il est possible que ce soit la version µCLinux/U-Boot de Insight qui ouvre et, même si en apparence c’est le même logiciel, elle n’est pas compatible avec le ICEBear.

On a maintenant une fenêtre Insight ouverte. On clique sur Run > Connect to target. On configure ensuite le tout ainsi :

• Target : Remote/TCP
• Hostname : 192.168.1.205
• Port : 2000

La ligne de code surlignée devrait maintenant être verte. On fait ensuite Run > Download. Maintenant, si on appuie sur le bouton Continue, le programme devrait rouler et la DEL clignoter ! Pour explorer les possibilités d’Insight/GDB, je vous conseille d’expérimenter, tout en vous référant au ICEBear Manual.

Tout sur la même machine

Voici une deuxième manière de procéder, beaucoup plus simple et élégante, à condition de ne pas avoir de problème de connexion avec les périphériques USB sur la machine virtuelle. La combinaison Ubuntu 9.04 et VirtualBox semble beaucoup plus stable sur ce point que Debian et VMWare. La première chose à faire est d’ouvrir un second terminal et d’y lancer GDBProxy :

root@jfduval-desktop:~# gdbproxy bfin Remote proxy for GDB, v0.8.6devel, Copyright (C) 1999 Quality Quorum Inc. Blackfin adaption (C) 2005-2008 Martin Strubel <hackfin@section5.ch> GDBproxy comes with ABSOLUTELY NO WARRANTY; for details use `--warranty' option. This is Open Source software. You are welcome to redistribute it under certain conditions. Use the '--copying' option for details. notice: Detected 1 device(s) notice: Setting clock wait cycle to 0 notice: Selecting CPU 0 notice: gdbproxy: waiting on TCP port 2000

Dans notre terminal principal, on lance Insight :

root@jfduval-desktop:~# cd /home/jfduval/Desktop/blinky_mod/ root@jfduval-desktop:/home/jfduval/Desktop/blinky_mod# /usr/bin/bfin-elf-insight blink.dxe

On a maintenant une fenêtre Insight ouverte. On clique sur Run > Connect to target. On configure ensuite le tout ainsi :

• Target : Remote/TCP
• Hostname :
• Port : 2000

La ligne de code surlignée devrait maintenant être verte. On fait ensuite Run > Download. Maintenant, si on appuie sur le bouton Continue, le programme devrait rouler et la DEL clignoter !

U-Boot et outils associés

Installation de la toolchain

Il faut commencer par ajouter le répertoire des sources de µCLinux et de la toolchain Blackfin à notre chemin de recherche de apt-get :

jfduval@jfduval-desktop:/etc/apt/sources.list.d$ sudo 'echo “deb http://download.analog.com/27516/distros/debian stable main” > /etc/apt/sources.list.d/blackfin.sources.list' sudo: echo “deb http://download.analog.com/27516/distros/debian stable main” > /etc/apt/sources.list.d/blackfin.sources.list: command not found

N’ayant pas eu de succès, j’ai créé le fichier blackfin.sources.list (simple fichier texte créé avec gedit) sur mon bureau et y ai mis la ligne deb http://download.analog.com/27516/distros/debian stable main, puis je l’ai envoyé à la bonne place :

jfduval@jfduval-desktop:~/Desktop$ sudo mv blackfin.sourpour finces.list /etc/apt/sources.list.d/

On fait un sudo apt-get update pour tenir compte des dernières modifications puis, toujours en suivant les informations du wiki (http://docs.blackfin.uclinux.org/doku.php ?id=toolchain :installing) on installe le tout :

jfduval@jfduval-desktop:~/Desktop$ sudo apt-get install blackfin-toolchain-uclinux blackfin-toolchain-linux-uclibc

Vous possédez maintenant tous les outils nécessaires pour compiler U-Boot. Avant de les utiliser, il ne reste qu’une seule étape : ajuster la variable d’environnement PATH. En se basant sur http://docs.blackfin.uclinux.org/doku.php ?id=toolchain :installing on fait :

root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5# export PATH=$PATH:/opt/uClinux/bfin-uclinux/bin:/opt/uClinux/bfin-linux-uclibc/bin

Sources de U-Boot

Télécharger les sources de U-Boot ici : http://blackfin.uclinux.org/gf/project/u-boot/frs On fait clic droit et Extract Here, puis on a un dossier U-Boot avec tous les fichiers nécessaires. Pour ma part, j’ai utilisé la dernière version stable, soit la 1.1.6-2008R1.5.

Compiler U-Boot

Pour compiler U-Boot, il est conseillé de travailler en root pour éviter les problèmes de permissions. Pour commencer, il faut se placer dans le bon répertoire (U-Boot) :

root@jfduval-desktop:/home/jfduval# cd Desktop/u-boot-1.1.6-2008R1.5 root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5#

Il faut maintenant configurer le projet. Pour fin d’exemple, nous allons compiler pour un BF533 Stamp :

root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5# make bf533-stamp_config Configuring for bf533-stamp board... root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5#

On peut maintenant nettoyer et compiler :

root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5# make clean root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5# make

Si vous obtenez une erreur disant gawk not found, il suffit d’installer gawk :

root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5# apt-get install gawk

Si la compilation est un succès, un fichier u-boot.ldr sera créé dans le répertoire principal. C’est ce fichier que nous utiliserons pour programmer le Blackfin.

[...] Creating LDR u-boot.ldr … Adding DXE 'u-boot' ... [jump block] [ELF block: 119104 @ 0x01FC0000] [ELF block: 44 @ 0xFFA0000C] [ELF block: 24972 @ 0x01FDD16C] OK! Done! bfin-uclinux-objcopy --gap-fill=0xff -O srec u-boot.ldr u-boot.ldr.srec -I binary bfin-uclinux-objcopy --gap-fill=0xff -O ihex u-boot.ldr u-boot.ldr.hex -I binary root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5#

Modifier U-Boot

Cette section ne décrira pas en détail la modification des fichiers de U-Boot, la documentation existante étant assez complète. Je vais plutôt vous pointer vers les bonnes références et vous montrer où trouver les fichiers à modifier.

Pour savoir comment modifier le makefile, le fichier de configuration et le répertoire de projet, se référer à la section Porting U-Boot du wiki. Bien que les informations sur le wiki soient assez claires, je considère que ce qu’il manque le plus c’est une liste des modifications possibles. Pour connaître ces commandes, il suffit de regarder le fichier README du répertoire U-Boot. On y trouve beaucoup d’informations utiles.

Répertoires importants

La version stable actuelle de U-Boot est 1.1.6-2008R1.5. Tout le développement a été effectué avec cette version. Plusieurs essais ont été faits afin de porter U-Boot correctement, j’ai donc créé quelques dossiers de projet. Le projet que j’utilise actuellement est le bf532-giga2. La liste des chemins ci-dessous est donc adaptée à ma version. Le plus simple est de partir d’un projet similaire et de modifier ses sources. Dans mon cas, je me suis basé sur le Stamp BF533, le Blackfin One, le Minotaur BF537 et le SRV-1.

U-Boot : /home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga/ : Répertoire principal de U-Boot. C’est une copie du répertoire originale où se trouvent mes fichiers modifiés.

board : /home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga/board/ (dans notre cas, on utilise /home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga/board/bf532-giga2/) : Fichiers propres à notre projet.

configs : /home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga/include/configs/ : Fichier de configuration de notre projet (bf532-giga2.h)

gdbscripts : /usr/share/gdbscripts : Scripts pour GDBProxy

Atmel Dataflash : outil de conversion

Pour que le Blackfin puisse booter depuis une Flash SPI, il faut qu’elle respecte certains critères : adresses de 8, 16 ou 24bits et pages de taille « puissance de 2 ». Ce dernier point est important dans notre cas, car par défaut les Dataflash utilisent des pages de 528bytes (et non de 512). La datasheet du AT45DB321D explique qu’il est possible de changer la Flash en mode 512bytes en suivant une procédure somme toute assez simple. Devant l’absence d’outil dans BFLoader et dans U-Boot pour effectuer ce changement, j’ai écrit la fonction nécessaire.

Le fichier que j’ai modifié est /home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga/board/bf532-giga2/spi_flash.c. Dans la fonction eeprom_info(void), tout juste avant SPI_DEINIT() ; il faut ajouter la ligne suivante :

atmel_po2(flash.sector_size); //Atmel Dataflash vs Power-of-Two

Ensuite, après la fonction eeprom_info(void) on ajoute cette fonction :

//ATMEL Spi Flash Power-of-Two Tool (JFDuval, IntRoLab, 2009) int atmel_po2(int size) { char InData; if(size == 528) { //It's in Dataflash, we can change it printf("Your FLASH uses 528 bytes pages. It can be converted to 512 bytes\n" "pages. Important: conversion is PERMANENT (no come back). Want to\n" "change it to 512? [y/n]"); InData = getc(); if((InData == 'y')||(InData == 'Y')) { printf("\nRunning conversion tool...\n"); //Open SPI SPI_ON(); //Send the 4 configuration bytes printf("Byte: 0x3D\n"); spi_write_read_byte(0x3D); printf("Byte: 0x2A\n"); spi_write_read_byte(0x2A); printf("Byte: 0x80\n"); spi_write_read_byte(0x80); printf("Byte: 0xA6\n"); spi_write_read_byte(0xA6); printf("Wait a moment than cycle power.\n"); //Close SPI SPI_OFF(); } else printf("\nNo modifications will be done.\n"); } else if(size == 512) { printf("This FLASH is in Power-of-Two mode.\n"); } }

Pour l’utiliser, il suffit de faire rouler U-Boot et de faire la commande eeprom info (voir Utiliser U-Boot : quelques commandes). Les instructions seront alors fournies pour modifier correctement votre Flash. Attention : le changement est permanent !

Exemple de fonctionnement (mon prototype est déjà en mode puissance de 2) :

bfin-giga>eeprom info SPI Device: AT45DB321x 0x1F (Atmel) 0x27 0x01 Parameters: num sectors = 8192, sector size = 512, write size = 512 Flash Size: 32 mbit (4 mbyte) Status: 0xB5 This FLASH is in Power-of-Two mode. bfin-giga>

Cet outil n’est seulement disponible que si vous modifiez votre U-Boot avec les changements décrits dans cette section ou que vous travaillez avec mes sources. Il est possible que cet outil soit ajouté aux prochaines versions de U-Boot, mais ce n’est pas encore le cas.

Utiliser U-Boot sur votre Blackfin

Maintenant que vous disposez d’une version compilée de U-Boot, il est temps de programmer un Blackfin avec ce code et de tester en conditions réelles si le tout est fonctionnel.

Charger U-Boot en mémoire

Normalement, le programme BFLoader permet de charger le .ldr directement dans la Flash, qu’elle soit parallèle (sur le bus mémoire) ou SPI. Par contre, il s’avère que le driver SPI ne supporte que les Flash ST et compatibles, qui utilisent un protocole standard et des pages de 512 bytes. La carte Gigamodule disposant d’une Flash Atmel qui utilise le protocole Dataflash (commandes plus évoluées et pages de 528 bytes). On va donc agir comme pour Blinky, on va charger U-Boot dans la RAM, en utilisant le ICEBear et GDBProxy/Insight, et l’exécuter. U-Boot étant capable de s’inscrire en mémoire, nous pourrons atteindre notre but malgré cet obstacle.

Note : plutôt que de répéter des informations, je vous réfère aux sections Atmel SPI Flash et Faire fonctionner Blinky sur le Blackfin. La démarche pour U-Boot étant très semblable à celle pour Blinky, je ne noterai ici que les différences.

Premièrement, il faut faire tourner GDBProxy avec le JTAG connecté sur la carte. Ensuite, il faut connecter la carte au PC par son interface série. Sur le Gigamodule, on utilise le connecteur USB car un circuit de conversion Série<>USB (FT232) est présent sur la carte. On ouvre un terminal RS-232 (voir la section Console RS-232 pour détails).

Comme pour Blinky, un fichier de scripts GDB est utilisé afin d’automatiser certaines tâches. Mon fichier /home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga/cfg.gdbinit contient :

target remote :2000 set remotetimeout 999999 set remoteaddresssize 32 source /usr/share/gdbscripts/mmr.gdb source /usr/share/gdbscripts/init.gdb source /usr/share/gdbscripts/dump.gdb echo Initializing Target.. set prompt (bfin-jtag-gdb)\ monitor reset set *$EBIU_SDGCTL = 0x809110CD set *$EBIU_SDBCTL = 0x0025 set *$EBIU_SDRRC = 0x01CF load u-boot restore u-boot.bin binary 0x100000

On se place dans le bon dossier et on lance Insight :

root@jfduval-desktop:/home/jfduval/Desktop# cd u-boot-1.1.6-2008R1.5_Giga/ root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga# /usr/bin/bfin-elf-insight u-boot.ldr

Je rappelle qu’il est important de spécifier le chemin de l’exécutable Insight afin que ce soit la version Section5 et non celle µCLinux qui charge !

Maintenant qu’Insight est lancé, on peut faire File > Source... > cfg.gdbinit > Open. Quand les icônes du débogueur deviendront colorées, c’est prêt à être utilisé. Notez que si vous utilisez une connexion réseau avec un autre PC, le transfert peut prendre quelques minutes. On appuie ensuite sur Continue. Dans la fenêtre de terminal, on devrait lire quelque chose du genre :

Early:start.S: Init Registers Early:start.S: Relocate Early:start.S: Lower to 15 Early: NOP Slide Early: Board init flash Early: Init CPLB tables Early: Exceptions setup Early: Turn on ICACHE Early: Turn on DCACHE Early: Init global data Early: IRQ init Early: Environment init Early: Baudrate init Early: Serial init Early: Console init flash Early: End of early debugging U-Boot 1.1.6 (ADI-2008R1.5) (Jul 10 2009 - 17:23:34) CPU: ADSP bf532-0.5 (Detected Rev: 0.5) Board: IntRoLab BF532 GigaModule v2 Clock: VCO: 300 MHz, Core: 300 MHz, System: 60 MHz RAM: Serial Port initialized with Baud rate = 115200 SDRAM attributes: tRCD 3 SCLK Cycles,tRP 3 SCLK Cycles,tRAS 6 SCLK CyclestWR 2 SCLK Cycles,CAS Latency 3 SCLK cycles SDRAM Begin: 0x0 Bank size = 64 MB 64 MB *** Warning - bad CRC, using default environment In: serial Out: serial Err: serial gd: 3f9c000 |-flags: 3 |-board_type: 0 |-baudrate: 115200 |-have_console: 1 |-ram_size: 0 |-reloc_off: 0 |-env_addr: 3fa000c |-env_valid: 1 |-jt(3fb0168): 3fc5d50 \-bd: 3f9c028 |-bi_baudrate: 1c200 |-bi_ip_addr: 0 |-bi_enetaddr: 0 0 0 0 0 0 |-bi_boot_params: 0 |-bi_memstart: 0 |-bi_memsize: 4000000 |-bi_flashstart: 0 |-bi_flashsize: 0 \-bi_flashoffset: 0 bfin-giga>#

Et voilà ! On a maintenant U-Boot qui tourne en RAM sur notre propre carte. Dans les prochaines sections, on verra comment utiliser U-Boot et comment l’écrire dans une Flash SPI.

Console RS-232

La carte Blackfin Gigamodule étant munie d’un convertisseur Série<>USB FT232, il faut connecter le câble USB à un PC. Les drivers du FT232 sont disponibles sur le site de FTDI. Notez que dans les versions récentes de Linux, les drivers sont déjà inclus. Il faut ensuite configurer le port série. Pour le Gigamodule, les valeurs ont été changées dans les sources et sont : 115200 bits/s, 8 bits, No parity, 1 Stop Bit, No Flow Control. Par défaut, c’est : 57600 bits/s, 8 bits, No parity, 1 Stop Bit, No Flow Control.

Lors du choix d’un programme de terminal, il est important de s’assurer qu’il permette le transfert de fichiers avec le protocole Y-Modem. Il y a deux manières de travailler. Vous pouvez ouvrir le terminal sous votre machine hôte, typiquement sous Windows, ou vous pouvez l’ouvrir dans la machine virtuelle, Ubuntu dans notre cas.

Windows

Dans mon cas, Hyperterminal a été utilisé. Notez qu’il suffit de copier l’exécutable et le .dll d’un PC sous XP pour l’avoir sous Vista.

Théoriquement, U-Boot permet le transfert de fichier par 2 protocoles : Kermit et Y-Modem. Même si Hyperterminal supporte les 2, il y a un problème avec Kermit, les données transférées ne sont pas bonnes. Utiliser Y-Modem permet un bon transfert de l’image. Pour transférer une image, il suffit de faire Transfer > Send file... > Filename = u-boot.ldr Protocole = Ymodem > Send.

Ubuntu 9.04

Pour utiliser Ymodem, le Wiki U-Boot recommande l’usage de Minicom. Les informations de la section Terminal Programs décrivent bien comment l’installer et le configurer. J’ai reproduit ce qui est expliqué là, à la différence près que mon port série, obtenu par le FT232, est ttyUSB0. Je vous préviens, pour quelqu’un habitué aux programmes modernes et aux GUI, Minicom est un cauchemar !

Une fois le programme installé et configuré, on le lance ainsi :

root@jfduval-desktop:/home/jfduval# minicom [?3;4l Welcome to minicom 2.3 OPTIONS: I18n Compiled on Oct 24 2008, 06:37:44. Port /dev/ttyUSB0 Press CTRL-A Z for help on special keys

Si on fait tourner U-Boot en RAM, on obtient bien notre sortie terminale. On doit ensuite appeler loady. Pour envoyer un fichier avec Minicom, il faut faire ’Ctrl+A’, puis appuyer sur ’S’ et choisir ymodem. Ensuite, avec les flèches on place le curseur sur Goto et on copie le chemin de notre fichier (/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga/ dans mon cas) puis on met le curseur sur Okay et on appui sur Enter.

Bien que la « fenêtre » de transfert Ymodem apparaissait bien, je n’avais aucun signe de fonctionnement, outre la DEL de réception du FT232 qui clignotait une fois aux quelques secondes. Arrêter la commande m’a donné plus d’informations, Minicom avait échoué une vingtaine de tentatives de connexion. Après une courte recherche sur Google, j’ai trouvé un site qui expliquait mon problème. J’ai suivi leurs instructions et j’ai installé lrzsz. Une fois ce programme installé, mon port série est devenu fou, il y avait un transfert incessant de données plus ou moins lisibles... Après avoir redémarré mon système, le problème était réglé et Minicom permet le transfert d’une image.

Voici à quoi ressemble la « fenêtre » d’un transfert réussi :

+-----------[ymodem upload - Press CTRL-C to quit]------------+ |Retry 0: NAK on sector | |Bytes Sent: 58240 BPS:3963 | |Sending: | |Ymodem sectors/kbytes sent: 0/ 0k | |Transfer complete | | | | READY: press any key to continue... | +-------------------------------------------------------------+

Après avoir appuyé sur une touche, on peut lire :

bfin-giga>loady ## Ready for binary (ymodem) download to 0x01000000 at 115200 bps... C## Total Size = 0x0000e334 = 58164 Bytes bfin-giga>

Bref, le transfert semble avoir bien fonctionné. Dans la section Écrire l’image U-Boot en Flash je décris quelques essais qui permettent de confirmer le bon transfert des fichiers.

Utiliser U-Boot : quelques commandes

Voici quelques commandes très utiles :

bfin-giga> help : Affiche toutes les commandes incluses dans votre version de U-Boot. Pour en ajouter/enlever, il suffit de modifier bf532-giga2.h en se basant sur le Readme.

bfin-giga> bdinfo : Affiche les propriétés du système (fréquences, versions, baudrate, etc.)

bfin-giga> eeprom info : Informations sur la Flash. C’est dans ce mode qu’on peut transformer une Flash Atmel en mode Puissance de 2. Note : dans votre version uniquement, mon code n’est pas encore inclus dans le release U-Boot.

bfin-giga> md.b : Memory Display. Exemple : md.b 0x1000 0x1000 affiche la RAM de l’adresse 0x1000 et 0x1000 de long. md.b StartAdress Length

bfin-giga> mw.b : Memory Write. Exemple : mw.b 0x1000000 0xFF 0x10000 écrit des 0xFF à l’adresse 0x1000000 pendant 0x10000. mw.b StartAdress Value Length.

bfin-giga> eeprom write : Eeprom Write. Exemple : eeprom write 0x1000000 0x0 0xD5B0 écrit l’adresse 0x1000000 de la RAM dans la Flash à l’adresse 0 pendant 0xD5B0 bytes. eeprom write RamStartAddress FlashStartAddress Length

bfin-giga> eeprom read : Eeprom Read. Exemple : eeprom read 0x1000000 0x0 0xD5B0 écrit à l’adresse 0x1000000 de la RAM le contenu de la Flash à l’adresse 0 pendant 0xD5B0 bytes. eeprom read RamStartAddress FlashStartAddress Length

bfin-giga> loady : Load file with Y-Modem Protocol. Exemple : envoyer la commande loady, puis, dans Hyperterminal Transfert > Send File... > Filename : u-boot.ldr Protocol : Ymodem > OK. Par défaut, le fichier sera chargé en RAM à l’adresse 0x1000000. Il ne reste ensuite qu’à écrire cette image à l’adresse 0 de la Flash pour booter dessus.

Booter sur une Flash SPI

La mémoire Flash de la carte Gigamodule est une Atmel Dataflash AT45DB321D de 32Mbit. On veut pouvoir booter depuis celle-ci. La première étape, en se référant à la datasheet du BF532, est de configurer le bon boot-mode. Pour booter sur un esclave SPI, il faut se placer en mode 11 (sur le Gigamodule, cela équivaut à enlever les deux jumpers).

On charge ensuite U-Boot en RAM et on le fait tourner (voir Charger U-Boot en mémoire). On peut confirmer que notre mémoire est bien détectée avec la commande eeprom info. On va donc charger une image de U-Boot dans la RAM.

Charger l’image U-Boot en RAM

Tel qu’expliqué ailleurs dans ce document, j’ai eu certains problèmes avec le transfert de fichiers avec le protocole Kermit et Hyperterminal. Je n’ai pas cherché à trouver si c’était U-Boot ou Hyperterminal qui causait le problème car utiliser Ymodem m’a permis de transmettre correctement mon image, réglant ainsi mon problème. Dans le terminal, on appelle la commande loady :

bfin-giga>loady ## Ready for binary (ymodem) download to 0x01000000 at 115200 bps...

Dans notre programme de terminal, on envoie notre fichier u-boot.ldr par le protocole Ymodem :

CCCxyzModem - CRC mode, 2(SOH)/57(STX)/0(CAN) packets, 5 retries ## Total Size = 0x0000e334 = 58164 Bytes bfin-giga>

Le transfert est un succès. La taille est 0xE334 : nous utiliserons cette valeur bientôt. L’image de U-Boot est donc présente en RAM, à l’adresse 0x01000000. Il est possible de vérifier facilement la réussite de cette étape en affichant le contenu de la RAM :

bfin-giga>md.b 0x1000000 0x100 01000000: 00 80 a0 ff 2c 03 00 00 08 00 66 01 c0 05 50 01 ....,.....f...P. 01000010: 51 01 52 01 53 01 58 01 59 01 5a 01 5b 01 5c 01 Q.R.S.X.Y.Z.[.\. 01000020: 5d 01 5e 01 5f 01 54 01 55 01 56 01 57 01 60 01 ].^._.T.U.V.W.`. 01000030: 61 01 4a e1 c0 ff 62 01 63 01 0a e1 24 04 50 95 a.J...b.c...$.P. 01000040: 21 e1 e1 00 00 48 49 4f 00 60 08 07 49 e1 c0 ff !....HIO.`..I... 01000050: 08 60 10 97 09 e1 0c 04 18 60 08 97 30 00 00 00 .`.......`..0... 01000060: 00 00 24 00 40 00 01 0c 1c 14 48 95 38 4a 08 97 ..$.@.....H.8J.. 01000070: 30 00 00 00 00 00 24 00 40 00 08 61 e2 6e 10 97 0.....$.@..a.n.. 01000080: 00 60 22 6c 10 97 30 00 00 00 00 00 24 00 40 00 .`"l..0.....$.@. 01000090: 48 95 38 4c 08 97 30 00 00 00 00 00 24 00 40 00 H.8L..0.....$.@. 010000a0: 4a e1 c0 ff 20 e1 53 00 0a e1 00 04 10 97 4a e1 J... .S.......J. 010000b0: c0 ff 0a e1 14 04 50 95 30 48 fa 1f 4a e1 c0 ff ......P.0H..J... 010000c0: 0a e1 14 05 20 60 10 97 4a e1 c0 ff 20 e1 42 00 .... `..J... .B. 010000d0: 0a e1 00 04 10 97 4a e1 c0 ff 0a e1 14 04 50 95 ......J.......P. 010000e0: 30 48 fa 1f 4a e1 c0 ff 0a e1 24 01 08 60 10 93 0H..J.....$..`.. 010000f0: 4a e1 c0 ff 20 e1 4c 00 0a e1 00 04 10 97 4a e1 J... .L.......J.

Que signifient ces informations ? Ce qu’on vient de lire est l’en-tête de l’image U-Boot, un header de 10 octets, ainsi que les données de l’image. Ce sont les premières données que va lire le Blackfin quand il va booter sur la Flash SPI. Selon les informations de l’Application Note EE-240 ADSP-BF533 Blackfin® Booting Process on peut découper le paquet des 10 premiers octets ainsi : [00 80 a0 ff] [2c 03 00 00] [08 00]. Cela représente en fait [Adress (4bytes)][Count (4bytes)][Flag (2bytes)]. Si vous allez voir dans le datasheet l’organisation mémoire du BF532 vous constaterez que 0xFFA08000 correspond au début de la mémoire instructions : on va donc transférer les données à la bonne place pour que le code s’exécute.

Si vous disposez d’un appareil capable d’analyser un bus SPI, comme un oscilloscope Agilent MSO6034A avec les bonnes options, vous pourrez lire ce header de 10 bytes quand le Blackfin démarre, confirmant ainsi le bon fonctionnement de votre système.

Écrire l’image U-Boot en Flash

On va maintenant écrire dans la Flash SPI l’image de U-Boot que l’on vient de charger en RAM. Pour ce faire, utilise la fonction eeprom write :

bfin-giga>eeprom write 0x1000000 0x0 0x0000e334 EEPROM @0x0 write: addr 01000000 off 0000 count 58164 ... .................... ................................................................................ ................................................................................ ................................................done bfin-giga>

Et voilà, l’image est transférée dans la mémoire Flash. À condition que notre boot-mode soit bien 11, le Blackfin devrait maintenant booter de sa Flash sans problème.

Vous voulez confirmer que le transfert s’est bien déroulé, que l’image est bien écrite dans la Flash ? On commence par effacer (bref, à remplacer par une valeur connue) une portion de la RAM, puis on l’affiche pour s’assurer que c’est correct :

bfin-giga>mw.b 0x1000000 0xFD 0x1000 bfin-giga>md.b 0x1000000 0x100 01000000: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000010: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000020: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000030: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000040: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000050: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000060: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000070: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000080: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 01000090: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 010000a0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 010000b0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 010000c0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 010000d0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 010000e0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ 010000f0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd ................ bfin-giga>

On constate bien que toutes les données valent 0xFD. On va maintenant lire la Flash et écrire ce qu’on lit par-dessus tous ces 0xFD :

bfin-giga>eeprom read 0x1000000 0x0 0x100 EEPROM @0x0 read: addr 01000000 off 0000 count 256 ... done bfin-giga>md.b 0x1000000 0x100 01000000: 00 80 a0 ff 2c 03 00 00 08 00 66 01 c0 05 50 01 ....,.....f...P. 01000010: 51 01 52 01 53 01 58 01 59 01 5a 01 5b 01 5c 01 Q.R.S.X.Y.Z.[.\. 01000020: 5d 01 5e 01 5f 01 54 01 55 01 56 01 57 01 60 01 ].^._.T.U.V.W.`. 01000030: 61 01 4a e1 c0 ff 62 01 63 01 0a e1 24 04 50 95 a.J...b.c...$.P. 01000040: 21 e1 e1 00 00 48 49 4f 00 60 08 07 49 e1 c0 ff !....HIO.`..I... 01000050: 08 60 10 97 09 e1 0c 04 18 60 08 97 30 00 00 00 .`.......`..0... 01000060: 00 00 24 00 40 00 01 0c 1c 14 48 95 38 4a 08 97 ..$.@.....H.8J.. 01000070: 30 00 00 00 00 00 24 00 40 00 08 61 e2 6e 10 97 0.....$.@..a.n.. 01000080: 00 60 22 6c 10 97 30 00 00 00 00 00 24 00 40 00 .`"l..0.....$.@. 01000090: 48 95 38 4c 08 97 30 00 00 00 00 00 24 00 40 00 H.8L..0.....$.@. 010000a0: 4a e1 c0 ff 20 e1 53 00 0a e1 00 04 10 97 4a e1 J... .S.......J. 010000b0: c0 ff 0a e1 14 04 50 95 30 48 fa 1f 4a e1 c0 ff ......P.0H..J... 010000c0: 0a e1 14 05 20 60 10 97 4a e1 c0 ff 20 e1 42 00 .... `..J... .B. 010000d0: 0a e1 00 04 10 97 4a e1 c0 ff 0a e1 14 04 50 95 ......J.......P. 010000e0: 30 48 fa 1f 4a e1 c0 ff 0a e1 24 01 08 60 10 93 0H..J.....$..`.. 010000f0: 4a e1 c0 ff 20 e1 4c 00 0a e1 00 04 10 97 4a e1 J... .L.......J. bfin-giga>

On constate que ce sont les même valeurs que l’image, donc l’écriture et la lecture sont un succès.

Déboguer avec le JTAG

Jusqu’à date nous avons utilisé notre ICEBear et Insight dans l’unique but de charger nos programmes en RAM. Une autre utilisation, tout aussi importante, est le débogage. J’utilise un script GDB que j’ai nommé cfg2.gdbscript :

target remote 192.168.1.205:2000 set remotetimeout 999999 set remoteaddresssize 32 source /usr/share/gdbscripts/mmr.gdb source /usr/share/gdbscripts/init.gdb source /usr/share/gdbscripts/dump.gdb echo Initializing Target.. set prompt (bfin-jtag-gdb)\ define init_target set *$EBIU_SDGCTL = 0x809110CD set *$EBIU_SDBCTL = 0x0025 set *$EBIU_SDRRC = 0x01CF monitor reset load blink.dxe end

Si vous le comparez à cfg.gdbinit, vous constaterez que la version 2 ne charge pas le programme. Pour déboguer ma version de U-Boot qui s’exécute depuis la Flash SPI, j’ai lancé Insight dans le bon dossier :

root@jfduval-desktop:/home/jfduval/Desktop# cd u-boot-1.1.6-2008R1.5_Giga/ root@jfduval-desktop:/home/jfduval/Desktop/u-boot-1.1.6-2008R1.5_Giga# /usr/bin/bfin-elf-insight u-boot.ldr <cadre> Maintenant qu'Insight est lancé, on peut faire File > Source... > cfg2.gdbinit > Open. Quand les icônes du débogueur deviendront colorés, c'est prêt à être utilisé. On fait Open > u-boot > Ok. On peut maintenant faire fonctionner le programme en pas-à-pas, le faire exécuter jusqu'à la fin, le mettre en pause, etc. Il est possible d'utiliser la console d'Insight et d'appeler des fonctions de débogage sous forme de scripts. Ainsi, appeler {dump_ebiu} vous affichera les données de configuration de la RAM, {dump_pll} vous informera de vos diviseurs et multiplicateurs de fréquence. Pour connaître toutes les possibilités de débogage, je vous conseil de consulter le ICEBear Manual et de lire le code des scripts du dossier {/gdbscripts/}. Vous pourrez alors savoir où votre programme bloque, quelle est la valeur de vos registres, etc. {{{Résultats}}} Le travail présenté dans ce document a été réalisé lors de mon stage à l'[IntRoLab->http://introlab.gel.usherbrooke.ca/], le laboratoire de recherche en robotique mobile et intelligence artificielle de l'Université de Sherbrooke. Mon but était d'aider l'équipe [Robot22] à réaliser leur projet en les avançant sur la portion Blackfin. J'ai donc commencé par analyser et modifier les schémas de la carte Gigamodule. J'ai ensuite conçu le circuit imprimé de cette carte, l'ai assemblé et testé. La suite de mon mandat était de charger U-Boot dans la flash et ensuite d'y mettre µCLinux. Ma recherche d'outils m'a conduit chez Section5 car la combinaison ICEBear et BFLoader répondait à mon besoin de trouver un outil simple, complet et économique pour programmer la carte. Tel qu'expliqué au fil de ce texte, mon parcours n'a pas été toujours simple et linéaire. J'ai vite constaté que la carte Gigamodule était subtilement différente de la majorité des autres cartes Blackfin et que mes outils n'étaient pas tous compatibles entre eux. Ainsi, j'ai passé un temps considérable à modifier mes outils, les exemples de codes et les programmes à utiliser pour les faire fonctionner sur un BF532 et le Gigamodule. Au final, je n'ai pas atteint le point d'avoir U-Boot parfaitement fonctionnel sur le Blackfin, même si je suis très près du but. Comme vous avez pu le constater plus haut dans ce document, j'ai réussi à faire tourner U-Boot en RAM avec succès. Ce fut une grande satisfaction pour moi après tous les efforts déployés! Par contre, même si je peux écrire avec succès la Flash et que je sais que le Blackfin la lit au départ (confirmé à l'analyseur logique), je n'obtiens pas de fonctionnement. Au démarrage, j'obtiens cela sur le terminal: <cadre> Ö ƒ])äFIN>

Ce qui ressemble à du garbage et à un prompt. Il me semble évident que la solution est tout prêt et que j’ai probablement une erreur stupide dans mon travail qui conduit à ce résultat. Par contre, j’ai du travailler sur d’autres tâches plus importantes et mon travail est donc resté à ce point.

Observations et pistes de solution possibles

Bien que je n’ai pas trouvé la solution exacte à mon problème, j’ai plusieurs pistes de solution en tête.

Observation 1 : Lorsque je débogue avec le JTAG le programme démarré depuis la Flash, il se rend jusqu’à la ligne 204 de serial.h, où il reste éternellement. J’ai mon output bidon entre l’initialisation et cette fameuse ligne 204.

Observation 2 : Autant dans mon script GDB que dans U-Boot, j’ai SDGCTL = 0x809110CD. Par contre, un dump_ebiu me retourne 0x80111OCD. Est-ce que ma configuration serait mauvaise ?

Soupçon 1 : Je soupçonne le ICEBear d’initialiser certains registres différemment de U-Boot, ce qui expliquerait que si je charge le programme en RAM il s’exécute correctement.

Soupçon 2 : Après avoir consulté la documentation du BlackStamp, il semble qu’un problème de mauvaise initialisation de la SDRAM cause exactement ce problème. Leur procédure n’est pas adaptée à notre version de U-Boot, il faudra enquêter. http://blackfin.uclinux.org/gf/project/blackstamp/frs/

Piste de solution 1 : Corriger l’erreur de SDGCTL (confirmer les valeurs, s’assurer qu’elles soient programmées correctement).

Piste de solution 2 : Tester à plus basse fréquence pour diminuer de potentiels problèmes liés au PCB.

Piste de solution 3 : Travailler avec la dernière version de U-Boot, qui incorpore un nouveau système de gestion des Flash SPI.

Pour le moment, l’équipe [Robot22] a le projet entre les mains et devrait surpasser cette erreur. Quand la solution sera trouvée, elle sera ajoutée à ce document. Si vous croyez détenir la solution ou une explication à ces problèmes, je vous serais très reconnaissant de me contacter.

Sommaire de mon expérience

Mon parcours aura été semé d’embûches tout au long de mon développement. Premièrement, ma connaissance limitée de l’environnement Linux et de l’usage de la console m’a fortement ralenti, surtout lorsque j’étais incapable de suivre les exemples trouvés en ligne pour cause de problèmes de dépendances ou d’incompatibilités entre les différentes saveurs et versions de Linux. Mon environnement de développement initial, composé de 2 PC et de trois systèmes d’exploitation n’était en aucun point optimal, mais il m’a permis de progresser. Ce n’est que quand j’ai commencé cette documentation que j’ai réalisé plusieurs de mes erreurs et que j’ai appris à les surmonter. Je ne vous cacherai pas que de tout faire fonctionner sur Ubuntu est plus compliqué que sur Debian Etch mais les avantages compensent : un seul système, plus rapide, plus stable et moderne, moins de problèmes d’échanges de périphériques et simplicité accrue. Il existe une grande quantité de documentation en ligne qui couvre la majorité des sujets traités dans ce document. Par contre, dès que l’on utilise du matériel non standard, les informations sont rares ou inexistantes. J’espère qu’avec cette documentation je pourrai aider quelques personnes, qui seraient dans une situation similaire à la mienne, à progresser plus rapidement. Cette expérience aura été très formatrice pour moi. Bien que je n’ai pas atteint tout à fais mon but, j’ai appris beaucoup sur le développement sous Linux, sur l’environnement Blackfin et sur les projets open-source U-Boot et µCLinux.

Annexe A: Sources

Afin de pouvoir d’analyser les modifications que j’ai effectuées aux sources des différents programmes modifiés, il vous est possible des les télécharger aux adresses suivantes :

Répertoire principal

Sources modifiés BFLoader

Sources modifiés Blinky

Sources modifiés U-Boot

Outil de conversion Atmel

Pour comparer mes sources modifiés aux originaux, vous pouvez installer l’excellent logiciel Diffuse qui vous permet de voir deux fichiers et de comparer les différences facilement :

root@jfduval-desktop:/home/jfduval# apt-get install diffuse

Annexe B: Documentation et liens

IntRoLab

Documentation JFDuval – IntRoLab :

Cet article complet sur le web

Cet article complet en PDF

Sources

Outils Section5 :

Site principal Section5

Forum Section5

Manuel ICEBear

U-Boot et µCLinux :

Blackfin Koop

Wiki Blackfin Koop

Wiki U-Boot

Forum U-Boot

Readme U-Boot :. .../u-boot-1.1.6-2008R1.5/README

µCLinux

Getting started with µCLinux

Divers :

Blackfin

Datasheet BF532

Manuel BF532

Projets et produits :

CData SBC

Camsig

Blackfin Stamp

Astfin

Annexe C: Remerciements

Je tiens à remercier en particulier trois personnes qui m’ont aidé dans mon développement et qui m’ont permis de progresser vers mon but.

• Dominic Létourneau d’IntRoLab, pour son aide et ses conseils
• Martin Strubel de Section5 pour son support par forum et courriel
• Mike Frysinger pour ses réponses sur les forums de U-Boot