1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2007 Nokia Corporation
5 * Test read and write speed of a MTD device.
7 * Author: Adrian Hunter <adrian.hunter@nokia.com>
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/init.h>
13 #include <linux/ktime.h>
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/err.h>
17 #include <linux/mtd/mtd.h>
18 #include <linux/slab.h>
19 #include <linux/sched.h>
20 #include <linux/random.h>
24 static int dev
= -EINVAL
;
25 module_param(dev
, int, S_IRUGO
);
26 MODULE_PARM_DESC(dev
, "MTD device number to use");
29 module_param(count
, int, S_IRUGO
);
30 MODULE_PARM_DESC(count
, "Maximum number of eraseblocks to use "
33 static struct mtd_info
*mtd
;
34 static unsigned char *iobuf
;
35 static unsigned char *bbt
;
41 static ktime_t start
, finish
;
43 static int multiblock_erase(int ebnum
, int blocks
)
47 loff_t addr
= (loff_t
)ebnum
* mtd
->erasesize
;
49 memset(&ei
, 0, sizeof(struct erase_info
));
51 ei
.len
= mtd
->erasesize
* blocks
;
53 err
= mtd_erase(mtd
, &ei
);
55 pr_err("error %d while erasing EB %d, blocks %d\n",
63 static int write_eraseblock(int ebnum
)
65 loff_t addr
= (loff_t
)ebnum
* mtd
->erasesize
;
67 return mtdtest_write(mtd
, addr
, mtd
->erasesize
, iobuf
);
70 static int write_eraseblock_by_page(int ebnum
)
73 loff_t addr
= (loff_t
)ebnum
* mtd
->erasesize
;
76 for (i
= 0; i
< pgcnt
; i
++) {
77 err
= mtdtest_write(mtd
, addr
, pgsize
, buf
);
87 static int write_eraseblock_by_2pages(int ebnum
)
89 size_t sz
= pgsize
* 2;
90 int i
, n
= pgcnt
/ 2, err
= 0;
91 loff_t addr
= (loff_t
)ebnum
* mtd
->erasesize
;
94 for (i
= 0; i
< n
; i
++) {
95 err
= mtdtest_write(mtd
, addr
, sz
, buf
);
102 err
= mtdtest_write(mtd
, addr
, pgsize
, buf
);
107 static int read_eraseblock(int ebnum
)
109 loff_t addr
= (loff_t
)ebnum
* mtd
->erasesize
;
111 return mtdtest_read(mtd
, addr
, mtd
->erasesize
, iobuf
);
114 static int read_eraseblock_by_page(int ebnum
)
117 loff_t addr
= (loff_t
)ebnum
* mtd
->erasesize
;
120 for (i
= 0; i
< pgcnt
; i
++) {
121 err
= mtdtest_read(mtd
, addr
, pgsize
, buf
);
131 static int read_eraseblock_by_2pages(int ebnum
)
133 size_t sz
= pgsize
* 2;
134 int i
, n
= pgcnt
/ 2, err
= 0;
135 loff_t addr
= (loff_t
)ebnum
* mtd
->erasesize
;
138 for (i
= 0; i
< n
; i
++) {
139 err
= mtdtest_read(mtd
, addr
, sz
, buf
);
146 err
= mtdtest_read(mtd
, addr
, pgsize
, buf
);
151 static inline void start_timing(void)
156 static inline void stop_timing(void)
158 finish
= ktime_get();
161 static long calc_speed(void)
165 us
= ktime_us_delta(finish
, start
);
168 k
= (uint64_t)goodebcnt
* (mtd
->erasesize
/ 1024) * 1000000;
173 static int __init
mtd_speedtest_init(void)
175 int err
, i
, blocks
, j
, k
;
179 printk(KERN_INFO
"\n");
180 printk(KERN_INFO
"=================================================\n");
183 pr_info("Please specify a valid mtd-device via module parameter\n");
184 pr_crit("CAREFUL: This test wipes all data on the specified MTD device!\n");
189 pr_info("MTD device: %d count: %d\n", dev
, count
);
191 pr_info("MTD device: %d\n", dev
);
193 mtd
= get_mtd_device(NULL
, dev
);
196 pr_err("error: cannot get MTD device\n");
200 if (mtd
->writesize
== 1) {
201 pr_info("not NAND flash, assume page size is 512 "
205 pgsize
= mtd
->writesize
;
208 do_div(tmp
, mtd
->erasesize
);
210 pgcnt
= mtd
->erasesize
/ pgsize
;
212 pr_info("MTD device size %llu, eraseblock size %u, "
213 "page size %u, count of eraseblocks %u, pages per "
214 "eraseblock %u, OOB size %u\n",
215 (unsigned long long)mtd
->size
, mtd
->erasesize
,
216 pgsize
, ebcnt
, pgcnt
, mtd
->oobsize
);
218 if (count
> 0 && count
< ebcnt
)
222 iobuf
= kmalloc(mtd
->erasesize
, GFP_KERNEL
);
226 get_random_bytes(iobuf
, mtd
->erasesize
);
228 bbt
= kzalloc(ebcnt
, GFP_KERNEL
);
231 err
= mtdtest_scan_for_bad_eraseblocks(mtd
, bbt
, 0, ebcnt
);
234 for (i
= 0; i
< ebcnt
; i
++) {
239 err
= mtdtest_erase_good_eraseblocks(mtd
, bbt
, 0, ebcnt
);
243 /* Write all eraseblocks, 1 eraseblock at a time */
244 pr_info("testing eraseblock write speed\n");
246 for (i
= 0; i
< ebcnt
; ++i
) {
249 err
= write_eraseblock(i
);
253 err
= mtdtest_relax();
258 speed
= calc_speed();
259 pr_info("eraseblock write speed is %ld KiB/s\n", speed
);
261 /* Read all eraseblocks, 1 eraseblock at a time */
262 pr_info("testing eraseblock read speed\n");
264 for (i
= 0; i
< ebcnt
; ++i
) {
267 err
= read_eraseblock(i
);
271 err
= mtdtest_relax();
276 speed
= calc_speed();
277 pr_info("eraseblock read speed is %ld KiB/s\n", speed
);
279 err
= mtdtest_erase_good_eraseblocks(mtd
, bbt
, 0, ebcnt
);
283 /* Write all eraseblocks, 1 page at a time */
284 pr_info("testing page write speed\n");
286 for (i
= 0; i
< ebcnt
; ++i
) {
289 err
= write_eraseblock_by_page(i
);
293 err
= mtdtest_relax();
298 speed
= calc_speed();
299 pr_info("page write speed is %ld KiB/s\n", speed
);
301 /* Read all eraseblocks, 1 page at a time */
302 pr_info("testing page read speed\n");
304 for (i
= 0; i
< ebcnt
; ++i
) {
307 err
= read_eraseblock_by_page(i
);
311 err
= mtdtest_relax();
316 speed
= calc_speed();
317 pr_info("page read speed is %ld KiB/s\n", speed
);
319 err
= mtdtest_erase_good_eraseblocks(mtd
, bbt
, 0, ebcnt
);
323 /* Write all eraseblocks, 2 pages at a time */
324 pr_info("testing 2 page write speed\n");
326 for (i
= 0; i
< ebcnt
; ++i
) {
329 err
= write_eraseblock_by_2pages(i
);
333 err
= mtdtest_relax();
338 speed
= calc_speed();
339 pr_info("2 page write speed is %ld KiB/s\n", speed
);
341 /* Read all eraseblocks, 2 pages at a time */
342 pr_info("testing 2 page read speed\n");
344 for (i
= 0; i
< ebcnt
; ++i
) {
347 err
= read_eraseblock_by_2pages(i
);
351 err
= mtdtest_relax();
356 speed
= calc_speed();
357 pr_info("2 page read speed is %ld KiB/s\n", speed
);
359 /* Erase all eraseblocks */
360 pr_info("Testing erase speed\n");
362 err
= mtdtest_erase_good_eraseblocks(mtd
, bbt
, 0, ebcnt
);
366 speed
= calc_speed();
367 pr_info("erase speed is %ld KiB/s\n", speed
);
369 /* Multi-block erase all eraseblocks */
370 for (k
= 1; k
< 7; k
++) {
372 pr_info("Testing %dx multi-block erase speed\n",
375 for (i
= 0; i
< ebcnt
; ) {
376 for (j
= 0; j
< blocks
&& (i
+ j
) < ebcnt
; j
++)
383 err
= multiblock_erase(i
, j
);
387 err
= mtdtest_relax();
394 speed
= calc_speed();
395 pr_info("%dx multi-block erase speed is %ld KiB/s\n",
398 pr_info("finished\n");
404 pr_info("error %d occurred\n", err
);
405 printk(KERN_INFO
"=================================================\n");
408 module_init(mtd_speedtest_init
);
410 static void __exit
mtd_speedtest_exit(void)
414 module_exit(mtd_speedtest_exit
);
416 MODULE_DESCRIPTION("Speed test module");
417 MODULE_AUTHOR("Adrian Hunter");
418 MODULE_LICENSE("GPL");