2 * (C) Copyright 2000-2010
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6 * Guennadi Liakhovetski, DENX Software Engineering, lg@denx.de.
8 * See file CREDITS for list of people who contributed to this
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of
14 * the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
33 #include <sys/types.h>
34 #include <sys/ioctl.h>
40 # include <linux/mtd/mtd.h>
42 # define __user /* nothing */
43 # include <mtd/mtd-user.h>
50 #define WHITESPACE(c) ((c == '\t') || (c == ' '))
52 #define min(x, y) ({ \
53 typeof(x) _min1 = (x); \
54 typeof(y) _min2 = (y); \
55 (void) (&_min1 == &_min2); \
56 _min1 < _min2 ? _min1 : _min2; })
59 char devname[16]; /* Device name */
60 ulong devoff; /* Device offset */
61 ulong env_size; /* environment size */
62 ulong erase_size; /* device erase size */
63 ulong env_sectors; /* number of environment sectors */
64 uint8_t mtd_type; /* type of the MTD device */
67 static struct envdev_s envdevices[2] =
70 .mtd_type = MTD_ABSENT,
72 .mtd_type = MTD_ABSENT,
75 static int dev_current;
77 #define DEVNAME(i) envdevices[(i)].devname
78 #define DEVOFFSET(i) envdevices[(i)].devoff
79 #define ENVSIZE(i) envdevices[(i)].env_size
80 #define DEVESIZE(i) envdevices[(i)].erase_size
81 #define ENVSECTORS(i) envdevices[(i)].env_sectors
82 #define DEVTYPE(i) envdevices[(i)].mtd_type
84 #define CONFIG_ENV_SIZE ENVSIZE(dev_current)
86 #define ENV_SIZE getenvsize()
88 struct env_image_single {
89 uint32_t crc; /* CRC32 over data bytes */
93 struct env_image_redundant {
94 uint32_t crc; /* CRC32 over data bytes */
95 unsigned char flags; /* active or obsolete */
108 unsigned char *flags;
110 enum flag_scheme flag_scheme;
113 static struct environment environment = {
114 .flag_scheme = FLAG_NONE,
117 static int HaveRedundEnv = 0;
119 static unsigned char active_flag = 1;
120 /* obsolete_flag must be 0 to efficiently set it on NOR flash without erasing */
121 static unsigned char obsolete_flag = 0;
124 static char default_environment[] = {
125 #if defined(CONFIG_BOOTARGS)
126 "bootargs=" CONFIG_BOOTARGS "\0"
128 #if defined(CONFIG_BOOTCOMMAND)
129 "bootcmd=" CONFIG_BOOTCOMMAND "\0"
131 #if defined(CONFIG_RAMBOOTCOMMAND)
132 "ramboot=" CONFIG_RAMBOOTCOMMAND "\0"
134 #if defined(CONFIG_NFSBOOTCOMMAND)
135 "nfsboot=" CONFIG_NFSBOOTCOMMAND "\0"
137 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
138 "bootdelay=" __stringify(CONFIG_BOOTDELAY) "\0"
140 #if defined(CONFIG_BAUDRATE) && (CONFIG_BAUDRATE >= 0)
141 "baudrate=" __stringify(CONFIG_BAUDRATE) "\0"
143 #ifdef CONFIG_LOADS_ECHO
144 "loads_echo=" __stringify(CONFIG_LOADS_ECHO) "\0"
146 #ifdef CONFIG_ETHADDR
147 "ethaddr=" __stringify(CONFIG_ETHADDR) "\0"
149 #ifdef CONFIG_ETH1ADDR
150 "eth1addr=" __stringify(CONFIG_ETH1ADDR) "\0"
152 #ifdef CONFIG_ETH2ADDR
153 "eth2addr=" __stringify(CONFIG_ETH2ADDR) "\0"
155 #ifdef CONFIG_ETH3ADDR
156 "eth3addr=" __stringify(CONFIG_ETH3ADDR) "\0"
158 #ifdef CONFIG_ETH4ADDR
159 "eth4addr=" __stringify(CONFIG_ETH4ADDR) "\0"
161 #ifdef CONFIG_ETH5ADDR
162 "eth5addr=" __stringify(CONFIG_ETH5ADDR) "\0"
164 #ifdef CONFIG_ETHPRIME
165 "ethprime=" CONFIG_ETHPRIME "\0"
168 "ipaddr=" __stringify(CONFIG_IPADDR) "\0"
170 #ifdef CONFIG_SERVERIP
171 "serverip=" __stringify(CONFIG_SERVERIP) "\0"
173 #ifdef CONFIG_SYS_AUTOLOAD
174 "autoload=" CONFIG_SYS_AUTOLOAD "\0"
176 #ifdef CONFIG_ROOTPATH
177 "rootpath=" CONFIG_ROOTPATH "\0"
179 #ifdef CONFIG_GATEWAYIP
180 "gatewayip=" __stringify(CONFIG_GATEWAYIP) "\0"
182 #ifdef CONFIG_NETMASK
183 "netmask=" __stringify(CONFIG_NETMASK) "\0"
185 #ifdef CONFIG_HOSTNAME
186 "hostname=" __stringify(CONFIG_HOSTNAME) "\0"
188 #ifdef CONFIG_BOOTFILE
189 "bootfile=" CONFIG_BOOTFILE "\0"
191 #ifdef CONFIG_LOADADDR
192 "loadaddr=" __stringify(CONFIG_LOADADDR) "\0"
194 #ifdef CONFIG_PREBOOT
195 "preboot=" CONFIG_PREBOOT "\0"
197 #ifdef CONFIG_CLOCKS_IN_MHZ
198 "clocks_in_mhz=" "1" "\0"
200 #if defined(CONFIG_PCI_BOOTDELAY) && (CONFIG_PCI_BOOTDELAY > 0)
201 "pcidelay=" __stringify(CONFIG_PCI_BOOTDELAY) "\0"
203 #ifdef CONFIG_ENV_VARS_UBOOT_CONFIG
204 "arch=" CONFIG_SYS_ARCH "\0"
205 "cpu=" CONFIG_SYS_CPU "\0"
206 "board=" CONFIG_SYS_BOARD "\0"
207 #ifdef CONFIG_SYS_VENDOR
208 "vendor=" CONFIG_SYS_VENDOR "\0"
210 #ifdef CONFIG_SYS_SOC
211 "soc=" CONFIG_SYS_SOC "\0"
214 #ifdef CONFIG_EXTRA_ENV_SETTINGS
215 CONFIG_EXTRA_ENV_SETTINGS
217 "\0" /* Termimate struct environment data with 2 NULs */
220 static int flash_io (int mode);
221 static char *envmatch (char * s1, char * s2);
222 static int parse_config (void);
224 #if defined(CONFIG_FILE)
225 static int get_config (char *);
227 static inline ulong getenvsize (void)
229 ulong rc = CONFIG_ENV_SIZE - sizeof (long);
236 static char *fw_string_blank(char *s, int noblank)
241 for (i = 0; i < len; i++, s++) {
242 if ((noblank && !WHITESPACE(*s)) ||
243 (!noblank && WHITESPACE(*s)))
253 * Search the environment for a variable.
254 * Return the value, if found, or NULL, if not found.
256 char *fw_getenv (char *name)
263 for (env = environment.data; *env; env = nxt + 1) {
266 for (nxt = env; *nxt; ++nxt) {
267 if (nxt >= &environment.data[ENV_SIZE]) {
268 fprintf (stderr, "## Error: "
269 "environment not terminated\n");
273 val = envmatch (name, env);
282 * Print the current definition of one, or more, or all
283 * environment variables
285 int fw_printenv (int argc, char *argv[])
294 if (argc == 1) { /* Print all env variables */
295 for (env = environment.data; *env; env = nxt + 1) {
296 for (nxt = env; *nxt; ++nxt) {
297 if (nxt >= &environment.data[ENV_SIZE]) {
298 fprintf (stderr, "## Error: "
299 "environment not terminated\n");
304 printf ("%s\n", env);
309 if (strcmp (argv[1], "-n") == 0) {
314 fprintf (stderr, "## Error: "
315 "`-n' option requires exactly one argument\n");
322 for (i = 1; i < argc; ++i) { /* print single env variables */
323 char *name = argv[i];
326 for (env = environment.data; *env; env = nxt + 1) {
328 for (nxt = env; *nxt; ++nxt) {
329 if (nxt >= &environment.data[ENV_SIZE]) {
330 fprintf (stderr, "## Error: "
331 "environment not terminated\n");
335 val = envmatch (name, env);
338 fputs (name, stdout);
346 fprintf (stderr, "## Error: \"%s\" not defined\n", name);
354 int fw_env_close(void)
359 *environment.crc = crc32(0, (uint8_t *) environment.data, ENV_SIZE);
361 /* write environment back to flash */
362 if (flash_io(O_RDWR)) {
364 "Error: can't write fw_env to flash\n");
373 * Set/Clear a single variable in the environment.
374 * This is called in sequence to update the environment
375 * in RAM without updating the copy in flash after each set
377 int fw_env_write(char *name, char *value)
384 * search if variable with this name already exists
386 for (nxt = env = environment.data; *env; env = nxt + 1) {
387 for (nxt = env; *nxt; ++nxt) {
388 if (nxt >= &environment.data[ENV_SIZE]) {
389 fprintf(stderr, "## Error: "
390 "environment not terminated\n");
395 if ((oldval = envmatch (name, env)) != NULL)
400 * Delete any existing definition
403 #ifndef CONFIG_ENV_OVERWRITE
405 * Ethernet Address and serial# can be set only once
408 (strcmp(name, "serial#") == 0) ||
409 ((strcmp(name, "ethaddr") == 0)
410 #if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)
411 && (strcmp(oldval, __stringify(CONFIG_ETHADDR)) != 0)
412 #endif /* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */
414 fprintf (stderr, "Can't overwrite \"%s\"\n", name);
418 #endif /* CONFIG_ENV_OVERWRITE */
420 if (*++nxt == '\0') {
425 if ((*env == '\0') && (*nxt == '\0'))
434 if (!value || !strlen(value))
438 * Append new definition at the end
440 for (env = environment.data; *env || *(env + 1); ++env);
441 if (env > environment.data)
445 * "name" + "=" + "val" +"\0\0" > CONFIG_ENV_SIZE - (env-environment)
447 len = strlen (name) + 2;
448 /* add '=' for first arg, ' ' for all others */
449 len += strlen(value) + 1;
451 if (len > (&environment.data[ENV_SIZE] - env)) {
453 "Error: environment overflow, \"%s\" deleted\n",
458 while ((*env = *name++) != '\0')
461 while ((*++env = *value++) != '\0')
464 /* end is marked with double '\0' */
471 * Deletes or sets environment variables. Returns -1 and sets errno error codes:
473 * EINVAL - need at least 1 argument
474 * EROFS - certain variables ("ethaddr", "serial#") cannot be
475 * modified or deleted
478 int fw_setenv(int argc, char *argv[])
491 fprintf(stderr, "Error: environment not initialized\n");
497 len = strlen(name) + 2;
498 for (i = 2; i < argc; ++i)
499 len += strlen(argv[i]) + 1;
501 /* Allocate enough place to the data string */
502 for (i = 2; i < argc; ++i) {
505 value = (char *)malloc(len - strlen(name));
508 "Cannot malloc %zu bytes: %s\n",
509 len - strlen(name), strerror(errno));
512 memset(value, 0, len - strlen(name));
521 fw_env_write(name, value);
526 return fw_env_close();
530 * Parse a file and configure the u-boot variables.
531 * The script file has a very simple format, as follows:
533 * Each line has a couple with name, value:
534 * <white spaces>variable_name<white spaces>variable_value
536 * Both variable_name and variable_value are interpreted as strings.
537 * Any character after <white spaces> and before ending \r\n is interpreted
538 * as variable's value (no comment allowed on these lines !)
540 * Comments are allowed if the first character in the line is #
542 * Returns -1 and sets errno error codes:
546 int fw_parse_script(char *fname)
549 char dump[1024]; /* Maximum line length in the file */
557 fprintf(stderr, "Error: environment not initialized\n");
561 if (strcmp(fname, "-") == 0)
564 fp = fopen(fname, "r");
566 fprintf(stderr, "I cannot open %s for reading\n",
572 while (fgets(dump, sizeof(dump), fp)) {
577 * Read a whole line from the file. If the line is too long
578 * or is not terminated, reports an error and exit.
580 if (dump[len - 1] != '\n') {
582 "Line %d not corrected terminated or too long\n",
588 /* Drop ending line feed / carriage return */
589 while (len > 0 && (dump[len - 1] == '\n' ||
590 dump[len - 1] == '\r')) {
591 dump[len - 1] = '\0';
595 /* Skip comment or empty lines */
596 if ((len == 0) || dump[0] == '#')
600 * Search for variable's name,
601 * remove leading whitespaces
603 name = fw_string_blank(dump, 1);
607 /* The first white space is the end of variable name */
608 val = fw_string_blank(name, 0);
612 if ((val - name) < len)
613 val = fw_string_blank(val, 1);
619 fprintf(stderr, "Setting %s : %s\n",
620 name, val ? val : " removed");
624 * If there is an error setting a variable,
625 * try to save the environment and returns an error
627 if (fw_env_write(name, val)) {
629 "fw_env_write returns with error : %s\n",
637 /* Close file if not stdin */
638 if (strcmp(fname, "-") != 0)
641 ret |= fw_env_close();
648 * Test for bad block on NAND, just returns 0 on NOR, on NAND:
651 * < 0 - failed to test
653 static int flash_bad_block (int fd, uint8_t mtd_type, loff_t *blockstart)
655 if (mtd_type == MTD_NANDFLASH) {
656 int badblock = ioctl (fd, MEMGETBADBLOCK, blockstart);
659 perror ("Cannot read bad block mark");
665 fprintf (stderr, "Bad block at 0x%llx, "
666 "skipping\n", *blockstart);
676 * Read data from flash at an offset into a provided buffer. On NAND it skips
677 * bad blocks but makes sure it stays within ENVSECTORS (dev) starting from
678 * the DEVOFFSET (dev) block. On NOR the loop is only run once.
680 static int flash_read_buf (int dev, int fd, void *buf, size_t count,
681 off_t offset, uint8_t mtd_type)
683 size_t blocklen; /* erase / write length - one block on NAND,
685 size_t processed = 0; /* progress counter */
686 size_t readlen = count; /* current read length */
687 off_t top_of_range; /* end of the last block we may use */
688 off_t block_seek; /* offset inside the current block to the start
690 loff_t blockstart; /* running start of the current block -
691 MEMGETBADBLOCK needs 64 bits */
694 blockstart = (offset / DEVESIZE (dev)) * DEVESIZE (dev);
696 /* Offset inside a block */
697 block_seek = offset - blockstart;
699 if (mtd_type == MTD_NANDFLASH) {
701 * NAND: calculate which blocks we are reading. We have
702 * to read one block at a time to skip bad blocks.
704 blocklen = DEVESIZE (dev);
707 * To calculate the top of the range, we have to use the
708 * global DEVOFFSET (dev), which can be different from offset
710 top_of_range = ((DEVOFFSET(dev) / blocklen) +
711 ENVSECTORS (dev)) * blocklen;
713 /* Limit to one block for the first read */
714 if (readlen > blocklen - block_seek)
715 readlen = blocklen - block_seek;
718 top_of_range = offset + count;
721 /* This only runs once on NOR flash */
722 while (processed < count) {
723 rc = flash_bad_block (fd, mtd_type, &blockstart);
724 if (rc < 0) /* block test failed */
727 if (blockstart + block_seek + readlen > top_of_range) {
728 /* End of range is reached */
730 "Too few good blocks within range\n");
734 if (rc) { /* block is bad */
735 blockstart += blocklen;
740 * If a block is bad, we retry in the next block at the same
741 * offset - see common/env_nand.c::writeenv()
743 lseek (fd, blockstart + block_seek, SEEK_SET);
745 rc = read (fd, buf + processed, readlen);
747 fprintf (stderr, "Read error on %s: %s\n",
748 DEVNAME (dev), strerror (errno));
752 fprintf (stderr, "Read 0x%x bytes at 0x%llx\n",
753 rc, blockstart + block_seek);
755 processed += readlen;
756 readlen = min (blocklen, count - processed);
758 blockstart += blocklen;
765 * Write count bytes at offset, but stay within ENVSECTORS (dev) sectors of
766 * DEVOFFSET (dev). Similar to the read case above, on NOR and dataflash we
767 * erase and write the whole data at once.
769 static int flash_write_buf (int dev, int fd, void *buf, size_t count,
770 off_t offset, uint8_t mtd_type)
773 struct erase_info_user erase;
774 size_t blocklen; /* length of NAND block / NOR erase sector */
775 size_t erase_len; /* whole area that can be erased - may include
777 size_t erasesize; /* erase / write length - one block on NAND,
779 size_t processed = 0; /* progress counter */
780 size_t write_total; /* total size to actually write - excluding
782 off_t erase_offset; /* offset to the first erase block (aligned)
784 off_t block_seek; /* offset inside the erase block to the start
786 off_t top_of_range; /* end of the last block we may use */
787 loff_t blockstart; /* running start of the current block -
788 MEMGETBADBLOCK needs 64 bits */
791 blocklen = DEVESIZE (dev);
793 top_of_range = ((DEVOFFSET(dev) / blocklen) +
794 ENVSECTORS (dev)) * blocklen;
796 erase_offset = (offset / blocklen) * blocklen;
798 /* Maximum area we may use */
799 erase_len = top_of_range - erase_offset;
801 blockstart = erase_offset;
802 /* Offset inside a block */
803 block_seek = offset - erase_offset;
806 * Data size we actually have to write: from the start of the block
807 * to the start of the data, then count bytes of data, and to the
810 write_total = ((block_seek + count + blocklen - 1) /
811 blocklen) * blocklen;
814 * Support data anywhere within erase sectors: read out the complete
815 * area to be erased, replace the environment image, write the whole
818 if (write_total > count) {
819 data = malloc (erase_len);
822 "Cannot malloc %zu bytes: %s\n",
823 erase_len, strerror (errno));
827 rc = flash_read_buf (dev, fd, data, write_total, erase_offset,
829 if (write_total != rc)
832 /* Overwrite the old environment */
833 memcpy (data + block_seek, buf, count);
836 * We get here, iff offset is block-aligned and count is a
837 * multiple of blocklen - see write_total calculation above
842 if (mtd_type == MTD_NANDFLASH) {
844 * NAND: calculate which blocks we are writing. We have
845 * to write one block at a time to skip bad blocks.
847 erasesize = blocklen;
849 erasesize = erase_len;
852 erase.length = erasesize;
854 /* This only runs once on NOR flash and SPI-dataflash */
855 while (processed < write_total) {
856 rc = flash_bad_block (fd, mtd_type, &blockstart);
857 if (rc < 0) /* block test failed */
860 if (blockstart + erasesize > top_of_range) {
861 fprintf (stderr, "End of range reached, aborting\n");
865 if (rc) { /* block is bad */
866 blockstart += blocklen;
870 erase.start = blockstart;
871 ioctl (fd, MEMUNLOCK, &erase);
873 /* Dataflash does not need an explicit erase cycle */
874 if (mtd_type != MTD_DATAFLASH)
875 if (ioctl (fd, MEMERASE, &erase) != 0) {
876 fprintf (stderr, "MTD erase error on %s: %s\n",
882 if (lseek (fd, blockstart, SEEK_SET) == -1) {
884 "Seek error on %s: %s\n",
885 DEVNAME (dev), strerror (errno));
890 printf ("Write 0x%x bytes at 0x%llx\n", erasesize, blockstart);
892 if (write (fd, data + processed, erasesize) != erasesize) {
893 fprintf (stderr, "Write error on %s: %s\n",
894 DEVNAME (dev), strerror (errno));
898 ioctl (fd, MEMLOCK, &erase);
900 processed += blocklen;
902 blockstart += blocklen;
905 if (write_total > count)
912 * Set obsolete flag at offset - NOR flash only
914 static int flash_flag_obsolete (int dev, int fd, off_t offset)
917 struct erase_info_user erase;
919 erase.start = DEVOFFSET (dev);
920 erase.length = DEVESIZE (dev);
921 /* This relies on the fact, that obsolete_flag == 0 */
922 rc = lseek (fd, offset, SEEK_SET);
924 fprintf (stderr, "Cannot seek to set the flag on %s \n",
928 ioctl (fd, MEMUNLOCK, &erase);
929 rc = write (fd, &obsolete_flag, sizeof (obsolete_flag));
930 ioctl (fd, MEMLOCK, &erase);
932 perror ("Could not set obsolete flag");
937 static int flash_write (int fd_current, int fd_target, int dev_target)
941 switch (environment.flag_scheme) {
944 case FLAG_INCREMENTAL:
945 (*environment.flags)++;
948 *environment.flags = active_flag;
951 fprintf (stderr, "Unimplemented flash scheme %u \n",
952 environment.flag_scheme);
957 printf ("Writing new environment at 0x%lx on %s\n",
958 DEVOFFSET (dev_target), DEVNAME (dev_target));
960 rc = flash_write_buf (dev_target, fd_target, environment.image,
961 CONFIG_ENV_SIZE, DEVOFFSET (dev_target),
962 DEVTYPE(dev_target));
966 if (environment.flag_scheme == FLAG_BOOLEAN) {
967 /* Have to set obsolete flag */
968 off_t offset = DEVOFFSET (dev_current) +
969 offsetof (struct env_image_redundant, flags);
971 printf ("Setting obsolete flag in environment at 0x%lx on %s\n",
972 DEVOFFSET (dev_current), DEVNAME (dev_current));
974 flash_flag_obsolete (dev_current, fd_current, offset);
980 static int flash_read (int fd)
982 struct mtd_info_user mtdinfo;
985 rc = ioctl (fd, MEMGETINFO, &mtdinfo);
987 perror ("Cannot get MTD information");
991 if (mtdinfo.type != MTD_NORFLASH &&
992 mtdinfo.type != MTD_NANDFLASH &&
993 mtdinfo.type != MTD_DATAFLASH) {
994 fprintf (stderr, "Unsupported flash type %u\n", mtdinfo.type);
998 DEVTYPE(dev_current) = mtdinfo.type;
1000 rc = flash_read_buf (dev_current, fd, environment.image, CONFIG_ENV_SIZE,
1001 DEVOFFSET (dev_current), mtdinfo.type);
1003 return (rc != CONFIG_ENV_SIZE) ? -1 : 0;
1006 static int flash_io (int mode)
1008 int fd_current, fd_target, rc, dev_target;
1010 /* dev_current: fd_current, erase_current */
1011 fd_current = open (DEVNAME (dev_current), mode);
1012 if (fd_current < 0) {
1014 "Can't open %s: %s\n",
1015 DEVNAME (dev_current), strerror (errno));
1019 if (mode == O_RDWR) {
1020 if (HaveRedundEnv) {
1021 /* switch to next partition for writing */
1022 dev_target = !dev_current;
1023 /* dev_target: fd_target, erase_target */
1024 fd_target = open (DEVNAME (dev_target), mode);
1025 if (fd_target < 0) {
1027 "Can't open %s: %s\n",
1028 DEVNAME (dev_target),
1034 dev_target = dev_current;
1035 fd_target = fd_current;
1038 rc = flash_write (fd_current, fd_target, dev_target);
1040 if (HaveRedundEnv) {
1041 if (close (fd_target)) {
1043 "I/O error on %s: %s\n",
1044 DEVNAME (dev_target),
1050 rc = flash_read (fd_current);
1054 if (close (fd_current)) {
1056 "I/O error on %s: %s\n",
1057 DEVNAME (dev_current), strerror (errno));
1065 * s1 is either a simple 'name', or a 'name=value' pair.
1066 * s2 is a 'name=value' pair.
1067 * If the names match, return the value of s2, else NULL.
1070 static char *envmatch (char * s1, char * s2)
1073 while (*s1 == *s2++)
1076 if (*s1 == '\0' && *(s2 - 1) == '=')
1082 * Prevent confusion if running from erased flash memory
1084 int fw_env_open(void)
1087 unsigned char flag0;
1091 unsigned char flag1;
1094 struct env_image_single *single;
1095 struct env_image_redundant *redundant;
1097 if (parse_config ()) /* should fill envdevices */
1100 addr0 = calloc (1, CONFIG_ENV_SIZE);
1101 if (addr0 == NULL) {
1103 "Not enough memory for environment (%ld bytes)\n",
1108 /* read environment from FLASH to local buffer */
1109 environment.image = addr0;
1111 if (HaveRedundEnv) {
1113 environment.crc = &redundant->crc;
1114 environment.flags = &redundant->flags;
1115 environment.data = redundant->data;
1118 environment.crc = &single->crc;
1119 environment.flags = NULL;
1120 environment.data = single->data;
1124 if (flash_io (O_RDONLY))
1127 crc0 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE);
1128 crc0_ok = (crc0 == *environment.crc);
1129 if (!HaveRedundEnv) {
1132 "Warning: Bad CRC, using default environment\n");
1133 memcpy(environment.data, default_environment, sizeof default_environment);
1136 flag0 = *environment.flags;
1139 addr1 = calloc (1, CONFIG_ENV_SIZE);
1140 if (addr1 == NULL) {
1142 "Not enough memory for environment (%ld bytes)\n",
1149 * have to set environment.image for flash_read(), careful -
1150 * other pointers in environment still point inside addr0
1152 environment.image = addr1;
1153 if (flash_io (O_RDONLY))
1156 /* Check flag scheme compatibility */
1157 if (DEVTYPE(dev_current) == MTD_NORFLASH &&
1158 DEVTYPE(!dev_current) == MTD_NORFLASH) {
1159 environment.flag_scheme = FLAG_BOOLEAN;
1160 } else if (DEVTYPE(dev_current) == MTD_NANDFLASH &&
1161 DEVTYPE(!dev_current) == MTD_NANDFLASH) {
1162 environment.flag_scheme = FLAG_INCREMENTAL;
1163 } else if (DEVTYPE(dev_current) == MTD_DATAFLASH &&
1164 DEVTYPE(!dev_current) == MTD_DATAFLASH) {
1165 environment.flag_scheme = FLAG_BOOLEAN;
1167 fprintf (stderr, "Incompatible flash types!\n");
1171 crc1 = crc32 (0, (uint8_t *) redundant->data, ENV_SIZE);
1172 crc1_ok = (crc1 == redundant->crc);
1173 flag1 = redundant->flags;
1175 if (crc0_ok && !crc1_ok) {
1177 } else if (!crc0_ok && crc1_ok) {
1179 } else if (!crc0_ok && !crc1_ok) {
1181 "Warning: Bad CRC, using default environment\n");
1182 memcpy (environment.data, default_environment,
1183 sizeof default_environment);
1186 switch (environment.flag_scheme) {
1188 if (flag0 == active_flag &&
1189 flag1 == obsolete_flag) {
1191 } else if (flag0 == obsolete_flag &&
1192 flag1 == active_flag) {
1194 } else if (flag0 == flag1) {
1196 } else if (flag0 == 0xFF) {
1198 } else if (flag1 == 0xFF) {
1204 case FLAG_INCREMENTAL:
1205 if (flag0 == 255 && flag1 == 0)
1207 else if ((flag1 == 255 && flag0 == 0) ||
1210 else /* flag1 > flag0 */
1214 fprintf (stderr, "Unknown flag scheme %u \n",
1215 environment.flag_scheme);
1221 * If we are reading, we don't need the flag and the CRC any
1222 * more, if we are writing, we will re-calculate CRC and update
1223 * flags before writing out
1226 environment.image = addr1;
1227 environment.crc = &redundant->crc;
1228 environment.flags = &redundant->flags;
1229 environment.data = redundant->data;
1232 environment.image = addr0;
1233 /* Other pointers are already set */
1241 static int parse_config ()
1245 #if defined(CONFIG_FILE)
1246 /* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */
1247 if (get_config (CONFIG_FILE)) {
1249 "Cannot parse config file: %s\n", strerror (errno));
1253 strcpy (DEVNAME (0), DEVICE1_NAME);
1254 DEVOFFSET (0) = DEVICE1_OFFSET;
1255 ENVSIZE (0) = ENV1_SIZE;
1256 /* Default values are: erase-size=env-size, #sectors=1 */
1257 DEVESIZE (0) = ENVSIZE (0);
1259 #ifdef DEVICE1_ESIZE
1260 DEVESIZE (0) = DEVICE1_ESIZE;
1262 #ifdef DEVICE1_ENVSECTORS
1263 ENVSECTORS (0) = DEVICE1_ENVSECTORS;
1267 strcpy (DEVNAME (1), DEVICE2_NAME);
1268 DEVOFFSET (1) = DEVICE2_OFFSET;
1269 ENVSIZE (1) = ENV2_SIZE;
1270 /* Default values are: erase-size=env-size, #sectors=1 */
1271 DEVESIZE (1) = ENVSIZE (1);
1273 #ifdef DEVICE2_ESIZE
1274 DEVESIZE (1) = DEVICE2_ESIZE;
1276 #ifdef DEVICE2_ENVSECTORS
1277 ENVSECTORS (1) = DEVICE2_ENVSECTORS;
1282 if (stat (DEVNAME (0), &st)) {
1284 "Cannot access MTD device %s: %s\n",
1285 DEVNAME (0), strerror (errno));
1289 if (HaveRedundEnv && stat (DEVNAME (1), &st)) {
1291 "Cannot access MTD device %s: %s\n",
1292 DEVNAME (1), strerror (errno));
1298 #if defined(CONFIG_FILE)
1299 static int get_config (char *fname)
1306 fp = fopen (fname, "r");
1310 while (i < 2 && fgets (dump, sizeof (dump), fp)) {
1311 /* Skip incomplete conversions and comment strings */
1315 rc = sscanf (dump, "%s %lx %lx %lx %lx",
1326 /* Assume the erase size is the same as the env-size */
1327 DEVESIZE(i) = ENVSIZE(i);
1330 /* Default - 1 sector */
1337 HaveRedundEnv = i - 1;
1338 if (!i) { /* No valid entries found */