11 files changed, 222 insertions, 12 deletions

diff --git a/drivers/mmc/core/Makefile b/drivers/mmc/core/Makefile
index 86b479119332..639501970b41 100644
--- a/drivers/mmc/core/Makefile
+++ b/drivers/mmc/core/Makefile
@@ -6,6 +6,7 @@ obj-$(CONFIG_MMC)		+= mmc_core.o
 mmc_core-y                      := core.o bus.o host.o \
                                    mmc.o mmc_ops.o sd.o sd_ops.o \
                                    sdio.o sdio_ops.o sdio_bus.o \
-                                   sdio_cis.o sdio_io.o sdio_irq.o
+                                   sdio_cis.o sdio_io.o sdio_irq.o \
+                                   quirks.o
 
 mmc_core-$(CONFIG_DEBUG_FS)     += debugfs.o
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 150b5f3cd401..1f453acc8682 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -167,8 +167,6 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 
         WARN_ON(!host->claimed);
 
-        led_trigger_event(host->led, LED_FULL);
-
         mrq->cmd->error = 0;
         mrq->cmd->mrq = mrq;
         if (mrq->data) {
@@ -194,6 +192,7 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                 }
         }
         mmc_host_clk_ungate(host);
+        led_trigger_event(host->led, LED_FULL);
         host->ops->request(host, mrq);
 }
 
@@ -528,7 +527,14 @@ int mmc_try_claim_host(struct mmc_host *host)
 }
 EXPORT_SYMBOL(mmc_try_claim_host);
 
-static void mmc_do_release_host(struct mmc_host *host)
+/**
+ *      mmc_do_release_host - release a claimed host
+ *      @host: mmc host to release
+ *
+ *      If you successfully claimed a host, this function will
+ *      release it again.
+ */
+void mmc_do_release_host(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -543,6 +549,7 @@ static void mmc_do_release_host(struct mmc_host *host)
                 wake_up(&host->wq);
         }
 }
