mmc: sdhci: make sdhci-pltfm device drivers self registered
authorShawn Guo <shawn.guo@linaro.org>
Fri, 27 May 2011 15:48:12 +0000 (23:48 +0800)
committerChris Ball <cjb@laptop.org>
Wed, 20 Jul 2011 21:16:06 +0000 (17:16 -0400)
The patch turns the common stuff in sdhci-pltfm.c into functions, and
add device drivers their own .probe and .remove which in turn call
into the common functions, so that those sdhci-pltfm device drivers
register itself and keep all device specific things away from common
sdhci-pltfm file.

Signed-off-by: Shawn Guo <shawn.guo@linaro.org>
Reviewed-by: Grant Likely <grant.likely@secretlab.ca>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Anton Vorontsov <cbouatmailru@gmail.com>
Signed-off-by: Chris Ball <cjb@laptop.org>
drivers/mmc/host/Kconfig
drivers/mmc/host/Makefile
drivers/mmc/host/sdhci-cns3xxx.c
drivers/mmc/host/sdhci-dove.c
drivers/mmc/host/sdhci-esdhc-imx.c
drivers/mmc/host/sdhci-pltfm.c
drivers/mmc/host/sdhci-pltfm.h
drivers/mmc/host/sdhci-tegra.c
include/linux/mmc/sdhci-pltfm.h

index 56dbf3f6ad08a495075b2e254dccc1cb61d2c707..d9ca2623038ddbadefb34b16ae027558cd047190 100644 (file)
@@ -112,29 +112,19 @@ config MMC_SDHCI_OF_HLWD
 
          If unsure, say N.
 
-config MMC_SDHCI_PLTFM
-       tristate "SDHCI support on the platform specific bus"
-       depends on MMC_SDHCI
-       help
-         This selects the platform specific bus support for Secure Digital Host
-         Controller Interface.
-
-         If you have a controller with this interface, say Y or M here.
-
-         If unsure, say N.
-
 config MMC_SDHCI_CNS3XXX
-       bool "SDHCI support on the Cavium Networks CNS3xxx SoC"
+       tristate "SDHCI support on the Cavium Networks CNS3xxx SoC"
        depends on ARCH_CNS3XXX
-       depends on MMC_SDHCI_PLTFM
+       depends on MMC_SDHCI
        help
          This selects the SDHCI support for CNS3xxx System-on-Chip devices.
 
          If unsure, say N.
 
 config MMC_SDHCI_ESDHC_IMX
-       bool "SDHCI platform support for the Freescale eSDHC i.MX controller"
-       depends on MMC_SDHCI_PLTFM && (ARCH_MX25 || ARCH_MX35 || ARCH_MX5)
+       tristate "SDHCI platform support for the Freescale eSDHC i.MX controller"
+       depends on ARCH_MX25 || ARCH_MX35 || ARCH_MX5
+       depends on MMC_SDHCI
        select MMC_SDHCI_IO_ACCESSORS
        help
          This selects the Freescale eSDHC controller support on the platform
@@ -143,9 +133,9 @@ config MMC_SDHCI_ESDHC_IMX
          If unsure, say N.
 
 config MMC_SDHCI_DOVE
-       bool "SDHCI support on Marvell's Dove SoC"
+       tristate "SDHCI support on Marvell's Dove SoC"
        depends on ARCH_DOVE
-       depends on MMC_SDHCI_PLTFM
+       depends on MMC_SDHCI
        select MMC_SDHCI_IO_ACCESSORS
        help
          This selects the Secure Digital Host Controller Interface in
@@ -154,8 +144,9 @@ config MMC_SDHCI_DOVE
          If unsure, say N.
 
 config MMC_SDHCI_TEGRA
-       bool "SDHCI platform support for the Tegra SD/MMC Controller"
-       depends on MMC_SDHCI_PLTFM && ARCH_TEGRA
+       tristate "SDHCI platform support for the Tegra SD/MMC Controller"
+       depends on ARCH_TEGRA
+       depends on MMC_SDHCI
        select MMC_SDHCI_IO_ACCESSORS
        help
          This selects the Tegra SD/MMC controller. If you have a Tegra
