uboot源码分析及移植下（转）

四、U-boot在ST2410的移植，基于NOR FLASH和NAND FLASH启动。
    1、从smdk2410到ST2410:
       ST2410板子的核心板与FS2410是一样的。我没有整到smdk2410的原理图，从网上得知的结论总结如下，
fs2410与smdk2410 RAM地址空间大小一致(0x30000000~0x34000000=64MB);

NOR FLASH型号不一样，FS2410用SST39VF1601系列的，smdk2410用AMD产LV系列的;

网络芯片型号和在内存中映射的地址完全一致（CS8900，IO方式基地址0x19000300）

   2、移植过程：
   移植u-boot的基本步骤如下
     (1) 在顶层Makefile中为开发板添加新的配置选项，使用已有的配置项目为例。
     smdk2410_config       :       unconfig
     @./mkconfig $(@:_config=) arm arm920t smdk2410 NULL s3c24×0
     参考上面2行，添加下面2行。
     fs2410_config        :       unconfig
     @./mkconfig $(@:_config=) arm arm920t fs2410 NULL s3c24×0
    
     (2) 创建一个新目录存放开发板相关的代码，并且添加文件。
     board/fs2410/config.mk
     board/fs2410/flash.c
     board/fs2410/fs2410.c
     board/fs2410/Makefile
     board/fs2410/memsetup.S
     board/fs2410/u-boot.lds
     注意将board/fs2410/Makefile中smdk2410.o全部改为fs2410.o
     (3) 为开发板添加新的配置文件
     可以先复制参考开发板的配置文件，再修改。例如：
     $cp include/configs/smdk2410.h include/configs/fs2410.h
     如果是为一颗新的CPU移植，还要创建一个新的目录存放CPU相关的代码。
    
     (4) 配置开发板
     $ make fs2410_config
    
    3、移植要考虑的问题：
    　从smdk2410到ST2410移植要考虑的主要问题就是NOR flash。从上述分析知道，u-boot启动时要执行flash_init() 检测flash的ID号，大小，secotor起始地址表和保护状态表,这些信息全部保存在flash_info_t flash_info[CFG_MAX_FLASH_BANKS]中。
   　 另外，u-boot中有一些命令如saveenvt需要要擦写flash，间接调用两个函数：flash_erase和write_buff。在board/smdk2410/flash.c
      实现了与smdk2410板子相关的nor flash函数操作。由于write_buffer中调用了write_hword去具体写入一个字到flash中，这个函数本身是与硬件无关的，
      所以与硬件密切相关的三个需要重写的函数是flash_init, flash_erase,write_hword；
    4、SST39VF1601:
      FS2410板nor flash型号是SST39VF1601，根据data sheet,其主要特性如下：
      16bit字为访问单位。2MBTYE大小。
      sector大小2kword=4KB,block大小32Kword=64KB;这里我按block为单位管理flash,即flash_info结构体变量中的sector_count是block数，起始地址表保存也是所有block的起始地址。
      SST Manufacturer ID = 00BFH ;
      SST39VF1601 Device ID = 234BH；
      软件命令序列如下图。

    5、我实现的flash.c主要部分：
     
//相关定义：
    # define CFG_FLASH_WORD_SIZE unsigned short   //访问单位为16b字
    #define MEM_FLASH_ADDR1   (*(volatile CFG_FLASH_WORD_SIZE *)(CFG_FLASH_BASE + 0x000005555<<1 ))

//命令序列地址1，由于2410地址线A1与SST39VF1601地址线A0连接实现按字访问，因此这个地址要左移1位。
    #define MEM_FLASH_ADDR2   (*(volatile CFG_FLASH_WORD_SIZE *)(CFG_FLASH_BASE + 0x000002AAA<<1 ))　//命令序列地址2
    #define READ_ADDR0 (*(volatile CFG_FLASH_WORD_SIZE *)(CFG_FLASH_BASE + 0x0000))   

