mmc: tegra: assume CONFIG_OF, remove platform data
[~shefty/rdma-dev.git] / drivers / mmc / host / sdhci-tegra.c
index 5a600a5..08b06e9 100644 (file)
@@ -27,8 +27,6 @@
 
 #include <asm/gpio.h>
 
-#include <linux/platform_data/mmc-sdhci-tegra.h>
-
 #include "sdhci-pltfm.h"
 
 /* Tegra SDHOST controller vendor register definitions */
@@ -45,8 +43,11 @@ struct sdhci_tegra_soc_data {
 };
 
 struct sdhci_tegra {
-       const struct tegra_sdhci_platform_data *plat;
        const struct sdhci_tegra_soc_data *soc_data;
+       int cd_gpio;
+       int wp_gpio;
+       int power_gpio;
+       int is_8bit;
 };
 
 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
@@ -108,12 +109,11 @@ static unsigned int tegra_sdhci_get_ro(struct sdhci_host *host)
 {
        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
        struct sdhci_tegra *tegra_host = pltfm_host->priv;
-       const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
 
-       if (!gpio_is_valid(plat->wp_gpio))
+       if (!gpio_is_valid(tegra_host->wp_gpio))
                return -1;
 
-       return gpio_get_value(plat->wp_gpio);
+       return gpio_get_value(tegra_host->wp_gpio);
 }
 
 static irqreturn_t carddetect_irq(int irq, void *data)
