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