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>
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 pr_err("error %d while erasing EB %d\n", err, ebnum);
86 if (ei.state == MTD_ERASE_FAILED) {
87 pr_err("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 pr_err("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 pr_err("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 pr_err("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 pr_err("error: read failed at %#llx\n",
155 if (memcmp(twopages, writebuf + (j * pgsize), bufsize)) {
156 pr_err("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 pr_err("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 pr_err("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 pr_err("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 pr_err("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 pr_info("crosstest\n");
210 pp1 = kmalloc(pgsize * 4, GFP_KERNEL);
212 pr_err("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 pr_err("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 pr_err("error: read failed at %#llx\n",
252 /* Read first page to pp2 */
254 pr_info("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 pr_err("error: read failed at %#llx\n",
265 /* Read last page to pp3 */
266 addr = addrn - pgsize;
267 pr_info("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 pr_err("error: read failed at %#llx\n",
278 /* Read first page again to pp4 */
280 pr_info("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 pr_err("error: read failed at %#llx\n",
291 /* pp2 and pp4 should be the same */
292 pr_info("verifying pages read at %#llx match\n",
294 if (memcmp(pp2, pp4, pgsize)) {
295 pr_err("verify failed!\n");
298 pr_info("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 pr_info("erasecrosstest\n");
314 for (i = 0; i < ebcnt && bbt[i]; ++i) {
315 addr0 += mtd->erasesize;
320 while (ebnum2 && bbt[ebnum2])
323 pr_info("erasing block %d\n", ebnum);
324 err = erase_eraseblock(ebnum);
328 pr_info("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 pr_info("error: write failed at %#llx\n",
335 return err ? err : -1;
338 pr_info("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 pr_err("error: read failed at %#llx\n",
346 return err ? err : -1;
349 pr_info("verifying 1st page of block %d\n", ebnum);
350 if (memcmp(writebuf, readbuf, pgsize)) {
351 pr_err("verify failed!\n");
356 pr_info("erasing block %d\n", ebnum);
357 err = erase_eraseblock(ebnum);
361 pr_info("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 pr_err("error: write failed at %#llx\n",
368 return err ? err : -1;
371 pr_info("erasing block %d\n", ebnum2);
372 err = erase_eraseblock(ebnum2);
376 pr_info("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 pr_err("error: read failed at %#llx\n",
384 return err ? err : -1;
387 pr_info("verifying 1st page of block %d\n", ebnum);
388 if (memcmp(writebuf, readbuf, pgsize)) {
389 pr_err("verify failed!\n");
395 pr_info("erasecrosstest ok\n");
399 static int erasetest(void)
401 size_t read, written;
402 int err = 0, i, ebnum, ok = 1;
405 pr_info("erasetest\n");
409 for (i = 0; i < ebcnt && bbt[i]; ++i) {
410 addr0 += mtd->erasesize;
414 pr_info("erasing block %d\n", ebnum);
415 err = erase_eraseblock(ebnum);
419 pr_info("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 pr_err("error: write failed at %#llx\n",
425 return err ? err : -1;
428 pr_info("erasing block %d\n", ebnum);
429 err = erase_eraseblock(ebnum);
433 pr_info("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 pr_err("error: read failed at %#llx\n",
440 return err ? err : -1;
443 pr_info("verifying 1st page of block %d is all 0xff\n",
445 for (i = 0; i < pgsize; ++i)
446 if (twopages[i] != 0xff) {
447 pr_err("verifying all 0xff failed at %d\n",
455 pr_info("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 pr_info("block %d is bad\n", ebnum);
471 static int scan_for_bad_eraseblocks(void)
475 bbt = kzalloc(ebcnt, GFP_KERNEL);
477 pr_err("error: cannot allocate memory\n");
481 pr_info("scanning for bad eraseblocks\n");
482 for (i = 0; i < ebcnt; ++i) {
483 bbt[i] = is_block_bad(i) ? 1 : 0;
488 pr_info("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 pr_info("Please specify a valid mtd-device via module parameter\n");
503 pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
507 pr_info("MTD device: %d\n", dev);
509 mtd = get_mtd_device(NULL, dev);
512 pr_err("error: cannot get MTD device\n");
516 if (mtd->type != MTD_NANDFLASH) {
517 pr_info("this test requires NAND flash\n");
522 do_div(tmp, mtd->erasesize);
524 pgcnt = mtd->erasesize / mtd->writesize;
525 pgsize = mtd->writesize;
527 pr_info("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 pr_err("error: cannot allocate memory\n");
540 twopages = kmalloc(bufsize, GFP_KERNEL);
542 pr_err("error: cannot allocate memory\n");
545 boundary = kmalloc(bufsize, GFP_KERNEL);
547 pr_err("error: cannot allocate memory\n");
551 err = scan_for_bad_eraseblocks();
555 /* Erase all eraseblocks */
556 pr_info("erasing whole device\n");
557 for (i = 0; i < ebcnt; ++i) {
560 err = erase_eraseblock(i);
565 pr_info("erased %u eraseblocks\n", i);
567 /* Write all eraseblocks */
569 pr_info("writing whole device\n");
570 for (i = 0; i < ebcnt; ++i) {
573 err = write_eraseblock(i);
577 pr_info("written up to eraseblock %u\n", i);
580 pr_info("written %u eraseblocks\n", i);
582 /* Check all eraseblocks */
584 pr_info("verifying all eraseblocks\n");
585 for (i = 0; i < ebcnt; ++i) {
588 err = verify_eraseblock(i);
592 pr_info("verified up to eraseblock %u\n", i);
595 pr_info("verified %u eraseblocks\n", i);
601 err = erasecrosstest();
609 pr_info("finished with %d errors\n", errcnt);
618 pr_info("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");