[deliverable/linux.git] / drivers / net / wireless / prism54 / islpci_hotplug.c

/*
 *  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/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 <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://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 */
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	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
a6b7a407	20	#include <linux/interrupt.h>
1da177e4 LT	21	#include <linux/module.h>
	22	#include <linux/pci.h>
	23	#include <linux/delay.h>
	24	#include <linux/init.h> /* For __init, __exit */
910638ae	25	#include <linux/dma-mapping.h>
1da177e4 LT	26
	27	#include "prismcompat.h"
	28	#include "islpci_dev.h"
	29	#include "islpci_mgt.h" /* for pc_debug */
	30	#include "isl_oid.h"
	31
1da177e4 LT	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,
93b2dd12 DT	40	* driver_data
93b2dd12 DT	41	* If you have an update for this please contact prism54-devel@prism54.org
631dd1a8	42	* The latest list can be found at http://wireless.kernel.org/en/users/Drivers/p54 */
a3aa1884	43	static DEFINE_PCI_DEVICE_TABLE(prism54_id_tbl) = {
1da177e4 LT	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	{
8ab0ea77	53	PCI_VDEVICE(3COM, 0x6001), 0
1da177e4 LT	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 *);
05adc3b7	79	static int prism54_suspend(struct pci_dev *, pm_message_t state);
1da177e4 LT	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,
1da177e4 LT	89	};
	90
	91	/******************************************************************************
	92	Module initialization functions
	93	******************************************************************************/
	94
6dd01480	95	static int
1da177e4 LT	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 */
284901a9	122	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
1da177e4 LT	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)
93b2dd12 DT	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.
1da177e4	135	*
93b2dd12 DT	136	* Writing zero to both these two registers will disable both timeouts and
93b2dd12 DT	137	* can solve problems caused by devices that are slow to respond.
1da177e4 LT	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 */
694625c0	168	pci_try_set_mwi(pdev);
1da177e4 LT	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);
02e0e5e9	175	goto do_pci_clear_mwi;
1da177e4 LT	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 */
a0607fd3	185	rvalue = request_irq(pdev->irq, islpci_interrupt,
1fb9df5d	186	IRQF_SHARED, ndev->name, priv);
1da177e4 LT	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;
02e0e5e9 JL	205	do_pci_clear_mwi:
02e0e5e9 JL	206	pci_clear_mwi(pdev);
1da177e4 LT	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 */
6dd01480	218	static void
1da177e4 LT	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
93b2dd12	240	* because some interrupts still linger after rmmod time,
1da177e4 LT	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
02e0e5e9 JL	254	pci_clear_mwi(pdev);
02e0e5e9 JL	255
1da177e4 LT	256	pci_release_regions(pdev);
	257
	258	pci_disable_device(pdev);
	259	}
	260
6dd01480	261	static int
05adc3b7	262	prism54_suspend(struct pci_dev *pdev, pm_message_t state)
1da177e4 LT	263	{
	264	struct net_device *ndev = pci_get_drvdata(pdev);
	265	islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
	266	BUG_ON(!priv);
	267
1da177e4 LT	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
6dd01480	284	static int
1da177e4 LT	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;
02e0e5e9	289	int err;
1da177e4	290
02e0e5e9	291	BUG_ON(!priv);
1da177e4 LT	292
	293	printk(KERN_NOTICE "%s: got resume request\n", ndev->name);
	294
02e0e5e9 JL	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
1da177e4 LT	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
29917620	321	return pci_register_driver(&prism54_driver);
1da177e4 LT	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 */