/* tulip.c: A DEC 21040-family ethernet driver for Linux. */ /* Written 1994-1998 by Donald Becker. This software may be used and distributed according to the terms of the GNU Public License, incorporated herein by reference. 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 Support and updates available at http://cesdis.gsfc.nasa.gov/linux/drivers/tulip.html */ #define SMP_CHECK /* Test version only: Do not distribute. */ static const char version[] = "tulip.c:v0.90 10/20/98 becker@cesdis.gsfc.nasa.gov+v0.190 981105 FASTROUTE/HW_FLOWCONTROL\n"; /* A few user-configurable values. */ #define AVE_STATS #define EXTRA_STATS /* Some possibilities for the interested user -- mutually exclusive */ #undef FILL_RX_RING_AT_ONCE #undef HW_FLOWCONTROL_NEW /* 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. */ static int full_duplex[MAX_UNITS] = {0, }; static int options[MAX_UNITS] = {0, }; 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[] = { "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", }; /* Set if the PCI BIOS detects the chips on a multiport board backwards. */ #ifdef REVERSE_PROBE_ORDER static int reverse_probe = 1; #else 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 32 #define RX_RING_SIZE 32 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */ #if defined(__alpha__) || defined(__arm__) static int rx_copybreak = 1518; #else static int rx_copybreak = 100; #endif /* Operational parameters that usually are not changed. */ /* Time in jiffies before concluding the transmitter is hung. */ #define TX_TIMEOUT (4*HZ) #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/ /* This is a mysterious value that can be written to CSR11 in the 21040 (only) to support a pre-NWay full-duplex signaling mechanism using short frames. No one knows what it should be, but if left at its default value some 10base2(!) packets trigger a full-duplex-request interrupt. */ #define FULL_DUPLEX_MAGIC 0x6969 #include #include #ifdef MODULE #ifdef MODVERSIONS #include #endif #include #else #define MOD_INC_USE_COUNT #define MOD_DEC_USE_COUNT #endif #include #include #include #include #include #include #include #include #include #include #include #include #include /* Processor type for cache alignment. */ #include #include #include #include /* Kernel compatibility defines, some common to David Hind's PCMCIA package. This is only in the support-all-kernels source code. */ #if defined(MODULE) && LINUX_VERSION_CODE > 0x20115 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(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 >= 0x20100) char kernel_version[] = UTS_RELEASE; #endif #if LINUX_VERSION_CODE < 0x20123 #define hard_smp_processor_id() smp_processor_id() #define test_and_set_bit(val, addr) set_bit(val, addr) #endif #if LINUX_VERSION_CODE <= 0x20139 #define net_device_stats enet_statistics #else #define NETSTATS_VER2 #endif #if LINUX_VERSION_CODE <= 0x20155 || defined(CARDBUS) /* 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 #define tulip_debug debug #ifdef TULIP_DEBUG static int tulip_debug = TULIP_DEBUG; #else static int tulip_debug = 1; #endif #define dma_wback_t(obj) \ dma_cache_wback((unsigned long)(obj), sizeof(*(obj))) #define dma_wback_inv_t(obj) \ dma_cache_wback_inv((unsigned long)(obj), sizeof(*(obj))) #define dma_inv_t(obj) \ dma_cache_inv((unsigned long)(obj), sizeof(*(obj))) /* Theory of Operation I. Board Compatibility This device driver is designed for the DECchip "Tulip", Digital's 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. 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 driver size and complexity. Almost of the increasing complexity is in the board configuration and media selection code. There is very little increasing in the operational critical path length. II. Board-specific settings PCI bus devices are configured by the system at boot time, so no jumpers need to be set on the board. The system BIOS preferably should assign the PCI INTA signal to an otherwise unused system IRQ line. Some boards have EEPROMs tables with default media entry. The factory default 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. III. Driver operation IIIa. Ring buffers The Tulip can use either ring buffers or lists of Tx and Rx descriptors. This driver uses statically allocated rings of Rx and Tx descriptors, set at compile time by RX/TX_RING_SIZE. This version of the driver allocates skbuffs for the Rx ring buffers at open() time and passes the skb->data field to the Tulip 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 and replaced by a newly allocated skbuff. 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. For small frames the copying cost is negligible (esp. considering that we are pre-loading the cache with immediately useful header 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. 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. IIIC. 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 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 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 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. IV. Notes Thanks to Duke Kamstra of SMC for long ago providing an EtherPower board. Greg LaPolla at Linksys provided PNIC and other Linksys boards. Znyx provided a four-port card for testing. IVb. References http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html http://www.digital.com (search for current 21*4* datasheets and "21X4 SROM") http://www.national.com/pf/DP/DP83840.html IVc. Errata The old DEC databooks were light on details. The 21040 databook claims that CSR13, CSR14, and CSR15 should each be the last register of the set CSR12-15 written. Hmmm, now how is that possible? 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. We cannot use MII interrupts because there is no defined GPIO pin to attach them. */ #ifndef PCI_VENDOR_ID_DEC /* Now defined in linux/pci.h */ #define PCI_VENDOR_ID_DEC 0x1011 #endif 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) 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); }; #ifndef CARDBUS static struct pci_id_info pci_tbl[] = { { "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 }, {0}, }; #endif CARD_BUS /* This table use during operation for capabilities and media timer. */ static void tulip_timer(unsigned long data); static void t21142_timer(unsigned long data); static void mxic_timer(unsigned long data); static void pnic_timer(unsigned long data); enum tbl_flag { HAS_MII=1, HAS_MEDIA_TABLE=2, CSR12_IN_SROM=4, ALWAYS_CHECK_MII=8, HAS_ACPI=0x10, }; static struct tulip_chip_table { char *chip_name; int io_size; 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, 0x0001ebef, HAS_MEDIA_TABLE, tulip_timer }, /* { "Digital DS21140 Tulip", 128, 0x0001ebef, */ { "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_ACPI, t21142_timer }, { "Lite-On 82c168 PNIC", 256, 0x0001ebef, HAS_MII, pnic_timer }, { "Macronix 98713 PMAC", 128, 0x0001ebef, HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, mxic_timer }, { "Macronix 98715 PMAC", 256, 0x0001ebef, HAS_MEDIA_TABLE, mxic_timer }, { "Macronix 98725 PMAC", 256, 0x0001ebef, HAS_MEDIA_TABLE, mxic_timer }, { "ASIX AX88140", 128, 0x0001fbff, HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM, tulip_timer }, {0}, }; /* This matches the table above. */ enum chips { DC21040=0, DC21041=1, DC21140=2, DC21142=3, DC21143=3, LC82C168, MX98713, MX98715, MX98725}; /* 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 }; /* 21041 transceiver register settings: 10-T, 10-2, AUI, 10-T, 10T-FD*/ static u16 t21041_csr13[] = { 0xEF05, 0xEF09, 0xEF09, 0xEF01, 0xEF09, }; static u16 t21041_csr14[] = { 0x7F3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, }; static u16 t21142_csr13[] = { 0x0001, 0x0009, 0x0009, 0x0000, 0x0001, }; static u16 t21142_csr14[] = { 0xFFFF, 0x0705, 0x0705, 0x0000, 0x7F3D, }; static u16 t21142_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, }; /* Offsets to the Command and Status Registers, "CSRs". All accesses must be longword instructions and quadword aligned. */ enum tulip_offsets { CSR0=0, CSR1=0x08, CSR2=0x10, CSR3=0x18, CSR4=0x20, CSR5=0x28, CSR6=0x30, CSR7=0x38, CSR8=0x40, CSR9=0x48, CSR10=0x50, CSR11=0x58, CSR12=0x60, CSR13=0x68, CSR14=0x70, CSR15=0x78 }; /* The bits in the CSR5 status registers, mostly interrupt sources. */ enum status_bits { TimerInt=0x800, TPLnkFail=0x1000, TPLnkPass=0x10, NormalIntr=0x10000, AbnormalIntr=0x8000, RxJabber=0x200, RxDied=0x100, RxNoBuf=0x80, RxIntr=0x40, TxFIFOUnderflow=0x20, TxJabber=0x08, TxNoBuf=0x04, TxDied=0x02, TxIntr=0x01, }; enum desc_status_bits { DescOwned=0x80000000, RxDescFatalErr=0x8000, RxWholePkt=0x0300, }; /* The Tulip Rx and Tx buffer descriptors. */ struct tulip_rx_desc { s32 status; s32 length; u32 buffer1, buffer2; }; struct tulip_tx_desc { s32 status; s32 length; u32 buffer1, buffer2; /* We use only buffer 1. */ }; /* Ring-wrap flag in length field, use for last ring entry. 0x01000000 means chain on buffer2 address, 0x02000000 means use the ring start address in CSR2/3. Note: Some work-alike chips do not function correctly in chained mode. */ #define DESC_RING_WRAP 0x02000000 struct medialeaf { u8 type; u8 media; unsigned char *leafdata; }; struct mediatable { u16 defaultmedia; u8 leafcount, csr12dir; /* General purpose pin directions. */ unsigned has_mii:1, has_nonmii:1; struct medialeaf mleaf[0]; }; struct mediainfo { struct mediainfo *next; int info_type; int index; unsigned char *info; }; #ifdef AVE_STATS #define AVE_STATS_VALUES 10 /* 5*2 */ static void ave_get(unsigned long arg); struct ave_estimate { unsigned int rx_packets_5min; unsigned int tx_packets_5min; unsigned int rx_bytes_5min; unsigned int tx_bytes_5min; unsigned int rx_errors_5min; unsigned int tx_errors_5min; unsigned int rx_dropped_5min; unsigned int tx_dropped_5min; unsigned int collisions_5min; unsigned int rx_missed_errors_5min; unsigned long time; }; #endif 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(). */ 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. */ u32 setup_frame[48]; /* Pseudo-Tx frame to init address table. */ int chip_id; int revision; struct net_device_stats stats; #ifdef EXTRA_STATS unsigned long stats_tx_new_refilled; /* # Packets filled with new scheme */ unsigned long stats_tx_old_refilled; /* # Packets filled with old scheme */ #ifdef CONFIG_NET_HW_FLOWCONTROL unsigned long stats_fc_on; /* HW_FLOWCONTROL # of xon's */ #endif unsigned long stats_private_skb_hits; unsigned long stats_private_skb_misses; /*Tulip interrupts causes */ unsigned long stats_intr_normal; unsigned long stats_intr_abnormal; unsigned long stats_intr_rx; unsigned long stats_intr_rx_nobuf; unsigned long stats_intr_tx; unsigned long stats_intr_tx_died; unsigned long stats_intr_tx_nobuf; unsigned long open_time; /* jiffies for last open */ #ifdef PPS_TESTING /* Special for measurement */ unsigned long stats_pktgun_pkts; /* Received pkts frpm packet-gun */ #endif #endif /* EXTRA_STATS */ #ifdef CONFIG_NET_FASTROUTE unsigned long stats_fastroute_hits; unsigned long stats_fastroute_succeed; unsigned long stats_fastroute_deferred; #endif struct timer_list timer; /* Media selection timer. */ #ifdef CONFIG_NET_HW_FLOWCONTROL int fc_bit; #endif #ifdef AVE_STATS struct ave_estimate ave_buf[AVE_STATS_VALUES]; struct timer_list ave_timer; unsigned int ring_p; unsigned int rx_packets_5min; unsigned int tx_packets_5min; unsigned int rx_bytes_5min; unsigned int tx_bytes_5min; unsigned int rx_errors_5min; unsigned int tx_errors_5min; unsigned int rx_dropped_5min; unsigned int tx_dropped_5min; unsigned int collisions_5min; unsigned int rx_missed_errors_5min; #endif int interrupt; /* In-interrupt flag. */ #ifdef SMP_CHECK int smp_proc_id; /* Which processor in IRQ handler. */ #endif 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 tx_full:1; /* The Tx queue is full. */ 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 mediasense:1; /* Media sensing in progress. */ unsigned int csr6; /* Current CSR6 control settings. */ unsigned char eeprom[128]; /* Serial EEPROM contents. */ u16 to_advertise; /* NWay capabilities advertised. */ u16 advertising[4]; signed char phys[4], mii_cnt; /* MII device addresses. */ struct mediatable *mtable; int cur_index; /* Current media index. */ int saved_if_port; unsigned char pci_bus, pci_devfn; int pad0, pad1; /* Used for 8-byte alignment */ }; #if 0 //def CONFIG_PROC_FS int c_time(char *buf, unsigned i); int dev_proc_tulip(char *buf , char **start, off_t offset, int len, int unused); #include static struct proc_dir_entry tulip_proc_entry = { PROC_NET_TULIP, 5, "tulip", S_IFREG | S_IRUGO, 1, 0, 0, 0, NULL, dev_proc_tulip }; #endif static void parse_eeprom(struct device *dev); static int read_eeprom(long ioaddr, int location); 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 void tulip_timer(unsigned long data); 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_rx(struct device *dev); static void tulip_interrupt(int irq, void *dev_instance, struct pt_regs *regs); static void tulip_check_tx_ring(struct device *dev); static void tulip_reconstruct_tx_ring(struct device *dev); static int tulip_close(struct device *dev); static struct net_device_stats *tulip_get_stats(struct device *dev); #ifdef CONFIG_NET_FASTROUTE static int tulip_fast_forward(struct device *dev, int entry, int len); #endif __inline__ static int tx_ring_fill(struct device *dev); __inline__ static int rx_ring_fill(struct device *dev); #ifdef HAVE_PRIVATE_IOCTL static int private_ioctl(struct device *dev, struct ifreq *rq, int cmd); #endif static void set_rx_mode(struct device *dev); #ifdef CONFIG_NET_FASTROUTE #undef FAST_SKB_RECYCLE /* Don't define it-- it's not working yet */ #include #include static int tulip_accept_fastpath(struct device *dev, struct dst_entry *dst); #endif #ifdef FAST_SKB_RECYCLE #define TULIP_RECYCLE_LIST_SIZE 100 /* Max # private buffers */ unsigned long recycle_hits, recycle_misses; __u32 dev_alloc_stats[4]; __u32 frames_per_rx[4]; /* Min, Max, #frames, #rx */ __u32 tx_stats[6]; struct sk_buff_head tulip_recycle_list; static __inline__ void tulip_recycle_skb(struct sk_buff *skb) { if (skb->pkt_type == PACKET_FASTROUTE && skb->type == 1 && tulip_recycle_list.qlen <= TULIP_RECYCLE_LIST_SIZE) { skb->type = 0; skb->tail = skb->data; skb->len = 0; /* LIFO queue */ skb_queue_head(&tulip_recycle_list, skb); } else kfree_skb(skb); } static __inline__ struct sk_buff * get_recycle_skb(unsigned int size) { struct sk_buff *skb; skb = skb_dequeue(&tulip_recycle_list ); if (skb) recycle_hits++; else recycle_misses++; return skb; } #endif #ifdef CONFIG_ARCH_NETWINDER #undef inl #undef outl #define inl(p) readl((p)) #define outl(v,p) writel((v),(p)) #endif /* A list of all installed Tulip devices. */ static struct device *root_tulip_dev = NULL; #ifndef CARDBUS int 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; for (;pci_index < 0xff; pci_index++) { u16 vendor, device, pci_command, new_command; 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); 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); #ifndef CONFIG_ARCH_NETWINDER ioaddr = pdev->base_address[0] & ~3; #else ioaddr = pdev->base_address[1]; #endif 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); #ifdef CONFIG_ARCH_NETWINDER // wms 10.Oct.1999 - ported from 2.0.35 // if Serial ROM not programmed - do not try to use the card // The chip with valid SROM should have "NWTU" in 0x2C { u16 subID; u16 subVenID; pcibios_read_config_word(pci_bus, pci_device_fn, PCI_SUBSYSTEM_ID, &subID); pcibios_read_config_word(pci_bus, pci_device_fn, PCI_SUBSYSTEM_VENDOR_ID, &subVenID); if (subID != 0x5554 || subVenID != 0x574E) { printk(KERN_WARNING "\nTulip Serial ROM needs to be programmed. Device disabled...\n"); continue; } } #endif 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++; } if( cards_found ) { #if 0 //def CONFIG_PROC_FS proc_net_register(&tulip_proc_entry); #endif #ifdef FAST_SKB_RECYCLE if (tulip_recycle_list.next == NULL) skb_queue_head_init(&tulip_recycle_list); #endif } 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 int did_version = 0; /* Already printed version info. */ struct tulip_private *tp; /* 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 */ int i; unsigned short sum; if (tulip_debug > 0 && did_version++ == 0) printk(KERN_INFO "%s", version); dev = init_etherdev(dev, 0); /* Bring the 21143 out of sleep mode. Caution: Snooze mode does not work with some boards! */ if (tulip_tbl[chip_idx].flags & HAS_ACPI) pcibios_write_config_dword(pci_bus, pci_devfn, 0x40, 0x00000000); printk(KERN_INFO "%s: %s at %#3lx,", dev->name, tulip_tbl[chip_idx].chip_name, ioaddr); /* Stop the chip's Tx and Rx processes. */ outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6); /* Clear the missed-packet counter. */ (volatile int)inl(ioaddr + CSR8); if (chip_idx == DC21041) { if (inl(ioaddr + CSR9) & 0x8000) { printk(" 21040 compatible mode,"); chip_idx = DC21040; } else { printk(" 21041 mode,"); } } /* 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. */ sum = 0; if (chip_idx == DC21040) { outl(0, ioaddr + CSR9); /* Reset the pointer with a dummy write. */ for (i = 0; i < 6; i++) { int value, boguscnt = 100000; do value = inl(ioaddr + CSR9); while (value < 0 && --boguscnt > 0); dev->dev_addr[i] = value; sum += value & 0xff; } } else if (chip_idx == LC82C168) { for (i = 0; i < 3; i++) { int value, boguscnt = 100000; outl(0x600 | i, ioaddr + 0x98); do value = inl(ioaddr + CSR9); while (value < 0 && --boguscnt > 0); ((u16*)dev->dev_addr)[i] = value; sum += value & 0xffff; } } else { /* Must be a new chip, with a serial EEPROM interface. */ /* We read the whole EEPROM, and sort it out later. DEC has a specification _Digital Semiconductor 21X4 Serial ROM Format_ but early vendor boards just put the address in the first six EEPROM locations. */ unsigned char ee_data[128]; int sa_offset = 0; for (i = 0; i < sizeof(ee_data)/2; i++) ((u16 *)ee_data)[i] = read_eeprom(ioaddr, i); /* Detect the simple EEPROM format by the duplicated station addr. */ 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) { sa_offset = 2; /* Grrr, damn Matrox boards. */ multiport_cnt = 4; } for (i = 0; i < 6; i ++) { dev->dev_addr[i] = ee_data[i + sa_offset]; sum += ee_data[i + sa_offset]; } } /* Lite-On boards have the address byte-swapped. */ if (dev->dev_addr[0] == 0xA0 && dev->dev_addr[1] == 0x00) for (i = 0; i < 6; i+=2) { char tmp = dev->dev_addr[i]; dev->dev_addr[i] = dev->dev_addr[i+1]; dev->dev_addr[i+1] = tmp; } /* On the Zynx 315 Etherarray and other multiport boards only the first Tulip has an EEPROM. The addresses of the subsequent ports are derived from the first. Many PCI BIOSes also incorrectly report the IRQ line, so we correct that here as well. */ if (sum == 0 || sum == 6*0xff) { printk(" EEPROM not present,"); for (i = 0; i < 5; i++) dev->dev_addr[i] = last_phys_addr[i]; dev->dev_addr[i] = last_phys_addr[i] + 1; #if defined(__i386__) /* This BIOS bug doesn't exist on Alphas. */ irq = last_irq; #endif } for (i = 0; i < 6; i++) printk(" %2.2x", last_phys_addr[i] = dev->dev_addr[i]); 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); dev->base_addr = ioaddr; dev->irq = irq; /* Make certain the data structures are quadword aligned. */ tp = (void *)(((long)kmalloc(sizeof(*tp), GFP_KERNEL | GFP_DMA) + 7) & ~7); memset(tp, 0, sizeof(*tp)); dev->priv = tp; tp->next_module = root_tulip_dev; root_tulip_dev = dev; tp->pci_bus = pci_bus; tp->pci_devfn = pci_devfn; tp->chip_id = chip_idx; #ifdef TULIP_FULL_DUPLEX tp->full_duplex = 1; tp->full_duplex_lock = 1; #endif #ifdef TULIP_DEFAULT_MEDIA tp->default_port = TULIP_DEFAULT_MEDIA; #endif #ifdef TULIP_NO_MEDIA_SWITCH tp->medialock = 1; #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) tp->full_duplex = 1; if (mtu[board_idx] > 0) dev->mtu = mtu[board_idx]; } if (dev->mem_start) tp->default_port = dev->mem_start; if (tp->default_port) { tp->medialock = 1; if (media_cap[tp->default_port] & MediaAlwaysFD) tp->full_duplex = 1; } if (tp->full_duplex) tp->full_duplex_lock = 1; /* This is logically part of probe1(), but too complex to write inline. */ if (tulip_tbl[chip_idx].flags & HAS_MEDIA_TABLE) parse_eeprom(dev); 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 tp->to_advertise = 0x03e1; if ((tulip_tbl[chip_idx].flags & ALWAYS_CHECK_MII) || (tp->mtable && tp->mtable->has_mii) || ( ! tp->mtable && (tulip_tbl[chip_idx].flags & HAS_MII))) { int phy, phy_idx; /* Clear undefined bits that confuse the MII interface. */ if (tp->chip_id == DC21142) #ifndef CONFIG_ARCH_NETWINDER outl(inl(ioaddr+CSR15) & ~(0x800037c0), ioaddr+CSR15); #else { /* wms: set GEP1 and GEP0 outputs, GEP1 led activity */ outl(0x08230008, ioaddr+CSR15); udelay(1); /* set GEP0 HI */ outl(0x00010008, ioaddr+CSR15); udelay(2); /* set GEP0 LO to reset the device */ outl(0x00000008, ioaddr+CSR15); udelay(2); /* set GEP0 HI to end reset */ outl(0x00010008, ioaddr+CSR15); udelay(2); } #endif /* 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++) { int mii_status = mdio_read(dev, phy, 1); if (mii_status != 0xffff && mii_status != 0x0000) { 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; 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) { printk(KERN_DEBUG "%s: Advertising %4.4x on PHY %d," " previously advertising %4.4x.\n", dev->name, reg4, phy, mii_advert); mdio_write(dev, phy, 4, reg4); } /* 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)); } } tp->mii_cnt = phy_idx; if (tp->mtable && tp->mtable->has_mii && phy_idx == 0) { printk(KERN_INFO "%s: ***WARNING***: No MII transceiver found!\n", dev->name); tp->phys[0] = 1; } } /* 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 #ifdef CONFIG_NET_FASTROUTE dev->accept_fastpath = tulip_accept_fastpath; #endif /* Reset the xcvr interface and turn on heartbeat. */ switch (chip_idx) { case DC21041: 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); break; case DC21140: default: if (tp->mtable) outl(tp->mtable->csr12dir | 0x100, ioaddr + CSR12); break; case DC21142: if (tp->mii_cnt) { outl(0x82020000, ioaddr + CSR6); outl(0x0000, ioaddr + CSR13); outl(0x0000, ioaddr + CSR14); outl(0x820E0000, ioaddr + CSR6); } else { outl(0x82420200, ioaddr + CSR6); outl(0x0001, ioaddr + CSR13); outl(0x0003FFFF, ioaddr + CSR14); outl(0x0008, ioaddr + CSR15); outl(0x0001, ioaddr + CSR13); outl(0x1301, ioaddr + CSR12); /* Start NWay. */ } break; case LC82C168: if ( ! tp->mii_cnt) { outl(0x00420000, ioaddr + CSR6); outl(0x30, ioaddr + CSR12); outl(0x0001F078, ioaddr + 0xB8); outl(0x0201F078, ioaddr + 0xB8); /* Turn on autonegotiation. */ } break; case MX98713: case MX98715: case MX98725: outl(0x00000000, ioaddr + CSR6); outl(0x000711C0, ioaddr + CSR14); /* Turn on NWay. */ outl(0x00000001, ioaddr + CSR13); break; } return dev; } /* 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. */ /* Known cards that have old-style EEPROMs. */ static struct fixups { char *name; unsigned char addr0, addr1, addr2; u16 newtable[32]; /* Max length below. */ } eeprom_fixups[] = { {"Asante", 0, 0, 0x94, {0x1e00, 0x0000, 0x0800, 0x0100, 0x018c, 0x0000, 0x0000, 0xe078, 0x0001, 0x0050, 0x0018 }}, {"SMC9332DST", 0, 0, 0xC0, { 0x1e00, 0x0000, 0x0800, 0x021f, 0x0000, 0x009E, /* 10baseT */ 0x0903, 0x006D, /* 100baseTx */ }}, {"Cogent EM100", 0, 0, 0x92, { 0x1e00, 0x0000, 0x0800, 0x033f, 0x0107, 0x8021, /* 100baseFx */ 0x0108, 0x8021, /* 100baseFx-FD */ 0x0103, 0x006D, /* 100baseTx */ }}, {"Maxtech NX-110", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x0313, 0x1001, 0x009E, /* 10base2, CSR12 0x10*/ 0x0000, 0x009E, /* 10baseT */ 0x0303, 0x006D, /* 100baseTx, CSR12 0x03 */ }}, {"Accton EN1207", 0, 0, 0xE8, { 0x1e00, 0x0000, 0x0800, 0x031F, 0x1B01, 0x0000, /* 10base2, CSR12 0x1B */ 0x1B03, 0x006D, /* 100baseTx, CSR12 0x1B */ 0x0B00, 0x009E, /* 10baseT, CSR12 0x0B */ }}, {"Corel", 0, 0x10, 0x57, { 0x1e00, 0x0000, 0x0800, /* default media (autosense) */ 0x8f01, /* 1 media types, first 11 bytes */ 0x0103, 0x0000, 0x0000, 0x01e1 }}, {0, 0, 0, 0, {}}}; static const char * block_name[] = {"21140 non-MII", "21140 MII PHY", "21142 Serial PHY", "21142 MII PHY", "21143 SYM PHY", "21143 reset method"}; #define EEPROM_SIZE 128 #if defined(__i386__) #define get_u16(ptr) (*(u16 *)(ptr)) #else #define get_u16(ptr) (((u8*)(ptr))[0] + (((u8*)(ptr))[1]<<8)) #endif static void parse_eeprom(struct 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; long ioaddr = dev->base_addr; unsigned char *ee_data = tp->eeprom; int i; tp->mtable = 0; for (i = 0; i < EEPROM_SIZE/2; i++) ((u16 *)ee_data)[i] = read_eeprom(ioaddr, i); /* Detect an old-style (SA only) EEPROM layout: memcmp(eedata, eedata+16, 8). */ for (i = 0; i < 8; i ++) if (ee_data[i] != ee_data[16+i]) break; if (i >= 8) { if (ee_data[0] == 0xff) { if (last_mediatable) { controller_index++; printk(KERN_INFO "%s: Controller %d of multiport board.\n", dev->name, controller_index); tp->mtable = last_mediatable; ee_data = last_ee_data; goto subsequent_board; } else printk(KERN_INFO "%s: Missing EEPROM, this interface may " "not work correctly!\n", 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; } } if (eeprom_fixups[i].name == NULL) { /* No fixup found. */ printk(KERN_INFO "%s: Old style EEPROM -- no media selection information.\n", dev->name); return; } } if (tulip_debug > 1) { printk(KERN_DEBUG "read_eeprom:"); for (i = 0; i < 64; i++) { printk("%s%4.4x", (i & 7) == 0 ? "\n" KERN_DEBUG : " ", read_eeprom(ioaddr, i)); } printk("\n"); } controller_index = 0; if (ee_data[19] > 1) { /* Multiport board. */ last_ee_data = ee_data; } subsequent_board: 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]; short media; int count; media = get_u16(p); p += 2; count = *p++; printk(KERN_INFO "%s:21041 Media information at %d, default media " "%4.4x (%s).\n", dev->name, ee_data[27], media, media & 0x0800 ? "Autosense" : medianame[media & 15]); for (i = 0; i < count; i++) { unsigned char media_code = *p++; u16 csrvals[3]; int idx; for (idx = 0; idx < 3; idx++) { csrvals[idx] = get_u16(p); p += 2; } if (media_code & 0x40) { printk(KERN_INFO "%s: 21041 media %2.2x (%s)," " csr13 %4.4x csr14 %4.4x csr15 %4.4x.\n", dev->name, media_code & 15, medianame[media_code & 15], csrvals[0], csrvals[1], csrvals[2]); } else printk(KERN_INFO "%s: 21041 media #%d, %s.\n", dev->name, media_code & 15, medianame[media_code & 15]); } } else { unsigned char *p = (void *)ee_data + ee_data[27]; unsigned char csr12dir = 0; int count; struct mediatable *mtable; u16 media = get_u16(p); p += 2; if (tulip_tbl[tp->chip_id].flags & CSR12_IN_SROM) csr12dir = *p++; count = *p++; mtable = (struct mediatable *) kmalloc(sizeof(struct mediatable) + count*sizeof(struct medialeaf), GFP_KERNEL); if (mtable == NULL) return; /* Horrible, impossible failure. */ last_mediatable = tp->mtable = mtable; mtable->defaultmedia = media; mtable->leafcount = count; mtable->csr12dir = csr12dir; mtable->has_nonmii = mtable->has_mii = 0; printk(KERN_INFO "%s: EEPROM default media type %s.\n", dev->name, media & 0x0800 ? "Autosense" : medianame[media & 15]); for (i = 0; i < count; i++) { struct medialeaf *leaf = &mtable->mleaf[i]; if ((p[0] & 0x80) == 0) { /* 21140 Compact block. */ leaf->type = 0; leaf->media = p[0] & 0x3f; leaf->leafdata = p; if ((p[2] & 0x61) == 0x01) /* Bogus, but Znyx boards do it. */ mtable->has_mii = 1; p += 4; } else { leaf->type = p[1]; if (p[1] & 1) { mtable->has_mii = 1; leaf->media = 11; } else { mtable->has_nonmii = 1; leaf->media = p[2] & 0x0f; } leaf->leafdata = p + 2; p += (p[0] & 0x3f) + 1; } if (tulip_debug > 1 && leaf->media == 11) { unsigned char *bp = leaf->leafdata; printk(KERN_INFO "%s: MII interface PHY %d, setup/reset " "sequences %d/%d long, capabilities %2.2x %2.2x.\n", dev->name, bp[0], bp[1], bp[2 + bp[1]*2], bp[5 + bp[2 + bp[1]*2]*2], bp[4 + bp[2 + bp[1]*2]*2]); } 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); } } } /* Reading a serial EEPROM is a "bit" grungy, but we work our way through:->.*/ /* EEPROM_Ctrl bits. */ #define EE_SHIFT_CLK 0x02 /* EEPROM shift clock. */ #define EE_CS 0x01 /* EEPROM chip select. */ #define EE_DATA_WRITE 0x04 /* EEPROM chip data in. */ #define EE_WRITE_0 0x01 #define EE_WRITE_1 0x05 #define EE_DATA_READ 0x08 /* EEPROM chip data out. */ #define EE_ENB (0x4800 | EE_CS) /* Delay between EEPROM clock transitions. Even at 33Mhz current PCI implementations don't overrun the EEPROM clock. We add a bus turn-around to insure that this remains true. */ #define eeprom_delay() inl(ee_addr) /* The EEPROM commands include the alway-set leading bit. */ #define EE_WRITE_CMD (5 << 6) #define EE_READ_CMD (6 << 6) #define EE_ERASE_CMD (7 << 6) static int read_eeprom(long ioaddr, int location) { int i; unsigned short retval = 0; long ee_addr = ioaddr + CSR9; int read_cmd = location | EE_READ_CMD; outl(EE_ENB & ~EE_CS, ee_addr); outl(EE_ENB, ee_addr); /* Shift the read command bits out. */ for (i = 10; i >= 0; i--) { short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; outl(EE_ENB | dataval, ee_addr); eeprom_delay(); outl(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr); eeprom_delay(); } outl(EE_ENB, ee_addr); for (i = 16; i > 0; i--) { outl(EE_ENB | EE_SHIFT_CLK, ee_addr); eeprom_delay(); retval = (retval << 1) | ((inl(ee_addr) & EE_DATA_READ) ? 1 : 0); outl(EE_ENB, ee_addr); eeprom_delay(); } /* Terminate the EEPROM access. */ outl(EE_ENB & ~EE_CS, 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 PCI I/O cycles, but we insert a delay to avoid "overclocking" issues or future 66Mhz PCI. */ #define mdio_delay() inl(mdio_addr) /* Read and write the MII registers using software-generated serial MDIO protocol. It is just different enough from the EEPROM protocol to not share code. The maxium data clock rate is 2.5 Mhz. */ #define MDIO_SHIFT_CLK 0x10000 #define MDIO_DATA_WRITE0 0x00000 #define MDIO_DATA_WRITE1 0x20000 #define MDIO_ENB 0x00000 /* Ignore the 0x02000 databook setting. */ #define MDIO_ENB_IN 0x40000 #define MDIO_DATA_READ 0x80000 static int mdio_read(struct 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 retval = 0; long mdio_addr = dev->base_addr + CSR9; if (tp->chip_id == LC82C168) { long ioaddr = dev->base_addr; int i = 1000; outl(0x60020000 + (phy_id<<23) + (location<<18), ioaddr + 0xA0); inl(ioaddr + 0xA0); inl(ioaddr + 0xA0); while (--i > 0) if ( ! ((retval = inl(ioaddr + 0xA0)) & 0x80000000)) return retval & 0xffff; return 0xffff; } /* Establish sync by sending at least 32 logic ones. */ for (i = 32; i >= 0; i--) { outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr); mdio_delay(); outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } /* Shift the read command bits out. */ for (i = 15; i >= 0; i--) { int dataval = (read_cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0; outl(MDIO_ENB | dataval, mdio_addr); mdio_delay(); outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } /* Read the two transition, 16 data, and wire-idle bits. */ for (i = 19; i > 0; i--) { outl(MDIO_ENB_IN, mdio_addr); mdio_delay(); retval = (retval << 1) | ((inl(mdio_addr) & MDIO_DATA_READ) ? 1 : 0); outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } return (retval>>1) & 0xffff; } static void mdio_write(struct device *dev, int phy_id, int location, int value) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int i; int cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value; long mdio_addr = dev->base_addr + CSR9; if (tp->chip_id == LC82C168) { long ioaddr = dev->base_addr; int i = 1000; outl(cmd, ioaddr + 0xA0); do if ( ! (inl(ioaddr + 0xA0) & 0x80000000)) break; while (--i > 0); return; } /* Establish sync by sending 32 logic ones. */ for (i = 32; i >= 0; i--) { outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr); mdio_delay(); outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } /* Shift the command bits out. */ for (i = 31; i >= 0; i--) { int dataval = (cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0; outl(MDIO_ENB | dataval, mdio_addr); mdio_delay(); outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } /* Clear out extra bits. */ for (i = 2; i > 0; i--) { outl(MDIO_ENB_IN, mdio_addr); mdio_delay(); outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr); mdio_delay(); } return; } #ifdef CONFIG_NET_HW_FLOWCONTROL /* Enable receiver */ void tulip_xon(struct device *dev) { struct tulip_private *lp = (struct tulip_private *)dev->priv; clear_bit(lp->fc_bit, &netdev_fc_xoff); if (dev->start) { #ifndef HW_FLOWCONTROL_NEW outl(lp->csr6 | 0x2002, dev->base_addr + CSR6); #else rx_ring_fill(dev); #endif #ifdef EXTRA_STATS lp->stats_fc_on++; #endif } } #endif static int tulip_open(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int i; /* On some chip revs we must set the MII/SYM port before the reset!? */ if (tp->mii_cnt || (tp->mtable && tp->mtable->has_mii)) outl(0x00040000, ioaddr + CSR6); /* 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; /* Deassert reset. 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 No alignment 0x00000000 unlimited 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(__alpha__) /* ToDo: Alpha setting could be better. */ outl(0x01A00000 | 0xE000, ioaddr + CSR0); #elif defined(__powerpc__) outl(0x01A00080 | 0x8000, ioaddr + CSR0); #elif defined(__arm__) outl(0x01A00000 | 0x4800, ioaddr + CSR0); #elif defined(__i386__) #if defined(MODULE) /* When a module we don't have 'x86' to check. */ outl(0x01A00000 | 0x4800, ioaddr + CSR0); #else #if (LINUX_VERSION_CODE > 0x2014c) #define x86 boot_cpu_data.x86 #endif outl(0x01A00000 | (x86 <= 4 ? 0x4800 : 0x8000), ioaddr + CSR0); if (x86 <= 4) printk(KERN_INFO "%s: This is a 386/486 PCI system, setting cache " "alignment to %x.\n", dev->name, 0x01A00000 | (x86 <= 4 ? 0x4800 : 0x8000)); #endif #else outl(0x01A00000 | 0x4800, ioaddr + CSR0); #warning Processor architecture undefined! #endif if (tulip_debug > 1) printk(KERN_DEBUG "%s: tulip_open() irq %d.\n", dev->name, dev->irq); tulip_init_ring(dev); /* This is set_rx_mode(), but without starting the transmitter. */ /* Fill the whole address filter table with our physical address. */ { u16 *eaddrs = (u16 *)dev->dev_addr; u32 *setup_frm = tp->setup_frame, i; /* You must add the broadcast address when doing perfect filtering! */ *setup_frm++ = 0xffff; *setup_frm++ = 0xffff; *setup_frm++ = 0xffff; /* Fill the rest of the accept table with our physical address. */ for (i = 1; i < 16; i++) { *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[2]; } /* Put the setup frame on the Tx list. */ tp->tx_ring[0].length = 0x08000000 | 192; tp->tx_ring[0].buffer1 = virt_to_bus(tp->setup_frame); tp->tx_ring[0].status = 0x80000000; tp->cur_tx++; } /*RMK: flush cache */ dma_wback_t(tp); outl(virt_to_bus(tp->rx_ring), ioaddr + CSR3); outl(virt_to_bus(tp->tx_ring), ioaddr + CSR4); tp->saved_if_port = dev->if_port; if (dev->if_port == 0) dev->if_port = tp->default_port; if (tp->chip_id == DC21041 && dev->if_port > 4) /* Invalid: Select initial TP, autosense, autonegotiate. */ dev->if_port = 4; /* Allow selecting a default media. */ i = 0; if (tp->mtable == NULL) goto media_picked; if (dev->if_port) { int looking_for = media_cap[dev->if_port] & MediaIsMII ? 11 : (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]); goto media_picked; } } if ((tp->mtable->defaultmedia & 0x0800) == 0) for (i = 0; i < tp->mtable->leafcount; i++) if (tp->mtable->mleaf[i].media == (tp->mtable->defaultmedia & 15)) { printk(KERN_INFO "%s: Using EEPROM-set media %s.\n", dev->name, medianame[tp->mtable->mleaf[i].media]); goto media_picked; } /* Start sensing first non-full-duplex media. */ for (i = tp->mtable->leafcount - 1; (media_cap[tp->mtable->mleaf[i].media] & MediaAlwaysFD) && i > 0; i--) ; media_picked: tp->csr6 = 0; tp->cur_index = i; if (dev->if_port == 0 && tp->chip_id == DC21142) { if (tp->mii_cnt) { if (tulip_debug > 1) printk(KERN_INFO "%s: Using MII transceiver %d, status " "%4.4x.\n", dev->name, tp->phys[0], mdio_read(dev, tp->phys[0], 1)); select_media(dev, 1); outl(0x82020000, ioaddr + CSR6); tp->csr6 = 0x820E0000; dev->if_port = 11; outl(0x0000, ioaddr + CSR13); outl(0x0000, ioaddr + CSR14); #ifndef CONFIG_ARCH_NETWINDER outl(0x0008, ioaddr + CSR15); #else /* wms: keep the GEP0 reset pin HI */ outl(0x10008, ioaddr + CSR15); #endif } else { if (tulip_debug > 1) printk(KERN_INFO "%s: Using default 21143 media sense.\n", dev->name); tp->csr6 = 0x82420200; outl(0x0003FFFF, ioaddr + CSR14); outl(0x0008, ioaddr + CSR15); outl(0x0001, ioaddr + CSR13); outl(0x1301, ioaddr + CSR12); } } else if (tp->chip_id == LC82C168 && tp->mii_cnt && ! tp->medialock) { dev->if_port = 11; tp->csr6 = 0x816C0000 | (tp->full_duplex ? 0x0200 : 0); outl(0x0001, ioaddr + CSR15); } else if (tp->chip_id == MX98713 && ! tp->medialock) { dev->if_port = 0; tp->csr6 = 0x01a80000 | (tp->full_duplex ? 0x0200 : 0); outl(0x0f370000 | inw(ioaddr + 0x80), ioaddr + 0x80); } 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); /* printk( "Setting interrrupt mask 0x%x\n", tulip_tbl[tp->chip_id].valid_intrs); */ outl(tp->csr6 | 0x2002, ioaddr + CSR6); outl(0, ioaddr + CSR2); /* Rx poll demand */ /* 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(5*HZ); tp->timer.data = (unsigned long)dev; tp->timer.function = tulip_tbl[tp->chip_id].media_timer; add_timer(&tp->timer); #ifdef AVE_STATS { int p1; for(p1=0; p1< AVE_STATS_VALUES; p1++) tp->ave_buf[p1].time= jiffies; tp->ring_p = 0; init_timer(&tp->ave_timer); tp->ave_timer.expires = jiffies + 1*HZ; tp->ave_timer.function = ave_get; tp->ave_timer.data = (unsigned long) tp; add_timer(&tp->ave_timer); } #endif #ifdef EXTRA_STATS dev->trans_start = dev->last_rx = tp->open_time = jiffies; #endif #ifdef CONFIG_NET_HW_FLOWCONTROL tp->fc_bit = netdev_register_fc(dev, tulip_xon); #endif #ifdef CONFIG_NET_FASTROUTE dev->tx_semaphore = 1; #endif if (tulip_debug > 2) { printk(KERN_DEBUG "%s: Done tulip_open(), CSR0 %8.8x, CSR5 %8.8x CSR6 %8.8x.\n", dev->name, (unsigned int)inl(ioaddr + CSR0), (unsigned int)inl(ioaddr + CSR5), (unsigned int)inl(ioaddr + CSR6)); } return 0; } /* Set up the transceiver control registers for the selected media type. */ static void select_media(struct device *dev, int startup) { long ioaddr = dev->base_addr; struct tulip_private *tp = (struct tulip_private *)dev->priv; struct mediatable *mtable = tp->mtable; u32 new_csr6; int check_mii =0, i; if (mtable) { struct medialeaf *mleaf = &mtable->mleaf[tp->cur_index]; unsigned char *p = mleaf->leafdata; switch (mleaf->type) { case 0: /* 21140 non-MII xcvr. */ if (tulip_debug > 1) printk(KERN_DEBUG "%s: Using a 21140 non-MII transceiver" " with control setting %2.2x.\n", dev->name, p[1]); dev->if_port = p[0]; if (startup) outl(mtable->csr12dir | 0x100, ioaddr + CSR12); outl(p[1], ioaddr + CSR12); new_csr6 = 0x02000000 | ((p[2] & 0x71) << 18); break; case 2: case 4: { u16 setup[3]; for (i = 0; i < 3; i++) setup[i] = get_u16(&p[i*2 + 1]); dev->if_port = p[0] & 15; if (tulip_debug > 1) printk(KERN_DEBUG "%s: 21143 non-MII %s transceiver control %4.4x/%4.4x.\n", dev->name, medianame[dev->if_port], setup[0], setup[1]); if (p[0] & 0x40) { /* SIA (CSR13-15) setup values are provided. */ outl(0, ioaddr + CSR13); outl(setup[1], ioaddr + CSR14); outl(setup[2], ioaddr + CSR15); outl(setup[0], ioaddr + CSR13); for (i = 0; i < 3; i++) /* Re-fill setup[] */ setup[i] = get_u16(&p[i*2 + 7]); } else if (dev->if_port <= 4) { outl(0, ioaddr + CSR13); outl(t21142_csr14[dev->if_port], ioaddr + CSR14); outl(t21142_csr15[dev->if_port], ioaddr + CSR15); outl(t21142_csr13[dev->if_port], ioaddr + CSR13); } else { outl(0, ioaddr + CSR14); outl(8, ioaddr + CSR15); outl(0, ioaddr + CSR13); } outl(setup[0]<<16, ioaddr + CSR15); /* Direction */ outl(setup[1]<<16, ioaddr + CSR15); /* Data */ if (mleaf->type == 4) new_csr6 = 0x82020000 | ((setup[2] & 0x71) << 18); else new_csr6 = 0x82420000; break; } case 1: case 3: { int phy_num = p[0]; int init_length = p[1]; u16 *misc_info; u16 to_advertise; dev->if_port = 11; check_mii = 1; new_csr6 = 0x020E0000; if (mleaf->type == 3) { /* 21142 */ u16 *init_sequence = (u16*)(p+2); u16 *reset_sequence = &((u16*)(p+3))[init_length]; int reset_length = p[2 + init_length*2]; misc_info = reset_sequence + reset_length; if (startup) for (i = 0; i < reset_length; i++) outl(get_u16(&reset_sequence[i]) << 16, ioaddr + CSR15); for (i = 0; i < init_length; i++) outl(get_u16(&init_sequence[i]) << 16, ioaddr + CSR15); } else { u8 *init_sequence = p + 2; u8 *reset_sequence = p + 3 + init_length; int reset_length = p[2 + init_length]; misc_info = (u16*)(reset_sequence + reset_length); if (startup) { outl(mtable->csr12dir | 0x100, ioaddr + CSR12); for (i = 0; i < reset_length; i++) outl(reset_sequence[i], ioaddr + CSR12); } 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 || 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); break; } default: new_csr6 = 0x020E0000; } if (tulip_debug > 1) printk(KERN_DEBUG "%s: Using media type %s, CSR12 is %2.2x.\n", dev->name, medianame[dev->if_port], (unsigned int)inl(ioaddr + CSR12) & 0xff); } else if (tp->chip_id == DC21041) { if (tulip_debug > 1) printk(KERN_DEBUG "%s: 21041 using media %s, CSR12 is %4.4x.\n", dev->name, medianame[dev->if_port & 15], (unsigned int)inl(ioaddr + CSR12) & 0xffff); outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */ outl(t21041_csr14[dev->if_port], ioaddr + CSR14); outl(t21041_csr15[dev->if_port], ioaddr + CSR15); outl(t21041_csr13[dev->if_port], ioaddr + CSR13); new_csr6 = 0x80020000; } else if (tp->chip_id == LC82C168) { if (startup && ! tp->medialock) dev->if_port = tp->mii_cnt ? 11 : 0; if (tulip_debug > 1) printk(KERN_DEBUG "%s: PNIC PHY status is %3.3x, CSR12 %4.4x," " media %s.\n", dev->name, (unsigned int)inl(ioaddr + 0xB8), (unsigned int)inl(ioaddr + CSR12), medianame[dev->if_port]); if (tp->mii_cnt) { new_csr6 = 0x812C0000; outl(0x0001, ioaddr + CSR15); outl(0x0201B07A, ioaddr + 0xB8); } else if (startup) { /* Start with 10mbps to do autonegotiation. */ outl(0x32, ioaddr + CSR12); new_csr6 = 0x00420000; outl(0x0001B078, ioaddr + 0xB8); outl(0x0201B078, ioaddr + 0xB8); } else if (dev->if_port == 3 || dev->if_port == 5) { outl(0x33, ioaddr + CSR12); new_csr6 = 0x01860000; if (startup) outl(0x0201F868, ioaddr + 0xB8); /* Trigger autonegotiation. */ else outl(0x1F868, ioaddr + 0xB8); } else { outl(0x32, ioaddr + CSR12); new_csr6 = 0x00420000; outl(0x1F078, ioaddr + 0xB8); } } else if (tp->chip_id == DC21040) { /* 21040 */ /* Turn on the xcvr interface. */ int csr12 = inl(ioaddr + CSR12); if (tulip_debug > 1) printk(KERN_DEBUG "%s: 21040 media type is %s, CSR12 is %2.2x.\n", dev->name, dev->if_port ? "AUI" : "10baseT", csr12); new_csr6 = (dev->if_port ? 0x01860000 : 0x00420000); /* Set the full duplux match frame. */ outl(FULL_DUPLEX_MAGIC, ioaddr + CSR11); outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */ outl(dev->if_port ? 0x0000000C : 0x00000004, ioaddr + CSR13); } else { /* Unknown chip type with no media table. */ if (tp->default_port == 0) { if (tp->mii_cnt) { dev->if_port = 11; } else dev->if_port = 3; } if (media_cap[dev->if_port] & MediaIsMII) { new_csr6 = 0x020E0000; } else if (media_cap[dev->if_port] & MediaIsFx) { new_csr6 = 0x028600000; } else new_csr6 = 0x038600000; 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], (unsigned int)inl(ioaddr + CSR12)); } tp->csr6 = new_csr6 | (tp->csr6 & 0xfdff) | (tp->full_duplex ? 0x0200 : 0); return; } static void tulip_timer(unsigned long data) { struct device *dev = (struct device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; u32 csr12 = inl(ioaddr + CSR12); int next_tick = 0; if (tulip_debug > 3) { printk(KERN_DEBUG "%s: Media selection tick, status %8.8x mode %8.8x " "SIA %8.8x %8.8x %8.8x %8.8x.\n", dev->name, (unsigned int)inl(ioaddr + CSR5), (unsigned int)inl(ioaddr + CSR6), csr12, (unsigned int)inl(ioaddr + CSR13), (unsigned int)inl(ioaddr + CSR14), (unsigned int)inl(ioaddr + CSR15)); } switch (tp->chip_id) { case DC21040: if (csr12 & 0x0002) { /* Network error */ printk(KERN_INFO "%s: No 10baseT link beat found, switching to %s media.\n", dev->name, dev->if_port ? "10baseT" : "AUI"); dev->if_port ^= 1; outl(dev->if_port ? 0x0000000C : 0x00000004, ioaddr + CSR13); dev->trans_start = jiffies; } break; case DC21041: if (tulip_debug > 2) printk(KERN_DEBUG "%s: 21041 media tick CSR12 %8.8x.\n", dev->name, csr12); switch (dev->if_port) { case 0: case 3: case 4: if (csr12 & 0x0004) { /*LnkFail */ /* 10baseT is dead. Check for activity on alternate port. */ tp->mediasense = 1; if (csr12 & 0x0200) dev->if_port = 2; else dev->if_port = 1; printk(KERN_INFO "%s: No 21041 10baseT link beat, Media switched to %s.\n", dev->name, medianame[dev->if_port]); outl(0, ioaddr + CSR13); /* Reset */ outl(t21041_csr14[dev->if_port], ioaddr + CSR14); outl(t21041_csr15[dev->if_port], ioaddr + CSR15); outl(t21041_csr13[dev->if_port], ioaddr + CSR13); next_tick = 10*HZ; /* 2.4 sec. */ } else next_tick = 30*HZ; break; case 1: /* 10base2 */ case 2: /* AUI */ if (csr12 & 0x0100) { next_tick = (30*HZ); /* 30 sec. */ tp->mediasense = 0; } else if ((csr12 & 0x0004) == 0) { printk(KERN_INFO "%s: 21041 media switched to 10baseT.\n", dev->name); dev->if_port = 0; select_media(dev, 0); next_tick = (24*HZ)/10; /* 2.4 sec. */ } else if (tp->mediasense || (csr12 & 0x0002)) { dev->if_port = 3 - dev->if_port; /* Swap ports. */ select_media(dev, 0); next_tick = 20*HZ; } else { next_tick = 20*HZ; } break; } break; case DC21140: case DC21142: case MX98713: default: { struct medialeaf *mleaf; unsigned char *p; if (tp->mtable == NULL) { /* No EEPROM info, use generic code. */ /* Not much that can be done. Assume this a generic MII or SYM transceiver. */ next_tick = 60*HZ; if (tulip_debug > 2) printk(KERN_DEBUG "%s: network media monitor CSR6 %8.8x " "CSR12 0x%2.2x.\n", dev->name, (unsigned int)inl(ioaddr + CSR6), csr12 & 0xff); break; } mleaf = &tp->mtable->mleaf[tp->cur_index]; p = mleaf->leafdata; switch (mleaf->type) { case 0: case 4: { /* Type 0 serial or 4 SYM transceiver. Check the link beat bit. */ int offset = mleaf->type == 4 ? 5 : 2; s8 bitnum = p[offset]; if (p[offset+1] & 0x80) { if (tulip_debug > 1) printk(KERN_DEBUG"%s: Transceiver monitor tick " "CSR12=%#2.2x, no media sense.\n", dev->name, csr12); if (mleaf->type == 4) { if (mleaf->media == 3 && (csr12 & 0x02)) goto select_next_media; } break; } if (tulip_debug > 2) printk(KERN_DEBUG "%s: Transceiver monitor tick: CSR12=%#2.2x" " bit %d is %d, expecting %d.\n", dev->name, csr12, (bitnum >> 1) & 7, (csr12 & (1 << ((bitnum >> 1) & 7))) != 0, (bitnum >= 0)); /* Check that the specified bit has the proper value. */ if ((bitnum < 0) != ((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]); if ((p[2] & 0x61) == 0x01) /* Bogus Znyx board. */ goto actually_mii; break; } if (tp->medialock) break; select_next_media: if (--tp->cur_index < 0) { /* We start again, but should instead look for default. */ tp->cur_index = tp->mtable->leafcount - 1; } dev->if_port = tp->mtable->mleaf[tp->cur_index].media; if (media_cap[dev->if_port] & MediaIsFD) goto select_next_media; /* Skip FD entries. */ 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], 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); next_tick = (24*HZ)/10; break; } case 1: case 3: { /* 21140, 21142 MII */ int mii_reg1, mii_reg5; actually_mii: mii_reg1 = mdio_read(dev, tp->phys[0], 1); mii_reg5 = mdio_read(dev, tp->phys[0], 5); if (tulip_debug > 1) printk(KERN_INFO "%s: MII status %4.4x, Link partner report " "%4.4x, CSR12 %2.2x, %cD.\n", dev->name, mii_reg1, mii_reg5, csr12, tp->full_duplex ? 'F' : 'H'); if (mii_reg1 != 0xffff && (mii_reg1 & 0x0004) == 0) { int new_reg1 = mdio_read(dev, tp->phys[0], 1); if ((new_reg1 & 0x0004) == 0) { printk(KERN_INFO "%s: No link beat on the MII interface," " status then %4.4x now %4.4x.\n", dev->name, mii_reg1, new_reg1); if (tp->mtable && tp->mtable->has_nonmii) goto select_next_media; } } if (mii_reg5 == 0xffff || mii_reg5 == 0x0000) ; /* No MII device or no link partner report */ else if (tp->full_duplex_lock) ; else { int negotiated = mii_reg5 & tp->advertising[0]; int duplex = ((negotiated & 0x0100) != 0 || (negotiated & 0x00C0) == 0x0040); /* 100baseTx-FD or 10T-FD, but not 100-HD */ if (tp->full_duplex != duplex) { tp->full_duplex = duplex; if (tp->full_duplex) tp->csr6 |= 0x0200; else tp->csr6 &= ~0x0200; outl(tp->csr6 | 0x0002, ioaddr + CSR6); outl(tp->csr6 | 0x2002, ioaddr + CSR6); if (tulip_debug > 0) /* Gurppp, should be >1 */ printk(KERN_INFO "%s: Setting %s-duplex based on MII" " Xcvr #%d parter capability of %4.4x.\n", dev->name, tp->full_duplex ? "full" : "half", tp->phys[0], mii_reg5); } } next_tick = 60*HZ; break; } case 2: /* 21142 serial block has no link beat. */ default: break; } } break; } if (next_tick) { tp->timer.expires = RUN_AT(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) { struct device *dev = (struct device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int csr12 = inl(ioaddr + CSR12); int next_tick = 60*HZ; int new_csr6 = 0; if (tulip_debug > 1) printk(KERN_INFO"%s: 21143 negotiation status %8.8x, %s.\n", dev->name, csr12, medianame[dev->if_port]); if (media_cap[dev->if_port] & MediaIsMII) { int mii_reg1 = mdio_read(dev, tp->phys[0], 1); int mii_reg5 = mdio_read(dev, tp->phys[0], 5); if (tulip_debug > 1) printk(KERN_INFO "%s: MII status %4.4x, Link partner report " "%4.4x, CSR6 %x.\n", dev->name, mii_reg1, mii_reg5, (unsigned int)inl(ioaddr + CSR6)); if (mii_reg1 != 0xffff && (mii_reg1 & 0x0004) == 0) { int new_reg1 = mdio_read(dev, tp->phys[0], 1); if ((new_reg1 & 0x0004) == 0) { printk(KERN_INFO "%s: No link beat on the MII interface," " status then %4.4x now %4.4x.\n", dev->name, mii_reg1, new_reg1); } if (tp->full_duplex_lock) ; else { int negotiated = mii_reg5 & tp->advertising[0]; int duplex = ((negotiated & 0x0100) != 0 || (negotiated & 0x00C0) == 0x0040); /* 100baseTx-FD or 10T-FD, but not 100-HD */ if (tp->full_duplex != duplex) { tp->full_duplex = duplex; if (tp->full_duplex) tp->csr6 |= 0x0200; else tp->csr6 &= ~0x0200; outl(tp->csr6 | 0x0002, ioaddr + CSR6); outl(tp->csr6 | 0x2002, ioaddr + CSR6); if (tulip_debug > 0) printk(KERN_INFO "%s: Setting %s-duplex based on MII" " Xcvr #%d parter capability of %4.4x.\n", dev->name, tp->full_duplex ? "full" : "half", tp->phys[0], mii_reg5); } } next_tick = 60*HZ; } } else if (dev->if_port == 3) { if (csr12 & 2) { /* No 100mbps link beat, revert to 10mbps. */ new_csr6 = 0x82420200; outl(new_csr6, ioaddr + CSR6); outl(0x0000, ioaddr + CSR13); outl(0x0003FFFF, ioaddr + CSR14); #ifndef CONFIG_ARCH_NETWINDER outl(0x0008, ioaddr + CSR15); #else /* wms: keep the GEP0 reset pin HI */ outl(0x10008, ioaddr + CSR15); #endif outl(0x0001, ioaddr + CSR13); outl(0x1301, ioaddr + CSR12); /* Start NWay. */ } } else if ((csr12 & 0x7000) != 0x5000) { /* Negotiation failed. Search media types. */ if (tulip_debug > 1) printk(KERN_INFO"%s: 21143 negotiation failed, status %8.8x.\n", dev->name, csr12); if (!(csr12 & 4)) { /* 10mbps link beat good. */ new_csr6 = 0x82420000; dev->if_port = 0; outl(0, ioaddr + CSR13); outl(0x0003FFFF, ioaddr + CSR14); #ifndef CONFIG_ARCH_NETWINDER outl(t21142_csr15[dev->if_port], ioaddr + CSR15); #else /* wms: keep the GEP0 reset pin HI */ outl(t21142_csr15[dev->if_port] | 0x10000, ioaddr + CSR15); #endif outl(t21142_csr13[dev->if_port], ioaddr + CSR13); } else if (csr12 & 0x100) { new_csr6 = 0x82420200; dev->if_port = 2; outl(0, ioaddr + CSR13); outl(0x0003FFFF, ioaddr + CSR14); #ifndef CONFIG_ARCH_NETWINDER outl(0x0008, ioaddr + CSR15); #else /* wms: keep the GEP0 reset pin HI */ outl(0x10008, ioaddr + CSR15); #endif outl(0x0001, ioaddr + CSR13); } else { /* Select 100mbps port to check for link beat. */ new_csr6 = 0x83860000; dev->if_port = 3; outl(0, ioaddr + CSR13); outl(0x0003FF7F, ioaddr + CSR14); #ifndef CONFIG_ARCH_NETWINDER outl(8, ioaddr + CSR15); #else /* wms: keep the GEP0 reset pin HI */ outl(0x10008, ioaddr + CSR15); #endif outl(1, ioaddr + CSR13); } 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; tp->csr6 |= new_csr6; outl(0x0301, ioaddr + CSR12); outl(tp->csr6 | 0x0002, ioaddr + CSR6); outl(tp->csr6 | 0x2002, ioaddr + CSR6); } } tp->timer.expires = RUN_AT(next_tick); add_timer(&tp->timer); } static void t21142_lnk_change( struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int csr12 = inl(ioaddr + CSR12); if (tulip_debug > 1) printk(KERN_INFO"%s: 21143 link status interrupt %8.8x, CSR5 %x.\n", dev->name, csr12, (unsigned int)inl(ioaddr + CSR5)); if ((csr12 & 0x7000) == 0x5000) { if (csr12 & 0x01800000) { /* Switch to 100mbps mode. */ outl(tp->csr6 | 0x0002, ioaddr + CSR6); if (csr12 & 0x01000000) { dev->if_port = 5; tp->csr6 = 0x83860200; } else { dev->if_port = 3; tp->csr6 = 0x83860000; } outl(tp->csr6 | 0x2002, ioaddr + CSR6); } /* Else 10baseT-FD is handled automatically. */ } else if (dev->if_port == 3) { if (!(csr12 & 2)) printk(KERN_INFO"%s: 21143 100baseTx link beat good.\n", dev->name); else dev->if_port = 0; } else if (dev->if_port == 0) { if (!(csr12 & 4)) printk(KERN_INFO"%s: 21143 10baseT link beat good.\n", dev->name); } else if (!(csr12 & 4)) { /* 10mbps link beat good. */ printk(KERN_INFO"%s: 21143 10mpbs sensed media.\n", dev->name); dev->if_port = 0; } else { /* 100mbps link beat good. */ printk(KERN_INFO"%s: 21143 100baseTx sensed media.\n", dev->name); dev->if_port = 3; tp->csr6 = 0x83860000; outl(0x0003FF7F, ioaddr + CSR14); outl(0x0301, ioaddr + CSR12); outl(tp->csr6 | 0x0002, ioaddr + CSR6); outl(tp->csr6 | 0x2002, ioaddr + CSR6); } } static void mxic_timer(unsigned long data) { struct device *dev = (struct 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, (unsigned int)inl(ioaddr + CSR12)); } if (next_tick) { tp->timer.expires = RUN_AT(next_tick); add_timer(&tp->timer); } } static void pnic_timer(unsigned long data) { struct device *dev = (struct device *)data; struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int csr12 = inl(ioaddr + CSR12); int next_tick = 60*HZ; int new_csr6 = tp->csr6 & ~0x40C40200; if (media_cap[dev->if_port] & MediaIsMII) { int negotiated = mdio_read(dev, tp->phys[0], 5) & tp->advertising[0]; if (tulip_debug > 1) printk(KERN_DEBUG "%s: LC82C168 negotiated capability %8.8x, " "CSR5 %8.8x.\n", dev->name, negotiated, (unsigned int)inl(ioaddr + CSR5)); if (negotiated & 0x0380) /* 10 vs 100mbps */ new_csr6 |= 0x812E0000; else new_csr6 |= 0x816E0000; if (((negotiated & 0x0300) == 0x0100) /* Duplex */ || (negotiated & 0x00C0) == 0x0040 || tp->full_duplex_lock) { tp->full_duplex = 1; new_csr6 |= 0x0200; } if (tulip_debug > 1) printk(KERN_DEBUG "%s: LC82C168 MII PHY status %4.4x, Link " "partner report %4.4x, csr6 %8.8x/%8.8x.\n", dev->name, mdio_read(dev, tp->phys[0], 1), negotiated, tp->csr6, (unsigned int)inl(ioaddr + CSR6)); } else { int phy_reg = inl(ioaddr + 0xB8); int csr5 = inl(ioaddr + CSR5); if (tulip_debug > 1) printk(KERN_DEBUG "%s: LC82C168 phy status %8.8x, CSR5 %8.8x.\n", dev->name, phy_reg, csr5); if (phy_reg & 0x04000000) { /* Remote link fault */ /*outl(0x0201F078, ioaddr + 0xB8);*/ next_tick = 3*HZ; } if (inl(ioaddr + CSR5) & TPLnkFail) { /* 100baseTx link beat */ if (tulip_debug > 1) 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, (unsigned int)inl(ioaddr + CSR5), (unsigned int)inl(ioaddr + 0xB8)); if (tp->medialock) { } else if (dev->if_port == 0) { dev->if_port = 3; outl(0x33, ioaddr + CSR12); new_csr6 = 0x01860000; outl(0x1F868, ioaddr + 0xB8); } else { dev->if_port = 0; outl(0x32, ioaddr + CSR12); new_csr6 = 0x00420000; outl(0x1F078, ioaddr + 0xB8); } new_csr6 |= (tp->csr6 & 0xfdff); next_tick = 3*HZ; } else new_csr6 = tp->csr6; if (tp->full_duplex_lock || (phy_reg & 0x30000000) != 0) { tp->full_duplex = 1; new_csr6 |= 0x00000200; } } if (tp->csr6 != new_csr6) { tp->csr6 = new_csr6; outl(tp->csr6 | 0x0002, ioaddr + CSR6); /* Restart Tx */ outl(tp->csr6 | 0x2002, ioaddr + CSR6); dev->trans_start = jiffies; if (tulip_debug > 0) /* Gurppp, should be >1 */ printk(KERN_INFO "%s: Changing PNIC configuration to %s-duplex, " "CSR6 %8.8x.\n", dev->name, tp->full_duplex ? "full" : "half", new_csr6); } tp->timer.expires = RUN_AT(next_tick); add_timer(&tp->timer); } static void tulip_tx_timeout(struct 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. */ if (tulip_debug > 1) printk(KERN_WARNING "%s: Transmit timeout using MII device.\n", dev->name); } else if (tp->chip_id == DC21040) { if ( !tp->medialock && inl(ioaddr + CSR12) & 0x0002) { dev->if_port ^= 1; printk(KERN_INFO "%s: transmit timed out, switching to " "%s10baseT media.\n", dev->name, dev->if_port ? "non" : ""); outl(dev->if_port ? 0x0000000C : 0x00000004, ioaddr + CSR13); } dev->trans_start = jiffies; return; } else if (tp->chip_id == 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, (unsigned int)inl(ioaddr + CSR5), csr12, (unsigned int)inl(ioaddr + CSR13), (unsigned 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; } else dev->if_port = 1; select_media(dev, 0); } } else if (tp->chip_id == DC21140 || tp->chip_id == DC21142 || tp->chip_id == MX98713) { printk(KERN_WARNING "%s: 21140 transmit timed out, status %8.8x, " "SIA %8.8x %8.8x %8.8x %8.8x, resetting...\n", dev->name, (unsigned int)inl(ioaddr + CSR5), (unsigned int)inl(ioaddr + CSR12), (unsigned int)inl(ioaddr + CSR13), (unsigned int)inl(ioaddr + CSR14), (unsigned int)inl(ioaddr + CSR15)); if ( ! tp->medialock && tp->mtable) { if (--tp->cur_index < 0) { /* We start again, but should instead look for default. */ tp->cur_index = tp->mtable->leafcount - 1; } select_media(dev, 0); printk(KERN_WARNING "%s: transmit timed out, switching to %s " "media.\n", dev->name, medianame[dev->if_port]); } } else { printk(KERN_WARNING "%s: Transmit timed out, status %8.8x, CSR12 " "%8.8x, resetting...\n", dev->name, (unsigned int)inl(ioaddr + CSR5), (unsigned int)inl(ioaddr + CSR12)); dev->if_port = 0; } if (tulip_debug > 5) { int i; printk(" Rx ring %8.8x: ", (int)tp->rx_ring); for (i = 0; i < RX_RING_SIZE; i++) printk(" %8.8x", (unsigned int)tp->rx_ring[i].status); printk("\n Original Tx ring %8.8x: ", (int)tp->tx_ring); for (i = 0; i < TX_RING_SIZE; i++) printk(" %8.8x(%8.8x)", (unsigned int)tp->tx_ring[i].status, (unsigned int)tp->tx_ring[i].length); printk("\n cur_tx %8.8x - dirty_tx %8.8x - tx_full %d\n", tp->cur_tx, tp->dirty_tx, tp->tx_full); printk(" csr5 %8.8x - csr6 %8.8x(%8.8x) - csr15 %8.8x\n", (unsigned int)inl(ioaddr + CSR5), (unsigned int)inl(ioaddr + CSR6), tp->csr6, (unsigned int)inl(ioaddr + CSR15)); printk(" csr4 %8.8x(%8.8x)\n", (unsigned int)inl(ioaddr + CSR4), (unsigned int)virt_to_bus(tp->tx_ring)); } /* dwp 22/11/99 : Move all tx ring entries to the top, and reset * dirty_tx and cur_tx, since the transmitter only restarts completely * if the ring buffer is filled from the start... */ tulip_reconstruct_tx_ring(dev); if ((tulip_debug > 2) && !dev->tbusy) printk(KERN_DEBUG "%s: tbusy cleared in tulip_tx_timeout\n", dev->name); if (tulip_debug > 5) { int i; printk(" New Tx ring %8.8x: ", (int)tp->tx_ring); for (i = 0; i < TX_RING_SIZE; i++) printk(" %8.8x(%8.8x)", (unsigned int)tp->tx_ring[i].status, (unsigned int)tp->tx_ring[i].length); printk("\n cur_tx %8.8x - dirty_tx %8.8x - tx_full %d\n", tp->cur_tx, tp->dirty_tx, tp->tx_full); printk(" csr5 %8.8x - csr6 %8.8x(%8.8x) - csr15 %8.8x\n", (unsigned int)inl(ioaddr + CSR5), (unsigned int)inl(ioaddr + CSR6), tp->csr6, (unsigned int)inl(ioaddr + CSR15)); printk(" csr4 %8.8x(%8.8x)\n", (unsigned int)inl(ioaddr + CSR4), (unsigned int)virt_to_bus(tp->tx_ring)); } tp->stats.tx_errors++; return; } /* Initialize the Rx and Tx rings, along with various 'dev' bits. */ static void tulip_init_ring(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int i; tp->tx_full = 0; tp->cur_rx = tp->cur_tx = 0; tp->dirty_rx = tp->dirty_tx = 0; for (i = 0; i < RX_RING_SIZE; i++) { tp->rx_ring[i].status = 0x80000000; /* Owned by Tulip chip */ tp->rx_ring[i].length = PKT_BUF_SZ; { /* Note the receive buffer must be longword aligned. dev_alloc_skb() provides 16 byte alignment. But do *not* use skb_reserve() to align the IP header! */ struct sk_buff *skb; skb = dev_alloc_skb(PKT_BUF_SZ); tp->rx_skbuff[i] = skb; if (skb == NULL) break; /* Bad news! */ skb->dev = dev; /* Mark as being used by this device. */ #if LINUX_VERSION_CODE > 0x10300 tp->rx_ring[i].buffer1 = virt_to_bus(skb->tail); #else tp->rx_ring[i].buffer1 = virt_to_bus(skb->data); #endif } tp->rx_ring[i].buffer2 = virt_to_bus(&tp->rx_ring[i+1]); } /* Mark the last entry as wrapping the ring. */ tp->rx_ring[i-1].length = PKT_BUF_SZ | DESC_RING_WRAP; tp->rx_ring[i-1].buffer2 = virt_to_bus(&tp->rx_ring[0]); /* The Tx buffer descriptor is filled in as needed, but we do need to clear the ownership bit. */ for (i = 0; i < TX_RING_SIZE; i++) { tp->tx_skbuff[i] = 0; tp->tx_ring[i].status = 0x00000000; tp->tx_ring[i].buffer2 = virt_to_bus(&tp->tx_ring[i+1]); } tp->tx_ring[i-1].buffer2 = virt_to_bus(&tp->tx_ring[0]); } static int tulip_start_xmit(struct sk_buff *skb, struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; /* struct tulip_private *tp; */ int entry; u32 flag; /* cli()/sti() moved to lock even when FASTROUTE is not defined 980913 --ro */ cli(); #ifdef CONFIG_NET_FASTROUTE if (xchg(&dev->tx_semaphore,0) == 0) { sti(); /* With new queueing algorithm returning 1 when dev->tbusy == 0 should not result in lockups, but I am still not sure. --ANK */ if (net_ratelimit()) printk(KERN_CRIT "Please check: are you still alive?\n"); return 1; } #endif /* 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) { sti(); if (jiffies - dev->trans_start >= TX_TIMEOUT) tulip_tx_timeout(dev); #ifdef CONFIG_NET_FASTROUTE dev->tx_semaphore = 1; #endif return 1; } /* See if we can free slots on the output ring */ /* if(tp->cur_tx - tp->dirty_tx == TX_RING_SIZE/2 ) */ #ifdef EXTRA_STATS tp->stats_tx_new_refilled += #endif tx_ring_fill(dev); /* Caution: the write order is important here, set the base address with the "ownership" bits last. */ /* Calculate the next Tx descriptor entry. */ entry = tp->cur_tx % TX_RING_SIZE; tp->tx_skbuff[entry] = skb; tp->tx_ring[entry].buffer1 = virt_to_bus(skb->data); dma_cache_wback((unsigned long)skb->data, skb->len); if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE/2) {/* Typical path */ flag = 0x60000000; /* No interrupt */ dev->tbusy = 0; } else if (tp->cur_tx - tp->dirty_tx == TX_RING_SIZE/2) { flag = 0xe0000000; /* Tx-done intr. */ dev->tbusy = 0; } else if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE - 2) { flag = 0x60000000; /* No Tx-done intr. */ dev->tbusy = 0; } else { /* Leave room for set_rx_mode() to fill entries. */ flag = 0xe0000000; /* Tx-done intr. */ tp->tx_full = 1; } if (entry == TX_RING_SIZE-1) flag |= 0xe0000000 | DESC_RING_WRAP; tp->tx_ring[entry].length = skb->len | flag; /*RMK*/ dma_wback_t(&tp->tx_ring[entry]); tp->tx_ring[entry].status = 0x80000000; /* Pass ownership to the chip. */ tp->cur_tx++; /*RMK*/ dma_wback_t(&tp->tx_ring[entry].status); /* Trigger an immediate transmit demand. */ outl(0, dev->base_addr + CSR1); dev->trans_start = jiffies; #ifdef CONFIG_NET_FASTROUTE dev->tx_semaphore = 1; #endif sti(); return 0; } /* The interrupt handler does all of the Rx thread work and cleans up 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 tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; int csr5, work_budget = max_interrupt_work; #if defined(__i386__) && defined(SMP_CHECK) /* && defined(__SMP__) */ if (test_and_set_bit(0, (void*)&dev->interrupt)) { printk(KERN_ERR "%s: Re-entering the interrupt handler with proc %d," " proc %d already handling.\n", dev->name, tp->smp_proc_id, hard_smp_processor_id()); dev->interrupt = 0; return; } else tp->smp_proc_id = hard_smp_processor_id(); #else if (dev->interrupt) { printk(KERN_ERR "%s: Re-entering the interrupt handler.\n", dev->name); return; } dev->interrupt = 1; #endif 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, (unsigned int)inl(dev->base_addr + CSR5)); #ifdef EXTRA_STATS if( csr5 & NormalIntr ) tp->stats_intr_normal++; if( csr5 & AbnormalIntr ) tp->stats_intr_abnormal++; if( csr5 & RxIntr ) tp->stats_intr_rx++; if( csr5 & RxNoBuf ) tp->stats_intr_rx_nobuf++; if( csr5 & TxIntr ) tp->stats_intr_tx++; if( csr5 & TxDied ) tp->stats_intr_tx_died++; if( csr5 & TxNoBuf ) tp->stats_intr_tx_nobuf++; #endif if ((csr5 & (NormalIntr|AbnormalIntr)) == 0) break; /* dwp 25/11/99 : changed to call tulip_rx if the rx process * is suspended due to buffer unavailability. */ if ((csr5 & (RxIntr | RxNoBuf)) || ((csr5 & 0x000E0000) == 0x00080000)) { if (((csr5 & 0x000E0000) == 0x00080000) && !(csr5 & (RxIntr | RxNoBuf))) printk(KERN_DEBUG "%s: Warning: Receive buffer filled " "without receive interrupt. Recovering... " "CSR5=%#8.8x CSR6=%#8.8x\n", dev->name, csr5, (unsigned int)inl(ioaddr + CSR6)); work_budget -= tulip_rx(dev); } if (csr5 & (TxNoBuf | TxDied | TxIntr)) { tulip_check_tx_ring(dev); #ifdef NOTNOW if (csr5 & TxDied) { if (tulip_debug) printk(KERN_WARNING "%s: The transmitter stopped!" " CSR5 is %x, CSR6 %x.\n", dev->name, csr5, (unsigned int)inl(ioaddr + CSR6)); outl(tp->csr6 | 0x0002, ioaddr + CSR6); outl(tp->csr6 | 0x2002, ioaddr + CSR6); } #endif } /* Log errors. */ if (csr5 & AbnormalIntr) { /* Abnormal error summary bit. */ if (csr5 == 0xffffffff) break; if (csr5 & TxJabber) tp->stats.tx_errors++; if (csr5 & TxFIFOUnderflow) { if ((tp->csr6 & 0xC000) != 0xC000) tp->csr6 += 0x4000; /* Bump up the Tx threshold */ else tp->csr6 |= 0x00200000; /* Store-n-forward. */ /* Restart the transmit process. */ if (tulip_debug) printk(KERN_WARNING "%s: The transmitter stopped pos2 !" " CSR5 is %x, CSR6 %x.\n", dev->name, csr5, (unsigned int)inl(ioaddr + CSR6)); outl(tp->csr6 | 0x0002, ioaddr + CSR6); outl(tp->csr6 | 0x2002, ioaddr + CSR6); } if (csr5 & RxDied) { /* Missed a Rx frame. */ tp->stats.rx_errors++; tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; } if (csr5 & TimerInt) { printk(KERN_ERR "%s: Something Wicked happened! %8.8x.\n", dev->name, csr5); /* Hmmmmm, it's not clear what to do here. */ } if (csr5 & (TPLnkPass | TPLnkFail | 0x08000000) && tp->chip_id == DC21142) { if (tulip_debug > 1) printk(KERN_INFO"%s: 21143 link change, CSR5 = %8.8x.\n", dev->name, csr5); t21142_lnk_change(dev); } /* Clear all error sources, included undocumented ones! */ outl(0x0800f7ba, ioaddr + CSR5); } /* end of error logging */ if (--work_budget < 0) { if (tulip_debug > 1) printk(KERN_WARNING "%s: Too much work during an interrupt, " "csr5=0x%8.8x.\n", dev->name, csr5); /* Acknowledge all interrupt sources. */ outl(0x8001ffff, ioaddr + CSR5); #ifdef notdef /* Clear all but standard interrupt sources. */ outl((~csr5) & 0x0001ebef, ioaddr + CSR7); #endif break; } } while (1); /* dwp 25/11/99 : check the tx ring at the end of the interrupt if the * transmitter is in the suspended state. Also, do the bubble test if this one fails. */ if (dev->tbusy && ((csr5 & 0x00700000) == 0x00600000)) { printk(KERN_DEBUG "%s: Warning: Transmit interrupt may have been " "missed. Recovering... CSR5=%#8.8x CSR6=%#8.8x\n", dev->name, csr5, (unsigned int)inl(ioaddr + CSR6)); /* dwp 22/11/99 : check to see if any ring entries can be freed * to allow transmitting to continue */ tulip_check_tx_ring(dev); if (dev->tbusy) { printk(KERN_DEBUG "%s: Warning: Initial recover failed. Transmitter " "is confused about ring state. Reconstructing transmit ring...\n", dev->name); tulip_reconstruct_tx_ring(dev); if (dev->tbusy) printk(KERN_DEBUG "%s: Warning: Transmit ring is still full " "after reconstruction.\n", dev->name); } printk(KERN_DEBUG "%s: Recovery: Ring has been changed: " "cur_tx=%#8.8x dirty_tx=%#8.8x tx_full=%d\n", dev->name, tp->cur_tx, tp->dirty_tx, tp->tx_full); } if (tulip_debug > 3) printk(KERN_DEBUG "%s: exiting interrupt, csr5=%#4.4x.\n", dev->name, (unsigned int)inl(ioaddr + CSR5)); #if defined(__i386__) clear_bit(0, (void*)&dev->interrupt); #else dev->interrupt = 0; #endif return; } /* dwp 22/11/99 - moved here from tulip_interrupt since * the tx ring has to be checked from more than one location */ static void tulip_check_tx_ring(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; unsigned int dirty_tx; for (dirty_tx = tp->dirty_tx; tp->cur_tx - dirty_tx > 0; dirty_tx++) { int entry = dirty_tx % TX_RING_SIZE; int status; /*RMK*/ dma_inv_t(&tp->tx_ring[entry].status); status = tp->tx_ring[entry].status; if (status < 0) break; /* It still hasn't been Txed */ /* 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 if (tulip_debug > 1) printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n", dev->name, status); #endif tp->stats.tx_errors++; if (status & 0x4104) tp->stats.tx_aborted_errors++; if (status & 0x0C00) tp->stats.tx_carrier_errors++; if (status & 0x0200) tp->stats.tx_window_errors++; if (status & 0x0002) tp->stats.tx_fifo_errors++; if ((status & 0x0080) && tp->full_duplex == 0) tp->stats.tx_heartbeat_errors++; #ifdef ETHER_STATS if (status & 0x0100) tp->stats.collisions16++; #endif } else { #ifdef ETHER_STATS if (status & 0x0001) tp->stats.tx_deferred++; #endif #if LINUX_VERSION_CODE > 0x20127 tp->stats.tx_bytes += tp->tx_ring[entry].length & 0x7ff; #endif tp->stats.collisions += (status >> 3) & 15; tp->stats.tx_packets++; } /* Free the original skb. */ #ifdef FAST_SKB_RECYCLE tulip_recycle_skb(xchg(&tp->tx_skbuff[entry], NULL)); #else dev_free_skb(tp->tx_skbuff[entry]); tp->tx_skbuff[entry] = 0; #endif #ifdef EXTRA_STATS tp->stats_tx_old_refilled++; #endif } #ifndef final_version if (tp->cur_tx - dirty_tx > TX_RING_SIZE) { printk(KERN_ERR "%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.\n", dev->name, dirty_tx, tp->cur_tx, tp->tx_full); dirty_tx += TX_RING_SIZE; } #endif if (tp->tx_full && dev->tbusy && tp->cur_tx - dirty_tx < TX_RING_SIZE - 2) { /* The ring is no longer full, clear tbusy. */ tp->tx_full = 0; dev->tbusy = 0; mark_bh(NET_BH); } tp->dirty_tx = dirty_tx; return; } /* dwp 25/11/99 : redo the ring buffer completely so that the * transmitter can resume reliably. */ static void tulip_reconstruct_tx_ring(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int first_avail = 0; int entry; long flags; long ioaddr = dev->base_addr; long csr6; /* Stop all Tx processes - to avoid problems when messing * around with the rings (also clear interrupts) */ save_flags(flags); cli(); csr6 = inl(ioaddr + CSR6); outl(csr6 & ~0x2002, ioaddr + CSR6); /* Go through the ring buffer and push everything back to * the start. */ for (entry = 0; entry < TX_RING_SIZE; entry++) { dma_inv_t(&tp->tx_ring[entry]); if (tp->tx_ring[entry].status < 0) { if (entry != first_avail) { if (tp->tx_skbuff[first_avail]) { #ifdef FAST_SKB_RECYCLE tulip_recycle_skb(xchg(&tp->tx_skbuff[first_avail], NULL)); #else dev_free_skb(tp->tx_skbuff[first_avail]); tp->tx_skbuff[first_avail] = 0; #endif } tp->tx_ring[first_avail].status = tp->tx_ring[entry].status; tp->tx_ring[first_avail].length = tp->tx_ring[entry].length & ~DESC_RING_WRAP; tp->tx_ring[first_avail].buffer1 = tp-> tx_ring[entry].buffer1; tp->tx_skbuff[first_avail] = tp->tx_skbuff[entry]; dma_wback_t(&tp->tx_ring[first_avail]); tp->tx_ring[entry].status = 0; tp->tx_skbuff[entry] = 0; dma_wback_t(&tp->tx_ring[entry].status); } first_avail++; if (first_avail == (TX_RING_SIZE-1)) break; } else { if (tp->tx_skbuff[entry]) { #ifdef FAST_SKB_RECYCLE tulip_recycle_skb(xchg(&tp->tx_skbuff[entry], NULL)); #else dev_free_skb(tp->tx_skbuff[entry]); tp->tx_skbuff[entry] = 0; #endif } } } /* Make sure that the last entry has the ring wrap flag set */ tp->tx_ring[TX_RING_SIZE-1].length |= 0xE0000000 | DESC_RING_WRAP; dma_wback_t(&tp->tx_ring[TX_RING_SIZE-1].length); /* Reset the ring pointers to match the new ring */ tp->dirty_tx = 0; tp->cur_tx = first_avail; /* This will almost always clear tbusy */ tp->tx_full = dev->tbusy = (first_avail == (TX_RING_SIZE-1)); mark_bh(NET_BH); /* Write out CSR4 again so that the tulip starts at the top of * the ring. */ outl(virt_to_bus(tp->tx_ring), ioaddr + CSR4); outl(csr6 | 0x2002, ioaddr + CSR6); /* Get the transmission process running again. */ outl(0, ioaddr + CSR1); dev->trans_start = jiffies; /* Restore interrupts, if needed. */ restore_flags(flags); } #ifdef CONFIG_NET_FASTROUTE /* DMAing cards are the most easy in this respect, they are able to make fast route to any device. Now we allow to make it only to another ethernet card. */ static int tulip_accept_fastpath(struct device *dev, struct dst_entry *dst) { struct device *odev = dst->dev; if (dst->ops->protocol != __constant_htons(ETH_P_IP)) return -1; if (odev->type != ARPHRD_ETHER || odev->accept_fastpath == NULL) return -1; return 0; } /* Return values: 0 - packet has gone by fast path. 1 - fast path is OK, but device deferred xmit. (semifast path) 2 - fast path is hit, but packet is a bit strange. (NI) 3 - oom 4 - fast path miss. */ static int tulip_fast_forward(struct device *dev, int entry, int len) { struct tulip_private *tp = (struct tulip_private *)dev->priv; struct sk_buff *skb = tp->rx_skbuff[entry]; struct ethhdr *eth = (void*)skb->data; if (eth->h_proto == __constant_htons(ETH_P_IP)) { struct rtable *rt; struct iphdr *iph; unsigned h; iph = (struct iphdr*)(skb->data + ETH_HLEN); h = (*(u8*)&iph->daddr^*(u8*)&iph->saddr)&NETDEV_FASTROUTE_HMASK; rt = (struct rtable*)(dev->fastpath[h]); if (rt && ((u16*)&iph->daddr)[0] == ((u16*)&rt->key.dst)[0] && ((u16*)&iph->daddr)[1] == ((u16*)&rt->key.dst)[1] && ((u16*)&iph->saddr)[0] == ((u16*)&rt->key.src)[0] && ((u16*)&iph->saddr)[1] == ((u16*)&rt->key.src)[1] && rt->u.dst.obsolete == 0) { struct device *odev = rt->u.dst.dev; dev_fastroute_stat.hits++; #ifdef EXTRA_STATS tp->stats_fastroute_hits++; #endif if (*(u8*)iph != 0x45 || (eth->h_dest[0]&1) || !neigh_is_valid(rt->u.dst.neighbour) || iph->ttl <= 1) { #ifdef not_yet skb->dst = dst_clone(&rt->u.dst); return 2; #else return 4; #endif } ip_decrease_ttl(iph); #ifdef FILL_RX_RING_AT_ONCE if (1) { #ifdef FAST_SKB_RECYCLE struct sk_buff *skb2 = tp->rx_skbuff[entry] = get_recycle_skb(PKT_BUF_SZ); if( !skb2 ) skb2 = dev_alloc_skb(PKT_BUF_SZ); #else struct sk_buff *skb2 = dev_alloc_skb(PKT_BUF_SZ); #endif if (skb2 == NULL) return 3; /* oom */ tp->rx_ring[entry].buffer1 = virt_to_bus(skb2->tail); skb2->dev = dev; tp->rx_skbuff[entry] = skb2; #ifdef FAST_SKB_RECYCLE skb2->type = 1; #endif } #else tp->rx_skbuff[entry] = NULL; /* Fill it later */ #endif skb_put(skb, len); ip_statistics.IpInReceives++; ip_statistics.IpForwDatagrams++; /* Could use hh cache */ memcpy(eth->h_source, odev->dev_addr, 6); memcpy(eth->h_dest, rt->u.dst.neighbour->ha, 6); skb->dev = odev; skb->pkt_type = PACKET_FASTROUTE; if (odev->tx_semaphore && odev->tbusy == 0 && odev->interrupt == 0 && odev->hard_start_xmit(skb, odev) == 0) { dev_fastroute_stat.succeed++; #ifdef EXTRA_STATS tp->stats_fastroute_succeed++; #endif return 0; } /* Otherwise... */ /* skb->pkt_type = PACKET_FASTROUTE; */ skb->nh.raw = skb->data + ETH_HLEN; skb->protocol = __constant_htons(ETH_P_IP); dev_fastroute_stat.deferred++; #ifdef EXTRA_STATS tp->stats_fastroute_deferred++; #endif return 1; } } return 4; } #endif static int tulip_rx(struct 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 work_done = 0; if (tulip_debug > 4) printk(KERN_DEBUG " In tulip_rx(), entry %d %8.8x.\n", entry, tp->rx_ring[entry].status); /* If we own the next entry, it's a new packet. Send it up. */ dma_inv_t(&tp->rx_ring[entry]); while (tp->rx_ring[entry].status >= 0) { s32 status = tp->rx_ring[entry].status; if (--rx_work_limit < 0) break; if ((status & 0x38008300) != 0x0300) { if ((status & 0x38000300) != 0x0300) { /* Ingore earlier buffers. */ if ((status & 0xffff) != 0x7fff) { if (tulip_debug > 1) printk(KERN_WARNING "%s: Oversized Ethernet frame " "spanned multiple buffers, status %8.8x!\n", dev->name, status); tp->stats.rx_length_errors++; } } else if (status & 0x8000) { /* There was a fatal error. */ if (tulip_debug > 2) printk(KERN_DEBUG "%s: Receive error, Rx status %8.8x.\n", dev->name, status); tp->stats.rx_errors++; /* end of a packet.*/ if (status & 0x0890) tp->stats.rx_length_errors++; if (status & 0x0004) tp->stats.rx_frame_errors++; if (status & 0x0002) tp->stats.rx_crc_errors++; if (status & 0x0001) tp->stats.rx_fifo_errors++; } } else { /* Omit the four octet CRC from the length. */ short pkt_len = ((status >> 16) & 0x7ff) - 4; struct sk_buff *skb; #ifndef final_version if (pkt_len > 1518) { printk("%s: Bogus packet size of %d (%#x).\n", dev->name, pkt_len, pkt_len); pkt_len = 1518; tp->stats.rx_length_errors++; } #endif #ifdef CONFIG_NET_HW_FLOWCONTROL if (netdev_dropping) goto throttle; #endif #ifdef CONFIG_NET_FASTROUTE skb = tp->rx_skbuff[entry]; switch (tulip_fast_forward(dev, entry, pkt_len)) { case 0: goto gone; case 1: goto semi_gone; case 2: /* fast path is hit, but packet is a bit strange */ break; case 3: /* oom */ break; case 4: /* fast path miss. */ break; } #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) { void *virt_buf_addr = bus_to_virt(tp->rx_ring[entry].buffer1);; skb->dev = dev; #if ! defined(__alpha__) dma_cache_inv((unsigned long)virt_buf_addr, pkt_len); skb_reserve(skb, 2); /* 16 byte align the IP header */ eth_copy_and_sum(skb, virt_buf_addr, pkt_len, 0); skb_put(skb, pkt_len); #else memcpy(skb_put(skb, pkt_len), virt_buf_addr, pkt_len); #endif work_done++; } else { /* Pass up the skb already on the Rx ring. */ char *temp; skb = tp->rx_skbuff[entry]; if(! skb ) goto oom; temp = skb_put(skb, pkt_len); /*char *temp = skb_put(skb = tp->rx_skbuff[entry], pkt_len);*/ #ifdef FILL_RX_RING_AT_ONCE { #ifdef FAST_SKB_RECYCLE struct sk_buff *skb2 = tp->rx_skbuff[entry] = get_recycle_skb(PKT_BUF_SZ); if( !skb2 ) skb2 = dev_alloc_skb(PKT_BUF_SZ); #else struct sk_buff *skb2 = dev_alloc_skb(PKT_BUF_SZ); #endif if (skb2 == NULL) goto oom; /* oom */ tp->rx_ring[entry].buffer1 = virt_to_bus(skb2->tail); skb2->dev = dev; tp->rx_skbuff[entry] = skb2; #ifdef FAST_SKB_RECYCLE skb2->type = 1; #endif } #else tp->rx_skbuff[entry] = NULL; #endif #ifdef NOTNOW #ifndef final_version if (bus_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, bus_to_virt(tp->rx_ring[entry].buffer1), skb->head, temp); #endif #endif } skb->protocol = eth_type_trans(skb, dev); #ifdef CONFIG_NET_FASTROUTE semi_gone: #endif netif_rx(skb); #ifdef CONFIG_NET_HW_FLOWCONTROL if (netdev_dropping) { throttle: if (tp->fc_bit) { #ifndef HW_FLOWCONTROL_NEW outl(tp->csr6 | 0x2000, dev->base_addr + CSR6); #endif set_bit(tp->fc_bit, &netdev_fc_xoff); } } #endif #ifdef CONFIG_NET_FASTROUTE gone: #endif dev->last_rx = jiffies; tp->stats.rx_packets++; #if LINUX_VERSION_CODE > 0x20127 tp->stats.rx_bytes += pkt_len; #endif } entry = (++tp->cur_rx) % RX_RING_SIZE; dma_inv_t(&tp->rx_ring[entry]); } #ifdef HW_FLOWCONTROL_NEW if( ! netdev_dropping ) { #endif /* 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; #ifdef FAST_SKB_RECYCLE skb = tp->rx_skbuff[entry] = get_recycle_skb(PKT_BUF_SZ); if( !skb ) #endif 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. */ #ifdef FAST_SKB_RECYCLE skb->type = 1; #endif tp->rx_ring[entry].buffer1 = virt_to_bus(skb->tail); work_done++; } dma_wback_t(&tp->rx_ring[entry]); tp->rx_ring[entry].status = 0x80000000; dma_wback_t(&tp->rx_ring[entry].status); } #ifdef HW_FLOWCONTROL_NEW } #endif return work_done; oom: /* take care of when we are out memory */ /* I have now idea for now */ if( net_ratelimit()) printk( KERN_WARNING "oom\n"); return work_done; } __inline__ static int rx_ring_fill(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; /* Refill the Rx ring buffers. */ int free = 0; for (; tp->cur_rx - tp->dirty_rx > 0; tp->dirty_rx++) { int 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_bus(skb->tail); } dma_wback_t(&tp->rx_ring[entry]); tp->rx_ring[entry].status = 0x80000000; dma_wback_t(&tp->rx_ring[entry].status); free++; } return free; } __inline__ static int tx_ring_fill(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; int free=0; unsigned int dirty_tx; /* Can we free any TX-buffers now? */ for (dirty_tx = tp->dirty_tx; tp->cur_tx-dirty_tx>0; dirty_tx++) { int entry = dirty_tx % TX_RING_SIZE; int status; dma_inv_t(&tp->tx_ring[entry].status); status = tp->tx_ring[entry].status; if (status < 0) break; /* It still hasn't been Txed */ /* 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 if (tulip_debug > 1) printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n", dev->name, status); #endif tp->stats.tx_errors++; if (status & 0x4104) tp->stats.tx_aborted_errors++; if (status & 0x0C00) tp->stats.tx_carrier_errors++; if (status & 0x0200) tp->stats.tx_window_errors++; if (status & 0x0002) tp->stats.tx_fifo_errors++; if ((status & 0x0080) && tp->full_duplex == 0) tp->stats.tx_heartbeat_errors++; #ifdef ETHER_STATS if (status & 0x0100) tp->stats.collisions16++; #endif } else { #ifdef ETHER_STATS if (status & 0x0001) tp->stats.tx_deferred++; #endif #if LINUX_VERSION_CODE > 0x20127 tp->stats.tx_bytes += tp->tx_ring[entry].length & 0x7ff; #endif tp->stats.collisions += (status >> 3) & 15; tp->stats.tx_packets++; } /* Free the original skb. */ #ifdef FAST_SKB_RECYCLE tulip_recycle_skb(xchg(&tp->tx_skbuff[entry], NULL)); #else dev_kfree_skb(tp->tx_skbuff[entry]); tp->tx_skbuff[entry] = 0; #endif free++; /* if( net_ratelimit()) printk( "In tx_ring_fill free %d\n", free); */ } #ifndef final_version if (tp->cur_tx - dirty_tx > TX_RING_SIZE) { printk(KERN_ERR "%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.\n", dev->name, dirty_tx, tp->cur_tx, tp->tx_full); dirty_tx += TX_RING_SIZE; } #endif if (tp->tx_full && dev->tbusy && dirty_tx > tp->cur_tx - TX_RING_SIZE + 2) { /* The ring is no longer full, clear tbusy. */ printk("The ring is no longer full, clear tbusy\n"); tp->tx_full = 0; dev->tbusy = 0; mark_bh(NET_BH); } tp->dirty_tx = dirty_tx; return free; } static int tulip_close(struct device *dev) { long ioaddr = dev->base_addr; struct tulip_private *tp = (struct tulip_private *)dev->priv; int i; #ifdef CONFIG_NET_FASTROUTE dev->tx_semaphore = 0; #endif dev->start = 0; dev->tbusy = 1; #ifdef CONFIG_NET_HW_FLOWCONTROL if (tp->fc_bit) { int bit = tp->fc_bit; tp->fc_bit = 0; netdev_unregister_fc(bit); } #endif if (tulip_debug > 1) printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n", dev->name, (unsigned int)inl(ioaddr + CSR5)); /* Disable interrupts by clearing the interrupt mask. */ outl(0x00000000, ioaddr + CSR7); /* Stop the chip's 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; #ifdef AVE_STATS del_timer(&tp->ave_timer); #endif 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]; tp->rx_skbuff[i] = 0; tp->rx_ring[i].status = 0; /* Not owned by Tulip chip. */ dma_wback_t(&tp->rx_ring[i].status); tp->rx_ring[i].length = 0; tp->rx_ring[i].buffer1 = 0xBADF00D0; /* An invalid address. */ dma_wback_t(&tp->rx_ring[i]); if (skb) { #if LINUX_VERSION_CODE < 0x20100 skb->free = 1; #endif dev_free_skb(skb); } } for (i = 0; i < TX_RING_SIZE; i++) { if (tp->tx_skbuff[i]) dev_free_skb(tp->tx_skbuff[i]); tp->tx_skbuff[i] = 0; } MOD_DEC_USE_COUNT; return 0; } static struct net_device_stats *tulip_get_stats(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; long ioaddr = dev->base_addr; if (dev->start) tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; 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) { 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; switch(cmd) { case SIOCDEVPRIVATE: /* Get the address of the PHY in use. */ if (tp->mii_cnt) data[0] = phy; else if (tp->chip_id == DC21142) data[0] = 32; else return -ENODEV; return 0; case SIOCDEVPRIVATE+1: /* Read the specified MII register. */ if (data[0] == 32) { /* 21142 pseudo-MII */ int csr12 = inl(ioaddr + CSR12); int csr14 = inl(ioaddr + CSR14); switch (data[1]) { case 0: { data[3] = ((csr14<<13)&0x4000) + ((csr14<<5)&0x1000); break; } case 1: data[3] = 0x7848 + ((csr12&0x7000) == 0x5000 ? 0x20 : 0) + (csr12&0x06 ? 0x04 : 0); break; case 4: { data[3] = ((csr14>>9)&0x0380) + ((inl(ioaddr + CSR6)>>3)&0x0040) +((csr14>>1)&0x20) + 1; break; } case 5: data[3] = csr12 >> 16; 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); } return 0; case SIOCDEVPRIVATE+2: /* Write the specified MII register */ if (!suser()) return -EPERM; if (data[0] == 32) { /* 21142 pseudo-MII */ if (data[1] == 5) tp->advertising[tp->mii_cnt] = data[2]; } else { save_flags(flags); cli(); mdio_write(dev, data[0] & 0x1f, data[1] & 0x1f, data[2]); restore_flags(flags); } return 0; default: return -EOPNOTSUPP; } return -EOPNOTSUPP; } #endif /* HAVE_PRIVATE_IOCTL */ /* Set or clear the multicast filter for this adaptor. Note that we only use exclusion around actually queueing the new frame, not around filling tp->setup_frame. This is non-deterministic when re-entered but still correct. */ /* The little-endian AUTODIN32 ethernet CRC calculation. N.B. Do not use for bulk data, use a table-based routine instead. This is common code and should be moved to net/core/crc.c */ 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 device *dev) { long ioaddr = dev->base_addr; int csr6 = inl(ioaddr + CSR6) & ~0x00D5; struct tulip_private *tp = (struct tulip_private *)dev->priv; tp->csr6 &= ~0x00D5; if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ outl(csr6 | 0x00C0, ioaddr + CSR6); /* Unconditionally log net taps. */ printk(KERN_INFO "%s: Promiscuous mode enabled.\n", dev->name); tp->csr6 |= 0xC0; } else if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) { /* Too many to filter perfectly -- accept all multicasts. */ outl(csr6 | 0x0080, ioaddr + CSR6); tp->csr6 |= 0x80; } else { u32 *setup_frm = tp->setup_frame; struct dev_mc_list *mclist; u16 *eaddrs; u32 tx_flags; int i; if (dev->mc_count > 14) { /* Must use a multicast hash table. */ u16 hash_table[32]; memset(hash_table, 0, sizeof(hash_table)); /* 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) set_bit(ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff, hash_table); /* Copy the hash table to the setup frame. NOTE that only the LOW SHORTWORD of setup_frame[] is valid! */ for (i = 0; i < 32; i++) *setup_frm++ = hash_table[i]; setup_frm += 7; tx_flags = 0x08400000 | 192; /* Too clever: i > 15 for fall-though. */ } else { /* We have <= 15 addresses so we can use the wonderful 16 address perfect filtering of the Tulip. */ for (i = 0, mclist = dev->mc_list; i < dev->mc_count; i++, mclist = mclist->next) { /* Note that only the low shortword of setup_frame[] is valid! This code may require tweaking for non-x86 architectures! */ eaddrs = (u16 *)mclist->dmi_addr; *setup_frm++ = *eaddrs++; *setup_frm++ = *eaddrs++; *setup_frm++ = *eaddrs++; } /* Fill the rest of the table with our physical address. Once again, only the low shortword or setup_frame[] is valid! */ *setup_frm++ = 0xffff; *setup_frm++ = 0xffff; *setup_frm++ = 0xffff; tx_flags = 0x08000000 | 192; } eaddrs = (u16 *)dev->dev_addr; do { *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[2]; } while (++i < 15); /* Now add this frame to the Tx list. */ if (tp->cur_tx - tp->dirty_tx > TX_RING_SIZE - 2) { /* Same setup recently queued, we need not add it. */ } else { unsigned long flags; unsigned int entry, dummy = 0; save_flags(flags); cli(); entry = tp->cur_tx++ % TX_RING_SIZE; if (entry != 0) { /* Avoid a chip errata by prefixing a dummy entry. */ tp->tx_skbuff[entry] = 0; tp->tx_ring[entry].length = (entry == TX_RING_SIZE-1) ? DESC_RING_WRAP : 0; tp->tx_ring[entry].buffer1 = 0; dma_wback_t(&tp->tx_ring[entry]); /* race with chip, set DescOwned later */ dummy = entry; entry = tp->cur_tx++ % TX_RING_SIZE; } tp->tx_skbuff[entry] = 0; /* Put the setup frame on the Tx list. */ if (entry == TX_RING_SIZE-1) tx_flags |= DESC_RING_WRAP; /* Wrap ring. */ tp->tx_ring[entry].length = tx_flags; tp->tx_ring[entry].buffer1 = virt_to_bus(tp->setup_frame); dma_wback_t(&tp->tx_ring[entry]); tp->tx_ring[entry].status = 0x80000000; dma_wback_t(&tp->tx_ring[entry].status); if (tp->cur_tx - tp->dirty_tx >= TX_RING_SIZE - 2) { dev->tbusy = 1; tp->tx_full = 1; } if (dummy > 0) { tp->tx_ring[dummy].status = DescOwned; dma_wback_t(&tp->tx_ring[entry].status); } restore_flags(flags); /* Trigger an immediate transmit demand. */ outl(0, ioaddr + CSR1); } outl(csr6 | 0x0000, ioaddr + CSR6); } } #ifdef AVE_STATS static void ave_get(unsigned long arg) { struct tulip_private *tp = (struct tulip_private *) arg; unsigned long ent; ent = tp->ring_p % AVE_STATS_VALUES; tp->ave_buf[ent].time = jiffies; tp->ave_buf[ent].rx_packets_5min = tp->stats.rx_packets; tp->ave_buf[ent].tx_packets_5min = tp->stats.tx_packets; tp->ave_buf[ent].rx_bytes_5min = tp->stats.rx_bytes; tp->ave_buf[ent].tx_bytes_5min = tp->stats.tx_bytes; tp->ave_buf[ent].rx_errors_5min = tp->stats.rx_errors; tp->ave_buf[ent].tx_errors_5min = tp->stats.tx_errors; tp->ave_buf[ent].rx_dropped_5min = tp->stats.rx_dropped; tp->ave_buf[ent].tx_dropped_5min = tp->stats.tx_dropped; tp->ave_buf[ent].collisions_5min = tp->collisions_5min; /* Fix this... has to read missed counter on chip */ tp->ave_buf[ent].rx_missed_errors_5min = tp->stats.rx_missed_errors; tp->ring_p++; #ifdef NOTNOW init_timer(&tp->ave_timer); tp->ave_timer.expires = jiffies + HZ*30; tp->ave_timer.function = ave_get; tp->ave_timer.data = (unsigned long) &tp; #endif tp->ave_timer.expires = jiffies + HZ*30; add_timer(&tp->ave_timer); } static void ave_calc(struct device *dev) { struct tulip_private *tp = (struct tulip_private *)dev->priv; unsigned long diff; int ent; ent = (tp->ring_p) % AVE_STATS_VALUES; if( ent < 0 ) ent = 0; diff = (jiffies - tp->ave_buf[ent].time)/HZ; if( diff == 0 ) diff=1; tp->rx_packets_5min = (tp->stats.rx_packets-tp->ave_buf[ent].rx_packets_5min)/diff; tp->tx_packets_5min = (tp->stats.tx_packets-tp->ave_buf[ent].tx_packets_5min)/diff; tp->rx_bytes_5min = (tp->stats.rx_bytes-tp->ave_buf[ent].rx_bytes_5min)/diff; tp->tx_bytes_5min = (tp->stats.tx_bytes-tp->ave_buf[ent].tx_bytes_5min)/diff; tp->rx_errors_5min = (tp->stats.rx_errors-tp->ave_buf[ent].rx_errors_5min)/diff; tp->rx_errors_5min = (tp->stats.rx_errors-tp->ave_buf[ent].rx_errors_5min)/diff; tp->rx_dropped_5min = (tp->stats.rx_dropped-tp->ave_buf[ent].rx_dropped_5min)/diff; tp->tx_dropped_5min = (tp->stats.tx_dropped-tp->ave_buf[ent].tx_dropped_5min)/diff; tp->collisions_5min = (tp->stats.collisions-tp->ave_buf[ent].collisions_5min)/diff; tp->rx_missed_errors_5min = (tp->stats.rx_missed_errors-tp->ave_buf[ent].rx_missed_errors_5min)/diff; } #endif #if 0 //def CONFIG_PROC_FS int dev_proc_tulip(char *buf , char **start, off_t offset, int len, int unused) { struct device *dev, **devp, **next; struct tulip_private *tp; char *p; p = buf; for (devp = &root_tulip_dev; *devp; devp = next) { next = &((struct tulip_private *)(*devp)->priv)->next_module; dev = *devp; tp = (struct tulip_private *)dev->priv; p += sprintf(p, "%s: %s %s %s ", dev->name, dev->flags&IFF_UP ? "UP" : "DOWN", medianame[dev->if_port], tp->full_duplex ? "Full Duplex" : "Half Duplex" ); { int new_reg1 = mdio_read(dev, tp->phys[0], 1); p += sprintf(p, "%s", new_reg1 & 0x0004 ? "Link UP\n" : "*** Link DOWN ***\n"); } /* tulip_tbl[tp->chip_id].chip_name */ #ifdef EXTRA_STATS if( dev->flags&IFF_UP ) { p += sprintf(p, "Admin up " ); p += c_time(p, (jiffies-(tp->open_time))/HZ); p += sprintf(p, "\n"); } #endif p += sprintf(p, "Last input " ); p += c_time(p, (jiffies-(dev->last_rx))/HZ); p += sprintf(p, "\n"); p += sprintf(p, "Last output " ); p += c_time(p, (jiffies-(dev->trans_start))/HZ); p += sprintf(p, "\n"); #ifdef EXTRA_STATS #ifdef AVE_STATS ave_calc(dev); p += sprintf(p, "5min RX bits/s\t%-12u \n", tp->rx_bytes_5min*8); p += sprintf(p, "5min TX bits/s\t%-12u \n", tp->tx_bytes_5min*8); p += sprintf(p, "5min RX pkts/s\t%-12u \n", tp->rx_packets_5min); p += sprintf(p, "5min TX pkts/s\t%-12u \n", tp->tx_packets_5min); p += sprintf(p, "5min TX errors\t%-12u \n", tp->tx_errors_5min); p += sprintf(p, "5min RX errors\t%-12u \n", tp->rx_errors_5min); p += sprintf(p, "5min RX dropped\t%-12u \n", tp->rx_dropped_5min); p += sprintf(p, "5min TX dropped\t%-12u \n", tp->rx_dropped_5min); p += sprintf(p, "5min collisions\t%-12u \n", tp->collisions_5min); p += sprintf(p, "5min RX missed errors\t%-12u \n", tp->rx_missed_errors_5min); #endif p += sprintf(p, "NormalIntr\t %-12lu\n", tp->stats_intr_normal); p += sprintf(p, "AbnormalIntr\t %-12lu\n", tp->stats_intr_abnormal); p += sprintf(p, "RxIntr\t %-12lu\n", tp->stats_intr_rx); p += sprintf(p, "RxNoBuf\t %-12lu\n", tp->stats_intr_rx_nobuf); p += sprintf(p, "TxIntr\t %-12lu\n", tp->stats_intr_tx); p += sprintf(p, "TxDied\t %-12lu\n", tp->stats_intr_tx_died); p += sprintf(p, "TxNoBuf\t %-12lu\n", tp->stats_intr_tx_nobuf); p += sprintf(p, "TX-refilled with old/new scheme %lu/%lu \n", tp->stats_tx_old_refilled, tp->stats_tx_new_refilled); #ifdef CONFIG_NET_HW_FLOWCONTROL #ifndef HW_FLOWCONTROL_NEW p += sprintf(p, "HW_flowcontrol(old) on's\t %-12lu\n", tp->stats_fc_on); #else p += sprintf(p, "HW_flowcontrol(new) on's\t %-12lu\n", tp->stats_fc_on); #endif #endif #ifdef PPS_TESTING p += sprintf(p, "RX-Pkts from pg\t %-12lu\n", tp->stats_pktgun_pkts); #endif /*PPS_TESTING*/ #endif #ifdef CONFIG_NET_FASTROUTE p += sprintf(p, "fastroute pkts hits/succeed/deferred %lu/%lu/%lu\n", tp->stats_fastroute_hits, tp->stats_fastroute_succeed, tp->stats_fastroute_deferred); #endif p += sprintf(p, "\n"); } #ifdef FAST_SKB_RECYCLE p += sprintf(p, "skb statistics recycled/allocated %lu/%lu\n", recycle_hits, recycle_misses); #endif return p-buf; } int c_time(char *buf, unsigned i) { char *p; int hms, s, m, h, d; p = buf; d = i / 8400L; hms = i % 8400L; /* Hours, minutes, seconds are easy */ h = hms / 3600; m = (hms % 3600) / 60; s = (hms % 3600) % 60; if( d ) p += sprintf(p, "%d day(s) ", d ); if( h ) p += sprintf(p, "%d hour(s) ", h ); if( m ) p += sprintf(p, "%d min ", m ); if( s ) p += sprintf(p, "%d sec ", s ); if( !d && !h && !m && !s ) p += sprintf(p, "NOW"); return p-buf; } #endif /* CONFIG_PROC_FS */ #ifdef CARDBUS #include static dev_node_t *tulip_attach(dev_locator_t *loc) { struct device *dev; u16 dev_id; u32 io; u8 bus, devfn, irq; 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, -1); if (dev) { dev_node_t *node = kmalloc(sizeof(dev_node_t), GFP_KERNEL); strcpy(node->dev_name, dev->name); node->major = node->minor = 0; node->next = NULL; MOD_INC_USE_COUNT; return node; } return NULL; } static void tulip_suspend(dev_node_t *node) { struct 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) { struct tulip_private *tp = (struct tulip_private *)(*devp)->priv; tulip_close(*devp); /* Put the chip 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; 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); } } static void tulip_detach(dev_node_t *node) { struct 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) { unregister_netdev(*devp); kfree(*devp); *devp = *next; kfree(node); MOD_DEC_USE_COUNT; } } struct driver_operations tulip_ops = { "tulip_cb", tulip_attach, tulip_suspend, tulip_resume, tulip_detach }; #endif /* Cardbus support */ #ifdef MODULE int init_module(void) { #ifdef CARDBUS reverse_probe = 0; /* Not used. */ register_driver(&tulip_ops); return 0; #else return tulip_probe(NULL); #endif } void cleanup_module(void) { struct device *next_dev; #ifdef CARDBUS unregister_driver(&tulip_ops); #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; unregister_netdev(root_tulip_dev); release_region(root_tulip_dev->base_addr, tulip_tbl[tp->chip_id].io_size); kfree(root_tulip_dev); root_tulip_dev = next_dev; } #ifdef FAST_SKB_RECYCLE printk( KERN_INFO "Freeing tulip_recycle_list size was %lu\n", (long unsigned int)skb_queue_len(&tulip_recycle_list)); skb_queue_purge(&tulip_recycle_list); #endif #if 0 //def CONFIG_PROC_FS proc_net_unregister(tulip_proc_entry.low_ino); #endif } #endif /* MODULE */ /* * Local variables: * SMP-compile-command: "gcc -D__SMP__ -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -c tulip.c `[ -f /usr/include/linux/modversions.h ] && echo -DMODVERSIONS`" * compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -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.5/include/" * c-indent-level: 4 * c-basic-offset: 4 * tab-width: 4 * End: */