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

Pull MMC updates from Ulf Hansson:
 "MMC core:
   - Introduce host claiming by context to support blkmq
   - Preparations for enabling CQE (eMMC CMDQ) requests
   - Re-factorizations to prepare for blkmq support
   - Re-factorizations to prepare for CQE support
   - Fix signal voltage switch for SD cards without power cycle
   - Convert RPMB to a character device
   - Export eMMC revision via sysfs
   - Support eMMC DT binding for fixed driver type
   - Document mmc_regulator_get_supply() API

 MMC host:
   - omap_hsmmc: Updated regulator management for PBIAS
   - sdhci-omap: Add new OMAP SDHCI driver
   - meson-mx-sdio: New driver for the Amlogic Meson8 and Meson8b SoCs
   - sdhci-pci: Add support for Intel CDF
   - sdhci-acpi: Fix voltage switch for some Intel host controllers
   - sdhci-msm: Enable delay circuit calibration clocks
   - sdhci-msm: Manage power IRQ properly
   - mediatek: Add support of mt2701/mt2712
   - mediatek: Updates management of clocks and tunings
   - mediatek: Upgrade eMMC HS400 support
   - rtsx_pci: Update tuning for gen3 PCI-Express
   - renesas_sdhi: Support R-Car Gen[123] fallback compatibility strings
   - Catch all errors when getting regulators
   - Various additional improvements and cleanups"

* tag 'mmc-v4.15' of git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc: (91 commits)
  sdhci-fujitsu: add support for setting the CMD_DAT_DELAY attribute
  dt-bindings: sdhci-fujitsu: document cmd-dat-delay property
  mmc: tmio: Replace msleep() of 20ms or less with usleep_range()
  mmc: dw_mmc: Convert timers to use timer_setup()
  mmc: dw_mmc: Cleanup the DTO timer like the CTO one
  mmc: vub300: Use common code in __download_offload_pseudocode()
  mmc: tmio: Use common error handling code in tmio_mmc_host_probe()
  mmc: Convert timers to use timer_setup()
  mmc: sdhci-acpi: Fix voltage switch for some Intel host controllers
  mmc: sdhci-acpi: Let devices define their own private data
  mmc: mediatek: perfer to use rise edge latching for cmd line
  mmc: mediatek: improve eMMC hs400 mode read performance
  mmc: mediatek: add latch-ck support
  mmc: mediatek: add support of source_cg clock
  mmc: mediatek: add stop_clk fix and enhance_rx support
  mmc: mediatek: add busy_check support
  mmc: mediatek: add async fifo and data tune support
  mmc: mediatek: add pad_tune0 support
  mmc: mediatek: make hs400_tune_response only for mt8173
  arm64: dts: mt8173: remove "mediatek, mt8135-mmc" from mmc nodes
  ...

1 files changed, 235 insertions, 27 deletions

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 66c9cf49ad2f..1f0f44f4dd5f 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -266,7 +266,8 @@ static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
         host->ops->request(host, mrq);
 }
 
-static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq)
+static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq,
+                             bool cqe)
 {
         if (mrq->sbc) {
                 pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n",
@@ -275,9 +276,12 @@ static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq)
         }
 
         if (mrq->cmd) {
-                pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
-                         mmc_hostname(host), mrq->cmd->opcode, mrq->cmd->arg,
-                         mrq->cmd->flags);
+                pr_debug("%s: starting %sCMD%u arg %08x flags %08x\n",
+                         mmc_hostname(host), cqe ? "CQE direct " : "",
+                         mrq->cmd->opcode, mrq->cmd->arg, mrq->cmd->flags);
+        } else if (cqe) {
+                pr_debug("%s: starting CQE transfer for tag %d blkaddr %u\n",
+                         mmc_hostname(host), mrq->tag, mrq->data->blk_addr);
         }
 
         if (mrq->data) {
@@ -333,7 +337,7 @@ static int mmc_mrq_prep(struct mmc_host *host, struct mmc_request *mrq)
         return 0;
 }
 
