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