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