U-Boot启动第二阶段代码分析

Myth丶恋晨 2022-03-26 15:58 233阅读 0赞

U-Boot -第二阶段代码分析

参考文档：

http://blog.chinaunix.net/space.php?uid=20540258&do=blog&cuid=313450

[http://www.cnblogs.com/zong-blogs/archive/2011/04/07/2008738.html][http_www.cnblogs.com_zong-blogs_archive_2011_04_07_2008738.html]

http://blog.csdn.net/aaronychen/article/category/445277

在上一篇文章中，我们介绍了u-boot启动的时候汇编语言的部分，当时我们进行了一些简单的初始化，并且为C语言的执行建立的环境（堆栈），现在我们看看当从汇编语言转到C语言的时候执行的第一个函数（ start\_armboot ()，在lib\_arm\\board.c中），该函数进行了一系列的外设初始化，然后调用main\_loop (),根据配置来选择是直接加载Linux内核还是进入等待命令模式。

1、在介绍该函数之前，我们需要看一看几个数据结构，这些是u-boot中几个重要的数据结构：

（1）gd\_t结构体

U-Boot使用了一个结构体gd\_t来存储全局数据区的数据，这个结构体在include/asm-arm/global\_data.h中定义如下：

typedef    struct      global\_data \{

bd\_t        \*bd;   //与板子相关的结构，见下面

unsigned longflags;

unsigned longbaudrate;

unsigned longhave\_console;/\* serial\_init() was called \*/

unsigned longreloc\_off;        /\* Relocation Offset \*/

unsigned longenv\_addr;        /\* Address  of Environment struct \*/

unsigned longenv\_valid;       /\* Checksum of Environment valid? \*/

unsigned longfb\_base;  /\* base address of frame buffer \*/

\#ifdef CONFIG\_VFD  //我们一般没有配置这个，这个是frame buffer的首地址

unsigned charvfd\_type;/\* display type \*/

\#endif

\#if 0

unsigned longcpu\_clk;  /\* CPU clock in Hz!          \*/

unsigned longbus\_clk;

unsigned longram\_size;/\* RAM size \*/

unsigned longreset\_status;     /\* reset status register at boot \*/

\#endif

void        \*\*jt;        /\* jump table \*/

\} gd\_t;

/\*

\* Global Data Flags

\*/

\#define    GD\_FLG\_RELOC  0x00001          /\* Code was relocated to RAM         \*/

\#define    GD\_FLG\_DEVINIT      0x00002          /\* Devices have been initialized\*/

\#define    GD\_FLG\_SILENT0x00004          /\* Silent mode                           \*/

\#define DECLARE\_GLOBAL\_DATA\_PTR     register volatile gd\_t \*gd asm ("r8")

在global\_data.h中U-Boot使用了一个存储在寄存器中的指针gd来记录全局数据区的地址：

\#define DECLARE\_GLOBAL\_DATA\_PTR     register volatile gd\_t \*gd asm ("r8")

DECLARE\_GLOBAL\_DATA\_PTR定义一个gd\_t全局数据结构的指针，这个指针存放在指定的寄存器r8中。这个声明也避免编译器把r8分配给其它的变量。任何想要访问全局数据区的代码，只要代码开头加入“DECLARE\_GLOBAL\_DATA\_PTR”一行代码，然后就可以使用gd指针来访问全局数据区了。

根据U-Boot内存使用图中可以计算gd的值：

gd = TEXT\_BASE －CONFIG\_SYS\_MALLOC\_LEN － sizeof(gd\_t)

[![20672257_1316850501J662.jpg][]][20672257_1316850501J662.jpg]

2）bd\_t 保存与板子相关的配置参数

bd\_t在include/asm-arm/u-boot.h中定义如下：

typedef struct bd\_info \{

int                 bi\_baudrate;     /\* 串口通讯波特率 \*/

unsigned longbi\_ip\_addr;      /\* IP地址 \*/

unsigned charbi\_enetaddr\[6\]; /\* Ethernet adress \*/

struct environment\_s             \*bi\_env; /\*环境变量开始地址 \*/

ulong  bi\_arch\_number;       /\* unique id for this board开发板的机器码 \*/

ulong  bi\_boot\_params;       /\* where this board expects params 内核参数的开始地址\*/

struct                           /\* RAM配置信息 \*/

ulong start;

ulong size;

\}     bi\_dram\[CONFIG\_NR\_DRAM\_BANKS\]; //在我的板子上DRAM配置是1个

\#ifdef CONFIG\_HAS\_ETH1

/\* second onboard ethernet port \*/

unsigned char   bi\_enet1addr\[6\];

\#endif

\} bd\_t;

\#define bi\_env\_data bi\_env->data

\#define bi\_env\_crc  bi\_env->crc

U-Boot启动内核时要给内核传递参数，这时就要使用gd\_t，bd\_t结构体中的信息来设置标记列表。

3). 初始化函数列表(以数组的形式)

相关代码在lib-arm/board.c中定义

typedef int (init\_fnc\_t) (void); /\*这是使用typedef定义一个init\_fnc\_t为函数类型，该函数返回int型，无参数\*/

int print\_cpuinfo (void); /\* test-only \*/

init\_fnc\_t \*init\_sequence\[\]定义一个init\_fnc\_t指针类型的数组。简单的说就是定义了个函数指针数组，指向一系列cpu初始化函数。

init\_fnc\_t \*init\_sequence\[\] = \{ /\*全局变量init\_sequence的定义，\*/

cpu\_init,         /\* basic cpu dependent setup CPU的相关配置，如初始化IRQ/FIQ模式的栈cpu/arm920t/cpu.c\*/

board\_init,             /\* basic board dependent setup开发板相关配置，是对板子的初始化,设置MPLL，改变系统时钟，以及一些GPIO寄存器的值，还设置了U-Boot机器码和内核启动参数地址，它是开发板相关的函数，比如2410是在：board/smdk2410/smdk2410.c中实现\*/

interrupt\_init,        /\* set up exceptions 初始化中断，在cpu/arm920t/s3c24x0/interrupts.c实现\*/

env\_init,         /\* initialize environment 初始化环境变量，检查flash上的环境变量是否有效common/env\_flash.c 或common/env\_nand.c \*/

init\_baudrate,         /\* initialze baudrate settings 初始化波特率lib\_arm/board.c \*/

serial\_init,             /\* serial communications setup串口初始化串口初始化后我们就可以打印信息了cpu/arm920t/s3c24x0/serial.c \*/

console\_init\_f,              /\* stage 1 init of console 控制台初始化第一阶段common/console.c \*/

display\_banner,             /\* say that we are here通知代码已经运行到该处，打印U-Boot版本、编译的时间\-- lib\_arm/board.c \*/

\#if defined(CONFIG\_DISPLAY\_CPUINFO)

print\_cpuinfo,        /\* display cpu info (and speed) \*/

\#endif

\#if defined(CONFIG\_DISPLAY\_BOARDINFO)

checkboard,           /\* display board info \*/

\#endif

dram\_init,             /\* configure available RAM banks 配置可用的内存区，检测系统内存映射，设置内存的起始地址和大小board/smdk2410/smdk2410.c\*/

display\_dram\_config,

NULL,

\};

可以看出这里定义了一个指针数组,它的每一个元素都是指针变量,这些指针变量指向的类型为init\_fnc\_t,在C语言中函数的入口地址就是函数名,所以这里使用一系列函数名来初始化这个数组。

现在来看看到底做了哪些初始化工作

int cpu\_init (void)

/\*

\* setup up stacks if necessary

\*/

\#ifdef CONFIG\_USE\_IRQ

IRQ\_STACK\_START = \_armboot\_start - CFG\_MALLOC\_LEN - CFG\_GBL\_DATA\_SIZE - 4;

FIQ\_STACK\_START = IRQ\_STACK\_START - CONFIG\_STACKSIZE\_IRQ;

\#endif

return 0;

这个函数cpu/arm920t/cpu.c在中实现，其实这个函数没有做任何工作,因为CONFIG\_USE\_IRQ这个宏没有定义,那么怎么知道这个宏是否被定义了呢,在使用SourceInsight的搜索功能时,发现有些宏会在很多头文件被定义,而我们又很难判断这些头文件是否被当前的c文件包含了,我使用一个简便的方法,利用编译器的预处理功能,

\#ifdef CONFIG\_USE\_IRQ

\#error CONFIG\_USE\_IRQ\_xxxxxx

DECLARE\_GLOBAL\_DATA\_PTR;

IRQ\_STACK\_START = \_armboot\_start - CFG\_MALLOC\_LEN - CFG\_GBL\_DATA\_SIZE - 4;

FIQ\_STACK\_START = IRQ\_STACK\_START - CONFIG\_STACKSIZE\_IRQ;

\#endif

这样如果这个宏被定义了,那么编译时就会报错输出\#error CONFIG\_USE\_IRQ\_xxxxxx,并终止编译.对于smdk2410来说这个宏CONFIG\_USE\_IRQ没定义，实际上就是把IRQ\_STACK\_START， FIQ\_STACK\_START指到RAM中的IRQ stuff区域。

接下来该看开发板基本配置初始化函数: board\_init

static inline void delay (unsigned long loops)

