main.c.bak

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

    unsigned long boot_size = 0x100000; /* 1MB, fixed */
    unsigned long heap_unzip_size = 0;
    unsigned long heap_size = 0;
    unsigned long total_size = 0;       /* Total size we want to use for
                                           temp+boot+heap_unzip+heap */
    loadaddr_initrd = loadaddr_kernel = loadaddr_romfs = FMEM_START + 0x00010000;
    loadaddr_kernelfs = FMEM_START + 0x00200000;
    
    /* To display the DRAM mapping, define the line below */
#if 0
#define ASSIGN(addr, value)                         \
    (addr) = (value);                               \
    uart_printf( "%24s = 0x%08lx\n", #addr, value)
#else
#define ASSIGN(addr, value)                         \
    (addr) = (value)
#endif
    
    /* Typical values for  64MB 48MB 32MB 16MB
     * loadaddr_skip   =   11MB  9MB  6MB  3MB
     * total_size      =   42MB 31MB 20MB 10MB
     * boot_size       =    1MB  1MB  1MB  1MB
     * heap_unzip_size =   16MB 12MB  7MB  3MB
     * heap_size       =    8MB  6MB  3MB  1MB
     * temp_size       =   17MB 12MB  9MB  5MB
     */
    ASSIGN(loadaddr_skip, ((dram_size / 6 + 1) << 20));
#ifdef ENABLE_ENCRYPTED_OPT_ROM
    ASSIGN(loadaddr_skip, ENCRYPTED_OPT_DRAM_SIZE);
#endif

    /* Use 80 % of available memory */
    ASSIGN(total_size, (((dram_size << 20) - loadaddr_skip) * 4  / 5) & ~(0xFFFFF));
    /* Heap for unzip takes 40 % of total_size */
    ASSIGN(heap_unzip_size, ((total_size - boot_size) * 2 / 5) & ~(0xFFFFF));
    ASSIGN(heap_size, heap_unzip_size / 2);
    ASSIGN(temp_size, total_size - heap_unzip_size - heap_size - boot_size);
    ASSIGN(loadaddr_temp, FMEM_START + loadaddr_skip);
    ASSIGN(loadaddr_boot, loadaddr_temp + temp_size);
    ASSIGN(loadaddr_heap_unzip, loadaddr_boot + boot_size);
    ASSIGN(loadaddr_heap_start, loadaddr_heap_unzip + heap_size);
    ASSIGN(loadaddr_heap_end, loadaddr_heap_start + heap_size);
    ASSIGN(loadaddr_pci_start, loadaddr_heap_start);
#ifdef CONFIG_ENABLE_2NDBOOT
    ASSIGN(loadaddr_2ndboot, loadaddr_boot + boot_size / 2);
#endif
#ifdef CONFIG_ENABLE_IRQHANDLER
    ASSIGN(loadaddr_irqhandler, DRAM0_BASE + FM_IRQHANDLER_CODE);
#endif
#ifdef CONFIG_ENABLE_BITMAPS
    ASSIGN(loadaddr_bitmap, loadaddr_heap_end);
#endif
#ifdef CONFIG_ENABLE_UCODES
    ASSIGN(loadaddr_ucode, loadaddr_heap_end);
#endif
#ifdef CONFIG_ENABLE_USERPREF
    ASSIGN(loadaddr_userpref, loadaddr_heap_end);
#endif
#ifdef CONFIG_ENABLE_VSYNCPARAM
    ASSIGN(loadaddr_vsyncparam, DRAM0_BASE + FM_IRQHANDLER_API);
#endif
#ifdef CONFIG_ENABLE_DVI
    ASSIGN(loadaddr_dvi, loadaddr_heap_end);
#endif
} 

