nand_bbt.c 38.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *  drivers/mtd/nand_bbt.c
 *
 *  Overview:
 *   Bad block table support for the NAND driver
6
 *
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14
 *  Copyright (C) 2004 Thomas Gleixner (tglx@linutronix.de)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Description:
 *
15
 * When nand_scan_bbt is called, then it tries to find the bad block table
16
 * depending on the options in the BBT descriptor(s). If no flash based BBT
17
 * (NAND_BBT_USE_FLASH) is specified then the device is scanned for factory
18 19 20 21 22 23 24
 * marked good / bad blocks. This information is used to create a memory BBT.
 * Once a new bad block is discovered then the "factory" information is updated
 * on the device.
 * If a flash based BBT is specified then the function first tries to find the
 * BBT on flash. If a BBT is found then the contents are read and the memory
 * based BBT is created. If a mirrored BBT is selected then the mirror is
 * searched too and the versions are compared. If the mirror has a greater
H
Huang Shijie 已提交
25
 * version number, then the mirror BBT is used to build the memory based BBT.
L
Linus Torvalds 已提交
26
 * If the tables are not versioned, then we "or" the bad block information.
27 28
 * If one of the BBTs is out of date or does not exist it is (re)created.
 * If no BBT exists at all then the device is scanned for factory marked
29
 * good / bad blocks and the bad block tables are created.
L
Linus Torvalds 已提交
30
 *
31 32
 * For manufacturer created BBTs like the one found on M-SYS DOC devices
 * the BBT is searched and read but never created
L
Linus Torvalds 已提交
33
 *
34
 * The auto generated bad block table is located in the last good blocks
35
 * of the device. The table is mirrored, so it can be updated eventually.
36 37 38
 * The table is marked in the OOB area with an ident pattern and a version
 * number which indicates which of both tables is more up to date. If the NAND
 * controller needs the complete OOB area for the ECC information then the
39
 * option NAND_BBT_NO_OOB should be used (along with NAND_BBT_USE_FLASH, of
40 41
 * course): it moves the ident pattern and the version byte into the data area
 * and the OOB area will remain untouched.
L
Linus Torvalds 已提交
42 43
 *
 * The table uses 2 bits per block
44 45 46
 * 11b:		block is good
 * 00b:		block is factory marked bad
 * 01b, 10b:	block is marked bad due to wear
L
Linus Torvalds 已提交
47 48 49 50 51 52
 *
 * The memory bad block table uses the following scheme:
 * 00b:		block is good
 * 01b:		block is marked bad due to wear
 * 10b:		block is reserved (to protect the bbt area)
 * 11b:		block is factory marked bad
53
 *
L
Linus Torvalds 已提交
54 55 56 57
 * Multichip devices like DOC store the bad block info per floor.
 *
 * Following assumptions are made:
 * - bbts start at a page boundary, if autolocated on a block boundary
58
 * - the space necessary for a bbt in FLASH does not exceed a block boundary
59
 *
L
Linus Torvalds 已提交
60 61 62 63 64 65 66 67 68
 */

#include <linux/slab.h>
#include <linux/types.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/nand.h>
#include <linux/mtd/nand_ecc.h>
#include <linux/bitops.h>
#include <linux/delay.h>
69
#include <linux/vmalloc.h>
70
#include <linux/export.h>
B
Brian Norris 已提交
71
#include <linux/string.h>
L
Linus Torvalds 已提交
72

73 74
static int check_pattern_no_oob(uint8_t *buf, struct nand_bbt_descr *td)
{
75 76 77
	if (memcmp(buf, td->pattern, td->len))
		return -1;
	return 0;
78 79
}

80
/**
L
Linus Torvalds 已提交
81
 * check_pattern - [GENERIC] check if a pattern is in the buffer
82 83 84 85
 * @buf: the buffer to search
 * @len: the length of buffer to search
 * @paglen: the pagelength
 * @td: search pattern descriptor
L
Linus Torvalds 已提交
86
 *
87 88 89 90
 * Check for a pattern at the given place. Used to search bad block tables and
 * good / bad block identifiers. If the SCAN_EMPTY option is set then check, if
 * all bytes except the pattern area contain 0xff.
 */
91
static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
L
Linus Torvalds 已提交
92
{
B
Brian Norris 已提交
93
	int end = 0;
L
Linus Torvalds 已提交
94 95
	uint8_t *p = buf;

96 97 98
	if (td->options & NAND_BBT_NO_OOB)
		return check_pattern_no_oob(buf, td);

99
	end = paglen + td->offs;
B
Brian Norris 已提交
100 101 102
	if (td->options & NAND_BBT_SCANEMPTY)
		if (memchr_inv(p, 0xff, end))
			return -1;
103
	p += end;
104

L
Linus Torvalds 已提交
105
	/* Compare the pattern */
106 107
	if (memcmp(p, td->pattern, td->len))
		return -1;
108

L
Linus Torvalds 已提交
109
	if (td->options & NAND_BBT_SCANEMPTY) {
110 111
		p += td->len;
		end += td->len;
B
Brian Norris 已提交
112 113
		if (memchr_inv(p, 0xff, len - end))
			return -1;
L
Linus Torvalds 已提交
114 115 116 117
	}
	return 0;
}

118
/**
119
 * check_short_pattern - [GENERIC] check if a pattern is in the buffer
120 121
 * @buf: the buffer to search
 * @td:	search pattern descriptor
122
 *
123 124 125 126
 * Check for a pattern at the given place. Used to search bad block tables and
 * good / bad block identifiers. Same as check_pattern, but no optional empty
 * check.
 */
127
static int check_short_pattern(uint8_t *buf, struct nand_bbt_descr *td)
128 129
{
	/* Compare the pattern */
B
Brian Norris 已提交
130 131
	if (memcmp(buf + td->offs, td->pattern, td->len))
		return -1;
132 133 134
	return 0;
}

135 136
/**
 * add_marker_len - compute the length of the marker in data area
137
 * @td: BBT descriptor used for computation
138
 *
139
 * The length will be 0 if the marker is located in OOB area.
140 141 142 143 144 145 146 147 148 149 150 151 152 153
 */
static u32 add_marker_len(struct nand_bbt_descr *td)
{
	u32 len;

	if (!(td->options & NAND_BBT_NO_OOB))
		return 0;

	len = td->len;
	if (td->options & NAND_BBT_VERSION)
		len++;
	return len;
}

L
Linus Torvalds 已提交
154 155
/**
 * read_bbt - [GENERIC] Read the bad block table starting from page
156 157 158 159
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @page: the starting page
 * @num: the number of bbt descriptors to read
160
 * @td: the bbt describtion table
161
 * @offs: offset in the memory table
L
Linus Torvalds 已提交
162 163 164
 *
 * Read the bad block table starting from page.
 */
165
static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
166
		struct nand_bbt_descr *td, int offs)
