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 GI |
26 | #include <linux/platform_device.h> |
27 | #include <linux/spi/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 | ||
8c00b39f GI |
40 | static struct wl12xx_platform_data *wl12xx_board_data; |
41 | ||
3ec410d7 BC |
42 | static struct sdio_func *wl_to_func(struct wl1251 *wl) |
43 | { | |
44 | return wl->if_priv; | |
45 | } | |
46 | ||
47 | static void wl1251_sdio_interrupt(struct sdio_func *func) | |
48 | { | |
b5ed9c1b BC |
49 | struct wl1251 *wl = sdio_get_drvdata(func); |
50 | ||
51 | wl1251_debug(DEBUG_IRQ, "IRQ"); | |
52 | ||
53 | /* FIXME should be synchronous for sdio */ | |
16e711f9 | 54 | ieee80211_queue_work(wl->hw, &wl->irq_work); |
3ec410d7 BC |
55 | } |
56 | ||
57 | static const struct sdio_device_id wl1251_devices[] = { | |
58 | { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) }, | |
59 | {} | |
60 | }; | |
61 | MODULE_DEVICE_TABLE(sdio, wl1251_devices); | |
62 | ||
63 | ||
3c9cb9c3 GI |
64 | static void wl1251_sdio_read(struct wl1251 *wl, int addr, |
65 | void *buf, size_t len) | |
3ec410d7 BC |
66 | { |
67 | int ret; | |
68 | struct sdio_func *func = wl_to_func(wl); | |
69 | ||
70 | sdio_claim_host(func); | |
71 | ret = sdio_memcpy_fromio(func, buf, addr, len); | |
72 | if (ret) | |
73 | wl1251_error("sdio read failed (%d)", ret); | |
74 | sdio_release_host(func); | |
75 | } | |
76 | ||
3c9cb9c3 GI |
77 | static void wl1251_sdio_write(struct wl1251 *wl, int addr, |
78 | void *buf, size_t len) | |
3ec410d7 BC |
79 | { |
80 | int ret; | |
81 | struct sdio_func *func = wl_to_func(wl); | |
82 | ||
83 | sdio_claim_host(func); | |
84 | ret = sdio_memcpy_toio(func, addr, buf, len); | |
85 | if (ret) | |
86 | wl1251_error("sdio write failed (%d)", ret); | |
87 | sdio_release_host(func); | |
88 | } | |
89 | ||
3f9e750d GI |
90 | static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val) |
91 | { | |
92 | int ret = 0; | |
93 | struct sdio_func *func = wl_to_func(wl); | |
94 | ||
95 | sdio_claim_host(func); | |
96 | *val = sdio_readb(func, addr, &ret); | |
97 | sdio_release_host(func); | |
98 | ||
99 | if (ret) | |
100 | wl1251_error("sdio_readb failed (%d)", ret); | |
101 | } | |
102 | ||
103 | static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val) | |
104 | { | |
105 | int ret = 0; | |
106 | struct sdio_func *func = wl_to_func(wl); | |
107 | ||
108 | sdio_claim_host(func); | |
109 | sdio_writeb(func, val, addr, &ret); | |
110 | sdio_release_host(func); | |
111 | ||
112 | if (ret) | |
113 | wl1251_error("sdio_writeb failed (%d)", ret); | |
114 | } | |
115 | ||
3c9cb9c3 | 116 | static void wl1251_sdio_reset(struct wl1251 *wl) |
3ec410d7 BC |
117 | { |
118 | } | |
119 | ||
b5ed9c1b BC |
120 | static void wl1251_sdio_enable_irq(struct wl1251 *wl) |
121 | { | |
122 | struct sdio_func *func = wl_to_func(wl); | |
123 | ||
124 | sdio_claim_host(func); | |
125 | sdio_claim_irq(func, wl1251_sdio_interrupt); | |
126 | sdio_release_host(func); | |
127 | } | |
128 | ||
129 | static void wl1251_sdio_disable_irq(struct wl1251 *wl) | |
130 | { | |
131 | struct sdio_func *func = wl_to_func(wl); | |
132 | ||
133 | sdio_claim_host(func); | |
134 | sdio_release_irq(func); | |
135 | sdio_release_host(func); | |
136 | } | |
137 | ||
a02a2956 GI |
138 | /* Interrupts when using dedicated WLAN_IRQ pin */ |
139 | static irqreturn_t wl1251_line_irq(int irq, void *cookie) | |
140 | { | |
141 | struct wl1251 *wl = cookie; | |
142 | ||
143 | ieee80211_queue_work(wl->hw, &wl->irq_work); | |
144 | ||
145 | return IRQ_HANDLED; | |
146 | } | |
147 | ||
148 | static void wl1251_enable_line_irq(struct wl1251 *wl) | |
149 | { | |
150 | return enable_irq(wl->irq); | |
151 | } | |
152 | ||
153 | static void wl1251_disable_line_irq(struct wl1251 *wl) | |
154 | { | |
155 | return disable_irq(wl->irq); | |
156 | } | |
157 | ||
3c9cb9c3 | 158 | static void wl1251_sdio_set_power(bool enable) |
3ec410d7 BC |
159 | { |
160 | } | |
161 | ||
a02a2956 | 162 | static struct wl1251_if_operations wl1251_sdio_ops = { |
3ec410d7 BC |
163 | .read = wl1251_sdio_read, |
164 | .write = wl1251_sdio_write, | |
3f9e750d GI |
165 | .write_elp = wl1251_sdio_write_elp, |
166 | .read_elp = wl1251_sdio_read_elp, | |
3ec410d7 BC |
167 | .reset = wl1251_sdio_reset, |
168 | }; | |
169 | ||
8c00b39f GI |
170 | static int wl1251_platform_probe(struct platform_device *pdev) |
171 | { | |
172 | if (pdev->id != -1) { | |
173 | wl1251_error("can only handle single device"); | |
174 | return -ENODEV; | |
175 | } | |
176 | ||
177 | wl12xx_board_data = pdev->dev.platform_data; | |
178 | return 0; | |
179 | } | |
180 | ||
181 | /* | |
182 | * Dummy platform_driver for passing platform_data to this driver, | |
183 | * until we have a way to pass this through SDIO subsystem or | |
184 | * some other way. | |
185 | */ | |
186 | static struct platform_driver wl1251_platform_driver = { | |
187 | .driver = { | |
188 | .name = "wl1251_data", | |
189 | .owner = THIS_MODULE, | |
190 | }, | |
191 | .probe = wl1251_platform_probe, | |
192 | }; | |
193 | ||
3c9cb9c3 GI |
194 | static int wl1251_sdio_probe(struct sdio_func *func, |
195 | const struct sdio_device_id *id) | |
3ec410d7 BC |
196 | { |
197 | int ret; | |
198 | struct wl1251 *wl; | |
199 | struct ieee80211_hw *hw; | |
200 | ||
201 | hw = wl1251_alloc_hw(); | |
202 | if (IS_ERR(hw)) | |
203 | return PTR_ERR(hw); | |
204 | ||
205 | wl = hw->priv; | |
206 | ||
207 | sdio_claim_host(func); | |
208 | ret = sdio_enable_func(func); | |
209 | if (ret) | |
210 | goto release; | |
211 | ||
212 | sdio_set_block_size(func, 512); | |
a02a2956 | 213 | sdio_release_host(func); |
3ec410d7 BC |
214 | |
215 | SET_IEEE80211_DEV(hw, &func->dev); | |
216 | wl->if_priv = func; | |
217 | wl->if_ops = &wl1251_sdio_ops; | |
218 | wl->set_power = wl1251_sdio_set_power; | |
219 | ||
8c00b39f GI |
220 | if (wl12xx_board_data != NULL) { |
221 | wl->set_power = wl12xx_board_data->set_power; | |
a02a2956 | 222 | wl->irq = wl12xx_board_data->irq; |
8c00b39f GI |
223 | wl->use_eeprom = wl12xx_board_data->use_eeprom; |
224 | } | |
225 | ||
a02a2956 GI |
226 | if (wl->irq) { |
227 | ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl); | |
228 | if (ret < 0) { | |
229 | wl1251_error("request_irq() failed: %d", ret); | |
230 | goto disable; | |
231 | } | |
232 | ||
233 | set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING); | |
234 | disable_irq(wl->irq); | |
235 | ||
236 | wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq; | |
237 | wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq; | |
238 | ||
239 | wl1251_info("using dedicated interrupt line"); | |
240 | } else { | |
241 | wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq; | |
242 | wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq; | |
243 | ||
244 | wl1251_info("using SDIO interrupt"); | |
245 | } | |
246 | ||
3ec410d7 | 247 | ret = wl1251_init_ieee80211(wl); |
3ec410d7 | 248 | if (ret) |
a02a2956 | 249 | goto out_free_irq; |
3ec410d7 | 250 | |
3ec410d7 BC |
251 | sdio_set_drvdata(func, wl); |
252 | return ret; | |
253 | ||
a02a2956 GI |
254 | out_free_irq: |
255 | if (wl->irq) | |
256 | free_irq(wl->irq, wl); | |
3ec410d7 | 257 | disable: |
b5ed9c1b | 258 | sdio_claim_host(func); |
3ec410d7 BC |
259 | sdio_disable_func(func); |
260 | release: | |
261 | sdio_release_host(func); | |
262 | return ret; | |
263 | } | |
264 | ||
265 | static void __devexit wl1251_sdio_remove(struct sdio_func *func) | |
266 | { | |
267 | struct wl1251 *wl = sdio_get_drvdata(func); | |
268 | ||
a02a2956 GI |
269 | if (wl->irq) |
270 | free_irq(wl->irq, wl); | |
3ec410d7 BC |
271 | wl1251_free_hw(wl); |
272 | ||
273 | sdio_claim_host(func); | |
274 | sdio_release_irq(func); | |
275 | sdio_disable_func(func); | |
276 | sdio_release_host(func); | |
277 | } | |
278 | ||
279 | static struct sdio_driver wl1251_sdio_driver = { | |
280 | .name = "wl1251_sdio", | |
281 | .id_table = wl1251_devices, | |
282 | .probe = wl1251_sdio_probe, | |
283 | .remove = __devexit_p(wl1251_sdio_remove), | |
284 | }; | |
285 | ||
286 | static int __init wl1251_sdio_init(void) | |
287 | { | |
288 | int err; | |
289 | ||
8c00b39f GI |
290 | err = platform_driver_register(&wl1251_platform_driver); |
291 | if (err) { | |
292 | wl1251_error("failed to register platform driver: %d", err); | |
293 | return err; | |
294 | } | |
295 | ||
3ec410d7 BC |
296 | err = sdio_register_driver(&wl1251_sdio_driver); |
297 | if (err) | |
298 | wl1251_error("failed to register sdio driver: %d", err); | |
299 | return err; | |
300 | } | |
301 | ||
302 | static void __exit wl1251_sdio_exit(void) | |
303 | { | |
304 | sdio_unregister_driver(&wl1251_sdio_driver); | |
8c00b39f | 305 | platform_driver_unregister(&wl1251_platform_driver); |
3ec410d7 BC |
306 | wl1251_notice("unloaded"); |
307 | } | |
308 | ||
309 | module_init(wl1251_sdio_init); | |
310 | module_exit(wl1251_sdio_exit); | |
311 | ||
312 | MODULE_LICENSE("GPL"); | |
b1b0a2b8 | 313 | MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>"); |