Uboot源码阅读笔记 4

最新推荐文章于 2023-10-11 11:33:26 发布
最新推荐文章于 2023-10-11 11:33:26 发布
阅读量2.8k 收藏 7
点赞数
分类专栏： uboot 文章标签： header image linux compression linux内核 application
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BoySKung/article/details/3194259
版权

引导加载内核
 
Common/main.c  main_loop()
Common/cmd_bootm.c  do_bootm()
Lib_arm/armlinux.c   do_bootm_linux()
 
在uboot的stage2的最后阶段，进入main_loop()函数。在这个函数中首先检查是否有启动延时，然后决定是自动加载内核映像来启动内核还是通过命令行来启动内核：
 
       s = getenv ("bootdelay");
       bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
上面两行是获得延时时长
 
              s = getenv ("bootcmd");
这行代码是获得启动命令行，这个环境变量的定义是
Bootcmd = "cp 0x200000 0x32000000 0x100000;bootm"
 
这个在配置头文件include/configs/s3c2410.h中也有定义
#define CONFIG_BOOTCOMMAND                      "cp 0x200000 0x32000000 0x100000;bootm"
 
因内核映像在flash的0x200000地址处，所以这里先把内核映像复制到sdram的32000000地址处，然后运行bootm启动。Bootm这个命令将在后面提到
 
判断延时是否结束，若延时已结束，则运行上面所获得的命令
       if (bootdelay >= 0 && s && ! abortboot (bootdelay)) {
# ifdef CONFIG_AUTOBOOT_KEYED
              int prev = disable_ctrlc(1);    /* disable Control C checking */
# endif
 
# ifndef CFG_HUSH_PARSER
//运行启动命令
              run_command (s, 0);
# else
              parse_string_outer(s, FLAG_PARSE_SEMICOLON |
                                FLAG_EXIT_FROM_LOOP);
# endif
 
# ifdef CONFIG_AUTOBOOT_KEYED
              disable_ctrlc(prev); /* restore Control C checking */
# endif
       }
 
若延时期间按了某个键，即上面粗体字函数 abortboot (bootdelay) 返回1，则进入命令行模式，这时可以通过网络加载内核映像到sdram中：
Tftpboot 32000000 uImage
然后运行bootm启动
 
或者从flash中拷贝
Cp 200000 32000000 size
然后运行bootm启动。
 
不管是自动加载，还是在命令行下加载，最后都是把内核映像加载到sdram中，再运行bootm命令启动。下面就说说bootm这个命令。
 
在cmd_bootm.c中声明并实现了bootm命令
U_BOOT_CMD(
      bootm,    CFG_MAXARGS,  1,    do_bootm,
      "bootm   - boot application image from memory/n",
      "[addr [arg ...]]/n    - boot application image stored in memory/n"
      "        passing arguments 'arg ...'; when booting a Linux kernel,/n"
      "        'arg' can be the address of an initrd image/n"
);
若对uboot命令不熟悉可参看http://blog.csdn.net/BoySKung/archive/2008/10/29/3176668.aspx。
 
其实现函数为do_bootm()
 
image_header_t header; //存放映像头信息的数据结构
 
//在include/configs/s3c2410.h中，CFG_LOAD_ADDR=32000000,即内核映像加载在这个地址处
ulong load_addr = CFG_LOAD_ADDR;              /* Default Load Address */
 
