Subversion Repositories test_project

/*

 *  Copyright (C) 2002 Intersil Americas Inc.

 *  Copyright (C) 2003 Herbert Valerio Riedel <hvr@gnu.org>

 *

 *  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/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 <prism54-devel@prism54.org>");

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 prism54-devel@prism54.org

 * The latest list can be found at http://prism54.org/supported_cards.php */

static const struct pci_device_id 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 */

        {

         0x10b7, 0x6001,

         PCI_ANY_ID, PCI_ANY_ID,

         0, 0, 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

******************************************************************************/

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_32BIT_MASK)) {

                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 */

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);

}

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;

}

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 */