uboot第二阶段启动流程

#include <stdio.h>
typedef unsigned long ulong;

typedef	struct environment_s {

} env_t;

typedef struct bd_info {
    int			bi_baudrate;	/* serial console baudrate */
    unsigned long	bi_ip_addr;	/* IP Address */
    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 configuration */
    {
	   ulong start;
	   ulong size;
    }bi_dram[1];
} bd_t;

int main(int argc, const char *argv[])
{
	printf("sizeof(bd_t) = %d\n",sizeof(bd_t));
	return 0;
}

#include <stdio.h>

typedef	struct	global_data {
	void		*bd;
	unsigned long	flags;
	unsigned long	baudrate;
	unsigned long	have_console;	/* serial_init() was called */
	unsigned long	env_addr;	/* Address  of Environment struct */
	unsigned long	env_valid;	/* Checksum of Environment valid? */
	unsigned long	fb_base;	/* base address of frame buffer */
	void		**jt;		/* jump table */
} gd_t;

int main() 
{
	printf("sizeof(gd_t) : %d\n",(int)sizeof(gd_t));
	return 0;
}

typedef	struct environment_s {
	uint32_t	crc;		/* CRC32 over data bytes	*/
	unsigned char	flags;		/* active/obsolete flags	*/
	unsigned char	data[ENV_SIZE]; /* Environment data		*/

} env_t;

typedef struct bd_info {
	//串口通讯波特率
    int			bi_baudrate;	/* serial console baudrate */
    //IP 地址
	unsigned long	bi_ip_addr;	/* IP Address */
    //环境变量起始地址
	struct environment_s	       *bi_env;
    //开发板的机器码
	ulong	        bi_arch_number;	/* unique id for this board */
    //uboot传递给内核参数的起始地址
	ulong	        bi_boot_params;	/* where this board expects params */
    //内存信息
	struct				/* RAM configuration */
    {
	   ulong start;//内存的起始地址
	   ulong size;//内存大小
    }bi_dram[1];
} bd_t;

typedef	struct	global_data {
	bd_t		*bd;
	unsigned long	flags; //uboot是否重定向的标志
	//串口波特率
	unsigned long	baudrate;
	//是否有一个控制台标志
	unsigned long	have_console;	/* serial_init() was called */
	//环境变量所在的地址
	unsigned long	env_addr;	/* Address  of Environment struct */
	//环境变量是否有效
	unsigned long	env_valid;	/* Checksum of Environment valid? */
	unsigned long	fb_base;	/* base address of frame buffer */
	void		**jt;		/* jump table */
} gd_t;


typedef int (init_fnc_t) (void);
register volatile gd_t *gd asm ("r8");
ulong monitor_flash_len;

init_fnc_t *init_sequence[] = {
	//初始化CPU相关设置:系统时钟操作函数
	arch_cpu_init,		/* basic arch cpu dependent setup */
	//初始化开发板相关设置：开发板的机器码 
	board_init,		/* basic board dependent setup */
	//初始化定时器
	timer_init,		/* initialize timer */
	//初始化环境变量
	env_init,		/* initialize environment */
	//初始化波特率 
	init_baudrate,		/* initialze baudrate settings */
	//串口初始化
	serial_init,		/* serial communications setup */
	//控制台设备一级初始化
	console_init_f,		/* stage 1 init of console */
	//打印u-boot版本、编译时间 
	display_banner,		/* say that we are here */
	
	//打印CPU类型和当前运行频率
	print_cpuinfo,		/* display cpu info (and speed) */
	
	//打印开发板名称
	checkboard,		   /* display board info */
	
	//配置可用的内存
	dram_init,		   /* configure available RAM banks */
	//显示当前内存大小
	display_dram_config,
	NULL,
};

void start_armboot (void)
{
	init_fnc_t **init_fnc_ptr;
	char *s;


	/* Pointer is writable since we allocated a register for it 
	 * _armboot_start :0x20f00044
	 * CONFIG_SYS_MALLOC_LEN:0x120000
	 * sizeof(gd_t)   :0x40 [64byte]
	 *
	 * gd : 0x20de0004
	 */
	gd = (gd_t*)(_armboot_start - CONFIG_SYS_MALLOC_LEN - sizeof(gd_t));
	/* compiler optimization barrier needed for GCC >= 3.4 */
	__asm__ __volatile__("": : :"memory");

	memset ((void*)gd, 0, sizeof (gd_t));

	//gd->bd :0x20de0004 -  0x38 = 0x20ddffcc
	gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));
	memset (gd->bd, 0, sizeof (bd_t));

	gd->flags |= GD_FLG_RELOC;
	
	//uboot去掉bss段的大小
	monitor_flash_len = _bss_start - _armboot_start;
	
	//外围硬件初始化
	for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
		if ((*init_fnc_ptr)() != 0) {
			hang ();
		}
	}
	
	//将堆区初始化为0
	/* armboot_start is defined in the board-specific linker script */
	mem_malloc_init (_armboot_start - CONFIG_SYS_MALLOC_LEN,
			CONFIG_SYS_MALLOC_LEN);


	puts ("NAND:  ");

	//NAND FALSH 初始化
	nand_init();		/* go init the NAND */

	/*读取Nand Flash的环境变量，然后做CRC校验,如果错误则使用默认的环境变量*/
	env_relocate ();

	/*获得IP 地址*/
	gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");
	
	//初始化输入、输出设备列表
	stdio_init ();	/* get the devices list going. */
	

	jumptable_init ();
	
	//初始化标准输入、输出、出错
	console_init_r ();	/* fully init console as a device */

	/* 使能IRQ异常 */
	enable_interrupts ();

	/* Initialize from environment */
	if ((s = getenv ("loadaddr")) != NULL) {
		load_addr = simple_strtoul (s, NULL, 16);
	}
	
	//初始化网卡设备
	eth_initialize(gd->bd);

	/* main_loop() can return to retry autoboot, if so just run it again. */
	for (;;) {
		main_loop ();
	}

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


