Category Archives: mini2440

Creación de una imagen Emdebian para tu FriendlyArm

0
Posted by javieralso on 22 Julio 2010 – 13:08
Filed under ARM, Debian, Embedded, GNU, mini2440
Tagged as , , ,

Introducción

Emdebian es una distribución Debian especialmente diseñada para dispositivos empotrados. Su principal característica radica en el poco espacio que ocupa la distribución.

Emdebian ofrece una Toolchain, un conjunto de herramientas de compilación cruzadas para crear paquetes para nuestra plataforma y repositorios con paquetes que ofrecen soporte a arquitecturas arm, ia64, m68k, mips, mipsel, powerpc y sparc. La instalación puede realizarse desde una máquina Debian con una arquitectura distinta a la arquitectura destino sin ningún tipo de problema utilizando debootstrap o, como se hará en ésta receta, utilizando multistrap, que permite crear un sistema nuevo utilizando varios repositorios y echando mano de apt y dpkg para solucionar posibles conflictos.

Qué necesitamos

Pues como he dicho anteriormente, utilizaremos multistrap, así que nos lo instalamos en nuestra máquina (ya sabeís, apt-get o aptitude bla, bla, bla…).

Además, supondremos que seguimos las recetas anteriores sobre cómo compilar Linux para mini2440 y sobre cómo configurar u-boot para arrancar el sistema desde una micro-sd.

Deberemos tener una tarjeta microSD con dos particiones, una para el núcleo y otra que dejaremos para el sistema (como se explicó en la receta sobre la compilación de Linux). Tendremos el árbol de directorios resultante de la compilación de Linux, pues lo necesitaremos para instalar los módulos del núcleo.

Creación de la imagen

Como se comentó anteriormente, utilizaremos multistrap para crear la imagen de emdebian. Para ejecutar multistrap antes deberemos crear un archivo de configuración en el que especificaremos los repositorios desde los que descargaremos los paquetes, la arquitectura destino y el directorio que se utilizará como destino para la instalación, entre otras cosas. El archivo que he utilizado yo es el siguiente:

  1. [General]
  2. arch=armel
  3. directory=multistrap
  4.  
  5. #cleanup=true
  6. # same as –no-auth option if set to true
  7. # keyring packages listed in each debootstrap will
  8. # still be installed.
  9. noauth=false
  10. # extract all downloaded archives (default is true)
  11. unpack=true
  12. # aptsources is a list of sections to be used for downloading packages
  13. # and lists and placed in the /etc/apt/sources.list.d/multistrap.sources.list
  14. # of the target. Order is not important
  15. aptsources=Emdebian
  16. # the order of sections is not important.
  17. # the debootstrap option determines which repository
  18. # is used to calculate the list of Priority: required packages.
  19. debootstrap=Debian Emdebian
  20.  
  21. [Emdebian]
  22. packages=ifupdown udev procps netbase vim-tiny module-init-tools wget openssh-server screen apmd
  23. source=http://www.emdebian.org/grip/
  24. keyring=emdebian-archive-keyring
  25. suite=squeeze main
  26.  
  27. [Debian]
  28. packages=
  29. source=http://ftp.uk.debian.org/debian
  30. keyring=debian-archive-keyring
  31. suite=squeeze main

La clave arch especifica la arquitectura destino de la distribución, en éste caso armel y la clave directory especifica el directorio destino en el que se desplegará la instalación. En nuestro caso, lo hará dentro del directorio multistrap, subdirectorio del directorio en el que se encuentra nuestro archivo de configuración.

Es importante que la clave cleanup esté comentada (o puesta a false). Ésto hará que la caché de apt no se limpie tras la instalación, pues necesitaremos los paquetes para reinstalarlos en el último paso desde la plataforma destino. El resto de opciones del archivo se pueden ver en la página sobre emdebian, así que no las comentaré aquí.

Guardamos el fichero con el nombre multistrap.conf (por darle algún nombre). Después, podemos instalar:

  1. javieralso@rigoberto:~/emdebian$ ls
  2. multistrap  multistrap.conf
  3. javieralso@rigoberto:~/emdebian$ sudo multistrap –no-auth -f multistrap.conf

Podemos ver que el directorio multistrap en el que quedará instalado emdebian y el archivo de configuración están bajo el mismo directorio. Tras invocar a multistrap podremos ver como se descargan los paquetes y se desempaquetan dentro del directorio multistrap.

Ahora tendremos un sistema muy básico que todavía no es funcional del todo. Tendremos que reinstalar todos los paquetes en el sistema destino, para lo cual deberemos poder logearnos. Como la distribución que tenemos es muy básica, no podremos hacerlo, puesto que /etc/passwd aún no existe, así que nos lo creamos nosotros:

  1. javieralso@rigoberto:~/emdebian$ cd multistrap
  2. javieralso@rigoberto:~/multistrap$ sudo su
  3. rigoberto:/home/javieralso/emdebian/multistrap# echo "root:Npge08pfz4wuk:0:0:root:/root:/bin/bash" > etc/passwd
  4. rigoberto:/home/javieralso/emdebian/multistrap# echo "root:Npge08pfz4wuk:0:" > etc/group
  5. rigoberto:/home/javieralso/emdebian/multistrap#

Como podemos ver, también hemos creado el archivo /etc/group. Recordad tener cuidado con no sobreescribir los archivos de VUESTRA máquina, no la vayais a liar….

Lo que hemos hecho ha sido asignar la contraseña password al usuario root utilizando el formato de contraseña salt/password, aunque para finalizar, aún debemos hacer mas cosas:

  1. rigoberto:/home/javieralso/emdebian/mutistrap# echo "proc /proc proc none 0 0" >>etc/fstab
  2. rigoberto:/home/javieralso/emdebian/multistrap# echo "mini2440" >etc/hostname
  3. rigoberto:/home/javieralso/emdebian/multistrap# mknod dev/console c 5 1
  4. rigoberto:/home/javieralso/emdebian/multistrap# mknod dev/ttySAC0 c 204 64

