uboot流程分析--修改android启动模式按键

uboot等同于其他所有的bootloader程序，从根本上讲是一个稍复杂的裸机程序，是最底层的东西，要分析裸机程序我们要从它的连接文件开始。连接文件（.lds文件）定义了程序编译之后整个连接过程，这样我们就可以找到这个程序的第一句汇编代码，进而来下一步分析。uboot的链接文件代码在android\bootable\bootloader\uboot-imx\u-boot.lds

OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")  //文件输出格式
OUTPUT_ARCH(arm)
ENTRY(_start)       //首地址标示符
SECTIONS
{
 . = 0x00000000;    //其实地址0
 . = ALIGN(4);      //4字节对齐
 .text :        //代码段
 {
   board/freescale/mx6q_sabresd/flash_header.o (.text.flasheader)   //第一个文件是board/freescale/mx6q_sabresd/flash_header.o
   cpu/arm_cortexa8/start.o         //第二个cpu/arm_cortexa8/start.o
   board/freescale/mx6q_sabresd/libmx6q_sabresd.a (.text)
   lib_arm/libarm.a (.text)
   net/libnet.a (.text)
   drivers/mtd/libmtd.a (.text)
   drivers/mmc/libmmc.a (.text)
   . = DEFINED(env_offset) ? env_offset : .;
   common/env_embedded.o(.text)
   *(.text)             //剩余的所有代码
 }
 . = ALIGN(4);
 .rodata : { *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.rodata*))) } //readonly data 段
 . = ALIGN(4);
 .data : { *(.data) }       //所有的readonly data
 . = ALIGN(4);
 .got : { *(.got) }
 . = .;
 __u_boot_cmd_start = .;        //u_boot_cmd段，里面是所有uboot命令的一个列表
 .u_boot_cmd : { *(.u_boot_cmd) }
 __u_boot_cmd_end = .;
 . = ALIGN(4);
 _end_of_copy = .;
 __bss_start = .;           //bss段 就是内存数据段
 .bss : { *(.bss) }
 _end = .;
}

从上面的代码可以看出我们编译生成的二进制应用程序组成是：代码段->rodata段->uboot命令列表->bss段。我们启动这个应用程序时候是从，0地址开始的，因此我们来看
board/freescale/mx6q_sabresd/flash_header.s这个文件。
  这个文件中除了分配内存和宏定义的伪汇编指令以外，真正执行的命令有一条

.section ".text.flasheader", "x"
    b   _start
    .org    CONFIG_FLASH_HEADER_OFFSET

也就是说，这个文件一执行就直接跳到_start 位置处。_start 在android\bootable\bootloader\uboot-imx\cpu\arm_cortexa8\ start.S中，因此我们来看这个文件代码

.globl _start
_start: b   reset

这里直接跳转的reset中接下来看

reset:
    /*
     * set the cpu to SVC32 mode    cpu设置成32位管理模式
     */
    mrs r0, cpsr
    bic r0, r0, #0x1f
    orr r0, r0, #0xd3
    msr cpsr,r0

#if (CONFIG_OMAP34XX)   //因为我们的cpu不是ompa的 所以这段不会编译
.............................
#endif
    /* the mask ROM code should have PLL and others stable */
#ifndef CONFIG_SKIP_LOWLEVEL_INIT
    bl  cpu_init_crit
#endif

这里接下来执行cpu_init_crit

/*************************************************************************
 *
 * CPU_init_critical registers
 *
 * setup important registers
 * setup memory timing
 *
 *************************************************************************/
cpu_init_crit:
    /*
     * Invalidate L1 I/D
     */
    mov r0, #0          @ set up for MCR
    mcr p15, 0, r0, c8, c7, 0   @ invalidate TLBs
    mcr p15, 0, r0, c7, c5, 0   @ invalidate icache

    /*
     * disable MMU stuff and caches     //关闭mmu
     */
    mrc p15, 0, r0, c1, c0, 0
    bic r0, r0, #0x00002000 @ clear bits 13 (--V-)
    bic r0, r0, #0x00000007 @ clear bits 2:0 (-CAM)
    orr r0, r0, #0x00000002 @ set bit 1 (--A-) Align
    orr r0, r0, #0x00000800 @ set bit 12 (Z---) BTB
    mcr p15, 0, r0, c1, c0, 0

    /*
     * Jump to board specific initialization...
     * The Mask ROM will have already initialized
     * basic memory. Go here to bump up clock rate and handle
     * wake up conditions.
     */
    mov ip, lr      @ persevere link reg across call
    bl  lowlevel_init   @ go setup pll,mux,memory//执行lowlevel_init这个函数代码在
                            @\bootloader\uboot-imx\board\freescale\mx6q_sabresd\lowlevel_init.S中
                            @主要对时钟,外部ram，rom等进行了初始化代码不贴了。
    mov lr, ip      @ restore link
    mov pc, lr      @ back to my caller

