Commit | Line | Data |
---|---|---|
5129dffe TP |
1 | /* |
2 | * This file is part of wl1271 | |
3 | * | |
4 | * Copyright (C) 2009-2010 Nokia Corporation | |
5 | * | |
6 | * Contact: Luciano Coelho <luciano.coelho@nokia.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License | |
10 | * version 2 as published by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | |
20 | * 02110-1301 USA | |
21 | * | |
22 | */ | |
23 | ||
24 | #include <linux/irq.h> | |
25 | #include <linux/module.h> | |
5129dffe | 26 | #include <linux/vmalloc.h> |
025aef8f | 27 | #include <linux/platform_device.h> |
5129dffe TP |
28 | #include <linux/mmc/sdio_func.h> |
29 | #include <linux/mmc/sdio_ids.h> | |
30 | #include <linux/mmc/card.h> | |
11251e7e | 31 | #include <linux/mmc/host.h> |
19b87173 | 32 | #include <linux/gpio.h> |
09cecc34 | 33 | #include <linux/wl12xx.h> |
00cbb3c5 | 34 | #include <linux/pm_runtime.h> |
5129dffe | 35 | |
00d20100 | 36 | #include "wl12xx.h" |
5129dffe | 37 | #include "wl12xx_80211.h" |
00d20100 | 38 | #include "io.h" |
5129dffe | 39 | |
5129dffe TP |
40 | #ifndef SDIO_VENDOR_ID_TI |
41 | #define SDIO_VENDOR_ID_TI 0x0097 | |
42 | #endif | |
43 | ||
44 | #ifndef SDIO_DEVICE_ID_TI_WL1271 | |
45 | #define SDIO_DEVICE_ID_TI_WL1271 0x4076 | |
46 | #endif | |
47 | ||
fbe936bc FB |
48 | struct wl12xx_sdio_glue { |
49 | struct device *dev; | |
025aef8f | 50 | struct platform_device *core; |
fbe936bc FB |
51 | }; |
52 | ||
33dd74c7 | 53 | static const struct sdio_device_id wl1271_devices[] __devinitconst = { |
5129dffe TP |
54 | { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) }, |
55 | {} | |
56 | }; | |
57 | MODULE_DEVICE_TABLE(sdio, wl1271_devices); | |
58 | ||
a390e85c FB |
59 | static void wl1271_sdio_set_block_size(struct device *child, |
60 | unsigned int blksz) | |
a81159ed | 61 | { |
a390e85c FB |
62 | struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); |
63 | struct sdio_func *func = dev_to_sdio_func(glue->dev); | |
5129dffe | 64 | |
a390e85c FB |
65 | sdio_claim_host(func); |
66 | sdio_set_block_size(func, blksz); | |
67 | sdio_release_host(func); | |
5129dffe TP |
68 | } |
69 | ||
a390e85c | 70 | static void wl12xx_sdio_raw_read(struct device *child, int addr, void *buf, |
a3b8ea75 | 71 | size_t len, bool fixed) |
5129dffe TP |
72 | { |
73 | int ret; | |
a390e85c | 74 | struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); |
fbe936bc | 75 | struct sdio_func *func = dev_to_sdio_func(glue->dev); |
5129dffe | 76 | |
b4748306 EP |
77 | sdio_claim_host(func); |
78 | ||
5129dffe TP |
79 | if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) { |
80 | ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret); | |
3c4d3868 LC |
81 | dev_dbg(child->parent, "sdio read 52 addr 0x%x, byte 0x%02x\n", |
82 | addr, ((u8 *)buf)[0]); | |
5129dffe TP |
83 | } else { |
84 | if (fixed) | |
85 | ret = sdio_readsb(func, buf, addr, len); | |
86 | else | |
87 | ret = sdio_memcpy_fromio(func, buf, addr, len); | |
88 | ||
3c4d3868 LC |
89 | dev_dbg(child->parent, "sdio read 53 addr 0x%x, %zu bytes\n", |
90 | addr, len); | |
5129dffe TP |
91 | } |
92 | ||
b4748306 EP |
93 | sdio_release_host(func); |
94 | ||
5129dffe | 95 | if (ret) |
3c4d3868 | 96 | dev_err(child->parent, "sdio read failed (%d)\n", ret); |
5129dffe TP |
97 | } |
98 | ||
a390e85c | 99 | static void wl12xx_sdio_raw_write(struct device *child, int addr, void *buf, |
a3b8ea75 | 100 | size_t len, bool fixed) |
5129dffe TP |
101 | { |
102 | int ret; | |
a390e85c | 103 | struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); |
fbe936bc | 104 | struct sdio_func *func = dev_to_sdio_func(glue->dev); |
5129dffe | 105 | |
b4748306 EP |
106 | sdio_claim_host(func); |
107 | ||
5129dffe TP |
108 | if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) { |
109 | sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret); | |
3c4d3868 LC |
110 | dev_dbg(child->parent, "sdio write 52 addr 0x%x, byte 0x%02x\n", |
111 | addr, ((u8 *)buf)[0]); | |
5129dffe | 112 | } else { |
3c4d3868 LC |
113 | dev_dbg(child->parent, "sdio write 53 addr 0x%x, %zu bytes\n", |
114 | addr, len); | |
5129dffe TP |
115 | |
116 | if (fixed) | |
117 | ret = sdio_writesb(func, addr, buf, len); | |
118 | else | |
119 | ret = sdio_memcpy_toio(func, addr, buf, len); | |
120 | } | |
49063a0d | 121 | |
b4748306 EP |
122 | sdio_release_host(func); |
123 | ||
5129dffe | 124 | if (ret) |
3c4d3868 | 125 | dev_err(child->parent, "sdio write failed (%d)\n", ret); |
49063a0d OBC |
126 | } |
127 | ||
a390e85c | 128 | static int wl12xx_sdio_power_on(struct wl12xx_sdio_glue *glue) |
49063a0d | 129 | { |
00cbb3c5 | 130 | int ret; |
fbe936bc | 131 | struct sdio_func *func = dev_to_sdio_func(glue->dev); |
00cbb3c5 | 132 | |
86046da4 OBC |
133 | /* If enabled, tell runtime PM not to power off the card */ |
134 | if (pm_runtime_enabled(&func->dev)) { | |
135 | ret = pm_runtime_get_sync(&func->dev); | |
a15f1c45 | 136 | if (ret < 0) |
86046da4 | 137 | goto out; |
b5d6e5f6 OBC |
138 | } else { |
139 | /* Runtime PM is disabled: power up the card manually */ | |
140 | ret = mmc_power_restore_host(func->card->host); | |
141 | if (ret < 0) | |
142 | goto out; | |
86046da4 | 143 | } |
5129dffe | 144 | |
49063a0d OBC |
145 | sdio_claim_host(func); |
146 | sdio_enable_func(func); | |
b4748306 | 147 | sdio_release_host(func); |
2cc78ff7 | 148 | |
00cbb3c5 OBC |
149 | out: |
150 | return ret; | |
49063a0d OBC |
151 | } |
152 | ||
a390e85c | 153 | static int wl12xx_sdio_power_off(struct wl12xx_sdio_glue *glue) |
49063a0d | 154 | { |
11251e7e | 155 | int ret; |
fbe936bc | 156 | struct sdio_func *func = dev_to_sdio_func(glue->dev); |
49063a0d | 157 | |
b4748306 | 158 | sdio_claim_host(func); |
49063a0d OBC |
159 | sdio_disable_func(func); |
160 | sdio_release_host(func); | |
2cc78ff7 | 161 | |
b5d6e5f6 | 162 | /* Power off the card manually, even if runtime PM is enabled. */ |
11251e7e IY |
163 | ret = mmc_power_save_host(func->card->host); |
164 | if (ret < 0) | |
165 | return ret; | |
166 | ||
86046da4 OBC |
167 | /* If enabled, let runtime PM know the card is powered off */ |
168 | if (pm_runtime_enabled(&func->dev)) | |
169 | ret = pm_runtime_put_sync(&func->dev); | |
170 | ||
171 | return ret; | |
5129dffe TP |
172 | } |
173 | ||
a390e85c | 174 | static int wl12xx_sdio_set_power(struct device *child, bool enable) |
becd551c | 175 | { |
a390e85c FB |
176 | struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); |
177 | ||
49063a0d | 178 | if (enable) |
a390e85c | 179 | return wl12xx_sdio_power_on(glue); |
49063a0d | 180 | else |
a390e85c | 181 | return wl12xx_sdio_power_off(glue); |
becd551c TP |
182 | } |
183 | ||
5129dffe | 184 | static struct wl1271_if_operations sdio_ops = { |
a390e85c FB |
185 | .read = wl12xx_sdio_raw_read, |
186 | .write = wl12xx_sdio_raw_write, | |
187 | .power = wl12xx_sdio_set_power, | |
a81159ed | 188 | .set_block_size = wl1271_sdio_set_block_size, |
5129dffe TP |
189 | }; |
190 | ||
5129dffe TP |
191 | static int __devinit wl1271_probe(struct sdio_func *func, |
192 | const struct sdio_device_id *id) | |
193 | { | |
a390e85c | 194 | struct wl12xx_platform_data *wlan_data; |
fbe936bc | 195 | struct wl12xx_sdio_glue *glue; |
025aef8f | 196 | struct resource res[1]; |
f795ea8b | 197 | mmc_pm_flag_t mmcflags; |
fbe936bc | 198 | int ret = -ENOMEM; |
5129dffe TP |
199 | |
200 | /* We are only able to handle the wlan function */ | |
201 | if (func->num != 0x02) | |
202 | return -ENODEV; | |
203 | ||
fbe936bc FB |
204 | glue = kzalloc(sizeof(*glue), GFP_KERNEL); |
205 | if (!glue) { | |
3c4d3868 | 206 | dev_err(&func->dev, "can't allocate glue\n"); |
fbe936bc FB |
207 | goto out; |
208 | } | |
209 | ||
fbe936bc | 210 | glue->dev = &func->dev; |
5129dffe | 211 | |
5129dffe TP |
212 | /* Grab access to FN0 for ELP reg. */ |
213 | func->card->quirks |= MMC_QUIRK_LENIENT_FN0; | |
214 | ||
1d732e8c AN |
215 | /* Use block mode for transferring over one block size of data */ |
216 | func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; | |
217 | ||
09cecc34 OBC |
218 | wlan_data = wl12xx_get_platform_data(); |
219 | if (IS_ERR(wlan_data)) { | |
220 | ret = PTR_ERR(wlan_data); | |
3c4d3868 | 221 | dev_err(glue->dev, "missing wlan platform data: %d\n", ret); |
a390e85c | 222 | goto out_free_glue; |
5129dffe TP |
223 | } |
224 | ||
a390e85c FB |
225 | /* if sdio can keep power while host is suspended, enable wow */ |
226 | mmcflags = sdio_get_host_pm_caps(func); | |
3c4d3868 | 227 | dev_dbg(glue->dev, "sdio PM caps = 0x%x\n", mmcflags); |
2c0f2463 | 228 | |
a390e85c FB |
229 | if (mmcflags & MMC_PM_KEEP_POWER) |
230 | wlan_data->pwr_in_suspend = true; | |
f795ea8b | 231 | |
a390e85c | 232 | wlan_data->ops = &sdio_ops; |
5129dffe | 233 | |
fbe936bc | 234 | sdio_set_drvdata(func, glue); |
49d7f6d8 | 235 | |
00cbb3c5 OBC |
236 | /* Tell PM core that we don't need the card to be powered now */ |
237 | pm_runtime_put_noidle(&func->dev); | |
238 | ||
ccb62000 | 239 | glue->core = platform_device_alloc("wl12xx", -1); |
025aef8f | 240 | if (!glue->core) { |
3c4d3868 | 241 | dev_err(glue->dev, "can't allocate platform_device"); |
025aef8f | 242 | ret = -ENOMEM; |
a390e85c | 243 | goto out_free_glue; |
025aef8f FB |
244 | } |
245 | ||
246 | glue->core->dev.parent = &func->dev; | |
247 | ||
248 | memset(res, 0x00, sizeof(res)); | |
249 | ||
250 | res[0].start = wlan_data->irq; | |
251 | res[0].flags = IORESOURCE_IRQ; | |
252 | res[0].name = "irq"; | |
253 | ||
254 | ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res)); | |
255 | if (ret) { | |
3c4d3868 | 256 | dev_err(glue->dev, "can't add resources\n"); |
025aef8f FB |
257 | goto out_dev_put; |
258 | } | |
259 | ||
260 | ret = platform_device_add_data(glue->core, wlan_data, | |
261 | sizeof(*wlan_data)); | |
262 | if (ret) { | |
3c4d3868 | 263 | dev_err(glue->dev, "can't add platform data\n"); |
025aef8f FB |
264 | goto out_dev_put; |
265 | } | |
266 | ||
267 | ret = platform_device_add(glue->core); | |
268 | if (ret) { | |
3c4d3868 | 269 | dev_err(glue->dev, "can't add platform device\n"); |
025aef8f FB |
270 | goto out_dev_put; |
271 | } | |
5129dffe TP |
272 | return 0; |
273 | ||
025aef8f FB |
274 | out_dev_put: |
275 | platform_device_put(glue->core); | |
276 | ||
fbe936bc FB |
277 | out_free_glue: |
278 | kfree(glue); | |
a390e85c | 279 | |
fbe936bc | 280 | out: |
5129dffe TP |
281 | return ret; |
282 | } | |
283 | ||
284 | static void __devexit wl1271_remove(struct sdio_func *func) | |
285 | { | |
fbe936bc | 286 | struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func); |
5129dffe | 287 | |
00cbb3c5 OBC |
288 | /* Undo decrement done above in wl1271_probe */ |
289 | pm_runtime_get_noresume(&func->dev); | |
290 | ||
025aef8f FB |
291 | platform_device_del(glue->core); |
292 | platform_device_put(glue->core); | |
fbe936bc | 293 | kfree(glue); |
5129dffe TP |
294 | } |
295 | ||
f634a4e7 | 296 | #ifdef CONFIG_PM |
674f3058 OBC |
297 | static int wl1271_suspend(struct device *dev) |
298 | { | |
299 | /* Tell MMC/SDIO core it's OK to power down the card | |
300 | * (if it isn't already), but not to remove it completely */ | |
039bdb14 | 301 | struct sdio_func *func = dev_to_sdio_func(dev); |
b6932894 ES |
302 | struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func); |
303 | struct wl1271 *wl = platform_get_drvdata(glue->core); | |
039bdb14 EP |
304 | mmc_pm_flag_t sdio_flags; |
305 | int ret = 0; | |
306 | ||
3c4d3868 LC |
307 | dev_dbg(dev, "wl1271 suspend. wow_enabled: %d\n", |
308 | wl->wow_enabled); | |
039bdb14 EP |
309 | |
310 | /* check whether sdio should keep power */ | |
311 | if (wl->wow_enabled) { | |
312 | sdio_flags = sdio_get_host_pm_caps(func); | |
313 | ||
314 | if (!(sdio_flags & MMC_PM_KEEP_POWER)) { | |
3c4d3868 LC |
315 | dev_err(dev, "can't keep power while host " |
316 | "is suspended\n"); | |
039bdb14 EP |
317 | ret = -EINVAL; |
318 | goto out; | |
319 | } | |
320 | ||
321 | /* keep power while host suspended */ | |
322 | ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); | |
323 | if (ret) { | |
3c4d3868 | 324 | dev_err(dev, "error while trying to keep power\n"); |
039bdb14 EP |
325 | goto out; |
326 | } | |
327 | } | |
328 | out: | |
329 | return ret; | |
674f3058 OBC |
330 | } |
331 | ||
332 | static int wl1271_resume(struct device *dev) | |
333 | { | |
3c4d3868 | 334 | dev_dbg(dev, "wl1271 resume\n"); |
f44e5868 | 335 | |
674f3058 OBC |
336 | return 0; |
337 | } | |
338 | ||
339 | static const struct dev_pm_ops wl1271_sdio_pm_ops = { | |
340 | .suspend = wl1271_suspend, | |
341 | .resume = wl1271_resume, | |
342 | }; | |
f634a4e7 | 343 | #endif |
674f3058 | 344 | |
5129dffe | 345 | static struct sdio_driver wl1271_sdio_driver = { |
f4b5d8d8 | 346 | .name = "wl1271_sdio", |
5129dffe TP |
347 | .id_table = wl1271_devices, |
348 | .probe = wl1271_probe, | |
349 | .remove = __devexit_p(wl1271_remove), | |
f634a4e7 | 350 | #ifdef CONFIG_PM |
674f3058 OBC |
351 | .drv = { |
352 | .pm = &wl1271_sdio_pm_ops, | |
353 | }, | |
f634a4e7 | 354 | #endif |
5129dffe TP |
355 | }; |
356 | ||
357 | static int __init wl1271_init(void) | |
358 | { | |
6bdaf796 | 359 | return sdio_register_driver(&wl1271_sdio_driver); |
5129dffe TP |
360 | } |
361 | ||
362 | static void __exit wl1271_exit(void) | |
363 | { | |
364 | sdio_unregister_driver(&wl1271_sdio_driver); | |
5129dffe TP |
365 | } |
366 | ||
367 | module_init(wl1271_init); | |
368 | module_exit(wl1271_exit); | |
369 | ||
370 | MODULE_LICENSE("GPL"); | |
5245e3a9 | 371 | MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); |
5129dffe | 372 | MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); |
c302b2c9 | 373 | MODULE_FIRMWARE(WL127X_FW_NAME); |
5aa42346 | 374 | MODULE_FIRMWARE(WL128X_FW_NAME); |