index 58a5cf73d6e9a0fa77646b5a4ca40c5f48a8f847..732ec1e2a3d0dcd46f8636b92a7d6e2b732ffab6 100644 (file)
@@ -44,12 +44,14 @@ obj-$(CONFIG_MMC_JZ4740)    += jz4740_mmc.o
 obj-$(CONFIG_MMC_VUB300)       += vub300.o
 obj-$(CONFIG_MMC_USHC)         += ushc.o
 
-obj-$(CONFIG_MMC_SDHCI_PLTFM)                  += sdhci-platform.o
-sdhci-platform-y                               := sdhci-pltfm.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_CNS3XXX)     += sdhci-cns3xxx.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_ESDHC_IMX)   += sdhci-esdhc-imx.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_DOVE)                += sdhci-dove.o
-sdhci-platform-$(CONFIG_MMC_SDHCI_TEGRA)       += sdhci-tegra.o
+obj-$(CONFIG_MMC_SDHCI_CNS3XXX)                += sdhci-cns3xxx.o
+sdhci-cns3xxx-objs                     := sdhci-pltfm.o
+obj-$(CONFIG_MMC_SDHCI_ESDHC_IMX)      += sdhci-esdhc-imx.o
+sdhci-esdhc-imx-objs                   := sdhci-pltfm.o
+obj-$(CONFIG_MMC_SDHCI_DOVE)           += sdhci-dove.o
+sdhci-dove-objs                                := sdhci-pltfm.o
+obj-$(CONFIG_MMC_SDHCI_TEGRA)          += sdhci-tegra.o
+sdhci-tegra-objs                       := sdhci-pltfm.o
 
 obj-$(CONFIG_MMC_SDHCI_OF)     += sdhci-of.o
 sdhci-of-y                             := sdhci-of-core.o
index 9ebd1d7759dc98d8f112d7a6c316c915f4a33a5c..ac4b26f555e605186908e09c26173beaa4e906f5 100644 (file)
@@ -86,7 +86,7 @@ static struct sdhci_ops sdhci_cns3xxx_ops = {
        .set_clock      = sdhci_cns3xxx_set_clock,
 };
 
