| /* |
| * (C) Copyright 2000-2008 |
| * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
| * |
| * (C) Copyright 2008 |
| * Guennadi Liakhovetski, DENX Software Engineering, lg@denx.de. |
| * |
| * See file CREDITS for list of people who contributed to this |
| * project. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License as |
| * published by the Free Software Foundation; either version 2 of |
| * the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, |
| * MA 02111-1307 USA |
| */ |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stddef.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <sys/ioctl.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| |
| #ifdef MTD_OLD |
| # include <stdint.h> |
| # include <linux/mtd/mtd.h> |
| #else |
| # define __user /* nothing */ |
| # include <mtd/mtd-user.h> |
| #endif |
| |
| #include "fw_env.h" |
| |
| #define CMD_GETENV "fw_printenv" |
| #define CMD_SETENV "fw_setenv" |
| |
| #define min(x, y) ({ \ |
| typeof(x) _min1 = (x); \ |
| typeof(y) _min2 = (y); \ |
| (void) (&_min1 == &_min2); \ |
| _min1 < _min2 ? _min1 : _min2; }) |
| |
| struct envdev_s { |
| char devname[16]; /* Device name */ |
| ulong devoff; /* Device offset */ |
| ulong env_size; /* environment size */ |
| ulong erase_size; /* device erase size */ |
| ulong env_sectors; /* number of environment sectors */ |
| uint8_t mtd_type; /* type of the MTD device */ |
| }; |
| |
| static struct envdev_s envdevices[2] = |
| { |
| { |
| .mtd_type = MTD_ABSENT, |
| }, { |
| .mtd_type = MTD_ABSENT, |
| }, |
| }; |
| static int dev_current; |
| |
| #define DEVNAME(i) envdevices[(i)].devname |
| #define DEVOFFSET(i) envdevices[(i)].devoff |
| #define ENVSIZE(i) envdevices[(i)].env_size |
| #define DEVESIZE(i) envdevices[(i)].erase_size |
| #define ENVSECTORS(i) envdevices[(i)].env_sectors |
| #define DEVTYPE(i) envdevices[(i)].mtd_type |
| |
| #define CONFIG_ENV_SIZE ENVSIZE(dev_current) |
| |
| #define ENV_SIZE getenvsize() |
| |
| struct env_image_single { |
| uint32_t crc; /* CRC32 over data bytes */ |
| char data[]; |
| }; |
| |
| struct env_image_redundant { |
| uint32_t crc; /* CRC32 over data bytes */ |
| unsigned char flags; /* active or obsolete */ |
| char data[]; |
| }; |
| |
| enum flag_scheme { |
| FLAG_NONE, |
| FLAG_BOOLEAN, |
| FLAG_INCREMENTAL, |
| }; |
| |
| struct environment { |
| void *image; |
| uint32_t *crc; |
| unsigned char *flags; |
| char *data; |
| enum flag_scheme flag_scheme; |
| }; |
| |
| static struct environment environment = { |
| .flag_scheme = FLAG_NONE, |
| }; |
| |
| static int HaveRedundEnv = 0; |
| |
| static unsigned char active_flag = 1; |
| /* obsolete_flag must be 0 to efficiently set it on NOR flash without erasing */ |
| static unsigned char obsolete_flag = 0; |
| |
| |
| #define XMK_STR(x) #x |
| #define MK_STR(x) XMK_STR(x) |
| |
| static char default_environment[] = { |
| #if defined(CONFIG_BOOTARGS) |
| "bootargs=" CONFIG_BOOTARGS "\0" |
| #endif |
| #if defined(CONFIG_BOOTCOMMAND) |
| "bootcmd=" CONFIG_BOOTCOMMAND "\0" |
| #endif |
| #if defined(CONFIG_RAMBOOTCOMMAND) |
| "ramboot=" CONFIG_RAMBOOTCOMMAND "\0" |
| #endif |
| #if defined(CONFIG_NFSBOOTCOMMAND) |
| "nfsboot=" CONFIG_NFSBOOTCOMMAND "\0" |
| #endif |
| #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0) |
| "bootdelay=" MK_STR (CONFIG_BOOTDELAY) "\0" |
| #endif |
| #if defined(CONFIG_BAUDRATE) && (CONFIG_BAUDRATE >= 0) |
| "baudrate=" MK_STR (CONFIG_BAUDRATE) "\0" |
| #endif |
| #ifdef CONFIG_LOADS_ECHO |
| "loads_echo=" MK_STR (CONFIG_LOADS_ECHO) "\0" |
| #endif |
| #ifdef CONFIG_ETHADDR |
| "ethaddr=" MK_STR (CONFIG_ETHADDR) "\0" |
| #endif |
| #ifdef CONFIG_ETH1ADDR |
| "eth1addr=" MK_STR (CONFIG_ETH1ADDR) "\0" |
| #endif |
| #ifdef CONFIG_ETH2ADDR |
| "eth2addr=" MK_STR (CONFIG_ETH2ADDR) "\0" |
| #endif |
| #ifdef CONFIG_ETH3ADDR |
| "eth3addr=" MK_STR (CONFIG_ETH3ADDR) "\0" |
| #endif |
| #ifdef CONFIG_ETH4ADDR |
| "eth4addr=" MK_STR (CONFIG_ETH4ADDR) "\0" |
| #endif |
| #ifdef CONFIG_ETH5ADDR |
| "eth5addr=" MK_STR (CONFIG_ETH5ADDR) "\0" |
| #endif |
| #ifdef CONFIG_ETHPRIME |
| "ethprime=" CONFIG_ETHPRIME "\0" |
| #endif |
| #ifdef CONFIG_IPADDR |
| "ipaddr=" MK_STR (CONFIG_IPADDR) "\0" |
| #endif |
| #ifdef CONFIG_SERVERIP |
| "serverip=" MK_STR (CONFIG_SERVERIP) "\0" |
| #endif |
| #ifdef CONFIG_SYS_AUTOLOAD |
| "autoload=" CONFIG_SYS_AUTOLOAD "\0" |
| #endif |
| #ifdef CONFIG_ROOTPATH |
| "rootpath=" MK_STR (CONFIG_ROOTPATH) "\0" |
| #endif |
| #ifdef CONFIG_GATEWAYIP |
| "gatewayip=" MK_STR (CONFIG_GATEWAYIP) "\0" |
| #endif |
| #ifdef CONFIG_NETMASK |
| "netmask=" MK_STR (CONFIG_NETMASK) "\0" |
| #endif |
| #ifdef CONFIG_HOSTNAME |
| "hostname=" MK_STR (CONFIG_HOSTNAME) "\0" |
| #endif |
| #ifdef CONFIG_BOOTFILE |
| "bootfile=" MK_STR (CONFIG_BOOTFILE) "\0" |
| #endif |
| #ifdef CONFIG_LOADADDR |
| "loadaddr=" MK_STR (CONFIG_LOADADDR) "\0" |
| #endif |
| #ifdef CONFIG_PREBOOT |
| "preboot=" CONFIG_PREBOOT "\0" |
| #endif |
| #ifdef CONFIG_CLOCKS_IN_MHZ |
| "clocks_in_mhz=" "1" "\0" |
| #endif |
| #if defined(CONFIG_PCI_BOOTDELAY) && (CONFIG_PCI_BOOTDELAY > 0) |
| "pcidelay=" MK_STR (CONFIG_PCI_BOOTDELAY) "\0" |
| #endif |
| #ifdef CONFIG_EXTRA_ENV_SETTINGS |
| CONFIG_EXTRA_ENV_SETTINGS |
| #endif |
| "\0" /* Termimate struct environment data with 2 NULs */ |
| }; |
| |
| static int flash_io (int mode); |
| static char *envmatch (char * s1, char * s2); |
| static int env_init (void); |
| static int parse_config (void); |
| |
| #if defined(CONFIG_FILE) |
| static int get_config (char *); |
| #endif |
| static inline ulong getenvsize (void) |
| { |
| ulong rc = CONFIG_ENV_SIZE - sizeof (long); |
| |
| if (HaveRedundEnv) |
| rc -= sizeof (char); |
| return rc; |
| } |
| |
| /* |
| * Search the environment for a variable. |
| * Return the value, if found, or NULL, if not found. |
| */ |
| char *fw_getenv (char *name) |
| { |
| char *env, *nxt; |
| |
| if (env_init ()) |
| return NULL; |
| |
| for (env = environment.data; *env; env = nxt + 1) { |
| char *val; |
| |
| for (nxt = env; *nxt; ++nxt) { |
| if (nxt >= &environment.data[ENV_SIZE]) { |
| fprintf (stderr, "## Error: " |
| "environment not terminated\n"); |
| return NULL; |
| } |
| } |
| val = envmatch (name, env); |
| if (!val) |
| continue; |
| return val; |
| } |
| return NULL; |
| } |
| |
| /* |
| * Print the current definition of one, or more, or all |
| * environment variables |
| */ |
| int fw_printenv (int argc, char *argv[]) |
| { |
| char *env, *nxt; |
| int i, n_flag; |
| int rc = 0; |
| |
| if (env_init ()) |
| return -1; |
| |
| if (argc == 1) { /* Print all env variables */ |
| for (env = environment.data; *env; env = nxt + 1) { |
| for (nxt = env; *nxt; ++nxt) { |
| if (nxt >= &environment.data[ENV_SIZE]) { |
| fprintf (stderr, "## Error: " |
| "environment not terminated\n"); |
| return -1; |
| } |
| } |
| |
| printf ("%s\n", env); |
| } |
| return 0; |
| } |
| |
| if (strcmp (argv[1], "-n") == 0) { |
| n_flag = 1; |
| ++argv; |
| --argc; |
| if (argc != 2) { |
| fprintf (stderr, "## Error: " |
| "`-n' option requires exactly one argument\n"); |
| return -1; |
| } |
| } else { |
| n_flag = 0; |
| } |
| |
| for (i = 1; i < argc; ++i) { /* print single env variables */ |
| char *name = argv[i]; |
| char *val = NULL; |
| |
| for (env = environment.data; *env; env = nxt + 1) { |
| |
| for (nxt = env; *nxt; ++nxt) { |
| if (nxt >= &environment.data[ENV_SIZE]) { |
| fprintf (stderr, "## Error: " |
| "environment not terminated\n"); |
| return -1; |
| } |
| } |
| val = envmatch (name, env); |
| if (val) { |
| if (!n_flag) { |
| fputs (name, stdout); |
| putc ('=', stdout); |
| } |
| puts (val); |
| break; |
| } |
| } |
| if (!val) { |
| fprintf (stderr, "## Error: \"%s\" not defined\n", name); |
| rc = -1; |
| } |
| } |
| |
| return rc; |
| } |
| |
| /* |
| * Deletes or sets environment variables. Returns -1 and sets errno error codes: |
| * 0 - OK |
| * EINVAL - need at least 1 argument |
| * EROFS - certain variables ("ethaddr", "serial#") cannot be |
| * modified or deleted |
| * |
| */ |
| int fw_setenv (int argc, char *argv[]) |
| { |
| int i, len; |
| char *env, *nxt; |
| char *oldval = NULL; |
| char *name; |
| |
| if (argc < 2) { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| if (env_init ()) |
| return -1; |
| |
| name = argv[1]; |
| |
| /* |
| * search if variable with this name already exists |
| */ |
| for (nxt = env = environment.data; *env; env = nxt + 1) { |
| for (nxt = env; *nxt; ++nxt) { |
| if (nxt >= &environment.data[ENV_SIZE]) { |
| fprintf (stderr, "## Error: " |
| "environment not terminated\n"); |
| errno = EINVAL; |
| return -1; |
| } |
| } |
| if ((oldval = envmatch (name, env)) != NULL) |
| break; |
| } |
| |
| /* |
| * Delete any existing definition |
| */ |
| if (oldval) { |
| /* |
| * Ethernet Address and serial# can be set only once |
| */ |
| if ((strcmp (name, "ethaddr") == 0) || |
| (strcmp (name, "serial#") == 0)) { |
| fprintf (stderr, "Can't overwrite \"%s\"\n", name); |
| errno = EROFS; |
| return -1; |
| } |
| |
| if (*++nxt == '\0') { |
| *env = '\0'; |
| } else { |
| for (;;) { |
| *env = *nxt++; |
| if ((*env == '\0') && (*nxt == '\0')) |
| break; |
| ++env; |
| } |
| } |
| *++env = '\0'; |
| } |
| |
| /* Delete only ? */ |
| if (argc < 3) |
| goto WRITE_FLASH; |
| |
| /* |
| * Append new definition at the end |
| */ |
| for (env = environment.data; *env || *(env + 1); ++env); |
| if (env > environment.data) |
| ++env; |
| /* |
| * Overflow when: |
| * "name" + "=" + "val" +"\0\0" > CONFIG_ENV_SIZE - (env-environment) |
| */ |
| len = strlen (name) + 2; |
| /* add '=' for first arg, ' ' for all others */ |
| for (i = 2; i < argc; ++i) { |
| len += strlen (argv[i]) + 1; |
| } |
| if (len > (&environment.data[ENV_SIZE] - env)) { |
| fprintf (stderr, |
| "Error: environment overflow, \"%s\" deleted\n", |
| name); |
| return -1; |
| } |
| while ((*env = *name++) != '\0') |
| env++; |
| for (i = 2; i < argc; ++i) { |
| char *val = argv[i]; |
| |
| *env = (i == 2) ? '=' : ' '; |
| while ((*++env = *val++) != '\0'); |
| } |
| |
| /* end is marked with double '\0' */ |
| *++env = '\0'; |
| |
| WRITE_FLASH: |
| |
| /* |
| * Update CRC |
| */ |
| *environment.crc = crc32 (0, (uint8_t *) environment.data, ENV_SIZE); |
| |
| /* write environment back to flash */ |
| if (flash_io (O_RDWR)) { |
| fprintf (stderr, "Error: can't write fw_env to flash\n"); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Test for bad block on NAND, just returns 0 on NOR, on NAND: |
| * 0 - block is good |
| * > 0 - block is bad |
| * < 0 - failed to test |
| */ |
| static int flash_bad_block (int fd, uint8_t mtd_type, loff_t *blockstart) |
| { |
| if (mtd_type == MTD_NANDFLASH) { |
| int badblock = ioctl (fd, MEMGETBADBLOCK, blockstart); |
| |
| if (badblock < 0) { |
| perror ("Cannot read bad block mark"); |
| return badblock; |
| } |
| |
| if (badblock) { |
| #ifdef DEBUG |
| fprintf (stderr, "Bad block at 0x%llx, " |
| "skipping\n", *blockstart); |
| #endif |
| return badblock; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Read data from flash at an offset into a provided buffer. On NAND it skips |
| * bad blocks but makes sure it stays within ENVSECTORS (dev) starting from |
| * the DEVOFFSET (dev) block. On NOR the loop is only run once. |
| */ |
| static int flash_read_buf (int dev, int fd, void *buf, size_t count, |
| off_t offset, uint8_t mtd_type) |
| { |
| size_t blocklen; /* erase / write length - one block on NAND, |
| 0 on NOR */ |
| size_t processed = 0; /* progress counter */ |
| size_t readlen = count; /* current read length */ |
| off_t top_of_range; /* end of the last block we may use */ |
| off_t block_seek; /* offset inside the current block to the start |
| of the data */ |
| loff_t blockstart; /* running start of the current block - |
| MEMGETBADBLOCK needs 64 bits */ |
| int rc; |
| |
| /* |
| * Start of the first block to be read, relies on the fact, that |
| * erase sector size is always a power of 2 |
| */ |
| blockstart = offset & ~(DEVESIZE (dev) - 1); |
| |
| /* Offset inside a block */ |
| block_seek = offset - blockstart; |
| |
| if (mtd_type == MTD_NANDFLASH) { |
| /* |
| * NAND: calculate which blocks we are reading. We have |
| * to read one block at a time to skip bad blocks. |
| */ |
| blocklen = DEVESIZE (dev); |
| |
| /* |
| * To calculate the top of the range, we have to use the |
| * global DEVOFFSET (dev), which can be different from offset |
| */ |
| top_of_range = (DEVOFFSET (dev) & ~(blocklen - 1)) + |
| ENVSECTORS (dev) * blocklen; |
| |
| /* Limit to one block for the first read */ |
| if (readlen > blocklen - block_seek) |
| readlen = blocklen - block_seek; |
| } else { |
| blocklen = 0; |
| top_of_range = offset + count; |
| } |
| |
| /* This only runs once on NOR flash */ |
| while (processed < count) { |
| rc = flash_bad_block (fd, mtd_type, &blockstart); |
| if (rc < 0) /* block test failed */ |
| return -1; |
| |
| if (blockstart + block_seek + readlen > top_of_range) { |
| /* End of range is reached */ |
| fprintf (stderr, |
| "Too few good blocks within range\n"); |
| return -1; |
| } |
| |
| if (rc) { /* block is bad */ |
| blockstart += blocklen; |
| continue; |
| } |
| |
| /* |
| * If a block is bad, we retry in the next block at the same |
| * offset - see common/env_nand.c::writeenv() |
| */ |
| lseek (fd, blockstart + block_seek, SEEK_SET); |
| |
| rc = read (fd, buf + processed, readlen); |
| if (rc != readlen) { |
| fprintf (stderr, "Read error on %s: %s\n", |
| DEVNAME (dev), strerror (errno)); |
| return -1; |
| } |
| #ifdef DEBUG |
| fprintf (stderr, "Read 0x%x bytes at 0x%llx\n", |
| rc, blockstart + block_seek); |
| #endif |
| processed += readlen; |
| readlen = min (blocklen, count - processed); |
| block_seek = 0; |
| blockstart += blocklen; |
| } |
| |
| return processed; |
| } |
| |
| /* |
| * Write count bytes at offset, but stay within ENVSETCORS (dev) sectors of |
| * DEVOFFSET (dev). Similar to the read case above, on NOR we erase and write |
| * the whole data at once. |
| */ |
| static int flash_write_buf (int dev, int fd, void *buf, size_t count, |
| off_t offset, uint8_t mtd_type) |
| { |
| void *data; |
| struct erase_info_user erase; |
| size_t blocklen; /* length of NAND block / NOR erase sector */ |
| size_t erase_len; /* whole area that can be erased - may include |
| bad blocks */ |
| size_t erasesize; /* erase / write length - one block on NAND, |
| whole area on NOR */ |
| size_t processed = 0; /* progress counter */ |
| size_t write_total; /* total size to actually write - excludinig |
| bad blocks */ |
| off_t erase_offset; /* offset to the first erase block (aligned) |
| below offset */ |
| off_t block_seek; /* offset inside the erase block to the start |
| of the data */ |
| off_t top_of_range; /* end of the last block we may use */ |
| loff_t blockstart; /* running start of the current block - |
| MEMGETBADBLOCK needs 64 bits */ |
| int rc; |
| |
| blocklen = DEVESIZE (dev); |
| |
| /* Erase sector size is always a power of 2 */ |
| top_of_range = (DEVOFFSET (dev) & ~(blocklen - 1)) + |
| ENVSECTORS (dev) * blocklen; |
| |
| erase_offset = offset & ~(blocklen - 1); |
| |
| /* Maximum area we may use */ |
| erase_len = top_of_range - erase_offset; |
| |
| blockstart = erase_offset; |
| /* Offset inside a block */ |
| block_seek = offset - erase_offset; |
| |
| /* |
| * Data size we actually have to write: from the start of the block |
| * to the start of the data, then count bytes of data, and to the |
| * end of the block |
| */ |
| write_total = (block_seek + count + blocklen - 1) & ~(blocklen - 1); |
| |
| /* |
| * Support data anywhere within erase sectors: read out the complete |
| * area to be erased, replace the environment image, write the whole |
| * block back again. |
| */ |
| if (write_total > count) { |
| data = malloc (erase_len); |
| if (!data) { |
| fprintf (stderr, |
| "Cannot malloc %u bytes: %s\n", |
| erase_len, strerror (errno)); |
| return -1; |
| } |
| |
| rc = flash_read_buf (dev, fd, data, write_total, erase_offset, |
| mtd_type); |
| if (write_total != rc) |
| return -1; |
| |
| /* Overwrite the old environment */ |
| memcpy (data + block_seek, buf, count); |
| } else { |
| /* |
| * We get here, iff offset is block-aligned and count is a |
| * multiple of blocklen - see write_total calculation above |
| */ |
| data = buf; |
| } |
| |
| if (mtd_type == MTD_NANDFLASH) { |
| /* |
| * NAND: calculate which blocks we are writing. We have |
| * to write one block at a time to skip bad blocks. |
| */ |
| erasesize = blocklen; |
| } else { |
| erasesize = erase_len; |
| } |
| |
| erase.length = erasesize; |
| |
| /* This only runs once on NOR flash */ |
| while (processed < write_total) { |
| rc = flash_bad_block (fd, mtd_type, &blockstart); |
| if (rc < 0) /* block test failed */ |
| return rc; |
| |
| if (blockstart + erasesize > top_of_range) { |
| fprintf (stderr, "End of range reached, aborting\n"); |
| return -1; |
| } |
| |
| if (rc) { /* block is bad */ |
| blockstart += blocklen; |
| continue; |
| } |
| |
| erase.start = blockstart; |
| ioctl (fd, MEMUNLOCK, &erase); |
| |
| if (ioctl (fd, MEMERASE, &erase) != 0) { |
| fprintf (stderr, "MTD erase error on %s: %s\n", |
| DEVNAME (dev), |
| strerror (errno)); |
| return -1; |
| } |
| |
| if (lseek (fd, blockstart, SEEK_SET) == -1) { |
| fprintf (stderr, |
| "Seek error on %s: %s\n", |
| DEVNAME (dev), strerror (errno)); |
| return -1; |
| } |
| |
| #ifdef DEBUG |
| printf ("Write 0x%x bytes at 0x%llx\n", erasesize, blockstart); |
| #endif |
| if (write (fd, data + processed, erasesize) != erasesize) { |
| fprintf (stderr, "Write error on %s: %s\n", |
| DEVNAME (dev), strerror (errno)); |
| return -1; |
| } |
| |
| ioctl (fd, MEMLOCK, &erase); |
| |
| processed += blocklen; |
| block_seek = 0; |
| blockstart += blocklen; |
| } |
| |
| if (write_total > count) |
| free (data); |
| |
| return processed; |
| } |
| |
| /* |
| * Set obsolete flag at offset - NOR flash only |
| */ |
| static int flash_flag_obsolete (int dev, int fd, off_t offset) |
| { |
| int rc; |
| |
| /* This relies on the fact, that obsolete_flag == 0 */ |
| rc = lseek (fd, offset, SEEK_SET); |
| if (rc < 0) { |
| fprintf (stderr, "Cannot seek to set the flag on %s \n", |
| DEVNAME (dev)); |
| return rc; |
| } |
| rc = write (fd, &obsolete_flag, sizeof (obsolete_flag)); |
| if (rc < 0) |
| perror ("Could not set obsolete flag"); |
| |
| return rc; |
| } |
| |
| static int flash_write (int fd_current, int fd_target, int dev_target) |
| { |
| int rc; |
| |
| switch (environment.flag_scheme) { |
| case FLAG_NONE: |
| break; |
| case FLAG_INCREMENTAL: |
| (*environment.flags)++; |
| break; |
| case FLAG_BOOLEAN: |
| *environment.flags = active_flag; |
| break; |
| default: |
| fprintf (stderr, "Unimplemented flash scheme %u \n", |
| environment.flag_scheme); |
| return -1; |
| } |
| |
| #ifdef DEBUG |
| printf ("Writing new environment at 0x%lx on %s\n", |
| DEVOFFSET (dev_target), DEVNAME (dev_target)); |
| #endif |
| rc = flash_write_buf (dev_target, fd_target, environment.image, |
| CONFIG_ENV_SIZE, DEVOFFSET (dev_target), |
| DEVTYPE(dev_target)); |
| if (rc < 0) |
| return rc; |
| |
| if (environment.flag_scheme == FLAG_BOOLEAN) { |
| /* Have to set obsolete flag */ |
| off_t offset = DEVOFFSET (dev_current) + |
| offsetof (struct env_image_redundant, flags); |
| #ifdef DEBUG |
| printf ("Setting obsolete flag in environment at 0x%lx on %s\n", |
| DEVOFFSET (dev_current), DEVNAME (dev_current)); |
| #endif |
| flash_flag_obsolete (dev_current, fd_current, offset); |
| } |
| |
| return 0; |
| } |
| |
| static int flash_read (int fd) |
| { |
| struct mtd_info_user mtdinfo; |
| int rc; |
| |
| rc = ioctl (fd, MEMGETINFO, &mtdinfo); |
| if (rc < 0) { |
| perror ("Cannot get MTD information"); |
| return -1; |
| } |
| |
| if (mtdinfo.type != MTD_NORFLASH && mtdinfo.type != MTD_NANDFLASH) { |
| fprintf (stderr, "Unsupported flash type %u\n", mtdinfo.type); |
| return -1; |
| } |
| |
| DEVTYPE(dev_current) = mtdinfo.type; |
| |
| rc = flash_read_buf (dev_current, fd, environment.image, CONFIG_ENV_SIZE, |
| DEVOFFSET (dev_current), mtdinfo.type); |
| |
| return (rc != CONFIG_ENV_SIZE) ? -1 : 0; |
| } |
| |
| static int flash_io (int mode) |
| { |
| int fd_current, fd_target, rc, dev_target; |
| |
| /* dev_current: fd_current, erase_current */ |
| fd_current = open (DEVNAME (dev_current), mode); |
| if (fd_current < 0) { |
| fprintf (stderr, |
| "Can't open %s: %s\n", |
| DEVNAME (dev_current), strerror (errno)); |
| return -1; |
| } |
| |
| if (mode == O_RDWR) { |
| if (HaveRedundEnv) { |
| /* switch to next partition for writing */ |
| dev_target = !dev_current; |
| /* dev_target: fd_target, erase_target */ |
| fd_target = open (DEVNAME (dev_target), mode); |
| if (fd_target < 0) { |
| fprintf (stderr, |
| "Can't open %s: %s\n", |
| DEVNAME (dev_target), |
| strerror (errno)); |
| rc = -1; |
| goto exit; |
| } |
| } else { |
| dev_target = dev_current; |
| fd_target = fd_current; |
| } |
| |
| rc = flash_write (fd_current, fd_target, dev_target); |
| |
| if (HaveRedundEnv) { |
| if (close (fd_target)) { |
| fprintf (stderr, |
| "I/O error on %s: %s\n", |
| DEVNAME (dev_target), |
| strerror (errno)); |
| rc = -1; |
| } |
| } |
| } else { |
| rc = flash_read (fd_current); |
| } |
| |
| exit: |
| if (close (fd_current)) { |
| fprintf (stderr, |
| "I/O error on %s: %s\n", |
| DEVNAME (dev_current), strerror (errno)); |
| return -1; |
| } |
| |
| return rc; |
| } |
| |
| /* |
| * s1 is either a simple 'name', or a 'name=value' pair. |
| * s2 is a 'name=value' pair. |
| * If the names match, return the value of s2, else NULL. |
| */ |
| |
| static char *envmatch (char * s1, char * s2) |
| { |
| |
| while (*s1 == *s2++) |
| if (*s1++ == '=') |
| return s2; |
| if (*s1 == '\0' && *(s2 - 1) == '=') |
| return s2; |
| return NULL; |
| } |
| |
| /* |
| * Prevent confusion if running from erased flash memory |
| */ |
| static int env_init (void) |
| { |
| int crc0, crc0_ok; |
| char flag0; |
| void *addr0; |
| |
| int crc1, crc1_ok; |
| char flag1; |
| void *addr1; |
| |
| struct env_image_single *single; |
| struct env_image_redundant *redundant; |
| |
| if (parse_config ()) /* should fill envdevices */ |
| return -1; |
| |
| addr0 = calloc (1, CONFIG_ENV_SIZE); |
| if (addr0 == NULL) { |
| fprintf (stderr, |
| "Not enough memory for environment (%ld bytes)\n", |
| CONFIG_ENV_SIZE); |
| return -1; |
| } |
| |
| /* read environment from FLASH to local buffer */ |
| environment.image = addr0; |
| |
| if (HaveRedundEnv) { |
| redundant = addr0; |
| environment.crc = &redundant->crc; |
| environment.flags = &redundant->flags; |
| environment.data = redundant->data; |
| } else { |
| single = addr0; |
| environment.crc = &single->crc; |
| environment.flags = NULL; |
| environment.data = single->data; |
| } |
| |
| dev_current = 0; |
| if (flash_io (O_RDONLY)) |
| return -1; |
| |
| crc0 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE); |
| crc0_ok = (crc0 == *environment.crc); |
| if (!HaveRedundEnv) { |
| if (!crc0_ok) { |
| fprintf (stderr, |
| "Warning: Bad CRC, using default environment\n"); |
| memcpy(environment.data, default_environment, sizeof default_environment); |
| } |
| } else { |
| flag0 = *environment.flags; |
| |
| dev_current = 1; |
| addr1 = calloc (1, CONFIG_ENV_SIZE); |
| if (addr1 == NULL) { |
| fprintf (stderr, |
| "Not enough memory for environment (%ld bytes)\n", |
| CONFIG_ENV_SIZE); |
| return -1; |
| } |
| redundant = addr1; |
| |
| /* |
| * have to set environment.image for flash_read(), careful - |
| * other pointers in environment still point inside addr0 |
| */ |
| environment.image = addr1; |
| if (flash_io (O_RDONLY)) |
| return -1; |
| |
| /* Check flag scheme compatibility */ |
| if (DEVTYPE(dev_current) == MTD_NORFLASH && |
| DEVTYPE(!dev_current) == MTD_NORFLASH) { |
| environment.flag_scheme = FLAG_BOOLEAN; |
| } else if (DEVTYPE(dev_current) == MTD_NANDFLASH && |
| DEVTYPE(!dev_current) == MTD_NANDFLASH) { |
| environment.flag_scheme = FLAG_INCREMENTAL; |
| } else { |
| fprintf (stderr, "Incompatible flash types!\n"); |
| return -1; |
| } |
| |
| crc1 = crc32 (0, (uint8_t *) redundant->data, ENV_SIZE); |
| crc1_ok = (crc1 == redundant->crc); |
| flag1 = redundant->flags; |
| |
| if (crc0_ok && !crc1_ok) { |
| dev_current = 0; |
| } else if (!crc0_ok && crc1_ok) { |
| dev_current = 1; |
| } else if (!crc0_ok && !crc1_ok) { |
| fprintf (stderr, |
| "Warning: Bad CRC, using default environment\n"); |
| memcpy (environment.data, default_environment, |
| sizeof default_environment); |
| dev_current = 0; |
| } else { |
| switch (environment.flag_scheme) { |
| case FLAG_BOOLEAN: |
| if (flag0 == active_flag && |
| flag1 == obsolete_flag) { |
| dev_current = 0; |
| } else if (flag0 == obsolete_flag && |
| flag1 == active_flag) { |
| dev_current = 1; |
| } else if (flag0 == flag1) { |
| dev_current = 0; |
| } else if (flag0 == 0xFF) { |
| dev_current = 0; |
| } else if (flag1 == 0xFF) { |
| dev_current = 1; |
| } else { |
| dev_current = 0; |
| } |
| break; |
| case FLAG_INCREMENTAL: |
| if ((flag0 == 255 && flag1 == 0) || |
| flag1 > flag0) |
| dev_current = 1; |
| else if ((flag1 == 255 && flag0 == 0) || |
| flag0 > flag1) |
| dev_current = 0; |
| else /* flags are equal - almost impossible */ |
| dev_current = 0; |
| break; |
| default: |
| fprintf (stderr, "Unknown flag scheme %u \n", |
| environment.flag_scheme); |
| return -1; |
| } |
| } |
| |
| /* |
| * If we are reading, we don't need the flag and the CRC any |
| * more, if we are writing, we will re-calculate CRC and update |
| * flags before writing out |
| */ |
| if (dev_current) { |
| environment.image = addr1; |
| environment.crc = &redundant->crc; |
| environment.flags = &redundant->flags; |
| environment.data = redundant->data; |
| free (addr0); |
| } else { |
| environment.image = addr0; |
| /* Other pointers are already set */ |
| free (addr1); |
| } |
| } |
| return 0; |
| } |
| |
| |
| static int parse_config () |
| { |
| struct stat st; |
| |
| #if defined(CONFIG_FILE) |
| /* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */ |
| if (get_config (CONFIG_FILE)) { |
| fprintf (stderr, |
| "Cannot parse config file: %s\n", strerror (errno)); |
| return -1; |
| } |
| #else |
| strcpy (DEVNAME (0), DEVICE1_NAME); |
| DEVOFFSET (0) = DEVICE1_OFFSET; |
| ENVSIZE (0) = ENV1_SIZE; |
| DEVESIZE (0) = DEVICE1_ESIZE; |
| ENVSECTORS (0) = DEVICE1_ENVSECTORS; |
| #ifdef HAVE_REDUND |
| strcpy (DEVNAME (1), DEVICE2_NAME); |
| DEVOFFSET (1) = DEVICE2_OFFSET; |
| ENVSIZE (1) = ENV2_SIZE; |
| DEVESIZE (1) = DEVICE2_ESIZE; |
| ENVSECTORS (1) = DEVICE2_ENVSECTORS; |
| HaveRedundEnv = 1; |
| #endif |
| #endif |
| if (stat (DEVNAME (0), &st)) { |
| fprintf (stderr, |
| "Cannot access MTD device %s: %s\n", |
| DEVNAME (0), strerror (errno)); |
| return -1; |
| } |
| |
| if (HaveRedundEnv && stat (DEVNAME (1), &st)) { |
| fprintf (stderr, |
| "Cannot access MTD device %s: %s\n", |
| DEVNAME (1), strerror (errno)); |
| return -1; |
| } |
| return 0; |
| } |
| |
| #if defined(CONFIG_FILE) |
| static int get_config (char *fname) |
| { |
| FILE *fp; |
| int i = 0; |
| int rc; |
| char dump[128]; |
| |
| fp = fopen (fname, "r"); |
| if (fp == NULL) |
| return -1; |
| |
| while (i < 2 && fgets (dump, sizeof (dump), fp)) { |
| /* Skip incomplete conversions and comment strings */ |
| if (dump[0] == '#') |
| continue; |
| |
| rc = sscanf (dump, "%s %lx %lx %lx %lx", |
| DEVNAME (i), |
| &DEVOFFSET (i), |
| &ENVSIZE (i), |
| &DEVESIZE (i), |
| &ENVSECTORS (i)); |
| |
| if (rc < 4) |
| continue; |
| |
| if (rc < 5) |
| /* Default - 1 sector */ |
| ENVSECTORS (i) = 1; |
| |
| i++; |
| } |
| fclose (fp); |
| |
| HaveRedundEnv = i - 1; |
| if (!i) { /* No valid entries found */ |
| errno = EINVAL; |
| return -1; |
| } else |
| return 0; |
| } |
| #endif |