\{         /\*board/smdk2410/smdk2410.c在中实现的延时函数\*/

\_\_asm\_\_ volatile ("1:\\n"

"subs %0, %1, \#1\\n"

"bne 1b":"=r" (loops):"0" (loops));

/\*

\* Miscellaneous platform dependent initialisations

\*/

int board\_init (void) 这个函数board/smdk2410/smdk2410.c在中实现

//获取power和clock及GPIO方面的寄存器地址，稍后的操作会对这些寄存器操作，需要看到的是，象S3C24X0\_CLOCK\_POWER里面的field对象都是按照实际寄存器的地址来安排的

S3C24X0\_CLOCK\_POWER \* const clk\_power = S3C24X0\_GetBase\_CLOCK\_POWER();

S3C24X0\_GPIO \* const gpio = S3C24X0\_GetBase\_GPIO();

/\* to reduce PLL lock time, adjust the LOCKTIME register \*/

//降低PLL的lock time的值，具体含义可参考data sheet

clk\_power->LOCKTIME = 0xFFFFFF;

/\* configure MPLL \*/

clk\_power->MPLLCON = ((M\_MDIV << 12) + (M\_PDIV << 4) + M\_SDIV);

/\* some delay between MPLL and UPLL \*/

delay (4000);

/\* configure UPLL \*/

clk\_power->UPLLCON = ((U\_M\_MDIV << 12) + (U\_M\_PDIV << 4) + U\_M\_SDIV);

/\* some delay between MPLL and UPLL \*/

delay (8000);

/\* 配置每个GPIO的功能，输入输出，等参数 \*/

gpio->GPACON = 0x007FFFFF;

gpio->GPBCON = 0x00044555;

gpio->GPBUP = 0x000007FF;

gpio->GPCCON = 0xAAAAAAAA;

gpio->GPCUP = 0x0000FFFF;

gpio->GPDCON = 0xAAAAAAAA;

gpio->GPDUP = 0x0000FFFF;

gpio->GPECON = 0xAAAAAAAA;

gpio->GPEUP = 0x0000FFFF;

gpio->GPFCON = 0x000055AA;

gpio->GPFUP = 0x000000FF;

gpio->GPGCON = 0xFF95FFBA;

gpio->GPGUP = 0x0000FFFF;

gpio->GPHCON = 0x002AFAAA;

gpio->GPHUP = 0x000007FF;

/\* SMDK2410开发板的机器码 \*/ \*/

gd->bd->bi\_arch\_number = MACH\_TYPE\_SMDK2410;

/\* adress of boot parameters内核启动参数地址，运行时在linux内核之下/

gd->bd->bi\_boot\_params = 0x30000100;

//使能指令cache和数据cache

icache\_enable();

dcache\_enable();

return 0;

现在说一下icache\_enable、dcache\_enable函数，它定义在cpu/arm920t/cpu.c中，这两个函数是通过修改CP15的c1寄存器来实现的，使能cache很简单，只要把协处理器15的相关位打开就行了，这里来是将c1的I、C位置1，来开启Icache、DCaches。我这里只分析icache\_enable，dcache\_enable类似。icache\_enable具体实现如下：

void icache\_enable (void)

ulong reg;

reg = read\_p15\_c1 ();         /\* get control reg. 获取CP15的c1寄存器值存到reg中\*/

cp\_delay ();

write\_p15\_c1 (reg | C1\_IC);/\*这里将C1寄存器的I、C位置1，来开启Icache、Dcaches，关于CP15的c1寄存器的格式可参看前面u-boot启动第一阶段分析的cpu\_init\_crit函数部分。

这里须要理解的是read\_p15\_c1与write\_p15\_c1函数，它们分别在cpu/arm920t/cpu.c中定义如下：

static unsigned long read\_p15\_c1 (void)

unsigned long value;

\_\_asm\_\_ \_\_volatile\_\_(

"mrc       p15, 0, %0, c1, c0, 0    @ read control reg\\n",%0是参数传递时R0寄存器，其功能是读取CP15的c1寄存器值放到r0中。

: "=r" (value)

: "memory");

\#ifdef MMU\_DEBUG

printf ("p15/c1 is = %08lx\\n", value);

\#endif

return value; 返回读取CP15的c1寄存器的值

/\* write to co-processor 15, register \#1 (control register) \*/

static void write\_p15\_c1 (unsigned long value)

\#ifdef MMU\_DEBUG

printf ("write %08lx to p15/c1\\n", value);

\#endif

\_\_asm\_\_ \_\_volatile\_\_(

"mcr       p15, 0, %0, c1, c0, 0    @ write it back\\n" @保存r0的值到控制寄存器CP15的c1寄存器中，因为函数参数传递时，第一个参数都是放在r0寄存器中的。

: "r" (value)

: "memory");

read\_p15\_c1 ();

static void cp\_delay (void)

volatile int i;

/\* copro seems to need some delay between reading and writing \*/

for (i = 0; i < 100; i++);

接下来该看初始化函数: interrupt\_init，在cpu/arm920t/s3c24x0/interrupts.c实现interrupt\_init代码如下：

int timer\_load\_val = 0;

static ulong timestamp;

static ulong lastdec;

int interrupt\_init (void)   初始化timer4相关寄存器，用于产生10ms定时中断信号。

S3C24X0\_TIMERS \* const timers = S3C24X0\_GetBase\_TIMERS();//返回定时器配置寄存器地址0x51000000,即TCFG0寄存器地址。

/\*这里使用定时器4，定时器4有只有一个内部定器没有输出管脚\*/

/\* prescaler for Timer 4 is 16 \*/

timers->TCFG0 = 0x0f00;

if (timer\_load\_val == 0)

/\*

\* for 10 ms clock period @ PCLK with 4 bit divider = 1/2

\* (default) and prescaler = 16. Should be 10390

\* @33.25MHz and 15625 @ 50 MHz

\*/

timer\_load\_val = get\_PCLK()/(2 \* 16 \* 100); //PCLK(返回PCLK频率

/\* load value for 10 ms timeout \*/

lastdec = timers->TCNTB4 = timer\_load\_val;//设置计数缓存寄存器初始值。

/\*设置定时器4手动更新，自动加载模式，并关闭定时器4\*/

timers->TCON = (timers->TCON & ~0x0700000) | 0x600000;

/\* auto load, 启动Timer 4 \*/

timers->TCON = (timers->TCON & ~0x0700000) | 0x500000;

timestamp = 0;

return (0);

对着datasheet来看这个函数，实际上这个函数使用timer 4来作为系统clock，即时钟滴答， 10ms一次，到点就产生一个中断，但由于此时中断还没打开所以这个中断不会响应。

接着看env\_init: 由于我们在inculde/configs/smdk2410.h下定义了CFG\_ENV\_IS\_IN\_FLASH，因此该函数位于common/env\_flash.c下

int  env\_init(void)

\#ifdef CONFIG\_OMAP2420H4

int flash\_probe(void);

if(flash\_probe() == 0)

goto bad\_flash;

\#endif

if (crc32(0, env\_ptr->data, ENV\_SIZE) == env\_ptr->crc) \{

gd->env\_addr  = (ulong)&(env\_ptr->data);

gd->env\_valid = 1;使用include/configs/smdk2410.h配置的环境变量则设置环境变量可用标志

return(0);

/\* env\_ptr在前面定义为env\_t \*env\_ptr = (env\_t \*)CFG\_ENV\_ADDR;而CFG\_ENV\_ADDR被定义在include/configs/smdk2410.h中了，这里判断如果校验正确(即CFG\_ENV\_ADDR被定义了)则环境变量的存放地址使用smdk2410.h中定义的，否则使用后面的默认的环境变量值default\_environment数组\*/

\#ifdef CONFIG\_OMAP2420H4

bad\_flash:

\#endif

gd->env\_addr  = (ulong)&default\_environment\[0\];

gd->env\_valid = 0; 使用默认的环境配置变量则设置环境变量不可用标志

return (0);

这个函数主要是在gd里保存环境变量的存放地址。一般使用默认的环境变量值即default\_environment数组，它在common/env\_commom.c中定义（关于u-boot环境变量更详细的说明请看U-BOOT环境变量实现一文档。地址：[http://blog.csdn.net/hxliu\_leo/article/details/5315011][http_blog.csdn.net_hxliu_leo_article_details_5315011]）

uchar default\_environment\[\] = \{

\#ifdef      CONFIG\_BOOTARGS

"bootargs="    CONFIG\_BOOTARGS                "\\0"

\#endif

\#ifdef      CONFIG\_BOOTCOMMAND

"bootcmd="    CONFIG\_BOOTCOMMAND              "\\0"

\#endif

\#if defined(CONFIG\_BOOTDELAY) && (CONFIG\_BOOTDELAY >= 0)

"bootdelay="  MK\_STR(CONFIG\_BOOTDELAY)     "\\0"

\#endif

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

\#ifdef  CONFIG\_EXTRA\_ENV\_SETTINGS

CONFIG\_EXTRA\_ENV\_SETTINGS

\#endif

"\\0"

\};

可见环境变量以如下的方式存放在数组中

Name=value

并且以”/0”结束，而类似CONFIG\_BOOTARGS的宏都定义在板子自己的配置文件中即smdk2410.h里。

接下来看init\_baudrate，定义在lib\_arm/board.c

static int init\_baudrate (void)

char tmp\[64\];/\* long enough for environment variables \*/

int i = getenv\_r ("baudrate", tmp, sizeof (tmp)); //从环境变量中获取波特率值

gd->bd->bi\_baudrate = gd->baudrate = (i > 0)

? (int) simple\_strtoul (tmp, NULL, 10)

: CONFIG\_BAUDRATE;

return (0);

该函数从上面刚初始化好的环境变量列表里找波特率值，如果没有就赋初始值为CONFIG\_BAUDRATE。

继续往下看serial\_init，cpu/arm920t/s3c24x0/serial.c

int serial\_init (void)

serial\_setbrg ();//设置波特率，停止位等

return (0);

void serial\_setbrg (void)  cpu/arm920t/s3c24x0/serial.c

S3C24X0\_UART \* const uart = S3C24X0\_GetBase\_UART(UART\_NR);

int i;

unsigned int reg = 0;

/\* value is calculated so : (int)(PCLK/16./baudrate) -1 \*/

reg = get\_PCLK() / (16 \* gd->baudrate) - 1;

/\* FIFO enable, Tx/Rx FIFO clear \*/

uart->UFCON = 0x07;

uart->UMCON = 0x0;

/\* Normal,No parity,1 stop,8 bit \*/

uart->ULCON = 0x3;

/\*

\* tx=level,rx=edge,disable timeout int.,enable rx error int.,

\* normal,interrupt or polling

\*/

uart->UCON = 0x245;

uart->UBRDIV = reg;

\#ifdef CONFIG\_HWFLOW

uart->UMCON = 0x1; /\* RTS up \*/

\#endif

for (i = 0; i < 100; i++);

上面这个函数对着datasheet看，无非是设置波特率，起始位，检验中断类型等等。

接着看初始化函数：console\_init\_f，common/console.c

int console\_init\_f (void)

gd->have\_console = 1;

\#ifdef CONFIG\_SILENT\_CONSOLE

if (getenv("silent") != NULL)

gd->flags |= GD\_FLG\_SILENT; //设置控制台模式

\#endif

return (0);

该函数初始化了几个控制台相关的标记。

接着看display\_banner: lib\_arm/board.c

static int display\_banner (void)

printf ("\\n\\n%s\\n\\n", version\_string); //打印U-BOOT的版本信息

debug ("U-Boot code: %08lX -> %08lX  BSS: -> %08lX\\n",

\_armboot\_start, \_bss\_start, \_bss\_end); //打印U-BOOT代码位置

\#ifdef CONFIG\_MODEM\_SUPPORT

debug ("Modem Support enabled\\n");

\#endif

\#ifdef CONFIG\_USE\_IRQ

debug ("IRQ Stack: %08lx\\n", IRQ\_STACK\_START);

debug ("FIQ Stack: %08lx\\n", FIQ\_STACK\_START);

\#endif

return (0);

这个函数就是在控制台上打印一些系统信息。

接着看dram\_init:

int dram\_init (void) 这个函数board/smdk2410/smdk2410.c在中实现

gd->bd->bi\_dram\[0\].start = PHYS\_SDRAM\_1;  //RAM起始地址

gd->bd->bi\_dram\[0\].size = PHYS\_SDRAM\_1\_SIZE;  //RAM大小

return 0;

2410使用2片32MB的SDRAM组成了64MB的内存，接在存储控制器的BANK6，地址空间是0x30000000~0x34000000。在include/configs/smdk2410.h中PHYS\_SDRAM\_1和PHYS\_SDRAM\_1\_SIZE 分别被定义为0x30000000和0x04000000（64M）。

再看display\_dram\_config lib\_arm/board.c

static int display\_dram\_config (void)

int i;

\#ifdef DEBUG

puts ("RAM Configuration:\\n");

for(i=0; i<CONFIG\_NR\_DRAM\_BANKS; i++) \{

printf ("Bank \#%d: %08lx ", i, gd->bd->bi\_dram\[i\].start);

print\_size (gd->bd->bi\_dram\[i\].size, "\\n");

\#else

ulong size = 0;

for (i=0; i<CONFIG\_NR\_DRAM\_BANKS; i++) \{

size += gd->bd->bi\_dram\[i\].size;

puts("DRAM:  ");

print\_size(size, "\\n");

\#endif

return (0);

呵呵仅仅是打印系统RAM的信息。

接着说初始化函数，对于Smdk2410来说不存在print\_cpuinfo、checkboard函数，

这样整个初始化函数表的函数都看完了，总结一下主要做了如下过程：

1． cpu, borad, interrupt的初始化，包括cache等，这些都于特定板子的配置有关。

2．环境变量的初始化，

3．串口，控制台，RAM的初始化，

4．在控制台上实时的显示系统配置等相关参数。

最后需要说明的是，大部分的配置参数都是预先在include/configs/board\_name.h下定义的，因此如果我们要移植我们自己的板子的话，这个文件必不可少，它描述了我们板子的配置情况如CPU型号，RAM大小等。

2、U-Boot第二阶段启动流程

在分析star\_armboot()源码前我们先看一下U-Boot第二阶段启动流程。

U-Boot第二阶段流程图如下：

3、start\_armboot()源码分析

分析完上述的数据结构，下面来分析start\_armboot函数，现在我贴出start\_armboot ()的源代码，然后具体的在其中解释一些代码的作用。

void start\_armboot (void)

init\_fnc\_t \*\*init\_fnc\_ptr; /\*它是指向指针的指针变量,变量的类型为init\_fnc\_t,这是一个使用typedef定义的函数类型,其中init\_fnc\_ptr将在后面指向一个数组指针\*/

char \*s;

\#ifndef CFG\_NO\_FLASH

ulong size;

\#endif

\#if defined(CONFIG\_VFD) || defined(CONFIG\_LCD)

unsigned long addr;

\#endif

/\* Pointer is writable since we allocated a register for it \*/

gd = (gd\_t\*)(\_armboot\_start - CFG\_MALLOC\_LEN - sizeof(gd\_t));//计算全局数据结构的地址gd

/\* compiler optimization barrier needed for GCC >= 3.4 \*/

\_\_asm\_\_ \_\_volatile\_\_("": : :"memory");

memset ((void\*)gd, 0, sizeof (gd\_t)); //初始化全局数据区为0；

gd->bd = (bd\_t\*)((char\*)gd - sizeof(bd\_t)); //为bd\_t分配空间，并赋值到gd

memset (gd->bd, 0, sizeof (bd\_t));

monitor\_flash\_len = \_bss\_start - \_armboot\_start; //代码段的大小

/\* 逐个调用init\_sequence数组中的初始化函数  \*/

for (init\_fnc\_ptr = init\_sequence; \*init\_fnc\_ptr; ++init\_fnc\_ptr) \{

if ((\*init\_fnc\_ptr)() != 0) \{

hang ();

/\* CFG\_NO\_FLASH 表示没有flash,如果没定义该常量则表示板子上有flash,此时调用flash\_init()对其进行初始化.这里是norflash初始化 \*/

\#ifndef CFG\_NO\_FLASH

/\* configure available FLASH banks \*/

size = flash\_init (); 详见后分析

display\_flash\_config (size); //打印flash的信息，仅是其大小；

\#endif /\* CFG\_NO\_FLASH \*/

\#ifdef CONFIG\_VFD  //smdk2410没定义

\#     ifndef PAGE\_SIZE

\#       define PAGE\_SIZE 4096

\#     endif

/\*

\* reserve memory for VFD display (always full pages)

\*/

/\* bss\_end is defined in the board-specific linker script \*/

addr = (\_bss\_end + (PAGE\_SIZE - 1)) & ~(PAGE\_SIZE - 1);

size = vfd\_setmem (addr);

gd->fb\_base = addr;

\#endif /\* CONFIG\_VFD \*/

\#ifdef CONFIG\_LCD

\#     ifndef PAGE\_SIZE

\#       define PAGE\_SIZE 4096

\#     endif

/\*

\* reserve memory for LCD display (always full pages)

\*/

/\* bss\_end is defined in the board-specific linker script \*/

addr = (\_bss\_end + (PAGE\_SIZE - 1)) & ~(PAGE\_SIZE - 1);

size = lcd\_setmem (addr);

gd->fb\_base = addr;

\#endif /\* CONFIG\_LCD \*/

/\* armboot\_start is defined in the board-specific linker script \*/

mem\_malloc\_init (\_armboot\_start - CFG\_MALLOC\_LEN); //初始化malloc区域，\_armboot\_start=0x33f80000,CFG\_MALLOC\_LEN=0x30000,mem\_malloc\_init对 (0x33f80000-0x30000)~(0x33f80000)这段存储区清零

//如果定义了命令和NAND命令，初始化nand

\#if (CONFIG\_COMMANDS & CFG\_CMD\_NAND)

puts ("NAND:  ");

nand\_init();          /\*探测NAND flash并根据NAND flash的类型填充相应的数据结构,全局结构体变量nand\_dev\_desc\[0\](类型struct nand\_chip) \*/

\#endif

\#ifdef CONFIG\_HAS\_DATAFLASH //没定义

AT91F\_DataflashInit();

dataflash\_print\_info();

\#endif

/\* initialize environment配置环境变量，重新定位 \*/ \*/

env\_relocate ();这个函数在common\\env\_common.c中

\#ifdef CONFIG\_VFD 没定义

/\* must do this after the framebuffer is allocated \*/

drv\_vfd\_init();

\#endif /\* CONFIG\_VFD \*/

/\* IP Address 从环境变量中获取IP地址 \*/ \*/

gd->bd->bi\_ip\_addr = getenv\_IPaddr ("ipaddr");

/\* MAC Address \*/

int i;

ulong reg;

char \*s, \*e;

char tmp\[64\];

//从环境变量获取网卡的MAC地址并填充gd结构体变量

i = getenv\_r ("ethaddr", tmp, sizeof (tmp));

s = (i > 0) ? tmp : NULL;

for (reg = 0; reg < 6; ++reg) \{

gd->bd->bi\_enetaddr\[reg\] = s ? simple\_strtoul (s, &e, 16) : 0;

if (s)

s = (\*e) ? e + 1 : e;

\#ifdef CONFIG\_HAS\_ETH1

i = getenv\_r ("eth1addr", tmp, sizeof (tmp));

s = (i > 0) ? tmp : NULL;

for (reg = 0; reg < 6; ++reg) \{

gd->bd->bi\_enet1addr\[reg\] = s ? simple\_strtoul (s, &e, 16) : 0;

if (s)

s = (\*e) ? e + 1 : e;

\#endif

devices\_init ();      /\* get the devices list going. 对设备初始化，在common/devices.c文件中，会根据配置来完成各个设备的初始化，其中会调用函数drv\_system\_init()，这个函数对串口设备初始化,然后注册串口设备\*/

\#ifdef CONFIG\_CMC\_PU2 //没定义

load\_sernum\_ethaddr ();

\#endif /\* CONFIG\_CMC\_PU2 \*/

jumptable\_init ();//跳转表初始化，函数在common\\exports.c文件中

console\_init\_r ();   /\* fully init console as a device函数在common\\console.c \*/

\#if defined(CONFIG\_MISC\_INIT\_R)  //没有定义

/\* miscellaneous platform dependent initialisations \*/

misc\_init\_r ();

\#endif

/\* enable exceptions \*/

enable\_interrupts ();//使能中断，cpu/arm920t/interrupts.c smdk2410是个空函数void enable\_interrupts (void)\{return;\} \*/

/\* Perform network card initialisation if necessary \*/

\#ifdef CONFIG\_DRIVER\_CS8900 /\*smdk2410没定义\*/

cs8900\_get\_enetaddr (gd->bd->bi\_enetaddr); //获取网卡的MAC地址

\#endif

\#if defined(CONFIG\_DRIVER\_SMC91111) || defined (CONFIG\_DRIVER\_LAN91C96)

if (getenv ("ethaddr")) \{

smc\_set\_mac\_addr(gd->bd->bi\_enetaddr);

\#endif /\* CONFIG\_DRIVER\_SMC91111 || CONFIG\_DRIVER\_LAN91C96 没定义 \*/

/\* Initialize from environment \*/

if ((s = getenv ("loadaddr")) != NULL) \{

load\_addr = simple\_strtoul (s, NULL, 16);//读取环境变量loadaddr到全局变量load\_addr中

\#if (CONFIG\_COMMANDS & CFG\_CMD\_NET)

if ((s = getenv ("bootfile")) != NULL) \{

copy\_filename (BootFile, s, sizeof (BootFile));//读取环境变量bootfile到全局变量BootFile中

\#endif     /\* CFG\_CMD\_NET \*/

\#ifdef BOARD\_LATE\_INIT //没定义

board\_late\_init ();

\#endif

\#if (CONFIG\_COMMANDS & CFG\_CMD\_NET)

\#if defined(CONFIG\_NET\_MULTI)  // smdk2410没定义

puts ("Net:   ");

\#endif

eth\_initialize(gd->bd);

\#endif

/\* main\_loop() can return to retry autoboot, if so just run it again. \*/

for (;;) \{

main\_loop ();//直接进入main\_loop 该函数在common\\main.c中，至此，硬件初始化完成

/\* NOTREACHED - no way out of command loop except booting \*/

对start\_armboot中相关调用的函数分析

这里flash\_init定义在board/smdk2410/flash.c:

ulong flash\_init (void)

int i, j;

ulong size = 0;

for (i = 0; i < CFG\_MAX\_FLASH\_BANKS; i++) \{

ulong flashbase = 0;

flash\_info\[i\].flash\_id =    /\*保存flash ID\*/

\#if defined(CONFIG\_AMD\_LV400)

(AMD\_MANUFACT & FLASH\_VENDMASK) |

(AMD\_ID\_LV400B & FLASH\_TYPEMASK);

\#elif defined(CONFIG\_AMD\_LV800)

(AMD\_MANUFACT & FLASH\_VENDMASK) |

(AMD\_ID\_LV800B & FLASH\_TYPEMASK);

\#else

\#error "Unknown flash configured"

\#endif

/\*保存每个flash blank的大小,sector数量，起始地址等信息\*/

flash\_info\[i\].size = FLASH\_BANK\_SIZE;

flash\_info\[i\].sector\_count = CFG\_MAX\_FLASH\_SECT;

memset (flash\_info\[i\].protect, 0, CFG\_MAX\_FLASH\_SECT);

if (i == 0)

flashbase = PHYS\_FLASH\_1;

else

panic ("configured too many flash banks!\\n");

/\*为每个sector分配不同的大小，作为不同的用途\*/

for (j = 0; j < flash\_info\[i\].sector\_count; j++) \{

if (j <= 3) \{

/\* 1st one is 16 KB \*/

if (j == 0) \{

flash\_info\[i\].start\[j\] =

flashbase + 0;

/\* 2nd and 3rd are both 8 KB \*/

if ((j == 1) || (j == 2)) \{

flash\_info\[i\].start\[j\] =

flashbase + 0x4000 + (j -

1) \*

0x2000;

/\* 4th 32 KB \*/

if (j == 3) \{

flash\_info\[i\].start\[j\] =

flashbase + 0x8000;

\} else \{

flash\_info\[i\].start\[j\] =

flashbase + (j - 3) \* MAIN\_SECT\_SIZE;

size += flash\_info\[i\].size;

/\*对flash上保存有RO, RW的地方进行保护，monitor\_flash\_len ＝ RO + RW的长度\*/

flash\_protect (FLAG\_PROTECT\_SET,

CFG\_FLASH\_BASE,

CFG\_FLASH\_BASE + monitor\_flash\_len - 1,

&flash\_info\[0\]);

//对flash上保存有环境变量的地方进行保护

flash\_protect (FLAG\_PROTECT\_SET,

CFG\_ENV\_ADDR,

CFG\_ENV\_ADDR + CFG\_ENV\_SIZE - 1, &flash\_info\[0\]);

return size;

该函数就是记录下flash的大小，数量，sector的大小数量等，并对flash上重要的数据进行保护

display\_flash\_config 定义在lib\_arm/board.c:

\#ifndef CFG\_NO\_FLASH

static void display\_flash\_config (ulong size)

puts ("Flash: ");

print\_size (size, "\\n");

\#endif

很简单，打印flash的大小信息。

mem\_malloc\_init定义在lib\_arm/board.c:

static ulong mem\_malloc\_start = 0;

static ulong mem\_malloc\_end = 0;

static ulong mem\_malloc\_brk = 0;

static void mem\_malloc\_init (ulong dest\_addr)

mem\_malloc\_start = dest\_addr;

mem\_malloc\_end = dest\_addr + CFG\_MALLOC\_LEN;

mem\_malloc\_brk = mem\_malloc\_start;

memset ((void \*) mem\_malloc\_start, 0,

mem\_malloc\_end - mem\_malloc\_start);

这个函数就是保存malloc区域的起始地址，结束地址，并清0这块区域，这块区域在RAM中的具体位置可查看前面的图。

接着看env\_relocate

Uboot在完成汇编部分的初始化之后，将跳到start\_armboot()去执行，其中便会执行env\_relocate()初始化环境变量。

第一步，初始化一个全局指针，它被定义为：

env\_t \*env\_ptr = 0;

第二步，重新初始化函数指针，

static uchar env\_get\_char\_init (int index);

uchar (\*env\_get\_char)(int) = env\_get\_char\_init;

该函数指针原来被初始化为env\_get\_char\_init，现在改为env\_get\_char\_memory。对于nand flash，这两个函数是一样的。

第三步，如果flash没有参数表，则使用默认参数，这里是通过memcpy (env\_ptr->data,default\_environment, sizeof(default\_environment));来加载。

第四步，如果flash上有参数表可用，则从flash上加载，通过env\_relocate\_spec()来实现：

第五步，gd->env\_addr = (ulong)&(env\_ptr->data)

即将环境变量的值赋值给全局变量gd->env\_addr，这样只要通过这个全局变量就可以访问这些变量了。值得一提的是，字符串数组data里面的变量与变量之间是通过’/0’来分割的。

common/env\_common.c:

env\_t \*env\_ptr = 0;

void env\_relocate (void)

DEBUGF ("%s\[%d\] offset = 0x%lx\\n", \_\_FUNCTION\_\_,\_\_LINE\_\_,

gd->reloc\_off);

\#ifdef CONFIG\_AMIGAONEG3SE //没有定义

enable\_nvram();

\#endif

/\*env\_ptr指向存放环境变量的区域\*/

\#ifdef ENV\_IS\_EMBEDDED

/\*

\* The environment buffer is embedded with the text segment,

\* just relocate the environment pointer

\*/

env\_ptr = (env\_t \*)((ulong)env\_ptr + gd->reloc\_off);

DEBUGF ("%s\[%d\] embedded ENV at %p\\n", \_\_FUNCTION\_\_,\_\_LINE\_\_,env\_ptr);

\#else

/\*

\* We must allocate a buffer for the environment

\*/

env\_ptr = (env\_t \*)malloc (CFG\_ENV\_SIZE);//为环境变量分配内存,env\_ptr是全局变量,在下面的env\_relocate\_spec ()函数中将环境变量读取到env\_ptr指向的内存中

DEBUGF ("%s\[%d\] malloced ENV at %p\\n", \_\_FUNCTION\_\_,\_\_LINE\_\_,env\_ptr);

\#endif

/\*

\* After relocation to RAM, we can always use the "memory" functions

\*/

env\_get\_char = env\_get\_char\_memory;

/\*如果在env\_init中没有初始化合适的环境变量则使用默认的环境变量来作为环境变量值,否则使用env\_init中定义好的环境变量值\*/

在env\_init函数中如果使用环境变量地址是include/configs/smdk2410.h配置的gd->env\_valid被初始化为1，即flash上有参数表，如果使用环境变量是默认的环境变量default\_environment，则gd->env\_valid被初始化为0了。

if (gd->env\_valid == 0) \{ //如果flash没有参数表，则使用默认参数，这里是通过下面

来加载。

\#if defined(CONFIG\_GTH)  || defined(CFG\_ENV\_IS\_NOWHERE)       /\* Environment not changable \*/

puts ("Using default environment\\n\\n");

\#else

puts ("\*\*\* Warning - bad CRC, using default environment\\n\\n");

SHOW\_BOOT\_PROGRESS (-1);

\#endif

if (sizeof(default\_environment) > ENV\_SIZE)

puts ("\*\*\* Error - default environment is too large\\n\\n");

return;

memset (env\_ptr, 0, sizeof(env\_t));

memcpy (env\_ptr->data,

default\_environment,

sizeof(default\_environment)); /\*把默认值存入RAM相应区域\*/

\#ifdef CFG\_REDUNDAND\_ENVIRONMENT

env\_ptr->flags = 0xFF;

\#endif

env\_crc\_update ();/\*更新crc校验值\*/

gd->env\_valid = 1; /\*标记环境变量有效\*/

else \{

env\_relocate\_spec ();/\*如果flash上有参数表可用，则从flash上加载，通过env\_relocate\_spec()来实现\*/

gd->env\_addr = (ulong)&(env\_ptr->data); //填充结构体变量, 即将环境变量的值赋值给全局变量gd->env\_addr，这样只要通过这个全局变量就可以访问这些变量了。值得一提的是，字符串数组data里面的变量与变量之间是通过’/0’来分割的。

\#ifdef CONFIG\_AMIGAONEG3SE //没定义

disable\_nvram();

\#endif

该函数重新分配了一块区域用于存放环境变量，并在gd\_t区域保存了这个地址值。

void env\_relocate\_spec (void)

\#if !defined(ENV\_IS\_EMBEDDED) //如果不是使用嵌入参数的形式，即为参数表的形式

ulong total;

int ret;

total = CFG\_ENV\_SIZE;//参数表大小，包括参数表头部

/\*从nand flash 中读取环境变量到全局变量env\_ptr指向的内存中,这里需要注意的是CFG\_ENV\_OFFSET、//CFG\_ENV\_SIZE这两个宏定义,它们表示从NAND flash中偏移为CFG\_ENV\_OFFSET处读取大小为CFG\_ENV\_SIZE字节//的数据,注意这两个宏定义决定了环境变量在nand flash中保存的位置和大小,不能和nand flash 中的其他分区(kernel分区、rootfs分区)相冲突,不然在执行saveenv命令时可能会覆盖其他分区的内容,导致系统无法启动.\*/

ret = nand\_read(&nand\_info\[0\], CFG\_ENV\_OFFSET, &total, (u\_char\*)env\_ptr);  //读出操作，flash设备为nand\_info，偏移为CFG\_ENV\_OFFSET，读出的大小为total，目标地址由env\_ptr所指。

if (ret || total != CFG\_ENV\_SIZE)

return use\_default();//如果读出的长度不对或出错，则使用默认值

if (crc32(0, env\_ptr->data, ENV\_SIZE) != env\_ptr->crc)

return use\_default();//如果校验出错，使用默认值

\#endif /\* ! ENV\_IS\_EMBEDDED \*/

\#endif /\* CFG\_ENV\_OFFSET\_REDUND \*/

该函数实现真正的重定位功能,先从NAND flash中读取环境变量,如果读取成功,并且crc校验正确的话,就使用NAND flash中读取出来的环境变量,否则使用默认的环境变量

此外，uboot的参数表还支持一种被称为CFG\_ENV\_OFFSET\_REDUND的冗余模式，它会在flash上保存两个参数表副本，这样在一个副本出错的时候，还可以从另一个副本中去读取，通过这种方式，提高了数据的安全性。

接着看devices\_init: common/devices.c:

int devices\_init (void)

\#ifndef CONFIG\_ARM     /\* already relocated for current ARM implementation \*/

ulong relocation\_offset = gd->reloc\_off;

int i;

/\* relocate device name pointers \*/

for (i = 0; i < (sizeof (stdio\_names) / sizeof (char \*)); ++i) \{

stdio\_names\[i\] = (char \*) (((ulong) stdio\_names\[i\]) +

relocation\_offset);

\#endif

/\* Initialize the list 创建一个保存device的列表\*/\*/

devlist = ListCreate (sizeof (device\_t));

if (devlist == NULL) \{

eputs ("Cannot initialize the list of devices!\\n");

return -1;

\#if defined(CONFIG\_HARD\_I2C) || defined(CONFIG\_SOFT\_I2C) //没定义

i2c\_init (CFG\_I2C\_SPEED, CFG\_I2C\_SLAVE);

\#endif

\#ifdef CONFIG\_LCD//没定义

drv\_lcd\_init ();

\#endif

\#if defined(CONFIG\_VIDEO) || defined(CONFIG\_CFB\_CONSOLE) //没定义

drv\_video\_init ();

\#endif

\#ifdef CONFIG\_KEYBOARD//没定义

drv\_keyboard\_init ();

\#endif

\#ifdef CONFIG\_LOGBUFFER//没定义

drv\_logbuff\_init ();

\#endif

drv\_system\_init ();

\#ifdef CONFIG\_SERIAL\_MULTI//没定义

serial\_devices\_init ();

\#endif

\#ifdef CONFIG\_USB\_TTY//没定义

drv\_usbtty\_init ();

\#endif

\#ifdef CONFIG\_NETCONSOLE //没定义

drv\_nc\_init ();

\#endif

return (0);

这个函数实际上就是根据板子的配置初始化各种设备，并调用device\_register()注册到系统中去，在这个中函数仅对串口设备初始化,然后注册串口设备.这里我们以drv\_system\_init为例解释一下，定义也在common/devices.c，其他代码类似。

static void drv\_system\_init (void)

device\_t dev;

memset (&dev, 0, sizeof (dev));

strcpy (dev.name, "serial"); /\*串口设备\*/

dev.flags = DEV\_FLAGS\_OUTPUT | DEV\_FLAGS\_INPUT | DEV\_FLAGS\_SYSTEM; /\*设备属性\*/

\#ifdef CONFIG\_SERIAL\_SOFTWARE\_FIFO

/\*注册设备操作函数集（输入函数，输出函数等）\*/

dev.putc = serial\_buffered\_putc;

dev.puts = serial\_buffered\_puts;

dev.getc = serial\_buffered\_getc;

dev.tstc = serial\_buffered\_tstc;

\#else

dev.putc = serial\_putc;

dev.puts = serial\_puts;

dev.getc = serial\_getc;

dev.tstc = serial\_tstc;

\#endif

device\_register (&dev); /\*把该设备注册进系统中去，即把dev添加进上面创建的设备列表中去\*/

\#ifdef CFG\_DEVICE\_NULLDEV

memset (&dev, 0, sizeof (dev));

strcpy (dev.name, "nulldev");

dev.flags = DEV\_FLAGS\_OUTPUT | DEV\_FLAGS\_INPUT | DEV\_FLAGS\_SYSTEM;

dev.putc = nulldev\_putc;

dev.puts = nulldev\_puts;

dev.getc = nulldev\_input;

dev.tstc = nulldev\_input;

device\_register (&dev);

\#endif

该函数注册了一个串口设备和一个空设备（根据配置而定）。其他的设备初始化函数以此大同小异，主要就是初始化好相关设备的设备信息，并注册到系统中去，详细代码大家可以自己去分析。

接下来看jumptable\_init

common/exports.c

void jumptable\_init (void)

int i;

/\*分配一块buffer用于存放跳转函数地址\*/

gd->jt = (void \*\*) malloc (XF\_MAX \* sizeof (void \*));

for (i = 0; i < XF\_MAX; i++)

gd->jt\[i\] = (void \*) dummy; /\*默认跳转函数地址，是一个空函数的地址\*/

/\*为每种功能定义各自的跳转函数\*/

gd->jt\[XF\_get\_version\] = (void \*) get\_version;

gd->jt\[XF\_malloc\] = (void \*) malloc;

gd->jt\[XF\_free\] = (void \*) free;

gd->jt\[XF\_getenv\] = (void \*) getenv;

gd->jt\[XF\_setenv\] = (void \*) setenv;

gd->jt\[XF\_get\_timer\] = (void \*) get\_timer;

gd->jt\[XF\_simple\_strtoul\] = (void \*) simple\_strtoul;

gd->jt\[XF\_udelay\] = (void \*) udelay;

\#if defined(CONFIG\_I386) || defined(CONFIG\_PPC)

gd->jt\[XF\_install\_hdlr\] = (void \*) irq\_install\_handler;

gd->jt\[XF\_free\_hdlr\] = (void \*) irq\_free\_handler;

\#endif     /\* I386 || PPC \*/

\#if (CONFIG\_COMMANDS & CFG\_CMD\_I2C)

gd->jt\[XF\_i2c\_write\] = (void \*) i2c\_write;

gd->jt\[XF\_i2c\_read\] = (void \*) i2c\_read;

\#endif     /\* CFG\_CMD\_I2C \*/

static void dummy(void)

以看出该函数主要就是为不同的功能安装了不同的功能函数。

继续看console\_init\_r（）函数

common/console.c

/\* Called after the relocation - use desired console functions \*/

int console\_init\_r (void)

/\*1. 首先获取由device\_init里注册的input,output设备\*/

device\_t \*inputdev = NULL, \*outputdev = NULL;

int i, items = ListNumItems (devlist);

\#ifdef CONFIG\_SPLASH\_SCREEN //没定义

/\* suppress all output if splash screen is enabled and we have

a bmp to display                                            \*/

if (getenv("splashimage") != NULL)

outputdev = search\_device (DEV\_FLAGS\_OUTPUT, "nulldev");

\#endif

\#ifdef CONFIG\_SILENT\_CONSOLE //没定义

/\* Suppress all output if "silent" mode requested           \*/

if (gd->flags & GD\_FLG\_SILENT)

outputdev = search\_device (DEV\_FLAGS\_OUTPUT, "nulldev");

\#endif

/\* Scan devices looking for input and output devices \*/

/\*寻找系统上存在的输入，输出设备，别忘了上面注册的串口设备就是输入，输出设备\*/

for (i = 1;

(i <= items) && ((inputdev == NULL) || (outputdev == NULL));

i++

) \{

device\_t \*dev = ListGetPtrToItem (devlist, i);

if ((dev->flags & DEV\_FLAGS\_INPUT) && (inputdev == NULL)) \{

inputdev = dev; /\*找到输入设备，参考drv\_system\_init \*/

if ((dev->flags & DEV\_FLAGS\_OUTPUT) && (outputdev == NULL)) \{

outputdev = dev; /\*找到输出设备，参考drv\_system\_init \*/

/\* Initializes output console first \*/

/\*由drv\_system\_init可知，我们可以找到输入，输出设备，而且都是同一个serial设备\*/

if (outputdev != NULL) \{

console\_setfile (stdout, outputdev); /\*设置标准输出设备\*/

console\_setfile (stderr, outputdev); /\*设置标准的错误输出设备\*/

/\* Initializes input console \*/

if (inputdev != NULL) \{

console\_setfile (stdin, inputdev); /\*设置标准输入设备\*/

gd->flags |= GD\_FLG\_DEVINIT;      /\* device initialization completed 设置初始化完成标记\*/

\#ifndef CFG\_CONSOLE\_INFO\_QUIET

/\* Print information 打印相关设备信息\*/

puts ("In:    ");

if (stdio\_devices\[stdin\] == NULL) \{

puts ("No input devices available!\\n");

\} else \{

printf ("%s\\n", stdio\_devices\[stdin\]->name);

puts ("Out:   ");

if (stdio\_devices\[stdout\] == NULL) \{

puts ("No output devices available!\\n");

\} else \{

printf ("%s\\n", stdio\_devices\[stdout\]->name);

puts ("Err:   ");

if (stdio\_devices\[stderr\] == NULL) \{

puts ("No error devices available!\\n");

\} else \{

printf ("%s\\n", stdio\_devices\[stderr\]->name);

\#endif /\* CFG\_CONSOLE\_INFO\_QUIET \*/

/\* Setting environment variables 设置环境变量\*/

for (i = 0; i < 3; i++) \{

setenv (stdio\_names\[i\], stdio\_devices\[i\]->name);

\#if 0

/\* If nothing usable installed, use only the initial console \*/

if ((stdio\_devices\[stdin\] == NULL) && (stdio\_devices\[stdout\] == NULL))

return (0);

\#endif

return (0);

该函数主要是设置好了标准输入，标准输出，标准错误输出设备，并定义好相关输入，输出函数，以使后面的如puts()，printf()等函数可以运行，这个应该不陌生的。为了一解疑惑我们可以继续分析下去：

static int console\_setfile (int file, device\_t \* dev)  common/console.c

int error = 0;

if (dev == NULL)

return -1;

switch (file) \{

case stdin:

case stdout:

case stderr:

/\* Start new device \*/

if (dev->start) \{

error = dev->start ();/\*在drv\_system\_init下没定义这个函数\*/

/\* If it's not started dont use it \*/

if (error < 0)

break;

/\* Assign the new device (leaving the existing one started) \*/

stdio\_devices\[file\] = dev; /\*保存标准输入，标准输出，标准错误输出设备\*/

/\*

\* Update monitor functions

\* (to use the console stuff by other applications)

\*/

设置好标准输入，标准输出，标准错误输出设备的输入，输出函数，可以从drv\_system\_init下查到

switch (file) \{

case stdin:

gd->jt\[XF\_getc\] = dev->getc;

gd->jt\[XF\_tstc\] = dev->tstc;

break;

case stdout:

gd->jt\[XF\_putc\] = dev->putc;

gd->jt\[XF\_puts\] = dev->puts;

gd->jt\[XF\_printf\] = printf;

break;

default:          /\* Invalid file ID \*/

error = -1;

return error;

这个函数就是初始化好标准输入，标准输出，标准错误输出设备，这以后就可以调用如puts,printf等函数了. 我们以puts为例继续分析:

common/console.c:

void puts (const char \*s)

\#ifdef CONFIG\_SILENT\_CONSOLE

if (gd->flags & GD\_FLG\_SILENT)

return;

\#endif

if (gd->flags & GD\_FLG\_DEVINIT) \{//这个标记前面设置过了

/\* Send to the standard output \*/

fputs (stdout, s); /\*就是调用这个函数\*/

\} else \{

/\* Send directly to the handler \*/

serial\_puts (s);

void fputs (int file, const char \*s)

if (file < MAX\_FILES)

stdio\_devices\[file\]->puts (s); 这里就是调用我们初始化时设置的了即serial\_puts（）函数，可以在drv\_system\_init查到

serial\_puts函数就是和具体设备相关了，对于smdk2410的代码如下

cpu/arm920t/s3c24x0/serial.c:

void serial\_puts (const char \*s)

while (\*s) \{

serial\_putc (\*s++);

void serial\_putc (const char c)   cpu/arm920t/s3c24x0/serial.c

S3C24X0\_UART \* const uart = S3C24X0\_GetBase\_UART(UART\_NR);

\#ifdef CONFIG\_MODEM\_SUPPORT

if (be\_quiet)

return;

\#endif

/\* wait for room in the tx FIFO \*/

while (!(uart->UTRSTAT & 0x2));

\#ifdef CONFIG\_HWFLOW

/\* Wait for CTS up \*/

while(hwflow && !(uart->UMSTAT & 0x1))

;

\#endif

uart->UTXH = c;

/\* If \\n, also do \\r \*/

if (c == '\\n')

serial\_putc ('\\r');

这些函数对照着datasheet就很好理解了。

printf函数最终也是调用puts函数。

至此我们对打印的来龙去脉了解了。

接下来主要分析main\_loop(),common/main.c

void main\_loop (void)

\#ifndef CFG\_HUSH\_PARSER  /\*smdk2410没定义\*/

static char lastcommand\[CFG\_CBSIZE\] = \{ 0, \};

int len;

int rc = 1;

int flag;

\#endif

\#if defined(CONFIG\_BOOTDELAY) && (CONFIG\_BOOTDELAY >= 0)

char \*s;

int bootdelay;

\#endif

\#ifdef CONFIG\_PREBOOT

char \*p;

\#endif

\#ifdef CONFIG\_BOOTCOUNT\_LIMIT

unsigned long bootcount = 0;

unsigned long bootlimit = 0;

char \*bcs;

char bcs\_set\[16\];

\#endif /\* CONFIG\_BOOTCOUNT\_LIMIT \*/

\#if defined(CONFIG\_VFD) && defined(VFD\_TEST\_LOGO)  /\*smdk2410没定义\*/

ulong bmp = 0;           /\* default bitmap \*/

extern int trab\_vfd (ulong bitmap);

\#ifdef CONFIG\_MODEM\_SUPPORT  /\*smdk2410没定义\*/

if (do\_mdm\_init)

bmp = 1;       /\* alternate bitmap \*/

\#endif

trab\_vfd (bmp);

\#endif     /\* CONFIG\_VFD && VFD\_TEST\_LOGO \*/

\#ifdef CONFIG\_BOOTCOUNT\_LIMIT  /\*smdk2410没定义\*/

bootcount = bootcount\_load();

bootcount++;

bootcount\_store (bootcount);

sprintf (bcs\_set, "%lu", bootcount);

setenv ("bootcount", bcs\_set);

bcs = getenv ("bootlimit");

bootlimit = bcs ? simple\_strtoul (bcs, NULL, 10) : 0;

\#endif /\* CONFIG\_BOOTCOUNT\_LIMIT \*/

\#ifdef CONFIG\_MODEM\_SUPPORT  /\*smdk2410没定义\*/

debug ("DEBUG: main\_loop:   do\_mdm\_init=%d\\n", do\_mdm\_init);

if (do\_mdm\_init) \{

char \*str = strdup(getenv("mdm\_cmd"));

setenv ("preboot", str);  /\* set or delete definition \*/

if (str != NULL)

free (str);

mdm\_init(); /\* wait for modem connection \*/

\#endif  /\* CONFIG\_MODEM\_SUPPORT \*/

\#ifdef CONFIG\_VERSION\_VARIABLE  /\*smdk2410没定义\*/

extern char version\_string\[\];

setenv ("ver", version\_string);  /\* set version variable \*/

\#endif /\* CONFIG\_VERSION\_VARIABLE \*/

\#ifdef CFG\_HUSH\_PARSER  /\*smdk2410没定义\*/

u\_boot\_hush\_start ();

\#endif

\#ifdef CONFIG\_AUTO\_COMPLETE /\*smdk2410没定义\*/

install\_auto\_complete();

\#endif

\#ifdef CONFIG\_PREBOOT  /\*smdk2410没定义\*/

if ((p = getenv ("preboot")) != NULL) \{

\# ifdef CONFIG\_AUTOBOOT\_KEYED  /\*smdk2410没定义\*/

int prev = disable\_ctrlc(1);  /\* disable Control C checking \*/

\# endif

\# ifndef CFG\_HUSH\_PARSER  /\*smdk2410没定义\*/

run\_command (p, 0);

\# else

parse\_string\_outer(p, FLAG\_PARSE\_SEMICOLON |

FLAG\_EXIT\_FROM\_LOOP);

\# endif

\# ifdef CONFIG\_AUTOBOOT\_KEYED  /\*smdk2410没定义\*/

disable\_ctrlc(prev);/\* restore Control C checking \*/

\# endif

\#endif /\* CONFIG\_PREBOOT \*/

\#if defined(CONFIG\_BOOTDELAY) && (CONFIG\_BOOTDELAY >= 0)

s = getenv ("bootdelay");

bootdelay = s ? (int)simple\_strtol(s, NULL, 10) : CONFIG\_BOOTDELAY;

debug ("\#\#\# main\_loop entered: bootdelay=%d\\n\\n", bootdelay);

\# ifdef CONFIG\_BOOT\_RETRY\_TIME

init\_cmd\_timeout ();

\# endif   /\* CONFIG\_BOOT\_RETRY\_TIME \*/

\#ifdef CONFIG\_BOOTCOUNT\_LIMIT

if (bootlimit && (bootcount > bootlimit)) \{

printf ("Warning: Bootlimit (%u) exceeded. Using altbootcmd.\\n",

(unsigned)bootlimit);

s = getenv ("altbootcmd");

else

\#endif /\* CONFIG\_BOOTCOUNT\_LIMIT \*/

s = getenv ("bootcmd"); /\*smdk2410下这个环境变量是空的\*/

debug ("\#\#\# main\_loop: bootcmd=\\"%s\\"\\n", s ? s : "<UNDEFINED>");

if (bootdelay >= 0 && s && !abortboot (bootdelay)) \{

\# ifdef CONFIG\_AUTOBOOT\_KEYED

int prev = disable\_ctrlc(1);  /\* disable Control C checking \*/

\# endif

\# ifndef CFG\_HUSH\_PARSER

run\_command (s, 0);

\# else

parse\_string\_outer(s, FLAG\_PARSE\_SEMICOLON |

FLAG\_EXIT\_FROM\_LOOP);

\# endif

\# ifdef CONFIG\_AUTOBOOT\_KEYED

disable\_ctrlc(prev);/\* restore Control C checking \*/

\# endif

\# ifdef CONFIG\_MENUKEY

if (menukey == CONFIG\_MENUKEY) \{

s = getenv("menucmd");

if (s) \{

\# ifndef CFG\_HUSH\_PARSER

run\_command (s, 0);

\# else

parse\_string\_outer(s, FLAG\_PARSE\_SEMICOLON |

FLAG\_EXIT\_FROM\_LOOP);

\# endif

\#endif /\* CONFIG\_MENUKEY \*/

\#endif     /\* CONFIG\_BOOTDELAY \*/

\#ifdef CONFIG\_AMIGAONEG3SE

extern void video\_banner(void);

video\_banner();

\#endif

/\*

\* Main Loop for Monitor Command Processing  最核心的就是这个死循环

\*/

\#ifdef CFG\_HUSH\_PARSER

parse\_file\_outer();

/\* This point is never reached \*/

for (;;);

\#else

for (;;) \{

\#ifdef CONFIG\_BOOT\_RETRY\_TIME

if (rc >= 0) \{

/\* Saw enough of a valid command to

\* restart the timeout.

\*/

reset\_cmd\_timeout();

\#endif

len = readline (CFG\_PROMPT);

flag = 0;       /\* assume no special flags for now \*/

if (len > 0)

strcpy (lastcommand, console\_buffer);

else if (len == 0)

flag |= CMD\_FLAG\_REPEAT;

\#ifdef CONFIG\_BOOT\_RETRY\_TIME

else if (len == -2) \{

/\* -2 means timed out, retry autoboot

\*/

puts ("\\nTimed out waiting for command\\n");

\# ifdef CONFIG\_RESET\_TO\_RETRY

/\* Reinit board to run initialization code again \*/

do\_reset (NULL, 0, 0, NULL);

\# else

return;            /\* retry autoboot \*/

\# endif

\#endif

if (len == -1)

puts ("<INTERRUPT>\\n");

else

rc = run\_command (lastcommand, flag);

if (rc <= 0) \{

/\* invalid command or not repeatable, forget it \*/

lastcommand\[0\] = 0;

\#endif /\*CFG\_HUSH\_PARSER\*/

该函数比较长，但核心就是不停的从串口获取命令并解析执行此命令，这个功能就在函数尾部的那个死循环里，我们重点就是分析这个循环。

先看readline()

common/main.c

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

/\*

\* Prompt for input and read a line.

\* If  CONFIG\_BOOT\_RETRY\_TIME is defined and retry\_time >= 0,

\* time out when time goes past endtime (timebase time in ticks).

\* Return:     number of read characters

\*           \-1 if break

\*           \-2 if timed out

\*/上面的注释说的很清楚了，就是提示用户输入命令，并读取这个命令

int readline (const char \*const prompt)

\#ifdef CONFIG\_CMDLINE\_EDITING  /\*sdmk2410没定义\*/

char \*p = console\_buffer; /\* console\_buffer 是个全局变量\*/

unsigned int len=MAX\_CMDBUF\_SIZE;

int rc;

static int initted = 0;

if (!initted) \{

hist\_init();

initted = 1;

puts (prompt);

rc = cread\_line(p, &len);

return rc < 0 ? rc : len;

\#else

char   \*p = console\_buffer;

int   n = 0;                          /\* buffer index            \*/

int   plen = 0;                      /\* prompt length   \*/

int   col;                        /\* output column cnt   \*/

charc;

/\* print prompt \*/

if (prompt) \{ /\*如果要输出提示符，则输出\*/

plen = strlen (prompt);

puts (prompt);

col = plen;

for (;;) \{

\#ifdef CONFIG\_BOOT\_RETRY\_TIME /\*sdmk2410没定义\*/

while (!tstc()) \{     /\* while no incoming data \*/

if (retry\_time >= 0 && get\_ticks() > endtime)

return (-2);    /\* timed out \*/

\#endif

WATCHDOG\_RESET();              /\* Trigger watchdog, if needed \*/

\#ifdef CONFIG\_SHOW\_ACTIVITY  /\*sdmk2410没定义\*/

while (!tstc()) \{

extern void show\_activity(int arg);

show\_activity(0);

\#endif

c = getc();/\*从串口获取用户输入的命令\*/

/\*

\* Special character handling

\*/ /\*下面这个switch就是处理不同的字符了\*/

switch (c) \{

case '\\r':                       /\* Enter         \*/

case '\\n':

\*p = '\\0';

puts ("\\r\\n");

return (p - console\_buffer); /\*输入结束\*/

case '\\0':                       /\* nul                   \*/ /\*忽略，继续\*/

continue;

case 0x03:                           /\* ^C - break              linux下的ctrl+c功能\*/

console\_buffer\[0\] = '\\0';       /\* discard input \*/

return (-1);

case 0x15:                           /\* ^U - erase line删除       \*/

while (col > plen) \{

puts (erase\_seq);

\--col;

p = console\_buffer;

n = 0;

continue;

case 0x17:                           /\* ^W - erase word删除    \*/

p=delete\_char(console\_buffer, p, &col, &n, plen);

while ((n > 0) && (\*p != ' ')) \{

p=delete\_char(console\_buffer, p, &col, &n, plen);

continue;

case 0x08:                           /\* ^H  \- backspace      \*/

case 0x7F:                          /\* DEL - backspace     \*/

p=delete\_char(console\_buffer, p, &col, &n, plen); 删除

continue;

default:  /\*获取常规字符\*/

/\*

\* Must be a normal character then

\*/

if (n < CFG\_CBSIZE-2) \{

if (c == '\\t') \{       /\* expand TABs           \*/

\#ifdef CONFIG\_AUTO\_COMPLETE

/\* if auto completion triggered just continue \*/

/\*自动补全功能，熟悉linux的肯定知道\*/

\*p = '\\0';

if (cmd\_auto\_complete(prompt, console\_buffer, &n, &col)) \{

p = console\_buffer + n;      /\* reset \*/

continue;

\#endif

puts (tab\_seq+(col&07));

col += 8 - (col&07);

\} else \{

\++col;            /\* echo input        \*/

putc (c);

\*p++ = c; /\*把字符保存在buffer中\*/

\++n;

\} else \{                 /\* Buffer full        \*/

putc ('\\a');

\#endif /\* CONFIG\_CMDLINE\_EDITING \*/

上面这个函数就是提示用户输入，然后一直等待用户输入，指到用户输入完成, 然后获取用户数据，并存入全局变量console\_buffer中。

再来回顾下那个for循环, 核心中的核心就是run\_command函数了，一猜就知道是用户执行所有用户下达命令的函数

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

\* returns:

\*    1  \- command executed, repeatable

\*    0  \- command executed but not repeatable, interrupted commands are

\*         always considered not repeatable

\*    \-1 - not executed (unrecognized, bootd recursion or too many args)

\*           (If cmd is NULL or "" or longer than CFG\_CBSIZE-1 it is

\*           considered unrecognized)

\* WARNING:

\* We must create a temporary copy of the command since the command we get

\* may be the result from getenv(), which returns a pointer directly to

\* the environment data, which may change magicly when the command we run

\* creates or modifies environment variables (like "bootp" does).

\*/

int run\_command (const char \*cmd, int flag)

cmd\_tbl\_t \*cmdtp;

char cmdbuf\[CFG\_CBSIZE\];       /\* working copy of cmd            \*/

char \*token;                 /\* start of token in cmdbuf       \*/

char \*sep;                    /\* end of token (separator) in cmdbuf \*/

char finaltoken\[CFG\_CBSIZE\];

char \*str = cmdbuf;

char \*argv\[CFG\_MAXARGS + 1\];    /\* NULL terminated     \*/

int argc, inquotes;

int repeatable = 1;

int rc = 0;

\#ifdef DEBUG\_PARSER

printf ("\[RUN\_COMMAND\] cmd\[%p\]=\\"", cmd);

puts (cmd ? cmd : "NULL");     /\* use puts - string may be loooong \*/

puts ("\\"\\n");

\#endif

clear\_ctrlc();          /\* forget any previous Control C \*/

if (!cmd || !\*cmd) \{   /\*先是对命令的有效性进行检测\*/

return -1;       /\* empty command \*/

if (strlen(cmd) >= CFG\_CBSIZE) \{

puts ("\#\# Command too long!\\n");

return -1;

strcpy (cmdbuf, cmd); /\*备份command\*/

/\* Process separators and check for invalid

\* repeatable commands

\*/

\#ifdef DEBUG\_PARSER

printf ("\[PROCESS\_SEPARATORS\] %s\\n", cmd);

\#endif

while (\*str) \{ /\*看前面的定义，str指向cmdbuf \*/

/\*

\* Find separator, or string end

\* Allow simple escape of ';' by writing "\\;"

\*/   /\*下面这个for是对u-boot的特殊语法的解析，这里就不分析了\*/

for (inquotes = 0, sep = str; \*sep; sep++) \{

if ((\*sep=='\\'') &&

(\*(sep-1) != '\\\\'))

inquotes=!inquotes;

if (!inquotes &&

(\*sep == ';') &&   /\* separator           \*/

( sep != str) &&  /\* past string start\*/

(\*(sep-1) != '\\\\'))   /\* and NOT escaped    \*/

break;

/\*

\* Limit the token to data between separators

\*/

token = str;

if (\*sep) \{

str = sep + 1;      /\* start of command for next pass \*/

\*sep = '\\0';

else

str = sep;       /\* no more commands for next pass \*/

\#ifdef DEBUG\_PARSER

printf ("token: \\"%s\\"\\n", token);

\#endif

/\* find macros in this token and replace them \*/

process\_macros (token, finaltoken);

/\* Extract arguments \*/

if ((argc = parse\_line (finaltoken, argv)) == 0) \{ /\*获取参数\*/

rc = -1;  /\* no command at all \*/

continue;

/\* Look up command in command table \*/

if ((cmdtp = find\_cmd(argv\[0\])) == NULL) \{ /\*获取对应的command\*/

printf ("Unknown command '%s' - try 'help'\\n", argv\[0\]);

rc = -1;  /\* give up after bad command \*/

continue;

/\* found - check max args \*/

if (argc > cmdtp->maxargs) \{ /\*检测command语法是否正确\*/

printf ("Usage:\\n%s\\n", cmdtp->usage);

rc = -1;

continue;

\#if (CONFIG\_COMMANDS & CFG\_CMD\_BOOTD)

/\* avoid "bootd" recursion \*/

if (cmdtp->cmd == do\_bootd) \{

\#ifdef DEBUG\_PARSER

printf ("\[%s\]\\n", finaltoken);

\#endif

if (flag & CMD\_FLAG\_BOOTD) \{

puts ("'bootd' recursion detected\\n");

rc = -1;

continue;

\} else \{

flag |= CMD\_FLAG\_BOOTD;

\#endif     /\* CFG\_CMD\_BOOTD \*/

/\* OK - call function to do the command \*/

if ((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0) \{ /\*执行具体的command\*/

rc = -1;

repeatable &= cmdtp->repeatable;

/\* Did the user stop this? \*/

if (had\_ctrlc ())

return 0;/\* if stopped then not repeatable \*/

return rc ? rc : repeatable;

这个函数主要是对用户输入的命令进行语法分析，从中获取命令，参数等信息，并查找一张系统保存的命令表，找到该命令对应的处理函数。并调用它来处理这个命令。

下面先详细分析这张系统的命令表是如何生成的，以添加一个命令为例，来详细说明。

U-Boot添加命令

一、相关数据定义说明

首先看的是命令表中存的每个命令的属性,结构体cmd\_tbl\_t在include/command.h中定义如下：

struct cmd\_tbl\_s \{

char        \*name;           /\* Command Name命令名  \*/

int          maxargs;/\* maximum number of arguments最大参数个数   \*/

int          repeatable;       /\* autorepeat allowed?  是否自动重复       \*/

/\* Implementation function  \*/

int          (\*cmd)(struct cmd\_tbl\_s \*, int, int, char \*\[\]); /\*  响应函数 \*/

char        \*usage;            /\* Usage message  (short) 简短的帮助信息      \*/

\#ifdef      CFG\_LONGHELP

char        \*help;             /\* Help  message  (long)     较详细的帮助信息\*/

\#endif

\#ifdef CONFIG\_AUTO\_COMPLETE

/\* do auto completion on the arguments自动补全参数\*/

int          (\*complete)(int argc, char \*argv\[\], char last\_char, int maxv, char \*cmdv\[\]);

\#endif

\};

内存中保存命令的help字段会占用一定的内存，通过配置U-Boot可以选择是否保存help字段。若在include/configs/smdk2410.h中定义了CFG\_LONGHELP宏，则在U-Boot中使用help命令查看某个命令的帮助信息时将显示 usage和help字段的内容，否则就只显示usage字段的内容。

接着看如何定义命令：

include/command.h

\#define Struct\_Section  \_\_attribute\_\_ ((unused,section (".u\_boot\_cmd")))

凡是带有\_\_attribute\_\_ ((unused,section (".u\_boot\_cmd"))属性声明的变量都将被存放在".u\_boot\_cmd"段中，并且即使该变量没有在代码中显式的使用编译器也不产生警告信息。

\#ifdef  CFG\_LONGHELP

/\*每个命令就用这个宏来定义，并加进系统命令表中\*/

\#define U\_BOOT\_CMD(name,maxargs,rep,cmd,usage,help) \\

cmd\_tbl\_t \_\_u\_boot\_cmd\_\#\#name Struct\_Section = \{\#name, maxargs, rep, cmd, usage, help\}

\#\#”与“\#”都是预编译操作符，“\#\#”有字符串连接的功能，“\#”表示后面紧接着的是一个字符串。它定义一个command变量，并把它放入".u\_boot\_cmd"节中\*/

\#else       /\* no long help info \*/

\#define U\_BOOT\_CMD(name,maxargs,rep,cmd,usage,help) \\

cmd\_tbl\_t \_\_u\_boot\_cmd\_\#\#name Struct\_Section = \{\#name, maxargs, rep, cmd, usage\}

\#endif     /\* CFG\_LONGHELP \*/

\#endif     /\* \_\_COMMAND\_H \*/

U\_BOOT\_CMD宏在include/command.h中定义,

其中U\_BOOT\_CMD命令格式如下：

U\_BOOT\_CMD(name,maxargs,rep,cmd,usage,help)

各个参数的意义如下：

name：命令名，非字符串，但在U\_BOOT\_CMD中用“\#”符号转化为字符串

maxargs：命令的最大参数个数

rep：是否自动重复（按Enter键是否会重复执行）

cmd：该命令对应的响应函数

usage：简短的使用说明（字符串）

help：较详细的使用说明（字符串）

二、添加定义一个“hello”命令

1.建立common/cmd\_hello.c

习惯上通用命令源代码放在common目录下，并且习惯以“cmd\_<命令名>.c”为文件名。

2.定义“hello”命令

在cmd\_hello.c中使用如下的代码定义“hello”命令：

U\_BOOT\_CMD(

hello,    3,    0,    do\_hello,

"hello \\n",

" - test cmd..."

);

这定义了一个名字为hello的command, 对应的函数为do\_hello, 也就是说如果用户输入命令: hello，u-boot将执行do\_hello函数。

至于为什么要用这种方式来定义一个命令列表，大家可以看一下这个文件：

doc/README.commands:

\*\*\*\* Behinde the scene \*\*\*\*\*\*

The structure created is named with a special prefix (\_\_u\_boot\_cmd\_)

and placed by the linker in a special section.

This makes it possible for the final link to extract all commands

compiled into any object code and construct a static array so the

command can be found in an array starting at \_\_u\_boot\_cmd\_start.

If a new board is defined do not forget to define the command section

by writing in u-boot.lds ($(TOPDIR)/board/boardname/u-boot.lds) these

3 lines:

\_\_u\_boot\_cmd\_start = .;

.u\_boot\_cmd : \{ \*(.u\_boot\_cmd) \}

\_\_u\_boot\_cmd\_end = .;

创建的结构用一个特殊的前缀命名（\_\_u\_boot\_cmd\_）并放置在一个特殊的连接区。

这使得所有命令被编译成目标作为一个静态数组结构，使命令在\_\_u\_boot\_cmd\_start开始的数组中可以找到。

如果定义一个新的板子，不要忘记定义的命令段，主要是在u-boot.lds ($(TOPDIR)/board/boardname/u-boot.lds)文件中添加下面三行。

在U-Boot连接脚本u-boot.lds中定义了".u\_boot\_cmd"段：

. = .;

\_\_u\_boot\_cmd\_start = .;          /\*将 \_\_u\_boot\_cmd\_start指定为当前地址 \*/

.u\_boot\_cmd : \{ \*(.u\_boot\_cmd) \}

\_\_u\_boot\_cmd\_end = .;           /\*  将\_\_u\_boot\_cmd\_end指定为当前地址  \*/

这表明带有“.u\_boot\_cmd”声明的函数或变量将存储在“u\_boot\_cmd”段。这样只要将U-Boot所有命令对应的 cmd\_tbl\_t变量加上“.u\_boot\_cmd”声明，编译器就会自动将其放在“u\_boot\_cmd”段，查找cmd\_tbl\_t变量时只要在 \_\_u\_boot\_cmd\_start与\_\_u\_boot\_cmd\_end之间查找就可以了。

因此“hello”命令的定义经过宏展开后如下：

cmd\_tbl\_t \_\_u\_boot\_cmd\_hello \_\_attribute\_\_ ((unused,section (".u\_boot\_cmd"))) = \{hello, 3, 0, do\_hello, " hello \\n ", " - test cmd..."\}

实质上就是用U\_BOOT\_CMD宏定义的信息构造了一个cmd\_tbl\_t类型的结构体。编译器将该结构体放在“u\_boot\_cmd”段，执行命令时就可以在“u\_boot\_cmd”段查找到对应的cmd\_tbl\_t类型结构体。

3、建立common/cmd\_hello.c

习惯上通用命令源代码放在common目录下，并且习惯以“cmd\_<命令名>.c”为文件名。

4.实现命令的函数

在cmd\_hello.c中添加“hello”命令的响应函数的实现。具体的实现代码略：

int do\_hello (cmd\_tbl\_t \*cmdtp, int flag, int argc, char \*argv\[\])

/\* 实现代码略 \*/

5.将common/cmd\_hello.c编译进u-boot.bin

在common/Makefile中加入如下代码：

COBJS   = main.o ACEX1K.o altera.o bedbug.o circbuf.o \\

cmd\_ace.o cmd\_autoscript.o cmd\_hello.o \\

重新编译下载U-Boot就可以使用hello命令

6.对于u-boot2011.03将common/cmd\_hello.c编译进u-boot.bin

在common/Makefile中加入如下代码：

COBJS-$(CONFIG\_BOOT\_MENU) += cmd\_hello.o

在include/configs/smdk2410.h加入如代码：

\#define CONFIG\_BOOT\_MENU 1

重新编译下载U-Boot就可以使用menu命令

======================================================================

hello命令执行的过程：

（1）在U-Boot中输入“hello”命令执行时，U-Boot接收输入的字符串“hello”，传递给run\_command函数。

run\_command函数在common/main.c中定义。

（2）run\_command函数调用common/command.c中实现的find\_cmd函数在\_\_u\_boot\_cmd\_start与\_\_u\_boot\_cmd\_end间查找命令，并返回hello命令的cmd\_tbl\_t结构。

find\_cmd函数在common/command.c定义。

（3）然后run\_command函数使用返回的cmd\_tbl\_t结构中的函数指针调用hello命令的响应函数do\_hello，从而完成了命令的执行。

下面我们就以引导linux内核的命令bootm为例，说一下u-boot到linux过渡及参数传递的整个过程, common/cmd\_bootm.c:

U\_BOOT\_CMD(

bootm,    CFG\_MAXARGS,1,    do\_bootm,

"bootm   \- boot application image from memory\\n",

"\[addr \[arg ...\]\]\\n    \- boot application image stored in memory\\n"

"\\tpassing arguments 'arg ...'; when booting a Linux kernel,\\n"

"\\t'arg' can be the address of an initrd image\\n"

\#ifdef CONFIG\_OF\_FLAT\_TREE

"\\tWhen booting a Linux kernel which requires a flat device-tree\\n"

"\\ta third argument is required which is the address of the of the\\n"

"\\tdevice-tree blob. To boot that kernel without an initrd image,\\n"

"\\tuse a '-' for the second argument. If you do not pass a third\\n"

"\\ta bd\_info struct will be passed instead\\n"

\#endif

);

从注释中可以看到这个命令的作用是从memory中引导application，我们这里就是引导linux内核,前提就是linux kernel已经在memory中了。这条命令的处理函数就是do\_bootm()。

ulong load\_addr = CFG\_LOAD\_ADDR;          /\* Default Load Address \*/

int do\_bootm (cmd\_tbl\_t \*cmdtp, int flag, int argc, char \*argv\[\])

ulong      iflag;

ulong      addr;

ulong      data, len, checksum;

ulong  \*len\_ptr;

uint  unc\_len = CFG\_BOOTM\_LEN;

int   i, verify;

char\*name, \*s;

int   (\*appl)(int, char \*\[\]);

image\_header\_t \*hdr = &header;

s = getenv ("verify");

verify = (s && (\*s == 'n')) ? 0 : 1;

if (argc < 2) \{

addr = load\_addr;

\} else \{

addr = simple\_strtoul(argv\[1\], NULL, 16);

SHOW\_BOOT\_PROGRESS (1);

printf ("\#\# Booting image at %08lx ...\\n", addr);

/\* Copy header so we can blank CRC field for re-calculation \*/

\#ifdef CONFIG\_HAS\_DATAFLASH

if (addr\_dataflash(addr))\{

read\_dataflash(addr, sizeof(image\_header\_t), (char \*)&header);

\} else

\#endif

memmove (&header, (char \*)addr, sizeof(image\_header\_t));

if (ntohl(hdr->ih\_magic) != IH\_MAGIC) \{

\#ifdef \_\_I386\_\_    /\* correct image format not implemented yet - fake it \*/

if (fake\_header(hdr, (void\*)addr, -1) != NULL) \{

/\* to compensate for the addition below \*/

addr -= sizeof(image\_header\_t);

/\* turnof verify,

\* fake\_header() does not fake the data crc

\*/

verify = 0;

\} else

\#endif     /\* \_\_I386\_\_ \*/

puts ("Bad Magic Number\\n");

SHOW\_BOOT\_PROGRESS (-1);

return 1;

SHOW\_BOOT\_PROGRESS (2);

data = (ulong)&header;

len  = sizeof(image\_header\_t);

checksum = ntohl(hdr->ih\_hcrc);

hdr->ih\_hcrc = 0;

if (crc32 (0, (uchar \*)data, len) != checksum) \{

puts ("Bad Header Checksum\\n");

SHOW\_BOOT\_PROGRESS (-2);

return 1;

SHOW\_BOOT\_PROGRESS (3);

\#ifdef CONFIG\_HAS\_DATAFLASH

if (addr\_dataflash(addr))\{

len  = ntohl(hdr->ih\_size) + sizeof(image\_header\_t);

read\_dataflash(addr, len, (char \*)CFG\_LOAD\_ADDR);

addr = CFG\_LOAD\_ADDR;

\#endif

/\* for multi-file images we need the data part, too \*/

print\_image\_hdr ((image\_header\_t \*)addr);

data = addr + sizeof(image\_header\_t);

len  = ntohl(hdr->ih\_size);

if (verify) \{

puts ("   Verifying Checksum ... ");

if (crc32 (0, (uchar \*)data, len) != ntohl(hdr->ih\_dcrc)) \{

printf ("Bad Data CRC\\n");

SHOW\_BOOT\_PROGRESS (-3);

return 1;

puts ("OK\\n");

SHOW\_BOOT\_PROGRESS (4);

len\_ptr = (ulong \*)data;

\#if defined(\_\_PPC\_\_)

if (hdr->ih\_arch != IH\_CPU\_PPC)

\#elif defined(\_\_ARM\_\_)

if (hdr->ih\_arch != IH\_CPU\_ARM)

\#elif defined(\_\_I386\_\_)

if (hdr->ih\_arch != IH\_CPU\_I386)

\#elif defined(\_\_mips\_\_)

if (hdr->ih\_arch != IH\_CPU\_MIPS)

\#elif defined(\_\_nios\_\_)

if (hdr->ih\_arch != IH\_CPU\_NIOS)

\#elif defined(\_\_M68K\_\_)

if (hdr->ih\_arch != IH\_CPU\_M68K)

\#elif defined(\_\_microblaze\_\_)

if (hdr->ih\_arch != IH\_CPU\_MICROBLAZE)

\#elif defined(\_\_nios2\_\_)

if (hdr->ih\_arch != IH\_CPU\_NIOS2)

\#elif defined(\_\_blackfin\_\_)

if (hdr->ih\_arch != IH\_CPU\_BLACKFIN)

\#elif defined(\_\_avr32\_\_)

if (hdr->ih\_arch != IH\_CPU\_AVR32)

\#else

\# error Unknown CPU type

\#endif

printf ("Unsupported Architecture 0x%x\\n", hdr->ih\_arch);

SHOW\_BOOT\_PROGRESS (-4);

return 1;

SHOW\_BOOT\_PROGRESS (5);

switch (hdr->ih\_type) \{

case IH\_TYPE\_STANDALONE:

name = "Standalone Application";

/\* A second argument overwrites the load address \*/

if (argc > 2) \{

hdr->ih\_load = htonl(simple\_strtoul(argv\[2\], NULL, 16));

break;

case IH\_TYPE\_KERNEL:

name = "Kernel Image";

break;

case IH\_TYPE\_MULTI:

name = "Multi-File Image";

len  = ntohl(len\_ptr\[0\]);

/\* OS kernel is always the first image \*/

data += 8; /\* kernel\_len + terminator \*/

for (i=1; len\_ptr\[i\]; ++i)

data += 4;

break;

default: printf ("Wrong Image Type for %s command\\n", cmdtp->name);

SHOW\_BOOT\_PROGRESS (-5);

return 1;

SHOW\_BOOT\_PROGRESS (6);

/\*

\* We have reached the point of no return: we are going to

\* overwrite all exception vector code, so we cannot easily

\* recover from any failures any more...

\*/

iflag = disable\_interrupts();

\#ifdef CONFIG\_AMIGAONEG3SE

/\*

\* We've possible left the caches enabled during

\* bios emulation, so turn them off again

\*/

icache\_disable();

invalidate\_l1\_instruction\_cache();

flush\_data\_cache();

dcache\_disable();

\#endif

switch (hdr->ih\_comp) \{

case IH\_COMP\_NONE:

if(ntohl(hdr->ih\_load) == addr) \{

printf ("   XIP %s ... ", name);

\} else \{

\#if defined(CONFIG\_HW\_WATCHDOG) || defined(CONFIG\_WATCHDOG)

size\_t l = len;

void \*to = (void \*)ntohl(hdr->ih\_load);

void \*from = (void \*)data;

printf ("   Loading %s ... ", name);

while (l > 0) \{

size\_t tail = (l > CHUNKSZ) ? CHUNKSZ : l;

WATCHDOG\_RESET();

memmove (to, from, tail);

to += tail;

from += tail;

l -= tail;

\#else       /\* !(CONFIG\_HW\_WATCHDOG || CONFIG\_WATCHDOG) \*/

memmove ((void \*) ntohl(hdr->ih\_load), (uchar \*)data, len);

\#endif     /\* CONFIG\_HW\_WATCHDOG || CONFIG\_WATCHDOG \*/

break;

case IH\_COMP\_GZIP:

printf ("   Uncompressing %s ... ", name);

if (gunzip ((void \*)ntohl(hdr->ih\_load), unc\_len,

(uchar \*)data, &len) != 0) \{

puts ("GUNZIP ERROR - must RESET board to recover\\n");

SHOW\_BOOT\_PROGRESS (-6);

do\_reset (cmdtp, flag, argc, argv);

break;

\#ifdef CONFIG\_BZIP2

case IH\_COMP\_BZIP2:

printf ("   Uncompressing %s ... ", name);

/\*

\* If we've got less than 4 MB of malloc() space,

\* use slower decompression algorithm which requires

\* at most 2300 KB of memory.

\*/

i = BZ2\_bzBuffToBuffDecompress ((char\*)ntohl(hdr->ih\_load),

&unc\_len, (char \*)data, len,

CFG\_MALLOC\_LEN < (4096 \* 1024), 0);

if (i != BZ\_OK) \{

printf ("BUNZIP2 ERROR %d - must RESET board to recover\\n", i);

SHOW\_BOOT\_PROGRESS (-6);

udelay(100000);

do\_reset (cmdtp, flag, argc, argv);

break;

\#endif /\* CONFIG\_BZIP2 \*/

default:

if (iflag)

enable\_interrupts();

printf ("Unimplemented compression type %d\\n", hdr->ih\_comp);

SHOW\_BOOT\_PROGRESS (-7);

return 1;

puts ("OK\\n");

SHOW\_BOOT\_PROGRESS (7);

switch (hdr->ih\_type) \{

case IH\_TYPE\_STANDALONE:

if (iflag)

enable\_interrupts();

/\* load (and uncompress), but don't start if "autostart"

\* is set to "no"

\*/

if (((s = getenv("autostart")) != NULL) && (strcmp(s,"no") == 0)) \{

char buf\[32\];

sprintf(buf, "%lX", len);

setenv("filesize", buf);

return 0;

appl = (int (\*)(int, char \*\[\]))ntohl(hdr->ih\_ep);

(\*appl)(argc-1, &argv\[1\]);

return 0;

case IH\_TYPE\_KERNEL:

case IH\_TYPE\_MULTI:

/\* handled below \*/

break;

default:

if (iflag)

enable\_interrupts();

printf ("Can't boot image type %d\\n", hdr->ih\_type);

SHOW\_BOOT\_PROGRESS (-8);

return 1;

SHOW\_BOOT\_PROGRESS (8);

/\*看到了吧，u-boot是如何支持多个操作系统引导的\*/

switch (hdr->ih\_os) \{

default:                 /\* handled by (original) Linux case \*/

case IH\_OS\_LINUX:

\#ifdef CONFIG\_SILENT\_CONSOLE

fixup\_silent\_linux();

\#endif

do\_bootm\_linux  (cmdtp, flag, argc, argv,

addr, len\_ptr, verify);  /\*linux引导的函数\*/

break;

case IH\_OS\_NETBSD:

do\_bootm\_netbsd (cmdtp, flag, argc, argv,

addr, len\_ptr, verify);

break;

\#ifdef CONFIG\_LYNXKDI

case IH\_OS\_LYNXOS:

do\_bootm\_lynxkdi (cmdtp, flag, argc, argv,

addr, len\_ptr, verify);

break;

\#endif

case IH\_OS\_RTEMS:

do\_bootm\_rtems (cmdtp, flag, argc, argv,

addr, len\_ptr, verify);

break;

\#if (CONFIG\_COMMANDS & CFG\_CMD\_ELF)

case IH\_OS\_VXWORKS:

do\_bootm\_vxworks (cmdtp, flag, argc, argv,

addr, len\_ptr, verify);

break;

case IH\_OS\_QNX:

do\_bootm\_qnxelf (cmdtp, flag, argc, argv,

addr, len\_ptr, verify);

break;

\#endif /\* CFG\_CMD\_ELF \*/

\#ifdef CONFIG\_ARTOS

case IH\_OS\_ARTOS:

do\_bootm\_artos  (cmdtp, flag, argc, argv,

addr, len\_ptr, verify);

break;

\#endif

SHOW\_BOOT\_PROGRESS (-9);

\#ifdef DEBUG

puts ("\\n\#\# Control returned to monitor - resetting...\\n");

do\_reset (cmdtp, flag, argc, argv);

\#endif

return 1;

U-Boot使用命令bootm来启动已经加载到内存中的内核。而bootm命令实际上调用的是do\_bootm函数。do\_bootm()函数很大，但是大部分代码都很简单，就是做一些检测，看是否是正确的image,做的检测有:magic number, crc校验，体系结构是否正确等等，如果是压缩的还会先解压缩(这里的压缩和linux编译出来的压缩没关系,应该是application是否被gzip等压缩过的概念)。对于Linux内核，最后do\_bootm函数会调用do\_bootm\_linux函数来设置标记列表和启动内核。do\_bootm\_linux函数在lib\_arm/armlinux.c中定义如下：

void do\_bootm\_linux (cmd\_tbl\_t \*cmdtp, int flag, int argc, char \*argv\[\],

ulong addr, ulong \*len\_ptr, int verify)

ulong len = 0, checksum;

ulong initrd\_start, initrd\_end;

ulong data;

void (\*theKernel)(int zero, int arch, uint params); /\*定义一个函数指针\*/

image\_header\_t \*hdr = &header; /\*linux image的头\*/

bd\_t \*bd = gd->bd; /\*用来存放传递给linux kernel参数的地址\*/

\#ifdef CONFIG\_CMDLINE\_TAG

char \*commandline = getenv ("bootargs");/\* U-Boot环境变量bootargs \*/

\#endif

theKernel = (void (\*)(int, int, uint))ntohl(hdr->ih\_ep); /\* 获取内核加载地址 \*/

/\*

\* Check if there is an initrd image

\*/

// 用户自定义了initrd之后需要加载进来

// 整个过程需要进行头部以及整个数据内部校验

// 类似于内核的加载校验。

if (argc >= 3) \{ /\*存在initrd image\*/

SHOW\_BOOT\_PROGRESS (9);

addr = simple\_strtoul (argv\[2\], NULL, 16); /\*获取地址\*/

printf ("\#\# Loading Ramdisk Image at %08lx ...\\n", addr);

/\* Copy header so we can blank CRC field for re-calculation \*/

\#ifdef CONFIG\_HAS\_DATAFLASH

if (addr\_dataflash (addr)) \{

read\_dataflash (addr, sizeof (image\_header\_t),

(char \*) &header);

\} else

\#endif

memcpy (&header, (char \*) addr,

sizeof (image\_header\_t)); /\*获取initrd的头\*/

if (ntohl (hdr->ih\_magic) != IH\_MAGIC) \{

printf ("Bad Magic Number\\n");

SHOW\_BOOT\_PROGRESS (-10);

do\_reset (cmdtp, flag, argc, argv);

data = (ulong) & header;

len = sizeof (image\_header\_t);

checksum = ntohl (hdr->ih\_hcrc);

hdr->ih\_hcrc = 0;

if (crc32 (0, (unsigned char \*) data, len) != checksum) \{ /\*合法性检测\*/

printf ("Bad Header Checksum\\n");

SHOW\_BOOT\_PROGRESS (-11);

do\_reset (cmdtp, flag, argc, argv);

SHOW\_BOOT\_PROGRESS (10);

print\_image\_hdr (hdr);

data = addr + sizeof (image\_header\_t);

len = ntohl (hdr->ih\_size);

\#ifdef CONFIG\_HAS\_DATAFLASH

if (addr\_dataflash (addr)) \{

read\_dataflash (data, len, (char \*) CFG\_LOAD\_ADDR);

data = CFG\_LOAD\_ADDR;

\#endif

if (verify) \{   /\*合法性检测\*/

ulong csum = 0;

printf ("   Verifying Checksum ... ");

csum = crc32 (0, (unsigned char \*) data, len);

if (csum != ntohl (hdr->ih\_dcrc)) \{

printf ("Bad Data CRC\\n");

SHOW\_BOOT\_PROGRESS (-12);

do\_reset (cmdtp, flag, argc, argv);

printf ("OK\\n");

SHOW\_BOOT\_PROGRESS (11);

if ((hdr->ih\_os != IH\_OS\_LINUX) ||

(hdr->ih\_arch != IH\_CPU\_ARM) ||

(hdr->ih\_type != IH\_TYPE\_RAMDISK)) \{   /\*合法性检测\*/

printf ("No Linux ARM Ramdisk Image\\n");

SHOW\_BOOT\_PROGRESS (-13);

do\_reset (cmdtp, flag, argc, argv);

\#if defined(CONFIG\_B2) || defined(CONFIG\_EVB4510) || defined(CONFIG\_ARMADILLO)

/\*

\*we need to copy the ramdisk to SRAM to let Linux boot

\*/

memmove ((void \*) ntohl(hdr->ih\_load), (uchar \*)data, len);

data = ntohl(hdr->ih\_load);

\#endif /\* CONFIG\_B2 || CONFIG\_EVB4510 \*/

/\*

\* Now check if we have a multifile image

\*/

\} else if ((hdr->ih\_type == IH\_TYPE\_MULTI) && (len\_ptr\[1\])) \{

ulong tail = ntohl (len\_ptr\[0\]) % 4;

int i;

SHOW\_BOOT\_PROGRESS (13);

/\* skip kernel length and terminator \*/

data = (ulong) (&len\_ptr\[2\]);

/\* skip any additional image length fields \*/

for (i = 1; len\_ptr\[i\]; ++i)

data += 4;

/\* add kernel length, and align \*/

data += ntohl (len\_ptr\[0\]);

if (tail) \{

data += 4 - tail;

len = ntohl (len\_ptr\[1\]);

\} else \{

/\*

\* no initrd image

\*/

SHOW\_BOOT\_PROGRESS (14);

len = data = 0;

上面的代码主要是检查是否有initrd image，如有则记住它在内存的地址。

\#ifdef      DEBUG

if (!data) \{

printf ("No initrd\\n");

\#endif

if (data) \{   /\*保存initrd的地址\*/

initrd\_start = data;

initrd\_end = initrd\_start + len;

\} else \{

initrd\_start = 0;

initrd\_end = 0;

SHOW\_BOOT\_PROGRESS (15);

debug ("\#\# Transferring control to Linux (at address %08lx) ...\\n",

(ulong) theKernel);

/\*下面这些实际上就是设置好参数\*/

// 在smdk2410.h文件中定义了如下宏

// \#define CONFIG\_CMDLINE\_TAG

// \#define CONFIG\_SETUP\_MEMORY\_TAGS

// \#define CONFIG\_INITRD\_TAG

// 根据上面不同的宏加载不同的TAG

// 注意的是必须定义CONFIG\_CMDLINE\_TAG和CONFIG\_SETUP\_MEMORY\_TAGS

// 除非内核已经根据系统初始化了这些值, 否则必须定义, 不定义将导致无法启动.

\#if defined (CONFIG\_SETUP\_MEMORY\_TAGS) || \\

defined (CONFIG\_CMDLINE\_TAG) || \\

defined (CONFIG\_INITRD\_TAG) || \\

defined (CONFIG\_SERIAL\_TAG) || \\

defined (CONFIG\_REVISION\_TAG) || \\

defined (CONFIG\_LCD) || \\

defined (CONFIG\_VFD)

setup\_start\_tag (bd);    /\* 设置ATAG\_CORE标志 \*/

\#ifdef CONFIG\_SERIAL\_TAG

setup\_serial\_tag (&params);

\#endif

\#ifdef CONFIG\_REVISION\_TAG

setup\_revision\_tag (&params);

\#endif

\#ifdef CONFIG\_SETUP\_MEMORY\_TAGS

setup\_memory\_tags (bd);  /\* 设置内存标记 \*/

\#endif

\#ifdef CONFIG\_CMDLINE\_TAG

setup\_commandline\_tag (bd, commandline);  /\* 设置命令行标记 \*/

\#endif

\#ifdef CONFIG\_INITRD\_TAG

if (initrd\_start && initrd\_end)

setup\_initrd\_tag (bd, initrd\_start, initrd\_end);

\#endif

\#if defined (CONFIG\_VFD) || defined (CONFIG\_LCD)

setup\_videolfb\_tag ((gd\_t \*) gd);

\#endif

setup\_end\_tag (bd);  /\* 设置ATAG\_NONE标志 \*/

\#endif

/\* we assume that the kernel is in place \*/

printf ("\\nStarting kernel ...\\n\\n");

\#ifdef CONFIG\_USB\_DEVICE

extern void udc\_disconnect (void);

udc\_disconnect ();

\#endif

cleanup\_before\_linux ();  /\* 启动内核前对CPU作最后的设置 \*/

theKernel (0, bd->bi\_arch\_number, bd->bi\_boot\_params);   /\*正式跳转到linux kernel\*/

其中的setup\_start\_tag，setup\_memory\_tags，setup\_end\_tag函数在lib\_arm/armlinux.c中定义如下：

static void setup\_start\_tag (bd\_t \*bd)

params = (struct tag \*) bd->bi\_boot\_params; /\* 内核的参数的开始地址 \*/

params->hdr.tag = ATAG\_CORE;

params->hdr.size = tag\_size (tag\_core);

params->u.core.flags = 0;

params->u.core.pagesize = 0;

params->u.core.rootdev = 0;

params = tag\_next (params);

标记列表必须以ATAG\_CORE开始，setup\_start\_tag函数在内核的参数的开始地址设置了一个ATAG\_CORE标记。

\#ifdef CONFIG\_SETUP\_MEMORY\_TAGS

static void setup\_memory\_tags (bd\_t \*bd)

int i;

/\*设置一个内存标记 \*/

for (i = 0; i < CONFIG\_NR\_DRAM\_BANKS; i++) \{

params->hdr.tag = ATAG\_MEM;

params->hdr.size = tag\_size (tag\_mem32);

params->u.mem.start = bd->bi\_dram\[i\].start;

params->u.mem.size = bd->bi\_dram\[i\].size;

params = tag\_next (params);

\#endif /\* CONFIG\_SETUP\_MEMORY\_TAGS \*/

setup\_memory\_tags函数设置了一个ATAG\_MEM标记，该标记包含内存起始地址，内存大小这两个参数。

\#ifdef CONFIG\_SERIAL\_TAG

void setup\_serial\_tag (struct tag \*\*tmp)

struct tag \*params = \*tmp;

struct tag\_serialnr serialnr;

void get\_board\_serial(struct tag\_serialnr \*serialnr);

get\_board\_serial(&serialnr);

params->hdr.tag = ATAG\_SERIAL;

params->hdr.size = tag\_size (tag\_serialnr);

params->u.serialnr.low = serialnr.low;

params->u.serialnr.high= serialnr.high;

params = tag\_next (params);

\*tmp = params;

\#endif

setup\_serial\_tag函数传进来的参数是&params,而params在setup\_start\_tag（）里已经被初始化为

params = (struct tag \*) bd->bi\_boot\_params;

因此该函数对params里变量的赋值实际上就是在对bd->bi\_boot\_params下赋值，因此bi\_boot\_params地址处存放了所有相关的参数。最后这个地址被传给了linux kernel。

static void setup\_end\_tag (bd\_t \*bd)

params->hdr.tag = ATAG\_NONE;

params->hdr.size = 0;

标记列表必须以标记ATAG\_NONE结束，setup\_end\_tag函数设置了一个ATAG\_NONE标记，表示标记列表的结束。

U-Boot设置好标记列表后就要调用内核了。但调用内核前，CPU必须满足下面的条件：

（1）    CPU寄存器的设置

Ø  r0=0

Ø  r1=机器码

Ø  r2=内核参数标记列表在RAM中的起始地址

（2）    CPU工作模式

Ø  禁止IRQ与FIQ中断

Ø  CPU为SVC模式

（3）    使数据Cache与指令Cache失效

do\_bootm\_linux中调用的cleanup\_before\_linux函数完成了禁止中断和使Cache失效的功能。cleanup\_before\_linux函数在cpu/arm920t/cpu.c中定义：

int cleanup\_before\_linux (void)

/\*

\* this function is called just before we call linux

\* it prepares the processor for linux

\* we turn off caches etc ...

\*/

unsigned long i;

disable\_interrupts ();  /\* 禁止FIQ/IRQ中断 \*/

/\* turn off I/D-cache /\*关掉数据和指令的cache\*/ \*/

asm ("mrc p15, 0, %0, c1, c0, 0":"=r" (i));

i &= ~(C1\_DC | C1\_IC);

asm ("mcr p15, 0, %0, c1, c0, 0": :"r" (i));

/\* flush I/D-cache 复位/刷新数据和指令的cache \*/

i = 0;

asm ("mcr p15, 0, %0, c7, c7, 0": :"r" (i));

return (0);

由于U-Boot启动以来就一直工作在SVC模式，因此CPU的工作模式就无需设置了。

do\_bootm\_linux中：

void       (\*theKernel)(int zero, int arch, uint params);

theKernel = (void (\*)(int, int, uint))images->ep;

theKernel (0, machid, bd->bi\_boot\_params);

第2行代码将内核的入口地址“images->ep”强制类型转换为函数指针。根据ATPCS规则，函数的参数个数不超过4 个时，使用r0~r3这4个寄存器来传递参数。因此第3行的函数调用则会将0放入r0，机器码machid放入r1，内核参数地址 bd->bi\_boot\_params放入r2，从而完成了寄存器的设置，最后转到内核的入口地址。

到这里，U-Boot的工作就结束了，系统跳转到Linux内核代码执行。后面会再分析linux启动顺序，这样可以有个衔接。

[http_www.cnblogs.com_zong-blogs_archive_2011_04_07_2008738.html]: http://www.cnblogs.com/zong-blogs/archive/2011/04/07/2008738.html
[20672257_1316850501J662.jpg]: http://blog.chinaunix.net/attachment/201109/24/20672257_1316850501J662.jpg
[http_blog.csdn.net_hxliu_leo_article_details_5315011]: http://blog.csdn.net/hxliu_leo/article/details/5315011