初始化完成后，接下来执行

#ifndef CONFIG_SKIP_RELOCATE_UBOOT
relocate:               @ relocate U-Boot to RAM    将uboot重新定位到内存中
    adr r0, _start      @ r0 <- current position of code
    ldr r1, _TEXT_BASE      @ test if we run from flash or RAM
    cmp r0, r1          @ don't reloc during debug测试当前代码是否已经在内存中
    beq stack_setup     @如果在的话就直接跳转到stack_setup


    ldr r2, _armboot_start  @如果不在的话，加载_armboot_start地址到r2中。_armboot_start是uboot执行的主体c函数。
    ldr r3, _bss_start
    sub r2, r3, r2      @ r2 <- size of armboot计算bss_start-armboot_start 保存到R2中，也就是uboot的总大小
    add r2, r0, r2      @ r2 <- source end address 计算出uboot代码和rodata地址

copy_loop:              @ copy 32 bytes at a time   //开始拷贝
    ldmia   r0!, {r3 - r10}     @ copy from source address [r0]
    stmia   r1!, {r3 - r10}     @ copy to   target address [r1]
    cmp r0, r2          @ until source end addreee [r2]
    ble copy_loop
#endif  /* CONFIG_SKIP_RELOCATE_UBOOT */

    /* Set up the stack */
stack_setup:
    ldr r0, _TEXT_BASE      @ upper 128 KiB: relocated uboot
    sub r0, r0, #CONFIG_SYS_MALLOC_LEN @ malloc area//为c语言malloc函数分配内存
    sub r0, r0, #CONFIG_SYS_GBL_DATA_SIZE @ bdinfo
#ifdef CONFIG_USE_IRQ
    sub r0, r0, #(CONFIG_STACKSIZE_IRQ + CONFIG_STACKSIZE_FIQ)
#endif
    sub sp, r0, #12     @ leave 3 words for abort-stack//分配c语言堆栈
    and sp, sp, #~7     @ 8 byte alinged for (ldr/str)d

    /* Clear BSS (if any). Is below tx (watch load addr - need space) */
clear_bss:
    ldr r0, _bss_start      @ find start of bss segment //清除bss段
    ldr r1, _bss_end        @ stop here
    mov r2, #0x00000000     @ clear value
clbss_l:
    str r2, [r0]        @ clear BSS location
    cmp r0, r1          @ are we at the end yet
    add r0, r0, #4      @ increment clear index pointer
    bne clbss_l         @ keep clearing till at end

#ifdef CONFIG_ARCH_MMU
    bl board_mmu_init   //初始化mmu
#endif
    ldr pc, _start_armboot  @ jump to C code以上所有的初始化就已经完成了，接下类正式执行c语言代码了。这才是我们的重点

_start_armboot: .word start_armboot

接下来正式看C代码，也就是start_armboot这个函数代码在android\bootable\bootloader\uboot-imx\lib_arm\board.c中

void start_armboot (void)
{
    init_fnc_t **init_fnc_ptr;
    char *s;
#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 - CONFIG_SYS_MALLOC_LEN - sizeof(gd_t));
    //分配一段内存.在cpu存储控制器初始化之前，是不能访问外部ram的，因此需要一小段
    //内存来运行最初的初始化函数，这段内存一般是cpu内部ram
    /* compiler optimization barrier needed for GCC >= 3.4 */
    __asm__ __volatile__("": : :"memory");

    memset ((void*)gd, 0, sizeof (gd_t));
    gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));
    memset (gd->bd, 0, sizeof (bd_t));

    gd->flags |= GD_FLG_RELOC;

    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 ();
        }
    }

注意看这里init_sequence的定义

init_fnc_t *init_sequence[] = {
#if defined(CONFIG_ARCH_CPU_INIT)
    arch_cpu_init,      /* basic arch cpu dependent setup */
#endif
    board_init,     /* basic board dependent setup */
#if defined(CONFIG_USE_IRQ)
    interrupt_init,     /* set up exceptions */
#endif
    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 */
    display_banner,     /* say that we are here */
#if defined(CONFIG_DISPLAY_CPUINFO)
    print_cpuinfo,      /* display cpu info (and speed) */
#endif
#if defined(CONFIG_DISPLAY_BOARDINFO)
    checkboard,     /* display board info */
#endif
#if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
    init_func_i2c,
#endif
    dram_init,      /* configure available RAM banks */
#if defined(CONFIG_CMD_PCI) || defined (CONFIG_PCI)
    arm_pci_init,
#endif
    display_dram_config,
    NULL,
};

