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.
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.
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
18 * Copyright (C) 2005 Texas Instruments Incorporated
19 * Copyright (C) 2008 Google Inc
20 * Copyright (C) 2009 Bob Copeland (me@bobcopeland.com)
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/spi/wl12xx.h>
28 #include <linux/irq.h>
32 #ifndef SDIO_VENDOR_ID_TI
33 #define SDIO_VENDOR_ID_TI 0x104c
36 #ifndef SDIO_DEVICE_ID_TI_WL1251
37 #define SDIO_DEVICE_ID_TI_WL1251 0x9066
41 struct sdio_func
*func
;
45 static struct wl12xx_platform_data
*wl12xx_board_data
;
47 static struct sdio_func
*wl_to_func(struct wl1251
*wl
)
49 struct wl1251_sdio
*wl_sdio
= wl
->if_priv
;
53 static void wl1251_sdio_interrupt(struct sdio_func
*func
)
55 struct wl1251
*wl
= sdio_get_drvdata(func
);
57 wl1251_debug(DEBUG_IRQ
, "IRQ");
59 ieee80211_queue_work(wl
->hw
, &wl
->irq_work
);
62 static const struct sdio_device_id wl1251_devices
[] = {
63 { SDIO_DEVICE(SDIO_VENDOR_ID_TI
, SDIO_DEVICE_ID_TI_WL1251
) },
66 MODULE_DEVICE_TABLE(sdio
, wl1251_devices
);
69 static void wl1251_sdio_read(struct wl1251
*wl
, int addr
,
70 void *buf
, size_t len
)
73 struct sdio_func
*func
= wl_to_func(wl
);
75 sdio_claim_host(func
);
76 ret
= sdio_memcpy_fromio(func
, buf
, addr
, len
);
78 wl1251_error("sdio read failed (%d)", ret
);
79 sdio_release_host(func
);
82 static void wl1251_sdio_write(struct wl1251
*wl
, int addr
,
83 void *buf
, size_t len
)
86 struct sdio_func
*func
= wl_to_func(wl
);
88 sdio_claim_host(func
);
89 ret
= sdio_memcpy_toio(func
, addr
, buf
, len
);
91 wl1251_error("sdio write failed (%d)", ret
);
92 sdio_release_host(func
);
95 static void wl1251_sdio_read_elp(struct wl1251
*wl
, int addr
, u32
*val
)
98 struct wl1251_sdio
*wl_sdio
= wl
->if_priv
;
99 struct sdio_func
*func
= wl_sdio
->func
;
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
107 sdio_claim_host(func
);
108 *val
= sdio_writeb_readb(func
, wl_sdio
->elp_val
, addr
, &ret
);
109 sdio_release_host(func
);
112 wl1251_error("sdio_readb failed (%d)", ret
);
115 static void wl1251_sdio_write_elp(struct wl1251
*wl
, int addr
, u32 val
)
118 struct wl1251_sdio
*wl_sdio
= wl
->if_priv
;
119 struct sdio_func
*func
= wl_sdio
->func
;
121 sdio_claim_host(func
);
122 sdio_writeb(func
, val
, addr
, &ret
);
123 sdio_release_host(func
);
126 wl1251_error("sdio_writeb failed (%d)", ret
);
128 wl_sdio
->elp_val
= val
;
131 static void wl1251_sdio_reset(struct wl1251
*wl
)
135 static void wl1251_sdio_enable_irq(struct wl1251
*wl
)
137 struct sdio_func
*func
= wl_to_func(wl
);
139 sdio_claim_host(func
);
140 sdio_claim_irq(func
, wl1251_sdio_interrupt
);
141 sdio_release_host(func
);
144 static void wl1251_sdio_disable_irq(struct wl1251
*wl
)
146 struct sdio_func
*func
= wl_to_func(wl
);
148 sdio_claim_host(func
);
149 sdio_release_irq(func
);
150 sdio_release_host(func
);
153 /* Interrupts when using dedicated WLAN_IRQ pin */
154 static irqreturn_t
wl1251_line_irq(int irq
, void *cookie
)
156 struct wl1251
*wl
= cookie
;
158 ieee80211_queue_work(wl
->hw
, &wl
->irq_work
);
163 static void wl1251_enable_line_irq(struct wl1251
*wl
)
165 return enable_irq(wl
->irq
);
168 static void wl1251_disable_line_irq(struct wl1251
*wl
)
170 return disable_irq(wl
->irq
);
173 static void wl1251_sdio_set_power(bool enable
)
177 static struct wl1251_if_operations wl1251_sdio_ops
= {
178 .read
= wl1251_sdio_read
,
179 .write
= wl1251_sdio_write
,
180 .write_elp
= wl1251_sdio_write_elp
,
181 .read_elp
= wl1251_sdio_read_elp
,
182 .reset
= wl1251_sdio_reset
,
185 static int wl1251_platform_probe(struct platform_device
*pdev
)
187 if (pdev
->id
!= -1) {
188 wl1251_error("can only handle single device");
192 wl12xx_board_data
= pdev
->dev
.platform_data
;
197 * Dummy platform_driver for passing platform_data to this driver,
198 * until we have a way to pass this through SDIO subsystem or
201 static struct platform_driver wl1251_platform_driver
= {
203 .name
= "wl1251_data",
204 .owner
= THIS_MODULE
,
206 .probe
= wl1251_platform_probe
,
209 static int wl1251_sdio_probe(struct sdio_func
*func
,
210 const struct sdio_device_id
*id
)
214 struct ieee80211_hw
*hw
;
215 struct wl1251_sdio
*wl_sdio
;
217 hw
= wl1251_alloc_hw();
223 wl_sdio
= kzalloc(sizeof(*wl_sdio
), GFP_KERNEL
);
224 if (wl_sdio
== NULL
) {
229 sdio_claim_host(func
);
230 ret
= sdio_enable_func(func
);
234 sdio_set_block_size(func
, 512);
235 sdio_release_host(func
);
237 SET_IEEE80211_DEV(hw
, &func
->dev
);
238 wl_sdio
->func
= func
;
239 wl
->if_priv
= wl_sdio
;
240 wl
->if_ops
= &wl1251_sdio_ops
;
241 wl
->set_power
= wl1251_sdio_set_power
;
243 if (wl12xx_board_data
!= NULL
) {
244 wl
->set_power
= wl12xx_board_data
->set_power
;
245 wl
->irq
= wl12xx_board_data
->irq
;
246 wl
->use_eeprom
= wl12xx_board_data
->use_eeprom
;
250 ret
= request_irq(wl
->irq
, wl1251_line_irq
, 0, "wl1251", wl
);
252 wl1251_error("request_irq() failed: %d", ret
);
256 set_irq_type(wl
->irq
, IRQ_TYPE_EDGE_RISING
);
257 disable_irq(wl
->irq
);
259 wl1251_sdio_ops
.enable_irq
= wl1251_enable_line_irq
;
260 wl1251_sdio_ops
.disable_irq
= wl1251_disable_line_irq
;
262 wl1251_info("using dedicated interrupt line");
264 wl1251_sdio_ops
.enable_irq
= wl1251_sdio_enable_irq
;
265 wl1251_sdio_ops
.disable_irq
= wl1251_sdio_disable_irq
;
267 wl1251_info("using SDIO interrupt");
270 ret
= wl1251_init_ieee80211(wl
);
274 sdio_set_drvdata(func
, wl
);
279 free_irq(wl
->irq
, wl
);
281 sdio_claim_host(func
);
282 sdio_disable_func(func
);
284 sdio_release_host(func
);
291 static void __devexit
wl1251_sdio_remove(struct sdio_func
*func
)
293 struct wl1251
*wl
= sdio_get_drvdata(func
);
294 struct wl1251_sdio
*wl_sdio
= wl
->if_priv
;
297 free_irq(wl
->irq
, wl
);
301 sdio_claim_host(func
);
302 sdio_release_irq(func
);
303 sdio_disable_func(func
);
304 sdio_release_host(func
);
307 static struct sdio_driver wl1251_sdio_driver
= {
308 .name
= "wl1251_sdio",
309 .id_table
= wl1251_devices
,
310 .probe
= wl1251_sdio_probe
,
311 .remove
= __devexit_p(wl1251_sdio_remove
),
314 static int __init
wl1251_sdio_init(void)
318 err
= platform_driver_register(&wl1251_platform_driver
);
320 wl1251_error("failed to register platform driver: %d", err
);
324 err
= sdio_register_driver(&wl1251_sdio_driver
);
326 wl1251_error("failed to register sdio driver: %d", err
);
330 static void __exit
wl1251_sdio_exit(void)
332 sdio_unregister_driver(&wl1251_sdio_driver
);
333 platform_driver_unregister(&wl1251_platform_driver
);
334 wl1251_notice("unloaded");
337 module_init(wl1251_sdio_init
);
338 module_exit(wl1251_sdio_exit
);
340 MODULE_LICENSE("GPL");
341 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");