blob: 0b1c48595f1255547aea9eae6e41ba03e47dc05f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/mtd/nand_bbt.c
3 *
4 * Overview:
5 * Bad block table support for the NAND driver
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00006 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Copyright (C) 2004 Thomas Gleixner (tglx@linutronix.de)
8 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * Description:
14 *
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000015 * 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 a bbt is found
17 * then the contents are read and the memory based bbt is created. If a
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 * mirrored bbt is selected then the mirror is searched too and the
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000019 * versions are compared. If the mirror has a greater version number
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 * than the mirror bbt is used to build the memory based bbt.
21 * If the tables are not versioned, then we "or" the bad block information.
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000022 * If one of the bbt's is out of date or does not exist it is (re)created.
23 * If no bbt exists at all then the device is scanned for factory marked
24 * good / bad blocks and the bad block tables are created.
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 *
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000026 * For manufacturer created bbts like the one found on M-SYS DOC devices
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 * the bbt is searched and read but never created
28 *
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000029 * The autogenerated bad block table is located in the last good blocks
30 * of the device. The table is mirrored, so it can be updated eventually.
31 * The table is marked in the oob area with an ident pattern and a version
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 * number which indicates which of both tables is more up to date.
33 *
34 * The table uses 2 bits per block
35 * 11b: block is good
36 * 00b: block is factory marked bad
37 * 01b, 10b: block is marked bad due to wear
38 *
39 * The memory bad block table uses the following scheme:
40 * 00b: block is good
41 * 01b: block is marked bad due to wear
42 * 10b: block is reserved (to protect the bbt area)
43 * 11b: block is factory marked bad
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000044 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * Multichip devices like DOC store the bad block info per floor.
46 *
47 * Following assumptions are made:
48 * - bbts start at a page boundary, if autolocated on a block boundary
David Woodhousee0c7d762006-05-13 18:07:53 +010049 * - the space necessary for a bbt in FLASH does not exceed a block boundary
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000050 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 */
52
53#include <linux/slab.h>
54#include <linux/types.h>
55#include <linux/mtd/mtd.h>
56#include <linux/mtd/nand.h>
57#include <linux/mtd/nand_ecc.h>
58#include <linux/mtd/compatmac.h>
59#include <linux/bitops.h>
60#include <linux/delay.h>
David Woodhousec3f8abf2006-05-13 04:03:42 +010061#include <linux/vmalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000063/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 * check_pattern - [GENERIC] check if a pattern is in the buffer
65 * @buf: the buffer to search
66 * @len: the length of buffer to search
67 * @paglen: the pagelength
68 * @td: search pattern descriptor
69 *
70 * Check for a pattern at the given place. Used to search bad block
71 * tables and good / bad block identifiers.
72 * If the SCAN_EMPTY option is set then check, if all bytes except the
73 * pattern area contain 0xff
74 *
75*/
David Woodhousee0c7d762006-05-13 18:07:53 +010076static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077{
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +000078 int i, end = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 uint8_t *p = buf;
80
Thomas Gleixnerc9e05362005-06-14 16:39:57 +010081 end = paglen + td->offs;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 if (td->options & NAND_BBT_SCANEMPTY) {
83 for (i = 0; i < end; i++) {
84 if (p[i] != 0xff)
85 return -1;
86 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000087 }
Thomas Gleixnerc9e05362005-06-14 16:39:57 +010088 p += end;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +000089
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 /* Compare the pattern */
91 for (i = 0; i < td->len; i++) {
92 if (p[i] != td->pattern[i])
93 return -1;
94 }
95
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 if (td->options & NAND_BBT_SCANEMPTY) {
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +000097 p += td->len;
98 end += td->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 for (i = end; i < len; i++) {
100 if (*p++ != 0xff)
101 return -1;
102 }
103 }
104 return 0;
105}
106
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000107/**
Thomas Gleixnerc9e05362005-06-14 16:39:57 +0100108 * check_short_pattern - [GENERIC] check if a pattern is in the buffer
109 * @buf: the buffer to search
Thomas Gleixnerc9e05362005-06-14 16:39:57 +0100110 * @td: search pattern descriptor
111 *
112 * Check for a pattern at the given place. Used to search bad block
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000113 * tables and good / bad block identifiers. Same as check_pattern, but
Thomas Gleixner19870da2005-07-15 14:53:51 +0100114 * no optional empty check
Thomas Gleixnerc9e05362005-06-14 16:39:57 +0100115 *
116*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100117static int check_short_pattern(uint8_t *buf, struct nand_bbt_descr *td)
Thomas Gleixnerc9e05362005-06-14 16:39:57 +0100118{
119 int i;
120 uint8_t *p = buf;
121
122 /* Compare the pattern */
123 for (i = 0; i < td->len; i++) {
Thomas Gleixner19870da2005-07-15 14:53:51 +0100124 if (p[td->offs + i] != td->pattern[i])
Thomas Gleixnerc9e05362005-06-14 16:39:57 +0100125 return -1;
126 }
127 return 0;
128}
129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130/**
131 * read_bbt - [GENERIC] Read the bad block table starting from page
132 * @mtd: MTD device structure
133 * @buf: temporary buffer
134 * @page: the starting page
135 * @num: the number of bbt descriptors to read
136 * @bits: number of bits per block
137 * @offs: offset in the memory table
138 * @reserved_block_code: Pattern to identify reserved blocks
139 *
140 * Read the bad block table starting from page.
141 *
142 */
David Woodhousee0c7d762006-05-13 18:07:53 +0100143static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
144 int bits, int offs, int reserved_block_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
146 int res, i, j, act = 0;
147 struct nand_chip *this = mtd->priv;
148 size_t retlen, len, totlen;
149 loff_t from;
150 uint8_t msk = (uint8_t) ((1 << bits) - 1);
151
152 totlen = (num * bits) >> 3;
David Woodhousee0c7d762006-05-13 18:07:53 +0100153 from = ((loff_t) page) << this->page_shift;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 while (totlen) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100156 len = min(totlen, (size_t) (1 << this->bbt_erase_shift));
Thomas Gleixner9223a452006-05-23 17:21:03 +0200157 res = mtd->read(mtd, from, len, &retlen, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (res < 0) {
159 if (retlen != len) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100160 printk(KERN_INFO "nand_bbt: Error reading bad block table\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 return res;
162 }
David Woodhousee0c7d762006-05-13 18:07:53 +0100163 printk(KERN_WARNING "nand_bbt: ECC error while reading bad block table\n");
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000164 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166 /* Analyse data */
167 for (i = 0; i < len; i++) {
168 uint8_t dat = buf[i];
169 for (j = 0; j < 8; j += bits, act += 2) {
170 uint8_t tmp = (dat >> j) & msk;
171 if (tmp == msk)
172 continue;
David Woodhousee0c7d762006-05-13 18:07:53 +0100173 if (reserved_block_code && (tmp == reserved_block_code)) {
174 printk(KERN_DEBUG "nand_read_bbt: Reserved block at 0x%08x\n",
175 ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 this->bbt[offs + (act >> 3)] |= 0x2 << (act & 0x06);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200177 mtd->ecc_stats.bbtblocks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 continue;
179 }
180 /* Leave it for now, if its matured we can move this
181 * message to MTD_DEBUG_LEVEL0 */
David Woodhousee0c7d762006-05-13 18:07:53 +0100182 printk(KERN_DEBUG "nand_read_bbt: Bad block at 0x%08x\n",
183 ((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000184 /* Factory marked bad or worn out ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 if (tmp == 0)
186 this->bbt[offs + (act >> 3)] |= 0x3 << (act & 0x06);
187 else
188 this->bbt[offs + (act >> 3)] |= 0x1 << (act & 0x06);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200189 mtd->ecc_stats.badblocks++;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000190 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 }
192 totlen -= len;
193 from += len;
194 }
195 return 0;
196}
197
198/**
199 * read_abs_bbt - [GENERIC] Read the bad block table starting at a given page
200 * @mtd: MTD device structure
201 * @buf: temporary buffer
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000202 * @td: descriptor for the bad block table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 * @chip: read the table for a specific chip, -1 read all chips.
204 * Applies only if NAND_BBT_PERCHIP option is set
205 *
206 * Read the bad block table for all chips starting at a given page
207 * We assume that the bbt bits are in consecutive order.
208*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100209static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
211 struct nand_chip *this = mtd->priv;
212 int res = 0, i;
213 int bits;
214
215 bits = td->options & NAND_BBT_NRBITS_MSK;
216 if (td->options & NAND_BBT_PERCHIP) {
217 int offs = 0;
218 for (i = 0; i < this->numchips; i++) {
219 if (chip == -1 || chip == i)
220 res = read_bbt (mtd, buf, td->pages[i], this->chipsize >> this->bbt_erase_shift, bits, offs, td->reserved_block_code);
221 if (res)
222 return res;
223 offs += this->chipsize >> (this->bbt_erase_shift + 2);
224 }
225 } else {
226 res = read_bbt (mtd, buf, td->pages[0], mtd->size >> this->bbt_erase_shift, bits, 0, td->reserved_block_code);
227 if (res)
228 return res;
229 }
230 return 0;
231}
232
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200233/*
234 * Scan read raw data from flash
235 */
236static int scan_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
237 size_t len)
238{
239 struct mtd_oob_ops ops;
240
241 ops.mode = MTD_OOB_RAW;
242 ops.ooboffs = 0;
243 ops.ooblen = mtd->oobsize;
244 ops.oobbuf = buf;
245 ops.datbuf = buf;
246 ops.len = len;
247
248 return mtd->read_oob(mtd, offs, &ops);
249}
250
251/*
252 * Scan write data with oob to flash
253 */
254static int scan_write_bbt(struct mtd_info *mtd, loff_t offs, size_t len,
255 uint8_t *buf, uint8_t *oob)
256{
257 struct mtd_oob_ops ops;
258
259 ops.mode = MTD_OOB_PLACE;
260 ops.ooboffs = 0;
261 ops.ooblen = mtd->oobsize;
262 ops.datbuf = buf;
263 ops.oobbuf = oob;
264 ops.len = len;
265
266 return mtd->write_oob(mtd, offs, &ops);
267}
268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269/**
270 * read_abs_bbts - [GENERIC] Read the bad block table(s) for all chips starting at a given page
271 * @mtd: MTD device structure
272 * @buf: temporary buffer
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000273 * @td: descriptor for the bad block table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 * @md: descriptor for the bad block table mirror
275 *
276 * Read the bad block table(s) for all chips starting at a given page
277 * We assume that the bbt bits are in consecutive order.
278 *
279*/
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200280static int read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
281 struct nand_bbt_descr *td, struct nand_bbt_descr *md)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282{
283 struct nand_chip *this = mtd->priv;
284
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000285 /* Read the primary version, if available */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (td->options & NAND_BBT_VERSION) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200287 scan_read_raw(mtd, buf, td->pages[0] << this->page_shift,
288 mtd->writesize);
Joern Engel28318772006-05-22 23:18:05 +0200289 td->version[0] = buf[mtd->writesize + td->veroffs];
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200290 printk(KERN_DEBUG "Bad block table at page %d, version 0x%02X\n",
291 td->pages[0], td->version[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 }
293
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000294 /* Read the mirror version, if available */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 if (md && (md->options & NAND_BBT_VERSION)) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200296 scan_read_raw(mtd, buf, md->pages[0] << this->page_shift,
297 mtd->writesize);
Joern Engel28318772006-05-22 23:18:05 +0200298 md->version[0] = buf[mtd->writesize + md->veroffs];
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200299 printk(KERN_DEBUG "Bad block table at page %d, version 0x%02X\n",
300 md->pages[0], md->version[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 return 1;
303}
304
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200305/*
306 * Scan a given block full
307 */
308static int scan_block_full(struct mtd_info *mtd, struct nand_bbt_descr *bd,
309 loff_t offs, uint8_t *buf, size_t readlen,
310 int scanlen, int len)
311{
312 int ret, j;
313
314 ret = scan_read_raw(mtd, buf, offs, readlen);
315 if (ret)
316 return ret;
317
318 for (j = 0; j < len; j++, buf += scanlen) {
319 if (check_pattern(buf, scanlen, mtd->writesize, bd))
320 return 1;
321 }
322 return 0;
323}
324
325/*
326 * Scan a given block partially
327 */
328static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
329 loff_t offs, uint8_t *buf, int len)
330{
331 struct mtd_oob_ops ops;
332 int j, ret;
333
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200334 ops.ooblen = mtd->oobsize;
335 ops.oobbuf = buf;
336 ops.ooboffs = 0;
337 ops.datbuf = NULL;
338 ops.mode = MTD_OOB_PLACE;
339
340 for (j = 0; j < len; j++) {
341 /*
342 * Read the full oob until read_oob is fixed to
343 * handle single byte reads for 16 bit
344 * buswidth
345 */
346 ret = mtd->read_oob(mtd, offs, &ops);
347 if (ret)
348 return ret;
349
350 if (check_short_pattern(buf, bd))
351 return 1;
352
353 offs += mtd->writesize;
354 }
355 return 0;
356}
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358/**
359 * create_bbt - [GENERIC] Create a bad block table by scanning the device
360 * @mtd: MTD device structure
361 * @buf: temporary buffer
362 * @bd: descriptor for the good/bad block search pattern
363 * @chip: create the table for a specific chip, -1 read all chips.
364 * Applies only if NAND_BBT_PERCHIP option is set
365 *
366 * Create a bad block table by scanning the device
367 * for the given good/bad block identify pattern
368 */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200369static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
370 struct nand_bbt_descr *bd, int chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
372 struct nand_chip *this = mtd->priv;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200373 int i, numblocks, len, scanlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 int startblock;
375 loff_t from;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200376 size_t readlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
David Woodhousee0c7d762006-05-13 18:07:53 +0100378 printk(KERN_INFO "Scanning device for bad blocks\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 if (bd->options & NAND_BBT_SCANALLPAGES)
381 len = 1 << (this->bbt_erase_shift - this->page_shift);
382 else {
383 if (bd->options & NAND_BBT_SCAN2NDPAGE)
384 len = 2;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000385 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 len = 1;
387 }
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +0000388
389 if (!(bd->options & NAND_BBT_SCANEMPTY)) {
390 /* We need only read few bytes from the OOB area */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200391 scanlen = 0;
Artem B. Bityuckiyeeada242005-02-11 10:14:15 +0000392 readlen = bd->len;
393 } else {
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +0000394 /* Full page content should be read */
Joern Engel28318772006-05-22 23:18:05 +0200395 scanlen = mtd->writesize + mtd->oobsize;
396 readlen = len * mtd->writesize;
Artem B. Bityuckiyeeada242005-02-11 10:14:15 +0000397 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 if (chip == -1) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200400 /* Note that numblocks is 2 * (real numblocks) here, see i+=2
401 * below as it makes shifting and masking less painful */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 numblocks = mtd->size >> (this->bbt_erase_shift - 1);
403 startblock = 0;
404 from = 0;
405 } else {
406 if (chip >= this->numchips) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100407 printk(KERN_WARNING "create_bbt(): chipnr (%d) > available chips (%d)\n",
408 chip + 1, this->numchips);
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +0000409 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 }
411 numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
412 startblock = chip * numblocks;
413 numblocks += startblock;
414 from = startblock << (this->bbt_erase_shift - 1);
415 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 for (i = startblock; i < numblocks;) {
Artem B. Bityuckiyeeada242005-02-11 10:14:15 +0000418 int ret;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000419
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200420 if (bd->options & NAND_BBT_SCANALLPAGES)
421 ret = scan_block_full(mtd, bd, from, buf, readlen,
422 scanlen, len);
423 else
424 ret = scan_block_fast(mtd, bd, from, buf, len);
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +0000425
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200426 if (ret < 0)
427 return ret;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000428
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200429 if (ret) {
430 this->bbt[i >> 3] |= 0x03 << (i & 0x6);
431 printk(KERN_WARNING "Bad eraseblock %d at 0x%08x\n",
432 i >> 1, (unsigned int)from);
Thomas Gleixnerf1a28c02006-05-30 00:37:34 +0200433 mtd->ecc_stats.badblocks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 }
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 i += 2;
437 from += (1 << this->bbt_erase_shift);
438 }
Artem B. Bityuckiyeeada242005-02-11 10:14:15 +0000439 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440}
441
442/**
443 * search_bbt - [GENERIC] scan the device for a specific bad block table
444 * @mtd: MTD device structure
445 * @buf: temporary buffer
446 * @td: descriptor for the bad block table
447 *
448 * Read the bad block table by searching for a given ident pattern.
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000449 * Search is preformed either from the beginning up or from the end of
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 * the device downwards. The search starts always at the start of a
451 * block.
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000452 * If the option NAND_BBT_PERCHIP is given, each chip is searched
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 * for a bbt, which contains the bad block information of this chip.
David Woodhousee0c7d762006-05-13 18:07:53 +0100454 * This is necessary to provide support for certain DOC devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 *
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000456 * The bbt ident pattern resides in the oob area of the first page
457 * in a block.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 */
David Woodhousee0c7d762006-05-13 18:07:53 +0100459static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
461 struct nand_chip *this = mtd->priv;
462 int i, chips;
463 int bits, startblock, block, dir;
Joern Engel28318772006-05-22 23:18:05 +0200464 int scanlen = mtd->writesize + mtd->oobsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 int bbtblocks;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200466 int blocktopage = this->bbt_erase_shift - this->page_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468 /* Search direction top -> down ? */
469 if (td->options & NAND_BBT_LASTBLOCK) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100470 startblock = (mtd->size >> this->bbt_erase_shift) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 dir = -1;
472 } else {
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000473 startblock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 dir = 1;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000475 }
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /* Do we have a bbt per chip ? */
478 if (td->options & NAND_BBT_PERCHIP) {
479 chips = this->numchips;
480 bbtblocks = this->chipsize >> this->bbt_erase_shift;
481 startblock &= bbtblocks - 1;
482 } else {
483 chips = 1;
484 bbtblocks = mtd->size >> this->bbt_erase_shift;
485 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 /* Number of bits for each erase block in the bbt */
488 bits = td->options & NAND_BBT_NRBITS_MSK;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000489
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 for (i = 0; i < chips; i++) {
491 /* Reset version information */
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000492 td->version[i] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 td->pages[i] = -1;
494 /* Scan the maximum number of blocks */
495 for (block = 0; block < td->maxblocks; block++) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 int actblock = startblock + dir * block;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200498 loff_t offs = actblock << this->bbt_erase_shift;
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 /* Read first page */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200501 scan_read_raw(mtd, buf, offs, mtd->writesize);
Joern Engel28318772006-05-22 23:18:05 +0200502 if (!check_pattern(buf, scanlen, mtd->writesize, td)) {
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200503 td->pages[i] = actblock << blocktopage;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if (td->options & NAND_BBT_VERSION) {
Joern Engel28318772006-05-22 23:18:05 +0200505 td->version[i] = buf[mtd->writesize + td->veroffs];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507 break;
508 }
509 }
510 startblock += this->chipsize >> this->bbt_erase_shift;
511 }
512 /* Check, if we found a bbt for each requested chip */
513 for (i = 0; i < chips; i++) {
514 if (td->pages[i] == -1)
David Woodhousee0c7d762006-05-13 18:07:53 +0100515 printk(KERN_WARNING "Bad block table not found for chip %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 else
David Woodhousee0c7d762006-05-13 18:07:53 +0100517 printk(KERN_DEBUG "Bad block table found at page %d, version 0x%02X\n", td->pages[i],
518 td->version[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000520 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521}
522
523/**
524 * search_read_bbts - [GENERIC] scan the device for bad block table(s)
525 * @mtd: MTD device structure
526 * @buf: temporary buffer
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000527 * @td: descriptor for the bad block table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 * @md: descriptor for the bad block table mirror
529 *
530 * Search and read the bad block table(s)
531*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100532static int search_read_bbts(struct mtd_info *mtd, uint8_t * buf, struct nand_bbt_descr *td, struct nand_bbt_descr *md)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
534 /* Search the primary table */
David Woodhousee0c7d762006-05-13 18:07:53 +0100535 search_bbt(mtd, buf, td);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 /* Search the mirror table */
538 if (md)
David Woodhousee0c7d762006-05-13 18:07:53 +0100539 search_bbt(mtd, buf, md);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000541 /* Force result check */
542 return 1;
543}
544
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000545/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 * write_bbt - [GENERIC] (Re)write the bad block table
547 *
548 * @mtd: MTD device structure
549 * @buf: temporary buffer
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000550 * @td: descriptor for the bad block table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 * @md: descriptor for the bad block table mirror
552 * @chipsel: selector for a specific chip, -1 for all
553 *
554 * (Re)write the bad block table
555 *
556*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100557static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
Thomas Gleixner9223a452006-05-23 17:21:03 +0200558 struct nand_bbt_descr *td, struct nand_bbt_descr *md,
559 int chipsel)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
561 struct nand_chip *this = mtd->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 struct erase_info einfo;
563 int i, j, res, chip = 0;
564 int bits, startblock, dir, page, offs, numblocks, sft, sftmsk;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200565 int nrchips, bbtoffs, pageoffs, ooboffs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 uint8_t msk[4];
567 uint8_t rcode = td->reserved_block_code;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200568 size_t retlen, len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 loff_t to;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200570 struct mtd_oob_ops ops;
571
572 ops.ooblen = mtd->oobsize;
573 ops.ooboffs = 0;
574 ops.datbuf = NULL;
575 ops.mode = MTD_OOB_PLACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
577 if (!rcode)
578 rcode = 0xff;
579 /* Write bad block table per chip rather than per device ? */
580 if (td->options & NAND_BBT_PERCHIP) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100581 numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000582 /* Full device write or specific chip ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 if (chipsel == -1) {
584 nrchips = this->numchips;
585 } else {
586 nrchips = chipsel + 1;
587 chip = chipsel;
588 }
589 } else {
David Woodhousee0c7d762006-05-13 18:07:53 +0100590 numblocks = (int)(mtd->size >> this->bbt_erase_shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 nrchips = 1;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000592 }
593
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 /* Loop through the chips */
595 for (; chip < nrchips; chip++) {
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000596
597 /* There was already a version of the table, reuse the page
598 * This applies for absolute placement too, as we have the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 * page nr. in td->pages.
600 */
601 if (td->pages[chip] != -1) {
602 page = td->pages[chip];
603 goto write;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000604 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
606 /* Automatic placement of the bad block table */
607 /* Search direction top -> down ? */
608 if (td->options & NAND_BBT_LASTBLOCK) {
609 startblock = numblocks * (chip + 1) - 1;
610 dir = -1;
611 } else {
612 startblock = chip * numblocks;
613 dir = 1;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000614 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
616 for (i = 0; i < td->maxblocks; i++) {
617 int block = startblock + dir * i;
618 /* Check, if the block is bad */
Thomas Gleixner9223a452006-05-23 17:21:03 +0200619 switch ((this->bbt[block >> 2] >>
620 (2 * (block & 0x03))) & 0x03) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 case 0x01:
622 case 0x03:
623 continue;
624 }
Thomas Gleixner9223a452006-05-23 17:21:03 +0200625 page = block <<
626 (this->bbt_erase_shift - this->page_shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 /* Check, if the block is used by the mirror table */
628 if (!md || md->pages[chip] != page)
629 goto write;
630 }
David Woodhousee0c7d762006-05-13 18:07:53 +0100631 printk(KERN_ERR "No space left to write bad block table\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 return -ENOSPC;
David Woodhousee0c7d762006-05-13 18:07:53 +0100633 write:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
635 /* Set up shift count and masks for the flash table */
636 bits = td->options & NAND_BBT_NRBITS_MSK;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200637 msk[2] = ~rcode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 switch (bits) {
Thomas Gleixner9223a452006-05-23 17:21:03 +0200639 case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01;
640 msk[3] = 0x01;
641 break;
642 case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01;
643 msk[3] = 0x03;
644 break;
645 case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C;
646 msk[3] = 0x0f;
647 break;
648 case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F;
649 msk[3] = 0xff;
650 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 default: return -EINVAL;
652 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 bbtoffs = chip * (numblocks >> 2);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 to = ((loff_t) page) << this->page_shift;
657
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 /* Must we save the block contents ? */
659 if (td->options & NAND_BBT_SAVECONTENT) {
660 /* Make it block aligned */
661 to &= ~((loff_t) ((1 << this->bbt_erase_shift) - 1));
662 len = 1 << this->bbt_erase_shift;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200663 res = mtd->read(mtd, to, len, &retlen, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 if (res < 0) {
665 if (retlen != len) {
Thomas Gleixner9223a452006-05-23 17:21:03 +0200666 printk(KERN_INFO "nand_bbt: Error "
667 "reading block for writing "
668 "the bad block table\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 return res;
670 }
Thomas Gleixner9223a452006-05-23 17:21:03 +0200671 printk(KERN_WARNING "nand_bbt: ECC error "
672 "while reading block for writing "
673 "bad block table\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 }
Thomas Gleixner9223a452006-05-23 17:21:03 +0200675 /* Read oob data */
Vitaly Wool70145682006-11-03 18:20:38 +0300676 ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200677 ops.oobbuf = &buf[len];
678 res = mtd->read_oob(mtd, to + mtd->writesize, &ops);
Vitaly Wool70145682006-11-03 18:20:38 +0300679 if (res < 0 || ops.oobretlen != ops.ooblen)
Thomas Gleixner9223a452006-05-23 17:21:03 +0200680 goto outerr;
681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 /* Calc the byte offset in the buffer */
683 pageoffs = page - (int)(to >> this->page_shift);
684 offs = pageoffs << this->page_shift;
685 /* Preset the bbt area with 0xff */
David Woodhousee0c7d762006-05-13 18:07:53 +0100686 memset(&buf[offs], 0xff, (size_t) (numblocks >> sft));
Thomas Gleixner9223a452006-05-23 17:21:03 +0200687 ooboffs = len + (pageoffs * mtd->oobsize);
688
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 } else {
690 /* Calc length */
691 len = (size_t) (numblocks >> sft);
692 /* Make it page aligned ! */
Thomas Gleixner9223a452006-05-23 17:21:03 +0200693 len = (len + (mtd->writesize - 1)) &
694 ~(mtd->writesize - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 /* Preset the buffer with 0xff */
Thomas Gleixner9223a452006-05-23 17:21:03 +0200696 memset(buf, 0xff, len +
697 (len >> this->page_shift)* mtd->oobsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 offs = 0;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200699 ooboffs = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 /* Pattern is located in oob area of first page */
Thomas Gleixner9223a452006-05-23 17:21:03 +0200701 memcpy(&buf[ooboffs + td->offs], td->pattern, td->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000703
Thomas Gleixner9223a452006-05-23 17:21:03 +0200704 if (td->options & NAND_BBT_VERSION)
705 buf[ooboffs + td->veroffs] = td->version[chip];
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 /* walk through the memory table */
David Woodhousee0c7d762006-05-13 18:07:53 +0100708 for (i = 0; i < numblocks;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 uint8_t dat;
710 dat = this->bbt[bbtoffs + (i >> 2)];
David Woodhousee0c7d762006-05-13 18:07:53 +0100711 for (j = 0; j < 4; j++, i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 int sftcnt = (i << (3 - sft)) & sftmsk;
713 /* Do not store the reserved bbt blocks ! */
Thomas Gleixner9223a452006-05-23 17:21:03 +0200714 buf[offs + (i >> sft)] &=
715 ~(msk[dat & 0x03] << sftcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 dat >>= 2;
717 }
718 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000719
David Woodhousee0c7d762006-05-13 18:07:53 +0100720 memset(&einfo, 0, sizeof(einfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 einfo.mtd = mtd;
David Woodhousee0c7d762006-05-13 18:07:53 +0100722 einfo.addr = (unsigned long)to;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 einfo.len = 1 << this->bbt_erase_shift;
David Woodhousee0c7d762006-05-13 18:07:53 +0100724 res = nand_erase_nand(mtd, &einfo, 1);
Thomas Gleixner9223a452006-05-23 17:21:03 +0200725 if (res < 0)
726 goto outerr;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000727
Thomas Gleixner8593fbc2006-05-29 03:26:58 +0200728 res = scan_write_bbt(mtd, to, len, buf, &buf[len]);
Thomas Gleixner9223a452006-05-23 17:21:03 +0200729 if (res < 0)
730 goto outerr;
731
732 printk(KERN_DEBUG "Bad block table written to 0x%08x, version "
733 "0x%02X\n", (unsigned int)to, td->version[chip]);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 /* Mark it as used */
736 td->pages[chip] = page;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000737 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 return 0;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200739
740 outerr:
741 printk(KERN_WARNING
742 "nand_bbt: Error while writing bad block table %d\n", res);
743 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744}
745
746/**
747 * nand_memory_bbt - [GENERIC] create a memory based bad block table
748 * @mtd: MTD device structure
749 * @bd: descriptor for the good/bad block search pattern
750 *
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000751 * The function creates a memory based bbt by scanning the device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 * for manufacturer / software marked good / bad blocks
753*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100754static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755{
756 struct nand_chip *this = mtd->priv;
757
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +0000758 bd->options &= ~NAND_BBT_SCANEMPTY;
David Woodhouse4bf63fc2006-09-25 17:08:04 +0100759 return create_bbt(mtd, this->buffers->databuf, bd, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760}
761
762/**
David Woodhousee0c7d762006-05-13 18:07:53 +0100763 * check_create - [GENERIC] create and write bbt(s) if necessary
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 * @mtd: MTD device structure
765 * @buf: temporary buffer
766 * @bd: descriptor for the good/bad block search pattern
767 *
768 * The function checks the results of the previous call to read_bbt
David Woodhousee0c7d762006-05-13 18:07:53 +0100769 * and creates / updates the bbt(s) if necessary
770 * Creation is necessary if no bbt was found for the chip/device
771 * Update is necessary if one of the tables is missing or the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 * version nr. of one table is less than the other
773*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100774static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775{
776 int i, chips, writeops, chipsel, res;
777 struct nand_chip *this = mtd->priv;
778 struct nand_bbt_descr *td = this->bbt_td;
779 struct nand_bbt_descr *md = this->bbt_md;
780 struct nand_bbt_descr *rd, *rd2;
781
782 /* Do we have a bbt per chip ? */
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000783 if (td->options & NAND_BBT_PERCHIP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 chips = this->numchips;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000785 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 chips = 1;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000787
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 for (i = 0; i < chips; i++) {
789 writeops = 0;
790 rd = NULL;
791 rd2 = NULL;
792 /* Per chip or per device ? */
793 chipsel = (td->options & NAND_BBT_PERCHIP) ? i : -1;
794 /* Mirrored table avilable ? */
795 if (md) {
796 if (td->pages[i] == -1 && md->pages[i] == -1) {
797 writeops = 0x03;
798 goto create;
799 }
800
801 if (td->pages[i] == -1) {
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000802 rd = md;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 td->version[i] = md->version[i];
804 writeops = 1;
805 goto writecheck;
806 }
807
808 if (md->pages[i] == -1) {
809 rd = td;
810 md->version[i] = td->version[i];
811 writeops = 2;
812 goto writecheck;
813 }
814
815 if (td->version[i] == md->version[i]) {
816 rd = td;
817 if (!(td->options & NAND_BBT_VERSION))
818 rd2 = md;
819 goto writecheck;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000820 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
822 if (((int8_t) (td->version[i] - md->version[i])) > 0) {
823 rd = td;
824 md->version[i] = td->version[i];
825 writeops = 2;
826 } else {
827 rd = md;
828 td->version[i] = md->version[i];
829 writeops = 1;
830 }
831
832 goto writecheck;
833
834 } else {
835 if (td->pages[i] == -1) {
836 writeops = 0x01;
837 goto create;
838 }
839 rd = td;
840 goto writecheck;
841 }
David Woodhousee0c7d762006-05-13 18:07:53 +0100842 create:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 /* Create the bad block table by scanning the device ? */
844 if (!(td->options & NAND_BBT_CREATE))
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000845 continue;
846
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 /* Create the table in memory by scanning the chip(s) */
David Woodhousee0c7d762006-05-13 18:07:53 +0100848 create_bbt(mtd, buf, bd, chipsel);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 td->version[i] = 1;
851 if (md)
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000852 md->version[i] = 1;
David Woodhousee0c7d762006-05-13 18:07:53 +0100853 writecheck:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 /* read back first ? */
855 if (rd)
David Woodhousee0c7d762006-05-13 18:07:53 +0100856 read_abs_bbt(mtd, buf, rd, chipsel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 /* If they weren't versioned, read both. */
858 if (rd2)
David Woodhousee0c7d762006-05-13 18:07:53 +0100859 read_abs_bbt(mtd, buf, rd2, chipsel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
861 /* Write the bad block table to the device ? */
862 if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100863 res = write_bbt(mtd, buf, td, md, chipsel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 if (res < 0)
865 return res;
866 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000867
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 /* Write the mirror bad block table to the device ? */
869 if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100870 res = write_bbt(mtd, buf, md, td, chipsel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 if (res < 0)
872 return res;
873 }
874 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000875 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876}
877
878/**
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000879 * mark_bbt_regions - [GENERIC] mark the bad block table regions
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 * @mtd: MTD device structure
881 * @td: bad block table descriptor
882 *
883 * The bad block table regions are marked as "bad" to prevent
884 * accidental erasures / writes. The regions are identified by
885 * the mark 0x02.
886*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100887static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888{
889 struct nand_chip *this = mtd->priv;
890 int i, j, chips, block, nrblocks, update;
891 uint8_t oldval, newval;
892
893 /* Do we have a bbt per chip ? */
894 if (td->options & NAND_BBT_PERCHIP) {
895 chips = this->numchips;
896 nrblocks = (int)(this->chipsize >> this->bbt_erase_shift);
897 } else {
898 chips = 1;
899 nrblocks = (int)(mtd->size >> this->bbt_erase_shift);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000900 }
901
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 for (i = 0; i < chips; i++) {
903 if ((td->options & NAND_BBT_ABSPAGE) ||
904 !(td->options & NAND_BBT_WRITE)) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100905 if (td->pages[i] == -1)
906 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000908 block <<= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 oldval = this->bbt[(block >> 3)];
910 newval = oldval | (0x2 << (block & 0x06));
911 this->bbt[(block >> 3)] = newval;
912 if ((oldval != newval) && td->reserved_block_code)
913 nand_update_bbt(mtd, block << (this->bbt_erase_shift - 1));
914 continue;
915 }
916 update = 0;
917 if (td->options & NAND_BBT_LASTBLOCK)
918 block = ((i + 1) * nrblocks) - td->maxblocks;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000919 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 block = i * nrblocks;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000921 block <<= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 for (j = 0; j < td->maxblocks; j++) {
923 oldval = this->bbt[(block >> 3)];
924 newval = oldval | (0x2 << (block & 0x06));
925 this->bbt[(block >> 3)] = newval;
David Woodhousee0c7d762006-05-13 18:07:53 +0100926 if (oldval != newval)
927 update = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 block += 2;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000929 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 /* If we want reserved blocks to be recorded to flash, and some
931 new ones have been marked, then we need to update the stored
932 bbts. This should only happen once. */
933 if (update && td->reserved_block_code)
934 nand_update_bbt(mtd, (block - 2) << (this->bbt_erase_shift - 1));
935 }
936}
937
938/**
939 * nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)
940 * @mtd: MTD device structure
941 * @bd: descriptor for the good/bad block search pattern
942 *
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000943 * The function checks, if a bad block table(s) is/are already
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 * available. If not it scans the device for manufacturer
945 * marked good / bad blocks and writes the bad block table(s) to
946 * the selected place.
947 *
948 * The bad block table memory is allocated here. It must be freed
949 * by calling the nand_free_bbt function.
950 *
951*/
David Woodhousee0c7d762006-05-13 18:07:53 +0100952int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953{
954 struct nand_chip *this = mtd->priv;
955 int len, res = 0;
956 uint8_t *buf;
957 struct nand_bbt_descr *td = this->bbt_td;
958 struct nand_bbt_descr *md = this->bbt_md;
959
960 len = mtd->size >> (this->bbt_erase_shift + 2);
Burman Yan95b93a02006-11-15 21:10:29 +0200961 /* Allocate memory (2bit per block) and clear the memory bad block table */
962 this->bbt = kzalloc(len, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 if (!this->bbt) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100964 printk(KERN_ERR "nand_scan_bbt: Out of memory\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 return -ENOMEM;
966 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
968 /* If no primary table decriptor is given, scan the device
969 * to build a memory based bad block table
970 */
Artem B. Bityuckiyeeada242005-02-11 10:14:15 +0000971 if (!td) {
972 if ((res = nand_memory_bbt(mtd, bd))) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100973 printk(KERN_ERR "nand_bbt: Can't scan flash and build the RAM-based BBT\n");
974 kfree(this->bbt);
Artem B. Bityuckiyeeada242005-02-11 10:14:15 +0000975 this->bbt = NULL;
976 }
977 return res;
978 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980 /* Allocate a temporary buffer for one eraseblock incl. oob */
981 len = (1 << this->bbt_erase_shift);
982 len += (len >> this->page_shift) * mtd->oobsize;
David Woodhousec3f8abf2006-05-13 04:03:42 +0100983 buf = vmalloc(len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 if (!buf) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100985 printk(KERN_ERR "nand_bbt: Out of memory\n");
986 kfree(this->bbt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 this->bbt = NULL;
988 return -ENOMEM;
989 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000990
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 /* Is the bbt at a given page ? */
992 if (td->options & NAND_BBT_ABSPAGE) {
David Woodhousee0c7d762006-05-13 18:07:53 +0100993 res = read_abs_bbts(mtd, buf, td, md);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000994 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 /* Search the bad block table using a pattern in oob */
David Woodhousee0c7d762006-05-13 18:07:53 +0100996 res = search_read_bbts(mtd, buf, td, md);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000997 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Thomas Gleixner61b03bd2005-11-07 11:15:49 +0000999 if (res)
David Woodhousee0c7d762006-05-13 18:07:53 +01001000 res = check_create(mtd, buf, bd);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001001
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 /* Prevent the bbt regions from erasing / writing */
David Woodhousee0c7d762006-05-13 18:07:53 +01001003 mark_bbt_region(mtd, td);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 if (md)
David Woodhousee0c7d762006-05-13 18:07:53 +01001005 mark_bbt_region(mtd, md);
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001006
David Woodhousee0c7d762006-05-13 18:07:53 +01001007 vfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 return res;
1009}
1010
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011/**
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001012 * nand_update_bbt - [NAND Interface] update bad block table(s)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 * @mtd: MTD device structure
1014 * @offs: the offset of the newly marked block
1015 *
1016 * The function updates the bad block table(s)
1017*/
David Woodhousee0c7d762006-05-13 18:07:53 +01001018int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019{
1020 struct nand_chip *this = mtd->priv;
1021 int len, res = 0, writeops = 0;
1022 int chip, chipsel;
1023 uint8_t *buf;
1024 struct nand_bbt_descr *td = this->bbt_td;
1025 struct nand_bbt_descr *md = this->bbt_md;
1026
1027 if (!this->bbt || !td)
1028 return -EINVAL;
1029
1030 len = mtd->size >> (this->bbt_erase_shift + 2);
1031 /* Allocate a temporary buffer for one eraseblock incl. oob */
1032 len = (1 << this->bbt_erase_shift);
1033 len += (len >> this->page_shift) * mtd->oobsize;
David Woodhousee0c7d762006-05-13 18:07:53 +01001034 buf = kmalloc(len, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 if (!buf) {
David Woodhousee0c7d762006-05-13 18:07:53 +01001036 printk(KERN_ERR "nand_update_bbt: Out of memory\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 return -ENOMEM;
1038 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001039
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 writeops = md != NULL ? 0x03 : 0x01;
1041
1042 /* Do we have a bbt per chip ? */
1043 if (td->options & NAND_BBT_PERCHIP) {
David Woodhousee0c7d762006-05-13 18:07:53 +01001044 chip = (int)(offs >> this->chip_shift);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 chipsel = chip;
1046 } else {
1047 chip = 0;
1048 chipsel = -1;
1049 }
1050
1051 td->version[chip]++;
1052 if (md)
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001053 md->version[chip]++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
1055 /* Write the bad block table to the device ? */
1056 if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
David Woodhousee0c7d762006-05-13 18:07:53 +01001057 res = write_bbt(mtd, buf, td, md, chipsel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 if (res < 0)
1059 goto out;
1060 }
1061 /* Write the mirror bad block table to the device ? */
1062 if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
David Woodhousee0c7d762006-05-13 18:07:53 +01001063 res = write_bbt(mtd, buf, md, td, chipsel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 }
1065
David Woodhousee0c7d762006-05-13 18:07:53 +01001066 out:
1067 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return res;
1069}
1070
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001071/* Define some generic bad / good block scan pattern which are used
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +00001072 * while scanning a device for factory marked good / bad blocks. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
1074
1075static struct nand_bbt_descr smallpage_memorybased = {
Artem B. Bityuckiy171650a2005-02-16 17:09:39 +00001076 .options = NAND_BBT_SCAN2NDPAGE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 .offs = 5,
1078 .len = 1,
1079 .pattern = scan_ff_pattern
1080};
1081
1082static struct nand_bbt_descr largepage_memorybased = {
1083 .options = 0,
1084 .offs = 0,
1085 .len = 2,
1086 .pattern = scan_ff_pattern
1087};
1088
1089static struct nand_bbt_descr smallpage_flashbased = {
David Woodhouse6943f8a2006-05-13 16:14:26 +01001090 .options = NAND_BBT_SCAN2NDPAGE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 .offs = 5,
1092 .len = 1,
1093 .pattern = scan_ff_pattern
1094};
1095
1096static struct nand_bbt_descr largepage_flashbased = {
David Woodhouse6943f8a2006-05-13 16:14:26 +01001097 .options = NAND_BBT_SCAN2NDPAGE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 .offs = 0,
1099 .len = 2,
1100 .pattern = scan_ff_pattern
1101};
1102
1103static uint8_t scan_agand_pattern[] = { 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7 };
1104
1105static struct nand_bbt_descr agand_flashbased = {
1106 .options = NAND_BBT_SCANEMPTY | NAND_BBT_SCANALLPAGES,
1107 .offs = 0x20,
1108 .len = 6,
1109 .pattern = scan_agand_pattern
1110};
1111
1112/* Generic flash bbt decriptors
1113*/
1114static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
1115static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
1116
1117static struct nand_bbt_descr bbt_main_descr = {
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001118 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1120 .offs = 8,
1121 .len = 4,
1122 .veroffs = 12,
1123 .maxblocks = 4,
1124 .pattern = bbt_pattern
1125};
1126
1127static struct nand_bbt_descr bbt_mirror_descr = {
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001128 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1130 .offs = 8,
1131 .len = 4,
1132 .veroffs = 12,
1133 .maxblocks = 4,
1134 .pattern = mirror_pattern
1135};
1136
1137/**
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001138 * nand_default_bbt - [NAND Interface] Select a default bad block table for the device
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 * @mtd: MTD device structure
1140 *
1141 * This function selects the default bad block table
1142 * support for the device and calls the nand_scan_bbt function
1143 *
1144*/
David Woodhousee0c7d762006-05-13 18:07:53 +01001145int nand_default_bbt(struct mtd_info *mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146{
1147 struct nand_chip *this = mtd->priv;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001148
1149 /* Default for AG-AND. We must use a flash based
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 * bad block table as the devices have factory marked
1151 * _good_ blocks. Erasing those blocks leads to loss
1152 * of the good / bad information, so we _must_ store
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001153 * this information in a good / bad table during
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 * startup
David Woodhousee0c7d762006-05-13 18:07:53 +01001155 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 if (this->options & NAND_IS_AND) {
1157 /* Use the default pattern descriptors */
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001158 if (!this->bbt_td) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 this->bbt_td = &bbt_main_descr;
1160 this->bbt_md = &bbt_mirror_descr;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 this->options |= NAND_USE_FLASH_BBT;
David Woodhousee0c7d762006-05-13 18:07:53 +01001163 return nand_scan_bbt(mtd, &agand_flashbased);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 }
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001165
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 /* Is a flash based bad block table requested ? */
1167 if (this->options & NAND_USE_FLASH_BBT) {
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001168 /* Use the default pattern descriptors */
1169 if (!this->bbt_td) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 this->bbt_td = &bbt_main_descr;
1171 this->bbt_md = &bbt_mirror_descr;
1172 }
1173 if (!this->badblock_pattern) {
Joern Engel28318772006-05-22 23:18:05 +02001174 this->badblock_pattern = (mtd->writesize > 512) ? &largepage_flashbased : &smallpage_flashbased;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
1176 } else {
1177 this->bbt_td = NULL;
1178 this->bbt_md = NULL;
1179 if (!this->badblock_pattern) {
Joern Engel28318772006-05-22 23:18:05 +02001180 this->badblock_pattern = (mtd->writesize > 512) ?
David Woodhousee0c7d762006-05-13 18:07:53 +01001181 &largepage_memorybased : &smallpage_memorybased;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 }
1183 }
David Woodhousee0c7d762006-05-13 18:07:53 +01001184 return nand_scan_bbt(mtd, this->badblock_pattern);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185}
1186
1187/**
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001188 * nand_isbad_bbt - [NAND Interface] Check if a block is bad
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 * @mtd: MTD device structure
1190 * @offs: offset in the device
1191 * @allowbbt: allow access to bad block table region
1192 *
1193*/
David Woodhousee0c7d762006-05-13 18:07:53 +01001194int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195{
1196 struct nand_chip *this = mtd->priv;
1197 int block;
David Woodhousee0c7d762006-05-13 18:07:53 +01001198 uint8_t res;
Thomas Gleixner61b03bd2005-11-07 11:15:49 +00001199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 /* Get block number * 2 */
David Woodhousee0c7d762006-05-13 18:07:53 +01001201 block = (int)(offs >> (this->bbt_erase_shift - 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 res = (this->bbt[block >> 3] >> (block & 0x06)) & 0x03;
1203
David Woodhousee0c7d762006-05-13 18:07:53 +01001204 DEBUG(MTD_DEBUG_LEVEL2, "nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n",
1205 (unsigned int)offs, block >> 1, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206
1207 switch ((int)res) {
David Woodhousee0c7d762006-05-13 18:07:53 +01001208 case 0x00:
1209 return 0;
1210 case 0x01:
1211 return 1;
1212 case 0x02:
1213 return allowbbt ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 }
1215 return 1;
1216}
1217
David Woodhousee0c7d762006-05-13 18:07:53 +01001218EXPORT_SYMBOL(nand_scan_bbt);
1219EXPORT_SYMBOL(nand_default_bbt);