精华内容
参与话题
问答
  • 史上最详细最全面的uboot启动过程分析,看完之后能对UBOOT有个全面的了解。绝对独家 史上最好的UBOOT分析教程。
  • uboot启动过程详解

    千次阅读 2017-04-15 17:50:05
    在android启动过程中,首先启动的便是ubootuboot是负责引导内核装入内存启动或者是引导recovery模式的启动。现在在很多android的uboot启动过程中,都需要对内核镜像和ramdisk进行验证,来保证android系统的安全...

    在android启动过程中,首先启动的便是uboot,uboot是负责引导内核装入内存启动或者是引导recovery模式的启动。现在在很多android的uboot的启动过程中,都需要对内核镜像和ramdisk进行验证,来保证android系统的安全性,如果在uboot引导过程中,如果内核镜像或ramdisk刷入的是第三方的未经过签名认证的相关镜像,则系统无法启动,这样便保证了android系统的安全性。

    在uboot启动过程中,是从start.S开始的,这里详细的细节不在赘述了,该篇文章主要学习uboot对内核镜像和ramdisk镜像的验证启动过程,同时学习一下里面的优秀巧妙的编码方式。

    我们从arch/arm/lib/board.c的函数board_init_r函数开始,我们来看一下该代码:

    
        void board_init_r(gd_t *id, ulong dest_addr)
        {
            gd = id;
    
            gd->flags |= GD_FLG_RELOC;  /* tell others: relocation done */
    
            monitor_flash_len = _end_ofs;
    
            debug("monitor flash len: %08lX\n", monitor_flash_len);
            board_init();   /* Setup chipselects */
    
        #if defined(CONFIG_MISC_INIT_R)
            /* miscellaneous platform dependent initialisations */
            misc_init_r();
        #endif
    
        #if defined(CONFIG_USE_IRQ)
            /* set up exceptions */
            interrupt_init();
    
            /* enable exceptions */
            enable_interrupts();
            printf("init interrupt done!\n");
        #endif
    
        #if defined(CONFIG_COMIP_FASTBOOT) && defined(CONFIG_LCD_SUPPORT)
            if (gd->fastboot) {
            /*register lcd support*/
        #if defined (CONFIG_LCD_AUO_OTM1285A_OTP)
                extern int lcd_auo_otm1285a_otp_init(void);
                lcd_auo_otm1285a_otp_init();
        #endif
        #if defined (CONFIG_LCD_AUO_R61308OTP)
                extern int lcd_auo_r61308opt_init(void);
                lcd_auo_r61308opt_init();
        #endif
        #if defined (CONFIG_LCD_AUO_NT35521)
                extern int lcd_auo_nt35521_init(void);
                lcd_auo_nt35521_init();
        #endif
        #if defined (CONFIG_LCD_SHARP_R69431)
                extern int lcd_sharp_eR69431_init(void);
                lcd_sharp_eR69431_init();
        #endif
                /*initialize lcdc & display logo*/
                extern int comipfb_probe(void);
                comipfb_probe();
            }
        #endif
    
        #if defined(CONFIG_COMIP_TARGETLOADER)
            extern int targetloader_init(void);
            targetloader_init();
        #elif defined(CONFIG_COMIP_FASTBOOT)
            if (gd->fastboot) {
                extern int fastboot_init(void);
                fastboot_init();
                while(1);
            }
        #endif
    
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_FOR_BOOT)
                extern  int secure_verify(void);
                extern void pmic_power_off(void);
                if(secure_verify()) {
                        printf("Secure verify failed! Shutdown now!\n");
                        pmic_power_off();
                } else {
                        printf("Secure verify succeed!\n");
                }
        #endif
    
            do_bootm_linux();
    
            /* 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 */
        }
    

    首先该函数做的是初始化board,调用board_init()函数。该函数位于board/****/***.c文件中,该文件由于属于板子厂家,所以暂时保密。我们来看一下这个函数:

    
        int board_init(void)
        {
            gd->bd->bi_arch_number = MACH_TYPE_LC186X;
            gd->bd->bi_boot_params = CONFIG_BOOT_PARAMS_LOADADDR;
    
        #ifndef CONFIG_COMIP_TARGETLOADER
            tl420_init();
    
            watchdog_init();
    
            comip_lc186x_coresight_config();
    
            comip_lc186x_sysclk_config();
    
            comip_lc186x_sec_config();
    
            comip_lc186x_bus_prior_config();
        #endif
    
        #if defined(COMIP_LOW_POWER_MODE_ENABLE)
            comip_lp_regs_init();
        #endif
            icache_enable();
            //dcache_enable();
        #if CONFIG_COMIP_EMMC_ENHANCE
            mmc_set_dma(1);
        #endif
            flash_init();
    
        #ifndef CONFIG_COMIP_TARGETLOADER
            pmic_power_on_key_check();
            boot_image();
            pmic_power_on_key_check();
        #endif
    
        #ifdef CONFIG_PMIC_VIBRATOR
            pmic_vibrator_enable_set();
        #endif
    
            return 0;
        }
    

    在该函数中,主要是用于初始化一些参数和硬件,包括arch版本号,boot加载地址,初始化watchdog,系统时钟,总线,flash,同时还需要做的就是,我们开机时的按钮监听,组合键按钮监听,启动镜像,开机震动等操作,在这里我们看一下boot_image()函数的实现。

    
        static void boot_image(void)
        {
            char *kernel_name = CONFIG_PARTITION_KERNEL;
            char *ramdisk_name = CONFIG_PARTITION_RAMDISK;
            int pu_reason;
            int key_code;
            int ret;
    
            pu_reason = pmic_power_up_reason_get();
            if ((pu_reason == PU_REASON_REBOOT_RECOVERY)
                    || (pu_reason == PU_REASON_REBOOT_FOTA)
                    || check_recovery_misc() || check_recovery_fota()) {
                gd->boot_mode = BOOT_MODE_RECOVERY;
                ramdisk_name = CONFIG_PARTITION_RAMDISK_RECOVERY;
        #if defined(CONFIG_USE_KERNEL_RECOVERY)
                kernel_name = CONFIG_PARTITION_KERNEL_RECOVERY;
        #endif
            } else {
                ret = keypad_init();
                if (ret)
                    printf("keypad init failed!\n");
    
                key_code = keypad_check();
                printf("key code: %d\n", key_code);
    
                 if(pu_reason == PU_REASON_USB_CHARGER
                    #if defined(CONFIG_COMIP_FASTBOOT)
                        && key_code != CONFIG_KEY_CODE_FASTBOOT
                    #endif
                ) {
                    gd->boot_mode = BOOT_MODE_NORMAL;
                    ramdisk_name = CONFIG_PARTITION_RAMDISK_AMT1;
                } else {
                    switch (key_code) {
                    case KEY_CODE_RECOVERY:
                        gd->boot_mode = BOOT_MODE_RECOVERY;
                        ramdisk_name = CONFIG_PARTITION_RAMDISK_RECOVERY;
                        #if defined(CONFIG_USE_KERNEL_RECOVERY)
                        kernel_name = CONFIG_PARTITION_KERNEL_RECOVERY;
                        #endif
                        break;
                    #if defined(CONFIG_USE_RAMDISK_AMT3)
                    case KEY_CODE_AMT3:
                        gd->boot_mode = BOOT_MODE_AMT3;
                        ramdisk_name = CONFIG_PARTITION_RAMDISK_AMT3;
                        break;
                    #endif
                    default:
                        gd->boot_mode = BOOT_MODE_NORMAL;
                        ramdisk_name = CONFIG_PARTITION_RAMDISK;
                        break;
                    }
    
                    #if defined(CONFIG_COMIP_FASTBOOT)
                    if (key_code == CONFIG_KEY_CODE_FASTBOOT) {
                        printf("goto fastmode!\n");
                        gd->fastboot = 1;
                    }
                    #endif
                }
            }
    
            printf("kernel name: %s, ramdisk name: %s\n", kernel_name, ramdisk_name);
    
            flash_partition_read(kernel_name, (u8*)(CONFIG_KERNEL_LOADADDR - IMAGE_ADDR_OFFSET), 0xffffffff);
    
            flash_partition_read(ramdisk_name, (u8*)(CONFIG_RAMDISK_LOADADDR - IMAGE_ADDR_OFFSET), 0xffffffff);
    
        #if defined(CONFIG_COMIP_FASTBOOT) && defined(CONFIG_LCD_SUPPORT)
            if (unlikely(gd->fastboot))
                flash_partition_read(CONFIG_PARTITION_FASTBOOT_LOGO, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
            else
                flash_partition_read(CONFIG_PARTITION_LOGO, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
        #else
            flash_partition_read(CONFIG_PARTITION_LOGO, (u8*)(unsigned int)gd->fb_base, CONFIG_FB_MEMORY_SIZE);
        #endif
    
            printf("boot image end\n");
        }
        #endif /* !CONFIG_COMIP_TARGETLOADER */
    

    在这里首先需要确定内核镜像和ramdisk镜像的地址,然后初始化按钮监听,根据不同的按钮组合按键启动不同的镜像,包括正常启动,也就是说启动内核,启动android;启动recovery镜像;启动工厂模式等。将这些镜像数据读取进入flash中引导启动。

    接着我们回到board.c,程序接着运行,接着初始化misc,初始化中断,使能中断;同时在这里判断是否进去fastboot模式。接着,进入我们的重点,也就是安全启动验证阶段。

        #if defined(CONFIG_ENABLE_SECURE_VERIFY_FOR_BOOT)
                extern  int secure_verify(void);
                extern void pmic_power_off(void);
                if(secure_verify()) {
                        printf("Secure verify failed! Shutdown now!\n");
                        pmic_power_off();
                } else {
                        printf("Secure verify succeed!\n");
                }
        #endif
    

    在这里,我们刚刚说了,已经把相应的内核镜像数据和ramdisk镜像数据读入到flash中了。

    那么uboot又是如何验证内核镜像和ramdisk镜像的呢?我们接着看。

    我们先来看函数secure_verify()函数。

    
        int secure_verify(void)
        {
                getverifyimage(VERIFY_KERNEL);
                if (image_rsa_verify()) {
                        printf("kernel verify failed!\n");
                        return 1;
                } else {
                        printf("kernel verify ok!\n");
                        getverifyimage(VERIFY_RAMDISK);
                        if(image_rsa_verify()) {
                                printf("ramdisk verify failed!\n");
                                return 1;
                        } else {
                                printf("ramdisk verify ok!\n");
                        }
                }
                return 0;
        }
    

    在这段代码中,我们可以看出,首先是获取内核镜像数据,然后进行rsa签名验证,接着获取ramdisk镜像数据,接着进行签名验证。

    我们来看一下如何获取内核镜像数据或者是ramdisk镜像数据,也就是getverifyimage()函数。

    
        void getverifyimage(int whichimage)
        {
                int i;
                unsigned int *cfgInfor = image_data_all;
                int ret;
    
                if(whichimage == VERIFY_KERNEL) {
                        image_data_all = CONFIG_KERNEL_LOADADDR - HEADINFOLEN;
                } else if(whichimage == VERIFY_RAMDISK) {
                        image_data_all = CONFIG_RAMDISK_LOADADDR - HEADINFOLEN;
                }
                cfgInfor = (unsigned int *)image_data_all;
                ORIGIN_IMAGE_LEN =  cfgInfor[0];
    
                for(i=0; i<(256/4); i++)
                {
                        RSASIGNATURE[i] = cfgInfor[i + (RSASIGNEDLEN / 4)];
                }
    
                for(i=0; i<(524/4); i++)
                {
                        RSAPUBKEYSTRU[i] = cfgInfor[i + (RSAPUBKEYLEN / 4)];
            }
    
                ORIGIN_IMAGE_BASEADDR = &image_data_all[HEADINFOLEN];
    
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
                printf("image len:0x%x(%d)\n", ORIGIN_IMAGE_LEN, ORIGIN_IMAGE_LEN);
    
                dumphex("rsa pub key", RSAPUBKEYSTRU, 524/4);
                dumpint("rsa pub key", RSAPUBKEYSTRU, 524/4);
        #endif
        }
    

    我们以内核启动验证为例进行讲解,ramdisk是一样的。我先来画一下内核镜像数据在flash中的分布,这样分析起代码来便会更容易理解。

    这里写图片描述

    首先我们需要了解的是,我们刷入的内核镜像并不是可运行的内核镜像,因为我们在真正的内核镜像之前加入了一个小小的1.5K的头,该头里面包含了内核的大小,经过私钥对内核签名后的签名,以及需要使用的公钥生成的一些属性。所以在该获取镜像的函数中,我们获取了所有的内核镜像数据,内核镜像大小,签名数据以及公钥属性数据。

    下面我们就需要对其进行rsa验证。

    
          /******************************************************
                        Let image to do RSA verify. If verify OK,
                        return 0. Otherwise, return 1.
        *******************************************************/
        int image_rsa_verify(void)
        {
                        unsigned int value, i;
                        unsigned char *image_sha256;
                        unsigned char *signature;
                        RSAPublicKey *public_key;
                        SHA256_CTX ctx;
    
                        updateNum = 0;
                        value = rsaPubKey_sha256_verify();
                        if(value == 1)
                                return 1;
    
                        updateNum = 0;
                        image_sha256 = (unsigned char*)SHA256_hash(ORIGIN_IMAGE_BASEADDR, ORIGIN_IMAGE_LEN, image_sha256, &ctx);
    
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
                        dumphex("current image hash", uboot_sha256, 32);
        #endif
    
                        for(i=0; i<32; i++)
                                ORIGIN_IMAGE_SHA[i] = image_sha256[i];
    
                        updateNum = 0;
                        signature = (unsigned char*)RSASIGNATURE;
                        public_key = (RSAPublicKey *)RSAPUBKEYSTRU;
                        value = RSA_verify(public_key, signature, 256, ORIGIN_IMAGE_SHA, 32);
    
                        if(value == 0)
                                return 1;
                        return 0;
        }
    
    

    通过这个函数可以看到,对内核进行了两次验证,一次是通过函数rsaPubKey_sha256_verify()进行验证,另外一个是通过RSA_verify进行验证,我们先来看第一个:

    
          /****************************************************
                        Use SHA256 to generate digest of RSA pub-key, 
                        which is 524 BYTES. Then compare the digest 
                        with the original digest which is store in the
                        EFUSE. If the new digest equals original digest,
                        it means RSA pub-key is right. Otherwise, means
                        the RSA pub-key is wrong. 
        *****************************************************/
        int rsaPubKey_sha256_verify(void)
        {
                unsigned int *digest, origDigest[8], i, result;
                unsigned char *newDigest;
                SHA256_CTX ctx;
                digest = (unsigned int *)SHA256_hash(RSAPUBKEYSTRU, 524, newDigest, &ctx);
        #if 1
                origDigest[0] = *RSA_SIGNATURE0;
                origDigest[1] = *RSA_SIGNATURE1;
                origDigest[2] = *RSA_SIGNATURE2;
                origDigest[3] = *RSA_SIGNATURE3;
                origDigest[4] = *RSA_SIGNATURE4;
                origDigest[5] = *RSA_SIGNATURE5;
                origDigest[6] = *RSA_SIGNATURE6;
                origDigest[7] = *RSA_SIGNATURE7;
        #else
                origDigest[0] = rsahash[0];
                origDigest[1] = rsahash[1];
                origDigest[2] = rsahash[2];
                origDigest[3] = rsahash[3];
                origDigest[4] = rsahash[4];
                origDigest[5] = rsahash[5];
                origDigest[6] = rsahash[6];
                origDigest[7] = rsahash[7];
        #endif
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
                dumphex("pubkey hash", digest, 32);
                dumphex("read pubkey hash", origDigest, 32);
        #endif
                //new key and old key xor
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
                printf("read pubkey hash:\n");
        #endif
                for(i=0; i<8; i++)
                {
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
                    printf("%08x ", origDigest[i]);
        #endif
                    result = ((origDigest[i]) ^ (digest[i]));
                    if(result != 0) {
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
                        printf("ERROR! %s %d\n", __func__,__LINE__);
        #endif
                        return 1;
                    }
                }
    
        #if defined(CONFIG_ENABLE_SECURE_VERIFY_DEBUG)
                        dumphex("pubkey hash", digest, 32);
        #endif
                        return 0;
    
    

    这里是对公钥进行sha256签名来验证公钥是否是对的,具体的函数实现不再学习。

    接着通过对内核镜像数据进行sha256获取哈希,然后,使用公钥和签名进行签名验证,验证内核镜像数据是否是正确的。这样,通过这两步,必须两步都对,才能进行内核的正常加载和运行。

    ramdisk镜像的签名验证也是如何,对内核镜像和ramdisk镜像签名验证之后,接着执行下面的操作,也就是执行do_bootm_linux()函数,该函数的实现如下:

    
          void do_bootm_linux(void)
        {
            bd_t *bd = gd->bd;
            void (*theKernel) (int zero, int arch, uint params);
            theKernel = (void (*)(int, int, uint))CONFIG_KERNEL_LOADADDR;
    
            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);
    
            params = comip_set_boot_params(params);
    
            params->hdr.tag = ATAG_NONE;
            params->hdr.size = 0;
    
            /* we assume that the kernel is in place */
            printf("\nStarting kernel ...\n");
            cleanup_before_linux();
            theKernel(0, bd->bi_arch_number, bd->bi_boot_params);
        }
    

    在这里实际上就是通过一个theKernel函数指针,加载内核启动运行,这样,便进行内核的启动运行了。

    这样,我们便把uboot的启动流程以及对内核和ramdisk进行启动验证的过程进行了一个整体的学习,其内部的RSA算法实现不再赘述。

    展开全文
  • uboot启动过程教程详解

    千次阅读 2018-06-07 13:38:16
    1.1 U-Boot工作过程U-Boot启动内核的过程可以分为两个阶段,两个阶段的功能如下:(1)第一阶段的功能Ø 硬件设备初始化Ø 加载U-Boot第二阶段代码到RAM空间Ø 设置好栈Ø 跳转到第二阶段代码入口(2)第二阶段的...

    1.1 U-Boot工作过程

    U-Boot启动内核的过程可以分为两个阶段,两个阶段的功能如下:

    (1)第一阶段的功能

    Ø 硬件设备初始化

    Ø 加载U-Boot第二阶段代码到RAM空间

    Ø 设置好栈

    Ø 跳转到第二阶段代码入口

    (2)第二阶段的功能

    Ø 初始化本阶段使用的硬件设备

    Ø 检测系统内存映射

    Ø 将内核从Flash读取到RAM中

    Ø 为内核设置启动参数

    Ø 调用内核

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

    第一阶段对应的文件是cpu/arm920t/start.S和board/samsung/mini2440/lowlevel_init.S。

    U-Boot启动第一阶段流程如下:

    图 2.1 U-Boot启动第一阶段流程

    根据cpu/arm920t/u-boot.lds中指定的连接方式:

    ENTRY(_start)

    SECTIONS

    {

    . = 0x00000000;

    . = ALIGN(4);

    .text :

    {

    cpu/arm920t/start.o (.text)

    board/samsung/mini2440/lowlevel_init.o (.text)

    board/samsung/mini2440/nand_read.o (.text)

    *(.text)

    }

    … …

    }

    第一个链接的是cpu/arm920t/start.o,因此u-boot.bin的入口代码在cpu/arm920t/start.o中,其源代码在cpu/arm920t/start.S中。下面我们来分析cpu/arm920t/start.S的执行。

    1. 硬件设备初始化

    (1)设置异常向量

    cpu/arm920t/start.S开头有如下的代码:

    .globl _start

    _start: b start_code /*复位 */

    ldr pc, _undefined_instruction /* 未定义指令向量 */

    ldr pc, _software_interrupt /* 软件中断向量 */

    ldr pc, _prefetch_abort /* 预取指令异常向量 */

    ldr pc, _data_abort /* 数据操作异常向量 */

    ldr pc, _not_used /* 未使用 */

    ldr pc, _irq /* irq中断向量 */

    ldr pc, _fiq /* fiq中断向量 */

    /* 中断向量表入口地址 */

    _undefined_instruction: .word undefined_instruction

    _software_interrupt: .word software_interrupt

    _prefetch_abort: .word prefetch_abort

    _data_abort: .word data_abort

    _not_used: .word not_used

    _irq: .word irq

    _fiq: .word fiq

    .balignl 16,0xdeadbeef

    以上代码设置了ARM异常向量表,各个异常向量介绍如下:

    表 2.1 ARM异常向量表

    地址

    异常

    进入模式

    描述

    0x00000000

    复位

    管理模式

    复位电平有效时,产生复位异常,程序跳转到复位处理程序处执行

    0x00000004

    未定义指令

    未定义模式

    遇到不能处理的指令时,产生未定义指令异常

    0x00000008

    软件中断

    管理模式

    执行SWI指令产生,用于用户模式下的程序调用特权操作指令

    0x0000000c

    预存指令

    中止模式

    处理器预取指令的地址不存在,或该地址不允许当前指令访问,产生指令预取中止异常

    0x00000010

    数据操作

    中止模式

    处理器数据访问指令的地址不存在,或该地址不允许当前指令访问时,产生数据中止异常

    0x00000014

    未使用

    未使用

    未使用

    0x00000018

    IRQ

    IRQ

    外部中断请求有效,且CPSR中的I位为0时,产生IRQ异常

    0x0000001c

    FIQ

    FIQ

    快速中断请求引脚有效,且CPSR中的F位为0时,产生FIQ异常

    在cpu/arm920t/start.S中还有这些异常对应的异常处理程序。当一个异常产生时,CPU根据异常号在异常向量表中找到对应的异常向量,然后执行异常向量处的跳转指令,CPU就跳转到对应的异常处理程序执行。

    其中复位异常向量的指令“b start_code”决定了U-Boot启动后将自动跳转到标号“start_code”处执行。

    (2)CPU进入SVC模式

    start_code:

    /*

    * set the cpu to SVC32 mode

    */

    mrs r0, cpsr

    bic r0, r0, #0x1f /*工作模式位清零 */

    orr r0, r0, #0xd3 /*工作模式位设置为“10011”(管理模式),并将中断禁止位和快中断禁止位置1 */

    msr cpsr, r0

    以上代码将CPU的工作模式位设置为管理模式,并将中断禁止位和快中断禁止位置一,从而屏蔽了IRQ和FIQ中断。

    (3)设置控制寄存器地址

    # if defined(CONFIG_S3C2400)

    # define pWTCON 0x15300000

    # define INTMSK 0x14400008

    # define CLKDIVN 0x14800014

    #else /* s3c2410与s3c2440下面4个寄存器地址相同 */

    # define pWTCON 0x53000000 /* WATCHDOG控制寄存器地址 */

    # define INTMSK 0x4A000008 /* INTMSK寄存器地址 */

    # define INTSUBMSK 0x4A00001C /* INTSUBMSK寄存器地址 */

    # define CLKDIVN 0x4C000014 /* CLKDIVN寄存器地址 */

    # endif

    对与s3c2440开发板,以上代码完成了WATCHDOG,INTMSK,INTSUBMSK,CLKDIVN四个寄存器的地址的设置。各个寄存器地址参见参考文献[4] 。

    (4)关闭看门狗

    ldr r0, =pWTCON

    mov r1, #0x0

    str r1, [r0] /*看门狗控制器的最低位为0时,看门狗不输出复位信号 */

    以上代码向看门狗控制寄存器写入0,关闭看门狗。否则在U-Boot启动过程中,CPU将不断重启。

    (5)屏蔽中断

    /*

    * mask all IRQs by setting all bits in the INTMR - default

    */

    mov r1, #0xffffffff /* 某位被置1则对应的中断被屏蔽 */

    ldr r0, =INTMSK

    str r1, [r0]

    INTMSK是主中断屏蔽寄存器,每一位对应SRCPND(中断源引脚寄存器)中的一位,表明SRCPND相应位代表的中断请求是否被CPU所处理。

    根据参考文献4,INTMSK寄存器是一个32位的寄存器,每位对应一个中断,向其中写入0xffffffff就将INTMSK寄存器全部位置一,从而屏蔽对应的中断。

    # if defined(CONFIG_S3C2440)

    ldr r1, =0x7fff

    ldr r0, =INTSUBMSK

    str r1, [r0]

    # endif

    INTSUBMSK每一位对应SUBSRCPND中的一位,表明SUBSRCPND相应位代表的中断请求是否被CPU所处理。

    根据参考文献4,INTSUBMSK寄存器是一个32位的寄存器,但是只使用了低15位。向其中写入0x7fff就是将INTSUBMSK寄存器全部有效位(低15位)置一,从而屏蔽对应的中断。

    (6)设置MPLLCON,UPLLCON, CLKDIVN

    # if defined(CONFIG_S3C2440)

    #define MPLLCON 0x4C000004

    #define UPLLCON 0x4C000008

    ldr r0, =CLKDIVN

    mov r1, #5

    str r1, [r0]

    ldr r0, =MPLLCON

    ldr r1, =0x7F021

    str r1, [r0]

    ldr r0, =UPLLCON

    ldr r1, =0x38022

    str r1, [r0]

    # else

    /* FCLK:HCLK:PCLK = 1:2:4 */

    /* default FCLK is 120 MHz ! */

    ldr r0, =CLKDIVN

    mov r1, #3

    str r1, [r0]

    #endif

    CPU上电几毫秒后,晶振输出稳定,FCLK=Fin(晶振频率),CPU开始执行指令。但实际上,FCLK可以高于Fin,为了提高系统时钟,需要用软件来启用PLL。这就需要设置CLKDIVN,MPLLCON,UPLLCON这3个寄存器。

    CLKDIVN寄存器用于设置FCLK,HCLK,PCLK三者间的比例,可以根据表2.2来设置。

    表 2.2 S3C2440 的CLKDIVN寄存器格式

    CLKDIVN

    说明

    初始值

    HDIVN

    [2:1]

    00 : HCLK = FCLK/1.

    01 : HCLK = FCLK/2.

    10 : HCLK = FCLK/4 (当 CAMDIVN[9] = 0 时)

    HCLK= FCLK/8 (当 CAMDIVN[9] = 1 时)

    11 : HCLK = FCLK/3 (当 CAMDIVN[8] = 0 时)

    HCLK = FCLK/6 (当 CAMDIVN[8] = 1时)

    00

    PDIVN

    [0]

    0: PCLK = HCLK/1 1: PCLK = HCLK/2

    0

    设置CLKDIVN为5,就将HDIVN设置为二进制的10,由于CAMDIVN[9]没有被改变过,取默认值0,因此HCLK = FCLK/4。PDIVN被设置为1,因此PCLK= HCLK/2。因此分频比FCLK:HCLK:PCLK = 1:4:8 。

    MPLLCON寄存器用于设置FCLK与Fin的倍数。MPLLCON的位[19:12]称为MDIV,位[9:4]称为PDIV,位[1:0]称为SDIV。

    对于S3C2440,FCLK与Fin的关系如下面公式:

    MPLL(FCLK) = (2×m×Fin)/(p×)

    其中: m=MDIC+8,p=PDIV+2,s=SDIV

    MPLLCON与UPLLCON的值可以根据参考文献4中“PLL VALUE SELECTION TABLE”设置。该表部分摘录如下:

    表 2.3 推荐PLL值

    输入频率

    输出频率

    MDIV

    PDIV

    SDIV

    12.0000MHz

    48.00 MHz

    56(0x38)

    2

    2

    12.0000MHz

    405.00 MHz

    127(0x7f)

    2

    1

    当mini2440系统主频设置为405MHZ,USB时钟频率设置为48MHZ时,系统可以稳定运行,因此设置MPLLCON与UPLLCON为:

    MPLLCON=(0x7f<<12) | (0x02<<4) | (0x01) = 0x7f021

    UPLLCON=(0x38<<12) | (0x02<<4) | (0x02) = 0x38022

    (7)关闭MMU,cache

    接着往下看:

    #ifndef CONFIG_SKIP_LOWLEVEL_INIT

    bl cpu_init_crit

    #endif

    cpu_init_crit这段代码在U-Boot正常启动时才需要执行,若将U-Boot从RAM中启动则应该注释掉这段代码。

    下面分析一下cpu_init_crit到底做了什么:

    320 #ifndef CONFIG_SKIP_LOWLEVEL_INIT

    321 cpu_init_crit:

    322 /*

    323 * 使数据cache与指令cache无效 */

    324 */

    325 mov r0, #0

    326 mcr p15, 0, r0, c7, c7, 0 /* 向c7写入0将使ICache与DCache无效*/

    327 mcr p15, 0, r0, c8, c7, 0 /* 向c8写入0将使TLB失效 */

    328

    329 /*

    330 * disable MMU stuff and caches

    331 */

    332 mrc p15, 0, r0, c1, c0, 0 /* 读出控制寄存器到r0中 */

    333 bic r0, r0, #0x00002300 @ clear bits 13, 9:8 (--V- --RS)

    334 bic r0, r0, #0x00000087 @ clear bits 7, 2:0 (B--- -CAM)

    335 orr r0, r0, #0x00000002 @ set bit 2 (A) Align

    336 orr r0, r0, #0x00001000 @ set bit 12 (I) I-Cache

    337 mcr p15, 0, r0, c1, c0, 0 /* 保存r0到控制寄存器 */

    338

    339 /*

    340 * before relocating, we have to setup RAM timing

    341 * because memory timing is board-dependend, you will

    342 * find a lowlevel_init.S in your board directory.

    343 */

    344 mov ip, lr

    345

    346 bl lowlevel_init

    347

    348 mov lr, ip

    349 mov pc, lr

    350 #endif /* CONFIG_SKIP_LOWLEVEL_INIT */

    代码中的c0,c1,c7,c8都是ARM920T的协处理器CP15的寄存器。其中c7是cache控制寄存器,c8是TLB控制寄存器。325~327行代码将0写入c7、c8,使Cache,TLB内容无效。

    第332~337行代码关闭了MMU。这是通过修改CP15的c1寄存器来实现的,先看CP15的c1寄存器的格式(仅列出代码中用到的位):

    表 2.3 CP15的c1寄存器格式(部分)

    15

    14

    13

    12

    11

    10

    9

    8

    7

    6

    5

    4

    3

    2

    1

    0

    .

    .

    V

    I

    .

    .

    R

    S

    B

    .

    .

    .

    .

    C

    A

    M

    各个位的意义如下:

    V : 表示异常向量表所在的位置,0:异常向量在0x00000000;1:异常向量在 0xFFFF0000
    I : 0 :关闭ICaches;1 :开启ICaches
    R、S : 用来与页表中的描述符一起确定内存的访问权限
    B : 0 :CPU为小字节序;1 : CPU为大字节序
    C : 0:关闭DCaches;1:开启DCaches
    A : 0:数据访问时不进行地址对齐检查;1:数据访问时进行地址对齐检查
    M : 0:关闭MMU;1:开启MMU

    332~337行代码将c1的 M位置零,关闭了MMU。

    (8)初始化RAM控制寄存器

    其中的lowlevel_init就完成了内存初始化的工作,由于内存初始化是依赖于开发板的,因此lowlevel_init的代码一般放在board下面相应的目录中。对于mini2440,lowlevel_init在board/samsung/mini2440/lowlevel_init.S中定义如下:

    45 #define BWSCON 0x48000000 /* 13个存储控制器的开始地址 */

    … …

    129 _TEXT_BASE:

    130 .word TEXT_BASE

    131

    132 .globl lowlevel_init

    133 lowlevel_init:

    134 /* memory control configuration */

    135 /* make r0 relative the current location so that it */

    136 /* reads SMRDATA out of FLASH rather than memory ! */

    137 ldr r0, =SMRDATA

    138 ldr r1, _TEXT_BASE

    139 sub r0, r0, r1 /* SMRDATA减 _TEXT_BASE就是13个寄存器的偏移地址 */

    140 ldr r1, =BWSCON /* Bus Width Status Controller */

    141 add r2, r0, #13*4

    142 0:

    143 ldr r3, [r0], #4 /*将13个寄存器的值逐一赋值给对应的寄存器*/

    144 str r3, [r1], #4

    145 cmp r2, r0

    146 bne 0b

    147

    148 /* everything is fine now */

    149 mov pc, lr

    150

    151 .ltorg

    152 /* the literal pools origin */

    153

    154 SMRDATA: /* 下面是13个寄存器的值 */

    155 .word … …

    156 .word … …

    … …

    lowlevel_init初始化了13个寄存器来实现RAM时钟的初始化。lowlevel_init函数对于U-Boot从NAND Flash或NOR Flash启动的情况都是有效的。

    U-Boot.lds链接脚本有如下代码:

    .text :

    {

    cpu/arm920t/start.o (.text)

    board/samsung/mini2440/lowlevel_init.o (.text)

    board/samsung/mini2440/nand_read.o (.text)

    … …

    }

    board/samsung/mini2440/lowlevel_init.o将被链接到cpu/arm920t/start.o后面,因此board/samsung/mini2440/lowlevel_init.o也在U-Boot的前4KB的代码中。

    U-Boot在NAND Flash启动时,lowlevel_init.o将自动被读取到CPU内部4KB的内部RAM中。因此第137~146行的代码将从CPU内部RAM中复制寄存器的值到相应的寄存器中。

    对于U-Boot在NOR Flash启动的情况,由于U-Boot连接时确定的地址是U-Boot在内存中的地址,而此时U-Boot还在NOR Flash中,因此还需要在NOR Flash中读取数据到RAM中。

    由于NOR Flash的开始地址是0,而U-Boot的加载到内存的起始地址是TEXT_BASE,SMRDATA标号在Flash的地址就是SMRDATA-TEXT_BASE。

    综上所述,lowlevel_init的作用就是将SMRDATA开始的13个值复制给开始地址[BWSCON]的13个寄存器,从而完成了存储控制器的设置。

    (9)复制U-Boot第二阶段代码到RAM

    cpu/arm920t/start.S原来的代码是只支持从NOR Flash启动的,经过修改现在U-Boot在NOR Flash和NAND Flash上都能启动了,实现的思路是这样的:

    bl bBootFrmNORFlash /* 判断U-Boot是在NAND Flash还是NOR Flash启动 */

    cmp r0, #0 /* r0存放bBootFrmNORFlash函数返回值,若返回0表示NAND Flash启动,否则表示在NOR Flash启动 */

    beq nand_boot /* 跳转到NAND Flash启动代码 */

    /* NOR Flash启动的代码 */

    b stack_setup /*跳过NAND Flash启动的代码 */

    nand_boot:

    /* NAND Flash启动的代码 */

    stack_setup:

    /*其他代码 */

    其中bBootFrmNORFlash函数作用是判断U-Boot是在NAND Flash启动还是NOR Flash启动,若在NOR Flash启动则返回1,否则返回0。根据ATPCS规则,函数返回值会被存放在r0寄存器中,因此调用bBootFrmNORFlash函数后根据r0的值就可以判断U-Boot在NAND Flash启动还是NOR Flash启动。bBootFrmNORFlash函数在board/samsung/mini2440/nand_read.c中定义如下:

    int bBootFrmNORFlash(void)

    {

    volatile unsigned int *pdw = (volatile unsigned int *)0;

    unsigned int dwVal;

    dwVal = *pdw; /*先记录下原来的数据 */

    *pdw = 0x12345678;

    if (*pdw != 0x12345678) /* 写入失败,说明是在NOR Flash启动 */

    {

    return 1;

    }

    else /* 写入成功,说明是在NAND Flash启动 */

    {

    *pdw = dwVal; /* 恢复原来的数据 */

    return 0;

    }

    }

    无论是从NOR Flash还是从NAND Flash启动,地址0处为U-Boot的第一条指令“ b start_code”。

    对于从NAND Flash启动的情况,其开始4KB的代码会被自动复制到CPU内部4K内存中,因此可以通过直接赋值的方法来修改。

    对于从NOR Flash启动的情况,NOR Flash的开始地址即为0,必须通过一定的命令序列才能向NOR Flash中写数据,所以可以根据这点差别来分辨是从NAND Flash还是NOR Flash启动:向地址0写入一个数据,然后读出来,如果发现写入失败的就是NOR Flash,否则就是NAND Flash。

    下面来分析NOR Flash启动部分代码:

    208 adr r0, _start /* r0<- current position of code */

    209 ldr r1, _TEXT_BASE /* test if we run from flash or RAM */

    /* 判断U-Boot是否是下载到RAM中运行,若是,则不用 再复制到RAM中了,这种情况通常在调试U-Boot时才发生 */

    210 cmp r0, r1 /*_start等于_TEXT_BASE说明是下载到RAM中运行 */

    211 beq stack_setup

    212 /* 以下直到nand_boot标号前都是NOR Flash启动的代码 */

    213 ldr r2, _armboot_start

    214 ldr r3, _bss_start

    215 sub r2, r3, r2 /* r2<- size of armboot */

    216 add r2, r0, r2 /* r2<- source end address */

    217 /* 搬运U-Boot自身到RAM中*/

    218 copy_loop:

    219 ldmia r0!, {r3-r10} /* 从地址为[r0]的NOR Flash中读入8个字的数据 */

    220 stmia r1!, {r3-r10} /* 将r3至r10寄存器的数据复制给地址为[r1]的内存 */

    221 cmp r0, r2 /* until source end addreee [r2] */

    222 ble copy_loop

    223 b stack_setup /* 跳过NAND Flash启动的代码 */

    下面再来分析NAND Flash启动部分代码:

    nand_boot:

    mov r1, #NAND_CTL_BASE

    ldr r2, =( (7<<12)|(7<<8)|(7<<4)|(0<<0) )

    str r2, [r1, #oNFCONF] /* 设置NFCONF寄存器 */

    /*设置NFCONT,初始化ECC编/解码器,禁止NAND Flash片选 */

    ldr r2, =( (1<<4)|(0<<1)|(1<<0) )

    str r2, [r1, #oNFCONT]

    ldr r2, =(0x6) /* 设置NFSTAT */

    str r2, [r1, #oNFSTAT]

    /*复位命令,第一次使用NAND Flash前复位 */

    mov r2, #0xff

    strb r2, [r1, #oNFCMD]

    mov r3, #0

    /* 为调用C函数nand_read_ll准备堆栈 */

    ldr sp, DW_STACK_START

    mov fp, #0

    /* 下面先设置r0至r2,然后调用nand_read_ll函数将U-Boot读入RAM */

    ldr r0, =TEXT_BASE /* 目的地址:U-Boot在RAM的开始地址 */

    mov r1, #0x0 /* 源地址:U-Boot在NAND Flash中的开始地址 */

    mov r2, #0x30000 /* 复制的大小,必须比u-boot.bin文件大,并且必须是NAND Flash块大小的整数倍,这里设置为0x30000(192KB) */

    bl nand_read_ll /*跳转到nand_read_ll函数,开始复制U-Boot到RAM */

    tst r0, #0x0 /*检查返回值是否正确 */

    beq stack_setup

    bad_nand_read:

    loop2: b loop2 //infinite loop

    .align 2

    DW_STACK_START: .word STACK_BASE+STACK_SIZE-4

    其中NAND_CTL_BASE,oNFCONF等在include/configs/mini2440.h中定义如下:

    #define NAND_CTL_BASE 0x4E000000 // NAND Flash控制寄存器基址

    #define STACK_BASE 0x33F00000 //base address of stack

    #define STACK_SIZE 0x8000 //size of stack

    #define oNFCONF 0x00 /* NFCONF相对于NAND_CTL_BASE偏移地址 */

    #define oNFCONT 0x04 /* NFCONT相对于NAND_CTL_BASE偏移地址*/

    #define oNFADDR 0x0c /* NFADDR相对于NAND_CTL_BASE偏移地址*/

    #define oNFDATA 0x10 /* NFDATA相对于NAND_CTL_BASE偏移地址*/

    #define oNFCMD 0x08 /* NFCMD相对于NAND_CTL_BASE偏移地址*/

    #define oNFSTAT 0x20 /* NFSTAT相对于NAND_CTL_BASE偏移地址*/

    #define oNFECC 0x2c /* NFECC相对于NAND_CTL_BASE偏移地址*/

    NAND Flash各个控制寄存器的设置在S3C2440的数据手册有详细说明,这里就不介绍了。

    代码中nand_read_ll函数的作用是在NAND Flash中搬运U-Boot到RAM,该函数在board/samsung/mini2440/nand_read.c中定义。

    NAND Flash根据page大小可分为2种: 512B/page和2048B/page的。这两种NAND Flash的读操作是不同的。因此就需要U-Boot识别到NAND Flash的类型,然后采用相应的读操作,也就是说nand_read_ll函数要能自动适应两种NAND Flash。

    参考S3C2440的数据手册可以知道:根据NFCONF寄存器的Bit3(AdvFlash (Read only))和Bit2 (PageSize (Read only))可以判断NAND Flash的类型。Bit2、Bit3与NAND Flash的block类型的关系如下表所示:

    表 2.4 NFCONF的Bit3、Bit2与NAND Flash的关系

    Bit2 Bit3

    0

    1

    0

    256 B/page

    512 B/page

    1

    1024 B/page

    2048 B/page

    由于的NAND Flash只有512B/page和2048 B/page这两种,因此根据NFCONF寄存器的Bit3即可区分这两种NAND Flash了。

    完整代码见board/samsung/mini2440/nand_read.c中的nand_read_ll函数,这里给出伪代码:

    int nand_read_ll(unsigned char *buf, unsigned long start_addr, int size)

    {

    //根据NFCONF寄存器的Bit3来区分2种NAND Flash

    if( NFCONF & 0x8 ) /* Bit是1,表示是2KB/page的NAND Flash */

    {

    读取2K block 的NAND Flash

    }

    else /* Bit是0,表示是512B/page的NAND Flash */

    {

    /

    读取512B block 的NAND Flash

    /

    }

    return 0;

    }

    (10)设置堆栈

    /* 设置堆栈*/

    stack_setup:

    ldr r0, _TEXT_BASE /* upper 128 KiB: relocated uboot */

    sub r0, r0, #CONFIG_SYS_MALLOC_LEN /* malloc area */

    sub r0, r0, #CONFIG_SYS_GBL_DATA_SIZE /* 跳过全局数据区 */

    #ifdef CONFIG_USE_IRQ

    sub r0, r0, #(CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ)

    #endif

    sub sp, r0, #12 /* leave 3 words for abort-stack */

    只要将sp指针指向一段没有被使用的内存就完成栈的设置了。根据上面的代码可以知道U-Boot内存使用情况了,如下图所示:

    图2.2 U-Boot内存使用情况

    (11)清除BSS段

    clear_bss:

    ldr r0, _bss_start /* BSS段开始地址,在u-boot.lds中指定*/

    ldr r1, _bss_end /* BSS段结束地址,在u-boot.lds中指定*/

    mov r2, #0x00000000

    clbss_l:str r2, [r0] /* 将bss段清零*/

    add r0, r0, #4

    cmp r0, r1

    ble clbss_l

    初始值为0,无初始值的全局变量,静态变量将自动被放在BSS段。应该将这些变量的初始值赋为0,否则这些变量的初始值将是一个随机的值,若有些程序直接使用这些没有初始化的变量将引起未知的后果。

    (12)跳转到第二阶段代码入口

    ldr pc, _start_armboot

    _start_armboot: .word start_armboot

    跳转到第二阶段代码入口start_armboot处。

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

    start_armboot函数在lib_arm/board.c中定义,是U-Boot第二阶段代码的入口。U-Boot启动第二阶段流程如下:

    图 2.3 U-Boot第二阶段执行流程

    在分析start_armboot函数前先来看看一些重要的数据结构:

    (1)gd_t结构体

    U-Boot使用了一个结构体gd_t来存储全局数据区的数据,这个结构体在include/asm-arm/global_data.h中定义如下:

    typedef struct global_data {

    bd_t *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;

    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)

    (2)bd_t结构体

    bd_t在include/asm-arm.u/u-boot.h中定义如下:

    typedef struct bd_info {

    int bi_baudrate; /*串口通讯波特率 */

    unsigned long bi_ip_addr; /* IP 地址*/

    struct environment_s *bi_env; /*环境变量开始地址 */

    ulong bi_arch_number; /* 开发板的机器码 */

    ulong bi_boot_params; /* 内核参数的开始地址 */

    struct /* RAM配置信息 */

    {

    ulong start;

    ulong size;

    }bi_dram[CONFIG_NR_DRAM_BANKS];

    } bd_t;

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

    (3)init_sequence数组

    U-Boot使用一个数组init_sequence来存储对于大多数开发板都要执行的初始化函数的函数指针。init_sequence数组中有较多的编译选项,去掉编译选项后init_sequence数组如下所示:

    typedef int (init_fnc_t) (void);

    init_fnc_t *init_sequence[] = {

    board_init, /*开发板相关的配置--board/samsung/mini2440/mini2440.c */

    timer_init, /* 时钟初始化-- cpu/arm920t/s3c24x0/timer.c */

    env_init, /*初始化环境变量--common/env_flash.c 或common/env_nand.c*/

    init_baudrate, /*初始化波特率-- lib_arm/board.c */

    serial_init, /* 串口初始化-- drivers/serial/serial_s3c24x0.c */

    console_init_f, /* 控制通讯台初始化阶段1-- common/console.c */

    display_banner, /*打印U-Boot版本、编译的时间-- gedit lib_arm/board.c */

    dram_init, /*配置可用的RAM-- board/samsung/mini2440/mini2440.c */

    display_dram_config, /* 显示RAM大小-- lib_arm/board.c */

    NULL,

    };

    其中的board_init函数在board/samsung/mini2440/mini2440.c中定义,该函数设置了MPLLCOM,UPLLCON,以及一些GPIO寄存器的值,还设置了U-Boot机器码和内核启动参数地址 :

    /* MINI2440开发板的机器码 */

    gd->bd->bi_arch_number = MACH_TYPE_MINI2440;

    /* 内核启动参数地址 */

    gd->bd->bi_boot_params = 0x30000100;

    其中的dram_init函数在board/samsung/mini2440/mini2440.c中定义如下:

    int dram_init (void)

    {

    /* 由于mini2440只有 */

    gd->bd->bi_dram[0].start = PHYS_SDRAM_1;

    gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;

    return 0;

    }

    mini2440使用2片32MB的SDRAM组成了64MB的内存,接在存储控制器的BANK6,地址空间是0x30000000~0x34000000。

    在include/configs/mini2440.h中PHYS_SDRAM_1和PHYS_SDRAM_1_SIZE 分别被定义为0x30000000和0x04000000(64M)。

    分析完上述的数据结构,下面来分析start_armboot函数:

    void start_armboot (void)

    {

    init_fnc_t **init_fnc_ptr;

    char *s;

    … …

    /*计算全局数据结构的地址gd */

    gd = (gd_t*)(_armboot_start - CONFIG_SYS_MALLOC_LEN - sizeof(gd_t));

    … …

    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;

    /* 逐个调用init_sequence数组中的初始化函数 */

    for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {

    if ((*init_fnc_ptr)() != 0) {

    hang ();

    }

    }

    /* armboot_start 在cpu/arm920t/start.S 中被初始化为u-boot.lds连接脚本中的_start */

    mem_malloc_init (_armboot_start - CONFIG_SYS_MALLOC_LEN,

    CONFIG_SYS_MALLOC_LEN);

    /* NOR Flash初始化 */

    #ifndef CONFIG_SYS_NO_FLASH

    /* configure available FLASH banks */

    display_flash_config (flash_init ());

    #endif /* CONFIG_SYS_NO_FLASH */

    … …

    /* NAND Flash 初始化*/

    #if defined(CONFIG_CMD_NAND)

    puts ("NAND: ");

    nand_init(); /* go init the NAND */

    #endif

    … …

    /*配置环境变量,重新定位 */

    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 */

    … …

    /*enable exceptions */

    enable_interrupts ();

    #ifdef CONFIG_USB_DEVICE

    usb_init_slave();

    #endif

    /* 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

    … …

    /*网卡初始化 */

    #if defined(CONFIG_CMD_NET)

    #if defined(CONFIG_NET_MULTI)

    puts ("Net: ");

    #endif

    eth_initialize(gd->bd);

    … …

    #endif

    /* 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 */

    }

    main_loop函数在common/main.c中定义。一般情况下,进入main_loop函数若干秒内没有

    1.1.3 U-Boot启动Linux过程

    U-Boot使用标记列表(tagged list)的方式向Linux传递参数。标记的数据结构式是tag,在U-Boot源代码目录include/asm-arm/setup.h中定义如下:

    struct tag_header {

    u32 size; /* 表示tag数据结构的联合u实质存放的数据的大小*/

    u32 tag; /* 表示标记的类型 */

    };

    struct tag {

    struct tag_header hdr;

    union {

    struct tag_core core;

    struct tag_mem32 mem;

    struct tag_videotext videotext;

    struct tag_ramdisk ramdisk;

    struct tag_initrd initrd;

    struct tag_serialnr serialnr;

    struct tag_revision revision;

    struct tag_videolfb videolfb;

    struct tag_cmdline cmdline;

    /*

    * Acorn specific

    */

    struct tag_acorn acorn;

    /*

    * DC21285 specific

    */

    struct tag_memclk memclk;

    } u;

    };

    U-Boot使用命令bootm来启动已经加载到内存中的内核。而bootm命令实际上调用的是do_bootm函数。对于Linux内核,do_bootm函数会调用do_bootm_linux函数来设置标记列表和启动内核。do_bootm_linux函数在lib_arm/bootm.c 中定义如下:

    59 int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images)

    60 {

    61 bd_t *bd = gd->bd;

    62 char *s;

    63 int machid = bd->bi_arch_number;

    64 void (*theKernel)(int zero, int arch, uint params);

    65

    66 #ifdef CONFIG_CMDLINE_TAG

    67 char *commandline = getenv ("bootargs"); /* U-Boot环境变量bootargs */

    68 #endif

    … …

    73 theKernel = (void (*)(int, int, uint))images->ep; /* 获取内核入口地址 */

    … …

    86 #if defined (CONFIG_SETUP_MEMORY_TAGS) || \

    87 defined (CONFIG_CMDLINE_TAG) || \

    88 defined (CONFIG_INITRD_TAG) || \

    89 defined (CONFIG_SERIAL_TAG) || \

    90 defined (CONFIG_REVISION_TAG) || \

    91 defined (CONFIG_LCD) || \

    92 defined (CONFIG_VFD)

    93 setup_start_tag (bd); /* 设置ATAG_CORE标志 */

    … …

    100 #ifdef CONFIG_SETUP_MEMORY_TAGS

    101 setup_memory_tags (bd); /* 设置内存标记 */

    102 #endif

    103 #ifdef CONFIG_CMDLINE_TAG

    104 setup_commandline_tag (bd, commandline); /* 设置命令行标记 */

    105 #endif

    … …

    113 setup_end_tag (bd); /* 设置ATAG_NONE标志 */

    114 #endif

    115

    116 /* we assume that the kernel is in place */

    117 printf ("\nStarting kernel ...\n\n");

    … …

    126 cleanup_before_linux (); /* 启动内核前对CPU作最后的设置 */

    127

    128 theKernel (0, machid, bd->bi_boot_params); /* 调用内核 */

    129 /* does not return */

    130

    131 return 1;

    132 }

    其中的setup_start_tag,setup_memory_tags,setup_end_tag函数在lib_arm/bootm.c中定义如下:

    (1)setup_start_tag函数

    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标记。

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

    }

    }

    setup_memory_tags函数设置了一个ATAG_MEM标记,该标记包含内存起始地址,内存大小这两个参数。

    (3)setup_end_tag函数

    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.中定义:

    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 ...

    */

    disable_interrupts (); /* 禁止FIQ/IRQ中断 */

    /*turn off I/D-cache */

    icache_disable(); /* 使指令Cache失效 */

    dcache_disable(); /* 使数据Cache失效 */

    /*flush I/D-cache */

    cache_flush(); /* 刷新Cache */

    return 0;

    }

    由于U-Boot启动以来就一直工作在SVC模式,因此CPU的工作模式就无需设置了。

    do_bootm_linux中:

    64 void (*theKernel)(int zero, int arch, uint params);

    … …

    73 theKernel = (void (*)(int, int, uint))images->ep;

    … …

    128 theKernel (0, machid, bd->bi_boot_params);

    第73行代码将内核的入口地址“images->ep”强制类型转换为函数指针。根据ATPCS规则,函数的参数个数不超过4个时,使用r0~r3这4个寄存器来传递参数。因此第128行的函数调用则会将0放入r0,机器码machid放入r1,内核参数地址bd->bi_boot_params放入r2,从而完成了寄存器的设置,最后转到内核的入口地址。

    到这里,U-Boot的工作就结束了,系统跳转到Linux内核代码执行。

    1.1.4 U-Boot添加命令的方法及U-Boot命令执行过程

    下面以添加menu命令(启动菜单)为例讲解U-Boot添加命令的方法。

    (1) 建立common/cmd_menu.c

    习惯上通用命令源代码放在common目录下,与开发板专有命令源代码则放在board/<board_dir>目录下,并且习惯以“cmd_<命令名>.c”为文件名。

    (2) 定义“menu”命令

    在cmd_menu.c中使用如下的代码定义“menu”命令:

    _BOOT_CMD(

    menu, 3, 0, do_menu,

    "menu- display a menu, to select the items to do something\n",

    "- display a menu, to select the items to do something"

    );

    其中U_BOOT_CMD命令格式如下:

    U_BOOT_CMD(name,maxargs,rep,cmd,usage,help)

    各个参数的意义如下:

    name:命令名,非字符串,但在U_BOOT_CMD中用“#”符号转化为字符串

    maxargs:命令的最大参数个数

    rep:是否自动重复(按Enter键是否会重复执行)

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

    usage:简短的使用说明(字符串)

    help:较详细的使用说明(字符串)

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

    U_BOOT_CMD宏在include/command.h中定义:

    #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}

    “##”与“#”都是预编译操作符,“##”有字符串连接的功能,“#”表示后面紧接着的是一个字符串。

    其中的cmd_tbl_t在include/command.h中定义如下:

    struct cmd_tbl_s {

    char *name; /* 命令名 */

    int maxargs; /* 最大参数个数 */

    int repeatable; /* 是否自动重复 */

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

    char *usage; /* 简短的帮助信息 */

    #ifdef CONFIG_SYS_LONGHELP

    char *help; /* 较详细的帮助信息 */

    #endif

    #ifdef CONFIG_AUTO_COMPLETE

    /*自动补全参数 */

    int (*complete)(int argc, char *argv[], char last_char, int maxv, char *cmdv[]);

    #endif

    };

    typedef struct cmd_tbl_s cmd_tbl_t;

    一个cmd_tbl_t结构体变量包含了调用一条命令的所需要的信息。

    其中Struct_Section在include/command.h中定义如下:

    #define Struct_Section __attribute__ ((unused,section (".u_boot_cmd")))

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

    在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之间查找就可以了。

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

    cmd_tbl_t __u_boot_cmd_menu __attribute__ ((unused,section (".u_boot_cmd"))) = {menu, 3, 0, do_menu, "menu- display a menu, to select the items to do something\n", " - display a menu, to select the items to do something"}

    实质上就是用U_BOOT_CMD宏定义的信息构造了一个cmd_tbl_t类型的结构体。编译器将该结构体放在“u_boot_cmd”段,执行命令时就可以在“u_boot_cmd”段查找到对应的cmd_tbl_t类型结构体。

    (3) 实现命令的函数

    在cmd_menu.c中添加“menu”命令的响应函数的实现。具体的实现代码略:

    int do_menu (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])

    {

    /*实现代码略 */

    }

    (4) 将common/cmd_menu.c编译进u-boot.bin

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

    COBJS-$(CONFIG_BOOT_MENU) += cmd_menu.o

    在include/configs/mini2440.h加入如代码:

    #define CONFIG_BOOT_MENU 1

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

    (5)menu命令执行的过程

    在U-Boot中输入“menu”命令执行时,U-Boot接收输入的字符串“menu”,传递给run_command函数。run_command函数调用common/command.c中实现的find_cmd函数在__u_boot_cmd_start与__u_boot_cmd_end间查找命令,并返回menu命令的cmd_tbl_t结构。然后run_command函数使用返回的cmd_tbl_t结构中的函数指针调用menu命令的响应函数do_menu,从而完成了命令的执行。

    展开全文
  • 一、uboot启动流程简介 与大多数BootLoader一样,uboot的启动过程分为BL1和BL2两个阶段。BL1阶段通常是开发板的配置等设备初始化代码,需要依赖依赖于SoC体系结构,通常用汇编语言来实现;BL2阶段主要是对外部设备...

     

    一、uboot启动流程简介

        与大多数BootLoader一样,uboot的启动过程分为BL1和BL2两个阶段。BL1阶段通常是开发板的配置等设备初始化代码,需要依赖依赖于SoC体系结构,通常用汇编语言来实现;BL2阶段主要是对外部设备如网卡、Flash等的初始化以及uboot命令集等的自身实现,通常用C语言来实现。

    1、BL1阶段

        uboot的BL1阶段代码通常放在start.s文件中,用汇编语言实现,其主要代码功能如下:

      (1) 指定uboot的入口。在链接脚本uboot.lds中指定uboot的入口为start.S中的_start。

      (2)设置异常向量(exception vector)

      (3)关闭IRQ、FIQ,设置SVC模式

      (4)关闭L1 cache、设置L2 cache、关闭MMU

      (5)根据OM引脚确定启动方式

      (6)在SoC内部SRAM中设置栈

      (7)lowlevel_init(主要初始化系统时钟、SDRAM初始化、串口初始化等)

      (8)设置开发板供电锁存

      (9)设置SDRAM中的栈

      (10)将uboot从SD卡拷贝到SDRAM中

      (11)设置并开启MMU

      (12)通过对SDRAM整体使用规划,在SDRAM中合适的地方设置栈

      (13)清除bss段,远跳转到start_armboot执行,BL1阶段执行完

    2、BL2阶段

        start_armboot函数位于lib_arm/board.c中,是C语言开始的函数,也是BL2阶段代码中C语言的主函数,同时还是整个u-boot(armboot)的主函数,BL2阶段的主要功能如下:

      (1)规划uboot的内存使用

      (2)遍历调用函数指针数组init_sequence中的初始化函数

      (3)初始化uboot的堆管理器mem_malloc_init

      (4)初始化SMDKV210开发板的SD/MMC控制器mmc_initialize

      (5)环境变量重定位env_relocate

      (6)将环境变量中网卡地址赋值给全局变量的开发板变量

      (7)开发板硬件设备的初始化devices_init

      (8)跳转表jumptable_init

      (9)控制台初始化console_init_r

      (10)网卡芯片初始化eth_initialize

      (11)uboot进入主循环main_loop

    二、uboot程序入口分析

    1、link.lds链接脚本文件分析

    u-boot.lds文件是uboot工程的链接脚本文件,位于board\samsung\smdkc110目录下,对于工程项目编译后期的链接阶段非常重要,决定了uboot程序的组装。

    u-boot.lds链接文件中的ENTRY(_start)指定了uboot程序的入口地址为_start。

    2、定位uboot程序入口地址

    在SourceInsight建立uboot工程,利用索引功能查找_start,在搜索结果中找到与三星smdkv210开发板相关的代码,最终锁定cpu\s5pc11x\start.S文件,定位到文件中的_start标识符。

    三、start.S文件分析

    1、头文件分析

    start.S有四个头文件:

    #include <config.h>

        config.h头文件在配置开发板时由mkconfig脚本创建的头文件,头文件内容即包含开发板的头文件:#include <configs/smdkv210single.h>

    #include <version.h>

        version.h头文件的内容为包含自动生成的版本头文件,头文件内容为:#include "version_autogenerated.h",version_autogenerated.h头文件定义了版本宏,宏定义为:#define U_BOOT_VERSION "U-Boot 1.3.4"。版本宏的值就是Makefile中定义的版本信息。

    #include <asm/proc/domain.h>

        domain.h头文件在定义了CONFIG_ENABLE_MMU宏时有效,为链接文件,实际指向的文件为include/asm-arm/proc-armv/domain.h。

    #include <regs.h>

    regs.h头文件为链接文件,指向s5pc110.h头文件,s5pc110.h文件内部使用宏定义了有关SoC内部寄存器的大量信息。

    2、头校验信息的占位

    #if defined(CONFIG_EVT1) && !defined(CONFIG_FUSED)

    .word 0x2000

    .word 0x0

    .word 0x0

    .word 0x0

    #endif

    定义uboot程序开头的16字节校验头信息填充空间,头校验信息块内的值需要在后面写入。

    3、异常向量表的构建

    .globl _start

    _start:

    b reset

    ldrpc, _undefined_instruction

    ldrpc, _software_interrupt

    ldrpc, _prefetch_abort

    ldrpc, _data_abort

    ldrpc, _not_used

    ldrpc, _irq

    ldrpc, _fiq

        uboot程序的入口点实际是定义了异常向量表,异常向量表由SoC硬件实现,因此uboot在开机上电复位时需要跳转到reset执行。

    4、复位reset分析

    SoC上电复位后运行的第一段代码就是reset。主要包括以下几部分:

    A、关闭IRQ、FIQ,并将处理器模式设置为SVC模式

    B、CPU关键寄存器的初始化cpu_init_crit:

        关闭L2 cache

        初始化L2 cache

        开启L2 cache

        关闭L1 cache

        关闭MMU

        读取OM启动引脚信息

        确定从启动设备SD卡启动

        设置SRAM中的栈为调用lowlevel_init做准备(lowlevel_init内部有嵌套调用)

        调用lowlevel_init(主要初始化系统时钟、SDRAM初始化、串口初始化等)

        设置开发板供电锁存

        设置SDRAM中的栈

        判断当前代码是否运行在SDRAM中,如果当前代码运行在SDRAM中,则跳过代码重定位。

        判断启动方式,选择SD卡启动设备,跳转到mmcsd_boot

        SD卡启动的准备工作,从SD卡拷贝uboot到SDRAM:movi_bl2_copy

     

    C、设置MMU,开启MMU

    D、通过对SDRAM整体使用规划,在SDRAM中合适的地方设置栈

    E、清除bss段,远跳转到start_armboot执行,BL1阶段执行完

    5、lowlevel_init分析

    lowlevel_init位于\board\samsung\smdkc110\lowlevel_init.S中,主要功能如下:

        A、检查复位状态,判断启动的方式

    根据复位状态选择复位启动的方式,处于低功耗状态时复位启动可以跳过后续多个步骤。

        B、IO状态恢复

        C、关闭看门狗

        D、外部SRAM的GPIO初始化、外部SROM初始化

        E、开发板供电锁存设置

        F、判断当前代码是否运行在SDRAM,如果当前代码运行在SDRAM,说明目前从低功耗状态复位,可以跳过系统时钟初始化、串口初始化、SDRAM初始化等

        G、初始化系统时钟:system_clock_init

        H、初始化SDRAM内存:mem_ctrl_asm_init

        I、初始化串口,打印出’O’:uart_asm_init

        J、初始化trustzone:tzpc_init

        K、初始化nand或onenand

        L、检查复位状态

        M、关闭ABB

        N、串口打印出‘K’

    说明:”OK”是打印出的调试信息,如果打印出’O’则说明在串口初始化uart_asm_init前的所有代码是正确的。如果打印出”OK”则说明在开发板板级初始化lowlevel_init前的所有代码是正常工作的。

    system_clock_init、uart_asm_init、tzpc_init、nand_asm_init都位于lowlevel_init.S文件内,mem_ctrl_asm_init位于cpu\s5pc11x\s5pc110\cpu_init.S文件中。

    四、board.c文件分析

    uboot在执行完BL1阶段后远跳转到start_armboot函数执行BL2,start_armboot函数位于lib_arm\board.c中。

    1、重要变量的说明

    typedef int (init_fnc_t) (void);函数类型

    init_fnc_t **init_fnc_ptr;//二级函数指针

    #define DECLARE_GLOBAL_DATA_PTR     register volatile gd_t *gd asm ("r8")

    DECLARE_GLOBAL_DATA_PTR定义了一个存储在寄存器r8中的指向gd_t类型全局变量的指针gd。

    全局变量结构体的定义:

    typedefstructglobal_data {

    bd_t*bd;//boardinfo结构体信息,存放和开发板有关的信息

    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;//fb基地址/* base address of frame buffer */

    #ifdef CONFIG_VFD

    unsigned charvfd_type;///* display type */

    #endif

    void**jt;//跳转表/* jump table */

    } gd_t;

    开发板信息结构体变量的定义:

    typedef struct bd_info {

        intbi_baudrate;//硬件串口波特率/* serial console baudrate */

        unsigned longbi_ip_addr;//开发板IP地址/* IP Address */

        unsigned charbi_enetaddr[6];//开发板网卡地址 /* Ethernet adress */

        struct environment_s       *bi_env;//环境变量指针

        ulong        bi_arch_number;//机器码/* unique id for this board */

        ulong        bi_boot_params;//uboot启动参数/* where this board expects params */

        struct/* RAM configuration */

        {

    ulong start;

    ulong size;

        }bi_dram[CONFIG_NR_DRAM_BANKS];//内存插条信息

    #ifdef CONFIG_HAS_ETH1

        /* second onboard ethernet port */

        unsigned char   bi_enet1addr[6];//第二块网卡的地址

    #endif

    } bd_t;

     

    2、uboot的内存规划

    wKioL1drRfTyRHOGAADgnjy9DiE579.jpg

        SDRAM_BASE被MMU映射在0xC0000000,CFG_UBOOT_BASE是0xC3E00000

        在BL1段运行时,uboot镜像被拷贝到CFG_UBOOT_BASE开始的地址处。

      gd的地址:

    gd_base = CFG_UBOOT_BASE + CFG_UBOOT_SIZE - CFG_MALLOC_LEN - CFG_STACK_SIZE - sizeof(gd_t);

      bd的地址:

    gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));

    3、start_armboot函数分析

        start_armboot函数的主要功能如下:

    (1)、遍历调用函数指针数组init_sequence中的初始化函数

    依次遍历调用函数指针数组init_sequence中的函数,如果有函数执行出错,则执行hang函数,打印出”### ERROR ### Please RESET the board ###”,进入死循环。

    (2)、初始化uboot的堆管理器mem_malloc_init

    (3)、初始化SMDKV210的SD/MMC控制器mmc_initialize

    (4)、环境变量重定位env_relocate

    (5)、将环境变量中网卡地址赋值给全局变量的开发板变量

    (6)、开发板硬件设备的初始化devices_init

    (7)、跳转表jumptable_init

    (8)、控制台初始化console_init_r

    (9)、网卡芯片初始化eth_initialize

    (10)、uboot进入主循环main_loop

    void start_armboot (void)
       {
       //全局数据变量指针gd占用r8。
       DECLARE_GLOBAL_DATA_PTR;       
       /* 给全局数据变量gd安排空间*/
       gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t));
       memset ((void*)gd, 0, sizeof (gd_t));
       /* 给板子数据变量gd->bd安排空间*/
       gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));
       memset (gd->bd, 0, sizeof (bd_t));
       monitor_flash_len = _bss_start - _armboot_start;//u-boot长度。       
       /* 顺序执行init_sequence数组中的初始化函数 */
       for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
           if ((*init_fnc_ptr)() != 0) {
               hang ();
                     }
              }
        /* 初始化堆空间 */
        mem_malloc_init (_armboot_start - CFG_MALLOC_LEN);
        /* 重新定位环境变量, */
         env_relocate ();
        /* 从环境变量中获取IP地址 */
        gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");
        /* 以太网接口MAC 地址 */
        devices_init ();      /* 设备初始化 */
        jumptable_init ();  //跳转表初始化
        console_init_r ();    /* 完整地初始化控制台设备 */
        enable_interrupts (); /* 使能中断处理 */
         /* 通过环境变量初始化 */
         if ((s = getenv ("loadaddr")) != NULL) {
            load_addr = simple_strtoul (s, NULL, 16);
         }
         /* main_loop()循环不断执行 */
         for (;;) {
             main_loop ();      /* 主循环函数处理执行用户命令 -- common/main.c */
              }
       }

    4、函数指针数组init_sequence

    函数指针数组init_sequence:

    init_fnc_t *init_sequence[] = {

    cpu_init,//CPU架构的初始化,为空cpu\s5pc11x\cpu.c

    board_init,//开发板初始化board\samsung\smdkc110\smdkc110.c

    interrupt_init,//定时器timer4初始化cpu\s5pc11x\interrupts.c

    env_init,//环境变量初始化common\env_movi.c

    init_baudrate,//波特率设置lib_arm\board.c

    serial_init,//延时函数C,没有再次初始化串口cpu\s5pc11x\serial.c

    console_init_f,//控制台第一阶段初始化,控制台未初始化好common\console.c

    display_banner,//用串口发送uboot版本信息lib_arm\board.c

    #if defined(CONFIG_DISPLAY_CPUINFO)

    print_cpuinfo,//串口打印系统时钟信息cpu\s5pc11x\s5pc110\speed.c

    #endif

    #if defined(CONFIG_DISPLAY_BOARDINFO)

    checkboard,//打印开发板信Board:SMDKV210

    //board\samsung\smdkc110\smdkc110.c

    #endif

    #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)

    init_func_i2c,//SMDKV210未定义I2C,函数为空lib_arm\board.c

    #endif

    dram_init,//初始化gd->bd->bi_dram,开发板的SDRAM配置信息

    board\samsung\smdkc110\smdkc110.c 

       display_dram_config,//串口打印出DRAM的大小信息,DRAM:xxxMB

    lib_arm\board.c

    NULL,

    };

    board_init函数:

    dm9000_pre_init();//网卡初始化,GPIO和端口设置

    gd->bd->bi_arch_number = MACH_TYPE;//开发板的机器码,uboot的机器码和linux的机器码之间必须适配

    gd->bd->bi_boot_params = (PHYS_SDRAM_1+0x100);//uboot给内核的传参地址

    display_banner函数:

    打印uboot版本信息:uboot-1.3.4

    print_cpuinfo函数:

    打印CPU时钟系统的时钟信息

    checkboard函数:

    打印出开发板信息Board:   SMDKV210

    display_dram_config函数:

    打印出DRAM的大小信息,DRAM:xxxMB

    打印出的信息可以作为调试使用,依次遍历调用函数指针数组init_sequence中的函数,如果有函数执行出错,则执行hang函数,打印出”### ERROR ### Please RESET the board ###”,进入死循环。

    转载于:https://www.cnblogs.com/cyyljw/p/10998066.html

    展开全文
  • Uboot启动过程详解

    2018-03-26 20:26:52
    U-Boot 启动内核的过程可以分为两个阶段,两个阶段的功能如下: (1)第一阶段的功能 硬件设备初始化 加载 U-Boot 第二阶段代码到 RAM 空间 设置好栈 跳转到第二阶段代码入口 (2)第二阶段的功能 初始...

    U-Boot 启动内核的过程可以分为两个阶段,两个阶段的功能如下:

    (1)第一阶段的功能
    硬件设备初始化
    加载 U-Boot 第二阶段代码到 RAM 空间
    设置好栈
    跳转到第二阶段代码入口
    (2)第二阶段的功能
    初始化本阶段使用的硬件设备
    检测系统内存映射
    将内核从 Flash 读取到 RAM 中
    为内核设置启动参数
    调用内核

    展开全文
  • 一、start.S cpu/s5pc11x/start.S 1、入口: .globl _start _start: b reset ldr pc, _undefined_instruction ldr pc, _software_interrupt ldr pc, _prefetch_abort ldr pc, _data_abort ldr pc, _not_used
  • 深入理解uboot (处理器启动流程分析)

    万次阅读 多人点赞 2018-05-15 10:32:42
    转载:https://blog.csdn.net/kernel_yx/article/details/53045424最近一段时间一直在做uboot移植相关的工作,...之前在学习uboot时,在网上看了很多文章,很多都是基于老版本的的uboot,并且很多都是直接从代码...
  • 03. Uboot启动流程详解

    千次阅读 2018-07-02 08:08:27
    1. start.S解析 1)uboot入口分析 要分析uboot的流程首先要找到uboot的入口函数,从x210开发板的链接器脚本可以获得该信息 根据ENTRY(_start)可知,uboot的入口函数为start;再根据.text段的链接顺序,可知start函数...
  • uboot启动linux的过程

    千次阅读 2018-09-19 17:05:58
      ...  一、概述  linux内核镜像常见到的有两种形式,zImage和uImage。这两种文件的格式稍有差别,所以...目前,uboot只支持启动uImage类型的镜像,对zImage还不支持(但是可以移植,TQ2440就是这样做的)。 二...
  • 开发板提供的bootloader为uboot,每次都是按照文档进行操作,对uboot 的操作命令也是一知半解,现决定去理清清绪,写一篇有关uboot烧录linux内核和文件系统的详细说明。 1 设置开发板IP和tftp服务器IP ...
  • UBOOT启动内核过程

    2017-02-16 22:46:00
    (1)、启动4步骤第一步:将内核搬移到DDR中第二步:校验内核格式、CRC等第三步:准备传参第四步:跳转执行内核(2)、涉及到的主要函数是:do_bootm和do_bootm_linux(3)、uboot启动的内核格式:zImage uImage ...
  • 深入理解uboot 2016 - 基础篇(处理器启动流程分析)

    万次阅读 多人点赞 2016-11-05 14:52:35
    最近一段时间一直在做uboot相关的移植的工作,需要将uboot-2016-7移植到ARMv7的处理器上。正好元旦放假三天闲来无事,有段完整的时间来整理下最近的工作成果。之前在学习uboot时,在网上看了很多文章,很多都是基于...
  • uboot启动流程如下: 1)设置CPU为管理模式 2)关看门狗 3)关中断 4)设置时钟频率 5)关mmu,初始化各个bank 6)进入board_init_f()函数(初始化定时器,GPIO,串口等,划分内存区域) 7)重定位 复制uboot,然后修改...
  • U-BOOT移植过程详解: UBOOT启动过程

    千次阅读 2014-01-17 22:06:32
     本着学习交流的原则, 将个人移植u-boot的过程做一个记录. 文章参考了csdn blog里面的很多内容, 有的已经记不得出处了, 只好把当时的摘要直接贴出来. 如果冒犯, 还请见谅. 如有侵权, 请与我邮件联系. 谢谢! 先占...
  • 在开发altera soc cyclone v以及其它的soc时,我们需要先使用quartus 及其它组件qsys构建工程,然后soceds根据生成硬件配置文件handoff,生成uboot的头文件及相关配置,最后编译成我们需要的preloader及其及uboot。...
  • uboot配置和编译过程详解

    万次阅读 2016-12-03 14:27:05
    ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼分享一个大神朋友的人工智能教程。零基础!通俗易懂!风趣幽默!还带黄段子!...
  • uboot启动流程详解(2)-reset

    千次阅读 2016-11-12 18:58:01
    1、cpsr寄存器介绍  通过向模式位M[4:0]里写入相应的数据切换到不同的模式,在对CPSR,SPSR寄存器进行操作不能使用mov,ldr等通用指令,只能使用特权指令msr和mrs。  在ARM处理器中,只有MRS(Move to ...
  • 2018/08/12 21:39 有道云地址:...amp;amp;amp;amp;sub=612AF77E36994945B6638F4B884E286C 太大了,这里就不高亮各处关键点了,详细查看有道云笔记。 ...一.VMware NAT方式 Ubuntu 14.04 联网 ...(转ht...
  • 0 目录 1 简介 1.1 uboot是什么? 1.2 存储器 ...3 uboot启动流程第1阶段 3.1 start.S文件分析 3.2 lowlevel_init.S文件分析 4 uboot启动流程第2阶段 4.1 初始化 4.2 加载内核 A 参考资料 ...
  • uboot配置过程详解

    2018-04-28 15:09:56
    当我们在编译uboot的时候,要分为两个阶段,一个阶段是配置,配置用的命令是 make x210_sd_...在这一篇文章中,我将单独详细分析uboot的配置过程。 1、主Makefile中配置相关部分 首先,目光转向主Makefile,在2...
  • HiTool工具烧录Uboot过程简介

    万次阅读 2018-09-18 19:03:07
    1. 烧录Uboot  2. 烧录过程,需要注意的是,烧录过程中要防止其他软件占用串口,比如CRT。
  • uboot如何启动内核

    千次阅读 2018-09-12 18:00:02
    一、uboot和内核到底是什么 1.uboot和内核就是一个裸机程序 (1)uboot的本质就是就是一个复杂点的裸机程序,和ARM部分写的裸机程序没有本质区别。 (2)内核本身也是一个裸机程序,和uboot、裸机程序无本质区别...

空空如也

1 2 3 4 5 ... 20
收藏数 16,079
精华内容 6,431
关键字:

uboot的过程