mmc: fix async request mechanism for sequential read scenarios

When current request is running on the bus and if next request fetched
by mmcqd is NULL, mmc context (mmcqd thread) gets blocked until the
current request completes. This means that if new request comes in while
the mmcqd thread is blocked, this new request can not be prepared in
parallel to current ongoing request. This may result in delaying the new
request execution and increase it's latency.

This change allows to wake up the MMC thread on new request arrival.
Now once the MMC thread is woken up, a new request can be fetched and
prepared in parallel to the current running request which means this new
request can be started immediately after the current running request
completes.

With this change read throughput is improved by 16%.

Signed-off-by: Konstantin Dorfman <kdorfman@codeaurora.org>
Reviewed-by: Seungwon Jeon <tgih.jun@samsung.com>
Signed-off-by: Chris Ball <cjb@laptop.org>

3 files changed, 40 insertions, 15 deletions

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 21056b9ef0a0..f79b4688e471 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -113,17 +113,6 @@ struct mmc_blk_data {
 
 static DEFINE_MUTEX(open_lock);
 
-enum mmc_blk_status {
-        MMC_BLK_SUCCESS = 0,
-        MMC_BLK_PARTIAL,
-        MMC_BLK_CMD_ERR,
-        MMC_BLK_RETRY,
-        MMC_BLK_ABORT,
-        MMC_BLK_DATA_ERR,
-        MMC_BLK_ECC_ERR,
-        MMC_BLK_NOMEDIUM,
-};
-
 module_param(perdev_minors, int, 0444);
 MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device");
 
@@ -1364,8 +1353,11 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                 } else
                         areq = NULL;
                 areq = mmc_start_req(card->host, areq, (int *) &status);
-                if (!areq)
+                if (!areq) {
+                        if (status == MMC_BLK_NEW_REQUEST)
+                                mq->flags |= MMC_QUEUE_NEW_REQUEST;
                         return 0;
+                }
 
                 mq_rq = container_of(areq, struct mmc_queue_req, mmc_active);
                 brq = &mq_rq->brq;
@@ -1438,6 +1430,10 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                         break;
                 case MMC_BLK_NOMEDIUM:
                         goto cmd_abort;
+                default:
+                        pr_err("%s: Unhandled return value (%d)",
+                                        req->rq_disk->disk_name, status);
+                        goto cmd_abort;
                 }
 
                 if (ret) {
@@ -1472,6 +1468,8 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
         int ret;
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
+        struct mmc_host *host = card->host;
+        unsigned long flags;
 
         if (req && !mq->mqrq_prev->req)
                 /* claim host only for the first request */
@@ -1486,6 +1484,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                 goto out;
         }
 
+        mq->flags &= ~MMC_QUEUE_NEW_REQUEST;
         if (req && req->cmd_flags & REQ_DISCARD) {
                 /* complete ongoing async transfer before issuing discard */
                 if (card->host->areq)
@@ -1501,11 +1500,16 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                         mmc_blk_issue_rw_rq(mq, NULL);
                 ret = mmc_blk_issue_flush(mq, req);
         } else {
+                if (!req && host->areq) {
+                        spin_lock_irqsave(&host->context_info.lock, flags);
+                        host->context_info.is_waiting_last_req = true;
+                        spin_unlock_irqrestore(&host->context_info.lock, flags);
+                }
                 ret = mmc_blk_issue_rw_rq(mq, req);
         }
 
 out:
-        if (!req)
+        if (!req && !(mq->flags & MMC_QUEUE_NEW_REQUEST))
                 /* release host only when there are no more requests */
                 mmc_release_host(card->host);
         return ret;
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index d630d9861e7b..5e0971016ac5 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -22,7 +22,6 @@
 
 #define MMC_QUEUE_BOUNCESZ      65536
 
-#define MMC_QUEUE_SUSPENDED     (1 << 0)
 
 #define MMC_REQ_SPECIAL_MASK    (REQ_DISCARD | REQ_FLUSH)
 
@@ -72,6 +71,10 @@ static int mmc_queue_thread(void *d)
                         set_current_state(TASK_RUNNING);
                         cmd_flags = req ? req->cmd_flags : 0;
                         mq->issue_fn(mq, req);
+                        if (mq->flags & MMC_QUEUE_NEW_REQUEST) {
+                                mq->flags &= ~MMC_QUEUE_NEW_REQUEST;
+                                continue; /* fetch again */
+                        }
 
                         /*
                          * Current request becomes previous request
@@ -113,6 +116,8 @@ static void mmc_request_fn(struct request_queue *q)
 {
         struct mmc_queue *mq = q->queuedata;
         struct request *req;
+        unsigned long flags;
+        struct mmc_context_info *cntx;
 
         if (!mq) {
                 while ((req = blk_fetch_request(q)) != NULL) {
@@ -122,7 +127,20 @@ static void mmc_request_fn(struct request_queue *q)
                 return;
         }
 
-        if (!mq->mqrq_cur->req && !mq->mqrq_prev->req)
+        cntx = &mq->card->host->context_info;
+        if (!mq->mqrq_cur->req && mq->mqrq_prev->req) {
+                /*
+                 * New MMC request arrived when MMC thread may be
+                 * blocked on the previous request to be complete
+                 * with no current request fetched
+                 */
+                spin_lock_irqsave(&cntx->lock, flags);
+                if (cntx->is_waiting_last_req) {
+                        cntx->is_new_req = true;
+                        wake_up_interruptible(&cntx->wait);
+                }
+                spin_unlock_irqrestore(&cntx->lock, flags);
+        } else if (!mq->mqrq_cur->req && !mq->mqrq_prev->req)
                 wake_up_process(mq->thread);
 }
 
diff --git a/drivers/mmc/card/queue.h b/drivers/mmc/card/queue.h
index d2a1eb4b9f9f..e20c27b2b8b4 100644
--- a/drivers/mmc/card/queue.h
+++ b/drivers/mmc/card/queue.h
@@ -27,6 +27,9 @@ struct mmc_queue {
         struct task_struct      *thread;
         struct semaphore        thread_sem;
         unsigned int            flags;
+#define MMC_QUEUE_SUSPENDED     (1 << 0)
+#define MMC_QUEUE_NEW_REQUEST   (1 << 1)
+
         int                     (*issue_fn)(struct mmc_queue *, struct request *);
         void                    *data;
         struct request_queue    *queue;