islpci_hotplug.c

Go to the documentation of this file.

/*
 *  Copyright (C) 2002 Intersil Americas Inc.
 *  Copyright (C) 2003 Herbert Valerio Riedel <[email protected]>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/init.h> /* For __init, __exit */
#include <linux/dma-mapping.h>

#include "prismcompat.h"
#include "islpci_dev.h"
#include "islpci_mgt.h"     /* for pc_debug */
#include "isl_oid.h"

MODULE_AUTHOR("[Intersil] R.Bastings and W.Termorshuizen, The prism54.org Development Team <[email protected]>");
MODULE_DESCRIPTION("The Prism54 802.11 Wireless LAN adapter");
MODULE_LICENSE("GPL");

static int  init_pcitm = 0;
module_param(init_pcitm, int, 0);

/* In this order: vendor, device, subvendor, subdevice, class, class_mask,
 * driver_data
 * If you have an update for this please contact [email protected]
 * The latest list can be found at http://wireless.kernel.org/en/users/Drivers/p54 */
static DEFINE_PCI_DEVICE_TABLE(prism54_id_tbl) = {
    /* Intersil PRISM Duette/Prism GT Wireless LAN adapter */
    {
     0x1260, 0x3890,
     PCI_ANY_ID, PCI_ANY_ID,
     0, 0, 0
    },

    /* 3COM 3CRWE154G72 Wireless LAN adapter */
    {
     PCI_VDEVICE(3COM, 0x6001), 0
    },

    /* Intersil PRISM Indigo Wireless LAN adapter */
    {
     0x1260, 0x3877,
     PCI_ANY_ID, PCI_ANY_ID,
     0, 0, 0
    },

    /* Intersil PRISM Javelin/Xbow Wireless LAN adapter */
    {
     0x1260, 0x3886,
     PCI_ANY_ID, PCI_ANY_ID,
     0, 0, 0
    },

    /* End of list */
    {0,0,0,0,0,0,0}
};

/* register the device with the Hotplug facilities of the kernel */
MODULE_DEVICE_TABLE(pci, prism54_id_tbl);

static int prism54_probe(struct pci_dev *, const struct pci_device_id *);
static void prism54_remove(struct pci_dev *);
static int prism54_suspend(struct pci_dev *, pm_message_t state);
static int prism54_resume(struct pci_dev *);

static struct pci_driver prism54_driver = {
    .name = DRV_NAME,
    .id_table = prism54_id_tbl,
    .probe = prism54_probe,
    .remove = prism54_remove,
    .suspend = prism54_suspend,
    .resume = prism54_resume,
};

/******************************************************************************
    Module initialization functions
******************************************************************************/

static int
prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
    struct net_device *ndev;
    u8 latency_tmr;
    u32 mem_addr;
    islpci_private *priv;
    int rvalue;

    /* Enable the pci device */
    if (pci_enable_device(pdev)) {
        printk(KERN_ERR "%s: pci_enable_device() failed.\n", DRV_NAME);
        return -ENODEV;
    }

    /* check whether the latency timer is set correctly */
    pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_tmr);
#if VERBOSE > SHOW_ERROR_MESSAGES
    DEBUG(SHOW_TRACING, "latency timer: %x\n", latency_tmr);
#endif
    if (latency_tmr < PCIDEVICE_LATENCY_TIMER_MIN) {
        /* set the latency timer */
        pci_write_config_byte(pdev, PCI_LATENCY_TIMER,
                      PCIDEVICE_LATENCY_TIMER_VAL);
    }

    /* enable PCI DMA */
    if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
        printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME);
        goto do_pci_disable_device;
        }

    /* 0x40 is the programmable timer to configure the response timeout (TRDY_TIMEOUT)
     * 0x41 is the programmable timer to configure the retry timeout (RETRY_TIMEOUT)
     *  The RETRY_TIMEOUT is used to set the number of retries that the core, as a
     *  Master, will perform before abandoning a cycle. The default value for
     *  RETRY_TIMEOUT is 0x80, which far exceeds the PCI 2.1 requirement for new
     *  devices. A write of zero to the RETRY_TIMEOUT register disables this
     *  function to allow use with any non-compliant legacy devices that may
     *  execute more retries.
     *
     *  Writing zero to both these two registers will disable both timeouts and
     *  *can* solve problems caused by devices that are slow to respond.
     *  Make this configurable - MSW
     */
    if ( init_pcitm >= 0 ) {
        pci_write_config_byte(pdev, 0x40, (u8)init_pcitm);
        pci_write_config_byte(pdev, 0x41, (u8)init_pcitm);
    } else {
        printk(KERN_INFO "PCI TRDY/RETRY unchanged\n");
    }

    /* request the pci device I/O regions */
    rvalue = pci_request_regions(pdev, DRV_NAME);
    if (rvalue) {
        printk(KERN_ERR "%s: pci_request_regions failure (rc=%d)\n",
               DRV_NAME, rvalue);
        goto do_pci_disable_device;
    }

    /* check if the memory window is indeed set */
    rvalue = pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &mem_addr);
    if (rvalue || !mem_addr) {
        printk(KERN_ERR "%s: PCI device memory region not configured; fix your BIOS or CardBus bridge/drivers\n",
               DRV_NAME);
        goto do_pci_release_regions;
    }

    /* enable PCI bus-mastering */
    DEBUG(SHOW_TRACING, "%s: pci_set_master(pdev)\n", DRV_NAME);
    pci_set_master(pdev);

    /* enable MWI */
    pci_try_set_mwi(pdev);

    /* setup the network device interface and its structure */
    if (!(ndev = islpci_setup(pdev))) {
        /* error configuring the driver as a network device */
        printk(KERN_ERR "%s: could not configure network device\n",
               DRV_NAME);
        goto do_pci_clear_mwi;
    }

    priv = netdev_priv(ndev);
    islpci_set_state(priv, PRV_STATE_PREBOOT); /* we are attempting to boot */

    /* card is in unknown state yet, might have some interrupts pending */
    isl38xx_disable_interrupts(priv->device_base);

    /* request for the interrupt before uploading the firmware */
    rvalue = request_irq(pdev->irq, islpci_interrupt,
                 IRQF_SHARED, ndev->name, priv);

    if (rvalue) {
        /* error, could not hook the handler to the irq */
        printk(KERN_ERR "%s: could not install IRQ handler\n",
               ndev->name);
        goto do_unregister_netdev;
    }

    /* firmware upload is triggered in islpci_open */

    return 0;

      do_unregister_netdev:
    unregister_netdev(ndev);
    islpci_free_memory(priv);
    pci_set_drvdata(pdev, NULL);
    free_netdev(ndev);
    priv = NULL;
      do_pci_clear_mwi:
    pci_clear_mwi(pdev);
      do_pci_release_regions:
    pci_release_regions(pdev);
      do_pci_disable_device:
    pci_disable_device(pdev);
    return -EIO;
}

