1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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>
31#include <linux/gpio.h>
32#include <linux/wl12xx.h>
33#include <linux/pm_runtime.h>
34
35#include "wl12xx.h"
36#include "wl12xx_80211.h"
37#include "io.h"
38
39#ifndef SDIO_VENDOR_ID_TI
40#define SDIO_VENDOR_ID_TI 0x0097
41#endif
42
43#ifndef SDIO_DEVICE_ID_TI_WL1271
44#define SDIO_DEVICE_ID_TI_WL1271 0x4076
45#endif
46
47static const struct sdio_device_id wl1271_devices[] = {
48 { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
49 {}
50};
51MODULE_DEVICE_TABLE(sdio, wl1271_devices);
52
53static inline struct sdio_func *wl_to_func(struct wl1271 *wl)
54{
55 return wl->if_priv;
56}
57
58static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)
59{
60 return &(wl_to_func(wl)->dev);
61}
62
63static irqreturn_t wl1271_irq(int irq, void *cookie)
64{
65 struct wl1271 *wl = cookie;
66 unsigned long flags;
67
68 wl1271_debug(DEBUG_IRQ, "IRQ");
69
70
71 spin_lock_irqsave(&wl->wl_lock, flags);
72 if (wl->elp_compl) {
73 complete(wl->elp_compl);
74 wl->elp_compl = NULL;
75 }
76
77 if (!test_and_set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags))
78 ieee80211_queue_work(wl->hw, &wl->irq_work);
79 set_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
80 spin_unlock_irqrestore(&wl->wl_lock, flags);
81
82 return IRQ_HANDLED;
83}
84
85static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)
86{
87 disable_irq(wl->irq);
88}
89
90static void wl1271_sdio_enable_interrupts(struct wl1271 *wl)
91{
92 enable_irq(wl->irq);
93}
94
95static void wl1271_sdio_reset(struct wl1271 *wl)
96{
97}
98
99static void wl1271_sdio_init(struct wl1271 *wl)
100{
101}
102
103static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,
104 size_t len, bool fixed)
105{
106 int ret;
107 struct sdio_func *func = wl_to_func(wl);
108
109 sdio_claim_host(func);
110
111 if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
112 ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
113 wl1271_debug(DEBUG_SDIO, "sdio read 52 addr 0x%x, byte 0x%02x",
114 addr, ((u8 *)buf)[0]);
115 } else {
116 if (fixed)
117 ret = sdio_readsb(func, buf, addr, len);
118 else
119 ret = sdio_memcpy_fromio(func, buf, addr, len);
120
121 wl1271_debug(DEBUG_SDIO, "sdio read 53 addr 0x%x, %zu bytes",
122 addr, len);
123 wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
124 }
125
126 sdio_release_host(func);
127
128 if (ret)
129 wl1271_error("sdio read failed (%d)", ret);
130}
131
132static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
133 size_t len, bool fixed)
134{
135 int ret;
136 struct sdio_func *func = wl_to_func(wl);
137
138 sdio_claim_host(func);
139
140 if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
141 sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
142 wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x",
143 addr, ((u8 *)buf)[0]);
144 } else {
145 wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes",
146 addr, len);
147 wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
148
149 if (fixed)
150 ret = sdio_writesb(func, addr, buf, len);
151 else
152 ret = sdio_memcpy_toio(func, addr, buf, len);
153 }
154
155 sdio_release_host(func);
156
157 if (ret)
158 wl1271_error("sdio write failed (%d)", ret);
159}
160
161static int wl1271_sdio_power_on(struct wl1271 *wl)
162{
163 struct sdio_func *func = wl_to_func(wl);
164 int ret;
165
166
167 ret = pm_runtime_get_sync(&func->dev);
168 if (ret < 0)
169 goto out;
170
171 sdio_claim_host(func);
172 sdio_enable_func(func);
173 sdio_release_host(func);
174
175out:
176 return ret;
177}
178
179static int wl1271_sdio_power_off(struct wl1271 *wl)
180{
181 struct sdio_func *func = wl_to_func(wl);
182
183 sdio_claim_host(func);
184 sdio_disable_func(func);
185 sdio_release_host(func);
186
187
188 return pm_runtime_put_sync(&func->dev);
189}
190
191static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
192{
193 if (enable)
194 return wl1271_sdio_power_on(wl);
195 else
196 return wl1271_sdio_power_off(wl);
197}
198
199static struct wl1271_if_operations sdio_ops = {
200 .read = wl1271_sdio_raw_read,
201 .write = wl1271_sdio_raw_write,
202 .reset = wl1271_sdio_reset,
203 .init = wl1271_sdio_init,
204 .power = wl1271_sdio_set_power,
205 .dev = wl1271_sdio_wl_to_dev,
206 .enable_irq = wl1271_sdio_enable_interrupts,
207 .disable_irq = wl1271_sdio_disable_interrupts
208};
209
210static int __devinit wl1271_probe(struct sdio_func *func,
211 const struct sdio_device_id *id)
212{
213 struct ieee80211_hw *hw;
214 const struct wl12xx_platform_data *wlan_data;
215 struct wl1271 *wl;
216 int ret;
217
218
219 if (func->num != 0x02)
220 return -ENODEV;
221
222 hw = wl1271_alloc_hw();
223 if (IS_ERR(hw))
224 return PTR_ERR(hw);
225
226 wl = hw->priv;
227
228 wl->if_priv = func;
229 wl->if_ops = &sdio_ops;
230
231
232 func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
233
234 wlan_data = wl12xx_get_platform_data();
235 if (IS_ERR(wlan_data)) {
236 ret = PTR_ERR(wlan_data);
237 wl1271_error("missing wlan platform data: %d", ret);
238 goto out_free;
239 }
240
241 wl->irq = wlan_data->irq;
242 wl->ref_clock = wlan_data->board_ref_clock;
243
244 ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
245 if (ret < 0) {
246 wl1271_error("request_irq() failed: %d", ret);
247 goto out_free;
248 }
249
250 set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
251
252 disable_irq(wl->irq);
253
254 ret = wl1271_init_ieee80211(wl);
255 if (ret)
256 goto out_irq;
257
258 ret = wl1271_register_hw(wl);
259 if (ret)
260 goto out_irq;
261
262 sdio_set_drvdata(func, wl);
263
264
265 pm_runtime_put_noidle(&func->dev);
266
267 wl1271_notice("initialized");
268
269 return 0;
270
271 out_irq:
272 free_irq(wl->irq, wl);
273
274
275 out_free:
276 wl1271_free_hw(wl);
277
278 return ret;
279}
280
281static void __devexit wl1271_remove(struct sdio_func *func)
282{
283 struct wl1271 *wl = sdio_get_drvdata(func);
284
285
286 pm_runtime_get_noresume(&func->dev);
287
288 wl1271_unregister_hw(wl);
289 free_irq(wl->irq, wl);
290 wl1271_free_hw(wl);
291}
292
293static int wl1271_suspend(struct device *dev)
294{
295
296
297 return 0;
298}
299
300static int wl1271_resume(struct device *dev)
301{
302 return 0;
303}
304
305static const struct dev_pm_ops wl1271_sdio_pm_ops = {
306 .suspend = wl1271_suspend,
307 .resume = wl1271_resume,
308};
309
310static struct sdio_driver wl1271_sdio_driver = {
311 .name = "wl1271_sdio",
312 .id_table = wl1271_devices,
313 .probe = wl1271_probe,
314 .remove = __devexit_p(wl1271_remove),
315 .drv = {
316 .pm = &wl1271_sdio_pm_ops,
317 },
318};
319
320static int __init wl1271_init(void)
321{
322 int ret;
323
324 ret = sdio_register_driver(&wl1271_sdio_driver);
325 if (ret < 0) {
326 wl1271_error("failed to register sdio driver: %d", ret);
327 goto out;
328 }
329
330out:
331 return ret;
332}
333
334static void __exit wl1271_exit(void)
335{
336 sdio_unregister_driver(&wl1271_sdio_driver);
337
338 wl1271_notice("unloaded");
339}
340
341module_init(wl1271_init);
342module_exit(wl1271_exit);
343
344MODULE_LICENSE("GPL");
345MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
346MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
347MODULE_FIRMWARE(WL1271_FW_NAME);
348
