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);
147 err = mtd_read(mtd, addr, bufsize, &read, twopages);
148 if (mtd_is_bitflip(err))
150 if (err || read != bufsize) {
151 printk(PRINT_PREF "error: read failed at %#llx\n",
155 if (memcmp(twopages, writebuf + (j * pgsize), bufsize)) {
156 printk(PRINT_PREF "error: verify failed at %#llx\n",
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 */
165 err = mtd_read(mtd, addr0, bufsize, &read, twopages);
166 if (mtd_is_bitflip(err))
168 if (err || read != bufsize) {
169 printk(PRINT_PREF "error: read failed at %#llx\n",
173 err = mtd_read(mtd, addrn - bufsize, bufsize, &read, twopages);
174 if (mtd_is_bitflip(err))
176 if (err || read != bufsize) {
177 printk(PRINT_PREF "error: read failed at %#llx\n",
178 (long long)(addrn - bufsize));
181 memset(twopages, 0, bufsize);
182 err = mtd_read(mtd, addr, bufsize, &read, twopages);
183 if (mtd_is_bitflip(err))
185 if (err || read != bufsize) {
186 printk(PRINT_PREF "error: read failed at %#llx\n",
190 memcpy(boundary, writebuf + mtd->erasesize - pgsize, pgsize);
191 set_random_data(boundary + pgsize, pgsize);
192 if (memcmp(twopages, boundary, bufsize)) {
193 printk(PRINT_PREF "error: verify failed at %#llx\n",
202 static int crosstest(void)
206 loff_t addr, addr0, addrn;
207 unsigned char *pp1, *pp2, *pp3, *pp4;
209 printk(PRINT_PREF "crosstest\n");
210 pp1 = kmalloc(pgsize * 4, GFP_KERNEL);
212 printk(PRINT_PREF "error: cannot allocate memory\n");
218 memset(pp1, 0, pgsize * 4);
221 for (i = 0; i < ebcnt && bbt[i]; ++i)
222 addr0 += mtd->erasesize;
225 for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i)
226 addrn -= mtd->erasesize;
228 /* Read 2nd-to-last page to pp1 */
229 addr = addrn - pgsize - pgsize;
230 err = mtd_read(mtd, addr, pgsize, &read, pp1);
231 if (mtd_is_bitflip(err))
233 if (err || read != pgsize) {
234 printk(PRINT_PREF "error: read failed at %#llx\n",
240 /* Read 3rd-to-last page to pp1 */
241 addr = addrn - pgsize - pgsize - pgsize;
242 err = mtd_read(mtd, addr, pgsize, &read, pp1);
243 if (mtd_is_bitflip(err))
245 if (err || read != pgsize) {
246 printk(PRINT_PREF "error: read failed at %#llx\n",
252 /* Read first page to pp2 */
254 printk(PRINT_PREF "reading page at %#llx\n", (long long)addr);
255 err = mtd_read(mtd, addr, pgsize, &read, pp2);
256 if (mtd_is_bitflip(err))
258 if (err || read != pgsize) {
259 printk(PRINT_PREF "error: read failed at %#llx\n",
265 /* Read last page to pp3 */
266 addr = addrn - pgsize;
267 printk(PRINT_PREF "reading page at %#llx\n", (long long)addr);
268 err = mtd_read(mtd, addr, pgsize, &read, pp3);
269 if (mtd_is_bitflip(err))
271 if (err || read != pgsize) {
272 printk(PRINT_PREF "error: read failed at %#llx\n",
278 /* Read first page again to pp4 */
280 printk(PRINT_PREF "reading page at %#llx\n", (long long)addr);
281 err = mtd_read(mtd, addr, pgsize, &read, pp4);
282 if (mtd_is_bitflip(err))
284 if (err || read != pgsize) {
285 printk(PRINT_PREF "error: read failed at %#llx\n",
291 /* pp2 and pp4 should be the same */
292 printk(PRINT_PREF "verifying pages read at %#llx match\n",
294 if (memcmp(pp2, pp4, pgsize)) {
295 printk(PRINT_PREF "verify failed!\n");
298 printk(PRINT_PREF "crosstest ok\n");
303 static int erasecrosstest(void)
305 size_t read, written;
306 int err = 0, i, ebnum, ebnum2;
308 char *readbuf = twopages;
310 printk(PRINT_PREF "erasecrosstest\n");
314 for (i = 0; i < ebcnt && bbt[i]; ++i) {
315 addr0 += mtd->erasesize;
320 while (ebnum2 && bbt[ebnum2])
323 printk(PRINT_PREF "erasing block %d\n", ebnum);
324 err = erase_eraseblock(ebnum);
328 printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
329 set_random_data(writebuf, pgsize);
330 strcpy(writebuf, "There is no data like this!");
331 err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
332 if (err || written != pgsize) {
333 printk(PRINT_PREF "error: write failed at %#llx\n",
335 return err ? err : -1;
338 printk(PRINT_PREF "reading 1st page of block %d\n", ebnum);
339 memset(readbuf, 0, pgsize);
340 err = mtd_read(mtd, addr0, pgsize, &read, readbuf);
341 if (mtd_is_bitflip(err))
343 if (err || read != pgsize) {
344 printk(PRINT_PREF "error: read failed at %#llx\n",
346 return err ? err : -1;
349 printk(PRINT_PREF "verifying 1st page of block %d\n", ebnum);
350 if (memcmp(writebuf, readbuf, pgsize)) {
351 printk(PRINT_PREF "verify failed!\n");
356 printk(PRINT_PREF "erasing block %d\n", ebnum);
357 err = erase_eraseblock(ebnum);
361 printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
362 set_random_data(writebuf, pgsize);
363 strcpy(writebuf, "There is no data like this!");
364 err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
365 if (err || written != pgsize) {
366 printk(PRINT_PREF "error: write failed at %#llx\n",
368 return err ? err : -1;
371 printk(PRINT_PREF "erasing block %d\n", ebnum2);
372 err = erase_eraseblock(ebnum2);
376 printk(PRINT_PREF "reading 1st page of block %d\n", ebnum);
377 memset(readbuf, 0, pgsize);
378 err = mtd_read(mtd, addr0, pgsize, &read, readbuf);
379 if (mtd_is_bitflip(err))
381 if (err || read != pgsize) {
382 printk(PRINT_PREF "error: read failed at %#llx\n",
384 return err ? err : -1;
387 printk(PRINT_PREF "verifying 1st page of block %d\n", ebnum);
388 if (memcmp(writebuf, readbuf, pgsize)) {
389 printk(PRINT_PREF "verify failed!\n");
395 printk(PRINT_PREF "erasecrosstest ok\n");
399 static int erasetest(void)
401 size_t read, written;
402 int err = 0, i, ebnum, ok = 1;
405 printk(PRINT_PREF "erasetest\n");
409 for (i = 0; i < ebcnt && bbt[i]; ++i) {
410 addr0 += mtd->erasesize;
414 printk(PRINT_PREF "erasing block %d\n", ebnum);
415 err = erase_eraseblock(ebnum);
419 printk(PRINT_PREF "writing 1st page of block %d\n", ebnum);
420 set_random_data(writebuf, pgsize);
421 err = mtd_write(mtd, addr0, pgsize, &written, writebuf);
422 if (err || written != pgsize) {
423 printk(PRINT_PREF "error: write failed at %#llx\n",
425 return err ? err : -1;
428 printk(PRINT_PREF "erasing block %d\n", ebnum);
429 err = erase_eraseblock(ebnum);
433 printk(PRINT_PREF "reading 1st page of block %d\n", ebnum);
434 err = mtd_read(mtd, addr0, pgsize, &read, twopages);
435 if (mtd_is_bitflip(err))
437 if (err || read != pgsize) {
438 printk(PRINT_PREF "error: read failed at %#llx\n",
440 return err ? err : -1;
443 printk(PRINT_PREF "verifying 1st page of block %d is all 0xff\n",
445 for (i = 0; i < pgsize; ++i)
446 if (twopages[i] != 0xff) {
447 printk(PRINT_PREF "verifying all 0xff failed at %d\n",
455 printk(PRINT_PREF "erasetest ok\n");
460 static int is_block_bad(int ebnum)
462 loff_t addr = ebnum * mtd->erasesize;
465 ret = mtd_block_isbad(mtd, addr);
467 printk(PRINT_PREF "block %d is bad\n", ebnum);
471 static int scan_for_bad_eraseblocks(void)
475 bbt = kzalloc(ebcnt, GFP_KERNEL);
477 printk(PRINT_PREF "error: cannot allocate memory\n");
481 printk(PRINT_PREF "scanning for bad eraseblocks\n");
482 for (i = 0; i < ebcnt; ++i) {
483 bbt[i] = is_block_bad(i) ? 1 : 0;
488 printk(PRINT_PREF "scanned %d eraseblocks, %d are bad\n", i, bad);
492 static int __init mtd_pagetest_init(void)
498 printk(KERN_INFO "\n");
499 printk(KERN_INFO "=================================================\n");
502 printk(PRINT_PREF "Please specify a valid mtd-device via module paramter\n");
503 printk(KERN_CRIT "CAREFUL: This test wipes all data on the specified MTD device!\n");
507 printk(PRINT_PREF "MTD device: %d\n", dev);
509 mtd = get_mtd_device(NULL, dev);
512 printk(PRINT_PREF "error: cannot get MTD device\n");
516 if (mtd->type != MTD_NANDFLASH) {
517 printk(PRINT_PREF "this test requires NAND flash\n");
522 do_div(tmp, mtd->erasesize);
524 pgcnt = mtd->erasesize / mtd->writesize;
525 pgsize = mtd->writesize;
527 printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
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);
534 bufsize = pgsize * 2;
535 writebuf = kmalloc(mtd->erasesize, GFP_KERNEL);
537 printk(PRINT_PREF "error: cannot allocate memory\n");
540 twopages = kmalloc(bufsize, GFP_KERNEL);
542 printk(PRINT_PREF "error: cannot allocate memory\n");
545 boundary = kmalloc(bufsize, GFP_KERNEL);
547 printk(PRINT_PREF "error: cannot allocate memory\n");
551 err = scan_for_bad_eraseblocks();
555 /* Erase all eraseblocks */
556 printk(PRINT_PREF "erasing whole device\n");
557 for (i = 0; i < ebcnt; ++i) {
560 err = erase_eraseblock(i);
565 printk(PRINT_PREF "erased %u eraseblocks\n", i);
567 /* Write all eraseblocks */
569 printk(PRINT_PREF "writing whole device\n");
570 for (i = 0; i < ebcnt; ++i) {
573 err = write_eraseblock(i);
577 printk(PRINT_PREF "written up to eraseblock %u\n", i);
580 printk(PRINT_PREF "written %u eraseblocks\n", i);
582 /* Check all eraseblocks */
584 printk(PRINT_PREF "verifying all eraseblocks\n");
585 for (i = 0; i < ebcnt; ++i) {
588 err = verify_eraseblock(i);
592 printk(PRINT_PREF "verified up to eraseblock %u\n", i);
595 printk(PRINT_PREF "verified %u eraseblocks\n", i);
601 err = erasecrosstest();
609 printk(PRINT_PREF "finished with %d errors\n", errcnt);
618 printk(PRINT_PREF "error %d occurred\n", err);
619 printk(KERN_INFO "=================================================\n");
622 module_init(mtd_pagetest_init);
624 static void __exit mtd_pagetest_exit(void)
628 module_exit(mtd_pagetest_exit);
630 MODULE_DESCRIPTION("NAND page test");
631 MODULE_AUTHOR("Adrian Hunter");
632 MODULE_LICENSE("GPL");