main.c.bak

em86xx 完整启动程序,支持网络下载与串通下载

/*****************************************
 Copyright (c) 2002-2005
 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 "vsprintf.h"
#include "uart.h"
#include "hardware.h"
#include "em86xxapi.h"
#include "io.h"
#include "flash.h"
#include "ide.h"
#include "pcifpga.h"
#include "bootconfig.h"
#include "timer.h"
#include "net.h"

#if defined(CONFIG_ENABLE_PCIHOST_EM86XX)
#include "pciem86xx.h"
#elif defined(CONFIG_ENABLE_PCIHOST_FPGA)
#include "pcifpga.h"
#endif

#include "bootmenu.h"
#include "boot.h"
#include "romfs.h"
#include "memcfg.h"

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

//
// function prototypes
// 

extern void test_stage1(loaderconfig_t *config);
extern int is_secondary_loader(void);

static loaderconfig_t *em86xx_bootconfig(void);
static void em86xx_bootflag(loaderconfig_t *config);
static unsigned em86xx_dram_size(int dram_ctrl);
static void adjust_memmap(unsigned dram_size);

#ifdef CONFIG_ARCH_TANGO15
static void set_mac_address(unsigned long mac_lo, unsigned mac_hi);
#endif

unsigned long loadaddr_romfs = 0;
unsigned long loadaddr_initrd = 0;
unsigned long loadaddr_kernel = 0;
unsigned long loadaddr_kernelfs = 0;
unsigned long loadaddr_temp = 0;
unsigned long loadaddr_boot = 0;
unsigned long loadaddr_heap_unzip = 0;
unsigned long loadaddr_heap_start = 0;
unsigned long loadaddr_heap_end = 0;
unsigned long loadaddr_pci_start = 0;
unsigned long dram0_size = 0;

#ifdef CONFIG_ENABLE_2NDBOOT
unsigned long loadaddr_2ndboot = 0;
#endif

#ifdef CONFIG_ENABLE_IRQHANDLER
unsigned long loadaddr_irqhandler = 0;
#endif

#ifdef CONFIG_ENABLE_BITMAPS
unsigned long loadaddr_bitmap = 0;
#endif

#ifdef CONFIG_ENABLE_UCODES
unsigned long loadaddr_ucode = 0;
#endif

#ifdef CONFIG_ENABLE_USERPREF
unsigned long loadaddr_userpref = 0;
#endif

#ifdef CONFIG_ENABLE_VSYNCPARAM
unsigned long loadaddr_vsyncparam = 0;
#endif

#ifdef CONFIG_ENABLE_DVI
unsigned long loadaddr_dvi = 0;
#endif

memcfg_t *memcfg_ptr = (memcfg_t *)MEMCFG_START;
const char *bootmsg_fmt = "Booted from %s flash.\n";
extern void download_init(void);

#if defined(CONFIG_ENABLE_IRQHANDLER) && defined(CONFIG_ENABLE_BITMAPS) && defined(CONFIG_ENABLE_USERPREF) && defined (CONFIG_ENABLE_VSYNCPARAM)
extern int board_splashscreen_init(void);
#endif

#ifndef CONFIG_RELEASE
int build_kernel_param_tag(void);
#endif

int entry(void)
{
    extern int __bss_start__, __bss_end__;
    loaderconfig_t *config;
    int dram0 = 0, dram1 = 0;

    // copies vector table from LOADER_DRAMBASE to DRAMBASE
    memcpy((void *) DRAMBASE, (void *) LOADER_DRAMBASE, VECTORS_SIZE);

    // clears BSS section
    memset(&__bss_start__, 0, (unsigned int) &__bss_end__ - (unsigned int) &__bss_start__);

    // initializes UART
    uart_init();

    // looks for configuration
    config = em86xx_bootconfig();

    // initializes UART and shows greeting
    uart_puts("\n\n" CONFIG_ARCH " boot loader v" BOOTLOADER_VERSIONSTR " for " CONFIG_BOARD "/");
    uart_puts((config && config->boardname[0] != 0) ? (char *) config->boardname : "unnamed");
    uart_puts(" board\n");
    uart_puts("(C) Copyright 2002-2005 Sigma Designs, Inc\n");
    uart_puts("\n");

#ifdef CONFIG_DEVEL
    uart_puts("NOTE: this boot loader is designed to boot kernels made with the\n"
              "      2.4.xx releases of the Sigma Designs ARMutils package\n\n");
    
    uart_puts("Built at " __DATE__ " " __TIME__ "\n");
    uart_printf("Loaded to 0x%08x\n", LOADER_DRAMBASE);

    if (config) {
        uart_puts("Found boot configuration\n");

        switch (config->bootvalid) {
        case LOADER_CONFIGBOOTFLASH :
            uart_printf(bootmsg_fmt, "parallel");
            break;
        case LOADER_CONFIGBOOTSFLASH :
            uart_printf(bootmsg_fmt, "serial");
            break;
        case LOADER_CONFIGSECBOOTSFLASH:
            uart_puts("Securely booted from serial flash\n");
            break;
        case LOADER_CONFIGSECBOOTFLASH:
            uart_puts("Securely booted from parallel flash\n");
            break;
        default :
            uart_puts("Booted from unknown media\n");
            break;
        }
    } else
        uart_puts("Booted directly from RAM\n");

#if defined(CONFIG_ENABLE_2NDBOOT) && defined(BOOT_2NDBOOT)
    if (is_secondary_loader()) {
        uart_puts("Using stage2 loader: "); 
        if (config) {
            if (BOOTLOADER_VERSION == config->version)
                uart_puts("version matched\n");
            else
                uart_printf("version mismatched(0x%08lx vs. 0x%08lx)\n", BOOTLOADER_VERSION, config->version);
        } else
            uart_printf("unknown version\n");
    } else
        uart_puts("Cannot find stage2 loader ..\n");
#endif
    
    uart_printf("CPU freq.: %d MHz\n", em86xx_getclockmhz());
    if (config) {
        dram0 = CONFIG_GETDRAMSIZE(config->dram_size, 0);
        dram1 = CONFIG_GETDRAMSIZE(config->dram_size, 1);
        if (dram0 != 0) 
            dram0 = em86xx_dram_size(0);
        if (dram1 != 0) 
            dram1 = em86xx_dram_size(1);
        dram0_size = dram0 << 20;
        adjust_memmap(dram0);
        uart_printf("DRAM size is %dMB (%dMB/%dMB)\n", dram0 + dram1, dram0, dram1);
        uart_printf("DRAM0 Params (0x%08lx/0x%08lx)\n",
                __raw_readl(REG_BASE_dram_controller_0 + DRAM_dunit_cfg),
                __raw_readl(REG_BASE_dram_controller_0 + DRAM_dunit_delay0_ctrl));
#if (DEFAULT_DRAM1_SIZE != 0)
        uart_printf("DRAM1 Params (0x%08lx/0x%08lx)\n",
                __raw_readl(REG_BASE_dram_controller_1 + DRAM_dunit_cfg),
                __raw_readl(REG_BASE_dram_controller_1 + DRAM_dunit_delay0_ctrl));
#endif
        /* Set memory data structure to 0 before start */
        memset((void *)memcfg_ptr, 0, sizeof(memcfg_t));
        memcfg_ptr->signature = MEMCFG_SIGNATURE;
        memcfg_ptr->dram0_size = dram0_size;
        memcfg_ptr->dram1_size = dram1 << 20;
        memcfg_ptr->kernel_end = LOADER_RESERVED; /* Left for OS to initialize */
