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