-struct sdhci_pltfm_data sdhci_cns3xxx_pdata = {
+static struct sdhci_pltfm_data sdhci_cns3xxx_pdata = {
        .ops = &sdhci_cns3xxx_ops,
        .quirks = SDHCI_QUIRK_BROKEN_DMA |
                  SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
@@ -95,3 +95,43 @@ struct sdhci_pltfm_data sdhci_cns3xxx_pdata = {
                  SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
                  SDHCI_QUIRK_NONSTANDARD_CLOCK,
 };
+
+static int __devinit sdhci_cns3xxx_probe(struct platform_device *pdev)
+{
+       return sdhci_pltfm_register(pdev, &sdhci_cns3xxx_pdata);
+}
+
+static int __devexit sdhci_cns3xxx_remove(struct platform_device *pdev)
+{
+       return sdhci_pltfm_unregister(pdev);
+}
+
+static struct platform_driver sdhci_cns3xxx_driver = {
+       .driver         = {
+               .name   = "sdhci-cns3xxx",
+               .owner  = THIS_MODULE,
+       },
+       .probe          = sdhci_cns3xxx_probe,
+       .remove         = __devexit_p(sdhci_cns3xxx_remove),
+#ifdef CONFIG_PM
+       .suspend        = sdhci_pltfm_suspend,
+       .resume         = sdhci_pltfm_resume,
+#endif
+};
+
+static int __init sdhci_cns3xxx_init(void)
+{
+       return platform_driver_register(&sdhci_cns3xxx_driver);
+}
+module_init(sdhci_cns3xxx_init);
+
+static void __exit sdhci_cns3xxx_exit(void)
+{
+       platform_driver_unregister(&sdhci_cns3xxx_driver);
+}
+module_exit(sdhci_cns3xxx_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for CNS3xxx");
+MODULE_AUTHOR("Scott Shu, "
+             "Anton Vorontsov <avorontsov@mvista.com>");
+MODULE_LICENSE("GPL v2");
index 2aeef4ffed8ceff6690caab653bd2dbc63005b6d..49aa533f23d4b3018798e7440dd9fc5bf2ee3948 100644 (file)
@@ -61,10 +61,50 @@ static struct sdhci_ops sdhci_dove_ops = {
        .read_l = sdhci_dove_readl,
 };
 
-struct sdhci_pltfm_data sdhci_dove_pdata = {
+static struct sdhci_pltfm_data sdhci_dove_pdata = {
        .ops    = &sdhci_dove_ops,
        .quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
                  SDHCI_QUIRK_NO_BUSY_IRQ |
                  SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
                  SDHCI_QUIRK_FORCE_DMA,
 };
+
+static int __devinit sdhci_dove_probe(struct platform_device *pdev)
+{
+       return sdhci_pltfm_register(pdev, &sdhci_dove_pdata);
+}
+
+static int __devexit sdhci_dove_remove(struct platform_device *pdev)
+{
+       return sdhci_pltfm_unregister(pdev);
+}
+
+static struct platform_driver sdhci_dove_driver = {
+       .driver         = {
+               .name   = "sdhci-dove",
+               .owner  = THIS_MODULE,
+       },
+       .probe          = sdhci_dove_probe,
+       .remove         = __devexit_p(sdhci_dove_remove),
+#ifdef CONFIG_PM
+       .suspend        = sdhci_pltfm_suspend,
+       .resume         = sdhci_pltfm_resume,
+#endif
+};
+
+static int __init sdhci_dove_init(void)
+{
+       return platform_driver_register(&sdhci_dove_driver);
+}
+module_init(sdhci_dove_init);
+
+static void __exit sdhci_dove_exit(void)
+{
+       platform_driver_unregister(&sdhci_dove_driver);
+}
+module_exit(sdhci_dove_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for Dove");
+MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>, "
+             "Mike Rapoport <mike@compulab.co.il>");
+MODULE_LICENSE("GPL v2");
index a19967d0bfc48b0ce8216de0d1a727093ee9fa03..e27ccbb5285b8303da018ab017e14b28ab28c0d4 100644 (file)
@@ -191,16 +191,6 @@ static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *host)
        return clk_get_rate(pltfm_host->clk) / 256 / 16;
 }
 
-static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
-{
-       struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
-
-       if (boarddata && gpio_is_valid(boarddata->wp_gpio))
-               return gpio_get_value(boarddata->wp_gpio);
-       else
-               return -ENOSYS;
-}
-
 static struct sdhci_ops sdhci_esdhc_ops = {
        .read_l = esdhc_readl_le,
        .read_w = esdhc_readw_le,
@@ -212,6 +202,24 @@ static struct sdhci_ops sdhci_esdhc_ops = {
        .get_min_clock = esdhc_pltfm_get_min_clock,
 };
 
+static struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
+       .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA
+                       | SDHCI_QUIRK_BROKEN_CARD_DETECTION,
+       /* ADMA has issues. Might be fixable */
+       .ops = &sdhci_esdhc_ops,
+};
+
+static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
+{
+       struct esdhc_platform_data *boarddata =
+                       host->mmc->parent->platform_data;
+
+       if (boarddata && gpio_is_valid(boarddata->wp_gpio))
+               return gpio_get_value(boarddata->wp_gpio);
+       else
+               return -ENOSYS;
+}
+
 static irqreturn_t cd_irq(int irq, void *data)
 {
        struct sdhci_host *sdhost = (struct sdhci_host *)data;
@@ -220,30 +228,35 @@ static irqreturn_t cd_irq(int irq, void *data)
        return IRQ_HANDLED;
 };
 
-static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pdata)
+static int __devinit sdhci_esdhc_imx_probe(struct platform_device *pdev)
 {
-       struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-       struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+       struct sdhci_pltfm_host *pltfm_host;
+       struct sdhci_host *host;
+       struct esdhc_platform_data *boarddata;
        struct clk *clk;
        int err;
        struct pltfm_imx_data *imx_data;
 
+       host = sdhci_pltfm_init(pdev, &sdhci_esdhc_imx_pdata);
+       if (IS_ERR(host))
+               return PTR_ERR(host);
+
+       pltfm_host = sdhci_priv(host);
+
+       imx_data = kzalloc(sizeof(struct pltfm_imx_data), GFP_KERNEL);
+       if (!imx_data)
+               return -ENOMEM;
+       pltfm_host->priv = imx_data;
+
        clk = clk_get(mmc_dev(host->mmc), NULL);
        if (IS_ERR(clk)) {
                dev_err(mmc_dev(host->mmc), "clk err\n");
-               return PTR_ERR(clk);
+               err = PTR_ERR(clk);
+               goto err_clk_get;
        }
        clk_enable(clk);
        pltfm_host->clk = clk;
 
-       imx_data = kzalloc(sizeof(struct pltfm_imx_data), GFP_KERNEL);
-       if (!imx_data) {
-               clk_disable(pltfm_host->clk);
-               clk_put(pltfm_host->clk);
-               return -ENOMEM;
-       }
-       pltfm_host->priv = imx_data;
-
        if (!cpu_is_mx25())
                host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
@@ -257,6 +270,7 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
        if (!(cpu_is_mx25() || cpu_is_mx35() || cpu_is_mx51()))
                imx_data->flags |= ESDHC_FLAG_MULTIBLK_NO_INT;
 
+       boarddata = host->mmc->parent->platform_data;
        if (boarddata) {
                err = gpio_request_one(boarddata->wp_gpio, GPIOF_IN, "ESDHC_WP");
                if (err) {
@@ -289,6 +303,10 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
                host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
        }
 
+       err = sdhci_add_host(host);
+       if (err)
+               goto err_add_host;
+
        return 0;
 
  no_card_detect_irq:
@@ -297,14 +315,23 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
        boarddata->cd_gpio = err;
  not_supported:
        kfree(imx_data);
-       return 0;
+ err_add_host:
+       clk_disable(pltfm_host->clk);
+       clk_put(pltfm_host->clk);
+ err_clk_get:
+       sdhci_pltfm_free(pdev);
+       return err;
 }
 
-static void esdhc_pltfm_exit(struct sdhci_host *host)
+static int __devexit sdhci_esdhc_imx_remove(struct platform_device *pdev)
 {
+       struct sdhci_host *host = platform_get_drvdata(pdev);
        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
        struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
        struct pltfm_imx_data *imx_data = pltfm_host->priv;
+       int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
+
+       sdhci_remove_host(host, dead);
 
        if (boarddata && gpio_is_valid(boarddata->wp_gpio))
                gpio_free(boarddata->wp_gpio);
@@ -319,13 +346,37 @@ static void esdhc_pltfm_exit(struct sdhci_host *host)
        clk_disable(pltfm_host->clk);
        clk_put(pltfm_host->clk);
        kfree(imx_data);
+
+       sdhci_pltfm_free(pdev);
+
+       return 0;
 }
 
-struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
-       .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_ADMA
-                       | SDHCI_QUIRK_BROKEN_CARD_DETECTION,
-       /* ADMA has issues. Might be fixable */
-       .ops = &sdhci_esdhc_ops,
-       .init = esdhc_pltfm_init,
-       .exit = esdhc_pltfm_exit,
+static struct platform_driver sdhci_esdhc_imx_driver = {
+       .driver         = {
+               .name   = "sdhci-esdhc-imx",
+               .owner  = THIS_MODULE,
+       },
+       .probe          = sdhci_esdhc_imx_probe,
+       .remove         = __devexit_p(sdhci_esdhc_imx_remove),
+#ifdef CONFIG_PM
+       .suspend        = sdhci_pltfm_suspend,
+       .resume         = sdhci_pltfm_resume,
+#endif
 };
+
+static int __init sdhci_esdhc_imx_init(void)
+{
+       return platform_driver_register(&sdhci_esdhc_imx_driver);
+}
+module_init(sdhci_esdhc_imx_init);
+
+static void __exit sdhci_esdhc_imx_exit(void)
+{
+       platform_driver_unregister(&sdhci_esdhc_imx_driver);
+}
+module_exit(sdhci_esdhc_imx_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for Freescale i.MX eSDHC");
+MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
+MODULE_LICENSE("GPL v2");
index dbab0407f4b643726fea113d985d48892d849e97..8ccf2566620128df94e3cbf8af77c057cdb8af2a 100644 (file)
  * Inspired by sdhci-pci.c, by Pierre Ossman
  */
 
-#include <linux/delay.h>
-#include <linux/highmem.h>
-#include <linux/mod_devicetable.h>
-#include <linux/platform_device.h>
-
-#include <linux/mmc/host.h>
-
-#include <linux/io.h>
-#include <linux/mmc/sdhci-pltfm.h>
+#include <linux/err.h>
 
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
 
-/*****************************************************************************\
- *                                                                           *
- * SDHCI core callbacks                                                      *
- *                                                                           *
-\*****************************************************************************/
-
 static struct sdhci_ops sdhci_pltfm_ops = {
 };
 
-/*****************************************************************************\
- *                                                                           *
- * Device probing/removal                                                    *
- *                                                                           *
-\*****************************************************************************/
-
-static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
+struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev,
+                                   struct sdhci_pltfm_data *pdata)
 {
-       const struct platform_device_id *platid = platform_get_device_id(pdev);
-       struct sdhci_pltfm_data *pdata;
        struct sdhci_host *host;
        struct sdhci_pltfm_host *pltfm_host;
        struct resource *iomem;
        int ret;
 
-       if (platid && platid->driver_data)
-               pdata = (void *)platid->driver_data;
-       else
-               pdata = pdev->dev.platform_data;
-
        iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!iomem) {
                ret = -ENOMEM;
@@ -71,8 +45,7 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
        }
 
        if (resource_size(iomem) < 0x100)
-               dev_err(&pdev->dev, "Invalid iomem size. You may "
-                       "experience problems.\n");
+               dev_err(&pdev->dev, "Invalid iomem size!\n");
 
        /* Some PCI-based MFD need the parent here */
        if (pdev->dev.parent != &platform_bus)
@@ -87,7 +60,7 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
 
        pltfm_host = sdhci_priv(host);
 
-       host->hw_name = "platform";
+       host->hw_name = dev_name(&pdev->dev);
        if (pdata && pdata->ops)
                host->ops = pdata->ops;
        else
@@ -110,126 +83,70 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
                goto err_remap;
        }
 
-       if (pdata && pdata->init) {
-               ret = pdata->init(host, pdata);
-               if (ret)
-                       goto err_plat_init;
-       }
-
-       ret = sdhci_add_host(host);
-       if (ret)
-               goto err_add_host;
-
        platform_set_drvdata(pdev, host);
 
-       return 0;
+       return host;
 
-err_add_host:
-       if (pdata && pdata->exit)
-               pdata->exit(host);
-err_plat_init:
-       iounmap(host->ioaddr);
 err_remap:
        release_mem_region(iomem->start, resource_size(iomem));
 err_request:
        sdhci_free_host(host);
 err:
-       printk(KERN_ERR"Probing of sdhci-pltfm failed: %d\n", ret);
-       return ret;
+       dev_err(&pdev->dev, "%s failed %d\n", __func__, ret);
+       return ERR_PTR(ret);
 }
 
