1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2017 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
5 */
6
7 #include <common.h>
8 #include <environment.h>
9
10 DECLARE_GLOBAL_DATA_PTR;
11
12 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
env_fix_drivers(void)13 void env_fix_drivers(void)
14 {
15 struct env_driver *drv;
16 const int n_ents = ll_entry_count(struct env_driver, env_driver);
17 struct env_driver *entry;
18
19 drv = ll_entry_start(struct env_driver, env_driver);
20 for (entry = drv; entry != drv + n_ents; entry++) {
21 if (entry->name)
22 entry->name += gd->reloc_off;
23 if (entry->load)
24 entry->load += gd->reloc_off;
25 if (entry->save)
26 entry->save += gd->reloc_off;
27 if (entry->init)
28 entry->init += gd->reloc_off;
29 }
30 }
31 #endif
32
_env_driver_lookup(enum env_location loc)33 static struct env_driver *_env_driver_lookup(enum env_location loc)
34 {
35 struct env_driver *drv;
36 const int n_ents = ll_entry_count(struct env_driver, env_driver);
37 struct env_driver *entry;
38
39 drv = ll_entry_start(struct env_driver, env_driver);
40 for (entry = drv; entry != drv + n_ents; entry++) {
41 if (loc == entry->location)
42 return entry;
43 }
44
45 /* Not found */
46 return NULL;
47 }
48
49 static enum env_location env_locations[] = {
50 #ifdef CONFIG_ENV_IS_IN_EEPROM
51 ENVL_EEPROM,
52 #endif
53 #ifdef CONFIG_ENV_IS_IN_EXT4
54 ENVL_EXT4,
55 #endif
56 #ifdef CONFIG_ENV_IS_IN_FAT
57 ENVL_FAT,
58 #endif
59 #ifdef CONFIG_ENV_IS_IN_FLASH
60 ENVL_FLASH,
61 #endif
62 #ifdef CONFIG_ENV_IS_IN_MMC
63 ENVL_MMC,
64 #endif
65 #ifdef CONFIG_ENV_IS_IN_NAND
66 ENVL_NAND,
67 #endif
68 #ifdef CONFIG_ENV_IS_IN_NVRAM
69 ENVL_NVRAM,
70 #endif
71 #ifdef CONFIG_ENV_IS_IN_REMOTE
72 ENVL_REMOTE,
73 #endif
74 #ifdef CONFIG_ENV_IS_IN_SATA
75 ENVL_ESATA,
76 #endif
77 #ifdef CONFIG_ENV_IS_IN_SPI_FLASH
78 ENVL_SPI_FLASH,
79 #endif
80 #ifdef CONFIG_ENV_IS_IN_UBI
81 ENVL_UBI,
82 #endif
83 #ifdef CONFIG_ENV_IS_NOWHERE
84 ENVL_NOWHERE,
85 #endif
86 };
87
env_has_inited(enum env_location location)88 static bool env_has_inited(enum env_location location)
89 {
90 return gd->env_has_init & BIT(location);
91 }
92
env_set_inited(enum env_location location)93 static void env_set_inited(enum env_location location)
94 {
95 /*
96 * We're using a 32-bits bitmask stored in gd (env_has_init)
97 * using the above enum value as the bit index. We need to
98 * make sure that we're not overflowing it.
99 */
100 BUILD_BUG_ON(ARRAY_SIZE(env_locations) > BITS_PER_LONG);
101
102 gd->env_has_init |= BIT(location);
103 }
104
105 /**
106 * env_get_location() - Returns the best env location for a board
107 * @op: operations performed on the environment
108 * @prio: priority between the multiple environments, 0 being the
109 * highest priority
110 *
111 * This will return the preferred environment for the given priority.
112 * This is overridable by boards if they need to.
113 *
114 * All implementations are free to use the operation, the priority and
115 * any other data relevant to their choice, but must take into account
116 * the fact that the lowest prority (0) is the most important location
117 * in the system. The following locations should be returned by order
118 * of descending priorities, from the highest to the lowest priority.
119 *
120 * Returns:
121 * an enum env_location value on success, a negative error code otherwise
122 */
env_get_location(enum env_operation op,int prio)123 __weak enum env_location env_get_location(enum env_operation op, int prio)
124 {
125 if (prio >= ARRAY_SIZE(env_locations))
126 return ENVL_UNKNOWN;
127
128 gd->env_load_prio = prio;
129
130 return env_locations[prio];
131 }
132
133
134 /**
135 * env_driver_lookup() - Finds the most suited environment location
136 * @op: operations performed on the environment
137 * @prio: priority between the multiple environments, 0 being the
138 * highest priority
139 *
140 * This will try to find the available environment with the highest
141 * priority in the system.
142 *
143 * Returns:
144 * NULL on error, a pointer to a struct env_driver otherwise
145 */
env_driver_lookup(enum env_operation op,int prio)146 static struct env_driver *env_driver_lookup(enum env_operation op, int prio)
147 {
148 enum env_location loc = env_get_location(op, prio);
149 struct env_driver *drv;
150
151 if (loc == ENVL_UNKNOWN)
152 return NULL;
153
154 drv = _env_driver_lookup(loc);
155 if (!drv) {
156 debug("%s: No environment driver for location %d\n", __func__,
157 loc);
158 return NULL;
159 }
160
161 return drv;
162 }
163
env_get_char_spec(int index)164 __weak int env_get_char_spec(int index)
165 {
166 return *(uchar *)(gd->env_addr + index);
167 }
168
env_get_char(int index)169 int env_get_char(int index)
170 {
171 if (gd->env_valid == ENV_INVALID)
172 return default_environment[index];
173 else
174 return env_get_char_spec(index);
175 }
176
env_load(void)177 int env_load(void)
178 {
179 struct env_driver *drv;
180 int best_prio = -1;
181 int prio;
182
183 for (prio = 0; (drv = env_driver_lookup(ENVOP_LOAD, prio)); prio++) {
184 int ret;
185
186 if (!drv->load)
187 continue;
188
189 if (!env_has_inited(drv->location))
190 continue;
191
192 printf("Loading Environment from %s... ", drv->name);
193 /*
194 * In error case, the error message must be printed during
195 * drv->load() in some underlying API, and it must be exactly
196 * one message.
197 */
198 ret = drv->load();
199 if (!ret) {
200 printf("OK\n");
201 return 0;
202 } else if (ret == -ENOMSG) {
203 /* Handle "bad CRC" case */
204 if (best_prio == -1)
205 best_prio = prio;
206 } else {
207 debug("Failed (%d)\n", ret);
208 }
209 }
210
211 /*
212 * In case of invalid environment, we set the 'default' env location
213 * to the best choice, i.e.:
214 * 1. Environment location with bad CRC, if such location was found
215 * 2. Otherwise use the location with highest priority
216 *
217 * This way, next calls to env_save() will restore the environment
218 * at the right place.
219 */
220 if (best_prio >= 0)
221 debug("Selecting environment with bad CRC\n");
222 else
223 best_prio = 0;
224 env_get_location(ENVOP_LOAD, best_prio);
225
226 return -ENODEV;
227 }
228
env_save(void)229 int env_save(void)
230 {
231 struct env_driver *drv;
232
233 drv = env_driver_lookup(ENVOP_SAVE, gd->env_load_prio);
234 if (drv) {
235 int ret;
236
237 if (!drv->save)
238 return -ENODEV;
239
240 if (!env_has_inited(drv->location))
241 return -ENODEV;
242
243 printf("Saving Environment to %s... ", drv->name);
244 ret = drv->save();
245 if (ret)
246 printf("Failed (%d)\n", ret);
247 else
248 printf("OK\n");
249
250 if (!ret)
251 return 0;
252 }
253
254 return -ENODEV;
255 }
256
env_init(void)257 int env_init(void)
258 {
259 struct env_driver *drv;
260 int ret = -ENOENT;
261 int prio;
262
263 for (prio = 0; (drv = env_driver_lookup(ENVOP_INIT, prio)); prio++) {
264 if (!drv->init || !(ret = drv->init()))
265 env_set_inited(drv->location);
266
267 debug("%s: Environment %s init done (ret=%d)\n", __func__,
268 drv->name, ret);
269 }
270
271 if (!prio)
272 return -ENODEV;
273
274 if (ret == -ENOENT) {
275 gd->env_addr = (ulong)&default_environment[0];
276 gd->env_valid = ENV_VALID;
277
278 return 0;
279 }
280
281 return ret;
282 }
283