2 * Mac80211 SDIO driver for ST-Ericsson CW1200 device
4 * Copyright (c) 2010, ST-Ericsson
5 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/module.h>
13 #include <linux/gpio.h>
14 #include <linux/delay.h>
15 #include <linux/mmc/host.h>
16 #include <linux/mmc/sdio_func.h>
17 #include <linux/mmc/card.h>
18 #include <linux/mmc/sdio.h>
19 #include <net/mac80211.h>
23 #include <linux/platform_data/cw1200_platform.h>
26 MODULE_AUTHOR("Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>");
27 MODULE_DESCRIPTION("mac80211 ST-Ericsson CW1200 SDIO driver");
28 MODULE_LICENSE("GPL");
30 #define SDIO_BLOCK_SIZE (512)
33 struct sdio_func
*func
;
34 struct cw1200_common
*core
;
35 const struct cw1200_platform_data_sdio
*pdata
;
38 #ifndef SDIO_VENDOR_ID_STE
39 #define SDIO_VENDOR_ID_STE 0x0020
42 #ifndef SDIO_DEVICE_ID_STE_CW1200
43 #define SDIO_DEVICE_ID_STE_CW1200 0x2280
46 static const struct sdio_device_id cw1200_sdio_ids
[] = {
47 { SDIO_DEVICE(SDIO_VENDOR_ID_STE
, SDIO_DEVICE_ID_STE_CW1200
) },
48 { /* end: all zeroes */ },
51 /* hwbus_ops implemetation */
53 static int cw1200_sdio_memcpy_fromio(struct hwbus_priv
*self
,
57 return sdio_memcpy_fromio(self
->func
, dst
, addr
, count
);
60 static int cw1200_sdio_memcpy_toio(struct hwbus_priv
*self
,
62 const void *src
, int count
)
64 return sdio_memcpy_toio(self
->func
, addr
, (void *)src
, count
);
67 static void cw1200_sdio_lock(struct hwbus_priv
*self
)
69 sdio_claim_host(self
->func
);
72 static void cw1200_sdio_unlock(struct hwbus_priv
*self
)
74 sdio_release_host(self
->func
);
77 static void cw1200_sdio_irq_handler(struct sdio_func
*func
)
79 struct hwbus_priv
*self
= sdio_get_drvdata(func
);
81 /* note: sdio_host already claimed here. */
83 cw1200_irq_handler(self
->core
);
86 static irqreturn_t
cw1200_gpio_hardirq(int irq
, void *dev_id
)
88 return IRQ_WAKE_THREAD
;
91 static irqreturn_t
cw1200_gpio_irq(int irq
, void *dev_id
)
93 struct hwbus_priv
*self
= dev_id
;
96 sdio_claim_host(self
->func
);
97 cw1200_irq_handler(self
->core
);
98 sdio_release_host(self
->func
);
105 static int cw1200_request_irq(struct hwbus_priv
*self
)
108 const struct resource
*irq
= self
->pdata
->irq
;
111 cccr
= sdio_f0_readb(self
->func
, SDIO_CCCR_IENx
, &ret
);
115 /* Master interrupt enable ... */
118 /* ... for our function */
119 cccr
|= BIT(self
->func
->num
);
121 sdio_f0_writeb(self
->func
, cccr
, SDIO_CCCR_IENx
, &ret
);
125 ret
= enable_irq_wake(irq
->start
);
129 /* Request the IRQ */
130 ret
= request_threaded_irq(irq
->start
, cw1200_gpio_hardirq
,
132 IRQF_TRIGGER_HIGH
| IRQF_ONESHOT
,
143 static int cw1200_sdio_irq_subscribe(struct hwbus_priv
*self
)
147 pr_debug("SW IRQ subscribe\n");
148 sdio_claim_host(self
->func
);
149 if (self
->pdata
->irq
)
150 ret
= cw1200_request_irq(self
);
152 ret
= sdio_claim_irq(self
->func
, cw1200_sdio_irq_handler
);
154 sdio_release_host(self
->func
);
158 static int cw1200_sdio_irq_unsubscribe(struct hwbus_priv
*self
)
162 pr_debug("SW IRQ unsubscribe\n");
164 if (self
->pdata
->irq
) {
165 disable_irq_wake(self
->pdata
->irq
->start
);
166 free_irq(self
->pdata
->irq
->start
, self
);
168 sdio_claim_host(self
->func
);
169 ret
= sdio_release_irq(self
->func
);
170 sdio_release_host(self
->func
);
175 static int cw1200_sdio_off(const struct cw1200_platform_data_sdio
*pdata
)
177 const struct resource
*reset
= pdata
->reset
;
180 gpio_set_value(reset
->start
, 0);
181 msleep(30); /* Min is 2 * CLK32K cycles */
182 gpio_free(reset
->start
);
185 if (pdata
->power_ctrl
)
186 pdata
->power_ctrl(pdata
, false);
188 pdata
->clk_ctrl(pdata
, false);
193 static int cw1200_sdio_on(const struct cw1200_platform_data_sdio
*pdata
)
195 const struct resource
*reset
= pdata
->reset
;
196 const struct resource
*powerup
= pdata
->reset
;
198 /* Ensure I/Os are pulled low */
200 gpio_request(reset
->start
, reset
->name
);
201 gpio_direction_output(reset
->start
, 0);
204 gpio_request(powerup
->start
, powerup
->name
);
205 gpio_direction_output(powerup
->start
, 0);
207 if (reset
|| powerup
)
208 msleep(50); /* Settle time */
210 /* Enable 3v3 and 1v8 to hardware */
211 if (pdata
->power_ctrl
) {
212 if (pdata
->power_ctrl(pdata
, true)) {
213 pr_err("power_ctrl() failed!\n");
219 if (pdata
->clk_ctrl
) {
220 if (pdata
->clk_ctrl(pdata
, true)) {
221 pr_err("clk_ctrl() failed!\n");
224 msleep(10); /* Delay until clock is stable for 2 cycles */
227 /* Enable POWERUP signal */
229 gpio_set_value(powerup
->start
, 1);
230 msleep(250); /* or more..? */
232 /* Enable RSTn signal */
234 gpio_set_value(reset
->start
, 1);
235 msleep(50); /* Or more..? */
240 static size_t cw1200_sdio_align_size(struct hwbus_priv
*self
, size_t size
)
242 if (self
->pdata
->no_nptb
)
243 size
= round_up(size
, SDIO_BLOCK_SIZE
);
245 size
= sdio_align_size(self
->func
, size
);
250 static int cw1200_sdio_pm(struct hwbus_priv
*self
, bool suspend
)
254 if (self
->pdata
->irq
)
255 ret
= irq_set_irq_wake(self
->pdata
->irq
->start
, suspend
);
259 static struct hwbus_ops cw1200_sdio_hwbus_ops
= {
260 .hwbus_memcpy_fromio
= cw1200_sdio_memcpy_fromio
,
261 .hwbus_memcpy_toio
= cw1200_sdio_memcpy_toio
,
262 .lock
= cw1200_sdio_lock
,
263 .unlock
= cw1200_sdio_unlock
,
264 .align_size
= cw1200_sdio_align_size
,
265 .power_mgmt
= cw1200_sdio_pm
,
268 /* Probe Function to be called by SDIO stack when device is discovered */
269 static int cw1200_sdio_probe(struct sdio_func
*func
,
270 const struct sdio_device_id
*id
)
272 struct hwbus_priv
*self
;
275 pr_info("cw1200_wlan_sdio: Probe called\n");
277 /* We are only able to handle the wlan function */
278 if (func
->num
!= 0x01)
281 self
= kzalloc(sizeof(*self
), GFP_KERNEL
);
283 pr_err("Can't allocate SDIO hwbus_priv.\n");
287 func
->card
->quirks
|= MMC_QUIRK_LENIENT_FN0
;
289 self
->pdata
= cw1200_get_platform_data();
291 sdio_set_drvdata(func
, self
);
292 sdio_claim_host(func
);
293 sdio_enable_func(func
);
294 sdio_release_host(func
);
296 status
= cw1200_sdio_irq_subscribe(self
);
298 status
= cw1200_core_probe(&cw1200_sdio_hwbus_ops
,
299 self
, &func
->dev
, &self
->core
,
300 self
->pdata
->ref_clk
,
301 self
->pdata
->macaddr
,
302 self
->pdata
->sdd_file
,
303 self
->pdata
->have_5ghz
);
305 cw1200_sdio_irq_unsubscribe(self
);
306 sdio_claim_host(func
);
307 sdio_disable_func(func
);
308 sdio_release_host(func
);
309 sdio_set_drvdata(func
, NULL
);
316 /* Disconnect Function to be called by SDIO stack when
317 * device is disconnected */
318 static void cw1200_sdio_disconnect(struct sdio_func
*func
)
320 struct hwbus_priv
*self
= sdio_get_drvdata(func
);
323 cw1200_sdio_irq_unsubscribe(self
);
325 cw1200_core_release(self
->core
);
328 sdio_claim_host(func
);
329 sdio_disable_func(func
);
330 sdio_release_host(func
);
331 sdio_set_drvdata(func
, NULL
);
337 static int cw1200_sdio_suspend(struct device
*dev
)
340 struct sdio_func
*func
= dev_to_sdio_func(dev
);
341 struct hwbus_priv
*self
= sdio_get_drvdata(func
);
343 if (!cw1200_can_suspend(self
->core
))
346 /* Notify SDIO that CW1200 will remain powered during suspend */
347 ret
= sdio_set_host_pm_flags(func
, MMC_PM_KEEP_POWER
);
349 pr_err("Error setting SDIO pm flags: %i\n", ret
);
354 static int cw1200_sdio_resume(struct device
*dev
)
359 static const struct dev_pm_ops cw1200_pm_ops
= {
360 .suspend
= cw1200_sdio_suspend
,
361 .resume
= cw1200_sdio_resume
,
365 static struct sdio_driver sdio_driver
= {
366 .name
= "cw1200_wlan_sdio",
367 .id_table
= cw1200_sdio_ids
,
368 .probe
= cw1200_sdio_probe
,
369 .remove
= cw1200_sdio_disconnect
,
372 .pm
= &cw1200_pm_ops
,
377 /* Init Module function -> Called by insmod */
378 static int __init
cw1200_sdio_init(void)
380 const struct cw1200_platform_data_sdio
*pdata
;
383 pdata
= cw1200_get_platform_data();
385 if (cw1200_sdio_on(pdata
)) {
390 ret
= sdio_register_driver(&sdio_driver
);
397 cw1200_sdio_off(pdata
);
401 /* Called at Driver Unloading */
402 static void __exit
cw1200_sdio_exit(void)
404 const struct cw1200_platform_data_sdio
*pdata
;
405 pdata
= cw1200_get_platform_data();
406 sdio_unregister_driver(&sdio_driver
);
407 cw1200_sdio_off(pdata
);
411 module_init(cw1200_sdio_init
);
412 module_exit(cw1200_sdio_exit
);