15 files changed, 286 insertions, 142 deletions

diff --git a/drivers/mmc/core/Kconfig b/drivers/mmc/core/Kconfig
index ab37a6d9d32a..bb22ffd76ef8 100644
--- a/drivers/mmc/core/Kconfig
+++ b/drivers/mmc/core/Kconfig
@@ -3,7 +3,7 @@
 #
 
 config MMC_UNSAFE_RESUME
-        bool "Allow unsafe resume (DANGEROUS)"
+        bool "Assume MMC/SD cards are non-removable (DANGEROUS)"
         help
           If you say Y here, the MMC layer will assume that all cards
           stayed in their respective slots during the suspend. The
@@ -14,3 +14,5 @@ config MMC_UNSAFE_RESUME
           This option is usually just for embedded systems which use
           a MMC/SD card for rootfs. Most people should say N here.
 
+          This option sets a default which can be overridden by the
+          module parameter "removable=0" or "removable=1".
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index bdb165f93046..49d9dcaeca49 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -13,6 +13,7 @@
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 7dab2e5f4bc9..3168ebd616b2 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -48,6 +48,22 @@ int use_spi_crc = 1;
 module_param(use_spi_crc, bool, 0);
 
 /*
+ * We normally treat cards as removed during suspend if they are not
+ * known to be on a non-removable bus, to avoid the risk of writing
+ * back data to a different card after resume.  Allow this to be
+ * overridden if necessary.
+ */
+#ifdef CONFIG_MMC_UNSAFE_RESUME
+int mmc_assume_removable;
+#else
+int mmc_assume_removable = 1;
+#endif
+module_param_named(removable, mmc_assume_removable, bool, 0644);
+MODULE_PARM_DESC(
+        removable,
+        "MMC/SD cards are removable and may be removed during suspend");
+
+/*
  * Internal function. Schedule delayed work in the MMC work queue.
  */
 static int mmc_schedule_delayed_work(struct delayed_work *work,
@@ -1073,6 +1089,7 @@ void mmc_rescan(struct work_struct *work)
         mmc_claim_host(host);
 
         mmc_power_up(host);
+        sdio_reset(host);
         mmc_go_idle(host);
 
         mmc_send_if_cond(host, host->ocr_avail);
@@ -1135,6 +1152,9 @@ void mmc_stop_host(struct mmc_host *host)
         cancel_delayed_work(&host->detect);
         mmc_flush_scheduled_work();
 
+        /* clear pm flags now and let card drivers set them as needed */
+        host->pm_flags = 0;
+
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
                 if (host->bus_ops->remove)
@@ -1257,12 +1277,13 @@ int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
                         mmc_claim_host(host);
                         mmc_detach_bus(host);
                         mmc_release_host(host);
+                        host->pm_flags = 0;
                         err = 0;
                 }
         }
         mmc_bus_put(host);
 
-        if (!err)
+        if (!err && !(host->pm_flags & MMC_PM_KEEP_POWER))
                 mmc_power_off(host);
 
         return err;
@@ -1280,8 +1301,10 @@ int mmc_resume_host(struct mmc_host *host)
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
-                mmc_power_up(host);
-                mmc_select_voltage(host, host->ocr);
+                if (!(host->pm_flags & MMC_PM_KEEP_POWER)) {
+                        mmc_power_up(host);
+                        mmc_select_voltage(host, host->ocr);
+                }
                 BUG_ON(!host->bus_ops->resume);
                 err = host->bus_ops->resume(host);
                 if (err) {
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index 67ae6abc4230..a811c52a1659 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -54,7 +54,9 @@ int mmc_attach_mmc(struct mmc_host *host, u32 ocr);
 int mmc_attach_sd(struct mmc_host *host, u32 ocr);
 int mmc_attach_sdio(struct mmc_host *host, u32 ocr);
 
+/* Module parameters */
 extern int use_spi_crc;
+extern int mmc_assume_removable;
 
 /* Debugfs information for hosts and cards */
 void mmc_add_host_debugfs(struct mmc_host *host);
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index 96d10f40fb23..53cb380c0987 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -10,6 +10,7 @@
 #include <linux/debugfs.h>
 #include <linux/fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <linux/stat.h>
 
 #include <linux/mmc/card.h>
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index a268d12f1af0..47353909e345 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -16,6 +16,7 @@
 #include <linux/idr.h>
 #include <linux/pagemap.h>
 #include <linux/leds.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/host.h>
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index bfefce365ae7..89f7a25b7ac1 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/err.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
@@ -207,7 +208,7 @@ static int mmc_read_ext_csd(struct mmc_card *card)
         }
 
         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
