2007-09-19 21:20:30 +00:00
|
|
|
/* b44.c: Broadcom 44xx/47xx Fast Ethernet device driver.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Copyright (C) 2002 David S. Miller (davem@redhat.com)
|
2007-09-19 21:20:30 +00: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 19:05:40 +00:00
|
|
|
* Copyright (C) 2006 Broadcom Corporation.
|
2011-07-04 18:50:05 +00:00
|
|
|
* Copyright (C) 2007 Michael Buesch <m@bues.ch>
|
2013-12-20 01:16:10 +00:00
|
|
|
* Copyright (C) 2013 Hauke Mehrtens <hauke@hauke-m.de>
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Distribute under GPL.
|
|
|
|
*/
|
|
|
|
|
2010-02-17 15:01:50 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#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 20:25:39 +00:00
|
|
|
#include <linux/if_vlan.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/init.h>
|
2011-06-06 10:43:46 +00:00
|
|
|
#include <linux/interrupt.h>
|
2005-10-28 20:38:02 +00:00
|
|
|
#include <linux/dma-mapping.h>
|
2007-09-19 21:20:30 +00:00
|
|
|
#include <linux/ssb/ssb.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2013-12-20 01:16:10 +00:00
|
|
|
#include <linux/phy.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "b44.h"
|
|
|
|
|
|
|
|
#define DRV_MODULE_NAME "b44"
|
2007-09-19 21:20:30 +00:00
|
|
|
#define DRV_MODULE_VERSION "2.0"
|
2011-07-05 07:43:46 +00:00
|
|
|
#define DRV_DESCRIPTION "Broadcom 44xx/47xx 10/100 PCI ethernet driver"
|
2005-04-16 22:20:36 +00: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 */
|
2016-10-17 19:54:04 +00:00
|
|
|
#define B44_MIN_MTU ETH_ZLEN
|
|
|
|
#define B44_MAX_MTU ETH_DATA_LEN
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#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))
|
|
|
|
|
2009-01-09 02:39:57 +00:00
|
|
|
#define RX_PKT_OFFSET (RX_HEADER_LEN + 2)
|
|
|
|
#define RX_PKT_BUF_SZ (1536 + RX_PKT_OFFSET)
|
2005-04-16 22:20:36 +00: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 22:34:36 +00: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
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
MODULE_AUTHOR("Felix Fietkau, Florian Schirmer, Pekka Pietikainen, David S. Miller");
|
2011-07-05 07:43:46 +00:00
|
|
|
MODULE_DESCRIPTION(DRV_DESCRIPTION);
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
#ifdef CONFIG_B44_PCI
|
2014-08-08 13:56:03 +00:00
|
|
|
static const struct pci_device_id b44_pci_tbl[] = {
|
2007-09-19 21:20:30 +00:00
|
|
|
{ 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 22:20:36 +00:00
|
|
|
MODULE_DEVICE_TABLE(pci, b44_pci_tbl);
|
|
|
|
|
2007-09-19 21:20:30 +00: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),
|
2015-02-10 21:19:24 +00:00
|
|
|
{},
|
2007-09-19 21:20:30 +00:00
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(ssb, b44_ssb_tbl);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void b44_halt(struct b44 *);
|
|
|
|
static void b44_init_rings(struct b44 *);
|
2007-01-27 07:59:57 +00:00
|
|
|
|
|
|
|
#define B44_FULL_RESET 1
|
|
|
|
#define B44_FULL_RESET_SKIP_PHY 2
|
|
|
|
#define B44_PARTIAL_RESET 3
|
2008-01-01 00:17:54 +00:00
|
|
|
#define B44_CHIP_RESET_FULL 4
|
|
|
|
#define B44_CHIP_RESET_PARTIAL 5
|
2007-01-27 07:59:57 +00:00
|
|
|
|
2006-06-20 22:34:26 +00:00
|
|
|
static void b44_init_hw(struct b44 *, int);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-19 01:30:59 +00:00
|
|
|
static int dma_desc_sync_size;
|
2007-09-19 21:20:30 +00:00
|
|
|
static int instance;
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2005-11-07 00:51:34 +00:00
|
|
|
static const char b44_gstrings[][ETH_GSTRING_LEN] = {
|
|
|
|
#define _B44(x...) # x,
|
|
|
|
B44_STAT_REG_DECLARE
|
|
|
|
#undef _B44
|
|
|
|
};
|
|
|
|
|
2007-09-19 21:20:30 +00: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-19 01:30:59 +00:00
|
|
|
{
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_sync_single_for_device(sdev->dma_dev, dma_base + offset,
|
|
|
|
dma_desc_sync_size, dir);
|
2005-10-19 01:30:59 +00:00
|
|
|
}
|
|
|
|
|
2007-09-19 21:20:30 +00: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-19 01:30:59 +00:00
|
|
|
{
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_sync_single_for_cpu(sdev->dma_dev, dma_base + offset,
|
|
|
|
dma_desc_sync_size, dir);
|
2005-10-19 01:30:59 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline unsigned long br32(const struct b44 *bp, unsigned long reg)
|
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
return ssb_read32(bp->sdev, reg);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-04-12 22:04:32 +00:00
|
|
|
static inline void bw32(const struct b44 *bp,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long reg, unsigned long val)
|
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
ssb_write32(bp->sdev, reg, val);
|
2005-04-16 22:20:36 +00: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) {
|
2010-02-12 10:11:54 +00:00
|
|
|
if (net_ratelimit())
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_err(bp->dev, "BUG! Timeout waiting for bit %08x of register %lx to %s\n",
|
|
|
|
bit, reg, clear ? "clear" : "set");
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
static inline void __b44_cam_read(struct b44 *bp, unsigned char *data, int index)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
bw32(bp, B44_CAM_CTRL, (CAM_CTRL_READ |
|
|
|
|
(index << CAM_CTRL_INDEX_SHIFT)));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
val = br32(bp, B44_CAM_DATA_LO);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
data[2] = (val >> 24) & 0xFF;
|
|
|
|
data[3] = (val >> 16) & 0xFF;
|
|
|
|
data[4] = (val >> 8) & 0xFF;
|
|
|
|
data[5] = (val >> 0) & 0xFF;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
val = br32(bp, B44_CAM_DATA_HI);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
data[0] = (val >> 8) & 0xFF;
|
|
|
|
data[1] = (val >> 0) & 0xFF;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
static inline void __b44_cam_write(struct b44 *bp, unsigned char *data, int index)
|
2005-04-16 22:20:36 +00: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 22:04:32 +00:00
|
|
|
val = (CAM_DATA_HI_VALID |
|
2005-04-16 22:20:36 +00: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 22:04:32 +00:00
|
|
|
b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
static int __b44_readphy(struct b44 *bp, int phy_addr, int reg, u32 *val)
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
(phy_addr << MDIO_DATA_PMD_SHIFT) |
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
static int __b44_writephy(struct b44 *bp, int phy_addr, int reg, u32 val)
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
(phy_addr << MDIO_DATA_PMD_SHIFT) |
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
static inline int b44_readphy(struct b44 *bp, int reg, u32 *val)
|
|
|
|
{
|
2013-12-20 01:16:06 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
2007-09-19 21:20:30 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return __b44_readphy(bp, bp->phy_addr, reg, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int b44_writephy(struct b44 *bp, int reg, u32 val)
|
|
|
|
{
|
2013-12-20 01:16:06 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
2007-09-19 21:20:30 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return __b44_writephy(bp, bp->phy_addr, reg, val);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* miilib interface */
|
2013-12-20 01:16:09 +00:00
|
|
|
static int b44_mdio_read_mii(struct net_device *dev, int phy_id, int location)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2007-09-19 21:20:30 +00:00
|
|
|
int rc = __b44_readphy(bp, phy_id, location, &val);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (rc)
|
|
|
|
return 0xffffffff;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2013-12-20 01:16:09 +00:00
|
|
|
static void b44_mdio_write_mii(struct net_device *dev, int phy_id, int location,
|
|
|
|
int val)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2007-09-19 21:20:30 +00:00
|
|
|
__b44_writephy(bp, phy_id, location, val);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-12-20 01:16:10 +00:00
|
|
|
static int b44_mdio_read_phylib(struct mii_bus *bus, int phy_id, int location)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
struct b44 *bp = bus->priv;
|
|
|
|
int rc = __b44_readphy(bp, phy_id, location, &val);
|
|
|
|
if (rc)
|
|
|
|
return 0xffffffff;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_mdio_write_phylib(struct mii_bus *bus, int phy_id, int location,
|
|
|
|
u16 val)
|
|
|
|
{
|
|
|
|
struct b44 *bp = bus->priv;
|
|
|
|
return __b44_writephy(bp, phy_id, location, val);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int b44_phy_reset(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
int err;
|
|
|
|
|
2013-12-20 01:16:06 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
2007-09-19 21:20:30 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00: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) {
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_err(bp->dev, "PHY Reset would not complete\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
err = -ENODEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-20 10:55:25 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 22:04:32 +00:00
|
|
|
u32 pause_enab = 0;
|
2006-04-10 19:02:21 +00:00
|
|
|
|
|
|
|
/* The driver supports only rx pause by default because
|
2006-04-12 22:04:32 +00:00
|
|
|
the b44 mac tx pause mechanism generates excessive
|
|
|
|
pause frames.
|
2006-04-10 19:02:21 +00:00
|
|
|
Use ethtool to turn on b44 tx pause if necessary.
|
|
|
|
*/
|
|
|
|
if ((local & ADVERTISE_PAUSE_CAP) &&
|
2006-04-12 22:04:32 +00:00
|
|
|
(local & ADVERTISE_PAUSE_ASYM)){
|
2006-04-10 19:02:21 +00:00
|
|
|
if ((remote & LPA_PAUSE_ASYM) &&
|
|
|
|
!(remote & LPA_PAUSE_CAP))
|
|
|
|
pause_enab |= B44_FLAG_RX_PAUSE;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
__b44_set_flow_ctrl(bp, pause_enab);
|
|
|
|
}
|
|
|
|
|
2010-11-27 06:47:43 +00:00
|
|
|
#ifdef CONFIG_BCM47XX
|
2014-12-01 06:58:18 +00:00
|
|
|
#include <linux/bcm47xx_nvram.h>
|
2007-09-19 21:20:30 +00:00
|
|
|
static void b44_wap54g10_workaround(struct b44 *bp)
|
|
|
|
{
|
2010-11-27 06:47:43 +00:00
|
|
|
char buf[20];
|
2007-09-19 21:20:30 +00:00
|
|
|
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"
|
|
|
|
*/
|
2012-12-26 19:51:14 +00:00
|
|
|
if (bcm47xx_nvram_getenv("boardnum", buf, sizeof(buf)) < 0)
|
2007-09-19 21:20:30 +00:00
|
|
|
return;
|
2010-11-27 06:47:43 +00:00
|
|
|
if (simple_strtoul(buf, NULL, 0) == 2) {
|
2007-09-19 21:20:30 +00:00
|
|
|
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:
|
2014-09-10 03:27:44 +00:00
|
|
|
pr_warn("PHY: cannot reset MII transceiver isolate bit\n");
|
2007-09-19 21:20:30 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void b44_wap54g10_workaround(struct b44 *bp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int b44_setup_phy(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
int err;
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
b44_wap54g10_workaround(bp);
|
|
|
|
|
2013-12-20 01:16:06 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
2007-09-19 21:20:30 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00: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;
|
2012-07-17 17:46:01 +00:00
|
|
|
u64 *val;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
val = &bp->hw_stats.tx_good_octets;
|
2012-07-17 17:46:01 +00:00
|
|
|
u64_stats_update_begin(&bp->hw_stats.syncp);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for (reg = B44_TX_GOOD_O; reg <= B44_TX_PAUSE; reg += 4UL) {
|
|
|
|
*val++ += br32(bp, reg);
|
|
|
|
}
|
2005-11-07 00:51:34 +00:00
|
|
|
|
|
|
|
/* Pad */
|
|
|
|
reg += 8*4UL;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for (reg = B44_RX_GOOD_O; reg <= B44_RX_NPAUSE; reg += 4UL) {
|
|
|
|
*val++ += br32(bp, reg);
|
|
|
|
}
|
2012-07-17 17:46:01 +00:00
|
|
|
|
|
|
|
u64_stats_update_end(&bp->hw_stats.syncp);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_link_report(struct b44 *bp)
|
|
|
|
{
|
|
|
|
if (!netif_carrier_ok(bp->dev)) {
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_info(bp->dev, "Link is down\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_info(bp->dev, "Link is up at %d Mbps, %s duplex\n",
|
|
|
|
(bp->flags & B44_FLAG_100_BASE_T) ? 100 : 10,
|
|
|
|
(bp->flags & B44_FLAG_FULL_DUPLEX) ? "full" : "half");
|
|
|
|
|
|
|
|
netdev_info(bp->dev, "Flow control is %s for TX and %s for RX\n",
|
|
|
|
(bp->flags & B44_FLAG_TX_PAUSE) ? "on" : "off",
|
|
|
|
(bp->flags & B44_FLAG_RX_PAUSE) ? "on" : "off");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_check_phy(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 bmsr, aux;
|
|
|
|
|
2013-12-20 01:16:06 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY) {
|
2007-09-19 21:20:30 +00:00
|
|
|
bp->flags |= B44_FLAG_100_BASE_T;
|
|
|
|
if (!netif_carrier_ok(bp->dev)) {
|
|
|
|
u32 val = br32(bp, B44_TX_CTRL);
|
2013-12-20 01:16:10 +00:00
|
|
|
if (bp->flags & B44_FLAG_FULL_DUPLEX)
|
|
|
|
val |= TX_CTRL_DUPLEX;
|
|
|
|
else
|
|
|
|
val &= ~TX_CTRL_DUPLEX;
|
2007-09-19 21:20:30 +00:00
|
|
|
bw32(bp, B44_TX_CTRL, val);
|
|
|
|
netif_carrier_on(bp->dev);
|
|
|
|
b44_link_report(bp);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00: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)
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_warn(bp->dev, "Remote fault detected in PHY\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bmsr & BMSR_JCD)
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_warn(bp->dev, "Jabber detected in PHY\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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 20:25:37 +00:00
|
|
|
mod_timer(&bp->timer, round_jiffies(jiffies + HZ));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_tx(struct b44 *bp)
|
|
|
|
{
|
|
|
|
u32 cur, cons;
|
2013-09-28 21:22:18 +00:00
|
|
|
unsigned bytes_compl = 0, pkts_compl = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
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 11:52:48 +00:00
|
|
|
BUG_ON(skb == NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_unmap_single(bp->sdev->dma_dev,
|
|
|
|
rp->mapping,
|
|
|
|
skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
rp->skb = NULL;
|
2013-09-28 21:22:18 +00:00
|
|
|
|
|
|
|
bytes_compl += skb->len;
|
|
|
|
pkts_compl++;
|
|
|
|
|
2011-11-23 21:40:31 +00:00
|
|
|
dev_kfree_skb_irq(skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-09-28 21:22:18 +00:00
|
|
|
netdev_completed_queue(bp->dev, pkts_compl, bytes_compl);
|
2005-04-16 22:20:36 +00:00
|
|
|
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 20:25:40 +00:00
|
|
|
skb = netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (skb == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
mapping = dma_map_single(bp->sdev->dma_dev, skb->data,
|
|
|
|
RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Hardware bug work-around, the chip is unable to do PCI DMA
|
|
|
|
to/from anything above 1GB :-( */
|
2010-06-04 02:37:40 +00:00
|
|
|
if (dma_mapping_error(bp->sdev->dma_dev, mapping) ||
|
2009-04-07 02:01:17 +00:00
|
|
|
mapping + RX_PKT_BUF_SZ > DMA_BIT_MASK(30)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Sigh... */
|
2010-06-04 02:37:40 +00:00
|
|
|
if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
|
|
|
|
dma_unmap_single(bp->sdev->dma_dev, mapping,
|
2008-06-20 09:50:29 +00:00
|
|
|
RX_PKT_BUF_SZ, DMA_FROM_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
2012-07-02 08:36:12 +00:00
|
|
|
skb = alloc_skb(RX_PKT_BUF_SZ, GFP_ATOMIC | GFP_DMA);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (skb == NULL)
|
|
|
|
return -ENOMEM;
|
2010-06-04 02:37:40 +00:00
|
|
|
mapping = dma_map_single(bp->sdev->dma_dev, skb->data,
|
|
|
|
RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
if (dma_mapping_error(bp->sdev->dma_dev, mapping) ||
|
|
|
|
mapping + RX_PKT_BUF_SZ > DMA_BIT_MASK(30)) {
|
|
|
|
if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
|
|
|
|
dma_unmap_single(bp->sdev->dma_dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2009-01-15 23:29:35 +00:00
|
|
|
bp->force_copybreak = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-06-04 20:25:39 +00:00
|
|
|
rh = (struct rx_header *) skb->data;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
rh->len = 0;
|
|
|
|
rh->flags = 0;
|
|
|
|
|
|
|
|
map->skb = skb;
|
2007-09-19 21:20:30 +00:00
|
|
|
map->mapping = mapping;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (src_map != NULL)
|
|
|
|
src_map->skb = NULL;
|
|
|
|
|
2009-01-09 02:39:57 +00:00
|
|
|
ctrl = (DESC_CTRL_LEN & RX_PKT_BUF_SZ);
|
2005-04-16 22:20:36 +00: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);
|
2009-01-09 02:39:57 +00:00
|
|
|
dp->addr = cpu_to_le32((u32) mapping + bp->dma_offset);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-19 01:30:59 +00:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2007-09-19 21:20:30 +00:00
|
|
|
b44_sync_dma_desc_for_device(bp->sdev, bp->rx_ring_dma,
|
2009-04-03 00:01:30 +00:00
|
|
|
dest_idx * sizeof(*dp),
|
2007-09-19 21:20:30 +00:00
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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 20:36:54 +00:00
|
|
|
__le32 ctrl;
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
dest_map->mapping = src_map->mapping;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-19 01:30:59 +00:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2007-09-19 21:20:30 +00:00
|
|
|
b44_sync_dma_desc_for_cpu(bp->sdev, bp->rx_ring_dma,
|
2009-04-03 00:01:30 +00:00
|
|
|
src_idx * sizeof(*src_desc),
|
2007-09-19 21:20:30 +00:00
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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-19 01:30:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
src_map->skb = NULL;
|
|
|
|
|
2005-10-19 01:30:59 +00:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2007-09-19 21:20:30 +00:00
|
|
|
b44_sync_dma_desc_for_device(bp->sdev, bp->rx_ring_dma,
|
2009-04-03 00:01:30 +00:00
|
|
|
dest_idx * sizeof(*dest_desc),
|
2007-09-19 21:20:30 +00:00
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_sync_single_for_device(bp->sdev->dma_dev, dest_map->mapping,
|
|
|
|
RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
dma_addr_t map = rp->mapping;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct rx_header *rh;
|
|
|
|
u16 len;
|
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_sync_single_for_cpu(bp->sdev->dma_dev, map,
|
|
|
|
RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
rh = (struct rx_header *) skb->data;
|
2007-01-29 20:36:54 +00:00
|
|
|
len = le16_to_cpu(rh->len);
|
2007-06-04 20:25:39 +00:00
|
|
|
if ((len > (RX_PKT_BUF_SZ - RX_PKT_OFFSET)) ||
|
2005-04-16 22:20:36 +00:00
|
|
|
(rh->flags & cpu_to_le16(RX_FLAG_ERRORS))) {
|
|
|
|
drop_it:
|
|
|
|
b44_recycle_rx(bp, cons, bp->rx_prod);
|
|
|
|
drop_it_no_recycle:
|
2009-05-27 10:34:50 +00:00
|
|
|
bp->dev->stats.rx_dropped++;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto next_pkt;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
udelay(2);
|
|
|
|
barrier();
|
2007-01-29 20:36:54 +00:00
|
|
|
len = le16_to_cpu(rh->len);
|
2005-04-16 22:20:36 +00:00
|
|
|
} while (len == 0 && i++ < 5);
|
|
|
|
if (len == 0)
|
|
|
|
goto drop_it;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Omit CRC. */
|
|
|
|
len -= 4;
|
|
|
|
|
2009-01-15 23:29:35 +00:00
|
|
|
if (!bp->force_copybreak && len > RX_COPY_THRESHOLD) {
|
2005-04-16 22:20:36 +00:00
|
|
|
int skb_size;
|
|
|
|
skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod);
|
|
|
|
if (skb_size < 0)
|
|
|
|
goto drop_it;
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_unmap_single(bp->sdev->dma_dev, map,
|
|
|
|
skb_size, DMA_FROM_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Leave out rx_header */
|
2009-01-09 02:39:57 +00:00
|
|
|
skb_put(skb, len + RX_PKT_OFFSET);
|
|
|
|
skb_pull(skb, RX_PKT_OFFSET);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
struct sk_buff *copy_skb;
|
|
|
|
|
|
|
|
b44_recycle_rx(bp, cons, bp->rx_prod);
|
2014-12-10 03:41:17 +00:00
|
|
|
copy_skb = napi_alloc_skb(&bp->napi, len);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (copy_skb == NULL)
|
|
|
|
goto drop_it_no_recycle;
|
|
|
|
|
|
|
|
skb_put(copy_skb, len);
|
|
|
|
/* DMA sync done above, copy just the actual packet */
|
2007-06-04 20:25:39 +00:00
|
|
|
skb_copy_from_linear_data_offset(skb, RX_PKT_OFFSET,
|
2007-03-27 21:55:52 +00:00
|
|
|
copy_skb->data, len);
|
2005-04-16 22:20:36 +00:00
|
|
|
skb = copy_skb;
|
|
|
|
}
|
2010-09-02 20:07:41 +00:00
|
|
|
skb_checksum_none_assert(skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
skb->protocol = eth_type_trans(skb, bp->dev);
|
|
|
|
netif_receive_skb(skb);
|
|
|
|
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 23:41:36 +00:00
|
|
|
static int b44_poll(struct napi_struct *napi, int budget)
|
2005-04-16 22:20:36 +00: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 23:41:36 +00:00
|
|
|
struct b44 *bp = container_of(napi, struct b44, napi);
|
|
|
|
int work_done;
|
2009-09-16 16:10:47 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-09-16 16:10:47 +00:00
|
|
|
spin_lock_irqsave(&bp->lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (bp->istat & (ISTAT_TX | ISTAT_TO)) {
|
|
|
|
/* spin_lock(&bp->tx_lock); */
|
|
|
|
b44_tx(bp);
|
|
|
|
/* spin_unlock(&bp->tx_lock); */
|
|
|
|
}
|
2010-09-04 14:17:59 +00:00
|
|
|
if (bp->istat & ISTAT_RFO) { /* fast recovery, in ~20msec */
|
|
|
|
bp->istat &= ~ISTAT_RFO;
|
|
|
|
b44_disable_ints(bp);
|
|
|
|
ssb_device_enable(bp->sdev, 0); /* resets ISTAT_RFO */
|
|
|
|
b44_init_rings(bp);
|
|
|
|
b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
|
|
|
|
netif_wake_queue(bp->dev);
|
|
|
|
}
|
|
|
|
|
2009-09-16 16:10:47 +00:00
|
|
|
spin_unlock_irqrestore(&bp->lock, flags);
|
2005-04-16 22:20:36 +00: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 23:41:36 +00:00
|
|
|
work_done = 0;
|
|
|
|
if (bp->istat & ISTAT_RX)
|
|
|
|
work_done += b44_rx(bp, budget);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (bp->istat & ISTAT_ERRORS) {
|
2006-12-17 22:03:15 +00:00
|
|
|
spin_lock_irqsave(&bp->lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
b44_halt(bp);
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
|
2005-04-16 22:20:36 +00:00
|
|
|
netif_wake_queue(bp->dev);
|
2006-12-17 22:03:15 +00: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 23:41:36 +00:00
|
|
|
work_done = 0;
|
2005-04-16 22:20:36 +00: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 23:41:36 +00:00
|
|
|
if (work_done < budget) {
|
2017-01-30 16:22:01 +00:00
|
|
|
napi_complete_done(napi, work_done);
|
2005-04-16 22:20:36 +00: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 23:41:36 +00:00
|
|
|
return work_done;
|
2005-04-16 22:20:36 +00: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 13:55:46 +00:00
|
|
|
static irqreturn_t b44_interrupt(int irq, void *dev_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *dev = dev_id;
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
u32 istat, imask;
|
|
|
|
int handled = 0;
|
|
|
|
|
2005-11-07 00:52:06 +00:00
|
|
|
spin_lock(&bp->lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
istat = br32(bp, B44_ISTAT);
|
|
|
|
imask = br32(bp, B44_IMASK);
|
|
|
|
|
2006-11-06 22:17:20 +00: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 22:20:36 +00:00
|
|
|
*/
|
|
|
|
istat &= imask;
|
|
|
|
if (istat) {
|
|
|
|
handled = 1;
|
2005-11-08 22:37:12 +00:00
|
|
|
|
|
|
|
if (unlikely(!netif_running(dev))) {
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_info(dev, "late interrupt\n");
|
2005-11-08 22:37:12 +00:00
|
|
|
goto irq_ack;
|
|
|
|
}
|
|
|
|
|
2009-01-20 00:43:59 +00:00
|
|
|
if (napi_schedule_prep(&bp->napi)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* NOTE: These writes are posted by the readback of
|
|
|
|
* the ISTAT register below.
|
|
|
|
*/
|
|
|
|
bp->istat = istat;
|
|
|
|
__b44_disable_ints(bp);
|
2009-01-20 00:43:59 +00:00
|
|
|
__napi_schedule(&bp->napi);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:12 +00:00
|
|
|
irq_ack:
|
2005-04-16 22:20:36 +00:00
|
|
|
bw32(bp, B44_ISTAT, istat);
|
|
|
|
br32(bp, B44_ISTAT);
|
|
|
|
}
|
2005-11-07 00:52:06 +00:00
|
|
|
spin_unlock(&bp->lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
return IRQ_RETVAL(handled);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_tx_timeout(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_err(dev, "transmit timed out, resetting\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_halt(bp);
|
|
|
|
b44_init_rings(bp);
|
2007-01-27 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
|
|
|
|
|
|
|
netif_wake_queue(dev);
|
|
|
|
}
|
|
|
|
|
2009-08-31 19:50:58 +00:00
|
|
|
static netdev_tx_t b44_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2005-11-07 00:50:03 +00:00
|
|
|
int rc = NETDEV_TX_OK;
|
2005-04-16 22:20:36 +00:00
|
|
|
dma_addr_t mapping;
|
|
|
|
u32 len, entry, ctrl;
|
2009-08-13 19:12:31 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
len = skb->len;
|
2009-08-13 19:12:31 +00:00
|
|
|
spin_lock_irqsave(&bp->lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* This is a hard error, log it. */
|
|
|
|
if (unlikely(TX_BUFFS_AVAIL(bp) < 1)) {
|
|
|
|
netif_stop_queue(dev);
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
|
2005-11-07 00:50:03 +00:00
|
|
|
goto err_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
mapping = dma_map_single(bp->sdev->dma_dev, skb->data, len, DMA_TO_DEVICE);
|
|
|
|
if (dma_mapping_error(bp->sdev->dma_dev, mapping) || mapping + len > DMA_BIT_MASK(30)) {
|
2007-06-04 20:25:38 +00:00
|
|
|
struct sk_buff *bounce_skb;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Chip can't handle DMA to/from >1GB, use bounce buffer */
|
2010-06-04 02:37:40 +00:00
|
|
|
if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
|
|
|
|
dma_unmap_single(bp->sdev->dma_dev, mapping, len,
|
2008-06-20 09:50:29 +00:00
|
|
|
DMA_TO_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-02 08:36:12 +00:00
|
|
|
bounce_skb = alloc_skb(len, GFP_ATOMIC | GFP_DMA);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!bounce_skb)
|
2005-11-07 00:50:03 +00:00
|
|
|
goto err_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
mapping = dma_map_single(bp->sdev->dma_dev, bounce_skb->data,
|
|
|
|
len, DMA_TO_DEVICE);
|
|
|
|
if (dma_mapping_error(bp->sdev->dma_dev, mapping) || mapping + len > DMA_BIT_MASK(30)) {
|
|
|
|
if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
|
|
|
|
dma_unmap_single(bp->sdev->dma_dev, mapping,
|
2008-06-20 09:50:29 +00:00
|
|
|
len, DMA_TO_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb_any(bounce_skb);
|
2005-11-07 00:50:03 +00:00
|
|
|
goto err_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-06-04 20:25:38 +00:00
|
|
|
skb_copy_from_linear_data(skb, skb_put(bounce_skb, len), len);
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
skb = bounce_skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry = bp->tx_prod;
|
|
|
|
bp->tx_buffers[entry].skb = skb;
|
2007-09-19 21:20:30 +00:00
|
|
|
bp->tx_buffers[entry].mapping = mapping;
|
2005-04-16 22:20:36 +00: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-19 01:30:59 +00:00
|
|
|
if (bp->flags & B44_FLAG_TX_RING_HACK)
|
2007-09-19 21:20:30 +00:00
|
|
|
b44_sync_dma_desc_for_device(bp->sdev, bp->tx_ring_dma,
|
|
|
|
entry * sizeof(bp->tx_ring[0]),
|
|
|
|
DMA_TO_DEVICE);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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);
|
|
|
|
|
2013-09-28 21:22:18 +00:00
|
|
|
netdev_sent_queue(dev, skb->len);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (TX_BUFFS_AVAIL(bp) < 1)
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
2005-11-07 00:50:03 +00:00
|
|
|
out_unlock:
|
2009-08-13 19:12:31 +00:00
|
|
|
spin_unlock_irqrestore(&bp->lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-07 00:50:03 +00:00
|
|
|
return rc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-07 00:50:03 +00:00
|
|
|
err_out:
|
|
|
|
rc = NETDEV_TX_BUSY;
|
|
|
|
goto out_unlock;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
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 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2006-04-12 22:04:32 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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;
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_unmap_single(bp->sdev->dma_dev, rp->mapping, RX_PKT_BUF_SZ,
|
|
|
|
DMA_FROM_DEVICE);
|
2005-04-16 22:20:36 +00: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;
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_unmap_single(bp->sdev->dma_dev, rp->mapping, rp->skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2005-04-16 22:20:36 +00: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-07 00:50:46 +00:00
|
|
|
* end up in the driver.
|
2005-04-16 22:20:36 +00: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-19 01:30:59 +00:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK)
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_sync_single_for_device(bp->sdev->dma_dev, bp->rx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES, DMA_BIDIRECTIONAL);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_TX_RING_HACK)
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_sync_single_for_device(bp->sdev->dma_dev, bp->tx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES, DMA_TO_DEVICE);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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 20:53:13 +00:00
|
|
|
kfree(bp->rx_buffers);
|
|
|
|
bp->rx_buffers = NULL;
|
|
|
|
kfree(bp->tx_buffers);
|
|
|
|
bp->tx_buffers = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bp->rx_ring) {
|
2005-10-19 01:30:59 +00:00
|
|
|
if (bp->flags & B44_FLAG_RX_RING_HACK) {
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_unmap_single(bp->sdev->dma_dev, bp->rx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES, DMA_BIDIRECTIONAL);
|
2005-10-19 01:30:59 +00:00
|
|
|
kfree(bp->rx_ring);
|
|
|
|
} else
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,
|
|
|
|
bp->rx_ring, bp->rx_ring_dma);
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->rx_ring = NULL;
|
2005-10-19 01:30:59 +00:00
|
|
|
bp->flags &= ~B44_FLAG_RX_RING_HACK;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bp->tx_ring) {
|
2005-10-19 01:30:59 +00:00
|
|
|
if (bp->flags & B44_FLAG_TX_RING_HACK) {
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_unmap_single(bp->sdev->dma_dev, bp->tx_ring_dma,
|
|
|
|
DMA_TABLE_BYTES, DMA_TO_DEVICE);
|
2005-10-19 01:30:59 +00:00
|
|
|
kfree(bp->tx_ring);
|
|
|
|
} else
|
2010-06-04 02:37:40 +00:00
|
|
|
dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,
|
|
|
|
bp->tx_ring, bp->tx_ring_dma);
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->tx_ring = NULL;
|
2005-10-19 01:30:59 +00:00
|
|
|
bp->flags &= ~B44_FLAG_TX_RING_HACK;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must not be invoked with interrupt sources disabled and
|
|
|
|
* the hardware shutdown down. Can sleep.
|
|
|
|
*/
|
2007-09-19 21:20:30 +00:00
|
|
|
static int b44_alloc_consistent(struct b44 *bp, gfp_t gfp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int size;
|
|
|
|
|
|
|
|
size = B44_RX_RING_SIZE * sizeof(struct ring_info);
|
2007-09-19 21:20:30 +00:00
|
|
|
bp->rx_buffers = kzalloc(size, gfp);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!bp->rx_buffers)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
size = B44_TX_RING_SIZE * sizeof(struct ring_info);
|
2007-09-19 21:20:30 +00:00
|
|
|
bp->tx_buffers = kzalloc(size, gfp);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!bp->tx_buffers)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
size = DMA_TABLE_BYTES;
|
2010-06-04 02:37:40 +00:00
|
|
|
bp->rx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size,
|
|
|
|
&bp->rx_ring_dma, gfp);
|
2005-10-19 01:30:59 +00: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 21:20:30 +00:00
|
|
|
rx_ring = kzalloc(size, gfp);
|
2005-11-07 00:50:46 +00:00
|
|
|
if (!rx_ring)
|
2005-10-19 01:30:59 +00:00
|
|
|
goto out_err;
|
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
rx_ring_dma = dma_map_single(bp->sdev->dma_dev, rx_ring,
|
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_BIDIRECTIONAL);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
if (dma_mapping_error(bp->sdev->dma_dev, rx_ring_dma) ||
|
2009-04-07 02:01:17 +00:00
|
|
|
rx_ring_dma + size > DMA_BIT_MASK(30)) {
|
2005-10-19 01:30:59 +00: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 22:20:36 +00:00
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
bp->tx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size,
|
|
|
|
&bp->tx_ring_dma, gfp);
|
2005-10-19 01:30:59 +00:00
|
|
|
if (!bp->tx_ring) {
|
2008-06-20 09:50:29 +00:00
|
|
|
/* Allocation may have failed due to ssb_dma_alloc_consistent
|
2005-10-19 01:30:59 +00: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 21:20:30 +00:00
|
|
|
tx_ring = kzalloc(size, gfp);
|
2005-11-07 00:50:46 +00:00
|
|
|
if (!tx_ring)
|
2005-10-19 01:30:59 +00:00
|
|
|
goto out_err;
|
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
tx_ring_dma = dma_map_single(bp->sdev->dma_dev, tx_ring,
|
|
|
|
DMA_TABLE_BYTES,
|
|
|
|
DMA_TO_DEVICE);
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2010-06-04 02:37:40 +00:00
|
|
|
if (dma_mapping_error(bp->sdev->dma_dev, tx_ring_dma) ||
|
2009-04-07 02:01:17 +00:00
|
|
|
tx_ring_dma + size > DMA_BIT_MASK(30)) {
|
2005-10-19 01:30:59 +00: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 22:20:36 +00: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. */
|
2008-01-01 00:17:54 +00:00
|
|
|
static void b44_chip_reset(struct b44 *bp, int reset_kind)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
struct ssb_device *sdev = bp->sdev;
|
2009-02-27 06:33:00 +00:00
|
|
|
bool was_enabled;
|
2007-09-19 21:20:30 +00:00
|
|
|
|
2009-02-27 06:33:00 +00:00
|
|
|
was_enabled = ssb_device_is_enabled(bp->sdev);
|
|
|
|
|
|
|
|
ssb_device_enable(bp->sdev, 0);
|
|
|
|
ssb_pcicore_dev_irqvecs_enable(&sdev->bus->pcicore, sdev);
|
|
|
|
|
|
|
|
if (was_enabled) {
|
2005-04-16 22:20:36 +00:00
|
|
|
bw32(bp, B44_RCV_LAZY, 0);
|
|
|
|
bw32(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE);
|
2007-02-16 21:27:27 +00:00
|
|
|
b44_wait_bit(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE, 200, 1);
|
2005-04-16 22:20:36 +00: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;
|
2009-02-27 06:33:00 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
b44_clear_stats(bp);
|
|
|
|
|
2008-01-01 00:17:54 +00: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 21:20:30 +00:00
|
|
|
switch (sdev->bus->bustype) {
|
|
|
|
case SSB_BUSTYPE_SSB:
|
|
|
|
bw32(bp, B44_MDIO_CTRL, (MDIO_CTRL_PREAMBLE |
|
2009-08-01 09:51:06 +00:00
|
|
|
(DIV_ROUND_CLOSEST(ssb_clockspeed(sdev->bus),
|
|
|
|
B44_MDC_RATIO)
|
2007-09-19 21:20:30 +00:00
|
|
|
& MDIO_CTRL_MAXF_MASK)));
|
|
|
|
break;
|
|
|
|
case SSB_BUSTYPE_PCI:
|
|
|
|
bw32(bp, B44_MDIO_CTRL, (MDIO_CTRL_PREAMBLE |
|
|
|
|
(0x0d & MDIO_CTRL_MAXF_MASK)));
|
|
|
|
break;
|
2009-09-08 17:33:31 +00:00
|
|
|
case SSB_BUSTYPE_PCMCIA:
|
|
|
|
case SSB_BUSTYPE_SDIO:
|
|
|
|
WARN_ON(1); /* A device with this bus does not exist. */
|
|
|
|
break;
|
2007-09-19 21:20:30 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00: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);
|
2013-12-20 01:16:06 +00:00
|
|
|
bp->flags |= B44_FLAG_EXTERNAL_PHY;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
u32 val = br32(bp, B44_DEVCTRL);
|
|
|
|
|
|
|
|
if (val & DEVCTRL_EPR) {
|
|
|
|
bw32(bp, B44_DEVCTRL, (val & ~DEVCTRL_EPR));
|
|
|
|
br32(bp, B44_DEVCTRL);
|
|
|
|
udelay(100);
|
|
|
|
}
|
2013-12-20 01:16:06 +00:00
|
|
|
bp->flags &= ~B44_FLAG_EXTERNAL_PHY;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bp->lock is held. */
|
|
|
|
static void b44_halt(struct b44 *bp)
|
|
|
|
{
|
|
|
|
b44_disable_ints(bp);
|
2008-01-01 00:17:54 +00:00
|
|
|
/* reset PHY */
|
|
|
|
b44_phy_reset(bp);
|
|
|
|
/* power down PHY */
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_info(bp->dev, "powering down PHY\n");
|
2008-01-01 00:17:54 +00:00
|
|
|
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 */
|
2013-12-20 01:16:11 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_FULL);
|
|
|
|
else
|
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_PARTIAL);
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
u32 val;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (netif_running(dev))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2006-03-28 22:57:38 +00:00
|
|
|
if (!is_valid_ether_addr(addr->sa_data))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
2007-09-19 21:20:30 +00:00
|
|
|
|
|
|
|
val = br32(bp, B44_RXCONFIG);
|
|
|
|
if (!(val & RXCONFIG_CAM_ABSENT))
|
|
|
|
__b44_set_mac_addr(bp);
|
|
|
|
|
2005-04-16 22:20:36 +00: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 07:59:57 +00:00
|
|
|
static void b44_init_hw(struct b44 *bp, int reset_kind)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
2008-01-01 00:17:54 +00:00
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_FULL);
|
2007-01-27 07:59:57 +00:00
|
|
|
if (reset_kind == B44_FULL_RESET) {
|
2006-06-20 22:34:26 +00:00
|
|
|
b44_phy_reset(bp);
|
|
|
|
b44_setup_phy(bp);
|
|
|
|
}
|
2005-04-16 22:20:36 +00: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 07:59:57 +00:00
|
|
|
if (reset_kind == B44_PARTIAL_RESET) {
|
|
|
|
bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
|
2007-06-04 20:25:39 +00:00
|
|
|
(RX_PKT_OFFSET << DMARX_CTRL_ROSHIFT)));
|
2007-01-27 07:59:57 +00:00
|
|
|
} else {
|
2006-06-20 22:34:26 +00: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 20:25:39 +00:00
|
|
|
(RX_PKT_OFFSET << DMARX_CTRL_ROSHIFT)));
|
2006-06-20 22:34:26 +00:00
|
|
|
bw32(bp, B44_DMARX_ADDR, bp->rx_ring_dma + bp->dma_offset);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-20 22:34:26 +00:00
|
|
|
bw32(bp, B44_DMARX_PTR, bp->rx_pending);
|
|
|
|
bp->rx_prod = bp->rx_pending;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-20 22:34:26 +00:00
|
|
|
bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
val = br32(bp, B44_ENET_CTRL);
|
|
|
|
bw32(bp, B44_ENET_CTRL, (val | ENET_CTRL_ENABLE));
|
2013-09-28 21:22:18 +00:00
|
|
|
|
|
|
|
netdev_reset_queue(bp->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_open(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
int err;
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
err = b44_alloc_consistent(bp, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err)
|
2005-11-07 00:52:57 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00: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 23:41:36 +00:00
|
|
|
napi_enable(&bp->napi);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
b44_init_rings(bp);
|
2007-01-27 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-08 19:11:57 +00:00
|
|
|
b44_check_phy(bp);
|
|
|
|
|
2006-07-02 02:29:39 +00:00
|
|
|
err = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
|
2005-11-07 00:52:57 +00: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 23:41:36 +00:00
|
|
|
napi_disable(&bp->napi);
|
2008-01-01 00:17:54 +00:00
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_PARTIAL);
|
2005-11-07 00:52:57 +00:00
|
|
|
b44_free_rings(bp);
|
|
|
|
b44_free_consistent(bp);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-09-21 17:04:23 +00:00
|
|
|
setup_timer(&bp->timer, b44_timer, (unsigned long)bp);
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->timer.expires = jiffies + HZ;
|
|
|
|
add_timer(&bp->timer);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2014-03-02 16:29:33 +00:00
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
2016-09-17 22:11:34 +00:00
|
|
|
phy_start(dev->phydev);
|
2014-03-02 16:29:33 +00:00
|
|
|
|
2005-11-30 21:30:23 +00:00
|
|
|
netif_start_queue(dev);
|
2005-11-07 00:52:57 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00: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 13:55:46 +00:00
|
|
|
b44_interrupt(dev->irq, dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
enable_irq(dev->irq);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-06-20 22:34:36 +00: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];
|
2009-12-09 05:00:22 +00:00
|
|
|
set_bit(len++, (unsigned long *) pmask);
|
2006-06-20 22:34:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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 08:49:03 +00:00
|
|
|
pwol_pattern = kzalloc(B44_PATTERN_SIZE, GFP_KERNEL);
|
2013-02-03 17:43:58 +00:00
|
|
|
if (!pwol_pattern)
|
2006-06-20 22:34:36 +00:00
|
|
|
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 22:34:23 +00:00
|
|
|
|
2007-09-19 21:20:30 +00: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 22:34:23 +00: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 22:34:36 +00:00
|
|
|
} else {
|
|
|
|
b44_setup_pseudo_magicp(bp);
|
|
|
|
}
|
2007-09-19 21:20:30 +00:00
|
|
|
b44_setup_wol_pci(bp);
|
2006-06-20 22:34:23 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int b44_close(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
2014-03-02 16:29:33 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
2016-09-17 22:11:34 +00:00
|
|
|
phy_stop(dev->phydev);
|
2014-03-02 16:29:33 +00: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 23:41:36 +00:00
|
|
|
napi_disable(&bp->napi);
|
2005-11-08 22:37:12 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
del_timer_sync(&bp->timer);
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_halt(bp);
|
|
|
|
b44_free_rings(bp);
|
2006-01-21 05:13:17 +00:00
|
|
|
netif_carrier_off(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
|
2006-06-20 22:34:23 +00:00
|
|
|
if (bp->flags & B44_FLAG_WOL_ENABLE) {
|
2007-01-27 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_PARTIAL_RESET);
|
2006-06-20 22:34:23 +00:00
|
|
|
b44_setup_wol(bp);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
b44_free_consistent(bp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-07 03:12:52 +00:00
|
|
|
static void b44_get_stats64(struct net_device *dev,
|
|
|
|
struct rtnl_link_stats64 *nstat)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
struct b44_hw_stats *hwstat = &bp->hw_stats;
|
2012-07-17 17:46:01 +00:00
|
|
|
unsigned int start;
|
|
|
|
|
|
|
|
do {
|
2014-03-14 04:26:42 +00:00
|
|
|
start = u64_stats_fetch_begin_irq(&hwstat->syncp);
|
2012-07-17 17:46:01 +00:00
|
|
|
|
|
|
|
/* Convert HW stats into rtnl_link_stats64 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);
|
2014-09-11 22:19:49 +00:00
|
|
|
nstat->multicast = hwstat->rx_multicast_pkts;
|
2012-07-17 17:46:01 +00:00
|
|
|
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;
|
2005-04-16 22:20:36 +00:00
|
|
|
#if 0
|
2012-07-17 17:46:01 +00:00
|
|
|
/* Carrier lost counter seems to be broken for some devices */
|
|
|
|
nstat->tx_carrier_errors = hwstat->tx_carrier_lost;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2014-03-14 04:26:42 +00:00
|
|
|
} while (u64_stats_fetch_retry_irq(&hwstat->syncp, start));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __b44_load_mcast(struct b44 *bp, struct net_device *dev)
|
|
|
|
{
|
2010-04-01 21:22:57 +00:00
|
|
|
struct netdev_hw_addr *ha;
|
2005-04-16 22:20:36 +00:00
|
|
|
int i, num_ents;
|
|
|
|
|
2010-02-08 04:30:35 +00:00
|
|
|
num_ents = min_t(int, netdev_mc_count(dev), B44_MCAST_TABLE_SIZE);
|
2010-02-20 00:13:58 +00:00
|
|
|
i = 0;
|
2010-04-01 21:22:57 +00:00
|
|
|
netdev_for_each_mc_addr(ha, dev) {
|
2010-02-20 00:13:58 +00:00
|
|
|
if (i == num_ents)
|
|
|
|
break;
|
2010-04-01 21:22:57 +00:00
|
|
|
__b44_cam_write(bp, ha->addr, i++ + 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
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 21:20:30 +00:00
|
|
|
if ((dev->flags & IFF_PROMISC) || (val & RXCONFIG_CAM_ABSENT)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
val |= RXCONFIG_PROMISC;
|
|
|
|
bw32(bp, B44_RXCONFIG, val);
|
|
|
|
} else {
|
2005-11-07 00:50:46 +00:00
|
|
|
unsigned char zero[6] = {0, 0, 0, 0, 0, 0};
|
2007-04-01 17:10:28 +00:00
|
|
|
int i = 1;
|
2005-11-07 00:50:46 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
__b44_set_mac_addr(bp);
|
|
|
|
|
2006-10-05 11:10:38 +00:00
|
|
|
if ((dev->flags & IFF_ALLMULTI) ||
|
2010-02-08 04:30:35 +00:00
|
|
|
(netdev_mc_count(dev) > B44_MCAST_TABLE_SIZE))
|
2005-04-16 22:20:36 +00:00
|
|
|
val |= RXCONFIG_ALLMULTI;
|
|
|
|
else
|
2005-11-07 00:50:46 +00:00
|
|
|
i = __b44_load_mcast(bp, dev);
|
2006-04-12 22:04:32 +00:00
|
|
|
|
2006-10-05 11:10:38 +00:00
|
|
|
for (; i < 64; i++)
|
2006-04-12 22:04:32 +00:00
|
|
|
__b44_cam_write(bp, zero, i);
|
2006-10-05 11:10:38 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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 21:20:30 +00:00
|
|
|
struct ssb_bus *bus = bp->sdev->bus;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-17 08:01:54 +00:00
|
|
|
strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
|
|
|
|
strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
|
2007-09-19 21:20:30 +00:00
|
|
|
switch (bus->bustype) {
|
|
|
|
case SSB_BUSTYPE_PCI:
|
2009-07-17 08:01:54 +00:00
|
|
|
strlcpy(info->bus_info, pci_name(bus->host_pci), sizeof(info->bus_info));
|
2007-09-19 21:20:30 +00:00
|
|
|
break;
|
|
|
|
case SSB_BUSTYPE_SSB:
|
2009-07-17 08:01:54 +00:00
|
|
|
strlcpy(info->bus_info, "SSB", sizeof(info->bus_info));
|
2007-09-19 21:20:30 +00:00
|
|
|
break;
|
2009-09-08 17:33:31 +00:00
|
|
|
case SSB_BUSTYPE_PCMCIA:
|
|
|
|
case SSB_BUSTYPE_SDIO:
|
|
|
|
WARN_ON(1); /* A device with this bus does not exist. */
|
|
|
|
break;
|
2007-09-19 21:20:30 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00: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;
|
|
|
|
}
|
|
|
|
|
2016-09-17 22:11:35 +00:00
|
|
|
static int b44_get_link_ksettings(struct net_device *dev,
|
|
|
|
struct ethtool_link_ksettings *cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2016-09-17 22:11:35 +00:00
|
|
|
u32 supported, advertising;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-12-20 01:16:10 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY) {
|
2016-09-17 22:11:34 +00:00
|
|
|
BUG_ON(!dev->phydev);
|
2017-06-13 07:09:46 +00:00
|
|
|
phy_ethtool_ksettings_get(dev->phydev, cmd);
|
|
|
|
|
|
|
|
return 0;
|
2013-12-20 01:16:10 +00:00
|
|
|
}
|
|
|
|
|
2016-09-17 22:11:35 +00:00
|
|
|
supported = (SUPPORTED_Autoneg);
|
|
|
|
supported |= (SUPPORTED_100baseT_Half |
|
|
|
|
SUPPORTED_100baseT_Full |
|
|
|
|
SUPPORTED_10baseT_Half |
|
|
|
|
SUPPORTED_10baseT_Full |
|
|
|
|
SUPPORTED_MII);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-09-17 22:11:35 +00:00
|
|
|
advertising = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bp->flags & B44_FLAG_ADV_10HALF)
|
2016-09-17 22:11:35 +00:00
|
|
|
advertising |= ADVERTISED_10baseT_Half;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bp->flags & B44_FLAG_ADV_10FULL)
|
2016-09-17 22:11:35 +00:00
|
|
|
advertising |= ADVERTISED_10baseT_Full;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bp->flags & B44_FLAG_ADV_100HALF)
|
2016-09-17 22:11:35 +00:00
|
|
|
advertising |= ADVERTISED_100baseT_Half;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bp->flags & B44_FLAG_ADV_100FULL)
|
2016-09-17 22:11:35 +00:00
|
|
|
advertising |= ADVERTISED_100baseT_Full;
|
|
|
|
advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
|
|
|
|
cmd->base.speed = (bp->flags & B44_FLAG_100_BASE_T) ?
|
|
|
|
SPEED_100 : SPEED_10;
|
|
|
|
cmd->base.duplex = (bp->flags & B44_FLAG_FULL_DUPLEX) ?
|
2005-04-16 22:20:36 +00:00
|
|
|
DUPLEX_FULL : DUPLEX_HALF;
|
2016-09-17 22:11:35 +00:00
|
|
|
cmd->base.port = 0;
|
|
|
|
cmd->base.phy_address = bp->phy_addr;
|
|
|
|
cmd->base.autoneg = (bp->flags & B44_FLAG_FORCE_LINK) ?
|
2005-04-16 22:20:36 +00:00
|
|
|
AUTONEG_DISABLE : AUTONEG_ENABLE;
|
2016-09-17 22:11:35 +00:00
|
|
|
if (cmd->base.autoneg == AUTONEG_ENABLE)
|
|
|
|
advertising |= ADVERTISED_Autoneg;
|
|
|
|
|
|
|
|
ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
|
|
|
|
supported);
|
|
|
|
ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
|
|
|
|
advertising);
|
|
|
|
|
2006-06-20 22:34:15 +00:00
|
|
|
if (!netif_running(dev)){
|
2016-09-17 22:11:35 +00:00
|
|
|
cmd->base.speed = 0;
|
|
|
|
cmd->base.duplex = 0xff;
|
2006-06-20 22:34:15 +00:00
|
|
|
}
|
2016-09-17 22:11:35 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-17 22:11:35 +00:00
|
|
|
static int b44_set_link_ksettings(struct net_device *dev,
|
|
|
|
const struct ethtool_link_ksettings *cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2013-12-20 01:16:10 +00:00
|
|
|
u32 speed;
|
|
|
|
int ret;
|
2016-09-17 22:11:35 +00:00
|
|
|
u32 advertising;
|
2013-12-20 01:16:10 +00:00
|
|
|
|
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY) {
|
2016-09-17 22:11:34 +00:00
|
|
|
BUG_ON(!dev->phydev);
|
2013-12-20 01:16:10 +00:00
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
if (netif_running(dev))
|
|
|
|
b44_setup_phy(bp);
|
|
|
|
|
2016-09-17 22:11:35 +00:00
|
|
|
ret = phy_ethtool_ksettings_set(dev->phydev, cmd);
|
2013-12-20 01:16:10 +00:00
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-09-17 22:11:35 +00:00
|
|
|
speed = cmd->base.speed;
|
|
|
|
|
|
|
|
ethtool_convert_link_mode_to_legacy_u32(&advertising,
|
|
|
|
cmd->link_modes.advertising);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* We do not support gigabit. */
|
2016-09-17 22:11:35 +00:00
|
|
|
if (cmd->base.autoneg == AUTONEG_ENABLE) {
|
|
|
|
if (advertising &
|
2005-04-16 22:20:36 +00:00
|
|
|
(ADVERTISED_1000baseT_Half |
|
|
|
|
ADVERTISED_1000baseT_Full))
|
|
|
|
return -EINVAL;
|
2011-04-27 18:32:39 +00:00
|
|
|
} else if ((speed != SPEED_100 &&
|
|
|
|
speed != SPEED_10) ||
|
2016-09-17 22:11:35 +00:00
|
|
|
(cmd->base.duplex != DUPLEX_HALF &&
|
|
|
|
cmd->base.duplex != DUPLEX_FULL)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
|
2016-09-17 22:11:35 +00:00
|
|
|
if (cmd->base.autoneg == AUTONEG_ENABLE) {
|
2006-06-20 22:34:15 +00:00
|
|
|
bp->flags &= ~(B44_FLAG_FORCE_LINK |
|
|
|
|
B44_FLAG_100_BASE_T |
|
|
|
|
B44_FLAG_FULL_DUPLEX |
|
|
|
|
B44_FLAG_ADV_10HALF |
|
2005-04-16 22:20:36 +00:00
|
|
|
B44_FLAG_ADV_10FULL |
|
|
|
|
B44_FLAG_ADV_100HALF |
|
|
|
|
B44_FLAG_ADV_100FULL);
|
2016-09-17 22:11:35 +00:00
|
|
|
if (advertising == 0) {
|
2006-06-20 22:34:15 +00:00
|
|
|
bp->flags |= (B44_FLAG_ADV_10HALF |
|
|
|
|
B44_FLAG_ADV_10FULL |
|
|
|
|
B44_FLAG_ADV_100HALF |
|
|
|
|
B44_FLAG_ADV_100FULL);
|
|
|
|
} else {
|
2016-09-17 22:11:35 +00:00
|
|
|
if (advertising & ADVERTISED_10baseT_Half)
|
2006-06-20 22:34:15 +00:00
|
|
|
bp->flags |= B44_FLAG_ADV_10HALF;
|
2016-09-17 22:11:35 +00:00
|
|
|
if (advertising & ADVERTISED_10baseT_Full)
|
2006-06-20 22:34:15 +00:00
|
|
|
bp->flags |= B44_FLAG_ADV_10FULL;
|
2016-09-17 22:11:35 +00:00
|
|
|
if (advertising & ADVERTISED_100baseT_Half)
|
2006-06-20 22:34:15 +00:00
|
|
|
bp->flags |= B44_FLAG_ADV_100HALF;
|
2016-09-17 22:11:35 +00:00
|
|
|
if (advertising & ADVERTISED_100baseT_Full)
|
2006-06-20 22:34:15 +00:00
|
|
|
bp->flags |= B44_FLAG_ADV_100FULL;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
bp->flags |= B44_FLAG_FORCE_LINK;
|
2006-06-20 22:34:15 +00:00
|
|
|
bp->flags &= ~(B44_FLAG_100_BASE_T | B44_FLAG_FULL_DUPLEX);
|
2011-04-27 18:32:39 +00:00
|
|
|
if (speed == SPEED_100)
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->flags |= B44_FLAG_100_BASE_T;
|
2016-09-17 22:11:35 +00:00
|
|
|
if (cmd->base.duplex == DUPLEX_FULL)
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->flags |= B44_FLAG_FULL_DUPLEX;
|
|
|
|
}
|
|
|
|
|
2006-06-20 22:34:15 +00:00
|
|
|
if (netif_running(dev))
|
|
|
|
b44_setup_phy(bp);
|
2005-04-16 22:20:36 +00: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 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 22:20:36 +00:00
|
|
|
netif_wake_queue(bp->dev);
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2006-04-12 22:04:32 +00:00
|
|
|
|
2005-04-16 22:20:36 +00: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 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
__b44_set_flow_ctrl(bp, bp->flags);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2006-04-12 22:04:32 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-07 00:51:34 +00: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-04 01:07:32 +00:00
|
|
|
static int b44_get_sset_count(struct net_device *dev, int sset)
|
2005-11-07 00:51:34 +00:00
|
|
|
{
|
2007-10-04 01:07:32 +00:00
|
|
|
switch (sset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
return ARRAY_SIZE(b44_gstrings);
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2005-11-07 00:51:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_get_ethtool_stats(struct net_device *dev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2012-07-17 17:46:01 +00:00
|
|
|
struct b44_hw_stats *hwstat = &bp->hw_stats;
|
|
|
|
u64 *data_src, *data_dst;
|
|
|
|
unsigned int start;
|
2005-11-07 00:51:34 +00:00
|
|
|
u32 i;
|
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
b44_stats_update(bp);
|
2012-07-17 17:46:01 +00:00
|
|
|
spin_unlock_irq(&bp->lock);
|
2005-11-07 00:51:34 +00:00
|
|
|
|
2012-07-17 17:46:01 +00:00
|
|
|
do {
|
|
|
|
data_src = &hwstat->tx_good_octets;
|
|
|
|
data_dst = data;
|
2014-03-14 04:26:42 +00:00
|
|
|
start = u64_stats_fetch_begin_irq(&hwstat->syncp);
|
2005-11-07 00:51:34 +00:00
|
|
|
|
2012-07-17 17:46:01 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(b44_gstrings); i++)
|
|
|
|
*data_dst++ = *data_src++;
|
|
|
|
|
2014-03-14 04:26:42 +00:00
|
|
|
} while (u64_stats_fetch_retry_irq(&hwstat->syncp, start));
|
2005-11-07 00:51:34 +00:00
|
|
|
}
|
|
|
|
|
2006-06-20 22:34:23 +00: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);
|
|
|
|
|
2014-12-04 16:32:46 +00:00
|
|
|
device_set_wakeup_enable(bp->sdev->dev, wol->wolopts & WAKE_MAGIC);
|
2006-06-20 22:34:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-13 18:30:00 +00:00
|
|
|
static const struct ethtool_ops b44_ethtool_ops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.get_drvinfo = b44_get_drvinfo,
|
|
|
|
.nway_reset = b44_nway_reset,
|
|
|
|
.get_link = ethtool_op_get_link,
|
2006-06-20 22:34:23 +00:00
|
|
|
.get_wol = b44_get_wol,
|
|
|
|
.set_wol = b44_set_wol,
|
2005-04-16 22:20:36 +00: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-07 00:51:34 +00:00
|
|
|
.get_strings = b44_get_strings,
|
2007-10-04 01:07:32 +00:00
|
|
|
.get_sset_count = b44_get_sset_count,
|
2005-11-07 00:51:34 +00:00
|
|
|
.get_ethtool_stats = b44_get_ethtool_stats,
|
2016-09-17 22:11:35 +00:00
|
|
|
.get_link_ksettings = b44_get_link_ksettings,
|
|
|
|
.set_link_ksettings = b44_set_link_ksettings,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int b44_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2005-11-30 21:32:13 +00:00
|
|
|
int err = -EINVAL;
|
|
|
|
|
|
|
|
if (!netif_running(dev))
|
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irq(&bp->lock);
|
2013-12-20 01:16:10 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY) {
|
2016-09-17 22:11:34 +00:00
|
|
|
BUG_ON(!dev->phydev);
|
|
|
|
err = phy_mii_ioctl(dev->phydev, ifr, cmd);
|
2013-12-20 01:16:10 +00:00
|
|
|
} else {
|
|
|
|
err = generic_mii_ioctl(&bp->mii_if, if_mii(ifr), cmd, NULL);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irq(&bp->lock);
|
2005-11-30 21:32:13 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-03 14:22:57 +00:00
|
|
|
static int b44_get_invariants(struct b44 *bp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
struct ssb_device *sdev = bp->sdev;
|
|
|
|
int err = 0;
|
|
|
|
u8 *addr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
bp->dma_offset = ssb_dma_translation(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
if (sdev->bus->bustype == SSB_BUSTYPE_SSB &&
|
|
|
|
instance > 1) {
|
2007-11-09 22:56:10 +00:00
|
|
|
addr = sdev->bus->sprom.et1mac;
|
|
|
|
bp->phy_addr = sdev->bus->sprom.et1phyaddr;
|
2007-09-19 21:20:30 +00:00
|
|
|
} else {
|
2007-11-09 22:56:10 +00:00
|
|
|
addr = sdev->bus->sprom.et0mac;
|
|
|
|
bp->phy_addr = sdev->bus->sprom.et0phyaddr;
|
2007-09-19 21:20:30 +00:00
|
|
|
}
|
2008-03-25 17:04:46 +00: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;
|
|
|
|
|
2013-10-02 02:04:40 +00:00
|
|
|
memcpy(bp->dev->dev_addr, addr, ETH_ALEN);
|
2006-03-28 22:57:38 +00:00
|
|
|
|
|
|
|
if (!is_valid_ether_addr(&bp->dev->dev_addr[0])){
|
2010-02-17 15:01:50 +00:00
|
|
|
pr_err("Invalid MAC address found in EEPROM\n");
|
2006-03-28 22:57:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->imask = IMASK_DEF;
|
|
|
|
|
2006-04-12 22:04:32 +00:00
|
|
|
/* XXX - really required?
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->flags |= B44_FLAG_BUGGY_TXPTR;
|
2007-09-19 21:20:30 +00:00
|
|
|
*/
|
2006-06-20 22:34:23 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
if (bp->sdev->id.revision >= 7)
|
|
|
|
bp->flags |= B44_FLAG_B0_ANDLATER;
|
2006-06-20 22:34:23 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-01-08 02:10:49 +00:00
|
|
|
static const struct net_device_ops b44_netdev_ops = {
|
|
|
|
.ndo_open = b44_open,
|
|
|
|
.ndo_stop = b44_close,
|
|
|
|
.ndo_start_xmit = b44_start_xmit,
|
2012-07-17 17:46:01 +00:00
|
|
|
.ndo_get_stats64 = b44_get_stats64,
|
2011-08-16 06:29:01 +00:00
|
|
|
.ndo_set_rx_mode = b44_set_rx_mode,
|
2009-01-08 02:10:49 +00:00
|
|
|
.ndo_set_mac_address = b44_set_mac_addr,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
.ndo_do_ioctl = b44_ioctl,
|
|
|
|
.ndo_tx_timeout = b44_tx_timeout,
|
|
|
|
.ndo_change_mtu = b44_change_mtu,
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = b44_poll_controller,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2013-12-20 01:16:10 +00:00
|
|
|
static void b44_adjust_link(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2016-09-17 22:11:34 +00:00
|
|
|
struct phy_device *phydev = dev->phydev;
|
2013-12-20 01:16:10 +00:00
|
|
|
bool status_changed = 0;
|
|
|
|
|
|
|
|
BUG_ON(!phydev);
|
|
|
|
|
|
|
|
if (bp->old_link != phydev->link) {
|
|
|
|
status_changed = 1;
|
|
|
|
bp->old_link = phydev->link;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reflect duplex change */
|
|
|
|
if (phydev->link) {
|
|
|
|
if ((phydev->duplex == DUPLEX_HALF) &&
|
|
|
|
(bp->flags & B44_FLAG_FULL_DUPLEX)) {
|
|
|
|
status_changed = 1;
|
|
|
|
bp->flags &= ~B44_FLAG_FULL_DUPLEX;
|
|
|
|
} else if ((phydev->duplex == DUPLEX_FULL) &&
|
|
|
|
!(bp->flags & B44_FLAG_FULL_DUPLEX)) {
|
|
|
|
status_changed = 1;
|
|
|
|
bp->flags |= B44_FLAG_FULL_DUPLEX;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (status_changed) {
|
2014-03-02 16:29:34 +00:00
|
|
|
u32 val = br32(bp, B44_TX_CTRL);
|
|
|
|
if (bp->flags & B44_FLAG_FULL_DUPLEX)
|
|
|
|
val |= TX_CTRL_DUPLEX;
|
|
|
|
else
|
|
|
|
val &= ~TX_CTRL_DUPLEX;
|
|
|
|
bw32(bp, B44_TX_CTRL, val);
|
2013-12-20 01:16:10 +00:00
|
|
|
phy_print_status(phydev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int b44_register_phy_one(struct b44 *bp)
|
|
|
|
{
|
|
|
|
struct mii_bus *mii_bus;
|
|
|
|
struct ssb_device *sdev = bp->sdev;
|
|
|
|
struct phy_device *phydev;
|
|
|
|
char bus_id[MII_BUS_ID_SIZE + 3];
|
2013-12-20 01:16:13 +00:00
|
|
|
struct ssb_sprom *sprom = &sdev->bus->sprom;
|
2013-12-20 01:16:10 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
mii_bus = mdiobus_alloc();
|
|
|
|
if (!mii_bus) {
|
|
|
|
dev_err(sdev->dev, "mdiobus_alloc() failed\n");
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mii_bus->priv = bp;
|
|
|
|
mii_bus->read = b44_mdio_read_phylib;
|
|
|
|
mii_bus->write = b44_mdio_write_phylib;
|
|
|
|
mii_bus->name = "b44_eth_mii";
|
|
|
|
mii_bus->parent = sdev->dev;
|
|
|
|
mii_bus->phy_mask = ~(1 << bp->phy_addr);
|
|
|
|
snprintf(mii_bus->id, MII_BUS_ID_SIZE, "%x", instance);
|
|
|
|
|
|
|
|
bp->mii_bus = mii_bus;
|
|
|
|
|
|
|
|
err = mdiobus_register(mii_bus);
|
|
|
|
if (err) {
|
|
|
|
dev_err(sdev->dev, "failed to register MII bus\n");
|
2016-01-06 19:11:15 +00:00
|
|
|
goto err_out_mdiobus;
|
2013-12-20 01:16:10 +00:00
|
|
|
}
|
|
|
|
|
2016-01-06 19:11:18 +00:00
|
|
|
if (!mdiobus_is_registered_device(bp->mii_bus, bp->phy_addr) &&
|
2013-12-20 01:16:13 +00:00
|
|
|
(sprom->boardflags_lo & (B44_BOARDFLAG_ROBO | B44_BOARDFLAG_ADM))) {
|
|
|
|
|
|
|
|
dev_info(sdev->dev,
|
|
|
|
"could not find PHY at %i, use fixed one\n",
|
|
|
|
bp->phy_addr);
|
|
|
|
|
|
|
|
bp->phy_addr = 0;
|
|
|
|
snprintf(bus_id, sizeof(bus_id), PHY_ID_FMT, "fixed-0",
|
|
|
|
bp->phy_addr);
|
|
|
|
} else {
|
|
|
|
snprintf(bus_id, sizeof(bus_id), PHY_ID_FMT, mii_bus->id,
|
|
|
|
bp->phy_addr);
|
|
|
|
}
|
2013-12-20 01:16:10 +00:00
|
|
|
|
|
|
|
phydev = phy_connect(bp->dev, bus_id, &b44_adjust_link,
|
|
|
|
PHY_INTERFACE_MODE_MII);
|
|
|
|
if (IS_ERR(phydev)) {
|
|
|
|
dev_err(sdev->dev, "could not attach PHY at %i\n",
|
|
|
|
bp->phy_addr);
|
|
|
|
err = PTR_ERR(phydev);
|
|
|
|
goto err_out_mdiobus_unregister;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* mask with MAC supported features */
|
|
|
|
phydev->supported &= (SUPPORTED_100baseT_Half |
|
|
|
|
SUPPORTED_100baseT_Full |
|
|
|
|
SUPPORTED_Autoneg |
|
|
|
|
SUPPORTED_MII);
|
|
|
|
phydev->advertising = phydev->supported;
|
|
|
|
|
|
|
|
bp->old_link = 0;
|
2016-01-06 19:11:16 +00:00
|
|
|
bp->phy_addr = phydev->mdio.addr;
|
2013-12-20 01:16:10 +00:00
|
|
|
|
2016-01-06 19:11:13 +00:00
|
|
|
phy_attached_info(phydev);
|
2013-12-20 01:16:10 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out_mdiobus_unregister:
|
|
|
|
mdiobus_unregister(mii_bus);
|
|
|
|
|
|
|
|
err_out_mdiobus:
|
|
|
|
mdiobus_free(mii_bus);
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void b44_unregister_phy_one(struct b44 *bp)
|
|
|
|
{
|
2016-09-17 22:11:34 +00:00
|
|
|
struct net_device *dev = bp->dev;
|
2013-12-20 01:16:10 +00:00
|
|
|
struct mii_bus *mii_bus = bp->mii_bus;
|
|
|
|
|
2016-09-17 22:11:34 +00:00
|
|
|
phy_disconnect(dev->phydev);
|
2013-12-20 01:16:10 +00:00
|
|
|
mdiobus_unregister(mii_bus);
|
|
|
|
mdiobus_free(mii_bus);
|
|
|
|
}
|
|
|
|
|
2012-12-03 14:22:57 +00:00
|
|
|
static int b44_init_one(struct ssb_device *sdev,
|
2012-12-06 14:30:56 +00:00
|
|
|
const struct ssb_device_id *ent)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
struct b44 *bp;
|
2007-10-04 00:59:30 +00:00
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
instance++;
|
|
|
|
|
2011-07-05 07:43:46 +00:00
|
|
|
pr_info_once("%s version %s\n", DRV_DESCRIPTION, DRV_MODULE_VERSION);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
dev = alloc_etherdev(sizeof(*bp));
|
|
|
|
if (!dev) {
|
|
|
|
err = -ENOMEM;
|
2007-09-19 21:20:30 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
SET_NETDEV_DEV(dev, sdev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* No interesting netdevice features in this card... */
|
|
|
|
dev->features |= 0;
|
|
|
|
|
|
|
|
bp = netdev_priv(dev);
|
2007-09-19 21:20:30 +00:00
|
|
|
bp->sdev = sdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->dev = dev;
|
2009-01-15 23:29:35 +00:00
|
|
|
bp->force_copybreak = 0;
|
2005-11-07 00:50:46 +00:00
|
|
|
|
|
|
|
bp->msg_enable = netif_msg_init(b44_debug, B44_DEF_MSG_ENABLE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_init(&bp->lock);
|
2017-08-01 19:11:06 +00:00
|
|
|
u64_stats_init(&bp->hw_stats.syncp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
bp->rx_pending = B44_DEF_RX_RING_PENDING;
|
|
|
|
bp->tx_pending = B44_DEF_TX_RING_PENDING;
|
|
|
|
|
2009-01-08 02:10:49 +00:00
|
|
|
dev->netdev_ops = &b44_netdev_ops;
|
[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 23:41:36 +00:00
|
|
|
netif_napi_add(dev, &bp->napi, b44_poll, 64);
|
2005-04-16 22:20:36 +00:00
|
|
|
dev->watchdog_timeo = B44_TX_TIMEOUT;
|
2016-10-17 19:54:04 +00:00
|
|
|
dev->min_mtu = B44_MIN_MTU;
|
|
|
|
dev->max_mtu = B44_MAX_MTU;
|
2007-09-19 21:20:30 +00:00
|
|
|
dev->irq = sdev->irq;
|
2014-05-11 00:12:32 +00:00
|
|
|
dev->ethtool_ops = &b44_ethtool_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00: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;
|
|
|
|
}
|
2010-06-04 02:37:40 +00:00
|
|
|
|
2013-06-26 18:04:29 +00:00
|
|
|
if (dma_set_mask_and_coherent(sdev->dma_dev, DMA_BIT_MASK(30))) {
|
2007-09-19 21:20:30 +00:00
|
|
|
dev_err(sdev->dev,
|
2010-02-17 15:01:50 +00:00
|
|
|
"Required 30BIT DMA mask unsupported by the system\n");
|
2007-09-19 21:20:30 +00:00
|
|
|
goto err_out_powerdown;
|
|
|
|
}
|
2010-06-04 02:37:40 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
err = b44_get_invariants(bp);
|
|
|
|
if (err) {
|
2007-09-19 21:20:30 +00:00
|
|
|
dev_err(sdev->dev,
|
2010-02-17 15:01:50 +00:00
|
|
|
"Problem fetching invariants of chip, aborting\n");
|
2007-09-19 21:20:30 +00:00
|
|
|
goto err_out_powerdown;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-12-20 01:16:08 +00:00
|
|
|
if (bp->phy_addr == B44_PHY_ADDR_NO_PHY) {
|
|
|
|
dev_err(sdev->dev, "No PHY present on this MAC, aborting\n");
|
|
|
|
err = -ENODEV;
|
|
|
|
goto err_out_powerdown;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
bp->mii_if.dev = dev;
|
2013-12-20 01:16:09 +00:00
|
|
|
bp->mii_if.mdio_read = b44_mdio_read_mii;
|
|
|
|
bp->mii_if.mdio_write = b44_mdio_write_mii;
|
2005-04-16 22:20:36 +00:00
|
|
|
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) {
|
2010-02-17 15:01:50 +00:00
|
|
|
dev_err(sdev->dev, "Cannot register net device, aborting\n");
|
2007-09-19 21:20:30 +00:00
|
|
|
goto err_out_powerdown;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-10-11 22:45:35 +00:00
|
|
|
netif_carrier_off(dev);
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
ssb_set_drvdata(sdev, dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-12 22:04:32 +00:00
|
|
|
/* Chip reset provides power to the b44 MAC & PCI cores, which
|
2006-03-29 22:12:05 +00:00
|
|
|
* is necessary for MAC register access.
|
2006-04-12 22:04:32 +00:00
|
|
|
*/
|
2008-01-01 00:17:54 +00:00
|
|
|
b44_chip_reset(bp, B44_CHIP_RESET_FULL);
|
2006-03-29 22:12:05 +00:00
|
|
|
|
2010-02-20 10:55:25 +00:00
|
|
|
/* do a phy reset to test if there is an active phy */
|
2013-12-20 01:16:12 +00:00
|
|
|
err = b44_phy_reset(bp);
|
|
|
|
if (err < 0) {
|
|
|
|
dev_err(sdev->dev, "phy reset failed\n");
|
|
|
|
goto err_out_unregister_netdev;
|
|
|
|
}
|
2010-02-20 10:55:25 +00:00
|
|
|
|
2013-12-20 01:16:10 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY) {
|
|
|
|
err = b44_register_phy_one(bp);
|
|
|
|
if (err) {
|
|
|
|
dev_err(sdev->dev, "Cannot register PHY, aborting\n");
|
|
|
|
goto err_out_unregister_netdev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-04 16:32:46 +00:00
|
|
|
device_set_wakeup_capable(sdev->dev, true);
|
2011-07-05 07:43:46 +00:00
|
|
|
netdev_info(dev, "%s %pM\n", DRV_DESCRIPTION, dev->dev_addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2013-12-20 01:16:10 +00:00
|
|
|
err_out_unregister_netdev:
|
|
|
|
unregister_netdev(dev);
|
2007-09-19 21:20:30 +00:00
|
|
|
err_out_powerdown:
|
|
|
|
ssb_bus_may_powerdown(sdev->bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
err_out_free_dev:
|
2015-06-07 12:11:48 +00:00
|
|
|
netif_napi_del(&bp->napi);
|
2005-04-16 22:20:36 +00:00
|
|
|
free_netdev(dev);
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-03 14:22:57 +00:00
|
|
|
static void b44_remove_one(struct ssb_device *sdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
struct net_device *dev = ssb_get_drvdata(sdev);
|
2013-12-20 01:16:10 +00:00
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-07 00:50:46 +00:00
|
|
|
unregister_netdev(dev);
|
2013-12-20 01:16:10 +00:00
|
|
|
if (bp->flags & B44_FLAG_EXTERNAL_PHY)
|
|
|
|
b44_unregister_phy_one(bp);
|
2009-02-27 06:35:02 +00:00
|
|
|
ssb_device_disable(sdev, 0);
|
2007-09-19 21:20:30 +00:00
|
|
|
ssb_bus_may_powerdown(sdev->bus);
|
2015-06-07 12:11:48 +00:00
|
|
|
netif_napi_del(&bp->napi);
|
2005-11-07 00:50:46 +00:00
|
|
|
free_netdev(dev);
|
2008-01-01 00:17:54 +00:00
|
|
|
ssb_pcihost_set_power_state(sdev, PCI_D3hot);
|
2007-09-19 21:20:30 +00:00
|
|
|
ssb_set_drvdata(sdev, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
static int b44_suspend(struct ssb_device *sdev, pm_message_t state)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
struct net_device *dev = ssb_get_drvdata(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct b44 *bp = netdev_priv(dev);
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
if (!netif_running(dev))
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
del_timer_sync(&bp->timer);
|
|
|
|
|
2006-04-12 22:04:32 +00:00
|
|
|
spin_lock_irq(&bp->lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
b44_halt(bp);
|
2006-04-12 22:04:32 +00:00
|
|
|
netif_carrier_off(bp->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
netif_device_detach(bp->dev);
|
|
|
|
b44_free_rings(bp);
|
|
|
|
|
|
|
|
spin_unlock_irq(&bp->lock);
|
2005-10-28 22:14:47 +00:00
|
|
|
|
|
|
|
free_irq(dev->irq, dev);
|
2006-06-20 22:34:23 +00:00
|
|
|
if (bp->flags & B44_FLAG_WOL_ENABLE) {
|
2007-01-27 07:59:57 +00:00
|
|
|
b44_init_hw(bp, B44_PARTIAL_RESET);
|
2006-06-20 22:34:23 +00:00
|
|
|
b44_setup_wol(bp);
|
|
|
|
}
|
2007-09-19 21:20:30 +00:00
|
|
|
|
2008-01-01 00:17:54 +00:00
|
|
|
ssb_pcihost_set_power_state(sdev, PCI_D3hot);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
static int b44_resume(struct ssb_device *sdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
struct net_device *dev = ssb_get_drvdata(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct b44 *bp = netdev_priv(dev);
|
2007-01-27 08:00:03 +00:00
|
|
|
int rc = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
rc = ssb_bus_powerup(sdev->bus, 0);
|
2007-01-27 08:00:03 +00:00
|
|
|
if (rc) {
|
2007-09-19 21:20:30 +00:00
|
|
|
dev_err(sdev->dev,
|
|
|
|
"Failed to powerup the bus\n");
|
2007-01-27 08:00:03 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!netif_running(dev))
|
|
|
|
return 0;
|
|
|
|
|
2010-10-17 01:48:59 +00:00
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
b44_init_rings(bp);
|
|
|
|
b44_init_hw(bp, B44_FULL_RESET);
|
|
|
|
spin_unlock_irq(&bp->lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* As a shared interrupt, the handler can be called immediately. To be
|
|
|
|
* able to check the interrupt status the hardware must already be
|
|
|
|
* powered back on (b44_init_hw).
|
|
|
|
*/
|
2007-01-27 08:00:03 +00:00
|
|
|
rc = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
|
|
|
|
if (rc) {
|
2010-02-17 15:01:50 +00:00
|
|
|
netdev_err(dev, "request_irq failed\n");
|
2010-10-17 01:48:59 +00:00
|
|
|
spin_lock_irq(&bp->lock);
|
|
|
|
b44_halt(bp);
|
|
|
|
b44_free_rings(bp);
|
|
|
|
spin_unlock_irq(&bp->lock);
|
2007-01-27 08:00:03 +00:00
|
|
|
return rc;
|
|
|
|
}
|
2005-10-28 22:14:47 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
netif_device_attach(bp->dev);
|
|
|
|
|
|
|
|
b44_enable_ints(bp);
|
2005-11-30 21:30:23 +00:00
|
|
|
netif_wake_queue(dev);
|
2007-06-04 20:25:37 +00:00
|
|
|
|
|
|
|
mod_timer(&bp->timer, jiffies + 1);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-19 21:20:30 +00:00
|
|
|
static struct ssb_driver b44_ssb_driver = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.name = DRV_MODULE_NAME,
|
2007-09-19 21:20:30 +00:00
|
|
|
.id_table = b44_ssb_tbl,
|
2005-04-16 22:20:36 +00:00
|
|
|
.probe = b44_init_one,
|
2012-12-03 14:22:57 +00:00
|
|
|
.remove = b44_remove_one,
|
2007-09-19 21:20:30 +00:00
|
|
|
.suspend = b44_suspend,
|
|
|
|
.resume = b44_resume,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2011-06-21 18:57:16 +00:00
|
|
|
static inline int __init b44_pci_init(void)
|
2007-09-19 21:20:30 +00:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
#ifdef CONFIG_B44_PCI
|
|
|
|
err = ssb_pcihost_register(&b44_pci_driver);
|
|
|
|
#endif
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-02-19 10:47:43 +00:00
|
|
|
static inline void b44_pci_exit(void)
|
2007-09-19 21:20:30 +00:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_B44_PCI
|
|
|
|
ssb_pcihost_unregister(&b44_pci_driver);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __init b44_init(void)
|
|
|
|
{
|
2005-10-19 01:30:59 +00:00
|
|
|
unsigned int dma_desc_align_size = dma_get_cache_alignment();
|
2007-09-19 21:20:30 +00:00
|
|
|
int err;
|
2005-10-19 01:30:59 +00:00
|
|
|
|
|
|
|
/* Setup paramaters for syncing RX/TX DMA descriptors */
|
2006-01-17 17:53:56 +00:00
|
|
|
dma_desc_sync_size = max_t(unsigned int, dma_desc_align_size, sizeof(struct dma_desc));
|
2005-10-19 01:30:59 +00:00
|
|
|
|
2007-09-19 21:20:30 +00: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 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit b44_cleanup(void)
|
|
|
|
{
|
2007-09-19 21:20:30 +00:00
|
|
|
ssb_driver_unregister(&b44_ssb_driver);
|
|
|
|
b44_pci_exit();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(b44_init);
|
|
|
|
module_exit(b44_cleanup);
|
|
|
|
|