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