static int env_sf_load(void) { int ret; char *buf = NULL; buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE); if (!buf) { set_default_env("!malloc() failed"); return -EIO; } ret = setup_flash_device(); if (ret) goto out; ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf); if (ret) { set_default_env("!spi_flash_read() failed"); goto err_read; } ret = env_import(buf, 1); if (!ret) gd->env_valid = ENV_VALID; err_read: spi_flash_free(env_flash); env_flash = NULL; out: free(buf); return ret; }
/* * In case we have restarted u-boot there is a chance that buffer * contains old environment (from the previous boot). * If UBI volume is zero size, ubi_volume_read() doesn't modify the * buffer. * We need to clear buffer manually here, so the invalid CRC will * cause setting default environment as expected. */ memset(env1_buf, 0x0, CONFIG_ENV_SIZE); memset(env2_buf, 0x0, CONFIG_ENV_SIZE); tmp_env1 = (env_t *)env1_buf; tmp_env2 = (env_t *)env2_buf; if (ubi_part(CONFIG_ENV_UBI_PART, NULL)) { printf("\n** Cannot find mtd partition \"%s\"\n", CONFIG_ENV_UBI_PART); set_default_env(NULL); return -EIO; } read1_fail = ubi_volume_read(CONFIG_ENV_UBI_VOLUME, (void *)tmp_env1, CONFIG_ENV_SIZE); if (read1_fail) printf("\n** Unable to read env from %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME); read2_fail = ubi_volume_read(CONFIG_ENV_UBI_VOLUME_REDUND, (void *)tmp_env2, CONFIG_ENV_SIZE); if (read2_fail) printf("\n** Unable to read redundant env from %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME_REDUND); return env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2, read2_fail); } #else /* ! CONFIG_SYS_REDUNDAND_ENVIRONMENT */ static int env_ubi_load(void) { ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); /* * In case we have restarted u-boot there is a chance that buffer * contains old environment (from the previous boot). * If UBI volume is zero size, ubi_volume_read() doesn't modify the * buffer. * We need to clear buffer manually here, so the invalid CRC will * cause setting default environment as expected. */ memset(buf, 0x0, CONFIG_ENV_SIZE); if (ubi_part(CONFIG_ENV_UBI_PART, NULL)) { printf("\n** Cannot find mtd partition \"%s\"\n", CONFIG_ENV_UBI_PART); set_default_env(NULL); return -EIO; } if (ubi_volume_read(CONFIG_ENV_UBI_VOLUME, buf, CONFIG_ENV_SIZE)) { printf("\n** Unable to read env from %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME); set_default_env(NULL); return -EIO; } return env_import(buf, 1); }
static void flash_env_relocate_spec(int workmode) { #if !defined(ENV_IS_EMBEDDED) char buf[CONFIG_ENV_SIZE]; u32 start; if((workmode & WORK_MODE_PRODUCT) && (!(workmode & WORK_MODE_UPDATE))) { flash_use_efex_env(); } else { start = sunxi_partition_get_offset_byname(CONFIG_SUNXI_ENV_PARTITION); if(!start){ printf("fail to find part named %s\n", CONFIG_SUNXI_ENV_PARTITION); use_default(); return; } if(!sunxi_flash_read(start, CONFIG_ENV_SIZE/512, buf)) { use_default(); return; } env_import(buf, 1); } #endif }
void env_relocate_spec(void) { #if !defined(ENV_IS_EMBEDDED) int crc1_ok = 0, crc2_ok = 0; env_t *ep, *tmp_env1, *tmp_env2; tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE); tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE); if (tmp_env1 == NULL || tmp_env2 == NULL) { puts("Can't allocate buffers for environment\n"); set_default_env("!malloc() failed"); goto done; } if (readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1)) puts("No Valid Environment Area found\n"); if (readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2)) puts("No Valid Redundant Environment Area found\n"); crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc; crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc; if (!crc1_ok && !crc2_ok) { set_default_env("!bad CRC"); goto done; } else if (crc1_ok && !crc2_ok) { gd->env_valid = 1; } else if (!crc1_ok && crc2_ok) { gd->env_valid = 2; } else { /* both ok - check serial */ if (tmp_env1->flags == 255 && tmp_env2->flags == 0) gd->env_valid = 2; else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) gd->env_valid = 1; else if (tmp_env1->flags > tmp_env2->flags) gd->env_valid = 1; else if (tmp_env2->flags > tmp_env1->flags) gd->env_valid = 2; else /* flags are equal - almost impossible */ gd->env_valid = 1; } free(env_ptr); if (gd->env_valid == 1) ep = tmp_env1; else ep = tmp_env2; env_flags = ep->flags; env_import((char *)ep, 0); done: free(tmp_env1); free(tmp_env2); #endif /* ! ENV_IS_EMBEDDED */ }
void spi_env_relocate_spec(void) { int ret; env_t env_buf; env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS, CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE); if (!env_flash) goto err_probe; ret = spi_flash_read(env_flash, CONFIG_ENV_IN_SPI_OFFSET, CONFIG_ENV_SIZE, &env_buf); if (ret) goto err_read; env_import(&env_buf, 1); gd->env_valid = 1; return; err_read: spi_flash_free(env_flash); env_flash = NULL; err_probe: //err_crc: set_default_env("!bad CRC"); }
void env_relocate_spec(void) { char buf[CONFIG_ENV_SIZE]; int ret; env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS, CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE); if (!env_flash) { set_default_env("!spi_flash_probe() failed"); return; } ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf); if (ret) { set_default_env("!spi_flash_read() failed"); goto out; } ret = env_import(buf, 1); if (ret) gd->env_valid = 1; out: spi_flash_free(env_flash); env_flash = NULL; }
void env_relocate_spec(void) { #if !defined(ENV_IS_EMBEDDED) block_dev_desc_t *sata = NULL; char buf[CONFIG_ENV_SIZE]; int ret; if (sata_curr_device == -1) { if (sata_initialize()) return; sata_curr_device = CONFIG_SATA_ENV_DEV; } if (sata_curr_device >= CONFIG_SYS_SATA_MAX_DEVICE) { printf("Unknown SATA(%d) device for environment!\n", sata_curr_device); return; } sata = sata_get_dev(sata_curr_device); if (read_env(sata, CONFIG_ENV_SIZE, CONFIG_ENV_OFFSET, buf)) return use_default(); ret = env_import(buf, 1); if (ret) gd->env_valid = 1; #endif }
void env_relocate_spec(void) { char buf[CONFIG_ENV_SIZE]; block_dev_desc_t *dev_desc = NULL; disk_partition_t info; int dev, part; int err; part = get_device_and_partition(FAT_ENV_INTERFACE, FAT_ENV_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) goto err_env_relocate; dev = dev_desc->dev; if (fat_set_blk_dev(dev_desc, &info) != 0) { printf("\n** Unable to use %s %d:%d for loading the env **\n", FAT_ENV_INTERFACE, dev, part); goto err_env_relocate; } err = file_fat_read(FAT_ENV_FILE, (uchar *)&buf, CONFIG_ENV_SIZE); if (err == -1) { printf("\n** Unable to read \"%s\" from %s%d:%d **\n", FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part); goto err_env_relocate; } env_import(buf, 1); return; err_env_relocate: set_default_env(NULL); }
void env_relocate_spec(void) { struct mtd_info *mtd = &onenand_mtd; #ifdef CONFIG_ENV_ADDR_FLEX struct onenand_chip *this = &onenand_chip; #endif int rc; size_t retlen; #ifdef ENV_IS_EMBEDDED char *buf = (char *)&environment[0]; #else loff_t env_addr = CONFIG_ENV_ADDR; char onenand_env[ONENAND_MAX_ENV_SIZE]; char *buf = (char *)&onenand_env[0]; #endif /* ENV_IS_EMBEDDED */ #ifndef ENV_IS_EMBEDDED # ifdef CONFIG_ENV_ADDR_FLEX if (FLEXONENAND(this)) env_addr = CONFIG_ENV_ADDR_FLEX; # endif /* Check OneNAND exist */ if (mtd->writesize) /* Ignore read fail */ mtd->read(mtd, env_addr, ONENAND_MAX_ENV_SIZE, &retlen, (u_char *)buf); else mtd->writesize = MAX_ONENAND_PAGESIZE; #endif /* !ENV_IS_EMBEDDED */ rc = env_import(buf, 1); if (rc) gd->env_valid = 1; }
/* both ok - check serial */ if (tmp_env1->flags == 255 && tmp_env2->flags == 0) gd->env_valid = 2; else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) gd->env_valid = 1; else if (tmp_env1->flags > tmp_env2->flags) gd->env_valid = 1; else if (tmp_env2->flags > tmp_env1->flags) gd->env_valid = 2; else /* flags are equal - almost impossible */ gd->env_valid = 1; } free(env_ptr); if (gd->env_valid == 1) ep = tmp_env1; else ep = tmp_env2; env_flags = ep->flags; env_import((char *)ep, 0); ret = 0; fini: fini_mmc_for_env(mmc); err: if (ret) set_default_env(NULL); #endif } #else /* ! CONFIG_ENV_OFFSET_REDUND */ void env_relocate_spec(void) { #if !defined(ENV_IS_EMBEDDED) ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV); u32 offset; int ret; if (init_mmc_for_env(mmc)) { ret = 1; goto err; } if (mmc_get_env_addr(mmc, 0, &offset)) { ret = 1; goto fini; } if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) { ret = 1; goto fini; } env_import(buf, 1); ret = 0; fini: fini_mmc_for_env(mmc); err: if (ret) set_default_env(NULL); #endif }
void env_relocate_spec(void) { #if !defined(ENV_IS_EMBEDDED) char buf[CONFIG_ENV_SIZE]; struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV); u32 offset; if (init_mmc_for_env(mmc)) { use_default(); return; } if(mmc_get_env_addr(mmc, &offset)) { use_default(); return ; } if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) { use_default(); return; } env_import(buf, 1); #endif }
void env_relocate_spec(void) { int ret; char *buf = NULL; buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE); env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS, CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE); if (!env_flash) { set_default_env("!spi_flash_probe() failed"); if (buf) free(buf); return; } ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf); if (ret) { set_default_env("!spi_flash_read() failed"); goto out; } ret = env_import(buf, 1); if (ret) gd->env_valid = 1; out: spi_flash_free(env_flash); if (buf) free(buf); env_flash = NULL; }
/* * The legacy NAND code saved the environment in the first NAND * device i.e., nand_dev_desc + 0. This is also the behaviour using * the new NAND code. */ void env_relocate_spec (void) { #if !defined(ENV_IS_EMBEDDED) int ret; char buf[CONFIG_ENV_SIZE]; #if defined(CONFIG_ENV_OFFSET_OOB) ret = get_nand_env_oob(&nand_info[0], &nand_env_oob_offset); /* * If unable to read environment offset from NAND OOB then fall through * to the normal environment reading code below */ if (!ret) { printf("Found Environment offset in OOB..\n"); } else { set_default_env("!no env offset in OOB"); return; } #endif ret = readenv(CONFIG_ENV_OFFSET, (u_char *)buf); if (ret) { set_default_env("!readenv() failed"); return; } env_import(buf, 1); #endif /* ! ENV_IS_EMBEDDED */ }
void env_relocate_spec(void) { char buf[CONFIG_ENV_SIZE]; read_dataflash(CONFIG_ENV_ADDR, CONFIG_ENV_SIZE, buf); env_import(buf, 1); }
void env_relocate_spec(void) { char buf[CONFIG_ENV_SIZE]; #if defined(CONFIG_SYS_NVRAM_ACCESS_ROUTINE) nvram_read(buf, CONFIG_ENV_ADDR, CONFIG_ENV_SIZE); #else memcpy(buf, (void*)CONFIG_ENV_ADDR, CONFIG_ENV_SIZE); #endif env_import(buf, 1); }
void env_relocate_spec(void) { char *buf; #if defined(CONFIG_SYS_NVRAM_ACCESS_ROUTINE) buf = env_buf; nvram_read(buf, CONFIG_ENV_ADDR, CONFIG_ENV_SIZE); #else buf = (void *)CONFIG_ENV_ADDR; #endif env_import(buf, 1); }
void real_main (int argc, char *const argv[]) { int i; /* TODO: handle -i */ env_import (); for (i = 1; i < argc && is_assignment (argv[i]); ++i) env_parse_assignment (argv[i]); if (i == argc) env_print (); else { env_export (); must_execvp (argv + i); } }
void env_relocate_spec(void) { char buf[CONFIG_ENV_SIZE]; unsigned int off = CONFIG_ENV_OFFSET; #ifdef CONFIG_ENV_OFFSET_REDUND if (gd->env_valid == 2) off = CONFIG_ENV_OFFSET_REDUND; #endif eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR, off, (uchar *)buf, CONFIG_ENV_SIZE); env_import(buf, 1); }
void env_relocate_spec(void) { int ret; char buf[CONFIG_ENV_SIZE]; env_t *tmp_env; tmp_env = (env_t*)buf; env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS, CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE); if (!env_flash) { set_default_env("!spi_flash_probe() failed"); return; } ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, tmp_env); if (ret) { set_default_env("!spi_flash_read() failed"); goto out; } if (crc32(0, tmp_env->data, ENV_SIZE) == tmp_env->crc) { gd->env_valid = 1; } else { ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND, CONFIG_ENV_SIZE, tmp_env); if (ret) { set_default_env("!spi_flash_read() failed"); goto out; } if (crc32(0, tmp_env->data, ENV_SIZE) != tmp_env->crc) { set_default_env("!both CRC failed"); goto out; } gd->env_valid = 2; } ret = env_import(buf, 0); if (!ret) { error("Cannot import environment: errno = %d\n", errno); set_default_env("env_import failed"); } out: spi_flash_free(env_flash); env_flash = NULL; }
static int env_ext4_load(void) { ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); struct blk_desc *dev_desc = NULL; disk_partition_t info; int dev, part; int err; loff_t off; #ifdef CONFIG_MMC if (!strcmp(CONFIG_ENV_EXT4_INTERFACE, "mmc")) mmc_initialize(NULL); #endif part = blk_get_device_part_str(CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) goto err_env_relocate; dev = dev_desc->devnum; ext4fs_set_blk_dev(dev_desc, &info); if (!ext4fs_mount(info.size)) { printf("\n** Unable to use %s %s for loading the env **\n", CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART); goto err_env_relocate; } err = ext4_read_file(CONFIG_ENV_EXT4_FILE, buf, 0, CONFIG_ENV_SIZE, &off); ext4fs_close(); if (err == -1) { printf("\n** Unable to read \"%s\" from %s%d:%d **\n", CONFIG_ENV_EXT4_FILE, CONFIG_ENV_EXT4_INTERFACE, dev, part); goto err_env_relocate; } return env_import(buf, 1); err_env_relocate: set_default_env(NULL, 0); return -EIO; }
void env_relocate_spec(void) #endif { #if !defined(ENV_IS_EMBEDDED) int ret; ALLOC_CACHE_ALIGN_BUFFER(u_char, buf, CONFIG_ENV_SIZE); ret = readenv(buf); if (ret) { set_default_env("!readenv() failed"); //saveenv(); return; } env_import((char *)buf, 1); #endif /* ! ENV_IS_EMBEDDED */ }
void env_relocate_spec(void) { #ifdef CONFIG_ENV_ADDR_REDUND if (gd->env_addr != (ulong)&(flash_addr->data)) { env_t *etmp = flash_addr; ulong ltmp = end_addr; flash_addr = flash_addr_new; flash_addr_new = etmp; end_addr = end_addr_new; end_addr_new = ltmp; } if (flash_addr_new->flags != OBSOLETE_FLAG && crc32(0, flash_addr_new->data, ENV_SIZE) == flash_addr_new->crc) { char flag = OBSOLETE_FLAG; gd->env_valid = 2; flash_sect_protect(0, (ulong)flash_addr_new, end_addr_new); flash_write(&flag, (ulong)&(flash_addr_new->flags), sizeof(flash_addr_new->flags)); flash_sect_protect(1, (ulong)flash_addr_new, end_addr_new); } if (flash_addr->flags != ACTIVE_FLAG && (flash_addr->flags & ACTIVE_FLAG) == ACTIVE_FLAG) { char flag = ACTIVE_FLAG; gd->env_valid = 2; flash_sect_protect(0, (ulong)flash_addr, end_addr); flash_write(&flag, (ulong)&(flash_addr->flags), sizeof(flash_addr->flags)); flash_sect_protect(1, (ulong)flash_addr, end_addr); } if (gd->env_valid == 2) puts ("*** Warning - some problems detected " "reading environment; recovered successfully\n\n"); #endif /* CONFIG_ENV_ADDR_REDUND */ env_import((char *)flash_addr, 1); }
void env_relocate_spec(void) { char buf[CONFIG_ENV_SIZE]; block_dev_desc_t *dev_desc = NULL; int dev = FAT_ENV_DEVICE; int part = FAT_ENV_PART; #ifdef CONFIG_MMC if (strcmp (FAT_ENV_INTERFACE, "mmc") == 0) { struct mmc *mmc = find_mmc_device(dev); if (!mmc) { printf("no mmc device at slot %x\n", dev); set_default_env(NULL); return; } mmc->has_init = 0; mmc_init(mmc); } #endif /* CONFIG_MMC */ dev_desc = get_dev(FAT_ENV_INTERFACE, dev); if (dev_desc == NULL) { printf("Failed to find %s%d\n", FAT_ENV_INTERFACE, dev); set_default_env(NULL); return; } if (fat_register_device(dev_desc, part) != 0) { printf("Failed to register %s%d:%d\n", FAT_ENV_INTERFACE, dev, part); set_default_env(NULL); return; } if (file_fat_read(FAT_ENV_FILE, (unsigned char *)&buf, CONFIG_ENV_SIZE) == -1) { printf("\n** Unable to read \"%s\" from %s%d:%d **\n", FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part); set_default_env(NULL); return; } env_import(buf, 1); }
/* both ok - check serial */ if (tmp_env1->flags == 255 && tmp_env2->flags == 0) gd->env_valid = 2; else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) gd->env_valid = 1; else if (tmp_env1->flags > tmp_env2->flags) gd->env_valid = 1; else if (tmp_env2->flags > tmp_env1->flags) gd->env_valid = 2; else /* flags are equal - almost impossible */ gd->env_valid = 1; } free(env_ptr); if (gd->env_valid == 1) ep = tmp_env1; else ep = tmp_env2; env_flags = ep->flags; env_import((char *)ep, 0); ret = 0; fini: fini_mmc_for_env(mmc); err: if (ret) set_default_env(errmsg); #endif } #else /* ! CONFIG_ENV_OFFSET_REDUND */ void env_relocate_spec(void) { #if !defined(ENV_IS_EMBEDDED) ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); struct mmc *mmc; u32 offset; int ret; int dev = mmc_get_env_dev(); const char *errmsg; #ifdef CONFIG_SPL_BUILD dev = 0; #endif mmc = find_mmc_device(dev); errmsg = init_mmc_for_env(mmc); if (errmsg) { ret = 1; goto err; } if (mmc_get_env_addr(mmc, 0, &offset)) { ret = 1; goto fini; } if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) { errmsg = "!read failed"; ret = 1; goto fini; } env_import(buf, 1); ret = 0; fini: fini_mmc_for_env(mmc); err: if (ret) set_default_env(errmsg); #endif }
static int env_fat_load(void) { ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); struct blk_desc *dev_desc = NULL; disk_partition_t info; int dev, part; int err; part = blk_get_device_part_str(CONFIG_ENV_FAT_INTERFACE, CONFIG_ENV_FAT_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) goto err_env_relocate; dev = dev_desc->devnum; if (fat_set_blk_dev(dev_desc, &info) != 0) { /* * This printf is embedded in the messages from env_save that * will calling it. The missing \n is intentional. */ printf("Unable to use %s %d:%d... ", CONFIG_ENV_FAT_INTERFACE, dev, part); goto err_env_relocate; } err = file_fat_read(CONFIG_ENV_FAT_FILE, buf, CONFIG_ENV_SIZE); if (err == -1) { /* * This printf is embedded in the messages from env_save that * will calling it. The missing \n is intentional. */ printf("Unable to read \"%s\" from %s%d:%d... ", CONFIG_ENV_FAT_FILE, CONFIG_ENV_FAT_INTERFACE, dev, part); goto err_env_relocate; } return env_import(buf, 1); err_env_relocate: set_default_env(NULL); return -EIO; }
void env_relocate_spec(void) { char buf[CONFIG_ENV_SIZE]; unsigned int err, rc; err = mg_disk_init(); if (err) { set_default_env("!mg_disk_init error"); return; } err = mg_disk_read(CONFIG_ENV_ADDR, buf, CONFIG_ENV_SIZE); if (err) { set_default_env("!mg_disk_read error"); return; } env_import(buf, 1); }
void env_relocate_spec(void) { ulong buf[(CONFIG_ENV_SIZE + 511) / 128]; unsigned int err, rc; err = init_sata(CONFIG_ENV_DEVICE); if (err) { set_default_env("!init_sata error"); return; } err = sata_read(CONFIG_ENV_DEVICE, CONFIG_ENV_ADDR, CONFIG_ENV_SIZE, buf); if (err) { set_default_env("!sata_read error"); return; } env_import(buf, 1); }
int env_import_redund(const char *buf1, const char *buf2) { int crc1_ok, crc2_ok; env_t *ep, *tmp_env1, *tmp_env2; tmp_env1 = (env_t *)buf1; tmp_env2 = (env_t *)buf2; crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc; crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc; if (!crc1_ok && !crc2_ok) { set_default_env("!bad CRC"); return 0; } else if (crc1_ok && !crc2_ok) { gd->env_valid = ENV_VALID; } else if (!crc1_ok && crc2_ok) { gd->env_valid = ENV_REDUND; } else { /* both ok - check serial */ if (tmp_env1->flags == 255 && tmp_env2->flags == 0) gd->env_valid = ENV_REDUND; else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) gd->env_valid = ENV_VALID; else if (tmp_env1->flags > tmp_env2->flags) gd->env_valid = ENV_VALID; else if (tmp_env2->flags > tmp_env1->flags) gd->env_valid = ENV_REDUND; else /* flags are equal - almost impossible */ gd->env_valid = ENV_VALID; } if (gd->env_valid == ENV_VALID) ep = tmp_env1; else ep = tmp_env2; env_flags = ep->flags; return env_import((char *)ep, 0); }
/* both ok - check serial */ if (tmp_env1->flags == 255 && tmp_env2->flags == 0) gd->env_valid = 2; else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) gd->env_valid = 1; else if (tmp_env1->flags > tmp_env2->flags) gd->env_valid = 1; else if (tmp_env2->flags > tmp_env1->flags) gd->env_valid = 2; else /* flags are equal - almost impossible */ gd->env_valid = 1; } if (gd->env_valid == 1) ep = tmp_env1; else ep = tmp_env2; env_flags = ep->flags; env_import((char *)ep, 0); } #else /* ! CONFIG_SYS_REDUNDAND_ENVIRONMENT */ void env_relocate_spec(void) { ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); if (ubi_part(CONFIG_ENV_UBI_PART, NULL)) { printf("\n** Cannot find mtd partition \"%s\"\n", CONFIG_ENV_UBI_PART); set_default_env(NULL); return; } if (ubi_volume_read(CONFIG_ENV_UBI_VOLUME, buf, CONFIG_ENV_SIZE)) { printf("\n** Unable to read env from %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME); set_default_env(NULL); return; } env_import(buf, 1); }
void env_relocate_spec(void) { #if !defined(ENV_IS_EMBEDDED) char buf[CONFIG_ENV_SIZE]; unsigned long offset; struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV); if (init_mmc_for_env(mmc)) { use_default(); return; } offset = find_mmc_env_offset(mmc); if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) { use_default(); return; } env_import(buf, 1); #endif }