//flash信息读取地址1，A0＝0,其余全为0
    #define READ_ADDR1 (*(volatile CFG_FLASH_WORD_SIZE *)(CFG_FLASH_BASE + 0x0001<<1))　//flash信息读取地址2，A0＝1,其余全为0
    flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* 定义全局变量flash_info[1]*/
   
   //flash_init(),我实现的比较简单，因为是与板子严重依赖的，只要检测到的信息与板子提供的已知信息符合就OK。
    ulong flash_init (void)
    {
     int i;
   
     CFG_FLASH_WORD_SIZE value;
     flash_info_t *info;
     for (i = 0; i < CFG_MAX_FLASH_BANKS; i++)
     {
      flash_info[i].flash_id=FLASH_UNKNOWN;
     }  
     info=(flash_info_t *)(&flash_info[0]);
    
     //进入读ID状态，读MAN ID和device id
     MEM_FLASH_ADDR1=(CFG_FLASH_WORD_SIZE)(0x00AA);
     MEM_FLASH_ADDR2=(CFG_FLASH_WORD_SIZE)(0x0055);
     MEM_FLASH_ADDR1=(CFG_FLASH_WORD_SIZE)(0x0090);
    
     value=READ_ADDR0;   //read Manufacturer ID
    
     if(value==(CFG_FLASH_WORD_SIZE)SST_MANUFACT)
     info->flash_id = FLASH_MAN_SST;
     else
     {
        panic("NOT expected FLASH FOUND!\n");return 0;
     }
     value=READ_ADDR1;   //read device ID
   
     if(value==(CFG_FLASH_WORD_SIZE)SST_ID_xF1601)
     {
        info->flash_id += FLASH_SST1601;
         info->sector_count = 32;   //32 block
         info->size = 0x00200000; // 2M=32*64K
     }
     else
     {
        panic("NOT expected FLASH FOUND!\n");return 0;  
     }
    
     //建立sector起始地址表。
     if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST )
     {
      for (i = 0; i < info->sector_count; i++)
      info->start[i] = CFG_FLASH_BASE + (i * 0x00010000);
     }
    
     //设置sector保护信息，对于SST生产的FLASH，全部设为0。
     for (i = 0; i < info->sector_count; i++)
     {
      if((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST)
       info->protect[i] = 0;
     }
    
     //结束读ID状态：
     *((CFG_FLASH_WORD_SIZE *)&info->start[0])= (CFG_FLASH_WORD_SIZE)0x00F0;
    
     //设置保护，将u-boot镜像和环境参数所在的block的proctect标志置1
     flash_protect (FLAG_PROTECT_SET,
            CFG_FLASH_BASE,
            CFG_FLASH_BASE + monitor_flash_len - 1,
            &flash_info[0]);
   
     flash_protect (FLAG_PROTECT_SET,
            CFG_ENV_ADDR,
            CFG_ENV_ADDR + CFG_ENV_SIZE - 1, &flash_info[0]);
     return info->size;
    }
　　　
//flash_erase实现
   　这里给出修改的部分，s_first，s_last是要擦除的block的起始和终止block号.对于protect[]置位的block不进行擦除。
擦除一个block命令时序按照上面图示的Block-Erase进行。
for (sect = s_first; sect<=s_last; sect++)
    {
     if (info->protect[sect] == 0)
     { /* not protected */
        addr = (CFG_FLASH_WORD_SIZE *)(info->start[sect]);
        if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST)
        {
         MEM_FLASH_ADDR1 = (CFG_FLASH_WORD_SIZE)0x00AA;
         MEM_FLASH_ADDR2 = (CFG_FLASH_WORD_SIZE)0x0055;
         MEM_FLASH_ADDR1 = (CFG_FLASH_WORD_SIZE)0x0080;
         MEM_FLASH_ADDR1 = (CFG_FLASH_WORD_SIZE)0x00AA;
         MEM_FLASH_ADDR2 = (CFG_FLASH_WORD_SIZE)0x0055;
         addr[0] = (CFG_FLASH_WORD_SIZE)0x0050; /* block erase */
         for (i=0; i<50; i++)
          udelay(1000); /* wait 1 ms */
          }
     else
      {
      break;
      }
     }
   }
   .........
   start = get_timer (0);　　//在指定时间内不能完成为超时。
   last = start;
   addr = (CFG_FLASH_WORD_SIZE *)(info->start[l_sect]);//查询DQ7是否为1，DQ7=1表明擦除完毕
   while ((addr[0] & (CFG_FLASH_WORD_SIZE)0x0080) != (CFG_FLASH_WORD_SIZE)0x0080) {
    if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
     printf ("Timeout\n");
     return 1;
   }
   ................
  
