[deliverable/linux.git] / drivers / net / wireless / hostap / hostap_pci.c

#define PRISM2_PCI

/* Host AP driver's support for Intersil Prism2.5 PCI cards is based on
 * driver patches from Reyk Floeter <reyk@vantronix.net> and
 * Andy Warner <andyw@pobox.com> */

#include <linux/config.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/if.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/workqueue.h>
#include <linux/wireless.h>
#include <net/iw_handler.h>

#include <linux/ioport.h>
#include <linux/pci.h>
#include <asm/io.h>

#include "hostap_wlan.h"


static char *version = PRISM2_VERSION " (Jouni Malinen <jkmaline@cc.hut.fi>)";
static char *dev_info = "hostap_pci";


MODULE_AUTHOR("Jouni Malinen");
MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "
		   "PCI cards.");
MODULE_SUPPORTED_DEVICE("Intersil Prism2.5-based WLAN PCI cards");
MODULE_LICENSE("GPL");
MODULE_VERSION(PRISM2_VERSION);


/* struct local_info::hw_priv */
struct hostap_pci_priv {
	void __iomem *mem_start;
};


/* FIX: do we need mb/wmb/rmb with memory operations? */


static struct pci_device_id prism2_pci_id_table[] __devinitdata = {
	/* Intersil Prism3 ISL3872 11Mb/s WLAN Controller */
	{ 0x1260, 0x3872, PCI_ANY_ID, PCI_ANY_ID },
	/* Intersil Prism2.5 ISL3874 11Mb/s WLAN Controller */
	{ 0x1260, 0x3873, PCI_ANY_ID, PCI_ANY_ID },
	/* Samsung MagicLAN SWL-2210P */
	{ 0x167d, 0xa000, PCI_ANY_ID, PCI_ANY_ID },
	{ 0 }
};


#ifdef PRISM2_IO_DEBUG

static inline void hfa384x_outb_debug(struct net_device *dev, int a, u8 v)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	local_info_t *local;
	unsigned long flags;

	iface = netdev_priv(dev);
	local = iface->local;
	hw_priv = local->hw_priv;

	spin_lock_irqsave(&local->lock, flags);
	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTB, a, v);
	writeb(v, hw_priv->mem_start + a);
	spin_unlock_irqrestore(&local->lock, flags);
}

static inline u8 hfa384x_inb_debug(struct net_device *dev, int a)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	local_info_t *local;
	unsigned long flags;
	u8 v;

	iface = netdev_priv(dev);
	local = iface->local;
	hw_priv = local->hw_priv;

	spin_lock_irqsave(&local->lock, flags);
	v = readb(hw_priv->mem_start + a);
	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INB, a, v);
	spin_unlock_irqrestore(&local->lock, flags);
	return v;
}

static inline void hfa384x_outw_debug(struct net_device *dev, int a, u16 v)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	local_info_t *local;
	unsigned long flags;

	iface = netdev_priv(dev);
	local = iface->local;
	hw_priv = local->hw_priv;

	spin_lock_irqsave(&local->lock, flags);
	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTW, a, v);
	writew(v, hw_priv->mem_start + a);
	spin_unlock_irqrestore(&local->lock, flags);
}

static inline u16 hfa384x_inw_debug(struct net_device *dev, int a)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	local_info_t *local;
	unsigned long flags;
	u16 v;

	iface = netdev_priv(dev);
	local = iface->local;
	hw_priv = local->hw_priv;

	spin_lock_irqsave(&local->lock, flags);
	v = readw(hw_priv->mem_start + a);
	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INW, a, v);
	spin_unlock_irqrestore(&local->lock, flags);
	return v;
}

#define HFA384X_OUTB(v,a) hfa384x_outb_debug(dev, (a), (v))
#define HFA384X_INB(a) hfa384x_inb_debug(dev, (a))
#define HFA384X_OUTW(v,a) hfa384x_outw_debug(dev, (a), (v))
#define HFA384X_INW(a) hfa384x_inw_debug(dev, (a))
#define HFA384X_OUTW_DATA(v,a) hfa384x_outw_debug(dev, (a), cpu_to_le16((v)))
#define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw_debug(dev, (a)))

