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