Month: November 2005

Como usar JFFS2 na LITE5282

Primeiramente deve-se criar o driver para a flash a ser utilizada, crie o arquivo driver/mtd/maps/m5282lite.c:

/*
* drivers/mtd/maps/m5282lite.c
*
* Flash map driver for the M5282Lite board
*
* $Id: m5282lite.c,v 1.5 2004/11/04 13:24:14 gleixner Exp $
*
* Copyright 2003-2004, UFRGS
*
* Based on the SVME181 flash map, by Tom Nelson, Dot4, Inc. for TimeSys Corp.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/

#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <asm/io.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>
#include <linux/errno.h>

/*
* This driver currently handles only the 2MiB user flash bank 0 on the
* board.
*/

#define FLASH_BASE_ADDR 0xFFE00000 /* 2 MiB */
#define FLASH_BANK_SIZE 0x00200000

MODULE_AUTHOR(“Alan Carvalho de Assis, UFRGS <acassis@inf.ufrgs.br>”);
MODULE_DESCRIPTION(“User-programmable flash device on the M5282Lite board “);
MODULE_LICENSE(“GPL”);

static struct map_info m5282lite_map = {
.name = “M5282Lite”,
.bankwidth = 2,
.size = 0x00200000
};

static struct mtd_partition m5282lite_partitions[] = {
/* Bank 0 */
{
.name = “dbug”, /* dBUG Firmware */
.offset = 0,
.size = 0x00040000, /* 256 KiB */
.mask_flags = MTD_WRITEABLE, /* force read-only */
},
{
.name = “kernel”, /* kernel partition */
.offset = 0x00040000,
.size = 0x000C0000, /* 768 KiB sector */
},
{
.name = “filesystem”, /* filesystem partition */
.offset = 0x00100000,
.size = 0x00100000, /* 1 MiB sector */
}
};

static struct mtd_info *this_mtd;

static int __init init_m5282lite(void)
{
struct mtd_partition *partitions;
int num_parts = sizeof(m5282lite_partitions) / sizeof(struct mtd_partition);

partitions = m5282lite_partitions;

m5282lite_map.virt = ioremap(FLASH_BASE_ADDR, m5282lite_map.size);

if (m5282lite_map.virt == 0) {
printk(KERN_NOTICE “Failed to ioremap FLASH memory area.\n”);
return -EIO;
}

simple_map_init(&m5282lite_map);

this_mtd = do_map_probe(“jedec_probe”, &m5282lite_map);
if (!this_mtd)
{
printk(KERN_NOTICE “M5282Lite error, can’t map”);
iounmap((void *)m5282lite_map.virt);
return -ENXIO;
}

printk(KERN_NOTICE “M5282Lite flash device: %dMiB at 0x%08x\n”,
this_mtd->size >> 20, FLASH_BASE_ADDR);

this_mtd->owner = THIS_MODULE;
add_mtd_partitions(this_mtd, partitions, num_parts);

return 0;
}

static void __exit cleanup_m5282lite(void)
{
if (this_mtd)
{
del_mtd_partitions(this_mtd);
map_destroy(this_mtd);
}

if (m5282lite_map.virt)
{
iounmap((void *)m5282lite_map.virt);
m5282lite_map.virt = 0;
}

return;
}

module_init(init_m5282lite);
module_exit(cleanup_m5282lite);

Agora acrescente a entrada no driver/mtd/maps/Makefile:

obj-$(CONFIG_MTD_M5282LITE) += m5282lite.o

Compile o uClinux com as seguintes opções ativadas:

CONFIG_MTD=y
CONFIG_MTD_PARTITIONS=y
CONFIG_MTD_CHAR=y
CONFIG_MTD_BLOCK=y
CONFIG_MTD_CFI=y
CONFIG_MTD_JEDECPROBE=y
CONFIG_MTD_GEN_PROBE=y
CONFIG_MTD_MAP_BANK_WIDTH_1=y
CONFIG_MTD_MAP_BANK_WIDTH_2=y
CONFIG_MTD_MAP_BANK_WIDTH_4=y
CONFIG_MTD_CFI_I1=y
CONFIG_MTD_CFI_I2=y
CONFIG_MTD_CFI_AMDSTD=y
CONFIG_MTD_CFI_AMDSTD_RETRY=0
CONFIG_MTD_CFI_STAA=y
CONFIG_MTD_CFI_UTIL=y
CONFIG_MTD_M5282LITE=y

Em Kernel hacking, ative Compiled-in Kernel Boot Parameter e acrescente:
root=/dev/mtdblock2