L
Linus Torvalds 已提交
167
{
168
	int res, ret = 0, i, j, act = 0;
L
Linus Torvalds 已提交
169 170 171
	struct nand_chip *this = mtd->priv;
	size_t retlen, len, totlen;
	loff_t from;
172
	int bits = td->options & NAND_BBT_NRBITS_MSK;
B
Brian Norris 已提交
173
	uint8_t msk = (uint8_t)((1 << bits) - 1);
174
	u32 marker_len;
175
	int reserved_block_code = td->reserved_block_code;
L
Linus Torvalds 已提交
176 177

	totlen = (num * bits) >> 3;
178
	marker_len = add_marker_len(td);
B
Brian Norris 已提交
179
	from = ((loff_t)page) << this->page_shift;
180

L
Linus Torvalds 已提交
181
	while (totlen) {
B
Brian Norris 已提交
182
		len = min(totlen, (size_t)(1 << this->bbt_erase_shift));
183 184 185 186 187 188 189 190 191
		if (marker_len) {
			/*
			 * In case the BBT marker is not in the OOB area it
			 * will be just in the first page.
			 */
			len -= marker_len;
			from += marker_len;
			marker_len = 0;
		}
192
		res = mtd_read(mtd, from, len, &retlen, buf);
L
Linus Torvalds 已提交
193
		if (res < 0) {
194 195 196 197 198 199 200 201 202 203
			if (mtd_is_eccerr(res)) {
				pr_info("nand_bbt: ECC error in BBT at "
					"0x%012llx\n", from & ~mtd->writesize);
				return res;
			} else if (mtd_is_bitflip(res)) {
				pr_info("nand_bbt: corrected error in BBT at "
					"0x%012llx\n", from & ~mtd->writesize);
				ret = res;
			} else {
				pr_info("nand_bbt: error reading BBT\n");
L
Linus Torvalds 已提交
204 205
				return res;
			}
206
		}
L
Linus Torvalds 已提交
207 208 209 210 211 212 213 214

		/* Analyse data */
		for (i = 0; i < len; i++) {
			uint8_t dat = buf[i];
			for (j = 0; j < 8; j += bits, act += 2) {
				uint8_t tmp = (dat >> j) & msk;
				if (tmp == msk)
					continue;
215
				if (reserved_block_code && (tmp == reserved_block_code)) {
216 217
					pr_info("nand_read_bbt: reserved block at 0x%012llx\n",
						 (loff_t)((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
L
Linus Torvalds 已提交
218
					this->bbt[offs + (act >> 3)] |= 0x2 << (act & 0x06);
219
					mtd->ecc_stats.bbtblocks++;
L
Linus Torvalds 已提交
220 221
					continue;
				}
222 223
				/*
				 * Leave it for now, if it's matured we can
224
				 * move this message to pr_debug.
225
				 */
226 227
				pr_info("nand_read_bbt: bad block at 0x%012llx\n",
					 (loff_t)((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
228
				/* Factory marked bad or worn out? */
L
Linus Torvalds 已提交
229 230 231 232
				if (tmp == 0)
					this->bbt[offs + (act >> 3)] |= 0x3 << (act & 0x06);
				else
					this->bbt[offs + (act >> 3)] |= 0x1 << (act & 0x06);
233
				mtd->ecc_stats.badblocks++;
234
			}
L
Linus Torvalds 已提交
235 236 237 238
		}
		totlen -= len;
		from += len;
	}
239
	return ret;
L
Linus Torvalds 已提交
240 241 242 243
}

/**
 * read_abs_bbt - [GENERIC] Read the bad block table starting at a given page
244 245 246
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @td: descriptor for the bad block table
B
Brian Norris 已提交
247
 * @chip: read the table for a specific chip, -1 read all chips; applies only if
248
 *        NAND_BBT_PERCHIP option is set
L
Linus Torvalds 已提交
249
 *
250 251 252
 * Read the bad block table for all chips starting at a given page. We assume
 * that the bbt bits are in consecutive order.
 */
253
static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
L
Linus Torvalds 已提交
254 255 256 257 258 259 260 261
{
	struct nand_chip *this = mtd->priv;
	int res = 0, i;

	if (td->options & NAND_BBT_PERCHIP) {
		int offs = 0;
		for (i = 0; i < this->numchips; i++) {
			if (chip == -1 || chip == i)
262 263 264
				res = read_bbt(mtd, buf, td->pages[i],
					this->chipsize >> this->bbt_erase_shift,
					td, offs);
L
Linus Torvalds 已提交
265 266 267 268 269
			if (res)
				return res;
			offs += this->chipsize >> (this->bbt_erase_shift + 2);
		}
	} else {
270 271
		res = read_bbt(mtd, buf, td->pages[0],
				mtd->size >> this->bbt_erase_shift, td, 0);
L
Linus Torvalds 已提交
272 273 274 275 276 277
		if (res)
			return res;
	}
	return 0;
}

278
/* BBT marker is in the first page, no OOB */
279 280 281 282 283 284 285 286 287 288
static int scan_read_raw_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
			 struct nand_bbt_descr *td)
{
	size_t retlen;
	size_t len;

	len = td->len;
	if (td->options & NAND_BBT_VERSION)
		len++;

289
	return mtd_read(mtd, offs, len, &retlen, buf);
290 291
}

292
/* Scan read raw data from flash */
293
static int scan_read_raw_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
294 295 296
			 size_t len)
{
	struct mtd_oob_ops ops;
297
	int res;
298

299
	ops.mode = MTD_OPS_RAW;
300 301 302
	ops.ooboffs = 0;
	ops.ooblen = mtd->oobsize;

303
	while (len > 0) {
B
Brian Norris 已提交
304 305 306
		ops.datbuf = buf;
		ops.len = min(len, (size_t)mtd->writesize);
		ops.oobbuf = buf + ops.len;
307

308
		res = mtd_read_oob(mtd, offs, &ops);
309

310
		if (res)
B
Brian Norris 已提交
311
			return res;
312 313 314

		buf += mtd->oobsize + mtd->writesize;
		len -= mtd->writesize;
D
Dmitry Maluka 已提交
315
		offs += mtd->writesize;
316 317
	}
	return 0;
318 319
}

320 321 322 323 324 325 326 327 328
static int scan_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
			 size_t len, struct nand_bbt_descr *td)
{
	if (td->options & NAND_BBT_NO_OOB)
		return scan_read_raw_data(mtd, buf, offs, td);
	else
		return scan_read_raw_oob(mtd, buf, offs, len);
}

329
/* Scan write data with oob to flash */
330 331 332 333 334
static int scan_write_bbt(struct mtd_info *mtd, loff_t offs, size_t len,
			  uint8_t *buf, uint8_t *oob)
{
	struct mtd_oob_ops ops;

335
	ops.mode = MTD_OPS_PLACE_OOB;
336 337 338 339 340 341
	ops.ooboffs = 0;
	ops.ooblen = mtd->oobsize;
	ops.datbuf = buf;
	ops.oobbuf = oob;
	ops.len = len;

342
	return mtd_write_oob(mtd, offs, &ops);
343 344
}

345 346 347 348 349 350 351 352 353
static u32 bbt_get_ver_offs(struct mtd_info *mtd, struct nand_bbt_descr *td)
{
	u32 ver_offs = td->veroffs;

	if (!(td->options & NAND_BBT_NO_OOB))
		ver_offs += mtd->writesize;
	return ver_offs;
}

L
Linus Torvalds 已提交
354 355
/**
 * read_abs_bbts - [GENERIC] Read the bad block table(s) for all chips starting at a given page
356 357 358 359
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @td: descriptor for the bad block table
 * @md:	descriptor for the bad block table mirror
L
Linus Torvalds 已提交
360
 *
361 362 363
 * Read the bad block table(s) for all chips starting at a given page. We
 * assume that the bbt bits are in consecutive order.
 */
364 365
static void read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
			  struct nand_bbt_descr *td, struct nand_bbt_descr *md)
L
Linus Torvalds 已提交
366 367 368
{
	struct nand_chip *this = mtd->priv;

369
	/* Read the primary version, if available */
L
Linus Torvalds 已提交
370
	if (td->options & NAND_BBT_VERSION) {
371
		scan_read_raw(mtd, buf, (loff_t)td->pages[0] << this->page_shift,
372 373
			      mtd->writesize, td);
		td->version[0] = buf[bbt_get_ver_offs(mtd, td)];
374
		pr_info("Bad block table at page %d, version 0x%02X\n",
375
			 td->pages[0], td->version[0]);
L
Linus Torvalds 已提交
376 377
	}

378
	/* Read the mirror version, if available */
L
Linus Torvalds 已提交
379
	if (md && (md->options & NAND_BBT_VERSION)) {
380
		scan_read_raw(mtd, buf, (loff_t)md->pages[0] << this->page_shift,
381
			      mtd->writesize, md);
382
		md->version[0] = buf[bbt_get_ver_offs(mtd, md)];
383
		pr_info("Bad block table at page %d, version 0x%02X\n",
384
			 md->pages[0], md->version[0]);
L
Linus Torvalds 已提交
385 386 387
	}
}

388
/* Scan a given block full */
389 390 391 392 393 394
static int scan_block_full(struct mtd_info *mtd, struct nand_bbt_descr *bd,
			   loff_t offs, uint8_t *buf, size_t readlen,
			   int scanlen, int len)
{
	int ret, j;

395
	ret = scan_read_raw_oob(mtd, buf, offs, readlen);
396
	/* Ignore ECC errors when checking for BBM */
397
	if (ret && !mtd_is_bitflip_or_eccerr(ret))
398 399 400 401 402 403 404 405 406
		return ret;

	for (j = 0; j < len; j++, buf += scanlen) {
		if (check_pattern(buf, scanlen, mtd->writesize, bd))
			return 1;
	}
	return 0;
}

407
/* Scan a given block partially */
408 409 410 411 412 413 414 415 416 417
static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
			   loff_t offs, uint8_t *buf, int len)
{
	struct mtd_oob_ops ops;
	int j, ret;

	ops.ooblen = mtd->oobsize;
	ops.oobbuf = buf;
	ops.ooboffs = 0;
	ops.datbuf = NULL;
418
	ops.mode = MTD_OPS_PLACE_OOB;
419 420 421

	for (j = 0; j < len; j++) {
		/*
422 423
		 * Read the full oob until read_oob is fixed to handle single
		 * byte reads for 16 bit buswidth.
424
		 */
425
		ret = mtd_read_oob(mtd, offs, &ops);
426
		/* Ignore ECC errors when checking for BBM */
427
		if (ret && !mtd_is_bitflip_or_eccerr(ret))
428 429 430 431 432 433 434 435 436 437
			return ret;

		if (check_short_pattern(buf, bd))
			return 1;

		offs += mtd->writesize;
	}
	return 0;
}

L
Linus Torvalds 已提交
438 439
/**
 * create_bbt - [GENERIC] Create a bad block table by scanning the device
440 441 442 443 444
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @bd: descriptor for the good/bad block search pattern
 * @chip: create the table for a specific chip, -1 read all chips; applies only
 *        if NAND_BBT_PERCHIP option is set
L
Linus Torvalds 已提交
445
 *
446 447
 * Create a bad block table by scanning the device for the given good/bad block
 * identify pattern.
L
Linus Torvalds 已提交
448
 */
449 450
static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
	struct nand_bbt_descr *bd, int chip)
