mmc: block: add member in mmc queue struct to hold request data

The way the request data is organized in the mmc queue struct, it only
allows processing of one request at a time.  This patch adds a new struct
to hold mmc queue request data such as sg list, request, blk request and
bounce buffers, and updates any functions depending on the mmc queue
struct. This prepares for using multiple active requests in one mmc queue.

Signed-off-by: Per Forlin <per.forlin@linaro.org>
Acked-by: Kyungmin Park <kyungmin.park@samsung.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Reviewed-by: Venkatraman S <svenkatr@ti.com>
Tested-by: Sourav Poddar <sourav.poddar@ti.com>
Tested-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Chris Ball <cjb@laptop.org>

1 files changed, 67 insertions, 62 deletions

diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index defc11b4572c..9122ff5f39c8 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -56,7 +56,7 @@ static int mmc_queue_thread(void *d)
                 spin_lock_irq(q->queue_lock);
                 set_current_state(TASK_INTERRUPTIBLE);
                 req = blk_fetch_request(q);
-                mq->req = req;
+                mq->mqrq_cur->req = req;
                 spin_unlock_irq(q->queue_lock);
 
                 if (!req) {
@@ -97,10 +97,25 @@ static void mmc_request(struct request_queue *q)
                 return;
         }
 
-        if (!mq->req)
+        if (!mq->mqrq_cur->req)
                 wake_up_process(mq->thread);
 }
 
