env/sf.c

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