Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 671 insertions, 140 deletions

diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 5dd8576b5c18..233cdfae92f4 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -17,6 +17,11 @@
 
 #include <linux/scatterlist.h>
 #include <linux/swap.h>         /* For nr_free_buffer_pages() */
+#include <linux/list.h>
+
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/seq_file.h>
 
 #define RESULT_OK               0
 #define RESULT_FAIL             1
@@ -56,7 +61,9 @@ struct mmc_test_mem {
  * struct mmc_test_area - information for performance tests.
  * @max_sz: test area size (in bytes)
  * @dev_addr: address on card at which to do performance tests
- * @max_segs: maximum segments in scatterlist @sg
+ * @max_tfr: maximum transfer size allowed by driver (in bytes)
+ * @max_segs: maximum segments allowed by driver in scatterlist @sg
+ * @max_seg_sz: maximum segment size allowed by driver
  * @blocks: number of (512 byte) blocks currently mapped by @sg
  * @sg_len: length of currently mapped scatterlist @sg
  * @mem: allocated memory
@@ -65,7 +72,9 @@ struct mmc_test_mem {
 struct mmc_test_area {
         unsigned long max_sz;
         unsigned int dev_addr;
+        unsigned int max_tfr;
         unsigned int max_segs;
+        unsigned int max_seg_sz;
         unsigned int blocks;
         unsigned int sg_len;
         struct mmc_test_mem *mem;
@@ -73,12 +82,59 @@ struct mmc_test_area {
 };
 
 /**
+ * struct mmc_test_transfer_result - transfer results for performance tests.
+ * @link: double-linked list
+ * @count: amount of group of sectors to check
+ * @sectors: amount of sectors to check in one group
+ * @ts: time values of transfer
+ * @rate: calculated transfer rate
+ * @iops: I/O operations per second (times 100)
+ */
+struct mmc_test_transfer_result {
+        struct list_head link;
+        unsigned int count;
+        unsigned int sectors;
+        struct timespec ts;
+        unsigned int rate;
+        unsigned int iops;
+};
+
+/**
+ * struct mmc_test_general_result - results for tests.
+ * @link: double-linked list
+ * @card: card under test
+ * @testcase: number of test case
+ * @result: result of test run
+ * @tr_lst: transfer measurements if any as mmc_test_transfer_result
+ */
+struct mmc_test_general_result {
+        struct list_head link;
+        struct mmc_card *card;
+        int testcase;
+        int result;
+        struct list_head tr_lst;
+};
+
+/**
+ * struct mmc_test_dbgfs_file - debugfs related file.
+ * @link: double-linked list
+ * @card: card under test
+ * @file: file created under debugfs
+ */
+struct mmc_test_dbgfs_file {
+        struct list_head link;
+        struct mmc_card *card;
+        struct dentry *file;
+};
+
+/**
  * struct mmc_test_card - test information.
  * @card: card under test
  * @scratch: transfer buffer
  * @buffer: transfer buffer
  * @highmem: buffer for highmem tests
  * @area: information for performance tests
+ * @gr: pointer to results of current testcase
  */
 struct mmc_test_card {
         struct mmc_card *card;
@@ -88,7 +144,8 @@ struct mmc_test_card {
 #ifdef CONFIG_HIGHMEM
         struct page     *highmem;
 #endif
-        struct mmc_test_area area;
+        struct mmc_test_area            area;
+        struct mmc_test_general_result  *gr;
 };
 
 /*******************************************************************/
@@ -100,17 +157,7 @@ struct mmc_test_card {
  */
 static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)
 {
-        struct mmc_command cmd;
-        int ret;
-
-        cmd.opcode = MMC_SET_BLOCKLEN;
-        cmd.arg = size;
-        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
-        ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
-        if (ret)
-                return ret;
-
-        return 0;
+        return mmc_set_blocklen(test->card, size);
 }
 
 /*
@@ -165,7 +212,7 @@ static int mmc_test_busy(struct mmc_command *cmd)
 static int mmc_test_wait_busy(struct mmc_test_card *test)
 {
         int ret, busy;
-        struct mmc_command cmd;
+        struct mmc_command cmd = {0};
 
         busy = 0;
         do {
@@ -181,9 +228,10 @@ static int mmc_test_wait_busy(struct mmc_test_card *test)
 
                 if (!busy && mmc_test_busy(&cmd)) {
                         busy = 1;
-                        printk(KERN_INFO "%s: Warning: Host did not "
-                                "wait for busy state to end.\n",
-                                mmc_hostname(test->card->host));
+                        if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
+                                printk(KERN_INFO "%s: Warning: Host did not "
+                                        "wait for busy state to end.\n",
+                                        mmc_hostname(test->card->host));
                 }
         } while (mmc_test_busy(&cmd));
 
@@ -198,18 +246,13 @@ static int mmc_test_buffer_transfer(struct mmc_test_card *test,
 {
         int ret;
 
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_command stop;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_command stop = {0};
+        struct mmc_data data = {0};
 
         struct scatterlist sg;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-        memset(&stop, 0, sizeof(struct mmc_command));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
         mrq.stop = &stop;
@@ -244,28 +287,39 @@ static void mmc_test_free_mem(struct mmc_test_mem *mem)
 }
 
 /*
- * Allocate a lot of memory, preferrably max_sz but at least min_sz.  In case
- * there isn't much memory do not exceed 1/16th total lowmem pages.
+ * Allocate a lot of memory, preferably max_sz but at least min_sz.  In case
+ * there isn't much memory do not exceed 1/16th total lowmem pages.  Also do
+ * not exceed a maximum number of segments and try not to make segments much
+ * bigger than maximum segment size.
  */
 static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
-                                               unsigned long max_sz)
+                                               unsigned long max_sz,
+                                               unsigned int max_segs,
+                                               unsigned int max_seg_sz)
 {
         unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE);
         unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE);
+        unsigned long max_seg_page_cnt = DIV_ROUND_UP(max_seg_sz, PAGE_SIZE);
         unsigned long page_cnt = 0;
         unsigned long limit = nr_free_buffer_pages() >> 4;
         struct mmc_test_mem *mem;
 
         if (max_page_cnt > limit)
                 max_page_cnt = limit;
-        if (max_page_cnt < min_page_cnt)
-                max_page_cnt = min_page_cnt;
+        if (min_page_cnt > max_page_cnt)
+                min_page_cnt = max_page_cnt;
+
+        if (max_seg_page_cnt > max_page_cnt)
+                max_seg_page_cnt = max_page_cnt;
+
+        if (max_segs > max_page_cnt)
+                max_segs = max_page_cnt;
 
         mem = kzalloc(sizeof(struct mmc_test_mem), GFP_KERNEL);
         if (!mem)
                 return NULL;
 
-        mem->arr = kzalloc(sizeof(struct mmc_test_pages) * max_page_cnt,
+        mem->arr = kzalloc(sizeof(struct mmc_test_pages) * max_segs,
                            GFP_KERNEL);
         if (!mem->arr)
                 goto out_free;
@@ -276,7 +330,7 @@ static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
                 gfp_t flags = GFP_KERNEL | GFP_DMA | __GFP_NOWARN |
                                 __GFP_NORETRY;
 
-                order = get_order(max_page_cnt << PAGE_SHIFT);
+                order = get_order(max_seg_page_cnt << PAGE_SHIFT);
                 while (1) {
                         page = alloc_pages(flags, order);
                         if (page || !order)
@@ -295,6 +349,11 @@ static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
                         break;
                 max_page_cnt -= 1UL << order;
                 page_cnt += 1UL << order;
+                if (mem->cnt >= max_segs) {
+                        if (page_cnt < min_page_cnt)
+                                goto out_free;
+                        break;
+                }
         }
 
         return mem;
@@ -310,7 +369,8 @@ out_free:
  */
 static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long sz,
                            struct scatterlist *sglist, int repeat,
-                           unsigned int max_segs, unsigned int *sg_len)
+                           unsigned int max_segs, unsigned int max_seg_sz,
+                           unsigned int *sg_len)
 {
         struct scatterlist *sg = NULL;
         unsigned int i;
@@ -322,8 +382,10 @@ static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long sz,
                 for (i = 0; i < mem->cnt; i++) {
                         unsigned long len = PAGE_SIZE << mem->arr[i].order;
 
-                        if (sz < len)
+                        if (len > sz)
                                 len = sz;
+                        if (len > max_seg_sz)
+                                len = max_seg_sz;
                         if (sg)
                                 sg = sg_next(sg);
                         else
@@ -355,6 +417,7 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
                                        unsigned long sz,
                                        struct scatterlist *sglist,
                                        unsigned int max_segs,
+                                       unsigned int max_seg_sz,
                                        unsigned int *sg_len)
 {
         struct scatterlist *sg = NULL;
@@ -365,7 +428,7 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
         sg_init_table(sglist, max_segs);
 
         *sg_len = 0;
-        while (sz && i) {
+        while (sz) {
                 base = page_address(mem->arr[--i].page);
                 cnt = 1 << mem->arr[i].order;
                 while (sz && cnt) {
@@ -374,7 +437,9 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
                                 continue;
                         last_addr = addr;
                         len = PAGE_SIZE;
-                        if (sz < len)
+                        if (len > max_seg_sz)
+                                len = max_seg_sz;
+                        if (len > sz)
                                 len = sz;
                         if (sg)
                                 sg = sg_next(sg);
@@ -386,6 +451,8 @@ static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
                         sz -= len;
                         *sg_len += 1;
                 }
+                if (i == 0)
+                        i = mem->cnt;
         }
 
         if (sg)
@@ -421,23 +488,52 @@ static unsigned int mmc_test_rate(uint64_t bytes, struct timespec *ts)
 }
 
 /*
+ * Save transfer results for future usage
+ */
+static void mmc_test_save_transfer_result(struct mmc_test_card *test,
+        unsigned int count, unsigned int sectors, struct timespec ts,
+        unsigned int rate, unsigned int iops)
+{
+        struct mmc_test_transfer_result *tr;
+
+        if (!test->gr)
+                return;
+
+        tr = kmalloc(sizeof(struct mmc_test_transfer_result), GFP_KERNEL);
+        if (!tr)
+                return;
+
+        tr->count = count;
+        tr->sectors = sectors;
+        tr->ts = ts;
+        tr->rate = rate;
+        tr->iops = iops;
+
+        list_add_tail(&tr->link, &test->gr->tr_lst);
+}
+
+/*
  * Print the transfer rate.
  */
 static void mmc_test_print_rate(struct mmc_test_card *test, uint64_t bytes,
                                 struct timespec *ts1, struct timespec *ts2)
 {
-        unsigned int rate, sectors = bytes >> 9;
+        unsigned int rate, iops, sectors = bytes >> 9;
         struct timespec ts;
 
         ts = timespec_sub(*ts2, *ts1);
 
         rate = mmc_test_rate(bytes, &ts);
+        iops = mmc_test_rate(100, &ts); /* I/O ops per sec x 100 */
 
         printk(KERN_INFO "%s: Transfer of %u sectors (%u%s KiB) took %lu.%09lu "
-                         "seconds (%u kB/s, %u KiB/s)\n",
+                         "seconds (%u kB/s, %u KiB/s, %u.%02u IOPS)\n",
                          mmc_hostname(test->card->host), sectors, sectors >> 1,
-                         (sectors == 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
-                         (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024);
+                         (sectors & 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
+                         (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024,
+                         iops / 100, iops % 100);
+
+        mmc_test_save_transfer_result(test, 1, sectors, ts, rate, iops);
 }
 
 /*
@@ -447,20 +543,24 @@ static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
                                     unsigned int count, struct timespec *ts1,
                                     struct timespec *ts2)
 {
-        unsigned int rate, sectors = bytes >> 9;
+        unsigned int rate, iops, sectors = bytes >> 9;
         uint64_t tot = bytes * count;
         struct timespec ts;
 
         ts = timespec_sub(*ts2, *ts1);
 
         rate = mmc_test_rate(tot, &ts);
+        iops = mmc_test_rate(count * 100, &ts); /* I/O ops per sec x 100 */
 
         printk(KERN_INFO "%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
-                         "%lu.%09lu seconds (%u kB/s, %u KiB/s)\n",
+                         "%lu.%09lu seconds (%u kB/s, %u KiB/s, "
+                         "%u.%02u IOPS)\n",
                          mmc_hostname(test->card->host), count, sectors, count,
-                         sectors >> 1, (sectors == 1 ? ".5" : ""),
+                         sectors >> 1, (sectors & 1 ? ".5" : ""),
                          (unsigned long)ts.tv_sec, (unsigned long)ts.tv_nsec,
-                         rate / 1000, rate / 1024);
+                         rate / 1000, rate / 1024, iops / 100, iops % 100);
+
+        mmc_test_save_transfer_result(test, count, sectors, ts, rate, iops);
 }
 
 /*
@@ -626,15 +726,10 @@ static int mmc_test_simple_transfer(struct mmc_test_card *test,
         struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
         unsigned blocks, unsigned blksz, int write)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_command stop;
-        struct mmc_data data;
-
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-        memset(&stop, 0, sizeof(struct mmc_command));
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_command stop = {0};
+        struct mmc_data data = {0};
 
         mrq.cmd = &cmd;
         mrq.data = &data;
@@ -656,18 +751,13 @@ static int mmc_test_simple_transfer(struct mmc_test_card *test,
 static int mmc_test_broken_transfer(struct mmc_test_card *test,
         unsigned blocks, unsigned blksz, int write)
 {
-        struct mmc_request mrq;
-        struct mmc_command cmd;
-        struct mmc_command stop;
-        struct mmc_data data;
+        struct mmc_request mrq = {0};
+        struct mmc_command cmd = {0};
+        struct mmc_command stop = {0};
+        struct mmc_data data = {0};
 
         struct scatterlist sg;
 
-        memset(&mrq, 0, sizeof(struct mmc_request));
-        memset(&cmd, 0, sizeof(struct mmc_command));
-        memset(&data, 0, sizeof(struct mmc_data));
-        memset(&stop, 0, sizeof(struct mmc_command));
-
         mrq.cmd = &cmd;
         mrq.data = &data;
         mrq.stop = &stop;
@@ -1215,16 +1305,22 @@ static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
                              int max_scatter)
 {
         struct mmc_test_area *t = &test->area;
+        int err;
 
         t->blocks = sz >> 9;
 
         if (max_scatter) {
-                return mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
-                                                   t->max_segs, &t->sg_len);
-        } else {
-                return mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
+                err = mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
+                                                  t->max_segs, t->max_seg_sz,
                                        &t->sg_len);
+        } else {
+                err = mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
+                                      t->max_seg_sz, &t->sg_len);
         }
+        if (err)
+                printk(KERN_INFO "%s: Failed to map sg list\n",
+                       mmc_hostname(test->card->host));
+        return err;
 }
 
 /*
@@ -1249,6 +1345,22 @@ static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
         struct timespec ts1, ts2;
         int ret;
 
+        /*
+         * In the case of a maximally scattered transfer, the maximum transfer
+         * size is further limited by using PAGE_SIZE segments.
+         */
+        if (max_scatter) {
+                struct mmc_test_area *t = &test->area;
+                unsigned long max_tfr;
+
+                if (t->max_seg_sz >= PAGE_SIZE)
+                        max_tfr = t->max_segs * PAGE_SIZE;
+                else
+                        max_tfr = t->max_segs * t->max_seg_sz;
+                if (sz > max_tfr)
+                        sz = max_tfr;
+        }
+
         ret = mmc_test_area_map(test, sz, max_scatter);
         if (ret)
                 return ret;
@@ -1274,8 +1386,9 @@ static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
  */
 static int mmc_test_area_fill(struct mmc_test_card *test)
 {
-        return mmc_test_area_io(test, test->area.max_sz, test->area.dev_addr,
-                                1, 0, 0);
+        struct mmc_test_area *t = &test->area;
+
+        return mmc_test_area_io(test, t->max_tfr, t->dev_addr, 1, 0, 0);
 }
 
 /*
@@ -1288,7 +1401,7 @@ static int mmc_test_area_erase(struct mmc_test_card *test)
         if (!mmc_can_erase(test->card))
                 return 0;
 
-        return mmc_erase(test->card, t->dev_addr, test->area.max_sz >> 9,
+        return mmc_erase(test->card, t->dev_addr, t->max_sz >> 9,
                          MMC_ERASE_ARG);
 }
 
@@ -1306,38 +1419,52 @@ static int mmc_test_area_cleanup(struct mmc_test_card *test)
 }
 
 /*
- * Initialize an area for testing large transfers.  The size of the area is the
- * preferred erase size which is a good size for optimal transfer speed.  Note
- * that is typically 4MiB for modern cards.  The test area is set to the middle
- * of the card because cards may have different charateristics at the front
- * (for FAT file system optimization).  Optionally, the area is erased (if the
- * card supports it) which may improve write performance.  Optionally, the area
- * is filled with data for subsequent read tests.
+ * Initialize an area for testing large transfers.  The test area is set to the
+ * middle of the card because cards may have different charateristics at the
+ * front (for FAT file system optimization).  Optionally, the area is erased
+ * (if the card supports it) which may improve write performance.  Optionally,
+ * the area is filled with data for subsequent read tests.
  */
 static int mmc_test_area_init(struct mmc_test_card *test, int erase, int fill)
 {
         struct mmc_test_area *t = &test->area;
-        unsigned long min_sz = 64 * 1024;
+        unsigned long min_sz = 64 * 1024, sz;
         int ret;
 
         ret = mmc_test_set_blksize(test, 512);
         if (ret)
                 return ret;
 
-        if (test->card->pref_erase > TEST_AREA_MAX_SIZE >> 9)
-                t->max_sz = TEST_AREA_MAX_SIZE;
-        else
-                t->max_sz = (unsigned long)test->card->pref_erase << 9;
+        /* Make the test area size about 4MiB */
+        sz = (unsigned long)test->card->pref_erase << 9;
+        t->max_sz = sz;
+        while (t->max_sz < 4 * 1024 * 1024)
+                t->max_sz += sz;
+        while (t->max_sz > TEST_AREA_MAX_SIZE && t->max_sz > sz)
+                t->max_sz -= sz;
+
+        t->max_segs = test->card->host->max_segs;
+        t->max_seg_sz = test->card->host->max_seg_size;
+
+        t->max_tfr = t->max_sz;
+        if (t->max_tfr >> 9 > test->card->host->max_blk_count)
+                t->max_tfr = test->card->host->max_blk_count << 9;
+        if (t->max_tfr > test->card->host->max_req_size)
+                t->max_tfr = test->card->host->max_req_size;
+        if (t->max_tfr / t->max_seg_sz > t->max_segs)
+                t->max_tfr = t->max_segs * t->max_seg_sz;
+
         /*
-         * Try to allocate enough memory for the whole area.  Less is OK
+         * Try to allocate enough memory for a max. sized transfer.  Less is OK
          * because the same memory can be mapped into the scatterlist more than
-         * once.
+         * once.  Also, take into account the limits imposed on scatterlist
+         * segments by the host driver.
          */
-        t->mem = mmc_test_alloc_mem(min_sz, t->max_sz);
+        t->mem = mmc_test_alloc_mem(min_sz, t->max_tfr, t->max_segs,
+                                    t->max_seg_sz);
         if (!t->mem)
                 return -ENOMEM;
 
-        t->max_segs = DIV_ROUND_UP(t->max_sz, PAGE_SIZE);
         t->sg = kmalloc(sizeof(struct scatterlist) * t->max_segs, GFP_KERNEL);
         if (!t->sg) {
                 ret = -ENOMEM;
@@ -1401,8 +1528,10 @@ static int mmc_test_area_prepare_fill(struct mmc_test_card *test)
 static int mmc_test_best_performance(struct mmc_test_card *test, int write,
                                      int max_scatter)
 {
-        return mmc_test_area_io(test, test->area.max_sz, test->area.dev_addr,
-                                write, max_scatter, 1);
+        struct mmc_test_area *t = &test->area;
+
+        return mmc_test_area_io(test, t->max_tfr, t->dev_addr, write,
+                                max_scatter, 1);
 }
 
 /*
@@ -1442,17 +1571,19 @@ static int mmc_test_best_write_perf_max_scatter(struct mmc_test_card *test)
  */
 static int mmc_test_profile_read_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr;
         int ret;
 
-        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
-                dev_addr = test->area.dev_addr + (sz >> 9);
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                dev_addr = t->dev_addr + (sz >> 9);
                 ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
                 if (ret)
                         return ret;
         }
-        dev_addr = test->area.dev_addr;
+        sz = t->max_tfr;
+        dev_addr = t->dev_addr;
         return mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
 }
 
@@ -1461,6 +1592,7 @@ static int mmc_test_profile_read_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_write_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr;
         int ret;
@@ -1468,8 +1600,8 @@ static int mmc_test_profile_write_perf(struct mmc_test_card *test)
         ret = mmc_test_area_erase(test);
         if (ret)
                 return ret;
-        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
-                dev_addr = test->area.dev_addr + (sz >> 9);
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                dev_addr = t->dev_addr + (sz >> 9);
                 ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
                 if (ret)
                         return ret;
@@ -1477,7 +1609,8 @@ static int mmc_test_profile_write_perf(struct mmc_test_card *test)
         ret = mmc_test_area_erase(test);
         if (ret)
                 return ret;
-        dev_addr = test->area.dev_addr;
+        sz = t->max_tfr;
+        dev_addr = t->dev_addr;
         return mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
 }
 
@@ -1486,6 +1619,7 @@ static int mmc_test_profile_write_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr;
         struct timespec ts1, ts2;
@@ -1497,8 +1631,8 @@ static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
         if (!mmc_can_erase(test->card))
                 return RESULT_UNSUP_HOST;
 
-        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
-                dev_addr = test->area.dev_addr + (sz >> 9);
+        for (sz = 512; sz < t->max_sz; sz <<= 1) {
+                dev_addr = t->dev_addr + (sz >> 9);
                 getnstimeofday(&ts1);
                 ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
                 if (ret)
@@ -1506,7 +1640,7 @@ static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
                 getnstimeofday(&ts2);
                 mmc_test_print_rate(test, sz, &ts1, &ts2);
         }
-        dev_addr = test->area.dev_addr;
+        dev_addr = t->dev_addr;
         getnstimeofday(&ts1);
         ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
         if (ret)
@@ -1516,29 +1650,66 @@ static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
         return 0;
 }
 
+static int mmc_test_seq_read_perf(struct mmc_test_card *test, unsigned long sz)
+{
+        struct mmc_test_area *t = &test->area;
+        unsigned int dev_addr, i, cnt;
+        struct timespec ts1, ts2;
+        int ret;
+
+        cnt = t->max_sz / sz;
+        dev_addr = t->dev_addr;
+        getnstimeofday(&ts1);
+        for (i = 0; i < cnt; i++) {
+                ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
+                if (ret)
+                        return ret;
+                dev_addr += (sz >> 9);
+        }
+        getnstimeofday(&ts2);
+        mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        return 0;
+}
+
 /*
  * Consecutive read performance by transfer size.
  */
 static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
+        int ret;
+
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                ret = mmc_test_seq_read_perf(test, sz);
+                if (ret)
+                        return ret;
+        }
+        sz = t->max_tfr;
+        return mmc_test_seq_read_perf(test, sz);
+}
+
+static int mmc_test_seq_write_perf(struct mmc_test_card *test, unsigned long sz)
+{
+        struct mmc_test_area *t = &test->area;
         unsigned int dev_addr, i, cnt;
         struct timespec ts1, ts2;
         int ret;
 
-        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
-                cnt = test->area.max_sz / sz;
-                dev_addr = test->area.dev_addr;
-                getnstimeofday(&ts1);
-                for (i = 0; i < cnt; i++) {
-                        ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
-                        if (ret)
-                                return ret;
-                        dev_addr += (sz >> 9);
-                }
-                getnstimeofday(&ts2);
-                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        ret = mmc_test_area_erase(test);
+        if (ret)
+                return ret;
+        cnt = t->max_sz / sz;
+        dev_addr = t->dev_addr;
+        getnstimeofday(&ts1);
+        for (i = 0; i < cnt; i++) {
+                ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
+                if (ret)
+                        return ret;
+                dev_addr += (sz >> 9);
         }
+        getnstimeofday(&ts2);
+        mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
         return 0;
 }
 
