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