-        if (card->ext_csd.rev > 3) {
+        if (card->ext_csd.rev > 5) {
                 printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
                         "version %d\n", mmc_hostname(card->host),
                         card->ext_csd.rev);
@@ -225,7 +226,7 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                         mmc_card_set_blockaddr(card);
         }
 
-        switch (ext_csd[EXT_CSD_CARD_TYPE]) {
+        switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) {
         case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
                 card->ext_csd.hs_max_dtr = 52000000;
                 break;
@@ -237,7 +238,6 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                 printk(KERN_WARNING "%s: card is mmc v4 but doesn't "
                         "support any high-speed modes.\n",
                         mmc_hostname(card->host));
-                goto out;
         }
 
         if (card->ext_csd.rev >= 3) {
@@ -602,25 +602,6 @@ static int mmc_awake(struct mmc_host *host)
         return err;
 }
 
-#ifdef CONFIG_MMC_UNSAFE_RESUME
-
-static const struct mmc_bus_ops mmc_ops = {
-        .awake = mmc_awake,
-        .sleep = mmc_sleep,
-        .remove = mmc_remove,
-        .detect = mmc_detect,
-        .suspend = mmc_suspend,
-        .resume = mmc_resume,
-        .power_restore = mmc_power_restore,
-};
-
-static void mmc_attach_bus_ops(struct mmc_host *host)
-{
-        mmc_attach_bus(host, &mmc_ops);
-}
-
-#else
-
 static const struct mmc_bus_ops mmc_ops = {
         .awake = mmc_awake,
         .sleep = mmc_sleep,
@@ -645,15 +626,13 @@ static void mmc_attach_bus_ops(struct mmc_host *host)
 {
         const struct mmc_bus_ops *bus_ops;
 
-        if (host->caps & MMC_CAP_NONREMOVABLE)
+        if (host->caps & MMC_CAP_NONREMOVABLE || !mmc_assume_removable)
                 bus_ops = &mmc_ops_unsafe;
         else
                 bus_ops = &mmc_ops;
         mmc_attach_bus(host, bus_ops);
 }
 
-#endif
-
 /*
  * Starting point for MMC card init.
  */
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index d2cb5c634392..326447c9ede8 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -9,6 +9,7 @@
  * your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/scatterlist.h>
 
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 10b2a4d20f5a..5eac21df4809 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/err.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
@@ -606,23 +607,6 @@ static void mmc_sd_power_restore(struct mmc_host *host)
         mmc_release_host(host);
 }
 