+EXPORT_SYMBOL(mmc_do_release_host);
 
 void mmc_host_deeper_disable(struct work_struct *work)
 {
@@ -1002,6 +1009,13 @@ static void mmc_power_off(struct mmc_host *host)
 {
         host->ios.clock = 0;
         host->ios.vdd = 0;
+
+        /*
+         * Reset ocr mask to be the highest possible voltage supported for
+         * this mmc host. This value will be used at next power up.
+         */
+        host->ocr = 1 << (fls(host->ocr_avail) - 1);
+
         if (!mmc_host_is_spi(host)) {
                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
                 host->ios.chip_select = MMC_CS_DONTCARE;
@@ -1495,6 +1509,12 @@ static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
                 mmc_hostname(host), __func__, host->f_init);
 #endif
         mmc_power_up(host);
+
+        /*
+         * sdio_reset sends CMD52 to reset card.  Since we do not know
+         * if the card is being re-initialized, just send it.  CMD52
+         * should be ignored by SD/eMMC cards.
+         */
         sdio_reset(host);
         mmc_go_idle(host);
 
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index ca1fdde29df6..20b1c0831eac 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -61,6 +61,8 @@ int mmc_attach_mmc(struct mmc_host *host);
 int mmc_attach_sd(struct mmc_host *host);
 int mmc_attach_sdio(struct mmc_host *host);
 
+void mmc_fixup_device(struct mmc_card *card);
+
 /* Module parameters */
 extern int use_spi_crc;
 
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index b3ac6c5bc5c6..461e6a17fb90 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -160,10 +160,7 @@ static bool mmc_host_may_gate_card(struct mmc_card *card)
          * gate the clock, because there is somebody out there that may still
          * be using it.
          */
-        if (mmc_card_sdio(card))
-                return false;
-
-        return true;
+        return !(card->quirks & MMC_QUIRK_BROKEN_CLK_GATING);
 }
 
 /**
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 16006ef153fe..772d0d0a541b 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -302,6 +302,44 @@ static int mmc_read_ext_csd(struct mmc_card *card)
         }
 
         if (card->ext_csd.rev >= 4) {
+                /*
+                 * Enhanced area feature support -- check whether the eMMC
+                 * card has the Enhanced area enabled.  If so, export enhanced
+                 * area offset and size to user by adding sysfs interface.
+                 */
+                if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
+                                (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
+                        u8 hc_erase_grp_sz =
+                                ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
+                        u8 hc_wp_grp_sz =
+                                ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
+
+                        card->ext_csd.enhanced_area_en = 1;
+                        /*
+                         * calculate the enhanced data area offset, in bytes
+                         */
+                        card->ext_csd.enhanced_area_offset =
+                                (ext_csd[139] << 24) + (ext_csd[138] << 16) +
+                                (ext_csd[137] << 8) + ext_csd[136];
+                        if (mmc_card_blockaddr(card))
+                                card->ext_csd.enhanced_area_offset <<= 9;
+                        /*
+                         * calculate the enhanced data area size, in kilobytes
+                         */
+                        card->ext_csd.enhanced_area_size =
+                                (ext_csd[142] << 16) + (ext_csd[141] << 8) +
+                                ext_csd[140];
+                        card->ext_csd.enhanced_area_size *=
+                                (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
+                        card->ext_csd.enhanced_area_size <<= 9;
+                } else {
+                        /*
+                         * If the enhanced area is not enabled, disable these
+                         * device attributes.
+                         */
+                        card->ext_csd.enhanced_area_offset = -EINVAL;
+                        card->ext_csd.enhanced_area_size = -EINVAL;
+                }
                 card->ext_csd.sec_trim_mult =
                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
                 card->ext_csd.sec_erase_mult =
@@ -336,6 +374,9 @@ MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
+MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
+                card->ext_csd.enhanced_area_offset);
+MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 
 static struct attribute *mmc_std_attrs[] = {
         &dev_attr_cid.attr,
@@ -349,6 +390,8 @@ static struct attribute *mmc_std_attrs[] = {
         &dev_attr_name.attr,
         &dev_attr_oemid.attr,
         &dev_attr_serial.attr,
+        &dev_attr_enhanced_area_offset.attr,
+        &dev_attr_enhanced_area_size.attr,
         NULL,
 };
 
@@ -378,6 +421,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         int err, ddr = 0;
         u32 cid[4];
         unsigned int max_dtr;
+        u32 rocr;
 
         BUG_ON(!host);
         WARN_ON(!host->claimed);
@@ -391,7 +435,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         mmc_go_idle(host);
 
         /* The extra bit indicates that we support high capacity */
-        err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
+        err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
         if (err)
                 goto err;
 
@@ -479,11 +523,51 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 err = mmc_read_ext_csd(card);
                 if (err)
                         goto free_card;
+
+                /* If doing byte addressing, check if required to do sector
+                 * addressing.  Handle the case of <2GB cards needing sector
+                 * addressing.  See section 8.1 JEDEC Standard JED84-A441;
+                 * ocr register has bit 30 set for sector addressing.
+                 */
+                if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
+                        mmc_card_set_blockaddr(card);
+
                 /* Erase size depends on CSD and Extended CSD */
                 mmc_set_erase_size(card);
         }
 
         /*
+         * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
+         * bit.  This bit will be lost every time after a reset or power off.
+         */
+        if (card->ext_csd.enhanced_area_en) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                EXT_CSD_ERASE_GROUP_DEF, 1);
+
+                if (err && err != -EBADMSG)
+                        goto free_card;
+
+                if (err) {
+                        err = 0;
+                        /*
+                         * Just disable enhanced area off & sz
+                         * will try to enable ERASE_GROUP_DEF
+                         * during next time reinit
+                         */
+                        card->ext_csd.enhanced_area_offset = -EINVAL;
+                        card->ext_csd.enhanced_area_size = -EINVAL;
+                } else {
+                        card->ext_csd.erase_group_def = 1;
+                        /*
+                         * enable ERASE_GRP_DEF successfully.
+                         * This will affect the erase size, so
+                         * here need to reset erase size
+                         */
+                        mmc_set_erase_size(card);
+                }
+        }
+
+        /*
          * Activate high speed (if supported)
          */
         if ((card->ext_csd.hs_max_dtr != 0) &&
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 60842f878ded..f3b22bf89cc9 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -105,7 +105,7 @@ int mmc_go_idle(struct mmc_host *host)
          * that in case of hardware that won't pull up DAT3/nCS otherwise.
          *
          * SPI hosts ignore ios.chip_select; it's managed according to
-         * rules that must accomodate non-MMC slaves which this layer
+         * rules that must accommodate non-MMC slaves which this layer
          * won't even know about.
          */
         if (!mmc_host_is_spi(host)) {
diff --git a/drivers/mmc/core/quirks.c b/drivers/mmc/core/quirks.c
new file mode 100644
index 000000000000..11118b74eb20
--- /dev/null
+++ b/drivers/mmc/core/quirks.c
@@ -0,0 +1,84 @@
+/*
+ *  This file contains work-arounds for many known sdio hardware
+ *  bugs.
+ *
+ *  Copyright (c) 2011 Pierre Tardy <tardyp@gmail.com>
+ *  Inspired from pci fixup code:
+ *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/mmc/card.h>
+#include <linux/mod_devicetable.h>
+
+/*
+ *  The world is not perfect and supplies us with broken mmc/sdio devices.
+ *  For at least a part of these bugs we need a work-around
+ */
+
+struct mmc_fixup {
+        u16 vendor, device;     /* You can use SDIO_ANY_ID here of course */
+        void (*vendor_fixup)(struct mmc_card *card, int data);
+        int data;
+};
+
+/*
+ * This hook just adds a quirk unconditionnally
+ */
+static void __maybe_unused add_quirk(struct mmc_card *card, int data)
+{
+        card->quirks |= data;
+}
+
+/*
+ * This hook just removes a quirk unconditionnally
+ */
+static void __maybe_unused remove_quirk(struct mmc_card *card, int data)
+{
+        card->quirks &= ~data;
+}
+
+/*
+ * This hook just adds a quirk for all sdio devices
+ */
+static void add_quirk_for_sdio_devices(struct mmc_card *card, int data)
+{
+        if (mmc_card_sdio(card))
+                card->quirks |= data;
+}
+
+#ifndef SDIO_VENDOR_ID_TI
+#define SDIO_VENDOR_ID_TI               0x0097
+#endif
+
+#ifndef SDIO_DEVICE_ID_TI_WL1271
+#define SDIO_DEVICE_ID_TI_WL1271        0x4076
+#endif
+
+static const struct mmc_fixup mmc_fixup_methods[] = {
+        /* by default sdio devices are considered CLK_GATING broken */
+        /* good cards will be whitelisted as they are tested */
+        { SDIO_ANY_ID, SDIO_ANY_ID,
+                add_quirk_for_sdio_devices, MMC_QUIRK_BROKEN_CLK_GATING },
+        { SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271,
+                remove_quirk, MMC_QUIRK_BROKEN_CLK_GATING },
+        { 0 }
+};
+
+void mmc_fixup_device(struct mmc_card *card)
+{
+        const struct mmc_fixup *f;
+
+        for (f = mmc_fixup_methods; f->vendor_fixup; f++) {
+                if ((f->vendor == card->cis.vendor
+                     || f->vendor == (u16) SDIO_ANY_ID) &&
+                    (f->device == card->cis.device
+                     || f->device == (u16) SDIO_ANY_ID)) {
+                        dev_dbg(&card->dev, "calling %pF\n", f->vendor_fixup);
+                        f->vendor_fixup(card, f->data);
+                }
+        }
+}
+EXPORT_SYMBOL(mmc_fixup_device);
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index d18c32bca99b..6dac89fe0535 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -21,6 +21,7 @@
 #include "core.h"
 #include "bus.h"
 #include "mmc_ops.h"
+#include "sd.h"
 #include "sd_ops.h"
 
 static const unsigned int tran_exp[] = {
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 797cdb5887fd..76af349c14b4 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -9,6 +9,7 @@
  * your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/scatterlist.h>
 
@@ -252,6 +253,7 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         struct mmc_command cmd;
         struct mmc_data data;
         struct scatterlist sg;
+        void *data_buf;
 
         BUG_ON(!card);
         BUG_ON(!card->host);
@@ -263,6 +265,13 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         if (err)
                 return err;
 
+        /* dma onto stack is unsafe/nonportable, but callers to this
+         * routine normally provide temporary on-stack buffers ...
+         */
+        data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
+        if (data_buf == NULL)
+                return -ENOMEM;
+
         memset(&mrq, 0, sizeof(struct mmc_request));
         memset(&cmd, 0, sizeof(struct mmc_command));
         memset(&data, 0, sizeof(struct mmc_data));
@@ -280,12 +289,15 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         data.sg = &sg;
         data.sg_len = 1;
 
-        sg_init_one(&sg, scr, 8);
+        sg_init_one(&sg, data_buf, 8);
 
         mmc_set_data_timeout(&data, card);
 
         mmc_wait_for_req(card->host, &mrq);
 
+        memcpy(scr, data_buf, sizeof(card->raw_scr));
+        kfree(data_buf);
+
         if (cmd.error)
                 return cmd.error;
         if (data.error)
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index ebc62ad4cc56..db0f0b44d684 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -395,6 +395,14 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 if (err)
                         goto remove;
 
+                /*
+                 * Update oldcard with the new RCA received from the SDIO
+                 * device -- we're doing this so that it's updated in the
+                 * "card" struct when oldcard overwrites that later.
+                 */
+                if (oldcard)
+                        oldcard->rca = card->rca;
+
                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
         }
 
@@ -458,6 +466,7 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
 
                 card = oldcard;
         }
+        mmc_fixup_device(card);
 
         if (card->type == MMC_TYPE_SD_COMBO) {
                 err = mmc_sd_setup_card(host, card, oldcard != NULL);
diff --git a/drivers/mmc/core/sdio_irq.c b/drivers/mmc/core/sdio_irq.c
index bb192f90e8e9..b3001617e67d 100644
--- a/drivers/mmc/core/sdio_irq.c
+++ b/drivers/mmc/core/sdio_irq.c
@@ -45,7 +45,7 @@ static int process_sdio_pending_irqs(struct mmc_card *card)
                         struct sdio_func *func = card->sdio_func[i - 1];
                         if (!func) {
                                 printk(KERN_WARNING "%s: pending IRQ for "
-                                        "non-existant function\n",
+                                        "non-existent function\n",
                                         mmc_card_id(card));
                                 ret = -EINVAL;
                         } else if (func->irq_handler) {