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