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.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
82static 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
89static 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
106static 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
126static 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
133static 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
150static 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
170static inline void start_timing(void)
171{
172 start = ktime_get();
173}
174
175static inline void stop_timing(void)
176{
177 finish = ktime_get();
178}
179
180static 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
193static 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
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
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
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
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
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
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
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
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");
419out:
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}
428module_init(mtd_speedtest_init);
429
430static void __exit mtd_speedtest_exit(void)
431{
432 return;
433}
434module_exit(mtd_speedtest_exit);
435
436MODULE_DESCRIPTION("Speed test module");
437MODULE_AUTHOR("Adrian Hunter");
438MODULE_LICENSE("GPL");
439