这个是一个函数指针的数组，涉及到cpu的最后的一些初始化。到了这里cpu的所有初始化都完成了

我们继续看板子的其他配置

#ifdef CONFIG_LCD   //lcd缓存设置
    /* board init may have inited fb_base */
    if (!gd->fb_base) {
#       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);
        lcd_setmem (addr);
        gd->fb_base = addr;
    }
#endif /* CONFIG_LCD */

    env_relocate ();//设置环境变量 也就是printenv 打印出来的那些

#ifdef CONFIG_VFD
    /* must do this after the framebuffer is allocated */
    drv_vfd_init(); //空函数
#endif /* CONFIG_VFD */

#ifdef CONFIG_SERIAL_MULTI
    serial_initialize();//串口初始化
#endif

    /* IP Address */
    gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");

#if defined CONFIG_SPLASH_SCREEN && defined CONFIG_VIDEO_MX5
    setup_splash_image();//lcd显示log
#endif
    //重新定义stdio的位置，在本环境中被定义到了串口上
    stdio_init ();  /* get the devices list going. */

    jumptable_init ();//把一些初始化函数的指针放到gd中，为以后调用

#if defined(CONFIG_API)
    /* Initialize API */
    api_init ();
#endif

    console_init_r ();  /* fully init console as a device 控制台初始化*/

#if defined(CONFIG_ARCH_MISC_INIT)
    /* miscellaneous arch dependent initialisations */
    arch_misc_init ();//空函数
#endif
#if defined(CONFIG_MISC_INIT_R)
    /* miscellaneous platform dependent initialisations */
    misc_init_r ();//空函数
#endif

    /* enable exceptions */
    enable_interrupts ();//使能中断

    /* Perform network card initialisation if necessary */
#ifdef CONFIG_DRIVER_TI_EMAC
    /* XXX: this needs to be moved to board init */
extern void davinci_eth_set_mac_addr (const u_int8_t *addr);//不编译
    if (getenv ("ethaddr")) {
        uchar enetaddr[6];
        eth_getenv_enetaddr("ethaddr", enetaddr);
        davinci_eth_set_mac_addr(enetaddr);
    }
#endif

#ifdef CONFIG_DRIVER_CS8900
    /* XXX: this needs to be moved to board init */
    cs8900_get_enetaddr ();//不编译
#endif

#if defined(CONFIG_DRIVER_SMC91111) || defined (CONFIG_DRIVER_LAN91C96)
    /* XXX: this needs to be moved to board init */
    if (getenv ("ethaddr")) {
        uchar enetaddr[6];
        eth_getenv_enetaddr("ethaddr", enetaddr);//不编译
        smc_set_mac_addr(enetaddr);
    }
#endif /* CONFIG_DRIVER_SMC91111 || CONFIG_DRIVER_LAN91C96 */

#if defined(CONFIG_ENC28J60_ETH) && !defined(CONFIG_ETHADDR)
    extern void enc_set_mac_addr (void);//不编译
    enc_set_mac_addr ();
#endif /* CONFIG_ENC28J60_ETH && !CONFIG_ETHADDR*/

    /* Initialize from environment */
    if ((s = getenv ("loadaddr")) != NULL) {
        load_addr = simple_strtoul (s, NULL, 16);
    }
#if defined(CONFIG_CMD_NET)
    if ((s = getenv ("bootfile")) != NULL) {
        copy_filename (BootFile, s, sizeof (BootFile));
    }
#endif

#ifdef BOARD_LATE_INIT
    board_late_init (); //初始化i2c，pmic等
#endif

接下来涉及到了我们最关心的地方，启动模式和按键响应

#ifdef CONFIG_ANDROID_RECOVERY
    check_recovery_mode();  //检测是否进入recovery
#endif

#if defined(CONFIG_CMD_NET)
#if defined(CONFIG_NET_MULTI)
    puts ("Net:   ");
#endif
    eth_initialize(gd->bd);  //根据gd的配置初始化以太网
#if defined(CONFIG_RESET_PHY_R)
    debug ("Reset Ethernet PHY\n");
    reset_phy();
#endif
#endif
#ifdef CONFIG_FASTBOOT
    check_fastboot_mode();  //检测是否进入fastboot
#endif

从代码里可以看出我们是首先检测recovery，然后才检测fastboot模式。