L
Linus Torvalds 已提交
451 452
{
	struct nand_chip *this = mtd->priv;
453
	int i, numblocks, len, scanlen;
L
Linus Torvalds 已提交
454 455
	int startblock;
	loff_t from;
456
	size_t readlen;
L
Linus Torvalds 已提交
457

458
	pr_info("Scanning device for bad blocks\n");
L
Linus Torvalds 已提交
459 460 461

	if (bd->options & NAND_BBT_SCANALLPAGES)
		len = 1 << (this->bbt_erase_shift - this->page_shift);
462 463 464 465
	else if (bd->options & NAND_BBT_SCAN2NDPAGE)
		len = 2;
	else
		len = 1;
466 467 468

	if (!(bd->options & NAND_BBT_SCANEMPTY)) {
		/* We need only read few bytes from the OOB area */
469
		scanlen = 0;
470 471
		readlen = bd->len;
	} else {
472
		/* Full page content should be read */
J
Joern Engel 已提交
473 474
		scanlen = mtd->writesize + mtd->oobsize;
		readlen = len * mtd->writesize;
475
	}
L
Linus Torvalds 已提交
476 477

	if (chip == -1) {
478 479 480 481
		/*
		 * Note that numblocks is 2 * (real numblocks) here, see i+=2
		 * below as it makes shifting and masking less painful
		 */
L
Linus Torvalds 已提交
482 483 484 485 486
		numblocks = mtd->size >> (this->bbt_erase_shift - 1);
		startblock = 0;
		from = 0;
	} else {
		if (chip >= this->numchips) {
487
			pr_warn("create_bbt(): chipnr (%d) > available chips (%d)\n",
488
			       chip + 1, this->numchips);
489
			return -EINVAL;
L
Linus Torvalds 已提交
490 491 492 493
		}
		numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
		startblock = chip * numblocks;
		numblocks += startblock;
494
		from = (loff_t)startblock << (this->bbt_erase_shift - 1);
L
Linus Torvalds 已提交
495
	}
496

497
	if (this->bbt_options & NAND_BBT_SCANLASTPAGE)
498 499
		from += mtd->erasesize - (mtd->writesize * len);

L
Linus Torvalds 已提交
500
	for (i = startblock; i < numblocks;) {
501
		int ret;
502

503 504
		BUG_ON(bd->options & NAND_BBT_NO_OOB);

505 506 507 508 509 510 511 512 513 514 515
		if (bd->options & NAND_BBT_SCANALLPAGES)
			ret = scan_block_full(mtd, bd, from, buf, readlen,
					      scanlen, len);
		else
			ret = scan_block_fast(mtd, bd, from, buf, len);

		if (ret < 0)
			return ret;

		if (ret) {
			this->bbt[i >> 3] |= 0x03 << (i & 0x6);
516
			pr_warn("Bad eraseblock %d at 0x%012llx\n",
517
				i >> 1, (unsigned long long)from);
518
			mtd->ecc_stats.badblocks++;
L
Linus Torvalds 已提交
519
		}
520

L
Linus Torvalds 已提交
521 522 523
		i += 2;
		from += (1 << this->bbt_erase_shift);
	}
524
	return 0;
L
Linus Torvalds 已提交
525 526 527 528
}

/**
 * search_bbt - [GENERIC] scan the device for a specific bad block table
529 530 531
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @td: descriptor for the bad block table
L
Linus Torvalds 已提交
532
 *
533 534 535 536 537 538
 * Read the bad block table by searching for a given ident pattern. Search is
 * preformed either from the beginning up or from the end of the device
 * downwards. The search starts always at the start of a block. If the option
 * NAND_BBT_PERCHIP is given, each chip is searched for a bbt, which contains
 * the bad block information of this chip. This is necessary to provide support
 * for certain DOC devices.
L
Linus Torvalds 已提交
539
 *
540
 * The bbt ident pattern resides in the oob area of the first page in a block.
L
Linus Torvalds 已提交
541
 */
