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