我们先来看原版是怎么做的，首先是recovery

void check_recovery_mode(void)
{
    if (check_key_pressing())
        setup_recovery_env();
    else if (check_recovery_cmd_file()) {
        puts("Recovery command file founded!\n");
        setup_recovery_env();
    }
}

这里首先检测是否有合法的按键按下，如果有的话就配置环境变量进入recovery

没有按键就检测uboot命令文件，看是不是主系统要求进入recovery

因此我们这里的重点是check_key_pressing()这个函数，仔细研究发现这个函数用的是uboot

标准的gpio驱动，官方给我们移植的uboot里面并没有初始化这个驱动，而是自己另外写的。也就是说

我们调用check_key_pressing()这个函数永远都返回0值而执行else if (check_recovery_cmd_file())这一句

我们来看 check_recovery_cmd_file()

int check_recovery_cmd_file(void)
{
    int button_pressed = 0;
    int recovery_mode = 0;

    recovery_mode = check_and_clean_recovery_flag();//读取kernel的recovery标志位，如果有的话就要进入recovery

    /* Check Recovery Combo Button press or not. */
    mxc_iomux_v3_setup_pad(MX6X_IOMUX(PAD_GPIO_5__GPIO_1_5));   //初始化vol down的gpio

    gpio_direction_input(GPIO_VOL_DN_KEY);

    if (gpio_get_value(GPIO_VOL_DN_KEY) == 0) { /* VOL_DN key is low assert *///如果vol down已经按下
        button_pressed = 1;
        printf("Recovery key pressed\n");
    }

    return recovery_mode || button_pressed; //返回进入recovery
}

也就是说官方修改的uboot走了偷懒的方法，直接在check_recovery_cmd_file()增加了一个按键的盘定。很不正规

因此我们下一步要修改它,从官方的基础上走，我们也不走标准uboot 按键驱动，而是自己写。

修改之前先来看原版fastboot怎么进入的

/* export to lib_arm/board.c */
void check_fastboot_mode(void)
{
    if (fastboot_check_and_clean_flag())
        do_fastboot(NULL, 0, 0, 0);
}

这里调用fastboot_check_and_clean_flag()来判定是否进入fastboot

/* check if the recovery bit is set by kernel, it can be set by kernel
 * issue a command '# reboot fastboot' */
int fastboot_check_and_clean_flag(void)
{
    int flag_set = 0;
    u32 reg;
    reg = readl(SRC_BASE_ADDR + SRC_GPR10);

    flag_set = !!(reg & ANDROID_FASTBOOT_BOOT);

    /* clean it in case looping infinite here.... */
    if (flag_set) {
        reg &= ~ANDROID_FASTBOOT_BOOT;
        writel(reg, SRC_BASE_ADDR + SRC_GPR10);
    }

    return flag_set;
}

从这里看出，要进入进入fastboot，只能检测(SRC_BASE_ADDR + SRC_GPR10)寄存器的

ANDROID_FASTBOOT_BOOT位是否被kernel置位，并没有按键，因此我们的板子不可能靠

按键进入fastboot的实际情况也确实这样。因此我们要修改这一块，由于我们的cpu在power键按住5s

以后会强制关机。因此开机后我们必须松开power键，我们板子检测的按键只能是1个。开机时vol up键进入

recovery，按住vol down进入fastboot模式。我们修改代码如下 

新建个按键检测函数check_key()

int check_key(void)
{
    #define PRESSED_VOLUP 1
    #define PRESSED_VOLDOWN 2
    #define KEY_MASK  (PRESSED_VOLUP|PRESSED_VOLDOWN)
    #define RECOVERY_KEY_MASK (PRESSED_VOLUP)
    #define FASTBOOT_KEY_MASK (PRESSED_VOLDOWN)

    int state = 0;
    mxc_iomux_v3_setup_pad(MX6X_IOMUX(PAD_GPIO_5__GPIO_1_5));//vol down
    mxc_iomux_v3_setup_pad(MX6X_IOMUX(PAD_GPIO_5__GPIO_1_4));//vol up
    gpio_direction_input(GPIO_VOL_DN_KEY);
    gpio_direction_input(GPIO_VOL_UP_KEY);

    if (gpio_get_value(GPIO_VOL_UP_KEY) == 0)
        state |= PRESSED_VOLUP;
    if (gpio_get_value(GPIO_VOL_DN_KEY) == 0)
        state |= PRESSED_VOLDOWN;

    //如果摁下power+voldown就进入fastboot 这个的优先级要比recovery高。
    //就算同时按下power+volup+voldown三个键也要进入fastboot模式
    if ((state & KEY_MASK) == FASTBOOT_KEY_MASK)
        return 1;
    if(((state & KEY_MASK) == FASTBOOT_KEY_MASK))
        return 2;

    return 0;
}

