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