-static int __devexit sdhci_pltfm_remove(struct platform_device *pdev)
+void sdhci_pltfm_free(struct platform_device *pdev)
 {
-       struct sdhci_pltfm_data *pdata = pdev->dev.platform_data;
        struct sdhci_host *host = platform_get_drvdata(pdev);
        struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       int dead;
-       u32 scratch;
-
-       dead = 0;
-       scratch = readl(host->ioaddr + SDHCI_INT_STATUS);
-       if (scratch == (u32)-1)
-               dead = 1;
 
-       sdhci_remove_host(host, dead);
-       if (pdata && pdata->exit)
-               pdata->exit(host);
        iounmap(host->ioaddr);
        release_mem_region(iomem->start, resource_size(iomem));
        sdhci_free_host(host);
        platform_set_drvdata(pdev, NULL);
+}
 
-       return 0;
+int sdhci_pltfm_register(struct platform_device *pdev,
+                        struct sdhci_pltfm_data *pdata)
+{
+       struct sdhci_host *host;
+       int ret = 0;
+
+       host = sdhci_pltfm_init(pdev, pdata);
+       if (IS_ERR(host))
+               return PTR_ERR(host);
+
+       ret = sdhci_add_host(host);
+       if (ret)
+               sdhci_pltfm_free(pdev);
+
+       return ret;
 }
 
