2007-09-19 17:20:30 -04:00
|
|
|
/* b44.c: Broadcom 44xx/47xx Fast Ethernet device driver.
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
|
|
|
* Copyright (C) 2002 David S. Miller (davem@redhat.com)
|
2007-09-19 17:20:30 -04:00
|
|
|
* Copyright (C) 2004 Pekka Pietikainen (pp@ee.oulu.fi)
|
|
|
|
* Copyright (C) 2004 Florian Schirmer (jolt@tuxbox.org)
|
|
|
|
* Copyright (C) 2006 Felix Fietkau (nbd@openwrt.org)
|
2006-04-10 15:05:40 -04:00
|
|
|
* Copyright (C) 2006 Broadcom Corporation.
|
2007-09-19 17:20:30 -04:00
|
|
|
* Copyright (C) 2007 Michael Buesch <mb@bu3sch.de>
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
|
|
|
* Distribute under GPL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/mii.h>
|
|
|
|
#include <linux/if_ether.h>
|
2007-06-04 16:25:39 -04:00
|
|
|
#include <linux/if_vlan.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/init.h>
|
2005-10-28 16:38:02 -04:00
|
|
|
#include <linux/dma-mapping.h>
|
2007-09-19 17:20:30 -04:00
|
|
|
#include <linux/ssb/ssb.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#include "b44.h"
|
|
|
|
|
|
|
|
#define DRV_MODULE_NAME "b44"
|
|
|
|
#define PFX DRV_MODULE_NAME ": "
|
2007-09-19 17:20:30 -04:00
|
|
|
#define DRV_MODULE_VERSION "2.0"
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#define B44_DEF_MSG_ENABLE \
|
|
|
|
(NETIF_MSG_DRV | \
|
|
|
|
NETIF_MSG_PROBE | \
|
|
|
|
NETIF_MSG_LINK | \
|
|
|
|
NETIF_MSG_TIMER | \
|
|
|
|
NETIF_MSG_IFDOWN | \
|
|
|
|
NETIF_MSG_IFUP | \
|
|
|
|
NETIF_MSG_RX_ERR | \
|
|
|
|
NETIF_MSG_TX_ERR)
|
|
|
|
|
|
|
|
/* length of time before we decide the hardware is borked,
|
|
|
|
* and dev->tx_timeout() should be called to fix the problem
|
|
|
|
*/
|
|
|
|
#define B44_TX_TIMEOUT (5 * HZ)
|
|
|
|
|
|
|
|
/* hardware minimum and maximum for a single frame's data payload */
|
|
|
|
#define B44_MIN_MTU 60
|
|
|
|
#define B44_MAX_MTU 1500
|
|
|
|
|
|
|
|
#define B44_RX_RING_SIZE 512
|
|
|
|
#define B44_DEF_RX_RING_PENDING 200
|
|
|
|
#define B44_RX_RING_BYTES (sizeof(struct dma_desc) * \
|
|
|
|
B44_RX_RING_SIZE)
|
|
|
|
#define B44_TX_RING_SIZE 512
|
|
|
|
#define B44_DEF_TX_RING_PENDING (B44_TX_RING_SIZE - 1)
|
|
|
|
#define B44_TX_RING_BYTES (sizeof(struct dma_desc) * \
|
|
|
|
B44_TX_RING_SIZE)
|
|
|
|
|
|
|
|
#define TX_RING_GAP(BP) \
|
|
|
|
(B44_TX_RING_SIZE - (BP)->tx_pending)
|
|
|
|
#define TX_BUFFS_AVAIL(BP) \
|
|
|
|
(((BP)->tx_cons <= (BP)->tx_prod) ? \
|
|
|
|
(BP)->tx_cons + (BP)->tx_pending - (BP)->tx_prod : \
|
|
|
|
(BP)->tx_cons - (BP)->tx_prod - TX_RING_GAP(BP))
|
|
|
|
#define NEXT_TX(N) (((N) + 1) & (B44_TX_RING_SIZE - 1))
|
|
|
|
|
2007-06-04 16:25:39 -04:00
|
|
|
#define RX_PKT_OFFSET 30
|
|
|
|
#define RX_PKT_BUF_SZ (1536 + RX_PKT_OFFSET + 64)
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* minimum number of free TX descriptors required to wake up TX process */
|
|
|
|
#define B44_TX_WAKEUP_THRESH (B44_TX_RING_SIZE / 4)
|
|
|
|
|
2006-06-20 18:34:36 -04:00
|
|
|
/* b44 internal pattern match filter info */
|
|
|
|
#define B44_PATTERN_BASE 0x400
|
|
|
|
#define B44_PATTERN_SIZE 0x80
|
|
|
|
#define B44_PMASK_BASE 0x600
|
|
|
|
#define B44_PMASK_SIZE 0x10
|
|
|
|
#define B44_MAX_PATTERNS 16
|
|
|
|
#define B44_ETHIPV6UDP_HLEN 62
|
|
|
|
#define B44_ETHIPV4UDP_HLEN 42
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static char version[] __devinitdata =
|
2007-09-19 17:20:30 -04:00
|
|
|
DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION "\n";
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
MODULE_AUTHOR("Felix Fietkau, Florian Schirmer, Pekka Pietikainen, David S. Miller");
|
|
|
|
MODULE_DESCRIPTION("Broadcom 44xx/47xx 10/100 PCI ethernet driver");
|
2005-04-16 18:20:36 -04:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_VERSION(DRV_MODULE_VERSION);
|
|
|
|
|
|
|
|
static int b44_debug = -1; /* -1 == use B44_DEF_MSG_ENABLE as value */
|
|
|
|
module_param(b44_debug, int, 0);
|
|
|
|
MODULE_PARM_DESC(b44_debug, "B44 bitmapped debugging message enable value");
|
|
|
|
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
#ifdef CONFIG_B44_PCI
|
|
|
|
static const struct pci_device_id b44_pci_tbl[] = {
|
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401) },
|
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401B0) },
|
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401B1) },
|
|
|
|
{ 0 } /* terminate list with empty entry */
|
|
|
|
};
|
2005-04-16 18:20:36 -04:00
|
|
|
MODULE_DEVICE_TABLE(pci, b44_pci_tbl);
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static struct pci_driver b44_pci_driver = {
|
|
|
|
.name = DRV_MODULE_NAME,
|
|
|
|
.id_table = b44_pci_tbl,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_B44_PCI */
|
|
|
|
|
|
|
|
static const struct ssb_device_id b44_ssb_tbl[] = {
|
|
|
|
SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_ETHERNET, SSB_ANY_REV),
|
|
|
|
SSB_DEVTABLE_END
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(ssb, b44_ssb_tbl);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static void b44_halt(struct b44 *);
|
|
|
|
static void b44_init_rings(struct b44 *);
|
2007-01-27 02:59:57 -05:00
|
|
|
|
|
|
|
#define B44_FULL_RESET 1
|
|
|
|
#define B44_FULL_RESET_SKIP_PHY 2
|
|
|
|
#define B44_PARTIAL_RESET 3
|
2007-12-31 19:17:54 -05:00
|
|
|
#define B44_CHIP_RESET_FULL 4
|
|
|
|
#define B44_CHIP_RESET_PARTIAL 5
|
2007-01-27 02:59:57 -05:00
|
|
|
|
2006-06-20 18:34:26 -04:00
|
|
|
static void b44_init_hw(struct b44 *, int);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-10-18 21:30:59 -04:00
|
|
|
static int dma_desc_align_mask;
|
|
|
|
static int dma_desc_sync_size;
|
2007-09-19 17:20:30 -04:00
|
|
|
static int instance;
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2005-11-06 19:51:34 -05:00
|
|
|
static const char b44_gstrings[][ETH_GSTRING_LEN] = {
|
|
|
|
#define _B44(x...) # x,
|
|
|
|
B44_STAT_REG_DECLARE
|
|
|
|
#undef _B44
|
|
|
|
};
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static inline void b44_sync_dma_desc_for_device(struct ssb_device *sdev,
|
|
|
|
dma_addr_t dma_base,
|
|
|
|
unsigned long offset,
|
|
|
|
enum dma_data_direction dir)
|
2005-10-18 21:30:59 -04:00
|
|
|
{
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_sync_single_range_for_device(sdev, dma_base,
|
|
|
|
offset & dma_desc_align_mask,
|
|
|
|
dma_desc_sync_size, dir);
|
2005-10-18 21:30:59 -04:00
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static inline void b44_sync_dma_desc_for_cpu(struct ssb_device *sdev,
|
|
|
|
dma_addr_t dma_base,
|
|
|
|
unsigned long offset,
|
|
|
|
enum dma_data_direction dir)
|
2005-10-18 21:30:59 -04:00
|
|
|
{
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_sync_single_range_for_cpu(sdev, dma_base,
|
|
|
|
offset & dma_desc_align_mask,
|
|
|
|
dma_desc_sync_size, dir);
|
2005-10-18 21:30:59 -04:00
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static inline unsigned long br32(const struct b44 *bp, unsigned long reg)
|
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
return ssb_read32(bp->sdev, reg);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2006-04-12 18:04:32 -04:00
|
|
|
static inline void bw32(const struct b44 *bp,
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned long reg, unsigned long val)
|
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
ssb_write32(bp->sdev, reg, val);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_wait_bit(struct b44 *bp, unsigned long reg,
|
|
|
|
u32 bit, unsigned long timeout, const int clear)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
|
|
|
|
for (i = 0; i < timeout; i++) {
|
|
|
|
u32 val = br32(bp, reg);
|
|
|
|
|
|
|
|
if (clear && !(val & bit))
|
|
|
|
break;
|
|
|
|
if (!clear && (val & bit))
|
|
|
|
break;
|
|
|
|
udelay(10);
|
|
|
|
}
|
|
|
|
if (i == timeout) {
|
|
|
|
printk(KERN_ERR PFX "%s: BUG! Timeout waiting for bit %08x of register "
|
|
|
|
"%lx to %s.\n",
|
|
|
|
bp->dev->name,
|
|
|
|
bit, reg,
|
|
|
|
(clear ? "clear" : "set"));
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static inline void __b44_cam_read(struct b44 *bp, unsigned char *data, int index)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
bw32(bp, B44_CAM_CTRL, (CAM_CTRL_READ |
|
|
|
|
(index << CAM_CTRL_INDEX_SHIFT)));
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
val = br32(bp, B44_CAM_DATA_LO);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
data[2] = (val >> 24) & 0xFF;
|
|
|
|
data[3] = (val >> 16) & 0xFF;
|
|
|
|
data[4] = (val >> 8) & 0xFF;
|
|
|
|
data[5] = (val >> 0) & 0xFF;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
val = br32(bp, B44_CAM_DATA_HI);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
data[0] = (val >> 8) & 0xFF;
|
|
|
|
data[1] = (val >> 0) & 0xFF;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static inline void __b44_cam_write(struct b44 *bp, unsigned char *data, int index)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
val = ((u32) data[2]) << 24;
|
|
|
|
val |= ((u32) data[3]) << 16;
|
|
|
|
val |= ((u32) data[4]) << 8;
|
|
|
|
val |= ((u32) data[5]) << 0;
|
|
|
|
bw32(bp, B44_CAM_DATA_LO, val);
|
2006-04-12 18:04:32 -04:00
|
|
|
val = (CAM_DATA_HI_VALID |
|
2005-04-16 18:20:36 -04:00
|
|
|
(((u32) data[0]) << 8) |
|
|
|
|
(((u32) data[1]) << 0));
|
|
|
|
bw32(bp, B44_CAM_DATA_HI, val);
|
|
|
|
bw32(bp, B44_CAM_CTRL, (CAM_CTRL_WRITE |
|
|
|
|
(index << CAM_CTRL_INDEX_SHIFT)));
|
2006-04-12 18:04:32 -04:00
|
|
|
b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void __b44_disable_ints(struct b44 *bp)
|
|
|
|
{
|
|
|
|
bw32(bp, B44_IMASK, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_disable_ints(struct b44 *bp)
|
|
|
|
{
|
|
|
|
__b44_disable_ints(bp);
|
|
|
|
|
|
|
|
/* Flush posted writes. */
|
|
|
|
br32(bp, B44_IMASK);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_enable_ints(struct b44 *bp)
|
|
|
|
{
|
|
|
|
bw32(bp, B44_IMASK, bp->imask);
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static int __b44_readphy(struct b44 *bp, int phy_addr, int reg, u32 *val)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII);
|
|
|
|
bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START |
|
|
|
|
(MDIO_OP_READ << MDIO_DATA_OP_SHIFT) |
|
2007-09-19 17:20:30 -04:00
|
|
|
(phy_addr << MDIO_DATA_PMD_SHIFT) |
|
2005-04-16 18:20:36 -04:00
|
|
|
(reg << MDIO_DATA_RA_SHIFT) |
|
|
|
|
(MDIO_TA_VALID << MDIO_DATA_TA_SHIFT)));
|
|
|
|
err = b44_wait_bit(bp, B44_EMAC_ISTAT, EMAC_INT_MII, 100, 0);
|
|
|
|
*val = br32(bp, B44_MDIO_DATA) & MDIO_DATA_DATA;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static int __b44_writephy(struct b44 *bp, int phy_addr, int reg, u32 val)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII);
|
|
|
|
bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START |
|
|
|
|
(MDIO_OP_WRITE << MDIO_DATA_OP_SHIFT) |
|
2007-09-19 17:20:30 -04:00
|
|
|
(phy_addr << MDIO_DATA_PMD_SHIFT) |
|
2005-04-16 18:20:36 -04:00
|
|
|
(reg << MDIO_DATA_RA_SHIFT) |
|
|
|
|
(MDIO_TA_VALID << MDIO_DATA_TA_SHIFT) |
|
|
|
|
(val & MDIO_DATA_DATA)));
|
|
|
|
return b44_wait_bit(bp, B44_EMAC_ISTAT, EMAC_INT_MII, 100, 0);
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static inline int b44_readphy(struct b44 *bp, int reg, u32 *val)
|
|
|
|
{
|
|
|
|
if (bp->phy_addr == B44_PHY_ADDR_NO_PHY)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return __b44_readphy(bp, bp->phy_addr, reg, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int b44_writephy(struct b44 *bp, int reg, u32 val)
|
|
|
|
{
|
|
|
|
if (bp->phy_addr == B44_PHY_ADDR_NO_PHY)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return __b44_writephy(bp, bp->phy_addr, reg, val);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* miilib interface */
|
|
|
|
static int b44_mii_read(struct net_device *dev, int phy_id, int location)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2007-09-19 17:20:30 -04:00
|
|
|
int rc = __b44_readphy(bp, phy_id, location, &val);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (rc)
|
|
|
|
return 0xffffffff;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_mii_write(struct net_device *dev, int phy_id, int location,
|
|
|
|
int val)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2007-09-19 17:20:30 -04:00
|
|
|
__b44_writephy(bp, phy_id, location, val);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_phy_reset(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
int err;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
if (bp->phy_addr == B44_PHY_ADDR_NO_PHY)
|
|
|
|
return 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
err = b44_writephy(bp, MII_BMCR, BMCR_RESET);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
udelay(100);
|
|
|
|
err = b44_readphy(bp, MII_BMCR, &val);
|
|
|
|
if (!err) {
|
|
|
|
if (val & BMCR_RESET) {
|
|
|
|
printk(KERN_ERR PFX "%s: PHY Reset would not complete.\n",
|
|
|
|
bp->dev->name);
|
|
|
|
err = -ENODEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __b44_set_flow_ctrl(struct b44 *bp, u32 pause_flags)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
bp->flags &= ~(B44_FLAG_TX_PAUSE | B44_FLAG_RX_PAUSE);
|
|
|
|
bp->flags |= pause_flags;
|
|
|
|
|
|
|
|
val = br32(bp, B44_RXCONFIG);
|
|
|
|
if (pause_flags & B44_FLAG_RX_PAUSE)
|
|
|
|
val |= RXCONFIG_FLOW;
|
|
|
|
else
|
|
|
|
val &= ~RXCONFIG_FLOW;
|
|
|
|
bw32(bp, B44_RXCONFIG, val);
|
|
|
|
|
|
|
|
val = br32(bp, B44_MAC_FLOW);
|
|
|
|
if (pause_flags & B44_FLAG_TX_PAUSE)
|
|
|
|
val |= (MAC_FLOW_PAUSE_ENAB |
|
|
|
|
(0xc0 & MAC_FLOW_RX_HI_WATER));
|
|
|
|
else
|
|
|
|
val &= ~MAC_FLOW_PAUSE_ENAB;
|
|
|
|
bw32(bp, B44_MAC_FLOW, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_set_flow_ctrl(struct b44 *bp, u32 local, u32 remote)
|
|
|
|
{
|
2006-04-12 18:04:32 -04:00
|
|
|
u32 pause_enab = 0;
|
2006-04-10 15:02:21 -04:00
|
|
|
|
|
|
|
/* The driver supports only rx pause by default because
|
2006-04-12 18:04:32 -04:00
|
|
|
the b44 mac tx pause mechanism generates excessive
|
|
|
|
pause frames.
|
2006-04-10 15:02:21 -04:00
|
|
|
Use ethtool to turn on b44 tx pause if necessary.
|
|
|
|
*/
|
|
|
|
if ((local & ADVERTISE_PAUSE_CAP) &&
|
2006-04-12 18:04:32 -04:00
|
|
|
(local & ADVERTISE_PAUSE_ASYM)){
|
2006-04-10 15:02:21 -04:00
|
|
|
if ((remote & LPA_PAUSE_ASYM) &&
|
|
|
|
!(remote & LPA_PAUSE_CAP))
|
|
|
|
pause_enab |= B44_FLAG_RX_PAUSE;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
__b44_set_flow_ctrl(bp, pause_enab);
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
#ifdef SSB_DRIVER_MIPS
|
|
|
|
extern char *nvram_get(char *name);
|
|
|
|
static void b44_wap54g10_workaround(struct b44 *bp)
|
|
|
|
{
|
|
|
|
const char *str;
|
|
|
|
u32 val;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* workaround for bad hardware design in Linksys WAP54G v1.0
|
|
|
|
* see https://dev.openwrt.org/ticket/146
|
|
|
|
* check and reset bit "isolate"
|
|
|
|
*/
|
|
|
|
str = nvram_get("boardnum");
|
|
|
|
if (!str)
|
|
|
|
return;
|
|
|
|
if (simple_strtoul(str, NULL, 0) == 2) {
|
|
|
|
err = __b44_readphy(bp, 0, MII_BMCR, &val);
|
|
|
|
if (err)
|
|
|
|
goto error;
|
|
|
|
if (!(val & BMCR_ISOLATE))
|
|
|
|
return;
|
|
|
|
val &= ~BMCR_ISOLATE;
|
|
|
|
err = __b44_writephy(bp, 0, MII_BMCR, val);
|
|
|
|
if (err)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
error:
|
|
|
|
printk(KERN_WARNING PFX "PHY: cannot reset MII transceiver isolate bit.\n");
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void b44_wap54g10_workaround(struct b44 *bp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static int b44_setup_phy(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
int err;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
b44_wap54g10_workaround(bp);
|
|
|
|
|
|
|
|
if (bp->phy_addr == B44_PHY_ADDR_NO_PHY)
|
|
|
|
return 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
if ((err = b44_readphy(bp, B44_MII_ALEDCTRL, &val)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((err = b44_writephy(bp, B44_MII_ALEDCTRL,
|
|
|
|
val & MII_ALEDCTRL_ALLMSK)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((err = b44_readphy(bp, B44_MII_TLEDCTRL, &val)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((err = b44_writephy(bp, B44_MII_TLEDCTRL,
|
|
|
|
val | MII_TLEDCTRL_ENABLE)) != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!(bp->flags & B44_FLAG_FORCE_LINK)) {
|
|
|
|
u32 adv = ADVERTISE_CSMA;
|
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_ADV_10HALF)
|
|
|
|
adv |= ADVERTISE_10HALF;
|
|
|
|
if (bp->flags & B44_FLAG_ADV_10FULL)
|
|
|
|
adv |= ADVERTISE_10FULL;
|
|
|
|
if (bp->flags & B44_FLAG_ADV_100HALF)
|
|
|
|
adv |= ADVERTISE_100HALF;
|
|
|
|
if (bp->flags & B44_FLAG_ADV_100FULL)
|
|
|
|
adv |= ADVERTISE_100FULL;
|
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_PAUSE_AUTO)
|
|
|
|
adv |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
|
|
|
|
|
|
|
|
if ((err = b44_writephy(bp, MII_ADVERTISE, adv)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((err = b44_writephy(bp, MII_BMCR, (BMCR_ANENABLE |
|
|
|
|
BMCR_ANRESTART))) != 0)
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
u32 bmcr;
|
|
|
|
|
|
|
|
if ((err = b44_readphy(bp, MII_BMCR, &bmcr)) != 0)
|
|
|
|
goto out;
|
|
|
|
bmcr &= ~(BMCR_FULLDPLX | BMCR_ANENABLE | BMCR_SPEED100);
|
|
|
|
if (bp->flags & B44_FLAG_100_BASE_T)
|
|
|
|
bmcr |= BMCR_SPEED100;
|
|
|
|
if (bp->flags & B44_FLAG_FULL_DUPLEX)
|
|
|
|
bmcr |= BMCR_FULLDPLX;
|
|
|
|
if ((err = b44_writephy(bp, MII_BMCR, bmcr)) != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Since we will not be negotiating there is no safe way
|
|
|
|
* to determine if the link partner supports flow control
|
|
|
|
* or not. So just disable it completely in this case.
|
|
|
|
*/
|
|
|
|
b44_set_flow_ctrl(bp, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_stats_update(struct b44 *bp)
|
|
|
|
{
|
|
|
|
unsigned long reg;
|
|
|
|
u32 *val;
|
|
|
|
|
|
|
|
val = &bp->hw_stats.tx_good_octets;
|
|
|
|
for (reg = B44_TX_GOOD_O; reg <= B44_TX_PAUSE; reg += 4UL) {
|
|
|
|
*val++ += br32(bp, reg);
|
|
|
|
}
|
2005-11-06 19:51:34 -05:00
|
|
|
|
|
|
|
/* Pad */
|
|
|
|
reg += 8*4UL;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
for (reg = B44_RX_GOOD_O; reg <= B44_RX_NPAUSE; reg += 4UL) {
|
|
|
|
*val++ += br32(bp, reg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_link_report(struct b44 *bp)
|
|
|
|
{
|
|
|
|
if (!netif_carrier_ok(bp->dev)) {
|
|
|
|
printk(KERN_INFO PFX "%s: Link is down.\n", bp->dev->name);
|
|
|
|
} else {
|
|
|
|
printk(KERN_INFO PFX "%s: Link is up at %d Mbps, %s duplex.\n",
|
|
|
|
bp->dev->name,
|
|
|
|
(bp->flags & B44_FLAG_100_BASE_T) ? 100 : 10,
|
|
|
|
(bp->flags & B44_FLAG_FULL_DUPLEX) ? "full" : "half");
|
|
|
|
|
|
|
|
printk(KERN_INFO PFX "%s: Flow control is %s for TX and "
|
|
|
|
"%s for RX.\n",
|
|
|
|
bp->dev->name,
|
|
|
|
(bp->flags & B44_FLAG_TX_PAUSE) ? "on" : "off",
|
|
|
|
(bp->flags & B44_FLAG_RX_PAUSE) ? "on" : "off");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_check_phy(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 bmsr, aux;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
if (bp->phy_addr == B44_PHY_ADDR_NO_PHY) {
|
|
|
|
bp->flags |= B44_FLAG_100_BASE_T;
|
|
|
|
bp->flags |= B44_FLAG_FULL_DUPLEX;
|
|
|
|
if (!netif_carrier_ok(bp->dev)) {
|
|
|
|
u32 val = br32(bp, B44_TX_CTRL);
|
|
|
|
val |= TX_CTRL_DUPLEX;
|
|
|
|
bw32(bp, B44_TX_CTRL, val);
|
|
|
|
netif_carrier_on(bp->dev);
|
|
|
|
b44_link_report(bp);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!b44_readphy(bp, MII_BMSR, &bmsr) &&
|
|
|
|
!b44_readphy(bp, B44_MII_AUXCTRL, &aux) &&
|
|
|
|
(bmsr != 0xffff)) {
|
|
|
|
if (aux & MII_AUXCTRL_SPEED)
|
|
|
|
bp->flags |= B44_FLAG_100_BASE_T;
|
|
|
|
else
|
|
|
|
bp->flags &= ~B44_FLAG_100_BASE_T;
|
|
|
|
if (aux & MII_AUXCTRL_DUPLEX)
|
|
|
|
bp->flags |= B44_FLAG_FULL_DUPLEX;
|
|
|
|
else
|
|
|
|
bp->flags &= ~B44_FLAG_FULL_DUPLEX;
|
|
|
|
|
|
|
|
if (!netif_carrier_ok(bp->dev) &&
|
|
|
|
(bmsr & BMSR_LSTATUS)) {
|
|
|
|
u32 val = br32(bp, B44_TX_CTRL);
|
|
|
|
u32 local_adv, remote_adv;
|
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_FULL_DUPLEX)
|
|
|
|
val |= TX_CTRL_DUPLEX;
|
|
|
|
else
|
|
|
|
val &= ~TX_CTRL_DUPLEX;
|
|
|
|
bw32(bp, B44_TX_CTRL, val);
|
|
|
|
|
|
|
|
if (!(bp->flags & B44_FLAG_FORCE_LINK) &&
|
|
|
|
!b44_readphy(bp, MII_ADVERTISE, &local_adv) &&
|
|
|
|
!b44_readphy(bp, MII_LPA, &remote_adv))
|
|
|
|
b44_set_flow_ctrl(bp, local_adv, remote_adv);
|
|
|
|
|
|
|
|
/* Link now up */
|
|
|
|
netif_carrier_on(bp->dev);
|
|
|
|
b44_link_report(bp);
|
|
|
|
} else if (netif_carrier_ok(bp->dev) && !(bmsr & BMSR_LSTATUS)) {
|
|
|
|
/* Link now down */
|
|
|
|
netif_carrier_off(bp->dev);
|
|
|
|
b44_link_report(bp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bmsr & BMSR_RFAULT)
|
|
|
|
printk(KERN_WARNING PFX "%s: Remote fault detected in PHY\n",
|
|
|
|
bp->dev->name);
|
|
|
|
if (bmsr & BMSR_JCD)
|
|
|
|
printk(KERN_WARNING PFX "%s: Jabber detected in PHY\n",
|
|
|
|
bp->dev->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_timer(unsigned long __opaque)
|
|
|
|
{
|
|
|
|
struct b44 *bp = (struct b44 *) __opaque;
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_check_phy(bp);
|
|
|
|
|
|
|
|
b44_stats_update(bp);
|
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
2007-06-04 16:25:37 -04:00
|
|
|
mod_timer(&bp->timer, round_jiffies(jiffies + HZ));
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_tx(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 cur, cons;
|
|
|
|
|
|
|
|
cur = br32(bp, B44_DMATX_STAT) & DMATX_STAT_CDMASK;
|
|
|
|
cur /= sizeof(struct dma_desc);
|
|
|
|
|
|
|
|
/* XXX needs updating when NETIF_F_SG is supported */
|
|
|
|
for (cons = bp->tx_cons; cons != cur; cons = NEXT_TX(cons)) {
|
|
|
|
struct ring_info *rp = &bp->tx_buffers[cons];
|
|
|
|
struct sk_buff *skb = rp->skb;
|
|
|
|
|
2006-04-02 07:52:48 -04:00
|
|
|
BUG_ON(skb == NULL);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_unmap_single(bp->sdev,
|
|
|
|
rp->mapping,
|
|
|
|
skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
rp->skb = NULL;
|
|
|
|
dev_kfree_skb_irq(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
bp->tx_cons = cons;
|
|
|
|
if (netif_queue_stopped(bp->dev) &&
|
|
|
|
TX_BUFFS_AVAIL(bp) > B44_TX_WAKEUP_THRESH)
|
|
|
|
netif_wake_queue(bp->dev);
|
|
|
|
|
|
|
|
bw32(bp, B44_GPTIMER, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Works like this. This chip writes a 'struct rx_header" 30 bytes
|
|
|
|
* before the DMA address you give it. So we allocate 30 more bytes
|
|
|
|
* for the RX buffer, DMA map all of it, skb_reserve the 30 bytes, then
|
|
|
|
* point the chip at 30 bytes past where the rx_header will go.
|
|
|
|
*/
|
|
|
|
static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
|
|
|
|
{
|
|
|
|
struct dma_desc *dp;
|
|
|
|
struct ring_info *src_map, *map;
|
|
|
|
struct rx_header *rh;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
dma_addr_t mapping;
|
|
|
|
int dest_idx;
|
|
|
|
u32 ctrl;
|
|
|
|
|
|
|
|
src_map = NULL;
|
|
|
|
if (src_idx >= 0)
|
|
|
|
src_map = &bp->rx_buffers[src_idx];
|
|
|
|
dest_idx = dest_idx_unmasked & (B44_RX_RING_SIZE - 1);
|
|
|
|
map = &bp->rx_buffers[dest_idx];
|
2007-06-04 16:25:40 -04:00
|
|
|
skb = netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (skb == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
mapping = ssb_dma_map_single(bp->sdev, skb->data,
|
|
|
|
RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Hardware bug work-around, the chip is unable to do PCI DMA
|
|
|
|
to/from anything above 1GB :-( */
|
2008-06-20 05:50:29 -04:00
|
|
|
if (ssb_dma_mapping_error(bp->sdev, mapping) ||
|
2007-02-16 16:27:23 -05:00
|
|
|
mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) {
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Sigh... */
|
2008-06-20 05:50:29 -04:00
|
|
|
if (!ssb_dma_mapping_error(bp->sdev, mapping))
|
|
|
|
ssb_dma_unmap_single(bp->sdev, mapping,
|
|
|
|
RX_PKT_BUF_SZ, DMA_FROM_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
dev_kfree_skb_any(skb);
|
2007-06-04 16:25:40 -04:00
|
|
|
skb = __netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ, GFP_ATOMIC|GFP_DMA);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (skb == NULL)
|
|
|
|
return -ENOMEM;
|
2008-06-20 05:50:29 -04:00
|
|
|
mapping = ssb_dma_map_single(bp->sdev, skb->data,
|
|
|
|
RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
if (ssb_dma_mapping_error(bp->sdev, mapping) ||
|
2007-02-16 16:27:23 -05:00
|
|
|
mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) {
|
2008-06-20 05:50:29 -04:00
|
|
|
if (!ssb_dma_mapping_error(bp->sdev, mapping))
|
|
|
|
ssb_dma_unmap_single(bp->sdev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-04 16:25:39 -04:00
|
|
|
rh = (struct rx_header *) skb->data;
|
|
|
|
skb_reserve(skb, RX_PKT_OFFSET);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
rh->len = 0;
|
|
|
|
rh->flags = 0;
|
|
|
|
|
|
|
|
map->skb = skb;
|
2007-09-19 17:20:30 -04:00
|
|
|
map->mapping = mapping;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (src_map != NULL)
|
|
|
|
src_map->skb = NULL;
|
|
|
|
|
2007-06-04 16:25:39 -04:00
|
|
|
ctrl = (DESC_CTRL_LEN & (RX_PKT_BUF_SZ - RX_PKT_OFFSET));
|
2005-04-16 18:20:36 -04:00
|
|
|
if (dest_idx == (B44_RX_RING_SIZE - 1))
|
|
|
|
ctrl |= DESC_CTRL_EOT;
|
|
|
|
|
|
|
|
dp = &bp->rx_ring[dest_idx];
|
|
|
|
dp->ctrl = cpu_to_le32(ctrl);
|
2007-06-04 16:25:39 -04:00
|
|
|
dp->addr = cpu_to_le32((u32) mapping + RX_PKT_OFFSET + bp->dma_offset);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-10-18 21:30:59 -04:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2007-09-19 17:20:30 -04:00
|
|
|
b44_sync_dma_desc_for_device(bp->sdev, bp->rx_ring_dma,
|
|
|
|
dest_idx * sizeof(dp),
|
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return RX_PKT_BUF_SZ;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_recycle_rx(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
|
|
|
|
{
|
|
|
|
struct dma_desc *src_desc, *dest_desc;
|
|
|
|
struct ring_info *src_map, *dest_map;
|
|
|
|
struct rx_header *rh;
|
|
|
|
int dest_idx;
|
2007-01-29 15:36:54 -05:00
|
|
|
__le32 ctrl;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
dest_idx = dest_idx_unmasked & (B44_RX_RING_SIZE - 1);
|
|
|
|
dest_desc = &bp->rx_ring[dest_idx];
|
|
|
|
dest_map = &bp->rx_buffers[dest_idx];
|
|
|
|
src_desc = &bp->rx_ring[src_idx];
|
|
|
|
src_map = &bp->rx_buffers[src_idx];
|
|
|
|
|
|
|
|
dest_map->skb = src_map->skb;
|
|
|
|
rh = (struct rx_header *) src_map->skb->data;
|
|
|
|
rh->len = 0;
|
|
|
|
rh->flags = 0;
|
2007-09-19 17:20:30 -04:00
|
|
|
dest_map->mapping = src_map->mapping;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-10-18 21:30:59 -04:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2007-09-19 17:20:30 -04:00
|
|
|
b44_sync_dma_desc_for_cpu(bp->sdev, bp->rx_ring_dma,
|
|
|
|
src_idx * sizeof(src_desc),
|
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
ctrl = src_desc->ctrl;
|
|
|
|
if (dest_idx == (B44_RX_RING_SIZE - 1))
|
|
|
|
ctrl |= cpu_to_le32(DESC_CTRL_EOT);
|
|
|
|
else
|
|
|
|
ctrl &= cpu_to_le32(~DESC_CTRL_EOT);
|
|
|
|
|
|
|
|
dest_desc->ctrl = ctrl;
|
|
|
|
dest_desc->addr = src_desc->addr;
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
src_map->skb = NULL;
|
|
|
|
|
2005-10-18 21:30:59 -04:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2007-09-19 17:20:30 -04:00
|
|
|
b44_sync_dma_desc_for_device(bp->sdev, bp->rx_ring_dma,
|
|
|
|
dest_idx * sizeof(dest_desc),
|
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_sync_single_for_device(bp->sdev, le32_to_cpu(src_desc->addr),
|
|
|
|
RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_rx(struct b44 *bp, int budget)
|
|
|
|
{
|
|
|
|
int received;
|
|
|
|
u32 cons, prod;
|
|
|
|
|
|
|
|
received = 0;
|
|
|
|
prod = br32(bp, B44_DMARX_STAT) & DMARX_STAT_CDMASK;
|
|
|
|
prod /= sizeof(struct dma_desc);
|
|
|
|
cons = bp->rx_cons;
|
|
|
|
|
|
|
|
while (cons != prod && budget > 0) {
|
|
|
|
struct ring_info *rp = &bp->rx_buffers[cons];
|
|
|
|
struct sk_buff *skb = rp->skb;
|
2007-09-19 17:20:30 -04:00
|
|
|
dma_addr_t map = rp->mapping;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct rx_header *rh;
|
|
|
|
u16 len;
|
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_sync_single_for_cpu(bp->sdev, map,
|
2005-04-16 18:20:36 -04:00
|
|
|
RX_PKT_BUF_SZ,
|
2007-09-19 17:20:30 -04:00
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
rh = (struct rx_header *) skb->data;
|
2007-01-29 15:36:54 -05:00
|
|
|
len = le16_to_cpu(rh->len);
|
2007-06-04 16:25:39 -04:00
|
|
|
if ((len > (RX_PKT_BUF_SZ - RX_PKT_OFFSET)) ||
|
2005-04-16 18:20:36 -04:00
|
|
|
(rh->flags & cpu_to_le16(RX_FLAG_ERRORS))) {
|
|
|
|
drop_it:
|
|
|
|
b44_recycle_rx(bp, cons, bp->rx_prod);
|
|
|
|
drop_it_no_recycle:
|
|
|
|
bp->stats.rx_dropped++;
|
|
|
|
goto next_pkt;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
udelay(2);
|
|
|
|
barrier();
|
2007-01-29 15:36:54 -05:00
|
|
|
len = le16_to_cpu(rh->len);
|
2005-04-16 18:20:36 -04:00
|
|
|
} while (len == 0 && i++ < 5);
|
|
|
|
if (len == 0)
|
|
|
|
goto drop_it;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Omit CRC. */
|
|
|
|
len -= 4;
|
|
|
|
|
|
|
|
if (len > RX_COPY_THRESHOLD) {
|
|
|
|
int skb_size;
|
|
|
|
skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod);
|
|
|
|
if (skb_size < 0)
|
|
|
|
goto drop_it;
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_unmap_single(bp->sdev, map,
|
|
|
|
skb_size, DMA_FROM_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Leave out rx_header */
|
2007-06-04 16:25:39 -04:00
|
|
|
skb_put(skb, len + RX_PKT_OFFSET);
|
|
|
|
skb_pull(skb, RX_PKT_OFFSET);
|
2005-04-16 18:20:36 -04:00
|
|
|
} else {
|
|
|
|
struct sk_buff *copy_skb;
|
|
|
|
|
|
|
|
b44_recycle_rx(bp, cons, bp->rx_prod);
|
|
|
|
copy_skb = dev_alloc_skb(len + 2);
|
|
|
|
if (copy_skb == NULL)
|
|
|
|
goto drop_it_no_recycle;
|
|
|
|
|
|
|
|
skb_reserve(copy_skb, 2);
|
|
|
|
skb_put(copy_skb, len);
|
|
|
|
/* DMA sync done above, copy just the actual packet */
|
2007-06-04 16:25:39 -04:00
|
|
|
skb_copy_from_linear_data_offset(skb, RX_PKT_OFFSET,
|
2007-03-27 17:55:52 -04:00
|
|
|
copy_skb->data, len);
|
2005-04-16 18:20:36 -04:00
|
|
|
skb = copy_skb;
|
|
|
|
}
|
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
|
|
skb->protocol = eth_type_trans(skb, bp->dev);
|
|
|
|
netif_receive_skb(skb);
|
|
|
|
bp->dev->last_rx = jiffies;
|
|
|
|
received++;
|
|
|
|
budget--;
|
|
|
|
next_pkt:
|
|
|
|
bp->rx_prod = (bp->rx_prod + 1) &
|
|
|
|
(B44_RX_RING_SIZE - 1);
|
|
|
|
cons = (cons + 1) & (B44_RX_RING_SIZE - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
bp->rx_cons = cons;
|
|
|
|
bw32(bp, B44_DMARX_PTR, cons * sizeof(struct dma_desc));
|
|
|
|
|
|
|
|
return received;
|
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
static int b44_poll(struct napi_struct *napi, int budget)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
struct b44 *bp = container_of(napi, struct b44, napi);
|
|
|
|
struct net_device *netdev = bp->dev;
|
|
|
|
int work_done;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
if (bp->istat & (ISTAT_TX | ISTAT_TO)) {
|
|
|
|
/* spin_lock(&bp->tx_lock); */
|
|
|
|
b44_tx(bp);
|
|
|
|
/* spin_unlock(&bp->tx_lock); */
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
work_done = 0;
|
|
|
|
if (bp->istat & ISTAT_RX)
|
|
|
|
work_done += b44_rx(bp, budget);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (bp->istat & ISTAT_ERRORS) {
|
2006-12-17 17:03:15 -05:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&bp->lock, flags);
|
2005-04-16 18:20:36 -04:00
|
|
|
b44_halt(bp);
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
|
2005-04-16 18:20:36 -04:00
|
|
|
netif_wake_queue(bp->dev);
|
2006-12-17 17:03:15 -05:00
|
|
|
spin_unlock_irqrestore(&bp->lock, flags);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
work_done = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
if (work_done < budget) {
|
|
|
|
netif_rx_complete(netdev, napi);
|
2005-04-16 18:20:36 -04:00
|
|
|
b44_enable_ints(bp);
|
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
return work_done;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 09:55:46 -04:00
|
|
|
static irqreturn_t b44_interrupt(int irq, void *dev_id)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct net_device *dev = dev_id;
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
u32 istat, imask;
|
|
|
|
int handled = 0;
|
|
|
|
|
2005-11-06 19:52:06 -05:00
|
|
|
spin_lock(&bp->lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
istat = br32(bp, B44_ISTAT);
|
|
|
|
imask = br32(bp, B44_IMASK);
|
|
|
|
|
2006-11-06 17:17:20 -05:00
|
|
|
/* The interrupt mask register controls which interrupt bits
|
|
|
|
* will actually raise an interrupt to the CPU when set by hw/firmware,
|
|
|
|
* but doesn't mask off the bits.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
|
|
|
istat &= imask;
|
|
|
|
if (istat) {
|
|
|
|
handled = 1;
|
2005-11-08 17:37:12 -05:00
|
|
|
|
|
|
|
if (unlikely(!netif_running(dev))) {
|
|
|
|
printk(KERN_INFO "%s: late interrupt.\n", dev->name);
|
|
|
|
goto irq_ack;
|
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
if (netif_rx_schedule_prep(dev, &bp->napi)) {
|
2005-04-16 18:20:36 -04:00
|
|
|
/* NOTE: These writes are posted by the readback of
|
|
|
|
* the ISTAT register below.
|
|
|
|
*/
|
|
|
|
bp->istat = istat;
|
|
|
|
__b44_disable_ints(bp);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
__netif_rx_schedule(dev, &bp->napi);
|
2005-04-16 18:20:36 -04:00
|
|
|
} else {
|
|
|
|
printk(KERN_ERR PFX "%s: Error, poll already scheduled\n",
|
|
|
|
dev->name);
|
|
|
|
}
|
|
|
|
|
2005-11-08 17:37:12 -05:00
|
|
|
irq_ack:
|
2005-04-16 18:20:36 -04:00
|
|
|
bw32(bp, B44_ISTAT, istat);
|
|
|
|
br32(bp, B44_ISTAT);
|
|
|
|
}
|
2005-11-06 19:52:06 -05:00
|
|
|
spin_unlock(&bp->lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
return IRQ_RETVAL(handled);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_tx_timeout(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
printk(KERN_ERR PFX "%s: transmit timed out, resetting\n",
|
|
|
|
dev->name);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_halt(bp);
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
|
|
|
|
|
|
|
netif_wake_queue(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2005-11-06 19:50:03 -05:00
|
|
|
int rc = NETDEV_TX_OK;
|
2005-04-16 18:20:36 -04:00
|
|
|
dma_addr_t mapping;
|
|
|
|
u32 len, entry, ctrl;
|
|
|
|
|
|
|
|
len = skb->len;
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
/* This is a hard error, log it. */
|
|
|
|
if (unlikely(TX_BUFFS_AVAIL(bp) < 1)) {
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
printk(KERN_ERR PFX "%s: BUG! Tx Ring full when queue awake!\n",
|
|
|
|
dev->name);
|
2005-11-06 19:50:03 -05:00
|
|
|
goto err_out;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
mapping = ssb_dma_map_single(bp->sdev, skb->data, len, DMA_TO_DEVICE);
|
|
|
|
if (ssb_dma_mapping_error(bp->sdev, mapping) || mapping + len > DMA_30BIT_MASK) {
|
2007-06-04 16:25:38 -04:00
|
|
|
struct sk_buff *bounce_skb;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Chip can't handle DMA to/from >1GB, use bounce buffer */
|
2008-06-20 05:50:29 -04:00
|
|
|
if (!ssb_dma_mapping_error(bp->sdev, mapping))
|
|
|
|
ssb_dma_unmap_single(bp->sdev, mapping, len,
|
|
|
|
DMA_TO_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-06-04 16:25:38 -04:00
|
|
|
bounce_skb = __dev_alloc_skb(len, GFP_ATOMIC | GFP_DMA);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!bounce_skb)
|
2005-11-06 19:50:03 -05:00
|
|
|
goto err_out;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
mapping = ssb_dma_map_single(bp->sdev, bounce_skb->data,
|
|
|
|
len, DMA_TO_DEVICE);
|
|
|
|
if (ssb_dma_mapping_error(bp->sdev, mapping) || mapping + len > DMA_30BIT_MASK) {
|
|
|
|
if (!ssb_dma_mapping_error(bp->sdev, mapping))
|
|
|
|
ssb_dma_unmap_single(bp->sdev, mapping,
|
|
|
|
len, DMA_TO_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
dev_kfree_skb_any(bounce_skb);
|
2005-11-06 19:50:03 -05:00
|
|
|
goto err_out;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-06-04 16:25:38 -04:00
|
|
|
skb_copy_from_linear_data(skb, skb_put(bounce_skb, len), len);
|
2005-04-16 18:20:36 -04:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
skb = bounce_skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry = bp->tx_prod;
|
|
|
|
bp->tx_buffers[entry].skb = skb;
|
2007-09-19 17:20:30 -04:00
|
|
|
bp->tx_buffers[entry].mapping = mapping;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
ctrl = (len & DESC_CTRL_LEN);
|
|
|
|
ctrl |= DESC_CTRL_IOC | DESC_CTRL_SOF | DESC_CTRL_EOF;
|
|
|
|
if (entry == (B44_TX_RING_SIZE - 1))
|
|
|
|
ctrl |= DESC_CTRL_EOT;
|
|
|
|
|
|
|
|
bp->tx_ring[entry].ctrl = cpu_to_le32(ctrl);
|
|
|
|
bp->tx_ring[entry].addr = cpu_to_le32((u32) mapping+bp->dma_offset);
|
|
|
|
|
2005-10-18 21:30:59 -04:00
|
|
|
if (bp->flags & B44_FLAG_TX_RING_HACK)
|
2007-09-19 17:20:30 -04:00
|
|
|
b44_sync_dma_desc_for_device(bp->sdev, bp->tx_ring_dma,
|
|
|
|
entry * sizeof(bp->tx_ring[0]),
|
|
|
|
DMA_TO_DEVICE);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
entry = NEXT_TX(entry);
|
|
|
|
|
|
|
|
bp->tx_prod = entry;
|
|
|
|
|
|
|
|
wmb();
|
|
|
|
|
|
|
|
bw32(bp, B44_DMATX_PTR, entry * sizeof(struct dma_desc));
|
|
|
|
if (bp->flags & B44_FLAG_BUGGY_TXPTR)
|
|
|
|
bw32(bp, B44_DMATX_PTR, entry * sizeof(struct dma_desc));
|
|
|
|
if (bp->flags & B44_FLAG_REORDER_BUG)
|
|
|
|
br32(bp, B44_DMATX_PTR);
|
|
|
|
|
|
|
|
if (TX_BUFFS_AVAIL(bp) < 1)
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
2005-11-06 19:50:03 -05:00
|
|
|
dev->trans_start = jiffies;
|
|
|
|
|
|
|
|
out_unlock:
|
2005-04-16 18:20:36 -04:00
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
2005-11-06 19:50:03 -05:00
|
|
|
return rc;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-06 19:50:03 -05:00
|
|
|
err_out:
|
|
|
|
rc = NETDEV_TX_BUSY;
|
|
|
|
goto out_unlock;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (new_mtu < B44_MIN_MTU || new_mtu > B44_MAX_MTU)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!netif_running(dev)) {
|
|
|
|
/* We'll just catch it later when the
|
|
|
|
* device is up'd.
|
|
|
|
*/
|
|
|
|
dev->mtu = new_mtu;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
b44_halt(bp);
|
|
|
|
dev->mtu = new_mtu;
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 18:20:36 -04:00
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2006-04-12 18:04:32 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free up pending packets in all rx/tx rings.
|
|
|
|
*
|
|
|
|
* The chip has been shut down and the driver detached from
|
|
|
|
* the networking, so no interrupts or new tx packets will
|
|
|
|
* end up in the driver. bp->lock is not held and we are not
|
|
|
|
* in an interrupt context and thus may sleep.
|
|
|
|
*/
|
|
|
|
static void b44_free_rings(struct b44 *bp)
|
|
|
|
{
|
|
|
|
struct ring_info *rp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < B44_RX_RING_SIZE; i++) {
|
|
|
|
rp = &bp->rx_buffers[i];
|
|
|
|
|
|
|
|
if (rp->skb == NULL)
|
|
|
|
continue;
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_unmap_single(bp->sdev, rp->mapping, RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
dev_kfree_skb_any(rp->skb);
|
|
|
|
rp->skb = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX needs changes once NETIF_F_SG is set... */
|
|
|
|
for (i = 0; i < B44_TX_RING_SIZE; i++) {
|
|
|
|
rp = &bp->tx_buffers[i];
|
|
|
|
|
|
|
|
if (rp->skb == NULL)
|
|
|
|
continue;
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_unmap_single(bp->sdev, rp->mapping, rp->skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2005-04-16 18:20:36 -04:00
|
|
|
dev_kfree_skb_any(rp->skb);
|
|
|
|
rp->skb = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize tx/rx rings for packet processing.
|
|
|
|
*
|
|
|
|
* The chip has been shut down and the driver detached from
|
|
|
|
* the networking, so no interrupts or new tx packets will
|
2005-11-06 19:50:46 -05:00
|
|
|
* end up in the driver.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
|
|
|
static void b44_init_rings(struct b44 *bp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
b44_free_rings(bp);
|
|
|
|
|
|
|
|
memset(bp->rx_ring, 0, B44_RX_RING_BYTES);
|
|
|
|
memset(bp->tx_ring, 0, B44_TX_RING_BYTES);
|
|
|
|
|
2005-10-18 21:30:59 -04:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_sync_single_for_device(bp->sdev, bp->rx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_TX_RING_HACK)
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_sync_single_for_device(bp->sdev, bp->tx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_TO_DEVICE);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
for (i = 0; i < bp->rx_pending; i++) {
|
|
|
|
if (b44_alloc_rx_skb(bp, -1, i) < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must not be invoked with interrupt sources disabled and
|
|
|
|
* the hardware shutdown down.
|
|
|
|
*/
|
|
|
|
static void b44_free_consistent(struct b44 *bp)
|
|
|
|
{
|
2005-10-28 16:53:13 -04:00
|
|
|
kfree(bp->rx_buffers);
|
|
|
|
bp->rx_buffers = NULL;
|
|
|
|
kfree(bp->tx_buffers);
|
|
|
|
bp->tx_buffers = NULL;
|
2005-04-16 18:20:36 -04:00
|
|
|
if (bp->rx_ring) {
|
2005-10-18 21:30:59 -04:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK) {
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_unmap_single(bp->sdev, bp->rx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-18 21:30:59 -04:00
|
|
|
kfree(bp->rx_ring);
|
|
|
|
} else
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_free_consistent(bp->sdev, DMA_TABLE_BYTES,
|
|
|
|
bp->rx_ring, bp->rx_ring_dma,
|
|
|
|
GFP_KERNEL);
|
2005-04-16 18:20:36 -04:00
|
|
|
bp->rx_ring = NULL;
|
2005-10-18 21:30:59 -04:00
|
|
|
bp->flags &= ~B44_FLAG_RX_RING_HACK;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
if (bp->tx_ring) {
|
2005-10-18 21:30:59 -04:00
|
|
|
if (bp->flags & B44_FLAG_TX_RING_HACK) {
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_unmap_single(bp->sdev, bp->tx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_TO_DEVICE);
|
2005-10-18 21:30:59 -04:00
|
|
|
kfree(bp->tx_ring);
|
|
|
|
} else
|
2008-06-20 05:50:29 -04:00
|
|
|
ssb_dma_free_consistent(bp->sdev, DMA_TABLE_BYTES,
|
|
|
|
bp->tx_ring, bp->tx_ring_dma,
|
|
|
|
GFP_KERNEL);
|
2005-04-16 18:20:36 -04:00
|
|
|
bp->tx_ring = NULL;
|
2005-10-18 21:30:59 -04:00
|
|
|
bp->flags &= ~B44_FLAG_TX_RING_HACK;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must not be invoked with interrupt sources disabled and
|
|
|
|
* the hardware shutdown down. Can sleep.
|
|
|
|
*/
|
2007-09-19 17:20:30 -04:00
|
|
|
static int b44_alloc_consistent(struct b44 *bp, gfp_t gfp)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
int size;
|
|
|
|
|
|
|
|
size = B44_RX_RING_SIZE * sizeof(struct ring_info);
|
2007-09-19 17:20:30 -04:00
|
|
|
bp->rx_buffers = kzalloc(size, gfp);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!bp->rx_buffers)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
size = B44_TX_RING_SIZE * sizeof(struct ring_info);
|
2007-09-19 17:20:30 -04:00
|
|
|
bp->tx_buffers = kzalloc(size, gfp);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!bp->tx_buffers)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
size = DMA_TABLE_BYTES;
|
2008-06-20 05:50:29 -04:00
|
|
|
bp->rx_ring = ssb_dma_alloc_consistent(bp->sdev, size, &bp->rx_ring_dma, gfp);
|
2005-10-18 21:30:59 -04:00
|
|
|
if (!bp->rx_ring) {
|
|
|
|
/* Allocation may have failed due to pci_alloc_consistent
|
|
|
|
insisting on use of GFP_DMA, which is more restrictive
|
|
|
|
than necessary... */
|
|
|
|
struct dma_desc *rx_ring;
|
|
|
|
dma_addr_t rx_ring_dma;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
rx_ring = kzalloc(size, gfp);
|
2005-11-06 19:50:46 -05:00
|
|
|
if (!rx_ring)
|
2005-10-18 21:30:59 -04:00
|
|
|
goto out_err;
|
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
rx_ring_dma = ssb_dma_map_single(bp->sdev, rx_ring,
|
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
if (ssb_dma_mapping_error(bp->sdev, rx_ring_dma) ||
|
2007-02-16 16:27:23 -05:00
|
|
|
rx_ring_dma + size > DMA_30BIT_MASK) {
|
2005-10-18 21:30:59 -04:00
|
|
|
kfree(rx_ring);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
bp->rx_ring = rx_ring;
|
|
|
|
bp->rx_ring_dma = rx_ring_dma;
|
|
|
|
bp->flags |= B44_FLAG_RX_RING_HACK;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
bp->tx_ring = ssb_dma_alloc_consistent(bp->sdev, size, &bp->tx_ring_dma, gfp);
|
2005-10-18 21:30:59 -04:00
|
|
|
if (!bp->tx_ring) {
|
2008-06-20 05:50:29 -04:00
|
|
|
/* Allocation may have failed due to ssb_dma_alloc_consistent
|
2005-10-18 21:30:59 -04:00
|
|
|
insisting on use of GFP_DMA, which is more restrictive
|
|
|
|
than necessary... */
|
|
|
|
struct dma_desc *tx_ring;
|
|
|
|
dma_addr_t tx_ring_dma;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
tx_ring = kzalloc(size, gfp);
|
2005-11-06 19:50:46 -05:00
|
|
|
if (!tx_ring)
|
2005-10-18 21:30:59 -04:00
|
|
|
goto out_err;
|
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
tx_ring_dma = ssb_dma_map_single(bp->sdev, tx_ring,
|
2007-09-19 17:20:30 -04:00
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_TO_DEVICE);
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2008-06-20 05:50:29 -04:00
|
|
|
if (ssb_dma_mapping_error(bp->sdev, tx_ring_dma) ||
|
2007-02-16 16:27:23 -05:00
|
|
|
tx_ring_dma + size > DMA_30BIT_MASK) {
|
2005-10-18 21:30:59 -04:00
|
|
|
kfree(tx_ring);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
bp->tx_ring = tx_ring;
|
|
|
|
bp->tx_ring_dma = tx_ring_dma;
|
|
|
|
bp->flags |= B44_FLAG_TX_RING_HACK;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_err:
|
|
|
|
b44_free_consistent(bp);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bp->lock is held. */
|
|
|
|
static void b44_clear_stats(struct b44 *bp)
|
|
|
|
{
|
|
|
|
unsigned long reg;
|
|
|
|
|
|
|
|
bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
|
|
|
|
for (reg = B44_TX_GOOD_O; reg <= B44_TX_PAUSE; reg += 4UL)
|
|
|
|
br32(bp, reg);
|
|
|
|
for (reg = B44_RX_GOOD_O; reg <= B44_RX_NPAUSE; reg += 4UL)
|
|
|
|
br32(bp, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bp->lock is held. */
|
2007-12-31 19:17:54 -05:00
|
|
|
static void b44_chip_reset(struct b44 *bp, int reset_kind)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
struct ssb_device *sdev = bp->sdev;
|
|
|
|
|
|
|
|
if (ssb_device_is_enabled(bp->sdev)) {
|
2005-04-16 18:20:36 -04:00
|
|
|
bw32(bp, B44_RCV_LAZY, 0);
|
|
|
|
bw32(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE);
|
2007-02-16 16:27:27 -05:00
|
|
|
b44_wait_bit(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE, 200, 1);
|
2005-04-16 18:20:36 -04:00
|
|
|
bw32(bp, B44_DMATX_CTRL, 0);
|
|
|
|
bp->tx_prod = bp->tx_cons = 0;
|
|
|
|
if (br32(bp, B44_DMARX_STAT) & DMARX_STAT_EMASK) {
|
|
|
|
b44_wait_bit(bp, B44_DMARX_STAT, DMARX_STAT_SIDLE,
|
|
|
|
100, 0);
|
|
|
|
}
|
|
|
|
bw32(bp, B44_DMARX_CTRL, 0);
|
|
|
|
bp->rx_prod = bp->rx_cons = 0;
|
2007-09-19 17:20:30 -04:00
|
|
|
} else
|
|
|
|
ssb_pcicore_dev_irqvecs_enable(&sdev->bus->pcicore, sdev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
ssb_device_enable(bp->sdev, 0);
|
2005-04-16 18:20:36 -04:00
|
|
|
b44_clear_stats(bp);
|
|
|
|
|
2007-12-31 19:17:54 -05:00
|
|
|
/*
|
|
|
|
* Don't enable PHY if we are doing a partial reset
|
|
|
|
* we are probably going to power down
|
|
|
|
*/
|
|
|
|
if (reset_kind == B44_CHIP_RESET_PARTIAL)
|
|
|
|
return;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
switch (sdev->bus->bustype) {
|
|
|
|
case SSB_BUSTYPE_SSB:
|
|
|
|
bw32(bp, B44_MDIO_CTRL, (MDIO_CTRL_PREAMBLE |
|
|
|
|
(((ssb_clockspeed(sdev->bus) + (B44_MDC_RATIO / 2)) / B44_MDC_RATIO)
|
|
|
|
& MDIO_CTRL_MAXF_MASK)));
|
|
|
|
break;
|
|
|
|
case SSB_BUSTYPE_PCI:
|
|
|
|
case SSB_BUSTYPE_PCMCIA:
|
|
|
|
bw32(bp, B44_MDIO_CTRL, (MDIO_CTRL_PREAMBLE |
|
|
|
|
(0x0d & MDIO_CTRL_MAXF_MASK)));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
br32(bp, B44_MDIO_CTRL);
|
|
|
|
|
|
|
|
if (!(br32(bp, B44_DEVCTRL) & DEVCTRL_IPP)) {
|
|
|
|
bw32(bp, B44_ENET_CTRL, ENET_CTRL_EPSEL);
|
|
|
|
br32(bp, B44_ENET_CTRL);
|
|
|
|
bp->flags &= ~B44_FLAG_INTERNAL_PHY;
|
|
|
|
} else {
|
|
|
|
u32 val = br32(bp, B44_DEVCTRL);
|
|
|
|
|
|
|
|
if (val & DEVCTRL_EPR) {
|
|
|
|
bw32(bp, B44_DEVCTRL, (val & ~DEVCTRL_EPR));
|
|
|
|
br32(bp, B44_DEVCTRL);
|
|
|
|
udelay(100);
|
|
|
|
}
|
|
|
|
bp->flags |= B44_FLAG_INTERNAL_PHY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bp->lock is held. */
|
|
|
|
static void b44_halt(struct b44 *bp)
|
|
|
|
{
|
|
|
|
b44_disable_ints(bp);
|
2007-12-31 19:17:54 -05:00
|
|
|
/* reset PHY */
|
|
|
|
b44_phy_reset(bp);
|
|
|
|
/* power down PHY */
|
|
|
|
printk(KERN_INFO PFX "%s: powering down PHY\n", bp->dev->name);
|
|
|
|
bw32(bp, B44_MAC_CTRL, MAC_CTRL_PHY_PDOWN);
|
|
|
|
/* now reset the chip, but without enabling the MAC&PHY
|
|
|
|
* part of it. This has to be done _after_ we shut down the PHY */
|
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_PARTIAL);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* bp->lock is held. */
|
|
|
|
static void __b44_set_mac_addr(struct b44 *bp)
|
|
|
|
{
|
|
|
|
bw32(bp, B44_CAM_CTRL, 0);
|
|
|
|
if (!(bp->dev->flags & IFF_PROMISC)) {
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
__b44_cam_write(bp, bp->dev->dev_addr, 0);
|
|
|
|
val = br32(bp, B44_CAM_CTRL);
|
|
|
|
bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_set_mac_addr(struct net_device *dev, void *p)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
struct sockaddr *addr = p;
|
2007-09-19 17:20:30 -04:00
|
|
|
u32 val;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (netif_running(dev))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2006-03-28 17:57:38 -05:00
|
|
|
if (!is_valid_ether_addr(addr->sa_data))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
2007-09-19 17:20:30 -04:00
|
|
|
|
|
|
|
val = br32(bp, B44_RXCONFIG);
|
|
|
|
if (!(val & RXCONFIG_CAM_ABSENT))
|
|
|
|
__b44_set_mac_addr(bp);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Called at device open time to get the chip ready for
|
|
|
|
* packet processing. Invoked with bp->lock held.
|
|
|
|
*/
|
|
|
|
static void __b44_set_rx_mode(struct net_device *);
|
2007-01-27 02:59:57 -05:00
|
|
|
static void b44_init_hw(struct b44 *bp, int reset_kind)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
2007-12-31 19:17:54 -05:00
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_FULL);
|
2007-01-27 02:59:57 -05:00
|
|
|
if (reset_kind == B44_FULL_RESET) {
|
2006-06-20 18:34:26 -04:00
|
|
|
b44_phy_reset(bp);
|
|
|
|
b44_setup_phy(bp);
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Enable CRC32, set proper LED modes and power on PHY */
|
|
|
|
bw32(bp, B44_MAC_CTRL, MAC_CTRL_CRC32_ENAB | MAC_CTRL_PHY_LEDCTRL);
|
|
|
|
bw32(bp, B44_RCV_LAZY, (1 << RCV_LAZY_FC_SHIFT));
|
|
|
|
|
|
|
|
/* This sets the MAC address too. */
|
|
|
|
__b44_set_rx_mode(bp->dev);
|
|
|
|
|
|
|
|
/* MTU + eth header + possible VLAN tag + struct rx_header */
|
|
|
|
bw32(bp, B44_RXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN);
|
|
|
|
bw32(bp, B44_TXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN);
|
|
|
|
|
|
|
|
bw32(bp, B44_TX_WMARK, 56); /* XXX magic */
|
2007-01-27 02:59:57 -05:00
|
|
|
if (reset_kind == B44_PARTIAL_RESET) {
|
|
|
|
bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
|
2007-06-04 16:25:39 -04:00
|
|
|
(RX_PKT_OFFSET << DMARX_CTRL_ROSHIFT)));
|
2007-01-27 02:59:57 -05:00
|
|
|
} else {
|
2006-06-20 18:34:26 -04:00
|
|
|
bw32(bp, B44_DMATX_CTRL, DMATX_CTRL_ENABLE);
|
|
|
|
bw32(bp, B44_DMATX_ADDR, bp->tx_ring_dma + bp->dma_offset);
|
|
|
|
bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
|
2007-06-04 16:25:39 -04:00
|
|
|
(RX_PKT_OFFSET << DMARX_CTRL_ROSHIFT)));
|
2006-06-20 18:34:26 -04:00
|
|
|
bw32(bp, B44_DMARX_ADDR, bp->rx_ring_dma + bp->dma_offset);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-06-20 18:34:26 -04:00
|
|
|
bw32(bp, B44_DMARX_PTR, bp->rx_pending);
|
|
|
|
bp->rx_prod = bp->rx_pending;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-06-20 18:34:26 -04:00
|
|
|
bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
val = br32(bp, B44_ENET_CTRL);
|
|
|
|
bw32(bp, B44_ENET_CTRL, (val | ENET_CTRL_ENABLE));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_open(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
int err;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
err = b44_alloc_consistent(bp, GFP_KERNEL);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (err)
|
2005-11-06 19:52:57 -05:00
|
|
|
goto out;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
napi_enable(&bp->napi);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
b44_init_rings(bp);
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-06-08 15:11:57 -04:00
|
|
|
b44_check_phy(bp);
|
|
|
|
|
2006-07-01 22:29:39 -04:00
|
|
|
err = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
|
2005-11-06 19:52:57 -05:00
|
|
|
if (unlikely(err < 0)) {
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
napi_disable(&bp->napi);
|
2007-12-31 19:17:54 -05:00
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_PARTIAL);
|
2005-11-06 19:52:57 -05:00
|
|
|
b44_free_rings(bp);
|
|
|
|
b44_free_consistent(bp);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
init_timer(&bp->timer);
|
|
|
|
bp->timer.expires = jiffies + HZ;
|
|
|
|
bp->timer.data = (unsigned long) bp;
|
|
|
|
bp->timer.function = b44_timer;
|
|
|
|
add_timer(&bp->timer);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2005-11-30 16:30:23 -05:00
|
|
|
netif_start_queue(dev);
|
2005-11-06 19:52:57 -05:00
|
|
|
out:
|
2005-04-16 18:20:36 -04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
/*
|
|
|
|
* Polling receive - used by netconsole and other diagnostic tools
|
|
|
|
* to allow network i/o with interrupts disabled.
|
|
|
|
*/
|
|
|
|
static void b44_poll_controller(struct net_device *dev)
|
|
|
|
{
|
|
|
|
disable_irq(dev->irq);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 09:55:46 -04:00
|
|
|
b44_interrupt(dev->irq, dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
enable_irq(dev->irq);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-06-20 18:34:36 -04:00
|
|
|
static void bwfilter_table(struct b44 *bp, u8 *pp, u32 bytes, u32 table_offset)
|
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
u32 *pattern = (u32 *) pp;
|
|
|
|
|
|
|
|
for (i = 0; i < bytes; i += sizeof(u32)) {
|
|
|
|
bw32(bp, B44_FILT_ADDR, table_offset + i);
|
|
|
|
bw32(bp, B44_FILT_DATA, pattern[i / sizeof(u32)]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_magic_pattern(u8 *macaddr, u8 *ppattern, u8 *pmask, int offset)
|
|
|
|
{
|
|
|
|
int magicsync = 6;
|
|
|
|
int k, j, len = offset;
|
|
|
|
int ethaddr_bytes = ETH_ALEN;
|
|
|
|
|
|
|
|
memset(ppattern + offset, 0xff, magicsync);
|
|
|
|
for (j = 0; j < magicsync; j++)
|
|
|
|
set_bit(len++, (unsigned long *) pmask);
|
|
|
|
|
|
|
|
for (j = 0; j < B44_MAX_PATTERNS; j++) {
|
|
|
|
if ((B44_PATTERN_SIZE - len) >= ETH_ALEN)
|
|
|
|
ethaddr_bytes = ETH_ALEN;
|
|
|
|
else
|
|
|
|
ethaddr_bytes = B44_PATTERN_SIZE - len;
|
|
|
|
if (ethaddr_bytes <=0)
|
|
|
|
break;
|
|
|
|
for (k = 0; k< ethaddr_bytes; k++) {
|
|
|
|
ppattern[offset + magicsync +
|
|
|
|
(j * ETH_ALEN) + k] = macaddr[k];
|
|
|
|
len++;
|
|
|
|
set_bit(len, (unsigned long *) pmask);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return len - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup magic packet patterns in the b44 WOL
|
|
|
|
* pattern matching filter.
|
|
|
|
*/
|
|
|
|
static void b44_setup_pseudo_magicp(struct b44 *bp)
|
|
|
|
{
|
|
|
|
|
|
|
|
u32 val;
|
|
|
|
int plen0, plen1, plen2;
|
|
|
|
u8 *pwol_pattern;
|
|
|
|
u8 pwol_mask[B44_PMASK_SIZE];
|
|
|
|
|
some kmalloc/memset ->kzalloc (tree wide)
Transform some calls to kmalloc/memset to a single kzalloc (or kcalloc).
Here is a short excerpt of the semantic patch performing
this transformation:
@@
type T2;
expression x;
identifier f,fld;
expression E;
expression E1,E2;
expression e1,e2,e3,y;
statement S;
@@
x =
- kmalloc
+ kzalloc
(E1,E2)
... when != \(x->fld=E;\|y=f(...,x,...);\|f(...,x,...);\|x=E;\|while(...) S\|for(e1;e2;e3) S\)
- memset((T2)x,0,E1);
@@
expression E1,E2,E3;
@@
- kzalloc(E1 * E2,E3)
+ kcalloc(E1,E2,E3)
[akpm@linux-foundation.org: get kcalloc args the right way around]
Signed-off-by: Yoann Padioleau <padator@wanadoo.fr>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Acked-by: Russell King <rmk@arm.linux.org.uk>
Cc: Bryan Wu <bryan.wu@analog.com>
Acked-by: Jiri Slaby <jirislaby@gmail.com>
Cc: Dave Airlie <airlied@linux.ie>
Acked-by: Roland Dreier <rolandd@cisco.com>
Cc: Jiri Kosina <jkosina@suse.cz>
Acked-by: Dmitry Torokhov <dtor@mail.ru>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Acked-by: Mauro Carvalho Chehab <mchehab@infradead.org>
Acked-by: Pierre Ossman <drzeus-list@drzeus.cx>
Cc: Jeff Garzik <jeff@garzik.org>
Cc: "David S. Miller" <davem@davemloft.net>
Acked-by: Greg KH <greg@kroah.com>
Cc: James Bottomley <James.Bottomley@steeleye.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 04:49:03 -04:00
|
|
|
pwol_pattern = kzalloc(B44_PATTERN_SIZE, GFP_KERNEL);
|
2006-06-20 18:34:36 -04:00
|
|
|
if (!pwol_pattern) {
|
|
|
|
printk(KERN_ERR PFX "Memory not available for WOL\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ipv4 magic packet pattern - pattern 0.*/
|
|
|
|
memset(pwol_mask, 0, B44_PMASK_SIZE);
|
|
|
|
plen0 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
|
|
|
|
B44_ETHIPV4UDP_HLEN);
|
|
|
|
|
|
|
|
bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE, B44_PATTERN_BASE);
|
|
|
|
bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE, B44_PMASK_BASE);
|
|
|
|
|
|
|
|
/* Raw ethernet II magic packet pattern - pattern 1 */
|
|
|
|
memset(pwol_pattern, 0, B44_PATTERN_SIZE);
|
|
|
|
memset(pwol_mask, 0, B44_PMASK_SIZE);
|
|
|
|
plen1 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
|
|
|
|
ETH_HLEN);
|
|
|
|
|
|
|
|
bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE,
|
|
|
|
B44_PATTERN_BASE + B44_PATTERN_SIZE);
|
|
|
|
bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE,
|
|
|
|
B44_PMASK_BASE + B44_PMASK_SIZE);
|
|
|
|
|
|
|
|
/* Ipv6 magic packet pattern - pattern 2 */
|
|
|
|
memset(pwol_pattern, 0, B44_PATTERN_SIZE);
|
|
|
|
memset(pwol_mask, 0, B44_PMASK_SIZE);
|
|
|
|
plen2 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
|
|
|
|
B44_ETHIPV6UDP_HLEN);
|
|
|
|
|
|
|
|
bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE,
|
|
|
|
B44_PATTERN_BASE + B44_PATTERN_SIZE + B44_PATTERN_SIZE);
|
|
|
|
bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE,
|
|
|
|
B44_PMASK_BASE + B44_PMASK_SIZE + B44_PMASK_SIZE);
|
|
|
|
|
|
|
|
kfree(pwol_pattern);
|
|
|
|
|
|
|
|
/* set these pattern's lengths: one less than each real length */
|
|
|
|
val = plen0 | (plen1 << 8) | (plen2 << 16) | WKUP_LEN_ENABLE_THREE;
|
|
|
|
bw32(bp, B44_WKUP_LEN, val);
|
|
|
|
|
|
|
|
/* enable wakeup pattern matching */
|
|
|
|
val = br32(bp, B44_DEVCTRL);
|
|
|
|
bw32(bp, B44_DEVCTRL, val | DEVCTRL_PFE);
|
|
|
|
|
|
|
|
}
|
2006-06-20 18:34:23 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
#ifdef CONFIG_B44_PCI
|
|
|
|
static void b44_setup_wol_pci(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u16 val;
|
|
|
|
|
|
|
|
if (bp->sdev->bus->bustype != SSB_BUSTYPE_SSB) {
|
|
|
|
bw32(bp, SSB_TMSLOW, br32(bp, SSB_TMSLOW) | SSB_TMSLOW_PE);
|
|
|
|
pci_read_config_word(bp->sdev->bus->host_pci, SSB_PMCSR, &val);
|
|
|
|
pci_write_config_word(bp->sdev->bus->host_pci, SSB_PMCSR, val | SSB_PE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void b44_setup_wol_pci(struct b44 *bp) { }
|
|
|
|
#endif /* CONFIG_B44_PCI */
|
|
|
|
|
2006-06-20 18:34:23 -04:00
|
|
|
static void b44_setup_wol(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
bw32(bp, B44_RXCONFIG, RXCONFIG_ALLMULTI);
|
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_B0_ANDLATER) {
|
|
|
|
|
|
|
|
bw32(bp, B44_WKUP_LEN, WKUP_LEN_DISABLE);
|
|
|
|
|
|
|
|
val = bp->dev->dev_addr[2] << 24 |
|
|
|
|
bp->dev->dev_addr[3] << 16 |
|
|
|
|
bp->dev->dev_addr[4] << 8 |
|
|
|
|
bp->dev->dev_addr[5];
|
|
|
|
bw32(bp, B44_ADDR_LO, val);
|
|
|
|
|
|
|
|
val = bp->dev->dev_addr[0] << 8 |
|
|
|
|
bp->dev->dev_addr[1];
|
|
|
|
bw32(bp, B44_ADDR_HI, val);
|
|
|
|
|
|
|
|
val = br32(bp, B44_DEVCTRL);
|
|
|
|
bw32(bp, B44_DEVCTRL, val | DEVCTRL_MPM | DEVCTRL_PFE);
|
|
|
|
|
2006-06-20 18:34:36 -04:00
|
|
|
} else {
|
|
|
|
b44_setup_pseudo_magicp(bp);
|
|
|
|
}
|
2007-09-19 17:20:30 -04:00
|
|
|
b44_setup_wol_pci(bp);
|
2006-06-20 18:34:23 -04:00
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static int b44_close(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
napi_disable(&bp->napi);
|
2005-11-08 17:37:12 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
del_timer_sync(&bp->timer);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_halt(bp);
|
|
|
|
b44_free_rings(bp);
|
2006-01-21 00:13:17 -05:00
|
|
|
netif_carrier_off(dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
|
2006-06-20 18:34:23 -04:00
|
|
|
if (bp->flags & B44_FLAG_WOL_ENABLE) {
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_PARTIAL_RESET);
|
2006-06-20 18:34:23 -04:00
|
|
|
b44_setup_wol(bp);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
b44_free_consistent(bp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct net_device_stats *b44_get_stats(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
struct net_device_stats *nstat = &bp->stats;
|
|
|
|
struct b44_hw_stats *hwstat = &bp->hw_stats;
|
|
|
|
|
|
|
|
/* Convert HW stats into netdevice stats. */
|
|
|
|
nstat->rx_packets = hwstat->rx_pkts;
|
|
|
|
nstat->tx_packets = hwstat->tx_pkts;
|
|
|
|
nstat->rx_bytes = hwstat->rx_octets;
|
|
|
|
nstat->tx_bytes = hwstat->tx_octets;
|
|
|
|
nstat->tx_errors = (hwstat->tx_jabber_pkts +
|
|
|
|
hwstat->tx_oversize_pkts +
|
|
|
|
hwstat->tx_underruns +
|
|
|
|
hwstat->tx_excessive_cols +
|
|
|
|
hwstat->tx_late_cols);
|
|
|
|
nstat->multicast = hwstat->tx_multicast_pkts;
|
|
|
|
nstat->collisions = hwstat->tx_total_cols;
|
|
|
|
|
|
|
|
nstat->rx_length_errors = (hwstat->rx_oversize_pkts +
|
|
|
|
hwstat->rx_undersize);
|
|
|
|
nstat->rx_over_errors = hwstat->rx_missed_pkts;
|
|
|
|
nstat->rx_frame_errors = hwstat->rx_align_errs;
|
|
|
|
nstat->rx_crc_errors = hwstat->rx_crc_errs;
|
|
|
|
nstat->rx_errors = (hwstat->rx_jabber_pkts +
|
|
|
|
hwstat->rx_oversize_pkts +
|
|
|
|
hwstat->rx_missed_pkts +
|
|
|
|
hwstat->rx_crc_align_errs +
|
|
|
|
hwstat->rx_undersize +
|
|
|
|
hwstat->rx_crc_errs +
|
|
|
|
hwstat->rx_align_errs +
|
|
|
|
hwstat->rx_symbol_errs);
|
|
|
|
|
|
|
|
nstat->tx_aborted_errors = hwstat->tx_underruns;
|
|
|
|
#if 0
|
|
|
|
/* Carrier lost counter seems to be broken for some devices */
|
|
|
|
nstat->tx_carrier_errors = hwstat->tx_carrier_lost;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return nstat;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __b44_load_mcast(struct b44 *bp, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct dev_mc_list *mclist;
|
|
|
|
int i, num_ents;
|
|
|
|
|
|
|
|
num_ents = min_t(int, dev->mc_count, B44_MCAST_TABLE_SIZE);
|
|
|
|
mclist = dev->mc_list;
|
|
|
|
for (i = 0; mclist && i < num_ents; i++, mclist = mclist->next) {
|
|
|
|
__b44_cam_write(bp, mclist->dmi_addr, i + 1);
|
|
|
|
}
|
|
|
|
return i+1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __b44_set_rx_mode(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
val = br32(bp, B44_RXCONFIG);
|
|
|
|
val &= ~(RXCONFIG_PROMISC | RXCONFIG_ALLMULTI);
|
2007-09-19 17:20:30 -04:00
|
|
|
if ((dev->flags & IFF_PROMISC) || (val & RXCONFIG_CAM_ABSENT)) {
|
2005-04-16 18:20:36 -04:00
|
|
|
val |= RXCONFIG_PROMISC;
|
|
|
|
bw32(bp, B44_RXCONFIG, val);
|
|
|
|
} else {
|
2005-11-06 19:50:46 -05:00
|
|
|
unsigned char zero[6] = {0, 0, 0, 0, 0, 0};
|
2007-04-01 13:10:28 -04:00
|
|
|
int i = 1;
|
2005-11-06 19:50:46 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
__b44_set_mac_addr(bp);
|
|
|
|
|
2006-10-05 07:10:38 -04:00
|
|
|
if ((dev->flags & IFF_ALLMULTI) ||
|
|
|
|
(dev->mc_count > B44_MCAST_TABLE_SIZE))
|
2005-04-16 18:20:36 -04:00
|
|
|
val |= RXCONFIG_ALLMULTI;
|
|
|
|
else
|
2005-11-06 19:50:46 -05:00
|
|
|
i = __b44_load_mcast(bp, dev);
|
2006-04-12 18:04:32 -04:00
|
|
|
|
2006-10-05 07:10:38 -04:00
|
|
|
for (; i < 64; i++)
|
2006-04-12 18:04:32 -04:00
|
|
|
__b44_cam_write(bp, zero, i);
|
2006-10-05 07:10:38 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
bw32(bp, B44_RXCONFIG, val);
|
|
|
|
val = br32(bp, B44_CAM_CTRL);
|
|
|
|
bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_set_rx_mode(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
__b44_set_rx_mode(dev);
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 b44_get_msglevel(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
return bp->msg_enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_set_msglevel(struct net_device *dev, u32 value)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
bp->msg_enable = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2007-09-19 17:20:30 -04:00
|
|
|
struct ssb_bus *bus = bp->sdev->bus;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
strncpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
|
|
|
|
strncpy(info->version, DRV_MODULE_VERSION, sizeof(info->driver));
|
|
|
|
switch (bus->bustype) {
|
|
|
|
case SSB_BUSTYPE_PCI:
|
|
|
|
strncpy(info->bus_info, pci_name(bus->host_pci), sizeof(info->bus_info));
|
|
|
|
break;
|
|
|
|
case SSB_BUSTYPE_PCMCIA:
|
|
|
|
case SSB_BUSTYPE_SSB:
|
|
|
|
strncpy(info->bus_info, "SSB", sizeof(info->bus_info));
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_nway_reset(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
u32 bmcr;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
b44_readphy(bp, MII_BMCR, &bmcr);
|
|
|
|
b44_readphy(bp, MII_BMCR, &bmcr);
|
|
|
|
r = -EINVAL;
|
|
|
|
if (bmcr & BMCR_ANENABLE) {
|
|
|
|
b44_writephy(bp, MII_BMCR,
|
|
|
|
bmcr | BMCR_ANRESTART);
|
|
|
|
r = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
cmd->supported = (SUPPORTED_Autoneg);
|
|
|
|
cmd->supported |= (SUPPORTED_100baseT_Half |
|
|
|
|
SUPPORTED_100baseT_Full |
|
|
|
|
SUPPORTED_10baseT_Half |
|
|
|
|
SUPPORTED_10baseT_Full |
|
|
|
|
SUPPORTED_MII);
|
|
|
|
|
|
|
|
cmd->advertising = 0;
|
|
|
|
if (bp->flags & B44_FLAG_ADV_10HALF)
|
2005-10-04 13:25:17 -04:00
|
|
|
cmd->advertising |= ADVERTISED_10baseT_Half;
|
2005-04-16 18:20:36 -04:00
|
|
|
if (bp->flags & B44_FLAG_ADV_10FULL)
|
2005-10-04 13:25:17 -04:00
|
|
|
cmd->advertising |= ADVERTISED_10baseT_Full;
|
2005-04-16 18:20:36 -04:00
|
|
|
if (bp->flags & B44_FLAG_ADV_100HALF)
|
2005-10-04 13:25:17 -04:00
|
|
|
cmd->advertising |= ADVERTISED_100baseT_Half;
|
2005-04-16 18:20:36 -04:00
|
|
|
if (bp->flags & B44_FLAG_ADV_100FULL)
|
2005-10-04 13:25:17 -04:00
|
|
|
cmd->advertising |= ADVERTISED_100baseT_Full;
|
|
|
|
cmd->advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
|
2005-04-16 18:20:36 -04:00
|
|
|
cmd->speed = (bp->flags & B44_FLAG_100_BASE_T) ?
|
|
|
|
SPEED_100 : SPEED_10;
|
|
|
|
cmd->duplex = (bp->flags & B44_FLAG_FULL_DUPLEX) ?
|
|
|
|
DUPLEX_FULL : DUPLEX_HALF;
|
|
|
|
cmd->port = 0;
|
|
|
|
cmd->phy_address = bp->phy_addr;
|
|
|
|
cmd->transceiver = (bp->flags & B44_FLAG_INTERNAL_PHY) ?
|
|
|
|
XCVR_INTERNAL : XCVR_EXTERNAL;
|
|
|
|
cmd->autoneg = (bp->flags & B44_FLAG_FORCE_LINK) ?
|
|
|
|
AUTONEG_DISABLE : AUTONEG_ENABLE;
|
2006-06-20 18:34:15 -04:00
|
|
|
if (cmd->autoneg == AUTONEG_ENABLE)
|
|
|
|
cmd->advertising |= ADVERTISED_Autoneg;
|
|
|
|
if (!netif_running(dev)){
|
|
|
|
cmd->speed = 0;
|
|
|
|
cmd->duplex = 0xff;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
cmd->maxtxpkt = 0;
|
|
|
|
cmd->maxrxpkt = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
/* We do not support gigabit. */
|
|
|
|
if (cmd->autoneg == AUTONEG_ENABLE) {
|
|
|
|
if (cmd->advertising &
|
|
|
|
(ADVERTISED_1000baseT_Half |
|
|
|
|
ADVERTISED_1000baseT_Full))
|
|
|
|
return -EINVAL;
|
|
|
|
} else if ((cmd->speed != SPEED_100 &&
|
|
|
|
cmd->speed != SPEED_10) ||
|
|
|
|
(cmd->duplex != DUPLEX_HALF &&
|
|
|
|
cmd->duplex != DUPLEX_FULL)) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
if (cmd->autoneg == AUTONEG_ENABLE) {
|
2006-06-20 18:34:15 -04:00
|
|
|
bp->flags &= ~(B44_FLAG_FORCE_LINK |
|
|
|
|
B44_FLAG_100_BASE_T |
|
|
|
|
B44_FLAG_FULL_DUPLEX |
|
|
|
|
B44_FLAG_ADV_10HALF |
|
2005-04-16 18:20:36 -04:00
|
|
|
B44_FLAG_ADV_10FULL |
|
|
|
|
B44_FLAG_ADV_100HALF |
|
|
|
|
B44_FLAG_ADV_100FULL);
|
2006-06-20 18:34:15 -04:00
|
|
|
if (cmd->advertising == 0) {
|
|
|
|
bp->flags |= (B44_FLAG_ADV_10HALF |
|
|
|
|
B44_FLAG_ADV_10FULL |
|
|
|
|
B44_FLAG_ADV_100HALF |
|
|
|
|
B44_FLAG_ADV_100FULL);
|
|
|
|
} else {
|
|
|
|
if (cmd->advertising & ADVERTISED_10baseT_Half)
|
|
|
|
bp->flags |= B44_FLAG_ADV_10HALF;
|
|
|
|
if (cmd->advertising & ADVERTISED_10baseT_Full)
|
|
|
|
bp->flags |= B44_FLAG_ADV_10FULL;
|
|
|
|
if (cmd->advertising & ADVERTISED_100baseT_Half)
|
|
|
|
bp->flags |= B44_FLAG_ADV_100HALF;
|
|
|
|
if (cmd->advertising & ADVERTISED_100baseT_Full)
|
|
|
|
bp->flags |= B44_FLAG_ADV_100FULL;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
} else {
|
|
|
|
bp->flags |= B44_FLAG_FORCE_LINK;
|
2006-06-20 18:34:15 -04:00
|
|
|
bp->flags &= ~(B44_FLAG_100_BASE_T | B44_FLAG_FULL_DUPLEX);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (cmd->speed == SPEED_100)
|
|
|
|
bp->flags |= B44_FLAG_100_BASE_T;
|
|
|
|
if (cmd->duplex == DUPLEX_FULL)
|
|
|
|
bp->flags |= B44_FLAG_FULL_DUPLEX;
|
|
|
|
}
|
|
|
|
|
2006-06-20 18:34:15 -04:00
|
|
|
if (netif_running(dev))
|
|
|
|
b44_setup_phy(bp);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_get_ringparam(struct net_device *dev,
|
|
|
|
struct ethtool_ringparam *ering)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
ering->rx_max_pending = B44_RX_RING_SIZE - 1;
|
|
|
|
ering->rx_pending = bp->rx_pending;
|
|
|
|
|
|
|
|
/* XXX ethtool lacks a tx_max_pending, oops... */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_set_ringparam(struct net_device *dev,
|
|
|
|
struct ethtool_ringparam *ering)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
if ((ering->rx_pending > B44_RX_RING_SIZE - 1) ||
|
|
|
|
(ering->rx_mini_pending != 0) ||
|
|
|
|
(ering->rx_jumbo_pending != 0) ||
|
|
|
|
(ering->tx_pending > B44_TX_RING_SIZE - 1))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
bp->rx_pending = ering->rx_pending;
|
|
|
|
bp->tx_pending = ering->tx_pending;
|
|
|
|
|
|
|
|
b44_halt(bp);
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 18:20:36 -04:00
|
|
|
netif_wake_queue(bp->dev);
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2006-04-12 18:04:32 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_get_pauseparam(struct net_device *dev,
|
|
|
|
struct ethtool_pauseparam *epause)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
epause->autoneg =
|
|
|
|
(bp->flags & B44_FLAG_PAUSE_AUTO) != 0;
|
|
|
|
epause->rx_pause =
|
|
|
|
(bp->flags & B44_FLAG_RX_PAUSE) != 0;
|
|
|
|
epause->tx_pause =
|
|
|
|
(bp->flags & B44_FLAG_TX_PAUSE) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_set_pauseparam(struct net_device *dev,
|
|
|
|
struct ethtool_pauseparam *epause)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
if (epause->autoneg)
|
|
|
|
bp->flags |= B44_FLAG_PAUSE_AUTO;
|
|
|
|
else
|
|
|
|
bp->flags &= ~B44_FLAG_PAUSE_AUTO;
|
|
|
|
if (epause->rx_pause)
|
|
|
|
bp->flags |= B44_FLAG_RX_PAUSE;
|
|
|
|
else
|
|
|
|
bp->flags &= ~B44_FLAG_RX_PAUSE;
|
|
|
|
if (epause->tx_pause)
|
|
|
|
bp->flags |= B44_FLAG_TX_PAUSE;
|
|
|
|
else
|
|
|
|
bp->flags &= ~B44_FLAG_TX_PAUSE;
|
|
|
|
if (bp->flags & B44_FLAG_PAUSE_AUTO) {
|
|
|
|
b44_halt(bp);
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 18:20:36 -04:00
|
|
|
} else {
|
|
|
|
__b44_set_flow_ctrl(bp, bp->flags);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2006-04-12 18:04:32 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-06 19:51:34 -05:00
|
|
|
static void b44_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
|
|
|
{
|
|
|
|
switch(stringset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
memcpy(data, *b44_gstrings, sizeof(b44_gstrings));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-03 21:07:32 -04:00
|
|
|
static int b44_get_sset_count(struct net_device *dev, int sset)
|
2005-11-06 19:51:34 -05:00
|
|
|
{
|
2007-10-03 21:07:32 -04:00
|
|
|
switch (sset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
return ARRAY_SIZE(b44_gstrings);
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2005-11-06 19:51:34 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_get_ethtool_stats(struct net_device *dev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
u32 *val = &bp->hw_stats.tx_good_octets;
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_stats_update(bp);
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(b44_gstrings); i++)
|
|
|
|
*data++ = *val++;
|
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
}
|
|
|
|
|
2006-06-20 18:34:23 -04:00
|
|
|
static void b44_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
wol->supported = WAKE_MAGIC;
|
|
|
|
if (bp->flags & B44_FLAG_WOL_ENABLE)
|
|
|
|
wol->wolopts = WAKE_MAGIC;
|
|
|
|
else
|
|
|
|
wol->wolopts = 0;
|
|
|
|
memset(&wol->sopass, 0, sizeof(wol->sopass));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
if (wol->wolopts & WAKE_MAGIC)
|
|
|
|
bp->flags |= B44_FLAG_WOL_ENABLE;
|
|
|
|
else
|
|
|
|
bp->flags &= ~B44_FLAG_WOL_ENABLE;
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-13 14:30:00 -04:00
|
|
|
static const struct ethtool_ops b44_ethtool_ops = {
|
2005-04-16 18:20:36 -04:00
|
|
|
.get_drvinfo = b44_get_drvinfo,
|
|
|
|
.get_settings = b44_get_settings,
|
|
|
|
.set_settings = b44_set_settings,
|
|
|
|
.nway_reset = b44_nway_reset,
|
|
|
|
.get_link = ethtool_op_get_link,
|
2006-06-20 18:34:23 -04:00
|
|
|
.get_wol = b44_get_wol,
|
|
|
|
.set_wol = b44_set_wol,
|
2005-04-16 18:20:36 -04:00
|
|
|
.get_ringparam = b44_get_ringparam,
|
|
|
|
.set_ringparam = b44_set_ringparam,
|
|
|
|
.get_pauseparam = b44_get_pauseparam,
|
|
|
|
.set_pauseparam = b44_set_pauseparam,
|
|
|
|
.get_msglevel = b44_get_msglevel,
|
|
|
|
.set_msglevel = b44_set_msglevel,
|
2005-11-06 19:51:34 -05:00
|
|
|
.get_strings = b44_get_strings,
|
2007-10-03 21:07:32 -04:00
|
|
|
.get_sset_count = b44_get_sset_count,
|
2005-11-06 19:51:34 -05:00
|
|
|
.get_ethtool_stats = b44_get_ethtool_stats,
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
static int b44_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
|
|
|
|
{
|
|
|
|
struct mii_ioctl_data *data = if_mii(ifr);
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2005-11-30 16:32:13 -05:00
|
|
|
int err = -EINVAL;
|
|
|
|
|
|
|
|
if (!netif_running(dev))
|
|
|
|
goto out;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
err = generic_mii_ioctl(&bp->mii_if, data, cmd, NULL);
|
|
|
|
spin_unlock_irq(&bp->lock);
|
2005-11-30 16:32:13 -05:00
|
|
|
out:
|
2005-04-16 18:20:36 -04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __devinit b44_get_invariants(struct b44 *bp)
|
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
struct ssb_device *sdev = bp->sdev;
|
|
|
|
int err = 0;
|
|
|
|
u8 *addr;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
bp->dma_offset = ssb_dma_translation(sdev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
if (sdev->bus->bustype == SSB_BUSTYPE_SSB &&
|
|
|
|
instance > 1) {
|
2007-11-09 17:56:10 -05:00
|
|
|
addr = sdev->bus->sprom.et1mac;
|
|
|
|
bp->phy_addr = sdev->bus->sprom.et1phyaddr;
|
2007-09-19 17:20:30 -04:00
|
|
|
} else {
|
2007-11-09 17:56:10 -05:00
|
|
|
addr = sdev->bus->sprom.et0mac;
|
|
|
|
bp->phy_addr = sdev->bus->sprom.et0phyaddr;
|
2007-09-19 17:20:30 -04:00
|
|
|
}
|
2008-03-25 13:04:46 -04:00
|
|
|
/* Some ROMs have buggy PHY addresses with the high
|
|
|
|
* bits set (sign extension?). Truncate them to a
|
|
|
|
* valid PHY address. */
|
|
|
|
bp->phy_addr &= 0x1F;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
memcpy(bp->dev->dev_addr, addr, 6);
|
2006-03-28 17:57:38 -05:00
|
|
|
|
|
|
|
if (!is_valid_ether_addr(&bp->dev->dev_addr[0])){
|
|
|
|
printk(KERN_ERR PFX "Invalid MAC address found in EEPROM\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-09-12 10:48:55 -04:00
|
|
|
memcpy(bp->dev->perm_addr, bp->dev->dev_addr, bp->dev->addr_len);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
bp->imask = IMASK_DEF;
|
|
|
|
|
2006-04-12 18:04:32 -04:00
|
|
|
/* XXX - really required?
|
2005-04-16 18:20:36 -04:00
|
|
|
bp->flags |= B44_FLAG_BUGGY_TXPTR;
|
2007-09-19 17:20:30 -04:00
|
|
|
*/
|
2006-06-20 18:34:23 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
if (bp->sdev->id.revision >= 7)
|
|
|
|
bp->flags |= B44_FLAG_B0_ANDLATER;
|
2006-06-20 18:34:23 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static int __devinit b44_init_one(struct ssb_device *sdev,
|
|
|
|
const struct ssb_device_id *ent)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
static int b44_version_printed = 0;
|
|
|
|
struct net_device *dev;
|
|
|
|
struct b44 *bp;
|
2007-10-03 20:59:30 -04:00
|
|
|
int err;
|
|
|
|
DECLARE_MAC_BUF(mac);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
instance++;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (b44_version_printed++ == 0)
|
|
|
|
printk(KERN_INFO "%s", version);
|
|
|
|
|
|
|
|
|
|
|
|
dev = alloc_etherdev(sizeof(*bp));
|
|
|
|
if (!dev) {
|
2007-09-19 17:20:30 -04:00
|
|
|
dev_err(sdev->dev, "Etherdev alloc failed, aborting.\n");
|
2005-04-16 18:20:36 -04:00
|
|
|
err = -ENOMEM;
|
2007-09-19 17:20:30 -04:00
|
|
|
goto out;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
SET_NETDEV_DEV(dev, sdev->dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* No interesting netdevice features in this card... */
|
|
|
|
dev->features |= 0;
|
|
|
|
|
|
|
|
bp = netdev_priv(dev);
|
2007-09-19 17:20:30 -04:00
|
|
|
bp->sdev = sdev;
|
2005-04-16 18:20:36 -04:00
|
|
|
bp->dev = dev;
|
2005-11-06 19:50:46 -05:00
|
|
|
|
|
|
|
bp->msg_enable = netif_msg_init(b44_debug, B44_DEF_MSG_ENABLE);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
spin_lock_init(&bp->lock);
|
|
|
|
|
|
|
|
bp->rx_pending = B44_DEF_RX_RING_PENDING;
|
|
|
|
bp->tx_pending = B44_DEF_TX_RING_PENDING;
|
|
|
|
|
|
|
|
dev->open = b44_open;
|
|
|
|
dev->stop = b44_close;
|
|
|
|
dev->hard_start_xmit = b44_start_xmit;
|
|
|
|
dev->get_stats = b44_get_stats;
|
|
|
|
dev->set_multicast_list = b44_set_rx_mode;
|
|
|
|
dev->set_mac_address = b44_set_mac_addr;
|
|
|
|
dev->do_ioctl = b44_ioctl;
|
|
|
|
dev->tx_timeout = b44_tx_timeout;
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 19:41:36 -04:00
|
|
|
netif_napi_add(dev, &bp->napi, b44_poll, 64);
|
2005-04-16 18:20:36 -04:00
|
|
|
dev->watchdog_timeo = B44_TX_TIMEOUT;
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
dev->poll_controller = b44_poll_controller;
|
|
|
|
#endif
|
|
|
|
dev->change_mtu = b44_change_mtu;
|
2007-09-19 17:20:30 -04:00
|
|
|
dev->irq = sdev->irq;
|
2005-04-16 18:20:36 -04:00
|
|
|
SET_ETHTOOL_OPS(dev, &b44_ethtool_ops);
|
|
|
|
|
2006-01-21 00:13:17 -05:00
|
|
|
netif_carrier_off(dev);
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
err = ssb_bus_powerup(sdev->bus, 0);
|
|
|
|
if (err) {
|
|
|
|
dev_err(sdev->dev,
|
|
|
|
"Failed to powerup the bus\n");
|
|
|
|
goto err_out_free_dev;
|
|
|
|
}
|
|
|
|
err = ssb_dma_set_mask(sdev, DMA_30BIT_MASK);
|
|
|
|
if (err) {
|
|
|
|
dev_err(sdev->dev,
|
|
|
|
"Required 30BIT DMA mask unsupported by the system.\n");
|
|
|
|
goto err_out_powerdown;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
err = b44_get_invariants(bp);
|
|
|
|
if (err) {
|
2007-09-19 17:20:30 -04:00
|
|
|
dev_err(sdev->dev,
|
[netdrvr] Use dev_printk() when ethernet interface isn't available
For messages prior to register_netdev(), prefer dev_printk() because
that prints out both our driver name and our [PCI | whatever] bus id.
Updates: 8139{cp,too}, b44, bnx2, cassini, {eepro,epic}100, fealnx,
hamachi, ne2k-pci, ns83820, pci-skeleton, r8169.
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-06-27 10:47:51 -04:00
|
|
|
"Problem fetching invariants of chip, aborting.\n");
|
2007-09-19 17:20:30 -04:00
|
|
|
goto err_out_powerdown;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
bp->mii_if.dev = dev;
|
|
|
|
bp->mii_if.mdio_read = b44_mii_read;
|
|
|
|
bp->mii_if.mdio_write = b44_mii_write;
|
|
|
|
bp->mii_if.phy_id = bp->phy_addr;
|
|
|
|
bp->mii_if.phy_id_mask = 0x1f;
|
|
|
|
bp->mii_if.reg_num_mask = 0x1f;
|
|
|
|
|
|
|
|
/* By default, advertise all speed/duplex settings. */
|
|
|
|
bp->flags |= (B44_FLAG_ADV_10HALF | B44_FLAG_ADV_10FULL |
|
|
|
|
B44_FLAG_ADV_100HALF | B44_FLAG_ADV_100FULL);
|
|
|
|
|
|
|
|
/* By default, auto-negotiate PAUSE. */
|
|
|
|
bp->flags |= B44_FLAG_PAUSE_AUTO;
|
|
|
|
|
|
|
|
err = register_netdev(dev);
|
|
|
|
if (err) {
|
2007-09-19 17:20:30 -04:00
|
|
|
dev_err(sdev->dev, "Cannot register net device, aborting.\n");
|
|
|
|
goto err_out_powerdown;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
ssb_set_drvdata(sdev, dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-04-12 18:04:32 -04:00
|
|
|
/* Chip reset provides power to the b44 MAC & PCI cores, which
|
2006-03-29 17:12:05 -05:00
|
|
|
* is necessary for MAC register access.
|
2006-04-12 18:04:32 -04:00
|
|
|
*/
|
2007-12-31 19:17:54 -05:00
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_FULL);
|
2006-03-29 17:12:05 -05:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
printk(KERN_INFO "%s: Broadcom 44xx/47xx 10/100BaseT Ethernet %s\n",
|
2007-10-03 20:59:30 -04:00
|
|
|
dev->name, print_mac(mac, dev->dev_addr));
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
err_out_powerdown:
|
|
|
|
ssb_bus_may_powerdown(sdev->bus);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
err_out_free_dev:
|
|
|
|
free_netdev(dev);
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
out:
|
2005-04-16 18:20:36 -04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static void __devexit b44_remove_one(struct ssb_device *sdev)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
struct net_device *dev = ssb_get_drvdata(sdev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-06 19:50:46 -05:00
|
|
|
unregister_netdev(dev);
|
2007-09-19 17:20:30 -04:00
|
|
|
ssb_bus_may_powerdown(sdev->bus);
|
2005-11-06 19:50:46 -05:00
|
|
|
free_netdev(dev);
|
2007-12-31 19:17:54 -05:00
|
|
|
ssb_pcihost_set_power_state(sdev, PCI_D3hot);
|
2007-09-19 17:20:30 -04:00
|
|
|
ssb_set_drvdata(sdev, NULL);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static int b44_suspend(struct ssb_device *sdev, pm_message_t state)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
struct net_device *dev = ssb_get_drvdata(sdev);
|
2005-04-16 18:20:36 -04:00
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
if (!netif_running(dev))
|
|
|
|
return 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
del_timer_sync(&bp->timer);
|
|
|
|
|
2006-04-12 18:04:32 -04:00
|
|
|
spin_lock_irq(&bp->lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
b44_halt(bp);
|
2006-04-12 18:04:32 -04:00
|
|
|
netif_carrier_off(bp->dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
netif_device_detach(bp->dev);
|
|
|
|
b44_free_rings(bp);
|
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
2005-10-28 18:14:47 -04:00
|
|
|
|
|
|
|
free_irq(dev->irq, dev);
|
2006-06-20 18:34:23 -04:00
|
|
|
if (bp->flags & B44_FLAG_WOL_ENABLE) {
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_PARTIAL_RESET);
|
2006-06-20 18:34:23 -04:00
|
|
|
b44_setup_wol(bp);
|
|
|
|
}
|
2007-09-19 17:20:30 -04:00
|
|
|
|
2007-12-31 19:17:54 -05:00
|
|
|
ssb_pcihost_set_power_state(sdev, PCI_D3hot);
|
2005-04-16 18:20:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static int b44_resume(struct ssb_device *sdev)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
struct net_device *dev = ssb_get_drvdata(sdev);
|
2005-04-16 18:20:36 -04:00
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2007-01-27 03:00:03 -05:00
|
|
|
int rc = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
rc = ssb_bus_powerup(sdev->bus, 0);
|
2007-01-27 03:00:03 -05:00
|
|
|
if (rc) {
|
2007-09-19 17:20:30 -04:00
|
|
|
dev_err(sdev->dev,
|
|
|
|
"Failed to powerup the bus\n");
|
2007-01-27 03:00:03 -05:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!netif_running(dev))
|
|
|
|
return 0;
|
|
|
|
|
2007-01-27 03:00:03 -05:00
|
|
|
rc = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
|
|
|
|
if (rc) {
|
2005-10-28 18:14:47 -04:00
|
|
|
printk(KERN_ERR PFX "%s: request_irq failed\n", dev->name);
|
2007-01-27 03:00:03 -05:00
|
|
|
return rc;
|
|
|
|
}
|
2005-10-28 18:14:47 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 02:59:57 -05:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 18:20:36 -04:00
|
|
|
netif_device_attach(bp->dev);
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2005-11-30 16:30:23 -05:00
|
|
|
netif_wake_queue(dev);
|
2007-06-04 16:25:37 -04:00
|
|
|
|
|
|
|
mod_timer(&bp->timer, jiffies + 1);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static struct ssb_driver b44_ssb_driver = {
|
2005-04-16 18:20:36 -04:00
|
|
|
.name = DRV_MODULE_NAME,
|
2007-09-19 17:20:30 -04:00
|
|
|
.id_table = b44_ssb_tbl,
|
2005-04-16 18:20:36 -04:00
|
|
|
.probe = b44_init_one,
|
|
|
|
.remove = __devexit_p(b44_remove_one),
|
2007-09-19 17:20:30 -04:00
|
|
|
.suspend = b44_suspend,
|
|
|
|
.resume = b44_resume,
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
static inline int b44_pci_init(void)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
#ifdef CONFIG_B44_PCI
|
|
|
|
err = ssb_pcihost_register(&b44_pci_driver);
|
|
|
|
#endif
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void b44_pci_exit(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_B44_PCI
|
|
|
|
ssb_pcihost_unregister(&b44_pci_driver);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static int __init b44_init(void)
|
|
|
|
{
|
2005-10-18 21:30:59 -04:00
|
|
|
unsigned int dma_desc_align_size = dma_get_cache_alignment();
|
2007-09-19 17:20:30 -04:00
|
|
|
int err;
|
2005-10-18 21:30:59 -04:00
|
|
|
|
|
|
|
/* Setup paramaters for syncing RX/TX DMA descriptors */
|
|
|
|
dma_desc_align_mask = ~(dma_desc_align_size - 1);
|
2006-01-17 12:53:56 -05:00
|
|
|
dma_desc_sync_size = max_t(unsigned int, dma_desc_align_size, sizeof(struct dma_desc));
|
2005-10-18 21:30:59 -04:00
|
|
|
|
2007-09-19 17:20:30 -04:00
|
|
|
err = b44_pci_init();
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
err = ssb_driver_register(&b44_ssb_driver);
|
|
|
|
if (err)
|
|
|
|
b44_pci_exit();
|
|
|
|
return err;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit b44_cleanup(void)
|
|
|
|
{
|
2007-09-19 17:20:30 -04:00
|
|
|
ssb_driver_unregister(&b44_ssb_driver);
|
|
|
|
b44_pci_exit();
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(b44_init);
|
|
|
|
module_exit(b44_cleanup);
|
|
|
|
|