int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
       ulong      iflag;
       ulong      addr;
       ulong      data, len, checksum;
       ulong  *len_ptr;
       uint  unc_len = 0x400000;
       int    i, verify;
       char *name, *s;
       int    (*appl)(int, char *[]);
       image_header_t *hdr = &header;
 
       //确定是否进行校验
       s = getenv ("verify");
       //verify = 1时进行校验
       verify = (s && (*s == 'n')) ? 0 : 1;
 
       if (argc < 2) {
              addr = load_addr; //获得内核映像的起始地址 32000000
       } else {
              addr = simple_strtoul(argv[1], NULL, 16);
       }
 
       SHOW_BOOT_PROGRESS (1);
       printf ("## Booting image at %08lx .../n", addr);
 
       /* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
       if (addr_dataflash(addr)){
              read_dataflash(addr, sizeof(image_header_t), (char *)&header);
       } else
#endif
//将映像头部信息存储在image_header_t 型的变量header中，
       memmove (&header, (char *)addr, sizeof(image_header_t));
 
//     printf("header=%x %x %x %x %x %x %x/n", header.ih_magic, header.ih_hcrc, header.ih_time, header.ih_size, header.ih_load, header.ih_ep, header.ih_dcrc);
//   printf("header=%x %x %x %x %s/n", header.ih_os, header.ih_arch, header.ih_type, header.ih_comp, header.ih_name);
 
// image_header_t 结构定义如下
//typedef struct image_header {
//     uint32_t   ih_magic;       /* Image Header Magic Number    */
//     uint32_t   ih_hcrc;  /* Image Header CRC Checksum  */
//     uint32_t   ih_time;   /* Image Creation Timestamp       */
//     uint32_t   ih_size;    /* Image Data Size        */
//     uint32_t   ih_load;   /* Data    Load  Address           */
//     uint32_t   ih_ep;             /* Entry Point Address          */
//     uint32_t   ih_dcrc;  /* Image Data CRC Checksum     */
//     uint8_t           ih_os;             /* Operating System             */
//     uint8_t           ih_arch;   /* CPU architecture              */
//     uint8_t           ih_type;   /* Image Type               */
//     uint8_t           ih_comp; /* Compression Type            */
//     uint8_t           ih_name[IH_NMLEN];   /* Image Name             */
//} image_header_t;
 
       if (ntohl(hdr->ih_magic) != IH_MAGIC) {
#ifdef __I386__     /* correct image format not implemented yet - fake it */
              if (fake_header(hdr, (void*)addr, -1) != NULL) {
                     /* to compensate for the addition below */
                     addr -= sizeof(image_header_t);
                     /* turnof verify,
                      * fake_header() does not fake the data crc
                      */
                     verify = 0;
              } else
#endif     /* __I386__ */
           {
              printf ("Bad Magic Number/n");
              SHOW_BOOT_PROGRESS (-1);
              return 1;
           }
       }
       SHOW_BOOT_PROGRESS (2);
 
//获得内核映像头部的起始地址
       data = (ulong)&header;
//头部大小
       len  = sizeof(image_header_t);
 
//内核映像的crc校验码
       checksum = ntohl(hdr->ih_hcrc);
       hdr->ih_hcrc = 0;
//检测校验码
       if (crc32 (0, (char *)data, len) != checksum) {
              printf ("Bad Header Checksum/n");
              SHOW_BOOT_PROGRESS (-2);
              return 1;
       }
       SHOW_BOOT_PROGRESS (3);
//打印内核映像头部信息
       /* for multi-file images we need the data part, too */
       print_image_hdr ((image_header_t *)addr);
 
//获得映像数据起始地址（除支内核映像头部）
       data = addr + sizeof(image_header_t);
//映像数据的大小（除头部）
       len  = ntohl(hdr->ih_size);
 
#ifdef CONFIG_HAS_DATAFLASH
       if (addr_dataflash(addr)){
              read_dataflash(data, len, (char *)CFG_LOAD_ADDR);
              data = CFG_LOAD_ADDR;
       }
#endif
 
//若verify = 1 进行校验
       if (verify) {
              printf ("   Verifying Checksum ... ");
              if (crc32 (0l, (volatile char *)data, len) != ntohl(hdr->ih_dcrc)) {
                     printf ("Bad Data CRC/n");
                     SHOW_BOOT_PROGRESS (-3);
                     return 1;
              }
              printf ("OK/n");
       }
       SHOW_BOOT_PROGRESS (4);
 
//映像数据的起始地址（除头部）
       len_ptr = (ulong *)data;
//查看头部信息，体系结构与配置的是否一致
#if defined(__PPC__)
       if (hdr->ih_arch != IH_CPU_PPC)
#elif defined(__ARM__)
       if (hdr->ih_arch != IH_CPU_ARM)
