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