U-BOOT分析之：环境变量

（环境如下：U-BOOT S3C2440 LINUX）记录自己的学习过程，如果分析有问题，请帮忙指正。

最近在研究U-BOOT的代码，其中的环境变量个人觉得用处非常大，所以重点学习和分析一下。

U-BOOT的第一个执行的文件为start.S，可以从链接文件分析出来（u-boot.lds）

进入U-BOOT执行过程如下：

1、设置CPU进入SVC32模式（set the cpu to SVC32 mode）

2、关看门狗（turn off the watchdog ）

3、关中断（mask all IRQs by setting all bits in the INTMR - default）

4、比较_start和_TEXT_BASE（链接脚本里面定义代码的运行地址TEXT_BASE = 0x33F80000），判断如果不是仿真启动，则执行cpu_init_crit

注：如果代码是烧录到板子则_start地址没有调整前是0，如果是仿真器则直接下载到RAM，这会下载到链接地址上，即TEXT_BASE

5、cpu_init_crit执行如下（flush v4 I/D caches，disable MMU stuff and caches，setup RAM timing），即关mmu，设置存储管理器（lowlevel_init）

注：设置完存储管理器后SDRAM NANDFLASH 等外围设备才能使用

6、规划内存空间，并且设置栈（自己规划空间的分配如下：CFG_MALLOC_LEN，CFG_GBL_DATA_SIZE，CONFIG_STACKSIZE_IRQ，CONFIG_STACKSIZE_FIQ，12）

7、设置时钟 clock_init（）

8、拷贝代码到SDRAM CopyCode2Ram（）

注，r0 r1 r2分别为CopyCode2Ram的三个参数，即起始地址，目的地址，拷贝的长度（同样，如果是仿真器则跳过这段代码）

9、清除bss段（把未初始化的全部变量和则静态变量初始化为0）

10、设置PreLoadedONRAM标志位，方便后面判断是否是debug模式

11、获取start_armboot的链接地址，并且跳转到start_armboot，此时跳转到SDRAM中执行

12、start_armboot函数首先给两个结构体分配空间,并且设置结构体成员值为0

　　注：gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t)); gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));

13、接下来执行各种初始化，即init_sequence指针数组里面的各个初始化函数，其中env_init即环境变量初始化

环境变量分析：

1、进入env_init()函数

 init_fnc_t *init_sequence[] = {

     cpu_init,        /* basic cpu dependent setup */

     board_init,        /* basic board dependent setup */

     interrupt_init,        /* set up exceptions */

     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

     dram_init,        /* configure available RAM banks */

     display_dram_config,

     NULL,

 };

     for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {   //循环执行上面结构体的内容，其中就有调用到env_init()

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

             hang ();

         }

     }

