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