if_axen.c revision 1.41
1 /* $NetBSD: if_axen.c,v 1.41 2019/05/28 07:41:50 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.41 2019/05/28 07:41:50 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_LOCK(ec); 374 ETHER_FIRST_MULTI(step, ec, enm); 375 while (enm != NULL) { 376 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, 377 ETHER_ADDR_LEN)) { 378 DPRINTF(("%s: allmulti\n", 379 device_xname(sc->axen_dev))); 380 memset(hashtbl, 0, sizeof(hashtbl)); 381 ETHER_UNLOCK(ec); 382 goto allmulti; 383 } 384 h = ether_crc32_be(enm->enm_addrlo, 385 ETHER_ADDR_LEN) >> 26; 386 hashtbl[h / 8] |= 1 << (h % 8); 387 DPRINTF(("%s: %s added\n", 388 device_xname(sc->axen_dev), 389 ether_sprintf(enm->enm_addrlo))); 390 ETHER_NEXT_MULTI(step, enm); 391 } 392 ETHER_UNLOCK(ec); 393 rxmode |= AXEN_RXCTL_ACPT_MCAST; 394 } 395 396 axen_cmd(sc, AXEN_CMD_MAC_WRITE_FILTER, 8, AXEN_FILTER_MULTI, hashtbl); 397 wval = htole16(rxmode); 398 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 399 axen_unlock_mii(sc); 400 } 401 402 static void 403 axen_reset(struct axen_softc *sc) 404 { 405 406 if (sc->axen_dying) 407 return; 408 /* XXX What to reset? */ 409 410 /* Wait a little while for the chip to get its brains in order. */ 411 DELAY(1000); 412 } 413 414 #if 0 /* not used */ 415 #define AXEN_GPIO_WRITE(x, y) do { \ 416 axen_cmd(sc, AXEN_CMD_WRITE_GPIO, 0, (x), NULL); \ 417 usbd_delay_ms(sc->axen_udev, (y)); \ 418 } while (/*CONSTCOND*/0) 419 420 static int 421 axen_ax88179_eeprom(struct axen_softc *sc, void *addr) 422 { 423 int i, retry; 424 uint8_t eeprom[20]; 425 uint16_t csum; 426 uint16_t buf; 427 428 for (i = 0; i < 6; i++) { 429 /* set eeprom address */ 430 buf = htole16(i); 431 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_ADDR, &buf); 432 433 /* set eeprom command */ 434 buf = htole16(AXEN_EEPROM_READ); 435 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_CMD, &buf); 436 437 /* check the value is ready */ 438 retry = 3; 439 do { 440 buf = htole16(AXEN_EEPROM_READ); 441 usbd_delay_ms(sc->axen_udev, 10); 442 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MAC_EEPROM_CMD, 443 &buf); 444 retry--; 445 if (retry < 0) 446 return EINVAL; 447 } while ((le16toh(buf) & 0xff) & AXEN_EEPROM_BUSY); 448 449 /* read data */ 450 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_EEPROM_READ, 451 &eeprom[i * 2]); 452 453 /* sanity check */ 454 if ((i == 0) && (eeprom[0] == 0xff)) 455 return EINVAL; 456 } 457 458 /* check checksum */ 459 csum = eeprom[6] + eeprom[7] + eeprom[8] + eeprom[9]; 460 csum = (csum >> 8) + (csum & 0xff) + eeprom[10]; 461 if (csum != 0xff) { 462 printf("eeprom checksum mismatchi(0x%02x)\n", csum); 463 return EINVAL; 464 } 465 466 memcpy(addr, eeprom, ETHER_ADDR_LEN); 467 return 0; 468 } 469 #endif 470 471 static void 472 axen_ax88179_init(struct axen_softc *sc) 473 { 474 struct axen_qctrl qctrl; 475 uint16_t ctl, temp; 476 uint16_t wval; 477 uint8_t val; 478 479 axen_lock_mii(sc); 480 481 /* XXX: ? */ 482 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_UNK_05, &val); 483 DPRINTFN(5, ("AXEN_CMD_MAC_READ(0x05): 0x%02x\n", val)); 484 485 /* check AX88179 version, UA1 / UA2 */ 486 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_GENERAL_STATUS, &val); 487 /* UA1 */ 488 if (!(val & AXEN_GENERAL_STATUS_MASK)) { 489 sc->axen_rev = AXEN_REV_UA1; 490 DPRINTF(("AX88179 ver. UA1\n")); 491 } else { 492 sc->axen_rev = AXEN_REV_UA2; 493 DPRINTF(("AX88179 ver. UA2\n")); 494 } 495 496 /* power up ethernet PHY */ 497 wval = htole16(0); 498 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval); 499 500 wval = htole16(AXEN_PHYPWR_RSTCTL_IPRL); 501 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval); 502 usbd_delay_ms(sc->axen_udev, 200); 503 504 /* set clock mode */ 505 val = AXEN_PHYCLK_ACS | AXEN_PHYCLK_BCS; 506 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val); 507 usbd_delay_ms(sc->axen_udev, 100); 508 509 /* set monitor mode (disable) */ 510 val = AXEN_MONITOR_NONE; 511 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val); 512 513 /* enable auto detach */ 514 axen_cmd(sc, AXEN_CMD_EEPROM_READ, 2, AXEN_EEPROM_STAT, &wval); 515 temp = le16toh(wval); 516 DPRINTFN(2,("EEPROM0x43 = 0x%04x\n", temp)); 517 if (!(temp == 0xffff) && !(temp & 0x0100)) { 518 /* Enable auto detach bit */ 519 val = 0; 520 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val); 521 val = AXEN_PHYCLK_ULR; 522 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val); 523 usbd_delay_ms(sc->axen_udev, 100); 524 525 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_PHYPWR_RSTCTL, &wval); 526 ctl = le16toh(wval); 527 ctl |= AXEN_PHYPWR_RSTCTL_AUTODETACH; 528 wval = htole16(ctl); 529 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval); 530 usbd_delay_ms(sc->axen_udev, 200); 531 aprint_error_dev(sc->axen_dev, "enable auto detach (0x%04x)\n", 532 ctl); 533 } 534 535 /* bulkin queue setting */ 536 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_USB_UPLINK, &val); 537 switch (val) { 538 case AXEN_USB_FS: 539 DPRINTF(("uplink: USB1.1\n")); 540 qctrl.ctrl = 0x07; 541 qctrl.timer_low = 0xcc; 542 qctrl.timer_high = 0x4c; 543 qctrl.bufsize = AXEN_BUFSZ_LS - 1; 544 qctrl.ifg = 0x08; 545 break; 546 case AXEN_USB_HS: 547 DPRINTF(("uplink: USB2.0\n")); 548 qctrl.ctrl = 0x07; 549 qctrl.timer_low = 0x02; 550 qctrl.timer_high = 0xa0; 551 qctrl.bufsize = AXEN_BUFSZ_HS - 1; 552 qctrl.ifg = 0xff; 553 break; 554 case AXEN_USB_SS: 555 DPRINTF(("uplink: USB3.0\n")); 556 qctrl.ctrl = 0x07; 557 qctrl.timer_low = 0x4f; 558 qctrl.timer_high = 0x00; 559 qctrl.bufsize = AXEN_BUFSZ_SS - 1; 560 qctrl.ifg = 0xff; 561 break; 562 default: 563 aprint_error_dev(sc->axen_dev, "unknown uplink bus:0x%02x\n", 564 val); 565 axen_unlock_mii(sc); 566 return; 567 } 568 axen_cmd(sc, AXEN_CMD_MAC_SET_RXSR, 5, AXEN_RX_BULKIN_QCTRL, &qctrl); 569 570 /* 571 * set buffer high/low watermark to pause/resume. 572 * write 2byte will set high/log simultaneous with AXEN_PAUSE_HIGH. 573 * XXX: what is the best value? OSX driver uses 0x3c-0x4c as LOW-HIGH 574 * watermark parameters. 575 */ 576 val = 0x34; 577 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_LOW_WATERMARK, &val); 578 val = 0x52; 579 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_HIGH_WATERMARK, &val); 580 581 /* Set RX/TX configuration. */ 582 /* Set RX control register */ 583 ctl = AXEN_RXCTL_IPE | AXEN_RXCTL_DROPCRCERR | AXEN_RXCTL_AUTOB; 584 wval = htole16(ctl); 585 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 586 587 /* set monitor mode (enable) */ 588 val = AXEN_MONITOR_PMETYPE | AXEN_MONITOR_PMEPOL | AXEN_MONITOR_RWMP; 589 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val); 590 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MONITOR_MODE, &val); 591 DPRINTF(("axen: Monitor mode = 0x%02x\n", val)); 592 593 /* set medium type */ 594 ctl = AXEN_MEDIUM_GIGA | AXEN_MEDIUM_FDX | AXEN_MEDIUM_EN_125MHZ | 595 AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN | 596 AXEN_MEDIUM_RECV_EN; 597 wval = htole16(ctl); 598 DPRINTF(("axen: set to medium mode: 0x%04x\n", ctl)); 599 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval); 600 usbd_delay_ms(sc->axen_udev, 100); 601 602 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MEDIUM_STATUS, &wval); 603 DPRINTF(("axen: current medium mode: 0x%04x\n", le16toh(wval))); 604 605 axen_unlock_mii(sc); 606 607 #if 0 /* XXX: TBD.... */ 608 #define GMII_LED_ACTIVE 0x1a 609 #define GMII_PHY_PAGE_SEL 0x1e 610 #define GMII_PHY_PAGE_SEL 0x1f 611 #define GMII_PAGE_EXT 0x0007 612 axen_miibus_writereg(&sc->axen_dev, sc->axen_phyno, GMII_PHY_PAGE_SEL, 613 GMII_PAGE_EXT); 614 axen_miibus_writereg(&sc->axen_dev, sc->axen_phyno, GMII_PHY_PAGE, 615 0x002c); 616 #endif 617 618 #if 1 /* XXX: phy hack ? */ 619 axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x1F, 0x0005); 620 axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x0C, 0x0000); 621 axen_miibus_readreg(sc->axen_dev, sc->axen_phyno, 0x0001, &wval); 622 axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x01, 623 wval | 0x0080); 624 axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x1F, 0x0000); 625 #endif 626 } 627 628 static void 629 axen_setcoe(struct axen_softc *sc) 630 { 631 struct ifnet *ifp = GET_IFP(sc); 632 uint64_t enabled = ifp->if_capenable; 633 uint8_t val; 634 635 axen_lock_mii(sc); 636 637 val = AXEN_RXCOE_OFF; 638 if (enabled & IFCAP_CSUM_IPv4_Rx) 639 val |= AXEN_RXCOE_IPv4; 640 if (enabled & IFCAP_CSUM_TCPv4_Rx) 641 val |= AXEN_RXCOE_TCPv4; 642 if (enabled & IFCAP_CSUM_UDPv4_Rx) 643 val |= AXEN_RXCOE_UDPv4; 644 if (enabled & IFCAP_CSUM_TCPv6_Rx) 645 val |= AXEN_RXCOE_TCPv6; 646 if (enabled & IFCAP_CSUM_UDPv6_Rx) 647 val |= AXEN_RXCOE_UDPv6; 648 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_RX_COE, &val); 649 650 val = AXEN_TXCOE_OFF; 651 if (enabled & IFCAP_CSUM_IPv4_Tx) 652 val |= AXEN_TXCOE_IPv4; 653 if (enabled & IFCAP_CSUM_TCPv4_Tx) 654 val |= AXEN_TXCOE_TCPv4; 655 if (enabled & IFCAP_CSUM_UDPv4_Tx) 656 val |= AXEN_TXCOE_UDPv4; 657 if (enabled & IFCAP_CSUM_TCPv6_Tx) 658 val |= AXEN_TXCOE_TCPv6; 659 if (enabled & IFCAP_CSUM_UDPv6_Tx) 660 val |= AXEN_TXCOE_UDPv6; 661 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_TX_COE, &val); 662 663 axen_unlock_mii(sc); 664 } 665 666 static int 667 axen_match(device_t parent, cfdata_t match, void *aux) 668 { 669 struct usb_attach_arg *uaa = aux; 670 671 return axen_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ? 672 UMATCH_VENDOR_PRODUCT : UMATCH_NONE; 673 } 674 675 static void 676 axen_attach(device_t parent, device_t self, void *aux) 677 { 678 struct axen_softc *sc = device_private(self); 679 struct usb_attach_arg *uaa = aux; 680 struct usbd_device *dev = uaa->uaa_device; 681 usbd_status err; 682 usb_interface_descriptor_t *id; 683 usb_endpoint_descriptor_t *ed; 684 struct mii_data *mii; 685 uint8_t eaddr[ETHER_ADDR_LEN]; 686 char *devinfop; 687 const char *devname = device_xname(self); 688 struct ifnet *ifp; 689 int i, s; 690 691 aprint_naive("\n"); 692 aprint_normal("\n"); 693 694 sc->axen_dev = self; 695 sc->axen_udev = dev; 696 697 devinfop = usbd_devinfo_alloc(dev, 0); 698 aprint_normal_dev(self, "%s\n", devinfop); 699 usbd_devinfo_free(devinfop); 700 701 err = usbd_set_config_no(dev, AXEN_CONFIG_NO, 1); 702 if (err) { 703 aprint_error_dev(self, "failed to set configuration" 704 ", err=%s\n", usbd_errstr(err)); 705 return; 706 } 707 708 sc->axen_flags = axen_lookup(uaa->uaa_vendor, uaa->uaa_product)->axen_flags; 709 710 rw_init(&sc->axen_mii_lock); 711 usb_init_task(&sc->axen_tick_task, axen_tick_task, sc, 0); 712 713 err = usbd_device2interface_handle(dev, AXEN_IFACE_IDX,&sc->axen_iface); 714 if (err) { 715 aprint_error_dev(self, "getting interface handle failed\n"); 716 return; 717 } 718 719 sc->axen_product = uaa->uaa_product; 720 sc->axen_vendor = uaa->uaa_vendor; 721 722 id = usbd_get_interface_descriptor(sc->axen_iface); 723 724 /* decide on what our bufsize will be */ 725 switch (sc->axen_udev->ud_speed) { 726 case USB_SPEED_SUPER: 727 sc->axen_rx_bufsz = AXEN_BUFSZ_SS * 1024; 728 break; 729 case USB_SPEED_HIGH: 730 sc->axen_rx_bufsz = AXEN_BUFSZ_HS * 1024; 731 break; 732 default: 733 sc->axen_rx_bufsz = AXEN_BUFSZ_LS * 1024; 734 break; 735 } 736 737 sc->axen_tx_bufsz = IP_MAXPACKET + 738 ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN + 739 sizeof(struct axen_sframe_hdr); 740 741 /* Find endpoints. */ 742 for (i = 0; i < id->bNumEndpoints; i++) { 743 ed = usbd_interface2endpoint_descriptor(sc->axen_iface, i); 744 if (!ed) { 745 aprint_error_dev(self, "couldn't get ep %d\n", i); 746 return; 747 } 748 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 749 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 750 sc->axen_ed[AXEN_ENDPT_RX] = ed->bEndpointAddress; 751 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 752 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 753 sc->axen_ed[AXEN_ENDPT_TX] = ed->bEndpointAddress; 754 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 755 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 756 sc->axen_ed[AXEN_ENDPT_INTR] = ed->bEndpointAddress; 757 } 758 } 759 760 s = splnet(); 761 762 sc->axen_phyno = AXEN_PHY_ID; 763 DPRINTF(("%s: phyno %d\n", device_xname(self), sc->axen_phyno)); 764 765 /* 766 * Get station address. 767 */ 768 #if 0 /* read from eeprom */ 769 if (axen_ax88179_eeprom(sc, &eaddr)) { 770 printf("EEPROM checksum error\n"); 771 return; 772 } 773 #else /* use MAC command */ 774 axen_lock_mii(sc); 775 axen_cmd(sc, AXEN_CMD_MAC_READ_ETHER, 6, AXEN_CMD_MAC_NODE_ID, &eaddr); 776 axen_unlock_mii(sc); 777 #endif 778 axen_ax88179_init(sc); 779 780 /* 781 * An ASIX chip was detected. Inform the world. 782 */ 783 if (sc->axen_flags & AX178A) 784 aprint_normal_dev(self, "AX88178a\n"); 785 else if (sc->axen_flags & AX179) 786 aprint_normal_dev(self, "AX88179\n"); 787 aprint_normal_dev(self, "Ethernet address %s\n", ether_sprintf(eaddr)); 788 789 /* Initialize interface info.*/ 790 791 ifp = &sc->sc_if; 792 ifp->if_softc = sc; 793 strlcpy(ifp->if_xname, devname, IFNAMSIZ); 794 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 795 ifp->if_ioctl = axen_ioctl; 796 ifp->if_start = axen_start; 797 ifp->if_init = axen_init; 798 ifp->if_stop = axen_stop; 799 ifp->if_watchdog = axen_watchdog; 800 801 IFQ_SET_READY(&ifp->if_snd); 802 803 sc->axen_ec.ec_capabilities = ETHERCAP_VLAN_MTU; 804 805 /* Adapter does not support TSOv6 (They call it LSOv2). */ 806 ifp->if_capabilities |= IFCAP_TSOv4 | 807 IFCAP_CSUM_IPv4_Rx | IFCAP_CSUM_IPv4_Tx | 808 IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv4_Tx | 809 IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv4_Tx | 810 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_TCPv6_Tx | 811 IFCAP_CSUM_UDPv6_Rx | IFCAP_CSUM_UDPv6_Tx; 812 813 /* Initialize MII/media info. */ 814 mii = &sc->axen_mii; 815 mii->mii_ifp = ifp; 816 mii->mii_readreg = axen_miibus_readreg; 817 mii->mii_writereg = axen_miibus_writereg; 818 mii->mii_statchg = axen_miibus_statchg; 819 mii->mii_flags = MIIF_AUTOTSLEEP; 820 821 sc->axen_ec.ec_mii = mii; 822 ifmedia_init(&mii->mii_media, 0, axen_ifmedia_upd, axen_ifmedia_sts); 823 mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0); 824 825 if (LIST_FIRST(&mii->mii_phys) == NULL) { 826 ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL); 827 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE); 828 } else 829 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO); 830 831 /* Attach the interface. */ 832 if_attach(ifp); 833 ether_ifattach(ifp, eaddr); 834 rnd_attach_source(&sc->rnd_source, device_xname(sc->axen_dev), 835 RND_TYPE_NET, RND_FLAG_DEFAULT); 836 837 callout_init(&sc->axen_stat_ch, 0); 838 callout_setfunc(&sc->axen_stat_ch, axen_tick, sc); 839 840 sc->axen_attached = true; 841 splx(s); 842 843 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->axen_udev,sc->axen_dev); 844 845 if (!pmf_device_register(self, NULL, NULL)) 846 aprint_error_dev(self, "couldn't establish power handler\n"); 847 } 848 849 static int 850 axen_detach(device_t self, int flags) 851 { 852 struct axen_softc *sc = device_private(self); 853 struct ifnet *ifp = GET_IFP(sc); 854 int s; 855 856 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__)); 857 858 /* Detached before attached finished, so just bail out. */ 859 if (!sc->axen_attached) 860 return 0; 861 862 pmf_device_deregister(self); 863 864 sc->axen_dying = true; 865 866 callout_halt(&sc->axen_stat_ch, NULL); 867 usb_rem_task_wait(sc->axen_udev, &sc->axen_tick_task, 868 USB_TASKQ_DRIVER, NULL); 869 870 s = splusb(); 871 872 if (ifp->if_flags & IFF_RUNNING) 873 axen_stop(ifp, 1); 874 875 callout_destroy(&sc->axen_stat_ch); 876 rnd_detach_source(&sc->rnd_source); 877 mii_detach(&sc->axen_mii, MII_PHY_ANY, MII_OFFSET_ANY); 878 ifmedia_delete_instance(&sc->axen_mii.mii_media, IFM_INST_ANY); 879 ether_ifdetach(ifp); 880 if_detach(ifp); 881 882 #ifdef DIAGNOSTIC 883 if (sc->axen_ep[AXEN_ENDPT_TX] != NULL || 884 sc->axen_ep[AXEN_ENDPT_RX] != NULL || 885 sc->axen_ep[AXEN_ENDPT_INTR] != NULL) 886 aprint_debug_dev(self, "detach has active endpoints\n"); 887 #endif 888 889 sc->axen_attached = false; 890 891 if (--sc->axen_refcnt >= 0) { 892 /* Wait for processes to go away. */ 893 usb_detach_waitold(sc->axen_dev); 894 } 895 splx(s); 896 897 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->axen_udev,sc->axen_dev); 898 899 rw_destroy(&sc->axen_mii_lock); 900 901 return 0; 902 } 903 904 static int 905 axen_activate(device_t self, devact_t act) 906 { 907 struct axen_softc *sc = device_private(self); 908 struct ifnet *ifp = GET_IFP(sc); 909 910 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__)); 911 912 switch (act) { 913 case DVACT_DEACTIVATE: 914 if_deactivate(ifp); 915 sc->axen_dying = true; 916 return 0; 917 default: 918 return EOPNOTSUPP; 919 } 920 } 921 922 static struct mbuf * 923 axen_newbuf(void) 924 { 925 struct mbuf *m; 926 927 MGETHDR(m, M_DONTWAIT, MT_DATA); 928 if (m == NULL) 929 return NULL; 930 931 MCLGET(m, M_DONTWAIT); 932 if (!(m->m_flags & M_EXT)) { 933 m_freem(m); 934 return NULL; 935 } 936 937 m->m_len = m->m_pkthdr.len = MCLBYTES; 938 m_adj(m, ETHER_ALIGN); 939 940 return m; 941 } 942 943 static int 944 axen_rx_list_init(struct axen_softc *sc) 945 { 946 struct axen_cdata *cd; 947 struct axen_chain *c; 948 int i; 949 950 DPRINTF(("%s: %s: enter\n", device_xname(sc->axen_dev), __func__)); 951 952 cd = &sc->axen_cdata; 953 for (i = 0; i < AXEN_RX_LIST_CNT; i++) { 954 c = &cd->axen_rx_chain[i]; 955 c->axen_sc = sc; 956 if (c->axen_xfer == NULL) { 957 int err = usbd_create_xfer(sc->axen_ep[AXEN_ENDPT_RX], 958 sc->axen_rx_bufsz, 0, 0, &c->axen_xfer); 959 if (err) 960 return err; 961 c->axen_buf = usbd_get_buffer(c->axen_xfer); 962 } 963 } 964 965 return 0; 966 } 967 968 static int 969 axen_tx_list_init(struct axen_softc *sc) 970 { 971 struct axen_cdata *cd; 972 struct axen_chain *c; 973 int i; 974 975 DPRINTF(("%s: %s: enter\n", device_xname(sc->axen_dev), __func__)); 976 977 cd = &sc->axen_cdata; 978 for (i = 0; i < AXEN_TX_LIST_CNT; i++) { 979 c = &cd->axen_tx_chain[i]; 980 c->axen_sc = sc; 981 if (c->axen_xfer == NULL) { 982 int err = usbd_create_xfer(sc->axen_ep[AXEN_ENDPT_TX], 983 sc->axen_tx_bufsz, USBD_FORCE_SHORT_XFER, 0, 984 &c->axen_xfer); 985 if (err) 986 return err; 987 c->axen_buf = usbd_get_buffer(c->axen_xfer); 988 } 989 } 990 991 cd->axen_tx_prod = cd->axen_tx_cnt = 0; 992 993 return 0; 994 } 995 996 /* 997 * A frame has been uploaded: pass the resulting mbuf chain up to 998 * the higher level protocols. 999 */ 1000 static void 1001 axen_rxeof(struct usbd_xfer *xfer, void * priv, usbd_status status) 1002 { 1003 struct axen_chain *c = (struct axen_chain *)priv; 1004 struct axen_softc *sc = c->axen_sc; 1005 struct ifnet *ifp = GET_IFP(sc); 1006 uint8_t *buf = c->axen_buf; 1007 struct mbuf *m; 1008 uint32_t total_len; 1009 uint32_t rx_hdr, pkt_hdr; 1010 uint32_t *hdr_p; 1011 uint16_t hdr_offset, pkt_count; 1012 size_t pkt_len; 1013 size_t temp; 1014 int s; 1015 1016 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__)); 1017 1018 if (sc->axen_dying) 1019 return; 1020 1021 if (!(ifp->if_flags & IFF_RUNNING)) 1022 return; 1023 1024 if (status != USBD_NORMAL_COMPLETION) { 1025 if (status == USBD_INVAL) 1026 return; /* XXX plugged out or down */ 1027 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) 1028 return; 1029 if (usbd_ratecheck(&sc->axen_rx_notice)) 1030 aprint_error_dev(sc->axen_dev, "usb errors on rx: %s\n", 1031 usbd_errstr(status)); 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 aprint_error_dev(sc->axen_dev, "rxeof: too short transfer\n"); 1041 ifp->if_ierrors++; 1042 goto done; 1043 } 1044 1045 /* 1046 * buffer map 1047 * [packet #0]...[packet #n][pkt hdr#0]..[pkt hdr#n][recv_hdr] 1048 * each packet has 0xeeee as psuedo header.. 1049 */ 1050 hdr_p = (uint32_t *)(buf + total_len - sizeof(uint32_t)); 1051 rx_hdr = le32toh(*hdr_p); 1052 hdr_offset = (uint16_t)(rx_hdr >> 16); 1053 pkt_count = (uint16_t)(rx_hdr & 0xffff); 1054 1055 if (total_len > sc->axen_rx_bufsz) { 1056 aprint_error_dev(sc->axen_dev, "rxeof: too large transfer\n"); 1057 goto done; 1058 } 1059 1060 /* sanity check */ 1061 if (hdr_offset > total_len) { 1062 aprint_error_dev(sc->axen_dev, "rxeof: invalid hdr offset\n"); 1063 ifp->if_ierrors++; 1064 usbd_delay_ms(sc->axen_udev, 100); 1065 goto done; 1066 } 1067 1068 /* point first packet header */ 1069 hdr_p = (uint32_t *)(buf + hdr_offset); 1070 1071 /* 1072 * ax88179 will pack multiple ip packet to a USB transaction. 1073 * process all of packets in the buffer 1074 */ 1075 1076 #if 1 /* XXX: paranoiac check. need to remove later */ 1077 #define AXEN_MAX_PACKED_PACKET 200 1078 if (pkt_count > AXEN_MAX_PACKED_PACKET) { 1079 DPRINTF(("%s: Too many packets (%d) in a transaction, discard.\n", 1080 device_xname(sc->axen_dev), pkt_count)); 1081 goto done; 1082 } 1083 #endif 1084 1085 do { 1086 if ((buf[0] != 0xee) || (buf[1] != 0xee)) { 1087 aprint_error_dev(sc->axen_dev, 1088 "invalid buffer(pkt#%d), continue\n", pkt_count); 1089 ifp->if_ierrors += pkt_count; 1090 goto done; 1091 } 1092 1093 pkt_hdr = le32toh(*hdr_p); 1094 pkt_len = (pkt_hdr >> 16) & 0x1fff; 1095 DPRINTFN(10, 1096 ("%s: rxeof: packet#%d, pkt_hdr 0x%08x, pkt_len %zu\n", 1097 device_xname(sc->axen_dev), pkt_count, pkt_hdr, pkt_len)); 1098 1099 if (pkt_hdr & (AXEN_RXHDR_CRC_ERR | AXEN_RXHDR_DROP_ERR)) { 1100 ifp->if_ierrors++; 1101 /* move to next pkt header */ 1102 DPRINTF(("%s: %s err (pkt#%d)\n", 1103 device_xname(sc->axen_dev), 1104 (pkt_hdr & AXEN_RXHDR_CRC_ERR) ? "crc" : "drop", 1105 pkt_count)); 1106 goto nextpkt; 1107 } 1108 1109 /* process each packet */ 1110 /* allocate mbuf */ 1111 m = axen_newbuf(); 1112 if (m == NULL) { 1113 ifp->if_ierrors++; 1114 goto nextpkt; 1115 } 1116 1117 /* skip pseudo header (2byte) */ 1118 m_set_rcvif(m, ifp); 1119 m->m_pkthdr.len = m->m_len = pkt_len - 6; 1120 1121 m->m_pkthdr.csum_flags = axen_csum_flags_rx(ifp, pkt_hdr); 1122 memcpy(mtod(m, char *), buf + 2, pkt_len - 6); 1123 1124 /* push the packet up */ 1125 s = splnet(); 1126 if_percpuq_enqueue((ifp)->if_percpuq, (m)); 1127 splx(s); 1128 1129 nextpkt: 1130 /* 1131 * prepare next packet 1132 * as each packet will be aligned 8byte boundary, 1133 * need to fix up the start point of the buffer. 1134 */ 1135 temp = ((pkt_len + 7) & 0xfff8); 1136 buf = buf + temp; 1137 hdr_p++; 1138 pkt_count--; 1139 } while(pkt_count > 0); 1140 1141 done: 1142 /* Setup new transfer. */ 1143 usbd_setup_xfer(xfer, c, c->axen_buf, sc->axen_rx_bufsz, 1144 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, axen_rxeof); 1145 usbd_transfer(xfer); 1146 1147 DPRINTFN(10,("%s: %s: start rx\n",device_xname(sc->axen_dev),__func__)); 1148 } 1149 1150 static int 1151 axen_csum_flags_rx(struct ifnet *ifp, uint32_t pkt_hdr) 1152 { 1153 int enabled_flags = ifp->if_csum_flags_rx; 1154 int csum_flags = 0; 1155 int l3_type, l4_type; 1156 1157 if (enabled_flags == 0) 1158 return 0; 1159 1160 l3_type = (pkt_hdr & AXEN_RXHDR_L3_TYPE_MASK) >> 1161 AXEN_RXHDR_L3_TYPE_OFFSET; 1162 1163 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4) 1164 csum_flags |= M_CSUM_IPv4; 1165 1166 l4_type = (pkt_hdr & AXEN_RXHDR_L4_TYPE_MASK) >> 1167 AXEN_RXHDR_L4_TYPE_OFFSET; 1168 1169 switch (l4_type) { 1170 case AXEN_RXHDR_L4_TYPE_TCP: 1171 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4) 1172 csum_flags |= M_CSUM_TCPv4; 1173 else 1174 csum_flags |= M_CSUM_TCPv6; 1175 break; 1176 case AXEN_RXHDR_L4_TYPE_UDP: 1177 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4) 1178 csum_flags |= M_CSUM_UDPv4; 1179 else 1180 csum_flags |= M_CSUM_UDPv6; 1181 break; 1182 default: 1183 break; 1184 } 1185 1186 csum_flags &= enabled_flags; 1187 if ((csum_flags & M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L3CSUM_ERR)) 1188 csum_flags |= M_CSUM_IPv4_BAD; 1189 if ((csum_flags & ~M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L4CSUM_ERR)) 1190 csum_flags |= M_CSUM_TCP_UDP_BAD; 1191 1192 return csum_flags; 1193 } 1194 1195 /* 1196 * A frame was downloaded to the chip. It's safe for us to clean up 1197 * the list buffers. 1198 */ 1199 static void 1200 axen_txeof(struct usbd_xfer *xfer, void * priv, usbd_status status) 1201 { 1202 struct axen_chain *c = (struct axen_chain *)priv; 1203 struct axen_softc *sc = c->axen_sc; 1204 struct axen_cdata *cd = &sc->axen_cdata; 1205 struct ifnet *ifp = GET_IFP(sc); 1206 int s; 1207 1208 if (sc->axen_dying) 1209 return; 1210 1211 s = splnet(); 1212 KASSERT(cd->axen_tx_cnt > 0); 1213 cd->axen_tx_cnt--; 1214 if (status != USBD_NORMAL_COMPLETION) { 1215 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) { 1216 splx(s); 1217 return; 1218 } 1219 ifp->if_oerrors++; 1220 if (usbd_ratecheck(&sc->axen_tx_notice)) 1221 aprint_error_dev(sc->axen_dev, "usb error on tx: %s\n", 1222 usbd_errstr(status)); 1223 if (status == USBD_STALLED) 1224 usbd_clear_endpoint_stall_async(sc->axen_ep[AXEN_ENDPT_TX]); 1225 splx(s); 1226 return; 1227 } 1228 1229 ifp->if_timer = 0; 1230 ifp->if_flags &= ~IFF_OACTIVE; 1231 1232 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 1233 axen_start(ifp); 1234 1235 ifp->if_opackets++; 1236 splx(s); 1237 } 1238 1239 static void 1240 axen_tick(void *xsc) 1241 { 1242 struct axen_softc *sc = xsc; 1243 1244 if (sc == NULL) 1245 return; 1246 1247 DPRINTFN(0xff,("%s: %s: enter\n", device_xname(sc->axen_dev),__func__)); 1248 1249 if (sc->axen_dying) 1250 return; 1251 1252 /* Perform periodic stuff in process context */ 1253 usb_add_task(sc->axen_udev, &sc->axen_tick_task, USB_TASKQ_DRIVER); 1254 } 1255 1256 static void 1257 axen_tick_task(void *xsc) 1258 { 1259 int s; 1260 struct axen_softc *sc; 1261 struct ifnet *ifp; 1262 struct mii_data *mii; 1263 1264 sc = xsc; 1265 1266 if (sc == NULL) 1267 return; 1268 1269 if (sc->axen_dying) 1270 return; 1271 1272 ifp = GET_IFP(sc); 1273 mii = GET_MII(sc); 1274 if (mii == NULL) 1275 return; 1276 1277 s = splnet(); 1278 1279 mii_tick(mii); 1280 if (sc->axen_link == 0) 1281 axen_miibus_statchg(ifp); 1282 1283 callout_schedule(&sc->axen_stat_ch, hz); 1284 1285 splx(s); 1286 } 1287 1288 static int 1289 axen_encap(struct axen_softc *sc, struct mbuf *m, int idx) 1290 { 1291 struct ifnet *ifp = GET_IFP(sc); 1292 struct axen_chain *c; 1293 usbd_status err; 1294 struct axen_sframe_hdr hdr; 1295 u_int length, boundary; 1296 1297 c = &sc->axen_cdata.axen_tx_chain[idx]; 1298 1299 /* XXX Is this need? */ 1300 switch (sc->axen_udev->ud_speed) { 1301 case USB_SPEED_SUPER: 1302 boundary = 4096; 1303 break; 1304 case USB_SPEED_HIGH: 1305 boundary = 512; 1306 break; 1307 default: 1308 boundary = 64; 1309 break; 1310 } 1311 1312 length = m->m_pkthdr.len + sizeof(hdr); 1313 KASSERT(length <= sc->axen_tx_bufsz); 1314 1315 hdr.plen = htole32(m->m_pkthdr.len); 1316 1317 hdr.gso = (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) ? 1318 m->m_pkthdr.segsz : 0; 1319 if ((length % boundary) == 0) { 1320 DPRINTF(("%s: boundary hit\n", device_xname(sc->axen_dev))); 1321 hdr.gso |= 0x80008000; /* XXX enable padding */ 1322 } 1323 hdr.gso = htole32(hdr.gso); 1324 1325 memcpy(c->axen_buf, &hdr, sizeof(hdr)); 1326 m_copydata(m, 0, m->m_pkthdr.len, c->axen_buf + sizeof(hdr)); 1327 1328 if (__predict_false(c->axen_xfer == NULL)) 1329 return EIO; /* XXX plugged out or down */ 1330 1331 usbd_setup_xfer(c->axen_xfer, c, c->axen_buf, length, 1332 USBD_FORCE_SHORT_XFER, 10000, axen_txeof); 1333 1334 /* Transmit */ 1335 err = usbd_transfer(c->axen_xfer); 1336 if (err != USBD_IN_PROGRESS) { 1337 axen_stop(ifp, 0); 1338 return EIO; 1339 } 1340 1341 return 0; 1342 } 1343 1344 static void 1345 axen_start(struct ifnet *ifp) 1346 { 1347 struct axen_softc *sc = ifp->if_softc; 1348 struct mbuf *m; 1349 struct axen_cdata *cd = &sc->axen_cdata; 1350 int idx; 1351 1352 if (sc->axen_link == 0) 1353 return; 1354 1355 if ((ifp->if_flags & (IFF_OACTIVE | IFF_RUNNING)) != IFF_RUNNING) 1356 return; 1357 1358 idx = cd->axen_tx_prod; 1359 while (cd->axen_tx_cnt < AXEN_TX_LIST_CNT) { 1360 IFQ_POLL(&ifp->if_snd, m); 1361 if (m == NULL) 1362 break; 1363 1364 if (axen_encap(sc, m, idx)) { 1365 ifp->if_flags |= IFF_OACTIVE; /* XXX */ 1366 ifp->if_oerrors++; 1367 break; 1368 } 1369 IFQ_DEQUEUE(&ifp->if_snd, m); 1370 1371 /* 1372 * If there's a BPF listener, bounce a copy of this frame 1373 * to him. 1374 */ 1375 bpf_mtap(ifp, m, BPF_D_OUT); 1376 m_freem(m); 1377 1378 idx = (idx + 1) % AXEN_TX_LIST_CNT; 1379 cd->axen_tx_cnt++; 1380 } 1381 cd->axen_tx_prod = idx; 1382 1383 if (cd->axen_tx_cnt >= AXEN_TX_LIST_CNT) 1384 ifp->if_flags |= IFF_OACTIVE; 1385 1386 /* 1387 * Set a timeout in case the chip goes out to lunch. 1388 */ 1389 ifp->if_timer = 5; 1390 } 1391 1392 static int 1393 axen_init(struct ifnet *ifp) 1394 { 1395 struct axen_softc *sc = ifp->if_softc; 1396 struct axen_chain *c; 1397 usbd_status err; 1398 int i, s; 1399 uint16_t rxmode; 1400 uint16_t wval; 1401 uint8_t bval; 1402 1403 s = splnet(); 1404 1405 if (ifp->if_flags & IFF_RUNNING) 1406 axen_stop(ifp, 0); 1407 1408 /* 1409 * Cancel pending I/O and free all RX/TX buffers. 1410 */ 1411 axen_reset(sc); 1412 1413 /* XXX: ? */ 1414 axen_lock_mii(sc); 1415 bval = 0x01; 1416 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_UNK_28, &bval); 1417 axen_unlock_mii(sc); 1418 1419 /* Configure offloading engine. */ 1420 axen_setcoe(sc); 1421 1422 /* Program promiscuous mode and multicast filters. */ 1423 axen_iff(sc); 1424 1425 /* Enable receiver, set RX mode */ 1426 axen_lock_mii(sc); 1427 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval); 1428 rxmode = le16toh(wval); 1429 rxmode |= AXEN_RXCTL_START; 1430 wval = htole16(rxmode); 1431 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 1432 axen_unlock_mii(sc); 1433 1434 /* Open RX and TX pipes. */ 1435 err = usbd_open_pipe(sc->axen_iface, sc->axen_ed[AXEN_ENDPT_RX], 1436 USBD_EXCLUSIVE_USE, &sc->axen_ep[AXEN_ENDPT_RX]); 1437 if (err) { 1438 aprint_error_dev(sc->axen_dev, "open rx pipe failed: %s\n", 1439 usbd_errstr(err)); 1440 splx(s); 1441 return EIO; 1442 } 1443 1444 err = usbd_open_pipe(sc->axen_iface, sc->axen_ed[AXEN_ENDPT_TX], 1445 USBD_EXCLUSIVE_USE, &sc->axen_ep[AXEN_ENDPT_TX]); 1446 if (err) { 1447 aprint_error_dev(sc->axen_dev, "open tx pipe failed: %s\n", 1448 usbd_errstr(err)); 1449 splx(s); 1450 return EIO; 1451 } 1452 1453 /* Init RX ring. */ 1454 if (axen_rx_list_init(sc)) { 1455 aprint_error_dev(sc->axen_dev, "rx list init failed\n"); 1456 splx(s); 1457 return ENOBUFS; 1458 } 1459 1460 /* Init TX ring. */ 1461 if (axen_tx_list_init(sc)) { 1462 aprint_error_dev(sc->axen_dev, "tx list init failed\n"); 1463 splx(s); 1464 return ENOBUFS; 1465 } 1466 1467 /* Start up the receive pipe. */ 1468 for (i = 0; i < AXEN_RX_LIST_CNT; i++) { 1469 c = &sc->axen_cdata.axen_rx_chain[i]; 1470 1471 usbd_setup_xfer(c->axen_xfer, c, c->axen_buf, sc->axen_rx_bufsz, 1472 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, axen_rxeof); 1473 usbd_transfer(c->axen_xfer); 1474 } 1475 1476 ifp->if_flags |= IFF_RUNNING; 1477 ifp->if_flags &= ~IFF_OACTIVE; 1478 1479 splx(s); 1480 1481 callout_schedule(&sc->axen_stat_ch, hz); 1482 return 0; 1483 } 1484 1485 static int 1486 axen_ioctl(struct ifnet *ifp, u_long cmd, void *data) 1487 { 1488 struct axen_softc *sc = ifp->if_softc; 1489 int s; 1490 int error = 0; 1491 1492 s = splnet(); 1493 1494 switch (cmd) { 1495 case SIOCSIFFLAGS: 1496 if ((error = ifioctl_common(ifp, cmd, data)) != 0) 1497 break; 1498 1499 switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) { 1500 case IFF_RUNNING: 1501 axen_stop(ifp, 1); 1502 break; 1503 case IFF_UP: 1504 axen_init(ifp); 1505 break; 1506 case IFF_UP | IFF_RUNNING: 1507 if ((ifp->if_flags ^ sc->axen_if_flags) == IFF_PROMISC) 1508 axen_iff(sc); 1509 else 1510 axen_init(ifp); 1511 break; 1512 } 1513 sc->axen_if_flags = ifp->if_flags; 1514 break; 1515 1516 default: 1517 if ((error = ether_ioctl(ifp, cmd, data)) != ENETRESET) 1518 break; 1519 1520 error = 0; 1521 switch (cmd) { 1522 case SIOCADDMULTI: 1523 case SIOCDELMULTI: 1524 axen_iff(sc); 1525 break; 1526 case SIOCSIFCAP: 1527 axen_setcoe(sc); 1528 break; 1529 default: 1530 break; 1531 } 1532 break; 1533 } 1534 splx(s); 1535 1536 return error; 1537 } 1538 1539 static void 1540 axen_watchdog(struct ifnet *ifp) 1541 { 1542 struct axen_softc *sc; 1543 struct axen_chain *c; 1544 usbd_status stat; 1545 int s; 1546 1547 sc = ifp->if_softc; 1548 1549 ifp->if_oerrors++; 1550 aprint_error_dev(sc->axen_dev, "watchdog timeout\n"); 1551 1552 s = splusb(); 1553 c = &sc->axen_cdata.axen_tx_chain[0]; 1554 usbd_get_xfer_status(c->axen_xfer, NULL, NULL, NULL, &stat); 1555 axen_txeof(c->axen_xfer, c, stat); 1556 1557 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 1558 axen_start(ifp); 1559 splx(s); 1560 } 1561 1562 /* 1563 * Stop the adapter and free any mbufs allocated to the 1564 * RX and TX lists. 1565 */ 1566 static void 1567 axen_stop(struct ifnet *ifp, int disable) 1568 { 1569 struct axen_softc *sc = ifp->if_softc; 1570 struct axen_chain *c; 1571 usbd_status err; 1572 int i; 1573 uint16_t rxmode, wval; 1574 1575 axen_reset(sc); 1576 1577 /* Disable receiver, set RX mode */ 1578 axen_lock_mii(sc); 1579 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval); 1580 rxmode = le16toh(wval); 1581 rxmode &= ~AXEN_RXCTL_START; 1582 wval = htole16(rxmode); 1583 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 1584 axen_unlock_mii(sc); 1585 1586 ifp->if_timer = 0; 1587 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1588 1589 callout_stop(&sc->axen_stat_ch); 1590 sc->axen_link = 0; 1591 1592 /* Stop transfers. */ 1593 if (sc->axen_ep[AXEN_ENDPT_RX] != NULL) { 1594 err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_RX]); 1595 if (err) { 1596 aprint_error_dev(sc->axen_dev, 1597 "abort rx pipe failed: %s\n", usbd_errstr(err)); 1598 1599 } 1600 } 1601 1602 if (sc->axen_ep[AXEN_ENDPT_TX] != NULL) { 1603 err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_TX]); 1604 if (err) { 1605 aprint_error_dev(sc->axen_dev, 1606 "abort tx pipe failed: %s\n", usbd_errstr(err)); 1607 } 1608 } 1609 1610 if (sc->axen_ep[AXEN_ENDPT_INTR] != NULL) { 1611 err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_INTR]); 1612 if (err) { 1613 aprint_error_dev(sc->axen_dev, 1614 "abort intr pipe failed: %s\n", usbd_errstr(err)); 1615 } 1616 } 1617 1618 /* Free RX resources. */ 1619 for (i = 0; i < AXEN_RX_LIST_CNT; i++) { 1620 c = &sc->axen_cdata.axen_rx_chain[i]; 1621 if (c->axen_xfer != NULL) { 1622 usbd_destroy_xfer(c->axen_xfer); 1623 c->axen_xfer = NULL; 1624 } 1625 } 1626 1627 /* Free TX resources. */ 1628 for (i = 0; i < AXEN_TX_LIST_CNT; i++) { 1629 c = &sc->axen_cdata.axen_tx_chain[i]; 1630 if (c->axen_xfer != NULL) { 1631 usbd_destroy_xfer(c->axen_xfer); 1632 c->axen_xfer = NULL; 1633 } 1634 } 1635 1636 /* Close pipes. */ 1637 if (sc->axen_ep[AXEN_ENDPT_RX] != NULL) { 1638 err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_RX]); 1639 if (err) { 1640 aprint_error_dev(sc->axen_dev, 1641 "close rx pipe failed: %s\n", usbd_errstr(err)); 1642 } 1643 sc->axen_ep[AXEN_ENDPT_RX] = NULL; 1644 } 1645 1646 if (sc->axen_ep[AXEN_ENDPT_TX] != NULL) { 1647 err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_TX]); 1648 if (err) { 1649 aprint_error_dev(sc->axen_dev, 1650 "close tx pipe failed: %s\n", usbd_errstr(err)); 1651 } 1652 sc->axen_ep[AXEN_ENDPT_TX] = NULL; 1653 } 1654 1655 if (sc->axen_ep[AXEN_ENDPT_INTR] != NULL) { 1656 err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_INTR]); 1657 if (err) { 1658 aprint_error_dev(sc->axen_dev, 1659 "close intr pipe failed: %s\n", usbd_errstr(err)); 1660 } 1661 sc->axen_ep[AXEN_ENDPT_INTR] = NULL; 1662 } 1663 } 1664 1665 MODULE(MODULE_CLASS_DRIVER, if_axen, NULL); 1666 1667 #ifdef _MODULE 1668 #include "ioconf.c" 1669 #endif 1670 1671 static int 1672 if_axen_modcmd(modcmd_t cmd, void *aux) 1673 { 1674 int error = 0; 1675 1676 switch (cmd) { 1677 case MODULE_CMD_INIT: 1678 #ifdef _MODULE 1679 error = config_init_component(cfdriver_ioconf_axen, 1680 cfattach_ioconf_axen, cfdata_ioconf_axen); 1681 #endif 1682 return error; 1683 case MODULE_CMD_FINI: 1684 #ifdef _MODULE 1685 error = config_fini_component(cfdriver_ioconf_axen, 1686 cfattach_ioconf_axen, cfdata_ioconf_axen); 1687 #endif 1688 return error; 1689 default: 1690 return ENOTTY; 1691 } 1692 } 1693
Indexes created Mon Oct 13 16:09:52 GMT 2025