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/ktime.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 int count;
  41 module_param(count, int, S_IRUGO);
  42 MODULE_PARM_DESC(count, "Maximum number of eraseblocks to use "
  43                         "(0 means use all)");
  44
  45 static struct mtd_info *mtd;
  46 static unsigned char *iobuf;
  47 static unsigned char *bbt;
  48
  49 static int pgsize;
  50 static int ebcnt;
  51 static int pgcnt;
  52 static int goodebcnt;
  53 static ktime_t start, finish;
  54
  55 static int multiblock_erase(int ebnum, int blocks)
  56 {
  57         int err;
  58         struct erase_info ei;
  59         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  60
  61         memset(&ei, 0, sizeof(struct erase_info));
  62         ei.mtd  = mtd;
  63         ei.addr = addr;
  64         ei.len  = mtd->erasesize * blocks;
  65
  66         err = mtd_erase(mtd, &ei);
  67         if (err) {
  68                 pr_err("error %d while erasing EB %d, blocks %d\n",
  69                        err, ebnum, blocks);
  70                 return err;
  71         }
  72
  73         if (ei.state == MTD_ERASE_FAILED) {
  74                 pr_err("some erase error occurred at EB %d,"
  75                        "blocks %d\n", ebnum, blocks);
  76                 return -EIO;
  77         }
  78
  79         return 0;
  80 }
  81
  82 static int write_eraseblock(int ebnum)
  83 {
  84         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  85
  86         return mtdtest_write(mtd, addr, mtd->erasesize, iobuf);
  87 }
  88
  89 static int write_eraseblock_by_page(int ebnum)
  90 {
  91         int i, err = 0;
  92         loff_t addr = (loff_t)ebnum * mtd->erasesize;
  93         void *buf = iobuf;
  94
  95         for (i = 0; i < pgcnt; i++) {
  96                 err = mtdtest_write(mtd, addr, pgsize, buf);
  97                 if (err)
  98                         break;
  99                 addr += pgsize;
 100                 buf += pgsize;
 101         }
 102
 103         return err;
 104 }
 105
 106 static int write_eraseblock_by_2pages(int ebnum)
 107 {
 108         size_t sz = pgsize * 2;
 109         int i, n = pgcnt / 2, err = 0;
 110         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 111         void *buf = iobuf;
 112
 113         for (i = 0; i < n; i++) {
 114                 err = mtdtest_write(mtd, addr, sz, buf);
 115                 if (err)
 116                         return err;
 117                 addr += sz;
 118                 buf += sz;
 119         }
 120         if (pgcnt % 2)
 121                 err = mtdtest_write(mtd, addr, pgsize, buf);
 122
 123         return err;
 124 }
 125
 126 static int read_eraseblock(int ebnum)
 127 {
 128         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 129
 130         return mtdtest_read(mtd, addr, mtd->erasesize, iobuf);
 131 }
 132
 133 static int read_eraseblock_by_page(int ebnum)
 134 {
 135         int i, err = 0;
 136         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 137         void *buf = iobuf;
 138
 139         for (i = 0; i < pgcnt; i++) {
 140                 err = mtdtest_read(mtd, addr, pgsize, buf);
 141                 if (err)
 142                         break;
 143                 addr += pgsize;
 144                 buf += pgsize;
 145         }
 146
 147         return err;
 148 }
 149
 150 static int read_eraseblock_by_2pages(int ebnum)
 151 {
 152         size_t sz = pgsize * 2;
 153         int i, n = pgcnt / 2, err = 0;
 154         loff_t addr = (loff_t)ebnum * mtd->erasesize;
 155         void *buf = iobuf;
 156
 157         for (i = 0; i < n; i++) {
 158                 err = mtdtest_read(mtd, addr, sz, buf);
 159                 if (err)
 160                         return err;
 161                 addr += sz;
 162                 buf += sz;
 163         }
 164         if (pgcnt % 2)
 165                 err = mtdtest_read(mtd, addr, pgsize, buf);
 166
 167         return err;
 168 }
 169
 170 static inline void start_timing(void)
 171 {
 172         start = ktime_get();
 173 }
 174
 175 static inline void stop_timing(void)
 176 {
 177         finish = ktime_get();
 178 }
 179
 180 static long calc_speed(void)
 181 {
 182         uint64_t k;
 183         long ms;
 184
 185         ms = ktime_ms_delta(finish, start);
 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");