-#ifdef CONFIG_MMC_UNSAFE_RESUME
-
-static const struct mmc_bus_ops mmc_sd_ops = {
-        .remove = mmc_sd_remove,
-        .detect = mmc_sd_detect,
-        .suspend = mmc_sd_suspend,
-        .resume = mmc_sd_resume,
-        .power_restore = mmc_sd_power_restore,
-};
-
-static void mmc_sd_attach_bus_ops(struct mmc_host *host)
-{
-        mmc_attach_bus(host, &mmc_sd_ops);
-}
-
-#else
-
 static const struct mmc_bus_ops mmc_sd_ops = {
         .remove = mmc_sd_remove,
         .detect = mmc_sd_detect,
@@ -643,15 +627,13 @@ static void mmc_sd_attach_bus_ops(struct mmc_host *host)
 {
         const struct mmc_bus_ops *bus_ops;
 
-        if (host->caps & MMC_CAP_NONREMOVABLE)
+        if (host->caps & MMC_CAP_NONREMOVABLE || !mmc_assume_removable)
                 bus_ops = &mmc_sd_ops_unsafe;
         else
                 bus_ops = &mmc_sd_ops;
         mmc_attach_bus(host, bus_ops);
 }
 
-#endif
-
 /*
  * Starting point for SD card init.
  */
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index cdb845b68ab5..2dd4cfe7ca17 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -188,6 +188,40 @@ static int sdio_disable_cd(struct mmc_card *card)
 }
 
 /*
+ * Devices that remain active during a system suspend are
+ * put back into 1-bit mode.
+ */
+static int sdio_disable_wide(struct mmc_card *card)
+{
+        int ret;
+        u8 ctrl;
+
+        if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
+                return 0;
+
+        if (card->cccr.low_speed && !card->cccr.wide_bus)
+                return 0;
+
+        ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
+        if (ret)
+                return ret;
+
+        if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
+                return 0;
+
+        ctrl &= ~SDIO_BUS_WIDTH_4BIT;
+        ctrl |= SDIO_BUS_ASYNC_INT;
+
+        ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
+        if (ret)
+                return ret;
+
+        mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);
+
+        return 0;
+}
+
+/*
  * Test if the card supports high-speed mode and, if so, switch to it.
  */
 static int sdio_enable_hs(struct mmc_card *card)
@@ -224,7 +258,7 @@ static int sdio_enable_hs(struct mmc_card *card)
  * we're trying to reinitialise.
  */
 static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
