3 files changed, 181 insertions, 35 deletions

diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 8741d0f5146a..3d1e5329da12 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -22,12 +22,13 @@
 #include <linux/clk.h>
 #include <linux/scatterlist.h>
 #include <linux/gpio.h>
+#include <linux/amba/mmci.h>
+#include <linux/regulator/consumer.h>
 
 #include <asm/cacheflush.h>
 #include <asm/div64.h>
 #include <asm/io.h>
 #include <asm/sizes.h>
-#include <asm/mach/mmc.h>
 
 #include "mmci.h"
 
@@ -38,6 +39,36 @@
 
 static unsigned int fmax = 515633;
 
+/*
+ * This must be called with host->lock held
+ */
+static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
+{
+        u32 clk = 0;
+
+        if (desired) {
+                if (desired >= host->mclk) {
+                        clk = MCI_CLK_BYPASS;
+                        host->cclk = host->mclk;
+                } else {
+                        clk = host->mclk / (2 * desired) - 1;
+                        if (clk >= 256)
+                                clk = 255;
+                        host->cclk = host->mclk / (2 * (clk + 1));
+                }
+                if (host->hw_designer == 0x80)
+                        clk |= MCI_FCEN; /* Bug fix in ST IP block */
+                clk |= MCI_CLK_ENABLE;
+                /* This hasn't proven to be worthwhile */
+                /* clk |= MCI_CLK_PWRSAVE; */
+        }
+
+        if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_4)
+                clk |= MCI_WIDE_BUS;
+
+        writel(clk, host->base + MMCICLOCK);
+}
+
 static void
 mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
 {
@@ -419,30 +450,31 @@ static void mmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct mmci_host *host = mmc_priv(mmc);
-        u32 clk = 0, pwr = 0;
-
-        if (ios->clock) {
-                if (ios->clock >= host->mclk) {
-                        clk = MCI_CLK_BYPASS;
-                        host->cclk = host->mclk;
-                } else {
-                        clk = host->mclk / (2 * ios->clock) - 1;
-                        if (clk >= 256)
-                                clk = 255;
-                        host->cclk = host->mclk / (2 * (clk + 1));
-                }
-                if (host->hw_designer == AMBA_VENDOR_ST)
-                        clk |= MCI_FCEN; /* Bug fix in ST IP block */
-                clk |= MCI_CLK_ENABLE;
-        }
-
-        if (host->plat->translate_vdd)
-                pwr |= host->plat->translate_vdd(mmc_dev(mmc), ios->vdd);
+        u32 pwr = 0;
+        unsigned long flags;
 
         switch (ios->power_mode) {
         case MMC_POWER_OFF:
+                if(host->vcc &&
+                   regulator_is_enabled(host->vcc))
+                        regulator_disable(host->vcc);
                 break;
         case MMC_POWER_UP:
+#ifdef CONFIG_REGULATOR
+                if (host->vcc)
+                        /* This implicitly enables the regulator */
+                        mmc_regulator_set_ocr(host->vcc, ios->vdd);
+#endif
+                /*
+                 * The translate_vdd function is not used if you have
+                 * an external regulator, or your design is really weird.
+                 * Using it would mean sending in power control BOTH using
+                 * a regulator AND the 4 MMCIPWR bits. If we don't have
+                 * a regulator, we might have some other platform specific
+                 * power control behind this translate function.
+                 */
+                if (!host->vcc && host->plat->translate_vdd)
+                        pwr |= host->plat->translate_vdd(mmc_dev(mmc), ios->vdd);
                 /* The ST version does not have this, fall through to POWER_ON */
                 if (host->hw_designer != AMBA_VENDOR_ST) {
                         pwr |= MCI_PWR_UP;
@@ -465,12 +497,16 @@ static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 }
         }
 
-        writel(clk, host->base + MMCICLOCK);
+        spin_lock_irqsave(&host->lock, flags);
+
+        mmci_set_clkreg(host, ios->clock);
 
         if (host->pwr != pwr) {
                 host->pwr = pwr;
                 writel(pwr, host->base + MMCIPOWER);
         }
+
+        spin_unlock_irqrestore(&host->lock, flags);
 }
 
 static int mmci_get_ro(struct mmc_host *mmc)
