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