boot.c

1. 8623L平台

/*****************************************
 Copyright (c) 2002-2007
 Sigma Designs, Inc. All Rights Reserved
 Proprietary and Confidential
 *****************************************/

/* This file is part of the EM86XX boot loader */

#include "config.h"
#include "util.h"
#include "uart.h"
#include "hardware.h"
#include "em86xxapi.h"
#include "io.h"
#include "romfs.h"
#include "flash.h"
#include "ide.h"
#include "bootcd.h"
#include "net.h"
#include "net_ipv4.h"

#include "bootmenu.h"
#include "bootconfig.h"
#include "memcfg.h"

#ifdef CONFIG_ENABLE_FIP
#include "fip.h"
extern const char *fiptext;
#endif

#ifdef CONFIG_ENABLE_DVI
#define ALLOW_OS_CODE 1
#include "rmdef/rmdef.h"
#include "emhwlib_hal/i2c/include/i2c_hal.h"
#endif

extern unsigned long dram0_size;
extern memcfg_t *memcfg_ptr;
extern void do_boot_prog(unsigned int) __attribute__ ((noreturn));

//
// function prototypes
// 
// every functions return 0 if failed. otherwise they don't return control to caller. 
//

#ifdef CONFIG_ENABLE_ROMFS2
int doboot_romfs_rom(unsigned int loadaddr, int idx);
#else
int doboot_romfs_rom(unsigned int loadaddr);
#endif
int doboot_romfs_ram(unsigned int loadaddr);
int doboot_ide(int drive, int part, int subpart, unsigned int loadaddr);
int doboot_idedisk(unsigned int loadaddr);
int doboot_cd(int drive, unsigned int loadaddr);
int doboot_idecd(unsigned int loadaddr);
int doboot_net(unsigned int loadaddr, char *filename);
void do_boot(unsigned int addr) __attribute__ ((noreturn));

extern unsigned long loadaddr_kernel, loadaddr_kernelfs, loadaddr_romfs;

static const char *copy_msg = "Copying binary from 0x%08x to 0x%08x, size %d(0x%x)\n";

void do_boot(unsigned int addr) 
{
#if defined(CONFIG_ENABLE_FIP) && defined(CONFIG_ENABLE_IDE)
    unsigned long key;
#endif
#ifdef CONFIG_ENABLE_NETWORK
    extern int net_dev_down(void);
    net_dev_down();
#endif

#if defined(CONFIG_ENABLE_FIP) && defined(CONFIG_ENABLE_IDE)
    key = fip_readkey(); /* See if any buttons is pressed */
    if (key == FIP_KEY_EJECT)  /* Ejecting the CD */
	ide_cdrom_eject(0, key);
    fip_write_text(0, fiptext = "BOOT", FIP_CENTER);
#endif

    do_boot_prog(addr);
}

//
// Boot from ROMFS
//

#ifdef CONFIG_ENABLE_ROMFS2
int doboot_romfs_rom(unsigned int loadaddr, int idx) /* idx = 0 (try romfs2 then romfs) */
{
    unsigned int addr = loadaddr ? loadaddr : loadaddr_kernel;
    unsigned int romfs_addr;

    if ((idx == 2) || (idx == 0)) {
	    romfs_addr = LOADER_FLASH_ROMFS2ADDR; /* Boot from ROMFS2 if possible */
	    if (boot_romfs(addr, romfs_addr, romfs_addr + 0x00040000)) {
		    uart_printf("Boot kernel at 0x%08x with ROMFS at 0x%08x\n", addr, romfs_addr);
		    do_boot(addr);
	    } 
    }

    if ((idx == 1) || (idx == 0)) {
	    romfs_addr = LOADER_FLASH_ROMFSADDR;
	    if (boot_romfs(addr, romfs_addr, romfs_addr + 0x00040000)) {
		    uart_printf("Boot kernel at 0x%08x with ROMFS at 0x%08x\n", addr, romfs_addr);
		    do_boot(addr);
	    }
    }
    return 0;
}
#else
int doboot_romfs_rom(unsigned int loadaddr)
{
    unsigned int addr = loadaddr ? loadaddr : loadaddr_kernel;
    unsigned int romfs_addr;

    romfs_addr = LOADER_FLASH_ROMFSADDR;
    if (boot_romfs(addr, romfs_addr, romfs_addr + 0x00040000)) {
        uart_printf("Boot kernel at 0x%08x with ROMFS at 0x%08x\n", addr, romfs_addr);
        do_boot(addr);
    }
    return 0;
}
#endif

