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
40 static struct wl12xx_platform_data
*wl12xx_board_data
;
42 static struct sdio_func
*wl_to_func(struct wl1251
*wl
)
47 static void wl1251_sdio_interrupt(struct sdio_func
*func
)
49 struct wl1251
*wl
= sdio_get_drvdata(func
);
51 wl1251_debug(DEBUG_IRQ
, "IRQ");
53 /* FIXME should be synchronous for sdio */
54 ieee80211_queue_work(wl
->hw
, &wl
->irq_work
);
57 static const struct sdio_device_id wl1251_devices
[] = {
58 { SDIO_DEVICE(SDIO_VENDOR_ID_TI
, SDIO_DEVICE_ID_TI_WL1251
) },
61 MODULE_DEVICE_TABLE(sdio
, wl1251_devices
);
64 static void wl1251_sdio_read(struct wl1251
*wl
, int addr
,
65 void *buf
, size_t len
)
68 struct sdio_func
*func
= wl_to_func(wl
);
70 sdio_claim_host(func
);
71 ret
= sdio_memcpy_fromio(func
, buf
, addr
, len
);
73 wl1251_error("sdio read failed (%d)", ret
);
74 sdio_release_host(func
);
77 static void wl1251_sdio_write(struct wl1251
*wl
, int addr
,
78 void *buf
, size_t len
)
81 struct sdio_func
*func
= wl_to_func(wl
);
83 sdio_claim_host(func
);
84 ret
= sdio_memcpy_toio(func
, addr
, buf
, len
);
86 wl1251_error("sdio write failed (%d)", ret
);
87 sdio_release_host(func
);
90 static void wl1251_sdio_read_elp(struct wl1251
*wl
, int addr
, u32
*val
)
93 struct sdio_func
*func
= wl_to_func(wl
);
95 sdio_claim_host(func
);
96 *val
= sdio_readb(func
, addr
, &ret
);
97 sdio_release_host(func
);
100 wl1251_error("sdio_readb failed (%d)", ret
);
103 static void wl1251_sdio_write_elp(struct wl1251
*wl
, int addr
, u32 val
)
106 struct sdio_func
*func
= wl_to_func(wl
);
108 sdio_claim_host(func
);
109 sdio_writeb(func
, val
, addr
, &ret
);
110 sdio_release_host(func
);
113 wl1251_error("sdio_writeb failed (%d)", ret
);
116 static void wl1251_sdio_reset(struct wl1251
*wl
)
120 static void wl1251_sdio_enable_irq(struct wl1251
*wl
)
122 struct sdio_func
*func
= wl_to_func(wl
);
124 sdio_claim_host(func
);
125 sdio_claim_irq(func
, wl1251_sdio_interrupt
);
126 sdio_release_host(func
);
129 static void wl1251_sdio_disable_irq(struct wl1251
*wl
)
131 struct sdio_func
*func
= wl_to_func(wl
);
133 sdio_claim_host(func
);
134 sdio_release_irq(func
);
135 sdio_release_host(func
);
138 /* Interrupts when using dedicated WLAN_IRQ pin */
139 static irqreturn_t
wl1251_line_irq(int irq
, void *cookie
)
141 struct wl1251
*wl
= cookie
;
143 ieee80211_queue_work(wl
->hw
, &wl
->irq_work
);
148 static void wl1251_enable_line_irq(struct wl1251
*wl
)
150 return enable_irq(wl
->irq
);
153 static void wl1251_disable_line_irq(struct wl1251
*wl
)
155 return disable_irq(wl
->irq
);
158 static void wl1251_sdio_set_power(bool enable
)
162 static struct wl1251_if_operations wl1251_sdio_ops
= {
163 .read
= wl1251_sdio_read
,
164 .write
= wl1251_sdio_write
,
165 .write_elp
= wl1251_sdio_write_elp
,
166 .read_elp
= wl1251_sdio_read_elp
,
167 .reset
= wl1251_sdio_reset
,
170 static int wl1251_platform_probe(struct platform_device
*pdev
)
172 if (pdev
->id
!= -1) {
173 wl1251_error("can only handle single device");
177 wl12xx_board_data
= pdev
->dev
.platform_data
;
182 * Dummy platform_driver for passing platform_data to this driver,
183 * until we have a way to pass this through SDIO subsystem or
186 static struct platform_driver wl1251_platform_driver
= {
188 .name
= "wl1251_data",
189 .owner
= THIS_MODULE
,
191 .probe
= wl1251_platform_probe
,
194 static int wl1251_sdio_probe(struct sdio_func
*func
,
195 const struct sdio_device_id
*id
)
199 struct ieee80211_hw
*hw
;
201 hw
= wl1251_alloc_hw();
207 sdio_claim_host(func
);
208 ret
= sdio_enable_func(func
);
212 sdio_set_block_size(func
, 512);
213 sdio_release_host(func
);
215 SET_IEEE80211_DEV(hw
, &func
->dev
);
217 wl
->if_ops
= &wl1251_sdio_ops
;
218 wl
->set_power
= wl1251_sdio_set_power
;
220 if (wl12xx_board_data
!= NULL
) {
221 wl
->set_power
= wl12xx_board_data
->set_power
;
222 wl
->irq
= wl12xx_board_data
->irq
;
223 wl
->use_eeprom
= wl12xx_board_data
->use_eeprom
;
227 ret
= request_irq(wl
->irq
, wl1251_line_irq
, 0, "wl1251", wl
);
229 wl1251_error("request_irq() failed: %d", ret
);
233 set_irq_type(wl
->irq
, IRQ_TYPE_EDGE_RISING
);
234 disable_irq(wl
->irq
);
236 wl1251_sdio_ops
.enable_irq
= wl1251_enable_line_irq
;
237 wl1251_sdio_ops
.disable_irq
= wl1251_disable_line_irq
;
239 wl1251_info("using dedicated interrupt line");
241 wl1251_sdio_ops
.enable_irq
= wl1251_sdio_enable_irq
;
242 wl1251_sdio_ops
.disable_irq
= wl1251_sdio_disable_irq
;
244 wl1251_info("using SDIO interrupt");
247 ret
= wl1251_init_ieee80211(wl
);
251 sdio_set_drvdata(func
, wl
);
256 free_irq(wl
->irq
, wl
);
258 sdio_claim_host(func
);
259 sdio_disable_func(func
);
261 sdio_release_host(func
);
265 static void __devexit
wl1251_sdio_remove(struct sdio_func
*func
)
267 struct wl1251
*wl
= sdio_get_drvdata(func
);
270 free_irq(wl
->irq
, wl
);
273 sdio_claim_host(func
);
274 sdio_release_irq(func
);
275 sdio_disable_func(func
);
276 sdio_release_host(func
);
279 static struct sdio_driver wl1251_sdio_driver
= {
280 .name
= "wl1251_sdio",
281 .id_table
= wl1251_devices
,
282 .probe
= wl1251_sdio_probe
,
283 .remove
= __devexit_p(wl1251_sdio_remove
),
286 static int __init
wl1251_sdio_init(void)
290 err
= platform_driver_register(&wl1251_platform_driver
);
292 wl1251_error("failed to register platform driver: %d", err
);
296 err
= sdio_register_driver(&wl1251_sdio_driver
);
298 wl1251_error("failed to register sdio driver: %d", err
);
302 static void __exit
wl1251_sdio_exit(void)
304 sdio_unregister_driver(&wl1251_sdio_driver
);
305 platform_driver_unregister(&wl1251_platform_driver
);
306 wl1251_notice("unloaded");
309 module_init(wl1251_sdio_init
);
310 module_exit(wl1251_sdio_exit
);
312 MODULE_LICENSE("GPL");
313 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");