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