Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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, see <http://www.gnu.org/licenses/>.
 16  *
 17  */
 18 
 19 #include <linux/interrupt.h>
 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://wireless.kernel.org/en/users/Drivers/p54 */
 42 static DEFINE_PCI_DEVICE_TABLE(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          PCI_VDEVICE(3COM, 0x6001), 0
 53         },
 54 
 55         /* Intersil PRISM Indigo Wireless LAN adapter */
 56         {
 57          0x1260, 0x3877,
 58          PCI_ANY_ID, PCI_ANY_ID,
 59          0, 0, 0
 60         },
 61 
 62         /* Intersil PRISM Javelin/Xbow Wireless LAN adapter */
 63         {
 64          0x1260, 0x3886,
 65          PCI_ANY_ID, PCI_ANY_ID,
 66          0, 0, 0
 67         },
 68 
 69         /* End of list */
 70         {0,0,0,0,0,0,0}
 71 };
 72 
 73 /* register the device with the Hotplug facilities of the kernel */
 74 MODULE_DEVICE_TABLE(pci, prism54_id_tbl);
 75 
 76 static int prism54_probe(struct pci_dev *, const struct pci_device_id *);
 77 static void prism54_remove(struct pci_dev *);
 78 static int prism54_suspend(struct pci_dev *, pm_message_t state);
 79 static int prism54_resume(struct pci_dev *);
 80 
 81 static struct pci_driver prism54_driver = {
 82         .name = DRV_NAME,
 83         .id_table = prism54_id_tbl,
 84         .probe = prism54_probe,
 85         .remove = prism54_remove,
 86         .suspend = prism54_suspend,
 87         .resume = prism54_resume,
 88 };
 89 
 90 /******************************************************************************
 91     Module initialization functions
 92 ******************************************************************************/
 93 
 94 static int
 95 prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 96 {
 97         struct net_device *ndev;
 98         u8 latency_tmr;
 99         u32 mem_addr;
100         islpci_private *priv;
101         int rvalue;
102 
103         /* Enable the pci device */
104         if (pci_enable_device(pdev)) {
105                 printk(KERN_ERR "%s: pci_enable_device() failed.\n", DRV_NAME);
106                 return -ENODEV;
107         }
108 
109         /* check whether the latency timer is set correctly */
110         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_tmr);
111 #if VERBOSE > SHOW_ERROR_MESSAGES
112         DEBUG(SHOW_TRACING, "latency timer: %x\n", latency_tmr);
113 #endif
114         if (latency_tmr < PCIDEVICE_LATENCY_TIMER_MIN) {
115                 /* set the latency timer */
116                 pci_write_config_byte(pdev, PCI_LATENCY_TIMER,
117                                       PCIDEVICE_LATENCY_TIMER_VAL);
118         }
119 
120         /* enable PCI DMA */
121         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
122                 printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME);
123                 goto do_pci_disable_device;
124         }
125 
126         /* 0x40 is the programmable timer to configure the response timeout (TRDY_TIMEOUT)
127          * 0x41 is the programmable timer to configure the retry timeout (RETRY_TIMEOUT)
128          *      The RETRY_TIMEOUT is used to set the number of retries that the core, as a
129          *      Master, will perform before abandoning a cycle. The default value for
130          *      RETRY_TIMEOUT is 0x80, which far exceeds the PCI 2.1 requirement for new
131          *      devices. A write of zero to the RETRY_TIMEOUT register disables this
132          *      function to allow use with any non-compliant legacy devices that may
133          *      execute more retries.
134          *
135          *      Writing zero to both these two registers will disable both timeouts and
136          *      *can* solve problems caused by devices that are slow to respond.
137          *      Make this configurable - MSW
138          */
139         if ( init_pcitm >= 0 ) {
140                 pci_write_config_byte(pdev, 0x40, (u8)init_pcitm);
141                 pci_write_config_byte(pdev, 0x41, (u8)init_pcitm);
142         } else {
143                 printk(KERN_INFO "PCI TRDY/RETRY unchanged\n");
144         }
145 
146         /* request the pci device I/O regions */
147         rvalue = pci_request_regions(pdev, DRV_NAME);
148         if (rvalue) {
149                 printk(KERN_ERR "%s: pci_request_regions failure (rc=%d)\n",
150                        DRV_NAME, rvalue);
151                 goto do_pci_disable_device;
152         }
153 
154         /* check if the memory window is indeed set */
155         rvalue = pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &mem_addr);
156         if (rvalue || !mem_addr) {
157                 printk(KERN_ERR "%s: PCI device memory region not configured; fix your BIOS or CardBus bridge/drivers\n",
158                        DRV_NAME);
159                 goto do_pci_release_regions;
160         }
161 
162         /* enable PCI bus-mastering */
163         DEBUG(SHOW_TRACING, "%s: pci_set_master(pdev)\n", DRV_NAME);
164         pci_set_master(pdev);
165 
166         /* enable MWI */
167         pci_try_set_mwi(pdev);
168 
169         /* setup the network device interface and its structure */
170         if (!(ndev = islpci_setup(pdev))) {
171                 /* error configuring the driver as a network device */
172                 printk(KERN_ERR "%s: could not configure network device\n",
173                        DRV_NAME);
174                 goto do_pci_clear_mwi;
175         }
176 
177         priv = netdev_priv(ndev);
178         islpci_set_state(priv, PRV_STATE_PREBOOT); /* we are attempting to boot */
179 
180         /* card is in unknown state yet, might have some interrupts pending */
181         isl38xx_disable_interrupts(priv->device_base);
182 
183         /* request for the interrupt before uploading the firmware */
184         rvalue = request_irq(pdev->irq, islpci_interrupt,
185                              IRQF_SHARED, ndev->name, priv);
186 
187         if (rvalue) {
188                 /* error, could not hook the handler to the irq */
189                 printk(KERN_ERR "%s: could not install IRQ handler\n",
190                        ndev->name);
191                 goto do_unregister_netdev;
192         }
193 
194         /* firmware upload is triggered in islpci_open */
195 
196         return 0;
197 
198       do_unregister_netdev:
199         unregister_netdev(ndev);
200         islpci_free_memory(priv);
201         free_netdev(ndev);
202         priv = NULL;
203       do_pci_clear_mwi:
204         pci_clear_mwi(pdev);
205       do_pci_release_regions:
206         pci_release_regions(pdev);
207       do_pci_disable_device:
208         pci_disable_device(pdev);
209         return -EIO;
210 }
211 
212 /* set by cleanup_module */
213 static volatile int __in_cleanup_module = 0;
214 
215 /* this one removes one(!!) instance only */
216 static void
217 prism54_remove(struct pci_dev *pdev)
218 {
219         struct net_device *ndev = pci_get_drvdata(pdev);
220         islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
221         BUG_ON(!priv);
222 
223         if (!__in_cleanup_module) {
224                 printk(KERN_DEBUG "%s: hot unplug detected\n", ndev->name);
225                 islpci_set_state(priv, PRV_STATE_OFF);
226         }
227 
228         printk(KERN_DEBUG "%s: removing device\n", ndev->name);
229 
230         unregister_netdev(ndev);
231 
232         /* free the interrupt request */
233 
234         if (islpci_get_state(priv) != PRV_STATE_OFF) {
235                 isl38xx_disable_interrupts(priv->device_base);
236                 islpci_set_state(priv, PRV_STATE_OFF);
237                 /* This bellow causes a lockup at rmmod time. It might be
238                  * because some interrupts still linger after rmmod time,
239                  * see bug #17 */
240                 /* pci_set_power_state(pdev, 3);*/      /* try to power-off */
241         }
242 
243         free_irq(pdev->irq, priv);
244 
245         /* free the PCI memory and unmap the remapped page */
246         islpci_free_memory(priv);
247 
248         free_netdev(ndev);
249         priv = NULL;
250 
251         pci_clear_mwi(pdev);
252 
253         pci_release_regions(pdev);
254 
255         pci_disable_device(pdev);
256 }
257 
258 static int
259 prism54_suspend(struct pci_dev *pdev, pm_message_t state)
260 {
261         struct net_device *ndev = pci_get_drvdata(pdev);
262         islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
263         BUG_ON(!priv);
264 
265 
266         pci_save_state(pdev);
267 
268         /* tell the device not to trigger interrupts for now... */
269         isl38xx_disable_interrupts(priv->device_base);
270 
271         /* from now on assume the hardware was already powered down
272            and don't touch it anymore */
273         islpci_set_state(priv, PRV_STATE_OFF);
274 
275         netif_stop_queue(ndev);
276         netif_device_detach(ndev);
277 
278         return 0;
279 }
280 
281 static int
282 prism54_resume(struct pci_dev *pdev)
283 {
284         struct net_device *ndev = pci_get_drvdata(pdev);
285         islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
286         int err;
287 
288         BUG_ON(!priv);
289 
290         printk(KERN_NOTICE "%s: got resume request\n", ndev->name);
291 
292         err = pci_enable_device(pdev);
293         if (err) {
294                 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
295                        ndev->name);
296                 return err;
297         }
298 
299         pci_restore_state(pdev);
300 
301         /* alright let's go into the PREBOOT state */
302         islpci_reset(priv, 1);
303 
304         netif_device_attach(ndev);
305         netif_start_queue(ndev);
306 
307         return 0;
308 }
309 
310 static int __init
311 prism54_module_init(void)
312 {
313         printk(KERN_INFO "Loaded %s driver, version %s\n",
314                DRV_NAME, DRV_VERSION);
315 
316         __bug_on_wrong_struct_sizes ();
317 
318         return pci_register_driver(&prism54_driver);
319 }
320 
321 /* by the time prism54_module_exit() terminates, as a postcondition
322  * all instances will have been destroyed by calls to
323  * prism54_remove() */
324 static void __exit
325 prism54_module_exit(void)
326 {
327         __in_cleanup_module = 1;
328 
329         pci_unregister_driver(&prism54_driver);
330 
331         printk(KERN_INFO "Unloaded %s driver\n", DRV_NAME);
332 
333         __in_cleanup_module = 0;
334 }
335 
336 /* register entry points */
337 module_init(prism54_module_init);
338 module_exit(prism54_module_exit);
339 /* EOF */
340 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us