Commit | Line | Data |
---|---|---|
3ec410d7 BC |
1 | /* |
2 | * wl12xx SDIO routines | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, but | |
9 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
11 | * General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * along with this program; if not, write to the Free Software | |
15 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | |
16 | * 02110-1301 USA | |
17 | * | |
18 | * Copyright (C) 2005 Texas Instruments Incorporated | |
19 | * Copyright (C) 2008 Google Inc | |
20 | * Copyright (C) 2009 Bob Copeland (me@bobcopeland.com) | |
21 | */ | |
a6b7a407 | 22 | #include <linux/interrupt.h> |
3ec410d7 | 23 | #include <linux/module.h> |
3ec410d7 | 24 | #include <linux/mod_devicetable.h> |
3ec410d7 BC |
25 | #include <linux/mmc/sdio_func.h> |
26 | #include <linux/mmc/sdio_ids.h> | |
8c00b39f | 27 | #include <linux/platform_device.h> |
c1f9a095 | 28 | #include <linux/wl12xx.h> |
a02a2956 | 29 | #include <linux/irq.h> |
1d4b89f2 | 30 | #include <linux/pm_runtime.h> |
3ec410d7 BC |
31 | |
32 | #include "wl1251.h" | |
3ec410d7 BC |
33 | |
34 | #ifndef SDIO_VENDOR_ID_TI | |
35 | #define SDIO_VENDOR_ID_TI 0x104c | |
36 | #endif | |
37 | ||
38 | #ifndef SDIO_DEVICE_ID_TI_WL1251 | |
39 | #define SDIO_DEVICE_ID_TI_WL1251 0x9066 | |
40 | #endif | |
41 | ||
832c10fd GI |
42 | struct wl1251_sdio { |
43 | struct sdio_func *func; | |
44 | u32 elp_val; | |
45 | }; | |
46 | ||
3ec410d7 BC |
47 | static struct sdio_func *wl_to_func(struct wl1251 *wl) |
48 | { | |
832c10fd GI |
49 | struct wl1251_sdio *wl_sdio = wl->if_priv; |
50 | return wl_sdio->func; | |
3ec410d7 BC |
51 | } |
52 | ||
53 | static void wl1251_sdio_interrupt(struct sdio_func *func) | |
54 | { | |
b5ed9c1b BC |
55 | struct wl1251 *wl = sdio_get_drvdata(func); |
56 | ||
57 | wl1251_debug(DEBUG_IRQ, "IRQ"); | |
58 | ||
59 | /* FIXME should be synchronous for sdio */ | |
16e711f9 | 60 | ieee80211_queue_work(wl->hw, &wl->irq_work); |
3ec410d7 BC |
61 | } |
62 | ||
63 | static const struct sdio_device_id wl1251_devices[] = { | |
64 | { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) }, | |
65 | {} | |
66 | }; | |
67 | MODULE_DEVICE_TABLE(sdio, wl1251_devices); | |
68 | ||
69 | ||
3c9cb9c3 GI |
70 | static void wl1251_sdio_read(struct wl1251 *wl, int addr, |
71 | void *buf, size_t len) | |
3ec410d7 BC |
72 | { |
73 | int ret; | |
74 | struct sdio_func *func = wl_to_func(wl); | |
75 | ||
76 | sdio_claim_host(func); | |
77 | ret = sdio_memcpy_fromio(func, buf, addr, len); | |
78 | if (ret) | |
79 | wl1251_error("sdio read failed (%d)", ret); | |
80 | sdio_release_host(func); | |
81 | } | |
82 | ||
3c9cb9c3 GI |
83 | static void wl1251_sdio_write(struct wl1251 *wl, int addr, |
84 | void *buf, size_t len) | |
3ec410d7 BC |
85 | { |
86 | int ret; | |
87 | struct sdio_func *func = wl_to_func(wl); | |
88 | ||
89 | sdio_claim_host(func); | |
90 | ret = sdio_memcpy_toio(func, addr, buf, len); | |
91 | if (ret) | |
92 | wl1251_error("sdio write failed (%d)", ret); | |
93 | sdio_release_host(func); | |
94 | } | |
95 | ||
3f9e750d GI |
96 | static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val) |
97 | { | |
98 | int ret = 0; | |
832c10fd GI |
99 | struct wl1251_sdio *wl_sdio = wl->if_priv; |
100 | struct sdio_func *func = wl_sdio->func; | |
101 | ||
102 | /* | |
103 | * The hardware only supports RAW (read after write) access for | |
104 | * reading, regular sdio_readb won't work here (it interprets | |
105 | * the unused bits of CMD52 as write data even if we send read | |
106 | * request). | |
107 | */ | |
3f9e750d | 108 | sdio_claim_host(func); |
832c10fd | 109 | *val = sdio_writeb_readb(func, wl_sdio->elp_val, addr, &ret); |
3f9e750d GI |
110 | sdio_release_host(func); |
111 | ||
112 | if (ret) | |
113 | wl1251_error("sdio_readb failed (%d)", ret); | |
114 | } | |
115 | ||
116 | static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val) | |
117 | { | |
118 | int ret = 0; | |
832c10fd GI |
119 | struct wl1251_sdio *wl_sdio = wl->if_priv; |
120 | struct sdio_func *func = wl_sdio->func; | |
3f9e750d GI |
121 | |
122 | sdio_claim_host(func); | |
123 | sdio_writeb(func, val, addr, &ret); | |
124 | sdio_release_host(func); | |
125 | ||
126 | if (ret) | |
127 | wl1251_error("sdio_writeb failed (%d)", ret); | |
832c10fd GI |
128 | else |
129 | wl_sdio->elp_val = val; | |
3f9e750d GI |
130 | } |
131 | ||
3c9cb9c3 | 132 | static void wl1251_sdio_reset(struct wl1251 *wl) |
3ec410d7 BC |
133 | { |
134 | } | |
135 | ||
b5ed9c1b BC |
136 | static void wl1251_sdio_enable_irq(struct wl1251 *wl) |
137 | { | |
138 | struct sdio_func *func = wl_to_func(wl); | |
139 | ||
140 | sdio_claim_host(func); | |
141 | sdio_claim_irq(func, wl1251_sdio_interrupt); | |
142 | sdio_release_host(func); | |
143 | } | |
144 | ||
145 | static void wl1251_sdio_disable_irq(struct wl1251 *wl) | |
146 | { | |
147 | struct sdio_func *func = wl_to_func(wl); | |
148 | ||
149 | sdio_claim_host(func); | |
150 | sdio_release_irq(func); | |
151 | sdio_release_host(func); | |
152 | } | |
153 | ||
a02a2956 GI |
154 | /* Interrupts when using dedicated WLAN_IRQ pin */ |
155 | static irqreturn_t wl1251_line_irq(int irq, void *cookie) | |
156 | { | |
157 | struct wl1251 *wl = cookie; | |
158 | ||
159 | ieee80211_queue_work(wl->hw, &wl->irq_work); | |
160 | ||
161 | return IRQ_HANDLED; | |
162 | } | |
163 | ||
164 | static void wl1251_enable_line_irq(struct wl1251 *wl) | |
165 | { | |
166 | return enable_irq(wl->irq); | |
167 | } | |
168 | ||
169 | static void wl1251_disable_line_irq(struct wl1251 *wl) | |
170 | { | |
171 | return disable_irq(wl->irq); | |
172 | } | |
173 | ||
cb7bbc7a | 174 | static int wl1251_sdio_set_power(struct wl1251 *wl, bool enable) |
3ec410d7 | 175 | { |
1d4b89f2 GI |
176 | struct sdio_func *func = wl_to_func(wl); |
177 | int ret; | |
cb7bbc7a | 178 | |
1d4b89f2 GI |
179 | if (enable) { |
180 | /* | |
181 | * Power is controlled by runtime PM, but we still call board | |
182 | * callback in case it wants to do any additional setup, | |
183 | * for example enabling clock buffer for the module. | |
184 | */ | |
185 | if (wl->set_power) | |
186 | wl->set_power(true); | |
187 | ||
188 | ret = pm_runtime_get_sync(&func->dev); | |
189 | if (ret < 0) | |
190 | goto out; | |
191 | ||
192 | sdio_claim_host(func); | |
193 | sdio_enable_func(func); | |
194 | sdio_release_host(func); | |
195 | } else { | |
196 | sdio_claim_host(func); | |
197 | sdio_disable_func(func); | |
198 | sdio_release_host(func); | |
199 | ||
200 | ret = pm_runtime_put_sync(&func->dev); | |
201 | if (ret < 0) | |
202 | goto out; | |
203 | ||
204 | if (wl->set_power) | |
205 | wl->set_power(false); | |
206 | } | |
207 | ||
208 | out: | |
209 | return ret; | |
3ec410d7 BC |
210 | } |
211 | ||
a02a2956 | 212 | static struct wl1251_if_operations wl1251_sdio_ops = { |
3ec410d7 BC |
213 | .read = wl1251_sdio_read, |
214 | .write = wl1251_sdio_write, | |
3f9e750d GI |
215 | .write_elp = wl1251_sdio_write_elp, |
216 | .read_elp = wl1251_sdio_read_elp, | |
3ec410d7 | 217 | .reset = wl1251_sdio_reset, |
cb7bbc7a | 218 | .power = wl1251_sdio_set_power, |
3ec410d7 BC |
219 | }; |
220 | ||
3c9cb9c3 GI |
221 | static int wl1251_sdio_probe(struct sdio_func *func, |
222 | const struct sdio_device_id *id) | |
3ec410d7 BC |
223 | { |
224 | int ret; | |
225 | struct wl1251 *wl; | |
226 | struct ieee80211_hw *hw; | |
832c10fd | 227 | struct wl1251_sdio *wl_sdio; |
e4b3fdb8 | 228 | const struct wl12xx_platform_data *wl12xx_board_data; |
3ec410d7 BC |
229 | |
230 | hw = wl1251_alloc_hw(); | |
231 | if (IS_ERR(hw)) | |
232 | return PTR_ERR(hw); | |
233 | ||
234 | wl = hw->priv; | |
235 | ||
832c10fd GI |
236 | wl_sdio = kzalloc(sizeof(*wl_sdio), GFP_KERNEL); |
237 | if (wl_sdio == NULL) { | |
238 | ret = -ENOMEM; | |
239 | goto out_free_hw; | |
240 | } | |
241 | ||
3ec410d7 BC |
242 | sdio_claim_host(func); |
243 | ret = sdio_enable_func(func); | |
244 | if (ret) | |
245 | goto release; | |
246 | ||
247 | sdio_set_block_size(func, 512); | |
a02a2956 | 248 | sdio_release_host(func); |
3ec410d7 BC |
249 | |
250 | SET_IEEE80211_DEV(hw, &func->dev); | |
832c10fd GI |
251 | wl_sdio->func = func; |
252 | wl->if_priv = wl_sdio; | |
3ec410d7 | 253 | wl->if_ops = &wl1251_sdio_ops; |
3ec410d7 | 254 | |
e4b3fdb8 | 255 | wl12xx_board_data = wl12xx_get_platform_data(); |
ae29fbb1 | 256 | if (!IS_ERR(wl12xx_board_data)) { |
8c00b39f | 257 | wl->set_power = wl12xx_board_data->set_power; |
a02a2956 | 258 | wl->irq = wl12xx_board_data->irq; |
8c00b39f GI |
259 | wl->use_eeprom = wl12xx_board_data->use_eeprom; |
260 | } | |
261 | ||
a02a2956 GI |
262 | if (wl->irq) { |
263 | ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl); | |
264 | if (ret < 0) { | |
265 | wl1251_error("request_irq() failed: %d", ret); | |
266 | goto disable; | |
267 | } | |
268 | ||
dced35ae | 269 | irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING); |
a02a2956 GI |
270 | disable_irq(wl->irq); |
271 | ||
272 | wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq; | |
273 | wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq; | |
274 | ||
275 | wl1251_info("using dedicated interrupt line"); | |
276 | } else { | |
277 | wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq; | |
278 | wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq; | |
279 | ||
280 | wl1251_info("using SDIO interrupt"); | |
281 | } | |
282 | ||
3ec410d7 | 283 | ret = wl1251_init_ieee80211(wl); |
3ec410d7 | 284 | if (ret) |
a02a2956 | 285 | goto out_free_irq; |
3ec410d7 | 286 | |
3ec410d7 | 287 | sdio_set_drvdata(func, wl); |
1d4b89f2 GI |
288 | |
289 | /* Tell PM core that we don't need the card to be powered now */ | |
290 | pm_runtime_put_noidle(&func->dev); | |
291 | ||
3ec410d7 BC |
292 | return ret; |
293 | ||
a02a2956 GI |
294 | out_free_irq: |
295 | if (wl->irq) | |
296 | free_irq(wl->irq, wl); | |
3ec410d7 | 297 | disable: |
b5ed9c1b | 298 | sdio_claim_host(func); |
3ec410d7 BC |
299 | sdio_disable_func(func); |
300 | release: | |
301 | sdio_release_host(func); | |
832c10fd GI |
302 | kfree(wl_sdio); |
303 | out_free_hw: | |
aa679c36 | 304 | wl1251_free_hw(wl); |
3ec410d7 BC |
305 | return ret; |
306 | } | |
307 | ||
308 | static void __devexit wl1251_sdio_remove(struct sdio_func *func) | |
309 | { | |
310 | struct wl1251 *wl = sdio_get_drvdata(func); | |
832c10fd | 311 | struct wl1251_sdio *wl_sdio = wl->if_priv; |
3ec410d7 | 312 | |
1d4b89f2 GI |
313 | /* Undo decrement done above in wl1251_probe */ |
314 | pm_runtime_get_noresume(&func->dev); | |
315 | ||
a02a2956 GI |
316 | if (wl->irq) |
317 | free_irq(wl->irq, wl); | |
832c10fd | 318 | kfree(wl_sdio); |
3ec410d7 BC |
319 | wl1251_free_hw(wl); |
320 | ||
321 | sdio_claim_host(func); | |
322 | sdio_release_irq(func); | |
323 | sdio_disable_func(func); | |
324 | sdio_release_host(func); | |
325 | } | |
326 | ||
1d4b89f2 GI |
327 | static int wl1251_suspend(struct device *dev) |
328 | { | |
329 | /* | |
330 | * Tell MMC/SDIO core it's OK to power down the card | |
331 | * (if it isn't already), but not to remove it completely. | |
332 | */ | |
333 | return 0; | |
334 | } | |
335 | ||
336 | static int wl1251_resume(struct device *dev) | |
337 | { | |
338 | return 0; | |
339 | } | |
340 | ||
341 | static const struct dev_pm_ops wl1251_sdio_pm_ops = { | |
342 | .suspend = wl1251_suspend, | |
343 | .resume = wl1251_resume, | |
344 | }; | |
345 | ||
3ec410d7 BC |
346 | static struct sdio_driver wl1251_sdio_driver = { |
347 | .name = "wl1251_sdio", | |
348 | .id_table = wl1251_devices, | |
349 | .probe = wl1251_sdio_probe, | |
350 | .remove = __devexit_p(wl1251_sdio_remove), | |
1d4b89f2 | 351 | .drv.pm = &wl1251_sdio_pm_ops, |
3ec410d7 BC |
352 | }; |
353 | ||
354 | static int __init wl1251_sdio_init(void) | |
355 | { | |
356 | int err; | |
357 | ||
358 | err = sdio_register_driver(&wl1251_sdio_driver); | |
359 | if (err) | |
360 | wl1251_error("failed to register sdio driver: %d", err); | |
361 | return err; | |
362 | } | |
363 | ||
364 | static void __exit wl1251_sdio_exit(void) | |
365 | { | |
366 | sdio_unregister_driver(&wl1251_sdio_driver); | |
367 | wl1251_notice("unloaded"); | |
368 | } | |
369 | ||
370 | module_init(wl1251_sdio_init); | |
371 | module_exit(wl1251_sdio_exit); | |
372 | ||
373 | MODULE_LICENSE("GPL"); | |
31c726f0 | 374 | MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>"); |