• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/rawnand.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 
79 static int nand_update_bbt(struct mtd_info *mtd, loff_t offs);
80 
bbt_get_entry(struct nand_chip * chip,int block)81 static 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 
bbt_mark_entry(struct nand_chip * chip,int block,uint8_t mark)88 static 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 
check_pattern_no_oob(uint8_t * buf,struct nand_bbt_descr * td)95 static 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  */
check_pattern(uint8_t * buf,int len,int paglen,struct nand_bbt_descr * td)112 static 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  */
check_short_pattern(uint8_t * buf,struct nand_bbt_descr * td)133 static 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  */
add_marker_len(struct nand_bbt_descr * td)147 static 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  */
read_bbt(struct mtd_info * mtd,uint8_t * buf,int page,int num,struct nand_bbt_descr * td,int offs)171 static 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  */
read_abs_bbt(struct mtd_info * mtd,uint8_t * buf,struct nand_bbt_descr * td,int chip)264 static 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 */
scan_read_data(struct mtd_info * mtd,uint8_t * buf,loff_t offs,struct nand_bbt_descr * td)290 static 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  */
scan_read_oob(struct mtd_info * mtd,uint8_t * buf,loff_t offs,size_t len)314 static 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 
scan_read(struct mtd_info * mtd,uint8_t * buf,loff_t offs,size_t len,struct nand_bbt_descr * td)344 static 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 */
scan_write_bbt(struct mtd_info * mtd,loff_t offs,size_t len,uint8_t * buf,uint8_t * oob)354 static 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 
bbt_get_ver_offs(struct mtd_info * mtd,struct nand_bbt_descr * td)369 static 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  */
read_abs_bbts(struct mtd_info * mtd,uint8_t * buf,struct nand_bbt_descr * td,struct nand_bbt_descr * md)388 static 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 */
scan_block_fast(struct mtd_info * mtd,struct nand_bbt_descr * bd,loff_t offs,uint8_t * buf,int numpages)413 static 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  */
create_bbt(struct mtd_info * mtd,uint8_t * buf,struct nand_bbt_descr * bd,int chip)454 static 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  */
search_bbt(struct mtd_info * mtd,uint8_t * buf,struct nand_bbt_descr * td)524 static 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  */
search_read_bbts(struct mtd_info * mtd,uint8_t * buf,struct nand_bbt_descr * td,struct nand_bbt_descr * md)595 static 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  * get_bbt_block - Get the first valid eraseblock suitable to store a BBT
609  * @this: the NAND device
610  * @td: the BBT description
611  * @md: the mirror BBT descriptor
612  * @chip: the CHIP selector
613  *
614  * This functions returns a positive block number pointing a valid eraseblock
615  * suitable to store a BBT (i.e. in the range reserved for BBT), or -ENOSPC if
616  * all blocks are already used of marked bad. If td->pages[chip] was already
617  * pointing to a valid block we re-use it, otherwise we search for the next
618  * valid one.
619  */
get_bbt_block(struct nand_chip * this,struct nand_bbt_descr * td,struct nand_bbt_descr * md,int chip)620 static int get_bbt_block(struct nand_chip *this, struct nand_bbt_descr *td,
621 			 struct nand_bbt_descr *md, int chip)
622 {
623 	int startblock, dir, page, numblocks, i;
624 
625 	/*
626 	 * There was already a version of the table, reuse the page. This
627 	 * applies for absolute placement too, as we have the page number in
628 	 * td->pages.
629 	 */
630 	if (td->pages[chip] != -1)
631 		return td->pages[chip] >>
632 				(this->bbt_erase_shift - this->page_shift);
633 
634 	numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
635 	if (!(td->options & NAND_BBT_PERCHIP))
636 		numblocks *= this->numchips;
637 
638 	/*
639 	 * Automatic placement of the bad block table. Search direction
640 	 * top -> down?
641 	 */
642 	if (td->options & NAND_BBT_LASTBLOCK) {
643 		startblock = numblocks * (chip + 1) - 1;
644 		dir = -1;
645 	} else {
646 		startblock = chip * numblocks;
647 		dir = 1;
648 	}
649 
650 	for (i = 0; i < td->maxblocks; i++) {
651 		int block = startblock + dir * i;
652 
653 		/* Check, if the block is bad */
654 		switch (bbt_get_entry(this, block)) {
655 		case BBT_BLOCK_WORN:
656 		case BBT_BLOCK_FACTORY_BAD:
657 			continue;
658 		}
659 
660 		page = block << (this->bbt_erase_shift - this->page_shift);
661 
662 		/* Check, if the block is used by the mirror table */
663 		if (!md || md->pages[chip] != page)
664 			return block;
665 	}
666 
667 	return -ENOSPC;
668 }
669 
670 /**
671  * mark_bbt_block_bad - Mark one of the block reserved for BBT bad
672  * @this: the NAND device
673  * @td: the BBT description
674  * @chip: the CHIP selector
675  * @block: the BBT block to mark
676  *
677  * Blocks reserved for BBT can become bad. This functions is an helper to mark
678  * such blocks as bad. It takes care of updating the in-memory BBT, marking the
679  * block as bad using a bad block marker and invalidating the associated
680  * td->pages[] entry.
681  */
mark_bbt_block_bad(struct nand_chip * this,struct nand_bbt_descr * td,int chip,int block)682 static void mark_bbt_block_bad(struct nand_chip *this,
683 			       struct nand_bbt_descr *td,
684 			       int chip, int block)
685 {
686 	struct mtd_info *mtd = nand_to_mtd(this);
687 	loff_t to;
688 	int res;
689 
690 	bbt_mark_entry(this, block, BBT_BLOCK_WORN);
691 
692 	to = (loff_t)block << this->bbt_erase_shift;
693 	res = this->block_markbad(mtd, to);
694 	if (res)
695 		pr_warn("nand_bbt: error %d while marking block %d bad\n",
696 			res, block);
697 
698 	td->pages[chip] = -1;
699 }
700 
701 /**
702  * write_bbt - [GENERIC] (Re)write the bad block table
703  * @mtd: MTD device structure
704  * @buf: temporary buffer
705  * @td: descriptor for the bad block table
706  * @md: descriptor for the bad block table mirror
707  * @chipsel: selector for a specific chip, -1 for all
708  *
709  * (Re)write the bad block table.
710  */
write_bbt(struct mtd_info * mtd,uint8_t * buf,struct nand_bbt_descr * td,struct nand_bbt_descr * md,int chipsel)711 static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
712 		     struct nand_bbt_descr *td, struct nand_bbt_descr *md,
713 		     int chipsel)
714 {
715 	struct nand_chip *this = mtd_to_nand(mtd);
716 	struct erase_info einfo;
717 	int i, res, chip = 0;
718 	int bits, page, offs, numblocks, sft, sftmsk;
719 	int nrchips, pageoffs, ooboffs;
720 	uint8_t msk[4];
721 	uint8_t rcode = td->reserved_block_code;
722 	size_t retlen, len = 0;
723 	loff_t to;
724 	struct mtd_oob_ops ops;
725 
726 	ops.ooblen = mtd->oobsize;
727 	ops.ooboffs = 0;
728 	ops.datbuf = NULL;
729 	ops.mode = MTD_OPS_PLACE_OOB;
730 
731 	if (!rcode)
732 		rcode = 0xff;
733 	/* Write bad block table per chip rather than per device? */
734 	if (td->options & NAND_BBT_PERCHIP) {
735 		numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
736 		/* Full device write or specific chip? */
737 		if (chipsel == -1) {
738 			nrchips = this->numchips;
739 		} else {
740 			nrchips = chipsel + 1;
741 			chip = chipsel;
742 		}
743 	} else {
744 		numblocks = (int)(mtd->size >> this->bbt_erase_shift);
745 		nrchips = 1;
746 	}
747 
748 	/* Loop through the chips */
749 	while (chip < nrchips) {
750 		int block;
751 
752 		block = get_bbt_block(this, td, md, chip);
753 		if (block < 0) {
754 			pr_err("No space left to write bad block table\n");
755 			res = block;
756 			goto outerr;
757 		}
758 
759 		/*
760 		 * get_bbt_block() returns a block number, shift the value to
761 		 * get a page number.
762 		 */
763 		page = block << (this->bbt_erase_shift - this->page_shift);
764 
765 		/* Set up shift count and masks for the flash table */
766 		bits = td->options & NAND_BBT_NRBITS_MSK;
767 		msk[2] = ~rcode;
768 		switch (bits) {
769 		case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01;
770 			msk[3] = 0x01;
771 			break;
772 		case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01;
773 			msk[3] = 0x03;
774 			break;
775 		case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C;
776 			msk[3] = 0x0f;
777 			break;
778 		case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F;
779 			msk[3] = 0xff;
780 			break;
781 		default: return -EINVAL;
782 		}
783 
784 		to = ((loff_t)page) << this->page_shift;
785 
786 		/* Must we save the block contents? */
787 		if (td->options & NAND_BBT_SAVECONTENT) {
788 			/* Make it block aligned */
789 			to &= ~(((loff_t)1 << this->bbt_erase_shift) - 1);
790 			len = 1 << this->bbt_erase_shift;
791 			res = mtd_read(mtd, to, len, &retlen, buf);
792 			if (res < 0) {
793 				if (retlen != len) {
794 					pr_info("nand_bbt: error reading block for writing the bad block table\n");
795 					return res;
796 				}
797 				pr_warn("nand_bbt: ECC error while reading block for writing bad block table\n");
798 			}
799 			/* Read oob data */
800 			ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
801 			ops.oobbuf = &buf[len];
802 			res = mtd_read_oob(mtd, to + mtd->writesize, &ops);
803 			if (res < 0 || ops.oobretlen != ops.ooblen)
804 				goto outerr;
805 
806 			/* Calc the byte offset in the buffer */
807 			pageoffs = page - (int)(to >> this->page_shift);
808 			offs = pageoffs << this->page_shift;
809 			/* Preset the bbt area with 0xff */
810 			memset(&buf[offs], 0xff, (size_t)(numblocks >> sft));
811 			ooboffs = len + (pageoffs * mtd->oobsize);
812 
813 		} else if (td->options & NAND_BBT_NO_OOB) {
814 			ooboffs = 0;
815 			offs = td->len;
816 			/* The version byte */
817 			if (td->options & NAND_BBT_VERSION)
818 				offs++;
819 			/* Calc length */
820 			len = (size_t)(numblocks >> sft);
821 			len += offs;
822 			/* Make it page aligned! */
823 			len = ALIGN(len, mtd->writesize);
824 			/* Preset the buffer with 0xff */
825 			memset(buf, 0xff, len);
826 			/* Pattern is located at the begin of first page */
827 			memcpy(buf, td->pattern, td->len);
828 		} else {
829 			/* Calc length */
830 			len = (size_t)(numblocks >> sft);
831 			/* Make it page aligned! */
832 			len = ALIGN(len, mtd->writesize);
833 			/* Preset the buffer with 0xff */
834 			memset(buf, 0xff, len +
835 			       (len >> this->page_shift)* mtd->oobsize);
836 			offs = 0;
837 			ooboffs = len;
838 			/* Pattern is located in oob area of first page */
839 			memcpy(&buf[ooboffs + td->offs], td->pattern, td->len);
840 		}
841 
842 		if (td->options & NAND_BBT_VERSION)
843 			buf[ooboffs + td->veroffs] = td->version[chip];
844 
845 		/* Walk through the memory table */
846 		for (i = 0; i < numblocks; i++) {
847 			uint8_t dat;
848 			int sftcnt = (i << (3 - sft)) & sftmsk;
849 			dat = bbt_get_entry(this, chip * numblocks + i);
850 			/* Do not store the reserved bbt blocks! */
851 			buf[offs + (i >> sft)] &= ~(msk[dat] << sftcnt);
852 		}
853 
854 		memset(&einfo, 0, sizeof(einfo));
855 		einfo.mtd = mtd;
856 		einfo.addr = to;
857 		einfo.len = 1 << this->bbt_erase_shift;
858 		res = nand_erase_nand(mtd, &einfo, 1);
859 		if (res < 0) {
860 			pr_warn("nand_bbt: error while erasing BBT block %d\n",
861 				res);
862 			mark_bbt_block_bad(this, td, chip, block);
863 			continue;
864 		}
865 
866 		res = scan_write_bbt(mtd, to, len, buf,
867 				td->options & NAND_BBT_NO_OOB ? NULL :
868 				&buf[len]);
869 		if (res < 0) {
870 			pr_warn("nand_bbt: error while writing BBT block %d\n",
871 				res);
872 			mark_bbt_block_bad(this, td, chip, block);
873 			continue;
874 		}
875 
876 		pr_info("Bad block table written to 0x%012llx, version 0x%02X\n",
877 			 (unsigned long long)to, td->version[chip]);
878 
879 		/* Mark it as used */
880 		td->pages[chip++] = page;
881 	}
882 	return 0;
883 
884  outerr:
885 	pr_warn("nand_bbt: error while writing bad block table %d\n", res);
886 	return res;
887 }
888 
889 /**
890  * nand_memory_bbt - [GENERIC] create a memory based bad block table
891  * @mtd: MTD device structure
892  * @bd: descriptor for the good/bad block search pattern
893  *
894  * The function creates a memory based bbt by scanning the device for
895  * manufacturer / software marked good / bad blocks.
896  */
nand_memory_bbt(struct mtd_info * mtd,struct nand_bbt_descr * bd)897 static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
898 {
899 	struct nand_chip *this = mtd_to_nand(mtd);
900 
901 	return create_bbt(mtd, this->buffers->databuf, bd, -1);
902 }
903 
904 /**
905  * check_create - [GENERIC] create and write bbt(s) if necessary
906  * @mtd: MTD device structure
907  * @buf: temporary buffer
908  * @bd: descriptor for the good/bad block search pattern
909  *
910  * The function checks the results of the previous call to read_bbt and creates
911  * / updates the bbt(s) if necessary. Creation is necessary if no bbt was found
912  * for the chip/device. Update is necessary if one of the tables is missing or
913  * the version nr. of one table is less than the other.
914  */
check_create(struct mtd_info * mtd,uint8_t * buf,struct nand_bbt_descr * bd)915 static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
916 {
917 	int i, chips, writeops, create, chipsel, res, res2;
918 	struct nand_chip *this = mtd_to_nand(mtd);
919 	struct nand_bbt_descr *td = this->bbt_td;
920 	struct nand_bbt_descr *md = this->bbt_md;
921 	struct nand_bbt_descr *rd, *rd2;
922 
923 	/* Do we have a bbt per chip? */
924 	if (td->options & NAND_BBT_PERCHIP)
925 		chips = this->numchips;
926 	else
927 		chips = 1;
928 
929 	for (i = 0; i < chips; i++) {
930 		writeops = 0;
931 		create = 0;
932 		rd = NULL;
933 		rd2 = NULL;
934 		res = res2 = 0;
935 		/* Per chip or per device? */
936 		chipsel = (td->options & NAND_BBT_PERCHIP) ? i : -1;
937 		/* Mirrored table available? */
938 		if (md) {
939 			if (td->pages[i] == -1 && md->pages[i] == -1) {
940 				create = 1;
941 				writeops = 0x03;
942 			} else if (td->pages[i] == -1) {
943 				rd = md;
944 				writeops = 0x01;
945 			} else if (md->pages[i] == -1) {
946 				rd = td;
947 				writeops = 0x02;
948 			} else if (td->version[i] == md->version[i]) {
949 				rd = td;
950 				if (!(td->options & NAND_BBT_VERSION))
951 					rd2 = md;
952 			} else if (((int8_t)(td->version[i] - md->version[i])) > 0) {
953 				rd = td;
954 				writeops = 0x02;
955 			} else {
956 				rd = md;
957 				writeops = 0x01;
958 			}
959 		} else {
960 			if (td->pages[i] == -1) {
961 				create = 1;
962 				writeops = 0x01;
963 			} else {
964 				rd = td;
965 			}
966 		}
967 
968 		if (create) {
969 			/* Create the bad block table by scanning the device? */
970 			if (!(td->options & NAND_BBT_CREATE))
971 				continue;
972 
973 			/* Create the table in memory by scanning the chip(s) */
974 			if (!(this->bbt_options & NAND_BBT_CREATE_EMPTY))
975 				create_bbt(mtd, buf, bd, chipsel);
976 
977 			td->version[i] = 1;
978 			if (md)
979 				md->version[i] = 1;
980 		}
981 
982 		/* Read back first? */
983 		if (rd) {
984 			res = read_abs_bbt(mtd, buf, rd, chipsel);
985 			if (mtd_is_eccerr(res)) {
986 				/* Mark table as invalid */
987 				rd->pages[i] = -1;
988 				rd->version[i] = 0;
989 				i--;
990 				continue;
991 			}
992 		}
993 		/* If they weren't versioned, read both */
994 		if (rd2) {
995 			res2 = read_abs_bbt(mtd, buf, rd2, chipsel);
996 			if (mtd_is_eccerr(res2)) {
997 				/* Mark table as invalid */
998 				rd2->pages[i] = -1;
999 				rd2->version[i] = 0;
1000 				i--;
1001 				continue;
1002 			}
1003 		}
1004 
1005 		/* Scrub the flash table(s)? */
1006 		if (mtd_is_bitflip(res) || mtd_is_bitflip(res2))
1007 			writeops = 0x03;
1008 
1009 		/* Update version numbers before writing */
1010 		if (md) {
1011 			td->version[i] = max(td->version[i], md->version[i]);
1012 			md->version[i] = td->version[i];
1013 		}
1014 
1015 		/* Write the bad block table to the device? */
1016 		if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
1017 			res = write_bbt(mtd, buf, td, md, chipsel);
1018 			if (res < 0)
1019 				return res;
1020 		}
1021 
1022 		/* Write the mirror bad block table to the device? */
1023 		if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
1024 			res = write_bbt(mtd, buf, md, td, chipsel);
1025 			if (res < 0)
1026 				return res;
1027 		}
1028 	}
1029 	return 0;
1030 }
1031 
1032 /**
1033  * mark_bbt_regions - [GENERIC] mark the bad block table regions
1034  * @mtd: MTD device structure
1035  * @td: bad block table descriptor
1036  *
1037  * The bad block table regions are marked as "bad" to prevent accidental
1038  * erasures / writes. The regions are identified by the mark 0x02.
1039  */
mark_bbt_region(struct mtd_info * mtd,struct nand_bbt_descr * td)1040 static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
1041 {
1042 	struct nand_chip *this = mtd_to_nand(mtd);
1043 	int i, j, chips, block, nrblocks, update;
1044 	uint8_t oldval;
1045 
1046 	/* Do we have a bbt per chip? */
1047 	if (td->options & NAND_BBT_PERCHIP) {
1048 		chips = this->numchips;
1049 		nrblocks = (int)(this->chipsize >> this->bbt_erase_shift);
1050 	} else {
1051 		chips = 1;
1052 		nrblocks = (int)(mtd->size >> this->bbt_erase_shift);
1053 	}
1054 
1055 	for (i = 0; i < chips; i++) {
1056 		if ((td->options & NAND_BBT_ABSPAGE) ||
1057 		    !(td->options & NAND_BBT_WRITE)) {
1058 			if (td->pages[i] == -1)
1059 				continue;
1060 			block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift);
1061 			oldval = bbt_get_entry(this, block);
1062 			bbt_mark_entry(this, block, BBT_BLOCK_RESERVED);
1063 			if ((oldval != BBT_BLOCK_RESERVED) &&
1064 					td->reserved_block_code)
1065 				nand_update_bbt(mtd, (loff_t)block <<
1066 						this->bbt_erase_shift);
1067 			continue;
1068 		}
1069 		update = 0;
1070 		if (td->options & NAND_BBT_LASTBLOCK)
1071 			block = ((i + 1) * nrblocks) - td->maxblocks;
1072 		else
1073 			block = i * nrblocks;
1074 		for (j = 0; j < td->maxblocks; j++) {
1075 			oldval = bbt_get_entry(this, block);
1076 			bbt_mark_entry(this, block, BBT_BLOCK_RESERVED);
1077 			if (oldval != BBT_BLOCK_RESERVED)
1078 				update = 1;
1079 			block++;
1080 		}
1081 		/*
1082 		 * If we want reserved blocks to be recorded to flash, and some
1083 		 * new ones have been marked, then we need to update the stored
1084 		 * bbts.  This should only happen once.
1085 		 */
1086 		if (update && td->reserved_block_code)
1087 			nand_update_bbt(mtd, (loff_t)(block - 1) <<
1088 					this->bbt_erase_shift);
1089 	}
1090 }
1091 
1092 /**
1093  * verify_bbt_descr - verify the bad block description
1094  * @mtd: MTD device structure
1095  * @bd: the table to verify
1096  *
1097  * This functions performs a few sanity checks on the bad block description
1098  * table.
1099  */
verify_bbt_descr(struct mtd_info * mtd,struct nand_bbt_descr * bd)1100 static void verify_bbt_descr(struct mtd_info *mtd, struct nand_bbt_descr *bd)
1101 {
1102 	struct nand_chip *this = mtd_to_nand(mtd);
1103 	u32 pattern_len;
1104 	u32 bits;
1105 	u32 table_size;
1106 
1107 	if (!bd)
1108 		return;
1109 
1110 	pattern_len = bd->len;
1111 	bits = bd->options & NAND_BBT_NRBITS_MSK;
1112 
1113 	BUG_ON((this->bbt_options & NAND_BBT_NO_OOB) &&
1114 			!(this->bbt_options & NAND_BBT_USE_FLASH));
1115 	BUG_ON(!bits);
1116 
1117 	if (bd->options & NAND_BBT_VERSION)
1118 		pattern_len++;
1119 
1120 	if (bd->options & NAND_BBT_NO_OOB) {
1121 		BUG_ON(!(this->bbt_options & NAND_BBT_USE_FLASH));
1122 		BUG_ON(!(this->bbt_options & NAND_BBT_NO_OOB));
1123 		BUG_ON(bd->offs);
1124 		if (bd->options & NAND_BBT_VERSION)
1125 			BUG_ON(bd->veroffs != bd->len);
1126 		BUG_ON(bd->options & NAND_BBT_SAVECONTENT);
1127 	}
1128 
1129 	if (bd->options & NAND_BBT_PERCHIP)
1130 		table_size = this->chipsize >> this->bbt_erase_shift;
1131 	else
1132 		table_size = mtd->size >> this->bbt_erase_shift;
1133 	table_size >>= 3;
1134 	table_size *= bits;
1135 	if (bd->options & NAND_BBT_NO_OOB)
1136 		table_size += pattern_len;
1137 	BUG_ON(table_size > (1 << this->bbt_erase_shift));
1138 }
1139 
1140 /**
1141  * nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)
1142  * @mtd: MTD device structure
1143  * @bd: descriptor for the good/bad block search pattern
1144  *
1145  * The function checks, if a bad block table(s) is/are already available. If
1146  * not it scans the device for manufacturer marked good / bad blocks and writes
1147  * the bad block table(s) to the selected place.
1148  *
1149  * The bad block table memory is allocated here. It must be freed by calling
1150  * the nand_free_bbt function.
1151  */
nand_scan_bbt(struct mtd_info * mtd,struct nand_bbt_descr * bd)1152 static int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
1153 {
1154 	struct nand_chip *this = mtd_to_nand(mtd);
1155 	int len, res;
1156 	uint8_t *buf;
1157 	struct nand_bbt_descr *td = this->bbt_td;
1158 	struct nand_bbt_descr *md = this->bbt_md;
1159 
1160 	len = (mtd->size >> (this->bbt_erase_shift + 2)) ? : 1;
1161 	/*
1162 	 * Allocate memory (2bit per block) and clear the memory bad block
1163 	 * table.
1164 	 */
1165 	this->bbt = kzalloc(len, GFP_KERNEL);
1166 	if (!this->bbt)
1167 		return -ENOMEM;
1168 
1169 	/*
1170 	 * If no primary table decriptor is given, scan the device to build a
1171 	 * memory based bad block table.
1172 	 */
1173 	if (!td) {
1174 		if ((res = nand_memory_bbt(mtd, bd))) {
1175 			pr_err("nand_bbt: can't scan flash and build the RAM-based BBT\n");
1176 			goto err;
1177 		}
1178 		return 0;
1179 	}
1180 	verify_bbt_descr(mtd, td);
1181 	verify_bbt_descr(mtd, md);
1182 
1183 	/* Allocate a temporary buffer for one eraseblock incl. oob */
1184 	len = (1 << this->bbt_erase_shift);
1185 	len += (len >> this->page_shift) * mtd->oobsize;
1186 	buf = vmalloc(len);
1187 	if (!buf) {
1188 		res = -ENOMEM;
1189 		goto err;
1190 	}
1191 
1192 	/* Is the bbt at a given page? */
1193 	if (td->options & NAND_BBT_ABSPAGE) {
1194 		read_abs_bbts(mtd, buf, td, md);
1195 	} else {
1196 		/* Search the bad block table using a pattern in oob */
1197 		search_read_bbts(mtd, buf, td, md);
1198 	}
1199 
1200 	res = check_create(mtd, buf, bd);
1201 	if (res)
1202 		goto err;
1203 
1204 	/* Prevent the bbt regions from erasing / writing */
1205 	mark_bbt_region(mtd, td);
1206 	if (md)
1207 		mark_bbt_region(mtd, md);
1208 
1209 	vfree(buf);
1210 	return 0;
1211 
1212 err:
1213 	kfree(this->bbt);
1214 	this->bbt = NULL;
1215 	return res;
1216 }
1217 
1218 /**
1219  * nand_update_bbt - update bad block table(s)
1220  * @mtd: MTD device structure
1221  * @offs: the offset of the newly marked block
1222  *
1223  * The function updates the bad block table(s).
1224  */
nand_update_bbt(struct mtd_info * mtd,loff_t offs)1225 static int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
1226 {
1227 	struct nand_chip *this = mtd_to_nand(mtd);
1228 	int len, res = 0;
1229 	int chip, chipsel;
1230 	uint8_t *buf;
1231 	struct nand_bbt_descr *td = this->bbt_td;
1232 	struct nand_bbt_descr *md = this->bbt_md;
1233 
1234 	if (!this->bbt || !td)
1235 		return -EINVAL;
1236 
1237 	/* Allocate a temporary buffer for one eraseblock incl. oob */
1238 	len = (1 << this->bbt_erase_shift);
1239 	len += (len >> this->page_shift) * mtd->oobsize;
1240 	buf = kmalloc(len, GFP_KERNEL);
1241 	if (!buf)
1242 		return -ENOMEM;
1243 
1244 	/* Do we have a bbt per chip? */
1245 	if (td->options & NAND_BBT_PERCHIP) {
1246 		chip = (int)(offs >> this->chip_shift);
1247 		chipsel = chip;
1248 	} else {
1249 		chip = 0;
1250 		chipsel = -1;
1251 	}
1252 
1253 	td->version[chip]++;
1254 	if (md)
1255 		md->version[chip]++;
1256 
1257 	/* Write the bad block table to the device? */
1258 	if (td->options & NAND_BBT_WRITE) {
1259 		res = write_bbt(mtd, buf, td, md, chipsel);
1260 		if (res < 0)
1261 			goto out;
1262 	}
1263 	/* Write the mirror bad block table to the device? */
1264 	if (md && (md->options & NAND_BBT_WRITE)) {
1265 		res = write_bbt(mtd, buf, md, td, chipsel);
1266 	}
1267 
1268  out:
1269 	kfree(buf);
1270 	return res;
1271 }
1272 
1273 /*
1274  * Define some generic bad / good block scan pattern which are used
1275  * while scanning a device for factory marked good / bad blocks.
1276  */
1277 static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
1278 
1279 /* Generic flash bbt descriptors */
1280 static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
1281 static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
1282 
1283 static struct nand_bbt_descr bbt_main_descr = {
1284 	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1285 		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1286 	.offs =	8,
1287 	.len = 4,
1288 	.veroffs = 12,
1289 	.maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1290 	.pattern = bbt_pattern
1291 };
1292 
1293 static struct nand_bbt_descr bbt_mirror_descr = {
1294 	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1295 		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1296 	.offs =	8,
1297 	.len = 4,
1298 	.veroffs = 12,
1299 	.maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1300 	.pattern = mirror_pattern
1301 };
1302 
1303 static struct nand_bbt_descr bbt_main_no_oob_descr = {
1304 	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1305 		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1306 		| NAND_BBT_NO_OOB,
1307 	.len = 4,
1308 	.veroffs = 4,
1309 	.maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1310 	.pattern = bbt_pattern
1311 };
1312 
1313 static struct nand_bbt_descr bbt_mirror_no_oob_descr = {
1314 	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1315 		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1316 		| NAND_BBT_NO_OOB,
1317 	.len = 4,
1318 	.veroffs = 4,
1319 	.maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1320 	.pattern = mirror_pattern
1321 };
1322 
1323 #define BADBLOCK_SCAN_MASK (~NAND_BBT_NO_OOB)
1324 /**
1325  * nand_create_badblock_pattern - [INTERN] Creates a BBT descriptor structure
1326  * @this: NAND chip to create descriptor for
1327  *
1328  * This function allocates and initializes a nand_bbt_descr for BBM detection
1329  * based on the properties of @this. The new descriptor is stored in
1330  * this->badblock_pattern. Thus, this->badblock_pattern should be NULL when
1331  * passed to this function.
1332  */
nand_create_badblock_pattern(struct nand_chip * this)1333 static int nand_create_badblock_pattern(struct nand_chip *this)
1334 {
1335 	struct nand_bbt_descr *bd;
1336 	if (this->badblock_pattern) {
1337 		pr_warn("Bad block pattern already allocated; not replacing\n");
1338 		return -EINVAL;
1339 	}
1340 	bd = kzalloc(sizeof(*bd), GFP_KERNEL);
1341 	if (!bd)
1342 		return -ENOMEM;
1343 	bd->options = this->bbt_options & BADBLOCK_SCAN_MASK;
1344 	bd->offs = this->badblockpos;
1345 	bd->len = (this->options & NAND_BUSWIDTH_16) ? 2 : 1;
1346 	bd->pattern = scan_ff_pattern;
1347 	bd->options |= NAND_BBT_DYNAMICSTRUCT;
1348 	this->badblock_pattern = bd;
1349 	return 0;
1350 }
1351 
1352 /**
1353  * nand_default_bbt - [NAND Interface] Select a default bad block table for the device
1354  * @mtd: MTD device structure
1355  *
1356  * This function selects the default bad block table support for the device and
1357  * calls the nand_scan_bbt function.
1358  */
nand_default_bbt(struct mtd_info * mtd)1359 int nand_default_bbt(struct mtd_info *mtd)
1360 {
1361 	struct nand_chip *this = mtd_to_nand(mtd);
1362 	int ret;
1363 
1364 	/* Is a flash based bad block table requested? */
1365 	if (this->bbt_options & NAND_BBT_USE_FLASH) {
1366 		/* Use the default pattern descriptors */
1367 		if (!this->bbt_td) {
1368 			if (this->bbt_options & NAND_BBT_NO_OOB) {
1369 				this->bbt_td = &bbt_main_no_oob_descr;
1370 				this->bbt_md = &bbt_mirror_no_oob_descr;
1371 			} else {
1372 				this->bbt_td = &bbt_main_descr;
1373 				this->bbt_md = &bbt_mirror_descr;
1374 			}
1375 		}
1376 	} else {
1377 		this->bbt_td = NULL;
1378 		this->bbt_md = NULL;
1379 	}
1380 
1381 	if (!this->badblock_pattern) {
1382 		ret = nand_create_badblock_pattern(this);
1383 		if (ret)
1384 			return ret;
1385 	}
1386 
1387 	return nand_scan_bbt(mtd, this->badblock_pattern);
1388 }
1389 
1390 /**
1391  * nand_isreserved_bbt - [NAND Interface] Check if a block is reserved
1392  * @mtd: MTD device structure
1393  * @offs: offset in the device
1394  */
nand_isreserved_bbt(struct mtd_info * mtd,loff_t offs)1395 int nand_isreserved_bbt(struct mtd_info *mtd, loff_t offs)
1396 {
1397 	struct nand_chip *this = mtd_to_nand(mtd);
1398 	int block;
1399 
1400 	block = (int)(offs >> this->bbt_erase_shift);
1401 	return bbt_get_entry(this, block) == BBT_BLOCK_RESERVED;
1402 }
1403 
1404 /**
1405  * nand_isbad_bbt - [NAND Interface] Check if a block is bad
1406  * @mtd: MTD device structure
1407  * @offs: offset in the device
1408  * @allowbbt: allow access to bad block table region
1409  */
nand_isbad_bbt(struct mtd_info * mtd,loff_t offs,int allowbbt)1410 int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
1411 {
1412 	struct nand_chip *this = mtd_to_nand(mtd);
1413 	int block, res;
1414 
1415 	block = (int)(offs >> this->bbt_erase_shift);
1416 	res = bbt_get_entry(this, block);
1417 
1418 	pr_debug("nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n",
1419 		 (unsigned int)offs, block, res);
1420 
1421 	switch (res) {
1422 	case BBT_BLOCK_GOOD:
1423 		return 0;
1424 	case BBT_BLOCK_WORN:
1425 		return 1;
1426 	case BBT_BLOCK_RESERVED:
1427 		return allowbbt ? 0 : 1;
1428 	}
1429 	return 1;
1430 }
1431 
1432 /**
1433  * nand_markbad_bbt - [NAND Interface] Mark a block bad in the BBT
1434  * @mtd: MTD device structure
1435  * @offs: offset of the bad block
1436  */
nand_markbad_bbt(struct mtd_info * mtd,loff_t offs)1437 int nand_markbad_bbt(struct mtd_info *mtd, loff_t offs)
1438 {
1439 	struct nand_chip *this = mtd_to_nand(mtd);
1440 	int block, ret = 0;
1441 
1442 	block = (int)(offs >> this->bbt_erase_shift);
1443 
1444 	/* Mark bad block in memory */
1445 	bbt_mark_entry(this, block, BBT_BLOCK_WORN);
1446 
1447 	/* Update flash-based bad block table */
1448 	if (this->bbt_options & NAND_BBT_USE_FLASH)
1449 		ret = nand_update_bbt(mtd, offs);
1450 
1451 	return ret;
1452 }
1453