/* * Check if CRC is valid and (if yes) import the environment. * Note that "buf" may or may not be aligned. */ int env_import(const char *buf, int check) { env_t *ep = (env_t *)buf; if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { set_default_env("!bad CRC"); return 0; }else if(ep->data[0] == 0xff){ printf("check env data = 0xff, set default env\n"); set_default_env("!check env data is 0xff"); saveenv(); return 0; } } if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0)) { gd->flags |= GD_FLG_ENV_READY; return 1; } error("Cannot import environment: errno = %d\n", errno); set_default_env("!import failed"); return 0; }
void env_relocate (void) { #if defined (CONFIG_VLSI_EMULATOR) set_default_env("!For emulator speed up"); #else #if defined(CONFIG_NEEDS_MANUAL_RELOC) extern void env_reloc(void); env_reloc(); #endif if (gd->env_valid == 0) { #if defined(CONFIG_ENV_IS_NOWHERE) /* Environment not changable */ set_default_env(NULL); #else show_boot_progress (-60); set_default_env("!bad CRC"); #endif } else { env_relocate_spec (); } #endif //#if !defined (CONFIG_VLSI_EMULATOR) #if defined(CONFIG_SILENT_CONSOLE) && \ defined(CONFIG_SILENT_CONSOLE_UPDATE_ON_RELOC) if (getenv("silent") != NULL) { puts("silenced by env\n"); gd->flags |= GD_FLG_SILENT; } else { gd->flags &= ~GD_FLG_SILENT; } #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; }
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 */ }
/* * Check if CRC is valid and (if yes) import the environment. * Note that "buf" may or may not be aligned. */ int env_import(const char *buf, int check) { env_t *ep = (env_t *)buf; if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { set_default_env("!bad CRC"); return 0; } } if (himport((char *)ep->data, ENV_SIZE, '\0', 0)) { gd->flags |= GD_FLG_ENV_READY; return 1; } error("Cannot import environment: errno = %d\n", errno); set_default_env("!import failed"); return 0; }
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; }
/* * 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 int setup_flash_device(void) { #ifdef CONFIG_DM_SPI_FLASH struct udevice *new; int ret; /* speed and mode will be read from DT */ ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS, 0, 0, &new); if (ret) { set_default_env("!spi_flash_probe_bus_cs() failed"); return ret; } env_flash = dev_get_uclass_priv(new); #else if (!env_flash) { 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 -EIO; } } #endif return 0; }
/* * 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 */ }
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; }
/* * Check if CRC is valid and (if yes) import the environment. * Note that "buf" may or may not be aligned. */ int env_import(const char *buf, int check) { env_t *ep = (env_t *)buf; if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { set_default_env("bad CRC", 0); return -EIO; } } if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0, 0, NULL)) { gd->flags |= GD_FLG_ENV_READY; return 0; } pr_err("Cannot import environment: errno = %d\n", errno); set_default_env("import failed", 0); return -EIO; }
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; }
void env_relocate(void) { #if defined(CONFIG_NEEDS_MANUAL_RELOC) env_reloc(); #endif if (gd->env_valid == 0) { #if defined(CONFIG_ENV_IS_NOWHERE) /* Environment not changable */ set_default_env(NULL); #else bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM); set_default_env("!bad CRC"); #endif } else { env_relocate_spec(); } }
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) { int ret; //printf("+env_relocate_spec/spi_flash_probe=%d,%d,%d,%d\n\r",CONFIG_ENV_SPI_BUS,CONFIG_ENV_SPI_CS,CONFIG_ENV_SPI_MAX_HZ,CONFIG_ENV_SPI_MODE); 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_OFFSET, CONFIG_ENV_SIZE, env_ptr); if (ret) goto err_read; if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc) goto err_crc; gd->env_valid = 1; return; err_read: spi_flash_free(env_flash); env_flash = NULL; err_probe: err_crc: puts("*** Warning - bad CRC, using default environment\n\n"); set_default_env(); }
void env_relocate(void) { #if defined(CONFIG_NEEDS_MANUAL_RELOC) env_reloc(); #endif if (gd->env_valid == 0) { #if defined(CONFIG_ENV_IS_NOWHERE) /* Environment not changable */ set_default_env(NULL); #else show_boot_progress(-60); set_default_env("!bad CRC"); #endif } else { env_relocate_spec(); } }
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) { #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) || mmc_get_env_addr(mmc, &offset)) return set_default_env(NULL); if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) return set_default_env(NULL); env_import(buf, 1); #endif }
static int initr_env(void) { /* initialize environment */ if (should_load_env()) env_relocate(); else set_default_env(NULL); #ifdef CONFIG_OF_CONTROL setenv_addr("fdtcontroladdr", gd->fdt_blob); #endif /* Initialize from environment */ load_addr = getenv_ulong("loadaddr", 16, load_addr); #if defined(CONFIG_SYS_EXTBDINFO) #if defined(CONFIG_405GP) || defined(CONFIG_405EP) #if defined(CONFIG_I2CFAST) /* * set bi_iic_fast for linux taking environment variable * "i2cfast" into account */ { char *s = getenv("i2cfast"); if (s && ((*s == 'y') || (*s == 'Y'))) { gd->bd->bi_iic_fast[0] = 1; gd->bd->bi_iic_fast[1] = 1; } } #endif /* CONFIG_I2CFAST */ #endif /* CONFIG_405GP, CONFIG_405EP */ #endif /* CONFIG_SYS_EXTBDINFO */ return 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; } 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 (void) { DEBUGF ("%s[%d] offset = 0x%lx\n", __FUNCTION__,__LINE__, gd->reloc_off); env_ptr = (env_t *)mALLOc (CONFIG_ENV_SIZE); DEBUGF ("%s[%d] malloced ENV at %p\n", __FUNCTION__,__LINE__,env_ptr); set_env_funcptrs() ; (*env_init)() ; if (gd->env_valid == 0) { #if defined(CONFIG_GTH) || defined(CONFIG_ENV_IS_NOWHERE) /* Environment not changable */ puts ("Using default environment\n\n"); #else //puts ("*** Warning - bad CRC, using default environment\n\n"); puts ("*** We do not have environment varialbes stored in the booting storgage, so we using default environment\n\n"); //show_boot_progress (-60); #endif set_default_env(); } else { printf(" Finding the environment variables in boot storage...\n") ; (*env_relocate_spec)(); } gd->env_addr = (ulong)&(env_ptr->data); }
static int do_env_default(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { if ((argc != 2) || (strcmp(argv[1], "-f") != 0)) return cmd_usage(cmdtp); set_default_env("## Resetting to default environment\n"); return 0; }
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); }
void env_relocate(void) { #if defined(CONFIG_NEEDS_MANUAL_RELOC) env_reloc(); env_htab.change_ok += gd->reloc_off; #endif if (gd->env_valid == ENV_INVALID) { #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD) /* Environment not changable */ set_default_env(NULL); #else bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM); set_default_env("!bad CRC"); #endif } else { env_load(); } }
static int do_env_default(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { if (argc != 2 || strcmp(argv[1], "-f") != 0) return CMD_RET_USAGE; set_default_env("## Resetting to default environment\n"); return 0; }
void env_relocate (void) { unsigned char initEthAddr = 0; DEBUGF ("%s[%d] offset = 0x%lx\n", __FUNCTION__,__LINE__, gd->reloc_off); #ifdef CONFIG_AMIGAONEG3SE enable_nvram(); #endif #ifdef ENV_IS_EMBEDDED /* * The environment buffer is embedded with the text segment, * just relocate the environment pointer */ env_ptr = (env_t *)((ulong)env_ptr + gd->reloc_off); DEBUGF ("%s[%d] embedded ENV at %p\n", __FUNCTION__,__LINE__,env_ptr); #else /* * We must allocate a buffer for the environment */ env_ptr = (env_t *)malloc (CONFIG_ENV_SIZE); DEBUGF ("%s[%d] malloced ENV at %p\n", __FUNCTION__,__LINE__,env_ptr); #endif if (gd->env_valid == 0) { #if defined(CONFIG_GTH) || defined(CONFIG_ENV_IS_NOWHERE) /* Environment not changable */ puts ("Using default environment\n\n"); #else puts ("*** Warning - bad CRC, using default environment\n\n"); show_boot_progress (-60); #endif set_default_env(); initEthAddr = 1; } else { env_relocate_spec (); } gd->env_addr = (ulong)&(env_ptr->data); #ifdef CONFIG_AMIGAONEG3SE disable_nvram(); #endif if (initEthAddr) { const char * ethaddr = getenv("ethaddr"); if (ethaddr == 0L) { extern const char * env_read_backup_mac(void ); ethaddr = env_read_backup_mac(); if (ethaddr != 0L && strlen(ethaddr) == 17) { setenv("ethaddr", ethaddr); } } } }
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); }
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); }
int env_relocate_r(void) { /* initialize environment */ if (should_load_env()) env_relocate(); else set_default_env(NULL); return 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); }