X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=env%2Fenv.c;h=9237bb9c742a5242940cd6248751bc5d4eef86fa;hb=16ad946f41d3dc3e475d8313f4acbba0df527a2a;hp=d4f5e35b1e0d800f55fd6fe6467b2aa3846059d3;hpb=1d4460871b46e0ed5c81ff7d8eea50e7fc9a66e5;p=oweals%2Fu-boot.git diff --git a/env/env.c b/env/env.c index d4f5e35b1e..9237bb9c74 100644 --- a/env/env.c +++ b/env/env.c @@ -1,15 +1,38 @@ +// SPDX-License-Identifier: GPL-2.0+ /* * Copyright (C) 2017 Google, Inc * Written by Simon Glass - * - * SPDX-License-Identifier: GPL-2.0+ */ #include -#include +#include +#include DECLARE_GLOBAL_DATA_PTR; +#if defined(CONFIG_NEEDS_MANUAL_RELOC) +void env_fix_drivers(void) +{ + struct env_driver *drv; + const int n_ents = ll_entry_count(struct env_driver, env_driver); + struct env_driver *entry; + + drv = ll_entry_start(struct env_driver, env_driver); + for (entry = drv; entry != drv + n_ents; entry++) { + if (entry->name) + entry->name += gd->reloc_off; + if (entry->load) + entry->load += gd->reloc_off; + if (entry->save) + entry->save += gd->reloc_off; + if (entry->erase) + entry->erase += gd->reloc_off; + if (entry->init) + entry->init += gd->reloc_off; + } +} +#endif + static struct env_driver *_env_driver_lookup(enum env_location loc) { struct env_driver *drv; @@ -51,6 +74,9 @@ static enum env_location env_locations[] = { #ifdef CONFIG_ENV_IS_IN_REMOTE ENVL_REMOTE, #endif +#ifdef CONFIG_ENV_IS_IN_SATA + ENVL_ESATA, +#endif #ifdef CONFIG_ENV_IS_IN_SPI_FLASH ENVL_SPI_FLASH, #endif @@ -62,8 +88,6 @@ static enum env_location env_locations[] = { #endif }; -static enum env_location env_load_location = ENVL_UNKNOWN; - static bool env_has_inited(enum env_location location) { return gd->env_has_init & BIT(location); @@ -88,6 +112,7 @@ static void env_set_inited(enum env_location location) * highest priority * * This will return the preferred environment for the given priority. + * This is overridable by boards if they need to. * * All implementations are free to use the operation, the priority and * any other data relevant to their choice, but must take into account @@ -98,23 +123,14 @@ static void env_set_inited(enum env_location location) * Returns: * an enum env_location value on success, a negative error code otherwise */ -static enum env_location env_get_location(enum env_operation op, int prio) +__weak enum env_location env_get_location(enum env_operation op, int prio) { - switch (op) { - case ENVOP_GET_CHAR: - case ENVOP_INIT: - case ENVOP_LOAD: - if (prio >= ARRAY_SIZE(env_locations)) - return ENVL_UNKNOWN; - - env_load_location = env_locations[prio]; - return env_load_location; - - case ENVOP_SAVE: - return env_load_location; - } + if (prio >= ARRAY_SIZE(env_locations)) + return ENVL_UNKNOWN; - return ENVL_UNKNOWN; + gd->env_load_prio = prio; + + return env_locations[prio]; } @@ -148,50 +164,87 @@ static struct env_driver *env_driver_lookup(enum env_operation op, int prio) return drv; } -int env_get_char(int index) +__weak int env_get_char_spec(int index) { - struct env_driver *drv; - int prio; + return *(uchar *)(gd->env_addr + index); +} +int env_get_char(int index) +{ if (gd->env_valid == ENV_INVALID) return default_environment[index]; + else + return env_get_char_spec(index); +} - for (prio = 0; (drv = env_driver_lookup(ENVOP_GET_CHAR, prio)); prio++) { +int env_load(void) +{ + struct env_driver *drv; + int best_prio = -1; + int prio; + + for (prio = 0; (drv = env_driver_lookup(ENVOP_LOAD, prio)); prio++) { int ret; - if (!drv->get_char) + if (!drv->load) continue; if (!env_has_inited(drv->location)) continue; - ret = drv->get_char(index); - if (!ret) + printf("Loading Environment from %s... ", drv->name); + /* + * In error case, the error message must be printed during + * drv->load() in some underlying API, and it must be exactly + * one message. + */ + ret = drv->load(); + if (!ret) { + printf("OK\n"); return 0; - - debug("%s: Environment %s failed to load (err=%d)\n", __func__, - drv->name, ret); + } else if (ret == -ENOMSG) { + /* Handle "bad CRC" case */ + if (best_prio == -1) + best_prio = prio; + } else { + debug("Failed (%d)\n", ret); + } } + /* + * In case of invalid environment, we set the 'default' env location + * to the best choice, i.e.: + * 1. Environment location with bad CRC, if such location was found + * 2. Otherwise use the location with highest priority + * + * This way, next calls to env_save() will restore the environment + * at the right place. + */ + if (best_prio >= 0) + debug("Selecting environment with bad CRC\n"); + else + best_prio = 0; + env_get_location(ENVOP_LOAD, best_prio); + return -ENODEV; } -int env_load(void) +int env_save(void) { struct env_driver *drv; - int prio; - for (prio = 0; (drv = env_driver_lookup(ENVOP_LOAD, prio)); prio++) { + drv = env_driver_lookup(ENVOP_SAVE, gd->env_load_prio); + if (drv) { int ret; - if (!drv->load) - continue; + if (!drv->save) + return -ENODEV; if (!env_has_inited(drv->location)) - continue; + return -ENODEV; - printf("Loading Environment from %s... ", drv->name); - ret = drv->load(); + printf("Saving Environment to %s... ", drv->name); + ret = drv->save(); if (ret) printf("Failed (%d)\n", ret); else @@ -204,22 +257,22 @@ int env_load(void) return -ENODEV; } -int env_save(void) +int env_erase(void) { struct env_driver *drv; - int prio; - for (prio = 0; (drv = env_driver_lookup(ENVOP_SAVE, prio)); prio++) { + drv = env_driver_lookup(ENVOP_ERASE, gd->env_load_prio); + if (drv) { int ret; - if (!drv->save) - continue; + if (!drv->erase) + return -ENODEV; if (!env_has_inited(drv->location)) - continue; + return -ENODEV; - printf("Saving Environment to %s... ", drv->name); - ret = drv->save(); + printf("Erasing Environment on %s... ", drv->name); + ret = drv->erase(); if (ret) printf("Failed (%d)\n", ret); else