loaderconfig_t *em86xx_bootconfig(void)
{
    loaderconfig_t *config = (loaderconfig_t *) LOADER_CONFIGADDR;
    unsigned int data;

    if (config->signature == LOADER_CONFIGSIGN) {
        // PCI configuration
        if ((config->configvalid & CONFIGVALID_PCISUBID) && config->pci_subsystem_id)
            __raw_writel(config->pci_subsystem_id, REG_BASE_HOST + PCI_devcfg_reg2);

        if ((config->configvalid & CONFIGVALID_PCIREVID) && config->pci_revision_id) {
            data = __raw_readl(REG_BASE_HOST + PCI_devcfg_reg1);
            data &= 0xffffff00;
            data |= config->pci_revision_id;
            __raw_writel(data, REG_BASE_HOST + PCI_devcfg_reg1);
        }

        if ((config->configvalid & CONFIGVALID_PCIMEMSIZE) && config->pci_memory_size) {
            data = __raw_readl(REG_BASE_HOST + PCI_devcfg_reg3);
            data &= 0xfffffff8;
            data |= config->pci_memory_size;
            __raw_writel(data, REG_BASE_HOST + PCI_devcfg_reg3);
        }

        // set PCI configuration valid bit
        __raw_writel(0x00010000, REG_BASE_HOST + PCI_host_host_reg2);

        return config;
    }

    return NULL;
}