#elif defined(__I386__)
       if (hdr->ih_arch != IH_CPU_I386)
#elif defined(__mips__)
       if (hdr->ih_arch != IH_CPU_MIPS)
#elif defined(__nios__)
       if (hdr->ih_arch != IH_CPU_NIOS)
#elif defined(__M68K__)
       if (hdr->ih_arch != IH_CPU_M68K)
#else
# error Unknown CPU type
#endif
       {
              printf ("Unsupported Architecture 0x%x/n", hdr->ih_arch);
              SHOW_BOOT_PROGRESS (-4);
              return 1;
       }
       SHOW_BOOT_PROGRESS (5);
 
//检测映像类型
       switch (hdr->ih_type) {
       case IH_TYPE_STANDALONE:
              name = "Standalone Application";
              /* A second argument overwrites the load address */
              if (argc > 2) {
                     hdr->ih_load = simple_strtoul(argv[2], NULL, 16);
              }
              break;
       case IH_TYPE_KERNEL:
              name = "Kernel Image";
              break;
       case IH_TYPE_MULTI:
              name = "Multi-File Image";
              len  = ntohl(len_ptr[0]);
              /* OS kernel is always the first image */
              data += 8; /* kernel_len + terminator */
              for (i=1; len_ptr[i]; ++i)
                     data += 4;
              break;
       default: printf ("Wrong Image Type for %s command/n", cmdtp->name);
              SHOW_BOOT_PROGRESS (-5);
              return 1;
       }
       SHOW_BOOT_PROGRESS (6);
 
       /*
        * We have reached the point of no return: we are going to
        * overwrite all exception vector code, so we cannot easily
        * recover from any failures any more...
        */
       iflag = disable_interrupts();
 
#ifdef CONFIG_AMIGAONEG3SE
       /*
        * We've possible left the caches enabled during
        * bios emulation, so turn them off again
        */
       icache_disable();
       invalidate_l1_instruction_cache();
       flush_data_cache();
       dcache_disable();
#endif
 
//检测映像的压缩类型，用相应工具解压缩
       switch (hdr->ih_comp) {
       case IH_COMP_NONE:
              if(ntohl(hdr->ih_load) == addr) {
                     printf ("   XIP %s ... ", name);
              } else {
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
                     size_t l = len;
                     void *to = (void *)ntohl(hdr->ih_load);
                     void *from = (void *)data;
 
                     printf ("   Loading %s ... ", name);
 
                     while (l > 0) {
                            size_t tail = (l > CHUNKSZ) ? CHUNKSZ : l;
                            WATCHDOG_RESET();
                            memmove (to, from, tail);
                            to += tail;
                            from += tail;
                            l -= tail;
                     }
#else       /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
                     memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
#endif     /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
              }
              break;
       case IH_COMP_GZIP:
              printf ("   Uncompressing %s ... ", name);
              if (gunzip ((void *)ntohl(hdr->ih_load), unc_len,
                         (uchar *)data, (int *)&len) != 0) {
                     printf ("GUNZIP ERROR - must RESET board to recover/n");
                     SHOW_BOOT_PROGRESS (-6);
                     do_reset (cmdtp, flag, argc, argv);
              }
              break;
#ifdef CONFIG_BZIP2
       case IH_COMP_BZIP2:
              printf ("   Uncompressing %s ... ", name);
              /*
               * If we've got less than 4 MB of malloc() space,
               * use slower decompression algorithm which requires
               * at most 2300 KB of memory.
               */
              i = BZ2_bzBuffToBuffDecompress ((char*)ntohl(hdr->ih_load),
                                          &unc_len, (char *)data, len,
                                          CFG_MALLOC_LEN < (4096 * 1024), 0);
              if (i != BZ_OK) {
                     printf ("BUNZIP2 ERROR %d - must RESET board to recover/n", i);
                     SHOW_BOOT_PROGRESS (-6);
                     udelay(100000);
                     do_reset (cmdtp, flag, argc, argv);
              }
              break;
#endif /* CONFIG_BZIP2 */
       default:
              if (iflag)
                     enable_interrupts();
              printf ("Unimplemented compression type %d/n", hdr->ih_comp);
              SHOW_BOOT_PROGRESS (-7);
              return 1;
       }
       printf ("OK/n");
       SHOW_BOOT_PROGRESS (7);
 
