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