void em86xx_bootflag(loaderconfig_t *config)
{
#if defined(CONFIG_ENABLE_FIP) && defined(CONFIG_ENABLE_IDE)
    unsigned long key = 0L;
#endif

    int i;
    int vsyncparm_loaded = 0;

    /* to avoid compilation warning */
    i = 0;

    if (config == NULL)
        return;

#ifdef CONFIG_ENABLE_FIP
    fip_init();

#ifdef CONFIG_ENABLE_IDE
    /* Check to see if the correct key is pressed from VFD when */
    /* bootloader starts. If so, activate the sequence of booting CD */
    for (i = 0; (i < 3) && (key == 0L); i++) {
        em86xx_msleep(100);     /* Wait for 100msec */
        key = fip_readkey();
    }

    if (key == FIP_KEY_PLAYPAUSE) { /* Booting from CD */
        fip_write_text(0, fiptext = "CDBOOT", FIP_CENTER);
#ifdef CONFIG_ENABLE_CRYPTO
        doboot_idecd_crypt(0);
#else
        doboot_idecd(0);
#endif
        fip_clear();
    } else if (key == FIP_KEY_EJECT) { /* Ejecting the CD */
        ide_cdrom_eject(0, key);
    } 
#else
    fip_clear();
#endif
#endif
    do {
        int i;
        unsigned int media, flag = config->bootflag >> 2;

        for (i = 0; i < 3; ++i) {
            media = flag & BOOTFLAG_MEDIA_MASK;

            /* First, if booting from flash, load irq, vsync, ucode and bitmap if required */
            if ((media == BOOTFLAG_MEDIA_FLASH || media == (BOOTFLAG_MEDIA_FLASH|BOOTFLAG_MEDIA_CRYPT)) &&
                (config->bootflag & BOOTFLAG_LOAD(BOOTFLAG_LOAD_MASK))){
#ifdef CONFIG_ENABLE_UCODES
                if ((config->bootflag & BOOTFLAG_LOAD(BOOTFLAG_LOAD_UCODE))) {
                    uart_puts("Loading ucodes ..\n");
#ifdef CONFIG_ENABLE_CRYPTO
                    i = doload_romfs_ucode_crypt(FMEM_START + 0x00010000);
#else
                    i = doload_romfs_ucode(DEFAULT_UCODE_FILENAME, FMEM_START + 0x00010000);
#endif
                    if (i == 0)
                        uart_puts("Loading ucode failed.\n");
                }
#endif
#if defined(CONFIG_ENABLE_FLASH) && defined(CONFIG_ENABLE_VSYNCPARAM)
                if ((config->bootflag & BOOTFLAG_LOAD(BOOTFLAG_LOAD_VSYNCPARAM))) {
                    uart_puts("Loading vsync parameters ..\n");
#ifdef CONFIG_ENABLE_CRYPTO
                    i = doload_romfs_vsyncparam_crypt(loadaddr_vsyncparam);
#else
                    i = load_romfs_file(DEFAULT_VSYNCPARAM_FILENAME, loadaddr_vsyncparam, LOADER_FLASH_ROMFSADDR, LOADER_FLASH_ROMFSADDR + 0x00040000, 1);
                    if (i == 0) { /* cannot find vsyncparm in romfs */
                        uart_puts(DEFAULT_VSYNCPARAM_FILENAME " not found in romfs, load from flash instead.\n");
                        i = doload_vsyncparam(loadaddr_vsyncparam, 1);
                    }
#endif
                    if (i == 0) {
                        uart_puts("Loading vsyncparam failed.\n");
                        vsyncparm_loaded = 0;
                    } else
                        vsyncparm_loaded = 1;
                } 
#else
                vsyncparm_loaded = 0;
#endif
#ifdef CONFIG_ENABLE_BITMAPS
                if ((config->bootflag & BOOTFLAG_LOAD(BOOTFLAG_LOAD_BITMAP))) {
                    uart_puts("Loading bitmaps ..\n");
                    i = doload_romfs_bitmap(DEFAULT_IMAGE_FILENAME, FMEM_START + 0x00010000);
                    if (i == 0)
                        uart_puts("Loading bitmap failed.\n");
                }
#endif
#ifdef CONFIG_ENABLE_DVI
		if ((config->bootflag & BOOTFLAG_LOAD(BOOTFLAG_LOAD_DVI))) {
		    uart_puts("configuring silicon image for DVI output ..\n");
		    i = doload_romfs_dvi(DEFAULT_DVI_FILENAME, FMEM_START + 0x00010000);
		    if (i == 0)
		        uart_puts("Loading dvi failed.\n");
		}
#endif
#ifdef CONFIG_ENABLE_IRQHANDLER
                if ((config->bootflag & BOOTFLAG_LOAD(BOOTFLAG_LOAD_IRQHANDLER))) { 
                    uart_puts("Loading/Installing IRQ handler ..\n");
                    if (vsyncparm_loaded == 0) {
                        uart_puts("No VSYNC parameters loaded: blank structure.\n");
                        memset((void *)loadaddr_vsyncparam, 0, MAX_USERPREF_SIZE/2);
                    }
#ifdef CONFIG_ENABLE_CRYPTO
                    i = doload_romfs_irqhandler_crypt(loadaddr_irqhandler);
#else
                    i = doload_romfs_irqhandler(loadaddr_irqhandler);
#endif
                    if (i == 0)
                        uart_puts("Loading irqhandler failed.\n");
                }
#endif 
#if defined(CONFIG_ENABLE_IRQHANDLER) && defined(CONFIG_ENABLE_BITMAPS) && defined(CONFIG_ENABLE_USERPREF) && defined (CONFIG_ENABLE_VSYNCPARAM)
                // Calling board specific initialization routine for screen.
                board_splashscreen_init();
#endif
            }


            switch (media) {
            case BOOTFLAG_MEDIA_NONE :
                break;
            case BOOTFLAG_MEDIA_FLASH :
                doboot_romfs_rom(0);
                break;
#ifdef CONFIG_ENABLE_CRYPTO
            case BOOTFLAG_MEDIA_FLASH|BOOTFLAG_MEDIA_CRYPT:
                doboot_romfs_rom_crypt(0);
                break;
#endif // CONFIG_ENABLE_CRYPTO
#ifdef CONFIG_ENABLE_IDE
            case BOOTFLAG_MEDIA_HDD :
                doboot_idedisk(0);
                break;
            case BOOTFLAG_MEDIA_CD :
                doboot_idecd(0);
                break;
#ifdef CONFIG_ENABLE_CRYPTO
            case BOOTFLAG_MEDIA_CD|BOOTFLAG_MEDIA_CRYPT:
                doboot_idecd_crypt(0);
                break;
#endif // CONFIG_ENABLE_CRYPTO
#endif // CONFIG_ENABLE_IDE
#ifdef CONFIG_ENABLE_NETWORK
            case BOOTFLAG_MEDIA_NETWORK :
#ifdef CONFIG_ENABLE_CRYPTO
            case BOOTFLAG_MEDIA_NETWORK|BOOTFLAG_MEDIA_CRYPT:
#endif
                // initialize heap
                heap_init((void *)loadaddr_heap_start, loadaddr_heap_end - loadaddr_heap_start);
                download_init();

#if defined(CONFIG_ENABLE_PCIHOST_EM86XX)
                pci_init(&g_pciem86xx_op, 1);
#elif defined(CONFIG_ENABLE_PCIHOST_FPGA)
                pci_init(&g_pcifpga_op, 1);
#endif
                net_init();
                net_dev_up();

#ifdef CONFIG_ENABLE_CRYPTO
                if (media & BOOTFLAG_MEDIA_CRYPT)
                    doboot_net_crypt(0, NULL);
                else
                    doboot_net(0, NULL);
#else
                doboot_net(0, NULL);
#endif // CONFIG_ENABLE_CRYPTO
                break;
#endif
            case BOOTFLAG_MEDIA_NOP :
                for (;;)
                    ;
                break;
            }
            
            flag >>= BOOTFLAG_MEDIA_BITS;
        }

#ifdef CONFIG_ENABLE_BOOTMENU
        if (uart_peekc() >= 0)  /* Key pressed, break out the loop */
            break;
        em86xx_msleep(100);     /* Wait for 100ms */
#endif
    } while (config->bootflag & BOOTFLAG_RETRY);
}