542
static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
L
Linus Torvalds 已提交
543 544 545 546
{
	struct nand_chip *this = mtd->priv;
	int i, chips;
	int bits, startblock, block, dir;
J
Joern Engel 已提交
547
	int scanlen = mtd->writesize + mtd->oobsize;
L
Linus Torvalds 已提交
548
	int bbtblocks;
549
	int blocktopage = this->bbt_erase_shift - this->page_shift;
L
Linus Torvalds 已提交
550

551
	/* Search direction top -> down? */
L
Linus Torvalds 已提交
552
	if (td->options & NAND_BBT_LASTBLOCK) {
553
		startblock = (mtd->size >> this->bbt_erase_shift) - 1;
L
Linus Torvalds 已提交
554 555
		dir = -1;
	} else {
556
		startblock = 0;
L
Linus Torvalds 已提交
557
		dir = 1;
558 559
	}

560
	/* Do we have a bbt per chip? */
L
Linus Torvalds 已提交
561 562 563 564 565 566 567 568
	if (td->options & NAND_BBT_PERCHIP) {
		chips = this->numchips;
		bbtblocks = this->chipsize >> this->bbt_erase_shift;
		startblock &= bbtblocks - 1;
	} else {
		chips = 1;
		bbtblocks = mtd->size >> this->bbt_erase_shift;
	}
569

L
Linus Torvalds 已提交
570 571
	/* Number of bits for each erase block in the bbt */
	bits = td->options & NAND_BBT_NRBITS_MSK;
572

L
Linus Torvalds 已提交
573 574
	for (i = 0; i < chips; i++) {
		/* Reset version information */
575
		td->version[i] = 0;
L
Linus Torvalds 已提交
576 577 578
		td->pages[i] = -1;
		/* Scan the maximum number of blocks */
		for (block = 0; block < td->maxblocks; block++) {
579

L
Linus Torvalds 已提交
580
			int actblock = startblock + dir * block;
581
			loff_t offs = (loff_t)actblock << this->bbt_erase_shift;
582

L
Linus Torvalds 已提交
583
			/* Read first page */
584
			scan_read_raw(mtd, buf, offs, mtd->writesize, td);
J
Joern Engel 已提交
585
			if (!check_pattern(buf, scanlen, mtd->writesize, td)) {
586
				td->pages[i] = actblock << blocktopage;
L
Linus Torvalds 已提交
587
				if (td->options & NAND_BBT_VERSION) {
588 589
					offs = bbt_get_ver_offs(mtd, td);
					td->version[i] = buf[offs];
L
Linus Torvalds 已提交
590 591 592 593 594 595 596 597 598
				}
				break;
			}
		}
		startblock += this->chipsize >> this->bbt_erase_shift;
	}
	/* Check, if we found a bbt for each requested chip */
	for (i = 0; i < chips; i++) {
		if (td->pages[i] == -1)
599
			pr_warn("Bad block table not found for chip %d\n", i);
L
Linus Torvalds 已提交
600
		else
601 602
			pr_info("Bad block table found at page %d, version "
				 "0x%02X\n", td->pages[i], td->version[i]);
L
Linus Torvalds 已提交
603
	}
604
	return 0;
L
Linus Torvalds 已提交
605 606 607 608
}

/**
 * search_read_bbts - [GENERIC] scan the device for bad block table(s)
609 610 611 612
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @td: descriptor for the bad block table
 * @md: descriptor for the bad block table mirror
L
Linus Torvalds 已提交
613
 *
614 615
 * Search and read the bad block table(s).
 */
616 617 618
static void search_read_bbts(struct mtd_info *mtd, uint8_t *buf,
			     struct nand_bbt_descr *td,
			     struct nand_bbt_descr *md)
L
Linus Torvalds 已提交
619 620
{
	/* Search the primary table */
621
	search_bbt(mtd, buf, td);
622

L
Linus Torvalds 已提交
623 624
	/* Search the mirror table */
	if (md)
625
		search_bbt(mtd, buf, md);
L
Linus Torvalds 已提交
626 627
}

628
/**
L
Linus Torvalds 已提交
629
 * write_bbt - [GENERIC] (Re)write the bad block table
630 631 632 633 634
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @td: descriptor for the bad block table
 * @md: descriptor for the bad block table mirror
 * @chipsel: selector for a specific chip, -1 for all
L
Linus Torvalds 已提交
635
 *
636 637
 * (Re)write the bad block table.
 */
638
static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
639 640
		     struct nand_bbt_descr *td, struct nand_bbt_descr *md,
		     int chipsel)
