2 * Copyright (C) 2006-2007 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 sub-page read and write on MTD device.
18 * Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 #include <linux/init.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/err.h>
28 #include <linux/mtd/mtd.h>
29 #include <linux/slab.h>
30 #include <linux/sched.h>
31 #include <linux/random.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 *writebuf;
39 static unsigned char *readbuf;
40 static unsigned char *bbt;
47 static struct rnd_state rnd_state;
49 static inline void clear_data(unsigned char *buf, size_t len)
54 static int erase_eraseblock(int ebnum)
58 loff_t addr = ebnum * mtd->erasesize;
60 memset(&ei, 0, sizeof(struct erase_info));
63 ei.len = mtd->erasesize;
65 err = mtd_erase(mtd, &ei);
67 pr_err("error %d while erasing EB %d\n", err, ebnum);
71 if (ei.state == MTD_ERASE_FAILED) {
72 pr_err("some erase error occurred at EB %d\n",
80 static int erase_whole_device(void)
85 pr_info("erasing whole device\n");
86 for (i = 0; i < ebcnt; ++i) {
89 err = erase_eraseblock(i);
94 pr_info("erased %u eraseblocks\n", i);
98 static int write_eraseblock(int ebnum)
102 loff_t addr = ebnum * mtd->erasesize;
104 prandom_bytes_state(&rnd_state, writebuf, subpgsize);
105 err = mtd_write(mtd, addr, subpgsize, &written, writebuf);
106 if (unlikely(err || written != subpgsize)) {
107 pr_err("error: write failed at %#llx\n",
109 if (written != subpgsize) {
110 pr_err(" write size: %#x\n", subpgsize);
111 pr_err(" written: %#zx\n", written);
113 return err ? err : -1;
118 prandom_bytes_state(&rnd_state, writebuf, subpgsize);
119 err = mtd_write(mtd, addr, subpgsize, &written, writebuf);
120 if (unlikely(err || written != subpgsize)) {
121 pr_err("error: write failed at %#llx\n",
123 if (written != subpgsize) {
124 pr_err(" write size: %#x\n", subpgsize);
125 pr_err(" written: %#zx\n", written);
127 return err ? err : -1;
133 static int write_eraseblock2(int ebnum)
137 loff_t addr = ebnum * mtd->erasesize;
139 for (k = 1; k < 33; ++k) {
140 if (addr + (subpgsize * k) > (ebnum + 1) * mtd->erasesize)
142 prandom_bytes_state(&rnd_state, writebuf, subpgsize * k);
143 err = mtd_write(mtd, addr, subpgsize * k, &written, writebuf);
144 if (unlikely(err || written != subpgsize * k)) {
145 pr_err("error: write failed at %#llx\n",
147 if (written != subpgsize) {
148 pr_err(" write size: %#x\n",
150 pr_err(" written: %#08zx\n",
153 return err ? err : -1;
155 addr += subpgsize * k;
161 static void print_subpage(unsigned char *p)
165 for (i = 0; i < subpgsize; ) {
166 for (j = 0; i < subpgsize && j < 32; ++i, ++j)
167 printk("%02x", *p++);
172 static int verify_eraseblock(int ebnum)
176 loff_t addr = ebnum * mtd->erasesize;
178 prandom_bytes_state(&rnd_state, writebuf, subpgsize);
179 clear_data(readbuf, subpgsize);
180 err = mtd_read(mtd, addr, subpgsize, &read, readbuf);
181 if (unlikely(err || read != subpgsize)) {
182 if (mtd_is_bitflip(err) && read == subpgsize) {
183 pr_info("ECC correction at %#llx\n",
187 pr_err("error: read failed at %#llx\n",
189 return err ? err : -1;
192 if (unlikely(memcmp(readbuf, writebuf, subpgsize))) {
193 pr_err("error: verify failed at %#llx\n",
195 pr_info("------------- written----------------\n");
196 print_subpage(writebuf);
197 pr_info("------------- read ------------------\n");
198 print_subpage(readbuf);
199 pr_info("-------------------------------------\n");
205 prandom_bytes_state(&rnd_state, writebuf, subpgsize);
206 clear_data(readbuf, subpgsize);
207 err = mtd_read(mtd, addr, subpgsize, &read, readbuf);
208 if (unlikely(err || read != subpgsize)) {
209 if (mtd_is_bitflip(err) && read == subpgsize) {
210 pr_info("ECC correction at %#llx\n",
214 pr_err("error: read failed at %#llx\n",
216 return err ? err : -1;
219 if (unlikely(memcmp(readbuf, writebuf, subpgsize))) {
220 pr_info("error: verify failed at %#llx\n",
222 pr_info("------------- written----------------\n");
223 print_subpage(writebuf);
224 pr_info("------------- read ------------------\n");
225 print_subpage(readbuf);
226 pr_info("-------------------------------------\n");
233 static int verify_eraseblock2(int ebnum)
237 loff_t addr = ebnum * mtd->erasesize;
239 for (k = 1; k < 33; ++k) {
240 if (addr + (subpgsize * k) > (ebnum + 1) * mtd->erasesize)
242 prandom_bytes_state(&rnd_state, writebuf, subpgsize * k);
243 clear_data(readbuf, subpgsize * k);
244 err = mtd_read(mtd, addr, subpgsize * k, &read, readbuf);
245 if (unlikely(err || read != subpgsize * k)) {
246 if (mtd_is_bitflip(err) && read == subpgsize * k) {
247 pr_info("ECC correction at %#llx\n",
251 pr_err("error: read failed at "
252 "%#llx\n", (long long)addr);
253 return err ? err : -1;
256 if (unlikely(memcmp(readbuf, writebuf, subpgsize * k))) {
257 pr_err("error: verify failed at %#llx\n",
261 addr += subpgsize * k;
267 static int verify_eraseblock_ff(int ebnum)
272 loff_t addr = ebnum * mtd->erasesize;
274 memset(writebuf, 0xff, subpgsize);
275 for (j = 0; j < mtd->erasesize / subpgsize; ++j) {
276 clear_data(readbuf, subpgsize);
277 err = mtd_read(mtd, addr, subpgsize, &read, readbuf);
278 if (unlikely(err || read != subpgsize)) {
279 if (mtd_is_bitflip(err) && read == subpgsize) {
280 pr_info("ECC correction at %#llx\n",
284 pr_err("error: read failed at "
285 "%#llx\n", (long long)addr);
286 return err ? err : -1;
289 if (unlikely(memcmp(readbuf, writebuf, subpgsize))) {
290 pr_err("error: verify 0xff failed at "
291 "%#llx\n", (long long)addr);
300 static int verify_all_eraseblocks_ff(void)
305 pr_info("verifying all eraseblocks for 0xff\n");
306 for (i = 0; i < ebcnt; ++i) {
309 err = verify_eraseblock_ff(i);
313 pr_info("verified up to eraseblock %u\n", i);
316 pr_info("verified %u eraseblocks\n", i);
320 static int is_block_bad(int ebnum)
322 loff_t addr = ebnum * mtd->erasesize;
325 ret = mtd_block_isbad(mtd, addr);
327 pr_info("block %d is bad\n", ebnum);
331 static int scan_for_bad_eraseblocks(void)
335 bbt = kzalloc(ebcnt, GFP_KERNEL);
339 pr_info("scanning for bad eraseblocks\n");
340 for (i = 0; i < ebcnt; ++i) {
341 bbt[i] = is_block_bad(i) ? 1 : 0;
346 pr_info("scanned %d eraseblocks, %d are bad\n", i, bad);
350 static int __init mtd_subpagetest_init(void)
356 printk(KERN_INFO "\n");
357 printk(KERN_INFO "=================================================\n");
360 pr_info("Please specify a valid mtd-device via module parameter\n");
361 pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
365 pr_info("MTD device: %d\n", dev);
367 mtd = get_mtd_device(NULL, dev);
370 pr_err("error: cannot get MTD device\n");
374 if (mtd->type != MTD_NANDFLASH) {
375 pr_info("this test requires NAND flash\n");
379 subpgsize = mtd->writesize >> mtd->subpage_sft;
381 do_div(tmp, mtd->erasesize);
383 pgcnt = mtd->erasesize / mtd->writesize;
385 pr_info("MTD device size %llu, eraseblock size %u, "
386 "page size %u, subpage size %u, count of eraseblocks %u, "
387 "pages per eraseblock %u, OOB size %u\n",
388 (unsigned long long)mtd->size, mtd->erasesize,
389 mtd->writesize, subpgsize, ebcnt, pgcnt, mtd->oobsize);
392 bufsize = subpgsize * 32;
393 writebuf = kmalloc(bufsize, GFP_KERNEL);
396 readbuf = kmalloc(bufsize, GFP_KERNEL);
400 err = scan_for_bad_eraseblocks();
404 err = erase_whole_device();
408 pr_info("writing whole device\n");
409 prandom_seed_state(&rnd_state, 1);
410 for (i = 0; i < ebcnt; ++i) {
413 err = write_eraseblock(i);
417 pr_info("written up to eraseblock %u\n", i);
420 pr_info("written %u eraseblocks\n", i);
422 prandom_seed_state(&rnd_state, 1);
423 pr_info("verifying all eraseblocks\n");
424 for (i = 0; i < ebcnt; ++i) {
427 err = verify_eraseblock(i);
431 pr_info("verified up to eraseblock %u\n", i);
434 pr_info("verified %u eraseblocks\n", i);
436 err = erase_whole_device();
440 err = verify_all_eraseblocks_ff();
444 /* Write all eraseblocks */
445 prandom_seed_state(&rnd_state, 3);
446 pr_info("writing whole device\n");
447 for (i = 0; i < ebcnt; ++i) {
450 err = write_eraseblock2(i);
454 pr_info("written up to eraseblock %u\n", i);
457 pr_info("written %u eraseblocks\n", i);
459 /* Check all eraseblocks */
460 prandom_seed_state(&rnd_state, 3);
461 pr_info("verifying all eraseblocks\n");
462 for (i = 0; i < ebcnt; ++i) {
465 err = verify_eraseblock2(i);
469 pr_info("verified up to eraseblock %u\n", i);
472 pr_info("verified %u eraseblocks\n", i);
474 err = erase_whole_device();
478 err = verify_all_eraseblocks_ff();
482 pr_info("finished with %d errors\n", errcnt);
490 pr_info("error %d occurred\n", err);
491 printk(KERN_INFO "=================================================\n");
494 module_init(mtd_subpagetest_init);
496 static void __exit mtd_subpagetest_exit(void)
500 module_exit(mtd_subpagetest_exit);
502 MODULE_DESCRIPTION("Subpage test module");
503 MODULE_AUTHOR("Adrian Hunter");
504 MODULE_LICENSE("GPL");