drivers/mtd/tests/speedtest.c

   1 /*
   2  * Copyright (C) 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 read and write speed of a MTD device.
  18  *
  19  * Author: Adrian Hunter <adrian.hunter@nokia.com>
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  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>
  32
  33 #include "mtd_test.h"
  34
  35 static int dev = -EINVAL;
  36 module_param(dev, int, S_IRUGO);
  37 MODULE_PARM_DESC(dev, "MTD device number to use");
  38
  39 static int count;
  40 module_param(count, int, S_IRUGO);
  41 MODULE_PARM_DESC(count, "Maximum number of eraseblocks to use "
  42                         "(0 means use all)");
  43
  44 static struct mtd_info *mtd;
  45 static unsigned char *iobuf;
  46 static unsigned char *bbt;
  47
  48 static int pgsize;
  49 static int ebcnt;
  50 static int pgcnt;
  51 static int goodebcnt;
  52 static struct timeval start, finish;
  53
  54 static int multiblock_erase(int ebnum, int blocks)
  55 {
  56         int err;
  57         struct erase_info ei;
  58         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  59
  60         memset(&ei, 0, sizeof(struct erase_info));
  61         ei.mtd  = mtd;
  62         ei.addr = addr;
  63         ei.len  = mtd->erasesize * blocks;
  64
  65         err = mtd_erase(mtd, &ei);
  66         if (err) {
  67                 pr_err("error %d while erasing EB %d, blocks %d\n",
  68                        err, ebnum, blocks);
  69                 return err;
  70         }
  71
  72         if (ei.state == MTD_ERASE_FAILED) {
  73                 pr_err("some erase error occurred at EB %d,"
  74                        "blocks %d\n", ebnum, blocks);
  75                 return -EIO;
  76         }
  77
  78         return 0;
  79 }
  80
  81 static int write_eraseblock(int ebnum)
  82 {
  83         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  84
  85         return mtdtest_write(mtd, addr, mtd->erasesize, iobuf);
  86 }
  87
  88 static int write_eraseblock_by_page(int ebnum)
  89 {
  90         int i, err = 0;
  91         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  92         void *buf = iobuf;
  93
  94         for (i = 0; i < pgcnt; i++) {
  95                 err = mtdtest_write(mtd, addr, pgsize, buf);
  96                 if (err)
  97                         break;
  98                 addr += pgsize;
  99                 buf += pgsize;
 100         }
 101
 102         return err;
 103 }
 104
 105 static int write_eraseblock_by_2pages(int ebnum)
 106 {
 107         size_t sz = pgsize * 2;
 108         int i, n = pgcnt / 2, err = 0;
 109         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 110         void *buf = iobuf;
 111
 112         for (i = 0; i < n; i++) {
 113                 err = mtdtest_write(mtd, addr, sz, buf);
 114                 if (err)
 115                         return err;
 116                 addr += sz;
 117                 buf += sz;
 118         }
 119         if (pgcnt % 2)
 120                 err = mtdtest_write(mtd, addr, pgsize, buf);
 121
 122         return err;
 123 }
 124
 125 static int read_eraseblock(int ebnum)
 126 {
 127         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 128
 129         return mtdtest_read(mtd, addr, mtd->erasesize, iobuf);
 130 }
 131
 132 static int read_eraseblock_by_page(int ebnum)
 133 {
 134         int i, err = 0;
 135         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 136         void *buf = iobuf;
 137
 138         for (i = 0; i < pgcnt; i++) {
 139                 err = mtdtest_read(mtd, addr, pgsize, buf);
 140                 if (err)
 141                         break;
 142                 addr += pgsize;
 143                 buf += pgsize;
 144         }
 145
 146         return err;
 147 }
 148
 149 static int read_eraseblock_by_2pages(int ebnum)
 150 {
 151         size_t sz = pgsize * 2;
 152         int i, n = pgcnt / 2, err = 0;
 153         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 154         void *buf = iobuf;
 155
 156         for (i = 0; i < n; i++) {
 157                 err = mtdtest_read(mtd, addr, sz, buf);
 158                 if (err)
 159                         return err;
 160                 addr += sz;
 161                 buf += sz;
 162         }
 163         if (pgcnt % 2)
 164                 err = mtdtest_read(mtd, addr, pgsize, buf);
 165
 166         return err;
 167 }
 168
 169 static inline void start_timing(void)
 170 {
 171         do_gettimeofday(&start);
 172 }
 173
 174 static inline void stop_timing(void)
 175 {
 176         do_gettimeofday(&finish);
 177 }
 178
 179 static long calc_speed(void)
 180 {
 181         uint64_t k;
 182         long ms;
 183
 184         ms = (finish.tv_sec - start.tv_sec) * 1000 +
 185              (finish.tv_usec - start.tv_usec) / 1000;
 186         if (ms == 0)
 187                 return 0;
 188         k = (uint64_t)goodebcnt * (mtd->erasesize / 1024) * 1000;
 189         do_div(k, ms);
 190         return k;
 191 }
 192
 193 static int __init mtd_speedtest_init(void)
 194 {
 195         int err, i, blocks, j, k;
 196         long speed;
 197         uint64_t tmp;
 198
 199         printk(KERN_INFO "\n");
 200         printk(KERN_INFO "=================================================\n");
 201
 202         if (dev < 0) {
 203                 pr_info("Please specify a valid mtd-device via module parameter\n");
 204                 pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
 205                 return -EINVAL;
 206         }
 207
 208         if (count)
 209                 pr_info("MTD device: %d    count: %d\n", dev, count);
 210         else
 211                 pr_info("MTD device: %d\n", dev);
 212
 213         mtd = get_mtd_device(NULL, dev);
 214         if (IS_ERR(mtd)) {
 215                 err = PTR_ERR(mtd);
 216                 pr_err("error: cannot get MTD device\n");
 217                 return err;
 218         }
 219
 220         if (mtd->writesize == 1) {
 221                 pr_info("not NAND flash, assume page size is 512 "
 222                        "bytes.\n");
 223                 pgsize = 512;
 224         } else
 225                 pgsize = mtd->writesize;
 226
 227         tmp = mtd->size;
 228         do_div(tmp, mtd->erasesize);
 229         ebcnt = tmp;
 230         pgcnt = mtd->erasesize / pgsize;
 231
 232         pr_info("MTD device size %llu, eraseblock size %u, "
 233                "page size %u, count of eraseblocks %u, pages per "
 234                "eraseblock %u, OOB size %u\n",
 235                (unsigned long long)mtd->size, mtd->erasesize,
 236                pgsize, ebcnt, pgcnt, mtd->oobsize);
 237
 238         if (count > 0 && count < ebcnt)
 239                 ebcnt = count;
 240
 241         err = -ENOMEM;
 242         iobuf = kmalloc(mtd->erasesize, GFP_KERNEL);
 243         if (!iobuf)
 244                 goto out;
 245
 246         prandom_bytes(iobuf, mtd->erasesize);
 247
 248         bbt = kzalloc(ebcnt, GFP_KERNEL);
 249         if (!bbt)
 250                 goto out;
 251         err = mtdtest_scan_for_bad_eraseblocks(mtd, bbt, 0, ebcnt);
 252         if (err)
 253                 goto out;
 254         for (i = 0; i < ebcnt; i++) {
 255                 if (!bbt[i])
 256                         goodebcnt++;
 257         }
 258
 259         err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
 260         if (err)
 261                 goto out;
 262
 263         /* Write all eraseblocks, 1 eraseblock at a time */
 264         pr_info("testing eraseblock write speed\n");
 265         start_timing();
 266         for (i = 0; i < ebcnt; ++i) {
 267                 if (bbt[i])
 268                         continue;
 269                 err = write_eraseblock(i);
 270                 if (err)
 271                         goto out;
 272
 273                 err = mtdtest_relax();
 274                 if (err)
 275                         goto out;
 276         }
 277         stop_timing();
 278         speed = calc_speed();
 279         pr_info("eraseblock write speed is %ld KiB/s\n", speed);
 280
 281         /* Read all eraseblocks, 1 eraseblock at a time */
 282         pr_info("testing eraseblock read speed\n");
 283         start_timing();
 284         for (i = 0; i < ebcnt; ++i) {
 285                 if (bbt[i])
 286                         continue;
 287                 err = read_eraseblock(i);
 288                 if (err)
 289                         goto out;
 290
 291                 err = mtdtest_relax();
 292                 if (err)
 293                         goto out;
 294         }
 295         stop_timing();
 296         speed = calc_speed();
 297         pr_info("eraseblock read speed is %ld KiB/s\n", speed);
 298
 299         err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
 300         if (err)
 301                 goto out;
 302
 303         /* Write all eraseblocks, 1 page at a time */
 304         pr_info("testing page write speed\n");
 305         start_timing();
 306         for (i = 0; i < ebcnt; ++i) {
 307                 if (bbt[i])
 308                         continue;
 309                 err = write_eraseblock_by_page(i);
 310                 if (err)
 311                         goto out;
 312
 313                 err = mtdtest_relax();
 314                 if (err)
 315                         goto out;
 316         }
 317         stop_timing();
 318         speed = calc_speed();
 319         pr_info("page write speed is %ld KiB/s\n", speed);
 320
 321         /* Read all eraseblocks, 1 page at a time */
 322         pr_info("testing page read speed\n");
 323         start_timing();
 324         for (i = 0; i < ebcnt; ++i) {
 325                 if (bbt[i])
 326                         continue;
 327                 err = read_eraseblock_by_page(i);
 328                 if (err)
 329                         goto out;
 330
 331                 err = mtdtest_relax();
 332                 if (err)
 333                         goto out;
 334         }
 335         stop_timing();
 336         speed = calc_speed();
 337         pr_info("page read speed is %ld KiB/s\n", speed);
 338
 339         err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
 340         if (err)
 341                 goto out;
 342
 343         /* Write all eraseblocks, 2 pages at a time */
 344         pr_info("testing 2 page write speed\n");
 345         start_timing();
 346         for (i = 0; i < ebcnt; ++i) {
 347                 if (bbt[i])
 348                         continue;
 349                 err = write_eraseblock_by_2pages(i);
 350                 if (err)
 351                         goto out;
 352
 353                 err = mtdtest_relax();
 354                 if (err)
 355                         goto out;
 356         }
 357         stop_timing();
 358         speed = calc_speed();
 359         pr_info("2 page write speed is %ld KiB/s\n", speed);
 360
 361         /* Read all eraseblocks, 2 pages at a time */
 362         pr_info("testing 2 page read speed\n");
 363         start_timing();
 364         for (i = 0; i < ebcnt; ++i) {
 365                 if (bbt[i])
 366                         continue;
 367                 err = read_eraseblock_by_2pages(i);
 368                 if (err)
 369                         goto out;
 370
 371                 err = mtdtest_relax();
 372                 if (err)
 373                         goto out;
 374         }
 375         stop_timing();
 376         speed = calc_speed();
 377         pr_info("2 page read speed is %ld KiB/s\n", speed);
 378
 379         /* Erase all eraseblocks */
 380         pr_info("Testing erase speed\n");
 381         start_timing();
 382         err = mtdtest_erase_good_eraseblocks(mtd, bbt, 0, ebcnt);
 383         if (err)
 384                 goto out;
 385         stop_timing();
 386         speed = calc_speed();
 387         pr_info("erase speed is %ld KiB/s\n", speed);
 388
 389         /* Multi-block erase all eraseblocks */
 390         for (k = 1; k < 7; k++) {
 391                 blocks = 1 << k;
 392                 pr_info("Testing %dx multi-block erase speed\n",
 393                        blocks);
 394                 start_timing();
 395                 for (i = 0; i < ebcnt; ) {
 396                         for (j = 0; j < blocks && (i + j) < ebcnt; j++)
 397                                 if (bbt[i + j])
 398                                         break;
 399                         if (j < 1) {
 400                                 i++;
 401                                 continue;
 402                         }
 403                         err = multiblock_erase(i, j);
 404                         if (err)
 405                                 goto out;
 406
 407                         err = mtdtest_relax();
 408                         if (err)
 409                                 goto out;
 410
 411                         i += j;
 412                 }
 413                 stop_timing();
 414                 speed = calc_speed();
 415                 pr_info("%dx multi-block erase speed is %ld KiB/s\n",
 416                        blocks, speed);
 417         }
 418         pr_info("finished\n");
 419 out:
 420         kfree(iobuf);
 421         kfree(bbt);
 422         put_mtd_device(mtd);
 423         if (err)
 424                 pr_info("error %d occurred\n", err);
 425         printk(KERN_INFO "=================================================\n");
 426         return err;
 427 }
 428 module_init(mtd_speedtest_init);
 429
 430 static void __exit mtd_speedtest_exit(void)
 431 {
 432         return;
 433 }
 434 module_exit(mtd_speedtest_exit);
 435
 436 MODULE_DESCRIPTION("Speed test module");
 437 MODULE_AUTHOR("Adrian Hunter");
 438 MODULE_LICENSE("GPL");