boot.c

1. 8623L平台

		default:
			uart_printf("Inavalid section identifier found at 0x%08lx\n", newaddr-3);
			return 0;
 	    }
	}
	memcfg_ptr->dram0_removable_topreserved = top_removable_size;
	gen_memcfg_checksum(memcfg_ptr); /* Compute and set the checksum value */
    }
    return 1;
}

int doload_romfs_bitmap(char *name, 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(name, loadaddr, romfs_addr, romfs_addr + 0x00040000, 1);
    if (len != 0)
	    return(doload_bitmap(loadaddr, len, 1));
#endif

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

#ifdef CONFIG_ENABLE_UCODES
int doload_ucode(unsigned int loadaddr, unsigned int len, int docksum)
{
	unsigned int checksum = 0;
	unsigned int dest;
	
	if (docksum != 0)
		checksum = binfile_crc_check((void *)loadaddr, len);
	
	if (checksum != 0)
		return 0;

	dest = DRAM0_BASE + memcfg_ptr->dram0_size - len;
	uart_printf(copy_msg, loadaddr, dest, len, len);
        memcpy((void *)UNCACHED(dest), (void *)(loadaddr), len);
	
	memcfg_ptr->dram0_fixed_topreserved = len;
	gen_memcfg_checksum(memcfg_ptr); /* Compute and set the checksum value */
		
	return 1;
}

int doload_romfs_ucode(char *name, 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(name, loadaddr, romfs_addr, romfs_addr + 0x00040000, 1);
    if (len != 0)
	    return(doload_ucode(loadaddr, len, 1));
#endif

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

#ifdef CONFIG_ENABLE_DVI
int doload_dvi(unsigned int loadaddr, unsigned int len, int docksum)
{
	unsigned int checksum = 0;
	unsigned int *newaddr = (unsigned int *)(loadaddr);
	struct i2c i2c_info;
	RMstatus err;
	
	if (docksum != 0)
		checksum = binfile_crc_check((void *)loadaddr, len);
	
	if (checksum != 0)
		return 0;

	i2c_info.pGBus = (struct gbus *) 1;
	i2c_info.RegBase = REG_BASE_SYSTEM;
	i2c_info.PioClock = (unsigned char)*newaddr; newaddr++;
	i2c_info.PioData = (unsigned char)*newaddr; newaddr++;
	i2c_info.DelayUs = ((unsigned long)*newaddr) & 0xffff; newaddr++; 
	i2c_info.WrAddr = (unsigned char)*newaddr; newaddr++;
	i2c_info.RdAddr = (unsigned char)*newaddr; newaddr++;
	
	while (newaddr  < (unsigned int *) (loadaddr + len - 4)) {
		unsigned char addr, val;

		addr = (unsigned char)*newaddr; newaddr++;
		val = (unsigned char)*newaddr; newaddr++;

		err = I2C_Write(&i2c_info, addr, &val, 1);
		if (RMFAILED(err)) {
			uart_printf("I2C_Write fails: addr: 0x%02x, val: 0x%02x\n", addr, val);
			return 0;
		}
	}

	return 1;
}

int doload_romfs_dvi(char *name, 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(name, loadaddr, romfs_addr, romfs_addr + 0x00040000, 1);
    if (len != 0)
	    return(doload_dvi(loadaddr, len, 1));
#endif

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

#ifdef CONFIG_ENABLE_FULLFUNCTION
int doboot_romfs_ram(unsigned int loadaddr)
{
    unsigned int addr = loadaddr ? loadaddr : loadaddr_kernelfs;

    if (boot_romfs(addr, loadaddr_romfs, loadaddr_kernelfs)) {
        uart_printf("Boot kernel at 0x%08x with ROMFS at 0x%08lx\n", addr, loadaddr_romfs);
        do_boot(addr);
    }

    return 0;
}
#endif

#ifdef CONFIG_ENABLE_IDE

//
// Boot from IDE device
//

int doboot_ide(int drive, int part, int subpart, unsigned int loadaddr)
{
    unsigned int addr = loadaddr ? loadaddr : 0;
    int doboot = 0, type;
    image_infoblock_t info;

    type = ide_check_image(drive, part, subpart, &info);

    switch (type) {
    case IMAGE_TYPE_NONE :
        uart_puts("No bootable image found\n");
        break;
    case IMAGE_TYPE_KERNEL :
        if (addr == 0)
            addr = loadaddr_kernel;
        uart_printf("Loading kernel from IDE device, size = %dKB\n", info.u.len >> 10);
        if (ide_read_image(type, drive, part, subpart, (unsigned char *) addr)) 
            uart_puts("Failed to load kernel image\n");
        else {
            doboot = 1;
            uart_printf("Boot kernel at 0x%08x with IDE\n", addr);
        }
        break;
    case IMAGE_TYPE_ROMFS :
        if (addr == 0)
            addr = loadaddr_kernelfs;
        uart_printf("Loading ROMFS from IDE device, size = %dKB\n", info.u.len >> 10);
        if (ide_read_image(type, drive, part, subpart, (unsigned char *) loadaddr_romfs))
            uart_puts("Failed to load romfs image\n");
        else {
            if (boot_romfs(addr, loadaddr_romfs, addr)) {
                doboot = 1;
                uart_printf("Boot kernel at 0x%08x with ROMFS at 0x%08lx\n", addr, loadaddr_romfs);
            }
        }
        break;
    }

    if (doboot)
        do_boot(addr);

    return doboot;
}

int doboot_idedisk(unsigned int loadaddr)
{
    int drive, drives, part;

    if ((drives = ide_found(IDE_ATA)) == 0) {
        ide_probe(0x03, 0);
        drives = ide_found(IDE_ATA);
    }

    if (drives == 0) {
        uart_puts("No IDE device found\n");
        return 0;
    }
    
    for (drive = 0; drive < MAX_DRIVES; ++drive) {
        if (drives & (1 << drive)) {
            if (ide_probe_image(drive, &part, NULL) != IMAGE_TYPE_NONE) {
                uart_printf("Found bootable image at drive %d partition %d\n", drive, part);
                doboot_ide(drive, part, 0, loadaddr);
            }
        }
    }

    uart_puts("No bootable image found\n");

    return 0;
}

int doboot_cd(int drive, unsigned int loadaddr)
{
	if (loadaddr == 0)
		loadaddr = loadaddr_kernel;

	if (bootcd_load_image(drive, loadaddr, NULL) == 0)
		do_boot(loadaddr);

    return 0;
}

int doboot_idecd(unsigned int loadaddr)
{
	int drive, drives;

    if ((drives = ide_found(IDE_ATAPI)) == 0) {
        ide_probe(IDE_ALL, 0);
        drives = ide_found(IDE_ATAPI);
    }

    if (drives == 0) {
        uart_puts("No ATAPI device found\n");
        return 0;
    }
    
    for (drive = 0; drive < MAX_DRIVES; ++drive) {
        if (drives & (1 << drive)) {
			if (doboot_cd(drive, loadaddr))
				break;
		}
	}

	return 0;
}

#endif

#ifdef CONFIG_ENABLE_NETWORK

//
// Boot from Network
//

int doboot_net(unsigned loadaddr, char *filename)
{
    extern int bootmenu_net_up(int force);

    int len;
    char *fname;

    if (loadaddr == 0)
        loadaddr = loadaddr_kernel;

    if (bootmenu_net_up(0) != 0)
        return 0;
    if (!ipv4_ipaddr_valid(g_bootconfig.server)) {
        uart_puts("Server address is invalid\n");
        return 0;
    }

    if (filename != NULL)
	fname = filename;
    else
	fname = g_bootconfig.kernel_filename;
	
    if (ipv4_tftp(g_bootconfig.server, fname, loadaddr, &len) == 0) {
        uart_printf("Loaded kernel to 0x%08x, size = %d bytes\n", loadaddr, len);
        do_boot(loadaddr);
    }
    
    return 0;
}

#endif