Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 LT |
2 | * Copyright (C) 2002 Intersil Americas Inc. |
3 | * Copyright (C) 2003 Herbert Valerio Riedel <hvr@gnu.org> | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation; either version 2 of the License | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program; if not, write to the Free Software | |
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
17 | * | |
18 | */ | |
19 | ||
1da177e4 LT |
20 | #include <linux/module.h> |
21 | #include <linux/pci.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/init.h> /* For __init, __exit */ | |
910638ae | 24 | #include <linux/dma-mapping.h> |
1da177e4 LT |
25 | |
26 | #include "prismcompat.h" | |
27 | #include "islpci_dev.h" | |
28 | #include "islpci_mgt.h" /* for pc_debug */ | |
29 | #include "isl_oid.h" | |
30 | ||
1da177e4 LT |
31 | MODULE_AUTHOR("[Intersil] R.Bastings and W.Termorshuizen, The prism54.org Development Team <prism54-devel@prism54.org>"); |
32 | MODULE_DESCRIPTION("The Prism54 802.11 Wireless LAN adapter"); | |
33 | MODULE_LICENSE("GPL"); | |
34 | ||
35 | static int init_pcitm = 0; | |
36 | module_param(init_pcitm, int, 0); | |
37 | ||
38 | /* In this order: vendor, device, subvendor, subdevice, class, class_mask, | |
93b2dd12 DT |
39 | * driver_data |
40 | * If you have an update for this please contact prism54-devel@prism54.org | |
1da177e4 LT |
41 | * The latest list can be found at http://prism54.org/supported_cards.php */ |
42 | static const struct pci_device_id prism54_id_tbl[] = { | |
43 | /* Intersil PRISM Duette/Prism GT Wireless LAN adapter */ | |
44 | { | |
45 | 0x1260, 0x3890, | |
46 | PCI_ANY_ID, PCI_ANY_ID, | |
47 | 0, 0, 0 | |
48 | }, | |
49 | ||
50 | /* 3COM 3CRWE154G72 Wireless LAN adapter */ | |
51 | { | |
52 | 0x10b7, 0x6001, | |
53 | PCI_ANY_ID, PCI_ANY_ID, | |
54 | 0, 0, 0 | |
55 | }, | |
56 | ||
57 | /* Intersil PRISM Indigo Wireless LAN adapter */ | |
58 | { | |
59 | 0x1260, 0x3877, | |
60 | PCI_ANY_ID, PCI_ANY_ID, | |
61 | 0, 0, 0 | |
62 | }, | |
63 | ||
64 | /* Intersil PRISM Javelin/Xbow Wireless LAN adapter */ | |
65 | { | |
66 | 0x1260, 0x3886, | |
67 | PCI_ANY_ID, PCI_ANY_ID, | |
68 | 0, 0, 0 | |
69 | }, | |
70 | ||
71 | /* End of list */ | |
72 | {0,0,0,0,0,0,0} | |
73 | }; | |
74 | ||
75 | /* register the device with the Hotplug facilities of the kernel */ | |
76 | MODULE_DEVICE_TABLE(pci, prism54_id_tbl); | |
77 | ||
78 | static int prism54_probe(struct pci_dev *, const struct pci_device_id *); | |
79 | static void prism54_remove(struct pci_dev *); | |
05adc3b7 | 80 | static int prism54_suspend(struct pci_dev *, pm_message_t state); |
1da177e4 LT |
81 | static int prism54_resume(struct pci_dev *); |
82 | ||
83 | static struct pci_driver prism54_driver = { | |
84 | .name = DRV_NAME, | |
85 | .id_table = prism54_id_tbl, | |
86 | .probe = prism54_probe, | |
87 | .remove = prism54_remove, | |
88 | .suspend = prism54_suspend, | |
89 | .resume = prism54_resume, | |
1da177e4 LT |
90 | }; |
91 | ||
92 | /****************************************************************************** | |
93 | Module initialization functions | |
94 | ******************************************************************************/ | |
95 | ||
6dd01480 | 96 | static int |
1da177e4 LT |
97 | prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id) |
98 | { | |
99 | struct net_device *ndev; | |
100 | u8 latency_tmr; | |
101 | u32 mem_addr; | |
102 | islpci_private *priv; | |
103 | int rvalue; | |
104 | ||
105 | /* Enable the pci device */ | |
106 | if (pci_enable_device(pdev)) { | |
107 | printk(KERN_ERR "%s: pci_enable_device() failed.\n", DRV_NAME); | |
108 | return -ENODEV; | |
109 | } | |
110 | ||
111 | /* check whether the latency timer is set correctly */ | |
112 | pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_tmr); | |
113 | #if VERBOSE > SHOW_ERROR_MESSAGES | |
114 | DEBUG(SHOW_TRACING, "latency timer: %x\n", latency_tmr); | |
115 | #endif | |
116 | if (latency_tmr < PCIDEVICE_LATENCY_TIMER_MIN) { | |
117 | /* set the latency timer */ | |
118 | pci_write_config_byte(pdev, PCI_LATENCY_TIMER, | |
119 | PCIDEVICE_LATENCY_TIMER_VAL); | |
120 | } | |
121 | ||
122 | /* enable PCI DMA */ | |
910638ae | 123 | if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) { |
1da177e4 LT |
124 | printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME); |
125 | goto do_pci_disable_device; | |
126 | } | |
127 | ||
128 | /* 0x40 is the programmable timer to configure the response timeout (TRDY_TIMEOUT) | |
129 | * 0x41 is the programmable timer to configure the retry timeout (RETRY_TIMEOUT) | |
93b2dd12 DT |
130 | * The RETRY_TIMEOUT is used to set the number of retries that the core, as a |
131 | * Master, will perform before abandoning a cycle. The default value for | |
132 | * RETRY_TIMEOUT is 0x80, which far exceeds the PCI 2.1 requirement for new | |
133 | * devices. A write of zero to the RETRY_TIMEOUT register disables this | |
134 | * function to allow use with any non-compliant legacy devices that may | |
135 | * execute more retries. | |
1da177e4 | 136 | * |
93b2dd12 DT |
137 | * Writing zero to both these two registers will disable both timeouts and |
138 | * *can* solve problems caused by devices that are slow to respond. | |
1da177e4 LT |
139 | * Make this configurable - MSW |
140 | */ | |
141 | if ( init_pcitm >= 0 ) { | |
142 | pci_write_config_byte(pdev, 0x40, (u8)init_pcitm); | |
143 | pci_write_config_byte(pdev, 0x41, (u8)init_pcitm); | |
144 | } else { | |
145 | printk(KERN_INFO "PCI TRDY/RETRY unchanged\n"); | |
146 | } | |
147 | ||
148 | /* request the pci device I/O regions */ | |
149 | rvalue = pci_request_regions(pdev, DRV_NAME); | |
150 | if (rvalue) { | |
151 | printk(KERN_ERR "%s: pci_request_regions failure (rc=%d)\n", | |
152 | DRV_NAME, rvalue); | |
153 | goto do_pci_disable_device; | |
154 | } | |
155 | ||
156 | /* check if the memory window is indeed set */ | |
157 | rvalue = pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &mem_addr); | |
158 | if (rvalue || !mem_addr) { | |
159 | printk(KERN_ERR "%s: PCI device memory region not configured; fix your BIOS or CardBus bridge/drivers\n", | |
160 | DRV_NAME); | |
161 | goto do_pci_release_regions; | |
162 | } | |
163 | ||
164 | /* enable PCI bus-mastering */ | |
165 | DEBUG(SHOW_TRACING, "%s: pci_set_master(pdev)\n", DRV_NAME); | |
166 | pci_set_master(pdev); | |
167 | ||
168 | /* enable MWI */ | |
694625c0 | 169 | pci_try_set_mwi(pdev); |
1da177e4 LT |
170 | |
171 | /* setup the network device interface and its structure */ | |
172 | if (!(ndev = islpci_setup(pdev))) { | |
173 | /* error configuring the driver as a network device */ | |
174 | printk(KERN_ERR "%s: could not configure network device\n", | |
175 | DRV_NAME); | |
02e0e5e9 | 176 | goto do_pci_clear_mwi; |
1da177e4 LT |
177 | } |
178 | ||
179 | priv = netdev_priv(ndev); | |
180 | islpci_set_state(priv, PRV_STATE_PREBOOT); /* we are attempting to boot */ | |
181 | ||
182 | /* card is in unknown state yet, might have some interrupts pending */ | |
183 | isl38xx_disable_interrupts(priv->device_base); | |
184 | ||
185 | /* request for the interrupt before uploading the firmware */ | |
186 | rvalue = request_irq(pdev->irq, &islpci_interrupt, | |
1fb9df5d | 187 | IRQF_SHARED, ndev->name, priv); |
1da177e4 LT |
188 | |
189 | if (rvalue) { | |
190 | /* error, could not hook the handler to the irq */ | |
191 | printk(KERN_ERR "%s: could not install IRQ handler\n", | |
192 | ndev->name); | |
193 | goto do_unregister_netdev; | |
194 | } | |
195 | ||
196 | /* firmware upload is triggered in islpci_open */ | |
197 | ||
198 | return 0; | |
199 | ||
200 | do_unregister_netdev: | |
201 | unregister_netdev(ndev); | |
202 | islpci_free_memory(priv); | |
203 | pci_set_drvdata(pdev, NULL); | |
204 | free_netdev(ndev); | |
205 | priv = NULL; | |
02e0e5e9 JL |
206 | do_pci_clear_mwi: |
207 | pci_clear_mwi(pdev); | |
1da177e4 LT |
208 | do_pci_release_regions: |
209 | pci_release_regions(pdev); | |
210 | do_pci_disable_device: | |
211 | pci_disable_device(pdev); | |
212 | return -EIO; | |
213 | } | |
214 | ||
215 | /* set by cleanup_module */ | |
216 | static volatile int __in_cleanup_module = 0; | |
217 | ||
218 | /* this one removes one(!!) instance only */ | |
6dd01480 | 219 | static void |
1da177e4 LT |
220 | prism54_remove(struct pci_dev *pdev) |
221 | { | |
222 | struct net_device *ndev = pci_get_drvdata(pdev); | |
223 | islpci_private *priv = ndev ? netdev_priv(ndev) : NULL; | |
224 | BUG_ON(!priv); | |
225 | ||
226 | if (!__in_cleanup_module) { | |
227 | printk(KERN_DEBUG "%s: hot unplug detected\n", ndev->name); | |
228 | islpci_set_state(priv, PRV_STATE_OFF); | |
229 | } | |
230 | ||
231 | printk(KERN_DEBUG "%s: removing device\n", ndev->name); | |
232 | ||
233 | unregister_netdev(ndev); | |
234 | ||
235 | /* free the interrupt request */ | |
236 | ||
237 | if (islpci_get_state(priv) != PRV_STATE_OFF) { | |
238 | isl38xx_disable_interrupts(priv->device_base); | |
239 | islpci_set_state(priv, PRV_STATE_OFF); | |
240 | /* This bellow causes a lockup at rmmod time. It might be | |
93b2dd12 | 241 | * because some interrupts still linger after rmmod time, |
1da177e4 LT |
242 | * see bug #17 */ |
243 | /* pci_set_power_state(pdev, 3);*/ /* try to power-off */ | |
244 | } | |
245 | ||
246 | free_irq(pdev->irq, priv); | |
247 | ||
248 | /* free the PCI memory and unmap the remapped page */ | |
249 | islpci_free_memory(priv); | |
250 | ||
251 | pci_set_drvdata(pdev, NULL); | |
252 | free_netdev(ndev); | |
253 | priv = NULL; | |
254 | ||
02e0e5e9 JL |
255 | pci_clear_mwi(pdev); |
256 | ||
1da177e4 LT |
257 | pci_release_regions(pdev); |
258 | ||
259 | pci_disable_device(pdev); | |
260 | } | |
261 | ||
6dd01480 | 262 | static int |
05adc3b7 | 263 | prism54_suspend(struct pci_dev *pdev, pm_message_t state) |
1da177e4 LT |
264 | { |
265 | struct net_device *ndev = pci_get_drvdata(pdev); | |
266 | islpci_private *priv = ndev ? netdev_priv(ndev) : NULL; | |
267 | BUG_ON(!priv); | |
268 | ||
1da177e4 LT |
269 | |
270 | pci_save_state(pdev); | |
271 | ||
272 | /* tell the device not to trigger interrupts for now... */ | |
273 | isl38xx_disable_interrupts(priv->device_base); | |
274 | ||
275 | /* from now on assume the hardware was already powered down | |
276 | and don't touch it anymore */ | |
277 | islpci_set_state(priv, PRV_STATE_OFF); | |
278 | ||
279 | netif_stop_queue(ndev); | |
280 | netif_device_detach(ndev); | |
281 | ||
282 | return 0; | |
283 | } | |
284 | ||
6dd01480 | 285 | static int |
1da177e4 LT |
286 | prism54_resume(struct pci_dev *pdev) |
287 | { | |
288 | struct net_device *ndev = pci_get_drvdata(pdev); | |
289 | islpci_private *priv = ndev ? netdev_priv(ndev) : NULL; | |
02e0e5e9 | 290 | int err; |
1da177e4 | 291 | |
02e0e5e9 | 292 | BUG_ON(!priv); |
1da177e4 LT |
293 | |
294 | printk(KERN_NOTICE "%s: got resume request\n", ndev->name); | |
295 | ||
02e0e5e9 JL |
296 | err = pci_enable_device(pdev); |
297 | if (err) { | |
298 | printk(KERN_ERR "%s: pci_enable_device failed on resume\n", | |
299 | ndev->name); | |
300 | return err; | |
301 | } | |
302 | ||
1da177e4 LT |
303 | pci_restore_state(pdev); |
304 | ||
305 | /* alright let's go into the PREBOOT state */ | |
306 | islpci_reset(priv, 1); | |
307 | ||
308 | netif_device_attach(ndev); | |
309 | netif_start_queue(ndev); | |
310 | ||
311 | return 0; | |
312 | } | |
313 | ||
314 | static int __init | |
315 | prism54_module_init(void) | |
316 | { | |
317 | printk(KERN_INFO "Loaded %s driver, version %s\n", | |
318 | DRV_NAME, DRV_VERSION); | |
319 | ||
320 | __bug_on_wrong_struct_sizes (); | |
321 | ||
29917620 | 322 | return pci_register_driver(&prism54_driver); |
1da177e4 LT |
323 | } |
324 | ||
325 | /* by the time prism54_module_exit() terminates, as a postcondition | |
326 | * all instances will have been destroyed by calls to | |
327 | * prism54_remove() */ | |
328 | static void __exit | |
329 | prism54_module_exit(void) | |
330 | { | |
331 | __in_cleanup_module = 1; | |
332 | ||
333 | pci_unregister_driver(&prism54_driver); | |
334 | ||
335 | printk(KERN_INFO "Unloaded %s driver\n", DRV_NAME); | |
336 | ||
337 | __in_cleanup_module = 0; | |
338 | } | |
339 | ||
340 | /* register entry points */ | |
341 | module_init(prism54_module_init); | |
342 | module_exit(prism54_module_exit); | |
343 | /* EOF */ |