Merge branch 'core-rcu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.git] / drivers / mmc / host / sdhci-pltfm.c
1 /*
2  * sdhci-pltfm.c Support for SDHCI platform devices
3  * Copyright (c) 2009 Intel Corporation
4  *
5  * Copyright (c) 2007 Freescale Semiconductor, Inc.
6  * Copyright (c) 2009 MontaVista Software, Inc.
7  *
8  * Authors: Xiaobo Xie <X.Xie@freescale.com>
9  *          Anton Vorontsov <avorontsov@ru.mvista.com>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25 /* Supports:
26  * SDHCI platform devices
27  *
28  * Inspired by sdhci-pci.c, by Pierre Ossman
29  */
30
31 #include <linux/err.h>
32 #include <linux/of.h>
33 #ifdef CONFIG_PPC
34 #include <asm/machdep.h>
35 #endif
36 #include "sdhci-pltfm.h"
37
38 static struct sdhci_ops sdhci_pltfm_ops = {
39 };
40
41 #ifdef CONFIG_OF
42 static bool sdhci_of_wp_inverted(struct device_node *np)
43 {
44         if (of_get_property(np, "sdhci,wp-inverted", NULL))
45                 return true;
46
47         /* Old device trees don't have the wp-inverted property. */
48 #ifdef CONFIG_PPC
49         return machine_is(mpc837x_rdb) || machine_is(mpc837x_mds);
50 #else
51         return false;
52 #endif /* CONFIG_PPC */
53 }
54
55 void sdhci_get_of_property(struct platform_device *pdev)
56 {
57         struct device_node *np = pdev->dev.of_node;
58         struct sdhci_host *host = platform_get_drvdata(pdev);
59         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
60         const __be32 *clk;
61         int size;
62
63         if (of_device_is_available(np)) {
64                 if (of_get_property(np, "sdhci,auto-cmd12", NULL))
65                         host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
66
67                 if (of_get_property(np, "sdhci,1-bit-only", NULL))
68                         host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA;
69
70                 if (sdhci_of_wp_inverted(np))
71                         host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
72
73                 clk = of_get_property(np, "clock-frequency", &size);
74                 if (clk && size == sizeof(*clk) && *clk)
75                         pltfm_host->clock = be32_to_cpup(clk);
76         }
77 }
78 #else
79 void sdhci_get_of_property(struct platform_device *pdev) {}
80 #endif /* CONFIG_OF */
81 EXPORT_SYMBOL_GPL(sdhci_get_of_property);
82
83 struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev,
84                                     struct sdhci_pltfm_data *pdata)
85 {
86         struct sdhci_host *host;
87         struct sdhci_pltfm_host *pltfm_host;
88         struct resource *iomem;
89         int ret;
90
91         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
92         if (!iomem) {
93                 ret = -ENOMEM;
94                 goto err;
95         }
96
97         if (resource_size(iomem) < 0x100)
98                 dev_err(&pdev->dev, "Invalid iomem size!\n");
99
100         /* Some PCI-based MFD need the parent here */
101         if (pdev->dev.parent != &platform_bus)
102                 host = sdhci_alloc_host(pdev->dev.parent, sizeof(*pltfm_host));
103         else
104                 host = sdhci_alloc_host(&pdev->dev, sizeof(*pltfm_host));
105
106         if (IS_ERR(host)) {
107                 ret = PTR_ERR(host);
108                 goto err;
109         }
110
111         pltfm_host = sdhci_priv(host);
112
113         host->hw_name = dev_name(&pdev->dev);
114         if (pdata && pdata->ops)
115                 host->ops = pdata->ops;
116         else
117                 host->ops = &sdhci_pltfm_ops;
118         if (pdata)
119                 host->quirks = pdata->quirks;
120         host->irq = platform_get_irq(pdev, 0);
121
122         if (!request_mem_region(iomem->start, resource_size(iomem),
123                 mmc_hostname(host->mmc))) {
124                 dev_err(&pdev->dev, "cannot request region\n");
125                 ret = -EBUSY;
126                 goto err_request;
127         }
128
129         host->ioaddr = ioremap(iomem->start, resource_size(iomem));
130         if (!host->ioaddr) {
131                 dev_err(&pdev->dev, "failed to remap registers\n");
132                 ret = -ENOMEM;
133                 goto err_remap;
134         }
135
136         platform_set_drvdata(pdev, host);
137
138         return host;
139
140 err_remap:
141         release_mem_region(iomem->start, resource_size(iomem));
142 err_request:
143         sdhci_free_host(host);
144 err:
145         dev_err(&pdev->dev, "%s failed %d\n", __func__, ret);
146         return ERR_PTR(ret);
147 }
148 EXPORT_SYMBOL_GPL(sdhci_pltfm_init);
149
150 void sdhci_pltfm_free(struct platform_device *pdev)
151 {
152         struct sdhci_host *host = platform_get_drvdata(pdev);
153         struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
154
155         iounmap(host->ioaddr);
156         release_mem_region(iomem->start, resource_size(iomem));
157         sdhci_free_host(host);
158         platform_set_drvdata(pdev, NULL);
159 }
160 EXPORT_SYMBOL_GPL(sdhci_pltfm_free);
161
162 int sdhci_pltfm_register(struct platform_device *pdev,
163                          struct sdhci_pltfm_data *pdata)
164 {
165         struct sdhci_host *host;
166         int ret = 0;
167
168         host = sdhci_pltfm_init(pdev, pdata);
169         if (IS_ERR(host))
170                 return PTR_ERR(host);
171
172         sdhci_get_of_property(pdev);
173
174         ret = sdhci_add_host(host);
175         if (ret)
176                 sdhci_pltfm_free(pdev);
177
178         return ret;
179 }
180 EXPORT_SYMBOL_GPL(sdhci_pltfm_register);
181
182 int sdhci_pltfm_unregister(struct platform_device *pdev)
183 {
184         struct sdhci_host *host = platform_get_drvdata(pdev);
185         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
186
187         sdhci_remove_host(host, dead);
188         sdhci_pltfm_free(pdev);
189
190         return 0;
191 }
192 EXPORT_SYMBOL_GPL(sdhci_pltfm_unregister);
193
194 #ifdef CONFIG_PM
195 int sdhci_pltfm_suspend(struct platform_device *dev, pm_message_t state)
196 {
197         struct sdhci_host *host = platform_get_drvdata(dev);
198
199         return sdhci_suspend_host(host, state);
200 }
201 EXPORT_SYMBOL_GPL(sdhci_pltfm_suspend);
202
203 int sdhci_pltfm_resume(struct platform_device *dev)
204 {
205         struct sdhci_host *host = platform_get_drvdata(dev);
206
207         return sdhci_resume_host(host);
208 }
209 EXPORT_SYMBOL_GPL(sdhci_pltfm_resume);
210 #endif  /* CONFIG_PM */
211
212 static int __init sdhci_pltfm_drv_init(void)
213 {
214         pr_info("sdhci-pltfm: SDHCI platform and OF driver helper\n");
215
216         return 0;
217 }
218 module_init(sdhci_pltfm_drv_init);
219
220 static void __exit sdhci_pltfm_drv_exit(void)
221 {
222 }
223 module_exit(sdhci_pltfm_drv_exit);
224
225 MODULE_DESCRIPTION("SDHCI platform and OF driver helper");
226 MODULE_AUTHOR("Intel Corporation");
227 MODULE_LICENSE("GPL v2");