void do_booti_linux (boot_img_hdr *hdr) { char *bootargs; ulong initrd_start, initrd_end; void (*theKernel)(int zero, int arch, uint params); bd_t *bd = gd->bd; theKernel = (void (*)(int, int, uint))(hdr->kernel_addr); initrd_start = hdr->ramdisk_addr; initrd_end = initrd_start + hdr->ramdisk_size; printf(" Initrd start : %p , Initrd end : %p",initrd_start, initrd_end); #if defined (CONFIG_SETUP_MEMORY_TAGS) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #endif #ifdef CONFIG_SETUP_MEMORY_TAGS setup_memory_tags (bd); #endif #ifdef CONFIG_CMDLINE_TAG bootargs = getenv("bootargs"); if (bootargs == NULL || *bootargs == '\0') { bootargs = hdr->cmdline; } setup_commandline_tag (bd, bootargs); #endif #ifdef CONFIG_INITRD_TAG if (hdr->ramdisk_size) setup_initrd_tag (bd, initrd_start, initrd_end); #endif #if defined (CONFIG_VFD) || defined (CONFIG_LCD) setup_videolfb_tag ((gd_t *) gd); #endif setup_modelid_tag (¶ms); setup_end_tag (bd); #endif /* we assume that the kernel is in place */ printf ("\nStarting kernel ...\n\n"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect (void); udc_disconnect (); } #endif cleanup_before_linux (); theKernel (0, bd->bi_arch_number, bd->bi_boot_params); }
int main( void ) { void (*theKernel)(int zero, int arch, unsigned int params); /* 1. 帮内核设置串口:内核启动的开始部分会从串口打印一些log,但是内核一开始还没有初始化串口 */ uart0_init(); puts("\r\n---------welcome----------\r\n"); /* 2. 从NAND FLASH把内核读入内存 */ puts("Copy kernel from NAND.\n\r"); nand_read(0xa0000+64, (unsigned char *)0x30008000, 0x400000);/*boot(512K),params(128K),kernel(4M),rootfs(...)*/ /* 3. 设置参数 */ puts("Set boot params\n\r"); setup_start_tag(); setup_memory_tags(); setup_commandline_tag("noinitrd root=/dev/mtdblock3 init=/linuxrc console=ttySAC0,115200"); setup_end_tag(); /* 4. 跳转执行 */ puts("Boot kernel\n\r"); theKernel = (void (*)(int, int, unsigned int))0x30008000; theKernel(0, 362, 0x30000100); puts("Error!\n\r"); return -1; }
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images) { void (*theKernel)(int magic, void *tagtable); struct tag *params, *params_start; char *commandline = getenv("bootargs"); int ret; theKernel = (void *)images->ep; show_boot_progress (15); params = params_start = (struct tag *)gd->bd->bi_boot_params; params = setup_start_tag(params); params = setup_memory_tags(params); if (images->rd_start) { params = setup_ramdisk_tag(params, PHYSADDR(images->rd_start), PHYSADDR(images->rd_end)); } params = setup_commandline_tag(params, commandline); params = setup_clock_tags(params); params = setup_ethernet_tags(params); setup_end_tag(params); printf("\nStarting kernel at %p (params at %p)...\n\n", theKernel, params_start); prepare_to_boot(); theKernel(ATAG_MAGIC, params_start); /* does not return */ error: return 1; }
void setup_tags(void *mem){ setup_core_tag(mem, 4096); /* standard core tag 4k pagesize */ setup_mem_tag(0xa0000000, 0x04000000); /* 64Mb at 0xa0000000 */ setup_mem_tag(0xc0000000, 0x04000000); /* 64Mb at 0xc0000000 */ //setup_cmdline_tag("root=31:0 rootfstype=jffs2 rootdelay=3 rw init=/sbin/init"); //root on flash setup_cmdline_tag("root=179:2 rootdelay=3 rw init=/sbin/init"); //root on mmc/sd card setup_end_tag(); /* end of tags */ }
static void setup_tags(uint32_t *parameters) { setup_core_tag(parameters, 4096); /* standard core tag 4k pagesize */ setup_mem_tag(DRAM_BASE, 0x1FFFFFFF); /* 512MB at 0x20000000, only DMC0 is connected in Tiny210 board */ setup_ramdisk_tag(8192); /* create 8Mb ramdisk */ setup_initrd2_tag(INITRD_LOAD_ADDRESS, 0x100000); /* 1Mb of compressed data placed 8Mb into memory */ setup_cmdline_tag("root=/dev/ram0"); /* commandline setting root device */ setup_end_tag(); /* end of tags */ }
/* * boot_kernel: */ void boot_kernel(funcp image_p) { typedef void (*theKernel)(int zero, int arch, uint params) __attribute__ ((noreturn)); theKernel kernel = (theKernel)image_p; /* setup the platform for serial driver */ spear_serial_init(); setup_start_tag(); setup_memory_tags(); setup_commandline_tag(CONFIG_BOOTARGS); setup_end_tag(); cleanup_caches(); (*kernel) (0, CONFIG_MACH_TYPE, CONFIG_BOOT_PARAMS_ADDR); }
int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images) { void (*theKernel)(int magic, void *tagtable); struct tag *params, *params_start; char *commandline = getenv("bootargs"); /* * allow the PREP bootm subcommand, it is required for bootm to work * * TODO: Andreas Bießmann <*****@*****.**> refactor the * do_bootm_linux() for avr32 */ if (flag & BOOTM_STATE_OS_PREP) return 0; if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) return 1; theKernel = (void *)images->ep; bootstage_mark(BOOTSTAGE_ID_RUN_OS); params = params_start = (struct tag *)gd->bd->bi_boot_params; params = setup_start_tag(params); params = setup_memory_tags(params); if (images->rd_start) { params = setup_ramdisk_tag(params, PHYSADDR(images->rd_start), PHYSADDR(images->rd_end)); } params = setup_commandline_tag(params, commandline); params = setup_clock_tags(params); params = setup_ethernet_tags(params); params = setup_boardinfo_tag(params); setup_end_tag(params); printf("\nStarting kernel at %p (params at %p)...\n\n", theKernel, params_start); prepare_to_boot(); theKernel(ATAG_MAGIC, params_start); /* does not return */ return 1; }
void boot_linux() { //1. 获取Linux启动地址 theKernel = (void (*)(int , int , unsigned int ))SDRAM_KERNEL_START; //2. 设置启动参数 //2.1 设置核心启动参数 setup_core_tag(); //2.2 设置内存参数 setup_mem_tag(); //2.3 设置命令行参数 setup_cmdline_tag(); //2.4 设置参数结束标志 setup_end_tag(); //3. 启动Linux系统 theKernel(0,168,SDRAM_TAGS_START); }
/* Prepare ATAGs, flash the cache and start the kernel */ static int start_legacy_kernel(bootm_header_t *bm_hdr_p) { int ret; struct tag *start_tag, *current_tag; ret = bootm_load_os(bm_hdr_p); if (ret) { printf("%s:%d failed to load os (%d)\n", __func__, __LINE__, ret); return ret; } start_tag = (struct tag *)CONFIG_ATAG_BASE;; current_tag = setup_start_tag(start_tag); current_tag = setup_commandline_tag(current_tag, bm_hdr_p->cmdline); current_tag = setup_memory_tags(current_tag); setup_end_tag(current_tag); cache_sync_instructions(); dcache_mmu_disable(); return jump_to_kernel(bm_hdr_p, start_tag); }
/* Boot android style linux kernel and ramdisk */ int do_boot_linux (char *para_addr, char *cmdline, __u32 cmdline_length) { setup_start_tag (para_addr); // setup_serial_tag (¶ms); // setup_revision_tag (¶ms); #if 0 /*---------------------------------------------------------------------- * We don't need to set memory tags, since kernel will squash_mem_tags() * in arch/arm/kernel/setup.c. If we set memory tags, kernel will print * "Ignoring unrecognised tag 0x00000000" at boot time. *----------------------------------------------------------------------*/ /* setup_memory_tags (bd); */ #endif setup_commandline_tag (cmdline, cmdline_length); //#ifdef CONFIG_INITRD_TAG // if (hdr->ramdisk_size) // setup_initrd_tag (bd, initrd_start, initrd_end); //#endif setup_end_tag (); return 0; }
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images) { bd_t *bd = gd->bd; char *s; int machid = bd->bi_arch_number; void (*theKernel)(int zero, int arch, uint params); #ifdef CONFIG_CMDLINE_TAG char *commandline = getenv("bootargs"); #endif /* * allow the PREP bootm subcommand, it is required for bootm to work */ if (flag & BOOTM_STATE_OS_PREP) return 0; if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) return 1; theKernel = (void (*)(int, int, uint))images->ep; s = getenv("machid"); if (s) { machid = simple_strtoul(s, NULL, 16); printf("Using machid 0x%x from environment\n", machid); } bootstage_mark(BOOTSTAGE_ID_RUN_OS); debug("## 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) setup_start_tag(bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag(¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag(¶ms); #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 (images->rd_start && images->rd_end) setup_initrd_tag(bd, images->rd_start, images->rd_end); #endif setup_end_tag(bd); #endif /* we assume that the kernel is in place */ printf("\nStarting kernel ...\n\n"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect(void); udc_disconnect(); } #endif cleanup_before_linux(); theKernel(0, machid, bd->bi_boot_params); /* does not return */ return 1; }
/** * Set up tags for arm kernel in booting dual Linux kernels. */ void setup_arm_tags(void *jump_addr, const char *cmdline, u32 mem_base, u32 mem_size, u32 initrd2_start, u32 initrd2_size, int verbose) { u32 atag_data_size = 4096; #if defined(AMBARELLA_LINUX_LAYOUT) u32 kernelp, kernels; u32 bsbp, bsbs; u32 dspp, dsps; #endif if (((u32)jump_addr) > (DRAM_START_ADDR + 0x00200000)) { /* Special handling for OS allocated in higer memory region */ mem_base = ((u32)jump_addr) & 0xfff00000; mem_size -= (mem_base - DRAM_START_ADDR); atag_data = (void *)mem_base; } else { atag_data = (void *)(DRAM_START_ADDR + 0x000c0000); } memzero(atag_data, atag_data_size); setup_core_tag(atag_data, atag_data_size); if (verbose) { putstr("atag_data: 0x"); puthex((u32)atag_data); putstr("\r\n"); } #if defined(AMBARELLA_LINUX_LAYOUT) ambarella_linux_arm_mem_layout(&kernelp, &kernels, &bsbp, &bsbs, &dspp, &dsps); if (verbose) { putstr("kernelp: 0x"); puthex(kernelp); putstr(" kernels: 0x"); puthex(kernels); putstr("\r\n"); putstr("bsbp: 0x"); puthex(bsbp); putstr(" bsbs: 0x"); puthex(bsbs); putstr("\r\n"); putstr("dspp: 0x"); puthex(dspp); putstr(" dsps: 0x"); puthex(dsps); putstr("\r\n"); } setup_mem_tag(ATAG_MEM, kernelp, kernels); setup_mem_tag(ATAG_AMBARELLA_BSB, bsbp, bsbs); setup_mem_tag(ATAG_AMBARELLA_DSP, dspp, dsps); setup_tag_revision(AMBOOT_BOARD_ID); if (verbose) { putstr("AMBOOT_BOARD_ID: 0x"); puthex(AMBOOT_BOARD_ID); putstr("\r\n"); } #else setup_mem_tag(ATAG_MEM, mem_base, mem_size); #endif if (initrd2_start != 0x0 && initrd2_size != 0x0) { setup_initrd_tag(initrd2_start, initrd2_size); if (verbose) { putstr("initrd: 0x"); puthex(initrd2_start); putstr(" size: 0x"); puthex(initrd2_size); putstr("\r\n"); } } if (ambarella_bapi_arm_atag_entry) ambarella_bapi_arm_atag_entry(verbose); if (cmdline != NULL&& cmdline[0] != '\0') { setup_cmdline_tag(cmdline); if (verbose) { putstr(cmdline); putstr("\r\n"); } } setup_end_tag(); clean_d_cache(atag_data, atag_data_size); }
/** * Set up tags for booting Linux kernel. */ void setup_tags(void *jump_addr, const char *cmdline, u32 mem_base, u32 mem_size, u32 initrd2_start, u32 initrd2_size, int verbose) { u32 atag_data_size = 4096; #if defined(AMBARELLA_LINUX_LAYOUT) int block_size; flpart_table_t ptb; u32 low, high; u32 kernelp, kernels; u32 bsbp, bsbs; u32 dspp, dsps; #endif if (((u32)jump_addr) > (DRAM_START_ADDR + 0x00200000)) { /* Special handling for OS allocated in higer memory region */ mem_base = ((u32)jump_addr) & 0xfff00000; mem_size -= (mem_base - DRAM_START_ADDR); atag_data = (void *)mem_base; } else { atag_data = (void *)(DRAM_START_ADDR + 0x000c0000); } memzero(atag_data, atag_data_size); setup_core_tag(atag_data, atag_data_size); if (verbose) { putstr("atag_data: 0x"); puthex((u32)atag_data); putstr("\r\n"); } #if defined(AMBARELLA_LINUX_LAYOUT) ambarella_linux_mem_layout(&kernelp, &kernels, &bsbp, &bsbs, &dspp, &dsps); bsbp = ARM11_TO_CORTEX(bsbp); dspp = ARM11_TO_CORTEX(dspp); kernelp = ARM11_TO_CORTEX(kernelp); if (verbose) { putstr("kernelp: 0x"); puthex(kernelp); putstr(" kernels: 0x"); puthex(kernels); putstr("\r\n"); putstr("bsbp: 0x"); puthex(bsbp); putstr(" bsbs: 0x"); puthex(bsbs); putstr("\r\n"); putstr("dspp: 0x"); puthex(dspp); putstr(" dsps: 0x"); puthex(dsps); putstr("\r\n"); } setup_mem_tag(ATAG_MEM, kernelp, kernels); setup_mem_tag(ATAG_AMBARELLA_BSB, bsbp, bsbs); setup_mem_tag(ATAG_AMBARELLA_DSP, dspp, dsps); setup_tag_revision(AMBOOT_BOARD_ID); if (verbose) { putstr("AMBOOT_BOARD_ID: 0x"); puthex(AMBOOT_BOARD_ID); putstr("\r\n"); } if (flprog_get_part_table(&ptb) >= 0) { high = ptb.dev.eth[0].mac[5]; high <<= 8; high |= ptb.dev.eth[0].mac[4]; low = ptb.dev.eth[0].mac[3]; low <<= 8; low |= ptb.dev.eth[0].mac[2]; low <<= 8; low |= ptb.dev.eth[0].mac[1]; low <<= 8; low |= ptb.dev.eth[0].mac[0]; setup_serialnr_tag(ATAG_AMBARELLA_ETH0, low, high); if (verbose) { putstr("ATAG_AMBARELLA_ETH0: 0x"); puthex(high); putstr(" 0x"); puthex(low); putstr("\r\n"); } high = ptb.dev.eth[1].mac[5]; high <<= 8; high |= ptb.dev.eth[1].mac[4]; low = ptb.dev.eth[1].mac[3]; low <<= 8; low |= ptb.dev.eth[1].mac[2]; low <<= 8; low |= ptb.dev.eth[1].mac[1]; low <<= 8; low |= ptb.dev.eth[1].mac[0]; setup_serialnr_tag(ATAG_AMBARELLA_ETH1, low, high); if (verbose) { putstr("ATAG_AMBARELLA_ETH1: 0x"); puthex(high); putstr(" 0x"); puthex(low); putstr("\r\n"); } high = ptb.dev.wifi[0].mac[5]; high <<= 8; high |= ptb.dev.wifi[0].mac[4]; low = ptb.dev.wifi[0].mac[3]; low <<= 8; low |= ptb.dev.wifi[0].mac[2]; low <<= 8; low |= ptb.dev.wifi[0].mac[1]; low <<= 8; low |= ptb.dev.wifi[0].mac[0]; setup_serialnr_tag(ATAG_AMBARELLA_WIFI0, low, high); if (verbose) { putstr("ATAG_AMBARELLA_WIFI0: 0x"); puthex(high); putstr(" 0x"); puthex(low); putstr("\r\n"); } /*Updating with the fldev_t struct*/ high = ptb.dev.wifi[1].mac[5]; high <<= 8; high |= ptb.dev.wifi[1].mac[4]; low = ptb.dev.wifi[1].mac[3]; low <<= 8; low |= ptb.dev.wifi[1].mac[2]; low <<= 8; low |= ptb.dev.wifi[1].mac[1]; low <<= 8; low |= ptb.dev.wifi[1].mac[0]; setup_serialnr_tag(ATAG_AMBARELLA_WIFI1, low, high); if (verbose) { putstr("ATAG_AMBARELLA_WIFI1: 0x"); puthex(high); putstr(" 0x"); puthex(low); putstr("\r\n"); } high = ptb.dev.usb_eth[0].mac[5]; high <<= 8; high |= ptb.dev.usb_eth[0].mac[4]; low = ptb.dev.usb_eth[0].mac[3]; low <<= 8; low |= ptb.dev.usb_eth[0].mac[2]; low <<= 8; low |= ptb.dev.usb_eth[0].mac[1]; low <<= 8; low |= ptb.dev.usb_eth[0].mac[0]; setup_serialnr_tag(ATAG_AMBARELLA_USB_ETH0, low, high); if (verbose) { putstr("ATAG_AMBARELLA_USB_ETH0: 0x"); puthex(high); putstr(" 0x"); puthex(low); putstr("\r\n"); } high = ptb.dev.usb_eth[1].mac[5]; high <<= 8; high |= ptb.dev.usb_eth[1].mac[4]; low = ptb.dev.usb_eth[1].mac[3]; low <<= 8; low |= ptb.dev.usb_eth[1].mac[2]; low <<= 8; low |= ptb.dev.usb_eth[1].mac[1]; low <<= 8; low |= ptb.dev.usb_eth[1].mac[0]; setup_serialnr_tag(ATAG_AMBARELLA_USB_ETH1, low, high); if (verbose) { putstr("ATAG_AMBARELLA_USB_ETH1: 0x"); puthex(high); putstr(" 0x"); puthex(low); putstr("\r\n"); } /* updating with the fldev_t struct end*/ #if (USE_HAL == 1) setup_hal_tag(ARM11_TO_CORTEX(ptb.part[PART_HAL].mem_addr), ptb.part[PART_HAL].img_len, HAL_BASE_VIRT); if (verbose) { putstr("HAL: 0x"); puthex(HAL_BASE_VIRT); putstr(" [0x"); puthex(ARM11_TO_CORTEX(ptb.part[PART_HAL].mem_addr)); putstr("] size: 0x"); puthex(ptb.part[PART_HAL].img_len); putstr("\r\n"); } #endif } #if (defined(ENABLE_FLASH) && !defined(CONFIG_NAND_NONE)) block_size = flnand.main_size * flnand.pages_per_block; setup_serialnr_tag(ATAG_AMBARELLA_NAND_CS, flnand.control, block_size); setup_serialnr_tag(ATAG_AMBARELLA_NAND_T0, flnand.nandtiming0, flnand.nandtiming1); setup_serialnr_tag(ATAG_AMBARELLA_NAND_T1, flnand.nandtiming2, flnand.nandtiming3); setup_serialnr_tag(ATAG_AMBARELLA_NAND_T2, flnand.nandtiming4, flnand.nandtiming5); setup_serialnr_tag(ATAG_AMBARELLA_NAND_ECC, flnand.ecc_bits, 0); if (verbose) { putstr("NAND control: 0x"); puthex(flnand.control); putstr(" block_size: 0x"); puthex(block_size); putstr("\r\n"); putstr("timing0: 0x"); puthex(flnand.timing0); putstr(" timing1: 0x"); puthex(flnand.timing1); putstr("\r\n"); putstr("timing2: 0x"); puthex(flnand.timing2); putstr(" timing3: 0x"); puthex(flnand.timing3); putstr("\r\n"); putstr("timing4: 0x"); puthex(flnand.timing4); putstr(" timing5: 0x"); puthex(flnand.timing5); putstr(" ecc bit: 0x"); puthex(flnand.ecc_bits); putstr("\r\n"); } #endif #else setup_mem_tag(ATAG_MEM, mem_base, mem_size); #endif if (initrd2_start != 0x0 && initrd2_size != 0x0) { setup_initrd_tag(ARM11_TO_CORTEX(initrd2_start), initrd2_size); if (verbose) { putstr("initrd: 0x"); puthex(ARM11_TO_CORTEX(initrd2_start)); putstr(" size: 0x"); puthex(initrd2_size); putstr("\r\n"); } } if (ambarella_bapi_atag_entry) ambarella_bapi_atag_entry(verbose); if (ambarella_cortex_atag_entry) ambarella_cortex_atag_entry(verbose); if (cmdline != NULL&& cmdline[0] != '\0') { setup_cmdline_tag(cmdline); if (verbose) { putstr(cmdline); putstr("\r\n"); } } setup_end_tag(); clean_d_cache(atag_data, atag_data_size); }
int main(runMode_t mode) { void* kernelImage = L"/e/zImage"; char* cmdlnRM = "bootmode=2 loglevel=4"; char* cmdlnBG = "bootmode=10 loglevel=4"; char* cmdln = "loglevel=4"; unsigned char ATAG_buf[512]={0}; t_stat filestat; fun_t kernel; int fd; unsigned long kernelSize=0; //here we start the real deal :) int mmuctrl = MemMMUCacheEnable(gMMUL1PageTable, 1); disp_FOTA_Init(); disp_FOTA_Printf("*----------------------------*"); disp_FOTA_Printf("| Booting Android |"); disp_FOTA_Printf("*----------------------------*"); //there was a ascii art forgatted it on other pc disp_FOTA_Printf("| |"); disp_FOTA_Printf("*----------------------------*"); disp_FOTA_Printf(""); //.... Your code here... __PfsNandInit(); __PfsMassInit(); MemoryCardMount(); tfs4_stat(kernelImage, &filestat); kernelSize = filestat.st_size; if ((fd=tfs4_open(kernelImage, 4)) >= 0) { tfs4_read(fd, &KERNEL_BUF, kernelSize); tfs4_close(fd); } if (kernelSize <= 0) { disp_FOTA_Printf("Kernel Not Found"); } DisableMmuCache(mmuctrl); _CoDisableMmu(); setup_core_tag(ATAG_buf); setup_serial_tag(0x123, 0x456); setup_rev_tag('0'); if(mode == rm_BIGMEM) { setup_cmdline_tag(cmdlnBG); disp_FOTA_Printf("Bigmem mode"); DRV_Modem_BootingStart(); } if(mode == rm_FPFK) { disp_FOTA_Printf("Under Maintise :D"); } if(mode == rm_FOTA_RECOVERY) { setup_cmdline_tag(cmdlnRM); disp_FOTA_Printf("recovery mode Activated"); } else { setup_cmdline_tag(cmdln); DRV_Modem_BootingStart(); } setup_end_tag(); //copy kernel to the right position memcpy(&KERNEL_START, &KERNEL_BUF, kernelSize); //SYSCON operations *((unsigned int*)SYSCON_NORMAL_CFG) = 0xFFFFFFFF; _CoDisableDCache(); _System_DisableVIC(); _System_DisableIRQ(); _System_DisableFIQ(); kernel = (fun_t)&KERNEL_START; kernel(0, 8500, ATAG_buf); //loop forever while(1); return 0; }
void do_bootm_linux (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], bootm_headers_t *images) { ulong initrd_start, initrd_end; ulong ep = 0; bd_t *bd = gd->bd; char *s; int machid = bd->bi_arch_number; void (*theKernel)(int zero, int arch, uint params); int ret; #ifdef CONFIG_CMDLINE_TAG char *commandline = getenv ("bootargs"); #endif /* find kernel entry point */ if (images->legacy_hdr_valid) { ep = image_get_ep (&images->legacy_hdr_os_copy); #if defined(CONFIG_FIT) } else if (images->fit_uname_os) { ret = fit_image_get_entry (images->fit_hdr_os, images->fit_noffset_os, &ep); if (ret) { puts ("Can't get entry point property!\n"); goto error; } #endif } else { puts ("Could not find kernel entry point!\n"); goto error; } theKernel = (void (*)(int, int, uint))ep; s = getenv ("machid"); if (s) { machid = simple_strtoul (s, NULL, 16); printf ("Using machid 0x%x from environment\n", machid); } ret = boot_get_ramdisk (argc, argv, images, IH_ARCH_ARM, &initrd_start, &initrd_end); if (ret) goto error; show_boot_progress (15); debug ("## 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_LCD) || \ defined (CONFIG_VFD) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #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) || defined (CONFIG_LCD) 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"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect (void); udc_disconnect (); } #endif cleanup_before_linux (); theKernel (0, machid, bd->bi_boot_params); /* does not return */ return; error: do_reset (cmdtp, flag, argc, argv); return; }
void do_bootm_linux(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], unsigned long addr, unsigned long *len_ptr, int verify) { unsigned long data, len = 0; unsigned long initrd_start, initrd_end; unsigned long image_start, image_end; unsigned long checksum; void (*theKernel)(int magic, void *tagtable); image_header_t *hdr; struct tag *params, *params_start; char *commandline = getenv("bootargs"); hdr = (image_header_t *)addr; image_start = addr; image_end = addr + hdr->ih_size; theKernel = (void *)ntohl(hdr->ih_ep); /* * Check if there is an initrd image */ if (argc >= 3) { show_boot_progress (9); addr = simple_strtoul(argv[2], NULL, 16); printf("## Loading RAMDISK image at %08lx ...\n", addr); memcpy(&header, (char *)addr, sizeof(header)); hdr = &header; if (ntohl(hdr->ih_magic) != IH_MAGIC) { puts("Bad Magic Number\n"); show_boot_progress (-10); do_reset(cmdtp, flag, argc, argv); } data = (unsigned long)hdr; len = sizeof(*hdr); checksum = ntohl(hdr->ih_hcrc); hdr->ih_hcrc = 0; if (crc32(0, (unsigned char *)data, len) != checksum) { puts("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(header); len = ntohl(hdr->ih_size); if (verify) { unsigned long csum = 0; puts(" Verifying Checksum ... "); csum = crc32(0, (unsigned char *)data, len); if (csum != ntohl(hdr->ih_dcrc)) { puts("Bad Data CRC\n"); show_boot_progress (-12); do_reset(cmdtp, flag, argc, argv); } puts("OK\n"); } show_boot_progress (11); if ((hdr->ih_os != IH_OS_LINUX) || (hdr->ih_arch != IH_CPU_AVR32) || (hdr->ih_type != IH_TYPE_RAMDISK)) { puts("Not a Linux/AVR32 RAMDISK image\n"); show_boot_progress (-13); do_reset(cmdtp, flag, argc, argv); } } 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; } if (data) { initrd_start = data; initrd_end = initrd_start + len; } else { initrd_start = 0; initrd_end = 0; } show_boot_progress (15); params = params_start = (struct tag *)gd->bd->bi_boot_params; params = setup_start_tag(params); params = setup_memory_tags(params); if (initrd_start) { params = setup_ramdisk_tag(params, PHYSADDR(initrd_start), PHYSADDR(initrd_end)); } params = setup_commandline_tag(params, commandline); params = setup_clock_tags(params); params = setup_ethernet_tags(params); setup_end_tag(params); printf("\nStarting kernel at %p (params at %p)...\n\n", theKernel, params_start); prepare_to_boot(); theKernel(ATAG_MAGIC, params_start); }
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images) { bd_t *bd = gd->bd; char *s; int machid = bd->bi_arch_number; void (*theKernel)(int zero, int arch, uint params); #ifdef CONFIG_CMDLINE_TAG char *commandline = getenv ("bootargs"); #endif #ifdef CONFIG_MARVELL_TAG char *env; #endif if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) return 1; theKernel = (void (*)(int, int, uint))images->ep; s = getenv ("machid"); if (s) { machid = simple_strtoul (s, NULL, 16); printf ("Using machid 0x%x from environment\n", machid); } show_boot_progress (15); debug ("## 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_LCD) || \ defined (CONFIG_VFD) || \ defined (CONFIG_MARVELL_TAG) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #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 (images->rd_start && images->rd_end) setup_initrd_tag (bd, images->rd_start, images->rd_end); #endif #if defined (CONFIG_VFD) || defined (CONFIG_LCD) setup_videolfb_tag ((gd_t *) gd); #endif #if defined (CONFIG_MARVELL_TAG) env = getenv("passDramInitTag"); if(((strcmp(env,"yes") == 0) || (strcmp(env,"Yes") == 0))) { setup_marvell_tag(); } #endif setup_end_tag (bd); #endif /* we assume that the kernel is in place */ printf ("\nStarting kernel ...\n\n"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect (void); udc_disconnect (); } #endif cleanup_before_linux (); theKernel (0, machid, bd->bi_boot_params); /* does not return */ return 1; }
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images) { bd_t *bd = gd->bd; char *s; int machid = bd->bi_arch_number; void (*kernel_entry)(int zero, int arch, uint params); #ifdef CONFIG_CMDLINE_TAG char *commandline = getenv ("bootargs"); #endif if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) return 1; s = getenv ("machid"); if (s) { machid = simple_strtoul (s, NULL, 16); printf ("Using machid 0x%x from environment\n", machid); } show_boot_progress (15); #ifdef CONFIG_OF_LIBFDT if (images->ft_len) return bootm_linux_fdt(machid, images); #endif kernel_entry = (void (*)(int, int, uint))images->ep; debug ("## Transferring control to Linux (at address %08lx) ...\n", (ulong) kernel_entry); #if defined (CONFIG_SETUP_MEMORY_TAGS) || \ defined (CONFIG_CMDLINE_TAG) || \ defined (CONFIG_INITRD_TAG) || \ defined (CONFIG_SERIAL_TAG) || \ defined (CONFIG_REVISION_TAG) || \ defined (CONFIG_LCD) || \ defined (CONFIG_VFD) || \ defined (CONFIG_DMAMEM) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #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 (images->rd_start && images->rd_end) setup_initrd_tag (bd, images->rd_start, images->rd_end); #endif #if defined (CONFIG_SETUP_VIDEOLFB_TAG) && (defined (CONFIG_VFD) || defined (CONFIG_LCD)) setup_videolfb_tag ((gd_t *) gd); #endif #ifdef CONFIG_DMAMEM setup_dmamem_tag(); #endif setup_end_tag(bd); #endif announce_and_cleanup(); kernel_entry(0, machid, bd->bi_boot_params); /* does not return */ return 1; }
void do_booti_linux (boot_img_hdr *hdr) { ulong initrd_start, initrd_end; void (*theKernel)(int zero, int arch, uint params); bd_t *bd = gd->bd; int machid = bd->bi_arch_number; #ifdef CONFIG_CMDLINE_TAG char *commandline = getenv("bootargs"); char *machidString = getenv("machid"); /* If no bootargs env, just use hdr command line */ if (!commandline) commandline = (char *)hdr->cmdline; if (machidString) machid = simple_strtoul(machidString, NULL, 16); /* XXX: in production, you should always use boot.img 's cmdline !!! */ printf("kernel cmdline: \n"); printf("\tuse %s ", getenv("bootargs") ? "uboot" : "boot.img"); printf("command line:\n\t%s \n", commandline); printf ("\tUsing machid 0x%x\n", machid); #endif theKernel = (void (*)(int, int, uint))(hdr->kernel_addr); initrd_start = hdr->ramdisk_addr; initrd_end = initrd_start + hdr->ramdisk_size; #if defined (CONFIG_SETUP_MEMORY_TAGS) setup_start_tag(bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #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 (hdr->ramdisk_size) setup_initrd_tag (bd, initrd_start, initrd_end); #endif #if defined (CONFIG_VFD) || defined (CONFIG_LCD) 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"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect (void); udc_disconnect (); } #endif cleanup_before_linux (); theKernel (0, machid, bd->bi_boot_params); }
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images) { bd_t *bd = gd->bd; char *s; int machid = bd->bi_arch_number; void (*theKernel)(int zero, int arch, uint params); #ifdef CONFIG_CMDLINE_TAG char *commandline = getenv ("bootargs"); #if !CONFIG_MFG #if defined(CONFIG_MX53_BEJ) || defined(CONFIG_MX53_BEJ2) extern char key_status_at_startup[6]; extern char *mx53_bej_boot_version; extern int kernel_dev; char *autorun,*serialno,*macaddr,*testkey; char kpp[16],ver[32],buff[1024]; strncpy(buff,commandline,sizeof(buff)); buff[(sizeof(buff)/sizeof(buff[0]))-1]='\0'; #ifdef CONFIG_SDTEST if((testkey=getenv("testkey")) != NULL){ strncat(buff," kpp=",sizeof(buff)); strncat(buff,testkey,sizeof(buff)); } else { strncat(buff," kpp=M_R-_",sizeof(buff)); } // printf(" %s\n",buff); #else sprintf(kpp," kpp=%s",key_status_at_startup); strncat(buff,kpp,sizeof(buff)); printf(kpp); #endif puts("\n"); sprintf(ver," bootVer=%s",mx53_bej_boot_version); strncat(buff,ver,sizeof(buff)); printf(ver); puts("\n"); if(autorun=getenv("autorun")){ strncat(buff," autorun=\"",sizeof(buff)); strncat(buff,autorun,sizeof(buff)); strncat(buff,"\"",sizeof(buff)); printf(" autorun=\"%s\"\n",autorun); } switch(kernel_dev){ case 10: strncat(buff," kernelfrom=eMMC",sizeof(buff)); printf(" kernelfrom=eMMC\n"); break; case 20: #ifdef CONFIG_SDTEST strncat(buff," kernelfrom=SDcard_test",sizeof(buff)); printf(" kernelfrom=SDcard_test\n"); #else strncat(buff," kernelfrom=SDcard",sizeof(buff)); printf(" kernelfrom=SDcard\n"); #endif break; } if(macaddr=getenv("macaddr")) { strncat(buff," macaddr=",sizeof(buff)); strncat(buff,macaddr,sizeof(buff)); printf(" macaddr=%s\n",macaddr); } if(serialno=getenv("serialno")) { strncat(buff," androidboot.serialno=",sizeof(buff)); strncat(buff,serialno,sizeof(buff)); printf(" serialno=%s\n",serialno); } commandline=buff; #endif #endif #endif if ((flag != 0) && (flag != BOOTM_STATE_OS_GO)) return 1; theKernel = (void (*)(int, int, uint))images->ep; s = getenv ("machid"); if (s) { machid = simple_strtoul (s, NULL, 16); printf ("Using machid 0x%x from environment\n", machid); } show_boot_progress (15); debug ("## 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_LCD) || \ defined (CONFIG_VFD) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #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 (images->rd_start && images->rd_end) setup_initrd_tag (bd, images->rd_start, images->rd_end); #endif #if defined (CONFIG_VFD) || defined (CONFIG_LCD) 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"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect (void); udc_disconnect (); } #endif cleanup_before_linux (); theKernel (0, machid, bd->bi_boot_params); /* does not return */ return 1; }
void do_bootm_linux (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], ulong addr, ulong *len_ptr, int verify) { 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 theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep); /* * Check if there is an initrd image */ 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, (unsigned 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 if (verify) { ulong csum = 0; printf (" Verifying Checksum ... "); csum = crc32 (0, (unsigned 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); } #if defined(CONFIG_B2) || defined(CONFIG_EVB4510) || defined(CONFIG_ARMADILLO) /* *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 || CONFIG_EVB4510 */ /* * 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 ("## 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_LCD) || \ defined (CONFIG_VFD) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #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) || defined (CONFIG_LCD) setup_videolfb_tag ((gd_t *) gd); #endif setup_modelid_tag(¶ms); setup_cpuid_tag(¶ms); setup_end_tag (bd); #endif /* we assume that the kernel is in place */ printf ("\nStarting kernel ...\n\n"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect (void); udc_disconnect (); } #endif cleanup_before_linux (); theKernel (0, bd->bi_arch_number, bd->bi_boot_params); }
int do_nand_boot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { DECLARE_GLOBAL_DATA_PTR; int ret; bd_t *bd = gd->bd; ulong addr, data, len, initrd_start, initrd_end; void (*theKernel)(int zero, int arch, uint params); int strlen; #ifdef CONFIG_CMDLINE_TAG char *commandline = getenv ("bootargs"); #endif #ifdef CFG_UBOOT_PROFILING extern unsigned int boot_time; unsigned int time_do_nand_boot= get_timer(0); unsigned int time_rootfs; unsigned int time_load_bootimg; unsigned int ubt; #endif #if defined (CONFIG_SETUP_MEMORY_TAGS) || \ defined (CONFIG_CMDLINE_TAG) || \ defined (CONFIG_INITRD_TAG) || \ defined (CONFIG_SERIAL_TAG) || \ defined (CONFIG_REVISION_TAG) || \ defined (CONFIG_LCD) || \ defined (CONFIG_VFD) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #endif #ifdef CONFIG_SETUP_MEMORY_TAGS if(g_boot_mode == FACTORY_BOOT) { setup_memory_tags_factory(bd); } else { setup_memory_tags (bd); } #endif //#ifdef CONFIG_CMDLINE_TAG //**************** //* according to current boot mode to set boot tag and related boot args //* switch(g_boot_mode) { //******************************************************************** //* NORMAL BOOT //******************************************************************** case NORMAL_BOOT: #if defined(CFG_NAND_BOOT) strlen += sprintf(commandline, "%s%s%x%s%x", commandline, NAND_MANF_CMDLINE, nand_flash_man_code, NAND_DEV_CMDLINE, nand_flash_dev_id); #endif setup_boot_tag(NORMAL_BOOT); ret = mboot_android_load_bootimg_hdr(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Boot Image"); } #ifdef CFG_UBOOT_PROFILING time_load_bootimg= get_timer(0); #endif ret = mboot_android_load_bootimg(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); #ifdef CFG_UBOOT_PROFILING printf("[PROFILE] ------- load boot.img takes %d ms -------- \n", get_timer(time_load_bootimg)); #endif if (ret < 0) { msg_img_error("Android Boot Image"); } break; //******************************************************************** //* META //******************************************************************** case META_BOOT: #ifdef CFG_META_MODE printf("[META] - Old bootargs : %s\n",commandline); commandline=strcat(commandline,META_BOOTARGS); printf("[META] - New bootargs : %s\n",commandline); setup_boot_tag(META_BOOT); #endif ret = mboot_android_load_bootimg_hdr(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Boot Image"); } ret = mboot_android_load_bootimg(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Boot Image"); } break; //******************************************************************** //* ADVANCED META MODE //******************************************************************** case ADVMETA_BOOT: printf("[META] - Old bootargs : %s\n",commandline); commandline=strcat(commandline, ADV_META_BOOTARGS); printf("[META] - New bootargs : %s\n",commandline); setup_boot_tag(ADVMETA_BOOT); ret = mboot_android_load_bootimg_hdr(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Boot Image"); } ret = mboot_android_load_bootimg(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Boot Image"); } break; //******************************************************************** //* ANDROID RECOVERY //******************************************************************** case RECOVERY_BOOT: #ifdef CFG_RECOVERY_MODE setup_boot_tag(RECOVERY_BOOT); #endif ret = mboot_android_load_recoveryimg_hdr(PART_RECOVERY, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Recovery Image"); } ret = mboot_android_load_recoveryimg(PART_RECOVERY, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Recovery Image"); } break; //******************************************************************** //* FACTORY //******************************************************************** case FACTORY_BOOT: #if defined(CFG_NAND_BOOT) strlen += sprintf(commandline, "%s%s%x%s%x", commandline, NAND_MANF_CMDLINE, nand_flash_man_code, NAND_DEV_CMDLINE, nand_flash_dev_id); #endif #ifdef CFG_FACTORY_MODE setup_boot_tag(FACTORY_BOOT); #endif //************* //* parse recovery image header //* ret = mboot_android_load_factoryimg_hdr(CFG_FACTORY_NAME, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { printf("factory image doesn't exist in SD card\n"); // load boot image from nand ret = mboot_android_load_bootimg_hdr(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Boot Image"); } ret = mboot_android_load_bootimg(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Boot Image"); } } else { // load the factory image ret = mboot_android_load_factoryimg(CFG_FACTORY_NAME, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Factory Image"); } } break; //******************************************************************** //* ATE_FACTORY_BOOT //******************************************************************** case ATE_FACTORY_BOOT: #if defined(CFG_NAND_BOOT) strlen += sprintf(commandline, "%s%s%x%s%x", commandline, NAND_MANF_CMDLINE, nand_flash_man_code, NAND_DEV_CMDLINE, nand_flash_dev_id); #endif #ifdef CFG_FACTORY_MODE setup_boot_tag(ATE_FACTORY_BOOT); #endif //************* //* parse recovery image header //* ret = mboot_android_load_factoryimg_hdr(CFG_FACTORY_NAME, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { printf("factory image doesn't exist in SD card\n"); // load boot image from nand ret = mboot_android_load_bootimg_hdr(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Boot Image"); } ret = mboot_android_load_bootimg(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Boot Image"); } } else { // load the factory image ret = mboot_android_load_factoryimg(CFG_FACTORY_NAME, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Factory Image"); } } break; //******************************************************************** //* SW BOOT //******************************************************************** case SW_REBOOT: setup_boot_tag(SW_REBOOT); ret = mboot_android_load_bootimg_hdr(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Boot Image"); } ret = mboot_android_load_bootimg(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_img_error("Android Boot Image"); } break; //******************************************************************** //* ALARM BOOT //******************************************************************** case ALARM_BOOT: #if defined(CFG_NAND_BOOT) strlen += sprintf(commandline, "%s%s%x%s%x", commandline, NAND_MANF_CMDLINE, nand_flash_man_code, NAND_DEV_CMDLINE, nand_flash_dev_id); #endif setup_boot_tag(ALARM_BOOT); ret = mboot_android_load_bootimg_hdr(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); if (ret < 0) { msg_header_error("Android Boot Image"); } #ifdef CFG_UBOOT_PROFILING time_load_bootimg= get_timer(0); #endif ret = mboot_android_load_bootimg(PART_BOOTIMG, CFG_BOOTIMG_LOAD_ADDR); #ifdef CFG_UBOOT_PROFILING printf("[PROFILE] ------- load boot.img takes %d ms -------- \n", get_timer(time_load_bootimg)); #endif if (ret < 0) { msg_img_error("Android Boot Image"); } break; } //************* //* relocate rootfs (ignore rootfs header) //* #ifdef CFG_UBOOT_PROFILING time_rootfs = get_timer(0); #endif //if(g_boot_mode == RECOVERY_BOOT) //{ memcpy((char *)CFG_RAMDISK_LOAD_ADDR, (char *)(g_rmem_off), g_rimg_sz); //} g_rmem_off = CFG_RAMDISK_LOAD_ADDR; #ifdef CFG_UBOOT_PROFILING printf("[PROFILE] ------- reloate rootfs takes %d ms -------- \n", get_timer(time_rootfs)); #endif strlen += sprintf(commandline, "%s%s%s", commandline, " uboot_ver=" UBOOT_VERSION_CLI, " uboot_build_ver=" BUILD_VERSION_CLI ); #ifdef CFG_UBOOT_PROFILING ubt = ((unsigned int)get_timer(boot_time)) + 810; strlen += sprintf(commandline, "%s%s%d", commandline, ".ubt.", ubt); #endif custom_port_in_kernel(g_boot_mode, commandline); strlen += sprintf(commandline, "%s lcm=%1d-%s", commandline, DISP_IsLcmFound(), mt65xx_disp_get_lcm_id()); setup_commandline_tag (bd, commandline); //#endif //CONFIG_CMDLINE_TAG //************* //* dump some starting instruction for debug //* //printf(" theKernel (0x%x)\n",g_kmem_off); //printf(" theKernel (0x%x) = 0x%x\n",g_kmem_off,DRV_Reg32(g_kmem_off)); //printf(" theKernel (0x%x) = 0x%x\n",g_kmem_off+0x4,DRV_Reg32(g_kmem_off+0x4)); //printf(" theKernel (0x%x) = 0x%x\n",g_kmem_off+0x8,DRV_Reg32(g_kmem_off+0x8)); //************* //* dump some starting instruction for debug //* //printf("\n rootfs (0x%x)\n",g_rmem_off); //printf(" rootfs (0x%x) = 0x%x\n",g_rmem_off,DRV_Reg32(g_rmem_off)); //printf(" rootfs (0x%x) = 0x%x\n",g_rmem_off+0x4,DRV_Reg32(g_rmem_off+0x4)); //printf(" rootfs (0x%x) = 0x%x\n",g_rmem_off+0x8,DRV_Reg32(g_rmem_off+0x8)); //************* //* specify the kernel jumping address //* theKernel = (void (*)(int, int, uint)) (g_kmem_off); //printf("\n > kernel mem offset (not include header) = 0x%x\n",theKernel); //************* //* specify the rootfs starting address //* initrd_start = g_rmem_off; initrd_end = initrd_start + g_rimg_sz; //printf(" > rootfs mem offset (not include header) = 0x%x\n\n",initrd_start); #ifdef CONFIG_INITRD_TAG if (initrd_start && initrd_end) setup_initrd_tag (bd, initrd_start, initrd_end); #endif #if CONFIG_VIDEOLFB_TAG setup_videolfb_tag ((gd_t *) gd); #endif setup_end_tag (bd); #endif #ifdef CFG_UBOOT_PROFILING printf("[PROFILE] ------- do_nand_boot takes %d ms -------- \n", get_timer(time_do_nand_boot)); printf("[MBOOT] ------- UBoot boot kernel takes %d ms -------- \n", get_timer(boot_time)); #endif printf("NAND BOOT\n"); #ifdef CONFIG_LCD video_printf("NAND BOOT\n"); video_printf("Boot Linux Kernel\n"); #endif //***************** //* to centralize deinit process, moving //* "Uboot_power_saving" to "cleanup_before_linux" //* cleanup_before_linux(); printf(" > kernel mem offset (not include header) = 0x%x\n",theKernel); //***************** //* jump to kernel //* theKernel (0, bd->bi_arch_number, bd->bi_boot_params); return 0; }
static int bt_atag_finish(BT_HANDLE hShell, int argc, char **argv) { setup_end_tag(); return 0; }
void do_booti_linux (boot_img_hdr *hdr) { ulong initrd_start, initrd_end; void (*theKernel)(int zero, int arch, uint params); bd_t *bd = gd->bd; theKernel = (void (*)(int, int, uint))(hdr->kernel_addr); initrd_start = hdr->ramdisk_addr; initrd_end = initrd_start + hdr->ramdisk_size; #if defined (CONFIG_SETUP_MEMORY_TAGS) setup_start_tag (bd); #ifdef CONFIG_SERIAL_TAG setup_serial_tag (¶ms); #endif #ifdef CONFIG_REVISION_TAG setup_revision_tag (¶ms); #endif #ifdef CONFIG_REVISION16_TAG setup_revision16_tag (¶ms); #endif #ifdef CONFIG_SERIAL16_TAG setup_serial16_tag (¶ms); #endif #ifdef CONFIG_MACADDR_TAG setup_macaddr_tag (¶ms); #endif #ifdef CONFIG_BOOTMODE_TAG setup_bootmode_tag (¶ms); #endif #ifdef CONFIG_GYROCAL_TAG setup_gyrocal_tag (¶ms); #endif #ifdef CONFIG_PRODUCTID_TAG setup_productid_tag (¶ms); #endif #ifdef CONFIG_SETUP_MEMORY_TAGS setup_memory_tags (bd); #endif #ifdef CONFIG_CMDLINE_TAG setup_commandline_tag (bd, hdr->cmdline); #endif #ifdef CONFIG_INITRD_TAG if (hdr->ramdisk_size) setup_initrd_tag (bd, initrd_start, initrd_end); #endif #if defined (CONFIG_VFD) || defined (CONFIG_LCD) 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"); #ifdef CONFIG_USB_DEVICE { extern void udc_disconnect (void); udc_disconnect (); } #endif cleanup_before_linux (); theKernel (0, bd->bi_arch_number, bd->bi_boot_params); }
void do_bootm_linux(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], bootm_headers_t *images) { ulong initrd_start, initrd_end; ulong ep = 0; void (*theKernel)(int magic, void *tagtable); struct tag *params, *params_start; char *commandline = getenv("bootargs"); int ret; /* find kernel entry point */ if (images->legacy_hdr_valid) { ep = image_get_ep (images->legacy_hdr_os); #if defined(CONFIG_FIT) } else if (images->fit_uname_os) { ret = fit_image_get_entry (images->fit_hdr_os, images->fit_noffset_os, &ep); if (ret) { puts ("Can't get entry point property!\n"); goto error; } #endif } else { puts ("Could not find kernel entry point!\n"); goto error; } theKernel = (void *)ep; ret = boot_get_ramdisk (argc, argv, images, IH_ARCH_AVR32, &initrd_start, &initrd_end); if (ret) goto error; show_boot_progress (15); params = params_start = (struct tag *)gd->bd->bi_boot_params; params = setup_start_tag(params); params = setup_memory_tags(params); if (initrd_start) { params = setup_ramdisk_tag(params, PHYSADDR(initrd_start), PHYSADDR(initrd_end)); } params = setup_commandline_tag(params, commandline); params = setup_clock_tags(params); params = setup_ethernet_tags(params); setup_end_tag(params); if (!images->autostart) return ; printf("\nStarting kernel at %p (params at %p)...\n\n", theKernel, params_start); prepare_to_boot(); theKernel(ATAG_MAGIC, params_start); /* does not return */ return; error: if (images->autostart) do_reset (cmdtp, flag, argc, argv); return; }