static int spl_nor_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { int ret; /* * Loading of the payload to SDRAM is done with skipping of * the mkimage header in this SPL NOR driver */ spl_image->flags |= SPL_COPY_PAYLOAD_ONLY; #ifdef CONFIG_SPL_OS_BOOT if (!spl_start_uboot()) { const struct image_header *header; /* * Load Linux from its location in NOR flash to its defined * location in SDRAM */ header = (const struct image_header *)CONFIG_SYS_OS_BASE; if (image_get_os(header) == IH_OS_LINUX) { /* happy - was a Linux */ ret = spl_parse_image_header(spl_image, header); if (ret) return ret; memcpy((void *)spl_image->load_addr, (void *)(CONFIG_SYS_OS_BASE + sizeof(struct image_header)), spl_image->size); spl_image->arg = (void *)CONFIG_SYS_FDT_BASE; return 0; } else { puts("The Expected Linux image was not found.\n" "Please check your NOR configuration.\n" "Trying to start u-boot now...\n"); } } #endif /* * Load real U-Boot from its location in NOR flash to its * defined location in SDRAM */ ret = spl_parse_image_header(spl_image, (const struct image_header *)CONFIG_SYS_UBOOT_BASE); if (ret) return ret; memcpy((void *)(unsigned long)spl_image->load_addr, (void *)(CONFIG_SYS_UBOOT_BASE + sizeof(struct image_header)), spl_image->size); return 0; }
void spl_nor_load_image(void) { /* * Loading of the payload to SDRAM is done with skipping of * the mkimage header in this SPL NOR driver */ spl_image.flags |= SPL_COPY_PAYLOAD_ONLY; #ifdef CONFIG_SPL_OS_BOOT if (!spl_start_uboot()) { const struct image_header *header; /* * Load Linux from its location in NOR flash to its defined * location in SDRAM */ header = (const struct image_header *)CONFIG_SYS_OS_BASE; if (image_get_os(header) == IH_OS_LINUX) { /* happy - was a Linux */ spl_parse_image_header(header); memcpy((void *)spl_image.load_addr, (void *)(CONFIG_SYS_OS_BASE + sizeof(struct image_header)), spl_image.size); /* * Copy DT blob (fdt) to SDRAM. Passing pointer to * flash doesn't work (16 KiB should be enough for DT) */ memcpy((void *)CONFIG_SYS_SPL_ARGS_ADDR, (void *)(CONFIG_SYS_FDT_BASE), (16 << 10)); return; } else { puts("The Expected Linux image was not found.\n" "Please check your NOR configuration.\n" "Trying to start u-boot now...\n"); } } #endif /* * Load real U-Boot from its location in NOR flash to its * defined location in SDRAM */ spl_parse_image_header( (const struct image_header *)CONFIG_SYS_UBOOT_BASE); memcpy((void *)spl_image.load_addr, (void *)(CONFIG_SYS_UBOOT_BASE + sizeof(struct image_header)), spl_image.size); }
/* * The main entry for SPI booting. It's necessary that SDRAM is already * configured and available since this code loads the main U-Boot image * from SPI into SDRAM and starts it from there. */ void spl_spi_load_image(void) { struct spi_flash *flash; struct image_header *header; /* * Load U-Boot image from SPI flash into RAM */ flash = spi_flash_probe(CONFIG_SPL_SPI_BUS, CONFIG_SPL_SPI_CS, CONFIG_SF_DEFAULT_SPEED, SPI_MODE_3); if (!flash) { puts("SPI probe failed.\n"); hang(); } /* use CONFIG_SYS_TEXT_BASE as temporary storage area */ header = (struct image_header *)(CONFIG_SYS_TEXT_BASE); /* Load u-boot, mkimage header is 64 bytes. */ spi_flash_read(flash, CONFIG_SYS_SPI_U_BOOT_OFFS, 0x40, (void *) header); spl_parse_image_header(header); spi_flash_read(flash, CONFIG_SYS_SPI_U_BOOT_OFFS, spl_image.size, (void *)spl_image.load_addr); }
static int mmc_load_image_raw(struct mmc *mmc, unsigned long sector) { unsigned long err; u32 image_size_sectors; struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); /* read image header to find the image size & load address */ err = mmc->block_dev.block_read(0, sector, 1, header); if (err == 0) goto end; if (image_get_magic(header) != IH_MAGIC) return -1; spl_parse_image_header(header); /* convert size to sectors - round up */ image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) / mmc->read_bl_len; /* Read the header too to avoid extra memcpy */ err = mmc->block_dev.block_read(0, sector, image_size_sectors, (void *)spl_image.load_addr); end: #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT if (err == 0) printf("spl: mmc blk read err - %lu\n", err); #endif return (err == 0); }
void spl_ymodem_load_image(void) { int size = 0; int err; int res; int ret; connection_info_t info; char buf[BUF_SIZE]; ulong store_addr = ~0; ulong addr = 0; info.mode = xyzModem_ymodem; ret = xyzModem_stream_open(&info, &err); if (!ret) { while ((res = xyzModem_stream_read(buf, BUF_SIZE, &err)) > 0) { if (addr == 0) spl_parse_image_header((struct image_header *)buf); store_addr = addr + spl_image.load_addr; size += res; addr += res; memcpy((char *)(store_addr), buf, res); WATCHDOG_RESET(); //add by QWB } } else { printf("spl: ymodem err - %s\n", xyzModem_error(err)); hang(); } xyzModem_stream_close(&err); xyzModem_stream_terminate(false, &getcymodem); printf("Loaded %d bytes\n", size); }
static int mmc_load_image_ext(struct mmc *mmc, const char *filename) { int err; struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); err = ext4_read_file(filename, header, 0, sizeof(struct image_header)); if (err <= 0) goto end; spl_parse_image_header(header); err = ext4_read_file(filename, (u8 *)spl_image.load_addr, 0, 0); end: if (err <= 0) printf("spl: error reading image %s, err - %d\n", filename, err); else printf("loading %s from MMC EXT...\n", filename); return (err <= 0); }
static void mmc_load_image_raw(struct mmc *mmc) { unsigned long err; u32 image_size_sectors; struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); /* read image header to find the image size & load address */ err = mmc->block_dev.block_read(0, CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR, 1, header); if (err == 0) goto end; spl_parse_image_header(header); /* convert size to sectors - round up */ image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) / mmc->read_bl_len; /* Read the header too to avoid extra memcpy */ err = mmc->block_dev.block_read(0, CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR, image_size_sectors, (void *)spl_image.load_addr); end: if (err == 0) { printf("spl: mmc blk read err - %lu\n", err); hang(); } }
static int spl_nand_load_element(int offset, struct image_header *header) { int err; err = nand_spl_load_image(offset, sizeof(*header), (void *)header); if (err) return err; if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.dev = NULL; load.priv = NULL; load.filename = NULL; load.bl_len = 1; load.read = spl_nand_fit_read; return spl_load_simple_fit(&load, offset, header); } else { err = spl_parse_image_header(header); if (err) return err; return nand_spl_load_image(offset, spl_image.size, (void *)(ulong)spl_image.load_addr); } }
static int mmc_load_image_fat_os(struct mmc *mmc) { int err; struct image_header *header; err = file_fat_read(spl_image.args, (void *)spl_image.args_addr, 0); if (err <= 0) { printf("spl: error reading image %s, err - %d\n", spl_image.args, err); goto end; } header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); err = file_fat_read(spl_image.args, header, sizeof(struct image_header)); if (err <= 0) goto end; spl_parse_image_header(header); return mmc_load_image_fat(mmc, spl_image.os_image); end: return err; }
static void mmc_load_image_fat(struct mmc *mmc) { int err; struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); err = fat_register_device(&mmc->block_dev, CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION); if (err) { printf("spl: fat register err - %d\n", err); hang(); } err = file_fat_read(CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME, header, sizeof(struct image_header)); if (err <= 0) goto end; spl_parse_image_header(header); err = file_fat_read(CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME, (u8 *)spl_image.load_addr, 0); end: if (err <= 0) { printf("spl: error reading image %s, err - %d\n", CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME, err); hang(); } }
static int mmc_load_image_fat(struct mmc *mmc, const char *filename) { int err; struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); err = file_fat_read(filename, header, sizeof(struct image_header)); if (err <= 0) goto end; spl_parse_image_header(header); err = file_fat_read(filename, (u8 *)spl_image.load_addr, 0); end: #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT if (err <= 0) printf("spl: error reading image %s, err - %d\n", filename, err); #endif return (err <= 0); }
static int spl_ram_load_image(void) { struct image_header *header; header = (struct image_header *)CONFIG_SPL_LOAD_FIT_ADDRESS; if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.bl_len = 1; load.read = spl_ram_load_read; spl_load_simple_fit(&load, 0, header); } else { debug("Legacy image\n"); /* * Get the header. It will point to an address defined by * handoff which will tell where the image located inside * the flash. For now, it will temporary fixed to address * pointed by U-Boot. */ header = (struct image_header *) (CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); spl_parse_image_header(header); } return 0; }
void spl_spi_load_image(void) { struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE); spl_parse_image_header(header); spi_load(CONFIG_SPL_PAD_TO, CONFIG_SYS_MONITOR_LEN, CONFIG_SYS_TEXT_BASE); }
int spl_load_image_ext(struct spl_image_info *spl_image, struct blk_desc *block_dev, int partition, const char *filename) { s32 err; struct image_header *header; loff_t filelen, actlen; disk_partition_t part_info = {}; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); if (part_get_info(block_dev, partition, &part_info)) { printf("spl: no partition table found\n"); return -1; } ext4fs_set_blk_dev(block_dev, &part_info); err = ext4fs_mount(0); if (!err) { #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT printf("%s: ext4fs mount err - %d\n", __func__, err); #endif goto end; } err = ext4fs_open(filename, &filelen); if (err < 0) { puts("spl: ext4fs_open failed\n"); goto end; } err = ext4fs_read((char *)header, 0, sizeof(struct image_header), &actlen); if (err < 0) { puts("spl: ext4fs_read failed\n"); goto end; } err = spl_parse_image_header(spl_image, header); if (err < 0) { puts("spl: ext: failed to parse image header\n"); goto end; } err = ext4fs_read((char *)spl_image->load_addr, 0, filelen, &actlen); end: #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT if (err < 0) printf("%s: error reading image %s, err - %d\n", __func__, filename, err); #endif return err < 0; }
void spl_nor_load_image(void) { /* * Loading of the payload to SDRAM is done with skipping of * the mkimage header in this SPL NOR driver */ spl_image.flags |= SPL_COPY_PAYLOAD_ONLY; if (spl_start_uboot()) { /* * Load real U-Boot from its location in NOR flash to its * defined location in SDRAM */ spl_parse_image_header( (const struct image_header *)CONFIG_SYS_UBOOT_BASE); memcpy((void *)spl_image.load_addr, (void *)(CONFIG_SYS_UBOOT_BASE + sizeof(struct image_header)), spl_image.size); } else { /* * Load Linux from its location in NOR flash to its defined * location in SDRAM */ spl_parse_image_header( (const struct image_header *)CONFIG_SYS_OS_BASE); memcpy((void *)spl_image.load_addr, (void *)(CONFIG_SYS_OS_BASE + sizeof(struct image_header)), spl_image.size); /* * Copy DT blob (fdt) to SDRAM. Passing pointer to flash * doesn't work (16 KiB should be enough for DT) */ memcpy((void *)CONFIG_SYS_SPL_ARGS_ADDR, (void *)(CONFIG_SYS_FDT_BASE), (16 << 10)); } }
void spl_nand_load_image(void) { struct image_header *header; switch (omap_boot_mode()) { case NAND_MODE_HW_ECC: debug("spl: nand - using hw ecc\n"); gpmc_init(); nand_init(); break; default: puts("spl: ERROR: This bootmode is not implemented - hanging"); hang(); } /*use CONFIG_SYS_TEXT_BASE as temporary storage area */ header = (struct image_header *)(CONFIG_SYS_TEXT_BASE); #ifdef CONFIG_NAND_ENV_DST nand_spl_load_image(CONFIG_ENV_OFFSET, CONFIG_SYS_NAND_PAGE_SIZE, (void *)header); spl_parse_image_header(header); nand_spl_load_image(CONFIG_ENV_OFFSET, spl_image.size, (void *)image_load_addr); #ifdef CONFIG_ENV_OFFSET_REDUND nand_spl_load_image(CONFIG_ENV_OFFSET_REDUND, CONFIG_SYS_NAND_PAGE_SIZE, (void *)header); spl_parse_image_header(header); nand_spl_load_image(CONFIG_ENV_OFFSET_REDUND, spl_image.size, (void *)image_load_addr); #endif #endif /* Load u-boot */ nand_spl_load_image(CONFIG_SYS_NAND_U_BOOT_OFFS, CONFIG_SYS_NAND_PAGE_SIZE, (void *)header); spl_parse_image_header(header); nand_spl_load_image(CONFIG_SYS_NAND_U_BOOT_OFFS, spl_image.size, (void *)spl_image.load_addr); nand_deselect(); }
static void spl_ram_load_image(void) { const struct image_header *header; /* * Get the header. It will point to an address defined by handoff * which will tell where the image located inside the flash. For * now, it will temporary fixed to address pointed by U-Boot. */ header = (struct image_header *) (CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); spl_parse_image_header(header); }
int spl_load_image_fat(struct spl_image_info *spl_image, struct blk_desc *block_dev, int partition, const char *filename) { int err; struct image_header *header; err = spl_register_fat_device(block_dev, partition); if (err) goto end; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); err = file_fat_read(filename, header, sizeof(struct image_header)); if (err <= 0) goto end; if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.read = spl_fit_read; load.bl_len = 1; load.filename = (void *)filename; load.priv = NULL; return spl_load_simple_fit(spl_image, &load, 0, header); } else { err = spl_parse_image_header(spl_image, header); if (err) goto end; err = file_fat_read(filename, (u8 *)(uintptr_t)spl_image->load_addr, 0); } end: #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT if (err <= 0) printf("%s: error reading image %s, err - %d\n", __func__, filename, err); #endif return (err <= 0); }
static int spl_ram_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { struct image_header *header; header = (struct image_header *)CONFIG_SPL_LOAD_FIT_ADDRESS; #if CONFIG_IS_ENABLED(DFU_SUPPORT) if (bootdev->boot_device == BOOT_DEVICE_DFU) spl_dfu_cmd(0, "dfu_alt_info_ram", "ram", "0"); #endif if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.bl_len = 1; load.read = spl_ram_load_read; spl_load_simple_fit(spl_image, &load, 0, header); } else { ulong u_boot_pos = binman_sym(ulong, u_boot_any, pos); debug("Legacy image\n"); /* * Get the header. It will point to an address defined by * handoff which will tell where the image located inside * the flash. */ debug("u_boot_pos = %lx\n", u_boot_pos); if (u_boot_pos == BINMAN_SYM_MISSING) { /* * No binman support or no information. For now, fix it * to the address pointed to by U-Boot. */ u_boot_pos = CONFIG_SYS_TEXT_BASE - sizeof(struct image_header); } header = (struct image_header *)map_sysmem(u_boot_pos, 0); spl_parse_image_header(spl_image, header); } return 0; }
static int spl_net_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { struct image_header *header = (struct image_header *)load_addr; int rv; env_init(); env_relocate(); env_set("autoload", "yes"); rv = eth_initialize(); if (rv == 0) { printf("No Ethernet devices found\n"); return -ENODEV; } if (bootdev->boot_device_name) env_set("ethact", bootdev->boot_device_name); rv = net_loop(BOOTP); if (rv < 0) { printf("Problem booting with BOOTP\n"); return rv; } if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.bl_len = 1; load.read = spl_net_load_read; rv = spl_load_simple_fit(spl_image, &load, 0, header); } else { debug("Legacy image\n"); rv = spl_parse_image_header(spl_image, header); if (rv) return rv; memcpy((void *)spl_image->load_addr, header, spl_image->size); } return rv; }
int spl_net_load_image(const char *device) { struct image_header *header; int rv; env_init(); env_relocate(); setenv("autoload", "yes"); if (IS_ENABLED(CONFIG_SPL_LOAD_FIT)) load_addr = CONFIG_SPL_LOAD_FIT_ADDRESS; else load_addr = CONFIG_SYS_TEXT_BASE - sizeof(struct image_header); rv = eth_initialize(); if (rv == 0) { printf("No Ethernet devices found\n"); return -ENODEV; } if (device) setenv("ethact", device); rv = net_loop(BOOTP); if (rv < 0) { printf("Problem booting with BOOTP\n"); return rv; } header = (struct image_header *)load_addr; if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT\n"); load.bl_len = 1; load.read = spl_net_load_read; spl_load_simple_fit(&load, 0, header); } else { spl_parse_image_header((struct image_header *)load_addr); } return 0; }
static int spl_onenand_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { struct image_header *header; int ret; debug("spl: onenand\n"); header = spl_get_load_buffer(0, CONFIG_SYS_ONENAND_PAGE_SIZE); /* Load u-boot */ onenand_spl_load_image(CONFIG_SYS_ONENAND_U_BOOT_OFFS, CONFIG_SYS_ONENAND_PAGE_SIZE, (void *)header); ret = spl_parse_image_header(spl_image, header); if (ret) return ret; onenand_spl_load_image(CONFIG_SYS_ONENAND_U_BOOT_OFFS, spl_image->size, (void *)spl_image->load_addr); return 0; }
static int spl_spi_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { int err; struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE); spi0_init(); spi0_read_data((void *)header, CONFIG_SYS_SPI_U_BOOT_OFFS, 0x40); err = spl_parse_image_header(spl_image, header); if (err) return err; spi0_read_data((void *)spl_image->load_addr, CONFIG_SYS_SPI_U_BOOT_OFFS, spl_image->size); spi0_deinit(); return 0; }
void spl_eth_load_image(void) { int rv; env_init(); env_relocate(); setenv("autoload", "yes"); load_addr = CONFIG_SYS_TEXT_BASE - sizeof(struct image_header); rv = eth_initialize(gd->bd); if (rv == 0) { printf("No Ethernet devices found\n"); hang(); } rv = NetLoop(BOOTP); if (rv < 0) { printf("Problem booting with BOOTP\n"); hang(); } spl_parse_image_header((struct image_header *)load_addr); }
static void mmc_load_image_fat(struct mmc *mmc) { s32 err; struct image_header *header; char *payloadname; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); err = fat_register_device(&mmc->block_dev, CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION); if (err) { printf("spl: fat register err - %d\n", err); hang(); } payloadname = CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME; err = file_fat_read(payloadname, (u8 *)header, sizeof(struct image_header)); if (err <= 0) { payloadname = "u-boot.bin"; err = file_fat_read(payloadname, (u8 *)header, sizeof(struct image_header)); if (err <= 0) { goto end; } } spl_parse_image_header(header); err = file_fat_read(payloadname, (u8 *)spl_image.load_addr, 0); end: if (err <= 0) { printf("spl: error reading image %s, err - %d\n", payloadname, err); hang(); } }
static int spl_spi_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { int ret = 0; struct image_header *header; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE); spi0_init(); spi0_read_data((void *)header, CONFIG_SYS_SPI_U_BOOT_OFFS, 0x40); if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && image_get_magic(header) == FDT_MAGIC) { struct spl_load_info load; debug("Found FIT image\n"); load.dev = NULL; load.priv = NULL; load.filename = NULL; load.bl_len = 1; load.read = spi_load_read; ret = spl_load_simple_fit(spl_image, &load, CONFIG_SYS_SPI_U_BOOT_OFFS, header); } else { ret = spl_parse_image_header(spl_image, header); if (ret) return ret; spi0_read_data((void *)spl_image->load_addr, CONFIG_SYS_SPI_U_BOOT_OFFS, spl_image->size); } spi0_deinit(); return ret; }
int spl_nand_load_image(void) { int err; struct image_header *header; int *src __attribute__((unused)); int *dst __attribute__((unused)); #ifdef CONFIG_SPL_NAND_SOFTECC debug("spl: nand - using sw ecc\n"); #else debug("spl: nand - using hw ecc\n"); #endif nand_init(); /*use CONFIG_SYS_TEXT_BASE as temporary storage area */ header = (struct image_header *)(CONFIG_SYS_TEXT_BASE); #ifdef CONFIG_SPL_OS_BOOT if (!spl_start_uboot()) { /* * load parameter image * load to temp position since nand_spl_load_image reads * a whole block which is typically larger than * CONFIG_CMD_SPL_WRITE_SIZE therefore may overwrite * following sections like BSS */ nand_spl_load_image(CONFIG_CMD_SPL_NAND_OFS, CONFIG_CMD_SPL_WRITE_SIZE, (void *)CONFIG_SYS_TEXT_BASE); /* copy to destintion */ for (dst = (int *)CONFIG_SYS_SPL_ARGS_ADDR, src = (int *)CONFIG_SYS_TEXT_BASE; src < (int *)(CONFIG_SYS_TEXT_BASE + CONFIG_CMD_SPL_WRITE_SIZE); src++, dst++) { writel(readl(src), dst); } /* load linux */ nand_spl_load_image(CONFIG_SYS_NAND_SPL_KERNEL_OFFS, sizeof(*header), (void *)header); err = spl_parse_image_header(header); if (err) return err; if (header->ih_os == IH_OS_LINUX) { /* happy - was a linux */ err = nand_spl_load_image( CONFIG_SYS_NAND_SPL_KERNEL_OFFS, spl_image.size, (void *)spl_image.load_addr); nand_deselect(); return err; } else { puts("The Expected Linux image was not " "found. Please check your NAND " "configuration.\n"); puts("Trying to start u-boot now...\n"); } } #endif #ifdef CONFIG_NAND_ENV_DST spl_nand_load_element(CONFIG_ENV_OFFSET, header); #ifdef CONFIG_ENV_OFFSET_REDUND spl_nand_load_element(CONFIG_ENV_OFFSET_REDUND, header); #endif #endif /* Load u-boot */ err = spl_nand_load_element(CONFIG_SYS_NAND_U_BOOT_OFFS, header); nand_deselect(); return err; }
int spl_ubi_load_image(struct spl_image_info *spl_image, struct spl_boot_device *bootdev) { struct image_header *header; struct ubispl_info info; struct ubispl_load volumes[2]; int ret = 1; switch (bootdev->boot_device) { #ifdef CONFIG_SPL_NAND_SUPPORT case BOOT_DEVICE_NAND: nand_init(); info.read = nand_spl_read_block; info.peb_size = CONFIG_SYS_NAND_BLOCK_SIZE; break; #endif #ifdef CONFIG_SPL_ONENAND_SUPPORT case BOOT_DEVICE_ONENAND: info.read = onenand_spl_read_block; info.peb_size = CONFIG_SYS_ONENAND_BLOCK_SIZE; break; #endif default: goto out; } info.ubi = (struct ubi_scan_info *)CONFIG_SPL_UBI_INFO_ADDR; info.fastmap = 1; info.peb_offset = CONFIG_SPL_UBI_PEB_OFFSET; info.vid_offset = CONFIG_SPL_UBI_VID_OFFSET; info.leb_start = CONFIG_SPL_UBI_LEB_START; info.peb_count = CONFIG_SPL_UBI_MAX_PEBS - info.peb_offset; #ifdef CONFIG_SPL_OS_BOOT if (!spl_start_uboot()) { volumes[0].vol_id = CONFIG_SPL_UBI_LOAD_KERNEL_ID; volumes[0].load_addr = (void *)CONFIG_SYS_LOAD_ADDR; volumes[1].vol_id = CONFIG_SPL_UBI_LOAD_ARGS_ID; volumes[1].load_addr = (void *)CONFIG_SYS_SPL_ARGS_ADDR; ret = ubispl_load_volumes(&info, volumes, 2); if (!ret) { header = (struct image_header *)volumes[0].load_addr; spl_parse_image_header(spl_image, header); puts("Linux loaded.\n"); goto out; } puts("Loading Linux failed, falling back to U-Boot.\n"); } #endif header = (struct image_header *) (CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); volumes[0].vol_id = CONFIG_SPL_UBI_LOAD_MONITOR_ID; volumes[0].load_addr = (void *)header; ret = ubispl_load_volumes(&info, volumes, 1); if (!ret) spl_parse_image_header(spl_image, header); out: #ifdef CONFIG_SPL_NAND_SUPPORT if (bootdev->boot_device == BOOT_DEVICE_NAND) nand_deselect(); #endif return ret; }