Merge tag 'mmc-updates-for-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc

Pull MMC updates from Chris Ball:
 "MMC highlights for 3.15:

  Core:
   - CONFIG_MMC_UNSAFE_RESUME=y is now default behavior
   - DT bindings for SDHCI UHS, eMMC HS200, high-speed DDR, at 1.8/1.2V
   - Add GPIO descriptor based slot-gpio card detect API

  Drivers:
   - dw_mmc: Refactor SOCFPGA support as a variant inside dw_mmc-pltfm.c
   - mmci: Support HW busy detection on ux500
   - omap: Support MMC_ERASE
   - omap_hsmmc: Support MMC_PM_KEEP_POWER, MMC_PM_WAKE_SDIO_IRQ, (a)cmd23
   - rtsx: Support pre-req/post-req async
   - sdhci: Add support for Realtek RTS5250 controllers
   - sdhci-acpi: Add support for 80860F16, fix 80860F14/SDIO card detect
   - sdhci-msm: Add new driver for Qualcomm SDHCI chipset support
   - sdhci-pxav3: Add support for Marvell Armada 380 and 385 SoCs"

* tag 'mmc-updates-for-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc: (102 commits)
  mmc: sdhci-acpi: Intel SDIO has broken card detect
  mmc: sdhci-pxav3: add support for the Armada 38x SDHCI controller
  mmc: sdhci-msm: Add platform_execute_tuning implementation
  mmc: sdhci-msm: Initial support for Qualcomm chipsets
  mmc: sdhci-msm: Qualcomm SDHCI binding documentation
  sdhci: only reprogram retuning timer when flag is set
  mmc: rename ARCH_BCM to ARCH_BCM_MOBILE
  mmc: sdhci: Allow for irq being shared
  mmc: sdhci-acpi: Add device id 80860F16
  mmc: sdhci-acpi: Fix broken card detect for ACPI HID 80860F14
  mmc: slot-gpio: Add GPIO descriptor based CD GPIO API
  mmc: slot-gpio: Split out CD IRQ request into a separate function
  mmc: slot-gpio: Record GPIO descriptors instead of GPIO numbers
  Revert "dts: socfpga: Add support for SD/MMC on the SOCFPGA platform"
  mmc: sdhci-spear: use generic card detection gpio support
  mmc: sdhci-spear: remove support for power gpio
  mmc: sdhci-spear: simplify resource handling
  mmc: sdhci-spear: fix platform_data usage
  mmc: sdhci-spear: fix error handling paths for DT
  mmc: sdhci-bcm-kona: fix build errors when built-in
  ...

1 files changed, 115 insertions, 66 deletions

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 7b5424f398ac..452782bffebc 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -415,8 +415,7 @@ static int ioctl_do_sanitize(struct mmc_card *card)
 {
         int err;
 
-        if (!(mmc_can_sanitize(card) &&
-              (card->host->caps2 & MMC_CAP2_SANITIZE))) {
+        if (!mmc_can_sanitize(card)) {
                         pr_warn("%s: %s - SANITIZE is not supported\n",
                                 mmc_hostname(card->host), __func__);
                         err = -EOPNOTSUPP;
@@ -722,19 +721,6 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
         return result;
 }
 
-static int send_stop(struct mmc_card *card, u32 *status)
-{
-        struct mmc_command cmd = {0};
-        int err;
-
-        cmd.opcode = MMC_STOP_TRANSMISSION;
-        cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
-        err = mmc_wait_for_cmd(card->host, &cmd, 5);
-        if (err == 0)
-                *status = cmd.resp[0];
-        return err;
-}
-
 static int get_card_status(struct mmc_card *card, u32 *status, int retries)
 {
         struct mmc_command cmd = {0};
@@ -750,6 +736,99 @@ static int get_card_status(struct mmc_card *card, u32 *status, int retries)
         return err;
 }
 
+static int card_busy_detect(struct mmc_card *card, unsigned int timeout_ms,
+                bool hw_busy_detect, struct request *req, int *gen_err)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
+        int err = 0;
+        u32 status;
+
+        do {
+                err = get_card_status(card, &status, 5);
+                if (err) {
+                        pr_err("%s: error %d requesting status\n",
+                               req->rq_disk->disk_name, err);
+                        return err;
+                }
+
+                if (status & R1_ERROR) {
+                        pr_err("%s: %s: error sending status cmd, status %#x\n",
+                                req->rq_disk->disk_name, __func__, status);
+                        *gen_err = 1;
+                }
+
+                /* We may rely on the host hw to handle busy detection.*/
+                if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) &&
+                        hw_busy_detect)
+                        break;
+
+                /*
+                 * Timeout if the device never becomes ready for data and never
+                 * leaves the program state.
+                 */
+                if (time_after(jiffies, timeout)) {
+                        pr_err("%s: Card stuck in programming state! %s %s\n",
+                                mmc_hostname(card->host),
+                                req->rq_disk->disk_name, __func__);
+                        return -ETIMEDOUT;
+                }
+
+                /*
+                 * Some cards mishandle the status bits,
+                 * so make sure to check both the busy
+                 * indication and the card state.
+                 */
+        } while (!(status & R1_READY_FOR_DATA) ||
+                 (R1_CURRENT_STATE(status) == R1_STATE_PRG));
+
+        return err;
+}
+
+static int send_stop(struct mmc_card *card, unsigned int timeout_ms,
+                struct request *req, int *gen_err, u32 *stop_status)
+{
+        struct mmc_host *host = card->host;
+        struct mmc_command cmd = {0};
+        int err;
+        bool use_r1b_resp = rq_data_dir(req) == WRITE;
+
+        /*
+         * Normally we use R1B responses for WRITE, but in cases where the host
+         * has specified a max_busy_timeout we need to validate it. A failure
+         * means we need to prevent the host from doing hw busy detection, which
+         * is done by converting to a R1 response instead.
+         */
+        if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout))
+                use_r1b_resp = false;
+
+        cmd.opcode = MMC_STOP_TRANSMISSION;
+        if (use_r1b_resp) {
+                cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+                cmd.busy_timeout = timeout_ms;
+        } else {
+                cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
+        }
+
+        err = mmc_wait_for_cmd(host, &cmd, 5);
+        if (err)
+                return err;
+
+        *stop_status = cmd.resp[0];
+
+        /* No need to check card status in case of READ. */
+        if (rq_data_dir(req) == READ)
+                return 0;
+
+        if (!mmc_host_is_spi(host) &&
+                (*stop_status & R1_ERROR)) {
+                pr_err("%s: %s: general error sending stop command, resp %#x\n",
+                        req->rq_disk->disk_name, __func__, *stop_status);
+                *gen_err = 1;
+        }
+
+        return card_busy_detect(card, timeout_ms, use_r1b_resp, req, gen_err);
+}
+
 #define ERR_NOMEDIUM    3
 #define ERR_RETRY       2
 #define ERR_ABORT       1