@@ -517,7 +553,7 @@ static void mmci_check_status(unsigned long data)
 
 static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
 {
-        struct mmc_platform_data *plat = dev->dev.platform_data;
+        struct mmci_platform_data *plat = dev->dev.platform_data;
         struct mmci_host *host;
         struct mmc_host *mmc;
         int ret;
@@ -583,7 +619,30 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         mmc->ops = &mmci_ops;
         mmc->f_min = (host->mclk + 511) / 512;
         mmc->f_max = min(host->mclk, fmax);
-        mmc->ocr_avail = plat->ocr_mask;
+#ifdef CONFIG_REGULATOR
+        /* If we're using the regulator framework, try to fetch a regulator */
+        host->vcc = regulator_get(&dev->dev, "vmmc");
+        if (IS_ERR(host->vcc))
+                host->vcc = NULL;
+        else {
+                int mask = mmc_regulator_get_ocrmask(host->vcc);
+
+                if (mask < 0)
+                        dev_err(&dev->dev, "error getting OCR mask (%d)\n",
+                                mask);
+                else {
+                        host->mmc->ocr_avail = (u32) mask;
+                        if (plat->ocr_mask)
+                                dev_warn(&dev->dev,
+                                 "Provided ocr_mask/setpower will not be used "
+                                 "(using regulator instead)\n");
+                }
+        }
+#endif
+        /* Fall back to platform data if no regulator is found */
+        if (host->vcc == NULL)
+                mmc->ocr_avail = plat->ocr_mask;
+        mmc->caps = plat->capabilities;
 
         /*
          * We can do SGIO
@@ -720,6 +779,10 @@ static int __devexit mmci_remove(struct amba_device *dev)
                 clk_disable(host->clk);
                 clk_put(host->clk);
 
+                if (regulator_is_enabled(host->vcc))
+                        regulator_disable(host->vcc);
+                regulator_put(host->vcc);
+
                 mmc_free_host(mmc);
 
                 amba_release_regions(dev);
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 839f264c9725..1ceb9a90f59b 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -161,7 +161,7 @@ struct mmci_host {
         unsigned int            mclk;
         unsigned int            cclk;
         u32                     pwr;
-        struct mmc_platform_data *plat;
+        struct mmci_platform_data *plat;
 
         u8                      hw_designer;
         u8                      hw_revision:4;
@@ -175,6 +175,7 @@ struct mmci_host {
         struct scatterlist      *sg_ptr;
         unsigned int            sg_off;
         unsigned int            size;
+        struct regulator        *vcc;
 };
 
 static inline void mmci_init_sg(struct mmci_host *host, struct mmc_data *data)
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index e55ac792d68c..5e0b1529964d 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -28,6 +28,7 @@
 #include <linux/mmc/host.h>
 #include <linux/io.h>
 #include <linux/regulator/consumer.h>
+#include <linux/gpio.h>
 
 #include <asm/sizes.h>
 
@@ -96,10 +97,18 @@ static inline void pxamci_init_ocr(struct pxamci_host *host)
 
 static inline void pxamci_set_power(struct pxamci_host *host, unsigned int vdd)
 {
+        int on;
+
 #ifdef CONFIG_REGULATOR
         if (host->vcc)
                 mmc_regulator_set_ocr(host->vcc, vdd);
 #endif
+        if (!host->vcc && host->pdata &&
+            gpio_is_valid(host->pdata->gpio_power)) {
+                on = ((1 << vdd) & host->pdata->ocr_mask);
+                gpio_set_value(host->pdata->gpio_power,
+                               !!on ^ host->pdata->gpio_power_invert);
+        }
         if (!host->vcc && host->pdata && host->pdata->setpower)
                 host->pdata->setpower(mmc_dev(host->mmc), vdd);
 }
@@ -421,6 +430,12 @@ static int pxamci_get_ro(struct mmc_host *mmc)
 {
         struct pxamci_host *host = mmc_priv(mmc);
 
+        if (host->pdata && gpio_is_valid(host->pdata->gpio_card_ro)) {
+                if (host->pdata->gpio_card_ro_invert)
+                        return !gpio_get_value(host->pdata->gpio_card_ro);
+                else
+                        return gpio_get_value(host->pdata->gpio_card_ro);
+        }
         if (host->pdata && host->pdata->get_ro)
                 return !!host->pdata->get_ro(mmc_dev(mmc));
         /*
@@ -534,7 +549,7 @@ static int pxamci_probe(struct platform_device *pdev)
         struct mmc_host *mmc;
         struct pxamci_host *host = NULL;
         struct resource *r, *dmarx, *dmatx;
-        int ret, irq;
+        int ret, irq, gpio_cd = -1, gpio_ro = -1, gpio_power = -1;
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
@@ -661,13 +676,63 @@ static int pxamci_probe(struct platform_device *pdev)
         }
         host->dma_drcmrtx = dmatx->start;
 
+        if (host->pdata) {
+                gpio_cd = host->pdata->gpio_card_detect;
+                gpio_ro = host->pdata->gpio_card_ro;
+                gpio_power = host->pdata->gpio_power;
+        }
+        if (gpio_is_valid(gpio_power)) {
+                ret = gpio_request(gpio_power, "mmc card power");
+                if (ret) {
+                        dev_err(&pdev->dev, "Failed requesting gpio_power %d\n", gpio_power);
+                        goto out;
+                }
+                gpio_direction_output(gpio_power,
+                                      host->pdata->gpio_power_invert);
+        }
+        if (gpio_is_valid(gpio_ro)) {
+                ret = gpio_request(gpio_ro, "mmc card read only");
+                if (ret) {
+                        dev_err(&pdev->dev, "Failed requesting gpio_ro %d\n", gpio_power);
+                        goto err_gpio_ro;
+                }
+                gpio_direction_input(gpio_ro);
+        }
+        if (gpio_is_valid(gpio_cd)) {
+                ret = gpio_request(gpio_cd, "mmc card detect");
+                if (ret) {
+                        dev_err(&pdev->dev, "Failed requesting gpio_cd %d\n", gpio_power);
+                        goto err_gpio_cd;
+                }
+                gpio_direction_input(gpio_cd);
+
+                ret = request_irq(gpio_to_irq(gpio_cd), pxamci_detect_irq,
+                                  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                  "mmc card detect", mmc);
+                if (ret) {
+                        dev_err(&pdev->dev, "failed to request card detect IRQ\n");
+                        goto err_request_irq;
+                }
+        }
+
         if (host->pdata && host->pdata->init)
                 host->pdata->init(&pdev->dev, pxamci_detect_irq, mmc);
 
+        if (gpio_is_valid(gpio_power) && host->pdata->setpower)
+                dev_warn(&pdev->dev, "gpio_power and setpower() both defined\n");
+        if (gpio_is_valid(gpio_ro) && host->pdata->get_ro)
+                dev_warn(&pdev->dev, "gpio_ro and get_ro() both defined\n");
+
         mmc_add_host(mmc);
 
         return 0;
 
+err_request_irq:
+        gpio_free(gpio_cd);
+err_gpio_cd:
+        gpio_free(gpio_ro);
+err_gpio_ro:
+        gpio_free(gpio_power);
  out:
         if (host) {
                 if (host->dma >= 0)
@@ -688,12 +753,26 @@ static int pxamci_probe(struct platform_device *pdev)
 static int pxamci_remove(struct platform_device *pdev)
 {
         struct mmc_host *mmc = platform_get_drvdata(pdev);
+        int gpio_cd = -1, gpio_ro = -1, gpio_power = -1;
 
         platform_set_drvdata(pdev, NULL);
 
         if (mmc) {
                 struct pxamci_host *host = mmc_priv(mmc);
 
+                if (host->pdata) {
+                        gpio_cd = host->pdata->gpio_card_detect;
+                        gpio_ro = host->pdata->gpio_card_ro;
+                        gpio_power = host->pdata->gpio_power;
+                }
+                if (gpio_is_valid(gpio_cd)) {
+                        free_irq(gpio_to_irq(gpio_cd), mmc);
+                        gpio_free(gpio_cd);
+                }
+                if (gpio_is_valid(gpio_ro))
+                        gpio_free(gpio_ro);
+                if (gpio_is_valid(gpio_power))
+                        gpio_free(gpio_power);
                 if (host->vcc)
                         regulator_put(host->vcc);
 
@@ -725,20 +804,20 @@ static int pxamci_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int pxamci_suspend(struct platform_device *dev, pm_message_t state)
+static int pxamci_suspend(struct device *dev)
 {
-        struct mmc_host *mmc = platform_get_drvdata(dev);
+        struct mmc_host *mmc = dev_get_drvdata(dev);
         int ret = 0;
 
         if (mmc)
-                ret = mmc_suspend_host(mmc, state);
+                ret = mmc_suspend_host(mmc, PMSG_SUSPEND);
 
         return ret;
 }
 
-static int pxamci_resume(struct platform_device *dev)
+static int pxamci_resume(struct device *dev)
 {
-        struct mmc_host *mmc = platform_get_drvdata(dev);
+        struct mmc_host *mmc = dev_get_drvdata(dev);
         int ret = 0;
 
         if (mmc)
@@ -746,19 +825,22 @@ static int pxamci_resume(struct platform_device *dev)
 
         return ret;
 }
-#else
-#define pxamci_suspend  NULL
-#define pxamci_resume   NULL
+
+static struct dev_pm_ops pxamci_pm_ops = {
+        .suspend        = pxamci_suspend,
+        .resume         = pxamci_resume,
+};
 #endif
 
 static struct platform_driver pxamci_driver = {
         .probe          = pxamci_probe,
         .remove         = pxamci_remove,
-        .suspend        = pxamci_suspend,
-        .resume         = pxamci_resume,
         .driver         = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &pxamci_pm_ops,
+#endif
         },
 };