wl12xx: Change claiming of the SDIO bus
[linux-2.6.git] / drivers / net / wireless / wl12xx / sdio.c
1 /*
2  * This file is part of wl1271
3  *
4  * Copyright (C) 2009-2010 Nokia Corporation
5  *
6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
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/mmc/host.h>
32 #include <linux/gpio.h>
33 #include <linux/wl12xx.h>
34 #include <linux/pm_runtime.h>
35
36 #include "wl12xx.h"
37 #include "wl12xx_80211.h"
38 #include "io.h"
39
40 #ifndef SDIO_VENDOR_ID_TI
41 #define SDIO_VENDOR_ID_TI               0x0097
42 #endif
43
44 #ifndef SDIO_DEVICE_ID_TI_WL1271
45 #define SDIO_DEVICE_ID_TI_WL1271        0x4076
46 #endif
47
48 static const struct sdio_device_id wl1271_devices[] = {
49         { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
50         {}
51 };
52 MODULE_DEVICE_TABLE(sdio, wl1271_devices);
53
54 static inline struct sdio_func *wl_to_func(struct wl1271 *wl)
55 {
56         return wl->if_priv;
57 }
58
59 static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)
60 {
61         return &(wl_to_func(wl)->dev);
62 }
63
64 static irqreturn_t wl1271_irq(int irq, void *cookie)
65 {
66         struct wl1271 *wl = cookie;
67         unsigned long flags;
68
69         wl1271_debug(DEBUG_IRQ, "IRQ");
70
71         /* complete the ELP completion */
72         spin_lock_irqsave(&wl->wl_lock, flags);
73         if (wl->elp_compl) {
74                 complete(wl->elp_compl);
75                 wl->elp_compl = NULL;
76         }
77
78         if (!test_and_set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags))
79                 ieee80211_queue_work(wl->hw, &wl->irq_work);
80         set_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
81         spin_unlock_irqrestore(&wl->wl_lock, flags);
82
83         return IRQ_HANDLED;
84 }
85
86 static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)
87 {
88         disable_irq(wl->irq);
89 }
90
91 static void wl1271_sdio_enable_interrupts(struct wl1271 *wl)
92 {
93         enable_irq(wl->irq);
94 }
95
96 static void wl1271_sdio_reset(struct wl1271 *wl)
97 {
98 }
99
100 static void wl1271_sdio_init(struct wl1271 *wl)
101 {
102 }
103
104 static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,
105                                  size_t len, bool fixed)
106 {
107         int ret;
108         struct sdio_func *func = wl_to_func(wl);
109
110         if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
111                 ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
112                 wl1271_debug(DEBUG_SDIO, "sdio read 52 addr 0x%x, byte 0x%02x",
113                              addr, ((u8 *)buf)[0]);
114         } else {
115                 if (fixed)
116                         ret = sdio_readsb(func, buf, addr, len);
117                 else
118                         ret = sdio_memcpy_fromio(func, buf, addr, len);
119
120                 wl1271_debug(DEBUG_SDIO, "sdio read 53 addr 0x%x, %zu bytes",
121                              addr, len);
122                 wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
123         }
124
125         if (ret)
126                 wl1271_error("sdio read failed (%d)", ret);
127 }
128
129 static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
130                                   size_t len, bool fixed)
131 {
132         int ret;
133         struct sdio_func *func = wl_to_func(wl);
134
135         if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
136                 sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
137                 wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x",
138                              addr, ((u8 *)buf)[0]);
139         } else {
140                 wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes",
141                              addr, len);
142                 wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
143
144                 if (fixed)
145                         ret = sdio_writesb(func, addr, buf, len);
146                 else
147                         ret = sdio_memcpy_toio(func, addr, buf, len);
148         }
149
150         if (ret)
151                 wl1271_error("sdio write failed (%d)", ret);
152 }
153
154 static int wl1271_sdio_power_on(struct wl1271 *wl)
155 {
156         struct sdio_func *func = wl_to_func(wl);
157         int ret;
158
159         /* Make sure the card will not be powered off by runtime PM */
160         ret = pm_runtime_get_sync(&func->dev);
161         if (ret < 0)
162                 goto out;
163
164         /* Runtime PM might be disabled, so power up the card manually */
165         ret = mmc_power_restore_host(func->card->host);
166         if (ret < 0)
167                 goto out;
168
169         sdio_claim_host(func);
170         sdio_enable_func(func);
171
172 out:
173         return ret;
174 }
175
176 static int wl1271_sdio_power_off(struct wl1271 *wl)
177 {
178         struct sdio_func *func = wl_to_func(wl);
179         int ret;
180
181         sdio_disable_func(func);
182         sdio_release_host(func);
183
184         /* Runtime PM might be disabled, so power off the card manually */
185         ret = mmc_power_save_host(func->card->host);
186         if (ret < 0)
187                 return ret;
188
189         /* Let runtime PM know the card is powered off */
190         return pm_runtime_put_sync(&func->dev);
191 }
192
193 static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
194 {
195         if (enable)
196                 return wl1271_sdio_power_on(wl);
197         else
198                 return wl1271_sdio_power_off(wl);
199 }
200
201 static struct wl1271_if_operations sdio_ops = {
202         .read           = wl1271_sdio_raw_read,
203         .write          = wl1271_sdio_raw_write,
204         .reset          = wl1271_sdio_reset,
205         .init           = wl1271_sdio_init,
206         .power          = wl1271_sdio_set_power,
207         .dev            = wl1271_sdio_wl_to_dev,
208         .enable_irq     = wl1271_sdio_enable_interrupts,
209         .disable_irq    = wl1271_sdio_disable_interrupts
210 };
211
212 static int __devinit wl1271_probe(struct sdio_func *func,
213                                   const struct sdio_device_id *id)
214 {
215         struct ieee80211_hw *hw;
216         const struct wl12xx_platform_data *wlan_data;
217         struct wl1271 *wl;
218         int ret;
219
220         /* We are only able to handle the wlan function */
221         if (func->num != 0x02)
222                 return -ENODEV;
223
224         hw = wl1271_alloc_hw();
225         if (IS_ERR(hw))
226                 return PTR_ERR(hw);
227
228         wl = hw->priv;
229
230         wl->if_priv = func;
231         wl->if_ops = &sdio_ops;
232
233         /* Grab access to FN0 for ELP reg. */
234         func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
235
236         wlan_data = wl12xx_get_platform_data();
237         if (IS_ERR(wlan_data)) {
238                 ret = PTR_ERR(wlan_data);
239                 wl1271_error("missing wlan platform data: %d", ret);
240                 goto out_free;
241         }
242
243         wl->irq = wlan_data->irq;
244         wl->ref_clock = wlan_data->board_ref_clock;
245
246         ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
247         if (ret < 0) {
248                 wl1271_error("request_irq() failed: %d", ret);
249                 goto out_free;
250         }
251
252         set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
253
254         disable_irq(wl->irq);
255
256         ret = wl1271_init_ieee80211(wl);
257         if (ret)
258                 goto out_irq;
259
260         ret = wl1271_register_hw(wl);
261         if (ret)
262                 goto out_irq;
263
264         sdio_set_drvdata(func, wl);
265
266         /* Tell PM core that we don't need the card to be powered now */
267         pm_runtime_put_noidle(&func->dev);
268
269         wl1271_notice("initialized");
270
271         return 0;
272
273  out_irq:
274         free_irq(wl->irq, wl);
275
276
277  out_free:
278         wl1271_free_hw(wl);
279
280         return ret;
281 }
282
283 static void __devexit wl1271_remove(struct sdio_func *func)
284 {
285         struct wl1271 *wl = sdio_get_drvdata(func);
286
287         /* Undo decrement done above in wl1271_probe */
288         pm_runtime_get_noresume(&func->dev);
289
290         wl1271_unregister_hw(wl);
291         free_irq(wl->irq, wl);
292         wl1271_free_hw(wl);
293 }
294
295 static int wl1271_suspend(struct device *dev)
296 {
297         /* Tell MMC/SDIO core it's OK to power down the card
298          * (if it isn't already), but not to remove it completely */
299         return 0;
300 }
301
302 static int wl1271_resume(struct device *dev)
303 {
304         return 0;
305 }
306
307 static const struct dev_pm_ops wl1271_sdio_pm_ops = {
308         .suspend        = wl1271_suspend,
309         .resume         = wl1271_resume,
310 };
311
312 static struct sdio_driver wl1271_sdio_driver = {
313         .name           = "wl1271_sdio",
314         .id_table       = wl1271_devices,
315         .probe          = wl1271_probe,
316         .remove         = __devexit_p(wl1271_remove),
317         .drv = {
318                 .pm = &wl1271_sdio_pm_ops,
319         },
320 };
321
322 static int __init wl1271_init(void)
323 {
324         int ret;
325
326         ret = sdio_register_driver(&wl1271_sdio_driver);
327         if (ret < 0) {
328                 wl1271_error("failed to register sdio driver: %d", ret);
329                 goto out;
330         }
331
332 out:
333         return ret;
334 }
335
336 static void __exit wl1271_exit(void)
337 {
338         sdio_unregister_driver(&wl1271_sdio_driver);
339
340         wl1271_notice("unloaded");
341 }
342
343 module_init(wl1271_init);
344 module_exit(wl1271_exit);
345
346 MODULE_LICENSE("GPL");
347 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
348 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
349 MODULE_FIRMWARE(WL1271_FW_NAME);
350 MODULE_FIRMWARE(WL1271_AP_FW_NAME);