void hang (void)
{
	puts ("### ERROR ### Please RESET the board ###\n");
	for (;;);
}

struct serial_device {
	char name[NAMESIZE];
	char ctlr[CTLRSIZE];

	int  (*init) (void);
	void (*setbrg) (void);
	int (*getc) (void);
	int (*tstc) (void);
	void (*putc) (const char c);
	void (*puts) (const char *s);

	struct serial_device *next;
};
static struct serial_device *serial_current = NULL;
struct serial_device *default_serial_console(void) __attribute__((weak, alias("__default_serial_console")));

int serial_init (void)
{
	if (!(gd->flags & GD_FLG_RELOC) || !serial_current) {
		struct serial_device *dev = default_serial_console ();

		return dev->init ();
	}

	return serial_current->init ();
}

struct serial_device *__default_serial_console (void)
{
	return &s5pc1xx_serial0_device;
}


int s5p_serial0_init(void) 
{ 
	return serial_init_dev(0); 
}

void s5p_serial0_setbrg(void) 
{
	serial_setbrg_dev(0); 
} 

int s5p_serial0_getc(void) 
{ 
	return serial_getc_dev(0); 
} 

int s5p_serial0_tstc(void) 
{
	return serial_tstc_dev(0); 
} 

void s5p_serial0_putc(const char c) 
{ 
	serial_putc_dev(c, 0); 
} 

void s5p_serial0_puts(const char *s) 
{ 
	serial_puts_dev(s, 0); 
}

struct serial_device s5pc1xx_serial0_device = {
	"s5pser0",
	"S5PUART0",
	s5p_serial0_init, 
	s5p_serial0_setbrg, 
	s5p_serial0_getc, 
	s5p_serial0_tstc, 
	s5p_serial0_putc, 
	s5p_serial0_puts, 
};


/*
 * Initialise the serial port with the given baudrate. The settings
 * are always 8 data bits, no parity, 1 stop bit, no start bits.
 */
int serial_init_dev(const int dev_index)
{
	struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index);

	/* reset and enable FIFOs, set triggers to the maximum */
	writel(0, &uart->ufcon);
	writel(0, &uart->umcon);
	/* 8N1 */
	writel(0x3, &uart->ulcon);
	/* No interrupts, no DMA, pure polling */
	writel(0x245, &uart->ucon);

	serial_setbrg_dev(dev_index);

	return 0;
}


void serial_setbrg_dev(const int dev_index)
{
	DECLARE_GLOBAL_DATA_PTR;
	struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index);
	u32 pclk = get_pclk();
	u32 baudrate = gd->baudrate;
	u32 val;

	val = pclk / baudrate;

	writel(val / 16 - 1, &uart->ubrdiv);
	writew(udivslot[val % 16], &uart->udivslot);
}

void main_loop (void)
{
	char *s;
	int bootdelay;

	u_boot_hush_start ();

	s = getenv ("bootdelay");
	bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;

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


	s = getenv ("bootcmd");

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

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

	parse_string_outer(s, FLAG_PARSE_SEMICOLON |
				    FLAG_EXIT_FROM_LOOP);

	/*
	 * Main Loop for Monitor Command Processing
	 */	
	parse_file_outer();
	/* This point is never reached */
	for (;;);
}

static __inline__ int abortboot(int bootdelay)
{
	int abort = 0;

	printf("Hit any key to stop autoboot: %2d ", bootdelay);

	/*
	 * Check if key already pressed
	 * Don't check if bootdelay < 0
	 */
	if (bootdelay >= 0) {
		if (tstc()) {	/* we got a key press	*/
			(void) getc();  /* consume input	*/
			puts ("\b\b\b 0");
			abort = 1;	/* don't auto boot	*/
		}
	}

	while ((bootdelay > 0) && (!abort)) {
		int i;

		--bootdelay;
		/* delay 100 * 10ms */
		for (i=0; !abort && i<100; ++i) {
			if (tstc()) {	/* we got a key press	*/
				abort  = 1;	/* don't auto boot	*/
				bootdelay = 0;	/* no more delay	*/
				(void) getc();  /* consume input	*/
				break;
			}
			udelay(10000);
		}

		printf("\b\b\b%2d ", bootdelay);
	}

	putc('\n');

	return abort;
}