@@ -147,11 +147,10 @@ static int tegra_sdhci_buswidth(struct sdhci_host *host, int bus_width)
 {
        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
        struct sdhci_tegra *tegra_host = pltfm_host->priv;
-       const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
        u32 ctrl;
 
        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
-       if (plat->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
+       if (tegra_host->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
                ctrl &= ~SDHCI_CTRL_4BITBUS;
                ctrl |= SDHCI_CTRL_8BITBUS;
        } else {
@@ -217,31 +216,19 @@ static const struct of_device_id sdhci_tegra_dt_match[] = {
 };
 MODULE_DEVICE_TABLE(of, sdhci_dt_ids);
 
-static struct tegra_sdhci_platform_data *sdhci_tegra_dt_parse_pdata(
-                                               struct platform_device *pdev)
+static void sdhci_tegra_parse_dt(struct device *dev,
+                                       struct sdhci_tegra *tegra_host)
 {
-       struct tegra_sdhci_platform_data *plat;
-       struct device_node *np = pdev->dev.of_node;
+       struct device_node *np = dev->of_node;
        u32 bus_width;
 
-       if (!np)
-               return NULL;
-
-       plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
-       if (!plat) {
-               dev_err(&pdev->dev, "Can't allocate platform data\n");
-               return NULL;
-       }
-
-       plat->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
-       plat->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
-       plat->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
+       tegra_host->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
+       tegra_host->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
+       tegra_host->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
 
        if (of_property_read_u32(np, "bus-width", &bus_width) == 0 &&
            bus_width == 8)
-               plat->is_8bit = 1;
-
-       return plat;
+               tegra_host->is_8bit = 1;
 }
 
 static int sdhci_tegra_probe(struct platform_device *pdev)
@@ -250,7 +237,6 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
        const struct sdhci_tegra_soc_data *soc_data;
        struct sdhci_host *host;
        struct sdhci_pltfm_host *pltfm_host;
-       struct tegra_sdhci_platform_data *plat;
        struct sdhci_tegra *tegra_host;
        struct clk *clk;
        int rc;
@@ -263,52 +249,40 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
        host = sdhci_pltfm_init(pdev, soc_data->pdata);
        if (IS_ERR(host))
                return PTR_ERR(host);
-
        pltfm_host = sdhci_priv(host);
 
-       plat = pdev->dev.platform_data;
-
-       if (plat == NULL)
-               plat = sdhci_tegra_dt_parse_pdata(pdev);
-
-       if (plat == NULL) {
-               dev_err(mmc_dev(host->mmc), "missing platform data\n");
-               rc = -ENXIO;
-               goto err_no_plat;
-       }
-
        tegra_host = devm_kzalloc(&pdev->dev, sizeof(*tegra_host), GFP_KERNEL);
        if (!tegra_host) {
                dev_err(mmc_dev(host->mmc), "failed to allocate tegra_host\n");
                rc = -ENOMEM;
-               goto err_no_plat;
+               goto err_alloc_tegra_host;
        }
-
-       tegra_host->plat = plat;
        tegra_host->soc_data = soc_data;
-
        pltfm_host->priv = tegra_host;
 
-       if (gpio_is_valid(plat->power_gpio)) {
-               rc = gpio_request(plat->power_gpio, "sdhci_power");
+       sdhci_tegra_parse_dt(&pdev->dev, tegra_host);
+
+       if (gpio_is_valid(tegra_host->power_gpio)) {
+               rc = gpio_request(tegra_host->power_gpio, "sdhci_power");
                if (rc) {
                        dev_err(mmc_dev(host->mmc),
                                "failed to allocate power gpio\n");
                        goto err_power_req;
                }
-               gpio_direction_output(plat->power_gpio, 1);
+               gpio_direction_output(tegra_host->power_gpio, 1);
        }
 
-       if (gpio_is_valid(plat->cd_gpio)) {
-               rc = gpio_request(plat->cd_gpio, "sdhci_cd");
+       if (gpio_is_valid(tegra_host->cd_gpio)) {
+               rc = gpio_request(tegra_host->cd_gpio, "sdhci_cd");
                if (rc) {
                        dev_err(mmc_dev(host->mmc),
                                "failed to allocate cd gpio\n");
                        goto err_cd_req;
                }
-               gpio_direction_input(plat->cd_gpio);
+               gpio_direction_input(tegra_host->cd_gpio);
 
-               rc = request_irq(gpio_to_irq(plat->cd_gpio), carddetect_irq,
+               rc = request_irq(gpio_to_irq(tegra_host->cd_gpio),
+                                carddetect_irq,
                                 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                                 mmc_hostname(host->mmc), host);
 
@@ -319,14 +293,14 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
 
        }
 
-       if (gpio_is_valid(plat->wp_gpio)) {
-               rc = gpio_request(plat->wp_gpio, "sdhci_wp");
+       if (gpio_is_valid(tegra_host->wp_gpio)) {
+               rc = gpio_request(tegra_host->wp_gpio, "sdhci_wp");
                if (rc) {
                        dev_err(mmc_dev(host->mmc),
                                "failed to allocate wp gpio\n");
                        goto err_wp_req;
                }
-               gpio_direction_input(plat->wp_gpio);
+               gpio_direction_input(tegra_host->wp_gpio);
        }
 
        clk = clk_get(mmc_dev(host->mmc), NULL);
@@ -338,9 +312,7 @@ static int sdhci_tegra_probe(struct platform_device *pdev)
        clk_prepare_enable(clk);
        pltfm_host->clk = clk;
 
-       host->mmc->pm_caps = plat->pm_flags;
-
-       if (plat->is_8bit)
+       if (tegra_host->is_8bit)
                host->mmc->caps |= MMC_CAP_8_BIT_DATA;
 
        rc = sdhci_add_host(host);
@@ -353,19 +325,19 @@ err_add_host:
        clk_disable_unprepare(pltfm_host->clk);
        clk_put(pltfm_host->clk);
 err_clk_get:
-       if (gpio_is_valid(plat->wp_gpio))
-               gpio_free(plat->wp_gpio);
+       if (gpio_is_valid(tegra_host->wp_gpio))
+               gpio_free(tegra_host->wp_gpio);
 err_wp_req:
-       if (gpio_is_valid(plat->cd_gpio))
-               free_irq(gpio_to_irq(plat->cd_gpio), host);
+       if (gpio_is_valid(tegra_host->cd_gpio))
+               free_irq(gpio_to_irq(tegra_host->cd_gpio), host);
 err_cd_irq_req:
-       if (gpio_is_valid(plat->cd_gpio))
-               gpio_free(plat->cd_gpio);
+       if (gpio_is_valid(tegra_host->cd_gpio))
+               gpio_free(tegra_host->cd_gpio);
 err_cd_req:
-       if (gpio_is_valid(plat->power_gpio))
-               gpio_free(plat->power_gpio);
+       if (gpio_is_valid(tegra_host->power_gpio))
+               gpio_free(tegra_host->power_gpio);
 err_power_req:
-err_no_plat:
+err_alloc_tegra_host:
        sdhci_pltfm_free(pdev);
        return rc;
 }
@@ -375,21 +347,20 @@ static int 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 sdhci_tegra *tegra_host = pltfm_host->priv;
-       const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
        int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
 
        sdhci_remove_host(host, dead);
 
-       if (gpio_is_valid(plat->wp_gpio))
-               gpio_free(plat->wp_gpio);
+       if (gpio_is_valid(tegra_host->wp_gpio))
+               gpio_free(tegra_host->wp_gpio);
 
-       if (gpio_is_valid(plat->cd_gpio)) {
-               free_irq(gpio_to_irq(plat->cd_gpio), host);
-               gpio_free(plat->cd_gpio);
+       if (gpio_is_valid(tegra_host->cd_gpio)) {
+               free_irq(gpio_to_irq(tegra_host->cd_gpio), host);
+               gpio_free(tegra_host->cd_gpio);
        }
 
-       if (gpio_is_valid(plat->power_gpio))
-               gpio_free(plat->power_gpio);
+       if (gpio_is_valid(tegra_host->power_gpio))
+               gpio_free(tegra_host->power_gpio);
 
        clk_disable_unprepare(pltfm_host->clk);
        clk_put(pltfm_host->clk);