uboot/drivers/mtd/nand/nand_bbt.c
<<
>>
Prefs
   1/*
   2 *  Overview:
   3 *   Bad block table support for the NAND driver
   4 *
   5 *  Copyright © 2004 Thomas Gleixner (tglx@linutronix.de)
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License version 2 as
   9 * published by the Free Software Foundation.
  10 *
  11 * Description:
  12 *
  13 * When nand_scan_bbt is called, then it tries to find the bad block table
  14 * depending on the options in the BBT descriptor(s). If no flash based BBT
  15 * (NAND_BBT_USE_FLASH) is specified then the device is scanned for factory
  16 * marked good / bad blocks. This information is used to create a memory BBT.
  17 * Once a new bad block is discovered then the "factory" information is updated
  18 * on the device.
  19 * If a flash based BBT is specified then the function first tries to find the
  20 * BBT on flash. If a BBT is found then the contents are read and the memory
  21 * based BBT is created. If a mirrored BBT is selected then the mirror is
  22 * searched too and the versions are compared. If the mirror has a greater
  23 * version number, then the mirror BBT is used to build the memory based BBT.
  24 * If the tables are not versioned, then we "or" the bad block information.
  25 * If one of the BBTs is out of date or does not exist it is (re)created.
  26 * If no BBT exists at all then the device is scanned for factory marked
  27 * good / bad blocks and the bad block tables are created.
  28 *
  29 * For manufacturer created BBTs like the one found on M-SYS DOC devices
  30 * the BBT is searched and read but never created
  31 *
  32 * The auto generated bad block table is located in the last good blocks
  33 * of the device. The table is mirrored, so it can be updated eventually.
  34 * The table is marked in the OOB area with an ident pattern and a version
  35 * number which indicates which of both tables is more up to date. If the NAND
  36 * controller needs the complete OOB area for the ECC information then the
  37 * option NAND_BBT_NO_OOB should be used (along with NAND_BBT_USE_FLASH, of
  38 * course): it moves the ident pattern and the version byte into the data area
  39 * and the OOB area will remain untouched.
  40 *
  41 * The table uses 2 bits per block
  42 * 11b:         block is good
  43 * 00b:         block is factory marked bad
  44 * 01b, 10b:    block is marked bad due to wear
  45 *
  46 * The memory bad block table uses the following scheme:
  47 * 00b:         block is good
  48 * 01b:         block is marked bad due to wear
  49 * 10b:         block is reserved (to protect the bbt area)
  50 * 11b:         block is factory marked bad
  51 *
  52 * Multichip devices like DOC store the bad block info per floor.
  53 *
  54 * Following assumptions are made:
  55 * - bbts start at a page boundary, if autolocated on a block boundary
  56 * - the space necessary for a bbt in FLASH does not exceed a block boundary
  57 *
  58 */
  59
  60#include <common.h>
  61#include <malloc.h>
  62#include <linux/compat.h>
  63#include <linux/mtd/mtd.h>
  64#include <linux/mtd/bbm.h>
  65#include <linux/mtd/rawnand.h>
  66#include <linux/bitops.h>
  67#include <linux/string.h>
  68
  69#define BBT_BLOCK_GOOD          0x00
  70#define BBT_BLOCK_WORN          0x01
  71#define BBT_BLOCK_RESERVED      0x02
  72#define BBT_BLOCK_FACTORY_BAD   0x03
  73
  74#define BBT_ENTRY_MASK          0x03
  75#define BBT_ENTRY_SHIFT         2
  76
  77static int nand_update_bbt(struct mtd_info *mtd, loff_t offs);
  78
  79static inline uint8_t bbt_get_entry(struct nand_chip *chip, int block)
  80{
  81        uint8_t entry = chip->bbt[block >> BBT_ENTRY_SHIFT];
  82        entry >>= (block & BBT_ENTRY_MASK) * 2;
  83        return entry & BBT_ENTRY_MASK;
  84}
  85
  86static inline void bbt_mark_entry(struct nand_chip *chip, int block,
  87                uint8_t mark)
  88{
  89        uint8_t msk = (mark & BBT_ENTRY_MASK) << ((block & BBT_ENTRY_MASK) * 2);
  90        chip->bbt[block >> BBT_ENTRY_SHIFT] |= msk;
  91}
  92
  93static int check_pattern_no_oob(uint8_t *buf, struct nand_bbt_descr *td)
  94{
  95        if (memcmp(buf, td->pattern, td->len))
  96                return -1;
  97        return 0;
  98}
  99
 100/**
 101 * check_pattern - [GENERIC] check if a pattern is in the buffer
 102 * @buf: the buffer to search
 103 * @len: the length of buffer to search
 104 * @paglen: the pagelength
 105 * @td: search pattern descriptor
 106 *
 107 * Check for a pattern at the given place. Used to search bad block tables and
 108 * good / bad block identifiers.
 109 */
 110static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
 111{
 112        if (td->options & NAND_BBT_NO_OOB)
 113                return check_pattern_no_oob(buf, td);
 114
 115        /* Compare the pattern */
 116        if (memcmp(buf + paglen + td->offs, td->pattern, td->len))
 117                return -1;
 118
 119        return 0;
 120}
 121
 122/**
 123 * check_short_pattern - [GENERIC] check if a pattern is in the buffer
 124 * @buf: the buffer to search
 125 * @td: search pattern descriptor
 126 *
 127 * Check for a pattern at the given place. Used to search bad block tables and
 128 * good / bad block identifiers. Same as check_pattern, but no optional empty
 129 * check.
 130 */
 131static int check_short_pattern(uint8_t *buf, struct nand_bbt_descr *td)
 132{
 133        /* Compare the pattern */
 134        if (memcmp(buf + td->offs, td->pattern, td->len))
 135                return -1;
 136        return 0;
 137}
 138
 139/**
 140 * add_marker_len - compute the length of the marker in data area
 141 * @td: BBT descriptor used for computation
 142 *
 143 * The length will be 0 if the marker is located in OOB area.
 144 */
 145static u32 add_marker_len(struct nand_bbt_descr *td)
 146{
 147        u32 len;
 148
 149        if (!(td->options & NAND_BBT_NO_OOB))
 150                return 0;
 151
 152        len = td->len;
 153        if (td->options & NAND_BBT_VERSION)
 154                len++;
 155        return len;
 156}
 157
 158/**
 159 * read_bbt - [GENERIC] Read the bad block table starting from page
 160 * @mtd: MTD device structure
 161 * @buf: temporary buffer
 162 * @page: the starting page
 163 * @num: the number of bbt descriptors to read
 164 * @td: the bbt describtion table
 165 * @offs: block number offset in the table
 166 *
 167 * Read the bad block table starting from page.
 168 */
 169static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
 170                struct nand_bbt_descr *td, int offs)
 171{
 172        int res, ret = 0, i, j, act = 0;
 173        struct nand_chip *this = mtd_to_nand(mtd);
 174        size_t retlen, len, totlen;
 175        loff_t from;
 176        int bits = td->options & NAND_BBT_NRBITS_MSK;
 177        uint8_t msk = (uint8_t)((1 << bits) - 1);
 178        u32 marker_len;
 179        int reserved_block_code = td->reserved_block_code;
 180
 181        totlen = (num * bits) >> 3;
 182        marker_len = add_marker_len(td);
 183        from = ((loff_t)page) << this->page_shift;
 184
 185        while (totlen) {
 186                len = min(totlen, (size_t)(1 << this->bbt_erase_shift));
 187                if (marker_len) {
 188                        /*
 189                         * In case the BBT marker is not in the OOB area it
 190                         * will be just in the first page.
 191                         */
 192                        len -= marker_len;
 193                        from += marker_len;
 194                        marker_len = 0;
 195                }
 196                res = mtd_read(mtd, from, len, &retlen, buf);
 197                if (res < 0) {
 198                        if (mtd_is_eccerr(res)) {
 199                                pr_info("nand_bbt: ECC error in BBT at 0x%012llx\n",
 200                                        from & ~mtd->writesize);
 201                                return res;
 202                        } else if (mtd_is_bitflip(res)) {
 203                                pr_info("nand_bbt: corrected error in BBT at 0x%012llx\n",
 204                                        from & ~mtd->writesize);
 205                                ret = res;
 206                        } else {
 207                                pr_info("nand_bbt: error reading BBT\n");
 208                                return res;
 209                        }
 210                }
 211
 212                /* Analyse data */
 213                for (i = 0; i < len; i++) {
 214                        uint8_t dat = buf[i];
 215                        for (j = 0; j < 8; j += bits, act++) {
 216                                uint8_t tmp = (dat >> j) & msk;
 217                                if (tmp == msk)
 218                                        continue;
 219                                if (reserved_block_code && (tmp == reserved_block_code)) {
 220                                        pr_info("nand_read_bbt: reserved block at 0x%012llx\n",
 221                                                 (loff_t)(offs + act) <<
 222                                                 this->bbt_erase_shift);
 223                                        bbt_mark_entry(this, offs + act,
 224                                                        BBT_BLOCK_RESERVED);
 225                                        mtd->ecc_stats.bbtblocks++;
 226                                        continue;
 227                                }
 228                                /*
 229                                 * Leave it for now, if it's matured we can
 230                                 * move this message to pr_debug.
 231                                 */
 232                                pr_info("nand_read_bbt: bad block at 0x%012llx\n",
 233                                         (loff_t)(offs + act) <<
 234                                         this->bbt_erase_shift);
 235                                /* Factory marked bad or worn out? */
 236                                if (tmp == 0)
 237                                        bbt_mark_entry(this, offs + act,
 238                                                        BBT_BLOCK_FACTORY_BAD);
 239                                else
 240                                        bbt_mark_entry(this, offs + act,
 241                                                        BBT_BLOCK_WORN);
 242                                mtd->ecc_stats.badblocks++;
 243                        }
 244                }
 245                totlen -= len;
 246                from += len;
 247        }
 248        return ret;
 249}
 250
 251/**
 252 * read_abs_bbt - [GENERIC] Read the bad block table starting at a given page
 253 * @mtd: MTD device structure
 254 * @buf: temporary buffer
 255 * @td: descriptor for the bad block table
 256 * @chip: read the table for a specific chip, -1 read all chips; applies only if
 257 *        NAND_BBT_PERCHIP option is set
 258 *
 259 * Read the bad block table for all chips starting at a given page. We assume
 260 * that the bbt bits are in consecutive order.
 261 */
 262static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
 263{
 264        struct nand_chip *this = mtd_to_nand(mtd);
 265        int res = 0, i;
 266
 267        if (td->options & NAND_BBT_PERCHIP) {
 268                int offs = 0;
 269                for (i = 0; i < this->numchips; i++) {
 270                        if (chip == -1 || chip == i)
 271                                res = read_bbt(mtd, buf, td->pages[i],
 272                                        this->chipsize >> this->bbt_erase_shift,
 273                                        td, offs);
 274                        if (res)
 275                                return res;
 276                        offs += this->chipsize >> this->bbt_erase_shift;
 277                }
 278        } else {
 279                res = read_bbt(mtd, buf, td->pages[0],
 280                                mtd->size >> this->bbt_erase_shift, td, 0);
 281                if (res)
 282                        return res;
 283        }
 284        return 0;
 285}
 286
 287/* BBT marker is in the first page, no OOB */
 288static int scan_read_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
 289                         struct nand_bbt_descr *td)
 290{
 291        size_t retlen;
 292        size_t len;
 293
 294        len = td->len;
 295        if (td->options & NAND_BBT_VERSION)
 296                len++;
 297
 298        return mtd_read(mtd, offs, len, &retlen, buf);
 299}
 300
 301/**
 302 * scan_read_oob - [GENERIC] Scan data+OOB region to buffer
 303 * @mtd: MTD device structure
 304 * @buf: temporary buffer
 305 * @offs: offset at which to scan
 306 * @len: length of data region to read
 307 *
 308 * Scan read data from data+OOB. May traverse multiple pages, interleaving
 309 * page,OOB,page,OOB,... in buf. Completes transfer and returns the "strongest"
 310 * ECC condition (error or bitflip). May quit on the first (non-ECC) error.
 311 */
 312static int scan_read_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
 313                         size_t len)
 314{
 315        struct mtd_oob_ops ops;
 316        int res, ret = 0;
 317
 318        ops.mode = MTD_OPS_PLACE_OOB;
 319        ops.ooboffs = 0;
 320        ops.ooblen = mtd->oobsize;
 321
 322        while (len > 0) {
 323                ops.datbuf = buf;
 324                ops.len = min(len, (size_t)mtd->writesize);
 325                ops.oobbuf = buf + ops.len;
 326
 327                res = mtd_read_oob(mtd, offs, &ops);
 328                if (res) {
 329                        if (!mtd_is_bitflip_or_eccerr(res))
 330                                return res;
 331                        else if (mtd_is_eccerr(res) || !ret)
 332                                ret = res;
 333                }
 334
 335                buf += mtd->oobsize + mtd->writesize;
 336                len -= mtd->writesize;
 337                offs += mtd->writesize;
 338        }
 339        return ret;
 340}
 341
 342static int scan_read(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
 343                         size_t len, struct nand_bbt_descr *td)
 344{
 345        if (td->options & NAND_BBT_NO_OOB)
 346                return scan_read_data(mtd, buf, offs, td);
 347        else
 348                return scan_read_oob(mtd, buf, offs, len);
 349}
 350
 351/* Scan write data with oob to flash */
 352static int scan_write_bbt(struct mtd_info *mtd, loff_t offs, size_t len,
 353                          uint8_t *buf, uint8_t *oob)
 354{
 355        struct mtd_oob_ops ops;
 356
 357        ops.mode = MTD_OPS_PLACE_OOB;
 358        ops.ooboffs = 0;
 359        ops.ooblen = mtd->oobsize;
 360        ops.datbuf = buf;
 361        ops.oobbuf = oob;
 362        ops.len = len;
 363
 364        return mtd_write_oob(mtd, offs, &ops);
 365}
 366
 367static u32 bbt_get_ver_offs(struct mtd_info *mtd, struct nand_bbt_descr *td)
 368{
 369        u32 ver_offs = td->veroffs;
 370
 371        if (!(td->options & NAND_BBT_NO_OOB))
 372                ver_offs += mtd->writesize;
 373        return ver_offs;
 374}
 375
 376/**
 377 * read_abs_bbts - [GENERIC] Read the bad block table(s) for all chips starting at a given page
 378 * @mtd: MTD device structure
 379 * @buf: temporary buffer
 380 * @td: descriptor for the bad block table
 381 * @md: descriptor for the bad block table mirror
 382 *
 383 * Read the bad block table(s) for all chips starting at a given page. We
 384 * assume that the bbt bits are in consecutive order.
 385 */
 386static void read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
 387                          struct nand_bbt_descr *td, struct nand_bbt_descr *md)
 388{
 389        struct nand_chip *this = mtd_to_nand(mtd);
 390
 391        /* Read the primary version, if available */
 392        if (td->options & NAND_BBT_VERSION) {
 393                scan_read(mtd, buf, (loff_t)td->pages[0] << this->page_shift,
 394                              mtd->writesize, td);
 395                td->version[0] = buf[bbt_get_ver_offs(mtd, td)];
 396                pr_info("Bad block table at page %d, version 0x%02X\n",
 397                         td->pages[0], td->version[0]);
 398        }
 399
 400        /* Read the mirror version, if available */
 401        if (md && (md->options & NAND_BBT_VERSION)) {
 402                scan_read(mtd, buf, (loff_t)md->pages[0] << this->page_shift,
 403                              mtd->writesize, md);
 404                md->version[0] = buf[bbt_get_ver_offs(mtd, md)];
 405                pr_info("Bad block table at page %d, version 0x%02X\n",
 406                         md->pages[0], md->version[0]);
 407        }
 408}
 409
 410/* Scan a given block partially */
 411static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
 412                           loff_t offs, uint8_t *buf, int numpages)
 413{
 414        struct mtd_oob_ops ops;
 415        int j, ret;
 416
 417        ops.ooblen = mtd->oobsize;
 418        ops.oobbuf = buf;
 419        ops.ooboffs = 0;
 420        ops.datbuf = NULL;
 421        ops.mode = MTD_OPS_PLACE_OOB;
 422
 423        for (j = 0; j < numpages; j++) {
 424                /*
 425                 * Read the full oob until read_oob is fixed to handle single
 426                 * byte reads for 16 bit buswidth.
 427                 */
 428                ret = mtd_read_oob(mtd, offs, &ops);
 429                /* Ignore ECC errors when checking for BBM */
 430                if (ret && !mtd_is_bitflip_or_eccerr(ret))
 431                        return ret;
 432
 433                if (check_short_pattern(buf, bd))
 434                        return 1;
 435
 436                offs += mtd->writesize;
 437        }
 438        return 0;
 439}
 440
 441/**
 442 * create_bbt - [GENERIC] Create a bad block table by scanning the device
 443 * @mtd: MTD device structure
 444 * @buf: temporary buffer
 445 * @bd: descriptor for the good/bad block search pattern
 446 * @chip: create the table for a specific chip, -1 read all chips; applies only
 447 *        if NAND_BBT_PERCHIP option is set
 448 *
 449 * Create a bad block table by scanning the device for the given good/bad block
 450 * identify pattern.
 451 */
 452static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
 453        struct nand_bbt_descr *bd, int chip)
 454{
 455        struct nand_chip *this = mtd_to_nand(mtd);
 456        int i, numblocks, numpages;
 457        int startblock;
 458        loff_t from;
 459
 460        pr_info("Scanning device for bad blocks\n");
 461
 462        if (bd->options & NAND_BBT_SCAN2NDPAGE)
 463                numpages = 2;
 464        else
 465                numpages = 1;
 466
 467        if (chip == -1) {
 468                numblocks = mtd->size >> this->bbt_erase_shift;
 469                startblock = 0;
 470                from = 0;
 471        } else {
 472                if (chip >= this->numchips) {
 473                        pr_warn("create_bbt(): chipnr (%d) > available chips (%d)\n",
 474                               chip + 1, this->numchips);
 475                        return -EINVAL;
 476                }
 477                numblocks = this->chipsize >> this->bbt_erase_shift;
 478                startblock = chip * numblocks;
 479                numblocks += startblock;
 480                from = (loff_t)startblock << this->bbt_erase_shift;
 481        }
 482
 483        if (this->bbt_options & NAND_BBT_SCANLASTPAGE)
 484                from += mtd->erasesize - (mtd->writesize * numpages);
 485
 486        for (i = startblock; i < numblocks; i++) {
 487                int ret;
 488
 489                BUG_ON(bd->options & NAND_BBT_NO_OOB);
 490
 491                ret = scan_block_fast(mtd, bd, from, buf, numpages);
 492                if (ret < 0)
 493                        return ret;
 494
 495                if (ret) {
 496                        bbt_mark_entry(this, i, BBT_BLOCK_FACTORY_BAD);
 497                        pr_warn("Bad eraseblock %d at 0x%012llx\n",
 498                                i, (unsigned long long)from);
 499                        mtd->ecc_stats.badblocks++;
 500                }
 501
 502                from += (1 << this->bbt_erase_shift);
 503        }
 504        return 0;
 505}
 506
 507/**
 508 * search_bbt - [GENERIC] scan the device for a specific bad block table
 509 * @mtd: MTD device structure
 510 * @buf: temporary buffer
 511 * @td: descriptor for the bad block table
 512 *
 513 * Read the bad block table by searching for a given ident pattern. Search is
 514 * preformed either from the beginning up or from the end of the device
 515 * downwards. The search starts always at the start of a block. If the option
 516 * NAND_BBT_PERCHIP is given, each chip is searched for a bbt, which contains
 517 * the bad block information of this chip. This is necessary to provide support
 518 * for certain DOC devices.
 519 *
 520 * The bbt ident pattern resides in the oob area of the first page in a block.
 521 */
 522static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
 523{
 524        struct nand_chip *this = mtd_to_nand(mtd);
 525        int i, chips;
 526        int startblock, block, dir;
 527        int scanlen = mtd->writesize + mtd->oobsize;
 528        int bbtblocks;
 529        int blocktopage = this->bbt_erase_shift - this->page_shift;
 530
 531        /* Search direction top -> down? */
 532        if (td->options & NAND_BBT_LASTBLOCK) {
 533                startblock = (mtd->size >> this->bbt_erase_shift) - 1;
 534                dir = -1;
 535        } else {
 536                startblock = 0;
 537                dir = 1;
 538        }
 539
 540        /* Do we have a bbt per chip? */
 541        if (td->options & NAND_BBT_PERCHIP) {
 542                chips = this->numchips;
 543                bbtblocks = this->chipsize >> this->bbt_erase_shift;
 544                startblock &= bbtblocks - 1;
 545        } else {
 546                chips = 1;
 547                bbtblocks = mtd->size >> this->bbt_erase_shift;
 548        }
 549
 550        for (i = 0; i < chips; i++) {
 551                /* Reset version information */
 552                td->version[i] = 0;
 553                td->pages[i] = -1;
 554                /* Scan the maximum number of blocks */
 555                for (block = 0; block < td->maxblocks; block++) {
 556
 557                        int actblock = startblock + dir * block;
 558                        loff_t offs = (loff_t)actblock << this->bbt_erase_shift;
 559
 560                        /* Read first page */
 561                        scan_read(mtd, buf, offs, mtd->writesize, td);
 562                        if (!check_pattern(buf, scanlen, mtd->writesize, td)) {
 563                                td->pages[i] = actblock << blocktopage;
 564                                if (td->options & NAND_BBT_VERSION) {
 565                                        offs = bbt_get_ver_offs(mtd, td);
 566                                        td->version[i] = buf[offs];
 567                                }
 568                                break;
 569                        }
 570                }
 571                startblock += this->chipsize >> this->bbt_erase_shift;
 572        }
 573        /* Check, if we found a bbt for each requested chip */
 574        for (i = 0; i < chips; i++) {
 575                if (td->pages[i] == -1)
 576                        pr_warn("Bad block table not found for chip %d\n", i);
 577                else
 578                        pr_info("Bad block table found at page %d, version 0x%02X\n",
 579                                td->pages[i], td->version[i]);
 580        }
 581        return 0;
 582}
 583
 584/**
 585 * search_read_bbts - [GENERIC] scan the device for bad block table(s)
 586 * @mtd: MTD device structure
 587 * @buf: temporary buffer
 588 * @td: descriptor for the bad block table
 589 * @md: descriptor for the bad block table mirror
 590 *
 591 * Search and read the bad block table(s).
 592 */
 593static void search_read_bbts(struct mtd_info *mtd, uint8_t *buf,
 594                             struct nand_bbt_descr *td,
 595                             struct nand_bbt_descr *md)
 596{
 597        /* Search the primary table */
 598        search_bbt(mtd, buf, td);
 599
 600        /* Search the mirror table */
 601        if (md)
 602                search_bbt(mtd, buf, md);
 603}
 604
 605/**
 606 * write_bbt - [GENERIC] (Re)write the bad block table
 607 * @mtd: MTD device structure
 608 * @buf: temporary buffer
 609 * @td: descriptor for the bad block table
 610 * @md: descriptor for the bad block table mirror
 611 * @chipsel: selector for a specific chip, -1 for all
 612 *
 613 * (Re)write the bad block table.
 614 */
 615static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
 616                     struct nand_bbt_descr *td, struct nand_bbt_descr *md,
 617                     int chipsel)
 618{
 619        struct nand_chip *this = mtd_to_nand(mtd);
 620        struct erase_info einfo;
 621        int i, res, chip = 0;
 622        int bits, startblock, dir, page, offs, numblocks, sft, sftmsk;
 623        int nrchips, pageoffs, ooboffs;
 624        uint8_t msk[4];
 625        uint8_t rcode = td->reserved_block_code;
 626        size_t retlen, len = 0;
 627        loff_t to;
 628        struct mtd_oob_ops ops;
 629
 630        ops.ooblen = mtd->oobsize;
 631        ops.ooboffs = 0;
 632        ops.datbuf = NULL;
 633        ops.mode = MTD_OPS_PLACE_OOB;
 634
 635        if (!rcode)
 636                rcode = 0xff;
 637        /* Write bad block table per chip rather than per device? */
 638        if (td->options & NAND_BBT_PERCHIP) {
 639                numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
 640                /* Full device write or specific chip? */
 641                if (chipsel == -1) {
 642                        nrchips = this->numchips;
 643                } else {
 644                        nrchips = chipsel + 1;
 645                        chip = chipsel;
 646                }
 647        } else {
 648                numblocks = (int)(mtd->size >> this->bbt_erase_shift);
 649                nrchips = 1;
 650        }
 651
 652        /* Loop through the chips */
 653        for (; chip < nrchips; chip++) {
 654                /*
 655                 * There was already a version of the table, reuse the page
 656                 * This applies for absolute placement too, as we have the
 657                 * page nr. in td->pages.
 658                 */
 659                if (td->pages[chip] != -1) {
 660                        page = td->pages[chip];
 661                        goto write;
 662                }
 663
 664                /*
 665                 * Automatic placement of the bad block table. Search direction
 666                 * top -> down?
 667                 */
 668                if (td->options & NAND_BBT_LASTBLOCK) {
 669                        startblock = numblocks * (chip + 1) - 1;
 670                        dir = -1;
 671                } else {
 672                        startblock = chip * numblocks;
 673                        dir = 1;
 674                }
 675
 676                for (i = 0; i < td->maxblocks; i++) {
 677                        int block = startblock + dir * i;
 678                        /* Check, if the block is bad */
 679                        switch (bbt_get_entry(this, block)) {
 680                        case BBT_BLOCK_WORN:
 681                        case BBT_BLOCK_FACTORY_BAD:
 682                                continue;
 683                        }
 684                        page = block <<
 685                                (this->bbt_erase_shift - this->page_shift);
 686                        /* Check, if the block is used by the mirror table */
 687                        if (!md || md->pages[chip] != page)
 688                                goto write;
 689                }
 690                pr_err("No space left to write bad block table\n");
 691                return -ENOSPC;
 692        write:
 693
 694                /* Set up shift count and masks for the flash table */
 695                bits = td->options & NAND_BBT_NRBITS_MSK;
 696                msk[2] = ~rcode;
 697                switch (bits) {
 698                case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01;
 699                        msk[3] = 0x01;
 700                        break;
 701                case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01;
 702                        msk[3] = 0x03;
 703                        break;
 704                case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C;
 705                        msk[3] = 0x0f;
 706                        break;
 707                case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F;
 708                        msk[3] = 0xff;
 709                        break;
 710                default: return -EINVAL;
 711                }
 712
 713                to = ((loff_t)page) << this->page_shift;
 714
 715                /* Must we save the block contents? */
 716                if (td->options & NAND_BBT_SAVECONTENT) {
 717                        /* Make it block aligned */
 718                        to &= ~(((loff_t)1 << this->bbt_erase_shift) - 1);
 719                        len = 1 << this->bbt_erase_shift;
 720                        res = mtd_read(mtd, to, len, &retlen, buf);
 721                        if (res < 0) {
 722                                if (retlen != len) {
 723                                        pr_info("nand_bbt: error reading block for writing the bad block table\n");
 724                                        return res;
 725                                }
 726                                pr_warn("nand_bbt: ECC error while reading block for writing bad block table\n");
 727                        }
 728                        /* Read oob data */
 729                        ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
 730                        ops.oobbuf = &buf[len];
 731                        res = mtd_read_oob(mtd, to + mtd->writesize, &ops);
 732                        if (res < 0 || ops.oobretlen != ops.ooblen)
 733                                goto outerr;
 734
 735                        /* Calc the byte offset in the buffer */
 736                        pageoffs = page - (int)(to >> this->page_shift);
 737                        offs = pageoffs << this->page_shift;
 738                        /* Preset the bbt area with 0xff */
 739                        memset(&buf[offs], 0xff, (size_t)(numblocks >> sft));
 740                        ooboffs = len + (pageoffs * mtd->oobsize);
 741
 742                } else if (td->options & NAND_BBT_NO_OOB) {
 743                        ooboffs = 0;
 744                        offs = td->len;
 745                        /* The version byte */
 746                        if (td->options & NAND_BBT_VERSION)
 747                                offs++;
 748                        /* Calc length */
 749                        len = (size_t)(numblocks >> sft);
 750                        len += offs;
 751                        /* Make it page aligned! */
 752                        len = ALIGN(len, mtd->writesize);
 753                        /* Preset the buffer with 0xff */
 754                        memset(buf, 0xff, len);
 755                        /* Pattern is located at the begin of first page */
 756                        memcpy(buf, td->pattern, td->len);
 757                } else {
 758                        /* Calc length */
 759                        len = (size_t)(numblocks >> sft);
 760                        /* Make it page aligned! */
 761                        len = ALIGN(len, mtd->writesize);
 762                        /* Preset the buffer with 0xff */
 763                        memset(buf, 0xff, len +
 764                               (len >> this->page_shift)* mtd->oobsize);
 765                        offs = 0;
 766                        ooboffs = len;
 767                        /* Pattern is located in oob area of first page */
 768                        memcpy(&buf[ooboffs + td->offs], td->pattern, td->len);
 769                }
 770
 771                if (td->options & NAND_BBT_VERSION)
 772                        buf[ooboffs + td->veroffs] = td->version[chip];
 773
 774                /* Walk through the memory table */
 775                for (i = 0; i < numblocks; i++) {
 776                        uint8_t dat;
 777                        int sftcnt = (i << (3 - sft)) & sftmsk;
 778                        dat = bbt_get_entry(this, chip * numblocks + i);
 779                        /* Do not store the reserved bbt blocks! */
 780                        buf[offs + (i >> sft)] &= ~(msk[dat] << sftcnt);
 781                }
 782
 783                memset(&einfo, 0, sizeof(einfo));
 784                einfo.mtd = mtd;
 785                einfo.addr = to;
 786                einfo.len = 1 << this->bbt_erase_shift;
 787                res = nand_erase_nand(mtd, &einfo, 1);
 788                if (res < 0)
 789                        goto outerr;
 790
 791                res = scan_write_bbt(mtd, to, len, buf,
 792                                td->options & NAND_BBT_NO_OOB ? NULL :
 793                                &buf[len]);
 794                if (res < 0)
 795                        goto outerr;
 796
 797                pr_info("Bad block table written to 0x%012llx, version 0x%02X\n",
 798                         (unsigned long long)to, td->version[chip]);
 799
 800                /* Mark it as used */
 801                td->pages[chip] = page;
 802        }
 803        return 0;
 804
 805 outerr:
 806        pr_warn("nand_bbt: error while writing bad block table %d\n", res);
 807        return res;
 808}
 809
 810/**
 811 * nand_memory_bbt - [GENERIC] create a memory based bad block table
 812 * @mtd: MTD device structure
 813 * @bd: descriptor for the good/bad block search pattern
 814 *
 815 * The function creates a memory based bbt by scanning the device for
 816 * manufacturer / software marked good / bad blocks.
 817 */
 818static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
 819{
 820        struct nand_chip *this = mtd_to_nand(mtd);
 821
 822        return create_bbt(mtd, this->buffers->databuf, bd, -1);
 823}
 824
 825/**
 826 * check_create - [GENERIC] create and write bbt(s) if necessary
 827 * @mtd: MTD device structure
 828 * @buf: temporary buffer
 829 * @bd: descriptor for the good/bad block search pattern
 830 *
 831 * The function checks the results of the previous call to read_bbt and creates
 832 * / updates the bbt(s) if necessary. Creation is necessary if no bbt was found
 833 * for the chip/device. Update is necessary if one of the tables is missing or
 834 * the version nr. of one table is less than the other.
 835 */
 836static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
 837{
 838        int i, chips, writeops, create, chipsel, res, res2;
 839        struct nand_chip *this = mtd_to_nand(mtd);
 840        struct nand_bbt_descr *td = this->bbt_td;
 841        struct nand_bbt_descr *md = this->bbt_md;
 842        struct nand_bbt_descr *rd, *rd2;
 843
 844        /* Do we have a bbt per chip? */
 845        if (td->options & NAND_BBT_PERCHIP)
 846                chips = this->numchips;
 847        else
 848                chips = 1;
 849
 850        for (i = 0; i < chips; i++) {
 851                writeops = 0;
 852                create = 0;
 853                rd = NULL;
 854                rd2 = NULL;
 855                res = res2 = 0;
 856                /* Per chip or per device? */
 857                chipsel = (td->options & NAND_BBT_PERCHIP) ? i : -1;
 858                /* Mirrored table available? */
 859                if (md) {
 860                        if (td->pages[i] == -1 && md->pages[i] == -1) {
 861                                create = 1;
 862                                writeops = 0x03;
 863                        } else if (td->pages[i] == -1) {
 864                                rd = md;
 865                                writeops = 0x01;
 866                        } else if (md->pages[i] == -1) {
 867                                rd = td;
 868                                writeops = 0x02;
 869                        } else if (td->version[i] == md->version[i]) {
 870                                rd = td;
 871                                if (!(td->options & NAND_BBT_VERSION))
 872                                        rd2 = md;
 873                        } else if (((int8_t)(td->version[i] - md->version[i])) > 0) {
 874                                rd = td;
 875                                writeops = 0x02;
 876                        } else {
 877                                rd = md;
 878                                writeops = 0x01;
 879                        }
 880                } else {
 881                        if (td->pages[i] == -1) {
 882                                create = 1;
 883                                writeops = 0x01;
 884                        } else {
 885                                rd = td;
 886                        }
 887                }
 888
 889                if (create) {
 890                        /* Create the bad block table by scanning the device? */
 891                        if (!(td->options & NAND_BBT_CREATE))
 892                                continue;
 893
 894                        /* Create the table in memory by scanning the chip(s) */
 895                        if (!(this->bbt_options & NAND_BBT_CREATE_EMPTY))
 896                                create_bbt(mtd, buf, bd, chipsel);
 897
 898                        td->version[i] = 1;
 899                        if (md)
 900                                md->version[i] = 1;
 901                }
 902
 903                /* Read back first? */
 904                if (rd) {
 905                        res = read_abs_bbt(mtd, buf, rd, chipsel);
 906                        if (mtd_is_eccerr(res)) {
 907                                /* Mark table as invalid */
 908                                rd->pages[i] = -1;
 909                                rd->version[i] = 0;
 910                                i--;
 911                                continue;
 912                        }
 913                }
 914                /* If they weren't versioned, read both */
 915                if (rd2) {
 916                        res2 = read_abs_bbt(mtd, buf, rd2, chipsel);
 917                        if (mtd_is_eccerr(res2)) {
 918                                /* Mark table as invalid */
 919                                rd2->pages[i] = -1;
 920                                rd2->version[i] = 0;
 921                                i--;
 922                                continue;
 923                        }
 924                }
 925
 926                /* Scrub the flash table(s)? */
 927                if (mtd_is_bitflip(res) || mtd_is_bitflip(res2))
 928                        writeops = 0x03;
 929
 930                /* Update version numbers before writing */
 931                if (md) {
 932                        td->version[i] = max(td->version[i], md->version[i]);
 933                        md->version[i] = td->version[i];
 934                }
 935
 936                /* Write the bad block table to the device? */
 937                if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
 938                        res = write_bbt(mtd, buf, td, md, chipsel);
 939                        if (res < 0)
 940                                return res;
 941                }
 942
 943                /* Write the mirror bad block table to the device? */
 944                if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
 945                        res = write_bbt(mtd, buf, md, td, chipsel);
 946                        if (res < 0)
 947                                return res;
 948                }
 949        }
 950        return 0;
 951}
 952
 953/**
 954 * mark_bbt_regions - [GENERIC] mark the bad block table regions
 955 * @mtd: MTD device structure
 956 * @td: bad block table descriptor
 957 *
 958 * The bad block table regions are marked as "bad" to prevent accidental
 959 * erasures / writes. The regions are identified by the mark 0x02.
 960 */
 961static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
 962{
 963        struct nand_chip *this = mtd_to_nand(mtd);
 964        int i, j, chips, block, nrblocks, update;
 965        uint8_t oldval;
 966
 967        /* Do we have a bbt per chip? */
 968        if (td->options & NAND_BBT_PERCHIP) {
 969                chips = this->numchips;
 970                nrblocks = (int)(this->chipsize >> this->bbt_erase_shift);
 971        } else {
 972                chips = 1;
 973                nrblocks = (int)(mtd->size >> this->bbt_erase_shift);
 974        }
 975
 976        for (i = 0; i < chips; i++) {
 977                if ((td->options & NAND_BBT_ABSPAGE) ||
 978                    !(td->options & NAND_BBT_WRITE)) {
 979                        if (td->pages[i] == -1)
 980                                continue;
 981                        block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift);
 982                        oldval = bbt_get_entry(this, block);
 983                        bbt_mark_entry(this, block, BBT_BLOCK_RESERVED);
 984                        if ((oldval != BBT_BLOCK_RESERVED) &&
 985                                        td->reserved_block_code)
 986                                nand_update_bbt(mtd, (loff_t)block <<
 987                                                this->bbt_erase_shift);
 988                        continue;
 989                }
 990                update = 0;
 991                if (td->options & NAND_BBT_LASTBLOCK)
 992                        block = ((i + 1) * nrblocks) - td->maxblocks;
 993                else
 994                        block = i * nrblocks;
 995                for (j = 0; j < td->maxblocks; j++) {
 996                        oldval = bbt_get_entry(this, block);
 997                        bbt_mark_entry(this, block, BBT_BLOCK_RESERVED);
 998                        if (oldval != BBT_BLOCK_RESERVED)
 999                                update = 1;
1000                        block++;
1001                }
1002                /*
1003                 * If we want reserved blocks to be recorded to flash, and some
1004                 * new ones have been marked, then we need to update the stored
1005                 * bbts.  This should only happen once.
1006                 */
1007                if (update && td->reserved_block_code)
1008                        nand_update_bbt(mtd, (loff_t)(block - 1) <<
1009                                        this->bbt_erase_shift);
1010        }
1011}
1012
1013/**
1014 * verify_bbt_descr - verify the bad block description
1015 * @mtd: MTD device structure
1016 * @bd: the table to verify
1017 *
1018 * This functions performs a few sanity checks on the bad block description
1019 * table.
1020 */
1021static void verify_bbt_descr(struct mtd_info *mtd, struct nand_bbt_descr *bd)
1022{
1023        struct nand_chip *this = mtd_to_nand(mtd);
1024        u32 pattern_len;
1025        u32 bits;
1026        u32 table_size;
1027
1028        if (!bd)
1029                return;
1030
1031        pattern_len = bd->len;
1032        bits = bd->options & NAND_BBT_NRBITS_MSK;
1033
1034        BUG_ON((this->bbt_options & NAND_BBT_NO_OOB) &&
1035                        !(this->bbt_options & NAND_BBT_USE_FLASH));
1036        BUG_ON(!bits);
1037
1038        if (bd->options & NAND_BBT_VERSION)
1039                pattern_len++;
1040
1041        if (bd->options & NAND_BBT_NO_OOB) {
1042                BUG_ON(!(this->bbt_options & NAND_BBT_USE_FLASH));
1043                BUG_ON(!(this->bbt_options & NAND_BBT_NO_OOB));
1044                BUG_ON(bd->offs);
1045                if (bd->options & NAND_BBT_VERSION)
1046                        BUG_ON(bd->veroffs != bd->len);
1047                BUG_ON(bd->options & NAND_BBT_SAVECONTENT);
1048        }
1049
1050        if (bd->options & NAND_BBT_PERCHIP)
1051                table_size = this->chipsize >> this->bbt_erase_shift;
1052        else
1053                table_size = mtd->size >> this->bbt_erase_shift;
1054        table_size >>= 3;
1055        table_size *= bits;
1056        if (bd->options & NAND_BBT_NO_OOB)
1057                table_size += pattern_len;
1058        BUG_ON(table_size > (1 << this->bbt_erase_shift));
1059}
1060
1061/**
1062 * nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)
1063 * @mtd: MTD device structure
1064 * @bd: descriptor for the good/bad block search pattern
1065 *
1066 * The function checks, if a bad block table(s) is/are already available. If
1067 * not it scans the device for manufacturer marked good / bad blocks and writes
1068 * the bad block table(s) to the selected place.
1069 *
1070 * The bad block table memory is allocated here. It must be freed by calling
1071 * the nand_free_bbt function.
1072 */
1073static int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
1074{
1075        struct nand_chip *this = mtd_to_nand(mtd);
1076        int len, res;
1077        uint8_t *buf;
1078        struct nand_bbt_descr *td = this->bbt_td;
1079        struct nand_bbt_descr *md = this->bbt_md;
1080
1081        len = (mtd->size >> (this->bbt_erase_shift + 2)) ? : 1;
1082        /*
1083         * Allocate memory (2bit per block) and clear the memory bad block
1084         * table.
1085         */
1086        this->bbt = kzalloc(len, GFP_KERNEL);
1087        if (!this->bbt)
1088                return -ENOMEM;
1089
1090        /*
1091         * If no primary table decriptor is given, scan the device to build a
1092         * memory based bad block table.
1093         */
1094        if (!td) {
1095                if ((res = nand_memory_bbt(mtd, bd))) {
1096                        pr_err("nand_bbt: can't scan flash and build the RAM-based BBT\n");
1097                        goto err;
1098                }
1099                return 0;
1100        }
1101        verify_bbt_descr(mtd, td);
1102        verify_bbt_descr(mtd, md);
1103
1104        /* Allocate a temporary buffer for one eraseblock incl. oob */
1105        len = (1 << this->bbt_erase_shift);
1106        len += (len >> this->page_shift) * mtd->oobsize;
1107        buf = vmalloc(len);
1108        if (!buf) {
1109                res = -ENOMEM;
1110                goto err;
1111        }
1112
1113        /* Is the bbt at a given page? */
1114        if (td->options & NAND_BBT_ABSPAGE) {
1115                read_abs_bbts(mtd, buf, td, md);
1116        } else {
1117                /* Search the bad block table using a pattern in oob */
1118                search_read_bbts(mtd, buf, td, md);
1119        }
1120
1121        res = check_create(mtd, buf, bd);
1122        if (res)
1123                goto err;
1124
1125        /* Prevent the bbt regions from erasing / writing */
1126        mark_bbt_region(mtd, td);
1127        if (md)
1128                mark_bbt_region(mtd, md);
1129
1130        vfree(buf);
1131        return 0;
1132
1133err:
1134        kfree(this->bbt);
1135        this->bbt = NULL;
1136        return res;
1137}
1138
1139/**
1140 * nand_update_bbt - update bad block table(s)
1141 * @mtd: MTD device structure
1142 * @offs: the offset of the newly marked block
1143 *
1144 * The function updates the bad block table(s).
1145 */
1146static int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
1147{
1148        struct nand_chip *this = mtd_to_nand(mtd);
1149        int len, res = 0;
1150        int chip, chipsel;
1151        uint8_t *buf;
1152        struct nand_bbt_descr *td = this->bbt_td;
1153        struct nand_bbt_descr *md = this->bbt_md;
1154
1155        if (!this->bbt || !td)
1156                return -EINVAL;
1157
1158        /* Allocate a temporary buffer for one eraseblock incl. oob */
1159        len = (1 << this->bbt_erase_shift);
1160        len += (len >> this->page_shift) * mtd->oobsize;
1161        buf = kmalloc(len, GFP_KERNEL);
1162        if (!buf)
1163                return -ENOMEM;
1164
1165        /* Do we have a bbt per chip? */
1166        if (td->options & NAND_BBT_PERCHIP) {
1167                chip = (int)(offs >> this->chip_shift);
1168                chipsel = chip;
1169        } else {
1170                chip = 0;
1171                chipsel = -1;
1172        }
1173
1174        td->version[chip]++;
1175        if (md)
1176                md->version[chip]++;
1177
1178        /* Write the bad block table to the device? */
1179        if (td->options & NAND_BBT_WRITE) {
1180                res = write_bbt(mtd, buf, td, md, chipsel);
1181                if (res < 0)
1182                        goto out;
1183        }
1184        /* Write the mirror bad block table to the device? */
1185        if (md && (md->options & NAND_BBT_WRITE)) {
1186                res = write_bbt(mtd, buf, md, td, chipsel);
1187        }
1188
1189 out:
1190        kfree(buf);
1191        return res;
1192}
1193
1194/*
1195 * Define some generic bad / good block scan pattern which are used
1196 * while scanning a device for factory marked good / bad blocks.
1197 */
1198static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
1199
1200/* Generic flash bbt descriptors */
1201static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
1202static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
1203
1204static struct nand_bbt_descr bbt_main_descr = {
1205        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1206                | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1207        .offs = 8,
1208        .len = 4,
1209        .veroffs = 12,
1210        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1211        .pattern = bbt_pattern
1212};
1213
1214static struct nand_bbt_descr bbt_mirror_descr = {
1215        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1216                | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1217        .offs = 8,
1218        .len = 4,
1219        .veroffs = 12,
1220        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1221        .pattern = mirror_pattern
1222};
1223
1224static struct nand_bbt_descr bbt_main_no_oob_descr = {
1225        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1226                | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1227                | NAND_BBT_NO_OOB,
1228        .len = 4,
1229        .veroffs = 4,
1230        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1231        .pattern = bbt_pattern
1232};
1233
1234static struct nand_bbt_descr bbt_mirror_no_oob_descr = {
1235        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1236                | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1237                | NAND_BBT_NO_OOB,
1238        .len = 4,
1239        .veroffs = 4,
1240        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1241        .pattern = mirror_pattern
1242};
1243
1244#define BADBLOCK_SCAN_MASK (~NAND_BBT_NO_OOB)
1245/**
1246 * nand_create_badblock_pattern - [INTERN] Creates a BBT descriptor structure
1247 * @this: NAND chip to create descriptor for
1248 *
1249 * This function allocates and initializes a nand_bbt_descr for BBM detection
1250 * based on the properties of @this. The new descriptor is stored in
1251 * this->badblock_pattern. Thus, this->badblock_pattern should be NULL when
1252 * passed to this function.
1253 */
1254static int nand_create_badblock_pattern(struct nand_chip *this)
1255{
1256        struct nand_bbt_descr *bd;
1257        if (this->badblock_pattern) {
1258                pr_warn("Bad block pattern already allocated; not replacing\n");
1259                return -EINVAL;
1260        }
1261        bd = kzalloc(sizeof(*bd), GFP_KERNEL);
1262        if (!bd)
1263                return -ENOMEM;
1264        bd->options = this->bbt_options & BADBLOCK_SCAN_MASK;
1265        bd->offs = this->badblockpos;
1266        bd->len = (this->options & NAND_BUSWIDTH_16) ? 2 : 1;
1267        bd->pattern = scan_ff_pattern;
1268        bd->options |= NAND_BBT_DYNAMICSTRUCT;
1269        this->badblock_pattern = bd;
1270        return 0;
1271}
1272
1273/**
1274 * nand_default_bbt - [NAND Interface] Select a default bad block table for the device
1275 * @mtd: MTD device structure
1276 *
1277 * This function selects the default bad block table support for the device and
1278 * calls the nand_scan_bbt function.
1279 */
1280int nand_default_bbt(struct mtd_info *mtd)
1281{
1282        struct nand_chip *this = mtd_to_nand(mtd);
1283        int ret;
1284
1285        /* Is a flash based bad block table requested? */
1286        if (this->bbt_options & NAND_BBT_USE_FLASH) {
1287                /* Use the default pattern descriptors */
1288                if (!this->bbt_td) {
1289                        if (this->bbt_options & NAND_BBT_NO_OOB) {
1290                                this->bbt_td = &bbt_main_no_oob_descr;
1291                                this->bbt_md = &bbt_mirror_no_oob_descr;
1292                        } else {
1293                                this->bbt_td = &bbt_main_descr;
1294                                this->bbt_md = &bbt_mirror_descr;
1295                        }
1296                }
1297        } else {
1298                this->bbt_td = NULL;
1299                this->bbt_md = NULL;
1300        }
1301
1302        if (!this->badblock_pattern) {
1303                ret = nand_create_badblock_pattern(this);
1304                if (ret)
1305                        return ret;
1306        }
1307
1308        return nand_scan_bbt(mtd, this->badblock_pattern);
1309}
1310
1311/**
1312 * nand_isreserved_bbt - [NAND Interface] Check if a block is reserved
1313 * @mtd: MTD device structure
1314 * @offs: offset in the device
1315 */
1316int nand_isreserved_bbt(struct mtd_info *mtd, loff_t offs)
1317{
1318        struct nand_chip *this = mtd_to_nand(mtd);
1319        int block;
1320
1321        block = (int)(offs >> this->bbt_erase_shift);
1322        return bbt_get_entry(this, block) == BBT_BLOCK_RESERVED;
1323}
1324
1325/**
1326 * nand_isbad_bbt - [NAND Interface] Check if a block is bad
1327 * @mtd: MTD device structure
1328 * @offs: offset in the device
1329 * @allowbbt: allow access to bad block table region
1330 */
1331int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
1332{
1333        struct nand_chip *this = mtd_to_nand(mtd);
1334        int block, res;
1335
1336        block = (int)(offs >> this->bbt_erase_shift);
1337        res = bbt_get_entry(this, block);
1338
1339        pr_debug("nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n",
1340                 (unsigned int)offs, block, res);
1341
1342        switch (res) {
1343        case BBT_BLOCK_GOOD:
1344                return 0;
1345        case BBT_BLOCK_WORN:
1346                return 1;
1347        case BBT_BLOCK_RESERVED:
1348                return allowbbt ? 0 : 1;
1349        }
1350        return 1;
1351}
1352
1353/**
1354 * nand_markbad_bbt - [NAND Interface] Mark a block bad in the BBT
1355 * @mtd: MTD device structure
1356 * @offs: offset of the bad block
1357 */
1358int nand_markbad_bbt(struct mtd_info *mtd, loff_t offs)
1359{
1360        struct nand_chip *this = mtd_to_nand(mtd);
1361        int block, ret = 0;
1362
1363        block = (int)(offs >> this->bbt_erase_shift);
1364
1365        /* Mark bad block in memory */
1366        bbt_mark_entry(this, block, BBT_BLOCK_WORN);
1367
1368        /* Update flash-based bad block table */
1369        if (this->bbt_options & NAND_BBT_USE_FLASH)
1370                ret = nand_update_bbt(mtd, offs);
1371
1372        return ret;
1373}
1374