drivers/mmc/card/mmc_test.c

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