Merge master.kernel.org:/pub/scm/linux/kernel/git/holtmann/bluetooth-2.6
[linux-2.6] / drivers / net / wireless / hostap / hostap_pci.c
1 #define PRISM2_PCI
2
3 /* Host AP driver's support for Intersil Prism2.5 PCI cards is based on
4  * driver patches from Reyk Floeter <reyk@vantronix.net> and
5  * Andy Warner <andyw@pobox.com> */
6
7 #include <linux/config.h>
8 #include <linux/version.h>
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/if.h>
12 #include <linux/skbuff.h>
13 #include <linux/netdevice.h>
14 #include <linux/workqueue.h>
15 #include <linux/wireless.h>
16 #include <net/iw_handler.h>
17
18 #include <linux/ioport.h>
19 #include <linux/pci.h>
20 #include <asm/io.h>
21
22 #include "hostap_wlan.h"
23
24
25 static char *version = PRISM2_VERSION " (Jouni Malinen <jkmaline@cc.hut.fi>)";
26 static char *dev_info = "hostap_pci";
27
28
29 MODULE_AUTHOR("Jouni Malinen");
30 MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "
31                    "PCI cards.");
32 MODULE_SUPPORTED_DEVICE("Intersil Prism2.5-based WLAN PCI cards");
33 MODULE_LICENSE("GPL");
34 MODULE_VERSION(PRISM2_VERSION);
35
36
37 /* struct local_info::hw_priv */
38 struct hostap_pci_priv {
39         void __iomem *mem_start;
40 };
41
42
43 /* FIX: do we need mb/wmb/rmb with memory operations? */
44
45
46 static struct pci_device_id prism2_pci_id_table[] __devinitdata = {
47         /* Intersil Prism3 ISL3872 11Mb/s WLAN Controller */
48         { 0x1260, 0x3872, PCI_ANY_ID, PCI_ANY_ID },
49         /* Intersil Prism2.5 ISL3874 11Mb/s WLAN Controller */
50         { 0x1260, 0x3873, PCI_ANY_ID, PCI_ANY_ID },
51         /* Samsung MagicLAN SWL-2210P */
52         { 0x167d, 0xa000, PCI_ANY_ID, PCI_ANY_ID },
53         { 0 }
54 };
55
56
57 #ifdef PRISM2_IO_DEBUG
58
59 static inline void hfa384x_outb_debug(struct net_device *dev, int a, u8 v)
60 {
61         struct hostap_interface *iface;
62         struct hostap_pci_priv *hw_priv;
63         local_info_t *local;
64         unsigned long flags;
65
66         iface = netdev_priv(dev);
67         local = iface->local;
68         hw_priv = local->hw_priv;
69
70         spin_lock_irqsave(&local->lock, flags);
71         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTB, a, v);
72         writeb(v, hw_priv->mem_start + a);
73         spin_unlock_irqrestore(&local->lock, flags);
74 }
75
76 static inline u8 hfa384x_inb_debug(struct net_device *dev, int a)
77 {
78         struct hostap_interface *iface;
79         struct hostap_pci_priv *hw_priv;
80         local_info_t *local;
81         unsigned long flags;
82         u8 v;
83
84         iface = netdev_priv(dev);
85         local = iface->local;
86         hw_priv = local->hw_priv;
87
88         spin_lock_irqsave(&local->lock, flags);
89         v = readb(hw_priv->mem_start + a);
90         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INB, a, v);
91         spin_unlock_irqrestore(&local->lock, flags);
92         return v;
93 }
94
95 static inline void hfa384x_outw_debug(struct net_device *dev, int a, u16 v)
96 {
97         struct hostap_interface *iface;
98         struct hostap_pci_priv *hw_priv;
99         local_info_t *local;
100         unsigned long flags;
101
102         iface = netdev_priv(dev);
103         local = iface->local;
104         hw_priv = local->hw_priv;
105
106         spin_lock_irqsave(&local->lock, flags);
107         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTW, a, v);
108         writew(v, hw_priv->mem_start + a);
109         spin_unlock_irqrestore(&local->lock, flags);
110 }
111
112 static inline u16 hfa384x_inw_debug(struct net_device *dev, int a)
113 {
114         struct hostap_interface *iface;
115         struct hostap_pci_priv *hw_priv;
116         local_info_t *local;
117         unsigned long flags;
118         u16 v;
119
120         iface = netdev_priv(dev);
121         local = iface->local;
122         hw_priv = local->hw_priv;
123
124         spin_lock_irqsave(&local->lock, flags);
125         v = readw(hw_priv->mem_start + a);
126         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INW, a, v);
127         spin_unlock_irqrestore(&local->lock, flags);
128         return v;
129 }
130
131 #define HFA384X_OUTB(v,a) hfa384x_outb_debug(dev, (a), (v))
132 #define HFA384X_INB(a) hfa384x_inb_debug(dev, (a))
133 #define HFA384X_OUTW(v,a) hfa384x_outw_debug(dev, (a), (v))
134 #define HFA384X_INW(a) hfa384x_inw_debug(dev, (a))
135 #define HFA384X_OUTW_DATA(v,a) hfa384x_outw_debug(dev, (a), cpu_to_le16((v)))
136 #define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw_debug(dev, (a)))
137
138 #else /* PRISM2_IO_DEBUG */
139
140 static inline void hfa384x_outb(struct net_device *dev, int a, u8 v)
141 {
142         struct hostap_interface *iface;
143         struct hostap_pci_priv *hw_priv;
144         iface = netdev_priv(dev);
145         hw_priv = iface->local->hw_priv;
146         writeb(v, hw_priv->mem_start + a);
147 }
148
149 static inline u8 hfa384x_inb(struct net_device *dev, int a)
150 {
151         struct hostap_interface *iface;
152         struct hostap_pci_priv *hw_priv;
153         iface = netdev_priv(dev);
154         hw_priv = iface->local->hw_priv;
155         return readb(hw_priv->mem_start + a);
156 }
157
158 static inline void hfa384x_outw(struct net_device *dev, int a, u16 v)
159 {
160         struct hostap_interface *iface;
161         struct hostap_pci_priv *hw_priv;
162         iface = netdev_priv(dev);
163         hw_priv = iface->local->hw_priv;
164         writew(v, hw_priv->mem_start + a);
165 }
166
167 static inline u16 hfa384x_inw(struct net_device *dev, int a)
168 {
169         struct hostap_interface *iface;
170         struct hostap_pci_priv *hw_priv;
171         iface = netdev_priv(dev);
172         hw_priv = iface->local->hw_priv;
173         return readw(hw_priv->mem_start + a);
174 }
175
176 #define HFA384X_OUTB(v,a) hfa384x_outb(dev, (a), (v))
177 #define HFA384X_INB(a) hfa384x_inb(dev, (a))
178 #define HFA384X_OUTW(v,a) hfa384x_outw(dev, (a), (v))
179 #define HFA384X_INW(a) hfa384x_inw(dev, (a))
180 #define HFA384X_OUTW_DATA(v,a) hfa384x_outw(dev, (a), cpu_to_le16((v)))
181 #define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw(dev, (a)))
182
183 #endif /* PRISM2_IO_DEBUG */
184
185
186 static int hfa384x_from_bap(struct net_device *dev, u16 bap, void *buf,
187                             int len)
188 {
189         u16 d_off;
190         u16 *pos;
191
192         d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
193         pos = (u16 *) buf;
194
195         for ( ; len > 1; len -= 2)
196                 *pos++ = HFA384X_INW_DATA(d_off);
197
198         if (len & 1)
199                 *((char *) pos) = HFA384X_INB(d_off);
200
201         return 0;
202 }
203
204
205 static int hfa384x_to_bap(struct net_device *dev, u16 bap, void *buf, int len)
206 {
207         u16 d_off;
208         u16 *pos;
209
210         d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
211         pos = (u16 *) buf;
212
213         for ( ; len > 1; len -= 2)
214                 HFA384X_OUTW_DATA(*pos++, d_off);
215
216         if (len & 1)
217                 HFA384X_OUTB(*((char *) pos), d_off);
218
219         return 0;
220 }
221
222
223 /* FIX: This might change at some point.. */
224 #include "hostap_hw.c"
225
226 static void prism2_pci_cor_sreset(local_info_t *local)
227 {
228         struct net_device *dev = local->dev;
229         u16 reg;
230
231         reg = HFA384X_INB(HFA384X_PCICOR_OFF);
232         printk(KERN_DEBUG "%s: Original COR value: 0x%0x\n", dev->name, reg);
233
234         /* linux-wlan-ng uses extremely long hold and settle times for
235          * COR sreset. A comment in the driver code mentions that the long
236          * delays appear to be necessary. However, at least IBM 22P6901 seems
237          * to work fine with shorter delays.
238          *
239          * Longer delays can be configured by uncommenting following line: */
240 /* #define PRISM2_PCI_USE_LONG_DELAYS */
241
242 #ifdef PRISM2_PCI_USE_LONG_DELAYS
243         int i;
244
245         HFA384X_OUTW(reg | 0x0080, HFA384X_PCICOR_OFF);
246         mdelay(250);
247
248         HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
249         mdelay(500);
250
251         /* Wait for f/w to complete initialization (CMD:BUSY == 0) */
252         i = 2000000 / 10;
253         while ((HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) && --i)
254                 udelay(10);
255
256 #else /* PRISM2_PCI_USE_LONG_DELAYS */
257
258         HFA384X_OUTW(reg | 0x0080, HFA384X_PCICOR_OFF);
259         mdelay(2);
260         HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
261         mdelay(2);
262
263 #endif /* PRISM2_PCI_USE_LONG_DELAYS */
264
265         if (HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) {
266                 printk(KERN_DEBUG "%s: COR sreset timeout\n", dev->name);
267         }
268 }
269
270
271 static void prism2_pci_genesis_reset(local_info_t *local, int hcr)
272 {
273         struct net_device *dev = local->dev;
274
275         HFA384X_OUTW(0x00C5, HFA384X_PCICOR_OFF);
276         mdelay(10);
277         HFA384X_OUTW(hcr, HFA384X_PCIHCR_OFF);
278         mdelay(10);
279         HFA384X_OUTW(0x0045, HFA384X_PCICOR_OFF);
280         mdelay(10);
281 }
282
283
284 static struct prism2_helper_functions prism2_pci_funcs =
285 {
286         .card_present   = NULL,
287         .cor_sreset     = prism2_pci_cor_sreset,
288         .genesis_reset  = prism2_pci_genesis_reset,
289         .hw_type        = HOSTAP_HW_PCI,
290 };
291
292
293 static int prism2_pci_probe(struct pci_dev *pdev,
294                             const struct pci_device_id *id)
295 {
296         unsigned long phymem;
297         void __iomem *mem = NULL;
298         local_info_t *local = NULL;
299         struct net_device *dev = NULL;
300         static int cards_found /* = 0 */;
301         int irq_registered = 0;
302         struct hostap_interface *iface;
303         struct hostap_pci_priv *hw_priv;
304
305         hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
306         if (hw_priv == NULL)
307                 return -ENOMEM;
308         memset(hw_priv, 0, sizeof(*hw_priv));
309
310         if (pci_enable_device(pdev))
311                 return -EIO;
312
313         phymem = pci_resource_start(pdev, 0);
314
315         if (!request_mem_region(phymem, pci_resource_len(pdev, 0), "Prism2")) {
316                 printk(KERN_ERR "prism2: Cannot reserve PCI memory region\n");
317                 goto err_out_disable;
318         }
319
320         mem = ioremap(phymem, pci_resource_len(pdev, 0));
321         if (mem == NULL) {
322                 printk(KERN_ERR "prism2: Cannot remap PCI memory region\n") ;
323                 goto fail;
324         }
325
326         dev = prism2_init_local_data(&prism2_pci_funcs, cards_found,
327                                      &pdev->dev);
328         if (dev == NULL)
329                 goto fail;
330         iface = netdev_priv(dev);
331         local = iface->local;
332         local->hw_priv = hw_priv;
333         cards_found++;
334
335         dev->irq = pdev->irq;
336         hw_priv->mem_start = mem;
337
338         prism2_pci_cor_sreset(local);
339
340         pci_set_drvdata(pdev, dev);
341
342         if (request_irq(dev->irq, prism2_interrupt, SA_SHIRQ, dev->name,
343                         dev)) {
344                 printk(KERN_WARNING "%s: request_irq failed\n", dev->name);
345                 goto fail;
346         } else
347                 irq_registered = 1;
348
349         if (!local->pri_only && prism2_hw_config(dev, 1)) {
350                 printk(KERN_DEBUG "%s: hardware initialization failed\n",
351                        dev_info);
352                 goto fail;
353         }
354
355         printk(KERN_INFO "%s: Intersil Prism2.5 PCI: "
356                "mem=0x%lx, irq=%d\n", dev->name, phymem, dev->irq);
357
358         return hostap_hw_ready(dev);
359
360  fail:
361         if (irq_registered && dev)
362                 free_irq(dev->irq, dev);
363
364         if (mem)
365                 iounmap(mem);
366
367         release_mem_region(phymem, pci_resource_len(pdev, 0));
368
369  err_out_disable:
370         pci_disable_device(pdev);
371         prism2_free_local_data(dev);
372         kfree(hw_priv);
373
374         return -ENODEV;
375 }
376
377
378 static void prism2_pci_remove(struct pci_dev *pdev)
379 {
380         struct net_device *dev;
381         struct hostap_interface *iface;
382         void __iomem *mem_start;
383         struct hostap_pci_priv *hw_priv;
384
385         dev = pci_get_drvdata(pdev);
386         iface = netdev_priv(dev);
387         hw_priv = iface->local->hw_priv;
388
389         /* Reset the hardware, and ensure interrupts are disabled. */
390         prism2_pci_cor_sreset(iface->local);
391         hfa384x_disable_interrupts(dev);
392
393         if (dev->irq)
394                 free_irq(dev->irq, dev);
395
396         mem_start = hw_priv->mem_start;
397         prism2_free_local_data(dev);
398         kfree(hw_priv);
399
400         iounmap(mem_start);
401
402         release_mem_region(pci_resource_start(pdev, 0),
403                            pci_resource_len(pdev, 0));
404         pci_disable_device(pdev);
405 }
406
407
408 #ifdef CONFIG_PM
409 static int prism2_pci_suspend(struct pci_dev *pdev, pm_message_t state)
410 {
411         struct net_device *dev = pci_get_drvdata(pdev);
412
413         if (netif_running(dev)) {
414                 netif_stop_queue(dev);
415                 netif_device_detach(dev);
416         }
417         prism2_suspend(dev);
418         pci_save_state(pdev);
419         pci_disable_device(pdev);
420         pci_set_power_state(pdev, PCI_D3hot);
421
422         return 0;
423 }
424
425 static int prism2_pci_resume(struct pci_dev *pdev)
426 {
427         struct net_device *dev = pci_get_drvdata(pdev);
428
429         pci_enable_device(pdev);
430         pci_restore_state(pdev);
431         prism2_hw_config(dev, 0);
432         if (netif_running(dev)) {
433                 netif_device_attach(dev);
434                 netif_start_queue(dev);
435         }
436
437         return 0;
438 }
439 #endif /* CONFIG_PM */
440
441
442 MODULE_DEVICE_TABLE(pci, prism2_pci_id_table);
443
444 static struct pci_driver prism2_pci_drv_id = {
445         .name           = "hostap_pci",
446         .id_table       = prism2_pci_id_table,
447         .probe          = prism2_pci_probe,
448         .remove         = prism2_pci_remove,
449 #ifdef CONFIG_PM
450         .suspend        = prism2_pci_suspend,
451         .resume         = prism2_pci_resume,
452 #endif /* CONFIG_PM */
453         /* Linux 2.4.6 added save_state and enable_wake that are not used here
454          */
455 };
456
457
458 static int __init init_prism2_pci(void)
459 {
460         printk(KERN_INFO "%s: %s\n", dev_info, version);
461
462         return pci_register_driver(&prism2_pci_drv_id);
463 }
464
465
466 static void __exit exit_prism2_pci(void)
467 {
468         pci_unregister_driver(&prism2_pci_drv_id);
469         printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
470 }
471
472
473 module_init(init_prism2_pci);
474 module_exit(exit_prism2_pci);