diff -Nur kernel-source-2.2.19.orig/Documentation/Configure.help kernel-source-2.2.19/Documentation/Configure.help --- kernel-source-2.2.19.orig/Documentation/Configure.help Tue Mar 13 11:37:55 2001 +++ kernel-source-2.2.19/Documentation/Configure.help Thu Aug 30 14:07:09 2001 @@ -6157,6 +6157,27 @@ module, say M here and read Documentation/modules.txt as well as Documentation/networking/net-modules.txt. +COMPEX-RL100a / Winbond-W89c840 PCI Ethernet support +CONFIG_WINBOND_840 + This driver is for the Winbond W89c840 chip. It also works with + the TX9882 chip on the Compex RL100-ATX board. + More specific information and updates are available from + http://cesdis.gsfc.nasa.gov/linux/drivers/ethercard.html + +National Semiconductor DP8382x series PCI Ethernet support +CONFIG_NATSEMI820 + This driver is for the National Semiconductor DP83820 + Gigabit Ethernet adapter series. + More specific information and updates are available from + http://www.scyld.com/network/natsemi.html + +Sundance ST201 "Alta" PCI Ethernet support +CONFIG_SUNDANCE + This driver is for the Sundance ST201 "Alta", as used on the + D-Link DFE-550. + Design information, usage details and updates are available from + http://www.scyld.com/network/ethernet.html + PCI DM9102 support CONFIG_DM9102 This driver is for DM9102 compatible PCI cards from Davicom diff -Nur kernel-source-2.2.19.orig/drivers/net/Config.in kernel-source-2.2.19/drivers/net/Config.in --- kernel-source-2.2.19.orig/drivers/net/Config.in Tue Mar 13 11:38:14 2001 +++ kernel-source-2.2.19/drivers/net/Config.in Thu Aug 30 14:07:09 2001 @@ -160,6 +160,9 @@ tristate 'Novell/Eagle/Microdyne NE3210 EISA support (EXPERIMENTAL)' CONFIG_NE3210 fi tristate 'PCI NE2000 support' CONFIG_NE2K_PCI + tristate 'COMPEX-RL100a / Winbond-W89c840 Ethernet card support' CONFIG_WINBOND_840 + tristate 'National Semiconductor DP8382x series PCI Ethernet support' CONFIG_NATSEMI820 + tristate 'Sundance ST201 "Alta" PCI Ethernet support' CONFIG_SUNDANCE tristate 'TI ThunderLAN support' CONFIG_TLAN tristate 'VIA Rhine support' CONFIG_VIA_RHINE tristate 'SiS 900/7016 PCI Fast Ethernet Adapter support' CONFIG_SIS900 diff -Nur kernel-source-2.2.19.orig/drivers/net/Makefile kernel-source-2.2.19/drivers/net/Makefile --- kernel-source-2.2.19.orig/drivers/net/Makefile Tue Mar 13 11:38:14 2001 +++ kernel-source-2.2.19/drivers/net/Makefile Thu Aug 30 14:15:17 2001 @@ -51,6 +51,10 @@ endif endif +ifeq ($(CONFIG_PCI),y) + L_OBJS += pci-scan.o +endif + ifeq ($(CONFIG_NET),y) L_OBJS += Space.o net_init.o loopback.o endif @@ -192,6 +196,33 @@ endif endif +ifeq ($(CONFIG_WINBOND_840),y) +L_OBJS += winbond-840.o +else + ifeq ($(CONFIG_WINBOND_840),m) + M_OBJS += winbond-840.o + M_OBJS += pci-scan.o + endif +endif + +ifeq ($(CONFIG_NATSEMI820),y) +L_OBJS += ns820.o +else + ifeq ($(CONFIG_NATSEMI820),m) + M_OBJS += ns820.o + M_OBJS += pci-scan.o + endif +endif + +ifeq ($(CONFIG_SUNDANCE),y) +L_OBJS += sundance.o +else + ifeq ($(CONFIG_SUNDANCE),m) + M_OBJS += sundance.o + M_OBJS += pci-scan.o + endif +endif + ifeq ($(CONFIG_NE2K_PCI),y) L_OBJS += ne2k-pci.o CONFIG_8390_BUILTIN = y @@ -793,6 +824,7 @@ L_OBJS += tulip.o else ifeq ($(CONFIG_DEC_ELCP),m) + M_OBJS += pci-scan.o M_OBJS += tulip.o endif endif diff -Nur kernel-source-2.2.19.orig/drivers/net/Space.c kernel-source-2.2.19/drivers/net/Space.c --- kernel-source-2.2.19.orig/drivers/net/Space.c Tue Mar 13 11:38:14 2001 +++ kernel-source-2.2.19/drivers/net/Space.c Thu Aug 30 14:07:09 2001 @@ -49,6 +49,9 @@ extern int wd_probe(struct device *dev); extern int el2_probe(struct device *dev); extern int ne2k_pci_probe(struct device *dev); +extern int winbond840_probe(struct device *dev); +extern int ns820_probe(struct device *dev); +extern int sundance_probe(struct device *dev); extern int ne_probe(struct device *dev); extern int hp_probe(struct device *dev); extern int hp_plus_probe(struct device *dev); @@ -228,6 +231,15 @@ #endif #ifdef CONFIG_NE2K_PCI {ne2k_pci_probe, 0}, +#endif +#ifdef CONFIG_WINBOND_840 + {winbond840_probe, 0}, +#endif +#ifdef CONFIG_NATSEMI820 + {ns820_probe, 0}, +#endif +#ifdef CONFIG_SUNDANCE + {sundance_probe, 0}, #endif #ifdef CONFIG_PCNET32 {pcnet32_probe, 0}, diff -Nur kernel-source-2.2.19.orig/drivers/net/kern_compat.h kernel-source-2.2.19/drivers/net/kern_compat.h --- kernel-source-2.2.19.orig/drivers/net/kern_compat.h Thu Jan 1 01:00:00 1970 +++ kernel-source-2.2.19/drivers/net/kern_compat.h Thu Aug 30 14:07:09 2001 @@ -0,0 +1,216 @@ +#ifndef _KERN_COMPAT_H +#define _KERN_COMPAT_H +/* kern_compat.h: Linux PCI network adapter backward compatibility code. */ +/* + $Revision: 1.9 $ $Date: 2001/07/13 15:43:21 $ + + Kernel compatibility defines. + This file provides macros to mask the difference between kernel versions. + It is designed primarily to allow device drivers to be written so that + they work with a range of kernel versions. + + Written 1999-2001 Donald Becker, Scyld Computing Corporation + This software may be used and distributed according to the terms + of the GNU General Public License (GPL), incorporated herein by + reference. Drivers interacting with these functions are derivative + works and thus are covered the GPL. They must include an explicit + GPL notice. + + This code also provides inline scan and activate functions for PCI network + interfaces. It has an interface identical to pci-scan.c, but is + intended as an include file to simplify using updated drivers with older + kernel versions. + This code version matches pci-scan.c:v0.05 9/16/99 + + The author may be reached as becker@scyld.com, or + Donald Becker + Scyld Computing Corporation + 410 Severn Ave., Suite 210 + Annapolis MD 21403 + + Other contributers: + +*/ + +/* We try to use defined values to decide when an interface has changed or + added features, but we must have the kernel version number for a few. */ +#if ! defined(LINUX_VERSION_CODE) || (LINUX_VERSION_CODE < 0x10000) +#include +#endif +/* Older kernel versions didn't include modversions automatically. */ +#if LINUX_VERSION_CODE < 0x20300 && defined(MODVERSIONS) +#include +#endif + +/* There was no support for PCI address space mapping in 2.0, but the + Alpha needed it. See the 2.2 documentation. */ +#if LINUX_VERSION_CODE < 0x20100 && ! defined(__alpha__) +#define ioremap(a,b)\ + (((unsigned long)(a) >= 0x100000) ? vremap(a,b) : (void*)(a)) +#define iounmap(v)\ + do { if ((unsigned long)(v) >= 0x100000) vfree(v);} while (0) +#endif + +/* Support for adding info about the purpose of and parameters for kernel + modules was added in 2.1. */ +#if LINUX_VERSION_CODE < 0x20115 +#define MODULE_AUTHOR(name) extern int nonesuch +#define MODULE_DESCRIPTION(string) extern int nonesuch +#define MODULE_PARM(varname, typestring) extern int nonesuch +#endif + +/* SMP and better multiarchitecture support were added. + Using an older kernel means we assume a little-endian uniprocessor. +*/ +#if LINUX_VERSION_CODE < 0x20123 +#define hard_smp_processor_id() smp_processor_id() +#define test_and_set_bit(val, addr) set_bit(val, addr) +#define cpu_to_le16(val) (val) +#define cpu_to_le32(val) (val) +#define le16_to_cpu(val) (val) +#define le16_to_cpus(val) /* In-place conversion. */ +#define le32_to_cpu(val) (val) +#define cpu_to_be16(val) ((((val) & 0xff) << 8) + (((val) >> 8) & 0xff)) +#define cpu_to_be32(val) ((cpu_to_be16(val) << 16) + cpu_to_be16((val) >> 16)) +typedef long spinlock_t; +#define SPIN_LOCK_UNLOCKED 0 +#define spin_lock(lock) +#define spin_unlock(lock) +#define spin_lock_irqsave(lock, flags) save_flags(flags); cli(); +#define spin_unlock_irqrestore(lock, flags) restore_flags(flags); +#endif + +#if LINUX_VERSION_CODE <= 0x20139 +#define net_device_stats enet_statistics +#else +#define NETSTATS_VER2 +#endif + +/* These are used by the netdrivers to report values from the + MII (Media Indpendent Interface) management registers. +*/ +#ifndef SIOCGMIIPHY +#define SIOCGMIIPHY (SIOCDEVPRIVATE) /* Get the PHY in use. */ +#define SIOCGMIIREG (SIOCDEVPRIVATE+1) /* Read a PHY register. */ +#define SIOCSMIIREG (SIOCDEVPRIVATE+2) /* Write a PHY register. */ +#endif +#ifndef SIOCGPARAMS +#define SIOCGPARAMS (SIOCDEVPRIVATE+3) /* Read operational parameters. */ +#define SIOCSPARAMS (SIOCDEVPRIVATE+4) /* Set operational parameters. */ +#endif + + +#if LINUX_VERSION_CODE < 0x20155 +#include +#define PCI_SUPPORT_VER1 +/* A minimal version of the 2.2.* PCI support that handles configuration + space access. + Drivers that actually use pci_dev fields must do explicit compatibility. + Note that the struct pci_dev * "pointer" is actually a byte mapped integer! +*/ +#if LINUX_VERSION_CODE < 0x20020 +struct pci_dev { int not_used; }; +#endif + +#define pci_find_slot(bus, devfn) (struct pci_dev*)((bus<<8) | devfn | 0xf0000) +#define bus_number(pci_dev) ((((int)(pci_dev))>>8) & 0xff) +#define devfn_number(pci_dev) (((int)(pci_dev)) & 0xff) + +#ifndef CONFIG_PCI +extern inline int pci_present(void) { return 0; } +#else +#define pci_present pcibios_present +#endif + +#define pci_read_config_byte(pdev, where, valp)\ + pcibios_read_config_byte(bus_number(pdev), devfn_number(pdev), where, valp) +#define pci_read_config_word(pdev, where, valp)\ + pcibios_read_config_word(bus_number(pdev), devfn_number(pdev), where, valp) +#define pci_read_config_dword(pdev, where, valp)\ + pcibios_read_config_dword(bus_number(pdev), devfn_number(pdev), where, valp) +#define pci_write_config_byte(pdev, where, val)\ + pcibios_write_config_byte(bus_number(pdev), devfn_number(pdev), where, val) +#define pci_write_config_word(pdev, where, val)\ + pcibios_write_config_word(bus_number(pdev), devfn_number(pdev), where, val) +#define pci_write_config_dword(pdev, where, val)\ + pcibios_write_config_dword(bus_number(pdev), devfn_number(pdev), where, val) +#else +#define PCI_SUPPORT_VER2 +#endif + +/* The arg count changed, but function name did not. + We cover that bad choice by defining a new name. +*/ +#if LINUX_VERSION_CODE < 0x20159 +#define dev_free_skb(skb) dev_kfree_skb(skb, FREE_WRITE); +#define dev_free_skb_irq(skb) dev_kfree_skb(skb, FREE_WRITE); +#elif LINUX_VERSION_CODE < 0x20400 +#define dev_free_skb(skb) dev_kfree_skb(skb); +#define dev_free_skb_irq(skb) dev_kfree_skb(skb); +#else +#define dev_free_skb(skb) dev_kfree_skb(skb); +#define dev_free_skb_irq(skb) dev_kfree_skb_irq(skb); +#endif + +/* Added at the suggestion of Jes Sorensen. */ +#if LINUX_VERSION_CODE > 0x20153 +#include +#else +#define __init +#define __initdata +#define __initfunc(__arginit) __arginit +#endif + +/* The old 'struct device' used a too-generic name. */ +#if LINUX_VERSION_CODE < 0x2030d +#define net_device device +#endif + +/* The 2.2 kernels added the start of capability-based security for operations + that formerally could only be done by root. +*/ +#if ! defined(CAP_NET_ADMIN) +#define capable(CAP_XXX) (suser()) +#endif + +#if ! defined(HAVE_NETIF_QUEUE) +#define netif_wake_queue(dev) do { clear_bit( 0, (void*)&(dev)->tbusy); mark_bh(NET_BH); } while (0) +#define netif_start_tx_queue(dev) do { (dev)->tbusy = 0; dev->start = 1; } while (0) +#define netif_stop_tx_queue(dev) do { (dev)->tbusy = 1; dev->start = 0; } while (0) +#define netif_queue_paused(dev) ((dev)->tbusy != 0) +/* Splitting these lines exposes a bug in some preprocessors. */ +#define netif_pause_tx_queue(dev) (test_and_set_bit( 0, (void*)&(dev)->tbusy)) +#define netif_unpause_tx_queue(dev) do { clear_bit( 0, (void*)&(dev)->tbusy); } while (0) +#define netif_resume_tx_queue(dev) do { clear_bit( 0, (void*)&(dev)->tbusy); mark_bh(NET_BH); } while (0) + +#define netif_running(dev) ((dev)->start != 0) +#define netif_device_attach(dev) do {; } while (0) +#define netif_device_detach(dev) do {; } while (0) +#define netif_device_present(dev) (1) +#define netif_set_tx_timeout(dev, func, deltajiffs) do {; } while (0) +#define netif_link_down(dev) (dev)->flags &= ~IFF_RUNNING; +#define netif_link_up(dev) (dev)->flags |= IFF_RUNNING + +#else + +#define netif_start_tx_queue(dev) netif_start_queue(dev) +#define netif_stop_tx_queue(dev) netif_stop_queue(dev) +#define netif_queue_paused(dev) netif_queue_stopped(dev) +#define netif_resume_tx_queue(dev) netif_wake_queue(dev) +/* Only used in transmit path. No function in 2.4. */ +#define netif_pause_tx_queue(dev) 0 +#define netif_unpause_tx_queue(dev) do {; } while (0) + +#define netif_link_down(dev) (dev)->flags &= ~IFF_RUNNING; +#define netif_link_up(dev) (dev)->flags |= IFF_RUNNING + +#endif + +#endif +/* + * Local variables: + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -Nur kernel-source-2.2.19.orig/drivers/net/ns820.c kernel-source-2.2.19/drivers/net/ns820.c --- kernel-source-2.2.19.orig/drivers/net/ns820.c Thu Jan 1 01:00:00 1970 +++ kernel-source-2.2.19/drivers/net/ns820.c Thu Aug 30 14:07:09 2001 @@ -0,0 +1,1332 @@ +/* ns820.c: A Linux Gigabit Ethernet driver for the NatSemi DP83820 series. */ +/* + Written/copyright 1999-2001 by Donald Becker. + + This software may be used and distributed according to the terms of + the GNU General Public License (GPL), incorporated herein by reference. + Drivers based on or derived from this code fall under the GPL and must + retain the authorship, copyright and license notice. This file is not + a complete program and may only be used when the entire operating + system is licensed under the GPL. License for under other terms may be + available. Contact the original author for details. + + The original author may be reached as becker@scyld.com, or at + Scyld Computing Corporation + 410 Severn Ave., Suite 210 + Annapolis MD 21403 + + Support information and updates available at + http://www.scyld.com/network/netsemi.html +*/ + +/* These identify the driver base version and may not be removed. */ +static const char version1[] = +"ns820.c:v0.06 7/31/2001 Written by Donald Becker \n"; +static const char version2[] = +" http://www.scyld.com/network/natsemi.html\n"; +/* Updated to recommendations in pci-skeleton v2.08. */ + +/* Automatically extracted configuration info: +probe-func: ns820_probe +config-in: tristate 'National Semiconductor DP8382x series PCI Ethernet support' CONFIG_NATSEMI820 + +c-help-name: National Semiconductor DP8382x series PCI Ethernet support +c-help-symbol: CONFIG_NATSEMI820 +c-help: This driver is for the National Semiconductor DP83820 Gigabit Ethernet +c-help: adapter series. +c-help: More specific information and updates are available from +c-help: http://www.scyld.com/network/natsemi.html +*/ + +/* The user-configurable values. + These may be modified when a driver module is loaded.*/ + +static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */ +/* Maximum events (Rx packets, etc.) to handle at each interrupt. */ +static int max_interrupt_work = 20; + +/* Maximum number of multicast addresses to filter (vs. rx-all-multicast). + This chip uses a 2048 element hash table based on the Ethernet CRC. */ +static int multicast_filter_limit = 100; + +/* Set the copy breakpoint for the copy-only-tiny-frames scheme. + Setting to > 1518 effectively disables this feature. */ +static int rx_copybreak = 0; + +/* Used to pass the media type, etc. + Both 'options[]' and 'full_duplex[]' should exist for driver + interoperability. + The media type is usually passed in 'options[]'. +*/ +#define MAX_UNITS 8 /* More are supported, limit only on options */ +static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1}; +static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +/* Operational parameters that are set at compile time. */ + +/* Keep the ring sizes a power of two for compile efficiency. + The compiler will convert '%'<2^N> into a bit mask. + Making the Tx ring too large decreases the effectiveness of channel + bonding and packet priority. + There are no ill effects from too-large receive rings. */ +#define TX_RING_SIZE 16 +#define TX_QUEUE_LEN 10 /* Limit ring entries actually used, min 4. */ +#define RX_RING_SIZE 64 + +/* Operational parameters that usually are not changed. */ +/* Time in jiffies before concluding the transmitter is hung. */ +#define TX_TIMEOUT (2*HZ) + +/* Size of each temporary Rx buffer. Avoid changing this from the default + of 1536. The default allows sharing the skbuff pool among interfaces. */ +#define PKT_BUF_SZ 1536 + +#ifndef __KERNEL__ +#define __KERNEL__ +#endif +#if !defined(__OPTIMIZE__) +#warning You must compile this file with the correct options! +#warning See the last lines of the source file. +#error You must compile this driver with "-O". +#endif + +/* Include files, designed to support most kernel versions 2.0.0 and later. */ +#include +#if defined(CONFIG_SMP) && ! defined(__SMP__) +#define __SMP__ +#endif +#if defined(MODULE) && defined(CONFIG_MODVERSIONS) && ! defined(MODVERSIONS) +#define MODVERSIONS +#endif + +#include +#include +#if LINUX_VERSION_CODE < 0x20300 && defined(MODVERSIONS) +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include /* Processor type for cache alignment. */ +#include +#include + +#ifdef INLINE_PCISCAN +#include "k_compat.h" +#else +#include "pci-scan.h" +#include "kern_compat.h" +#endif + +#if (LINUX_VERSION_CODE >= 0x20100) && defined(MODULE) +char kernel_version[] = UTS_RELEASE; +#endif + +MODULE_AUTHOR("Donald Becker "); +MODULE_DESCRIPTION("National Semiconductor DP83820 series PCI Ethernet driver"); +MODULE_PARM(max_interrupt_work, "i"); +MODULE_PARM(debug, "i"); +MODULE_PARM(rx_copybreak, "i"); +MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i"); +MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i"); + +/* + Theory of Operation + +I. Board Compatibility + +This driver is designed for National Semiconductor DP83820 10/100/1000 +Ethernet NIC. It is superficially similar to the 810 series "natsemi.c" +driver, however the register layout, descriptor layout and element +length of the new chip series is different. + +II. Board-specific settings + +This driver requires the PCI interrupt line to be configured. +It honors the EEPROM-set values. + +III. Driver operation + +IIIa. Ring buffers + +This driver uses two statically allocated fixed-size descriptor lists +formed into rings by a branch from the final descriptor to the beginning of +the list. The ring sizes are set at compile time by RX/TX_RING_SIZE. +The NatSemi design uses a 'next descriptor' pointer that the driver forms +into a list. + +IIIb/c. Transmit/Receive Structure + +This driver uses a zero-copy receive and transmit scheme. +The driver allocates full frame size skbuffs for the Rx ring buffers at +open() time and passes the skb->data field to the chip as receive data +buffers. When an incoming frame is less than RX_COPYBREAK bytes long, +a fresh skbuff is allocated and the frame is copied to the new skbuff. +When the incoming frame is larger, the skbuff is passed directly up the +protocol stack. Buffers consumed this way are replaced by newly allocated +skbuffs in a later phase of receives. + +The RX_COPYBREAK value is chosen to trade-off the memory wasted by +using a full-sized skbuff for small frames vs. the copying costs of larger +frames. New boards are typically used in generously configured machines +and the underfilled buffers have negligible impact compared to the benefit of +a single allocation size, so the default value of zero results in never +copying packets. When copying is done, the cost is usually mitigated by using +a combined copy/checksum routine. Copying also preloads the cache, which is +most useful with small frames. + +A subtle aspect of the operation is that unaligned buffers are not permitted +by the hardware. Thus the IP header at offset 14 in an ethernet frame isn't +longword aligned for further processing. On copies frames are put into the +skbuff at an offset of "+2", 16-byte aligning the IP header. + +IIId. Synchronization + +The driver runs as two independent, single-threaded flows of control. One +is the send-packet routine, which enforces single-threaded use by the +dev->tbusy flag. The other thread is the interrupt handler, which is single +threaded by the hardware and interrupt handling software. + +The send packet thread has partial control over the Tx ring and 'dev->tbusy' +flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next +queue slot is empty, it clears the tbusy flag when finished otherwise it sets +the 'lp->tx_full' flag. + +The interrupt handler has exclusive control over the Rx ring and records stats +from the Tx ring. After reaping the stats, it marks the Tx queue entry as +empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it +clears both the tx_full and tbusy flags. + +IV. Notes + +NatSemi PCI network controllers are very uncommon. + +IVb. References + +http://www.scyld.com/expert/100mbps.html +http://www.scyld.com/expert/NWay.html +No NatSemi datasheet was publically available at the initial release date. + +IVc. Errata + +None characterised. */ + + + +static void *ns820_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int chip_idx, int find_cnt); +#ifdef USE_IO_OPS +#define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_IO | PCI_ADDR0) +#else +#define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_MEM | PCI_ADDR1) +#endif + +static struct pci_id_info pci_id_tbl[] = { + {"NatSemi DP83820", { 0x0022100B, 0xffffffff }, + PCI_IOTYPE, 256, 0}, + {0,}, /* 0 terminated list. */ +}; + +struct drv_id_info natsemi_drv_id = { + "ns820", 0, PCI_CLASS_NETWORK_ETHERNET<<8, pci_id_tbl, ns820_probe1, }; + +/* Offsets to the device registers. + Unlike software-only systems, device drivers interact with complex hardware. + It's not useful to define symbolic names for every register bit in the + device. +*/ +enum register_offsets { + ChipCmd=0x00, ChipConfig=0x04, EECtrl=0x08, PCIBusCfg=0x0C, + IntrStatus=0x10, IntrMask=0x14, IntrEnable=0x18, IntrHoldoff=0x1C, + TxRingPtr=0x20, TxRingPtrHi=0x24, TxConfig=0x28, + RxRingPtr=0x30, RxRingPtrHi=0x34, RxConfig=0x38, + WOLCmd=0x40, PauseCmd=0x44, RxFilterAddr=0x48, RxFilterData=0x4C, + BootRomAddr=0x50, BootRomData=0x54, ChipRevReg=0x58, + StatsCtrl=0x5C, RxPktErrs=0x60, RxMissed=0x68, RxCRCErrs=0x64, +}; + +/* Bit in ChipCmd. */ +enum ChipCmdBits { + ChipReset=0x100, SoftIntr=0x80, RxReset=0x20, TxReset=0x10, + RxOff=0x08, RxOn=0x04, TxOff=0x02, TxOn=0x01, +}; + +/* Bits in the interrupt status/mask registers. */ +enum intr_status_bits { + IntrRxDone=0x0001, IntrRxIntr=0x0002, IntrRxErr=0x0004, IntrRxEarly=0x0008, + IntrRxIdle=0x0010, IntrRxOverrun=0x0020, + IntrTxDone=0x0040, IntrTxIntr=0x0080, IntrTxErr=0x0100, + IntrTxIdle=0x0200, IntrTxUnderrun=0x0400, + StatsMax=0x0800, LinkChange=0x4000, + WOLPkt=0x2000, + RxResetDone=0x00200000, TxResetDone=0x00400000, + IntrPCIErr=0x001E0000, + IntrNormalSummary=0x0251, IntrAbnormalSummary=0xED20, +}; + +/* Bits in the RxMode register. */ +enum rx_mode_bits { + AcceptErr=0x20, AcceptRunt=0x10, + AcceptBroadcast=0xC0000000, + AcceptMulticast=0x00200000, AcceptAllMulticast=0x20000000, + AcceptAllPhys=0x10000000, AcceptMyPhys=0x08000000, +}; + +/* The Rx and Tx buffer descriptors. */ +/* Note that using only 32 bit fields simplifies conversion to big-endian + architectures. */ +struct netdev_desc { +#if ADDRLEN == 64 + u64 next_desc; + u64 buf_addr; +#endif + u32 next_desc; + u32 buf_addr; + s32 cmd_status; + u32 vlan_status; +}; + +/* Bits in network_desc.status */ +enum desc_status_bits { + DescOwn=0x80000000, DescMore=0x40000000, DescIntr=0x20000000, + DescNoCRC=0x10000000, + DescPktOK=0x08000000, RxTooLong=0x00400000, +}; + +#define PRIV_ALIGN 15 /* Required alignment mask */ +struct netdev_private { + /* Descriptor rings first for alignment. */ + struct netdev_desc rx_ring[RX_RING_SIZE]; + struct netdev_desc tx_ring[TX_RING_SIZE]; + struct net_device *next_module; /* Link for devices of this type. */ + void *priv_addr; /* Unaligned address for kfree */ + const char *product_name; + /* The addresses of receive-in-place skbuffs. */ + struct sk_buff* rx_skbuff[RX_RING_SIZE]; + /* The saved address of a sent-in-place packet/buffer, for later free(). */ + struct sk_buff* tx_skbuff[TX_RING_SIZE]; + struct net_device_stats stats; + struct timer_list timer; /* Media monitoring timer. */ + /* Frequently used values: keep some adjacent for cache effect. */ + int chip_id, drv_flags; + struct pci_dev *pci_dev; + long in_interrupt; /* Word-long for SMP locks. */ + struct netdev_desc *rx_head_desc; + unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */ + unsigned int cur_tx, dirty_tx; + unsigned int rx_buf_sz; /* Based on MTU+slack. */ + unsigned int tx_full:1; /* The Tx queue is full. */ + /* These values are keep track of the transceiver/media in use. */ + unsigned int full_duplex:1; /* Full-duplex operation requested. */ + unsigned int duplex_lock:1; + unsigned int medialock:1; /* Do not sense media. */ + unsigned int default_port:4; /* Last dev->if_port value. */ + /* Rx filter. */ + u32 cur_rx_mode; + u32 rx_filter[16]; + /* FIFO and PCI burst thresholds. */ + int tx_config, rx_config; + /* MII transceiver section. */ + u16 advertising; /* NWay media advertisement */ +}; + +static int eeprom_read(long ioaddr, int location); +static void mdio_sync(long mdio_addr); +static int mdio_read(struct net_device *dev, int phy_id, int location); +static void mdio_write(struct net_device *dev, int phy_id, int location, int value); +static int netdev_open(struct net_device *dev); +static void check_duplex(struct net_device *dev); +static void netdev_timer(unsigned long data); +static void tx_timeout(struct net_device *dev); +static void init_ring(struct net_device *dev); +static int start_tx(struct sk_buff *skb, struct net_device *dev); +static void intr_handler(int irq, void *dev_instance, struct pt_regs *regs); +static void netdev_error(struct net_device *dev, int intr_status); +static int netdev_rx(struct net_device *dev); +static void netdev_error(struct net_device *dev, int intr_status); +static void set_rx_mode(struct net_device *dev); +static struct net_device_stats *get_stats(struct net_device *dev); +static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); +static int netdev_close(struct net_device *dev); + + + +/* A list of our installed devices, for removing the driver module. */ +static struct net_device *root_net_dev = NULL; + +#ifndef MODULE +int ns820_probe(struct net_device *dev) +{ + if (pci_drv_register(&natsemi_drv_id, dev) < 0) + return -ENODEV; + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); + return 0; +} +#endif + +static void *ns820_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int chip_idx, int find_cnt) +{ + struct net_device *dev; + struct netdev_private *np; + void *priv_mem; + int i, option = find_cnt < MAX_UNITS ? options[find_cnt] : 0; + + dev = init_etherdev(init_dev, 0); + + printk(KERN_INFO "%s: %s at 0x%lx, ", + dev->name, pci_id_tbl[chip_idx].name, ioaddr); + + for (i = 0; i < 3; i++) + ((u16 *)dev->dev_addr)[i] = le16_to_cpu(eeprom_read(ioaddr, 12 - i)); + for (i = 0; i < 5; i++) + printk("%2.2x:", dev->dev_addr[i]); + printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq); + + /* Reset the chip to erase previous misconfiguration. */ + writel(ChipReset, ioaddr + ChipCmd); + /* Power up Xcvr. */ + writel(~0x00400200 & readl(ioaddr + ChipConfig), ioaddr + ChipConfig); + + /* Make certain elements e.g. descriptor lists are aligned. */ + priv_mem = kmalloc(sizeof(*np) + PRIV_ALIGN, GFP_KERNEL); + /* Check for the very unlikely case of no memory. */ + if (priv_mem == NULL) + return NULL; + + dev->base_addr = ioaddr; + dev->irq = irq; + + dev->priv = np = (void *)(((long)priv_mem + PRIV_ALIGN) & ~PRIV_ALIGN); + memset(np, 0, sizeof(*np)); + np->priv_addr = priv_mem; + + np->next_module = root_net_dev; + root_net_dev = dev; + + np->pci_dev = pdev; + np->chip_id = chip_idx; + np->drv_flags = pci_id_tbl[chip_idx].drv_flags; + + if (dev->mem_start) + option = dev->mem_start; + + /* The lower four bits are the media type. */ + if (option > 0) { + if (option & 0x200) + np->full_duplex = 1; + np->default_port = option & 15; + if (np->default_port) + np->medialock = 1; + } + if (find_cnt < MAX_UNITS && full_duplex[find_cnt] > 0) + np->full_duplex = 1; + + if (np->full_duplex) + np->duplex_lock = 1; + + /* Initialize the transceiver. Future releases may allow limiting + or forcing the media types. */ + mdio_sync(ioaddr + EECtrl); + + /* The chip-specific entries in the device structure. */ + dev->open = &netdev_open; + dev->hard_start_xmit = &start_tx; + dev->stop = &netdev_close; + dev->get_stats = &get_stats; + dev->set_multicast_list = &set_rx_mode; + dev->do_ioctl = &mii_ioctl; + + return dev; +} + + +/* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. + The EEPROM code is for the common 93c06/46 EEPROMs with 6 bit addresses. */ + +/* Delay between EEPROM clock transitions. + This "delay" forces out buffered PCI writes, which is sufficient to meet + the timing requirements of most EEPROMs. +*/ +#define eeprom_delay(ee_addr) readl(ee_addr) + +enum EEPROM_Ctrl_Bits { + EE_ShiftClk=0x04, EE_DataIn=0x01, EE_ChipSelect=0x08, EE_DataOut=0x02, +}; +#define EE_Write0 (EE_ChipSelect) +#define EE_Write1 (EE_ChipSelect | EE_DataIn) + +/* The EEPROM commands are 4 bits, including the 01 preamble. */ +enum EEPROM_Cmds { + EE_WriteCmd=5, EE_ReadCmd=6, EE_EraseCmd=7, +}; + +static int eeprom_read(long addr, int location) +{ + long eeprom_addr = addr + EECtrl; + int read_cmd = (EE_ReadCmd << 6) | location; + int retval = 0; + int i; + + writel(EE_Write0, eeprom_addr); + + /* Shift the read command bits out. */ + for (i = 10; i >= 0; i--) { + int dataval = (read_cmd & (1 << i)) ? EE_Write1 : EE_Write0; + writel(dataval, eeprom_addr); + eeprom_delay(eeprom_addr); + writel(dataval | EE_ShiftClk, eeprom_addr); + eeprom_delay(eeprom_addr); + } + writel(EE_ChipSelect, eeprom_addr); + eeprom_delay(eeprom_addr); + + for (i = 15; i >= 0; i--) { + writel(EE_ChipSelect | EE_ShiftClk, eeprom_addr); + eeprom_delay(eeprom_addr); + retval |= (readl(eeprom_addr) & EE_DataOut) ? 1 << i : 0; + writel(EE_ChipSelect, eeprom_addr); + eeprom_delay(eeprom_addr); + } + + /* Terminate the EEPROM access. */ + writel(EE_Write0, eeprom_addr); + writel(0, eeprom_addr); + return retval; +} + +/* MII transceiver control section. + Read and write MII registers using software-generated serial MDIO + protocol. See the MII specifications or DP83840A data sheet for details. + + The maximum data clock rate is 2.5 Mhz. To meet minimum timing we + must flush writes to the PCI bus with a PCI read. */ +#define mdio_delay(mdio_addr) readl(mdio_addr) + +/* Set iff a MII transceiver on any interface requires mdio preamble. + This only set with older tranceivers, so the extra + code size of a per-interface flag is not worthwhile. */ +static char mii_preamble_required = 0; + +enum mii_reg_bits { + MDIO_ShiftClk=0x0040, MDIO_Data=0x0010, MDIO_EnbOutput=0x0020, +}; +#define MDIO_EnbIn (0) +#define MDIO_WRITE0 (MDIO_EnbOutput) +#define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput) + +/* Generate the preamble required for initial synchronization and + a few older transceivers. */ +static void mdio_sync(long mdio_addr) +{ + int bits = 32; + + /* Establish sync by sending at least 32 logic ones. */ + while (--bits >= 0) { + writel(MDIO_WRITE1, mdio_addr); + mdio_delay(mdio_addr); + writel(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } +} + +static int mdio_read(struct net_device *dev, int phy_id, int location) +{ + long mdio_addr = dev->base_addr + EECtrl; + int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location; + int i, retval = 0; + + if (mii_preamble_required) + mdio_sync(mdio_addr); + + /* Shift the read command bits out. */ + for (i = 15; i >= 0; i--) { + int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; + + writel(dataval, mdio_addr); + mdio_delay(mdio_addr); + writel(dataval | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + /* Read the two transition, 16 data, and wire-idle bits. */ + for (i = 19; i > 0; i--) { + writel(MDIO_EnbIn, mdio_addr); + mdio_delay(mdio_addr); + retval = (retval << 1) | ((readl(mdio_addr) & MDIO_Data) ? 1 : 0); + writel(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + return (retval>>1) & 0xffff; +} + +static void mdio_write(struct net_device *dev, int phy_id, int location, int value) +{ + long mdio_addr = dev->base_addr + EECtrl; + int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value; + int i; + + if (mii_preamble_required) + mdio_sync(mdio_addr); + + /* Shift the command bits out. */ + for (i = 31; i >= 0; i--) { + int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; + + writel(dataval, mdio_addr); + mdio_delay(mdio_addr); + writel(dataval | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + /* Clear out extra bits. */ + for (i = 2; i > 0; i--) { + writel(MDIO_EnbIn, mdio_addr); + mdio_delay(mdio_addr); + writel(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + return; +} + +static int netdev_open(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int i; + u32 intr_status = readl(ioaddr + IntrStatus); + + /* Do we need to reset the chip??? */ + + MOD_INC_USE_COUNT; + + if (request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev)) { + MOD_DEC_USE_COUNT; + return -EAGAIN; + } + + if (debug > 1) + printk(KERN_DEBUG "%s: netdev_open() irq %d intr_status %8.8x.\n", + dev->name, dev->irq, intr_status); + + init_ring(dev); + +#if defined(ADDR_64BITS) && defined(__alpha__) + writel(virt_to_bus(np->rx_ring) >> 32, ioaddr + RxRingPtrHi); + writel(virt_to_bus(np->tx_ring) >> 32, ioaddr + TxRingPtrHi); +#else + writel(0, ioaddr + RxRingPtrHi); + writel(0, ioaddr + TxRingPtrHi); +#endif + writel(virt_to_bus(np->rx_ring), ioaddr + RxRingPtr); + writel(virt_to_bus(np->tx_ring), ioaddr + TxRingPtr); + + for (i = 0; i < 6; i += 2) { + writel(i, ioaddr + RxFilterAddr); + writew(dev->dev_addr[i] + (dev->dev_addr[i+1] << 8), + ioaddr + RxFilterData); + } + + /* Initialize other registers. */ + /* Configure the PCI bus bursts and FIFO thresholds. */ + /* Configure for standard, in-spec Ethernet. */ + + if (np->full_duplex || + readl(ioaddr + ChipConfig) & 0x20000000) { /* Full duplex */ + np->tx_config = 0xD0801002; + np->rx_config = 0x10000020; + } else { + np->tx_config = 0x10801002; + np->rx_config = 0x0020; + } + writel(np->tx_config, ioaddr + TxConfig); + writel(np->rx_config, ioaddr + RxConfig); + if (debug > 2) + printk(KERN_DEBUG "%s: Setting TxConfig to %8.8x.\n", + dev->name, (int)readl(ioaddr + TxConfig)); + + if (dev->if_port == 0) + dev->if_port = np->default_port; + + np->in_interrupt = 0; + + check_duplex(dev); + set_rx_mode(dev); + netif_start_tx_queue(dev); + + /* Enable interrupts by setting the interrupt mask. */ + writel(IntrNormalSummary | IntrAbnormalSummary | 0x1f, ioaddr + IntrMask); + writel(1, ioaddr + IntrEnable); + + writel(RxOn | TxOn, ioaddr + ChipCmd); + writel(4, ioaddr + StatsCtrl); /* Clear Stats */ + + if (debug > 2) + printk(KERN_DEBUG "%s: Done netdev_open(), status: %x.\n", + dev->name, (int)readl(ioaddr + ChipCmd)); + + /* Set the timer to check for link beat. */ + init_timer(&np->timer); + np->timer.expires = jiffies + 3*HZ; + np->timer.data = (unsigned long)dev; + np->timer.function = &netdev_timer; /* timer handler */ + add_timer(&np->timer); + + return 0; +} + +static void check_duplex(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int duplex; + + if (np->duplex_lock) + return; + duplex = readl(ioaddr + ChipConfig) & 0x20000000 ? 1 : 0; + if (np->full_duplex != duplex) { + np->full_duplex = duplex; + if (debug) + printk(KERN_INFO "%s: Setting %s-duplex based on negotiated link" + " capability.\n", dev->name, + duplex ? "full" : "half"); + if (duplex) { + np->rx_config |= 0x10000000; + np->tx_config |= 0xC0000000; + } else { + np->rx_config &= ~0x10000000; + np->tx_config &= ~0xC0000000; + } + writew(np->tx_config, ioaddr + TxConfig); + writew(np->rx_config, ioaddr + RxConfig); + } +} + +static void netdev_timer(unsigned long data) +{ + struct net_device *dev = (struct net_device *)data; + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int next_tick = 60*HZ; + + if (debug > 3) + printk(KERN_DEBUG "%s: Media selection timer tick, status %8.8x.\n", + dev->name, (int)readl(ioaddr + ChipConfig)); + if (netif_queue_paused(dev) && + np->cur_tx - np->dirty_tx > 1 && + (jiffies - dev->trans_start) > TX_TIMEOUT) { + tx_timeout(dev); + } + check_duplex(dev); + np->timer.expires = jiffies + next_tick; + add_timer(&np->timer); +} + +static void tx_timeout(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + + printk(KERN_WARNING "%s: Transmit timed out, status %8.8x," + " resetting...\n", dev->name, (int)readl(ioaddr + TxRingPtr)); + +#ifndef __alpha__ + { + int i; + printk(KERN_DEBUG " Rx ring %8.8x: ", (int)np->rx_ring); + for (i = 0; i < RX_RING_SIZE; i++) + printk(" %8.8x", (unsigned int)np->rx_ring[i].cmd_status); + printk("\n"KERN_DEBUG" Tx ring %8.8x: ", (int)np->tx_ring); + for (i = 0; i < TX_RING_SIZE; i++) + printk(" %4.4x", np->tx_ring[i].cmd_status); + printk("\n"); + } +#endif + + /* Perhaps we should reinitialize the hardware here. */ + dev->if_port = 0; + /* Stop and restart the chip's Tx processes . */ + + /* Trigger an immediate transmit demand. */ + + dev->trans_start = jiffies; + np->stats.tx_errors++; + return; +} + + +/* Initialize the Rx and Tx rings, along with various 'dev' bits. */ +static void init_ring(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + int i; + + np->tx_full = 0; + np->cur_rx = np->cur_tx = 0; + np->dirty_rx = np->dirty_tx = 0; + + np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); + np->rx_head_desc = &np->rx_ring[0]; + + /* Initialize all Rx descriptors. */ + for (i = 0; i < RX_RING_SIZE; i++) { + np->rx_ring[i].next_desc = virt_to_bus(&np->rx_ring[i+1]); + np->rx_ring[i].cmd_status = cpu_to_le32(DescOwn); + np->rx_skbuff[i] = 0; + } + /* Mark the last entry as wrapping the ring. */ + np->rx_ring[i-1].next_desc = virt_to_bus(&np->rx_ring[0]); + + /* Fill in the Rx buffers. Handle allocation failure gracefully. */ + for (i = 0; i < RX_RING_SIZE; i++) { + struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz); + np->rx_skbuff[i] = skb; + if (skb == NULL) + break; + skb->dev = dev; /* Mark as being used by this device. */ + np->rx_ring[i].buf_addr = virt_to_bus(skb->tail); + np->rx_ring[i].cmd_status = cpu_to_le32(DescIntr | np->rx_buf_sz); + } + np->dirty_rx = (unsigned int)(i - RX_RING_SIZE); + + for (i = 0; i < TX_RING_SIZE; i++) { + np->tx_skbuff[i] = 0; + np->tx_ring[i].next_desc = virt_to_bus(&np->tx_ring[i+1]); + np->tx_ring[i].cmd_status = 0; + } + np->tx_ring[i-1].next_desc = virt_to_bus(&np->tx_ring[0]); + return; +} + +static int start_tx(struct sk_buff *skb, struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + unsigned entry; + + /* Block a timer-based transmit from overlapping. This happens when + packets are presumed lost, and we use this check the Tx status. */ + if (netif_pause_tx_queue(dev) != 0) { + /* This watchdog code is redundant with the media monitor timer. */ + if (jiffies - dev->trans_start > TX_TIMEOUT) + tx_timeout(dev); + return 1; + } + + /* Note: Ordering is important here, set the field with the + "ownership" bit last, and only then increment cur_tx. */ + + /* Calculate the next Tx descriptor entry. */ + entry = np->cur_tx % TX_RING_SIZE; + + np->tx_skbuff[entry] = skb; + + np->tx_ring[entry].buf_addr = virt_to_bus(skb->data); + np->tx_ring[entry].cmd_status = cpu_to_le32(DescOwn|DescIntr | skb->len); + np->cur_tx++; + + /* StrongARM: Explicitly cache flush np->tx_ring and skb->data,skb->len. */ + + if (np->cur_tx - np->dirty_tx >= TX_QUEUE_LEN - 1) { + np->tx_full = 1; + /* Check for a just-cleared queue. */ + if (np->cur_tx - (volatile unsigned int)np->dirty_tx + < TX_QUEUE_LEN - 4) { + np->tx_full = 0; + netif_unpause_tx_queue(dev); + } else + netif_stop_tx_queue(dev); + } else + netif_unpause_tx_queue(dev); + /* Wake the potentially-idle transmit channel. */ + writel(TxOn, dev->base_addr + ChipCmd); + + dev->trans_start = jiffies; + + if (debug > 4) { + printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n", + dev->name, np->cur_tx, entry); + } + return 0; +} + +/* The interrupt handler does all of the Rx thread work and cleans up + after the Tx thread. */ +static void intr_handler(int irq, void *dev_instance, struct pt_regs *rgs) +{ + struct net_device *dev = (struct net_device *)dev_instance; + struct netdev_private *np; + long ioaddr; + int boguscnt = max_interrupt_work; + +#ifndef final_version /* Can never occur. */ + if (dev == NULL) { + printk (KERN_ERR "Netdev interrupt handler(): IRQ %d for unknown " + "device.\n", irq); + return; + } +#endif + + ioaddr = dev->base_addr; + np = (struct netdev_private *)dev->priv; +#if defined(__i386__) && LINUX_VERSION_CODE < 0x020300 + /* A lock to prevent simultaneous entry bug on Intel SMP machines. */ + if (test_and_set_bit(0, (void*)&dev->interrupt)) { + printk(KERN_ERR"%s: SMP simultaneous entry of an interrupt handler.\n", + dev->name); + dev->interrupt = 0; /* Avoid halting machine. */ + return; + } +#endif + + do { + u32 intr_status = readl(ioaddr + IntrStatus); + + if (debug > 4) + printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n", + dev->name, intr_status); + + if (intr_status == 0 || intr_status == 0xffffffff) + break; + + /* Acknowledge all of the current interrupt sources ASAP. */ + writel(intr_status & 0x000ffff, ioaddr + IntrStatus); + + + if (intr_status & (IntrRxDone | IntrRxIntr)) + netdev_rx(dev); + + for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) { + int entry = np->dirty_tx % TX_RING_SIZE; +#ifndef final_version + if (debug > 6) + printk(KERN_DEBUG "%s: Tx status %8.8x.\n", + dev->name, np->tx_ring[entry].cmd_status); +#endif + if (debug > 6) + printk(KERN_DEBUG "%s: Tx entry %d @%p status %8.8x.\n", + dev->name, entry, &np->tx_ring[entry], + np->tx_ring[entry].cmd_status); + if (np->tx_ring[entry].cmd_status & cpu_to_le32(DescOwn)) + break; + if (np->tx_ring[entry].cmd_status & cpu_to_le32(0x08000000)) { + np->stats.tx_packets++; +#if LINUX_VERSION_CODE > 0x20127 + np->stats.tx_bytes += np->tx_skbuff[entry]->len; +#endif + } else { /* Various Tx errors */ + int tx_status = le32_to_cpu(np->tx_ring[entry].cmd_status); + if (tx_status & 0x04010000) np->stats.tx_aborted_errors++; + if (tx_status & 0x02000000) np->stats.tx_fifo_errors++; + if (tx_status & 0x01000000) np->stats.tx_carrier_errors++; + if (tx_status & 0x00200000) np->stats.tx_window_errors++; + np->stats.tx_errors++; + } + /* Free the original skb. */ + dev_free_skb_irq(np->tx_skbuff[entry]); + np->tx_skbuff[entry] = 0; + } + if (np->tx_full + && np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) { + /* The ring is no longer full, allow new TX entries. */ + np->tx_full = 0; + netif_resume_tx_queue(dev); + } + + /* Abnormal error summary/uncommon events handlers. */ + if (intr_status & IntrAbnormalSummary) + netdev_error(dev, intr_status); + + if (--boguscnt < 0) { + printk(KERN_WARNING "%s: Too much work at interrupt, " + "status=0x%4.4x.\n", + dev->name, intr_status); + break; + } + } while (1); + + if (debug > 3) + printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n", + dev->name, (int)readl(ioaddr + IntrStatus)); + +#if defined(__i386__) && LINUX_VERSION_CODE < 0x020300 + clear_bit(0, (void*)&dev->interrupt); +#endif + return; +} + +/* This routine is logically part of the interrupt handler, but separated + for clarity and better register allocation. */ +static int netdev_rx(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + int entry = np->cur_rx % RX_RING_SIZE; + int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx; + s32 desc_status = le32_to_cpu(np->rx_head_desc->cmd_status); + + /* If the driver owns the next entry it's a new packet. Send it up. */ + while (desc_status < 0) { /* e.g. & DescOwn */ + if (debug > 4) + printk(KERN_DEBUG " In netdev_rx() entry %d status was %8.8x.\n", + entry, desc_status); + if (--boguscnt < 0) + break; + if ((desc_status & (DescMore|DescPktOK|RxTooLong)) != DescPktOK) { + if (desc_status & DescMore) { + printk(KERN_WARNING "%s: Oversized(?) Ethernet frame spanned " + "multiple buffers, entry %#x status %x.\n", + dev->name, np->cur_rx, desc_status); + np->stats.rx_length_errors++; + } else { + /* There was a error. */ + if (debug > 2) + printk(KERN_DEBUG " netdev_rx() Rx error was %8.8x.\n", + desc_status); + np->stats.rx_errors++; + if (desc_status & 0x06000000) np->stats.rx_over_errors++; + if (desc_status & 0x00600000) np->stats.rx_length_errors++; + if (desc_status & 0x00140000) np->stats.rx_frame_errors++; + if (desc_status & 0x00080000) np->stats.rx_crc_errors++; + } + } else { + struct sk_buff *skb; + int pkt_len = (desc_status & 0x0fff) - 4; /* Omit CRC size. */ + /* Check if the packet is long enough to accept without copying + to a minimally-sized skbuff. */ + if (pkt_len < rx_copybreak + && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) { + skb->dev = dev; + skb_reserve(skb, 2); /* 16 byte align the IP header */ +#if HAS_IP_COPYSUM + eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0); + skb_put(skb, pkt_len); +#else + memcpy(skb_put(skb, pkt_len), np->rx_skbuff[entry]->tail, + pkt_len); +#endif + } else { + skb_put(skb = np->rx_skbuff[entry], pkt_len); + np->rx_skbuff[entry] = NULL; + } +#ifndef final_version /* Remove after testing. */ + /* You will want this info for the initial debug. */ + if (debug > 5) + printk(KERN_DEBUG " Rx data %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:" + "%2.2x %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x %2.2x%2.2x " + "%d.%d.%d.%d.\n", + skb->data[0], skb->data[1], skb->data[2], skb->data[3], + skb->data[4], skb->data[5], skb->data[6], skb->data[7], + skb->data[8], skb->data[9], skb->data[10], + skb->data[11], skb->data[12], skb->data[13], + skb->data[14], skb->data[15], skb->data[16], + skb->data[17]); +#endif + skb->protocol = eth_type_trans(skb, dev); + /* W/ hardware checksum: skb->ip_summed = CHECKSUM_UNNECESSARY; */ + netif_rx(skb); + dev->last_rx = jiffies; + np->stats.rx_packets++; +#if LINUX_VERSION_CODE > 0x20127 + np->stats.rx_bytes += pkt_len; +#endif + } + entry = (++np->cur_rx) % RX_RING_SIZE; + np->rx_head_desc = &np->rx_ring[entry]; + desc_status = le32_to_cpu(np->rx_head_desc->cmd_status); + } + + /* Refill the Rx ring buffers. */ + for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) { + struct sk_buff *skb; + entry = np->dirty_rx % RX_RING_SIZE; + if (np->rx_skbuff[entry] == NULL) { + skb = dev_alloc_skb(np->rx_buf_sz); + np->rx_skbuff[entry] = skb; + if (skb == NULL) + break; /* Better luck next round. */ + skb->dev = dev; /* Mark as being used by this device. */ + np->rx_ring[entry].buf_addr = virt_to_bus(skb->tail); + } + np->rx_ring[entry].cmd_status = + cpu_to_le32(DescIntr | np->rx_buf_sz); + } + + /* Restart Rx engine if stopped. */ + writel(RxOn, dev->base_addr + ChipCmd); + return 0; +} + +static void netdev_error(struct net_device *dev, int intr_status) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + + if (intr_status & LinkChange) { + printk(KERN_NOTICE "%s: Link changed: Autonegotiation advertising" + " %4.4x partner %4.4x.\n", dev->name, + (int)readl(ioaddr + 0x90), (int)readl(ioaddr + 0x94)); + check_duplex(dev); + } + if (intr_status & StatsMax) { + get_stats(dev); + } + if (intr_status & IntrTxUnderrun) { + if ((np->tx_config & 0x3f) < 62) + np->tx_config += 2; + writew(np->tx_config, ioaddr + TxConfig); + } + if (intr_status & WOLPkt) { + int wol_status = readl(ioaddr + WOLCmd); + printk(KERN_NOTICE "%s: Link wake-up event %8.8x", + dev->name, wol_status); + } + if ((intr_status & ~(LinkChange|StatsMax|RxResetDone|TxResetDone|0xA7ff)) + && debug) + printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n", + dev->name, intr_status); + /* Hmmmmm, it's not clear how to recover from PCI faults. */ + if (intr_status & IntrPCIErr) { + np->stats.tx_fifo_errors++; + np->stats.rx_fifo_errors++; + } +} + +static struct net_device_stats *get_stats(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + int crc_errs = readl(ioaddr + RxCRCErrs); + + if (crc_errs != 0xffffffff) { + /* We need not lock this segment of code for SMP. + The non-atomic-add vulnerability is very small + and statistics are non-critical. */ + /* The chip only need report frame silently dropped. */ + np->stats.rx_crc_errors += crc_errs; + np->stats.rx_missed_errors += readl(ioaddr + RxMissed); + } + + return &np->stats; +} + +/* The little-endian AUTODIN II ethernet CRC calculations. + A big-endian version is also available. + This is slow but compact code. Do not use this routine for bulk data, + use a table-based routine instead. + This is common code and should be moved to net/core/crc.c. + Chips may use the upper or lower CRC bits, and may reverse and/or invert + them. Select the endian-ness that results in minimal calculations. +*/ +static unsigned const ethernet_polynomial_le = 0xedb88320U; +static inline unsigned ether_crc_le(int length, unsigned char *data) +{ + unsigned int crc = 0xffffffff; /* Initial value. */ + while(--length >= 0) { + unsigned char current_octet = *data++; + int bit; + for (bit = 8; --bit >= 0; current_octet >>= 1) { + if ((crc ^ current_octet) & 1) { + crc >>= 1; + crc ^= ethernet_polynomial_le; + } else + crc >>= 1; + } + } + return crc; +} + +static void set_rx_mode(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + u8 mc_filter[64]; /* Multicast hash filter */ + u32 rx_mode; + + if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ + /* Unconditionally log net taps. */ + printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); + rx_mode = AcceptBroadcast | AcceptAllMulticast | AcceptAllPhys + | AcceptMyPhys; + } else if ((dev->mc_count > multicast_filter_limit) + || (dev->flags & IFF_ALLMULTI)) { + rx_mode = AcceptBroadcast | AcceptAllMulticast | AcceptMyPhys; + } else { + struct dev_mc_list *mclist; + int i; + memset(mc_filter, 0, sizeof(mc_filter)); + for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; + i++, mclist = mclist->next) { + set_bit(ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff, + mc_filter); + } + rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys; + for (i = 0; i < 64; i += 2) { + writew(0x200 + i, ioaddr + RxFilterAddr); + writew((mc_filter[i+1]<<8) + mc_filter[i], ioaddr + RxFilterData); + } + } + writel(rx_mode, ioaddr + RxFilterAddr); + np->cur_rx_mode = rx_mode; +} + +static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + u16 *data = (u16 *)&rq->ifr_data; + + switch(cmd) { + case SIOCGMIIPHY: /* Get the address of the PHY in use. */ + data[0] = 1; + /* Fall Through */ + case SIOCGMIIREG: /* Read the specified MII register. */ + data[3] = mdio_read(dev, data[0] & 0x1f, data[1] & 0x1f); + return 0; + case SIOCSMIIREG: /* Write the specified MII register */ + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + if (data[0] == 1) { + u16 miireg = data[1] & 0x1f; + u16 value = data[2]; + switch (miireg) { + case 0: + /* Check for autonegotiation on or reset. */ + np->duplex_lock = (value & 0x9000) ? 0 : 1; + if (np->duplex_lock) + np->full_duplex = (value & 0x0100) ? 1 : 0; + break; + case 4: np->advertising = value; break; + } + } + mdio_write(dev, data[0] & 0x1f, data[1] & 0x1f, data[2]); + return 0; + default: + return -EOPNOTSUPP; + } +} + +static int netdev_close(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + int i; + + netif_stop_tx_queue(dev); + + if (debug > 1) { + printk(KERN_DEBUG "%s: Shutting down ethercard, status was %4.4x " + "Int %2.2x.\n", + dev->name, (int)readl(ioaddr + ChipCmd), + (int)readl(ioaddr + IntrStatus)); + printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n", + dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx); + } + + /* Disable interrupts using the mask. */ + writel(0, ioaddr + IntrMask); + writel(0, ioaddr + IntrEnable); + writel(2, ioaddr + StatsCtrl); /* Freeze Stats */ + + /* Stop the chip's Tx and Rx processes. */ + writel(RxOff | TxOff, ioaddr + ChipCmd); + + del_timer(&np->timer); + get_stats(dev); + +#ifdef __i386__ + if (debug > 2) { + printk("\n"KERN_DEBUG" Tx ring at %8.8x:\n", + (int)virt_to_bus(np->tx_ring)); + for (i = 0; i < TX_RING_SIZE; i++) + printk(" #%d desc. %8.8x %8.8x.\n", + i, np->tx_ring[i].cmd_status, (u32)np->tx_ring[i].buf_addr); + printk("\n"KERN_DEBUG " Rx ring %8.8x:\n", + (int)virt_to_bus(np->rx_ring)); + for (i = 0; i < RX_RING_SIZE; i++) { + printk(KERN_DEBUG " #%d desc. %8.8x %8.8x\n", + i, np->rx_ring[i].cmd_status, (u32)np->rx_ring[i].buf_addr); + } + } +#endif /* __i386__ debugging only */ + + free_irq(dev->irq, dev); + + /* Free all the skbuffs in the Rx queue. */ + for (i = 0; i < RX_RING_SIZE; i++) { + np->rx_ring[i].cmd_status = 0; + np->rx_ring[i].buf_addr = 0xBADF00D0; /* An invalid address. */ + if (np->rx_skbuff[i]) { +#if LINUX_VERSION_CODE < 0x20100 + np->rx_skbuff[i]->free = 1; +#endif + dev_free_skb(np->rx_skbuff[i]); + } + np->rx_skbuff[i] = 0; + } + for (i = 0; i < TX_RING_SIZE; i++) { + if (np->tx_skbuff[i]) + dev_free_skb(np->tx_skbuff[i]); + np->tx_skbuff[i] = 0; + } + + /* Power down Xcvr. */ + writel(0x0200 | readl(ioaddr + ChipConfig), ioaddr + ChipConfig); + + MOD_DEC_USE_COUNT; + + return 0; +} + + +#ifdef MODULE +int init_module(void) +{ + if (debug) /* Emit version even if no cards detected. */ + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); +#ifdef CARDBUS + register_driver(ðerdev_ops); + return 0; +#else + return pci_drv_register(&natsemi_drv_id, NULL); +#endif +} + +void cleanup_module(void) +{ + struct net_device *next_dev; + +#ifdef CARDBUS + unregister_driver(ðerdev_ops); +#else + pci_drv_unregister(&natsemi_drv_id); +#endif + + /* No need to check MOD_IN_USE, as sys_delete_module() checks. */ + while (root_net_dev) { + struct netdev_private *np = (void *)(root_net_dev->priv); + unregister_netdev(root_net_dev); + iounmap((char *)root_net_dev->base_addr); + next_dev = np->next_module; + if (np->priv_addr) + kfree(np->priv_addr); + kfree(root_net_dev); + root_net_dev = next_dev; + } +} + +#endif /* MODULE */ + +/* + * Local variables: + * compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O6 -c ns820.c" + * simple-compile-command: "gcc -DMODULE -O6 -c ns820.c" + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -Nur kernel-source-2.2.19.orig/drivers/net/pci-scan.c kernel-source-2.2.19/drivers/net/pci-scan.c --- kernel-source-2.2.19.orig/drivers/net/pci-scan.c Thu Jan 1 01:00:00 1970 +++ kernel-source-2.2.19/drivers/net/pci-scan.c Thu Aug 30 14:07:09 2001 @@ -0,0 +1,581 @@ +/* pci-scan.c: Linux PCI network adapter support code. */ +/* + Originally written 1999-2001 by Donald Becker. + + This software may be used and distributed according to the terms + of the GNU General Public License (GPL), incorporated herein by + reference. Drivers interacting with these functions are derivative + works and thus are covered the GPL. They must include an explicit + GPL notice. + + This code provides common scan and activate functions for PCI network + interfaces. + + The author may be reached as becker@scyld.com, or + Donald Becker + Scyld Computing Corporation + 410 Severn Ave., Suite 210 + Annapolis MD 21403 + + Other contributers: +*/ +static const char version[] = +"pci-scan.c:v1.06 5/18/2001 Donald Becker " +" http://www.scyld.com/linux/drivers.html\n"; + +/* A few user-configurable values that may be modified when a module. */ + +static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */ +static int min_pci_latency = 32; + +#if ! defined(__KERNEL__) +#define __KERNEL__ 1 +#endif +#if !defined(__OPTIMIZE__) +#warning You must compile this file with the correct options! +#warning See the last lines of the source file. +#error You must compile this driver with the proper options, including "-O". +#endif + +#if defined(MODULE) && ! defined(EXPORT_SYMTAB) +#define EXPORT_SYMTAB +#endif + +#include +#if defined(CONFIG_SMP) && ! defined(__SMP__) +#define __SMP__ +#endif +#if defined(MODULE) && defined(CONFIG_MODVERSIONS) && ! defined(MODVERSIONS) +#define MODVERSIONS +#endif + +#include +#include +/* Older kernels do not include this automatically. */ +#if LINUX_VERSION_CODE < 0x20300 && defined(MODVERSIONS) +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include "pci-scan.h" +#include "kern_compat.h" +#ifdef CONFIG_APM +#include +#endif + +#if (LINUX_VERSION_CODE >= 0x20100) && defined(MODULE) +char kernel_version[] = UTS_RELEASE; +#endif +#if (LINUX_VERSION_CODE < 0x20100) +#define PCI_CAPABILITY_LIST 0x34 /* Offset of first capability list entry */ +#define PCI_STATUS_CAP_LIST 0x10 /* Support Capability List */ +#define PCI_CAP_ID_PM 0x01 /* Power Management */ +#endif + +int (*register_cb_hook)(struct drv_id_info *did); +void (*unregister_cb_hook)(struct drv_id_info *did); + +#if LINUX_VERSION_CODE > 0x20118 && defined(MODULE) +MODULE_PARM(debug, "i"); +MODULE_PARM(min_pci_latency, "i"); +#if defined(EXPORT_SYMTAB) +EXPORT_SYMBOL_NOVERS(pci_drv_register); +EXPORT_SYMBOL_NOVERS(pci_drv_unregister); +EXPORT_SYMBOL_NOVERS(acpi_wake); +EXPORT_SYMBOL_NOVERS(acpi_set_pwr_state); +EXPORT_SYMBOL_NOVERS(register_cb_hook); +EXPORT_SYMBOL_NOVERS(unregister_cb_hook); +#endif +#endif + +/* List of registered drivers. */ +static struct drv_id_info *drv_list; +/* List of detected PCI devices, for APM events. */ +static struct dev_info { + struct dev_info *next; + void *dev; + struct drv_id_info *drv_id; + int flags; +} *dev_list; + +/* + This code is not intended to support every configuration. + It is intended to minimize duplicated code by providing the functions + needed in almost every PCI driver. + + The "no kitchen sink" policy: + Additional features and code will be added to this module only if more + than half of the drivers for common hardware would benefit from the feature. +*/ + +/* + Ideally we would detect and number all cards of a type (e.g. network) in + PCI slot order. + But that does not work with hot-swap card, CardBus cards and added drivers. + So instead we detect just the each chip table in slot order. + + This routine takes a PCI ID table, scans the PCI bus, and calls the + associated attach/probe1 routine with the hardware already activated and + single I/O or memory address already mapped. + + This routine will later be supplemented with CardBus and hot-swap PCI + support using the same table. Thus the pci_chip_tbl[] should not be + marked as __initdata. +*/ + +#if LINUX_VERSION_CODE >= 0x20200 +/* Grrrr.. complex abstaction layers with negative benefit. */ +int pci_drv_register(struct drv_id_info *drv_id, void *initial_device) +{ + int chip_idx, cards_found; + struct pci_dev *pdev = NULL; + struct pci_id_info *pci_tbl = drv_id->pci_dev_tbl; + struct drv_id_info *drv; + void *newdev; + + + /* Ignore a double-register attempt. */ + for (drv = drv_list; drv; drv = drv->next) + if (drv == drv_id) + return -EBUSY; + + for (cards_found = 0; + (pdev = pci_find_class(drv_id->pci_class, pdev)) != 0; + cards_found++) { + u32 pci_id, pci_subsys_id, pci_class_rev; + u16 pci_command, new_command; + int pci_flags; + long pciaddr; /* Bus address. */ + long ioaddr; /* Mapped address for this processor. */ + + pci_read_config_dword(pdev, PCI_VENDOR_ID, &pci_id); + /* Offset 0x2c is PCI_SUBSYSTEM_ID aka PCI_SUBSYSTEM_VENDOR_ID. */ + pci_read_config_dword(pdev, 0x2c, &pci_subsys_id); + pci_read_config_dword(pdev, PCI_REVISION_ID, &pci_class_rev); + + if (debug > 3) + printk(KERN_DEBUG "PCI ID %8.8x subsystem ID is %8.8x.\n", + pci_id, pci_subsys_id); + for (chip_idx = 0; pci_tbl[chip_idx].name; chip_idx++) { + struct pci_id_info *chip = &pci_tbl[chip_idx]; + if ((pci_id & chip->id.pci_mask) == chip->id.pci + && (pci_subsys_id&chip->id.subsystem_mask) == chip->id.subsystem + && (pci_class_rev&chip->id.revision_mask) == chip->id.revision) + break; + } + if (pci_tbl[chip_idx].name == 0) /* Compiled out! */ + continue; + + pci_flags = pci_tbl[chip_idx].pci_flags; +#if LINUX_VERSION_CODE >= 0x2030C + /* Wow. A oversized, hard-to-use abstraction. Bogus. */ + pciaddr = pdev->resource[(pci_flags >> 4) & 7].start; +#else + pciaddr = pdev->base_address[(pci_flags >> 4) & 7]; +#if defined(__alpha__) /* Really any machine with 64 bit addressing. */ + if (pci_flags & PCI_ADDR_64BITS) + pciaddr |= ((long)pdev->base_address[((pci_flags>>4)&7)+ 1]) << 32; +#endif +#endif + if (debug > 2) + printk(KERN_INFO "Found %s at PCI address %#lx, mapped IRQ %d.\n", + pci_tbl[chip_idx].name, pciaddr, pdev->irq); + + if ( ! (pci_flags & PCI_UNUSED_IRQ) && + (pdev->irq == 0 || pdev->irq == 255)) { + if (pdev->bus->number == 32) /* Broken CardBus activation. */ + printk(KERN_WARNING "Resources for CardBus device '%s' have" + " not been allocated.\n" + KERN_WARNING "Activation has been delayed.\n", + pci_tbl[chip_idx].name); + else + printk(KERN_WARNING "PCI device '%s' was not assigned an " + "IRQ.\n" + KERN_WARNING "It will not be activated.\n", + pci_tbl[chip_idx].name); + continue; + } + if ((pciaddr & PCI_BASE_ADDRESS_SPACE_IO)) { + ioaddr = pciaddr & PCI_BASE_ADDRESS_IO_MASK; + if (check_region(ioaddr, pci_tbl[chip_idx].io_size)) + continue; + } else if ((ioaddr = (long)ioremap(pciaddr & PCI_BASE_ADDRESS_MEM_MASK, + pci_tbl[chip_idx].io_size)) == 0) { + printk(KERN_INFO "Failed to map PCI address %#lx for device " + "'%s'.\n", pciaddr, pci_tbl[chip_idx].name); + continue; + } + if ( ! (pci_flags & PCI_NO_ACPI_WAKE)) + acpi_wake(pdev); + pci_read_config_word(pdev, PCI_COMMAND, &pci_command); + new_command = pci_command | (pci_flags & 7); + if (pci_command != new_command) { + printk(KERN_INFO " The PCI BIOS has not enabled the" + " device at %d/%d! Updating PCI command %4.4x->%4.4x.\n", + pdev->bus->number, pdev->devfn, pci_command, new_command); + pci_write_config_word(pdev, PCI_COMMAND, new_command); + } + + newdev = drv_id->probe1(pdev, initial_device, + ioaddr, pdev->irq, chip_idx, cards_found); + if (newdev == NULL) + continue; + initial_device = 0; + if (pci_flags & PCI_COMMAND_MASTER) { + pci_set_master(pdev); + if ( ! (pci_flags & PCI_NO_MIN_LATENCY)) { + u8 pci_latency; + pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency); + if (pci_latency < min_pci_latency) { + printk(KERN_INFO " PCI latency timer (CFLT) is " + "unreasonably low at %d. Setting to %d clocks.\n", + pci_latency, min_pci_latency); + pci_write_config_byte(pdev, PCI_LATENCY_TIMER, + min_pci_latency); + } + } + } + { + struct dev_info *devp = + kmalloc(sizeof(struct dev_info), GFP_KERNEL); + if (devp == 0) + continue; + devp->next = dev_list; + devp->dev = newdev; + devp->drv_id = drv_id; + dev_list = devp; + } + } + + if (((drv_id->flags & PCI_HOTSWAP) + && register_cb_hook && (*register_cb_hook)(drv_id) == 0) + || cards_found) { + MOD_INC_USE_COUNT; + drv_id->next = drv_list; + drv_list = drv_id; + return 0; + } else + return -ENODEV; +} +#else +int pci_drv_register(struct drv_id_info *drv_id, void *initial_device) +{ + int pci_index, cards_found = 0; + unsigned char pci_bus, pci_device_fn; + struct pci_dev *pdev; + struct pci_id_info *pci_tbl = drv_id->pci_dev_tbl; + void *newdev; + + if ( ! pcibios_present()) + return -ENODEV; + + for (pci_index = 0; pci_index < 0xff; pci_index++) { + u32 pci_id, subsys_id, pci_class_rev; + u16 pci_command, new_command; + int chip_idx, irq, pci_flags; + long pciaddr; + long ioaddr; + u32 pci_busaddr; + u8 pci_irq_line; + + if (pcibios_find_class (drv_id->pci_class, pci_index, + &pci_bus, &pci_device_fn) + != PCIBIOS_SUCCESSFUL) + break; + pcibios_read_config_dword(pci_bus, pci_device_fn, + PCI_VENDOR_ID, &pci_id); + /* Offset 0x2c is PCI_SUBSYSTEM_ID aka PCI_SUBSYSTEM_VENDOR_ID. */ + pcibios_read_config_dword(pci_bus, pci_device_fn, 0x2c, &subsys_id); + pcibios_read_config_dword(pci_bus, pci_device_fn, + PCI_REVISION_ID, &pci_class_rev); + + for (chip_idx = 0; pci_tbl[chip_idx].name; chip_idx++) { + struct pci_id_info *chip = &pci_tbl[chip_idx]; + if ((pci_id & chip->id.pci_mask) == chip->id.pci + && (subsys_id & chip->id.subsystem_mask) == chip->id.subsystem + && (pci_class_rev&chip->id.revision_mask) == chip->id.revision) + break; + } + if (pci_tbl[chip_idx].name == 0) /* Compiled out! */ + continue; + + pci_flags = pci_tbl[chip_idx].pci_flags; + pdev = pci_find_slot(pci_bus, pci_device_fn); + pcibios_read_config_byte(pci_bus, pci_device_fn, + PCI_INTERRUPT_LINE, &pci_irq_line); + irq = pci_irq_line; + pcibios_read_config_dword(pci_bus, pci_device_fn, + ((pci_flags >> 2) & 0x1C) + 0x10, + &pci_busaddr); + pciaddr = pci_busaddr; +#if defined(__alpha__) + if (pci_flags & PCI_ADDR_64BITS) { + pcibios_read_config_dword(pci_bus, pci_device_fn, + ((pci_flags >> 2) & 0x1C) + 0x14, + &pci_busaddr); + pciaddr |= ((long)pci_busaddr)<<32; + } +#endif + + if (debug > 2) + printk(KERN_INFO "Found %s at PCI address %#lx, IRQ %d.\n", + pci_tbl[chip_idx].name, pciaddr, irq); + + if ( ! (pci_flags & PCI_UNUSED_IRQ) && + (irq == 0 || irq == 255)) { + if (pci_bus == 32) /* Broken CardBus activation. */ + printk(KERN_WARNING "Resources for CardBus device '%s' have" + " not been allocated.\n" + KERN_WARNING "It will not be activated.\n", + pci_tbl[chip_idx].name); + else + printk(KERN_WARNING "PCI device '%s' was not assigned an " + "IRQ.\n" + KERN_WARNING "It will not be activated.\n", + pci_tbl[chip_idx].name); + continue; + } + + if ((pciaddr & PCI_BASE_ADDRESS_SPACE_IO)) { + ioaddr = pciaddr & PCI_BASE_ADDRESS_IO_MASK; + if (check_region(ioaddr, pci_tbl[chip_idx].io_size)) + continue; + } else if ((ioaddr = (long)ioremap(pciaddr & PCI_BASE_ADDRESS_MEM_MASK, + pci_tbl[chip_idx].io_size)) == 0) { + printk(KERN_INFO "Failed to map PCI address %#lx.\n", + pciaddr); + continue; + } + + if ( ! (pci_flags & PCI_NO_ACPI_WAKE)) + acpi_wake(pdev); + pcibios_read_config_word(pci_bus, pci_device_fn, + PCI_COMMAND, &pci_command); + new_command = pci_command | (pci_flags & 7); + if (pci_command != new_command) { + printk(KERN_INFO " The PCI BIOS has not enabled the" + " device at %d/%d! Updating PCI command %4.4x->%4.4x.\n", + pci_bus, pci_device_fn, pci_command, new_command); + pcibios_write_config_word(pci_bus, pci_device_fn, + PCI_COMMAND, new_command); + } + + newdev = drv_id->probe1(pdev, initial_device, + ioaddr, irq, chip_idx, cards_found); + + if (newdev && (pci_flags & PCI_COMMAND_MASTER) && + ! (pci_flags & PCI_NO_MIN_LATENCY)) { + u8 pci_latency; + pcibios_read_config_byte(pci_bus, pci_device_fn, + PCI_LATENCY_TIMER, &pci_latency); + if (pci_latency < min_pci_latency) { + printk(KERN_INFO " PCI latency timer (CFLT) is " + "unreasonably low at %d. Setting to %d clocks.\n", + pci_latency, min_pci_latency); + pcibios_write_config_byte(pci_bus, pci_device_fn, + PCI_LATENCY_TIMER, min_pci_latency); + } + } + if (newdev) { + struct dev_info *devp = + kmalloc(sizeof(struct dev_info), GFP_KERNEL); + if (devp) { + devp->next = dev_list; + devp->dev = newdev; + devp->drv_id = drv_id; + dev_list = devp; + } + } + initial_device = 0; + cards_found++; + } + + if (((drv_id->flags & PCI_HOTSWAP) + && register_cb_hook && (*register_cb_hook)(drv_id) == 0) + || cards_found) { + MOD_INC_USE_COUNT; + drv_id->next = drv_list; + drv_list = drv_id; + return 0; + } else + return cards_found ? 0 : -ENODEV; +} +#endif + +void pci_drv_unregister(struct drv_id_info *drv_id) +{ + struct drv_id_info **drvp; + struct dev_info **devip = &dev_list; + + if (unregister_cb_hook) + (*unregister_cb_hook)(drv_id); + + for (drvp = &drv_list; *drvp; drvp = &(*drvp)->next) + if (*drvp == drv_id) { + *drvp = (*drvp)->next; + MOD_DEC_USE_COUNT; + break; + } + while (*devip) { + struct dev_info *thisdevi = *devip; + if (thisdevi->drv_id == drv_id) { + *devip = thisdevi->next; + kfree(thisdevi); + } else + devip = &(*devip)->next; + } + + return; +} + +/* + Search PCI configuration space for the specified capability registers. + Return the index, or 0 on failure. +*/ +int pci_find_capability(struct pci_dev *pdev, int findtype) +{ + u16 pci_status, cap_type; + u8 pci_cap_idx; + int cap_idx; + + pci_read_config_word(pdev, PCI_STATUS, &pci_status); + if ( ! (pci_status & PCI_STATUS_CAP_LIST)) + return 0; + pci_read_config_byte(pdev, PCI_CAPABILITY_LIST, &pci_cap_idx); + cap_idx = pci_cap_idx; + for (cap_idx = pci_cap_idx; cap_idx; cap_idx = (cap_type >> 8) & 0xff) { + pci_read_config_word(pdev, cap_idx, &cap_type); + if ((cap_type & 0xff) == findtype) + return cap_idx; + } + return 0; +} + + +/* Change a device from D3 (sleep) to D0 (active). + Return the old power state. + This is more complicated than you might first expect since most cards + forget all PCI config info during the transition! */ +int acpi_wake(struct pci_dev *pdev) +{ + u32 base[5], romaddr; + u16 pci_command, pwr_command; + u8 pci_latency, pci_cacheline, irq; + int i, pwr_cmd_idx = pci_find_capability(pdev, PCI_CAP_ID_PM); + + if (pwr_cmd_idx == 0) + return 0; + pci_read_config_word(pdev, pwr_cmd_idx + 4, &pwr_command); + if ((pwr_command & 3) == 0) + return 0; + pci_read_config_word(pdev, PCI_COMMAND, &pci_command); + for (i = 0; i < 5; i++) + pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0 + i*4, + &base[i]); + pci_read_config_dword(pdev, PCI_ROM_ADDRESS, &romaddr); + pci_read_config_byte( pdev, PCI_LATENCY_TIMER, &pci_latency); + pci_read_config_byte( pdev, PCI_CACHE_LINE_SIZE, &pci_cacheline); + pci_read_config_byte( pdev, PCI_INTERRUPT_LINE, &irq); + + pci_write_config_word(pdev, pwr_cmd_idx + 4, 0x0000); + for (i = 0; i < 5; i++) + if (base[i]) + pci_write_config_dword(pdev, PCI_BASE_ADDRESS_0 + i*4, + base[i]); + pci_write_config_dword(pdev, PCI_ROM_ADDRESS, romaddr); + pci_write_config_byte( pdev, PCI_INTERRUPT_LINE, irq); + pci_write_config_byte( pdev, PCI_CACHE_LINE_SIZE, pci_cacheline); + pci_write_config_byte( pdev, PCI_LATENCY_TIMER, pci_latency); + pci_write_config_word( pdev, PCI_COMMAND, pci_command | 5); + return pwr_command & 3; +} + +int acpi_set_pwr_state(struct pci_dev *pdev, enum acpi_pwr_state new_state) +{ + u16 pwr_command; + int pwr_cmd_idx = pci_find_capability(pdev, PCI_CAP_ID_PM); + + if (pwr_cmd_idx == 0) + return 0; + pci_read_config_word(pdev, pwr_cmd_idx + 4, &pwr_command); + if ((pwr_command & 3) == ACPI_D3 && new_state != ACPI_D3) + acpi_wake(pdev); /* The complicated sequence. */ + pci_write_config_word(pdev, pwr_cmd_idx + 4, + (pwr_command & ~3) | new_state); + return pwr_command & 3; +} + +#if defined(CONFIG_APM) +static int handle_apm_event(apm_event_t event) +{ + static int down = 0; + struct dev_info *devi; + + if (debug > 1) + printk(KERN_DEBUG "pci-scan: Handling APM event %d for driver " + "list %s...\n", + event, drv_list->name); + return 0; + switch (event) { + case APM_SYS_SUSPEND: + case APM_USER_SUSPEND: + if (down) { + printk(KERN_DEBUG "pci-scan: Received extra suspend event\n"); + break; + } + down = 1; + for (devi = dev_list; devi; devi = devi->next) + if (devi->drv_id->pwr_event) + devi->drv_id->pwr_event(devi->dev, DRV_SUSPEND); + break; + case APM_NORMAL_RESUME: + case APM_CRITICAL_RESUME: + if (!down) { + printk(KERN_DEBUG "pci-scan: Received bogus resume event\n"); + break; + } + for (devi = dev_list; devi; devi = devi->next) + if (devi->drv_id->pwr_event) + devi->drv_id->pwr_event(devi->dev, DRV_RESUME); + down = 0; + break; + } + return 0; +} +#endif /* CONFIG_APM */ + +#ifdef MODULE +int init_module(void) +{ +#if defined(CONFIG_APM) + apm_register_callback(&handle_apm_event); +#endif + return 0; +} +void cleanup_module(void) +{ +#if defined(CONFIG_APM) + apm_unregister_callback(&handle_apm_event); +#endif + if (dev_list != NULL) + printk(KERN_WARNING "pci-scan: Unfreed device references.\n"); + return; +} +#endif + + +/* + * Local variables: + * compile-command: "gcc -DMODULE -D__KERNEL__ -DEXPORT_SYMTAB -Wall -Wstrict-prototypes -O6 -c pci-scan.c" + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -Nur kernel-source-2.2.19.orig/drivers/net/pci-scan.h kernel-source-2.2.19/drivers/net/pci-scan.h --- kernel-source-2.2.19.orig/drivers/net/pci-scan.h Thu Jan 1 01:00:00 1970 +++ kernel-source-2.2.19/drivers/net/pci-scan.h Thu Aug 30 14:07:09 2001 @@ -0,0 +1,90 @@ +#ifndef _PCI_SCAN_H +#define _PCI_SCAN_H +/* + version 1.02 $Version:$ $Date: 2001/03/18 21:35:59 $ + Copyright 1999-2001 Donald Becker / Scyld Computing Corporation + This software is part of the Linux kernel. It may be used and + distributed according to the terms of the GNU Public License, + incorporated herein by reference. +*/ + +/* + These are the structures in the table that drives the PCI probe routines. + Note the matching code uses a bitmask: more specific table entries should + be placed before "catch-all" entries. + + The table must be zero terminated. +*/ +enum pci_id_flags_bits { + /* Set PCI command register bits before calling probe1(). */ + PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4, + /* Read and map the single following PCI BAR. */ + PCI_ADDR0=0<<4, PCI_ADDR1=1<<4, PCI_ADDR2=2<<4, PCI_ADDR3=3<<4, + PCI_ADDR_64BITS=0x100, PCI_NO_ACPI_WAKE=0x200, PCI_NO_MIN_LATENCY=0x400, + PCI_UNUSED_IRQ=0x800, +}; + +struct pci_id_info { + const char *name; + struct match_info { + int pci, pci_mask, subsystem, subsystem_mask; + int revision, revision_mask; /* Only 8 bits. */ + } id; + enum pci_id_flags_bits pci_flags; + int io_size; /* Needed for I/O region check or ioremap(). */ + int drv_flags; /* Driver use, intended as capability flags. */ +}; + +enum drv_id_flags { + PCI_HOTSWAP=1, /* Leave module loaded for Cardbus-like chips. */ +}; +enum drv_pwr_action { + DRV_NOOP, /* No action. */ + DRV_ATTACH, /* The driver may expect power ops. */ + DRV_SUSPEND, /* Machine suspending, next event RESUME or DETACH. */ + DRV_RESUME, /* Resume from previous SUSPEND */ + DRV_DETACH, /* Card will-be/is gone. Valid from SUSPEND! */ + DRV_PWR_WakeOn, /* Put device in e.g. Wake-On-LAN mode. */ + DRV_PWR_DOWN, /* Go to lowest power mode. */ + DRV_PWR_UP, /* Go to normal power mode. */ +}; + +struct drv_id_info { + const char *name; /* Single-word driver name. */ + int flags; + int pci_class; /* Typically PCI_CLASS_NETWORK_ETHERNET<<8. */ + struct pci_id_info *pci_dev_tbl; + void *(*probe1)(struct pci_dev *pdev, void *dev_ptr, + long ioaddr, int irq, int table_idx, int fnd_cnt); + /* Optional, called for suspend, resume and detach. */ + int (*pwr_event)(void *dev, int event); + /* Internal values. */ + struct drv_id_info *next; + void *cb_ops; +}; + +/* PCI scan and activate. + Scan PCI-like hardware, calling probe1(..,dev,..) on devices that match. + Returns -ENODEV, a negative number, if no cards are found. */ + +extern int pci_drv_register(struct drv_id_info *drv_id, void *initial_device); +extern void pci_drv_unregister(struct drv_id_info *drv_id); + + +/* ACPI routines. + Wake (change to ACPI D0 state) or set the ACPI power level of a sleeping + ACPI device. Returns the old power state. */ + +int acpi_wake(struct pci_dev *pdev); +enum acpi_pwr_state {ACPI_D0, ACPI_D1, ACPI_D2, ACPI_D3}; +int acpi_set_pwr_state(struct pci_dev *pdev, enum acpi_pwr_state state); + + +/* + * Local variables: + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ +#endif diff -Nur kernel-source-2.2.19.orig/drivers/net/sundance.c kernel-source-2.2.19/drivers/net/sundance.c --- kernel-source-2.2.19.orig/drivers/net/sundance.c Thu Jan 1 01:00:00 1970 +++ kernel-source-2.2.19/drivers/net/sundance.c Thu Aug 30 14:07:09 2001 @@ -0,0 +1,1359 @@ +/* sundance.c: A Linux device driver for the Sundance ST201 "Alta". */ +/* + Written 1999-2001 by Donald Becker. + + This software may be used and distributed according to the terms of + the GNU General Public License (GPL), incorporated herein by reference. + Drivers based on or derived from this code fall under the GPL and must + retain the authorship, copyright and license notice. This file is not + a complete program and may only be used when the entire operating + system is licensed under the GPL. + + The author may be reached as becker@scyld.com, or C/O + Scyld Computing Corporation + 410 Severn Ave., Suite 210 + Annapolis MD 21403 + + Support and updates available at + http://www.scyld.com/network/sundance.html +*/ + +/* These identify the driver base version and may not be removed. */ +static const char version1[] = +"sundance.c:v1.04 7/27/2001 Written by Donald Becker\n"; +static const char version2[] = +" http://www.scyld.com/network/sundance.html\n"; + +/* The user-configurable values. + These may be modified when a driver module is loaded.*/ + +static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */ +/* Maximum events (Rx packets, etc.) to handle at each interrupt. */ +static int max_interrupt_work = 20; +static int mtu = 0; +/* Maximum number of multicast addresses to filter (vs. rx-all-multicast). + Typical is a 64 element hash table based on the Ethernet CRC. */ +static int multicast_filter_limit = 32; + +/* Set the copy breakpoint for the copy-only-tiny-frames scheme. + Setting to > 1518 effectively disables this feature. + This chip can receive into offset buffers, so the Alpha does not + need a copy-align. */ +static int rx_copybreak = 0; + +/* Used to pass the media type, etc. + Both 'options[]' and 'full_duplex[]' should exist for driver + interoperability. + The media type is usually passed in 'options[]'. +*/ +#define MAX_UNITS 8 /* More are supported, limit only on options */ +static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1}; +static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +/* Automatically extracted configuration info: +probe-func: sundance_probe +config-in: tristate 'Sundance ST201 "Alta" PCI Ethernet support' CONFIG_SUNDANCE +c-help-name: Sundance ST201 "Alta" PCI Ethernet support +c-help-symbol: CONFIG_SUNDANCE +c-help: This driver is for the Sundance ST201 "Alta", as used on the +c-help: D-Link DFE-550. +c-help: Design information, usage details and updates are available from +c-help: http://www.scyld.com/network/ethernet.html +*/ + +/* Operational parameters that are set at compile time. */ + +/* Keep the ring sizes a power of two for compile efficiency. + The compiler will convert '%'<2^N> into a bit mask. + Making the Tx ring too large decreases the effectiveness of channel + bonding and packet priority, and more than 128 requires modifying the + Tx error recovery. + Large receive rings merely waste memory. */ +#define TX_RING_SIZE 16 +#define TX_QUEUE_LEN 10 /* Limit ring entries actually used. */ +#define RX_RING_SIZE 32 + +/* Operational parameters that usually are not changed. */ +/* Time in jiffies before concluding the transmitter is hung. */ +#define TX_TIMEOUT (2*HZ) + +#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/ + +#ifndef __KERNEL__ +#define __KERNEL__ +#endif +#if !defined(__OPTIMIZE__) +#warning You must compile this file with the correct options! +#warning See the last lines of the source file. +#error You must compile this driver with "-O". +#endif + +/* Include files, designed to support most kernel versions 2.0.0 and later. */ +#include +#if defined(CONFIG_SMP) && ! defined(__SMP__) +#define __SMP__ +#endif +#if defined(MODULE) && defined(CONFIG_MODVERSIONS) && ! defined(MODVERSIONS) +#define MODVERSIONS +#endif + +#include +#include +#if LINUX_VERSION_CODE < 0x20300 && defined(MODVERSIONS) +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if LINUX_VERSION_CODE >= 0x20300 +#include +#elif LINUX_VERSION_CODE >= 0x20200 +#include +#endif + +#ifdef INLINE_PCISCAN +#include "k_compat.h" +#else +#include "pci-scan.h" +#include "kern_compat.h" +#endif + +/* Condensed operations for readability. */ +#define virt_to_le32desc(addr) cpu_to_le32(virt_to_bus(addr)) +#define le32desc_to_virt(addr) bus_to_virt(le32_to_cpu(addr)) + +#if (LINUX_VERSION_CODE >= 0x20100) && defined(MODULE) +char kernel_version[] = UTS_RELEASE; +#endif + +MODULE_AUTHOR("Donald Becker "); +MODULE_DESCRIPTION("Sundance Alta Ethernet driver"); +MODULE_PARM(max_interrupt_work, "i"); +MODULE_PARM(mtu, "i"); +MODULE_PARM(debug, "i"); +MODULE_PARM(rx_copybreak, "i"); +MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i"); +MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i"); +MODULE_PARM(multicast_filter_limit, "i"); + +/* + Theory of Operation + +I. Board Compatibility + +This driver is designed for the Sundance Technologies "Alta" ST201 chip. + +II. Board-specific settings + +This is an all-in-one chip, so there are no board-specific settings. + +III. Driver operation + +IIIa. Ring buffers + +This driver uses two statically allocated fixed-size descriptor lists +formed into rings by a branch from the final descriptor to the beginning of +the list. The ring sizes are set at compile time by RX/TX_RING_SIZE. +Some chips explicitly use only 2^N sized rings, while others use a +'next descriptor' pointer that the driver forms into rings. + +IIIb/c. Transmit/Receive Structure + +This driver uses a zero-copy receive and transmit scheme. +The driver allocates full frame size skbuffs for the Rx ring buffers at +open() time and passes the skb->data field to the chip as receive data +buffers. When an incoming frame is less than RX_COPYBREAK bytes long, +a fresh skbuff is allocated and the frame is copied to the new skbuff. +When the incoming frame is larger, the skbuff is passed directly up the +protocol stack. Buffers consumed this way are replaced by newly allocated +skbuffs in a later phase of receives. + +The RX_COPYBREAK value is chosen to trade-off the memory wasted by +using a full-sized skbuff for small frames vs. the copying costs of larger +frames. New boards are typically used in generously configured machines +and the underfilled buffers have negligible impact compared to the benefit of +a single allocation size, so the default value of zero results in never +copying packets. When copying is done, the cost is usually mitigated by using +a combined copy/checksum routine. Copying also preloads the cache, which is +most useful with small frames. + +A subtle aspect of the operation is that the IP header at offset 14 in an +ethernet frame isn't longword aligned for further processing. +Unaligned buffers are permitted by the Sundance hardware, so +frames are received into the skbuff at an offset of "+2", 16-byte aligning +the IP header. + +IIId. Synchronization + +The driver runs as two independent, single-threaded flows of control. One +is the send-packet routine, which enforces single-threaded use by the +dev->tbusy flag. The other thread is the interrupt handler, which is single +threaded by the hardware and interrupt handling software. + +The send packet thread has partial control over the Tx ring and 'dev->tbusy' +flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next +queue slot is empty, it clears the tbusy flag when finished otherwise it sets +the 'lp->tx_full' flag. + +The interrupt handler has exclusive control over the Rx ring and records stats +from the Tx ring. After reaping the stats, it marks the Tx queue entry as +empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it +clears both the tx_full and tbusy flags. + +IV. Notes + +IVb. References + +The Sundance ST201 datasheet, preliminary version. +http://www.scyld.com/expert/100mbps.html +http://www.scyld.com/expert/NWay.html + +IVc. Errata + +*/ + + + +static void *sundance_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int chip_idx, int find_cnt); +enum chip_capability_flags {CanHaveMII=1, }; +#ifdef USE_IO_OPS +#define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_IO | PCI_ADDR0) +#else +#define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_MEM | PCI_ADDR1) +#endif + +static struct pci_id_info pci_id_tbl[] = { + {"OEM Sundance Technology ST201", {0x10021186, 0xffffffff, }, + PCI_IOTYPE, 128, CanHaveMII}, + {"Sundance Technology Alta", {0x020113F0, 0xffffffff, }, + PCI_IOTYPE, 128, CanHaveMII}, + {0,}, /* 0 terminated list. */ +}; + +struct drv_id_info sundance_drv_id = { + "sundance", 0, PCI_CLASS_NETWORK_ETHERNET<<8, pci_id_tbl, sundance_probe1, +}; + +/* This driver was written to use PCI memory space, however x86-oriented + hardware often uses I/O space accesses. */ +#ifdef USE_IO_OPS +#undef readb +#undef readw +#undef readl +#undef writeb +#undef writew +#undef writel +#define readb inb +#define readw inw +#define readl inl +#define writeb outb +#define writew outw +#define writel outl +#endif + +/* Offsets to the device registers. + Unlike software-only systems, device drivers interact with complex hardware. + It's not useful to define symbolic names for every register bit in the + device. The name can only partially document the semantics and make + the driver longer and more difficult to read. + In general, only the important configuration values or bits changed + multiple times should be defined symbolically. +*/ +enum alta_offsets { + DMACtrl=0x00, TxListPtr=0x04, TxDMACtrl=0x08, TxDescPoll=0x0a, + RxDMAStatus=0x0c, RxListPtr=0x10, RxDMACtrl=0x14, RxDescPoll=0x16, + LEDCtrl=0x1a, ASICCtrl=0x30, + EEData=0x34, EECtrl=0x36, TxThreshold=0x3c, + FlashAddr=0x40, FlashData=0x44, TxStatus=0x46, DownCounter=0x48, + IntrClear=0x4a, IntrEnable=0x4c, IntrStatus=0x4e, + MACCtrl0=0x50, MACCtrl1=0x52, StationAddr=0x54, + MaxTxSize=0x5A, RxMode=0x5c, MIICtrl=0x5e, + MulticastFilter0=0x60, MulticastFilter1=0x64, + RxOctetsLow=0x68, RxOctetsHigh=0x6a, TxOctetsLow=0x6c, TxOctetsHigh=0x6e, + TxFramesOK=0x70, RxFramesOK=0x72, StatsCarrierError=0x74, + StatsLateColl=0x75, StatsMultiColl=0x76, StatsOneColl=0x77, + StatsTxDefer=0x78, RxMissed=0x79, StatsTxXSDefer=0x7a, StatsTxAbort=0x7b, + StatsBcastTx=0x7c, StatsBcastRx=0x7d, StatsMcastTx=0x7e, StatsMcastRx=0x7f, + /* Aliased and bogus values! */ + RxStatus=0x0c, +}; + +/* Bits in the interrupt status/mask registers. */ +enum intr_status_bits { + IntrSummary=0x0001, IntrPCIErr=0x0002, IntrMACCtrl=0x0008, + IntrTxDone=0x0004, IntrRxDone=0x0010, IntrRxStart=0x0020, + IntrDrvRqst=0x0040, + StatsMax=0x0080, LinkChange=0x0100, + IntrTxDMADone=0x0200, IntrRxDMADone=0x0400, +}; + +/* Bits in the RxMode register. */ +enum rx_mode_bits { + AcceptAllIPMulti=0x20, AcceptMultiHash=0x10, AcceptAll=0x08, + AcceptBroadcast=0x04, AcceptMulticast=0x02, AcceptMyPhys=0x01, +}; +/* Bits in MACCtrl. */ +enum mac_ctrl0_bits { + EnbFullDuplex=0x20, EnbRcvLargeFrame=0x40, + EnbFlowCtrl=0x100, EnbPassRxCRC=0x200, +}; +enum mac_ctrl1_bits { + StatsEnable=0x0020, StatsDisable=0x0040, StatsEnabled=0x0080, + TxEnable=0x0100, TxDisable=0x0200, TxEnabled=0x0400, + RxEnable=0x0800, RxDisable=0x1000, RxEnabled=0x2000, +}; + +/* The Rx and Tx buffer descriptors. */ +/* Note that using only 32 bit fields simplifies conversion to big-endian + architectures. */ +struct netdev_desc { + u32 next_desc; + u32 status; + struct desc_frag { u32 addr, length; } frag[1]; +}; + +/* Bits in netdev_desc.status */ +enum desc_status_bits { + DescOwn=0x8000, DescEndPacket=0x4000, DescEndRing=0x2000, + DescTxDMADone=0x10000, + LastFrag=0x80000000, DescIntrOnTx=0x8000, DescIntrOnDMADone=0x80000000, +}; + +#define PRIV_ALIGN 15 /* Required alignment mask */ +/* Use __attribute__((aligned (L1_CACHE_BYTES))) to maintain alignment + within the structure. */ +struct netdev_private { + /* Descriptor rings first for alignment. */ + struct netdev_desc rx_ring[RX_RING_SIZE]; + struct netdev_desc tx_ring[TX_RING_SIZE]; + struct net_device *next_module; /* Link for devices of this type. */ + void *priv_addr; /* Unaligned address for kfree */ + const char *product_name; + /* The addresses of receive-in-place skbuffs. */ + struct sk_buff* rx_skbuff[RX_RING_SIZE]; + /* The saved address of a sent-in-place packet/buffer, for later free(). */ + struct sk_buff* tx_skbuff[TX_RING_SIZE]; + struct net_device_stats stats; + struct timer_list timer; /* Media monitoring timer. */ + /* Frequently used values: keep some adjacent for cache effect. */ + int chip_id, drv_flags; + struct pci_dev *pci_dev; + /* Word-long for SMP locks. */ + long in_interrupt; + /* Note: Cache paragraph grouped variables. */ + struct netdev_desc *rx_head_desc; + unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */ + unsigned int rx_buf_sz; /* Based on MTU+slack. */ + spinlock_t txlock; /* Group with Tx control cache line. */ + struct netdev_desc *last_tx; /* Last Tx descriptor used. */ + unsigned int cur_tx, dirty_tx; + unsigned int tx_full:1; /* The Tx queue is full. */ + /* These values are keep track of the transceiver/media in use. */ + unsigned int full_duplex:1; /* Full-duplex operation requested. */ + unsigned int duplex_lock:1; + unsigned int medialock:1; /* Do not sense media. */ + unsigned int default_port:4; /* Last dev->if_port value. */ + /* Multicast and receive mode. */ + spinlock_t mcastlock; /* SMP lock multicast updates. */ + u16 mcast_filter[4]; + /* MII transceiver section. */ + int mii_cnt; /* MII device addresses. */ + u16 advertising; /* NWay media advertisement */ + unsigned char phys[2]; /* MII device addresses. */ +}; + +/* The station address location in the EEPROM. */ +#define EEPROM_SA_OFFSET 0x10 + +static int eeprom_read(long ioaddr, int location); +static int mdio_read(struct net_device *dev, int phy_id, int location); +static void mdio_write(struct net_device *dev, int phy_id, int location, int value); +static int netdev_open(struct net_device *dev); +static void check_duplex(struct net_device *dev); +static void netdev_timer(unsigned long data); +static void tx_timeout(struct net_device *dev); +static void init_ring(struct net_device *dev); +static int start_tx(struct sk_buff *skb, struct net_device *dev); +static void intr_handler(int irq, void *dev_instance, struct pt_regs *regs); +static void netdev_error(struct net_device *dev, int intr_status); +static int netdev_rx(struct net_device *dev); +static void netdev_error(struct net_device *dev, int intr_status); +static void set_rx_mode(struct net_device *dev); +static struct net_device_stats *get_stats(struct net_device *dev); +static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); +static int netdev_close(struct net_device *dev); + + + +/* A list of our installed devices, for removing the driver module. */ +static struct net_device *root_net_dev = NULL; + +#ifndef MODULE +int sundance_probe(struct net_device *dev) +{ + static int didthat = 0; + if (didthat) + return; + if (pci_drv_register(&sundance_drv_id, dev) < 0) + return -ENODEV; + didthat = 1; + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); + return 0; +} +#endif + +static void *sundance_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int chip_idx, int card_idx) +{ + struct net_device *dev; + struct netdev_private *np; + void *priv_mem; + int i, option = card_idx < MAX_UNITS ? options[card_idx] : 0; + + dev = init_etherdev(init_dev, 0); + if (!dev) + return NULL; + + printk(KERN_INFO "%s: %s at 0x%lx, ", + dev->name, pci_id_tbl[chip_idx].name, ioaddr); + + for (i = 0; i < 3; i++) + ((u16 *)dev->dev_addr)[i] = + le16_to_cpu(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET)); + for (i = 0; i < 5; i++) + printk("%2.2x:", dev->dev_addr[i]); + printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq); + + /* Make certain elements e.g. descriptor lists are aligned. */ + priv_mem = kmalloc(sizeof(*np) + PRIV_ALIGN, GFP_KERNEL); + /* Check for the very unlikely case of no memory. */ + if (priv_mem == NULL) + return NULL; + + /* All failure checks before this point. + We do a request_region() only to register /proc/ioports info. */ +#ifdef USE_IO_OPS + request_region(ioaddr, pci_tbl[chip_idx].io_size, dev->name); +#endif + + dev->base_addr = ioaddr; + dev->irq = irq; + + dev->priv = np = (void *)(((long)priv_mem + PRIV_ALIGN) & ~PRIV_ALIGN); + memset(np, 0, sizeof(*np)); + np->priv_addr = priv_mem; + + np->next_module = root_net_dev; + root_net_dev = dev; + + np->pci_dev = pdev; + np->chip_id = chip_idx; + np->drv_flags = pci_id_tbl[chip_idx].drv_flags; + + if (dev->mem_start) + option = dev->mem_start; + + if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0) + np->full_duplex = 1; + + if (np->full_duplex) + np->medialock = 1; + + /* The chip-specific entries in the device structure. */ + dev->open = &netdev_open; + dev->hard_start_xmit = &start_tx; + dev->stop = &netdev_close; + dev->get_stats = &get_stats; + dev->set_multicast_list = &set_rx_mode; + dev->do_ioctl = &mii_ioctl; + + if (mtu) + dev->mtu = mtu; + + if (1) { + int phy, phy_idx = 0; + np->phys[0] = 1; /* Default setting */ + for (phy = 0; phy < 32 && phy_idx < 4; phy++) { + int mii_status = mdio_read(dev, phy, 1); + if (mii_status != 0xffff && mii_status != 0x0000) { + np->phys[phy_idx++] = phy; + np->advertising = mdio_read(dev, phy, 4); + printk(KERN_INFO "%s: MII PHY found at address %d, status " + "0x%4.4x advertising %4.4x.\n", + dev->name, phy, mii_status, np->advertising); + } + } + np->mii_cnt = phy_idx; + if (phy_idx == 0) + printk(KERN_INFO "%s: No MII transceiver found!, ASIC status %x\n", + dev->name, (int)readl(ioaddr + ASICCtrl)); + } + + /* Allow forcing the media the media type. */ + if (option > 0) { + if (option & 0x220) + np->full_duplex = 1; + np->default_port = option & 0x3ff; + if (np->default_port & 0x330) { + np->medialock = 1; + printk(KERN_INFO " Forcing %dMbs %s-duplex operation.\n", + (option & 0x300 ? 100 : 10), + (option & 0x220 ? "full" : "half")); + mdio_write(dev, np->phys[0], 0, + ((option & 0x300) ? 0x2000 : 0) | /* 100mbps? */ + ((option & 0x220) ? 0x0100 : 0)); /* Full duplex? */ + } + } + + /* Perhaps move the reset here? */ + /* Reset the chip to erase previous misconfiguration. */ + if (debug > 1) + printk("ASIC Control is %x.\n", (int)readl(ioaddr + ASICCtrl)); + writew(0x007f, ioaddr + ASICCtrl + 2); + if (debug > 1) + printk("ASIC Control is now %x.\n", (int)readl(ioaddr + ASICCtrl)); + + return dev; +} + + +/* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */ +static int eeprom_read(long ioaddr, int location) +{ + int boguscnt = 1000; /* Typical 190 ticks. */ + writew(0x0200 | (location & 0xff), ioaddr + EECtrl); + do { + if (! (readw(ioaddr + EECtrl) & 0x8000)) { + return readw(ioaddr + EEData); + } + } while (--boguscnt > 0); + return 0; +} + +/* MII transceiver control section. + Read and write the MII registers using software-generated serial + MDIO protocol. See the MII specifications or DP83840A data sheet + for details. + + The maximum data clock rate is 2.5 Mhz. The minimum timing is usually + met by back-to-back 33Mhz PCI cycles. */ +#define mdio_delay() readb(mdio_addr) + +/* Set iff a MII transceiver on any interface requires mdio preamble. + This only set with older tranceivers, so the extra + code size of a per-interface flag is not worthwhile. */ +static char mii_preamble_required = 0; + +enum mii_reg_bits { + MDIO_ShiftClk=0x0001, MDIO_Data=0x0002, MDIO_EnbOutput=0x0004, +}; +#define MDIO_EnbIn (0) +#define MDIO_WRITE0 (MDIO_EnbOutput) +#define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput) + +/* Generate the preamble required for initial synchronization and + a few older transceivers. */ +static void mdio_sync(long mdio_addr) +{ + int bits = 32; + + /* Establish sync by sending at least 32 logic ones. */ + while (--bits >= 0) { + writeb(MDIO_WRITE1, mdio_addr); + mdio_delay(); + writeb(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr); + mdio_delay(); + } +} + +static int mdio_read(struct net_device *dev, int phy_id, int location) +{ + long mdio_addr = dev->base_addr + MIICtrl; + int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location; + int i, retval = 0; + + if (mii_preamble_required) + mdio_sync(mdio_addr); + + /* Shift the read command bits out. */ + for (i = 15; i >= 0; i--) { + int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; + + writeb(dataval, mdio_addr); + mdio_delay(); + writeb(dataval | MDIO_ShiftClk, mdio_addr); + mdio_delay(); + } + /* Read the two transition, 16 data, and wire-idle bits. */ + for (i = 19; i > 0; i--) { + writeb(MDIO_EnbIn, mdio_addr); + mdio_delay(); + retval = (retval << 1) | ((readb(mdio_addr) & MDIO_Data) ? 1 : 0); + writeb(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr); + mdio_delay(); + } + return (retval>>1) & 0xffff; +} + +static void mdio_write(struct net_device *dev, int phy_id, int location, int value) +{ + long mdio_addr = dev->base_addr + MIICtrl; + int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value; + int i; + + if (mii_preamble_required) + mdio_sync(mdio_addr); + + /* Shift the command bits out. */ + for (i = 31; i >= 0; i--) { + int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; + + writeb(dataval, mdio_addr); + mdio_delay(); + writeb(dataval | MDIO_ShiftClk, mdio_addr); + mdio_delay(); + } + /* Clear out extra bits. */ + for (i = 2; i > 0; i--) { + writeb(MDIO_EnbIn, mdio_addr); + mdio_delay(); + writeb(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr); + mdio_delay(); + } + return; +} + + +static int netdev_open(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int i; + + /* Do we need to reset the chip??? */ + + MOD_INC_USE_COUNT; + + if (request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev)) { + MOD_DEC_USE_COUNT; + return -EAGAIN; + } + + if (debug > 1) + printk(KERN_DEBUG "%s: netdev_open() irq %d.\n", + dev->name, dev->irq); + + init_ring(dev); + + writel(virt_to_bus(np->rx_ring), ioaddr + RxListPtr); + /* The Tx list pointer is written as packets are queued. */ + + for (i = 0; i < 6; i++) + writeb(dev->dev_addr[i], ioaddr + StationAddr + i); + + /* Initialize other registers. */ + /* Configure the PCI bus bursts and FIFO thresholds. */ + + if (dev->if_port == 0) + dev->if_port = np->default_port; + + np->in_interrupt = 0; + np->full_duplex = np->duplex_lock; + np->mcastlock = (spinlock_t) SPIN_LOCK_UNLOCKED; + + set_rx_mode(dev); + writew(0, ioaddr + DownCounter); + /* Set the chip to poll every N*320nsec. */ + writeb(100, ioaddr + RxDescPoll); + writeb(127, ioaddr + TxDescPoll); + netif_start_tx_queue(dev); + + /* Enable interrupts by setting the interrupt mask. */ + writew(IntrRxDone | IntrRxDMADone | IntrPCIErr | IntrDrvRqst | IntrTxDone + | StatsMax | LinkChange, ioaddr + IntrEnable); + + writew(StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1); + + if (debug > 2) + printk(KERN_DEBUG "%s: Done netdev_open(), status: Rx %x Tx %x " + "MAC Control %x, %4.4x %4.4x.\n", + dev->name, (int)readl(ioaddr + RxStatus), + (int)readb(ioaddr + TxStatus), (int)readl(ioaddr + MACCtrl0), + (int)readw(ioaddr + MACCtrl1), (int)readw(ioaddr + MACCtrl0)); + + /* Set the timer to check for link beat. */ + init_timer(&np->timer); + np->timer.expires = jiffies + 3*HZ; + np->timer.data = (unsigned long)dev; + np->timer.function = &netdev_timer; /* timer handler */ + add_timer(&np->timer); + + return 0; +} + +static void check_duplex(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int mii_reg5 = mdio_read(dev, np->phys[0], 5); + int negotiated = mii_reg5 & np->advertising; + int duplex; + + if (np->duplex_lock || mii_reg5 == 0xffff) + return; + duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040; + if (np->full_duplex != duplex) { + np->full_duplex = duplex; + if (debug) + printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d " + "negotiated capability %4.4x.\n", dev->name, + duplex ? "full" : "half", np->phys[0], negotiated); + writew(duplex ? 0x20 : 0, ioaddr + MACCtrl0); + } +} + +static void netdev_timer(unsigned long data) +{ + struct net_device *dev = (struct net_device *)data; + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int next_tick = 10*HZ; + + if (debug > 3) { + printk(KERN_DEBUG "%s: Media selection timer tick, intr status %4.4x, " + "Tx %x Rx %x.\n", + dev->name, (int)readw(ioaddr + IntrEnable), + (int)readb(ioaddr + TxStatus), (int)readl(ioaddr + RxStatus)); + } + /* Note: This does not catch a 0 or 1 element stuck queue. */ + if (netif_queue_paused(dev) && + np->cur_tx - np->dirty_tx > 1 && + (jiffies - dev->trans_start) > TX_TIMEOUT) { + tx_timeout(dev); + } + check_duplex(dev); + np->timer.expires = jiffies + next_tick; + add_timer(&np->timer); +} + +static void tx_timeout(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + + printk(KERN_WARNING "%s: Transmit timed out, status %2.2x," + " resetting...\n", dev->name, (int)readb(ioaddr + TxStatus)); + +#ifndef __alpha__ + { + int i; + printk(KERN_DEBUG " Rx ring %8.8x: ", (int)np->rx_ring); + for (i = 0; i < RX_RING_SIZE; i++) + printk(" %8.8x", (unsigned int)np->rx_ring[i].status); + printk("\n"KERN_DEBUG" Tx ring %8.8x: ", (int)np->tx_ring); + for (i = 0; i < TX_RING_SIZE; i++) + printk(" %8.8x", np->tx_ring[i].status); + printk("\n"); + } +#endif + + /* Perhaps we should reinitialize the hardware here. */ + dev->if_port = 0; + /* Stop and restart the chip's Tx processes . */ + + /* Trigger an immediate transmit demand. */ + writew(IntrRxDone | IntrRxDMADone | IntrPCIErr | IntrDrvRqst | IntrTxDone + | StatsMax | LinkChange, ioaddr + IntrEnable); + + dev->trans_start = jiffies; + np->stats.tx_errors++; + return; +} + + +/* Initialize the Rx and Tx rings, along with various 'dev' bits. */ +static void init_ring(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + int i; + + np->tx_full = 0; + np->cur_rx = np->cur_tx = 0; + np->dirty_rx = np->dirty_tx = 0; + + np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); + np->rx_head_desc = &np->rx_ring[0]; + + /* Initialize all Rx descriptors. */ + for (i = 0; i < RX_RING_SIZE; i++) { + np->rx_ring[i].next_desc = virt_to_le32desc(&np->rx_ring[i+1]); + np->rx_ring[i].status = 0; + np->rx_ring[i].frag[0].length = 0; + np->rx_skbuff[i] = 0; + } + /* Wrap the ring. */ + np->rx_ring[i-1].next_desc = virt_to_le32desc(&np->rx_ring[0]); + + /* Fill in the Rx buffers. Handle allocation failure gracefully. */ + for (i = 0; i < RX_RING_SIZE; i++) { + struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz); + np->rx_skbuff[i] = skb; + if (skb == NULL) + break; + skb->dev = dev; /* Mark as being used by this device. */ + skb_reserve(skb, 2); /* 16 byte align the IP header. */ + np->rx_ring[i].frag[0].addr = virt_to_le32desc(skb->tail); + np->rx_ring[i].frag[0].length = cpu_to_le32(np->rx_buf_sz | LastFrag); + } + np->dirty_rx = (unsigned int)(i - RX_RING_SIZE); + + for (i = 0; i < TX_RING_SIZE; i++) { + np->tx_skbuff[i] = 0; + np->tx_ring[i].status = 0; + } + return; +} + +static int start_tx(struct sk_buff *skb, struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + struct netdev_desc *txdesc; + unsigned entry; + + /* Block a timer-based transmit from overlapping. */ + if (netif_pause_tx_queue(dev) != 0) { + /* This watchdog code is redundant with the media monitor timer. */ + if (jiffies - dev->trans_start > TX_TIMEOUT) + tx_timeout(dev); + return 1; + } + + /* Note: Ordering is important here, set the field with the + "ownership" bit last, and only then increment cur_tx. */ + + /* Calculate the next Tx descriptor entry. */ + entry = np->cur_tx % TX_RING_SIZE; + np->tx_skbuff[entry] = skb; + txdesc = &np->tx_ring[entry]; + + txdesc->next_desc = 0; + /* Note: disable the interrupt generation here before releasing. */ + txdesc->status = + cpu_to_le32((entry<<2) | DescIntrOnDMADone | DescIntrOnTx | 1); + txdesc->frag[0].addr = virt_to_le32desc(skb->data); + txdesc->frag[0].length = cpu_to_le32(skb->len | LastFrag); + if (np->last_tx) + np->last_tx->next_desc = virt_to_le32desc(txdesc); + np->last_tx = txdesc; + np->cur_tx++; + + /* On some architectures: explicitly flush cache lines here. */ + + if (np->cur_tx - np->dirty_tx >= TX_QUEUE_LEN - 1) { + np->tx_full = 1; + /* Check for a just-cleared queue. */ + if (np->cur_tx - (volatile unsigned int)np->dirty_tx + < TX_QUEUE_LEN - 2) { + np->tx_full = 0; + netif_unpause_tx_queue(dev); + } + } else + netif_unpause_tx_queue(dev); /* Typical path */ + + /* Side effect: The read wakes the potentially-idle transmit channel. */ + if (readl(dev->base_addr + TxListPtr) == 0) + writel(virt_to_bus(&np->tx_ring[entry]), dev->base_addr + TxListPtr); + + dev->trans_start = jiffies; + + if (debug > 4) { + printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n", + dev->name, np->cur_tx, entry); + } + return 0; +} + +/* The interrupt handler does all of the Rx thread work and cleans up + after the Tx thread. */ +static void intr_handler(int irq, void *dev_instance, struct pt_regs *rgs) +{ + struct net_device *dev = (struct net_device *)dev_instance; + struct netdev_private *np; + long ioaddr; + int boguscnt = max_interrupt_work; + + ioaddr = dev->base_addr; + np = (struct netdev_private *)dev->priv; + + do { + int intr_status = readw(ioaddr + IntrStatus); + if (intr_status == 0 || intr_status == 0xffff) + break; + + writew(intr_status & (IntrRxDone | IntrRxDMADone | IntrPCIErr | + IntrDrvRqst |IntrTxDone|IntrTxDMADone | + StatsMax | LinkChange), + ioaddr + IntrStatus); + + if (debug > 4) + printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n", + dev->name, intr_status); + + if (intr_status & (IntrRxDone|IntrRxDMADone)) + netdev_rx(dev); + + if (intr_status & IntrTxDone) { + int boguscnt = 32; + int tx_status = readw(ioaddr + TxStatus); + while (tx_status & 0x80) { + if (debug > 4) + printk("%s: Transmit status is %2.2x.\n", + dev->name, tx_status); + if (tx_status & 0x1e) { + if (debug > 3) + printk("%s: Transmit error, status %2.2x.\n", + dev->name, tx_status); + np->stats.tx_errors++; + if (tx_status & 0x10) np->stats.tx_fifo_errors++; +#ifdef ETHER_STATS + if (tx_status & 0x08) np->stats.collisions16++; +#else + if (tx_status & 0x08) np->stats.collisions++; +#endif + if (tx_status & 0x04) np->stats.tx_fifo_errors++; + if (tx_status & 0x02) np->stats.tx_window_errors++; + /* This reset has not been verified!. */ + if (tx_status & 0x10) { /* Reset the Tx. */ + writew(0x001c, ioaddr + ASICCtrl + 2); +#if 0 /* Do we need to reset the Tx pointer here? */ + writel(virt_to_bus(&np->tx_ring[np->dirty_tx]), + dev->base_addr + TxListPtr); +#endif + } + if (tx_status & 0x1e) /* Restart the Tx. */ + writew(TxEnable, ioaddr + MACCtrl1); + } + /* Yup, this is a documentation bug. It cost me *hours*. */ + writew(0, ioaddr + TxStatus); + tx_status = readb(ioaddr + TxStatus); + if (--boguscnt < 0) + break; + } + } + for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) { + int entry = np->dirty_tx % TX_RING_SIZE; + if ( ! (np->tx_ring[entry].status & cpu_to_le32(DescTxDMADone))) + break; + /* Free the original skb. */ + dev_free_skb_irq(np->tx_skbuff[entry]); + np->tx_skbuff[entry] = 0; + } + if (np->tx_full + && np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) { + /* The ring is no longer full, allow new TX entries. */ + np->tx_full = 0; + netif_resume_tx_queue(dev); + } + + /* Abnormal error summary/uncommon events handlers. */ + if (intr_status & (IntrDrvRqst | IntrPCIErr | LinkChange | StatsMax)) + netdev_error(dev, intr_status); + + if (--boguscnt < 0) { + get_stats(dev); + printk(KERN_WARNING "%s: Too much work at interrupt, " + "status=0x%4.4x / 0x%4.4x.\n", + dev->name, intr_status, (int)readw(ioaddr + IntrClear)); + /* Re-enable us in 3.2msec. */ + writew(1000, ioaddr + DownCounter); + writew(IntrDrvRqst, ioaddr + IntrEnable); + break; + } + } while (1); + + if (debug > 3) + printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n", + dev->name, (int)readw(ioaddr + IntrStatus)); + + return; +} + +/* This routine is logically part of the interrupt handler, but separated + for clarity and better register allocation. */ +static int netdev_rx(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + int entry = np->cur_rx % RX_RING_SIZE; + int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx; + + if (debug > 4) { + printk(KERN_DEBUG " In netdev_rx(), entry %d status %4.4x.\n", + entry, np->rx_ring[entry].status); + } + + /* If EOP is set on the next entry, it's a new packet. Send it up. */ + while (np->rx_head_desc->status & cpu_to_le32(DescOwn)) { + struct netdev_desc *desc = np->rx_head_desc; + u32 frame_status = le32_to_cpu(desc->status); + int pkt_len = frame_status & 0x1fff; /* Chip omits the CRC. */ + + if (debug > 4) + printk(KERN_DEBUG " netdev_rx() status was %8.8x.\n", + frame_status); + if (--boguscnt < 0) + break; + if (frame_status & 0x001f4000) { + /* There was a error. */ + if (debug > 2) + printk(KERN_DEBUG " netdev_rx() Rx error was %8.8x.\n", + frame_status); + np->stats.rx_errors++; + if (frame_status & 0x00100000) np->stats.rx_length_errors++; + if (frame_status & 0x00010000) np->stats.rx_fifo_errors++; + if (frame_status & 0x00060000) np->stats.rx_frame_errors++; + if (frame_status & 0x00080000) np->stats.rx_crc_errors++; + if (frame_status & 0x00100000) { + printk(KERN_WARNING "%s: Oversized Ethernet frame," + " status %8.8x.\n", + dev->name, frame_status); + } + } else { + struct sk_buff *skb; + +#ifndef final_version + if (debug > 4) + printk(KERN_DEBUG " netdev_rx() normal Rx pkt length %d" + ", bogus_cnt %d.\n", + pkt_len, boguscnt); +#endif + /* Check if the packet is long enough to accept without copying + to a minimally-sized skbuff. */ + if (pkt_len < rx_copybreak + && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) { + skb->dev = dev; + skb_reserve(skb, 2); /* 16 byte align the IP header */ + eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0); + skb_put(skb, pkt_len); + } else { + skb_put(skb = np->rx_skbuff[entry], pkt_len); + np->rx_skbuff[entry] = NULL; + } + skb->protocol = eth_type_trans(skb, dev); + /* Note: checksum -> skb->ip_summed = CHECKSUM_UNNECESSARY; */ + netif_rx(skb); + dev->last_rx = jiffies; + } + entry = (++np->cur_rx) % RX_RING_SIZE; + np->rx_head_desc = &np->rx_ring[entry]; + } + + /* Refill the Rx ring buffers. */ + for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) { + struct sk_buff *skb; + entry = np->dirty_rx % RX_RING_SIZE; + if (np->rx_skbuff[entry] == NULL) { + skb = dev_alloc_skb(np->rx_buf_sz); + np->rx_skbuff[entry] = skb; + if (skb == NULL) + break; /* Better luck next round. */ + skb->dev = dev; /* Mark as being used by this device. */ + skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */ + np->rx_ring[entry].frag[0].addr = virt_to_le32desc(skb->tail); + } + /* Perhaps we need not reset this field. */ + np->rx_ring[entry].frag[0].length = + cpu_to_le32(np->rx_buf_sz | LastFrag); + np->rx_ring[entry].status = 0; + } + + /* No need to restart Rx engine, it will poll. */ + return 0; +} + +static void netdev_error(struct net_device *dev, int intr_status) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + + if (intr_status & IntrDrvRqst) { + /* Stop the down counter and turn interrupts back on. */ + printk("%s: Turning interrupts back on.\n", dev->name); + writew(0, ioaddr + DownCounter); + writew(IntrRxDone | IntrRxDMADone | IntrPCIErr | IntrDrvRqst | + IntrTxDone | StatsMax | LinkChange, ioaddr + IntrEnable); + } + if (intr_status & LinkChange) { + printk(KERN_ERR "%s: Link changed: Autonegotiation advertising" + " %4.4x partner %4.4x.\n", dev->name, + mdio_read(dev, np->phys[0], 4), + mdio_read(dev, np->phys[0], 5)); + check_duplex(dev); + } + if (intr_status & StatsMax) { + get_stats(dev); + } + if (intr_status & IntrPCIErr) { + printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n", + dev->name, intr_status); + /* We must do a global reset of DMA to continue. */ + } +} + +static struct net_device_stats *get_stats(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + int i; + + if (readw(ioaddr + TxOctetsHigh) == 0xffff) + return &np->stats; + + /* We do not spinlock statistics. + A window only exists if we have non-atomic adds, the error counts + are typically zero, and statistics are non-critical. */ + /* The chip only need report frame silently dropped. */ + np->stats.rx_missed_errors += readb(ioaddr + RxMissed); + np->stats.tx_packets += readw(ioaddr + TxFramesOK); + np->stats.rx_packets += readw(ioaddr + RxFramesOK); + np->stats.collisions += readb(ioaddr + StatsLateColl); + np->stats.collisions += readb(ioaddr + StatsMultiColl); + np->stats.collisions += readb(ioaddr + StatsOneColl); + readb(ioaddr + StatsCarrierError); + readb(ioaddr + StatsTxDefer); + for (i = StatsTxDefer; i <= StatsMcastRx; i++) + readb(ioaddr + i); +#if LINUX_VERSION_CODE > 0x20127 + np->stats.tx_bytes += readw(ioaddr + TxOctetsLow); + np->stats.tx_bytes += readw(ioaddr + TxOctetsHigh) << 16; + np->stats.rx_bytes += readw(ioaddr + RxOctetsLow); + np->stats.rx_bytes += readw(ioaddr + RxOctetsHigh) << 16; +#else + readw(ioaddr + TxOctetsLow); + readw(ioaddr + TxOctetsHigh); + readw(ioaddr + RxOctetsLow); + readw(ioaddr + RxOctetsHigh); +#endif + + return &np->stats; +} + +/* The little-endian AUTODIN II ethernet CRC calculations. + A big-endian version is also available. + This is slow but compact code. Do not use this routine for bulk data, + use a table-based routine instead. + This is common code and should be moved to net/core/crc.c. + Chips may use the upper or lower CRC bits, and may reverse and/or invert + them. Select the endian-ness that results in minimal calculations. +*/ +static unsigned const ethernet_polynomial_le = 0xedb88320U; +static inline unsigned ether_crc_le(int length, unsigned char *data) +{ + unsigned int crc = 0xffffffff; /* Initial value. */ + while(--length >= 0) { + unsigned char current_octet = *data++; + int bit; + for (bit = 8; --bit >= 0; current_octet >>= 1) { + if ((crc ^ current_octet) & 1) { + crc >>= 1; + crc ^= ethernet_polynomial_le; + } else + crc >>= 1; + } + } + return crc; +} + +static void set_rx_mode(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + u16 mc_filter[4]; /* Multicast hash filter */ + u32 rx_mode; + int i; + + if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ + /* Unconditionally log net taps. */ + printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); + memset(mc_filter, 0xff, sizeof(mc_filter)); + rx_mode = AcceptBroadcast | AcceptMulticast | AcceptAll | AcceptMyPhys; + } else if ((dev->mc_count > multicast_filter_limit) + || (dev->flags & IFF_ALLMULTI)) { + /* Too many to match, or accept all multicasts. */ + memset(mc_filter, 0xff, sizeof(mc_filter)); + rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys; + } else if (dev->mc_count) { + struct dev_mc_list *mclist; + memset(mc_filter, 0, sizeof(mc_filter)); + for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; + i++, mclist = mclist->next) { + set_bit(ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x3f, + mc_filter); + } + rx_mode = AcceptBroadcast | AcceptMultiHash | AcceptMyPhys; + } else { + writeb(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode); + return; + } + for (i = 0; i < 4; i++) + writew(mc_filter[i], ioaddr + MulticastFilter0 + i*2); + writeb(rx_mode, ioaddr + RxMode); +} + +static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + u16 *data = (u16 *)&rq->ifr_data; + + switch(cmd) { + case SIOCGMIIPHY: /* Get the address of the PHY in use. */ + data[0] = np->phys[0] & 0x1f; + /* Fall Through */ + case SIOCGMIIREG: /* Read the specified MII register. */ + data[3] = mdio_read(dev, data[0] & 0x1f, data[1] & 0x1f); + return 0; + case SIOCSMIIREG: /* Write the specified MII register */ + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + if (data[0] == np->phys[0]) { + u16 value = data[2]; + switch (data[1]) { + case 0: + /* Check for autonegotiation on or reset. */ + np->medialock = (value & 0x9000) ? 0 : 1; + if (np->medialock) + np->full_duplex = (value & 0x0100) ? 1 : 0; + break; + case 4: np->advertising = value; break; + } + /* Perhaps check_duplex(dev), depending on chip semantics. */ + } + mdio_write(dev, data[0] & 0x1f, data[1] & 0x1f, data[2]); + return 0; + default: + return -EOPNOTSUPP; + } +} + +static int netdev_close(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + int i; + + netif_stop_tx_queue(dev); + + if (debug > 1) { + printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %2.2x " + "Rx %4.4x Int %2.2x.\n", + dev->name, (int)readb(ioaddr + TxStatus), + (int)readl(ioaddr + RxStatus), (int)readw(ioaddr + IntrStatus)); + printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n", + dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx); + } + + /* Disable interrupts by clearing the interrupt mask. */ + writew(0x0000, ioaddr + IntrEnable); + + /* Stop the chip's Tx and Rx processes. */ + writew(TxDisable | RxDisable | StatsDisable, ioaddr + MACCtrl1); + + del_timer(&np->timer); + +#ifdef __i386__ + if (debug > 2) { + printk("\n"KERN_DEBUG" Tx ring at %8.8x:\n", + (int)virt_to_bus(np->tx_ring)); + for (i = 0; i < TX_RING_SIZE; i++) + printk(" #%d desc. %4.4x %8.8x %8.8x.\n", + i, np->tx_ring[i].status, np->tx_ring[i].frag[0].addr, + np->tx_ring[i].frag[0].length); + printk("\n"KERN_DEBUG " Rx ring %8.8x:\n", + (int)virt_to_bus(np->rx_ring)); + for (i = 0; i < /*RX_RING_SIZE*/4 ; i++) { + printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n", + i, np->rx_ring[i].status, np->rx_ring[i].frag[0].addr, + np->rx_ring[i].frag[0].length); + } + } +#endif /* __i386__ debugging only */ + + free_irq(dev->irq, dev); + + /* Free all the skbuffs in the Rx queue. */ + for (i = 0; i < RX_RING_SIZE; i++) { + np->rx_ring[i].status = 0; + np->rx_ring[i].frag[0].addr = 0xBADF00D0; /* An invalid address. */ + if (np->rx_skbuff[i]) { +#if LINUX_VERSION_CODE < 0x20100 + np->rx_skbuff[i]->free = 1; +#endif + dev_free_skb(np->rx_skbuff[i]); + } + np->rx_skbuff[i] = 0; + } + for (i = 0; i < TX_RING_SIZE; i++) { + if (np->tx_skbuff[i]) + dev_free_skb(np->tx_skbuff[i]); + np->tx_skbuff[i] = 0; + } + + MOD_DEC_USE_COUNT; + + return 0; +} + + +#ifdef MODULE +int init_module(void) +{ + if (debug) /* Emit version even if no cards detected. */ + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); + return pci_drv_register(&sundance_drv_id, NULL); +} + +void cleanup_module(void) +{ + struct net_device *next_dev; + + pci_drv_unregister(&sundance_drv_id); + + /* No need to check MOD_IN_USE, as sys_delete_module() checks. */ + while (root_net_dev) { + struct netdev_private *np = (void *)(root_net_dev->priv); + unregister_netdev(root_net_dev); +#ifdef USE_IO_OPS + release_region(root_net_dev->base_addr, pci_tbl[np->chip_id].io_size); +#else + iounmap((char *)root_net_dev->base_addr); +#endif + next_dev = np->next_module; + if (np->priv_addr) + kfree(np->priv_addr); + kfree(root_net_dev); + root_net_dev = next_dev; + } +} + +#endif /* MODULE */ + +/* + * Local variables: + * compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O6 -c sundance.c" + * simple-compile-command: "gcc -DMODULE -O6 -c sundance.c" + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -Nur kernel-source-2.2.19.orig/drivers/net/tulip.c kernel-source-2.2.19/drivers/net/tulip.c --- kernel-source-2.2.19.orig/drivers/net/tulip.c Tue Mar 13 10:32:23 2001 +++ kernel-source-2.2.19/drivers/net/tulip.c Thu Aug 30 14:07:28 2001 @@ -1,34 +1,43 @@ -/* tulip.c: A DEC 21040-family ethernet driver for Linux. */ +/* tulip.c: A DEC 21040 family ethernet driver for Linux. */ /* - Written/copyright 1994-1999 by Donald Becker. + Written/copyright 1994-2001 by Donald Becker. - This software may be used and distributed according to the terms - of the GNU Public License, incorporated herein by reference. + This software may be used and distributed according to the terms of + the GNU General Public License (GPL), incorporated herein by reference. + Drivers based on or derived from this code fall under the GPL and must + retain the authorship, copyright and license notice. This file is not + a complete program and may only be used when the entire operating + system is licensed under the GPL. This driver is for the Digital "Tulip" Ethernet adapter interface. It should work with most DEC 21*4*-based chips/ethercards, as well as with work-alike chips from Lite-On (PNIC) and Macronix (MXIC) and ASIX. - The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O - Center of Excellence in Space Data and Information Sciences - Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771 + The author may be reached as becker@scyld.com, or C/O + Scyld Computing Corporation + 410 Severn Ave., Suite 210 + Annapolis MD 21403 Support and updates available at - http://cesdis.gsfc.nasa.gov/linux/drivers/tulip.html - - This driver also contains updates by Wolfgang Walter and others. - For this specific driver variant please use linux-kernel for - bug reports. - - Updated 12/17/2000 by Jim McQuillan to - include support for the Linksys LNE100TX card based on the - Admtek 985 Centaur-P chipset. + http://www.scyld.com/network/tulip.html */ +/* These identify the driver base version and may not be removed. */ +static const char version1[] = +"tulip.c:v0.92w 7/9/2001 Written by Donald Becker \n"; +static const char version2[] = +" http://www.scyld.com/network/tulip.html\n"; + #define SMP_CHECK -static const char version[] = "tulip.c:v0.91g-ppc 7/16/99 becker@cesdis.gsfc.nasa.gov\n"; -/* A few user-configurable values. */ +/* The user-configurable values. + These may be modified when a driver module is loaded.*/ + +static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */ +#define tulip_debug debug /* Inconsistently used to minimize changes. */ + +/* Maximum events (Rx packets, etc.) to handle at each interrupt. */ +static int max_interrupt_work = 25; #define MAX_UNITS 8 /* Used to pass the full-duplex flag, etc. */ @@ -37,11 +46,14 @@ static int mtu[MAX_UNITS] = {0, }; /* Jumbo MTU for interfaces. */ /* The possible media types that can be set in options[] are: */ -static const char * const medianame[] = { +#define MEDIA_MASK 31 +static const char * const medianame[32] = { "10baseT", "10base2", "AUI", "100baseTx", - "10baseT-FD", "100baseTx-FD", "100baseT4", "100baseFx", - "100baseFx-FD", "MII 10baseT", "MII 10baseT-FD", "MII", - "10baseT(forced)", "MII 100baseTx", "MII 100baseTx-FD", "MII 100baseT4", + "10baseT-FDX", "100baseTx-FDX", "100baseT4", "100baseFx", + "100baseFx-FDX", "MII 10baseT", "MII 10baseT-FDX", "MII", + "10baseT(forced)", "MII 100baseTx", "MII 100baseTx-FDX", "MII 100baseT4", + "MII 100baseFx-HDX", "MII 100baseFx-FDX", "Home-PNA 1Mbps", "Invalid-19", + "","","","", "","","","", "","","","Transceiver reset", }; /* Set if the PCI BIOS detects the chips on a multiport board backwards. */ @@ -51,15 +63,8 @@ static int reverse_probe = 0; #endif -/* Keep the ring sizes a power of two for efficiency. - Making the Tx ring too large decreases the effectiveness of channel - bonding and packet priority. - There are no ill effects from too-large receive rings. */ -#define TX_RING_SIZE 16 -#define RX_RING_SIZE 32 - /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */ -#ifdef __alpha__ +#ifdef __alpha__ /* Always copy to aligned IP headers. */ static int rx_copybreak = 1518; #else static int rx_copybreak = 100; @@ -87,6 +92,19 @@ static int csr0 = 0x00A00000 | 0x4800; #endif +/* Operational parameters that are set at compile time. */ + +/* Keep the descriptor ring sizes a power of two for efficiency. + The Tx queue length limits transmit packets to a portion of the available + ring entries. It should be at least one element less to allow multicast + filter setup frames to be queued. It must be at least four for hysteresis. + Making the Tx queue too long decreases the effectiveness of channel + bonding and packet priority. + Large receive rings merely consume memory. */ +#define TX_RING_SIZE 16 +#define TX_QUEUE_LEN 10 +#define RX_RING_SIZE 32 + /* Operational parameters that usually are not changed. */ /* Time in jiffies before concluding the transmitter is hung. */ #define TX_TIMEOUT (4*HZ) @@ -97,26 +115,32 @@ 10base2(!) packets trigger a full-duplex-request interrupt. */ #define FULL_DUPLEX_MAGIC 0x6969 -#if !defined(__OPTIMIZE__) || !defined(__KERNEL__) +/* The include file section. We start by doing checks and fix-ups for + missing compile flags. */ +#ifndef __KERNEL__ +#define __KERNEL__ +#endif +#if !defined(__OPTIMIZE__) #warning You must compile this file with the correct options! #warning See the last lines of the source file. #error You must compile this driver with "-O". #endif #include -#include -#ifdef MODULE -#ifdef MODVERSIONS -#include +#if defined(CONFIG_SMP) && ! defined(__SMP__) +#define __SMP__ +#endif +#if defined(CONFIG_MODVERSIONS) && defined(MODULE) && ! defined(MODVERSIONS) +#define MODVERSIONS #endif + +#include #include -#else -#define MOD_INC_USE_COUNT -#define MOD_DEC_USE_COUNT +#if LINUX_VERSION_CODE < 0x20300 && defined(MODVERSIONS) +#include #endif #include -#include #include #include #include @@ -127,68 +151,53 @@ #include #include #include -#include #include /* Processor type for cache alignment. */ #include #include #include -/* Kernel compatibility defines, some common to David Hind's PCMCIA package. - This is only in the support-all-kernels source code. */ +#ifdef INLINE_PCISCAN +#include "k_compat.h" +#else +#include "pci-scan.h" +#include "kern_compat.h" +#endif + +/* Condensed operations for readability. */ +#define virt_to_le32desc(addr) cpu_to_le32(virt_to_bus(addr)) + +#if (LINUX_VERSION_CODE >= 0x20100) && defined(MODULE) +char kernel_version[] = UTS_RELEASE; +#endif -#if defined(MODULE) && LINUX_VERSION_CODE > 0x20115 -MODULE_AUTHOR("Donald Becker "); +MODULE_AUTHOR("Donald Becker "); MODULE_DESCRIPTION("Digital 21*4* Tulip ethernet driver"); MODULE_PARM(debug, "i"); +MODULE_PARM(max_interrupt_work, "i"); MODULE_PARM(reverse_probe, "i"); MODULE_PARM(rx_copybreak, "i"); MODULE_PARM(csr0, "i"); MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i"); MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i"); -#endif - -#define RUN_AT(x) (jiffies + (x)) - -#if LINUX_VERSION_CODE < 0x20123 -#define hard_smp_processor_id() smp_processor_id() -#define test_and_set_bit(val, addr) set_bit(val, addr) -#define le16_to_cpu(val) (val) -#define le32_to_cpu(val) (val) -#define cpu_to_le32(val) (val) -#endif -#if LINUX_VERSION_CODE <= 0x20139 -#define net_device_stats enet_statistics -#else -#define NETSTATS_VER2 -#endif -#if LINUX_VERSION_CODE < 0x20155 -/* Grrrr, the PCI code changed, but did not consider CardBus... */ -#include -#define PCI_SUPPORT_VER1 -#else -#define PCI_SUPPORT_VER2 -#endif -#if LINUX_VERSION_CODE < 0x20159 -#define dev_free_skb(skb) dev_kfree_skb(skb, FREE_WRITE); -#else -#define dev_free_skb(skb) dev_kfree_skb(skb); -#endif -#if ! defined(CAP_NET_ADMIN) -#define capable(CAP_XXX) (suser()) -#endif -#if ! defined(HAS_NETIF_QUEUE) -#define netif_wake_queue(dev) mark_bh(NET_BH); -#endif - -/* Condensed operations for readability. */ -#define virt_to_le32desc(addr) cpu_to_le32(virt_to_bus(addr)) -#define le32desc_to_virt(addr) bus_to_virt(le32_to_cpu(addr)) -#define tulip_debug debug -#ifdef TULIP_DEBUG -static int tulip_debug = TULIP_DEBUG; -#else -static int tulip_debug = 1; +/* This driver was originally written to use I/O space access, but now + uses memory space by default. Override this this with -DUSE_IO_OPS. */ +#if (LINUX_VERSION_CODE < 0x20100) || ! defined(MODULE) +#define USE_IO_OPS +#endif +#ifndef USE_IO_OPS +#undef inb +#undef inw +#undef inl +#undef outb +#undef outw +#undef outl +#define inb readb +#define inw readw +#define inl readl +#define outb writeb +#define outw writew +#define outl writel #endif /* @@ -200,7 +209,7 @@ single-chip ethernet controllers for PCI. Supported members of the family are the 21040, 21041, 21140, 21140A, 21142, and 21143. Similar work-alike chips from Lite-On, Macronics, ASIX, Compex and other listed below are also -supported. +supported. These chips are used on at least 140 unique PCI board designs. The great number of chips and board designs supported is the reason for the @@ -218,7 +227,7 @@ is usually "autoselect". This should only be overridden when using transceiver connections without link beat e.g. 10base2 or AUI, or (rarely!) for forcing full-duplex when used with old link partners that do not do -autonegotiation. +autonegotiation. III. Driver operation @@ -241,7 +250,7 @@ information). For large frames the copying cost is non-trivial, and the larger copy might flush the cache of useful data. A subtle aspect of this choice is that the Tulip only receives into longword aligned buffers, thus -the IP header at offset 14 isn't longword aligned for further processing. +the IP header at offset 14 is not longword aligned for further processing. Copied frames are put into the new skbuff at an offset of "+2", thus copying has the beneficial effect of aligning the IP header and preloading the cache. @@ -253,13 +262,13 @@ threaded by the hardware and other software. The send packet thread has partial control over the Tx ring and 'dev->tbusy' -flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next +flag. It sets the tbusy flag whenever it is queuing a Tx packet. If the next queue slot is empty, it clears the tbusy flag when finished otherwise it sets the 'tp->tx_full' flag. The interrupt handler has exclusive control over the Rx ring and records stats -from the Tx ring. (The Tx-done interrupt can't be selectively turned off, so -we can't avoid the interrupt overhead by having the Tx routine reap the Tx +from the Tx ring. (The Tx-done interrupt can not be selectively turned off, so +we cannot avoid the interrupt overhead by having the Tx routine reap the Tx stats.) After reaping the stats, it marks the queue entry as empty by setting the 'base' to zero. Iff the 'tp->tx_full' flag is set, it clears both the tx_full and tbusy flags. @@ -272,7 +281,7 @@ IVb. References -http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html +http://scyld.com/expert/NWay.html http://www.digital.com (search for current 21*4* datasheets and "21X4 SROM") http://www.national.com/pf/DP/DP83840A.html http://www.asix.com.tw/pmac.htm @@ -287,75 +296,117 @@ The DEC SROM format is very badly designed not precisely defined, leading to part of the media selection junkheap below. Some boards do not have EEPROM media tables and need to be patched up. Worse, other boards use the DEC -design kit media table when it isn't correct for their board. +design kit media table when it is not correct for their design. We cannot use MII interrupts because there is no defined GPIO pin to attach them. The MII transceiver status is polled using an kernel timer. */ -static struct device * -tulip_probe1(int pci_bus, int pci_devfn, struct device *dev, long ioaddr, - int irq, int chip_idx, int board_idx); - -/* This table drives the PCI probe routines. It's mostly boilerplate in all - of the drivers, and will likely be provided by some future kernel. - Note the matching code -- the first table entry matchs all 56** cards but - second only the 1234 card. -*/ -enum pci_flags_bit { - PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4, - PCI_ADDR0=0x10<<0, PCI_ADDR1=0x10<<1, PCI_ADDR2=0x10<<2, PCI_ADDR3=0x10<<3, -}; -#define PCI_ADDR0_IO (PCI_USES_IO|PCI_ADDR0) +static void *tulip_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int chip_idx, int find_cnt); +static int tulip_pwr_event(void *dev_instance, int event); + +#ifdef USE_IO_OPS +#define TULIP_IOTYPE PCI_USES_MASTER | PCI_USES_IO | PCI_ADDR0 +#define TULIP_SIZE 0x80 +#define TULIP_SIZE1 0x100 +#else +#define TULIP_IOTYPE PCI_USES_MASTER | PCI_USES_MEM | PCI_ADDR1 +#define TULIP_SIZE 0x400 /* New PCI v2.1 recommends 4K min mem size. */ +#define TULIP_SIZE1 0x400 /* New PCI v2.1 recommends 4K min mem size. */ +#endif -struct pci_id_info { - const char *name; - u16 vendor_id, device_id, device_id_mask, flags; - int io_size, min_latency; - struct device *(*probe1)(int pci_bus, int pci_devfn, struct device *dev, - long ioaddr, int irq, int chip_idx, int fnd_cnt); +/* This much match tulip_tbl[]! Note 21142 == 21143. */ +enum tulip_chips { + DC21040=0, DC21041=1, DC21140=2, DC21142=3, DC21143=3, + LC82C168, MX98713, MX98715, MX98725, AX88141, AX88140, PNIC2, COMET, + COMPEX9881, I21145, XIRCOM, CONEXANT, + /* These flags may be added to the chip type. */ + HAS_VLAN=0x100, }; -#ifndef CARDBUS -static struct pci_id_info pci_tbl[] __initdata = { - { "Digital DC21040 Tulip", - 0x1011, 0x0002, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - { "Digital DC21041 Tulip", - 0x1011, 0x0014, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - { "Digital DS21140 Tulip", - 0x1011, 0x0009, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - { "Digital DS21143 Tulip", - 0x1011, 0x0019, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - { "Lite-On 82c168 PNIC", - 0x11AD, 0x0002, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 }, - { "Macronix 98713 PMAC", - 0x10d9, 0x0512, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 }, - { "Macronix 98715 PMAC", - 0x10d9, 0x0531, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 }, - { "Macronix 98725 PMAC", - 0x10d9, 0x0531, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 }, - { "ASIX AX88140", - 0x125B, 0x1400, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - { "Lite-On LC82C115 PNIC-II", - 0x11AD, 0xc115, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 }, - { "ADMtek AN981 Comet", - 0x1317, 0x0981, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 }, - { "ADMtek AN985 Comet", - 0x1317, 0x0985, 0xffff, PCI_ADDR0_IO, 256, 32, tulip_probe1 }, - { "Compex RL100-TX", - 0x11F6, 0x9881, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - { "Intel 21145 Tulip", - 0x8086, 0x0039, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - { "Xircom Tulip clone", - 0x115d, 0x0003, 0xffff, PCI_ADDR0_IO, 128, 32, tulip_probe1 }, - {0}, + +static struct pci_id_info pci_id_tbl[] = { + { "Digital DC21040 Tulip", { 0x00021011, 0xffffffff }, + TULIP_IOTYPE, 0x80, DC21040 }, + { "Digital DC21041 Tulip", { 0x00141011, 0xffffffff }, + TULIP_IOTYPE, 0x80, DC21041 }, + { "Digital DS21140A Tulip", { 0x00091011, 0xffffffff, 0,0, 0x20,0xf0 }, + TULIP_IOTYPE, 0x80, DC21140 }, + { "Digital DS21140 Tulip", { 0x00091011, 0xffffffff }, + TULIP_IOTYPE, 0x80, DC21140 }, + { "Digital DS21143-xD Tulip", { 0x00191011, 0xffffffff, 0,0, 0x40,0xf0 }, + TULIP_IOTYPE, TULIP_SIZE, DC21142 | HAS_VLAN }, + { "Digital DS21143-xC Tulip", { 0x00191011, 0xffffffff, 0,0, 0x30,0xf0 }, + TULIP_IOTYPE, TULIP_SIZE, DC21142 }, + { "Digital DS21142 Tulip", { 0x00191011, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE, DC21142 }, + { "Kingston KNE110tx (PNIC)", + { 0x000211AD, 0xffffffff, 0xf0022646, 0xffffffff }, + TULIP_IOTYPE, 256, LC82C168 }, + { "Linksys LNE100TX (82c168 PNIC)", /* w/SYM */ + { 0x000211AD, 0xffffffff, 0xffff11ad, 0xffffffff, 17,0xff }, + TULIP_IOTYPE, 256, LC82C168 }, + { "Linksys LNE100TX (82c169 PNIC)", /* w/ MII */ + { 0x000211AD, 0xffffffff, 0xf00311ad, 0xffffffff, 32,0xff }, + TULIP_IOTYPE, 256, LC82C168 }, + { "Lite-On 82c168 PNIC", { 0x000211AD, 0xffffffff }, + TULIP_IOTYPE, 256, LC82C168 }, + { "Macronix 98713 PMAC", { 0x051210d9, 0xffffffff }, + TULIP_IOTYPE, 256, MX98713 }, + { "Macronix 98715 PMAC", { 0x053110d9, 0xffffffff }, + TULIP_IOTYPE, 256, MX98715 }, + { "Macronix 98725 PMAC", { 0x053110d9, 0xffffffff }, + TULIP_IOTYPE, 256, MX98725 }, + { "ASIX AX88141", { 0x1400125B, 0xffffffff, 0,0, 0x10, 0xf0 }, + TULIP_IOTYPE, 128, AX88141 }, + { "ASIX AX88140", { 0x1400125B, 0xffffffff }, + TULIP_IOTYPE, 128, AX88140 }, + { "Lite-On LC82C115 PNIC-II", { 0xc11511AD, 0xffffffff }, + TULIP_IOTYPE, 256, PNIC2 }, + { "ADMtek AN981 Comet", { 0x09811317, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "ADMtek Centaur-P", { 0x09851317, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "ADMtek Centaur-C", { 0x19851317, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "ADMtek Centaur-C (Linksys v2)", { 0xab0213d1, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "ADMtek Centaur-C (Linksys)", { 0xab0313d1, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "STMicro STE10/100 Comet", { 0x0981104a, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "STMicro STE10/100A Comet", { 0x2774104a, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "ADMtek Comet-II", { 0x95111317, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "Accton EN1217/EN2242 (ADMtek Comet)", { 0x12161113, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, COMET }, + { "Compex RL100-TX", { 0x988111F6, 0xffffffff }, + TULIP_IOTYPE, 128, COMPEX9881 }, + { "Intel 21145 Tulip", { 0x00398086, 0xffffffff }, + TULIP_IOTYPE, 128, I21145 }, + { "Xircom Tulip clone", { 0x0003115d, 0xffffffff }, + TULIP_IOTYPE, 128, XIRCOM }, + { "Davicom DM9102", { 0x91021282, 0xffffffff }, + TULIP_IOTYPE, 0x80, DC21140 }, + { "Davicom DM9100", { 0x91001282, 0xffffffff }, + TULIP_IOTYPE, 0x80, DC21140 }, + { "Macronix mxic-98715 (EN1217)", { 0x12171113, 0xffffffff }, + TULIP_IOTYPE, 256, MX98715 }, + { "Conexant LANfinity", { 0x180314f1, 0xffffffff }, + TULIP_IOTYPE, TULIP_SIZE1, CONEXANT }, + { 0}, }; -#endif /* !CARD_BUS */ -/* This table use during operation for capabilities and media timer. */ +struct drv_id_info tulip_drv_id = { + "tulip", PCI_HOTSWAP, PCI_CLASS_NETWORK_ETHERNET<<8, pci_id_tbl, + tulip_probe1, tulip_pwr_event }; + +/* This table is used during operation for capabilities and media timer. */ static void tulip_timer(unsigned long data); -static void t21142_timer(unsigned long data); +static void nway_timer(unsigned long data); static void mxic_timer(unsigned long data); static void pnic_timer(unsigned long data); static void comet_timer(unsigned long data); @@ -363,23 +414,27 @@ enum tbl_flag { HAS_MII=1, HAS_MEDIA_TABLE=2, CSR12_IN_SROM=4, ALWAYS_CHECK_MII=8, HAS_PWRDWN=0x10, MC_HASH_ONLY=0x20, /* Hash-only multicast filter. */ - HAS_PNICNWAY=0x80, HAS_NWAY143=0x40, /* Uses internal NWay xcvr. */ - HAS_8023X=0x100, + HAS_PNICNWAY=0x80, HAS_NWAY=0x40, /* Uses internal NWay xcvr. */ + HAS_INTR_MITIGATION=0x100, IS_ASIX=0x200, HAS_8023X=0x400, + COMET_MAC_ADDR=0x0800, }; + +/* Note: this table must match enum tulip_chips above. */ static struct tulip_chip_table { char *chip_name; - int io_size; + int io_size; /* Unused */ int valid_intrs; /* CSR7 interrupt enable settings */ int flags; void (*media_timer)(unsigned long data); } tulip_tbl[] = { { "Digital DC21040 Tulip", 128, 0x0001ebef, 0, tulip_timer }, - { "Digital DC21041 Tulip", 128, 0x0001ebff, HAS_MEDIA_TABLE, tulip_timer }, + { "Digital DC21041 Tulip", 128, 0x0001ebff, + HAS_MEDIA_TABLE | HAS_NWAY, tulip_timer }, { "Digital DS21140 Tulip", 128, 0x0001ebef, HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, tulip_timer }, { "Digital DS21143 Tulip", 128, 0x0801fbff, - HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_PWRDWN | HAS_NWAY143, - t21142_timer }, + HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_PWRDWN | HAS_NWAY + | HAS_INTR_MITIGATION, nway_timer }, { "Lite-On 82c168 PNIC", 256, 0x0001ebef, HAS_MII | HAS_PNICNWAY, pnic_timer }, { "Macronix 98713 PMAC", 128, 0x0001ebef, @@ -389,40 +444,37 @@ { "Macronix 98725 PMAC", 256, 0x0001ebef, HAS_MEDIA_TABLE, mxic_timer }, { "ASIX AX88140", 128, 0x0001fbff, - HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | MC_HASH_ONLY, tulip_timer }, + HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | MC_HASH_ONLY | IS_ASIX, tulip_timer }, + { "ASIX AX88141", 128, 0x0001fbff, + HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | MC_HASH_ONLY | IS_ASIX, tulip_timer }, { "Lite-On PNIC-II", 256, 0x0801fbff, - HAS_MII | HAS_NWAY143 | HAS_8023X, t21142_timer }, + HAS_MII | HAS_NWAY | HAS_8023X, nway_timer }, { "ADMtek Comet", 256, 0x0001abef, - MC_HASH_ONLY, comet_timer }, - { "ADMtek Centaur-P", 256, 0x0001abef, - MC_HASH_ONLY, comet_timer }, + HAS_MII | MC_HASH_ONLY | COMET_MAC_ADDR, comet_timer }, { "Compex 9881 PMAC", 128, 0x0001ebef, HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, mxic_timer }, { "Intel DS21145 Tulip", 128, 0x0801fbff, - HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_PWRDWN | HAS_NWAY143, - t21142_timer }, + HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_PWRDWN | HAS_NWAY, + nway_timer }, { "Xircom tulip work-alike", 128, 0x0801fbff, - HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_PWRDWN | HAS_NWAY143, - t21142_timer }, + HAS_MII | HAS_MEDIA_TABLE | ALWAYS_CHECK_MII | HAS_PWRDWN | HAS_NWAY, + nway_timer }, + { "Conexant LANfinity", 256, 0x0001ebef, + HAS_MII | HAS_PWRDWN, tulip_timer }, {0}, }; -/* This matches the table above. Note 21142 == 21143. */ -enum chips { - DC21040=0, DC21041=1, DC21140=2, DC21142=3, DC21143=3, - LC82C168, MX98713, MX98715, MX98725, AX88140, PNIC2, COMET, COMET5, - COMPEX9881, I21145, XIRCOM, -}; /* A full-duplex map for media types. */ enum MediaIs { MediaIsFD = 1, MediaAlwaysFD=2, MediaIsMII=4, MediaIsFx=8, MediaIs100=16}; -static const char media_cap[] = -{0,0,0,16, 3,19,16,24, 27,4,7,5, 0,20,23,20 }; +static const char media_cap[32] = +{0,0,0,16, 3,19,16,24, 27,4,7,5, 0,20,23,20, 28,31,0,0, }; static u8 t21040_csr13[] = {2,0x0C,8,4, 4,0,0,0, 0,0,0,0, 4,0,0,0}; + /* 21041 transceiver register settings: 10-T, 10-2, AUI, 10-T, 10T-FD*/ -static u16 t21041_csr13[] = { 0xEF05, 0xEF0D, 0xEF0D, 0xEF05, 0xEF05, }; -static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; +static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, }; +static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, }; static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, }; static u16 t21142_csr13[] = { 0x0001, 0x0009, 0x0009, 0x0000, 0x0001, }; @@ -438,12 +490,20 @@ /* The bits in the CSR5 status registers, mostly interrupt sources. */ enum status_bits { - TimerInt=0x800, SytemError=0x2000, TPLnkFail=0x1000, TPLnkPass=0x10, - NormalIntr=0x10000, AbnormalIntr=0x8000, - RxJabber=0x200, RxDied=0x100, RxNoBuf=0x80, RxIntr=0x40, + TimerInt=0x800, TPLnkFail=0x1000, TPLnkPass=0x10, + NormalIntr=0x10000, AbnormalIntr=0x8000, PCIBusError=0x2000, + RxJabber=0x200, RxStopped=0x100, RxNoBuf=0x80, RxIntr=0x40, TxFIFOUnderflow=0x20, TxJabber=0x08, TxNoBuf=0x04, TxDied=0x02, TxIntr=0x01, }; +/* The configuration bits in CSR6. */ +enum csr6_mode_bits { + TxOn=0x2000, RxOn=0x0002, FullDuplex=0x0200, + AcceptBroadcast=0x0100, AcceptAllMulticast=0x0080, + AcceptAllPhys=0x0040, AcceptRunt=0x0008, +}; + + /* The Tulip Rx and Tx buffer descriptors. */ struct tulip_rx_desc { s32 status; @@ -471,7 +531,7 @@ */ #define DESC_RING_WRAP 0x02000000 -#define EEPROM_SIZE 128 /* 2 << EEPROM_ADDRLEN */ +#define EEPROM_SIZE 512 /* support 256*16 EEPROMs */ struct medialeaf { u8 type; @@ -494,239 +554,137 @@ unsigned char *info; }; +#define PRIV_ALIGN 15 /* Required alignment mask */ struct tulip_private { - char devname[8]; /* Used only for kernel debugging. */ - const char *product_name; - struct device *next_module; struct tulip_rx_desc rx_ring[RX_RING_SIZE]; struct tulip_tx_desc tx_ring[TX_RING_SIZE]; - /* The saved address of a sent-in-place packet/buffer, for skfree(). */ + /* The saved addresses of Rx/Tx-in-place packet buffers. */ struct sk_buff* tx_skbuff[TX_RING_SIZE]; - /* The addresses of receive-in-place skbuffs. */ struct sk_buff* rx_skbuff[RX_RING_SIZE]; - char *rx_buffs; /* Address of temporary Rx buffers. */ + struct net_device *next_module; + void *priv_addr; /* Unaligned address of dev->priv for kfree */ u16 setup_frame[96]; /* Pseudo-Tx frame to init address table. */ - int chip_id; - int revision; + u32 mc_filter[2]; /* Multicast hash filter */ + struct pci_dev *pci_dev; + int chip_id, revision; int flags; + struct timer_list timer; /* Media selection timer. */ + unsigned int csr0, csr6; /* Current CSR0, CSR6 settings. */ + /* Note: cache line pairing and isolation of Rx vs. Tx indicies. */ + unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */ struct net_device_stats stats; - struct timer_list timer; /* Media selection timer. */ - int interrupt; /* In-interrupt flag. */ - unsigned int cur_rx, cur_tx; /* The next free ring entry */ - unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */ + unsigned int cur_tx, dirty_tx; unsigned int tx_full:1; /* The Tx queue is full. */ + unsigned int rx_dead:1; /* We have no Rx buffers. */ unsigned int full_duplex:1; /* Full-duplex operation requested. */ unsigned int full_duplex_lock:1; unsigned int fake_addr:1; /* Multiport board faked address. */ - unsigned int default_port:4; /* Last dev->if_port value. */ unsigned int media2:4; /* Secondary monitored media port. */ - unsigned int medialock:1; /* Don't sense media type. */ + unsigned int medialock:1; /* Do not sense media type. */ unsigned int mediasense:1; /* Media sensing in progress. */ unsigned int nway:1, nwayset:1; /* 21143 internal NWay. */ - unsigned int csr0; /* CSR0 setting. */ - unsigned int csr6; /* Current CSR6 control settings. */ + unsigned int default_port:8; /* Last dev->if_port value. */ unsigned char eeprom[EEPROM_SIZE]; /* Serial EEPROM contents. */ - void (*link_change)(struct device *dev, int csr5); - u16 to_advertise; /* NWay capabilities advertised. */ + void (*link_change)(struct net_device *dev, int csr5); u16 lpar; /* 21143 Link partner ability. */ - u16 advertising[4]; + u16 sym_advertise, mii_advertise; /* NWay to-advertise. */ + u16 advertising[4]; /* MII advertise, from SROM table. */ signed char phys[4], mii_cnt; /* MII device addresses. */ + spinlock_t mii_lock; struct mediatable *mtable; int cur_index; /* Current media index. */ int saved_if_port; - unsigned char pci_bus, pci_devfn; - int ttimer; - int susp_rx; - unsigned long nir; - int pad0, pad1; /* Used for 8-byte alignment */ }; -static void parse_eeprom(struct device *dev); +static void start_link(struct net_device *dev); +static void parse_eeprom(struct net_device *dev); static int read_eeprom(long ioaddr, int location, int addr_len); -static int mdio_read(struct device *dev, int phy_id, int location); -static void mdio_write(struct device *dev, int phy_id, int location, int value); -static void select_media(struct device *dev, int startup); -static int tulip_open(struct device *dev); +static int mdio_read(struct net_device *dev, int phy_id, int location); +static void mdio_write(struct net_device *dev, int phy_id, int location, int value); +static int tulip_open(struct net_device *dev); /* Chip-specific media selection (timer functions prototyped above). */ -static void t21142_lnk_change(struct device *dev, int csr5); -static void t21142_start_nway(struct device *dev); -static void pnic_lnk_change(struct device *dev, int csr5); -static void pnic_do_nway(struct device *dev); - -static void tulip_tx_timeout(struct device *dev); -static void tulip_init_ring(struct device *dev); -static int tulip_start_xmit(struct sk_buff *skb, struct device *dev); -static int tulip_refill_rx(struct device *dev); -static int tulip_rx(struct device *dev); +static int check_duplex(struct net_device *dev); +static void select_media(struct net_device *dev, int startup); +static void init_media(struct net_device *dev); +static void nway_lnk_change(struct net_device *dev, int csr5); +static void nway_start(struct net_device *dev); +static void pnic_lnk_change(struct net_device *dev, int csr5); +static void pnic_do_nway(struct net_device *dev); + +static void tulip_tx_timeout(struct net_device *dev); +static void tulip_init_ring(struct net_device *dev); +static int tulip_start_xmit(struct sk_buff *skb, struct net_device *dev); +static int tulip_rx(struct net_device *dev); static void tulip_interrupt(int irq, void *dev_instance, struct pt_regs *regs); -static int tulip_close(struct device *dev); -static struct net_device_stats *tulip_get_stats(struct device *dev); +static int tulip_close(struct net_device *dev); +static struct net_device_stats *tulip_get_stats(struct net_device *dev); #ifdef HAVE_PRIVATE_IOCTL -static int private_ioctl(struct device *dev, struct ifreq *rq, int cmd); +static int private_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); #endif -static void set_rx_mode(struct device *dev); +static void set_rx_mode(struct net_device *dev); /* A list of all installed Tulip devices. */ -static struct device *root_tulip_dev = NULL; - -#ifndef CARDBUS -int __init tulip_probe(struct device *dev) -{ - int cards_found = 0; - int pci_index = 0; - unsigned char pci_bus, pci_device_fn; - - if ( ! pcibios_present()) - return -ENODEV; +static struct net_device *root_tulip_dev = NULL; - for (;pci_index < 0xff; pci_index++) { - u16 vendor, device, pci_command, new_command, subvendor; - int chip_idx; - int irq; - long ioaddr; - - if (pcibios_find_class - (PCI_CLASS_NETWORK_ETHERNET << 8, - reverse_probe ? 0xfe - pci_index : pci_index, - &pci_bus, &pci_device_fn) != PCIBIOS_SUCCESSFUL) { - if (reverse_probe) - continue; - else - break; - } - pcibios_read_config_word(pci_bus, pci_device_fn, - PCI_VENDOR_ID, &vendor); - pcibios_read_config_word(pci_bus, pci_device_fn, - PCI_DEVICE_ID, &device); - pcibios_read_config_word(pci_bus, pci_device_fn, - PCI_SUBSYSTEM_VENDOR_ID, &subvendor); - - if( subvendor == 0x1376 ){ - printk("tulip: skipping LMC card.\n"); - continue; - } - - for (chip_idx = 0; pci_tbl[chip_idx].vendor_id; chip_idx++) - if (vendor == pci_tbl[chip_idx].vendor_id - && (device & pci_tbl[chip_idx].device_id_mask) == - pci_tbl[chip_idx].device_id) - break; - if (pci_tbl[chip_idx].vendor_id == 0) - continue; - - { -#if defined(PCI_SUPPORT_VER2) - struct pci_dev *pdev = pci_find_slot(pci_bus, pci_device_fn); - ioaddr = pdev->base_address[0] & ~3; - irq = pdev->irq; -#else - u32 pci_ioaddr; - u8 pci_irq_line; - pcibios_read_config_dword(pci_bus, pci_device_fn, - PCI_BASE_ADDRESS_0, &pci_ioaddr); - pcibios_read_config_byte(pci_bus, pci_device_fn, - PCI_INTERRUPT_LINE, &pci_irq_line); - ioaddr = pci_ioaddr & ~3; - irq = pci_irq_line; -#endif - } - - if (debug > 2) - printk(KERN_INFO "Found %s at PCI I/O address %#lx.\n", - pci_tbl[chip_idx].name, ioaddr); - - if (check_region(ioaddr, pci_tbl[chip_idx].io_size)) - continue; - - pcibios_read_config_word(pci_bus, pci_device_fn, - PCI_COMMAND, &pci_command); - new_command = pci_command | PCI_COMMAND_MASTER|PCI_COMMAND_IO; - if (pci_command != new_command) { - printk(KERN_INFO " The PCI BIOS has not enabled the" - " device at %d/%d! Updating PCI command %4.4x->%4.4x.\n", - pci_bus, pci_device_fn, pci_command, new_command); - pcibios_write_config_word(pci_bus, pci_device_fn, - PCI_COMMAND, new_command); - } - - dev = pci_tbl[chip_idx].probe1(pci_bus, pci_device_fn, dev, ioaddr, - irq, chip_idx, cards_found); - - /* Get and check the bus-master and latency values. */ - if (dev) { - u8 pci_latency; - pcibios_read_config_byte(pci_bus, pci_device_fn, - PCI_LATENCY_TIMER, &pci_latency); - if (pci_latency < 10) { - printk(KERN_INFO " PCI latency timer (CFLT) is " - "unreasonably low at %d. Setting to 64 clocks.\n", - pci_latency); - pcibios_write_config_byte(pci_bus, pci_device_fn, - PCI_LATENCY_TIMER, 64); - } - } - dev = 0; - cards_found++; - } - - return cards_found ? 0 : -ENODEV; -} -#endif /* not CARDBUS */ - -static struct device *tulip_probe1(int pci_bus, int pci_devfn, - struct device *dev, long ioaddr, int irq, - int chip_idx, int board_idx) +static void *tulip_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int pci_tbl_idx, int find_cnt) { - static int did_version = 0; /* Already printed version info. */ + struct net_device *dev; struct tulip_private *tp; + void *priv_mem; /* See note below on the multiport cards. */ static unsigned char last_phys_addr[6] = {0x00, 'L', 'i', 'n', 'u', 'x'}; static int last_irq = 0; static int multiport_cnt = 0; /* For four-port boards w/one EEPROM */ u8 chip_rev; - int i; + int i, chip_idx = pci_id_tbl[pci_tbl_idx].drv_flags & 0xff; unsigned short sum; u8 ee_data[EEPROM_SIZE]; - if (tulip_debug > 0 && did_version++ == 0) - printk(KERN_INFO "%s", version); + /* Bring the 21041/21143 out of sleep mode. + Caution: Snooze mode does not work with some boards! */ + if (tulip_tbl[chip_idx].flags & HAS_PWRDWN) + pci_write_config_dword(pdev, 0x40, 0x00000000); + + if (inl(ioaddr + CSR5) == 0xffffffff) { + printk(KERN_ERR "The Tulip chip at %#lx is not functioning.\n", ioaddr); + return 0; + } - dev = init_etherdev(dev, 0); + dev = init_etherdev(init_dev, 0); + if (!dev) + return NULL; /* Make certain the data structures are quadword aligned. */ - tp = (void *)(((long)kmalloc(sizeof(*tp), GFP_KERNEL | GFP_DMA) + 7) & ~7); + priv_mem = kmalloc(sizeof(*tp) + PRIV_ALIGN, GFP_KERNEL); + /* Check for the very unlikely case of no memory. */ + if (priv_mem == NULL) + return NULL; + dev->priv = tp = (void *)(((long)priv_mem + PRIV_ALIGN) & ~PRIV_ALIGN); memset(tp, 0, sizeof(*tp)); - dev->priv = tp; + tp->priv_addr = priv_mem; tp->next_module = root_tulip_dev; root_tulip_dev = dev; - pcibios_read_config_byte(pci_bus, pci_devfn, PCI_REVISION_ID, &chip_rev); - - /* Bring the 21041/21143 out of sleep mode. - Caution: Snooze mode does not work with some boards! */ - if (tulip_tbl[chip_idx].flags & HAS_PWRDWN) - pcibios_write_config_dword(pci_bus, pci_devfn, 0x40, 0x00000000); + pci_read_config_byte(pdev, PCI_REVISION_ID, &chip_rev); printk(KERN_INFO "%s: %s rev %d at %#3lx,", - dev->name, tulip_tbl[chip_idx].chip_name, chip_rev, ioaddr); + dev->name, pci_id_tbl[pci_tbl_idx].name, chip_rev, ioaddr); - /* Stop the chip's Tx and Rx processes. */ - outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6); + /* Stop the Tx and Rx processes. */ + outl(inl(ioaddr + CSR6) & ~TxOn & ~RxOn, ioaddr + CSR6); /* Clear the missed-packet counter. */ - (volatile int)inl(ioaddr + CSR8); + inl(ioaddr + CSR8); if (chip_idx == DC21041 && inl(ioaddr + CSR9) & 0x8000) { printk(" 21040 compatible mode,"); chip_idx = DC21040; } - /* The station address ROM is read byte serially. The register must - be polled, waiting for the value to be read bit serially from the - EEPROM. - */ + /* The SROM/EEPROM interface varies dramatically. */ sum = 0; if (chip_idx == DC21040) { outl(0, ioaddr + CSR9); /* Reset the pointer with a dummy write. */ @@ -748,18 +706,20 @@ put_unaligned(le16_to_cpu(value), ((u16*)dev->dev_addr) + i); sum += value & 0xffff; } - } else if ((chip_idx == COMET) || (chip_idx == COMET5)) { + } else if (chip_idx == COMET) { /* No need to read the EEPROM. */ - put_unaligned(inl(ioaddr + 0xA4), (u32 *)dev->dev_addr); - put_unaligned(inl(ioaddr + 0xA8), (u16 *)(dev->dev_addr + 4)); + put_unaligned(le32_to_cpu(inl(ioaddr + 0xA4)), (u32 *)dev->dev_addr); + put_unaligned(le16_to_cpu(inl(ioaddr + 0xA8)), + (u16 *)(dev->dev_addr + 4)); for (i = 0; i < 6; i ++) sum += dev->dev_addr[i]; } else { /* A serial EEPROM interface, we read now and sort it out later. */ int sa_offset = 0; int ee_addr_size = read_eeprom(ioaddr, 0xff, 8) & 0x40000 ? 8 : 6; + int eeprom_word_cnt = 1 << ee_addr_size; - for (i = 0; i < sizeof(ee_data)/2; i++) + for (i = 0; i < eeprom_word_cnt; i++) ((u16 *)ee_data)[i] = le16_to_cpu(read_eeprom(ioaddr, i, ee_addr_size)); @@ -769,7 +729,12 @@ for (i = 0; i < 8; i ++) if (ee_data[i] != ee_data[16+i]) sa_offset = 20; - if (ee_data[0] == 0xff && ee_data[1] == 0xff && ee_data[2] == 0) { + if (chip_idx == CONEXANT) { + /* Check that the tuple type and length is correct. */ + if (ee_data[0x198] == 0x04 && ee_data[0x199] == 6) + sa_offset = 0x19A; + } else if (ee_data[0] == 0xff && ee_data[1] == 0xff && + ee_data[2] == 0) { sa_offset = 2; /* Grrr, damn Matrox boards. */ multiport_cnt = 4; } @@ -807,27 +772,27 @@ printk(", IRQ %d.\n", irq); last_irq = irq; - /* We do a request_region() only to register /proc/ioports info. */ - /* Note that proper size is tulip_tbl[chip_idx].chip_name, but... */ - request_region(ioaddr, tulip_tbl[chip_idx].io_size, dev->name); + /* We do a request_region() to register /proc/ioports info. */ + request_region(ioaddr, pci_id_tbl[chip_idx].io_size, dev->name); dev->base_addr = ioaddr; dev->irq = irq; - tp->pci_bus = pci_bus; - tp->pci_devfn = pci_devfn; + tp->pci_dev = pdev; tp->chip_id = chip_idx; tp->revision = chip_rev; - tp->flags = tulip_tbl[chip_idx].flags; + tp->flags = tulip_tbl[chip_idx].flags + | (pci_id_tbl[pci_tbl_idx].drv_flags & 0xffffff00); tp->csr0 = csr0; /* BugFixes: The 21143-TD hangs with PCI Write-and-Invalidate cycles. And the ASIX must have a burst limit or horrible things happen. */ if (chip_idx == DC21143 && chip_rev == 65) tp->csr0 &= ~0x01000000; - else if (chip_idx == AX88140) + else if (tp->flags & IS_ASIX) tp->csr0 |= 0x2000; + /* We support a zillion ways to set the media type. */ #ifdef TULIP_FULL_DUPLEX tp->full_duplex = 1; tp->full_duplex_lock = 1; @@ -840,16 +805,19 @@ #endif /* The lower four bits are the media type. */ - if (board_idx >= 0 && board_idx < MAX_UNITS) { - tp->default_port = options[board_idx] & 15; - if ((options[board_idx] & 0x90) || full_duplex[board_idx] > 0) + if (find_cnt >= 0 && find_cnt < MAX_UNITS) { + if (options[find_cnt] & 0x1f) + tp->default_port = options[find_cnt] & 0x1f; + if ((options[find_cnt] & 0x200) || full_duplex[find_cnt] > 0) tp->full_duplex = 1; - if (mtu[board_idx] > 0) - dev->mtu = mtu[board_idx]; + if (mtu[find_cnt] > 0) + dev->mtu = mtu[find_cnt]; } if (dev->mem_start) - tp->default_port = dev->mem_start; + tp->default_port = dev->mem_start & 0x1f; if (tp->default_port) { + printk(KERN_INFO "%s: Transceiver selection forced to %s.\n", + dev->name, medianame[tp->default_port & MEDIA_MASK]); tp->medialock = 1; if (media_cap[tp->default_port] & MediaAlwaysFD) tp->full_duplex = 1; @@ -859,11 +827,9 @@ if (media_cap[tp->default_port] & MediaIsMII) { u16 media2advert[] = { 0x20, 0x40, 0x03e0, 0x60, 0x80, 0x100, 0x200 }; - tp->to_advertise = media2advert[tp->default_port - 9]; - } else if (tp->flags & HAS_8023X) - tp->to_advertise = 0x05e1; - else - tp->to_advertise = 0x01e1; + tp->mii_advertise = media2advert[tp->default_port - 9]; + tp->mii_advertise |= (tp->flags & HAS_8023X); /* Matching bits! */ + } /* This is logically part of probe1(), but too complex to write inline. */ if (tp->flags & HAS_MEDIA_TABLE) { @@ -871,16 +837,45 @@ parse_eeprom(dev); } + /* The Tulip-specific entries in the device structure. */ + dev->open = &tulip_open; + dev->hard_start_xmit = &tulip_start_xmit; + dev->stop = &tulip_close; + dev->get_stats = &tulip_get_stats; +#ifdef HAVE_PRIVATE_IOCTL + dev->do_ioctl = &private_ioctl; +#endif +#ifdef HAVE_MULTICAST + dev->set_multicast_list = &set_rx_mode; +#endif + + if (tp->flags & HAS_NWAY) + tp->link_change = nway_lnk_change; + else if (tp->flags & HAS_PNICNWAY) + tp->link_change = pnic_lnk_change; + start_link(dev); + + return dev; +} + +/* Start the link, typically called at probe1() time but sometimes later with + multiport cards. */ +static void start_link(struct net_device *dev) +{ + struct tulip_private *tp = (struct tulip_private *)dev->priv; + long ioaddr = dev->base_addr; + int i; + if ((tp->flags & ALWAYS_CHECK_MII) || (tp->mtable && tp->mtable->has_mii) || ( ! tp->mtable && (tp->flags & HAS_MII))) { - int phy, phy_idx; + int phyn, phy_idx = 0; if (tp->mtable && tp->mtable->has_mii) { for (i = 0; i < tp->mtable->leafcount; i++) if (tp->mtable->mleaf[i].media == 11) { tp->cur_index = i; tp->saved_if_port = dev->if_port; - select_media(dev, 1); + select_media(dev, 2); dev->if_port = tp->saved_if_port; break; } @@ -888,33 +883,38 @@ /* Find the connected MII xcvrs. Doing this in open() would allow detecting external xcvrs later, but takes much time. */ - for (phy = 0, phy_idx = 0; phy < 32 && phy_idx < sizeof(tp->phys); - phy++) { + for (phyn = 1; phyn <= 32 && phy_idx < sizeof(tp->phys); phyn++) { + int phy = phyn & 0x1f; int mii_status = mdio_read(dev, phy, 1); if ((mii_status & 0x8301) == 0x8001 || ((mii_status & 0x8000) == 0 && (mii_status & 0x7800) != 0)) { int mii_reg0 = mdio_read(dev, phy, 0); int mii_advert = mdio_read(dev, phy, 4); - int reg4 = ((mii_status>>6) & tp->to_advertise) | 1; - tp->phys[phy_idx] = phy; - tp->advertising[phy_idx++] = reg4; + int to_advert; + + if (tp->mii_advertise) + to_advert = tp->mii_advertise; + else if (tp->advertising[phy_idx]) + to_advert = tp->advertising[phy_idx]; + else /* Leave unchanged. */ + tp->mii_advertise = to_advert = mii_advert; + + tp->phys[phy_idx++] = phy; printk(KERN_INFO "%s: MII transceiver #%d " "config %4.4x status %4.4x advertising %4.4x.\n", dev->name, phy, mii_reg0, mii_status, mii_advert); /* Fixup for DLink with miswired PHY. */ - if (mii_advert != reg4) { + if (mii_advert != to_advert) { printk(KERN_DEBUG "%s: Advertising %4.4x on PHY %d," " previously advertising %4.4x.\n", - dev->name, reg4, phy, mii_advert); - printk(KERN_DEBUG "%s: Advertising %4.4x (to advertise" - " is %4.4x).\n", - dev->name, reg4, tp->to_advertise); - mdio_write(dev, phy, 4, reg4); + dev->name, to_advert, phy, mii_advert); + mdio_write(dev, phy, 4, to_advert); } /* Enable autonegotiation: some boards default to off. */ - mdio_write(dev, phy, 0, mii_reg0 | - (tp->full_duplex ? 0x1100 : 0x1000) | - (media_cap[tp->default_port]&MediaIs100 ? 0x2000:0)); + mdio_write(dev, phy, 0, (mii_reg0 & ~0x3000) | + (tp->full_duplex ? 0x0100 : 0x0000) | + ((media_cap[tp->default_port] & MediaIs100) ? + 0x2000 : 0x1000)); } } tp->mii_cnt = phy_idx; @@ -925,36 +925,21 @@ } } - /* The Tulip-specific entries in the device structure. */ - dev->open = &tulip_open; - dev->hard_start_xmit = &tulip_start_xmit; - dev->stop = &tulip_close; - dev->get_stats = &tulip_get_stats; -#ifdef HAVE_PRIVATE_IOCTL - dev->do_ioctl = &private_ioctl; -#endif -#ifdef HAVE_MULTICAST - dev->set_multicast_list = &set_rx_mode; -#endif - - if ((tp->flags & HAS_NWAY143) || tp->chip_id == DC21041) - tp->link_change = t21142_lnk_change; - else if (tp->flags & HAS_PNICNWAY) - tp->link_change = pnic_lnk_change; - /* Reset the xcvr interface and turn on heartbeat. */ - switch (chip_idx) { + switch (tp->chip_id) { + case DC21040: + outl(0x00000000, ioaddr + CSR13); + outl(0x00000004, ioaddr + CSR13); + break; case DC21041: - tp->to_advertise = 0x0061; + /* This is nway_start(). */ + if (tp->sym_advertise == 0) + tp->sym_advertise = 0x0061; outl(0x00000000, ioaddr + CSR13); outl(0xFFFFFFFF, ioaddr + CSR14); outl(0x00000008, ioaddr + CSR15); /* Listen on AUI also. */ - outl(inl(ioaddr + CSR6) | 0x0200, ioaddr + CSR6); - outl(0x0000EF05, ioaddr + CSR13); - break; - case DC21040: - outl(0x00000000, ioaddr + CSR13); - outl(0x00000004, ioaddr + CSR13); + outl(inl(ioaddr + CSR6) | FullDuplex, ioaddr + CSR6); + outl(0x0000EF01, ioaddr + CSR13); break; case DC21140: default: if (tp->mtable) @@ -968,7 +953,7 @@ outl(0x0000, ioaddr + CSR14); outl(0x820E0000, ioaddr + CSR6); } else - t21142_start_nway(dev); + nway_start(dev); break; case LC82C168: if ( ! tp->mii_cnt) { @@ -991,25 +976,25 @@ outl(0x00001000, ioaddr + CSR12); break; case COMET: - case COMET5: - /* No initialization necessary. */ break; } - if (tulip_tbl[chip_idx].flags & HAS_PWRDWN) - pcibios_write_config_dword(pci_bus, pci_devfn, 0x40, 0x40000000); - - return dev; + if (tp->flags & HAS_PWRDWN) + pci_write_config_dword(tp->pci_dev, 0x40, 0x40000000); } + /* Serial EEPROM section. */ /* The main routine to parse the very complicated SROM structure. Search www.digital.com for "21X4 SROM" to get details. This code is very complex, and will require changes to support - additional cards, so I'll be verbose about what is going on. + additional cards, so I will be verbose about what is going on. */ -/* Known cards that have old-style EEPROMs. */ +/* Known cards that have old-style EEPROMs. + Writing this table is described at + http://www.scyld.com/network/tulip-media.html +*/ static struct fixups { char *name; unsigned char addr0, addr1, addr2; @@ -1053,14 +1038,15 @@ #define get_u16(ptr) (((u8*)(ptr))[0] + (((u8*)(ptr))[1]<<8)) #endif -static void parse_eeprom(struct device *dev) +static void parse_eeprom(struct net_device *dev) { /* The last media info list parsed, for multiport boards. */ static struct mediatable *last_mediatable = NULL; static unsigned char *last_ee_data = NULL; static int controller_index = 0; struct tulip_private *tp = (struct tulip_private *)dev->priv; - unsigned char *ee_data = tp->eeprom; + unsigned char *p, *ee_data = tp->eeprom; + int new_advertise = 0; int i; tp->mtable = 0; @@ -1081,59 +1067,76 @@ } else printk(KERN_INFO "%s: Missing EEPROM, this interface may " "not work correctly!\n", - dev->name); + dev->name); return; } - /* Do a fix-up based on the vendor half of the station address prefix. */ - for (i = 0; eeprom_fixups[i].name; i++) { - if (dev->dev_addr[0] == eeprom_fixups[i].addr0 - && dev->dev_addr[1] == eeprom_fixups[i].addr1 - && dev->dev_addr[2] == eeprom_fixups[i].addr2) { - if (dev->dev_addr[2] == 0xE8 && ee_data[0x1a] == 0x55) - i++; /* An Accton EN1207, not an outlaw Maxtech. */ - memcpy(ee_data + 26, eeprom_fixups[i].newtable, - sizeof(eeprom_fixups[i].newtable)); - printk(KERN_INFO "%s: Old format EEPROM on '%s' board. Using" - " substitute media control info.\n", - dev->name, eeprom_fixups[i].name); - break; + /* Do a fix-up based on the vendor half of the station address. */ + for (i = 0; eeprom_fixups[i].name; i++) { + if (dev->dev_addr[0] == eeprom_fixups[i].addr0 + && dev->dev_addr[1] == eeprom_fixups[i].addr1 + && dev->dev_addr[2] == eeprom_fixups[i].addr2) { + if (dev->dev_addr[2] == 0xE8 && ee_data[0x1a] == 0x55) + i++; /* An Accton EN1207, not an outlaw Maxtech. */ + memcpy(ee_data + 26, eeprom_fixups[i].newtable, + sizeof(eeprom_fixups[i].newtable)); + printk(KERN_INFO "%s: Old format EEPROM on '%s' board.\n" + KERN_INFO "%s: Using substitute media control info.\n", + dev->name, eeprom_fixups[i].name, dev->name); + break; + } + } + if (eeprom_fixups[i].name == NULL) { /* No fixup found. */ + printk(KERN_INFO "%s: Old style EEPROM with no media selection " + "information.\n", + dev->name); + return; } - } - if (eeprom_fixups[i].name == NULL) { /* No fixup found. */ - printk(KERN_INFO "%s: Old style EEPROM with no media selection " - "information.\n", - dev->name); - return; - } } controller_index = 0; - if (ee_data[19] > 1) { /* Multiport board. */ + if (ee_data[19] > 1) { + struct net_device *prev_dev; + struct tulip_private *otp; + /* This is a multiport board. The probe order may be "backwards", so + we patch up already found devices. */ last_ee_data = ee_data; + for (prev_dev = tp->next_module; prev_dev; prev_dev = otp->next_module) { + otp = (struct tulip_private *)prev_dev->priv; + if (otp->eeprom[0] == 0xff && otp->mtable == 0) { + parse_eeprom(prev_dev); + start_link(prev_dev); + } else + break; + } + controller_index = 0; } subsequent_board: + p = (void *)ee_data + ee_data[27 + controller_index*3]; if (ee_data[27] == 0) { /* No valid media table. */ } else if (tp->chip_id == DC21041) { - unsigned char *p = (void *)ee_data + ee_data[27 + controller_index*3]; int media = get_u16(p); int count = p[2]; p += 3; printk(KERN_INFO "%s: 21041 Media table, default media %4.4x (%s).\n", dev->name, media, - media & 0x0800 ? "Autosense" : medianame[media & 15]); + media & 0x0800 ? "Autosense" : medianame[media & MEDIA_MASK]); for (i = 0; i < count; i++) { - unsigned char media_code = *p++; - if (media_code & 0x40) + unsigned char media_block = *p++; + int media_code = media_block & MEDIA_MASK; + if (media_block & 0x40) p += 6; + switch(media_code) { + case 0: new_advertise |= 0x0020; break; + case 4: new_advertise |= 0x0040; break; + } printk(KERN_INFO "%s: 21041 media #%d, %s.\n", - dev->name, media_code & 15, medianame[media_code & 15]); + dev->name, media_code, medianame[media_code]); } } else { - unsigned char *p = (void *)ee_data + ee_data[27]; unsigned char csr12dir = 0; - int count, new_advertise = 0; + int count; struct mediatable *mtable; u16 media = get_u16(p); @@ -1154,7 +1157,7 @@ mtable->csr15dir = mtable->csr15val = 0; printk(KERN_INFO "%s: EEPROM default media type %s.\n", dev->name, - media & 0x0800 ? "Autosense" : medianame[media & 15]); + media & 0x0800 ? "Autosense" : medianame[media & MEDIA_MASK]); for (i = 0; i < count; i++) { struct medialeaf *leaf = &mtable->mleaf[i]; @@ -1166,16 +1169,28 @@ mtable->has_mii = 1; p += 4; } else { - leaf->type = p[1]; - if (p[1] == 0x05) { - mtable->has_reset = i; - leaf->media = p[2] & 0x0f; - } else if (p[1] & 1) { + switch(leaf->type = p[1]) { + case 5: + mtable->has_reset = i + 1; /* Assure non-zero */ + /* Fall through */ + case 6: + leaf->media = 31; + break; + case 1: case 3: mtable->has_mii = 1; leaf->media = 11; - } else { + break; + case 2: + if ((p[2] & 0x3f) == 0) { + u32 base15 = (p[2] & 0x40) ? get_u16(p + 7) : 0x0008; + u16 *p1 = (u16 *)(p + (p[2] & 0x40 ? 9 : 3)); + mtable->csr15dir = (get_unaligned(p1 + 0)<<16) + base15; + mtable->csr15val = (get_unaligned(p1 + 1)<<16) + base15; + } + /* Fall through. */ + case 0: case 4: mtable->has_nonmii = 1; - leaf->media = p[2] & 0x0f; + leaf->media = p[2] & MEDIA_MASK; switch (leaf->media) { case 0: new_advertise |= 0x0020; break; case 4: new_advertise |= 0x0040; break; @@ -1183,18 +1198,9 @@ case 5: new_advertise |= 0x0100; break; case 6: new_advertise |= 0x0200; break; } - if (p[1] == 2 && leaf->media == 0) { - if (p[2] & 0x40) { - u32 base15 = get_unaligned((u16*)&p[7]); - mtable->csr15dir = - (get_unaligned((u16*)&p[9])<<16) + base15; - mtable->csr15val = - (get_unaligned((u16*)&p[11])<<16) + base15; - } else { - mtable->csr15dir = get_unaligned((u16*)&p[3])<<16; - mtable->csr15val = get_unaligned((u16*)&p[5])<<16; - } - } + break; + default: + leaf->media = 19; } leaf->leafdata = p + 2; p += (p[0] & 0x3f) + 1; @@ -1209,10 +1215,11 @@ printk(KERN_INFO "%s: Index #%d - Media %s (#%d) described " "by a %s (%d) block.\n", dev->name, i, medianame[leaf->media], leaf->media, - block_name[leaf->type], leaf->type); + leaf->type < 6 ? block_name[leaf->type] : "UNKNOWN", + leaf->type); } if (new_advertise) - tp->to_advertise = new_advertise; + tp->sym_advertise = new_advertise; } } /* Reading a serial EEPROM is a "bit" grungy, but we work our way through:->.*/ @@ -1227,7 +1234,7 @@ #define EE_ENB (0x4800 | EE_CS) /* Delay between EEPROM clock transitions. - Even at 33Mhz current PCI implementations don't overrun the EEPROM clock. + Even at 33Mhz current PCI implementations do not overrun the EEPROM clock. We add a bus turn-around to insure that this remains true. */ #define eeprom_delay() inl(ee_addr) @@ -1255,6 +1262,7 @@ retval = (retval << 1) | ((inl(ee_addr) & EE_DATA_READ) ? 1 : 0); } outl(EE_ENB, ee_addr); + eeprom_delay(); for (i = 16; i > 0; i--) { outl(EE_ENB | EE_SHIFT_CLK, ee_addr); @@ -1289,15 +1297,30 @@ #define MDIO_ENB_IN 0x40000 #define MDIO_DATA_READ 0x80000 -static int mdio_read(struct device *dev, int phy_id, int location) +static const unsigned char comet_miireg2offset[32] = { + 0xB4, 0xB8, 0xBC, 0xC0, 0xC4, 0xC8, 0xCC, 0, 0,0,0,0, 0,0,0,0, + 0,0xD0,0,0, 0,0,0,0, 0,0,0,0, 0, 0xD4, 0xD8, 0xDC, }; + +static int mdio_read(struct net_device *dev, int phy_id, int location) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int i; - int read_cmd = (0xf6 << 10) | (phy_id << 5) | location; + int read_cmd = (0xf6 << 10) | ((phy_id & 0x1f) << 5) | location; int retval = 0; long ioaddr = dev->base_addr; long mdio_addr = ioaddr + CSR9; + long flags; + + if (location & ~0x1f) + return 0xffff; + + if (tp->chip_id == COMET && phy_id == 30) { + if (comet_miireg2offset[location]) + return inl(ioaddr + comet_miireg2offset[location]); + return 0xffff; + } + spin_lock_irqsave(&tp->mii_lock, flags); if (tp->chip_id == LC82C168) { int i = 1000; outl(0x60020000 + (phy_id<<23) + (location<<18), ioaddr + 0xA0); @@ -1305,20 +1328,9 @@ inl(ioaddr + 0xA0); while (--i > 0) if ( ! ((retval = inl(ioaddr + 0xA0)) & 0x80000000)) - return retval & 0xffff; - return 0xffff; - } - - if ((tp->chip_id == COMET) || (tp->chip_id == COMET5)) { - if (phy_id == 1) { - if (location < 7) - return inl(ioaddr + 0xB4 + (location<<2)); - else if (location == 17) - return inl(ioaddr + 0xD0); - else if (location >= 29 && location <= 31) - return inl(ioaddr + 0xD4 + ((location-29)<<2)); - } - return 0xffff; + break; + spin_unlock_irqrestore(&tp->mii_lock, flags); + return retval & 0xffff; } /* Establish sync by sending at least 32 logic ones. */ @@ -1345,17 +1357,29 @@ outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } + spin_unlock_irqrestore(&tp->mii_lock, flags); return (retval>>1) & 0xffff; } -static void mdio_write(struct device *dev, int phy_id, int location, int value) +static void mdio_write(struct net_device *dev, int phy_id, int location, int val) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int i; - int cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value; + int cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | (val & 0xffff); long ioaddr = dev->base_addr; long mdio_addr = ioaddr + CSR9; + long flags; + + if (location & ~0x1f) + return; + + if (tp->chip_id == COMET && phy_id == 30) { + if (comet_miireg2offset[location]) + outl(val, ioaddr + comet_miireg2offset[location]); + return; + } + spin_lock_irqsave(&tp->mii_lock, flags); if (tp->chip_id == LC82C168) { int i = 1000; outl(cmd, ioaddr + 0xA0); @@ -1363,18 +1387,7 @@ if ( ! (inl(ioaddr + 0xA0) & 0x80000000)) break; while (--i > 0); - return; - } - - if ((tp->chip_id == COMET) || (tp->chip_id == COMET5)) { - if (phy_id != 1) - return; - if (location < 7) - outl(value, ioaddr + 0xB4 + (location<<2)); - else if (location == 17) - outl(value, ioaddr + 0xD0); - else if (location >= 29 && location <= 31) - outl(value, ioaddr + 0xD4 + ((location-29)<<2)); + spin_unlock_irqrestore(&tp->mii_lock, flags); return; } @@ -1400,21 +1413,21 @@ outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } + spin_unlock_irqrestore(&tp->mii_lock, flags); return; } static int -tulip_open(struct device *dev) +tulip_open(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int next_tick = 3*HZ; - int i; /* Wake the chip from sleep/snooze mode. */ if (tp->flags & HAS_PWRDWN) - pcibios_write_config_dword(tp->pci_bus, tp->pci_devfn, 0x40, 0); + pci_write_config_dword(tp->pci_dev, 0x40, 0); /* On some chip revs we must set the MII/SYM port before the reset!? */ if (tp->mii_cnt || (tp->mtable && tp->mtable->has_mii)) @@ -1423,10 +1436,15 @@ /* Reset the chip, holding bit 0 set at least 50 PCI cycles. */ outl(0x00000001, ioaddr + CSR0); - if (request_irq(dev->irq, &tulip_interrupt, SA_SHIRQ, dev->name, dev)) - return -EAGAIN; MOD_INC_USE_COUNT; + /* This would be done after interrupts are initialized, but we do not want + to frob the transceiver only to fail later. */ + if (request_irq(dev->irq, &tulip_interrupt, SA_SHIRQ, dev->name, dev)) { + MOD_DEC_USE_COUNT; + return -EAGAIN; + } + /* Deassert reset. Wait the specified 50 PCI cycles after a reset by initializing Tx and Rx queues and the address filter list. */ @@ -1437,53 +1455,74 @@ tulip_init_ring(dev); -#if 0 if (tp->chip_id == PNIC2) { - u32 addr_low = cpu_to_le32(get_unaligned((u32 *)dev->dev_addr)); - u32 addr_high = cpu_to_le16(get_unaligned((u16 *)(dev->dev_addr+4))); - addr_high = (dev->dev_addr[4]<<8) + (dev->dev_addr[5]<<0); - outl((dev->dev_addr[0]<<8) + dev->dev_addr[1] + - (dev->dev_addr[2]<<24) + (dev->dev_addr[3]<<16), + u32 addr_high = (dev->dev_addr[1]<<8) + (dev->dev_addr[0]<<0); + /* This address setting does not appear to impact chip operation?? */ + outl((dev->dev_addr[5]<<8) + dev->dev_addr[4] + + (dev->dev_addr[3]<<24) + (dev->dev_addr[2]<<16), ioaddr + 0xB0); outl(addr_high + (addr_high<<16), ioaddr + 0xB8); } -#endif if (tp->flags & MC_HASH_ONLY) { u32 addr_low = cpu_to_le32(get_unaligned((u32 *)dev->dev_addr)); - u32 addr_high = cpu_to_le32(get_unaligned((u16 *)(dev->dev_addr+4))); - if (tp->chip_id == AX88140) { + u32 addr_high = cpu_to_le16(get_unaligned((u16 *)(dev->dev_addr+4))); + if (tp->flags & IS_ASIX) { outl(0, ioaddr + CSR13); outl(addr_low, ioaddr + CSR14); outl(1, ioaddr + CSR13); outl(addr_high, ioaddr + CSR14); - } else if ((tp->chip_id == COMET) || (tp->chip_id == COMET5)) { + } else if (tp->flags & COMET_MAC_ADDR) { outl(addr_low, ioaddr + 0xA4); outl(addr_high, ioaddr + 0xA8); outl(0, ioaddr + 0xAC); outl(0, ioaddr + 0xB0); } - } else { - /* This is set_rx_mode(), but without starting the transmitter. */ - u16 *eaddrs = (u16 *)dev->dev_addr; - u16 *setup_frm = &tp->setup_frame[15*6]; - - /* 21140 bug: you must add the broadcast address. */ - memset(tp->setup_frame, 0xff, sizeof(tp->setup_frame)); - /* Fill the final entry of the table with our physical address. */ - *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0]; - *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1]; - *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2]; - /* Put the setup frame on the Tx list. */ - tp->tx_ring[0].length = cpu_to_le32(0x08000000 | 192); - tp->tx_ring[0].buffer1 = virt_to_le32desc(tp->setup_frame); - tp->tx_ring[0].status = cpu_to_le32(DescOwned); - - tp->cur_tx++; } outl(virt_to_bus(tp->rx_ring), ioaddr + CSR3); outl(virt_to_bus(tp->tx_ring), ioaddr + CSR4); + if ( ! tp->full_duplex_lock) + tp->full_duplex = 0; + init_media(dev); + if (media_cap[dev->if_port] & MediaIsMII) + check_duplex(dev); + set_rx_mode(dev); + + /* Start the Tx to process setup frame. */ + outl(tp->csr6, ioaddr + CSR6); + outl(tp->csr6 | TxOn, ioaddr + CSR6); + + netif_start_tx_queue(dev); + + /* Enable interrupts by setting the interrupt mask. */ + outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR5); + outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7); + outl(tp->csr6 | TxOn | RxOn, ioaddr + CSR6); + outl(0, ioaddr + CSR2); /* Rx poll demand */ + + if (tulip_debug > 2) + printk(KERN_DEBUG "%s: Done tulip_open(), CSR0 %8.8x, CSR5 %8.8x CSR6 " + "%8.8x.\n", dev->name, (int)inl(ioaddr + CSR0), + (int)inl(ioaddr + CSR5), (int)inl(ioaddr + CSR6)); + + /* Set the timer to switch to check for link beat and perhaps switch + to an alternate media type. */ + init_timer(&tp->timer); + tp->timer.expires = jiffies + next_tick; + tp->timer.data = (unsigned long)dev; + tp->timer.function = tulip_tbl[tp->chip_id].media_timer; + add_timer(&tp->timer); + + return 0; +} + +static void init_media(struct net_device *dev) +{ + struct tulip_private *tp = (struct tulip_private *)dev->priv; + long ioaddr = dev->base_addr; + int i; + tp->saved_if_port = dev->if_port; if (dev->if_port == 0) dev->if_port = tp->default_port; @@ -1497,13 +1536,14 @@ (dev->if_port == 12 ? 0 : dev->if_port); for (i = 0; i < tp->mtable->leafcount; i++) if (tp->mtable->mleaf[i].media == looking_for) { - printk(KERN_INFO "%s: Using user-specified media %s.\n", - dev->name, medianame[dev->if_port]); + if (debug) + printk(KERN_INFO "%s: Using user-specified media %s.\n", + dev->name, medianame[dev->if_port]); goto media_picked; } } if ((tp->mtable->defaultmedia & 0x0800) == 0) { - int looking_for = tp->mtable->defaultmedia & 15; + int looking_for = tp->mtable->defaultmedia & MEDIA_MASK; for (i = 0; i < tp->mtable->leafcount; i++) if (tp->mtable->mleaf[i].media == looking_for) { printk(KERN_INFO "%s: Using EEPROM-set media %s.\n", @@ -1520,15 +1560,28 @@ tp->csr6 = 0; tp->cur_index = i; tp->nwayset = 0; - if (dev->if_port == 0 && tp->chip_id == DC21041) { - tp->nway = 1; + + if (dev->if_port) { + if (tp->chip_id == DC21143 && + (media_cap[dev->if_port] & MediaIsMII)) { + /* We must reset the media CSRs when we force-select MII mode. */ + outl(0x0000, ioaddr + CSR13); + outl(0x0000, ioaddr + CSR14); + outl(0x0008, ioaddr + CSR15); + } + select_media(dev, 1); + return; } - if (dev->if_port == 0 && tp->chip_id == DC21142) { + switch(tp->chip_id) { + case DC21041: + /* tp->nway = 1;*/ + nway_start(dev); + break; + case DC21142: if (tp->mii_cnt) { select_media(dev, 1); if (tulip_debug > 1) - printk(KERN_INFO "%s: Using MII transceiver %d, status " - "%4.4x.\n", + printk(KERN_INFO "%s: Using MII transceiver %d, status %4.4x.\n", dev->name, tp->phys[0], mdio_read(dev, tp->phys[0], 1)); outl(0x82020000, ioaddr + CSR6); tp->csr6 = 0x820E0000; @@ -1536,13 +1589,15 @@ outl(0x0000, ioaddr + CSR13); outl(0x0000, ioaddr + CSR14); } else - t21142_start_nway(dev); - } else if (tp->chip_id == PNIC2) { - t21142_start_nway(dev); - } else if (tp->chip_id == LC82C168 && ! tp->medialock) { + nway_start(dev); + break; + case PNIC2: + nway_start(dev); + break; + case LC82C168: if (tp->mii_cnt) { dev->if_port = 11; - tp->csr6 = 0x814C0000 | (tp->full_duplex ? 0x0200 : 0); + tp->csr6 = 0x814C0000 | (tp->full_duplex ? FullDuplex : 0); outl(0x0001, ioaddr + CSR15); } else if (inl(ioaddr + CSR5) & TPLnkPass) pnic_do_nway(dev); @@ -1552,65 +1607,39 @@ tp->csr6 = 0x00420000; outl(0x0001B078, ioaddr + 0xB8); outl(0x0201B078, ioaddr + 0xB8); - next_tick = 1*HZ; } - } else if ((tp->chip_id == MX98713 || tp->chip_id == COMPEX9881) - && ! tp->medialock) { + break; + case MX98713: case COMPEX9881: dev->if_port = 0; - tp->csr6 = 0x01880000 | (tp->full_duplex ? 0x0200 : 0); + tp->csr6 = 0x01880000 | (tp->full_duplex ? FullDuplex : 0); outl(0x0f370000 | inw(ioaddr + 0x80), ioaddr + 0x80); - } else if (tp->chip_id == MX98715 || tp->chip_id == MX98725) { + break; + case MX98715: case MX98725: /* Provided by BOLO, Macronix - 12/10/1998. */ dev->if_port = 0; - tp->csr6 = 0x01a80200; + tp->csr6 = 0x01a80000 | FullDuplex; outl(0x0f370000 | inw(ioaddr + 0x80), ioaddr + 0x80); outl(0x11000 | inw(ioaddr + 0xa0), ioaddr + 0xa0); - } else if (tp->chip_id == DC21143 && - media_cap[dev->if_port] & MediaIsMII) { - /* We must reset the media CSRs when we force-select MII mode. */ - outl(0x0000, ioaddr + CSR13); - outl(0x0000, ioaddr + CSR14); - outl(0x0008, ioaddr + CSR15); - } else if ((tp->chip_id == COMET) || (tp->chip_id == COMET5)) { - dev->if_port = 0; + break; + case COMET: case CONEXANT: + /* Enable automatic Tx underrun recovery. */ + outl(inl(ioaddr + 0x88) | 1, ioaddr + 0x88); + dev->if_port = tp->mii_cnt ? 11 : 0; tp->csr6 = 0x00040000; - } else if (tp->chip_id == AX88140) { + break; + case AX88140: case AX88141: tp->csr6 = tp->mii_cnt ? 0x00040100 : 0x00000100; - } else - select_media(dev, 1); - - /* Start the chip's Tx to process setup frame. */ - outl(tp->csr6, ioaddr + CSR6); - outl(tp->csr6 | 0x2000, ioaddr + CSR6); - - dev->tbusy = 0; - tp->interrupt = 0; - dev->start = 1; - - /* Enable interrupts by setting the interrupt mask. */ - outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR5); - outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); - outl(0, ioaddr + CSR2); /* Rx poll demand */ - - if (tulip_debug > 2) { - printk(KERN_DEBUG "%s: Done tulip_open(), CSR0 %8.8x, CSR5 %8.8x CSR6 %8.8x.\n", - dev->name, inl(ioaddr + CSR0), inl(ioaddr + CSR5), - inl(ioaddr + CSR6)); + break; + default: + select_media(dev, 1); } - /* Set the timer to switch to check for link beat and perhaps switch - to an alternate media type. */ - init_timer(&tp->timer); - tp->timer.expires = RUN_AT(next_tick); - tp->timer.data = (unsigned long)dev; - tp->timer.function = tulip_tbl[tp->chip_id].media_timer; - add_timer(&tp->timer); - - return 0; } -/* Set up the transceiver control registers for the selected media type. */ -static void select_media(struct device *dev, int startup) +/* Set up the transceiver control registers for the selected media type. + STARTUP indicates to reset the transceiver. It is set to '2' for + the initial card detection, and '1' during resume or open(). +*/ +static void select_media(struct net_device *dev, int startup) { long ioaddr = dev->base_addr; struct tulip_private *tp = (struct tulip_private *)dev->priv; @@ -1621,6 +1650,9 @@ if (mtable) { struct medialeaf *mleaf = &mtable->mleaf[tp->cur_index]; unsigned char *p = mleaf->leafdata; + if (tulip_debug > 2) + printk(KERN_DEBUG "%s: Media table type %d.\n", + dev->name, mleaf->type); switch (mleaf->type) { case 0: /* 21140 non-MII xcvr. */ if (tulip_debug > 1) @@ -1639,12 +1671,12 @@ for (i = 0; i < 5; i++) setup[i] = get_u16(&p[i*2 + 1]); - dev->if_port = p[0] & 15; + dev->if_port = p[0] & MEDIA_MASK; if (media_cap[dev->if_port] & MediaAlwaysFD) tp->full_duplex = 1; if (startup && mtable->has_reset) { - struct medialeaf *rleaf = &mtable->mleaf[mtable->has_reset]; + struct medialeaf *rleaf = &mtable->mleaf[mtable->has_reset-1]; unsigned char *rst = rleaf->leafdata; if (tulip_debug > 1) printk(KERN_DEBUG "%s: Resetting the transceiver.\n", @@ -1668,7 +1700,7 @@ outl(csr13val, ioaddr + CSR13); } else { csr13val = 1; - csr14val = 0x0003FF7F; + csr14val = 0x0003FFFF; csr15dir = (setup[0]<<16) | 0x0008; csr15val = (setup[1]<<16) | 0x0008; if (dev->if_port <= 4) @@ -1685,7 +1717,7 @@ printk(KERN_DEBUG "%s: Setting CSR15 to %8.8x/%8.8x.\n", dev->name, csr15dir, csr15val); if (mleaf->type == 4) - new_csr6 = 0x82020000 | ((setup[2] & 0x71) << 18); + new_csr6 = 0x820A0000 | ((setup[2] & 0x71) << 18); else new_csr6 = 0x82420000; break; @@ -1694,7 +1726,6 @@ int phy_num = p[0]; int init_length = p[1]; u16 *misc_info; - u16 to_advertise; dev->if_port = 11; new_csr6 = 0x020E0000; @@ -1721,13 +1752,15 @@ for (i = 0; i < init_length; i++) outl(init_sequence[i], ioaddr + CSR12); } - to_advertise = (get_u16(&misc_info[1]) & tp->to_advertise) | 1; - tp->advertising[phy_num] = to_advertise; - if (tulip_debug > 1) - printk(KERN_DEBUG "%s: Advertising %4.4x on PHY %d (%d).\n", - dev->name, to_advertise, phy_num, tp->phys[phy_num]); - /* Bogus: put in by a committee? */ - mdio_write(dev, tp->phys[phy_num], 4, to_advertise); + tp->advertising[phy_num] = get_u16(&misc_info[1]) | 1; + if (startup < 2) { + if (tp->mii_advertise == 0) + tp->mii_advertise = tp->advertising[phy_num]; + if (tulip_debug > 1) + printk(KERN_DEBUG "%s: Advertising %4.4x on MII %d.\n", + dev->name, tp->mii_advertise, tp->phys[phy_num]); + mdio_write(dev, tp->phys[phy_num], 4, tp->mii_advertise); + } break; } default: @@ -1738,13 +1771,13 @@ if (tulip_debug > 1) printk(KERN_DEBUG "%s: Using media type %s, CSR12 is %2.2x.\n", dev->name, medianame[dev->if_port], - inl(ioaddr + CSR12) & 0xff); + (int)inl(ioaddr + CSR12) & 0xff); } else if (tp->chip_id == DC21041) { int port = dev->if_port <= 4 ? dev->if_port : 0; if (tulip_debug > 1) printk(KERN_DEBUG "%s: 21041 using media %s, CSR12 is %4.4x.\n", dev->name, medianame[port == 3 ? 12: port], - inl(ioaddr + CSR12)); + (int)inl(ioaddr + CSR12)); outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */ outl(t21041_csr14[port], ioaddr + CSR14); outl(t21041_csr15[port], ioaddr + CSR15); @@ -1755,7 +1788,8 @@ dev->if_port = tp->mii_cnt ? 11 : 0; if (tulip_debug > 1) printk(KERN_DEBUG "%s: PNIC PHY status is %3.3x, media %s.\n", - dev->name, inl(ioaddr + 0xB8), medianame[dev->if_port]); + dev->name, (int)inl(ioaddr + 0xB8), + medianame[dev->if_port]); if (tp->mii_cnt) { new_csr6 = 0x810C0000; outl(0x0001, ioaddr + CSR15); @@ -1804,15 +1838,16 @@ } else if (media_cap[dev->if_port] & MediaIsFx) { new_csr6 = 0x028600000; } else - new_csr6 = 0x038600000; + new_csr6 = 0x038E00000; if (tulip_debug > 1) printk(KERN_DEBUG "%s: No media description table, assuming " "%s transceiver, CSR12 %2.2x.\n", dev->name, medianame[dev->if_port], - inl(ioaddr + CSR12)); + (int)inl(ioaddr + CSR12)); } - tp->csr6 = new_csr6 | (tp->csr6 & 0xfdff) | (tp->full_duplex ? 0x0200 : 0); + tp->csr6 = new_csr6 | (tp->csr6 & 0xfdff) | + (tp->full_duplex ? FullDuplex : 0); return; } @@ -1822,7 +1857,7 @@ Return 0 if everything is OK. Return < 0 if the transceiver is missing or has no link beat. */ -static int check_duplex(struct device *dev) +static int check_duplex(struct net_device *dev) { long ioaddr = dev->base_addr; struct tulip_private *tp = (struct tulip_private *)dev->priv; @@ -1830,14 +1865,16 @@ if (tp->full_duplex_lock) return 0; - mii_reg1 = mdio_read(dev, tp->phys[0], 1); mii_reg5 = mdio_read(dev, tp->phys[0], 5); + negotiated = mii_reg5 & tp->mii_advertise; + if (tulip_debug > 1) - printk(KERN_INFO "%s: MII status %4.4x, Link partner report " - "%4.4x.\n", dev->name, mii_reg1, mii_reg5); - if (mii_reg1 == 0xffff) + printk(KERN_INFO "%s: MII link partner %4.4x, negotiated %4.4x.\n", + dev->name, mii_reg5, negotiated); + if (mii_reg5 == 0xffff) return -2; - if ((mii_reg1 & 0x0004) == 0) { + if ((mii_reg5 & 0x4000) == 0 && /* No negotiation. */ + ((mii_reg1 = mdio_read(dev, tp->phys[0], 1)) & 0x0004) == 0) { int new_reg1 = mdio_read(dev, tp->phys[0], 1); if ((new_reg1 & 0x0004) == 0) { if (tulip_debug > 1) @@ -1846,20 +1883,19 @@ return -1; } } - negotiated = mii_reg5 & tp->advertising[0]; duplex = ((negotiated & 0x0300) == 0x0100 || (negotiated & 0x00C0) == 0x0040); /* 100baseTx-FD or 10T-FD, but not 100-HD */ if (tp->full_duplex != duplex) { tp->full_duplex = duplex; - if (negotiated & 0x038) /* 100mbps. */ + if (negotiated & 0x0380) /* 100mbps. */ tp->csr6 &= ~0x00400000; - if (tp->full_duplex) tp->csr6 |= 0x0200; - else tp->csr6 &= ~0x0200; - outl(tp->csr6 | 0x0002, ioaddr + CSR6); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + if (tp->full_duplex) tp->csr6 |= FullDuplex; + else tp->csr6 &= ~FullDuplex; + outl(tp->csr6 | RxOn, ioaddr + CSR6); + outl(tp->csr6 | TxOn | RxOn, ioaddr + CSR6); if (tulip_debug > 0) - printk(KERN_INFO "%s: Setting %s-duplex based on MII" + printk(KERN_INFO "%s: Setting %s-duplex based on MII " "#%d link partner capability of %4.4x.\n", dev->name, tp->full_duplex ? "full" : "half", tp->phys[0], mii_reg5); @@ -1870,7 +1906,7 @@ static void tulip_timer(unsigned long data) { - struct device *dev = (struct device *)data; + struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; u32 csr12 = inl(ioaddr + CSR12); @@ -1879,13 +1915,13 @@ if (tulip_debug > 2) { printk(KERN_DEBUG "%s: Media selection tick, %s, status %8.8x mode" " %8.8x SIA %8.8x %8.8x %8.8x %8.8x.\n", - dev->name, medianame[dev->if_port], inl(ioaddr + CSR5), - inl(ioaddr + CSR6), csr12, inl(ioaddr + CSR13), - inl(ioaddr + CSR14), inl(ioaddr + CSR15)); + dev->name, medianame[dev->if_port], (int)inl(ioaddr + CSR5), + (int)inl(ioaddr + CSR6), csr12, (int)inl(ioaddr + CSR13), + (int)inl(ioaddr + CSR14), (int)inl(ioaddr + CSR15)); } switch (tp->chip_id) { case DC21040: - if (!tp->medialock && csr12 & 0x0002) { /* Network error */ + if (!tp->medialock && (csr12 & 0x0002)) { /* Network error */ printk(KERN_INFO "%s: No link beat found.\n", dev->name); dev->if_port = (dev->if_port == 2 ? 0 : 2); @@ -1948,7 +1984,7 @@ if (tulip_debug > 2) printk(KERN_DEBUG "%s: network media monitor CSR6 %8.8x " "CSR12 0x%2.2x.\n", - dev->name, inl(ioaddr + CSR6), csr12 & 0xff); + dev->name, (int)inl(ioaddr + CSR6), csr12 & 0xff); break; } mleaf = &tp->mtable->mleaf[tp->cur_index]; @@ -1980,7 +2016,7 @@ ((csr12 & (1 << ((bitnum >> 1) & 7))) != 0)) { if (tulip_debug > 1) printk(KERN_DEBUG "%s: Link beat detected for %s.\n", dev->name, - medianame[mleaf->media]); + medianame[mleaf->media & MEDIA_MASK]); if ((p[2] & 0x61) == 0x01) /* Bogus Znyx board. */ goto actually_mii; break; @@ -1998,12 +2034,12 @@ if (tulip_debug > 1) printk(KERN_DEBUG "%s: No link beat on media %s," " trying transceiver type %s.\n", - dev->name, medianame[mleaf->media & 15], + dev->name, medianame[mleaf->media & MEDIA_MASK], medianame[tp->mtable->mleaf[tp->cur_index].media]); select_media(dev, 0); /* Restart the transmit process. */ - outl(tp->csr6 | 0x0002, ioaddr + CSR6); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + outl(tp->csr6 | RxOn, ioaddr + CSR6); + outl(tp->csr6 | TxOn | RxOn, ioaddr + CSR6); next_tick = (24*HZ)/10; break; } @@ -2019,15 +2055,16 @@ } break; } - tp->timer.expires = RUN_AT(next_tick); + tp->timer.expires = jiffies + next_tick; add_timer(&tp->timer); } -/* Handle the 21143 uniquely: do autoselect with NWay, not the EEPROM list - of available transceivers. */ -static void t21142_timer(unsigned long data) +/* Handle internal NWay transceivers uniquely. + These exist on the 21041, 21143 (in SYM mode) and the PNIC2. + */ +static void nway_timer(unsigned long data) { - struct device *dev = (struct device *)data; + struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int csr12 = inl(ioaddr + CSR12); @@ -2035,13 +2072,12 @@ int new_csr6 = 0; if (tulip_debug > 2) - printk(KERN_INFO"%s: 21143 negotiation status %8.8x, %s.\n", + printk(KERN_INFO"%s: N-Way autonegotiation status %8.8x, %s.\n", dev->name, csr12, medianame[dev->if_port]); if (media_cap[dev->if_port] & MediaIsMII) { check_duplex(dev); - next_tick = 60*HZ; } else if (tp->nwayset) { - /* Don't screw up a negotiated session! */ + /* Do not screw up a negotiated session! */ if (tulip_debug > 1) printk(KERN_INFO"%s: Using NWay-set %s media, csr12 %8.8x.\n", dev->name, medianame[dev->if_port], csr12); @@ -2052,7 +2088,7 @@ if (tulip_debug > 1) printk(KERN_INFO"%s: No 21143 100baseTx link beat, %8.8x, " "trying NWay.\n", dev->name, csr12); - t21142_start_nway(dev); + nway_start(dev); next_tick = 3*HZ; } } else if ((csr12 & 0x7000) != 0x5000) { @@ -2079,12 +2115,12 @@ if (tulip_debug > 1) printk(KERN_INFO"%s: Testing new 21143 media %s.\n", dev->name, medianame[dev->if_port]); - if (new_csr6 != (tp->csr6 & ~0x00D5)) { - tp->csr6 &= 0x00D5; + if (new_csr6 != (tp->csr6 & ~0x20D7)) { + tp->csr6 &= 0x20D7; tp->csr6 |= new_csr6; outl(0x0301, ioaddr + CSR12); - outl(tp->csr6 | 0x0002, ioaddr + CSR6); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + outl(tp->csr6 | RxOn, ioaddr + CSR6); + outl(tp->csr6 | TxOn | RxOn, ioaddr + CSR6); } next_tick = 3*HZ; } @@ -2095,49 +2131,69 @@ tulip_tx_timeout(dev); } - tp->timer.expires = RUN_AT(next_tick); + tp->timer.expires = jiffies + next_tick; add_timer(&tp->timer); } -static void t21142_start_nway(struct device *dev) +static void nway_start(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; - int csr14 = ((tp->to_advertise & 0x0780) << 9) | - ((tp->to_advertise&0x0020)<<1) | 0xffbf; + int csr14 = ((tp->sym_advertise & 0x0780) << 9) | + ((tp->sym_advertise&0x0020)<<1) | 0xffbf; dev->if_port = 0; tp->nway = tp->mediasense = 1; tp->nwayset = tp->lpar = 0; + if (tp->chip_id == PNIC2) { + tp->csr6 = 0x01000000 | (tp->sym_advertise & 0x0040 ? FullDuplex : 0); + return; + } if (debug > 1) - printk(KERN_DEBUG "%s: Restarting 21143 autonegotiation, %8.8x.\n", + printk(KERN_DEBUG "%s: Restarting internal NWay autonegotiation, %8.8x.\n", dev->name, csr14); outl(0x0001, ioaddr + CSR13); outl(csr14, ioaddr + CSR14); - tp->csr6 = 0x82420000 | (tp->to_advertise & 0x0040 ? 0x0200 : 0); + tp->csr6 = 0x82420000 | (tp->sym_advertise & 0x0040 ? FullDuplex : 0) + | (tp->csr6 & 0x20ff); outl(tp->csr6, ioaddr + CSR6); if (tp->mtable && tp->mtable->csr15dir) { outl(tp->mtable->csr15dir, ioaddr + CSR15); outl(tp->mtable->csr15val, ioaddr + CSR15); - } else + } else if (tp->chip_id != PNIC2) outw(0x0008, ioaddr + CSR15); - outl(0x1301, ioaddr + CSR12); /* Trigger NWAY. */ + if (tp->chip_id == DC21041) /* Trigger NWAY. */ + outl(0xEF01, ioaddr + CSR12); + else + outl(0x1301, ioaddr + CSR12); } -static void t21142_lnk_change(struct device *dev, int csr5) +static void nway_lnk_change(struct net_device *dev, int csr5) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int csr12 = inl(ioaddr + CSR12); + if (tp->chip_id == PNIC2) { + if (debug > 1) + printk(KERN_INFO"%s: PNIC-2 link status changed, CSR5/12/14 %8.8x" + " %8.8x, %8.8x.\n", + dev->name, csr12, csr5, (int)inl(ioaddr + CSR14)); + dev->if_port = 5; + tp->lpar = csr12 >> 16; + tp->nwayset = 1; + tp->csr6 = 0x01000000 | (tp->csr6 & 0xffff); + outl(tp->csr6, ioaddr + CSR6); + return; + } if (tulip_debug > 1) printk(KERN_INFO"%s: 21143 link status interrupt %8.8x, CSR5 %x, " - "%8.8x.\n", dev->name, csr12, csr5, inl(ioaddr + CSR14)); + "%8.8x.\n", dev->name, csr12, csr5, (int)inl(ioaddr + CSR14)); /* If NWay finished and we have a negotiated partner capability. */ if (tp->nway && !tp->nwayset && (csr12 & 0x7000) == 0x5000) { int setup_done = 0; - int negotiated = tp->to_advertise & (csr12 >> 16); + int negotiated = tp->sym_advertise & (csr12 >> 16); tp->lpar = csr12 >> 16; tp->nwayset = 1; if (negotiated & 0x0100) dev->if_port = 5; @@ -2146,7 +2202,7 @@ else if (negotiated & 0x0020) dev->if_port = 0; else { tp->nwayset = 0; - if ((csr12 & 2) == 0 && (tp->to_advertise & 0x0180)) + if ((csr12 & 2) == 0 && (tp->sym_advertise & 0x0180)) dev->if_port = 3; } tp->full_duplex = (media_cap[dev->if_port] & MediaAlwaysFD) ? 1:0; @@ -2155,7 +2211,7 @@ if (tp->nwayset) printk(KERN_INFO "%s: Switching to %s based on link " "negotiation %4.4x & %4.4x = %4.4x.\n", - dev->name, medianame[dev->if_port], tp->to_advertise, + dev->name, medianame[dev->if_port], tp->sym_advertise, tp->lpar, negotiated); else printk(KERN_INFO "%s: Autonegotiation failed, using %s," @@ -2174,30 +2230,31 @@ } } if ( ! setup_done) { - tp->csr6 = dev->if_port & 1 ? 0x83860000 : 0x82420000; + tp->csr6 = (dev->if_port & 1 ? 0x838E0000 : 0x82420000) + | (tp->csr6 & 0x20ff); if (tp->full_duplex) - tp->csr6 |= 0x0200; + tp->csr6 |= FullDuplex; outl(1, ioaddr + CSR13); } -#if 0 /* Restart shouldn't be needed. */ +#if 0 /* Restart should not be needed. */ outl(tp->csr6 | 0x0000, ioaddr + CSR6); if (debug > 2) printk(KERN_DEBUG "%s: Restarting Tx and Rx, CSR5 is %8.8x.\n", dev->name, inl(ioaddr + CSR5)); #endif - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + outl(tp->csr6 | TxOn | RxOn, ioaddr + CSR6); if (debug > 2) printk(KERN_DEBUG "%s: Setting CSR6 %8.8x/%x CSR12 %8.8x.\n", - dev->name, tp->csr6, inl(ioaddr + CSR6), - inl(ioaddr + CSR12)); + dev->name, tp->csr6, (int)inl(ioaddr + CSR6), + (int)inl(ioaddr + CSR12)); } else if ((tp->nwayset && (csr5 & 0x08000000) && (dev->if_port == 3 || dev->if_port == 5) && (csr12 & 2) == 2) || (tp->nway && (csr5 & (TPLnkFail)))) { /* Link blew? Maybe restart NWay. */ del_timer(&tp->timer); - t21142_start_nway(dev); - tp->timer.expires = RUN_AT(3*HZ); + nway_start(dev); + tp->timer.expires = jiffies + 3*HZ; add_timer(&tp->timer); } else if (dev->if_port == 3 || dev->if_port == 5) { if (tulip_debug > 1) @@ -2206,10 +2263,11 @@ (csr12 & 2) ? "failed" : "good"); if ((csr12 & 2) && ! tp->medialock) { del_timer(&tp->timer); - t21142_start_nway(dev); - tp->timer.expires = RUN_AT(3*HZ); + nway_start(dev); + tp->timer.expires = jiffies + 3*HZ; add_timer(&tp->timer); - } + } else if (dev->if_port == 5) + outl(inl(ioaddr + CSR14) & ~0x080, ioaddr + CSR14); } else if (dev->if_port == 0 || dev->if_port == 4) { if ((csr12 & 4) == 0) printk(KERN_INFO"%s: 21143 10baseT link beat good.\n", @@ -2228,32 +2286,30 @@ printk(KERN_INFO"%s: 21143 100baseTx sensed media.\n", dev->name); dev->if_port = 3; - tp->csr6 = 0x83860000; + tp->csr6 = 0x838E0000 | (tp->csr6 & 0x20ff); outl(0x0003FF7F, ioaddr + CSR14); outl(0x0301, ioaddr + CSR12); - outl(tp->csr6 | 0x0002, ioaddr + CSR6); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + outl(tp->csr6 | RxOn, ioaddr + CSR6); + outl(tp->csr6 | RxOn | TxOn, ioaddr + CSR6); } } static void mxic_timer(unsigned long data) { - struct device *dev = (struct device *)data; + struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int next_tick = 60*HZ; if (tulip_debug > 3) { printk(KERN_INFO"%s: MXIC negotiation status %8.8x.\n", dev->name, - inl(ioaddr + CSR12)); - } - if (next_tick) { - tp->timer.expires = RUN_AT(next_tick); - add_timer(&tp->timer); + (int)inl(ioaddr + CSR12)); } + tp->timer.expires = jiffies + next_tick; + add_timer(&tp->timer); } -static void pnic_do_nway(struct device *dev) +static void pnic_do_nway(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; @@ -2272,20 +2328,21 @@ outl(0x1F868, ioaddr + 0xB8); if (phy_reg & 0x30000000) { tp->full_duplex = 1; - new_csr6 |= 0x00000200; + new_csr6 |= FullDuplex; } if (tulip_debug > 1) printk(KERN_DEBUG "%s: PNIC autonegotiated status %8.8x, %s.\n", dev->name, phy_reg, medianame[dev->if_port]); if (tp->csr6 != new_csr6) { tp->csr6 = new_csr6; - outl(tp->csr6 | 0x0002, ioaddr + CSR6); /* Restart Tx */ - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + outl(tp->csr6 | RxOn, ioaddr + CSR6); /* Restart Tx */ + outl(tp->csr6 | TxOn | RxOn, ioaddr + CSR6); dev->trans_start = jiffies; } } } -static void pnic_lnk_change(struct device *dev, int csr5) + +static void pnic_lnk_change(struct net_device *dev, int csr5) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; @@ -2310,7 +2367,7 @@ } static void pnic_timer(unsigned long data) { - struct device *dev = (struct device *)data; + struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int next_tick = 60*HZ; @@ -2340,7 +2397,7 @@ printk(KERN_DEBUG "%s: %s link beat failed, CSR12 %4.4x, " "CSR5 %8.8x, PHY %3.3x.\n", dev->name, medianame[dev->if_port], csr12, - inl(ioaddr + CSR5), inl(ioaddr + 0xB8)); + (int)inl(ioaddr + CSR5), (int)inl(ioaddr + 0xB8)); next_tick = 3*HZ; if (tp->medialock) { } else if (tp->nwayset && (dev->if_port & 1)) { @@ -2358,8 +2415,8 @@ } if (tp->csr6 != new_csr6) { tp->csr6 = new_csr6; - outl(tp->csr6 | 0x0002, ioaddr + CSR6); /* Restart Tx */ - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + outl(tp->csr6 | RxOn, ioaddr + CSR6); /* Restart Tx */ + outl(tp->csr6 | RxOn | TxOn, ioaddr + CSR6); dev->trans_start = jiffies; if (tulip_debug > 1) printk(KERN_INFO "%s: Changing PNIC configuration to %s " @@ -2369,36 +2426,45 @@ } } } - tp->timer.expires = RUN_AT(next_tick); + tp->timer.expires = jiffies + next_tick; add_timer(&tp->timer); } static void comet_timer(unsigned long data) { - struct device *dev = (struct device *)data; + struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; - long ioaddr = dev->base_addr; int next_tick = 60*HZ; if (tulip_debug > 1) printk(KERN_DEBUG "%s: Comet link status %4.4x partner capability " "%4.4x.\n", - dev->name, inl(ioaddr + 0xB8), inl(ioaddr + 0xC8)); - tp->timer.expires = RUN_AT(next_tick); + dev->name, mdio_read(dev, tp->phys[0], 1), + mdio_read(dev, tp->phys[0], 5)); + check_duplex(dev); + tp->timer.expires = jiffies + next_tick; add_timer(&tp->timer); } -static void tulip_tx_timeout(struct device *dev) +static void tulip_tx_timeout(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; if (media_cap[dev->if_port] & MediaIsMII) { /* Do nothing -- the media monitor should handle this. */ + int mii_bmsr = mdio_read(dev, tp->phys[0], 1); if (tulip_debug > 1) - printk(KERN_WARNING "%s: Transmit timeout using MII device.\n", - dev->name); - } else if (tp->chip_id == DC21040) { + printk(KERN_WARNING "%s: Transmit timeout using MII device," + " status %4.4x.\n", + dev->name, mii_bmsr); + if ( ! (mii_bmsr & 0x0004)) { /* No link beat present */ + dev->trans_start = jiffies; + netif_link_down(dev); + return; + } + } else switch (tp->chip_id) { + case DC21040: if ( !tp->medialock && inl(ioaddr + CSR12) & 0x0002) { dev->if_port = (dev->if_port == 2 ? 0 : 2); printk(KERN_INFO "%s: transmit timed out, switching to " @@ -2407,38 +2473,49 @@ select_media(dev, 0); } dev->trans_start = jiffies; - return; - } else if (tp->chip_id == DC21041) { + return; /* Note: not break! */ + case DC21041: { int csr12 = inl(ioaddr + CSR12); printk(KERN_WARNING "%s: 21041 transmit timed out, status %8.8x, " "CSR12 %8.8x, CSR13 %8.8x, CSR14 %8.8x, resetting...\n", - dev->name, inl(ioaddr + CSR5), csr12, - inl(ioaddr + CSR13), inl(ioaddr + CSR14)); + dev->name, (int)inl(ioaddr + CSR5), csr12, + (int)inl(ioaddr + CSR13), (int)inl(ioaddr + CSR14)); tp->mediasense = 1; if ( ! tp->medialock) { if (dev->if_port == 1 || dev->if_port == 2) - if (csr12 & 0x0004) { - dev->if_port = 2 - dev->if_port; - } else - dev->if_port = 0; + dev->if_port = (csr12 & 0x0004) ? 2 - dev->if_port : 0; else dev->if_port = 1; select_media(dev, 0); } - } else if (tp->chip_id == DC21140 || tp->chip_id == DC21142 - || tp->chip_id == MX98713 || tp->chip_id == COMPEX9881) { - printk(KERN_WARNING "%s: 21140 transmit timed out, status %8.8x, " + break; + } + case DC21142: + if (tp->nwayset) { + printk(KERN_WARNING "%s: Transmit timed out, status %8.8x, " + "SIA %8.8x %8.8x %8.8x %8.8x, restarting NWay .\n", + dev->name, (int)inl(ioaddr + CSR5), + (int)inl(ioaddr + CSR12), (int)inl(ioaddr + CSR13), + (int)inl(ioaddr + CSR14), (int)inl(ioaddr + CSR15)); + nway_start(dev); + break; + } + /* Fall through. */ + case DC21140: case MX98713: case COMPEX9881: + printk(KERN_WARNING "%s: %s transmit timed out, status %8.8x, " "SIA %8.8x %8.8x %8.8x %8.8x, resetting...\n", - dev->name, inl(ioaddr + CSR5), inl(ioaddr + CSR12), - inl(ioaddr + CSR13), inl(ioaddr + CSR14), inl(ioaddr + CSR15)); + dev->name, tulip_tbl[tp->chip_id].chip_name, + (int)inl(ioaddr + CSR5), (int)inl(ioaddr + CSR12), + (int)inl(ioaddr + CSR13), (int)inl(ioaddr + CSR14), + (int)inl(ioaddr + CSR15)); if ( ! tp->medialock && tp->mtable) { do --tp->cur_index; while (tp->cur_index >= 0 && (media_cap[tp->mtable->mleaf[tp->cur_index].media] & MediaIsFD)); - if (--tp->cur_index < 0) { + if (tp->cur_index < 0) { /* We start again, but should instead look for default. */ tp->cur_index = tp->mtable->leafcount - 1; } @@ -2446,14 +2523,20 @@ printk(KERN_WARNING "%s: transmit timed out, switching to %s " "media.\n", dev->name, medianame[dev->if_port]); } - } else { + break; + case PNIC2: + printk(KERN_WARNING "%s: PNIC2 transmit timed out, status %8.8x, " + "CSR6/7 %8.8x / %8.8x CSR12 %8.8x, resetting...\n", + dev->name, (int)inl(ioaddr + CSR5), (int)inl(ioaddr + CSR6), + (int)inl(ioaddr + CSR7), (int)inl(ioaddr + CSR12)); + break; + default: printk(KERN_WARNING "%s: Transmit timed out, status %8.8x, CSR12 " "%8.8x, resetting...\n", - dev->name, inl(ioaddr + CSR5), inl(ioaddr + CSR12)); - dev->if_port = 0; + dev->name, (int)inl(ioaddr + CSR5), (int)inl(ioaddr + CSR12)); } -#if defined(way_too_many_messages) +#if defined(way_too_many_messages) && defined(__i386__) if (tulip_debug > 3) { int i; for (i = 0; i < RX_RING_SIZE; i++) { @@ -2480,11 +2563,13 @@ } #endif - /* Stop and restart the chip's Tx processes . */ - outl(tp->csr6 | 0x0002, ioaddr + CSR6); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + /* Stop and restart the Tx process. + The pwr_event approach of empty/init_rings() may be better... */ + outl(tp->csr6 | RxOn, ioaddr + CSR6); + outl(tp->csr6 | RxOn | TxOn, ioaddr + CSR6); /* Trigger an immediate transmit demand. */ outl(0, ioaddr + CSR1); + outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7); dev->trans_start = jiffies; tp->stats.tx_errors++; @@ -2493,17 +2578,14 @@ /* Initialize the Rx and Tx rings, along with various 'dev' bits. */ -static void tulip_init_ring(struct device *dev) +static void tulip_init_ring(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int i; - tp->tx_full = 0; + tp->rx_dead = tp->tx_full = 0; tp->cur_rx = tp->cur_tx = 0; tp->dirty_rx = tp->dirty_tx = 0; - tp->susp_rx = 0; - tp->ttimer = 0; - tp->nir = 0; for (i = 0; i < RX_RING_SIZE; i++) { tp->rx_ring[i].status = 0x00000000; @@ -2524,7 +2606,7 @@ if (skb == NULL) break; skb->dev = dev; /* Mark as being used by this device. */ - tp->rx_ring[i].status = cpu_to_le32(DescOwned); /* Owned by Tulip chip */ + tp->rx_ring[i].status = cpu_to_le32(DescOwned); tp->rx_ring[i].buffer1 = virt_to_le32desc(skb->tail); } tp->dirty_rx = (unsigned int)(i - RX_RING_SIZE); @@ -2540,18 +2622,18 @@ } static int -tulip_start_xmit(struct sk_buff *skb, struct device *dev) +tulip_start_xmit(struct sk_buff *skb, struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; - int entry; + int entry, q_used_cnt; u32 flag; - /* Block a timer-based transmit from overlapping. This could better be - done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */ - if (test_and_set_bit(0, (void*)&dev->tbusy) != 0) { - if (jiffies - dev->trans_start < TX_TIMEOUT) - return 1; - tulip_tx_timeout(dev); + /* Block a timer-based transmit from overlapping. This happens when + packets are presumed lost, and we use this check the Tx status. */ + if (netif_pause_tx_queue(dev) != 0) { + /* This watchdog code is redundant with the media monitor timer. */ + if (jiffies - dev->trans_start > TX_TIMEOUT) + tulip_tx_timeout(dev); return 1; } @@ -2560,15 +2642,16 @@ /* Calculate the next Tx descriptor entry. */ entry = tp->cur_tx % TX_RING_SIZE; + q_used_cnt = tp->cur_tx - tp->dirty_tx; tp->tx_skbuff[entry] = skb; tp->tx_ring[entry].buffer1 = virt_to_le32desc(skb->data); - if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE/2) {/* Typical path */ + if (q_used_cnt < TX_QUEUE_LEN/2) {/* Typical path */ flag = 0x60000000; /* No interrupt */ - } else if (tp->cur_tx - tp->dirty_tx == TX_RING_SIZE/2) { + } else if (q_used_cnt == TX_QUEUE_LEN/2) { flag = 0xe0000000; /* Tx-done intr. */ - } else if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE - 2) { + } else if (q_used_cnt < TX_QUEUE_LEN) { flag = 0x60000000; /* No Tx-done intr. */ } else { /* Leave room for set_rx_mode() to fill entries. */ tp->tx_full = 1; @@ -2581,7 +2664,7 @@ tp->tx_ring[entry].status = cpu_to_le32(DescOwned); tp->cur_tx++; if ( ! tp->tx_full) - clear_bit(0, (void*)&dev->tbusy); + netif_unpause_tx_queue(dev); dev->trans_start = jiffies; /* Trigger an immediate transmit demand. */ @@ -2594,55 +2677,27 @@ after the Tx thread. */ static void tulip_interrupt(int irq, void *dev_instance, struct pt_regs *regs) { - struct device *dev = (struct device *)dev_instance; + struct net_device *dev = (struct net_device *)dev_instance; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; - int csr5; - int entry; - int missed; - int rx = 0; - int tx = 0; - int oi = 0; - int maxrx = RX_RING_SIZE; - int maxtx = TX_RING_SIZE; - int maxoi = TX_RING_SIZE; - -#if defined(__i386__) && defined(SMP_CHECK) - if (test_and_set_bit(0, (void*)&dev->interrupt)) { - printk(KERN_ERR "%s: Duplicate entry of the interrupt handler by " - "processor %d.\n", - dev->name, hard_smp_processor_id()); - dev->interrupt = 0; - return; - } -#else - if (dev->interrupt) { - printk(KERN_ERR "%s: Re-entering the interrupt handler.\n", dev->name); - return; - } - dev->interrupt = 1; -#endif - - tp->nir++; + int csr5, work_budget = max_interrupt_work; do { csr5 = inl(ioaddr + CSR5); /* Acknowledge all of the current interrupt sources ASAP. */ outl(csr5 & 0x0001ffff, ioaddr + CSR5); - if (tulip_debug > 4) - printk(KERN_DEBUG "%s: interrupt csr5=%#8.8x new csr5=%#8.8x.\n", - dev->name, csr5, inl(dev->base_addr + CSR5)); - if ((csr5 & (NormalIntr|AbnormalIntr)) == 0) break; - if (csr5 & (RxIntr | RxNoBuf)) { - rx += tulip_rx(dev); - tulip_refill_rx(dev); - } + if (tulip_debug > 3) + printk(KERN_DEBUG "%s: interrupt csr5=%#8.8x new csr5=%#8.8x.\n", + dev->name, csr5, (int)inl(dev->base_addr + CSR5)); + + if (csr5 & (RxIntr | RxNoBuf)) + work_budget -= tulip_rx(dev); - if (csr5 & (TxNoBuf | TxDied | TxIntr | TimerInt)) { + if (csr5 & (TxNoBuf | TxDied | TxIntr)) { unsigned int dirty_tx; for (dirty_tx = tp->dirty_tx; tp->cur_tx - dirty_tx > 0; @@ -2655,7 +2710,7 @@ /* Check for Rx filter setup frames. */ if (tp->tx_skbuff[entry] == NULL) continue; - + if (status & 0x8000) { /* There was an major error, log it. */ #ifndef final_version @@ -2687,7 +2742,6 @@ /* Free the original skb. */ dev_free_skb(tp->tx_skbuff[entry]); tp->tx_skbuff[entry] = 0; - tx++; } #ifndef final_version @@ -2698,22 +2752,22 @@ } #endif - if (tp->tx_full && dev->tbusy - && tp->cur_tx - dirty_tx < TX_RING_SIZE - 2) { + if (tp->tx_full && tp->cur_tx - dirty_tx < TX_QUEUE_LEN - 4) { /* The ring is no longer full, clear tbusy. */ tp->tx_full = 0; - dev->tbusy = 0; - netif_wake_queue(dev); + netif_resume_tx_queue(dev); } tp->dirty_tx = dirty_tx; - if (csr5 & TxDied) { - if (tulip_debug > 2) - printk(KERN_WARNING "%s: The transmitter stopped." - " CSR5 is %x, CSR6 %x, new CSR6 %x.\n", - dev->name, csr5, inl(ioaddr + CSR6), tp->csr6); - outl(tp->csr6 | 0x0002, ioaddr + CSR6); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + } + + if (tp->rx_dead) { + tulip_rx(dev); + if (tp->cur_rx - tp->dirty_rx < RX_RING_SIZE - 3) { + printk(KERN_ERR "%s: Restarted Rx at %d / %d.\n", + dev->name, tp->cur_rx, tp->dirty_rx); + outl(0, ioaddr + CSR2); /* Rx poll demand */ + tp->rx_dead = 0; } } @@ -2722,121 +2776,89 @@ if (csr5 == 0xffffffff) break; if (csr5 & TxJabber) tp->stats.tx_errors++; + if (csr5 & PCIBusError) { + printk(KERN_ERR "%s: PCI Fatal Bus Error, %8.8x.\n", + dev->name, csr5); + } if (csr5 & TxFIFOUnderflow) { if ((tp->csr6 & 0xC000) != 0xC000) tp->csr6 += 0x4000; /* Bump up the Tx threshold */ else tp->csr6 |= 0x00200000; /* Store-n-forward. */ + if (tulip_debug > 1) + printk(KERN_WARNING "%s: Tx threshold increased, " + "new CSR6 %x.\n", dev->name, tp->csr6); + } + if (csr5 & TxDied) { + /* This is normal when changing Tx modes. */ + if (tulip_debug > 2) + printk(KERN_WARNING "%s: The transmitter stopped." + " CSR5 is %x, CSR6 %x, new CSR6 %x.\n", + dev->name, csr5, (int)inl(ioaddr + CSR6), tp->csr6); + } + if (csr5 & (TxDied | TxFIFOUnderflow | PCIBusError)) { /* Restart the transmit process. */ - outl(tp->csr6 | 0x0002, ioaddr + CSR6); - outl(tp->csr6 | 0x2002, ioaddr + CSR6); - outl(0, ioaddr + CSR1); + outl(tp->csr6 | RxOn, ioaddr + CSR6); + outl(tp->csr6 | RxOn | TxOn, ioaddr + CSR6); } - if (csr5 & RxDied) { /* Missed a Rx frame. */ - tp->stats.rx_errors++; + if (csr5 & (RxStopped | RxNoBuf)) { + /* Missed a Rx frame or mode change. */ tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; - outl(tp->csr6 | 0x2002, ioaddr + CSR6); + if (tp->flags & COMET_MAC_ADDR) { + outl(tp->mc_filter[0], ioaddr + 0xAC); + outl(tp->mc_filter[1], ioaddr + 0xB0); + } + tulip_rx(dev); + if (csr5 & RxNoBuf) + tp->rx_dead = 1; + outl(tp->csr6 | RxOn | TxOn, ioaddr + CSR6); + } + if (csr5 & TimerInt) { + if (tulip_debug > 2) + printk(KERN_ERR "%s: Re-enabling interrupts, %8.8x.\n", + dev->name, csr5); + outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7); } if (csr5 & (TPLnkPass | TPLnkFail | 0x08000000)) { if (tp->link_change) (tp->link_change)(dev, csr5); } - if (csr5 & SytemError) { - printk(KERN_ERR "%s: (%lu) System Error occured\n", dev->name, tp->nir); - } /* Clear all error sources, included undocumented ones! */ outl(0x0800f7ba, ioaddr + CSR5); - oi++; - } - if (csr5 & TimerInt) { -#if 0 - if (tulip_debug > 2) - printk(KERN_ERR "%s: Re-enabling interrupts, %8.8x.\n", - dev->name, csr5); - outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7); -#endif - tp->ttimer = 0; - oi++; } - if (tx > maxtx || rx > maxrx || oi > maxoi) { - if (tulip_debug > 1) + if (--work_budget < 0) { + if (tulip_debug > 0) printk(KERN_WARNING "%s: Too much work during an interrupt, " - "csr5=0x%8.8x. (%lu) (%d,%d,%d)\n", dev->name, csr5, tp->nir, tx, rx, oi); + "csr5=0x%8.8x.\n", dev->name, csr5); /* Acknowledge all interrupt sources. */ -#if 0 - /* Clear all interrupting sources, set timer to re-enable. */ - outl(((~csr5) & 0x0001ebef) | NormalIntr | AbnormalIntr | TimerInt, - ioaddr + CSR7); - outl(12, ioaddr + CSR11); - tp->ttimer = 1; -#endif + outl(0x8001ffff, ioaddr + CSR5); + if (tp->flags & HAS_INTR_MITIGATION) { + /* Josip Loncaric at ICASE did extensive experimentation + to develop a good interrupt mitigation setting.*/ + outl(0x8b240000, ioaddr + CSR11); + } else { + /* Mask all interrupting sources, set timer to re-enable. */ + outl(((~csr5) & 0x0001ebef) | AbnormalIntr | TimerInt, + ioaddr + CSR7); + outl(0x0012, ioaddr + CSR11); + } break; } } while (1); - tulip_refill_rx(dev); - - /* check if we card is in suspend mode */ - entry = tp->dirty_rx % RX_RING_SIZE; - if (tp->rx_skbuff[entry] == NULL) { - if (tulip_debug > 1) - printk(KERN_WARNING "%s: in rx suspend mode: (%lu) (tp->cur_rx = %u, ttimer = %d, rx = %d) go/stay in suspend mode\n", dev->name, tp->nir, tp->cur_rx, tp->ttimer, rx); - if (tp->ttimer == 0 || (inl(ioaddr + CSR11) & 0xffff) == 0) { - if (tulip_debug > 1) - printk(KERN_WARNING "%s: in rx suspend mode: (%lu) set timer\n", dev->name, tp->nir); - outl(tulip_tbl[tp->chip_id].valid_intrs | TimerInt, - ioaddr + CSR7); - outl(TimerInt, ioaddr + CSR5); - outl(12, ioaddr + CSR11); - tp->ttimer = 1; - } - } - - if ((missed = inl(ioaddr + CSR8) & 0x1ffff)) { - tp->stats.rx_dropped += missed & 0x10000 ? 0x10000 : missed; - } - if (tulip_debug > 4) printk(KERN_DEBUG "%s: exiting interrupt, csr5=%#4.4x.\n", - dev->name, inl(ioaddr + CSR5)); + dev->name, (int)inl(ioaddr + CSR5)); -#if defined(__i386__) - clear_bit(0, (void*)&dev->interrupt); -#else - dev->interrupt = 0; -#endif return; } -static int tulip_refill_rx(struct device *dev) -{ - struct tulip_private *tp = (struct tulip_private *)dev->priv; - int entry; - int refilled = 0; - - /* Refill the Rx ring buffers. */ - for (; tp->cur_rx - tp->dirty_rx > 0; tp->dirty_rx++) { - entry = tp->dirty_rx % RX_RING_SIZE; - if (tp->rx_skbuff[entry] == NULL) { - struct sk_buff *skb; - skb = tp->rx_skbuff[entry] = dev_alloc_skb(PKT_BUF_SZ); - if (skb == NULL) - break; - skb->dev = dev; /* Mark as being used by this device. */ - tp->rx_ring[entry].buffer1 = virt_to_le32desc(skb->tail); - refilled++; - } - tp->rx_ring[entry].status = cpu_to_le32(DescOwned); - } - return refilled; -} - -static int tulip_rx(struct device *dev) +static int tulip_rx(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int entry = tp->cur_rx % RX_RING_SIZE; int rx_work_limit = tp->dirty_rx + RX_RING_SIZE - tp->cur_rx; - int received = 0; + int work_done = 0; if (tulip_debug > 4) printk(KERN_DEBUG " In tulip_rx(), entry %d %8.8x.\n", entry, @@ -2897,17 +2919,10 @@ memcpy(skb_put(skb, pkt_len), tp->rx_skbuff[entry]->tail, pkt_len); #endif - } else { /* Pass up the skb already on the Rx ring. */ - char *temp = skb_put(skb = tp->rx_skbuff[entry], pkt_len); + work_done++; + } else { /* Pass up the skb already on the Rx ring. */ + skb_put(skb = tp->rx_skbuff[entry], pkt_len); tp->rx_skbuff[entry] = NULL; -#ifndef final_version - if (le32desc_to_virt(tp->rx_ring[entry].buffer1) != temp) - printk(KERN_ERR "%s: Internal fault: The skbuff addresses " - "do not match in tulip_rx: %p vs. %p / %p.\n", - dev->name, - le32desc_to_virt(tp->rx_ring[entry].buffer1), - skb->head, temp); -#endif } skb->protocol = eth_type_trans(skb, dev); netif_rx(skb); @@ -2917,43 +2932,32 @@ tp->stats.rx_bytes += pkt_len; #endif } - received++; entry = (++tp->cur_rx) % RX_RING_SIZE; } - return received; + /* Refill the Rx ring buffers. */ + for (; tp->cur_rx - tp->dirty_rx > 0; tp->dirty_rx++) { + entry = tp->dirty_rx % RX_RING_SIZE; + if (tp->rx_skbuff[entry] == NULL) { + struct sk_buff *skb; + skb = tp->rx_skbuff[entry] = dev_alloc_skb(PKT_BUF_SZ); + if (skb == NULL) + break; + skb->dev = dev; /* Mark as being used by this device. */ + tp->rx_ring[entry].buffer1 = virt_to_le32desc(skb->tail); + work_done++; + } + tp->rx_ring[entry].status = cpu_to_le32(DescOwned); + } + + return work_done; } -static int tulip_close(struct device *dev) +static void empty_rings(struct net_device *dev) { - long ioaddr = dev->base_addr; struct tulip_private *tp = (struct tulip_private *)dev->priv; int i; - dev->start = 0; - dev->tbusy = 1; - - if (tulip_debug > 1) - printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n", - dev->name, inl(ioaddr + CSR5)); - - /* Disable interrupts by clearing the interrupt mask. */ - outl(0x00000000, ioaddr + CSR7); - /* Stop the Tx and Rx processes. */ - outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6); - /* 21040 -- Leave the card in 10baseT state. */ - if (tp->chip_id == DC21040) - outl(0x00000004, ioaddr + CSR13); - - if (inl(ioaddr + CSR6) != 0xffffffff) - tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; - - del_timer(&tp->timer); - - free_irq(dev->irq, dev); - - dev->if_port = tp->saved_if_port; - /* Free all the skbuffs in the Rx queue. */ for (i = 0; i < RX_RING_SIZE; i++) { struct sk_buff *skb = tp->rx_skbuff[i]; @@ -2973,88 +2977,149 @@ dev_free_skb(tp->tx_skbuff[i]); tp->tx_skbuff[i] = 0; } +} + +static int tulip_close(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct tulip_private *tp = (struct tulip_private *)dev->priv; + netif_stop_tx_queue(dev); + + if (tulip_debug > 1) + printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n", + dev->name, (int)inl(ioaddr + CSR5)); + + /* Disable interrupts by clearing the interrupt mask. */ + outl(0x00000000, ioaddr + CSR7); + /* Stop the Tx and Rx processes. */ + outl(inl(ioaddr + CSR6) & ~TxOn & ~RxOn, ioaddr + CSR6); + /* 21040 -- Leave the card in 10baseT state. */ + if (tp->chip_id == DC21040) + outl(0x00000004, ioaddr + CSR13); + + if (inl(ioaddr + CSR6) != 0xffffffff) + tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; + + del_timer(&tp->timer); + + free_irq(dev->irq, dev); + + dev->if_port = tp->saved_if_port; + + empty_rings(dev); /* Leave the driver in snooze, not sleep, mode. */ if (tp->flags & HAS_PWRDWN) - pcibios_write_config_dword(tp->pci_bus, tp->pci_devfn, 0x40, - 0x40000000); + pci_write_config_dword(tp->pci_dev, 0x40, 0x40000000); MOD_DEC_USE_COUNT; return 0; } -static struct net_device_stats *tulip_get_stats(struct device *dev) +static struct net_device_stats *tulip_get_stats(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; + int csr8 = inl(ioaddr + CSR8); - if (dev->start) - tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; + if (netif_running(dev) && csr8 != 0xffffffff) + tp->stats.rx_missed_errors += (u16)csr8; return &tp->stats; } #ifdef HAVE_PRIVATE_IOCTL /* Provide ioctl() calls to examine the MII xcvr state. */ -static int private_ioctl(struct device *dev, struct ifreq *rq, int cmd) +static int private_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; u16 *data = (u16 *)&rq->ifr_data; - int phy = tp->phys[0] & 0x1f; - long flags; + unsigned int phy = tp->phys[0]; + unsigned int regnum = data[1]; switch(cmd) { - case SIOCDEVPRIVATE: /* Get the address of the PHY in use. */ + case SIOCGMIIPHY: /* Get the address of the PHY in use. */ if (tp->mii_cnt) data[0] = phy; - else if (tp->flags & HAS_NWAY143) + else if (tp->flags & HAS_NWAY) data[0] = 32; - else if ((tp->chip_id == COMET) || (tp->chip_id == COMET5)) + else if (tp->chip_id == COMET) data[0] = 1; else return -ENODEV; - case SIOCDEVPRIVATE+1: /* Read the specified MII register. */ - if (data[0] == 32 && (tp->flags & HAS_NWAY143)) { + case SIOCGMIIREG: /* Read the specified MII register. */ + if (data[0] == 32 && (tp->flags & HAS_NWAY)) { int csr12 = inl(ioaddr + CSR12); int csr14 = inl(ioaddr + CSR14); - switch (data[1]) { - case 0: { - data[3] = (csr14<<5) & 0x1000; - break; } + switch (regnum) { + case 0: + if (((csr14<<5) & 0x1000) || + (dev->if_port == 5 && tp->nwayset)) + data[3] = 0x1000; + else + data[3] = (media_cap[dev->if_port]&MediaIs100 ? 0x2000 : 0) + | (media_cap[dev->if_port]&MediaIsFD ? 0x0100 : 0); + break; case 1: - data[3] = 0x7848 + ((csr12&0x7000) == 0x5000 ? 0x20 : 0) - + (csr12&0x06 ? 0x04 : 0); + data[3] = 0x1848 + ((csr12&0x7000) == 0x5000 ? 0x20 : 0) + + ((csr12&0x06) == 6 ? 0 : 4); + if (tp->chip_id != DC21041) + data[3] |= 0x6048; break; case 4: { - data[3] = ((csr14>>9)&0x07C0) + - ((inl(ioaddr + CSR6)>>3)&0x0040) + ((csr14>>1)&0x20) + 1; + /* Advertised value, bogus 10baseTx-FD value from CSR6. */ + data[3] = ((inl(ioaddr + CSR6)>>3)&0x0040)+((csr14>>1)&0x20)+1; + if (tp->chip_id != DC21041) + data[3] |= ((csr14>>9)&0x03C0); break; } - case 5: data[3] = csr12 >> 16; break; + case 5: data[3] = tp->lpar; break; default: data[3] = 0; break; } } else { - save_flags(flags); - cli(); - data[3] = mdio_read(dev, data[0] & 0x1f, data[1] & 0x1f); - restore_flags(flags); + data[3] = mdio_read(dev, data[0] & 0x1f, regnum); } return 0; - case SIOCDEVPRIVATE+2: /* Write the specified MII register */ + case SIOCSMIIREG: /* Write the specified MII register */ if (!capable(CAP_NET_ADMIN)) return -EPERM; - if (data[0] == 32 && (tp->flags & HAS_NWAY143)) { - if (data[1] == 5) - tp->to_advertise = data[2]; + if (regnum & ~0x1f) + return -EINVAL; + if (data[0] == phy) { + u16 value = data[2]; + switch (regnum) { + case 0: /* Check for autonegotiation on or reset. */ + tp->full_duplex_lock = (value & 0x9000) ? 0 : 1; + if (tp->full_duplex_lock) + tp->full_duplex = (value & 0x0100) ? 1 : 0; + break; + case 4: tp->mii_advertise = data[2]; break; + } + } + if (data[0] == 32 && (tp->flags & HAS_NWAY)) { + u16 value = data[2]; + if (regnum == 0) { + if ((value & 0x1200) == 0x1200) + nway_start(dev); + } else if (regnum == 4) + tp->sym_advertise = value; } else { - save_flags(flags); - cli(); - mdio_write(dev, data[0] & 0x1f, data[1] & 0x1f, data[2]); - restore_flags(flags); + mdio_write(dev, data[0] & 0x1f, regnum, data[2]); } return 0; + case SIOCSPARAMS: + /* This tuning code may not exist in future drivers. */ + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + if (tp->flags & HAS_INTR_MITIGATION) { + u32 *d = (u32 *)&rq->ifr_data; + outl(d[0], ioaddr + CSR11); + printk(KERN_NOTICE "%s: Set interrupt mitigate paramters %8.8x.\n", + dev->name, d[0]); + return 0; + } default: return -EOPNOTSUPP; } @@ -3091,19 +3156,19 @@ static unsigned const ethernet_polynomial = 0x04c11db7U; static inline u32 ether_crc(int length, unsigned char *data) { - int crc = -1; + int crc = -1; - while(--length >= 0) { + while(--length >= 0) { unsigned char current_octet = *data++; int bit; for (bit = 0; bit < 8; bit++, current_octet >>= 1) crc = (crc << 1) ^ ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0); - } - return crc; + } + return crc; } -static void set_rx_mode(struct device *dev) +static void set_rx_mode(struct net_device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; @@ -3111,39 +3176,56 @@ tp->csr6 &= ~0x00D5; if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ - tp->csr6 |= 0x00C0; - csr6 |= 0x00C0; + tp->csr6 |= AcceptAllMulticast | AcceptAllPhys; + csr6 |= AcceptAllMulticast | AcceptAllPhys; /* Unconditionally log net taps. */ printk(KERN_INFO "%s: Promiscuous mode enabled.\n", dev->name); } else if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) { /* Too many to filter well -- accept all multicasts. */ - tp->csr6 |= 0x0080; - csr6 |= 0x0080; + tp->csr6 |= AcceptAllMulticast; + csr6 |= AcceptAllMulticast; } else if (tp->flags & MC_HASH_ONLY) { /* Some work-alikes have only a 64-entry hash filter table. */ /* Should verify correctness on big-endian/__powerpc__ */ struct dev_mc_list *mclist; int i; - u32 mc_filter[2]; /* Multicast hash filter */ if (dev->mc_count > 64) { /* Arbitrary non-effective limit. */ - tp->csr6 |= 0x0080; - csr6 |= 0x0080; + tp->csr6 |= AcceptAllMulticast; + csr6 |= AcceptAllMulticast; } else { - mc_filter[1] = mc_filter[0] = 0; + u32 mc_filter[2] = {0, 0}; /* Multicast hash filter */ + int filterbit; for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; - i++, mclist = mclist->next) - set_bit(ether_crc(ETH_ALEN, mclist->dmi_addr)>>26, mc_filter); - if (tp->chip_id == AX88140) { + i++, mclist = mclist->next) { + if (tp->flags & COMET_MAC_ADDR) + filterbit = ether_crc_le(ETH_ALEN, mclist->dmi_addr); + else + filterbit = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26; + filterbit &= 0x3f; + set_bit(filterbit, mc_filter); + if (debug > 2) { + printk(KERN_INFO "%s: Added filter for %2.2x:%2.2x:%2.2x:" + "%2.2x:%2.2x:%2.2x %8.8x bit %d.\n", dev->name, + mclist->dmi_addr[0], mclist->dmi_addr[1], + mclist->dmi_addr[2], mclist->dmi_addr[3], + mclist->dmi_addr[4], mclist->dmi_addr[5], + ether_crc(ETH_ALEN, mclist->dmi_addr), filterbit); + } + } + if (mc_filter[0] == tp->mc_filter[0] && + mc_filter[1] == tp->mc_filter[1]) + ; /* No change. */ + else if (tp->flags & IS_ASIX) { outl(2, ioaddr + CSR13); outl(mc_filter[0], ioaddr + CSR14); outl(3, ioaddr + CSR13); outl(mc_filter[1], ioaddr + CSR14); - - /* Has a simple hash filter. */ - } else if ((tp->chip_id == COMET) || (tp->chip_id == COMET5)) { + } else if (tp->flags & COMET_MAC_ADDR) { outl(mc_filter[0], ioaddr + 0xAC); outl(mc_filter[1], ioaddr + 0xB0); } + tp->mc_filter[0] = mc_filter[0]; + tp->mc_filter[1] = mc_filter[1]; } } else { u16 *eaddrs, *setup_frm = tp->setup_frame; @@ -3157,7 +3239,7 @@ u16 hash_table[32]; tx_flags = 0x08400000 | 192; /* Use hash filter. */ memset(hash_table, 0, sizeof(hash_table)); - set_bit(255, hash_table); /* Broadcast entry */ + set_bit(255, hash_table); /* Broadcast entry */ /* This should work on big-endian machines as well. */ for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; i++, mclist = mclist->next) @@ -3199,7 +3281,7 @@ /* Avoid a chip errata by prefixing a dummy entry. */ tp->tx_skbuff[entry] = 0; tp->tx_ring[entry].length = - (entry == TX_RING_SIZE-1) ? cpu_to_le32(DESC_RING_WRAP) : 0; + (entry == TX_RING_SIZE-1) ? cpu_to_le32(DESC_RING_WRAP):0; tp->tx_ring[entry].buffer1 = 0; tp->tx_ring[entry].status = cpu_to_le32(DescOwned); entry = tp->cur_tx++ % TX_RING_SIZE; @@ -3213,7 +3295,7 @@ tp->tx_ring[entry].buffer1 = virt_to_le32desc(tp->setup_frame); tp->tx_ring[entry].status = cpu_to_le32(DescOwned); if (tp->cur_tx - tp->dirty_tx >= TX_RING_SIZE - 2) { - set_bit(0, (void*)&dev->tbusy); + netif_stop_tx_queue(dev); tp->tx_full = 1; } restore_flags(flags); @@ -3221,27 +3303,136 @@ outl(0, ioaddr + CSR1); } } - outl(csr6 | 0x0000, ioaddr + CSR6); + outl(csr6, ioaddr + CSR6); } + +static int tulip_pwr_event(void *dev_instance, int event) +{ + struct net_device *dev = dev_instance; + struct tulip_private *tp = (struct tulip_private *)dev->priv; + long ioaddr = dev->base_addr; + if (debug > 1) + printk("%s: Handling power event %d.\n", dev->name, event); + switch(event) { + case DRV_ATTACH: + MOD_INC_USE_COUNT; + break; + case DRV_SUSPEND: { + int csr6 = inl(ioaddr + CSR6); + /* Disable interrupts, stop the chip, gather stats. */ + if (csr6 != 0xffffffff) { + int csr8 = inl(ioaddr + CSR8); + outl(0x00000000, ioaddr + CSR7); + outl(csr6 & ~TxOn & ~RxOn, ioaddr + CSR6); + tp->stats.rx_missed_errors += (unsigned short)csr8; + } + empty_rings(dev); + /* Put the 21143 into sleep mode. */ + if (tp->flags & HAS_PWRDWN) + pci_write_config_dword(tp->pci_dev, 0x40,0x80000000); + break; + } + case DRV_RESUME: + if (tp->flags & HAS_PWRDWN) + pci_write_config_dword(tp->pci_dev, 0x40, 0x0000); + outl(tp->csr0, ioaddr + CSR0); + tulip_init_ring(dev); + outl(virt_to_bus(tp->rx_ring), ioaddr + CSR3); + outl(virt_to_bus(tp->tx_ring), ioaddr + CSR4); + if (tp->mii_cnt) { + dev->if_port = 11; + if (tp->mtable && tp->mtable->has_mii) + select_media(dev, 1); + tp->csr6 = 0x820E0000; + dev->if_port = 11; + outl(0x0000, ioaddr + CSR13); + outl(0x0000, ioaddr + CSR14); + } else if (! tp->medialock) + nway_start(dev); + else + select_media(dev, 1); + outl(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7); + outl(tp->csr6 | TxOn | RxOn, ioaddr + CSR6); + outl(0, ioaddr + CSR2); /* Rx poll demand */ + set_rx_mode(dev); + break; + case DRV_DETACH: { + struct net_device **devp, **next; + if (dev->flags & IFF_UP) { + printk(KERN_ERR "%s: Tulip CardBus interface was detached while " + "still active.\n", dev->name); + dev_close(dev); + dev->flags &= ~(IFF_UP|IFF_RUNNING); + } + if (debug) + printk(KERN_DEBUG "%s: Unregistering device.\n", dev->name); + unregister_netdev(dev); + release_region(dev->base_addr, pci_id_tbl[tp->chip_id].io_size); +#ifndef USE_IO_OPS + iounmap((char *)dev->base_addr); +#endif + for (devp = &root_tulip_dev; *devp; devp = next) { + next = &((struct tulip_private *)(*devp)->priv)->next_module; + if (*devp == dev) { + *devp = *next; + break; + } + } + if (tp->priv_addr) + kfree(tp->priv_addr); + kfree(dev); + MOD_DEC_USE_COUNT; + break; + } + default: + break; + } + + return 0; +} + #ifdef CARDBUS #include static dev_node_t *tulip_attach(dev_locator_t *loc) { - struct device *dev; - u16 dev_id; - u32 io; + struct net_device *dev; + long ioaddr; + struct pci_dev *pdev; u8 bus, devfn, irq; + u32 dev_id; + u32 pciaddr; + int i, chip_id = 4; /* DC21143 */ if (loc->bus != LOC_PCI) return NULL; bus = loc->b.pci.bus; devfn = loc->b.pci.devfn; printk(KERN_INFO "tulip_attach(bus %d, function %d)\n", bus, devfn); - pcibios_read_config_dword(bus, devfn, PCI_BASE_ADDRESS_0, &io); - pcibios_read_config_word(bus, devfn, PCI_DEVICE_ID, &dev_id); - pcibios_read_config_byte(bus, devfn, PCI_INTERRUPT_LINE, &irq); - dev = tulip_probe1(bus, devfn, NULL, io & ~3, irq, DC21142, 0); + pdev = pci_find_slot(bus, devfn); +#ifdef USE_IO_OPS + pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &pciaddr); + ioaddr = pciaddr & PCI_BASE_ADDRESS_IO_MASK; +#else + pci_read_config_dword(pdev, PCI_BASE_ADDRESS_1, &pciaddr); + ioaddr = (long)ioremap(pciaddr & PCI_BASE_ADDRESS_MEM_MASK, + pci_id_tbl[DC21142].io_size); +#endif + pci_read_config_dword(pdev, 0, &dev_id); + pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &irq); + if (ioaddr == 0 || irq == 0) { + printk(KERN_ERR "The Tulip CardBus Ethernet interface at %d/%d was " + "not assigned an %s.\n" + KERN_ERR " It will not be activated.\n", + bus, devfn, ioaddr == 0 ? "address" : "IRQ"); + return NULL; + } + for (i = 0; pci_id_tbl[i].id.pci; i++) { + if (pci_id_tbl[i].id.pci == (dev_id & pci_id_tbl[i].id.pci_mask)) { + chip_id = i; break; + } + } + dev = tulip_probe1(pdev, NULL, ioaddr, irq, chip_id, 0); if (dev) { dev_node_t *node = kmalloc(sizeof(dev_node_t), GFP_KERNEL); strcpy(node->dev_name, dev->name); @@ -3255,54 +3446,48 @@ static void tulip_suspend(dev_node_t *node) { - struct device **devp, **next; + struct net_device **devp, **next; printk(KERN_INFO "tulip_suspend(%s)\n", node->dev_name); for (devp = &root_tulip_dev; *devp; devp = next) { next = &((struct tulip_private *)(*devp)->priv)->next_module; - if (strcmp((*devp)->name, node->dev_name) == 0) break; - } - if (*devp) { - long ioaddr = (*devp)->base_addr; - struct tulip_private *tp = (struct tulip_private *)(*devp)->priv; - int csr6 = inl(ioaddr + CSR6); - /* Disable interrupts, stop the chip, gather stats. */ - if (csr6 != 0xffffffff) { - outl(0x00000000, ioaddr + CSR7); - outl(csr6 & ~0x2002, ioaddr + CSR6); - tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; + if (strcmp((*devp)->name, node->dev_name) == 0) { + tulip_pwr_event(*devp, DRV_SUSPEND); + break; } - tulip_close(*devp); - /* Put the 21143 into sleep mode. */ - pcibios_write_config_dword(tp->pci_bus,tp->pci_devfn, 0x40,0x80000000); } } static void tulip_resume(dev_node_t *node) { - struct device **devp, **next; + struct net_device **devp, **next; printk(KERN_INFO "tulip_resume(%s)\n", node->dev_name); for (devp = &root_tulip_dev; *devp; devp = next) { next = &((struct tulip_private *)(*devp)->priv)->next_module; - if (strcmp((*devp)->name, node->dev_name) == 0) break; - } - if (*devp) { - struct tulip_private *tp = (struct tulip_private *)(*devp)->priv; - pcibios_write_config_dword(tp->pci_bus, tp->pci_devfn, 0x40, 0x0000); - tulip_open(*devp); + if (strcmp((*devp)->name, node->dev_name) == 0) { + tulip_pwr_event(*devp, DRV_RESUME); + break; + } } } static void tulip_detach(dev_node_t *node) { - struct device **devp, **next; + struct net_device **devp, **next; printk(KERN_INFO "tulip_detach(%s)\n", node->dev_name); for (devp = &root_tulip_dev; *devp; devp = next) { next = &((struct tulip_private *)(*devp)->priv)->next_module; if (strcmp((*devp)->name, node->dev_name) == 0) break; } if (*devp) { + struct tulip_private *tp = (struct tulip_private *)(*devp)->priv; unregister_netdev(*devp); + release_region((*devp)->base_addr, pci_id_tbl[DC21142].io_size); +#ifndef USE_IO_OPS + iounmap((char *)(*devp)->base_addr); +#endif kfree(*devp); + if (tp->priv_addr) + kfree(tp->priv_addr); *devp = *next; kfree(node); MOD_DEC_USE_COUNT; @@ -3319,42 +3504,58 @@ #ifdef MODULE int init_module(void) { + if (debug) /* Emit version even if no cards detected. */ + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); #ifdef CARDBUS - reverse_probe = 0; /* Not used. */ register_driver(&tulip_ops); return 0; #else - return tulip_probe(NULL); + return pci_drv_register(&tulip_drv_id, NULL); #endif + reverse_probe = 0; /* Not used. */ } void cleanup_module(void) { - struct device *next_dev; + struct net_device *next_dev; #ifdef CARDBUS unregister_driver(&tulip_ops); +#else + pci_drv_unregister(&tulip_drv_id); #endif /* No need to check MOD_IN_USE, as sys_delete_module() checks. */ while (root_tulip_dev) { - struct tulip_private *tp = (struct tulip_private *)root_tulip_dev->priv; - next_dev = tp->next_module; + struct tulip_private *tp = (struct tulip_private*)root_tulip_dev->priv; unregister_netdev(root_tulip_dev); release_region(root_tulip_dev->base_addr, - tulip_tbl[tp->chip_id].io_size); + pci_id_tbl[tp->chip_id].io_size); +#ifndef USE_IO_OPS + iounmap((char *)root_tulip_dev->base_addr); +#endif + next_dev = tp->next_module; + if (tp->priv_addr) + kfree(tp->priv_addr); kfree(root_tulip_dev); root_tulip_dev = next_dev; } } - +#else +int tulip_probe(struct net_device *dev) +{ + if (pci_drv_register(&tulip_drv_id, dev) < 0) + return -ENODEV; + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); + return 0; + reverse_probe = 0; /* Not used. */ +} #endif /* MODULE */ /* * Local variables: - * SMP-compile-command: "gcc -D__SMP__ -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c tulip.c `[ -f /usr/include/linux/modversions.h ] && echo -DMODVERSIONS`" - * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c tulip.c `[ -f /usr/include/linux/modversions.h ] && echo -DMODVERSIONS`" - * cardbus-compile-command: "gcc -DCARDBUS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c tulip.c -o tulip_cb.o -I/usr/src/pcmcia-cs-3.0.9/include/" + * compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O6 -c tulip.c" + * cardbus-compile-command: "gcc -DCARDBUS -DMODULE -Wall -Wstrict-prototypes -O6 -c tulip.c -o tulip_cb.o -I/usr/src/pcmcia/include/" * c-indent-level: 4 * c-basic-offset: 4 * tab-width: 4 diff -Nur kernel-source-2.2.19.orig/drivers/net/winbond-840.c kernel-source-2.2.19/drivers/net/winbond-840.c --- kernel-source-2.2.19.orig/drivers/net/winbond-840.c Thu Jan 1 01:00:00 1970 +++ kernel-source-2.2.19/drivers/net/winbond-840.c Thu Aug 30 14:07:09 2001 @@ -0,0 +1,1391 @@ +/* winbond-840.c: A Linux PCI network adapter skeleton device driver. */ +/* + Written 1998-2000 by Donald Becker. + + This software may be used and distributed according to the terms of + the GNU General Public License (GPL), incorporated herein by reference. + Drivers based on or derived from this code fall under the GPL and must + retain the authorship, copyright and license notice. This file is not + a complete program and may only be used when the entire operating + system is licensed under the GPL. + + The author may be reached as becker@scyld.com, or C/O + Scyld Computing Corporation + 410 Severn Ave., Suite 210 + Annapolis MD 21403 + + Support and updates available at + http://www.scyld.com/network/drivers.html + + Do not remove the copyright infomation. + Do not change the version information unless an improvement has been made. + Merely removing my name, as Compex has done in the past, does not count + as an improvement. +*/ + +/* These identify the driver base version and may not be removed. */ +static const char version1[] = +"winbond-840.c:v1.01 5/15/2000 Donald Becker \n"; +static const char version2[] = +" http://www.scyld.com/network/drivers.html\n"; + +/* Automatically extracted configuration info: +probe-func: winbond840_probe +config-in: tristate 'Winbond W89c840 Ethernet support' CONFIG_WINBOND_840 + +c-help-name: Winbond W89c840 PCI Ethernet support +c-help-symbol: CONFIG_WINBOND_840 +c-help: This driver is for the Winbond W89c840 chip. It also works with +c-help: the TX9882 chip on the Compex RL100-ATX board. +c-help: More specific information and updates are available from +c-help: http://www.scyld.com/network/drivers.html +*/ + +/* The user-configurable values. + These may be modified when a driver module is loaded.*/ + +static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */ +static int max_interrupt_work = 20; +/* Maximum number of multicast addresses to filter (vs. Rx-all-multicast). + The '840 uses a 64 element hash table based on the Ethernet CRC. */ +static int multicast_filter_limit = 32; + +/* Set the copy breakpoint for the copy-only-tiny-frames scheme. + Setting to > 1518 effectively disables this feature. */ +static int rx_copybreak = 0; + +/* Used to pass the media type, etc. + Both 'options[]' and 'full_duplex[]' should exist for driver + interoperability. + The media type is usually passed in 'options[]'. +*/ +#define MAX_UNITS 8 /* More are supported, limit only on options */ +static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1}; +static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +/* Operational parameters that are set at compile time. */ + +/* Keep the ring sizes a power of two for compile efficiency. + The compiler will convert '%'<2^N> into a bit mask. + Making the Tx ring too large decreases the effectiveness of channel + bonding and packet priority. + There are no ill effects from too-large receive rings. */ +#define TX_RING_SIZE 16 +#define TX_QUEUE_LEN 10 /* Limit ring entries actually used. */ +#define RX_RING_SIZE 32 + +/* The presumed FIFO size for working around the Tx-FIFO-overflow bug. + To avoid overflowing we don't queue again until we have room for a + full-size packet. + */ +#define TX_FIFO_SIZE (2048) +#define TX_BUG_FIFO_LIMIT (TX_FIFO_SIZE-1514-16) + +/* Operational parameters that usually are not changed. */ +/* Time in jiffies before concluding the transmitter is hung. */ +#define TX_TIMEOUT (2*HZ) + +#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/ + +#ifndef __KERNEL__ +#define __KERNEL__ +#endif +#if !defined(__OPTIMIZE__) +#warning You must compile this file with the correct options! +#warning See the last lines of the source file. +#error You must compile this driver with "-O". +#endif + +/* Include files, designed to support most kernel versions 2.0.0 and later. */ +#include +#if defined(CONFIG_SMP) && ! defined(__SMP__) +#define __SMP__ +#endif +#if defined(CONFIG_MODVERSIONS) && ! defined(MODVERSIONS) +#define MODVERSIONS +#endif + +#include +#include +#if LINUX_VERSION_CODE < 0x20300 && defined(MODVERSIONS) +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include /* Processor type for cache alignment. */ +#include +#include + +#ifdef INLINE_PCISCAN +#include "k_compat.h" +#else +#include "pci-scan.h" +#include "kern_compat.h" +#endif + +/* Condensed operations for readability. + The compatibility defines are in kern_compat.h */ + +#define virt_to_le32desc(addr) cpu_to_le32(virt_to_bus(addr)) +#define le32desc_to_virt(addr) bus_to_virt(le32_to_cpu(addr)) + +#if (LINUX_VERSION_CODE >= 0x20100) && defined(MODULE) +char kernel_version[] = UTS_RELEASE; +#endif + +MODULE_AUTHOR("Donald Becker "); +MODULE_DESCRIPTION("Winbond W89c840 Ethernet driver"); +MODULE_PARM(max_interrupt_work, "i"); +MODULE_PARM(debug, "i"); +MODULE_PARM(rx_copybreak, "i"); +MODULE_PARM(multicast_filter_limit, "i"); +MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i"); +MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i"); + +/* + Theory of Operation + +I. Board Compatibility + +This driver is for the Winbond w89c840 chip. + +II. Board-specific settings + +None. + +III. Driver operation + +This chip is very similar to the Digital 21*4* "Tulip" family. The first +twelve registers and the descriptor format are nearly identical. Read a +Tulip manual for operational details. + +A significant difference is that the multicast filter and station address are +stored in registers rather than loaded through a pseudo-transmit packet. + +Unlike the Tulip, transmit buffers are limited to 1KB. To transmit a +full-sized packet we must use both data buffers in a descriptor. Thus the +driver uses ring mode where descriptors are implicitly sequential in memory, +rather than using the second descriptor address as a chain pointer to +subsequent descriptors. + +IV. Notes + +If you are going to almost clone a Tulip, why not go all the way and avoid +the need for a new driver? + +IVb. References + +http://www.scyld.com/expert/100mbps.html +http://www.scyld.com/expert/NWay.html +http://www.winbond.com.tw/ + +IVc. Errata + +A horrible bug exists in the transmit FIFO. Apparently the chip doesn't +correctly detect a full FIFO, and queuing more than 2048 bytes may result in +silent data corruption. + +*/ + + + +/* + PCI probe table. +*/ +static void *w840_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int chip_idx, int find_cnt); +enum chip_capability_flags {CanHaveMII=1, HasBrokenTx=2}; +#ifdef USE_IO_OPS +#define W840_FLAGS (PCI_USES_IO | PCI_ADDR0 | PCI_USES_MASTER) +#else +#define W840_FLAGS (PCI_USES_MEM | PCI_ADDR1 | PCI_USES_MASTER) +#endif + +static struct pci_id_info pci_id_tbl[] = { + {"Winbond W89c840", { 0x08401050, 0xffffffff, }, + W840_FLAGS, 128, CanHaveMII | HasBrokenTx}, + {"Compex RL100-ATX", { 0x201111F6, 0xffffffff,}, + W840_FLAGS, 128, CanHaveMII | HasBrokenTx}, + {0,}, /* 0 terminated list. */ +}; + +struct drv_id_info winbond840_drv_id = { + "winbond-840", 0, PCI_CLASS_NETWORK_ETHERNET<<8, pci_id_tbl, w840_probe1 }; + +/* This driver was written to use PCI memory space, however some x86 systems + work only with I/O space accesses. Pass -DUSE_IO_OPS to use PCI I/O space + accesses instead of memory space. */ + +#ifdef USE_IO_OPS +#undef readb +#undef readw +#undef readl +#undef writeb +#undef writew +#undef writel +#define readb inb +#define readw inw +#define readl inl +#define writeb outb +#define writew outw +#define writel outl +#endif + +/* Offsets to the Command and Status Registers, "CSRs". + While similar to the Tulip, these registers are longword aligned. + Note: It's not useful to define symbolic names for every register bit in + the device. The name can only partially document the semantics and make + the driver longer and more difficult to read. +*/ +enum w840_offsets { + PCIBusCfg=0x00, TxStartDemand=0x04, RxStartDemand=0x08, + RxRingPtr=0x0C, TxRingPtr=0x10, + IntrStatus=0x14, NetworkConfig=0x18, IntrEnable=0x1C, + RxMissed=0x20, EECtrl=0x24, MIICtrl=0x24, BootRom=0x28, GPTimer=0x2C, + CurRxDescAddr=0x30, CurRxBufAddr=0x34, /* Debug use */ + MulticastFilter0=0x38, MulticastFilter1=0x3C, StationAddr=0x40, + CurTxDescAddr=0x4C, CurTxBufAddr=0x50, +}; + +/* Bits in the interrupt status/enable registers. */ +/* The bits in the Intr Status/Enable registers, mostly interrupt sources. */ +enum intr_status_bits { + NormalIntr=0x10000, AbnormalIntr=0x8000, + IntrPCIErr=0x2000, TimerInt=0x800, + IntrRxDied=0x100, RxNoBuf=0x80, IntrRxDone=0x40, + TxFIFOUnderflow=0x20, RxErrIntr=0x10, + TxIdle=0x04, IntrTxStopped=0x02, IntrTxDone=0x01, +}; + +/* Bits in the NetworkConfig register. */ +enum rx_mode_bits { + AcceptErr=0x80, AcceptRunt=0x40, + AcceptBroadcast=0x20, AcceptMulticast=0x10, + AcceptAllPhys=0x08, AcceptMyPhys=0x02, +}; + +enum mii_reg_bits { + MDIO_ShiftClk=0x10000, MDIO_DataIn=0x80000, MDIO_DataOut=0x20000, + MDIO_EnbOutput=0x40000, MDIO_EnbIn = 0x00000, +}; + +/* The Tulip Rx and Tx buffer descriptors. */ +struct w840_rx_desc { + s32 status; + s32 length; + u32 buffer1; + u32 next_desc; +}; + +struct w840_tx_desc { + s32 status; + s32 length; + u32 buffer1, buffer2; /* We use only buffer 1. */ +}; + +/* Bits in network_desc.status */ +enum desc_status_bits { + DescOwn=0x80000000, DescEndRing=0x02000000, DescUseLink=0x01000000, + DescWholePkt=0x60000000, DescStartPkt=0x20000000, DescEndPkt=0x40000000, + DescIntr=0x80000000, +}; + +#define PRIV_ALIGN 15 /* Required alignment mask */ +struct netdev_private { + /* Descriptor rings first for alignment. */ + struct w840_rx_desc rx_ring[RX_RING_SIZE]; + struct w840_tx_desc tx_ring[TX_RING_SIZE]; + struct net_device *next_module; /* Link for devices of this type. */ + void *priv_addr; /* Unaligned address for kfree */ + const char *product_name; + /* The addresses of receive-in-place skbuffs. */ + struct sk_buff* rx_skbuff[RX_RING_SIZE]; + /* The saved address of a sent-in-place packet/buffer, for later free(). */ + struct sk_buff* tx_skbuff[TX_RING_SIZE]; + struct net_device_stats stats; + struct timer_list timer; /* Media monitoring timer. */ + /* Frequently used values: keep some adjacent for cache effect. */ + int chip_id, drv_flags; + struct pci_dev *pci_dev; + int csr6; + struct w840_rx_desc *rx_head_desc; + unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */ + unsigned int rx_buf_sz; /* Based on MTU+slack. */ + unsigned int cur_tx, dirty_tx; + int tx_q_bytes; + unsigned int tx_full:1; /* The Tx queue is full. */ + /* These values are keep track of the transceiver/media in use. */ + unsigned int full_duplex:1; /* Full-duplex operation requested. */ + unsigned int duplex_lock:1; + unsigned int medialock:1; /* Do not sense media. */ + unsigned int default_port:4; /* Last dev->if_port value. */ + /* MII transceiver section. */ + int mii_cnt; /* MII device addresses. */ + u16 advertising; /* NWay media advertisement */ + unsigned char phys[2]; /* MII device addresses. */ +}; + +static int eeprom_read(long ioaddr, int location); +static int mdio_read(struct net_device *dev, int phy_id, int location); +static void mdio_write(struct net_device *dev, int phy_id, int location, int value); +static int netdev_open(struct net_device *dev); +static void check_duplex(struct net_device *dev); +static void netdev_timer(unsigned long data); +static void tx_timeout(struct net_device *dev); +static void init_ring(struct net_device *dev); +static int start_tx(struct sk_buff *skb, struct net_device *dev); +static void intr_handler(int irq, void *dev_instance, struct pt_regs *regs); +static void netdev_error(struct net_device *dev, int intr_status); +static int netdev_rx(struct net_device *dev); +static void netdev_error(struct net_device *dev, int intr_status); +static inline unsigned ether_crc(int length, unsigned char *data); +static void set_rx_mode(struct net_device *dev); +static struct net_device_stats *get_stats(struct net_device *dev); +static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); +static int netdev_close(struct net_device *dev); + + + +/* A list of our installed devices, for removing the driver module. */ +static struct net_device *root_net_dev = NULL; + +static void *w840_probe1(struct pci_dev *pdev, void *init_dev, + long ioaddr, int irq, int chip_idx, int find_cnt) +{ + struct net_device *dev; + struct netdev_private *np; + void *priv_mem; + int i, option = find_cnt < MAX_UNITS ? options[find_cnt] : 0; + + dev = init_etherdev(init_dev, 0); + + printk(KERN_INFO "%s: %s at 0x%lx, ", + dev->name, pci_id_tbl[chip_idx].name, ioaddr); + + /* Warning: broken for big-endian machines. */ + for (i = 0; i < 3; i++) + ((u16 *)dev->dev_addr)[i] = le16_to_cpu(eeprom_read(ioaddr, i)); + + for (i = 0; i < 5; i++) + printk("%2.2x:", dev->dev_addr[i]); + printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq); + + priv_mem = kmalloc(sizeof(*np) + PRIV_ALIGN, GFP_KERNEL); + /* Out of memory is very unlikely. */ + if (priv_mem == NULL) + return NULL; + +#ifdef USE_IO_OPS + request_region(ioaddr, pci_tbl[chip_idx].io_size, dev->name); +#endif + + /* Reset the chip to erase previous misconfiguration. + No hold time required! */ + writel(0x00000001, ioaddr + PCIBusCfg); + + dev->base_addr = ioaddr; + dev->irq = irq; + + /* The descriptor lists must be aligned. */ + dev->priv = np = (void *)(((long)priv_mem + PRIV_ALIGN) & ~PRIV_ALIGN); + memset(np, 0, sizeof(*np)); + np->priv_addr = priv_mem; + + np->next_module = root_net_dev; + root_net_dev = dev; + + np->pci_dev = pdev; + np->chip_id = chip_idx; + np->drv_flags = pci_id_tbl[chip_idx].drv_flags; + + if (dev->mem_start) + option = dev->mem_start; + + /* The lower four bits are the media type. */ + if (option > 0) { + if (option & 0x200) + np->full_duplex = 1; + np->default_port = option & 15; + if (np->default_port) + np->medialock = 1; + } + if (find_cnt < MAX_UNITS && full_duplex[find_cnt] > 0) + np->full_duplex = 1; + + if (np->full_duplex) + np->duplex_lock = 1; + + /* The chip-specific entries in the device structure. */ + dev->open = &netdev_open; + dev->hard_start_xmit = &start_tx; + dev->stop = &netdev_close; + dev->get_stats = &get_stats; + dev->set_multicast_list = &set_rx_mode; + dev->do_ioctl = &mii_ioctl; + + if (np->drv_flags & CanHaveMII) { + int phy, phy_idx = 0; + for (phy = 1; phy < 32 && phy_idx < 4; phy++) { + int mii_status = mdio_read(dev, phy, 1); + if (mii_status != 0xffff && mii_status != 0x0000) { + np->phys[phy_idx++] = phy; + np->advertising = mdio_read(dev, phy, 4); + printk(KERN_INFO "%s: MII PHY found at address %d, status " + "0x%4.4x advertising %4.4x.\n", + dev->name, phy, mii_status, np->advertising); + } + } + np->mii_cnt = phy_idx; + if (phy_idx == 0) { + printk(KERN_WARNING "%s: MII PHY not found -- this device may " + "not operate correctly.\n", dev->name); + } + } + + return dev; +} + + +/* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. These are + often serial bit streams generated by the host processor. + The example below is for the common 93c46 EEPROM, 64 16 bit words. */ + +/* Delay between EEPROM clock transitions. + No extra delay is needed with 33Mhz PCI, but future 66Mhz access may need + a delay. Note that pre-2.0.34 kernels had a cache-alignment bug that + made udelay() unreliable. + The old method of using an ISA access as a delay, __SLOW_DOWN_IO__, is + depricated. +*/ +#define eeprom_delay(ee_addr) readl(ee_addr) + +enum EEPROM_Ctrl_Bits { + EE_ShiftClk=0x02, EE_Write0=0x801, EE_Write1=0x805, + EE_ChipSelect=0x801, EE_DataIn=0x08, +}; + +/* The EEPROM commands include the alway-set leading bit. */ +enum EEPROM_Cmds { + EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6), +}; + +static int eeprom_read(long addr, int location) +{ + int i; + int retval = 0; + int ee_addr = addr + EECtrl; + int read_cmd = location | EE_ReadCmd; + writel(EE_ChipSelect, ee_addr); + + /* Shift the read command bits out. */ + for (i = 10; i >= 0; i--) { + short dataval = (read_cmd & (1 << i)) ? EE_Write1 : EE_Write0; + writel(dataval, ee_addr); + eeprom_delay(ee_addr); + writel(dataval | EE_ShiftClk, ee_addr); + eeprom_delay(ee_addr); + } + writel(EE_ChipSelect, ee_addr); + + for (i = 16; i > 0; i--) { + writel(EE_ChipSelect | EE_ShiftClk, ee_addr); + eeprom_delay(ee_addr); + retval = (retval << 1) | ((readl(ee_addr) & EE_DataIn) ? 1 : 0); + writel(EE_ChipSelect, ee_addr); + eeprom_delay(ee_addr); + } + + /* Terminate the EEPROM access. */ + writel(0, ee_addr); + return retval; +} + +/* MII transceiver control section. + Read and write the MII registers using software-generated serial + MDIO protocol. See the MII specifications or DP83840A data sheet + for details. + + The maximum data clock rate is 2.5 Mhz. The minimum timing is usually + met by back-to-back 33Mhz PCI cycles. */ +#define mdio_delay(mdio_addr) readl(mdio_addr) + +/* Set iff a MII transceiver on any interface requires mdio preamble. + This only set with older tranceivers, so the extra + code size of a per-interface flag is not worthwhile. */ +static char mii_preamble_required = 1; + +#define MDIO_WRITE0 (MDIO_EnbOutput) +#define MDIO_WRITE1 (MDIO_DataOut | MDIO_EnbOutput) + +/* Generate the preamble required for initial synchronization and + a few older transceivers. */ +static void mdio_sync(long mdio_addr) +{ + int bits = 32; + + /* Establish sync by sending at least 32 logic ones. */ + while (--bits >= 0) { + writel(MDIO_WRITE1, mdio_addr); + mdio_delay(mdio_addr); + writel(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } +} + +static int mdio_read(struct net_device *dev, int phy_id, int location) +{ + long mdio_addr = dev->base_addr + MIICtrl; + int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location; + int i, retval = 0; + + if (mii_preamble_required) + mdio_sync(mdio_addr); + + /* Shift the read command bits out. */ + for (i = 15; i >= 0; i--) { + int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; + + writel(dataval, mdio_addr); + mdio_delay(mdio_addr); + writel(dataval | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + /* Read the two transition, 16 data, and wire-idle bits. */ + for (i = 20; i > 0; i--) { + writel(MDIO_EnbIn, mdio_addr); + mdio_delay(mdio_addr); + retval = (retval << 1) | ((readl(mdio_addr) & MDIO_DataIn) ? 1 : 0); + writel(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + return (retval>>1) & 0xffff; +} + +static void mdio_write(struct net_device *dev, int phy_id, int location, int value) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long mdio_addr = dev->base_addr + MIICtrl; + int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value; + int i; + + if (location == 4 && phy_id == np->phys[0]) + np->advertising = value; + + if (mii_preamble_required) + mdio_sync(mdio_addr); + + /* Shift the command bits out. */ + for (i = 31; i >= 0; i--) { + int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0; + + writel(dataval, mdio_addr); + mdio_delay(mdio_addr); + writel(dataval | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + /* Clear out extra bits. */ + for (i = 2; i > 0; i--) { + writel(MDIO_EnbIn, mdio_addr); + mdio_delay(mdio_addr); + writel(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr); + mdio_delay(mdio_addr); + } + return; +} + + +static int netdev_open(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int i; + + writel(0x00000001, ioaddr + PCIBusCfg); /* Reset */ + + MOD_INC_USE_COUNT; + + if (request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev)) { + MOD_DEC_USE_COUNT; + return -EAGAIN; + } + + if (debug > 1) + printk(KERN_DEBUG "%s: w89c840_open() irq %d.\n", + dev->name, dev->irq); + + init_ring(dev); + + writel(virt_to_bus(np->rx_ring), ioaddr + RxRingPtr); + writel(virt_to_bus(np->tx_ring), ioaddr + TxRingPtr); + + for (i = 0; i < 6; i++) + writeb(dev->dev_addr[i], ioaddr + StationAddr + i); + + /* Initialize other registers. */ + /* Configure the PCI bus bursts and FIFO thresholds. + 486: Set 8 longword cache alignment, 8 longword burst. + 586: Set 16 longword cache alignment, no burst limit. + Cache alignment bits 15:14 Burst length 13:8 + 0000 0000 align to cache 0800 8 longwords + 4000 8 longwords 0100 1 longword 1000 16 longwords + 8000 16 longwords 0200 2 longwords 2000 32 longwords + C000 32 longwords 0400 4 longwords + Wait the specified 50 PCI cycles after a reset by initializing + Tx and Rx queues and the address filter list. */ +#if defined(__powerpc__) /* Big-endian */ + writel(0x00100080 | 0xE010, ioaddr + PCIBusCfg); +#elif defined(__alpha__) + writel(0xE010, ioaddr + PCIBusCfg); +#elif defined(__i386__) +#if defined(MODULE) + writel(0xE010, ioaddr + PCIBusCfg); +#else + /* When not a module we can work around broken '486 PCI boards. */ +#if (LINUX_VERSION_CODE > 0x2014c) +#define x86 boot_cpu_data.x86 +#endif + writel((x86 <= 4 ? 0x4810 : 0xE010), ioaddr + PCIBusCfg); + if (x86 <= 4) + printk(KERN_INFO "%s: This is a 386/486 PCI system, setting cache " + "alignment to %x.\n", dev->name, + (x86 <= 4 ? 0x4810 : 0x8010)); +#endif +#else + writel(0xE010, ioaddr + PCIBusCfg); +#warning Processor architecture undefined! +#endif + + if (dev->if_port == 0) + dev->if_port = np->default_port; + + dev->tbusy = 0; + dev->interrupt = 0; + + writel(0, ioaddr + RxStartDemand); + np->csr6 = 0x20022002; + check_duplex(dev); + set_rx_mode(dev); + + dev->start = 1; + + /* Clear and Enable interrupts by setting the interrupt mask. */ + writel(0x1A0F5, ioaddr + IntrStatus); + writel(0x1A0F5, ioaddr + IntrEnable); + + if (debug > 2) + printk(KERN_DEBUG "%s: Done netdev_open().\n", dev->name); + + /* Set the timer to check for link beat. */ + init_timer(&np->timer); + np->timer.expires = jiffies + 3*HZ; + np->timer.data = (unsigned long)dev; + np->timer.function = &netdev_timer; /* timer handler */ + add_timer(&np->timer); + + return 0; +} + +static void check_duplex(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + int mii_reg5 = mdio_read(dev, np->phys[0], 5); + int negotiated = mii_reg5 & np->advertising; + int duplex; + + if (np->duplex_lock || mii_reg5 == 0xffff) + return; + duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040; + if (np->full_duplex != duplex) { + np->full_duplex = duplex; + if (debug) + printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d " + "negotiated capability %4.4x.\n", dev->name, + duplex ? "full" : "half", np->phys[0], negotiated); + np->csr6 &= ~0x200; + np->csr6 |= duplex ? 0x200 : 0; + } +} + +static void netdev_timer(unsigned long data) +{ + struct net_device *dev = (struct net_device *)data; + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int next_tick = 10*HZ; + int old_csr6 = np->csr6; + + if (debug > 2) + printk(KERN_DEBUG "%s: Media selection timer tick, status %8.8x " + "config %8.8x.\n", + dev->name, (int)readl(ioaddr + IntrStatus), + (int)readl(ioaddr + NetworkConfig)); + if (test_bit(0, (void*)&dev->tbusy) && + np->cur_tx - np->dirty_tx > 1 && + (jiffies - dev->trans_start) > TX_TIMEOUT) { + tx_timeout(dev); + } + check_duplex(dev); + if (np->csr6 != old_csr6) { + writel(np->csr6 & ~0x0002, ioaddr + NetworkConfig); + writel(np->csr6 | 0x2002, ioaddr + NetworkConfig); + } + np->timer.expires = jiffies + next_tick; + add_timer(&np->timer); +} + +static void tx_timeout(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + + printk(KERN_WARNING "%s: Transmit timed out, status %8.8x," + " resetting...\n", dev->name, (int)readl(ioaddr + IntrStatus)); + +#ifndef __alpha__ + { + int i; + printk(KERN_DEBUG " Rx ring %8.8x: ", (int)np->rx_ring); + for (i = 0; i < RX_RING_SIZE; i++) + printk(" %8.8x", (unsigned int)np->rx_ring[i].status); + printk("\n"KERN_DEBUG" Tx ring %8.8x: ", (int)np->tx_ring); + for (i = 0; i < TX_RING_SIZE; i++) + printk(" %4.4x", np->tx_ring[i].status); + printk("\n"); + } +#endif + + /* Perhaps we should reinitialize the hardware here. Just trigger a + Tx demand for now. */ + writel(0, ioaddr + TxStartDemand); + dev->if_port = 0; + /* Stop and restart the chip's Tx processes . */ + + dev->trans_start = jiffies; + np->stats.tx_errors++; + return; +} + + +/* Initialize the Rx and Tx rings, along with various 'dev' bits. */ +static void init_ring(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + int i; + + np->tx_full = 0; + np->tx_q_bytes = np->cur_rx = np->cur_tx = 0; + np->dirty_rx = np->dirty_tx = 0; + + np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32); + np->rx_head_desc = &np->rx_ring[0]; + + /* Initial all Rx descriptors. */ + for (i = 0; i < RX_RING_SIZE; i++) { + np->rx_ring[i].length = cpu_to_le32(np->rx_buf_sz); + np->rx_ring[i].status = 0; + np->rx_ring[i].next_desc = virt_to_le32desc(&np->rx_ring[i+1]); + np->rx_skbuff[i] = 0; + } + /* Mark the last entry as wrapping the ring. */ + np->rx_ring[i-1].length |= cpu_to_le32(DescEndRing); + np->rx_ring[i-1].next_desc = virt_to_le32desc(&np->rx_ring[0]); + + /* Fill in the Rx buffers. Handle allocation failure gracefully. */ + for (i = 0; i < RX_RING_SIZE; i++) { + struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz); + np->rx_skbuff[i] = skb; + if (skb == NULL) + break; + skb->dev = dev; /* Mark as being used by this device. */ + np->rx_ring[i].buffer1 = virt_to_le32desc(skb->tail); + np->rx_ring[i].status = cpu_to_le32(DescOwn | DescIntr); + } + np->dirty_rx = (unsigned int)(i - RX_RING_SIZE); + + for (i = 0; i < TX_RING_SIZE; i++) { + np->tx_skbuff[i] = 0; + np->tx_ring[i].status = 0; + } + return; +} + +static int start_tx(struct sk_buff *skb, struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + unsigned entry; + + /* Block a timer-based transmit from overlapping. This could better be + done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */ + if (test_and_set_bit(0, (void*)&dev->tbusy) != 0) { + if (jiffies - dev->trans_start > TX_TIMEOUT) + tx_timeout(dev); + return 1; + } + + /* Caution: the write order is important here, set the field + with the "ownership" bits last. */ + + /* Calculate the next Tx descriptor entry. */ + entry = np->cur_tx % TX_RING_SIZE; + + np->tx_skbuff[entry] = skb; + np->tx_ring[entry].buffer1 = virt_to_le32desc(skb->data); + +#define one_buffer +#define BPT 1022 +#if defined(one_buffer) + np->tx_ring[entry].length = cpu_to_le32(DescWholePkt | skb->len); + if (entry >= TX_RING_SIZE-1) /* Wrap ring */ + np->tx_ring[entry].length |= cpu_to_le32(DescIntr | DescEndRing); + np->tx_ring[entry].status = cpu_to_le32(DescOwn); + np->cur_tx++; +#elif defined(two_buffer) + if (skb->len > BPT) { + unsigned int entry1 = ++np->cur_tx % TX_RING_SIZE; + np->tx_ring[entry].length = cpu_to_le32(DescStartPkt | BPT); + np->tx_ring[entry1].length = cpu_to_le32(DescEndPkt | (skb->len - BPT)); + np->tx_ring[entry1].buffer1 = virt_to_le32desc((skb->data) + BPT); + np->tx_ring[entry1].status = cpu_to_le32(DescOwn); + np->tx_ring[entry].status = cpu_to_le32(DescOwn); + if (entry >= TX_RING_SIZE-1) + np->tx_ring[entry].length |= cpu_to_le32(DescIntr|DescEndRing); + else if (entry1 >= TX_RING_SIZE-1) + np->tx_ring[entry1].length |= cpu_to_le32(DescIntr|DescEndRing); + np->cur_tx++; + } else { + np->tx_ring[entry].length = cpu_to_le32(DescWholePkt | skb->len); + if (entry >= TX_RING_SIZE-1) /* Wrap ring */ + np->tx_ring[entry].length |= cpu_to_le32(DescIntr | DescEndRing); + np->tx_ring[entry].status = cpu_to_le32(DescOwn); + np->cur_tx++; + } +#elif defined(split_buffer) + { + /* Work around the Tx-FIFO-full bug by splitting our transmit packet + into two pieces, the first which may be loaded without overflowing + the FIFO, and the second which contains the remainder of the + packet. When we get a Tx-done interrupt that frees enough room + in the FIFO we mark the remainder of the packet as loadable. + + This has the problem that the Tx descriptors are written both + here and in the interrupt handler. + */ + + int buf1size = TX_FIFO_SIZE - np->tx_q_bytes; + int buf2size = skb->len - buf1size; + + if (buf2size <= 0) { /* We fit into one descriptor. */ + np->tx_ring[entry].length = cpu_to_le32(DescWholePkt | skb->len); + } else { /* We must use two descriptors. */ + unsigned int entry2; + np->tx_ring[entry].length = + cpu_to_le32(DescIntr | DescStartPkt | buf1size); + if (entry >= TX_RING_SIZE-1) { /* Wrap ring */ + np->tx_ring[entry].length |= cpu_to_le32(DescEndRing); + entry2 = 0; + } else + entry2 = entry + 1; + np->cur_tx++; + np->tx_ring[entry2].buffer1 = + virt_to_le32desc(skb->data + buf1size); + np->tx_ring[entry2].length = cpu_to_le32(DescEndPkt | buf2size); + if (entry2 >= TX_RING_SIZE-1) /* Wrap ring */ + np->tx_ring[entry2].length |= cpu_to_le32(DescEndRing); + } + np->tx_ring[entry].status = cpu_to_le32(DescOwn); + np->cur_tx++; + } +#endif + np->tx_q_bytes += skb->len; + writel(0, dev->base_addr + TxStartDemand); + + /* Work around horrible bug in the chip by marking the queue as full + when we do not have FIFO room for a maximum sized packet. */ + if (np->cur_tx - np->dirty_tx > TX_QUEUE_LEN) + np->tx_full = 1; + else if ((np->drv_flags & HasBrokenTx) + && np->tx_q_bytes > TX_BUG_FIFO_LIMIT) + np->tx_full = 1; + else + clear_bit(0, (void*)&dev->tbusy); /* Typical path */ + + dev->trans_start = jiffies; + + if (debug > 4) { + printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n", + dev->name, np->cur_tx, entry); + } + return 0; +} + +/* The interrupt handler does all of the Rx thread work and cleans up + after the Tx thread. */ +static void intr_handler(int irq, void *dev_instance, struct pt_regs *rgs) +{ + struct net_device *dev = (struct net_device *)dev_instance; + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + int work_limit = max_interrupt_work; + +#if defined(__i386__) + /* A lock to prevent simultaneous entry bug on Intel SMP machines. */ + if (test_and_set_bit(0, (void*)&dev->interrupt)) { + printk(KERN_ERR"%s: SMP simultaneous entry of an interrupt handler.\n", + dev->name); + dev->interrupt = 0; /* Avoid halting machine. */ + return; + } +#endif + + do { + u32 intr_status = readl(ioaddr + IntrStatus); + + /* Acknowledge all of the current interrupt sources ASAP. */ + writel(intr_status & 0x001ffff, ioaddr + IntrStatus); + + if (debug > 4) + printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n", + dev->name, intr_status); + + if ((intr_status & (NormalIntr|AbnormalIntr)) == 0) + break; + + if (intr_status & (IntrRxDone | RxNoBuf)) + netdev_rx(dev); + + for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) { + int entry = np->dirty_tx % TX_RING_SIZE; + int tx_status = le32_to_cpu(np->tx_ring[entry].status); + + if (tx_status < 0) + break; + if (tx_status & 0x8000) { /* There was an error, log it. */ +#ifndef final_version + if (debug > 1) + printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n", + dev->name, tx_status); +#endif + np->stats.tx_errors++; + if (tx_status & 0x0104) np->stats.tx_aborted_errors++; + if (tx_status & 0x0C80) np->stats.tx_carrier_errors++; + if (tx_status & 0x0200) np->stats.tx_window_errors++; + if (tx_status & 0x0002) np->stats.tx_fifo_errors++; + if ((tx_status & 0x0080) && np->full_duplex == 0) + np->stats.tx_heartbeat_errors++; +#ifdef ETHER_STATS + if (tx_status & 0x0100) np->stats.collisions16++; +#endif + } else { +#ifdef ETHER_STATS + if (tx_status & 0x0001) np->stats.tx_deferred++; +#endif +#if LINUX_VERSION_CODE > 0x20127 + np->stats.tx_bytes += np->tx_skbuff[entry]->len; +#endif + np->stats.collisions += (tx_status >> 3) & 15; + np->stats.tx_packets++; + } + /* Free the original skb. */ + np->tx_q_bytes -= np->tx_skbuff[entry]->len; + dev_free_skb(np->tx_skbuff[entry]); + np->tx_skbuff[entry] = 0; + } + if (np->tx_full && + np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4 + && np->tx_q_bytes < TX_BUG_FIFO_LIMIT) { + /* The ring is no longer full, clear tbusy. */ + np->tx_full = 0; + clear_bit(0, (void*)&dev->tbusy); + netif_wake_queue(dev); + } + + /* Abnormal error summary/uncommon events handlers. */ + if (intr_status & (AbnormalIntr | TxFIFOUnderflow | IntrPCIErr | + TimerInt | IntrTxStopped)) + netdev_error(dev, intr_status); + + if (--work_limit < 0) { + printk(KERN_WARNING "%s: Too much work at interrupt, " + "status=0x%4.4x.\n", dev->name, intr_status); + /* Set the timer to re-enable the other interrupts after + 10*82usec ticks. */ + writel(AbnormalIntr | TimerInt, ioaddr + IntrEnable); + writel(10, ioaddr + GPTimer); + break; + } + } while (1); + + if (debug > 3) + printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n", + dev->name, (int)readl(ioaddr + IntrStatus)); + +#if defined(__i386__) + clear_bit(0, (void*)&dev->interrupt); +#else + dev->interrupt = 0; +#endif + return; +} + +/* This routine is logically part of the interrupt handler, but separated + for clarity and better register allocation. */ +static int netdev_rx(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + int entry = np->cur_rx % RX_RING_SIZE; + int work_limit = np->dirty_rx + RX_RING_SIZE - np->cur_rx; + + if (debug > 4) { + printk(KERN_DEBUG " In netdev_rx(), entry %d status %4.4x.\n", + entry, np->rx_ring[entry].status); + } + + /* If EOP is set on the next entry, it's a new packet. Send it up. */ + while (--work_limit >= 0) { + struct w840_rx_desc *desc = np->rx_head_desc; + s32 status = le32_to_cpu(desc->status); + + if (debug > 4) + printk(KERN_DEBUG " netdev_rx() status was %8.8x.\n", + status); + if (status < 0) + break; + if ((status & 0x38008300) != 0x0300) { + if ((status & 0x38000300) != 0x0300) { + /* Ingore earlier buffers. */ + if ((status & 0xffff) != 0x7fff) { + printk(KERN_WARNING "%s: Oversized Ethernet frame spanned " + "multiple buffers, entry %#x status %4.4x!\n", + dev->name, np->cur_rx, status); + np->stats.rx_length_errors++; + } + } else if (status & 0x8000) { + /* There was a fatal error. */ + if (debug > 2) + printk(KERN_DEBUG "%s: Receive error, Rx status %8.8x.\n", + dev->name, status); + np->stats.rx_errors++; /* end of a packet.*/ + if (status & 0x0890) np->stats.rx_length_errors++; + if (status & 0x004C) np->stats.rx_frame_errors++; + if (status & 0x0002) np->stats.rx_crc_errors++; + } + } else { + struct sk_buff *skb; + /* Omit the four octet CRC from the length. */ + int pkt_len = ((status >> 16) & 0x7ff) - 4; + +#ifndef final_version + if (debug > 4) + printk(KERN_DEBUG " netdev_rx() normal Rx pkt length %d" + " status %x.\n", pkt_len, status); +#endif + /* Check if the packet is long enough to accept without copying + to a minimally-sized skbuff. */ + if (pkt_len < rx_copybreak + && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) { + skb->dev = dev; + skb_reserve(skb, 2); /* 16 byte align the IP header */ + /* Call copy + cksum if available. */ +#if HAS_IP_COPYSUM + eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0); + skb_put(skb, pkt_len); +#else + memcpy(skb_put(skb, pkt_len), np->rx_skbuff[entry]->tail, + pkt_len); +#endif + } else { + char *temp = skb_put(skb = np->rx_skbuff[entry], pkt_len); + np->rx_skbuff[entry] = NULL; +#ifndef final_version /* Remove after testing. */ + if (le32desc_to_virt(desc->buffer1) != temp) + printk(KERN_ERR "%s: Internal fault: The skbuff addresses " + "do not match in netdev_rx: %p vs. %p / %p.\n", + dev->name, le32desc_to_virt(desc->buffer1), + skb->head, temp); +#endif + } +#ifndef final_version /* Remove after testing. */ + /* You will want this info for the initial debug. */ + if (debug > 5) + printk(KERN_DEBUG " Rx data %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:" + "%2.2x %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x %2.2x%2.2x " + "%d.%d.%d.%d.\n", + skb->data[0], skb->data[1], skb->data[2], skb->data[3], + skb->data[4], skb->data[5], skb->data[6], skb->data[7], + skb->data[8], skb->data[9], skb->data[10], + skb->data[11], skb->data[12], skb->data[13], + skb->data[14], skb->data[15], skb->data[16], + skb->data[17]); +#endif + skb->protocol = eth_type_trans(skb, dev); + netif_rx(skb); + dev->last_rx = jiffies; + np->stats.rx_packets++; +#if LINUX_VERSION_CODE > 0x20127 + np->stats.rx_bytes += pkt_len; +#endif + } + entry = (++np->cur_rx) % RX_RING_SIZE; + np->rx_head_desc = &np->rx_ring[entry]; + } + + /* Refill the Rx ring buffers. */ + for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) { + struct sk_buff *skb; + entry = np->dirty_rx % RX_RING_SIZE; + if (np->rx_skbuff[entry] == NULL) { + skb = dev_alloc_skb(np->rx_buf_sz); + np->rx_skbuff[entry] = skb; + if (skb == NULL) + break; /* Better luck next round. */ + skb->dev = dev; /* Mark as being used by this device. */ + np->rx_ring[entry].buffer1 = virt_to_le32desc(skb->tail); + } + np->rx_ring[entry].status = cpu_to_le32(DescOwn); + } + + return 0; +} + +static void netdev_error(struct net_device *dev, int intr_status) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + + if (debug > 2) + printk(KERN_DEBUG "%s: Abnormal event, %8.8x.\n", + dev->name, intr_status); + if (intr_status == 0xffffffff) + return; + if (intr_status & TxFIFOUnderflow) { + np->csr6 += 0x4000; /* Bump up the Tx threshold */ + printk(KERN_DEBUG "%s: Tx underflow, increasing threshold to %8.8x.\n", + dev->name, np->csr6); + writel(np->csr6, ioaddr + NetworkConfig); + } + if (intr_status & IntrRxDied) { /* Missed a Rx frame. */ + np->stats.rx_errors++; + } + if (intr_status & TimerInt) { + /* Re-enable other interrupts. */ + writel(0x1A0F5, ioaddr + IntrEnable); + } + np->stats.rx_missed_errors += readl(ioaddr + RxMissed) & 0xffff; + writel(0, ioaddr + RxStartDemand); +} + +static struct net_device_stats *get_stats(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + + /* The chip only need report frame silently dropped. */ + if (dev->start) + np->stats.rx_missed_errors += readl(ioaddr + RxMissed) & 0xffff; + + return &np->stats; +} + +static unsigned const ethernet_polynomial = 0x04c11db7U; +static inline u32 ether_crc(int length, unsigned char *data) +{ + int crc = -1; + + while(--length >= 0) { + unsigned char current_octet = *data++; + int bit; + for (bit = 0; bit < 8; bit++, current_octet >>= 1) { + crc = (crc << 1) ^ + ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0); + } + } + return crc; +} + +static void set_rx_mode(struct net_device *dev) +{ + struct netdev_private *np = (struct netdev_private *)dev->priv; + long ioaddr = dev->base_addr; + u32 mc_filter[2]; /* Multicast hash filter */ + u32 rx_mode; + + if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ + /* Unconditionally log net taps. */ + printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); + memset(mc_filter, 0xff, sizeof(mc_filter)); + rx_mode = AcceptBroadcast | AcceptMulticast | AcceptAllPhys + | AcceptMyPhys; + } else if ((dev->mc_count > multicast_filter_limit) + || (dev->flags & IFF_ALLMULTI)) { + /* Too many to match, or accept all multicasts. */ + memset(mc_filter, 0xff, sizeof(mc_filter)); + rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys; + } else { + struct dev_mc_list *mclist; + int i; + memset(mc_filter, 0, sizeof(mc_filter)); + for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; + i++, mclist = mclist->next) { + set_bit((ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26) ^ 0x3F, + mc_filter); + } + rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys; + } + writel(mc_filter[0], ioaddr + MulticastFilter0); + writel(mc_filter[1], ioaddr + MulticastFilter1); + np->csr6 &= ~0x00F8; + np->csr6 |= rx_mode; + writel(np->csr6, ioaddr + NetworkConfig); +} + +static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) +{ + u16 *data = (u16 *)&rq->ifr_data; + + switch(cmd) { + case SIOCDEVPRIVATE: /* Get the address of the PHY in use. */ + data[0] = ((struct netdev_private *)dev->priv)->phys[0] & 0x1f; + /* Fall Through */ + case SIOCDEVPRIVATE+1: /* Read the specified MII register. */ + data[3] = mdio_read(dev, data[0] & 0x1f, data[1] & 0x1f); + return 0; + case SIOCDEVPRIVATE+2: /* Write the specified MII register */ + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + mdio_write(dev, data[0] & 0x1f, data[1] & 0x1f, data[2]); + return 0; + default: + return -EOPNOTSUPP; + } +} + +static int netdev_close(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = (struct netdev_private *)dev->priv; + int i; + + dev->start = 0; + dev->tbusy = 1; + + if (debug > 1) { + printk(KERN_DEBUG "%s: Shutting down ethercard, status was %8.8x " + "Config %8.8x.\n", dev->name, (int)readl(ioaddr + IntrStatus), + (int)readl(ioaddr + NetworkConfig)); + printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n", + dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx); + } + + /* Disable interrupts by clearing the interrupt mask. */ + writel(0x0000, ioaddr + IntrEnable); + + /* Stop the chip's Tx and Rx processes. */ + writel(np->csr6 &= ~0x20FA, ioaddr + NetworkConfig); + + del_timer(&np->timer); + if (readl(ioaddr + NetworkConfig) != 0xffffffff) + np->stats.rx_missed_errors += readl(ioaddr + RxMissed) & 0xffff; + +#ifdef __i386__ + if (debug > 2) { + printk("\n"KERN_DEBUG" Tx ring at %8.8x:\n", + (int)virt_to_le32desc(np->tx_ring)); + for (i = 0; i < TX_RING_SIZE; i++) + printk(" #%d desc. %4.4x %4.4x %8.8x.\n", + i, np->tx_ring[i].length, + np->tx_ring[i].status, np->tx_ring[i].buffer1); + printk("\n"KERN_DEBUG " Rx ring %8.8x:\n", + (int)virt_to_le32desc(np->rx_ring)); + for (i = 0; i < RX_RING_SIZE; i++) { + printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n", + i, np->rx_ring[i].length, + np->rx_ring[i].status, np->rx_ring[i].buffer1); + } + } +#endif /* __i386__ debugging only */ + + free_irq(dev->irq, dev); + + /* Free all the skbuffs in the Rx queue. */ + for (i = 0; i < RX_RING_SIZE; i++) { + np->rx_ring[i].status = 0; + if (np->rx_skbuff[i]) { +#if LINUX_VERSION_CODE < 0x20100 + np->rx_skbuff[i]->free = 1; +#endif + dev_free_skb(np->rx_skbuff[i]); + } + np->rx_skbuff[i] = 0; + } + for (i = 0; i < TX_RING_SIZE; i++) { + if (np->tx_skbuff[i]) + dev_free_skb(np->tx_skbuff[i]); + np->tx_skbuff[i] = 0; + } + + MOD_DEC_USE_COUNT; + + return 0; +} + + +#ifdef MODULE +int init_module(void) +{ + if (debug) /* Emit version even if no cards detected. */ + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); + return pci_drv_register(&winbond840_drv_id, NULL); +} + +void cleanup_module(void) +{ + struct net_device *next_dev; + + pci_drv_unregister(&winbond840_drv_id); + + /* No need to check MOD_IN_USE, as sys_delete_module() checks. */ + while (root_net_dev) { + struct netdev_private *np = (void *)(root_net_dev->priv); + unregister_netdev(root_net_dev); +#ifdef USE_IO_OPS + release_region(root_net_dev->base_addr, pci_tbl[np->chip_id].io_size); +#else + iounmap((char *)(root_net_dev->base_addr)); +#endif + next_dev = np->next_module; + if (np->priv_addr) + kfree(np->priv_addr); + kfree(root_net_dev); + root_net_dev = next_dev; + } +} +#else +int winbond840_probe(struct net_device *dev) +{ + if (pci_drv_register(&winbond840_drv_id, dev) < 0) + return -ENODEV; + printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2); + return 0; +} +#endif /* MODULE */ + + +/* + * Local variables: + * compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O6 -c winbond-840.c" + * simple-compile-command: "gcc -DMODULE -O6 -c winbond-840.c" + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */