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, int secs, int force_retuning) 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 >= secs) 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 if (force_retuning) 1933 mmc_retune_needed(test->card->host); 1934 ret = mmc_test_area_io(test, sz, dev_addr, write, 0, 0); 1935 if (ret) 1936 return ret; 1937 } 1938 if (print) 1939 mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2); 1940 return 0; 1941 } 1942 1943 static int mmc_test_random_perf(struct mmc_test_card *test, int write) 1944 { 1945 struct mmc_test_area *t = &test->area; 1946 unsigned int next; 1947 unsigned long sz; 1948 int ret; 1949 1950 for (sz = 512; sz < t->max_tfr; sz <<= 1) { 1951 /* 1952 * When writing, try to get more consistent results by running 1953 * the test twice with exactly the same I/O but outputting the 1954 * results only for the 2nd run. 1955 */ 1956 if (write) { 1957 next = rnd_next; 1958 ret = mmc_test_rnd_perf(test, write, 0, sz, 10, 0); 1959 if (ret) 1960 return ret; 1961 rnd_next = next; 1962 } 1963 ret = mmc_test_rnd_perf(test, write, 1, sz, 10, 0); 1964 if (ret) 1965 return ret; 1966 } 1967 sz = t->max_tfr; 1968 if (write) { 1969 next = rnd_next; 1970 ret = mmc_test_rnd_perf(test, write, 0, sz, 10, 0); 1971 if (ret) 1972 return ret; 1973 rnd_next = next; 1974 } 1975 return mmc_test_rnd_perf(test, write, 1, sz, 10, 0); 1976 } 1977 1978 static int mmc_test_retuning(struct mmc_test_card *test) 1979 { 1980 if (!mmc_can_retune(test->card->host)) { 1981 pr_info("%s: No retuning - test skipped\n", 1982 mmc_hostname(test->card->host)); 1983 return RESULT_UNSUP_HOST; 1984 } 1985 1986 return mmc_test_rnd_perf(test, 0, 0, 8192, 30, 1); 1987 } 1988 1989 /* 1990 * Random read performance by transfer size. 1991 */ 1992 static int mmc_test_random_read_perf(struct mmc_test_card *test) 1993 { 1994 return mmc_test_random_perf(test, 0); 1995 } 1996 1997 /* 1998 * Random write performance by transfer size. 1999 */ 2000 static int mmc_test_random_write_perf(struct mmc_test_card *test) 2001 { 2002 return mmc_test_random_perf(test, 1); 2003 } 2004 2005 static int mmc_test_seq_perf(struct mmc_test_card *test, int write, 2006 unsigned int tot_sz, int max_scatter) 2007 { 2008 struct mmc_test_area *t = &test->area; 2009 unsigned int dev_addr, i, cnt, sz, ssz; 2010 struct timespec64 ts1, ts2; 2011 int ret; 2012 2013 sz = t->max_tfr; 2014 2015 /* 2016 * In the case of a maximally scattered transfer, the maximum transfer 2017 * size is further limited by using PAGE_SIZE segments. 2018 */ 2019 if (max_scatter) { 2020 unsigned long max_tfr; 2021 2022 if (t->max_seg_sz >= PAGE_SIZE) 2023 max_tfr = t->max_segs * PAGE_SIZE; 2024 else 2025 max_tfr = t->max_segs * t->max_seg_sz; 2026 if (sz > max_tfr) 2027 sz = max_tfr; 2028 } 2029 2030 ssz = sz >> 9; 2031 dev_addr = mmc_test_capacity(test->card) / 4; 2032 if (tot_sz > dev_addr << 9) 2033 tot_sz = dev_addr << 9; 2034 cnt = tot_sz / sz; 2035 dev_addr &= 0xffff0000; /* Round to 64MiB boundary */ 2036 2037 ktime_get_ts64(&ts1); 2038 for (i = 0; i < cnt; i++) { 2039 ret = mmc_test_area_io(test, sz, dev_addr, write, 2040 max_scatter, 0); 2041 if (ret) 2042 return ret; 2043 dev_addr += ssz; 2044 } 2045 ktime_get_ts64(&ts2); 2046 2047 mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2); 2048 2049 return 0; 2050 } 2051 2052 static int mmc_test_large_seq_perf(struct mmc_test_card *test, int write) 2053 { 2054 int ret, i; 2055 2056 for (i = 0; i < 10; i++) { 2057 ret = mmc_test_seq_perf(test, write, 10 * 1024 * 1024, 1); 2058 if (ret) 2059 return ret; 2060 } 2061 for (i = 0; i < 5; i++) { 2062 ret = mmc_test_seq_perf(test, write, 100 * 1024 * 1024, 1); 2063 if (ret) 2064 return ret; 2065 } 2066 for (i = 0; i < 3; i++) { 2067 ret = mmc_test_seq_perf(test, write, 1000 * 1024 * 1024, 1); 2068 if (ret) 2069 return ret; 2070 } 2071 2072 return ret; 2073 } 2074 2075 /* 2076 * Large sequential read performance. 2077 */ 2078 static int mmc_test_large_seq_read_perf(struct mmc_test_card *test) 2079 { 2080 return mmc_test_large_seq_perf(test, 0); 2081 } 2082 2083 /* 2084 * Large sequential write performance. 2085 */ 2086 static int mmc_test_large_seq_write_perf(struct mmc_test_card *test) 2087 { 2088 return mmc_test_large_seq_perf(test, 1); 2089 } 2090 2091 static int mmc_test_rw_multiple(struct mmc_test_card *test, 2092 struct mmc_test_multiple_rw *tdata, 2093 unsigned int reqsize, unsigned int size, 2094 int min_sg_len) 2095 { 2096 unsigned int dev_addr; 2097 struct mmc_test_area *t = &test->area; 2098 int ret = 0; 2099 2100 /* Set up test area */ 2101 if (size > mmc_test_capacity(test->card) / 2 * 512) 2102 size = mmc_test_capacity(test->card) / 2 * 512; 2103 if (reqsize > t->max_tfr) 2104 reqsize = t->max_tfr; 2105 dev_addr = mmc_test_capacity(test->card) / 4; 2106 if ((dev_addr & 0xffff0000)) 2107 dev_addr &= 0xffff0000; /* Round to 64MiB boundary */ 2108 else 2109 dev_addr &= 0xfffff800; /* Round to 1MiB boundary */ 2110 if (!dev_addr) 2111 goto err; 2112 2113 if (reqsize > size) 2114 return 0; 2115 2116 /* prepare test area */ 2117 if (mmc_can_erase(test->card) && 2118 tdata->prepare & MMC_TEST_PREP_ERASE) { 2119 ret = mmc_erase(test->card, dev_addr, 2120 size / 512, test->card->erase_arg); 2121 if (ret) 2122 ret = mmc_erase(test->card, dev_addr, 2123 size / 512, MMC_ERASE_ARG); 2124 if (ret) 2125 goto err; 2126 } 2127 2128 /* Run test */ 2129 ret = mmc_test_area_io_seq(test, reqsize, dev_addr, 2130 tdata->do_write, 0, 1, size / reqsize, 2131 tdata->do_nonblock_req, min_sg_len); 2132 if (ret) 2133 goto err; 2134 2135 return ret; 2136 err: 2137 pr_info("[%s] error\n", __func__); 2138 return ret; 2139 } 2140 2141 static int mmc_test_rw_multiple_size(struct mmc_test_card *test, 2142 struct mmc_test_multiple_rw *rw) 2143 { 2144 int ret = 0; 2145 int i; 2146 void *pre_req = test->card->host->ops->pre_req; 2147 void *post_req = test->card->host->ops->post_req; 2148 2149 if (rw->do_nonblock_req && 2150 ((!pre_req && post_req) || (pre_req && !post_req))) { 2151 pr_info("error: only one of pre/post is defined\n"); 2152 return -EINVAL; 2153 } 2154 2155 for (i = 0 ; i < rw->len && ret == 0; i++) { 2156 ret = mmc_test_rw_multiple(test, rw, rw->bs[i], rw->size, 0); 2157 if (ret) 2158 break; 2159 } 2160 return ret; 2161 } 2162 2163 static int mmc_test_rw_multiple_sg_len(struct mmc_test_card *test, 2164 struct mmc_test_multiple_rw *rw) 2165 { 2166 int ret = 0; 2167 int i; 2168 2169 for (i = 0 ; i < rw->len && ret == 0; i++) { 2170 ret = mmc_test_rw_multiple(test, rw, 512 * 1024, rw->size, 2171 rw->sg_len[i]); 2172 if (ret) 2173 break; 2174 } 2175 return ret; 2176 } 2177 2178 /* 2179 * Multiple blocking write 4k to 4 MB chunks 2180 */ 2181 static int mmc_test_profile_mult_write_blocking_perf(struct mmc_test_card *test) 2182 { 2183 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, 2184 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22}; 2185 struct mmc_test_multiple_rw test_data = { 2186 .bs = bs, 2187 .size = TEST_AREA_MAX_SIZE, 2188 .len = ARRAY_SIZE(bs), 2189 .do_write = true, 2190 .do_nonblock_req = false, 2191 .prepare = MMC_TEST_PREP_ERASE, 2192 }; 2193 2194 return mmc_test_rw_multiple_size(test, &test_data); 2195 }; 2196 2197 /* 2198 * Multiple non-blocking write 4k to 4 MB chunks 2199 */ 2200 static int mmc_test_profile_mult_write_nonblock_perf(struct mmc_test_card *test) 2201 { 2202 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, 2203 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22}; 2204 struct mmc_test_multiple_rw test_data = { 2205 .bs = bs, 2206 .size = TEST_AREA_MAX_SIZE, 2207 .len = ARRAY_SIZE(bs), 2208 .do_write = true, 2209 .do_nonblock_req = true, 2210 .prepare = MMC_TEST_PREP_ERASE, 2211 }; 2212 2213 return mmc_test_rw_multiple_size(test, &test_data); 2214 } 2215 2216 /* 2217 * Multiple blocking read 4k to 4 MB chunks 2218 */ 2219 static int mmc_test_profile_mult_read_blocking_perf(struct mmc_test_card *test) 2220 { 2221 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, 2222 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22}; 2223 struct mmc_test_multiple_rw test_data = { 2224 .bs = bs, 2225 .size = TEST_AREA_MAX_SIZE, 2226 .len = ARRAY_SIZE(bs), 2227 .do_write = false, 2228 .do_nonblock_req = false, 2229 .prepare = MMC_TEST_PREP_NONE, 2230 }; 2231 2232 return mmc_test_rw_multiple_size(test, &test_data); 2233 } 2234 2235 /* 2236 * Multiple non-blocking read 4k to 4 MB chunks 2237 */ 2238 static int mmc_test_profile_mult_read_nonblock_perf(struct mmc_test_card *test) 2239 { 2240 unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16, 2241 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22}; 2242 struct mmc_test_multiple_rw test_data = { 2243 .bs = bs, 2244 .size = TEST_AREA_MAX_SIZE, 2245 .len = ARRAY_SIZE(bs), 2246 .do_write = false, 2247 .do_nonblock_req = true, 2248 .prepare = MMC_TEST_PREP_NONE, 2249 }; 2250 2251 return mmc_test_rw_multiple_size(test, &test_data); 2252 } 2253 2254 /* 2255 * Multiple blocking write 1 to 512 sg elements 2256 */ 2257 static int mmc_test_profile_sglen_wr_blocking_perf(struct mmc_test_card *test) 2258 { 2259 unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 2260 1 << 7, 1 << 8, 1 << 9}; 2261 struct mmc_test_multiple_rw test_data = { 2262 .sg_len = sg_len, 2263 .size = TEST_AREA_MAX_SIZE, 2264 .len = ARRAY_SIZE(sg_len), 2265 .do_write = true, 2266 .do_nonblock_req = false, 2267 .prepare = MMC_TEST_PREP_ERASE, 2268 }; 2269 2270 return mmc_test_rw_multiple_sg_len(test, &test_data); 2271 }; 2272 2273 /* 2274 * Multiple non-blocking write 1 to 512 sg elements 2275 */ 2276 static int mmc_test_profile_sglen_wr_nonblock_perf(struct mmc_test_card *test) 2277 { 2278 unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 2279 1 << 7, 1 << 8, 1 << 9}; 2280 struct mmc_test_multiple_rw test_data = { 2281 .sg_len = sg_len, 2282 .size = TEST_AREA_MAX_SIZE, 2283 .len = ARRAY_SIZE(sg_len), 2284 .do_write = true, 2285 .do_nonblock_req = true, 2286 .prepare = MMC_TEST_PREP_ERASE, 2287 }; 2288 2289 return mmc_test_rw_multiple_sg_len(test, &test_data); 2290 } 2291 2292 /* 2293 * Multiple blocking read 1 to 512 sg elements 2294 */ 2295 static int mmc_test_profile_sglen_r_blocking_perf(struct mmc_test_card *test) 2296 { 2297 unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 2298 1 << 7, 1 << 8, 1 << 9}; 2299 struct mmc_test_multiple_rw test_data = { 2300 .sg_len = sg_len, 2301 .size = TEST_AREA_MAX_SIZE, 2302 .len = ARRAY_SIZE(sg_len), 2303 .do_write = false, 2304 .do_nonblock_req = false, 2305 .prepare = MMC_TEST_PREP_NONE, 2306 }; 2307 2308 return mmc_test_rw_multiple_sg_len(test, &test_data); 2309 } 2310 2311 /* 2312 * Multiple non-blocking read 1 to 512 sg elements 2313 */ 2314 static int mmc_test_profile_sglen_r_nonblock_perf(struct mmc_test_card *test) 2315 { 2316 unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 2317 1 << 7, 1 << 8, 1 << 9}; 2318 struct mmc_test_multiple_rw test_data = { 2319 .sg_len = sg_len, 2320 .size = TEST_AREA_MAX_SIZE, 2321 .len = ARRAY_SIZE(sg_len), 2322 .do_write = false, 2323 .do_nonblock_req = true, 2324 .prepare = MMC_TEST_PREP_NONE, 2325 }; 2326 2327 return mmc_test_rw_multiple_sg_len(test, &test_data); 2328 } 2329 2330 /* 2331 * eMMC hardware reset. 2332 */ 2333 static int mmc_test_reset(struct mmc_test_card *test) 2334 { 2335 struct mmc_card *card = test->card; 2336 int err; 2337 2338 err = mmc_hw_reset(card); 2339 if (!err) { 2340 /* 2341 * Reset will re-enable the card's command queue, but tests 2342 * expect it to be disabled. 2343 */ 2344 if (card->ext_csd.cmdq_en) 2345 mmc_cmdq_disable(card); 2346 return RESULT_OK; 2347 } else if (err == -EOPNOTSUPP) { 2348 return RESULT_UNSUP_HOST; 2349 } 2350 2351 return RESULT_FAIL; 2352 } 2353 2354 static int mmc_test_send_status(struct mmc_test_card *test, 2355 struct mmc_command *cmd) 2356 { 2357 memset(cmd, 0, sizeof(*cmd)); 2358 2359 cmd->opcode = MMC_SEND_STATUS; 2360 if (!mmc_host_is_spi(test->card->host)) 2361 cmd->arg = test->card->rca << 16; 2362 cmd->flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; 2363 2364 return mmc_wait_for_cmd(test->card->host, cmd, 0); 2365 } 2366 2367 static int mmc_test_ongoing_transfer(struct mmc_test_card *test, 2368 unsigned int dev_addr, int use_sbc, 2369 int repeat_cmd, int write, int use_areq) 2370 { 2371 struct mmc_test_req *rq = mmc_test_req_alloc(); 2372 struct mmc_host *host = test->card->host; 2373 struct mmc_test_area *t = &test->area; 2374 struct mmc_request *mrq; 2375 unsigned long timeout; 2376 bool expired = false; 2377 int ret = 0, cmd_ret; 2378 u32 status = 0; 2379 int count = 0; 2380 2381 if (!rq) 2382 return -ENOMEM; 2383 2384 mrq = &rq->mrq; 2385 if (use_sbc) 2386 mrq->sbc = &rq->sbc; 2387 mrq->cap_cmd_during_tfr = true; 2388 2389 mmc_test_prepare_mrq(test, mrq, t->sg, t->sg_len, dev_addr, t->blocks, 2390 512, write); 2391 2392 if (use_sbc && t->blocks > 1 && !mrq->sbc) { 2393 ret = mmc_host_cmd23(host) ? 2394 RESULT_UNSUP_CARD : 2395 RESULT_UNSUP_HOST; 2396 goto out_free; 2397 } 2398 2399 /* Start ongoing data request */ 2400 if (use_areq) { 2401 ret = mmc_test_start_areq(test, mrq, NULL); 2402 if (ret) 2403 goto out_free; 2404 } else { 2405 mmc_wait_for_req(host, mrq); 2406 } 2407 2408 timeout = jiffies + msecs_to_jiffies(3000); 2409 do { 2410 count += 1; 2411 2412 /* Send status command while data transfer in progress */ 2413 cmd_ret = mmc_test_send_status(test, &rq->status); 2414 if (cmd_ret) 2415 break; 2416 2417 status = rq->status.resp[0]; 2418 if (status & R1_ERROR) { 2419 cmd_ret = -EIO; 2420 break; 2421 } 2422 2423 if (mmc_is_req_done(host, mrq)) 2424 break; 2425 2426 expired = time_after(jiffies, timeout); 2427 if (expired) { 2428 pr_info("%s: timeout waiting for Tran state status %#x\n", 2429 mmc_hostname(host), status); 2430 cmd_ret = -ETIMEDOUT; 2431 break; 2432 } 2433 } while (repeat_cmd && R1_CURRENT_STATE(status) != R1_STATE_TRAN); 2434 2435 /* Wait for data request to complete */ 2436 if (use_areq) { 2437 ret = mmc_test_start_areq(test, NULL, mrq); 2438 } else { 2439 mmc_wait_for_req_done(test->card->host, mrq); 2440 } 2441 2442 /* 2443 * For cap_cmd_during_tfr request, upper layer must send stop if 2444 * required. 2445 */ 2446 if (mrq->data->stop && (mrq->data->error || !mrq->sbc)) { 2447 if (ret) 2448 mmc_wait_for_cmd(host, mrq->data->stop, 0); 2449 else 2450 ret = mmc_wait_for_cmd(host, mrq->data->stop, 0); 2451 } 2452 2453 if (ret) 2454 goto out_free; 2455 2456 if (cmd_ret) { 2457 pr_info("%s: Send Status failed: status %#x, error %d\n", 2458 mmc_hostname(test->card->host), status, cmd_ret); 2459 } 2460 2461 ret = mmc_test_check_result(test, mrq); 2462 if (ret) 2463 goto out_free; 2464 2465 ret = mmc_test_wait_busy(test); 2466 if (ret) 2467 goto out_free; 2468 2469 if (repeat_cmd && (t->blocks + 1) << 9 > t->max_tfr) 2470 pr_info("%s: %d commands completed during transfer of %u blocks\n", 2471 mmc_hostname(test->card->host), count, t->blocks); 2472 2473 if (cmd_ret) 2474 ret = cmd_ret; 2475 out_free: 2476 kfree(rq); 2477 2478 return ret; 2479 } 2480 2481 static int __mmc_test_cmds_during_tfr(struct mmc_test_card *test, 2482 unsigned long sz, int use_sbc, int write, 2483 int use_areq) 2484 { 2485 struct mmc_test_area *t = &test->area; 2486 int ret; 2487 2488 if (!(test->card->host->caps & MMC_CAP_CMD_DURING_TFR)) 2489 return RESULT_UNSUP_HOST; 2490 2491 ret = mmc_test_area_map(test, sz, 0, 0, use_areq); 2492 if (ret) 2493 return ret; 2494 2495 ret = mmc_test_ongoing_transfer(test, t->dev_addr, use_sbc, 0, write, 2496 use_areq); 2497 if (ret) 2498 return ret; 2499 2500 return mmc_test_ongoing_transfer(test, t->dev_addr, use_sbc, 1, write, 2501 use_areq); 2502 } 2503 2504 static int mmc_test_cmds_during_tfr(struct mmc_test_card *test, int use_sbc, 2505 int write, int use_areq) 2506 { 2507 struct mmc_test_area *t = &test->area; 2508 unsigned long sz; 2509 int ret; 2510 2511 for (sz = 512; sz <= t->max_tfr; sz += 512) { 2512 ret = __mmc_test_cmds_during_tfr(test, sz, use_sbc, write, 2513 use_areq); 2514 if (ret) 2515 return ret; 2516 } 2517 return 0; 2518 } 2519 2520 /* 2521 * Commands during read - no Set Block Count (CMD23). 2522 */ 2523 static int mmc_test_cmds_during_read(struct mmc_test_card *test) 2524 { 2525 return mmc_test_cmds_during_tfr(test, 0, 0, 0); 2526 } 2527 2528 /* 2529 * Commands during write - no Set Block Count (CMD23). 2530 */ 2531 static int mmc_test_cmds_during_write(struct mmc_test_card *test) 2532 { 2533 return mmc_test_cmds_during_tfr(test, 0, 1, 0); 2534 } 2535 2536 /* 2537 * Commands during read - use Set Block Count (CMD23). 2538 */ 2539 static int mmc_test_cmds_during_read_cmd23(struct mmc_test_card *test) 2540 { 2541 return mmc_test_cmds_during_tfr(test, 1, 0, 0); 2542 } 2543 2544 /* 2545 * Commands during write - use Set Block Count (CMD23). 2546 */ 2547 static int mmc_test_cmds_during_write_cmd23(struct mmc_test_card *test) 2548 { 2549 return mmc_test_cmds_during_tfr(test, 1, 1, 0); 2550 } 2551 2552 /* 2553 * Commands during non-blocking read - use Set Block Count (CMD23). 2554 */ 2555 static int mmc_test_cmds_during_read_cmd23_nonblock(struct mmc_test_card *test) 2556 { 2557 return mmc_test_cmds_during_tfr(test, 1, 0, 1); 2558 } 2559 2560 /* 2561 * Commands during non-blocking write - use Set Block Count (CMD23). 2562 */ 2563 static int mmc_test_cmds_during_write_cmd23_nonblock(struct mmc_test_card *test) 2564 { 2565 return mmc_test_cmds_during_tfr(test, 1, 1, 1); 2566 } 2567 2568 static const struct mmc_test_case mmc_test_cases[] = { 2569 { 2570 .name = "Basic write (no data verification)", 2571 .run = mmc_test_basic_write, 2572 }, 2573 2574 { 2575 .name = "Basic read (no data verification)", 2576 .run = mmc_test_basic_read, 2577 }, 2578 2579 { 2580 .name = "Basic write (with data verification)", 2581 .prepare = mmc_test_prepare_write, 2582 .run = mmc_test_verify_write, 2583 .cleanup = mmc_test_cleanup, 2584 }, 2585 2586 { 2587 .name = "Basic read (with data verification)", 2588 .prepare = mmc_test_prepare_read, 2589 .run = mmc_test_verify_read, 2590 .cleanup = mmc_test_cleanup, 2591 }, 2592 2593 { 2594 .name = "Multi-block write", 2595 .prepare = mmc_test_prepare_write, 2596 .run = mmc_test_multi_write, 2597 .cleanup = mmc_test_cleanup, 2598 }, 2599 2600 { 2601 .name = "Multi-block read", 2602 .prepare = mmc_test_prepare_read, 2603 .run = mmc_test_multi_read, 2604 .cleanup = mmc_test_cleanup, 2605 }, 2606 2607 { 2608 .name = "Power of two block writes", 2609 .prepare = mmc_test_prepare_write, 2610 .run = mmc_test_pow2_write, 2611 .cleanup = mmc_test_cleanup, 2612 }, 2613 2614 { 2615 .name = "Power of two block reads", 2616 .prepare = mmc_test_prepare_read, 2617 .run = mmc_test_pow2_read, 2618 .cleanup = mmc_test_cleanup, 2619 }, 2620 2621 { 2622 .name = "Weird sized block writes", 2623 .prepare = mmc_test_prepare_write, 2624 .run = mmc_test_weird_write, 2625 .cleanup = mmc_test_cleanup, 2626 }, 2627 2628 { 2629 .name = "Weird sized block reads", 2630 .prepare = mmc_test_prepare_read, 2631 .run = mmc_test_weird_read, 2632 .cleanup = mmc_test_cleanup, 2633 }, 2634 2635 { 2636 .name = "Badly aligned write", 2637 .prepare = mmc_test_prepare_write, 2638 .run = mmc_test_align_write, 2639 .cleanup = mmc_test_cleanup, 2640 }, 2641 2642 { 2643 .name = "Badly aligned read", 2644 .prepare = mmc_test_prepare_read, 2645 .run = mmc_test_align_read, 2646 .cleanup = mmc_test_cleanup, 2647 }, 2648 2649 { 2650 .name = "Badly aligned multi-block write", 2651 .prepare = mmc_test_prepare_write, 2652 .run = mmc_test_align_multi_write, 2653 .cleanup = mmc_test_cleanup, 2654 }, 2655 2656 { 2657 .name = "Badly aligned multi-block read", 2658 .prepare = mmc_test_prepare_read, 2659 .run = mmc_test_align_multi_read, 2660 .cleanup = mmc_test_cleanup, 2661 }, 2662 2663 { 2664 .name = "Proper xfer_size at write (start failure)", 2665 .run = mmc_test_xfersize_write, 2666 }, 2667 2668 { 2669 .name = "Proper xfer_size at read (start failure)", 2670 .run = mmc_test_xfersize_read, 2671 }, 2672 2673 { 2674 .name = "Proper xfer_size at write (midway failure)", 2675 .run = mmc_test_multi_xfersize_write, 2676 }, 2677 2678 { 2679 .name = "Proper xfer_size at read (midway failure)", 2680 .run = mmc_test_multi_xfersize_read, 2681 }, 2682 2683 #ifdef CONFIG_HIGHMEM 2684 2685 { 2686 .name = "Highmem write", 2687 .prepare = mmc_test_prepare_write, 2688 .run = mmc_test_write_high, 2689 .cleanup = mmc_test_cleanup, 2690 }, 2691 2692 { 2693 .name = "Highmem read", 2694 .prepare = mmc_test_prepare_read, 2695 .run = mmc_test_read_high, 2696 .cleanup = mmc_test_cleanup, 2697 }, 2698 2699 { 2700 .name = "Multi-block highmem write", 2701 .prepare = mmc_test_prepare_write, 2702 .run = mmc_test_multi_write_high, 2703 .cleanup = mmc_test_cleanup, 2704 }, 2705 2706 { 2707 .name = "Multi-block highmem read", 2708 .prepare = mmc_test_prepare_read, 2709 .run = mmc_test_multi_read_high, 2710 .cleanup = mmc_test_cleanup, 2711 }, 2712 2713 #else 2714 2715 { 2716 .name = "Highmem write", 2717 .run = mmc_test_no_highmem, 2718 }, 2719 2720 { 2721 .name = "Highmem read", 2722 .run = mmc_test_no_highmem, 2723 }, 2724 2725 { 2726 .name = "Multi-block highmem write", 2727 .run = mmc_test_no_highmem, 2728 }, 2729 2730 { 2731 .name = "Multi-block highmem read", 2732 .run = mmc_test_no_highmem, 2733 }, 2734 2735 #endif /* CONFIG_HIGHMEM */ 2736 2737 { 2738 .name = "Best-case read performance", 2739 .prepare = mmc_test_area_prepare_fill, 2740 .run = mmc_test_best_read_performance, 2741 .cleanup = mmc_test_area_cleanup, 2742 }, 2743 2744 { 2745 .name = "Best-case write performance", 2746 .prepare = mmc_test_area_prepare_erase, 2747 .run = mmc_test_best_write_performance, 2748 .cleanup = mmc_test_area_cleanup, 2749 }, 2750 2751 { 2752 .name = "Best-case read performance into scattered pages", 2753 .prepare = mmc_test_area_prepare_fill, 2754 .run = mmc_test_best_read_perf_max_scatter, 2755 .cleanup = mmc_test_area_cleanup, 2756 }, 2757 2758 { 2759 .name = "Best-case write performance from scattered pages", 2760 .prepare = mmc_test_area_prepare_erase, 2761 .run = mmc_test_best_write_perf_max_scatter, 2762 .cleanup = mmc_test_area_cleanup, 2763 }, 2764 2765 { 2766 .name = "Single read performance by transfer size", 2767 .prepare = mmc_test_area_prepare_fill, 2768 .run = mmc_test_profile_read_perf, 2769 .cleanup = mmc_test_area_cleanup, 2770 }, 2771 2772 { 2773 .name = "Single write performance by transfer size", 2774 .prepare = mmc_test_area_prepare, 2775 .run = mmc_test_profile_write_perf, 2776 .cleanup = mmc_test_area_cleanup, 2777 }, 2778 2779 { 2780 .name = "Single trim performance by transfer size", 2781 .prepare = mmc_test_area_prepare_fill, 2782 .run = mmc_test_profile_trim_perf, 2783 .cleanup = mmc_test_area_cleanup, 2784 }, 2785 2786 { 2787 .name = "Consecutive read performance by transfer size", 2788 .prepare = mmc_test_area_prepare_fill, 2789 .run = mmc_test_profile_seq_read_perf, 2790 .cleanup = mmc_test_area_cleanup, 2791 }, 2792 2793 { 2794 .name = "Consecutive write performance by transfer size", 2795 .prepare = mmc_test_area_prepare, 2796 .run = mmc_test_profile_seq_write_perf, 2797 .cleanup = mmc_test_area_cleanup, 2798 }, 2799 2800 { 2801 .name = "Consecutive trim performance by transfer size", 2802 .prepare = mmc_test_area_prepare, 2803 .run = mmc_test_profile_seq_trim_perf, 2804 .cleanup = mmc_test_area_cleanup, 2805 }, 2806 2807 { 2808 .name = "Random read performance by transfer size", 2809 .prepare = mmc_test_area_prepare, 2810 .run = mmc_test_random_read_perf, 2811 .cleanup = mmc_test_area_cleanup, 2812 }, 2813 2814 { 2815 .name = "Random write performance by transfer size", 2816 .prepare = mmc_test_area_prepare, 2817 .run = mmc_test_random_write_perf, 2818 .cleanup = mmc_test_area_cleanup, 2819 }, 2820 2821 { 2822 .name = "Large sequential read into scattered pages", 2823 .prepare = mmc_test_area_prepare, 2824 .run = mmc_test_large_seq_read_perf, 2825 .cleanup = mmc_test_area_cleanup, 2826 }, 2827 2828 { 2829 .name = "Large sequential write from scattered pages", 2830 .prepare = mmc_test_area_prepare, 2831 .run = mmc_test_large_seq_write_perf, 2832 .cleanup = mmc_test_area_cleanup, 2833 }, 2834 2835 { 2836 .name = "Write performance with blocking req 4k to 4MB", 2837 .prepare = mmc_test_area_prepare, 2838 .run = mmc_test_profile_mult_write_blocking_perf, 2839 .cleanup = mmc_test_area_cleanup, 2840 }, 2841 2842 { 2843 .name = "Write performance with non-blocking req 4k to 4MB", 2844 .prepare = mmc_test_area_prepare, 2845 .run = mmc_test_profile_mult_write_nonblock_perf, 2846 .cleanup = mmc_test_area_cleanup, 2847 }, 2848 2849 { 2850 .name = "Read performance with blocking req 4k to 4MB", 2851 .prepare = mmc_test_area_prepare, 2852 .run = mmc_test_profile_mult_read_blocking_perf, 2853 .cleanup = mmc_test_area_cleanup, 2854 }, 2855 2856 { 2857 .name = "Read performance with non-blocking req 4k to 4MB", 2858 .prepare = mmc_test_area_prepare, 2859 .run = mmc_test_profile_mult_read_nonblock_perf, 2860 .cleanup = mmc_test_area_cleanup, 2861 }, 2862 2863 { 2864 .name = "Write performance blocking req 1 to 512 sg elems", 2865 .prepare = mmc_test_area_prepare, 2866 .run = mmc_test_profile_sglen_wr_blocking_perf, 2867 .cleanup = mmc_test_area_cleanup, 2868 }, 2869 2870 { 2871 .name = "Write performance non-blocking req 1 to 512 sg elems", 2872 .prepare = mmc_test_area_prepare, 2873 .run = mmc_test_profile_sglen_wr_nonblock_perf, 2874 .cleanup = mmc_test_area_cleanup, 2875 }, 2876 2877 { 2878 .name = "Read performance blocking req 1 to 512 sg elems", 2879 .prepare = mmc_test_area_prepare, 2880 .run = mmc_test_profile_sglen_r_blocking_perf, 2881 .cleanup = mmc_test_area_cleanup, 2882 }, 2883 2884 { 2885 .name = "Read performance non-blocking req 1 to 512 sg elems", 2886 .prepare = mmc_test_area_prepare, 2887 .run = mmc_test_profile_sglen_r_nonblock_perf, 2888 .cleanup = mmc_test_area_cleanup, 2889 }, 2890 2891 { 2892 .name = "Reset test", 2893 .run = mmc_test_reset, 2894 }, 2895 2896 { 2897 .name = "Commands during read - no Set Block Count (CMD23)", 2898 .prepare = mmc_test_area_prepare, 2899 .run = mmc_test_cmds_during_read, 2900 .cleanup = mmc_test_area_cleanup, 2901 }, 2902 2903 { 2904 .name = "Commands during write - no Set Block Count (CMD23)", 2905 .prepare = mmc_test_area_prepare, 2906 .run = mmc_test_cmds_during_write, 2907 .cleanup = mmc_test_area_cleanup, 2908 }, 2909 2910 { 2911 .name = "Commands during read - use Set Block Count (CMD23)", 2912 .prepare = mmc_test_area_prepare, 2913 .run = mmc_test_cmds_during_read_cmd23, 2914 .cleanup = mmc_test_area_cleanup, 2915 }, 2916 2917 { 2918 .name = "Commands during write - use Set Block Count (CMD23)", 2919 .prepare = mmc_test_area_prepare, 2920 .run = mmc_test_cmds_during_write_cmd23, 2921 .cleanup = mmc_test_area_cleanup, 2922 }, 2923 2924 { 2925 .name = "Commands during non-blocking read - use Set Block Count (CMD23)", 2926 .prepare = mmc_test_area_prepare, 2927 .run = mmc_test_cmds_during_read_cmd23_nonblock, 2928 .cleanup = mmc_test_area_cleanup, 2929 }, 2930 2931 { 2932 .name = "Commands during non-blocking write - use Set Block Count (CMD23)", 2933 .prepare = mmc_test_area_prepare, 2934 .run = mmc_test_cmds_during_write_cmd23_nonblock, 2935 .cleanup = mmc_test_area_cleanup, 2936 }, 2937 2938 { 2939 .name = "Re-tuning reliability", 2940 .prepare = mmc_test_area_prepare, 2941 .run = mmc_test_retuning, 2942 .cleanup = mmc_test_area_cleanup, 2943 }, 2944 2945 }; 2946 2947 static DEFINE_MUTEX(mmc_test_lock); 2948 2949 static LIST_HEAD(mmc_test_result); 2950 2951 static void mmc_test_run(struct mmc_test_card *test, int testcase) 2952 { 2953 int i, ret; 2954 2955 pr_info("%s: Starting tests of card %s...\n", 2956 mmc_hostname(test->card->host), mmc_card_id(test->card)); 2957 2958 mmc_claim_host(test->card->host); 2959 2960 for (i = 0; i < ARRAY_SIZE(mmc_test_cases); i++) { 2961 struct mmc_test_general_result *gr; 2962 2963 if (testcase && ((i + 1) != testcase)) 2964 continue; 2965 2966 pr_info("%s: Test case %d. %s...\n", 2967 mmc_hostname(test->card->host), i + 1, 2968 mmc_test_cases[i].name); 2969 2970 if (mmc_test_cases[i].prepare) { 2971 ret = mmc_test_cases[i].prepare(test); 2972 if (ret) { 2973 pr_info("%s: Result: Prepare stage failed! (%d)\n", 2974 mmc_hostname(test->card->host), 2975 ret); 2976 continue; 2977 } 2978 } 2979 2980 gr = kzalloc(sizeof(*gr), GFP_KERNEL); 2981 if (gr) { 2982 INIT_LIST_HEAD(&gr->tr_lst); 2983 2984 /* Assign data what we know already */ 2985 gr->card = test->card; 2986 gr->testcase = i; 2987 2988 /* Append container to global one */ 2989 list_add_tail(&gr->link, &mmc_test_result); 2990 2991 /* 2992 * Save the pointer to created container in our private 2993 * structure. 2994 */ 2995 test->gr = gr; 2996 } 2997 2998 ret = mmc_test_cases[i].run(test); 2999 switch (ret) { 3000 case RESULT_OK: 3001 pr_info("%s: Result: OK\n", 3002 mmc_hostname(test->card->host)); 3003 break; 3004 case RESULT_FAIL: 3005 pr_info("%s: Result: FAILED\n", 3006 mmc_hostname(test->card->host)); 3007 break; 3008 case RESULT_UNSUP_HOST: 3009 pr_info("%s: Result: UNSUPPORTED (by host)\n", 3010 mmc_hostname(test->card->host)); 3011 break; 3012 case RESULT_UNSUP_CARD: 3013 pr_info("%s: Result: UNSUPPORTED (by card)\n", 3014 mmc_hostname(test->card->host)); 3015 break; 3016 default: 3017 pr_info("%s: Result: ERROR (%d)\n", 3018 mmc_hostname(test->card->host), ret); 3019 } 3020 3021 /* Save the result */ 3022 if (gr) 3023 gr->result = ret; 3024 3025 if (mmc_test_cases[i].cleanup) { 3026 ret = mmc_test_cases[i].cleanup(test); 3027 if (ret) { 3028 pr_info("%s: Warning: Cleanup stage failed! (%d)\n", 3029 mmc_hostname(test->card->host), 3030 ret); 3031 } 3032 } 3033 } 3034 3035 mmc_release_host(test->card->host); 3036 3037 pr_info("%s: Tests completed.\n", 3038 mmc_hostname(test->card->host)); 3039 } 3040 3041 static void mmc_test_free_result(struct mmc_card *card) 3042 { 3043 struct mmc_test_general_result *gr, *grs; 3044 3045 mutex_lock(&mmc_test_lock); 3046 3047 list_for_each_entry_safe(gr, grs, &mmc_test_result, link) { 3048 struct mmc_test_transfer_result *tr, *trs; 3049 3050 if (card && gr->card != card) 3051 continue; 3052 3053 list_for_each_entry_safe(tr, trs, &gr->tr_lst, link) { 3054 list_del(&tr->link); 3055 kfree(tr); 3056 } 3057 3058 list_del(&gr->link); 3059 kfree(gr); 3060 } 3061 3062 mutex_unlock(&mmc_test_lock); 3063 } 3064 3065 static LIST_HEAD(mmc_test_file_test); 3066 3067 static int mtf_test_show(struct seq_file *sf, void *data) 3068 { 3069 struct mmc_card *card = sf->private; 3070 struct mmc_test_general_result *gr; 3071 3072 mutex_lock(&mmc_test_lock); 3073 3074 list_for_each_entry(gr, &mmc_test_result, link) { 3075 struct mmc_test_transfer_result *tr; 3076 3077 if (gr->card != card) 3078 continue; 3079 3080 seq_printf(sf, "Test %d: %d\n", gr->testcase + 1, gr->result); 3081 3082 list_for_each_entry(tr, &gr->tr_lst, link) { 3083 seq_printf(sf, "%u %d %llu.%09u %u %u.%02u\n", 3084 tr->count, tr->sectors, 3085 (u64)tr->ts.tv_sec, (u32)tr->ts.tv_nsec, 3086 tr->rate, tr->iops / 100, tr->iops % 100); 3087 } 3088 } 3089 3090 mutex_unlock(&mmc_test_lock); 3091 3092 return 0; 3093 } 3094 3095 static int mtf_test_open(struct inode *inode, struct file *file) 3096 { 3097 return single_open(file, mtf_test_show, inode->i_private); 3098 } 3099 3100 static ssize_t mtf_test_write(struct file *file, const char __user *buf, 3101 size_t count, loff_t *pos) 3102 { 3103 struct seq_file *sf = file->private_data; 3104 struct mmc_card *card = sf->private; 3105 struct mmc_test_card *test; 3106 long testcase; 3107 int ret; 3108 3109 ret = kstrtol_from_user(buf, count, 10, &testcase); 3110 if (ret) 3111 return ret; 3112 3113 test = kzalloc(sizeof(*test), GFP_KERNEL); 3114 if (!test) 3115 return -ENOMEM; 3116 3117 /* 3118 * Remove all test cases associated with given card. Thus we have only 3119 * actual data of the last run. 3120 */ 3121 mmc_test_free_result(card); 3122 3123 test->card = card; 3124 3125 test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL); 3126 #ifdef CONFIG_HIGHMEM 3127 test->highmem = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM, BUFFER_ORDER); 3128 #endif 3129 3130 #ifdef CONFIG_HIGHMEM 3131 if (test->buffer && test->highmem) { 3132 #else 3133 if (test->buffer) { 3134 #endif 3135 mutex_lock(&mmc_test_lock); 3136 mmc_test_run(test, testcase); 3137 mutex_unlock(&mmc_test_lock); 3138 } 3139 3140 #ifdef CONFIG_HIGHMEM 3141 __free_pages(test->highmem, BUFFER_ORDER); 3142 #endif 3143 kfree(test->buffer); 3144 kfree(test); 3145 3146 return count; 3147 } 3148 3149 static const struct file_operations mmc_test_fops_test = { 3150 .open = mtf_test_open, 3151 .read = seq_read, 3152 .write = mtf_test_write, 3153 .llseek = seq_lseek, 3154 .release = single_release, 3155 }; 3156 3157 static int mtf_testlist_show(struct seq_file *sf, void *data) 3158 { 3159 int i; 3160 3161 mutex_lock(&mmc_test_lock); 3162 3163 seq_puts(sf, "0:\tRun all tests\n"); 3164 for (i = 0; i < ARRAY_SIZE(mmc_test_cases); i++) 3165 seq_printf(sf, "%d:\t%s\n", i + 1, mmc_test_cases[i].name); 3166 3167 mutex_unlock(&mmc_test_lock); 3168 3169 return 0; 3170 } 3171 3172 DEFINE_SHOW_ATTRIBUTE(mtf_testlist); 3173 3174 static void mmc_test_free_dbgfs_file(struct mmc_card *card) 3175 { 3176 struct mmc_test_dbgfs_file *df, *dfs; 3177 3178 mutex_lock(&mmc_test_lock); 3179 3180 list_for_each_entry_safe(df, dfs, &mmc_test_file_test, link) { 3181 if (card && df->card != card) 3182 continue; 3183 debugfs_remove(df->file); 3184 list_del(&df->link); 3185 kfree(df); 3186 } 3187 3188 mutex_unlock(&mmc_test_lock); 3189 } 3190 3191 static int __mmc_test_register_dbgfs_file(struct mmc_card *card, 3192 const char *name, umode_t mode, const struct file_operations *fops) 3193 { 3194 struct dentry *file = NULL; 3195 struct mmc_test_dbgfs_file *df; 3196 3197 if (card->debugfs_root) 3198 file = debugfs_create_file(name, mode, card->debugfs_root, 3199 card, fops); 3200 3201 df = kmalloc(sizeof(*df), GFP_KERNEL); 3202 if (!df) { 3203 debugfs_remove(file); 3204 return -ENOMEM; 3205 } 3206 3207 df->card = card; 3208 df->file = file; 3209 3210 list_add(&df->link, &mmc_test_file_test); 3211 return 0; 3212 } 3213 3214 static int mmc_test_register_dbgfs_file(struct mmc_card *card) 3215 { 3216 int ret; 3217 3218 mutex_lock(&mmc_test_lock); 3219 3220 ret = __mmc_test_register_dbgfs_file(card, "test", S_IWUSR | S_IRUGO, 3221 &mmc_test_fops_test); 3222 if (ret) 3223 goto err; 3224 3225 ret = __mmc_test_register_dbgfs_file(card, "testlist", S_IRUGO, 3226 &mtf_testlist_fops); 3227 if (ret) 3228 goto err; 3229 3230 err: 3231 mutex_unlock(&mmc_test_lock); 3232 3233 return ret; 3234 } 3235 3236 static int mmc_test_probe(struct mmc_card *card) 3237 { 3238 int ret; 3239 3240 if (!mmc_card_mmc(card) && !mmc_card_sd(card)) 3241 return -ENODEV; 3242 3243 ret = mmc_test_register_dbgfs_file(card); 3244 if (ret) 3245 return ret; 3246 3247 if (card->ext_csd.cmdq_en) { 3248 mmc_claim_host(card->host); 3249 ret = mmc_cmdq_disable(card); 3250 mmc_release_host(card->host); 3251 if (ret) 3252 return ret; 3253 } 3254 3255 dev_info(&card->dev, "Card claimed for testing.\n"); 3256 3257 return 0; 3258 } 3259 3260 static void mmc_test_remove(struct mmc_card *card) 3261 { 3262 if (card->reenable_cmdq) { 3263 mmc_claim_host(card->host); 3264 mmc_cmdq_enable(card); 3265 mmc_release_host(card->host); 3266 } 3267 mmc_test_free_result(card); 3268 mmc_test_free_dbgfs_file(card); 3269 } 3270 3271 static struct mmc_driver mmc_driver = { 3272 .drv = { 3273 .name = "mmc_test", 3274 }, 3275 .probe = mmc_test_probe, 3276 .remove = mmc_test_remove, 3277 }; 3278 3279 static int __init mmc_test_init(void) 3280 { 3281 return mmc_register_driver(&mmc_driver); 3282 } 3283 3284 static void __exit mmc_test_exit(void) 3285 { 3286 /* Clear stalled data if card is still plugged */ 3287 mmc_test_free_result(NULL); 3288 mmc_test_free_dbgfs_file(NULL); 3289 3290 mmc_unregister_driver(&mmc_driver); 3291 } 3292 3293 module_init(mmc_test_init); 3294 module_exit(mmc_test_exit); 3295 3296 MODULE_LICENSE("GPL"); 3297 MODULE_DESCRIPTION("Multimedia Card (MMC) host test driver"); 3298 MODULE_AUTHOR("Pierre Ossman"); 3299