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> | |
26 | #include <linux/crc7.h> | |
27 | #include <linux/vmalloc.h> | |
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 | ||
48 | static const struct sdio_device_id wl1271_devices[] = { | |
49 | { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) }, | |
50 | {} | |
51 | }; | |
52 | MODULE_DEVICE_TABLE(sdio, wl1271_devices); | |
53 | ||
0da13da7 | 54 | static void wl1271_sdio_set_block_size(struct wl1271 *wl, unsigned int blksz) |
a81159ed | 55 | { |
a81159ed | 56 | sdio_claim_host(wl->if_priv); |
0da13da7 | 57 | sdio_set_block_size(wl->if_priv, blksz); |
a81159ed LC |
58 | sdio_release_host(wl->if_priv); |
59 | } | |
60 | ||
5129dffe TP |
61 | static inline struct sdio_func *wl_to_func(struct wl1271 *wl) |
62 | { | |
63 | return wl->if_priv; | |
64 | } | |
65 | ||
66 | static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl) | |
67 | { | |
68 | return &(wl_to_func(wl)->dev); | |
69 | } | |
70 | ||
a620865e | 71 | static irqreturn_t wl1271_hardirq(int irq, void *cookie) |
5129dffe TP |
72 | { |
73 | struct wl1271 *wl = cookie; | |
74 | unsigned long flags; | |
75 | ||
76 | wl1271_debug(DEBUG_IRQ, "IRQ"); | |
77 | ||
78 | /* complete the ELP completion */ | |
79 | spin_lock_irqsave(&wl->wl_lock, flags); | |
a620865e | 80 | set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags); |
5129dffe TP |
81 | if (wl->elp_compl) { |
82 | complete(wl->elp_compl); | |
83 | wl->elp_compl = NULL; | |
84 | } | |
f44e5868 EP |
85 | |
86 | if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) { | |
87 | /* don't enqueue a work right now. mark it as pending */ | |
88 | set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags); | |
89 | wl1271_debug(DEBUG_IRQ, "should not enqueue work"); | |
90 | disable_irq_nosync(wl->irq); | |
91 | pm_wakeup_event(wl1271_sdio_wl_to_dev(wl), 0); | |
92 | spin_unlock_irqrestore(&wl->wl_lock, flags); | |
93 | return IRQ_HANDLED; | |
94 | } | |
5129dffe TP |
95 | spin_unlock_irqrestore(&wl->wl_lock, flags); |
96 | ||
a620865e | 97 | return IRQ_WAKE_THREAD; |
5129dffe TP |
98 | } |
99 | ||
100 | static void wl1271_sdio_disable_interrupts(struct wl1271 *wl) | |
101 | { | |
102 | disable_irq(wl->irq); | |
103 | } | |
104 | ||
105 | static void wl1271_sdio_enable_interrupts(struct wl1271 *wl) | |
106 | { | |
107 | enable_irq(wl->irq); | |
108 | } | |
109 | ||
110 | static void wl1271_sdio_reset(struct wl1271 *wl) | |
111 | { | |
112 | } | |
113 | ||
114 | static void wl1271_sdio_init(struct wl1271 *wl) | |
115 | { | |
116 | } | |
117 | ||
118 | static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf, | |
a3b8ea75 | 119 | size_t len, bool fixed) |
5129dffe TP |
120 | { |
121 | int ret; | |
122 | struct sdio_func *func = wl_to_func(wl); | |
123 | ||
5129dffe TP |
124 | if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) { |
125 | ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret); | |
a3b8ea75 | 126 | wl1271_debug(DEBUG_SDIO, "sdio read 52 addr 0x%x, byte 0x%02x", |
5129dffe TP |
127 | addr, ((u8 *)buf)[0]); |
128 | } else { | |
129 | if (fixed) | |
130 | ret = sdio_readsb(func, buf, addr, len); | |
131 | else | |
132 | ret = sdio_memcpy_fromio(func, buf, addr, len); | |
133 | ||
99e50314 | 134 | wl1271_debug(DEBUG_SDIO, "sdio read 53 addr 0x%x, %zu bytes", |
5129dffe | 135 | addr, len); |
a3b8ea75 | 136 | wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len); |
5129dffe TP |
137 | } |
138 | ||
139 | if (ret) | |
140 | wl1271_error("sdio read failed (%d)", ret); | |
5129dffe TP |
141 | } |
142 | ||
143 | static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf, | |
a3b8ea75 | 144 | size_t len, bool fixed) |
5129dffe TP |
145 | { |
146 | int ret; | |
147 | struct sdio_func *func = wl_to_func(wl); | |
148 | ||
5129dffe TP |
149 | if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) { |
150 | sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret); | |
a3b8ea75 | 151 | wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x", |
5129dffe TP |
152 | addr, ((u8 *)buf)[0]); |
153 | } else { | |
99e50314 | 154 | wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes", |
5129dffe | 155 | addr, len); |
a3b8ea75 | 156 | wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len); |
5129dffe TP |
157 | |
158 | if (fixed) | |
159 | ret = sdio_writesb(func, addr, buf, len); | |
160 | else | |
161 | ret = sdio_memcpy_toio(func, addr, buf, len); | |
162 | } | |
49063a0d | 163 | |
5129dffe TP |
164 | if (ret) |
165 | wl1271_error("sdio write failed (%d)", ret); | |
49063a0d OBC |
166 | } |
167 | ||
2cc78ff7 | 168 | static int wl1271_sdio_power_on(struct wl1271 *wl) |
49063a0d OBC |
169 | { |
170 | struct sdio_func *func = wl_to_func(wl); | |
00cbb3c5 OBC |
171 | int ret; |
172 | ||
11251e7e | 173 | /* Make sure the card will not be powered off by runtime PM */ |
00cbb3c5 OBC |
174 | ret = pm_runtime_get_sync(&func->dev); |
175 | if (ret < 0) | |
176 | goto out; | |
5129dffe | 177 | |
11251e7e IY |
178 | /* Runtime PM might be disabled, so power up the card manually */ |
179 | ret = mmc_power_restore_host(func->card->host); | |
180 | if (ret < 0) | |
181 | goto out; | |
182 | ||
49063a0d OBC |
183 | sdio_claim_host(func); |
184 | sdio_enable_func(func); | |
2cc78ff7 | 185 | |
00cbb3c5 OBC |
186 | out: |
187 | return ret; | |
49063a0d OBC |
188 | } |
189 | ||
2cc78ff7 | 190 | static int wl1271_sdio_power_off(struct wl1271 *wl) |
49063a0d OBC |
191 | { |
192 | struct sdio_func *func = wl_to_func(wl); | |
11251e7e | 193 | int ret; |
49063a0d | 194 | |
49063a0d OBC |
195 | sdio_disable_func(func); |
196 | sdio_release_host(func); | |
2cc78ff7 | 197 | |
11251e7e IY |
198 | /* Runtime PM might be disabled, so power off the card manually */ |
199 | ret = mmc_power_save_host(func->card->host); | |
200 | if (ret < 0) | |
201 | return ret; | |
202 | ||
203 | /* Let runtime PM know the card is powered off */ | |
00cbb3c5 | 204 | return pm_runtime_put_sync(&func->dev); |
5129dffe TP |
205 | } |
206 | ||
2cc78ff7 | 207 | static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable) |
becd551c | 208 | { |
49063a0d | 209 | if (enable) |
2cc78ff7 | 210 | return wl1271_sdio_power_on(wl); |
49063a0d | 211 | else |
2cc78ff7 | 212 | return wl1271_sdio_power_off(wl); |
becd551c TP |
213 | } |
214 | ||
5129dffe TP |
215 | static struct wl1271_if_operations sdio_ops = { |
216 | .read = wl1271_sdio_raw_read, | |
217 | .write = wl1271_sdio_raw_write, | |
218 | .reset = wl1271_sdio_reset, | |
219 | .init = wl1271_sdio_init, | |
becd551c | 220 | .power = wl1271_sdio_set_power, |
5129dffe TP |
221 | .dev = wl1271_sdio_wl_to_dev, |
222 | .enable_irq = wl1271_sdio_enable_interrupts, | |
a81159ed LC |
223 | .disable_irq = wl1271_sdio_disable_interrupts, |
224 | .set_block_size = wl1271_sdio_set_block_size, | |
5129dffe TP |
225 | }; |
226 | ||
5129dffe TP |
227 | static int __devinit wl1271_probe(struct sdio_func *func, |
228 | const struct sdio_device_id *id) | |
229 | { | |
230 | struct ieee80211_hw *hw; | |
09cecc34 | 231 | const struct wl12xx_platform_data *wlan_data; |
5129dffe | 232 | struct wl1271 *wl; |
341b7cde | 233 | unsigned long irqflags; |
5129dffe TP |
234 | int ret; |
235 | ||
236 | /* We are only able to handle the wlan function */ | |
237 | if (func->num != 0x02) | |
238 | return -ENODEV; | |
239 | ||
240 | hw = wl1271_alloc_hw(); | |
241 | if (IS_ERR(hw)) | |
242 | return PTR_ERR(hw); | |
243 | ||
244 | wl = hw->priv; | |
245 | ||
246 | wl->if_priv = func; | |
247 | wl->if_ops = &sdio_ops; | |
248 | ||
5129dffe TP |
249 | /* Grab access to FN0 for ELP reg. */ |
250 | func->card->quirks |= MMC_QUIRK_LENIENT_FN0; | |
251 | ||
1d732e8c AN |
252 | /* Use block mode for transferring over one block size of data */ |
253 | func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; | |
254 | ||
09cecc34 OBC |
255 | wlan_data = wl12xx_get_platform_data(); |
256 | if (IS_ERR(wlan_data)) { | |
257 | ret = PTR_ERR(wlan_data); | |
258 | wl1271_error("missing wlan platform data: %d", ret); | |
5129dffe TP |
259 | goto out_free; |
260 | } | |
261 | ||
09cecc34 | 262 | wl->irq = wlan_data->irq; |
15cea993 | 263 | wl->ref_clock = wlan_data->board_ref_clock; |
5ea417ae | 264 | wl->tcxo_clock = wlan_data->board_tcxo_clock; |
341b7cde IY |
265 | wl->platform_quirks = wlan_data->platform_quirks; |
266 | ||
267 | if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ) | |
268 | irqflags = IRQF_TRIGGER_RISING; | |
269 | else | |
270 | irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT; | |
09cecc34 | 271 | |
a620865e | 272 | ret = request_threaded_irq(wl->irq, wl1271_hardirq, wl1271_irq, |
341b7cde | 273 | irqflags, |
a620865e | 274 | DRIVER_NAME, wl); |
5129dffe TP |
275 | if (ret < 0) { |
276 | wl1271_error("request_irq() failed: %d", ret); | |
277 | goto out_free; | |
278 | } | |
279 | ||
2c0f2463 | 280 | enable_irq_wake(wl->irq); |
f44e5868 | 281 | device_init_wakeup(wl1271_sdio_wl_to_dev(wl), 1); |
2c0f2463 | 282 | |
5129dffe TP |
283 | disable_irq(wl->irq); |
284 | ||
285 | ret = wl1271_init_ieee80211(wl); | |
286 | if (ret) | |
287 | goto out_irq; | |
288 | ||
289 | ret = wl1271_register_hw(wl); | |
290 | if (ret) | |
291 | goto out_irq; | |
292 | ||
49d7f6d8 TP |
293 | sdio_set_drvdata(func, wl); |
294 | ||
00cbb3c5 OBC |
295 | /* Tell PM core that we don't need the card to be powered now */ |
296 | pm_runtime_put_noidle(&func->dev); | |
297 | ||
5129dffe TP |
298 | wl1271_notice("initialized"); |
299 | ||
300 | return 0; | |
301 | ||
5129dffe TP |
302 | out_irq: |
303 | free_irq(wl->irq, wl); | |
304 | ||
5129dffe | 305 | out_free: |
3b56dd6a | 306 | wl1271_free_hw(wl); |
5129dffe TP |
307 | |
308 | return ret; | |
309 | } | |
310 | ||
311 | static void __devexit wl1271_remove(struct sdio_func *func) | |
312 | { | |
313 | struct wl1271 *wl = sdio_get_drvdata(func); | |
314 | ||
00cbb3c5 OBC |
315 | /* Undo decrement done above in wl1271_probe */ |
316 | pm_runtime_get_noresume(&func->dev); | |
317 | ||
3b56dd6a | 318 | wl1271_unregister_hw(wl); |
f44e5868 | 319 | device_init_wakeup(wl1271_sdio_wl_to_dev(wl), 0); |
2c0f2463 | 320 | disable_irq_wake(wl->irq); |
4e23b11b | 321 | free_irq(wl->irq, wl); |
801a673e | 322 | wl1271_free_hw(wl); |
5129dffe TP |
323 | } |
324 | ||
674f3058 OBC |
325 | static int wl1271_suspend(struct device *dev) |
326 | { | |
327 | /* Tell MMC/SDIO core it's OK to power down the card | |
328 | * (if it isn't already), but not to remove it completely */ | |
039bdb14 EP |
329 | struct sdio_func *func = dev_to_sdio_func(dev); |
330 | struct wl1271 *wl = sdio_get_drvdata(func); | |
331 | mmc_pm_flag_t sdio_flags; | |
332 | int ret = 0; | |
333 | ||
334 | wl1271_debug(DEBUG_MAC80211, "wl1271 suspend. wow_enabled: %d", | |
335 | wl->wow_enabled); | |
336 | ||
337 | /* check whether sdio should keep power */ | |
338 | if (wl->wow_enabled) { | |
339 | sdio_flags = sdio_get_host_pm_caps(func); | |
340 | ||
341 | if (!(sdio_flags & MMC_PM_KEEP_POWER)) { | |
342 | wl1271_error("can't keep power while host " | |
343 | "is suspended"); | |
344 | ret = -EINVAL; | |
345 | goto out; | |
346 | } | |
347 | ||
348 | /* keep power while host suspended */ | |
349 | ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); | |
350 | if (ret) { | |
351 | wl1271_error("error while trying to keep power"); | |
352 | goto out; | |
353 | } | |
f44e5868 EP |
354 | |
355 | /* release host */ | |
356 | sdio_release_host(func); | |
039bdb14 EP |
357 | } |
358 | out: | |
359 | return ret; | |
674f3058 OBC |
360 | } |
361 | ||
362 | static int wl1271_resume(struct device *dev) | |
363 | { | |
f44e5868 EP |
364 | struct sdio_func *func = dev_to_sdio_func(dev); |
365 | struct wl1271 *wl = sdio_get_drvdata(func); | |
366 | ||
367 | wl1271_debug(DEBUG_MAC80211, "wl1271 resume"); | |
368 | if (wl->wow_enabled) { | |
369 | /* claim back host */ | |
370 | sdio_claim_host(func); | |
371 | } | |
372 | ||
674f3058 OBC |
373 | return 0; |
374 | } | |
375 | ||
376 | static const struct dev_pm_ops wl1271_sdio_pm_ops = { | |
377 | .suspend = wl1271_suspend, | |
378 | .resume = wl1271_resume, | |
379 | }; | |
380 | ||
5129dffe | 381 | static struct sdio_driver wl1271_sdio_driver = { |
f4b5d8d8 | 382 | .name = "wl1271_sdio", |
5129dffe TP |
383 | .id_table = wl1271_devices, |
384 | .probe = wl1271_probe, | |
385 | .remove = __devexit_p(wl1271_remove), | |
674f3058 OBC |
386 | .drv = { |
387 | .pm = &wl1271_sdio_pm_ops, | |
388 | }, | |
5129dffe TP |
389 | }; |
390 | ||
391 | static int __init wl1271_init(void) | |
392 | { | |
393 | int ret; | |
394 | ||
395 | ret = sdio_register_driver(&wl1271_sdio_driver); | |
396 | if (ret < 0) { | |
397 | wl1271_error("failed to register sdio driver: %d", ret); | |
398 | goto out; | |
399 | } | |
400 | ||
401 | out: | |
402 | return ret; | |
403 | } | |
404 | ||
405 | static void __exit wl1271_exit(void) | |
406 | { | |
407 | sdio_unregister_driver(&wl1271_sdio_driver); | |
408 | ||
409 | wl1271_notice("unloaded"); | |
410 | } | |
411 | ||
412 | module_init(wl1271_init); | |
413 | module_exit(wl1271_exit); | |
414 | ||
415 | MODULE_LICENSE("GPL"); | |
5245e3a9 | 416 | MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); |
5129dffe TP |
417 | MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); |
418 | MODULE_FIRMWARE(WL1271_FW_NAME); | |
5aa42346 | 419 | MODULE_FIRMWARE(WL128X_FW_NAME); |
1aed55fd AN |
420 | MODULE_FIRMWARE(WL127X_AP_FW_NAME); |
421 | MODULE_FIRMWARE(WL128X_AP_FW_NAME); |