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