#else /* PRISM2_IO_DEBUG */

static inline void hfa384x_outb(struct net_device *dev, int a, u8 v)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	iface = netdev_priv(dev);
	hw_priv = iface->local->hw_priv;
	writeb(v, hw_priv->mem_start + a);
}

static inline u8 hfa384x_inb(struct net_device *dev, int a)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	iface = netdev_priv(dev);
	hw_priv = iface->local->hw_priv;
	return readb(hw_priv->mem_start + a);
}

static inline void hfa384x_outw(struct net_device *dev, int a, u16 v)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	iface = netdev_priv(dev);
	hw_priv = iface->local->hw_priv;
	writew(v, hw_priv->mem_start + a);
}

static inline u16 hfa384x_inw(struct net_device *dev, int a)
{
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;
	iface = netdev_priv(dev);
	hw_priv = iface->local->hw_priv;
	return readw(hw_priv->mem_start + a);
}

#define HFA384X_OUTB(v,a) hfa384x_outb(dev, (a), (v))
#define HFA384X_INB(a) hfa384x_inb(dev, (a))
#define HFA384X_OUTW(v,a) hfa384x_outw(dev, (a), (v))
#define HFA384X_INW(a) hfa384x_inw(dev, (a))
#define HFA384X_OUTW_DATA(v,a) hfa384x_outw(dev, (a), cpu_to_le16((v)))
#define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw(dev, (a)))

#endif /* PRISM2_IO_DEBUG */


static int hfa384x_from_bap(struct net_device *dev, u16 bap, void *buf,
			    int len)
{
	u16 d_off;
	u16 *pos;

	d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
	pos = (u16 *) buf;

	for ( ; len > 1; len -= 2)
		*pos++ = HFA384X_INW_DATA(d_off);

	if (len & 1)
		*((char *) pos) = HFA384X_INB(d_off);

	return 0;
}


static int hfa384x_to_bap(struct net_device *dev, u16 bap, void *buf, int len)
{
	u16 d_off;
	u16 *pos;

	d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
	pos = (u16 *) buf;

	for ( ; len > 1; len -= 2)
		HFA384X_OUTW_DATA(*pos++, d_off);

	if (len & 1)
		HFA384X_OUTB(*((char *) pos), d_off);

	return 0;
}


/* FIX: This might change at some point.. */
#include "hostap_hw.c"

static void prism2_pci_cor_sreset(local_info_t *local)
{
	struct net_device *dev = local->dev;
	u16 reg;

	reg = HFA384X_INB(HFA384X_PCICOR_OFF);
	printk(KERN_DEBUG "%s: Original COR value: 0x%0x\n", dev->name, reg);

	/* linux-wlan-ng uses extremely long hold and settle times for
	 * COR sreset. A comment in the driver code mentions that the long
	 * delays appear to be necessary. However, at least IBM 22P6901 seems
	 * to work fine with shorter delays.
	 *
	 * Longer delays can be configured by uncommenting following line: */
/* #define PRISM2_PCI_USE_LONG_DELAYS */

#ifdef PRISM2_PCI_USE_LONG_DELAYS
	int i;

	HFA384X_OUTW(reg | 0x0080, HFA384X_PCICOR_OFF);
	mdelay(250);

	HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
	mdelay(500);

	/* Wait for f/w to complete initialization (CMD:BUSY == 0) */
	i = 2000000 / 10;
	while ((HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) && --i)
		udelay(10);

#else /* PRISM2_PCI_USE_LONG_DELAYS */

	HFA384X_OUTW(reg | 0x0080, HFA384X_PCICOR_OFF);
	mdelay(2);
	HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
	mdelay(2);

#endif /* PRISM2_PCI_USE_LONG_DELAYS */

	if (HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) {
		printk(KERN_DEBUG "%s: COR sreset timeout\n", dev->name);
	}
}