2、那么程序进入Env_nand.c执行

 int env_init(void)

 {

 #if defined(ENV_IS_EMBEDDED)   //搜寻代码 发现ENV_IS_EMBEDDED没有定义，所以执行#else部分

     ulong total;

     int crc1_ok = , crc2_ok = ;

     env_t *tmp_env1, *tmp_env2;

     total = CFG_ENV_SIZE;

     tmp_env1 = env_ptr;

     tmp_env2 = (env_t *)((ulong)env_ptr + CFG_ENV_SIZE);

     crc1_ok = (crc32(, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);

     crc2_ok = (crc32(, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);

     if (!crc1_ok && !crc2_ok)

         gd->env_valid = ;

     else if(crc1_ok && !crc2_ok)

         gd->env_valid = ;

     else if(!crc1_ok && crc2_ok)

         gd->env_valid = ;

     else {

         /* both ok - check serial */

         if(tmp_env1->flags ==  && tmp_env2->flags == )

             gd->env_valid = ;

         else if(tmp_env2->flags ==  && tmp_env1->flags == )

             gd->env_valid = ;

         else if(tmp_env1->flags > tmp_env2->flags)

             gd->env_valid = ;

         else if(tmp_env2->flags > tmp_env1->flags)

             gd->env_valid = ;

         else /* flags are equal - almost impossible */

             gd->env_valid = ;

     }

     if (gd->env_valid == )

         env_ptr = tmp_env1;

     else if (gd->env_valid == )

         env_ptr = tmp_env2;

 #else /* ENV_IS_EMBEDDED */    //执行此处

     gd->env_addr  = (ulong)&default_environment[];    //获取默认的环境变量数组的地址

     gd->env_valid = ;                                 //环境变量准备好标准位，=1表示准备OK

 #endif /* ENV_IS_EMBEDDED */

     return ();

 }

3、继续往下分析发现和环境变量有关的函数，env_relocate ();

 void env_relocate (void)

 {

     DEBUGF ("%s[%d] offset = 0x%lx\n", __FUNCTION__,__LINE__,

         gd->reloc_off);

 #ifdef CONFIG_AMIGAONEG3SE      //未定于，不执行

     enable_nvram();

 #endif

 #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);   //给环境变量分配地址

     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_get_char指向env_get_char_memory函数（这个函数执行返回对应便宜量的实际地址）

     if (gd->env_valid == ) {                   //gd->env_valid = 1，执行else

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

 #endif

         if (sizeof(default_environment) > ENV_SIZE)

         {

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

             return;

         }

         memset (env_ptr, , sizeof(env_t));

         memcpy (env_ptr->data,

             default_environment,

             sizeof(default_environment));

 #ifdef CFG_REDUNDAND_ENVIRONMENT

         env_ptr->flags = 0xFF;

 #endif

         env_crc_update ();

         gd->env_valid = ;

     }

     else {

         env_relocate_spec ();    //执行此处

     }

     gd->env_addr = (ulong)&(env_ptr->data);   

 #ifdef CONFIG_AMIGAONEG3SE

     disable_nvram();

 #endif

 }

4、跳去env_relocate_spec();

 void env_relocate_spec (void)

 {

 #if !defined(ENV_IS_EMBEDDED)

     ulong total = CFG_ENV_SIZE;

     int ret;

     ret = nand_read(&nand_info[], CFG_ENV_OFFSET, &total, (u_char*)env_ptr);  //将nandlflash里面的环境变量，拷贝到env_ptr指向的内存

       if (ret || total != CFG_ENV_SIZE)

         return use_default();

     if (crc32(, env_ptr->data, ENV_SIZE) != env_ptr->crc)

         return use_default();

 #endif /* ! ENV_IS_EMBEDDED */

 }

如果没有执行过save，即没有把环境变量保存到nandflash。则执行use_default();使用默认的default_environment[]环境变量

5、跳出env_relocate_spec();

gd->env_addr = (ulong)&(env_ptr->data); //跳转地址，指向当前使用的环境变量数据

6、至此环境变量的准备工作已经完成。后面就可以正常使用了。例如s = getenv ("bootdelay");

7、getenv("bootdelay")函数会提取环境变量的指令(每条指令之间以（"\0"结尾）)，并且与传入的名字对比，如果相同则返回=后面的数据的地址，此数据即可拿来各种使用了

 char *getenv (char *name)

 {

     int i, nxt;

     WATCHDOG_RESET();

     for (i=; env_get_char(i) != '\0'; i=nxt+) {      //循环提取字符串，与传入名字比较是否匹配

         int val;

         for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) { //提取一条完整的字符，使i=下一条字符的起始位置

             if (nxt >= CFG_ENV_SIZE) {

                 return (NULL);

             }

         }

         if ((val=envmatch((uchar *)name, i)) < )   //比较函数传入参数name与提取到数据比较，如果匹配，则返回名字后面的数据的偏移量

             continue;

         return ((char *)env_get_addr(val));       //将偏移量转换为实际的地址，并且返回地址，此地址就可以拿来使用了

     }

     return (NULL);

 }

8、执行save指令，可以调用int do_saveenv (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])函数：

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

 {

     extern char * env_name_spec;

     printf ("Saving Environment to %s...\n", env_name_spec);   //打印

     return (saveenv() ?  : );  //跳转到下面的函数继续执行

 }

 int saveenv(void)

 {

     ulong total;

     int ret = ;

     puts ("Erasing Nand...");    //打印

     if (nand_erase(&nand_info[], CFG_ENV_OFFSET, CFG_ENV_SIZE))    //擦除nandflash中的环境变量

         return ;

     puts ("Writing to Nand... ");      //打印

     total = CFG_ENV_SIZE;

     ret = nand_write(&nand_info[], CFG_ENV_OFFSET, &total, (u_char*)env_ptr);    //将当前环境变量的值写入到nandflash

     if (ret || total != CFG_ENV_SIZE)

         return ;

     puts ("done\n");

     return ret;

 }

从上面分析，我们可以设置各种环境变量的各种参数，在u-boot需要使用的地方调用他们，使用非常方便。并且需要永久保存的直接写入nandflash。

秒客网

U-BOOT分析之：环境变量

相关文章