drivers/mtd/tests/pagetest.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 page read and write on MTD device.
  18  *
  19  * Author: Adrian Hunter <ext-adrian.hunter@nokia.com>
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  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>
  32 #include <linux/random.h>
  33
  34 #include "mtd_test.h"
  35
  36 static int dev = -EINVAL;
  37 module_param(dev, int, S_IRUGO);
  38 MODULE_PARM_DESC(dev, "MTD device number to use");
  39
  40 static struct mtd_info *mtd;
  41 static unsigned char *twopages;
  42 static unsigned char *writebuf;
  43 static unsigned char *boundary;
  44 static unsigned char *bbt;
  45
  46 static int pgsize;
  47 static int bufsize;
  48 static int ebcnt;
  49 static int pgcnt;
  50 static int errcnt;
  51 static struct rnd_state rnd_state;
  52
  53 static int write_eraseblock(int ebnum)
  54 {
  55         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  56
  57         prandom_bytes_state(&rnd_state, writebuf, mtd->erasesize);
  58         cond_resched();
  59         return mtdtest_write(mtd, addr, mtd->erasesize, writebuf);
  60 }
  61
  62 static int verify_eraseblock(int ebnum)
  63 {
  64         uint32_t j;
  65         int err = 0, i;
  66         loff_t addr0, addrn;
  67         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  68
  69         addr0 = 0;
  70         for (i = 0; i < ebcnt && bbt[i]; ++i)
  71                 addr0 += mtd->erasesize;
  72
  73         addrn = mtd->size;
  74         for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i)
  75                 addrn -= mtd->erasesize;
  76
  77         prandom_bytes_state(&rnd_state, writebuf, mtd->erasesize);
  78         for (j = 0; j < pgcnt - 1; ++j, addr += pgsize) {
  79                 /* Do a read to set the internal dataRAMs to different data */
  80                 err = mtdtest_read(mtd, addr0, bufsize, twopages);
  81                 if (err)
  82                         return err;
  83                 err = mtdtest_read(mtd, addrn - bufsize, bufsize, twopages);
  84                 if (err)
  85                         return err;
  86                 memset(twopages, 0, bufsize);
  87                 err = mtdtest_read(mtd, addr, bufsize, twopages);
  88                 if (err)
  89                         break;
  90                 if (memcmp(twopages, writebuf + (j * pgsize), bufsize)) {
  91                         pr_err("error: verify failed at %#llx\n",
  92                                (long long)addr);
  93                         errcnt += 1;
  94                 }
  95         }
  96         /* Check boundary between eraseblocks */
  97         if (addr <= addrn - pgsize - pgsize && !bbt[ebnum + 1]) {
  98                 struct rnd_state old_state = rnd_state;
  99
 100                 /* Do a read to set the internal dataRAMs to different data */
 101                 err = mtdtest_read(mtd, addr0, bufsize, twopages);
 102                 if (err)
 103                         return err;
 104                 err = mtdtest_read(mtd, addrn - bufsize, bufsize, twopages);
 105                 if (err)
 106                         return err;
 107                 memset(twopages, 0, bufsize);
 108                 err = mtdtest_read(mtd, addr, bufsize, twopages);
 109                 if (err)
 110                         return err;
 111                 memcpy(boundary, writebuf + mtd->erasesize - pgsize, pgsize);
 112                 prandom_bytes_state(&rnd_state, boundary + pgsize, pgsize);
 113                 if (memcmp(twopages, boundary, bufsize)) {
 114                         pr_err("error: verify failed at %#llx\n",
 115                                (long long)addr);
 116                         errcnt += 1;
 117                 }
 118                 rnd_state = old_state;
 119         }
 120         return err;
 121 }
 122
 123 static int crosstest(void)
 124 {
 125         int err = 0, i;
 126         loff_t addr, addr0, addrn;
 127         unsigned char *pp1, *pp2, *pp3, *pp4;
 128
 129         pr_info("crosstest\n");
 130         pp1 = kcalloc(pgsize, 4, GFP_KERNEL);
 131         if (!pp1)
 132                 return -ENOMEM;
 133         pp2 = pp1 + pgsize;
 134         pp3 = pp2 + pgsize;
 135         pp4 = pp3 + pgsize;
 136
 137         addr0 = 0;
 138         for (i = 0; i < ebcnt && bbt[i]; ++i)
 139                 addr0 += mtd->erasesize;
 140
 141         addrn = mtd->size;
 142         for (i = 0; i < ebcnt && bbt[ebcnt - i - 1]; ++i)
 143                 addrn -= mtd->erasesize;
 144
 145         /* Read 2nd-to-last page to pp1 */
 146         addr = addrn - pgsize - pgsize;
 147         err = mtdtest_read(mtd, addr, pgsize, pp1);
 148         if (err) {
 149                 kfree(pp1);
 150                 return err;
 151         }
 152
 153         /* Read 3rd-to-last page to pp1 */
 154         addr = addrn - pgsize - pgsize - pgsize;
 155         err = mtdtest_read(mtd, addr, pgsize, pp1);
 156         if (err) {
 157                 kfree(pp1);
 158                 return err;
 159         }
 160
 161         /* Read first page to pp2 */
 162         addr = addr0;
 163         pr_info("reading page at %#llx\n", (long long)addr);
 164         err = mtdtest_read(mtd, addr, pgsize, pp2);
 165         if (err) {
 166                 kfree(pp1);
 167                 return err;
 168         }
 169
 170         /* Read last page to pp3 */
 171         addr = addrn - pgsize;
 172         pr_info("reading page at %#llx\n", (long long)addr);
 173         err = mtdtest_read(mtd, addr, pgsize, pp3);
 174         if (err) {
 175                 kfree(pp1);
 176                 return err;
 177         }
 178
 179         /* Read first page again to pp4 */
 180         addr = addr0;
 181         pr_info("reading page at %#llx\n", (long long)addr);
 182         err = mtdtest_read(mtd, addr, pgsize, pp4);
 183         if (err) {
 184                 kfree(pp1);
 185                 return err;
 186         }
 187
 188         /* pp2 and pp4 should be the same */
 189         pr_info("verifying pages read at %#llx match\n",
 190                (long long)addr0);
 191         if (memcmp(pp2, pp4, pgsize)) {
 192                 pr_err("verify failed!\n");
 193                 errcnt += 1;
 194         } else if (!err)
 195                 pr_info("crosstest ok\n");
 196         kfree(pp1);
 197         return err;
 198 }
 199
 200 static int erasecrosstest(void)
 201 {
 202         int err = 0, i, ebnum, ebnum2;
 203         loff_t addr0;
 204         char *readbuf = twopages;
 205
 206         pr_info("erasecrosstest\n");
 207
 208         ebnum = 0;
 209         addr0 = 0;
 210         for (i = 0; i < ebcnt && bbt[i]; ++i) {
 211                 addr0 += mtd->erasesize;
 212                 ebnum += 1;
 213         }
 214
 215         ebnum2 = ebcnt - 1;
 216         while (ebnum2 && bbt[ebnum2])
 217                 ebnum2 -= 1;
 218
 219         pr_info("erasing block %d\n", ebnum);
 220         err = mtdtest_erase_eraseblock(mtd, ebnum);
 221         if (err)
 222                 return err;
 223
 224         pr_info("writing 1st page of block %d\n", ebnum);
 225         prandom_bytes_state(&rnd_state, writebuf, pgsize);
 226         strcpy(writebuf, "There is no data like this!");
 227         err = mtdtest_write(mtd, addr0, pgsize, writebuf);
 228         if (err)
 229                 return err;
 230
 231         pr_info("reading 1st page of block %d\n", ebnum);
 232         memset(readbuf, 0, pgsize);
 233         err = mtdtest_read(mtd, addr0, pgsize, readbuf);
 234         if (err)
 235                 return err;
 236
 237         pr_info("verifying 1st page of block %d\n", ebnum);
 238         if (memcmp(writebuf, readbuf, pgsize)) {
 239                 pr_err("verify failed!\n");
 240                 errcnt += 1;
 241                 return -1;
 242         }
 243
 244         pr_info("erasing block %d\n", ebnum);
 245         err = mtdtest_erase_eraseblock(mtd, ebnum);
 246         if (err)
 247                 return err;
 248
 249         pr_info("writing 1st page of block %d\n", ebnum);
 250         prandom_bytes_state(&rnd_state, writebuf, pgsize);
 251         strcpy(writebuf, "There is no data like this!");
 252         err = mtdtest_write(mtd, addr0, pgsize, writebuf);
 253         if (err)
 254                 return err;
 255
 256         pr_info("erasing block %d\n", ebnum2);
 257         err = mtdtest_erase_eraseblock(mtd, ebnum2);
 258         if (err)
 259                 return err;
 260
 261         pr_info("reading 1st page of block %d\n", ebnum);
 262         memset(readbuf, 0, pgsize);
 263         err = mtdtest_read(mtd, addr0, pgsize, readbuf);
 264         if (err)
 265                 return err;
 266
 267         pr_info("verifying 1st page of block %d\n", ebnum);
 268         if (memcmp(writebuf, readbuf, pgsize)) {
 269                 pr_err("verify failed!\n");
 270                 errcnt += 1;
 271                 return -1;
 272         }
 273
 274         if (!err)
 275                 pr_info("erasecrosstest ok\n");
 276         return err;
 277 }
 278
 279 static int erasetest(void)
 280 {
 281         int err = 0, i, ebnum, ok = 1;
 282         loff_t addr0;
 283
 284         pr_info("erasetest\n");
 285
 286         ebnum = 0;
 287         addr0 = 0;
 288         for (i = 0; i < ebcnt && bbt[i]; ++i) {
 289                 addr0 += mtd->erasesize;
 290                 ebnum += 1;
 291         }
 292
 293         pr_info("erasing block %d\n", ebnum);
 294         err = mtdtest_erase_eraseblock(mtd, ebnum);
 295         if (err)
 296                 return err;
 297
 298         pr_info("writing 1st page of block %d\n", ebnum);
 299         prandom_bytes_state(&rnd_state, writebuf, pgsize);
 300         err = mtdtest_write(mtd, addr0, pgsize, writebuf);
 301         if (err)
 302                 return err;
 303
 304         pr_info("erasing block %d\n", ebnum);
 305         err = mtdtest_erase_eraseblock(mtd, ebnum);
 306         if (err)
 307                 return err;
 308
 309         pr_info("reading 1st page of block %d\n", ebnum);
 310         err = mtdtest_read(mtd, addr0, pgsize, twopages);
 311         if (err)
 312                 return err;
 313
 314         pr_info("verifying 1st page of block %d is all 0xff\n",
 315                ebnum);
 316         for (i = 0; i < pgsize; ++i)
 317                 if (twopages[i] != 0xff) {
 318                         pr_err("verifying all 0xff failed at %d\n",
 319                                i);
 320                         errcnt += 1;
 321                         ok = 0;
 322                         break;
 323                 }
 324
 325         if (ok && !err)
 326                 pr_info("erasetest ok\n");
 327
 328         return err;
 329 }
 330
 331 static int __init mtd_pagetest_init(void)
 332 {
 333         int err = 0;
 334         uint64_t tmp;
 335         uint32_t i;
 336
 337         printk(KERN_INFO "\n");
 338         printk(KERN_INFO "=================================================\n");
 339
 340         if (dev < 0) {
 341                 pr_info("Please specify a valid mtd-device via module parameter\n");
 342                 pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
 343                 return -EINVAL;
 344         }
 345
 346         pr_info("MTD device: %d\n", dev);
 347
 348         mtd = get_mtd_device(NULL, dev);
 349         if (IS_ERR(mtd)) {
 350                 err = PTR_ERR(mtd);
 351                 pr_err("error: cannot get MTD device\n");
 352                 return err;
 353         }
 354
 355         if (!mtd_type_is_nand(mtd)) {
 356                 pr_info("this test requires NAND flash\n");
 357                 goto out;
 358         }
 359
 360         tmp = mtd->size;
 361         do_div(tmp, mtd->erasesize);
 362         ebcnt = tmp;
 363         pgcnt = mtd->erasesize / mtd->writesize;
 364         pgsize = mtd->writesize;
 365
 366         pr_info("MTD device size %llu, eraseblock size %u, "
 367                "page size %u, count of eraseblocks %u, pages per "
 368                "eraseblock %u, OOB size %u\n",
 369                (unsigned long long)mtd->size, mtd->erasesize,
 370                pgsize, ebcnt, pgcnt, mtd->oobsize);
 371
 372         err = -ENOMEM;
 373         bufsize = pgsize * 2;
 374         writebuf = kmalloc(mtd->erasesize, GFP_KERNEL);
 375         if (!writebuf)
 376                 goto out;
 377         twopages = kmalloc(bufsize, GFP_KERNEL);
 378         if (!twopages)
 379                 goto out;
 380         boundary = kmalloc(bufsize, GFP_KERNEL);
 381         if (!boundary)
 382                 goto out;
 383
 384         bbt = kzalloc(ebcnt, GFP_KERNEL);
 385         if (!bbt)
 386                 goto out;
 387         err = mtdtest_scan_for_bad_eraseblocks(mtd, bbt, 0, ebcnt);
 388         if (err)
 389                 goto out;
 390
 391         /* Erase all eraseblocks */
 392         pr_info("erasing whole device\n");
 393         err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
 394         if (err)
 395                 goto out;
 396         pr_info("erased %u eraseblocks\n", ebcnt);
 397
 398         /* Write all eraseblocks */
 399         prandom_seed_state(&rnd_state, 1);
 400         pr_info("writing whole device\n");
 401         for (i = 0; i < ebcnt; ++i) {
 402                 if (bbt[i])
 403                         continue;
 404                 err = write_eraseblock(i);
 405                 if (err)
 406                         goto out;
 407                 if (i % 256 == 0)
 408                         pr_info("written up to eraseblock %u\n", i);
 409
 410                 err = mtdtest_relax();
 411                 if (err)
 412                         goto out;
 413         }
 414         pr_info("written %u eraseblocks\n", i);
 415
 416         /* Check all eraseblocks */
 417         prandom_seed_state(&rnd_state, 1);
 418         pr_info("verifying all eraseblocks\n");
 419         for (i = 0; i < ebcnt; ++i) {
 420                 if (bbt[i])
 421                         continue;
 422                 err = verify_eraseblock(i);
 423                 if (err)
 424                         goto out;
 425                 if (i % 256 == 0)
 426                         pr_info("verified up to eraseblock %u\n", i);
 427
 428                 err = mtdtest_relax();
 429                 if (err)
 430                         goto out;
 431         }
 432         pr_info("verified %u eraseblocks\n", i);
 433
 434         err = crosstest();
 435         if (err)
 436                 goto out;
 437
 438         if (ebcnt > 1) {
 439                 err = erasecrosstest();
 440                 if (err)
 441                         goto out;
 442         } else {
 443                 pr_info("skipping erasecrosstest, 2 erase blocks needed\n");
 444         }
 445
 446         err = erasetest();
 447         if (err)
 448                 goto out;
 449
 450         pr_info("finished with %d errors\n", errcnt);
 451 out:
 452
 453         kfree(bbt);
 454         kfree(boundary);
 455         kfree(twopages);
 456         kfree(writebuf);
 457         put_mtd_device(mtd);
 458         if (err)
 459                 pr_info("error %d occurred\n", err);
 460         printk(KERN_INFO "=================================================\n");
 461         return err;
 462 }
 463 module_init(mtd_pagetest_init);
 464
 465 static void __exit mtd_pagetest_exit(void)
 466 {
 467         return;
 468 }
 469 module_exit(mtd_pagetest_exit);
 470
 471 MODULE_DESCRIPTION("NAND page test");
 472 MODULE_AUTHOR("Adrian Hunter");
 473 MODULE_LICENSE("GPL");