drivers/mtd/nand/nand_util.c

   1 /*
   2  * drivers/mtd/nand/nand_util.c
   3  *
   4  * Copyright (C) 2006 by Weiss-Electronic GmbH.
   5  * All rights reserved.
   6  *
   7  * @author:     Guido Classen <clagix@gmail.com>
   8  * @descr:      NAND Flash support
   9  * @references: borrowed heavily from Linux mtd-utils code:
  10  *              flash_eraseall.c by Arcom Control System Ltd
  11  *              nandwrite.c by Steven J. Hill (sjhill@realitydiluted.com)
  12  *                             and Thomas Gleixner (tglx@linutronix.de)
  13  *
  14  * Copyright (C) 2008 Nokia Corporation: drop_ffs() function by
  15  * Artem Bityutskiy <dedekind1@gmail.com> from mtd-utils
  16  *
  17  * See file CREDITS for list of people who contributed to this
  18  * project.
  19  *
  20  * This program is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU General Public License version
  22  * 2 as published by the Free Software Foundation.
  23  *
  24  * This program is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  * GNU General Public License for more details.
  28  *
  29  * You should have received a copy of the GNU General Public License
  30  * along with this program; if not, write to the Free Software
  31  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  * MA 02111-1307 USA
  33  *
  34  * Copyright 2010 Freescale Semiconductor
  35  * The portions of this file whose copyright is held by Freescale and which
  36  * are not considered a derived work of GPL v2-only code may be distributed
  37  * and/or modified under the terms of the GNU General Public License as
  38  * published by the Free Software Foundation; either version 2 of the
  39  * License, or (at your option) any later version.
  40  */
  41
  42 #include <common.h>
  43 #include <command.h>
  44 #include <watchdog.h>
  45 #include <malloc.h>
  46 #include <div64.h>
  47
  48 #include <asm/errno.h>
  49 #include <linux/mtd/mtd.h>
  50 #include <nand.h>
  51 #include <jffs2/jffs2.h>
  52
  53 typedef struct erase_info       erase_info_t;
  54 typedef struct mtd_info         mtd_info_t;
  55
  56 /* support only for native endian JFFS2 */
  57 #define cpu_to_je16(x) (x)
  58 #define cpu_to_je32(x) (x)
  59
  60 /**
  61  * nand_erase_opts: - erase NAND flash with support for various options
  62  *                    (jffs2 formatting)
  63  *
  64  * @param meminfo       NAND device to erase
  65  * @param opts          options,  @see struct nand_erase_options
  66  * @return              0 in case of success
  67  *
  68  * This code is ported from flash_eraseall.c from Linux mtd utils by
  69  * Arcom Control System Ltd.
  70  */
  71 int nand_erase_opts(nand_info_t *meminfo, const nand_erase_options_t *opts)
  72 {
  73         struct jffs2_unknown_node cleanmarker;
  74         erase_info_t erase;
  75         unsigned long erase_length, erased_length; /* in blocks */
  76         int bbtest = 1;
  77         int result;
  78         int percent_complete = -1;
  79         const char *mtd_device = meminfo->name;
  80         struct mtd_oob_ops oob_opts;
  81         struct nand_chip *chip = meminfo->priv;
  82
  83         if ((opts->offset & (meminfo->erasesize - 1)) != 0) {
  84                 printf("Attempt to erase non block-aligned data\n");
  85                 return -1;
  86         }
  87
  88         memset(&erase, 0, sizeof(erase));
  89         memset(&oob_opts, 0, sizeof(oob_opts));
  90
  91         erase.mtd = meminfo;
  92         erase.len  = meminfo->erasesize;
  93         erase.addr = opts->offset;
  94         erase_length = lldiv(opts->length + meminfo->erasesize - 1,
  95                              meminfo->erasesize);
  96
  97         cleanmarker.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  98         cleanmarker.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
  99         cleanmarker.totlen = cpu_to_je32(8);
 100
 101         /* scrub option allows to erase badblock. To prevent internal
 102          * check from erase() method, set block check method to dummy
 103          * and disable bad block table while erasing.
 104          */
 105         if (opts->scrub) {
 106                 erase.scrub = opts->scrub;
 107                 /*
 108                  * We don't need the bad block table anymore...
 109                  * after scrub, there are no bad blocks left!
 110                  */
 111                 if (chip->bbt) {
 112                         kfree(chip->bbt);
 113                 }
 114                 chip->bbt = NULL;
 115         }
 116
 117         for (erased_length = 0;
 118              erased_length < erase_length;
 119              erase.addr += meminfo->erasesize) {
 120
 121                 WATCHDOG_RESET();
 122
 123                 if (opts->lim && (erase.addr >= (opts->offset + opts->lim))) {
 124                         puts("Size of erase exceeds limit\n");
 125                         return -EFBIG;
 126                 }
 127                 if (!opts->scrub && bbtest) {
 128                         int ret = mtd_block_isbad(meminfo, erase.addr);
 129                         if (ret > 0) {
 130                                 if (!opts->quiet)
 131                                         printf("\rSkipping bad block at  "
 132                                                "0x%08llx                 "
 133                                                "                         \n",
 134                                                erase.addr);
 135
 136                                 if (!opts->spread)
 137                                         erased_length++;
 138
 139                                 continue;
 140
 141                         } else if (ret < 0) {
 142                                 printf("\n%s: MTD get bad block failed: %d\n",
 143                                        mtd_device,
 144                                        ret);
 145                                 return -1;
 146                         }
 147                 }
 148
 149                 erased_length++;
 150
 151                 result = mtd_erase(meminfo, &erase);
 152                 if (result != 0) {
 153                         printf("\n%s: MTD Erase failure: %d\n",
 154                                mtd_device, result);
 155                         continue;
 156                 }
 157
 158                 /* format for JFFS2 ? */
 159                 if (opts->jffs2 && chip->ecc.layout->oobavail >= 8) {
 160                         struct mtd_oob_ops ops;
 161                         ops.ooblen = 8;
 162                         ops.datbuf = NULL;
 163                         ops.oobbuf = (uint8_t *)&cleanmarker;
 164                         ops.ooboffs = 0;
 165                         ops.mode = MTD_OPS_AUTO_OOB;
 166
 167                         result = mtd_write_oob(meminfo,
 168                                                     erase.addr,
 169                                                     &ops);
 170                         if (result != 0) {
 171                                 printf("\n%s: MTD writeoob failure: %d\n",
 172                                        mtd_device, result);
 173                                 continue;
 174                         }
 175                 }
 176
 177                 if (!opts->quiet) {
 178                         unsigned long long n = erased_length * 100ULL;
 179                         int percent;
 180
 181                         do_div(n, erase_length);
 182                         percent = (int)n;
 183
 184                         /* output progress message only at whole percent
 185                          * steps to reduce the number of messages printed
 186                          * on (slow) serial consoles
 187                          */
 188                         if (percent != percent_complete) {
 189                                 percent_complete = percent;
 190
 191                                 printf("\rErasing at 0x%llx -- %3d%% complete.",
 192                                        erase.addr, percent);
 193
 194                                 if (opts->jffs2 && result == 0)
 195                                         printf(" Cleanmarker written at 0x%llx.",
 196                                                erase.addr);
 197                         }
 198                 }
 199         }
 200         if (!opts->quiet)
 201                 printf("\n");
 202
 203         if (opts->scrub)
 204                 chip->scan_bbt(meminfo);
 205
 206         return 0;
 207 }
 208
 209 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
 210
 211 /******************************************************************************
 212  * Support for locking / unlocking operations of some NAND devices
 213  *****************************************************************************/
 214
 215 /**
 216  * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT
 217  *            state
 218  *
 219  * @param mtd           nand mtd instance
 220  * @param tight         bring device in lock tight mode
 221  *
 222  * @return              0 on success, -1 in case of error
 223  *
 224  * The lock / lock-tight command only applies to the whole chip. To get some
 225  * parts of the chip lock and others unlocked use the following sequence:
 226  *
 227  * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin)
 228  * - Call nand_unlock() once for each consecutive area to be unlocked
 229  * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1)
 230  *
 231  *   If the device is in lock-tight state software can't change the
 232  *   current active lock/unlock state of all pages. nand_lock() / nand_unlock()
 233  *   calls will fail. It is only posible to leave lock-tight state by
 234  *   an hardware signal (low pulse on _WP pin) or by power down.
 235  */
 236 int nand_lock(struct mtd_info *mtd, int tight)
 237 {
 238         int ret = 0;
 239         int status;
 240         struct nand_chip *chip = mtd->priv;
 241
 242         /* select the NAND device */
 243         chip->select_chip(mtd, 0);
 244
 245         /* check the Lock Tight Status */
 246         chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, 0);
 247         if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) {
 248                 printf("nand_lock: Device is locked tight!\n");
 249                 ret = -1;
 250                 goto out;
 251         }
 252
 253         chip->cmdfunc(mtd,
 254                       (tight ? NAND_CMD_LOCK_TIGHT : NAND_CMD_LOCK),
 255                       -1, -1);
 256
 257         /* call wait ready function */
 258         status = chip->waitfunc(mtd, chip);
 259
 260         /* see if device thinks it succeeded */
 261         if (status & 0x01) {
 262                 ret = -1;
 263         }
 264
 265  out:
 266         /* de-select the NAND device */
 267         chip->select_chip(mtd, -1);
 268         return ret;
 269 }
 270
 271 /**
 272  * nand_get_lock_status: - query current lock state from one page of NAND
 273  *                         flash
 274  *
 275  * @param mtd           nand mtd instance
 276  * @param offset        page address to query (must be page-aligned!)
 277  *
 278  * @return              -1 in case of error
 279  *                      >0 lock status:
 280  *                        bitfield with the following combinations:
 281  *                        NAND_LOCK_STATUS_TIGHT: page in tight state
 282  *                        NAND_LOCK_STATUS_UNLOCK: page unlocked
 283  *
 284  */
 285 int nand_get_lock_status(struct mtd_info *mtd, loff_t offset)
 286 {
 287         int ret = 0;
 288         int chipnr;
 289         int page;
 290         struct nand_chip *chip = mtd->priv;
 291
 292         /* select the NAND device */
 293         chipnr = (int)(offset >> chip->chip_shift);
 294         chip->select_chip(mtd, chipnr);
 295
 296
 297         if ((offset & (mtd->writesize - 1)) != 0) {
 298                 printf("nand_get_lock_status: "
 299                         "Start address must be beginning of "
 300                         "nand page!\n");
 301                 ret = -1;
 302                 goto out;
 303         }
 304
 305         /* check the Lock Status */
 306         page = (int)(offset >> chip->page_shift);
 307         chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask);
 308
 309         ret = chip->read_byte(mtd) & (NAND_LOCK_STATUS_TIGHT
 310                                           | NAND_LOCK_STATUS_UNLOCK);
 311
 312  out:
 313         /* de-select the NAND device */
 314         chip->select_chip(mtd, -1);
 315         return ret;
 316 }
 317
 318 /**
 319  * nand_unlock: - Unlock area of NAND pages
 320  *                only one consecutive area can be unlocked at one time!
 321  *
 322  * @param mtd           nand mtd instance
 323  * @param start         start byte address
 324  * @param length        number of bytes to unlock (must be a multiple of
 325  *                      page size nand->writesize)
 326  * @param allexcept     if set, unlock everything not selected
 327  *
 328  * @return              0 on success, -1 in case of error
 329  */
 330 int nand_unlock(struct mtd_info *mtd, loff_t start, size_t length,
 331         int allexcept)
 332 {
 333         int ret = 0;
 334         int chipnr;
 335         int status;
 336         int page;
 337         struct nand_chip *chip = mtd->priv;
 338
 339         debug("nand_unlock%s: start: %08llx, length: %d!\n",
 340                 allexcept ? " (allexcept)" : "", start, length);
 341
 342         /* select the NAND device */
 343         chipnr = (int)(start >> chip->chip_shift);
 344         chip->select_chip(mtd, chipnr);
 345
 346         /* check the WP bit */
 347         chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
 348         if (!(chip->read_byte(mtd) & NAND_STATUS_WP)) {
 349                 printf("nand_unlock: Device is write protected!\n");
 350                 ret = -1;
 351                 goto out;
 352         }
 353
 354         /* check the Lock Tight Status */
 355         page = (int)(start >> chip->page_shift);
 356         chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask);
 357         if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) {
 358                 printf("nand_unlock: Device is locked tight!\n");
 359                 ret = -1;
 360                 goto out;
 361         }
 362
 363         if ((start & (mtd->erasesize - 1)) != 0) {
 364                 printf("nand_unlock: Start address must be beginning of "
 365                         "nand block!\n");
 366                 ret = -1;
 367                 goto out;
 368         }
 369
 370         if (length == 0 || (length & (mtd->erasesize - 1)) != 0) {
 371                 printf("nand_unlock: Length must be a multiple of nand block "
 372                         "size %08x!\n", mtd->erasesize);
 373                 ret = -1;
 374                 goto out;
 375         }
 376
 377         /*
 378          * Set length so that the last address is set to the
 379          * starting address of the last block
 380          */
 381         length -= mtd->erasesize;
 382
 383         /* submit address of first page to unlock */
 384         chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask);
 385
 386         /* submit ADDRESS of LAST page to unlock */
 387         page += (int)(length >> chip->page_shift);
 388
 389         /*
 390          * Page addresses for unlocking are supposed to be block-aligned.
 391          * At least some NAND chips use the low bit to indicate that the
 392          * page range should be inverted.
 393          */
 394         if (allexcept)
 395                 page |= 1;
 396
 397         chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1, page & chip->pagemask);
 398
 399         /* call wait ready function */
 400         status = chip->waitfunc(mtd, chip);
 401         /* see if device thinks it succeeded */
 402         if (status & 0x01) {
 403                 /* there was an error */
 404                 ret = -1;
 405                 goto out;
 406         }
 407
 408  out:
 409         /* de-select the NAND device */
 410         chip->select_chip(mtd, -1);
 411         return ret;
 412 }
 413 #endif
 414
 415 /**
 416  * check_skip_len
 417  *
 418  * Check if there are any bad blocks, and whether length including bad
 419  * blocks fits into device
 420  *
 421  * @param nand NAND device
 422  * @param offset offset in flash
 423  * @param length image length
 424  * @param used length of flash needed for the requested length
 425  * @return 0 if the image fits and there are no bad blocks
 426  *         1 if the image fits, but there are bad blocks
 427  *        -1 if the image does not fit
 428  */
 429 static int check_skip_len(nand_info_t *nand, loff_t offset, size_t length,
 430                 size_t *used)
 431 {
 432         size_t len_excl_bad = 0;
 433         int ret = 0;
 434
 435         while (len_excl_bad < length) {
 436                 size_t block_len, block_off;
 437                 loff_t block_start;
 438
 439                 if (offset >= nand->size)
 440                         return -1;
 441
 442                 block_start = offset & ~(loff_t)(nand->erasesize - 1);
 443                 block_off = offset & (nand->erasesize - 1);
 444                 block_len = nand->erasesize - block_off;
 445
 446                 if (!nand_block_isbad(nand, block_start))
 447                         len_excl_bad += block_len;
 448                 else
 449                         ret = 1;
 450
 451                 offset += block_len;
 452                 *used += block_len;
 453         }
 454
 455         /* If the length is not a multiple of block_len, adjust. */
 456         if (len_excl_bad > length)
 457                 *used -= (len_excl_bad - length);
 458
 459         return ret;
 460 }
 461
 462 #ifdef CONFIG_CMD_NAND_TRIMFFS
 463 static size_t drop_ffs(const nand_info_t *nand, const u_char *buf,
 464                         const size_t *len)
 465 {
 466         size_t l = *len;
 467         ssize_t i;
 468
 469         for (i = l - 1; i >= 0; i--)
 470                 if (buf[i] != 0xFF)
 471                         break;
 472
 473         /* The resulting length must be aligned to the minimum flash I/O size */
 474         l = i + 1;
 475         l = (l + nand->writesize - 1) / nand->writesize;
 476         l *=  nand->writesize;
 477
 478         /*
 479          * since the input length may be unaligned, prevent access past the end
 480          * of the buffer
 481          */
 482         return min(l, *len);
 483 }
 484 #endif
 485
 486 /**
 487  * nand_write_skip_bad:
 488  *
 489  * Write image to NAND flash.
 490  * Blocks that are marked bad are skipped and the is written to the next
 491  * block instead as long as the image is short enough to fit even after
 492  * skipping the bad blocks.  Due to bad blocks we may not be able to
 493  * perform the requested write.  In the case where the write would
 494  * extend beyond the end of the NAND device, both length and actual (if
 495  * not NULL) are set to 0.  In the case where the write would extend
 496  * beyond the limit we are passed, length is set to 0 and actual is set
 497  * to the required length.
 498  *
 499  * @param nand          NAND device
 500  * @param offset        offset in flash
 501  * @param length        buffer length
 502  * @param actual        set to size required to write length worth of
 503  *                      buffer or 0 on error, if not NULL
 504  * @param lim           maximum size that actual may be in order to not
 505  *                      exceed the buffer
 506  * @param buffer        buffer to read from
 507  * @param flags         flags modifying the behaviour of the write to NAND
 508  * @return              0 in case of success
 509  */
 510 int nand_write_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
 511                 size_t *actual, loff_t lim, u_char *buffer, int flags)
 512 {
 513         int rval = 0, blocksize;
 514         size_t left_to_write = *length;
 515         size_t used_for_write = 0;
 516         u_char *p_buffer = buffer;
 517         int need_skip;
 518
 519         if (actual)
 520                 *actual = 0;
 521
 522 #ifdef CONFIG_CMD_NAND_YAFFS
 523         if (flags & WITH_YAFFS_OOB) {
 524                 if (flags & ~WITH_YAFFS_OOB)
 525                         return -EINVAL;
 526
 527                 int pages;
 528                 pages = nand->erasesize / nand->writesize;
 529                 blocksize = (pages * nand->oobsize) + nand->erasesize;
 530                 if (*length % (nand->writesize + nand->oobsize)) {
 531                         printf("Attempt to write incomplete page"
 532                                 " in yaffs mode\n");
 533                         return -EINVAL;
 534                 }
 535         } else
 536 #endif
 537         {
 538                 blocksize = nand->erasesize;
 539         }
 540
 541         /*
 542          * nand_write() handles unaligned, partial page writes.
 543          *
 544          * We allow length to be unaligned, for convenience in
 545          * using the $filesize variable.
 546          *
 547          * However, starting at an unaligned offset makes the
 548          * semantics of bad block skipping ambiguous (really,
 549          * you should only start a block skipping access at a
 550          * partition boundary).  So don't try to handle that.
 551          */
 552         if ((offset & (nand->writesize - 1)) != 0) {
 553                 printf("Attempt to write non page-aligned data\n");
 554                 *length = 0;
 555                 return -EINVAL;
 556         }
 557
 558         need_skip = check_skip_len(nand, offset, *length, &used_for_write);
 559
 560         if (actual)
 561                 *actual = used_for_write;
 562
 563         if (need_skip < 0) {
 564                 printf("Attempt to write outside the flash area\n");
 565                 *length = 0;
 566                 return -EINVAL;
 567         }
 568
 569         if (used_for_write > lim) {
 570                 puts("Size of write exceeds partition or device limit\n");
 571                 *length = 0;
 572                 return -EFBIG;
 573         }
 574
 575         if (!need_skip && !(flags & WITH_DROP_FFS)) {
 576                 rval = nand_write(nand, offset, length, buffer);
 577                 if (rval == 0)
 578                         return 0;
 579
 580                 *length = 0;
 581                 printf("NAND write to offset %llx failed %d\n",
 582                         offset, rval);
 583                 return rval;
 584         }
 585
 586         while (left_to_write > 0) {
 587                 size_t block_offset = offset & (nand->erasesize - 1);
 588                 size_t write_size, truncated_write_size;
 589
 590                 WATCHDOG_RESET();
 591
 592                 if (nand_block_isbad(nand, offset & ~(nand->erasesize - 1))) {
 593                         printf("Skip bad block 0x%08llx\n",
 594                                 offset & ~(nand->erasesize - 1));
 595                         offset += nand->erasesize - block_offset;
 596                         continue;
 597                 }
 598
 599                 if (left_to_write < (blocksize - block_offset))
 600                         write_size = left_to_write;
 601                 else
 602                         write_size = blocksize - block_offset;
 603
 604 #ifdef CONFIG_CMD_NAND_YAFFS
 605                 if (flags & WITH_YAFFS_OOB) {
 606                         int page, pages;
 607                         size_t pagesize = nand->writesize;
 608                         size_t pagesize_oob = pagesize + nand->oobsize;
 609                         struct mtd_oob_ops ops;
 610
 611                         ops.len = pagesize;
 612                         ops.ooblen = nand->oobsize;
 613                         ops.mode = MTD_OPS_AUTO_OOB;
 614                         ops.ooboffs = 0;
 615
 616                         pages = write_size / pagesize_oob;
 617                         for (page = 0; page < pages; page++) {
 618                                 WATCHDOG_RESET();
 619
 620                                 ops.datbuf = p_buffer;
 621                                 ops.oobbuf = ops.datbuf + pagesize;
 622
 623                                 rval = mtd_write_oob(nand, offset, &ops);
 624                                 if (rval != 0)
 625                                         break;
 626
 627                                 offset += pagesize;
 628                                 p_buffer += pagesize_oob;
 629                         }
 630                 }
 631                 else
 632 #endif
 633                 {
 634                         truncated_write_size = write_size;
 635 #ifdef CONFIG_CMD_NAND_TRIMFFS
 636                         if (flags & WITH_DROP_FFS)
 637                                 truncated_write_size = drop_ffs(nand, p_buffer,
 638                                                 &write_size);
 639 #endif
 640
 641                         rval = nand_write(nand, offset, &truncated_write_size,
 642                                         p_buffer);
 643                         offset += write_size;
 644                         p_buffer += write_size;
 645                 }
 646
 647                 if (rval != 0) {
 648                         printf("NAND write to offset %llx failed %d\n",
 649                                 offset, rval);
 650                         *length -= left_to_write;
 651                         return rval;
 652                 }
 653
 654                 left_to_write -= write_size;
 655         }
 656
 657         return 0;
 658 }
 659
 660 /**
 661  * nand_read_skip_bad:
 662  *
 663  * Read image from NAND flash.
 664  * Blocks that are marked bad are skipped and the next block is read
 665  * instead as long as the image is short enough to fit even after
 666  * skipping the bad blocks.  Due to bad blocks we may not be able to
 667  * perform the requested read.  In the case where the read would extend
 668  * beyond the end of the NAND device, both length and actual (if not
 669  * NULL) are set to 0.  In the case where the read would extend beyond
 670  * the limit we are passed, length is set to 0 and actual is set to the
 671  * required length.
 672  *
 673  * @param nand NAND device
 674  * @param offset offset in flash
 675  * @param length buffer length, on return holds number of read bytes
 676  * @param actual set to size required to read length worth of buffer or 0
 677  * on error, if not NULL
 678  * @param lim maximum size that actual may be in order to not exceed the
 679  * buffer
 680  * @param buffer buffer to write to
 681  * @return 0 in case of success
 682  */
 683 int nand_read_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
 684                 size_t *actual, loff_t lim, u_char *buffer)
 685 {
 686         int rval;
 687         size_t left_to_read = *length;
 688         size_t used_for_read = 0;
 689         u_char *p_buffer = buffer;
 690         int need_skip;
 691
 692         if ((offset & (nand->writesize - 1)) != 0) {
 693                 printf("Attempt to read non page-aligned data\n");
 694                 *length = 0;
 695                 if (actual)
 696                         *actual = 0;
 697                 return -EINVAL;
 698         }
 699
 700         need_skip = check_skip_len(nand, offset, *length, &used_for_read);
 701
 702         if (actual)
 703                 *actual = used_for_read;
 704
 705         if (need_skip < 0) {
 706                 printf("Attempt to read outside the flash area\n");
 707                 *length = 0;
 708                 return -EINVAL;
 709         }
 710
 711         if (used_for_read > lim) {
 712                 puts("Size of read exceeds partition or device limit\n");
 713                 *length = 0;
 714                 return -EFBIG;
 715         }
 716
 717         if (!need_skip) {
 718                 rval = nand_read(nand, offset, length, buffer);
 719                 if (!rval || rval == -EUCLEAN)
 720                         return 0;
 721
 722                 *length = 0;
 723                 printf("NAND read from offset %llx failed %d\n",
 724                         offset, rval);
 725                 return rval;
 726         }
 727
 728         while (left_to_read > 0) {
 729                 size_t block_offset = offset & (nand->erasesize - 1);
 730                 size_t read_length;
 731
 732                 WATCHDOG_RESET();
 733
 734                 if (nand_block_isbad(nand, offset & ~(nand->erasesize - 1))) {
 735                         printf("Skipping bad block 0x%08llx\n",
 736                                 offset & ~(nand->erasesize - 1));
 737                         offset += nand->erasesize - block_offset;
 738                         continue;
 739                 }
 740
 741                 if (left_to_read < (nand->erasesize - block_offset))
 742                         read_length = left_to_read;
 743                 else
 744                         read_length = nand->erasesize - block_offset;
 745
 746                 rval = nand_read(nand, offset, &read_length, p_buffer);
 747                 if (rval && rval != -EUCLEAN) {
 748                         printf("NAND read from offset %llx failed %d\n",
 749                                 offset, rval);
 750                         *length -= left_to_read;
 751                         return rval;
 752                 }
 753
 754                 left_to_read -= read_length;
 755                 offset       += read_length;
 756                 p_buffer     += read_length;
 757         }
 758
 759         return 0;
 760 }
 761
 762 #ifdef CONFIG_CMD_NAND_TORTURE
 763
 764 /**
 765  * check_pattern:
 766  *
 767  * Check if buffer contains only a certain byte pattern.
 768  *
 769  * @param buf buffer to check
 770  * @param patt the pattern to check
 771  * @param size buffer size in bytes
 772  * @return 1 if there are only patt bytes in buf
 773  *         0 if something else was found
 774  */
 775 static int check_pattern(const u_char *buf, u_char patt, int size)
 776 {
 777         int i;
 778
 779         for (i = 0; i < size; i++)
 780                 if (buf[i] != patt)
 781                         return 0;
 782         return 1;
 783 }
 784
 785 /**
 786  * nand_torture:
 787  *
 788  * Torture a block of NAND flash.
 789  * This is useful to determine if a block that caused a write error is still
 790  * good or should be marked as bad.
 791  *
 792  * @param nand NAND device
 793  * @param offset offset in flash
 794  * @return 0 if the block is still good
 795  */
 796 int nand_torture(nand_info_t *nand, loff_t offset)
 797 {
 798         u_char patterns[] = {0xa5, 0x5a, 0x00};
 799         struct erase_info instr = {
 800                 .mtd = nand,
 801                 .addr = offset,
 802                 .len = nand->erasesize,
 803         };
 804         size_t retlen;
 805         int err, ret = -1, i, patt_count;
 806         u_char *buf;
 807
 808         if ((offset & (nand->erasesize - 1)) != 0) {
 809                 puts("Attempt to torture a block at a non block-aligned offset\n");
 810                 return -EINVAL;
 811         }
 812
 813         if (offset + nand->erasesize > nand->size) {
 814                 puts("Attempt to torture a block outside the flash area\n");
 815                 return -EINVAL;
 816         }
 817
 818         patt_count = ARRAY_SIZE(patterns);
 819
 820         buf = malloc(nand->erasesize);
 821         if (buf == NULL) {
 822                 puts("Out of memory for erase block buffer\n");
 823                 return -ENOMEM;
 824         }
 825
 826         for (i = 0; i < patt_count; i++) {
 827                 err = nand->erase(nand, &instr);
 828                 if (err) {
 829                         printf("%s: erase() failed for block at 0x%llx: %d\n",
 830                                 nand->name, instr.addr, err);
 831                         goto out;
 832                 }
 833
 834                 /* Make sure the block contains only 0xff bytes */
 835                 err = nand->read(nand, offset, nand->erasesize, &retlen, buf);
 836                 if ((err && err != -EUCLEAN) || retlen != nand->erasesize) {
 837                         printf("%s: read() failed for block at 0x%llx: %d\n",
 838                                 nand->name, instr.addr, err);
 839                         goto out;
 840                 }
 841
 842                 err = check_pattern(buf, 0xff, nand->erasesize);
 843                 if (!err) {
 844                         printf("Erased block at 0x%llx, but a non-0xff byte was found\n",
 845                                 offset);
 846                         ret = -EIO;
 847                         goto out;
 848                 }
 849
 850                 /* Write a pattern and check it */
 851                 memset(buf, patterns[i], nand->erasesize);
 852                 err = nand->write(nand, offset, nand->erasesize, &retlen, buf);
 853                 if (err || retlen != nand->erasesize) {
 854                         printf("%s: write() failed for block at 0x%llx: %d\n",
 855                                 nand->name, instr.addr, err);
 856                         goto out;
 857                 }
 858
 859                 err = nand->read(nand, offset, nand->erasesize, &retlen, buf);
 860                 if ((err && err != -EUCLEAN) || retlen != nand->erasesize) {
 861                         printf("%s: read() failed for block at 0x%llx: %d\n",
 862                                 nand->name, instr.addr, err);
 863                         goto out;
 864                 }
 865
 866                 err = check_pattern(buf, patterns[i], nand->erasesize);
 867                 if (!err) {
 868                         printf("Pattern 0x%.2x checking failed for block at "
 869                                         "0x%llx\n", patterns[i], offset);
 870                         ret = -EIO;
 871                         goto out;
 872                 }
 873         }
 874
 875         ret = 0;
 876
 877 out:
 878         free(buf);
 879         return ret;
 880 }
 881
 882 #endif