env/sf.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000-2010
   4  * Wolfgang Denk, DENX Software Engineering, [email protected].
   5  *
   6  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   7  * Andreas Heppel <[email protected]>
   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 <asm/global_data.h>
  24 #include <dm/device-internal.h>
  25 #include <u-boot/crc.h>
  26
  27 #ifndef CONFIG_SPL_BUILD
  28 #define INITENV
  29 #endif
  30
  31 #ifdef CONFIG_ENV_OFFSET_REDUND
  32 static ulong env_offset         = CONFIG_ENV_OFFSET;
  33 static ulong env_new_offset     = CONFIG_ENV_OFFSET_REDUND;
  34 #endif /* CONFIG_ENV_OFFSET_REDUND */
  35
  36 DECLARE_GLOBAL_DATA_PTR;
  37
  38 static struct spi_flash *env_flash;
  39
  40 static int setup_flash_device(void)
  41 {
  42 #if CONFIG_IS_ENABLED(DM_SPI_FLASH)
  43         struct udevice *new;
  44         int     ret;
  45
  46         /* speed and mode will be read from DT */
  47         ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  48                                      CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE,
  49                                      &new);
  50         if (ret) {
  51                 env_set_default("spi_flash_probe_bus_cs() failed", 0);
  52                 return ret;
  53         }
  54
  55         env_flash = dev_get_uclass_priv(new);
  56 #else
  57         if (env_flash)
  58                 spi_flash_free(env_flash);
  59
  60         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  61                                     CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
  62         if (!env_flash) {
  63                 env_set_default("spi_flash_probe() failed", 0);
  64                 return -EIO;
  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, H_EXTERNAL);
 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, H_EXTERNAL);
 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 /*
 292  * check if Environment on CONFIG_ENV_ADDR is valid.
 293  */
 294 static int env_sf_init_addr(void)
 295 {
 296         env_t *env_ptr = (env_t *)env_sf_get_env_addr();
 297
 298         if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
 299                 gd->env_addr    = (ulong)&(env_ptr->data);
 300                 gd->env_valid   = 1;
 301         } else {
 302                 gd->env_addr = (ulong)&default_environment[0];
 303                 gd->env_valid = 1;
 304         }
 305
 306         return 0;
 307 }
 308 #endif
 309
 310 #if defined(CONFIG_ENV_SPI_EARLY)
 311 /*
 312  * early load environment from SPI flash (before relocation)
 313  * and check if it is valid.
 314  */
 315 static int env_sf_init_early(void)
 316 {
 317         int ret;
 318         int read1_fail;
 319         int read2_fail;
 320         int crc1_ok;
 321         env_t *tmp_env2 = NULL;
 322         env_t *tmp_env1;
 323
 324         /*
 325          * if malloc is not ready yet, we cannot use
 326          * this part yet.
 327          */
 328         if (!gd->malloc_limit)
 329                 return -ENOENT;
 330
 331         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 332                         CONFIG_ENV_SIZE);
 333         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
 334                 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 335                                              CONFIG_ENV_SIZE);
 336
 337         if (!tmp_env1 || !tmp_env2)
 338                 goto out;
 339
 340         ret = setup_flash_device();
 341         if (ret)
 342                 goto out;
 343
 344         read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 345                                     CONFIG_ENV_SIZE, tmp_env1);
 346
 347         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
 348                 read2_fail = spi_flash_read(env_flash,
 349                                             CONFIG_ENV_OFFSET_REDUND,
 350                                             CONFIG_ENV_SIZE, tmp_env2);
 351                 ret = env_check_redund((char *)tmp_env1, read1_fail,
 352                                        (char *)tmp_env2, read2_fail);
 353
 354                 if (ret == -EIO || ret == -ENOMSG)
 355                         goto err_read;
 356
 357                 if (gd->env_valid == ENV_VALID)
 358                         gd->env_addr = (unsigned long)&tmp_env1->data;
 359                 else
 360                         gd->env_addr = (unsigned long)&tmp_env2->data;
 361         } else {
 362                 if (read1_fail)
 363                         goto err_read;
 364
 365                 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
 366                                 tmp_env1->crc;
 367                 if (!crc1_ok)
 368                         goto err_read;
 369
 370                 /* if valid -> this is our env */
 371                 gd->env_valid = ENV_VALID;
 372                 gd->env_addr = (unsigned long)&tmp_env1->data;
 373         }
 374
 375         return 0;
 376 err_read:
 377         spi_flash_free(env_flash);
 378         env_flash = NULL;
 379         free(tmp_env1);
 380         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
 381                 free(tmp_env2);
 382 out:
 383         /* env is not valid. always return 0 */
 384         gd->env_valid = ENV_INVALID;
 385         return 0;
 386 }
 387 #endif
 388
 389 static int env_sf_init(void)
 390 {
 391 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
 392         return env_sf_init_addr();
 393 #elif defined(CONFIG_ENV_SPI_EARLY)
 394         return env_sf_init_early();
 395 #endif
 396         /*
 397          * return here -ENOENT, so env_init()
 398          * can set the init bit and later if no
 399          * other Environment storage is defined
 400          * can set the default environment
 401          */
 402         return -ENOENT;
 403 }
 404
 405 U_BOOT_ENV_LOCATION(sf) = {
 406         .location       = ENVL_SPI_FLASH,
 407         ENV_NAME("SPIFlash")
 408         .load           = env_sf_load,
 409         .save           = CONFIG_IS_ENABLED(SAVEENV) ? ENV_SAVE_PTR(env_sf_save) : NULL,
 410         .init           = env_sf_init,
 411 };