@@ -866,26 +945,21 @@ static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
          */
         if (R1_CURRENT_STATE(status) == R1_STATE_DATA ||
             R1_CURRENT_STATE(status) == R1_STATE_RCV) {
-                err = send_stop(card, &stop_status);
-                if (err)
+                err = send_stop(card,
+                        DIV_ROUND_UP(brq->data.timeout_ns, 1000000),
+                        req, gen_err, &stop_status);
+                if (err) {
                         pr_err("%s: error %d sending stop command\n",
                                req->rq_disk->disk_name, err);
-
-                /*
-                 * If the stop cmd also timed out, the card is probably
-                 * not present, so abort.  Other errors are bad news too.
-                 */
-                if (err)
+                        /*
+                         * If the stop cmd also timed out, the card is probably
+                         * not present, so abort. Other errors are bad news too.
+                         */
                         return ERR_ABORT;
+                }
+
                 if (stop_status & R1_CARD_ECC_FAILED)
                         *ecc_err = 1;
-                if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ)
-                        if (stop_status & R1_ERROR) {
-                                pr_err("%s: %s: general error sending stop command, stop cmd response %#x\n",
-                                       req->rq_disk->disk_name, __func__,
-                                       stop_status);
-                                *gen_err = 1;
-                        }
         }
 
         /* Check for set block count errors */
@@ -1157,8 +1231,7 @@ static int mmc_blk_err_check(struct mmc_card *card,
          * program mode, which we have to wait for it to complete.
          */
         if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
-                u32 status;
-                unsigned long timeout;
+                int err;
 
                 /* Check stop command response */
                 if (brq->stop.resp[0] & R1_ERROR) {
@@ -1168,39 +1241,10 @@ static int mmc_blk_err_check(struct mmc_card *card,
                         gen_err = 1;
                 }
 
-                timeout = jiffies + msecs_to_jiffies(MMC_BLK_TIMEOUT_MS);
-                do {
-                        int err = get_card_status(card, &status, 5);
-                        if (err) {
-                                pr_err("%s: error %d requesting status\n",
-                                       req->rq_disk->disk_name, err);
-                                return MMC_BLK_CMD_ERR;
-                        }
-
-                        if (status & R1_ERROR) {
-                                pr_err("%s: %s: general error sending status command, card status %#x\n",
-                                       req->rq_disk->disk_name, __func__,
-                                       status);
-                                gen_err = 1;
-                        }
-
-                        /* Timeout if the device never becomes ready for data
-                         * and never leaves the program state.
-                         */
-                        if (time_after(jiffies, timeout)) {
-                                pr_err("%s: Card stuck in programming state!"\
-                                        " %s %s\n", mmc_hostname(card->host),
-                                        req->rq_disk->disk_name, __func__);
-
-                                return MMC_BLK_CMD_ERR;
-                        }
-                        /*
-                         * Some cards mishandle the status bits,
-                         * so make sure to check both the busy
-                         * indication and the card state.
-                         */
-                } while (!(status & R1_READY_FOR_DATA) ||
-                         (R1_CURRENT_STATE(status) == R1_STATE_PRG));
+                err = card_busy_detect(card, MMC_BLK_TIMEOUT_MS, false, req,
+                                        &gen_err);
+                if (err)
+                        return MMC_BLK_CMD_ERR;
         }
 
         /* if general error occurs, retry the write operation. */
@@ -1335,7 +1379,6 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
         brq->data.blksz = 512;
         brq->stop.opcode = MMC_STOP_TRANSMISSION;
         brq->stop.arg = 0;
-        brq->stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
         brq->data.blocks = blk_rq_sectors(req);
 
         /*
@@ -1378,9 +1421,15 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
         if (rq_data_dir(req) == READ) {
                 brq->cmd.opcode = readcmd;
                 brq->data.flags |= MMC_DATA_READ;
+                if (brq->mrq.stop)
+                        brq->stop.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 |
+                                        MMC_CMD_AC;
         } else {
                 brq->cmd.opcode = writecmd;
                 brq->data.flags |= MMC_DATA_WRITE;
+                if (brq->mrq.stop)
+                        brq->stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B |
+                                        MMC_CMD_AC;
         }
 
         if (do_rel_wr)