1
2
3
4
5
6
7
8
9
10#include <common.h>
11#include <bootstage.h>
12#include <command.h>
13#include <env.h>
14#include <env_internal.h>
15#include <log.h>
16#include <sort.h>
17#include <asm/global_data.h>
18#include <linux/stddef.h>
19#include <search.h>
20#include <errno.h>
21#include <malloc.h>
22#include <u-boot/crc.h>
23#include <dm/ofnode.h>
24
25DECLARE_GLOBAL_DATA_PTR;
26
27
28
29
30#include <env_default.h>
31
32struct hsearch_data env_htab = {
33 .change_ok = env_flags_validate,
34};
35
36
37
38
39
40int env_get_yesno(const char *var)
41{
42 char *s = env_get(var);
43
44 if (s == NULL)
45 return -1;
46 return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
47 1 : 0;
48}
49
50
51
52
53char *env_get_default(const char *name)
54{
55 char *ret_val;
56 unsigned long really_valid = gd->env_valid;
57 unsigned long real_gd_flags = gd->flags;
58
59
60 gd->flags &= ~GD_FLG_ENV_READY;
61 gd->env_valid = ENV_INVALID;
62 ret_val = env_get(name);
63 gd->env_valid = really_valid;
64 gd->flags = real_gd_flags;
65 return ret_val;
66}
67
68void env_set_default(const char *s, int flags)
69{
70 if (sizeof(default_environment) > ENV_SIZE) {
71 puts("*** Error - default environment is too large\n\n");
72 return;
73 }
74
75 if (s) {
76 if ((flags & H_INTERACTIVE) == 0) {
77 printf("*** Warning - %s, "
78 "using default environment\n\n", s);
79 } else {
80 puts(s);
81 }
82 } else {
83 debug("Using default environment\n");
84 }
85
86 flags |= H_DEFAULT;
87 if (himport_r(&env_htab, (char *)default_environment,
88 sizeof(default_environment), '\0', flags, 0,
89 0, NULL) == 0)
90 pr_err("## Error: Environment import failed: errno = %d\n",
91 errno);
92
93 gd->flags |= GD_FLG_ENV_READY;
94 gd->flags |= GD_FLG_ENV_DEFAULT;
95}
96
97
98
99int env_set_default_vars(int nvars, char * const vars[], int flags)
100{
101
102
103
104
105 flags |= H_NOCLEAR | H_DEFAULT;
106 return himport_r(&env_htab, (const char *)default_environment,
107 sizeof(default_environment), '\0',
108 flags, 0, nvars, vars);
109}
110
111
112
113
114
115int env_import(const char *buf, int check, int flags)
116{
117 env_t *ep = (env_t *)buf;
118
119 if (check) {
120 uint32_t crc;
121
122 memcpy(&crc, &ep->crc, sizeof(crc));
123
124 if (crc32(0, ep->data, ENV_SIZE) != crc) {
125 env_set_default("bad CRC", 0);
126 return -ENOMSG;
127 }
128 }
129
130 if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
131 0, NULL)) {
132 gd->flags |= GD_FLG_ENV_READY;
133 return 0;
134 }
135
136 pr_err("Cannot import environment: errno = %d\n", errno);
137
138 env_set_default("import failed", 0);
139
140 return -EIO;
141}
142
143#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
144static unsigned char env_flags;
145
146int env_check_redund(const char *buf1, int buf1_read_fail,
147 const char *buf2, int buf2_read_fail)
148{
149 int crc1_ok = 0, crc2_ok = 0;
150 env_t *tmp_env1, *tmp_env2;
151
152 tmp_env1 = (env_t *)buf1;
153 tmp_env2 = (env_t *)buf2;
154
155 if (buf1_read_fail && buf2_read_fail) {
156 puts("*** Error - No Valid Environment Area found\n");
157 return -EIO;
158 } else if (buf1_read_fail || buf2_read_fail) {
159 puts("*** Warning - some problems detected ");
160 puts("reading environment; recovered successfully\n");
161 }
162
163 if (!buf1_read_fail)
164 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
165 tmp_env1->crc;
166 if (!buf2_read_fail)
167 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
168 tmp_env2->crc;
169
170 if (!crc1_ok && !crc2_ok) {
171 return -ENOMSG;
172 } else if (crc1_ok && !crc2_ok) {
173 gd->env_valid = ENV_VALID;
174 } else if (!crc1_ok && crc2_ok) {
175 gd->env_valid = ENV_REDUND;
176 } else {
177
178 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
179 gd->env_valid = ENV_REDUND;
180 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
181 gd->env_valid = ENV_VALID;
182 else if (tmp_env1->flags > tmp_env2->flags)
183 gd->env_valid = ENV_VALID;
184 else if (tmp_env2->flags > tmp_env1->flags)
185 gd->env_valid = ENV_REDUND;
186 else
187 gd->env_valid = ENV_VALID;
188 }
189
190 return 0;
191}
192
193int env_import_redund(const char *buf1, int buf1_read_fail,
194 const char *buf2, int buf2_read_fail,
195 int flags)
196{
197 env_t *ep;
198 int ret;
199
200 ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);
201
202 if (ret == -EIO) {
203 env_set_default("bad env area", 0);
204 return -EIO;
205 } else if (ret == -ENOMSG) {
206 env_set_default("bad CRC", 0);
207 return -ENOMSG;
208 }
209
210 if (gd->env_valid == ENV_VALID)
211 ep = (env_t *)buf1;
212 else
213 ep = (env_t *)buf2;
214
215 env_flags = ep->flags;
216
217 return env_import((char *)ep, 0, flags);
218}
219#endif
220
221
222int env_export(env_t *env_out)
223{
224 char *res;
225 ssize_t len;
226
227 res = (char *)env_out->data;
228 len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
229 if (len < 0) {
230 pr_err("Cannot export environment: errno = %d\n", errno);
231 return 1;
232 }
233
234 env_out->crc = crc32(0, env_out->data, ENV_SIZE);
235
236#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
237 env_out->flags = ++env_flags;
238#endif
239
240 return 0;
241}
242
243void env_relocate(void)
244{
245#if defined(CONFIG_NEEDS_MANUAL_RELOC)
246 env_reloc();
247 env_fix_drivers();
248 env_htab.change_ok += gd->reloc_off;
249#endif
250 if (gd->env_valid == ENV_INVALID) {
251#if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
252
253 env_set_default(NULL, 0);
254#else
255 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
256 env_set_default("bad CRC", 0);
257#endif
258 } else {
259 env_load();
260 }
261}
262
263#ifdef CONFIG_AUTO_COMPLETE
264int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf,
265 bool dollar_comp)
266{
267 struct env_entry *match;
268 int found, idx;
269
270 if (dollar_comp) {
271
272
273
274
275 if (var[0] != '$')
276 return 0;
277
278 var++;
279
280
281
282
283
284
285 if (var[0] == '{')
286 var++;
287 else if (var[0] != '\0')
288 return 0;
289 }
290
291 idx = 0;
292 found = 0;
293 cmdv[0] = NULL;
294
295
296 while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
297 int vallen = strlen(match->key) + 1;
298
299 if (found >= maxv - 2 ||
300 bufsz < vallen + (dollar_comp ? 3 : 0))
301 break;
302
303 cmdv[found++] = buf;
304
305
306 if (dollar_comp) {
307 strcpy(buf, "${");
308 buf += 2;
309 bufsz -= 3;
310 }
311
312 memcpy(buf, match->key, vallen);
313 buf += vallen;
314 bufsz -= vallen;
315
316 if (dollar_comp) {
317
318
319
320
321
322
323
324 strcpy(buf - 1, "}");
325 buf++;
326 }
327 }
328
329 qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
330
331 if (idx)
332 cmdv[found++] = dollar_comp ? "${...}" : "...";
333
334 cmdv[found] = NULL;
335 return found;
336}
337#endif
338
339#ifdef CONFIG_ENV_IMPORT_FDT
340void env_import_fdt(void)
341{
342 const char *path;
343 struct ofprop prop;
344 ofnode node;
345 int res;
346
347 path = env_get("env_fdt_path");
348 if (!path || !path[0])
349 return;
350
351 node = ofnode_path(path);
352 if (!ofnode_valid(node)) {
353 printf("Warning: device tree node '%s' not found\n", path);
354 return;
355 }
356
357 for (res = ofnode_get_first_property(node, &prop);
358 !res;
359 res = ofnode_get_next_property(&prop)) {
360 const char *name, *val;
361
362 val = ofnode_get_property_by_prop(&prop, &name, NULL);
363 env_set(name, val);
364 }
365}
366#endif
367