//根据映像压缩类型进行相应设置
       switch (hdr->ih_type) {
       case IH_TYPE_STANDALONE:
              if (iflag)
                     enable_interrupts();
 
              /* load (and uncompress), but don't start if "autostart"
               * is set to "no"
               */
              if (((s = getenv("autostart")) != NULL) && (strcmp(s,"no") == 0)) {
                     char buf[32];
                     sprintf(buf, "%lX", len);
                     setenv("filesize", buf);
                     return 0;
              }
              appl = (int (*)(int, char *[]))ntohl(hdr->ih_ep);
              (*appl)(argc-1, &argv[1]);
              return 0;
       case IH_TYPE_KERNEL:
       case IH_TYPE_MULTI:
              /* handled below */
              break;
       default:
              if (iflag)
                     enable_interrupts();
              printf ("Can't boot image type %d/n", hdr->ih_type);
              SHOW_BOOT_PROGRESS (-8);
              return 1;
       }
       SHOW_BOOT_PROGRESS (8);
 
//检测映像是什么操作系统
       switch (hdr->ih_os) {
       default:                  /* handled by (original) Linux case */
       case IH_OS_LINUX:   //为linux，则执行do_bootm_linux，启动linux内核
#ifdef CONFIG_SILENT_CONSOLE
           fixup_silent_linux();
#endif
           do_bootm_linux  (cmdtp, flag, argc, argv,
                          addr, len_ptr, verify);
           break;
       case IH_OS_NETBSD:
           do_bootm_netbsd (cmdtp, flag, argc, argv,
                          addr, len_ptr, verify);
           break;
 
#ifdef CONFIG_LYNXKDI
       case IH_OS_LYNXOS:
           do_bootm_lynxkdi (cmdtp, flag, argc, argv,
                          addr, len_ptr, verify);
           break;
#endif
 
       case IH_OS_RTEMS:
           do_bootm_rtems (cmdtp, flag, argc, argv,
                          addr, len_ptr, verify);
           break;
 
#if (CONFIG_COMMANDS & CFG_CMD_ELF)
       case IH_OS_VXWORKS:
           do_bootm_vxworks (cmdtp, flag, argc, argv,
                           addr, len_ptr, verify);
           break;
       case IH_OS_QNX:
           do_bootm_qnxelf (cmdtp, flag, argc, argv,
                           addr, len_ptr, verify);
           break;
#endif /* CFG_CMD_ELF */
#ifdef CONFIG_ARTOS
       case IH_OS_ARTOS:
           do_bootm_artos  (cmdtp, flag, argc, argv,
                          addr, len_ptr, verify);
           break;
#endif
       }
 
       SHOW_BOOT_PROGRESS (-9);
#ifdef DEBUG
       printf ("/n## Control returned to monitor - resetting.../n");
       do_reset (cmdtp, flag, argc, argv);
#endif
       return 1;
}
 
当根据头信息检测到是linux内核映像是，执行do_bootm_linux启动内核 lib_arm/armlinux.c
 
void do_bootm_linux (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
                   ulong addr, ulong *len_ptr, int verify)
{
       DECLARE_GLOBAL_DATA_PTR;
 
       ulong len = 0, checksum;
       ulong initrd_start, initrd_end;
       ulong data;
       void (*theKernel)(int zero, int arch, uint params);
       image_header_t *hdr = &header;
       bd_t *bd = gd->bd;
 
//获得命令行
#ifdef CONFIG_CMDLINE_TAG
       char *commandline = getenv ("bootargs");
#endif
 
//初始化内核entry point的地址
       theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep);
 
       /*
        * Check if there is an initrd image
        */
