git.sur5r.net Git - u-boot/blob - 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 <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 #ifndef CONFIG_SPL_BUILD
  35 #define CMD_SAVEENV
  36 #define INITENV
  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 ret;
  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 -EIO;
  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 -EIO;
  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 = -ENOMEM;
 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 int env_sf_load(void)
 166 {
 167         int ret;
 168         int read1_fail, read2_fail;
 169         env_t *tmp_env1, *tmp_env2;
 170
 171         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 172                         CONFIG_ENV_SIZE);
 173         tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 174                         CONFIG_ENV_SIZE);
 175         if (!tmp_env1 || !tmp_env2) {
 176                 set_default_env("!malloc() failed");
 177                 ret = -EIO;
 178                 goto out;
 179         }
 180
 181         ret = setup_flash_device();
 182         if (ret)
 183                 goto out;
 184
 185         read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 186                                     CONFIG_ENV_SIZE, tmp_env1);
 187         read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
 188                                     CONFIG_ENV_SIZE, tmp_env2);
 189
 190         ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
 191                                 read2_fail);
 192
 193         spi_flash_free(env_flash);
 194         env_flash = NULL;
 195 out:
 196         free(tmp_env1);
 197         free(tmp_env2);
 198
 199         return ret;
 200 }
 201 #else
 202 #ifdef CMD_SAVEENV
 203 static int env_sf_save(void)
 204 {
 205         u32     saved_size, saved_offset, sector;
 206         char    *saved_buffer = NULL;
 207         int     ret = 1;
 208         env_t   env_new;
 209
 210         ret = setup_flash_device();
 211         if (ret)
 212                 return ret;
 213
 214         /* Is the sector larger than the env (i.e. embedded) */
 215         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 216                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 217                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 218                 saved_buffer = malloc(saved_size);
 219                 if (!saved_buffer)
 220                         goto done;
 221
 222                 ret = spi_flash_read(env_flash, saved_offset,
 223                         saved_size, saved_buffer);
 224                 if (ret)
 225                         goto done;
 226         }
 227
 228         ret = env_export(&env_new);
 229         if (ret)
 230                 goto done;
 231
 232         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
 233
 234         puts("Erasing SPI flash...");
 235         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
 236                 sector * CONFIG_ENV_SECT_SIZE);
 237         if (ret)
 238                 goto done;
 239
 240         puts("Writing to SPI flash...");
 241         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
 242                 CONFIG_ENV_SIZE, &env_new);
 243         if (ret)
 244                 goto done;
 245
 246         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 247                 ret = spi_flash_write(env_flash, saved_offset,
 248                         saved_size, saved_buffer);
 249                 if (ret)
 250                         goto done;
 251         }
 252
 253         ret = 0;
 254         puts("done\n");
 255
 256  done:
 257         if (saved_buffer)
 258                 free(saved_buffer);
 259
 260         return ret;
 261 }
 262 #endif /* CMD_SAVEENV */
 263
 264 static int env_sf_load(void)
 265 {
 266         int ret;
 267         char *buf = NULL;
 268
 269         buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
 270         if (!buf) {
 271                 set_default_env("!malloc() failed");
 272                 return -EIO;
 273         }
 274
 275         ret = setup_flash_device();
 276         if (ret)
 277                 goto out;
 278
 279         ret = spi_flash_read(env_flash,
 280                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
 281         if (ret) {
 282                 set_default_env("!spi_flash_read() failed");
 283                 goto err_read;
 284         }
 285
 286         ret = env_import(buf, 1);
 287         if (!ret)
 288                 gd->env_valid = ENV_VALID;
 289
 290 err_read:
 291         spi_flash_free(env_flash);
 292         env_flash = NULL;
 293 out:
 294         free(buf);
 295
 296         return ret;
 297 }
 298 #endif
 299
 300 #if defined(INITENV) && defined(CONFIG_ENV_ADDR)
 301 static int env_sf_init(void)
 302 {
 303         env_t *env_ptr = (env_t *)(CONFIG_ENV_ADDR);
 304
 305         if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
 306                 gd->env_addr    = (ulong)&(env_ptr->data);
 307                 gd->env_valid   = 1;
 308         } else {
 309                 gd->env_addr = (ulong)&default_environment[0];
 310                 gd->env_valid = 1;
 311         }
 312
 313         return 0;
 314 }
 315 #endif
 316
 317 U_BOOT_ENV_LOCATION(sf) = {
 318         .location       = ENVL_SPI_FLASH,
 319         ENV_NAME("SPI Flash")
 320         .load           = env_sf_load,
 321 #ifdef CMD_SAVEENV
 322         .save           = env_save_ptr(env_sf_save),
 323 #endif
 324 #if defined(INITENV) && defined(CONFIG_ENV_ADDR)
 325         .init           = env_sf_init,
 326 #endif
 327 };