projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mmc: mmc_test: add tests to measure large sequential I/O performance
[deliverable/linux.git] / drivers / mmc / card / mmc_test.c
1 /*
2 * linux/drivers/mmc/card/mmc_test.c
3 *
4 * Copyright 2007-2008 Pierre Ossman
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 */
11
12 #include <linux/mmc/core.h>
13 #include <linux/mmc/card.h>
14 #include <linux/mmc/host.h>
15 #include <linux/mmc/mmc.h>
16 #include <linux/slab.h>
17
18 #include <linux/scatterlist.h>
19 #include <linux/swap.h> /* For nr_free_buffer_pages() */
20 #include <linux/list.h>
21
22 #include <linux/debugfs.h>
23 #include <linux/uaccess.h>
24 #include <linux/seq_file.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 /*
35 * Limit the test area size to the maximum MMC HC erase group size. Note that
36 * the maximum SD allocation unit size is just 4MiB.
37 */
38 #define TEST_AREA_MAX_SIZE (128 * 1024 * 1024)
39
40 /**
41 * struct mmc_test_pages - pages allocated by 'alloc_pages()'.
42 * @page: first page in the allocation
43 * @order: order of the number of pages allocated
44 */
45 struct mmc_test_pages {
46 struct page *page;
47 unsigned int order;
48 };
49
50 /**
51 * struct mmc_test_mem - allocated memory.
52 * @arr: array of allocations
53 * @cnt: number of allocations
54 */
55 struct mmc_test_mem {
56 struct mmc_test_pages *arr;
57 unsigned int cnt;
58 };
59
60 /**
61 * struct mmc_test_area - information for performance tests.
62 * @max_sz: test area size (in bytes)
63 * @dev_addr: address on card at which to do performance tests
64 * @max_tfr: maximum transfer size allowed by driver (in bytes)
65 * @max_segs: maximum segments allowed by driver in scatterlist @sg
66 * @max_seg_sz: maximum segment size allowed by driver
67 * @blocks: number of (512 byte) blocks currently mapped by @sg
68 * @sg_len: length of currently mapped scatterlist @sg
69 * @mem: allocated memory
70 * @sg: scatterlist
71 */
72 struct mmc_test_area {
73 unsigned long max_sz;
74 unsigned int dev_addr;
75 unsigned int max_tfr;
76 unsigned int max_segs;
77 unsigned int max_seg_sz;
78 unsigned int blocks;
79 unsigned int sg_len;
80 struct mmc_test_mem *mem;
81 struct scatterlist *sg;
82 };
83
84 /**
85 * struct mmc_test_transfer_result - transfer results for performance tests.
86 * @link: double-linked list
87 * @count: amount of group of sectors to check
88 * @sectors: amount of sectors to check in one group
89 * @ts: time values of transfer
90 * @rate: calculated transfer rate
91 * @iops: I/O operations per second (times 100)
92 */
93 struct mmc_test_transfer_result {
94 struct list_head link;
95 unsigned int count;
96 unsigned int sectors;
97 struct timespec ts;
98 unsigned int rate;
99 unsigned int iops;
100 };
101
102 /**
103 * struct mmc_test_general_result - results for tests.
104 * @link: double-linked list
105 * @card: card under test
106 * @testcase: number of test case
107 * @result: result of test run
108 * @tr_lst: transfer measurements if any as mmc_test_transfer_result
109 */
110 struct mmc_test_general_result {
111 struct list_head link;
112 struct mmc_card *card;
113 int testcase;
114 int result;
115 struct list_head tr_lst;
116 };
117
118 /**
119 * struct mmc_test_dbgfs_file - debugfs related file.
120 * @link: double-linked list
121 * @card: card under test
122 * @file: file created under debugfs
123 */
124 struct mmc_test_dbgfs_file {
125 struct list_head link;
126 struct mmc_card *card;
127 struct dentry *file;
128 };
129
130 /**
131 * struct mmc_test_card - test information.
132 * @card: card under test
133 * @scratch: transfer buffer
134 * @buffer: transfer buffer
135 * @highmem: buffer for highmem tests
136 * @area: information for performance tests
137 * @gr: pointer to results of current testcase
138 */
139 struct mmc_test_card {
140 struct mmc_card *card;
141
142 u8 scratch[BUFFER_SIZE];
143 u8 *buffer;
144 #ifdef CONFIG_HIGHMEM
145 struct page *highmem;
146 #endif
147 struct mmc_test_area area;
148 struct mmc_test_general_result *gr;
149 };
150
151 /*******************************************************************/
152 /* General helper functions */
153 /*******************************************************************/
154
155 /*
156 * Configure correct block size in card
157 */
158 static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)
159 {
160 return mmc_set_blocklen(test->card, size);
161 }
162
163 /*
164 * Fill in the mmc_request structure given a set of transfer parameters.
165 */
166 static void mmc_test_prepare_mrq(struct mmc_test_card *test,
167 struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
168 unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
169 {
170 BUG_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop);
171
172 if (blocks > 1) {
173 mrq->cmd->opcode = write ?
174 MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
175 } else {
176 mrq->cmd->opcode = write ?
177 MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
178 }
179
180 mrq->cmd->arg = dev_addr;
181 if (!mmc_card_blockaddr(test->card))
182 mrq->cmd->arg <<= 9;
183
184 mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
185
186 if (blocks == 1)
187 mrq->stop = NULL;
188 else {
189 mrq->stop->opcode = MMC_STOP_TRANSMISSION;
190 mrq->stop->arg = 0;
191 mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
192 }
193
194 mrq->data->blksz = blksz;
195 mrq->data->blocks = blocks;
196 mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
197 mrq->data->sg = sg;
198 mrq->data->sg_len = sg_len;
199
200 mmc_set_data_timeout(mrq->data, test->card);
201 }
202
203 static int mmc_test_busy(struct mmc_command *cmd)
204 {
205 return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
206 (R1_CURRENT_STATE(cmd->resp[0]) == 7);
207 }
208
209 /*
210 * Wait for the card to finish the busy state
211 */
212 static int mmc_test_wait_busy(struct mmc_test_card *test)
213 {
214 int ret, busy;
215 struct mmc_command cmd;
216
217 busy = 0;
218 do {
219 memset(&cmd, 0, sizeof(struct mmc_command));
220
221 cmd.opcode = MMC_SEND_STATUS;
222 cmd.arg = test->card->rca << 16;
223 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
224
225 ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
226 if (ret)
227 break;
228
229 if (!busy && mmc_test_busy(&cmd)) {
230 busy = 1;
231 if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
232 printk(KERN_INFO "%s: Warning: Host did not "
233 "wait for busy state to end.\n",
234 mmc_hostname(test->card->host));
235 }
236 } while (mmc_test_busy(&cmd));
237
238 return ret;
239 }
240
241 /*
242 * Transfer a single sector of kernel addressable data
243 */
244 static int mmc_test_buffer_transfer(struct mmc_test_card *test,
245 u8 *buffer, unsigned addr, unsigned blksz, int write)
246 {
247 int ret;
248
249 struct mmc_request mrq;
250 struct mmc_command cmd;
251 struct mmc_command stop;
252 struct mmc_data data;
253
254 struct scatterlist sg;
255
256 memset(&mrq, 0, sizeof(struct mmc_request));
257 memset(&cmd, 0, sizeof(struct mmc_command));
258 memset(&data, 0, sizeof(struct mmc_data));
259 memset(&stop, 0, sizeof(struct mmc_command));
260
261 mrq.cmd = &cmd;
262 mrq.data = &data;
263 mrq.stop = &stop;
264
265 sg_init_one(&sg, buffer, blksz);
266
267 mmc_test_prepare_mrq(test, &mrq, &sg, 1, addr, 1, blksz, write);
268
269 mmc_wait_for_req(test->card->host, &mrq);
270
271 if (cmd.error)
272 return cmd.error;
273 if (data.error)
274 return data.error;
275
276 ret = mmc_test_wait_busy(test);
277 if (ret)
278 return ret;
279
280 return 0;
281 }
282
283 static void mmc_test_free_mem(struct mmc_test_mem *mem)
284 {
285 if (!mem)
286 return;
287 while (mem->cnt--)
288 __free_pages(mem->arr[mem->cnt].page,
289 mem->arr[mem->cnt].order);
290 kfree(mem->arr);
291 kfree(mem);
292 }
293
294 /*
295 * Allocate a lot of memory, preferrably max_sz but at least min_sz. In case
296 * there isn't much memory do not exceed 1/16th total lowmem pages. Also do
297 * not exceed a maximum number of segments and try not to make segments much
298 * bigger than maximum segment size.
299 */
300 static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
301 unsigned long max_sz,
302 unsigned int max_segs,
303 unsigned int max_seg_sz)
304 {
305 unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE);
306 unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE);
307 unsigned long max_seg_page_cnt = DIV_ROUND_UP(max_seg_sz, PAGE_SIZE);
308 unsigned long page_cnt = 0;
309 unsigned long limit = nr_free_buffer_pages() >> 4;
310 struct mmc_test_mem *mem;
311
312 if (max_page_cnt > limit)
313 max_page_cnt = limit;
314 if (min_page_cnt > max_page_cnt)
315 min_page_cnt = max_page_cnt;
316
317 if (max_seg_page_cnt > max_page_cnt)
318 max_seg_page_cnt = max_page_cnt;
319
320 if (max_segs > max_page_cnt)
321 max_segs = max_page_cnt;
322
323 mem = kzalloc(sizeof(struct mmc_test_mem), GFP_KERNEL);
324 if (!mem)
325 return NULL;
326
327 mem->arr = kzalloc(sizeof(struct mmc_test_pages) * max_segs,
328 GFP_KERNEL);
329 if (!mem->arr)
330 goto out_free;
331
332 while (max_page_cnt) {
333 struct page *page;
334 unsigned int order;
335 gfp_t flags = GFP_KERNEL | GFP_DMA | __GFP_NOWARN |
336 __GFP_NORETRY;
337
338 order = get_order(max_seg_page_cnt << PAGE_SHIFT);
339 while (1) {
340 page = alloc_pages(flags, order);
341 if (page || !order)
342 break;
343 order -= 1;
344 }
345 if (!page) {
346 if (page_cnt < min_page_cnt)
347 goto out_free;
348 break;
349 }
350 mem->arr[mem->cnt].page = page;
351 mem->arr[mem->cnt].order = order;
352 mem->cnt += 1;
353 if (max_page_cnt <= (1UL << order))
354 break;
355 max_page_cnt -= 1UL << order;
356 page_cnt += 1UL << order;
357 if (mem->cnt >= max_segs) {
358 if (page_cnt < min_page_cnt)
359 goto out_free;
360 break;
361 }
362 }
363
364 return mem;
365
366 out_free:
367 mmc_test_free_mem(mem);
368 return NULL;
369 }
370
371 /*
372 * Map memory into a scatterlist. Optionally allow the same memory to be
373 * mapped more than once.
374 */
375 static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long sz,
376 struct scatterlist *sglist, int repeat,
377 unsigned int max_segs, unsigned int max_seg_sz,
378 unsigned int *sg_len)
379 {
380 struct scatterlist *sg = NULL;
381 unsigned int i;
382
383 sg_init_table(sglist, max_segs);
384
385 *sg_len = 0;
386 do {
387 for (i = 0; i < mem->cnt; i++) {
388 unsigned long len = PAGE_SIZE << mem->arr[i].order;
389
390 if (len > sz)
391 len = sz;
392 if (len > max_seg_sz)
393 len = max_seg_sz;
394 if (sg)
395 sg = sg_next(sg);
396 else
397 sg = sglist;
398 if (!sg)
399 return -EINVAL;
400 sg_set_page(sg, mem->arr[i].page, len, 0);
401 sz -= len;
402 *sg_len += 1;
403 if (!sz)
404 break;
405 }
406 } while (sz && repeat);
407
408 if (sz)
409 return -EINVAL;
410
411 if (sg)
412 sg_mark_end(sg);
413
414 return 0;
415 }
416
417 /*
418 * Map memory into a scatterlist so that no pages are contiguous. Allow the
419 * same memory to be mapped more than once.
420 */
421 static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
422 unsigned long sz,
423 struct scatterlist *sglist,
424 unsigned int max_segs,
425 unsigned int max_seg_sz,
426 unsigned int *sg_len)
427 {
428 struct scatterlist *sg = NULL;
429 unsigned int i = mem->cnt, cnt;
430 unsigned long len;
431 void *base, *addr, *last_addr = NULL;
432
433 sg_init_table(sglist, max_segs);
434
435 *sg_len = 0;
436 while (sz) {
437 base = page_address(mem->arr[--i].page);
438 cnt = 1 << mem->arr[i].order;
439 while (sz && cnt) {
440 addr = base + PAGE_SIZE * --cnt;
441 if (last_addr && last_addr + PAGE_SIZE == addr)
442 continue;
443 last_addr = addr;
444 len = PAGE_SIZE;
445 if (len > max_seg_sz)
446 len = max_seg_sz;
447 if (len > sz)
448 len = sz;
449 if (sg)
450 sg = sg_next(sg);
451 else
452 sg = sglist;
453 if (!sg)
454 return -EINVAL;
455 sg_set_page(sg, virt_to_page(addr), len, 0);
456 sz -= len;
457 *sg_len += 1;
458 }
459 if (i == 0)
460 i = mem->cnt;
461 }
462
463 if (sg)
464 sg_mark_end(sg);
465
466 return 0;
467 }
468
469 /*
470 * Calculate transfer rate in bytes per second.
471 */
472 static unsigned int mmc_test_rate(uint64_t bytes, struct timespec *ts)
473 {
474 uint64_t ns;
475
476 ns = ts->tv_sec;
477 ns *= 1000000000;
478 ns += ts->tv_nsec;
479
480 bytes *= 1000000000;
481
482 while (ns > UINT_MAX) {
483 bytes >>= 1;
484 ns >>= 1;
485 }
486
487 if (!ns)
488 return 0;
489
490 do_div(bytes, (uint32_t)ns);
491
492 return bytes;
493 }
494
495 /*
496 * Save transfer results for future usage
497 */
498 static void mmc_test_save_transfer_result(struct mmc_test_card *test,
499 unsigned int count, unsigned int sectors, struct timespec ts,
500 unsigned int rate, unsigned int iops)
501 {
502 struct mmc_test_transfer_result *tr;
503
504 if (!test->gr)
505 return;
506
507 tr = kmalloc(sizeof(struct mmc_test_transfer_result), GFP_KERNEL);
508 if (!tr)
509 return;
510
511 tr->count = count;
512 tr->sectors = sectors;
513 tr->ts = ts;
514 tr->rate = rate;
515 tr->iops = iops;
516
517 list_add_tail(&tr->link, &test->gr->tr_lst);
518 }
519
520 /*
521 * Print the transfer rate.
522 */
523 static void mmc_test_print_rate(struct mmc_test_card *test, uint64_t bytes,
524 struct timespec *ts1, struct timespec *ts2)
525 {
526 unsigned int rate, iops, sectors = bytes >> 9;
527 struct timespec ts;
528
529 ts = timespec_sub(*ts2, *ts1);
530
531 rate = mmc_test_rate(bytes, &ts);
532 iops = mmc_test_rate(100, &ts); /* I/O ops per sec x 100 */
533
534 printk(KERN_INFO "%s: Transfer of %u sectors (%u%s KiB) took %lu.%09lu "
535 "seconds (%u kB/s, %u KiB/s, %u.%02u IOPS)\n",
536 mmc_hostname(test->card->host), sectors, sectors >> 1,
537 (sectors & 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
538 (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024,
539 iops / 100, iops % 100);
540
541 mmc_test_save_transfer_result(test, 1, sectors, ts, rate, iops);
542 }
543
544 /*
545 * Print the average transfer rate.
546 */
547 static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
548 unsigned int count, struct timespec *ts1,
549 struct timespec *ts2)
550 {
551 unsigned int rate, iops, sectors = bytes >> 9;
552 uint64_t tot = bytes * count;
553 struct timespec ts;
554
555 ts = timespec_sub(*ts2, *ts1);
556
557 rate = mmc_test_rate(tot, &ts);
558 iops = mmc_test_rate(count * 100, &ts); /* I/O ops per sec x 100 */
559
560 printk(KERN_INFO "%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
561 "%lu.%09lu seconds (%u kB/s, %u KiB/s, "
562 "%u.%02u IOPS)\n",
563 mmc_hostname(test->card->host), count, sectors, count,
564 sectors >> 1, (sectors & 1 ? ".5" : ""),
565 (unsigned long)ts.tv_sec, (unsigned long)ts.tv_nsec,
566 rate / 1000, rate / 1024, iops / 100, iops % 100);
567
568 mmc_test_save_transfer_result(test, count, sectors, ts, rate, iops);
569 }
570
571 /*
572 * Return the card size in sectors.
573 */
574 static unsigned int mmc_test_capacity(struct mmc_card *card)
575 {
576 if (!mmc_card_sd(card) && mmc_card_blockaddr(card))
577 return card->ext_csd.sectors;
578 else
579 return card->csd.capacity << (card->csd.read_blkbits - 9);
580 }
581
582 /*******************************************************************/
583 /* Test preparation and cleanup */
584 /*******************************************************************/
585
586 /*
587 * Fill the first couple of sectors of the card with known data
588 * so that bad reads/writes can be detected
589 */
590 static int __mmc_test_prepare(struct mmc_test_card *test, int write)
591 {
592 int ret, i;
593
594 ret = mmc_test_set_blksize(test, 512);
595 if (ret)
596 return ret;
597
598 if (write)
599 memset(test->buffer, 0xDF, 512);
600 else {
601 for (i = 0;i < 512;i++)
602 test->buffer[i] = i;
603 }
604
605 for (i = 0;i < BUFFER_SIZE / 512;i++) {
606 ret = mmc_test_buffer_transfer(test, test->buffer, i, 512, 1);
607 if (ret)
608 return ret;
609 }
610
611 return 0;
612 }
613
614 static int mmc_test_prepare_write(struct mmc_test_card *test)
615 {
616 return __mmc_test_prepare(test, 1);
617 }
618
619 static int mmc_test_prepare_read(struct mmc_test_card *test)
620 {
621 return __mmc_test_prepare(test, 0);
622 }
623
624 static int mmc_test_cleanup(struct mmc_test_card *test)
625 {
626 int ret, i;
627
628 ret = mmc_test_set_blksize(test, 512);
629 if (ret)
630 return ret;
631
632 memset(test->buffer, 0, 512);
633
634 for (i = 0;i < BUFFER_SIZE / 512;i++) {
635 ret = mmc_test_buffer_transfer(test, test->buffer, i, 512, 1);
636 if (ret)
637 return ret;
638 }
639
640 return 0;
641 }
642
643 /*******************************************************************/
644 /* Test execution helpers */
645 /*******************************************************************/
646
647 /*
648 * Modifies the mmc_request to perform the "short transfer" tests
649 */
650 static void mmc_test_prepare_broken_mrq(struct mmc_test_card *test,
651 struct mmc_request *mrq, int write)
652 {
653 BUG_ON(!mrq || !mrq->cmd || !mrq->data);
654
655 if (mrq->data->blocks > 1) {
656 mrq->cmd->opcode = write ?
657 MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
658 mrq->stop = NULL;
659 } else {
660 mrq->cmd->opcode = MMC_SEND_STATUS;
661 mrq->cmd->arg = test->card->rca << 16;
662 }
663 }
664
665 /*
666 * Checks that a normal transfer didn't have any errors
667 */
668 static int mmc_test_check_result(struct mmc_test_card *test,
669 struct mmc_request *mrq)
670 {
671 int ret;
672
673 BUG_ON(!mrq || !mrq->cmd || !mrq->data);
674
675 ret = 0;
676
677 if (!ret && mrq->cmd->error)
678 ret = mrq->cmd->error;
679 if (!ret && mrq->data->error)
680 ret = mrq->data->error;
681 if (!ret && mrq->stop && mrq->stop->error)
682 ret = mrq->stop->error;
683 if (!ret && mrq->data->bytes_xfered !=
684 mrq->data->blocks * mrq->data->blksz)
685 ret = RESULT_FAIL;
686
687 if (ret == -EINVAL)
688 ret = RESULT_UNSUP_HOST;
689
690 return ret;
691 }
692
693 /*
694 * Checks that a "short transfer" behaved as expected
695 */
696 static int mmc_test_check_broken_result(struct mmc_test_card *test,
697 struct mmc_request *mrq)
698 {
699 int ret;
700
701 BUG_ON(!mrq || !mrq->cmd || !mrq->data);
702
703 ret = 0;
704
705 if (!ret && mrq->cmd->error)
706 ret = mrq->cmd->error;
707 if (!ret && mrq->data->error == 0)
708 ret = RESULT_FAIL;
709 if (!ret && mrq->data->error != -ETIMEDOUT)
710 ret = mrq->data->error;
711 if (!ret && mrq->stop && mrq->stop->error)
712 ret = mrq->stop->error;
713 if (mrq->data->blocks > 1) {
714 if (!ret && mrq->data->bytes_xfered > mrq->data->blksz)
715 ret = RESULT_FAIL;
716 } else {
717 if (!ret && mrq->data->bytes_xfered > 0)
718 ret = RESULT_FAIL;
719 }
720
721 if (ret == -EINVAL)
722 ret = RESULT_UNSUP_HOST;
723
724 return ret;
725 }
726
727 /*
728 * Tests a basic transfer with certain parameters
729 */
730 static int mmc_test_simple_transfer(struct mmc_test_card *test,
731 struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
732 unsigned blocks, unsigned blksz, int write)
733 {
734 struct mmc_request mrq;
735 struct mmc_command cmd;
736 struct mmc_command stop;
737 struct mmc_data data;
738
739 memset(&mrq, 0, sizeof(struct mmc_request));
740 memset(&cmd, 0, sizeof(struct mmc_command));
741 memset(&data, 0, sizeof(struct mmc_data));
742 memset(&stop, 0, sizeof(struct mmc_command));
743
744 mrq.cmd = &cmd;
745 mrq.data = &data;
746 mrq.stop = &stop;
747
748 mmc_test_prepare_mrq(test, &mrq, sg, sg_len, dev_addr,
749 blocks, blksz, write);
750
751 mmc_wait_for_req(test->card->host, &mrq);
752
753 mmc_test_wait_busy(test);
754
755 return mmc_test_check_result(test, &mrq);
756 }
757
758 /*
759 * Tests a transfer where the card will fail completely or partly
760 */
761 static int mmc_test_broken_transfer(struct mmc_test_card *test,
762 unsigned blocks, unsigned blksz, int write)
763 {
764 struct mmc_request mrq;
765 struct mmc_command cmd;
766 struct mmc_command stop;
767 struct mmc_data data;
768
769 struct scatterlist sg;
770
771 memset(&mrq, 0, sizeof(struct mmc_request));
772 memset(&cmd, 0, sizeof(struct mmc_command));
773 memset(&data, 0, sizeof(struct mmc_data));
774 memset(&stop, 0, sizeof(struct mmc_command));
775
776 mrq.cmd = &cmd;
777 mrq.data = &data;
778 mrq.stop = &stop;
779
780 sg_init_one(&sg, test->buffer, blocks * blksz);
781
782 mmc_test_prepare_mrq(test, &mrq, &sg, 1, 0, blocks, blksz, write);
783 mmc_test_prepare_broken_mrq(test, &mrq, write);
784
785 mmc_wait_for_req(test->card->host, &mrq);
786
787 mmc_test_wait_busy(test);
788
789 return mmc_test_check_broken_result(test, &mrq);
790 }
791
792 /*
793 * Does a complete transfer test where data is also validated
794 *
795 * Note: mmc_test_prepare() must have been done before this call
796 */
797 static int mmc_test_transfer(struct mmc_test_card *test,
798 struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
799 unsigned blocks, unsigned blksz, int write)
800 {
801 int ret, i;
802 unsigned long flags;
803
804 if (write) {
805 for (i = 0;i < blocks * blksz;i++)
806 test->scratch[i] = i;
807 } else {
808 memset(test->scratch, 0, BUFFER_SIZE);
809 }
810 local_irq_save(flags);
811 sg_copy_from_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
812 local_irq_restore(flags);
813
814 ret = mmc_test_set_blksize(test, blksz);
815 if (ret)
816 return ret;
817
818 ret = mmc_test_simple_transfer(test, sg, sg_len, dev_addr,
819 blocks, blksz, write);
820 if (ret)
821 return ret;
822
823 if (write) {
824 int sectors;
825
826 ret = mmc_test_set_blksize(test, 512);
827 if (ret)
828 return ret;
829
830 sectors = (blocks * blksz + 511) / 512;
831 if ((sectors * 512) == (blocks * blksz))
832 sectors++;
833
834 if ((sectors * 512) > BUFFER_SIZE)
835 return -EINVAL;
836
837 memset(test->buffer, 0, sectors * 512);
838
839 for (i = 0;i < sectors;i++) {
840 ret = mmc_test_buffer_transfer(test,
841 test->buffer + i * 512,
842 dev_addr + i, 512, 0);
843 if (ret)
844 return ret;
845 }
846
847 for (i = 0;i < blocks * blksz;i++) {
848 if (test->buffer[i] != (u8)i)
849 return RESULT_FAIL;
850 }
851
852 for (;i < sectors * 512;i++) {
853 if (test->buffer[i] != 0xDF)
854 return RESULT_FAIL;
855 }
856 } else {
857 local_irq_save(flags);
858 sg_copy_to_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
859 local_irq_restore(flags);
860 for (i = 0;i < blocks * blksz;i++) {
861 if (test->scratch[i] != (u8)i)
862 return RESULT_FAIL;
863 }
864 }
865
866 return 0;
867 }
868
869 /*******************************************************************/
870 /* Tests */
871 /*******************************************************************/
872
873 struct mmc_test_case {
874 const char *name;
875
876 int (*prepare)(struct mmc_test_card *);
877 int (*run)(struct mmc_test_card *);
878 int (*cleanup)(struct mmc_test_card *);
879 };
880
881 static int mmc_test_basic_write(struct mmc_test_card *test)
882 {
883 int ret;
884 struct scatterlist sg;
885
886 ret = mmc_test_set_blksize(test, 512);
887 if (ret)
888 return ret;
889
890 sg_init_one(&sg, test->buffer, 512);
891
892 ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 1);
893 if (ret)
894 return ret;
895
896 return 0;
897 }
898
899 static int mmc_test_basic_read(struct mmc_test_card *test)
900 {
901 int ret;
902 struct scatterlist sg;
903
904 ret = mmc_test_set_blksize(test, 512);
905 if (ret)
906 return ret;
907
908 sg_init_one(&sg, test->buffer, 512);
909
910 ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 0);
911 if (ret)
912 return ret;
913
914 return 0;
915 }
916
917 static int mmc_test_verify_write(struct mmc_test_card *test)
918 {
919 int ret;
920 struct scatterlist sg;
921
922 sg_init_one(&sg, test->buffer, 512);
923
924 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
925 if (ret)
926 return ret;
927
928 return 0;
929 }
930
931 static int mmc_test_verify_read(struct mmc_test_card *test)
932 {
933 int ret;
934 struct scatterlist sg;
935
936 sg_init_one(&sg, test->buffer, 512);
937
938 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
939 if (ret)
940 return ret;
941
942 return 0;
943 }
944
945 static int mmc_test_multi_write(struct mmc_test_card *test)
946 {
947 int ret;
948 unsigned int size;
949 struct scatterlist sg;
950
951 if (test->card->host->max_blk_count == 1)
952 return RESULT_UNSUP_HOST;
953
954 size = PAGE_SIZE * 2;
955 size = min(size, test->card->host->max_req_size);
956 size = min(size, test->card->host->max_seg_size);
957 size = min(size, test->card->host->max_blk_count * 512);
958
959 if (size < 1024)
960 return RESULT_UNSUP_HOST;
961
962 sg_init_one(&sg, test->buffer, size);
963
964 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
965 if (ret)
966 return ret;
967
968 return 0;
969 }
970
971 static int mmc_test_multi_read(struct mmc_test_card *test)
972 {
973 int ret;
974 unsigned int size;
975 struct scatterlist sg;
976
977 if (test->card->host->max_blk_count == 1)
978 return RESULT_UNSUP_HOST;
979
980 size = PAGE_SIZE * 2;
981 size = min(size, test->card->host->max_req_size);
982 size = min(size, test->card->host->max_seg_size);
983 size = min(size, test->card->host->max_blk_count * 512);
984
985 if (size < 1024)
986 return RESULT_UNSUP_HOST;
987
988 sg_init_one(&sg, test->buffer, size);
989
990 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
991 if (ret)
992 return ret;
993
994 return 0;
995 }
996
997 static int mmc_test_pow2_write(struct mmc_test_card *test)
998 {
999 int ret, i;
1000 struct scatterlist sg;
1001
1002 if (!test->card->csd.write_partial)
1003 return RESULT_UNSUP_CARD;
1004
1005 for (i = 1; i < 512;i <<= 1) {
1006 sg_init_one(&sg, test->buffer, i);
1007 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
1008 if (ret)
1009 return ret;
1010 }
1011
1012 return 0;
1013 }
1014
1015 static int mmc_test_pow2_read(struct mmc_test_card *test)
1016 {
1017 int ret, i;
1018 struct scatterlist sg;
1019
1020 if (!test->card->csd.read_partial)
1021 return RESULT_UNSUP_CARD;
1022
1023 for (i = 1; i < 512;i <<= 1) {
1024 sg_init_one(&sg, test->buffer, i);
1025 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
1026 if (ret)
1027 return ret;
1028 }
1029
1030 return 0;
1031 }
1032
1033 static int mmc_test_weird_write(struct mmc_test_card *test)
1034 {
1035 int ret, i;
1036 struct scatterlist sg;
1037
1038 if (!test->card->csd.write_partial)
1039 return RESULT_UNSUP_CARD;
1040
1041 for (i = 3; i < 512;i += 7) {
1042 sg_init_one(&sg, test->buffer, i);
1043 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
1044 if (ret)
1045 return ret;
1046 }
1047
1048 return 0;
1049 }
1050
1051 static int mmc_test_weird_read(struct mmc_test_card *test)
1052 {
1053 int ret, i;
1054 struct scatterlist sg;
1055
1056 if (!test->card->csd.read_partial)
1057 return RESULT_UNSUP_CARD;
1058
1059 for (i = 3; i < 512;i += 7) {
1060 sg_init_one(&sg, test->buffer, i);
1061 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
1062 if (ret)
1063 return ret;
1064 }
1065
1066 return 0;
1067 }
1068
1069 static int mmc_test_align_write(struct mmc_test_card *test)
1070 {
1071 int ret, i;
1072 struct scatterlist sg;
1073
1074 for (i = 1;i < 4;i++) {
1075 sg_init_one(&sg, test->buffer + i, 512);
1076 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
1077 if (ret)
1078 return ret;
1079 }
1080
1081 return 0;
1082 }
1083
1084 static int mmc_test_align_read(struct mmc_test_card *test)
1085 {
1086 int ret, i;
1087 struct scatterlist sg;
1088
1089 for (i = 1;i < 4;i++) {
1090 sg_init_one(&sg, test->buffer + i, 512);
1091 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
1092 if (ret)
1093 return ret;
1094 }
1095
1096 return 0;
1097 }
1098
1099 static int mmc_test_align_multi_write(struct mmc_test_card *test)
1100 {
1101 int ret, i;
1102 unsigned int size;
1103 struct scatterlist sg;
1104
1105 if (test->card->host->max_blk_count == 1)
1106 return RESULT_UNSUP_HOST;
1107
1108 size = PAGE_SIZE * 2;
1109 size = min(size, test->card->host->max_req_size);
1110 size = min(size, test->card->host->max_seg_size);
1111 size = min(size, test->card->host->max_blk_count * 512);
1112
1113 if (size < 1024)
1114 return RESULT_UNSUP_HOST;
1115
1116 for (i = 1;i < 4;i++) {
1117 sg_init_one(&sg, test->buffer + i, size);
1118 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
1119 if (ret)
1120 return ret;
1121 }
1122
1123 return 0;
1124 }
1125
1126 static int mmc_test_align_multi_read(struct mmc_test_card *test)
1127 {
1128 int ret, i;
1129 unsigned int size;
1130 struct scatterlist sg;
1131
1132 if (test->card->host->max_blk_count == 1)
1133 return RESULT_UNSUP_HOST;
1134
1135 size = PAGE_SIZE * 2;
1136 size = min(size, test->card->host->max_req_size);
1137 size = min(size, test->card->host->max_seg_size);
1138 size = min(size, test->card->host->max_blk_count * 512);
1139
1140 if (size < 1024)
1141 return RESULT_UNSUP_HOST;
1142
1143 for (i = 1;i < 4;i++) {
1144 sg_init_one(&sg, test->buffer + i, size);
1145 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
1146 if (ret)
1147 return ret;
1148 }
1149
1150 return 0;
1151 }
1152
1153 static int mmc_test_xfersize_write(struct mmc_test_card *test)
1154 {
1155 int ret;
1156
1157 ret = mmc_test_set_blksize(test, 512);
1158 if (ret)
1159 return ret;
1160
1161 ret = mmc_test_broken_transfer(test, 1, 512, 1);
1162 if (ret)
1163 return ret;
1164
1165 return 0;
1166 }
1167
1168 static int mmc_test_xfersize_read(struct mmc_test_card *test)
1169 {
1170 int ret;
1171
1172 ret = mmc_test_set_blksize(test, 512);
1173 if (ret)
1174 return ret;
1175
1176 ret = mmc_test_broken_transfer(test, 1, 512, 0);
1177 if (ret)
1178 return ret;
1179
1180 return 0;
1181 }
1182
1183 static int mmc_test_multi_xfersize_write(struct mmc_test_card *test)
1184 {
1185 int ret;
1186
1187 if (test->card->host->max_blk_count == 1)
1188 return RESULT_UNSUP_HOST;
1189
1190 ret = mmc_test_set_blksize(test, 512);
1191 if (ret)
1192 return ret;
1193
1194 ret = mmc_test_broken_transfer(test, 2, 512, 1);
1195 if (ret)
1196 return ret;
1197
1198 return 0;
1199 }
1200
1201 static int mmc_test_multi_xfersize_read(struct mmc_test_card *test)
1202 {
1203 int ret;
1204
1205 if (test->card->host->max_blk_count == 1)
1206 return RESULT_UNSUP_HOST;
1207
1208 ret = mmc_test_set_blksize(test, 512);
1209 if (ret)
1210 return ret;
1211
1212 ret = mmc_test_broken_transfer(test, 2, 512, 0);
1213 if (ret)
1214 return ret;
1215
1216 return 0;
1217 }
1218
1219 #ifdef CONFIG_HIGHMEM
1220
1221 static int mmc_test_write_high(struct mmc_test_card *test)
1222 {
1223 int ret;
1224 struct scatterlist sg;
1225
1226 sg_init_table(&sg, 1);
1227 sg_set_page(&sg, test->highmem, 512, 0);
1228
1229 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
1230 if (ret)
1231 return ret;
1232
1233 return 0;
1234 }
1235
1236 static int mmc_test_read_high(struct mmc_test_card *test)
1237 {
1238 int ret;
1239 struct scatterlist sg;
1240
1241 sg_init_table(&sg, 1);
1242 sg_set_page(&sg, test->highmem, 512, 0);
1243
1244 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
1245 if (ret)
1246 return ret;
1247
1248 return 0;
1249 }
1250
1251 static int mmc_test_multi_write_high(struct mmc_test_card *test)
1252 {
1253 int ret;
1254 unsigned int size;
1255 struct scatterlist sg;
1256
1257 if (test->card->host->max_blk_count == 1)
1258 return RESULT_UNSUP_HOST;
1259
1260 size = PAGE_SIZE * 2;
1261 size = min(size, test->card->host->max_req_size);
1262 size = min(size, test->card->host->max_seg_size);
1263 size = min(size, test->card->host->max_blk_count * 512);
1264
1265 if (size < 1024)
1266 return RESULT_UNSUP_HOST;
1267
1268 sg_init_table(&sg, 1);
1269 sg_set_page(&sg, test->highmem, size, 0);
1270
1271 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
1272 if (ret)
1273 return ret;
1274
1275 return 0;
1276 }
1277
1278 static int mmc_test_multi_read_high(struct mmc_test_card *test)
1279 {
1280 int ret;
1281 unsigned int size;
1282 struct scatterlist sg;
1283
1284 if (test->card->host->max_blk_count == 1)
1285 return RESULT_UNSUP_HOST;
1286
1287 size = PAGE_SIZE * 2;
1288 size = min(size, test->card->host->max_req_size);
1289 size = min(size, test->card->host->max_seg_size);
1290 size = min(size, test->card->host->max_blk_count * 512);
1291
1292 if (size < 1024)
1293 return RESULT_UNSUP_HOST;
1294
1295 sg_init_table(&sg, 1);
1296 sg_set_page(&sg, test->highmem, size, 0);
1297
1298 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
1299 if (ret)
1300 return ret;
1301
1302 return 0;
1303 }
1304
1305 #else
1306
1307 static int mmc_test_no_highmem(struct mmc_test_card *test)
1308 {
1309 printk(KERN_INFO "%s: Highmem not configured - test skipped\n",
1310 mmc_hostname(test->card->host));
1311 return 0;
1312 }
1313
1314 #endif /* CONFIG_HIGHMEM */
1315
1316 /*
1317 * Map sz bytes so that it can be transferred.
1318 */
1319 static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
1320 int max_scatter)
1321 {
1322 struct mmc_test_area *t = &test->area;
1323 int err;
1324
1325 t->blocks = sz >> 9;
1326
1327 if (max_scatter) {
1328 err = mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
1329 t->max_segs, t->max_seg_sz,
1330 &t->sg_len);
1331 } else {
1332 err = mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
1333 t->max_seg_sz, &t->sg_len);
1334 }
1335 if (err)
1336 printk(KERN_INFO "%s: Failed to map sg list\n",
1337 mmc_hostname(test->card->host));
1338 return err;
1339 }
1340
1341 /*
1342 * Transfer bytes mapped by mmc_test_area_map().
1343 */
1344 static int mmc_test_area_transfer(struct mmc_test_card *test,
1345 unsigned int dev_addr, int write)
1346 {
1347 struct mmc_test_area *t = &test->area;
1348
1349 return mmc_test_simple_transfer(test, t->sg, t->sg_len, dev_addr,
1350 t->blocks, 512, write);
1351 }
1352
1353 /*
1354 * Map and transfer bytes.
1355 */
1356 static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
1357 unsigned int dev_addr, int write, int max_scatter,
1358 int timed)
1359 {
1360 struct timespec ts1, ts2;
1361 int ret;
1362
1363 /*
1364 * In the case of a maximally scattered transfer, the maximum transfer
1365 * size is further limited by using PAGE_SIZE segments.
1366 */
1367 if (max_scatter) {
1368 struct mmc_test_area *t = &test->area;
1369 unsigned long max_tfr;
1370
1371 if (t->max_seg_sz >= PAGE_SIZE)
1372 max_tfr = t->max_segs * PAGE_SIZE;
1373 else
1374 max_tfr = t->max_segs * t->max_seg_sz;
1375 if (sz > max_tfr)
1376 sz = max_tfr;
1377 }
1378
1379 ret = mmc_test_area_map(test, sz, max_scatter);
1380 if (ret)
1381 return ret;
1382
1383 if (timed)
1384 getnstimeofday(&ts1);
1385
1386 ret = mmc_test_area_transfer(test, dev_addr, write);
1387 if (ret)
1388 return ret;
1389
1390 if (timed)
1391 getnstimeofday(&ts2);
1392
1393 if (timed)
1394 mmc_test_print_rate(test, sz, &ts1, &ts2);
1395
1396 return 0;
1397 }
1398
1399 /*
1400 * Write the test area entirely.
1401 */
1402 static int mmc_test_area_fill(struct mmc_test_card *test)
1403 {
1404 return mmc_test_area_io(test, test->area.max_tfr, test->area.dev_addr,
1405 1, 0, 0);
1406 }
1407
1408 /*
1409 * Erase the test area entirely.
1410 */
1411 static int mmc_test_area_erase(struct mmc_test_card *test)
1412 {
1413 struct mmc_test_area *t = &test->area;
1414
1415 if (!mmc_can_erase(test->card))
1416 return 0;
1417
1418 return mmc_erase(test->card, t->dev_addr, test->area.max_sz >> 9,
1419 MMC_ERASE_ARG);
1420 }
1421
1422 /*
1423 * Cleanup struct mmc_test_area.
1424 */
1425 static int mmc_test_area_cleanup(struct mmc_test_card *test)
1426 {
1427 struct mmc_test_area *t = &test->area;
1428
1429 kfree(t->sg);
1430 mmc_test_free_mem(t->mem);
1431
1432 return 0;
1433 }
1434
1435 /*
1436 * Initialize an area for testing large transfers. The test area is set to the
1437 * middle of the card because cards may have different charateristics at the
1438 * front (for FAT file system optimization). Optionally, the area is erased
1439 * (if the card supports it) which may improve write performance. Optionally,
1440 * the area is filled with data for subsequent read tests.
1441 */
1442 static int mmc_test_area_init(struct mmc_test_card *test, int erase, int fill)
1443 {
1444 struct mmc_test_area *t = &test->area;
1445 unsigned long min_sz = 64 * 1024, sz;
1446 int ret;
1447
1448 ret = mmc_test_set_blksize(test, 512);
1449 if (ret)
1450 return ret;
1451
1452 /* Make the test area size about 4MiB */
1453 sz = (unsigned long)test->card->pref_erase << 9;
1454 t->max_sz = sz;
1455 while (t->max_sz < 4 * 1024 * 1024)
1456 t->max_sz += sz;
1457 while (t->max_sz > TEST_AREA_MAX_SIZE && t->max_sz > sz)
1458 t->max_sz -= sz;
1459
1460 t->max_segs = test->card->host->max_segs;
1461 t->max_seg_sz = test->card->host->max_seg_size;
1462
1463 t->max_tfr = t->max_sz;
1464 if (t->max_tfr >> 9 > test->card->host->max_blk_count)
1465 t->max_tfr = test->card->host->max_blk_count << 9;
1466 if (t->max_tfr > test->card->host->max_req_size)
1467 t->max_tfr = test->card->host->max_req_size;
1468 if (t->max_tfr / t->max_seg_sz > t->max_segs)
1469 t->max_tfr = t->max_segs * t->max_seg_sz;
1470
1471 /*
1472 * Try to allocate enough memory for a max. sized transfer. Less is OK
1473 * because the same memory can be mapped into the scatterlist more than
1474 * once. Also, take into account the limits imposed on scatterlist
1475 * segments by the host driver.
1476 */
1477 t->mem = mmc_test_alloc_mem(min_sz, t->max_tfr, t->max_segs,
1478 t->max_seg_sz);
1479 if (!t->mem)
1480 return -ENOMEM;
1481
1482 t->sg = kmalloc(sizeof(struct scatterlist) * t->max_segs, GFP_KERNEL);
1483 if (!t->sg) {
1484 ret = -ENOMEM;
1485 goto out_free;
1486 }
1487
1488 t->dev_addr = mmc_test_capacity(test->card) / 2;
1489 t->dev_addr -= t->dev_addr % (t->max_sz >> 9);
1490
1491 if (erase) {
1492 ret = mmc_test_area_erase(test);
1493 if (ret)
1494 goto out_free;
1495 }
1496
1497 if (fill) {
1498 ret = mmc_test_area_fill(test);
1499 if (ret)
1500 goto out_free;
1501 }
1502
1503 return 0;
1504
1505 out_free:
1506 mmc_test_area_cleanup(test);
1507 return ret;
1508 }
1509
1510 /*
1511 * Prepare for large transfers. Do not erase the test area.
1512 */
1513 static int mmc_test_area_prepare(struct mmc_test_card *test)
1514 {
1515 return mmc_test_area_init(test, 0, 0);
1516 }
1517
1518 /*
1519 * Prepare for large transfers. Do erase the test area.
1520 */
1521 static int mmc_test_area_prepare_erase(struct mmc_test_card *test)
1522 {
1523 return mmc_test_area_init(test, 1, 0);
1524 }
1525
1526 /*
1527 * Prepare for large transfers. Erase and fill the test area.
1528 */
1529 static int mmc_test_area_prepare_fill(struct mmc_test_card *test)
1530 {
1531 return mmc_test_area_init(test, 1, 1);
1532 }
1533
1534 /*
1535 * Test best-case performance. Best-case performance is expected from
1536 * a single large transfer.
1537 *
1538 * An additional option (max_scatter) allows the measurement of the same
1539 * transfer but with no contiguous pages in the scatter list. This tests
1540 * the efficiency of DMA to handle scattered pages.
1541 */
1542 static int mmc_test_best_performance(struct mmc_test_card *test, int write,
1543 int max_scatter)
1544 {
1545 return mmc_test_area_io(test, test->area.max_tfr, test->area.dev_addr,
1546 write, max_scatter, 1);
1547 }
1548
1549 /*
1550 * Best-case read performance.
1551 */
1552 static int mmc_test_best_read_performance(struct mmc_test_card *test)
1553 {
1554 return mmc_test_best_performance(test, 0, 0);
1555 }
1556
1557 /*
1558 * Best-case write performance.
1559 */
1560 static int mmc_test_best_write_performance(struct mmc_test_card *test)
1561 {
1562 return mmc_test_best_performance(test, 1, 0);
1563 }
1564
1565 /*
1566 * Best-case read performance into scattered pages.
1567 */
1568 static int mmc_test_best_read_perf_max_scatter(struct mmc_test_card *test)
1569 {
1570 return mmc_test_best_performance(test, 0, 1);
1571 }
1572
1573 /*
1574 * Best-case write performance from scattered pages.
1575 */
1576 static int mmc_test_best_write_perf_max_scatter(struct mmc_test_card *test)
1577 {
1578 return mmc_test_best_performance(test, 1, 1);
1579 }
1580
1581 /*
1582 * Single read performance by transfer size.
1583 */
1584 static int mmc_test_profile_read_perf(struct mmc_test_card *test)
1585 {
1586 unsigned long sz;
1587 unsigned int dev_addr;
1588 int ret;
1589
1590 for (sz = 512; sz < test->area.max_tfr; sz <<= 1) {
1591 dev_addr = test->area.dev_addr + (sz >> 9);
1592 ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
1593 if (ret)
1594 return ret;
1595 }
1596 sz = test->area.max_tfr;
1597 dev_addr = test->area.dev_addr;
1598 return mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
1599 }
1600
1601 /*
1602 * Single write performance by transfer size.
1603 */
1604 static int mmc_test_profile_write_perf(struct mmc_test_card *test)
1605 {
1606 unsigned long sz;
1607 unsigned int dev_addr;
1608 int ret;
1609
1610 ret = mmc_test_area_erase(test);
1611 if (ret)
1612 return ret;
1613 for (sz = 512; sz < test->area.max_tfr; sz <<= 1) {
1614 dev_addr = test->area.dev_addr + (sz >> 9);
1615 ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
1616 if (ret)
1617 return ret;
1618 }
1619 ret = mmc_test_area_erase(test);
1620 if (ret)
1621 return ret;
1622 sz = test->area.max_tfr;
1623 dev_addr = test->area.dev_addr;
1624 return mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
1625 }
1626
1627 /*
1628 * Single trim performance by transfer size.
1629 */
1630 static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
1631 {
1632 unsigned long sz;
1633 unsigned int dev_addr;
1634 struct timespec ts1, ts2;
1635 int ret;
1636
1637 if (!mmc_can_trim(test->card))
1638 return RESULT_UNSUP_CARD;
1639
1640 if (!mmc_can_erase(test->card))
1641 return RESULT_UNSUP_HOST;
1642
1643 for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
1644 dev_addr = test->area.dev_addr + (sz >> 9);
1645 getnstimeofday(&ts1);
1646 ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
1647 if (ret)
1648 return ret;
1649 getnstimeofday(&ts2);
1650 mmc_test_print_rate(test, sz, &ts1, &ts2);
1651 }
1652 dev_addr = test->area.dev_addr;
1653 getnstimeofday(&ts1);
1654 ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
1655 if (ret)
1656 return ret;
1657 getnstimeofday(&ts2);
1658 mmc_test_print_rate(test, sz, &ts1, &ts2);
1659 return 0;
1660 }
1661
1662 static int mmc_test_seq_read_perf(struct mmc_test_card *test, unsigned long sz)
1663 {
1664 unsigned int dev_addr, i, cnt;
1665 struct timespec ts1, ts2;
1666 int ret;
1667
1668 cnt = test->area.max_sz / sz;
1669 dev_addr = test->area.dev_addr;
1670 getnstimeofday(&ts1);
1671 for (i = 0; i < cnt; i++) {
1672 ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
1673 if (ret)
1674 return ret;
1675 dev_addr += (sz >> 9);
1676 }
1677 getnstimeofday(&ts2);
1678 mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1679 return 0;
1680 }
1681
1682 /*
1683 * Consecutive read performance by transfer size.
1684 */
1685 static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
1686 {
1687 unsigned long sz;
1688 int ret;
1689
1690 for (sz = 512; sz < test->area.max_tfr; sz <<= 1) {
1691 ret = mmc_test_seq_read_perf(test, sz);
1692 if (ret)
1693 return ret;
1694 }
1695 sz = test->area.max_tfr;
1696 return mmc_test_seq_read_perf(test, sz);
1697 }
1698
1699 static int mmc_test_seq_write_perf(struct mmc_test_card *test, unsigned long sz)
1700 {
1701 unsigned int dev_addr, i, cnt;
1702 struct timespec ts1, ts2;
1703 int ret;
1704
1705 ret = mmc_test_area_erase(test);
1706 if (ret)
1707 return ret;
1708 cnt = test->area.max_sz / sz;
1709 dev_addr = test->area.dev_addr;
1710 getnstimeofday(&ts1);
1711 for (i = 0; i < cnt; i++) {
1712 ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
1713 if (ret)
1714 return ret;
1715 dev_addr += (sz >> 9);
1716 }
1717 getnstimeofday(&ts2);
1718 mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1719 return 0;
1720 }
1721
1722 /*
1723 * Consecutive write performance by transfer size.
1724 */
1725 static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
1726 {
1727 unsigned long sz;
1728 int ret;
1729
1730 for (sz = 512; sz < test->area.max_tfr; sz <<= 1) {
1731 ret = mmc_test_seq_write_perf(test, sz);
1732 if (ret)
1733 return ret;
1734 }
1735 sz = test->area.max_tfr;
1736 return mmc_test_seq_write_perf(test, sz);
1737 }
1738
1739 /*
1740 * Consecutive trim performance by transfer size.
1741 */
1742 static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
1743 {
1744 unsigned long sz;
1745 unsigned int dev_addr, i, cnt;
1746 struct timespec 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 <= test->area.max_sz; sz <<= 1) {
1756 ret = mmc_test_area_erase(test);
1757 if (ret)
1758 return ret;
1759 ret = mmc_test_area_fill(test);
1760 if (ret)
1761 return ret;
1762 cnt = test->area.max_sz / sz;
1763 dev_addr = test->area.dev_addr;
1764 getnstimeofday(&ts1);
1765 for (i = 0; i < cnt; i++) {
1766 ret = mmc_erase(test->card, dev_addr, sz >> 9,
1767 MMC_TRIM_ARG);
1768 if (ret)
1769 return ret;
1770 dev_addr += (sz >> 9);
1771 }
1772 getnstimeofday(&ts2);
1773 mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1774 }
1775 return 0;
1776 }
1777
1778 static unsigned int rnd_next = 1;
1779
1780 static unsigned int mmc_test_rnd_num(unsigned int rnd_cnt)
1781 {
1782 uint64_t r;
1783
1784 rnd_next = rnd_next * 1103515245 + 12345;
1785 r = (rnd_next >> 16) & 0x7fff;
1786 return (r * rnd_cnt) >> 15;
1787 }
1788
1789 static int mmc_test_rnd_perf(struct mmc_test_card *test, int write, int print,
1790 unsigned long sz)
1791 {
1792 unsigned int dev_addr, cnt, rnd_addr, range1, range2, last_ea = 0, ea;
1793 unsigned int ssz;
1794 struct timespec ts1, ts2, ts;
1795 int ret;
1796
1797 ssz = sz >> 9;
1798
1799 rnd_addr = mmc_test_capacity(test->card) / 4;
1800 range1 = rnd_addr / test->card->pref_erase;
1801 range2 = range1 / ssz;
1802
1803 getnstimeofday(&ts1);
1804 for (cnt = 0; cnt < UINT_MAX; cnt++) {
1805 getnstimeofday(&ts2);
1806 ts = timespec_sub(ts2, ts1);
1807 if (ts.tv_sec >= 10)
1808 break;
1809 ea = mmc_test_rnd_num(range1);
1810 if (ea == last_ea)
1811 ea -= 1;
1812 last_ea = ea;
1813 dev_addr = rnd_addr + test->card->pref_erase * ea +
1814 ssz * mmc_test_rnd_num(range2);
1815 ret = mmc_test_area_io(test, sz, dev_addr, write, 0, 0);
1816 if (ret)
1817 return ret;
1818 }
1819 if (print)
1820 mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1821 return 0;
1822 }
1823
1824 static int mmc_test_random_perf(struct mmc_test_card *test, int write)
1825 {
1826 unsigned int next;
1827 unsigned long sz;
1828 int ret;
1829
1830 for (sz = 512; sz < test->area.max_tfr; sz <<= 1) {
1831 /*
1832 * When writing, try to get more consistent results by running
1833 * the test twice with exactly the same I/O but outputting the
1834 * results only for the 2nd run.
1835 */
1836 if (write) {
1837 next = rnd_next;
1838 ret = mmc_test_rnd_perf(test, write, 0, sz);
1839 if (ret)
1840 return ret;
1841 rnd_next = next;
1842 }
1843 ret = mmc_test_rnd_perf(test, write, 1, sz);
1844 if (ret)
1845 return ret;
1846 }
1847 sz = test->area.max_tfr;
1848 if (write) {
1849 next = rnd_next;
1850 ret = mmc_test_rnd_perf(test, write, 0, sz);
1851 if (ret)
1852 return ret;
1853 rnd_next = next;
1854 }
1855 return mmc_test_rnd_perf(test, write, 1, sz);
1856 }
1857
1858 /*
1859 * Random read performance by transfer size.
1860 */
1861 static int mmc_test_random_read_perf(struct mmc_test_card *test)
1862 {
1863 return mmc_test_random_perf(test, 0);
1864 }
1865
1866 /*
1867 * Random write performance by transfer size.
1868 */
1869 static int mmc_test_random_write_perf(struct mmc_test_card *test)
1870 {
1871 return mmc_test_random_perf(test, 1);
1872 }
1873
1874 static int mmc_test_seq_perf(struct mmc_test_card *test, int write,
1875 unsigned int tot_sz, int max_scatter)
1876 {
1877 unsigned int dev_addr, i, cnt, sz, ssz;
1878 struct timespec ts1, ts2, ts;
1879 int ret;
1880
1881 sz = test->area.max_tfr;
1882 /*
1883 * In the case of a maximally scattered transfer, the maximum transfer
1884 * size is further limited by using PAGE_SIZE segments.
1885 */
1886 if (max_scatter) {
1887 struct mmc_test_area *t = &test->area;
1888 unsigned long max_tfr;
1889
1890 if (t->max_seg_sz >= PAGE_SIZE)
1891 max_tfr = t->max_segs * PAGE_SIZE;
1892 else
1893 max_tfr = t->max_segs * t->max_seg_sz;
1894 if (sz > max_tfr)
1895 sz = max_tfr;
1896 }
1897
1898 ssz = sz >> 9;
1899 dev_addr = mmc_test_capacity(test->card) / 4;
1900 if (tot_sz > dev_addr << 9)
1901 tot_sz = dev_addr << 9;
1902 cnt = tot_sz / sz;
1903 dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
1904
1905 getnstimeofday(&ts1);
1906 for (i = 0; i < cnt; i++) {
1907 ret = mmc_test_area_io(test, sz, dev_addr, write,
1908 max_scatter, 0);
1909 if (ret)
1910 return ret;
1911 dev_addr += ssz;
1912 }
1913 getnstimeofday(&ts2);
1914
1915 ts = timespec_sub(ts2, ts1);
1916 mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
1917
1918 return 0;
1919 }
1920
1921 static int mmc_test_large_seq_perf(struct mmc_test_card *test, int write)
1922 {
1923 int ret, i;
1924
1925 for (i = 0; i < 10; i++) {
1926 ret = mmc_test_seq_perf(test, write, 10 * 1024 * 1024, 1);
1927 if (ret)
1928 return ret;
1929 }
1930 for (i = 0; i < 5; i++) {
1931 ret = mmc_test_seq_perf(test, write, 100 * 1024 * 1024, 1);
1932 if (ret)
1933 return ret;
1934 }
1935 for (i = 0; i < 3; i++) {
1936 ret = mmc_test_seq_perf(test, write, 1000 * 1024 * 1024, 1);
1937 if (ret)
1938 return ret;
1939 }
1940
1941 return ret;
1942 }
1943
1944 /*
1945 * Large sequential read performance.
1946 */
1947 static int mmc_test_large_seq_read_perf(struct mmc_test_card *test)
1948 {
1949 return mmc_test_large_seq_perf(test, 0);
1950 }
1951
1952 /*
1953 * Large sequential write performance.
1954 */
1955 static int mmc_test_large_seq_write_perf(struct mmc_test_card *test)
1956 {
1957 return mmc_test_large_seq_perf(test, 1);
1958 }
1959
1960 static const struct mmc_test_case mmc_test_cases[] = {
1961 {
1962 .name = "Basic write (no data verification)",
1963 .run = mmc_test_basic_write,
1964 },
1965
1966 {
1967 .name = "Basic read (no data verification)",
1968 .run = mmc_test_basic_read,
1969 },
1970
1971 {
1972 .name = "Basic write (with data verification)",
1973 .prepare = mmc_test_prepare_write,
1974 .run = mmc_test_verify_write,
1975 .cleanup = mmc_test_cleanup,
1976 },
1977
1978 {
1979 .name = "Basic read (with data verification)",
1980 .prepare = mmc_test_prepare_read,
1981 .run = mmc_test_verify_read,
1982 .cleanup = mmc_test_cleanup,
1983 },
1984
1985 {
1986 .name = "Multi-block write",
1987 .prepare = mmc_test_prepare_write,
1988 .run = mmc_test_multi_write,
1989 .cleanup = mmc_test_cleanup,
1990 },
1991
1992 {
1993 .name = "Multi-block read",
1994 .prepare = mmc_test_prepare_read,
1995 .run = mmc_test_multi_read,
1996 .cleanup = mmc_test_cleanup,
1997 },
1998
1999 {
2000 .name = "Power of two block writes",
2001 .prepare = mmc_test_prepare_write,
2002 .run = mmc_test_pow2_write,
2003 .cleanup = mmc_test_cleanup,
2004 },
2005
2006 {
2007 .name = "Power of two block reads",
2008 .prepare = mmc_test_prepare_read,
2009 .run = mmc_test_pow2_read,
2010 .cleanup = mmc_test_cleanup,
2011 },
2012
2013 {
2014 .name = "Weird sized block writes",
2015 .prepare = mmc_test_prepare_write,
2016 .run = mmc_test_weird_write,
2017 .cleanup = mmc_test_cleanup,
2018 },
2019
2020 {
2021 .name = "Weird sized block reads",
2022 .prepare = mmc_test_prepare_read,
2023 .run = mmc_test_weird_read,
2024 .cleanup = mmc_test_cleanup,
2025 },
2026
2027 {
2028 .name = "Badly aligned write",
2029 .prepare = mmc_test_prepare_write,
2030 .run = mmc_test_align_write,
2031 .cleanup = mmc_test_cleanup,
2032 },
2033
2034 {
2035 .name = "Badly aligned read",
2036 .prepare = mmc_test_prepare_read,
2037 .run = mmc_test_align_read,
2038 .cleanup = mmc_test_cleanup,
2039 },
2040
2041 {
2042 .name = "Badly aligned multi-block write",
2043 .prepare = mmc_test_prepare_write,
2044 .run = mmc_test_align_multi_write,
2045 .cleanup = mmc_test_cleanup,
2046 },
2047
2048 {
2049 .name = "Badly aligned multi-block read",
2050 .prepare = mmc_test_prepare_read,
2051 .run = mmc_test_align_multi_read,
2052 .cleanup = mmc_test_cleanup,
2053 },
2054
2055 {
2056 .name = "Correct xfer_size at write (start failure)",
2057 .run = mmc_test_xfersize_write,
2058 },
2059
2060 {
2061 .name = "Correct xfer_size at read (start failure)",
2062 .run = mmc_test_xfersize_read,
2063 },
2064
2065 {
2066 .name = "Correct xfer_size at write (midway failure)",
2067 .run = mmc_test_multi_xfersize_write,
2068 },
2069
2070 {
2071 .name = "Correct xfer_size at read (midway failure)",
2072 .run = mmc_test_multi_xfersize_read,
2073 },
2074
2075 #ifdef CONFIG_HIGHMEM
2076
2077 {
2078 .name = "Highmem write",
2079 .prepare = mmc_test_prepare_write,
2080 .run = mmc_test_write_high,
2081 .cleanup = mmc_test_cleanup,
2082 },
2083
2084 {
2085 .name = "Highmem read",
2086 .prepare = mmc_test_prepare_read,
2087 .run = mmc_test_read_high,
2088 .cleanup = mmc_test_cleanup,
2089 },
2090
2091 {
2092 .name = "Multi-block highmem write",
2093 .prepare = mmc_test_prepare_write,
2094 .run = mmc_test_multi_write_high,
2095 .cleanup = mmc_test_cleanup,
2096 },
2097
2098 {
2099 .name = "Multi-block highmem read",
2100 .prepare = mmc_test_prepare_read,
2101 .run = mmc_test_multi_read_high,
2102 .cleanup = mmc_test_cleanup,
2103 },
2104
2105 #else
2106
2107 {
2108 .name = "Highmem write",
2109 .run = mmc_test_no_highmem,
2110 },
2111
2112 {
2113 .name = "Highmem read",
2114 .run = mmc_test_no_highmem,
2115 },
2116
2117 {
2118 .name = "Multi-block highmem write",
2119 .run = mmc_test_no_highmem,
2120 },
2121
2122 {
2123 .name = "Multi-block highmem read",
2124 .run = mmc_test_no_highmem,
2125 },
2126
2127 #endif /* CONFIG_HIGHMEM */
2128
2129 {
2130 .name = "Best-case read performance",
2131 .prepare = mmc_test_area_prepare_fill,
2132 .run = mmc_test_best_read_performance,
2133 .cleanup = mmc_test_area_cleanup,
2134 },
2135
2136 {
2137 .name = "Best-case write performance",
2138 .prepare = mmc_test_area_prepare_erase,
2139 .run = mmc_test_best_write_performance,
2140 .cleanup = mmc_test_area_cleanup,
2141 },
2142
2143 {
2144 .name = "Best-case read performance into scattered pages",
2145 .prepare = mmc_test_area_prepare_fill,
2146 .run = mmc_test_best_read_perf_max_scatter,
2147 .cleanup = mmc_test_area_cleanup,
2148 },
2149
2150 {
2151 .name = "Best-case write performance from scattered pages",
2152 .prepare = mmc_test_area_prepare_erase,
2153 .run = mmc_test_best_write_perf_max_scatter,
2154 .cleanup = mmc_test_area_cleanup,
2155 },
2156
2157 {
2158 .name = "Single read performance by transfer size",
2159 .prepare = mmc_test_area_prepare_fill,
2160 .run = mmc_test_profile_read_perf,
2161 .cleanup = mmc_test_area_cleanup,
2162 },
2163
2164 {
2165 .name = "Single write performance by transfer size",
2166 .prepare = mmc_test_area_prepare,
2167 .run = mmc_test_profile_write_perf,
2168 .cleanup = mmc_test_area_cleanup,
2169 },
2170
2171 {
2172 .name = "Single trim performance by transfer size",
2173 .prepare = mmc_test_area_prepare_fill,
2174 .run = mmc_test_profile_trim_perf,
2175 .cleanup = mmc_test_area_cleanup,
2176 },
2177
2178 {
2179 .name = "Consecutive read performance by transfer size",
2180 .prepare = mmc_test_area_prepare_fill,
2181 .run = mmc_test_profile_seq_read_perf,
2182 .cleanup = mmc_test_area_cleanup,
2183 },
2184
2185 {
2186 .name = "Consecutive write performance by transfer size",
2187 .prepare = mmc_test_area_prepare,
2188 .run = mmc_test_profile_seq_write_perf,
2189 .cleanup = mmc_test_area_cleanup,
2190 },
2191
2192 {
2193 .name = "Consecutive trim performance by transfer size",
2194 .prepare = mmc_test_area_prepare,
2195 .run = mmc_test_profile_seq_trim_perf,
2196 .cleanup = mmc_test_area_cleanup,
2197 },
2198
2199 {
2200 .name = "Random read performance by transfer size",
2201 .prepare = mmc_test_area_prepare,
2202 .run = mmc_test_random_read_perf,
2203 .cleanup = mmc_test_area_cleanup,
2204 },
2205
2206 {
2207 .name = "Random write performance by transfer size",
2208 .prepare = mmc_test_area_prepare,
2209 .run = mmc_test_random_write_perf,
2210 .cleanup = mmc_test_area_cleanup,
2211 },
2212
2213 {
2214 .name = "Large sequential read into scattered pages",
2215 .prepare = mmc_test_area_prepare,
2216 .run = mmc_test_large_seq_read_perf,
2217 .cleanup = mmc_test_area_cleanup,
2218 },
2219
2220 {
2221 .name = "Large sequential write from scattered pages",
2222 .prepare = mmc_test_area_prepare,
2223 .run = mmc_test_large_seq_write_perf,
2224 .cleanup = mmc_test_area_cleanup,
2225 },
2226
2227 };
2228
2229 static DEFINE_MUTEX(mmc_test_lock);
2230
2231 static LIST_HEAD(mmc_test_result);
2232
2233 static void mmc_test_run(struct mmc_test_card *test, int testcase)
2234 {
2235 int i, ret;
2236
2237 printk(KERN_INFO "%s: Starting tests of card %s...\n",
2238 mmc_hostname(test->card->host), mmc_card_id(test->card));
2239
2240 mmc_claim_host(test->card->host);
2241
2242 for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {
2243 struct mmc_test_general_result *gr;
2244
2245 if (testcase && ((i + 1) != testcase))
2246 continue;
2247
2248 printk(KERN_INFO "%s: Test case %d. %s...\n",
2249 mmc_hostname(test->card->host), i + 1,
2250 mmc_test_cases[i].name);
2251
2252 if (mmc_test_cases[i].prepare) {
2253 ret = mmc_test_cases[i].prepare(test);
2254 if (ret) {
2255 printk(KERN_INFO "%s: Result: Prepare "
2256 "stage failed! (%d)\n",
2257 mmc_hostname(test->card->host),
2258 ret);
2259 continue;
2260 }
2261 }
2262
2263 gr = kzalloc(sizeof(struct mmc_test_general_result),
2264 GFP_KERNEL);
2265 if (gr) {
2266 INIT_LIST_HEAD(&gr->tr_lst);
2267
2268 /* Assign data what we know already */
2269 gr->card = test->card;
2270 gr->testcase = i;
2271
2272 /* Append container to global one */
2273 list_add_tail(&gr->link, &mmc_test_result);
2274
2275 /*
2276 * Save the pointer to created container in our private
2277 * structure.
2278 */
2279 test->gr = gr;
2280 }
2281
2282 ret = mmc_test_cases[i].run(test);
2283 switch (ret) {
2284 case RESULT_OK:
2285 printk(KERN_INFO "%s: Result: OK\n",
2286 mmc_hostname(test->card->host));
2287 break;
2288 case RESULT_FAIL:
2289 printk(KERN_INFO "%s: Result: FAILED\n",
2290 mmc_hostname(test->card->host));
2291 break;
2292 case RESULT_UNSUP_HOST:
2293 printk(KERN_INFO "%s: Result: UNSUPPORTED "
2294 "(by host)\n",
2295 mmc_hostname(test->card->host));
2296 break;
2297 case RESULT_UNSUP_CARD:
2298 printk(KERN_INFO "%s: Result: UNSUPPORTED "
2299 "(by card)\n",
2300 mmc_hostname(test->card->host));
2301 break;
2302 default:
2303 printk(KERN_INFO "%s: Result: ERROR (%d)\n",
2304 mmc_hostname(test->card->host), ret);
2305 }
2306
2307 /* Save the result */
2308 if (gr)
2309 gr->result = ret;
2310
2311 if (mmc_test_cases[i].cleanup) {
2312 ret = mmc_test_cases[i].cleanup(test);
2313 if (ret) {
2314 printk(KERN_INFO "%s: Warning: Cleanup "
2315 "stage failed! (%d)\n",
2316 mmc_hostname(test->card->host),
2317 ret);
2318 }
2319 }
2320 }
2321
2322 mmc_release_host(test->card->host);
2323
2324 printk(KERN_INFO "%s: Tests completed.\n",
2325 mmc_hostname(test->card->host));
2326 }
2327
2328 static void mmc_test_free_result(struct mmc_card *card)
2329 {
2330 struct mmc_test_general_result *gr, *grs;
2331
2332 mutex_lock(&mmc_test_lock);
2333
2334 list_for_each_entry_safe(gr, grs, &mmc_test_result, link) {
2335 struct mmc_test_transfer_result *tr, *trs;
2336
2337 if (card && gr->card != card)
2338 continue;
2339
2340 list_for_each_entry_safe(tr, trs, &gr->tr_lst, link) {
2341 list_del(&tr->link);
2342 kfree(tr);
2343 }
2344
2345 list_del(&gr->link);
2346 kfree(gr);
2347 }
2348
2349 mutex_unlock(&mmc_test_lock);
2350 }
2351
2352 static LIST_HEAD(mmc_test_file_test);
2353
2354 static int mtf_test_show(struct seq_file *sf, void *data)
2355 {
2356 struct mmc_card *card = (struct mmc_card *)sf->private;
2357 struct mmc_test_general_result *gr;
2358
2359 mutex_lock(&mmc_test_lock);
2360
2361 list_for_each_entry(gr, &mmc_test_result, link) {
2362 struct mmc_test_transfer_result *tr;
2363
2364 if (gr->card != card)
2365 continue;
2366
2367 seq_printf(sf, "Test %d: %d\n", gr->testcase + 1, gr->result);
2368
2369 list_for_each_entry(tr, &gr->tr_lst, link) {
2370 seq_printf(sf, "%u %d %lu.%09lu %u %u.%02u\n",
2371 tr->count, tr->sectors,
2372 (unsigned long)tr->ts.tv_sec,
2373 (unsigned long)tr->ts.tv_nsec,
2374 tr->rate, tr->iops / 100, tr->iops % 100);
2375 }
2376 }
2377
2378 mutex_unlock(&mmc_test_lock);
2379
2380 return 0;
2381 }
2382
2383 static int mtf_test_open(struct inode *inode, struct file *file)
2384 {
2385 return single_open(file, mtf_test_show, inode->i_private);
2386 }
2387
2388 static ssize_t mtf_test_write(struct file *file, const char __user *buf,
2389 size_t count, loff_t *pos)
2390 {
2391 struct seq_file *sf = (struct seq_file *)file->private_data;
2392 struct mmc_card *card = (struct mmc_card *)sf->private;
2393 struct mmc_test_card *test;
2394 char lbuf[12];
2395 long testcase;
2396
2397 if (count >= sizeof(lbuf))
2398 return -EINVAL;
2399
2400 if (copy_from_user(lbuf, buf, count))
2401 return -EFAULT;
2402 lbuf[count] = '\0';
2403
2404 if (strict_strtol(lbuf, 10, &testcase))
2405 return -EINVAL;
2406
2407 test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);
2408 if (!test)
2409 return -ENOMEM;
2410
2411 /*
2412 * Remove all test cases associated with given card. Thus we have only
2413 * actual data of the last run.
2414 */
2415 mmc_test_free_result(card);
2416
2417 test->card = card;
2418
2419 test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
2420 #ifdef CONFIG_HIGHMEM
2421 test->highmem = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM, BUFFER_ORDER);
2422 #endif
2423
2424 #ifdef CONFIG_HIGHMEM
2425 if (test->buffer && test->highmem) {
2426 #else
2427 if (test->buffer) {
2428 #endif
2429 mutex_lock(&mmc_test_lock);
2430 mmc_test_run(test, testcase);
2431 mutex_unlock(&mmc_test_lock);
2432 }
2433
2434 #ifdef CONFIG_HIGHMEM
2435 __free_pages(test->highmem, BUFFER_ORDER);
2436 #endif
2437 kfree(test->buffer);
2438 kfree(test);
2439
2440 return count;
2441 }
2442
2443 static const struct file_operations mmc_test_fops_test = {
2444 .open = mtf_test_open,
2445 .read = seq_read,
2446 .write = mtf_test_write,
2447 .llseek = seq_lseek,
2448 .release = single_release,
2449 };
2450
2451 static void mmc_test_free_file_test(struct mmc_card *card)
2452 {
2453 struct mmc_test_dbgfs_file *df, *dfs;
2454
2455 mutex_lock(&mmc_test_lock);
2456
2457 list_for_each_entry_safe(df, dfs, &mmc_test_file_test, link) {
2458 if (card && df->card != card)
2459 continue;
2460 debugfs_remove(df->file);
2461 list_del(&df->link);
2462 kfree(df);
2463 }
2464
2465 mutex_unlock(&mmc_test_lock);
2466 }
2467
2468 static int mmc_test_register_file_test(struct mmc_card *card)
2469 {
2470 struct dentry *file = NULL;
2471 struct mmc_test_dbgfs_file *df;
2472 int ret = 0;
2473
2474 mutex_lock(&mmc_test_lock);
2475
2476 if (card->debugfs_root)
2477 file = debugfs_create_file("test", S_IWUSR | S_IRUGO,
2478 card->debugfs_root, card, &mmc_test_fops_test);
2479
2480 if (IS_ERR_OR_NULL(file)) {
2481 dev_err(&card->dev,
2482 "Can't create file. Perhaps debugfs is disabled.\n");
2483 ret = -ENODEV;
2484 goto err;
2485 }
2486
2487 df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL);
2488 if (!df) {
2489 debugfs_remove(file);
2490 dev_err(&card->dev,
2491 "Can't allocate memory for internal usage.\n");
2492 ret = -ENOMEM;
2493 goto err;
2494 }
2495
2496 df->card = card;
2497 df->file = file;
2498
2499 list_add(&df->link, &mmc_test_file_test);
2500
2501 err:
2502 mutex_unlock(&mmc_test_lock);
2503
2504 return ret;
2505 }
2506
2507 static int mmc_test_probe(struct mmc_card *card)
2508 {
2509 int ret;
2510
2511 if (!mmc_card_mmc(card) && !mmc_card_sd(card))
2512 return -ENODEV;
2513
2514 ret = mmc_test_register_file_test(card);
2515 if (ret)
2516 return ret;
2517
2518 dev_info(&card->dev, "Card claimed for testing.\n");
2519
2520 return 0;
2521 }
2522
2523 static void mmc_test_remove(struct mmc_card *card)
2524 {
2525 mmc_test_free_result(card);
2526 mmc_test_free_file_test(card);
2527 }
2528
2529 static struct mmc_driver mmc_driver = {
2530 .drv = {
2531 .name = "mmc_test",
2532 },
2533 .probe = mmc_test_probe,
2534 .remove = mmc_test_remove,
2535 };
2536
2537 static int __init mmc_test_init(void)
2538 {
2539 return mmc_register_driver(&mmc_driver);
2540 }
2541
2542 static void __exit mmc_test_exit(void)
2543 {
2544 /* Clear stalled data if card is still plugged */
2545 mmc_test_free_result(NULL);
2546 mmc_test_free_file_test(NULL);
2547
2548 mmc_unregister_driver(&mmc_driver);
2549 }
2550
2551 module_init(mmc_test_init);
2552 module_exit(mmc_test_exit);
2553
2554 MODULE_LICENSE("GPL");
2555 MODULE_DESCRIPTION("Multimedia Card (MMC) host test driver");
2556 MODULE_AUTHOR("Pierre Ossman");
Linux kernel - Deliverables
This page took 0.087588 seconds and 6 git commands to generate.