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
关注
专栏目录
【嵌入式Linux】Uboot源码分析笔记
qingxiu3733的博客
07-01 592
本笔记为记录嵌入式Linux的uboot部分基础知识，结合源码对uboot的实现原理和应用展开学习
UBOOT源码阅读笔记
02-28
### UBOOT源码阅读笔记知识点解析 #### 一、UBOOT简介 UBOOT（Universal Boot Loader）是一款开源的Bootloader程序，广泛应用于嵌入式系统中。它支持多种处理器架构和操作系统，具备高度的可移植性和灵活性。通过...
（3）uboot源代码分析
qq_40674996的博客
05-04 1470
从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 4393
1. 硬件准备 俗话说，纸上得来终觉浅，绝知此事要躬行。 要想真正的搞懂uboot，不能只靠查看源码，要准备一块实际可以跑Linux的板子，并且一定要有别人移植好的uboot作为参考。 这里我使用的是JZ2440开发板，处理器是三星的S3C2440，CPU是ARM920T，如图。因为这款处理器移植uboot的资料太太太丰富了，所以在学习阶段，我选择这款处理器。 2. 下载uboot源码 uboo...
Uboot开发与移植笔记（超详细代码讲解）（一）
最新发布
qq_46037552的博客
10-11 6247
本文对UBoot源码进行详细讲解，逐一带你从0修改UBoot源码进行移植工作
uboot源码分析(基于S5PV210)之零距离初体验
小嵌同学的博客
09-08 2247
(1) . gitignore，git工具的文件，git是一个版本管理工具（类似的还有个svn），这个文件和git有关，和uboot本身无关的，不用去管。(2) arm_config . mk，后缀是 . mk，是一个Makefile文件，将来在某个Makefile中会去调用它。(3) 三个Changelog文件，修改记录文件，该文件记录了这个uboot项目的版本变迁以及每个版本较上个版本修改的记录。正式的项目都有这些记录的。可以直接忽略，主要是给维护uboot的人用的。
uboot移植视频笔记
我的安卓之路
05-05 315
麦子学院uboot移植视频源码和笔记
IMX6 DualLite摸索笔记（3）Yocto 中uboot源码位置
asdf14time的博客
05-22 2432
又过了一周，蹉跎人生呀，总是在做些没有营养的鸡毛蒜皮的琐事。下载好Yocto文件后，后面就和《i.MX_BSP_Porting_Guide》不太一样了，对应的目录一个找不到，只能再次摸石头过河了。首先是uboot目录，据我观察是owen@ubuntu:~/fsl-release-bsp/buildDir/tmp/work/imx6dlsabreauto-poky-linux-gnueabi/u-b...
Uboot1.1.16源代码完全注释笔记
小棋学编程的博客
10-31 5340
第一章 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学习笔记之源码解读（一）
CSDNmianfeixiazai001的博客
08-17 2810
1、BootLoader介绍 对于计算机系统来说，从开机上电到操作系统启动需要一个引导过程。嵌入式Linux系统同样离不开引导程序，这个引导程序就叫作启动加载程序（Bootloader）。 Bootloader是在操作系统运行之前执行的一段小程序。通过这段小程序，可以初始化硬件设备、建立内存空间的映射表，从而建立适当的系统软硬件环境，为最终调用操作系统内核做好准备。对于嵌入式系统，Bootlo...
Uboot源码目录分析笔记.docx
09-09
《UBoot源码目录分析详解》 UBoot，全称微内核启动加载器（Micro Universal Boot Loader），是嵌入式系统中广泛使用的引导加载程序。深入理解UBoot的源码目录结构对于开发者来说至关重要，这有助于我们进行系统移植...
Uboot源码阅读笔记.pdf
04-26
本文将根据提供的文档《U-Boot源码阅读笔记.pdf》中的内容，详细解析U-Boot在ARM920T处理器上的启动过程及其关键步骤。 #### 二、启动过程概览 在U-Boot的启动过程中，首先是汇编语言编写的启动文件`start.S`，它...
p2020 uboot 移植笔记
06-22
从U-Boot官方网站获取最新源代码，然后使用`./configure`脚本配置工程，指定目标架构为`powerpc-e500mc`，以适应P2020处理器。 5. **硬件平台初始化** U-Boot需要知道如何初始化P2020的时钟、内存控制器、中断...
dm9000初始化过程
11-18 5846
  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 5723
这里主要涉及到如下几个文件： 主目录中的Makfile、mkconfig、config.mk以及各子目录中的Makefile。因为子目录中Makefile太多，所以本文中以lib_arm目录中的Makefile为例进行分析。   首先大概介绍一下这几个文件。   主目录中的Makefile是对整个工程的编译链接规则进行了描述。   子目录中的Makfile主要是编译一些源文件并进行归档，生成一些静
uboot源码阅读笔记 1
10-22 1852
uboot 源码阅读笔记 1   cpu/arm920t/start.S   在开始处首先定义了一个全局的标签， .globl _start   这个是整个uboot程序的入口，可在链接脚本 board/s3c2410/u-boot.lds中找到。   这个标签所指的地址处就是一跳转指令 _start:     b       reset 开始复位。   reset:        /*     
uboot 移植到s3c2410 第一篇
11-14 1796
本次移植是将uboot-1.1.6移植到s3c2410开发板上   一、创建开发板目录，修改相应的makefile及相关文件   创建开发板目录board/s3c2410, 找到相似的开发板board/smdk2410,将此目录中文件全部copy到s3c2410目录中。   由于我的开发板用的flash是intel的E28F128J3A，所以要寻找这个flash的驱动。将board/cmi中的fl
Uboot源码阅读笔记 3
10-29 1637
    Uboot中的每一个命令都由一个宏进行声明，这宏在文件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}   如i2
正点原子笔记精粹：从入门到Uboot源码分析
第4讲 Uboot源码目录分析_笔记可能涉及的知识点包括： 1. Uboot源码结构：详细解读Uboot源码目录的构成，各部分的功能和作用。 2. 启动流程分析：Uboot如何在嵌入式设备上启动，包括其初始化过程和启动阶段。 3. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值