L
Linus Torvalds 已提交
641 642 643 644 645
{
	struct nand_chip *this = mtd->priv;
	struct erase_info einfo;
	int i, j, res, chip = 0;
	int bits, startblock, dir, page, offs, numblocks, sft, sftmsk;
646
	int nrchips, bbtoffs, pageoffs, ooboffs;
L
Linus Torvalds 已提交
647 648
	uint8_t msk[4];
	uint8_t rcode = td->reserved_block_code;
649
	size_t retlen, len = 0;
L
Linus Torvalds 已提交
650
	loff_t to;
651 652 653 654 655
	struct mtd_oob_ops ops;

	ops.ooblen = mtd->oobsize;
	ops.ooboffs = 0;
	ops.datbuf = NULL;
656
	ops.mode = MTD_OPS_PLACE_OOB;
L
Linus Torvalds 已提交
657 658 659

	if (!rcode)
		rcode = 0xff;
660
	/* Write bad block table per chip rather than per device? */
L
Linus Torvalds 已提交
661
	if (td->options & NAND_BBT_PERCHIP) {
662
		numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
663
		/* Full device write or specific chip? */
L
Linus Torvalds 已提交
664 665 666 667 668 669 670
		if (chipsel == -1) {
			nrchips = this->numchips;
		} else {
			nrchips = chipsel + 1;
			chip = chipsel;
		}
	} else {
671
		numblocks = (int)(mtd->size >> this->bbt_erase_shift);
L
Linus Torvalds 已提交
672
		nrchips = 1;
673 674
	}

L
Linus Torvalds 已提交
675 676
	/* Loop through the chips */
	for (; chip < nrchips; chip++) {
677 678
		/*
		 * There was already a version of the table, reuse the page
679
		 * This applies for absolute placement too, as we have the
L
Linus Torvalds 已提交
680 681 682 683 684
		 * page nr. in td->pages.
		 */
		if (td->pages[chip] != -1) {
			page = td->pages[chip];
			goto write;
685
		}
L
Linus Torvalds 已提交
686

687 688 689 690
		/*
		 * Automatic placement of the bad block table. Search direction
		 * top -> down?
		 */
L
Linus Torvalds 已提交
691 692 693 694 695 696
		if (td->options & NAND_BBT_LASTBLOCK) {
			startblock = numblocks * (chip + 1) - 1;
			dir = -1;
		} else {
			startblock = chip * numblocks;
			dir = 1;
697
		}
L
Linus Torvalds 已提交
698 699 700 701

		for (i = 0; i < td->maxblocks; i++) {
			int block = startblock + dir * i;
			/* Check, if the block is bad */
702 703
			switch ((this->bbt[block >> 2] >>
				 (2 * (block & 0x03))) & 0x03) {
L
Linus Torvalds 已提交
704 705 706 707
			case 0x01:
			case 0x03:
				continue;
			}
708 709
			page = block <<
				(this->bbt_erase_shift - this->page_shift);
L
Linus Torvalds 已提交
710 711 712 713
			/* Check, if the block is used by the mirror table */
			if (!md || md->pages[chip] != page)
				goto write;
		}
714
		pr_err("No space left to write bad block table\n");
L
Linus Torvalds 已提交
715
		return -ENOSPC;
716
	write:
L
Linus Torvalds 已提交
717 718 719

		/* Set up shift count and masks for the flash table */
		bits = td->options & NAND_BBT_NRBITS_MSK;
720
		msk[2] = ~rcode;
L
Linus Torvalds 已提交
721
		switch (bits) {
722 723 724 725 726 727 728 729 730 731 732 733
		case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01;
			msk[3] = 0x01;
			break;
		case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01;
			msk[3] = 0x03;
			break;
		case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C;
			msk[3] = 0x0f;
			break;
		case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F;
			msk[3] = 0xff;
			break;
L
Linus Torvalds 已提交
734 735
		default: return -EINVAL;
		}
736

L
Linus Torvalds 已提交
737
		bbtoffs = chip * (numblocks >> 2);
738

B
Brian Norris 已提交
739
		to = ((loff_t)page) << this->page_shift;
L
Linus Torvalds 已提交
740

741
		/* Must we save the block contents? */
L
Linus Torvalds 已提交
742 743
		if (td->options & NAND_BBT_SAVECONTENT) {
			/* Make it block aligned */
B
Brian Norris 已提交
744
			to &= ~((loff_t)((1 << this->bbt_erase_shift) - 1));
L
Linus Torvalds 已提交
745
			len = 1 << this->bbt_erase_shift;
746
			res = mtd_read(mtd, to, len, &retlen, buf);
L
Linus Torvalds 已提交
747 748
			if (res < 0) {
				if (retlen != len) {
749 750
					pr_info("nand_bbt: error reading block "
						"for writing the bad block table\n");
L
Linus Torvalds 已提交
751 752
					return res;
				}
753 754
				pr_warn("nand_bbt: ECC error while reading "
					"block for writing bad block table\n");
L
Linus Torvalds 已提交
755
			}
756
			/* Read oob data */
757
			ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
758
			ops.oobbuf = &buf[len];
759
			res = mtd_read_oob(mtd, to + mtd->writesize, &ops);
760
			if (res < 0 || ops.oobretlen != ops.ooblen)
761 762
				goto outerr;

L
Linus Torvalds 已提交
763 764 765 766
			/* Calc the byte offset in the buffer */
			pageoffs = page - (int)(to >> this->page_shift);
			offs = pageoffs << this->page_shift;
			/* Preset the bbt area with 0xff */
B
Brian Norris 已提交
767
			memset(&buf[offs], 0xff, (size_t)(numblocks >> sft));
768 769
			ooboffs = len + (pageoffs * mtd->oobsize);

770 771 772
		} else if (td->options & NAND_BBT_NO_OOB) {
			ooboffs = 0;
			offs = td->len;
773
			/* The version byte */
774 775 776
			if (td->options & NAND_BBT_VERSION)
				offs++;
			/* Calc length */
B
Brian Norris 已提交
777
			len = (size_t)(numblocks >> sft);
778
			len += offs;
779
			/* Make it page aligned! */
780 781 782 783 784
			len = ALIGN(len, mtd->writesize);
			/* Preset the buffer with 0xff */
			memset(buf, 0xff, len);
			/* Pattern is located at the begin of first page */
			memcpy(buf, td->pattern, td->len);
L
Linus Torvalds 已提交
785 786
		} else {
			/* Calc length */
B
Brian Norris 已提交
787
			len = (size_t)(numblocks >> sft);
788
			/* Make it page aligned! */
789
			len = ALIGN(len, mtd->writesize);
L
Linus Torvalds 已提交
790
			/* Preset the buffer with 0xff */
791 792
			memset(buf, 0xff, len +
			       (len >> this->page_shift)* mtd->oobsize);
L
Linus Torvalds 已提交
793
			offs = 0;
794
			ooboffs = len;
L
Linus Torvalds 已提交
795
			/* Pattern is located in oob area of first page */
796
			memcpy(&buf[ooboffs + td->offs], td->pattern, td->len);
L
Linus Torvalds 已提交
797
		}
798

799 800 801
		if (td->options & NAND_BBT_VERSION)
			buf[ooboffs + td->veroffs] = td->version[chip];

802
		/* Walk through the memory table */
803
		for (i = 0; i < numblocks;) {
L
Linus Torvalds 已提交
804 805
			uint8_t dat;
			dat = this->bbt[bbtoffs + (i >> 2)];
806
			for (j = 0; j < 4; j++, i++) {
L
Linus Torvalds 已提交
807
				int sftcnt = (i << (3 - sft)) & sftmsk;
808
				/* Do not store the reserved bbt blocks! */
809 810
				buf[offs + (i >> sft)] &=
					~(msk[dat & 0x03] << sftcnt);
L
Linus Torvalds 已提交
811 812 813
				dat >>= 2;
			}
		}
814

815
		memset(&einfo, 0, sizeof(einfo));
L
Linus Torvalds 已提交
816
		einfo.mtd = mtd;
817
		einfo.addr = to;
L
Linus Torvalds 已提交
818
		einfo.len = 1 << this->bbt_erase_shift;
819
		res = nand_erase_nand(mtd, &einfo, 1);
820 821
		if (res < 0)
			goto outerr;
822

823 824 825
		res = scan_write_bbt(mtd, to, len, buf,
				td->options & NAND_BBT_NO_OOB ? NULL :
				&buf[len]);
826 827 828
		if (res < 0)
			goto outerr;

829 830
		pr_info("Bad block table written to 0x%012llx, version 0x%02X\n",
			 (unsigned long long)to, td->version[chip]);
831

L
Linus Torvalds 已提交
832 833
		/* Mark it as used */
		td->pages[chip] = page;
834
	}
L
Linus Torvalds 已提交
835
	return 0;
836 837

 outerr:
838
	pr_warn("nand_bbt: error while writing bad block table %d\n", res);
839
	return res;
L
Linus Torvalds 已提交
840 841 842 843
}

/**
 * nand_memory_bbt - [GENERIC] create a memory based bad block table
844 845
 * @mtd: MTD device structure
 * @bd: descriptor for the good/bad block search pattern
L
Linus Torvalds 已提交
846
 *
847 848 849
 * The function creates a memory based bbt by scanning the device for
 * manufacturer / software marked good / bad blocks.
 */
850
static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
L
Linus Torvalds 已提交
851 852 853
{
	struct nand_chip *this = mtd->priv;

854
	bd->options &= ~NAND_BBT_SCANEMPTY;
855
	return create_bbt(mtd, this->buffers->databuf, bd, -1);
L
Linus Torvalds 已提交
856 857 858
}

/**
859
 * check_create - [GENERIC] create and write bbt(s) if necessary
860 861 862
 * @mtd: MTD device structure
 * @buf: temporary buffer
 * @bd: descriptor for the good/bad block search pattern
L
Linus Torvalds 已提交
863
 *
864 865 866 867 868
 * The function checks the results of the previous call to read_bbt and creates
 * / updates the bbt(s) if necessary. Creation is necessary if no bbt was found
 * for the chip/device. Update is necessary if one of the tables is missing or
 * the version nr. of one table is less than the other.
 */