Después de ésto, empaquetamos el directorio.

  1. rigoberto:/home/javieralso/emdebian/multistrap# tar jcf ../emdebian-grip-071910-armel-debootstrap-squeeze.tar.bz2 .
  2. rigoberto:/home/javieralso/emdebian/multistrap#

Ahora, suponiendo que hemos montado la partición 2 de la tarjeta microSD (donde se supone que vamos a instalar el sistema) en el directorio /media/rootfs, podemos cargar ahí el sistema recién creado:

  1. rigoberto:/home/javieralso/emdebian/multistrap# cd ..
  2. rigoberto:/home/javieralso/emdebian# unp emdebian-grip-071910-armel-debootstrap-squeeze.tar.bz2 /media/rootfs/
  3. rigoberto:/home/javieralso/emdebian#

Instalamos los módulos del núcleo que compilamos en su momento, para eso, nos vamos al directorio mini2440 que creamos en su día y ejecutamos lo siguiente:

  1. javieralso@rigoberto:~/kernel/mini2440# sudo make INSTALL_MOD_PATH=/media/rootfs/  O=../kernel-bin/ modules_install
  2. …………………………………………………………………………………..
  3. …………………………………………………………………………………..
  4. Lots and lots of INSTALL messages
  5. …………………………………………………………………………………..
  6. …………………………………………………………………………………..

Desmontamos la tarjeta, la insertamos en nuestra MINI2440 y arrancamos (conectando el puerto serie de la tarjeta a nuestro PC y arrancando minicom).

Cuando el sistema termine de arrancar, veremos que se para porque no encuentra el archivo /etc/inittab:

  1. …………………………………………………………………………………..
  2. …………………………………………………………………………………..
  3. …………………………………………………………………………………..
  4. …………………………………………………………………………………..
  5. …………………………………………………………………………………..
  6. mmcblk0: mmc0:b368 MSD   1.85 GiB
  7.  mmcblk0: p1 p2
  8. s3c2410-rtc s3c2410-rtc: setting system clock to 2010-07-20 23:14:47 UTC (1279667687)
  9. usb 1-1: new full speed USB device using s3c2410-ohci and address 2
  10. usb 1-1: configuration #1 chosen from 1 choice
  11. kjournald starting.  Commit interval 5 seconds
  12. EXT3-fs warning: maximal mount count reached, running e2fsck is recommended
  13. EXT3 FS on mmcblk0p2, internal journal
  14. EXT3-fs: recovery complete.
  15. EXT3-fs: mounted filesystem with writeback data mode.
  16. VFS: Mounted root (ext3 filesystem) on device 179:2.
  17. Freeing init memory: 136K
  18. INIT: version 2.88 booting
  19. INIT: No inittab file found
  20. Enter runlevel:

Introducimos ‘s’ (single user) y cuando nos pida contraseña introducimos: “password“. De ésta forma tendremos una Shell con permisos de root muy básica, pero con la que podremos terminar de instalar el sistema.

A continuación remontamos el sistema de archivos como sistema de lectura/escritura:

  1. root@(none):~# mount -n / -o remount,rw

y después montamos el sistema de archivos /proc:

  1. root@(none):~# mount -n /proc

Ahora debemos reinstalar todos los paquetes. Aunque los paquetes ya “están” en el disco, debemos “reinstalarlos” para que se genere la base de datos del sistema:

  1. root@(none):~# cd /var/cache/apt/archives
  2. root@(none):/var/cache/apt/archives# dpkg –force-all -i libc6* libstdc++* libncurses5* dpkg_*
  3. ………………………………………………………………………………
  4. ………………………………………………………………………………
  5. lots and lots of installation messages
  6. ………………………………………………………………………………
  7. ………………………………………………………………………………
  8. root@(none):/var/cache/apt/archives# dpkg –force-all -i apt*.deb
  9. ………………………………………………………………………………
  10. ………………………………………………………………………………
  11. lots and lots of installation messages
  12. ………………………………………………………………………………
  13. ………………………………………………………………………………

Una vez que tenemos instalado apt, reinstalamos todos los paquetes configurando la lista selections de dpkg:

  1. root@(none):/var/cache/apt/archives# ls *.deb | sed ‘s/\([^_]*\)_.*/\1 install/’ | dpkg –set-selections
  2. root@(none):/var/cache/apt/archives# apt-get dselect-upgrade
  3. ………………………………………………………………………………
  4. ………………………………………………………………………………
  5. lots and lots of installation messages
  6. ………………………………………………………………………………
  7. ………………………………………………………………………………

Aquí es muy probable que se produzcan errores durante la reinstalación. cuando ésto suceda se vuelve a ejecutar apt-get dselect-upgrade hasta que se termine. Para algunos paquetes es posible incluso que tengas que tocar algo a mano, como por ejemplo para que el paquete base-files pueda instalarse correctamente, que en mi caso me fue necesario eliminar el directorio /var/mail a mano.

En éste punto ya casi hemos terminado. Ahora solo falta activar la consola a través de puerto serie:

  1. root@(none):/var/cache/apt/archives# cd /
  2. root@(none):/# echo ttySAC0 >>etc/securetty
  3. root@(none):/# printf "T0:123:respawn:/sbin/getty 115200 ttySAC0\n" >>etc/inittab

