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 #if CONFIG_IS_ENABLED(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         if (env_flash)
  57                 spi_flash_free(env_flash);
  58
  59         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, 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 #endif
  66         return 0;
  67 }
  68
  69 #if defined(CONFIG_ENV_OFFSET_REDUND)
  70 static int env_sf_save(void)
  71 {
  72         env_t   env_new;
  73         char    *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE;
  74         u32     saved_size, saved_offset, sector;
  75         int     ret;
  76
  77         ret = setup_flash_device();
  78         if (ret)
  79                 return ret;
  80
  81         ret = env_export(&env_new);
  82         if (ret)
  83                 return -EIO;
  84         env_new.flags   = ENV_REDUND_ACTIVE;
  85
  86         if (gd->env_valid == ENV_VALID) {
  87                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
  88                 env_offset = CONFIG_ENV_OFFSET;
  89         } else {
  90                 env_new_offset = CONFIG_ENV_OFFSET;
  91                 env_offset = CONFIG_ENV_OFFSET_REDUND;
  92         }
  93
  94         /* Is the sector larger than the env (i.e. embedded) */
  95         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
  96                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
  97                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
  98                 saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
  99                 if (!saved_buffer) {
 100                         ret = -ENOMEM;
 101                         goto done;
 102                 }
 103                 ret = spi_flash_read(env_flash, saved_offset,
 104                                         saved_size, saved_buffer);
 105                 if (ret)
 106                         goto done;
 107         }
 108
 109         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
 110
 111         puts("Erasing SPI flash...");
 112         ret = spi_flash_erase(env_flash, env_new_offset,
 113                                 sector * CONFIG_ENV_SECT_SIZE);
 114         if (ret)
 115                 goto done;
 116
 117         puts("Writing to SPI flash...");
 118
 119         ret = spi_flash_write(env_flash, env_new_offset,
 120                 CONFIG_ENV_SIZE, &env_new);
 121         if (ret)
 122                 goto done;
 123
 124         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 125                 ret = spi_flash_write(env_flash, saved_offset,
 126                                         saved_size, saved_buffer);
 127                 if (ret)
 128                         goto done;
 129         }
 130
 131         ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
 132                                 sizeof(env_new.flags), &flag);
 133         if (ret)
 134                 goto done;
 135
 136         puts("done\n");
 137
 138         gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
 139
 140         printf("Valid environment: %d\n", (int)gd->env_valid);
 141
 142  done:
 143         if (saved_buffer)
 144                 free(saved_buffer);
 145
 146         return ret;
 147 }
 148
 149 static int env_sf_load(void)
 150 {
 151         int ret;
 152         int read1_fail, read2_fail;
 153         env_t *tmp_env1, *tmp_env2;
 154
 155         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 156                         CONFIG_ENV_SIZE);
 157         tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 158                         CONFIG_ENV_SIZE);
 159         if (!tmp_env1 || !tmp_env2) {
 160                 env_set_default("malloc() failed", 0);
 161                 ret = -EIO;
 162                 goto out;
 163         }
 164
 165         ret = setup_flash_device();
 166         if (ret)
 167                 goto out;
 168
 169         read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 170                                     CONFIG_ENV_SIZE, tmp_env1);
 171         read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
 172                                     CONFIG_ENV_SIZE, tmp_env2);
 173
 174         ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
 175                                 read2_fail, H_EXTERNAL);
 176
 177         spi_flash_free(env_flash);
 178         env_flash = NULL;
 179 out:
 180         free(tmp_env1);
 181         free(tmp_env2);
 182
 183         return ret;
 184 }
 185 #else
 186 static int env_sf_save(void)
 187 {
 188         u32     saved_size, saved_offset, sector;
 189         char    *saved_buffer = NULL;
 190         int     ret = 1;
 191         env_t   env_new;
 192
 193         ret = setup_flash_device();
 194         if (ret)
 195                 return ret;
 196
 197         /* Is the sector larger than the env (i.e. embedded) */
 198         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 199                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 200                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 201                 saved_buffer = malloc(saved_size);
 202                 if (!saved_buffer)
 203                         goto done;
 204
 205                 ret = spi_flash_read(env_flash, saved_offset,
 206                         saved_size, saved_buffer);
 207                 if (ret)
 208                         goto done;
 209         }
 210
 211         ret = env_export(&env_new);
 212         if (ret)
 213                 goto done;
 214
 215         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
 216
 217         puts("Erasing SPI flash...");
 218         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
 219                 sector * CONFIG_ENV_SECT_SIZE);
 220         if (ret)
 221                 goto done;
 222
 223         puts("Writing to SPI flash...");
 224         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
 225                 CONFIG_ENV_SIZE, &env_new);
 226         if (ret)
 227                 goto done;
 228
 229         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 230                 ret = spi_flash_write(env_flash, saved_offset,
 231                         saved_size, saved_buffer);
 232                 if (ret)
 233                         goto done;
 234         }
 235
 236         ret = 0;
 237         puts("done\n");
 238
 239  done:
 240         if (saved_buffer)
 241                 free(saved_buffer);
 242
 243         return ret;
 244 }
 245
 246 static int env_sf_load(void)
 247 {
 248         int ret;
 249         char *buf = NULL;
 250
 251         buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
 252         if (!buf) {
 253                 env_set_default("malloc() failed", 0);
 254                 return -EIO;
 255         }
 256
 257         ret = setup_flash_device();
 258         if (ret)
 259                 goto out;
 260
 261         ret = spi_flash_read(env_flash,
 262                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
 263         if (ret) {
 264                 env_set_default("spi_flash_read() failed", 0);
 265                 goto err_read;
 266         }
 267
 268         ret = env_import(buf, 1, H_EXTERNAL);
 269         if (!ret)
 270                 gd->env_valid = ENV_VALID;
 271
 272 err_read:
 273         spi_flash_free(env_flash);
 274         env_flash = NULL;
 275 out:
 276         free(buf);
 277
 278         return ret;
 279 }
 280 #endif
 281
 282 #if CONFIG_ENV_ADDR != 0x0
 283 __weak void *env_sf_get_env_addr(void)
 284 {
 285         return (void *)CONFIG_ENV_ADDR;
 286 }
 287 #endif
 288
 289 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
 290 /*
 291  * check if Environment on CONFIG_ENV_ADDR is valid.
 292  */
 293 static int env_sf_init_addr(void)
 294 {
 295         env_t *env_ptr = (env_t *)env_sf_get_env_addr();
 296
 297         if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
 298                 gd->env_addr    = (ulong)&(env_ptr->data);
 299                 gd->env_valid   = 1;
 300         } else {
 301                 gd->env_addr = (ulong)&default_environment[0];
 302                 gd->env_valid = 1;
 303         }
 304
 305         return 0;
 306 }
 307 #endif
 308
 309 #if defined(CONFIG_ENV_SPI_EARLY)
 310 /*
 311  * early load environment from SPI flash (before relocation)
 312  * and check if it is valid.
 313  */
 314 static int env_sf_init_early(void)
 315 {
 316         int ret;
 317         int read1_fail;
 318         int read2_fail;
 319         int crc1_ok;
 320         env_t *tmp_env2 = NULL;
 321         env_t *tmp_env1;
 322
 323         /*
 324          * if malloc is not ready yet, we cannot use
 325          * this part yet.
 326          */
 327         if (!gd->malloc_limit)
 328                 return -ENOENT;
 329
 330         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 331                         CONFIG_ENV_SIZE);
 332         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
 333                 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 334                                              CONFIG_ENV_SIZE);
 335
 336         if (!tmp_env1 || !tmp_env2)
 337                 goto out;
 338
 339         ret = setup_flash_device();
 340         if (ret)
 341                 goto out;
 342
 343         read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 344                                     CONFIG_ENV_SIZE, tmp_env1);
 345
 346         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
 347                 read2_fail = spi_flash_read(env_flash,
 348                                             CONFIG_ENV_OFFSET_REDUND,
 349                                             CONFIG_ENV_SIZE, tmp_env2);
 350                 ret = env_check_redund((char *)tmp_env1, read1_fail,
 351                                        (char *)tmp_env2, read2_fail);
 352
 353                 if (ret == -EIO || ret == -ENOMSG)
 354                         goto err_read;
 355
 356                 if (gd->env_valid == ENV_VALID)
 357                         gd->env_addr = (unsigned long)&tmp_env1->data;
 358                 else
 359                         gd->env_addr = (unsigned long)&tmp_env2->data;
 360         } else {
 361                 if (read1_fail)
 362                         goto err_read;
 363
 364                 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
 365                                 tmp_env1->crc;
 366                 if (!crc1_ok)
 367                         goto err_read;
 368
 369                 /* if valid -> this is our env */
 370                 gd->env_valid = ENV_VALID;
 371                 gd->env_addr = (unsigned long)&tmp_env1->data;
 372         }
 373
 374         return 0;
 375 err_read:
 376         spi_flash_free(env_flash);
 377         env_flash = NULL;
 378         free(tmp_env1);
 379         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
 380                 free(tmp_env2);
 381 out:
 382         /* env is not valid. always return 0 */
 383         gd->env_valid = ENV_INVALID;
 384         return 0;
 385 }
 386 #endif
 387
 388 static int env_sf_init(void)
 389 {
 390 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
 391         return env_sf_init_addr();
 392 #elif defined(CONFIG_ENV_SPI_EARLY)
 393         return env_sf_init_early();
 394 #endif
 395         /*
 396          * return here -ENOENT, so env_init()
 397          * can set the init bit and later if no
 398          * other Environment storage is defined
 399          * can set the default environment
 400          */
 401         return -ENOENT;
 402 }
 403
 404 U_BOOT_ENV_LOCATION(sf) = {
 405         .location       = ENVL_SPI_FLASH,
 406         ENV_NAME("SPIFlash")
 407         .load           = env_sf_load,
 408         .save           = CONFIG_IS_ENABLED(SAVEENV) ? ENV_SAVE_PTR(env_sf_save) : NULL,
 409         .init           = env_sf_init,
 410 };