diff options
Diffstat (limited to 'drivers/net/wireless/wl12xx/wl1271_sdio.c')
-rw-r--r-- | drivers/net/wireless/wl12xx/wl1271_sdio.c | 291 |
1 files changed, 291 insertions, 0 deletions
diff --git a/drivers/net/wireless/wl12xx/wl1271_sdio.c b/drivers/net/wireless/wl12xx/wl1271_sdio.c new file mode 100644 index 00000000000..d3d6f302f70 --- /dev/null +++ b/drivers/net/wireless/wl12xx/wl1271_sdio.c | |||
@@ -0,0 +1,291 @@ | |||
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 <plat/gpio.h> | ||
32 | |||
33 | #include "wl1271.h" | ||
34 | #include "wl12xx_80211.h" | ||
35 | #include "wl1271_io.h" | ||
36 | |||
37 | |||
38 | #define RX71_WL1271_IRQ_GPIO 42 | ||
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 | |||
130 | static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf, | ||
131 | size_t len, bool fixed) | ||
132 | { | ||
133 | int ret; | ||
134 | struct sdio_func *func = wl_to_func(wl); | ||
135 | |||
136 | if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) { | ||
137 | sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret); | ||
138 | wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x", | ||
139 | addr, ((u8 *)buf)[0]); | ||
140 | } else { | ||
141 | wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes", | ||
142 | addr, len); | ||
143 | wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len); | ||
144 | |||
145 | if (fixed) | ||
146 | ret = sdio_writesb(func, addr, buf, len); | ||
147 | else | ||
148 | ret = sdio_memcpy_toio(func, addr, buf, len); | ||
149 | } | ||
150 | if (ret) | ||
151 | wl1271_error("sdio write failed (%d)", ret); | ||
152 | |||
153 | } | ||
154 | |||
155 | static void wl1271_sdio_set_power(struct wl1271 *wl, bool enable) | ||
156 | { | ||
157 | struct sdio_func *func = wl_to_func(wl); | ||
158 | |||
159 | /* Let the SDIO stack handle wlan_enable control, so we | ||
160 | * keep host claimed while wlan is in use to keep wl1271 | ||
161 | * alive. | ||
162 | */ | ||
163 | if (enable) { | ||
164 | sdio_claim_host(func); | ||
165 | sdio_enable_func(func); | ||
166 | } else { | ||
167 | sdio_disable_func(func); | ||
168 | sdio_release_host(func); | ||
169 | } | ||
170 | } | ||
171 | |||
172 | static struct wl1271_if_operations sdio_ops = { | ||
173 | .read = wl1271_sdio_raw_read, | ||
174 | .write = wl1271_sdio_raw_write, | ||
175 | .reset = wl1271_sdio_reset, | ||
176 | .init = wl1271_sdio_init, | ||
177 | .power = wl1271_sdio_set_power, | ||
178 | .dev = wl1271_sdio_wl_to_dev, | ||
179 | .enable_irq = wl1271_sdio_enable_interrupts, | ||
180 | .disable_irq = wl1271_sdio_disable_interrupts | ||
181 | }; | ||
182 | |||
183 | static int __devinit wl1271_probe(struct sdio_func *func, | ||
184 | const struct sdio_device_id *id) | ||
185 | { | ||
186 | struct ieee80211_hw *hw; | ||
187 | struct wl1271 *wl; | ||
188 | int ret; | ||
189 | |||
190 | /* We are only able to handle the wlan function */ | ||
191 | if (func->num != 0x02) | ||
192 | return -ENODEV; | ||
193 | |||
194 | hw = wl1271_alloc_hw(); | ||
195 | if (IS_ERR(hw)) | ||
196 | return PTR_ERR(hw); | ||
197 | |||
198 | wl = hw->priv; | ||
199 | |||
200 | wl->if_priv = func; | ||
201 | wl->if_ops = &sdio_ops; | ||
202 | |||
203 | /* Grab access to FN0 for ELP reg. */ | ||
204 | func->card->quirks |= MMC_QUIRK_LENIENT_FN0; | ||
205 | |||
206 | wl->irq = gpio_to_irq(RX71_WL1271_IRQ_GPIO); | ||
207 | if (wl->irq < 0) { | ||
208 | ret = wl->irq; | ||
209 | wl1271_error("could not get irq!"); | ||
210 | goto out_free; | ||
211 | } | ||
212 | |||
213 | ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl); | ||
214 | if (ret < 0) { | ||
215 | wl1271_error("request_irq() failed: %d", ret); | ||
216 | goto out_free; | ||
217 | } | ||
218 | |||
219 | set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING); | ||
220 | |||
221 | disable_irq(wl->irq); | ||
222 | |||
223 | ret = wl1271_init_ieee80211(wl); | ||
224 | if (ret) | ||
225 | goto out_irq; | ||
226 | |||
227 | ret = wl1271_register_hw(wl); | ||
228 | if (ret) | ||
229 | goto out_irq; | ||
230 | |||
231 | sdio_set_drvdata(func, wl); | ||
232 | |||
233 | wl1271_notice("initialized"); | ||
234 | |||
235 | return 0; | ||
236 | |||
237 | out_irq: | ||
238 | free_irq(wl->irq, wl); | ||
239 | |||
240 | |||
241 | out_free: | ||
242 | wl1271_free_hw(wl); | ||
243 | |||
244 | return ret; | ||
245 | } | ||
246 | |||
247 | static void __devexit wl1271_remove(struct sdio_func *func) | ||
248 | { | ||
249 | struct wl1271 *wl = sdio_get_drvdata(func); | ||
250 | |||
251 | free_irq(wl->irq, wl); | ||
252 | |||
253 | wl1271_unregister_hw(wl); | ||
254 | wl1271_free_hw(wl); | ||
255 | } | ||
256 | |||
257 | static struct sdio_driver wl1271_sdio_driver = { | ||
258 | .name = "wl1271_sdio", | ||
259 | .id_table = wl1271_devices, | ||
260 | .probe = wl1271_probe, | ||
261 | .remove = __devexit_p(wl1271_remove), | ||
262 | }; | ||
263 | |||
264 | static int __init wl1271_init(void) | ||
265 | { | ||
266 | int ret; | ||
267 | |||
268 | ret = sdio_register_driver(&wl1271_sdio_driver); | ||
269 | if (ret < 0) { | ||
270 | wl1271_error("failed to register sdio driver: %d", ret); | ||
271 | goto out; | ||
272 | } | ||
273 | |||
274 | out: | ||
275 | return ret; | ||
276 | } | ||
277 | |||
278 | static void __exit wl1271_exit(void) | ||
279 | { | ||
280 | sdio_unregister_driver(&wl1271_sdio_driver); | ||
281 | |||
282 | wl1271_notice("unloaded"); | ||
283 | } | ||
284 | |||
285 | module_init(wl1271_init); | ||
286 | module_exit(wl1271_exit); | ||
287 | |||
288 | MODULE_LICENSE("GPL"); | ||
289 | MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>"); | ||
290 | MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); | ||
291 | MODULE_FIRMWARE(WL1271_FW_NAME); | ||