static void prism2_pci_genesis_reset(local_info_t *local, int hcr)
{
	struct net_device *dev = local->dev;

	HFA384X_OUTW(0x00C5, HFA384X_PCICOR_OFF);
	mdelay(10);
	HFA384X_OUTW(hcr, HFA384X_PCIHCR_OFF);
	mdelay(10);
	HFA384X_OUTW(0x0045, HFA384X_PCICOR_OFF);
	mdelay(10);
}


static struct prism2_helper_functions prism2_pci_funcs =
{
	.card_present	= NULL,
	.cor_sreset	= prism2_pci_cor_sreset,
	.genesis_reset	= prism2_pci_genesis_reset,
	.hw_type	= HOSTAP_HW_PCI,
};


static int prism2_pci_probe(struct pci_dev *pdev,
			    const struct pci_device_id *id)
{
	unsigned long phymem;
	void __iomem *mem = NULL;
	local_info_t *local = NULL;
	struct net_device *dev = NULL;
	static int cards_found /* = 0 */;
	int irq_registered = 0;
	struct hostap_interface *iface;
	struct hostap_pci_priv *hw_priv;

	hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
	if (hw_priv == NULL)
		return -ENOMEM;
	memset(hw_priv, 0, sizeof(*hw_priv));

	if (pci_enable_device(pdev))
		return -EIO;

	phymem = pci_resource_start(pdev, 0);

	if (!request_mem_region(phymem, pci_resource_len(pdev, 0), "Prism2")) {
		printk(KERN_ERR "prism2: Cannot reserve PCI memory region\n");
		goto err_out_disable;
	}

	mem = ioremap(phymem, pci_resource_len(pdev, 0));
	if (mem == NULL) {
		printk(KERN_ERR "prism2: Cannot remap PCI memory region\n") ;
		goto fail;
	}

	dev = prism2_init_local_data(&prism2_pci_funcs, cards_found,
				     &pdev->dev);
	if (dev == NULL)
		goto fail;
	iface = netdev_priv(dev);
	local = iface->local;
	local->hw_priv = hw_priv;
	cards_found++;

        dev->irq = pdev->irq;
        hw_priv->mem_start = mem;

	prism2_pci_cor_sreset(local);

	pci_set_drvdata(pdev, dev);

	if (request_irq(dev->irq, prism2_interrupt, SA_SHIRQ, dev->name,
			dev)) {
		printk(KERN_WARNING "%s: request_irq failed\n", dev->name);
		goto fail;
	} else
		irq_registered = 1;

	if (!local->pri_only && prism2_hw_config(dev, 1)) {
		printk(KERN_DEBUG "%s: hardware initialization failed\n",
		       dev_info);
		goto fail;
	}

	printk(KERN_INFO "%s: Intersil Prism2.5 PCI: "
	       "mem=0x%lx, irq=%d\n", dev->name, phymem, dev->irq);

	return hostap_hw_ready(dev);

 fail:
	if (irq_registered && dev)
		free_irq(dev->irq, dev);

	if (mem)
		iounmap(mem);

	release_mem_region(phymem, pci_resource_len(pdev, 0));

 err_out_disable:
	pci_disable_device(pdev);
	prism2_free_local_data(dev);
	kfree(hw_priv);

	return -ENODEV;
}


static void prism2_pci_remove(struct pci_dev *pdev)
{
	struct net_device *dev;
	struct hostap_interface *iface;
	void __iomem *mem_start;
	struct hostap_pci_priv *hw_priv;

	dev = pci_get_drvdata(pdev);
	iface = netdev_priv(dev);
	hw_priv = iface->local->hw_priv;

	/* Reset the hardware, and ensure interrupts are disabled. */
	prism2_pci_cor_sreset(iface->local);
	hfa384x_disable_interrupts(dev);

	if (dev->irq)
		free_irq(dev->irq, dev);

	mem_start = hw_priv->mem_start;
	prism2_free_local_data(dev);
	kfree(hw_priv);

	iounmap(mem_start);

	release_mem_region(pci_resource_start(pdev, 0),
			   pci_resource_len(pdev, 0));
	pci_disable_device(pdev);
}