869
static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
L
Linus Torvalds 已提交
870
{
871
	int i, chips, writeops, create, chipsel, res, res2;
L
Linus Torvalds 已提交
872 873 874 875 876
	struct nand_chip *this = mtd->priv;
	struct nand_bbt_descr *td = this->bbt_td;
	struct nand_bbt_descr *md = this->bbt_md;
	struct nand_bbt_descr *rd, *rd2;

877
	/* Do we have a bbt per chip? */
878
	if (td->options & NAND_BBT_PERCHIP)
L
Linus Torvalds 已提交
879
		chips = this->numchips;
880
	else
L
Linus Torvalds 已提交
881
		chips = 1;
882

L
Linus Torvalds 已提交
883 884
	for (i = 0; i < chips; i++) {
		writeops = 0;
885
		create = 0;
L
Linus Torvalds 已提交
886 887
		rd = NULL;
		rd2 = NULL;
888
		res = res2 = 0;
889
		/* Per chip or per device? */
L
Linus Torvalds 已提交
890
		chipsel = (td->options & NAND_BBT_PERCHIP) ? i : -1;
891
		/* Mirrored table available? */
L
Linus Torvalds 已提交
892 893
		if (md) {
			if (td->pages[i] == -1 && md->pages[i] == -1) {
894
				create = 1;
L
Linus Torvalds 已提交
895
				writeops = 0x03;
896
			} else if (td->pages[i] == -1) {
897
				rd = md;
B
Brian Norris 已提交
898
				writeops = 0x01;
899
			} else if (md->pages[i] == -1) {
L
Linus Torvalds 已提交
900
				rd = td;
B
Brian Norris 已提交
901
				writeops = 0x02;
902
			} else if (td->version[i] == md->version[i]) {
L
Linus Torvalds 已提交
903 904 905
				rd = td;
				if (!(td->options & NAND_BBT_VERSION))
					rd2 = md;
906
			} else if (((int8_t)(td->version[i] - md->version[i])) > 0) {
L
Linus Torvalds 已提交
907
				rd = td;
B
Brian Norris 已提交
908
				writeops = 0x02;
L
Linus Torvalds 已提交
909 910
			} else {
				rd = md;
B
Brian Norris 已提交
911
				writeops = 0x01;
L
Linus Torvalds 已提交
912 913 914
			}
		} else {
			if (td->pages[i] == -1) {
915
				create = 1;
L
Linus Torvalds 已提交
916
				writeops = 0x01;
917 918
			} else {
				rd = td;
L
Linus Torvalds 已提交
919 920
			}
		}
921

922 923 924 925 926 927 928 929 930 931 932 933 934 935
		if (create) {
			/* Create the bad block table by scanning the device? */
			if (!(td->options & NAND_BBT_CREATE))
				continue;

			/* Create the table in memory by scanning the chip(s) */
			if (!(this->bbt_options & NAND_BBT_CREATE_EMPTY))
				create_bbt(mtd, buf, bd, chipsel);

			td->version[i] = 1;
			if (md)
				md->version[i] = 1;
		}

936
		/* Read back first? */
937 938 939 940 941
		if (rd) {
			res = read_abs_bbt(mtd, buf, rd, chipsel);
			if (mtd_is_eccerr(res)) {
				/* Mark table as invalid */
				rd->pages[i] = -1;
942
				rd->version[i] = 0;
943 944 945 946
				i--;
				continue;
			}
		}
947
		/* If they weren't versioned, read both */
948 949 950 951 952
		if (rd2) {
			res2 = read_abs_bbt(mtd, buf, rd2, chipsel);
			if (mtd_is_eccerr(res2)) {
				/* Mark table as invalid */
				rd2->pages[i] = -1;
953
				rd2->version[i] = 0;
954 955 956 957 958 959 960 961
				i--;
				continue;
			}
		}

		/* Scrub the flash table(s)? */
		if (mtd_is_bitflip(res) || mtd_is_bitflip(res2))
			writeops = 0x03;
L
Linus Torvalds 已提交
962

963 964 965 966 967 968
		/* Update version numbers before writing */
		if (md) {
			td->version[i] = max(td->version[i], md->version[i]);
			md->version[i] = td->version[i];
		}

969
		/* Write the bad block table to the device? */
L
Linus Torvalds 已提交
970
		if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
971
			res = write_bbt(mtd, buf, td, md, chipsel);
L
Linus Torvalds 已提交
972 973 974
			if (res < 0)
				return res;
		}
975

976
		/* Write the mirror bad block table to the device? */
L
Linus Torvalds 已提交
977
		if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
978
			res = write_bbt(mtd, buf, md, td, chipsel);
L
Linus Torvalds 已提交
979 980 981 982
			if (res < 0)
				return res;
		}
	}
983
	return 0;
L
Linus Torvalds 已提交
984 985 986
}

/**
987
 * mark_bbt_regions - [GENERIC] mark the bad block table regions
988 989
 * @mtd: MTD device structure
 * @td: bad block table descriptor
L
Linus Torvalds 已提交
990
 *
991 992 993
 * The bad block table regions are marked as "bad" to prevent accidental
 * erasures / writes. The regions are identified by the mark 0x02.
 */
994
static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
L
Linus Torvalds 已提交
995 996 997 998 999
{
	struct nand_chip *this = mtd->priv;
	int i, j, chips, block, nrblocks, update;
	uint8_t oldval, newval;

1000
	/* Do we have a bbt per chip? */
L
Linus Torvalds 已提交
1001 1002 1003 1004 1005 1006
	if (td->options & NAND_BBT_PERCHIP) {
		chips = this->numchips;
		nrblocks = (int)(this->chipsize >> this->bbt_erase_shift);
	} else {
		chips = 1;
		nrblocks = (int)(mtd->size >> this->bbt_erase_shift);
1007 1008
	}

L
Linus Torvalds 已提交
1009 1010 1011
	for (i = 0; i < chips; i++) {
		if ((td->options & NAND_BBT_ABSPAGE) ||
		    !(td->options & NAND_BBT_WRITE)) {
1012 1013
			if (td->pages[i] == -1)
				continue;
L
Linus Torvalds 已提交
1014
			block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift);
1015
			block <<= 1;
L
Linus Torvalds 已提交
1016 1017 1018 1019
			oldval = this->bbt[(block >> 3)];
			newval = oldval | (0x2 << (block & 0x06));
			this->bbt[(block >> 3)] = newval;
			if ((oldval != newval) && td->reserved_block_code)
1020
				nand_update_bbt(mtd, (loff_t)block << (this->bbt_erase_shift - 1));
L
Linus Torvalds 已提交
1021 1022 1023 1024 1025
			continue;
		}
		update = 0;
		if (td->options & NAND_BBT_LASTBLOCK)
			block = ((i + 1) * nrblocks) - td->maxblocks;
1026
		else
L
Linus Torvalds 已提交
1027
			block = i * nrblocks;
1028
		block <<= 1;
L
Linus Torvalds 已提交
1029 1030 1031 1032
		for (j = 0; j < td->maxblocks; j++) {
			oldval = this->bbt[(block >> 3)];
			newval = oldval | (0x2 << (block & 0x06));
			this->bbt[(block >> 3)] = newval;
1033 1034
			if (oldval != newval)
				update = 1;
L
Linus Torvalds 已提交
1035
			block += 2;
1036
		}
1037 1038 1039 1040 1041
		/*
		 * If we want reserved blocks to be recorded to flash, and some
		 * new ones have been marked, then we need to update the stored
		 * bbts.  This should only happen once.
		 */
L
Linus Torvalds 已提交
1042
		if (update && td->reserved_block_code)
1043
			nand_update_bbt(mtd, (loff_t)(block - 2) << (this->bbt_erase_shift - 1));
L
Linus Torvalds 已提交
1044 1045 1046
	}
}