#ifdef ENABLE_ENCRYPTED_OPT_ROM
        /* Only the bootloader knows the real size the kernel and its
         * additional ROMFS will take, update the kernel end, the OS should not
         * touch this */
        memcfg_ptr->kernel_end += ENCRYPTED_OPT_DRAM_SIZE;
        uart_printf("Optional encrypted ROMFS enabled, kernel end set to 0x%08lx\n", memcfg_ptr->kernel_end);
#endif

#ifdef CONFIG_ARCH_TANGO15
        {
                unsigned char addr[8];
	        if (mac_read(&addr[0]) != -1) {
                        unsigned long mac_hi, mac_lo;
		        mac_hi = (addr[0] & 0xff) << 8;
		        mac_hi |= (addr[1] & 0xff);
		        mac_lo = (addr[2] & 0xff) << 24;
		        mac_lo |= (addr[3] & 0xff) << 16;
		        mac_lo |= (addr[4] & 0xff) << 8;
		        mac_lo |= (addr[5] & 0xff);
                        set_mac_address(mac_lo, mac_hi);
                }
	}
#endif

        gen_memcfg_checksum(memcfg_ptr); /* Compute and set the checksum value */
    }
    
#if DEFAULT_UART_PORT != 0
    uart_printf("Use UART %d by default\n", DEFAULT_UART_PORT);