#ifdef CONFIG_PM
static int prism2_pci_suspend(struct pci_dev *pdev, pm_message_t state)
{
	struct net_device *dev = pci_get_drvdata(pdev);

	if (netif_running(dev)) {
		netif_stop_queue(dev);
		netif_device_detach(dev);
	}
	prism2_suspend(dev);
	pci_save_state(pdev);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

static int prism2_pci_resume(struct pci_dev *pdev)
{
	struct net_device *dev = pci_get_drvdata(pdev);

	pci_enable_device(pdev);
	pci_restore_state(pdev);
	prism2_hw_config(dev, 0);
	if (netif_running(dev)) {
		netif_device_attach(dev);
		netif_start_queue(dev);
	}

	return 0;
}
#endif /* CONFIG_PM */


MODULE_DEVICE_TABLE(pci, prism2_pci_id_table);

static struct pci_driver prism2_pci_drv_id = {
	.name		= "hostap_pci",
	.id_table	= prism2_pci_id_table,
	.probe		= prism2_pci_probe,
	.remove		= prism2_pci_remove,
#ifdef CONFIG_PM
	.suspend	= prism2_pci_suspend,
	.resume		= prism2_pci_resume,
#endif /* CONFIG_PM */
	/* Linux 2.4.6 added save_state and enable_wake that are not used here
	 */
};


static int __init init_prism2_pci(void)
{
	printk(KERN_INFO "%s: %s\n", dev_info, version);

	return pci_register_driver(&prism2_pci_drv_id);
}


static void __exit exit_prism2_pci(void)
{
	pci_unregister_driver(&prism2_pci_drv_id);
	printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
}


module_init(init_prism2_pci);
module_exit(exit_prism2_pci);
Commit	Line	Data
ff1d2767 JM	1	#define PRISM2_PCI
	2
	3	/* Host AP driver's support for Intersil Prism2.5 PCI cards is based on
	4	* driver patches from Reyk Floeter <reyk@vantronix.net> and
	5	* Andy Warner <andyw@pobox.com> */
	6
	7	#include <linux/config.h>
	8	#include <linux/version.h>
	9	#include <linux/module.h>
	10	#include <linux/init.h>
	11	#include <linux/if.h>
	12	#include <linux/skbuff.h>
	13	#include <linux/netdevice.h>
	14	#include <linux/workqueue.h>
	15	#include <linux/wireless.h>
	16	#include <net/iw_handler.h>
	17
	18	#include <linux/ioport.h>
	19	#include <linux/pci.h>
	20	#include <asm/io.h>
	21
	22	#include "hostap_wlan.h"
	23
	24
	25	static char *version = PRISM2_VERSION " (Jouni Malinen <jkmaline@cc.hut.fi>)";
	26	static char *dev_info = "hostap_pci";
	27
	28
	29	MODULE_AUTHOR("Jouni Malinen");
	30	MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "
	31	"PCI cards.");
	32	MODULE_SUPPORTED_DEVICE("Intersil Prism2.5-based WLAN PCI cards");
	33	MODULE_LICENSE("GPL");
f06ac319	34	MODULE_VERSION(PRISM2_VERSION);
ff1d2767 JM	35
ff1d2767 JM	36
67e0e473 JM	37	/* struct local_info::hw_priv */
	38	struct hostap_pci_priv {
	39	void __iomem *mem_start;
	40	};
	41
	42
ff1d2767 JM	43	/* FIX: do we need mb/wmb/rmb with memory operations? */
	44
	45
	46	static struct pci_device_id prism2_pci_id_table[] __devinitdata = {
	47	/* Intersil Prism3 ISL3872 11Mb/s WLAN Controller */
	48	{ 0x1260, 0x3872, PCI_ANY_ID, PCI_ANY_ID },
	49	/* Intersil Prism2.5 ISL3874 11Mb/s WLAN Controller */
	50	{ 0x1260, 0x3873, PCI_ANY_ID, PCI_ANY_ID },
	51	/* Samsung MagicLAN SWL-2210P */
	52	{ 0x167d, 0xa000, PCI_ANY_ID, PCI_ANY_ID },
	53	{ 0 }
	54	};
	55
	56
	57	#ifdef PRISM2_IO_DEBUG
	58
	59	static inline void hfa384x_outb_debug(struct net_device *dev, int a, u8 v)
	60	{
	61	struct hostap_interface *iface;
f7a74447	62	struct hostap_pci_priv *hw_priv;
ff1d2767 JM	63	local_info_t *local;
	64	unsigned long flags;
	65
	66	iface = netdev_priv(dev);
	67	local = iface->local;
f7a74447	68	hw_priv = local->hw_priv;
ff1d2767 JM	69
	70	spin_lock_irqsave(&local->lock, flags);
	71	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTB, a, v);
