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 | */ | |
22 | #include <linux/module.h> | |
3ec410d7 | 23 | #include <linux/mod_devicetable.h> |
3ec410d7 BC |
24 | #include <linux/mmc/sdio_func.h> |
25 | #include <linux/mmc/sdio_ids.h> | |
8c00b39f | 26 | #include <linux/platform_device.h> |
c1f9a095 | 27 | #include <linux/wl12xx.h> |
a02a2956 | 28 | #include <linux/irq.h> |
3ec410d7 BC |
29 | |
30 | #include "wl1251.h" | |
3ec410d7 BC |
31 | |
32 | #ifndef SDIO_VENDOR_ID_TI | |
33 | #define SDIO_VENDOR_ID_TI 0x104c | |
34 | #endif | |
35 | ||
36 | #ifndef SDIO_DEVICE_ID_TI_WL1251 | |
37 | #define SDIO_DEVICE_ID_TI_WL1251 0x9066 | |
38 | #endif | |
39 | ||
832c10fd GI |
40 | struct wl1251_sdio { |
41 | struct sdio_func *func; | |
42 | u32 elp_val; | |
43 | }; | |
44 | ||
8c00b39f GI |
45 | static struct wl12xx_platform_data *wl12xx_board_data; |
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 | ||
3c9cb9c3 | 174 | static void wl1251_sdio_set_power(bool enable) |
3ec410d7 BC |
175 | { |
176 | } | |
177 | ||
a02a2956 | 178 | static struct wl1251_if_operations wl1251_sdio_ops = { |
3ec410d7 BC |
179 | .read = wl1251_sdio_read, |
180 | .write = wl1251_sdio_write, | |
3f9e750d GI |
181 | .write_elp = wl1251_sdio_write_elp, |
182 | .read_elp = wl1251_sdio_read_elp, | |
3ec410d7 BC |
183 | .reset = wl1251_sdio_reset, |
184 | }; | |
185 | ||
8c00b39f GI |
186 | static int wl1251_platform_probe(struct platform_device *pdev) |
187 | { | |
188 | if (pdev->id != -1) { | |
189 | wl1251_error("can only handle single device"); | |
190 | return -ENODEV; | |
191 | } | |
192 | ||
193 | wl12xx_board_data = pdev->dev.platform_data; | |
194 | return 0; | |
195 | } | |
196 | ||
197 | /* | |
198 | * Dummy platform_driver for passing platform_data to this driver, | |
199 | * until we have a way to pass this through SDIO subsystem or | |
200 | * some other way. | |
201 | */ | |
202 | static struct platform_driver wl1251_platform_driver = { | |
203 | .driver = { | |
204 | .name = "wl1251_data", | |
205 | .owner = THIS_MODULE, | |
206 | }, | |
207 | .probe = wl1251_platform_probe, | |
208 | }; | |
209 | ||
3c9cb9c3 GI |
210 | static int wl1251_sdio_probe(struct sdio_func *func, |
211 | const struct sdio_device_id *id) | |
3ec410d7 BC |
212 | { |
213 | int ret; | |
214 | struct wl1251 *wl; | |
215 | struct ieee80211_hw *hw; | |
832c10fd | 216 | struct wl1251_sdio *wl_sdio; |
3ec410d7 BC |
217 | |
218 | hw = wl1251_alloc_hw(); | |
219 | if (IS_ERR(hw)) | |
220 | return PTR_ERR(hw); | |
221 | ||
222 | wl = hw->priv; | |
223 | ||
832c10fd GI |
224 | wl_sdio = kzalloc(sizeof(*wl_sdio), GFP_KERNEL); |
225 | if (wl_sdio == NULL) { | |
226 | ret = -ENOMEM; | |
227 | goto out_free_hw; | |
228 | } | |
229 | ||
3ec410d7 BC |
230 | sdio_claim_host(func); |
231 | ret = sdio_enable_func(func); | |
232 | if (ret) | |
233 | goto release; | |
234 | ||
235 | sdio_set_block_size(func, 512); | |
a02a2956 | 236 | sdio_release_host(func); |
3ec410d7 BC |
237 | |
238 | SET_IEEE80211_DEV(hw, &func->dev); | |
832c10fd GI |
239 | wl_sdio->func = func; |
240 | wl->if_priv = wl_sdio; | |
3ec410d7 BC |
241 | wl->if_ops = &wl1251_sdio_ops; |
242 | wl->set_power = wl1251_sdio_set_power; | |
243 | ||
8c00b39f GI |
244 | if (wl12xx_board_data != NULL) { |
245 | wl->set_power = wl12xx_board_data->set_power; | |
a02a2956 | 246 | wl->irq = wl12xx_board_data->irq; |
8c00b39f GI |
247 | wl->use_eeprom = wl12xx_board_data->use_eeprom; |
248 | } | |
249 | ||
a02a2956 GI |
250 | if (wl->irq) { |
251 | ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl); | |
252 | if (ret < 0) { | |
253 | wl1251_error("request_irq() failed: %d", ret); | |
254 | goto disable; | |
255 | } | |
256 | ||
257 | set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING); | |
258 | disable_irq(wl->irq); | |
259 | ||
260 | wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq; | |
261 | wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq; | |
262 | ||
263 | wl1251_info("using dedicated interrupt line"); | |
264 | } else { | |
265 | wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq; | |
266 | wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq; | |
267 | ||
268 | wl1251_info("using SDIO interrupt"); | |
269 | } | |
270 | ||
3ec410d7 | 271 | ret = wl1251_init_ieee80211(wl); |
3ec410d7 | 272 | if (ret) |
a02a2956 | 273 | goto out_free_irq; |
3ec410d7 | 274 | |
3ec410d7 BC |
275 | sdio_set_drvdata(func, wl); |
276 | return ret; | |
277 | ||
a02a2956 GI |
278 | out_free_irq: |
279 | if (wl->irq) | |
280 | free_irq(wl->irq, wl); | |
3ec410d7 | 281 | disable: |
b5ed9c1b | 282 | sdio_claim_host(func); |
3ec410d7 BC |
283 | sdio_disable_func(func); |
284 | release: | |
285 | sdio_release_host(func); | |
832c10fd GI |
286 | kfree(wl_sdio); |
287 | out_free_hw: | |
aa679c36 | 288 | wl1251_free_hw(wl); |
3ec410d7 BC |
289 | return ret; |
290 | } | |
291 | ||
292 | static void __devexit wl1251_sdio_remove(struct sdio_func *func) | |
293 | { | |
294 | struct wl1251 *wl = sdio_get_drvdata(func); | |
832c10fd | 295 | struct wl1251_sdio *wl_sdio = wl->if_priv; |
3ec410d7 | 296 | |
a02a2956 GI |
297 | if (wl->irq) |
298 | free_irq(wl->irq, wl); | |
832c10fd | 299 | kfree(wl_sdio); |
3ec410d7 BC |
300 | wl1251_free_hw(wl); |
301 | ||
302 | sdio_claim_host(func); | |
303 | sdio_release_irq(func); | |
304 | sdio_disable_func(func); | |
305 | sdio_release_host(func); | |
306 | } | |
307 | ||
308 | static struct sdio_driver wl1251_sdio_driver = { | |
309 | .name = "wl1251_sdio", | |
310 | .id_table = wl1251_devices, | |
311 | .probe = wl1251_sdio_probe, | |
312 | .remove = __devexit_p(wl1251_sdio_remove), | |
313 | }; | |
314 | ||
315 | static int __init wl1251_sdio_init(void) | |
316 | { | |
317 | int err; | |
318 | ||
8c00b39f GI |
319 | err = platform_driver_register(&wl1251_platform_driver); |
320 | if (err) { | |
321 | wl1251_error("failed to register platform driver: %d", err); | |
322 | return err; | |
323 | } | |
324 | ||
3ec410d7 BC |
325 | err = sdio_register_driver(&wl1251_sdio_driver); |
326 | if (err) | |
327 | wl1251_error("failed to register sdio driver: %d", err); | |
328 | return err; | |
329 | } | |
330 | ||
331 | static void __exit wl1251_sdio_exit(void) | |
332 | { | |
333 | sdio_unregister_driver(&wl1251_sdio_driver); | |
8c00b39f | 334 | platform_driver_unregister(&wl1251_platform_driver); |
3ec410d7 BC |
335 | wl1251_notice("unloaded"); |
336 | } | |
337 | ||
338 | module_init(wl1251_sdio_init); | |
339 | module_exit(wl1251_sdio_exit); | |
340 | ||
341 | MODULE_LICENSE("GPL"); | |
31c726f0 | 342 | MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>"); |