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