67e0e473	72	writeb(v, hw_priv->mem_start + a);
ff1d2767 JM	73	spin_unlock_irqrestore(&local->lock, flags);
	74	}
	75
	76	static inline u8 hfa384x_inb_debug(struct net_device *dev, int a)
	77	{
	78	struct hostap_interface *iface;
f7a74447	79	struct hostap_pci_priv *hw_priv;
ff1d2767 JM	80	local_info_t *local;
	81	unsigned long flags;
	82	u8 v;
	83
	84	iface = netdev_priv(dev);
	85	local = iface->local;
f7a74447	86	hw_priv = local->hw_priv;
ff1d2767 JM	87
ff1d2767 JM	88	spin_lock_irqsave(&local->lock, flags);
67e0e473	89	v = readb(hw_priv->mem_start + a);
ff1d2767 JM	90	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INB, a, v);
	91	spin_unlock_irqrestore(&local->lock, flags);
	92	return v;
	93	}
	94
	95	static inline void hfa384x_outw_debug(struct net_device *dev, int a, u16 v)
	96	{
	97	struct hostap_interface *iface;
f7a74447	98	struct hostap_pci_priv *hw_priv;
ff1d2767 JM	99	local_info_t *local;
	100	unsigned long flags;
	101
	102	iface = netdev_priv(dev);
	103	local = iface->local;
f7a74447	104	hw_priv = local->hw_priv;
ff1d2767 JM	105
	106	spin_lock_irqsave(&local->lock, flags);
	107	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTW, a, v);
