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