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#include <net.h>
25#include <watchdog.h>
26
27DECLARE_GLOBAL_DATA_PTR;
28
29
30
31
32#include <env_default.h>
33
34struct hsearch_data env_htab = {
35 .change_ok = env_flags_validate,
36};
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52int env_set_ulong(const char *varname, ulong value)
53{
54
55 char *str = simple_itoa(value);
56
57 return env_set(varname, str);
58}
59
60
61
62
63
64
65
66
67int env_set_hex(const char *varname, ulong value)
68{
69 char str[17];
70
71 sprintf(str, "%lx", value);
72 return env_set(varname, str);
73}
74
75ulong env_get_hex(const char *varname, ulong default_val)
76{
77 const char *s;
78 ulong value;
79 char *endp;
80
81 s = env_get(varname);
82 if (s)
83 value = hextoul(s, &endp);
84 if (!s || endp == s)
85 return default_val;
86
87 return value;
88}
89
90int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr)
91{
92 string_to_enetaddr(env_get(name), enetaddr);
93 return is_valid_ethaddr(enetaddr);
94}
95
96int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr)
97{
98 char buf[ARP_HLEN_ASCII + 1];
99
100 if (eth_env_get_enetaddr(name, (uint8_t *)buf))
101 return -EEXIST;
102
103 sprintf(buf, "%pM", enetaddr);
104
105 return env_set(name, buf);
106}
107
108
109
110
111
112
113char *env_get(const char *name)
114{
115 if (gd->flags & GD_FLG_ENV_READY) {
116 struct env_entry e, *ep;
117
118 WATCHDOG_RESET();
119
120 e.key = name;
121 e.data = NULL;
122 hsearch_r(e, ENV_FIND, &ep, &env_htab, 0);
123
124 return ep ? ep->data : NULL;
125 }
126
127
128 if (env_get_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) >= 0)
129 return (char *)(gd->env_buf);
130
131 return NULL;
132}
133
134
135
136
137
138
139char *from_env(const char *envvar)
140{
141 char *ret;
142
143 ret = env_get(envvar);
144
145 if (!ret)
146 printf("missing environment variable: %s\n", envvar);
147
148 return ret;
149}
150
151static int env_get_from_linear(const char *env, const char *name, char *buf,
152 unsigned len)
153{
154 const char *p, *end;
155 size_t name_len;
156
157 if (name == NULL || *name == '\0')
158 return -1;
159
160 name_len = strlen(name);
161
162 for (p = env; *p != '\0'; p = end + 1) {
163 const char *value;
164 unsigned res;
165
166 for (end = p; *end != '\0'; ++end)
167 if (end - env >= CONFIG_ENV_SIZE)
168 return -1;
169
170 if (strncmp(name, p, name_len) || p[name_len] != '=')
171 continue;
172 value = &p[name_len + 1];
173
174 res = end - value;
175 memcpy(buf, value, min(len, res + 1));
176
177 if (len <= res) {
178 buf[len - 1] = '\0';
179 printf("env_buf [%u bytes] too small for value of \"%s\"\n",
180 len, name);
181 }
182
183 return res;
184 }
185
186 return -1;
187}
188
189
190
191
192int env_get_f(const char *name, char *buf, unsigned len)
193{
194 const char *env;
195
196 if (gd->env_valid == ENV_INVALID)
197 env = default_environment;
198 else
199 env = (const char *)gd->env_addr;
200
201 return env_get_from_linear(env, name, buf, len);
202}
203
204
205
206
207
208
209
210
211
212
213ulong env_get_ulong(const char *name, int base, ulong default_val)
214{
215
216
217
218
219 const char *str = env_get(name);
220
221 return str ? simple_strtoul(str, NULL, base) : default_val;
222}
223
224
225
226
227
228int env_get_yesno(const char *var)
229{
230 char *s = env_get(var);
231
232 if (s == NULL)
233 return -1;
234 return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
235 1 : 0;
236}
237
238
239
240
241char *env_get_default(const char *name)
242{
243 if (env_get_from_linear(default_environment, name,
244 (char *)(gd->env_buf),
245 sizeof(gd->env_buf)) >= 0)
246 return (char *)(gd->env_buf);
247
248 return NULL;
249}
250
251void env_set_default(const char *s, int flags)
252{
253 if (s) {
254 if ((flags & H_INTERACTIVE) == 0) {
255 printf("*** Warning - %s, "
256 "using default environment\n\n", s);
257 } else {
258 puts(s);
259 }
260 } else {
261 debug("Using default environment\n");
262 }
263
264 flags |= H_DEFAULT;
265 if (himport_r(&env_htab, default_environment,
266 sizeof(default_environment), '\0', flags, 0,
267 0, NULL) == 0) {
268 pr_err("## Error: Environment import failed: errno = %d\n",
269 errno);
270 return;
271 }
272
273 gd->flags |= GD_FLG_ENV_READY;
274 gd->flags |= GD_FLG_ENV_DEFAULT;
275}
276
277
278
279int env_set_default_vars(int nvars, char * const vars[], int flags)
280{
281
282
283
284
285 flags |= H_NOCLEAR | H_DEFAULT;
286 return himport_r(&env_htab, default_environment,
287 sizeof(default_environment), '\0',
288 flags, 0, nvars, vars);
289}
290
291
292
293
294
295int env_import(const char *buf, int check, int flags)
296{
297 env_t *ep = (env_t *)buf;
298
299 if (check) {
300 uint32_t crc;
301
302 memcpy(&crc, &ep->crc, sizeof(crc));
303
304 if (crc32(0, ep->data, ENV_SIZE) != crc) {
305 env_set_default("bad CRC", 0);
306 return -ENOMSG;
307 }
308 }
309
310 if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
311 0, NULL)) {
312 gd->flags |= GD_FLG_ENV_READY;
313 return 0;
314 }
315
316 pr_err("Cannot import environment: errno = %d\n", errno);
317
318 env_set_default("import failed", 0);
319
320 return -EIO;
321}
322
323#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
324static unsigned char env_flags;
325
326int env_check_redund(const char *buf1, int buf1_read_fail,
327 const char *buf2, int buf2_read_fail)
328{
329 int crc1_ok = 0, crc2_ok = 0;
330 env_t *tmp_env1, *tmp_env2;
331
332 tmp_env1 = (env_t *)buf1;
333 tmp_env2 = (env_t *)buf2;
334
335 if (buf1_read_fail && buf2_read_fail) {
336 puts("*** Error - No Valid Environment Area found\n");
337 return -EIO;
338 } else if (buf1_read_fail || buf2_read_fail) {
339 puts("*** Warning - some problems detected ");
340 puts("reading environment; recovered successfully\n");
341 }
342
343 if (!buf1_read_fail)
344 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
345 tmp_env1->crc;
346 if (!buf2_read_fail)
347 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
348 tmp_env2->crc;
349
350 if (!crc1_ok && !crc2_ok) {
351 return -ENOMSG;
352 } else if (crc1_ok && !crc2_ok) {
353 gd->env_valid = ENV_VALID;
354 } else if (!crc1_ok && crc2_ok) {
355 gd->env_valid = ENV_REDUND;
356 } else {
357
358 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
359 gd->env_valid = ENV_REDUND;
360 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
361 gd->env_valid = ENV_VALID;
362 else if (tmp_env1->flags > tmp_env2->flags)
363 gd->env_valid = ENV_VALID;
364 else if (tmp_env2->flags > tmp_env1->flags)
365 gd->env_valid = ENV_REDUND;
366 else
367 gd->env_valid = ENV_VALID;
368 }
369
370 return 0;
371}
372
373int env_import_redund(const char *buf1, int buf1_read_fail,
374 const char *buf2, int buf2_read_fail,
375 int flags)
376{
377 env_t *ep;
378 int ret;
379
380 ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);
381
382 if (ret == -EIO) {
383 env_set_default("bad env area", 0);
384 return -EIO;
385 } else if (ret == -ENOMSG) {
386 env_set_default("bad CRC", 0);
387 return -ENOMSG;
388 }
389
390 if (gd->env_valid == ENV_VALID)
391 ep = (env_t *)buf1;
392 else
393 ep = (env_t *)buf2;
394
395 env_flags = ep->flags;
396
397 return env_import((char *)ep, 0, flags);
398}
399#endif
400
401
402int env_export(env_t *env_out)
403{
404 char *res;
405 ssize_t len;
406
407 res = (char *)env_out->data;
408 len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
409 if (len < 0) {
410 pr_err("Cannot export environment: errno = %d\n", errno);
411 return 1;
412 }
413
414 env_out->crc = crc32(0, env_out->data, ENV_SIZE);
415
416#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
417 env_out->flags = ++env_flags;
418#endif
419
420 return 0;
421}
422
423void env_relocate(void)
424{
425#if defined(CONFIG_NEEDS_MANUAL_RELOC)
426 env_reloc();
427 env_fix_drivers();
428 env_htab.change_ok += gd->reloc_off;
429#endif
430 if (gd->env_valid == ENV_INVALID) {
431#if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
432
433 env_set_default(NULL, 0);
434#else
435 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
436 env_set_default("bad CRC", 0);
437#endif
438 } else {
439 env_load();
440 }
441}
442
443#ifdef CONFIG_AUTO_COMPLETE
444int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf,
445 bool dollar_comp)
446{
447 struct env_entry *match;
448 int found, idx;
449
450 if (dollar_comp) {
451
452
453
454
455 if (var[0] != '$')
456 return 0;
457
458 var++;
459
460
461
462
463
464
465 if (var[0] == '{')
466 var++;
467 else if (var[0] != '\0')
468 return 0;
469 }
470
471 idx = 0;
472 found = 0;
473 cmdv[0] = NULL;
474
475
476 while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
477 int vallen = strlen(match->key) + 1;
478
479 if (found >= maxv - 2 ||
480 bufsz < vallen + (dollar_comp ? 3 : 0))
481 break;
482
483 cmdv[found++] = buf;
484
485
486 if (dollar_comp) {
487 strcpy(buf, "${");
488 buf += 2;
489 bufsz -= 3;
490 }
491
492 memcpy(buf, match->key, vallen);
493 buf += vallen;
494 bufsz -= vallen;
495
496 if (dollar_comp) {
497
498
499
500
501
502
503
504 strcpy(buf - 1, "}");
505 buf++;
506 }
507 }
508
509 qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
510
511 if (idx)
512 cmdv[found++] = dollar_comp ? "${...}" : "...";
513
514 cmdv[found] = NULL;
515 return found;
516}
517#endif
518
519#ifdef CONFIG_ENV_IMPORT_FDT
520void env_import_fdt(void)
521{
522 const char *path;
523 struct ofprop prop;
524 ofnode node;
525 int res;
526
527 path = env_get("env_fdt_path");
528 if (!path || !path[0])
529 return;
530
531 node = ofnode_path(path);
532 if (!ofnode_valid(node)) {
533 printf("Warning: device tree node '%s' not found\n", path);
534 return;
535 }
536
537 for (res = ofnode_get_first_property(node, &prop);
538 !res;
539 res = ofnode_get_next_property(&prop)) {
540 const char *name, *val;
541
542 val = ofnode_get_property_by_prop(&prop, &name, NULL);
543 env_set(name, val);
544 }
545}
546#endif
547