//检查有没有initrd 映像
//若有，则载到内存，并进行头部和数据的crc校验
       if (argc >= 3) {
              SHOW_BOOT_PROGRESS (9);
 
              addr = simple_strtoul (argv[2], NULL, 16);
 
              printf ("## Loading Ramdisk Image at %08lx .../n", addr);
 
              /* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
              if (addr_dataflash (addr)) {
                     read_dataflash (addr, sizeof (image_header_t),
                                   (char *) &header);
              } else
#endif
                     memcpy (&header, (char *) addr,
                            sizeof (image_header_t));
 
              if (ntohl (hdr->ih_magic) != IH_MAGIC) {
                     printf ("Bad Magic Number/n");
                     SHOW_BOOT_PROGRESS (-10);
                     do_reset (cmdtp, flag, argc, argv);
              }
 
              data = (ulong) & header;
              len = sizeof (image_header_t);
 
              checksum = ntohl (hdr->ih_hcrc);
              hdr->ih_hcrc = 0;
 
              if (crc32 (0, (char *) data, len) != checksum) {
                     printf ("Bad Header Checksum/n");
                     SHOW_BOOT_PROGRESS (-11);
                     do_reset (cmdtp, flag, argc, argv);
              }
 
              SHOW_BOOT_PROGRESS (10);
 
              print_image_hdr (hdr);
 
              data = addr + sizeof (image_header_t);
              len = ntohl (hdr->ih_size);
 
#ifdef CONFIG_HAS_DATAFLASH
              if (addr_dataflash (addr)) {
                     read_dataflash (data, len, (char *) CFG_LOAD_ADDR);
                     data = CFG_LOAD_ADDR;
              }
#endif
              memcpy ((char *)CONFIG_LOAD_INITRD_FILE_ADDR, (char *)data, len);
              data = CONFIG_LOAD_INITRD_FILE_ADDR;
 
              if (verify) {
                     ulong csum = 0;
 
                     printf ("   Verifying Checksum ... ");
                     csum = crc32 (0, (char *) data, len);
                     if (csum != ntohl (hdr->ih_dcrc)) {
                            printf ("Bad Data CRC/n");
                            SHOW_BOOT_PROGRESS (-12);
                            do_reset (cmdtp, flag, argc, argv);
                     }
                     printf ("OK/n");
              }
 
              SHOW_BOOT_PROGRESS (11);
 
              if ((hdr->ih_os != IH_OS_LINUX) ||
                  (hdr->ih_arch != IH_CPU_ARM) ||
                  (hdr->ih_type != IH_TYPE_RAMDISK)) {
                     printf ("No Linux ARM Ramdisk Image/n");
                     SHOW_BOOT_PROGRESS (-13);
                     do_reset (cmdtp, flag, argc, argv);
              }
 
#ifdef CONFIG_B2
              /*
               *we need to copy the ramdisk to SRAM to let Linux boot
               */
              memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
              data = ntohl(hdr->ih_load);
#endif /* CONFIG_B2 */
 
              /*
               * Now check if we have a multifile image
               */
       } else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
              ulong tail = ntohl (len_ptr[0]) % 4;
              int i;
 
              SHOW_BOOT_PROGRESS (13);
 
              /* skip kernel length and terminator */
              data = (ulong) (&len_ptr[2]);
              /* skip any additional image length fields */
              for (i = 1; len_ptr[i]; ++i)
                     data += 4;
              /* add kernel length, and align */
              data += ntohl (len_ptr[0]);
              if (tail) {
                     data += 4 - tail;
              }
 
              len = ntohl (len_ptr[1]);
 
       } else {
              /*
               * no initrd image
               */
              SHOW_BOOT_PROGRESS (14);
 
              len = data = 0;
       }
 
#ifdef      DEBUG
       if (!data) {
              printf ("No initrd/n");
       }
#endif
 
       if (data) {
              initrd_start = data;
              initrd_end = initrd_start + len;
       } else {
              initrd_start = 0;
              initrd_end = 0;
       }
 
       SHOW_BOOT_PROGRESS (15);
 
       /*debug*/printf("## Transferring control to Linux (at address %08lx) .../n",
              (ulong) theKernel);
 
