MTD: tests: add mtd_readtest
[linux-2.6.git] / drivers / mtd / tests / mtd_oobtest.c
1 /*
2  * Copyright (C) 2006-2008 Nokia Corporation
3  *
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.
7  *
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
11  * more details.
12  *
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.
16  *
17  * Test OOB read and write on MTD device.
18  *
19  * Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
20  */
21
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/sched.h>
29
30 #define PRINT_PREF KERN_INFO "mtd_oobtest: "
31
32 static int dev;
33 module_param(dev, int, S_IRUGO);
34 MODULE_PARM_DESC(dev, "MTD device number to use");
35
36 static struct mtd_info *mtd;
37 static unsigned char *readbuf;
38 static unsigned char *writebuf;
39 static unsigned char *bbt;
40
41 static int ebcnt;
42 static int pgcnt;
43 static int errcnt;
44 static int use_offset;
45 static int use_len;
46 static int use_len_max;
47 static int vary_offset;
48 static unsigned long next = 1;
49
50 static inline unsigned int simple_rand(void)
51 {
52         next = next * 1103515245 + 12345;
53         return (unsigned int)((next / 65536) % 32768);
54 }
55
56 static inline void simple_srand(unsigned long seed)
57 {
58         next = seed;
59 }
60
61 static void set_random_data(unsigned char *buf, size_t len)
62 {
63         size_t i;
64
65         for (i = 0; i < len; ++i)
66                 buf[i] = simple_rand();
67 }
68
69 static int erase_eraseblock(int ebnum)
70 {
71         int err;
72         struct erase_info ei;
73         loff_t addr = ebnum * mtd->erasesize;
74
75         memset(&ei, 0, sizeof(struct erase_info));
76         ei.mtd  = mtd;
77         ei.addr = addr;
78         ei.len  = mtd->erasesize;
79
80         err = mtd->erase(mtd, &ei);
81         if (err) {
82                 printk(PRINT_PREF "error %d while erasing EB %d\n", err, ebnum);
83                 return err;
84         }
85
86         if (ei.state == MTD_ERASE_FAILED) {
87                 printk(PRINT_PREF "some erase error occurred at EB %d\n",
88                        ebnum);
89                 return -EIO;
90         }
91
92         return 0;
93 }
94
95 static int erase_whole_device(void)
96 {
97         int err;
98         unsigned int i;
99
100         printk(PRINT_PREF "erasing whole device\n");
101         for (i = 0; i < ebcnt; ++i) {
102                 if (bbt[i])
103                         continue;
104                 err = erase_eraseblock(i);
105                 if (err)
106                         return err;
107                 cond_resched();
108         }
109         printk(PRINT_PREF "erased %u eraseblocks\n", i);
110         return 0;
111 }
112
113 static void do_vary_offset(void)
114 {
115         use_len -= 1;
116         if (use_len < 1) {
117                 use_offset += 1;
118                 if (use_offset >= use_len_max)
119                         use_offset = 0;
120                 use_len = use_len_max - use_offset;
121         }
122 }
123
124 static int write_eraseblock(int ebnum)
125 {
126         int i;
127         struct mtd_oob_ops ops;
128         int err = 0;
129         loff_t addr = ebnum * mtd->erasesize;
130
131         for (i = 0; i < pgcnt; ++i, addr += mtd->writesize) {
132                 set_random_data(writebuf, use_len);
133                 ops.mode      = MTD_OOB_AUTO;
134                 ops.len       = 0;
135                 ops.retlen    = 0;
136                 ops.ooblen    = use_len;
137                 ops.oobretlen = 0;
138                 ops.ooboffs   = use_offset;
139                 ops.datbuf    = 0;
140                 ops.oobbuf    = writebuf;
141                 err = mtd->write_oob(mtd, addr, &ops);
142                 if (err || ops.oobretlen != use_len) {
143                         printk(PRINT_PREF "error: writeoob failed at %#llx\n",
144                                (long long)addr);
145                         printk(PRINT_PREF "error: use_len %d, use_offset %d\n",
146                                use_len, use_offset);
147                         errcnt += 1;
148                         return err ? err : -1;
149                 }
150                 if (vary_offset)
151                         do_vary_offset();
152         }
153
154         return err;
155 }
156
157 static int write_whole_device(void)
158 {
159         int err;
160         unsigned int i;
161
162         printk(PRINT_PREF "writing OOBs of whole device\n");
163         for (i = 0; i < ebcnt; ++i) {
164                 if (bbt[i])
165                         continue;
166                 err = write_eraseblock(i);
167                 if (err)
168                         return err;
169                 if (i % 256 == 0)
170                         printk(PRINT_PREF "written up to eraseblock %u\n", i);
171                 cond_resched();
172         }
173         printk(PRINT_PREF "written %u eraseblocks\n", i);
174         return 0;
175 }
176
177 static int verify_eraseblock(int ebnum)
178 {
179         int i;
180         struct mtd_oob_ops ops;
181         int err = 0;
182         loff_t addr = ebnum * mtd->erasesize;
183
184         for (i = 0; i < pgcnt; ++i, addr += mtd->writesize) {
185                 set_random_data(writebuf, use_len);
186                 ops.mode      = MTD_OOB_AUTO;
187                 ops.len       = 0;
188                 ops.retlen    = 0;
189                 ops.ooblen    = use_len;
190                 ops.oobretlen = 0;
191                 ops.ooboffs   = use_offset;
192                 ops.datbuf    = 0;
193                 ops.oobbuf    = readbuf;
194                 err = mtd->read_oob(mtd, addr, &ops);
195                 if (err || ops.oobretlen != use_len) {
196                         printk(PRINT_PREF "error: readoob failed at %#llx\n",
197                                (long long)addr);
198                         errcnt += 1;
199                         return err ? err : -1;
200                 }
201                 if (memcmp(readbuf, writebuf, use_len)) {
202                         printk(PRINT_PREF "error: verify failed at %#llx\n",
203                                (long long)addr);
204                         errcnt += 1;
205                         if (errcnt > 1000) {
206                                 printk(PRINT_PREF "error: too many errors\n");
207                                 return -1;
208                         }
209                 }
210                 if (use_offset != 0 || use_len < mtd->ecclayout->oobavail) {
211                         int k;
212
213                         ops.mode      = MTD_OOB_AUTO;
214                         ops.len       = 0;
215                         ops.retlen    = 0;
216                         ops.ooblen    = mtd->ecclayout->oobavail;
217                         ops.oobretlen = 0;
218                         ops.ooboffs   = 0;
219                         ops.datbuf    = 0;
220                         ops.oobbuf    = readbuf;
221                         err = mtd->read_oob(mtd, addr, &ops);
222                         if (err || ops.oobretlen != mtd->ecclayout->oobavail) {
223                                 printk(PRINT_PREF "error: readoob failed at "
224                                        "%#llx\n", (long long)addr);
225                                 errcnt += 1;
226                                 return err ? err : -1;
227                         }
228                         if (memcmp(readbuf + use_offset, writebuf, use_len)) {
229                                 printk(PRINT_PREF "error: verify failed at "
230                                        "%#llx\n", (long long)addr);
231                                 errcnt += 1;
232                                 if (errcnt > 1000) {
233                                         printk(PRINT_PREF "error: too many "
234                                                "errors\n");
235                                         return -1;
236                                 }
237                         }
238                         for (k = 0; k < use_offset; ++k)
239                                 if (readbuf[k] != 0xff) {
240                                         printk(PRINT_PREF "error: verify 0xff "
241                                                "failed at %#llx\n",
242                                                (long long)addr);
243                                         errcnt += 1;
244                                         if (errcnt > 1000) {
245                                                 printk(PRINT_PREF "error: too "
246                                                        "many errors\n");
247                                                 return -1;
248                                         }
249                                 }
250                         for (k = use_offset + use_len;
251                              k < mtd->ecclayout->oobavail; ++k)
252                                 if (readbuf[k] != 0xff) {
253                                         printk(PRINT_PREF "error: verify 0xff "
254                                                "failed at %#llx\n",
255                                                (long long)addr);
256                                         errcnt += 1;
257                                         if (errcnt > 1000) {
258                                                 printk(PRINT_PREF "error: too "
259                                                        "many errors\n");
260                                                 return -1;
261                                         }
262                                 }
263                 }
264                 if (vary_offset)
265                         do_vary_offset();
266         }
267         return err;
268 }
269
270 static int verify_eraseblock_in_one_go(int ebnum)
271 {
272         struct mtd_oob_ops ops;
273         int err = 0;
274         loff_t addr = ebnum * mtd->erasesize;
275         size_t len = mtd->ecclayout->oobavail * pgcnt;
276
277         set_random_data(writebuf, len);
278         ops.mode      = MTD_OOB_AUTO;
279         ops.len       = 0;
280         ops.retlen    = 0;
281         ops.ooblen    = len;
282         ops.oobretlen = 0;
283         ops.ooboffs   = 0;
284         ops.datbuf    = 0;
285         ops.oobbuf    = readbuf;
286         err = mtd->read_oob(mtd, addr, &ops);
287         if (err || ops.oobretlen != len) {
288                 printk(PRINT_PREF "error: readoob failed at %#llx\n",
289                        (long long)addr);
290                 errcnt += 1;
291                 return err ? err : -1;
292         }
293         if (memcmp(readbuf, writebuf, len)) {
294                 printk(PRINT_PREF "error: verify failed at %#llx\n",
295                        (long long)addr);
296                 errcnt += 1;
297                 if (errcnt > 1000) {
298                         printk(PRINT_PREF "error: too many errors\n");
299                         return -1;
300                 }
301         }
302
303         return err;
304 }
305
306 static int verify_all_eraseblocks(void)
307 {
308         int err;
309         unsigned int i;
310
311         printk(PRINT_PREF "verifying all eraseblocks\n");
312         for (i = 0; i < ebcnt; ++i) {
313                 if (bbt[i])
314                         continue;
315                 err = verify_eraseblock(i);
316                 if (err)
317                         return err;
318                 if (i % 256 == 0)
319                         printk(PRINT_PREF "verified up to eraseblock %u\n", i);
320                 cond_resched();
321         }
322         printk(PRINT_PREF "verified %u eraseblocks\n", i);
323         return 0;
324 }
325
326 static int is_block_bad(int ebnum)
327 {
328         int ret;
329         loff_t addr = ebnum * mtd->erasesize;
330
331         ret = mtd->block_isbad(mtd, addr);
332         if (ret)
333                 printk(PRINT_PREF "block %d is bad\n", ebnum);
334         return ret;
335 }
336
337 static int scan_for_bad_eraseblocks(void)
338 {
339         int i, bad = 0;
340
341         bbt = kmalloc(ebcnt, GFP_KERNEL);
342         if (!bbt) {
343                 printk(PRINT_PREF "error: cannot allocate memory\n");
344                 return -ENOMEM;
345         }
346         memset(bbt, 0 , ebcnt);
347
348         printk(PRINT_PREF "scanning for bad eraseblocks\n");
349         for (i = 0; i < ebcnt; ++i) {
350                 bbt[i] = is_block_bad(i) ? 1 : 0;
351                 if (bbt[i])
352                         bad += 1;
353                 cond_resched();
354         }
355         printk(PRINT_PREF "scanned %d eraseblocks, %d are bad\n", i, bad);
356         return 0;
357 }
358
359 static int __init mtd_oobtest_init(void)
360 {
361         int err = 0;
362         unsigned int i;
363         uint64_t tmp;
364         struct mtd_oob_ops ops;
365         loff_t addr = 0, addr0;
366
367         printk(KERN_INFO "\n");
368         printk(KERN_INFO "=================================================\n");
369         printk(PRINT_PREF "MTD device: %d\n", dev);
370
371         mtd = get_mtd_device(NULL, dev);
372         if (IS_ERR(mtd)) {
373                 err = PTR_ERR(mtd);
374                 printk(PRINT_PREF "error: cannot get MTD device\n");
375                 return err;
376         }
377
378         if (mtd->type != MTD_NANDFLASH) {
379                 printk(PRINT_PREF "this test requires NAND flash\n");
380                 goto out;
381         }
382
383         tmp = mtd->size;
384         do_div(tmp, mtd->erasesize);
385         ebcnt = tmp;
386         pgcnt = mtd->erasesize / mtd->writesize;
387
388         printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
389                "page size %u, count of eraseblocks %u, pages per "
390                "eraseblock %u, OOB size %u\n",
391                (unsigned long long)mtd->size, mtd->erasesize,
392                mtd->writesize, ebcnt, pgcnt, mtd->oobsize);
393
394         err = -ENOMEM;
395         mtd->erasesize = mtd->erasesize;
396         readbuf = kmalloc(mtd->erasesize, GFP_KERNEL);
397         if (!readbuf) {
398                 printk(PRINT_PREF "error: cannot allocate memory\n");
399                 goto out;
400         }
401         writebuf = kmalloc(mtd->erasesize, GFP_KERNEL);
402         if (!writebuf) {
403                 printk(PRINT_PREF "error: cannot allocate memory\n");
404                 goto out;
405         }
406
407         err = scan_for_bad_eraseblocks();
408         if (err)
409                 goto out;
410
411         use_offset = 0;
412         use_len = mtd->ecclayout->oobavail;
413         use_len_max = mtd->ecclayout->oobavail;
414         vary_offset = 0;
415
416         /* First test: write all OOB, read it back and verify */
417         printk(PRINT_PREF "test 1 of 5\n");
418
419         err = erase_whole_device();
420         if (err)
421                 goto out;
422
423         simple_srand(1);
424         err = write_whole_device();
425         if (err)
426                 goto out;
427
428         simple_srand(1);
429         err = verify_all_eraseblocks();
430         if (err)
431                 goto out;
432
433         /*
434          * Second test: write all OOB, a block at a time, read it back and
435          * verify.
436          */
437         printk(PRINT_PREF "test 2 of 5\n");
438
439         err = erase_whole_device();
440         if (err)
441                 goto out;
442
443         simple_srand(3);
444         err = write_whole_device();
445         if (err)
446                 goto out;
447
448         /* Check all eraseblocks */
449         simple_srand(3);
450         printk(PRINT_PREF "verifying all eraseblocks\n");
451         for (i = 0; i < ebcnt; ++i) {
452                 if (bbt[i])
453                         continue;
454                 err = verify_eraseblock_in_one_go(i);
455                 if (err)
456                         goto out;
457                 if (i % 256 == 0)
458                         printk(PRINT_PREF "verified up to eraseblock %u\n", i);
459                 cond_resched();
460         }
461         printk(PRINT_PREF "verified %u eraseblocks\n", i);
462
463         /*
464          * Third test: write OOB at varying offsets and lengths, read it back
465          * and verify.
466          */
467         printk(PRINT_PREF "test 3 of 5\n");
468
469         err = erase_whole_device();
470         if (err)
471                 goto out;
472
473         /* Write all eraseblocks */
474         use_offset = 0;
475         use_len = mtd->ecclayout->oobavail;
476         use_len_max = mtd->ecclayout->oobavail;
477         vary_offset = 1;
478         simple_srand(5);
479         printk(PRINT_PREF "writing OOBs of whole device\n");
480         for (i = 0; i < ebcnt; ++i) {
481                 if (bbt[i])
482                         continue;
483                 err = write_eraseblock(i);
484                 if (err)
485                         goto out;
486                 if (i % 256 == 0)
487                         printk(PRINT_PREF "written up to eraseblock %u\n", i);
488                 cond_resched();
489         }
490         printk(PRINT_PREF "written %u eraseblocks\n", i);
491
492         /* Check all eraseblocks */
493         use_offset = 0;
494         use_len = mtd->ecclayout->oobavail;
495         use_len_max = mtd->ecclayout->oobavail;
496         vary_offset = 1;
497         simple_srand(5);
498         err = verify_all_eraseblocks();
499         if (err)
500                 goto out;
501
502         use_offset = 0;
503         use_len = mtd->ecclayout->oobavail;
504         use_len_max = mtd->ecclayout->oobavail;
505         vary_offset = 0;
506
507         /* Fourth test: try to write off end of device */
508         printk(PRINT_PREF "test 4 of 5\n");
509
510         err = erase_whole_device();
511         if (err)
512                 goto out;
513
514         addr0 = 0;
515         for (i = 0; bbt[i] && i < ebcnt; ++i)
516                 addr0 += mtd->erasesize;
517
518         /* Attempt to write off end of OOB */
519         ops.mode      = MTD_OOB_AUTO;
520         ops.len       = 0;
521         ops.retlen    = 0;
522         ops.ooblen    = 1;
523         ops.oobretlen = 0;
524         ops.ooboffs   = mtd->ecclayout->oobavail;
525         ops.datbuf    = 0;
526         ops.oobbuf    = writebuf;
527         printk(PRINT_PREF "attempting to start write past end of OOB\n");
528         printk(PRINT_PREF "an error is expected...\n");
529         err = mtd->write_oob(mtd, addr0, &ops);
530         if (err) {
531                 printk(PRINT_PREF "error occurred as expected\n");
532                 err = 0;
533         } else {
534                 printk(PRINT_PREF "error: can write past end of OOB\n");
535                 errcnt += 1;
536         }
537
538         /* Attempt to read off end of OOB */
539         ops.mode      = MTD_OOB_AUTO;
540         ops.len       = 0;
541         ops.retlen    = 0;
542         ops.ooblen    = 1;
543         ops.oobretlen = 0;
544         ops.ooboffs   = mtd->ecclayout->oobavail;
545         ops.datbuf    = 0;
546         ops.oobbuf    = readbuf;
547         printk(PRINT_PREF "attempting to start read past end of OOB\n");
548         printk(PRINT_PREF "an error is expected...\n");
549         err = mtd->read_oob(mtd, addr0, &ops);
550         if (err) {
551                 printk(PRINT_PREF "error occurred as expected\n");
552                 err = 0;
553         } else {
554                 printk(PRINT_PREF "error: can read past end of OOB\n");
555                 errcnt += 1;
556         }
557
558         if (bbt[ebcnt - 1])
559                 printk(PRINT_PREF "skipping end of device tests because last "
560                        "block is bad\n");
561         else {
562                 /* Attempt to write off end of device */
563                 ops.mode      = MTD_OOB_AUTO;
564                 ops.len       = 0;
565                 ops.retlen    = 0;
566                 ops.ooblen    = mtd->ecclayout->oobavail + 1;
567                 ops.oobretlen = 0;
568                 ops.ooboffs   = 0;
569                 ops.datbuf    = 0;
570                 ops.oobbuf    = writebuf;
571                 printk(PRINT_PREF "attempting to write past end of device\n");
572                 printk(PRINT_PREF "an error is expected...\n");
573                 err = mtd->write_oob(mtd, mtd->size - mtd->writesize, &ops);
574                 if (err) {
575                         printk(PRINT_PREF "error occurred as expected\n");
576                         err = 0;
577                 } else {
578                         printk(PRINT_PREF "error: wrote past end of device\n");
579                         errcnt += 1;
580                 }
581
582                 /* Attempt to read off end of device */
583                 ops.mode      = MTD_OOB_AUTO;
584                 ops.len       = 0;
585                 ops.retlen    = 0;
586                 ops.ooblen    = mtd->ecclayout->oobavail + 1;
587                 ops.oobretlen = 0;
588                 ops.ooboffs   = 0;
589                 ops.datbuf    = 0;
590                 ops.oobbuf    = readbuf;
591                 printk(PRINT_PREF "attempting to read past end of device\n");
592                 printk(PRINT_PREF "an error is expected...\n");
593                 err = mtd->read_oob(mtd, mtd->size - mtd->writesize, &ops);
594                 if (err) {
595                         printk(PRINT_PREF "error occurred as expected\n");
596                         err = 0;
597                 } else {
598                         printk(PRINT_PREF "error: read past end of device\n");
599                         errcnt += 1;
600                 }
601
602                 err = erase_eraseblock(ebcnt - 1);
603                 if (err)
604                         goto out;
605
606                 /* Attempt to write off end of device */
607                 ops.mode      = MTD_OOB_AUTO;
608                 ops.len       = 0;
609                 ops.retlen    = 0;
610                 ops.ooblen    = mtd->ecclayout->oobavail;
611                 ops.oobretlen = 0;
612                 ops.ooboffs   = 1;
613                 ops.datbuf    = 0;
614                 ops.oobbuf    = writebuf;
615                 printk(PRINT_PREF "attempting to write past end of device\n");
616                 printk(PRINT_PREF "an error is expected...\n");
617                 err = mtd->write_oob(mtd, mtd->size - mtd->writesize, &ops);
618                 if (err) {
619                         printk(PRINT_PREF "error occurred as expected\n");
620                         err = 0;
621                 } else {
622                         printk(PRINT_PREF "error: wrote past end of device\n");
623                         errcnt += 1;
624                 }
625
626                 /* Attempt to read off end of device */
627                 ops.mode      = MTD_OOB_AUTO;
628                 ops.len       = 0;
629                 ops.retlen    = 0;
630                 ops.ooblen    = mtd->ecclayout->oobavail;
631                 ops.oobretlen = 0;
632                 ops.ooboffs   = 1;
633                 ops.datbuf    = 0;
634                 ops.oobbuf    = readbuf;
635                 printk(PRINT_PREF "attempting to read past end of device\n");
636                 printk(PRINT_PREF "an error is expected...\n");
637                 err = mtd->read_oob(mtd, mtd->size - mtd->writesize, &ops);
638                 if (err) {
639                         printk(PRINT_PREF "error occurred as expected\n");
640                         err = 0;
641                 } else {
642                         printk(PRINT_PREF "error: read past end of device\n");
643                         errcnt += 1;
644                 }
645         }
646
647         /* Fifth test: write / read across block boundaries */
648         printk(PRINT_PREF "test 5 of 5\n");
649
650         /* Erase all eraseblocks */
651         err = erase_whole_device();
652         if (err)
653                 goto out;
654
655         /* Write all eraseblocks */
656         simple_srand(11);
657         printk(PRINT_PREF "writing OOBs of whole device\n");
658         for (i = 0; i < ebcnt - 1; ++i) {
659                 int cnt = 2;
660                 int pg;
661                 size_t sz = mtd->ecclayout->oobavail;
662                 if (bbt[i] || bbt[i + 1])
663                         continue;
664                 addr = (i + 1) * mtd->erasesize - mtd->writesize;
665                 for (pg = 0; pg < cnt; ++pg) {
666                         set_random_data(writebuf, sz);
667                         ops.mode      = MTD_OOB_AUTO;
668                         ops.len       = 0;
669                         ops.retlen    = 0;
670                         ops.ooblen    = sz;
671                         ops.oobretlen = 0;
672                         ops.ooboffs   = 0;
673                         ops.datbuf    = 0;
674                         ops.oobbuf    = writebuf;
675                         err = mtd->write_oob(mtd, addr, &ops);
676                         if (err)
677                                 goto out;
678                         if (i % 256 == 0)
679                                 printk(PRINT_PREF "written up to eraseblock "
680                                        "%u\n", i);
681                         cond_resched();
682                         addr += mtd->writesize;
683                 }
684         }
685         printk(PRINT_PREF "written %u eraseblocks\n", i);
686
687         /* Check all eraseblocks */
688         simple_srand(11);
689         printk(PRINT_PREF "verifying all eraseblocks\n");
690         for (i = 0; i < ebcnt - 1; ++i) {
691                 if (bbt[i] || bbt[i + 1])
692                         continue;
693                 set_random_data(writebuf, mtd->ecclayout->oobavail * 2);
694                 addr = (i + 1) * mtd->erasesize - mtd->writesize;
695                 ops.mode      = MTD_OOB_AUTO;
696                 ops.len       = 0;
697                 ops.retlen    = 0;
698                 ops.ooblen    = mtd->ecclayout->oobavail * 2;
699                 ops.oobretlen = 0;
700                 ops.ooboffs   = 0;
701                 ops.datbuf    = 0;
702                 ops.oobbuf    = readbuf;
703                 err = mtd->read_oob(mtd, addr, &ops);
704                 if (err)
705                         goto out;
706                 if (memcmp(readbuf, writebuf, mtd->ecclayout->oobavail * 2)) {
707                         printk(PRINT_PREF "error: verify failed at %#llx\n",
708                                (long long)addr);
709                         errcnt += 1;
710                         if (errcnt > 1000) {
711                                 printk(PRINT_PREF "error: too many errors\n");
712                                 goto out;
713                         }
714                 }
715                 if (i % 256 == 0)
716                         printk(PRINT_PREF "verified up to eraseblock %u\n", i);
717                 cond_resched();
718         }
719         printk(PRINT_PREF "verified %u eraseblocks\n", i);
720
721         printk(PRINT_PREF "finished with %d errors\n", errcnt);
722 out:
723         kfree(bbt);
724         kfree(writebuf);
725         kfree(readbuf);
726         put_mtd_device(mtd);
727         if (err)
728                 printk(PRINT_PREF "error %d occurred\n", err);
729         printk(KERN_INFO "=================================================\n");
730         return err;
731 }
732 module_init(mtd_oobtest_init);
733
734 static void __exit mtd_oobtest_exit(void)
735 {
736         return;
737 }
738 module_exit(mtd_oobtest_exit);
739
740 MODULE_DESCRIPTION("Out-of-band test module");
741 MODULE_AUTHOR("Adrian Hunter");
742 MODULE_LICENSE("GPL");