if_axe.c revision 184610
1/*- 2 * Copyright (c) 1997, 1998, 1999, 2000-2003 3 * Bill Paul <wpaul@windriver.com>. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Bill Paul. 16 * 4. Neither the name of the author nor the names of any co-contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 30 * THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33#include <sys/cdefs.h> 34__FBSDID("$FreeBSD: head/sys/dev/usb2/ethernet/if_axe2.c 184610 2008-11-04 02:31:03Z alfred $"); 35 36/* 37 * ASIX Electronics AX88172/AX88178/AX88778 USB 2.0 ethernet driver. Used in the 38 * LinkSys USB200M and various other adapters. 39 * 40 * Manuals available from: 41 * http://www.asix.com.tw/datasheet/mac/Ax88172.PDF 42 * Note: you need the manual for the AX88170 chip (USB 1.x ethernet 43 * controller) to find the definitions for the RX control register. 44 * http://www.asix.com.tw/datasheet/mac/Ax88170.PDF 45 * 46 * Written by Bill Paul <wpaul@windriver.com> 47 * Senior Engineer 48 * Wind River Systems 49 */ 50 51/* 52 * The AX88172 provides USB ethernet supports at 10 and 100Mbps. 53 * It uses an external PHY (reference designs use a RealTek chip), 54 * and has a 64-bit multicast hash filter. There is some information 55 * missing from the manual which one needs to know in order to make 56 * the chip function: 57 * 58 * - You must set bit 7 in the RX control register, otherwise the 59 * chip won't receive any packets. 60 * - You must initialize all 3 IPG registers, or you won't be able 61 * to send any packets. 62 * 63 * Note that this device appears to only support loading the station 64 * address via autload from the EEPROM (i.e. there's no way to manaully 65 * set it). 66 * 67 * (Adam Weinberger wanted me to name this driver if_gir.c.) 68 */ 69 70/* 71 * Ax88178 and Ax88772 support backported from the OpenBSD driver. 72 * 2007/02/12, J.R. Oldroyd, fbsd@opal.com 73 * 74 * Manual here: 75 * http://www.asix.com.tw/FrootAttach/datasheet/AX88178_datasheet_Rev10.pdf 76 * http://www.asix.com.tw/FrootAttach/datasheet/AX88772_datasheet_Rev10.pdf 77 */ 78 79/* 80 * NOTE: all function names beginning like "axe_cfg_" can only 81 * be called from within the config thread function ! 82 */ 83 84#include <dev/usb2/include/usb2_devid.h> 85#include <dev/usb2/include/usb2_standard.h> 86#include <dev/usb2/include/usb2_mfunc.h> 87#include <dev/usb2/include/usb2_error.h> 88 89#define usb2_config_td_cc usb2_ether_cc 90#define usb2_config_td_softc axe_softc 91 92#define USB_DEBUG_VAR axe_debug 93 94#include <dev/usb2/core/usb2_core.h> 95#include <dev/usb2/core/usb2_lookup.h> 96#include <dev/usb2/core/usb2_process.h> 97#include <dev/usb2/core/usb2_config_td.h> 98#include <dev/usb2/core/usb2_debug.h> 99#include <dev/usb2/core/usb2_request.h> 100#include <dev/usb2/core/usb2_busdma.h> 101#include <dev/usb2/core/usb2_util.h> 102 103#include <dev/usb2/ethernet/usb2_ethernet.h> 104#include <dev/usb2/ethernet/if_axe2_reg.h> 105 106MODULE_DEPEND(axe, usb2_ethernet, 1, 1, 1); 107MODULE_DEPEND(axe, usb2_core, 1, 1, 1); 108MODULE_DEPEND(axe, ether, 1, 1, 1); 109MODULE_DEPEND(axe, miibus, 1, 1, 1); 110 111#if USB_DEBUG 112static int axe_debug = 0; 113 114SYSCTL_NODE(_hw_usb2, OID_AUTO, axe, CTLFLAG_RW, 0, "USB axe"); 115SYSCTL_INT(_hw_usb2_axe, OID_AUTO, debug, CTLFLAG_RW, &axe_debug, 0, 116 "Debug level"); 117#endif 118 119/* 120 * Various supported device vendors/products. 121 */ 122static const struct usb2_device_id axe_devs[] = { 123 {USB_VPI(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_UF200, 0)}, 124 {USB_VPI(USB_VENDOR_ACERCM, USB_PRODUCT_ACERCM_EP1427X2, 0)}, 125 {USB_VPI(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_ETHERNET, AXE_FLAG_772)}, 126 {USB_VPI(USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88172, 0)}, 127 {USB_VPI(USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88178, AXE_FLAG_178)}, 128 {USB_VPI(USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88772, AXE_FLAG_772)}, 129 {USB_VPI(USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC210T, 0)}, 130 {USB_VPI(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5D5055, AXE_FLAG_178)}, 131 {USB_VPI(USB_VENDOR_BILLIONTON, USB_PRODUCT_BILLIONTON_USB2AR, 0)}, 132 {USB_VPI(USB_VENDOR_CISCOLINKSYS, USB_PRODUCT_CISCOLINKSYS_USB200MV2, AXE_FLAG_772)}, 133 {USB_VPI(USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB2_TX, 0)}, 134 {USB_VPI(USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DUBE100, 0)}, 135 {USB_VPI(USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DUBE100B1, AXE_FLAG_772)}, 136 {USB_VPI(USB_VENDOR_GOODWAY, USB_PRODUCT_GOODWAY_GWUSB2E, 0)}, 137 {USB_VPI(USB_VENDOR_IODATA, USB_PRODUCT_IODATA_ETGUS2, AXE_FLAG_178)}, 138 {USB_VPI(USB_VENDOR_JVC, USB_PRODUCT_JVC_MP_PRX1, 0)}, 139 {USB_VPI(USB_VENDOR_LINKSYS2, USB_PRODUCT_LINKSYS2_USB200M, 0)}, 140 {USB_VPI(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_USB1000, AXE_FLAG_178)}, 141 {USB_VPI(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAU2KTX, 0)}, 142 {USB_VPI(USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_FA120, 0)}, 143 {USB_VPI(USB_VENDOR_OQO, USB_PRODUCT_OQO_ETHER01PLUS, AXE_FLAG_772)}, 144 {USB_VPI(USB_VENDOR_PLANEX3, USB_PRODUCT_PLANEX3_GU1000T, AXE_FLAG_178)}, 145 {USB_VPI(USB_VENDOR_SITECOM, USB_PRODUCT_SITECOM_LN029, 0)}, 146 {USB_VPI(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_LN028, AXE_FLAG_178)}, 147 {USB_VPI(USB_VENDOR_SYSTEMTALKS, USB_PRODUCT_SYSTEMTALKS_SGCX2UL, 0)}, 148}; 149 150static device_probe_t axe_probe; 151static device_attach_t axe_attach; 152static device_detach_t axe_detach; 153static device_shutdown_t axe_shutdown; 154 155static usb2_callback_t axe_intr_clear_stall_callback; 156static usb2_callback_t axe_intr_callback; 157static usb2_callback_t axe_bulk_read_clear_stall_callback; 158static usb2_callback_t axe_bulk_read_callback; 159static usb2_callback_t axe_bulk_write_clear_stall_callback; 160static usb2_callback_t axe_bulk_write_callback; 161 162static void axe_cfg_cmd(struct axe_softc *sc, uint16_t cmd, uint16_t index, uint16_t val, void *buf); 163 164static miibus_readreg_t axe_cfg_miibus_readreg; 165static miibus_writereg_t axe_cfg_miibus_writereg; 166static miibus_statchg_t axe_cfg_miibus_statchg; 167 168static usb2_config_td_command_t axe_cfg_ifmedia_upd; 169static usb2_config_td_command_t axe_config_copy; 170static usb2_config_td_command_t axe_cfg_setmulti; 171static usb2_config_td_command_t axe_cfg_first_time_setup; 172static usb2_config_td_command_t axe_cfg_tick; 173static usb2_config_td_command_t axe_cfg_pre_init; 174static usb2_config_td_command_t axe_cfg_init; 175static usb2_config_td_command_t axe_cfg_promisc_upd; 176static usb2_config_td_command_t axe_cfg_pre_stop; 177static usb2_config_td_command_t axe_cfg_stop; 178 179static int axe_ifmedia_upd_cb(struct ifnet *ifp); 180static void axe_ifmedia_sts_cb(struct ifnet *ifp, struct ifmediareq *ifmr); 181static void axe_cfg_reset(struct axe_softc *sc); 182static void axe_start_cb(struct ifnet *ifp); 183static void axe_start_transfers(struct axe_softc *sc); 184static void axe_init_cb(void *arg); 185static int axe_ioctl_cb(struct ifnet *ifp, u_long command, caddr_t data); 186static void axe_watchdog(void *arg); 187static void axe_cfg_ax88178_init(struct axe_softc *); 188static void axe_cfg_ax88772_init(struct axe_softc *); 189 190static const struct usb2_config axe_config[AXE_ENDPT_MAX] = { 191 192 [0] = { 193 .type = UE_BULK, 194 .endpoint = UE_ADDR_ANY, 195 .direction = UE_DIR_OUT, 196 .mh.bufsize = AXE_BULK_BUF_SIZE, 197 .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 198 .mh.callback = &axe_bulk_write_callback, 199 .mh.timeout = 10000, /* 10 seconds */ 200 }, 201 202 [1] = { 203 .type = UE_BULK, 204 .endpoint = UE_ADDR_ANY, 205 .direction = UE_DIR_IN, 206#if (MCLBYTES < 2048) 207#error "(MCLBYTES < 2048)" 208#endif 209 .mh.bufsize = MCLBYTES, 210 .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 211 .mh.callback = &axe_bulk_read_callback, 212 .mh.timeout = 0, /* no timeout */ 213 }, 214 215 [2] = { 216 .type = UE_CONTROL, 217 .endpoint = 0x00, /* Control pipe */ 218 .direction = UE_DIR_ANY, 219 .mh.bufsize = sizeof(struct usb2_device_request), 220 .mh.flags = {}, 221 .mh.callback = &axe_bulk_write_clear_stall_callback, 222 .mh.timeout = 1000, /* 1 second */ 223 .mh.interval = 50, /* 50ms */ 224 }, 225 226 [3] = { 227 .type = UE_CONTROL, 228 .endpoint = 0x00, /* Control pipe */ 229 .direction = UE_DIR_ANY, 230 .mh.bufsize = sizeof(struct usb2_device_request), 231 .mh.flags = {}, 232 .mh.callback = &axe_bulk_read_clear_stall_callback, 233 .mh.timeout = 1000, /* 1 second */ 234 .mh.interval = 50, /* 50ms */ 235 }, 236 237 [4] = { 238 .type = UE_INTERRUPT, 239 .endpoint = UE_ADDR_ANY, 240 .direction = UE_DIR_IN, 241 .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 242 .mh.bufsize = 0, /* use wMaxPacketSize */ 243 .mh.callback = &axe_intr_callback, 244 }, 245 246 [5] = { 247 .type = UE_CONTROL, 248 .endpoint = 0x00, /* Control pipe */ 249 .direction = UE_DIR_ANY, 250 .mh.bufsize = sizeof(struct usb2_device_request), 251 .mh.flags = {}, 252 .mh.callback = &axe_intr_clear_stall_callback, 253 .mh.timeout = 1000, /* 1 second */ 254 .mh.interval = 50, /* 50ms */ 255 }, 256}; 257 258static device_method_t axe_methods[] = { 259 /* Device interface */ 260 DEVMETHOD(device_probe, axe_probe), 261 DEVMETHOD(device_attach, axe_attach), 262 DEVMETHOD(device_detach, axe_detach), 263 DEVMETHOD(device_shutdown, axe_shutdown), 264 265 /* bus interface */ 266 DEVMETHOD(bus_print_child, bus_generic_print_child), 267 DEVMETHOD(bus_driver_added, bus_generic_driver_added), 268 269 /* MII interface */ 270 DEVMETHOD(miibus_readreg, axe_cfg_miibus_readreg), 271 DEVMETHOD(miibus_writereg, axe_cfg_miibus_writereg), 272 DEVMETHOD(miibus_statchg, axe_cfg_miibus_statchg), 273 274 {0, 0} 275}; 276 277static driver_t axe_driver = { 278 .name = "axe", 279 .methods = axe_methods, 280 .size = sizeof(struct axe_softc), 281}; 282 283static devclass_t axe_devclass; 284 285DRIVER_MODULE(axe, ushub, axe_driver, axe_devclass, NULL, 0); 286DRIVER_MODULE(miibus, axe, miibus_driver, miibus_devclass, 0, 0); 287 288static void 289axe_cfg_cmd(struct axe_softc *sc, uint16_t cmd, uint16_t index, 290 uint16_t val, void *buf) 291{ 292 struct usb2_device_request req; 293 usb2_error_t err; 294 uint16_t length = AXE_CMD_LEN(cmd); 295 296 req.bmRequestType = (AXE_CMD_IS_WRITE(cmd) ? 297 UT_WRITE_VENDOR_DEVICE : 298 UT_READ_VENDOR_DEVICE); 299 req.bRequest = AXE_CMD_CMD(cmd); 300 USETW(req.wValue, val); 301 USETW(req.wIndex, index); 302 USETW(req.wLength, length); 303 304 if (usb2_config_td_is_gone(&sc->sc_config_td)) { 305 goto error; 306 } 307 err = usb2_do_request_flags 308 (sc->sc_udev, &sc->sc_mtx, &req, buf, 0, NULL, 1000); 309 310 if (err) { 311 312 DPRINTFN(0, "device request failed, err=%s " 313 "(ignored)\n", usb2_errstr(err)); 314 315error: 316 317 if ((req.bmRequestType & UT_READ) && length) { 318 bzero(buf, length); 319 } 320 } 321 return; 322} 323 324static int 325axe_cfg_miibus_readreg(device_t dev, int phy, int reg) 326{ 327 struct axe_softc *sc = device_get_softc(dev); 328 uint16_t val; 329 uint8_t do_unlock; 330 331 /* avoid recursive locking */ 332 if (mtx_owned(&sc->sc_mtx)) { 333 do_unlock = 0; 334 } else { 335 mtx_lock(&sc->sc_mtx); 336 do_unlock = 1; 337 } 338 339#if 0 340 /* 341 * The chip tells us the MII address of any supported 342 * PHYs attached to the chip, so only read from those. 343 */ 344 345 if ((sc->sc_phyaddrs[0] != AXE_NOPHY) && (phy != sc->sc_phyaddrs[0])) { 346 val = 0; 347 goto done; 348 } 349 if ((sc->sc_phyaddrs[1] != AXE_NOPHY) && (phy != sc->sc_phyaddrs[1])) { 350 val = 0; 351 goto done; 352 } 353#endif 354 if ((sc->sc_phyaddrs[0] != 0xFF) && (sc->sc_phyaddrs[0] != phy)) { 355 val = 0; 356 goto done; 357 } 358 axe_cfg_cmd(sc, AXE_CMD_MII_OPMODE_SW, 0, 0, NULL); 359 axe_cfg_cmd(sc, AXE_CMD_MII_READ_REG, reg, phy, &val); 360 axe_cfg_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL); 361 362 val = le16toh(val); 363 364 if (val && (val != 0xffff)) { 365 sc->sc_phyaddrs[0] = phy; 366 } 367done: 368 if (do_unlock) { 369 mtx_unlock(&sc->sc_mtx); 370 } 371 return (val); 372} 373 374static int 375axe_cfg_miibus_writereg(device_t dev, int phy, int reg, int val) 376{ 377 struct axe_softc *sc = device_get_softc(dev); 378 uint8_t do_unlock; 379 380 val = htole16(val); 381 382 /* avoid recursive locking */ 383 if (mtx_owned(&sc->sc_mtx)) { 384 do_unlock = 0; 385 } else { 386 mtx_lock(&sc->sc_mtx); 387 do_unlock = 1; 388 } 389 390 axe_cfg_cmd(sc, AXE_CMD_MII_OPMODE_SW, 0, 0, NULL); 391 axe_cfg_cmd(sc, AXE_CMD_MII_WRITE_REG, reg, phy, &val); 392 axe_cfg_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL); 393 394 if (do_unlock) { 395 mtx_unlock(&sc->sc_mtx); 396 } 397 return (0); 398} 399 400static void 401axe_cfg_miibus_statchg(device_t dev) 402{ 403 struct axe_softc *sc = device_get_softc(dev); 404 struct mii_data *mii = GET_MII(sc); 405 uint16_t val; 406 uint8_t do_unlock; 407 408 /* avoid recursive locking */ 409 if (mtx_owned(&sc->sc_mtx)) { 410 do_unlock = 0; 411 } else { 412 mtx_lock(&sc->sc_mtx); 413 do_unlock = 1; 414 } 415 416 if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) 417 val = AXE_MEDIA_FULL_DUPLEX; 418 else 419 val = 0; 420 421 if (sc->sc_flags & (AXE_FLAG_772 | AXE_FLAG_178)) { 422 423 val |= (AXE_178_MEDIA_RX_EN | AXE_178_MEDIA_MAGIC); 424 425 switch (IFM_SUBTYPE(mii->mii_media_active)) { 426 case IFM_1000_T: 427 val |= AXE_178_MEDIA_GMII | AXE_178_MEDIA_ENCK; 428 break; 429 case IFM_100_TX: 430 val |= AXE_178_MEDIA_100TX; 431 break; 432 case IFM_10_T: 433 /* doesn't need to be handled */ 434 break; 435 } 436 } 437 axe_cfg_cmd(sc, AXE_CMD_WRITE_MEDIA, 0, val, NULL); 438 if (do_unlock) { 439 mtx_unlock(&sc->sc_mtx); 440 } 441 return; 442} 443 444/* 445 * Set media options. 446 */ 447static int 448axe_ifmedia_upd_cb(struct ifnet *ifp) 449{ 450 struct axe_softc *sc = ifp->if_softc; 451 452 mtx_lock(&sc->sc_mtx); 453 usb2_config_td_queue_command 454 (&sc->sc_config_td, NULL, &axe_cfg_ifmedia_upd, 0, 0); 455 mtx_unlock(&sc->sc_mtx); 456 457 return (0); 458} 459 460static void 461axe_cfg_ifmedia_upd(struct axe_softc *sc, 462 struct usb2_config_td_cc *cc, uint16_t refcount) 463{ 464 struct ifnet *ifp = sc->sc_ifp; 465 struct mii_data *mii = GET_MII(sc); 466 467 if ((ifp == NULL) || 468 (mii == NULL)) { 469 /* not ready */ 470 return; 471 } 472 sc->sc_flags |= AXE_FLAG_WAIT_LINK; 473 474 if (mii->mii_instance) { 475 struct mii_softc *miisc; 476 477 LIST_FOREACH(miisc, &mii->mii_phys, mii_list) { 478 mii_phy_reset(miisc); 479 } 480 } 481 mii_mediachg(mii); 482 483 return; 484} 485 486/* 487 * Report current media status. 488 */ 489static void 490axe_ifmedia_sts_cb(struct ifnet *ifp, struct ifmediareq *ifmr) 491{ 492 struct axe_softc *sc = ifp->if_softc; 493 494 mtx_lock(&sc->sc_mtx); 495 ifmr->ifm_active = sc->sc_media_active; 496 ifmr->ifm_status = sc->sc_media_status; 497 mtx_unlock(&sc->sc_mtx); 498 499 return; 500} 501 502static void 503axe_mchash(struct usb2_config_td_cc *cc, const uint8_t *ptr) 504{ 505 uint8_t h; 506 507 h = (ether_crc32_be(ptr, ETHER_ADDR_LEN) >> 26); 508 cc->if_hash[(h >> 3)] |= (1 << (h & 7)); 509 return; 510} 511 512static void 513axe_config_copy(struct axe_softc *sc, 514 struct usb2_config_td_cc *cc, uint16_t refcount) 515{ 516 bzero(cc, sizeof(*cc)); 517 usb2_ether_cc(sc->sc_ifp, &axe_mchash, cc); 518 return; 519} 520 521static void 522axe_cfg_setmulti(struct axe_softc *sc, 523 struct usb2_config_td_cc *cc, uint16_t refcount) 524{ 525 uint16_t rxmode; 526 527 axe_cfg_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, &rxmode); 528 529 rxmode = le16toh(rxmode); 530 531 if (cc->if_flags & (IFF_ALLMULTI | IFF_PROMISC)) { 532 rxmode |= AXE_RXCMD_ALLMULTI; 533 axe_cfg_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL); 534 return; 535 } 536 rxmode &= ~AXE_RXCMD_ALLMULTI; 537 538 axe_cfg_cmd(sc, AXE_CMD_WRITE_MCAST, 0, 0, cc->if_hash); 539 axe_cfg_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL); 540 541 return; 542} 543 544static void 545axe_cfg_reset(struct axe_softc *sc) 546{ 547 struct usb2_config_descriptor *cd; 548 usb2_error_t err; 549 550 cd = usb2_get_config_descriptor(sc->sc_udev); 551 552 err = usb2_req_set_config(sc->sc_udev, &sc->sc_mtx, 553 cd->bConfigurationValue); 554 if (err) { 555 DPRINTF("reset failed (ignored)\n"); 556 } 557 /* 558 * wait a little while for the chip to get its brains in order: 559 */ 560 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 100); 561 562 return; 563} 564 565/* 566 * Probe for a AX88172 chip. 567 */ 568static int 569axe_probe(device_t dev) 570{ 571 struct usb2_attach_arg *uaa = device_get_ivars(dev); 572 573 if (uaa->usb2_mode != USB_MODE_HOST) { 574 return (ENXIO); 575 } 576 if (uaa->info.bConfigIndex != AXE_CONFIG_IDX) { 577 return (ENXIO); 578 } 579 if (uaa->info.bIfaceIndex != AXE_IFACE_IDX) { 580 return (ENXIO); 581 } 582 return (usb2_lookup_id_by_uaa(axe_devs, sizeof(axe_devs), uaa)); 583} 584 585/* 586 * Attach the interface. Allocate softc structures, do ifmedia 587 * setup and ethernet/BPF attach. 588 */ 589static int 590axe_attach(device_t dev) 591{ 592 struct usb2_attach_arg *uaa = device_get_ivars(dev); 593 struct axe_softc *sc = device_get_softc(dev); 594 int32_t error; 595 uint8_t iface_index; 596 597 if (sc == NULL) { 598 return (ENOMEM); 599 } 600 sc->sc_udev = uaa->device; 601 sc->sc_dev = dev; 602 sc->sc_unit = device_get_unit(dev); 603 sc->sc_flags = USB_GET_DRIVER_INFO(uaa); 604 605 device_set_usb2_desc(dev); 606 607 snprintf(sc->sc_name, sizeof(sc->sc_name), "%s", 608 device_get_nameunit(dev)); 609 610 mtx_init(&sc->sc_mtx, "axe lock", NULL, MTX_DEF | MTX_RECURSE); 611 612 usb2_callout_init_mtx(&sc->sc_watchdog, 613 &sc->sc_mtx, CALLOUT_RETURNUNLOCKED); 614 615 iface_index = AXE_IFACE_IDX; 616 error = usb2_transfer_setup(uaa->device, &iface_index, 617 sc->sc_xfer, axe_config, AXE_ENDPT_MAX, 618 sc, &sc->sc_mtx); 619 if (error) { 620 device_printf(dev, "allocating USB " 621 "transfers failed!\n"); 622 goto detach; 623 } 624 error = usb2_config_td_setup(&sc->sc_config_td, sc, &sc->sc_mtx, 625 NULL, sizeof(struct usb2_config_td_cc), 16); 626 if (error) { 627 device_printf(dev, "could not setup config " 628 "thread!\n"); 629 goto detach; 630 } 631 mtx_lock(&sc->sc_mtx); 632 633 sc->sc_flags |= AXE_FLAG_WAIT_LINK; 634 635 /* start setup */ 636 637 usb2_config_td_queue_command 638 (&sc->sc_config_td, NULL, &axe_cfg_first_time_setup, 0, 0); 639 640 /* start watchdog (will exit mutex) */ 641 642 axe_watchdog(sc); 643 644 return (0); /* success */ 645 646detach: 647 axe_detach(dev); 648 return (ENXIO); /* failure */ 649} 650 651static void 652axe_cfg_ax88178_init(struct axe_softc *sc) 653{ 654 uint16_t eeprom; 655 uint16_t phymode; 656 uint16_t gpio0; 657 uint8_t err; 658 659 DPRINTF("\n"); 660 661 axe_cfg_cmd(sc, AXE_CMD_SROM_WR_ENABLE, 0, 0, NULL); 662 /* XXX magic */ 663 axe_cfg_cmd(sc, AXE_CMD_SROM_READ, 0, 0x0017, &eeprom); 664 axe_cfg_cmd(sc, AXE_CMD_SROM_WR_DISABLE, 0, 0, NULL); 665 666 /* For big-endian machines: */ 667 eeprom = le16toh(eeprom); 668 669 /* if EEPROM is invalid we have to use to GPIO0 */ 670 if (eeprom == 0xffff) { 671 phymode = 0; 672 gpio0 = 1; 673 } else { 674 phymode = (eeprom & 7); 675 gpio0 = (eeprom & 0x80) ? 0 : 1; 676 } 677 678 axe_cfg_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x008c, NULL); 679 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 16); 680 681 if ((eeprom >> 8) != 0x01) { 682 axe_cfg_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL); 683 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 32); 684 685 axe_cfg_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x001c, NULL); 686 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 3); 687 688 axe_cfg_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL); 689 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 32); 690 } else { 691 axe_cfg_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x0004, NULL); 692 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 32); 693 694 axe_cfg_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x000c, NULL); 695 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 32); 696 } 697 698 /* soft reset */ 699 axe_cfg_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL); 700 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 4); 701 702 axe_cfg_cmd(sc, AXE_CMD_SW_RESET_REG, 0, 703 AXE_SW_RESET_PRL | AXE_178_RESET_MAGIC, NULL); 704 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 4); 705 706 axe_cfg_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL); 707 return; 708} 709 710static void 711axe_cfg_ax88772_init(struct axe_softc *sc) 712{ 713 uint8_t err; 714 715 DPRINTF("\n"); 716 717 axe_cfg_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x00b0, NULL); 718 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 16); 719 720 if (sc->sc_phyaddrs[1] == AXE_INTPHY) { 721 /* ask for the embedded PHY */ 722 axe_cfg_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x01, NULL); 723 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 64); 724 725 /* power down and reset state, pin reset state */ 726 axe_cfg_cmd(sc, AXE_CMD_SW_RESET_REG, 0, 727 AXE_SW_RESET_CLEAR, NULL); 728 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 16); 729 730 /* power down/reset state, pin operating state */ 731 axe_cfg_cmd(sc, AXE_CMD_SW_RESET_REG, 0, 732 AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL); 733 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 4); 734 735 /* power up, reset */ 736 axe_cfg_cmd(sc, AXE_CMD_SW_RESET_REG, 0, 737 AXE_SW_RESET_PRL, NULL); 738 739 /* power up, operating */ 740 axe_cfg_cmd(sc, AXE_CMD_SW_RESET_REG, 0, 741 AXE_SW_RESET_IPRL | AXE_SW_RESET_PRL, NULL); 742 } else { 743 /* ask for external PHY */ 744 axe_cfg_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x00, NULL); 745 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 64); 746 747 /* power down internal PHY */ 748 axe_cfg_cmd(sc, AXE_CMD_SW_RESET_REG, 0, 749 AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL); 750 } 751 752 err = usb2_config_td_sleep(&sc->sc_config_td, hz / 4); 753 axe_cfg_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL); 754 return; 755} 756 757static void 758axe_cfg_first_time_setup(struct axe_softc *sc, 759 struct usb2_config_td_cc *cc, uint16_t refcount) 760{ 761 struct ifnet *ifp; 762 int error; 763 uint8_t eaddr[min(ETHER_ADDR_LEN, 6)]; 764 765 /* set default value */ 766 bzero(eaddr, sizeof(eaddr)); 767 768 /* 769 * Load PHY indexes first. Needed by axe_xxx_init(). 770 */ 771 axe_cfg_cmd(sc, AXE_CMD_READ_PHYID, 0, 0, sc->sc_phyaddrs); 772 773 if (sc->sc_flags & AXE_FLAG_178) { 774 axe_cfg_ax88178_init(sc); 775 } else if (sc->sc_flags & AXE_FLAG_772) { 776 axe_cfg_ax88772_init(sc); 777 } 778 /* 779 * Get station address. 780 */ 781 if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772)) 782 axe_cfg_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, eaddr); 783 else 784 axe_cfg_cmd(sc, AXE_172_CMD_READ_NODEID, 0, 0, eaddr); 785 786 /* 787 * Fetch IPG values. 788 */ 789 axe_cfg_cmd(sc, AXE_CMD_READ_IPG012, 0, 0, sc->sc_ipgs); 790 791 /* 792 * Work around broken adapters that appear to lie about 793 * their PHY addresses. 794 */ 795 sc->sc_phyaddrs[0] = sc->sc_phyaddrs[1] = 0xFF; 796 797 mtx_unlock(&sc->sc_mtx); 798 799 ifp = if_alloc(IFT_ETHER); 800 801 mtx_lock(&sc->sc_mtx); 802 803 if (ifp == NULL) { 804 printf("%s: could not if_alloc()\n", 805 sc->sc_name); 806 goto done; 807 } 808 sc->sc_evilhack = ifp; 809 810 ifp->if_softc = sc; 811 if_initname(ifp, "axe", sc->sc_unit); 812 ifp->if_mtu = ETHERMTU; 813 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 814 ifp->if_ioctl = axe_ioctl_cb; 815 ifp->if_start = axe_start_cb; 816 ifp->if_watchdog = NULL; 817 ifp->if_init = axe_init_cb; 818 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); 819 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN; 820 IFQ_SET_READY(&ifp->if_snd); 821 822 /* 823 * XXX need Giant when accessing the device structures ! 824 */ 825 826 mtx_unlock(&sc->sc_mtx); 827 828 mtx_lock(&Giant); 829 830 error = mii_phy_probe(sc->sc_dev, &sc->sc_miibus, 831 &axe_ifmedia_upd_cb, 832 &axe_ifmedia_sts_cb); 833 mtx_unlock(&Giant); 834 835 mtx_lock(&sc->sc_mtx); 836 837 if (error) { 838 printf("%s: MII without any PHY!\n", 839 sc->sc_name); 840 if_free(ifp); 841 goto done; 842 } 843 sc->sc_ifp = ifp; 844 845 mtx_unlock(&sc->sc_mtx); 846 847 /* 848 * Call MI attach routine. 849 */ 850 851 ether_ifattach(ifp, eaddr); 852 853 mtx_lock(&sc->sc_mtx); 854 855done: 856 return; 857} 858 859static int 860axe_detach(device_t dev) 861{ 862 struct axe_softc *sc = device_get_softc(dev); 863 struct ifnet *ifp; 864 865 usb2_config_td_drain(&sc->sc_config_td); 866 867 mtx_lock(&sc->sc_mtx); 868 869 usb2_callout_stop(&sc->sc_watchdog); 870 871 axe_cfg_pre_stop(sc, NULL, 0); 872 873 ifp = sc->sc_ifp; 874 875 mtx_unlock(&sc->sc_mtx); 876 877 /* stop all USB transfers first */ 878 usb2_transfer_unsetup(sc->sc_xfer, AXE_ENDPT_MAX); 879 880 /* get rid of any late children */ 881 bus_generic_detach(dev); 882 883 if (ifp) { 884 ether_ifdetach(ifp); 885 if_free(ifp); 886 } 887 usb2_config_td_unsetup(&sc->sc_config_td); 888 889 usb2_callout_drain(&sc->sc_watchdog); 890 891 mtx_destroy(&sc->sc_mtx); 892 893 return (0); 894} 895 896static void 897axe_intr_clear_stall_callback(struct usb2_xfer *xfer) 898{ 899 struct axe_softc *sc = xfer->priv_sc; 900 struct usb2_xfer *xfer_other = sc->sc_xfer[4]; 901 902 if (usb2_clear_stall_callback(xfer, xfer_other)) { 903 DPRINTF("stall cleared\n"); 904 sc->sc_flags &= ~AXE_FLAG_INTR_STALL; 905 usb2_transfer_start(xfer_other); 906 } 907 return; 908} 909 910static void 911axe_intr_callback(struct usb2_xfer *xfer) 912{ 913 struct axe_softc *sc = xfer->priv_sc; 914 915 switch (USB_GET_STATE(xfer)) { 916 case USB_ST_TRANSFERRED: 917 918 /* do nothing */ 919 920 case USB_ST_SETUP: 921 if (sc->sc_flags & AXE_FLAG_INTR_STALL) { 922 usb2_transfer_start(sc->sc_xfer[5]); 923 } else { 924 xfer->frlengths[0] = xfer->max_data_length; 925 usb2_start_hardware(xfer); 926 } 927 return; 928 929 default: /* Error */ 930 if (xfer->error != USB_ERR_CANCELLED) { 931 /* start clear stall */ 932 sc->sc_flags |= AXE_FLAG_INTR_STALL; 933 usb2_transfer_start(sc->sc_xfer[5]); 934 } 935 return; 936 } 937} 938 939static void 940axe_bulk_read_clear_stall_callback(struct usb2_xfer *xfer) 941{ 942 struct axe_softc *sc = xfer->priv_sc; 943 struct usb2_xfer *xfer_other = sc->sc_xfer[1]; 944 945 if (usb2_clear_stall_callback(xfer, xfer_other)) { 946 DPRINTF("stall cleared\n"); 947 sc->sc_flags &= ~AXE_FLAG_READ_STALL; 948 usb2_transfer_start(xfer_other); 949 } 950 return; 951} 952 953#if (AXE_BULK_BUF_SIZE >= 0x10000) 954#error "Please update axe_bulk_read_callback()!" 955#endif 956 957static void 958axe_bulk_read_callback(struct usb2_xfer *xfer) 959{ 960 struct axe_softc *sc = xfer->priv_sc; 961 struct axe_sframe_hdr hdr; 962 struct ifnet *ifp = sc->sc_ifp; 963 struct mbuf *m; 964 struct { /* mini-queue */ 965 struct mbuf *ifq_head; 966 struct mbuf *ifq_tail; 967 uint16_t ifq_len; 968 } mq = { 969 NULL, NULL, 0 970 }; 971 uint16_t pos; 972 uint16_t len; 973 uint16_t adjust; 974 975 switch (USB_GET_STATE(xfer)) { 976 case USB_ST_TRANSFERRED: 977 978 pos = 0; 979 980 while (1) { 981 982 if (sc->sc_flags & (AXE_FLAG_772 | AXE_FLAG_178)) { 983 984 if (xfer->actlen < sizeof(hdr)) { 985 /* too little data */ 986 break; 987 } 988 usb2_copy_out(xfer->frbuffers, pos, &hdr, sizeof(hdr)); 989 990 if ((hdr.len ^ hdr.ilen) != 0xFFFF) { 991 /* we lost sync */ 992 break; 993 } 994 xfer->actlen -= sizeof(hdr); 995 pos += sizeof(hdr); 996 997 len = le16toh(hdr.len); 998 if (len > xfer->actlen) { 999 /* invalid length */ 1000 break; 1001 } 1002 adjust = (len & 1); 1003 1004 } else { 1005 len = xfer->actlen; 1006 adjust = 0; 1007 } 1008 1009 if (len < sizeof(struct ether_header)) { 1010 ifp->if_ierrors++; 1011 goto skip; 1012 } 1013 m = usb2_ether_get_mbuf(); 1014 if (m == NULL) { 1015 /* we are out of memory */ 1016 break; 1017 } 1018 if (m->m_len > len) { 1019 m->m_len = len; 1020 } 1021 usb2_copy_out(xfer->frbuffers, pos, m->m_data, m->m_len); 1022 1023 ifp->if_ipackets++; 1024 m->m_pkthdr.rcvif = ifp; 1025 m->m_pkthdr.len = m->m_len; 1026 1027 /* enqueue */ 1028 _IF_ENQUEUE(&mq, m); 1029 1030 skip: 1031 1032 pos += len; 1033 xfer->actlen -= len; 1034 1035 if (xfer->actlen <= adjust) { 1036 /* we are finished */ 1037 goto tr_setup; 1038 } 1039 pos += adjust; 1040 xfer->actlen -= adjust; 1041 } 1042 1043 /* count an error */ 1044 ifp->if_ierrors++; 1045 1046 case USB_ST_SETUP: 1047tr_setup: 1048 1049 if (sc->sc_flags & AXE_FLAG_READ_STALL) { 1050 usb2_transfer_start(sc->sc_xfer[3]); 1051 } else { 1052 xfer->frlengths[0] = xfer->max_data_length; 1053 usb2_start_hardware(xfer); 1054 } 1055 1056 /* 1057 * At the end of a USB callback it is always safe to unlock 1058 * the private mutex of a device! That is why we do the 1059 * "if_input" here, and not some lines up! 1060 */ 1061 if (mq.ifq_head) { 1062 1063 mtx_unlock(&sc->sc_mtx); 1064 1065 while (1) { 1066 1067 _IF_DEQUEUE(&mq, m); 1068 1069 if (m == NULL) 1070 break; 1071 1072 (ifp->if_input) (ifp, m); 1073 } 1074 1075 mtx_lock(&sc->sc_mtx); 1076 } 1077 return; 1078 1079 default: /* Error */ 1080 if (xfer->error != USB_ERR_CANCELLED) { 1081 /* try to clear stall first */ 1082 sc->sc_flags |= AXE_FLAG_READ_STALL; 1083 usb2_transfer_start(sc->sc_xfer[3]); 1084 } 1085 DPRINTF("bulk read error, %s\n", 1086 usb2_errstr(xfer->error)); 1087 return; 1088 1089 } 1090} 1091 1092static void 1093axe_bulk_write_clear_stall_callback(struct usb2_xfer *xfer) 1094{ 1095 struct axe_softc *sc = xfer->priv_sc; 1096 struct usb2_xfer *xfer_other = sc->sc_xfer[0]; 1097 1098 if (usb2_clear_stall_callback(xfer, xfer_other)) { 1099 DPRINTF("stall cleared\n"); 1100 sc->sc_flags &= ~AXE_FLAG_WRITE_STALL; 1101 usb2_transfer_start(xfer_other); 1102 } 1103 return; 1104} 1105 1106#if ((AXE_BULK_BUF_SIZE >= 0x10000) || (AXE_BULK_BUF_SIZE < (MCLBYTES+4))) 1107#error "Please update axe_bulk_write_callback()!" 1108#endif 1109 1110static void 1111axe_bulk_write_callback(struct usb2_xfer *xfer) 1112{ 1113 struct axe_softc *sc = xfer->priv_sc; 1114 struct axe_sframe_hdr hdr; 1115 struct ifnet *ifp = sc->sc_ifp; 1116 struct mbuf *m; 1117 uint16_t pos; 1118 1119 switch (USB_GET_STATE(xfer)) { 1120 case USB_ST_TRANSFERRED: 1121 DPRINTFN(11, "transfer complete\n"); 1122 1123 ifp->if_opackets++; 1124 1125 case USB_ST_SETUP: 1126 1127 if (sc->sc_flags & AXE_FLAG_WRITE_STALL) { 1128 usb2_transfer_start(sc->sc_xfer[2]); 1129 goto done; 1130 } 1131 if (sc->sc_flags & AXE_FLAG_WAIT_LINK) { 1132 /* 1133 * don't send anything if there is no link ! 1134 */ 1135 goto done; 1136 } 1137 pos = 0; 1138 1139 while (1) { 1140 1141 IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 1142 1143 if (m == NULL) { 1144 if (pos > 0) 1145 break; /* send out data */ 1146 else 1147 goto done; 1148 } 1149 if (m->m_pkthdr.len > MCLBYTES) { 1150 m->m_pkthdr.len = MCLBYTES; 1151 } 1152 if (sc->sc_flags & (AXE_FLAG_772 | AXE_FLAG_178)) { 1153 1154 hdr.len = htole16(m->m_pkthdr.len); 1155 hdr.ilen = ~hdr.len; 1156 1157 usb2_copy_in(xfer->frbuffers, pos, &hdr, sizeof(hdr)); 1158 1159 pos += sizeof(hdr); 1160 1161 /* 1162 * NOTE: Some drivers force a short packet 1163 * by appending a dummy header with zero 1164 * length at then end of the USB transfer. 1165 * This driver uses the 1166 * USB_FORCE_SHORT_XFER flag instead. 1167 */ 1168 } 1169 usb2_m_copy_in(xfer->frbuffers, pos, 1170 m, 0, m->m_pkthdr.len); 1171 1172 pos += m->m_pkthdr.len; 1173 1174 /* 1175 * if there's a BPF listener, bounce a copy 1176 * of this frame to him: 1177 */ 1178 BPF_MTAP(ifp, m); 1179 1180 m_freem(m); 1181 1182 if (sc->sc_flags & (AXE_FLAG_772 | AXE_FLAG_178)) { 1183 if (pos > (AXE_BULK_BUF_SIZE - MCLBYTES - sizeof(hdr))) { 1184 /* send out frame(s) */ 1185 break; 1186 } 1187 } else { 1188 /* send out frame */ 1189 break; 1190 } 1191 } 1192 1193 xfer->frlengths[0] = pos; 1194 usb2_start_hardware(xfer); 1195 1196done: 1197 return; 1198 1199 default: /* Error */ 1200 DPRINTFN(11, "transfer error, %s\n", 1201 usb2_errstr(xfer->error)); 1202 1203 if (xfer->error != USB_ERR_CANCELLED) { 1204 /* try to clear stall first */ 1205 sc->sc_flags |= AXE_FLAG_WRITE_STALL; 1206 usb2_transfer_start(sc->sc_xfer[2]); 1207 } 1208 ifp->if_oerrors++; 1209 return; 1210 1211 } 1212} 1213 1214static void 1215axe_cfg_tick(struct axe_softc *sc, 1216 struct usb2_config_td_cc *cc, uint16_t refcount) 1217{ 1218 struct ifnet *ifp = sc->sc_ifp; 1219 struct mii_data *mii = GET_MII(sc); 1220 1221 if ((ifp == NULL) || 1222 (mii == NULL)) { 1223 /* not ready */ 1224 return; 1225 } 1226 mii_tick(mii); 1227 1228 mii_pollstat(mii); 1229 1230 if ((sc->sc_flags & AXE_FLAG_WAIT_LINK) && 1231 (mii->mii_media_status & IFM_ACTIVE) && 1232 (IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE)) { 1233 sc->sc_flags &= ~AXE_FLAG_WAIT_LINK; 1234 } 1235 sc->sc_media_active = mii->mii_media_active; 1236 sc->sc_media_status = mii->mii_media_status; 1237 1238 /* start stopped transfers, if any */ 1239 1240 axe_start_transfers(sc); 1241 1242 return; 1243} 1244 1245static void 1246axe_start_cb(struct ifnet *ifp) 1247{ 1248 struct axe_softc *sc = ifp->if_softc; 1249 1250 mtx_lock(&sc->sc_mtx); 1251 1252 axe_start_transfers(sc); 1253 1254 mtx_unlock(&sc->sc_mtx); 1255 1256 return; 1257} 1258 1259static void 1260axe_start_transfers(struct axe_softc *sc) 1261{ 1262 if ((sc->sc_flags & AXE_FLAG_LL_READY) && 1263 (sc->sc_flags & AXE_FLAG_HL_READY)) { 1264 1265 /* 1266 * start the USB transfers, if not already started: 1267 */ 1268 usb2_transfer_start(sc->sc_xfer[4]); 1269 usb2_transfer_start(sc->sc_xfer[1]); 1270 usb2_transfer_start(sc->sc_xfer[0]); 1271 } 1272 return; 1273} 1274 1275static void 1276axe_init_cb(void *arg) 1277{ 1278 struct axe_softc *sc = arg; 1279 1280 mtx_lock(&sc->sc_mtx); 1281 usb2_config_td_queue_command 1282 (&sc->sc_config_td, &axe_cfg_pre_init, &axe_cfg_init, 0, 0); 1283 mtx_unlock(&sc->sc_mtx); 1284 1285 return; 1286} 1287 1288static void 1289axe_cfg_pre_init(struct axe_softc *sc, 1290 struct usb2_config_td_cc *cc, uint16_t refcount) 1291{ 1292 struct ifnet *ifp = sc->sc_ifp; 1293 1294 /* immediate configuration */ 1295 1296 axe_cfg_pre_stop(sc, cc, 0); 1297 1298 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1299 1300 sc->sc_flags |= AXE_FLAG_HL_READY; 1301 return; 1302} 1303 1304static void 1305axe_cfg_init(struct axe_softc *sc, 1306 struct usb2_config_td_cc *cc, uint16_t refcount) 1307{ 1308 struct mii_data *mii = GET_MII(sc); 1309 uint16_t rxmode; 1310 1311 /* 1312 * Cancel pending I/O 1313 */ 1314 1315 axe_cfg_stop(sc, cc, 0); 1316 1317#if 0 1318 /* Set MAC address */ 1319 axe_mac(sc, cc->if_lladdr); 1320#endif 1321 1322 /* Set transmitter IPG values */ 1323 if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772)) { 1324 axe_cfg_cmd(sc, AXE_178_CMD_WRITE_IPG012, sc->sc_ipgs[2], 1325 (sc->sc_ipgs[1] << 8) | (sc->sc_ipgs[0]), NULL); 1326 } else { 1327 axe_cfg_cmd(sc, AXE_172_CMD_WRITE_IPG0, 0, sc->sc_ipgs[0], NULL); 1328 axe_cfg_cmd(sc, AXE_172_CMD_WRITE_IPG1, 0, sc->sc_ipgs[1], NULL); 1329 axe_cfg_cmd(sc, AXE_172_CMD_WRITE_IPG2, 0, sc->sc_ipgs[2], NULL); 1330 } 1331 1332 /* Enable receiver, set RX mode */ 1333 rxmode = (AXE_RXCMD_MULTICAST | AXE_RXCMD_ENABLE); 1334 if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772)) { 1335 rxmode |= AXE_178_RXCMD_MFB_2048; /* chip default */ 1336 } else { 1337 rxmode |= AXE_172_RXCMD_UNICAST; 1338 } 1339 1340 /* If we want promiscuous mode, set the allframes bit. */ 1341 if (cc->if_flags & IFF_PROMISC) { 1342 rxmode |= AXE_RXCMD_PROMISC; 1343 } 1344 if (cc->if_flags & IFF_BROADCAST) { 1345 rxmode |= AXE_RXCMD_BROADCAST; 1346 } 1347 axe_cfg_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL); 1348 1349 /* Load the multicast filter. */ 1350 axe_cfg_setmulti(sc, cc, 0); 1351 1352 mii_mediachg(mii); 1353 1354 sc->sc_flags |= (AXE_FLAG_READ_STALL | 1355 AXE_FLAG_WRITE_STALL | 1356 AXE_FLAG_LL_READY); 1357 1358 axe_start_transfers(sc); 1359 1360 return; 1361} 1362 1363static void 1364axe_cfg_promisc_upd(struct axe_softc *sc, 1365 struct usb2_config_td_cc *cc, uint16_t refcount) 1366{ 1367 uint16_t rxmode; 1368 1369 axe_cfg_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, &rxmode); 1370 1371 rxmode = le16toh(rxmode); 1372 1373 if (cc->if_flags & IFF_PROMISC) { 1374 rxmode |= AXE_RXCMD_PROMISC; 1375 } else { 1376 rxmode &= ~AXE_RXCMD_PROMISC; 1377 } 1378 1379 axe_cfg_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL); 1380 1381 axe_cfg_setmulti(sc, cc, 0); 1382 1383 return; 1384} 1385 1386static int 1387axe_ioctl_cb(struct ifnet *ifp, u_long command, caddr_t data) 1388{ 1389 struct axe_softc *sc = ifp->if_softc; 1390 struct mii_data *mii; 1391 int error = 0; 1392 1393 switch (command) { 1394 case SIOCSIFFLAGS: 1395 mtx_lock(&sc->sc_mtx); 1396 if (ifp->if_flags & IFF_UP) { 1397 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 1398 usb2_config_td_queue_command 1399 (&sc->sc_config_td, &axe_config_copy, 1400 &axe_cfg_promisc_upd, 0, 0); 1401 } else { 1402 usb2_config_td_queue_command 1403 (&sc->sc_config_td, &axe_cfg_pre_init, 1404 &axe_cfg_init, 0, 0); 1405 } 1406 } else { 1407 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 1408 usb2_config_td_queue_command 1409 (&sc->sc_config_td, &axe_cfg_pre_stop, 1410 &axe_cfg_stop, 0, 0); 1411 } 1412 } 1413 mtx_unlock(&sc->sc_mtx); 1414 break; 1415 1416 case SIOCADDMULTI: 1417 case SIOCDELMULTI: 1418 mtx_lock(&sc->sc_mtx); 1419 usb2_config_td_queue_command 1420 (&sc->sc_config_td, &axe_config_copy, 1421 &axe_cfg_setmulti, 0, 0); 1422 mtx_unlock(&sc->sc_mtx); 1423 break; 1424 1425 case SIOCGIFMEDIA: 1426 case SIOCSIFMEDIA: 1427 mii = GET_MII(sc); 1428 if (mii == NULL) { 1429 error = EINVAL; 1430 } else { 1431 error = ifmedia_ioctl 1432 (ifp, (void *)data, &mii->mii_media, command); 1433 } 1434 break; 1435 1436 default: 1437 error = ether_ioctl(ifp, command, data); 1438 break; 1439 } 1440 return (error); 1441} 1442 1443static void 1444axe_watchdog(void *arg) 1445{ 1446 struct axe_softc *sc = arg; 1447 1448 mtx_assert(&sc->sc_mtx, MA_OWNED); 1449 1450 usb2_config_td_queue_command 1451 (&sc->sc_config_td, NULL, &axe_cfg_tick, 0, 0); 1452 1453 usb2_callout_reset(&sc->sc_watchdog, 1454 hz, &axe_watchdog, sc); 1455 1456 mtx_unlock(&sc->sc_mtx); 1457 return; 1458} 1459 1460/* 1461 * NOTE: can be called when "ifp" is NULL 1462 */ 1463static void 1464axe_cfg_pre_stop(struct axe_softc *sc, 1465 struct usb2_config_td_cc *cc, uint16_t refcount) 1466{ 1467 struct ifnet *ifp = sc->sc_ifp; 1468 1469 if (cc) { 1470 /* copy the needed configuration */ 1471 axe_config_copy(sc, cc, refcount); 1472 } 1473 /* immediate configuration */ 1474 1475 if (ifp) { 1476 /* clear flags */ 1477 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 1478 } 1479 sc->sc_flags &= ~(AXE_FLAG_HL_READY | 1480 AXE_FLAG_LL_READY); 1481 1482 sc->sc_flags |= AXE_FLAG_WAIT_LINK; 1483 1484 /* 1485 * stop all the transfers, if not already stopped: 1486 */ 1487 usb2_transfer_stop(sc->sc_xfer[0]); 1488 usb2_transfer_stop(sc->sc_xfer[1]); 1489 usb2_transfer_stop(sc->sc_xfer[2]); 1490 usb2_transfer_stop(sc->sc_xfer[3]); 1491 usb2_transfer_stop(sc->sc_xfer[4]); 1492 usb2_transfer_stop(sc->sc_xfer[5]); 1493 return; 1494} 1495 1496static void 1497axe_cfg_stop(struct axe_softc *sc, 1498 struct usb2_config_td_cc *cc, uint16_t refcount) 1499{ 1500 axe_cfg_reset(sc); 1501 return; 1502} 1503 1504/* 1505 * Stop all chip I/O so that the kernel's probe routines don't 1506 * get confused by errant DMAs when rebooting. 1507 */ 1508static int 1509axe_shutdown(device_t dev) 1510{ 1511 struct axe_softc *sc = device_get_softc(dev); 1512 1513 mtx_lock(&sc->sc_mtx); 1514 1515 usb2_config_td_queue_command 1516 (&sc->sc_config_td, &axe_cfg_pre_stop, 1517 &axe_cfg_stop, 0, 0); 1518 1519 mtx_unlock(&sc->sc_mtx); 1520 1521 return (0); 1522} 1523