Onde /dev/mtdblock2 é a partição[2] (a nossa “filesystem”). Talvez você queira montar a partição ROMfs que é criada na RAM, para pode entrar no uClinux formatar a mtdblock2. Neste caso acrescente “root=/dev/mtdblock3 rootfstype=romfs” para que o kernel monte esta partição como romfs, do contrário ele tentará montar como jffs2

Entre no diretório romfs/dev e crie os arquivos especial reais:

# for i in $(ls); do a=$(echo $i | tr “@,” ” “); mknod $a; done

Apaque os arquivos usados para gerar os arquivos especiais

# rm @*

Retorne ao diretório uClinux-dist e crie a imagem jffs2:

# mkfs.jffs2 -b -d romfs -o /tftpboot/rootfs.img

Baixar a imagem para o dBUG:

dBUG> dn -i rootfs.img

Gravar a imagem na memória flash (partição filesystem):

dBUG> fl w fff00000 10000 a6408

Onde:
* fff00000 é o endereço da flash onde será gravado;
* 10000 é o endereço da RAM onde imagem foi descarregada;
* a6408 é o tamanho da imagem convertido em hexadecimal.

Instalando o U-Boot na Lite5200

Baixe o U-Boot 1.0.3 (www.sourceforge.net/projects/u-boot)

Descompacte:
$ tar jxvf u-boot-1.1.3.tar.bz2

Iremos primeiro compilar o U-Boot para iniciar a partir da RAM para verificar se está funcionando corretamente, e depois compilaremos para a gravar na Flash.

Altere o Makefile:
$ vi Makefile
mude a seção LOWBOOT de 0xFF000000 para 0x00020000

Adicione no Makefile o crosscompiler usado:
CROSS_COMPILE = powerpc-860-linux-gnu-

Execute o processo de configuração:
$ make Lite5200_LOWBOOT_config

Compile:
$ make

Copie a imagem do u-boot gerada para /tftpboot:
$ cp u-boot.bin /tftpboot

No dBUG execute:
dBUG> dn -i u-boot.bin
dBUG> go 20100

Após verificar que o U-Boot está funcionando na placa, vamos gravá-lo na flash.

Edite o arquivo Makefile do U-Boot e volte com valor 0xFF000000.

Limpe a árvore dos fontes:
$ make distclean
$ make Lite5200_LOWBOOT_config
$ make

Copie o arquivo u-boot.bin para /tftpboot
$ cp u-boot.bin /tftpboot

Desligue e ligue a placa, o dBUG inicia no endereço HIGHBOOT (jumper entre J75 e J74, indicação “B H/L”), iremos gravar o U-Boot no endereço LOWBOOT (jumper entre J74 e J73).

Baixe o U-Boot para a placa:
dBUG> dn -i -o 100000 u-boot.bin

Apague a flash:
dBUG> fe 0xFF000000 0xFF050000

Grave o U-Boot na flash:
dBUG> fp 0xFF000000 0xFF040000 0x100000

Desligue a placa, mude o jumper da placa para iniciar no HIGHBOOT (jumper entre J74 e J73, indicação “B H/L”).

O U-Boot iniciará.

Criando o root file system usando o busybox

Uma vez que já possuímos o cross-compiler está na hora de criar o sistema de arquivo com todos os aplicativos que temos direito.

Baixe o busybox, descompacte-o e execute dentro dele:
$ make menuconfig

Em “Build Option” marque a opção:
[*] Do you want to build BusyBox with a Cross Compiler?

E acrescente o caminho do seu crosscompiler seguindo do prefixo do mesmo:
/opt/crosstool/gcc-3.4.1-glibc-2.3.3/powerpc-860-linux-gnu/bin/powerpc-860-linux-gnu-

A compilação como “static binary” não funcionou, portanto não ative esta opção. Obs.: Usando o cross-compiler criado pelo buildroot funciona.

Selecione os aplicativos de seu interesse, salve e saia.

Execute o comando para compilação:
$ make

A compilação é bem rápida e simples, ao final será gerado o arquivo busybox e busybox.links

Então vamos criar o sistema de arquivo e colocar o busybox e os links para os binários.

Crie um diretório onde ficará seu sistema de arquivo, no caso criei um chamado mylinux:

$ mkdir mylinux
$ cd mylinux

Povoe com os diretórios básicos do linux:

