2005-04-17 06:20:36 +08:00
|
|
|
/* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
|
2012-05-18 20:56:27 +08:00
|
|
|
* driver for linux.
|
|
|
|
* Written 1996 by Russell Nelson, with reference to skeleton.c
|
|
|
|
* written 1993-1994 by Donald Becker.
|
|
|
|
*
|
|
|
|
* This software may be used and distributed according to the terms
|
|
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
|
|
*
|
|
|
|
* The author may be reached at nelson@crynwr.com, Crynwr
|
|
|
|
* Software, 521 Pleasant Valley Rd., Potsdam, NY 13676
|
|
|
|
*
|
|
|
|
* Other contributors:
|
|
|
|
* Mike Cruse : mcruse@cti-ltd.com
|
|
|
|
* Russ Nelson
|
|
|
|
* Melody Lee : ethernet@crystal.cirrus.com
|
|
|
|
* Alan Cox
|
|
|
|
* Andrew Morton
|
|
|
|
* Oskar Schirmer : oskar@scara.com
|
|
|
|
* Deepak Saxena : dsaxena@plexity.net
|
|
|
|
* Dmitry Pervushin : dpervushin@ru.mvista.com
|
|
|
|
* Deepak Saxena : dsaxena@plexity.net
|
|
|
|
* Domenico Andreoli : cavokz@gmail.com
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set this to zero to disable DMA code
|
|
|
|
*
|
|
|
|
* Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
|
|
|
|
* module options so we don't break any startup scripts.
|
|
|
|
*/
|
2006-01-12 04:17:34 +08:00
|
|
|
#ifndef CONFIG_ISA_DMA_API
|
2005-04-17 06:20:36 +08:00
|
|
|
#define ALLOW_DMA 0
|
|
|
|
#else
|
|
|
|
#define ALLOW_DMA 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set this to zero to remove all the debug statements via
|
|
|
|
* dead code elimination
|
|
|
|
*/
|
|
|
|
#define DEBUGGING 1
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
/* Sources:
|
|
|
|
* Crynwr packet driver epktisa.
|
|
|
|
* Crystal Semiconductor data sheets.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:28 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2012-01-27 04:46:15 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/printk.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
2016-06-13 23:51:05 +08:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
2012-01-27 04:46:15 +08:00
|
|
|
#include <linux/platform_device.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/in.h>
|
2014-12-14 16:34:18 +08:00
|
|
|
#include <linux/jiffies.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/delay.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 16:04:11 +08:00
|
|
|
#include <linux/gfp.h>
|
2012-05-18 20:56:29 +08:00
|
|
|
#include <linux/io.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-09-26 12:25:59 +08:00
|
|
|
#include <asm/irq.h>
|
2012-01-27 04:46:15 +08:00
|
|
|
#include <linux/atomic.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#if ALLOW_DMA
|
|
|
|
#include <asm/dma.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "cs89x0.h"
|
|
|
|
|
2012-05-18 20:56:30 +08:00
|
|
|
#define cs89_dbg(val, level, fmt, ...) \
|
|
|
|
do { \
|
|
|
|
if (val <= net_debug) \
|
|
|
|
pr_##level(fmt, ##__VA_ARGS__); \
|
|
|
|
} while (0)
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static char version[] __initdata =
|
2012-05-18 20:56:30 +08:00
|
|
|
"v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton";
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#define DRV_NAME "cs89x0"
|
|
|
|
|
|
|
|
/* First, a few definitions that the brave might change.
|
2012-05-18 20:56:27 +08:00
|
|
|
* A zero-terminated list of I/O addresses to be probed. Some special flags..
|
|
|
|
* Addr & 1 = Read back the address port, look for signature and reset
|
|
|
|
* the page window before probing
|
|
|
|
* Addr & 3 = Reset the page window and probe
|
|
|
|
* The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
|
|
|
|
* but it is possible that a Cirrus board could be plugged into the ISA
|
|
|
|
* slots.
|
|
|
|
*/
|
2006-09-14 01:24:59 +08:00
|
|
|
/* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
|
2012-05-18 20:56:27 +08:00
|
|
|
* them to system IRQ numbers. This mapping is card specific and is set to
|
|
|
|
* the configuration of the Cirrus Eval board for this chip.
|
|
|
|
*/
|
2012-01-27 04:46:15 +08:00
|
|
|
#ifndef CONFIG_CS89x0_PLATFORM
|
2012-05-18 20:56:29 +08:00
|
|
|
static unsigned int netcard_portlist[] __used __initdata = {
|
|
|
|
0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240,
|
|
|
|
0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0
|
|
|
|
};
|
|
|
|
static unsigned int cs8900_irq_map[] = {
|
|
|
|
10, 11, 12, 5
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if DEBUGGING
|
|
|
|
static unsigned int net_debug = DEBUGGING;
|
|
|
|
#else
|
|
|
|
#define net_debug 0 /* gcc will remove all the debug code for us */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* The number of low I/O ports used by the ethercard. */
|
|
|
|
#define NETCARD_IO_EXTENT 16
|
|
|
|
|
|
|
|
/* we allow the user to override various values normally set in the EEPROM */
|
|
|
|
#define FORCE_RJ45 0x0001 /* pick one of these three */
|
|
|
|
#define FORCE_AUI 0x0002
|
|
|
|
#define FORCE_BNC 0x0004
|
|
|
|
|
|
|
|
#define FORCE_AUTO 0x0010 /* pick one of these three */
|
|
|
|
#define FORCE_HALF 0x0020
|
|
|
|
#define FORCE_FULL 0x0030
|
|
|
|
|
|
|
|
/* Information that need to be kept for each board. */
|
|
|
|
struct net_local {
|
|
|
|
int chip_type; /* one of: CS8900, CS8920, CS8920M */
|
|
|
|
char chip_revision; /* revision letter of the chip ('A'...) */
|
|
|
|
int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
|
|
|
|
int auto_neg_cnf; /* auto-negotiation word from EEPROM */
|
|
|
|
int adapter_cnf; /* adapter configuration from EEPROM */
|
|
|
|
int isa_config; /* ISA configuration from EEPROM */
|
|
|
|
int irq_map; /* IRQ map from EEPROM */
|
|
|
|
int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
|
|
|
|
int curr_rx_cfg; /* a copy of PP_RxCFG */
|
|
|
|
int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
|
|
|
|
int send_underrun; /* keep track of how many underruns in a row we get */
|
|
|
|
int force; /* force various values; see FORCE* above. */
|
|
|
|
spinlock_t lock;
|
2012-05-17 15:11:42 +08:00
|
|
|
void __iomem *virt_addr;/* CS89x0 virtual address. */
|
2005-04-17 06:20:36 +08:00
|
|
|
#if ALLOW_DMA
|
|
|
|
int use_dma; /* Flag: we're using dma */
|
|
|
|
int dma; /* DMA channel */
|
|
|
|
int dmasize; /* 16 or 64 */
|
|
|
|
unsigned char *dma_buff; /* points to the beginning of the buffer */
|
|
|
|
unsigned char *end_dma_buff; /* points to the end of the buffer */
|
|
|
|
unsigned char *rx_dma_ptr; /* points to the next packet */
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Example routines you must write ;->. */
|
|
|
|
#define tx_done(dev) 1
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Permit 'cs89x0_dma=N' in the kernel boot environment
|
|
|
|
*/
|
2012-05-17 15:11:42 +08:00
|
|
|
#if !defined(MODULE)
|
|
|
|
#if ALLOW_DMA
|
2005-04-17 06:20:36 +08:00
|
|
|
static int g_cs89x0_dma;
|
|
|
|
|
|
|
|
static int __init dma_fn(char *str)
|
|
|
|
{
|
2012-05-18 20:56:27 +08:00
|
|
|
g_cs89x0_dma = simple_strtol(str, NULL, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("cs89x0_dma=", dma_fn);
|
2012-05-17 15:11:42 +08:00
|
|
|
#endif /* ALLOW_DMA */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static int g_cs89x0_media__force;
|
|
|
|
|
|
|
|
static int __init media_fn(char *str)
|
|
|
|
{
|
2012-05-18 20:56:29 +08:00
|
|
|
if (!strcmp(str, "rj45"))
|
|
|
|
g_cs89x0_media__force = FORCE_RJ45;
|
|
|
|
else if (!strcmp(str, "aui"))
|
|
|
|
g_cs89x0_media__force = FORCE_AUI;
|
|
|
|
else if (!strcmp(str, "bnc"))
|
|
|
|
g_cs89x0_media__force = FORCE_BNC;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("cs89x0_media=", media_fn);
|
2012-01-27 04:46:15 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-17 15:11:42 +08:00
|
|
|
static void readwords(struct net_local *lp, int portno, void *buf, int length)
|
2006-01-08 17:01:12 +08:00
|
|
|
{
|
|
|
|
u8 *buf8 = (u8 *)buf;
|
|
|
|
|
|
|
|
do {
|
2006-01-15 05:21:17 +08:00
|
|
|
u16 tmp16;
|
2006-01-08 17:01:12 +08:00
|
|
|
|
2012-05-17 15:11:42 +08:00
|
|
|
tmp16 = ioread16(lp->virt_addr + portno);
|
2006-01-15 05:21:17 +08:00
|
|
|
*buf8++ = (u8)tmp16;
|
|
|
|
*buf8++ = (u8)(tmp16 >> 8);
|
2006-01-08 17:01:12 +08:00
|
|
|
} while (--length);
|
|
|
|
}
|
|
|
|
|
2012-05-17 15:11:42 +08:00
|
|
|
static void writewords(struct net_local *lp, int portno, void *buf, int length)
|
2006-01-08 17:01:12 +08:00
|
|
|
{
|
|
|
|
u8 *buf8 = (u8 *)buf;
|
|
|
|
|
|
|
|
do {
|
2006-01-15 05:21:17 +08:00
|
|
|
u16 tmp16;
|
2006-01-08 17:01:12 +08:00
|
|
|
|
2006-01-15 05:21:17 +08:00
|
|
|
tmp16 = *buf8++;
|
|
|
|
tmp16 |= (*buf8++) << 8;
|
2012-05-17 15:11:42 +08:00
|
|
|
iowrite16(tmp16, lp->virt_addr + portno);
|
2006-01-08 17:01:12 +08:00
|
|
|
} while (--length);
|
|
|
|
}
|
|
|
|
|
2006-01-15 05:21:17 +08:00
|
|
|
static u16
|
|
|
|
readreg(struct net_device *dev, u16 regno)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-17 15:11:42 +08:00
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
|
|
|
|
iowrite16(regno, lp->virt_addr + ADD_PORT);
|
|
|
|
return ioread16(lp->virt_addr + DATA_PORT);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-01-15 05:21:17 +08:00
|
|
|
writereg(struct net_device *dev, u16 regno, u16 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-17 15:11:42 +08:00
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
|
|
|
|
iowrite16(regno, lp->virt_addr + ADD_PORT);
|
|
|
|
iowrite16(value, lp->virt_addr + DATA_PORT);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init
|
|
|
|
wait_eeprom_ready(struct net_device *dev)
|
|
|
|
{
|
2014-12-14 16:34:18 +08:00
|
|
|
unsigned long timeout = jiffies;
|
2012-05-18 20:56:27 +08:00
|
|
|
/* check to see if the EEPROM is ready,
|
|
|
|
* a timeout is used just in case EEPROM is ready when
|
|
|
|
* SI_BUSY in the PP_SelfST is clear
|
|
|
|
*/
|
|
|
|
while (readreg(dev, PP_SelfST) & SI_BUSY)
|
2014-12-14 16:34:18 +08:00
|
|
|
if (time_after_eq(jiffies, timeout + 40))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init
|
|
|
|
get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(3, info, "EEPROM data from %x for %x:", off, len);
|
2005-04-17 06:20:36 +08:00
|
|
|
for (i = 0; i < len; i++) {
|
2012-05-18 20:56:29 +08:00
|
|
|
if (wait_eeprom_ready(dev) < 0)
|
|
|
|
return -1;
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Now send the EEPROM read command and EEPROM location to read */
|
|
|
|
writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
|
2012-05-18 20:56:29 +08:00
|
|
|
if (wait_eeprom_ready(dev) < 0)
|
|
|
|
return -1;
|
2005-04-17 06:20:36 +08:00
|
|
|
buffer[i] = readreg(dev, PP_EEData);
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(3, cont, " %04x", buffer[i]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:30 +08:00
|
|
|
cs89_dbg(3, cont, "\n");
|
2012-05-18 20:56:27 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init
|
|
|
|
get_eeprom_cksum(int off, int len, int *buffer)
|
|
|
|
{
|
|
|
|
int i, cksum;
|
|
|
|
|
|
|
|
cksum = 0;
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
cksum += buffer[i];
|
|
|
|
cksum &= 0xffff;
|
|
|
|
if (cksum == 0)
|
|
|
|
return 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void
|
|
|
|
write_irq(struct net_device *dev, int chip_type, int irq)
|
2005-09-10 04:02:07 +08:00
|
|
|
{
|
2012-05-18 20:56:31 +08:00
|
|
|
int i;
|
2005-09-10 04:02:07 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (chip_type == CS8900) {
|
|
|
|
#ifndef CONFIG_CS89x0_PLATFORM
|
|
|
|
/* Search the mapping table for the corresponding IRQ pin. */
|
|
|
|
for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
|
|
|
|
if (cs8900_irq_map[i] == irq)
|
|
|
|
break;
|
|
|
|
/* Not found */
|
|
|
|
if (i == ARRAY_SIZE(cs8900_irq_map))
|
|
|
|
i = 3;
|
|
|
|
#else
|
|
|
|
/* INTRQ0 pin is used for interrupt generation. */
|
|
|
|
i = 0;
|
2009-03-26 23:11:43 +08:00
|
|
|
#endif
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_CS8900_ISAINT, i);
|
|
|
|
} else {
|
|
|
|
writereg(dev, PP_CS8920_ISAINT, irq);
|
|
|
|
}
|
|
|
|
}
|
2009-03-26 23:11:43 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void
|
|
|
|
count_rx_errors(int status, struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-18 20:56:31 +08:00
|
|
|
dev->stats.rx_errors++;
|
|
|
|
if (status & RX_RUNT)
|
|
|
|
dev->stats.rx_length_errors++;
|
|
|
|
if (status & RX_EXTRA_DATA)
|
|
|
|
dev->stats.rx_length_errors++;
|
|
|
|
if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA | RX_RUNT)))
|
|
|
|
/* per str 172 */
|
|
|
|
dev->stats.rx_crc_errors++;
|
|
|
|
if (status & RX_DRIBBLE)
|
|
|
|
dev->stats.rx_frame_errors++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
* This page contains DMA routines
|
|
|
|
*********************************/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#if ALLOW_DMA
|
2012-05-18 20:56:31 +08:00
|
|
|
|
|
|
|
#define dma_page_eq(ptr1, ptr2) ((long)(ptr1) >> 17 == (long)(ptr2) >> 17)
|
|
|
|
|
|
|
|
static void
|
|
|
|
get_dma_channel(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (lp->dma) {
|
|
|
|
dev->dma = lp->dma;
|
|
|
|
lp->isa_config |= ISA_RxDMA;
|
|
|
|
} else {
|
|
|
|
if ((lp->isa_config & ANY_ISA_DMA) == 0)
|
|
|
|
return;
|
|
|
|
dev->dma = lp->isa_config & DMA_NO_MASK;
|
|
|
|
if (lp->chip_type == CS8900)
|
|
|
|
dev->dma += 5;
|
|
|
|
if (dev->dma < 5 || dev->dma > 7) {
|
|
|
|
lp->isa_config &= ~ANY_ISA_DMA;
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:27 +08:00
|
|
|
}
|
2012-05-18 20:56:31 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void
|
|
|
|
write_dma(struct net_device *dev, int chip_type, int dma)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
if ((lp->isa_config & ANY_ISA_DMA) == 0)
|
|
|
|
return;
|
|
|
|
if (chip_type == CS8900)
|
|
|
|
writereg(dev, PP_CS8900_ISADMA, dma - 5);
|
|
|
|
else
|
|
|
|
writereg(dev, PP_CS8920_ISADMA, dma);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void
|
|
|
|
set_dma_cfg(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (lp->use_dma) {
|
|
|
|
if ((lp->isa_config & ANY_ISA_DMA) == 0) {
|
|
|
|
cs89_dbg(3, err, "set_dma_cfg(): no DMA\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (lp->isa_config & ISA_RxDMA) {
|
|
|
|
lp->curr_rx_cfg |= RX_DMA_ONLY;
|
|
|
|
cs89_dbg(3, info, "set_dma_cfg(): RX_DMA_ONLY\n");
|
|
|
|
} else {
|
|
|
|
lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
|
|
|
|
cs89_dbg(3, info, "set_dma_cfg(): AUTO_RX_DMA\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static int
|
|
|
|
dma_bufcfg(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
if (lp->use_dma)
|
|
|
|
return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static int
|
|
|
|
dma_busctl(struct net_device *dev)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
if (lp->use_dma) {
|
|
|
|
if (lp->isa_config & ANY_ISA_DMA)
|
|
|
|
retval |= RESET_RX_DMA; /* Reset the DMA pointer */
|
|
|
|
if (lp->isa_config & DMA_BURST)
|
|
|
|
retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
|
|
|
|
if (lp->dmasize == 64)
|
|
|
|
retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
|
|
|
|
retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void
|
|
|
|
dma_rx(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int status, length;
|
|
|
|
unsigned char *bp = lp->rx_dma_ptr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
status = bp[0] + (bp[1] << 8);
|
|
|
|
length = bp[2] + (bp[3] << 8);
|
|
|
|
bp += 4;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n",
|
|
|
|
dev->name, (unsigned long)bp, status, length);
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if ((status & RX_OK) == 0) {
|
|
|
|
count_rx_errors(status, dev);
|
|
|
|
goto skip_this_frame;
|
|
|
|
}
|
2012-05-18 20:56:27 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* Malloc up new buffer. */
|
|
|
|
skb = netdev_alloc_skb(dev, length + 2);
|
|
|
|
if (skb == NULL) {
|
|
|
|
dev->stats.rx_dropped++;
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* AKPM: advance bp to the next frame */
|
|
|
|
skip_this_frame:
|
|
|
|
bp += (length + 3) & ~3;
|
|
|
|
if (bp >= lp->end_dma_buff)
|
|
|
|
bp -= lp->dmasize * 1024;
|
|
|
|
lp->rx_dma_ptr = bp;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
skb_reserve(skb, 2); /* longword align L3 header */
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (bp + length > lp->end_dma_buff) {
|
|
|
|
int semi_cnt = lp->end_dma_buff - bp;
|
networking: introduce and use skb_put_data()
A common pattern with skb_put() is to just want to memcpy()
some data into the new space, introduce skb_put_data() for
this.
An spatch similar to the one for skb_put_zero() converts many
of the places using it:
@@
identifier p, p2;
expression len, skb, data;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_data(skb, data, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_data(skb, data, len);
)
(
p2 = (t2)p;
-memcpy(p2, data, len);
|
-memcpy(p, data, len);
)
@@
type t, t2;
identifier p, p2;
expression skb, data;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
)
(
p2 = (t2)p;
-memcpy(p2, data, sizeof(*p));
|
-memcpy(p, data, sizeof(*p));
)
@@
expression skb, len, data;
@@
-memcpy(skb_put(skb, len), data, len);
+skb_put_data(skb, data, len);
(again, manually post-processed to retain some comments)
Reviewed-by: Stephen Hemminger <stephen@networkplumber.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 20:29:20 +08:00
|
|
|
skb_put_data(skb, bp, semi_cnt);
|
|
|
|
skb_put_data(skb, lp->dma_buff, length - semi_cnt);
|
2012-05-18 20:56:27 +08:00
|
|
|
} else {
|
networking: introduce and use skb_put_data()
A common pattern with skb_put() is to just want to memcpy()
some data into the new space, introduce skb_put_data() for
this.
An spatch similar to the one for skb_put_zero() converts many
of the places using it:
@@
identifier p, p2;
expression len, skb, data;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_data(skb, data, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_data(skb, data, len);
)
(
p2 = (t2)p;
-memcpy(p2, data, len);
|
-memcpy(p, data, len);
)
@@
type t, t2;
identifier p, p2;
expression skb, data;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
)
(
p2 = (t2)p;
-memcpy(p2, data, sizeof(*p));
|
-memcpy(p, data, sizeof(*p));
)
@@
expression skb, len, data;
@@
-memcpy(skb_put(skb, len), data, len);
+skb_put_data(skb, data, len);
(again, manually post-processed to retain some comments)
Reviewed-by: Stephen Hemminger <stephen@networkplumber.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 20:29:20 +08:00
|
|
|
skb_put_data(skb, bp, length);
|
2012-05-18 20:56:27 +08:00
|
|
|
}
|
2012-05-18 20:56:31 +08:00
|
|
|
bp += (length + 3) & ~3;
|
|
|
|
if (bp >= lp->end_dma_buff)
|
|
|
|
bp -= lp->dmasize*1024;
|
|
|
|
lp->rx_dma_ptr = bp;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(3, info, "%s: received %d byte DMA packet of type %x\n",
|
|
|
|
dev->name, length,
|
|
|
|
((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
|
|
|
|
skb->data[ETH_ALEN + ETH_ALEN + 1]));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
skb->protocol = eth_type_trans(skb, dev);
|
|
|
|
netif_rx(skb);
|
|
|
|
dev->stats.rx_packets++;
|
|
|
|
dev->stats.rx_bytes += length;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void release_dma_buff(struct net_local *lp)
|
|
|
|
{
|
|
|
|
if (lp->dma_buff) {
|
|
|
|
free_pages((unsigned long)(lp->dma_buff),
|
|
|
|
get_order(lp->dmasize * 1024));
|
|
|
|
lp->dma_buff = NULL;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
#endif /* ALLOW_DMA */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void
|
|
|
|
control_dc_dc(struct net_device *dev, int on_not_off)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
unsigned int selfcontrol;
|
2014-12-14 16:34:18 +08:00
|
|
|
unsigned long timenow = jiffies;
|
2012-05-18 20:56:31 +08:00
|
|
|
/* control the DC to DC convertor in the SelfControl register.
|
|
|
|
* Note: This is hooked up to a general purpose pin, might not
|
|
|
|
* always be a DC to DC convertor.
|
2012-05-18 20:56:27 +08:00
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
|
|
|
|
if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
|
|
|
|
selfcontrol |= HCB1;
|
|
|
|
else
|
|
|
|
selfcontrol &= ~HCB1;
|
|
|
|
writereg(dev, PP_SelfCTL, selfcontrol);
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* Wait for the DC/DC converter to power up - 500ms */
|
2014-12-14 16:34:18 +08:00
|
|
|
while (time_before(jiffies, timenow + HZ))
|
2012-05-18 20:56:31 +08:00
|
|
|
;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* send a test packet - return true if carrier bits are ok */
|
|
|
|
static int
|
|
|
|
send_test_pkt(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
char test_packet[] = {
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 46, /* A 46 in network order */
|
|
|
|
0, 0, /* DSAP=0 & SSAP=0 fields */
|
|
|
|
0xf3, 0 /* Control (Test Req + P bit set) */
|
|
|
|
};
|
2014-12-14 16:34:18 +08:00
|
|
|
unsigned long timenow = jiffies;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
memcpy(test_packet, dev->dev_addr, ETH_ALEN);
|
|
|
|
memcpy(test_packet + ETH_ALEN, dev->dev_addr, ETH_ALEN);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
iowrite16(TX_AFTER_ALL, lp->virt_addr + TX_CMD_PORT);
|
|
|
|
iowrite16(ETH_ZLEN, lp->virt_addr + TX_LEN_PORT);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* Test to see if the chip has allocated memory for the packet */
|
2014-12-14 16:34:18 +08:00
|
|
|
while (time_before(jiffies, timenow + 5))
|
2012-05-18 20:56:31 +08:00
|
|
|
if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
|
|
|
|
break;
|
2014-12-14 16:34:18 +08:00
|
|
|
if (time_after_eq(jiffies, timenow + 5))
|
2012-05-18 20:56:31 +08:00
|
|
|
return 0; /* this shouldn't happen */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* Write the contents of the packet */
|
|
|
|
writewords(lp, TX_FRAME_PORT, test_packet, (ETH_ZLEN + 1) >> 1);
|
2005-05-13 08:11:55 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(1, debug, "Sending test packet ");
|
|
|
|
/* wait a couple of jiffies for packet to be received */
|
2014-12-14 16:34:18 +08:00
|
|
|
for (timenow = jiffies; time_before(jiffies, timenow + 3);)
|
2012-05-18 20:56:31 +08:00
|
|
|
;
|
|
|
|
if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
|
|
|
|
cs89_dbg(1, cont, "succeeded\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
cs89_dbg(1, cont, "failed\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
#define DETECTED_NONE 0
|
|
|
|
#define DETECTED_RJ45H 1
|
|
|
|
#define DETECTED_RJ45F 2
|
|
|
|
#define DETECTED_AUI 3
|
|
|
|
#define DETECTED_BNC 4
|
|
|
|
|
|
|
|
static int
|
|
|
|
detect_tp(struct net_device *dev)
|
2012-05-17 15:11:42 +08:00
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
2014-12-14 16:34:18 +08:00
|
|
|
unsigned long timenow = jiffies;
|
2012-05-18 20:56:31 +08:00
|
|
|
int fdx;
|
2012-05-17 15:11:42 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(1, debug, "%s: Attempting TP\n", dev->name);
|
2012-05-17 15:11:42 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* If connected to another full duplex capable 10-Base-T card
|
|
|
|
* the link pulses seem to be lost when the auto detect bit in
|
|
|
|
* the LineCTL is set. To overcome this the auto detect bit will
|
|
|
|
* be cleared whilst testing the 10-Base-T interface. This would
|
|
|
|
* not be necessary for the sparrow chip but is simpler to do it
|
|
|
|
* anyway.
|
2012-05-18 20:56:27 +08:00
|
|
|
*/
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_LineCTL, lp->linectl & ~AUI_ONLY);
|
|
|
|
control_dc_dc(dev, 0);
|
2012-05-17 15:11:42 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* Delay for the hardware to work out if the TP cable is present
|
|
|
|
* - 150ms
|
|
|
|
*/
|
2014-12-14 16:34:18 +08:00
|
|
|
for (timenow = jiffies; time_before(jiffies, timenow + 15);)
|
2012-05-18 20:56:31 +08:00
|
|
|
;
|
|
|
|
if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
|
|
|
|
return DETECTED_NONE;
|
2012-05-17 15:11:42 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (lp->chip_type == CS8900) {
|
|
|
|
switch (lp->force & 0xf0) {
|
|
|
|
#if 0
|
|
|
|
case FORCE_AUTO:
|
|
|
|
pr_info("%s: cs8900 doesn't autonegotiate\n",
|
|
|
|
dev->name);
|
|
|
|
return DETECTED_NONE;
|
|
|
|
#endif
|
|
|
|
/* CS8900 doesn't support AUTO, change to HALF*/
|
|
|
|
case FORCE_AUTO:
|
|
|
|
lp->force &= ~FORCE_AUTO;
|
|
|
|
lp->force |= FORCE_HALF;
|
|
|
|
break;
|
|
|
|
case FORCE_HALF:
|
|
|
|
break;
|
|
|
|
case FORCE_FULL:
|
|
|
|
writereg(dev, PP_TestCTL,
|
|
|
|
readreg(dev, PP_TestCTL) | FDX_8900);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
fdx = readreg(dev, PP_TestCTL) & FDX_8900;
|
2012-05-17 15:11:42 +08:00
|
|
|
} else {
|
2012-05-18 20:56:31 +08:00
|
|
|
switch (lp->force & 0xf0) {
|
|
|
|
case FORCE_AUTO:
|
|
|
|
lp->auto_neg_cnf = AUTO_NEG_ENABLE;
|
|
|
|
break;
|
|
|
|
case FORCE_HALF:
|
|
|
|
lp->auto_neg_cnf = 0;
|
|
|
|
break;
|
|
|
|
case FORCE_FULL:
|
|
|
|
lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
|
|
|
|
break;
|
2012-05-17 15:11:42 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
|
|
|
|
pr_info("%s: negotiating duplex...\n", dev->name);
|
|
|
|
while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
|
2014-12-14 16:34:18 +08:00
|
|
|
if (time_after(jiffies, timenow + 4000)) {
|
2012-05-18 20:56:31 +08:00
|
|
|
pr_err("**** Full / half duplex auto-negotiation timed out ****\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:31 +08:00
|
|
|
fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:31 +08:00
|
|
|
if (fdx)
|
|
|
|
return DETECTED_RJ45F;
|
2012-05-18 20:56:29 +08:00
|
|
|
else
|
2012-05-18 20:56:31 +08:00
|
|
|
return DETECTED_RJ45H;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static int
|
|
|
|
detect_bnc(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(1, debug, "%s: Attempting BNC\n", dev->name);
|
|
|
|
control_dc_dc(dev, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
|
|
|
|
|
|
|
|
if (send_test_pkt(dev))
|
|
|
|
return DETECTED_BNC;
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2012-05-18 20:56:31 +08:00
|
|
|
return DETECTED_NONE;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2012-05-18 20:56:31 +08:00
|
|
|
detect_aui(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
2012-05-18 20:56:31 +08:00
|
|
|
|
|
|
|
cs89_dbg(1, debug, "%s: Attempting AUI\n", dev->name);
|
|
|
|
control_dc_dc(dev, 0);
|
|
|
|
|
|
|
|
writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
|
|
|
|
|
|
|
|
if (send_test_pkt(dev))
|
|
|
|
return DETECTED_AUI;
|
|
|
|
else
|
|
|
|
return DETECTED_NONE;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* We have a good packet(s), get it/them out of the buffers. */
|
2005-04-17 06:20:36 +08:00
|
|
|
static void
|
2012-05-18 20:56:31 +08:00
|
|
|
net_rx(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int status, length;
|
2012-05-18 20:56:30 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
status = ioread16(lp->virt_addr + RX_FRAME_PORT);
|
|
|
|
length = ioread16(lp->virt_addr + RX_FRAME_PORT);
|
2012-05-18 20:56:30 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((status & RX_OK) == 0) {
|
2010-07-05 10:13:15 +08:00
|
|
|
count_rx_errors(status, dev);
|
2012-05-18 20:56:31 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Malloc up new buffer. */
|
2012-02-05 10:50:10 +08:00
|
|
|
skb = netdev_alloc_skb(dev, length + 2);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (skb == NULL) {
|
2010-07-05 10:13:15 +08:00
|
|
|
dev->stats.rx_dropped++;
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
skb_reserve(skb, 2); /* longword align L3 header */
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
|
|
|
|
if (length & 1)
|
|
|
|
skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(3, debug, "%s: received %d byte packet of type %x\n",
|
2012-05-18 20:56:30 +08:00
|
|
|
dev->name, length,
|
2012-05-18 20:56:31 +08:00
|
|
|
(skb->data[ETH_ALEN + ETH_ALEN] << 8) |
|
|
|
|
skb->data[ETH_ALEN + ETH_ALEN + 1]);
|
2012-05-18 20:56:30 +08:00
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
skb->protocol = eth_type_trans(skb, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
netif_rx(skb);
|
2010-07-05 10:13:15 +08:00
|
|
|
dev->stats.rx_packets++;
|
|
|
|
dev->stats.rx_bytes += length;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* The typical workload of the driver:
|
|
|
|
* Handle the network interface interrupts.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static irqreturn_t net_interrupt(int irq, void *dev_id)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-18 20:56:31 +08:00
|
|
|
struct net_device *dev = dev_id;
|
|
|
|
struct net_local *lp;
|
|
|
|
int status;
|
|
|
|
int handled = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
lp = netdev_priv(dev);
|
2012-05-17 15:11:42 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* we MUST read all the events out of the ISQ, otherwise we'll never
|
|
|
|
* get interrupted again. As a consequence, we can't have any limit
|
|
|
|
* on the number of times we loop in the interrupt handler. The
|
|
|
|
* hardware guarantees that eventually we'll run out of events. Of
|
|
|
|
* course, if you're on a slow machine, and packets are arriving
|
|
|
|
* faster than you can read them off, you're screwed. Hasta la
|
|
|
|
* vista, baby!
|
|
|
|
*/
|
|
|
|
while ((status = ioread16(lp->virt_addr + ISQ_PORT))) {
|
|
|
|
cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status);
|
|
|
|
handled = 1;
|
|
|
|
switch (status & ISQ_EVENT_MASK) {
|
|
|
|
case ISQ_RECEIVER_EVENT:
|
|
|
|
/* Got a packet(s). */
|
|
|
|
net_rx(dev);
|
|
|
|
break;
|
|
|
|
case ISQ_TRANSMITTER_EVENT:
|
|
|
|
dev->stats.tx_packets++;
|
|
|
|
netif_wake_queue(dev); /* Inform upper layers. */
|
|
|
|
if ((status & (TX_OK |
|
|
|
|
TX_LOST_CRS |
|
|
|
|
TX_SQE_ERROR |
|
|
|
|
TX_LATE_COL |
|
|
|
|
TX_16_COL)) != TX_OK) {
|
|
|
|
if ((status & TX_OK) == 0)
|
|
|
|
dev->stats.tx_errors++;
|
|
|
|
if (status & TX_LOST_CRS)
|
|
|
|
dev->stats.tx_carrier_errors++;
|
|
|
|
if (status & TX_SQE_ERROR)
|
|
|
|
dev->stats.tx_heartbeat_errors++;
|
|
|
|
if (status & TX_LATE_COL)
|
|
|
|
dev->stats.tx_window_errors++;
|
|
|
|
if (status & TX_16_COL)
|
|
|
|
dev->stats.tx_aborted_errors++;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ISQ_BUFFER_EVENT:
|
|
|
|
if (status & READY_FOR_TX) {
|
|
|
|
/* we tried to transmit a packet earlier,
|
|
|
|
* but inexplicably ran out of buffers.
|
|
|
|
* That shouldn't happen since we only ever
|
|
|
|
* load one packet. Shrug. Do the right
|
|
|
|
* thing anyway.
|
|
|
|
*/
|
|
|
|
netif_wake_queue(dev); /* Inform upper layers. */
|
|
|
|
}
|
|
|
|
if (status & TX_UNDERRUN) {
|
|
|
|
cs89_dbg(0, err, "%s: transmit underrun\n",
|
|
|
|
dev->name);
|
|
|
|
lp->send_underrun++;
|
|
|
|
if (lp->send_underrun == 3)
|
|
|
|
lp->send_cmd = TX_AFTER_381;
|
|
|
|
else if (lp->send_underrun == 6)
|
|
|
|
lp->send_cmd = TX_AFTER_ALL;
|
|
|
|
/* transmit cycle is done, although
|
|
|
|
* frame wasn't transmitted - this
|
|
|
|
* avoids having to wait for the upper
|
|
|
|
* layers to timeout on us, in the
|
|
|
|
* event of a tx underrun
|
|
|
|
*/
|
|
|
|
netif_wake_queue(dev); /* Inform upper layers. */
|
|
|
|
}
|
|
|
|
#if ALLOW_DMA
|
|
|
|
if (lp->use_dma && (status & RX_DMA)) {
|
|
|
|
int count = readreg(dev, PP_DmaFrameCnt);
|
|
|
|
while (count) {
|
|
|
|
cs89_dbg(5, debug,
|
|
|
|
"%s: receiving %d DMA frames\n",
|
|
|
|
dev->name, count);
|
|
|
|
if (count > 1)
|
|
|
|
cs89_dbg(2, debug,
|
|
|
|
"%s: receiving %d DMA frames\n",
|
|
|
|
dev->name, count);
|
|
|
|
dma_rx(dev);
|
|
|
|
if (--count == 0)
|
|
|
|
count = readreg(dev, PP_DmaFrameCnt);
|
|
|
|
if (count > 0)
|
|
|
|
cs89_dbg(2, debug,
|
|
|
|
"%s: continuing with %d DMA frames\n",
|
|
|
|
dev->name, count);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
case ISQ_RX_MISS_EVENT:
|
|
|
|
dev->stats.rx_missed_errors += (status >> 6);
|
|
|
|
break;
|
|
|
|
case ISQ_TX_COL_EVENT:
|
|
|
|
dev->stats.collisions += (status >> 6);
|
|
|
|
break;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:31 +08:00
|
|
|
return IRQ_RETVAL(handled);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* Open/initialize the board. This is called (in the current kernel)
|
|
|
|
sometime after booting when the 'ifconfig' program is run.
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
This routine should set everything up anew at each open, even
|
|
|
|
registers that "should" only need to be set once at boot, so that
|
|
|
|
there is non-reboot way to recover if something goes wrong.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* AKPM: do we need to do any locking here? */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static int
|
2012-05-18 20:56:31 +08:00
|
|
|
net_open(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
2012-05-18 20:56:31 +08:00
|
|
|
int result = 0;
|
|
|
|
int i;
|
|
|
|
int ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (dev->irq < 2) {
|
|
|
|
/* Allow interrupts to be generated by the chip */
|
|
|
|
/* Cirrus' release had this: */
|
2005-04-17 06:20:36 +08:00
|
|
|
#if 0
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
/* And 2.3.47 had this: */
|
|
|
|
writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
|
|
|
|
|
|
|
|
for (i = 2; i < CS8920_NO_INTS; i++) {
|
|
|
|
if ((1 << i) & lp->irq_map) {
|
2012-05-18 20:56:29 +08:00
|
|
|
if (request_irq(i, net_interrupt, 0, dev->name,
|
|
|
|
dev) == 0) {
|
2005-04-17 06:20:36 +08:00
|
|
|
dev->irq = i;
|
|
|
|
write_irq(dev, lp->chip_type, i);
|
|
|
|
/* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i >= CS8920_NO_INTS) {
|
|
|
|
writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("can't get an interrupt\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = -EAGAIN;
|
|
|
|
goto bad_out;
|
|
|
|
}
|
2012-05-18 20:56:29 +08:00
|
|
|
} else {
|
2013-03-29 08:51:30 +08:00
|
|
|
#if !defined(CONFIG_CS89x0_PLATFORM)
|
2005-04-17 06:20:36 +08:00
|
|
|
if (((1 << dev->irq) & lp->irq_map) == 0) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
|
2012-05-18 20:56:27 +08:00
|
|
|
dev->name, dev->irq, lp->irq_map);
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = -EAGAIN;
|
|
|
|
goto bad_out;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* FIXME: Cirrus' release had this: */
|
2012-05-18 20:56:27 +08:00
|
|
|
writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* And 2.3.47 had this: */
|
|
|
|
#if 0
|
|
|
|
writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
|
|
|
|
#endif
|
|
|
|
write_irq(dev, lp->chip_type, dev->irq);
|
2009-11-19 15:29:17 +08:00
|
|
|
ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("request_irq(%d) failed\n", dev->irq);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto bad_out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ALLOW_DMA
|
2012-05-18 20:56:29 +08:00
|
|
|
if (lp->use_dma && (lp->isa_config & ANY_ISA_DMA)) {
|
|
|
|
unsigned long flags;
|
|
|
|
lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
|
|
|
|
get_order(lp->dmasize * 1024));
|
|
|
|
if (!lp->dma_buff) {
|
|
|
|
pr_err("%s: cannot get %dK memory for DMA\n",
|
|
|
|
dev->name, lp->dmasize);
|
|
|
|
goto release_irq;
|
|
|
|
}
|
2012-05-18 20:56:30 +08:00
|
|
|
cs89_dbg(1, debug, "%s: dma %lx %lx\n",
|
|
|
|
dev->name,
|
|
|
|
(unsigned long)lp->dma_buff,
|
|
|
|
(unsigned long)isa_virt_to_bus(lp->dma_buff));
|
2012-05-18 20:56:29 +08:00
|
|
|
if ((unsigned long)lp->dma_buff >= MAX_DMA_ADDRESS ||
|
|
|
|
!dma_page_eq(lp->dma_buff,
|
|
|
|
lp->dma_buff + lp->dmasize * 1024 - 1)) {
|
|
|
|
pr_err("%s: not usable as DMA buffer\n", dev->name);
|
|
|
|
goto release_irq;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:29 +08:00
|
|
|
memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
|
|
|
|
if (request_dma(dev->dma, dev->name)) {
|
|
|
|
pr_err("%s: cannot get dma channel %d\n",
|
|
|
|
dev->name, dev->dma);
|
|
|
|
goto release_irq;
|
|
|
|
}
|
|
|
|
write_dma(dev, lp->chip_type, dev->dma);
|
|
|
|
lp->rx_dma_ptr = lp->dma_buff;
|
|
|
|
lp->end_dma_buff = lp->dma_buff + lp->dmasize * 1024;
|
|
|
|
spin_lock_irqsave(&lp->lock, flags);
|
|
|
|
disable_dma(dev->dma);
|
|
|
|
clear_dma_ff(dev->dma);
|
|
|
|
set_dma_mode(dev->dma, DMA_RX_MODE); /* auto_init as well */
|
|
|
|
set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
|
|
|
|
set_dma_count(dev->dma, lp->dmasize * 1024);
|
|
|
|
enable_dma(dev->dma);
|
|
|
|
spin_unlock_irqrestore(&lp->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#endif /* ALLOW_DMA */
|
|
|
|
|
|
|
|
/* set the Ethernet address */
|
2012-05-18 20:56:27 +08:00
|
|
|
for (i = 0; i < ETH_ALEN / 2; i++)
|
2012-05-18 20:56:29 +08:00
|
|
|
writereg(dev, PP_IA + i * 2,
|
|
|
|
(dev->dev_addr[i * 2] |
|
|
|
|
(dev->dev_addr[i * 2 + 1] << 8)));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* while we're testing the interface, leave interrupts disabled */
|
|
|
|
writereg(dev, PP_BusCTL, MEMORY_ON);
|
|
|
|
|
|
|
|
/* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
|
2012-05-18 20:56:29 +08:00
|
|
|
if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) &&
|
|
|
|
(lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
|
2012-05-18 20:56:27 +08:00
|
|
|
lp->linectl = LOW_RX_SQUELCH;
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2012-05-18 20:56:27 +08:00
|
|
|
lp->linectl = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
/* check to make sure that they have the "right" hardware available */
|
|
|
|
switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
|
2012-05-18 20:56:29 +08:00
|
|
|
case A_CNF_MEDIA_10B_T:
|
|
|
|
result = lp->adapter_cnf & A_CNF_10B_T;
|
|
|
|
break;
|
|
|
|
case A_CNF_MEDIA_AUI:
|
|
|
|
result = lp->adapter_cnf & A_CNF_AUI;
|
|
|
|
break;
|
|
|
|
case A_CNF_MEDIA_10B_2:
|
|
|
|
result = lp->adapter_cnf & A_CNF_10B_2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result = lp->adapter_cnf & (A_CNF_10B_T |
|
|
|
|
A_CNF_AUI |
|
|
|
|
A_CNF_10B_2);
|
2012-05-18 20:56:27 +08:00
|
|
|
}
|
|
|
|
if (!result) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("%s: EEPROM is configured for unavailable media\n",
|
|
|
|
dev->name);
|
2008-05-30 11:18:55 +08:00
|
|
|
release_dma:
|
|
|
|
#if ALLOW_DMA
|
|
|
|
free_dma(dev->dma);
|
|
|
|
release_irq:
|
2005-04-17 06:20:36 +08:00
|
|
|
release_dma_buff(lp);
|
|
|
|
#endif
|
2012-05-18 20:56:29 +08:00
|
|
|
writereg(dev, PP_LineCTL,
|
|
|
|
readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
|
2012-05-18 20:56:27 +08:00
|
|
|
free_irq(dev->irq, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = -EAGAIN;
|
|
|
|
goto bad_out;
|
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
/* set the hardware to the configured choice */
|
|
|
|
switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
|
2005-04-17 06:20:36 +08:00
|
|
|
case A_CNF_MEDIA_10B_T:
|
2012-05-18 20:56:27 +08:00
|
|
|
result = detect_tp(dev);
|
|
|
|
if (result == DETECTED_NONE) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_warn("%s: 10Base-T (RJ-45) has no cable\n",
|
|
|
|
dev->name);
|
2012-05-18 20:56:27 +08:00
|
|
|
if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
|
|
|
|
result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case A_CNF_MEDIA_AUI:
|
2012-05-18 20:56:27 +08:00
|
|
|
result = detect_aui(dev);
|
|
|
|
if (result == DETECTED_NONE) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_warn("%s: 10Base-5 (AUI) has no cable\n", dev->name);
|
2012-05-18 20:56:27 +08:00
|
|
|
if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
|
|
|
|
result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case A_CNF_MEDIA_10B_2:
|
2012-05-18 20:56:27 +08:00
|
|
|
result = detect_bnc(dev);
|
|
|
|
if (result == DETECTED_NONE) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_warn("%s: 10Base-2 (BNC) has no cable\n", dev->name);
|
2012-05-18 20:56:27 +08:00
|
|
|
if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
|
|
|
|
result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case A_CNF_MEDIA_AUTO:
|
|
|
|
writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
|
2012-05-18 20:56:29 +08:00
|
|
|
if (lp->adapter_cnf & A_CNF_10B_T) {
|
|
|
|
result = detect_tp(dev);
|
|
|
|
if (result != DETECTED_NONE)
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2012-05-18 20:56:29 +08:00
|
|
|
}
|
|
|
|
if (lp->adapter_cnf & A_CNF_AUI) {
|
|
|
|
result = detect_aui(dev);
|
|
|
|
if (result != DETECTED_NONE)
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2012-05-18 20:56:29 +08:00
|
|
|
}
|
|
|
|
if (lp->adapter_cnf & A_CNF_10B_2) {
|
|
|
|
result = detect_bnc(dev);
|
|
|
|
if (result != DETECTED_NONE)
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2012-05-18 20:56:29 +08:00
|
|
|
}
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("%s: no media detected\n", dev->name);
|
2008-05-30 11:18:55 +08:00
|
|
|
goto release_dma;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:27 +08:00
|
|
|
switch (result) {
|
2005-04-17 06:20:36 +08:00
|
|
|
case DETECTED_NONE:
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("%s: no network cable attached to configured media\n",
|
|
|
|
dev->name);
|
2008-05-30 11:18:55 +08:00
|
|
|
goto release_dma;
|
2005-04-17 06:20:36 +08:00
|
|
|
case DETECTED_RJ45H:
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_info("%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case DETECTED_RJ45F:
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_info("%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case DETECTED_AUI:
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_info("%s: using 10Base-5 (AUI)\n", dev->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case DETECTED_BNC:
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_info("%s: using 10Base-2 (BNC)\n", dev->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Turn on both receive and transmit operations */
|
2012-05-18 20:56:29 +08:00
|
|
|
writereg(dev, PP_LineCTL,
|
|
|
|
readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Receive only error free packets addressed to this card */
|
|
|
|
lp->rx_mode = 0;
|
|
|
|
writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
|
|
|
|
|
|
|
|
lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
|
|
|
|
|
|
|
|
if (lp->isa_config & STREAM_TRANSFER)
|
|
|
|
lp->curr_rx_cfg |= RX_STREAM_ENBL;
|
|
|
|
#if ALLOW_DMA
|
|
|
|
set_dma_cfg(dev);
|
|
|
|
#endif
|
|
|
|
writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
|
|
|
|
|
2012-05-18 20:56:29 +08:00
|
|
|
writereg(dev, PP_TxCFG, (TX_LOST_CRS_ENBL |
|
|
|
|
TX_SQE_ERROR_ENBL |
|
|
|
|
TX_OK_ENBL |
|
|
|
|
TX_LATE_COL_ENBL |
|
|
|
|
TX_JBR_ENBL |
|
|
|
|
TX_ANY_COL_ENBL |
|
|
|
|
TX_16_COL_ENBL));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:29 +08:00
|
|
|
writereg(dev, PP_BufCFG, (READY_FOR_TX_ENBL |
|
|
|
|
RX_MISS_COUNT_OVRFLOW_ENBL |
|
2005-04-17 06:20:36 +08:00
|
|
|
#if ALLOW_DMA
|
2012-05-18 20:56:29 +08:00
|
|
|
dma_bufcfg(dev) |
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2012-05-18 20:56:29 +08:00
|
|
|
TX_COL_COUNT_OVRFLOW_ENBL |
|
|
|
|
TX_UNDERRUN_ENBL));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* now that we've got our act together, enable everything */
|
2012-05-18 20:56:29 +08:00
|
|
|
writereg(dev, PP_BusCTL, (ENABLE_IRQ
|
|
|
|
| (dev->mem_start ? MEMORY_ON : 0) /* turn memory on */
|
2005-04-17 06:20:36 +08:00
|
|
|
#if ALLOW_DMA
|
2012-05-18 20:56:29 +08:00
|
|
|
| dma_busctl(dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2012-05-18 20:56:29 +08:00
|
|
|
));
|
2012-05-18 20:56:27 +08:00
|
|
|
netif_start_queue(dev);
|
2012-05-18 20:56:30 +08:00
|
|
|
cs89_dbg(1, debug, "net_open() succeeded\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
bad_out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* The inverse routine to net_open(). */
|
|
|
|
static int
|
|
|
|
net_close(struct net_device *dev)
|
|
|
|
{
|
|
|
|
#if ALLOW_DMA
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
|
|
|
writereg(dev, PP_RxCFG, 0);
|
|
|
|
writereg(dev, PP_TxCFG, 0);
|
|
|
|
writereg(dev, PP_BufCFG, 0);
|
|
|
|
writereg(dev, PP_BusCTL, 0);
|
|
|
|
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
|
|
|
|
#if ALLOW_DMA
|
|
|
|
if (lp->use_dma && lp->dma) {
|
|
|
|
free_dma(dev->dma);
|
|
|
|
release_dma_buff(lp);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Update the statistics here. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the current statistics.
|
|
|
|
* This may be called with the card open or closed.
|
|
|
|
*/
|
|
|
|
static struct net_device_stats *
|
|
|
|
net_get_stats(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&lp->lock, flags);
|
|
|
|
/* Update the statistics from the device registers. */
|
|
|
|
dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
|
|
|
|
dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
|
|
|
|
spin_unlock_irqrestore(&lp->lock, flags);
|
|
|
|
|
|
|
|
return &dev->stats;
|
|
|
|
}
|
|
|
|
|
netdev: pass the stuck queue to the timeout handler
This allows incrementing the correct timeout statistic without any mess.
Down the road, devices can learn to reset just the specific queue.
The patch was generated with the following script:
use strict;
use warnings;
our $^I = '.bak';
my @work = (
["arch/m68k/emu/nfeth.c", "nfeth_tx_timeout"],
["arch/um/drivers/net_kern.c", "uml_net_tx_timeout"],
["arch/um/drivers/vector_kern.c", "vector_net_tx_timeout"],
["arch/xtensa/platforms/iss/network.c", "iss_net_tx_timeout"],
["drivers/char/pcmcia/synclink_cs.c", "hdlcdev_tx_timeout"],
["drivers/infiniband/ulp/ipoib/ipoib_main.c", "ipoib_timeout"],
["drivers/infiniband/ulp/ipoib/ipoib_main.c", "ipoib_timeout"],
["drivers/message/fusion/mptlan.c", "mpt_lan_tx_timeout"],
["drivers/misc/sgi-xp/xpnet.c", "xpnet_dev_tx_timeout"],
["drivers/net/appletalk/cops.c", "cops_timeout"],
["drivers/net/arcnet/arcdevice.h", "arcnet_timeout"],
["drivers/net/arcnet/arcnet.c", "arcnet_timeout"],
["drivers/net/arcnet/com20020.c", "arcnet_timeout"],
["drivers/net/ethernet/3com/3c509.c", "el3_tx_timeout"],
["drivers/net/ethernet/3com/3c515.c", "corkscrew_timeout"],
["drivers/net/ethernet/3com/3c574_cs.c", "el3_tx_timeout"],
["drivers/net/ethernet/3com/3c589_cs.c", "el3_tx_timeout"],
["drivers/net/ethernet/3com/3c59x.c", "vortex_tx_timeout"],
["drivers/net/ethernet/3com/3c59x.c", "vortex_tx_timeout"],
["drivers/net/ethernet/3com/typhoon.c", "typhoon_tx_timeout"],
["drivers/net/ethernet/8390/8390.h", "ei_tx_timeout"],
["drivers/net/ethernet/8390/8390.h", "eip_tx_timeout"],
["drivers/net/ethernet/8390/8390.c", "ei_tx_timeout"],
["drivers/net/ethernet/8390/8390p.c", "eip_tx_timeout"],
["drivers/net/ethernet/8390/ax88796.c", "ax_ei_tx_timeout"],
["drivers/net/ethernet/8390/axnet_cs.c", "axnet_tx_timeout"],
["drivers/net/ethernet/8390/etherh.c", "__ei_tx_timeout"],
["drivers/net/ethernet/8390/hydra.c", "__ei_tx_timeout"],
["drivers/net/ethernet/8390/mac8390.c", "__ei_tx_timeout"],
["drivers/net/ethernet/8390/mcf8390.c", "__ei_tx_timeout"],
["drivers/net/ethernet/8390/lib8390.c", "__ei_tx_timeout"],
["drivers/net/ethernet/8390/ne2k-pci.c", "ei_tx_timeout"],
["drivers/net/ethernet/8390/pcnet_cs.c", "ei_tx_timeout"],
["drivers/net/ethernet/8390/smc-ultra.c", "ei_tx_timeout"],
["drivers/net/ethernet/8390/wd.c", "ei_tx_timeout"],
["drivers/net/ethernet/8390/zorro8390.c", "__ei_tx_timeout"],
["drivers/net/ethernet/adaptec/starfire.c", "tx_timeout"],
["drivers/net/ethernet/agere/et131x.c", "et131x_tx_timeout"],
["drivers/net/ethernet/allwinner/sun4i-emac.c", "emac_timeout"],
["drivers/net/ethernet/alteon/acenic.c", "ace_watchdog"],
["drivers/net/ethernet/amazon/ena/ena_netdev.c", "ena_tx_timeout"],
["drivers/net/ethernet/amd/7990.h", "lance_tx_timeout"],
["drivers/net/ethernet/amd/7990.c", "lance_tx_timeout"],
["drivers/net/ethernet/amd/a2065.c", "lance_tx_timeout"],
["drivers/net/ethernet/amd/am79c961a.c", "am79c961_timeout"],
["drivers/net/ethernet/amd/amd8111e.c", "amd8111e_tx_timeout"],
["drivers/net/ethernet/amd/ariadne.c", "ariadne_tx_timeout"],
["drivers/net/ethernet/amd/atarilance.c", "lance_tx_timeout"],
["drivers/net/ethernet/amd/au1000_eth.c", "au1000_tx_timeout"],
["drivers/net/ethernet/amd/declance.c", "lance_tx_timeout"],
["drivers/net/ethernet/amd/lance.c", "lance_tx_timeout"],
["drivers/net/ethernet/amd/mvme147.c", "lance_tx_timeout"],
["drivers/net/ethernet/amd/ni65.c", "ni65_timeout"],
["drivers/net/ethernet/amd/nmclan_cs.c", "mace_tx_timeout"],
["drivers/net/ethernet/amd/pcnet32.c", "pcnet32_tx_timeout"],
["drivers/net/ethernet/amd/sunlance.c", "lance_tx_timeout"],
["drivers/net/ethernet/amd/xgbe/xgbe-drv.c", "xgbe_tx_timeout"],
["drivers/net/ethernet/apm/xgene-v2/main.c", "xge_timeout"],
["drivers/net/ethernet/apm/xgene/xgene_enet_main.c", "xgene_enet_timeout"],
["drivers/net/ethernet/apple/macmace.c", "mace_tx_timeout"],
["drivers/net/ethernet/atheros/ag71xx.c", "ag71xx_tx_timeout"],
["drivers/net/ethernet/atheros/alx/main.c", "alx_tx_timeout"],
["drivers/net/ethernet/atheros/atl1c/atl1c_main.c", "atl1c_tx_timeout"],
["drivers/net/ethernet/atheros/atl1e/atl1e_main.c", "atl1e_tx_timeout"],
["drivers/net/ethernet/atheros/atlx/atl.c", "atlx_tx_timeout"],
["drivers/net/ethernet/atheros/atlx/atl1.c", "atlx_tx_timeout"],
["drivers/net/ethernet/atheros/atlx/atl2.c", "atl2_tx_timeout"],
["drivers/net/ethernet/broadcom/b44.c", "b44_tx_timeout"],
["drivers/net/ethernet/broadcom/bcmsysport.c", "bcm_sysport_tx_timeout"],
["drivers/net/ethernet/broadcom/bnx2.c", "bnx2_tx_timeout"],
["drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h", "bnx2x_tx_timeout"],
["drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c", "bnx2x_tx_timeout"],
["drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c", "bnx2x_tx_timeout"],
["drivers/net/ethernet/broadcom/bnxt/bnxt.c", "bnxt_tx_timeout"],
["drivers/net/ethernet/broadcom/genet/bcmgenet.c", "bcmgenet_timeout"],
["drivers/net/ethernet/broadcom/sb1250-mac.c", "sbmac_tx_timeout"],
["drivers/net/ethernet/broadcom/tg3.c", "tg3_tx_timeout"],
["drivers/net/ethernet/calxeda/xgmac.c", "xgmac_tx_timeout"],
["drivers/net/ethernet/cavium/liquidio/lio_main.c", "liquidio_tx_timeout"],
["drivers/net/ethernet/cavium/liquidio/lio_vf_main.c", "liquidio_tx_timeout"],
["drivers/net/ethernet/cavium/liquidio/lio_vf_rep.c", "lio_vf_rep_tx_timeout"],
["drivers/net/ethernet/cavium/thunder/nicvf_main.c", "nicvf_tx_timeout"],
["drivers/net/ethernet/cirrus/cs89x0.c", "net_timeout"],
["drivers/net/ethernet/cisco/enic/enic_main.c", "enic_tx_timeout"],
["drivers/net/ethernet/cisco/enic/enic_main.c", "enic_tx_timeout"],
["drivers/net/ethernet/cortina/gemini.c", "gmac_tx_timeout"],
["drivers/net/ethernet/davicom/dm9000.c", "dm9000_timeout"],
["drivers/net/ethernet/dec/tulip/de2104x.c", "de_tx_timeout"],
["drivers/net/ethernet/dec/tulip/tulip_core.c", "tulip_tx_timeout"],
["drivers/net/ethernet/dec/tulip/winbond-840.c", "tx_timeout"],
["drivers/net/ethernet/dlink/dl2k.c", "rio_tx_timeout"],
["drivers/net/ethernet/dlink/sundance.c", "tx_timeout"],
["drivers/net/ethernet/emulex/benet/be_main.c", "be_tx_timeout"],
["drivers/net/ethernet/ethoc.c", "ethoc_tx_timeout"],
["drivers/net/ethernet/faraday/ftgmac100.c", "ftgmac100_tx_timeout"],
["drivers/net/ethernet/fealnx.c", "fealnx_tx_timeout"],
["drivers/net/ethernet/freescale/dpaa/dpaa_eth.c", "dpaa_tx_timeout"],
["drivers/net/ethernet/freescale/fec_main.c", "fec_timeout"],
["drivers/net/ethernet/freescale/fec_mpc52xx.c", "mpc52xx_fec_tx_timeout"],
["drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c", "fs_timeout"],
["drivers/net/ethernet/freescale/gianfar.c", "gfar_timeout"],
["drivers/net/ethernet/freescale/ucc_geth.c", "ucc_geth_timeout"],
["drivers/net/ethernet/fujitsu/fmvj18x_cs.c", "fjn_tx_timeout"],
["drivers/net/ethernet/google/gve/gve_main.c", "gve_tx_timeout"],
["drivers/net/ethernet/hisilicon/hip04_eth.c", "hip04_timeout"],
["drivers/net/ethernet/hisilicon/hix5hd2_gmac.c", "hix5hd2_net_timeout"],
["drivers/net/ethernet/hisilicon/hns/hns_enet.c", "hns_nic_net_timeout"],
["drivers/net/ethernet/hisilicon/hns3/hns3_enet.c", "hns3_nic_net_timeout"],
["drivers/net/ethernet/huawei/hinic/hinic_main.c", "hinic_tx_timeout"],
["drivers/net/ethernet/i825xx/82596.c", "i596_tx_timeout"],
["drivers/net/ethernet/i825xx/ether1.c", "ether1_timeout"],
["drivers/net/ethernet/i825xx/lib82596.c", "i596_tx_timeout"],
["drivers/net/ethernet/i825xx/sun3_82586.c", "sun3_82586_timeout"],
["drivers/net/ethernet/ibm/ehea/ehea_main.c", "ehea_tx_watchdog"],
["drivers/net/ethernet/ibm/emac/core.c", "emac_tx_timeout"],
["drivers/net/ethernet/ibm/emac/core.c", "emac_tx_timeout"],
["drivers/net/ethernet/ibm/ibmvnic.c", "ibmvnic_tx_timeout"],
["drivers/net/ethernet/intel/e100.c", "e100_tx_timeout"],
["drivers/net/ethernet/intel/e1000/e1000_main.c", "e1000_tx_timeout"],
["drivers/net/ethernet/intel/e1000e/netdev.c", "e1000_tx_timeout"],
["drivers/net/ethernet/intel/fm10k/fm10k_netdev.c", "fm10k_tx_timeout"],
["drivers/net/ethernet/intel/i40e/i40e_main.c", "i40e_tx_timeout"],
["drivers/net/ethernet/intel/iavf/iavf_main.c", "iavf_tx_timeout"],
["drivers/net/ethernet/intel/ice/ice_main.c", "ice_tx_timeout"],
["drivers/net/ethernet/intel/ice/ice_main.c", "ice_tx_timeout"],
["drivers/net/ethernet/intel/igb/igb_main.c", "igb_tx_timeout"],
["drivers/net/ethernet/intel/igbvf/netdev.c", "igbvf_tx_timeout"],
["drivers/net/ethernet/intel/ixgb/ixgb_main.c", "ixgb_tx_timeout"],
["drivers/net/ethernet/intel/ixgbe/ixgbe_debugfs.c", "adapter->netdev->netdev_ops->ndo_tx_timeout(adapter->netdev);"],
["drivers/net/ethernet/intel/ixgbe/ixgbe_main.c", "ixgbe_tx_timeout"],
["drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c", "ixgbevf_tx_timeout"],
["drivers/net/ethernet/jme.c", "jme_tx_timeout"],
["drivers/net/ethernet/korina.c", "korina_tx_timeout"],
["drivers/net/ethernet/lantiq_etop.c", "ltq_etop_tx_timeout"],
["drivers/net/ethernet/marvell/mv643xx_eth.c", "mv643xx_eth_tx_timeout"],
["drivers/net/ethernet/marvell/pxa168_eth.c", "pxa168_eth_tx_timeout"],
["drivers/net/ethernet/marvell/skge.c", "skge_tx_timeout"],
["drivers/net/ethernet/marvell/sky2.c", "sky2_tx_timeout"],
["drivers/net/ethernet/marvell/sky2.c", "sky2_tx_timeout"],
["drivers/net/ethernet/mediatek/mtk_eth_soc.c", "mtk_tx_timeout"],
["drivers/net/ethernet/mellanox/mlx4/en_netdev.c", "mlx4_en_tx_timeout"],
["drivers/net/ethernet/mellanox/mlx4/en_netdev.c", "mlx4_en_tx_timeout"],
["drivers/net/ethernet/mellanox/mlx5/core/en_main.c", "mlx5e_tx_timeout"],
["drivers/net/ethernet/micrel/ks8842.c", "ks8842_tx_timeout"],
["drivers/net/ethernet/micrel/ksz884x.c", "netdev_tx_timeout"],
["drivers/net/ethernet/microchip/enc28j60.c", "enc28j60_tx_timeout"],
["drivers/net/ethernet/microchip/encx24j600.c", "encx24j600_tx_timeout"],
["drivers/net/ethernet/natsemi/sonic.h", "sonic_tx_timeout"],
["drivers/net/ethernet/natsemi/sonic.c", "sonic_tx_timeout"],
["drivers/net/ethernet/natsemi/jazzsonic.c", "sonic_tx_timeout"],
["drivers/net/ethernet/natsemi/macsonic.c", "sonic_tx_timeout"],
["drivers/net/ethernet/natsemi/natsemi.c", "ns_tx_timeout"],
["drivers/net/ethernet/natsemi/ns83820.c", "ns83820_tx_timeout"],
["drivers/net/ethernet/natsemi/xtsonic.c", "sonic_tx_timeout"],
["drivers/net/ethernet/neterion/s2io.h", "s2io_tx_watchdog"],
["drivers/net/ethernet/neterion/s2io.c", "s2io_tx_watchdog"],
["drivers/net/ethernet/neterion/vxge/vxge-main.c", "vxge_tx_watchdog"],
["drivers/net/ethernet/netronome/nfp/nfp_net_common.c", "nfp_net_tx_timeout"],
["drivers/net/ethernet/nvidia/forcedeth.c", "nv_tx_timeout"],
["drivers/net/ethernet/nvidia/forcedeth.c", "nv_tx_timeout"],
["drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c", "pch_gbe_tx_timeout"],
["drivers/net/ethernet/packetengines/hamachi.c", "hamachi_tx_timeout"],
["drivers/net/ethernet/packetengines/yellowfin.c", "yellowfin_tx_timeout"],
["drivers/net/ethernet/pensando/ionic/ionic_lif.c", "ionic_tx_timeout"],
["drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c", "netxen_tx_timeout"],
["drivers/net/ethernet/qlogic/qla3xxx.c", "ql3xxx_tx_timeout"],
["drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c", "qlcnic_tx_timeout"],
["drivers/net/ethernet/qualcomm/emac/emac.c", "emac_tx_timeout"],
["drivers/net/ethernet/qualcomm/qca_spi.c", "qcaspi_netdev_tx_timeout"],
["drivers/net/ethernet/qualcomm/qca_uart.c", "qcauart_netdev_tx_timeout"],
["drivers/net/ethernet/rdc/r6040.c", "r6040_tx_timeout"],
["drivers/net/ethernet/realtek/8139cp.c", "cp_tx_timeout"],
["drivers/net/ethernet/realtek/8139too.c", "rtl8139_tx_timeout"],
["drivers/net/ethernet/realtek/atp.c", "tx_timeout"],
["drivers/net/ethernet/realtek/r8169_main.c", "rtl8169_tx_timeout"],
["drivers/net/ethernet/renesas/ravb_main.c", "ravb_tx_timeout"],
["drivers/net/ethernet/renesas/sh_eth.c", "sh_eth_tx_timeout"],
["drivers/net/ethernet/renesas/sh_eth.c", "sh_eth_tx_timeout"],
["drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c", "sxgbe_tx_timeout"],
["drivers/net/ethernet/seeq/ether3.c", "ether3_timeout"],
["drivers/net/ethernet/seeq/sgiseeq.c", "timeout"],
["drivers/net/ethernet/sfc/efx.c", "efx_watchdog"],
["drivers/net/ethernet/sfc/falcon/efx.c", "ef4_watchdog"],
["drivers/net/ethernet/sgi/ioc3-eth.c", "ioc3_timeout"],
["drivers/net/ethernet/sgi/meth.c", "meth_tx_timeout"],
["drivers/net/ethernet/silan/sc92031.c", "sc92031_tx_timeout"],
["drivers/net/ethernet/sis/sis190.c", "sis190_tx_timeout"],
["drivers/net/ethernet/sis/sis900.c", "sis900_tx_timeout"],
["drivers/net/ethernet/smsc/epic100.c", "epic_tx_timeout"],
["drivers/net/ethernet/smsc/smc911x.c", "smc911x_timeout"],
["drivers/net/ethernet/smsc/smc9194.c", "smc_timeout"],
["drivers/net/ethernet/smsc/smc91c92_cs.c", "smc_tx_timeout"],
["drivers/net/ethernet/smsc/smc91x.c", "smc_timeout"],
["drivers/net/ethernet/stmicro/stmmac/stmmac_main.c", "stmmac_tx_timeout"],
["drivers/net/ethernet/sun/cassini.c", "cas_tx_timeout"],
["drivers/net/ethernet/sun/ldmvsw.c", "sunvnet_tx_timeout_common"],
["drivers/net/ethernet/sun/niu.c", "niu_tx_timeout"],
["drivers/net/ethernet/sun/sunbmac.c", "bigmac_tx_timeout"],
["drivers/net/ethernet/sun/sungem.c", "gem_tx_timeout"],
["drivers/net/ethernet/sun/sunhme.c", "happy_meal_tx_timeout"],
["drivers/net/ethernet/sun/sunqe.c", "qe_tx_timeout"],
["drivers/net/ethernet/sun/sunvnet.c", "sunvnet_tx_timeout_common"],
["drivers/net/ethernet/sun/sunvnet_common.c", "sunvnet_tx_timeout_common"],
["drivers/net/ethernet/sun/sunvnet_common.h", "sunvnet_tx_timeout_common"],
["drivers/net/ethernet/synopsys/dwc-xlgmac-net.c", "xlgmac_tx_timeout"],
["drivers/net/ethernet/ti/cpmac.c", "cpmac_tx_timeout"],
["drivers/net/ethernet/ti/cpsw.c", "cpsw_ndo_tx_timeout"],
["drivers/net/ethernet/ti/cpsw_priv.c", "cpsw_ndo_tx_timeout"],
["drivers/net/ethernet/ti/cpsw_priv.h", "cpsw_ndo_tx_timeout"],
["drivers/net/ethernet/ti/davinci_emac.c", "emac_dev_tx_timeout"],
["drivers/net/ethernet/ti/netcp_core.c", "netcp_ndo_tx_timeout"],
["drivers/net/ethernet/ti/tlan.c", "tlan_tx_timeout"],
["drivers/net/ethernet/toshiba/ps3_gelic_net.h", "gelic_net_tx_timeout"],
["drivers/net/ethernet/toshiba/ps3_gelic_net.c", "gelic_net_tx_timeout"],
["drivers/net/ethernet/toshiba/ps3_gelic_wireless.c", "gelic_net_tx_timeout"],
["drivers/net/ethernet/toshiba/spider_net.c", "spider_net_tx_timeout"],
["drivers/net/ethernet/toshiba/tc35815.c", "tc35815_tx_timeout"],
["drivers/net/ethernet/via/via-rhine.c", "rhine_tx_timeout"],
["drivers/net/ethernet/wiznet/w5100.c", "w5100_tx_timeout"],
["drivers/net/ethernet/wiznet/w5300.c", "w5300_tx_timeout"],
["drivers/net/ethernet/xilinx/xilinx_emaclite.c", "xemaclite_tx_timeout"],
["drivers/net/ethernet/xircom/xirc2ps_cs.c", "xirc_tx_timeout"],
["drivers/net/fjes/fjes_main.c", "fjes_tx_retry"],
["drivers/net/slip/slip.c", "sl_tx_timeout"],
["include/linux/usb/usbnet.h", "usbnet_tx_timeout"],
["drivers/net/usb/aqc111.c", "usbnet_tx_timeout"],
["drivers/net/usb/asix_devices.c", "usbnet_tx_timeout"],
["drivers/net/usb/asix_devices.c", "usbnet_tx_timeout"],
["drivers/net/usb/asix_devices.c", "usbnet_tx_timeout"],
["drivers/net/usb/ax88172a.c", "usbnet_tx_timeout"],
["drivers/net/usb/ax88179_178a.c", "usbnet_tx_timeout"],
["drivers/net/usb/catc.c", "catc_tx_timeout"],
["drivers/net/usb/cdc_mbim.c", "usbnet_tx_timeout"],
["drivers/net/usb/cdc_ncm.c", "usbnet_tx_timeout"],
["drivers/net/usb/dm9601.c", "usbnet_tx_timeout"],
["drivers/net/usb/hso.c", "hso_net_tx_timeout"],
["drivers/net/usb/int51x1.c", "usbnet_tx_timeout"],
["drivers/net/usb/ipheth.c", "ipheth_tx_timeout"],
["drivers/net/usb/kaweth.c", "kaweth_tx_timeout"],
["drivers/net/usb/lan78xx.c", "lan78xx_tx_timeout"],
["drivers/net/usb/mcs7830.c", "usbnet_tx_timeout"],
["drivers/net/usb/pegasus.c", "pegasus_tx_timeout"],
["drivers/net/usb/qmi_wwan.c", "usbnet_tx_timeout"],
["drivers/net/usb/r8152.c", "rtl8152_tx_timeout"],
["drivers/net/usb/rndis_host.c", "usbnet_tx_timeout"],
["drivers/net/usb/rtl8150.c", "rtl8150_tx_timeout"],
["drivers/net/usb/sierra_net.c", "usbnet_tx_timeout"],
["drivers/net/usb/smsc75xx.c", "usbnet_tx_timeout"],
["drivers/net/usb/smsc95xx.c", "usbnet_tx_timeout"],
["drivers/net/usb/sr9700.c", "usbnet_tx_timeout"],
["drivers/net/usb/sr9800.c", "usbnet_tx_timeout"],
["drivers/net/usb/usbnet.c", "usbnet_tx_timeout"],
["drivers/net/vmxnet3/vmxnet3_drv.c", "vmxnet3_tx_timeout"],
["drivers/net/wan/cosa.c", "cosa_net_timeout"],
["drivers/net/wan/farsync.c", "fst_tx_timeout"],
["drivers/net/wan/fsl_ucc_hdlc.c", "uhdlc_tx_timeout"],
["drivers/net/wan/lmc/lmc_main.c", "lmc_driver_timeout"],
["drivers/net/wan/x25_asy.c", "x25_asy_timeout"],
["drivers/net/wimax/i2400m/netdev.c", "i2400m_tx_timeout"],
["drivers/net/wireless/intel/ipw2x00/ipw2100.c", "ipw2100_tx_timeout"],
["drivers/net/wireless/intersil/hostap/hostap_main.c", "prism2_tx_timeout"],
["drivers/net/wireless/intersil/hostap/hostap_main.c", "prism2_tx_timeout"],
["drivers/net/wireless/intersil/hostap/hostap_main.c", "prism2_tx_timeout"],
["drivers/net/wireless/intersil/orinoco/main.c", "orinoco_tx_timeout"],
["drivers/net/wireless/intersil/orinoco/orinoco_usb.c", "orinoco_tx_timeout"],
["drivers/net/wireless/intersil/orinoco/orinoco.h", "orinoco_tx_timeout"],
["drivers/net/wireless/intersil/prism54/islpci_dev.c", "islpci_eth_tx_timeout"],
["drivers/net/wireless/intersil/prism54/islpci_eth.c", "islpci_eth_tx_timeout"],
["drivers/net/wireless/intersil/prism54/islpci_eth.h", "islpci_eth_tx_timeout"],
["drivers/net/wireless/marvell/mwifiex/main.c", "mwifiex_tx_timeout"],
["drivers/net/wireless/quantenna/qtnfmac/core.c", "qtnf_netdev_tx_timeout"],
["drivers/net/wireless/quantenna/qtnfmac/core.h", "qtnf_netdev_tx_timeout"],
["drivers/net/wireless/rndis_wlan.c", "usbnet_tx_timeout"],
["drivers/net/wireless/wl3501_cs.c", "wl3501_tx_timeout"],
["drivers/net/wireless/zydas/zd1201.c", "zd1201_tx_timeout"],
["drivers/s390/net/qeth_core.h", "qeth_tx_timeout"],
["drivers/s390/net/qeth_core_main.c", "qeth_tx_timeout"],
["drivers/s390/net/qeth_l2_main.c", "qeth_tx_timeout"],
["drivers/s390/net/qeth_l2_main.c", "qeth_tx_timeout"],
["drivers/s390/net/qeth_l3_main.c", "qeth_tx_timeout"],
["drivers/s390/net/qeth_l3_main.c", "qeth_tx_timeout"],
["drivers/staging/ks7010/ks_wlan_net.c", "ks_wlan_tx_timeout"],
["drivers/staging/qlge/qlge_main.c", "qlge_tx_timeout"],
["drivers/staging/rtl8192e/rtl8192e/rtl_core.c", "_rtl92e_tx_timeout"],
["drivers/staging/rtl8192u/r8192U_core.c", "tx_timeout"],
["drivers/staging/unisys/visornic/visornic_main.c", "visornic_xmit_timeout"],
["drivers/staging/wlan-ng/p80211netdev.c", "p80211knetdev_tx_timeout"],
["drivers/tty/n_gsm.c", "gsm_mux_net_tx_timeout"],
["drivers/tty/synclink.c", "hdlcdev_tx_timeout"],
["drivers/tty/synclink_gt.c", "hdlcdev_tx_timeout"],
["drivers/tty/synclinkmp.c", "hdlcdev_tx_timeout"],
["net/atm/lec.c", "lec_tx_timeout"],
["net/bluetooth/bnep/netdev.c", "bnep_net_timeout"]
);
for my $p (@work) {
my @pair = @$p;
my $file = $pair[0];
my $func = $pair[1];
print STDERR $file , ": ", $func,"\n";
our @ARGV = ($file);
while (<ARGV>) {
if (m/($func\s*\(struct\s+net_device\s+\*[A-Za-z_]?[A-Za-z-0-9_]*)(\))/) {
print STDERR "found $1+$2 in $file\n";
}
if (s/($func\s*\(struct\s+net_device\s+\*[A-Za-z_]?[A-Za-z-0-9_]*)(\))/$1, unsigned int txqueue$2/) {
print STDERR "$func found in $file\n";
}
print;
}
}
where the list of files and functions is simply from:
git grep ndo_tx_timeout, with manual addition of headers
in the rare cases where the function is from a header,
then manually changing the few places which actually
call ndo_tx_timeout.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Heiner Kallweit <hkallweit1@gmail.com>
Acked-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Acked-by: Shannon Nelson <snelson@pensando.io>
Reviewed-by: Martin Habets <mhabets@solarflare.com>
changes from v9:
fixup a forward declaration
changes from v9:
more leftovers from v3 change
changes from v8:
fix up a missing direct call to timeout
rebased on net-next
changes from v7:
fixup leftovers from v3 change
changes from v6:
fix typo in rtl driver
changes from v5:
add missing files (allow any net device argument name)
changes from v4:
add a missing driver header
changes from v3:
change queue # to unsigned
Changes from v2:
added headers
Changes from v1:
Fix errors found by kbuild:
generalize the pattern a bit, to pick up
a couple of instances missed by the previous
version.
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-12-10 22:23:51 +08:00
|
|
|
static void net_timeout(struct net_device *dev, unsigned int txqueue)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
/* If we get here, some higher level has decided we are broken.
|
|
|
|
There should really be a "kick me" function call instead. */
|
2012-05-18 20:56:30 +08:00
|
|
|
cs89_dbg(0, err, "%s: transmit timed out, %s?\n",
|
|
|
|
dev->name,
|
|
|
|
tx_done(dev) ? "IRQ conflict" : "network cable problem");
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Try to restart the adaptor. */
|
|
|
|
netif_wake_queue(dev);
|
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
2009-07-13 04:27:06 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:30 +08:00
|
|
|
cs89_dbg(3, debug, "%s: sent %d byte packet of type %x\n",
|
|
|
|
dev->name, skb->len,
|
|
|
|
((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
|
|
|
|
skb->data[ETH_ALEN + ETH_ALEN + 1]));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* keep the upload from being interrupted, since we
|
2012-05-18 20:56:29 +08:00
|
|
|
* ask the chip to start transmitting before the
|
|
|
|
* whole packet has been completely uploaded.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-13 04:27:06 +08:00
|
|
|
spin_lock_irqsave(&lp->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
|
|
|
/* initiate a transmit sequence */
|
2012-05-17 15:11:42 +08:00
|
|
|
iowrite16(lp->send_cmd, lp->virt_addr + TX_CMD_PORT);
|
|
|
|
iowrite16(skb->len, lp->virt_addr + TX_LEN_PORT);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Test to see if the chip has allocated memory for the packet */
|
|
|
|
if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
|
2012-05-18 20:56:27 +08:00
|
|
|
/* Gasp! It hasn't. But that shouldn't happen since
|
2005-04-17 06:20:36 +08:00
|
|
|
* we're waiting for TxOk, so return 1 and requeue this packet.
|
|
|
|
*/
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2009-07-13 04:27:06 +08:00
|
|
|
spin_unlock_irqrestore(&lp->lock, flags);
|
2012-05-18 20:56:30 +08:00
|
|
|
cs89_dbg(0, err, "Tx buffer not free!\n");
|
2009-06-12 14:22:29 +08:00
|
|
|
return NETDEV_TX_BUSY;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
/* Write the contents of the packet */
|
2012-05-18 20:56:29 +08:00
|
|
|
writewords(lp, TX_FRAME_PORT, skb->data, (skb->len + 1) >> 1);
|
2009-07-13 04:27:06 +08:00
|
|
|
spin_unlock_irqrestore(&lp->lock, flags);
|
2010-07-05 10:13:15 +08:00
|
|
|
dev->stats.tx_bytes += skb->len;
|
2014-03-16 07:45:46 +08:00
|
|
|
dev_consume_skb_any(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
/* We DO NOT call netif_wake_queue() here.
|
2005-04-17 06:20:36 +08:00
|
|
|
* We also DO NOT call netif_start_queue().
|
|
|
|
*
|
|
|
|
* Either of these would cause another bottom half run through
|
2012-05-18 20:56:29 +08:00
|
|
|
* net_send_packet() before this packet has fully gone out.
|
|
|
|
* That causes us to hit the "Gasp!" above and the send is rescheduled.
|
|
|
|
* it runs like a dog. We just return and wait for the Tx completion
|
|
|
|
* interrupt handler to restart the netdevice layer
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
2009-06-23 14:03:08 +08:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static void set_multicast_list(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-18 20:56:31 +08:00
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
unsigned long flags;
|
2012-08-27 19:53:51 +08:00
|
|
|
u16 cfg;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
spin_lock_irqsave(&lp->lock, flags);
|
|
|
|
if (dev->flags & IFF_PROMISC)
|
|
|
|
lp->rx_mode = RX_ALL_ACCEPT;
|
|
|
|
else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev))
|
|
|
|
/* The multicast-accept list is initialized to accept-all,
|
|
|
|
* and we rely on higher-level filtering for now.
|
|
|
|
*/
|
|
|
|
lp->rx_mode = RX_MULTCAST_ACCEPT;
|
|
|
|
else
|
|
|
|
lp->rx_mode = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
|
|
|
|
|
|
|
|
/* in promiscuous mode, we accept errored packets,
|
|
|
|
* so we have to enable interrupts on them also
|
2012-05-18 20:56:27 +08:00
|
|
|
*/
|
2012-08-27 19:53:51 +08:00
|
|
|
cfg = lp->curr_rx_cfg;
|
|
|
|
if (lp->rx_mode == RX_ALL_ACCEPT)
|
|
|
|
cfg |= RX_CRC_ERROR_ENBL | RX_RUNT_ENBL | RX_EXTRA_DATA_ENBL;
|
|
|
|
writereg(dev, PP_RxCFG, cfg);
|
2012-05-18 20:56:31 +08:00
|
|
|
spin_unlock_irqrestore(&lp->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
static int set_mac_address(struct net_device *dev, void *p)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-18 20:56:31 +08:00
|
|
|
int i;
|
|
|
|
struct sockaddr *addr = p;
|
|
|
|
|
|
|
|
if (netif_running(dev))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
|
|
|
|
|
|
|
|
cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
|
|
|
|
dev->name, dev->dev_addr);
|
|
|
|
|
|
|
|
/* set the Ethernet address */
|
|
|
|
for (i = 0; i < ETH_ALEN / 2; i++)
|
|
|
|
writereg(dev, PP_IA + i * 2,
|
|
|
|
(dev->dev_addr[i * 2] |
|
|
|
|
(dev->dev_addr[i * 2 + 1] << 8)));
|
|
|
|
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
/*
|
|
|
|
* Polling receive - used by netconsole and other diagnostic tools
|
|
|
|
* to allow network i/o with interrupts disabled.
|
|
|
|
*/
|
|
|
|
static void net_poll_controller(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-18 20:56:31 +08:00
|
|
|
disable_irq(dev->irq);
|
|
|
|
net_interrupt(dev->irq, dev);
|
|
|
|
enable_irq(dev->irq);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const struct net_device_ops net_ops = {
|
|
|
|
.ndo_open = net_open,
|
|
|
|
.ndo_stop = net_close,
|
|
|
|
.ndo_tx_timeout = net_timeout,
|
|
|
|
.ndo_start_xmit = net_send_packet,
|
|
|
|
.ndo_get_stats = net_get_stats,
|
|
|
|
.ndo_set_rx_mode = set_multicast_list,
|
|
|
|
.ndo_set_mac_address = set_mac_address,
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = net_poll_controller,
|
|
|
|
#endif
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __init reset_chip(struct net_device *dev)
|
|
|
|
{
|
|
|
|
#if !defined(CONFIG_MACH_MX31ADS)
|
2012-05-17 15:11:42 +08:00
|
|
|
struct net_local *lp = netdev_priv(dev);
|
2014-12-14 16:34:18 +08:00
|
|
|
unsigned long reset_start_time;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* wait 30 ms */
|
|
|
|
msleep(30);
|
|
|
|
|
|
|
|
if (lp->chip_type != CS8900) {
|
|
|
|
/* Hardware problem requires PNP registers to be reconfigured after a reset */
|
|
|
|
iowrite16(PP_CS8920_ISAINT, lp->virt_addr + ADD_PORT);
|
|
|
|
iowrite8(dev->irq, lp->virt_addr + DATA_PORT);
|
|
|
|
iowrite8(0, lp->virt_addr + DATA_PORT + 1);
|
|
|
|
|
|
|
|
iowrite16(PP_CS8920_ISAMemB, lp->virt_addr + ADD_PORT);
|
|
|
|
iowrite8((dev->mem_start >> 16) & 0xff,
|
|
|
|
lp->virt_addr + DATA_PORT);
|
|
|
|
iowrite8((dev->mem_start >> 8) & 0xff,
|
|
|
|
lp->virt_addr + DATA_PORT + 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* Wait until the chip is reset */
|
|
|
|
reset_start_time = jiffies;
|
|
|
|
while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
|
2014-12-14 16:34:18 +08:00
|
|
|
time_before(jiffies, reset_start_time + 2))
|
2012-05-18 20:56:31 +08:00
|
|
|
;
|
|
|
|
#endif /* !CONFIG_MACH_MX31ADS */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is the real probe routine.
|
|
|
|
* Linux has a history of friendly device probes on the ISA bus.
|
|
|
|
* A good device probes avoids doing writes, and
|
|
|
|
* verifies that the correct device exists and functions.
|
|
|
|
* Return 0 on success.
|
|
|
|
*/
|
|
|
|
static int __init
|
|
|
|
cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
|
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
|
|
|
int i;
|
|
|
|
int tmp;
|
|
|
|
unsigned rev_type = 0;
|
|
|
|
int eeprom_buff[CHKSUM_LEN];
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
/* Initialize the device structure. */
|
|
|
|
if (!modular) {
|
|
|
|
memset(lp, 0, sizeof(*lp));
|
|
|
|
spin_lock_init(&lp->lock);
|
|
|
|
#ifndef MODULE
|
|
|
|
#if ALLOW_DMA
|
|
|
|
if (g_cs89x0_dma) {
|
|
|
|
lp->use_dma = 1;
|
|
|
|
lp->dma = g_cs89x0_dma;
|
|
|
|
lp->dmasize = 16; /* Could make this an option... */
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2012-05-18 20:56:31 +08:00
|
|
|
lp->force = g_cs89x0_media__force;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("PP_addr at %p[%x]: 0x%x\n",
|
|
|
|
ioaddr, ADD_PORT, ioread16(ioaddr + ADD_PORT));
|
|
|
|
iowrite16(PP_ChipID, ioaddr + ADD_PORT);
|
|
|
|
|
|
|
|
tmp = ioread16(ioaddr + DATA_PORT);
|
|
|
|
if (tmp != CHIP_EISA_ID_SIG) {
|
|
|
|
pr_debug("%s: incorrect signature at %p[%x]: 0x%x!="
|
|
|
|
CHIP_EISA_ID_SIG_STR "\n",
|
|
|
|
dev->name, ioaddr, DATA_PORT, tmp);
|
|
|
|
retval = -ENODEV;
|
|
|
|
goto out1;
|
|
|
|
}
|
|
|
|
|
|
|
|
lp->virt_addr = ioaddr;
|
|
|
|
|
|
|
|
/* get the chip type */
|
|
|
|
rev_type = readreg(dev, PRODUCT_ID_ADD);
|
|
|
|
lp->chip_type = rev_type & ~REVISON_BITS;
|
|
|
|
lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
|
|
|
|
|
|
|
|
/* Check the chip type and revision in order to set the correct
|
|
|
|
* send command. CS8920 revision C and CS8900 revision F can use
|
|
|
|
* the faster send.
|
|
|
|
*/
|
|
|
|
lp->send_cmd = TX_AFTER_381;
|
|
|
|
if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
|
|
|
|
lp->send_cmd = TX_NOW;
|
|
|
|
if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
|
|
|
|
lp->send_cmd = TX_NOW;
|
|
|
|
|
|
|
|
pr_info_once("%s\n", version);
|
|
|
|
|
|
|
|
pr_info("%s: cs89%c0%s rev %c found at %p ",
|
|
|
|
dev->name,
|
|
|
|
lp->chip_type == CS8900 ? '0' : '2',
|
|
|
|
lp->chip_type == CS8920M ? "M" : "",
|
|
|
|
lp->chip_revision,
|
|
|
|
lp->virt_addr);
|
|
|
|
|
|
|
|
reset_chip(dev);
|
|
|
|
|
|
|
|
/* Here we read the current configuration of the chip.
|
|
|
|
* If there is no Extended EEPROM then the idea is to not disturb
|
|
|
|
* the chip configuration, it should have been correctly setup by
|
|
|
|
* automatic EEPROM read on reset. So, if the chip says it read
|
|
|
|
* the EEPROM the driver will always do *something* instead of
|
|
|
|
* complain that adapter_cnf is 0.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
|
|
|
|
(EEPROM_OK | EEPROM_PRESENT)) {
|
|
|
|
/* Load the MAC. */
|
|
|
|
for (i = 0; i < ETH_ALEN / 2; i++) {
|
|
|
|
unsigned int Addr;
|
|
|
|
Addr = readreg(dev, PP_IA + i * 2);
|
|
|
|
dev->dev_addr[i * 2] = Addr & 0xFF;
|
|
|
|
dev->dev_addr[i * 2 + 1] = Addr >> 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Load the Adapter Configuration.
|
|
|
|
* Note: Barring any more specific information from some
|
|
|
|
* other source (ie EEPROM+Schematics), we would not know
|
|
|
|
* how to operate a 10Base2 interface on the AUI port.
|
|
|
|
* However, since we do read the status of HCB1 and use
|
|
|
|
* settings that always result in calls to control_dc_dc(dev,0)
|
|
|
|
* a BNC interface should work if the enable pin
|
|
|
|
* (dc/dc converter) is on HCB1.
|
|
|
|
* It will be called AUI however.
|
|
|
|
*/
|
|
|
|
|
|
|
|
lp->adapter_cnf = 0;
|
|
|
|
i = readreg(dev, PP_LineCTL);
|
|
|
|
/* Preserve the setting of the HCB1 pin. */
|
|
|
|
if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
|
|
|
|
lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
|
|
|
|
/* Save the sqelch bit */
|
|
|
|
if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
|
|
|
|
lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
|
|
|
|
/* Check if the card is in 10Base-t only mode */
|
|
|
|
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
|
|
|
|
lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
|
|
|
|
/* Check if the card is in AUI only mode */
|
|
|
|
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
|
|
|
|
lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
|
|
|
|
/* Check if the card is in Auto mode. */
|
|
|
|
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
|
|
|
|
lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
|
|
|
|
A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
|
|
|
|
|
|
|
|
cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
|
|
|
|
dev->name, i, lp->adapter_cnf);
|
|
|
|
|
|
|
|
/* IRQ. Other chips already probe, see below. */
|
|
|
|
if (lp->chip_type == CS8900)
|
|
|
|
lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
|
|
|
|
|
|
|
|
pr_cont("[Cirrus EEPROM] ");
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_cont("\n");
|
|
|
|
|
|
|
|
/* First check to see if an EEPROM is attached. */
|
|
|
|
|
|
|
|
if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
|
|
|
|
pr_warn("No EEPROM, relying on command line....\n");
|
|
|
|
else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
|
|
|
|
pr_warn("EEPROM read failed, relying on command line\n");
|
|
|
|
} else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
|
|
|
|
/* Check if the chip was able to read its own configuration starting
|
|
|
|
at 0 in the EEPROM*/
|
|
|
|
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
|
|
|
|
(EEPROM_OK | EEPROM_PRESENT))
|
|
|
|
pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* This reads an extended EEPROM that is not documented
|
|
|
|
* in the CS8900 datasheet.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* get transmission control word but keep the autonegotiation bits */
|
|
|
|
if (!lp->auto_neg_cnf)
|
|
|
|
lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
|
|
|
|
/* Store adapter configuration */
|
|
|
|
if (!lp->adapter_cnf)
|
|
|
|
lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
|
|
|
|
/* Store ISA configuration */
|
|
|
|
lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
|
|
|
|
dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
|
|
|
|
|
|
|
|
/* eeprom_buff has 32-bit ints, so we can't just memcpy it */
|
|
|
|
/* store the initial memory base address */
|
|
|
|
for (i = 0; i < ETH_ALEN / 2; i++) {
|
|
|
|
dev->dev_addr[i * 2] = eeprom_buff[i];
|
|
|
|
dev->dev_addr[i * 2 + 1] = eeprom_buff[i] >> 8;
|
|
|
|
}
|
|
|
|
cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
|
|
|
|
dev->name, lp->adapter_cnf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow them to force multiple transceivers. If they force multiple, autosense */
|
|
|
|
{
|
|
|
|
int count = 0;
|
|
|
|
if (lp->force & FORCE_RJ45) {
|
|
|
|
lp->adapter_cnf |= A_CNF_10B_T;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
if (lp->force & FORCE_AUI) {
|
|
|
|
lp->adapter_cnf |= A_CNF_AUI;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
if (lp->force & FORCE_BNC) {
|
|
|
|
lp->adapter_cnf |= A_CNF_10B_2;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
if (count > 1)
|
|
|
|
lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
|
|
|
|
else if (lp->force & FORCE_RJ45)
|
|
|
|
lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
|
|
|
|
else if (lp->force & FORCE_AUI)
|
|
|
|
lp->adapter_cnf |= A_CNF_MEDIA_AUI;
|
|
|
|
else if (lp->force & FORCE_BNC)
|
|
|
|
lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
|
|
|
|
dev->name, lp->force, lp->adapter_cnf);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* FIXME: we don't set the Ethernet address on the command line. Use
|
|
|
|
* ifconfig IFACE hw ether AABBCCDDEEFF
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
pr_info("media %s%s%s",
|
|
|
|
(lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
|
|
|
|
(lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
|
|
|
|
(lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
lp->irq_map = 0xffff;
|
2006-09-14 01:24:59 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* If this is a CS8900 then no pnp soft */
|
|
|
|
if (lp->chip_type != CS8900 &&
|
|
|
|
/* Check if the ISA IRQ has been set */
|
|
|
|
(i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
|
|
|
|
(i != 0 && i < CS8920_NO_INTS))) {
|
|
|
|
if (!dev->irq)
|
|
|
|
dev->irq = i;
|
|
|
|
} else {
|
|
|
|
i = lp->isa_config & INT_NO_MASK;
|
|
|
|
#ifndef CONFIG_CS89x0_PLATFORM
|
|
|
|
if (lp->chip_type == CS8900) {
|
|
|
|
/* Translate the IRQ using the IRQ mapping table. */
|
|
|
|
if (i >= ARRAY_SIZE(cs8900_irq_map))
|
|
|
|
pr_err("invalid ISA interrupt number %d\n", i);
|
|
|
|
else
|
|
|
|
i = cs8900_irq_map[i];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
|
|
|
|
} else {
|
|
|
|
int irq_map_buff[IRQ_MAP_LEN/2];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
|
|
|
|
IRQ_MAP_LEN / 2,
|
|
|
|
irq_map_buff) >= 0) {
|
|
|
|
if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
|
|
|
|
lp->irq_map = ((irq_map_buff[0] >> 8) |
|
|
|
|
(irq_map_buff[1] << 8));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (!dev->irq)
|
|
|
|
dev->irq = i;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:31 +08:00
|
|
|
|
|
|
|
pr_cont(" IRQ %d", dev->irq);
|
|
|
|
|
|
|
|
#if ALLOW_DMA
|
|
|
|
if (lp->use_dma) {
|
|
|
|
get_dma_channel(dev);
|
|
|
|
pr_cont(", DMA %d", dev->dma);
|
|
|
|
} else
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2012-05-18 20:56:31 +08:00
|
|
|
pr_cont(", programmed I/O");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* print the ethernet address. */
|
|
|
|
pr_cont(", MAC %pM\n", dev->dev_addr);
|
|
|
|
|
|
|
|
dev->netdev_ops = &net_ops;
|
|
|
|
dev->watchdog_timeo = HZ;
|
|
|
|
|
|
|
|
cs89_dbg(0, info, "cs89x0_probe1() successful\n");
|
|
|
|
|
|
|
|
retval = register_netdev(dev);
|
|
|
|
if (retval)
|
|
|
|
goto out2;
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
2012-05-18 20:56:31 +08:00
|
|
|
out2:
|
|
|
|
iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
|
|
|
|
out1:
|
|
|
|
return retval;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
#ifndef CONFIG_CS89x0_PLATFORM
|
|
|
|
/*
|
2015-03-07 12:49:12 +08:00
|
|
|
* This function converts the I/O port address used by the cs89x0_probe() and
|
2012-05-18 20:56:31 +08:00
|
|
|
* init_module() functions to the I/O memory address used by the
|
|
|
|
* cs89x0_probe1() function.
|
2012-05-18 20:56:27 +08:00
|
|
|
*/
|
2012-05-18 20:56:31 +08:00
|
|
|
static int __init
|
|
|
|
cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_local *lp = netdev_priv(dev);
|
2012-05-18 20:56:31 +08:00
|
|
|
int ret;
|
|
|
|
void __iomem *io_mem;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (!lp)
|
|
|
|
return -ENOMEM;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
dev->base_addr = ioport;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
|
|
|
|
if (!io_mem) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto release;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
/* if they give us an odd I/O address, then do ONE write to
|
|
|
|
* the address port, to get it back to address zero, where we
|
|
|
|
* expect to find the EISA signature word. An IO with a base of 0x3
|
|
|
|
* will skip the test for the ADD_PORT.
|
2012-05-18 20:56:29 +08:00
|
|
|
*/
|
2012-05-18 20:56:31 +08:00
|
|
|
if (ioport & 1) {
|
|
|
|
cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
|
|
|
|
if ((ioport & 2) != 2) {
|
|
|
|
if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
|
|
|
|
ADD_SIG) {
|
|
|
|
pr_err("%s: bad signature 0x%x\n",
|
|
|
|
dev->name, ioread16(io_mem + ADD_PORT));
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto unmap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = cs89x0_probe1(dev, io_mem, modular);
|
|
|
|
if (!ret)
|
|
|
|
goto out;
|
|
|
|
unmap:
|
|
|
|
ioport_unmap(io_mem);
|
|
|
|
release:
|
|
|
|
release_region(ioport, NETCARD_IO_EXTENT);
|
|
|
|
out:
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
#ifndef MODULE
|
|
|
|
/* Check for a network adaptor of this type, and return '0' iff one exists.
|
|
|
|
* If dev->base_addr == 0, probe all likely locations.
|
|
|
|
* If dev->base_addr == 1, always return failure.
|
|
|
|
* If dev->base_addr == 2, allocate space for the device and return success
|
|
|
|
* (detachable devices only).
|
|
|
|
* Return 0 on success.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
struct net_device * __init cs89x0_probe(int unit)
|
|
|
|
{
|
|
|
|
struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
|
|
|
|
unsigned *port;
|
|
|
|
int err = 0;
|
|
|
|
int irq;
|
|
|
|
int io;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (!dev)
|
|
|
|
return ERR_PTR(-ENODEV);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
sprintf(dev->name, "eth%d", unit);
|
|
|
|
netdev_boot_setup_check(dev);
|
|
|
|
io = dev->base_addr;
|
|
|
|
irq = dev->irq;
|
2008-10-28 06:59:26 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-18 20:56:31 +08:00
|
|
|
if (io > 0x1ff) { /* Check a single specified location. */
|
|
|
|
err = cs89x0_ioport_probe(dev, io, 0);
|
|
|
|
} else if (io != 0) { /* Don't probe at all. */
|
|
|
|
err = -ENXIO;
|
|
|
|
} else {
|
|
|
|
for (port = netcard_portlist; *port; port++) {
|
|
|
|
if (cs89x0_ioport_probe(dev, *port, 0) == 0)
|
|
|
|
break;
|
|
|
|
dev->irq = irq;
|
|
|
|
}
|
|
|
|
if (!*port)
|
|
|
|
err = -ENODEV;
|
|
|
|
}
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
return dev;
|
|
|
|
out:
|
|
|
|
free_netdev(dev);
|
|
|
|
pr_warn("no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
|
|
|
|
return ERR_PTR(err);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-05-18 20:56:31 +08:00
|
|
|
#endif
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-01-27 04:46:15 +08:00
|
|
|
#if defined(MODULE) && !defined(CONFIG_CS89x0_PLATFORM)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static struct net_device *dev_cs89x0;
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
/* Support the 'debug' module parm even if we're compiled for non-debug to
|
2006-09-14 01:24:59 +08:00
|
|
|
* avoid breaking someone's startup scripts
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int io;
|
|
|
|
static int irq;
|
|
|
|
static int debug;
|
|
|
|
static char media[8];
|
2012-05-18 20:56:27 +08:00
|
|
|
static int duplex = -1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
|
|
|
|
static int dma;
|
2012-05-18 20:56:27 +08:00
|
|
|
static int dmasize = 16; /* or 64 */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-04-04 23:54:26 +08:00
|
|
|
module_param_hw(io, int, ioport, 0);
|
|
|
|
module_param_hw(irq, int, irq, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
module_param(debug, int, 0);
|
|
|
|
module_param_string(media, media, sizeof(media), 0);
|
|
|
|
module_param(duplex, int, 0);
|
2017-04-04 23:54:26 +08:00
|
|
|
module_param_hw(dma , int, dma, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
module_param(dmasize , int, 0);
|
|
|
|
module_param(use_dma , int, 0);
|
|
|
|
MODULE_PARM_DESC(io, "cs89x0 I/O base address");
|
|
|
|
MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
|
|
|
|
#if DEBUGGING
|
|
|
|
MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
|
|
|
|
#else
|
|
|
|
MODULE_PARM_DESC(debug, "(ignored)");
|
|
|
|
#endif
|
|
|
|
MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
|
|
|
|
/* No other value than -1 for duplex seems to be currently interpreted */
|
|
|
|
MODULE_PARM_DESC(duplex, "(ignored)");
|
|
|
|
#if ALLOW_DMA
|
|
|
|
MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
|
|
|
|
MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
|
|
|
|
MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
|
|
|
|
#else
|
|
|
|
MODULE_PARM_DESC(dma , "(ignored)");
|
|
|
|
MODULE_PARM_DESC(dmasize , "(ignored)");
|
|
|
|
MODULE_PARM_DESC(use_dma , "(ignored)");
|
|
|
|
#endif
|
|
|
|
|
2008-10-16 13:01:59 +08:00
|
|
|
MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
|
2005-04-17 06:20:36 +08:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
/*
|
2012-05-18 20:56:27 +08:00
|
|
|
* media=t - specify media type
|
|
|
|
* or media=2
|
|
|
|
* or media=aui
|
|
|
|
* or medai=auto
|
|
|
|
* duplex=0 - specify forced half/full/autonegotiate duplex
|
|
|
|
* debug=# - debug level
|
|
|
|
*
|
|
|
|
* Default Chip Configuration:
|
|
|
|
* DMA Burst = enabled
|
|
|
|
* IOCHRDY Enabled = enabled
|
|
|
|
* UseSA = enabled
|
|
|
|
* CS8900 defaults to half-duplex if not specified on command-line
|
|
|
|
* CS8920 defaults to autoneg if not specified on command-line
|
|
|
|
* Use reset defaults for other config parameters
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* media type specified is supported (circuitry is present)
|
|
|
|
* if memory address is > 1MB, then required mem decode hw is present
|
|
|
|
* if 10B-2, then agent other than driver will enable DC/DC converter
|
|
|
|
* (hw or software util)
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-15 13:59:59 +08:00
|
|
|
int __init init_module(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
|
|
|
|
struct net_local *lp;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
#if DEBUGGING
|
|
|
|
net_debug = debug;
|
|
|
|
#else
|
|
|
|
debug = 0;
|
|
|
|
#endif
|
|
|
|
if (!dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
dev->irq = irq;
|
|
|
|
dev->base_addr = io;
|
|
|
|
lp = netdev_priv(dev);
|
|
|
|
|
|
|
|
#if ALLOW_DMA
|
|
|
|
if (use_dma) {
|
|
|
|
lp->use_dma = use_dma;
|
|
|
|
lp->dma = dma;
|
|
|
|
lp->dmasize = dmasize;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_init(&lp->lock);
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
/* boy, they'd better get these right */
|
|
|
|
if (!strcmp(media, "rj45"))
|
2005-04-17 06:20:36 +08:00
|
|
|
lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
|
|
|
|
else if (!strcmp(media, "aui"))
|
|
|
|
lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
|
|
|
|
else if (!strcmp(media, "bnc"))
|
|
|
|
lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
|
|
|
|
else
|
|
|
|
lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
if (duplex == -1)
|
2005-04-17 06:20:36 +08:00
|
|
|
lp->auto_neg_cnf = AUTO_NEG_ENABLE;
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
if (io == 0) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("Module autoprobing not allowed\n");
|
|
|
|
pr_err("Append io=0xNNN\n");
|
2012-05-18 20:56:27 +08:00
|
|
|
ret = -EPERM;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
2012-05-18 20:56:27 +08:00
|
|
|
} else if (io <= 0x1ff) {
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = -ENXIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ALLOW_DMA
|
|
|
|
if (use_dma && dmasize != 16 && dmasize != 64) {
|
2012-05-18 20:56:28 +08:00
|
|
|
pr_err("dma size must be either 16K or 64K, not %dK\n",
|
|
|
|
dmasize);
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = -EPERM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
#endif
|
2012-05-17 15:11:42 +08:00
|
|
|
ret = cs89x0_ioport_probe(dev, io, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dev_cs89x0 = dev;
|
|
|
|
return 0;
|
|
|
|
out:
|
|
|
|
free_netdev(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-06-15 06:50:53 +08:00
|
|
|
void __exit
|
2005-04-17 06:20:36 +08:00
|
|
|
cleanup_module(void)
|
|
|
|
{
|
2012-05-17 15:11:42 +08:00
|
|
|
struct net_local *lp = netdev_priv(dev_cs89x0);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
unregister_netdev(dev_cs89x0);
|
2012-05-17 15:11:42 +08:00
|
|
|
iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
|
|
|
|
ioport_unmap(lp->virt_addr);
|
2005-04-17 06:20:36 +08:00
|
|
|
release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
|
|
|
|
free_netdev(dev_cs89x0);
|
|
|
|
}
|
2012-01-27 04:46:15 +08:00
|
|
|
#endif /* MODULE && !CONFIG_CS89x0_PLATFORM */
|
|
|
|
|
|
|
|
#ifdef CONFIG_CS89x0_PLATFORM
|
|
|
|
static int __init cs89x0_platform_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
|
2012-05-17 15:11:42 +08:00
|
|
|
void __iomem *virt_addr;
|
2012-01-27 04:46:15 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
dev->irq = platform_get_irq(pdev, 0);
|
2014-08-01 23:28:19 +08:00
|
|
|
if (dev->irq <= 0) {
|
|
|
|
dev_warn(&dev->dev, "interrupt resource missing\n");
|
2012-01-27 04:46:15 +08:00
|
|
|
err = -ENXIO;
|
|
|
|
goto free;
|
|
|
|
}
|
|
|
|
|
2019-08-21 21:02:41 +08:00
|
|
|
virt_addr = devm_platform_ioremap_resource(pdev, 0);
|
2014-08-01 23:28:19 +08:00
|
|
|
if (IS_ERR(virt_addr)) {
|
|
|
|
err = PTR_ERR(virt_addr);
|
2012-01-27 04:46:15 +08:00
|
|
|
goto free;
|
|
|
|
}
|
|
|
|
|
2012-05-17 15:11:42 +08:00
|
|
|
err = cs89x0_probe1(dev, virt_addr, 0);
|
2012-01-27 04:46:15 +08:00
|
|
|
if (err) {
|
2012-05-18 20:56:29 +08:00
|
|
|
dev_warn(&dev->dev, "no cs8900 or cs8920 detected\n");
|
2014-08-01 23:28:19 +08:00
|
|
|
goto free;
|
2012-01-27 04:46:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, dev);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
free:
|
|
|
|
free_netdev(dev);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cs89x0_platform_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *dev = platform_get_drvdata(pdev);
|
|
|
|
|
2012-05-18 20:56:27 +08:00
|
|
|
/* This platform_get_resource() call will not return NULL, because
|
2012-05-17 15:11:42 +08:00
|
|
|
* the same call in cs89x0_platform_probe() has returned a non NULL
|
|
|
|
* value.
|
|
|
|
*/
|
2012-01-27 04:46:15 +08:00
|
|
|
unregister_netdev(dev);
|
|
|
|
free_netdev(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-04-18 04:54:34 +08:00
|
|
|
static const struct of_device_id __maybe_unused cs89x0_match[] = {
|
2016-06-13 23:51:05 +08:00
|
|
|
{ .compatible = "cirrus,cs8900", },
|
|
|
|
{ .compatible = "cirrus,cs8920", },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, cs89x0_match);
|
|
|
|
|
2012-01-27 04:46:15 +08:00
|
|
|
static struct platform_driver cs89x0_driver = {
|
|
|
|
.driver = {
|
2016-06-13 23:51:05 +08:00
|
|
|
.name = DRV_NAME,
|
|
|
|
.of_match_table = of_match_ptr(cs89x0_match),
|
2012-01-27 04:46:15 +08:00
|
|
|
},
|
|
|
|
.remove = cs89x0_platform_remove,
|
|
|
|
};
|
|
|
|
|
2013-03-05 00:43:50 +08:00
|
|
|
module_platform_driver_probe(cs89x0_driver, cs89x0_platform_probe);
|
2012-01-27 04:46:15 +08:00
|
|
|
|
|
|
|
#endif /* CONFIG_CS89x0_PLATFORM */
|
2018-01-11 00:30:22 +08:00
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("Crystal Semiconductor (Now Cirrus Logic) CS89[02]0 network driver");
|
|
|
|
MODULE_AUTHOR("Russell Nelson <nelson@crynwr.com>");
|