Merge tag 'mmc-v4.13' of git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc

Pull MMC updates from Ulf Hansson:
 "MMC core:
   - Add support to enable irq wake for slot gpio
   - Remove MMC_CAP2_HC_ERASE_SZ and make it the default behaviour
   - Improve R1 response error checks for stop commands
   - Cleanup and clarify some MMC specific code
   - Keep card runtime resumed while adding SDIO function devices
   - Use device_property_read instead of of_property_read in mmc_of_parse()
   - Move boot partition locking into a driver op to enable proper I/O scheduling
   - Move multi/single-ioctl() to use block layer to enable proper I/O scheduling
   - Delete bounce buffer Kconfig option
   - Improve the eMMC HW reset support provided via the eMMC pwrseq
   - Add host API to manage SDIO IRQs from a workqueue

  MMC host:
   - dw_mmc: Drop support for multiple slots
   - dw_mmc: Use device_property_read instead of of_property_read
   - dw_mmc-rockchip: Optional improved tuning to greatly decrease tuning time
   - dw_mmc: Prevent rpm suspend for SDIO IRQs instead of always for SDIO cards
   - dw_mmc: Convert to use MMC_CAP2_SDIO_IRQ_NOTHREAD for SDIO IRQs
   - omap_hsmmc: Convert to mmc regulator APIs to consolidate code
   - omap_hsmmc: Deprecate "vmmc_aux" in DT and use "vqmmc" instead
   - tmio: make sure SDIO gets reinitialized after resume
   - sdhi: add CMD23 support to R-Car Gen2 & Gen3
   - tmio: add CMD23 support
   - sdhi/tmio: Refactor code and rename files to simplify Kconfig options
   - sdhci-pci: Enable card detect wake for Intel BYT-related SD controllers
   - sdhci-pci: Add support for Intel CNP
   - sdhci-esdhc-imx: Remove ENGcm07207 workaround - allow multi block transfers
   - sdhci-esdhc-imx: Allow all supported prescaler values
   - sdhci-esdhc-imx: Fix DAT line software reset
   - sdhci-esdhc: Add SDHCI_QUIRK_32BIT_DMA_ADDR
   - atmel-mci: Drop AVR32 support"

* tag 'mmc-v4.13' of git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc: (86 commits)
  mmc: dw_mmc: remove the unnecessary slot variable
  mmc: dw_mmc: use the 'slot' instead of 'cur_slot'
  mmc: dw_mmc: remove the 'id' arguments about functions relevant to slot
  mmc: dw_mmc: change the array of slots
  mmc: dw_mmc: remove the loop about finding slots
  mmc: dw_mmc: deprecated the "num-slots" property
  mmc: dw_mmc-rockchip: parse rockchip, desired-num-phases from DT
  dt-bindings: rockchip-dw-mshc: add optional rockchip, desired-num-phases
  mmc: renesas-sdhi: improve checkpatch cleanness
  mmc: tmio: improve checkpatch cleanness
  mmc: sdhci-pci: Enable card detect wake for Intel BYT-related SD controllers
  mmc: slot-gpio: Add support to enable irq wake on cd_irq
  mmc: core: Remove MMC_CAP2_HC_ERASE_SZ
  mmc: core: for data errors, take response of stop cmd into account
  mmc: core: check also R1 response for stop commands
  mmc: core: Clarify code for sending CSD
  mmc: core: Drop mmc_all_send_cid() and use mmc_send_cxd_native() instead
  mmc: core: Re-factor code for sending CID
  mmc: core: Remove redundant code in mmc_send_cid()
  mmc: core: Make mmc_can_reset() static
  ...

1 files changed, 60 insertions, 182 deletions

diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c
index b659a28c8018..affa7370ba82 100644
--- a/drivers/mmc/core/queue.c
+++ b/drivers/mmc/core/queue.c
@@ -40,35 +40,6 @@ 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;
@@ -149,11 +120,11 @@ static void mmc_request_fn(struct request_queue *q)
                 wake_up_process(mq->thread);
 }
 
