xref: /openbmc/linux/drivers/mmc/core/mmc_test.c (revision cac2815f)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Copyright 2007-2008 Pierre Ossman
4  */
5 
6 #include <linux/mmc/core.h>
7 #include <linux/mmc/card.h>
8 #include <linux/mmc/host.h>
9 #include <linux/mmc/mmc.h>
10 #include <linux/slab.h>
11 
12 #include <linux/scatterlist.h>
13 #include <linux/list.h>
14 
15 #include <linux/debugfs.h>
16 #include <linux/uaccess.h>
17 #include <linux/seq_file.h>
18 #include <linux/module.h>
19 
20 #include "core.h"
21 #include "card.h"
22 #include "host.h"
23 #include "bus.h"
24 #include "mmc_ops.h"
25 
26 #define RESULT_OK		0
27 #define RESULT_FAIL		1
28 #define RESULT_UNSUP_HOST	2
29 #define RESULT_UNSUP_CARD	3
30 
31 #define BUFFER_ORDER		2
32 #define BUFFER_SIZE		(PAGE_SIZE << BUFFER_ORDER)
33 
34 #define TEST_ALIGN_END		8
35 
36 /*
37  * Limit the test area size to the maximum MMC HC erase group size.  Note that
38  * the maximum SD allocation unit size is just 4MiB.
39  */
40 #define TEST_AREA_MAX_SIZE (128 * 1024 * 1024)
41 
42 /**
43  * struct mmc_test_pages - pages allocated by 'alloc_pages()'.
44  * @page: first page in the allocation
45  * @order: order of the number of pages allocated
46  */
47 struct mmc_test_pages {
48 	struct page *page;
49 	unsigned int order;
50 };
51 
52 /**
53  * struct mmc_test_mem - allocated memory.
54  * @arr: array of allocations
55  * @cnt: number of allocations
56  */
57 struct mmc_test_mem {
58 	struct mmc_test_pages *arr;
59 	unsigned int cnt;
60 };
61 
62 /**
63  * struct mmc_test_area - information for performance tests.
64  * @max_sz: test area size (in bytes)
65  * @dev_addr: address on card at which to do performance tests
66  * @max_tfr: maximum transfer size allowed by driver (in bytes)
67  * @max_segs: maximum segments allowed by driver in scatterlist @sg
68  * @max_seg_sz: maximum segment size allowed by driver
69  * @blocks: number of (512 byte) blocks currently mapped by @sg
70  * @sg_len: length of currently mapped scatterlist @sg
71  * @mem: allocated memory
72  * @sg: scatterlist
73  * @sg_areq: scatterlist for non-blocking request
74  */
75 struct mmc_test_area {
76 	unsigned long max_sz;
77 	unsigned int dev_addr;
78 	unsigned int max_tfr;
79 	unsigned int max_segs;
80 	unsigned int max_seg_sz;
81 	unsigned int blocks;
82 	unsigned int sg_len;
83 	struct mmc_test_mem *mem;
84 	struct scatterlist *sg;
85 	struct scatterlist *sg_areq;
86 };
87 
88 /**
89  * struct mmc_test_transfer_result - transfer results for performance tests.
90  * @link: double-linked list
91  * @count: amount of group of sectors to check
92  * @sectors: amount of sectors to check in one group
93  * @ts: time values of transfer
94  * @rate: calculated transfer rate
95  * @iops: I/O operations per second (times 100)
96  */
97 struct mmc_test_transfer_result {
98 	struct list_head link;
99 	unsigned int count;
100 	unsigned int sectors;
101 	struct timespec64 ts;
102 	unsigned int rate;
103 	unsigned int iops;
104 };
105 
106 /**
107  * struct mmc_test_general_result - results for tests.
108  * @link: double-linked list
109  * @card: card under test
110  * @testcase: number of test case
111  * @result: result of test run
112  * @tr_lst: transfer measurements if any as mmc_test_transfer_result
113  */
114 struct mmc_test_general_result {
115 	struct list_head link;
116 	struct mmc_card *card;
117 	int testcase;
118 	int result;
119 	struct list_head tr_lst;
120 };
121 
122 /**
123  * struct mmc_test_dbgfs_file - debugfs related file.
124  * @link: double-linked list
125  * @card: card under test
126  * @file: file created under debugfs
127  */
128 struct mmc_test_dbgfs_file {
129 	struct list_head link;
130 	struct mmc_card *card;
131 	struct dentry *file;
132 };
133 
134 /**
135  * struct mmc_test_card - test information.
136  * @card: card under test
137  * @scratch: transfer buffer
138  * @buffer: transfer buffer
139  * @highmem: buffer for highmem tests
140  * @area: information for performance tests
141  * @gr: pointer to results of current testcase
142  */
143 struct mmc_test_card {
144 	struct mmc_card	*card;
145 
146 	u8		scratch[BUFFER_SIZE];
147 	u8		*buffer;
148 #ifdef CONFIG_HIGHMEM
149 	struct page	*highmem;
150 #endif
151 	struct mmc_test_area		area;
152 	struct mmc_test_general_result	*gr;
153 };
154 
155 enum mmc_test_prep_media {
156 	MMC_TEST_PREP_NONE = 0,
157 	MMC_TEST_PREP_WRITE_FULL = 1 << 0,
158 	MMC_TEST_PREP_ERASE = 1 << 1,
159 };
160 
161 struct mmc_test_multiple_rw {
162 	unsigned int *sg_len;
163 	unsigned int *bs;
164 	unsigned int len;
165 	unsigned int size;
166 	bool do_write;
167 	bool do_nonblock_req;
168 	enum mmc_test_prep_media prepare;
169 };
170 
171 /*******************************************************************/
172 /*  General helper functions                                       */
173 /*******************************************************************/
174 
175 /*
176  * Configure correct block size in card
177  */
mmc_test_set_blksize(struct mmc_test_card * test,unsigned size)178 static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)
179 {
180 	return mmc_set_blocklen(test->card, size);
181 }
182 
mmc_test_card_cmd23(struct mmc_card * card)183 static bool mmc_test_card_cmd23(struct mmc_card *card)
184 {
185 	return mmc_card_mmc(card) ||
186 	       (mmc_card_sd(card) && card->scr.cmds & SD_SCR_CMD23_SUPPORT);
187 }
188 
mmc_test_prepare_sbc(struct mmc_test_card * test,struct mmc_request * mrq,unsigned int blocks)189 static void mmc_test_prepare_sbc(struct mmc_test_card *test,
190 				 struct mmc_request *mrq, unsigned int blocks)
191 {
192 	struct mmc_card *card = test->card;
193 
194 	if (!mrq->sbc || !mmc_host_cmd23(card->host) ||
195 	    !mmc_test_card_cmd23(card) || !mmc_op_multi(mrq->cmd->opcode) ||
196 	    (card->quirks & MMC_QUIRK_BLK_NO_CMD23)) {
197 		mrq->sbc = NULL;
198 		return;
199 	}
200 
201 	mrq->sbc->opcode = MMC_SET_BLOCK_COUNT;
202 	mrq->sbc->arg = blocks;
203 	mrq->sbc->flags = MMC_RSP_R1 | MMC_CMD_AC;
204 }
205 
206 /*
207  * Fill in the mmc_request structure given a set of transfer parameters.
208  */
mmc_test_prepare_mrq(struct mmc_test_card * test,struct mmc_request * mrq,struct scatterlist * sg,unsigned sg_len,unsigned dev_addr,unsigned blocks,unsigned blksz,int write)209 static void mmc_test_prepare_mrq(struct mmc_test_card *test,
210 	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
211 	unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
212 {
213 	if (WARN_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop))
214 		return;
215 
216 	if (blocks > 1) {
217 		mrq->cmd->opcode = write ?
218 			MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
219 	} else {
220 		mrq->cmd->opcode = write ?
221 			MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
222 	}
223 
224 	mrq->cmd->arg = dev_addr;
225 	if (!mmc_card_blockaddr(test->card))
226 		mrq->cmd->arg <<= 9;
227 
228 	mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
229 
230 	if (blocks == 1)
231 		mrq->stop = NULL;
232 	else {
233 		mrq->stop->opcode = MMC_STOP_TRANSMISSION;
234 		mrq->stop->arg = 0;
235 		mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
236 	}
237 
238 	mrq->data->blksz = blksz;
239 	mrq->data->blocks = blocks;
240 	mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
241 	mrq->data->sg = sg;
242 	mrq->data->sg_len = sg_len;
243 
244 	mmc_test_prepare_sbc(test, mrq, blocks);
245 
246 	mmc_set_data_timeout(mrq->data, test->card);
247 }
248 
mmc_test_busy(struct mmc_command * cmd)249 static int mmc_test_busy(struct mmc_command *cmd)
250 {
251 	return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
252 		(R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
253 }
254 
255 /*
256  * Wait for the card to finish the busy state
257  */
mmc_test_wait_busy(struct mmc_test_card * test)258 static int mmc_test_wait_busy(struct mmc_test_card *test)
259 {
260 	int ret, busy;
261 	struct mmc_command cmd = {};
262 
263 	busy = 0;
264 	do {
265 		memset(&cmd, 0, sizeof(struct mmc_command));
266 
267 		cmd.opcode = MMC_SEND_STATUS;
268 		cmd.arg = test->card->rca << 16;
269 		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
270 
271 		ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
272 		if (ret)
273 			break;
274 
275 		if (!busy && mmc_test_busy(&cmd)) {
276 			busy = 1;
277 			if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
278 				pr_info("%s: Warning: Host did not wait for busy state to end.\n",
279 					mmc_hostname(test->card->host));
280 		}
281 	} while (mmc_test_busy(&cmd));
282 
283 	return ret;
284 }
285 
286 /*
287  * Transfer a single sector of kernel addressable data
288  */
mmc_test_buffer_transfer(struct mmc_test_card * test,u8 * buffer,unsigned addr,unsigned blksz,int write)289 static int mmc_test_buffer_transfer(struct mmc_test_card *test,
290 	u8 *buffer, unsigned addr, unsigned blksz, int write)
291 {
292 	struct mmc_request mrq = {};
293 	struct mmc_command cmd = {};
294 	struct mmc_command stop = {};
295 	struct mmc_data data = {};
296 
297 	struct scatterlist sg;
298 
299 	mrq.cmd = &cmd;
300 	mrq.data = &data;
301 	mrq.stop = &stop;
302 
303 	sg_init_one(&sg, buffer, blksz);
304 
305 	mmc_test_prepare_mrq(test, &mrq, &sg, 1, addr, 1, blksz, write);
306 
307 	mmc_wait_for_req(test->card->host, &mrq);
308 
309 	if (cmd.error)
310 		return cmd.error;
311 	if (data.error)
312 		return data.error;
313 
314 	return mmc_test_wait_busy(test);
315 }
316 
mmc_test_free_mem(struct mmc_test_mem * mem)317 static void mmc_test_free_mem(struct mmc_test_mem *mem)
318 {
319 	if (!mem)
320 		return;
321 	while (mem->cnt--)
322 		__free_pages(mem->arr[mem->cnt].page,
323 			     mem->arr[mem->cnt].order);
324 	kfree(mem->arr);
325 	kfree(mem);
326 }
327 
328 /*
329  * Allocate a lot of memory, preferably max_sz but at least min_sz.  In case
330  * there isn't much memory do not exceed 1/16th total lowmem pages.  Also do
331  * not exceed a maximum number of segments and try not to make segments much
332  * bigger than maximum segment size.
333  */
mmc_test_alloc_mem(unsigned long min_sz,unsigned long max_sz,unsigned int max_segs,unsigned int max_seg_sz)334 static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
335 					       unsigned long max_sz,
336 					       unsigned int max_segs,
337 					       unsigned int max_seg_sz)
338 {
339 	unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE);
340 	unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE);
341 	unsigned long max_seg_page_cnt = DIV_ROUND_UP(max_seg_sz, PAGE_SIZE);
342 	unsigned long page_cnt = 0;
343 	unsigned long limit = nr_free_buffer_pages() >> 4;
344 	struct mmc_test_mem *mem;
345 
346 	if (max_page_cnt > limit)
347 		max_page_cnt = limit;
348 	if (min_page_cnt > max_page_cnt)
349 		min_page_cnt = max_page_cnt;
350 
351 	if (max_seg_page_cnt > max_page_cnt)
352 		max_seg_page_cnt = max_page_cnt;
353 
354 	if (max_segs > max_page_cnt)
355 		max_segs = max_page_cnt;
356 
357 	mem = kzalloc(sizeof(*mem), GFP_KERNEL);
358 	if (!mem)
359 		return NULL;
360 
361 	mem->arr = kcalloc(max_segs, sizeof(*mem->arr), GFP_KERNEL);
362 	if (!mem->arr)
363 		goto out_free;
364 
365 	while (max_page_cnt) {
366 		struct page *page;
367 		unsigned int order;
368 		gfp_t flags = GFP_KERNEL | GFP_DMA | __GFP_NOWARN |
369 				__GFP_NORETRY;
370 
371 		order = get_order(max_seg_page_cnt << PAGE_SHIFT);
372 		while (1) {
373 			page = alloc_pages(flags, order);
374 			if (page || !order)
375 				break;
376 			order -= 1;
377 		}
378 		if (!page) {
379 			if (page_cnt < min_page_cnt)
380 				goto out_free;
381 			break;
382 		}
383 		mem->arr[mem->cnt].page = page;
384 		mem->arr[mem->cnt].order = order;
385 		mem->cnt += 1;
386 		if (max_page_cnt <= (1UL << order))
387 			break;
388 		max_page_cnt -= 1UL << order;
389 		page_cnt += 1UL << order;
390 		if (mem->cnt >= max_segs) {
391 			if (page_cnt < min_page_cnt)
392 				goto out_free;
393 			break;
394 		}
395 	}
396 
397 	return mem;
398 
399 out_free:
400 	mmc_test_free_mem(mem);
401 	return NULL;
402 }
403 
404 /*
405  * Map memory into a scatterlist.  Optionally allow the same memory to be
406  * mapped more than once.
407  */
mmc_test_map_sg(struct mmc_test_mem * mem,unsigned long size,struct scatterlist * sglist,int repeat,unsigned int max_segs,unsigned int max_seg_sz,unsigned int * sg_len,int min_sg_len)408 static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long size,
409 			   struct scatterlist *sglist, int repeat,
410 			   unsigned int max_segs, unsigned int max_seg_sz,
411 			   unsigned int *sg_len, int min_sg_len)
412 {
413 	struct scatterlist *sg = NULL;
414 	unsigned int i;
415 	unsigned long sz = size;
416 
417 	sg_init_table(sglist, max_segs);
418 	if (min_sg_len > max_segs)
419 		min_sg_len = max_segs;
420 
421 	*sg_len = 0;
422 	do {
423 		for (i = 0; i < mem->cnt; i++) {
424 			unsigned long len = PAGE_SIZE << mem->arr[i].order;
425 
426 			if (min_sg_len && (size / min_sg_len < len))
427 				len = ALIGN(size / min_sg_len, 512);
428 			if (len > sz)
429 				len = sz;
430 			if (len > max_seg_sz)
431 				len = max_seg_sz;
432 			if (sg)
433 				sg = sg_next(sg);
434 			else
435 				sg = sglist;
436 			if (!sg)
437 				return -EINVAL;
438 			sg_set_page(sg, mem->arr[i].page, len, 0);
439 			sz -= len;
440 			*sg_len += 1;
441 			if (!sz)
442 				break;
443 		}
444 	} while (sz && repeat);
445 
446 	if (sz)
447 		return -EINVAL;
448 
449 	if (sg)
450 		sg_mark_end(sg);
451 
452 	return 0;
453 }
454 
455 /*
456  * Map memory into a scatterlist so that no pages are contiguous.  Allow the
457  * same memory to be mapped more than once.
458  */
mmc_test_map_sg_max_scatter(struct mmc_test_mem * mem,unsigned long sz,struct scatterlist * sglist,unsigned int max_segs,unsigned int max_seg_sz,unsigned int * sg_len)459 static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
460 				       unsigned long sz,
461 				       struct scatterlist *sglist,
462 				       unsigned int max_segs,
463 				       unsigned int max_seg_sz,
464 				       unsigned int *sg_len)
465 {
466 	struct scatterlist *sg = NULL;
467 	unsigned int i = mem->cnt, cnt;
468 	unsigned long len;
469 	void *base, *addr, *last_addr = NULL;
470 
471 	sg_init_table(sglist, max_segs);
472 
473 	*sg_len = 0;
474 	while (sz) {
475 		base = page_address(mem->arr[--i].page);
476 		cnt = 1 << mem->arr[i].order;
477 		while (sz && cnt) {
478 			addr = base + PAGE_SIZE * --cnt;
479 			if (last_addr && last_addr + PAGE_SIZE == addr)
480 				continue;
481 			last_addr = addr;
482 			len = PAGE_SIZE;
483 			if (len > max_seg_sz)
484 				len = max_seg_sz;
485 			if (len > sz)
486 				len = sz;
487 			if (sg)
488 				sg = sg_next(sg);
489 			else
490 				sg = sglist;
491 			if (!sg)
492 				return -EINVAL;
493 			sg_set_page(sg, virt_to_page(addr), len, 0);
494 			sz -= len;
495 			*sg_len += 1;
496 		}
497 		if (i == 0)
498 			i = mem->cnt;
499 	}
500 
501 	if (sg)
502 		sg_mark_end(sg);
503 
504 	return 0;
505 }
506 
507 /*
508  * Calculate transfer rate in bytes per second.
509  */
mmc_test_rate(uint64_t bytes,struct timespec64 * ts)510 static unsigned int mmc_test_rate(uint64_t bytes, struct timespec64 *ts)
511 {
512 	uint64_t ns;
513 
514 	ns = timespec64_to_ns(ts);
515 	bytes *= 1000000000;
516 
517 	while (ns > UINT_MAX) {
518 		bytes >>= 1;
519 		ns >>= 1;
520 	}
521 
522 	if (!ns)
523 		return 0;
524 
525 	do_div(bytes, (uint32_t)ns);
526 
527 	return bytes;
528 }
529 
530 /*
531  * Save transfer results for future usage
532  */
mmc_test_save_transfer_result(struct mmc_test_card * test,unsigned int count,unsigned int sectors,struct timespec64 ts,unsigned int rate,unsigned int iops)533 static void mmc_test_save_transfer_result(struct mmc_test_card *test,
534 	unsigned int count, unsigned int sectors, struct timespec64 ts,
535 	unsigned int rate, unsigned int iops)
536 {
537 	struct mmc_test_transfer_result *tr;
538 
539 	if (!test->gr)
540 		return;
541 
542 	tr = kmalloc(sizeof(*tr), GFP_KERNEL);
543 	if (!tr)
544 		return;
545 
546 	tr->count = count;
547 	tr->sectors = sectors;
548 	tr->ts = ts;
549 	tr->rate = rate;
550 	tr->iops = iops;
551 
552 	list_add_tail(&tr->link, &test->gr->tr_lst);
553 }
554 
555 /*
556  * Print the transfer rate.
557  */
mmc_test_print_rate(struct mmc_test_card * test,uint64_t bytes,struct timespec64 * ts1,struct timespec64 * ts2)558 static void mmc_test_print_rate(struct mmc_test_card *test, uint64_t bytes,
559 				struct timespec64 *ts1, struct timespec64 *ts2)
560 {
561 	unsigned int rate, iops, sectors = bytes >> 9;
562 	struct timespec64 ts;
563 
564 	ts = timespec64_sub(*ts2, *ts1);
565 
566 	rate = mmc_test_rate(bytes, &ts);
567 	iops = mmc_test_rate(100, &ts); /* I/O ops per sec x 100 */
568 
569 	pr_info("%s: Transfer of %u sectors (%u%s KiB) took %llu.%09u "
570 			 "seconds (%u kB/s, %u KiB/s, %u.%02u IOPS)\n",
571 			 mmc_hostname(test->card->host), sectors, sectors >> 1,
572 			 (sectors & 1 ? ".5" : ""), (u64)ts.tv_sec,
573 			 (u32)ts.tv_nsec, rate / 1000, rate / 1024,
574 			 iops / 100, iops % 100);
575 
576 	mmc_test_save_transfer_result(test, 1, sectors, ts, rate, iops);
577 }
578 
579 /*
580  * Print the average transfer rate.
581  */
mmc_test_print_avg_rate(struct mmc_test_card * test,uint64_t bytes,unsigned int count,struct timespec64 * ts1,struct timespec64 * ts2)582 static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
583 				    unsigned int count, struct timespec64 *ts1,
584 				    struct timespec64 *ts2)
585 {
586 	unsigned int rate, iops, sectors = bytes >> 9;
587 	uint64_t tot = bytes * count;
588 	struct timespec64 ts;
589 
590 	ts = timespec64_sub(*ts2, *ts1);
591 
592 	rate = mmc_test_rate(tot, &ts);
593 	iops = mmc_test_rate(count * 100, &ts); /* I/O ops per sec x 100 */
594 
595 	pr_info("%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
596 			 "%llu.%09u seconds (%u kB/s, %u KiB/s, "
597 			 "%u.%02u IOPS, sg_len %d)\n",
598 			 mmc_hostname(test->card->host), count, sectors, count,
599 			 sectors >> 1, (sectors & 1 ? ".5" : ""),
600 			 (u64)ts.tv_sec, (u32)ts.tv_nsec,
601 			 rate / 1000, rate / 1024, iops / 100, iops % 100,
602 			 test->area.sg_len);
603 
604 	mmc_test_save_transfer_result(test, count, sectors, ts, rate, iops);
605 }
606 
607 /*
608  * Return the card size in sectors.
609  */
mmc_test_capacity(struct mmc_card * card)610 static unsigned int mmc_test_capacity(struct mmc_card *card)
611 {
612 	if (!mmc_card_sd(card) && mmc_card_blockaddr(card))
613 		return card->ext_csd.sectors;
614 	else
615 		return card->csd.capacity << (card->csd.read_blkbits - 9);
616 }
617 
618 /*******************************************************************/
619 /*  Test preparation and cleanup                                   */
620 /*******************************************************************/
621 
622 /*
623  * Fill the first couple of sectors of the card with known data
624  * so that bad reads/writes can be detected
625  */
__mmc_test_prepare(struct mmc_test_card * test,int write,int val)626 static int __mmc_test_prepare(struct mmc_test_card *test, int write, int val)
627 {
628 	int ret, i;
629 
630 	ret = mmc_test_set_blksize(test, 512);
631 	if (ret)
632 		return ret;
633 
634 	if (write)
635 		memset(test->buffer, val, 512);
636 	else {
637 		for (i = 0; i < 512; i++)
638 			test->buffer[i] = i;
639 	}
640 
641 	for (i = 0; i < BUFFER_SIZE / 512; i++) {
642 		ret = mmc_test_buffer_transfer(test, test->buffer, i, 512, 1);
643 		if (ret)
644 			return ret;
645 	}
646 
647 	return 0;
648 }
649 
mmc_test_prepare_write(struct mmc_test_card * test)650 static int mmc_test_prepare_write(struct mmc_test_card *test)
651 {
652 	return __mmc_test_prepare(test, 1, 0xDF);
653 }
654 
mmc_test_prepare_read(struct mmc_test_card * test)655 static int mmc_test_prepare_read(struct mmc_test_card *test)
656 {
657 	return __mmc_test_prepare(test, 0, 0);
658 }
659 
mmc_test_cleanup(struct mmc_test_card * test)660 static int mmc_test_cleanup(struct mmc_test_card *test)
661 {
662 	return __mmc_test_prepare(test, 1, 0);
663 }
664 
665 /*******************************************************************/
666 /*  Test execution helpers                                         */
667 /*******************************************************************/
668 
669 /*
670  * Modifies the mmc_request to perform the "short transfer" tests
671  */
mmc_test_prepare_broken_mrq(struct mmc_test_card * test,struct mmc_request * mrq,int write)672 static void mmc_test_prepare_broken_mrq(struct mmc_test_card *test,
673 	struct mmc_request *mrq, int write)
674 {
675 	if (WARN_ON(!mrq || !mrq->cmd || !mrq->data))
676 		return;
677 
678 	if (mrq->data->blocks > 1) {
679 		mrq->cmd->opcode = write ?
680 			MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
681 		mrq->stop = NULL;
682 	} else {
683 		mrq->cmd->opcode = MMC_SEND_STATUS;
684 		mrq->cmd->arg = test->card->rca << 16;
685 	}
686 }
687 
688 /*
689  * Checks that a normal transfer didn't have any errors
690  */
mmc_test_check_result(struct mmc_test_card * test,struct mmc_request * mrq)691 static int mmc_test_check_result(struct mmc_test_card *test,
692 				 struct mmc_request *mrq)
693 {
694 	int ret;
695 
696 	if (WARN_ON(!mrq || !mrq->cmd || !mrq->data))
697 		return -EINVAL;
698 
699 	ret = 0;
700 
701 	if (mrq->sbc && mrq->sbc->error)
702 		ret = mrq->sbc->error;
703 	if (!ret && mrq->cmd->error)
704 		ret = mrq->cmd->error;
705 	if (!ret && mrq->data->error)
706 		ret = mrq->data->error;
707 	if (!ret && mrq->stop && mrq->stop->error)
708 		ret = mrq->stop->error;
709 	if (!ret && mrq->data->bytes_xfered !=
710 		mrq->data->blocks * mrq->data->blksz)
711 		ret = RESULT_FAIL;
712 
713 	if (ret == -EINVAL)
714 		ret = RESULT_UNSUP_HOST;
715 
716 	return ret;
717 }
718 
719 /*
720  * Checks that a "short transfer" behaved as expected
721  */
mmc_test_check_broken_result(struct mmc_test_card * test,struct mmc_request * mrq)722 static int mmc_test_check_broken_result(struct mmc_test_card *test,
723 	struct mmc_request *mrq)
724 {
725 	int ret;
726 
727 	if (WARN_ON(!mrq || !mrq->cmd || !mrq->data))
728 		return -EINVAL;
729 
730 	ret = 0;
731 
732 	if (!ret && mrq->cmd->error)
733 		ret = mrq->cmd->error;
734 	if (!ret && mrq->data->error == 0)
735 		ret = RESULT_FAIL;
736 	if (!ret && mrq->data->error != -ETIMEDOUT)
737 		ret = mrq->data->error;
738 	if (!ret && mrq->stop && mrq->stop->error)
739 		ret = mrq->stop->error;
740 	if (mrq->data->blocks > 1) {
741 		if (!ret && mrq->data->bytes_xfered > mrq->data->blksz)
742 			ret = RESULT_FAIL;
743 	} else {
744 		if (!ret && mrq->data->bytes_xfered > 0)
745 			ret = RESULT_FAIL;
746 	}
747 
748 	if (ret == -EINVAL)
749 		ret = RESULT_UNSUP_HOST;
750 
751 	return ret;
752 }
753 
754 struct mmc_test_req {
755 	struct mmc_request mrq;
756 	struct mmc_command sbc;
757 	struct mmc_command cmd;
758 	struct mmc_command stop;
759 	struct mmc_command status;
760 	struct mmc_data data;
761 };
762 
763 /*
764  * Tests nonblock transfer with certain parameters
765  */
mmc_test_req_reset(struct mmc_test_req * rq)766 static void mmc_test_req_reset(struct mmc_test_req *rq)
767 {
768 	memset(rq, 0, sizeof(struct mmc_test_req));
769 
770 	rq->mrq.cmd = &rq->cmd;
771 	rq->mrq.data = &rq->data;
772 	rq->mrq.stop = &rq->stop;
773 }
774 
mmc_test_req_alloc(void)775 static struct mmc_test_req *mmc_test_req_alloc(void)
776 {
777 	struct mmc_test_req *rq = kmalloc(sizeof(*rq), GFP_KERNEL);
778 
779 	if (rq)
780 		mmc_test_req_reset(rq);
781 
782 	return rq;
783 }
784 
mmc_test_wait_done(struct mmc_request * mrq)785 static void mmc_test_wait_done(struct mmc_request *mrq)
786 {
787 	complete(&mrq->completion);
788 }
789 
mmc_test_start_areq(struct mmc_test_card * test,struct mmc_request * mrq,struct mmc_request * prev_mrq)790 static int mmc_test_start_areq(struct mmc_test_card *test,
791 			       struct mmc_request *mrq,
792 			       struct mmc_request *prev_mrq)
793 {
794 	struct mmc_host *host = test->card->host;
795 	int err = 0;
796 
797 	if (mrq) {
798 		init_completion(&mrq->completion);
799 		mrq->done = mmc_test_wait_done;
800 		mmc_pre_req(host, mrq);
801 	}
802 
803 	if (prev_mrq) {
804 		wait_for_completion(&prev_mrq->completion);
805 		err = mmc_test_wait_busy(test);
806 		if (!err)
807 			err = mmc_test_check_result(test, prev_mrq);
808 	}
809 
810 	if (!err && mrq) {
811 		err = mmc_start_request(host, mrq);
812 		if (err)
813 			mmc_retune_release(host);
814 	}
815 
816 	if (prev_mrq)
817 		mmc_post_req(host, prev_mrq, 0);
818 
819 	if (err && mrq)
820 		mmc_post_req(host, mrq, err);
821 
822 	return err;
823 }
824 
mmc_test_nonblock_transfer(struct mmc_test_card * test,unsigned int dev_addr,int write,int count)825 static int mmc_test_nonblock_transfer(struct mmc_test_card *test,
826 				      unsigned int dev_addr, int write,
827 				      int count)
828 {
829 	struct mmc_test_req *rq1, *rq2;
830 	struct mmc_request *mrq, *prev_mrq;
831 	int i;
832 	int ret = RESULT_OK;
833 	struct mmc_test_area *t = &test->area;
834 	struct scatterlist *sg = t->sg;
835 	struct scatterlist *sg_areq = t->sg_areq;
836 
837 	rq1 = mmc_test_req_alloc();
838 	rq2 = mmc_test_req_alloc();
839 	if (!rq1 || !rq2) {
840 		ret = RESULT_FAIL;
841 		goto err;
842 	}
843 
844 	mrq = &rq1->mrq;
845 	prev_mrq = NULL;
846 
847 	for (i = 0; i < count; i++) {
848 		mmc_test_req_reset(container_of(mrq, struct mmc_test_req, mrq));
849 		mmc_test_prepare_mrq(test, mrq, sg, t->sg_len, dev_addr,
850 				     t->blocks, 512, write);
851 		ret = mmc_test_start_areq(test, mrq, prev_mrq);
852 		if (ret)
853 			goto err;
854 
855 		if (!prev_mrq)
856 			prev_mrq = &rq2->mrq;
857 
858 		swap(mrq, prev_mrq);
859 		swap(sg, sg_areq);
860 		dev_addr += t->blocks;
861 	}
862 
863 	ret = mmc_test_start_areq(test, NULL, prev_mrq);
864 err:
865 	kfree(rq1);
866 	kfree(rq2);
867 	return ret;
868 }
869 
870 /*
871  * Tests a basic transfer with certain parameters
872  */
mmc_test_simple_transfer(struct mmc_test_card * test,struct scatterlist * sg,unsigned sg_len,unsigned dev_addr,unsigned blocks,unsigned blksz,int write)873 static int mmc_test_simple_transfer(struct mmc_test_card *test,
874 	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
875 	unsigned blocks, unsigned blksz, int write)
876 {
877 	struct mmc_request mrq = {};
878 	struct mmc_command cmd = {};
879 	struct mmc_command stop = {};
880 	struct mmc_data data = {};
881 
882 	mrq.cmd = &cmd;
883 	mrq.data = &data;
884 	mrq.stop = &stop;
885 
886 	mmc_test_prepare_mrq(test, &mrq, sg, sg_len, dev_addr,
887 		blocks, blksz, write);
888 
889 	mmc_wait_for_req(test->card->host, &mrq);
890 
891 	mmc_test_wait_busy(test);
892 
893 	return mmc_test_check_result(test, &mrq);
894 }
895 
896 /*
897  * Tests a transfer where the card will fail completely or partly
898  */
mmc_test_broken_transfer(struct mmc_test_card * test,unsigned blocks,unsigned blksz,int write)899 static int mmc_test_broken_transfer(struct mmc_test_card *test,
900 	unsigned blocks, unsigned blksz, int write)
901 {
902 	struct mmc_request mrq = {};
903 	struct mmc_command cmd = {};
904 	struct mmc_command stop = {};
905 	struct mmc_data data = {};
906 
907 	struct scatterlist sg;
908 
909 	mrq.cmd = &cmd;
910 	mrq.data = &data;
911 	mrq.stop = &stop;
912 
913 	sg_init_one(&sg, test->buffer, blocks * blksz);
914 
915 	mmc_test_prepare_mrq(test, &mrq, &sg, 1, 0, blocks, blksz, write);
916 	mmc_test_prepare_broken_mrq(test, &mrq, write);
917 
918 	mmc_wait_for_req(test->card->host, &mrq);
919 
920 	mmc_test_wait_busy(test);
921 
922 	return mmc_test_check_broken_result(test, &mrq);
923 }
924 
925 /*
926  * Does a complete transfer test where data is also validated
927  *
928  * Note: mmc_test_prepare() must have been done before this call
929  */
mmc_test_transfer(struct mmc_test_card * test,struct scatterlist * sg,unsigned sg_len,unsigned dev_addr,unsigned blocks,unsigned blksz,int write)930 static int mmc_test_transfer(struct mmc_test_card *test,
931 	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
932 	unsigned blocks, unsigned blksz, int write)
933 {
934 	int ret, i;
935 
936 	if (write) {
937 		for (i = 0; i < blocks * blksz; i++)
938 			test->scratch[i] = i;
939 	} else {
940 		memset(test->scratch, 0, BUFFER_SIZE);
941 	}
942 	sg_copy_from_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
943 
944 	ret = mmc_test_set_blksize(test, blksz);
945 	if (ret)
946 		return ret;
947 
948 	ret = mmc_test_simple_transfer(test, sg, sg_len, dev_addr,
949 		blocks, blksz, write);
950 	if (ret)
951 		return ret;
952 
953 	if (write) {
954 		int sectors;
955 
956 		ret = mmc_test_set_blksize(test, 512);
957 		if (ret)
958 			return ret;
959 
960 		sectors = (blocks * blksz + 511) / 512;
961 		if ((sectors * 512) == (blocks * blksz))
962 			sectors++;
963 
964 		if ((sectors * 512) > BUFFER_SIZE)
965 			return -EINVAL;
966 
967 		memset(test->buffer, 0, sectors * 512);
968 
969 		for (i = 0; i < sectors; i++) {
970 			ret = mmc_test_buffer_transfer(test,
971 				test->buffer + i * 512,
972 				dev_addr + i, 512, 0);
973 			if (ret)
974 				return ret;
975 		}
976 
977 		for (i = 0; i < blocks * blksz; i++) {
978 			if (test->buffer[i] != (u8)i)
979 				return RESULT_FAIL;
980 		}
981 
982 		for (; i < sectors * 512; i++) {
983 			if (test->buffer[i] != 0xDF)
984 				return RESULT_FAIL;
985 		}
986 	} else {
987 		sg_copy_to_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
988 		for (i = 0; i < blocks * blksz; i++) {
989 			if (test->scratch[i] != (u8)i)
990 				return RESULT_FAIL;
991 		}
992 	}
993 
994 	return 0;
995 }
996 
997 /*******************************************************************/
998 /*  Tests                                                          */
999 /*******************************************************************/
1000 
1001 struct mmc_test_case {
1002 	const char *name;
1003 
1004 	int (*prepare)(struct mmc_test_card *);
1005 	int (*run)(struct mmc_test_card *);
1006 	int (*cleanup)(struct mmc_test_card *);
1007 };
1008 
mmc_test_basic_write(struct mmc_test_card * test)1009 static int mmc_test_basic_write(struct mmc_test_card *test)
1010 {
1011 	int ret;
1012 	struct scatterlist sg;
1013 
1014 	ret = mmc_test_set_blksize(test, 512);
1015 	if (ret)
1016 		return ret;
1017 
1018 	sg_init_one(&sg, test->buffer, 512);
1019 
1020 	return mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 1);
1021 }
1022 
mmc_test_basic_read(struct mmc_test_card * test)1023 static int mmc_test_basic_read(struct mmc_test_card *test)
1024 {
1025 	int ret;
1026 	struct scatterlist sg;
1027 
1028 	ret = mmc_test_set_blksize(test, 512);
1029 	if (ret)
1030 		return ret;
1031 
1032 	sg_init_one(&sg, test->buffer, 512);
1033 
1034 	return mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 0);
1035 }
1036 
mmc_test_verify_write(struct mmc_test_card * test)1037 static int mmc_test_verify_write(struct mmc_test_card *test)
1038 {
1039 	struct scatterlist sg;
1040 
1041 	sg_init_one(&sg, test->buffer, 512);
1042 
1043 	return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
1044 }
1045 
mmc_test_verify_read(struct mmc_test_card * test)1046 static int mmc_test_verify_read(struct mmc_test_card *test)
1047 {
1048 	struct scatterlist sg;
1049 
1050 	sg_init_one(&sg, test->buffer, 512);
1051 
1052 	return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
1053 }
1054 
mmc_test_multi_write(struct mmc_test_card * test)1055 static int mmc_test_multi_write(struct mmc_test_card *test)
1056 {
1057 	unsigned int size;
1058 	struct scatterlist sg;
1059 
1060 	if (test->card->host->max_blk_count == 1)
1061 		return RESULT_UNSUP_HOST;
1062 
1063 	size = PAGE_SIZE * 2;
1064 	size = min(size, test->card->host->max_req_size);
1065 	size = min(size, test->card->host->max_seg_size);
1066 	size = min(size, test->card->host->max_blk_count * 512);
1067 
1068 	if (size < 1024)
1069 		return RESULT_UNSUP_HOST;
1070 
1071 	sg_init_one(&sg, test->buffer, size);
1072 
1073 	return mmc_test_transfer(test, &sg, 1, 0, size / 512, 512, 1);
1074 }
1075 
mmc_test_multi_read(struct mmc_test_card * test)1076 static int mmc_test_multi_read(struct mmc_test_card *test)
1077 {
1078 	unsigned int size;
1079 	struct scatterlist sg;
1080 
1081 	if (test->card->host->max_blk_count == 1)
1082 		return RESULT_UNSUP_HOST;
1083 
1084 	size = PAGE_SIZE * 2;
1085 	size = min(size, test->card->host->max_req_size);
1086 	size = min(size, test->card->host->max_seg_size);
1087 	size = min(size, test->card->host->max_blk_count * 512);
1088 
1089 	if (size < 1024)
1090 		return RESULT_UNSUP_HOST;
1091 
1092 	sg_init_one(&sg, test->buffer, size);
1093 
1094 	return mmc_test_transfer(test, &sg, 1, 0, size / 512, 512, 0);
1095 }
1096 
mmc_test_pow2_write(struct mmc_test_card * test)1097 static int mmc_test_pow2_write(struct mmc_test_card *test)
1098 {
1099 	int ret, i;
1100 	struct scatterlist sg;
1101 
1102 	if (!test->card->csd.write_partial)
1103 		return RESULT_UNSUP_CARD;
1104 
1105 	for (i = 1; i < 512; i <<= 1) {
1106 		sg_init_one(&sg, test->buffer, i);
1107 		ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
1108 		if (ret)
1109 			return ret;
1110 	}
1111 
1112 	return 0;
1113 }
1114 
mmc_test_pow2_read(struct mmc_test_card * test)1115 static int mmc_test_pow2_read(struct mmc_test_card *test)
1116 {
1117 	int ret, i;
1118 	struct scatterlist sg;
1119 
1120 	if (!test->card->csd.read_partial)
1121 		return RESULT_UNSUP_CARD;
1122 
1123 	for (i = 1; i < 512; i <<= 1) {
1124 		sg_init_one(&sg, test->buffer, i);
1125 		ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
1126 		if (ret)
1127 			return ret;
1128 	}
1129 
1130 	return 0;
1131 }
1132 
mmc_test_weird_write(struct mmc_test_card * test)1133 static int mmc_test_weird_write(struct mmc_test_card *test)
1134 {
1135 	int ret, i;
1136 	struct scatterlist sg;
1137 
1138 	if (!test->card->csd.write_partial)
1139 		return RESULT_UNSUP_CARD;
1140 
1141 	for (i = 3; i < 512; i += 7) {
1142 		sg_init_one(&sg, test->buffer, i);
1143 		ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
1144 		if (ret)
1145 			return ret;
1146 	}
1147 
1148 	return 0;
1149 }
1150 
mmc_test_weird_read(struct mmc_test_card * test)1151 static int mmc_test_weird_read(struct mmc_test_card *test)
1152 {
1153 	int ret, i;
1154 	struct scatterlist sg;
1155 
1156 	if (!test->card->csd.read_partial)
1157 		return RESULT_UNSUP_CARD;
1158 
1159 	for (i = 3; i < 512; i += 7) {
1160 		sg_init_one(&sg, test->buffer, i);
1161 		ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
1162 		if (ret)
1163 			return ret;
1164 	}
1165 
1166 	return 0;
1167 }
1168 
mmc_test_align_write(struct mmc_test_card * test)1169 static int mmc_test_align_write(struct mmc_test_card *test)
1170 {
1171 	int ret, i;
1172 	struct scatterlist sg;
1173 
1174 	for (i = 1; i < TEST_ALIGN_END; i++) {
1175 		sg_init_one(&sg, test->buffer + i, 512);
1176 		ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
1177 		if (ret)
1178 			return ret;
1179 	}
1180 
1181 	return 0;
1182 }
1183 
mmc_test_align_read(struct mmc_test_card * test)1184 static int mmc_test_align_read(struct mmc_test_card *test)
1185 {
1186 	int ret, i;
1187 	struct scatterlist sg;
1188 
1189 	for (i = 1; i < TEST_ALIGN_END; i++) {
1190 		sg_init_one(&sg, test->buffer + i, 512);
1191 		ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
1192 		if (ret)
1193 			return ret;
1194 	}
1195 
1196 	return 0;
1197 }
1198 
mmc_test_align_multi_write(struct mmc_test_card * test)1199 static int mmc_test_align_multi_write(struct mmc_test_card *test)
1200 {
1201 	int ret, i;
1202 	unsigned int size;
1203 	struct scatterlist sg;
1204 
1205 	if (test->card->host->max_blk_count == 1)
1206 		return RESULT_UNSUP_HOST;
1207 
1208 	size = PAGE_SIZE * 2;
1209 	size = min(size, test->card->host->max_req_size);
1210 	size = min(size, test->card->host->max_seg_size);
1211 	size = min(size, test->card->host->max_blk_count * 512);
1212 
1213 	if (size < 1024)
1214 		return RESULT_UNSUP_HOST;
1215 
1216 	for (i = 1; i < TEST_ALIGN_END; i++) {
1217 		sg_init_one(&sg, test->buffer + i, size);
1218 		ret = mmc_test_transfer(test, &sg, 1, 0, size / 512, 512, 1);
1219 		if (ret)
1220 			return ret;
1221 	}
1222 
1223 	return 0;
1224 }
1225 
mmc_test_align_multi_read(struct mmc_test_card * test)1226 static int mmc_test_align_multi_read(struct mmc_test_card *test)
1227 {
1228 	int ret, i;
1229 	unsigned int size;
1230 	struct scatterlist sg;
1231 
1232 	if (test->card->host->max_blk_count == 1)
1233 		return RESULT_UNSUP_HOST;
1234 
1235 	size = PAGE_SIZE * 2;
1236 	size = min(size, test->card->host->max_req_size);
1237 	size = min(size, test->card->host->max_seg_size);
1238 	size = min(size, test->card->host->max_blk_count * 512);
1239 
1240 	if (size < 1024)
1241 		return RESULT_UNSUP_HOST;
1242 
1243 	for (i = 1; i < TEST_ALIGN_END; i++) {
1244 		sg_init_one(&sg, test->buffer + i, size);
1245 		ret = mmc_test_transfer(test, &sg, 1, 0, size / 512, 512, 0);
1246 		if (ret)
1247 			return ret;
1248 	}
1249 
1250 	return 0;
1251 }
1252 
mmc_test_xfersize_write(struct mmc_test_card * test)1253 static int mmc_test_xfersize_write(struct mmc_test_card *test)
1254 {
1255 	int ret;
1256 
1257 	ret = mmc_test_set_blksize(test, 512);
1258 	if (ret)
1259 		return ret;
1260 
1261 	return mmc_test_broken_transfer(test, 1, 512, 1);
1262 }
1263 
mmc_test_xfersize_read(struct mmc_test_card * test)1264 static int mmc_test_xfersize_read(struct mmc_test_card *test)
1265 {
1266 	int ret;
1267 
1268 	ret = mmc_test_set_blksize(test, 512);
1269 	if (ret)
1270 		return ret;
1271 
1272 	return mmc_test_broken_transfer(test, 1, 512, 0);
1273 }
1274 
mmc_test_multi_xfersize_write(struct mmc_test_card * test)1275 static int mmc_test_multi_xfersize_write(struct mmc_test_card *test)
1276 {
1277 	int ret;
1278 
1279 	if (test->card->host->max_blk_count == 1)
1280 		return RESULT_UNSUP_HOST;
1281 
1282 	ret = mmc_test_set_blksize(test, 512);
1283 	if (ret)
1284 		return ret;
1285 
1286 	return mmc_test_broken_transfer(test, 2, 512, 1);
1287 }
1288 
mmc_test_multi_xfersize_read(struct mmc_test_card * test)1289 static int mmc_test_multi_xfersize_read(struct mmc_test_card *test)
1290 {
1291 	int ret;
1292 
1293 	if (test->card->host->max_blk_count == 1)
1294 		return RESULT_UNSUP_HOST;
1295 
1296 	ret = mmc_test_set_blksize(test, 512);
1297 	if (ret)
1298 		return ret;
1299 
1300 	return mmc_test_broken_transfer(test, 2, 512, 0);
1301 }
1302 
1303 #ifdef CONFIG_HIGHMEM
1304 
mmc_test_write_high(struct mmc_test_card * test)1305 static int mmc_test_write_high(struct mmc_test_card *test)
1306 {
1307 	struct scatterlist sg;
1308 
1309 	sg_init_table(&sg, 1);
1310 	sg_set_page(&sg, test->highmem, 512, 0);
1311 
1312 	return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
1313 }
1314 
mmc_test_read_high(struct mmc_test_card * test)1315 static int mmc_test_read_high(struct mmc_test_card *test)
1316 {
1317 	struct scatterlist sg;
1318 
1319 	sg_init_table(&sg, 1);
1320 	sg_set_page(&sg, test->highmem, 512, 0);
1321 
1322 	return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
1323 }
1324 
mmc_test_multi_write_high(struct mmc_test_card * test)1325 static int mmc_test_multi_write_high(struct mmc_test_card *test)
1326 {
1327 	unsigned int size;
1328 	struct scatterlist sg;
1329 
1330 	if (test->card->host->max_blk_count == 1)
1331 		return RESULT_UNSUP_HOST;
1332 
1333 	size = PAGE_SIZE * 2;
1334 	size = min(size, test->card->host->max_req_size);
1335 	size = min(size, test->card->host->max_seg_size);
1336 	size = min(size, test->card->host->max_blk_count * 512);
1337 
1338 	if (size < 1024)
1339 		return RESULT_UNSUP_HOST;
1340 
1341 	sg_init_table(&sg, 1);
1342 	sg_set_page(&sg, test->highmem, size, 0);
1343 
1344 	return mmc_test_transfer(test, &sg, 1, 0, size / 512, 512, 1);
1345 }
1346 
mmc_test_multi_read_high(struct mmc_test_card * test)1347 static int mmc_test_multi_read_high(struct mmc_test_card *test)
1348 {
1349 	unsigned int size;
1350 	struct scatterlist sg;
1351 
1352 	if (test->card->host->max_blk_count == 1)
1353 		return RESULT_UNSUP_HOST;
1354 
1355 	size = PAGE_SIZE * 2;
1356 	size = min(size, test->card->host->max_req_size);
1357 	size = min(size, test->card->host->max_seg_size);
1358 	size = min(size, test->card->host->max_blk_count * 512);
1359 
1360 	if (size < 1024)
1361 		return RESULT_UNSUP_HOST;
1362 
1363 	sg_init_table(&sg, 1);
1364 	sg_set_page(&sg, test->highmem, size, 0);
1365 
1366 	return mmc_test_transfer(test, &sg, 1, 0, size / 512, 512, 0);
1367 }
1368 
1369 #else
1370 
mmc_test_no_highmem(struct mmc_test_card * test)1371 static int mmc_test_no_highmem(struct mmc_test_card *test)
1372 {
1373 	pr_info("%s: Highmem not configured - test skipped\n",
1374 	       mmc_hostname(test->card->host));
1375 	return 0;
1376 }
1377 
1378 #endif /* CONFIG_HIGHMEM */
1379 
1380 /*
1381  * Map sz bytes so that it can be transferred.
1382  */
mmc_test_area_map(struct mmc_test_card * test,unsigned long sz,int max_scatter,int min_sg_len,bool nonblock)1383 static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
1384 			     int max_scatter, int min_sg_len, bool nonblock)
1385 {
1386 	struct mmc_test_area *t = &test->area;
1387 	int err;
1388 	unsigned int sg_len = 0;
1389 
1390 	t->blocks = sz >> 9;
1391 
1392 	if (max_scatter) {
1393 		err = mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
1394 						  t->max_segs, t->max_seg_sz,
1395 				       &t->sg_len);
1396 	} else {
1397 		err = mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
1398 				      t->max_seg_sz, &t->sg_len, min_sg_len);
1399 	}
1400 
1401 	if (err || !nonblock)
1402 		goto err;
1403 
1404 	if (max_scatter) {
1405 		err = mmc_test_map_sg_max_scatter(t->mem, sz, t->sg_areq,
1406 						  t->max_segs, t->max_seg_sz,
1407 						  &sg_len);
1408 	} else {
1409 		err = mmc_test_map_sg(t->mem, sz, t->sg_areq, 1, t->max_segs,
1410 				      t->max_seg_sz, &sg_len, min_sg_len);
1411 	}
1412 	if (!err && sg_len != t->sg_len)
1413 		err = -EINVAL;
1414 
1415 err:
1416 	if (err)
1417 		pr_info("%s: Failed to map sg list\n",
1418 		       mmc_hostname(test->card->host));
1419 	return err;
1420 }
1421 
1422 /*
1423  * Transfer bytes mapped by mmc_test_area_map().
1424  */
mmc_test_area_transfer(struct mmc_test_card * test,unsigned int dev_addr,int write)1425 static int mmc_test_area_transfer(struct mmc_test_card *test,
1426 				  unsigned int dev_addr, int write)
1427 {
1428 	struct mmc_test_area *t = &test->area;
1429 
1430 	return mmc_test_simple_transfer(test, t->sg, t->sg_len, dev_addr,
1431 					t->blocks, 512, write);
1432 }
1433 
1434 /*
1435  * Map and transfer bytes for multiple transfers.
1436  */
mmc_test_area_io_seq(struct mmc_test_card * test,unsigned long sz,unsigned int dev_addr,int write,int max_scatter,int timed,int count,bool nonblock,int min_sg_len)1437 static int mmc_test_area_io_seq(struct mmc_test_card *test, unsigned long sz,
1438 				unsigned int dev_addr, int write,
1439 				int max_scatter, int timed, int count,
1440 				bool nonblock, int min_sg_len)
1441 {
1442 	struct timespec64 ts1, ts2;
1443 	int ret = 0;
1444 	int i;
1445 
1446 	/*
1447 	 * In the case of a maximally scattered transfer, the maximum transfer
1448 	 * size is further limited by using PAGE_SIZE segments.
1449 	 */
1450 	if (max_scatter) {
1451 		struct mmc_test_area *t = &test->area;
1452 		unsigned long max_tfr;
1453 
1454 		if (t->max_seg_sz >= PAGE_SIZE)
1455 			max_tfr = t->max_segs * PAGE_SIZE;
1456 		else
1457 			max_tfr = t->max_segs * t->max_seg_sz;
1458 		if (sz > max_tfr)
1459 			sz = max_tfr;
1460 	}
1461 
1462 	ret = mmc_test_area_map(test, sz, max_scatter, min_sg_len, nonblock);
1463 	if (ret)
1464 		return ret;
1465 
1466 	if (timed)
1467 		ktime_get_ts64(&ts1);
1468 	if (nonblock)
1469 		ret = mmc_test_nonblock_transfer(test, dev_addr, write, count);
1470 	else
1471 		for (i = 0; i < count && ret == 0; i++) {
1472 			ret = mmc_test_area_transfer(test, dev_addr, write);
1473 			dev_addr += sz >> 9;
1474 		}
1475 
1476 	if (ret)
1477 		return ret;
1478 
1479 	if (timed)
1480 		ktime_get_ts64(&ts2);
1481 
1482 	if (timed)
1483 		mmc_test_print_avg_rate(test, sz, count, &ts1, &ts2);
1484 
1485 	return 0;
1486 }
1487 
mmc_test_area_io(struct mmc_test_card * test,unsigned long sz,unsigned int dev_addr,int write,int max_scatter,int timed)1488 static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
1489 			    unsigned int dev_addr, int write, int max_scatter,
1490 			    int timed)
1491 {
1492 	return mmc_test_area_io_seq(test, sz, dev_addr, write, max_scatter,
1493 				    timed, 1, false, 0);
1494 }
1495 
1496 /*
1497  * Write the test area entirely.
1498  */
mmc_test_area_fill(struct mmc_test_card * test)1499 static int mmc_test_area_fill(struct mmc_test_card *test)
1500 {
1501 	struct mmc_test_area *t = &test->area;
1502 
1503 	return mmc_test_area_io(test, t->max_tfr, t->dev_addr, 1, 0, 0);
1504 }
1505 
1506 /*
1507  * Erase the test area entirely.
1508  */
mmc_test_area_erase(struct mmc_test_card * test)1509 static int mmc_test_area_erase(struct mmc_test_card *test)
1510 {
1511 	struct mmc_test_area *t = &test->area;
1512 
1513 	if (!mmc_can_erase(test->card))
1514 		return 0;
1515 
1516 	return mmc_erase(test->card, t->dev_addr, t->max_sz >> 9,
1517 			 MMC_ERASE_ARG);
1518 }
1519 
1520 /*
1521  * Cleanup struct mmc_test_area.
1522  */
mmc_test_area_cleanup(struct mmc_test_card * test)1523 static int mmc_test_area_cleanup(struct mmc_test_card *test)
1524 {
1525 	struct mmc_test_area *t = &test->area;
1526 
1527 	kfree(t->sg);
1528 	kfree(t->sg_areq);
1529 	mmc_test_free_mem(t->mem);
1530 
1531 	return 0;
1532 }
1533 
1534 /*
1535  * Initialize an area for testing large transfers.  The test area is set to the
1536  * middle of the card because cards may have different characteristics at the
1537  * front (for FAT file system optimization).  Optionally, the area is erased
1538  * (if the card supports it) which may improve write performance.  Optionally,
1539  * the area is filled with data for subsequent read tests.
1540  */
mmc_test_area_init(struct mmc_test_card * test,int erase,int fill)1541 static int mmc_test_area_init(struct mmc_test_card *test, int erase, int fill)
1542 {
1543 	struct mmc_test_area *t = &test->area;
1544 	unsigned long min_sz = 64 * 1024, sz;
1545 	int ret;
1546 
1547 	ret = mmc_test_set_blksize(test, 512);
1548 	if (ret)
1549 		return ret;
1550 
1551 	/* Make the test area size about 4MiB */
1552 	sz = (unsigned long)test->card->pref_erase << 9;
1553 	t->max_sz = sz;
1554 	while (t->max_sz < 4 * 1024 * 1024)
1555 		t->max_sz += sz;
1556 	while (t->max_sz > TEST_AREA_MAX_SIZE && t->max_sz > sz)
1557 		t->max_sz -= sz;
1558 
1559 	t->max_segs = test->card->host->max_segs;
1560 	t->max_seg_sz = test->card->host->max_seg_size;
1561 	t->max_seg_sz -= t->max_seg_sz % 512;
1562 
1563 	t->max_tfr = t->max_sz;
1564 	if (t->max_tfr >> 9 > test->card->host->max_blk_count)
1565 		t->max_tfr = test->card->host->max_blk_count << 9;
1566 	if (t->max_tfr > test->card->host->max_req_size)
1567 		t->max_tfr = test->card->host->max_req_size;
1568 	if (t->max_tfr / t->max_seg_sz > t->max_segs)
1569 		t->max_tfr = t->max_segs * t->max_seg_sz;
1570 
1571 	/*
1572 	 * Try to allocate enough memory for a max. sized transfer.  Less is OK
1573 	 * because the same memory can be mapped into the scatterlist more than
1574 	 * once.  Also, take into account the limits imposed on scatterlist
1575 	 * segments by the host driver.
1576 	 */
1577 	t->mem = mmc_test_alloc_mem(min_sz, t->max_tfr, t->max_segs,
1578 				    t->max_seg_sz);
1579 	if (!t->mem)
1580 		return -ENOMEM;
1581 
1582 	t->sg = kmalloc_array(t->max_segs, sizeof(*t->sg), GFP_KERNEL);
1583 	if (!t->sg) {
1584 		ret = -ENOMEM;
1585 		goto out_free;
1586 	}
1587 
1588 	t->sg_areq = kmalloc_array(t->max_segs, sizeof(*t->sg_areq),
1589 				   GFP_KERNEL);
1590 	if (!t->sg_areq) {
1591 		ret = -ENOMEM;
1592 		goto out_free;
1593 	}
1594 
1595 	t->dev_addr = mmc_test_capacity(test->card) / 2;
1596 	t->dev_addr -= t->dev_addr % (t->max_sz >> 9);
1597 
1598 	if (erase) {
1599 		ret = mmc_test_area_erase(test);
1600 		if (ret)
1601 			goto out_free;
1602 	}
1603 
1604 	if (fill) {
1605 		ret = mmc_test_area_fill(test);
1606 		if (ret)
1607 			goto out_free;
1608 	}
1609 
1610 	return 0;
1611 
1612 out_free:
1613 	mmc_test_area_cleanup(test);
1614 	return ret;
1615 }
1616 
1617 /*
1618  * Prepare for large transfers.  Do not erase the test area.
1619  */
mmc_test_area_prepare(struct mmc_test_card * test)1620 static int mmc_test_area_prepare(struct mmc_test_card *test)
1621 {
1622 	return mmc_test_area_init(test, 0, 0);
1623 }
1624 
1625 /*
1626  * Prepare for large transfers.  Do erase the test area.
1627  */
mmc_test_area_prepare_erase(struct mmc_test_card * test)1628 static int mmc_test_area_prepare_erase(struct mmc_test_card *test)
1629 {
1630 	return mmc_test_area_init(test, 1, 0);
1631 }
1632 
1633 /*
1634  * Prepare for large transfers.  Erase and fill the test area.
1635  */
mmc_test_area_prepare_fill(struct mmc_test_card * test)1636 static int mmc_test_area_prepare_fill(struct mmc_test_card *test)
1637 {
1638 	return mmc_test_area_init(test, 1, 1);
1639 }
1640 
1641 /*
1642  * Test best-case performance.  Best-case performance is expected from
1643  * a single large transfer.
1644  *
1645  * An additional option (max_scatter) allows the measurement of the same
1646  * transfer but with no contiguous pages in the scatter list.  This tests
1647  * the efficiency of DMA to handle scattered pages.
1648  */
mmc_test_best_performance(struct mmc_test_card * test,int write,int max_scatter)1649 static int mmc_test_best_performance(struct mmc_test_card *test, int write,
1650 				     int max_scatter)
1651 {
1652 	struct mmc_test_area *t = &test->area;
1653 
1654 	return mmc_test_area_io(test, t->max_tfr, t->dev_addr, write,
1655 				max_scatter, 1);
1656 }
1657 
1658 /*
1659  * Best-case read performance.
1660  */
mmc_test_best_read_performance(struct mmc_test_card * test)1661 static int mmc_test_best_read_performance(struct mmc_test_card *test)
1662 {
1663 	return mmc_test_best_performance(test, 0, 0);
1664 }
1665 
1666 /*
1667  * Best-case write performance.
1668  */
mmc_test_best_write_performance(struct mmc_test_card * test)1669 static int mmc_test_best_write_performance(struct mmc_test_card *test)
1670 {
1671 	return mmc_test_best_performance(test, 1, 0);
1672 }
1673 
1674 /*
1675  * Best-case read performance into scattered pages.
1676  */
mmc_test_best_read_perf_max_scatter(struct mmc_test_card * test)1677 static int mmc_test_best_read_perf_max_scatter(struct mmc_test_card *test)
1678 {
1679 	return mmc_test_best_performance(test, 0, 1);
1680 }
1681 
1682 /*
1683  * Best-case write performance from scattered pages.
1684  */
mmc_test_best_write_perf_max_scatter(struct mmc_test_card * test)1685 static int mmc_test_best_write_perf_max_scatter(struct mmc_test_card *test)
1686 {
1687 	return mmc_test_best_performance(test, 1, 1);
1688 }
1689 
1690 /*
1691  * Single read performance by transfer size.
1692  */
mmc_test_profile_read_perf(struct mmc_test_card * test)1693 static int mmc_test_profile_read_perf(struct mmc_test_card *test)
1694 {
1695 	struct mmc_test_area *t = &test->area;
1696 	unsigned long sz;
1697 	unsigned int dev_addr;
1698 	int ret;
1699 
1700 	for (sz = 512; sz < t->max_tfr; sz <<= 1) {
1701 		dev_addr = t->dev_addr + (sz >> 9);
1702 		ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
1703 		if (ret)
1704 			return ret;
1705 	}
1706 	sz = t->max_tfr;
1707 	dev_addr = t->dev_addr;
1708 	return mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
1709 }
1710 
1711 /*
1712  * Single write performance by transfer size.
1713  */
mmc_test_profile_write_perf(struct mmc_test_card * test)1714 static int mmc_test_profile_write_perf(struct mmc_test_card *test)
1715 {
1716 	struct mmc_test_area *t = &test->area;
1717 	unsigned long sz;
1718 	unsigned int dev_addr;
1719 	int ret;
1720 
1721 	ret = mmc_test_area_erase(test);
1722 	if (ret)
1723 		return ret;
1724 	for (sz = 512; sz < t->max_tfr; sz <<= 1) {
1725 		dev_addr = t->dev_addr + (sz >> 9);
1726 		ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
1727 		if (ret)
1728 			return ret;
1729 	}
1730 	ret = mmc_test_area_erase(test);
1731 	if (ret)
1732 		return ret;
1733 	sz = t->max_tfr;
1734 	dev_addr = t->dev_addr;
1735 	return mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
1736 }
1737 
1738 /*
1739  * Single trim performance by transfer size.
1740  */
mmc_test_profile_trim_perf(struct mmc_test_card * test)1741 static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
1742 {
1743 	struct mmc_test_area *t = &test->area;
1744 	unsigned long sz;
1745 	unsigned int dev_addr;
1746 	struct timespec64 ts1, ts2;
1747 	int ret;
1748 
1749 	if (!mmc_can_trim(test->card))
1750 		return RESULT_UNSUP_CARD;
1751 
1752 	if (!mmc_can_erase(test->card))
1753 		return RESULT_UNSUP_HOST;
1754 
1755 	for (sz = 512; sz < t->max_sz; sz <<= 1) {
1756 		dev_addr = t->dev_addr + (sz >> 9);
1757 		ktime_get_ts64(&ts1);
1758 		ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
1759 		if (ret)
1760 			return ret;
1761 		ktime_get_ts64(&ts2);
1762 		mmc_test_print_rate(test, sz, &ts1, &ts2);
1763 	}
1764 	dev_addr = t->dev_addr;
1765 	ktime_get_ts64(&ts1);
1766 	ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
1767 	if (ret)
1768 		return ret;
1769 	ktime_get_ts64(&ts2);
1770 	mmc_test_print_rate(test, sz, &ts1, &ts2);
1771 	return 0;
1772 }
1773 
mmc_test_seq_read_perf(struct mmc_test_card * test,unsigned long sz)1774 static int mmc_test_seq_read_perf(struct mmc_test_card *test, unsigned long sz)
1775 {
1776 	struct mmc_test_area *t = &test->area;
1777 	unsigned int dev_addr, i, cnt;
1778 	struct timespec64 ts1, ts2;
1779 	int ret;
1780 
1781 	cnt = t->max_sz / sz;
1782 	dev_addr = t->dev_addr;
1783 	ktime_get_ts64(&ts1);
1784 	for (i = 0; i < cnt; i++) {
1785 		ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
1786 		if (ret)
1787 			return ret;
1788 		dev_addr += (sz >> 9);
1789 	}
1790 	ktime_get_ts64(&ts2);
1791 	mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1792 	return 0;
1793 }
1794 
1795 /*
1796  * Consecutive read performance by transfer size.
1797  */
mmc_test_profile_seq_read_perf(struct mmc_test_card * test)1798 static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
1799 {
1800 	struct mmc_test_area *t = &test->area;
1801 	unsigned long sz;
1802 	int ret;
1803 
1804 	for (sz = 512; sz < t->max_tfr; sz <<= 1) {
1805 		ret = mmc_test_seq_read_perf(test, sz);
1806 		if (ret)
1807 			return ret;
1808 	}
1809 	sz = t->max_tfr;
1810 	return mmc_test_seq_read_perf(test, sz);
1811 }
1812 
mmc_test_seq_write_perf(struct mmc_test_card * test,unsigned long sz)1813 static int mmc_test_seq_write_perf(struct mmc_test_card *test, unsigned long sz)
1814 {
1815 	struct mmc_test_area *t = &test->area;
1816 	unsigned int dev_addr, i, cnt;
1817 	struct timespec64 ts1, ts2;
1818 	int ret;
1819 
1820 	ret = mmc_test_area_erase(test);
1821 	if (ret)
1822 		return ret;
1823 	cnt = t->max_sz / sz;
1824 	dev_addr = t->dev_addr;
1825 	ktime_get_ts64(&ts1);
1826 	for (i = 0; i < cnt; i++) {
1827 		ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
1828 		if (ret)
1829 			return ret;
1830 		dev_addr += (sz >> 9);
1831 	}
1832 	ktime_get_ts64(&ts2);
1833 	mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1834 	return 0;
1835 }
1836 
1837 /*
1838  * Consecutive write performance by transfer size.
1839  */
mmc_test_profile_seq_write_perf(struct mmc_test_card * test)1840 static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
1841 {
1842 	struct mmc_test_area *t = &test->area;
1843 	unsigned long sz;
1844 	int ret;
1845 
1846 	for (sz = 512; sz < t->max_tfr; sz <<= 1) {
1847 		ret = mmc_test_seq_write_perf(test, sz);
1848 		if (ret)
1849 			return ret;
1850 	}
1851 	sz = t->max_tfr;
1852 	return mmc_test_seq_write_perf(test, sz);
1853 }
1854 
1855 /*
1856  * Consecutive trim performance by transfer size.
1857  */
mmc_test_profile_seq_trim_perf(struct mmc_test_card * test)1858 static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
1859 {
1860 	struct mmc_test_area *t = &test->area;
1861 	unsigned long sz;
1862 	unsigned int dev_addr, i, cnt;
1863 	struct timespec64 ts1, ts2;
1864 	int ret;
1865 
1866 	if (!mmc_can_trim(test->card))
1867 		return RESULT_UNSUP_CARD;
1868 
1869 	if (!mmc_can_erase(test->card))
1870 		return RESULT_UNSUP_HOST;
1871 
1872 	for (sz = 512; sz <= t->max_sz; sz <<= 1) {
1873 		ret = mmc_test_area_erase(test);
1874 		if (ret)
1875 			return ret;
1876 		ret = mmc_test_area_fill(test);
1877 		if (ret)
1878 			return ret;
1879 		cnt = t->max_sz / sz;
1880 		dev_addr = t->dev_addr;
1881 		ktime_get_ts64(&ts1);
1882 		for (i = 0; i < cnt; i++) {
1883 			ret = mmc_erase(test->card, dev_addr, sz >> 9,
1884 					MMC_TRIM_ARG);
1885 			if (ret)
1886 				return ret;
1887 			dev_addr += (sz >> 9);
1888 		}
1889 		ktime_get_ts64(&ts2);
1890 		mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1891 	}
1892 	return 0;
1893 }
1894 
1895 static unsigned int rnd_next = 1;
1896 
mmc_test_rnd_num(unsigned int rnd_cnt)1897 static unsigned int mmc_test_rnd_num(unsigned int rnd_cnt)
1898 {
1899 	uint64_t r;
1900 
1901 	rnd_next = rnd_next * 1103515245 + 12345;
1902 	r = (rnd_next >> 16) & 0x7fff;
1903 	return (r * rnd_cnt) >> 15;
1904 }
1905 
mmc_test_rnd_perf(struct mmc_test_card * test,int write,int print,unsigned long sz)1906 static int mmc_test_rnd_perf(struct mmc_test_card *test, int write, int print,
1907 			     unsigned long sz)
1908 {
1909 	unsigned int dev_addr, cnt, rnd_addr, range1, range2, last_ea = 0, ea;
1910 	unsigned int ssz;
1911 	struct timespec64 ts1, ts2, ts;
1912 	int ret;
1913 
1914 	ssz = sz >> 9;
1915 
1916 	rnd_addr = mmc_test_capacity(test->card) / 4;
1917 	range1 = rnd_addr / test->card->pref_erase;
1918 	range2 = range1 / ssz;
1919 
1920 	ktime_get_ts64(&ts1);
1921 	for (cnt = 0; cnt < UINT_MAX; cnt++) {
1922 		ktime_get_ts64(&ts2);
1923 		ts = timespec64_sub(ts2, ts1);
1924 		if (ts.tv_sec >= 10)
1925 			break;
1926 		ea = mmc_test_rnd_num(range1);
1927 		if (ea == last_ea)
1928 			ea -= 1;
1929 		last_ea = ea;
1930 		dev_addr = rnd_addr + test->card->pref_erase * ea +
1931 			   ssz * mmc_test_rnd_num(range2);
1932 		ret = mmc_test_area_io(test, sz, dev_addr, write, 0, 0);
1933 		if (ret)
1934 			return ret;
1935 	}
1936 	if (print)
1937 		mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1938 	return 0;
1939 }
1940 
mmc_test_random_perf(struct mmc_test_card * test,int write)1941 static int mmc_test_random_perf(struct mmc_test_card *test, int write)
1942 {
1943 	struct mmc_test_area *t = &test->area;
1944 	unsigned int next;
1945 	unsigned long sz;
1946 	int ret;
1947 
1948 	for (sz = 512; sz < t->max_tfr; sz <<= 1) {
1949 		/*
1950 		 * When writing, try to get more consistent results by running
1951 		 * the test twice with exactly the same I/O but outputting the
1952 		 * results only for the 2nd run.
1953 		 */
1954 		if (write) {
1955 			next = rnd_next;
1956 			ret = mmc_test_rnd_perf(test, write, 0, sz);
1957 			if (ret)
1958 				return ret;
1959 			rnd_next = next;
1960 		}
1961 		ret = mmc_test_rnd_perf(test, write, 1, sz);
1962 		if (ret)
1963 			return ret;
1964 	}
1965 	sz = t->max_tfr;
1966 	if (write) {
1967 		next = rnd_next;
1968 		ret = mmc_test_rnd_perf(test, write, 0, sz);
1969 		if (ret)
1970 			return ret;
1971 		rnd_next = next;
1972 	}
1973 	return mmc_test_rnd_perf(test, write, 1, sz);
1974 }
1975 
1976 /*
1977  * Random read performance by transfer size.
1978  */
mmc_test_random_read_perf(struct mmc_test_card * test)1979 static int mmc_test_random_read_perf(struct mmc_test_card *test)
1980 {
1981 	return mmc_test_random_perf(test, 0);
1982 }
1983 
1984 /*
1985  * Random write performance by transfer size.
1986  */
mmc_test_random_write_perf(struct mmc_test_card * test)1987 static int mmc_test_random_write_perf(struct mmc_test_card *test)
1988 {
1989 	return mmc_test_random_perf(test, 1);
1990 }
1991 
mmc_test_seq_perf(struct mmc_test_card * test,int write,unsigned int tot_sz,int max_scatter)1992 static int mmc_test_seq_perf(struct mmc_test_card *test, int write,
1993 			     unsigned int tot_sz, int max_scatter)
1994 {
1995 	struct mmc_test_area *t = &test->area;
1996 	unsigned int dev_addr, i, cnt, sz, ssz;
1997 	struct timespec64 ts1, ts2;
1998 	int ret;
1999 
2000 	sz = t->max_tfr;
2001 
2002 	/*
2003 	 * In the case of a maximally scattered transfer, the maximum transfer
2004 	 * size is further limited by using PAGE_SIZE segments.
2005 	 */
2006 	if (max_scatter) {
2007 		unsigned long max_tfr;
2008 
2009 		if (t->max_seg_sz >= PAGE_SIZE)
2010 			max_tfr = t->max_segs * PAGE_SIZE;
2011 		else
2012 			max_tfr = t->max_segs * t->max_seg_sz;
2013 		if (sz > max_tfr)
2014 			sz = max_tfr;
2015 	}
2016 
2017 	ssz = sz >> 9;
2018 	dev_addr = mmc_test_capacity(test->card) / 4;
2019 	if (tot_sz > dev_addr << 9)
2020 		tot_sz = dev_addr << 9;
2021 	cnt = tot_sz / sz;
2022 	dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
2023 
2024 	ktime_get_ts64(&ts1);
2025 	for (i = 0; i < cnt; i++) {
2026 		ret = mmc_test_area_io(test, sz, dev_addr, write,
2027 				       max_scatter, 0);
2028 		if (ret)
2029 			return ret;
2030 		dev_addr += ssz;
2031 	}
2032 	ktime_get_ts64(&ts2);
2033 
2034 	mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
2035 
2036 	return 0;
2037 }
2038 
mmc_test_large_seq_perf(struct mmc_test_card * test,int write)2039 static int mmc_test_large_seq_perf(struct mmc_test_card *test, int write)
2040 {
2041 	int ret, i;
2042 
2043 	for (i = 0; i < 10; i++) {
2044 		ret = mmc_test_seq_perf(test, write, 10 * 1024 * 1024, 1);
2045 		if (ret)
2046 			return ret;
2047 	}
2048 	for (i = 0; i < 5; i++) {
2049 		ret = mmc_test_seq_perf(test, write, 100 * 1024 * 1024, 1);
2050 		if (ret)
2051 			return ret;
2052 	}
2053 	for (i = 0; i < 3; i++) {
2054 		ret = mmc_test_seq_perf(test, write, 1000 * 1024 * 1024, 1);
2055 		if (ret)
2056 			return ret;
2057 	}
2058 
2059 	return ret;
2060 }
2061 
2062 /*
2063  * Large sequential read performance.
2064  */
mmc_test_large_seq_read_perf(struct mmc_test_card * test)2065 static int mmc_test_large_seq_read_perf(struct mmc_test_card *test)
2066 {
2067 	return mmc_test_large_seq_perf(test, 0);
2068 }
2069 
2070 /*
2071  * Large sequential write performance.
2072  */
mmc_test_large_seq_write_perf(struct mmc_test_card * test)2073 static int mmc_test_large_seq_write_perf(struct mmc_test_card *test)
2074 {
2075 	return mmc_test_large_seq_perf(test, 1);
2076 }
2077 
mmc_test_rw_multiple(struct mmc_test_card * test,struct mmc_test_multiple_rw * tdata,unsigned int reqsize,unsigned int size,int min_sg_len)2078 static int mmc_test_rw_multiple(struct mmc_test_card *test,
2079 				struct mmc_test_multiple_rw *tdata,
2080 				unsigned int reqsize, unsigned int size,
2081 				int min_sg_len)
2082 {
2083 	unsigned int dev_addr;
2084 	struct mmc_test_area *t = &test->area;
2085 	int ret = 0;
2086 
2087 	/* Set up test area */
2088 	if (size > mmc_test_capacity(test->card) / 2 * 512)
2089 		size = mmc_test_capacity(test->card) / 2 * 512;
2090 	if (reqsize > t->max_tfr)
2091 		reqsize = t->max_tfr;
2092 	dev_addr = mmc_test_capacity(test->card) / 4;
2093 	if ((dev_addr & 0xffff0000))
2094 		dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
2095 	else
2096 		dev_addr &= 0xfffff800; /* Round to 1MiB boundary */
2097 	if (!dev_addr)
2098 		goto err;
2099 
2100 	if (reqsize > size)
2101 		return 0;
2102 
2103 	/* prepare test area */
2104 	if (mmc_can_erase(test->card) &&
2105 	    tdata->prepare & MMC_TEST_PREP_ERASE) {
2106 		ret = mmc_erase(test->card, dev_addr,
2107 				size / 512, test->card->erase_arg);
2108 		if (ret)
2109 			ret = mmc_erase(test->card, dev_addr,
2110 					size / 512, MMC_ERASE_ARG);
2111 		if (ret)
2112 			goto err;
2113 	}
2114 
2115 	/* Run test */
2116 	ret = mmc_test_area_io_seq(test, reqsize, dev_addr,
2117 				   tdata->do_write, 0, 1, size / reqsize,
2118 				   tdata->do_nonblock_req, min_sg_len);
2119 	if (ret)
2120 		goto err;
2121 
2122 	return ret;
2123  err:
2124 	pr_info("[%s] error\n", __func__);
2125 	return ret;
2126 }
2127 
mmc_test_rw_multiple_size(struct mmc_test_card * test,struct mmc_test_multiple_rw * rw)2128 static int mmc_test_rw_multiple_size(struct mmc_test_card *test,
2129 				     struct mmc_test_multiple_rw *rw)
2130 {
2131 	int ret = 0;
2132 	int i;
2133 	void *pre_req = test->card->host->ops->pre_req;
2134 	void *post_req = test->card->host->ops->post_req;
2135 
2136 	if (rw->do_nonblock_req &&
2137 	    ((!pre_req && post_req) || (pre_req && !post_req))) {
2138 		pr_info("error: only one of pre/post is defined\n");
2139 		return -EINVAL;
2140 	}
2141 
2142 	for (i = 0 ; i < rw->len && ret == 0; i++) {
2143 		ret = mmc_test_rw_multiple(test, rw, rw->bs[i], rw->size, 0);
2144 		if (ret)
2145 			break;
2146 	}
2147 	return ret;
2148 }
2149 
mmc_test_rw_multiple_sg_len(struct mmc_test_card * test,struct mmc_test_multiple_rw * rw)2150 static int mmc_test_rw_multiple_sg_len(struct mmc_test_card *test,
2151 				       struct mmc_test_multiple_rw *rw)
2152 {
2153 	int ret = 0;
2154 	int i;
2155 
2156 	for (i = 0 ; i < rw->len && ret == 0; i++) {
2157 		ret = mmc_test_rw_multiple(test, rw, 512 * 1024, rw->size,
2158 					   rw->sg_len[i]);
2159 		if (ret)
2160 			break;
2161 	}
2162 	return ret;
2163 }
2164 
2165 /*
2166  * Multiple blocking write 4k to 4 MB chunks
2167  */
mmc_test_profile_mult_write_blocking_perf(struct mmc_test_card * test)2168 static int mmc_test_profile_mult_write_blocking_perf(struct mmc_test_card *test)
2169 {
2170 	unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
2171 			     1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
2172 	struct mmc_test_multiple_rw test_data = {
2173 		.bs = bs,
2174 		.size = TEST_AREA_MAX_SIZE,
2175 		.len = ARRAY_SIZE(bs),
2176 		.do_write = true,
2177 		.do_nonblock_req = false,
2178 		.prepare = MMC_TEST_PREP_ERASE,
2179 	};
2180 
2181 	return mmc_test_rw_multiple_size(test, &test_data);
2182 };
2183 
2184 /*
2185  * Multiple non-blocking write 4k to 4 MB chunks
2186  */
mmc_test_profile_mult_write_nonblock_perf(struct mmc_test_card * test)2187 static int mmc_test_profile_mult_write_nonblock_perf(struct mmc_test_card *test)
2188 {
2189 	unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
2190 			     1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
2191 	struct mmc_test_multiple_rw test_data = {
2192 		.bs = bs,
2193 		.size = TEST_AREA_MAX_SIZE,
2194 		.len = ARRAY_SIZE(bs),
2195 		.do_write = true,
2196 		.do_nonblock_req = true,
2197 		.prepare = MMC_TEST_PREP_ERASE,
2198 	};
2199 
2200 	return mmc_test_rw_multiple_size(test, &test_data);
2201 }
2202 
2203 /*
2204  * Multiple blocking read 4k to 4 MB chunks
2205  */
mmc_test_profile_mult_read_blocking_perf(struct mmc_test_card * test)2206 static int mmc_test_profile_mult_read_blocking_perf(struct mmc_test_card *test)
2207 {
2208 	unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
2209 			     1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
2210 	struct mmc_test_multiple_rw test_data = {
2211 		.bs = bs,
2212 		.size = TEST_AREA_MAX_SIZE,
2213 		.len = ARRAY_SIZE(bs),
2214 		.do_write = false,
2215 		.do_nonblock_req = false,
2216 		.prepare = MMC_TEST_PREP_NONE,
2217 	};
2218 
2219 	return mmc_test_rw_multiple_size(test, &test_data);
2220 }
2221 
2222 /*
2223  * Multiple non-blocking read 4k to 4 MB chunks
2224  */
mmc_test_profile_mult_read_nonblock_perf(struct mmc_test_card * test)2225 static int mmc_test_profile_mult_read_nonblock_perf(struct mmc_test_card *test)
2226 {
2227 	unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
2228 			     1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
2229 	struct mmc_test_multiple_rw test_data = {
2230 		.bs = bs,
2231 		.size = TEST_AREA_MAX_SIZE,
2232 		.len = ARRAY_SIZE(bs),
2233 		.do_write = false,
2234 		.do_nonblock_req = true,
2235 		.prepare = MMC_TEST_PREP_NONE,
2236 	};
2237 
2238 	return mmc_test_rw_multiple_size(test, &test_data);
2239 }
2240 
2241 /*
2242  * Multiple blocking write 1 to 512 sg elements
2243  */
mmc_test_profile_sglen_wr_blocking_perf(struct mmc_test_card * test)2244 static int mmc_test_profile_sglen_wr_blocking_perf(struct mmc_test_card *test)
2245 {
2246 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
2247 				 1 << 7, 1 << 8, 1 << 9};
2248 	struct mmc_test_multiple_rw test_data = {
2249 		.sg_len = sg_len,
2250 		.size = TEST_AREA_MAX_SIZE,
2251 		.len = ARRAY_SIZE(sg_len),
2252 		.do_write = true,
2253 		.do_nonblock_req = false,
2254 		.prepare = MMC_TEST_PREP_ERASE,
2255 	};
2256 
2257 	return mmc_test_rw_multiple_sg_len(test, &test_data);
2258 };
2259 
2260 /*
2261  * Multiple non-blocking write 1 to 512 sg elements
2262  */
mmc_test_profile_sglen_wr_nonblock_perf(struct mmc_test_card * test)2263 static int mmc_test_profile_sglen_wr_nonblock_perf(struct mmc_test_card *test)
2264 {
2265 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
2266 				 1 << 7, 1 << 8, 1 << 9};
2267 	struct mmc_test_multiple_rw test_data = {
2268 		.sg_len = sg_len,
2269 		.size = TEST_AREA_MAX_SIZE,
2270 		.len = ARRAY_SIZE(sg_len),
2271 		.do_write = true,
2272 		.do_nonblock_req = true,
2273 		.prepare = MMC_TEST_PREP_ERASE,
2274 	};
2275 
2276 	return mmc_test_rw_multiple_sg_len(test, &test_data);
2277 }
2278 
2279 /*
2280  * Multiple blocking read 1 to 512 sg elements
2281  */
mmc_test_profile_sglen_r_blocking_perf(struct mmc_test_card * test)2282 static int mmc_test_profile_sglen_r_blocking_perf(struct mmc_test_card *test)
2283 {
2284 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
2285 				 1 << 7, 1 << 8, 1 << 9};
2286 	struct mmc_test_multiple_rw test_data = {
2287 		.sg_len = sg_len,
2288 		.size = TEST_AREA_MAX_SIZE,
2289 		.len = ARRAY_SIZE(sg_len),
2290 		.do_write = false,
2291 		.do_nonblock_req = false,
2292 		.prepare = MMC_TEST_PREP_NONE,
2293 	};
2294 
2295 	return mmc_test_rw_multiple_sg_len(test, &test_data);
2296 }
2297 
2298 /*
2299  * Multiple non-blocking read 1 to 512 sg elements
2300  */
mmc_test_profile_sglen_r_nonblock_perf(struct mmc_test_card * test)2301 static int mmc_test_profile_sglen_r_nonblock_perf(struct mmc_test_card *test)
2302 {
2303 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
2304 				 1 << 7, 1 << 8, 1 << 9};
2305 	struct mmc_test_multiple_rw test_data = {
2306 		.sg_len = sg_len,
2307 		.size = TEST_AREA_MAX_SIZE,
2308 		.len = ARRAY_SIZE(sg_len),
2309 		.do_write = false,
2310 		.do_nonblock_req = true,
2311 		.prepare = MMC_TEST_PREP_NONE,
2312 	};
2313 
2314 	return mmc_test_rw_multiple_sg_len(test, &test_data);
2315 }
2316 
2317 /*
2318  * eMMC hardware reset.
2319  */
mmc_test_reset(struct mmc_test_card * test)2320 static int mmc_test_reset(struct mmc_test_card *test)
2321 {
2322 	struct mmc_card *card = test->card;
2323 	int err;
2324 
2325 	err = mmc_hw_reset(card);
2326 	if (!err) {
2327 		/*
2328 		 * Reset will re-enable the card's command queue, but tests
2329 		 * expect it to be disabled.
2330 		 */
2331 		if (card->ext_csd.cmdq_en)
2332 			mmc_cmdq_disable(card);
2333 		return RESULT_OK;
2334 	} else if (err == -EOPNOTSUPP) {
2335 		return RESULT_UNSUP_HOST;
2336 	}
2337 
2338 	return RESULT_FAIL;
2339 }
2340 
mmc_test_send_status(struct mmc_test_card * test,struct mmc_command * cmd)2341 static int mmc_test_send_status(struct mmc_test_card *test,
2342 				struct mmc_command *cmd)
2343 {
2344 	memset(cmd, 0, sizeof(*cmd));
2345 
2346 	cmd->opcode = MMC_SEND_STATUS;
2347 	if (!mmc_host_is_spi(test->card->host))
2348 		cmd->arg = test->card->rca << 16;
2349 	cmd->flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
2350 
2351 	return mmc_wait_for_cmd(test->card->host, cmd, 0);
2352 }
2353 
mmc_test_ongoing_transfer(struct mmc_test_card * test,unsigned int dev_addr,int use_sbc,int repeat_cmd,int write,int use_areq)2354 static int mmc_test_ongoing_transfer(struct mmc_test_card *test,
2355 				     unsigned int dev_addr, int use_sbc,
2356 				     int repeat_cmd, int write, int use_areq)
2357 {
2358 	struct mmc_test_req *rq = mmc_test_req_alloc();
2359 	struct mmc_host *host = test->card->host;
2360 	struct mmc_test_area *t = &test->area;
2361 	struct mmc_request *mrq;
2362 	unsigned long timeout;
2363 	bool expired = false;
2364 	int ret = 0, cmd_ret;
2365 	u32 status = 0;
2366 	int count = 0;
2367 
2368 	if (!rq)
2369 		return -ENOMEM;
2370 
2371 	mrq = &rq->mrq;
2372 	if (use_sbc)
2373 		mrq->sbc = &rq->sbc;
2374 	mrq->cap_cmd_during_tfr = true;
2375 
2376 	mmc_test_prepare_mrq(test, mrq, t->sg, t->sg_len, dev_addr, t->blocks,
2377 			     512, write);
2378 
2379 	if (use_sbc && t->blocks > 1 && !mrq->sbc) {
2380 		ret =  mmc_host_cmd23(host) ?
2381 		       RESULT_UNSUP_CARD :
2382 		       RESULT_UNSUP_HOST;
2383 		goto out_free;
2384 	}
2385 
2386 	/* Start ongoing data request */
2387 	if (use_areq) {
2388 		ret = mmc_test_start_areq(test, mrq, NULL);
2389 		if (ret)
2390 			goto out_free;
2391 	} else {
2392 		mmc_wait_for_req(host, mrq);
2393 	}
2394 
2395 	timeout = jiffies + msecs_to_jiffies(3000);
2396 	do {
2397 		count += 1;
2398 
2399 		/* Send status command while data transfer in progress */
2400 		cmd_ret = mmc_test_send_status(test, &rq->status);
2401 		if (cmd_ret)
2402 			break;
2403 
2404 		status = rq->status.resp[0];
2405 		if (status & R1_ERROR) {
2406 			cmd_ret = -EIO;
2407 			break;
2408 		}
2409 
2410 		if (mmc_is_req_done(host, mrq))
2411 			break;
2412 
2413 		expired = time_after(jiffies, timeout);
2414 		if (expired) {
2415 			pr_info("%s: timeout waiting for Tran state status %#x\n",
2416 				mmc_hostname(host), status);
2417 			cmd_ret = -ETIMEDOUT;
2418 			break;
2419 		}
2420 	} while (repeat_cmd && R1_CURRENT_STATE(status) != R1_STATE_TRAN);
2421 
2422 	/* Wait for data request to complete */
2423 	if (use_areq) {
2424 		ret = mmc_test_start_areq(test, NULL, mrq);
2425 	} else {
2426 		mmc_wait_for_req_done(test->card->host, mrq);
2427 	}
2428 
2429 	/*
2430 	 * For cap_cmd_during_tfr request, upper layer must send stop if
2431 	 * required.
2432 	 */
2433 	if (mrq->data->stop && (mrq->data->error || !mrq->sbc)) {
2434 		if (ret)
2435 			mmc_wait_for_cmd(host, mrq->data->stop, 0);
2436 		else
2437 			ret = mmc_wait_for_cmd(host, mrq->data->stop, 0);
2438 	}
2439 
2440 	if (ret)
2441 		goto out_free;
2442 
2443 	if (cmd_ret) {
2444 		pr_info("%s: Send Status failed: status %#x, error %d\n",
2445 			mmc_hostname(test->card->host), status, cmd_ret);
2446 	}
2447 
2448 	ret = mmc_test_check_result(test, mrq);
2449 	if (ret)
2450 		goto out_free;
2451 
2452 	ret = mmc_test_wait_busy(test);
2453 	if (ret)
2454 		goto out_free;
2455 
2456 	if (repeat_cmd && (t->blocks + 1) << 9 > t->max_tfr)
2457 		pr_info("%s: %d commands completed during transfer of %u blocks\n",
2458 			mmc_hostname(test->card->host), count, t->blocks);
2459 
2460 	if (cmd_ret)
2461 		ret = cmd_ret;
2462 out_free:
2463 	kfree(rq);
2464 
2465 	return ret;
2466 }
2467 
__mmc_test_cmds_during_tfr(struct mmc_test_card * test,unsigned long sz,int use_sbc,int write,int use_areq)2468 static int __mmc_test_cmds_during_tfr(struct mmc_test_card *test,
2469 				      unsigned long sz, int use_sbc, int write,
2470 				      int use_areq)
2471 {
2472 	struct mmc_test_area *t = &test->area;
2473 	int ret;
2474 
2475 	if (!(test->card->host->caps & MMC_CAP_CMD_DURING_TFR))
2476 		return RESULT_UNSUP_HOST;
2477 
2478 	ret = mmc_test_area_map(test, sz, 0, 0, use_areq);
2479 	if (ret)
2480 		return ret;
2481 
2482 	ret = mmc_test_ongoing_transfer(test, t->dev_addr, use_sbc, 0, write,
2483 					use_areq);
2484 	if (ret)
2485 		return ret;
2486 
2487 	return mmc_test_ongoing_transfer(test, t->dev_addr, use_sbc, 1, write,
2488 					 use_areq);
2489 }
2490 
mmc_test_cmds_during_tfr(struct mmc_test_card * test,int use_sbc,int write,int use_areq)2491 static int mmc_test_cmds_during_tfr(struct mmc_test_card *test, int use_sbc,
2492 				    int write, int use_areq)
2493 {
2494 	struct mmc_test_area *t = &test->area;
2495 	unsigned long sz;
2496 	int ret;
2497 
2498 	for (sz = 512; sz <= t->max_tfr; sz += 512) {
2499 		ret = __mmc_test_cmds_during_tfr(test, sz, use_sbc, write,
2500 						 use_areq);
2501 		if (ret)
2502 			return ret;
2503 	}
2504 	return 0;
2505 }
2506 
2507 /*
2508  * Commands during read - no Set Block Count (CMD23).
2509  */
mmc_test_cmds_during_read(struct mmc_test_card * test)2510 static int mmc_test_cmds_during_read(struct mmc_test_card *test)
2511 {
2512 	return mmc_test_cmds_during_tfr(test, 0, 0, 0);
2513 }
2514 
2515 /*
2516  * Commands during write - no Set Block Count (CMD23).
2517  */
mmc_test_cmds_during_write(struct mmc_test_card * test)2518 static int mmc_test_cmds_during_write(struct mmc_test_card *test)
2519 {
2520 	return mmc_test_cmds_during_tfr(test, 0, 1, 0);
2521 }
2522 
2523 /*
2524  * Commands during read - use Set Block Count (CMD23).
2525  */
mmc_test_cmds_during_read_cmd23(struct mmc_test_card * test)2526 static int mmc_test_cmds_during_read_cmd23(struct mmc_test_card *test)
2527 {
2528 	return mmc_test_cmds_during_tfr(test, 1, 0, 0);
2529 }
2530 
2531 /*
2532  * Commands during write - use Set Block Count (CMD23).
2533  */
mmc_test_cmds_during_write_cmd23(struct mmc_test_card * test)2534 static int mmc_test_cmds_during_write_cmd23(struct mmc_test_card *test)
2535 {
2536 	return mmc_test_cmds_during_tfr(test, 1, 1, 0);
2537 }
2538 
2539 /*
2540  * Commands during non-blocking read - use Set Block Count (CMD23).
2541  */
mmc_test_cmds_during_read_cmd23_nonblock(struct mmc_test_card * test)2542 static int mmc_test_cmds_during_read_cmd23_nonblock(struct mmc_test_card *test)
2543 {
2544 	return mmc_test_cmds_during_tfr(test, 1, 0, 1);
2545 }
2546 
2547 /*
2548  * Commands during non-blocking write - use Set Block Count (CMD23).
2549  */
mmc_test_cmds_during_write_cmd23_nonblock(struct mmc_test_card * test)2550 static int mmc_test_cmds_during_write_cmd23_nonblock(struct mmc_test_card *test)
2551 {
2552 	return mmc_test_cmds_during_tfr(test, 1, 1, 1);
2553 }
2554 
2555 static const struct mmc_test_case mmc_test_cases[] = {
2556 	{
2557 		.name = "Basic write (no data verification)",
2558 		.run = mmc_test_basic_write,
2559 	},
2560 
2561 	{
2562 		.name = "Basic read (no data verification)",
2563 		.run = mmc_test_basic_read,
2564 	},
2565 
2566 	{
2567 		.name = "Basic write (with data verification)",
2568 		.prepare = mmc_test_prepare_write,
2569 		.run = mmc_test_verify_write,
2570 		.cleanup = mmc_test_cleanup,
2571 	},
2572 
2573 	{
2574 		.name = "Basic read (with data verification)",
2575 		.prepare = mmc_test_prepare_read,
2576 		.run = mmc_test_verify_read,
2577 		.cleanup = mmc_test_cleanup,
2578 	},
2579 
2580 	{
2581 		.name = "Multi-block write",
2582 		.prepare = mmc_test_prepare_write,
2583 		.run = mmc_test_multi_write,
2584 		.cleanup = mmc_test_cleanup,
2585 	},
2586 
2587 	{
2588 		.name = "Multi-block read",
2589 		.prepare = mmc_test_prepare_read,
2590 		.run = mmc_test_multi_read,
2591 		.cleanup = mmc_test_cleanup,
2592 	},
2593 
2594 	{
2595 		.name = "Power of two block writes",
2596 		.prepare = mmc_test_prepare_write,
2597 		.run = mmc_test_pow2_write,
2598 		.cleanup = mmc_test_cleanup,
2599 	},
2600 
2601 	{
2602 		.name = "Power of two block reads",
2603 		.prepare = mmc_test_prepare_read,
2604 		.run = mmc_test_pow2_read,
2605 		.cleanup = mmc_test_cleanup,
2606 	},
2607 
2608 	{
2609 		.name = "Weird sized block writes",
2610 		.prepare = mmc_test_prepare_write,
2611 		.run = mmc_test_weird_write,
2612 		.cleanup = mmc_test_cleanup,
2613 	},
2614 
2615 	{
2616 		.name = "Weird sized block reads",
2617 		.prepare = mmc_test_prepare_read,
2618 		.run = mmc_test_weird_read,
2619 		.cleanup = mmc_test_cleanup,
2620 	},
2621 
2622 	{
2623 		.name = "Badly aligned write",
2624 		.prepare = mmc_test_prepare_write,
2625 		.run = mmc_test_align_write,
2626 		.cleanup = mmc_test_cleanup,
2627 	},
2628 
2629 	{
2630 		.name = "Badly aligned read",
2631 		.prepare = mmc_test_prepare_read,
2632 		.run = mmc_test_align_read,
2633 		.cleanup = mmc_test_cleanup,
2634 	},
2635 
2636 	{
2637 		.name = "Badly aligned multi-block write",
2638 		.prepare = mmc_test_prepare_write,
2639 		.run = mmc_test_align_multi_write,
2640 		.cleanup = mmc_test_cleanup,
2641 	},
2642 
2643 	{
2644 		.name = "Badly aligned multi-block read",
2645 		.prepare = mmc_test_prepare_read,
2646 		.run = mmc_test_align_multi_read,
2647 		.cleanup = mmc_test_cleanup,
2648 	},
2649 
2650 	{
2651 		.name = "Proper xfer_size at write (start failure)",
2652 		.run = mmc_test_xfersize_write,
2653 	},
2654 
2655 	{
2656 		.name = "Proper xfer_size at read (start failure)",
2657 		.run = mmc_test_xfersize_read,
2658 	},
2659 
2660 	{
2661 		.name = "Proper xfer_size at write (midway failure)",
2662 		.run = mmc_test_multi_xfersize_write,
2663 	},
2664 
2665 	{
2666 		.name = "Proper xfer_size at read (midway failure)",
2667 		.run = mmc_test_multi_xfersize_read,
2668 	},
2669 
2670 #ifdef CONFIG_HIGHMEM
2671 
2672 	{
2673 		.name = "Highmem write",
2674 		.prepare = mmc_test_prepare_write,
2675 		.run = mmc_test_write_high,
2676 		.cleanup = mmc_test_cleanup,
2677 	},
2678 
2679 	{
2680 		.name = "Highmem read",
2681 		.prepare = mmc_test_prepare_read,
2682 		.run = mmc_test_read_high,
2683 		.cleanup = mmc_test_cleanup,
2684 	},
2685 
2686 	{
2687 		.name = "Multi-block highmem write",
2688 		.prepare = mmc_test_prepare_write,
2689 		.run = mmc_test_multi_write_high,
2690 		.cleanup = mmc_test_cleanup,
2691 	},
2692 
2693 	{
2694 		.name = "Multi-block highmem read",
2695 		.prepare = mmc_test_prepare_read,
2696 		.run = mmc_test_multi_read_high,
2697 		.cleanup = mmc_test_cleanup,
2698 	},
2699 
2700 #else
2701 
2702 	{
2703 		.name = "Highmem write",
2704 		.run = mmc_test_no_highmem,
2705 	},
2706 
2707 	{
2708 		.name = "Highmem read",
2709 		.run = mmc_test_no_highmem,
2710 	},
2711 
2712 	{
2713 		.name = "Multi-block highmem write",
2714 		.run = mmc_test_no_highmem,
2715 	},
2716 
2717 	{
2718 		.name = "Multi-block highmem read",
2719 		.run = mmc_test_no_highmem,
2720 	},
2721 
2722 #endif /* CONFIG_HIGHMEM */
2723 
2724 	{
2725 		.name = "Best-case read performance",
2726 		.prepare = mmc_test_area_prepare_fill,
2727 		.run = mmc_test_best_read_performance,
2728 		.cleanup = mmc_test_area_cleanup,
2729 	},
2730 
2731 	{
2732 		.name = "Best-case write performance",
2733 		.prepare = mmc_test_area_prepare_erase,
2734 		.run = mmc_test_best_write_performance,
2735 		.cleanup = mmc_test_area_cleanup,
2736 	},
2737 
2738 	{
2739 		.name = "Best-case read performance into scattered pages",
2740 		.prepare = mmc_test_area_prepare_fill,
2741 		.run = mmc_test_best_read_perf_max_scatter,
2742 		.cleanup = mmc_test_area_cleanup,
2743 	},
2744 
2745 	{
2746 		.name = "Best-case write performance from scattered pages",
2747 		.prepare = mmc_test_area_prepare_erase,
2748 		.run = mmc_test_best_write_perf_max_scatter,
2749 		.cleanup = mmc_test_area_cleanup,
2750 	},
2751 
2752 	{
2753 		.name = "Single read performance by transfer size",
2754 		.prepare = mmc_test_area_prepare_fill,
2755 		.run = mmc_test_profile_read_perf,
2756 		.cleanup = mmc_test_area_cleanup,
2757 	},
2758 
2759 	{
2760 		.name = "Single write performance by transfer size",
2761 		.prepare = mmc_test_area_prepare,
2762 		.run = mmc_test_profile_write_perf,
2763 		.cleanup = mmc_test_area_cleanup,
2764 	},
2765 
2766 	{
2767 		.name = "Single trim performance by transfer size",
2768 		.prepare = mmc_test_area_prepare_fill,
2769 		.run = mmc_test_profile_trim_perf,
2770 		.cleanup = mmc_test_area_cleanup,
2771 	},
2772 
2773 	{
2774 		.name = "Consecutive read performance by transfer size",
2775 		.prepare = mmc_test_area_prepare_fill,
2776 		.run = mmc_test_profile_seq_read_perf,
2777 		.cleanup = mmc_test_area_cleanup,
2778 	},
2779 
2780 	{
2781 		.name = "Consecutive write performance by transfer size",
2782 		.prepare = mmc_test_area_prepare,
2783 		.run = mmc_test_profile_seq_write_perf,
2784 		.cleanup = mmc_test_area_cleanup,
2785 	},
2786 
2787 	{
2788 		.name = "Consecutive trim performance by transfer size",
2789 		.prepare = mmc_test_area_prepare,
2790 		.run = mmc_test_profile_seq_trim_perf,
2791 		.cleanup = mmc_test_area_cleanup,
2792 	},
2793 
2794 	{
2795 		.name = "Random read performance by transfer size",
2796 		.prepare = mmc_test_area_prepare,
2797 		.run = mmc_test_random_read_perf,
2798 		.cleanup = mmc_test_area_cleanup,
2799 	},
2800 
2801 	{
2802 		.name = "Random write performance by transfer size",
2803 		.prepare = mmc_test_area_prepare,
2804 		.run = mmc_test_random_write_perf,
2805 		.cleanup = mmc_test_area_cleanup,
2806 	},
2807 
2808 	{
2809 		.name = "Large sequential read into scattered pages",
2810 		.prepare = mmc_test_area_prepare,
2811 		.run = mmc_test_large_seq_read_perf,
2812 		.cleanup = mmc_test_area_cleanup,
2813 	},
2814 
2815 	{
2816 		.name = "Large sequential write from scattered pages",
2817 		.prepare = mmc_test_area_prepare,
2818 		.run = mmc_test_large_seq_write_perf,
2819 		.cleanup = mmc_test_area_cleanup,
2820 	},
2821 
2822 	{
2823 		.name = "Write performance with blocking req 4k to 4MB",
2824 		.prepare = mmc_test_area_prepare,
2825 		.run = mmc_test_profile_mult_write_blocking_perf,
2826 		.cleanup = mmc_test_area_cleanup,
2827 	},
2828 
2829 	{
2830 		.name = "Write performance with non-blocking req 4k to 4MB",
2831 		.prepare = mmc_test_area_prepare,
2832 		.run = mmc_test_profile_mult_write_nonblock_perf,
2833 		.cleanup = mmc_test_area_cleanup,
2834 	},
2835 
2836 	{
2837 		.name = "Read performance with blocking req 4k to 4MB",
2838 		.prepare = mmc_test_area_prepare,
2839 		.run = mmc_test_profile_mult_read_blocking_perf,
2840 		.cleanup = mmc_test_area_cleanup,
2841 	},
2842 
2843 	{
2844 		.name = "Read performance with non-blocking req 4k to 4MB",
2845 		.prepare = mmc_test_area_prepare,
2846 		.run = mmc_test_profile_mult_read_nonblock_perf,
2847 		.cleanup = mmc_test_area_cleanup,
2848 	},
2849 
2850 	{
2851 		.name = "Write performance blocking req 1 to 512 sg elems",
2852 		.prepare = mmc_test_area_prepare,
2853 		.run = mmc_test_profile_sglen_wr_blocking_perf,
2854 		.cleanup = mmc_test_area_cleanup,
2855 	},
2856 
2857 	{
2858 		.name = "Write performance non-blocking req 1 to 512 sg elems",
2859 		.prepare = mmc_test_area_prepare,
2860 		.run = mmc_test_profile_sglen_wr_nonblock_perf,
2861 		.cleanup = mmc_test_area_cleanup,
2862 	},
2863 
2864 	{
2865 		.name = "Read performance blocking req 1 to 512 sg elems",
2866 		.prepare = mmc_test_area_prepare,
2867 		.run = mmc_test_profile_sglen_r_blocking_perf,
2868 		.cleanup = mmc_test_area_cleanup,
2869 	},
2870 
2871 	{
2872 		.name = "Read performance non-blocking req 1 to 512 sg elems",
2873 		.prepare = mmc_test_area_prepare,
2874 		.run = mmc_test_profile_sglen_r_nonblock_perf,
2875 		.cleanup = mmc_test_area_cleanup,
2876 	},
2877 
2878 	{
2879 		.name = "Reset test",
2880 		.run = mmc_test_reset,
2881 	},
2882 
2883 	{
2884 		.name = "Commands during read - no Set Block Count (CMD23)",
2885 		.prepare = mmc_test_area_prepare,
2886 		.run = mmc_test_cmds_during_read,
2887 		.cleanup = mmc_test_area_cleanup,
2888 	},
2889 
2890 	{
2891 		.name = "Commands during write - no Set Block Count (CMD23)",
2892 		.prepare = mmc_test_area_prepare,
2893 		.run = mmc_test_cmds_during_write,
2894 		.cleanup = mmc_test_area_cleanup,
2895 	},
2896 
2897 	{
2898 		.name = "Commands during read - use Set Block Count (CMD23)",
2899 		.prepare = mmc_test_area_prepare,
2900 		.run = mmc_test_cmds_during_read_cmd23,
2901 		.cleanup = mmc_test_area_cleanup,
2902 	},
2903 
2904 	{
2905 		.name = "Commands during write - use Set Block Count (CMD23)",
2906 		.prepare = mmc_test_area_prepare,
2907 		.run = mmc_test_cmds_during_write_cmd23,
2908 		.cleanup = mmc_test_area_cleanup,
2909 	},
2910 
2911 	{
2912 		.name = "Commands during non-blocking read - use Set Block Count (CMD23)",
2913 		.prepare = mmc_test_area_prepare,
2914 		.run = mmc_test_cmds_during_read_cmd23_nonblock,
2915 		.cleanup = mmc_test_area_cleanup,
2916 	},
2917 
2918 	{
2919 		.name = "Commands during non-blocking write - use Set Block Count (CMD23)",
2920 		.prepare = mmc_test_area_prepare,
2921 		.run = mmc_test_cmds_during_write_cmd23_nonblock,
2922 		.cleanup = mmc_test_area_cleanup,
2923 	},
2924 };
2925 
2926 static DEFINE_MUTEX(mmc_test_lock);
2927 
2928 static LIST_HEAD(mmc_test_result);
2929 
mmc_test_run(struct mmc_test_card * test,int testcase)2930 static void mmc_test_run(struct mmc_test_card *test, int testcase)
2931 {
2932 	int i, ret;
2933 
2934 	pr_info("%s: Starting tests of card %s...\n",
2935 		mmc_hostname(test->card->host), mmc_card_id(test->card));
2936 
2937 	mmc_claim_host(test->card->host);
2938 
2939 	for (i = 0; i < ARRAY_SIZE(mmc_test_cases); i++) {
2940 		struct mmc_test_general_result *gr;
2941 
2942 		if (testcase && ((i + 1) != testcase))
2943 			continue;
2944 
2945 		pr_info("%s: Test case %d. %s...\n",
2946 			mmc_hostname(test->card->host), i + 1,
2947 			mmc_test_cases[i].name);
2948 
2949 		if (mmc_test_cases[i].prepare) {
2950 			ret = mmc_test_cases[i].prepare(test);
2951 			if (ret) {
2952 				pr_info("%s: Result: Prepare stage failed! (%d)\n",
2953 					mmc_hostname(test->card->host),
2954 					ret);
2955 				continue;
2956 			}
2957 		}
2958 
2959 		gr = kzalloc(sizeof(*gr), GFP_KERNEL);
2960 		if (gr) {
2961 			INIT_LIST_HEAD(&gr->tr_lst);
2962 
2963 			/* Assign data what we know already */
2964 			gr->card = test->card;
2965 			gr->testcase = i;
2966 
2967 			/* Append container to global one */
2968 			list_add_tail(&gr->link, &mmc_test_result);
2969 
2970 			/*
2971 			 * Save the pointer to created container in our private
2972 			 * structure.
2973 			 */
2974 			test->gr = gr;
2975 		}
2976 
2977 		ret = mmc_test_cases[i].run(test);
2978 		switch (ret) {
2979 		case RESULT_OK:
2980 			pr_info("%s: Result: OK\n",
2981 				mmc_hostname(test->card->host));
2982 			break;
2983 		case RESULT_FAIL:
2984 			pr_info("%s: Result: FAILED\n",
2985 				mmc_hostname(test->card->host));
2986 			break;
2987 		case RESULT_UNSUP_HOST:
2988 			pr_info("%s: Result: UNSUPPORTED (by host)\n",
2989 				mmc_hostname(test->card->host));
2990 			break;
2991 		case RESULT_UNSUP_CARD:
2992 			pr_info("%s: Result: UNSUPPORTED (by card)\n",
2993 				mmc_hostname(test->card->host));
2994 			break;
2995 		default:
2996 			pr_info("%s: Result: ERROR (%d)\n",
2997 				mmc_hostname(test->card->host), ret);
2998 		}
2999 
3000 		/* Save the result */
3001 		if (gr)
3002 			gr->result = ret;
3003 
3004 		if (mmc_test_cases[i].cleanup) {
3005 			ret = mmc_test_cases[i].cleanup(test);
3006 			if (ret) {
3007 				pr_info("%s: Warning: Cleanup stage failed! (%d)\n",
3008 					mmc_hostname(test->card->host),
3009 					ret);
3010 			}
3011 		}
3012 	}
3013 
3014 	mmc_release_host(test->card->host);
3015 
3016 	pr_info("%s: Tests completed.\n",
3017 		mmc_hostname(test->card->host));
3018 }
3019 
mmc_test_free_result(struct mmc_card * card)3020 static void mmc_test_free_result(struct mmc_card *card)
3021 {
3022 	struct mmc_test_general_result *gr, *grs;
3023 
3024 	mutex_lock(&mmc_test_lock);
3025 
3026 	list_for_each_entry_safe(gr, grs, &mmc_test_result, link) {
3027 		struct mmc_test_transfer_result *tr, *trs;
3028 
3029 		if (card && gr->card != card)
3030 			continue;
3031 
3032 		list_for_each_entry_safe(tr, trs, &gr->tr_lst, link) {
3033 			list_del(&tr->link);
3034 			kfree(tr);
3035 		}
3036 
3037 		list_del(&gr->link);
3038 		kfree(gr);
3039 	}
3040 
3041 	mutex_unlock(&mmc_test_lock);
3042 }
3043 
3044 static LIST_HEAD(mmc_test_file_test);
3045 
mtf_test_show(struct seq_file * sf,void * data)3046 static int mtf_test_show(struct seq_file *sf, void *data)
3047 {
3048 	struct mmc_card *card = sf->private;
3049 	struct mmc_test_general_result *gr;
3050 
3051 	mutex_lock(&mmc_test_lock);
3052 
3053 	list_for_each_entry(gr, &mmc_test_result, link) {
3054 		struct mmc_test_transfer_result *tr;
3055 
3056 		if (gr->card != card)
3057 			continue;
3058 
3059 		seq_printf(sf, "Test %d: %d\n", gr->testcase + 1, gr->result);
3060 
3061 		list_for_each_entry(tr, &gr->tr_lst, link) {
3062 			seq_printf(sf, "%u %d %llu.%09u %u %u.%02u\n",
3063 				tr->count, tr->sectors,
3064 				(u64)tr->ts.tv_sec, (u32)tr->ts.tv_nsec,
3065 				tr->rate, tr->iops / 100, tr->iops % 100);
3066 		}
3067 	}
3068 
3069 	mutex_unlock(&mmc_test_lock);
3070 
3071 	return 0;
3072 }
3073 
mtf_test_open(struct inode * inode,struct file * file)3074 static int mtf_test_open(struct inode *inode, struct file *file)
3075 {
3076 	return single_open(file, mtf_test_show, inode->i_private);
3077 }
3078 
mtf_test_write(struct file * file,const char __user * buf,size_t count,loff_t * pos)3079 static ssize_t mtf_test_write(struct file *file, const char __user *buf,
3080 	size_t count, loff_t *pos)
3081 {
3082 	struct seq_file *sf = file->private_data;
3083 	struct mmc_card *card = sf->private;
3084 	struct mmc_test_card *test;
3085 	long testcase;
3086 	int ret;
3087 
3088 	ret = kstrtol_from_user(buf, count, 10, &testcase);
3089 	if (ret)
3090 		return ret;
3091 
3092 	test = kzalloc(sizeof(*test), GFP_KERNEL);
3093 	if (!test)
3094 		return -ENOMEM;
3095 
3096 	/*
3097 	 * Remove all test cases associated with given card. Thus we have only
3098 	 * actual data of the last run.
3099 	 */
3100 	mmc_test_free_result(card);
3101 
3102 	test->card = card;
3103 
3104 	test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
3105 #ifdef CONFIG_HIGHMEM
3106 	test->highmem = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM, BUFFER_ORDER);
3107 	if (!test->highmem) {
3108 		count = -ENOMEM;
3109 		goto free_test_buffer;
3110 	}
3111 #endif
3112 
3113 	if (test->buffer) {
3114 		mutex_lock(&mmc_test_lock);
3115 		mmc_test_run(test, testcase);
3116 		mutex_unlock(&mmc_test_lock);
3117 	}
3118 
3119 #ifdef CONFIG_HIGHMEM
3120 	__free_pages(test->highmem, BUFFER_ORDER);
3121 free_test_buffer:
3122 #endif
3123 	kfree(test->buffer);
3124 	kfree(test);
3125 
3126 	return count;
3127 }
3128 
3129 static const struct file_operations mmc_test_fops_test = {
3130 	.open		= mtf_test_open,
3131 	.read		= seq_read,
3132 	.write		= mtf_test_write,
3133 	.llseek		= seq_lseek,
3134 	.release	= single_release,
3135 };
3136 
mtf_testlist_show(struct seq_file * sf,void * data)3137 static int mtf_testlist_show(struct seq_file *sf, void *data)
3138 {
3139 	int i;
3140 
3141 	mutex_lock(&mmc_test_lock);
3142 
3143 	seq_puts(sf, "0:\tRun all tests\n");
3144 	for (i = 0; i < ARRAY_SIZE(mmc_test_cases); i++)
3145 		seq_printf(sf, "%d:\t%s\n", i + 1, mmc_test_cases[i].name);
3146 
3147 	mutex_unlock(&mmc_test_lock);
3148 
3149 	return 0;
3150 }
3151 
3152 DEFINE_SHOW_ATTRIBUTE(mtf_testlist);
3153 
mmc_test_free_dbgfs_file(struct mmc_card * card)3154 static void mmc_test_free_dbgfs_file(struct mmc_card *card)
3155 {
3156 	struct mmc_test_dbgfs_file *df, *dfs;
3157 
3158 	mutex_lock(&mmc_test_lock);
3159 
3160 	list_for_each_entry_safe(df, dfs, &mmc_test_file_test, link) {
3161 		if (card && df->card != card)
3162 			continue;
3163 		debugfs_remove(df->file);
3164 		list_del(&df->link);
3165 		kfree(df);
3166 	}
3167 
3168 	mutex_unlock(&mmc_test_lock);
3169 }
3170 
__mmc_test_register_dbgfs_file(struct mmc_card * card,const char * name,umode_t mode,const struct file_operations * fops)3171 static int __mmc_test_register_dbgfs_file(struct mmc_card *card,
3172 	const char *name, umode_t mode, const struct file_operations *fops)
3173 {
3174 	struct dentry *file = NULL;
3175 	struct mmc_test_dbgfs_file *df;
3176 
3177 	if (card->debugfs_root)
3178 		file = debugfs_create_file(name, mode, card->debugfs_root,
3179 					   card, fops);
3180 
3181 	df = kmalloc(sizeof(*df), GFP_KERNEL);
3182 	if (!df) {
3183 		debugfs_remove(file);
3184 		return -ENOMEM;
3185 	}
3186 
3187 	df->card = card;
3188 	df->file = file;
3189 
3190 	list_add(&df->link, &mmc_test_file_test);
3191 	return 0;
3192 }
3193 
mmc_test_register_dbgfs_file(struct mmc_card * card)3194 static int mmc_test_register_dbgfs_file(struct mmc_card *card)
3195 {
3196 	int ret;
3197 
3198 	mutex_lock(&mmc_test_lock);
3199 
3200 	ret = __mmc_test_register_dbgfs_file(card, "test", S_IWUSR | S_IRUGO,
3201 		&mmc_test_fops_test);
3202 	if (ret)
3203 		goto err;
3204 
3205 	ret = __mmc_test_register_dbgfs_file(card, "testlist", S_IRUGO,
3206 		&mtf_testlist_fops);
3207 	if (ret)
3208 		goto err;
3209 
3210 err:
3211 	mutex_unlock(&mmc_test_lock);
3212 
3213 	return ret;
3214 }
3215 
mmc_test_probe(struct mmc_card * card)3216 static int mmc_test_probe(struct mmc_card *card)
3217 {
3218 	int ret;
3219 
3220 	if (!mmc_card_mmc(card) && !mmc_card_sd(card))
3221 		return -ENODEV;
3222 
3223 	ret = mmc_test_register_dbgfs_file(card);
3224 	if (ret)
3225 		return ret;
3226 
3227 	if (card->ext_csd.cmdq_en) {
3228 		mmc_claim_host(card->host);
3229 		ret = mmc_cmdq_disable(card);
3230 		mmc_release_host(card->host);
3231 		if (ret)
3232 			return ret;
3233 	}
3234 
3235 	dev_info(&card->dev, "Card claimed for testing.\n");
3236 
3237 	return 0;
3238 }
3239 
mmc_test_remove(struct mmc_card * card)3240 static void mmc_test_remove(struct mmc_card *card)
3241 {
3242 	if (card->reenable_cmdq) {
3243 		mmc_claim_host(card->host);
3244 		mmc_cmdq_enable(card);
3245 		mmc_release_host(card->host);
3246 	}
3247 	mmc_test_free_result(card);
3248 	mmc_test_free_dbgfs_file(card);
3249 }
3250 
3251 static struct mmc_driver mmc_driver = {
3252 	.drv		= {
3253 		.name	= "mmc_test",
3254 	},
3255 	.probe		= mmc_test_probe,
3256 	.remove		= mmc_test_remove,
3257 };
3258 
mmc_test_init(void)3259 static int __init mmc_test_init(void)
3260 {
3261 	return mmc_register_driver(&mmc_driver);
3262 }
3263 
mmc_test_exit(void)3264 static void __exit mmc_test_exit(void)
3265 {
3266 	/* Clear stalled data if card is still plugged */
3267 	mmc_test_free_result(NULL);
3268 	mmc_test_free_dbgfs_file(NULL);
3269 
3270 	mmc_unregister_driver(&mmc_driver);
3271 }
3272 
3273 module_init(mmc_test_init);
3274 module_exit(mmc_test_exit);
3275 
3276 MODULE_LICENSE("GPL");
3277 MODULE_DESCRIPTION("Multimedia Card (MMC) host test driver");
3278 MODULE_AUTHOR("Pierre Ossman");
3279