if_axen.c revision 1.51
1 /* $NetBSD: if_axen.c,v 1.51 2019/07/31 09:13:16 mrg 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.51 2019/07/31 09:13:16 mrg Exp $"); 27 28 #ifdef _KERNEL_OPT 29 #include "opt_usb.h" 30 #endif 31 32 #include <sys/param.h> 33 #include <sys/module.h> 34 35 #include <netinet/in.h> /* XXX for netinet/ip.h */ 36 #include <netinet/ip.h> /* XXX for IP_MAXPACKET */ 37 38 #include <dev/usb/usbnet.h> 39 40 #include <dev/usb/if_axenreg.h> 41 42 #ifdef AXEN_DEBUG 43 #define DPRINTF(x) do { if (axendebug) printf x; } while (/*CONSTCOND*/0) 44 #define DPRINTFN(n, x) do { if (axendebug >= (n)) printf x; } while (/*CONSTCOND*/0) 45 int axendebug = 0; 46 #else 47 #define DPRINTF(x) 48 #define DPRINTFN(n, x) 49 #endif 50 51 struct axen_softc { 52 struct usbnet axen_un; 53 int axen_rev; 54 }; 55 56 struct axen_type { 57 struct usb_devno axen_devno; 58 uint16_t axen_flags; 59 #define AX178A 0x0001 /* AX88178a */ 60 #define AX179 0x0002 /* AX88179 */ 61 }; 62 63 /* 64 * Various supported device vendors/products. 65 */ 66 static const struct axen_type axen_devs[] = { 67 #if 0 /* not tested */ 68 { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88178A}, AX178A }, 69 #endif 70 { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88179}, AX179 }, 71 { { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DUB1312}, AX179 } 72 }; 73 74 #define axen_lookup(v, p) ((const struct axen_type *)usb_lookup(axen_devs, v, p)) 75 76 static int axen_match(device_t, cfdata_t, void *); 77 static void axen_attach(device_t, device_t, void *); 78 79 CFATTACH_DECL_NEW(axen, sizeof(struct axen_softc), 80 axen_match, axen_attach, usbnet_detach, usbnet_activate); 81 82 static unsigned axen_tx_prepare(struct usbnet *, struct mbuf *, 83 struct usbnet_chain *); 84 static int axen_init(struct ifnet *); 85 static int axen_cmd(struct axen_softc *, int, int, int, void *); 86 static void axen_reset(struct axen_softc *); 87 static int axen_get_eaddr(struct axen_softc *, void *); 88 static void axen_stop_cb(struct ifnet *, int); 89 static void axen_ax88179_init(struct axen_softc *); 90 91 static usbd_status axen_mii_read_reg(struct usbnet *, int, int, uint16_t *); 92 static usbd_status axen_mii_write_reg(struct usbnet *, int, int, uint16_t); 93 static void axen_rxeof_loop(struct usbnet *, struct usbd_xfer *, 94 struct usbnet_chain *, uint32_t); 95 96 static int 97 axen_cmd(struct axen_softc *sc, int cmd, int index, int val, void *buf) 98 { 99 struct usbnet * const un = &sc->axen_un; 100 usb_device_request_t req; 101 usbd_status err; 102 103 KASSERT(mutex_owned(&un->un_miilock)); 104 105 if (un->un_dying) 106 return 0; 107 108 if (AXEN_CMD_DIR(cmd)) 109 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 110 else 111 req.bmRequestType = UT_READ_VENDOR_DEVICE; 112 req.bRequest = AXEN_CMD_CMD(cmd); 113 USETW(req.wValue, val); 114 USETW(req.wIndex, index); 115 USETW(req.wLength, AXEN_CMD_LEN(cmd)); 116 117 err = usbd_do_request(un->un_udev, &req, buf); 118 DPRINTFN(5, ("axen_cmd: cmd 0x%04x val 0x%04x len %d\n", 119 cmd, val, AXEN_CMD_LEN(cmd))); 120 121 if (err) { 122 DPRINTF(("%s: cmd: %d, error: %d\n", __func__, cmd, err)); 123 return -1; 124 } 125 126 return 0; 127 } 128 129 static usbd_status 130 axen_mii_read_reg(struct usbnet *un, int reg, int phy, uint16_t *val) 131 { 132 struct axen_softc * const sc = un->un_sc; 133 uint16_t data; 134 usbd_status err = axen_cmd(sc, AXEN_CMD_MII_READ_REG, reg, phy, &data); 135 136 if (!err) { 137 *val = le16toh(data); 138 139 if (reg == MII_BMSR) 140 *val &= ~BMSR_EXTCAP; 141 } 142 143 return err; 144 } 145 146 static usbd_status 147 axen_mii_write_reg(struct usbnet *un, int reg, int phy, uint16_t val) 148 { 149 struct axen_softc * const sc = un->un_sc; 150 uint16_t uval = htole16(val); 151 152 return axen_cmd(sc, AXEN_CMD_MII_WRITE_REG, reg, phy, &uval); 153 } 154 155 static void 156 axen_miibus_statchg(struct ifnet *ifp) 157 { 158 struct usbnet * const un = ifp->if_softc; 159 struct axen_softc * const sc = un->un_sc; 160 struct mii_data * const mii = usbnet_mii(un); 161 int err; 162 uint16_t val; 163 uint16_t wval; 164 165 if (un->un_dying) 166 return; 167 168 un->un_link = false; 169 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) == 170 (IFM_ACTIVE | IFM_AVALID)) { 171 switch (IFM_SUBTYPE(mii->mii_media_active)) { 172 case IFM_10_T: 173 case IFM_100_TX: 174 un->un_link = true; 175 break; 176 case IFM_1000_T: 177 un->un_link = true; 178 break; 179 default: 180 break; 181 } 182 } 183 184 /* Lost link, do nothing. */ 185 if (!un->un_link) 186 return; 187 188 val = 0; 189 if ((mii->mii_media_active & IFM_FDX) != 0) 190 val |= AXEN_MEDIUM_FDX; 191 192 val |= AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN | 193 AXEN_MEDIUM_RECV_EN; 194 switch (IFM_SUBTYPE(mii->mii_media_active)) { 195 case IFM_1000_T: 196 val |= AXEN_MEDIUM_GIGA | AXEN_MEDIUM_EN_125MHZ; 197 break; 198 case IFM_100_TX: 199 val |= AXEN_MEDIUM_PS; 200 break; 201 case IFM_10_T: 202 /* doesn't need to be handled */ 203 break; 204 } 205 206 DPRINTF(("%s: val=0x%x\n", __func__, val)); 207 wval = htole16(val); 208 usbnet_lock_mii(un); 209 err = axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval); 210 usbnet_unlock_mii(un); 211 if (err) 212 aprint_error_dev(un->un_dev, "media change failed\n"); 213 } 214 215 static void 216 axen_setiff_locked(struct usbnet *un) 217 { 218 struct axen_softc * const sc = un->un_sc; 219 struct ifnet * const ifp = usbnet_ifp(un); 220 struct ethercom *ec = &un->un_ec; 221 struct ether_multi *enm; 222 struct ether_multistep step; 223 uint32_t h = 0; 224 uint16_t rxmode; 225 uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 226 uint16_t wval; 227 228 if (un->un_dying) 229 return; 230 231 KASSERT(mutex_owned(&un->un_miilock)); 232 233 rxmode = 0; 234 235 /* Enable receiver, set RX mode */ 236 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval); 237 rxmode = le16toh(wval); 238 rxmode &= ~(AXEN_RXCTL_ACPT_ALL_MCAST | AXEN_RXCTL_PROMISC | 239 AXEN_RXCTL_ACPT_MCAST); 240 241 if (ifp->if_flags & IFF_PROMISC) { 242 DPRINTF(("%s: promisc\n", device_xname(un->un_dev))); 243 rxmode |= AXEN_RXCTL_PROMISC; 244 allmulti: 245 ETHER_LOCK(ec); 246 ec->ec_flags |= ETHER_F_ALLMULTI; 247 ETHER_UNLOCK(ec); 248 rxmode |= AXEN_RXCTL_ACPT_ALL_MCAST 249 /* | AXEN_RXCTL_ACPT_PHY_MCAST */; 250 } else { 251 /* now program new ones */ 252 DPRINTF(("%s: initializing hash table\n", 253 device_xname(un->un_dev))); 254 ETHER_LOCK(ec); 255 ec->ec_flags &= ~ETHER_F_ALLMULTI; 256 257 ETHER_FIRST_MULTI(step, ec, enm); 258 while (enm != NULL) { 259 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, 260 ETHER_ADDR_LEN)) { 261 DPRINTF(("%s: allmulti\n", 262 device_xname(un->un_dev))); 263 memset(hashtbl, 0, sizeof(hashtbl)); 264 ETHER_UNLOCK(ec); 265 goto allmulti; 266 } 267 h = ether_crc32_be(enm->enm_addrlo, 268 ETHER_ADDR_LEN) >> 26; 269 hashtbl[h / 8] |= 1 << (h % 8); 270 DPRINTF(("%s: %s added\n", 271 device_xname(un->un_dev), 272 ether_sprintf(enm->enm_addrlo))); 273 ETHER_NEXT_MULTI(step, enm); 274 } 275 ETHER_UNLOCK(ec); 276 rxmode |= AXEN_RXCTL_ACPT_MCAST; 277 } 278 279 axen_cmd(sc, AXEN_CMD_MAC_WRITE_FILTER, 8, AXEN_FILTER_MULTI, hashtbl); 280 wval = htole16(rxmode); 281 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 282 } 283 284 static void 285 axen_setiff(struct usbnet *un) 286 { 287 usbnet_lock_mii(un); 288 axen_setiff_locked(un); 289 usbnet_unlock_mii(un); 290 } 291 292 static void 293 axen_reset(struct axen_softc *sc) 294 { 295 struct usbnet * const un = &sc->axen_un; 296 297 KASSERT(mutex_owned(&un->un_lock)); 298 if (un->un_dying) 299 return; 300 /* XXX What to reset? */ 301 302 /* Wait a little while for the chip to get its brains in order. */ 303 DELAY(1000); 304 } 305 306 static int 307 axen_get_eaddr(struct axen_softc *sc, void *addr) 308 { 309 #if 1 310 return axen_cmd(sc, AXEN_CMD_MAC_READ_ETHER, 6, AXEN_CMD_MAC_NODE_ID, 311 addr); 312 #else 313 struct usbnet * const un = &sc->axen_un; 314 int i, retry; 315 uint8_t eeprom[20]; 316 uint16_t csum; 317 uint16_t buf; 318 319 for (i = 0; i < 6; i++) { 320 /* set eeprom address */ 321 buf = htole16(i); 322 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_ADDR, &buf); 323 324 /* set eeprom command */ 325 buf = htole16(AXEN_EEPROM_READ); 326 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_CMD, &buf); 327 328 /* check the value is ready */ 329 retry = 3; 330 do { 331 buf = htole16(AXEN_EEPROM_READ); 332 usbd_delay_ms(un->un_udev, 10); 333 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MAC_EEPROM_CMD, 334 &buf); 335 retry--; 336 if (retry < 0) 337 return EINVAL; 338 } while ((le16toh(buf) & 0xff) & AXEN_EEPROM_BUSY); 339 340 /* read data */ 341 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_EEPROM_READ, 342 &eeprom[i * 2]); 343 344 /* sanity check */ 345 if ((i == 0) && (eeprom[0] == 0xff)) 346 return EINVAL; 347 } 348 349 /* check checksum */ 350 csum = eeprom[6] + eeprom[7] + eeprom[8] + eeprom[9]; 351 csum = (csum >> 8) + (csum & 0xff) + eeprom[10]; 352 if (csum != 0xff) { 353 printf("eeprom checksum mismatchi(0x%02x)\n", csum); 354 return EINVAL; 355 } 356 357 memcpy(addr, eeprom, ETHER_ADDR_LEN); 358 return 0; 359 #endif 360 } 361 362 static void 363 axen_ax88179_init(struct axen_softc *sc) 364 { 365 struct usbnet * const un = &sc->axen_un; 366 struct axen_qctrl qctrl; 367 uint16_t ctl, temp; 368 uint16_t wval; 369 uint8_t val; 370 371 usbnet_lock_mii(un); 372 373 /* XXX: ? */ 374 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_UNK_05, &val); 375 DPRINTFN(5, ("AXEN_CMD_MAC_READ(0x05): 0x%02x\n", val)); 376 377 /* check AX88179 version, UA1 / UA2 */ 378 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_GENERAL_STATUS, &val); 379 /* UA1 */ 380 if (!(val & AXEN_GENERAL_STATUS_MASK)) { 381 sc->axen_rev = AXEN_REV_UA1; 382 DPRINTF(("AX88179 ver. UA1\n")); 383 } else { 384 sc->axen_rev = AXEN_REV_UA2; 385 DPRINTF(("AX88179 ver. UA2\n")); 386 } 387 388 /* power up ethernet PHY */ 389 wval = htole16(0); 390 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval); 391 392 wval = htole16(AXEN_PHYPWR_RSTCTL_IPRL); 393 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval); 394 usbd_delay_ms(un->un_udev, 200); 395 396 /* set clock mode */ 397 val = AXEN_PHYCLK_ACS | AXEN_PHYCLK_BCS; 398 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val); 399 usbd_delay_ms(un->un_udev, 100); 400 401 /* set monitor mode (disable) */ 402 val = AXEN_MONITOR_NONE; 403 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val); 404 405 /* enable auto detach */ 406 axen_cmd(sc, AXEN_CMD_EEPROM_READ, 2, AXEN_EEPROM_STAT, &wval); 407 temp = le16toh(wval); 408 DPRINTFN(2,("EEPROM0x43 = 0x%04x\n", temp)); 409 if (!(temp == 0xffff) && !(temp & 0x0100)) { 410 /* Enable auto detach bit */ 411 val = 0; 412 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val); 413 val = AXEN_PHYCLK_ULR; 414 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val); 415 usbd_delay_ms(un->un_udev, 100); 416 417 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_PHYPWR_RSTCTL, &wval); 418 ctl = le16toh(wval); 419 ctl |= AXEN_PHYPWR_RSTCTL_AUTODETACH; 420 wval = htole16(ctl); 421 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval); 422 usbd_delay_ms(un->un_udev, 200); 423 aprint_error_dev(un->un_dev, "enable auto detach (0x%04x)\n", 424 ctl); 425 } 426 427 /* bulkin queue setting */ 428 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_USB_UPLINK, &val); 429 switch (val) { 430 case AXEN_USB_FS: 431 DPRINTF(("uplink: USB1.1\n")); 432 qctrl.ctrl = 0x07; 433 qctrl.timer_low = 0xcc; 434 qctrl.timer_high = 0x4c; 435 qctrl.bufsize = AXEN_BUFSZ_LS - 1; 436 qctrl.ifg = 0x08; 437 break; 438 case AXEN_USB_HS: 439 DPRINTF(("uplink: USB2.0\n")); 440 qctrl.ctrl = 0x07; 441 qctrl.timer_low = 0x02; 442 qctrl.timer_high = 0xa0; 443 qctrl.bufsize = AXEN_BUFSZ_HS - 1; 444 qctrl.ifg = 0xff; 445 break; 446 case AXEN_USB_SS: 447 DPRINTF(("uplink: USB3.0\n")); 448 qctrl.ctrl = 0x07; 449 qctrl.timer_low = 0x4f; 450 qctrl.timer_high = 0x00; 451 qctrl.bufsize = AXEN_BUFSZ_SS - 1; 452 qctrl.ifg = 0xff; 453 break; 454 default: 455 aprint_error_dev(un->un_dev, "unknown uplink bus:0x%02x\n", 456 val); 457 usbnet_unlock_mii(un); 458 return; 459 } 460 axen_cmd(sc, AXEN_CMD_MAC_SET_RXSR, 5, AXEN_RX_BULKIN_QCTRL, &qctrl); 461 462 /* 463 * set buffer high/low watermark to pause/resume. 464 * write 2byte will set high/log simultaneous with AXEN_PAUSE_HIGH. 465 * XXX: what is the best value? OSX driver uses 0x3c-0x4c as LOW-HIGH 466 * watermark parameters. 467 */ 468 val = 0x34; 469 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_LOW_WATERMARK, &val); 470 val = 0x52; 471 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_HIGH_WATERMARK, &val); 472 473 /* Set RX/TX configuration. */ 474 /* Set RX control register */ 475 ctl = AXEN_RXCTL_IPE | AXEN_RXCTL_DROPCRCERR | AXEN_RXCTL_AUTOB; 476 wval = htole16(ctl); 477 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 478 479 /* set monitor mode (enable) */ 480 val = AXEN_MONITOR_PMETYPE | AXEN_MONITOR_PMEPOL | AXEN_MONITOR_RWMP; 481 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val); 482 axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MONITOR_MODE, &val); 483 DPRINTF(("axen: Monitor mode = 0x%02x\n", val)); 484 485 /* set medium type */ 486 ctl = AXEN_MEDIUM_GIGA | AXEN_MEDIUM_FDX | AXEN_MEDIUM_EN_125MHZ | 487 AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN | 488 AXEN_MEDIUM_RECV_EN; 489 wval = htole16(ctl); 490 DPRINTF(("axen: set to medium mode: 0x%04x\n", ctl)); 491 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval); 492 usbd_delay_ms(un->un_udev, 100); 493 494 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MEDIUM_STATUS, &wval); 495 DPRINTF(("axen: current medium mode: 0x%04x\n", le16toh(wval))); 496 497 usbnet_unlock_mii(un); 498 499 #if 0 /* XXX: TBD.... */ 500 #define GMII_LED_ACTIVE 0x1a 501 #define GMII_PHY_PAGE_SEL 0x1e 502 #define GMII_PHY_PAGE_SEL 0x1f 503 #define GMII_PAGE_EXT 0x0007 504 usbnet_miibus_writereg(un->un_dev, un->un_phyno, GMII_PHY_PAGE_SEL, 505 GMII_PAGE_EXT); 506 usbnet_miibus_writereg(un->un_dev, un->un_phyno, GMII_PHY_PAGE, 507 0x002c); 508 #endif 509 510 #if 1 /* XXX: phy hack ? */ 511 usbnet_miibus_writereg(un->un_dev, un->un_phyno, 0x1F, 0x0005); 512 usbnet_miibus_writereg(un->un_dev, un->un_phyno, 0x0C, 0x0000); 513 usbnet_miibus_readreg(un->un_dev, un->un_phyno, 0x0001, &wval); 514 usbnet_miibus_writereg(un->un_dev, un->un_phyno, 0x01, wval | 0x0080); 515 usbnet_miibus_writereg(un->un_dev, un->un_phyno, 0x1F, 0x0000); 516 #endif 517 } 518 519 static void 520 axen_setoe_locked(struct usbnet *un) 521 { 522 struct axen_softc * const sc = un->un_sc; 523 struct ifnet * const ifp = usbnet_ifp(un); 524 uint64_t enabled = ifp->if_capenable; 525 uint8_t val; 526 527 KASSERT(mutex_owned(&un->un_miilock)); 528 529 val = AXEN_RXCOE_OFF; 530 if (enabled & IFCAP_CSUM_IPv4_Rx) 531 val |= AXEN_RXCOE_IPv4; 532 if (enabled & IFCAP_CSUM_TCPv4_Rx) 533 val |= AXEN_RXCOE_TCPv4; 534 if (enabled & IFCAP_CSUM_UDPv4_Rx) 535 val |= AXEN_RXCOE_UDPv4; 536 if (enabled & IFCAP_CSUM_TCPv6_Rx) 537 val |= AXEN_RXCOE_TCPv6; 538 if (enabled & IFCAP_CSUM_UDPv6_Rx) 539 val |= AXEN_RXCOE_UDPv6; 540 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_RX_COE, &val); 541 542 val = AXEN_TXCOE_OFF; 543 if (enabled & IFCAP_CSUM_IPv4_Tx) 544 val |= AXEN_TXCOE_IPv4; 545 if (enabled & IFCAP_CSUM_TCPv4_Tx) 546 val |= AXEN_TXCOE_TCPv4; 547 if (enabled & IFCAP_CSUM_UDPv4_Tx) 548 val |= AXEN_TXCOE_UDPv4; 549 if (enabled & IFCAP_CSUM_TCPv6_Tx) 550 val |= AXEN_TXCOE_TCPv6; 551 if (enabled & IFCAP_CSUM_UDPv6_Tx) 552 val |= AXEN_TXCOE_UDPv6; 553 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_TX_COE, &val); 554 } 555 556 static void 557 axen_setoe(struct usbnet *un) 558 { 559 560 usbnet_lock_mii(un); 561 axen_setoe_locked(un); 562 usbnet_unlock_mii(un); 563 } 564 565 static int 566 axen_ioctl_cb(struct ifnet *ifp, u_long cmd, void *data) 567 { 568 struct usbnet * const un = ifp->if_softc; 569 570 switch (cmd) { 571 case SIOCSIFFLAGS: 572 case SIOCSETHERCAP: 573 case SIOCADDMULTI: 574 case SIOCDELMULTI: 575 axen_setiff(un); 576 break; 577 case SIOCSIFCAP: 578 axen_setoe(un); 579 break; 580 default: 581 break; 582 } 583 584 return 0; 585 } 586 587 static int 588 axen_match(device_t parent, cfdata_t match, void *aux) 589 { 590 struct usb_attach_arg *uaa = aux; 591 592 return axen_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ? 593 UMATCH_VENDOR_PRODUCT : UMATCH_NONE; 594 } 595 596 static void 597 axen_attach(device_t parent, device_t self, void *aux) 598 { 599 struct axen_softc * const sc = device_private(self); 600 struct usbnet * const un = &sc->axen_un; 601 struct usb_attach_arg *uaa = aux; 602 struct usbd_device *dev = uaa->uaa_device; 603 usbd_status err; 604 usb_interface_descriptor_t *id; 605 usb_endpoint_descriptor_t *ed; 606 char *devinfop; 607 uint16_t axen_flags; 608 int i; 609 610 /* Switch to usbnet for device_private() */ 611 self->dv_private = un; 612 613 aprint_naive("\n"); 614 aprint_normal("\n"); 615 616 un->un_dev = self; 617 un->un_udev = dev; 618 un->un_sc = sc; 619 un->un_stop_cb = axen_stop_cb; 620 un->un_ioctl_cb = axen_ioctl_cb; 621 un->un_read_reg_cb = axen_mii_read_reg; 622 un->un_write_reg_cb = axen_mii_write_reg; 623 un->un_statchg_cb = axen_miibus_statchg; 624 un->un_tx_prepare_cb = axen_tx_prepare; 625 un->un_rx_loop_cb = axen_rxeof_loop; 626 un->un_init_cb = axen_init; 627 un->un_rx_xfer_flags = USBD_SHORT_XFER_OK; 628 un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER; 629 630 devinfop = usbd_devinfo_alloc(dev, 0); 631 aprint_normal_dev(self, "%s\n", devinfop); 632 usbd_devinfo_free(devinfop); 633 634 err = usbd_set_config_no(dev, AXEN_CONFIG_NO, 1); 635 if (err) { 636 aprint_error_dev(self, "failed to set configuration" 637 ", err=%s\n", usbd_errstr(err)); 638 return; 639 } 640 641 axen_flags = axen_lookup(uaa->uaa_vendor, uaa->uaa_product)->axen_flags; 642 643 err = usbd_device2interface_handle(dev, AXEN_IFACE_IDX, &un->un_iface); 644 if (err) { 645 aprint_error_dev(self, "getting interface handle failed\n"); 646 return; 647 } 648 649 /* decide on what our bufsize will be */ 650 switch (dev->ud_speed) { 651 case USB_SPEED_SUPER: 652 un->un_cdata.uncd_rx_bufsz = AXEN_BUFSZ_SS * 1024; 653 break; 654 case USB_SPEED_HIGH: 655 un->un_cdata.uncd_rx_bufsz = AXEN_BUFSZ_HS * 1024; 656 break; 657 default: 658 un->un_cdata.uncd_rx_bufsz = AXEN_BUFSZ_LS * 1024; 659 break; 660 } 661 662 un->un_cdata.uncd_tx_bufsz = IP_MAXPACKET + 663 ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN + 664 sizeof(struct axen_sframe_hdr); 665 666 /* Find endpoints. */ 667 id = usbd_get_interface_descriptor(un->un_iface); 668 for (i = 0; i < id->bNumEndpoints; i++) { 669 ed = usbd_interface2endpoint_descriptor(un->un_iface, i); 670 if (!ed) { 671 aprint_error_dev(self, "couldn't get ep %d\n", i); 672 return; 673 } 674 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 675 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 676 un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress; 677 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 678 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 679 un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress; 680 #if 0 /* not used yet */ 681 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 682 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 683 un->un_ed[USBNET_ENDPT_INTR] = ed->bEndpointAddress; 684 #endif 685 } 686 } 687 688 /* Set these up now for axen_cmd(). */ 689 usbnet_attach(un, "axendet", AXEN_RX_LIST_CNT, AXEN_TX_LIST_CNT); 690 691 un->un_phyno = AXEN_PHY_ID; 692 DPRINTF(("%s: phyno %d\n", device_xname(self), un->un_phyno)); 693 694 /* Get station address. */ 695 usbnet_lock_mii(un); 696 if (axen_get_eaddr(sc, &un->un_eaddr)) { 697 usbnet_unlock_mii(un); 698 printf("EEPROM checksum error\n"); 699 return; 700 } 701 usbnet_unlock_mii(un); 702 703 axen_ax88179_init(sc); 704 705 /* An ASIX chip was detected. Inform the world. */ 706 if (axen_flags & AX178A) 707 aprint_normal_dev(self, "AX88178a\n"); 708 else if (axen_flags & AX179) 709 aprint_normal_dev(self, "AX88179\n"); 710 else 711 aprint_normal_dev(self, "(unknown)\n"); 712 aprint_normal_dev(self, "Ethernet address %s\n", 713 ether_sprintf(un->un_eaddr)); 714 715 struct ifnet *ifp = usbnet_ifp(un); 716 un->un_ec.ec_capabilities = ETHERCAP_VLAN_MTU; 717 718 /* Adapter does not support TSOv6 (They call it LSOv2). */ 719 ifp->if_capabilities |= IFCAP_TSOv4 | 720 IFCAP_CSUM_IPv4_Rx | IFCAP_CSUM_IPv4_Tx | 721 IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv4_Tx | 722 IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv4_Tx | 723 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_TCPv6_Tx | 724 IFCAP_CSUM_UDPv6_Rx | IFCAP_CSUM_UDPv6_Tx; 725 726 usbnet_attach_ifp(un, true, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST, 727 0); 728 } 729 730 static int 731 axen_csum_flags_rx(struct ifnet *ifp, uint32_t pkt_hdr) 732 { 733 int enabled_flags = ifp->if_csum_flags_rx; 734 int csum_flags = 0; 735 int l3_type, l4_type; 736 737 if (enabled_flags == 0) 738 return 0; 739 740 l3_type = (pkt_hdr & AXEN_RXHDR_L3_TYPE_MASK) >> 741 AXEN_RXHDR_L3_TYPE_OFFSET; 742 743 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4) 744 csum_flags |= M_CSUM_IPv4; 745 746 l4_type = (pkt_hdr & AXEN_RXHDR_L4_TYPE_MASK) >> 747 AXEN_RXHDR_L4_TYPE_OFFSET; 748 749 switch (l4_type) { 750 case AXEN_RXHDR_L4_TYPE_TCP: 751 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4) 752 csum_flags |= M_CSUM_TCPv4; 753 else 754 csum_flags |= M_CSUM_TCPv6; 755 break; 756 case AXEN_RXHDR_L4_TYPE_UDP: 757 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4) 758 csum_flags |= M_CSUM_UDPv4; 759 else 760 csum_flags |= M_CSUM_UDPv6; 761 break; 762 default: 763 break; 764 } 765 766 csum_flags &= enabled_flags; 767 if ((csum_flags & M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L3CSUM_ERR)) 768 csum_flags |= M_CSUM_IPv4_BAD; 769 if ((csum_flags & ~M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L4CSUM_ERR)) 770 csum_flags |= M_CSUM_TCP_UDP_BAD; 771 772 return csum_flags; 773 } 774 775 static void 776 axen_rxeof_loop(struct usbnet * un, struct usbd_xfer *xfer, 777 struct usbnet_chain *c, uint32_t total_len) 778 { 779 struct ifnet *ifp = usbnet_ifp(un); 780 uint8_t *buf = c->unc_buf; 781 uint32_t rx_hdr, pkt_hdr; 782 uint32_t *hdr_p; 783 uint16_t hdr_offset, pkt_count; 784 size_t pkt_len; 785 size_t temp; 786 787 KASSERT(mutex_owned(&un->un_rxlock)); 788 789 if (total_len < sizeof(pkt_hdr)) { 790 aprint_error_dev(un->un_dev, "rxeof: too short transfer\n"); 791 ifp->if_ierrors++; 792 return; 793 } 794 795 /* 796 * buffer map 797 * [packet #0]...[packet #n][pkt hdr#0]..[pkt hdr#n][recv_hdr] 798 * each packet has 0xeeee as psuedo header.. 799 */ 800 hdr_p = (uint32_t *)(buf + total_len - sizeof(uint32_t)); 801 rx_hdr = le32toh(*hdr_p); 802 hdr_offset = (uint16_t)(rx_hdr >> 16); 803 pkt_count = (uint16_t)(rx_hdr & 0xffff); 804 805 /* sanity check */ 806 if (hdr_offset > total_len) { 807 aprint_error_dev(un->un_dev, 808 "rxeof: invalid hdr offset (%u > %u)\n", 809 hdr_offset, total_len); 810 ifp->if_ierrors++; 811 usbd_delay_ms(un->un_udev, 100); 812 return; 813 } 814 815 /* point first packet header */ 816 hdr_p = (uint32_t *)(buf + hdr_offset); 817 818 /* 819 * ax88179 will pack multiple ip packet to a USB transaction. 820 * process all of packets in the buffer 821 */ 822 823 #if 1 /* XXX: paranoiac check. need to remove later */ 824 #define AXEN_MAX_PACKED_PACKET 200 825 if (pkt_count > AXEN_MAX_PACKED_PACKET) { 826 DPRINTF(("%s: Too many packets (%d) in a transaction, discard.\n", 827 device_xname(un->un_dev), pkt_count)); 828 return; 829 } 830 #endif 831 832 if (pkt_count) 833 rnd_add_uint32(&un->un_rndsrc, pkt_count); 834 835 do { 836 if ((buf[0] != 0xee) || (buf[1] != 0xee)) { 837 aprint_error_dev(un->un_dev, 838 "invalid buffer(pkt#%d), continue\n", pkt_count); 839 ifp->if_ierrors += pkt_count; 840 return; 841 } 842 843 pkt_hdr = le32toh(*hdr_p); 844 pkt_len = (pkt_hdr >> 16) & 0x1fff; 845 DPRINTFN(10, 846 ("%s: rxeof: packet#%d, pkt_hdr 0x%08x, pkt_len %zu\n", 847 device_xname(un->un_dev), pkt_count, pkt_hdr, pkt_len)); 848 849 if (pkt_hdr & (AXEN_RXHDR_CRC_ERR | AXEN_RXHDR_DROP_ERR)) { 850 ifp->if_ierrors++; 851 /* move to next pkt header */ 852 DPRINTF(("%s: %s err (pkt#%d)\n", 853 device_xname(un->un_dev), 854 (pkt_hdr & AXEN_RXHDR_CRC_ERR) ? "crc" : "drop", 855 pkt_count)); 856 goto nextpkt; 857 } 858 859 usbnet_enqueue(un, buf + 2, pkt_len - 6, 860 axen_csum_flags_rx(ifp, pkt_hdr)); 861 862 nextpkt: 863 /* 864 * prepare next packet 865 * as each packet will be aligned 8byte boundary, 866 * need to fix up the start point of the buffer. 867 */ 868 temp = ((pkt_len + 7) & 0xfff8); 869 buf = buf + temp; 870 hdr_p++; 871 pkt_count--; 872 } while (pkt_count > 0); 873 } 874 875 static unsigned 876 axen_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c) 877 { 878 struct axen_sframe_hdr hdr; 879 u_int length, boundary; 880 881 KASSERT(mutex_owned(&un->un_txlock)); 882 883 /* XXX Is this needed? wMaxPacketSize? */ 884 switch (un->un_udev->ud_speed) { 885 case USB_SPEED_SUPER: 886 boundary = 4096; 887 break; 888 case USB_SPEED_HIGH: 889 boundary = 512; 890 break; 891 default: 892 boundary = 64; 893 break; 894 } 895 896 length = m->m_pkthdr.len + sizeof(hdr); 897 KASSERT(length <= un->un_cdata.uncd_tx_bufsz); 898 899 hdr.plen = htole32(m->m_pkthdr.len); 900 901 hdr.gso = (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) ? 902 m->m_pkthdr.segsz : 0; 903 if ((length % boundary) == 0) { 904 DPRINTF(("%s: boundary hit\n", device_xname(un->un_dev))); 905 hdr.gso |= 0x80008000; /* XXX enable padding */ 906 } 907 hdr.gso = htole32(hdr.gso); 908 909 memcpy(c->unc_buf, &hdr, sizeof(hdr)); 910 m_copydata(m, 0, m->m_pkthdr.len, c->unc_buf + sizeof(hdr)); 911 912 return length; 913 } 914 915 static int 916 axen_init_locked(struct ifnet *ifp) 917 { 918 struct usbnet * const un = ifp->if_softc; 919 struct axen_softc * const sc = un->un_sc; 920 uint16_t rxmode; 921 uint16_t wval; 922 uint8_t bval; 923 924 KASSERT(mutex_owned(&un->un_lock)); 925 926 if (un->un_dying) 927 return EIO; 928 929 /* Cancel pending I/O */ 930 usbnet_stop(un, ifp, 1); 931 932 /* Reset the ethernet interface. */ 933 axen_reset(sc); 934 935 usbnet_lock_mii_un_locked(un); 936 937 /* XXX: ? */ 938 bval = 0x01; 939 axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_UNK_28, &bval); 940 941 /* Configure offloading engine. */ 942 axen_setoe_locked(un); 943 944 /* Program promiscuous mode and multicast filters. */ 945 axen_setiff_locked(un); 946 947 /* Enable receiver, set RX mode */ 948 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval); 949 rxmode = le16toh(wval); 950 rxmode |= AXEN_RXCTL_START; 951 wval = htole16(rxmode); 952 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 953 954 usbnet_unlock_mii_un_locked(un); 955 956 return usbnet_init_rx_tx(un, 0, 0); 957 } 958 959 static int 960 axen_init(struct ifnet *ifp) 961 { 962 struct usbnet * const un = ifp->if_softc; 963 964 mutex_enter(&un->un_lock); 965 int ret = axen_init_locked(ifp); 966 mutex_exit(&un->un_lock); 967 968 return ret; 969 } 970 971 /* 972 * Stop the adapter and free any mbufs allocated to the 973 * RX and TX lists. 974 */ 975 static void 976 axen_stop_cb(struct ifnet *ifp, int disable) 977 { 978 struct usbnet * const un = ifp->if_softc; 979 struct axen_softc * const sc = un->un_sc; 980 uint16_t rxmode, wval; 981 982 axen_reset(sc); 983 984 /* Disable receiver, set RX mode */ 985 usbnet_lock_mii_un_locked(un); 986 axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval); 987 rxmode = le16toh(wval); 988 rxmode &= ~AXEN_RXCTL_START; 989 wval = htole16(rxmode); 990 axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval); 991 usbnet_unlock_mii_un_locked(un); 992 } 993 994 MODULE(MODULE_CLASS_DRIVER, if_axen, "usbnet"); 995 996 #ifdef _MODULE 997 #include "ioconf.c" 998 #endif 999 1000 static int 1001 if_axen_modcmd(modcmd_t cmd, void *aux) 1002 { 1003 int error = 0; 1004 1005 switch (cmd) { 1006 case MODULE_CMD_INIT: 1007 #ifdef _MODULE 1008 error = config_init_component(cfdriver_ioconf_axen, 1009 cfattach_ioconf_axen, cfdata_ioconf_axen); 1010 #endif 1011 return error; 1012 case MODULE_CMD_FINI: 1013 #ifdef _MODULE 1014 error = config_fini_component(cfdriver_ioconf_axen, 1015 cfattach_ioconf_axen, cfdata_ioconf_axen); 1016 #endif 1017 return error; 1018 default: 1019 return ENOTTY; 1020 } 1021 } 1022
Indexes created Tue Oct 14 06:10:07 GMT 2025