1047 1048
/**
 * verify_bbt_descr - verify the bad block description
1049 1050
 * @mtd: MTD device structure
 * @bd: the table to verify
1051 1052 1053 1054 1055 1056 1057
 *
 * This functions performs a few sanity checks on the bad block description
 * table.
 */
static void verify_bbt_descr(struct mtd_info *mtd, struct nand_bbt_descr *bd)
{
	struct nand_chip *this = mtd->priv;
1058 1059
	u32 pattern_len;
	u32 bits;
1060 1061 1062 1063
	u32 table_size;

	if (!bd)
		return;
1064 1065 1066 1067

	pattern_len = bd->len;
	bits = bd->options & NAND_BBT_NRBITS_MSK;

1068
	BUG_ON((this->bbt_options & NAND_BBT_NO_OOB) &&
1069
			!(this->bbt_options & NAND_BBT_USE_FLASH));
1070 1071 1072 1073 1074 1075
	BUG_ON(!bits);

	if (bd->options & NAND_BBT_VERSION)
		pattern_len++;

	if (bd->options & NAND_BBT_NO_OOB) {
1076
		BUG_ON(!(this->bbt_options & NAND_BBT_USE_FLASH));
1077
		BUG_ON(!(this->bbt_options & NAND_BBT_NO_OOB));
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
		BUG_ON(bd->offs);
		if (bd->options & NAND_BBT_VERSION)
			BUG_ON(bd->veroffs != bd->len);
		BUG_ON(bd->options & NAND_BBT_SAVECONTENT);
	}

	if (bd->options & NAND_BBT_PERCHIP)
		table_size = this->chipsize >> this->bbt_erase_shift;
	else
		table_size = mtd->size >> this->bbt_erase_shift;
	table_size >>= 3;
	table_size *= bits;
	if (bd->options & NAND_BBT_NO_OOB)
		table_size += pattern_len;
	BUG_ON(table_size > (1 << this->bbt_erase_shift));
}

L
Linus Torvalds 已提交
1095 1096
/**
 * nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)
1097 1098
 * @mtd: MTD device structure
 * @bd: descriptor for the good/bad block search pattern
L
Linus Torvalds 已提交
1099
 *
1100 1101 1102
 * The function checks, if a bad block table(s) is/are already available. If
 * not it scans the device for manufacturer marked good / bad blocks and writes
 * the bad block table(s) to the selected place.
L
Linus Torvalds 已提交
1103
 *
1104 1105 1106
 * The bad block table memory is allocated here. It must be freed by calling
 * the nand_free_bbt function.
 */
1107
int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
L
Linus Torvalds 已提交
1108 1109 1110 1111 1112 1113 1114 1115
{
	struct nand_chip *this = mtd->priv;
	int len, res = 0;
	uint8_t *buf;
	struct nand_bbt_descr *td = this->bbt_td;
	struct nand_bbt_descr *md = this->bbt_md;

	len = mtd->size >> (this->bbt_erase_shift + 2);
1116 1117 1118 1119
	/*
	 * Allocate memory (2bit per block) and clear the memory bad block
	 * table.
	 */
1120
	this->bbt = kzalloc(len, GFP_KERNEL);
1121
	if (!this->bbt)
L
Linus Torvalds 已提交
1122 1123
		return -ENOMEM;

1124 1125 1126
	/*
	 * If no primary table decriptor is given, scan the device to build a
	 * memory based bad block table.
L
Linus Torvalds 已提交
1127
	 */
1128 1129
	if (!td) {
		if ((res = nand_memory_bbt(mtd, bd))) {
1130
			pr_err("nand_bbt: can't scan flash and build the RAM-based BBT\n");
1131
			kfree(this->bbt);
1132 1133 1134 1135
			this->bbt = NULL;
		}
		return res;
	}
1136 1137
	verify_bbt_descr(mtd, td);
	verify_bbt_descr(mtd, md);
L
Linus Torvalds 已提交
1138 1139 1140 1141

	/* Allocate a temporary buffer for one eraseblock incl. oob */
	len = (1 << this->bbt_erase_shift);
	len += (len >> this->page_shift) * mtd->oobsize;
1142
	buf = vmalloc(len);
L
Linus Torvalds 已提交
1143
	if (!buf) {
1144
		kfree(this->bbt);
L
Linus Torvalds 已提交
1145 1146 1147
		this->bbt = NULL;
		return -ENOMEM;
	}
1148

1149
	/* Is the bbt at a given page? */
L
Linus Torvalds 已提交
1150
	if (td->options & NAND_BBT_ABSPAGE) {
1151
		read_abs_bbts(mtd, buf, td, md);
1152
	} else {
L
Linus Torvalds 已提交
1153
		/* Search the bad block table using a pattern in oob */
1154
		search_read_bbts(mtd, buf, td, md);
1155
	}
L
Linus Torvalds 已提交
1156

1157
	res = check_create(mtd, buf, bd);
1158

L
Linus Torvalds 已提交
1159
	/* Prevent the bbt regions from erasing / writing */
1160
	mark_bbt_region(mtd, td);
L
Linus Torvalds 已提交
1161
	if (md)
1162
		mark_bbt_region(mtd, md);
1163

1164
	vfree(buf);
L
Linus Torvalds 已提交
1165 1166 1167 1168
	return res;
}

/**
1169
 * nand_update_bbt - [NAND Interface] update bad block table(s)
1170 1171
 * @mtd: MTD device structure
 * @offs: the offset of the newly marked block
L
Linus Torvalds 已提交
1172
 *
1173 1174
 * The function updates the bad block table(s).
 */
1175
int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
L
Linus Torvalds 已提交
1176 1177
{
	struct nand_chip *this = mtd->priv;
1178
	int len, res = 0;
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
	int chip, chipsel;
	uint8_t *buf;
	struct nand_bbt_descr *td = this->bbt_td;
	struct nand_bbt_descr *md = this->bbt_md;

	if (!this->bbt || !td)
		return -EINVAL;

	/* Allocate a temporary buffer for one eraseblock incl. oob */
	len = (1 << this->bbt_erase_shift);
	len += (len >> this->page_shift) * mtd->oobsize;
1190
	buf = kmalloc(len, GFP_KERNEL);
1191
	if (!buf)
L
Linus Torvalds 已提交
1192 1193
		return -ENOMEM;

1194
	/* Do we have a bbt per chip? */
L
Linus Torvalds 已提交
1195
	if (td->options & NAND_BBT_PERCHIP) {
1196
		chip = (int)(offs >> this->chip_shift);
L
Linus Torvalds 已提交
1197 1198 1199 1200 1201 1202 1203 1204
		chipsel = chip;
	} else {
		chip = 0;
		chipsel = -1;
	}

	td->version[chip]++;
	if (md)
1205
		md->version[chip]++;
L
Linus Torvalds 已提交
1206

1207
	/* Write the bad block table to the device? */
1208
	if (td->options & NAND_BBT_WRITE) {
1209
		res = write_bbt(mtd, buf, td, md, chipsel);
L
Linus Torvalds 已提交
1210 1211 1212
		if (res < 0)
			goto out;
	}
1213
	/* Write the mirror bad block table to the device? */
1214
	if (md && (md->options & NAND_BBT_WRITE)) {
1215
		res = write_bbt(mtd, buf, md, td, chipsel);
L
Linus Torvalds 已提交
1216 1217
	}

1218 1219
 out:
	kfree(buf);
L
Linus Torvalds 已提交
1220 1221 1222
	return res;
}