-static const struct platform_device_id sdhci_pltfm_ids[] = {
-       { "sdhci", },
-#ifdef CONFIG_MMC_SDHCI_CNS3XXX
-       { "sdhci-cns3xxx", (kernel_ulong_t)&sdhci_cns3xxx_pdata },
-#endif
-#ifdef CONFIG_MMC_SDHCI_ESDHC_IMX
-       { "sdhci-esdhc-imx", (kernel_ulong_t)&sdhci_esdhc_imx_pdata },
-#endif
-#ifdef CONFIG_MMC_SDHCI_DOVE
-       { "sdhci-dove", (kernel_ulong_t)&sdhci_dove_pdata },
-#endif
-#ifdef CONFIG_MMC_SDHCI_TEGRA
-       { "sdhci-tegra", (kernel_ulong_t)&sdhci_tegra_pdata },
-#endif
-       { },
-};
-MODULE_DEVICE_TABLE(platform, sdhci_pltfm_ids);
+int sdhci_pltfm_unregister(struct platform_device *pdev)
+{
+       struct sdhci_host *host = platform_get_drvdata(pdev);
+       int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
+
+       sdhci_remove_host(host, dead);
+       sdhci_pltfm_free(pdev);
+
+       return 0;
+}
 
 #ifdef CONFIG_PM