int doload_installablefile(unsigned int loadaddr, unsigned int len, int docksum, int doadj)
{
    unsigned int checksum = 0;

    if (docksum != 0)
	checksum = binfile_crc_check((void *)loadaddr, len);

    if (checksum != 0)
	return 0;
    else {
        unsigned int dest = *((unsigned int *)loadaddr);

	uart_printf(copy_msg, loadaddr + 2 * sizeof(unsigned long), dest, len - sizeof(void *), len - sizeof(void *));

	/* Strip off the header 8 bytes: 4 = dest addr, 4 = checksum */
        memcpy((void *)UNCACHED(dest), (void *)(loadaddr + 2 * sizeof(unsigned long)), len - 2 * sizeof(unsigned long));

	/* If adjustment of memcfg need to be made */
	if (doadj != 0) {
            memcfg_ptr->dram0_fixed_topreserved = memcfg_ptr->dram0_size
						+ DRAM0_BASE - dest;
            if (memcfg_ptr->dram0_removable_topreserved != 0)
                memcfg_ptr->dram0_removable_topreserved -=
			memcfg_ptr->dram0_fixed_topreserved;
	    gen_memcfg_checksum(memcfg_ptr); /* Compute and set the checksum value */
        }
    }
    return 1;
}

int doload_romfs_installablefile(char *name, unsigned int loadaddr, int doadj)
{
    unsigned int len, romfs_addr;

#ifdef CONFIG_ENABLE_ROMFS2
    romfs_addr = LOADER_FLASH_ROMFS2ADDR; /* Load from ROMFS2 if possible */
    len = load_romfs_file(name, loadaddr, romfs_addr, romfs_addr + 0x00040000, 1);
    if (len != 0)
	    return(doload_installablefile(loadaddr, len, 1, doadj));
#endif

    romfs_addr = LOADER_FLASH_ROMFSADDR;
    len = load_romfs_file(name, loadaddr, romfs_addr, romfs_addr + 0x00040000, 1);
    if (len != 0)
	    return(doload_installablefile(loadaddr, len, 1, doadj));

    return(0);
}

#if defined(CONFIG_ENABLE_FLASH) && defined(CONFIG_ENABLE_VSYNCPARAM)
int doload_vsyncparam(unsigned int dest, int docksum)
{
    unsigned int checksum = 0;
    unsigned int startaddr;

    flash_probe(LOADER_FLASHBASE, 1, 0); /* In case the flash hasn't been probed */
    startaddr = LOADER_FLASHBASE + flash_getsize() - (MAX_USERPREF_SIZE / 2); /* Last 32KB of flash */
    if (docksum != 0)
        checksum = binfile_crc_check((void *)startaddr, MAX_USERPREF_SIZE / 2); 

    if ((checksum == 0) && (dest != 0)) {
	    uart_printf(copy_msg, startaddr, dest, MAX_USERPREF_SIZE / 2, MAX_USERPREF_SIZE / 2);
	memcpy((void *)dest, (void *)startaddr, MAX_USERPREF_SIZE / 2);
	return 1;
    } 
    return 0;
}
#endif

#ifdef CONFIG_ENABLE_IRQHANDLER
extern const char *irqhandler_init_msg;

