Merge branch 'master' into for-next

Fast-forwarded to current state of Linus' tree as there are patches to be
applied for files that didn't exist on the old branch.

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) {