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