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 /* references to names in env_common.c */
  59 extern uchar default_environment[];
  60
  61 char * env_name_spec = "SPI Flash";
  62
  63 static struct spi_flash *env_flash;
  64
  65 uchar env_get_char_spec(int index)
  66 {
  67         return *((uchar *)(gd->env_addr + index));
  68 }
  69
  70 #if defined(CONFIG_ENV_OFFSET_REDUND)
  71
  72 int saveenv(void)
  73 {
  74         env_t   env_new;
  75         ssize_t len;
  76         char    *res;
  77         u32     saved_size, saved_offset;
  78         char    *saved_buffer = NULL;
  79         u32     sector = 1;
  80         int     ret;
  81         char    flag = OBSOLETE_FLAG;
  82
  83         if (!env_flash) {
  84                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
  85                         CONFIG_ENV_SPI_CS,
  86                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
  87                 if (!env_flash) {
  88                         set_default_env("!spi_flash_probe() failed");
  89                         return 1;
  90                 }
  91         }
  92
  93         res = (char *)&env_new.data;
  94         len = hexport_r(&env_htab, '\0', &res, ENV_SIZE);
  95         if (len < 0) {
  96                 error("Cannot export environment: errno = %d\n", errno);
  97                 return 1;
  98         }
  99         env_new.crc   = crc32(0, env_new.data, ENV_SIZE);
 100         env_new.flags = ACTIVE_FLAG;
 101
 102         if (gd->env_valid == 1) {
 103                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
 104                 env_offset = CONFIG_ENV_OFFSET;
 105         } else {
 106                 env_new_offset = CONFIG_ENV_OFFSET;
 107                 env_offset = CONFIG_ENV_OFFSET_REDUND;
 108         }
 109
 110         /* Is the sector larger than the env (i.e. embedded) */
 111         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 112                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 113                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
 114                 saved_buffer = malloc(saved_size);
 115                 if (!saved_buffer) {
 116                         ret = 1;
 117                         goto done;
 118                 }
 119                 ret = spi_flash_read(env_flash, saved_offset,
 120                                         saved_size, saved_buffer);
 121                 if (ret)
 122                         goto done;
 123         }
 124
 125         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
 126                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
 127                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
 128                         sector++;
 129         }
 130
 131         puts("Erasing SPI flash...");
 132         ret = spi_flash_erase(env_flash, env_new_offset,
 133                                 sector * CONFIG_ENV_SECT_SIZE);
 134         if (ret)
 135                 goto done;
 136
 137         puts("Writing to SPI flash...");
 138
 139         ret = spi_flash_write(env_flash, env_new_offset,
 140                 CONFIG_ENV_SIZE, &env_new);
 141         if (ret)
 142                 goto done;
 143
 144         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 145                 ret = spi_flash_write(env_flash, saved_offset,
 146                                         saved_size, saved_buffer);
 147                 if (ret)
 148                         goto done;
 149         }
 150
 151         ret = spi_flash_write(env_flash,
 152                 env_offset + offsetof(env_t, flags),
 153                 sizeof(env_new.flags), &flag);
 154         if (ret)
 155                 goto done;
 156
 157         puts("done\n");
 158
 159         gd->env_valid = (gd->env_valid == 2 ? 1 : 2);
 160
 161         printf("Valid environment: %d\n", (int)gd->env_valid);
 162
 163  done:
 164         if (saved_buffer)
 165                 free(saved_buffer);
 166         return ret;
 167 }
 168
 169 void env_relocate_spec(void)
 170 {
 171         int ret;
 172         int crc1_ok = 0, crc2_ok = 0;
 173         env_t *tmp_env1 = NULL;
 174         env_t *tmp_env2 = NULL;
 175         env_t *ep = NULL;
 176
 177         tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
 178         tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
 179
 180         if (!tmp_env1 || !tmp_env2) {
 181                 set_default_env("!malloc() failed");
 182                 goto out;
 183         }
 184
 185         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
 186                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
 187         if (!env_flash) {
 188                 set_default_env("!spi_flash_probe() failed");
 189                 goto out;
 190         }
 191
 192         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
 193                                 CONFIG_ENV_SIZE, tmp_env1);
 194         if (ret) {
 195                 set_default_env("!spi_flash_read() failed");
 196                 goto err_read;
 197         }
 198
 199         if (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc)
 200                 crc1_ok = 1;
 201
 202         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
 203                                 CONFIG_ENV_SIZE, tmp_env2);
 204         if (!ret) {
 205                 if (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc)
 206                         crc2_ok = 1;
 207         }
 208
 209         if (!crc1_ok && !crc2_ok) {
 210                 set_default_env("!bad CRC");
 211                 goto err_read;
 212         } else if (crc1_ok && !crc2_ok) {
 213                 gd->env_valid = 1;
 214         } else if (!crc1_ok && crc2_ok) {
 215                 gd->env_valid = 2;
 216         } else if (tmp_env1->flags == ACTIVE_FLAG &&
 217                    tmp_env2->flags == OBSOLETE_FLAG) {
 218                 gd->env_valid = 1;
 219         } else if (tmp_env1->flags == OBSOLETE_FLAG &&
 220                    tmp_env2->flags == ACTIVE_FLAG) {
 221                 gd->env_valid = 2;
 222         } else if (tmp_env1->flags == tmp_env2->flags) {
 223                 gd->env_valid = 2;
 224         } else if (tmp_env1->flags == 0xFF) {
 225                 gd->env_valid = 2;
 226         } else {
 227                 /*
 228                  * this differs from code in env_flash.c, but I think a sane
 229                  * default path is desirable.
 230                  */
 231                 gd->env_valid = 2;
 232         }
 233
 234         if (gd->env_valid == 1)
 235                 ep = tmp_env1;
 236         else
 237                 ep = tmp_env2;
 238
 239         ret = env_import((char *)ep, 0);
 240         if (!ret) {
 241                 error("Cannot import environment: errno = %d\n", errno);
 242                 set_default_env("env_import failed");
 243         }
 244
 245 err_read:
 246         spi_flash_free(env_flash);
 247         env_flash = NULL;
 248 out:
 249         free(tmp_env1);
 250         free(tmp_env2);
 251
 252         return;
 253 }
 254 #else
 255 int saveenv(void)
 256 {
 257         u32 saved_size, saved_offset;
 258         char *saved_buffer = NULL;
 259         u32 sector = 1;
 260         int ret = 1;
 261         env_t   env_new;
 262         char    *res;
 263         ssize_t len;
 264
 265         if (!env_flash) {
 266                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
 267                         CONFIG_ENV_SPI_CS,
 268                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
 269                 if (!env_flash) {
 270                         set_default_env("!spi_flash_probe() failed");
 271                         return 1;
 272                 }
 273         }
 274
 275         /* Is the sector larger than the env (i.e. embedded) */
 276         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 277                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
 278                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 279                 saved_buffer = malloc(saved_size);
 280                 if (!saved_buffer) {
 281                         goto done;
 282                 }
 283                 ret = spi_flash_read(env_flash, saved_offset,
 284                         saved_size, saved_buffer);
 285                 if (ret)
 286                         goto done;
 287         }
 288
 289         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
 290                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
 291                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
 292                         sector++;
 293         }
 294
 295         res = (char *)&env_new.data;
 296         len = hexport_r(&env_htab, '\0', &res, ENV_SIZE);
 297         if (len < 0) {
 298                 error("Cannot export environment: errno = %d\n", errno);
 299                 goto done;
 300         }
 301         env_new.crc = crc32(0, env_new.data, ENV_SIZE);
 302
 303         puts("Erasing SPI flash...");
 304         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
 305                 sector * CONFIG_ENV_SECT_SIZE);
 306         if (ret)
 307                 goto done;
 308
 309         puts("Writing to SPI flash...");
 310         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
 311                 CONFIG_ENV_SIZE, &env_new);
 312         if (ret)
 313                 goto done;
 314
 315         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
 316                 ret = spi_flash_write(env_flash, saved_offset,
 317                         saved_size, saved_buffer);
 318                 if (ret)
 319                         goto done;
 320         }
 321
 322         ret = 0;
 323         puts("done\n");
 324
 325  done:
 326         if (saved_buffer)
 327                 free(saved_buffer);
 328         return ret;
 329 }
 330
 331 void env_relocate_spec(void)
 332 {
 333         char buf[CONFIG_ENV_SIZE];
 334         int ret;
 335
 336         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
 337                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
 338         if (!env_flash) {
 339                 set_default_env("!spi_flash_probe() failed");
 340                 return;
 341         }
 342
 343         ret = spi_flash_read(env_flash,
 344                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
 345         if (ret) {
 346                 set_default_env("!spi_flash_read() failed");
 347                 goto out;
 348         }
 349
 350         ret = env_import(buf, 1);
 351
 352         if (ret)
 353                 gd->env_valid = 1;
 354 out:
 355         spi_flash_free(env_flash);
 356         env_flash = NULL;
 357 }
 358 #endif
 359
 360 int env_init(void)
 361 {
 362         /* SPI flash isn't usable before relocation */
 363         gd->env_addr = (ulong)&default_environment[0];
 364         gd->env_valid = 1;
 365
 366         return 0;
 367 }