主函数判定的代码段修改为

if (check_key()==1)
    do_fastboot(NULL, 0, 0, 0);
if (check_key()==2)
    setup_recovery_env();

if (check_and_clean_recovery_flag()) {
    setup_recovery_env();
}
if (fastboot_check_and_clean_flag())
    do_fastboot(NULL, 0, 0, 0);

这样我们的启动模式按键就修改完成了，编译后测试成功。

下面我们还有代码没有分析完：uboot的主循环：main_loop()

代码在：\bootable\bootloader\uboot-imx\common\main.c

void main_loop (void)
{
#ifndef CONFIG_SYS_HUSH_PARSER
    static char lastcommand[CONFIG_SYS_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)
    ulong bmp = 0;      /* default bitmap */
    extern int trab_vfd (ulong bitmap);

#ifdef CONFIG_MODEM_SUPPORT
    if (do_mdm_init)
        bmp = 1;    /* alternate bitmap */
#endif
    trab_vfd (bmp);
#endif  /* CONFIG_VFD && VFD_TEST_LOGO */

#if defined(CONFIG_UPDATE_TFTP)
    update_tftp ();
#endif /* CONFIG_UPDATE_TFTP */

#ifdef CONFIG_BOOTCOUNT_LIMIT
    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
    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
    {
        extern char version_string[];

        setenv ("ver", version_string);  /* set version variable */
    }
#endif /* CONFIG_VERSION_VARIABLE */

#ifdef CONFIG_SYS_HUSH_PARSER
    u_boot_hush_start ();
#endif

#if defined(CONFIG_HUSH_INIT_VAR)
    hush_init_var ();
#endif

#ifdef CONFIG_AUTO_COMPLETE
    install_auto_complete();
#endif

#ifdef CONFIG_PREBOOT
    if ((p = getenv ("preboot")) != NULL) {
# ifdef CONFIG_AUTOBOOT_KEYED
        int prev = disable_ctrlc(1);    /* disable Control C checking */
# endif

# ifndef CONFIG_SYS_HUSH_PARSER
        run_command (p, 0);
# else
        parse_string_outer(p, FLAG_PARSE_SEMICOLON |
                    FLAG_EXIT_FROM_LOOP);
# endif

# ifdef CONFIG_AUTOBOOT_KEYED
        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;//计算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_POST
    if (gd->flags & GD_FLG_POSTFAIL) {
        s = getenv("failbootcmd");
    }
    else
#endif /* CONFIG_POST */
#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");//得到bootcmd命令

    debug ("### main_loop: bootcmd=\"%s\"\n", s ? s : "");
//每10ms从控制台读取一个字符,并且显示倒计时。如果读取成功的话就继续执行main_loop代码，
//如果失败的话就执行下面的run_command(s,0)
    if (bootdelay >= 0 && s && !abortboot (bootdelay)) {
# ifdef CONFIG_AUTOBOOT_KEYED
        int prev = disable_ctrlc(1);    /* disable Control C checking */
# endif

# ifndef CONFIG_SYS_HUSH_PARSER
        run_command (s, 0);//执行 bootcmd命令
# 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 CONFIG_SYS_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 CONFIG_SYS_HUSH_PARSER
    parse_file_outer();
    /* This point is never reached */
    for (;;);
#else
    for (;;) {  //如果bootdelay时候有按键 就进入命令处理模式
#ifdef CONFIG_BOOT_RETRY_TIME
        if (rc >= 0) {
            /* Saw enough of a valid command to
             * restart the timeout.
             */
            reset_cmd_timeout();
        }
#endif
        len = readline (CONFIG_SYS_PROMPT);//从控制台读取一行数据，以回车为标志

        flag = 0;   /* assume no special flags for now */
        if (len > 0)
            z (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 ("\n");
        else
            rc = run_command (lastcommand, flag);//处理这条命令

        if (rc <= 0) {
            /* invalid command or not repeatable, forget it */
            lastcommand[0] = 0;
        }
    }
#endif /*CONFIG_SYS_HUSH_PARSER*/
}

到了这里整个的uboot流程已经走完了。从这里可以知道，uboot正式运行以后，实现的所有功能都是通过命令实现的，要继续分析的话，就要分析uboot的命令的实现了。

我们在下一篇文章里面讲述uboot命令是怎么实现的，kernel是怎么启动的。