int doload_irqhandler(unsigned int loadaddr, unsigned int len, int docksum)
{
    unsigned int checksum = 0;

    if (docksum != 0)
	checksum = binfile_crc_check((void *)loadaddr, len);

    if (checksum == 0) {
	typedef void (*FUNCPTR)(void);
	unsigned long dest = *(unsigned int *)(loadaddr + sizeof(unsigned int));
        FUNCPTR irqhandler_entry = (FUNCPTR)dest;       /* Offset by 4 */

	if (dest == 0)
	    return 0;
	uart_printf(irqhandler_init_msg, (unsigned long)irqhandler_entry);
        (*irqhandler_entry)();
	return 1;
    }
    return 0;
}

int doload_romfs_irqhandler(unsigned int loadaddr)
{
    unsigned int len, romfs_addr;

#ifdef CONFIG_ENABLE_ROMFS2
    romfs_addr = LOADER_FLASH_ROMFS2ADDR; /* Load from ROMFS2 if possible */
    len = load_romfs_file(DEFAULT_IRQHANDLER_FILENAME, loadaddr, romfs_addr, romfs_addr + 0x00040000, 1);
    if (len != 0)
	    return(doload_irqhandler(loadaddr, len, 1));
#endif

    romfs_addr = LOADER_FLASH_ROMFSADDR;
    len = load_romfs_file(DEFAULT_IRQHANDLER_FILENAME, loadaddr, romfs_addr, romfs_addr + 0x00040000, 1);
    if (len != 0)
	    return(doload_irqhandler(loadaddr, len, 1));
    return(0);
}
#endif

#ifdef CONFIG_ENABLE_BITMAPS
int doload_bitmap(unsigned int loadaddr, unsigned int len, int docksum)
{
    unsigned int checksum = 0;

    if (docksum != 0)
	checksum = binfile_crc_check((void *)loadaddr, len);

    if (checksum != 0)
	return 0;
    else {
	unsigned int *newaddr = (unsigned int *)(loadaddr);
	unsigned int i;
	unsigned int top_removable_size = 0;
	while (newaddr < (unsigned int *)(loadaddr + len) - sizeof(unsigned int)) {
	    unsigned long dest, len, type;
	    type = (unsigned long)*newaddr;
	    newaddr++; 
	    dest = (unsigned long)*newaddr;
 	    newaddr++;
 	    len = (unsigned long)*newaddr; 
 	    newaddr++;
		
	    if (dest > UNCACHED(DRAM0_BASE)) {
		unsigned int dram0_base = UNCACHED(DRAM0_BASE);
		if (dest > DRAM0_BASE)
		    dram0_base = DRAM0_BASE;
			
		if (dram0_base + memcfg_ptr->dram0_size - dest > top_removable_size) 
		    top_removable_size = UNCACHED(DRAM0_BASE) + memcfg_ptr->dram0_size - dest;
	    }

	    switch(type) {
	        case 0x44454c52:  //RLED
			uart_printf("Decompressing RLED section to 0x%08lx, from 0x%08lx, size %d (0x%x)\n", dest, newaddr, len, len);
			uart_printf("Decompressed size of RLED section is 0x%08lx\n", bmp_inflate((unsigned char*)newaddr, (unsigned char*)dest, len));
			newaddr += ((len+sizeof(unsigned int)-1) / sizeof(unsigned int));
			break;
		case 0x44574152: //RAWD
			uart_printf("Copying RAWD section to 0x%08lx, from 0x%08lx, size %d (0x%x)\n", dest, newaddr, len, len);			    
			if (dest < UNCACHED(DRAM0_BASE)) {
				for (i = 0; i < len/sizeof(unsigned int); i++) {
					__raw_writel(*newaddr, dest);
					newaddr++;
					dest+=sizeof(unsigned int);
				}
			} else {
				if ((UNCACHED(dest) + len) > (UNCACHED(DRAM0_BASE) + memcfg_ptr->dram0_size - 
					memcfg_ptr->dram0_fixed_topreserved)) {
					uart_puts("Warning: section too big (");
					if (memcfg_ptr->dram0_fixed_topreserved)
						uart_puts("override top fixed reserved area).\n");
					else
						uart_puts("beyond DRAM0 boundary).\n");
				}
				memcpy((void *)dest, (void *)newaddr, len);
				newaddr += len/sizeof(unsigned int);
			}
			break;