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