$ mkdir dev etc etc/init.d bin lib proc mnt tmp var usr usr/bin usr/sbin
$ chmod 755 . dev etc etc/init.d bin lib proc mnt tmp var usr usr/bin usr/sbin

Crie os arquivos de dispositivos como superusuário:
$ su
# cd dev

Serial, usada para serial console:
# mknod ttyS0 c 4 64

Terminais genéricos:
# mknod tty c 5 0
# mknod console c 5 1
# chmod 666 tty console

Terminal virtual para VGA
# mknod tty0 c 4 0
# chmod 666 tty0

Dispositivo para o RAMDISK:
# mknod ram0 b 1 0
# chmod 644 ram0

Crie o dispositivo /dev/null (vulgo buraco negro)
# mknod null c 1 3
# chmod 666 null
# exit
$

Entre em init.d e crie o script de inicialização:
$ cd ../etc/init.d

Use um editor de sua preferência e crie o arquivo mylinux/etc/init.d/rcS com o conteúdo:
#!/bin/sh
mount -a #monta todos os pontos de montagens listados no fstab

Torne-o executável:
$ chmod 744 rcS

Entre em mylinux/etc :
$ cd ..

Crie o arquivo mylinux/etc/fstab com o conteúdo:
proc /proc proc defaults 0 0

Mude a permissão do mesmo:
$ chmod 644 fstab

Crie o arquivo mylinux/etc/inittab, que é usado pelo /bin/init para saber quais processo ele deverá executar, com o seguinte conteúdo:
::sysinit:/etc/init.d/rcS
::askfirst:/bin/sh

Mude a permissão:
$ chmod 644 inittab

Crie todos os links simbólicos para o busybox (explicado no post anterior)

Como nós criamos o busybox usando “shared libs” precisamos copiar as bibliotecas necessárias para o busybox,

Entre em /opt/crosstool/gcc-3.4.1-glibc-2.3.3/powerpc-860-linux-gnu/powerpc-860-linux-gnu/lib e copie as bibliotecas necessárias:
$ cp ld-2.3.3.so /mylinux/lib
$ cp libc-2.3.3.so /mylinux/lib

Entre em mylinux/lib e crie os links simbólicos para as bibliotecas:
$ ln -s ld-2.3.3.so ld.so.1
$ ln -s libc-2.3.3.so libc.so.6

Saia de dentro do diretório mylinux e execute:
$ genromfs -d mylinux -f ramdisk.image

Compacte a imagem gerada:
# gzip ramdisk.image

Será criado o arquivo ramdisk.image.gz, então copie-o para dentro do kernel do linux que você está compilando para a placa alvo:
$ cp ramdisk.image.gz linux/arch/ppc/boot/images

IMPORTANTE: o nome do arquivo tem que ser ramdisk.image.gz

Entre no diretório fonte do kernel:
$ cd kernel/linux

Execute o comando p/ compilar o kernel e concatenar o ramdisk:
$ make zImage.initrd

Após terminar será gerado o arquivo zImage.initrd.lite5200 dentro de linux/arch/ppc/boot/images.

Copie este arquivo para o diretório do servidor tftp:
$ cp zImage.initrd.lite5200 /tftpboot

Agora basta enviar o arquivo para a placa:
dBUG> dn -i zImage.initrd.lite5200
……………………………
2173261 bytes read via TFTP
dBUG> go 20000

Pronto, ufá!

Criar os links para o Busybox

Tive um problema com a criação dos links para o busybox, o chroot do meu host não estava funcionando, então não teria como eu criar os links de forma correta, pois eles apontariam para o lugar errado.

Para resolver isso tive que usar a criatividade, além de deixar o binário busybox no $mylinux/bin copiei-o para /bin do meu sistema (host), e removi o / inicial das linhas do arquivo busybox.links usando o sed:

cat busybox.links | sed ‘s/^\///’ > busybox-noslash.links

Então apenas executei em $mylinux/ :
for i in $(cat busybox-noslash.links); do ln -s /bin/busybox $i; done

Compilar kernel Linux para PowerPC

Descompacte o kernel:
tar zxvf kernel-2.6.14.tar.gz

cd kernel

Edite o Makefile:
CROSS_COMPILE = powerpc-860-linux-gnu-
ARCH = ppc

make distclean
make mrproper

make menuconfig

Marque ‘PReP bootloader arguments’ como built-in e coloque ‘root=/dev/nfs’
Em ‘Networking options’ marque ‘IP Kernel level auto configuration’ como built-in. Em ‘Filesystems section’ marque ‘Network File Systems’ e ‘Root file system on NFS’

make