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