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