common/env_nand.c

   1 /*
   2  * (C) Copyright 2000-2010
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * (C) Copyright 2008
   6  * Stuart Wood, Lab X Technologies <stuart.wood@labxtechnologies.com>
   7  *
   8  * (C) Copyright 2004
   9  * Jian Zhang, Texas Instruments, jzhang@ti.com.
  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 #include <common.h>
  34 #include <command.h>
  35 #include <environment.h>
  36 #include <linux/stddef.h>
  37 #include <malloc.h>
  38 #include <nand.h>
  39 #include <search.h>
  40 #include <errno.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 CONFIG_ENV_OFFSET_REDUND must have CONFIG_CMD_SAVEENV & CONFIG_CMD_NAND
  46 #endif
  47
  48 #if defined(CONFIG_ENV_SIZE_REDUND) &&  \
  49         (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE)
  50 #error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE
  51 #endif
  52
  53 #ifndef CONFIG_ENV_RANGE
  54 #define CONFIG_ENV_RANGE        CONFIG_ENV_SIZE
  55 #endif
  56
  57 char *env_name_spec = "NAND";
  58
  59 #if defined(ENV_IS_EMBEDDED)
  60 env_t *env_ptr = &environment;
  61 #elif defined(CONFIG_NAND_ENV_DST)
  62 env_t *env_ptr = (env_t *)CONFIG_NAND_ENV_DST;
  63 #else /* ! ENV_IS_EMBEDDED */
  64 env_t *env_ptr;
  65 #endif /* ENV_IS_EMBEDDED */
  66
  67 DECLARE_GLOBAL_DATA_PTR;
  68
  69 /*
  70  * This is called before nand_init() so we can't read NAND to
  71  * validate env data.
  72  *
  73  * Mark it OK for now. env_relocate() in env_common.c will call our
  74  * relocate function which does the real validation.
  75  *
  76  * When using a NAND boot image (like sequoia_nand), the environment
  77  * can be embedded or attached to the U-Boot image in NAND flash.
  78  * This way the SPL loads not only the U-Boot image from NAND but
  79  * also the environment.
  80  */
  81 int env_init(void)
  82 {
  83 #if defined(ENV_IS_EMBEDDED) || defined(CONFIG_NAND_ENV_DST)
  84         int crc1_ok = 0, crc2_ok = 0;
  85         env_t *tmp_env1;
  86
  87 #ifdef CONFIG_ENV_OFFSET_REDUND
  88         env_t *tmp_env2;
  89
  90         tmp_env2 = (env_t *)((ulong)env_ptr + CONFIG_ENV_SIZE);
  91         crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc;
  92 #endif
  93         tmp_env1 = env_ptr;
  94         crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc;
  95
  96         if (!crc1_ok && !crc2_ok) {
  97                 gd->env_addr    = 0;
  98                 gd->env_valid   = 0;
  99
 100                 return 0;
 101         } else if (crc1_ok && !crc2_ok) {
 102                 gd->env_valid = 1;
 103         }
 104 #ifdef CONFIG_ENV_OFFSET_REDUND
 105         else if (!crc1_ok && crc2_ok) {
 106                 gd->env_valid = 2;
 107         } else {
 108                 /* both ok - check serial */
 109                 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
 110                         gd->env_valid = 2;
 111                 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
 112                         gd->env_valid = 1;
 113                 else if (tmp_env1->flags > tmp_env2->flags)
 114                         gd->env_valid = 1;
 115                 else if (tmp_env2->flags > tmp_env1->flags)
 116                         gd->env_valid = 2;
 117                 else /* flags are equal - almost impossible */
 118                         gd->env_valid = 1;
 119         }
 120
 121         if (gd->env_valid == 2)
 122                 env_ptr = tmp_env2;
 123         else
 124 #endif
 125         if (gd->env_valid == 1)
 126                 env_ptr = tmp_env1;
 127
 128         gd->env_addr = (ulong)env_ptr->data;
 129
 130 #else /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */
 131         gd->env_addr    = (ulong)&default_environment[0];
 132         gd->env_valid   = 1;
 133 #endif /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */
 134
 135         return 0;
 136 }
 137
 138 #ifdef CMD_SAVEENV
 139 /*
 140  * The legacy NAND code saved the environment in the first NAND device i.e.,
 141  * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
 142  */
 143 int writeenv(size_t offset, u_char *buf)
 144 {
 145         size_t end = offset + CONFIG_ENV_RANGE;
 146         size_t amount_saved = 0;
 147         size_t blocksize, len;
 148         u_char *char_ptr;
 149
 150         blocksize = nand_info[0].erasesize;
 151         len = min(blocksize, CONFIG_ENV_SIZE);
 152
 153         while (amount_saved < CONFIG_ENV_SIZE && offset < end) {
 154                 if (nand_block_isbad(&nand_info[0], offset)) {
 155                         offset += blocksize;
 156                 } else {
 157                         char_ptr = &buf[amount_saved];
 158                         if (nand_write(&nand_info[0], offset, &len, char_ptr))
 159                                 return 1;
 160
 161                         offset += blocksize;
 162                         amount_saved += len;
 163                 }
 164         }
 165         if (amount_saved != CONFIG_ENV_SIZE)
 166                 return 1;
 167
 168         return 0;
 169 }
 170
 171 #ifdef CONFIG_ENV_OFFSET_REDUND
 172 static unsigned char env_flags;
 173
 174 int saveenv(void)
 175 {
 176         env_t   env_new;
 177         ssize_t len;
 178         char    *res;
 179         int     ret = 0;
 180         nand_erase_options_t nand_erase_options;
 181
 182         memset(&nand_erase_options, 0, sizeof(nand_erase_options));
 183         nand_erase_options.length = CONFIG_ENV_RANGE;
 184
 185         if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
 186                 return 1;
 187
 188         res = (char *)&env_new.data;
 189         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
 190         if (len < 0) {
 191                 error("Cannot export environment: errno = %d\n", errno);
 192                 return 1;
 193         }
 194         env_new.crc     = crc32(0, env_new.data, ENV_SIZE);
 195         env_new.flags   = ++env_flags; /* increase the serial */
 196
 197         if (gd->env_valid == 1) {
 198                 puts("Erasing redundant NAND...\n");
 199                 nand_erase_options.offset = CONFIG_ENV_OFFSET_REDUND;
 200                 if (nand_erase_opts(&nand_info[0], &nand_erase_options))
 201                         return 1;
 202
 203                 puts("Writing to redundant NAND... ");
 204                 ret = writeenv(CONFIG_ENV_OFFSET_REDUND, (u_char *)&env_new);
 205         } else {
 206                 puts("Erasing NAND...\n");
 207                 nand_erase_options.offset = CONFIG_ENV_OFFSET;
 208                 if (nand_erase_opts(&nand_info[0], &nand_erase_options))
 209                         return 1;
 210
 211                 puts("Writing to NAND... ");
 212                 ret = writeenv(CONFIG_ENV_OFFSET, (u_char *)&env_new);
 213         }
 214         if (ret) {
 215                 puts("FAILED!\n");
 216                 return 1;
 217         }
 218
 219         puts("done\n");
 220
 221         gd->env_valid = gd->env_valid == 2 ? 1 : 2;
 222
 223         return ret;
 224 }
 225 #else /* ! CONFIG_ENV_OFFSET_REDUND */
 226 int saveenv(void)
 227 {
 228         int     ret = 0;
 229         ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
 230         ssize_t len;
 231         char    *res;
 232         nand_erase_options_t nand_erase_options;
 233
 234         memset(&nand_erase_options, 0, sizeof(nand_erase_options));
 235         nand_erase_options.length = CONFIG_ENV_RANGE;
 236         nand_erase_options.offset = CONFIG_ENV_OFFSET;
 237
 238         if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
 239                 return 1;
 240
 241         res = (char *)&env_new->data;
 242         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
 243         if (len < 0) {
 244                 error("Cannot export environment: errno = %d\n", errno);
 245                 return 1;
 246         }
 247         env_new->crc = crc32(0, env_new->data, ENV_SIZE);
 248
 249         puts("Erasing Nand...\n");
 250         if (nand_erase_opts(&nand_info[0], &nand_erase_options))
 251                 return 1;
 252
 253         puts("Writing to Nand... ");
 254         if (writeenv(CONFIG_ENV_OFFSET, (u_char *)env_new)) {
 255                 puts("FAILED!\n");
 256                 return 1;
 257         }
 258
 259         puts("done\n");
 260         return ret;
 261 }
 262 #endif /* CONFIG_ENV_OFFSET_REDUND */
 263 #endif /* CMD_SAVEENV */
 264
 265 int readenv(size_t offset, u_char *buf)
 266 {
 267         size_t end = offset + CONFIG_ENV_RANGE;
 268         size_t amount_loaded = 0;
 269         size_t blocksize, len;
 270         u_char *char_ptr;
 271
 272         blocksize = nand_info[0].erasesize;
 273         if (!blocksize)
 274                 return 1;
 275
 276         len = min(blocksize, CONFIG_ENV_SIZE);
 277
 278         while (amount_loaded < CONFIG_ENV_SIZE && offset < end) {
 279                 if (nand_block_isbad(&nand_info[0], offset)) {
 280                         offset += blocksize;
 281                 } else {
 282                         char_ptr = &buf[amount_loaded];
 283                         if (nand_read_skip_bad(&nand_info[0], offset,
 284                                                &len, NULL,
 285                                                nand_info[0].size, char_ptr))
 286                                 return 1;
 287
 288                         offset += blocksize;
 289                         amount_loaded += len;
 290                 }
 291         }
 292
 293         if (amount_loaded != CONFIG_ENV_SIZE)
 294                 return 1;
 295
 296         return 0;
 297 }
 298
 299 #ifdef CONFIG_ENV_OFFSET_OOB
 300 int get_nand_env_oob(nand_info_t *nand, unsigned long *result)
 301 {
 302         struct mtd_oob_ops ops;
 303         uint32_t oob_buf[ENV_OFFSET_SIZE / sizeof(uint32_t)];
 304         int ret;
 305
 306         ops.datbuf      = NULL;
 307         ops.mode        = MTD_OOB_AUTO;
 308         ops.ooboffs     = 0;
 309         ops.ooblen      = ENV_OFFSET_SIZE;
 310         ops.oobbuf      = (void *)oob_buf;
 311
 312         ret = nand->read_oob(nand, ENV_OFFSET_SIZE, &ops);
 313         if (ret) {
 314                 printf("error reading OOB block 0\n");
 315                 return ret;
 316         }
 317
 318         if (oob_buf[0] == ENV_OOB_MARKER) {
 319                 *result = oob_buf[1] * nand->erasesize;
 320         } else if (oob_buf[0] == ENV_OOB_MARKER_OLD) {
 321                 *result = oob_buf[1];
 322         } else {
 323                 printf("No dynamic environment marker in OOB block 0\n");
 324                 return -ENOENT;
 325         }
 326
 327         return 0;
 328 }
 329 #endif
 330
 331 #ifdef CONFIG_ENV_OFFSET_REDUND
 332 void env_relocate_spec(void)
 333 {
 334 #if !defined(ENV_IS_EMBEDDED)
 335         int read1_fail = 0, read2_fail = 0;
 336         int crc1_ok = 0, crc2_ok = 0;
 337         env_t *ep, *tmp_env1, *tmp_env2;
 338
 339         tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
 340         tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
 341         if (tmp_env1 == NULL || tmp_env2 == NULL) {
 342                 puts("Can't allocate buffers for environment\n");
 343                 set_default_env("!malloc() failed");
 344                 goto done;
 345         }
 346
 347         read1_fail = readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1);
 348         read2_fail = readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2);
 349
 350         if (read1_fail && read2_fail)
 351                 puts("*** Error - No Valid Environment Area found\n");
 352         else if (read1_fail || read2_fail)
 353                 puts("*** Warning - some problems detected "
 354                      "reading environment; recovered successfully\n");
 355
 356         crc1_ok = !read1_fail &&
 357                 (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
 358         crc2_ok = !read2_fail &&
 359                 (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
 360
 361         if (!crc1_ok && !crc2_ok) {
 362                 set_default_env("!bad CRC");
 363                 goto done;
 364         } else if (crc1_ok && !crc2_ok) {
 365                 gd->env_valid = 1;
 366         } else if (!crc1_ok && crc2_ok) {
 367                 gd->env_valid = 2;
 368         } else {
 369                 /* both ok - check serial */
 370                 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
 371                         gd->env_valid = 2;
 372                 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
 373                         gd->env_valid = 1;
 374                 else if (tmp_env1->flags > tmp_env2->flags)
 375                         gd->env_valid = 1;
 376                 else if (tmp_env2->flags > tmp_env1->flags)
 377                         gd->env_valid = 2;
 378                 else /* flags are equal - almost impossible */
 379                         gd->env_valid = 1;
 380         }
 381
 382         free(env_ptr);
 383
 384         if (gd->env_valid == 1)
 385                 ep = tmp_env1;
 386         else
 387                 ep = tmp_env2;
 388
 389         env_flags = ep->flags;
 390         env_import((char *)ep, 0);
 391
 392 done:
 393         free(tmp_env1);
 394         free(tmp_env2);
 395
 396 #endif /* ! ENV_IS_EMBEDDED */
 397 }
 398 #else /* ! CONFIG_ENV_OFFSET_REDUND */
 399 /*
 400  * The legacy NAND code saved the environment in the first NAND
 401  * device i.e., nand_dev_desc + 0. This is also the behaviour using
 402  * the new NAND code.
 403  */
 404 void env_relocate_spec(void)
 405 {
 406 #if !defined(ENV_IS_EMBEDDED)
 407         int ret;
 408         ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
 409
 410 #if defined(CONFIG_ENV_OFFSET_OOB)
 411         ret = get_nand_env_oob(&nand_info[0], &nand_env_oob_offset);
 412         /*
 413          * If unable to read environment offset from NAND OOB then fall through
 414          * to the normal environment reading code below
 415          */
 416         if (!ret) {
 417                 printf("Found Environment offset in OOB..\n");
 418         } else {
 419                 set_default_env("!no env offset in OOB");
 420                 return;
 421         }
 422 #endif
 423
 424         ret = readenv(CONFIG_ENV_OFFSET, (u_char *)buf);
 425         if (ret) {
 426                 set_default_env("!readenv() failed");
 427                 return;
 428         }
 429
 430         env_import(buf, 1);
 431 #endif /* ! ENV_IS_EMBEDDED */
 432 }
 433 #endif /* CONFIG_ENV_OFFSET_REDUND */