#ifndef CONFIG_RELEASE
int build_kernel_param_tag(void)
{
    struct tag_header *hdr = (struct tag_header *)KERNEL_PARAMS;
    char cmdline[256];

    cmdline[0] = 0;
    
/*
    loaderconfig_t *config;
    int dramsize;

    config = em86xx_bootconfig();
    if (config) {
        dramsize = CONFIG_GETDRAMSIZE(config->dram_size, 0);
        sprintf(cmdline, "mem=%dM ", dramsize);
    }
*/

    if (g_bootconfig.kernel_cmdline[0] != 0)
        strcat(cmdline, g_bootconfig.kernel_cmdline);

#ifdef ENABLE_ENCRYPTED_OPT_ROM
    if (strlen(cmdline)+strlen(CRYPTO_KERNEL_CMDLINE)+2 < BOOTCONFIG_KERNELPARAMLEN){
        strcat(cmdline, " ");
        strcat(cmdline, CRYPTO_KERNEL_CMDLINE);
    }else{
        uart_printf("Warning, kernel command line is too big, not updated\n");
    }
#endif

    if (cmdline[0] != 0) {
        /* Add last \0, header size and rounds to 4 bytes */
        hdr->size = (strlen(cmdline) + 1 + sizeof(struct tag_header) + 3) >> 2;
        hdr->tag = ATAG_CMDLINE;
        strcpy((unsigned char *) hdr + sizeof(struct tag_header), cmdline);
        hdr = (struct tag_header *) ((unsigned char *) hdr + (hdr->size << 2));
    }

    hdr->size = 0;
    hdr->tag = ATAG_NONE;

    return 0;
}
#endif

#ifdef CONFIG_ARCH_TANGO15
static void set_mac_address(unsigned long mac_lo, unsigned mac_hi)
{
    unsigned long cksum;
    const unsigned char marker = 'M';

    cksum = ((mac_lo & 0xff) + ((mac_lo >> 8) & 0xff) + ((mac_lo >> 16) & 0xff) + ((mac_lo >> 24) & 0xff) +
             (mac_hi & 0xff) + ((mac_hi >> 8) & 0xff)) & 0xff;
    
    __raw_writel(mac_lo, REG_BASE_CPU + LR_ETH_MAC_LO);
    __raw_writel((mac_hi & 0xffff) | ((marker & 0xff) << 16) | (cksum << 24), REG_BASE_CPU + LR_ETH_MAC_HI);
}
#endif

/* vim:set shiftwidth=4 tabstop=8 expandtab: */