Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc: (83 commits)
  mmc: fix compile error when CONFIG_BLOCK is not enabled
  mmc: core: Cleanup eMMC4.5 conditionals
  mmc: omap_hsmmc: if multiblock reads are broken, disable them
  mmc: core: add workaround for controllers with broken multiblock reads
  mmc: core: Prevent too long response times for suspend
  mmc: recognise SDIO cards with SDIO_CCCR_REV 3.00
  mmc: sd: Handle SD3.0 cards not supporting UHS-I bus speed mode
  mmc: core: support HPI send command
  mmc: core: Add cache control for eMMC4.5 device
  mmc: core: Modify the timeout value for writing power class
  mmc: core: new discard feature support at eMMC v4.5
  mmc: core: mmc sanitize feature support for v4.5
  mmc: dw_mmc: modify DATA register offset
  mmc: sdhci-pci: add flag for devices that can support runtime PM
  mmc: omap_hsmmc: ensure pbias configuration is always done
  mmc: core: Add Power Off Notify Feature eMMC 4.5
  mmc: sdhci-s3c: fix potential NULL dereference
  mmc: replace printk with appropriate display macro
  mmc: core: Add default timeout value for CMD6
  mmc: sdhci-pci: add runtime pm support
  ...

4 files changed, 269 insertions, 124 deletions

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 4c1a648d00fc..a1cb21f95302 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -94,6 +94,11 @@ struct mmc_blk_data {
         unsigned int    read_only;
         unsigned int    part_type;
         unsigned int    name_idx;
+        unsigned int    reset_done;
+#define MMC_BLK_READ            BIT(0)
+#define MMC_BLK_WRITE           BIT(1)
+#define MMC_BLK_DISCARD         BIT(2)
+#define MMC_BLK_SECDISCARD      BIT(3)
 
         /*
          * Only set in main mmc_blk_data associated
@@ -109,11 +114,11 @@ static DEFINE_MUTEX(open_lock);
 enum mmc_blk_status {
         MMC_BLK_SUCCESS = 0,
         MMC_BLK_PARTIAL,
-        MMC_BLK_RETRY,
-        MMC_BLK_RETRY_SINGLE,
-        MMC_BLK_DATA_ERR,
         MMC_BLK_CMD_ERR,
+        MMC_BLK_RETRY,
         MMC_BLK_ABORT,
+        MMC_BLK_DATA_ERR,
+        MMC_BLK_ECC_ERR,
 };
 
 module_param(perdev_minors, int, 0444);
@@ -291,7 +296,7 @@ static int mmc_blk_ioctl_cmd(struct block_device *bdev,
         struct mmc_card *card;
         struct mmc_command cmd = {0};
         struct mmc_data data = {0};
-        struct mmc_request mrq = {0};
+        struct mmc_request mrq = {NULL};
         struct scatterlist sg;
         int err;
 
@@ -442,19 +447,24 @@ static inline int mmc_blk_part_switch(struct mmc_card *card,
 {
         int ret;
         struct mmc_blk_data *main_md = mmc_get_drvdata(card);
+
         if (main_md->part_curr == md->part_type)
                 return 0;
 
         if (mmc_card_mmc(card)) {
-                card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
-                card->ext_csd.part_config |= md->part_type;
+                u8 part_config = card->ext_csd.part_config;
+
+                part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
+                part_config |= md->part_type;
 
                 ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                 EXT_CSD_PART_CONFIG, card->ext_csd.part_config,
+                                 EXT_CSD_PART_CONFIG, part_config,
                                  card->ext_csd.part_time);
                 if (ret)
                         return ret;
-}
+
+                card->ext_csd.part_config = part_config;
+        }
 
         main_md->part_curr = md->part_type;
         return 0;
@@ -466,7 +476,7 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
         u32 result;
         __be32 *blocks;
 
-        struct mmc_request mrq = {0};
+        struct mmc_request mrq = {NULL};
         struct mmc_command cmd = {0};
         struct mmc_data data = {0};
         unsigned int timeout_us;
@@ -616,7 +626,7 @@ static int mmc_blk_cmd_error(struct request *req, const char *name, int error,
  * Otherwise we don't understand what happened, so abort.
  */
 static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
-        struct mmc_blk_request *brq)
+        struct mmc_blk_request *brq, int *ecc_err)
 {
         bool prev_cmd_status_valid = true;
         u32 status, stop_status = 0;
@@ -641,6 +651,12 @@ static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
         if (err)
                 return ERR_ABORT;
 
+        /* Flag ECC errors */
+        if ((status & R1_CARD_ECC_FAILED) ||
+            (brq->stop.resp[0] & R1_CARD_ECC_FAILED) ||
+            (brq->cmd.resp[0] & R1_CARD_ECC_FAILED))
+                *ecc_err = 1;
+
         /*
          * Check the current card state.  If it is in some data transfer
          * mode, tell it to stop (and hopefully transition back to TRAN.)
@@ -658,6 +674,8 @@ static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
                  */
                 if (err)
                         return ERR_ABORT;
+                if (stop_status & R1_CARD_ECC_FAILED)
+                        *ecc_err = 1;
         }
 
         /* Check for set block count errors */