67e0e473	108	writew(v, hw_priv->mem_start + a);
ff1d2767 JM	109	spin_unlock_irqrestore(&local->lock, flags);
	110	}
	111
	112	static inline u16 hfa384x_inw_debug(struct net_device *dev, int a)
	113	{
	114	struct hostap_interface *iface;
f7a74447	115	struct hostap_pci_priv *hw_priv;
ff1d2767 JM	116	local_info_t *local;
	117	unsigned long flags;
	118	u16 v;
	119
	120	iface = netdev_priv(dev);
	121	local = iface->local;
f7a74447	122	hw_priv = local->hw_priv;
ff1d2767 JM	123
ff1d2767 JM	124	spin_lock_irqsave(&local->lock, flags);
67e0e473	125	v = readw(hw_priv->mem_start + a);
ff1d2767 JM	126	prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INW, a, v);
	127	spin_unlock_irqrestore(&local->lock, flags);
	128	return v;
	129	}
	130
	131	#define HFA384X_OUTB(v,a) hfa384x_outb_debug(dev, (a), (v))
	132	#define HFA384X_INB(a) hfa384x_inb_debug(dev, (a))
	133	#define HFA384X_OUTW(v,a) hfa384x_outw_debug(dev, (a), (v))
	134	#define HFA384X_INW(a) hfa384x_inw_debug(dev, (a))
	135	#define HFA384X_OUTW_DATA(v,a) hfa384x_outw_debug(dev, (a), cpu_to_le16((v)))
	136	#define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw_debug(dev, (a)))
	137
	138	#else /* PRISM2_IO_DEBUG */
	139
	140	static inline void hfa384x_outb(struct net_device *dev, int a, u8 v)
	141	{
	142	struct hostap_interface *iface;
67e0e473	143	struct hostap_pci_priv *hw_priv;
ff1d2767	144	iface = netdev_priv(dev);
67e0e473 JM	145	hw_priv = iface->local->hw_priv;
67e0e473 JM	146	writeb(v, hw_priv->mem_start + a);
ff1d2767 JM	147	}
	148
	149	static inline u8 hfa384x_inb(struct net_device *dev, int a)
	150	{
	151	struct hostap_interface *iface;
67e0e473	152	struct hostap_pci_priv *hw_priv;
ff1d2767	153	iface = netdev_priv(dev);
67e0e473 JM	154	hw_priv = iface->local->hw_priv;
67e0e473 JM	155	return readb(hw_priv->mem_start + a);
ff1d2767 JM	156	}
	157
	158	static inline void hfa384x_outw(struct net_device *dev, int a, u16 v)
	159	{
	160	struct hostap_interface *iface;
67e0e473	161	struct hostap_pci_priv *hw_priv;
ff1d2767	162	iface = netdev_priv(dev);
67e0e473 JM	163	hw_priv = iface->local->hw_priv;
67e0e473 JM	164	writew(v, hw_priv->mem_start + a);
ff1d2767 JM	165	}
	166
	167	static inline u16 hfa384x_inw(struct net_device *dev, int a)
	168	{
	169	struct hostap_interface *iface;
67e0e473	170	struct hostap_pci_priv *hw_priv;
ff1d2767	171	iface = netdev_priv(dev);
67e0e473 JM	172	hw_priv = iface->local->hw_priv;
67e0e473 JM	173	return readw(hw_priv->mem_start + a);
ff1d2767 JM	174	}
	175
	176	#define HFA384X_OUTB(v,a) hfa384x_outb(dev, (a), (v))
	177	#define HFA384X_INB(a) hfa384x_inb(dev, (a))
	178	#define HFA384X_OUTW(v,a) hfa384x_outw(dev, (a), (v))
	179	#define HFA384X_INW(a) hfa384x_inw(dev, (a))
	180	#define HFA384X_OUTW_DATA(v,a) hfa384x_outw(dev, (a), cpu_to_le16((v)))
	181	#define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw(dev, (a)))
	182
	183	#endif /* PRISM2_IO_DEBUG */
	184
	185
	186	static int hfa384x_from_bap(struct net_device dev, u16 bap, void buf,
	187	int len)
	188	{
	189	u16 d_off;
	190	u16 *pos;
	191
	192	d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
	193	pos = (u16 *) buf;
	194
	195	for ( ; len > 1; len -= 2)
	196	*pos++ = HFA384X_INW_DATA(d_off);
	197
	198	if (len & 1)
	199	((char ) pos) = HFA384X_INB(d_off);
	200
	201	return 0;
	202	}
	203
	204
	205	static int hfa384x_to_bap(struct net_device dev, u16 bap, void buf, int len)
	206	{
	207	u16 d_off;
	208	u16 *pos;
	209
	210	d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
	211	pos = (u16 *) buf;
	212
	213	for ( ; len > 1; len -= 2)
	214	HFA384X_OUTW_DATA(*pos++, d_off);
	215
	216	if (len & 1)
	217	HFA384X_OUTB(((char ) pos), d_off);
	218
	219	return 0;
	220	}
	221
	222
	223	/* FIX: This might change at some point.. */
	224	#include "hostap_hw.c"
	225
	226	static void prism2_pci_cor_sreset(local_info_t *local)
	227	{
	228	struct net_device *dev = local->dev;
	229	u16 reg;
	230
	231	reg = HFA384X_INB(HFA384X_PCICOR_OFF);
	232	printk(KERN_DEBUG "%s: Original COR value: 0x%0x\n", dev->name, reg);
	233
	234	/* linux-wlan-ng uses extremely long hold and settle times for
	235	* COR sreset. A comment in the driver code mentions that the long
	236	* delays appear to be necessary. However, at least IBM 22P6901 seems
	237	* to work fine with shorter delays.
238	*
239	* Longer delays can be configured by uncommenting following line: */
240	/* #define PRISM2_PCI_USE_LONG_DELAYS */
241
242	#ifdef PRISM2_PCI_USE_LONG_DELAYS
243	int i;
244
245	HFA384X_OUTW(reg \| 0x0080, HFA384X_PCICOR_OFF);
246	mdelay(250);
247
248	HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
249	mdelay(500);
250
251	/* Wait for f/w to complete initialization (CMD:BUSY == 0) */
252	i = 2000000 / 10;
253	while ((HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) && --i)
254	udelay(10);
255
256	#else /* PRISM2_PCI_USE_LONG_DELAYS */
257
258	HFA384X_OUTW(reg \| 0x0080, HFA384X_PCICOR_OFF);
259	mdelay(2);
260	HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
261	mdelay(2);
262
263	#endif /* PRISM2_PCI_USE_LONG_DELAYS */
264
265	if (HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) {
266	printk(KERN_DEBUG "%s: COR sreset timeout\n", dev->name);
267	}
268	}
269
270
271	static void prism2_pci_genesis_reset(local_info_t *local, int hcr)
272	{
273	struct net_device *dev = local->dev;
274
275	HFA384X_OUTW(0x00C5, HFA384X_PCICOR_OFF);
276	mdelay(10);
277	HFA384X_OUTW(hcr, HFA384X_PCIHCR_OFF);
278	mdelay(10);
279	HFA384X_OUTW(0x0045, HFA384X_PCICOR_OFF);
280	mdelay(10);
281	}
282
283
284	static struct prism2_helper_functions prism2_pci_funcs =
285	{
286	.card_present = NULL,
287	.cor_sreset = prism2_pci_cor_sreset,
ff1d2767 JM	288	.genesis_reset = prism2_pci_genesis_reset,
	289	.hw_type = HOSTAP_HW_PCI,
	290	};
	291
	292
	293	static int prism2_pci_probe(struct pci_dev *pdev,
	294	const struct pci_device_id *id)
	295	{
	296	unsigned long phymem;
	297	void __iomem *mem = NULL;
	298	local_info_t *local = NULL;
	299	struct net_device *dev = NULL;
	300	static int cards_found /* = 0 */;
	301	int irq_registered = 0;
	302	struct hostap_interface *iface;
67e0e473 JM	303	struct hostap_pci_priv *hw_priv;
	304
	305	hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
	306	if (hw_priv == NULL)
	307	return -ENOMEM;
	308	memset(hw_priv, 0, sizeof(*hw_priv));
ff1d2767 JM	309
	310	if (pci_enable_device(pdev))
	311	return -EIO;
	312
	313	phymem = pci_resource_start(pdev, 0);
	314
	315	if (!request_mem_region(phymem, pci_resource_len(pdev, 0), "Prism2")) {
	316	printk(KERN_ERR "prism2: Cannot reserve PCI memory region\n");
	317	goto err_out_disable;
	318	}
	319
	320	mem = ioremap(phymem, pci_resource_len(pdev, 0));
	321	if (mem == NULL) {
	322	printk(KERN_ERR "prism2: Cannot remap PCI memory region\n") ;
	323	goto fail;
	324	}
	325
0cd545d6 DH	326	dev = prism2_init_local_data(&prism2_pci_funcs, cards_found,
0cd545d6 DH	327	&pdev->dev);
ff1d2767 JM	328	if (dev == NULL)
	329	goto fail;
	330	iface = netdev_priv(dev);
	331	local = iface->local;
67e0e473	332	local->hw_priv = hw_priv;
ff1d2767 JM	333	cards_found++;
	334
	335	dev->irq = pdev->irq;
67e0e473	336	hw_priv->mem_start = mem;
ff1d2767 JM	337
	338	prism2_pci_cor_sreset(local);
	339
	340	pci_set_drvdata(pdev, dev);
	341
	342	if (request_irq(dev->irq, prism2_interrupt, SA_SHIRQ, dev->name,
	343	dev)) {
	344	printk(KERN_WARNING "%s: request_irq failed\n", dev->name);
	345	goto fail;
	346	} else
	347	irq_registered = 1;
	348
	349	if (!local->pri_only && prism2_hw_config(dev, 1)) {
	350	printk(KERN_DEBUG "%s: hardware initialization failed\n",
	351	dev_info);
	352	goto fail;
	353	}
	354
	355	printk(KERN_INFO "%s: Intersil Prism2.5 PCI: "
	356	"mem=0x%lx, irq=%d\n", dev->name, phymem, dev->irq);
	357
	358	return hostap_hw_ready(dev);
	359
	360	fail:
	361	if (irq_registered && dev)
	362	free_irq(dev->irq, dev);
	363
	364	if (mem)
	365	iounmap(mem);
	366
	367	release_mem_region(phymem, pci_resource_len(pdev, 0));
	368
	369	err_out_disable:
	370	pci_disable_device(pdev);
	371	prism2_free_local_data(dev);
c355184c	372	kfree(hw_priv);
ff1d2767 JM	373
	374	return -ENODEV;
	375	}
	376
	377
	378	static void prism2_pci_remove(struct pci_dev *pdev)
	379	{
	380	struct net_device *dev;
	381	struct hostap_interface *iface;
	382	void __iomem *mem_start;
67e0e473	383	struct hostap_pci_priv *hw_priv;
ff1d2767 JM	384
	385	dev = pci_get_drvdata(pdev);
	386	iface = netdev_priv(dev);
67e0e473	387	hw_priv = iface->local->hw_priv;
ff1d2767 JM	388
	389	/* Reset the hardware, and ensure interrupts are disabled. */
	390	prism2_pci_cor_sreset(iface->local);
	391	hfa384x_disable_interrupts(dev);
	392
	393	if (dev->irq)
	394	free_irq(dev->irq, dev);
	395
67e0e473	396	mem_start = hw_priv->mem_start;
ff1d2767	397	prism2_free_local_data(dev);
c355184c	398	kfree(hw_priv);
ff1d2767 JM	399
	400	iounmap(mem_start);
	401
	402	release_mem_region(pci_resource_start(pdev, 0),
	403	pci_resource_len(pdev, 0));
	404	pci_disable_device(pdev);
	405	}
	406
	407
	408	#ifdef CONFIG_PM
