2 * Copyright (C) 2006-2008 Nokia Corporation
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.
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
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.
17 * Test page read and write on MTD device.
19 * Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
30 #include <linux/slab.h>
31 #include <linux/sched.h>
32 #include <linux/random.h>
34 static int dev = -EINVAL;
35 module_param(dev, int, S_IRUGO);
36 MODULE_PARM_DESC(dev, "MTD device number to use");
38 static struct mtd_info *mtd;
39 static unsigned char *twopages;
40 static unsigned char *writebuf;
41 static unsigned char *boundary;
42 static unsigned char *bbt;
49 static struct rnd_state rnd_state;
51 static int erase_eraseblock(int ebnum)
55 loff_t addr = ebnum * mtd->erasesize;
57 memset(&ei, 0, sizeof(struct erase_info));
60 ei.len = mtd->erasesize;
62 err = mtd_erase(mtd, &ei);
64 pr_err("error %d while erasing EB %d\n", err, ebnum);
68 if (ei.state == MTD_ERASE_FAILED) {
69 pr_err("some erase error occurred at EB %d\n",
77 static int write_eraseblock(int ebnum)
81 loff_t addr = ebnum * mtd->erasesize;
83 prandom_bytes_state(&rnd_state, writebuf, mtd->erasesize);
85 err = mtd_write(mtd, addr, mtd->erasesize, &written, writebuf);
86 if (err || written != mtd->erasesize)
87 pr_err("error: write failed at %#llx\n",
93 static int verify_eraseblock(int ebnum)
99 loff_t addr = ebnum * mtd->erasesize;
102 for (i = 0; i < ebcnt && bbt[i]; ++i)
103 addr0 += mtd->erasesize;
106 for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i)
107 addrn -= mtd->erasesize;
109 prandom_bytes_state(&rnd_state, writebuf, mtd->erasesize);
110 for (j = 0; j < pgcnt - 1; ++j, addr += pgsize) {
111 /* Do a read to set the internal dataRAMs to different data */
112 err = mtd_read(mtd, addr0, bufsize, &read, twopages);
113 if (mtd_is_bitflip(err))
115 if (err || read != bufsize) {
116 pr_err("error: read failed at %#llx\n",
120 err = mtd_read(mtd, addrn - bufsize, bufsize, &read, twopages);
121 if (mtd_is_bitflip(err))
123 if (err || read != bufsize) {
124 pr_err("error: read failed at %#llx\n",
125 (long long)(addrn - bufsize));
128 memset(twopages, 0, bufsize);
129 err = mtd_read(mtd, addr, bufsize, &read, twopages);
130 if (mtd_is_bitflip(err))
132 if (err || read != bufsize) {
133 pr_err("error: read failed at %#llx\n",
137 if (memcmp(twopages, writebuf + (j * pgsize), bufsize)) {
138 pr_err("error: verify failed at %#llx\n",
143 /* Check boundary between eraseblocks */
144 if (addr <= addrn - pgsize - pgsize && !bbt[ebnum + 1]) {
145 struct rnd_state old_state = rnd_state;
147 /* Do a read to set the internal dataRAMs to different data */
148 err = mtd_read(mtd, addr0, bufsize, &read, twopages);
149 if (mtd_is_bitflip(err))
151 if (err || read != bufsize) {
152 pr_err("error: read failed at %#llx\n",
156 err = mtd_read(mtd, addrn - bufsize, bufsize, &read, twopages);
157 if (mtd_is_bitflip(err))
159 if (err || read != bufsize) {
160 pr_err("error: read failed at %#llx\n",
161 (long long)(addrn - bufsize));
164 memset(twopages, 0, bufsize);
165 err = mtd_read(mtd, addr, bufsize, &read, twopages);
166 if (mtd_is_bitflip(err))
168 if (err || read != bufsize) {
169 pr_err("error: read failed at %#llx\n",
173 memcpy(boundary, writebuf + mtd->erasesize - pgsize, pgsize);
174 prandom_bytes_state(&rnd_state, boundary + pgsize, pgsize);
175 if (memcmp(twopages, boundary, bufsize)) {
176 pr_err("error: verify failed at %#llx\n",
180 rnd_state = old_state;
185 static int crosstest(void)
189 loff_t addr, addr0, addrn;
190 unsigned char *pp1, *pp2, *pp3, *pp4;
192 pr_info("crosstest\n");
193 pp1 = kmalloc(pgsize * 4, GFP_KERNEL);
199 memset(pp1, 0, pgsize * 4);
202 for (i = 0; i < ebcnt && bbt[i]; ++i)
203 addr0 += mtd->erasesize;
206 for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i)
207 addrn -= mtd->erasesize;
209 /* Read 2nd-to-last page to pp1 */
210 addr = addrn - pgsize - pgsize;
211 err = mtd_read(mtd, addr, pgsize, &read, pp1);
212 if (mtd_is_bitflip(err))
214 if (err || read != pgsize) {
215 pr_err("error: read failed at %#llx\n",
221 /* Read 3rd-to-last page to pp1 */
222 addr = addrn - pgsize - pgsize - pgsize;
223 err = mtd_read(mtd, addr, pgsize, &read, pp1);
224 if (mtd_is_bitflip(err))
226 if (err || read != pgsize) {
227 pr_err("error: read failed at %#llx\n",
233 /* Read first page to pp2 */
235 pr_info("reading page at %#llx\n", (long long)addr);
236 err = mtd_read(mtd, addr, pgsize, &read, pp2);
237 if (mtd_is_bitflip(err))
239 if (err || read != pgsize) {
240 pr_err("error: read failed at %#llx\n",
246 /* Read last page to pp3 */
247 addr = addrn - pgsize;
248 pr_info("reading page at %#llx\n", (long long)addr);
249 err = mtd_read(mtd, addr, pgsize, &read, pp3);
250 if (mtd_is_bitflip(err))
252 if (err || read != pgsize) {
253 pr_err("error: read failed at %#llx\n",
259 /* Read first page again to pp4 */
261 pr_info("reading page at %#llx\n", (long long)addr);
262 err = mtd_read(mtd, addr, pgsize, &read, pp4);
263 if (mtd_is_bitflip(err))
265 if (err || read != pgsize) {
266 pr_err("error: read failed at %#llx\n",
272 /* pp2 and pp4 should be the same */
273 pr_info("verifying pages read at %#llx match\n",
275 if (memcmp(pp2, pp4, pgsize)) {
276 pr_err("verify failed!\n");
279 pr_info("crosstest ok\n");
284 static int erasecrosstest(void)
286 size_t read, written;
287 int err = 0, i, ebnum, ebnum2;
289 char *readbuf = twopages;
291 pr_info("erasecrosstest\n");
295 for (i = 0; i < ebcnt && bbt[i]; ++i) {
296 addr0 += mtd->erasesize;
301 while (ebnum2 && bbt[ebnum2])
304 pr_info("erasing block %d\n", ebnum);
305 err = erase_eraseblock(ebnum);
309 pr_info("writing 1st page of block %d\n", ebnum);
310 prandom_bytes_state(&rnd_state, writebuf, pgsize);
311 strcpy(writebuf, "There is no data like this!");
312 err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
313 if (err || written != pgsize) {
314 pr_info("error: write failed at %#llx\n",
316 return err ? err : -1;
319 pr_info("reading 1st page of block %d\n", ebnum);
320 memset(readbuf, 0, pgsize);
321 err = mtd_read(mtd, addr0, pgsize, &read, readbuf);
322 if (mtd_is_bitflip(err))
324 if (err || read != pgsize) {
325 pr_err("error: read failed at %#llx\n",
327 return err ? err : -1;
330 pr_info("verifying 1st page of block %d\n", ebnum);
331 if (memcmp(writebuf, readbuf, pgsize)) {
332 pr_err("verify failed!\n");
337 pr_info("erasing block %d\n", ebnum);
338 err = erase_eraseblock(ebnum);
342 pr_info("writing 1st page of block %d\n", ebnum);
343 prandom_bytes_state(&rnd_state, writebuf, pgsize);
344 strcpy(writebuf, "There is no data like this!");
345 err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
346 if (err || written != pgsize) {
347 pr_err("error: write failed at %#llx\n",
349 return err ? err : -1;
352 pr_info("erasing block %d\n", ebnum2);
353 err = erase_eraseblock(ebnum2);
357 pr_info("reading 1st page of block %d\n", ebnum);
358 memset(readbuf, 0, pgsize);
359 err = mtd_read(mtd, addr0, pgsize, &read, readbuf);
360 if (mtd_is_bitflip(err))
362 if (err || read != pgsize) {
363 pr_err("error: read failed at %#llx\n",
365 return err ? err : -1;
368 pr_info("verifying 1st page of block %d\n", ebnum);
369 if (memcmp(writebuf, readbuf, pgsize)) {
370 pr_err("verify failed!\n");
376 pr_info("erasecrosstest ok\n");
380 static int erasetest(void)
382 size_t read, written;
383 int err = 0, i, ebnum, ok = 1;
386 pr_info("erasetest\n");
390 for (i = 0; i < ebcnt && bbt[i]; ++i) {
391 addr0 += mtd->erasesize;
395 pr_info("erasing block %d\n", ebnum);
396 err = erase_eraseblock(ebnum);
400 pr_info("writing 1st page of block %d\n", ebnum);
401 prandom_bytes_state(&rnd_state, writebuf, pgsize);
402 err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
403 if (err || written != pgsize) {
404 pr_err("error: write failed at %#llx\n",
406 return err ? err : -1;
409 pr_info("erasing block %d\n", ebnum);
410 err = erase_eraseblock(ebnum);
414 pr_info("reading 1st page of block %d\n", ebnum);
415 err = mtd_read(mtd, addr0, pgsize, &read, twopages);
416 if (mtd_is_bitflip(err))
418 if (err || read != pgsize) {
419 pr_err("error: read failed at %#llx\n",
421 return err ? err : -1;
424 pr_info("verifying 1st page of block %d is all 0xff\n",
426 for (i = 0; i < pgsize; ++i)
427 if (twopages[i] != 0xff) {
428 pr_err("verifying all 0xff failed at %d\n",
436 pr_info("erasetest ok\n");
441 static int is_block_bad(int ebnum)
443 loff_t addr = ebnum * mtd->erasesize;
446 ret = mtd_block_isbad(mtd, addr);
448 pr_info("block %d is bad\n", ebnum);
452 static int scan_for_bad_eraseblocks(void)
456 bbt = kzalloc(ebcnt, GFP_KERNEL);
460 pr_info("scanning for bad eraseblocks\n");
461 for (i = 0; i < ebcnt; ++i) {
462 bbt[i] = is_block_bad(i) ? 1 : 0;
467 pr_info("scanned %d eraseblocks, %d are bad\n", i, bad);
471 static int __init mtd_pagetest_init(void)
477 printk(KERN_INFO "\n");
478 printk(KERN_INFO "=================================================\n");
481 pr_info("Please specify a valid mtd-device via module parameter\n");
482 pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
486 pr_info("MTD device: %d\n", dev);
488 mtd = get_mtd_device(NULL, dev);
491 pr_err("error: cannot get MTD device\n");
495 if (mtd->type != MTD_NANDFLASH) {
496 pr_info("this test requires NAND flash\n");
501 do_div(tmp, mtd->erasesize);
503 pgcnt = mtd->erasesize / mtd->writesize;
504 pgsize = mtd->writesize;
506 pr_info("MTD device size %llu, eraseblock size %u, "
507 "page size %u, count of eraseblocks %u, pages per "
508 "eraseblock %u, OOB size %u\n",
509 (unsigned long long)mtd->size, mtd->erasesize,
510 pgsize, ebcnt, pgcnt, mtd->oobsize);
513 bufsize = pgsize * 2;
514 writebuf = kmalloc(mtd->erasesize, GFP_KERNEL);
517 twopages = kmalloc(bufsize, GFP_KERNEL);
520 boundary = kmalloc(bufsize, GFP_KERNEL);
524 err = scan_for_bad_eraseblocks();
528 /* Erase all eraseblocks */
529 pr_info("erasing whole device\n");
530 for (i = 0; i < ebcnt; ++i) {
533 err = erase_eraseblock(i);
538 pr_info("erased %u eraseblocks\n", i);
540 /* Write all eraseblocks */
541 prandom_seed_state(&rnd_state, 1);
542 pr_info("writing whole device\n");
543 for (i = 0; i < ebcnt; ++i) {
546 err = write_eraseblock(i);
550 pr_info("written up to eraseblock %u\n", i);
553 pr_info("written %u eraseblocks\n", i);
555 /* Check all eraseblocks */
556 prandom_seed_state(&rnd_state, 1);
557 pr_info("verifying all eraseblocks\n");
558 for (i = 0; i < ebcnt; ++i) {
561 err = verify_eraseblock(i);
565 pr_info("verified up to eraseblock %u\n", i);
568 pr_info("verified %u eraseblocks\n", i);
574 err = erasecrosstest();
582 pr_info("finished with %d errors\n", errcnt);
591 pr_info("error %d occurred\n", err);
592 printk(KERN_INFO "=================================================\n");
595 module_init(mtd_pagetest_init);
597 static void __exit mtd_pagetest_exit(void)
601 module_exit(mtd_pagetest_exit);
603 MODULE_DESCRIPTION("NAND page test");
604 MODULE_AUTHOR("Adrian Hunter");
605 MODULE_LICENSE("GPL");