blob: 8ef58451d522131ba3b9bec3c116531c94217681 [file] [log] [blame]
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001/*
2 * drivers/mtd/nand_bbt.c
3 *
4 * Overview:
5 * Bad block table support for the NAND driver
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02006 *
Sergey Lapin3a38a552013-01-14 03:46:50 +00007 * Copyright © 2004 Thomas Gleixner (tglx@linutronix.de)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02008 *
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02009 * 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 *
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020015 * When nand_scan_bbt is called, then it tries to find the bad block table
Christian Hitz24e6ea42011-10-12 09:32:04 +020016 * depending on the options in the BBT descriptor(s). If no flash based BBT
Sergey Lapin3a38a552013-01-14 03:46:50 +000017 * (NAND_BBT_USE_FLASH) is specified then the device is scanned for factory
Christian Hitz24e6ea42011-10-12 09:32:04 +020018 * 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
Sergey Lapin3a38a552013-01-14 03:46:50 +000025 * version number, then the mirror BBT is used to build the memory based BBT.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020026 * If the tables are not versioned, then we "or" the bad block information.
Christian Hitz24e6ea42011-10-12 09:32:04 +020027 * 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
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020029 * good / bad blocks and the bad block tables are created.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020030 *
Christian Hitz24e6ea42011-10-12 09:32:04 +020031 * For manufacturer created BBTs like the one found on M-SYS DOC devices
32 * the BBT is searched and read but never created
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020033 *
Christian Hitz24e6ea42011-10-12 09:32:04 +020034 * The auto generated bad block table is located in the last good blocks
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020035 * of the device. The table is mirrored, so it can be updated eventually.
Christian Hitz24e6ea42011-10-12 09:32:04 +020036 * 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
Sergey Lapin3a38a552013-01-14 03:46:50 +000039 * 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.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020042 *
43 * The table uses 2 bits per block
Christian Hitz24e6ea42011-10-12 09:32:04 +020044 * 11b: block is good
45 * 00b: block is factory marked bad
Wolfgang Denka1be4762008-05-20 16:00:29 +020046 * 01b, 10b: block is marked bad due to wear
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020047 *
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
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020053 *
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020054 * 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
William Juul52c07962007-10-31 13:53:06 +010058 * - the space necessary for a bbt in FLASH does not exceed a block boundary
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020059 *
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020060 */
61
62#include <common.h>
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020063#include <malloc.h>
Mike Frysinger11d1a092012-04-09 13:39:55 +000064#include <linux/compat.h>
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020065#include <linux/mtd/mtd.h>
Sergey Lapin3a38a552013-01-14 03:46:50 +000066#include <linux/mtd/bbm.h>
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020067#include <linux/mtd/nand.h>
Christian Hitz24e6ea42011-10-12 09:32:04 +020068#include <linux/mtd/nand_ecc.h>
69#include <linux/bitops.h>
Sergey Lapin3a38a552013-01-14 03:46:50 +000070#include <linux/string.h>
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020071
72#include <asm/errno.h>
73
Christian Hitz24e6ea42011-10-12 09:32:04 +020074static int check_pattern_no_oob(uint8_t *buf, struct nand_bbt_descr *td)
75{
Sergey Lapin3a38a552013-01-14 03:46:50 +000076 if (memcmp(buf, td->pattern, td->len))
77 return -1;
78 return 0;
Christian Hitz24e6ea42011-10-12 09:32:04 +020079}
80
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020081/**
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020082 * check_pattern - [GENERIC] check if a pattern is in the buffer
Sergey Lapin3a38a552013-01-14 03:46:50 +000083 * @buf: the buffer to search
84 * @len: the length of buffer to search
85 * @paglen: the pagelength
86 * @td: search pattern descriptor
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020087 *
Sergey Lapin3a38a552013-01-14 03:46:50 +000088 * Check for a pattern at the given place. Used to search bad block tables and
89 * good / bad block identifiers. If the SCAN_EMPTY option is set then check, if
90 * all bytes except the pattern area contain 0xff.
91 */
William Juul52c07962007-10-31 13:53:06 +010092static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020093{
Sergey Lapin3a38a552013-01-14 03:46:50 +000094 int end = 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020095 uint8_t *p = buf;
96
Christian Hitz24e6ea42011-10-12 09:32:04 +020097 if (td->options & NAND_BBT_NO_OOB)
98 return check_pattern_no_oob(buf, td);
99
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200100 end = paglen + td->offs;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000101 if (td->options & NAND_BBT_SCANEMPTY)
102 if (memchr_inv(p, 0xff, end))
103 return -1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200104 p += end;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200105
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200106 /* Compare the pattern */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000107 if (memcmp(p, td->pattern, td->len))
108 return -1;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200109
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200110 if (td->options & NAND_BBT_SCANEMPTY) {
William Juul52c07962007-10-31 13:53:06 +0100111 p += td->len;
112 end += td->len;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000113 if (memchr_inv(p, 0xff, len - end))
114 return -1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200115 }
116 return 0;
117}
118
119/**
William Juul52c07962007-10-31 13:53:06 +0100120 * check_short_pattern - [GENERIC] check if a pattern is in the buffer
Sergey Lapin3a38a552013-01-14 03:46:50 +0000121 * @buf: the buffer to search
122 * @td: search pattern descriptor
William Juul52c07962007-10-31 13:53:06 +0100123 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000124 * Check for a pattern at the given place. Used to search bad block tables and
125 * good / bad block identifiers. Same as check_pattern, but no optional empty
126 * check.
127 */
William Juul52c07962007-10-31 13:53:06 +0100128static int check_short_pattern(uint8_t *buf, struct nand_bbt_descr *td)
129{
William Juul52c07962007-10-31 13:53:06 +0100130 /* Compare the pattern */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000131 if (memcmp(buf + td->offs, td->pattern, td->len))
132 return -1;
William Juul52c07962007-10-31 13:53:06 +0100133 return 0;
134}
135
136/**
Christian Hitz24e6ea42011-10-12 09:32:04 +0200137 * add_marker_len - compute the length of the marker in data area
Sergey Lapin3a38a552013-01-14 03:46:50 +0000138 * @td: BBT descriptor used for computation
Christian Hitz24e6ea42011-10-12 09:32:04 +0200139 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000140 * The length will be 0 if the marker is located in OOB area.
Christian Hitz24e6ea42011-10-12 09:32:04 +0200141 */
142static u32 add_marker_len(struct nand_bbt_descr *td)
143{
144 u32 len;
145
146 if (!(td->options & NAND_BBT_NO_OOB))
147 return 0;
148
149 len = td->len;
150 if (td->options & NAND_BBT_VERSION)
151 len++;
152 return len;
153}
154
155/**
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200156 * read_bbt - [GENERIC] Read the bad block table starting from page
Sergey Lapin3a38a552013-01-14 03:46:50 +0000157 * @mtd: MTD device structure
158 * @buf: temporary buffer
159 * @page: the starting page
160 * @num: the number of bbt descriptors to read
161 * @td: the bbt describtion table
162 * @offs: offset in the memory table
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200163 *
164 * Read the bad block table starting from page.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200165 */
William Juul52c07962007-10-31 13:53:06 +0100166static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
Christian Hitz24e6ea42011-10-12 09:32:04 +0200167 struct nand_bbt_descr *td, int offs)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200168{
Sergey Lapin3a38a552013-01-14 03:46:50 +0000169 int res, ret = 0, i, j, act = 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200170 struct nand_chip *this = mtd->priv;
171 size_t retlen, len, totlen;
172 loff_t from;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200173 int bits = td->options & NAND_BBT_NRBITS_MSK;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000174 uint8_t msk = (uint8_t)((1 << bits) - 1);
Christian Hitz24e6ea42011-10-12 09:32:04 +0200175 u32 marker_len;
176 int reserved_block_code = td->reserved_block_code;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200177
178 totlen = (num * bits) >> 3;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200179 marker_len = add_marker_len(td);
Sergey Lapin3a38a552013-01-14 03:46:50 +0000180 from = ((loff_t)page) << this->page_shift;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200181
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200182 while (totlen) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000183 len = min(totlen, (size_t)(1 << this->bbt_erase_shift));
Christian Hitz24e6ea42011-10-12 09:32:04 +0200184 if (marker_len) {
185 /*
186 * In case the BBT marker is not in the OOB area it
187 * will be just in the first page.
188 */
189 len -= marker_len;
190 from += marker_len;
191 marker_len = 0;
192 }
Sergey Lapin3a38a552013-01-14 03:46:50 +0000193 res = mtd_read(mtd, from, len, &retlen, buf);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200194 if (res < 0) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000195 if (mtd_is_eccerr(res)) {
196 pr_info("nand_bbt: ECC error in BBT at "
197 "0x%012llx\n", from & ~mtd->writesize);
198 return res;
199 } else if (mtd_is_bitflip(res)) {
200 pr_info("nand_bbt: corrected error in BBT at "
201 "0x%012llx\n", from & ~mtd->writesize);
202 ret = res;
203 } else {
204 pr_info("nand_bbt: error reading BBT\n");
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200205 return res;
206 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200207 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200208
209 /* Analyse data */
210 for (i = 0; i < len; i++) {
211 uint8_t dat = buf[i];
212 for (j = 0; j < 8; j += bits, act += 2) {
213 uint8_t tmp = (dat >> j) & msk;
214 if (tmp == msk)
215 continue;
William Juul52c07962007-10-31 13:53:06 +0100216 if (reserved_block_code && (tmp == reserved_block_code)) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000217 pr_info("nand_read_bbt: reserved block at 0x%012llx\n",
218 (loff_t)((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200219 this->bbt[offs + (act >> 3)] |= 0x2 << (act & 0x06);
William Juul52c07962007-10-31 13:53:06 +0100220 mtd->ecc_stats.bbtblocks++;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200221 continue;
222 }
Sergey Lapin3a38a552013-01-14 03:46:50 +0000223 pr_info("nand_read_bbt: Bad block at 0x%012llx\n",
Heiko Schocher435d3512012-02-14 22:34:05 +0000224 (loff_t)((offs << 2) + (act >> 1))
225 << this->bbt_erase_shift);
Sergey Lapin3a38a552013-01-14 03:46:50 +0000226 /* Factory marked bad or worn out? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200227 if (tmp == 0)
228 this->bbt[offs + (act >> 3)] |= 0x3 << (act & 0x06);
229 else
230 this->bbt[offs + (act >> 3)] |= 0x1 << (act & 0x06);
William Juul52c07962007-10-31 13:53:06 +0100231 mtd->ecc_stats.badblocks++;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200232 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200233 }
234 totlen -= len;
235 from += len;
236 }
Sergey Lapin3a38a552013-01-14 03:46:50 +0000237 return ret;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200238}
239
240/**
241 * read_abs_bbt - [GENERIC] Read the bad block table starting at a given page
Sergey Lapin3a38a552013-01-14 03:46:50 +0000242 * @mtd: MTD device structure
243 * @buf: temporary buffer
244 * @td: descriptor for the bad block table
245 * @chip: read the table for a specific chip, -1 read all chips; applies only if
246 * NAND_BBT_PERCHIP option is set
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200247 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000248 * Read the bad block table for all chips starting at a given page. We assume
249 * that the bbt bits are in consecutive order.
250 */
William Juul52c07962007-10-31 13:53:06 +0100251static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200252{
253 struct nand_chip *this = mtd->priv;
254 int res = 0, i;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200255
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200256 if (td->options & NAND_BBT_PERCHIP) {
257 int offs = 0;
258 for (i = 0; i < this->numchips; i++) {
259 if (chip == -1 || chip == i)
Christian Hitz24e6ea42011-10-12 09:32:04 +0200260 res = read_bbt(mtd, buf, td->pages[i],
261 this->chipsize >> this->bbt_erase_shift,
262 td, offs);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200263 if (res)
264 return res;
265 offs += this->chipsize >> (this->bbt_erase_shift + 2);
266 }
267 } else {
Christian Hitz24e6ea42011-10-12 09:32:04 +0200268 res = read_bbt(mtd, buf, td->pages[0],
269 mtd->size >> this->bbt_erase_shift, td, 0);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200270 if (res)
271 return res;
272 }
273 return 0;
274}
275
Sergey Lapin3a38a552013-01-14 03:46:50 +0000276/* BBT marker is in the first page, no OOB */
277static int scan_read_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
Christian Hitz24e6ea42011-10-12 09:32:04 +0200278 struct nand_bbt_descr *td)
279{
280 size_t retlen;
281 size_t len;
282
283 len = td->len;
284 if (td->options & NAND_BBT_VERSION)
285 len++;
286
Sergey Lapin3a38a552013-01-14 03:46:50 +0000287 return mtd_read(mtd, offs, len, &retlen, buf);
Christian Hitz24e6ea42011-10-12 09:32:04 +0200288}
289
Sergey Lapin3a38a552013-01-14 03:46:50 +0000290/**
291 * scan_read_oob - [GENERIC] Scan data+OOB region to buffer
292 * @mtd: MTD device structure
293 * @buf: temporary buffer
294 * @offs: offset at which to scan
295 * @len: length of data region to read
296 *
297 * Scan read data from data+OOB. May traverse multiple pages, interleaving
298 * page,OOB,page,OOB,... in buf. Completes transfer and returns the "strongest"
299 * ECC condition (error or bitflip). May quit on the first (non-ECC) error.
William Juul52c07962007-10-31 13:53:06 +0100300 */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000301static int scan_read_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
William Juul52c07962007-10-31 13:53:06 +0100302 size_t len)
303{
304 struct mtd_oob_ops ops;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000305 int res, ret = 0;
William Juul52c07962007-10-31 13:53:06 +0100306
Sergey Lapin3a38a552013-01-14 03:46:50 +0000307 ops.mode = MTD_OPS_PLACE_OOB;
William Juul52c07962007-10-31 13:53:06 +0100308 ops.ooboffs = 0;
309 ops.ooblen = mtd->oobsize;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200310
Christian Hitz24e6ea42011-10-12 09:32:04 +0200311 while (len > 0) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000312 ops.datbuf = buf;
313 ops.len = min(len, (size_t)mtd->writesize);
314 ops.oobbuf = buf + ops.len;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200315
Sergey Lapin3a38a552013-01-14 03:46:50 +0000316 res = mtd_read_oob(mtd, offs, &ops);
317 if (res) {
318 if (!mtd_is_bitflip_or_eccerr(res))
Christian Hitz24e6ea42011-10-12 09:32:04 +0200319 return res;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000320 else if (mtd_is_eccerr(res) || !ret)
321 ret = res;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200322 }
323
324 buf += mtd->oobsize + mtd->writesize;
325 len -= mtd->writesize;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000326 offs += mtd->writesize;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200327 }
Sergey Lapin3a38a552013-01-14 03:46:50 +0000328 return ret;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200329}
William Juul52c07962007-10-31 13:53:06 +0100330
Sergey Lapin3a38a552013-01-14 03:46:50 +0000331static int scan_read(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
Christian Hitz24e6ea42011-10-12 09:32:04 +0200332 size_t len, struct nand_bbt_descr *td)
333{
334 if (td->options & NAND_BBT_NO_OOB)
Sergey Lapin3a38a552013-01-14 03:46:50 +0000335 return scan_read_data(mtd, buf, offs, td);
Christian Hitz24e6ea42011-10-12 09:32:04 +0200336 else
Sergey Lapin3a38a552013-01-14 03:46:50 +0000337 return scan_read_oob(mtd, buf, offs, len);
William Juul52c07962007-10-31 13:53:06 +0100338}
339
Sergey Lapin3a38a552013-01-14 03:46:50 +0000340/* Scan write data with oob to flash */
William Juul52c07962007-10-31 13:53:06 +0100341static int scan_write_bbt(struct mtd_info *mtd, loff_t offs, size_t len,
342 uint8_t *buf, uint8_t *oob)
343{
344 struct mtd_oob_ops ops;
345
Sergey Lapin3a38a552013-01-14 03:46:50 +0000346 ops.mode = MTD_OPS_PLACE_OOB;
William Juul52c07962007-10-31 13:53:06 +0100347 ops.ooboffs = 0;
348 ops.ooblen = mtd->oobsize;
349 ops.datbuf = buf;
350 ops.oobbuf = oob;
351 ops.len = len;
352
Sergey Lapin3a38a552013-01-14 03:46:50 +0000353 return mtd_write_oob(mtd, offs, &ops);
William Juul52c07962007-10-31 13:53:06 +0100354}
355
Christian Hitz24e6ea42011-10-12 09:32:04 +0200356static u32 bbt_get_ver_offs(struct mtd_info *mtd, struct nand_bbt_descr *td)
357{
358 u32 ver_offs = td->veroffs;
359
360 if (!(td->options & NAND_BBT_NO_OOB))
361 ver_offs += mtd->writesize;
362 return ver_offs;
363}
364
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200365/**
366 * read_abs_bbts - [GENERIC] Read the bad block table(s) for all chips starting at a given page
Sergey Lapin3a38a552013-01-14 03:46:50 +0000367 * @mtd: MTD device structure
368 * @buf: temporary buffer
369 * @td: descriptor for the bad block table
370 * @md: descriptor for the bad block table mirror
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200371 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000372 * Read the bad block table(s) for all chips starting at a given page. We
373 * assume that the bbt bits are in consecutive order.
374 */
375static void read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
376 struct nand_bbt_descr *td, struct nand_bbt_descr *md)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200377{
378 struct nand_chip *this = mtd->priv;
379
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200380 /* Read the primary version, if available */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200381 if (td->options & NAND_BBT_VERSION) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000382 scan_read(mtd, buf, (loff_t)td->pages[0] << this->page_shift,
Christian Hitz24e6ea42011-10-12 09:32:04 +0200383 mtd->writesize, td);
384 td->version[0] = buf[bbt_get_ver_offs(mtd, td)];
Sergey Lapin3a38a552013-01-14 03:46:50 +0000385 pr_info("Bad block table at page %d, version 0x%02X\n",
386 td->pages[0], td->version[0]);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200387 }
388
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200389 /* Read the mirror version, if available */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200390 if (md && (md->options & NAND_BBT_VERSION)) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000391 scan_read(mtd, buf, (loff_t)md->pages[0] << this->page_shift,
392 mtd->writesize, md);
Christian Hitz24e6ea42011-10-12 09:32:04 +0200393 md->version[0] = buf[bbt_get_ver_offs(mtd, md)];
Sergey Lapin3a38a552013-01-14 03:46:50 +0000394 pr_info("Bad block table at page %d, version 0x%02X\n",
395 md->pages[0], md->version[0]);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200396 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200397}
398
Sergey Lapin3a38a552013-01-14 03:46:50 +0000399/* Scan a given block full */
William Juul52c07962007-10-31 13:53:06 +0100400static int scan_block_full(struct mtd_info *mtd, struct nand_bbt_descr *bd,
401 loff_t offs, uint8_t *buf, size_t readlen,
Sergey Lapin3a38a552013-01-14 03:46:50 +0000402 int scanlen, int numpages)
William Juul52c07962007-10-31 13:53:06 +0100403{
404 int ret, j;
405
Sergey Lapin3a38a552013-01-14 03:46:50 +0000406 ret = scan_read_oob(mtd, buf, offs, readlen);
407 /* Ignore ECC errors when checking for BBM */
408 if (ret && !mtd_is_bitflip_or_eccerr(ret))
William Juul52c07962007-10-31 13:53:06 +0100409 return ret;
410
Sergey Lapin3a38a552013-01-14 03:46:50 +0000411 for (j = 0; j < numpages; j++, buf += scanlen) {
William Juul52c07962007-10-31 13:53:06 +0100412 if (check_pattern(buf, scanlen, mtd->writesize, bd))
413 return 1;
414 }
415 return 0;
416}
417
Sergey Lapin3a38a552013-01-14 03:46:50 +0000418/* Scan a given block partially */
William Juul52c07962007-10-31 13:53:06 +0100419static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
Sergey Lapin3a38a552013-01-14 03:46:50 +0000420 loff_t offs, uint8_t *buf, int numpages)
William Juul52c07962007-10-31 13:53:06 +0100421{
422 struct mtd_oob_ops ops;
423 int j, ret;
424
425 ops.ooblen = mtd->oobsize;
426 ops.oobbuf = buf;
427 ops.ooboffs = 0;
428 ops.datbuf = NULL;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000429 ops.mode = MTD_OPS_PLACE_OOB;
William Juul52c07962007-10-31 13:53:06 +0100430
Sergey Lapin3a38a552013-01-14 03:46:50 +0000431 for (j = 0; j < numpages; j++) {
William Juul52c07962007-10-31 13:53:06 +0100432 /*
Sergey Lapin3a38a552013-01-14 03:46:50 +0000433 * Read the full oob until read_oob is fixed to handle single
434 * byte reads for 16 bit buswidth.
William Juul52c07962007-10-31 13:53:06 +0100435 */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000436 ret = mtd_read_oob(mtd, offs, &ops);
437 /* Ignore ECC errors when checking for BBM */
438 if (ret && !mtd_is_bitflip_or_eccerr(ret))
William Juul52c07962007-10-31 13:53:06 +0100439 return ret;
440
441 if (check_short_pattern(buf, bd))
442 return 1;
443
444 offs += mtd->writesize;
445 }
446 return 0;
447}
448
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200449/**
450 * create_bbt - [GENERIC] Create a bad block table by scanning the device
Sergey Lapin3a38a552013-01-14 03:46:50 +0000451 * @mtd: MTD device structure
452 * @buf: temporary buffer
453 * @bd: descriptor for the good/bad block search pattern
454 * @chip: create the table for a specific chip, -1 read all chips; applies only
455 * if NAND_BBT_PERCHIP option is set
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200456 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000457 * Create a bad block table by scanning the device for the given good/bad block
458 * identify pattern.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200459 */
William Juul52c07962007-10-31 13:53:06 +0100460static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
461 struct nand_bbt_descr *bd, int chip)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200462{
463 struct nand_chip *this = mtd->priv;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000464 int i, numblocks, numpages, scanlen;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200465 int startblock;
466 loff_t from;
William Juul52c07962007-10-31 13:53:06 +0100467 size_t readlen;
468
Sergey Lapin3a38a552013-01-14 03:46:50 +0000469 pr_info("Scanning device for bad blocks\n");
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200470
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200471 if (bd->options & NAND_BBT_SCANALLPAGES)
Sergey Lapin3a38a552013-01-14 03:46:50 +0000472 numpages = 1 << (this->bbt_erase_shift - this->page_shift);
Christian Hitz24e6ea42011-10-12 09:32:04 +0200473 else if (bd->options & NAND_BBT_SCAN2NDPAGE)
Sergey Lapin3a38a552013-01-14 03:46:50 +0000474 numpages = 2;
Christian Hitz24e6ea42011-10-12 09:32:04 +0200475 else
Sergey Lapin3a38a552013-01-14 03:46:50 +0000476 numpages = 1;
William Juul52c07962007-10-31 13:53:06 +0100477
478 if (!(bd->options & NAND_BBT_SCANEMPTY)) {
479 /* We need only read few bytes from the OOB area */
480 scanlen = 0;
481 readlen = bd->len;
482 } else {
483 /* Full page content should be read */
484 scanlen = mtd->writesize + mtd->oobsize;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000485 readlen = numpages * mtd->writesize;
William Juul52c07962007-10-31 13:53:06 +0100486 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200487
488 if (chip == -1) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000489 /*
490 * Note that numblocks is 2 * (real numblocks) here, see i+=2
491 * below as it makes shifting and masking less painful
492 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200493 numblocks = mtd->size >> (this->bbt_erase_shift - 1);
494 startblock = 0;
495 from = 0;
496 } else {
497 if (chip >= this->numchips) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000498 pr_warn("create_bbt(): chipnr (%d) > available chips (%d)\n",
William Juul52c07962007-10-31 13:53:06 +0100499 chip + 1, this->numchips);
500 return -EINVAL;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200501 }
502 numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
503 startblock = chip * numblocks;
504 numblocks += startblock;
Sandeep Paulrajeab580c2009-10-30 13:51:23 -0400505 from = (loff_t)startblock << (this->bbt_erase_shift - 1);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200506 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200507
Sergey Lapin3a38a552013-01-14 03:46:50 +0000508 if (this->bbt_options & NAND_BBT_SCANLASTPAGE)
509 from += mtd->erasesize - (mtd->writesize * numpages);
Christian Hitz24e6ea42011-10-12 09:32:04 +0200510
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200511 for (i = startblock; i < numblocks;) {
William Juul52c07962007-10-31 13:53:06 +0100512 int ret;
513
Christian Hitz24e6ea42011-10-12 09:32:04 +0200514 BUG_ON(bd->options & NAND_BBT_NO_OOB);
515
William Juul52c07962007-10-31 13:53:06 +0100516 if (bd->options & NAND_BBT_SCANALLPAGES)
517 ret = scan_block_full(mtd, bd, from, buf, readlen,
Sergey Lapin3a38a552013-01-14 03:46:50 +0000518 scanlen, numpages);
William Juul52c07962007-10-31 13:53:06 +0100519 else
Sergey Lapin3a38a552013-01-14 03:46:50 +0000520 ret = scan_block_fast(mtd, bd, from, buf, numpages);
William Juul52c07962007-10-31 13:53:06 +0100521
522 if (ret < 0)
523 return ret;
524
525 if (ret) {
526 this->bbt[i >> 3] |= 0x03 << (i & 0x6);
Sergey Lapin3a38a552013-01-14 03:46:50 +0000527 pr_warn("Bad eraseblock %d at 0x%012llx\n",
Sandeep Paulrajeab580c2009-10-30 13:51:23 -0400528 i >> 1, (unsigned long long)from);
William Juul52c07962007-10-31 13:53:06 +0100529 mtd->ecc_stats.badblocks++;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200530 }
William Juul52c07962007-10-31 13:53:06 +0100531
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200532 i += 2;
533 from += (1 << this->bbt_erase_shift);
534 }
William Juul52c07962007-10-31 13:53:06 +0100535 return 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200536}
537
538/**
539 * search_bbt - [GENERIC] scan the device for a specific bad block table
Sergey Lapin3a38a552013-01-14 03:46:50 +0000540 * @mtd: MTD device structure
541 * @buf: temporary buffer
542 * @td: descriptor for the bad block table
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200543 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000544 * Read the bad block table by searching for a given ident pattern. Search is
545 * preformed either from the beginning up or from the end of the device
546 * downwards. The search starts always at the start of a block. If the option
547 * NAND_BBT_PERCHIP is given, each chip is searched for a bbt, which contains
548 * the bad block information of this chip. This is necessary to provide support
549 * for certain DOC devices.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200550 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000551 * The bbt ident pattern resides in the oob area of the first page in a block.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200552 */
William Juul52c07962007-10-31 13:53:06 +0100553static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200554{
555 struct nand_chip *this = mtd->priv;
556 int i, chips;
Marek Vasut15324ad2011-09-30 12:13:22 +0200557 int startblock, block, dir;
William Juul52c07962007-10-31 13:53:06 +0100558 int scanlen = mtd->writesize + mtd->oobsize;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200559 int bbtblocks;
William Juul52c07962007-10-31 13:53:06 +0100560 int blocktopage = this->bbt_erase_shift - this->page_shift;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200561
Sergey Lapin3a38a552013-01-14 03:46:50 +0000562 /* Search direction top -> down? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200563 if (td->options & NAND_BBT_LASTBLOCK) {
William Juul52c07962007-10-31 13:53:06 +0100564 startblock = (mtd->size >> this->bbt_erase_shift) - 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200565 dir = -1;
566 } else {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200567 startblock = 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200568 dir = 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200569 }
570
Sergey Lapin3a38a552013-01-14 03:46:50 +0000571 /* Do we have a bbt per chip? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200572 if (td->options & NAND_BBT_PERCHIP) {
573 chips = this->numchips;
574 bbtblocks = this->chipsize >> this->bbt_erase_shift;
575 startblock &= bbtblocks - 1;
576 } else {
577 chips = 1;
578 bbtblocks = mtd->size >> this->bbt_erase_shift;
579 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200580
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200581 for (i = 0; i < chips; i++) {
582 /* Reset version information */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200583 td->version[i] = 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200584 td->pages[i] = -1;
585 /* Scan the maximum number of blocks */
586 for (block = 0; block < td->maxblocks; block++) {
William Juul52c07962007-10-31 13:53:06 +0100587
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200588 int actblock = startblock + dir * block;
Sandeep Paulrajeab580c2009-10-30 13:51:23 -0400589 loff_t offs = (loff_t)actblock << this->bbt_erase_shift;
William Juul52c07962007-10-31 13:53:06 +0100590
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200591 /* Read first page */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000592 scan_read(mtd, buf, offs, mtd->writesize, td);
William Juul52c07962007-10-31 13:53:06 +0100593 if (!check_pattern(buf, scanlen, mtd->writesize, td)) {
594 td->pages[i] = actblock << blocktopage;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200595 if (td->options & NAND_BBT_VERSION) {
Christian Hitz24e6ea42011-10-12 09:32:04 +0200596 offs = bbt_get_ver_offs(mtd, td);
597 td->version[i] = buf[offs];
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200598 }
599 break;
600 }
601 }
602 startblock += this->chipsize >> this->bbt_erase_shift;
603 }
604 /* Check, if we found a bbt for each requested chip */
605 for (i = 0; i < chips; i++) {
606 if (td->pages[i] == -1)
Sergey Lapin3a38a552013-01-14 03:46:50 +0000607 pr_warn("Bad block table not found for chip %d\n", i);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200608 else
Sergey Lapin3a38a552013-01-14 03:46:50 +0000609 pr_info("Bad block table found at page %d, version 0x%02X\n", td->pages[i],
Heiko Schocher435d3512012-02-14 22:34:05 +0000610 td->version[i]);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200611 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200612 return 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200613}
614
615/**
616 * search_read_bbts - [GENERIC] scan the device for bad block table(s)
Sergey Lapin3a38a552013-01-14 03:46:50 +0000617 * @mtd: MTD device structure
618 * @buf: temporary buffer
619 * @td: descriptor for the bad block table
620 * @md: descriptor for the bad block table mirror
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200621 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000622 * Search and read the bad block table(s).
623 */
624static void search_read_bbts(struct mtd_info *mtd, uint8_t *buf,
625 struct nand_bbt_descr *td,
626 struct nand_bbt_descr *md)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200627{
628 /* Search the primary table */
William Juul52c07962007-10-31 13:53:06 +0100629 search_bbt(mtd, buf, td);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200630
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200631 /* Search the mirror table */
632 if (md)
William Juul52c07962007-10-31 13:53:06 +0100633 search_bbt(mtd, buf, md);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200634}
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200635
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200636/**
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200637 * write_bbt - [GENERIC] (Re)write the bad block table
Sergey Lapin3a38a552013-01-14 03:46:50 +0000638 * @mtd: MTD device structure
639 * @buf: temporary buffer
640 * @td: descriptor for the bad block table
641 * @md: descriptor for the bad block table mirror
642 * @chipsel: selector for a specific chip, -1 for all
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200643 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000644 * (Re)write the bad block table.
645 */
William Juul52c07962007-10-31 13:53:06 +0100646static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
647 struct nand_bbt_descr *td, struct nand_bbt_descr *md,
648 int chipsel)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200649{
650 struct nand_chip *this = mtd->priv;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200651 struct erase_info einfo;
652 int i, j, res, chip = 0;
653 int bits, startblock, dir, page, offs, numblocks, sft, sftmsk;
William Juul52c07962007-10-31 13:53:06 +0100654 int nrchips, bbtoffs, pageoffs, ooboffs;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200655 uint8_t msk[4];
656 uint8_t rcode = td->reserved_block_code;
657 size_t retlen, len = 0;
658 loff_t to;
William Juul52c07962007-10-31 13:53:06 +0100659 struct mtd_oob_ops ops;
660
661 ops.ooblen = mtd->oobsize;
662 ops.ooboffs = 0;
663 ops.datbuf = NULL;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000664 ops.mode = MTD_OPS_PLACE_OOB;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200665
666 if (!rcode)
667 rcode = 0xff;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000668 /* Write bad block table per chip rather than per device? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200669 if (td->options & NAND_BBT_PERCHIP) {
William Juul52c07962007-10-31 13:53:06 +0100670 numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
Sergey Lapin3a38a552013-01-14 03:46:50 +0000671 /* Full device write or specific chip? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200672 if (chipsel == -1) {
673 nrchips = this->numchips;
674 } else {
675 nrchips = chipsel + 1;
676 chip = chipsel;
677 }
678 } else {
William Juul52c07962007-10-31 13:53:06 +0100679 numblocks = (int)(mtd->size >> this->bbt_erase_shift);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200680 nrchips = 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200681 }
682
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200683 /* Loop through the chips */
684 for (; chip < nrchips; chip++) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000685 /*
686 * There was already a version of the table, reuse the page
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200687 * This applies for absolute placement too, as we have the
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200688 * page nr. in td->pages.
689 */
690 if (td->pages[chip] != -1) {
691 page = td->pages[chip];
692 goto write;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200693 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200694
Sergey Lapin3a38a552013-01-14 03:46:50 +0000695 /*
696 * Automatic placement of the bad block table. Search direction
697 * top -> down?
698 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200699 if (td->options & NAND_BBT_LASTBLOCK) {
700 startblock = numblocks * (chip + 1) - 1;
701 dir = -1;
702 } else {
703 startblock = chip * numblocks;
704 dir = 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200705 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200706
707 for (i = 0; i < td->maxblocks; i++) {
708 int block = startblock + dir * i;
709 /* Check, if the block is bad */
William Juul52c07962007-10-31 13:53:06 +0100710 switch ((this->bbt[block >> 2] >>
711 (2 * (block & 0x03))) & 0x03) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200712 case 0x01:
713 case 0x03:
714 continue;
715 }
William Juul52c07962007-10-31 13:53:06 +0100716 page = block <<
717 (this->bbt_erase_shift - this->page_shift);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200718 /* Check, if the block is used by the mirror table */
719 if (!md || md->pages[chip] != page)
720 goto write;
721 }
Sergey Lapin3a38a552013-01-14 03:46:50 +0000722 pr_err("No space left to write bad block table\n");
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200723 return -ENOSPC;
William Juul52c07962007-10-31 13:53:06 +0100724 write:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200725
726 /* Set up shift count and masks for the flash table */
727 bits = td->options & NAND_BBT_NRBITS_MSK;
William Juul52c07962007-10-31 13:53:06 +0100728 msk[2] = ~rcode;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200729 switch (bits) {
William Juul52c07962007-10-31 13:53:06 +0100730 case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01;
731 msk[3] = 0x01;
732 break;
733 case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01;
734 msk[3] = 0x03;
735 break;
736 case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C;
737 msk[3] = 0x0f;
738 break;
739 case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F;
740 msk[3] = 0xff;
741 break;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200742 default: return -EINVAL;
743 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200744
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200745 bbtoffs = chip * (numblocks >> 2);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200746
Sergey Lapin3a38a552013-01-14 03:46:50 +0000747 to = ((loff_t)page) << this->page_shift;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200748
Sergey Lapin3a38a552013-01-14 03:46:50 +0000749 /* Must we save the block contents? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200750 if (td->options & NAND_BBT_SAVECONTENT) {
751 /* Make it block aligned */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000752 to &= ~((loff_t)((1 << this->bbt_erase_shift) - 1));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200753 len = 1 << this->bbt_erase_shift;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000754 res = mtd_read(mtd, to, len, &retlen, buf);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200755 if (res < 0) {
756 if (retlen != len) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000757 pr_info("nand_bbt: error reading block "
758 "for writing the bad block table\n");
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200759 return res;
760 }
Sergey Lapin3a38a552013-01-14 03:46:50 +0000761 pr_warn("nand_bbt: ECC error while reading "
762 "block for writing bad block table\n");
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200763 }
William Juul52c07962007-10-31 13:53:06 +0100764 /* Read oob data */
765 ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
766 ops.oobbuf = &buf[len];
Sergey Lapin3a38a552013-01-14 03:46:50 +0000767 res = mtd_read_oob(mtd, to + mtd->writesize, &ops);
William Juul52c07962007-10-31 13:53:06 +0100768 if (res < 0 || ops.oobretlen != ops.ooblen)
769 goto outerr;
770
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200771 /* Calc the byte offset in the buffer */
772 pageoffs = page - (int)(to >> this->page_shift);
773 offs = pageoffs << this->page_shift;
774 /* Preset the bbt area with 0xff */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000775 memset(&buf[offs], 0xff, (size_t)(numblocks >> sft));
William Juul52c07962007-10-31 13:53:06 +0100776 ooboffs = len + (pageoffs * mtd->oobsize);
777
Christian Hitz24e6ea42011-10-12 09:32:04 +0200778 } else if (td->options & NAND_BBT_NO_OOB) {
779 ooboffs = 0;
780 offs = td->len;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000781 /* The version byte */
Christian Hitz24e6ea42011-10-12 09:32:04 +0200782 if (td->options & NAND_BBT_VERSION)
783 offs++;
784 /* Calc length */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000785 len = (size_t)(numblocks >> sft);
Christian Hitz24e6ea42011-10-12 09:32:04 +0200786 len += offs;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000787 /* Make it page aligned! */
Christian Hitz24e6ea42011-10-12 09:32:04 +0200788 len = ALIGN(len, mtd->writesize);
789 /* Preset the buffer with 0xff */
790 memset(buf, 0xff, len);
791 /* Pattern is located at the begin of first page */
792 memcpy(buf, td->pattern, td->len);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200793 } else {
794 /* Calc length */
Sergey Lapin3a38a552013-01-14 03:46:50 +0000795 len = (size_t)(numblocks >> sft);
796 /* Make it page aligned! */
Christian Hitz24e6ea42011-10-12 09:32:04 +0200797 len = ALIGN(len, mtd->writesize);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200798 /* Preset the buffer with 0xff */
William Juul52c07962007-10-31 13:53:06 +0100799 memset(buf, 0xff, len +
800 (len >> this->page_shift)* mtd->oobsize);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200801 offs = 0;
William Juul52c07962007-10-31 13:53:06 +0100802 ooboffs = len;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200803 /* Pattern is located in oob area of first page */
William Juul52c07962007-10-31 13:53:06 +0100804 memcpy(&buf[ooboffs + td->offs], td->pattern, td->len);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200805 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200806
William Juul52c07962007-10-31 13:53:06 +0100807 if (td->options & NAND_BBT_VERSION)
808 buf[ooboffs + td->veroffs] = td->version[chip];
809
Sergey Lapin3a38a552013-01-14 03:46:50 +0000810 /* Walk through the memory table */
William Juul52c07962007-10-31 13:53:06 +0100811 for (i = 0; i < numblocks;) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200812 uint8_t dat;
813 dat = this->bbt[bbtoffs + (i >> 2)];
William Juul52c07962007-10-31 13:53:06 +0100814 for (j = 0; j < 4; j++, i++) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200815 int sftcnt = (i << (3 - sft)) & sftmsk;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000816 /* Do not store the reserved bbt blocks! */
William Juul52c07962007-10-31 13:53:06 +0100817 buf[offs + (i >> sft)] &=
818 ~(msk[dat & 0x03] << sftcnt);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200819 dat >>= 2;
820 }
821 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200822
William Juul52c07962007-10-31 13:53:06 +0100823 memset(&einfo, 0, sizeof(einfo));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200824 einfo.mtd = mtd;
Sandeep Paulrajeab580c2009-10-30 13:51:23 -0400825 einfo.addr = to;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200826 einfo.len = 1 << this->bbt_erase_shift;
William Juul52c07962007-10-31 13:53:06 +0100827 res = nand_erase_nand(mtd, &einfo, 1);
828 if (res < 0)
829 goto outerr;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200830
Christian Hitz24e6ea42011-10-12 09:32:04 +0200831 res = scan_write_bbt(mtd, to, len, buf,
832 td->options & NAND_BBT_NO_OOB ? NULL :
833 &buf[len]);
William Juul52c07962007-10-31 13:53:06 +0100834 if (res < 0)
835 goto outerr;
836
Sergey Lapin3a38a552013-01-14 03:46:50 +0000837 pr_info("Bad block table written to 0x%012llx, version 0x%02X\n",
838 (unsigned long long)to, td->version[chip]);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200839
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200840 /* Mark it as used */
841 td->pages[chip] = page;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200842 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200843 return 0;
William Juul52c07962007-10-31 13:53:06 +0100844
845 outerr:
Sergey Lapin3a38a552013-01-14 03:46:50 +0000846 pr_warn("nand_bbt: error while writing bad block table %d\n", res);
William Juul52c07962007-10-31 13:53:06 +0100847 return res;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200848}
849
850/**
851 * nand_memory_bbt - [GENERIC] create a memory based bad block table
Sergey Lapin3a38a552013-01-14 03:46:50 +0000852 * @mtd: MTD device structure
853 * @bd: descriptor for the good/bad block search pattern
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200854 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000855 * The function creates a memory based bbt by scanning the device for
856 * manufacturer / software marked good / bad blocks.
857 */
William Juul52c07962007-10-31 13:53:06 +0100858static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200859{
860 struct nand_chip *this = mtd->priv;
861
William Juul52c07962007-10-31 13:53:06 +0100862 bd->options &= ~NAND_BBT_SCANEMPTY;
863 return create_bbt(mtd, this->buffers->databuf, bd, -1);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200864}
865
866/**
William Juul52c07962007-10-31 13:53:06 +0100867 * check_create - [GENERIC] create and write bbt(s) if necessary
Sergey Lapin3a38a552013-01-14 03:46:50 +0000868 * @mtd: MTD device structure
869 * @buf: temporary buffer
870 * @bd: descriptor for the good/bad block search pattern
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200871 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000872 * The function checks the results of the previous call to read_bbt and creates
873 * / updates the bbt(s) if necessary. Creation is necessary if no bbt was found
874 * for the chip/device. Update is necessary if one of the tables is missing or
875 * the version nr. of one table is less than the other.
876 */
William Juul52c07962007-10-31 13:53:06 +0100877static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200878{
Sergey Lapin3a38a552013-01-14 03:46:50 +0000879 int i, chips, writeops, create, chipsel, res, res2;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200880 struct nand_chip *this = mtd->priv;
881 struct nand_bbt_descr *td = this->bbt_td;
882 struct nand_bbt_descr *md = this->bbt_md;
883 struct nand_bbt_descr *rd, *rd2;
884
Sergey Lapin3a38a552013-01-14 03:46:50 +0000885 /* Do we have a bbt per chip? */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200886 if (td->options & NAND_BBT_PERCHIP)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200887 chips = this->numchips;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200888 else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200889 chips = 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200890
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200891 for (i = 0; i < chips; i++) {
892 writeops = 0;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000893 create = 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200894 rd = NULL;
895 rd2 = NULL;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000896 res = res2 = 0;
897 /* Per chip or per device? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200898 chipsel = (td->options & NAND_BBT_PERCHIP) ? i : -1;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000899 /* Mirrored table available? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200900 if (md) {
901 if (td->pages[i] == -1 && md->pages[i] == -1) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000902 create = 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200903 writeops = 0x03;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000904 } else if (td->pages[i] == -1) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200905 rd = md;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000906 writeops = 0x01;
907 } else if (md->pages[i] == -1) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200908 rd = td;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000909 writeops = 0x02;
910 } else if (td->version[i] == md->version[i]) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200911 rd = td;
912 if (!(td->options & NAND_BBT_VERSION))
913 rd2 = md;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000914 } else if (((int8_t)(td->version[i] - md->version[i])) > 0) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200915 rd = td;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000916 writeops = 0x02;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200917 } else {
918 rd = md;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000919 writeops = 0x01;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200920 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200921 } else {
922 if (td->pages[i] == -1) {
Sergey Lapin3a38a552013-01-14 03:46:50 +0000923 create = 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200924 writeops = 0x01;
Sergey Lapin3a38a552013-01-14 03:46:50 +0000925 } else {
926 rd = td;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200927 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200928 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200929
Sergey Lapin3a38a552013-01-14 03:46:50 +0000930 if (create) {
931 /* Create the bad block table by scanning the device? */
932 if (!(td->options & NAND_BBT_CREATE))
933 continue;
934
935 /* Create the table in memory by scanning the chip(s) */
936 if (!(this->bbt_options & NAND_BBT_CREATE_EMPTY))
937 create_bbt(mtd, buf, bd, chipsel);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200938
Sergey Lapin3a38a552013-01-14 03:46:50 +0000939 td->version[i] = 1;
940 if (md)
941 md->version[i] = 1;
942 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200943
Sergey Lapin3a38a552013-01-14 03:46:50 +0000944 /* Read back first? */
945 if (rd) {
946 res = read_abs_bbt(mtd, buf, rd, chipsel);
947 if (mtd_is_eccerr(res)) {
948 /* Mark table as invalid */
949 rd->pages[i] = -1;
950 rd->version[i] = 0;
951 i--;
952 continue;
953 }
954 }
955 /* If they weren't versioned, read both */
956 if (rd2) {
957 res2 = read_abs_bbt(mtd, buf, rd2, chipsel);
958 if (mtd_is_eccerr(res2)) {
959 /* Mark table as invalid */
960 rd2->pages[i] = -1;
961 rd2->version[i] = 0;
962 i--;
963 continue;
964 }
965 }
966
967 /* Scrub the flash table(s)? */
968 if (mtd_is_bitflip(res) || mtd_is_bitflip(res2))
969 writeops = 0x03;
970
971 /* Update version numbers before writing */
972 if (md) {
973 td->version[i] = max(td->version[i], md->version[i]);
974 md->version[i] = td->version[i];
975 }
976
977 /* Write the bad block table to the device? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200978 if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
William Juul52c07962007-10-31 13:53:06 +0100979 res = write_bbt(mtd, buf, td, md, chipsel);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200980 if (res < 0)
981 return res;
982 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200983
Sergey Lapin3a38a552013-01-14 03:46:50 +0000984 /* Write the mirror bad block table to the device? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200985 if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
William Juul52c07962007-10-31 13:53:06 +0100986 res = write_bbt(mtd, buf, md, td, chipsel);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200987 if (res < 0)
988 return res;
989 }
990 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200991 return 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200992}
993
994/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200995 * mark_bbt_regions - [GENERIC] mark the bad block table regions
Sergey Lapin3a38a552013-01-14 03:46:50 +0000996 * @mtd: MTD device structure
997 * @td: bad block table descriptor
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200998 *
Sergey Lapin3a38a552013-01-14 03:46:50 +0000999 * The bad block table regions are marked as "bad" to prevent accidental
1000 * erasures / writes. The regions are identified by the mark 0x02.
1001 */
William Juul52c07962007-10-31 13:53:06 +01001002static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001003{
1004 struct nand_chip *this = mtd->priv;
1005 int i, j, chips, block, nrblocks, update;
1006 uint8_t oldval, newval;
1007
Sergey Lapin3a38a552013-01-14 03:46:50 +00001008 /* Do we have a bbt per chip? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001009 if (td->options & NAND_BBT_PERCHIP) {
1010 chips = this->numchips;
1011 nrblocks = (int)(this->chipsize >> this->bbt_erase_shift);
1012 } else {
1013 chips = 1;
1014 nrblocks = (int)(mtd->size >> this->bbt_erase_shift);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001015 }
1016
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001017 for (i = 0; i < chips; i++) {
1018 if ((td->options & NAND_BBT_ABSPAGE) ||
1019 !(td->options & NAND_BBT_WRITE)) {
William Juul52c07962007-10-31 13:53:06 +01001020 if (td->pages[i] == -1)
1021 continue;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001022 block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001023 block <<= 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001024 oldval = this->bbt[(block >> 3)];
1025 newval = oldval | (0x2 << (block & 0x06));
1026 this->bbt[(block >> 3)] = newval;
1027 if ((oldval != newval) && td->reserved_block_code)
Christian Hitz24e6ea42011-10-12 09:32:04 +02001028 nand_update_bbt(mtd, (loff_t)block << (this->bbt_erase_shift - 1));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001029 continue;
1030 }
1031 update = 0;
1032 if (td->options & NAND_BBT_LASTBLOCK)
1033 block = ((i + 1) * nrblocks) - td->maxblocks;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001034 else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001035 block = i * nrblocks;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001036 block <<= 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001037 for (j = 0; j < td->maxblocks; j++) {
1038 oldval = this->bbt[(block >> 3)];
1039 newval = oldval | (0x2 << (block & 0x06));
1040 this->bbt[(block >> 3)] = newval;
William Juul52c07962007-10-31 13:53:06 +01001041 if (oldval != newval)
1042 update = 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001043 block += 2;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001044 }
Sergey Lapin3a38a552013-01-14 03:46:50 +00001045 /*
1046 * If we want reserved blocks to be recorded to flash, and some
1047 * new ones have been marked, then we need to update the stored
1048 * bbts. This should only happen once.
1049 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001050 if (update && td->reserved_block_code)
Christian Hitz24e6ea42011-10-12 09:32:04 +02001051 nand_update_bbt(mtd, (loff_t)(block - 2) << (this->bbt_erase_shift - 1));
1052 }
1053}
1054
1055/**
1056 * verify_bbt_descr - verify the bad block description
Sergey Lapin3a38a552013-01-14 03:46:50 +00001057 * @mtd: MTD device structure
1058 * @bd: the table to verify
Christian Hitz24e6ea42011-10-12 09:32:04 +02001059 *
1060 * This functions performs a few sanity checks on the bad block description
1061 * table.
1062 */
1063static void verify_bbt_descr(struct mtd_info *mtd, struct nand_bbt_descr *bd)
1064{
1065 struct nand_chip *this = mtd->priv;
1066 u32 pattern_len;
1067 u32 bits;
1068 u32 table_size;
1069
1070 if (!bd)
1071 return;
1072
1073 pattern_len = bd->len;
1074 bits = bd->options & NAND_BBT_NRBITS_MSK;
1075
Sergey Lapin3a38a552013-01-14 03:46:50 +00001076 BUG_ON((this->bbt_options & NAND_BBT_NO_OOB) &&
1077 !(this->bbt_options & NAND_BBT_USE_FLASH));
Christian Hitz24e6ea42011-10-12 09:32:04 +02001078 BUG_ON(!bits);
1079
1080 if (bd->options & NAND_BBT_VERSION)
1081 pattern_len++;
1082
1083 if (bd->options & NAND_BBT_NO_OOB) {
Sergey Lapin3a38a552013-01-14 03:46:50 +00001084 BUG_ON(!(this->bbt_options & NAND_BBT_USE_FLASH));
1085 BUG_ON(!(this->bbt_options & NAND_BBT_NO_OOB));
Christian Hitz24e6ea42011-10-12 09:32:04 +02001086 BUG_ON(bd->offs);
1087 if (bd->options & NAND_BBT_VERSION)
1088 BUG_ON(bd->veroffs != bd->len);
1089 BUG_ON(bd->options & NAND_BBT_SAVECONTENT);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001090 }
Christian Hitz24e6ea42011-10-12 09:32:04 +02001091
1092 if (bd->options & NAND_BBT_PERCHIP)
1093 table_size = this->chipsize >> this->bbt_erase_shift;
1094 else
1095 table_size = mtd->size >> this->bbt_erase_shift;
1096 table_size >>= 3;
1097 table_size *= bits;
1098 if (bd->options & NAND_BBT_NO_OOB)
1099 table_size += pattern_len;
1100 BUG_ON(table_size > (1 << this->bbt_erase_shift));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001101}
1102
1103/**
1104 * nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)
Sergey Lapin3a38a552013-01-14 03:46:50 +00001105 * @mtd: MTD device structure
1106 * @bd: descriptor for the good/bad block search pattern
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001107 *
Sergey Lapin3a38a552013-01-14 03:46:50 +00001108 * The function checks, if a bad block table(s) is/are already available. If
1109 * not it scans the device for manufacturer marked good / bad blocks and writes
1110 * the bad block table(s) to the selected place.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001111 *
Sergey Lapin3a38a552013-01-14 03:46:50 +00001112 * The bad block table memory is allocated here. It must be freed by calling
1113 * the nand_free_bbt function.
1114 */
William Juul52c07962007-10-31 13:53:06 +01001115int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001116{
1117 struct nand_chip *this = mtd->priv;
1118 int len, res = 0;
1119 uint8_t *buf;
1120 struct nand_bbt_descr *td = this->bbt_td;
1121 struct nand_bbt_descr *md = this->bbt_md;
1122
1123 len = mtd->size >> (this->bbt_erase_shift + 2);
Sergey Lapin3a38a552013-01-14 03:46:50 +00001124 /*
1125 * Allocate memory (2bit per block) and clear the memory bad block
1126 * table.
1127 */
William Juul52c07962007-10-31 13:53:06 +01001128 this->bbt = kzalloc(len, GFP_KERNEL);
Sergey Lapin3a38a552013-01-14 03:46:50 +00001129 if (!this->bbt)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001130 return -ENOMEM;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001131
Sergey Lapin3a38a552013-01-14 03:46:50 +00001132 /*
1133 * If no primary table decriptor is given, scan the device to build a
1134 * memory based bad block table.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001135 */
William Juul52c07962007-10-31 13:53:06 +01001136 if (!td) {
1137 if ((res = nand_memory_bbt(mtd, bd))) {
Sergey Lapin3a38a552013-01-14 03:46:50 +00001138 pr_err("nand_bbt: can't scan flash and build the RAM-based BBT\n");
William Juul52c07962007-10-31 13:53:06 +01001139 kfree(this->bbt);
1140 this->bbt = NULL;
1141 }
1142 return res;
1143 }
Christian Hitz24e6ea42011-10-12 09:32:04 +02001144 verify_bbt_descr(mtd, td);
1145 verify_bbt_descr(mtd, md);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001146
1147 /* Allocate a temporary buffer for one eraseblock incl. oob */
1148 len = (1 << this->bbt_erase_shift);
1149 len += (len >> this->page_shift) * mtd->oobsize;
William Juul52c07962007-10-31 13:53:06 +01001150 buf = vmalloc(len);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001151 if (!buf) {
William Juul52c07962007-10-31 13:53:06 +01001152 kfree(this->bbt);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001153 this->bbt = NULL;
1154 return -ENOMEM;
1155 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001156
Sergey Lapin3a38a552013-01-14 03:46:50 +00001157 /* Is the bbt at a given page? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001158 if (td->options & NAND_BBT_ABSPAGE) {
Sergey Lapin3a38a552013-01-14 03:46:50 +00001159 read_abs_bbts(mtd, buf, td, md);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001160 } else {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001161 /* Search the bad block table using a pattern in oob */
Sergey Lapin3a38a552013-01-14 03:46:50 +00001162 search_read_bbts(mtd, buf, td, md);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001163 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001164
Sergey Lapin3a38a552013-01-14 03:46:50 +00001165 res = check_create(mtd, buf, bd);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001166
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001167 /* Prevent the bbt regions from erasing / writing */
William Juul52c07962007-10-31 13:53:06 +01001168 mark_bbt_region(mtd, td);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001169 if (md)
William Juul52c07962007-10-31 13:53:06 +01001170 mark_bbt_region(mtd, md);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001171
William Juul52c07962007-10-31 13:53:06 +01001172 vfree(buf);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001173 return res;
1174}
1175
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001176/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001177 * nand_update_bbt - [NAND Interface] update bad block table(s)
Sergey Lapin3a38a552013-01-14 03:46:50 +00001178 * @mtd: MTD device structure
1179 * @offs: the offset of the newly marked block
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001180 *
Sergey Lapin3a38a552013-01-14 03:46:50 +00001181 * The function updates the bad block table(s).
1182 */
William Juul52c07962007-10-31 13:53:06 +01001183int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001184{
1185 struct nand_chip *this = mtd->priv;
Sergey Lapin3a38a552013-01-14 03:46:50 +00001186 int len, res = 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001187 int chip, chipsel;
1188 uint8_t *buf;
1189 struct nand_bbt_descr *td = this->bbt_td;
1190 struct nand_bbt_descr *md = this->bbt_md;
1191
1192 if (!this->bbt || !td)
1193 return -EINVAL;
1194
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001195 /* Allocate a temporary buffer for one eraseblock incl. oob */
1196 len = (1 << this->bbt_erase_shift);
1197 len += (len >> this->page_shift) * mtd->oobsize;
William Juul52c07962007-10-31 13:53:06 +01001198 buf = kmalloc(len, GFP_KERNEL);
Sergey Lapin3a38a552013-01-14 03:46:50 +00001199 if (!buf)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001200 return -ENOMEM;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001201
Sergey Lapin3a38a552013-01-14 03:46:50 +00001202 /* Do we have a bbt per chip? */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001203 if (td->options & NAND_BBT_PERCHIP) {
William Juul52c07962007-10-31 13:53:06 +01001204 chip = (int)(offs >> this->chip_shift);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001205 chipsel = chip;
1206 } else {
1207 chip = 0;
1208 chipsel = -1;
1209 }
1210
1211 td->version[chip]++;
1212 if (md)
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001213 md->version[chip]++;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001214
Sergey Lapin3a38a552013-01-14 03:46:50 +00001215 /* Write the bad block table to the device? */
1216 if (td->options & NAND_BBT_WRITE) {
William Juul52c07962007-10-31 13:53:06 +01001217 res = write_bbt(mtd, buf, td, md, chipsel);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001218 if (res < 0)
1219 goto out;
1220 }
Sergey Lapin3a38a552013-01-14 03:46:50 +00001221 /* Write the mirror bad block table to the device? */
1222 if (md && (md->options & NAND_BBT_WRITE)) {
William Juul52c07962007-10-31 13:53:06 +01001223 res = write_bbt(mtd, buf, md, td, chipsel);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001224 }
1225
William Juul52c07962007-10-31 13:53:06 +01001226 out:
1227 kfree(buf);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001228 return res;
1229}
1230
Sergey Lapin3a38a552013-01-14 03:46:50 +00001231/*
1232 * Define some generic bad / good block scan pattern which are used
1233 * while scanning a device for factory marked good / bad blocks.
1234 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001235static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
1236
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001237static uint8_t scan_agand_pattern[] = { 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7 };
1238
1239static struct nand_bbt_descr agand_flashbased = {
1240 .options = NAND_BBT_SCANEMPTY | NAND_BBT_SCANALLPAGES,
1241 .offs = 0x20,
1242 .len = 6,
1243 .pattern = scan_agand_pattern
1244};
1245
Sergey Lapin3a38a552013-01-14 03:46:50 +00001246/* Generic flash bbt descriptors */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001247static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
1248static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
1249
1250static struct nand_bbt_descr bbt_main_descr = {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001251 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001252 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1253 .offs = 8,
1254 .len = 4,
1255 .veroffs = 12,
Sergey Lapin3a38a552013-01-14 03:46:50 +00001256 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001257 .pattern = bbt_pattern
1258};
1259
1260static struct nand_bbt_descr bbt_mirror_descr = {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001261 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001262 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1263 .offs = 8,
1264 .len = 4,
1265 .veroffs = 12,
Sergey Lapin3a38a552013-01-14 03:46:50 +00001266 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001267 .pattern = mirror_pattern
1268};
1269
Sergey Lapin3a38a552013-01-14 03:46:50 +00001270static struct nand_bbt_descr bbt_main_no_oob_descr = {
Christian Hitz24e6ea42011-10-12 09:32:04 +02001271 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1272 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1273 | NAND_BBT_NO_OOB,
1274 .len = 4,
1275 .veroffs = 4,
Sergey Lapin3a38a552013-01-14 03:46:50 +00001276 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
Christian Hitz24e6ea42011-10-12 09:32:04 +02001277 .pattern = bbt_pattern
1278};
1279
Sergey Lapin3a38a552013-01-14 03:46:50 +00001280static struct nand_bbt_descr bbt_mirror_no_oob_descr = {
Christian Hitz24e6ea42011-10-12 09:32:04 +02001281 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1282 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1283 | NAND_BBT_NO_OOB,
1284 .len = 4,
1285 .veroffs = 4,
Sergey Lapin3a38a552013-01-14 03:46:50 +00001286 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
Christian Hitz24e6ea42011-10-12 09:32:04 +02001287 .pattern = mirror_pattern
1288};
1289
Sergey Lapin3a38a552013-01-14 03:46:50 +00001290#define BADBLOCK_SCAN_MASK (~NAND_BBT_NO_OOB)
Christian Hitz24e6ea42011-10-12 09:32:04 +02001291/**
Sergey Lapin3a38a552013-01-14 03:46:50 +00001292 * nand_create_badblock_pattern - [INTERN] Creates a BBT descriptor structure
1293 * @this: NAND chip to create descriptor for
Christian Hitz24e6ea42011-10-12 09:32:04 +02001294 *
1295 * This function allocates and initializes a nand_bbt_descr for BBM detection
Sergey Lapin3a38a552013-01-14 03:46:50 +00001296 * based on the properties of @this. The new descriptor is stored in
Christian Hitz24e6ea42011-10-12 09:32:04 +02001297 * this->badblock_pattern. Thus, this->badblock_pattern should be NULL when
1298 * passed to this function.
Christian Hitz24e6ea42011-10-12 09:32:04 +02001299 */
Sergey Lapin3a38a552013-01-14 03:46:50 +00001300static int nand_create_badblock_pattern(struct nand_chip *this)
Christian Hitz24e6ea42011-10-12 09:32:04 +02001301{
1302 struct nand_bbt_descr *bd;
1303 if (this->badblock_pattern) {
Sergey Lapin3a38a552013-01-14 03:46:50 +00001304 pr_warn("Bad block pattern already allocated; not replacing\n");
Christian Hitz24e6ea42011-10-12 09:32:04 +02001305 return -EINVAL;
1306 }
1307 bd = kzalloc(sizeof(*bd), GFP_KERNEL);
Sergey Lapin3a38a552013-01-14 03:46:50 +00001308 if (!bd)
Christian Hitz24e6ea42011-10-12 09:32:04 +02001309 return -ENOMEM;
Sergey Lapin3a38a552013-01-14 03:46:50 +00001310 bd->options = this->bbt_options & BADBLOCK_SCAN_MASK;
Christian Hitz24e6ea42011-10-12 09:32:04 +02001311 bd->offs = this->badblockpos;
1312 bd->len = (this->options & NAND_BUSWIDTH_16) ? 2 : 1;
1313 bd->pattern = scan_ff_pattern;
1314 bd->options |= NAND_BBT_DYNAMICSTRUCT;
1315 this->badblock_pattern = bd;
1316 return 0;
1317}
1318
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001319/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001320 * nand_default_bbt - [NAND Interface] Select a default bad block table for the device
Sergey Lapin3a38a552013-01-14 03:46:50 +00001321 * @mtd: MTD device structure
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001322 *
Sergey Lapin3a38a552013-01-14 03:46:50 +00001323 * This function selects the default bad block table support for the device and
1324 * calls the nand_scan_bbt function.
1325 */
William Juul52c07962007-10-31 13:53:06 +01001326int nand_default_bbt(struct mtd_info *mtd)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001327{
1328 struct nand_chip *this = mtd->priv;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001329
Sergey Lapin3a38a552013-01-14 03:46:50 +00001330 /*
1331 * Default for AG-AND. We must use a flash based bad block table as the
1332 * devices have factory marked _good_ blocks. Erasing those blocks
1333 * leads to loss of the good / bad information, so we _must_ store this
1334 * information in a good / bad table during startup.
William Juul52c07962007-10-31 13:53:06 +01001335 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001336 if (this->options & NAND_IS_AND) {
1337 /* Use the default pattern descriptors */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001338 if (!this->bbt_td) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001339 this->bbt_td = &bbt_main_descr;
1340 this->bbt_md = &bbt_mirror_descr;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001341 }
Sergey Lapin3a38a552013-01-14 03:46:50 +00001342 this->bbt_options |= NAND_BBT_USE_FLASH;
William Juul52c07962007-10-31 13:53:06 +01001343 return nand_scan_bbt(mtd, &agand_flashbased);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001344 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001345
Sergey Lapin3a38a552013-01-14 03:46:50 +00001346 /* Is a flash based bad block table requested? */
1347 if (this->bbt_options & NAND_BBT_USE_FLASH) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001348 /* Use the default pattern descriptors */
1349 if (!this->bbt_td) {
Sergey Lapin3a38a552013-01-14 03:46:50 +00001350 if (this->bbt_options & NAND_BBT_NO_OOB) {
1351 this->bbt_td = &bbt_main_no_oob_descr;
1352 this->bbt_md = &bbt_mirror_no_oob_descr;
Christian Hitz24e6ea42011-10-12 09:32:04 +02001353 } else {
1354 this->bbt_td = &bbt_main_descr;
1355 this->bbt_md = &bbt_mirror_descr;
1356 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001357 }
1358 } else {
1359 this->bbt_td = NULL;
1360 this->bbt_md = NULL;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001361 }
Christian Hitz24e6ea42011-10-12 09:32:04 +02001362
1363 if (!this->badblock_pattern)
Sergey Lapin3a38a552013-01-14 03:46:50 +00001364 nand_create_badblock_pattern(this);
Christian Hitz24e6ea42011-10-12 09:32:04 +02001365
William Juul52c07962007-10-31 13:53:06 +01001366 return nand_scan_bbt(mtd, this->badblock_pattern);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001367}
1368
1369/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001370 * nand_isbad_bbt - [NAND Interface] Check if a block is bad
Sergey Lapin3a38a552013-01-14 03:46:50 +00001371 * @mtd: MTD device structure
1372 * @offs: offset in the device
1373 * @allowbbt: allow access to bad block table region
1374 */
William Juul52c07962007-10-31 13:53:06 +01001375int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001376{
1377 struct nand_chip *this = mtd->priv;
1378 int block;
William Juul52c07962007-10-31 13:53:06 +01001379 uint8_t res;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001380
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001381 /* Get block number * 2 */
William Juul52c07962007-10-31 13:53:06 +01001382 block = (int)(offs >> (this->bbt_erase_shift - 1));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001383 res = (this->bbt[block >> 3] >> (block & 0x06)) & 0x03;
1384
Christian Hitz24e6ea42011-10-12 09:32:04 +02001385 MTDDEBUG(MTD_DEBUG_LEVEL2, "nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n",
1386 (unsigned int)offs, block >> 1, res);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001387
1388 switch ((int)res) {
William Juul52c07962007-10-31 13:53:06 +01001389 case 0x00:
1390 return 0;
1391 case 0x01:
1392 return 1;
1393 case 0x02:
1394 return allowbbt ? 0 : 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001395 }
1396 return 1;
1397}