]>
Commit | Line | Data |
---|---|---|
e73f2174 AB |
1 | /* |
2 | * Copyright (C) 2006-2008 Nokia Corporation | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify it | |
5 | * under the terms of the GNU General Public License version 2 as published by | |
6 | * the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
11 | * more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License along with | |
14 | * this program; see the file COPYING. If not, write to the Free Software | |
15 | * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
16 | * | |
17 | * Test page read and write on MTD device. | |
18 | * | |
19 | * Author: Adrian Hunter <ext-adrian.hunter@nokia.com> | |
20 | */ | |
21 | ||
bb998419 VN |
22 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
23 | ||
e73f2174 AB |
24 | #include <asm/div64.h> |
25 | #include <linux/init.h> | |
26 | #include <linux/module.h> | |
27 | #include <linux/moduleparam.h> | |
28 | #include <linux/err.h> | |
29 | #include <linux/mtd/mtd.h> | |
5a0e3ad6 | 30 | #include <linux/slab.h> |
e73f2174 AB |
31 | #include <linux/sched.h> |
32 | ||
7406060e | 33 | static int dev = -EINVAL; |
e73f2174 AB |
34 | module_param(dev, int, S_IRUGO); |
35 | MODULE_PARM_DESC(dev, "MTD device number to use"); | |
36 | ||
37 | static struct mtd_info *mtd; | |
38 | static unsigned char *twopages; | |
39 | static unsigned char *writebuf; | |
40 | static unsigned char *boundary; | |
41 | static unsigned char *bbt; | |
42 | ||
43 | static int pgsize; | |
44 | static int bufsize; | |
45 | static int ebcnt; | |
46 | static int pgcnt; | |
47 | static int errcnt; | |
48 | static unsigned long next = 1; | |
49 | ||
50 | static inline unsigned int simple_rand(void) | |
51 | { | |
52 | next = next * 1103515245 + 12345; | |
53 | return (unsigned int)((next / 65536) % 32768); | |
54 | } | |
55 | ||
56 | static inline void simple_srand(unsigned long seed) | |
57 | { | |
58 | next = seed; | |
59 | } | |
60 | ||
61 | static void set_random_data(unsigned char *buf, size_t len) | |
62 | { | |
63 | size_t i; | |
64 | ||
65 | for (i = 0; i < len; ++i) | |
66 | buf[i] = simple_rand(); | |
67 | } | |
68 | ||
69 | static int erase_eraseblock(int ebnum) | |
70 | { | |
71 | int err; | |
72 | struct erase_info ei; | |
73 | loff_t addr = ebnum * mtd->erasesize; | |
74 | ||
75 | memset(&ei, 0, sizeof(struct erase_info)); | |
76 | ei.mtd = mtd; | |
77 | ei.addr = addr; | |
78 | ei.len = mtd->erasesize; | |
79 | ||
7e1f0dc0 | 80 | err = mtd_erase(mtd, &ei); |
e73f2174 | 81 | if (err) { |
bb998419 | 82 | pr_err("error %d while erasing EB %d\n", err, ebnum); |
e73f2174 AB |
83 | return err; |
84 | } | |
85 | ||
86 | if (ei.state == MTD_ERASE_FAILED) { | |
bb998419 | 87 | pr_err("some erase error occurred at EB %d\n", |
e73f2174 AB |
88 | ebnum); |
89 | return -EIO; | |
90 | } | |
91 | ||
92 | return 0; | |
93 | } | |
94 | ||
95 | static int write_eraseblock(int ebnum) | |
96 | { | |
97 | int err = 0; | |
30fa9848 | 98 | size_t written; |
e73f2174 AB |
99 | loff_t addr = ebnum * mtd->erasesize; |
100 | ||
101 | set_random_data(writebuf, mtd->erasesize); | |
102 | cond_resched(); | |
eda95cbf | 103 | err = mtd_write(mtd, addr, mtd->erasesize, &written, writebuf); |
e73f2174 | 104 | if (err || written != mtd->erasesize) |
bb998419 | 105 | pr_err("error: write failed at %#llx\n", |
e73f2174 AB |
106 | (long long)addr); |
107 | ||
108 | return err; | |
109 | } | |
110 | ||
111 | static int verify_eraseblock(int ebnum) | |
112 | { | |
113 | uint32_t j; | |
30fa9848 | 114 | size_t read; |
e73f2174 AB |
115 | int err = 0, i; |
116 | loff_t addr0, addrn; | |
117 | loff_t addr = ebnum * mtd->erasesize; | |
118 | ||
119 | addr0 = 0; | |
c6f7e7be | 120 | for (i = 0; i < ebcnt && bbt[i]; ++i) |
e73f2174 AB |
121 | addr0 += mtd->erasesize; |
122 | ||
123 | addrn = mtd->size; | |
c6f7e7be | 124 | for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i) |
e73f2174 AB |
125 | addrn -= mtd->erasesize; |
126 | ||
127 | set_random_data(writebuf, mtd->erasesize); | |
128 | for (j = 0; j < pgcnt - 1; ++j, addr += pgsize) { | |
129 | /* Do a read to set the internal dataRAMs to different data */ | |
329ad399 | 130 | err = mtd_read(mtd, addr0, bufsize, &read, twopages); |
d57f4054 | 131 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
132 | err = 0; |
133 | if (err || read != bufsize) { | |
bb998419 | 134 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
135 | (long long)addr0); |
136 | return err; | |
137 | } | |
329ad399 | 138 | err = mtd_read(mtd, addrn - bufsize, bufsize, &read, twopages); |
d57f4054 | 139 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
140 | err = 0; |
141 | if (err || read != bufsize) { | |
bb998419 | 142 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
143 | (long long)(addrn - bufsize)); |
144 | return err; | |
145 | } | |
146 | memset(twopages, 0, bufsize); | |
329ad399 | 147 | err = mtd_read(mtd, addr, bufsize, &read, twopages); |
d57f4054 | 148 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
149 | err = 0; |
150 | if (err || read != bufsize) { | |
bb998419 | 151 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
152 | (long long)addr); |
153 | break; | |
154 | } | |
155 | if (memcmp(twopages, writebuf + (j * pgsize), bufsize)) { | |
bb998419 | 156 | pr_err("error: verify failed at %#llx\n", |
e73f2174 AB |
157 | (long long)addr); |
158 | errcnt += 1; | |
159 | } | |
160 | } | |
161 | /* Check boundary between eraseblocks */ | |
162 | if (addr <= addrn - pgsize - pgsize && !bbt[ebnum + 1]) { | |
163 | unsigned long oldnext = next; | |
164 | /* Do a read to set the internal dataRAMs to different data */ | |
329ad399 | 165 | err = mtd_read(mtd, addr0, bufsize, &read, twopages); |
d57f4054 | 166 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
167 | err = 0; |
168 | if (err || read != bufsize) { | |
bb998419 | 169 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
170 | (long long)addr0); |
171 | return err; | |
172 | } | |
329ad399 | 173 | err = mtd_read(mtd, addrn - bufsize, bufsize, &read, twopages); |
d57f4054 | 174 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
175 | err = 0; |
176 | if (err || read != bufsize) { | |
bb998419 | 177 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
178 | (long long)(addrn - bufsize)); |
179 | return err; | |
180 | } | |
181 | memset(twopages, 0, bufsize); | |
329ad399 | 182 | err = mtd_read(mtd, addr, bufsize, &read, twopages); |
d57f4054 | 183 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
184 | err = 0; |
185 | if (err || read != bufsize) { | |
bb998419 | 186 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
187 | (long long)addr); |
188 | return err; | |
189 | } | |
190 | memcpy(boundary, writebuf + mtd->erasesize - pgsize, pgsize); | |
191 | set_random_data(boundary + pgsize, pgsize); | |
192 | if (memcmp(twopages, boundary, bufsize)) { | |
bb998419 | 193 | pr_err("error: verify failed at %#llx\n", |
e73f2174 AB |
194 | (long long)addr); |
195 | errcnt += 1; | |
196 | } | |
197 | next = oldnext; | |
198 | } | |
199 | return err; | |
200 | } | |
201 | ||
202 | static int crosstest(void) | |
203 | { | |
30fa9848 | 204 | size_t read; |
e73f2174 AB |
205 | int err = 0, i; |
206 | loff_t addr, addr0, addrn; | |
207 | unsigned char *pp1, *pp2, *pp3, *pp4; | |
208 | ||
bb998419 | 209 | pr_info("crosstest\n"); |
e73f2174 AB |
210 | pp1 = kmalloc(pgsize * 4, GFP_KERNEL); |
211 | if (!pp1) { | |
bb998419 | 212 | pr_err("error: cannot allocate memory\n"); |
e73f2174 AB |
213 | return -ENOMEM; |
214 | } | |
215 | pp2 = pp1 + pgsize; | |
216 | pp3 = pp2 + pgsize; | |
217 | pp4 = pp3 + pgsize; | |
218 | memset(pp1, 0, pgsize * 4); | |
219 | ||
220 | addr0 = 0; | |
c6f7e7be | 221 | for (i = 0; i < ebcnt && bbt[i]; ++i) |
e73f2174 AB |
222 | addr0 += mtd->erasesize; |
223 | ||
224 | addrn = mtd->size; | |
c6f7e7be | 225 | for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i) |
e73f2174 AB |
226 | addrn -= mtd->erasesize; |
227 | ||
228 | /* Read 2nd-to-last page to pp1 */ | |
e73f2174 | 229 | addr = addrn - pgsize - pgsize; |
329ad399 | 230 | err = mtd_read(mtd, addr, pgsize, &read, pp1); |
d57f4054 | 231 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
232 | err = 0; |
233 | if (err || read != pgsize) { | |
bb998419 | 234 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
235 | (long long)addr); |
236 | kfree(pp1); | |
237 | return err; | |
238 | } | |
239 | ||
240 | /* Read 3rd-to-last page to pp1 */ | |
e73f2174 | 241 | addr = addrn - pgsize - pgsize - pgsize; |
329ad399 | 242 | err = mtd_read(mtd, addr, pgsize, &read, pp1); |
d57f4054 | 243 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
244 | err = 0; |
245 | if (err || read != pgsize) { | |
bb998419 | 246 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
247 | (long long)addr); |
248 | kfree(pp1); | |
249 | return err; | |
250 | } | |
251 | ||
252 | /* Read first page to pp2 */ | |
e73f2174 | 253 | addr = addr0; |
bb998419 | 254 | pr_info("reading page at %#llx\n", (long long)addr); |
329ad399 | 255 | err = mtd_read(mtd, addr, pgsize, &read, pp2); |
d57f4054 | 256 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
257 | err = 0; |
258 | if (err || read != pgsize) { | |
bb998419 | 259 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
260 | (long long)addr); |
261 | kfree(pp1); | |
262 | return err; | |
263 | } | |
264 | ||
265 | /* Read last page to pp3 */ | |
e73f2174 | 266 | addr = addrn - pgsize; |
bb998419 | 267 | pr_info("reading page at %#llx\n", (long long)addr); |
329ad399 | 268 | err = mtd_read(mtd, addr, pgsize, &read, pp3); |
d57f4054 | 269 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
270 | err = 0; |
271 | if (err || read != pgsize) { | |
bb998419 | 272 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
273 | (long long)addr); |
274 | kfree(pp1); | |
275 | return err; | |
276 | } | |
277 | ||
278 | /* Read first page again to pp4 */ | |
e73f2174 | 279 | addr = addr0; |
bb998419 | 280 | pr_info("reading page at %#llx\n", (long long)addr); |
329ad399 | 281 | err = mtd_read(mtd, addr, pgsize, &read, pp4); |
d57f4054 | 282 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
283 | err = 0; |
284 | if (err || read != pgsize) { | |
bb998419 | 285 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
286 | (long long)addr); |
287 | kfree(pp1); | |
288 | return err; | |
289 | } | |
290 | ||
291 | /* pp2 and pp4 should be the same */ | |
bb998419 | 292 | pr_info("verifying pages read at %#llx match\n", |
e73f2174 AB |
293 | (long long)addr0); |
294 | if (memcmp(pp2, pp4, pgsize)) { | |
bb998419 | 295 | pr_err("verify failed!\n"); |
e73f2174 AB |
296 | errcnt += 1; |
297 | } else if (!err) | |
bb998419 | 298 | pr_info("crosstest ok\n"); |
e73f2174 AB |
299 | kfree(pp1); |
300 | return err; | |
301 | } | |
302 | ||
303 | static int erasecrosstest(void) | |
304 | { | |
30fa9848 | 305 | size_t read, written; |
7fc14bce | 306 | int err = 0, i, ebnum, ebnum2; |
e73f2174 AB |
307 | loff_t addr0; |
308 | char *readbuf = twopages; | |
309 | ||
bb998419 | 310 | pr_info("erasecrosstest\n"); |
e73f2174 AB |
311 | |
312 | ebnum = 0; | |
313 | addr0 = 0; | |
c6f7e7be | 314 | for (i = 0; i < ebcnt && bbt[i]; ++i) { |
e73f2174 AB |
315 | addr0 += mtd->erasesize; |
316 | ebnum += 1; | |
317 | } | |
318 | ||
319 | ebnum2 = ebcnt - 1; | |
320 | while (ebnum2 && bbt[ebnum2]) | |
321 | ebnum2 -= 1; | |
322 | ||
bb998419 | 323 | pr_info("erasing block %d\n", ebnum); |
e73f2174 AB |
324 | err = erase_eraseblock(ebnum); |
325 | if (err) | |
326 | return err; | |
327 | ||
bb998419 | 328 | pr_info("writing 1st page of block %d\n", ebnum); |
e73f2174 AB |
329 | set_random_data(writebuf, pgsize); |
330 | strcpy(writebuf, "There is no data like this!"); | |
eda95cbf | 331 | err = mtd_write(mtd, addr0, pgsize, &written, writebuf); |
e73f2174 | 332 | if (err || written != pgsize) { |
bb998419 | 333 | pr_info("error: write failed at %#llx\n", |
e73f2174 AB |
334 | (long long)addr0); |
335 | return err ? err : -1; | |
336 | } | |
337 | ||
bb998419 | 338 | pr_info("reading 1st page of block %d\n", ebnum); |
e73f2174 | 339 | memset(readbuf, 0, pgsize); |
329ad399 | 340 | err = mtd_read(mtd, addr0, pgsize, &read, readbuf); |
d57f4054 | 341 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
342 | err = 0; |
343 | if (err || read != pgsize) { | |
bb998419 | 344 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
345 | (long long)addr0); |
346 | return err ? err : -1; | |
347 | } | |
348 | ||
bb998419 | 349 | pr_info("verifying 1st page of block %d\n", ebnum); |
e73f2174 | 350 | if (memcmp(writebuf, readbuf, pgsize)) { |
bb998419 | 351 | pr_err("verify failed!\n"); |
e73f2174 | 352 | errcnt += 1; |
7fc14bce | 353 | return -1; |
e73f2174 AB |
354 | } |
355 | ||
bb998419 | 356 | pr_info("erasing block %d\n", ebnum); |
e73f2174 AB |
357 | err = erase_eraseblock(ebnum); |
358 | if (err) | |
359 | return err; | |
360 | ||
bb998419 | 361 | pr_info("writing 1st page of block %d\n", ebnum); |
e73f2174 AB |
362 | set_random_data(writebuf, pgsize); |
363 | strcpy(writebuf, "There is no data like this!"); | |
eda95cbf | 364 | err = mtd_write(mtd, addr0, pgsize, &written, writebuf); |
e73f2174 | 365 | if (err || written != pgsize) { |
bb998419 | 366 | pr_err("error: write failed at %#llx\n", |
e73f2174 AB |
367 | (long long)addr0); |
368 | return err ? err : -1; | |
369 | } | |
370 | ||
bb998419 | 371 | pr_info("erasing block %d\n", ebnum2); |
e73f2174 AB |
372 | err = erase_eraseblock(ebnum2); |
373 | if (err) | |
374 | return err; | |
375 | ||
bb998419 | 376 | pr_info("reading 1st page of block %d\n", ebnum); |
e73f2174 | 377 | memset(readbuf, 0, pgsize); |
329ad399 | 378 | err = mtd_read(mtd, addr0, pgsize, &read, readbuf); |
d57f4054 | 379 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
380 | err = 0; |
381 | if (err || read != pgsize) { | |
bb998419 | 382 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
383 | (long long)addr0); |
384 | return err ? err : -1; | |
385 | } | |
386 | ||
bb998419 | 387 | pr_info("verifying 1st page of block %d\n", ebnum); |
e73f2174 | 388 | if (memcmp(writebuf, readbuf, pgsize)) { |
bb998419 | 389 | pr_err("verify failed!\n"); |
e73f2174 | 390 | errcnt += 1; |
7fc14bce | 391 | return -1; |
e73f2174 AB |
392 | } |
393 | ||
7fc14bce | 394 | if (!err) |
bb998419 | 395 | pr_info("erasecrosstest ok\n"); |
e73f2174 AB |
396 | return err; |
397 | } | |
398 | ||
399 | static int erasetest(void) | |
400 | { | |
30fa9848 | 401 | size_t read, written; |
e73f2174 AB |
402 | int err = 0, i, ebnum, ok = 1; |
403 | loff_t addr0; | |
404 | ||
bb998419 | 405 | pr_info("erasetest\n"); |
e73f2174 AB |
406 | |
407 | ebnum = 0; | |
408 | addr0 = 0; | |
c6f7e7be | 409 | for (i = 0; i < ebcnt && bbt[i]; ++i) { |
e73f2174 AB |
410 | addr0 += mtd->erasesize; |
411 | ebnum += 1; | |
412 | } | |
413 | ||
bb998419 | 414 | pr_info("erasing block %d\n", ebnum); |
e73f2174 AB |
415 | err = erase_eraseblock(ebnum); |
416 | if (err) | |
417 | return err; | |
418 | ||
bb998419 | 419 | pr_info("writing 1st page of block %d\n", ebnum); |
e73f2174 | 420 | set_random_data(writebuf, pgsize); |
eda95cbf | 421 | err = mtd_write(mtd, addr0, pgsize, &written, writebuf); |
e73f2174 | 422 | if (err || written != pgsize) { |
bb998419 | 423 | pr_err("error: write failed at %#llx\n", |
e73f2174 AB |
424 | (long long)addr0); |
425 | return err ? err : -1; | |
426 | } | |
427 | ||
bb998419 | 428 | pr_info("erasing block %d\n", ebnum); |
e73f2174 AB |
429 | err = erase_eraseblock(ebnum); |
430 | if (err) | |
431 | return err; | |
432 | ||
bb998419 | 433 | pr_info("reading 1st page of block %d\n", ebnum); |
329ad399 | 434 | err = mtd_read(mtd, addr0, pgsize, &read, twopages); |
d57f4054 | 435 | if (mtd_is_bitflip(err)) |
e73f2174 AB |
436 | err = 0; |
437 | if (err || read != pgsize) { | |
bb998419 | 438 | pr_err("error: read failed at %#llx\n", |
e73f2174 AB |
439 | (long long)addr0); |
440 | return err ? err : -1; | |
441 | } | |
442 | ||
bb998419 | 443 | pr_info("verifying 1st page of block %d is all 0xff\n", |
e73f2174 AB |
444 | ebnum); |
445 | for (i = 0; i < pgsize; ++i) | |
446 | if (twopages[i] != 0xff) { | |
bb998419 | 447 | pr_err("verifying all 0xff failed at %d\n", |
e73f2174 AB |
448 | i); |
449 | errcnt += 1; | |
450 | ok = 0; | |
451 | break; | |
452 | } | |
453 | ||
454 | if (ok && !err) | |
bb998419 | 455 | pr_info("erasetest ok\n"); |
e73f2174 AB |
456 | |
457 | return err; | |
458 | } | |
459 | ||
460 | static int is_block_bad(int ebnum) | |
461 | { | |
462 | loff_t addr = ebnum * mtd->erasesize; | |
463 | int ret; | |
464 | ||
7086c19d | 465 | ret = mtd_block_isbad(mtd, addr); |
e73f2174 | 466 | if (ret) |
bb998419 | 467 | pr_info("block %d is bad\n", ebnum); |
e73f2174 AB |
468 | return ret; |
469 | } | |
470 | ||
471 | static int scan_for_bad_eraseblocks(void) | |
472 | { | |
473 | int i, bad = 0; | |
474 | ||
2bfefa4c | 475 | bbt = kzalloc(ebcnt, GFP_KERNEL); |
e73f2174 | 476 | if (!bbt) { |
bb998419 | 477 | pr_err("error: cannot allocate memory\n"); |
e73f2174 AB |
478 | return -ENOMEM; |
479 | } | |
e73f2174 | 480 | |
bb998419 | 481 | pr_info("scanning for bad eraseblocks\n"); |
e73f2174 AB |
482 | for (i = 0; i < ebcnt; ++i) { |
483 | bbt[i] = is_block_bad(i) ? 1 : 0; | |
484 | if (bbt[i]) | |
485 | bad += 1; | |
486 | cond_resched(); | |
487 | } | |
bb998419 | 488 | pr_info("scanned %d eraseblocks, %d are bad\n", i, bad); |
e73f2174 AB |
489 | return 0; |
490 | } | |
491 | ||
492 | static int __init mtd_pagetest_init(void) | |
493 | { | |
494 | int err = 0; | |
495 | uint64_t tmp; | |
496 | uint32_t i; | |
497 | ||
498 | printk(KERN_INFO "\n"); | |
499 | printk(KERN_INFO "=================================================\n"); | |
7406060e WS |
500 | |
501 | if (dev < 0) { | |
064a7694 | 502 | pr_info("Please specify a valid mtd-device via module parameter\n"); |
bb998419 | 503 | pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n"); |
7406060e WS |
504 | return -EINVAL; |
505 | } | |
506 | ||
bb998419 | 507 | pr_info("MTD device: %d\n", dev); |
e73f2174 AB |
508 | |
509 | mtd = get_mtd_device(NULL, dev); | |
510 | if (IS_ERR(mtd)) { | |
511 | err = PTR_ERR(mtd); | |
bb998419 | 512 | pr_err("error: cannot get MTD device\n"); |
e73f2174 AB |
513 | return err; |
514 | } | |
515 | ||
516 | if (mtd->type != MTD_NANDFLASH) { | |
bb998419 | 517 | pr_info("this test requires NAND flash\n"); |
e73f2174 AB |
518 | goto out; |
519 | } | |
520 | ||
521 | tmp = mtd->size; | |
522 | do_div(tmp, mtd->erasesize); | |
523 | ebcnt = tmp; | |
524 | pgcnt = mtd->erasesize / mtd->writesize; | |
4c2b8a62 | 525 | pgsize = mtd->writesize; |
e73f2174 | 526 | |
bb998419 | 527 | pr_info("MTD device size %llu, eraseblock size %u, " |
e73f2174 AB |
528 | "page size %u, count of eraseblocks %u, pages per " |
529 | "eraseblock %u, OOB size %u\n", | |
530 | (unsigned long long)mtd->size, mtd->erasesize, | |
531 | pgsize, ebcnt, pgcnt, mtd->oobsize); | |
532 | ||
533 | err = -ENOMEM; | |
534 | bufsize = pgsize * 2; | |
535 | writebuf = kmalloc(mtd->erasesize, GFP_KERNEL); | |
536 | if (!writebuf) { | |
bb998419 | 537 | pr_err("error: cannot allocate memory\n"); |
e73f2174 AB |
538 | goto out; |
539 | } | |
540 | twopages = kmalloc(bufsize, GFP_KERNEL); | |
541 | if (!twopages) { | |
bb998419 | 542 | pr_err("error: cannot allocate memory\n"); |
e73f2174 AB |
543 | goto out; |
544 | } | |
545 | boundary = kmalloc(bufsize, GFP_KERNEL); | |
546 | if (!boundary) { | |
bb998419 | 547 | pr_err("error: cannot allocate memory\n"); |
e73f2174 AB |
548 | goto out; |
549 | } | |
550 | ||
551 | err = scan_for_bad_eraseblocks(); | |
552 | if (err) | |
553 | goto out; | |
554 | ||
555 | /* Erase all eraseblocks */ | |
bb998419 | 556 | pr_info("erasing whole device\n"); |
e73f2174 AB |
557 | for (i = 0; i < ebcnt; ++i) { |
558 | if (bbt[i]) | |
559 | continue; | |
560 | err = erase_eraseblock(i); | |
561 | if (err) | |
562 | goto out; | |
563 | cond_resched(); | |
564 | } | |
bb998419 | 565 | pr_info("erased %u eraseblocks\n", i); |
e73f2174 AB |
566 | |
567 | /* Write all eraseblocks */ | |
568 | simple_srand(1); | |
bb998419 | 569 | pr_info("writing whole device\n"); |
e73f2174 AB |
570 | for (i = 0; i < ebcnt; ++i) { |
571 | if (bbt[i]) | |
572 | continue; | |
573 | err = write_eraseblock(i); | |
574 | if (err) | |
575 | goto out; | |
576 | if (i % 256 == 0) | |
bb998419 | 577 | pr_info("written up to eraseblock %u\n", i); |
e73f2174 AB |
578 | cond_resched(); |
579 | } | |
bb998419 | 580 | pr_info("written %u eraseblocks\n", i); |
e73f2174 AB |
581 | |
582 | /* Check all eraseblocks */ | |
583 | simple_srand(1); | |
bb998419 | 584 | pr_info("verifying all eraseblocks\n"); |
e73f2174 AB |
585 | for (i = 0; i < ebcnt; ++i) { |
586 | if (bbt[i]) | |
587 | continue; | |
588 | err = verify_eraseblock(i); | |
589 | if (err) | |
590 | goto out; | |
591 | if (i % 256 == 0) | |
bb998419 | 592 | pr_info("verified up to eraseblock %u\n", i); |
e73f2174 AB |
593 | cond_resched(); |
594 | } | |
bb998419 | 595 | pr_info("verified %u eraseblocks\n", i); |
e73f2174 AB |
596 | |
597 | err = crosstest(); | |
598 | if (err) | |
599 | goto out; | |
600 | ||
601 | err = erasecrosstest(); | |
602 | if (err) | |
603 | goto out; | |
604 | ||
605 | err = erasetest(); | |
606 | if (err) | |
607 | goto out; | |
608 | ||
bb998419 | 609 | pr_info("finished with %d errors\n", errcnt); |
e73f2174 AB |
610 | out: |
611 | ||
612 | kfree(bbt); | |
613 | kfree(boundary); | |
614 | kfree(twopages); | |
615 | kfree(writebuf); | |
616 | put_mtd_device(mtd); | |
617 | if (err) | |
bb998419 | 618 | pr_info("error %d occurred\n", err); |
e73f2174 AB |
619 | printk(KERN_INFO "=================================================\n"); |
620 | return err; | |
621 | } | |
622 | module_init(mtd_pagetest_init); | |
623 | ||
624 | static void __exit mtd_pagetest_exit(void) | |
625 | { | |
626 | return; | |
627 | } | |
628 | module_exit(mtd_pagetest_exit); | |
629 | ||
630 | MODULE_DESCRIPTION("NAND page test"); | |
631 | MODULE_AUTHOR("Adrian Hunter"); | |
632 | MODULE_LICENSE("GPL"); |