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 | |
5129dffe TP |
77 | if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) { |
78 | ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret); | |
3c4d3868 LC |
79 | dev_dbg(child->parent, "sdio read 52 addr 0x%x, byte 0x%02x\n", |
80 | addr, ((u8 *)buf)[0]); | |
5129dffe TP |
81 | } else { |
82 | if (fixed) | |
83 | ret = sdio_readsb(func, buf, addr, len); | |
84 | else | |
85 | ret = sdio_memcpy_fromio(func, buf, addr, len); | |
86 | ||
3c4d3868 LC |
87 | dev_dbg(child->parent, "sdio read 53 addr 0x%x, %zu bytes\n", |
88 | addr, len); | |
5129dffe TP |
89 | } |
90 | ||
91 | if (ret) | |
3c4d3868 | 92 | dev_err(child->parent, "sdio read failed (%d)\n", ret); |
5129dffe TP |
93 | } |
94 | ||
a390e85c | 95 | static void wl12xx_sdio_raw_write(struct device *child, int addr, void *buf, |
a3b8ea75 | 96 | size_t len, bool fixed) |
5129dffe TP |
97 | { |
98 | int ret; | |
a390e85c | 99 | struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); |
fbe936bc | 100 | struct sdio_func *func = dev_to_sdio_func(glue->dev); |
5129dffe | 101 | |
5129dffe TP |
102 | if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) { |
103 | sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret); | |
3c4d3868 LC |
104 | dev_dbg(child->parent, "sdio write 52 addr 0x%x, byte 0x%02x\n", |
105 | addr, ((u8 *)buf)[0]); | |
5129dffe | 106 | } else { |
3c4d3868 LC |
107 | dev_dbg(child->parent, "sdio write 53 addr 0x%x, %zu bytes\n", |
108 | addr, len); | |
5129dffe TP |
109 | |
110 | if (fixed) | |
111 | ret = sdio_writesb(func, addr, buf, len); | |
112 | else | |
113 | ret = sdio_memcpy_toio(func, addr, buf, len); | |
114 | } | |
49063a0d | 115 | |
5129dffe | 116 | if (ret) |
3c4d3868 | 117 | dev_err(child->parent, "sdio write failed (%d)\n", ret); |
49063a0d OBC |
118 | } |
119 | ||
a390e85c | 120 | static int wl12xx_sdio_power_on(struct wl12xx_sdio_glue *glue) |
49063a0d | 121 | { |
00cbb3c5 | 122 | int ret; |
fbe936bc | 123 | struct sdio_func *func = dev_to_sdio_func(glue->dev); |
00cbb3c5 | 124 | |
86046da4 OBC |
125 | /* If enabled, tell runtime PM not to power off the card */ |
126 | if (pm_runtime_enabled(&func->dev)) { | |
127 | ret = pm_runtime_get_sync(&func->dev); | |
a15f1c45 | 128 | if (ret < 0) |
86046da4 | 129 | goto out; |
b5d6e5f6 OBC |
130 | } else { |
131 | /* Runtime PM is disabled: power up the card manually */ | |
132 | ret = mmc_power_restore_host(func->card->host); | |
133 | if (ret < 0) | |
134 | goto out; | |
86046da4 | 135 | } |
5129dffe | 136 | |
49063a0d OBC |
137 | sdio_claim_host(func); |
138 | sdio_enable_func(func); | |
2cc78ff7 | 139 | |
00cbb3c5 OBC |
140 | out: |
141 | return ret; | |
49063a0d OBC |
142 | } |
143 | ||
a390e85c | 144 | static int wl12xx_sdio_power_off(struct wl12xx_sdio_glue *glue) |
49063a0d | 145 | { |
11251e7e | 146 | int ret; |
fbe936bc | 147 | struct sdio_func *func = dev_to_sdio_func(glue->dev); |
49063a0d | 148 | |
49063a0d OBC |
149 | sdio_disable_func(func); |
150 | sdio_release_host(func); | |
2cc78ff7 | 151 | |
b5d6e5f6 | 152 | /* Power off the card manually, even if runtime PM is enabled. */ |
11251e7e IY |
153 | ret = mmc_power_save_host(func->card->host); |
154 | if (ret < 0) | |
155 | return ret; | |
156 | ||
86046da4 OBC |
157 | /* If enabled, let runtime PM know the card is powered off */ |
158 | if (pm_runtime_enabled(&func->dev)) | |
159 | ret = pm_runtime_put_sync(&func->dev); | |
160 | ||
161 | return ret; | |
5129dffe TP |
162 | } |
163 | ||
a390e85c | 164 | static int wl12xx_sdio_set_power(struct device *child, bool enable) |
becd551c | 165 | { |
a390e85c FB |
166 | struct wl12xx_sdio_glue *glue = dev_get_drvdata(child->parent); |
167 | ||
49063a0d | 168 | if (enable) |
a390e85c | 169 | return wl12xx_sdio_power_on(glue); |
49063a0d | 170 | else |
a390e85c | 171 | return wl12xx_sdio_power_off(glue); |
becd551c TP |
172 | } |
173 | ||
5129dffe | 174 | static struct wl1271_if_operations sdio_ops = { |
a390e85c FB |
175 | .read = wl12xx_sdio_raw_read, |
176 | .write = wl12xx_sdio_raw_write, | |
177 | .power = wl12xx_sdio_set_power, | |
a81159ed | 178 | .set_block_size = wl1271_sdio_set_block_size, |
5129dffe TP |
179 | }; |
180 | ||
5129dffe TP |
181 | static int __devinit wl1271_probe(struct sdio_func *func, |
182 | const struct sdio_device_id *id) | |
183 | { | |
a390e85c | 184 | struct wl12xx_platform_data *wlan_data; |
fbe936bc | 185 | struct wl12xx_sdio_glue *glue; |
025aef8f | 186 | struct resource res[1]; |
f795ea8b | 187 | mmc_pm_flag_t mmcflags; |
fbe936bc | 188 | int ret = -ENOMEM; |
5129dffe TP |
189 | |
190 | /* We are only able to handle the wlan function */ | |
191 | if (func->num != 0x02) | |
192 | return -ENODEV; | |
193 | ||
fbe936bc FB |
194 | glue = kzalloc(sizeof(*glue), GFP_KERNEL); |
195 | if (!glue) { | |
3c4d3868 | 196 | dev_err(&func->dev, "can't allocate glue\n"); |
fbe936bc FB |
197 | goto out; |
198 | } | |
199 | ||
fbe936bc | 200 | glue->dev = &func->dev; |
5129dffe | 201 | |
5129dffe TP |
202 | /* Grab access to FN0 for ELP reg. */ |
203 | func->card->quirks |= MMC_QUIRK_LENIENT_FN0; | |
204 | ||
1d732e8c AN |
205 | /* Use block mode for transferring over one block size of data */ |
206 | func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; | |
207 | ||
09cecc34 OBC |
208 | wlan_data = wl12xx_get_platform_data(); |
209 | if (IS_ERR(wlan_data)) { | |
210 | ret = PTR_ERR(wlan_data); | |
3c4d3868 | 211 | dev_err(glue->dev, "missing wlan platform data: %d\n", ret); |
a390e85c | 212 | goto out_free_glue; |
5129dffe TP |
213 | } |
214 | ||
a390e85c FB |
215 | /* if sdio can keep power while host is suspended, enable wow */ |
216 | mmcflags = sdio_get_host_pm_caps(func); | |
3c4d3868 | 217 | dev_dbg(glue->dev, "sdio PM caps = 0x%x\n", mmcflags); |
2c0f2463 | 218 | |
a390e85c FB |
219 | if (mmcflags & MMC_PM_KEEP_POWER) |
220 | wlan_data->pwr_in_suspend = true; | |
f795ea8b | 221 | |
a390e85c | 222 | wlan_data->ops = &sdio_ops; |
5129dffe | 223 | |
fbe936bc | 224 | sdio_set_drvdata(func, glue); |
49d7f6d8 | 225 | |
00cbb3c5 OBC |
226 | /* Tell PM core that we don't need the card to be powered now */ |
227 | pm_runtime_put_noidle(&func->dev); | |
228 | ||
ccb62000 | 229 | glue->core = platform_device_alloc("wl12xx", -1); |
025aef8f | 230 | if (!glue->core) { |
3c4d3868 | 231 | dev_err(glue->dev, "can't allocate platform_device"); |
025aef8f | 232 | ret = -ENOMEM; |
a390e85c | 233 | goto out_free_glue; |
025aef8f FB |
234 | } |
235 | ||
236 | glue->core->dev.parent = &func->dev; | |
237 | ||
238 | memset(res, 0x00, sizeof(res)); | |
239 | ||
240 | res[0].start = wlan_data->irq; | |
241 | res[0].flags = IORESOURCE_IRQ; | |
242 | res[0].name = "irq"; | |
243 | ||
244 | ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res)); | |
245 | if (ret) { | |
3c4d3868 | 246 | dev_err(glue->dev, "can't add resources\n"); |
025aef8f FB |
247 | goto out_dev_put; |
248 | } | |
249 | ||
250 | ret = platform_device_add_data(glue->core, wlan_data, | |
251 | sizeof(*wlan_data)); | |
252 | if (ret) { | |
3c4d3868 | 253 | dev_err(glue->dev, "can't add platform data\n"); |
025aef8f FB |
254 | goto out_dev_put; |
255 | } | |
256 | ||
257 | ret = platform_device_add(glue->core); | |
258 | if (ret) { | |
3c4d3868 | 259 | dev_err(glue->dev, "can't add platform device\n"); |
025aef8f FB |
260 | goto out_dev_put; |
261 | } | |
5129dffe TP |
262 | return 0; |
263 | ||
025aef8f FB |
264 | out_dev_put: |
265 | platform_device_put(glue->core); | |
266 | ||
fbe936bc FB |
267 | out_free_glue: |
268 | kfree(glue); | |
a390e85c | 269 | |
fbe936bc | 270 | out: |
5129dffe TP |
271 | return ret; |
272 | } | |
273 | ||
274 | static void __devexit wl1271_remove(struct sdio_func *func) | |
275 | { | |
fbe936bc | 276 | struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func); |
5129dffe | 277 | |
00cbb3c5 OBC |
278 | /* Undo decrement done above in wl1271_probe */ |
279 | pm_runtime_get_noresume(&func->dev); | |
280 | ||
025aef8f FB |
281 | platform_device_del(glue->core); |
282 | platform_device_put(glue->core); | |
fbe936bc | 283 | kfree(glue); |
5129dffe TP |
284 | } |
285 | ||
f634a4e7 | 286 | #ifdef CONFIG_PM |
674f3058 OBC |
287 | static int wl1271_suspend(struct device *dev) |
288 | { | |
289 | /* Tell MMC/SDIO core it's OK to power down the card | |
290 | * (if it isn't already), but not to remove it completely */ | |
039bdb14 EP |
291 | struct sdio_func *func = dev_to_sdio_func(dev); |
292 | struct wl1271 *wl = sdio_get_drvdata(func); | |
293 | mmc_pm_flag_t sdio_flags; | |
294 | int ret = 0; | |
295 | ||
3c4d3868 LC |
296 | dev_dbg(dev, "wl1271 suspend. wow_enabled: %d\n", |
297 | wl->wow_enabled); | |
039bdb14 EP |
298 | |
299 | /* check whether sdio should keep power */ | |
300 | if (wl->wow_enabled) { | |
301 | sdio_flags = sdio_get_host_pm_caps(func); | |
302 | ||
303 | if (!(sdio_flags & MMC_PM_KEEP_POWER)) { | |
3c4d3868 LC |
304 | dev_err(dev, "can't keep power while host " |
305 | "is suspended\n"); | |
039bdb14 EP |
306 | ret = -EINVAL; |
307 | goto out; | |
308 | } | |
309 | ||
310 | /* keep power while host suspended */ | |
311 | ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); | |
312 | if (ret) { | |
3c4d3868 | 313 | dev_err(dev, "error while trying to keep power\n"); |
039bdb14 EP |
314 | goto out; |
315 | } | |
f44e5868 EP |
316 | |
317 | /* release host */ | |
318 | sdio_release_host(func); | |
039bdb14 EP |
319 | } |
320 | out: | |
321 | return ret; | |
674f3058 OBC |
322 | } |
323 | ||
324 | static int wl1271_resume(struct device *dev) | |
325 | { | |
f44e5868 EP |
326 | struct sdio_func *func = dev_to_sdio_func(dev); |
327 | struct wl1271 *wl = sdio_get_drvdata(func); | |
328 | ||
3c4d3868 | 329 | dev_dbg(dev, "wl1271 resume\n"); |
f44e5868 EP |
330 | if (wl->wow_enabled) { |
331 | /* claim back host */ | |
332 | sdio_claim_host(func); | |
333 | } | |
334 | ||
674f3058 OBC |
335 | return 0; |
336 | } | |
337 | ||
338 | static const struct dev_pm_ops wl1271_sdio_pm_ops = { | |
339 | .suspend = wl1271_suspend, | |
340 | .resume = wl1271_resume, | |
341 | }; | |
f634a4e7 | 342 | #endif |
674f3058 | 343 | |
5129dffe | 344 | static struct sdio_driver wl1271_sdio_driver = { |
f4b5d8d8 | 345 | .name = "wl1271_sdio", |
5129dffe TP |
346 | .id_table = wl1271_devices, |
347 | .probe = wl1271_probe, | |
348 | .remove = __devexit_p(wl1271_remove), | |
f634a4e7 | 349 | #ifdef CONFIG_PM |
674f3058 OBC |
350 | .drv = { |
351 | .pm = &wl1271_sdio_pm_ops, | |
352 | }, | |
f634a4e7 | 353 | #endif |
5129dffe TP |
354 | }; |
355 | ||
356 | static int __init wl1271_init(void) | |
357 | { | |
6bdaf796 | 358 | return sdio_register_driver(&wl1271_sdio_driver); |
5129dffe TP |
359 | } |
360 | ||
361 | static void __exit wl1271_exit(void) | |
362 | { | |
363 | sdio_unregister_driver(&wl1271_sdio_driver); | |
5129dffe TP |
364 | } |
365 | ||
366 | module_init(wl1271_init); | |
367 | module_exit(wl1271_exit); | |
368 | ||
369 | MODULE_LICENSE("GPL"); | |
5245e3a9 | 370 | MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); |
5129dffe | 371 | MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); |
c302b2c9 | 372 | MODULE_FIRMWARE(WL127X_FW_NAME); |
5aa42346 | 373 | MODULE_FIRMWARE(WL128X_FW_NAME); |