env/sf.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000-2010
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  *
   6  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   7  * Andreas Heppel <aheppel@sysgo.de>
   8  *
   9  * (C) Copyright 2008 Atmel Corporation
  10  */
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <env.h>
  14 #include <env_internal.h>
  15 #include <flash.h>
  16 #include <malloc.h>
  17 #include <spi.h>
  18 #include <spi_flash.h>
  19 #include <search.h>
  20 #include <errno.h>
  21 #include <uuid.h>
  22 #include <dm/device-internal.h>
  23 #include <u-boot/crc.h>
  24
  25 #ifndef CONFIG_SPL_BUILD
  26 #define INITENV
  27 #endif
  28
  29 #ifdef CONFIG_ENV_OFFSET_REDUND
  30 static ulong env_offset         = CONFIG_ENV_OFFSET;
  31 static ulong env_new_offset     = CONFIG_ENV_OFFSET_REDUND;
  32 #endif /* CONFIG_ENV_OFFSET_REDUND */
  33
  34 DECLARE_GLOBAL_DATA_PTR;
  35
  36 static struct spi_flash *env_flash;
  37
  38 static int setup_flash_device(void)
  39 {
  40 #ifdef CONFIG_DM_SPI_FLASH
  41         struct udevice *new;
  42         int     ret;
  43
  44         /* speed and mode will be read from DT */
  45         ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  46                                      CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE,
  47                                      &new);
  48         if (ret) {
  49                 env_set_default("spi_flash_probe_bus_cs() failed", 0);
  50                 return ret;
  51         }
  52
  53         env_flash = dev_get_uclass_priv(new);
  54 #else
  55
  56         if (!env_flash) {
  57                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
  58                         CONFIG_ENV_SPI_CS,
  59                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
  60                 if (!env_flash) {
  61                         env_set_default("spi_flash_probe() failed", 0);
  62                         return -EIO;
  63                 }
  64         }
  65 #endif
  66         return 0;
  67 }
  68
  69 #if defined(CONFIG_ENV_OFFSET_REDUND)
  70 static int env_sf_save(void)
  71 {
  72         env_t   env_new;
  73         char    *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE;
  74         u32     saved_size, saved_offset, sector;
  75         int     ret;
  76
  77         ret = setup_flash_device();
  78         if (ret)
  79                 return ret;
  80
  81         ret = env_export(&env_new);
  82         if (ret)
  83                 return -EIO;
  84         env_new.flags   = ENV_REDUND_ACTIVE;
  85
  86         if (gd->env_valid == ENV_VALID) {
  87                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
  88                 env_offset = CONFIG_ENV_OFFSET;
  89         } else {
  90                 env_new_offset = CONFIG_ENV_OFFSET;
  91                 env_offset = CONFIG_ENV_OFFSET_REDUND;
  92         }
  93
  94         /* Is the sector larger than the env (i.e. embedded) */
  95         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
  96                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
  97                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
  98                 saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
  99                 if (!saved_buffer) {
 100                         ret = -ENOMEM;
 101                         goto done;
 102                 }
 103                 ret = spi_flash_read(env_flash, saved_offset,
 104                                         saved_size, saved_buffer);
 105                 if (ret)
 106                         goto done;
 107         }
 108
 109         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
 110
 111         puts("Erasing SPI flash...");
 112         ret = spi_flash_erase(env_flash, env_new_offset,
 113                                 sector * CONFIG_ENV_SECT_SIZE);
 114         if (ret)
 115                 goto done;
 116
 117         puts("Writing to SPI flash...");
 118
 119         ret = spi_flash_write(env_flash, env_new_offset,
 120                 CONFIG_ENV_SIZE, &env_new);
 121         if (ret)
 122                 goto done;
 123
 124         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 125                 ret = spi_flash_write(env_flash, saved_offset,
 126                                         saved_size, saved_buffer);
 127                 if (ret)
 128                         goto done;
 129         }
 130
 131         ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
 132                                 sizeof(env_new.flags), &flag);
 133         if (ret)
 134                 goto done;
 135
 136         puts("done\n");
 137
 138         gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
 139
 140         printf("Valid environment: %d\n", (int)gd->env_valid);
 141
 142  done:
 143         if (saved_buffer)
 144                 free(saved_buffer);
 145
 146         return ret;
 147 }
 148
 149 static int env_sf_load(void)
 150 {
 151         int ret;
 152         int read1_fail, read2_fail;
 153         env_t *tmp_env1, *tmp_env2;
 154
 155         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 156                         CONFIG_ENV_SIZE);
 157         tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 158                         CONFIG_ENV_SIZE);
 159         if (!tmp_env1 || !tmp_env2) {
 160                 env_set_default("malloc() failed", 0);
 161                 ret = -EIO;
 162                 goto out;
 163         }
 164
 165         ret = setup_flash_device();
 166         if (ret)
 167                 goto out;
 168
 169         read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 170                                     CONFIG_ENV_SIZE, tmp_env1);
 171         read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
 172                                     CONFIG_ENV_SIZE, tmp_env2);
 173
 174         ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
 175                                 read2_fail);
 176
 177         spi_flash_free(env_flash);
 178         env_flash = NULL;
 179 out:
 180         free(tmp_env1);
 181         free(tmp_env2);
 182
 183         return ret;
 184 }
 185 #else
 186 static int env_sf_save(void)
 187 {
 188         u32     saved_size, saved_offset, sector;
 189         char    *saved_buffer = NULL;
 190         int     ret = 1;
 191         env_t   env_new;
 192
 193         ret = setup_flash_device();
 194         if (ret)
 195                 return ret;
 196
 197         /* Is the sector larger than the env (i.e. embedded) */
 198         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 199                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 200                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 201                 saved_buffer = malloc(saved_size);
 202                 if (!saved_buffer)
 203                         goto done;
 204
 205                 ret = spi_flash_read(env_flash, saved_offset,
 206                         saved_size, saved_buffer);
 207                 if (ret)
 208                         goto done;
 209         }
 210
 211         ret = env_export(&env_new);
 212         if (ret)
 213                 goto done;
 214
 215         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
 216
 217         puts("Erasing SPI flash...");
 218         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
 219                 sector * CONFIG_ENV_SECT_SIZE);
 220         if (ret)
 221                 goto done;
 222
 223         puts("Writing to SPI flash...");
 224         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
 225                 CONFIG_ENV_SIZE, &env_new);
 226         if (ret)
 227                 goto done;
 228
 229         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 230                 ret = spi_flash_write(env_flash, saved_offset,
 231                         saved_size, saved_buffer);
 232                 if (ret)
 233                         goto done;
 234         }
 235
 236         ret = 0;
 237         puts("done\n");
 238
 239  done:
 240         if (saved_buffer)
 241                 free(saved_buffer);
 242
 243         return ret;
 244 }
 245
 246 static int env_sf_load(void)
 247 {
 248         int ret;
 249         char *buf = NULL;
 250
 251         buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
 252         if (!buf) {
 253                 env_set_default("malloc() failed", 0);
 254                 return -EIO;
 255         }
 256
 257         ret = setup_flash_device();
 258         if (ret)
 259                 goto out;
 260
 261         ret = spi_flash_read(env_flash,
 262                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
 263         if (ret) {
 264                 env_set_default("spi_flash_read() failed", 0);
 265                 goto err_read;
 266         }
 267
 268         ret = env_import(buf, 1);
 269         if (!ret)
 270                 gd->env_valid = ENV_VALID;
 271
 272 err_read:
 273         spi_flash_free(env_flash);
 274         env_flash = NULL;
 275 out:
 276         free(buf);
 277
 278         return ret;
 279 }
 280 #endif
 281
 282 #if CONFIG_ENV_ADDR != 0x0
 283 __weak void *env_sf_get_env_addr(void)
 284 {
 285         return (void *)CONFIG_ENV_ADDR;
 286 }
 287 #endif
 288
 289 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
 290 static int env_sf_init(void)
 291 {
 292         env_t *env_ptr = (env_t *)env_sf_get_env_addr();
 293
 294         if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
 295                 gd->env_addr    = (ulong)&(env_ptr->data);
 296                 gd->env_valid   = 1;
 297         } else {
 298                 gd->env_addr = (ulong)&default_environment[0];
 299                 gd->env_valid = 1;
 300         }
 301
 302         return 0;
 303 }
 304 #endif
 305
 306 U_BOOT_ENV_LOCATION(sf) = {
 307         .location       = ENVL_SPI_FLASH,
 308         ENV_NAME("SPI Flash")
 309         .load           = env_sf_load,
 310         .save           = CONFIG_IS_ENABLED(SAVEENV) ? ENV_SAVE_PTR(env_sf_save) : NULL,
 311 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
 312         .init           = env_sf_init,
 313 #endif
 314 };