577ce2de4725249ba4989d02f78c57595d6f93c6
[karo-tx-uboot.git] / tools / env / fw_env.c
1 /*
2  * (C) Copyright 2000-2010
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2008
6  * Guennadi Liakhovetski, DENX Software Engineering, lg@denx.de.
7  *
8  * SPDX-License-Identifier:     GPL-2.0+
9  */
10
11 #include <errno.h>
12 #include <env_flags.h>
13 #include <fcntl.h>
14 #include <linux/stringify.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <stddef.h>
18 #include <string.h>
19 #include <sys/types.h>
20 #include <sys/ioctl.h>
21 #include <sys/stat.h>
22 #include <unistd.h>
23
24 #ifdef MTD_OLD
25 # include <stdint.h>
26 # include <linux/mtd/mtd.h>
27 #else
28 # define  __user        /* nothing */
29 # include <mtd/mtd-user.h>
30 #endif
31
32 #include "fw_env.h"
33
34 #define WHITESPACE(c) ((c == '\t') || (c == ' '))
35
36 #define min(x, y) ({                            \
37         typeof(x) _min1 = (x);                  \
38         typeof(y) _min2 = (y);                  \
39         (void) (&_min1 == &_min2);              \
40         _min1 < _min2 ? _min1 : _min2; })
41
42 struct envdev_s {
43         char devname[16];               /* Device name */
44         ulong devoff;                   /* Device offset */
45         ulong env_size;                 /* environment size */
46         ulong erase_size;               /* device erase size */
47         ulong env_sectors;              /* number of environment sectors */
48         uint8_t mtd_type;               /* type of the MTD device */
49 };
50
51 static struct envdev_s envdevices[2] =
52 {
53         {
54                 .mtd_type = MTD_ABSENT,
55         }, {
56                 .mtd_type = MTD_ABSENT,
57         },
58 };
59 static int dev_current;
60
61 #define DEVNAME(i)    envdevices[(i)].devname
62 #define DEVOFFSET(i)  envdevices[(i)].devoff
63 #define ENVSIZE(i)    envdevices[(i)].env_size
64 #define DEVESIZE(i)   envdevices[(i)].erase_size
65 #define ENVSECTORS(i) envdevices[(i)].env_sectors
66 #define DEVTYPE(i)    envdevices[(i)].mtd_type
67
68 #define CUR_ENVSIZE ENVSIZE(dev_current)
69
70 #define ENV_SIZE      getenvsize()
71
72 struct env_image_single {
73         uint32_t        crc;    /* CRC32 over data bytes    */
74         char            data[];
75 };
76
77 struct env_image_redundant {
78         uint32_t        crc;    /* CRC32 over data bytes    */
79         unsigned char   flags;  /* active or obsolete */
80         char            data[];
81 };
82
83 enum flag_scheme {
84         FLAG_NONE,
85         FLAG_BOOLEAN,
86         FLAG_INCREMENTAL,
87 };
88
89 struct environment {
90         void                    *image;
91         uint32_t                *crc;
92         unsigned char           *flags;
93         char                    *data;
94         enum flag_scheme        flag_scheme;
95 };
96
97 static struct environment environment = {
98         .flag_scheme = FLAG_NONE,
99 };
100
101 static int HaveRedundEnv = 0;
102
103 static unsigned char active_flag = 1;
104 /* obsolete_flag must be 0 to efficiently set it on NOR flash without erasing */
105 static unsigned char obsolete_flag = 0;
106
107 #define DEFAULT_ENV_INSTANCE_STATIC
108 #include <env_default.h>
109
110 static int flash_io (int mode);
111 static char *envmatch (char * s1, char * s2);
112 static int parse_config (void);
113
114 #if defined(CONFIG_FILE)
115 static int get_config (char *);
116 #endif
117 static inline ulong getenvsize (void)
118 {
119         ulong rc = CUR_ENVSIZE - sizeof(long);
120
121         if (HaveRedundEnv)
122                 rc -= sizeof (char);
123         return rc;
124 }
125
126 static char *fw_string_blank(char *s, int noblank)
127 {
128         int i;
129         int len = strlen(s);
130
131         for (i = 0; i < len; i++, s++) {
132                 if ((noblank && !WHITESPACE(*s)) ||
133                         (!noblank && WHITESPACE(*s)))
134                         break;
135         }
136         if (i == len)
137                 return NULL;
138
139         return s;
140 }
141
142 /*
143  * Search the environment for a variable.
144  * Return the value, if found, or NULL, if not found.
145  */
146 char *fw_getenv (char *name)
147 {
148         char *env, *nxt;
149
150         for (env = environment.data; *env; env = nxt + 1) {
151                 char *val;
152
153                 for (nxt = env; *nxt; ++nxt) {
154                         if (nxt >= &environment.data[ENV_SIZE]) {
155                                 fprintf (stderr, "## Error: "
156                                         "environment not terminated\n");
157                                 return NULL;
158                         }
159                 }
160                 val = envmatch (name, env);
161                 if (!val)
162                         continue;
163                 return val;
164         }
165         return NULL;
166 }
167
168 /*
169  * Search the default environment for a variable.
170  * Return the value, if found, or NULL, if not found.
171  */
172 char *fw_getdefenv(char *name)
173 {
174         char *env, *nxt;
175
176         for (env = default_environment; *env; env = nxt + 1) {
177                 char *val;
178
179                 for (nxt = env; *nxt; ++nxt) {
180                         if (nxt >= &default_environment[ENV_SIZE]) {
181                                 fprintf(stderr, "## Error: "
182                                         "default environment not terminated\n");
183                                 return NULL;
184                         }
185                 }
186                 val = envmatch(name, env);
187                 if (!val)
188                         continue;
189                 return val;
190         }
191         return NULL;
192 }
193
194 /*
195  * Print the current definition of one, or more, or all
196  * environment variables
197  */
198 int fw_printenv (int argc, char *argv[])
199 {
200         char *env, *nxt;
201         int i, n_flag;
202         int rc = 0;
203
204         if (fw_env_open())
205                 return -1;
206
207         if (argc == 1) {                /* Print all env variables  */
208                 for (env = environment.data; *env; env = nxt + 1) {
209                         for (nxt = env; *nxt; ++nxt) {
210                                 if (nxt >= &environment.data[ENV_SIZE]) {
211                                         fprintf (stderr, "## Error: "
212                                                 "environment not terminated\n");
213                                         return -1;
214                                 }
215                         }
216
217                         printf ("%s\n", env);
218                 }
219                 return 0;
220         }
221
222         if (strcmp (argv[1], "-n") == 0) {
223                 n_flag = 1;
224                 ++argv;
225                 --argc;
226                 if (argc != 2) {
227                         fprintf (stderr, "## Error: "
228                                 "`-n' option requires exactly one argument\n");
229                         return -1;
230                 }
231         } else {
232                 n_flag = 0;
233         }
234
235         for (i = 1; i < argc; ++i) {    /* print single env variables   */
236                 char *name = argv[i];
237                 char *val = NULL;
238
239                 for (env = environment.data; *env; env = nxt + 1) {
240
241                         for (nxt = env; *nxt; ++nxt) {
242                                 if (nxt >= &environment.data[ENV_SIZE]) {
243                                         fprintf (stderr, "## Error: "
244                                                 "environment not terminated\n");
245                                         return -1;
246                                 }
247                         }
248                         val = envmatch (name, env);
249                         if (val) {
250                                 if (!n_flag) {
251                                         fputs (name, stdout);
252                                         putc ('=', stdout);
253                                 }
254                                 puts (val);
255                                 break;
256                         }
257                 }
258                 if (!val) {
259                         fprintf (stderr, "## Error: \"%s\" not defined\n", name);
260                         rc = -1;
261                 }
262         }
263
264         return rc;
265 }
266
267 int fw_env_close(void)
268 {
269         /*
270          * Update CRC
271          */
272         *environment.crc = crc32(0, (uint8_t *) environment.data, ENV_SIZE);
273
274         /* write environment back to flash */
275         if (flash_io(O_RDWR)) {
276                 fprintf(stderr,
277                         "Error: can't write fw_env to flash\n");
278                         return -1;
279         }
280
281         return 0;
282 }
283
284
285 /*
286  * Set/Clear a single variable in the environment.
287  * This is called in sequence to update the environment
288  * in RAM without updating the copy in flash after each set
289  */
290 int fw_env_write(char *name, char *value)
291 {
292         int len;
293         char *env, *nxt;
294         char *oldval = NULL;
295         int deleting, creating, overwriting;
296
297         /*
298          * search if variable with this name already exists
299          */
300         for (nxt = env = environment.data; *env; env = nxt + 1) {
301                 for (nxt = env; *nxt; ++nxt) {
302                         if (nxt >= &environment.data[ENV_SIZE]) {
303                                 fprintf(stderr, "## Error: "
304                                         "environment not terminated\n");
305                                 errno = EINVAL;
306                                 return -1;
307                         }
308                 }
309                 if ((oldval = envmatch (name, env)) != NULL)
310                         break;
311         }
312
313         deleting = (oldval && !(value && strlen(value)));
314         creating = (!oldval && (value && strlen(value)));
315         overwriting = (oldval && (value && strlen(value)));
316
317         /* check for permission */
318         if (deleting) {
319                 if (env_flags_validate_varaccess(name,
320                     ENV_FLAGS_VARACCESS_PREVENT_DELETE)) {
321                         printf("Can't delete \"%s\"\n", name);
322                         errno = EROFS;
323                         return -1;
324                 }
325         } else if (overwriting) {
326                 if (env_flags_validate_varaccess(name,
327                     ENV_FLAGS_VARACCESS_PREVENT_OVERWR)) {
328                         printf("Can't overwrite \"%s\"\n", name);
329                         errno = EROFS;
330                         return -1;
331                 } else if (env_flags_validate_varaccess(name,
332                     ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR)) {
333                         const char *defval = fw_getdefenv(name);
334
335                         if (defval == NULL)
336                                 defval = "";
337                         if (strcmp(oldval, defval)
338                             != 0) {
339                                 printf("Can't overwrite \"%s\"\n", name);
340                                 errno = EROFS;
341                                 return -1;
342                         }
343                 }
344         } else if (creating) {
345                 if (env_flags_validate_varaccess(name,
346                     ENV_FLAGS_VARACCESS_PREVENT_CREATE)) {
347                         printf("Can't create \"%s\"\n", name);
348                         errno = EROFS;
349                         return -1;
350                 }
351         } else
352                 /* Nothing to do */
353                 return 0;
354
355         if (deleting || overwriting) {
356                 if (*++nxt == '\0') {
357                         *env = '\0';
358                 } else {
359                         for (;;) {
360                                 *env = *nxt++;
361                                 if ((*env == '\0') && (*nxt == '\0'))
362                                         break;
363                                 ++env;
364                         }
365                 }
366                 *++env = '\0';
367         }
368
369         /* Delete only ? */
370         if (!value || !strlen(value))
371                 return 0;
372
373         /*
374          * Append new definition at the end
375          */
376         for (env = environment.data; *env || *(env + 1); ++env);
377         if (env > environment.data)
378                 ++env;
379         /*
380          * Overflow when:
381          * "name" + "=" + "val" +"\0\0"  > CUR_ENVSIZE - (env-environment)
382          */
383         len = strlen (name) + 2;
384         /* add '=' for first arg, ' ' for all others */
385         len += strlen(value) + 1;
386
387         if (len > (&environment.data[ENV_SIZE] - env)) {
388                 fprintf (stderr,
389                         "Error: environment overflow, \"%s\" deleted\n",
390                         name);
391                 return -1;
392         }
393
394         while ((*env = *name++) != '\0')
395                 env++;
396         *env = '=';
397         while ((*++env = *value++) != '\0')
398                 ;
399
400         /* end is marked with double '\0' */
401         *++env = '\0';
402
403         return 0;
404 }
405
406 /*
407  * Deletes or sets environment variables. Returns -1 and sets errno error codes:
408  * 0      - OK
409  * EINVAL - need at least 1 argument
410  * EROFS  - certain variables ("ethaddr", "serial#") cannot be
411  *          modified or deleted
412  *
413  */
414 int fw_setenv(int argc, char *argv[])
415 {
416         int i;
417         size_t len;
418         char *name;
419         char *value = NULL;
420
421         if (argc < 2) {
422                 errno = EINVAL;
423                 return -1;
424         }
425
426         if (fw_env_open()) {
427                 fprintf(stderr, "Error: environment not initialized\n");
428                 return -1;
429         }
430
431         name = argv[1];
432
433         if (env_flags_validate_env_set_params(argc, argv) < 0)
434                 return 1;
435
436         len = 0;
437         for (i = 2; i < argc; ++i) {
438                 char *val = argv[i];
439                 size_t val_len = strlen(val);
440
441                 if (value)
442                         value[len - 1] = ' ';
443                 value = realloc(value, len + val_len + 1);
444                 if (!value) {
445                         fprintf(stderr,
446                                 "Cannot malloc %zu bytes: %s\n",
447                                 len, strerror(errno));
448                         return -1;
449                 }
450
451                 memcpy(value + len, val, val_len);
452                 len += val_len;
453                 value[len++] = '\0';
454         }
455
456         fw_env_write(name, value);
457
458         free(value);
459
460         return fw_env_close();
461 }
462
463 /*
464  * Parse  a file  and configure the u-boot variables.
465  * The script file has a very simple format, as follows:
466  *
467  * Each line has a couple with name, value:
468  * <white spaces>variable_name<white spaces>variable_value
469  *
470  * Both variable_name and variable_value are interpreted as strings.
471  * Any character after <white spaces> and before ending \r\n is interpreted
472  * as variable's value (no comment allowed on these lines !)
473  *
474  * Comments are allowed if the first character in the line is #
475  *
476  * Returns -1 and sets errno error codes:
477  * 0      - OK
478  * -1     - Error
479  */
480 int fw_parse_script(char *fname)
481 {
482         FILE *fp;
483         char dump[1024];        /* Maximum line length in the file */
484         char *name;
485         char *val;
486         int lineno = 0;
487         int len;
488         int ret = 0;
489
490         if (fw_env_open()) {
491                 fprintf(stderr, "Error: environment not initialized\n");
492                 return -1;
493         }
494
495         if (strcmp(fname, "-") == 0)
496                 fp = stdin;
497         else {
498                 fp = fopen(fname, "r");
499                 if (fp == NULL) {
500                         fprintf(stderr, "I cannot open %s for reading\n",
501                                  fname);
502                         return -1;
503                 }
504         }
505
506         while (fgets(dump, sizeof(dump), fp)) {
507                 lineno++;
508                 len = strlen(dump);
509
510                 /*
511                  * Read a whole line from the file. If the line is too long
512                  * or is not terminated, reports an error and exit.
513                  */
514                 if (dump[len - 1] != '\n') {
515                         fprintf(stderr,
516                         "Line %d not corrected terminated or too long\n",
517                                 lineno);
518                         ret = -1;
519                         break;
520                 }
521
522                 /* Drop ending line feed / carriage return */
523                 while (len > 0 && (dump[len - 1] == '\n' ||
524                                 dump[len - 1] == '\r')) {
525                         dump[len - 1] = '\0';
526                         len--;
527                 }
528
529                 /* Skip comment or empty lines */
530                 if ((len == 0) || dump[0] == '#')
531                         continue;
532
533                 /*
534                  * Search for variable's name,
535                  * remove leading whitespaces
536                  */
537                 name = fw_string_blank(dump, 1);
538                 if (!name)
539                         continue;
540
541                 /* The first white space is the end of variable name */
542                 val = fw_string_blank(name, 0);
543                 len = strlen(name);
544                 if (val) {
545                         *val++ = '\0';
546                         if ((val - name) < len)
547                                 val = fw_string_blank(val, 1);
548                         else
549                                 val = NULL;
550                 }
551
552 #ifdef DEBUG
553                 fprintf(stderr, "Setting %s : %s\n",
554                         name, val ? val : " removed");
555 #endif
556
557                 if (env_flags_validate_type(name, val) < 0) {
558                         ret = -1;
559                         break;
560                 }
561
562                 /*
563                  * If there is an error setting a variable,
564                  * try to save the environment and returns an error
565                  */
566                 if (fw_env_write(name, val)) {
567                         fprintf(stderr,
568                         "fw_env_write returns with error : %s\n",
569                                 strerror(errno));
570                         ret = -1;
571                         break;
572                 }
573
574         }
575
576         /* Close file if not stdin */
577         if (strcmp(fname, "-") != 0)
578                 fclose(fp);
579
580         ret |= fw_env_close();
581
582         return ret;
583
584 }
585
586 /*
587  * Test for bad block on NAND, just returns 0 on NOR, on NAND:
588  * 0    - block is good
589  * > 0  - block is bad
590  * < 0  - failed to test
591  */
592 static int flash_bad_block (int fd, uint8_t mtd_type, loff_t *blockstart)
593 {
594         if (mtd_type == MTD_NANDFLASH) {
595                 int badblock = ioctl (fd, MEMGETBADBLOCK, blockstart);
596
597                 if (badblock < 0) {
598                         perror ("Cannot read bad block mark");
599                         return badblock;
600                 }
601
602                 if (badblock) {
603 #ifdef DEBUG
604                         fprintf (stderr, "Bad block at 0x%llx, "
605                                  "skipping\n", *blockstart);
606 #endif
607                         return badblock;
608                 }
609         }
610
611         return 0;
612 }
613
614 /*
615  * Read data from flash at an offset into a provided buffer. On NAND it skips
616  * bad blocks but makes sure it stays within ENVSECTORS (dev) starting from
617  * the DEVOFFSET (dev) block. On NOR the loop is only run once.
618  */
619 static int flash_read_buf (int dev, int fd, void *buf, size_t count,
620                            off_t offset, uint8_t mtd_type)
621 {
622         size_t blocklen;        /* erase / write length - one block on NAND,
623                                    0 on NOR */
624         size_t processed = 0;   /* progress counter */
625         size_t readlen = count; /* current read length */
626         off_t top_of_range;     /* end of the last block we may use */
627         off_t block_seek;       /* offset inside the current block to the start
628                                    of the data */
629         loff_t blockstart;      /* running start of the current block -
630                                    MEMGETBADBLOCK needs 64 bits */
631         int rc;
632
633         blockstart = (offset / DEVESIZE (dev)) * DEVESIZE (dev);
634
635         /* Offset inside a block */
636         block_seek = offset - blockstart;
637
638         if (mtd_type == MTD_NANDFLASH) {
639                 /*
640                  * NAND: calculate which blocks we are reading. We have
641                  * to read one block at a time to skip bad blocks.
642                  */
643                 blocklen = DEVESIZE (dev);
644
645                 /*
646                  * To calculate the top of the range, we have to use the
647                  * global DEVOFFSET (dev), which can be different from offset
648                  */
649                 top_of_range = ((DEVOFFSET(dev) / blocklen) +
650                                 ENVSECTORS (dev)) * blocklen;
651
652                 /* Limit to one block for the first read */
653                 if (readlen > blocklen - block_seek)
654                         readlen = blocklen - block_seek;
655         } else {
656                 blocklen = 0;
657                 top_of_range = offset + count;
658         }
659
660         /* This only runs once on NOR flash */
661         while (processed < count) {
662                 rc = flash_bad_block (fd, mtd_type, &blockstart);
663                 if (rc < 0)             /* block test failed */
664                         return -1;
665
666                 if (blockstart + block_seek + readlen > top_of_range) {
667                         /* End of range is reached */
668                         fprintf (stderr,
669                                  "Too few good blocks within range\n");
670                         return -1;
671                 }
672
673                 if (rc) {               /* block is bad */
674                         blockstart += blocklen;
675                         continue;
676                 }
677
678                 /*
679                  * If a block is bad, we retry in the next block at the same
680                  * offset - see common/env_nand.c::writeenv()
681                  */
682                 lseek (fd, blockstart + block_seek, SEEK_SET);
683
684                 rc = read (fd, buf + processed, readlen);
685                 if (rc != readlen) {
686                         fprintf (stderr, "Read error on %s: %s\n",
687                                  DEVNAME (dev), strerror (errno));
688                         return -1;
689                 }
690 #ifdef DEBUG
691                 fprintf(stderr, "Read 0x%x bytes at 0x%llx on %s\n",
692                          rc, blockstart + block_seek, DEVNAME(dev));
693 #endif
694                 processed += readlen;
695                 readlen = min (blocklen, count - processed);
696                 block_seek = 0;
697                 blockstart += blocklen;
698         }
699
700         return processed;
701 }
702
703 /*
704  * Write count bytes at offset, but stay within ENVSECTORS (dev) sectors of
705  * DEVOFFSET (dev). Similar to the read case above, on NOR and dataflash we
706  * erase and write the whole data at once.
707  */
708 static int flash_write_buf (int dev, int fd, void *buf, size_t count,
709                             off_t offset, uint8_t mtd_type)
710 {
711         void *data;
712         struct erase_info_user erase;
713         size_t blocklen;        /* length of NAND block / NOR erase sector */
714         size_t erase_len;       /* whole area that can be erased - may include
715                                    bad blocks */
716         size_t erasesize;       /* erase / write length - one block on NAND,
717                                    whole area on NOR */
718         size_t processed = 0;   /* progress counter */
719         size_t write_total;     /* total size to actually write - excluding
720                                    bad blocks */
721         off_t erase_offset;     /* offset to the first erase block (aligned)
722                                    below offset */
723         off_t block_seek;       /* offset inside the erase block to the start
724                                    of the data */
725         off_t top_of_range;     /* end of the last block we may use */
726         loff_t blockstart;      /* running start of the current block -
727                                    MEMGETBADBLOCK needs 64 bits */
728         int rc;
729
730         /*
731          * For mtd devices only offset and size of the environment do matter
732          */
733         if (mtd_type == MTD_ABSENT) {
734                 blocklen = count;
735                 top_of_range = offset + count;
736                 erase_len = blocklen;
737                 blockstart = offset;
738                 block_seek = 0;
739                 write_total = blocklen;
740         } else {
741                 blocklen = DEVESIZE(dev);
742
743                 top_of_range = ((DEVOFFSET(dev) / blocklen) +
744                                         ENVSECTORS(dev)) * blocklen;
745
746                 erase_offset = (offset / blocklen) * blocklen;
747
748                 /* Maximum area we may use */
749                 erase_len = top_of_range - erase_offset;
750
751                 blockstart = erase_offset;
752                 /* Offset inside a block */
753                 block_seek = offset - erase_offset;
754
755                 /*
756                  * Data size we actually write: from the start of the block
757                  * to the start of the data, then count bytes of data, and
758                  * to the end of the block
759                  */
760                 write_total = ((block_seek + count + blocklen - 1) /
761                                                         blocklen) * blocklen;
762         }
763
764         /*
765          * Support data anywhere within erase sectors: read out the complete
766          * area to be erased, replace the environment image, write the whole
767          * block back again.
768          */
769         if (write_total > count) {
770                 data = malloc (erase_len);
771                 if (!data) {
772                         fprintf (stderr,
773                                  "Cannot malloc %zu bytes: %s\n",
774                                  erase_len, strerror (errno));
775                         return -1;
776                 }
777
778                 rc = flash_read_buf (dev, fd, data, write_total, erase_offset,
779                                      mtd_type);
780                 if (write_total != rc)
781                         return -1;
782
783 #ifdef DEBUG
784                 fprintf(stderr, "Preserving data ");
785                 if (block_seek != 0)
786                         fprintf(stderr, "0x%x - 0x%lx", 0, block_seek - 1);
787                 if (block_seek + count != write_total) {
788                         if (block_seek != 0)
789                                 fprintf(stderr, " and ");
790                         fprintf(stderr, "0x%lx - 0x%x",
791                                 block_seek + count, write_total - 1);
792                 }
793                 fprintf(stderr, "\n");
794 #endif
795                 /* Overwrite the old environment */
796                 memcpy (data + block_seek, buf, count);
797         } else {
798                 /*
799                  * We get here, iff offset is block-aligned and count is a
800                  * multiple of blocklen - see write_total calculation above
801                  */
802                 data = buf;
803         }
804
805         if (mtd_type == MTD_NANDFLASH) {
806                 /*
807                  * NAND: calculate which blocks we are writing. We have
808                  * to write one block at a time to skip bad blocks.
809                  */
810                 erasesize = blocklen;
811         } else {
812                 erasesize = erase_len;
813         }
814
815         erase.length = erasesize;
816
817         /* This only runs once on NOR flash and SPI-dataflash */
818         while (processed < write_total) {
819                 rc = flash_bad_block (fd, mtd_type, &blockstart);
820                 if (rc < 0)             /* block test failed */
821                         return rc;
822
823                 if (blockstart + erasesize > top_of_range) {
824                         fprintf (stderr, "End of range reached, aborting\n");
825                         return -1;
826                 }
827
828                 if (rc) {               /* block is bad */
829                         blockstart += blocklen;
830                         continue;
831                 }
832
833                 if (mtd_type != MTD_ABSENT) {
834                         erase.start = blockstart;
835                         ioctl(fd, MEMUNLOCK, &erase);
836                         /* These do not need an explicit erase cycle */
837                         if (mtd_type != MTD_DATAFLASH)
838                                 if (ioctl(fd, MEMERASE, &erase) != 0) {
839                                         fprintf(stderr,
840                                                 "MTD erase error on %s: %s\n",
841                                                 DEVNAME(dev), strerror(errno));
842                                         return -1;
843                                 }
844                 }
845
846                 if (lseek (fd, blockstart, SEEK_SET) == -1) {
847                         fprintf (stderr,
848                                  "Seek error on %s: %s\n",
849                                  DEVNAME (dev), strerror (errno));
850                         return -1;
851                 }
852
853 #ifdef DEBUG
854                 fprintf(stderr, "Write 0x%x bytes at 0x%llx\n", erasesize,
855                         blockstart);
856 #endif
857                 if (write (fd, data + processed, erasesize) != erasesize) {
858                         fprintf (stderr, "Write error on %s: %s\n",
859                                  DEVNAME (dev), strerror (errno));
860                         return -1;
861                 }
862
863                 if (mtd_type != MTD_ABSENT)
864                         ioctl(fd, MEMLOCK, &erase);
865
866                 processed  += blocklen;
867                 block_seek = 0;
868                 blockstart += blocklen;
869         }
870
871         if (write_total > count)
872                 free (data);
873
874         return processed;
875 }
876
877 /*
878  * Set obsolete flag at offset - NOR flash only
879  */
880 static int flash_flag_obsolete (int dev, int fd, off_t offset)
881 {
882         int rc;
883         struct erase_info_user erase;
884
885         erase.start  = DEVOFFSET (dev);
886         erase.length = DEVESIZE (dev);
887         /* This relies on the fact, that obsolete_flag == 0 */
888         rc = lseek (fd, offset, SEEK_SET);
889         if (rc < 0) {
890                 fprintf (stderr, "Cannot seek to set the flag on %s \n",
891                          DEVNAME (dev));
892                 return rc;
893         }
894         ioctl (fd, MEMUNLOCK, &erase);
895         rc = write (fd, &obsolete_flag, sizeof (obsolete_flag));
896         ioctl (fd, MEMLOCK, &erase);
897         if (rc < 0)
898                 perror ("Could not set obsolete flag");
899
900         return rc;
901 }
902
903 static int flash_write (int fd_current, int fd_target, int dev_target)
904 {
905         int rc;
906
907         switch (environment.flag_scheme) {
908         case FLAG_NONE:
909                 break;
910         case FLAG_INCREMENTAL:
911                 (*environment.flags)++;
912                 break;
913         case FLAG_BOOLEAN:
914                 *environment.flags = active_flag;
915                 break;
916         default:
917                 fprintf (stderr, "Unimplemented flash scheme %u \n",
918                          environment.flag_scheme);
919                 return -1;
920         }
921
922 #ifdef DEBUG
923         fprintf(stderr, "Writing new environment at 0x%lx on %s\n",
924                 DEVOFFSET (dev_target), DEVNAME (dev_target));
925 #endif
926         rc = flash_write_buf(dev_target, fd_target, environment.image,
927                               CUR_ENVSIZE, DEVOFFSET(dev_target),
928                               DEVTYPE(dev_target));
929         if (rc < 0)
930                 return rc;
931
932         if (environment.flag_scheme == FLAG_BOOLEAN) {
933                 /* Have to set obsolete flag */
934                 off_t offset = DEVOFFSET (dev_current) +
935                         offsetof (struct env_image_redundant, flags);
936 #ifdef DEBUG
937                 fprintf(stderr,
938                         "Setting obsolete flag in environment at 0x%lx on %s\n",
939                         DEVOFFSET (dev_current), DEVNAME (dev_current));
940 #endif
941                 flash_flag_obsolete (dev_current, fd_current, offset);
942         }
943
944         return 0;
945 }
946
947 static int flash_read (int fd)
948 {
949         struct mtd_info_user mtdinfo;
950         struct stat st;
951         int rc;
952
953         rc = fstat(fd, &st);
954         if (rc < 0) {
955                 fprintf(stderr, "Cannot stat the file %s\n",
956                         DEVNAME(dev_current));
957                 return -1;
958         }
959
960         if (S_ISCHR(st.st_mode)) {
961                 rc = ioctl(fd, MEMGETINFO, &mtdinfo);
962                 if (rc < 0) {
963                         fprintf(stderr, "Cannot get MTD information for %s\n",
964                                 DEVNAME(dev_current));
965                         return -1;
966                 }
967                 if (mtdinfo.type != MTD_NORFLASH &&
968                     mtdinfo.type != MTD_NANDFLASH &&
969                     mtdinfo.type != MTD_DATAFLASH &&
970                     mtdinfo.type != MTD_UBIVOLUME) {
971                         fprintf (stderr, "Unsupported flash type %u on %s\n",
972                                  mtdinfo.type, DEVNAME(dev_current));
973                         return -1;
974                 }
975         } else {
976                 memset(&mtdinfo, 0, sizeof(mtdinfo));
977                 mtdinfo.type = MTD_ABSENT;
978         }
979
980         DEVTYPE(dev_current) = mtdinfo.type;
981
982         rc = flash_read_buf(dev_current, fd, environment.image, CUR_ENVSIZE,
983                              DEVOFFSET (dev_current), mtdinfo.type);
984
985         return (rc != CUR_ENVSIZE) ? -1 : 0;
986 }
987
988 static int flash_io (int mode)
989 {
990         int fd_current, fd_target, rc, dev_target;
991
992         /* dev_current: fd_current, erase_current */
993         fd_current = open (DEVNAME (dev_current), mode);
994         if (fd_current < 0) {
995                 fprintf (stderr,
996                          "Can't open %s: %s\n",
997                          DEVNAME (dev_current), strerror (errno));
998                 return -1;
999         }
1000
1001         if (mode == O_RDWR) {
1002                 if (HaveRedundEnv) {
1003                         /* switch to next partition for writing */
1004                         dev_target = !dev_current;
1005                         /* dev_target: fd_target, erase_target */
1006                         fd_target = open (DEVNAME (dev_target), mode);
1007                         if (fd_target < 0) {
1008                                 fprintf (stderr,
1009                                          "Can't open %s: %s\n",
1010                                          DEVNAME (dev_target),
1011                                          strerror (errno));
1012                                 rc = -1;
1013                                 goto exit;
1014                         }
1015                 } else {
1016                         dev_target = dev_current;
1017                         fd_target = fd_current;
1018                 }
1019
1020                 rc = flash_write (fd_current, fd_target, dev_target);
1021
1022                 if (HaveRedundEnv) {
1023                         if (close (fd_target)) {
1024                                 fprintf (stderr,
1025                                         "I/O error on %s: %s\n",
1026                                         DEVNAME (dev_target),
1027                                         strerror (errno));
1028                                 rc = -1;
1029                         }
1030                 }
1031         } else {
1032                 rc = flash_read (fd_current);
1033         }
1034
1035 exit:
1036         if (close (fd_current)) {
1037                 fprintf (stderr,
1038                          "I/O error on %s: %s\n",
1039                          DEVNAME (dev_current), strerror (errno));
1040                 return -1;
1041         }
1042
1043         return rc;
1044 }
1045
1046 /*
1047  * s1 is either a simple 'name', or a 'name=value' pair.
1048  * s2 is a 'name=value' pair.
1049  * If the names match, return the value of s2, else NULL.
1050  */
1051
1052 static char *envmatch (char * s1, char * s2)
1053 {
1054         if (s1 == NULL || s2 == NULL)
1055                 return NULL;
1056
1057         while (*s1 == *s2++)
1058                 if (*s1++ == '=')
1059                         return s2;
1060         if (*s1 == '\0' && *(s2 - 1) == '=')
1061                 return s2;
1062         return NULL;
1063 }
1064
1065 /*
1066  * Prevent confusion if running from erased flash memory
1067  */
1068 int fw_env_open(void)
1069 {
1070         int crc0, crc0_ok;
1071         unsigned char flag0;
1072         void *addr0;
1073
1074         int crc1, crc1_ok;
1075         unsigned char flag1;
1076         void *addr1;
1077
1078         struct env_image_single *single;
1079         struct env_image_redundant *redundant;
1080
1081         if (parse_config ())            /* should fill envdevices */
1082                 return -1;
1083
1084         addr0 = calloc(1, CUR_ENVSIZE);
1085         if (addr0 == NULL) {
1086                 fprintf(stderr,
1087                         "Not enough memory for environment (%ld bytes)\n",
1088                         CUR_ENVSIZE);
1089                 return -1;
1090         }
1091
1092         /* read environment from FLASH to local buffer */
1093         environment.image = addr0;
1094
1095         if (HaveRedundEnv) {
1096                 redundant = addr0;
1097                 environment.crc         = &redundant->crc;
1098                 environment.flags       = &redundant->flags;
1099                 environment.data        = redundant->data;
1100         } else {
1101                 single = addr0;
1102                 environment.crc         = &single->crc;
1103                 environment.flags       = NULL;
1104                 environment.data        = single->data;
1105         }
1106
1107         dev_current = 0;
1108         if (flash_io (O_RDONLY))
1109                 return -1;
1110
1111         crc0 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE);
1112         crc0_ok = (crc0 == *environment.crc);
1113         if (!HaveRedundEnv) {
1114                 if (!crc0_ok) {
1115                         fprintf (stderr,
1116                                 "Warning: Bad CRC, using default environment\n");
1117                         memcpy(environment.data, default_environment, sizeof default_environment);
1118                 }
1119         } else {
1120                 flag0 = *environment.flags;
1121
1122                 dev_current = 1;
1123                 addr1 = calloc(1, CUR_ENVSIZE);
1124                 if (addr1 == NULL) {
1125                         fprintf(stderr,
1126                                 "Not enough memory for environment (%ld bytes)\n",
1127                                 CUR_ENVSIZE);
1128                         return -1;
1129                 }
1130                 redundant = addr1;
1131
1132                 /*
1133                  * have to set environment.image for flash_read(), careful -
1134                  * other pointers in environment still point inside addr0
1135                  */
1136                 environment.image = addr1;
1137                 if (flash_io (O_RDONLY))
1138                         return -1;
1139
1140                 /* Check flag scheme compatibility */
1141                 if (DEVTYPE(dev_current) == MTD_NORFLASH &&
1142                     DEVTYPE(!dev_current) == MTD_NORFLASH) {
1143                         environment.flag_scheme = FLAG_BOOLEAN;
1144                 } else if (DEVTYPE(dev_current) == MTD_NANDFLASH &&
1145                            DEVTYPE(!dev_current) == MTD_NANDFLASH) {
1146                         environment.flag_scheme = FLAG_INCREMENTAL;
1147                 } else if (DEVTYPE(dev_current) == MTD_DATAFLASH &&
1148                            DEVTYPE(!dev_current) == MTD_DATAFLASH) {
1149                         environment.flag_scheme = FLAG_BOOLEAN;
1150                 } else if (DEVTYPE(dev_current) == MTD_UBIVOLUME &&
1151                            DEVTYPE(!dev_current) == MTD_UBIVOLUME) {
1152                         environment.flag_scheme = FLAG_INCREMENTAL;
1153                 } else if (DEVTYPE(dev_current) == MTD_ABSENT &&
1154                            DEVTYPE(!dev_current) == MTD_ABSENT) {
1155                         environment.flag_scheme = FLAG_INCREMENTAL;
1156                 } else {
1157                         fprintf (stderr, "Incompatible flash types!\n");
1158                         return -1;
1159                 }
1160
1161                 crc1 = crc32 (0, (uint8_t *) redundant->data, ENV_SIZE);
1162                 crc1_ok = (crc1 == redundant->crc);
1163                 flag1 = redundant->flags;
1164
1165                 if (crc0_ok && !crc1_ok) {
1166                         dev_current = 0;
1167                 } else if (!crc0_ok && crc1_ok) {
1168                         dev_current = 1;
1169                 } else if (!crc0_ok && !crc1_ok) {
1170                         fprintf (stderr,
1171                                 "Warning: Bad CRC, using default environment\n");
1172                         memcpy (environment.data, default_environment,
1173                                 sizeof default_environment);
1174                         dev_current = 0;
1175                 } else {
1176                         switch (environment.flag_scheme) {
1177                         case FLAG_BOOLEAN:
1178                                 if (flag0 == active_flag &&
1179                                     flag1 == obsolete_flag) {
1180                                         dev_current = 0;
1181                                 } else if (flag0 == obsolete_flag &&
1182                                            flag1 == active_flag) {
1183                                         dev_current = 1;
1184                                 } else if (flag0 == flag1) {
1185                                         dev_current = 0;
1186                                 } else if (flag0 == 0xFF) {
1187                                         dev_current = 0;
1188                                 } else if (flag1 == 0xFF) {
1189                                         dev_current = 1;
1190                                 } else {
1191                                         dev_current = 0;
1192                                 }
1193                                 break;
1194                         case FLAG_INCREMENTAL:
1195                                 if (flag0 == 255 && flag1 == 0)
1196                                         dev_current = 1;
1197                                 else if ((flag1 == 255 && flag0 == 0) ||
1198                                          flag0 >= flag1)
1199                                         dev_current = 0;
1200                                 else /* flag1 > flag0 */
1201                                         dev_current = 1;
1202                                 break;
1203                         default:
1204                                 fprintf (stderr, "Unknown flag scheme %u \n",
1205                                          environment.flag_scheme);
1206                                 return -1;
1207                         }
1208                 }
1209
1210                 /*
1211                  * If we are reading, we don't need the flag and the CRC any
1212                  * more, if we are writing, we will re-calculate CRC and update
1213                  * flags before writing out
1214                  */
1215                 if (dev_current) {
1216                         environment.image       = addr1;
1217                         environment.crc         = &redundant->crc;
1218                         environment.flags       = &redundant->flags;
1219                         environment.data        = redundant->data;
1220                         free (addr0);
1221                 } else {
1222                         environment.image       = addr0;
1223                         /* Other pointers are already set */
1224                         free (addr1);
1225                 }
1226 #ifdef DEBUG
1227                 fprintf(stderr, "Selected env in %s\n", DEVNAME(dev_current));
1228 #endif
1229         }
1230         return 0;
1231 }
1232
1233
1234 static int parse_config ()
1235 {
1236         struct stat st;
1237
1238 #if defined(CONFIG_FILE)
1239         /* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */
1240         if (get_config (CONFIG_FILE)) {
1241                 fprintf (stderr,
1242                         "Cannot parse config file: %s\n", strerror (errno));
1243                 return -1;
1244         }
1245 #else
1246         strcpy (DEVNAME (0), DEVICE1_NAME);
1247         DEVOFFSET (0) = DEVICE1_OFFSET;
1248         ENVSIZE (0) = ENV1_SIZE;
1249         /* Default values are: erase-size=env-size, #sectors=1 */
1250         DEVESIZE (0) = ENVSIZE (0);
1251         ENVSECTORS (0) = 1;
1252 #ifdef DEVICE1_ESIZE
1253         DEVESIZE (0) = DEVICE1_ESIZE;
1254 #endif
1255 #ifdef DEVICE1_ENVSECTORS
1256         ENVSECTORS (0) = DEVICE1_ENVSECTORS;
1257 #endif
1258
1259 #ifdef HAVE_REDUND
1260         strcpy (DEVNAME (1), DEVICE2_NAME);
1261         DEVOFFSET (1) = DEVICE2_OFFSET;
1262         ENVSIZE (1) = ENV2_SIZE;
1263         /* Default values are: erase-size=env-size, #sectors=1 */
1264         DEVESIZE (1) = ENVSIZE (1);
1265         ENVSECTORS (1) = 1;
1266 #ifdef DEVICE2_ESIZE
1267         DEVESIZE (1) = DEVICE2_ESIZE;
1268 #endif
1269 #ifdef DEVICE2_ENVSECTORS
1270         ENVSECTORS (1) = DEVICE2_ENVSECTORS;
1271 #endif
1272         HaveRedundEnv = 1;
1273 #endif
1274 #endif
1275         if (stat (DEVNAME (0), &st)) {
1276                 fprintf (stderr,
1277                         "Cannot access MTD device %s: %s\n",
1278                         DEVNAME (0), strerror (errno));
1279                 return -1;
1280         }
1281
1282         if (HaveRedundEnv && stat (DEVNAME (1), &st)) {
1283                 fprintf (stderr,
1284                         "Cannot access MTD device %s: %s\n",
1285                         DEVNAME (1), strerror (errno));
1286                 return -1;
1287         }
1288         return 0;
1289 }
1290
1291 #if defined(CONFIG_FILE)
1292 static int get_config (char *fname)
1293 {
1294         FILE *fp;
1295         int i = 0;
1296         int rc;
1297         char dump[128];
1298
1299         fp = fopen (fname, "r");
1300         if (fp == NULL)
1301                 return -1;
1302
1303         while (i < 2 && fgets (dump, sizeof (dump), fp)) {
1304                 /* Skip incomplete conversions and comment strings */
1305                 if (dump[0] == '#')
1306                         continue;
1307
1308                 rc = sscanf (dump, "%s %lx %lx %lx %lx",
1309                              DEVNAME (i),
1310                              &DEVOFFSET (i),
1311                              &ENVSIZE (i),
1312                              &DEVESIZE (i),
1313                              &ENVSECTORS (i));
1314
1315                 if (rc < 3)
1316                         continue;
1317
1318                 if (rc < 4)
1319                         /* Assume the erase size is the same as the env-size */
1320                         DEVESIZE(i) = ENVSIZE(i);
1321
1322                 if (rc < 5)
1323                         /* Default - 1 sector */
1324                         ENVSECTORS (i) = 1;
1325
1326                 i++;
1327         }
1328         fclose (fp);
1329
1330         HaveRedundEnv = i - 1;
1331         if (!i) {                       /* No valid entries found */
1332                 errno = EINVAL;
1333                 return -1;
1334         } else
1335                 return 0;
1336 }
1337 #endif