+struct scatterlist *mmc_alloc_sg(int sg_len, int *err)
+{
+        struct scatterlist *sg;
+
+        sg = kmalloc(sizeof(struct scatterlist)*sg_len, GFP_KERNEL);
+        if (!sg)
+                *err = -ENOMEM;
+        else {
+                *err = 0;
+                sg_init_table(sg, sg_len);
+        }
+
+        return sg;
+}
+
 static void mmc_queue_setup_discard(struct request_queue *q,
                                     struct mmc_card *card)
 {
@@ -137,6 +152,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
         struct mmc_host *host = card->host;
         u64 limit = BLK_BOUNCE_HIGH;
         int ret;
+        struct mmc_queue_req *mqrq_cur = &mq->mqrq[0];
 
         if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
                 limit = *mmc_dev(host)->dma_mask;
@@ -146,8 +162,9 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
         if (!mq->queue)
                 return -ENOMEM;
 
+        memset(&mq->mqrq_cur, 0, sizeof(mq->mqrq_cur));
+        mq->mqrq_cur = mqrq_cur;
         mq->queue->queuedata = mq;
-        mq->req = NULL;
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
@@ -168,53 +185,44 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
                         bouncesz = host->max_blk_count * 512;
 
                 if (bouncesz > 512) {
-                        mq->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
-                        if (!mq->bounce_buf) {
+                        mqrq_cur->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
+                        if (!mqrq_cur->bounce_buf) {
                                 printk(KERN_WARNING "%s: unable to "
-                                        "allocate bounce buffer\n",
+                                        "allocate bounce cur buffer\n",
                                         mmc_card_name(card));
                         }
                 }
 
-                if (mq->bounce_buf) {
+                if (mqrq_cur->bounce_buf) {
                         blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
                         blk_queue_max_hw_sectors(mq->queue, bouncesz / 512);
                         blk_queue_max_segments(mq->queue, bouncesz / 512);
                         blk_queue_max_segment_size(mq->queue, bouncesz);
 
-                        mq->sg = kmalloc(sizeof(struct scatterlist),
-                                GFP_KERNEL);
-                        if (!mq->sg) {
-                                ret = -ENOMEM;
+                        mqrq_cur->sg = mmc_alloc_sg(1, &ret);
+                        if (ret)
                                 goto cleanup_queue;
-                        }
-                        sg_init_table(mq->sg, 1);
 
-                        mq->bounce_sg = kmalloc(sizeof(struct scatterlist) *
-                                bouncesz / 512, GFP_KERNEL);
-                        if (!mq->bounce_sg) {
-                                ret = -ENOMEM;
+                        mqrq_cur->bounce_sg =
+                                mmc_alloc_sg(bouncesz / 512, &ret);
+                        if (ret)
                                 goto cleanup_queue;
-                        }
-                        sg_init_table(mq->bounce_sg, bouncesz / 512);
+
                 }
         }
 #endif
 
-        if (!mq->bounce_buf) {
+        if (!mqrq_cur->bounce_buf) {
                 blk_queue_bounce_limit(mq->queue, limit);
                 blk_queue_max_hw_sectors(mq->queue,
                         min(host->max_blk_count, host->max_req_size / 512));
                 blk_queue_max_segments(mq->queue, host->max_segs);
                 blk_queue_max_segment_size(mq->queue, host->max_seg_size);
 
-                mq->sg = kmalloc(sizeof(struct scatterlist) *
-                        host->max_segs, GFP_KERNEL);
-                if (!mq->sg) {
-                        ret = -ENOMEM;
+                mqrq_cur->sg = mmc_alloc_sg(host->max_segs, &ret);
+                if (ret)
                         goto cleanup_queue;
-                }
-                sg_init_table(mq->sg, host->max_segs);
+
         }
 
         sema_init(&mq->thread_sem, 1);
@@ -229,16 +237,15 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
 
         return 0;
  free_bounce_sg:
-        if (mq->bounce_sg)
-                kfree(mq->bounce_sg);
-        mq->bounce_sg = NULL;
+        kfree(mqrq_cur->bounce_sg);
+        mqrq_cur->bounce_sg = NULL;
+
  cleanup_queue:
-        if (mq->sg)
-                kfree(mq->sg);
-        mq->sg = NULL;
-        if (mq->bounce_buf)
-                kfree(mq->bounce_buf);
-        mq->bounce_buf = NULL;
+        kfree(mqrq_cur->sg);
+        mqrq_cur->sg = NULL;
+        kfree(mqrq_cur->bounce_buf);
+        mqrq_cur->bounce_buf = NULL;
+
         blk_cleanup_queue(mq->queue);
         return ret;
 }
@@ -247,6 +254,7 @@ void mmc_cleanup_queue(struct mmc_queue *mq)
 {
         struct request_queue *q = mq->queue;
         unsigned long flags;
+        struct mmc_queue_req *mqrq_cur = mq->mqrq_cur;
 
         /* Make sure the queue isn't suspended, as that will deadlock */
         mmc_queue_resume(mq);
@@ -260,16 +268,14 @@ void mmc_cleanup_queue(struct mmc_queue *mq)
         blk_start_queue(q);
         spin_unlock_irqrestore(q->queue_lock, flags);
 
-        if (mq->bounce_sg)
-                kfree(mq->bounce_sg);
-        mq->bounce_sg = NULL;
+        kfree(mqrq_cur->bounce_sg);
+        mqrq_cur->bounce_sg = NULL;
 
-        kfree(mq->sg);
-        mq->sg = NULL;
+        kfree(mqrq_cur->sg);
+        mqrq_cur->sg = NULL;
 
-        if (mq->bounce_buf)
-                kfree(mq->bounce_buf);
-        mq->bounce_buf = NULL;
+        kfree(mqrq_cur->bounce_buf);
+        mqrq_cur->bounce_buf = NULL;
 
         mq->card = NULL;
 }
@@ -322,27 +328,27 @@ void mmc_queue_resume(struct mmc_queue *mq)
 /*
  * Prepare the sg list(s) to be handed of to the host driver
  */
-unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
+unsigned int mmc_queue_map_sg(struct mmc_queue *mq, struct mmc_queue_req *mqrq)
 {
         unsigned int sg_len;
         size_t buflen;
         struct scatterlist *sg;
         int i;
 
-        if (!mq->bounce_buf)
-                return blk_rq_map_sg(mq->queue, mq->req, mq->sg);
+        if (!mqrq->bounce_buf)
+                return blk_rq_map_sg(mq->queue, mqrq->req, mqrq->sg);
 
-        BUG_ON(!mq->bounce_sg);
+        BUG_ON(!mqrq->bounce_sg);
 
-        sg_len = blk_rq_map_sg(mq->queue, mq->req, mq->bounce_sg);
+        sg_len = blk_rq_map_sg(mq->queue, mqrq->req, mqrq->bounce_sg);
 
-        mq->bounce_sg_len = sg_len;
+        mqrq->bounce_sg_len = sg_len;
 
         buflen = 0;
-        for_each_sg(mq->bounce_sg, sg, sg_len, i)
+        for_each_sg(mqrq->bounce_sg, sg, sg_len, i)
                 buflen += sg->length;
 
-        sg_init_one(mq->sg, mq->bounce_buf, buflen);
+        sg_init_one(mqrq->sg, mqrq->bounce_buf, buflen);
 
         return 1;
 }
@@ -351,31 +357,30 @@ unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
  * If writing, bounce the data to the buffer before the request
  * is sent to the host driver
  */
-void mmc_queue_bounce_pre(struct mmc_queue *mq)
+void mmc_queue_bounce_pre(struct mmc_queue_req *mqrq)
 {
-        if (!mq->bounce_buf)
+        if (!mqrq->bounce_buf)
                 return;
 
-        if (rq_data_dir(mq->req) != WRITE)
+        if (rq_data_dir(mqrq->req) != WRITE)
                 return;
 
-        sg_copy_to_buffer(mq->bounce_sg, mq->bounce_sg_len,
-                mq->bounce_buf, mq->sg[0].length);
+        sg_copy_to_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
+                mqrq->bounce_buf, mqrq->sg[0].length);
 }
 
 /*
  * If reading, bounce the data from the buffer after the request
  * has been handled by the host driver
  */
-void mmc_queue_bounce_post(struct mmc_queue *mq)
+void mmc_queue_bounce_post(struct mmc_queue_req *mqrq)
 {
-        if (!mq->bounce_buf)
+        if (!mqrq->bounce_buf)
                 return;
 
-        if (rq_data_dir(mq->req) != READ)
+        if (rq_data_dir(mqrq->req) != READ)
                 return;
 
-        sg_copy_from_buffer(mq->bounce_sg, mq->bounce_sg_len,
-                mq->bounce_buf, mq->sg[0].length);
+        sg_copy_from_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
+                mqrq->bounce_buf, mqrq->sg[0].length);
 }
-