#endif
#ifndef CONFIG_ENABLE_CACHE
    uart_puts("Disabled internal I and D cache\n");
#endif
#endif // CONFIG_DEVEL

    em86xx_init();
#ifdef CONFIG_ENABLE_PCIHOST_FPGA
    pcifpga_init(1);
#endif

#ifndef CONFIG_RELEASE
    build_kernel_param_tag();
#endif

#ifdef CONFIG_PRODUCTIONTEST
    test_stage1(config);
#endif

    // initialize
    em86xx_irq_init();
    em86xx_sbox_init();
    em86xx_mbus_init();
                                                                                
    // enable IRQ/FIQ
    em86xx_sti();
    em86xx_stf();
                                                                                
    // setup timer
    em86xx_setup_timer();

#ifdef CONFIG_ENABLE_BOOTMENU
    if (config && (config->bootflag & BOOTFLAG_BOOT)) {
        if ((config->bootflag & BOOTFLAG_DIRECT) == 0) {
            em86xx_msleep(100);
            if (uart_peekc() >= 0)
                bootmenu();
        }
    } else
        bootmenu();
#endif

    // process bootflag if any
    em86xx_bootflag(config);
    
#ifdef CONFIG_ENABLE_BOOTMENU
    bootmenu();
#endif

    // default boot order
    doboot_romfs_rom(0);

    // boot failed if the control reaches here
    uart_puts("Boot failed\n");
    for (;;)
        ;
    
    return 0;
}

/* Return #MB of given DRAM bank */
static unsigned em86xx_dram_size(int bank)
{
#if 0
    register int count;
    unsigned long baddr = ((bank + 1) * 0x10000000);
    unsigned long addr1, addr2;

#ifdef CONFIG_ARCH_TANGO
    /* Only use bank 0 for Tango */
    if (bank != 0)
	return(0);
#endif

    baddr -= 4;
    addr1 = baddr + (1 << 20);
    *((volatile unsigned long *)addr1) = 0xde0000ad;
 
    /* 2MB-1024MB */
    for (count = 1; count <= 10; count++) {
        addr1 = baddr + (1 << (20 + count));
        addr2 = baddr + (1 << (20 + count + 1));
        *((volatile unsigned long *)addr2) = 0xde0000ad | 
				(((count + 1) << 16) | ((count + 1) << 8));
	if (*((volatile unsigned long *)addr1) == 
		*((volatile unsigned long *)addr2))
		break;
    }
    return(1 << count);
#else
#define MAXDRAM_SIZE    8   /* MAX 2^8 = 256MB */

    unsigned long pattern[MAXDRAM_SIZE + 1];
    unsigned long baddr = ((bank + 1) * 0x10000000);
    unsigned long caddr;
    register int i;
                                                                                
#ifdef CONFIG_ARCH_TANGO
    /* Only use bank 0 for Tango */
    if (bank != 0)
	    return(0);
#endif

    for (i = 0; i < MAXDRAM_SIZE + 1; i++) {
        pattern[i] = 0xde0000ad | (i << 8) | (i << 16);
        caddr = (0x00100000 << i) + baddr - sizeof(unsigned long);
        *((volatile unsigned long *)caddr) = pattern[i];
    }
                                                                                
    for (i = 0; i < MAXDRAM_SIZE + 1; i++) {
        caddr = (0x00100000 << i) + baddr - sizeof(unsigned long);
        if (*((volatile unsigned long *)caddr) != pattern[i])
            break;
    }
    return(1 << i); /* The real size is (0x00100000 << i) */
#endif
}

/* Base on given dram size, adjust the map accordingly */
static void adjust_memmap(unsigned dram_size)
{
    unsigned long loadaddr_skip = 0;    /* Size to skip after FMEM_START */
    unsigned long temp_size = 0;