Home | History | Annotate | Line # | Download | only in ic
rtl8169.c revision 1.104.2.1
      1  1.104.2.1  wrstuden /*	$NetBSD: rtl8169.c,v 1.104.2.1 2008/09/18 04:35:04 wrstuden Exp $	*/
      2        1.1  jonathan 
      3        1.1  jonathan /*
      4        1.1  jonathan  * Copyright (c) 1997, 1998-2003
      5        1.1  jonathan  *	Bill Paul <wpaul (at) windriver.com>.  All rights reserved.
      6        1.1  jonathan  *
      7        1.1  jonathan  * Redistribution and use in source and binary forms, with or without
      8        1.1  jonathan  * modification, are permitted provided that the following conditions
      9        1.1  jonathan  * are met:
     10        1.1  jonathan  * 1. Redistributions of source code must retain the above copyright
     11        1.1  jonathan  *    notice, this list of conditions and the following disclaimer.
     12        1.1  jonathan  * 2. Redistributions in binary form must reproduce the above copyright
     13        1.1  jonathan  *    notice, this list of conditions and the following disclaimer in the
     14        1.1  jonathan  *    documentation and/or other materials provided with the distribution.
     15        1.1  jonathan  * 3. All advertising materials mentioning features or use of this software
     16        1.1  jonathan  *    must display the following acknowledgement:
     17        1.1  jonathan  *	This product includes software developed by Bill Paul.
     18        1.1  jonathan  * 4. Neither the name of the author nor the names of any co-contributors
     19        1.1  jonathan  *    may be used to endorse or promote products derived from this software
     20        1.1  jonathan  *    without specific prior written permission.
     21        1.1  jonathan  *
     22        1.1  jonathan  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
     23        1.1  jonathan  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24        1.1  jonathan  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25        1.1  jonathan  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
     26        1.1  jonathan  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     27        1.1  jonathan  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     28        1.1  jonathan  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     29        1.1  jonathan  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     30        1.1  jonathan  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     31        1.1  jonathan  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     32        1.1  jonathan  * THE POSSIBILITY OF SUCH DAMAGE.
     33        1.1  jonathan  */
     34        1.1  jonathan 
     35        1.1  jonathan #include <sys/cdefs.h>
     36  1.104.2.1  wrstuden __KERNEL_RCSID(0, "$NetBSD: rtl8169.c,v 1.104.2.1 2008/09/18 04:35:04 wrstuden Exp $");
     37        1.1  jonathan /* $FreeBSD: /repoman/r/ncvs/src/sys/dev/re/if_re.c,v 1.20 2004/04/11 20:34:08 ru Exp $ */
     38        1.1  jonathan 
     39        1.1  jonathan /*
     40        1.1  jonathan  * RealTek 8139C+/8169/8169S/8110S PCI NIC driver
     41        1.1  jonathan  *
     42        1.1  jonathan  * Written by Bill Paul <wpaul (at) windriver.com>
     43        1.1  jonathan  * Senior Networking Software Engineer
     44        1.1  jonathan  * Wind River Systems
     45        1.1  jonathan  */
     46        1.1  jonathan 
     47        1.1  jonathan /*
     48        1.1  jonathan  * This driver is designed to support RealTek's next generation of
     49        1.1  jonathan  * 10/100 and 10/100/1000 PCI ethernet controllers. There are currently
     50        1.1  jonathan  * four devices in this family: the RTL8139C+, the RTL8169, the RTL8169S
     51        1.1  jonathan  * and the RTL8110S.
     52        1.1  jonathan  *
     53        1.1  jonathan  * The 8139C+ is a 10/100 ethernet chip. It is backwards compatible
     54        1.1  jonathan  * with the older 8139 family, however it also supports a special
     55        1.1  jonathan  * C+ mode of operation that provides several new performance enhancing
     56        1.1  jonathan  * features. These include:
     57        1.1  jonathan  *
     58        1.1  jonathan  *	o Descriptor based DMA mechanism. Each descriptor represents
     59        1.1  jonathan  *	  a single packet fragment. Data buffers may be aligned on
     60        1.1  jonathan  *	  any byte boundary.
     61        1.1  jonathan  *
     62        1.1  jonathan  *	o 64-bit DMA
     63        1.1  jonathan  *
     64        1.1  jonathan  *	o TCP/IP checksum offload for both RX and TX
     65        1.1  jonathan  *
     66        1.1  jonathan  *	o High and normal priority transmit DMA rings
     67        1.1  jonathan  *
     68        1.1  jonathan  *	o VLAN tag insertion and extraction
     69        1.1  jonathan  *
     70        1.1  jonathan  *	o TCP large send (segmentation offload)
     71        1.1  jonathan  *
     72        1.1  jonathan  * Like the 8139, the 8139C+ also has a built-in 10/100 PHY. The C+
     73        1.1  jonathan  * programming API is fairly straightforward. The RX filtering, EEPROM
     74        1.1  jonathan  * access and PHY access is the same as it is on the older 8139 series
     75        1.1  jonathan  * chips.
     76        1.1  jonathan  *
     77        1.1  jonathan  * The 8169 is a 64-bit 10/100/1000 gigabit ethernet MAC. It has almost the
     78        1.1  jonathan  * same programming API and feature set as the 8139C+ with the following
     79        1.1  jonathan  * differences and additions:
     80        1.1  jonathan  *
     81        1.1  jonathan  *	o 1000Mbps mode
     82        1.1  jonathan  *
     83        1.1  jonathan  *	o Jumbo frames
     84        1.1  jonathan  *
     85        1.1  jonathan  * 	o GMII and TBI ports/registers for interfacing with copper
     86        1.1  jonathan  *	  or fiber PHYs
     87        1.1  jonathan  *
     88        1.1  jonathan  *      o RX and TX DMA rings can have up to 1024 descriptors
     89        1.1  jonathan  *        (the 8139C+ allows a maximum of 64)
     90        1.1  jonathan  *
     91        1.1  jonathan  *	o Slight differences in register layout from the 8139C+
     92        1.1  jonathan  *
     93        1.1  jonathan  * The TX start and timer interrupt registers are at different locations
     94        1.1  jonathan  * on the 8169 than they are on the 8139C+. Also, the status word in the
     95        1.1  jonathan  * RX descriptor has a slightly different bit layout. The 8169 does not
     96        1.1  jonathan  * have a built-in PHY. Most reference boards use a Marvell 88E1000 'Alaska'
     97        1.1  jonathan  * copper gigE PHY.
     98        1.1  jonathan  *
     99        1.1  jonathan  * The 8169S/8110S 10/100/1000 devices have built-in copper gigE PHYs
    100        1.1  jonathan  * (the 'S' stands for 'single-chip'). These devices have the same
    101        1.1  jonathan  * programming API as the older 8169, but also have some vendor-specific
    102        1.1  jonathan  * registers for the on-board PHY. The 8110S is a LAN-on-motherboard
    103        1.1  jonathan  * part designed to be pin-compatible with the RealTek 8100 10/100 chip.
    104       1.12     perry  *
    105        1.1  jonathan  * This driver takes advantage of the RX and TX checksum offload and
    106        1.1  jonathan  * VLAN tag insertion/extraction features. It also implements TX
    107        1.1  jonathan  * interrupt moderation using the timer interrupt registers, which
    108        1.1  jonathan  * significantly reduces TX interrupt load. There is also support
    109        1.1  jonathan  * for jumbo frames, however the 8169/8169S/8110S can not transmit
    110        1.1  jonathan  * jumbo frames larger than 7.5K, so the max MTU possible with this
    111        1.1  jonathan  * driver is 7500 bytes.
    112        1.1  jonathan  */
    113        1.1  jonathan 
    114        1.1  jonathan #include "bpfilter.h"
    115        1.1  jonathan #include "vlan.h"
    116        1.1  jonathan 
    117        1.1  jonathan #include <sys/param.h>
    118        1.1  jonathan #include <sys/endian.h>
    119        1.1  jonathan #include <sys/systm.h>
    120        1.1  jonathan #include <sys/sockio.h>
    121        1.1  jonathan #include <sys/mbuf.h>
    122        1.1  jonathan #include <sys/malloc.h>
    123        1.1  jonathan #include <sys/kernel.h>
    124        1.1  jonathan #include <sys/socket.h>
    125        1.1  jonathan #include <sys/device.h>
    126        1.1  jonathan 
    127        1.1  jonathan #include <net/if.h>
    128        1.1  jonathan #include <net/if_arp.h>
    129        1.1  jonathan #include <net/if_dl.h>
    130        1.1  jonathan #include <net/if_ether.h>
    131        1.1  jonathan #include <net/if_media.h>
    132        1.1  jonathan #include <net/if_vlanvar.h>
    133        1.1  jonathan 
    134       1.13      yamt #include <netinet/in_systm.h>	/* XXX for IP_MAXPACKET */
    135       1.13      yamt #include <netinet/in.h>		/* XXX for IP_MAXPACKET */
    136       1.13      yamt #include <netinet/ip.h>		/* XXX for IP_MAXPACKET */
    137       1.13      yamt 
    138        1.1  jonathan #if NBPFILTER > 0
    139        1.1  jonathan #include <net/bpf.h>
    140        1.1  jonathan #endif
    141        1.1  jonathan 
    142       1.89        ad #include <sys/bus.h>
    143        1.1  jonathan 
    144        1.1  jonathan #include <dev/mii/mii.h>
    145        1.1  jonathan #include <dev/mii/miivar.h>
    146        1.1  jonathan 
    147        1.1  jonathan #include <dev/ic/rtl81x9reg.h>
    148        1.1  jonathan #include <dev/ic/rtl81x9var.h>
    149        1.1  jonathan 
    150        1.1  jonathan #include <dev/ic/rtl8169var.h>
    151        1.1  jonathan 
    152       1.64   tsutsui static inline void re_set_bufaddr(struct re_desc *, bus_addr_t);
    153        1.1  jonathan 
    154        1.4   kanaoka static int re_newbuf(struct rtk_softc *, int, struct mbuf *);
    155        1.4   kanaoka static int re_rx_list_init(struct rtk_softc *);
    156        1.4   kanaoka static int re_tx_list_init(struct rtk_softc *);
    157        1.4   kanaoka static void re_rxeof(struct rtk_softc *);
    158        1.4   kanaoka static void re_txeof(struct rtk_softc *);
    159        1.4   kanaoka static void re_tick(void *);
    160        1.4   kanaoka static void re_start(struct ifnet *);
    161       1.83  christos static int re_ioctl(struct ifnet *, u_long, void *);
    162        1.4   kanaoka static int re_init(struct ifnet *);
    163        1.4   kanaoka static void re_stop(struct ifnet *, int);
    164        1.4   kanaoka static void re_watchdog(struct ifnet *);
    165        1.4   kanaoka 
    166        1.4   kanaoka static int re_enable(struct rtk_softc *);
    167        1.4   kanaoka static void re_disable(struct rtk_softc *);
    168        1.4   kanaoka 
    169        1.4   kanaoka static int re_gmii_readreg(struct device *, int, int);
    170        1.4   kanaoka static void re_gmii_writereg(struct device *, int, int, int);
    171        1.4   kanaoka 
    172        1.4   kanaoka static int re_miibus_readreg(struct device *, int, int);
    173        1.4   kanaoka static void re_miibus_writereg(struct device *, int, int, int);
    174        1.4   kanaoka static void re_miibus_statchg(struct device *);
    175        1.1  jonathan 
    176        1.4   kanaoka static void re_reset(struct rtk_softc *);
    177        1.1  jonathan 
    178       1.64   tsutsui static inline void
    179       1.64   tsutsui re_set_bufaddr(struct re_desc *d, bus_addr_t addr)
    180       1.64   tsutsui {
    181       1.64   tsutsui 
    182       1.64   tsutsui 	d->re_bufaddr_lo = htole32((uint32_t)addr);
    183       1.64   tsutsui 	if (sizeof(bus_addr_t) == sizeof(uint64_t))
    184       1.64   tsutsui 		d->re_bufaddr_hi = htole32((uint64_t)addr >> 32);
    185       1.64   tsutsui 	else
    186       1.64   tsutsui 		d->re_bufaddr_hi = 0;
    187       1.64   tsutsui }
    188       1.64   tsutsui 
    189        1.1  jonathan static int
    190      1.103   tsutsui re_gmii_readreg(device_t dev, int phy, int reg)
    191        1.1  jonathan {
    192      1.103   tsutsui 	struct rtk_softc *sc = device_private(dev);
    193      1.102   tsutsui 	uint32_t rval;
    194      1.102   tsutsui 	int i;
    195        1.1  jonathan 
    196        1.1  jonathan 	if (phy != 7)
    197        1.4   kanaoka 		return 0;
    198        1.1  jonathan 
    199        1.1  jonathan 	/* Let the rgephy driver read the GMEDIASTAT register */
    200        1.1  jonathan 
    201        1.1  jonathan 	if (reg == RTK_GMEDIASTAT) {
    202        1.1  jonathan 		rval = CSR_READ_1(sc, RTK_GMEDIASTAT);
    203        1.4   kanaoka 		return rval;
    204        1.1  jonathan 	}
    205        1.1  jonathan 
    206        1.1  jonathan 	CSR_WRITE_4(sc, RTK_PHYAR, reg << 16);
    207        1.1  jonathan 	DELAY(1000);
    208        1.1  jonathan 
    209        1.1  jonathan 	for (i = 0; i < RTK_TIMEOUT; i++) {
    210        1.1  jonathan 		rval = CSR_READ_4(sc, RTK_PHYAR);
    211        1.1  jonathan 		if (rval & RTK_PHYAR_BUSY)
    212        1.1  jonathan 			break;
    213        1.1  jonathan 		DELAY(100);
    214        1.1  jonathan 	}
    215        1.1  jonathan 
    216        1.1  jonathan 	if (i == RTK_TIMEOUT) {
    217      1.102   tsutsui 		printf("%s: PHY read failed\n", device_xname(sc->sc_dev));
    218        1.4   kanaoka 		return 0;
    219        1.1  jonathan 	}
    220        1.1  jonathan 
    221        1.4   kanaoka 	return rval & RTK_PHYAR_PHYDATA;
    222        1.1  jonathan }
    223        1.1  jonathan 
    224        1.1  jonathan static void
    225      1.102   tsutsui re_gmii_writereg(device_t dev, int phy, int reg, int data)
    226        1.1  jonathan {
    227      1.102   tsutsui 	struct rtk_softc *sc = device_private(dev);
    228      1.102   tsutsui 	uint32_t rval;
    229      1.102   tsutsui 	int i;
    230        1.1  jonathan 
    231        1.1  jonathan 	CSR_WRITE_4(sc, RTK_PHYAR, (reg << 16) |
    232        1.1  jonathan 	    (data & RTK_PHYAR_PHYDATA) | RTK_PHYAR_BUSY);
    233        1.1  jonathan 	DELAY(1000);
    234        1.1  jonathan 
    235        1.1  jonathan 	for (i = 0; i < RTK_TIMEOUT; i++) {
    236        1.1  jonathan 		rval = CSR_READ_4(sc, RTK_PHYAR);
    237        1.1  jonathan 		if (!(rval & RTK_PHYAR_BUSY))
    238        1.1  jonathan 			break;
    239        1.1  jonathan 		DELAY(100);
    240        1.1  jonathan 	}
    241        1.1  jonathan 
    242        1.1  jonathan 	if (i == RTK_TIMEOUT) {
    243      1.101   tsutsui 		printf("%s: PHY write reg %x <- %x failed\n",
    244      1.102   tsutsui 		    device_xname(sc->sc_dev), reg, data);
    245        1.1  jonathan 	}
    246        1.1  jonathan }
    247        1.1  jonathan 
    248        1.1  jonathan static int
    249      1.102   tsutsui re_miibus_readreg(device_t dev, int phy, int reg)
    250        1.1  jonathan {
    251      1.102   tsutsui 	struct rtk_softc *sc = device_private(dev);
    252      1.102   tsutsui 	uint16_t rval = 0;
    253      1.102   tsutsui 	uint16_t re8139_reg = 0;
    254      1.102   tsutsui 	int s;
    255        1.1  jonathan 
    256        1.1  jonathan 	s = splnet();
    257        1.1  jonathan 
    258       1.84   tsutsui 	if ((sc->sc_quirk & RTKQ_8139CPLUS) == 0) {
    259        1.1  jonathan 		rval = re_gmii_readreg(dev, phy, reg);
    260        1.1  jonathan 		splx(s);
    261        1.4   kanaoka 		return rval;
    262        1.1  jonathan 	}
    263        1.1  jonathan 
    264        1.1  jonathan 	/* Pretend the internal PHY is only at address 0 */
    265        1.1  jonathan 	if (phy) {
    266        1.1  jonathan 		splx(s);
    267        1.4   kanaoka 		return 0;
    268        1.1  jonathan 	}
    269        1.4   kanaoka 	switch (reg) {
    270        1.1  jonathan 	case MII_BMCR:
    271        1.1  jonathan 		re8139_reg = RTK_BMCR;
    272        1.1  jonathan 		break;
    273        1.1  jonathan 	case MII_BMSR:
    274        1.1  jonathan 		re8139_reg = RTK_BMSR;
    275        1.1  jonathan 		break;
    276        1.1  jonathan 	case MII_ANAR:
    277        1.1  jonathan 		re8139_reg = RTK_ANAR;
    278        1.1  jonathan 		break;
    279        1.1  jonathan 	case MII_ANER:
    280        1.1  jonathan 		re8139_reg = RTK_ANER;
    281        1.1  jonathan 		break;
    282        1.1  jonathan 	case MII_ANLPAR:
    283        1.1  jonathan 		re8139_reg = RTK_LPAR;
    284        1.1  jonathan 		break;
    285        1.1  jonathan 	case MII_PHYIDR1:
    286        1.1  jonathan 	case MII_PHYIDR2:
    287        1.1  jonathan 		splx(s);
    288        1.4   kanaoka 		return 0;
    289        1.1  jonathan 	/*
    290        1.1  jonathan 	 * Allow the rlphy driver to read the media status
    291        1.1  jonathan 	 * register. If we have a link partner which does not
    292        1.1  jonathan 	 * support NWAY, this is the register which will tell
    293        1.1  jonathan 	 * us the results of parallel detection.
    294        1.1  jonathan 	 */
    295        1.1  jonathan 	case RTK_MEDIASTAT:
    296        1.1  jonathan 		rval = CSR_READ_1(sc, RTK_MEDIASTAT);
    297        1.1  jonathan 		splx(s);
    298        1.4   kanaoka 		return rval;
    299        1.1  jonathan 	default:
    300      1.102   tsutsui 		printf("%s: bad phy register\n", device_xname(sc->sc_dev));
    301        1.1  jonathan 		splx(s);
    302        1.4   kanaoka 		return 0;
    303        1.1  jonathan 	}
    304        1.1  jonathan 	rval = CSR_READ_2(sc, re8139_reg);
    305       1.84   tsutsui 	if ((sc->sc_quirk & RTKQ_8139CPLUS) != 0 && re8139_reg == RTK_BMCR) {
    306       1.51   tsutsui 		/* 8139C+ has different bit layout. */
    307       1.51   tsutsui 		rval &= ~(BMCR_LOOP | BMCR_ISO);
    308       1.51   tsutsui 	}
    309        1.1  jonathan 	splx(s);
    310        1.4   kanaoka 	return rval;
    311        1.1  jonathan }
    312        1.1  jonathan 
    313        1.1  jonathan static void
    314      1.102   tsutsui re_miibus_writereg(device_t dev, int phy, int reg, int data)
    315        1.1  jonathan {
    316      1.102   tsutsui 	struct rtk_softc *sc = device_private(dev);
    317      1.102   tsutsui 	uint16_t re8139_reg = 0;
    318      1.102   tsutsui 	int s;
    319        1.1  jonathan 
    320        1.1  jonathan 	s = splnet();
    321        1.1  jonathan 
    322       1.84   tsutsui 	if ((sc->sc_quirk & RTKQ_8139CPLUS) == 0) {
    323        1.1  jonathan 		re_gmii_writereg(dev, phy, reg, data);
    324        1.1  jonathan 		splx(s);
    325        1.1  jonathan 		return;
    326        1.1  jonathan 	}
    327        1.1  jonathan 
    328        1.1  jonathan 	/* Pretend the internal PHY is only at address 0 */
    329        1.1  jonathan 	if (phy) {
    330        1.1  jonathan 		splx(s);
    331        1.1  jonathan 		return;
    332        1.1  jonathan 	}
    333        1.4   kanaoka 	switch (reg) {
    334        1.1  jonathan 	case MII_BMCR:
    335        1.1  jonathan 		re8139_reg = RTK_BMCR;
    336       1.84   tsutsui 		if ((sc->sc_quirk & RTKQ_8139CPLUS) != 0) {
    337       1.51   tsutsui 			/* 8139C+ has different bit layout. */
    338       1.51   tsutsui 			data &= ~(BMCR_LOOP | BMCR_ISO);
    339       1.51   tsutsui 		}
    340        1.1  jonathan 		break;
    341        1.1  jonathan 	case MII_BMSR:
    342        1.1  jonathan 		re8139_reg = RTK_BMSR;
    343        1.1  jonathan 		break;
    344        1.1  jonathan 	case MII_ANAR:
    345        1.1  jonathan 		re8139_reg = RTK_ANAR;
    346        1.1  jonathan 		break;
    347        1.1  jonathan 	case MII_ANER:
    348        1.1  jonathan 		re8139_reg = RTK_ANER;
    349        1.1  jonathan 		break;
    350        1.1  jonathan 	case MII_ANLPAR:
    351        1.1  jonathan 		re8139_reg = RTK_LPAR;
    352        1.1  jonathan 		break;
    353        1.1  jonathan 	case MII_PHYIDR1:
    354        1.1  jonathan 	case MII_PHYIDR2:
    355        1.1  jonathan 		splx(s);
    356        1.1  jonathan 		return;
    357        1.1  jonathan 		break;
    358        1.1  jonathan 	default:
    359      1.102   tsutsui 		printf("%s: bad phy register\n", device_xname(sc->sc_dev));
    360        1.1  jonathan 		splx(s);
    361        1.1  jonathan 		return;
    362        1.1  jonathan 	}
    363        1.1  jonathan 	CSR_WRITE_2(sc, re8139_reg, data);
    364        1.1  jonathan 	splx(s);
    365        1.1  jonathan 	return;
    366        1.1  jonathan }
    367        1.1  jonathan 
    368        1.1  jonathan static void
    369      1.102   tsutsui re_miibus_statchg(device_t dev)
    370        1.1  jonathan {
    371        1.1  jonathan 
    372        1.1  jonathan 	return;
    373        1.1  jonathan }
    374        1.1  jonathan 
    375        1.1  jonathan static void
    376        1.1  jonathan re_reset(struct rtk_softc *sc)
    377        1.1  jonathan {
    378      1.102   tsutsui 	int i;
    379        1.1  jonathan 
    380        1.1  jonathan 	CSR_WRITE_1(sc, RTK_COMMAND, RTK_CMD_RESET);
    381        1.1  jonathan 
    382        1.1  jonathan 	for (i = 0; i < RTK_TIMEOUT; i++) {
    383        1.1  jonathan 		DELAY(10);
    384       1.41   tsutsui 		if ((CSR_READ_1(sc, RTK_COMMAND) & RTK_CMD_RESET) == 0)
    385        1.1  jonathan 			break;
    386        1.1  jonathan 	}
    387        1.1  jonathan 	if (i == RTK_TIMEOUT)
    388      1.101   tsutsui 		printf("%s: reset never completed!\n",
    389      1.102   tsutsui 		    device_xname(sc->sc_dev));
    390        1.1  jonathan 
    391        1.1  jonathan 	/*
    392        1.1  jonathan 	 * NB: Realtek-supplied Linux driver does this only for
    393      1.104   tsutsui 	 * MCFG_METHOD_2, which corresponds to sc->sc_rev == 3.
    394        1.1  jonathan 	 */
    395        1.4   kanaoka 	if (1) /* XXX check softc flag for 8169s version */
    396       1.66   tsutsui 		CSR_WRITE_1(sc, RTK_LDPS, 1);
    397        1.1  jonathan 
    398        1.1  jonathan }
    399        1.1  jonathan 
    400        1.1  jonathan /*
    401        1.1  jonathan  * The following routine is designed to test for a defect on some
    402        1.1  jonathan  * 32-bit 8169 cards. Some of these NICs have the REQ64# and ACK64#
    403        1.1  jonathan  * lines connected to the bus, however for a 32-bit only card, they
    404        1.1  jonathan  * should be pulled high. The result of this defect is that the
    405        1.1  jonathan  * NIC will not work right if you plug it into a 64-bit slot: DMA
    406        1.1  jonathan  * operations will be done with 64-bit transfers, which will fail
    407        1.1  jonathan  * because the 64-bit data lines aren't connected.
    408        1.1  jonathan  *
    409        1.1  jonathan  * There's no way to work around this (short of talking a soldering
    410        1.1  jonathan  * iron to the board), however we can detect it. The method we use
    411        1.1  jonathan  * here is to put the NIC into digital loopback mode, set the receiver
    412        1.1  jonathan  * to promiscuous mode, and then try to send a frame. We then compare
    413        1.1  jonathan  * the frame data we sent to what was received. If the data matches,
    414        1.1  jonathan  * then the NIC is working correctly, otherwise we know the user has
    415        1.1  jonathan  * a defective NIC which has been mistakenly plugged into a 64-bit PCI
    416        1.1  jonathan  * slot. In the latter case, there's no way the NIC can work correctly,
    417        1.1  jonathan  * so we print out a message on the console and abort the device attach.
    418        1.1  jonathan  */
    419        1.1  jonathan 
    420        1.6   kanaoka int
    421        1.1  jonathan re_diag(struct rtk_softc *sc)
    422        1.1  jonathan {
    423      1.102   tsutsui 	struct ifnet *ifp = &sc->ethercom.ec_if;
    424      1.102   tsutsui 	struct mbuf *m0;
    425      1.102   tsutsui 	struct ether_header *eh;
    426      1.102   tsutsui 	struct re_rxsoft *rxs;
    427      1.102   tsutsui 	struct re_desc *cur_rx;
    428      1.102   tsutsui 	bus_dmamap_t dmamap;
    429      1.102   tsutsui 	uint16_t status;
    430      1.102   tsutsui 	uint32_t rxstat;
    431      1.102   tsutsui 	int total_len, i, s, error = 0;
    432      1.102   tsutsui 	static const uint8_t dst[] = { 0x00, 'h', 'e', 'l', 'l', 'o' };
    433      1.102   tsutsui 	static const uint8_t src[] = { 0x00, 'w', 'o', 'r', 'l', 'd' };
    434        1.1  jonathan 
    435        1.1  jonathan 	/* Allocate a single mbuf */
    436        1.1  jonathan 
    437        1.1  jonathan 	MGETHDR(m0, M_DONTWAIT, MT_DATA);
    438        1.1  jonathan 	if (m0 == NULL)
    439        1.4   kanaoka 		return ENOBUFS;
    440        1.1  jonathan 
    441        1.1  jonathan 	/*
    442        1.1  jonathan 	 * Initialize the NIC in test mode. This sets the chip up
    443        1.1  jonathan 	 * so that it can send and receive frames, but performs the
    444        1.1  jonathan 	 * following special functions:
    445        1.1  jonathan 	 * - Puts receiver in promiscuous mode
    446        1.1  jonathan 	 * - Enables digital loopback mode
    447        1.1  jonathan 	 * - Leaves interrupts turned off
    448        1.1  jonathan 	 */
    449        1.1  jonathan 
    450        1.1  jonathan 	ifp->if_flags |= IFF_PROMISC;
    451       1.52   tsutsui 	sc->re_testmode = 1;
    452        1.1  jonathan 	re_init(ifp);
    453        1.6   kanaoka 	re_stop(ifp, 0);
    454        1.1  jonathan 	DELAY(100000);
    455        1.1  jonathan 	re_init(ifp);
    456        1.1  jonathan 
    457        1.1  jonathan 	/* Put some data in the mbuf */
    458        1.1  jonathan 
    459        1.1  jonathan 	eh = mtod(m0, struct ether_header *);
    460       1.36   tsutsui 	memcpy(eh->ether_dhost, (char *)&dst, ETHER_ADDR_LEN);
    461       1.36   tsutsui 	memcpy(eh->ether_shost, (char *)&src, ETHER_ADDR_LEN);
    462        1.1  jonathan 	eh->ether_type = htons(ETHERTYPE_IP);
    463        1.1  jonathan 	m0->m_pkthdr.len = m0->m_len = ETHER_MIN_LEN - ETHER_CRC_LEN;
    464        1.1  jonathan 
    465        1.1  jonathan 	/*
    466        1.1  jonathan 	 * Queue the packet, start transmission.
    467        1.1  jonathan 	 */
    468        1.1  jonathan 
    469        1.1  jonathan 	CSR_WRITE_2(sc, RTK_ISR, 0xFFFF);
    470        1.1  jonathan 	s = splnet();
    471        1.1  jonathan 	IF_ENQUEUE(&ifp->if_snd, m0);
    472        1.1  jonathan 	re_start(ifp);
    473        1.1  jonathan 	splx(s);
    474        1.1  jonathan 	m0 = NULL;
    475        1.1  jonathan 
    476        1.1  jonathan 	/* Wait for it to propagate through the chip */
    477        1.1  jonathan 
    478        1.1  jonathan 	DELAY(100000);
    479        1.1  jonathan 	for (i = 0; i < RTK_TIMEOUT; i++) {
    480        1.1  jonathan 		status = CSR_READ_2(sc, RTK_ISR);
    481        1.4   kanaoka 		if ((status & (RTK_ISR_TIMEOUT_EXPIRED | RTK_ISR_RX_OK)) ==
    482        1.4   kanaoka 		    (RTK_ISR_TIMEOUT_EXPIRED | RTK_ISR_RX_OK))
    483        1.1  jonathan 			break;
    484        1.1  jonathan 		DELAY(10);
    485        1.1  jonathan 	}
    486        1.1  jonathan 	if (i == RTK_TIMEOUT) {
    487      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    488      1.101   tsutsui 		    "diagnostic failed, failed to receive packet "
    489       1.99    cegger 		    "in loopback mode\n");
    490        1.1  jonathan 		error = EIO;
    491        1.1  jonathan 		goto done;
    492        1.1  jonathan 	}
    493        1.1  jonathan 
    494        1.1  jonathan 	/*
    495        1.1  jonathan 	 * The packet should have been dumped into the first
    496        1.1  jonathan 	 * entry in the RX DMA ring. Grab it from there.
    497        1.1  jonathan 	 */
    498        1.1  jonathan 
    499       1.52   tsutsui 	rxs = &sc->re_ldata.re_rxsoft[0];
    500       1.50   tsutsui 	dmamap = rxs->rxs_dmamap;
    501        1.1  jonathan 	bus_dmamap_sync(sc->sc_dmat, dmamap, 0, dmamap->dm_mapsize,
    502       1.20    briggs 	    BUS_DMASYNC_POSTREAD);
    503       1.50   tsutsui 	bus_dmamap_unload(sc->sc_dmat, dmamap);
    504        1.1  jonathan 
    505       1.50   tsutsui 	m0 = rxs->rxs_mbuf;
    506       1.50   tsutsui 	rxs->rxs_mbuf = NULL;
    507        1.1  jonathan 	eh = mtod(m0, struct ether_header *);
    508        1.1  jonathan 
    509       1.52   tsutsui 	RE_RXDESCSYNC(sc, 0, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
    510       1.52   tsutsui 	cur_rx = &sc->re_ldata.re_rx_list[0];
    511       1.52   tsutsui 	rxstat = le32toh(cur_rx->re_cmdstat);
    512       1.52   tsutsui 	total_len = rxstat & sc->re_rxlenmask;
    513        1.1  jonathan 
    514        1.1  jonathan 	if (total_len != ETHER_MIN_LEN) {
    515      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    516      1.101   tsutsui 		    "diagnostic failed, received short packet\n");
    517        1.1  jonathan 		error = EIO;
    518        1.1  jonathan 		goto done;
    519        1.1  jonathan 	}
    520        1.1  jonathan 
    521        1.1  jonathan 	/* Test that the received packet data matches what we sent. */
    522        1.1  jonathan 
    523       1.36   tsutsui 	if (memcmp((char *)&eh->ether_dhost, (char *)&dst, ETHER_ADDR_LEN) ||
    524       1.36   tsutsui 	    memcmp((char *)&eh->ether_shost, (char *)&src, ETHER_ADDR_LEN) ||
    525        1.1  jonathan 	    ntohs(eh->ether_type) != ETHERTYPE_IP) {
    526      1.102   tsutsui 		aprint_error_dev(sc->sc_dev, "WARNING, DMA FAILURE!\n");
    527      1.102   tsutsui 		aprint_error_dev(sc->sc_dev, "expected TX data: %s",
    528       1.99    cegger 		    ether_sprintf(dst));
    529        1.4   kanaoka 		aprint_error("/%s/0x%x\n", ether_sprintf(src), ETHERTYPE_IP);
    530      1.102   tsutsui 		aprint_error_dev(sc->sc_dev, "received RX data: %s",
    531        1.1  jonathan 		    ether_sprintf(eh->ether_dhost));
    532        1.4   kanaoka 		aprint_error("/%s/0x%x\n", ether_sprintf(eh->ether_shost),
    533        1.1  jonathan 		    ntohs(eh->ether_type));
    534      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    535      1.101   tsutsui 		    "You may have a defective 32-bit NIC plugged "
    536       1.99    cegger 		    "into a 64-bit PCI slot.\n");
    537      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    538      1.101   tsutsui 		    "Please re-install the NIC in a 32-bit slot "
    539       1.99    cegger 		    "for proper operation.\n");
    540      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    541      1.101   tsutsui 		    "Read the re(4) man page for more details.\n");
    542        1.1  jonathan 		error = EIO;
    543        1.1  jonathan 	}
    544        1.1  jonathan 
    545       1.41   tsutsui  done:
    546        1.1  jonathan 	/* Turn interface off, release resources */
    547        1.1  jonathan 
    548       1.52   tsutsui 	sc->re_testmode = 0;
    549        1.1  jonathan 	ifp->if_flags &= ~IFF_PROMISC;
    550        1.6   kanaoka 	re_stop(ifp, 0);
    551        1.1  jonathan 	if (m0 != NULL)
    552        1.1  jonathan 		m_freem(m0);
    553        1.1  jonathan 
    554        1.4   kanaoka 	return error;
    555        1.1  jonathan }
    556        1.1  jonathan 
    557        1.1  jonathan 
    558        1.1  jonathan /*
    559        1.1  jonathan  * Attach the interface. Allocate softc structures, do ifmedia
    560        1.1  jonathan  * setup and ethernet/BPF attach.
    561        1.1  jonathan  */
    562        1.1  jonathan void
    563        1.1  jonathan re_attach(struct rtk_softc *sc)
    564        1.1  jonathan {
    565      1.102   tsutsui 	uint8_t eaddr[ETHER_ADDR_LEN];
    566      1.102   tsutsui 	uint16_t val;
    567      1.102   tsutsui 	struct ifnet *ifp;
    568      1.102   tsutsui 	int error = 0, i, addr_len;
    569        1.1  jonathan 
    570        1.1  jonathan 	/* Reset the adapter. */
    571        1.1  jonathan 	re_reset(sc);
    572        1.1  jonathan 
    573       1.84   tsutsui 	if ((sc->sc_quirk & RTKQ_8139CPLUS) == 0) {
    574        1.1  jonathan 		uint32_t hwrev;
    575        1.1  jonathan 
    576        1.1  jonathan 		/* Revision of 8169/8169S/8110s in bits 30..26, 23 */
    577       1.78   tsutsui 		hwrev = CSR_READ_4(sc, RTK_TXCFG) & RTK_TXCFG_HWREV;
    578       1.78   tsutsui 		/* These rev numbers are taken from Realtek's driver */
    579      1.104   tsutsui 		switch (hwrev) {
    580      1.104   tsutsui 		case RTK_HWREV_8169:
    581      1.104   tsutsui 			/* XXX not in the Realtek driver */
    582        1.1  jonathan 			sc->sc_rev = 1;
    583       1.84   tsutsui 			sc->sc_quirk |= RTKQ_8169NONS;
    584      1.104   tsutsui 			break;
    585      1.104   tsutsui 		case RTK_HWREV_8169S:
    586      1.104   tsutsui 		case RTK_HWREV_8110S:
    587      1.104   tsutsui 			sc->sc_rev = 3;
    588      1.104   tsutsui 			break;
    589      1.104   tsutsui 		case RTK_HWREV_8169_8110SB:
    590      1.104   tsutsui 			sc->sc_rev = 4;
    591      1.104   tsutsui 			break;
    592      1.104   tsutsui 		case RTK_HWREV_8169_8110SC:
    593      1.104   tsutsui 			sc->sc_rev = 5;
    594      1.104   tsutsui 			break;
    595      1.104   tsutsui 		case RTK_HWREV_8101E:
    596      1.104   tsutsui 			sc->sc_rev = 11;
    597      1.104   tsutsui 			break;
    598      1.104   tsutsui 		case RTK_HWREV_8168_SPIN1:
    599      1.104   tsutsui 			sc->sc_rev = 21;
    600      1.104   tsutsui 			break;
    601      1.104   tsutsui 		case RTK_HWREV_8168_SPIN2:
    602      1.104   tsutsui 			sc->sc_rev = 22;
    603      1.104   tsutsui 			break;
    604      1.104   tsutsui 		case RTK_HWREV_8168_SPIN3:
    605      1.104   tsutsui 			sc->sc_rev = 23;
    606      1.104   tsutsui 			break;
    607      1.104   tsutsui 		case RTK_HWREV_8168C:
    608      1.104   tsutsui 			sc->sc_rev = 24;
    609      1.104   tsutsui 			break;
    610  1.104.2.1  wrstuden 		case RTK_HWREV_8102E:
    611  1.104.2.1  wrstuden 		case RTK_HWREV_8102EL:
    612  1.104.2.1  wrstuden 			sc->sc_rev = 25;
    613  1.104.2.1  wrstuden 			break;
    614      1.104   tsutsui 		case RTK_HWREV_8100E:
    615      1.104   tsutsui 		case RTK_HWREV_8100E_SPIN2:
    616      1.104   tsutsui 			/* XXX not in the Realtek driver */
    617      1.104   tsutsui 			sc->sc_rev = 0;
    618      1.104   tsutsui 			break;
    619      1.104   tsutsui 		default:
    620      1.102   tsutsui 			aprint_normal_dev(sc->sc_dev,
    621      1.101   tsutsui 			    "Unknown revision (0x%08x)\n", hwrev);
    622      1.104   tsutsui 			sc->sc_rev = 0;
    623       1.84   tsutsui 		}
    624        1.1  jonathan 
    625        1.1  jonathan 		/* Set RX length mask */
    626       1.52   tsutsui 		sc->re_rxlenmask = RE_RDESC_STAT_GFRAGLEN;
    627       1.52   tsutsui 		sc->re_ldata.re_tx_desc_cnt = RE_TX_DESC_CNT_8169;
    628        1.1  jonathan 	} else {
    629        1.1  jonathan 		/* Set RX length mask */
    630       1.52   tsutsui 		sc->re_rxlenmask = RE_RDESC_STAT_FRAGLEN;
    631       1.52   tsutsui 		sc->re_ldata.re_tx_desc_cnt = RE_TX_DESC_CNT_8139;
    632        1.1  jonathan 	}
    633        1.1  jonathan 
    634  1.104.2.1  wrstuden 	if (sc->sc_rev == 24 || sc->sc_rev == 25) {
    635      1.104   tsutsui 		/*
    636      1.104   tsutsui 		 * Get station address from ID registers.
    637      1.104   tsutsui 		 */
    638      1.104   tsutsui 		for (i = 0; i < ETHER_ADDR_LEN; i++)
    639      1.104   tsutsui 			eaddr[i] = CSR_READ_1(sc, RTK_IDR0 + i);
    640      1.104   tsutsui 	} else {
    641      1.104   tsutsui 		/*
    642      1.104   tsutsui 		 * Get station address from the EEPROM.
    643      1.104   tsutsui 		 */
    644      1.104   tsutsui 		if (rtk_read_eeprom(sc, RTK_EE_ID, RTK_EEADDR_LEN1) == 0x8129)
    645      1.104   tsutsui 			addr_len = RTK_EEADDR_LEN1;
    646      1.104   tsutsui 		else
    647      1.104   tsutsui 			addr_len = RTK_EEADDR_LEN0;
    648      1.104   tsutsui 
    649      1.104   tsutsui 		/*
    650      1.104   tsutsui 		 * Get station address from the EEPROM.
    651      1.104   tsutsui 		 */
    652      1.104   tsutsui 		for (i = 0; i < ETHER_ADDR_LEN / 2; i++) {
    653      1.104   tsutsui 			val = rtk_read_eeprom(sc, RTK_EE_EADDR0 + i, addr_len);
    654      1.104   tsutsui 			eaddr[(i * 2) + 0] = val & 0xff;
    655      1.104   tsutsui 			eaddr[(i * 2) + 1] = val >> 8;
    656      1.104   tsutsui 		}
    657      1.104   tsutsui 	}
    658      1.104   tsutsui 
    659      1.102   tsutsui 	aprint_normal_dev(sc->sc_dev, "Ethernet address %s\n",
    660       1.99    cegger 	    ether_sprintf(eaddr));
    661        1.1  jonathan 
    662       1.52   tsutsui 	if (sc->re_ldata.re_tx_desc_cnt >
    663       1.52   tsutsui 	    PAGE_SIZE / sizeof(struct re_desc)) {
    664       1.52   tsutsui 		sc->re_ldata.re_tx_desc_cnt =
    665       1.52   tsutsui 		    PAGE_SIZE / sizeof(struct re_desc);
    666       1.15      yamt 	}
    667       1.15      yamt 
    668      1.102   tsutsui 	aprint_verbose_dev(sc->sc_dev, "using %d tx descriptors\n",
    669       1.99    cegger 	    sc->re_ldata.re_tx_desc_cnt);
    670       1.65   tsutsui 	KASSERT(RE_NEXT_TX_DESC(sc, RE_TX_DESC_CNT(sc) - 1) == 0);
    671        1.1  jonathan 
    672        1.5   kanaoka 	/* Allocate DMA'able memory for the TX ring */
    673       1.52   tsutsui 	if ((error = bus_dmamem_alloc(sc->sc_dmat, RE_TX_LIST_SZ(sc),
    674       1.52   tsutsui 	    RE_RING_ALIGN, 0, &sc->re_ldata.re_tx_listseg, 1,
    675       1.52   tsutsui 	    &sc->re_ldata.re_tx_listnseg, BUS_DMA_NOWAIT)) != 0) {
    676      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    677      1.101   tsutsui 		    "can't allocate tx listseg, error = %d\n", error);
    678        1.5   kanaoka 		goto fail_0;
    679        1.5   kanaoka 	}
    680        1.5   kanaoka 
    681        1.5   kanaoka 	/* Load the map for the TX ring. */
    682       1.52   tsutsui 	if ((error = bus_dmamem_map(sc->sc_dmat, &sc->re_ldata.re_tx_listseg,
    683       1.52   tsutsui 	    sc->re_ldata.re_tx_listnseg, RE_TX_LIST_SZ(sc),
    684       1.83  christos 	    (void **)&sc->re_ldata.re_tx_list,
    685       1.41   tsutsui 	    BUS_DMA_COHERENT | BUS_DMA_NOWAIT)) != 0) {
    686      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    687      1.101   tsutsui 		    "can't map tx list, error = %d\n", error);
    688        1.5   kanaoka 	  	goto fail_1;
    689        1.5   kanaoka 	}
    690       1.52   tsutsui 	memset(sc->re_ldata.re_tx_list, 0, RE_TX_LIST_SZ(sc));
    691        1.5   kanaoka 
    692       1.52   tsutsui 	if ((error = bus_dmamap_create(sc->sc_dmat, RE_TX_LIST_SZ(sc), 1,
    693       1.52   tsutsui 	    RE_TX_LIST_SZ(sc), 0, 0,
    694       1.52   tsutsui 	    &sc->re_ldata.re_tx_list_map)) != 0) {
    695      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    696      1.101   tsutsui 		    "can't create tx list map, error = %d\n", error);
    697        1.5   kanaoka 		goto fail_2;
    698        1.5   kanaoka 	}
    699        1.5   kanaoka 
    700        1.5   kanaoka 
    701       1.12     perry 	if ((error = bus_dmamap_load(sc->sc_dmat,
    702       1.52   tsutsui 	    sc->re_ldata.re_tx_list_map, sc->re_ldata.re_tx_list,
    703       1.52   tsutsui 	    RE_TX_LIST_SZ(sc), NULL, BUS_DMA_NOWAIT)) != 0) {
    704      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    705      1.101   tsutsui 		    "can't load tx list, error = %d\n", error);
    706        1.5   kanaoka 		goto fail_3;
    707        1.5   kanaoka 	}
    708        1.5   kanaoka 
    709        1.5   kanaoka 	/* Create DMA maps for TX buffers */
    710       1.52   tsutsui 	for (i = 0; i < RE_TX_QLEN; i++) {
    711       1.13      yamt 		error = bus_dmamap_create(sc->sc_dmat,
    712       1.13      yamt 		    round_page(IP_MAXPACKET),
    713       1.94   tsutsui 		    RE_TX_DESC_CNT(sc), RE_TDESC_CMD_FRAGLEN,
    714       1.59   tsutsui 		    0, 0, &sc->re_ldata.re_txq[i].txq_dmamap);
    715        1.5   kanaoka 		if (error) {
    716      1.102   tsutsui 			aprint_error_dev(sc->sc_dev,
    717      1.101   tsutsui 			    "can't create DMA map for TX\n");
    718        1.5   kanaoka 			goto fail_4;
    719        1.5   kanaoka 		}
    720        1.5   kanaoka 	}
    721        1.5   kanaoka 
    722        1.5   kanaoka 	/* Allocate DMA'able memory for the RX ring */
    723       1.71   tsutsui 	/* XXX see also a comment about RE_RX_DMAMEM_SZ in rtl81x9var.h */
    724       1.63   tsutsui 	if ((error = bus_dmamem_alloc(sc->sc_dmat,
    725       1.71   tsutsui 	    RE_RX_DMAMEM_SZ, RE_RING_ALIGN, 0, &sc->re_ldata.re_rx_listseg, 1,
    726       1.52   tsutsui 	    &sc->re_ldata.re_rx_listnseg, BUS_DMA_NOWAIT)) != 0) {
    727      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    728      1.101   tsutsui 		    "can't allocate rx listseg, error = %d\n", error);
    729        1.5   kanaoka 		goto fail_4;
    730        1.5   kanaoka 	}
    731        1.5   kanaoka 
    732        1.5   kanaoka 	/* Load the map for the RX ring. */
    733       1.52   tsutsui 	if ((error = bus_dmamem_map(sc->sc_dmat, &sc->re_ldata.re_rx_listseg,
    734       1.71   tsutsui 	    sc->re_ldata.re_rx_listnseg, RE_RX_DMAMEM_SZ,
    735       1.83  christos 	    (void **)&sc->re_ldata.re_rx_list,
    736       1.41   tsutsui 	    BUS_DMA_COHERENT | BUS_DMA_NOWAIT)) != 0) {
    737      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    738      1.101   tsutsui 		    "can't map rx list, error = %d\n", error);
    739        1.5   kanaoka 		goto fail_5;
    740        1.5   kanaoka 	}
    741       1.71   tsutsui 	memset(sc->re_ldata.re_rx_list, 0, RE_RX_DMAMEM_SZ);
    742        1.5   kanaoka 
    743       1.63   tsutsui 	if ((error = bus_dmamap_create(sc->sc_dmat,
    744       1.71   tsutsui 	    RE_RX_DMAMEM_SZ, 1, RE_RX_DMAMEM_SZ, 0, 0,
    745       1.52   tsutsui 	    &sc->re_ldata.re_rx_list_map)) != 0) {
    746      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    747      1.101   tsutsui 		    "can't create rx list map, error = %d\n", error);
    748        1.5   kanaoka 		goto fail_6;
    749        1.5   kanaoka 	}
    750        1.5   kanaoka 
    751        1.5   kanaoka 	if ((error = bus_dmamap_load(sc->sc_dmat,
    752       1.52   tsutsui 	    sc->re_ldata.re_rx_list_map, sc->re_ldata.re_rx_list,
    753       1.71   tsutsui 	    RE_RX_DMAMEM_SZ, NULL, BUS_DMA_NOWAIT)) != 0) {
    754      1.102   tsutsui 		aprint_error_dev(sc->sc_dev,
    755      1.101   tsutsui 		    "can't load rx list, error = %d\n", error);
    756        1.5   kanaoka 		goto fail_7;
    757        1.5   kanaoka 	}
    758        1.5   kanaoka 
    759        1.5   kanaoka 	/* Create DMA maps for RX buffers */
    760       1.52   tsutsui 	for (i = 0; i < RE_RX_DESC_CNT; i++) {
    761        1.5   kanaoka 		error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES,
    762       1.52   tsutsui 		    0, 0, &sc->re_ldata.re_rxsoft[i].rxs_dmamap);
    763        1.5   kanaoka 		if (error) {
    764      1.102   tsutsui 			aprint_error_dev(sc->sc_dev,
    765      1.101   tsutsui 			    "can't create DMA map for RX\n");
    766        1.5   kanaoka 			goto fail_8;
    767        1.5   kanaoka 		}
    768        1.1  jonathan 	}
    769        1.1  jonathan 
    770        1.6   kanaoka 	/*
    771        1.6   kanaoka 	 * Record interface as attached. From here, we should not fail.
    772        1.6   kanaoka 	 */
    773        1.6   kanaoka 	sc->sc_flags |= RTK_ATTACHED;
    774        1.6   kanaoka 
    775        1.1  jonathan 	ifp = &sc->ethercom.ec_if;
    776        1.1  jonathan 	ifp->if_softc = sc;
    777      1.102   tsutsui 	strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
    778        1.1  jonathan 	ifp->if_mtu = ETHERMTU;
    779        1.1  jonathan 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
    780        1.1  jonathan 	ifp->if_ioctl = re_ioctl;
    781       1.74   tsutsui 	sc->ethercom.ec_capabilities |=
    782       1.74   tsutsui 	    ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING;
    783        1.1  jonathan 	ifp->if_start = re_start;
    784        1.3   kanaoka 	ifp->if_stop = re_stop;
    785       1.19      yamt 
    786       1.19      yamt 	/*
    787       1.67   tsutsui 	 * IFCAP_CSUM_IPv4_Tx on re(4) is broken for small packets,
    788       1.67   tsutsui 	 * so we have a workaround to handle the bug by padding
    789       1.67   tsutsui 	 * such packets manually.
    790       1.19      yamt 	 */
    791        1.1  jonathan 	ifp->if_capabilities |=
    792       1.63   tsutsui 	    IFCAP_CSUM_IPv4_Tx | IFCAP_CSUM_IPv4_Rx |
    793       1.18      yamt 	    IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv4_Rx |
    794       1.18      yamt 	    IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv4_Rx |
    795       1.13      yamt 	    IFCAP_TSOv4;
    796        1.1  jonathan 	ifp->if_watchdog = re_watchdog;
    797        1.1  jonathan 	ifp->if_init = re_init;
    798       1.52   tsutsui 	ifp->if_snd.ifq_maxlen = RE_IFQ_MAXLEN;
    799        1.1  jonathan 	ifp->if_capenable = ifp->if_capabilities;
    800        1.1  jonathan 	IFQ_SET_READY(&ifp->if_snd);
    801        1.1  jonathan 
    802       1.86        ad 	callout_init(&sc->rtk_tick_ch, 0);
    803        1.1  jonathan 
    804        1.1  jonathan 	/* Do MII setup */
    805        1.1  jonathan 	sc->mii.mii_ifp = ifp;
    806        1.1  jonathan 	sc->mii.mii_readreg = re_miibus_readreg;
    807        1.1  jonathan 	sc->mii.mii_writereg = re_miibus_writereg;
    808        1.1  jonathan 	sc->mii.mii_statchg = re_miibus_statchg;
    809       1.93    dyoung 	sc->ethercom.ec_mii = &sc->mii;
    810       1.93    dyoung 	ifmedia_init(&sc->mii.mii_media, IFM_IMASK, ether_mediachange,
    811       1.93    dyoung 	    ether_mediastatus);
    812      1.102   tsutsui 	mii_attach(sc->sc_dev, &sc->mii, 0xffffffff, MII_PHY_ANY,
    813        1.1  jonathan 	    MII_OFFSET_ANY, 0);
    814        1.4   kanaoka 	ifmedia_set(&sc->mii.mii_media, IFM_ETHER | IFM_AUTO);
    815        1.1  jonathan 
    816        1.1  jonathan 	/*
    817        1.1  jonathan 	 * Call MI attach routine.
    818        1.1  jonathan 	 */
    819        1.1  jonathan 	if_attach(ifp);
    820        1.1  jonathan 	ether_ifattach(ifp, eaddr);
    821        1.1  jonathan 
    822        1.5   kanaoka 	return;
    823        1.5   kanaoka 
    824       1.41   tsutsui  fail_8:
    825        1.5   kanaoka 	/* Destroy DMA maps for RX buffers. */
    826       1.52   tsutsui 	for (i = 0; i < RE_RX_DESC_CNT; i++)
    827       1.52   tsutsui 		if (sc->re_ldata.re_rxsoft[i].rxs_dmamap != NULL)
    828        1.5   kanaoka 			bus_dmamap_destroy(sc->sc_dmat,
    829       1.52   tsutsui 			    sc->re_ldata.re_rxsoft[i].rxs_dmamap);
    830        1.5   kanaoka 
    831        1.5   kanaoka 	/* Free DMA'able memory for the RX ring. */
    832       1.52   tsutsui 	bus_dmamap_unload(sc->sc_dmat, sc->re_ldata.re_rx_list_map);
    833       1.41   tsutsui  fail_7:
    834       1.52   tsutsui 	bus_dmamap_destroy(sc->sc_dmat, sc->re_ldata.re_rx_list_map);
    835       1.41   tsutsui  fail_6:
    836        1.5   kanaoka 	bus_dmamem_unmap(sc->sc_dmat,
    837       1.83  christos 	    (void *)sc->re_ldata.re_rx_list, RE_RX_DMAMEM_SZ);
    838       1.41   tsutsui  fail_5:
    839        1.5   kanaoka 	bus_dmamem_free(sc->sc_dmat,
    840       1.52   tsutsui 	    &sc->re_ldata.re_rx_listseg, sc->re_ldata.re_rx_listnseg);
    841        1.5   kanaoka 
    842       1.41   tsutsui  fail_4:
    843        1.5   kanaoka 	/* Destroy DMA maps for TX buffers. */
    844       1.52   tsutsui 	for (i = 0; i < RE_TX_QLEN; i++)
    845       1.52   tsutsui 		if (sc->re_ldata.re_txq[i].txq_dmamap != NULL)
    846        1.5   kanaoka 			bus_dmamap_destroy(sc->sc_dmat,
    847       1.52   tsutsui 			    sc->re_ldata.re_txq[i].txq_dmamap);
    848        1.5   kanaoka 
    849        1.5   kanaoka 	/* Free DMA'able memory for the TX ring. */
    850       1.52   tsutsui 	bus_dmamap_unload(sc->sc_dmat, sc->re_ldata.re_tx_list_map);
    851       1.41   tsutsui  fail_3:
    852       1.52   tsutsui 	bus_dmamap_destroy(sc->sc_dmat, sc->re_ldata.re_tx_list_map);
    853       1.41   tsutsui  fail_2:
    854        1.5   kanaoka 	bus_dmamem_unmap(sc->sc_dmat,
    855       1.83  christos 	    (void *)sc->re_ldata.re_tx_list, RE_TX_LIST_SZ(sc));
    856       1.41   tsutsui  fail_1:
    857        1.5   kanaoka 	bus_dmamem_free(sc->sc_dmat,
    858       1.52   tsutsui 	    &sc->re_ldata.re_tx_listseg, sc->re_ldata.re_tx_listnseg);
    859       1.41   tsutsui  fail_0:
    860        1.1  jonathan 	return;
    861        1.1  jonathan }
    862        1.1  jonathan 
    863        1.1  jonathan 
    864        1.1  jonathan /*
    865        1.1  jonathan  * re_activate:
    866        1.1  jonathan  *     Handle device activation/deactivation requests.
    867        1.1  jonathan  */
    868        1.1  jonathan int
    869      1.102   tsutsui re_activate(device_t self, enum devact act)
    870        1.1  jonathan {
    871      1.102   tsutsui 	struct rtk_softc *sc = device_private(self);
    872        1.1  jonathan 	int s, error = 0;
    873        1.1  jonathan 
    874        1.1  jonathan 	s = splnet();
    875        1.1  jonathan 	switch (act) {
    876        1.1  jonathan 	case DVACT_ACTIVATE:
    877        1.1  jonathan 		error = EOPNOTSUPP;
    878        1.1  jonathan 		break;
    879        1.1  jonathan 	case DVACT_DEACTIVATE:
    880        1.1  jonathan 		mii_activate(&sc->mii, act, MII_PHY_ANY, MII_OFFSET_ANY);
    881        1.1  jonathan 		if_deactivate(&sc->ethercom.ec_if);
    882        1.1  jonathan 		break;
    883        1.1  jonathan 	}
    884        1.1  jonathan 	splx(s);
    885        1.1  jonathan 
    886        1.4   kanaoka 	return error;
    887        1.1  jonathan }
    888        1.1  jonathan 
    889        1.1  jonathan /*
    890        1.1  jonathan  * re_detach:
    891        1.1  jonathan  *     Detach a rtk interface.
    892        1.1  jonathan  */
    893        1.1  jonathan int
    894        1.1  jonathan re_detach(struct rtk_softc *sc)
    895        1.1  jonathan {
    896        1.1  jonathan 	struct ifnet *ifp = &sc->ethercom.ec_if;
    897        1.5   kanaoka 	int i;
    898        1.1  jonathan 
    899        1.1  jonathan 	/*
    900        1.1  jonathan 	 * Succeed now if there isn't any work to do.
    901        1.1  jonathan 	 */
    902        1.1  jonathan 	if ((sc->sc_flags & RTK_ATTACHED) == 0)
    903        1.4   kanaoka 		return 0;
    904        1.1  jonathan 
    905        1.1  jonathan 	/* Unhook our tick handler. */
    906        1.1  jonathan 	callout_stop(&sc->rtk_tick_ch);
    907        1.1  jonathan 
    908        1.1  jonathan 	/* Detach all PHYs. */
    909        1.1  jonathan 	mii_detach(&sc->mii, MII_PHY_ANY, MII_OFFSET_ANY);
    910        1.1  jonathan 
    911        1.1  jonathan 	/* Delete all remaining media. */
    912        1.1  jonathan 	ifmedia_delete_instance(&sc->mii.mii_media, IFM_INST_ANY);
    913        1.1  jonathan 
    914        1.1  jonathan 	ether_ifdetach(ifp);
    915        1.1  jonathan 	if_detach(ifp);
    916        1.1  jonathan 
    917        1.5   kanaoka 	/* Destroy DMA maps for RX buffers. */
    918       1.52   tsutsui 	for (i = 0; i < RE_RX_DESC_CNT; i++)
    919       1.52   tsutsui 		if (sc->re_ldata.re_rxsoft[i].rxs_dmamap != NULL)
    920        1.5   kanaoka 			bus_dmamap_destroy(sc->sc_dmat,
    921       1.52   tsutsui 			    sc->re_ldata.re_rxsoft[i].rxs_dmamap);
    922        1.5   kanaoka 
    923        1.5   kanaoka 	/* Free DMA'able memory for the RX ring. */
    924       1.52   tsutsui 	bus_dmamap_unload(sc->sc_dmat, sc->re_ldata.re_rx_list_map);
    925       1.52   tsutsui 	bus_dmamap_destroy(sc->sc_dmat, sc->re_ldata.re_rx_list_map);
    926        1.5   kanaoka 	bus_dmamem_unmap(sc->sc_dmat,
    927       1.83  christos 	    (void *)sc->re_ldata.re_rx_list, RE_RX_DMAMEM_SZ);
    928        1.5   kanaoka 	bus_dmamem_free(sc->sc_dmat,
    929       1.52   tsutsui 	    &sc->re_ldata.re_rx_listseg, sc->re_ldata.re_rx_listnseg);
    930        1.5   kanaoka 
    931        1.5   kanaoka 	/* Destroy DMA maps for TX buffers. */
    932       1.52   tsutsui 	for (i = 0; i < RE_TX_QLEN; i++)
    933       1.52   tsutsui 		if (sc->re_ldata.re_txq[i].txq_dmamap != NULL)
    934        1.5   kanaoka 			bus_dmamap_destroy(sc->sc_dmat,
    935       1.52   tsutsui 			    sc->re_ldata.re_txq[i].txq_dmamap);
    936        1.5   kanaoka 
    937        1.5   kanaoka 	/* Free DMA'able memory for the TX ring. */
    938       1.52   tsutsui 	bus_dmamap_unload(sc->sc_dmat, sc->re_ldata.re_tx_list_map);
    939       1.52   tsutsui 	bus_dmamap_destroy(sc->sc_dmat, sc->re_ldata.re_tx_list_map);
    940        1.5   kanaoka 	bus_dmamem_unmap(sc->sc_dmat,
    941       1.83  christos 	    (void *)sc->re_ldata.re_tx_list, RE_TX_LIST_SZ(sc));
    942        1.5   kanaoka 	bus_dmamem_free(sc->sc_dmat,
    943       1.52   tsutsui 	    &sc->re_ldata.re_tx_listseg, sc->re_ldata.re_tx_listnseg);
    944        1.5   kanaoka 
    945        1.4   kanaoka 	return 0;
    946        1.1  jonathan }
    947        1.1  jonathan 
    948        1.1  jonathan /*
    949        1.1  jonathan  * re_enable:
    950        1.1  jonathan  *     Enable the RTL81X9 chip.
    951        1.1  jonathan  */
    952       1.12     perry static int
    953        1.1  jonathan re_enable(struct rtk_softc *sc)
    954        1.1  jonathan {
    955       1.41   tsutsui 
    956        1.1  jonathan 	if (RTK_IS_ENABLED(sc) == 0 && sc->sc_enable != NULL) {
    957        1.1  jonathan 		if ((*sc->sc_enable)(sc) != 0) {
    958      1.101   tsutsui 			printf("%s: device enable failed\n",
    959      1.102   tsutsui 			    device_xname(sc->sc_dev));
    960        1.4   kanaoka 			return EIO;
    961        1.1  jonathan 		}
    962        1.1  jonathan 		sc->sc_flags |= RTK_ENABLED;
    963        1.1  jonathan 	}
    964        1.4   kanaoka 	return 0;
    965        1.1  jonathan }
    966        1.1  jonathan 
    967        1.1  jonathan /*
    968        1.1  jonathan  * re_disable:
    969        1.1  jonathan  *     Disable the RTL81X9 chip.
    970        1.1  jonathan  */
    971       1.12     perry static void
    972        1.1  jonathan re_disable(struct rtk_softc *sc)
    973        1.1  jonathan {
    974        1.1  jonathan 
    975        1.1  jonathan 	if (RTK_IS_ENABLED(sc) && sc->sc_disable != NULL) {
    976        1.1  jonathan 		(*sc->sc_disable)(sc);
    977        1.1  jonathan 		sc->sc_flags &= ~RTK_ENABLED;
    978        1.1  jonathan 	}
    979        1.1  jonathan }
    980        1.1  jonathan 
    981        1.1  jonathan static int
    982        1.1  jonathan re_newbuf(struct rtk_softc *sc, int idx, struct mbuf *m)
    983        1.1  jonathan {
    984      1.102   tsutsui 	struct mbuf *n = NULL;
    985      1.102   tsutsui 	bus_dmamap_t map;
    986      1.102   tsutsui 	struct re_desc *d;
    987      1.102   tsutsui 	struct re_rxsoft *rxs;
    988      1.102   tsutsui 	uint32_t cmdstat;
    989      1.102   tsutsui 	int error;
    990        1.1  jonathan 
    991        1.1  jonathan 	if (m == NULL) {
    992        1.1  jonathan 		MGETHDR(n, M_DONTWAIT, MT_DATA);
    993        1.1  jonathan 		if (n == NULL)
    994        1.4   kanaoka 			return ENOBUFS;
    995        1.1  jonathan 
    996       1.42   tsutsui 		MCLGET(n, M_DONTWAIT);
    997       1.42   tsutsui 		if ((n->m_flags & M_EXT) == 0) {
    998       1.42   tsutsui 			m_freem(n);
    999        1.4   kanaoka 			return ENOBUFS;
   1000        1.1  jonathan 		}
   1001       1.42   tsutsui 		m = n;
   1002        1.1  jonathan 	} else
   1003        1.1  jonathan 		m->m_data = m->m_ext.ext_buf;
   1004        1.1  jonathan 
   1005        1.1  jonathan 	/*
   1006        1.1  jonathan 	 * Initialize mbuf length fields and fixup
   1007        1.1  jonathan 	 * alignment so that the frame payload is
   1008        1.1  jonathan 	 * longword aligned.
   1009        1.1  jonathan 	 */
   1010       1.61   tsutsui 	m->m_len = m->m_pkthdr.len = MCLBYTES - RE_ETHER_ALIGN;
   1011       1.61   tsutsui 	m->m_data += RE_ETHER_ALIGN;
   1012        1.1  jonathan 
   1013       1.52   tsutsui 	rxs = &sc->re_ldata.re_rxsoft[idx];
   1014       1.50   tsutsui 	map = rxs->rxs_dmamap;
   1015       1.21      yamt 	error = bus_dmamap_load_mbuf(sc->sc_dmat, map, m,
   1016       1.21      yamt 	    BUS_DMA_READ|BUS_DMA_NOWAIT);
   1017        1.1  jonathan 
   1018        1.1  jonathan 	if (error)
   1019        1.1  jonathan 		goto out;
   1020        1.1  jonathan 
   1021       1.33   tsutsui 	bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
   1022       1.33   tsutsui 	    BUS_DMASYNC_PREREAD);
   1023       1.33   tsutsui 
   1024       1.52   tsutsui 	d = &sc->re_ldata.re_rx_list[idx];
   1025       1.76   tsutsui #ifdef DIAGNOSTIC
   1026       1.52   tsutsui 	RE_RXDESCSYNC(sc, idx, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
   1027       1.52   tsutsui 	cmdstat = le32toh(d->re_cmdstat);
   1028       1.52   tsutsui 	RE_RXDESCSYNC(sc, idx, BUS_DMASYNC_PREREAD);
   1029       1.52   tsutsui 	if (cmdstat & RE_RDESC_STAT_OWN) {
   1030       1.76   tsutsui 		panic("%s: tried to map busy RX descriptor",
   1031      1.102   tsutsui 		    device_xname(sc->sc_dev));
   1032       1.32   tsutsui 	}
   1033       1.76   tsutsui #endif
   1034        1.1  jonathan 
   1035       1.50   tsutsui 	rxs->rxs_mbuf = m;
   1036       1.50   tsutsui 
   1037       1.74   tsutsui 	d->re_vlanctl = 0;
   1038        1.1  jonathan 	cmdstat = map->dm_segs[0].ds_len;
   1039       1.52   tsutsui 	if (idx == (RE_RX_DESC_CNT - 1))
   1040       1.52   tsutsui 		cmdstat |= RE_RDESC_CMD_EOR;
   1041       1.64   tsutsui 	re_set_bufaddr(d, map->dm_segs[0].ds_addr);
   1042       1.52   tsutsui 	d->re_cmdstat = htole32(cmdstat);
   1043       1.52   tsutsui 	RE_RXDESCSYNC(sc, idx, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
   1044       1.52   tsutsui 	cmdstat |= RE_RDESC_CMD_OWN;
   1045       1.52   tsutsui 	d->re_cmdstat = htole32(cmdstat);
   1046       1.52   tsutsui 	RE_RXDESCSYNC(sc, idx, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
   1047        1.1  jonathan 
   1048        1.1  jonathan 	return 0;
   1049       1.42   tsutsui  out:
   1050        1.1  jonathan 	if (n != NULL)
   1051        1.1  jonathan 		m_freem(n);
   1052        1.1  jonathan 	return ENOMEM;
   1053        1.1  jonathan }
   1054        1.1  jonathan 
   1055        1.1  jonathan static int
   1056        1.1  jonathan re_tx_list_init(struct rtk_softc *sc)
   1057        1.1  jonathan {
   1058       1.15      yamt 	int i;
   1059       1.15      yamt 
   1060       1.52   tsutsui 	memset(sc->re_ldata.re_tx_list, 0, RE_TX_LIST_SZ(sc));
   1061       1.52   tsutsui 	for (i = 0; i < RE_TX_QLEN; i++) {
   1062       1.52   tsutsui 		sc->re_ldata.re_txq[i].txq_mbuf = NULL;
   1063       1.15      yamt 	}
   1064        1.1  jonathan 
   1065        1.1  jonathan 	bus_dmamap_sync(sc->sc_dmat,
   1066       1.52   tsutsui 	    sc->re_ldata.re_tx_list_map, 0,
   1067       1.52   tsutsui 	    sc->re_ldata.re_tx_list_map->dm_mapsize,
   1068       1.32   tsutsui 	    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
   1069       1.52   tsutsui 	sc->re_ldata.re_txq_prodidx = 0;
   1070       1.52   tsutsui 	sc->re_ldata.re_txq_considx = 0;
   1071       1.59   tsutsui 	sc->re_ldata.re_txq_free = RE_TX_QLEN;
   1072       1.52   tsutsui 	sc->re_ldata.re_tx_free = RE_TX_DESC_CNT(sc);
   1073       1.52   tsutsui 	sc->re_ldata.re_tx_nextfree = 0;
   1074        1.1  jonathan 
   1075        1.4   kanaoka 	return 0;
   1076        1.1  jonathan }
   1077        1.1  jonathan 
   1078        1.1  jonathan static int
   1079        1.1  jonathan re_rx_list_init(struct rtk_softc *sc)
   1080        1.1  jonathan {
   1081      1.102   tsutsui 	int i;
   1082        1.1  jonathan 
   1083      1.102   tsutsui 	memset(sc->re_ldata.re_rx_list, 0, RE_RX_LIST_SZ);
   1084        1.1  jonathan 
   1085       1.52   tsutsui 	for (i = 0; i < RE_RX_DESC_CNT; i++) {
   1086        1.1  jonathan 		if (re_newbuf(sc, i, NULL) == ENOBUFS)
   1087        1.4   kanaoka 			return ENOBUFS;
   1088        1.1  jonathan 	}
   1089        1.1  jonathan 
   1090       1.52   tsutsui 	sc->re_ldata.re_rx_prodidx = 0;
   1091       1.52   tsutsui 	sc->re_head = sc->re_tail = NULL;
   1092        1.1  jonathan 
   1093        1.4   kanaoka 	return 0;
   1094        1.1  jonathan }
   1095        1.1  jonathan 
   1096        1.1  jonathan /*
   1097        1.1  jonathan  * RX handler for C+ and 8169. For the gigE chips, we support
   1098        1.1  jonathan  * the reception of jumbo frames that have been fragmented
   1099        1.1  jonathan  * across multiple 2K mbuf cluster buffers.
   1100        1.1  jonathan  */
   1101        1.1  jonathan static void
   1102        1.1  jonathan re_rxeof(struct rtk_softc *sc)
   1103        1.1  jonathan {
   1104      1.102   tsutsui 	struct mbuf *m;
   1105      1.102   tsutsui 	struct ifnet *ifp;
   1106      1.102   tsutsui 	int i, total_len;
   1107      1.102   tsutsui 	struct re_desc *cur_rx;
   1108      1.102   tsutsui 	struct re_rxsoft *rxs;
   1109      1.102   tsutsui 	uint32_t rxstat, rxvlan;
   1110        1.1  jonathan 
   1111        1.1  jonathan 	ifp = &sc->ethercom.ec_if;
   1112        1.1  jonathan 
   1113       1.52   tsutsui 	for (i = sc->re_ldata.re_rx_prodidx;; i = RE_NEXT_RX_DESC(sc, i)) {
   1114       1.52   tsutsui 		cur_rx = &sc->re_ldata.re_rx_list[i];
   1115       1.52   tsutsui 		RE_RXDESCSYNC(sc, i,
   1116       1.32   tsutsui 		    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
   1117       1.52   tsutsui 		rxstat = le32toh(cur_rx->re_cmdstat);
   1118       1.97   tsutsui 		rxvlan = le32toh(cur_rx->re_vlanctl);
   1119       1.52   tsutsui 		RE_RXDESCSYNC(sc, i, BUS_DMASYNC_PREREAD);
   1120       1.52   tsutsui 		if ((rxstat & RE_RDESC_STAT_OWN) != 0) {
   1121       1.32   tsutsui 			break;
   1122       1.32   tsutsui 		}
   1123       1.52   tsutsui 		total_len = rxstat & sc->re_rxlenmask;
   1124       1.52   tsutsui 		rxs = &sc->re_ldata.re_rxsoft[i];
   1125       1.50   tsutsui 		m = rxs->rxs_mbuf;
   1126        1.1  jonathan 
   1127        1.1  jonathan 		/* Invalidate the RX mbuf and unload its map */
   1128        1.1  jonathan 
   1129        1.1  jonathan 		bus_dmamap_sync(sc->sc_dmat,
   1130       1.50   tsutsui 		    rxs->rxs_dmamap, 0, rxs->rxs_dmamap->dm_mapsize,
   1131       1.20    briggs 		    BUS_DMASYNC_POSTREAD);
   1132       1.50   tsutsui 		bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
   1133        1.1  jonathan 
   1134       1.52   tsutsui 		if ((rxstat & RE_RDESC_STAT_EOF) == 0) {
   1135       1.52   tsutsui 			m->m_len = MCLBYTES - RE_ETHER_ALIGN;
   1136       1.52   tsutsui 			if (sc->re_head == NULL)
   1137       1.52   tsutsui 				sc->re_head = sc->re_tail = m;
   1138        1.1  jonathan 			else {
   1139        1.1  jonathan 				m->m_flags &= ~M_PKTHDR;
   1140       1.52   tsutsui 				sc->re_tail->m_next = m;
   1141       1.52   tsutsui 				sc->re_tail = m;
   1142        1.1  jonathan 			}
   1143        1.1  jonathan 			re_newbuf(sc, i, NULL);
   1144        1.1  jonathan 			continue;
   1145        1.1  jonathan 		}
   1146        1.1  jonathan 
   1147        1.1  jonathan 		/*
   1148        1.1  jonathan 		 * NOTE: for the 8139C+, the frame length field
   1149        1.1  jonathan 		 * is always 12 bits in size, but for the gigE chips,
   1150        1.1  jonathan 		 * it is 13 bits (since the max RX frame length is 16K).
   1151        1.1  jonathan 		 * Unfortunately, all 32 bits in the status word
   1152        1.1  jonathan 		 * were already used, so to make room for the extra
   1153        1.1  jonathan 		 * length bit, RealTek took out the 'frame alignment
   1154        1.1  jonathan 		 * error' bit and shifted the other status bits
   1155        1.1  jonathan 		 * over one slot. The OWN, EOR, FS and LS bits are
   1156        1.1  jonathan 		 * still in the same places. We have already extracted
   1157        1.1  jonathan 		 * the frame length and checked the OWN bit, so rather
   1158        1.1  jonathan 		 * than using an alternate bit mapping, we shift the
   1159        1.1  jonathan 		 * status bits one space to the right so we can evaluate
   1160        1.1  jonathan 		 * them using the 8169 status as though it was in the
   1161        1.1  jonathan 		 * same format as that of the 8139C+.
   1162        1.1  jonathan 		 */
   1163       1.84   tsutsui 		if ((sc->sc_quirk & RTKQ_8139CPLUS) == 0)
   1164        1.1  jonathan 			rxstat >>= 1;
   1165        1.1  jonathan 
   1166       1.75   tsutsui 		if (__predict_false((rxstat & RE_RDESC_STAT_RXERRSUM) != 0)) {
   1167       1.70   tsutsui #ifdef RE_DEBUG
   1168      1.101   tsutsui 			printf("%s: RX error (rxstat = 0x%08x)",
   1169      1.102   tsutsui 			    device_xname(sc->sc_dev), rxstat);
   1170       1.70   tsutsui 			if (rxstat & RE_RDESC_STAT_FRALIGN)
   1171      1.101   tsutsui 				printf(", frame alignment error");
   1172       1.70   tsutsui 			if (rxstat & RE_RDESC_STAT_BUFOFLOW)
   1173      1.101   tsutsui 				printf(", out of buffer space");
   1174       1.70   tsutsui 			if (rxstat & RE_RDESC_STAT_FIFOOFLOW)
   1175      1.101   tsutsui 				printf(", FIFO overrun");
   1176       1.70   tsutsui 			if (rxstat & RE_RDESC_STAT_GIANT)
   1177      1.101   tsutsui 				printf(", giant packet");
   1178       1.70   tsutsui 			if (rxstat & RE_RDESC_STAT_RUNT)
   1179      1.101   tsutsui 				printf(", runt packet");
   1180       1.70   tsutsui 			if (rxstat & RE_RDESC_STAT_CRCERR)
   1181      1.101   tsutsui 				printf(", CRC error");
   1182      1.101   tsutsui 			printf("\n");
   1183       1.70   tsutsui #endif
   1184        1.1  jonathan 			ifp->if_ierrors++;
   1185        1.1  jonathan 			/*
   1186        1.1  jonathan 			 * If this is part of a multi-fragment packet,
   1187        1.1  jonathan 			 * discard all the pieces.
   1188        1.1  jonathan 			 */
   1189       1.52   tsutsui 			if (sc->re_head != NULL) {
   1190       1.52   tsutsui 				m_freem(sc->re_head);
   1191       1.52   tsutsui 				sc->re_head = sc->re_tail = NULL;
   1192        1.1  jonathan 			}
   1193        1.1  jonathan 			re_newbuf(sc, i, m);
   1194        1.1  jonathan 			continue;
   1195        1.1  jonathan 		}
   1196        1.1  jonathan 
   1197        1.1  jonathan 		/*
   1198        1.1  jonathan 		 * If allocating a replacement mbuf fails,
   1199        1.1  jonathan 		 * reload the current one.
   1200        1.1  jonathan 		 */
   1201        1.1  jonathan 
   1202       1.75   tsutsui 		if (__predict_false(re_newbuf(sc, i, NULL) != 0)) {
   1203        1.1  jonathan 			ifp->if_ierrors++;
   1204       1.52   tsutsui 			if (sc->re_head != NULL) {
   1205       1.52   tsutsui 				m_freem(sc->re_head);
   1206       1.52   tsutsui 				sc->re_head = sc->re_tail = NULL;
   1207        1.1  jonathan 			}
   1208        1.1  jonathan 			re_newbuf(sc, i, m);
   1209        1.1  jonathan 			continue;
   1210        1.1  jonathan 		}
   1211        1.1  jonathan 
   1212       1.52   tsutsui 		if (sc->re_head != NULL) {
   1213       1.52   tsutsui 			m->m_len = total_len % (MCLBYTES - RE_ETHER_ALIGN);
   1214       1.12     perry 			/*
   1215        1.1  jonathan 			 * Special case: if there's 4 bytes or less
   1216        1.1  jonathan 			 * in this buffer, the mbuf can be discarded:
   1217        1.1  jonathan 			 * the last 4 bytes is the CRC, which we don't
   1218        1.1  jonathan 			 * care about anyway.
   1219        1.1  jonathan 			 */
   1220        1.1  jonathan 			if (m->m_len <= ETHER_CRC_LEN) {
   1221       1.52   tsutsui 				sc->re_tail->m_len -=
   1222        1.1  jonathan 				    (ETHER_CRC_LEN - m->m_len);
   1223        1.1  jonathan 				m_freem(m);
   1224        1.1  jonathan 			} else {
   1225        1.1  jonathan 				m->m_len -= ETHER_CRC_LEN;
   1226        1.1  jonathan 				m->m_flags &= ~M_PKTHDR;
   1227       1.52   tsutsui 				sc->re_tail->m_next = m;
   1228        1.1  jonathan 			}
   1229       1.52   tsutsui 			m = sc->re_head;
   1230       1.52   tsutsui 			sc->re_head = sc->re_tail = NULL;
   1231        1.1  jonathan 			m->m_pkthdr.len = total_len - ETHER_CRC_LEN;
   1232        1.1  jonathan 		} else
   1233        1.1  jonathan 			m->m_pkthdr.len = m->m_len =
   1234        1.1  jonathan 			    (total_len - ETHER_CRC_LEN);
   1235        1.1  jonathan 
   1236        1.1  jonathan 		ifp->if_ipackets++;
   1237        1.1  jonathan 		m->m_pkthdr.rcvif = ifp;
   1238        1.1  jonathan 
   1239       1.68   tsutsui 		/* Do RX checksumming */
   1240        1.1  jonathan 
   1241       1.68   tsutsui 		/* Check IP header checksum */
   1242       1.68   tsutsui 		if (rxstat & RE_RDESC_STAT_PROTOID) {
   1243       1.68   tsutsui 			m->m_pkthdr.csum_flags |= M_CSUM_IPv4;
   1244       1.52   tsutsui 			if (rxstat & RE_RDESC_STAT_IPSUMBAD)
   1245        1.4   kanaoka 				m->m_pkthdr.csum_flags |= M_CSUM_IPv4_BAD;
   1246        1.1  jonathan 		}
   1247        1.1  jonathan 
   1248        1.1  jonathan 		/* Check TCP/UDP checksum */
   1249       1.68   tsutsui 		if (RE_TCPPKT(rxstat)) {
   1250        1.1  jonathan 			m->m_pkthdr.csum_flags |= M_CSUM_TCPv4;
   1251       1.52   tsutsui 			if (rxstat & RE_RDESC_STAT_TCPSUMBAD)
   1252        1.1  jonathan 				m->m_pkthdr.csum_flags |= M_CSUM_TCP_UDP_BAD;
   1253       1.68   tsutsui 		} else if (RE_UDPPKT(rxstat)) {
   1254        1.1  jonathan 			m->m_pkthdr.csum_flags |= M_CSUM_UDPv4;
   1255       1.52   tsutsui 			if (rxstat & RE_RDESC_STAT_UDPSUMBAD)
   1256        1.1  jonathan 				m->m_pkthdr.csum_flags |= M_CSUM_TCP_UDP_BAD;
   1257        1.1  jonathan 		}
   1258        1.1  jonathan 
   1259       1.52   tsutsui 		if (rxvlan & RE_RDESC_VLANCTL_TAG) {
   1260        1.9  jdolecek 			VLAN_INPUT_TAG(ifp, m,
   1261       1.74   tsutsui 			     bswap16(rxvlan & RE_RDESC_VLANCTL_DATA),
   1262        1.9  jdolecek 			     continue);
   1263        1.1  jonathan 		}
   1264        1.1  jonathan #if NBPFILTER > 0
   1265        1.1  jonathan 		if (ifp->if_bpf)
   1266        1.1  jonathan 			bpf_mtap(ifp->if_bpf, m);
   1267        1.1  jonathan #endif
   1268        1.1  jonathan 		(*ifp->if_input)(ifp, m);
   1269        1.1  jonathan 	}
   1270        1.1  jonathan 
   1271       1.52   tsutsui 	sc->re_ldata.re_rx_prodidx = i;
   1272        1.1  jonathan }
   1273        1.1  jonathan 
   1274        1.1  jonathan static void
   1275        1.1  jonathan re_txeof(struct rtk_softc *sc)
   1276        1.1  jonathan {
   1277      1.102   tsutsui 	struct ifnet *ifp;
   1278      1.102   tsutsui 	struct re_txq *txq;
   1279      1.102   tsutsui 	uint32_t txstat;
   1280      1.102   tsutsui 	int idx, descidx;
   1281        1.1  jonathan 
   1282        1.1  jonathan 	ifp = &sc->ethercom.ec_if;
   1283        1.1  jonathan 
   1284       1.59   tsutsui 	for (idx = sc->re_ldata.re_txq_considx;
   1285       1.59   tsutsui 	    sc->re_ldata.re_txq_free < RE_TX_QLEN;
   1286       1.59   tsutsui 	    idx = RE_NEXT_TXQ(sc, idx), sc->re_ldata.re_txq_free++) {
   1287       1.58   tsutsui 		txq = &sc->re_ldata.re_txq[idx];
   1288       1.59   tsutsui 		KASSERT(txq->txq_mbuf != NULL);
   1289       1.15      yamt 
   1290       1.17      yamt 		descidx = txq->txq_descidx;
   1291       1.52   tsutsui 		RE_TXDESCSYNC(sc, descidx,
   1292       1.32   tsutsui 		    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
   1293       1.15      yamt 		txstat =
   1294       1.52   tsutsui 		    le32toh(sc->re_ldata.re_tx_list[descidx].re_cmdstat);
   1295       1.52   tsutsui 		RE_TXDESCSYNC(sc, descidx, BUS_DMASYNC_PREREAD);
   1296       1.52   tsutsui 		KASSERT((txstat & RE_TDESC_CMD_EOF) != 0);
   1297       1.52   tsutsui 		if (txstat & RE_TDESC_CMD_OWN) {
   1298        1.1  jonathan 			break;
   1299       1.32   tsutsui 		}
   1300        1.1  jonathan 
   1301       1.63   tsutsui 		sc->re_ldata.re_tx_free += txq->txq_nsegs;
   1302       1.52   tsutsui 		KASSERT(sc->re_ldata.re_tx_free <= RE_TX_DESC_CNT(sc));
   1303       1.32   tsutsui 		bus_dmamap_sync(sc->sc_dmat, txq->txq_dmamap,
   1304       1.32   tsutsui 		    0, txq->txq_dmamap->dm_mapsize, BUS_DMASYNC_POSTWRITE);
   1305       1.15      yamt 		bus_dmamap_unload(sc->sc_dmat, txq->txq_dmamap);
   1306       1.15      yamt 		m_freem(txq->txq_mbuf);
   1307       1.15      yamt 		txq->txq_mbuf = NULL;
   1308       1.15      yamt 
   1309       1.52   tsutsui 		if (txstat & (RE_TDESC_STAT_EXCESSCOL | RE_TDESC_STAT_COLCNT))
   1310       1.15      yamt 			ifp->if_collisions++;
   1311       1.52   tsutsui 		if (txstat & RE_TDESC_STAT_TXERRSUM)
   1312       1.15      yamt 			ifp->if_oerrors++;
   1313       1.15      yamt 		else
   1314       1.15      yamt 			ifp->if_opackets++;
   1315       1.59   tsutsui 	}
   1316        1.1  jonathan 
   1317       1.59   tsutsui 	sc->re_ldata.re_txq_considx = idx;
   1318        1.1  jonathan 
   1319       1.79   tsutsui 	if (sc->re_ldata.re_txq_free > RE_NTXDESC_RSVD)
   1320        1.1  jonathan 		ifp->if_flags &= ~IFF_OACTIVE;
   1321        1.1  jonathan 
   1322        1.1  jonathan 	/*
   1323        1.1  jonathan 	 * If not all descriptors have been released reaped yet,
   1324        1.1  jonathan 	 * reload the timer so that we will eventually get another
   1325        1.1  jonathan 	 * interrupt that will cause us to re-enter this routine.
   1326        1.1  jonathan 	 * This is done in case the transmitter has gone idle.
   1327        1.1  jonathan 	 */
   1328       1.85   tsutsui 	if (sc->re_ldata.re_txq_free < RE_TX_QLEN) {
   1329        1.4   kanaoka 		CSR_WRITE_4(sc, RTK_TIMERCNT, 1);
   1330       1.85   tsutsui 		if ((sc->sc_quirk & RTKQ_PCIE) != 0) {
   1331       1.85   tsutsui 			/*
   1332       1.85   tsutsui 			 * Some chips will ignore a second TX request
   1333       1.85   tsutsui 			 * issued while an existing transmission is in
   1334       1.85   tsutsui 			 * progress. If the transmitter goes idle but
   1335       1.85   tsutsui 			 * there are still packets waiting to be sent,
   1336       1.85   tsutsui 			 * we need to restart the channel here to flush
   1337       1.85   tsutsui 			 * them out. This only seems to be required with
   1338       1.85   tsutsui 			 * the PCIe devices.
   1339       1.85   tsutsui 			 */
   1340       1.95   tsutsui 			CSR_WRITE_1(sc, RTK_GTXSTART, RTK_TXSTART_START);
   1341       1.85   tsutsui 		}
   1342       1.85   tsutsui 	} else
   1343       1.56   tsutsui 		ifp->if_timer = 0;
   1344        1.1  jonathan }
   1345        1.1  jonathan 
   1346        1.1  jonathan static void
   1347      1.102   tsutsui re_tick(void *arg)
   1348        1.1  jonathan {
   1349      1.102   tsutsui 	struct rtk_softc *sc = arg;
   1350        1.1  jonathan 	int s;
   1351        1.1  jonathan 
   1352        1.1  jonathan 	/*XXX: just return for 8169S/8110S with rev 2 or newer phy */
   1353        1.1  jonathan 	s = splnet();
   1354        1.1  jonathan 
   1355        1.1  jonathan 	mii_tick(&sc->mii);
   1356        1.1  jonathan 	splx(s);
   1357        1.1  jonathan 
   1358        1.1  jonathan 	callout_reset(&sc->rtk_tick_ch, hz, re_tick, sc);
   1359        1.1  jonathan }
   1360        1.1  jonathan 
   1361        1.1  jonathan int
   1362        1.1  jonathan re_intr(void *arg)
   1363        1.1  jonathan {
   1364      1.102   tsutsui 	struct rtk_softc *sc = arg;
   1365      1.102   tsutsui 	struct ifnet *ifp;
   1366      1.102   tsutsui 	uint16_t status;
   1367      1.102   tsutsui 	int handled = 0;
   1368        1.1  jonathan 
   1369      1.102   tsutsui 	if (!device_has_power(sc->sc_dev))
   1370       1.92     joerg 		return 0;
   1371       1.92     joerg 
   1372        1.1  jonathan 	ifp = &sc->ethercom.ec_if;
   1373        1.1  jonathan 
   1374       1.41   tsutsui 	if ((ifp->if_flags & IFF_UP) == 0)
   1375        1.1  jonathan 		return 0;
   1376        1.1  jonathan 
   1377        1.1  jonathan 	for (;;) {
   1378        1.1  jonathan 
   1379        1.1  jonathan 		status = CSR_READ_2(sc, RTK_ISR);
   1380        1.1  jonathan 		/* If the card has gone away the read returns 0xffff. */
   1381        1.1  jonathan 		if (status == 0xffff)
   1382        1.1  jonathan 			break;
   1383        1.1  jonathan 		if (status) {
   1384        1.1  jonathan 			handled = 1;
   1385        1.1  jonathan 			CSR_WRITE_2(sc, RTK_ISR, status);
   1386        1.1  jonathan 		}
   1387        1.1  jonathan 
   1388        1.1  jonathan 		if ((status & RTK_INTRS_CPLUS) == 0)
   1389        1.1  jonathan 			break;
   1390        1.1  jonathan 
   1391       1.57   tsutsui 		if (status & (RTK_ISR_RX_OK | RTK_ISR_RX_ERR))
   1392        1.1  jonathan 			re_rxeof(sc);
   1393        1.1  jonathan 
   1394       1.57   tsutsui 		if (status & (RTK_ISR_TIMEOUT_EXPIRED | RTK_ISR_TX_ERR |
   1395       1.57   tsutsui 		    RTK_ISR_TX_DESC_UNAVAIL))
   1396        1.1  jonathan 			re_txeof(sc);
   1397        1.1  jonathan 
   1398        1.1  jonathan 		if (status & RTK_ISR_SYSTEM_ERR) {
   1399        1.1  jonathan 			re_init(ifp);
   1400        1.1  jonathan 		}
   1401        1.1  jonathan 
   1402        1.1  jonathan 		if (status & RTK_ISR_LINKCHG) {
   1403        1.1  jonathan 			callout_stop(&sc->rtk_tick_ch);
   1404        1.1  jonathan 			re_tick(sc);
   1405        1.1  jonathan 		}
   1406        1.1  jonathan 	}
   1407        1.1  jonathan 
   1408       1.57   tsutsui 	if (handled && !IFQ_IS_EMPTY(&ifp->if_snd))
   1409       1.57   tsutsui 		re_start(ifp);
   1410        1.1  jonathan 
   1411        1.1  jonathan 	return handled;
   1412        1.1  jonathan }
   1413        1.1  jonathan 
   1414       1.59   tsutsui 
   1415       1.59   tsutsui 
   1416       1.59   tsutsui /*
   1417       1.59   tsutsui  * Main transmit routine for C+ and gigE NICs.
   1418       1.59   tsutsui  */
   1419       1.59   tsutsui 
   1420       1.59   tsutsui static void
   1421       1.59   tsutsui re_start(struct ifnet *ifp)
   1422        1.1  jonathan {
   1423      1.102   tsutsui 	struct rtk_softc *sc;
   1424      1.102   tsutsui 	struct mbuf *m;
   1425      1.102   tsutsui 	bus_dmamap_t map;
   1426      1.102   tsutsui 	struct re_txq *txq;
   1427      1.102   tsutsui 	struct re_desc *d;
   1428      1.102   tsutsui 	struct m_tag *mtag;
   1429      1.102   tsutsui 	uint32_t cmdstat, re_flags, vlanctl;
   1430      1.102   tsutsui 	int ofree, idx, error, nsegs, seg;
   1431      1.102   tsutsui 	int startdesc, curdesc, lastdesc;
   1432      1.102   tsutsui 	bool pad;
   1433        1.1  jonathan 
   1434       1.59   tsutsui 	sc = ifp->if_softc;
   1435       1.59   tsutsui 	ofree = sc->re_ldata.re_txq_free;
   1436        1.1  jonathan 
   1437       1.59   tsutsui 	for (idx = sc->re_ldata.re_txq_prodidx;; idx = RE_NEXT_TXQ(sc, idx)) {
   1438        1.1  jonathan 
   1439       1.59   tsutsui 		IFQ_POLL(&ifp->if_snd, m);
   1440       1.59   tsutsui 		if (m == NULL)
   1441       1.59   tsutsui 			break;
   1442        1.1  jonathan 
   1443       1.59   tsutsui 		if (sc->re_ldata.re_txq_free == 0 ||
   1444       1.94   tsutsui 		    sc->re_ldata.re_tx_free == 0) {
   1445       1.59   tsutsui 			/* no more free slots left */
   1446       1.59   tsutsui 			ifp->if_flags |= IFF_OACTIVE;
   1447       1.59   tsutsui 			break;
   1448       1.59   tsutsui 		}
   1449       1.16      yamt 
   1450       1.16      yamt 		/*
   1451       1.59   tsutsui 		 * Set up checksum offload. Note: checksum offload bits must
   1452       1.59   tsutsui 		 * appear in all descriptors of a multi-descriptor transmit
   1453       1.59   tsutsui 		 * attempt. (This is according to testing done with an 8169
   1454       1.59   tsutsui 		 * chip. I'm not sure if this is a requirement or a bug.)
   1455       1.16      yamt 		 */
   1456       1.16      yamt 
   1457       1.59   tsutsui 		if ((m->m_pkthdr.csum_flags & M_CSUM_TSOv4) != 0) {
   1458       1.59   tsutsui 			uint32_t segsz = m->m_pkthdr.segsz;
   1459       1.59   tsutsui 
   1460       1.59   tsutsui 			re_flags = RE_TDESC_CMD_LGSEND |
   1461       1.59   tsutsui 			    (segsz << RE_TDESC_CMD_MSSVAL_SHIFT);
   1462       1.59   tsutsui 		} else {
   1463       1.59   tsutsui 			/*
   1464       1.59   tsutsui 			 * set RE_TDESC_CMD_IPCSUM if any checksum offloading
   1465       1.59   tsutsui 			 * is requested.  otherwise, RE_TDESC_CMD_TCPCSUM/
   1466       1.59   tsutsui 			 * RE_TDESC_CMD_UDPCSUM doesn't make effects.
   1467       1.59   tsutsui 			 */
   1468       1.59   tsutsui 			re_flags = 0;
   1469       1.59   tsutsui 			if ((m->m_pkthdr.csum_flags &
   1470       1.59   tsutsui 			    (M_CSUM_IPv4 | M_CSUM_TCPv4 | M_CSUM_UDPv4))
   1471       1.59   tsutsui 			    != 0) {
   1472       1.59   tsutsui 				re_flags |= RE_TDESC_CMD_IPCSUM;
   1473       1.59   tsutsui 				if (m->m_pkthdr.csum_flags & M_CSUM_TCPv4) {
   1474       1.59   tsutsui 					re_flags |= RE_TDESC_CMD_TCPCSUM;
   1475       1.59   tsutsui 				} else if (m->m_pkthdr.csum_flags &
   1476       1.59   tsutsui 				    M_CSUM_UDPv4) {
   1477       1.59   tsutsui 					re_flags |= RE_TDESC_CMD_UDPCSUM;
   1478       1.59   tsutsui 				}
   1479       1.16      yamt 			}
   1480       1.16      yamt 		}
   1481        1.1  jonathan 
   1482       1.59   tsutsui 		txq = &sc->re_ldata.re_txq[idx];
   1483       1.59   tsutsui 		map = txq->txq_dmamap;
   1484       1.59   tsutsui 		error = bus_dmamap_load_mbuf(sc->sc_dmat, map, m,
   1485       1.59   tsutsui 		    BUS_DMA_WRITE|BUS_DMA_NOWAIT);
   1486       1.59   tsutsui 
   1487       1.75   tsutsui 		if (__predict_false(error)) {
   1488       1.59   tsutsui 			/* XXX try to defrag if EFBIG? */
   1489      1.101   tsutsui 			printf("%s: can't map mbuf (error %d)\n",
   1490      1.102   tsutsui 			    device_xname(sc->sc_dev), error);
   1491        1.1  jonathan 
   1492       1.59   tsutsui 			IFQ_DEQUEUE(&ifp->if_snd, m);
   1493       1.59   tsutsui 			m_freem(m);
   1494       1.59   tsutsui 			ifp->if_oerrors++;
   1495       1.59   tsutsui 			continue;
   1496       1.59   tsutsui 		}
   1497       1.13      yamt 
   1498       1.63   tsutsui 		nsegs = map->dm_nsegs;
   1499       1.87   tsutsui 		pad = false;
   1500       1.75   tsutsui 		if (__predict_false(m->m_pkthdr.len <= RE_IP4CSUMTX_PADLEN &&
   1501       1.75   tsutsui 		    (re_flags & RE_TDESC_CMD_IPCSUM) != 0)) {
   1502       1.87   tsutsui 			pad = true;
   1503       1.63   tsutsui 			nsegs++;
   1504       1.63   tsutsui 		}
   1505       1.63   tsutsui 
   1506       1.94   tsutsui 		if (nsegs > sc->re_ldata.re_tx_free) {
   1507       1.59   tsutsui 			/*
   1508       1.59   tsutsui 			 * Not enough free descriptors to transmit this packet.
   1509       1.59   tsutsui 			 */
   1510       1.59   tsutsui 			ifp->if_flags |= IFF_OACTIVE;
   1511       1.59   tsutsui 			bus_dmamap_unload(sc->sc_dmat, map);
   1512       1.59   tsutsui 			break;
   1513       1.59   tsutsui 		}
   1514       1.13      yamt 
   1515       1.59   tsutsui 		IFQ_DEQUEUE(&ifp->if_snd, m);
   1516        1.1  jonathan 
   1517       1.59   tsutsui 		/*
   1518       1.59   tsutsui 		 * Make sure that the caches are synchronized before we
   1519       1.59   tsutsui 		 * ask the chip to start DMA for the packet data.
   1520       1.59   tsutsui 		 */
   1521       1.59   tsutsui 		bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
   1522       1.59   tsutsui 		    BUS_DMASYNC_PREWRITE);
   1523       1.20    briggs 
   1524       1.59   tsutsui 		/*
   1525       1.98   tsutsui 		 * Set up hardware VLAN tagging. Note: vlan tag info must
   1526       1.98   tsutsui 		 * appear in all descriptors of a multi-descriptor
   1527       1.98   tsutsui 		 * transmission attempt.
   1528       1.98   tsutsui 		 */
   1529       1.98   tsutsui 		vlanctl = 0;
   1530       1.98   tsutsui 		if ((mtag = VLAN_OUTPUT_TAG(&sc->ethercom, m)) != NULL)
   1531       1.98   tsutsui 			vlanctl = bswap16(VLAN_TAG_VALUE(mtag)) |
   1532       1.98   tsutsui 			    RE_TDESC_VLANCTL_TAG;
   1533       1.98   tsutsui 
   1534       1.98   tsutsui 		/*
   1535       1.59   tsutsui 		 * Map the segment array into descriptors.
   1536       1.59   tsutsui 		 * Note that we set the start-of-frame and
   1537       1.59   tsutsui 		 * end-of-frame markers for either TX or RX,
   1538       1.59   tsutsui 		 * but they really only have meaning in the TX case.
   1539       1.59   tsutsui 		 * (In the RX case, it's the chip that tells us
   1540       1.59   tsutsui 		 *  where packets begin and end.)
   1541       1.59   tsutsui 		 * We also keep track of the end of the ring
   1542       1.59   tsutsui 		 * and set the end-of-ring bits as needed,
   1543       1.59   tsutsui 		 * and we set the ownership bits in all except
   1544       1.59   tsutsui 		 * the very first descriptor. (The caller will
   1545       1.59   tsutsui 		 * set this descriptor later when it start
   1546       1.59   tsutsui 		 * transmission or reception.)
   1547       1.59   tsutsui 		 */
   1548       1.59   tsutsui 		curdesc = startdesc = sc->re_ldata.re_tx_nextfree;
   1549       1.59   tsutsui 		lastdesc = -1;
   1550       1.59   tsutsui 		for (seg = 0; seg < map->dm_nsegs;
   1551       1.59   tsutsui 		    seg++, curdesc = RE_NEXT_TX_DESC(sc, curdesc)) {
   1552       1.59   tsutsui 			d = &sc->re_ldata.re_tx_list[curdesc];
   1553       1.69   tsutsui #ifdef DIAGNOSTIC
   1554       1.59   tsutsui 			RE_TXDESCSYNC(sc, curdesc,
   1555       1.59   tsutsui 			    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
   1556       1.59   tsutsui 			cmdstat = le32toh(d->re_cmdstat);
   1557       1.59   tsutsui 			RE_TXDESCSYNC(sc, curdesc, BUS_DMASYNC_PREREAD);
   1558       1.59   tsutsui 			if (cmdstat & RE_TDESC_STAT_OWN) {
   1559       1.59   tsutsui 				panic("%s: tried to map busy TX descriptor",
   1560      1.102   tsutsui 				    device_xname(sc->sc_dev));
   1561       1.59   tsutsui 			}
   1562       1.59   tsutsui #endif
   1563       1.20    briggs 
   1564       1.98   tsutsui 			d->re_vlanctl = htole32(vlanctl);
   1565       1.64   tsutsui 			re_set_bufaddr(d, map->dm_segs[seg].ds_addr);
   1566       1.59   tsutsui 			cmdstat = re_flags | map->dm_segs[seg].ds_len;
   1567       1.59   tsutsui 			if (seg == 0)
   1568       1.59   tsutsui 				cmdstat |= RE_TDESC_CMD_SOF;
   1569       1.59   tsutsui 			else
   1570       1.59   tsutsui 				cmdstat |= RE_TDESC_CMD_OWN;
   1571       1.59   tsutsui 			if (curdesc == (RE_TX_DESC_CNT(sc) - 1))
   1572       1.59   tsutsui 				cmdstat |= RE_TDESC_CMD_EOR;
   1573       1.63   tsutsui 			if (seg == nsegs - 1) {
   1574       1.59   tsutsui 				cmdstat |= RE_TDESC_CMD_EOF;
   1575       1.59   tsutsui 				lastdesc = curdesc;
   1576       1.13      yamt 			}
   1577       1.59   tsutsui 			d->re_cmdstat = htole32(cmdstat);
   1578       1.59   tsutsui 			RE_TXDESCSYNC(sc, curdesc,
   1579       1.59   tsutsui 			    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
   1580       1.13      yamt 		}
   1581       1.75   tsutsui 		if (__predict_false(pad)) {
   1582       1.63   tsutsui 			bus_addr_t paddaddr;
   1583       1.63   tsutsui 
   1584       1.63   tsutsui 			d = &sc->re_ldata.re_tx_list[curdesc];
   1585       1.98   tsutsui 			d->re_vlanctl = htole32(vlanctl);
   1586       1.63   tsutsui 			paddaddr = RE_TXPADDADDR(sc);
   1587       1.64   tsutsui 			re_set_bufaddr(d, paddaddr);
   1588       1.63   tsutsui 			cmdstat = re_flags |
   1589       1.63   tsutsui 			    RE_TDESC_CMD_OWN | RE_TDESC_CMD_EOF |
   1590       1.63   tsutsui 			    (RE_IP4CSUMTX_PADLEN + 1 - m->m_pkthdr.len);
   1591       1.63   tsutsui 			if (curdesc == (RE_TX_DESC_CNT(sc) - 1))
   1592       1.63   tsutsui 				cmdstat |= RE_TDESC_CMD_EOR;
   1593       1.63   tsutsui 			d->re_cmdstat = htole32(cmdstat);
   1594       1.63   tsutsui 			RE_TXDESCSYNC(sc, curdesc,
   1595       1.63   tsutsui 			    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
   1596       1.63   tsutsui 			lastdesc = curdesc;
   1597       1.63   tsutsui 			curdesc = RE_NEXT_TX_DESC(sc, curdesc);
   1598       1.63   tsutsui 		}
   1599       1.59   tsutsui 		KASSERT(lastdesc != -1);
   1600        1.1  jonathan 
   1601       1.59   tsutsui 		/* Transfer ownership of packet to the chip. */
   1602        1.1  jonathan 
   1603       1.59   tsutsui 		sc->re_ldata.re_tx_list[startdesc].re_cmdstat |=
   1604       1.59   tsutsui 		    htole32(RE_TDESC_CMD_OWN);
   1605       1.59   tsutsui 		RE_TXDESCSYNC(sc, startdesc,
   1606       1.59   tsutsui 		    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
   1607       1.17      yamt 
   1608       1.59   tsutsui 		/* update info of TX queue and descriptors */
   1609       1.59   tsutsui 		txq->txq_mbuf = m;
   1610       1.59   tsutsui 		txq->txq_descidx = lastdesc;
   1611       1.63   tsutsui 		txq->txq_nsegs = nsegs;
   1612       1.59   tsutsui 
   1613       1.59   tsutsui 		sc->re_ldata.re_txq_free--;
   1614       1.63   tsutsui 		sc->re_ldata.re_tx_free -= nsegs;
   1615       1.59   tsutsui 		sc->re_ldata.re_tx_nextfree = curdesc;
   1616       1.17      yamt 
   1617        1.1  jonathan #if NBPFILTER > 0
   1618        1.1  jonathan 		/*
   1619        1.1  jonathan 		 * If there's a BPF listener, bounce a copy of this frame
   1620        1.1  jonathan 		 * to him.
   1621        1.1  jonathan 		 */
   1622        1.1  jonathan 		if (ifp->if_bpf)
   1623       1.17      yamt 			bpf_mtap(ifp->if_bpf, m);
   1624        1.1  jonathan #endif
   1625        1.1  jonathan 	}
   1626        1.1  jonathan 
   1627       1.59   tsutsui 	if (sc->re_ldata.re_txq_free < ofree) {
   1628       1.59   tsutsui 		/*
   1629       1.59   tsutsui 		 * TX packets are enqueued.
   1630       1.59   tsutsui 		 */
   1631       1.59   tsutsui 		sc->re_ldata.re_txq_prodidx = idx;
   1632       1.17      yamt 
   1633       1.59   tsutsui 		/*
   1634       1.59   tsutsui 		 * Start the transmitter to poll.
   1635       1.59   tsutsui 		 *
   1636       1.59   tsutsui 		 * RealTek put the TX poll request register in a different
   1637       1.59   tsutsui 		 * location on the 8169 gigE chip. I don't know why.
   1638       1.59   tsutsui 		 */
   1639       1.84   tsutsui 		if ((sc->sc_quirk & RTKQ_8139CPLUS) != 0)
   1640       1.84   tsutsui 			CSR_WRITE_1(sc, RTK_TXSTART, RTK_TXSTART_START);
   1641       1.84   tsutsui 		else
   1642       1.95   tsutsui 			CSR_WRITE_1(sc, RTK_GTXSTART, RTK_TXSTART_START);
   1643        1.1  jonathan 
   1644       1.59   tsutsui 		/*
   1645       1.59   tsutsui 		 * Use the countdown timer for interrupt moderation.
   1646       1.59   tsutsui 		 * 'TX done' interrupts are disabled. Instead, we reset the
   1647       1.59   tsutsui 		 * countdown timer, which will begin counting until it hits
   1648       1.59   tsutsui 		 * the value in the TIMERINT register, and then trigger an
   1649       1.59   tsutsui 		 * interrupt. Each time we write to the TIMERCNT register,
   1650       1.59   tsutsui 		 * the timer count is reset to 0.
   1651       1.59   tsutsui 		 */
   1652       1.59   tsutsui 		CSR_WRITE_4(sc, RTK_TIMERCNT, 1);
   1653        1.1  jonathan 
   1654       1.59   tsutsui 		/*
   1655       1.59   tsutsui 		 * Set a timeout in case the chip goes out to lunch.
   1656       1.59   tsutsui 		 */
   1657       1.59   tsutsui 		ifp->if_timer = 5;
   1658       1.59   tsutsui 	}
   1659        1.1  jonathan }
   1660        1.1  jonathan 
   1661        1.1  jonathan static int
   1662        1.1  jonathan re_init(struct ifnet *ifp)
   1663        1.1  jonathan {
   1664      1.102   tsutsui 	struct rtk_softc *sc = ifp->if_softc;
   1665      1.102   tsutsui 	const uint8_t *enaddr;
   1666      1.102   tsutsui 	uint32_t rxcfg = 0;
   1667      1.102   tsutsui 	uint32_t reg;
   1668        1.1  jonathan 	int error;
   1669       1.12     perry 
   1670        1.1  jonathan 	if ((error = re_enable(sc)) != 0)
   1671        1.1  jonathan 		goto out;
   1672        1.1  jonathan 
   1673        1.1  jonathan 	/*
   1674        1.1  jonathan 	 * Cancel pending I/O and free all RX/TX buffers.
   1675        1.1  jonathan 	 */
   1676        1.3   kanaoka 	re_stop(ifp, 0);
   1677        1.1  jonathan 
   1678       1.53   tsutsui 	re_reset(sc);
   1679       1.53   tsutsui 
   1680        1.1  jonathan 	/*
   1681        1.1  jonathan 	 * Enable C+ RX and TX mode, as well as VLAN stripping and
   1682        1.1  jonathan 	 * RX checksum offload. We must configure the C+ register
   1683        1.1  jonathan 	 * before all others.
   1684        1.1  jonathan 	 */
   1685        1.1  jonathan 	reg = 0;
   1686        1.1  jonathan 
   1687        1.1  jonathan 	/*
   1688        1.1  jonathan 	 * XXX: Realtek docs say bits 0 and 1 are reserved, for 8169S/8110S.
   1689        1.1  jonathan 	 * FreeBSD  drivers set these bits anyway (for 8139C+?).
   1690        1.1  jonathan 	 * So far, it works.
   1691        1.1  jonathan 	 */
   1692        1.1  jonathan 
   1693        1.1  jonathan 	/*
   1694       1.84   tsutsui 	 * XXX: For old 8169 set bit 14.
   1695       1.84   tsutsui 	 *      For 8169S/8110S and above, do not set bit 14.
   1696        1.1  jonathan 	 */
   1697       1.84   tsutsui 	if ((sc->sc_quirk & RTKQ_8169NONS) != 0)
   1698        1.4   kanaoka 		reg |= (0x1 << 14) | RTK_CPLUSCMD_PCI_MRW;;
   1699        1.1  jonathan 
   1700        1.4   kanaoka 	if (1)  {/* not for 8169S ? */
   1701       1.24     blymn 		reg |=
   1702       1.23     pavel 		    RTK_CPLUSCMD_VLANSTRIP |
   1703        1.4   kanaoka 		    (ifp->if_capenable &
   1704       1.18      yamt 		    (IFCAP_CSUM_IPv4_Rx | IFCAP_CSUM_TCPv4_Rx |
   1705       1.18      yamt 		     IFCAP_CSUM_UDPv4_Rx) ?
   1706        1.4   kanaoka 		    RTK_CPLUSCMD_RXCSUM_ENB : 0);
   1707        1.4   kanaoka 	}
   1708       1.12     perry 
   1709        1.1  jonathan 	CSR_WRITE_2(sc, RTK_CPLUS_CMD,
   1710        1.4   kanaoka 	    reg | RTK_CPLUSCMD_RXENB | RTK_CPLUSCMD_TXENB);
   1711        1.1  jonathan 
   1712        1.1  jonathan 	/* XXX: from Realtek-supplied Linux driver. Wholly undocumented. */
   1713       1.84   tsutsui 	if ((sc->sc_quirk & RTKQ_8139CPLUS) == 0)
   1714       1.66   tsutsui 		CSR_WRITE_2(sc, RTK_IM, 0x0000);
   1715        1.1  jonathan 
   1716        1.1  jonathan 	DELAY(10000);
   1717        1.1  jonathan 
   1718        1.1  jonathan 	/*
   1719        1.1  jonathan 	 * Init our MAC address.  Even though the chipset
   1720        1.1  jonathan 	 * documentation doesn't mention it, we need to enter "Config
   1721        1.1  jonathan 	 * register write enable" mode to modify the ID registers.
   1722        1.1  jonathan 	 */
   1723        1.1  jonathan 	CSR_WRITE_1(sc, RTK_EECMD, RTK_EEMODE_WRITECFG);
   1724       1.88    dyoung 	enaddr = CLLADDR(ifp->if_sadl);
   1725       1.49   tsutsui 	reg = enaddr[0] | (enaddr[1] << 8) |
   1726       1.49   tsutsui 	    (enaddr[2] << 16) | (enaddr[3] << 24);
   1727       1.49   tsutsui 	CSR_WRITE_4(sc, RTK_IDR0, reg);
   1728       1.49   tsutsui 	reg = enaddr[4] | (enaddr[5] << 8);
   1729       1.49   tsutsui 	CSR_WRITE_4(sc, RTK_IDR4, reg);
   1730        1.1  jonathan 	CSR_WRITE_1(sc, RTK_EECMD, RTK_EEMODE_OFF);
   1731        1.1  jonathan 
   1732        1.1  jonathan 	/*
   1733        1.1  jonathan 	 * For C+ mode, initialize the RX descriptors and mbufs.
   1734        1.1  jonathan 	 */
   1735        1.1  jonathan 	re_rx_list_init(sc);
   1736        1.1  jonathan 	re_tx_list_init(sc);
   1737        1.1  jonathan 
   1738        1.1  jonathan 	/*
   1739       1.54   tsutsui 	 * Load the addresses of the RX and TX lists into the chip.
   1740       1.54   tsutsui 	 */
   1741       1.54   tsutsui 	CSR_WRITE_4(sc, RTK_RXLIST_ADDR_HI,
   1742       1.54   tsutsui 	    RE_ADDR_HI(sc->re_ldata.re_rx_list_map->dm_segs[0].ds_addr));
   1743       1.54   tsutsui 	CSR_WRITE_4(sc, RTK_RXLIST_ADDR_LO,
   1744       1.54   tsutsui 	    RE_ADDR_LO(sc->re_ldata.re_rx_list_map->dm_segs[0].ds_addr));
   1745       1.54   tsutsui 
   1746       1.54   tsutsui 	CSR_WRITE_4(sc, RTK_TXLIST_ADDR_HI,
   1747       1.54   tsutsui 	    RE_ADDR_HI(sc->re_ldata.re_tx_list_map->dm_segs[0].ds_addr));
   1748       1.54   tsutsui 	CSR_WRITE_4(sc, RTK_TXLIST_ADDR_LO,
   1749       1.54   tsutsui 	    RE_ADDR_LO(sc->re_ldata.re_tx_list_map->dm_segs[0].ds_addr));
   1750       1.54   tsutsui 
   1751       1.54   tsutsui 	/*
   1752        1.1  jonathan 	 * Enable transmit and receive.
   1753        1.1  jonathan 	 */
   1754        1.4   kanaoka 	CSR_WRITE_1(sc, RTK_COMMAND, RTK_CMD_TX_ENB | RTK_CMD_RX_ENB);
   1755        1.1  jonathan 
   1756        1.1  jonathan 	/*
   1757        1.1  jonathan 	 * Set the initial TX and RX configuration.
   1758        1.1  jonathan 	 */
   1759       1.84   tsutsui 	if (sc->re_testmode && (sc->sc_quirk & RTKQ_8169NONS) != 0) {
   1760       1.84   tsutsui 		/* test mode is needed only for old 8169 */
   1761       1.84   tsutsui 		CSR_WRITE_4(sc, RTK_TXCFG,
   1762       1.84   tsutsui 		    RE_TXCFG_CONFIG | RTK_LOOPTEST_ON);
   1763        1.1  jonathan 	} else
   1764       1.70   tsutsui 		CSR_WRITE_4(sc, RTK_TXCFG, RE_TXCFG_CONFIG);
   1765       1.54   tsutsui 
   1766       1.54   tsutsui 	CSR_WRITE_1(sc, RTK_EARLY_TX_THRESH, 16);
   1767       1.54   tsutsui 
   1768       1.70   tsutsui 	CSR_WRITE_4(sc, RTK_RXCFG, RE_RXCFG_CONFIG);
   1769        1.1  jonathan 
   1770        1.1  jonathan 	/* Set the individual bit to receive frames for this host only. */
   1771        1.1  jonathan 	rxcfg = CSR_READ_4(sc, RTK_RXCFG);
   1772        1.1  jonathan 	rxcfg |= RTK_RXCFG_RX_INDIV;
   1773        1.1  jonathan 
   1774        1.1  jonathan 	/* If we want promiscuous mode, set the allframes bit. */
   1775        1.8  jdolecek 	if (ifp->if_flags & IFF_PROMISC)
   1776        1.1  jonathan 		rxcfg |= RTK_RXCFG_RX_ALLPHYS;
   1777        1.8  jdolecek 	else
   1778        1.1  jonathan 		rxcfg &= ~RTK_RXCFG_RX_ALLPHYS;
   1779        1.8  jdolecek 	CSR_WRITE_4(sc, RTK_RXCFG, rxcfg);
   1780        1.1  jonathan 
   1781        1.1  jonathan 	/*
   1782        1.1  jonathan 	 * Set capture broadcast bit to capture broadcast frames.
   1783        1.1  jonathan 	 */
   1784        1.8  jdolecek 	if (ifp->if_flags & IFF_BROADCAST)
   1785        1.1  jonathan 		rxcfg |= RTK_RXCFG_RX_BROAD;
   1786        1.8  jdolecek 	else
   1787        1.1  jonathan 		rxcfg &= ~RTK_RXCFG_RX_BROAD;
   1788        1.8  jdolecek 	CSR_WRITE_4(sc, RTK_RXCFG, rxcfg);
   1789        1.1  jonathan 
   1790        1.1  jonathan 	/*
   1791        1.1  jonathan 	 * Program the multicast filter, if necessary.
   1792        1.1  jonathan 	 */
   1793        1.1  jonathan 	rtk_setmulti(sc);
   1794        1.1  jonathan 
   1795        1.1  jonathan 	/*
   1796        1.1  jonathan 	 * Enable interrupts.
   1797        1.1  jonathan 	 */
   1798       1.52   tsutsui 	if (sc->re_testmode)
   1799        1.1  jonathan 		CSR_WRITE_2(sc, RTK_IMR, 0);
   1800        1.1  jonathan 	else
   1801        1.1  jonathan 		CSR_WRITE_2(sc, RTK_IMR, RTK_INTRS_CPLUS);
   1802        1.1  jonathan 
   1803        1.1  jonathan 	/* Start RX/TX process. */
   1804        1.1  jonathan 	CSR_WRITE_4(sc, RTK_MISSEDPKT, 0);
   1805        1.1  jonathan #ifdef notdef
   1806        1.1  jonathan 	/* Enable receiver and transmitter. */
   1807        1.4   kanaoka 	CSR_WRITE_1(sc, RTK_COMMAND, RTK_CMD_TX_ENB | RTK_CMD_RX_ENB);
   1808        1.1  jonathan #endif
   1809        1.1  jonathan 
   1810        1.1  jonathan 	/*
   1811        1.1  jonathan 	 * Initialize the timer interrupt register so that
   1812        1.1  jonathan 	 * a timer interrupt will be generated once the timer
   1813        1.1  jonathan 	 * reaches a certain number of ticks. The timer is
   1814        1.1  jonathan 	 * reloaded on each transmit. This gives us TX interrupt
   1815        1.1  jonathan 	 * moderation, which dramatically improves TX frame rate.
   1816        1.1  jonathan 	 */
   1817        1.1  jonathan 
   1818       1.84   tsutsui 	if ((sc->sc_quirk & RTKQ_8139CPLUS) != 0)
   1819       1.84   tsutsui 		CSR_WRITE_4(sc, RTK_TIMERINT, 0x400);
   1820       1.84   tsutsui 	else {
   1821        1.1  jonathan 		CSR_WRITE_4(sc, RTK_TIMERINT_8169, 0x800);
   1822        1.1  jonathan 
   1823       1.84   tsutsui 		/*
   1824       1.84   tsutsui 		 * For 8169 gigE NICs, set the max allowed RX packet
   1825       1.84   tsutsui 		 * size so we can receive jumbo frames.
   1826       1.84   tsutsui 		 */
   1827        1.1  jonathan 		CSR_WRITE_2(sc, RTK_MAXRXPKTLEN, 16383);
   1828       1.84   tsutsui 	}
   1829        1.1  jonathan 
   1830       1.52   tsutsui 	if (sc->re_testmode)
   1831        1.1  jonathan 		return 0;
   1832        1.1  jonathan 
   1833       1.81   tsutsui 	CSR_WRITE_1(sc, RTK_CFG1, RTK_CFG1_DRVLOAD);
   1834        1.1  jonathan 
   1835        1.1  jonathan 	ifp->if_flags |= IFF_RUNNING;
   1836        1.1  jonathan 	ifp->if_flags &= ~IFF_OACTIVE;
   1837        1.1  jonathan 
   1838        1.1  jonathan 	callout_reset(&sc->rtk_tick_ch, hz, re_tick, sc);
   1839        1.1  jonathan 
   1840       1.41   tsutsui  out:
   1841        1.1  jonathan 	if (error) {
   1842        1.4   kanaoka 		ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
   1843        1.1  jonathan 		ifp->if_timer = 0;
   1844      1.101   tsutsui 		printf("%s: interface not running\n",
   1845      1.102   tsutsui 		    device_xname(sc->sc_dev));
   1846        1.1  jonathan 	}
   1847       1.12     perry 
   1848        1.1  jonathan 	return error;
   1849        1.1  jonathan }
   1850        1.1  jonathan 
   1851        1.1  jonathan static int
   1852       1.83  christos re_ioctl(struct ifnet *ifp, u_long command, void *data)
   1853        1.1  jonathan {
   1854      1.102   tsutsui 	struct rtk_softc *sc = ifp->if_softc;
   1855      1.102   tsutsui 	struct ifreq *ifr = data;
   1856      1.102   tsutsui 	int s, error = 0;
   1857        1.1  jonathan 
   1858        1.1  jonathan 	s = splnet();
   1859        1.1  jonathan 
   1860        1.4   kanaoka 	switch (command) {
   1861        1.1  jonathan 	case SIOCSIFMTU:
   1862  1.104.2.1  wrstuden 		/*
   1863  1.104.2.1  wrstuden 		 * According to FreeBSD, 8102E/8102EL use a different DMA
   1864  1.104.2.1  wrstuden 		 * descriptor format. Disable jumbo frames for those parts.
   1865  1.104.2.1  wrstuden 		 */
   1866  1.104.2.1  wrstuden 		if (sc->sc_rev == 25 && ifr->ifr_mtu > ETHERMTU) {
   1867  1.104.2.1  wrstuden 			error = EINVAL;
   1868  1.104.2.1  wrstuden 			break;
   1869  1.104.2.1  wrstuden 		}
   1870  1.104.2.1  wrstuden 
   1871       1.96    dyoung 		if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > ETHERMTU_JUMBO)
   1872        1.1  jonathan 			error = EINVAL;
   1873      1.102   tsutsui 		else if ((error = ifioctl_common(ifp, command, data)) ==
   1874      1.102   tsutsui 		    ENETRESET)
   1875       1.96    dyoung 			error = 0;
   1876        1.1  jonathan 		break;
   1877        1.1  jonathan 	default:
   1878       1.96    dyoung 		if ((error = ether_ioctl(ifp, command, data)) != ENETRESET)
   1879       1.96    dyoung 			break;
   1880       1.96    dyoung 
   1881       1.96    dyoung 		error = 0;
   1882       1.96    dyoung 
   1883       1.96    dyoung 		if (command == SIOCSIFCAP)
   1884       1.96    dyoung 			error = (*ifp->if_init)(ifp);
   1885       1.96    dyoung 		else if (command != SIOCADDMULTI && command != SIOCDELMULTI)
   1886       1.96    dyoung 			;
   1887       1.96    dyoung 		else if (ifp->if_flags & IFF_RUNNING)
   1888       1.96    dyoung 			rtk_setmulti(sc);
   1889        1.1  jonathan 		break;
   1890        1.1  jonathan 	}
   1891        1.1  jonathan 
   1892        1.1  jonathan 	splx(s);
   1893        1.1  jonathan 
   1894        1.4   kanaoka 	return error;
   1895        1.1  jonathan }
   1896        1.1  jonathan 
   1897        1.1  jonathan static void
   1898        1.1  jonathan re_watchdog(struct ifnet *ifp)
   1899        1.1  jonathan {
   1900      1.102   tsutsui 	struct rtk_softc *sc;
   1901      1.102   tsutsui 	int s;
   1902        1.1  jonathan 
   1903        1.1  jonathan 	sc = ifp->if_softc;
   1904        1.1  jonathan 	s = splnet();
   1905      1.102   tsutsui 	printf("%s: watchdog timeout\n", device_xname(sc->sc_dev));
   1906        1.1  jonathan 	ifp->if_oerrors++;
   1907        1.1  jonathan 
   1908        1.1  jonathan 	re_txeof(sc);
   1909        1.1  jonathan 	re_rxeof(sc);
   1910        1.1  jonathan 
   1911        1.1  jonathan 	re_init(ifp);
   1912        1.1  jonathan 
   1913        1.1  jonathan 	splx(s);
   1914        1.1  jonathan }
   1915        1.1  jonathan 
   1916        1.1  jonathan /*
   1917        1.1  jonathan  * Stop the adapter and free any mbufs allocated to the
   1918        1.1  jonathan  * RX and TX lists.
   1919        1.1  jonathan  */
   1920        1.1  jonathan static void
   1921        1.3   kanaoka re_stop(struct ifnet *ifp, int disable)
   1922        1.1  jonathan {
   1923      1.102   tsutsui 	int i;
   1924        1.3   kanaoka 	struct rtk_softc *sc = ifp->if_softc;
   1925        1.1  jonathan 
   1926        1.3   kanaoka 	callout_stop(&sc->rtk_tick_ch);
   1927        1.1  jonathan 
   1928        1.3   kanaoka 	mii_down(&sc->mii);
   1929        1.3   kanaoka 
   1930        1.1  jonathan 	CSR_WRITE_1(sc, RTK_COMMAND, 0x00);
   1931        1.1  jonathan 	CSR_WRITE_2(sc, RTK_IMR, 0x0000);
   1932        1.1  jonathan 
   1933       1.52   tsutsui 	if (sc->re_head != NULL) {
   1934       1.52   tsutsui 		m_freem(sc->re_head);
   1935       1.52   tsutsui 		sc->re_head = sc->re_tail = NULL;
   1936        1.1  jonathan 	}
   1937        1.1  jonathan 
   1938        1.1  jonathan 	/* Free the TX list buffers. */
   1939       1.52   tsutsui 	for (i = 0; i < RE_TX_QLEN; i++) {
   1940       1.52   tsutsui 		if (sc->re_ldata.re_txq[i].txq_mbuf != NULL) {
   1941        1.1  jonathan 			bus_dmamap_unload(sc->sc_dmat,
   1942       1.52   tsutsui 			    sc->re_ldata.re_txq[i].txq_dmamap);
   1943       1.52   tsutsui 			m_freem(sc->re_ldata.re_txq[i].txq_mbuf);
   1944       1.52   tsutsui 			sc->re_ldata.re_txq[i].txq_mbuf = NULL;
   1945        1.1  jonathan 		}
   1946        1.1  jonathan 	}
   1947        1.1  jonathan 
   1948        1.1  jonathan 	/* Free the RX list buffers. */
   1949       1.52   tsutsui 	for (i = 0; i < RE_RX_DESC_CNT; i++) {
   1950       1.52   tsutsui 		if (sc->re_ldata.re_rxsoft[i].rxs_mbuf != NULL) {
   1951        1.1  jonathan 			bus_dmamap_unload(sc->sc_dmat,
   1952       1.52   tsutsui 			    sc->re_ldata.re_rxsoft[i].rxs_dmamap);
   1953       1.52   tsutsui 			m_freem(sc->re_ldata.re_rxsoft[i].rxs_mbuf);
   1954       1.52   tsutsui 			sc->re_ldata.re_rxsoft[i].rxs_mbuf = NULL;
   1955        1.1  jonathan 		}
   1956        1.1  jonathan 	}
   1957        1.1  jonathan 
   1958        1.3   kanaoka 	if (disable)
   1959        1.3   kanaoka 		re_disable(sc);
   1960        1.3   kanaoka 
   1961        1.3   kanaoka 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
   1962        1.4   kanaoka 	ifp->if_timer = 0;
   1963        1.1  jonathan }
   1964