-static int sdhci_pltfm_suspend(struct platform_device *dev, pm_message_t state)
+int sdhci_pltfm_suspend(struct platform_device *dev, pm_message_t state)
 {
        struct sdhci_host *host = platform_get_drvdata(dev);
 
        return sdhci_suspend_host(host, state);
 }
 
-static int sdhci_pltfm_resume(struct platform_device *dev)
+int sdhci_pltfm_resume(struct platform_device *dev)
 {
        struct sdhci_host *host = platform_get_drvdata(dev);
 
        return sdhci_resume_host(host);
 }
-#else
-#define sdhci_pltfm_suspend    NULL
-#define sdhci_pltfm_resume     NULL
 #endif /* CONFIG_PM */
-
-static struct platform_driver sdhci_pltfm_driver = {
-       .driver = {
-               .name   = "sdhci",
-               .owner  = THIS_MODULE,
-       },
-       .probe          = sdhci_pltfm_probe,
-       .remove         = __devexit_p(sdhci_pltfm_remove),
-       .id_table       = sdhci_pltfm_ids,
-       .suspend        = sdhci_pltfm_suspend,
-       .resume         = sdhci_pltfm_resume,
-};
-
-/*****************************************************************************\
- *                                                                           *
- * Driver init/exit                                                          *
- *                                                                           *
-\*****************************************************************************/
-
-static int __init sdhci_drv_init(void)
-{
-       return platform_driver_register(&sdhci_pltfm_driver);
-}
-
-static void __exit sdhci_drv_exit(void)
-{
-       platform_driver_unregister(&sdhci_pltfm_driver);
-}
-
-module_init(sdhci_drv_init);
-module_exit(sdhci_drv_exit);
-
-MODULE_DESCRIPTION("Secure Digital Host Controller Interface platform driver");
-MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
-MODULE_LICENSE("GPL v2");
index 2b37016ad0acccb67f8fb5540cdf4d6cfe6ae5a5..ff4b7eb326fb2a1375aa01b95d076a942ef99c0b 100644 (file)
@@ -13,6 +13,7 @@
 
 #include <linux/clk.h>
 #include <linux/types.h>
+#include <linux/platform_device.h>
 #include <linux/mmc/sdhci-pltfm.h>
 
 struct sdhci_pltfm_host {
@@ -20,9 +21,17 @@ struct sdhci_pltfm_host {
        void *priv; /* to handle quirks across io-accessor calls */
 };
 
-extern struct sdhci_pltfm_data sdhci_cns3xxx_pdata;
-extern struct sdhci_pltfm_data sdhci_esdhc_imx_pdata;
-extern struct sdhci_pltfm_data sdhci_dove_pdata;
-extern struct sdhci_pltfm_data sdhci_tegra_pdata;
+extern struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev,
+                                          struct sdhci_pltfm_data *pdata);
+extern void sdhci_pltfm_free(struct platform_device *pdev);
+
+extern int sdhci_pltfm_register(struct platform_device *pdev,
+                               struct sdhci_pltfm_data *pdata);
+extern int sdhci_pltfm_unregister(struct platform_device *pdev);
+
+#ifdef CONFIG_PM
+extern int sdhci_pltfm_suspend(struct platform_device *dev, pm_message_t state);
+extern int sdhci_pltfm_resume(struct platform_device *dev);
+#endif
 
 #endif /* _DRIVERS_MMC_SDHCI_PLTFM_H */
