2 * Intel Wireless Multicomm 3200 WiFi driver
4 * Copyright (C) 2009 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 * Intel Corporation <ilw@linux.intel.com>
34 * Samuel Ortiz <samuel.ortiz@intel.com>
35 * Zhu Yi <yi.zhu@intel.com>
40 * This is the SDIO bus specific hooks for iwm.
41 * It also is the module's entry point.
43 * Interesting code paths:
44 * iwm_sdio_probe() (Called by an SDIO bus scan)
45 * -> iwm_if_alloc() (netdev.c)
46 * -> iwm_wdev_alloc() (cfg80211.c, allocates and register our wiphy)
49 * -> alloc_netdev_mq()
50 * -> register_netdev()
53 * -> iwm_if_free() (netdev.c)
54 * -> unregister_netdev()
55 * -> iwm_wdev_free() (cfg80211.c)
56 * -> wiphy_unregister()
59 * iwm_sdio_isr() (called in process context from the SDIO core code)
60 * -> queue_work(.., isr_worker)
61 * -- [async] --> iwm_sdio_isr_worker()
65 #include <linux/kernel.h>
66 #include <linux/module.h>
67 #include <linux/slab.h>
68 #include <linux/netdevice.h>
69 #include <linux/debugfs.h>
70 #include <linux/mmc/sdio_ids.h>
71 #include <linux/mmc/sdio.h>
72 #include <linux/mmc/sdio_func.h>
79 static void iwm_sdio_isr_worker(struct work_struct
*work
)
81 struct iwm_sdio_priv
*hw
;
83 struct iwm_rx_info
*rx_info
;
86 unsigned long rx_size
;
88 hw
= container_of(work
, struct iwm_sdio_priv
, isr_worker
);
91 while (!skb_queue_empty(&iwm
->rx_list
)) {
92 skb
= skb_dequeue(&iwm
->rx_list
);
93 rx_info
= skb_to_rx_info(skb
);
94 rx_size
= rx_info
->rx_size
;
97 IWM_HEXDUMP(iwm
, DBG
, SDIO
, "RX: ", rx_buf
, rx_size
);
98 if (iwm_rx_handle(iwm
, rx_buf
, rx_size
) < 0)
99 IWM_WARN(iwm
, "RX error\n");
105 static void iwm_sdio_isr(struct sdio_func
*func
)
107 struct iwm_priv
*iwm
;
108 struct iwm_sdio_priv
*hw
;
109 struct iwm_rx_info
*rx_info
;
111 unsigned long buf_size
, read_size
;
115 hw
= sdio_get_drvdata(func
);
118 buf_size
= hw
->blk_size
;
120 /* We're checking the status */
121 val
= sdio_readb(func
, IWM_SDIO_INTR_STATUS_ADDR
, &ret
);
122 if (val
== 0 || ret
< 0) {
123 IWM_ERR(iwm
, "Wrong INTR_STATUS\n");
127 /* See if we have free buffers */
128 if (skb_queue_len(&iwm
->rx_list
) > IWM_RX_LIST_SIZE
) {
129 IWM_ERR(iwm
, "No buffer for more Rx frames\n");
133 /* We first read the transaction size */
134 read_size
= sdio_readb(func
, IWM_SDIO_INTR_GET_SIZE_ADDR
+ 1, &ret
);
135 read_size
= read_size
<< 8;
138 IWM_ERR(iwm
, "Couldn't read the xfer size\n");
142 /* We need to clear the INT register */
143 sdio_writeb(func
, 1, IWM_SDIO_INTR_CLEAR_ADDR
, &ret
);
145 IWM_ERR(iwm
, "Couldn't clear the INT register\n");
149 while (buf_size
< read_size
)
152 skb
= dev_alloc_skb(buf_size
);
154 IWM_ERR(iwm
, "Couldn't alloc RX skb\n");
157 rx_info
= skb_to_rx_info(skb
);
158 rx_info
->rx_size
= read_size
;
159 rx_info
->rx_buf_size
= buf_size
;
161 /* Now we can read the actual buffer */
162 ret
= sdio_memcpy_fromio(func
, skb_put(skb
, read_size
),
163 IWM_SDIO_DATA_ADDR
, read_size
);
165 /* The skb is put on a driver's specific Rx SKB list */
166 skb_queue_tail(&iwm
->rx_list
, skb
);
168 /* We can now schedule the actual worker */
169 queue_work(hw
->isr_wq
, &hw
->isr_worker
);
172 static void iwm_sdio_rx_free(struct iwm_sdio_priv
*hw
)
174 struct iwm_priv
*iwm
= hw_to_iwm(hw
);
176 flush_workqueue(hw
->isr_wq
);
178 skb_queue_purge(&iwm
->rx_list
);
182 static int if_sdio_enable(struct iwm_priv
*iwm
)
184 struct iwm_sdio_priv
*hw
= iwm_to_if_sdio(iwm
);
187 sdio_claim_host(hw
->func
);
189 ret
= sdio_enable_func(hw
->func
);
191 IWM_ERR(iwm
, "Couldn't enable the device: is TOP driver "
192 "loaded and functional?\n");
198 ret
= sdio_claim_irq(hw
->func
, iwm_sdio_isr
);
200 IWM_ERR(iwm
, "Failed to claim irq: %d\n", ret
);
204 sdio_writeb(hw
->func
, 1, IWM_SDIO_INTR_ENABLE_ADDR
, &ret
);
206 IWM_ERR(iwm
, "Couldn't enable INTR: %d\n", ret
);
210 sdio_release_host(hw
->func
);
212 IWM_DBG_SDIO(iwm
, INFO
, "IWM SDIO enable\n");
217 sdio_release_irq(hw
->func
);
219 sdio_release_host(hw
->func
);
224 static int if_sdio_disable(struct iwm_priv
*iwm
)
226 struct iwm_sdio_priv
*hw
= iwm_to_if_sdio(iwm
);
229 sdio_claim_host(hw
->func
);
230 sdio_writeb(hw
->func
, 0, IWM_SDIO_INTR_ENABLE_ADDR
, &ret
);
232 IWM_WARN(iwm
, "Couldn't disable INTR: %d\n", ret
);
234 sdio_release_irq(hw
->func
);
235 sdio_disable_func(hw
->func
);
236 sdio_release_host(hw
->func
);
238 iwm_sdio_rx_free(hw
);
242 IWM_DBG_SDIO(iwm
, INFO
, "IWM SDIO disable\n");
247 static int if_sdio_send_chunk(struct iwm_priv
*iwm
, u8
*buf
, int count
)
249 struct iwm_sdio_priv
*hw
= iwm_to_if_sdio(iwm
);
250 int aligned_count
= ALIGN(count
, hw
->blk_size
);
253 if ((unsigned long)buf
& 0x3) {
254 IWM_ERR(iwm
, "buf <%p> is not dword aligned\n", buf
);
255 /* TODO: Is this a hardware limitation? use get_unligned */
259 sdio_claim_host(hw
->func
);
260 ret
= sdio_memcpy_toio(hw
->func
, IWM_SDIO_DATA_ADDR
, buf
,
262 sdio_release_host(hw
->func
);
267 static ssize_t
iwm_debugfs_sdio_read(struct file
*filp
, char __user
*buffer
,
268 size_t count
, loff_t
*ppos
)
270 struct iwm_priv
*iwm
= filp
->private_data
;
271 struct iwm_sdio_priv
*hw
= iwm_to_if_sdio(iwm
);
274 int buf_len
= 4096, ret
;
279 if (count
< sizeof(buf
))
282 buf
= kzalloc(buf_len
, GFP_KERNEL
);
286 sdio_claim_host(hw
->func
);
288 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_IOEx
, &ret
);
290 IWM_ERR(iwm
, "Could not read SDIO_CCCR_IOEx\n");
293 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_IOEx: 0x%x\n", cccr
);
295 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_IORx
, &ret
);
297 IWM_ERR(iwm
, "Could not read SDIO_CCCR_IORx\n");
300 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_IORx: 0x%x\n", cccr
);
303 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_IENx
, &ret
);
305 IWM_ERR(iwm
, "Could not read SDIO_CCCR_IENx\n");
308 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_IENx: 0x%x\n", cccr
);
311 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_INTx
, &ret
);
313 IWM_ERR(iwm
, "Could not read SDIO_CCCR_INTx\n");
316 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_INTx: 0x%x\n", cccr
);
319 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_ABORT
, &ret
);
321 IWM_ERR(iwm
, "Could not read SDIO_CCCR_ABORTx\n");
324 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_ABORT: 0x%x\n", cccr
);
326 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_IF
, &ret
);
328 IWM_ERR(iwm
, "Could not read SDIO_CCCR_IF\n");
331 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_IF: 0x%x\n", cccr
);
334 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_CAPS
, &ret
);
336 IWM_ERR(iwm
, "Could not read SDIO_CCCR_CAPS\n");
339 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_CAPS: 0x%x\n", cccr
);
341 cccr
= sdio_f0_readb(hw
->func
, SDIO_CCCR_CIS
, &ret
);
343 IWM_ERR(iwm
, "Could not read SDIO_CCCR_CIS\n");
346 len
+= snprintf(buf
+ len
, buf_len
- len
, "CCCR_CIS: 0x%x\n", cccr
);
348 ret
= simple_read_from_buffer(buffer
, len
, ppos
, buf
, buf_len
);
350 sdio_release_host(hw
->func
);
357 static const struct file_operations iwm_debugfs_sdio_fops
= {
358 .owner
= THIS_MODULE
,
360 .read
= iwm_debugfs_sdio_read
,
361 .llseek
= default_llseek
,
364 static void if_sdio_debugfs_init(struct iwm_priv
*iwm
, struct dentry
*parent_dir
)
366 struct iwm_sdio_priv
*hw
= iwm_to_if_sdio(iwm
);
368 hw
->cccr_dentry
= debugfs_create_file("cccr", 0200,
370 &iwm_debugfs_sdio_fops
);
373 static void if_sdio_debugfs_exit(struct iwm_priv
*iwm
)
375 struct iwm_sdio_priv
*hw
= iwm_to_if_sdio(iwm
);
377 debugfs_remove(hw
->cccr_dentry
);
380 static struct iwm_if_ops if_sdio_ops
= {
381 .enable
= if_sdio_enable
,
382 .disable
= if_sdio_disable
,
383 .send_chunk
= if_sdio_send_chunk
,
384 .debugfs_init
= if_sdio_debugfs_init
,
385 .debugfs_exit
= if_sdio_debugfs_exit
,
386 .umac_name
= "iwmc3200wifi-umac-sdio.bin",
387 .calib_lmac_name
= "iwmc3200wifi-calib-sdio.bin",
388 .lmac_name
= "iwmc3200wifi-lmac-sdio.bin",
390 MODULE_FIRMWARE("iwmc3200wifi-umac-sdio.bin");
391 MODULE_FIRMWARE("iwmc3200wifi-calib-sdio.bin");
392 MODULE_FIRMWARE("iwmc3200wifi-lmac-sdio.bin");
394 static int iwm_sdio_probe(struct sdio_func
*func
,
395 const struct sdio_device_id
*id
)
397 struct iwm_priv
*iwm
;
398 struct iwm_sdio_priv
*hw
;
399 struct device
*dev
= &func
->dev
;
402 /* check if TOP has already initialized the card */
403 sdio_claim_host(func
);
404 ret
= sdio_enable_func(func
);
406 dev_err(dev
, "wait for TOP to enable the device\n");
407 sdio_release_host(func
);
411 ret
= sdio_set_block_size(func
, IWM_SDIO_BLK_SIZE
);
413 sdio_disable_func(func
);
414 sdio_release_host(func
);
417 dev_err(dev
, "Failed to set block size: %d\n", ret
);
421 iwm
= iwm_if_alloc(sizeof(struct iwm_sdio_priv
), dev
, &if_sdio_ops
);
423 dev_err(dev
, "allocate SDIO interface failed\n");
427 hw
= iwm_private(iwm
);
430 iwm_debugfs_init(iwm
);
432 sdio_set_drvdata(func
, hw
);
435 hw
->blk_size
= IWM_SDIO_BLK_SIZE
;
437 hw
->isr_wq
= create_singlethread_workqueue(KBUILD_MODNAME
"_sdio");
443 INIT_WORK(&hw
->isr_worker
, iwm_sdio_isr_worker
);
445 ret
= iwm_if_add(iwm
);
447 dev_err(dev
, "add SDIO interface failed\n");
451 dev_info(dev
, "IWM SDIO probe\n");
456 destroy_workqueue(hw
->isr_wq
);
458 iwm_debugfs_exit(iwm
);
463 static void iwm_sdio_remove(struct sdio_func
*func
)
465 struct iwm_sdio_priv
*hw
= sdio_get_drvdata(func
);
466 struct iwm_priv
*iwm
= hw_to_iwm(hw
);
467 struct device
*dev
= &func
->dev
;
470 destroy_workqueue(hw
->isr_wq
);
471 iwm_debugfs_exit(iwm
);
474 sdio_set_drvdata(func
, NULL
);
476 dev_info(dev
, "IWM SDIO remove\n");
479 static const struct sdio_device_id iwm_sdio_ids
[] = {
481 { SDIO_DEVICE(SDIO_VENDOR_ID_INTEL
, 0x1403) },
483 { SDIO_DEVICE(SDIO_VENDOR_ID_INTEL
, 0x1408) },
484 { /* end: all zeroes */ },
486 MODULE_DEVICE_TABLE(sdio
, iwm_sdio_ids
);
488 static struct sdio_driver iwm_sdio_driver
= {
490 .id_table
= iwm_sdio_ids
,
491 .probe
= iwm_sdio_probe
,
492 .remove
= iwm_sdio_remove
,
495 static int __init
iwm_sdio_init_module(void)
497 return sdio_register_driver(&iwm_sdio_driver
);
500 static void __exit
iwm_sdio_exit_module(void)
502 sdio_unregister_driver(&iwm_sdio_driver
);
505 module_init(iwm_sdio_init_module
);
506 module_exit(iwm_sdio_exit_module
);
508 MODULE_LICENSE("GPL");
509 MODULE_AUTHOR(IWM_COPYRIGHT
" " IWM_AUTHOR
);