blob: 0a438a3be427116432bbe88720d3ce7495b12113 [file] [log] [blame]
wdenk6aff3112002-12-17 01:51:00 +00001/*
Detlev Zundel0aef7bc2010-07-30 11:22:15 +02002 * (C) Copyright 2000-2010
wdenk6aff3112002-12-17 01:51:00 +00003 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02005 * (C) Copyright 2008
6 * Guennadi Liakhovetski, DENX Software Engineering, lg@denx.de.
7 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02008 * SPDX-License-Identifier: GPL-2.0+
wdenk6aff3112002-12-17 01:51:00 +00009 */
10
Jörg Krause26e355d2015-04-22 21:36:22 +020011#define _GNU_SOURCE
12
Peter Robinson69bf2d22015-12-09 07:15:33 +000013#include <compiler.h>
wdenk6aff3112002-12-17 01:51:00 +000014#include <errno.h>
Joe Hershberger30fd4fad2012-12-11 22:16:32 -060015#include <env_flags.h>
wdenk6aff3112002-12-17 01:51:00 +000016#include <fcntl.h>
Joe Hershberger06134212012-10-12 10:23:37 +000017#include <linux/stringify.h>
Andreas Fenkart10667e12016-03-11 09:39:35 +010018#include <ctype.h>
wdenk6aff3112002-12-17 01:51:00 +000019#include <stdio.h>
20#include <stdlib.h>
21#include <stddef.h>
22#include <string.h>
23#include <sys/types.h>
24#include <sys/ioctl.h>
25#include <sys/stat.h>
26#include <unistd.h>
wdenk6aff3112002-12-17 01:51:00 +000027
Markus Klotzbücher6de66b32007-11-27 10:23:20 +010028#ifdef MTD_OLD
Wolfgang Denk1711f3b2008-09-02 21:17:36 +020029# include <stdint.h>
Markus Klotzbücher6de66b32007-11-27 10:23:20 +010030# include <linux/mtd/mtd.h>
31#else
Wolfgang Denkc83d7ca2008-01-08 22:58:27 +010032# define __user /* nothing */
Markus Klotzbücher6de66b32007-11-27 10:23:20 +010033# include <mtd/mtd-user.h>
34#endif
35
36#include "fw_env.h"
wdenk6aff3112002-12-17 01:51:00 +000037
Marek Vasuta8a752c2014-03-05 19:59:52 +010038#define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
39
Guennadi Liakhovetski56086922008-09-04 13:01:49 +020040#define min(x, y) ({ \
41 typeof(x) _min1 = (x); \
42 typeof(y) _min2 = (y); \
43 (void) (&_min1 == &_min2); \
44 _min1 < _min2 ? _min1 : _min2; })
45
46struct envdev_s {
Tom Rini229695f2014-03-28 12:03:33 -040047 const char *devname; /* Device name */
wdenk4a6fd342003-04-12 23:38:12 +000048 ulong devoff; /* Device offset */
49 ulong env_size; /* environment size */
50 ulong erase_size; /* device erase size */
Guennadi Liakhovetski56086922008-09-04 13:01:49 +020051 ulong env_sectors; /* number of environment sectors */
52 uint8_t mtd_type; /* type of the MTD device */
53};
wdenk6aff3112002-12-17 01:51:00 +000054
Guennadi Liakhovetski56086922008-09-04 13:01:49 +020055static struct envdev_s envdevices[2] =
56{
57 {
58 .mtd_type = MTD_ABSENT,
59 }, {
60 .mtd_type = MTD_ABSENT,
61 },
62};
63static int dev_current;
wdenk6aff3112002-12-17 01:51:00 +000064
65#define DEVNAME(i) envdevices[(i)].devname
wdenkd0fb80c2003-01-11 09:48:40 +000066#define DEVOFFSET(i) envdevices[(i)].devoff
wdenk6aff3112002-12-17 01:51:00 +000067#define ENVSIZE(i) envdevices[(i)].env_size
68#define DEVESIZE(i) envdevices[(i)].erase_size
Guennadi Liakhovetski56086922008-09-04 13:01:49 +020069#define ENVSECTORS(i) envdevices[(i)].env_sectors
70#define DEVTYPE(i) envdevices[(i)].mtd_type
wdenk6aff3112002-12-17 01:51:00 +000071
Joe Hershberger497f2052012-10-03 09:38:46 +000072#define CUR_ENVSIZE ENVSIZE(dev_current)
wdenk6aff3112002-12-17 01:51:00 +000073
wdenkd0fb80c2003-01-11 09:48:40 +000074#define ENV_SIZE getenvsize()
wdenk6aff3112002-12-17 01:51:00 +000075
Guennadi Liakhovetski56086922008-09-04 13:01:49 +020076struct env_image_single {
77 uint32_t crc; /* CRC32 over data bytes */
78 char data[];
79};
wdenk6aff3112002-12-17 01:51:00 +000080
Guennadi Liakhovetski56086922008-09-04 13:01:49 +020081struct env_image_redundant {
82 uint32_t crc; /* CRC32 over data bytes */
83 unsigned char flags; /* active or obsolete */
84 char data[];
85};
86
87enum flag_scheme {
88 FLAG_NONE,
89 FLAG_BOOLEAN,
90 FLAG_INCREMENTAL,
91};
92
93struct environment {
94 void *image;
95 uint32_t *crc;
96 unsigned char *flags;
97 char *data;
98 enum flag_scheme flag_scheme;
99};
100
101static struct environment environment = {
102 .flag_scheme = FLAG_NONE,
103};
wdenk6aff3112002-12-17 01:51:00 +0000104
Marek Vasuta8a752c2014-03-05 19:59:52 +0100105static int env_aes_cbc_crypt(char *data, const int enc);
106
wdenkd0fb80c2003-01-11 09:48:40 +0000107static int HaveRedundEnv = 0;
108
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100109static unsigned char active_flag = 1;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200110/* obsolete_flag must be 0 to efficiently set it on NOR flash without erasing */
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100111static unsigned char obsolete_flag = 0;
wdenkd0fb80c2003-01-11 09:48:40 +0000112
Joe Hershbergerddd84182012-10-12 08:48:51 +0000113#define DEFAULT_ENV_INSTANCE_STATIC
114#include <env_default.h>
wdenk6aff3112002-12-17 01:51:00 +0000115
wdenk4a6fd342003-04-12 23:38:12 +0000116static int flash_io (int mode);
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100117static char *envmatch (char * s1, char * s2);
wdenk4a6fd342003-04-12 23:38:12 +0000118static int parse_config (void);
119
wdenkd0fb80c2003-01-11 09:48:40 +0000120#if defined(CONFIG_FILE)
wdenk4a6fd342003-04-12 23:38:12 +0000121static int get_config (char *);
wdenkd0fb80c2003-01-11 09:48:40 +0000122#endif
wdenk4a6fd342003-04-12 23:38:12 +0000123static inline ulong getenvsize (void)
wdenkd0fb80c2003-01-11 09:48:40 +0000124{
Dominic Sacréea195272014-11-05 00:30:18 +0100125 ulong rc = CUR_ENVSIZE - sizeof(uint32_t);
wdenk4a6fd342003-04-12 23:38:12 +0000126
wdenkd0fb80c2003-01-11 09:48:40 +0000127 if (HaveRedundEnv)
wdenk4a6fd342003-04-12 23:38:12 +0000128 rc -= sizeof (char);
Marek Vasuta8a752c2014-03-05 19:59:52 +0100129
Andreas Fenkart371ee132015-12-09 13:13:24 +0100130 if (common_args.aes_flag)
Marek Vasuta8a752c2014-03-05 19:59:52 +0100131 rc &= ~(AES_KEY_LENGTH - 1);
132
wdenkd0fb80c2003-01-11 09:48:40 +0000133 return rc;
134}
wdenk6aff3112002-12-17 01:51:00 +0000135
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200136static char *fw_string_blank(char *s, int noblank)
137{
138 int i;
139 int len = strlen(s);
140
141 for (i = 0; i < len; i++, s++) {
Andreas Fenkart10667e12016-03-11 09:39:35 +0100142 if ((noblank && !isblank(*s)) ||
143 (!noblank && isblank(*s)))
Andreas Fenkart9583efc2016-03-11 09:39:36 +0100144 return s;
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200145 }
Andreas Fenkart9583efc2016-03-11 09:39:36 +0100146 return NULL;
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200147}
148
wdenk6aff3112002-12-17 01:51:00 +0000149/*
150 * Search the environment for a variable.
151 * Return the value, if found, or NULL, if not found.
152 */
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100153char *fw_getenv (char *name)
wdenk6aff3112002-12-17 01:51:00 +0000154{
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100155 char *env, *nxt;
wdenk6aff3112002-12-17 01:51:00 +0000156
wdenk4a6fd342003-04-12 23:38:12 +0000157 for (env = environment.data; *env; env = nxt + 1) {
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100158 char *val;
wdenk6aff3112002-12-17 01:51:00 +0000159
wdenk4a6fd342003-04-12 23:38:12 +0000160 for (nxt = env; *nxt; ++nxt) {
wdenk6aff3112002-12-17 01:51:00 +0000161 if (nxt >= &environment.data[ENV_SIZE]) {
162 fprintf (stderr, "## Error: "
163 "environment not terminated\n");
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200164 return NULL;
wdenk6aff3112002-12-17 01:51:00 +0000165 }
166 }
wdenk4a6fd342003-04-12 23:38:12 +0000167 val = envmatch (name, env);
wdenk6aff3112002-12-17 01:51:00 +0000168 if (!val)
169 continue;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200170 return val;
wdenk6aff3112002-12-17 01:51:00 +0000171 }
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200172 return NULL;
wdenk6aff3112002-12-17 01:51:00 +0000173}
174
175/*
Joe Hershberger267541f2012-12-11 22:16:34 -0600176 * Search the default environment for a variable.
177 * Return the value, if found, or NULL, if not found.
178 */
179char *fw_getdefenv(char *name)
180{
181 char *env, *nxt;
182
183 for (env = default_environment; *env; env = nxt + 1) {
184 char *val;
185
186 for (nxt = env; *nxt; ++nxt) {
187 if (nxt >= &default_environment[ENV_SIZE]) {
188 fprintf(stderr, "## Error: "
189 "default environment not terminated\n");
190 return NULL;
191 }
192 }
193 val = envmatch(name, env);
194 if (!val)
195 continue;
196 return val;
197 }
198 return NULL;
199}
200
Andreas Fenkart371ee132015-12-09 13:13:24 +0100201int parse_aes_key(char *key, uint8_t *bin_key)
Marek Vasuta8a752c2014-03-05 19:59:52 +0100202{
203 char tmp[5] = { '0', 'x', 0, 0, 0 };
204 unsigned long ul;
205 int i;
206
207 if (strnlen(key, 64) != 32) {
208 fprintf(stderr,
209 "## Error: '-a' option requires 16-byte AES key\n");
210 return -1;
211 }
212
213 for (i = 0; i < 16; i++) {
214 tmp[2] = key[0];
215 tmp[3] = key[1];
216 errno = 0;
217 ul = strtoul(tmp, NULL, 16);
218 if (errno) {
219 fprintf(stderr,
220 "## Error: '-a' option requires valid AES key\n");
221 return -1;
222 }
Andreas Fenkart8b27abd2015-12-09 13:13:22 +0100223 bin_key[i] = ul & 0xff;
Marek Vasuta8a752c2014-03-05 19:59:52 +0100224 key += 2;
225 }
Marek Vasuta8a752c2014-03-05 19:59:52 +0100226 return 0;
227}
228
Joe Hershberger267541f2012-12-11 22:16:34 -0600229/*
wdenk6aff3112002-12-17 01:51:00 +0000230 * Print the current definition of one, or more, or all
231 * environment variables
232 */
Grant Ericksonbc117562008-05-06 20:16:15 -0700233int fw_printenv (int argc, char *argv[])
wdenk6aff3112002-12-17 01:51:00 +0000234{
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100235 char *env, *nxt;
Andreas Fenkart371ee132015-12-09 13:13:24 +0100236 int i, rc = 0;
wdenk6aff3112002-12-17 01:51:00 +0000237
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200238 if (fw_env_open())
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200239 return -1;
wdenk6aff3112002-12-17 01:51:00 +0000240
Andreas Fenkart1ce68692015-12-09 13:13:25 +0100241 if (argc == 0) { /* Print all env variables */
wdenk4a6fd342003-04-12 23:38:12 +0000242 for (env = environment.data; *env; env = nxt + 1) {
243 for (nxt = env; *nxt; ++nxt) {
wdenk6aff3112002-12-17 01:51:00 +0000244 if (nxt >= &environment.data[ENV_SIZE]) {
245 fprintf (stderr, "## Error: "
246 "environment not terminated\n");
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200247 return -1;
wdenk6aff3112002-12-17 01:51:00 +0000248 }
249 }
250
wdenk4a6fd342003-04-12 23:38:12 +0000251 printf ("%s\n", env);
wdenk6aff3112002-12-17 01:51:00 +0000252 }
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200253 return 0;
wdenk6aff3112002-12-17 01:51:00 +0000254 }
255
Andreas Fenkart1ce68692015-12-09 13:13:25 +0100256 if (printenv_args.name_suppress && argc != 1) {
257 fprintf(stderr,
258 "## Error: `-n' option requires exactly one argument\n");
259 return -1;
wdenk6aff3112002-12-17 01:51:00 +0000260 }
261
Andreas Fenkart1ce68692015-12-09 13:13:25 +0100262 for (i = 0; i < argc; ++i) { /* print single env variables */
Markus Klotzbücher6de66b32007-11-27 10:23:20 +0100263 char *name = argv[i];
264 char *val = NULL;
wdenk6aff3112002-12-17 01:51:00 +0000265
wdenk4a6fd342003-04-12 23:38:12 +0000266 for (env = environment.data; *env; env = nxt + 1) {
wdenk6aff3112002-12-17 01:51:00 +0000267
wdenk4a6fd342003-04-12 23:38:12 +0000268 for (nxt = env; *nxt; ++nxt) {
wdenk6aff3112002-12-17 01:51:00 +0000269 if (nxt >= &environment.data[ENV_SIZE]) {
270 fprintf (stderr, "## Error: "
271 "environment not terminated\n");
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200272 return -1;
wdenk6aff3112002-12-17 01:51:00 +0000273 }
274 }
wdenk4a6fd342003-04-12 23:38:12 +0000275 val = envmatch (name, env);
wdenk6aff3112002-12-17 01:51:00 +0000276 if (val) {
Andreas Fenkart371ee132015-12-09 13:13:24 +0100277 if (!printenv_args.name_suppress) {
wdenk6aff3112002-12-17 01:51:00 +0000278 fputs (name, stdout);
wdenk4a6fd342003-04-12 23:38:12 +0000279 putc ('=', stdout);
wdenk6aff3112002-12-17 01:51:00 +0000280 }
wdenk4a6fd342003-04-12 23:38:12 +0000281 puts (val);
wdenk6aff3112002-12-17 01:51:00 +0000282 break;
283 }
284 }
Grant Ericksonbc117562008-05-06 20:16:15 -0700285 if (!val) {
wdenk4a6fd342003-04-12 23:38:12 +0000286 fprintf (stderr, "## Error: \"%s\" not defined\n", name);
Grant Ericksonbc117562008-05-06 20:16:15 -0700287 rc = -1;
288 }
wdenk6aff3112002-12-17 01:51:00 +0000289 }
Grant Ericksonbc117562008-05-06 20:16:15 -0700290
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200291 return rc;
wdenk6aff3112002-12-17 01:51:00 +0000292}
293
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200294int fw_env_close(void)
wdenk6aff3112002-12-17 01:51:00 +0000295{
Marek Vasuta8a752c2014-03-05 19:59:52 +0100296 int ret;
Andreas Fenkart371ee132015-12-09 13:13:24 +0100297 if (common_args.aes_flag) {
Marek Vasuta8a752c2014-03-05 19:59:52 +0100298 ret = env_aes_cbc_crypt(environment.data, 1);
299 if (ret) {
300 fprintf(stderr,
301 "Error: can't encrypt env for flash\n");
302 return ret;
303 }
304 }
305
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200306 /*
307 * Update CRC
308 */
309 *environment.crc = crc32(0, (uint8_t *) environment.data, ENV_SIZE);
wdenk6aff3112002-12-17 01:51:00 +0000310
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200311 /* write environment back to flash */
312 if (flash_io(O_RDWR)) {
313 fprintf(stderr,
314 "Error: can't write fw_env to flash\n");
315 return -1;
wdenk6aff3112002-12-17 01:51:00 +0000316 }
317
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200318 return 0;
319}
wdenk6aff3112002-12-17 01:51:00 +0000320
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200321
322/*
323 * Set/Clear a single variable in the environment.
324 * This is called in sequence to update the environment
325 * in RAM without updating the copy in flash after each set
326 */
327int fw_env_write(char *name, char *value)
328{
329 int len;
330 char *env, *nxt;
331 char *oldval = NULL;
Joe Hershberger267541f2012-12-11 22:16:34 -0600332 int deleting, creating, overwriting;
wdenk6aff3112002-12-17 01:51:00 +0000333
334 /*
335 * search if variable with this name already exists
336 */
wdenk4a6fd342003-04-12 23:38:12 +0000337 for (nxt = env = environment.data; *env; env = nxt + 1) {
338 for (nxt = env; *nxt; ++nxt) {
wdenk6aff3112002-12-17 01:51:00 +0000339 if (nxt >= &environment.data[ENV_SIZE]) {
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200340 fprintf(stderr, "## Error: "
wdenk6aff3112002-12-17 01:51:00 +0000341 "environment not terminated\n");
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200342 errno = EINVAL;
343 return -1;
wdenk6aff3112002-12-17 01:51:00 +0000344 }
345 }
wdenk4a6fd342003-04-12 23:38:12 +0000346 if ((oldval = envmatch (name, env)) != NULL)
wdenk6aff3112002-12-17 01:51:00 +0000347 break;
348 }
349
Joe Hershberger267541f2012-12-11 22:16:34 -0600350 deleting = (oldval && !(value && strlen(value)));
351 creating = (!oldval && (value && strlen(value)));
352 overwriting = (oldval && (value && strlen(value)));
353
354 /* check for permission */
355 if (deleting) {
356 if (env_flags_validate_varaccess(name,
357 ENV_FLAGS_VARACCESS_PREVENT_DELETE)) {
358 printf("Can't delete \"%s\"\n", name);
359 errno = EROFS;
360 return -1;
361 }
362 } else if (overwriting) {
363 if (env_flags_validate_varaccess(name,
364 ENV_FLAGS_VARACCESS_PREVENT_OVERWR)) {
365 printf("Can't overwrite \"%s\"\n", name);
366 errno = EROFS;
367 return -1;
368 } else if (env_flags_validate_varaccess(name,
369 ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR)) {
370 const char *defval = fw_getdefenv(name);
371
372 if (defval == NULL)
373 defval = "";
374 if (strcmp(oldval, defval)
375 != 0) {
376 printf("Can't overwrite \"%s\"\n", name);
377 errno = EROFS;
378 return -1;
379 }
380 }
381 } else if (creating) {
382 if (env_flags_validate_varaccess(name,
383 ENV_FLAGS_VARACCESS_PREVENT_CREATE)) {
384 printf("Can't create \"%s\"\n", name);
385 errno = EROFS;
386 return -1;
387 }
388 } else
389 /* Nothing to do */
390 return 0;
391
392 if (deleting || overwriting) {
wdenk6aff3112002-12-17 01:51:00 +0000393 if (*++nxt == '\0') {
394 *env = '\0';
395 } else {
396 for (;;) {
397 *env = *nxt++;
398 if ((*env == '\0') && (*nxt == '\0'))
399 break;
400 ++env;
401 }
402 }
403 *++env = '\0';
404 }
405
406 /* Delete only ? */
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200407 if (!value || !strlen(value))
408 return 0;
wdenk6aff3112002-12-17 01:51:00 +0000409
410 /*
411 * Append new definition at the end
412 */
wdenk4a6fd342003-04-12 23:38:12 +0000413 for (env = environment.data; *env || *(env + 1); ++env);
wdenk6aff3112002-12-17 01:51:00 +0000414 if (env > environment.data)
415 ++env;
416 /*
417 * Overflow when:
Joe Hershberger497f2052012-10-03 09:38:46 +0000418 * "name" + "=" + "val" +"\0\0" > CUR_ENVSIZE - (env-environment)
wdenk6aff3112002-12-17 01:51:00 +0000419 */
wdenk4a6fd342003-04-12 23:38:12 +0000420 len = strlen (name) + 2;
wdenk6aff3112002-12-17 01:51:00 +0000421 /* add '=' for first arg, ' ' for all others */
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200422 len += strlen(value) + 1;
423
wdenk4a6fd342003-04-12 23:38:12 +0000424 if (len > (&environment.data[ENV_SIZE] - env)) {
wdenk6aff3112002-12-17 01:51:00 +0000425 fprintf (stderr,
426 "Error: environment overflow, \"%s\" deleted\n",
427 name);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200428 return -1;
wdenk6aff3112002-12-17 01:51:00 +0000429 }
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200430
wdenk6aff3112002-12-17 01:51:00 +0000431 while ((*env = *name++) != '\0')
432 env++;
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200433 *env = '=';
434 while ((*++env = *value++) != '\0')
435 ;
wdenk6aff3112002-12-17 01:51:00 +0000436
437 /* end is marked with double '\0' */
438 *++env = '\0';
439
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200440 return 0;
441}
wdenk6aff3112002-12-17 01:51:00 +0000442
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200443/*
444 * Deletes or sets environment variables. Returns -1 and sets errno error codes:
445 * 0 - OK
446 * EINVAL - need at least 1 argument
447 * EROFS - certain variables ("ethaddr", "serial#") cannot be
448 * modified or deleted
449 *
450 */
451int fw_setenv(int argc, char *argv[])
452{
Andreas Fenkart371ee132015-12-09 13:13:24 +0100453 int i;
Mike Frysinger3779c8e2012-11-10 19:47:45 +0000454 size_t len;
Andreas Fenkart167f5252015-12-09 13:13:21 +0100455 char *name, **valv;
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200456 char *value = NULL;
Andreas Fenkart167f5252015-12-09 13:13:21 +0100457 int valc;
wdenk6aff3112002-12-17 01:51:00 +0000458
Andreas Fenkart1ce68692015-12-09 13:13:25 +0100459 if (argc < 1) {
460 fprintf(stderr, "## Error: variable name missing\n");
Marek Vasuta8a752c2014-03-05 19:59:52 +0100461 errno = EINVAL;
462 return -1;
463 }
464
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200465 if (fw_env_open()) {
466 fprintf(stderr, "Error: environment not initialized\n");
467 return -1;
468 }
469
Andreas Fenkart1ce68692015-12-09 13:13:25 +0100470 name = argv[0];
471 valv = argv + 1;
472 valc = argc - 1;
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200473
Andreas Fenkart167f5252015-12-09 13:13:21 +0100474 if (env_flags_validate_env_set_params(name, valv, valc) < 0)
Joe Hershberger30fd4fad2012-12-11 22:16:32 -0600475 return 1;
476
Joe Hershberger62a34a02012-10-03 09:38:47 +0000477 len = 0;
Andreas Fenkart167f5252015-12-09 13:13:21 +0100478 for (i = 0; i < valc; ++i) {
479 char *val = valv[i];
Joe Hershberger62a34a02012-10-03 09:38:47 +0000480 size_t val_len = strlen(val);
481
Joe Hershbergerce2f5802012-10-15 15:29:24 +0000482 if (value)
483 value[len - 1] = ' ';
Joe Hershberger62a34a02012-10-03 09:38:47 +0000484 value = realloc(value, len + val_len + 1);
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200485 if (!value) {
Joe Hershberger62a34a02012-10-03 09:38:47 +0000486 fprintf(stderr,
Luka Perkov8603b692011-09-05 23:40:13 +0200487 "Cannot malloc %zu bytes: %s\n",
Joe Hershberger62a34a02012-10-03 09:38:47 +0000488 len, strerror(errno));
489 return -1;
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200490 }
Joe Hershberger62a34a02012-10-03 09:38:47 +0000491
492 memcpy(value + len, val, val_len);
493 len += val_len;
Joe Hershbergerce2f5802012-10-15 15:29:24 +0000494 value[len++] = '\0';
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200495 }
496
497 fw_env_write(name, value);
498
Joe Hershberger62a34a02012-10-03 09:38:47 +0000499 free(value);
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200500
501 return fw_env_close();
502}
503
504/*
505 * Parse a file and configure the u-boot variables.
506 * The script file has a very simple format, as follows:
507 *
508 * Each line has a couple with name, value:
509 * <white spaces>variable_name<white spaces>variable_value
510 *
511 * Both variable_name and variable_value are interpreted as strings.
512 * Any character after <white spaces> and before ending \r\n is interpreted
513 * as variable's value (no comment allowed on these lines !)
514 *
515 * Comments are allowed if the first character in the line is #
516 *
517 * Returns -1 and sets errno error codes:
518 * 0 - OK
519 * -1 - Error
520 */
521int fw_parse_script(char *fname)
522{
523 FILE *fp;
524 char dump[1024]; /* Maximum line length in the file */
525 char *name;
526 char *val;
527 int lineno = 0;
528 int len;
529 int ret = 0;
530
531 if (fw_env_open()) {
532 fprintf(stderr, "Error: environment not initialized\n");
533 return -1;
534 }
535
536 if (strcmp(fname, "-") == 0)
537 fp = stdin;
538 else {
539 fp = fopen(fname, "r");
540 if (fp == NULL) {
541 fprintf(stderr, "I cannot open %s for reading\n",
542 fname);
543 return -1;
544 }
545 }
546
547 while (fgets(dump, sizeof(dump), fp)) {
548 lineno++;
549 len = strlen(dump);
550
551 /*
552 * Read a whole line from the file. If the line is too long
553 * or is not terminated, reports an error and exit.
554 */
555 if (dump[len - 1] != '\n') {
556 fprintf(stderr,
557 "Line %d not corrected terminated or too long\n",
558 lineno);
559 ret = -1;
560 break;
561 }
562
563 /* Drop ending line feed / carriage return */
564 while (len > 0 && (dump[len - 1] == '\n' ||
565 dump[len - 1] == '\r')) {
566 dump[len - 1] = '\0';
567 len--;
568 }
569
570 /* Skip comment or empty lines */
571 if ((len == 0) || dump[0] == '#')
572 continue;
573
574 /*
575 * Search for variable's name,
576 * remove leading whitespaces
577 */
578 name = fw_string_blank(dump, 1);
579 if (!name)
580 continue;
581
582 /* The first white space is the end of variable name */
583 val = fw_string_blank(name, 0);
584 len = strlen(name);
585 if (val) {
586 *val++ = '\0';
587 if ((val - name) < len)
588 val = fw_string_blank(val, 1);
589 else
590 val = NULL;
591 }
592
593#ifdef DEBUG
594 fprintf(stderr, "Setting %s : %s\n",
595 name, val ? val : " removed");
596#endif
597
Joe Hershberger30fd4fad2012-12-11 22:16:32 -0600598 if (env_flags_validate_type(name, val) < 0) {
599 ret = -1;
600 break;
601 }
602
Stefano Babicbd7b26f2010-05-24 12:08:16 +0200603 /*
604 * If there is an error setting a variable,
605 * try to save the environment and returns an error
606 */
607 if (fw_env_write(name, val)) {
608 fprintf(stderr,
609 "fw_env_write returns with error : %s\n",
610 strerror(errno));
611 ret = -1;
612 break;
613 }
614
615 }
616
617 /* Close file if not stdin */
618 if (strcmp(fname, "-") != 0)
619 fclose(fp);
620
621 ret |= fw_env_close();
622
623 return ret;
624
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200625}
626
627/*
628 * Test for bad block on NAND, just returns 0 on NOR, on NAND:
629 * 0 - block is good
630 * > 0 - block is bad
631 * < 0 - failed to test
632 */
633static int flash_bad_block (int fd, uint8_t mtd_type, loff_t *blockstart)
634{
635 if (mtd_type == MTD_NANDFLASH) {
636 int badblock = ioctl (fd, MEMGETBADBLOCK, blockstart);
637
638 if (badblock < 0) {
639 perror ("Cannot read bad block mark");
640 return badblock;
641 }
642
643 if (badblock) {
644#ifdef DEBUG
645 fprintf (stderr, "Bad block at 0x%llx, "
646 "skipping\n", *blockstart);
647#endif
648 return badblock;
649 }
650 }
651
652 return 0;
653}
654
655/*
656 * Read data from flash at an offset into a provided buffer. On NAND it skips
657 * bad blocks but makes sure it stays within ENVSECTORS (dev) starting from
658 * the DEVOFFSET (dev) block. On NOR the loop is only run once.
659 */
660static int flash_read_buf (int dev, int fd, void *buf, size_t count,
661 off_t offset, uint8_t mtd_type)
662{
663 size_t blocklen; /* erase / write length - one block on NAND,
664 0 on NOR */
665 size_t processed = 0; /* progress counter */
666 size_t readlen = count; /* current read length */
667 off_t top_of_range; /* end of the last block we may use */
668 off_t block_seek; /* offset inside the current block to the start
669 of the data */
670 loff_t blockstart; /* running start of the current block -
671 MEMGETBADBLOCK needs 64 bits */
672 int rc;
673
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +0100674 blockstart = (offset / DEVESIZE (dev)) * DEVESIZE (dev);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200675
676 /* Offset inside a block */
677 block_seek = offset - blockstart;
678
679 if (mtd_type == MTD_NANDFLASH) {
680 /*
681 * NAND: calculate which blocks we are reading. We have
682 * to read one block at a time to skip bad blocks.
683 */
684 blocklen = DEVESIZE (dev);
685
686 /*
687 * To calculate the top of the range, we have to use the
688 * global DEVOFFSET (dev), which can be different from offset
689 */
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +0100690 top_of_range = ((DEVOFFSET(dev) / blocklen) +
691 ENVSECTORS (dev)) * blocklen;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200692
693 /* Limit to one block for the first read */
694 if (readlen > blocklen - block_seek)
695 readlen = blocklen - block_seek;
696 } else {
697 blocklen = 0;
698 top_of_range = offset + count;
699 }
700
701 /* This only runs once on NOR flash */
702 while (processed < count) {
703 rc = flash_bad_block (fd, mtd_type, &blockstart);
704 if (rc < 0) /* block test failed */
705 return -1;
706
707 if (blockstart + block_seek + readlen > top_of_range) {
708 /* End of range is reached */
709 fprintf (stderr,
710 "Too few good blocks within range\n");
711 return -1;
712 }
713
714 if (rc) { /* block is bad */
715 blockstart += blocklen;
716 continue;
717 }
718
719 /*
720 * If a block is bad, we retry in the next block at the same
721 * offset - see common/env_nand.c::writeenv()
722 */
723 lseek (fd, blockstart + block_seek, SEEK_SET);
724
725 rc = read (fd, buf + processed, readlen);
726 if (rc != readlen) {
727 fprintf (stderr, "Read error on %s: %s\n",
728 DEVNAME (dev), strerror (errno));
729 return -1;
730 }
731#ifdef DEBUG
Joe Hershberger74620e12012-10-15 15:29:25 +0000732 fprintf(stderr, "Read 0x%x bytes at 0x%llx on %s\n",
733 rc, blockstart + block_seek, DEVNAME(dev));
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200734#endif
735 processed += readlen;
736 readlen = min (blocklen, count - processed);
737 block_seek = 0;
738 blockstart += blocklen;
739 }
740
741 return processed;
742}
743
744/*
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +0100745 * Write count bytes at offset, but stay within ENVSECTORS (dev) sectors of
746 * DEVOFFSET (dev). Similar to the read case above, on NOR and dataflash we
747 * erase and write the whole data at once.
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200748 */
749static int flash_write_buf (int dev, int fd, void *buf, size_t count,
750 off_t offset, uint8_t mtd_type)
751{
752 void *data;
753 struct erase_info_user erase;
754 size_t blocklen; /* length of NAND block / NOR erase sector */
755 size_t erase_len; /* whole area that can be erased - may include
756 bad blocks */
757 size_t erasesize; /* erase / write length - one block on NAND,
758 whole area on NOR */
759 size_t processed = 0; /* progress counter */
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +0100760 size_t write_total; /* total size to actually write - excluding
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200761 bad blocks */
762 off_t erase_offset; /* offset to the first erase block (aligned)
763 below offset */
764 off_t block_seek; /* offset inside the erase block to the start
765 of the data */
766 off_t top_of_range; /* end of the last block we may use */
767 loff_t blockstart; /* running start of the current block -
768 MEMGETBADBLOCK needs 64 bits */
769 int rc;
770
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200771 /*
Oliver Metze387efb2013-08-30 00:56:02 +0200772 * For mtd devices only offset and size of the environment do matter
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200773 */
Oliver Metze387efb2013-08-30 00:56:02 +0200774 if (mtd_type == MTD_ABSENT) {
775 blocklen = count;
776 top_of_range = offset + count;
777 erase_len = blocklen;
778 blockstart = offset;
779 block_seek = 0;
780 write_total = blocklen;
781 } else {
782 blocklen = DEVESIZE(dev);
783
784 top_of_range = ((DEVOFFSET(dev) / blocklen) +
785 ENVSECTORS(dev)) * blocklen;
786
787 erase_offset = (offset / blocklen) * blocklen;
788
789 /* Maximum area we may use */
790 erase_len = top_of_range - erase_offset;
791
792 blockstart = erase_offset;
793 /* Offset inside a block */
794 block_seek = offset - erase_offset;
795
796 /*
797 * Data size we actually write: from the start of the block
798 * to the start of the data, then count bytes of data, and
799 * to the end of the block
800 */
801 write_total = ((block_seek + count + blocklen - 1) /
802 blocklen) * blocklen;
803 }
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200804
805 /*
806 * Support data anywhere within erase sectors: read out the complete
807 * area to be erased, replace the environment image, write the whole
808 * block back again.
809 */
810 if (write_total > count) {
811 data = malloc (erase_len);
812 if (!data) {
813 fprintf (stderr,
Luka Perkov8603b692011-09-05 23:40:13 +0200814 "Cannot malloc %zu bytes: %s\n",
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200815 erase_len, strerror (errno));
816 return -1;
817 }
818
819 rc = flash_read_buf (dev, fd, data, write_total, erase_offset,
820 mtd_type);
821 if (write_total != rc)
822 return -1;
823
Joe Hershberger74620e12012-10-15 15:29:25 +0000824#ifdef DEBUG
825 fprintf(stderr, "Preserving data ");
826 if (block_seek != 0)
827 fprintf(stderr, "0x%x - 0x%lx", 0, block_seek - 1);
828 if (block_seek + count != write_total) {
829 if (block_seek != 0)
830 fprintf(stderr, " and ");
831 fprintf(stderr, "0x%lx - 0x%x",
832 block_seek + count, write_total - 1);
833 }
834 fprintf(stderr, "\n");
835#endif
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200836 /* Overwrite the old environment */
837 memcpy (data + block_seek, buf, count);
838 } else {
839 /*
840 * We get here, iff offset is block-aligned and count is a
841 * multiple of blocklen - see write_total calculation above
842 */
843 data = buf;
844 }
845
846 if (mtd_type == MTD_NANDFLASH) {
847 /*
848 * NAND: calculate which blocks we are writing. We have
849 * to write one block at a time to skip bad blocks.
850 */
851 erasesize = blocklen;
852 } else {
853 erasesize = erase_len;
854 }
855
856 erase.length = erasesize;
857
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +0100858 /* This only runs once on NOR flash and SPI-dataflash */
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200859 while (processed < write_total) {
860 rc = flash_bad_block (fd, mtd_type, &blockstart);
861 if (rc < 0) /* block test failed */
862 return rc;
863
864 if (blockstart + erasesize > top_of_range) {
865 fprintf (stderr, "End of range reached, aborting\n");
866 return -1;
867 }
868
869 if (rc) { /* block is bad */
870 blockstart += blocklen;
871 continue;
872 }
873
Oliver Metze387efb2013-08-30 00:56:02 +0200874 if (mtd_type != MTD_ABSENT) {
875 erase.start = blockstart;
876 ioctl(fd, MEMUNLOCK, &erase);
877 /* These do not need an explicit erase cycle */
878 if (mtd_type != MTD_DATAFLASH)
879 if (ioctl(fd, MEMERASE, &erase) != 0) {
880 fprintf(stderr,
881 "MTD erase error on %s: %s\n",
882 DEVNAME(dev), strerror(errno));
883 return -1;
884 }
885 }
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200886
887 if (lseek (fd, blockstart, SEEK_SET) == -1) {
888 fprintf (stderr,
889 "Seek error on %s: %s\n",
890 DEVNAME (dev), strerror (errno));
891 return -1;
892 }
893
894#ifdef DEBUG
Joe Hershberger74620e12012-10-15 15:29:25 +0000895 fprintf(stderr, "Write 0x%x bytes at 0x%llx\n", erasesize,
896 blockstart);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200897#endif
898 if (write (fd, data + processed, erasesize) != erasesize) {
899 fprintf (stderr, "Write error on %s: %s\n",
900 DEVNAME (dev), strerror (errno));
901 return -1;
902 }
903
Oliver Metze387efb2013-08-30 00:56:02 +0200904 if (mtd_type != MTD_ABSENT)
905 ioctl(fd, MEMLOCK, &erase);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200906
Dustin Byford4b774ff2014-03-06 20:48:23 -0800907 processed += erasesize;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200908 block_seek = 0;
Dustin Byford4b774ff2014-03-06 20:48:23 -0800909 blockstart += erasesize;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200910 }
911
912 if (write_total > count)
913 free (data);
914
915 return processed;
916}
917
918/*
919 * Set obsolete flag at offset - NOR flash only
920 */
921static int flash_flag_obsolete (int dev, int fd, off_t offset)
922{
923 int rc;
Detlev Zundel0aef7bc2010-07-30 11:22:15 +0200924 struct erase_info_user erase;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200925
Detlev Zundel0aef7bc2010-07-30 11:22:15 +0200926 erase.start = DEVOFFSET (dev);
927 erase.length = DEVESIZE (dev);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200928 /* This relies on the fact, that obsolete_flag == 0 */
929 rc = lseek (fd, offset, SEEK_SET);
930 if (rc < 0) {
931 fprintf (stderr, "Cannot seek to set the flag on %s \n",
932 DEVNAME (dev));
933 return rc;
934 }
Detlev Zundel0aef7bc2010-07-30 11:22:15 +0200935 ioctl (fd, MEMUNLOCK, &erase);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200936 rc = write (fd, &obsolete_flag, sizeof (obsolete_flag));
Detlev Zundel0aef7bc2010-07-30 11:22:15 +0200937 ioctl (fd, MEMLOCK, &erase);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200938 if (rc < 0)
939 perror ("Could not set obsolete flag");
940
941 return rc;
942}
943
Marek Vasuta8a752c2014-03-05 19:59:52 +0100944/* Encrypt or decrypt the environment before writing or reading it. */
945static int env_aes_cbc_crypt(char *payload, const int enc)
946{
947 uint8_t *data = (uint8_t *)payload;
948 const int len = getenvsize();
949 uint8_t key_exp[AES_EXPAND_KEY_LENGTH];
950 uint32_t aes_blocks;
951
952 /* First we expand the key. */
Andreas Fenkart371ee132015-12-09 13:13:24 +0100953 aes_expand_key(common_args.aes_key, key_exp);
Marek Vasuta8a752c2014-03-05 19:59:52 +0100954
955 /* Calculate the number of AES blocks to encrypt. */
956 aes_blocks = DIV_ROUND_UP(len, AES_KEY_LENGTH);
957
958 if (enc)
959 aes_cbc_encrypt_blocks(key_exp, data, data, aes_blocks);
960 else
961 aes_cbc_decrypt_blocks(key_exp, data, data, aes_blocks);
962
963 return 0;
964}
965
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200966static int flash_write (int fd_current, int fd_target, int dev_target)
967{
968 int rc;
969
970 switch (environment.flag_scheme) {
971 case FLAG_NONE:
972 break;
973 case FLAG_INCREMENTAL:
974 (*environment.flags)++;
975 break;
976 case FLAG_BOOLEAN:
977 *environment.flags = active_flag;
978 break;
979 default:
980 fprintf (stderr, "Unimplemented flash scheme %u \n",
981 environment.flag_scheme);
982 return -1;
983 }
984
985#ifdef DEBUG
Joe Hershberger74620e12012-10-15 15:29:25 +0000986 fprintf(stderr, "Writing new environment at 0x%lx on %s\n",
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200987 DEVOFFSET (dev_target), DEVNAME (dev_target));
988#endif
Marek Vasuta8a752c2014-03-05 19:59:52 +0100989
Joe Hershberger497f2052012-10-03 09:38:46 +0000990 rc = flash_write_buf(dev_target, fd_target, environment.image,
991 CUR_ENVSIZE, DEVOFFSET(dev_target),
Guennadi Liakhovetski56086922008-09-04 13:01:49 +0200992 DEVTYPE(dev_target));
993 if (rc < 0)
994 return rc;
995
996 if (environment.flag_scheme == FLAG_BOOLEAN) {
997 /* Have to set obsolete flag */
998 off_t offset = DEVOFFSET (dev_current) +
999 offsetof (struct env_image_redundant, flags);
1000#ifdef DEBUG
Joe Hershberger74620e12012-10-15 15:29:25 +00001001 fprintf(stderr,
1002 "Setting obsolete flag in environment at 0x%lx on %s\n",
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001003 DEVOFFSET (dev_current), DEVNAME (dev_current));
1004#endif
1005 flash_flag_obsolete (dev_current, fd_current, offset);
1006 }
1007
1008 return 0;
1009}
1010
1011static int flash_read (int fd)
1012{
1013 struct mtd_info_user mtdinfo;
Lubomir Rintelf1932b72013-02-10 01:02:36 +00001014 struct stat st;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001015 int rc;
1016
Lubomir Rintelf1932b72013-02-10 01:02:36 +00001017 rc = fstat(fd, &st);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001018 if (rc < 0) {
Lubomir Rintelf1932b72013-02-10 01:02:36 +00001019 fprintf(stderr, "Cannot stat the file %s\n",
1020 DEVNAME(dev_current));
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001021 return -1;
1022 }
1023
Lubomir Rintelf1932b72013-02-10 01:02:36 +00001024 if (S_ISCHR(st.st_mode)) {
1025 rc = ioctl(fd, MEMGETINFO, &mtdinfo);
1026 if (rc < 0) {
1027 fprintf(stderr, "Cannot get MTD information for %s\n",
1028 DEVNAME(dev_current));
1029 return -1;
1030 }
1031 if (mtdinfo.type != MTD_NORFLASH &&
1032 mtdinfo.type != MTD_NANDFLASH &&
Joe Hershberger2b744332013-04-08 10:32:51 +00001033 mtdinfo.type != MTD_DATAFLASH &&
1034 mtdinfo.type != MTD_UBIVOLUME) {
Lubomir Rintelf1932b72013-02-10 01:02:36 +00001035 fprintf (stderr, "Unsupported flash type %u on %s\n",
1036 mtdinfo.type, DEVNAME(dev_current));
1037 return -1;
1038 }
1039 } else {
1040 memset(&mtdinfo, 0, sizeof(mtdinfo));
1041 mtdinfo.type = MTD_ABSENT;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001042 }
1043
1044 DEVTYPE(dev_current) = mtdinfo.type;
1045
Joe Hershberger497f2052012-10-03 09:38:46 +00001046 rc = flash_read_buf(dev_current, fd, environment.image, CUR_ENVSIZE,
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001047 DEVOFFSET (dev_current), mtdinfo.type);
Marek Vasuta8a752c2014-03-05 19:59:52 +01001048 if (rc != CUR_ENVSIZE)
1049 return -1;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001050
Marek Vasuta8a752c2014-03-05 19:59:52 +01001051 return 0;
wdenk6aff3112002-12-17 01:51:00 +00001052}
1053
1054static int flash_io (int mode)
1055{
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001056 int fd_current, fd_target, rc, dev_target;
wdenk6aff3112002-12-17 01:51:00 +00001057
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001058 /* dev_current: fd_current, erase_current */
1059 fd_current = open (DEVNAME (dev_current), mode);
1060 if (fd_current < 0) {
wdenk4a6fd342003-04-12 23:38:12 +00001061 fprintf (stderr,
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001062 "Can't open %s: %s\n",
1063 DEVNAME (dev_current), strerror (errno));
1064 return -1;
wdenkd0fb80c2003-01-11 09:48:40 +00001065 }
wdenk6aff3112002-12-17 01:51:00 +00001066
1067 if (mode == O_RDWR) {
wdenkd0fb80c2003-01-11 09:48:40 +00001068 if (HaveRedundEnv) {
1069 /* switch to next partition for writing */
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001070 dev_target = !dev_current;
1071 /* dev_target: fd_target, erase_target */
1072 fd_target = open (DEVNAME (dev_target), mode);
1073 if (fd_target < 0) {
wdenk4a6fd342003-04-12 23:38:12 +00001074 fprintf (stderr,
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001075 "Can't open %s: %s\n",
1076 DEVNAME (dev_target),
1077 strerror (errno));
1078 rc = -1;
1079 goto exit;
wdenkd0fb80c2003-01-11 09:48:40 +00001080 }
1081 } else {
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001082 dev_target = dev_current;
1083 fd_target = fd_current;
wdenk6aff3112002-12-17 01:51:00 +00001084 }
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001085
1086 rc = flash_write (fd_current, fd_target, dev_target);
wdenk6aff3112002-12-17 01:51:00 +00001087
wdenkd0fb80c2003-01-11 09:48:40 +00001088 if (HaveRedundEnv) {
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001089 if (close (fd_target)) {
wdenkd0fb80c2003-01-11 09:48:40 +00001090 fprintf (stderr,
wdenk4a6fd342003-04-12 23:38:12 +00001091 "I/O error on %s: %s\n",
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001092 DEVNAME (dev_target),
wdenk4a6fd342003-04-12 23:38:12 +00001093 strerror (errno));
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001094 rc = -1;
wdenkd0fb80c2003-01-11 09:48:40 +00001095 }
wdenk6aff3112002-12-17 01:51:00 +00001096 }
wdenk6aff3112002-12-17 01:51:00 +00001097 } else {
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001098 rc = flash_read (fd_current);
wdenk6aff3112002-12-17 01:51:00 +00001099 }
1100
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001101exit:
1102 if (close (fd_current)) {
wdenk6aff3112002-12-17 01:51:00 +00001103 fprintf (stderr,
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001104 "I/O error on %s: %s\n",
1105 DEVNAME (dev_current), strerror (errno));
1106 return -1;
wdenk6aff3112002-12-17 01:51:00 +00001107 }
1108
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001109 return rc;
wdenk6aff3112002-12-17 01:51:00 +00001110}
1111
1112/*
1113 * s1 is either a simple 'name', or a 'name=value' pair.
1114 * s2 is a 'name=value' pair.
1115 * If the names match, return the value of s2, else NULL.
1116 */
1117
Markus Klotzbücher6de66b32007-11-27 10:23:20 +01001118static char *envmatch (char * s1, char * s2)
wdenk6aff3112002-12-17 01:51:00 +00001119{
Joe Hershberger586197d2012-10-03 09:38:50 +00001120 if (s1 == NULL || s2 == NULL)
1121 return NULL;
wdenk6aff3112002-12-17 01:51:00 +00001122
1123 while (*s1 == *s2++)
1124 if (*s1++ == '=')
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001125 return s2;
wdenk4a6fd342003-04-12 23:38:12 +00001126 if (*s1 == '\0' && *(s2 - 1) == '=')
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001127 return s2;
1128 return NULL;
wdenk6aff3112002-12-17 01:51:00 +00001129}
1130
1131/*
1132 * Prevent confusion if running from erased flash memory
1133 */
Stefano Babicbd7b26f2010-05-24 12:08:16 +02001134int fw_env_open(void)
wdenk6aff3112002-12-17 01:51:00 +00001135{
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001136 int crc0, crc0_ok;
Jon Povey735eb0f2011-03-11 14:10:56 +09001137 unsigned char flag0;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001138 void *addr0;
wdenkd0fb80c2003-01-11 09:48:40 +00001139
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001140 int crc1, crc1_ok;
Jon Povey735eb0f2011-03-11 14:10:56 +09001141 unsigned char flag1;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001142 void *addr1;
1143
Marek Vasuta8a752c2014-03-05 19:59:52 +01001144 int ret;
1145
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001146 struct env_image_single *single;
1147 struct env_image_redundant *redundant;
wdenk6aff3112002-12-17 01:51:00 +00001148
wdenk4a6fd342003-04-12 23:38:12 +00001149 if (parse_config ()) /* should fill envdevices */
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001150 return -1;
wdenk4a6fd342003-04-12 23:38:12 +00001151
Joe Hershberger497f2052012-10-03 09:38:46 +00001152 addr0 = calloc(1, CUR_ENVSIZE);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001153 if (addr0 == NULL) {
Joe Hershberger497f2052012-10-03 09:38:46 +00001154 fprintf(stderr,
wdenk4a6fd342003-04-12 23:38:12 +00001155 "Not enough memory for environment (%ld bytes)\n",
Joe Hershberger497f2052012-10-03 09:38:46 +00001156 CUR_ENVSIZE);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001157 return -1;
wdenkd0fb80c2003-01-11 09:48:40 +00001158 }
wdenk4a6fd342003-04-12 23:38:12 +00001159
wdenkd0fb80c2003-01-11 09:48:40 +00001160 /* read environment from FLASH to local buffer */
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001161 environment.image = addr0;
1162
1163 if (HaveRedundEnv) {
1164 redundant = addr0;
1165 environment.crc = &redundant->crc;
1166 environment.flags = &redundant->flags;
1167 environment.data = redundant->data;
1168 } else {
1169 single = addr0;
1170 environment.crc = &single->crc;
1171 environment.flags = NULL;
1172 environment.data = single->data;
wdenkd0fb80c2003-01-11 09:48:40 +00001173 }
wdenk4a6fd342003-04-12 23:38:12 +00001174
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001175 dev_current = 0;
1176 if (flash_io (O_RDONLY))
1177 return -1;
1178
1179 crc0 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE);
Marek Vasuta8a752c2014-03-05 19:59:52 +01001180
Andreas Fenkart371ee132015-12-09 13:13:24 +01001181 if (common_args.aes_flag) {
Marek Vasuta8a752c2014-03-05 19:59:52 +01001182 ret = env_aes_cbc_crypt(environment.data, 0);
1183 if (ret)
1184 return ret;
1185 }
1186
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001187 crc0_ok = (crc0 == *environment.crc);
wdenkd0fb80c2003-01-11 09:48:40 +00001188 if (!HaveRedundEnv) {
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001189 if (!crc0_ok) {
wdenk4a6fd342003-04-12 23:38:12 +00001190 fprintf (stderr,
1191 "Warning: Bad CRC, using default environment\n");
Wolfgang Denkf07217c2006-03-12 23:27:46 +01001192 memcpy(environment.data, default_environment, sizeof default_environment);
wdenk6aff3112002-12-17 01:51:00 +00001193 }
wdenkd0fb80c2003-01-11 09:48:40 +00001194 } else {
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001195 flag0 = *environment.flags;
wdenk4a6fd342003-04-12 23:38:12 +00001196
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001197 dev_current = 1;
Joe Hershberger497f2052012-10-03 09:38:46 +00001198 addr1 = calloc(1, CUR_ENVSIZE);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001199 if (addr1 == NULL) {
Joe Hershberger497f2052012-10-03 09:38:46 +00001200 fprintf(stderr,
wdenk4a6fd342003-04-12 23:38:12 +00001201 "Not enough memory for environment (%ld bytes)\n",
Joe Hershberger497f2052012-10-03 09:38:46 +00001202 CUR_ENVSIZE);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001203 return -1;
wdenk4a6fd342003-04-12 23:38:12 +00001204 }
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001205 redundant = addr1;
wdenk4a6fd342003-04-12 23:38:12 +00001206
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001207 /*
1208 * have to set environment.image for flash_read(), careful -
1209 * other pointers in environment still point inside addr0
1210 */
1211 environment.image = addr1;
1212 if (flash_io (O_RDONLY))
1213 return -1;
1214
1215 /* Check flag scheme compatibility */
1216 if (DEVTYPE(dev_current) == MTD_NORFLASH &&
1217 DEVTYPE(!dev_current) == MTD_NORFLASH) {
1218 environment.flag_scheme = FLAG_BOOLEAN;
1219 } else if (DEVTYPE(dev_current) == MTD_NANDFLASH &&
1220 DEVTYPE(!dev_current) == MTD_NANDFLASH) {
1221 environment.flag_scheme = FLAG_INCREMENTAL;
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001222 } else if (DEVTYPE(dev_current) == MTD_DATAFLASH &&
1223 DEVTYPE(!dev_current) == MTD_DATAFLASH) {
1224 environment.flag_scheme = FLAG_BOOLEAN;
Joe Hershberger785881f2013-04-08 10:32:52 +00001225 } else if (DEVTYPE(dev_current) == MTD_UBIVOLUME &&
1226 DEVTYPE(!dev_current) == MTD_UBIVOLUME) {
1227 environment.flag_scheme = FLAG_INCREMENTAL;
Oliver Metz23ef62d2013-08-30 00:56:01 +02001228 } else if (DEVTYPE(dev_current) == MTD_ABSENT &&
1229 DEVTYPE(!dev_current) == MTD_ABSENT) {
1230 environment.flag_scheme = FLAG_INCREMENTAL;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001231 } else {
1232 fprintf (stderr, "Incompatible flash types!\n");
1233 return -1;
wdenk6aff3112002-12-17 01:51:00 +00001234 }
wdenk4a6fd342003-04-12 23:38:12 +00001235
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001236 crc1 = crc32 (0, (uint8_t *) redundant->data, ENV_SIZE);
Marek Vasuta8a752c2014-03-05 19:59:52 +01001237
Andreas Fenkart371ee132015-12-09 13:13:24 +01001238 if (common_args.aes_flag) {
Marek Vasuta8a752c2014-03-05 19:59:52 +01001239 ret = env_aes_cbc_crypt(redundant->data, 0);
1240 if (ret)
1241 return ret;
1242 }
1243
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001244 crc1_ok = (crc1 == redundant->crc);
1245 flag1 = redundant->flags;
wdenk4a6fd342003-04-12 23:38:12 +00001246
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001247 if (crc0_ok && !crc1_ok) {
1248 dev_current = 0;
1249 } else if (!crc0_ok && crc1_ok) {
1250 dev_current = 1;
1251 } else if (!crc0_ok && !crc1_ok) {
wdenk4a6fd342003-04-12 23:38:12 +00001252 fprintf (stderr,
1253 "Warning: Bad CRC, using default environment\n");
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001254 memcpy (environment.data, default_environment,
1255 sizeof default_environment);
1256 dev_current = 0;
1257 } else {
1258 switch (environment.flag_scheme) {
1259 case FLAG_BOOLEAN:
1260 if (flag0 == active_flag &&
1261 flag1 == obsolete_flag) {
1262 dev_current = 0;
1263 } else if (flag0 == obsolete_flag &&
1264 flag1 == active_flag) {
1265 dev_current = 1;
1266 } else if (flag0 == flag1) {
1267 dev_current = 0;
1268 } else if (flag0 == 0xFF) {
1269 dev_current = 0;
1270 } else if (flag1 == 0xFF) {
1271 dev_current = 1;
1272 } else {
1273 dev_current = 0;
1274 }
1275 break;
1276 case FLAG_INCREMENTAL:
Jon Povey735eb0f2011-03-11 14:10:56 +09001277 if (flag0 == 255 && flag1 == 0)
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001278 dev_current = 1;
1279 else if ((flag1 == 255 && flag0 == 0) ||
Jon Povey735eb0f2011-03-11 14:10:56 +09001280 flag0 >= flag1)
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001281 dev_current = 0;
Jon Povey735eb0f2011-03-11 14:10:56 +09001282 else /* flag1 > flag0 */
1283 dev_current = 1;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001284 break;
1285 default:
1286 fprintf (stderr, "Unknown flag scheme %u \n",
1287 environment.flag_scheme);
1288 return -1;
1289 }
1290 }
1291
1292 /*
1293 * If we are reading, we don't need the flag and the CRC any
1294 * more, if we are writing, we will re-calculate CRC and update
1295 * flags before writing out
1296 */
1297 if (dev_current) {
1298 environment.image = addr1;
1299 environment.crc = &redundant->crc;
1300 environment.flags = &redundant->flags;
1301 environment.data = redundant->data;
1302 free (addr0);
1303 } else {
1304 environment.image = addr0;
1305 /* Other pointers are already set */
wdenk4a6fd342003-04-12 23:38:12 +00001306 free (addr1);
wdenk6aff3112002-12-17 01:51:00 +00001307 }
Joe Hershberger74620e12012-10-15 15:29:25 +00001308#ifdef DEBUG
1309 fprintf(stderr, "Selected env in %s\n", DEVNAME(dev_current));
1310#endif
wdenk6aff3112002-12-17 01:51:00 +00001311 }
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001312 return 0;
wdenk6aff3112002-12-17 01:51:00 +00001313}
1314
1315
wdenk4a6fd342003-04-12 23:38:12 +00001316static int parse_config ()
wdenk6aff3112002-12-17 01:51:00 +00001317{
1318 struct stat st;
1319
wdenkd0fb80c2003-01-11 09:48:40 +00001320#if defined(CONFIG_FILE)
1321 /* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */
Andreas Fenkart371ee132015-12-09 13:13:24 +01001322 if (get_config(common_args.config_file)) {
1323 fprintf(stderr, "Cannot parse config file '%s': %m\n",
1324 common_args.config_file);
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001325 return -1;
wdenk6aff3112002-12-17 01:51:00 +00001326 }
wdenkd0fb80c2003-01-11 09:48:40 +00001327#else
Tom Rini229695f2014-03-28 12:03:33 -04001328 DEVNAME (0) = DEVICE1_NAME;
wdenk4a6fd342003-04-12 23:38:12 +00001329 DEVOFFSET (0) = DEVICE1_OFFSET;
1330 ENVSIZE (0) = ENV1_SIZE;
Dustin Byford23869bf2014-03-06 20:48:22 -08001331 /* Default values are: erase-size=env-size */
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001332 DEVESIZE (0) = ENVSIZE (0);
Dustin Byford23869bf2014-03-06 20:48:22 -08001333 /* #sectors=env-size/erase-size (rounded up) */
1334 ENVSECTORS (0) = (ENVSIZE(0) + DEVESIZE(0) - 1) / DEVESIZE(0);
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001335#ifdef DEVICE1_ESIZE
wdenk4a6fd342003-04-12 23:38:12 +00001336 DEVESIZE (0) = DEVICE1_ESIZE;
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001337#endif
1338#ifdef DEVICE1_ENVSECTORS
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001339 ENVSECTORS (0) = DEVICE1_ENVSECTORS;
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001340#endif
1341
wdenk6aff3112002-12-17 01:51:00 +00001342#ifdef HAVE_REDUND
Tom Rini229695f2014-03-28 12:03:33 -04001343 DEVNAME (1) = DEVICE2_NAME;
wdenk4a6fd342003-04-12 23:38:12 +00001344 DEVOFFSET (1) = DEVICE2_OFFSET;
1345 ENVSIZE (1) = ENV2_SIZE;
Dustin Byford23869bf2014-03-06 20:48:22 -08001346 /* Default values are: erase-size=env-size */
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001347 DEVESIZE (1) = ENVSIZE (1);
Dustin Byford23869bf2014-03-06 20:48:22 -08001348 /* #sectors=env-size/erase-size (rounded up) */
1349 ENVSECTORS (1) = (ENVSIZE(1) + DEVESIZE(1) - 1) / DEVESIZE(1);
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001350#ifdef DEVICE2_ESIZE
wdenk4a6fd342003-04-12 23:38:12 +00001351 DEVESIZE (1) = DEVICE2_ESIZE;
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001352#endif
1353#ifdef DEVICE2_ENVSECTORS
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001354 ENVSECTORS (1) = DEVICE2_ENVSECTORS;
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001355#endif
wdenkd0fb80c2003-01-11 09:48:40 +00001356 HaveRedundEnv = 1;
wdenk6aff3112002-12-17 01:51:00 +00001357#endif
wdenkd0fb80c2003-01-11 09:48:40 +00001358#endif
wdenk4a6fd342003-04-12 23:38:12 +00001359 if (stat (DEVNAME (0), &st)) {
1360 fprintf (stderr,
1361 "Cannot access MTD device %s: %s\n",
1362 DEVNAME (0), strerror (errno));
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001363 return -1;
wdenkd0fb80c2003-01-11 09:48:40 +00001364 }
wdenk4a6fd342003-04-12 23:38:12 +00001365
1366 if (HaveRedundEnv && stat (DEVNAME (1), &st)) {
1367 fprintf (stderr,
1368 "Cannot access MTD device %s: %s\n",
Wolfgang Denke2146b62005-09-25 01:20:38 +02001369 DEVNAME (1), strerror (errno));
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001370 return -1;
wdenkd0fb80c2003-01-11 09:48:40 +00001371 }
wdenk6aff3112002-12-17 01:51:00 +00001372 return 0;
1373}
wdenkd0fb80c2003-01-11 09:48:40 +00001374
1375#if defined(CONFIG_FILE)
1376static int get_config (char *fname)
1377{
1378 FILE *fp;
1379 int i = 0;
1380 int rc;
1381 char dump[128];
Tom Rini229695f2014-03-28 12:03:33 -04001382 char *devname;
wdenkd0fb80c2003-01-11 09:48:40 +00001383
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001384 fp = fopen (fname, "r");
1385 if (fp == NULL)
1386 return -1;
wdenkd0fb80c2003-01-11 09:48:40 +00001387
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001388 while (i < 2 && fgets (dump, sizeof (dump), fp)) {
wdenkd0fb80c2003-01-11 09:48:40 +00001389 /* Skip incomplete conversions and comment strings */
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001390 if (dump[0] == '#')
wdenkd0fb80c2003-01-11 09:48:40 +00001391 continue;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001392
Tom Rini229695f2014-03-28 12:03:33 -04001393 rc = sscanf (dump, "%ms %lx %lx %lx %lx",
1394 &devname,
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001395 &DEVOFFSET (i),
1396 &ENVSIZE (i),
1397 &DEVESIZE (i),
1398 &ENVSECTORS (i));
1399
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001400 if (rc < 3)
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001401 continue;
1402
Tom Rini229695f2014-03-28 12:03:33 -04001403 DEVNAME(i) = devname;
1404
Remy Bohmer9eeaa8e2011-02-12 19:06:26 +01001405 if (rc < 4)
1406 /* Assume the erase size is the same as the env-size */
1407 DEVESIZE(i) = ENVSIZE(i);
1408
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001409 if (rc < 5)
Dustin Byford23869bf2014-03-06 20:48:22 -08001410 /* Assume enough env sectors to cover the environment */
1411 ENVSECTORS (i) = (ENVSIZE(i) + DEVESIZE(i) - 1) / DEVESIZE(i);
wdenkd0fb80c2003-01-11 09:48:40 +00001412
1413 i++;
1414 }
wdenk4a6fd342003-04-12 23:38:12 +00001415 fclose (fp);
1416
wdenkd0fb80c2003-01-11 09:48:40 +00001417 HaveRedundEnv = i - 1;
wdenk4a6fd342003-04-12 23:38:12 +00001418 if (!i) { /* No valid entries found */
wdenkd0fb80c2003-01-11 09:48:40 +00001419 errno = EINVAL;
Guennadi Liakhovetski56086922008-09-04 13:01:49 +02001420 return -1;
wdenkd0fb80c2003-01-11 09:48:40 +00001421 } else
1422 return 0;
1423}
1424#endif