//write_word操作，这个函数由write_buff一调用，完成写入一个word的操作，其操作命令序列由上图中Word-Program指定。
   static int write_word (flash_info_t *info, ulong dest, ulong data)
   {
    volatile CFG_FLASH_WORD_SIZE *dest2 = (CFG_FLASH_WORD_SIZE *)dest;
    volatile CFG_FLASH_WORD_SIZE *data2 = (CFG_FLASH_WORD_SIZE *)&data;
    ulong start;
    int flag;
    int i;
  
    /* Check if Flash is (sufficiently) erased */
    if ((*((volatile ulong *)dest) & data) != data) {
     return (2);
    }
    /* Disable interrupts which might cause a timeout here */
    flag = disable_interrupts();
  
    for (i=0; i<4/sizeof(CFG_FLASH_WORD_SIZE); i++)
     {
       MEM_FLASH_ADDR1 = (CFG_FLASH_WORD_SIZE)0x00AA;
       MEM_FLASH_ADDR2 = (CFG_FLASH_WORD_SIZE)0x0055;
       MEM_FLASH_ADDR1 = (CFG_FLASH_WORD_SIZE)0x00A0;
  
       dest2[i] = data2[i];
  
       /* re-enable interrupts if necessary */
       if (flag)
         enable_interrupts();
  
       /* data polling for D7 */
       start = get_timer (0);
       while ((dest2[i] & (CFG_FLASH_WORD_SIZE)0x0080) !=
       (data2[i] & (CFG_FLASH_WORD_SIZE)0x0080)) {
         if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
     return (1);
         }
       }
     }
    return (0);
   }
  
   这些代码在与nor flash相关的命令中都会间接被调用。所以u-boot可移植性的另一个方面就是规定一些函数调用接口和全局变量，这些函数的实现是硬件相关的，移植时只需要实现这些函数。
   而全局变量是具体硬件无关的。u-boot在通用目录中实现其余与硬件无关的函数，这些函数就只与全局变量和函数接口打交道了。 通过编译选项设置来灵活控制是否需要编译通用部分。
  
  
6、增加从Nand 启动的代码：
FS2410板有跳线，跳线短路时从NAND启动，否则从NOR启动。根据FS2410 BIOS源码，我修改了start.s加入了可以从两种FLASH中启动u-boot的
代码。原理在于：在重定位之前先读BWSCON寄存器，判断OM0位是0（有跳线，NAND启动）还是1（无跳线，NOR启动），采取不同的重定位代码
分别从nand或nor中拷贝u-boot镜像到RAM中。这里面也有问题，比如从Nand启动后，nor flash的初始化代码和与它相关的命令都是不能使用的。
这里我采用比较简单的方法，定义一个全局变量标志_boot_flash保存当前启动FLASH标志，_boot_flash=0则表明是NOR启动，否则是从NAND。
在每个与nor flash 相关的命令执行函数一开始就判断这个变量，如果为1立即返回。flash_init()也必须放在这个if(!_boot_flash)条件中。
这里方法比较笨，主要是为了能在跳线处于任意状态时都能启动u-boot。
修改后的start.s如下。
.......
   //修改1
   .globl _boot_flash
   _boot_flash:    //定义全局标志变量，0:NOR FLASH启动，1：NAND FLASH启动。
   .word 0x00000000   
.........

   ///修改2：

   ldr r0,=BWSCON
   ldr r0,[r0]
   ands r0,r0,#6
   beq nand_boot   //OM0=0,有跳线，从Nand启动。nand_boot在后面定义。
   ............
  
   //修改4,这里在全局变量_boot_flash中设置当前启动flash设备是NOR还是NAND
   //这里已经完成搬运到RAM的工作，即将跳转到RAM中_start_armboot函数中执行。
   adr r1,_boot_flash //取_boot_flash的当前地址，这时还在NOR FLASH或者NAND 4KB缓冲中。
   ldr r2,_TEXT_BASE
   add r1,r1,r2    //得到_boot_flash重定位后的地址，这个地址在RAM中。
   ldr r0,=BWSCON
   ldr r0,[r0]
   ands r0,r0,#6    //
   mov r2,#0x00000001
   streq r2,[r1]    //如果当前是从NAND启动，置_boot_flash为1
  
   ldr pc, _start_armboot

_start_armboot: .word start_armboot

........