-static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
+int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 {
         int err;
 
@@ -342,7 +346,7 @@ static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
         if (mmc_card_removed(host->card))
                 return -ENOMEDIUM;
 
-        mmc_mrq_pr_debug(host, mrq);
+        mmc_mrq_pr_debug(host, mrq, false);
 
         WARN_ON(!host->claimed);
 
@@ -355,6 +359,7 @@ static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 
         return 0;
 }
+EXPORT_SYMBOL(mmc_start_request);
 
 /*
  * mmc_wait_data_done() - done callback for data request
@@ -482,6 +487,155 @@ void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq)
 }
 EXPORT_SYMBOL(mmc_wait_for_req_done);
 
+/*
+ * mmc_cqe_start_req - Start a CQE request.
+ * @host: MMC host to start the request
+ * @mrq: request to start
+ *
+ * Start the request, re-tuning if needed and it is possible. Returns an error
+ * code if the request fails to start or -EBUSY if CQE is busy.
+ */
+int mmc_cqe_start_req(struct mmc_host *host, struct mmc_request *mrq)
+{
+        int err;
+
+        /*
+         * CQE cannot process re-tuning commands. Caller must hold retuning
+         * while CQE is in use.  Re-tuning can happen here only when CQE has no
+         * active requests i.e. this is the first.  Note, re-tuning will call
+         * ->cqe_off().
+         */
+        err = mmc_retune(host);
+        if (err)
+                goto out_err;
+
+        mrq->host = host;
+
+        mmc_mrq_pr_debug(host, mrq, true);
+
+        err = mmc_mrq_prep(host, mrq);
+        if (err)
+                goto out_err;
+
+        err = host->cqe_ops->cqe_request(host, mrq);
+        if (err)
+                goto out_err;
+
+        trace_mmc_request_start(host, mrq);
+
+        return 0;
+
+out_err:
+        if (mrq->cmd) {
+                pr_debug("%s: failed to start CQE direct CMD%u, error %d\n",
+                         mmc_hostname(host), mrq->cmd->opcode, err);
+        } else {
+                pr_debug("%s: failed to start CQE transfer for tag %d, error %d\n",
+                         mmc_hostname(host), mrq->tag, err);
+        }
+        return err;
+}
+EXPORT_SYMBOL(mmc_cqe_start_req);
+
+/**
+ *      mmc_cqe_request_done - CQE has finished processing an MMC request
+ *      @host: MMC host which completed request
+ *      @mrq: MMC request which completed
+ *
+ *      CQE drivers should call this function when they have completed
+ *      their processing of a request.
+ */
+void mmc_cqe_request_done(struct mmc_host *host, struct mmc_request *mrq)
+{
+        mmc_should_fail_request(host, mrq);
+
+        /* Flag re-tuning needed on CRC errors */
+        if ((mrq->cmd && mrq->cmd->error == -EILSEQ) ||
+            (mrq->data && mrq->data->error == -EILSEQ))
+                mmc_retune_needed(host);
+
+        trace_mmc_request_done(host, mrq);
+
+        if (mrq->cmd) {
+                pr_debug("%s: CQE req done (direct CMD%u): %d\n",
+                         mmc_hostname(host), mrq->cmd->opcode, mrq->cmd->error);
+        } else {
+                pr_debug("%s: CQE transfer done tag %d\n",
+                         mmc_hostname(host), mrq->tag);
+        }
+
+        if (mrq->data) {
+                pr_debug("%s:     %d bytes transferred: %d\n",
+                         mmc_hostname(host),
+                         mrq->data->bytes_xfered, mrq->data->error);
+        }
+
+        mrq->done(mrq);
+}
+EXPORT_SYMBOL(mmc_cqe_request_done);
+
+/**
+ *      mmc_cqe_post_req - CQE post process of a completed MMC request
+ *      @host: MMC host
+ *      @mrq: MMC request to be processed
+ */
+void mmc_cqe_post_req(struct mmc_host *host, struct mmc_request *mrq)
+{
+        if (host->cqe_ops->cqe_post_req)
+                host->cqe_ops->cqe_post_req(host, mrq);
+}
+EXPORT_SYMBOL(mmc_cqe_post_req);
+
+/* Arbitrary 1 second timeout */
+#define MMC_CQE_RECOVERY_TIMEOUT        1000
+
+/*
+ * mmc_cqe_recovery - Recover from CQE errors.
+ * @host: MMC host to recover
+ *
+ * Recovery consists of stopping CQE, stopping eMMC, discarding the queue in
+ * in eMMC, and discarding the queue in CQE. CQE must call
+ * mmc_cqe_request_done() on all requests. An error is returned if the eMMC
+ * fails to discard its queue.
+ */
+int mmc_cqe_recovery(struct mmc_host *host)
+{
+        struct mmc_command cmd;
+        int err;
+
+        mmc_retune_hold_now(host);
+
+        /*
+         * Recovery is expected seldom, if at all, but it reduces performance,
+         * so make sure it is not completely silent.
+         */
+        pr_warn("%s: running CQE recovery\n", mmc_hostname(host));
+
+        host->cqe_ops->cqe_recovery_start(host);
+
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.opcode       = MMC_STOP_TRANSMISSION,
+        cmd.flags        = MMC_RSP_R1B | MMC_CMD_AC,
+        cmd.flags       &= ~MMC_RSP_CRC; /* Ignore CRC */
+        cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT,
+        mmc_wait_for_cmd(host, &cmd, 0);
+
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.opcode       = MMC_CMDQ_TASK_MGMT;
+        cmd.arg          = 1; /* Discard entire queue */
+        cmd.flags        = MMC_RSP_R1B | MMC_CMD_AC;
+        cmd.flags       &= ~MMC_RSP_CRC; /* Ignore CRC */
+        cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT,
+        err = mmc_wait_for_cmd(host, &cmd, 0);
+
+        host->cqe_ops->cqe_recovery_finish(host);
+
+        mmc_retune_release(host);
+
+        return err;
+}
+EXPORT_SYMBOL(mmc_cqe_recovery);
+
 /**
  *      mmc_is_req_done - Determine if a 'cap_cmd_during_tfr' request is done
  *      @host: MMC host
@@ -832,9 +986,36 @@ unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz)
 }
 EXPORT_SYMBOL(mmc_align_data_size);
 
+/*
+ * Allow claiming an already claimed host if the context is the same or there is
+ * no context but the task is the same.
+ */
+static inline bool mmc_ctx_matches(struct mmc_host *host, struct mmc_ctx *ctx,
+                                   struct task_struct *task)
+{
+        return host->claimer == ctx ||
+               (!ctx && task && host->claimer->task == task);
+}
+
+static inline void mmc_ctx_set_claimer(struct mmc_host *host,
+                                       struct mmc_ctx *ctx,
+                                       struct task_struct *task)
+{
+        if (!host->claimer) {
+                if (ctx)
+                        host->claimer = ctx;
+                else
+                        host->claimer = &host->default_ctx;
+        }
+        if (task)
+                host->claimer->task = task;
+}
+
 /**
  *      __mmc_claim_host - exclusively claim a host
  *      @host: mmc host to claim
+ *      @ctx: context that claims the host or NULL in which case the default
+ *      context will be used
  *      @abort: whether or not the operation should be aborted
  *
  *      Claim a host for a set of operations.  If @abort is non null and
@@ -842,8 +1023,10 @@ EXPORT_SYMBOL(mmc_align_data_size);
  *      that non-zero value without acquiring the lock.  Returns zero
  *      with the lock held otherwise.
  */