-static struct scatterlist *mmc_alloc_sg(int sg_len)
+static struct scatterlist *mmc_alloc_sg(int sg_len, gfp_t gfp)
 {
         struct scatterlist *sg;
 
-        sg = kmalloc_array(sg_len, sizeof(*sg), GFP_KERNEL);
+        sg = kmalloc_array(sg_len, sizeof(*sg), gfp);
         if (sg)
                 sg_init_table(sg, sg_len);
 
@@ -179,86 +150,11 @@ static void mmc_queue_setup_discard(struct request_queue *q,
                 queue_flag_set_unlocked(QUEUE_FLAG_SECERASE, q);
 }
 
-static void mmc_queue_req_free_bufs(struct mmc_queue_req *mqrq)
-{
-        kfree(mqrq->bounce_sg);
-        mqrq->bounce_sg = NULL;
-
-        kfree(mqrq->sg);
-        mqrq->sg = NULL;
-
-        kfree(mqrq->bounce_buf);
-        mqrq->bounce_buf = NULL;
-}
-
-static void mmc_queue_reqs_free_bufs(struct mmc_queue_req *mqrq, int qdepth)
-{
-        int i;
-
-        for (i = 0; i < qdepth; i++)
-                mmc_queue_req_free_bufs(&mqrq[i]);
-}
-
-static void mmc_queue_free_mqrqs(struct mmc_queue_req *mqrq, int qdepth)
-{
-        mmc_queue_reqs_free_bufs(mqrq, qdepth);
-        kfree(mqrq);
-}
-
-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 int mmc_queue_alloc_bounce_bufs(struct mmc_queue_req *mqrq, int qdepth,
-                                       unsigned int bouncesz)
-{
-        int i;
-
-        for (i = 0; i < qdepth; i++) {
-                mqrq[i].bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
-                if (!mqrq[i].bounce_buf)
-                        return -ENOMEM;
-
-                mqrq[i].sg = mmc_alloc_sg(1);
-                if (!mqrq[i].sg)
-                        return -ENOMEM;
-
-                mqrq[i].bounce_sg = mmc_alloc_sg(bouncesz / 512);
-                if (!mqrq[i].bounce_sg)
-                        return -ENOMEM;
-        }
-
-        return 0;
-}
-
-static bool mmc_queue_alloc_bounce(struct mmc_queue_req *mqrq, int qdepth,
-                                   unsigned int bouncesz)
-{
-        int ret;
-
-        ret = mmc_queue_alloc_bounce_bufs(mqrq, qdepth, bouncesz);
-        if (ret)
-                mmc_queue_reqs_free_bufs(mqrq, qdepth);
-
-        return !ret;
-}
-
 static unsigned int mmc_queue_calc_bouncesz(struct mmc_host *host)
 {
         unsigned int bouncesz = MMC_QUEUE_BOUNCESZ;
 
-        if (host->max_segs != 1)
+        if (host->max_segs != 1 || (host->caps & MMC_CAP_NO_BOUNCE_BUFF))
                 return 0;
 
         if (bouncesz > host->max_req_size)
@@ -273,84 +169,58 @@ static unsigned int mmc_queue_calc_bouncesz(struct mmc_host *host)
 
         return bouncesz;
 }
-#else
-static inline bool mmc_queue_alloc_bounce(struct mmc_queue_req *mqrq,
-                                          int qdepth, unsigned int bouncesz)
-{
-        return false;
-}
 
-static unsigned int mmc_queue_calc_bouncesz(struct mmc_host *host)
-{
-        return 0;
-}
-#endif
-
-static int mmc_queue_alloc_sgs(struct mmc_queue_req *mqrq, int qdepth,
-                               int max_segs)
+/**
+ * mmc_init_request() - initialize the MMC-specific per-request data
+ * @q: the request queue
+ * @req: the request
+ * @gfp: memory allocation policy
+ */
+static int mmc_init_request(struct request_queue *q, struct request *req,
+                            gfp_t gfp)
 {
-        int i;
+        struct mmc_queue_req *mq_rq = req_to_mmc_queue_req(req);
+        struct mmc_queue *mq = q->queuedata;
+        struct mmc_card *card = mq->card;
+        struct mmc_host *host = card->host;
 
-        for (i = 0; i < qdepth; i++) {
-                mqrq[i].sg = mmc_alloc_sg(max_segs);
-                if (!mqrq[i].sg)
+        if (card->bouncesz) {
+                mq_rq->bounce_buf = kmalloc(card->bouncesz, gfp);
+                if (!mq_rq->bounce_buf)
+                        return -ENOMEM;
+                if (card->bouncesz > 512) {
+                        mq_rq->sg = mmc_alloc_sg(1, gfp);
+                        if (!mq_rq->sg)
+                                return -ENOMEM;
+                        mq_rq->bounce_sg = mmc_alloc_sg(card->bouncesz / 512,
+                                                        gfp);
+                        if (!mq_rq->bounce_sg)
+                                return -ENOMEM;
+                }
+        } else {
+                mq_rq->bounce_buf = NULL;
+                mq_rq->bounce_sg = NULL;
+                mq_rq->sg = mmc_alloc_sg(host->max_segs, gfp);
+                if (!mq_rq->sg)
                         return -ENOMEM;
         }
 
         return 0;
 }
 
-void mmc_queue_free_shared_queue(struct mmc_card *card)
+static void mmc_exit_request(struct request_queue *q, struct request *req)
 {
-        if (card->mqrq) {
-                mmc_queue_free_mqrqs(card->mqrq, card->qdepth);
-                card->mqrq = NULL;
-        }
-}
-
-static int __mmc_queue_alloc_shared_queue(struct mmc_card *card, int qdepth)
-{
-        struct mmc_host *host = card->host;
-        struct mmc_queue_req *mqrq;
-        unsigned int bouncesz;
-        int ret = 0;
-
-        if (card->mqrq)
-                return -EINVAL;
+        struct mmc_queue_req *mq_rq = req_to_mmc_queue_req(req);
 
-        mqrq = mmc_queue_alloc_mqrqs(qdepth);
-        if (!mqrq)
-                return -ENOMEM;
-
-        card->mqrq = mqrq;
-        card->qdepth = qdepth;
-
-        bouncesz = mmc_queue_calc_bouncesz(host);
-
-        if (bouncesz && !mmc_queue_alloc_bounce(mqrq, qdepth, bouncesz)) {
-                bouncesz = 0;
-                pr_warn("%s: unable to allocate bounce buffers\n",
-                        mmc_card_name(card));
-        }
+        /* It is OK to kfree(NULL) so this will be smooth */
+        kfree(mq_rq->bounce_sg);
+        mq_rq->bounce_sg = NULL;
 
-        card->bouncesz = bouncesz;
+        kfree(mq_rq->bounce_buf);
+        mq_rq->bounce_buf = NULL;
 
-        if (!bouncesz) {
-                ret = mmc_queue_alloc_sgs(mqrq, qdepth, host->max_segs);
-                if (ret)
-                        goto out_err;
-        }
-
-        return ret;
-
-out_err:
-        mmc_queue_free_shared_queue(card);
-        return ret;
-}
-
-int mmc_queue_alloc_shared_queue(struct mmc_card *card)
-{
-        return __mmc_queue_alloc_shared_queue(card, 2);
+        kfree(mq_rq->sg);
+        mq_rq->sg = NULL;
 }
 
 /**
@@ -373,13 +243,21 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
                 limit = (u64)dma_max_pfn(mmc_dev(host)) << PAGE_SHIFT;
 
         mq->card = card;
-        mq->queue = blk_init_queue(mmc_request_fn, lock);
+        mq->queue = blk_alloc_queue(GFP_KERNEL);
         if (!mq->queue)
                 return -ENOMEM;
-
-        mq->mqrq = card->mqrq;
-        mq->qdepth = card->qdepth;
+        mq->queue->queue_lock = lock;
+        mq->queue->request_fn = mmc_request_fn;
+        mq->queue->init_rq_fn = mmc_init_request;
+        mq->queue->exit_rq_fn = mmc_exit_request;
+        mq->queue->cmd_size = sizeof(struct mmc_queue_req);
         mq->queue->queuedata = mq;
+        mq->qcnt = 0;
+        ret = blk_init_allocated_queue(mq->queue);
+        if (ret) {
+                blk_cleanup_queue(mq->queue);
+                return ret;
+        }
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
@@ -387,6 +265,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
         if (mmc_can_erase(card))
                 mmc_queue_setup_discard(mq->queue, card);
 
+        card->bouncesz = mmc_queue_calc_bouncesz(host);
         if (card->bouncesz) {
                 blk_queue_max_hw_sectors(mq->queue, card->bouncesz / 512);
                 blk_queue_max_segments(mq->queue, card->bouncesz / 512);
@@ -412,7 +291,6 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
         return 0;
 
 cleanup_queue:
-        mq->mqrq = NULL;
         blk_cleanup_queue(mq->queue);
         return ret;
 }
@@ -434,7 +312,6 @@ void mmc_cleanup_queue(struct mmc_queue *mq)
         blk_start_queue(q);
         spin_unlock_irqrestore(q->queue_lock, flags);
 
-        mq->mqrq = NULL;
         mq->card = NULL;
 }
 EXPORT_SYMBOL(mmc_cleanup_queue);
@@ -491,12 +368,13 @@ 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;
+        struct request *req = mmc_queue_req_to_req(mqrq);
         int i;
 
         if (!mqrq->bounce_buf)
-                return blk_rq_map_sg(mq->queue, mqrq->req, mqrq->sg);
+                return blk_rq_map_sg(mq->queue, req, mqrq->sg);
 
-        sg_len = blk_rq_map_sg(mq->queue, mqrq->req, mqrq->bounce_sg);
+        sg_len = blk_rq_map_sg(mq->queue, req, mqrq->bounce_sg);
 
         mqrq->bounce_sg_len = sg_len;
 
@@ -518,7 +396,7 @@ void mmc_queue_bounce_pre(struct mmc_queue_req *mqrq)
         if (!mqrq->bounce_buf)
                 return;
 
-        if (rq_data_dir(mqrq->req) != WRITE)
+        if (rq_data_dir(mmc_queue_req_to_req(mqrq)) != WRITE)
                 return;
 
         sg_copy_to_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
@@ -534,7 +412,7 @@ void mmc_queue_bounce_post(struct mmc_queue_req *mqrq)
         if (!mqrq->bounce_buf)
                 return;
 
-        if (rq_data_dir(mqrq->req) != READ)
+        if (rq_data_dir(mmc_queue_req_to_req(mqrq)) != READ)
                 return;
 
         sg_copy_from_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,