int boot_linux_from_flash(void)
{
boot_img_hdr *hdr = (void*) raw_header;
unsigned n;
ptentry *p;
unsigned offset = 0;
const char *cmdline;
if((p = flash_find_ptn("boot")) == 0) {
cprintf("NO BOOT PARTITION\n");
return -1;
}
if(flash_read(p, offset, raw_header, 2048)) {
cprintf("CANNOT READ BOOT IMAGE HEADER\n");
return -1;
}
offset += 2048;
if(memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
cprintf("INVALID BOOT IMAGE HEADER\n");
return -1;
}
n = (hdr->kernel_size + (FLASH_PAGE_SIZE - 1)) & (~(FLASH_PAGE_SIZE - 1));
if(flash_read(p, offset, (void*) hdr->kernel_addr, n)) {
cprintf("CANNOT READ KERNEL IMAGE\n");
return -1;
}
offset += n;
n = (hdr->ramdisk_size + (FLASH_PAGE_SIZE - 1)) & (~(FLASH_PAGE_SIZE - 1));
if(flash_read(p, offset, (void*) hdr->ramdisk_addr, n)) {
cprintf("CANNOT READ RAMDISK IMAGE\n");
return -1;
}
offset += n;
dprintf("\nkernel @ %x (%d bytes)\n", hdr->kernel_addr, hdr->kernel_size);
dprintf("ramdisk @ %x (%d bytes)\n\n\n", hdr->ramdisk_addr, hdr->ramdisk_size);
if(hdr->cmdline[0]) {
cmdline = (char*) hdr->cmdline;
} else {
cmdline = board_cmdline();
if(cmdline == 0) {
cmdline = "mem=50M console=null";
}
}
cprintf("cmdline = '%s'\n", cmdline);
cprintf("\nBooting Linux\n");
create_atags(ADDR_TAGS, cmdline,
hdr->ramdisk_addr, hdr->ramdisk_size);
boot_linux(hdr->kernel_addr);
return 0;
}
void cmd_boot(int argc, char** argv) {
char* arguments = "";
if(argc >= 2) {
arguments = argv[1];
}
bufferPrintf("Booting kernel with arguments (%s)...\r\n", arguments);
boot_linux(arguments);
}
void boot_from_mem(unsigned int addr, int size)
{
if(kernel_addr != addr)
memcpy(kernel_addr, addr, size);
kernel_size = size;
if(init_boot_linux()) {
DISPLAY_MSG("FAILinvalid boot image");
}
// DISPLAY_MSG("\nTrying to reset modem...\n");
smsm_ack_amss_crash();
// DISPLAY_MSG("\nbooting linux...\n");
mdelay(10);
boot_linux();
return;
}
void cmd_boot(const char *arg, void *data, unsigned sz)
{
unsigned kernel_actual;
unsigned ramdisk_actual;
static struct boot_img_hdr hdr;
char *ptr = ((char*) data);
if (sz < sizeof(hdr)) {
fastboot_fail("invalid bootimage header");
return;
}
memcpy(&hdr, data, sizeof(hdr));
/* ensure commandline is terminated */
hdr.cmdline[BOOT_ARGS_SIZE-1] = 0;
if(target_is_emmc_boot() && hdr.page_size) {
page_size = hdr.page_size;
page_mask = page_size - 1;
}
kernel_actual = ROUND_TO_PAGE(hdr.kernel_size, page_mask);
ramdisk_actual = ROUND_TO_PAGE(hdr.ramdisk_size, page_mask);
if (page_size + kernel_actual + ramdisk_actual < sz) {
fastboot_fail("incomplete bootimage");
return;
}
memmove((void*) KERNEL_ADDR, ptr + page_size, hdr.kernel_size);
memmove((void*) RAMDISK_ADDR, ptr + page_size + kernel_actual, hdr.ramdisk_size);
fastboot_okay("");
target_battery_charging_enable(0, 1);
udc_stop();
boot_linux((void*) KERNEL_ADDR, (void*) TAGS_ADDR,
(const char*) hdr.cmdline, board_machtype(),
(void*) RAMDISK_ADDR, hdr.ramdisk_size);
}
/*
* clean and invalidate I & D cache ,mmu table, and then boot linux zImage
* a0 must be zero
* a1 machine type
* a2 linux zImage addr
*/
void call_linux(ulong a0, ulong a1, ulong a2)
{
ulong ip;
boot_linux_t boot_linux = (boot_linux_t)a2;
local_irq_disable();
cache_clean_invalidate();
tlb_invalidate();
__asm
{
mov ip, #0
mcr p15, 0, ip, c13, c0, 0 /* zero PID */
mcr p15, 0, ip, c7, c7, 0 /* invalidate I,D caches */
mcr p15, 0, ip, c7, c10, 4 /* drain write buffer */
mcr p15, 0, ip, c8, c7, 0 /* invalidate I,D TLBs */
mrc p15, 0, ip, c1, c0, 0 /* get control register */
bic ip, ip, #0x0001 /* disable MMU */
mcr p15, 0, ip, c1, c0, 0 /* write control register */
}
boot_linux(a0, a1, a2);
}
void cmd_boot(const char *arg, void *data, unsigned sz)
{
unsigned kernel_actual;
unsigned ramdisk_actual;
static struct boot_img_hdr hdr;
char *ptr = ((char*) data);
unsigned page_size = 0;
unsigned page_mask = 0;
int strlen = 0;
if (sz < sizeof(hdr)) {
fastboot_fail("invalid bootimage header");
return;
}
memcpy(&hdr, data, sizeof(hdr));
printf("\n============================================================\n");
hdr.magic[7] = '\0';
printf("[%s] Android Boot IMG Hdr - Magic : %s\n",MODULE_NAME,hdr.magic);
printf("[%s] Android Boot IMG Hdr - Kernel Size : 0x%x\n",MODULE_NAME,hdr.kernel_size);
printf("[%s] Android Boot IMG Hdr - Rootfs Size : 0x%x\n",MODULE_NAME,hdr.ramdisk_size);
printf("[%s] Android Boot IMG Hdr - Page Size : 0x%x\n",MODULE_NAME,hdr.page_size);
printf("============================================================\n");
/* ensure commandline is terminated */
hdr.cmdline[BOOT_ARGS_SIZE-1] = 0;
if(hdr.page_size) {
page_size = hdr.page_size;
page_mask = page_size - 1;
//page_mask = 2*1024 ; /*FIXME*/
}
else
{
printf("[FASTBOOT] Please specify the storage page-size in the boot header!\n");
fastboot_fail("Please specify the storage page-size in the boot header!\n");
return;
}
kernel_actual = ROUND_TO_PAGE(hdr.kernel_size, page_mask);
ramdisk_actual = ROUND_TO_PAGE(hdr.ramdisk_size, page_mask);
/* sz should have atleast raw boot image */
if (page_size + kernel_actual + ramdisk_actual > sz) {
fastboot_fail("incomplete bootimage");
return;
}
memmove((void*) hdr.kernel_addr, (ptr + MKIMG_HEADER_SZ + BIMG_HEADER_SZ), hdr.kernel_size);
memmove((void*) hdr.ramdisk_addr, (ptr + MKIMG_HEADER_SZ + BIMG_HEADER_SZ + kernel_actual), hdr.ramdisk_size);
strlen += sprintf((const char*) hdr.cmdline, "%s lcm=%1d-%s", hdr.cmdline, DISP_IsLcmFound(), mt_disp_get_lcm_id());
strlen += sprintf((const char*) hdr.cmdline, "%s fps=%1d", hdr.cmdline, mt_disp_get_lcd_time());
fastboot_okay("");
udc_stop();
mtk_wdt_init(); //re-open wdt
g_boot_mode = NORMAL_BOOT;
boot_linux((void*) hdr.kernel_addr, (void*) hdr.tags_addr,
(const char*) hdr.cmdline, board_machtype(),
(void*) hdr.ramdisk_addr, hdr.ramdisk_size);
#if 0
unsigned kernel_actual;
unsigned ramdisk_actual;
struct boot_img_hdr boot_hdr;
unsigned int k_pg_cnt = 0;
unsigned int r_pg_cnt = 0;
unsigned int b_pg_cnt = 0;
unsigned int size_b = 0;
unsigned int pg_sz = 2*1024 ;
int strlen = 0;
/*copy hdr data from download_base*/
memcpy(&boot_hdr, data, sizeof(boot_hdr));
/* ensure commandline is terminated */
boot_hdr.cmdline[BOOT_ARGS_SIZE-1] = 0;
printf("\n============================================================\n");
boot_hdr.magic[7] = '\0';
printf("[%s] Android Boot IMG Hdr - Magic : %s\n",MODULE_NAME,boot_hdr.magic);
printf("[%s] Android Boot IMG Hdr - Kernel Size : 0x%x\n",MODULE_NAME,boot_hdr.kernel_size);
printf("[%s] Android Boot IMG Hdr - Rootfs Size : 0x%x\n",MODULE_NAME,boot_hdr.ramdisk_size);
printf("[%s] Android Boot IMG Hdr - Page Size : 0x%x\n",MODULE_NAME,boot_hdr.page_size);
printf("============================================================\n");
//***************
//* check partition magic
//*
if (strncmp(boot_hdr.magic,BOOT_MAGIC, sizeof(BOOT_MAGIC))!=0) {
printf("[%s] boot image header magic error\n", MODULE_NAME);
return -1;
}
g_kmem_off = (unsigned int)target_get_scratch_address();
g_kmem_off = g_kmem_off + MKIMG_HEADER_SZ + BIMG_HEADER_SZ;
if(boot_hdr.kernel_size % pg_sz == 0)
{
k_pg_cnt = boot_hdr.kernel_size / pg_sz;
}
else
{
k_pg_cnt = (boot_hdr.kernel_size / pg_sz) + 1;
}
if(boot_hdr.ramdisk_size % pg_sz == 0)
{
r_pg_cnt = boot_hdr.ramdisk_size / pg_sz;
}
else
{
r_pg_cnt = (boot_hdr.ramdisk_size / pg_sz) + 1;
}
printf(" > page count of kernel image = %d\n",k_pg_cnt);
g_rmem_off = g_kmem_off + k_pg_cnt * pg_sz;
printf(" > kernel mem offset = 0x%x\n",g_kmem_off);
printf(" > rootfs mem offset = 0x%x\n",g_rmem_off);
//***************
//* specify boot image size
//*
g_bimg_sz = (k_pg_cnt + r_pg_cnt + 2)* pg_sz;
printf(" > boot image size = 0x%x\n",g_bimg_sz);
memmove((void*)CFG_BOOTIMG_LOAD_ADDR , g_kmem_off, boot_hdr.kernel_size);
memmove((void*)CFG_RAMDISK_LOAD_ADDR , g_rmem_off, boot_hdr.ramdisk_size);
//custom_port_in_kernel(g_boot_mode, commanline);
//strlen += sprintf(commanline, "%s lcm=%1d-%s", commanline, DISP_IsLcmFound(), mt_disp_get_lcm_id());
//strlen += sprintf(commanline, "%s fps=%1d", commanline, mt_disp_get_lcd_time());
fastboot_okay("");
udc_stop();
mtk_wdt_init();
boot_linux((void *)CFG_BOOTIMG_LOAD_ADDR, (unsigned *)CFG_BOOTARGS_ADDR,
(const char*) boot_hdr.cmdline, board_machtype(),
(void *)CFG_RAMDISK_LOAD_ADDR, boot_hdr.ramdisk_size);
#endif
}
int gboot_main()
{
int num;
//unsigned char buf[1024*4];
#ifdef MMU_ON
mmu_init();
#endif
uart_init();
led_init();
button_init();
init_irq();
led_off();
dma_init();
dma_start();
dm9000_init();
while(1)
{
printf("\n***************************************\n\r");
printf("\n****************MYBOOT*****************\n\r");
printf("1:Set Out a Arp Package to Get Host Ip and MAC!\n\r");
printf("2:Download Linux Kernel from TFTP Server!\n\r");
printf("3:Boot Linux from RAM!\n\r");
printf("\n Plese Select:");
scanf("%d",&num);
switch (num)
{
case 1:
arp_progress();
break;
case 2:
tftp_send_request("tftp.c");
while(FLAG_TFTP);
break;
case 3:
boot_linux();
//boot_linux_nand();
break;
default:
printf("Error: wrong selection!\n\r");
break;
}
}
return 0;
}
int My_boot_main()
{
//unsigned char buff[2048];
int num;
#ifdef MMU_ON
mmu_init();
#endif
led_init();
button_init();
init_irq();
uart_init();
ts_init();
//lcd_init();
//lcd_test();
dm9000_init();
while(1)
{
printf("\n**********************************************\n\r");
printf("\n*******************My-boot********************\n\r");
printf("[1], Download Linux Kernel from TFTP Server!\n\r");
printf("[2], Boot Linux from RAM!\n\r");
printf("[3], Boot Linux from Nand Flash\n\r");
printf("\n Please Select:");
int num;
scanf("%d", &num);
switch (num)
{
case 1:
//tftp_load();
tftp_send_request("start.o");
break;
case 2:
//boot_linux_ram();
//arp_request();
boot_linux();
break;
case 3:
//boot_linux_nand();
arp_request();
break;
default:
printf("Error: wrong selection!\n\r");
break;
}
return 0;
}
}
static void usb_rx_cmd_complete(struct usb_request *req, unsigned actual, int status)
{
if(status != 0) return;
if(actual > 4095) actual = 4095;
cmdbuf[actual] = 0;
dprintf("\n> %s\n",cmdbuf);
// dprintf("usb_rx_cmd_complete() '%s'\n", cmdbuf);
if(memcmp(cmdbuf, "reboot", 6) == 0) {
tx_status("OKAY");
rx_cmd();
mdelay(100);
board_reboot();
}
#if 0
if(memcmp(cmdbuf, "debug:", 6) == 0) {
void debug(char *cmd, char *resp);
memcpy(cmdbuf, "OKAY", 5);
tx_status(cmdbuf);
rx_cmd();
mdelay(5000);
dprintf("NOW!\n");
debug(cmdbuf + 6, cmdbuf + 4);
return;
}
#endif
if(memcmp(cmdbuf, "getvar:", 7) == 0) {
char response[64];
strcpy(response,"OKAY");
if(!strcmp(cmdbuf + 7, "version")) {
strcpy(response + 4, VERSION);
} else if(!strcmp(cmdbuf + 7, "product")) {
strcpy(response + 4, PRODUCTNAME);
} else if(!strcmp(cmdbuf + 7, "serialno")) {
strcpy(response + 4, serialno);
} else {
board_getvar(cmdbuf + 7, response + 4);
}
tx_status(response);
rx_cmd();
return;
}
if(memcmp(cmdbuf, "download:", 9) == 0) {
char status[16];
rx_addr = kernel_addr;
rx_length = hex2unsigned(cmdbuf + 9);
if (rx_length > (64*1024*1024)) {
tx_status("FAILdata too large");
rx_cmd();
return;
}
kernel_size = rx_length;
dprintf("recv data addr=%x size=%x\n", rx_addr, rx_length);
strcpy(status,"DATA");
num_to_hex8(rx_length, status + 4);
tx_status(status);
rx_data();
return;
}
if(memcmp(cmdbuf, "erase:", 6) == 0){
struct ptentry *ptn;
ptn = flash_find_ptn(cmdbuf + 6);
if(ptn == 0) {
tx_status("FAILpartition does not exist");
rx_cmd();
return;
}
dprintf("erasing '%s'\n", ptn->name);
cprintf("erasing '%s'", ptn->name);
if(flash_erase(ptn)) {
tx_status("FAILfailed to erase partition");
rx_cmd();
cprintf(" - FAIL\n");
return;
} else {
dprintf("partition '%s' erased\n", ptn->name);
cprintf(" - OKAY\n");
}
tx_status("OKAY");
rx_cmd();
return;
}
if(memcmp(cmdbuf, "flash:", 6) == 0){
struct ptentry *ptn;
int extra = 0;
ptn = flash_find_ptn(cmdbuf + 6);
if(kernel_size == 0) {
tx_status("FAILno image downloaded");
rx_cmd();
return;
}
if(ptn == 0) {
tx_status("FAILpartition does not exist");
rx_cmd();
return;
}
if(!strcmp(ptn->name,"boot") || !strcmp(ptn->name,"recovery")) {
if(memcmp((void*) kernel_addr, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
tx_status("FAILimage is not a boot image");
rx_cmd();
return;
}
}
#if REQUIRE_SIGNATURE
{
unsigned char digest[DIGEST_SIZE];
compute_digest((void*) kernel_addr, kernel_size, digest);
if (is_signature_okay(digest, signature, key_engineering)) {
dprintf("verified by engineering key\n");
} else {
tx_status("FAILsignature did not verify");
rx_cmd();
return;
}
}
#endif
if(!strcmp(ptn->name,"system") || !strcmp(ptn->name,"userdata")) {
extra = 64;
} else {
kernel_size = (kernel_size + 2047) & (~2047);
}
dprintf("writing %d bytes to '%s'\n",
kernel_size, ptn->name);
cprintf("writing '%s' (%d bytes)", ptn->name, kernel_size);
if(flash_write(ptn, extra, (void*) kernel_addr, kernel_size)) {
tx_status("FAILflash write failure");
rx_cmd();
cprintf(" - FAIL\n");
return;
} else {
dprintf("partition '%s' updated\n", ptn->name);
cprintf(" - OKAY\n");
}
tx_status("OKAY");
rx_cmd();
return;
}
if(memcmp(cmdbuf, "boot", 4) == 0) {
if(init_boot_linux()) {
tx_status("FAILinvalid boot image");
rx_cmd();
return;
}
dprintf("booting linux...\n");
cprintf("\nbooting linux...\n");
tx_status("OKAY");
mdelay(10);
usb_shutdown();
boot_linux();
return;
}
if(memcmp(cmdbuf, "signature", 9) == 0) {
if (kernel_size != SIGNATURE_SIZE) {
tx_status("FAILsignature not 256 bytes long");
rx_cmd();
return;
}
memcpy(signature, (void*)kernel_addr, SIGNATURE_SIZE);
tx_status("OKAY");
rx_cmd();
return;
}
tx_status("FAILinvalid command");
rx_cmd();
}
int main()
{
unsigned int num;
unsigned char ret = 0;
#ifdef MMU_ON
mmu_init();
#endif
led_init();
key_init();
irq_init();
uart0_init();
lcd_init();
i2c0_init();
lcd_clear_screen(0x000000);
dm9000_init();
printf("First write address of 0x0,");
at24cxx_write(0x0, 0xAA); //往设备内存0地址写入0xAA
ret = at24cxx_read(0x0); //读设备内存0地址里面的数据
printf("the value in address 0x0 = %x\r\n",ret);
printf("Second write address of 0x1,");
at24cxx_write(0x1,0x33);
ret = at24cxx_read(0x1);
printf("the value in address 0x1 = %x\r\n",ret);
// dm9000_arp();
while(1)
{
printf("\r\n");
printf("========= Boot for S5pv210 Main Menu =========\r\n");
printf("========= designed by KungfuMonkey =========\r\n");
printf("\r\n");
printf("1.ARP Request for PC MAC\r\n");
printf("2.Download Linux Kernel to SDRAM\r\n");
printf("3.Run the linux\r\n");
scanf("%d\r\n",&num);
printf("%d\r\n",num);
switch(num)
{
case 1:
arp_request();
break;
case 2:
tftp_send_request("zImage");
break;
case 3:
boot_linux();
break;
default:
printf("Error: wrong selection!\r\n");
break;
}
}
return 0;
}
int boot_linux_from_flash(void)
{
struct boot_img_hdr *hdr = (void*) buf;
unsigned n;
struct ptentry *ptn;
struct ptable *ptable;
unsigned offset = 0;
const char *cmdline;
if (target_is_emmc_boot()) {
hdr = (struct boot_img_hdr *)EMMC_BOOT_IMG_HEADER_ADDR;
if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
dprintf(CRITICAL, "ERROR: Invalid boot image header\n");
return -1;
}
goto continue_boot;
}
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
if(!boot_into_recovery)
{
ptn = ptable_find(ptable, "boot");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No boot partition found\n");
return -1;
}
}
else
{
ptn = ptable_find(ptable, "recovery");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No recovery partition found\n");
return -1;
}
}
if (flash_read(ptn, offset, buf, page_size)) {
dprintf(CRITICAL, "ERROR: Cannot read boot image header\n");
return -1;
}
offset += page_size;
if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
dprintf(CRITICAL, "ERROR: Invaled boot image heador\n");
return -1;
}
if (hdr->page_size != page_size) {
dprintf(CRITICAL, "ERROR: Invaled boot image pagesize. Device pagesize: %d, Image pagesize: %d\n",page_size,hdr->page_size);
return -1;
}
n = ROUND_TO_PAGE(hdr->kernel_size, page_mask);
if (flash_read(ptn, offset, (void *)hdr->kernel_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read kernel image\n");
return -1;
}
offset += n;
n = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask);
if (flash_read(ptn, offset, (void *)hdr->ramdisk_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read ramdisk image\n");
return -1;
}
offset += n;
continue_boot:
dprintf(INFO, "\nkernel @ %x (%d bytes)\n", hdr->kernel_addr,
hdr->kernel_size);
dprintf(INFO, "ramdisk @ %x (%d bytes)\n", hdr->ramdisk_addr,
hdr->ramdisk_size);
if(hdr->cmdline[0]) {
cmdline = (char*) hdr->cmdline;
} else {
cmdline = DEFAULT_CMDLINE;
}
dprintf(INFO, "cmdline = '%s'\n", cmdline);
/* TODO: create/pass atags to kernel */
dprintf(INFO, "\nBooting Linux\n");
boot_linux((void *)hdr->kernel_addr, (void *)TAGS_ADDR,
(const char *)cmdline, board_machtype(),
(void *)hdr->ramdisk_addr, hdr->ramdisk_size);
return 0;
}
int boot_linux_from_mmc(void)
{
struct boot_img_hdr *hdr = (void*) buf;
struct boot_img_hdr *uhdr;
unsigned offset = 0;
unsigned long long ptn = 0;
unsigned n = 0;
const char *cmdline;
uhdr = (struct boot_img_hdr *)EMMC_BOOT_IMG_HEADER_ADDR;
if (!memcmp(uhdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
dprintf(INFO, "Unified boot method!\n");
hdr = uhdr;
goto unified_boot;
}
if(!boot_into_recovery)
{
ptn = mmc_ptn_offset("boot");
if(ptn == 0) {
dprintf(CRITICAL, "ERROR: No boot partition found\n");
return -1;
}
}
else
{
ptn = mmc_ptn_offset("recovery");
if(ptn == 0) {
dprintf(CRITICAL, "ERROR: No recovery partition found\n");
return -1;
}
}
if (mmc_read(ptn + offset, (unsigned int *)buf, page_size)) {
dprintf(CRITICAL, "ERROR: Cannot read boot image header\n");
return -1;
}
if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
dprintf(CRITICAL, "ERROR: Invaled boot image header\n");
return -1;
}
if (hdr->page_size && (hdr->page_size != page_size)) {
page_size = hdr->page_size;
page_mask = page_size - 1;
}
offset += page_size;
n = ROUND_TO_PAGE(hdr->kernel_size, page_mask);
if (mmc_read(ptn + offset, (void *)hdr->kernel_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read kernel image\n");
return -1;
}
offset += n;
n = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask);
if (mmc_read(ptn + offset, (void *)hdr->ramdisk_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read ramdisk image\n");
return -1;
}
offset += n;
unified_boot:
dprintf(INFO, "\nkernel @ %x (%d bytes)\n", hdr->kernel_addr,
hdr->kernel_size);
dprintf(INFO, "ramdisk @ %x (%d bytes)\n", hdr->ramdisk_addr,
hdr->ramdisk_size);
if(hdr->cmdline[0]) {
cmdline = (char*) hdr->cmdline;
} else {
cmdline = DEFAULT_CMDLINE;
}
dprintf(INFO, "cmdline = '%s'\n", cmdline);
dprintf(INFO, "\nBooting Linux\n");
boot_linux((void *)hdr->kernel_addr, (void *)TAGS_ADDR,
(const char *)cmdline, board_machtype(),
(void *)hdr->ramdisk_addr, hdr->ramdisk_size);
return 0;
}
