common/env_nand.c

   1 /*
   2  * (C) Copyright 2008
   3  * Stuart Wood, Lab X Technologies <stuart.wood@labxtechnologies.com>
   4  *
   5  * (C) Copyright 2004
   6  * Jian Zhang, Texas Instruments, jzhang@ti.com.
   7
   8  * (C) Copyright 2000-2006
   9  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  10  *
  11  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
  12  * Andreas Heppel <aheppel@sysgo.de>
  13
  14  * See file CREDITS for list of people who contributed to this
  15  * project.
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License as
  19  * published by the Free Software Foundation; either version 2 of
  20  * the License, or (at your option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  * GNU General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License
  28  * along with this program; if not, write to the Free Software
  29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  30  * MA 02111-1307 USA
  31  */
  32
  33 /* #define DEBUG */
  34
  35 #include <common.h>
  36 #include <command.h>
  37 #include <environment.h>
  38 #include <linux/stddef.h>
  39 #include <malloc.h>
  40 #include <nand.h>
  41
  42 #if defined(CONFIG_CMD_SAVEENV) && defined(CONFIG_CMD_NAND)
  43 #define CMD_SAVEENV
  44 #elif defined(CONFIG_ENV_OFFSET_REDUND)
  45 #error Cannot use CONFIG_ENV_OFFSET_REDUND without CONFIG_CMD_SAVEENV & CONFIG_CMD_NAND
  46 #endif
  47
  48 #if defined(CONFIG_ENV_SIZE_REDUND) && (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE)
  49 #error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE
  50 #endif
  51
  52 #ifdef CONFIG_INFERNO
  53 #error CONFIG_INFERNO not supported yet
  54 #endif
  55
  56 #ifndef CONFIG_ENV_RANGE
  57 #define CONFIG_ENV_RANGE        CONFIG_ENV_SIZE
  58 #endif
  59
  60 int nand_legacy_rw (struct nand_chip* nand, int cmd,
  61             size_t start, size_t len,
  62             size_t * retlen, u_char * buf);
  63
  64 /* references to names in env_common.c */
  65 extern uchar default_environment[];
  66 extern int default_environment_size;
  67
  68 char * env_name_spec = "NAND";
  69
  70
  71 #ifdef ENV_IS_EMBEDDED
  72 extern uchar environment[];
  73 env_t *env_ptr = (env_t *)(&environment[0]);
  74 #else /* ! ENV_IS_EMBEDDED */
  75 env_t *env_ptr = 0;
  76 #endif /* ENV_IS_EMBEDDED */
  77
  78
  79 /* local functions */
  80 #if !defined(ENV_IS_EMBEDDED)
  81 static void use_default(void);
  82 #endif
  83
  84 DECLARE_GLOBAL_DATA_PTR;
  85
  86 uchar env_get_char_spec (int index)
  87 {
  88         return ( *((uchar *)(gd->env_addr + index)) );
  89 }
  90
  91
  92 /* this is called before nand_init()
  93  * so we can't read Nand to validate env data.
  94  * Mark it OK for now. env_relocate() in env_common.c
  95  * will call our relocate function which does the real
  96  * validation.
  97  *
  98  * When using a NAND boot image (like sequoia_nand), the environment
  99  * can be embedded or attached to the U-Boot image in NAND flash. This way
 100  * the SPL loads not only the U-Boot image from NAND but also the
 101  * environment.
 102  */
 103 int env_init(void)
 104 {
 105 #if defined(ENV_IS_EMBEDDED)
 106         size_t total;
 107         int crc1_ok = 0, crc2_ok = 0;
 108         env_t *tmp_env1, *tmp_env2;
 109
 110         total = CONFIG_ENV_SIZE;
 111
 112         tmp_env1 = env_ptr;
 113         tmp_env2 = (env_t *)((ulong)env_ptr + CONFIG_ENV_SIZE);
 114
 115         crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
 116         crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
 117
 118         if (!crc1_ok && !crc2_ok)
 119                 gd->env_valid = 0;
 120         else if(crc1_ok && !crc2_ok)
 121                 gd->env_valid = 1;
 122         else if(!crc1_ok && crc2_ok)
 123                 gd->env_valid = 2;
 124         else {
 125                 /* both ok - check serial */
 126                 if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
 127                         gd->env_valid = 2;
 128                 else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
 129                         gd->env_valid = 1;
 130                 else if(tmp_env1->flags > tmp_env2->flags)
 131                         gd->env_valid = 1;
 132                 else if(tmp_env2->flags > tmp_env1->flags)
 133                         gd->env_valid = 2;
 134                 else /* flags are equal - almost impossible */
 135                         gd->env_valid = 1;
 136         }
 137
 138         if (gd->env_valid == 1)
 139                 env_ptr = tmp_env1;
 140         else if (gd->env_valid == 2)
 141                 env_ptr = tmp_env2;
 142 #else /* ENV_IS_EMBEDDED */
 143         gd->env_addr  = (ulong)&default_environment[0];
 144         gd->env_valid = 1;
 145 #endif /* ENV_IS_EMBEDDED */
 146
 147         return (0);
 148 }
 149
 150 #ifdef CMD_SAVEENV
 151 /*
 152  * The legacy NAND code saved the environment in the first NAND device i.e.,
 153  * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
 154  */
 155 int writeenv(size_t offset, u_char *buf)
 156 {
 157         size_t end = offset + CONFIG_ENV_RANGE;
 158         size_t amount_saved = 0;
 159         size_t blocksize, len;
 160
 161         u_char *char_ptr;
 162
 163         blocksize = nand_info[0].erasesize;
 164         len = min(blocksize, CONFIG_ENV_SIZE);
 165
 166         while (amount_saved < CONFIG_ENV_SIZE && offset < end) {
 167                 if (nand_block_isbad(&nand_info[0], offset)) {
 168                         offset += blocksize;
 169                 } else {
 170                         char_ptr = &buf[amount_saved];
 171                         if (nand_write(&nand_info[0], offset, &len,
 172                                         char_ptr))
 173                                 return 1;
 174                         offset += blocksize;
 175                         amount_saved += len;
 176                 }
 177         }
 178         if (amount_saved != CONFIG_ENV_SIZE)
 179                 return 1;
 180
 181         return 0;
 182 }
 183 #ifdef CONFIG_ENV_OFFSET_REDUND
 184 int saveenv(void)
 185 {
 186         size_t total;
 187         int ret = 0;
 188         nand_erase_options_t nand_erase_options;
 189
 190         env_ptr->flags++;
 191         total = CONFIG_ENV_SIZE;
 192
 193         nand_erase_options.length = CONFIG_ENV_RANGE;
 194         nand_erase_options.quiet = 0;
 195         nand_erase_options.jffs2 = 0;
 196         nand_erase_options.scrub = 0;
 197
 198         if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
 199                 return 1;
 200         if(gd->env_valid == 1) {
 201                 puts ("Erasing redundant Nand...\n");
 202                 nand_erase_options.offset = CONFIG_ENV_OFFSET_REDUND;
 203                 if (nand_erase_opts(&nand_info[0], &nand_erase_options))
 204                         return 1;
 205
 206                 puts ("Writing to redundant Nand... ");
 207                 ret = writeenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) env_ptr);
 208         } else {
 209                 puts ("Erasing Nand...\n");
 210                 nand_erase_options.offset = CONFIG_ENV_OFFSET;
 211                 if (nand_erase_opts(&nand_info[0], &nand_erase_options))
 212                         return 1;
 213
 214                 puts ("Writing to Nand... ");
 215                 ret = writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
 216         }
 217         if (ret) {
 218                 puts("FAILED!\n");
 219                 return 1;
 220         }
 221
 222         puts ("done\n");
 223         gd->env_valid = (gd->env_valid == 2 ? 1 : 2);
 224         return ret;
 225 }
 226 #else /* ! CONFIG_ENV_OFFSET_REDUND */
 227 int saveenv(void)
 228 {
 229         size_t total;
 230         int ret = 0;
 231         nand_erase_options_t nand_erase_options;
 232
 233         nand_erase_options.length = CONFIG_ENV_RANGE;
 234         nand_erase_options.quiet = 0;
 235         nand_erase_options.jffs2 = 0;
 236         nand_erase_options.scrub = 0;
 237         nand_erase_options.offset = CONFIG_ENV_OFFSET;
 238
 239         if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
 240                 return 1;
 241         puts ("Erasing Nand...\n");
 242         if (nand_erase_opts(&nand_info[0], &nand_erase_options))
 243                 return 1;
 244
 245         puts ("Writing to Nand... ");
 246         total = CONFIG_ENV_SIZE;
 247         if (writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr)) {
 248                 puts("FAILED!\n");
 249                 return 1;
 250         }
 251
 252         puts ("done\n");
 253         return ret;
 254 }
 255 #endif /* CONFIG_ENV_OFFSET_REDUND */
 256 #endif /* CMD_SAVEENV */
 257
 258 int readenv (size_t offset, u_char * buf)
 259 {
 260         size_t end = offset + CONFIG_ENV_RANGE;
 261         size_t amount_loaded = 0;
 262         size_t blocksize, len;
 263
 264         u_char *char_ptr;
 265
 266         blocksize = nand_info[0].erasesize;
 267         len = min(blocksize, CONFIG_ENV_SIZE);
 268
 269         while (amount_loaded < CONFIG_ENV_SIZE && offset < end) {
 270                 if (nand_block_isbad(&nand_info[0], offset)) {
 271                         offset += blocksize;
 272                 } else {
 273                         char_ptr = &buf[amount_loaded];
 274                         if (nand_read(&nand_info[0], offset, &len, char_ptr))
 275                                 return 1;
 276                         offset += blocksize;
 277                         amount_loaded += len;
 278                 }
 279         }
 280         if (amount_loaded != CONFIG_ENV_SIZE)
 281                 return 1;
 282
 283         return 0;
 284 }
 285
 286 #ifdef CONFIG_ENV_OFFSET_REDUND
 287 void env_relocate_spec (void)
 288 {
 289 #if !defined(ENV_IS_EMBEDDED)
 290         size_t total;
 291         int crc1_ok = 0, crc2_ok = 0;
 292         env_t *tmp_env1, *tmp_env2;
 293
 294         total = CONFIG_ENV_SIZE;
 295
 296         tmp_env1 = (env_t *) malloc(CONFIG_ENV_SIZE);
 297         tmp_env2 = (env_t *) malloc(CONFIG_ENV_SIZE);
 298
 299         if (readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1))
 300                 puts("No Valid Environment Area Found\n");
 301         if (readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2))
 302                 puts("No Valid Reundant Environment Area Found\n");
 303
 304         crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
 305         crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
 306
 307         if(!crc1_ok && !crc2_ok) {
 308                 free(tmp_env1);
 309                 free(tmp_env2);
 310                 return use_default();
 311         } else if(crc1_ok && !crc2_ok)
 312                 gd->env_valid = 1;
 313         else if(!crc1_ok && crc2_ok)
 314                 gd->env_valid = 2;
 315         else {
 316                 /* both ok - check serial */
 317                 if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
 318                         gd->env_valid = 2;
 319                 else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
 320                         gd->env_valid = 1;
 321                 else if(tmp_env1->flags > tmp_env2->flags)
 322                         gd->env_valid = 1;
 323                 else if(tmp_env2->flags > tmp_env1->flags)
 324                         gd->env_valid = 2;
 325                 else /* flags are equal - almost impossible */
 326                         gd->env_valid = 1;
 327
 328         }
 329
 330         free(env_ptr);
 331         if(gd->env_valid == 1) {
 332                 env_ptr = tmp_env1;
 333                 free(tmp_env2);
 334         } else {
 335                 env_ptr = tmp_env2;
 336                 free(tmp_env1);
 337         }
 338
 339 #endif /* ! ENV_IS_EMBEDDED */
 340 }
 341 #else /* ! CONFIG_ENV_OFFSET_REDUND */
 342 /*
 343  * The legacy NAND code saved the environment in the first NAND device i.e.,
 344  * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
 345  */
 346 void env_relocate_spec (void)
 347 {
 348 #if !defined(ENV_IS_EMBEDDED)
 349         int ret;
 350
 351         ret = readenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
 352         if (ret)
 353                 return use_default();
 354
 355         if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc)
 356                 return use_default();
 357 #endif /* ! ENV_IS_EMBEDDED */
 358 }
 359 #endif /* CONFIG_ENV_OFFSET_REDUND */
 360
 361 #if !defined(ENV_IS_EMBEDDED)
 362 static void use_default()
 363 {
 364         puts ("*** Warning - bad CRC or NAND, using default environment\n\n");
 365         set_default_env();
 366 }
 367 #endif