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