-int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
+int __mmc_claim_host(struct mmc_host *host, struct mmc_ctx *ctx,
+                     atomic_t *abort)
 {
+        struct task_struct *task = ctx ? NULL : current;
         DECLARE_WAITQUEUE(wait, current);
         unsigned long flags;
         int stop;
@@ -856,7 +1039,7 @@ int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
         while (1) {
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 stop = abort ? atomic_read(abort) : 0;
-                if (stop || !host->claimed || host->claimer == current)
+                if (stop || !host->claimed || mmc_ctx_matches(host, ctx, task))
                         break;
                 spin_unlock_irqrestore(&host->lock, flags);
                 schedule();
@@ -865,7 +1048,7 @@ int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
         set_current_state(TASK_RUNNING);
         if (!stop) {
                 host->claimed = 1;
-                host->claimer = current;
+                mmc_ctx_set_claimer(host, ctx, task);
                 host->claim_cnt += 1;
                 if (host->claim_cnt == 1)
                         pm = true;
@@ -900,6 +1083,7 @@ void mmc_release_host(struct mmc_host *host)
                 spin_unlock_irqrestore(&host->lock, flags);
         } else {
                 host->claimed = 0;
+                host->claimer->task = NULL;
                 host->claimer = NULL;
                 spin_unlock_irqrestore(&host->lock, flags);
                 wake_up(&host->wq);
@@ -913,10 +1097,10 @@ EXPORT_SYMBOL(mmc_release_host);
  * This is a helper function, which fetches a runtime pm reference for the
  * card device and also claims the host.
  */
-void mmc_get_card(struct mmc_card *card)
+void mmc_get_card(struct mmc_card *card, struct mmc_ctx *ctx)
 {
         pm_runtime_get_sync(&card->dev);
-        mmc_claim_host(card->host);
+        __mmc_claim_host(card->host, ctx, NULL);
 }
 EXPORT_SYMBOL(mmc_get_card);
 
@@ -924,9 +1108,13 @@ EXPORT_SYMBOL(mmc_get_card);
  * This is a helper function, which releases the host and drops the runtime
  * pm reference for the card device.
  */
-void mmc_put_card(struct mmc_card *card)
+void mmc_put_card(struct mmc_card *card, struct mmc_ctx *ctx)
 {
-        mmc_release_host(card->host);
+        struct mmc_host *host = card->host;
+
+        WARN_ON(ctx && host->claimer != ctx);
+
+        mmc_release_host(host);
         pm_runtime_mark_last_busy(&card->dev);
         pm_runtime_put_autosuspend(&card->dev);
 }
@@ -1400,6 +1588,16 @@ EXPORT_SYMBOL_GPL(mmc_regulator_set_vqmmc);
 
 #endif /* CONFIG_REGULATOR */
 
+/**
+ * mmc_regulator_get_supply - try to get VMMC and VQMMC regulators for a host
+ * @mmc: the host to regulate
+ *
+ * Returns 0 or errno. errno should be handled, it is either a critical error
+ * or -EPROBE_DEFER. 0 means no critical error but it does not mean all
+ * regulators have been found because they all are optional. If you require
+ * certain regulators, you need to check separately in your driver if they got
+ * populated after calling this function.
+ */
 int mmc_regulator_get_supply(struct mmc_host *mmc)
 {
         struct device *dev = mmc_dev(mmc);
@@ -1484,11 +1682,33 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
 
 }
 
+int mmc_host_set_uhs_voltage(struct mmc_host *host)
+{
+        u32 clock;
+
+        /*
+         * During a signal voltage level switch, the clock must be gated
+         * for 5 ms according to the SD spec
+         */
+        clock = host->ios.clock;
+        host->ios.clock = 0;
+        mmc_set_ios(host);
+
+        if (mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180))
+                return -EAGAIN;
+
+        /* Keep clock gated for at least 10 ms, though spec only says 5 ms */
+        mmc_delay(10);
+        host->ios.clock = clock;
+        mmc_set_ios(host);
+
+        return 0;
+}
+
 int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr)
 {
         struct mmc_command cmd = {};
         int err = 0;
-        u32 clock;
 
         /*
          * If we cannot switch voltages, return failure so the caller
@@ -1520,15 +1740,8 @@ int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr)
                 err = -EAGAIN;
                 goto power_cycle;
         }
-        /*
-         * During a signal voltage level switch, the clock must be gated
-         * for 5 ms according to the SD spec
-         */
-        clock = host->ios.clock;
-        host->ios.clock = 0;
-        mmc_set_ios(host);
 
-        if (mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180)) {
+        if (mmc_host_set_uhs_voltage(host)) {
                 /*
                  * Voltages may not have been switched, but we've already
                  * sent CMD11, so a power cycle is required anyway
@@ -1537,11 +1750,6 @@ int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr)
                 goto power_cycle;
         }
 
-        /* Keep clock gated for at least 10 ms, though spec only says 5 ms */
-        mmc_delay(10);
-        host->ios.clock = clock;
-        mmc_set_ios(host);
-
         /* Wait for at least 1 ms according to spec */
         mmc_delay(1);