mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
445 lines
10 KiB
445 lines
10 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
#define PRISM2_PCI |
|
|
|
/* Host AP driver's support for Intersil Prism2.5 PCI cards is based on |
|
* driver patches from Reyk Floeter <[email protected]> and |
|
* Andy Warner <[email protected]> */ |
|
|
|
#include <linux/module.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_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 const struct pci_device_id 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); |
|
} |
|
|
|
static int __maybe_unused prism2_pci_suspend(struct device *dev_d) |
|
{ |
|
struct net_device *dev = dev_get_drvdata(dev_d); |
|
|
|
if (netif_running(dev)) { |
|
netif_stop_queue(dev); |
|
netif_device_detach(dev); |
|
} |
|
prism2_suspend(dev); |
|
|
|
return 0; |
|
} |
|
|
|
static int __maybe_unused prism2_pci_resume(struct device *dev_d) |
|
{ |
|
struct net_device *dev = dev_get_drvdata(dev_d); |
|
|
|
prism2_hw_config(dev, 0); |
|
if (netif_running(dev)) { |
|
netif_device_attach(dev); |
|
netif_start_queue(dev); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
MODULE_DEVICE_TABLE(pci, prism2_pci_id_table); |
|
|
|
static SIMPLE_DEV_PM_OPS(prism2_pci_pm_ops, |
|
prism2_pci_suspend, |
|
prism2_pci_resume); |
|
|
|
static struct pci_driver prism2_pci_driver = { |
|
.name = "hostap_pci", |
|
.id_table = prism2_pci_id_table, |
|
.probe = prism2_pci_probe, |
|
.remove = prism2_pci_remove, |
|
.driver.pm = &prism2_pci_pm_ops, |
|
}; |
|
|
|
module_pci_driver(prism2_pci_driver);
|
|
|