mmc: sdhci: make sdhci-pltfm device drivers self registered

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>

1 files changed, 37 insertions, 120 deletions

diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index dbab0407f4b6..8ccf25666201 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -22,48 +22,22 @@
  * 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");