blob: 1da5f29abbcb3f6013eb04f3268cdce7ccc3028d [file] [log] [blame]
Adrian Hunterc4e05032012-11-23 21:17:34 +01001/*
2 * Secure Digital Host Controller Interface ACPI driver.
3 *
4 * Copyright (c) 2012, Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 */
20
21#include <linux/init.h>
22#include <linux/export.h>
23#include <linux/module.h>
24#include <linux/device.h>
25#include <linux/platform_device.h>
26#include <linux/ioport.h>
27#include <linux/io.h>
28#include <linux/dma-mapping.h>
29#include <linux/compiler.h>
30#include <linux/stddef.h>
31#include <linux/bitops.h>
32#include <linux/types.h>
33#include <linux/err.h>
34#include <linux/interrupt.h>
35#include <linux/acpi.h>
36#include <linux/pm.h>
37#include <linux/pm_runtime.h>
38
39#include <linux/mmc/host.h>
40#include <linux/mmc/pm.h>
41#include <linux/mmc/sdhci.h>
42
43#include "sdhci.h"
44
45enum {
46 SDHCI_ACPI_SD_CD = BIT(0),
47 SDHCI_ACPI_RUNTIME_PM = BIT(1),
48};
49
50struct sdhci_acpi_chip {
51 const struct sdhci_ops *ops;
52 unsigned int quirks;
53 unsigned int quirks2;
54 unsigned long caps;
55 unsigned int caps2;
56 mmc_pm_flag_t pm_caps;
57};
58
59struct sdhci_acpi_slot {
60 const struct sdhci_acpi_chip *chip;
61 unsigned int quirks;
62 unsigned int quirks2;
63 unsigned long caps;
64 unsigned int caps2;
65 mmc_pm_flag_t pm_caps;
66 unsigned int flags;
67};
68
69struct sdhci_acpi_host {
70 struct sdhci_host *host;
71 const struct sdhci_acpi_slot *slot;
72 struct platform_device *pdev;
73 bool use_runtime_pm;
74};
75
76static inline bool sdhci_acpi_flag(struct sdhci_acpi_host *c, unsigned int flag)
77{
78 return c->slot && (c->slot->flags & flag);
79}
80
81static int sdhci_acpi_enable_dma(struct sdhci_host *host)
82{
83 return 0;
84}
85
86static const struct sdhci_ops sdhci_acpi_ops_dflt = {
87 .enable_dma = sdhci_acpi_enable_dma,
88};
89
Adrian Huntere5571392012-12-10 21:18:48 +010090static const struct sdhci_acpi_slot sdhci_acpi_slot_int_sdio = {
91 .quirks2 = SDHCI_QUIRK2_HOST_OFF_CARD_ON,
92 .caps = MMC_CAP_NONREMOVABLE | MMC_CAP_POWER_OFF_CARD,
93 .flags = SDHCI_ACPI_RUNTIME_PM,
94 .pm_caps = MMC_PM_KEEP_POWER,
95};
96
Adrian Hunterc4e05032012-11-23 21:17:34 +010097static const struct acpi_device_id sdhci_acpi_ids[] = {
Adrian Huntere5571392012-12-10 21:18:48 +010098 { "INT33C6", (kernel_ulong_t)&sdhci_acpi_slot_int_sdio },
Adrian Hunterc4e05032012-11-23 21:17:34 +010099 { "PNP0D40" },
100 { },
101};
102MODULE_DEVICE_TABLE(acpi, sdhci_acpi_ids);
103
104static const struct sdhci_acpi_slot *sdhci_acpi_get_slot(const char *hid)
105{
106 const struct acpi_device_id *id;
107
108 for (id = sdhci_acpi_ids; id->id[0]; id++)
109 if (!strcmp(id->id, hid))
110 return (const struct sdhci_acpi_slot *)id->driver_data;
111 return NULL;
112}
113
Greg Kroah-Hartman4e608e42012-12-21 15:05:47 -0800114static int sdhci_acpi_probe(struct platform_device *pdev)
Adrian Hunterc4e05032012-11-23 21:17:34 +0100115{
116 struct device *dev = &pdev->dev;
117 acpi_handle handle = ACPI_HANDLE(dev);
118 struct acpi_device *device;
119 struct sdhci_acpi_host *c;
120 struct sdhci_host *host;
121 struct resource *iomem;
122 resource_size_t len;
123 const char *hid;
124 int err;
125
126 if (acpi_bus_get_device(handle, &device))
127 return -ENODEV;
128
129 if (acpi_bus_get_status(device) || !device->status.present)
130 return -ENODEV;
131
132 hid = acpi_device_hid(device);
133
134 iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
135 if (!iomem)
136 return -ENOMEM;
137
138 len = resource_size(iomem);
139 if (len < 0x100)
140 dev_err(dev, "Invalid iomem size!\n");
141
142 if (!devm_request_mem_region(dev, iomem->start, len, dev_name(dev)))
143 return -ENOMEM;
144
145 host = sdhci_alloc_host(dev, sizeof(struct sdhci_acpi_host));
146 if (IS_ERR(host))
147 return PTR_ERR(host);
148
149 c = sdhci_priv(host);
150 c->host = host;
151 c->slot = sdhci_acpi_get_slot(hid);
152 c->pdev = pdev;
153 c->use_runtime_pm = sdhci_acpi_flag(c, SDHCI_ACPI_RUNTIME_PM);
154
155 platform_set_drvdata(pdev, c);
156
157 host->hw_name = "ACPI";
158 host->ops = &sdhci_acpi_ops_dflt;
159 host->irq = platform_get_irq(pdev, 0);
160
161 host->ioaddr = devm_ioremap_nocache(dev, iomem->start,
162 resource_size(iomem));
163 if (host->ioaddr == NULL) {
164 err = -ENOMEM;
165 goto err_free;
166 }
167
168 if (!dev->dma_mask) {
169 u64 dma_mask;
170
171 if (sdhci_readl(host, SDHCI_CAPABILITIES) & SDHCI_CAN_64BIT) {
172 /* 64-bit DMA is not supported at present */
173 dma_mask = DMA_BIT_MASK(32);
174 } else {
175 dma_mask = DMA_BIT_MASK(32);
176 }
177
178 dev->dma_mask = &dev->coherent_dma_mask;
179 dev->coherent_dma_mask = dma_mask;
180 }
181
182 if (c->slot) {
183 if (c->slot->chip) {
184 host->ops = c->slot->chip->ops;
185 host->quirks |= c->slot->chip->quirks;
186 host->quirks2 |= c->slot->chip->quirks2;
187 host->mmc->caps |= c->slot->chip->caps;
188 host->mmc->caps2 |= c->slot->chip->caps2;
189 host->mmc->pm_caps |= c->slot->chip->pm_caps;
190 }
191 host->quirks |= c->slot->quirks;
192 host->quirks2 |= c->slot->quirks2;
193 host->mmc->caps |= c->slot->caps;
194 host->mmc->caps2 |= c->slot->caps2;
195 host->mmc->pm_caps |= c->slot->pm_caps;
196 }
197
Adrian Hunter0d3e3352013-04-04 16:41:06 +0300198 host->mmc->caps2 |= MMC_CAP2_NO_PRESCAN_POWERUP;
199
Adrian Hunterc4e05032012-11-23 21:17:34 +0100200 err = sdhci_add_host(host);
201 if (err)
202 goto err_free;
203
204 if (c->use_runtime_pm) {
Adrian Hunter1d1ff452013-04-26 11:27:21 +0300205 pm_runtime_set_active(dev);
Adrian Hunterc4e05032012-11-23 21:17:34 +0100206 pm_suspend_ignore_children(dev, 1);
207 pm_runtime_set_autosuspend_delay(dev, 50);
208 pm_runtime_use_autosuspend(dev);
209 pm_runtime_enable(dev);
210 }
211
212 return 0;
213
214err_free:
215 platform_set_drvdata(pdev, NULL);
216 sdhci_free_host(c->host);
217 return err;
218}
219
Greg Kroah-Hartman4e608e42012-12-21 15:05:47 -0800220static int sdhci_acpi_remove(struct platform_device *pdev)
Adrian Hunterc4e05032012-11-23 21:17:34 +0100221{
222 struct sdhci_acpi_host *c = platform_get_drvdata(pdev);
223 struct device *dev = &pdev->dev;
224 int dead;
225
226 if (c->use_runtime_pm) {
227 pm_runtime_get_sync(dev);
228 pm_runtime_disable(dev);
229 pm_runtime_put_noidle(dev);
230 }
231
232 dead = (sdhci_readl(c->host, SDHCI_INT_STATUS) == ~0);
233 sdhci_remove_host(c->host, dead);
234 platform_set_drvdata(pdev, NULL);
235 sdhci_free_host(c->host);
236
237 return 0;
238}
239
240#ifdef CONFIG_PM_SLEEP
241
242static int sdhci_acpi_suspend(struct device *dev)
243{
244 struct sdhci_acpi_host *c = dev_get_drvdata(dev);
245
246 return sdhci_suspend_host(c->host);
247}
248
249static int sdhci_acpi_resume(struct device *dev)
250{
251 struct sdhci_acpi_host *c = dev_get_drvdata(dev);
252
253 return sdhci_resume_host(c->host);
254}
255
256#else
257
258#define sdhci_acpi_suspend NULL
259#define sdhci_acpi_resume NULL
260
261#endif
262
263#ifdef CONFIG_PM_RUNTIME
264
265static int sdhci_acpi_runtime_suspend(struct device *dev)
266{
267 struct sdhci_acpi_host *c = dev_get_drvdata(dev);
268
269 return sdhci_runtime_suspend_host(c->host);
270}
271
272static int sdhci_acpi_runtime_resume(struct device *dev)
273{
274 struct sdhci_acpi_host *c = dev_get_drvdata(dev);
275
276 return sdhci_runtime_resume_host(c->host);
277}
278
279static int sdhci_acpi_runtime_idle(struct device *dev)
280{
281 return 0;
282}
283
284#else
285
286#define sdhci_acpi_runtime_suspend NULL
287#define sdhci_acpi_runtime_resume NULL
288#define sdhci_acpi_runtime_idle NULL
289
290#endif
291
292static const struct dev_pm_ops sdhci_acpi_pm_ops = {
293 .suspend = sdhci_acpi_suspend,
294 .resume = sdhci_acpi_resume,
295 .runtime_suspend = sdhci_acpi_runtime_suspend,
296 .runtime_resume = sdhci_acpi_runtime_resume,
297 .runtime_idle = sdhci_acpi_runtime_idle,
298};
299
300static struct platform_driver sdhci_acpi_driver = {
301 .driver = {
302 .name = "sdhci-acpi",
303 .owner = THIS_MODULE,
304 .acpi_match_table = sdhci_acpi_ids,
305 .pm = &sdhci_acpi_pm_ops,
306 },
307 .probe = sdhci_acpi_probe,
Greg Kroah-Hartman4e608e42012-12-21 15:05:47 -0800308 .remove = sdhci_acpi_remove,
Adrian Hunterc4e05032012-11-23 21:17:34 +0100309};
310
311module_platform_driver(sdhci_acpi_driver);
312
313MODULE_DESCRIPTION("Secure Digital Host Controller Interface ACPI driver");
314MODULE_AUTHOR("Adrian Hunter");
315MODULE_LICENSE("GPL v2");