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