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