simple_open: automatically convert to simple_open()
[linux-2.6.git] / drivers / net / wireless / iwmc3200wifi / sdio.c
1 /*
2  * Intel Wireless Multicomm 3200 WiFi driver
3  *
4  * Copyright (C) 2009 Intel Corporation. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
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
15  *     distribution.
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.
19  *
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.
31  *
32  *
33  * Intel Corporation <ilw@linux.intel.com>
34  * Samuel Ortiz <samuel.ortiz@intel.com>
35  * Zhu Yi <yi.zhu@intel.com>
36  *
37  */
38
39 /*
40  * This is the SDIO bus specific hooks for iwm.
41  * It also is the module's entry point.
42  *
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)
47  *          -> wiphy_new()
48  *          -> wiphy_register()
49  *      -> alloc_netdev_mq()
50  *      -> register_netdev()
51  *
52  * iwm_sdio_remove()
53  *  -> iwm_if_free() (netdev.c)
54  *      -> unregister_netdev()
55  *      -> iwm_wdev_free() (cfg80211.c)
56  *          -> wiphy_unregister()
57  *          -> wiphy_free()
58  *
59  * iwm_sdio_isr() (called in process context from the SDIO core code)
60  *  -> queue_work(.., isr_worker)
61  *      -- [async] --> iwm_sdio_isr_worker()
62  *                      -> iwm_rx_handle()
63  */
64
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>
73
74 #include "iwm.h"
75 #include "debug.h"
76 #include "bus.h"
77 #include "sdio.h"
78
79 static void iwm_sdio_isr_worker(struct work_struct *work)
80 {
81         struct iwm_sdio_priv *hw;
82         struct iwm_priv *iwm;
83         struct iwm_rx_info *rx_info;
84         struct sk_buff *skb;
85         u8 *rx_buf;
86         unsigned long rx_size;
87
88         hw = container_of(work, struct iwm_sdio_priv, isr_worker);
89         iwm = hw_to_iwm(hw);
90
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;
95                 rx_buf = skb->data;
96
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");
100
101                 kfree_skb(skb);
102         }
103 }
104
105 static void iwm_sdio_isr(struct sdio_func *func)
106 {
107         struct iwm_priv *iwm;
108         struct iwm_sdio_priv *hw;
109         struct iwm_rx_info *rx_info;
110         struct sk_buff *skb;
111         unsigned long buf_size, read_size;
112         int ret;
113         u8 val;
114
115         hw = sdio_get_drvdata(func);
116         iwm = hw_to_iwm(hw);
117
118         buf_size = hw->blk_size;
119
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");
124                 return;
125         }
126
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");
130                 return;
131         }
132
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;
136
137         if (ret < 0) {
138                 IWM_ERR(iwm, "Couldn't read the xfer size\n");
139                 return;
140         }
141
142         /* We need to clear the INT register */
143         sdio_writeb(func, 1, IWM_SDIO_INTR_CLEAR_ADDR, &ret);
144         if (ret < 0) {
145                 IWM_ERR(iwm, "Couldn't clear the INT register\n");
146                 return;
147         }
148
149         while (buf_size < read_size)
150                 buf_size <<= 1;
151
152         skb = dev_alloc_skb(buf_size);
153         if (!skb) {
154                 IWM_ERR(iwm, "Couldn't alloc RX skb\n");
155                 return;
156         }
157         rx_info = skb_to_rx_info(skb);
158         rx_info->rx_size = read_size;
159         rx_info->rx_buf_size = buf_size;
160
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);
164
165         /* The skb is put on a driver's specific Rx SKB list */
166         skb_queue_tail(&iwm->rx_list, skb);
167
168         /* We can now schedule the actual worker */
169         queue_work(hw->isr_wq, &hw->isr_worker);
170 }
171
172 static void iwm_sdio_rx_free(struct iwm_sdio_priv *hw)
173 {
174         struct iwm_priv *iwm = hw_to_iwm(hw);
175
176         flush_workqueue(hw->isr_wq);
177
178         skb_queue_purge(&iwm->rx_list);
179 }
180
181 /* Bus ops */
182 static int if_sdio_enable(struct iwm_priv *iwm)
183 {
184         struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm);
185         int ret;
186
187         sdio_claim_host(hw->func);
188
189         ret = sdio_enable_func(hw->func);
190         if (ret) {
191                 IWM_ERR(iwm, "Couldn't enable the device: is TOP driver "
192                         "loaded and functional?\n");
193                 goto release_host;
194         }
195
196         iwm_reset(iwm);
197
198         ret = sdio_claim_irq(hw->func, iwm_sdio_isr);
199         if (ret) {
200                 IWM_ERR(iwm, "Failed to claim irq: %d\n", ret);
201                 goto release_host;
202         }
203
204         sdio_writeb(hw->func, 1, IWM_SDIO_INTR_ENABLE_ADDR, &ret);
205         if (ret < 0) {
206                 IWM_ERR(iwm, "Couldn't enable INTR: %d\n", ret);
207                 goto release_irq;
208         }
209
210         sdio_release_host(hw->func);
211
212         IWM_DBG_SDIO(iwm, INFO, "IWM SDIO enable\n");
213
214         return 0;
215
216  release_irq:
217         sdio_release_irq(hw->func);
218  release_host:
219         sdio_release_host(hw->func);
220
221         return ret;
222 }
223
224 static int if_sdio_disable(struct iwm_priv *iwm)
225 {
226         struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm);
227         int ret;
228
229         sdio_claim_host(hw->func);
230         sdio_writeb(hw->func, 0, IWM_SDIO_INTR_ENABLE_ADDR, &ret);
231         if (ret < 0)
232                 IWM_WARN(iwm, "Couldn't disable INTR: %d\n", ret);
233
234         sdio_release_irq(hw->func);
235         sdio_disable_func(hw->func);
236         sdio_release_host(hw->func);
237
238         iwm_sdio_rx_free(hw);
239
240         iwm_reset(iwm);
241
242         IWM_DBG_SDIO(iwm, INFO, "IWM SDIO disable\n");
243
244         return 0;
245 }
246
247 static int if_sdio_send_chunk(struct iwm_priv *iwm, u8 *buf, int count)
248 {
249         struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm);
250         int aligned_count = ALIGN(count, hw->blk_size);
251         int ret;
252
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 */
256                 return -EINVAL;
257         }
258
259         sdio_claim_host(hw->func);
260         ret = sdio_memcpy_toio(hw->func, IWM_SDIO_DATA_ADDR, buf,
261                                aligned_count);
262         sdio_release_host(hw->func);
263
264         return ret;
265 }
266
267 static ssize_t iwm_debugfs_sdio_read(struct file *filp, char __user *buffer,
268                                      size_t count, loff_t *ppos)
269 {
270         struct iwm_priv *iwm = filp->private_data;
271         struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm);
272         char *buf;
273         u8 cccr;
274         int buf_len = 4096, ret;
275         size_t len = 0;
276
277         if (*ppos != 0)
278                 return 0;
279         if (count < sizeof(buf))
280                 return -ENOSPC;
281
282         buf = kzalloc(buf_len, GFP_KERNEL);
283         if (!buf)
284                 return -ENOMEM;
285
286         sdio_claim_host(hw->func);
287
288         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_IOEx, &ret);
289         if (ret) {
290                 IWM_ERR(iwm, "Could not read SDIO_CCCR_IOEx\n");
291                 goto err;
292         }
293         len += snprintf(buf + len, buf_len - len, "CCCR_IOEx:  0x%x\n", cccr);
294
295         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_IORx, &ret);
296         if (ret) {
297                 IWM_ERR(iwm, "Could not read SDIO_CCCR_IORx\n");
298                 goto err;
299         }
300         len += snprintf(buf + len, buf_len - len, "CCCR_IORx:  0x%x\n", cccr);
301
302
303         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_IENx, &ret);
304         if (ret) {
305                 IWM_ERR(iwm, "Could not read SDIO_CCCR_IENx\n");
306                 goto err;
307         }
308         len += snprintf(buf + len, buf_len - len, "CCCR_IENx:  0x%x\n", cccr);
309
310
311         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_INTx, &ret);
312         if (ret) {
313                 IWM_ERR(iwm, "Could not read SDIO_CCCR_INTx\n");
314                 goto err;
315         }
316         len += snprintf(buf + len, buf_len - len, "CCCR_INTx:  0x%x\n", cccr);
317
318
319         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_ABORT, &ret);
320         if (ret) {
321                 IWM_ERR(iwm, "Could not read SDIO_CCCR_ABORTx\n");
322                 goto err;
323         }
324         len += snprintf(buf + len, buf_len - len, "CCCR_ABORT: 0x%x\n", cccr);
325
326         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_IF, &ret);
327         if (ret) {
328                 IWM_ERR(iwm, "Could not read SDIO_CCCR_IF\n");
329                 goto err;
330         }
331         len += snprintf(buf + len, buf_len - len, "CCCR_IF:    0x%x\n", cccr);
332
333
334         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_CAPS, &ret);
335         if (ret) {
336                 IWM_ERR(iwm, "Could not read SDIO_CCCR_CAPS\n");
337                 goto err;
338         }
339         len += snprintf(buf + len, buf_len - len, "CCCR_CAPS:  0x%x\n", cccr);
340
341         cccr =  sdio_f0_readb(hw->func, SDIO_CCCR_CIS, &ret);
342         if (ret) {
343                 IWM_ERR(iwm, "Could not read SDIO_CCCR_CIS\n");
344                 goto err;
345         }
346         len += snprintf(buf + len, buf_len - len, "CCCR_CIS:   0x%x\n", cccr);
347
348         ret = simple_read_from_buffer(buffer, len, ppos, buf, buf_len);
349 err:
350         sdio_release_host(hw->func);
351
352         kfree(buf);
353
354         return ret;
355 }
356
357 static const struct file_operations iwm_debugfs_sdio_fops = {
358         .owner =        THIS_MODULE,
359         .open =         simple_open,
360         .read =         iwm_debugfs_sdio_read,
361         .llseek =       default_llseek,
362 };
363
364 static void if_sdio_debugfs_init(struct iwm_priv *iwm, struct dentry *parent_dir)
365 {
366         struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm);
367
368         hw->cccr_dentry = debugfs_create_file("cccr", 0200,
369                                               parent_dir, iwm,
370                                               &iwm_debugfs_sdio_fops);
371 }
372
373 static void if_sdio_debugfs_exit(struct iwm_priv *iwm)
374 {
375         struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm);
376
377         debugfs_remove(hw->cccr_dentry);
378 }
379
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",
389 };
390 MODULE_FIRMWARE("iwmc3200wifi-umac-sdio.bin");
391 MODULE_FIRMWARE("iwmc3200wifi-calib-sdio.bin");
392 MODULE_FIRMWARE("iwmc3200wifi-lmac-sdio.bin");
393
394 static int iwm_sdio_probe(struct sdio_func *func,
395                           const struct sdio_device_id *id)
396 {
397         struct iwm_priv *iwm;
398         struct iwm_sdio_priv *hw;
399         struct device *dev = &func->dev;
400         int ret;
401
402         /* check if TOP has already initialized the card */
403         sdio_claim_host(func);
404         ret = sdio_enable_func(func);
405         if (ret) {
406                 dev_err(dev, "wait for TOP to enable the device\n");
407                 sdio_release_host(func);
408                 return ret;
409         }
410
411         ret = sdio_set_block_size(func, IWM_SDIO_BLK_SIZE);
412
413         sdio_disable_func(func);
414         sdio_release_host(func);
415
416         if (ret < 0) {
417                 dev_err(dev, "Failed to set block size: %d\n", ret);
418                 return ret;
419         }
420
421         iwm = iwm_if_alloc(sizeof(struct iwm_sdio_priv), dev, &if_sdio_ops);
422         if (IS_ERR(iwm)) {
423                 dev_err(dev, "allocate SDIO interface failed\n");
424                 return PTR_ERR(iwm);
425         }
426
427         hw = iwm_private(iwm);
428         hw->iwm = iwm;
429
430         iwm_debugfs_init(iwm);
431
432         sdio_set_drvdata(func, hw);
433
434         hw->func = func;
435         hw->blk_size = IWM_SDIO_BLK_SIZE;
436
437         hw->isr_wq = create_singlethread_workqueue(KBUILD_MODNAME "_sdio");
438         if (!hw->isr_wq) {
439                 ret = -ENOMEM;
440                 goto debugfs_exit;
441         }
442
443         INIT_WORK(&hw->isr_worker, iwm_sdio_isr_worker);
444
445         ret = iwm_if_add(iwm);
446         if (ret) {
447                 dev_err(dev, "add SDIO interface failed\n");
448                 goto destroy_wq;
449         }
450
451         dev_info(dev, "IWM SDIO probe\n");
452
453         return 0;
454
455  destroy_wq:
456         destroy_workqueue(hw->isr_wq);
457  debugfs_exit:
458         iwm_debugfs_exit(iwm);
459         iwm_if_free(iwm);
460         return ret;
461 }
462
463 static void iwm_sdio_remove(struct sdio_func *func)
464 {
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;
468
469         iwm_if_remove(iwm);
470         destroy_workqueue(hw->isr_wq);
471         iwm_debugfs_exit(iwm);
472         iwm_if_free(iwm);
473
474         sdio_set_drvdata(func, NULL);
475
476         dev_info(dev, "IWM SDIO remove\n");
477 }
478
479 static const struct sdio_device_id iwm_sdio_ids[] = {
480         /* Global/AGN SKU */
481         { SDIO_DEVICE(SDIO_VENDOR_ID_INTEL, 0x1403) },
482         /* BGN SKU */
483         { SDIO_DEVICE(SDIO_VENDOR_ID_INTEL, 0x1408) },
484         { /* end: all zeroes */ },
485 };
486 MODULE_DEVICE_TABLE(sdio, iwm_sdio_ids);
487
488 static struct sdio_driver iwm_sdio_driver = {
489         .name           = "iwm_sdio",
490         .id_table       = iwm_sdio_ids,
491         .probe          = iwm_sdio_probe,
492         .remove         = iwm_sdio_remove,
493 };
494
495 static int __init iwm_sdio_init_module(void)
496 {
497         return sdio_register_driver(&iwm_sdio_driver);
498 }
499
500 static void __exit iwm_sdio_exit_module(void)
501 {
502         sdio_unregister_driver(&iwm_sdio_driver);
503 }
504
505 module_init(iwm_sdio_init_module);
506 module_exit(iwm_sdio_exit_module);
507
508 MODULE_LICENSE("GPL");
509 MODULE_AUTHOR(IWM_COPYRIGHT " " IWM_AUTHOR);