]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
c9d728dd SG |
2 | /* |
3 | * Copyright (C) 2017 Google, Inc | |
4 | * Written by Simon Glass <sjg@chromium.org> | |
c9d728dd SG |
5 | */ |
6 | ||
7 | #include <common.h> | |
8 | #include <environment.h> | |
9 | ||
10 | DECLARE_GLOBAL_DATA_PTR; | |
11 | ||
7bcdf195 SDPP |
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 | ||
52746c43 | 33 | static struct env_driver *_env_driver_lookup(enum env_location loc) |
c9d728dd SG |
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 | ||
7d714a24 MR |
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_SPI_FLASH | |
75 | ENVL_SPI_FLASH, | |
76 | #endif | |
77 | #ifdef CONFIG_ENV_IS_IN_UBI | |
78 | ENVL_UBI, | |
79 | #endif | |
80 | #ifdef CONFIG_ENV_IS_NOWHERE | |
81 | ENVL_NOWHERE, | |
82 | #endif | |
83 | }; | |
84 | ||
1d446087 MR |
85 | static bool env_has_inited(enum env_location location) |
86 | { | |
87 | return gd->env_has_init & BIT(location); | |
88 | } | |
89 | ||
90 | static void env_set_inited(enum env_location location) | |
91 | { | |
92 | /* | |
93 | * We're using a 32-bits bitmask stored in gd (env_has_init) | |
94 | * using the above enum value as the bit index. We need to | |
95 | * make sure that we're not overflowing it. | |
96 | */ | |
97 | BUILD_BUG_ON(ARRAY_SIZE(env_locations) > BITS_PER_LONG); | |
98 | ||
99 | gd->env_has_init |= BIT(location); | |
100 | } | |
101 | ||
8a3a7e22 MR |
102 | /** |
103 | * env_get_location() - Returns the best env location for a board | |
104 | * @op: operations performed on the environment | |
105 | * @prio: priority between the multiple environments, 0 being the | |
106 | * highest priority | |
107 | * | |
108 | * This will return the preferred environment for the given priority. | |
40c08a68 | 109 | * This is overridable by boards if they need to. |
8a3a7e22 MR |
110 | * |
111 | * All implementations are free to use the operation, the priority and | |
112 | * any other data relevant to their choice, but must take into account | |
113 | * the fact that the lowest prority (0) is the most important location | |
114 | * in the system. The following locations should be returned by order | |
115 | * of descending priorities, from the highest to the lowest priority. | |
116 | * | |
117 | * Returns: | |
118 | * an enum env_location value on success, a negative error code otherwise | |
119 | */ | |
40c08a68 | 120 | __weak enum env_location env_get_location(enum env_operation op, int prio) |
c9d728dd | 121 | { |
7d714a24 MR |
122 | switch (op) { |
123 | case ENVOP_GET_CHAR: | |
124 | case ENVOP_INIT: | |
125 | case ENVOP_LOAD: | |
126 | if (prio >= ARRAY_SIZE(env_locations)) | |
127 | return ENVL_UNKNOWN; | |
128 | ||
e1caa584 YS |
129 | gd->env_load_location = env_locations[prio]; |
130 | return gd->env_load_location; | |
7d714a24 MR |
131 | |
132 | case ENVOP_SAVE: | |
e1caa584 | 133 | return gd->env_load_location; |
7d714a24 | 134 | } |
8a3a7e22 | 135 | |
7d714a24 | 136 | return ENVL_UNKNOWN; |
c9d728dd SG |
137 | } |
138 | ||
8a3a7e22 MR |
139 | |
140 | /** | |
141 | * env_driver_lookup() - Finds the most suited environment location | |
142 | * @op: operations performed on the environment | |
143 | * @prio: priority between the multiple environments, 0 being the | |
144 | * highest priority | |
145 | * | |
146 | * This will try to find the available environment with the highest | |
147 | * priority in the system. | |
148 | * | |
149 | * Returns: | |
150 | * NULL on error, a pointer to a struct env_driver otherwise | |
151 | */ | |
152 | static struct env_driver *env_driver_lookup(enum env_operation op, int prio) | |
c9d728dd | 153 | { |
8a3a7e22 | 154 | enum env_location loc = env_get_location(op, prio); |
c9d728dd SG |
155 | struct env_driver *drv; |
156 | ||
8a3a7e22 MR |
157 | if (loc == ENVL_UNKNOWN) |
158 | return NULL; | |
159 | ||
52746c43 | 160 | drv = _env_driver_lookup(loc); |
c9d728dd SG |
161 | if (!drv) { |
162 | debug("%s: No environment driver for location %d\n", __func__, | |
163 | loc); | |
164 | return NULL; | |
165 | } | |
166 | ||
167 | return drv; | |
168 | } | |
169 | ||
b2cdef48 | 170 | __weak int env_get_char_spec(int index) |
c9d728dd | 171 | { |
b2cdef48 GS |
172 | return *(uchar *)(gd->env_addr + index); |
173 | } | |
c9d728dd | 174 | |
b2cdef48 GS |
175 | int env_get_char(int index) |
176 | { | |
2d7cb5b4 | 177 | if (gd->env_valid == ENV_INVALID) |
a69d0f60 | 178 | return default_environment[index]; |
b2cdef48 GS |
179 | else |
180 | return env_get_char_spec(index); | |
c9d728dd SG |
181 | } |
182 | ||
183 | int env_load(void) | |
184 | { | |
8a3a7e22 MR |
185 | struct env_driver *drv; |
186 | int prio; | |
c9d728dd | 187 | |
8a3a7e22 MR |
188 | for (prio = 0; (drv = env_driver_lookup(ENVOP_LOAD, prio)); prio++) { |
189 | int ret; | |
190 | ||
191 | if (!drv->load) | |
192 | continue; | |
193 | ||
1d446087 MR |
194 | if (!env_has_inited(drv->location)) |
195 | continue; | |
196 | ||
3574ba01 | 197 | printf("Loading Environment from %s... ", drv->name); |
8a3a7e22 | 198 | ret = drv->load(); |
3574ba01 MR |
199 | if (ret) |
200 | printf("Failed (%d)\n", ret); | |
201 | else | |
202 | printf("OK\n"); | |
203 | ||
8a3a7e22 MR |
204 | if (!ret) |
205 | return 0; | |
c9d728dd SG |
206 | } |
207 | ||
8a3a7e22 | 208 | return -ENODEV; |
c9d728dd SG |
209 | } |
210 | ||
211 | int env_save(void) | |
212 | { | |
8a3a7e22 MR |
213 | struct env_driver *drv; |
214 | int prio; | |
c9d728dd | 215 | |
8a3a7e22 MR |
216 | for (prio = 0; (drv = env_driver_lookup(ENVOP_SAVE, prio)); prio++) { |
217 | int ret; | |
218 | ||
219 | if (!drv->save) | |
220 | continue; | |
221 | ||
1d446087 MR |
222 | if (!env_has_inited(drv->location)) |
223 | continue; | |
224 | ||
9efac3c8 | 225 | printf("Saving Environment to %s... ", drv->name); |
8a3a7e22 | 226 | ret = drv->save(); |
3574ba01 MR |
227 | if (ret) |
228 | printf("Failed (%d)\n", ret); | |
229 | else | |
230 | printf("OK\n"); | |
231 | ||
8a3a7e22 MR |
232 | if (!ret) |
233 | return 0; | |
c9d728dd SG |
234 | } |
235 | ||
8a3a7e22 | 236 | return -ENODEV; |
c9d728dd SG |
237 | } |
238 | ||
6eeae424 | 239 | int env_init(void) |
c9d728dd | 240 | { |
8a3a7e22 | 241 | struct env_driver *drv; |
7938822a | 242 | int ret = -ENOENT; |
8a3a7e22 MR |
243 | int prio; |
244 | ||
245 | for (prio = 0; (drv = env_driver_lookup(ENVOP_INIT, prio)); prio++) { | |
1d446087 MR |
246 | if (!drv->init || !(ret = drv->init())) |
247 | env_set_inited(drv->location); | |
8a3a7e22 | 248 | |
1d446087 | 249 | debug("%s: Environment %s init done (ret=%d)\n", __func__, |
8a3a7e22 MR |
250 | drv->name, ret); |
251 | } | |
252 | ||
253 | if (!prio) | |
254 | return -ENODEV; | |
255 | ||
7938822a SG |
256 | if (ret == -ENOENT) { |
257 | gd->env_addr = (ulong)&default_environment[0]; | |
eeba55cb | 258 | gd->env_valid = ENV_VALID; |
7938822a SG |
259 | |
260 | return 0; | |
c9d728dd SG |
261 | } |
262 | ||
8a3a7e22 | 263 | return ret; |
c9d728dd | 264 | } |