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