[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/module.h>
#include <linux/init.h>
#include <linux/if.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/slab.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 *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");


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


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


static DEFINE_PCI_DEVICE_TABLE(prism2_pci_id_table) = {
	/* 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), le16_to_cpu((v)))
#define HFA384X_INW_DATA(a) cpu_to_le16(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), le16_to_cpu((v)))
#define HFA384X_INW_DATA(a) cpu_to_le16(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;
	__le16 *pos;

	d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
	pos = (__le16 *) 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;
	__le16 *pos;

	d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
	pos = (__le16 *) 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 = kzalloc(sizeof(*hw_priv), GFP_KERNEL);
	if (hw_priv == NULL)
		return -ENOMEM;

	if (pci_enable_device(pdev))
		goto err_out_free;

	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 = pci_ioremap_bar(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;
	dev->base_addr = (unsigned long) mem;

	prism2_pci_cor_sreset(local);

	pci_set_drvdata(pdev, dev);

	if (request_irq(dev->irq, prism2_interrupt, IRQF_SHARED, 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);

 err_out_free:
	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);
	int err;

	err = pci_enable_device(pdev);
	if (err) {
		printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
		       dev->name);
		return err;
	}
	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_driver = {
	.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 */
};


static int __init init_prism2_pci(void)
{
	return pci_register_driver(&prism2_pci_driver);
}


static void __exit exit_prism2_pci(void)
{
	pci_unregister_driver(&prism2_pci_driver);
}


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