//初始化参数标记列表
#if defined (CONFIG_SETUP_MEMORY_TAGS) || /
    defined (CONFIG_CMDLINE_TAG) || /
    defined (CONFIG_INITRD_TAG) || /
    defined (CONFIG_SERIAL_TAG) || /
    defined (CONFIG_REVISION_TAG) || /
    defined (CONFIG_VFD)
       setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
       setup_serial_tag (&params);
#endif
#ifdef CONFIG_REVISION_TAG
       setup_revision_tag (&params);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
       setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
       setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
       if (initrd_start && initrd_end)
              setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD)
       setup_videolfb_tag ((gd_t *) gd);
#endif
       setup_end_tag (bd);
#endif
 
       /* we assume that the kernel is in place */
       printf ("/nStarting kernel ... /n/n");
 
//内核启动前对cpu进行设置
       cleanup_before_linux ();
      
//跳转到内核的入口点开始执行，所传递的三个参数分别存放在
//r0(0); r1(machin type number); r2(physical address of tagged list in system RAM);
       theKernel (0, bd->bi_arch_number, bd->bi_boot_params);
}
 
到这里，控制权交到了内核的手中
 
总结：do_bootm主要是将内核解到内核映像头部信息指定的加载地址中，do_bootm_linux主要是设置参数，并跳转到内核入口开始执行。
BoySKung
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【嵌入式Linux】Uboot源码分析笔记
qingxiu3733的博客
07-01 527
本笔记为记录嵌入式Linux的uboot部分基础知识，结合源码对uboot的实现原理和应用展开学习
Uboot源码阅读笔记.pdf
04-26
Uboot源码阅读笔记.pdfUboot源码阅读笔记.pdfUboot源码阅读笔记.pdf
（3）uboot源代码分析
qq_40674996的博客
05-04 1412
从makefile和mkconfig我们知道了，第一个运行的文件时 cpu/arm920t/start.S 一、uboot源代码第一阶段 所以我们从start.S着手分析源代码。 uboot第一阶段是硬件相关的初始化： 设置cpu为svc模式 关闭看门狗 屏蔽中断 初始化SDRAM： blne cpu_init_crit cpu的初始化 点进这个函数里，就能看到SDRAM的初始化： bl...
uboot研读笔记 | 01 - 下载uboot源码并使用VSCode远程查看源码、编译uboot（2012.04.01版本）
Mculover666的博客（嵌入式）
02-21 4158
1. 硬件准备 俗话说，纸上得来终觉浅，绝知此事要躬行。 要想真正的搞懂uboot，不能只靠查看源码，要准备一块实际可以跑Linux的板子，并且一定要有别人移植好的uboot作为参考。 这里我使用的是JZ2440开发板，处理器是三星的S3C2440，CPU是ARM920T，如图。因为这款处理器移植uboot的资料太太太丰富了，所以在学习阶段，我选择这款处理器。 2. 下载uboot源码 uboo...
uboot源码分析(基于S5PV210)之零距离初体验
小嵌同学的博客
09-08 1592
(1) . gitignore，git工具的文件，git是一个版本管理工具（类似的还有个svn），这个文件和git有关，和uboot本身无关的，不用去管。(2) arm_config . mk，后缀是 . mk，是一个Makefile文件，将来在某个Makefile中会去调用它。(3) 三个Changelog文件，修改记录文件，该文件记录了这个uboot项目的版本变迁以及每个版本较上个版本修改的记录。正式的项目都有这些记录的。可以直接忽略，主要是给维护uboot的人用的。
Uboot开发与移植笔记（超详细代码讲解）（一）
qq_46037552的博客
10-11 2912
本文对UBoot源码进行详细讲解，逐一带你从0修改UBoot源码进行移植工作
IMX6 DualLite摸索笔记（3）Yocto 中uboot源码位置
asdf14time的博客
05-22 2385
又过了一周，蹉跎人生呀，总是在做些没有营养的鸡毛蒜皮的琐事。下载好Yocto文件后，后面就和《i.MX_BSP_Porting_Guide》不太一样了，对应的目录一个找不到，只能再次摸石头过河了。首先是uboot目录，据我观察是owen@ubuntu:~/fsl-release-bsp/buildDir/tmp/work/imx6dlsabreauto-poky-linux-gnueabi/u-b...
uboot学习笔记之源码解读（一）
CSDNmianfeixiazai001的博客
08-17 2672
1、BootLoader介绍 对于计算机系统来说，从开机上电到操作系统启动需要一个引导过程。嵌入式Linux系统同样离不开引导程序，这个引导程序就叫作启动加载程序（Bootloader）。 Bootloader是在操作系统运行之前执行的一段小程序。通过这段小程序，可以初始化硬件设备、建立内存空间的映射表，从而建立适当的系统软硬件环境，为最终调用操作系统内核做好准备。对于嵌入式系统，Bootlo...
Uboot1.1.16源代码完全注释笔记
小棋学编程的博客
10-31 4797
第一章 Uboot1.1.16中的汇编部分 老版本的Uboot1.1.16是从start.S (uboot1.1.16_256m-for36---v1.01\cpu\s3c64xx)开始执行的。 1.中断向量表和中断地址表。 .globl _start _start: b reset ldr pc, _undefined_instruction ldr pc, _software_in
uboot学习笔记
qq_37400022的博客
01-31 527
一、启动流程的分析 [TBL0: ARM的起始地址都是0地址, 三星的芯片一般将0地址映射到iROM中, BL0就是指iROM中固化的启动代码, 主要负责加载BL1 BL1: 三星对于bootloader的加密代码bl1.bin, 要放在外设中uboot.bin的头上, 和一部分uboot.bin一起加载到iRAM中运行. BL2: 从(nand/sd/usb)中拷贝的uboot.bin头最大14K到iRAM中代码中除去bl1.bin后剩余的部分, 负责设置CPU为SVC模式, 关闭MMU, 关闭中断, 关
Uboot源码目录分析笔记.docx
09-09
Uboot源码目录分析笔记
UBOOT源码阅读笔记
02-28
UBOOT源码阅读笔记，记录作者移植及对源码的理解
p2020 uboot 移植笔记
06-22
p2020 uboot 移植笔记
uboot代码详细分析.pdf
08-27
分享一篇我总结的 uboot 学习笔记（转） .....................................................................................15 U-BOOT内存布局及启动过程浅析 ................................................
dm9000初始化过程
11-18 5790
  drivers/dm9000x.c eth_init()函数   这里的初始化并不复杂，首先对dm9000进行复位 static void dm9000_reset(void) {        DM9000_DBG("resetting/n");        DM9000_iow(DM9000_NCR, NCR_RST);        udelay(1000);             
uboot Makefile源码分析
11-03 5676
这里主要涉及到如下几个文件： 主目录中的Makfile、mkconfig、config.mk以及各子目录中的Makefile。因为子目录中Makefile太多，所以本文中以lib_arm目录中的Makefile为例进行分析。   首先大概介绍一下这几个文件。   主目录中的Makefile是对整个工程的编译链接规则进行了描述。   子目录中的Makfile主要是编译一些源文件并进行归档，生成一些静
uboot源码阅读笔记 1
10-22 1824
uboot 源码阅读笔记 1   cpu/arm920t/start.S   在开始处首先定义了一个全局的标签， .globl _start   这个是整个uboot程序的入口，可在链接脚本 board/s3c2410/u-boot.lds中找到。   这个标签所指的地址处就是一跳转指令 _start:     b       reset 开始复位。   reset:        /*     
uboot 移植到s3c2410 第一篇
11-14 1777
本次移植是将uboot-1.1.6移植到s3c2410开发板上   一、创建开发板目录，修改相应的makefile及相关文件   创建开发板目录board/s3c2410, 找到相似的开发板board/smdk2410,将此目录中文件全部copy到s3c2410目录中。   由于我的开发板用的flash是intel的E28F128J3A，所以要寻找这个flash的驱动。将board/cmi中的fl
imx6dl uboot源码下载
最新发布
02-04
总之，下载imx6dl uboot源码需要找到官方源码仓库，使用git命令将源码克隆到本地计算机，然后按照官方文档进行编译和配置，最后进行代码的修改和调试。这样就可以在嵌入式系统开发中使用定制化的uboot引导加载程序了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值