git.sur5r.net Git - u-boot/blob - common/env_eeprom.c

   1 /*
   2  * (C) Copyright 2000-2010
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   6  * Andreas Heppel <aheppel@sysgo.de>
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <command.h>
  13 #include <environment.h>
  14 #include <linux/stddef.h>
  15 #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  16 #include <i2c.h>
  17 #endif
  18 #include <search.h>
  19 #include <errno.h>
  20 #include <linux/compiler.h>     /* for BUG_ON */
  21
  22 DECLARE_GLOBAL_DATA_PTR;
  23
  24 env_t *env_ptr;
  25
  26 char *env_name_spec = "EEPROM";
  27
  28 static int eeprom_bus_read(unsigned dev_addr, unsigned offset,
  29                            uchar *buffer, unsigned cnt)
  30 {
  31         int rcode;
  32 #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  33         int old_bus = i2c_get_bus_num();
  34
  35         if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
  36                 i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
  37 #endif
  38
  39         rcode = eeprom_read(dev_addr, offset, buffer, cnt);
  40
  41 #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  42         i2c_set_bus_num(old_bus);
  43 #endif
  44
  45         return rcode;
  46 }
  47
  48 static int eeprom_bus_write(unsigned dev_addr, unsigned offset,
  49                             uchar *buffer, unsigned cnt)
  50 {
  51         int rcode;
  52 #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  53         int old_bus = i2c_get_bus_num();
  54
  55         if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
  56                 i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
  57 #endif
  58
  59         rcode = eeprom_write(dev_addr, offset, buffer, cnt);
  60
  61 #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  62         i2c_set_bus_num(old_bus);
  63 #endif
  64
  65         return rcode;
  66 }
  67
  68 uchar env_get_char_spec(int index)
  69 {
  70         uchar c;
  71         unsigned int off = CONFIG_ENV_OFFSET;
  72
  73 #ifdef CONFIG_ENV_OFFSET_REDUND
  74         if (gd->env_valid == 2)
  75                 off = CONFIG_ENV_OFFSET_REDUND;
  76 #endif
  77         eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  78                         off + index + offsetof(env_t, data), &c, 1);
  79
  80         return c;
  81 }
  82
  83 void env_relocate_spec(void)
  84 {
  85         char buf[CONFIG_ENV_SIZE];
  86         unsigned int off = CONFIG_ENV_OFFSET;
  87
  88 #ifdef CONFIG_ENV_OFFSET_REDUND
  89         if (gd->env_valid == 2)
  90                 off = CONFIG_ENV_OFFSET_REDUND;
  91 #endif
  92         eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  93                         off, (uchar *)buf, CONFIG_ENV_SIZE);
  94
  95         env_import(buf, 1);
  96 }
  97
  98 int saveenv(void)
  99 {
 100         env_t   env_new;
 101         ssize_t len;
 102         char    *res;
 103         int     rc;
 104         unsigned int off        = CONFIG_ENV_OFFSET;
 105 #ifdef CONFIG_ENV_OFFSET_REDUND
 106         unsigned int off_red    = CONFIG_ENV_OFFSET_REDUND;
 107         char flag_obsolete      = OBSOLETE_FLAG;
 108 #endif
 109
 110         BUG_ON(env_ptr != NULL);
 111
 112         res = (char *)&env_new.data;
 113         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
 114         if (len < 0) {
 115                 error("Cannot export environment: errno = %d\n", errno);
 116                 return 1;
 117         }
 118         env_new.crc = crc32(0, env_new.data, ENV_SIZE);
 119
 120 #ifdef CONFIG_ENV_OFFSET_REDUND
 121         if (gd->env_valid == 1) {
 122                 off     = CONFIG_ENV_OFFSET_REDUND;
 123                 off_red = CONFIG_ENV_OFFSET;
 124         }
 125
 126         env_new.flags = ACTIVE_FLAG;
 127 #endif
 128
 129         rc = eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
 130                               off, (uchar *)&env_new, CONFIG_ENV_SIZE);
 131
 132 #ifdef CONFIG_ENV_OFFSET_REDUND
 133         if (rc == 0) {
 134                 eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
 135                                  off_red + offsetof(env_t, flags),
 136                                  (uchar *)&flag_obsolete, 1);
 137
 138                 if (gd->env_valid == 1)
 139                         gd->env_valid = 2;
 140                 else
 141                         gd->env_valid = 1;
 142         }
 143 #endif
 144         return rc;
 145 }
 146
 147 /*
 148  * Initialize Environment use
 149  *
 150  * We are still running from ROM, so data use is limited.
 151  * Use a (moderately small) buffer on the stack
 152  */
 153 #ifdef CONFIG_ENV_OFFSET_REDUND
 154 int env_init(void)
 155 {
 156         ulong len, crc[2], crc_tmp;
 157         unsigned int off, off_env[2];
 158         uchar buf[64], flags[2];
 159         int i, crc_ok[2] = {0, 0};
 160
 161         eeprom_init();  /* prepare for EEPROM read/write */
 162
 163         off_env[0] = CONFIG_ENV_OFFSET;
 164         off_env[1] = CONFIG_ENV_OFFSET_REDUND;
 165
 166         for (i = 0; i < 2; i++) {
 167                 /* read CRC */
 168                 eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
 169                                 off_env[i] + offsetof(env_t, crc),
 170                                 (uchar *)&crc[i], sizeof(ulong));
 171                 /* read FLAGS */
 172                 eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
 173                                 off_env[i] + offsetof(env_t, flags),
 174                                 (uchar *)&flags[i], sizeof(uchar));
 175
 176                 crc_tmp = 0;
 177                 len = ENV_SIZE;
 178                 off = off_env[i] + offsetof(env_t, data);
 179                 while (len > 0) {
 180                         int n = (len > sizeof(buf)) ? sizeof(buf) : len;
 181
 182                         eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR, off,
 183                                         buf, n);
 184
 185                         crc_tmp = crc32(crc_tmp, buf, n);
 186                         len -= n;
 187                         off += n;
 188                 }
 189
 190                 if (crc_tmp == crc[i])
 191                         crc_ok[i] = 1;
 192         }
 193
 194         if (!crc_ok[0] && !crc_ok[1]) {
 195                 gd->env_addr    = 0;
 196                 gd->env_valid   = 0;
 197
 198                 return 0;
 199         } else if (crc_ok[0] && !crc_ok[1]) {
 200                 gd->env_valid = 1;
 201         } else if (!crc_ok[0] && crc_ok[1]) {
 202                 gd->env_valid = 2;
 203         } else {
 204                 /* both ok - check serial */
 205                 if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
 206                         gd->env_valid = 1;
 207                 else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
 208                         gd->env_valid = 2;
 209                 else if (flags[0] == 0xFF && flags[1] == 0)
 210                         gd->env_valid = 2;
 211                 else if (flags[1] == 0xFF && flags[0] == 0)
 212                         gd->env_valid = 1;
 213                 else /* flags are equal - almost impossible */
 214                         gd->env_valid = 1;
 215         }
 216
 217         if (gd->env_valid == 2)
 218                 gd->env_addr = off_env[1] + offsetof(env_t, data);
 219         else if (gd->env_valid == 1)
 220                 gd->env_addr = off_env[0] + offsetof(env_t, data);
 221
 222         return 0;
 223 }
 224 #else
 225 int env_init(void)
 226 {
 227         ulong crc, len, new;
 228         unsigned off;
 229         uchar buf[64];
 230
 231         eeprom_init();  /* prepare for EEPROM read/write */
 232
 233         /* read old CRC */
 234         eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
 235                         CONFIG_ENV_OFFSET + offsetof(env_t, crc),
 236                         (uchar *)&crc, sizeof(ulong));
 237
 238         new = 0;
 239         len = ENV_SIZE;
 240         off = offsetof(env_t, data);
 241
 242         while (len > 0) {
 243                 int n = (len > sizeof(buf)) ? sizeof(buf) : len;
 244
 245                 eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
 246                                 CONFIG_ENV_OFFSET + off, buf, n);
 247                 new = crc32(new, buf, n);
 248                 len -= n;
 249                 off += n;
 250         }
 251
 252         if (crc == new) {
 253                 gd->env_addr    = offsetof(env_t, data);
 254                 gd->env_valid   = 1;
 255         } else {
 256                 gd->env_addr    = 0;
 257                 gd->env_valid   = 0;
 258         }
 259
 260         return 0;
 261 }
 262 #endif