mmc: block: Introduce queue semantics

Change from viewing the requests in progress as 'current' and 'previous',
to viewing them as a queue. The current request is allocated to the first
free slot. The presence of incomplete requests is determined from the
count (mq->qcnt) of entries in the queue. Non-read-write requests (i.e.
discards and flushes) are not added to the queue at all and require no
special handling. Also no special handling is needed for the
MMC_BLK_NEW_REQUEST case.

As well as allowing an arbitrarily sized queue, the queue thread function
is significantly simpler.

Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Reviewed-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>

1 files changed, 47 insertions, 28 deletions

diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c
index 493eb10ce580..4a2045527b62 100644
--- a/drivers/mmc/core/queue.c
+++ b/drivers/mmc/core/queue.c
@@ -40,6 +40,35 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
         return BLKPREP_OK;
 }
 
+struct mmc_queue_req *mmc_queue_req_find(struct mmc_queue *mq,
+                                         struct request *req)
+{
+        struct mmc_queue_req *mqrq;
+        int i = ffz(mq->qslots);
+
+        if (i >= mq->qdepth)
+                return NULL;
+
+        mqrq = &mq->mqrq[i];
+        WARN_ON(mqrq->req || mq->qcnt >= mq->qdepth ||
+                test_bit(mqrq->task_id, &mq->qslots));
+        mqrq->req = req;
+        mq->qcnt += 1;
+        __set_bit(mqrq->task_id, &mq->qslots);
+
+        return mqrq;
+}
+
+void mmc_queue_req_free(struct mmc_queue *mq,
+                        struct mmc_queue_req *mqrq)
+{
+        WARN_ON(!mqrq->req || mq->qcnt < 1 ||
+                !test_bit(mqrq->task_id, &mq->qslots));
+        mqrq->req = NULL;
+        mq->qcnt -= 1;
+        __clear_bit(mqrq->task_id, &mq->qslots);
+}
+
 static int mmc_queue_thread(void *d)
 {
         struct mmc_queue *mq = d;
@@ -50,7 +79,7 @@ static int mmc_queue_thread(void *d)
 
         down(&mq->thread_sem);
         do {
-                struct request *req = NULL;
+                struct request *req;
 
                 spin_lock_irq(q->queue_lock);
                 set_current_state(TASK_INTERRUPTIBLE);
@@ -63,38 +92,17 @@ static int mmc_queue_thread(void *d)
                          * Dispatch queue is empty so set flags for
                          * mmc_request_fn() to wake us up.
                          */
-                        if (mq->mqrq_prev->req)
+                        if (mq->qcnt)
                                 cntx->is_waiting_last_req = true;
                         else
                                 mq->asleep = true;
                 }
-                mq->mqrq_cur->req = req;
                 spin_unlock_irq(q->queue_lock);
 
-                if (req || mq->mqrq_prev->req) {
-                        bool req_is_special = mmc_req_is_special(req);
-
+                if (req || mq->qcnt) {
                         set_current_state(TASK_RUNNING);
                         mmc_blk_issue_rq(mq, req);
                         cond_resched();
-                        if (mq->new_request) {
-                                mq->new_request = false;
-                                continue; /* fetch again */
-                        }
-
-                        /*
-                         * Current request becomes previous request
-                         * and vice versa.
-                         * In case of special requests, current request
-                         * has been finished. Do not assign it to previous
-                         * request.
-                         */
-                        if (req_is_special)
-                                mq->mqrq_cur->req = NULL;
-
-                        mq->mqrq_prev->brq.mrq.data = NULL;
-                        mq->mqrq_prev->req = NULL;
-                        swap(mq->mqrq_prev, mq->mqrq_cur);
                 } else {
                         if (kthread_should_stop()) {
                                 set_current_state(TASK_RUNNING);
@@ -177,6 +185,20 @@ static void mmc_queue_setup_discard(struct request_queue *q,
                 queue_flag_set_unlocked(QUEUE_FLAG_SECERASE, q);
 }
 
+static struct mmc_queue_req *mmc_queue_alloc_mqrqs(int qdepth)
+{
+        struct mmc_queue_req *mqrq;
+        int i;
+
+        mqrq = kcalloc(qdepth, sizeof(*mqrq), GFP_KERNEL);
+        if (mqrq) {
+                for (i = 0; i < qdepth; i++)
+                        mqrq[i].task_id = i;
+        }
+
+        return mqrq;
+}
+
 #ifdef CONFIG_MMC_BLOCK_BOUNCE
 static bool mmc_queue_alloc_bounce_bufs(struct mmc_queue *mq,
                                         unsigned int bouncesz)
@@ -279,12 +301,9 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
                 return -ENOMEM;
 
         mq->qdepth = 2;
-        mq->mqrq = kcalloc(mq->qdepth, sizeof(struct mmc_queue_req),
-                           GFP_KERNEL);
+        mq->mqrq = mmc_queue_alloc_mqrqs(mq->qdepth);
         if (!mq->mqrq)
                 goto blk_cleanup;
-        mq->mqrq_cur = &mq->mqrq[0];
-        mq->mqrq_prev = &mq->mqrq[1];
         mq->queue->queuedata = mq;
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);