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 <malloc.h>
  16 #include <spi.h>
  17 #include <spi_flash.h>
  18 #include <search.h>
  19 #include <errno.h>
  20 #include <uuid.h>
  21 #include <asm/cache.h>
  22 #include <asm/global_data.h>
  23 #include <dm/device-internal.h>
  24 #include <u-boot/crc.h>
  25
  26 #define OFFSET_INVALID          (~(u32)0)
  27
  28 #ifdef CONFIG_ENV_OFFSET_REDUND
  29 #define ENV_OFFSET_REDUND       CONFIG_ENV_OFFSET_REDUND
  30
  31 static ulong env_offset         = CONFIG_ENV_OFFSET;
  32 static ulong env_new_offset     = CONFIG_ENV_OFFSET_REDUND;
  33
  34 #else
  35
  36 #define ENV_OFFSET_REDUND       OFFSET_INVALID
  37
  38 #endif /* CONFIG_ENV_OFFSET_REDUND */
  39
  40 DECLARE_GLOBAL_DATA_PTR;
  41
  42 static int setup_flash_device(struct spi_flash **env_flash)
  43 {
  44 #if CONFIG_IS_ENABLED(DM_SPI_FLASH)
  45         struct udevice *new;
  46         int     ret;
  47
  48         /* speed and mode will be read from DT */
  49         ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  50                                      &new);
  51         if (ret) {
  52                 env_set_default("spi_flash_probe_bus_cs() failed", 0);
  53                 return ret;
  54         }
  55
  56         *env_flash = dev_get_uclass_priv(new);
  57 #else
  58         *env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  59                                      CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
  60         if (!*env_flash) {
  61                 env_set_default("spi_flash_probe() failed", 0);
  62                 return -EIO;
  63         }
  64 #endif
  65         return 0;
  66 }
  67
  68 #if defined(CONFIG_ENV_OFFSET_REDUND)
  69 static int env_sf_save(void)
  70 {
  71         env_t   env_new;
  72         char    *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE;
  73         u32     saved_size = 0, saved_offset = 0, sector;
  74         u32     sect_size = CONFIG_ENV_SECT_SIZE;
  75         int     ret;
  76         struct spi_flash *env_flash;
  77
  78         ret = setup_flash_device(&env_flash);
  79         if (ret)
  80                 return ret;
  81
  82         if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO))
  83                 sect_size = env_flash->mtd.erasesize;
  84
  85         ret = env_export(&env_new);
  86         if (ret)
  87                 return -EIO;
  88         env_new.flags   = ENV_REDUND_ACTIVE;
  89
  90         if (gd->env_valid == ENV_VALID) {
  91                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
  92                 env_offset = CONFIG_ENV_OFFSET;
  93         } else {
  94                 env_new_offset = CONFIG_ENV_OFFSET;
  95                 env_offset = CONFIG_ENV_OFFSET_REDUND;
  96         }
  97
  98         /* Is the sector larger than the env (i.e. embedded) */
  99         if (sect_size > CONFIG_ENV_SIZE) {
 100                 saved_size = sect_size - CONFIG_ENV_SIZE;
 101                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
 102                 saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
 103                 if (!saved_buffer) {
 104                         ret = -ENOMEM;
 105                         goto done;
 106                 }
 107                 ret = spi_flash_read(env_flash, saved_offset,
 108                                         saved_size, saved_buffer);
 109                 if (ret)
 110                         goto done;
 111         }
 112
 113         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size);
 114
 115         puts("Erasing SPI flash...");
 116         ret = spi_flash_erase(env_flash, env_new_offset,
 117                                 sector * sect_size);
 118         if (ret)
 119                 goto done;
 120
 121         puts("Writing to SPI flash...");
 122
 123         ret = spi_flash_write(env_flash, env_new_offset,
 124                 CONFIG_ENV_SIZE, &env_new);
 125         if (ret)
 126                 goto done;
 127
 128         if (sect_size > CONFIG_ENV_SIZE) {
 129                 ret = spi_flash_write(env_flash, saved_offset,
 130                                         saved_size, saved_buffer);
 131                 if (ret)
 132                         goto done;
 133         }
 134
 135         ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
 136                                 sizeof(env_new.flags), &flag);
 137         if (ret)
 138                 goto done;
 139
 140         puts("done\n");
 141
 142         gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
 143
 144         printf("Valid environment: %d\n", (int)gd->env_valid);
 145
 146 done:
 147         spi_flash_free(env_flash);
 148
 149         if (saved_buffer)
 150                 free(saved_buffer);
 151
 152         return ret;
 153 }
 154
 155 static int env_sf_load(void)
 156 {
 157         int ret;
 158         int read1_fail, read2_fail;
 159         env_t *tmp_env1, *tmp_env2;
 160         struct spi_flash *env_flash;
 161
 162         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 163                         CONFIG_ENV_SIZE);
 164         tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 165                         CONFIG_ENV_SIZE);
 166         if (!tmp_env1 || !tmp_env2) {
 167                 env_set_default("malloc() failed", 0);
 168                 ret = -EIO;
 169                 goto out;
 170         }
 171
 172         ret = setup_flash_device(&env_flash);
 173         if (ret)
 174                 goto out;
 175
 176         read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 177                                     CONFIG_ENV_SIZE, tmp_env1);
 178         read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
 179                                     CONFIG_ENV_SIZE, tmp_env2);
 180
 181         ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
 182                                 read2_fail, H_EXTERNAL);
 183
 184         spi_flash_free(env_flash);
 185 out:
 186         free(tmp_env1);
 187         free(tmp_env2);
 188
 189         return ret;
 190 }
 191 #else
 192 static int env_sf_save(void)
 193 {
 194         u32     saved_size = 0, saved_offset = 0, sector;
 195         u32     sect_size = CONFIG_ENV_SECT_SIZE;
 196         char    *saved_buffer = NULL;
 197         int     ret = 1;
 198         env_t   env_new;
 199         struct spi_flash *env_flash;
 200
 201         ret = setup_flash_device(&env_flash);
 202         if (ret)
 203                 return ret;
 204
 205         if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO))
 206                 sect_size = env_flash->mtd.erasesize;
 207
 208         /* Is the sector larger than the env (i.e. embedded) */
 209         if (sect_size > CONFIG_ENV_SIZE) {
 210                 saved_size = sect_size - CONFIG_ENV_SIZE;
 211                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 212                 saved_buffer = malloc(saved_size);
 213                 if (!saved_buffer)
 214                         goto done;
 215
 216                 ret = spi_flash_read(env_flash, saved_offset,
 217                         saved_size, saved_buffer);
 218                 if (ret)
 219                         goto done;
 220         }
 221
 222         ret = env_export(&env_new);
 223         if (ret)
 224                 goto done;
 225
 226         sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size);
 227
 228         puts("Erasing SPI flash...");
 229         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
 230                 sector * sect_size);
 231         if (ret)
 232                 goto done;
 233
 234         puts("Writing to SPI flash...");
 235         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
 236                 CONFIG_ENV_SIZE, &env_new);
 237         if (ret)
 238                 goto done;
 239
 240         if (sect_size > CONFIG_ENV_SIZE) {
 241                 ret = spi_flash_write(env_flash, saved_offset,
 242                         saved_size, saved_buffer);
 243                 if (ret)
 244                         goto done;
 245         }
 246
 247         ret = 0;
 248         puts("done\n");
 249
 250 done:
 251         spi_flash_free(env_flash);
 252
 253         if (saved_buffer)
 254                 free(saved_buffer);
 255
 256         return ret;
 257 }
 258
 259 static int env_sf_load(void)
 260 {
 261         int ret;
 262         char *buf = NULL;
 263         struct spi_flash *env_flash;
 264
 265         buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
 266         if (!buf) {
 267                 env_set_default("malloc() failed", 0);
 268                 return -EIO;
 269         }
 270
 271         ret = setup_flash_device(&env_flash);
 272         if (ret)
 273                 goto out;
 274
 275         ret = spi_flash_read(env_flash,
 276                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
 277         if (ret) {
 278                 env_set_default("spi_flash_read() failed", 0);
 279                 goto err_read;
 280         }
 281
 282         ret = env_import(buf, 1, H_EXTERNAL);
 283         if (!ret)
 284                 gd->env_valid = ENV_VALID;
 285
 286 err_read:
 287         spi_flash_free(env_flash);
 288 out:
 289         free(buf);
 290
 291         return ret;
 292 }
 293 #endif
 294
 295 static int env_sf_erase(void)
 296 {
 297         int ret;
 298         env_t env;
 299         struct spi_flash *env_flash;
 300
 301         ret = setup_flash_device(&env_flash);
 302         if (ret)
 303                 return ret;
 304
 305         memset(&env, 0, sizeof(env_t));
 306         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, &env);
 307         if (ret)
 308                 goto done;
 309
 310         if (ENV_OFFSET_REDUND != OFFSET_INVALID)
 311                 ret = spi_flash_write(env_flash, ENV_OFFSET_REDUND, CONFIG_ENV_SIZE, &env);
 312
 313 done:
 314         spi_flash_free(env_flash);
 315
 316         return ret;
 317 }
 318
 319 __weak void *env_sf_get_env_addr(void)
 320 {
 321 #ifndef CONFIG_SPL_BUILD
 322         return (void *)CONFIG_ENV_ADDR;
 323 #else
 324         return NULL;
 325 #endif
 326 }
 327
 328 /*
 329  * check if Environment on CONFIG_ENV_ADDR is valid.
 330  */
 331 static int env_sf_init_addr(void)
 332 {
 333         env_t *env_ptr = (env_t *)env_sf_get_env_addr();
 334
 335         if (!env_ptr)
 336                 return -ENOENT;
 337
 338         if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
 339                 gd->env_addr = (ulong)&(env_ptr->data);
 340                 gd->env_valid = ENV_VALID;
 341         } else {
 342                 gd->env_valid = ENV_INVALID;
 343         }
 344
 345         return 0;
 346 }
 347
 348 #if defined(CONFIG_ENV_SPI_EARLY)
 349 /*
 350  * early load environment from SPI flash (before relocation)
 351  * and check if it is valid.
 352  */
 353 static int env_sf_init_early(void)
 354 {
 355         int ret;
 356         int read1_fail;
 357         int read2_fail;
 358         int crc1_ok;
 359         env_t *tmp_env2 = NULL;
 360         env_t *tmp_env1;
 361         struct spi_flash *env_flash;
 362
 363         /*
 364          * if malloc is not ready yet, we cannot use
 365          * this part yet.
 366          */
 367         if (!gd->malloc_limit)
 368                 return -ENOENT;
 369
 370         tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 371                         CONFIG_ENV_SIZE);
 372         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
 373                 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
 374                                              CONFIG_ENV_SIZE);
 375
 376         if (!tmp_env1 || !tmp_env2)
 377                 goto out;
 378
 379         ret = setup_flash_device(&env_flash);
 380         if (ret)
 381                 goto out;
 382
 383         read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 384                                     CONFIG_ENV_SIZE, tmp_env1);
 385
 386         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
 387                 read2_fail = spi_flash_read(env_flash,
 388                                             CONFIG_ENV_OFFSET_REDUND,
 389                                             CONFIG_ENV_SIZE, tmp_env2);
 390                 ret = env_check_redund((char *)tmp_env1, read1_fail,
 391                                        (char *)tmp_env2, read2_fail);
 392
 393                 if (ret < 0)
 394                         goto err_read;
 395
 396                 if (gd->env_valid == ENV_VALID)
 397                         gd->env_addr = (unsigned long)&tmp_env1->data;
 398                 else
 399                         gd->env_addr = (unsigned long)&tmp_env2->data;
 400         } else {
 401                 if (read1_fail)
 402                         goto err_read;
 403
 404                 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
 405                                 tmp_env1->crc;
 406                 if (!crc1_ok)
 407                         goto err_read;
 408
 409                 /* if valid -> this is our env */
 410                 gd->env_valid = ENV_VALID;
 411                 gd->env_addr = (unsigned long)&tmp_env1->data;
 412         }
 413
 414         spi_flash_free(env_flash);
 415
 416         return 0;
 417 err_read:
 418         spi_flash_free(env_flash);
 419
 420         free(tmp_env1);
 421         if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
 422                 free(tmp_env2);
 423 out:
 424         /* env is not valid. always return 0 */
 425         gd->env_valid = ENV_INVALID;
 426         return 0;
 427 }
 428 #endif
 429
 430 static int env_sf_init(void)
 431 {
 432         int ret = env_sf_init_addr();
 433         if (ret != -ENOENT)
 434                 return ret;
 435 #ifdef CONFIG_ENV_SPI_EARLY
 436         return env_sf_init_early();
 437 #endif
 438         /*
 439          * return here -ENOENT, so env_init()
 440          * can set the init bit and later if no
 441          * other Environment storage is defined
 442          * can set the default environment
 443          */
 444         return -ENOENT;
 445 }
 446
 447 U_BOOT_ENV_LOCATION(sf) = {
 448         .location       = ENVL_SPI_FLASH,
 449         ENV_NAME("SPIFlash")
 450         .load           = env_sf_load,
 451         .save           = ENV_SAVE_PTR(env_sf_save),
 452         .erase          = ENV_ERASE_PTR(env_sf_erase),
 453         .init           = env_sf_init,
 454 };