@@ -670,6 +688,10 @@ static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
                 return mmc_blk_cmd_error(req, "r/w cmd", brq->cmd.error,
                                 prev_cmd_status_valid, status);
 
+        /* Data errors */
+        if (!brq->stop.error)
+                return ERR_CONTINUE;
+
         /* Now for stop errors.  These aren't fatal to the transfer. */
         pr_err("%s: error %d sending stop command, original cmd response %#x, card status %#x\n",
                req->rq_disk->disk_name, brq->stop.error,
@@ -686,12 +708,45 @@ static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
         return ERR_CONTINUE;
 }
 
+static int mmc_blk_reset(struct mmc_blk_data *md, struct mmc_host *host,
+                         int type)
+{
+        int err;
+
+        if (md->reset_done & type)
+                return -EEXIST;
+
+        md->reset_done |= type;
+        err = mmc_hw_reset(host);
+        /* Ensure we switch back to the correct partition */
+        if (err != -EOPNOTSUPP) {
+                struct mmc_blk_data *main_md = mmc_get_drvdata(host->card);
+                int part_err;
+
+                main_md->part_curr = main_md->part_type;
+                part_err = mmc_blk_part_switch(host->card, md);
+                if (part_err) {
+                        /*
+                         * We have failed to get back into the correct
+                         * partition, so we need to abort the whole request.
+                         */
+                        return -ENODEV;
+                }
+        }
+        return err;
+}
+
+static inline void mmc_blk_reset_success(struct mmc_blk_data *md, int type)
+{
+        md->reset_done &= ~type;
+}
+
 static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
 {
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
         unsigned int from, nr, arg;
-        int err = 0;
+        int err = 0, type = MMC_BLK_DISCARD;
 
         if (!mmc_can_erase(card)) {
                 err = -EOPNOTSUPP;
@@ -701,11 +756,13 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
         from = blk_rq_pos(req);
         nr = blk_rq_sectors(req);
 
-        if (mmc_can_trim(card))
+        if (mmc_can_discard(card))
+                arg = MMC_DISCARD_ARG;
+        else if (mmc_can_trim(card))
                 arg = MMC_TRIM_ARG;
         else
                 arg = MMC_ERASE_ARG;
-
+retry:
         if (card->quirks & MMC_QUIRK_INAND_CMD38) {
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                  INAND_CMD38_ARG_EXT_CSD,
@@ -718,6 +775,10 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
         }
         err = mmc_erase(card, from, nr, arg);
 out:
+        if (err == -EIO && !mmc_blk_reset(md, card->host, type))
+                goto retry;
+        if (!err)
+                mmc_blk_reset_success(md, type);
         spin_lock_irq(&md->lock);
         __blk_end_request(req, err, blk_rq_bytes(req));
         spin_unlock_irq(&md->lock);
@@ -731,13 +792,20 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
         unsigned int from, nr, arg;
-        int err = 0;
+        int err = 0, type = MMC_BLK_SECDISCARD;
 
-        if (!mmc_can_secure_erase_trim(card)) {
+        if (!(mmc_can_secure_erase_trim(card) || mmc_can_sanitize(card))) {
                 err = -EOPNOTSUPP;
                 goto out;
         }
 
+        /* The sanitize operation is supported at v4.5 only */
+        if (mmc_can_sanitize(card)) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                EXT_CSD_SANITIZE_START, 1, 0);
+                goto out;
+        }
+
         from = blk_rq_pos(req);
         nr = blk_rq_sectors(req);
 
@@ -745,7 +813,7 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
                 arg = MMC_SECURE_TRIM1_ARG;
         else
                 arg = MMC_SECURE_ERASE_ARG;
-
+retry:
         if (card->quirks & MMC_QUIRK_INAND_CMD38) {
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                  INAND_CMD38_ARG_EXT_CSD,
@@ -769,6 +837,10 @@ static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
                 err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG);
         }
 out:
