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