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