xref: /openbmc/u-boot/env/env.c (revision 14453fbf)
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)
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 
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 
88 static bool env_has_inited(enum env_location location)
89 {
90 	return gd->env_has_init & BIT(location);
91 }
92 
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  */
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  */
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 
164 __weak int env_get_char_spec(int index)
165 {
166 	return *(uchar *)(gd->env_addr + index);
167 }
168 
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 
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 
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 
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