[MTD] [TESTS] Fix some size_t printk format warnings
[linux-2.6.git] / drivers / mtd / tests / mtd_subpagetest.c
1 /*
2  * Copyright (C) 2006-2007 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 sub-page read and write on MTD device.
18  * Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
19  *
20  */
21
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/err.h>
26 #include <linux/mtd/mtd.h>
27 #include <linux/sched.h>
28
29 #define PRINT_PREF KERN_INFO "mtd_subpagetest: "
30
31 static int dev;
32 module_param(dev, int, S_IRUGO);
33 MODULE_PARM_DESC(dev, "MTD device number to use");
34
35 static struct mtd_info *mtd;
36 static unsigned char *writebuf;
37 static unsigned char *readbuf;
38 static unsigned char *bbt;
39
40 static int subpgsize;
41 static int bufsize;
42 static int ebcnt;
43 static int pgcnt;
44 static int errcnt;
45 static unsigned long next = 1;
46
47 static inline unsigned int simple_rand(void)
48 {
49         next = next * 1103515245 + 12345;
50         return (unsigned int)((next / 65536) % 32768);
51 }
52
53 static inline void simple_srand(unsigned long seed)
54 {
55         next = seed;
56 }
57
58 static void set_random_data(unsigned char *buf, size_t len)
59 {
60         size_t i;
61
62         for (i = 0; i < len; ++i)
63                 buf[i] = simple_rand();
64 }
65
66 static inline void clear_data(unsigned char *buf, size_t len)
67 {
68         memset(buf, 0, len);
69 }
70
71 static int erase_eraseblock(int ebnum)
72 {
73         int err;
74         struct erase_info ei;
75         loff_t addr = ebnum * mtd->erasesize;
76
77         memset(&ei, 0, sizeof(struct erase_info));
78         ei.mtd  = mtd;
79         ei.addr = addr;
80         ei.len  = mtd->erasesize;
81
82         err = mtd->erase(mtd, &ei);
83         if (err) {
84                 printk(PRINT_PREF "error %d while erasing EB %d\n", err, ebnum);
85                 return err;
86         }
87
88         if (ei.state == MTD_ERASE_FAILED) {
89                 printk(PRINT_PREF "some erase error occurred at EB %d\n",
90                        ebnum);
91                 return -EIO;
92         }
93
94         return 0;
95 }
96
97 static int erase_whole_device(void)
98 {
99         int err;
100         unsigned int i;
101
102         printk(PRINT_PREF "erasing whole device\n");
103         for (i = 0; i < ebcnt; ++i) {
104                 if (bbt[i])
105                         continue;
106                 err = erase_eraseblock(i);
107                 if (err)
108                         return err;
109                 cond_resched();
110         }
111         printk(PRINT_PREF "erased %u eraseblocks\n", i);
112         return 0;
113 }
114
115 static int write_eraseblock(int ebnum)
116 {
117         size_t written = 0;
118         int err = 0;
119         loff_t addr = ebnum * mtd->erasesize;
120
121         set_random_data(writebuf, subpgsize);
122         err = mtd->write(mtd, addr, subpgsize, &written, writebuf);
123         if (unlikely(err || written != subpgsize)) {
124                 printk(PRINT_PREF "error: write failed at %#llx\n",
125                        (long long)addr);
126                 if (written != subpgsize) {
127                         printk(PRINT_PREF "  write size: %#x\n", subpgsize);
128                         printk(PRINT_PREF "  written: %#zx\n", written);
129                 }
130                 return err ? err : -1;
131         }
132
133         addr += subpgsize;
134
135         set_random_data(writebuf, subpgsize);
136         err = mtd->write(mtd, addr, subpgsize, &written, writebuf);
137         if (unlikely(err || written != subpgsize)) {
138                 printk(PRINT_PREF "error: write failed at %#llx\n",
139                        (long long)addr);
140                 if (written != subpgsize) {
141                         printk(PRINT_PREF "  write size: %#x\n", subpgsize);
142                         printk(PRINT_PREF "  written: %#zx\n", written);
143                 }
144                 return err ? err : -1;
145         }
146
147         return err;
148 }
149
150 static int write_eraseblock2(int ebnum)
151 {
152         size_t written = 0;
153         int err = 0, k;
154         loff_t addr = ebnum * mtd->erasesize;
155
156         for (k = 1; k < 33; ++k) {
157                 if (addr + (subpgsize * k) > (ebnum + 1) * mtd->erasesize)
158                         break;
159                 set_random_data(writebuf, subpgsize * k);
160                 err = mtd->write(mtd, addr, subpgsize * k, &written, writebuf);
161                 if (unlikely(err || written != subpgsize * k)) {
162                         printk(PRINT_PREF "error: write failed at %#llx\n",
163                                (long long)addr);
164                         if (written != subpgsize) {
165                                 printk(PRINT_PREF "  write size: %#x\n",
166                                        subpgsize * k);
167                                 printk(PRINT_PREF "  written: %#08zx\n",
168                                        written);
169                         }
170                         return err ? err : -1;
171                 }
172                 addr += subpgsize * k;
173         }
174
175         return err;
176 }
177
178 static void print_subpage(unsigned char *p)
179 {
180         int i, j;
181
182         for (i = 0; i < subpgsize; ) {
183                 for (j = 0; i < subpgsize && j < 32; ++i, ++j)
184                         printk("%02x", *p++);
185                 printk("\n");
186         }
187 }
188
189 static int verify_eraseblock(int ebnum)
190 {
191         size_t read = 0;
192         int err = 0;
193         loff_t addr = ebnum * mtd->erasesize;
194
195         set_random_data(writebuf, subpgsize);
196         clear_data(readbuf, subpgsize);
197         read = 0;
198         err = mtd->read(mtd, addr, subpgsize, &read, readbuf);
199         if (unlikely(err || read != subpgsize)) {
200                 if (err == -EUCLEAN && read == subpgsize) {
201                         printk(PRINT_PREF "ECC correction at %#llx\n",
202                                (long long)addr);
203                         err = 0;
204                 } else {
205                         printk(PRINT_PREF "error: read failed at %#llx\n",
206                                (long long)addr);
207                         return err ? err : -1;
208                 }
209         }
210         if (unlikely(memcmp(readbuf, writebuf, subpgsize))) {
211                 printk(PRINT_PREF "error: verify failed at %#llx\n",
212                        (long long)addr);
213                 printk(PRINT_PREF "------------- written----------------\n");
214                 print_subpage(writebuf);
215                 printk(PRINT_PREF "------------- read ------------------\n");
216                 print_subpage(readbuf);
217                 printk(PRINT_PREF "-------------------------------------\n");
218                 errcnt += 1;
219         }
220
221         addr += subpgsize;
222
223         set_random_data(writebuf, subpgsize);
224         clear_data(readbuf, subpgsize);
225         read = 0;
226         err = mtd->read(mtd, addr, subpgsize, &read, readbuf);
227         if (unlikely(err || read != subpgsize)) {
228                 if (err == -EUCLEAN && read == subpgsize) {
229                         printk(PRINT_PREF "ECC correction at %#llx\n",
230                                (long long)addr);
231                         err = 0;
232                 } else {
233                         printk(PRINT_PREF "error: read failed at %#llx\n",
234                                (long long)addr);
235                         return err ? err : -1;
236                 }
237         }
238         if (unlikely(memcmp(readbuf, writebuf, subpgsize))) {
239                 printk(PRINT_PREF "error: verify failed at %#llx\n",
240                        (long long)addr);
241                 printk(PRINT_PREF "------------- written----------------\n");
242                 print_subpage(writebuf);
243                 printk(PRINT_PREF "------------- read ------------------\n");
244                 print_subpage(readbuf);
245                 printk(PRINT_PREF "-------------------------------------\n");
246                 errcnt += 1;
247         }
248
249         return err;
250 }
251
252 static int verify_eraseblock2(int ebnum)
253 {
254         size_t read = 0;
255         int err = 0, k;
256         loff_t addr = ebnum * mtd->erasesize;
257
258         for (k = 1; k < 33; ++k) {
259                 if (addr + (subpgsize * k) > (ebnum + 1) * mtd->erasesize)
260                         break;
261                 set_random_data(writebuf, subpgsize * k);
262                 clear_data(readbuf, subpgsize * k);
263                 read = 0;
264                 err = mtd->read(mtd, addr, subpgsize * k, &read, readbuf);
265                 if (unlikely(err || read != subpgsize * k)) {
266                         if (err == -EUCLEAN && read == subpgsize * k) {
267                                 printk(PRINT_PREF "ECC correction at %#llx\n",
268                                        (long long)addr);
269                                 err = 0;
270                         } else {
271                                 printk(PRINT_PREF "error: read failed at "
272                                        "%#llx\n", (long long)addr);
273                                 return err ? err : -1;
274                         }
275                 }
276                 if (unlikely(memcmp(readbuf, writebuf, subpgsize * k))) {
277                         printk(PRINT_PREF "error: verify failed at %#llx\n",
278                                (long long)addr);
279                         errcnt += 1;
280                 }
281                 addr += subpgsize * k;
282         }
283
284         return err;
285 }
286
287 static int verify_eraseblock_ff(int ebnum)
288 {
289         uint32_t j;
290         size_t read = 0;
291         int err = 0;
292         loff_t addr = ebnum * mtd->erasesize;
293
294         memset(writebuf, 0xff, subpgsize);
295         for (j = 0; j < mtd->erasesize / subpgsize; ++j) {
296                 clear_data(readbuf, subpgsize);
297                 read = 0;
298                 err = mtd->read(mtd, addr, subpgsize, &read, readbuf);
299                 if (unlikely(err || read != subpgsize)) {
300                         if (err == -EUCLEAN && read == subpgsize) {
301                                 printk(PRINT_PREF "ECC correction at %#llx\n",
302                                        (long long)addr);
303                                 err = 0;
304                         } else {
305                                 printk(PRINT_PREF "error: read failed at "
306                                        "%#llx\n", (long long)addr);
307                                 return err ? err : -1;
308                         }
309                 }
310                 if (unlikely(memcmp(readbuf, writebuf, subpgsize))) {
311                         printk(PRINT_PREF "error: verify 0xff failed at "
312                                "%#llx\n", (long long)addr);
313                         errcnt += 1;
314                 }
315                 addr += subpgsize;
316         }
317
318         return err;
319 }
320
321 static int verify_all_eraseblocks_ff(void)
322 {
323         int err;
324         unsigned int i;
325
326         printk(PRINT_PREF "verifying all eraseblocks for 0xff\n");
327         for (i = 0; i < ebcnt; ++i) {
328                 if (bbt[i])
329                         continue;
330                 err = verify_eraseblock_ff(i);
331                 if (err)
332                         return err;
333                 if (i % 256 == 0)
334                         printk(PRINT_PREF "verified up to eraseblock %u\n", i);
335                 cond_resched();
336         }
337         printk(PRINT_PREF "verified %u eraseblocks\n", i);
338         return 0;
339 }
340
341 static int is_block_bad(int ebnum)
342 {
343         loff_t addr = ebnum * mtd->erasesize;
344         int ret;
345
346         ret = mtd->block_isbad(mtd, addr);
347         if (ret)
348                 printk(PRINT_PREF "block %d is bad\n", ebnum);
349         return ret;
350 }
351
352 static int scan_for_bad_eraseblocks(void)
353 {
354         int i, bad = 0;
355
356         bbt = kmalloc(ebcnt, GFP_KERNEL);
357         if (!bbt) {
358                 printk(PRINT_PREF "error: cannot allocate memory\n");
359                 return -ENOMEM;
360         }
361         memset(bbt, 0 , ebcnt);
362
363         printk(PRINT_PREF "scanning for bad eraseblocks\n");
364         for (i = 0; i < ebcnt; ++i) {
365                 bbt[i] = is_block_bad(i) ? 1 : 0;
366                 if (bbt[i])
367                         bad += 1;
368                 cond_resched();
369         }
370         printk(PRINT_PREF "scanned %d eraseblocks, %d are bad\n", i, bad);
371         return 0;
372 }
373
374 static int __init mtd_subpagetest_init(void)
375 {
376         int err = 0;
377         uint32_t i;
378         uint64_t tmp;
379
380         printk(KERN_INFO "\n");
381         printk(KERN_INFO "=================================================\n");
382         printk(PRINT_PREF "MTD device: %d\n", dev);
383
384         mtd = get_mtd_device(NULL, dev);
385         if (IS_ERR(mtd)) {
386                 err = PTR_ERR(mtd);
387                 printk(PRINT_PREF "error: cannot get MTD device\n");
388                 return err;
389         }
390
391         if (mtd->type != MTD_NANDFLASH) {
392                 printk(PRINT_PREF "this test requires NAND flash\n");
393                 goto out;
394         }
395
396         subpgsize = mtd->writesize >> mtd->subpage_sft;
397         printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
398                "page size %u, subpage size %u, count of eraseblocks %u, "
399                "pages per eraseblock %u, OOB size %u\n",
400                (unsigned long long)mtd->size, mtd->erasesize,
401                mtd->writesize, subpgsize, ebcnt, pgcnt, mtd->oobsize);
402
403         err = -ENOMEM;
404         bufsize = subpgsize * 32;
405         writebuf = kmalloc(bufsize, GFP_KERNEL);
406         if (!writebuf) {
407                 printk(PRINT_PREF "error: cannot allocate memory\n");
408                 goto out;
409         }
410         readbuf = kmalloc(bufsize, GFP_KERNEL);
411         if (!readbuf) {
412                 printk(PRINT_PREF "error: cannot allocate memory\n");
413                 goto out;
414         }
415
416         tmp = mtd->size;
417         do_div(tmp, mtd->erasesize);
418         ebcnt = tmp;
419         pgcnt = mtd->erasesize / mtd->writesize;
420
421         err = scan_for_bad_eraseblocks();
422         if (err)
423                 goto out;
424
425         err = erase_whole_device();
426         if (err)
427                 goto out;
428
429         printk(PRINT_PREF "writing whole device\n");
430         simple_srand(1);
431         for (i = 0; i < ebcnt; ++i) {
432                 if (bbt[i])
433                         continue;
434                 err = write_eraseblock(i);
435                 if (unlikely(err))
436                         goto out;
437                 if (i % 256 == 0)
438                         printk(PRINT_PREF "written up to eraseblock %u\n", i);
439                 cond_resched();
440         }
441         printk(PRINT_PREF "written %u eraseblocks\n", i);
442
443         simple_srand(1);
444         printk(PRINT_PREF "verifying all eraseblocks\n");
445         for (i = 0; i < ebcnt; ++i) {
446                 if (bbt[i])
447                         continue;
448                 err = verify_eraseblock(i);
449                 if (unlikely(err))
450                         goto out;
451                 if (i % 256 == 0)
452                         printk(PRINT_PREF "verified up to eraseblock %u\n", i);
453                 cond_resched();
454         }
455         printk(PRINT_PREF "verified %u eraseblocks\n", i);
456
457         err = erase_whole_device();
458         if (err)
459                 goto out;
460
461         err = verify_all_eraseblocks_ff();
462         if (err)
463                 goto out;
464
465         /* Write all eraseblocks */
466         simple_srand(3);
467         printk(PRINT_PREF "writing whole device\n");
468         for (i = 0; i < ebcnt; ++i) {
469                 if (bbt[i])
470                         continue;
471                 err = write_eraseblock2(i);
472                 if (unlikely(err))
473                         goto out;
474                 if (i % 256 == 0)
475                         printk(PRINT_PREF "written up to eraseblock %u\n", i);
476                 cond_resched();
477         }
478         printk(PRINT_PREF "written %u eraseblocks\n", i);
479
480         /* Check all eraseblocks */
481         simple_srand(3);
482         printk(PRINT_PREF "verifying all eraseblocks\n");
483         for (i = 0; i < ebcnt; ++i) {
484                 if (bbt[i])
485                         continue;
486                 err = verify_eraseblock2(i);
487                 if (unlikely(err))
488                         goto out;
489                 if (i % 256 == 0)
490                         printk(PRINT_PREF "verified up to eraseblock %u\n", i);
491                 cond_resched();
492         }
493         printk(PRINT_PREF "verified %u eraseblocks\n", i);
494
495         err = erase_whole_device();
496         if (err)
497                 goto out;
498
499         err = verify_all_eraseblocks_ff();
500         if (err)
501                 goto out;
502
503         printk(PRINT_PREF "finished with %d errors\n", errcnt);
504
505 out:
506         kfree(bbt);
507         kfree(readbuf);
508         kfree(writebuf);
509         put_mtd_device(mtd);
510         if (err)
511                 printk(PRINT_PREF "error %d occurred\n", err);
512         printk(KERN_INFO "=================================================\n");
513         return err;
514 }
515 module_init(mtd_subpagetest_init);
516
517 static void __exit mtd_subpagetest_exit(void)
518 {
519         return;
520 }
521 module_exit(mtd_subpagetest_exit);
522
523 MODULE_DESCRIPTION("Subpage test module");
524 MODULE_AUTHOR("Adrian Hunter");
525 MODULE_LICENSE("GPL");