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 static struct spi_flash *env_flash;
  52
  53 static int setup_flash_device(void)
  54 {
  55 #ifdef CONFIG_DM_SPI_FLASH
  56         struct udevice *new;
  57         int     ret;
  58
  59         /* speed and mode will be read from DT */
  60         ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  61                                      0, 0, &new);
  62         if (ret) {
  63                 set_default_env("!spi_flash_probe_bus_cs() failed");
  64                 return 1;
  65         }
  66
  67         env_flash = dev_get_uclass_priv(new);
  68 #else
  69
  70         if (!env_flash) {
  71                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
  72                         CONFIG_ENV_SPI_CS,
  73                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
  74                 if (!env_flash) {
  75                         set_default_env("!spi_flash_probe() failed");
  76                         return 1;
  77                 }
  78         }
  79 #endif
  80         return 0;
  81 }
  82
  83 #if defined(CONFIG_ENV_OFFSET_REDUND)
  84 #ifdef CMD_SAVEENV
  85 static int env_sf_save(void)
  86 {
  87         env_t   env_new;
  88         char    *saved_buffer = NULL, flag = OBSOLETE_FLAG;
  89         u32     saved_size, saved_offset, sector;
  90         int     ret;
  91
  92         ret = setup_flash_device();
  93         if (ret)
  94                 return ret;
  95
  96         ret = env_export(&env_new);
  97         if (ret)
  98                 return ret;
  99         env_new.flags   = ACTIVE_FLAG;
 100
 101         if (gd->env_valid == ENV_VALID) {
 102                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
 103                 env_offset = CONFIG_ENV_OFFSET;
 104         } else {
 105                 env_new_offset = CONFIG_ENV_OFFSET;
 106                 env_offset = CONFIG_ENV_OFFSET_REDUND;
 107         }
 108
 109         /* Is the sector larger than the env (i.e. embedded) */
 110         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 111                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 112                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
 113                 saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
 114                 if (!saved_buffer) {
 115                         ret = 1;
 116                         goto done;
 117                 }
 118                 ret = spi_flash_read(env_flash, saved_offset,
 119                                         saved_size, saved_buffer);
 120                 if (ret)
 121                         goto done;
 122         }
 123
 124         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
 125
 126         puts("Erasing SPI flash...");
 127         ret = spi_flash_erase(env_flash, env_new_offset,
 128                                 sector * CONFIG_ENV_SECT_SIZE);
 129         if (ret)
 130                 goto done;
 131
 132         puts("Writing to SPI flash...");
 133
 134         ret = spi_flash_write(env_flash, env_new_offset,
 135                 CONFIG_ENV_SIZE, &env_new);
 136         if (ret)
 137                 goto done;
 138
 139         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 140                 ret = spi_flash_write(env_flash, saved_offset,
 141                                         saved_size, saved_buffer);
 142                 if (ret)
 143                         goto done;
 144         }
 145
 146         ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
 147                                 sizeof(env_new.flags), &flag);
 148         if (ret)
 149                 goto done;
 150
 151         puts("done\n");
 152
 153         gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
 154
 155         printf("Valid environment: %d\n", (int)gd->env_valid);
 156
 157  done:
 158         if (saved_buffer)
 159                 free(saved_buffer);
 160
 161         return ret;
 162 }
 163 #endif /* CMD_SAVEENV */
 164
 165 static void env_sf_load(void)
 166 {
 167         int ret;
 168         int crc1_ok = 0, crc2_ok = 0;
 169         env_t *tmp_env1 = NULL;
 170         env_t *tmp_env2 = NULL;
 171         env_t *ep = NULL;
 172
 173         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 174                         CONFIG_ENV_SIZE);
 175         tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 176                         CONFIG_ENV_SIZE);
 177         if (!tmp_env1 || !tmp_env2) {
 178                 set_default_env("!malloc() failed");
 179                 goto out;
 180         }
 181
 182         ret = setup_flash_device();
 183         if (ret)
 184                 goto out;
 185
 186         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 187                                 CONFIG_ENV_SIZE, tmp_env1);
 188         if (ret) {
 189                 set_default_env("!spi_flash_read() failed");
 190                 goto err_read;
 191         }
 192
 193         if (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc)
 194                 crc1_ok = 1;
 195
 196         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
 197                                 CONFIG_ENV_SIZE, tmp_env2);
 198         if (!ret) {
 199                 if (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc)
 200                         crc2_ok = 1;
 201         }
 202
 203         if (!crc1_ok && !crc2_ok) {
 204                 set_default_env("!bad CRC");
 205                 goto err_read;
 206         } else if (crc1_ok && !crc2_ok) {
 207                 gd->env_valid = ENV_VALID;
 208         } else if (!crc1_ok && crc2_ok) {
 209                 gd->env_valid = ENV_REDUND;
 210         } else if (tmp_env1->flags == ACTIVE_FLAG &&
 211                    tmp_env2->flags == OBSOLETE_FLAG) {
 212                 gd->env_valid = ENV_VALID;
 213         } else if (tmp_env1->flags == OBSOLETE_FLAG &&
 214                    tmp_env2->flags == ACTIVE_FLAG) {
 215                 gd->env_valid = ENV_REDUND;
 216         } else if (tmp_env1->flags == tmp_env2->flags) {
 217                 gd->env_valid = ENV_VALID;
 218         } else if (tmp_env1->flags == 0xFF) {
 219                 gd->env_valid = ENV_VALID;
 220         } else if (tmp_env2->flags == 0xFF) {
 221                 gd->env_valid = ENV_REDUND;
 222         } else {
 223                 /*
 224                  * this differs from code in env_flash.c, but I think a sane
 225                  * default path is desirable.
 226                  */
 227                 gd->env_valid = ENV_VALID;
 228         }
 229
 230         if (gd->env_valid == ENV_VALID)
 231                 ep = tmp_env1;
 232         else
 233                 ep = tmp_env2;
 234
 235         ret = env_import((char *)ep, 0);
 236         if (!ret) {
 237                 error("Cannot import environment: errno = %d\n", errno);
 238                 set_default_env("!env_import failed");
 239         }
 240
 241 err_read:
 242         spi_flash_free(env_flash);
 243         env_flash = NULL;
 244 out:
 245         free(tmp_env1);
 246         free(tmp_env2);
 247 }
 248 #else
 249 #ifdef CMD_SAVEENV
 250 static int env_sf_save(void)
 251 {
 252         u32     saved_size, saved_offset, sector;
 253         char    *saved_buffer = NULL;
 254         int     ret = 1;
 255         env_t   env_new;
 256
 257         ret = setup_flash_device();
 258         if (ret)
 259                 return ret;
 260
 261         /* Is the sector larger than the env (i.e. embedded) */
 262         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 263                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 264                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 265                 saved_buffer = malloc(saved_size);
 266                 if (!saved_buffer)
 267                         goto done;
 268
 269                 ret = spi_flash_read(env_flash, saved_offset,
 270                         saved_size, saved_buffer);
 271                 if (ret)
 272                         goto done;
 273         }
 274
 275         ret = env_export(&env_new);
 276         if (ret)
 277                 goto done;
 278
 279         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
 280
 281         puts("Erasing SPI flash...");
 282         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
 283                 sector * CONFIG_ENV_SECT_SIZE);
 284         if (ret)
 285                 goto done;
 286
 287         puts("Writing to SPI flash...");
 288         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
 289                 CONFIG_ENV_SIZE, &env_new);
 290         if (ret)
 291                 goto done;
 292
 293         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 294                 ret = spi_flash_write(env_flash, saved_offset,
 295                         saved_size, saved_buffer);
 296                 if (ret)
 297                         goto done;
 298         }
 299
 300         ret = 0;
 301         puts("done\n");
 302
 303  done:
 304         if (saved_buffer)
 305                 free(saved_buffer);
 306
 307         return ret;
 308 }
 309 #endif /* CMD_SAVEENV */
 310
 311 static void env_sf_load(void)
 312 {
 313         int ret;
 314         char *buf = NULL;
 315
 316         buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
 317         if (!buf) {
 318                 set_default_env("!malloc() failed");
 319                 return;
 320         }
 321
 322         ret = setup_flash_device();
 323         if (ret)
 324                 goto out;
 325
 326         ret = spi_flash_read(env_flash,
 327                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
 328         if (ret) {
 329                 set_default_env("!spi_flash_read() failed");
 330                 goto err_read;
 331         }
 332
 333         ret = env_import(buf, 1);
 334         if (ret)
 335                 gd->env_valid = ENV_VALID;
 336
 337 err_read:
 338         spi_flash_free(env_flash);
 339         env_flash = NULL;
 340 out:
 341         free(buf);
 342 }
 343 #endif
 344
 345 U_BOOT_ENV_LOCATION(sf) = {
 346         .location       = ENVL_SPI_FLASH,
 347         ENV_NAME("SPI Flash")
 348         .load           = env_sf_load,
 349 #ifdef CMD_SAVEENV
 350         .save           = env_save_ptr(env_sf_save),
 351 #endif
 352 };