env/env.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017 Google, Inc
   4  * Written by Simon Glass <[email protected]>
   5  */
   6
   7 #include <common.h>
   8 #include <env.h>
   9 #include <env_internal.h>
  10 #include <log.h>
  11 #include <linux/bitops.h>
  12 #include <linux/bug.h>
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
  17 void env_fix_drivers(void)
  18 {
  19         struct env_driver *drv;
  20         const int n_ents = ll_entry_count(struct env_driver, env_driver);
  21         struct env_driver *entry;
  22
  23         drv = ll_entry_start(struct env_driver, env_driver);
  24         for (entry = drv; entry != drv + n_ents; entry++) {
  25                 if (entry->name)
  26                         entry->name += gd->reloc_off;
  27                 if (entry->load)
  28                         entry->load += gd->reloc_off;
  29                 if (entry->save)
  30                         entry->save += gd->reloc_off;
  31                 if (entry->erase)
  32                         entry->erase += gd->reloc_off;
  33                 if (entry->init)
  34                         entry->init += gd->reloc_off;
  35         }
  36 }
  37 #endif
  38
  39 static struct env_driver *_env_driver_lookup(enum env_location loc)
  40 {
  41         struct env_driver *drv;
  42         const int n_ents = ll_entry_count(struct env_driver, env_driver);
  43         struct env_driver *entry;
  44
  45         drv = ll_entry_start(struct env_driver, env_driver);
  46         for (entry = drv; entry != drv + n_ents; entry++) {
  47                 if (loc == entry->location)
  48                         return entry;
  49         }
  50
  51         /* Not found */
  52         return NULL;
  53 }
  54
  55 static enum env_location env_locations[] = {
  56 #ifdef CONFIG_ENV_IS_IN_EEPROM
  57         ENVL_EEPROM,
  58 #endif
  59 #ifdef CONFIG_ENV_IS_IN_EXT4
  60         ENVL_EXT4,
  61 #endif
  62 #ifdef CONFIG_ENV_IS_IN_FAT
  63         ENVL_FAT,
  64 #endif
  65 #ifdef CONFIG_ENV_IS_IN_FLASH
  66         ENVL_FLASH,
  67 #endif
  68 #ifdef CONFIG_ENV_IS_IN_MMC
  69         ENVL_MMC,
  70 #endif
  71 #ifdef CONFIG_ENV_IS_IN_NAND
  72         ENVL_NAND,
  73 #endif
  74 #ifdef CONFIG_ENV_IS_IN_NVRAM
  75         ENVL_NVRAM,
  76 #endif
  77 #ifdef CONFIG_ENV_IS_IN_REMOTE
  78         ENVL_REMOTE,
  79 #endif
  80 #ifdef CONFIG_ENV_IS_IN_SATA
  81         ENVL_ESATA,
  82 #endif
  83 #ifdef CONFIG_ENV_IS_IN_SPI_FLASH
  84         ENVL_SPI_FLASH,
  85 #endif
  86 #ifdef CONFIG_ENV_IS_IN_UBI
  87         ENVL_UBI,
  88 #endif
  89 #ifdef CONFIG_ENV_IS_NOWHERE
  90         ENVL_NOWHERE,
  91 #endif
  92 };
  93
  94 static bool env_has_inited(enum env_location location)
  95 {
  96         return gd->env_has_init & BIT(location);
  97 }
  98
  99 static void env_set_inited(enum env_location location)
 100 {
 101         /*
 102          * We're using a 32-bits bitmask stored in gd (env_has_init)
 103          * using the above enum value as the bit index. We need to
 104          * make sure that we're not overflowing it.
 105          */
 106         BUILD_BUG_ON(ENVL_COUNT > BITS_PER_LONG);
 107
 108         gd->env_has_init |= BIT(location);
 109 }
 110
 111 /**
 112  * env_get_location() - Returns the best env location for a board
 113  * @op: operations performed on the environment
 114  * @prio: priority between the multiple environments, 0 being the
 115  *        highest priority
 116  *
 117  * This will return the preferred environment for the given priority.
 118  * This is overridable by boards if they need to.
 119  *
 120  * All implementations are free to use the operation, the priority and
 121  * any other data relevant to their choice, but must take into account
 122  * the fact that the lowest prority (0) is the most important location
 123  * in the system. The following locations should be returned by order
 124  * of descending priorities, from the highest to the lowest priority.
 125  *
 126  * Returns:
 127  * an enum env_location value on success, a negative error code otherwise
 128  */
 129 __weak enum env_location env_get_location(enum env_operation op, int prio)
 130 {
 131         if (prio >= ARRAY_SIZE(env_locations))
 132                 return ENVL_UNKNOWN;
 133
 134         return env_locations[prio];
 135 }
 136
 137
 138 /**
 139  * env_driver_lookup() - Finds the most suited environment location
 140  * @op: operations performed on the environment
 141  * @prio: priority between the multiple environments, 0 being the
 142  *        highest priority
 143  *
 144  * This will try to find the available environment with the highest
 145  * priority in the system.
 146  *
 147  * Returns:
 148  * NULL on error, a pointer to a struct env_driver otherwise
 149  */
 150 static struct env_driver *env_driver_lookup(enum env_operation op, int prio)
 151 {
 152         enum env_location loc = env_get_location(op, prio);
 153         struct env_driver *drv;
 154
 155         if (loc == ENVL_UNKNOWN)
 156                 return NULL;
 157
 158         drv = _env_driver_lookup(loc);
 159         if (!drv) {
 160                 debug("%s: No environment driver for location %d\n", __func__,
 161                       loc);
 162                 return NULL;
 163         }
 164
 165         return drv;
 166 }
 167
 168 __weak int env_get_char_spec(int index)
 169 {
 170         return *(uchar *)(gd->env_addr + index);
 171 }
 172
 173 int env_get_char(int index)
 174 {
 175         if (gd->env_valid == ENV_INVALID)
 176                 return default_environment[index];
 177         else
 178                 return env_get_char_spec(index);
 179 }
 180
 181 int env_load(void)
 182 {
 183         struct env_driver *drv;
 184         int best_prio = -1;
 185         int prio;
 186
 187         for (prio = 0; (drv = env_driver_lookup(ENVOP_LOAD, prio)); prio++) {
 188                 int ret;
 189
 190                 if (!env_has_inited(drv->location))
 191                         continue;
 192
 193                 printf("Loading Environment from %s... ", drv->name);
 194                 /*
 195                  * In error case, the error message must be printed during
 196                  * drv->load() in some underlying API, and it must be exactly
 197                  * one message.
 198                  */
 199                 ret = drv->load();
 200                 if (!ret) {
 201                         printf("OK\n");
 202                         gd->env_load_prio = prio;
 203
 204 #if !CONFIG_IS_ENABLED(ENV_APPEND)
 205                         return 0;
 206 #endif
 207                 } else if (ret == -ENOMSG) {
 208                         /* Handle "bad CRC" case */
 209                         if (best_prio == -1)
 210                                 best_prio = prio;
 211                 } else {
 212                         debug("Failed (%d)\n", ret);
 213                 }
 214         }
 215
 216         /*
 217          * In case of invalid environment, we set the 'default' env location
 218          * to the best choice, i.e.:
 219          *   1. Environment location with bad CRC, if such location was found
 220          *   2. Otherwise use the location with highest priority
 221          *
 222          * This way, next calls to env_save() will restore the environment
 223          * at the right place.
 224          */
 225         if (best_prio >= 0)
 226                 debug("Selecting environment with bad CRC\n");
 227         else
 228                 best_prio = 0;
 229
 230         gd->env_load_prio = best_prio;
 231
 232         return -ENODEV;
 233 }
 234
 235 int env_reload(void)
 236 {
 237         struct env_driver *drv;
 238
 239         drv = env_driver_lookup(ENVOP_LOAD, gd->env_load_prio);
 240         if (drv) {
 241                 int ret;
 242
 243                 printf("Loading Environment from %s... ", drv->name);
 244
 245                 if (!env_has_inited(drv->location)) {
 246                         printf("not initialized\n");
 247                         return -ENODEV;
 248                 }
 249
 250                 ret = drv->load();
 251                 if (ret)
 252                         printf("Failed (%d)\n", ret);
 253                 else
 254                         printf("OK\n");
 255
 256                 if (!ret)
 257                         return 0;
 258         }
 259
 260         return -ENODEV;
 261 }
 262
 263 int env_save(void)
 264 {
 265         struct env_driver *drv;
 266
 267         drv = env_driver_lookup(ENVOP_SAVE, gd->env_load_prio);
 268         if (drv) {
 269                 int ret;
 270
 271                 printf("Saving Environment to %s... ", drv->name);
 272                 if (!drv->save) {
 273                         printf("not possible\n");
 274                         return -ENODEV;
 275                 }
 276
 277                 if (!env_has_inited(drv->location)) {
 278                         printf("not initialized\n");
 279                         return -ENODEV;
 280                 }
 281
 282                 ret = drv->save();
 283                 if (ret)
 284                         printf("Failed (%d)\n", ret);
 285                 else
 286                         printf("OK\n");
 287
 288                 if (!ret)
 289                         return 0;
 290         }
 291
 292         return -ENODEV;
 293 }
 294
 295 int env_erase(void)
 296 {
 297         struct env_driver *drv;
 298
 299         drv = env_driver_lookup(ENVOP_ERASE, gd->env_load_prio);
 300         if (drv) {
 301                 int ret;
 302
 303                 if (!drv->erase)
 304                         return -ENODEV;
 305
 306                 if (!env_has_inited(drv->location))
 307                         return -ENODEV;
 308
 309                 printf("Erasing Environment on %s... ", drv->name);
 310                 ret = drv->erase();
 311                 if (ret)
 312                         printf("Failed (%d)\n", ret);
 313                 else
 314                         printf("OK\n");
 315
 316                 if (!ret)
 317                         return 0;
 318         }
 319
 320         return -ENODEV;
 321 }
 322
 323 int env_init(void)
 324 {
 325         struct env_driver *drv;
 326         int ret = -ENOENT;
 327         int prio;
 328
 329         for (prio = 0; (drv = env_driver_lookup(ENVOP_INIT, prio)); prio++) {
 330                 if (!drv->init || !(ret = drv->init()))
 331                         env_set_inited(drv->location);
 332
 333                 debug("%s: Environment %s init done (ret=%d)\n", __func__,
 334                       drv->name, ret);
 335         }
 336
 337         if (!prio)
 338                 return -ENODEV;
 339
 340         if (ret == -ENOENT) {
 341                 gd->env_addr = (ulong)&default_environment[0];
 342                 gd->env_valid = ENV_VALID;
 343
 344                 return 0;
 345         }
 346
 347         return ret;
 348 }
 349
 350 int env_select(const char *name)
 351 {
 352         struct env_driver *drv;
 353         const int n_ents = ll_entry_count(struct env_driver, env_driver);
 354         struct env_driver *entry;
 355         int prio;
 356         bool found = false;
 357
 358         printf("Select Environment on %s: ", name);
 359
 360         /* search ENV driver by name */
 361         drv = ll_entry_start(struct env_driver, env_driver);
 362         for (entry = drv; entry != drv + n_ents; entry++) {
 363                 if (!strcmp(entry->name, name)) {
 364                         found = true;
 365                         break;
 366                 }
 367         }
 368
 369         if (!found) {
 370                 printf("driver not found\n");
 371                 return -ENODEV;
 372         }
 373
 374         /* search priority by driver */
 375         for (prio = 0; (drv = env_driver_lookup(ENVOP_INIT, prio)); prio++) {
 376                 if (entry->location == env_get_location(ENVOP_LOAD, prio)) {
 377                         /* when priority change, reset the ENV flags */
 378                         if (gd->env_load_prio != prio) {
 379                                 gd->env_load_prio = prio;
 380                                 gd->env_valid = ENV_INVALID;
 381                                 gd->flags &= ~GD_FLG_ENV_DEFAULT;
 382                         }
 383                         printf("OK\n");
 384                         return 0;
 385                 }
 386         }
 387         printf("priority not found\n");
 388
 389         return -ENODEV;
 390 }