//////// 修改4，从NAND拷贝U-boot镜像（最大128KB），这段代码由fs2410 BIOS修改得来。
nand_boot:
    mov r5, #NFCONF
    ldr r0, =(1<<15)|(1<<12)|(1<<11)|(7<<8)|(7<<4)|(7)
    str r0, [r5]
   
    bl ReadNandID
    mov r6, #0
    ldr r0, =0xec73
    cmp r5, r0
    beq x1
    ldr r0, =0xec75
    cmp r5, r0
    beq x1
    mov r6, #1
   x1:
    bl ReadNandStatus
   
    mov r8, #0         //r8是PAGE数变量
    ldr r9, _TEXT_BASE    //r9指向u-boot在RAM中的起始地址。
   x2:
    ands r0, r8, #0x1f
    bne   x3        //此处意思在于页数是32的整数倍的时候才进行一次坏块检查 1 block=32 pages，否则直接读取页面。
    mov   r0, r8
    bl   CheckBadBlk    //检查坏块返回值非0表明当前块不是坏块。
    cmp   r0, #0
    addne r8, r8, #32    //如果当前块坏了，跳过读取操作。 1 block=32 pages
    bne   x4
   x3:
    mov r0, r8
    mov r1, r9
    bl ReadNandPage   //读取一页(512B)
    add r9, r9, #512
    add r8, r8, #1
   x4:
    cmp r8, #256     //一共读取256*512=128KB。
    bcc x2
   
    mov r5, #NFCONF    //DsNandFlash
    ldr r0, [r5]
    and r0, r0, #~0x8000
    str r0, [r5]
   
    adr lr,stack_setup //注意这里直接跳转到stack_setup中执行
    mov pc,lr
   ///
   /*************************************************
   *
   *Nand basic functions:
   *************************************************
   */

   //读取Nand的ID号，返回值在r5中
   ReadNandID:
    mov   r7,#NFCONF
    ldr      r0,[r7,#0]   //NFChipEn();
    bic      r0,r0,#0x800
    str      r0,[r7,#0]
    mov      r0,#0x90   //WrNFCmd(RdIDCMD);
    strb     r0,[r7,#4]
    mov      r4,#0    //WrNFAddr(0);
    strb     r4,[r7,#8]
   y1:            //while(NFIsBusy());
    ldr      r0,[r7,#0x10]
    tst      r0,#1
    beq      y1
    ldrb     r0,[r7,#0xc] //id = RdNFDat()<<8;
    mov      r0,r0,lsl #8
    ldrb     r1,[r7,#0xc] //id |= RdNFDat();
    orr      r5,r1,r0
    ldr      r0,[r7,#0]   //NFChipDs();
    orr      r0,r0,#0x800
    str      r0,[r7,#0]
    mov   pc,lr
  
   //读取Nand状态,返回值在r1,此处没有用到返回值。
  
   ReadNandStatus:
    mov   r7,#NFCONF
    ldr      r0,[r7,#0]   //NFChipEn();
    bic      r0,r0,#0x800
    str      r0,[r7,#0]
    mov      r0,#0x70     //WrNFCmd(QUERYCMD);
    strb     r0,[r7,#4]
    ldrb     r1,[r7,#0xc] //r1 = RdNFDat();
    ldr      r0,[r7,#0]   //NFChipDs();
    orr      r0,r0,#0x800
    str      r0,[r7,#0]
    mov   pc,lr
  
   //等待Nand内部操作完毕
   WaitNandBusy:
    mov      r0,#0x70   //WrNFCmd(QUERYCMD);
    mov      r1,#NFCONF
    strb     r0,[r1,#4]
   z1:                //while(!(RdNFDat()&0x40));
    ldrb     r0,[r1,#0xc]
    tst      r0,#0x40
    beq     z1
    mov      r0,#0    //WrNFCmd(READCMD0);
    strb     r0,[r1,#4]
    mov      pc,lr
  
   //检查坏block:
   CheckBadBlk:
    mov     r7, lr
    mov     r5, #NFCONF
   
    bic     r0, r0, #0x1f   //addr &= ~0x1f;
    ldr      r1,[r5,#0]   //NFChipEn()
    bic      r1,r1,#0x800
    str      r1,[r5,#0]
  
    mov      r1,#0x50    //WrNFCmd(READCMD2)
    strb     r1,[r5,#4]
    mov    r1, #6
    strb     r1,[r5,#8]   //WrNFAddr(6)
    strb     r0,[r5,#8]   //WrNFAddr(addr)
    mov      r1,r0,lsr #8 //WrNFAddr(addr>>8)
    strb     r1,[r5,#8]
    cmp      r6,#0     //if(NandAddr)  
    movne    r0,r0,lsr #16 //WrNFAddr(addr>>16)
    strneb   r0,[r5,#8]
   
    bl   WaitNandBusy //WaitNFBusy()
  
    ldrb r0, [r5,#0xc] //RdNFDat()
    sub   r0, r0, #0xff
   
    mov      r1,#0    //WrNFCmd(READCMD0)
    strb     r1,[r5,#4]
   
    ldr      r1,[r5,#0]   //NFChipDs()
    orr      r1,r1,#0x800
    str      r1,[r5,#0]
   
    mov   pc, r7
  
   ReadNandPage:
    mov     r7,lr
    mov      r4,r1
    mov      r5,#NFCONF
  
    ldr      r1,[r5,#0]   //NFChipEn()
    bic      r1,r1,#0x800
    str      r1,[r5,#0]
  
    mov      r1,#0    //WrNFCmd(READCMD0)
    strb     r1,[r5,#4]
    strb     r1,[r5,#8]   //WrNFAddr(0)
    strb     r0,[r5,#8]   //WrNFAddr(addr)
    mov      r1,r0,lsr #8 //WrNFAddr(addr>>8)
    strb     r1,[r5,#8]
    cmp      r6,#0    //if(NandAddr)  
    movne    r0,r0,lsr #16 //WrNFAddr(addr>>16)
    strneb   r0,[r5,#8]
   
    ldr      r0,[r5,#0]   //InitEcc()
    orr      r0,r0,#0x1000
    str      r0,[r5,#0]
   
    bl       WaitNandBusy //WaitNFBusy()
   
    mov      r0,#0    //for(i=0; i<512; i++)
   r1:
    ldrb     r1,[r5,#0xc] //buf[i] = RdNFDat()
    strb     r1,[r4,r0]
    add      r0,r0,#1
    bic      r0,r0,#0x10000
    cmp      r0,#0x200
    bcc      r1
   
    ldr      r0,[r5,#0]   //NFChipDs()
    orr      r0,r0,#0x800
    str      r0,[r5,#0]
    
    mov   pc,r7
  
关于nand命令，我尝试打开CFG_CMD_NAND选项，并定义
    #define CFG_MAX_NAND_DEVICE 1
    #define MAX_NAND_CHIPS 1
    #define CFG_NAND_BASE 0x4e000000
   添加boar_nand_init()定义(空实现)。但是连接时出现问题，原因是u-boot使用的是软浮点，而我的交叉编译arm-linux-gcc是硬件浮点。
   看过一些解决方法，比较麻烦，还没有解决这个问题，希望好心的高手指点。不过我比较纳闷，u-boot在nand部分哪里会用到浮点运算呢？
  
  7、添加网络命令。
   我尝试使用ping命令，其余的命令暂时不考虑。
   在common/cmd_net中，首先有条件编译 #if (CONFIG_COMMANDS & CFG_CMD_NET)，然后在命令函数do_ping(...)定义之前有条件编译判断
   #if (CONFIG_COMMANDS & CFG_CMD_PING) 。所以在include/cofig/fs2410.h中必须打开这两个命令选项。
    #define CONFIG_COMMANDS \
     (CONFIG_CMD_DFL | \
     CFG_CMD_CACHE | \
     CFG_CMD_REGINFO | \
     CFG_CMD_DATE | \
     CFG_CMD_NET | \ //
     CFG_CMD_PING |\ //
     CFG_CMD_ELF)
   并且设定IP:192.168.0.12。

   至此，整个移植过程已经完成。编译连接生成u-boot.bin，烧到nand 和nor上都能顺利启动u-boot,使用ping命令时出现问题，
   发现ping自己的主机竟然超时，还以为是程序出了问题，后来才发现是windows防火墙的问题。关闭防火墙就能PING通了。
  
   总体来说，u-boot是一个很特殊的程序，代码庞大，功能强大，自成体系。为了在不同的CPU，ARCH，BOARD上移植进行了很多灵活的设计。
在u-boot的移植过程中学到很多东西，尤其是程序设计方法方面真的是大开了眼界。u-boot在代码级可移植性和底层程序开发技术上给人很好的启发。
很多东西没有搞明白，尤其是u-boot最重要的功能--引导OS这部分还没有涉及。linux内核还没入门呢，路漫漫其修远兮，吾将上下而求索。
没有IDE环境看u-boot这种makefile工程很费劲，我用UltraEdit干了这件事，后来才发现可以使用source insight 这个软件。。。。。。。。

 

转载:http://hi.baidu.com/assxq/blog/item/f78aeb09e094193ae824883a.html