Loading...
Note: File does not exist in v6.8.
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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_to_nand(mtd);
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}