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 #include <asm/div64.h>
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/err.h>
27 #include <linux/mtd/mtd.h>
28 #include <linux/slab.h>
29 #include <linux/sched.h>
31 #define PRINT_PREF KERN_INFO "mtd_pagetest: "
33 static int dev = -EINVAL;
34 module_param(dev, int, S_IRUGO);
35 MODULE_PARM_DESC(dev, "MTD device number to use");
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;
48 static unsigned long next = 1;
50 static inline unsigned int simple_rand(void)
52 next = next * 1103515245 + 12345;
53 return (unsigned int)((next / 65536) % 32768);
56 static inline void simple_srand(unsigned long seed)
61 static void set_random_data(unsigned char *buf, size_t len)
65 for (i = 0; i < len; ++i)
66 buf[i] = simple_rand();
69 static int erase_eraseblock(int ebnum)
73 loff_t addr = ebnum * mtd->erasesize;
75 memset(&ei, 0, sizeof(struct erase_info));
78 ei.len = mtd->erasesize;
80 err = mtd_erase(mtd, &ei);
82 printk(PRINT_PREF "error %d while erasing EB %d\n", err, ebnum);
86 if (ei.state == MTD_ERASE_FAILED) {
87 printk(PRINT_PREF "some erase error occurred at EB %d\n",
95 static int write_eraseblock(int ebnum)
99 loff_t addr = ebnum * mtd->erasesize;
101 set_random_data(writebuf, mtd->erasesize);
103 err = mtd->write(mtd, addr, mtd->erasesize, &written, writebuf);
104 if (err || written != mtd->erasesize)
105 printk(PRINT_PREF "error: write failed at %#llx\n",
111 static int verify_eraseblock(int ebnum)
117 loff_t addr = ebnum * mtd->erasesize;
120 for (i = 0; i < ebcnt && bbt[i]; ++i)
121 addr0 += mtd->erasesize;
124 for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i)
125 addrn -= mtd->erasesize;
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 */
130 err = mtd_read(mtd, addr0, bufsize, &read, twopages);
131 if (mtd_is_bitflip(err))
133 if (err || read != bufsize) {
134 printk(PRINT_PREF "error: read failed at %#llx\n",
138 err = mtd_read(mtd, addrn - bufsize, bufsize, &read, twopages);
139 if (mtd_is_bitflip(err))
141 if (err || read != bufsize) {
142 printk(PRINT_PREF "error: read failed at %#llx\n",
143 (long long)(addrn - bufsize));
146 memset(twopages, 0, bufsize);
148 err = mtd_read(mtd, addr, bufsize, &read, twopages);
149 if (mtd_is_bitflip(err))
151 if (err || read != bufsize) {
152 printk(PRINT_PREF "error: read failed at %#llx\n",
156 if (memcmp(twopages, writebuf + (j * pgsize), bufsize)) {
157 printk(PRINT_PREF "error: verify failed at %#llx\n",
162 /* Check boundary between eraseblocks */
163 if (addr <= addrn - pgsize - pgsize && !bbt[ebnum + 1]) {
164 unsigned long oldnext = next;
165 /* Do a read to set the internal dataRAMs to different data */
166 err = mtd_read(mtd, addr0, bufsize, &read, twopages);
167 if (mtd_is_bitflip(err))
169 if (err || read != bufsize) {
170 printk(PRINT_PREF "error: read failed at %#llx\n",
174 err = mtd_read(mtd, addrn - bufsize, bufsize, &read, twopages);
175 if (mtd_is_bitflip(err))
177 if (err || read != bufsize) {
178 printk(PRINT_PREF "error: read failed at %#llx\n",
179 (long long)(addrn - bufsize));
182 memset(twopages, 0, bufsize);
184 err = mtd_read(mtd, addr, bufsize, &read, twopages);
185 if (mtd_is_bitflip(err))
187 if (err || read != bufsize) {
188 printk(PRINT_PREF "error: read failed at %#llx\n",
192 memcpy(boundary, writebuf + mtd->erasesize - pgsize, pgsize);
193 set_random_data(boundary + pgsize, pgsize);
194 if (memcmp(twopages, boundary, bufsize)) {
195 printk(PRINT_PREF "error: verify failed at %#llx\n",
204 static int crosstest(void)
208 loff_t addr, addr0, addrn;
209 unsigned char *pp1, *pp2, *pp3, *pp4;
211 printk(PRINT_PREF "crosstest\n");
212 pp1 = kmalloc(pgsize * 4, GFP_KERNEL);
214 printk(PRINT_PREF "error: cannot allocate memory\n");
220 memset(pp1, 0, pgsize * 4);
223 for (i = 0; i < ebcnt && bbt[i]; ++i)
224 addr0 += mtd->erasesize;
227 for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i)
228 addrn -= mtd->erasesize;
230 /* Read 2nd-to-last page to pp1 */
232 addr = addrn - pgsize - pgsize;
233 err = mtd_read(mtd, addr, pgsize, &read, pp1);
234 if (mtd_is_bitflip(err))
236 if (err || read != pgsize) {
237 printk(PRINT_PREF "error: read failed at %#llx\n",
243 /* Read 3rd-to-last page to pp1 */
245 addr = addrn - pgsize - pgsize - pgsize;
246 err = mtd_read(mtd, addr, pgsize, &read, pp1);
247 if (mtd_is_bitflip(err))
249 if (err || read != pgsize) {
250 printk(PRINT_PREF "error: read failed at %#llx\n",
256 /* Read first page to pp2 */
259 printk(PRINT_PREF "reading page at %#llx\n", (long long)addr);
260 err = mtd_read(mtd, addr, pgsize, &read, pp2);
261 if (mtd_is_bitflip(err))
263 if (err || read != pgsize) {
264 printk(PRINT_PREF "error: read failed at %#llx\n",
270 /* Read last page to pp3 */
272 addr = addrn - pgsize;
273 printk(PRINT_PREF "reading page at %#llx\n", (long long)addr);
274 err = mtd_read(mtd, addr, pgsize, &read, pp3);
275 if (mtd_is_bitflip(err))
277 if (err || read != pgsize) {
278 printk(PRINT_PREF "error: read failed at %#llx\n",
284 /* Read first page again to pp4 */
287 printk(PRINT_PREF "reading page at %#llx\n", (long long)addr);
288 err = mtd_read(mtd, addr, pgsize, &read, pp4);
289 if (mtd_is_bitflip(err))
291 if (err || read != pgsize) {
292 printk(PRINT_PREF "error: read failed at %#llx\n",
298 /* pp2 and pp4 should be the same */
299 printk(PRINT_PREF "verifying pages read at %#llx match\n",
301 if (memcmp(pp2, pp4, pgsize)) {
302 printk(PRINT_PREF "verify failed!\n");
305 printk(PRINT_PREF "crosstest ok\n");
310 static int erasecrosstest(void)
312 size_t read = 0, written = 0;
313 int err = 0, i, ebnum, ebnum2;
315 char *readbuf = twopages;
317 printk(PRINT_PREF "erasecrosstest\n");
321 for (i = 0; i < ebcnt && bbt[i]; ++i) {
322 addr0 += mtd->erasesize;
327 while (ebnum2 && bbt[ebnum2])
330 printk(PRINT_PREF "erasing block %d\n", ebnum);
331 err = erase_eraseblock(ebnum);
335 printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
336 set_random_data(writebuf, pgsize);
337 strcpy(writebuf, "There is no data like this!");
338 err = mtd->write(mtd, addr0, pgsize, &written, writebuf);
339 if (err || written != pgsize) {
340 printk(PRINT_PREF "error: write failed at %#llx\n",
342 return err ? err : -1;
345 printk(PRINT_PREF "reading 1st page of block %d\n", ebnum);
346 memset(readbuf, 0, pgsize);
347 err = mtd_read(mtd, addr0, pgsize, &read, readbuf);
348 if (mtd_is_bitflip(err))
350 if (err || read != pgsize) {
351 printk(PRINT_PREF "error: read failed at %#llx\n",
353 return err ? err : -1;
356 printk(PRINT_PREF "verifying 1st page of block %d\n", ebnum);
357 if (memcmp(writebuf, readbuf, pgsize)) {
358 printk(PRINT_PREF "verify failed!\n");
363 printk(PRINT_PREF "erasing block %d\n", ebnum);
364 err = erase_eraseblock(ebnum);
368 printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
369 set_random_data(writebuf, pgsize);
370 strcpy(writebuf, "There is no data like this!");
371 err = mtd->write(mtd, addr0, pgsize, &written, writebuf);
372 if (err || written != pgsize) {
373 printk(PRINT_PREF "error: write failed at %#llx\n",
375 return err ? err : -1;
378 printk(PRINT_PREF "erasing block %d\n", ebnum2);
379 err = erase_eraseblock(ebnum2);
383 printk(PRINT_PREF "reading 1st page of block %d\n", ebnum);
384 memset(readbuf, 0, pgsize);
385 err = mtd_read(mtd, addr0, pgsize, &read, readbuf);
386 if (mtd_is_bitflip(err))
388 if (err || read != pgsize) {
389 printk(PRINT_PREF "error: read failed at %#llx\n",
391 return err ? err : -1;
394 printk(PRINT_PREF "verifying 1st page of block %d\n", ebnum);
395 if (memcmp(writebuf, readbuf, pgsize)) {
396 printk(PRINT_PREF "verify failed!\n");
402 printk(PRINT_PREF "erasecrosstest ok\n");
406 static int erasetest(void)
408 size_t read = 0, written = 0;
409 int err = 0, i, ebnum, ok = 1;
412 printk(PRINT_PREF "erasetest\n");
416 for (i = 0; i < ebcnt && bbt[i]; ++i) {
417 addr0 += mtd->erasesize;
421 printk(PRINT_PREF "erasing block %d\n", ebnum);
422 err = erase_eraseblock(ebnum);
426 printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
427 set_random_data(writebuf, pgsize);
428 err = mtd->write(mtd, addr0, pgsize, &written, writebuf);
429 if (err || written != pgsize) {
430 printk(PRINT_PREF "error: write failed at %#llx\n",
432 return err ? err : -1;
435 printk(PRINT_PREF "erasing block %d\n", ebnum);
436 err = erase_eraseblock(ebnum);
440 printk(PRINT_PREF "reading 1st page of block %d\n", ebnum);
441 err = mtd_read(mtd, addr0, pgsize, &read, twopages);
442 if (mtd_is_bitflip(err))
444 if (err || read != pgsize) {
445 printk(PRINT_PREF "error: read failed at %#llx\n",
447 return err ? err : -1;
450 printk(PRINT_PREF "verifying 1st page of block %d is all 0xff\n",
452 for (i = 0; i < pgsize; ++i)
453 if (twopages[i] != 0xff) {
454 printk(PRINT_PREF "verifying all 0xff failed at %d\n",
462 printk(PRINT_PREF "erasetest ok\n");
467 static int is_block_bad(int ebnum)
469 loff_t addr = ebnum * mtd->erasesize;
472 ret = mtd->block_isbad(mtd, addr);
474 printk(PRINT_PREF "block %d is bad\n", ebnum);
478 static int scan_for_bad_eraseblocks(void)
482 bbt = kzalloc(ebcnt, GFP_KERNEL);
484 printk(PRINT_PREF "error: cannot allocate memory\n");
488 printk(PRINT_PREF "scanning for bad eraseblocks\n");
489 for (i = 0; i < ebcnt; ++i) {
490 bbt[i] = is_block_bad(i) ? 1 : 0;
495 printk(PRINT_PREF "scanned %d eraseblocks, %d are bad\n", i, bad);
499 static int __init mtd_pagetest_init(void)
505 printk(KERN_INFO "\n");
506 printk(KERN_INFO "=================================================\n");
509 printk(PRINT_PREF "Please specify a valid mtd-device via module paramter\n");
510 printk(KERN_CRIT "CAREFUL: This test wipes all data on the specified MTD device!\n");
514 printk(PRINT_PREF "MTD device: %d\n", dev);
516 mtd = get_mtd_device(NULL, dev);
519 printk(PRINT_PREF "error: cannot get MTD device\n");
523 if (mtd->type != MTD_NANDFLASH) {
524 printk(PRINT_PREF "this test requires NAND flash\n");
529 do_div(tmp, mtd->erasesize);
531 pgcnt = mtd->erasesize / mtd->writesize;
532 pgsize = mtd->writesize;
534 printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
535 "page size %u, count of eraseblocks %u, pages per "
536 "eraseblock %u, OOB size %u\n",
537 (unsigned long long)mtd->size, mtd->erasesize,
538 pgsize, ebcnt, pgcnt, mtd->oobsize);
541 bufsize = pgsize * 2;
542 writebuf = kmalloc(mtd->erasesize, GFP_KERNEL);
544 printk(PRINT_PREF "error: cannot allocate memory\n");
547 twopages = kmalloc(bufsize, GFP_KERNEL);
549 printk(PRINT_PREF "error: cannot allocate memory\n");
552 boundary = kmalloc(bufsize, GFP_KERNEL);
554 printk(PRINT_PREF "error: cannot allocate memory\n");
558 err = scan_for_bad_eraseblocks();
562 /* Erase all eraseblocks */
563 printk(PRINT_PREF "erasing whole device\n");
564 for (i = 0; i < ebcnt; ++i) {
567 err = erase_eraseblock(i);
572 printk(PRINT_PREF "erased %u eraseblocks\n", i);
574 /* Write all eraseblocks */
576 printk(PRINT_PREF "writing whole device\n");
577 for (i = 0; i < ebcnt; ++i) {
580 err = write_eraseblock(i);
584 printk(PRINT_PREF "written up to eraseblock %u\n", i);
587 printk(PRINT_PREF "written %u eraseblocks\n", i);
589 /* Check all eraseblocks */
591 printk(PRINT_PREF "verifying all eraseblocks\n");
592 for (i = 0; i < ebcnt; ++i) {
595 err = verify_eraseblock(i);
599 printk(PRINT_PREF "verified up to eraseblock %u\n", i);
602 printk(PRINT_PREF "verified %u eraseblocks\n", i);
608 err = erasecrosstest();
616 printk(PRINT_PREF "finished with %d errors\n", errcnt);
625 printk(PRINT_PREF "error %d occurred\n", err);
626 printk(KERN_INFO "=================================================\n");
629 module_init(mtd_pagetest_init);
631 static void __exit mtd_pagetest_exit(void)
635 module_exit(mtd_pagetest_exit);
637 MODULE_DESCRIPTION("NAND page test");
638 MODULE_AUTHOR("Adrian Hunter");
639 MODULE_LICENSE("GPL");