1 files changed, 473 insertions, 0 deletions

diff --git a/drivers/net/wireless/hostap/hostap_pci.c b/drivers/net/wireless/hostap/hostap_pci.c
new file mode 100644
index 000000000000..025f8cdb5566
--- /dev/null
+++ b/drivers/net/wireless/hostap/hostap_pci.c
@@ -0,0 +1,473 @@
+#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;
+        local_info_t *local;
+        unsigned long flags;
+
+        iface = netdev_priv(dev);
+        local = iface->local;
+
+        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;
+        local_info_t *local;
+        unsigned long flags;
+        u8 v;
+
+        iface = netdev_priv(dev);
+        local = iface->local;
+
+        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;
+        local_info_t *local;
+        unsigned long flags;
+
+        iface = netdev_priv(dev);
+        local = iface->local;
+
+        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;
+        local_info_t *local;
+        unsigned long flags;
+        u16 v;
+
+        iface = netdev_priv(dev);
+        local = iface->local;
+
+        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,
+        .dev_open       = NULL,
+        .dev_close      = NULL,
+        .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:
+        kfree(hw_priv);
+
+        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);
+        kfree(hw_priv);
+        if (local)
+                local->hw_priv = NULL;
+        prism2_free_local_data(dev);
+
+        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;
+        kfree(hw_priv);
+        iface->local->hw_priv = NULL;
+        prism2_free_local_data(dev);
+
+        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           = "prism2_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);