-                              struct mmc_card *oldcard)
+                              struct mmc_card *oldcard, int powered_resume)
 {
         struct mmc_card *card;
         int err;
@@ -235,9 +269,11 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
         /*
          * Inform the card of the voltage
          */
-        err = mmc_send_io_op_cond(host, host->ocr, &ocr);
-        if (err)
-                goto err;
+        if (!powered_resume) {
+                err = mmc_send_io_op_cond(host, host->ocr, &ocr);
+                if (err)
+                        goto err;
+        }
 
         /*
          * For SPI, enable CRC as appropriate.
@@ -262,7 +298,7 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
         /*
          * For native busses:  set card RCA and quit open drain mode.
          */
-        if (!mmc_host_is_spi(host)) {
+        if (!powered_resume && !mmc_host_is_spi(host)) {
                 err = mmc_send_relative_addr(host, &card->rca);
                 if (err)
                         goto remove;
@@ -273,7 +309,7 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
         /*
          * Select card, as all following commands rely on that.
          */
-        if (!mmc_host_is_spi(host)) {
+        if (!powered_resume && !mmc_host_is_spi(host)) {
                 err = mmc_select_card(card);
                 if (err)
                         goto remove;
@@ -425,6 +461,12 @@ static int mmc_sdio_suspend(struct mmc_host *host)
                 }
         }
 
+        if (!err && host->pm_flags & MMC_PM_KEEP_POWER) {
+                mmc_claim_host(host);
+                sdio_disable_wide(host->card);
+                mmc_release_host(host);
+        }
+
         return err;
 }
 
@@ -437,7 +479,13 @@ static int mmc_sdio_resume(struct mmc_host *host)
 
         /* Basic card reinitialization. */
         mmc_claim_host(host);
-        err = mmc_sdio_init_card(host, host->ocr, host->card);
+        err = mmc_sdio_init_card(host, host->ocr, host->card,
+                                 (host->pm_flags & MMC_PM_KEEP_POWER));
+        if (!err)
+                /* We may have switched to 1-bit mode during suspend. */
+                err = sdio_enable_wide(host->card);
+        if (!err && host->sdio_irqs)
+                mmc_signal_sdio_irq(host);
         mmc_release_host(host);
 
         /*
@@ -507,7 +555,7 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
         /*
          * Detect and init the card.
          */
-        err = mmc_sdio_init_card(host, host->ocr, NULL);
+        err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
         if (err)
                 goto err;
         card = host->card;
@@ -516,7 +564,8 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
          * The number of functions on the card is encoded inside
          * the ocr.
          */
-        card->sdio_funcs = funcs = (ocr & 0x70000000) >> 28;
+        funcs = (ocr & 0x70000000) >> 28;
+        card->sdio_funcs = 0;
 
         /*
          * If needed, disconnect card detection pull-up resistor.
@@ -528,7 +577,7 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
         /*
          * Initialize (but don't add) all present functions.
          */
-        for (i = 0;i < funcs;i++) {
+        for (i = 0; i < funcs; i++, card->sdio_funcs++) {
                 err = sdio_init_func(host->card, i + 1);
                 if (err)
                         goto remove;
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index d37464e296a5..4a890dcb95ab 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -13,6 +13,7 @@
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/sdio_func.h>
@@ -248,12 +249,15 @@ int sdio_add_func(struct sdio_func *func)
 /*
  * Unregister a SDIO function with the driver model, and
  * (eventually) free it.
+ * This function can be called through error paths where sdio_add_func() was
+ * never executed (because a failure occurred at an earlier point).
  */
 void sdio_remove_func(struct sdio_func *func)
 {
-        if (sdio_func_present(func))
-                device_del(&func->dev);
+        if (!sdio_func_present(func))
+                return;
 
+        device_del(&func->dev);
         put_device(&func->dev);
 }
 
diff --git a/drivers/mmc/core/sdio_cis.c b/drivers/mmc/core/sdio_cis.c
index f85dcd536508..541bdb89e0c5 100644
--- a/drivers/mmc/core/sdio_cis.c
+++ b/drivers/mmc/core/sdio_cis.c
@@ -14,6 +14,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
@@ -97,26 +98,56 @@ static const unsigned char speed_val[16] =
 static const unsigned int speed_unit[8] =
         { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 };
 
-/* FUNCE tuples with these types get passed to SDIO drivers */
-static const unsigned char funce_type_whitelist[] = {
-        4 /* CISTPL_FUNCE_LAN_NODE_ID used in Broadcom cards */
+
+typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *,
+                           const unsigned char *, unsigned);
+
+struct cis_tpl {
+        unsigned char code;
+        unsigned char min_size;
+        tpl_parse_t *parse;
 };
 
-static int cistpl_funce_whitelisted(unsigned char type)
+static int cis_tpl_parse(struct mmc_card *card, struct sdio_func *func,
+                         const char *tpl_descr,
+                         const struct cis_tpl *tpl, int tpl_count,
+                         unsigned char code,
+                         const unsigned char *buf, unsigned size)
 {
-        int i;
+        int i, ret;
 
-        for (i = 0; i < ARRAY_SIZE(funce_type_whitelist); i++) {
-                if (funce_type_whitelist[i] == type)
-                        return 1;
+        /* look for a matching code in the table */
+        for (i = 0; i < tpl_count; i++, tpl++) {
+                if (tpl->code == code)
+                        break;
         }
-        return 0;
+        if (i < tpl_count) {
+                if (size >= tpl->min_size) {
+                        if (tpl->parse)
+                                ret = tpl->parse(card, func, buf, size);
+                        else
+                                ret = -EILSEQ;  /* known tuple, not parsed */
+                } else {
+                        /* invalid tuple */
+                        ret = -EINVAL;
+                }
+                if (ret && ret != -EILSEQ && ret != -ENOENT) {
+                        printk(KERN_ERR "%s: bad %s tuple 0x%02x (%u bytes)\n",
+                               mmc_hostname(card->host), tpl_descr, code, size);
+                }
+        } else {
+                /* unknown tuple */
+                ret = -ENOENT;
+        }
+
+        return ret;
 }
 
-static int cistpl_funce_common(struct mmc_card *card,
+static int cistpl_funce_common(struct mmc_card *card, struct sdio_func *func,
                                const unsigned char *buf, unsigned size)
 {
-        if (size < 0x04 || buf[0] != 0)
+        /* Only valid for the common CIS (function 0) */
+        if (func)
                 return -EINVAL;
 
         /* TPLFE_FN0_BLK_SIZE */
@@ -129,20 +160,24 @@ static int cistpl_funce_common(struct mmc_card *card,
         return 0;
 }
 
-static int cistpl_funce_func(struct sdio_func *func,
+static int cistpl_funce_func(struct mmc_card *card, struct sdio_func *func,
                              const unsigned char *buf, unsigned size)
 {
         unsigned vsn;
         unsigned min_size;
 
-        /* let SDIO drivers take care of whitelisted FUNCE tuples */
-        if (cistpl_funce_whitelisted(buf[0]))
-                return -EILSEQ;
+        /* Only valid for the individual function's CIS (1-7) */
+        if (!func)
+                return -EINVAL;
 
+        /*
+         * This tuple has a different length depending on the SDIO spec
+         * version.
+         */
         vsn = func->card->cccr.sdio_vsn;
         min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42;
 
-        if (size < min_size || buf[0] != 1)
+        if (size < min_size)
                 return -EINVAL;
 
         /* TPLFE_MAX_BLK_SIZE */
@@ -157,39 +192,32 @@ static int cistpl_funce_func(struct sdio_func *func,
         return 0;
 }
 
+/*
+ * Known TPLFE_TYPEs table for CISTPL_FUNCE tuples.
+ *
+ * Note that, unlike PCMCIA, CISTPL_FUNCE tuples are not parsed depending
+ * on the TPLFID_FUNCTION value of the previous CISTPL_FUNCID as on SDIO
+ * TPLFID_FUNCTION is always hardcoded to 0x0C.
+ */
+static const struct cis_tpl cis_tpl_funce_list[] = {
+        {       0x00,   4,      cistpl_funce_common             },
+        {       0x01,   0,      cistpl_funce_func               },
+        {       0x04,   1+1+6,  /* CISTPL_FUNCE_LAN_NODE_ID */  },
+};
+
 static int cistpl_funce(struct mmc_card *card, struct sdio_func *func,
                         const unsigned char *buf, unsigned size)
 {
-        int ret;
-
-        /*
-         * There should be two versions of the CISTPL_FUNCE tuple,
-         * one for the common CIS (function 0) and a version used by
-         * the individual function's CIS (1-7). Yet, the later has a
-         * different length depending on the SDIO spec version.
-         */
-        if (func)
-                ret = cistpl_funce_func(func, buf, size);
-        else
-                ret = cistpl_funce_common(card, buf, size);
-
-        if (ret && ret != -EILSEQ) {
-                printk(KERN_ERR "%s: bad CISTPL_FUNCE size %u "
-                       "type %u\n", mmc_hostname(card->host), size, buf[0]);
-        }
+        if (size < 1)
+                return -EINVAL;
 
-        return ret;
+        return cis_tpl_parse(card, func, "CISTPL_FUNCE",
+                             cis_tpl_funce_list,
+                             ARRAY_SIZE(cis_tpl_funce_list),
+                             buf[0], buf, size);
 }
 
-typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *,
-                           const unsigned char *, unsigned);
-
-struct cis_tpl {
-        unsigned char code;
-        unsigned char min_size;
-        tpl_parse_t *parse;
-};
-
+/* Known TPL_CODEs table for CIS tuples */
 static const struct cis_tpl cis_tpl_list[] = {
         {       0x15,   3,      cistpl_vers_1           },
         {       0x20,   4,      cistpl_manfid           },
@@ -268,46 +296,38 @@ static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func)
                         break;
                 }
 
-                for (i = 0; i < ARRAY_SIZE(cis_tpl_list); i++)
-                        if (cis_tpl_list[i].code == tpl_code)
-                                break;
-                if (i < ARRAY_SIZE(cis_tpl_list)) {
-                        const struct cis_tpl *tpl = cis_tpl_list + i;
-                        if (tpl_link < tpl->min_size) {
-                                printk(KERN_ERR
-                                       "%s: bad CIS tuple 0x%02x"
-                                       " (length = %u, expected >= %u)\n",
-                                       mmc_hostname(card->host),
-                                       tpl_code, tpl_link, tpl->min_size);
-                                ret = -EINVAL;
-                        } else if (tpl->parse) {
-                                ret = tpl->parse(card, func,
-                                                 this->data, tpl_link);
-                        }
+                /* Try to parse the CIS tuple */
+                ret = cis_tpl_parse(card, func, "CIS",
+                                    cis_tpl_list, ARRAY_SIZE(cis_tpl_list),
+                                    tpl_code, this->data, tpl_link);
+                if (ret == -EILSEQ || ret == -ENOENT) {
                         /*
-                         * We don't need the tuple anymore if it was
-                         * successfully parsed by the SDIO core or if it is
-                         * not going to be parsed by SDIO drivers.
+                         * The tuple is unknown or known but not parsed.
+                         * Queue the tuple for the function driver.
                          */
-                        if (!ret || ret != -EILSEQ)
-                                kfree(this);
-                } else {
-                        /* unknown tuple */
-                        ret = -EILSEQ;
-                }
-
-                if (ret == -EILSEQ) {
-                        /* this tuple is unknown to the core or whitelisted */
                         this->next = NULL;
                         this->code = tpl_code;
                         this->size = tpl_link;
                         *prev = this;
                         prev = &this->next;
-                        printk(KERN_DEBUG
-                               "%s: queuing CIS tuple 0x%02x length %u\n",
-                               mmc_hostname(card->host), tpl_code, tpl_link);
+
+                        if (ret == -ENOENT) {
+                                /* warn about unknown tuples */
+                                printk(KERN_WARNING "%s: queuing unknown"
+                                       " CIS tuple 0x%02x (%u bytes)\n",
+                                       mmc_hostname(card->host),
+                                       tpl_code, tpl_link);
+                        }
+
                         /* keep on analyzing tuples */
                         ret = 0;
+                } else {
+                        /*
+                         * We don't need the tuple anymore if it was
+                         * successfully parsed by the SDIO core or if it is
+                         * not going to be queued for a driver.
+                         */
+                        kfree(this);
                 }
 
                 ptr += tpl_link;
diff --git a/drivers/mmc/core/sdio_io.c b/drivers/mmc/core/sdio_io.c
index f9aa8a7deffa..ff27c8c71355 100644
--- a/drivers/mmc/core/sdio_io.c
+++ b/drivers/mmc/core/sdio_io.c
@@ -189,7 +189,12 @@ static inline unsigned int sdio_max_byte_size(struct sdio_func *func)
 {
         unsigned mval = min(func->card->host->max_seg_size,
                             func->card->host->max_blk_size);
-        mval = min(mval, func->max_blksize);
+
+        if (mmc_blksz_for_byte_mode(func->card))
+                mval = min(mval, func->cur_blksize);
+        else
+                mval = min(mval, func->max_blksize);
+
         return min(mval, 512u); /* maximum size for byte mode */
 }
 
@@ -635,3 +640,52 @@ void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
                 *err_ret = ret;
 }
 EXPORT_SYMBOL_GPL(sdio_f0_writeb);
+
+/**
+ *      sdio_get_host_pm_caps - get host power management capabilities
+ *      @func: SDIO function attached to host
+ *
+ *      Returns a capability bitmask corresponding to power management
+ *      features supported by the host controller that the card function
+ *      might rely upon during a system suspend.  The host doesn't need
+ *      to be claimed, nor the function active, for this information to be
+ *      obtained.
+ */
+mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func)
+{
+        BUG_ON(!func);
+        BUG_ON(!func->card);
+
+        return func->card->host->pm_caps;
+}
+EXPORT_SYMBOL_GPL(sdio_get_host_pm_caps);
+
+/**
+ *      sdio_set_host_pm_flags - set wanted host power management capabilities
+ *      @func: SDIO function attached to host
+ *
+ *      Set a capability bitmask corresponding to wanted host controller
+ *      power management features for the upcoming suspend state.
+ *      This must be called, if needed, each time the suspend method of
+ *      the function driver is called, and must contain only bits that
+ *      were returned by sdio_get_host_pm_caps().
+ *      The host doesn't need to be claimed, nor the function active,
+ *      for this information to be set.
+ */
+int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags)
+{
+        struct mmc_host *host;
+
+        BUG_ON(!func);
+        BUG_ON(!func->card);
+
+        host = func->card->host;
+
+        if (flags & ~host->pm_caps)
+                return -EINVAL;
+
+        /* function suspend methods are serialized, hence no lock needed */
+        host->pm_flags |= flags;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(sdio_set_host_pm_flags);
diff --git a/drivers/mmc/core/sdio_ops.c b/drivers/mmc/core/sdio_ops.c
index 4eb7825fd1a7..dea36d9c22e6 100644
--- a/drivers/mmc/core/sdio_ops.c
+++ b/drivers/mmc/core/sdio_ops.c
@@ -67,13 +67,13 @@ int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
         return err;
 }
 
-int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
-        unsigned addr, u8 in, u8* out)
+static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
+        unsigned addr, u8 in, u8 *out)
 {
         struct mmc_command cmd;
         int err;
 
-        BUG_ON(!card);
+        BUG_ON(!host);
         BUG_ON(fn > 7);
 
         /* sanity check */
@@ -90,11 +90,11 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         cmd.arg |= in;
         cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
 
-        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        err = mmc_wait_for_cmd(host, &cmd, 0);
         if (err)
                 return err;
 
-        if (mmc_host_is_spi(card->host)) {
+        if (mmc_host_is_spi(host)) {
                 /* host driver already reported errors */
         } else {
                 if (cmd.resp[0] & R5_ERROR)
@@ -106,7 +106,7 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         }
 
         if (out) {
-                if (mmc_host_is_spi(card->host))
+                if (mmc_host_is_spi(host))
                         *out = (cmd.resp[0] >> 8) & 0xFF;
                 else
                         *out = cmd.resp[0] & 0xFF;
@@ -115,6 +115,13 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         return 0;
 }
 
+int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
+        unsigned addr, u8 in, u8 *out)
+{
+        BUG_ON(!card);
+        return mmc_io_rw_direct_host(card->host, write, fn, addr, in, out);
+}
+
 int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
 {
@@ -182,3 +189,20 @@ int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         return 0;
 }
 
+int sdio_reset(struct mmc_host *host)
+{
+        int ret;
+        u8 abort;
+
+        /* SDIO Simplified Specification V2.0, 4.4 Reset for SDIO */
+
+        ret = mmc_io_rw_direct_host(host, 0, 0, SDIO_CCCR_ABORT, 0, &abort);
+        if (ret)
+                abort = 0x08;
+        else
+                abort |= 0x08;
+
+        ret = mmc_io_rw_direct_host(host, 1, 0, SDIO_CCCR_ABORT, abort, NULL);
+        return ret;
+}
+
diff --git a/drivers/mmc/core/sdio_ops.h b/drivers/mmc/core/sdio_ops.h
index e2e74b0d17d8..12a4d3ab174c 100644
--- a/drivers/mmc/core/sdio_ops.h
+++ b/drivers/mmc/core/sdio_ops.h
@@ -17,6 +17,7 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, u8 in, u8* out);
 int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz);
+int sdio_reset(struct mmc_host *host);
 
 #endif