blob: e53400800606e20d3976eb5f123d51dfe131e829 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassc9d728d2017-08-03 12:22:00 -06002/*
3 * Copyright (C) 2017 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
Simon Glassc9d728d2017-08-03 12:22:00 -06005 */
6
7#include <common.h>
Simon Glass4bfd1f52019-08-01 09:46:43 -06008#include <env.h>
Simon Glassf3998fd2019-08-02 09:44:25 -06009#include <env_internal.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060010#include <log.h>
Simon Glass401d1c42020-10-30 21:38:53 -060011#include <asm/global_data.h>
Simon Glasscd93d622020-05-10 11:40:13 -060012#include <linux/bitops.h>
Simon Glasseb41d8a2020-05-10 11:40:08 -060013#include <linux/bug.h>
Simon Glassc9d728d2017-08-03 12:22:00 -060014
15DECLARE_GLOBAL_DATA_PTR;
16
Siva Durga Prasad Paladugu7bcdf192018-04-13 07:57:21 +020017#if defined(CONFIG_NEEDS_MANUAL_RELOC)
18void env_fix_drivers(void)
19{
20 struct env_driver *drv;
21 const int n_ents = ll_entry_count(struct env_driver, env_driver);
22 struct env_driver *entry;
23
24 drv = ll_entry_start(struct env_driver, env_driver);
25 for (entry = drv; entry != drv + n_ents; entry++) {
26 if (entry->name)
27 entry->name += gd->reloc_off;
28 if (entry->load)
29 entry->load += gd->reloc_off;
30 if (entry->save)
31 entry->save += gd->reloc_off;
Frank Wunderlichcd121bd2019-06-29 11:36:19 +020032 if (entry->erase)
33 entry->erase += gd->reloc_off;
Siva Durga Prasad Paladugu7bcdf192018-04-13 07:57:21 +020034 if (entry->init)
35 entry->init += gd->reloc_off;
36 }
37}
38#endif
39
Maxime Ripard52746c42018-01-23 21:16:51 +010040static struct env_driver *_env_driver_lookup(enum env_location loc)
Simon Glassc9d728d2017-08-03 12:22:00 -060041{
42 struct env_driver *drv;
43 const int n_ents = ll_entry_count(struct env_driver, env_driver);
44 struct env_driver *entry;
45
46 drv = ll_entry_start(struct env_driver, env_driver);
47 for (entry = drv; entry != drv + n_ents; entry++) {
48 if (loc == entry->location)
49 return entry;
50 }
51
52 /* Not found */
53 return NULL;
54}
55
Maxime Ripard7d714a22018-01-23 21:16:58 +010056static enum env_location env_locations[] = {
57#ifdef CONFIG_ENV_IS_IN_EEPROM
58 ENVL_EEPROM,
59#endif
60#ifdef CONFIG_ENV_IS_IN_EXT4
61 ENVL_EXT4,
62#endif
63#ifdef CONFIG_ENV_IS_IN_FAT
64 ENVL_FAT,
65#endif
66#ifdef CONFIG_ENV_IS_IN_FLASH
67 ENVL_FLASH,
68#endif
69#ifdef CONFIG_ENV_IS_IN_MMC
70 ENVL_MMC,
71#endif
72#ifdef CONFIG_ENV_IS_IN_NAND
73 ENVL_NAND,
74#endif
75#ifdef CONFIG_ENV_IS_IN_NVRAM
76 ENVL_NVRAM,
77#endif
78#ifdef CONFIG_ENV_IS_IN_REMOTE
79 ENVL_REMOTE,
80#endif
Ye Li9a6a3112019-01-04 09:34:24 +000081#ifdef CONFIG_ENV_IS_IN_SATA
82 ENVL_ESATA,
83#endif
Maxime Ripard7d714a22018-01-23 21:16:58 +010084#ifdef CONFIG_ENV_IS_IN_SPI_FLASH
85 ENVL_SPI_FLASH,
86#endif
87#ifdef CONFIG_ENV_IS_IN_UBI
88 ENVL_UBI,
89#endif
90#ifdef CONFIG_ENV_IS_NOWHERE
91 ENVL_NOWHERE,
92#endif
93};
94
Maxime Ripard1d446082018-01-23 21:16:59 +010095static bool env_has_inited(enum env_location location)
96{
97 return gd->env_has_init & BIT(location);
98}
99
100static void env_set_inited(enum env_location location)
101{
102 /*
103 * We're using a 32-bits bitmask stored in gd (env_has_init)
104 * using the above enum value as the bit index. We need to
105 * make sure that we're not overflowing it.
106 */
Patrick Delaunayd5a6a5a2020-06-24 09:27:25 +0200107 BUILD_BUG_ON(ENVL_COUNT > BITS_PER_LONG);
Maxime Ripard1d446082018-01-23 21:16:59 +0100108
109 gd->env_has_init |= BIT(location);
110}
111
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100112/**
113 * env_get_location() - Returns the best env location for a board
114 * @op: operations performed on the environment
115 * @prio: priority between the multiple environments, 0 being the
116 * highest priority
117 *
118 * This will return the preferred environment for the given priority.
Maxime Ripard40c08a62018-01-23 21:17:02 +0100119 * This is overridable by boards if they need to.
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100120 *
121 * All implementations are free to use the operation, the priority and
122 * any other data relevant to their choice, but must take into account
123 * the fact that the lowest prority (0) is the most important location
124 * in the system. The following locations should be returned by order
125 * of descending priorities, from the highest to the lowest priority.
126 *
127 * Returns:
128 * an enum env_location value on success, a negative error code otherwise
129 */
Maxime Ripard40c08a62018-01-23 21:17:02 +0100130__weak enum env_location env_get_location(enum env_operation op, int prio)
Simon Glassc9d728d2017-08-03 12:22:00 -0600131{
Nicholas Faustinid30ba232018-07-23 10:01:07 +0200132 if (prio >= ARRAY_SIZE(env_locations))
133 return ENVL_UNKNOWN;
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100134
Nicholas Faustinid30ba232018-07-23 10:01:07 +0200135 return env_locations[prio];
Simon Glassc9d728d2017-08-03 12:22:00 -0600136}
137
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100138
139/**
140 * env_driver_lookup() - Finds the most suited environment location
141 * @op: operations performed on the environment
142 * @prio: priority between the multiple environments, 0 being the
143 * highest priority
144 *
145 * This will try to find the available environment with the highest
146 * priority in the system.
147 *
148 * Returns:
149 * NULL on error, a pointer to a struct env_driver otherwise
150 */
151static struct env_driver *env_driver_lookup(enum env_operation op, int prio)
Simon Glassc9d728d2017-08-03 12:22:00 -0600152{
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100153 enum env_location loc = env_get_location(op, prio);
Simon Glassc9d728d2017-08-03 12:22:00 -0600154 struct env_driver *drv;
155
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100156 if (loc == ENVL_UNKNOWN)
157 return NULL;
158
Maxime Ripard52746c42018-01-23 21:16:51 +0100159 drv = _env_driver_lookup(loc);
Simon Glassc9d728d2017-08-03 12:22:00 -0600160 if (!drv) {
161 debug("%s: No environment driver for location %d\n", __func__,
162 loc);
163 return NULL;
164 }
165
166 return drv;
167}
168
Goldschmidt Simonb2cdef42018-02-09 20:23:17 +0000169__weak int env_get_char_spec(int index)
170{
171 return *(uchar *)(gd->env_addr + index);
172}
173
Simon Glassa69d0f62017-08-03 12:22:06 -0600174int env_get_char(int index)
Simon Glassc9d728d2017-08-03 12:22:00 -0600175{
Simon Glass2d7cb5b2017-08-20 04:45:15 -0600176 if (gd->env_valid == ENV_INVALID)
Simon Glassa69d0f62017-08-03 12:22:06 -0600177 return default_environment[index];
Goldschmidt Simonb2cdef42018-02-09 20:23:17 +0000178 else
179 return env_get_char_spec(index);
Simon Glassc9d728d2017-08-03 12:22:00 -0600180}
181
182int env_load(void)
183{
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100184 struct env_driver *drv;
Sam Protsenko293a1722019-01-18 21:19:04 +0200185 int best_prio = -1;
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100186 int prio;
Simon Glassc9d728d2017-08-03 12:22:00 -0600187
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100188 for (prio = 0; (drv = env_driver_lookup(ENVOP_LOAD, prio)); prio++) {
189 int ret;
190
Maxime Ripard1d446082018-01-23 21:16:59 +0100191 if (!env_has_inited(drv->location))
192 continue;
193
Maxime Ripard3574ba02018-01-23 21:16:54 +0100194 printf("Loading Environment from %s... ", drv->name);
Sam Protsenko13bbfb42018-07-30 19:19:26 +0300195 /*
196 * In error case, the error message must be printed during
197 * drv->load() in some underlying API, and it must be exactly
198 * one message.
199 */
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100200 ret = drv->load();
Sam Protsenko293a1722019-01-18 21:19:04 +0200201 if (!ret) {
Maxime Ripard3574ba02018-01-23 21:16:54 +0100202 printf("OK\n");
Patrick Delaunay6d8d8402020-07-28 11:51:17 +0200203 gd->env_load_prio = prio;
204
Marek Vasut47f3b1f2020-07-07 20:51:38 +0200205#if !CONFIG_IS_ENABLED(ENV_APPEND)
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100206 return 0;
Marek Vasut47f3b1f2020-07-07 20:51:38 +0200207#endif
Sam Protsenko293a1722019-01-18 21:19:04 +0200208 } else if (ret == -ENOMSG) {
209 /* Handle "bad CRC" case */
210 if (best_prio == -1)
211 best_prio = prio;
212 } else {
213 debug("Failed (%d)\n", ret);
Sam Protsenko13bbfb42018-07-30 19:19:26 +0300214 }
Simon Glassc9d728d2017-08-03 12:22:00 -0600215 }
216
Nicholas Faustinid30ba232018-07-23 10:01:07 +0200217 /*
218 * In case of invalid environment, we set the 'default' env location
Sam Protsenko293a1722019-01-18 21:19:04 +0200219 * to the best choice, i.e.:
220 * 1. Environment location with bad CRC, if such location was found
221 * 2. Otherwise use the location with highest priority
222 *
223 * This way, next calls to env_save() will restore the environment
224 * at the right place.
Nicholas Faustinid30ba232018-07-23 10:01:07 +0200225 */
Sam Protsenko293a1722019-01-18 21:19:04 +0200226 if (best_prio >= 0)
227 debug("Selecting environment with bad CRC\n");
228 else
229 best_prio = 0;
Patrick Delaunay6d8d8402020-07-28 11:51:17 +0200230
231 gd->env_load_prio = best_prio;
Nicholas Faustinid30ba232018-07-23 10:01:07 +0200232
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100233 return -ENODEV;
Simon Glassc9d728d2017-08-03 12:22:00 -0600234}
235
Patrick Delaunay0115dd32020-07-28 11:51:20 +0200236int env_reload(void)
237{
238 struct env_driver *drv;
239
240 drv = env_driver_lookup(ENVOP_LOAD, gd->env_load_prio);
241 if (drv) {
242 int ret;
243
244 printf("Loading Environment from %s... ", drv->name);
245
246 if (!env_has_inited(drv->location)) {
247 printf("not initialized\n");
248 return -ENODEV;
249 }
250
251 ret = drv->load();
252 if (ret)
253 printf("Failed (%d)\n", ret);
254 else
255 printf("OK\n");
256
257 if (!ret)
258 return 0;
259 }
260
261 return -ENODEV;
262}
263
Simon Glassc9d728d2017-08-03 12:22:00 -0600264int env_save(void)
265{
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100266 struct env_driver *drv;
Simon Glassc9d728d2017-08-03 12:22:00 -0600267
Nicholas Faustinid30ba232018-07-23 10:01:07 +0200268 drv = env_driver_lookup(ENVOP_SAVE, gd->env_load_prio);
269 if (drv) {
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100270 int ret;
Maxime Ripard9c24dfb2018-01-23 21:16:50 +0100271
Maxime Ripard9efac3c2018-01-23 21:16:53 +0100272 printf("Saving Environment to %s... ", drv->name);
Patrick Delaunay89682882020-06-24 10:17:50 +0200273 if (!drv->save) {
274 printf("not possible\n");
275 return -ENODEV;
276 }
277
278 if (!env_has_inited(drv->location)) {
279 printf("not initialized\n");
280 return -ENODEV;
281 }
282
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100283 ret = drv->save();
Maxime Ripard3574ba02018-01-23 21:16:54 +0100284 if (ret)
285 printf("Failed (%d)\n", ret);
286 else
287 printf("OK\n");
288
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100289 if (!ret)
290 return 0;
Simon Glassc9d728d2017-08-03 12:22:00 -0600291 }
292
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100293 return -ENODEV;
Simon Glassc9d728d2017-08-03 12:22:00 -0600294}
295
Frank Wunderlichcd121bd2019-06-29 11:36:19 +0200296int env_erase(void)
297{
298 struct env_driver *drv;
299
300 drv = env_driver_lookup(ENVOP_ERASE, gd->env_load_prio);
301 if (drv) {
302 int ret;
303
304 if (!drv->erase)
305 return -ENODEV;
306
307 if (!env_has_inited(drv->location))
308 return -ENODEV;
309
310 printf("Erasing Environment on %s... ", drv->name);
311 ret = drv->erase();
312 if (ret)
313 printf("Failed (%d)\n", ret);
314 else
315 printf("OK\n");
316
317 if (!ret)
318 return 0;
319 }
320
321 return -ENODEV;
322}
323
Simon Glass6eeae422017-08-03 12:22:05 -0600324int env_init(void)
Simon Glassc9d728d2017-08-03 12:22:00 -0600325{
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100326 struct env_driver *drv;
Simon Glass79388222017-08-03 12:22:02 -0600327 int ret = -ENOENT;
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100328 int prio;
Simon Glassc9d728d2017-08-03 12:22:00 -0600329
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100330 for (prio = 0; (drv = env_driver_lookup(ENVOP_INIT, prio)); prio++) {
Maxime Ripard1d446082018-01-23 21:16:59 +0100331 if (!drv->init || !(ret = drv->init()))
332 env_set_inited(drv->location);
Heiko Schocher46ce9e72020-11-03 15:22:36 +0100333 if (ret == -ENOENT)
334 env_set_inited(drv->location);
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100335
Maxime Ripard1d446082018-01-23 21:16:59 +0100336 debug("%s: Environment %s init done (ret=%d)\n", __func__,
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100337 drv->name, ret);
Marek Vasut5557eec2021-01-20 15:45:16 +0100338
339 if (gd->env_valid == ENV_INVALID)
340 ret = -ENOENT;
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100341 }
342
343 if (!prio)
344 return -ENODEV;
345
Simon Glass79388222017-08-03 12:22:02 -0600346 if (ret == -ENOENT) {
347 gd->env_addr = (ulong)&default_environment[0];
Tom Rinieeba55c2017-08-19 22:27:57 -0400348 gd->env_valid = ENV_VALID;
Simon Glass79388222017-08-03 12:22:02 -0600349
350 return 0;
Simon Glassc9d728d2017-08-03 12:22:00 -0600351 }
352
Maxime Ripard8a3a7e22018-01-23 21:16:52 +0100353 return ret;
Simon Glassc9d728d2017-08-03 12:22:00 -0600354}
Patrick Delaunaya97d22e2020-07-28 11:51:21 +0200355
356int env_select(const char *name)
357{
358 struct env_driver *drv;
359 const int n_ents = ll_entry_count(struct env_driver, env_driver);
360 struct env_driver *entry;
361 int prio;
362 bool found = false;
363
364 printf("Select Environment on %s: ", name);
365
366 /* search ENV driver by name */
367 drv = ll_entry_start(struct env_driver, env_driver);
368 for (entry = drv; entry != drv + n_ents; entry++) {
369 if (!strcmp(entry->name, name)) {
370 found = true;
371 break;
372 }
373 }
374
375 if (!found) {
376 printf("driver not found\n");
377 return -ENODEV;
378 }
379
380 /* search priority by driver */
381 for (prio = 0; (drv = env_driver_lookup(ENVOP_INIT, prio)); prio++) {
382 if (entry->location == env_get_location(ENVOP_LOAD, prio)) {
383 /* when priority change, reset the ENV flags */
384 if (gd->env_load_prio != prio) {
385 gd->env_load_prio = prio;
386 gd->env_valid = ENV_INVALID;
387 gd->flags &= ~GD_FLG_ENV_DEFAULT;
388 }
389 printf("OK\n");
390 return 0;
391 }
392 }
393 printf("priority not found\n");
394
395 return -ENODEV;
396}