1223 1224 1225 1226
/*
 * Define some generic bad / good block scan pattern which are used
 * while scanning a device for factory marked good / bad blocks.
 */
L
Linus Torvalds 已提交
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
static uint8_t scan_ff_pattern[] = { 0xff, 0xff };

static uint8_t scan_agand_pattern[] = { 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7 };

static struct nand_bbt_descr agand_flashbased = {
	.options = NAND_BBT_SCANEMPTY | NAND_BBT_SCANALLPAGES,
	.offs = 0x20,
	.len = 6,
	.pattern = scan_agand_pattern
};

1238
/* Generic flash bbt descriptors */
L
Linus Torvalds 已提交
1239 1240 1241 1242
static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };

static struct nand_bbt_descr bbt_main_descr = {
1243
	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
L
Linus Torvalds 已提交
1244 1245 1246 1247 1248 1249 1250 1251 1252
		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
	.offs =	8,
	.len = 4,
	.veroffs = 12,
	.maxblocks = 4,
	.pattern = bbt_pattern
};

static struct nand_bbt_descr bbt_mirror_descr = {
1253
	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
L
Linus Torvalds 已提交
1254 1255 1256 1257 1258 1259 1260 1261
		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
	.offs =	8,
	.len = 4,
	.veroffs = 12,
	.maxblocks = 4,
	.pattern = mirror_pattern
};

1262
static struct nand_bbt_descr bbt_main_no_oob_descr = {
1263 1264 1265 1266 1267 1268 1269 1270 1271
	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
		| NAND_BBT_NO_OOB,
	.len = 4,
	.veroffs = 4,
	.maxblocks = 4,
	.pattern = bbt_pattern
};

1272
static struct nand_bbt_descr bbt_mirror_no_oob_descr = {
1273 1274 1275 1276 1277 1278 1279 1280 1281
	.options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
		| NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
		| NAND_BBT_NO_OOB,
	.len = 4,
	.veroffs = 4,
	.maxblocks = 4,
	.pattern = mirror_pattern
};

1282
#define BADBLOCK_SCAN_MASK (~NAND_BBT_NO_OOB)
1283
/**
1284
 * nand_create_badblock_pattern - [INTERN] Creates a BBT descriptor structure
1285
 * @this: NAND chip to create descriptor for
1286 1287
 *
 * This function allocates and initializes a nand_bbt_descr for BBM detection
1288
 * based on the properties of @this. The new descriptor is stored in
1289 1290 1291
 * this->badblock_pattern. Thus, this->badblock_pattern should be NULL when
 * passed to this function.
 */
1292
static int nand_create_badblock_pattern(struct nand_chip *this)
1293 1294 1295
{
	struct nand_bbt_descr *bd;
	if (this->badblock_pattern) {
1296
		pr_warn("Bad block pattern already allocated; not replacing\n");
1297 1298 1299
		return -EINVAL;
	}
	bd = kzalloc(sizeof(*bd), GFP_KERNEL);
1300
	if (!bd)
1301
		return -ENOMEM;
1302
	bd->options = this->bbt_options & BADBLOCK_SCAN_MASK;
1303 1304 1305 1306 1307 1308 1309 1310
	bd->offs = this->badblockpos;
	bd->len = (this->options & NAND_BUSWIDTH_16) ? 2 : 1;
	bd->pattern = scan_ff_pattern;
	bd->options |= NAND_BBT_DYNAMICSTRUCT;
	this->badblock_pattern = bd;
	return 0;
}

L
Linus Torvalds 已提交
1311
/**
1312
 * nand_default_bbt - [NAND Interface] Select a default bad block table for the device
1313
 * @mtd: MTD device structure
L
Linus Torvalds 已提交
1314
 *
1315 1316 1317
 * This function selects the default bad block table support for the device and
 * calls the nand_scan_bbt function.
 */
1318
int nand_default_bbt(struct mtd_info *mtd)
L
Linus Torvalds 已提交
1319 1320
{
	struct nand_chip *this = mtd->priv;
1321

1322 1323 1324 1325 1326
	/*
	 * Default for AG-AND. We must use a flash based bad block table as the
	 * devices have factory marked _good_ blocks. Erasing those blocks
	 * leads to loss of the good / bad information, so we _must_ store this
	 * information in a good / bad table during startup.
1327
	 */
L
Linus Torvalds 已提交
1328 1329
	if (this->options & NAND_IS_AND) {
		/* Use the default pattern descriptors */
1330
		if (!this->bbt_td) {
L
Linus Torvalds 已提交
1331 1332
			this->bbt_td = &bbt_main_descr;
			this->bbt_md = &bbt_mirror_descr;
1333
		}
1334
		this->bbt_options |= NAND_BBT_USE_FLASH;
1335
		return nand_scan_bbt(mtd, &agand_flashbased);
L
Linus Torvalds 已提交
1336
	}
1337

1338
	/* Is a flash based bad block table requested? */
1339
	if (this->bbt_options & NAND_BBT_USE_FLASH) {
1340 1341
		/* Use the default pattern descriptors */
		if (!this->bbt_td) {
1342
			if (this->bbt_options & NAND_BBT_NO_OOB) {
1343 1344
				this->bbt_td = &bbt_main_no_oob_descr;
				this->bbt_md = &bbt_mirror_no_oob_descr;
1345 1346 1347 1348
			} else {
				this->bbt_td = &bbt_main_descr;
				this->bbt_md = &bbt_mirror_descr;
			}
L
Linus Torvalds 已提交
1349 1350 1351 1352 1353
		}
	} else {
		this->bbt_td = NULL;
		this->bbt_md = NULL;
	}
1354 1355

	if (!this->badblock_pattern)
1356
		nand_create_badblock_pattern(this);
1357

1358
	return nand_scan_bbt(mtd, this->badblock_pattern);
L
Linus Torvalds 已提交
1359 1360 1361
}

/**
1362
 * nand_isbad_bbt - [NAND Interface] Check if a block is bad
1363 1364 1365 1366
 * @mtd: MTD device structure
 * @offs: offset in the device
 * @allowbbt: allow access to bad block table region
 */
1367
int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
L
Linus Torvalds 已提交
1368 1369 1370
{
	struct nand_chip *this = mtd->priv;
	int block;
1371
	uint8_t res;
1372

L
Linus Torvalds 已提交
1373
	/* Get block number * 2 */
1374
	block = (int)(offs >> (this->bbt_erase_shift - 1));
L
Linus Torvalds 已提交
1375 1376
	res = (this->bbt[block >> 3] >> (block & 0x06)) & 0x03;

1377 1378 1379
	pr_debug("nand_isbad_bbt(): bbt info for offs 0x%08x: "
			"(block %d) 0x%02x\n",
			(unsigned int)offs, block >> 1, res);
L
Linus Torvalds 已提交
1380 1381

	switch ((int)res) {
1382 1383 1384 1385 1386 1387
	case 0x00:
		return 0;
	case 0x01:
		return 1;
	case 0x02:
		return allowbbt ? 0 : 1;
L
Linus Torvalds 已提交
1388 1389 1390 1391
	}
	return 1;
}

1392 1393
EXPORT_SYMBOL(nand_scan_bbt);
EXPORT_SYMBOL(nand_default_bbt);