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