common/env_sf.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  * (C) Copyright 2008 Atmel Corporation
   9  *
  10  * See file CREDITS for list of people who contributed to this
  11  * project.
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License as
  15  * published by the Free Software Foundation; either version 2 of
  16  * the License, or (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  26  * MA 02111-1307 USA
  27  */
  28 #include <common.h>
  29 #include <environment.h>
  30 #include <malloc.h>
  31 #include <spi_flash.h>
  32 #include <search.h>
  33 #include <errno.h>
  34
  35 #ifndef CONFIG_ENV_SPI_BUS
  36 # define CONFIG_ENV_SPI_BUS     0
  37 #endif
  38 #ifndef CONFIG_ENV_SPI_CS
  39 # define CONFIG_ENV_SPI_CS      0
  40 #endif
  41 #ifndef CONFIG_ENV_SPI_MAX_HZ
  42 # define CONFIG_ENV_SPI_MAX_HZ  1000000
  43 #endif
  44 #ifndef CONFIG_ENV_SPI_MODE
  45 # define CONFIG_ENV_SPI_MODE    SPI_MODE_3
  46 #endif
  47
  48 #ifdef CONFIG_ENV_OFFSET_REDUND
  49 static ulong env_offset         = CONFIG_ENV_OFFSET;
  50 static ulong env_new_offset     = CONFIG_ENV_OFFSET_REDUND;
  51
  52 #define ACTIVE_FLAG     1
  53 #define OBSOLETE_FLAG   0
  54 #endif /* CONFIG_ENV_OFFSET_REDUND */
  55
  56 DECLARE_GLOBAL_DATA_PTR;
  57
  58 char *env_name_spec = "SPI Flash";
  59
  60 static struct spi_flash *env_flash;
  61 static char env_buf[CONFIG_ENV_SIZE];
  62
  63 #if defined(CONFIG_ENV_OFFSET_REDUND)
  64 int saveenv(void)
  65 {
  66         env_t   *env_new = (env_t *)env_buf;
  67         ssize_t len;
  68         char    *res, *saved_buffer = NULL, flag = OBSOLETE_FLAG;
  69         u32     saved_size, saved_offset, sector = 1;
  70         int     ret;
  71
  72         if (!env_flash) {
  73                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
  74                         CONFIG_ENV_SPI_CS,
  75                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
  76                 if (!env_flash) {
  77                         set_default_env("!spi_flash_probe() failed");
  78                         return 1;
  79                 }
  80         }
  81
  82         res = (char *)env_new->data;
  83         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
  84         if (len < 0) {
  85                 error("Cannot export environment: errno = %d\n", errno);
  86                 return 1;
  87         }
  88         env_new->crc    = crc32(0, env_new->data, ENV_SIZE);
  89         env_new->flags  = ACTIVE_FLAG;
  90
  91         if (gd->env_valid == 1) {
  92                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
  93                 env_offset = CONFIG_ENV_OFFSET;
  94         } else {
  95                 env_new_offset = CONFIG_ENV_OFFSET;
  96                 env_offset = CONFIG_ENV_OFFSET_REDUND;
  97         }
  98
  99         /* Is the sector larger than the env (i.e. embedded) */
 100         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 101                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 102                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
 103                 saved_buffer = malloc(saved_size);
 104                 if (!saved_buffer) {
 105                         ret = 1;
 106                         goto done;
 107                 }
 108                 ret = spi_flash_read(env_flash, saved_offset,
 109                                         saved_size, saved_buffer);
 110                 if (ret)
 111                         goto done;
 112         }
 113
 114         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
 115                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
 116                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
 117                         sector++;
 118         }
 119
 120         puts("Erasing SPI flash...");
 121         ret = spi_flash_erase(env_flash, env_new_offset,
 122                                 sector * CONFIG_ENV_SECT_SIZE);
 123         if (ret)
 124                 goto done;
 125
 126         puts("Writing to SPI flash...");
 127
 128         ret = spi_flash_write(env_flash, env_new_offset,
 129                 CONFIG_ENV_SIZE, env_new);
 130         if (ret)
 131                 goto done;
 132
 133         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 134                 ret = spi_flash_write(env_flash, saved_offset,
 135                                         saved_size, saved_buffer);
 136                 if (ret)
 137                         goto done;
 138         }
 139
 140         ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
 141                                 sizeof(env_new->flags), &flag);
 142         if (ret)
 143                 goto done;
 144
 145         puts("done\n");
 146
 147         gd->env_valid = gd->env_valid == 2 ? 1 : 2;
 148
 149         printf("Valid environment: %d\n", (int)gd->env_valid);
 150
 151  done:
 152         if (saved_buffer)
 153                 free(saved_buffer);
 154
 155         return ret;
 156 }
 157
 158 void env_relocate_spec(void)
 159 {
 160         int ret;
 161         int crc1_ok = 0, crc2_ok = 0;
 162         env_t *tmp_env1 = NULL;
 163         env_t *tmp_env2 = NULL;
 164         env_t *ep = NULL;
 165
 166         tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
 167         tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
 168
 169         if (!tmp_env1 || !tmp_env2) {
 170                 set_default_env("!malloc() failed");
 171                 goto out;
 172         }
 173
 174         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
 175                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
 176         if (!env_flash) {
 177                 set_default_env("!spi_flash_probe() failed");
 178                 goto out;
 179         }
 180
 181         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 182                                 CONFIG_ENV_SIZE, tmp_env1);
 183         if (ret) {
 184                 set_default_env("!spi_flash_read() failed");
 185                 goto err_read;
 186         }
 187
 188         if (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc)
 189                 crc1_ok = 1;
 190
 191         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
 192                                 CONFIG_ENV_SIZE, tmp_env2);
 193         if (!ret) {
 194                 if (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc)
 195                         crc2_ok = 1;
 196         }
 197
 198         if (!crc1_ok && !crc2_ok) {
 199                 set_default_env("!bad CRC");
 200                 goto err_read;
 201         } else if (crc1_ok && !crc2_ok) {
 202                 gd->env_valid = 1;
 203         } else if (!crc1_ok && crc2_ok) {
 204                 gd->env_valid = 2;
 205         } else if (tmp_env1->flags == ACTIVE_FLAG &&
 206                    tmp_env2->flags == OBSOLETE_FLAG) {
 207                 gd->env_valid = 1;
 208         } else if (tmp_env1->flags == OBSOLETE_FLAG &&
 209                    tmp_env2->flags == ACTIVE_FLAG) {
 210                 gd->env_valid = 2;
 211         } else if (tmp_env1->flags == tmp_env2->flags) {
 212                 gd->env_valid = 2;
 213         } else if (tmp_env1->flags == 0xFF) {
 214                 gd->env_valid = 2;
 215         } else {
 216                 /*
 217                  * this differs from code in env_flash.c, but I think a sane
 218                  * default path is desirable.
 219                  */
 220                 gd->env_valid = 2;
 221         }
 222
 223         if (gd->env_valid == 1)
 224                 ep = tmp_env1;
 225         else
 226                 ep = tmp_env2;
 227
 228         ret = env_import((char *)ep, 0);
 229         if (!ret) {
 230                 error("Cannot import environment: errno = %d\n", errno);
 231                 set_default_env("env_import failed");
 232         }
 233
 234 err_read:
 235         spi_flash_free(env_flash);
 236         env_flash = NULL;
 237 out:
 238         free(tmp_env1);
 239         free(tmp_env2);
 240 }
 241 #else
 242 int saveenv(void)
 243 {
 244         u32     saved_size, saved_offset, sector = 1;
 245         char    *res, *saved_buffer = NULL;
 246         int     ret = 1;
 247         env_t   *env_new = (env_t *)env_buf;
 248         ssize_t len;
 249
 250         if (!env_flash) {
 251                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
 252                         CONFIG_ENV_SPI_CS,
 253                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
 254                 if (!env_flash) {
 255                         set_default_env("!spi_flash_probe() failed");
 256                         return 1;
 257                 }
 258         }
 259
 260         /* Is the sector larger than the env (i.e. embedded) */
 261         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 262                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 263                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 264                 saved_buffer = malloc(saved_size);
 265                 if (!saved_buffer)
 266                         goto done;
 267
 268                 ret = spi_flash_read(env_flash, saved_offset,
 269                         saved_size, saved_buffer);
 270                 if (ret)
 271                         goto done;
 272         }
 273
 274         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
 275                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
 276                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
 277                         sector++;
 278         }
 279
 280         res = (char *)env_new->data;
 281         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
 282         if (len < 0) {
 283                 error("Cannot export environment: errno = %d\n", errno);
 284                 goto done;
 285         }
 286         env_new->crc = crc32(0, env_new->data, ENV_SIZE);
 287
 288         puts("Erasing SPI flash...");
 289         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
 290                 sector * CONFIG_ENV_SECT_SIZE);
 291         if (ret)
 292                 goto done;
 293
 294         puts("Writing to SPI flash...");
 295         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
 296                 CONFIG_ENV_SIZE, env_new);
 297         if (ret)
 298                 goto done;
 299
 300         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 301                 ret = spi_flash_write(env_flash, saved_offset,
 302                         saved_size, saved_buffer);
 303                 if (ret)
 304                         goto done;
 305         }
 306
 307         ret = 0;
 308         puts("done\n");
 309
 310  done:
 311         if (saved_buffer)
 312                 free(saved_buffer);
 313
 314         return ret;
 315 }
 316
 317 void env_relocate_spec(void)
 318 {
 319         char *buf = env_buf;
 320         int ret;
 321
 322         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
 323                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
 324         if (!env_flash) {
 325                 set_default_env("!spi_flash_probe() failed");
 326                 return;
 327         }
 328
 329         ret = spi_flash_read(env_flash,
 330                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
 331         if (ret) {
 332                 set_default_env("!spi_flash_read() failed");
 333                 goto out;
 334         }
 335
 336         ret = env_import(buf, 1);
 337         if (ret)
 338                 gd->env_valid = 1;
 339 out:
 340         spi_flash_free(env_flash);
 341         env_flash = NULL;
 342 }
 343 #endif
 344
 345 int env_init(void)
 346 {
 347         /* SPI flash isn't usable before relocation */
 348         gd->env_addr = (ulong)&default_environment[0];
 349         gd->env_valid = 1;
 350
 351         return 0;
 352 }