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");