+        if (err == -EIO && !mmc_blk_reset(md, card->host, type))
+                goto retry;
+        if (!err)
+                mmc_blk_reset_success(md, type);
         spin_lock_irq(&md->lock);
         __blk_end_request(req, err, blk_rq_bytes(req));
         spin_unlock_irq(&md->lock);
@@ -779,16 +851,18 @@ out:
 static int mmc_blk_issue_flush(struct mmc_queue *mq, struct request *req)
 {
         struct mmc_blk_data *md = mq->data;
+        struct mmc_card *card = md->queue.card;
+        int ret = 0;
+
+        ret = mmc_flush_cache(card);
+        if (ret)
+                ret = -EIO;
 
-        /*
-         * No-op, only service this because we need REQ_FUA for reliable
-         * writes.
-         */
         spin_lock_irq(&md->lock);
-        __blk_end_request_all(req, 0);
+        __blk_end_request_all(req, ret);
         spin_unlock_irq(&md->lock);
 
-        return 1;
+        return ret ? 0 : 1;
 }
 
 /*
@@ -825,11 +899,11 @@ static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq,
 static int mmc_blk_err_check(struct mmc_card *card,
                              struct mmc_async_req *areq)
 {
-        enum mmc_blk_status ret = MMC_BLK_SUCCESS;
         struct mmc_queue_req *mq_mrq = container_of(areq, struct mmc_queue_req,
                                                     mmc_active);
         struct mmc_blk_request *brq = &mq_mrq->brq;
         struct request *req = mq_mrq->req;
+        int ecc_err = 0;
 
         /*
          * sbc.error indicates a problem with the set block count
@@ -841,8 +915,9 @@ static int mmc_blk_err_check(struct mmc_card *card,
          * stop.error indicates a problem with the stop command.  Data
          * may have been transferred, or may still be transferring.
          */
