Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / drivers / net / wireless / prism54 / islpci_hotplug.c
1 /*
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
20 #include <linux/module.h>
21 #include <linux/pci.h>
22 #include <linux/delay.h>
23 #include <linux/init.h> /* For __init, __exit */
24 #include <linux/dma-mapping.h>
25
26 #include "prismcompat.h"
27 #include "islpci_dev.h"
28 #include "islpci_mgt.h"         /* for pc_debug */
29 #include "isl_oid.h"
30
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,
39  * driver_data
40  * If you have an update for this please contact prism54-devel@prism54.org
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 *);
80 static int prism54_suspend(struct pci_dev *, pm_message_t state);
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,
90 };
91
92 /******************************************************************************
93     Module initialization functions
94 ******************************************************************************/
95
96 static int
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 */
123         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
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)
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.
136          *
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.
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 */
169         pci_try_set_mwi(pdev);
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);
176                 goto do_pci_clear_mwi;
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,
187                              IRQF_SHARED, ndev->name, priv);
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;
206       do_pci_clear_mwi:
207         pci_clear_mwi(pdev);
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 */
219 static void
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
241                  * because some interrupts still linger after rmmod time,
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
255         pci_clear_mwi(pdev);
256
257         pci_release_regions(pdev);
258
259         pci_disable_device(pdev);
260 }
261
262 static int
263 prism54_suspend(struct pci_dev *pdev, pm_message_t state)
264 {
265         struct net_device *ndev = pci_get_drvdata(pdev);
266         islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
267         BUG_ON(!priv);
268
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
285 static int
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;
290         int err;
291
292         BUG_ON(!priv);
293
294         printk(KERN_NOTICE "%s: got resume request\n", ndev->name);
295
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
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
322         return pci_register_driver(&prism54_driver);
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 */