Home | History | Annotate | Line # | Download | only in usb
if_axen.c revision 1.39
      1 /*	$NetBSD: if_axen.c,v 1.39 2019/05/23 10:57:29 msaitoh Exp $	*/
      2 /*	$OpenBSD: if_axen.c,v 1.3 2013/10/21 10:10:22 yuo Exp $	*/
      3 
      4 /*
      5  * Copyright (c) 2013 Yojiro UO <yuo (at) openbsd.org>
      6  *
      7  * Permission to use, copy, modify, and distribute this software for any
      8  * purpose with or without fee is hereby granted, provided that the above
      9  * copyright notice and this permission notice appear in all copies.
     10  *
     11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
     12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
     14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
     15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
     16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
     17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
     18  */
     19 
     20 /*
     21  * ASIX Electronics AX88178a USB 2.0 ethernet and AX88179 USB 3.0 Ethernet
     22  * driver.
     23  */
     24 
     25 #include <sys/cdefs.h>
     26 __KERNEL_RCSID(0, "$NetBSD: if_axen.c,v 1.39 2019/05/23 10:57:29 msaitoh Exp $");
     27 
     28 #ifdef _KERNEL_OPT
     29 #include "opt_inet.h"
     30 #include "opt_usb.h"
     31 #endif
     32 
     33 #include <sys/param.h>
     34 #include <sys/bus.h>
     35 #include <sys/device.h>
     36 #include <sys/kernel.h>
     37 #include <sys/mbuf.h>
     38 #include <sys/module.h>
     39 #include <sys/rwlock.h>
     40 #include <sys/socket.h>
     41 #include <sys/sockio.h>
     42 #include <sys/systm.h>
     43 
     44 #include <sys/rndsource.h>
     45 
     46 #include <net/if.h>
     47 #include <net/if_dl.h>
     48 #include <net/if_ether.h>
     49 #include <net/if_media.h>
     50 
     51 #include <net/bpf.h>
     52 
     53 #include <netinet/in.h>		/* XXX for netinet/ip.h */
     54 #include <netinet/ip.h>		/* XXX for IP_MAXPACKET */
     55 
     56 #include <dev/mii/mii.h>
     57 #include <dev/mii/miivar.h>
     58 
     59 #include <dev/usb/usb.h>
     60 #include <dev/usb/usbdi.h>
     61 #include <dev/usb/usbdi_util.h>
     62 #include <dev/usb/usbdivar.h>
     63 #include <dev/usb/usbdevs.h>
     64 
     65 #include <dev/usb/if_axenreg.h>
     66 
     67 #ifdef AXEN_DEBUG
     68 #define DPRINTF(x)	do { if (axendebug) printf x; } while (/*CONSTCOND*/0)
     69 #define DPRINTFN(n, x)	do { if (axendebug >= (n)) printf x; } while (/*CONSTCOND*/0)
     70 int	axendebug = 0;
     71 #else
     72 #define DPRINTF(x)
     73 #define DPRINTFN(n, x)
     74 #endif
     75 
     76 /*
     77  * Various supported device vendors/products.
     78  */
     79 static const struct axen_type axen_devs[] = {
     80 #if 0 /* not tested */
     81 	{ { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88178A}, AX178A },
     82 #endif
     83 	{ { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88179}, AX179 },
     84 	{ { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DUB1312}, AX179 }
     85 };
     86 
     87 #define axen_lookup(v, p) ((const struct axen_type *)usb_lookup(axen_devs, v, p))
     88 
     89 static int	axen_match(device_t, cfdata_t, void *);
     90 static void	axen_attach(device_t, device_t, void *);
     91 static int	axen_detach(device_t, int);
     92 static int	axen_activate(device_t, devact_t);
     93 
     94 CFATTACH_DECL_NEW(axen, sizeof(struct axen_softc),
     95 	axen_match, axen_attach, axen_detach, axen_activate);
     96 
     97 static int	axen_tx_list_init(struct axen_softc *);
     98 static int	axen_rx_list_init(struct axen_softc *);
     99 static struct mbuf *axen_newbuf(void);
    100 static int	axen_encap(struct axen_softc *, struct mbuf *, int);
    101 static void	axen_rxeof(struct usbd_xfer *, void *, usbd_status);
    102 static int	axen_csum_flags_rx(struct ifnet *, uint32_t);
    103 static void	axen_txeof(struct usbd_xfer *, void *, usbd_status);
    104 static void	axen_tick(void *);
    105 static void	axen_tick_task(void *);
    106 static void	axen_start(struct ifnet *);
    107 static int	axen_ioctl(struct ifnet *, u_long, void *);
    108 static int	axen_init(struct ifnet *);
    109 static void	axen_stop(struct ifnet *, int);
    110 static void	axen_watchdog(struct ifnet *);
    111 static int	axen_miibus_readreg(device_t, int, int, uint16_t *);
    112 static int	axen_miibus_writereg(device_t, int, int, uint16_t);
    113 static void	axen_miibus_statchg(struct ifnet *);
    114 static int	axen_cmd(struct axen_softc *, int, int, int, void *);
    115 static int	axen_ifmedia_upd(struct ifnet *);
    116 static void	axen_ifmedia_sts(struct ifnet *, struct ifmediareq *);
    117 static void	axen_reset(struct axen_softc *);
    118 #if 0
    119 static int	axen_ax88179_eeprom(struct axen_softc *, void *);
    120 #endif
    121 
    122 static void	axen_iff(struct axen_softc *);
    123 static void	axen_lock_mii(struct axen_softc *);
    124 static void	axen_unlock_mii(struct axen_softc *);
    125 
    126 static void	axen_ax88179_init(struct axen_softc *);
    127 static void	axen_setcoe(struct axen_softc *);
    128 
    129 /* Get exclusive access to the MII registers */
    130 static void
    131 axen_lock_mii(struct axen_softc *sc)
    132 {
    133 
    134 	sc->axen_refcnt++;
    135 	rw_enter(&sc->axen_mii_lock, RW_WRITER);
    136 }
    137 
    138 static void
    139 axen_unlock_mii(struct axen_softc *sc)
    140 {
    141 
    142 	rw_exit(&sc->axen_mii_lock);
    143 	if (--sc->axen_refcnt < 0)
    144 		usb_detach_wakeupold(sc->axen_dev);
    145 }
    146 
    147 static int
    148 axen_cmd(struct axen_softc *sc, int cmd, int index, int val, void *buf)
    149 {
    150 	usb_device_request_t req;
    151 	usbd_status err;
    152 
    153 	KASSERT(rw_lock_held(&sc->axen_mii_lock));
    154 
    155 	if (sc->axen_dying)
    156 		return 0;
    157 
    158 	if (AXEN_CMD_DIR(cmd))
    159 		req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
    160 	else
    161 		req.bmRequestType = UT_READ_VENDOR_DEVICE;
    162 	req.bRequest = AXEN_CMD_CMD(cmd);
    163 	USETW(req.wValue, val);
    164 	USETW(req.wIndex, index);
    165 	USETW(req.wLength, AXEN_CMD_LEN(cmd));
    166 
    167 	err = usbd_do_request(sc->axen_udev, &req, buf);
    168 	DPRINTFN(5, ("axen_cmd: cmd 0x%04x val 0x%04x len %d\n",
    169 	    cmd, val, AXEN_CMD_LEN(cmd)));
    170 
    171 	if (err) {
    172 		DPRINTF(("axen_cmd err: cmd: %d, error: %d\n", cmd, err));
    173 		return -1;
    174 	}
    175 
    176 	return 0;
    177 }
    178 
    179 static int
    180 axen_miibus_readreg(device_t dev, int phy, int reg, uint16_t *val)
    181 {
    182 	struct axen_softc *sc = device_private(dev);
    183 	usbd_status err;
    184 	uint16_t data;
    185 
    186 	if (sc->axen_dying) {
    187 		DPRINTF(("axen: dying\n"));
    188 		return -1;
    189 	}
    190 
    191 	if (sc->axen_phyno != phy)
    192 		return -1;
    193 
    194 	axen_lock_mii(sc);
    195 	err = axen_cmd(sc, AXEN_CMD_MII_READ_REG, reg, phy, &data);
    196 	axen_unlock_mii(sc);
    197 
    198 	if (err) {
    199 		aprint_error_dev(sc->axen_dev, "read PHY failed\n");
    200 		return err;
    201 	}
    202 
    203 	*val = le16toh(data);
    204 	DPRINTFN(2,("axen_miibus_readreg: phy 0x%x reg 0x%x val 0x%hx\n",
    205 	    phy, reg, *val));
    206 
    207 	if (reg == MII_BMSR) {
    208 		*val &= ~BMSR_EXTCAP;
    209 	}
    210 
    211 	return 0;
    212 }
    213 
    214 static int
    215 axen_miibus_writereg(device_t dev, int phy, int reg, uint16_t val)
    216 {
    217 	struct axen_softc *sc = device_private(dev);
    218 	usbd_status err;
    219 	uint16_t uval;
    220 
    221 	if (sc->axen_dying)
    222 		return -1;
    223 
    224 	if (sc->axen_phyno != phy)
    225 		return -1;
    226 
    227 	uval = htole16(val);
    228 	axen_lock_mii(sc);
    229 	err = axen_cmd(sc, AXEN_CMD_MII_WRITE_REG, reg, phy, &uval);
    230 	axen_unlock_mii(sc);
    231 	DPRINTFN(2, ("axen_miibus_writereg: phy 0x%x reg 0x%x val 0x%04hx\n",
    232 	    phy, reg, val));
    233 
    234 	if (err) {
    235 		aprint_error_dev(sc->axen_dev, "write PHY failed\n");
    236 		return err;
    237 	}
    238 
    239 	return 0;
    240 }
    241 
    242 static void
    243 axen_miibus_statchg(struct ifnet *ifp)
    244 {
    245 	struct axen_softc *sc = ifp->if_softc;
    246 	struct mii_data *mii = GET_MII(sc);
    247 	int err;
    248 	uint16_t val;
    249 	uint16_t wval;
    250 
    251 	sc->axen_link = 0;
    252 	if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
    253 	    (IFM_ACTIVE | IFM_AVALID)) {
    254 		switch (IFM_SUBTYPE(mii->mii_media_active)) {
    255 		case IFM_10_T:
    256 		case IFM_100_TX:
    257 			sc->axen_link++;
    258 			break;
    259 		case IFM_1000_T:
    260 			sc->axen_link++;
    261 			break;
    262 		default:
    263 			break;
    264 		}
    265 	}
    266 
    267 	/* Lost link, do nothing. */
    268 	if (sc->axen_link == 0)
    269 		return;
    270 
    271 	val = 0;
    272 	if ((mii->mii_media_active & IFM_FDX) != 0)
    273 		val |= AXEN_MEDIUM_FDX;
    274 
    275 	val |= AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN |
    276 	    AXEN_MEDIUM_RECV_EN;
    277 	switch (IFM_SUBTYPE(mii->mii_media_active)) {
    278 	case IFM_1000_T:
    279 		val |= AXEN_MEDIUM_GIGA | AXEN_MEDIUM_EN_125MHZ;
    280 		break;
    281 	case IFM_100_TX:
    282 		val |= AXEN_MEDIUM_PS;
    283 		break;
    284 	case IFM_10_T:
    285 		/* doesn't need to be handled */
    286 		break;
    287 	}
    288 
    289 	DPRINTF(("axen_miibus_statchg: val=0x%x\n", val));
    290 	wval = htole16(val);
    291 	axen_lock_mii(sc);
    292 	err = axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval);
    293 	axen_unlock_mii(sc);
    294 	if (err) {
    295 		aprint_error_dev(sc->axen_dev, "media change failed\n");
    296 		return;
    297 	}
    298 }
    299 
    300 /*
    301  * Set media options.
    302  */
    303 static int
    304 axen_ifmedia_upd(struct ifnet *ifp)
    305 {
    306 	struct axen_softc *sc = ifp->if_softc;
    307 	struct mii_data *mii = GET_MII(sc);
    308 	int rc;
    309 
    310 	sc->axen_link = 0;
    311 
    312 	if (mii->mii_instance) {
    313 		struct mii_softc *miisc;
    314 
    315 		LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
    316 			mii_phy_reset(miisc);
    317 	}
    318 
    319 	if ((rc = mii_mediachg(mii)) == ENXIO)
    320 		return 0;
    321 	return rc;
    322 }
    323 
    324 /*
    325  * Report current media status.
    326  */
    327 static void
    328 axen_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
    329 {
    330 	struct axen_softc *sc = ifp->if_softc;
    331 	struct mii_data *mii = GET_MII(sc);
    332 
    333 	mii_pollstat(mii);
    334 	ifmr->ifm_active = mii->mii_media_active;
    335 	ifmr->ifm_status = mii->mii_media_status;
    336 }
    337 
    338 static void
    339 axen_iff(struct axen_softc *sc)
    340 {
    341 	struct ifnet *ifp = GET_IFP(sc);
    342 	struct ethercom *ec = &sc->axen_ec;
    343 	struct ether_multi *enm;
    344 	struct ether_multistep step;
    345 	uint32_t h = 0;
    346 	uint16_t rxmode;
    347 	uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    348 	uint16_t wval;
    349 
    350 	if (sc->axen_dying)
    351 		return;
    352 
    353 	rxmode = 0;
    354 
    355 	/* Enable receiver, set RX mode */
    356 	axen_lock_mii(sc);
    357 	axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
    358 	rxmode = le16toh(wval);
    359 	rxmode &= ~(AXEN_RXCTL_ACPT_ALL_MCAST | AXEN_RXCTL_PROMISC |
    360 	    AXEN_RXCTL_ACPT_MCAST);
    361 	ifp->if_flags &= ~IFF_ALLMULTI;
    362 
    363 	if (ifp->if_flags & IFF_PROMISC) {
    364 		DPRINTF(("%s: promisc\n", device_xname(sc->axen_dev)));
    365 		rxmode |= AXEN_RXCTL_PROMISC;
    366 allmulti:	ifp->if_flags |= IFF_ALLMULTI;
    367 		rxmode |= AXEN_RXCTL_ACPT_ALL_MCAST
    368 		/* | AXEN_RXCTL_ACPT_PHY_MCAST */;
    369 	} else {
    370 		/* now program new ones */
    371 		DPRINTF(("%s: initializing hash table\n",
    372 		    device_xname(sc->axen_dev)));
    373 		ETHER_FIRST_MULTI(step, ec, enm);
    374 		while (enm != NULL) {
    375 			if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
    376 			    ETHER_ADDR_LEN)) {
    377 				DPRINTF(("%s: allmulti\n",
    378 				    device_xname(sc->axen_dev)));
    379 				memset(hashtbl, 0, sizeof(hashtbl));
    380 				goto allmulti;
    381 			}
    382 			h = ether_crc32_be(enm->enm_addrlo,
    383 			    ETHER_ADDR_LEN) >> 26;
    384 			hashtbl[h / 8] |= 1 << (h % 8);
    385 			DPRINTF(("%s: %s added\n",
    386 			    device_xname(sc->axen_dev),
    387 			    ether_sprintf(enm->enm_addrlo)));
    388 			ETHER_NEXT_MULTI(step, enm);
    389 		}
    390 		rxmode |= AXEN_RXCTL_ACPT_MCAST;
    391 	}
    392 
    393 	axen_cmd(sc, AXEN_CMD_MAC_WRITE_FILTER, 8, AXEN_FILTER_MULTI, hashtbl);
    394 	wval = htole16(rxmode);
    395 	axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
    396 	axen_unlock_mii(sc);
    397 }
    398 
    399 static void
    400 axen_reset(struct axen_softc *sc)
    401 {
    402 
    403 	if (sc->axen_dying)
    404 		return;
    405 	/* XXX What to reset? */
    406 
    407 	/* Wait a little while for the chip to get its brains in order. */
    408 	DELAY(1000);
    409 }
    410 
    411 #if 0 /* not used */
    412 #define AXEN_GPIO_WRITE(x, y) do {				\
    413 	axen_cmd(sc, AXEN_CMD_WRITE_GPIO, 0, (x), NULL);	\
    414 	usbd_delay_ms(sc->axen_udev, (y));			\
    415 } while (/*CONSTCOND*/0)
    416 
    417 static int
    418 axen_ax88179_eeprom(struct axen_softc *sc, void *addr)
    419 {
    420 	int i, retry;
    421 	uint8_t eeprom[20];
    422 	uint16_t csum;
    423 	uint16_t buf;
    424 
    425 	for (i = 0; i < 6; i++) {
    426 		/* set eeprom address */
    427 		buf = htole16(i);
    428 		axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_ADDR, &buf);
    429 
    430 		/* set eeprom command */
    431 		buf = htole16(AXEN_EEPROM_READ);
    432 		axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_CMD, &buf);
    433 
    434 		/* check the value is ready */
    435 		retry = 3;
    436 		do {
    437 			buf = htole16(AXEN_EEPROM_READ);
    438 			usbd_delay_ms(sc->axen_udev, 10);
    439 			axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MAC_EEPROM_CMD,
    440 			    &buf);
    441 			retry--;
    442 			if (retry < 0)
    443 				return EINVAL;
    444 		} while ((le16toh(buf) & 0xff) & AXEN_EEPROM_BUSY);
    445 
    446 		/* read data */
    447 		axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_EEPROM_READ,
    448 		    &eeprom[i * 2]);
    449 
    450 		/* sanity check */
    451 		if ((i == 0) && (eeprom[0] == 0xff))
    452 			return EINVAL;
    453 	}
    454 
    455 	/* check checksum */
    456 	csum = eeprom[6] + eeprom[7] + eeprom[8] + eeprom[9];
    457 	csum = (csum >> 8) + (csum & 0xff) + eeprom[10];
    458 	if (csum != 0xff) {
    459 		printf("eeprom checksum mismatchi(0x%02x)\n", csum);
    460 		return EINVAL;
    461 	}
    462 
    463 	memcpy(addr, eeprom, ETHER_ADDR_LEN);
    464 	return 0;
    465 }
    466 #endif
    467 
    468 static void
    469 axen_ax88179_init(struct axen_softc *sc)
    470 {
    471 	struct axen_qctrl qctrl;
    472 	uint16_t ctl, temp;
    473 	uint16_t wval;
    474 	uint8_t val;
    475 
    476 	axen_lock_mii(sc);
    477 
    478 	/* XXX: ? */
    479 	axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_UNK_05, &val);
    480 	DPRINTFN(5, ("AXEN_CMD_MAC_READ(0x05): 0x%02x\n", val));
    481 
    482 	/* check AX88179 version, UA1 / UA2 */
    483 	axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_GENERAL_STATUS, &val);
    484 	/* UA1 */
    485 	if (!(val & AXEN_GENERAL_STATUS_MASK)) {
    486 		sc->axen_rev = AXEN_REV_UA1;
    487 		DPRINTF(("AX88179 ver. UA1\n"));
    488 	} else {
    489 		sc->axen_rev = AXEN_REV_UA2;
    490 		DPRINTF(("AX88179 ver. UA2\n"));
    491 	}
    492 
    493 	/* power up ethernet PHY */
    494 	wval = htole16(0);
    495 	axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
    496 
    497 	wval = htole16(AXEN_PHYPWR_RSTCTL_IPRL);
    498 	axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
    499 	usbd_delay_ms(sc->axen_udev, 200);
    500 
    501 	/* set clock mode */
    502 	val = AXEN_PHYCLK_ACS | AXEN_PHYCLK_BCS;
    503 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
    504 	usbd_delay_ms(sc->axen_udev, 100);
    505 
    506 	/* set monitor mode (disable) */
    507 	val = AXEN_MONITOR_NONE;
    508 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val);
    509 
    510 	/* enable auto detach */
    511 	axen_cmd(sc, AXEN_CMD_EEPROM_READ, 2, AXEN_EEPROM_STAT, &wval);
    512 	temp = le16toh(wval);
    513 	DPRINTFN(2,("EEPROM0x43 = 0x%04x\n", temp));
    514 	if (!(temp == 0xffff) && !(temp & 0x0100)) {
    515 		/* Enable auto detach bit */
    516 		val = 0;
    517 		axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
    518 		val = AXEN_PHYCLK_ULR;
    519 		axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
    520 		usbd_delay_ms(sc->axen_udev, 100);
    521 
    522 		axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_PHYPWR_RSTCTL, &wval);
    523 		ctl = le16toh(wval);
    524 		ctl |= AXEN_PHYPWR_RSTCTL_AUTODETACH;
    525 		wval = htole16(ctl);
    526 		axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
    527 		usbd_delay_ms(sc->axen_udev, 200);
    528 		aprint_error_dev(sc->axen_dev, "enable auto detach (0x%04x)\n",
    529 		    ctl);
    530 	}
    531 
    532 	/* bulkin queue setting */
    533 	axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_USB_UPLINK, &val);
    534 	switch (val) {
    535 	case AXEN_USB_FS:
    536 		DPRINTF(("uplink: USB1.1\n"));
    537 		qctrl.ctrl	 = 0x07;
    538 		qctrl.timer_low	 = 0xcc;
    539 		qctrl.timer_high = 0x4c;
    540 		qctrl.bufsize	 = AXEN_BUFSZ_LS - 1;
    541 		qctrl.ifg	 = 0x08;
    542 		break;
    543 	case AXEN_USB_HS:
    544 		DPRINTF(("uplink: USB2.0\n"));
    545 		qctrl.ctrl	 = 0x07;
    546 		qctrl.timer_low	 = 0x02;
    547 		qctrl.timer_high = 0xa0;
    548 		qctrl.bufsize	 = AXEN_BUFSZ_HS - 1;
    549 		qctrl.ifg	 = 0xff;
    550 		break;
    551 	case AXEN_USB_SS:
    552 		DPRINTF(("uplink: USB3.0\n"));
    553 		qctrl.ctrl	 = 0x07;
    554 		qctrl.timer_low	 = 0x4f;
    555 		qctrl.timer_high = 0x00;
    556 		qctrl.bufsize	 = AXEN_BUFSZ_SS - 1;
    557 		qctrl.ifg	 = 0xff;
    558 		break;
    559 	default:
    560 		aprint_error_dev(sc->axen_dev, "unknown uplink bus:0x%02x\n",
    561 		    val);
    562 		axen_unlock_mii(sc);
    563 		return;
    564 	}
    565 	axen_cmd(sc, AXEN_CMD_MAC_SET_RXSR, 5, AXEN_RX_BULKIN_QCTRL, &qctrl);
    566 
    567 	/*
    568 	 * set buffer high/low watermark to pause/resume.
    569 	 * write 2byte will set high/log simultaneous with AXEN_PAUSE_HIGH.
    570 	 * XXX: what is the best value? OSX driver uses 0x3c-0x4c as LOW-HIGH
    571 	 * watermark parameters.
    572 	 */
    573 	val = 0x34;
    574 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_LOW_WATERMARK, &val);
    575 	val = 0x52;
    576 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_HIGH_WATERMARK, &val);
    577 
    578 	/* Set RX/TX configuration. */
    579 	/* Set RX control register */
    580 	ctl = AXEN_RXCTL_IPE | AXEN_RXCTL_DROPCRCERR | AXEN_RXCTL_AUTOB;
    581 	wval = htole16(ctl);
    582 	axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
    583 
    584 	/* set monitor mode (enable) */
    585 	val = AXEN_MONITOR_PMETYPE | AXEN_MONITOR_PMEPOL | AXEN_MONITOR_RWMP;
    586 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val);
    587 	axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MONITOR_MODE, &val);
    588 	DPRINTF(("axen: Monitor mode = 0x%02x\n", val));
    589 
    590 	/* set medium type */
    591 	ctl = AXEN_MEDIUM_GIGA | AXEN_MEDIUM_FDX | AXEN_MEDIUM_EN_125MHZ |
    592 	    AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN |
    593 	    AXEN_MEDIUM_RECV_EN;
    594 	wval = htole16(ctl);
    595 	DPRINTF(("axen: set to medium mode: 0x%04x\n", ctl));
    596 	axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval);
    597 	usbd_delay_ms(sc->axen_udev, 100);
    598 
    599 	axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MEDIUM_STATUS, &wval);
    600 	DPRINTF(("axen: current medium mode: 0x%04x\n", le16toh(wval)));
    601 
    602 	axen_unlock_mii(sc);
    603 
    604 #if 0 /* XXX: TBD.... */
    605 #define GMII_LED_ACTIVE		0x1a
    606 #define GMII_PHY_PAGE_SEL	0x1e
    607 #define GMII_PHY_PAGE_SEL	0x1f
    608 #define GMII_PAGE_EXT		0x0007
    609 	axen_miibus_writereg(&sc->axen_dev, sc->axen_phyno, GMII_PHY_PAGE_SEL,
    610 	    GMII_PAGE_EXT);
    611 	axen_miibus_writereg(&sc->axen_dev, sc->axen_phyno, GMII_PHY_PAGE,
    612 	    0x002c);
    613 #endif
    614 
    615 #if 1 /* XXX: phy hack ? */
    616 	axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x1F, 0x0005);
    617 	axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x0C, 0x0000);
    618 	axen_miibus_readreg(sc->axen_dev, sc->axen_phyno, 0x0001, &wval);
    619 	axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x01,
    620 	    wval | 0x0080);
    621 	axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x1F, 0x0000);
    622 #endif
    623 }
    624 
    625 static void
    626 axen_setcoe(struct axen_softc *sc)
    627 {
    628 	struct ifnet *ifp = GET_IFP(sc);
    629 	uint64_t enabled = ifp->if_capenable;
    630 	uint8_t val;
    631 
    632 	axen_lock_mii(sc);
    633 
    634 	val = AXEN_RXCOE_OFF;
    635 	if (enabled & IFCAP_CSUM_IPv4_Rx)
    636 		val |= AXEN_RXCOE_IPv4;
    637 	if (enabled & IFCAP_CSUM_TCPv4_Rx)
    638 		val |= AXEN_RXCOE_TCPv4;
    639 	if (enabled & IFCAP_CSUM_UDPv4_Rx)
    640 		val |= AXEN_RXCOE_UDPv4;
    641 	if (enabled & IFCAP_CSUM_TCPv6_Rx)
    642 		val |= AXEN_RXCOE_TCPv6;
    643 	if (enabled & IFCAP_CSUM_UDPv6_Rx)
    644 		val |= AXEN_RXCOE_UDPv6;
    645 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_RX_COE, &val);
    646 
    647 	val = AXEN_TXCOE_OFF;
    648 	if (enabled & IFCAP_CSUM_IPv4_Tx)
    649 		val |= AXEN_TXCOE_IPv4;
    650 	if (enabled & IFCAP_CSUM_TCPv4_Tx)
    651 		val |= AXEN_TXCOE_TCPv4;
    652 	if (enabled & IFCAP_CSUM_UDPv4_Tx)
    653 		val |= AXEN_TXCOE_UDPv4;
    654 	if (enabled & IFCAP_CSUM_TCPv6_Tx)
    655 		val |= AXEN_TXCOE_TCPv6;
    656 	if (enabled & IFCAP_CSUM_UDPv6_Tx)
    657 		val |= AXEN_TXCOE_UDPv6;
    658 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_TX_COE, &val);
    659 
    660 	axen_unlock_mii(sc);
    661 }
    662 
    663 static int
    664 axen_match(device_t parent, cfdata_t match, void *aux)
    665 {
    666 	struct usb_attach_arg *uaa = aux;
    667 
    668 	return axen_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
    669 		UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
    670 }
    671 
    672 static void
    673 axen_attach(device_t parent, device_t self, void *aux)
    674 {
    675 	struct axen_softc *sc = device_private(self);
    676 	struct usb_attach_arg *uaa = aux;
    677 	struct usbd_device *dev = uaa->uaa_device;
    678 	usbd_status err;
    679 	usb_interface_descriptor_t *id;
    680 	usb_endpoint_descriptor_t *ed;
    681 	struct mii_data	*mii;
    682 	uint8_t eaddr[ETHER_ADDR_LEN];
    683 	char *devinfop;
    684 	const char *devname = device_xname(self);
    685 	struct ifnet *ifp;
    686 	int i, s;
    687 
    688 	aprint_naive("\n");
    689 	aprint_normal("\n");
    690 
    691 	sc->axen_dev = self;
    692 	sc->axen_udev = dev;
    693 
    694 	devinfop = usbd_devinfo_alloc(dev, 0);
    695 	aprint_normal_dev(self, "%s\n", devinfop);
    696 	usbd_devinfo_free(devinfop);
    697 
    698 	err = usbd_set_config_no(dev, AXEN_CONFIG_NO, 1);
    699 	if (err) {
    700 		aprint_error_dev(self, "failed to set configuration"
    701 		    ", err=%s\n", usbd_errstr(err));
    702 		return;
    703 	}
    704 
    705 	sc->axen_flags = axen_lookup(uaa->uaa_vendor, uaa->uaa_product)->axen_flags;
    706 
    707 	rw_init(&sc->axen_mii_lock);
    708 	usb_init_task(&sc->axen_tick_task, axen_tick_task, sc, 0);
    709 
    710 	err = usbd_device2interface_handle(dev, AXEN_IFACE_IDX,&sc->axen_iface);
    711 	if (err) {
    712 		aprint_error_dev(self, "getting interface handle failed\n");
    713 		return;
    714 	}
    715 
    716 	sc->axen_product = uaa->uaa_product;
    717 	sc->axen_vendor = uaa->uaa_vendor;
    718 
    719 	id = usbd_get_interface_descriptor(sc->axen_iface);
    720 
    721 	/* decide on what our bufsize will be */
    722 	switch (sc->axen_udev->ud_speed) {
    723 	case USB_SPEED_SUPER:
    724 		sc->axen_rx_bufsz = AXEN_BUFSZ_SS * 1024;
    725 		break;
    726 	case USB_SPEED_HIGH:
    727 		sc->axen_rx_bufsz = AXEN_BUFSZ_HS * 1024;
    728 		break;
    729 	default:
    730 		sc->axen_rx_bufsz = AXEN_BUFSZ_LS * 1024;
    731 		break;
    732 	}
    733 
    734 	sc->axen_tx_bufsz = IP_MAXPACKET +
    735 	    ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN +
    736 	    sizeof(struct axen_sframe_hdr);
    737 
    738 	/* Find endpoints. */
    739 	for (i = 0; i < id->bNumEndpoints; i++) {
    740 		ed = usbd_interface2endpoint_descriptor(sc->axen_iface, i);
    741 		if (!ed) {
    742 			aprint_error_dev(self, "couldn't get ep %d\n", i);
    743 			return;
    744 		}
    745 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
    746 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
    747 			sc->axen_ed[AXEN_ENDPT_RX] = ed->bEndpointAddress;
    748 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
    749 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
    750 			sc->axen_ed[AXEN_ENDPT_TX] = ed->bEndpointAddress;
    751 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
    752 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
    753 			sc->axen_ed[AXEN_ENDPT_INTR] = ed->bEndpointAddress;
    754 		}
    755 	}
    756 
    757 	s = splnet();
    758 
    759 	sc->axen_phyno = AXEN_PHY_ID;
    760 	DPRINTF(("%s: phyno %d\n", device_xname(self), sc->axen_phyno));
    761 
    762 	/*
    763 	 * Get station address.
    764 	 */
    765 #if 0 /* read from eeprom */
    766 	if (axen_ax88179_eeprom(sc, &eaddr)) {
    767 		printf("EEPROM checksum error\n");
    768 		return;
    769 	}
    770 #else /* use MAC command */
    771 	axen_lock_mii(sc);
    772 	axen_cmd(sc, AXEN_CMD_MAC_READ_ETHER, 6, AXEN_CMD_MAC_NODE_ID, &eaddr);
    773 	axen_unlock_mii(sc);
    774 #endif
    775 	axen_ax88179_init(sc);
    776 
    777 	/*
    778 	 * An ASIX chip was detected. Inform the world.
    779 	 */
    780 	if (sc->axen_flags & AX178A)
    781 		aprint_normal_dev(self, "AX88178a\n");
    782 	else if (sc->axen_flags & AX179)
    783 		aprint_normal_dev(self, "AX88179\n");
    784 	aprint_normal_dev(self, "Ethernet address %s\n", ether_sprintf(eaddr));
    785 
    786 	/* Initialize interface info.*/
    787 
    788 	ifp = &sc->sc_if;
    789 	ifp->if_softc = sc;
    790 	strlcpy(ifp->if_xname, devname, IFNAMSIZ);
    791 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
    792 	ifp->if_ioctl = axen_ioctl;
    793 	ifp->if_start = axen_start;
    794 	ifp->if_init = axen_init;
    795 	ifp->if_stop = axen_stop;
    796 	ifp->if_watchdog = axen_watchdog;
    797 
    798 	IFQ_SET_READY(&ifp->if_snd);
    799 
    800 	sc->axen_ec.ec_capabilities = ETHERCAP_VLAN_MTU;
    801 
    802 	/* Adapter does not support TSOv6 (They call it LSOv2). */
    803 	ifp->if_capabilities |= IFCAP_TSOv4 |
    804 	    IFCAP_CSUM_IPv4_Rx  | IFCAP_CSUM_IPv4_Tx  |
    805 	    IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv4_Tx |
    806 	    IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv4_Tx |
    807 	    IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_TCPv6_Tx |
    808 	    IFCAP_CSUM_UDPv6_Rx | IFCAP_CSUM_UDPv6_Tx;
    809 
    810 	/* Initialize MII/media info. */
    811 	mii = &sc->axen_mii;
    812 	mii->mii_ifp = ifp;
    813 	mii->mii_readreg = axen_miibus_readreg;
    814 	mii->mii_writereg = axen_miibus_writereg;
    815 	mii->mii_statchg = axen_miibus_statchg;
    816 	mii->mii_flags = MIIF_AUTOTSLEEP;
    817 
    818 	sc->axen_ec.ec_mii = mii;
    819 	ifmedia_init(&mii->mii_media, 0, axen_ifmedia_upd, axen_ifmedia_sts);
    820 	mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
    821 
    822 	if (LIST_FIRST(&mii->mii_phys) == NULL) {
    823 		ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
    824 		ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
    825 	} else
    826 		ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
    827 
    828 	/* Attach the interface. */
    829 	if_attach(ifp);
    830 	ether_ifattach(ifp, eaddr);
    831 	rnd_attach_source(&sc->rnd_source, device_xname(sc->axen_dev),
    832 	    RND_TYPE_NET, RND_FLAG_DEFAULT);
    833 
    834 	callout_init(&sc->axen_stat_ch, 0);
    835 	callout_setfunc(&sc->axen_stat_ch, axen_tick, sc);
    836 
    837 	sc->axen_attached = true;
    838 	splx(s);
    839 
    840 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->axen_udev,sc->axen_dev);
    841 
    842 	if (!pmf_device_register(self, NULL, NULL))
    843 		aprint_error_dev(self, "couldn't establish power handler\n");
    844 }
    845 
    846 static int
    847 axen_detach(device_t self, int flags)
    848 {
    849 	struct axen_softc *sc = device_private(self);
    850 	struct ifnet *ifp = GET_IFP(sc);
    851 	int s;
    852 
    853 	DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
    854 
    855 	/* Detached before attached finished, so just bail out. */
    856 	if (!sc->axen_attached)
    857 		return 0;
    858 
    859 	pmf_device_deregister(self);
    860 
    861 	sc->axen_dying = true;
    862 
    863 	callout_halt(&sc->axen_stat_ch, NULL);
    864 	usb_rem_task_wait(sc->axen_udev, &sc->axen_tick_task,
    865 	    USB_TASKQ_DRIVER, NULL);
    866 
    867 	s = splusb();
    868 
    869 	if (ifp->if_flags & IFF_RUNNING)
    870 		axen_stop(ifp, 1);
    871 
    872 	callout_destroy(&sc->axen_stat_ch);
    873 	rnd_detach_source(&sc->rnd_source);
    874 	mii_detach(&sc->axen_mii, MII_PHY_ANY, MII_OFFSET_ANY);
    875 	ifmedia_delete_instance(&sc->axen_mii.mii_media, IFM_INST_ANY);
    876 	ether_ifdetach(ifp);
    877 	if_detach(ifp);
    878 
    879 #ifdef DIAGNOSTIC
    880 	if (sc->axen_ep[AXEN_ENDPT_TX] != NULL ||
    881 	    sc->axen_ep[AXEN_ENDPT_RX] != NULL ||
    882 	    sc->axen_ep[AXEN_ENDPT_INTR] != NULL)
    883 		aprint_debug_dev(self, "detach has active endpoints\n");
    884 #endif
    885 
    886 	sc->axen_attached = false;
    887 
    888 	if (--sc->axen_refcnt >= 0) {
    889 		/* Wait for processes to go away. */
    890 		usb_detach_waitold(sc->axen_dev);
    891 	}
    892 	splx(s);
    893 
    894 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->axen_udev,sc->axen_dev);
    895 
    896 	rw_destroy(&sc->axen_mii_lock);
    897 
    898 	return 0;
    899 }
    900 
    901 static int
    902 axen_activate(device_t self, devact_t act)
    903 {
    904 	struct axen_softc *sc = device_private(self);
    905 	struct ifnet *ifp = GET_IFP(sc);
    906 
    907 	DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
    908 
    909 	switch (act) {
    910 	case DVACT_DEACTIVATE:
    911 		if_deactivate(ifp);
    912 		sc->axen_dying = true;
    913 		return 0;
    914 	default:
    915 		return EOPNOTSUPP;
    916 	}
    917 }
    918 
    919 static struct mbuf *
    920 axen_newbuf(void)
    921 {
    922 	struct mbuf *m;
    923 
    924 	MGETHDR(m, M_DONTWAIT, MT_DATA);
    925 	if (m == NULL)
    926 		return NULL;
    927 
    928 	MCLGET(m, M_DONTWAIT);
    929 	if (!(m->m_flags & M_EXT)) {
    930 		m_freem(m);
    931 		return NULL;
    932 	}
    933 
    934 	m->m_len = m->m_pkthdr.len = MCLBYTES;
    935 	m_adj(m, ETHER_ALIGN);
    936 
    937 	return m;
    938 }
    939 
    940 static int
    941 axen_rx_list_init(struct axen_softc *sc)
    942 {
    943 	struct axen_cdata *cd;
    944 	struct axen_chain *c;
    945 	int i;
    946 
    947 	DPRINTF(("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
    948 
    949 	cd = &sc->axen_cdata;
    950 	for (i = 0; i < AXEN_RX_LIST_CNT; i++) {
    951 		c = &cd->axen_rx_chain[i];
    952 		c->axen_sc = sc;
    953 		if (c->axen_xfer == NULL) {
    954 			int err = usbd_create_xfer(sc->axen_ep[AXEN_ENDPT_RX],
    955 			    sc->axen_rx_bufsz, 0, 0, &c->axen_xfer);
    956 			if (err)
    957 				return err;
    958 			c->axen_buf = usbd_get_buffer(c->axen_xfer);
    959 		}
    960 	}
    961 
    962 	return 0;
    963 }
    964 
    965 static int
    966 axen_tx_list_init(struct axen_softc *sc)
    967 {
    968 	struct axen_cdata *cd;
    969 	struct axen_chain *c;
    970 	int i;
    971 
    972 	DPRINTF(("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
    973 
    974 	cd = &sc->axen_cdata;
    975 	for (i = 0; i < AXEN_TX_LIST_CNT; i++) {
    976 		c = &cd->axen_tx_chain[i];
    977 		c->axen_sc = sc;
    978 		if (c->axen_xfer == NULL) {
    979 			int err = usbd_create_xfer(sc->axen_ep[AXEN_ENDPT_TX],
    980 			    sc->axen_tx_bufsz, USBD_FORCE_SHORT_XFER, 0,
    981 			    &c->axen_xfer);
    982 			if (err)
    983 				return err;
    984 			c->axen_buf = usbd_get_buffer(c->axen_xfer);
    985 		}
    986 	}
    987 
    988 	cd->axen_tx_prod = cd->axen_tx_cnt = 0;
    989 
    990 	return 0;
    991 }
    992 
    993 /*
    994  * A frame has been uploaded: pass the resulting mbuf chain up to
    995  * the higher level protocols.
    996  */
    997 static void
    998 axen_rxeof(struct usbd_xfer *xfer, void * priv, usbd_status status)
    999 {
   1000 	struct axen_chain *c = (struct axen_chain *)priv;
   1001 	struct axen_softc *sc = c->axen_sc;
   1002 	struct ifnet *ifp = GET_IFP(sc);
   1003 	uint8_t *buf = c->axen_buf;
   1004 	struct mbuf *m;
   1005 	uint32_t total_len;
   1006 	uint32_t rx_hdr, pkt_hdr;
   1007 	uint32_t *hdr_p;
   1008 	uint16_t hdr_offset, pkt_count;
   1009 	size_t pkt_len;
   1010 	size_t temp;
   1011 	int s;
   1012 
   1013 	DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
   1014 
   1015 	if (sc->axen_dying)
   1016 		return;
   1017 
   1018 	if (!(ifp->if_flags & IFF_RUNNING))
   1019 		return;
   1020 
   1021 	if (status != USBD_NORMAL_COMPLETION) {
   1022 		if (status == USBD_INVAL)
   1023 			return;	/* XXX plugged out or down */
   1024 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
   1025 			return;
   1026 		if (usbd_ratecheck(&sc->axen_rx_notice))
   1027 			aprint_error_dev(sc->axen_dev, "usb errors on rx: %s\n",
   1028 			    usbd_errstr(status));
   1029 		if (status == USBD_STALLED)
   1030 			usbd_clear_endpoint_stall_async(sc->axen_ep[AXEN_ENDPT_RX]);
   1031 		goto done;
   1032 	}
   1033 
   1034 	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
   1035 
   1036 	if (total_len < sizeof(pkt_hdr)) {
   1037 		aprint_error_dev(sc->axen_dev, "rxeof: too short transfer\n");
   1038 		ifp->if_ierrors++;
   1039 		goto done;
   1040 	}
   1041 
   1042 	/*
   1043 	 * buffer map
   1044 	 * [packet #0]...[packet #n][pkt hdr#0]..[pkt hdr#n][recv_hdr]
   1045 	 * each packet has 0xeeee as psuedo header..
   1046 	 */
   1047 	hdr_p = (uint32_t *)(buf + total_len - sizeof(uint32_t));
   1048 	rx_hdr = le32toh(*hdr_p);
   1049 	hdr_offset = (uint16_t)(rx_hdr >> 16);
   1050 	pkt_count  = (uint16_t)(rx_hdr & 0xffff);
   1051 
   1052 	if (total_len > sc->axen_rx_bufsz) {
   1053 		aprint_error_dev(sc->axen_dev, "rxeof: too large transfer\n");
   1054 		goto done;
   1055 	}
   1056 
   1057 	/* sanity check */
   1058 	if (hdr_offset > total_len) {
   1059 		aprint_error_dev(sc->axen_dev, "rxeof: invalid hdr offset\n");
   1060 		ifp->if_ierrors++;
   1061 		usbd_delay_ms(sc->axen_udev, 100);
   1062 		goto done;
   1063 	}
   1064 
   1065 	/* point first packet header */
   1066 	hdr_p = (uint32_t *)(buf + hdr_offset);
   1067 
   1068 	/*
   1069 	 * ax88179 will pack multiple ip packet to a USB transaction.
   1070 	 * process all of packets in the buffer
   1071 	 */
   1072 
   1073 #if 1 /* XXX: paranoiac check. need to remove later */
   1074 #define AXEN_MAX_PACKED_PACKET 200
   1075 	if (pkt_count > AXEN_MAX_PACKED_PACKET) {
   1076 		DPRINTF(("%s: Too many packets (%d) in a transaction, discard.\n",
   1077 		    device_xname(sc->axen_dev), pkt_count));
   1078 		goto done;
   1079 	}
   1080 #endif
   1081 
   1082 	do {
   1083 		if ((buf[0] != 0xee) || (buf[1] != 0xee)) {
   1084 			aprint_error_dev(sc->axen_dev,
   1085 			    "invalid buffer(pkt#%d), continue\n", pkt_count);
   1086 	    		ifp->if_ierrors += pkt_count;
   1087 			goto done;
   1088 		}
   1089 
   1090 		pkt_hdr = le32toh(*hdr_p);
   1091 		pkt_len = (pkt_hdr >> 16) & 0x1fff;
   1092 		DPRINTFN(10,
   1093 		    ("%s: rxeof: packet#%d, pkt_hdr 0x%08x, pkt_len %zu\n",
   1094 		   device_xname(sc->axen_dev), pkt_count, pkt_hdr, pkt_len));
   1095 
   1096 		if (pkt_hdr & (AXEN_RXHDR_CRC_ERR | AXEN_RXHDR_DROP_ERR)) {
   1097 	    		ifp->if_ierrors++;
   1098 			/* move to next pkt header */
   1099 			DPRINTF(("%s: %s err (pkt#%d)\n",
   1100 			    device_xname(sc->axen_dev),
   1101 			    (pkt_hdr & AXEN_RXHDR_CRC_ERR) ? "crc" : "drop",
   1102 			    pkt_count));
   1103 			goto nextpkt;
   1104 		}
   1105 
   1106 		/* process each packet */
   1107 		/* allocate mbuf */
   1108 		m = axen_newbuf();
   1109 		if (m == NULL) {
   1110 			ifp->if_ierrors++;
   1111 			goto nextpkt;
   1112 		}
   1113 
   1114 		/* skip pseudo header (2byte) */
   1115 		m_set_rcvif(m, ifp);
   1116 		m->m_pkthdr.len = m->m_len = pkt_len - 6;
   1117 
   1118 		m->m_pkthdr.csum_flags = axen_csum_flags_rx(ifp, pkt_hdr);
   1119 		memcpy(mtod(m, char *), buf + 2, pkt_len - 6);
   1120 
   1121 		/* push the packet up */
   1122 		s = splnet();
   1123 		if_percpuq_enqueue((ifp)->if_percpuq, (m));
   1124 		splx(s);
   1125 
   1126 nextpkt:
   1127 		/*
   1128 		 * prepare next packet
   1129 		 * as each packet will be aligned 8byte boundary,
   1130 		 * need to fix up the start point of the buffer.
   1131 		 */
   1132 		temp = ((pkt_len + 7) & 0xfff8);
   1133 		buf = buf + temp;
   1134 		hdr_p++;
   1135 		pkt_count--;
   1136 	} while(pkt_count > 0);
   1137 
   1138 done:
   1139 	/* Setup new transfer. */
   1140 	usbd_setup_xfer(xfer, c, c->axen_buf, sc->axen_rx_bufsz,
   1141 	    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, axen_rxeof);
   1142 	usbd_transfer(xfer);
   1143 
   1144 	DPRINTFN(10,("%s: %s: start rx\n",device_xname(sc->axen_dev),__func__));
   1145 }
   1146 
   1147 static int
   1148 axen_csum_flags_rx(struct ifnet *ifp, uint32_t pkt_hdr)
   1149 {
   1150 	int enabled_flags = ifp->if_csum_flags_rx;
   1151 	int csum_flags = 0;
   1152 	int l3_type, l4_type;
   1153 
   1154 	if (enabled_flags == 0)
   1155 		return 0;
   1156 
   1157 	l3_type = (pkt_hdr & AXEN_RXHDR_L3_TYPE_MASK) >>
   1158 	    AXEN_RXHDR_L3_TYPE_OFFSET;
   1159 
   1160 	if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4)
   1161 		csum_flags |= M_CSUM_IPv4;
   1162 
   1163 	l4_type = (pkt_hdr & AXEN_RXHDR_L4_TYPE_MASK) >>
   1164 	    AXEN_RXHDR_L4_TYPE_OFFSET;
   1165 
   1166 	switch (l4_type) {
   1167 	case AXEN_RXHDR_L4_TYPE_TCP:
   1168 		if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4)
   1169 			csum_flags |= M_CSUM_TCPv4;
   1170 		else
   1171 			csum_flags |= M_CSUM_TCPv6;
   1172 		break;
   1173 	case AXEN_RXHDR_L4_TYPE_UDP:
   1174 		if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4)
   1175 			csum_flags |= M_CSUM_UDPv4;
   1176 		else
   1177 			csum_flags |= M_CSUM_UDPv6;
   1178 		break;
   1179 	default:
   1180 		break;
   1181 	}
   1182 
   1183 	csum_flags &= enabled_flags;
   1184 	if ((csum_flags & M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L3CSUM_ERR))
   1185 		csum_flags |= M_CSUM_IPv4_BAD;
   1186 	if ((csum_flags & ~M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L4CSUM_ERR))
   1187 		csum_flags |= M_CSUM_TCP_UDP_BAD;
   1188 
   1189 	return csum_flags;
   1190 }
   1191 
   1192 /*
   1193  * A frame was downloaded to the chip. It's safe for us to clean up
   1194  * the list buffers.
   1195  */
   1196 static void
   1197 axen_txeof(struct usbd_xfer *xfer, void * priv, usbd_status status)
   1198 {
   1199 	struct axen_chain *c = (struct axen_chain *)priv;
   1200 	struct axen_softc *sc = c->axen_sc;
   1201 	struct axen_cdata *cd = &sc->axen_cdata;
   1202 	struct ifnet *ifp = GET_IFP(sc);
   1203 	int s;
   1204 
   1205 	if (sc->axen_dying)
   1206 		return;
   1207 
   1208 	s = splnet();
   1209 	KASSERT(cd->axen_tx_cnt > 0);
   1210 	cd->axen_tx_cnt--;
   1211 	if (status != USBD_NORMAL_COMPLETION) {
   1212 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
   1213 			splx(s);
   1214 			return;
   1215 		}
   1216 		ifp->if_oerrors++;
   1217 		if (usbd_ratecheck(&sc->axen_tx_notice))
   1218 			aprint_error_dev(sc->axen_dev, "usb error on tx: %s\n",
   1219 			    usbd_errstr(status));
   1220 		if (status == USBD_STALLED)
   1221 			usbd_clear_endpoint_stall_async(sc->axen_ep[AXEN_ENDPT_TX]);
   1222 		splx(s);
   1223 		return;
   1224 	}
   1225 
   1226 	ifp->if_timer = 0;
   1227 	ifp->if_flags &= ~IFF_OACTIVE;
   1228 
   1229 	if (!IFQ_IS_EMPTY(&ifp->if_snd))
   1230 		axen_start(ifp);
   1231 
   1232 	ifp->if_opackets++;
   1233 	splx(s);
   1234 }
   1235 
   1236 static void
   1237 axen_tick(void *xsc)
   1238 {
   1239 	struct axen_softc *sc = xsc;
   1240 
   1241 	if (sc == NULL)
   1242 		return;
   1243 
   1244 	DPRINTFN(0xff,("%s: %s: enter\n", device_xname(sc->axen_dev),__func__));
   1245 
   1246 	if (sc->axen_dying)
   1247 		return;
   1248 
   1249 	/* Perform periodic stuff in process context */
   1250 	usb_add_task(sc->axen_udev, &sc->axen_tick_task, USB_TASKQ_DRIVER);
   1251 }
   1252 
   1253 static void
   1254 axen_tick_task(void *xsc)
   1255 {
   1256 	int s;
   1257 	struct axen_softc *sc;
   1258 	struct ifnet *ifp;
   1259 	struct mii_data *mii;
   1260 
   1261 	sc = xsc;
   1262 
   1263 	if (sc == NULL)
   1264 		return;
   1265 
   1266 	if (sc->axen_dying)
   1267 		return;
   1268 
   1269 	ifp = GET_IFP(sc);
   1270 	mii = GET_MII(sc);
   1271 	if (mii == NULL)
   1272 		return;
   1273 
   1274 	s = splnet();
   1275 
   1276 	mii_tick(mii);
   1277 	if (sc->axen_link == 0)
   1278 		axen_miibus_statchg(ifp);
   1279 
   1280 	callout_schedule(&sc->axen_stat_ch, hz);
   1281 
   1282 	splx(s);
   1283 }
   1284 
   1285 static int
   1286 axen_encap(struct axen_softc *sc, struct mbuf *m, int idx)
   1287 {
   1288 	struct ifnet *ifp = GET_IFP(sc);
   1289 	struct axen_chain *c;
   1290 	usbd_status err;
   1291 	struct axen_sframe_hdr hdr;
   1292 	u_int length, boundary;
   1293 
   1294 	c = &sc->axen_cdata.axen_tx_chain[idx];
   1295 
   1296 	/* XXX Is this need? */
   1297 	switch (sc->axen_udev->ud_speed) {
   1298 	case USB_SPEED_SUPER:
   1299 		boundary = 4096;
   1300 		break;
   1301 	case USB_SPEED_HIGH:
   1302 		boundary = 512;
   1303 		break;
   1304 	default:
   1305 		boundary = 64;
   1306 		break;
   1307 	}
   1308 
   1309 	length = m->m_pkthdr.len + sizeof(hdr);
   1310 	KASSERT(length <= sc->axen_tx_bufsz);
   1311 
   1312 	hdr.plen = htole32(m->m_pkthdr.len);
   1313 
   1314 	hdr.gso = (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) ?
   1315 	    m->m_pkthdr.segsz : 0;
   1316 	if ((length % boundary) == 0) {
   1317 		DPRINTF(("%s: boundary hit\n", device_xname(sc->axen_dev)));
   1318 		hdr.gso |= 0x80008000;	/* XXX enable padding */
   1319 	}
   1320 	hdr.gso = htole32(hdr.gso);
   1321 
   1322 	memcpy(c->axen_buf, &hdr, sizeof(hdr));
   1323 	m_copydata(m, 0, m->m_pkthdr.len, c->axen_buf + sizeof(hdr));
   1324 
   1325 	if (__predict_false(c->axen_xfer == NULL))
   1326 		return EIO;	/* XXX plugged out or down */
   1327 
   1328 	usbd_setup_xfer(c->axen_xfer, c, c->axen_buf, length,
   1329 	    USBD_FORCE_SHORT_XFER, 10000, axen_txeof);
   1330 
   1331 	/* Transmit */
   1332 	err = usbd_transfer(c->axen_xfer);
   1333 	if (err != USBD_IN_PROGRESS) {
   1334 		axen_stop(ifp, 0);
   1335 		return EIO;
   1336 	}
   1337 
   1338 	return 0;
   1339 }
   1340 
   1341 static void
   1342 axen_start(struct ifnet *ifp)
   1343 {
   1344 	struct axen_softc *sc = ifp->if_softc;
   1345 	struct mbuf *m;
   1346 	struct axen_cdata *cd = &sc->axen_cdata;
   1347 	int idx;
   1348 
   1349 	if (sc->axen_link == 0)
   1350 		return;
   1351 
   1352 	if ((ifp->if_flags & (IFF_OACTIVE | IFF_RUNNING)) != IFF_RUNNING)
   1353 		return;
   1354 
   1355 	idx = cd->axen_tx_prod;
   1356 	while (cd->axen_tx_cnt < AXEN_TX_LIST_CNT) {
   1357 		IFQ_POLL(&ifp->if_snd, m);
   1358 		if (m == NULL)
   1359 			break;
   1360 
   1361 		if (axen_encap(sc, m, idx)) {
   1362 			ifp->if_flags |= IFF_OACTIVE; /* XXX */
   1363 			ifp->if_oerrors++;
   1364 			break;
   1365 		}
   1366 		IFQ_DEQUEUE(&ifp->if_snd, m);
   1367 
   1368 		/*
   1369 		 * If there's a BPF listener, bounce a copy of this frame
   1370 		 * to him.
   1371 		 */
   1372 		bpf_mtap(ifp, m, BPF_D_OUT);
   1373 		m_freem(m);
   1374 
   1375 		idx = (idx + 1) % AXEN_TX_LIST_CNT;
   1376 		cd->axen_tx_cnt++;
   1377 	}
   1378 	cd->axen_tx_prod = idx;
   1379 
   1380 	if (cd->axen_tx_cnt >= AXEN_TX_LIST_CNT)
   1381 		ifp->if_flags |= IFF_OACTIVE;
   1382 
   1383 	/*
   1384 	 * Set a timeout in case the chip goes out to lunch.
   1385 	 */
   1386 	ifp->if_timer = 5;
   1387 }
   1388 
   1389 static int
   1390 axen_init(struct ifnet *ifp)
   1391 {
   1392 	struct axen_softc *sc = ifp->if_softc;
   1393 	struct axen_chain *c;
   1394 	usbd_status err;
   1395 	int i, s;
   1396 	uint16_t rxmode;
   1397 	uint16_t wval;
   1398 	uint8_t bval;
   1399 
   1400 	s = splnet();
   1401 
   1402 	if (ifp->if_flags & IFF_RUNNING)
   1403 		axen_stop(ifp, 0);
   1404 
   1405 	/*
   1406 	 * Cancel pending I/O and free all RX/TX buffers.
   1407 	 */
   1408 	axen_reset(sc);
   1409 
   1410 	/* XXX: ? */
   1411 	axen_lock_mii(sc);
   1412 	bval = 0x01;
   1413 	axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_UNK_28, &bval);
   1414 	axen_unlock_mii(sc);
   1415 
   1416 	/* Configure offloading engine. */
   1417 	axen_setcoe(sc);
   1418 
   1419 	/* Program promiscuous mode and multicast filters. */
   1420 	axen_iff(sc);
   1421 
   1422 	/* Enable receiver, set RX mode */
   1423 	axen_lock_mii(sc);
   1424 	axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
   1425 	rxmode = le16toh(wval);
   1426 	rxmode |= AXEN_RXCTL_START;
   1427 	wval = htole16(rxmode);
   1428 	axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
   1429 	axen_unlock_mii(sc);
   1430 
   1431 	/* Open RX and TX pipes. */
   1432 	err = usbd_open_pipe(sc->axen_iface, sc->axen_ed[AXEN_ENDPT_RX],
   1433 	    USBD_EXCLUSIVE_USE, &sc->axen_ep[AXEN_ENDPT_RX]);
   1434 	if (err) {
   1435 		aprint_error_dev(sc->axen_dev, "open rx pipe failed: %s\n",
   1436 		    usbd_errstr(err));
   1437 		splx(s);
   1438 		return EIO;
   1439 	}
   1440 
   1441 	err = usbd_open_pipe(sc->axen_iface, sc->axen_ed[AXEN_ENDPT_TX],
   1442 	    USBD_EXCLUSIVE_USE, &sc->axen_ep[AXEN_ENDPT_TX]);
   1443 	if (err) {
   1444 		aprint_error_dev(sc->axen_dev, "open tx pipe failed: %s\n",
   1445 		    usbd_errstr(err));
   1446 		splx(s);
   1447 		return EIO;
   1448 	}
   1449 
   1450 	/* Init RX ring. */
   1451 	if (axen_rx_list_init(sc)) {
   1452 		aprint_error_dev(sc->axen_dev, "rx list init failed\n");
   1453 		splx(s);
   1454 		return ENOBUFS;
   1455 	}
   1456 
   1457 	/* Init TX ring. */
   1458 	if (axen_tx_list_init(sc)) {
   1459 		aprint_error_dev(sc->axen_dev, "tx list init failed\n");
   1460 		splx(s);
   1461 		return ENOBUFS;
   1462 	}
   1463 
   1464 	/* Start up the receive pipe. */
   1465 	for (i = 0; i < AXEN_RX_LIST_CNT; i++) {
   1466 		c = &sc->axen_cdata.axen_rx_chain[i];
   1467 
   1468 		usbd_setup_xfer(c->axen_xfer, c, c->axen_buf, sc->axen_rx_bufsz,
   1469 		    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, axen_rxeof);
   1470 		usbd_transfer(c->axen_xfer);
   1471 	}
   1472 
   1473 	ifp->if_flags |= IFF_RUNNING;
   1474 	ifp->if_flags &= ~IFF_OACTIVE;
   1475 
   1476 	splx(s);
   1477 
   1478 	callout_schedule(&sc->axen_stat_ch, hz);
   1479 	return 0;
   1480 }
   1481 
   1482 static int
   1483 axen_ioctl(struct ifnet *ifp, u_long cmd, void *data)
   1484 {
   1485 	struct axen_softc *sc = ifp->if_softc;
   1486 	int s;
   1487 	int error = 0;
   1488 
   1489 	s = splnet();
   1490 
   1491 	switch (cmd) {
   1492 	case SIOCSIFFLAGS:
   1493 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
   1494 			break;
   1495 
   1496 		switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
   1497 		case IFF_RUNNING:
   1498 			axen_stop(ifp, 1);
   1499 			break;
   1500 		case IFF_UP:
   1501 			axen_init(ifp);
   1502 			break;
   1503 		case IFF_UP | IFF_RUNNING:
   1504 			if ((ifp->if_flags ^ sc->axen_if_flags) == IFF_PROMISC)
   1505 				axen_iff(sc);
   1506 			else
   1507 				axen_init(ifp);
   1508 			break;
   1509 		}
   1510 		sc->axen_if_flags = ifp->if_flags;
   1511 		break;
   1512 
   1513 	default:
   1514 		if ((error = ether_ioctl(ifp, cmd, data)) != ENETRESET)
   1515 			break;
   1516 
   1517 		error = 0;
   1518 		switch (cmd) {
   1519 		case SIOCADDMULTI:
   1520 		case SIOCDELMULTI:
   1521 			axen_iff(sc);
   1522 			break;
   1523 		case SIOCSIFCAP:
   1524 			axen_setcoe(sc);
   1525 			break;
   1526 		default:
   1527 			break;
   1528 		}
   1529 		break;
   1530 	}
   1531 	splx(s);
   1532 
   1533 	return error;
   1534 }
   1535 
   1536 static void
   1537 axen_watchdog(struct ifnet *ifp)
   1538 {
   1539 	struct axen_softc *sc;
   1540 	struct axen_chain *c;
   1541 	usbd_status stat;
   1542 	int s;
   1543 
   1544 	sc = ifp->if_softc;
   1545 
   1546 	ifp->if_oerrors++;
   1547 	aprint_error_dev(sc->axen_dev, "watchdog timeout\n");
   1548 
   1549 	s = splusb();
   1550 	c = &sc->axen_cdata.axen_tx_chain[0];
   1551 	usbd_get_xfer_status(c->axen_xfer, NULL, NULL, NULL, &stat);
   1552 	axen_txeof(c->axen_xfer, c, stat);
   1553 
   1554 	if (!IFQ_IS_EMPTY(&ifp->if_snd))
   1555 		axen_start(ifp);
   1556 	splx(s);
   1557 }
   1558 
   1559 /*
   1560  * Stop the adapter and free any mbufs allocated to the
   1561  * RX and TX lists.
   1562  */
   1563 static void
   1564 axen_stop(struct ifnet *ifp, int disable)
   1565 {
   1566 	struct axen_softc *sc = ifp->if_softc;
   1567 	struct axen_chain *c;
   1568 	usbd_status err;
   1569 	int i;
   1570 	uint16_t rxmode, wval;
   1571 
   1572 	axen_reset(sc);
   1573 
   1574 	/* Disable receiver, set RX mode */
   1575 	axen_lock_mii(sc);
   1576 	axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
   1577 	rxmode = le16toh(wval);
   1578 	rxmode &= ~AXEN_RXCTL_START;
   1579 	wval = htole16(rxmode);
   1580 	axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
   1581 	axen_unlock_mii(sc);
   1582 
   1583 	ifp->if_timer = 0;
   1584 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
   1585 
   1586 	callout_stop(&sc->axen_stat_ch);
   1587 	sc->axen_link = 0;
   1588 
   1589 	/* Stop transfers. */
   1590 	if (sc->axen_ep[AXEN_ENDPT_RX] != NULL) {
   1591 		err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_RX]);
   1592 		if (err) {
   1593 			aprint_error_dev(sc->axen_dev,
   1594 			    "abort rx pipe failed: %s\n", usbd_errstr(err));
   1595 
   1596 		}
   1597 	}
   1598 
   1599 	if (sc->axen_ep[AXEN_ENDPT_TX] != NULL) {
   1600 		err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_TX]);
   1601 		if (err) {
   1602 			aprint_error_dev(sc->axen_dev,
   1603 			    "abort tx pipe failed: %s\n", usbd_errstr(err));
   1604 		}
   1605 	}
   1606 
   1607 	if (sc->axen_ep[AXEN_ENDPT_INTR] != NULL) {
   1608 		err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_INTR]);
   1609 		if (err) {
   1610 			aprint_error_dev(sc->axen_dev,
   1611 			    "abort intr pipe failed: %s\n", usbd_errstr(err));
   1612 		}
   1613 	}
   1614 
   1615 	/* Free RX resources. */
   1616 	for (i = 0; i < AXEN_RX_LIST_CNT; i++) {
   1617 		c = &sc->axen_cdata.axen_rx_chain[i];
   1618 		if (c->axen_xfer != NULL) {
   1619 			usbd_destroy_xfer(c->axen_xfer);
   1620 			c->axen_xfer = NULL;
   1621 		}
   1622 	}
   1623 
   1624 	/* Free TX resources. */
   1625 	for (i = 0; i < AXEN_TX_LIST_CNT; i++) {
   1626 		c = &sc->axen_cdata.axen_tx_chain[i];
   1627 		if (c->axen_xfer != NULL) {
   1628 			usbd_destroy_xfer(c->axen_xfer);
   1629 			c->axen_xfer = NULL;
   1630 		}
   1631 	}
   1632 
   1633 	/* Close pipes. */
   1634 	if (sc->axen_ep[AXEN_ENDPT_RX] != NULL) {
   1635 		err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_RX]);
   1636 		if (err) {
   1637 			aprint_error_dev(sc->axen_dev,
   1638 			    "close rx pipe failed: %s\n", usbd_errstr(err));
   1639 		}
   1640 		sc->axen_ep[AXEN_ENDPT_RX] = NULL;
   1641 	}
   1642 
   1643 	if (sc->axen_ep[AXEN_ENDPT_TX] != NULL) {
   1644 		err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_TX]);
   1645 		if (err) {
   1646 			aprint_error_dev(sc->axen_dev,
   1647 			    "close tx pipe failed: %s\n", usbd_errstr(err));
   1648 		}
   1649 		sc->axen_ep[AXEN_ENDPT_TX] = NULL;
   1650 	}
   1651 
   1652 	if (sc->axen_ep[AXEN_ENDPT_INTR] != NULL) {
   1653 		err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_INTR]);
   1654 		if (err) {
   1655 			aprint_error_dev(sc->axen_dev,
   1656 			    "close intr pipe failed: %s\n", usbd_errstr(err));
   1657 		}
   1658 		sc->axen_ep[AXEN_ENDPT_INTR] = NULL;
   1659 	}
   1660 }
   1661 
   1662 MODULE(MODULE_CLASS_DRIVER, if_axen, NULL);
   1663 
   1664 #ifdef _MODULE
   1665 #include "ioconf.c"
   1666 #endif
   1667 
   1668 static int
   1669 if_axen_modcmd(modcmd_t cmd, void *aux)
   1670 {
   1671 	int error = 0;
   1672 
   1673 	switch (cmd) {
   1674 	case MODULE_CMD_INIT:
   1675 #ifdef _MODULE
   1676 		error = config_init_component(cfdriver_ioconf_axen,
   1677 		    cfattach_ioconf_axen, cfdata_ioconf_axen);
   1678 #endif
   1679 		return error;
   1680 	case MODULE_CMD_FINI:
   1681 #ifdef _MODULE
   1682 		error = config_fini_component(cfdriver_ioconf_axen,
   1683 		    cfattach_ioconf_axen, cfdata_ioconf_axen);
   1684 #endif
   1685 		return error;
   1686 	default:
   1687 		return ENOTTY;
   1688 	}
   1689 }
   1690