-        if (brq->sbc.error || brq->cmd.error || brq->stop.error) {
-                switch (mmc_blk_cmd_recovery(card, req, brq)) {
+        if (brq->sbc.error || brq->cmd.error || brq->stop.error ||
+            brq->data.error) {
+                switch (mmc_blk_cmd_recovery(card, req, brq, &ecc_err)) {
                 case ERR_RETRY:
                         return MMC_BLK_RETRY;
                 case ERR_ABORT:
@@ -873,7 +948,7 @@ static int mmc_blk_err_check(struct mmc_card *card,
                 do {
                         int err = get_card_status(card, &status, 5);
                         if (err) {
-                                printk(KERN_ERR "%s: error %d requesting status\n",
+                                pr_err("%s: error %d requesting status\n",
                                        req->rq_disk->disk_name, err);
                                 return MMC_BLK_CMD_ERR;
                         }
@@ -894,23 +969,21 @@ static int mmc_blk_err_check(struct mmc_card *card,
                        brq->cmd.resp[0], brq->stop.resp[0]);
 
                 if (rq_data_dir(req) == READ) {
-                        if (brq->data.blocks > 1) {
-                                /* Redo read one sector at a time */
-                                pr_warning("%s: retrying using single block read\n",
-                                           req->rq_disk->disk_name);
-                                return MMC_BLK_RETRY_SINGLE;
-                        }
+                        if (ecc_err)
+                                return MMC_BLK_ECC_ERR;
                         return MMC_BLK_DATA_ERR;
                 } else {
                         return MMC_BLK_CMD_ERR;
                 }
         }
 
-        if (ret == MMC_BLK_SUCCESS &&
-            blk_rq_bytes(req) != brq->data.bytes_xfered)
-                ret = MMC_BLK_PARTIAL;
+        if (!brq->data.bytes_xfered)
+                return MMC_BLK_RETRY;
 
-        return ret;
+        if (blk_rq_bytes(req) != brq->data.bytes_xfered)
+                return MMC_BLK_PARTIAL;
+
+        return MMC_BLK_SUCCESS;
 }
 
 static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
@@ -957,13 +1030,20 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
         if (brq->data.blocks > card->host->max_blk_count)
                 brq->data.blocks = card->host->max_blk_count;
 
-        /*
-         * After a read error, we redo the request one sector at a time
-         * in order to accurately determine which sectors can be read
-         * successfully.
-         */
-        if (disable_multi && brq->data.blocks > 1)
-                brq->data.blocks = 1;
+        if (brq->data.blocks > 1) {
+                /*
+                 * After a read error, we redo the request one sector
+                 * at a time in order to accurately determine which
+                 * sectors can be read successfully.
+                 */
+                if (disable_multi)
+                        brq->data.blocks = 1;
+
+                /* Some controllers can't do multiblock reads due to hw bugs */
+                if (card->host->caps2 & MMC_CAP2_NO_MULTI_READ &&
+                    rq_data_dir(req) == READ)
+                        brq->data.blocks = 1;
+        }
 
         if (brq->data.blocks > 1 || do_rel_wr) {
                 /* SPI multiblock writes terminate using a special
@@ -1049,12 +1129,41 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
         mmc_queue_bounce_pre(mqrq);
 }
 
+static int mmc_blk_cmd_err(struct mmc_blk_data *md, struct mmc_card *card,
+                           struct mmc_blk_request *brq, struct request *req,
+                           int ret)
+{
+        /*
+         * If this is an SD card and we're writing, we can first
+         * mark the known good sectors as ok.
+         *
+         * If the card is not SD, we can still ok written sectors
+         * as reported by the controller (which might be less than
+         * the real number of written sectors, but never more).
+         */
+        if (mmc_card_sd(card)) {
+                u32 blocks;
+
+                blocks = mmc_sd_num_wr_blocks(card);
+                if (blocks != (u32)-1) {
+                        spin_lock_irq(&md->lock);
+                        ret = __blk_end_request(req, 0, blocks << 9);
+                        spin_unlock_irq(&md->lock);
+                }
+        } else {
+                spin_lock_irq(&md->lock);
+                ret = __blk_end_request(req, 0, brq->data.bytes_xfered);
+                spin_unlock_irq(&md->lock);
+        }
+        return ret;
+}
+
 static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
 {
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
         struct mmc_blk_request *brq = &mq->mqrq_cur->brq;
-        int ret = 1, disable_multi = 0, retry = 0;
+        int ret = 1, disable_multi = 0, retry = 0, type;
         enum mmc_blk_status status;
         struct mmc_queue_req *mq_rq;
         struct request *req;
@@ -1076,6 +1185,7 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                 mq_rq = container_of(areq, struct mmc_queue_req, mmc_active);
                 brq = &mq_rq->brq;
                 req = mq_rq->req;
+                type = rq_data_dir(req) == READ ? MMC_BLK_READ : MMC_BLK_WRITE;
                 mmc_queue_bounce_post(mq_rq);
 
                 switch (status) {
@@ -1084,18 +1194,18 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                         /*
                          * A block was successfully transferred.
                          */
+                        mmc_blk_reset_success(md, type);
                         spin_lock_irq(&md->lock);
                         ret = __blk_end_request(req, 0,
                                                 brq->data.bytes_xfered);
                         spin_unlock_irq(&md->lock);
+                        /*
+                         * If the blk_end_request function returns non-zero even
+                         * though all data has been transferred and no errors
+                         * were returned by the host controller, it's a bug.
+                         */
                         if (status == MMC_BLK_SUCCESS && ret) {
-                                /*
-                                 * The blk_end_request has returned non zero
-                                 * even though all data is transfered and no
-                                 * erros returned by host.
-                                 * If this happen it's a bug.
-                                 */
-                                printk(KERN_ERR "%s BUG rq_tot %d d_xfer %d\n",
+                                pr_err("%s BUG rq_tot %d d_xfer %d\n",
                                        __func__, blk_rq_bytes(req),
                                        brq->data.bytes_xfered);
                                 rqc = NULL;
@@ -1103,16 +1213,36 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                         }
                         break;
                 case MMC_BLK_CMD_ERR:
-                        goto cmd_err;
-                case MMC_BLK_RETRY_SINGLE:
-                        disable_multi = 1;
-                        break;
+                        ret = mmc_blk_cmd_err(md, card, brq, req, ret);
+                        if (!mmc_blk_reset(md, card->host, type))
+                                break;
+                        goto cmd_abort;
                 case MMC_BLK_RETRY:
                         if (retry++ < 5)
                                 break;
+                        /* Fall through */
                 case MMC_BLK_ABORT:
+                        if (!mmc_blk_reset(md, card->host, type))
+                                break;
                         goto cmd_abort;
-                case MMC_BLK_DATA_ERR:
+                case MMC_BLK_DATA_ERR: {
+                        int err;
+
+                        err = mmc_blk_reset(md, card->host, type);
+                        if (!err)
+                                break;
+                        if (err == -ENODEV)
+                                goto cmd_abort;
+                        /* Fall through */
+                }
+                case MMC_BLK_ECC_ERR:
+                        if (brq->data.blocks > 1) {
+                                /* Redo read one sector at a time */
+                                pr_warning("%s: retrying using single block read\n",
+                                           req->rq_disk->disk_name);
+                                disable_multi = 1;
+                                break;
+                        }
                         /*
                          * After an error, we redo I/O one sector at a
                          * time, so we only reach here after trying to
@@ -1129,7 +1259,7 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
 
                 if (ret) {
                         /*
-                         * In case of a none complete request
+                         * In case of a incomplete request
                          * prepare it again and resend.
                          */
                         mmc_blk_rw_rq_prep(mq_rq, card, disable_multi, mq);
@@ -1139,30 +1269,6 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
 
         return 1;
 
- cmd_err:
-        /*
-         * If this is an SD card and we're writing, we can first
-         * mark the known good sectors as ok.
-         *
-         * If the card is not SD, we can still ok written sectors
-         * as reported by the controller (which might be less than
-         * the real number of written sectors, but never more).
-         */
-        if (mmc_card_sd(card)) {
-                u32 blocks;
-
-                blocks = mmc_sd_num_wr_blocks(card);
-                if (blocks != (u32)-1) {
-                        spin_lock_irq(&md->lock);
-                        ret = __blk_end_request(req, 0, blocks << 9);
-                        spin_unlock_irq(&md->lock);
-                }
-        } else {
-                spin_lock_irq(&md->lock);
-                ret = __blk_end_request(req, 0, brq->data.bytes_xfered);
-                spin_unlock_irq(&md->lock);
-        }
-
  cmd_abort:
         spin_lock_irq(&md->lock);
         while (ret)
@@ -1190,6 +1296,11 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 
         ret = mmc_blk_part_switch(card, md);
         if (ret) {
+                if (req) {
+                        spin_lock_irq(&md->lock);
+                        __blk_end_request_all(req, -EIO);
+                        spin_unlock_irq(&md->lock);
+                }
                 ret = 0;
                 goto out;
         }
@@ -1374,32 +1485,35 @@ static int mmc_blk_alloc_part(struct mmc_card *card,
 
         string_get_size((u64)get_capacity(part_md->disk) << 9, STRING_UNITS_2,
                         cap_str, sizeof(cap_str));
-        printk(KERN_INFO "%s: %s %s partition %u %s\n",
+        pr_info("%s: %s %s partition %u %s\n",
                part_md->disk->disk_name, mmc_card_id(card),
                mmc_card_name(card), part_md->part_type, cap_str);
         return 0;
 }
 
+/* MMC Physical partitions consist of two boot partitions and
+ * up to four general purpose partitions.
+ * For each partition enabled in EXT_CSD a block device will be allocatedi
+ * to provide access to the partition.
+ */
+
 static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
 {
-        int ret = 0;
+        int idx, ret = 0;
 
         if (!mmc_card_mmc(card))
                 return 0;
 
-        if (card->ext_csd.boot_size) {
-                ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT0,
-                                         card->ext_csd.boot_size >> 9,
-                                         true,
-                                         "boot0");
-                if (ret)
-                        return ret;
-                ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT1,
-                                         card->ext_csd.boot_size >> 9,
-                                         true,
-                                         "boot1");
-                if (ret)
-                        return ret;
+        for (idx = 0; idx < card->nr_parts; idx++) {
+                if (card->part[idx].size) {
+                        ret = mmc_blk_alloc_part(card, md,
+                                card->part[idx].part_cfg,
+                                card->part[idx].size >> 9,
+                                card->part[idx].force_ro,
+                                card->part[idx].name);
+                        if (ret)
+                                return ret;
+                }
         }
 
         return ret;
@@ -1415,7 +1529,7 @@ mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
         mmc_release_host(card->host);
 
         if (err) {
-                printk(KERN_ERR "%s: unable to set block size to 512: %d\n",
+                pr_err("%s: unable to set block size to 512: %d\n",
                         md->disk->disk_name, err);
                 return -EINVAL;
         }
@@ -1517,7 +1631,7 @@ static int mmc_blk_probe(struct mmc_card *card)
 
         string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
                         cap_str, sizeof(cap_str));
-        printk(KERN_INFO "%s: %s %s %s %s\n",
+        pr_info("%s: %s %s %s %s\n",
                 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
                 cap_str, md->read_only ? "(ro)" : "");
 
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 2bf229acd3b8..b038c4a9468b 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -22,6 +22,7 @@
 #include <linux/debugfs.h>
 #include <linux/uaccess.h>
 #include <linux/seq_file.h>
+#include <linux/module.h>
 
 #define RESULT_OK               0
 #define RESULT_FAIL             1
@@ -250,7 +251,7 @@ static int mmc_test_wait_busy(struct mmc_test_card *test)
                 if (!busy && mmc_test_busy(&cmd)) {
                         busy = 1;
                         if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
-                                printk(KERN_INFO "%s: Warning: Host did not "
+                                pr_info("%s: Warning: Host did not "
                                         "wait for busy state to end.\n",
                                         mmc_hostname(test->card->host));
                 }
@@ -552,7 +553,7 @@ static void mmc_test_print_rate(struct mmc_test_card *test, uint64_t bytes,
         rate = mmc_test_rate(bytes, &ts);
         iops = mmc_test_rate(100, &ts); /* I/O ops per sec x 100 */
 
-        printk(KERN_INFO "%s: Transfer of %u sectors (%u%s KiB) took %lu.%09lu "
+        pr_info("%s: Transfer of %u sectors (%u%s KiB) took %lu.%09lu "
                          "seconds (%u kB/s, %u KiB/s, %u.%02u IOPS)\n",
                          mmc_hostname(test->card->host), sectors, sectors >> 1,
                          (sectors & 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
@@ -578,7 +579,7 @@ static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
         rate = mmc_test_rate(tot, &ts);
         iops = mmc_test_rate(count * 100, &ts); /* I/O ops per sec x 100 */
 
-        printk(KERN_INFO "%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
+        pr_info("%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
                          "%lu.%09lu seconds (%u kB/s, %u KiB/s, "
                          "%u.%02u IOPS, sg_len %d)\n",
                          mmc_hostname(test->card->host), count, sectors, count,
@@ -1408,7 +1409,7 @@ static int mmc_test_multi_read_high(struct mmc_test_card *test)
 
 static int mmc_test_no_highmem(struct mmc_test_card *test)
 {
-        printk(KERN_INFO "%s: Highmem not configured - test skipped\n",
+        pr_info("%s: Highmem not configured - test skipped\n",
                mmc_hostname(test->card->host));
         return 0;
 }
@@ -1435,7 +1436,7 @@ static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
                                       t->max_seg_sz, &t->sg_len, min_sg_len);
         }
         if (err)
-                printk(KERN_INFO "%s: Failed to map sg list\n",
+                pr_info("%s: Failed to map sg list\n",
                        mmc_hostname(test->card->host));
         return err;
 }
@@ -2135,7 +2136,7 @@ static int mmc_test_rw_multiple(struct mmc_test_card *test,
 
         return ret;
  err:
-        printk(KERN_INFO "[%s] error\n", __func__);
+        pr_info("[%s] error\n", __func__);
         return ret;
 }
 
@@ -2149,7 +2150,7 @@ static int mmc_test_rw_multiple_size(struct mmc_test_card *test,
 
         if (rw->do_nonblock_req &&
             ((!pre_req && post_req) || (pre_req && !post_req))) {
-                printk(KERN_INFO "error: only one of pre/post is defined\n");
+                pr_info("error: only one of pre/post is defined\n");
                 return -EINVAL;
         }
 
@@ -2328,6 +2329,31 @@ static int mmc_test_profile_sglen_r_nonblock_perf(struct mmc_test_card *test)
         return mmc_test_rw_multiple_sg_len(test, &test_data);
 }
 
+/*
+ * eMMC hardware reset.
+ */
+static int mmc_test_hw_reset(struct mmc_test_card *test)
+{
+        struct mmc_card *card = test->card;
+        struct mmc_host *host = card->host;
+        int err;
+
+        err = mmc_hw_reset_check(host);
+        if (!err)
+                return RESULT_OK;
+
+        if (err == -ENOSYS)
+                return RESULT_FAIL;
+
+        if (err != -EOPNOTSUPP)
+                return err;
+
+        if (!mmc_can_reset(card))
+                return RESULT_UNSUP_CARD;
+
+        return RESULT_UNSUP_HOST;
+}
+
 static const struct mmc_test_case mmc_test_cases[] = {
         {
                 .name = "Basic write (no data verification)",
@@ -2650,6 +2676,11 @@ static const struct mmc_test_case mmc_test_cases[] = {
                 .run = mmc_test_profile_sglen_r_nonblock_perf,
                 .cleanup = mmc_test_area_cleanup,
         },
+
+        {
+                .name = "eMMC hardware reset",
+                .run = mmc_test_hw_reset,
+        },
 };
 
 static DEFINE_MUTEX(mmc_test_lock);
@@ -2660,7 +2691,7 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
 {
         int i, ret;
 
-        printk(KERN_INFO "%s: Starting tests of card %s...\n",
+        pr_info("%s: Starting tests of card %s...\n",
                 mmc_hostname(test->card->host), mmc_card_id(test->card));
 
         mmc_claim_host(test->card->host);
@@ -2671,14 +2702,14 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                 if (testcase && ((i + 1) != testcase))
                         continue;
 
-                printk(KERN_INFO "%s: Test case %d. %s...\n",
+                pr_info("%s: Test case %d. %s...\n",
                         mmc_hostname(test->card->host), i + 1,
                         mmc_test_cases[i].name);
 
                 if (mmc_test_cases[i].prepare) {
                         ret = mmc_test_cases[i].prepare(test);
                         if (ret) {
-                                printk(KERN_INFO "%s: Result: Prepare "
+                                pr_info("%s: Result: Prepare "
                                         "stage failed! (%d)\n",
                                         mmc_hostname(test->card->host),
                                         ret);
@@ -2708,25 +2739,25 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                 ret = mmc_test_cases[i].run(test);
                 switch (ret) {
                 case RESULT_OK:
-                        printk(KERN_INFO "%s: Result: OK\n",
+                        pr_info("%s: Result: OK\n",
                                 mmc_hostname(test->card->host));
                         break;
                 case RESULT_FAIL:
-                        printk(KERN_INFO "%s: Result: FAILED\n",
+                        pr_info("%s: Result: FAILED\n",
                                 mmc_hostname(test->card->host));
                         break;
                 case RESULT_UNSUP_HOST:
-                        printk(KERN_INFO "%s: Result: UNSUPPORTED "
+                        pr_info("%s: Result: UNSUPPORTED "
                                 "(by host)\n",
                                 mmc_hostname(test->card->host));
                         break;
                 case RESULT_UNSUP_CARD:
-                        printk(KERN_INFO "%s: Result: UNSUPPORTED "
+                        pr_info("%s: Result: UNSUPPORTED "
                                 "(by card)\n",
                                 mmc_hostname(test->card->host));
                         break;
                 default:
-                        printk(KERN_INFO "%s: Result: ERROR (%d)\n",
+                        pr_info("%s: Result: ERROR (%d)\n",
                                 mmc_hostname(test->card->host), ret);
                 }
 
@@ -2737,7 +2768,7 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
                 if (mmc_test_cases[i].cleanup) {
                         ret = mmc_test_cases[i].cleanup(test);
                         if (ret) {
-                                printk(KERN_INFO "%s: Warning: Cleanup "
+                                pr_info("%s: Warning: Cleanup "
                                         "stage failed! (%d)\n",
                                         mmc_hostname(test->card->host),
                                         ret);
@@ -2747,7 +2778,7 @@ static void mmc_test_run(struct mmc_test_card *test, int testcase)
 
         mmc_release_host(test->card->host);
 
-        printk(KERN_INFO "%s: Tests completed.\n",
+        pr_info("%s: Tests completed.\n",
                 mmc_hostname(test->card->host));
 }
 
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 45fb362e3f01..dcad59cbfef1 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -108,7 +108,7 @@ static void mmc_request(struct request_queue *q)
                 wake_up_process(mq->thread);
 }
 
-struct scatterlist *mmc_alloc_sg(int sg_len, int *err)
+static struct scatterlist *mmc_alloc_sg(int sg_len, int *err)
 {
         struct scatterlist *sg;
 
@@ -140,7 +140,7 @@ static void mmc_queue_setup_discard(struct request_queue *q,
         /* granularity must not be greater than max. discard */
         if (card->pref_erase > max_discard)
                 q->limits.discard_granularity = 0;
-        if (mmc_can_secure_erase_trim(card))
+        if (mmc_can_secure_erase_trim(card) || mmc_can_sanitize(card))
                 queue_flag_set_unlocked(QUEUE_FLAG_SECDISCARD, q);
 }
 
@@ -197,13 +197,13 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
                 if (bouncesz > 512) {
                         mqrq_cur->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
                         if (!mqrq_cur->bounce_buf) {
-                                printk(KERN_WARNING "%s: unable to "
+                                pr_warning("%s: unable to "
                                         "allocate bounce cur buffer\n",
                                         mmc_card_name(card));
                         }
                         mqrq_prev->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
                         if (!mqrq_prev->bounce_buf) {
-                                printk(KERN_WARNING "%s: unable to "
+                                pr_warning("%s: unable to "
                                         "allocate bounce prev buffer\n",
                                         mmc_card_name(card));
                                 kfree(mqrq_cur->bounce_buf);
diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
index c8c9edb3d7cb..2c151e18c9e8 100644
--- a/drivers/mmc/card/sdio_uart.c
+++ b/drivers/mmc/card/sdio_uart.c
@@ -1082,7 +1082,7 @@ static int sdio_uart_probe(struct sdio_func *func,
                 return -ENOMEM;
 
         if (func->class == SDIO_CLASS_UART) {
-                printk(KERN_WARNING "%s: need info on UART class basic setup\n",
+                pr_warning("%s: need info on UART class basic setup\n",
                        sdio_func_id(func));
                 kfree(port);
                 return -ENOSYS;
@@ -1101,23 +1101,23 @@ static int sdio_uart_probe(struct sdio_func *func,
                                 break;
                 }
                 if (!tpl) {
-                        printk(KERN_WARNING
+                        pr_warning(
        "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
                                sdio_func_id(func));
                         kfree(port);
                         return -EINVAL;
                 }
-                printk(KERN_DEBUG "%s: Register ID = 0x%02x, Exp ID = 0x%02x\n",
+                pr_debug("%s: Register ID = 0x%02x, Exp ID = 0x%02x\n",
                        sdio_func_id(func), tpl->data[2], tpl->data[3]);
                 port->regs_offset = (tpl->data[4] << 0) |
                                     (tpl->data[5] << 8) |
                                     (tpl->data[6] << 16);
-                printk(KERN_DEBUG "%s: regs offset = 0x%x\n",
+                pr_debug("%s: regs offset = 0x%x\n",
                        sdio_func_id(func), port->regs_offset);
                 port->uartclk = tpl->data[7] * 115200;
                 if (port->uartclk == 0)
                         port->uartclk = 115200;
-                printk(KERN_DEBUG "%s: clk %d baudcode %u 4800-div %u\n",
+                pr_debug("%s: clk %d baudcode %u 4800-div %u\n",
                        sdio_func_id(func), port->uartclk,
                        tpl->data[7], tpl->data[8] | (tpl->data[9] << 8));
         } else {