static int env_sata_save(void) { ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); struct blk_desc *sata = NULL; int env_sata, ret; if (sata_initialize()) return 1; env_sata = sata_get_env_dev(); sata = sata_get_dev(env_sata); if (sata == NULL) { printf("Unknown SATA(%d) device for environment!\n", env_sata); return 1; } ret = env_export(env_new); if (ret) return 1; printf("Writing to SATA(%d)...", env_sata); if (write_env(sata, CONFIG_ENV_SIZE, CONFIG_ENV_OFFSET, &env_new)) { puts("failed\n"); return 1; } puts("done\n"); return 0; }
/* * (c) Copyright 2012 by National Instruments, * Joe Hershberger <*****@*****.**> */ #include <common.h> #include <command.h> #include <environment.h> #include <errno.h> #include <malloc.h> #include <memalign.h> #include <search.h> #include <ubi_uboot.h> #undef crc32 DECLARE_GLOBAL_DATA_PTR; #ifdef CONFIG_CMD_SAVEENV #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT static int env_ubi_save(void) { ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); int ret; ret = env_export(env_new); if (ret) return ret; if (ubi_part(CONFIG_ENV_UBI_PART, NULL)) { printf("\n** Cannot find mtd partition \"%s\"\n", CONFIG_ENV_UBI_PART); return 1; } if (gd->env_valid == ENV_VALID) { puts("Writing to redundant UBI... "); if (ubi_volume_write(CONFIG_ENV_UBI_VOLUME_REDUND, (void *)env_new, CONFIG_ENV_SIZE)) { printf("\n** Unable to write env to %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME_REDUND); return 1; } } else { puts("Writing to UBI... "); if (ubi_volume_write(CONFIG_ENV_UBI_VOLUME, (void *)env_new, CONFIG_ENV_SIZE)) { printf("\n** Unable to write env to %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME); return 1; } } puts("done\n"); gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND; return 0; } #else /* ! CONFIG_SYS_REDUNDAND_ENVIRONMENT */ static int env_ubi_save(void) { ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); int ret; ret = env_export(env_new); if (ret) return ret; if (ubi_part(CONFIG_ENV_UBI_PART, NULL)) { printf("\n** Cannot find mtd partition \"%s\"\n", CONFIG_ENV_UBI_PART); return 1; } if (ubi_volume_write(CONFIG_ENV_UBI_VOLUME, (void *)env_new, CONFIG_ENV_SIZE)) { printf("\n** Unable to write env to %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME); return 1; } puts("done\n"); return 0; }
int saveenv(void) { env_t env_new; block_dev_desc_t *dev_desc = NULL; disk_partition_t info; int dev, part; int err; err = env_export(&env_new); if (err) return err; part = get_device_and_partition(FAT_ENV_INTERFACE, FAT_ENV_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; if (fat_set_blk_dev(dev_desc, &info) != 0) { printf("\n** Unable to use %s %d:%d for saveenv **\n", FAT_ENV_INTERFACE, dev, part); return 1; } err = file_fat_write(FAT_ENV_FILE, (void *)&env_new, sizeof(env_t)); if (err == -1) { printf("\n** Unable to write \"%s\" from %s%d:%d **\n", FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part); return 1; } puts("done\n"); return 0; }
static int env_sf_save(void) { u32 saved_size, saved_offset, sector; char *saved_buffer = NULL; int ret = 1; env_t env_new; ret = setup_flash_device(); if (ret) return ret; /* Is the sector larger than the env (i.e. embedded) */ if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE; saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE; saved_buffer = malloc(saved_size); if (!saved_buffer) goto done; ret = spi_flash_read(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } ret = env_export(&env_new); if (ret) goto done; sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE); puts("Erasing SPI flash..."); ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET, sector * CONFIG_ENV_SECT_SIZE); if (ret) goto done; puts("Writing to SPI flash..."); ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, &env_new); if (ret) goto done; if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { ret = spi_flash_write(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } ret = 0; puts("done\n"); done: if (saved_buffer) free(saved_buffer); return ret; }
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); } }
int saveenv(void) #endif { int ret = 0; ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); ret = env_export(env_new); if (ret) return ret; ret = amlnf_env_save((u_char *)env_new, CONFIG_ENV_SIZE); return ret; }
int saveenv(void) { ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); int dev = mmc_get_env_dev(); struct mmc *mmc = find_mmc_device(dev); u32 offset; int ret, copy = 0; const char *errmsg; errmsg = init_mmc_for_env(mmc); if (errmsg) { printf("%s\n", errmsg); return 1; } ret = env_export(env_new); if (ret) goto fini; #ifdef CONFIG_ENV_OFFSET_REDUND env_new->flags = ++env_flags; /* increase the serial */ if (gd->env_valid == 1) copy = 1; #endif if (mmc_get_env_addr(mmc, copy, &offset)) { ret = 1; goto fini; } printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev); if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) { puts("failed\n"); ret = 1; goto fini; } puts("done\n"); ret = 0; #ifdef CONFIG_ENV_OFFSET_REDUND gd->env_valid = gd->env_valid == 2 ? 1 : 2; #endif fini: fini_mmc_for_env(mmc); return ret; }
int saveenv(void) { env_t env_new; int rcode = 0; rcode = env_export(&env_new); if (rcode) return rcode; #ifdef CONFIG_SYS_NVRAM_ACCESS_ROUTINE nvram_write(CONFIG_ENV_ADDR, &env_new, CONFIG_ENV_SIZE); #else if (memcpy((char *)CONFIG_ENV_ADDR, &env_new, CONFIG_ENV_SIZE) == NULL) rcode = 1; #endif return rcode; }
static int env_fat_save(void) { env_t __aligned(ARCH_DMA_MINALIGN) env_new; struct blk_desc *dev_desc = NULL; disk_partition_t info; int dev, part; int err; loff_t size; err = env_export(&env_new); if (err) return err; part = blk_get_device_part_str(CONFIG_ENV_FAT_INTERFACE, CONFIG_ENV_FAT_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) return 1; 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); return 1; } err = file_fat_write(CONFIG_ENV_FAT_FILE, (void *)&env_new, 0, sizeof(env_t), &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 write \"%s\" from %s%d:%d... ", CONFIG_ENV_FAT_FILE, CONFIG_ENV_FAT_INTERFACE, dev, part); return 1; } return 0; }
int saveenv(void) { ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); int ret; ret = env_export(env_new); if (ret) return ret; if (ubi_part(CONFIG_ENV_UBI_PART, NULL)) { printf("\n** Cannot find mtd partition \"%s\"\n", CONFIG_ENV_UBI_PART); return 1; } env_new->flags = ++env_flags; /* increase the serial */ if (gd->env_valid == 1) { puts("Writing to redundant UBI... "); if (ubi_volume_write(CONFIG_ENV_UBI_VOLUME_REDUND, (void *)env_new, CONFIG_ENV_SIZE)) { printf("\n** Unable to write env to %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME_REDUND); return 1; } } else { puts("Writing to UBI... "); if (ubi_volume_write(CONFIG_ENV_UBI_VOLUME, (void *)env_new, CONFIG_ENV_SIZE)) { printf("\n** Unable to write env to %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME); return 1; } } puts("done\n"); gd->env_valid = gd->env_valid == 2 ? 1 : 2; return 0; }
static int env_ext4_save(void) { env_t env_new; struct blk_desc *dev_desc = NULL; disk_partition_t info; int dev, part; int err; err = env_export(&env_new); if (err) return err; part = blk_get_device_part_str(CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->devnum; ext4fs_set_blk_dev(dev_desc, &info); if (!ext4fs_mount(info.size)) { printf("\n** Unable to use %s %s for saveenv **\n", CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART); return 1; } err = ext4fs_write(CONFIG_ENV_EXT4_FILE, (void *)&env_new, sizeof(env_t)); ext4fs_close(); if (err == -1) { printf("\n** Unable to write \"%s\" from %s%d:%d **\n", CONFIG_ENV_EXT4_FILE, CONFIG_ENV_EXT4_INTERFACE, dev, part); return 1; } puts("done\n"); return 0; }
static int env_onenand_save(void) { env_t env_new; int ret; struct mtd_info *mtd = &onenand_mtd; #ifdef CONFIG_ENV_ADDR_FLEX struct onenand_chip *this = &onenand_chip; #endif loff_t env_addr = CONFIG_ENV_ADDR; size_t retlen; struct erase_info instr = { .callback = NULL, }; ret = env_export(&env_new); if (ret) return ret; instr.len = CONFIG_ENV_SIZE; #ifdef CONFIG_ENV_ADDR_FLEX if (FLEXONENAND(this)) { env_addr = CONFIG_ENV_ADDR_FLEX; instr.len = CONFIG_ENV_SIZE_FLEX; instr.len <<= onenand_mtd.eraseregions[0].numblocks == 1 ? 1 : 0; } #endif instr.addr = env_addr; instr.mtd = mtd; if (mtd_erase(mtd, &instr)) { printf("OneNAND: erase failed at 0x%08llx\n", env_addr); return 1; } if (mtd_write(mtd, env_addr, ONENAND_MAX_ENV_SIZE, &retlen, (u_char *)&env_new)) { printf("OneNAND: write failed at 0x%llx\n", instr.addr); return 2; } return 0; }
int saveenv(void) { env_t env_new; int rc; unsigned int off = CONFIG_ENV_OFFSET; #ifdef CONFIG_ENV_OFFSET_REDUND unsigned int off_red = CONFIG_ENV_OFFSET_REDUND; char flag_obsolete = OBSOLETE_FLAG; #endif BUG_ON(env_ptr != NULL); rc = env_export(&env_new); if (rc) return rc; #ifdef CONFIG_ENV_OFFSET_REDUND if (gd->env_valid == 1) { off = CONFIG_ENV_OFFSET_REDUND; off_red = CONFIG_ENV_OFFSET; } env_new.flags = ACTIVE_FLAG; #endif rc = eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR, off, (uchar *)&env_new, CONFIG_ENV_SIZE); #ifdef CONFIG_ENV_OFFSET_REDUND if (rc == 0) { eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR, off_red + offsetof(env_t, flags), (uchar *)&flag_obsolete, 1); if (gd->env_valid == 1) gd->env_valid = 2; else gd->env_valid = 1; } #endif return rc; }
static int env_ubi_save(void) { ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); int ret; ret = env_export(env_new); if (ret) return ret; if (ubi_part(CONFIG_ENV_UBI_PART, NULL)) { printf("\n** Cannot find mtd partition \"%s\"\n", CONFIG_ENV_UBI_PART); return 1; } if (gd->env_valid == ENV_VALID) { puts("Writing to redundant UBI... "); if (ubi_volume_write(CONFIG_ENV_UBI_VOLUME_REDUND, (void *)env_new, CONFIG_ENV_SIZE)) { printf("\n** Unable to write env to %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME_REDUND); return 1; } } else { puts("Writing to UBI... "); if (ubi_volume_write(CONFIG_ENV_UBI_VOLUME, (void *)env_new, CONFIG_ENV_SIZE)) { printf("\n** Unable to write env to %s:%s **\n", CONFIG_ENV_UBI_PART, CONFIG_ENV_UBI_VOLUME); return 1; } } puts("done\n"); gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND; return 0; }
int saveenv(void) { env_t env_new; int rc = 1; char *saved_data = NULL; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; up_data = end_addr + 1 - ((long)flash_addr + CONFIG_ENV_SIZE); debug("Data to save 0x%lx\n", up_data); if (up_data) { saved_data = malloc(up_data); if (saved_data == NULL) { printf("Unable to save the rest of sector (%ld)\n", up_data); goto done; } memcpy(saved_data, (void *)((long)flash_addr + CONFIG_ENV_SIZE), up_data); debug("Data (start 0x%lx, len 0x%lx) saved at 0x%lx\n", (ulong)flash_addr + CONFIG_ENV_SIZE, up_data, (ulong)saved_data); } #endif /* CONFIG_ENV_SECT_SIZE */ debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr, end_addr); if (flash_sect_protect(0, (long)flash_addr, end_addr)) goto done; rc = env_export(&env_new); if (rc) goto done; puts("Erasing Flash..."); if (flash_sect_erase((long)flash_addr, end_addr)) goto done; puts("Writing to Flash... "); rc = flash_write((char *)&env_new, (long)flash_addr, CONFIG_ENV_SIZE); if (rc != 0) goto perror; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug("Restoring the rest of data to 0x%lx len 0x%lx\n", (ulong)flash_addr + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, (long)flash_addr + CONFIG_ENV_SIZE, up_data)) goto perror; } #endif puts("done\n"); rc = 0; goto done; perror: flash_perror(rc); done: if (saved_data) free(saved_data); /* try to re-protect */ flash_sect_protect(1, (long)flash_addr, end_addr); return rc; }
int saveenv(void) { env_t env_new; char *saved_data = NULL; char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG; int rc = 1; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; #endif debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr, end_addr); if (flash_sect_protect(0, (ulong)flash_addr, end_addr)) goto done; debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr_new, end_addr_new); if (flash_sect_protect(0, (ulong)flash_addr_new, end_addr_new)) goto done; rc = env_export(&env_new); if (rc) return rc; env_new.flags = new_flag; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE up_data = end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE); debug("Data to save 0x%lX\n", up_data); if (up_data) { saved_data = malloc(up_data); if (saved_data == NULL) { printf("Unable to save the rest of sector (%ld)\n", up_data); goto done; } memcpy(saved_data, (void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data); debug("Data (start 0x%lX, len 0x%lX) saved at 0x%p\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data, saved_data); } #endif puts("Erasing Flash..."); debug(" %08lX ... %08lX ...", (ulong)flash_addr_new, end_addr_new); if (flash_sect_erase((ulong)flash_addr_new, end_addr_new)) goto done; puts("Writing to Flash... "); debug(" %08lX ... %08lX ...", (ulong)&(flash_addr_new->data), sizeof(env_ptr->data) + (ulong)&(flash_addr_new->data)); rc = flash_write((char *)&env_new, (ulong)flash_addr_new, sizeof(env_new)); if (rc) goto perror; rc = flash_write(&flag, (ulong)&(flash_addr->flags), sizeof(flash_addr->flags)); if (rc) goto perror; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug("Restoring the rest of data to 0x%lX len 0x%lX\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, (long)flash_addr_new + CONFIG_ENV_SIZE, up_data)) goto perror; } #endif puts("done\n"); { 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; } rc = 0; goto done; perror: flash_perror(rc); done: if (saved_data) free(saved_data); /* try to re-protect */ flash_sect_protect(1, (ulong)flash_addr, end_addr); flash_sect_protect(1, (ulong)flash_addr_new, end_addr_new); return rc; }
int saveenv(void) { u32 saved_size, saved_offset, sector = 1; char *saved_buffer = NULL; int ret = 1; env_t env_new; 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 1; } } /* Is the sector larger than the env (i.e. embedded) */ if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE; saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE; saved_buffer = malloc(saved_size); if (!saved_buffer) goto done; ret = spi_flash_read(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) { sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE; if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE) sector++; } ret = env_export(&env_new); if (ret) goto done; printf("Erasing %d bytes on SPI flash at %08x\n", sector * CONFIG_ENV_SECT_SIZE, CONFIG_ENV_OFFSET); ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET, sector * CONFIG_ENV_SECT_SIZE); if (ret) goto done; puts("Writing to SPI flash..."); ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, &env_new); if (ret) goto done; if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { ret = spi_flash_write(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } ret = 0; puts("done\n"); done: if (saved_buffer) free(saved_buffer); return ret; }
int saveenv(void) { env_t env_new; char *saved_buffer = NULL, flag = OBSOLETE_FLAG; u32 saved_size, saved_offset, sector = 1; int ret; #ifdef CONFIG_DM_SPI_FLASH struct udevice *new; /* 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 1; } 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 1; } } #endif ret = env_export(&env_new); if (ret) return ret; env_new.flags = ACTIVE_FLAG; if (gd->env_valid == 1) { env_new_offset = CONFIG_ENV_OFFSET_REDUND; env_offset = CONFIG_ENV_OFFSET; } else { env_new_offset = CONFIG_ENV_OFFSET; env_offset = CONFIG_ENV_OFFSET_REDUND; } /* Is the sector larger than the env (i.e. embedded) */ if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE; saved_offset = env_new_offset + CONFIG_ENV_SIZE; saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size); if (!saved_buffer) { ret = 1; goto done; } ret = spi_flash_read(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) { sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE; if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE) sector++; } puts("Erasing SPI flash..."); ret = spi_flash_erase(env_flash, env_new_offset, sector * CONFIG_ENV_SECT_SIZE); if (ret) goto done; puts("Writing to SPI flash..."); ret = spi_flash_write(env_flash, env_new_offset, CONFIG_ENV_SIZE, &env_new); if (ret) goto done; if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { ret = spi_flash_write(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags), sizeof(env_new.flags), &flag); if (ret) goto done; puts("done\n"); gd->env_valid = gd->env_valid == 2 ? 1 : 2; printf("Valid environment: %d\n", (int)gd->env_valid); done: if (saved_buffer) free(saved_buffer); return ret; }
int saveenv(void) { u32 saved_size, saved_offset, sector = 1; char *saved_buffer = NULL; int ret = 1; env_t env_new; #ifdef CONFIG_DM_SPI_FLASH struct udevice *new; /* 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 1; } 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 1; } } #endif /* Is the sector larger than the env (i.e. embedded) */ if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE; saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE; saved_buffer = malloc(saved_size); if (!saved_buffer) goto done; ret = spi_flash_read(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) { sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE; if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE) sector++; } ret = env_export(&env_new); if (ret) goto done; puts("Erasing SPI flash..."); ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET, sector * CONFIG_ENV_SECT_SIZE); if (ret) goto done; puts("Writing to SPI flash..."); ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, &env_new); if (ret) goto done; if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { ret = spi_flash_write(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } ret = 0; puts("done\n"); done: if (saved_buffer) free(saved_buffer); return ret; }
int saveenv(void) { env_t env_new; char *saved_buffer = NULL, flag = OBSOLETE_FLAG; u32 saved_size, saved_offset, sector = 1; int ret; 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 1; } } ret = env_export(&env_new); if (ret) return ret; env_new.flags = ACTIVE_FLAG; if (gd->env_valid == 1) { env_new_offset = CONFIG_ENV_OFFSET_REDUND; env_offset = CONFIG_ENV_OFFSET; } else { env_new_offset = CONFIG_ENV_OFFSET; env_offset = CONFIG_ENV_OFFSET_REDUND; } /* Is the sector larger than the env (i.e. embedded) */ if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE; saved_offset = env_new_offset + CONFIG_ENV_SIZE; saved_buffer = malloc(saved_size); if (!saved_buffer) { ret = 1; goto done; } ret = spi_flash_read(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) { sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE; if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE) sector++; } printf("Erasing %d bytes on SPI flash at %08x\n", sector * CONFIG_ENV_SECT_SIZE, env_new_offset); ret = spi_flash_erase(env_flash, env_new_offset, sector * CONFIG_ENV_SECT_SIZE); if (ret) goto done; puts("Writing to SPI flash..."); ret = spi_flash_write(env_flash, env_new_offset, CONFIG_ENV_SIZE, &env_new); if (ret) goto done; if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { ret = spi_flash_write(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags), sizeof(env_new.flags), &flag); if (ret) goto done; puts("done\n"); gd->env_valid = gd->env_valid == 2 ? 1 : 2; printf("Valid environment: %d\n", (int)gd->env_valid); done: if (saved_buffer) free(saved_buffer); return ret; }
static int env_sf_save(void) { env_t env_new; char *saved_buffer = NULL, flag = OBSOLETE_FLAG; u32 saved_size, saved_offset, sector; int ret; ret = setup_flash_device(); if (ret) return ret; ret = env_export(&env_new); if (ret) return -EIO; env_new.flags = ACTIVE_FLAG; if (gd->env_valid == ENV_VALID) { env_new_offset = CONFIG_ENV_OFFSET_REDUND; env_offset = CONFIG_ENV_OFFSET; } else { env_new_offset = CONFIG_ENV_OFFSET; env_offset = CONFIG_ENV_OFFSET_REDUND; } /* Is the sector larger than the env (i.e. embedded) */ if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE; saved_offset = env_new_offset + CONFIG_ENV_SIZE; saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size); if (!saved_buffer) { ret = -ENOMEM; goto done; } ret = spi_flash_read(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE); puts("Erasing SPI flash..."); ret = spi_flash_erase(env_flash, env_new_offset, sector * CONFIG_ENV_SECT_SIZE); if (ret) goto done; puts("Writing to SPI flash..."); ret = spi_flash_write(env_flash, env_new_offset, CONFIG_ENV_SIZE, &env_new); if (ret) goto done; if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) { ret = spi_flash_write(env_flash, saved_offset, saved_size, saved_buffer); if (ret) goto done; } ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags), sizeof(env_new.flags), &flag); if (ret) goto done; puts("done\n"); gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND; printf("Valid environment: %d\n", (int)gd->env_valid); done: if (saved_buffer) free(saved_buffer); return ret; }