Commit | Line | Data |
---|---|---|
87590e26 KP |
1 | /* |
2 | * linux/drivers/mtd/onenand/onenand_bbt.c | |
3 | * | |
4 | * Bad Block Table support for the OneNAND driver | |
5 | * | |
6 | * Copyright(c) 2005 Samsung Electronics | |
7 | * Kyungmin Park <kyungmin.park@samsung.com> | |
8 | * | |
9 | * Derived from nand_bbt.c | |
10 | * | |
11 | * TODO: | |
12 | * Split BBT core and chip specific BBT. | |
13 | */ | |
14 | ||
15 | #include <linux/slab.h> | |
16 | #include <linux/mtd/mtd.h> | |
17 | #include <linux/mtd/onenand.h> | |
18 | #include <linux/mtd/compatmac.h> | |
19 | ||
8593fbc6 | 20 | extern int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len, |
a5e7c7b4 | 21 | size_t *retlen, u_char *buf, mtd_oob_mode_t mode); |
8593fbc6 | 22 | |
87590e26 KP |
23 | /** |
24 | * check_short_pattern - [GENERIC] check if a pattern is in the buffer | |
25 | * @param buf the buffer to search | |
26 | * @param len the length of buffer to search | |
27 | * @param paglen the pagelength | |
28 | * @param td search pattern descriptor | |
29 | * | |
30 | * Check for a pattern at the given place. Used to search bad block | |
31 | * tables and good / bad block identifiers. Same as check_pattern, but | |
32 | * no optional empty check and the pattern is expected to start | |
33 | * at offset 0. | |
34 | * | |
35 | */ | |
36 | static int check_short_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td) | |
37 | { | |
38 | int i; | |
39 | uint8_t *p = buf; | |
40 | ||
41 | /* Compare the pattern */ | |
42 | for (i = 0; i < td->len; i++) { | |
43 | if (p[i] != td->pattern[i]) | |
44 | return -1; | |
45 | } | |
46 | return 0; | |
47 | } | |
48 | ||
49 | /** | |
50 | * create_bbt - [GENERIC] Create a bad block table by scanning the device | |
51 | * @param mtd MTD device structure | |
52 | * @param buf temporary buffer | |
53 | * @param bd descriptor for the good/bad block search pattern | |
54 | * @param chip create the table for a specific chip, -1 read all chips. | |
55 | * Applies only if NAND_BBT_PERCHIP option is set | |
56 | * | |
57 | * Create a bad block table by scanning the device | |
58 | * for the given good/bad block identify pattern | |
59 | */ | |
60 | static int create_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd, int chip) | |
61 | { | |
62 | struct onenand_chip *this = mtd->priv; | |
63 | struct bbm_info *bbm = this->bbm; | |
64 | int i, j, numblocks, len, scanlen; | |
65 | int startblock; | |
66 | loff_t from; | |
67 | size_t readlen, ooblen; | |
68 | ||
69 | printk(KERN_INFO "Scanning device for bad blocks\n"); | |
70 | ||
ec255e34 | 71 | len = 2; |
87590e26 KP |
72 | |
73 | /* We need only read few bytes from the OOB area */ | |
74 | scanlen = ooblen = 0; | |
75 | readlen = bd->len; | |
76 | ||
77 | /* chip == -1 case only */ | |
78 | /* Note that numblocks is 2 * (real numblocks) here; | |
79 | * see i += 2 below as it makses shifting and masking less painful | |
80 | */ | |
81 | numblocks = mtd->size >> (bbm->bbt_erase_shift - 1); | |
82 | startblock = 0; | |
83 | from = 0; | |
84 | ||
85 | for (i = startblock; i < numblocks; ) { | |
86 | int ret; | |
87 | ||
88 | for (j = 0; j < len; j++) { | |
89 | size_t retlen; | |
90 | ||
91 | /* No need to read pages fully, | |
92 | * just read required OOB bytes */ | |
8593fbc6 | 93 | ret = onenand_do_read_oob(mtd, from + j * mtd->writesize + bd->offs, |
a5e7c7b4 | 94 | readlen, &retlen, &buf[0], MTD_OOB_PLACE); |
87590e26 | 95 | |
f6272487 KP |
96 | /* If it is a initial bad block, just ignore it */ |
97 | if (ret && !(ret & ONENAND_CTRL_LOAD)) | |
87590e26 KP |
98 | return ret; |
99 | ||
28318776 | 100 | if (check_short_pattern(&buf[j * scanlen], scanlen, mtd->writesize, bd)) { |
87590e26 KP |
101 | bbm->bbt[i >> 3] |= 0x03 << (i & 0x6); |
102 | printk(KERN_WARNING "Bad eraseblock %d at 0x%08x\n", | |
103 | i >> 1, (unsigned int) from); | |
f4f91ac3 | 104 | mtd->ecc_stats.badblocks++; |
87590e26 KP |
105 | break; |
106 | } | |
107 | } | |
108 | i += 2; | |
109 | from += (1 << bbm->bbt_erase_shift); | |
110 | } | |
111 | ||
112 | return 0; | |
113 | } | |
114 | ||
115 | ||
116 | /** | |
117 | * onenand_memory_bbt - [GENERIC] create a memory based bad block table | |
118 | * @param mtd MTD device structure | |
119 | * @param bd descriptor for the good/bad block search pattern | |
120 | * | |
121 | * The function creates a memory based bbt by scanning the device | |
122 | * for manufacturer / software marked good / bad blocks | |
123 | */ | |
124 | static inline int onenand_memory_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd) | |
125 | { | |
532a37cf | 126 | struct onenand_chip *this = mtd->priv; |
87590e26 KP |
127 | |
128 | bd->options &= ~NAND_BBT_SCANEMPTY; | |
532a37cf | 129 | return create_bbt(mtd, this->page_buf, bd, -1); |
87590e26 KP |
130 | } |
131 | ||
132 | /** | |
133 | * onenand_isbad_bbt - [OneNAND Interface] Check if a block is bad | |
134 | * @param mtd MTD device structure | |
135 | * @param offs offset in the device | |
136 | * @param allowbbt allow access to bad block table region | |
137 | */ | |
138 | static int onenand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt) | |
139 | { | |
140 | struct onenand_chip *this = mtd->priv; | |
141 | struct bbm_info *bbm = this->bbm; | |
142 | int block; | |
143 | uint8_t res; | |
144 | ||
145 | /* Get block number * 2 */ | |
146 | block = (int) (offs >> (bbm->bbt_erase_shift - 1)); | |
147 | res = (bbm->bbt[block >> 3] >> (block & 0x06)) & 0x03; | |
148 | ||
149 | DEBUG(MTD_DEBUG_LEVEL2, "onenand_isbad_bbt: bbt info for offs 0x%08x: (block %d) 0x%02x\n", | |
150 | (unsigned int) offs, block >> 1, res); | |
151 | ||
152 | switch ((int) res) { | |
153 | case 0x00: return 0; | |
154 | case 0x01: return 1; | |
155 | case 0x02: return allowbbt ? 0 : 1; | |
156 | } | |
157 | ||
158 | return 1; | |
159 | } | |
160 | ||
161 | /** | |
162 | * onenand_scan_bbt - [OneNAND Interface] scan, find, read and maybe create bad block table(s) | |
163 | * @param mtd MTD device structure | |
164 | * @param bd descriptor for the good/bad block search pattern | |
165 | * | |
166 | * The function checks, if a bad block table(s) is/are already | |
167 | * available. If not it scans the device for manufacturer | |
168 | * marked good / bad blocks and writes the bad block table(s) to | |
169 | * the selected place. | |
170 | * | |
f00b0046 AH |
171 | * The bad block table memory is allocated here. It is freed |
172 | * by the onenand_release function. | |
87590e26 KP |
173 | * |
174 | */ | |
175 | int onenand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd) | |
176 | { | |
177 | struct onenand_chip *this = mtd->priv; | |
178 | struct bbm_info *bbm = this->bbm; | |
179 | int len, ret = 0; | |
180 | ||
181 | len = mtd->size >> (this->erase_shift + 2); | |
95b93a0c BY |
182 | /* Allocate memory (2bit per block) and clear the memory bad block table */ |
183 | bbm->bbt = kzalloc(len, GFP_KERNEL); | |
87590e26 KP |
184 | if (!bbm->bbt) { |
185 | printk(KERN_ERR "onenand_scan_bbt: Out of memory\n"); | |
186 | return -ENOMEM; | |
187 | } | |
87590e26 KP |
188 | |
189 | /* Set the bad block position */ | |
190 | bbm->badblockpos = ONENAND_BADBLOCK_POS; | |
191 | ||
192 | /* Set erase shift */ | |
193 | bbm->bbt_erase_shift = this->erase_shift; | |
194 | ||
195 | if (!bbm->isbad_bbt) | |
196 | bbm->isbad_bbt = onenand_isbad_bbt; | |
197 | ||
198 | /* Scan the device to build a memory based bad block table */ | |
199 | if ((ret = onenand_memory_bbt(mtd, bd))) { | |
200 | printk(KERN_ERR "onenand_scan_bbt: Can't scan flash and build the RAM-based BBT\n"); | |
201 | kfree(bbm->bbt); | |
202 | bbm->bbt = NULL; | |
203 | } | |
204 | ||
205 | return ret; | |
206 | } | |
207 | ||
208 | /* | |
209 | * Define some generic bad / good block scan pattern which are used | |
210 | * while scanning a device for factory marked good / bad blocks. | |
211 | */ | |
212 | static uint8_t scan_ff_pattern[] = { 0xff, 0xff }; | |
213 | ||
214 | static struct nand_bbt_descr largepage_memorybased = { | |
215 | .options = 0, | |
216 | .offs = 0, | |
217 | .len = 2, | |
218 | .pattern = scan_ff_pattern, | |
219 | }; | |
220 | ||
221 | /** | |
222 | * onenand_default_bbt - [OneNAND Interface] Select a default bad block table for the device | |
223 | * @param mtd MTD device structure | |
224 | * | |
225 | * This function selects the default bad block table | |
226 | * support for the device and calls the onenand_scan_bbt function | |
227 | */ | |
228 | int onenand_default_bbt(struct mtd_info *mtd) | |
229 | { | |
230 | struct onenand_chip *this = mtd->priv; | |
231 | struct bbm_info *bbm; | |
232 | ||
95b93a0c | 233 | this->bbm = kzalloc(sizeof(struct bbm_info), GFP_KERNEL); |
87590e26 KP |
234 | if (!this->bbm) |
235 | return -ENOMEM; | |
236 | ||
237 | bbm = this->bbm; | |
238 | ||
87590e26 KP |
239 | /* 1KB page has same configuration as 2KB page */ |
240 | if (!bbm->badblock_pattern) | |
241 | bbm->badblock_pattern = &largepage_memorybased; | |
242 | ||
243 | return onenand_scan_bbt(mtd, bbm->badblock_pattern); | |
244 | } | |
245 | ||
246 | EXPORT_SYMBOL(onenand_scan_bbt); | |
247 | EXPORT_SYMBOL(onenand_default_bbt); |