/* set by cleanup_module */
static volatile int __in_cleanup_module = 0;

/* this one removes one(!!) instance only */
static void
prism54_remove(struct pci_dev *pdev)
{
    struct net_device *ndev = pci_get_drvdata(pdev);
    islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
    BUG_ON(!priv);

    if (!__in_cleanup_module) {
        printk(KERN_DEBUG "%s: hot unplug detected\n", ndev->name);
        islpci_set_state(priv, PRV_STATE_OFF);
    }

    printk(KERN_DEBUG "%s: removing device\n", ndev->name);

    unregister_netdev(ndev);

    /* free the interrupt request */

    if (islpci_get_state(priv) != PRV_STATE_OFF) {
        isl38xx_disable_interrupts(priv->device_base);
        islpci_set_state(priv, PRV_STATE_OFF);
        /* This bellow causes a lockup at rmmod time. It might be
         * because some interrupts still linger after rmmod time,
         * see bug #17 */
        /* pci_set_power_state(pdev, 3);*/  /* try to power-off */
    }

    free_irq(pdev->irq, priv);

    /* free the PCI memory and unmap the remapped page */
    islpci_free_memory(priv);

    pci_set_drvdata(pdev, NULL);
    free_netdev(ndev);
    priv = NULL;

    pci_clear_mwi(pdev);

    pci_release_regions(pdev);

    pci_disable_device(pdev);
}

static int
prism54_suspend(struct pci_dev *pdev, pm_message_t state)
{
    struct net_device *ndev = pci_get_drvdata(pdev);
    islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
    BUG_ON(!priv);


    pci_save_state(pdev);

    /* tell the device not to trigger interrupts for now... */
    isl38xx_disable_interrupts(priv->device_base);

    /* from now on assume the hardware was already powered down
       and don't touch it anymore */
    islpci_set_state(priv, PRV_STATE_OFF);

    netif_stop_queue(ndev);
    netif_device_detach(ndev);

    return 0;
}

static int
prism54_resume(struct pci_dev *pdev)
{
    struct net_device *ndev = pci_get_drvdata(pdev);
    islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
    int err;

    BUG_ON(!priv);

    printk(KERN_NOTICE "%s: got resume request\n", ndev->name);

    err = pci_enable_device(pdev);
    if (err) {
        printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
               ndev->name);
        return err;
    }

    pci_restore_state(pdev);

    /* alright let's go into the PREBOOT state */
    islpci_reset(priv, 1);

    netif_device_attach(ndev);
    netif_start_queue(ndev);

    return 0;
}

static int __init
prism54_module_init(void)
{
    printk(KERN_INFO "Loaded %s driver, version %s\n",
           DRV_NAME, DRV_VERSION);

    __bug_on_wrong_struct_sizes ();

    return pci_register_driver(&prism54_driver);
}

/* by the time prism54_module_exit() terminates, as a postcondition
 * all instances will have been destroyed by calls to
 * prism54_remove() */
static void __exit
prism54_module_exit(void)
{
    __in_cleanup_module = 1;

    pci_unregister_driver(&prism54_driver);

    printk(KERN_INFO "Unloaded %s driver\n", DRV_NAME);

    __in_cleanup_module = 0;
}

/* register entry points */
module_init(prism54_module_init);
module_exit(prism54_module_exit);
/* EOF */