@@ -1547,28 +1718,17 @@ static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
-        unsigned int dev_addr, i, cnt;
-        struct timespec ts1, ts2;
         int ret;
 
-        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
-                ret = mmc_test_area_erase(test);
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                ret = mmc_test_seq_write_perf(test, sz);
                 if (ret)
                         return ret;
-                cnt = test->area.max_sz / sz;
-                dev_addr = test->area.dev_addr;
-                getnstimeofday(&ts1);
-                for (i = 0; i < cnt; i++) {
-                        ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
-                        if (ret)
-                                return ret;
-                        dev_addr += (sz >> 9);
-                }
-                getnstimeofday(&ts2);
-                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
         }
-        return 0;
+        sz = t->max_tfr;
+        return mmc_test_seq_write_perf(test, sz);
 }
 
 /*
@@ -1576,6 +1736,7 @@ static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
  */
 static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
 {
+        struct mmc_test_area *t = &test->area;
         unsigned long sz;
         unsigned int dev_addr, i, cnt;
         struct timespec ts1, ts2;
@@ -1587,15 +1748,15 @@ static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
         if (!mmc_can_erase(test->card))
                 return RESULT_UNSUP_HOST;
 
-        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
+        for (sz = 512; sz <= t->max_sz; sz <<= 1) {
                 ret = mmc_test_area_erase(test);
                 if (ret)
                         return ret;
                 ret = mmc_test_area_fill(test);
                 if (ret)
                         return ret;
-                cnt = test->area.max_sz / sz;
-                dev_addr = test->area.dev_addr;
+                cnt = t->max_sz / sz;
+                dev_addr = t->dev_addr;
                 getnstimeofday(&ts1);
                 for (i = 0; i < cnt; i++) {
                         ret = mmc_erase(test->card, dev_addr, sz >> 9,
@@ -1610,6 +1771,189 @@ static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
         return 0;
 }
 
+static unsigned int rnd_next = 1;
+
+static unsigned int mmc_test_rnd_num(unsigned int rnd_cnt)
+{
+        uint64_t r;
+
+        rnd_next = rnd_next * 1103515245 + 12345;
+        r = (rnd_next >> 16) & 0x7fff;
+        return (r * rnd_cnt) >> 15;
+}
+
+static int mmc_test_rnd_perf(struct mmc_test_card *test, int write, int print,
+                             unsigned long sz)
+{
+        unsigned int dev_addr, cnt, rnd_addr, range1, range2, last_ea = 0, ea;
+        unsigned int ssz;
+        struct timespec ts1, ts2, ts;
+        int ret;
+
+        ssz = sz >> 9;
+
+        rnd_addr = mmc_test_capacity(test->card) / 4;
+        range1 = rnd_addr / test->card->pref_erase;
+        range2 = range1 / ssz;
+
+        getnstimeofday(&ts1);
+        for (cnt = 0; cnt < UINT_MAX; cnt++) {
+                getnstimeofday(&ts2);
+                ts = timespec_sub(ts2, ts1);
+                if (ts.tv_sec >= 10)
+                        break;
+                ea = mmc_test_rnd_num(range1);
+                if (ea == last_ea)
+                        ea -= 1;
+                last_ea = ea;
+                dev_addr = rnd_addr + test->card->pref_erase * ea +
+                           ssz * mmc_test_rnd_num(range2);
+                ret = mmc_test_area_io(test, sz, dev_addr, write, 0, 0);
+                if (ret)
+                        return ret;
+        }
+        if (print)
+                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        return 0;
+}
+
+static int mmc_test_random_perf(struct mmc_test_card *test, int write)
+{
+        struct mmc_test_area *t = &test->area;
+        unsigned int next;
+        unsigned long sz;
+        int ret;
+
+        for (sz = 512; sz < t->max_tfr; sz <<= 1) {
+                /*
+                 * When writing, try to get more consistent results by running
+                 * the test twice with exactly the same I/O but outputting the
+                 * results only for the 2nd run.
+                 */
+                if (write) {
+                        next = rnd_next;
+                        ret = mmc_test_rnd_perf(test, write, 0, sz);
+                        if (ret)
+                                return ret;
+                        rnd_next = next;
+                }
+                ret = mmc_test_rnd_perf(test, write, 1, sz);
+                if (ret)
+                        return ret;
+        }
+        sz = t->max_tfr;
+        if (write) {
+                next = rnd_next;
+                ret = mmc_test_rnd_perf(test, write, 0, sz);
+                if (ret)
+                        return ret;
+                rnd_next = next;
+        }
+        return mmc_test_rnd_perf(test, write, 1, sz);
+}
+
+/*
+ * Random read performance by transfer size.
+ */
+static int mmc_test_random_read_perf(struct mmc_test_card *test)
+{
+        return mmc_test_random_perf(test, 0);
+}
+
+/*
+ * Random write performance by transfer size.
+ */
+static int mmc_test_random_write_perf(struct mmc_test_card *test)
+{
+        return mmc_test_random_perf(test, 1);
+}
+
+static int mmc_test_seq_perf(struct mmc_test_card *test, int write,
+                             unsigned int tot_sz, int max_scatter)
+{
+        struct mmc_test_area *t = &test->area;
+        unsigned int dev_addr, i, cnt, sz, ssz;
+        struct timespec ts1, ts2;
+        int ret;
+
+        sz = t->max_tfr;
+
+        /*
+         * In the case of a maximally scattered transfer, the maximum transfer
+         * size is further limited by using PAGE_SIZE segments.
+         */
+        if (max_scatter) {
+                unsigned long max_tfr;
+
+                if (t->max_seg_sz >= PAGE_SIZE)
+                        max_tfr = t->max_segs * PAGE_SIZE;
+                else
+                        max_tfr = t->max_segs * t->max_seg_sz;
+                if (sz > max_tfr)
+                        sz = max_tfr;
+        }
+
+        ssz = sz >> 9;
+        dev_addr = mmc_test_capacity(test->card) / 4;
+        if (tot_sz > dev_addr << 9)
+                tot_sz = dev_addr << 9;
+        cnt = tot_sz / sz;
+        dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
+
+        getnstimeofday(&ts1);
+        for (i = 0; i < cnt; i++) {
+                ret = mmc_test_area_io(test, sz, dev_addr, write,
+                                       max_scatter, 0);
+                if (ret)
+                        return ret;
+                dev_addr += ssz;
+        }
+        getnstimeofday(&ts2);
+
+        mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+
+        return 0;
+}
+
+static int mmc_test_large_seq_perf(struct mmc_test_card *test, int write)
+{
+        int ret, i;
+
+        for (i = 0; i < 10; i++) {
+                ret = mmc_test_seq_perf(test, write, 10 * 1024 * 1024, 1);
+                if (ret)
+                        return ret;
+        }
+        for (i = 0; i < 5; i++) {
+                ret = mmc_test_seq_perf(test, write, 100 * 1024 * 1024, 1);
+                if (ret)
+                        return ret;
+        }
+        for (i = 0; i < 3; i++) {
+                ret = mmc_test_seq_perf(test, write, 1000 * 1024 * 1024, 1);
+                if (ret)
+                        return ret;
+        }
+
+        return ret;
+}
+
+/*
+ * Large sequential read performance.
+ */
+static int mmc_test_large_seq_read_perf(struct mmc_test_card *test)
+{
+        return mmc_test_large_seq_perf(test, 0);
+}
+
+/*
+ * Large sequential write performance.
+ */
+static int mmc_test_large_seq_write_perf(struct mmc_test_card *test)
+{
+        return mmc_test_large_seq_perf(test, 1);
+}
+
 static const struct mmc_test_case mmc_test_cases[] = {
         {
                 .name = "Basic write (no data verification)",
@@ -1849,10 +2193,40 @@ static const struct mmc_test_case mmc_test_cases[] = {
                 .cleanup = mmc_test_area_cleanup,
         },
 
+        {
+                .name = "Random read performance by transfer size",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_random_read_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Random write performance by transfer size",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_random_write_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Large sequential read into scattered pages",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_large_seq_read_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Large sequential write from scattered pages",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_large_seq_write_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
 };
 
 static DEFINE_MUTEX(mmc_test_lock);
 
+static LIST_HEAD(mmc_test_result);
+
 static void mmc_test_run(struct mmc_test_card *test, int testcase)
 {
         int i, ret;
@@ -1863,6 +2237,8 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
         mmc_claim_host(test->card->host);
 
         for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {
+                struct mmc_test_general_result *gr;
+
                 if (testcase && ((i + 1) != testcase))
                         continue;
 
@@ -1881,6 +2257,25 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                         }
                 }
 
+                gr = kzalloc(sizeof(struct mmc_test_general_result),
+                        GFP_KERNEL);
+                if (gr) {
+                        INIT_LIST_HEAD(&gr->tr_lst);
+
+                        /* Assign data what we know already */
+                        gr->card = test->card;
+                        gr->testcase = i;
+
+                        /* Append container to global one */
+                        list_add_tail(&gr->link, &mmc_test_result);
+
+                        /*
+                         * Save the pointer to created container in our private
+                         * structure.
+                         */
+                        test->gr = gr;
+                }
+
                 ret = mmc_test_cases[i].run(test);
                 switch (ret) {
                 case RESULT_OK:
@@ -1906,6 +2301,10 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                                 mmc_hostname(test->card->host), ret);
                 }
 
+                /* Save the result */
+                if (gr)
+                        gr->result = ret;
+
                 if (mmc_test_cases[i].cleanup) {
                         ret = mmc_test_cases[i].cleanup(test);
                         if (ret) {
@@ -1923,30 +2322,95 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                 mmc_hostname(test->card->host));
 }
 
-static ssize_t mmc_test_show(struct device *dev,
-        struct device_attribute *attr, char *buf)
+static void mmc_test_free_result(struct mmc_card *card)
+{
+        struct mmc_test_general_result *gr, *grs;
+
+        mutex_lock(&mmc_test_lock);
+
+        list_for_each_entry_safe(gr, grs, &mmc_test_result, link) {
+                struct mmc_test_transfer_result *tr, *trs;
+
+                if (card && gr->card != card)
+                        continue;
+
+                list_for_each_entry_safe(tr, trs, &gr->tr_lst, link) {
+                        list_del(&tr->link);
+                        kfree(tr);
+                }
+
+                list_del(&gr->link);
+                kfree(gr);
+        }
+
+        mutex_unlock(&mmc_test_lock);
+}
+
+static LIST_HEAD(mmc_test_file_test);
+
+static int mtf_test_show(struct seq_file *sf, void *data)
 {
+        struct mmc_card *card = (struct mmc_card *)sf->private;
+        struct mmc_test_general_result *gr;
+
         mutex_lock(&mmc_test_lock);
+
+        list_for_each_entry(gr, &mmc_test_result, link) {
+                struct mmc_test_transfer_result *tr;
+
+                if (gr->card != card)
+                        continue;
+
+                seq_printf(sf, "Test %d: %d\n", gr->testcase + 1, gr->result);
+
+                list_for_each_entry(tr, &gr->tr_lst, link) {
+                        seq_printf(sf, "%u %d %lu.%09lu %u %u.%02u\n",
+                                tr->count, tr->sectors,
+                                (unsigned long)tr->ts.tv_sec,
+                                (unsigned long)tr->ts.tv_nsec,
+                                tr->rate, tr->iops / 100, tr->iops % 100);
+                }
+        }
+
         mutex_unlock(&mmc_test_lock);
 
         return 0;
 }
 
-static ssize_t mmc_test_store(struct device *dev,
-        struct device_attribute *attr, const char *buf, size_t count)
+static int mtf_test_open(struct inode *inode, struct file *file)
 {
-        struct mmc_card *card;
+        return single_open(file, mtf_test_show, inode->i_private);
+}
+
+static ssize_t mtf_test_write(struct file *file, const char __user *buf,
+        size_t count, loff_t *pos)
+{
+        struct seq_file *sf = (struct seq_file *)file->private_data;
+        struct mmc_card *card = (struct mmc_card *)sf->private;
         struct mmc_test_card *test;
-        int testcase;
+        char lbuf[12];
+        long testcase;
+
+        if (count >= sizeof(lbuf))
+                return -EINVAL;
 
-        card = container_of(dev, struct mmc_card, dev);
+        if (copy_from_user(lbuf, buf, count))
+                return -EFAULT;
+        lbuf[count] = '\0';
 
-        testcase = simple_strtol(buf, NULL, 10);
+        if (strict_strtol(lbuf, 10, &testcase))
+                return -EINVAL;
 
         test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);
         if (!test)
                 return -ENOMEM;
 
+        /*
+         * Remove all test cases associated with given card. Thus we have only
+         * actual data of the last run.
+         */
+        mmc_test_free_result(card);
+
         test->card = card;
 
         test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
@@ -1973,16 +2437,78 @@ static ssize_t mmc_test_store(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(test, S_IWUSR | S_IRUGO, mmc_test_show, mmc_test_store);
+static const struct file_operations mmc_test_fops_test = {
+        .open           = mtf_test_open,
+        .read           = seq_read,
+        .write          = mtf_test_write,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static void mmc_test_free_file_test(struct mmc_card *card)
+{
+        struct mmc_test_dbgfs_file *df, *dfs;
+
+        mutex_lock(&mmc_test_lock);
+
+        list_for_each_entry_safe(df, dfs, &mmc_test_file_test, link) {
+                if (card && df->card != card)
+                        continue;
+                debugfs_remove(df->file);
+                list_del(&df->link);
+                kfree(df);
+        }
+
+        mutex_unlock(&mmc_test_lock);
+}
+
+static int mmc_test_register_file_test(struct mmc_card *card)
+{
+        struct dentry *file = NULL;
+        struct mmc_test_dbgfs_file *df;
+        int ret = 0;
+
+        mutex_lock(&mmc_test_lock);
+
+        if (card->debugfs_root)
+                file = debugfs_create_file("test", S_IWUSR | S_IRUGO,
+                        card->debugfs_root, card, &mmc_test_fops_test);
+
+        if (IS_ERR_OR_NULL(file)) {
+                dev_err(&card->dev,
+                        "Can't create file. Perhaps debugfs is disabled.\n");
+                ret = -ENODEV;
+                goto err;
+        }
+
+        df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL);
+        if (!df) {
+                debugfs_remove(file);
+                dev_err(&card->dev,
+                        "Can't allocate memory for internal usage.\n");
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        df->card = card;
+        df->file = file;
+
+        list_add(&df->link, &mmc_test_file_test);
+
+err:
+        mutex_unlock(&mmc_test_lock);
+
+        return ret;
+}
 
 static int mmc_test_probe(struct mmc_card *card)
 {
         int ret;
 
-        if ((card->type != MMC_TYPE_MMC) && (card->type != MMC_TYPE_SD))
+        if (!mmc_card_mmc(card) && !mmc_card_sd(card))
                 return -ENODEV;
 
-        ret = device_create_file(&card->dev, &dev_attr_test);
+        ret = mmc_test_register_file_test(card);
         if (ret)
                 return ret;
 
@@ -1993,7 +2519,8 @@ static int mmc_test_probe(struct mmc_card *card)
 
 static void mmc_test_remove(struct mmc_card *card)
 {
-        device_remove_file(&card->dev, &dev_attr_test);
+        mmc_test_free_result(card);
+        mmc_test_free_file_test(card);
 }
 
 static struct mmc_driver mmc_driver = {
@@ -2011,6 +2538,10 @@ static int __init mmc_test_init(void)
 
 static void __exit mmc_test_exit(void)
 {
+        /* Clear stalled data if card is still plugged */
+        mmc_test_free_result(NULL);
+        mmc_test_free_file_test(NULL);
+
         mmc_unregister_driver(&mmc_driver);
 }