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
35static int dev = -EINVAL;
36module_param(dev, int, S_IRUGO);
37MODULE_PARM_DESC(dev, "MTD device number to use");
38
39static int count;
40module_param(count, int, S_IRUGO);
41MODULE_PARM_DESC(count, "Maximum number of eraseblocks to use "
42			"(0 means use all)");
43
44static struct mtd_info *mtd;
45static unsigned char *iobuf;
46static unsigned char *bbt;
47
48static int pgsize;
49static int ebcnt;
50static int pgcnt;
51static int goodebcnt;
52static struct timeval start, finish;
53
54static 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
81static 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
88static 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
105static 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
125static 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
132static 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
149static 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
169static inline void start_timing(void)
170{
171	do_gettimeofday(&start);
172}
173
174static inline void stop_timing(void)
175{
176	do_gettimeofday(&finish);
177}
178
179static 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
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	/* 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");
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