¡Y ya está! Reinicia el sistema y ya tendrás una Debian flamante corriendo en tu MINI2440. ¡¡A disfrutarla!!

  1. …………………………………………………………………………………..
  2. …………………………………………………………………………………..
  3. …………………………………………………………………………………..
  4. …………………………………………………………………………………..
  5. …………………………………………………………………………………..
  6. Mounting local filesystems…done.
  7. Activating swapfile swap…done.
  8. Cleaning up temporary files….
  9. Configuring network interfaces…done.
  10. Cleaning up temporary files….
  11. Setting kernel variables …done.
  12. Running scripts in rcS.d/ took 20 seconds.
  13. INIT: Entering runlevel: 2
  14. Using makefile-style concurrent boot in runlevel 2.
  15. apmd[1110]: apmd 3.2.1 interfacing with apm driver 1.13 and APM BIOS 1.2
  16. Starting Advanced Power Management daemon….
  17. Running scripts in rc2.d/ took 2 seconds.
  18. Debian GNU/Linux squeeze/sid MINI2440 ttySAC0
  19. MINI2440 login: root
  20. Password:
  21. Last login: Wed Jul 21 01:14:00 CEST 2010 on ttySAC0
  22. Linux MINI2440 2.6.32-rc8 #1 Mon Dec 7 16:07:52 CET 2009 armv4tl
  23. The programs included with the Debian GNU/Linux system are free software;
  24. the exact distribution terms for each program are described in the
  25. individual files in /usr/share/doc/*/copyright.
  26. Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
  27. permitted by applicable law.
  28. root@MINI2440:~#

Y después…

Lo próximo es la creación de una imagen opie utilizando openembedded.

Referencias

NOTA: Entrada extraída de otra antigua entrada publicada por mi en CrySoL.

ARM mini2440: Configurando uBoot para arranque desde SD para FriendlyArm

0
Posted by javieralso on 31 Diciembre 2009 – 14:39
Filed under ARM, Embedded, mini2440
Tagged as , ,

Introducción

Después de haber compilado e instalado uBoot en nuestra tarjeta de desarrollo mini2440 y de haberle compilado una imágen Linux ahora nos proponemos configurar uBoot para el arranque de dicho kernel.
uBoot permite mucha flexibilidad a la hora de instalar y arrancar imágenes desde la memoria. Aún así, aquí sólo explicaré el procedimiento que he utilizado yo para poder cargar y ejecutar Linux desde una tarjeta SD, ya que además de parecerme los mas fácil y cómodo a la hora de actualizar (tan solo hay que copiar la nueva imagen a la SD), mantendremos intacta la NAND interna de nuestra tarjeta, que sabemos que tiene vida limitada, y aunque muy larga, no deja de ser eso, limitada.

Qué necesitamos

Pues como dije antes, se supone que debemos de haber leído, comprendido y ejecutado las dos recetas que se mencionan mas arriba.
De la segunda receta obtenemos la imagen del núcleo que vamos a utilizar en nuestra tarjeta, uImage.
A continuación, hay que preparar la tarjeta de memoria. Yo en mi caso tengo una partición ext3 de unos 128MB que utilizo para tal fin. Lo del tamaño no importa mucho (ejem), pero nunca por mucho trigo fue mal año (ejem, ejem), así que si nos sobra espacio, podremos utilizarlo para guardar ahí backups y cosas de esas (es lo que yo hago).
También es aconsejable que dicha partición se la primera particion de la unidad (primaria, claro está), ésto no es muy crítico, pero mi configuración tiene ésto en cuenta, con lo cual si situas la partición en otro sitio, deberás especificarlo en la configuración.
Evidentemente no me voy a poner a explicar cómo hacer dicha partición, ya somos todos muy grandecitos para hacerlo solitos, así que cuando termines, te espero mas abajo…

Configurando uBoot

Una vez que tienes la partición hecha, copias la imagen uImage que compilaste en su día a dicha partición e insertas la tarjeta en el lector de tu mini2440. Conectas el puerto serie, abres minicom con la configuración que usaste para instalar uBoot y arrancas. Cuando salga el mensaje de que pulses una tecla para cancelar el arranque procedes:

  1. U-Boot 1.3.2-mini2440 (Oct 15 2009 – 19:42:55)                                                      
  2. I2C:   ready
  3. DRAM:  64 MB
  4. Flash:  2 MB
  5. NAND:  128 MiB
  6. Found Environment offset in OOB..
  7. USB:   S3C2410 USB Deviced
  8. In:    serial
  9. Out:   serial
  10. Err:   serial
  11. MAC: 08:08:11:18:12:27
  12. Hit any key to stop autoboot:  0
  13. MINI2440 #

Lo primero que vamos a hacer, para asegurarnos de que todo va sobre ruedas, es hacer el arranque “a mano”, de modo que sepamos exactamente qué parámetros tenemos que dar a uBoot para que cargue correctamente nuestro núcleo. Una vez que ya sepamos estos parámetros, configuraremos uBoot correctamente para que se haga todo de forma automática cada vez que encendamos nuestra tarjeta. Algunos de los comandos que se mostrarán ahora ya nos sonarán de la receta en la que instalamos uBoot, aún así los volveré a explicar ahora.
Lo primero es inicializar la tarjeta SD:

  1. MINI2440 # mmcinit
  2. trying to detect SD Card…
  3. Manufacturer:       0x1b, OEM "SM"
  4. Product name:       "UD   ", revision 1.0
  5. Serial number:      2697000253
  6. Manufacturing date: 12/2006
  7. CRC:                0×78, b0 = 1
  8. READ_BL_LEN=15, C_SIZE_MULT=7, C_SIZE=3453
  9. size = 2329935872
  10. MINI2440 #

Una vez que la tarjeta ha sido detectada e inicializada correctamente, se carga la imagen:

  1. MINI2440 # ext2load mmc 0:1 0×32000000 uImage
  2. 2148500 bytes read
  3. MINI2440 #

Lo que hemos hecho ha sido decirle a uBoot que cargue el archivo uImage que se encuentra en la partición 1 de la tarjeta 0 (0:1) cuyo tipo es extX (ext2load) a partir de la dirección de memoria 0×32000000. Recordemos que en ésta imagen ya definimos el entrypoint, entre otras cosas, por lo que no necesitaremos definirlo mas.
Ahora ya solo queda arrancar:

  1. MINI2440 # bootm
  2. ## Booting kernel from Legacy Image at 32000000 …
  3.    Image Name:   Angstrom/2.6.31+git/mini2440
  4.    Created:      2009-12-10   4:50:52 UTC
  5.    Image Type:   ARM Linux Kernel Image (uncompressed)
  6.    Data Size:    2148436 Bytes =  2 MB
  7.    Load Address: 30008000
  8.    Entry Point:  30008000
  9.    Verifying Checksum … OK
  10.    Loading Kernel Image … OK
  11. OK
  12. Starting kernel …
  13. <Lots and lots of logs….>
  14. Failed to execute /sbin/init.  Attempting defaults…
  15. Kernel panic – not syncing: No init found.  Try passing init= option to kernel.
  16. [<c002b4c8>] (unwind_backtrace+0×0/0xdc) from [<c0301dd0>] (panic+0×34/0×118)
  17. [<c0301dd0>] (panic+0×34/0×118) from [<c0026544>] (init_post+0×134/0x16c)
  18. [<c0026544>] (init_post+0×134/0x16c) from [<c00085c4>] (kernel_init+0xd8/0x10c)
  19. [<c00085c4>] (kernel_init+0xd8/0x10c) from [<c00277d8>] (kernel_thread_exit+0×0/0×8)

Como podemos observar, el núcleo ha arrancado correctamente aunque veamos un nunca bienvenido kernel panic. Éste es debido a que no tenemos sistema alguno instalado, con lo cual, cuando el kernel termina de cargar e inicializar el sistema no es capaz de lanzar el proceso Init, con lo que se detiene.
De momento no lo necesitamos, éso será el contenido de una próxima receta. Con que arranque el núcleo nos daremos por satisfechos :-P .
Puesto que ya hemos visto que nuestra configuración funciona, la guardamos:

  1. MINI2440 # setenv bootcmd ‘mmcinit; fat2load mmc 0:1 0×32000000 uImage; bootm’
  2. MINI2440 # saveenv
  3. Saving Environment to NAND…
  4. Erasing Nand…Writing to Nand… done

El comando setenv sirve para asignar valores a las variables de entorno de uBoot. En éste caso configuramos la variable bootcmd que es la que contiene los comandos que se ejecutarán en el arranque. Dichas instrucciones son las que probamos anteriormente para la carga del núcleo.
saveenv como su nombre indica, sirve para hacer persistente el contenido de las variables de entorno, de forma que esten ahí cada vez que arranquemos la tarjeta.
Con ésto ya debería ser suficiente para que tu núcleo arranque correctamente, pero ya que estamos metidos con uBoot vamos a hacer algo mas: Vamos a configurarlo para decirle en qué partición de la tarjeta tenemos instalado el sistema, así como con qué parámetros debe de arrancar el núcleo, ya que con los que arranca por defecto probablemente no tengamos acceso a un terminal desde el puerto serie (cosa que a veces puede ser muy útil).
Para esto deberemos tocar otra variable de entorno, en éste caso bootargs que contiene los parámetros que son pasados al kernel:

  1. MINI2440 # setenv bootargs ‘root=/dev/mmcblk0p2 rootwait=4 rw init=/sbin/init noinitrd console=ttySAC0,115200′
  2. MINI2440 # saveenv
  3. Saving Environment to NAND…
  4. Erasing Nand…Writing to Nand… done

Lo que hemos hecho ha sido decirle que tenemos el sistema instalado en la partición 2 de la tarjeta SD (boot=/dev/mmcblk0p2), la ruta de init, y desde donde se puede acceder a la consola y a qué velocidad.
La partición que se ha indicado como partición del sistema deberá ser forzosamente ext3, así que recomiendo que el espacio que te sobró en tu SD lo dediques a una partición para el sistema (cuando haga la preceptiva receta :-P ).
Ahora podemos ver el contenido de nuestras variables de entorno:

  1. MINI2440 # printenv
  2. bootdelay=3
  3. baudrate=115200
  4. ethaddr=08:08:11:18:12:27
  5. ipaddr=10.0.0.111
  6. serverip=10.0.0.4
  7. netmask=255.255.255.0
  8. usbtty=cdc_acm
  9. mini2440=mini2440=0tb
  10. bootargs_base=console=ttySAC0,115200 noinitrd
  11. bootargs_init=init=/sbin/init
  12. root_nand=root=/dev/mtdblock3 rootfstype=jffs2
  13. root_mmc=root=/dev/mmcblk0p2 rootdelay=2
  14. root_nfs=/mnt/nfs
  15. set_root_nfs=setenv root_nfs root=/dev/nfs rw nfsroot=${serverip}:${root_nfs}
  16. ifconfig_static=run setenv ifconfig ip=${ipaddr}:${serverip}::${netmask}:mini2440:eth0
  17. ifconfig_dhcp=run setenv ifconfig ip=dhcp
  18. ifconfig=ip=dhcp
  19. set_bootargs_mmc=setenv bootargs ${bootargs_base} ${bootargs_init} ${mini2440} ${root_mmc}
  20. set_bootargs_nand=setenv bootargs ${bootargs_base} ${bootargs_init} ${mini2440} ${root_nand}
  21. set_bootargs_nfs=run set_root_nfs; setenv bootargs ${bootargs_base} ${bootargs_init} ${mini2440} ${root_nfs} ${ifconfig}
  22. mtdids=nand0=mini2440-nand
  23. mtdparts=mtdparts=mini2440-nand:256k(u-boot),128k(u-boot_env),5m(kernel),125568k(rootfs)
  24. bootargs=root=/dev/mmcblk0p2 rootwait=4 rw init=/sbin/init noinitrd console=ttySAC0,115200
  25. "ootcmd="mmcinit
  26. filesize=20C8EC
  27. partition=nand0,0
  28. mtddevnum=0
  29. mtddevname=u-boot
  30. bootcmd=mmcinit; fat2load mmc 0:1 0×32000000 uImage; bootm
  31. Environment size: 1209/131068 bytes
  32. MINI2440 #

Ahí podremos ver el contenido de todas las variables de entorno de uBoot. Aparte de las explicadas hay algunas interesantes como por ejemplo ifconfig que sirve para configurar si queremos que ejecute un cliente dhcp al arranque o si queremos darle una ip estática, bootdelay , que sirve para configurar el retardo en el arranque o baudrate, que como podemos imaginar, sirve para configurar la velocidad del puerto serie.
Si reiniciamos ahora nuestra mini2440, podremos ver que arranca el núcleo perfectamente, aunque sin sistema poco podemos hacer… Paciencia…. :-D

Referencias

NOTA: Entrada extraída de otra antigua entrada publicada por mi en CrySoL.

ARM mini2440: Compilando Linux para FriendlyArm

0
Posted by javieralso on 31 Diciembre 2009 – 13:34
Filed under ARM, Embedded, mini2440
Tagged as , ,

Introducción

En una entrada anterior escribí sobre cómo compilar e instalar u-boot en una tarjeta mini2440. Ahora voy a explicar cómo compilar un núcleo Linux para ésta misma plataforma. En una próxima receta tengo intención de explicar los pasos para configurar u-boot y hacer arrancable éste núcleo en nuestra amada tarjeta. De momento, vamos lo que interesa: El núcleo.

Descargando los fuentes

Los fuentes del núcleo ya parcheados para su uso en nuestra arquitectura los descargamos de su repositorio git:

  1. javieralso@rigoberto:~$ mkdir kernel ; cd kernel
  2. javieralso@rigoberto:~$ git clone git://repo.or.cz/linux-2.6/mini2440.git
  3. javieralso@rigoberto:~$ mkdir kernel-bin
  4. javieralso@rigoberto:~$ cd mini2440

Con ésto ya tendremos creada la jerarquía de directorios necesaria y los fuentes descargados.
Para la compilación, usaré la misma toolchain que utilicé en la receta sobre u-boot, así que después de leerla y configurar la toolchain contiuaremos.

Lo primero que necesitaremos es crear el archivo de configuración (.config) con las opciones del núcleo. Suponiendo que estamos en el directorio mini2440 creado anteriormente, ejecutamos

  1. javieralso@rigoberto:~$ CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make O=../kernel-bin/ mini2440_defconfig

Ésto generará la configuración a partir de una template existente en los propios fuentes y prácticamente no tendremos que tocar nada mas.

Configuración del display

En el código descargado existe un bug que hace que la imagen mostrada en el display aparezca desplazada 13 pixeles hacia la derecha. Preguntándo a Google encontré cómo arreglarlo. La solución pasa por editar en uno de los fuentes los parámetros de configuración del display. Sé que hubiese resultado mas cómodo generar el parche y ponerlo aquí sin mas para que se aplique, pero así explico con un poco mas de detalle que es lo que hay que hacer, no sea que alguien utilice otro tipo de display y tenga que editar de forma distinta los fuentes.

El archivo a editar es mini2440/arch/arm/mach-s3c2440/mach-mini2440.c. Aquí, entre otras cosas, se inicializan muchas de las estructuras utilizadas por el núcleo con parámetros específicos de nuestra arquitectura. En nuestro caso habrá que modificar los parámetros del display TFT de 3’5″ con touchscreen, que es el que tengo yo. En otro caso y dependiendo del display que tengas tu, puede que tengas que modificar o no dicho archivo con distintos parámetros.

Buscamos el siguiente código (a partir de la línea 227):

  1. …………………………………
  2. …………………………………
  3. static struct s3c2410fb_display mini2440_lcd_cfg[] __initdata = {
  4.         [0] = { /* mini2440 + 3.5" TFT + touchscreen – old model "N35" */
  5.                 _LCD_DECLARE(
  6.                         7,                      /* The 3.5 is quite fast */
  7.                         240, 21, 38, 6,         /* x timing */
  8.                         320, 4, 4, 2,           /* y timing */
  9.                         60),                    /* refresh rate */
  10. ………………………………..
  11. ………………………………..