b2dabd5a	409	static int prism2_pci_suspend(struct pci_dev *pdev, pm_message_t state)
ff1d2767 JM	410	{
	411	struct net_device *dev = pci_get_drvdata(pdev);
	412
	413	if (netif_running(dev)) {
	414	netif_stop_queue(dev);
	415	netif_device_detach(dev);
	416	}
	417	prism2_suspend(dev);
	418	pci_save_state(pdev);
	419	pci_disable_device(pdev);
583a4e88	420	pci_set_power_state(pdev, PCI_D3hot);
ff1d2767 JM	421
	422	return 0;
	423	}
	424
	425	static int prism2_pci_resume(struct pci_dev *pdev)
	426	{
	427	struct net_device *dev = pci_get_drvdata(pdev);
	428
	429	pci_enable_device(pdev);
	430	pci_restore_state(pdev);
	431	prism2_hw_config(dev, 0);
	432	if (netif_running(dev)) {
	433	netif_device_attach(dev);
	434	netif_start_queue(dev);
	435	}
	436
	437	return 0;
	438	}
	439	#endif /* CONFIG_PM */
	440
	441
	442	MODULE_DEVICE_TABLE(pci, prism2_pci_id_table);
	443
	444	static struct pci_driver prism2_pci_drv_id = {
7a716536	445	.name = "hostap_pci",
ff1d2767 JM	446	.id_table = prism2_pci_id_table,
	447	.probe = prism2_pci_probe,
	448	.remove = prism2_pci_remove,
	449	#ifdef CONFIG_PM
	450	.suspend = prism2_pci_suspend,
	451	.resume = prism2_pci_resume,
	452	#endif /* CONFIG_PM */
	453	/* Linux 2.4.6 added save_state and enable_wake that are not used here
	454	*/
	455	};
	456
	457
	458	static int __init init_prism2_pci(void)
	459	{
	460	printk(KERN_INFO "%s: %s\n", dev_info, version);
	461
	462	return pci_register_driver(&prism2_pci_drv_id);
	463	}
	464
	465
	466	static void __exit exit_prism2_pci(void)
	467	{
	468	pci_unregister_driver(&prism2_pci_drv_id);
	469	printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
	470	}
	471
	472
	473	module_init(init_prism2_pci);
	474	module_exit(exit_prism2_pci);