index 343c97edba32bfc780295784cc25869699b734d5..1f66aca5f50673ee0510d8dde6d78a0a148f0c66 100644 (file)
@@ -116,20 +116,42 @@ static int tegra_sdhci_8bit(struct sdhci_host *host, int bus_width)
        return 0;
 }
 
+static struct sdhci_ops tegra_sdhci_ops = {
+       .get_ro     = tegra_sdhci_get_ro,
+       .read_l     = tegra_sdhci_readl,
+       .read_w     = tegra_sdhci_readw,
+       .write_l    = tegra_sdhci_writel,
+       .platform_8bit_width = tegra_sdhci_8bit,
+};
+
+static struct sdhci_pltfm_data sdhci_tegra_pdata = {
+       .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
+                 SDHCI_QUIRK_SINGLE_POWER_WRITE |
+                 SDHCI_QUIRK_NO_HISPD_BIT |
+                 SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC,
+       .ops  = &tegra_sdhci_ops,
+};
 
-static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
-                                 struct sdhci_pltfm_data *pdata)
+static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
 {
-       struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-       struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
+       struct sdhci_pltfm_host *pltfm_host;
        struct tegra_sdhci_platform_data *plat;
+       struct sdhci_host *host;
        struct clk *clk;
        int rc;
 
+       host = sdhci_pltfm_init(pdev, &sdhci_tegra_pdata);
+       if (IS_ERR(host))
+               return PTR_ERR(host);
+
+       pltfm_host = sdhci_priv(host);
+
        plat = pdev->dev.platform_data;
+
        if (plat == NULL) {
                dev_err(mmc_dev(host->mmc), "missing platform data\n");
-               return -ENXIO;
+               rc = -ENXIO;
+               goto err_no_plat;
        }
 
        if (gpio_is_valid(plat->power_gpio)) {
@@ -137,7 +159,7 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
                if (rc) {
                        dev_err(mmc_dev(host->mmc),
                                "failed to allocate power gpio\n");
-                       goto out;
+                       goto err_power_req;
                }
                tegra_gpio_enable(plat->power_gpio);
                gpio_direction_output(plat->power_gpio, 1);
@@ -148,7 +170,7 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
                if (rc) {
                        dev_err(mmc_dev(host->mmc),
                                "failed to allocate cd gpio\n");
-                       goto out_power;
+                       goto err_cd_req;
                }
                tegra_gpio_enable(plat->cd_gpio);
                gpio_direction_input(plat->cd_gpio);
@@ -159,7 +181,7 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
 
                if (rc) {
                        dev_err(mmc_dev(host->mmc), "request irq error\n");
-                       goto out_cd;
+                       goto err_cd_irq_req;
                }
 
        }
@@ -169,7 +191,7 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
                if (rc) {
                        dev_err(mmc_dev(host->mmc),
                                "failed to allocate wp gpio\n");
-                       goto out_irq;
+                       goto err_wp_req;
                }
                tegra_gpio_enable(plat->wp_gpio);
                gpio_direction_input(plat->wp_gpio);
@@ -179,7 +201,7 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
        if (IS_ERR(clk)) {
                dev_err(mmc_dev(host->mmc), "clk err\n");
                rc = PTR_ERR(clk);
-               goto out_wp;
+               goto err_clk_get;
        }
        clk_enable(clk);
        pltfm_host->clk = clk;
@@ -189,38 +211,47 @@ static int tegra_sdhci_pltfm_init(struct sdhci_host *host,
        if (plat->is_8bit)
                host->mmc->caps |= MMC_CAP_8_BIT_DATA;
 
+       rc = sdhci_add_host(host);
+       if (rc)
+               goto err_add_host;
+
        return 0;
 
-out_wp:
+err_add_host:
+       clk_disable(pltfm_host->clk);
+       clk_put(pltfm_host->clk);
+err_clk_get:
        if (gpio_is_valid(plat->wp_gpio)) {
                tegra_gpio_disable(plat->wp_gpio);
                gpio_free(plat->wp_gpio);
        }
-
-out_irq:
+err_wp_req:
        if (gpio_is_valid(plat->cd_gpio))
                free_irq(gpio_to_irq(plat->cd_gpio), host);
-out_cd:
+err_cd_irq_req:
        if (gpio_is_valid(plat->cd_gpio)) {
                tegra_gpio_disable(plat->cd_gpio);
                gpio_free(plat->cd_gpio);
        }
-
-out_power:
+err_cd_req:
        if (gpio_is_valid(plat->power_gpio)) {
                tegra_gpio_disable(plat->power_gpio);
                gpio_free(plat->power_gpio);
        }
-
-out:
+err_power_req:
+err_no_plat:
+       sdhci_pltfm_free(pdev);
        return rc;
 }
 
-static void tegra_sdhci_pltfm_exit(struct sdhci_host *host)
+static int __devexit sdhci_tegra_remove(struct platform_device *pdev)
 {
+       struct sdhci_host *host = platform_get_drvdata(pdev);
        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-       struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
        struct tegra_sdhci_platform_data *plat;
+       int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
+
+       sdhci_remove_host(host, dead);
 
        plat = pdev->dev.platform_data;
 
@@ -242,22 +273,37 @@ static void tegra_sdhci_pltfm_exit(struct sdhci_host *host)
 
        clk_disable(pltfm_host->clk);
        clk_put(pltfm_host->clk);
+
+       sdhci_pltfm_free(pdev);
+
+       return 0;
 }
 
-static struct sdhci_ops tegra_sdhci_ops = {
-       .get_ro     = tegra_sdhci_get_ro,
-       .read_l     = tegra_sdhci_readl,
-       .read_w     = tegra_sdhci_readw,
-       .write_l    = tegra_sdhci_writel,
-       .platform_8bit_width = tegra_sdhci_8bit,
+static struct platform_driver sdhci_tegra_driver = {
+       .driver         = {
+               .name   = "sdhci-tegra",
+               .owner  = THIS_MODULE,
+       },
+       .probe          = sdhci_tegra_probe,
+       .remove         = __devexit_p(sdhci_tegra_remove),
+#ifdef CONFIG_PM
+       .suspend        = sdhci_pltfm_suspend,
+       .resume         = sdhci_pltfm_resume,
+#endif
 };
 
-struct sdhci_pltfm_data sdhci_tegra_pdata = {
-       .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
-                 SDHCI_QUIRK_SINGLE_POWER_WRITE |
-                 SDHCI_QUIRK_NO_HISPD_BIT |
-                 SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC,
-       .ops  = &tegra_sdhci_ops,
-       .init = tegra_sdhci_pltfm_init,
-       .exit = tegra_sdhci_pltfm_exit,
-};
+static int __init sdhci_tegra_init(void)
+{
+       return platform_driver_register(&sdhci_tegra_driver);
+}
+module_init(sdhci_tegra_init);
+
+static void __exit sdhci_tegra_exit(void)
+{
+       platform_driver_unregister(&sdhci_tegra_driver);
+}
+module_exit(sdhci_tegra_exit);
+
+MODULE_DESCRIPTION("SDHCI driver for Tegra");
+MODULE_AUTHOR(" Google, Inc.");
+MODULE_LICENSE("GPL v2");
index 548d59d404cb6ad9878e0bb44f2722dae3abc7d5..f1c2ac3fb300633f930dc285b3df5f35ffb80546 100644 (file)
 #define _SDHCI_PLTFM_H
 
 struct sdhci_ops;
-struct sdhci_host;
 
 /**
  * struct sdhci_pltfm_data - SDHCI platform-specific information & hooks
  * @ops: optional pointer to the platform-provided SDHCI ops
  * @quirks: optional SDHCI quirks
- * @init: optional hook that is called during device probe, before the
- *        driver tries to access any SDHCI registers
- * @exit: optional hook that is called during device removal
  */
 struct sdhci_pltfm_data {
        struct sdhci_ops *ops;
        unsigned int quirks;
-       int (*init)(struct sdhci_host *host, struct sdhci_pltfm_data *pdata);
-       void (*exit)(struct sdhci_host *host);
 };
 
 #endif /* _SDHCI_PLTFM_H */