Cómo podemos observar, este fragmento corresponde al display de 3’5″ con touchscreen del mini2440 (seleccionado por defecto en la configuración que creamos anteriormente). Dentro de los parámetros x timing, cambiamos el valor 38 por 25, restando así el offset de 13 pixels que hay en el eje X del display.
El código entonces deberá quedar tal que así:

  1. …………………………………
  2. …………………………………
  3. static struct s3c2410fb_display mini2440_lcd_cfg[] __initdata = {
  4.         [0] = { /* mini2440 + 3.5" TFT + touchscreen – old model "N35" */
  5.                 _LCD_DECLARE(
  6.                         7,                      /* The 3.5 is quite fast */
  7.                         240, 21, 25, 6,         /* x timing */
  8.                         320, 4, 4, 2,           /* y timing */
  9.                         60),                    /* refresh rate */
  10. ………………………………..
  11. ………………………………..

Repito, ésto está probado para mi display, si tu display es distinto, deberás buscar la sección correspondiente en el archivo y “ajustarlo” según tus necesidades.

Una vez editado, proseguimos con la compilación.

Compilando

Después de generada la configuración y arreglado el pequeño bug del que hablé antes, ya podemos compilar:

  1. javieralso@rigoberto:~$ CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make O=../kernel-bin/

Y a esperar (no mucho, un café mientras ves el youtube :D ).

Suponiendo que ya has terminado de compilar y todo ha ido a las mil maravillas, ahora toca crear la imagen que u-boot cargará y arrancará. Para ello utilizamos la herramienta mkimage que podemos encontrar en el directorio tools de la distribución u-boot que compilamos en su momento.

el comando a introducir será el siguiente:

  1. avieralso@rigoberto:~$ mkimage -A arm -O linux -T kernel -C none -a 0×30008000 -e 0×30008000 -d ../kernel-bin/arch/arm/boot/zImage ./uImage

Deberemos usar el path completo a mkimage si no lo tenemos en nuestro path.

Éste comando crea una imagen para arm (-A arm), sistema operativo linux y tipo de imagen un núcleo. Además, no se usará compresión (-O linux -T kernel -C none). La imagen creada será cargada por u-boot a partir de la dirección 0×30008000 y el punto de entrada (dirección a partir de la cual arranca la imagen) será la misma dirección (-a 0×30008000 -e 0×30008000).
La imagen se llamará uImage y quedará almacenada en el directorio actual.

Lo próximo…

En una próxima receta explicaré la configuración de u-boot poniendo como ejemplo la instalación de nuestra imagen para que sea cargada desde una tarjeta microSD (o desde donde queramos).
Después explicaré como compilar desde cero una imagen de opie utilizando la toolchain de openembedded e instalarla, junto con las librerías generadas durante la compilación de éste núcleo.
Finalmente hablaré sobre como compilar una aplicación para opie utilizando bitbake, el script de compilación automatizado de openembedded.

Referencias

Como siempre muchísimas, pero la principal, de la que lo he seguido todo, ha sido el siguiente enlace:

Un saludo

NOTA: Entrada extraída de otra antigua entrada publicada por mi en CrySoL.

Instalando uBoot en una mini2440 (Friendlyarm)

2
Posted by javieralso on 24 Octubre 2009 – 14:08
Filed under ARM, Embedded, GNU, mini2440
Tagged as , , ,

Introducción

Como he comentado anteriormente, u-boot es un bootloader totalmente libre para dispositivos empotrados de bajo poder computacional. Entre sus múltiples posibilidades, están las de particionar la memoría flash del dispostivo en el que se encuentre corriendo, asignar nombre a dichas particiones, cargar imágenes en RAM desde distintas fuentes, volcarlas a flash, y un largo etcétera….
Aquí hablaré de las opciones que a mi juicio pueden ser mas socorridas para la instalación de un Sistema Operativo en un dispositivo empotrado, en mi caso, tomando como ejemplo la tarjeta de desarrollo mini2440 comentada anteriormente, aunque como es de suponer, las mismas operaciones pueden ser realizadas en distintas plataformas hardware.
Así pues vamos a lo divertido del asunto ¡¡Empezamos!!

Instalando

El proceso de instalación de u-boot consiste básicamente en cargar una imagen de u-boot en la RAM de nuestrá máquina, bien a través de su propio bootloader, bien a través de un JTAG. Una vez cargado en RAM, se lanza y se le dice que se (auto)guarde en la flash de nuestra tarjeta. En este caso y dependiendo de nuestro hardware, puede sobreescribir a su bootloader original o bien coexistir con él. En cualquier caso, deberás consultar el manual de tu tarjeta para comprobarlo.

Para el caso de la MINI2440, ésta viene con dos memorias Flash distintas: por un lado hay una flash NOR de 2MB en la que se encuentra almacenado el bootloader específico para los micros de Samsung (mirco de mi tarjeta de desarrollo): supervivi. Por otro lado, tenemos una memoria flash NAND de 128MB en la que se supone que irá nuestro sistema. En ésta memoria será en la que instalaremos u-boot, configurando posteriormente nuestra mini2440 para que arranque desde ahí (utilizando un conmutador que a tal efecto lleva instalado).

Para comenzar, necesitaremos descargarnos tanto el código fuente de u-boot como el software necesario para poder comunicarnos con supervivi y un compilador cruzado para ARM:

* u-boot:

  1. javieralso@rigoberto:~$ mkdir uboot; cd uboot
  2. javierlaso@rigoberto:~$ git clone git://repo.or.cz/u-boot-openmoko/mini2440.git
  3.  

* toolchain: Compiladores cruzados para ARM los hay muchos en esto de GNU. Yo, que seguí al dedillo todo lo que leí en montónes de blogs, usé el siguiente:

  1. javieralso@rigoberto:~$ wget http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2
  2. javieralso@rigoberto:~$ unp  arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2
  3. javieralso@rigoberto:~$ export PATH=$PATH:/home/rigoberto/arm-2008q3/bin

* Friendlyarm package: Se trata de un paquete con un uploader ya compilado para comunicarse con supervivi y de una imagen ya compilada de u-boot, que deberemos utilizar para cargar la imagen que compilemos nosotros. El por qué de usar dos imágenes de u-boot se explicará mas adelante.

  1. javieralso@rigoberto:~$ wget http://www.kernelconcepts.de/~fuchs/micro2440/friendlyarm2440-package.tar.bz2
  2. javieralso@rigoberto:~$ unp friendlyarm2440-package.tar.bz2

Una vez que lo tenemos todo descargado, empezaremos por compilar el bootloader, para ello no debemos olvidar añadir a nuestro PATH la ruta en la que se encuentran los binarios de la toolchain que usemos (como hicimos anteriormente). Una vez hecho esto, podemos pasar a compilar:

  1. javieralso@rigoberto:~$ cd uboot/mini2440
  2. javieralso@rigoberto:uboot/mini2440$ export CROSS_COMPILE=arm-none-linux-gnueabi-
  3. javieralso@rigoberto:uboot/mini2440$ make mini2440_config; make

Después de no mucho tiempo y si todo ha ido bien, deberemos tener un archivo llamado u-boot.bin en la carpeta donde hemos llevado a cabo la compilación. Esa es la imagen de u-boot que se almacenará en la flash de nuestra tarjeta, pero para poder llevar a cabo dicho proceso, necesitaremos otra versión de u-boot (sé que suena bastante raro, y de hecho lo es. Mas adelante explicaré el por qué de ello).

Bueno, llegados a este punto, cogemos nuestra mini2440, deslizamos el conmutador superior hacia la izquierda (para configurar el arranque desde la NOR), conectamos un módem nulo desde su puerto serie a un puerto serie de nuestra máquina y el device USB a un puerto USB libre. Tras ésto, arramcamos minicom y configuramos el puerto serie a 115200 Baudios, 8N1 y sin ningún tipo de contol de flujo.
Hecho ésto, solo queda encender nuestra tarjeta y comprobar que supervivi arranca:

  1. ##### FriendlyARM BIOS for 2440 #####
  2. [x] bon part 0 320k 2368k
  3. [v] Download vivi
  4. [k] Download linux kernel
  5. [y] Download root_yaffs image
  6. [c] Download root_cramfs image
  7. [a] Absolute User Application
  8. [n] Download Nboot
  9. [e] Download Eboot
  10. [i] Download WinCE NK.nb0
  11. [w] Download WinCE NK.bin
  12. [d] Download & Run
  13. [z] Download zImage into RAM
  14. [g] Boot linux from RAM
  15. [f] Format the nand flash
  16. [p] Partition for Linux
  17. [b] Boot the system
  18. [s] Set the boot parameters
  19. [t] Print the TOC struct of wince
  20. [u] Backup NAND Flash to HOST through USB(upload)
  21. [r] Restore NAND Flash from HOST through USB
  22. [q] Goto shell of vivi
  23. Enter your selection:

Seleccionamos la opción q para acceder a la shell de superivi y después le diremos que queremos cargar una imagen en la memoria y arrancar, pero para ello, antes deberemos saber cuando ocupa el bootloader que vamos a cargar (el que ya viene compilado), así que volvemos a la carpeta en la que lo descomprimimos y lo comprobamos:

  1. javieralso@rigoberto:friendlyarm2440-package$ ls -l
  2. …………………..
  3. …………………..
  4. -rwxr-xr-x   1 javieralso javieralso 239016 oct 24 11:38 u-boot.bin
  5. …………………..
  6. …………………..

Podemos ver que ocupa 239016 bytes. Guardamos este dato, nos será util para lo que comentamos anteriormente.

  1. Enter your selection:q
  2. Supervivi> load flash 0 239016 u
  3. USB host is connected. Waiting a download.

Con esto le hemos dicho a supervivi que queremos cargar 239016 bytes de datos (observad que es la misma cantidad de bytes que ocupa la imagen de u-boot) en la RAM de la tarjeta. Ahora supervivi se ha quedado esperando los datos, que deberemos envíarselos vía USB. Habiendo conectado el cable USB como se indicó antes ejecutamos el uploader:

  1. javieralso@rigoberto: friendlyarm2440-package$ sudo ./s3c2410_boot_usb u-boot.bin

que deberá ser llamado desde la carpeta friendlyarm2440-package y con sudo para poder tener acceso al puerto USB.

Si todo ha ido bien, supervivi debería mostar algo como esto:

  1. Now, Downloading [ADDRESS:30000000h,TOTAL:232706]
  2. RECEIVED FILE SIZE:  239016 (28KB/S, 8S)
  3. Downloaded file at 0×30000000, size = 232696 bytes
  4. Found block size = 0x0003c000
  5. Erasing…    … done
  6. Writing…    … done
  7. Written 239016 bytes
  8. Supervivi>

Ahora, arrancamos u-boot:

  1. Supervivi> go 0×30000000

y ya está, nuestra tarjeta arrancará u-boot:

  1. U-Boot 1.3.2-mini2440 (May 15 2009 – 21:24:49)
  2. I2C:   ready
  3. DRAM:  64 MB
  4. Flash:  2 MB
  5. NAND:  Bad block table not found for chip 0
  6. Bad block table not found for chip 0
  7. 64 MiB
  8. *** Warning – bad CRC or NAND, using default environment
  9. USB:   S3C2410 USB Deviced
  10. In:    serial
  11. Out:   serial
  12. Err:   serial
  13. MAC: 08:08:11:18:12:27
  14. Hit any key to stop autoboot:  0

Lo primero que ha hecho u-boot al arranchar ha sido darnos un mensaje de alerta indicando que el contenido de las variables de entorno no está fijado y de ahí el error CRC que se ve. Éstas variables de entorno son necesarias para que u-boot pueda configurarse al arrancar, pero antes de crearlas debemos de preparar la memoria NAND.

Para preparar la NAND, lo primero que haremos será borrar el listado de sectores defectuosos y volver a crearlo nosotros. Los sectores defectuosos son una lista, generalmente almacenada en fábrica, que indica qué sectores de la NAND son defectuosos. Lo normal es que haya alguno y con el tiempo y el uso se irán incrementando.

  1. MINI2440 # nand scrub
  2. NAND scrub: device 0 whole chip
  3. Warning: scrub option will erase all factory set bad blocks!
  4.          There is no reliable way to recover them.
  5.          Use this command only for testing purposes if you
  6.          are sure of what you are doing!
  7. Really scrub this NAND flash? <y/N>
  8. Erasing at 0x33d4000 —  81% complete.
  9. NAND 64MiB 3,3V 8-bit: MTD Erase failure: -5
  10. Erasing at 0x3ffc000 — 100% complete.
  11. Bad block table not found for chip 0
  12. Bad block table not found for chip 0
  13. OK
  14. MINI2440 #

Con el comando anterior borramos la lista de sectores defectuosos antes mencionada. Después de haber hecho la limpieza, creamos nuestra propia tabla (también conocida como BBT):

  1. MINI2440 # nand createbbt
  2. Create BBT and erase everything ? <y/N>
  3. Skipping bad block at  0×03410000                                            
  4. Skipping bad block at  0x03ff0000                                            
  5. Skipping bad block at  0x03ff4000                                            
  6. Skipping bad block at  0x03ff8000                                            
  7. Skipping bad block at  0x03ffc000                                            
  8. Creating BBT. Please wait …Bad block table not found for chip 0
  9. Bad block table not found for chip 0
  10. Bad block table written to 0x03ffc000, version 0×01
  11. Bad block table written to 0x03ff8000, version 0×01

Este proceso es relativamente lento, por lo que habrá que esperar que esperar (3-4 minutillos), así que mientras tanto, busca una tarjeta SD y copia el binario u-boot.bin QUE COMPILASTE en dicha tarjeta. La cargaremos desde ahí.

Una vez que tenemos nuestra SD con el binario cargado y que ya se ha generado la nueva BBT, introducimos la tarjeta en el lector de la mini2440 y le decimos a u-boot que la detecte:

  1. MINI2440 # mmcinit
  2. trying to detect SD Card…
  3. Manufacturer:       0×30, OEM "SD"
  4. Product name:       "SU02G", revision 8.0
  5. Serial number:      3489032
  6. Manufacturing date: 9/2010
  7. CRC:                0×27, b0 = 1
  8. READ_BL_LEN=15, C_SIZE_MULT=7, C_SIZE=365
  9. size = 1642070016

Con la tarjeta ya detectada, cargamos u-boot.bin en la RAM:

  1. MINI2440 # fatload mmc 0:1 0×32000000 u-boot.bin
  2.  
  3. 233412 bytes read

¿Qué ha pasado? pues que le hemos dicho a u-boot que cargue el archivo binario u-boot.bin desde un sistema de archivos FAT (fatload), ubicado en la SD (mmc), dispositivo 1, primera partición (0:1), a partir de la dirección de memoria 0×32000000.

Una vez que tenemos el archivo en RAM, lo volcamos a la NAND:

  1. MINI2440 # nand write.e 0×32000000 0×0 0x38fc4
  2. NAND write: device 0 offset 0×0, size 0x38fc4
  3. Writing data at 0x38c00 — 100% complete.
  4.  233412 bytes written: OK

Bueno, en este caso, hemos escrito 0x38fc4 bytes (233412, para que nos entendamos), al comienzo de la NAND. El numerajo hexadecimal, como hemos visto corresponde al peso de u-boot.bin pero ésta vez del que hemos compilado NOSOTROS, no del que cargamos en RAM al principio. Importante no confundir ésto. Un apunte importante es que en ésta parte del proceso, la longitud deberá darse en hexadecimal, no en decimal, ya que ello puede dar lugar a errores.

Por lo que he leído por ahí, el modificador .e del comando write se utiliza para generar códigos de correción de errores y evitar así lo posibles bloques defectuosos que pueda haber en la NAND (recordad el comando createbbt de antes).

Una vez hecho esto, podemos reiniciar tranquilos nuestra mini2440: u-boot la hará arrancar. Aunque no hará mucho mas ya que la NAND está completamente borrada y no hay sistema.

Para finalizar debemos indicar a u-boot donde está la partición dedicada a las variables de entorno. Para ello primero debemos de conocer la tabla de particiones de nuestra memoria NAND, que deberá estar formateada de fábrica (si no es así puede hacerse desde el menú de supervivi). El comando mtdparts nos proporcionará dicha información:

  1. MINI2440 # mtdparts
  2.  
  3. device nand0 <mini2440-nand>, # parts = 4
  4.  #: name                        size            offset          mask_flags
  5.  0: u-boot              0×00040000      0×00000000      0
  6.  1: env                 0×00020000      0×00040000      0
  7.  2: kernel              0×00500000      0×00060000      0
  8.  3: root                0x07aa0000      0×00560000      0
  9.  
  10. active partition: nand0,0 – (u-boot) 0×00040000 @ 0×00000000
  11.  
  12. defaults:
  13. mtdids  : nand0=mini2440-nand
  14. mtdparts: <NULL>

Podemos ver que tenemos cuatro particiones cuyos nombres son bastante descriptivos. La partición 1, env será la utilizada para las variables de entorno de u-boot, así que con dynenv lo configuramos:

  1. MINI2440 # dynenv set 40000
  2. device 0 offset 0×40000, size 0x7fc0000
  3. 45 4e 56 30 – 00 00 04 00

El comando introducido ha configurado la ubicación de las variables de entorno a partir de la dirección 0×40000, que como se puede ver en la tabla de particiones mostrada anteriormente, es la dirección offset (de comienzo) de la partición asignada a tal efecto.

Una vez configurada la ubicación de las variables de entorno, almacenamos la configuración con el comando saveenv:

  1. MINI2440 # saveenv
  2. Saving Environment to NAND…
  3. Erasing Nand…Writing to Nand… done

Y listo, ya tenemos u-boot instalado.

Para finalizar os contaré por qué antes utilicé dos versiones distintas de uboot. El motivo es que para instalar uboot, primero debe residir en la RAM y poderse ejecutar desde ahí, ya que hay que hacer una limpieza de la NAND antes de llevar a cabo la instalación propiamente dicha. Lo que observé entonces fue que las versiones de uboot que conseguían arrancar desde la RAM, no eran capaces de hacerlo luego una vez que se instalaban en NAND (en efecto, según los manuales que leí, una vez creada la BBT, se escribía el contenido de la RAM a la NAND, ya que allí es donde está uboot) y viceversa, las imágenes que si que eran capaces de arrancar desde la NAND no lo podían hacer desde la RAM. No sé si esto es por algún bug en uboot (que deberían ser entonces bugs distintos en cada una de las versiones) o porque yo hice algo mal (repetí montones de veces lo que vi en tutos, blogs y demás paso por paso). El caso es que después de varios intentos sin mucho éxito, decidí hacerlo tal y como lo he explicado aquí.

En el futuro….

En próximas recetas, explicaré qué comandos básicos utilizar en u-boot para cargar imágenes en RAM o NAND, configurar el arranque automático desde distintas fuentes, particionar la NAND, configurar opciones de arranque para el S.O. que tengamos y alguna cosilla mas. Evito poner esa información aquí para no sobrecargar demasíado esta receta, que se supone que tienen que ser breves y concisas.

Referencias

Muchas y muy variadas, aunque las mas importantes son éstas.

NOTA: Entrada extraída de otra antigua entrada publicada por mi en CrySoL.