if_rue.c revision 226479
1/*- 2 * Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>. 3 * Copyright (c) 1997, 1998, 1999, 2000 Bill Paul <wpaul@ee.columbia.edu>. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27/*- 28 * Copyright (c) 1997, 1998, 1999, 2000 29 * Bill Paul <wpaul@ee.columbia.edu>. All rights reserved. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions 33 * are met: 34 * 1. Redistributions of source code must retain the above copyright 35 * notice, this list of conditions and the following disclaimer. 36 * 2. Redistributions in binary form must reproduce the above copyright 37 * notice, this list of conditions and the following disclaimer in the 38 * documentation and/or other materials provided with the distribution. 39 * 3. All advertising materials mentioning features or use of this software 40 * must display the following acknowledgement: 41 * This product includes software developed by Bill Paul. 42 * 4. Neither the name of the author nor the names of any co-contributors 43 * may be used to endorse or promote products derived from this software 44 * without specific prior written permission. 45 * 46 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 47 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 49 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD 50 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 51 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 52 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 53 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 54 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 55 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 56 * THE POSSIBILITY OF SUCH DAMAGE. 57 */ 58 59#include <sys/cdefs.h> 60__FBSDID("$FreeBSD: head/sys/dev/usb/net/if_rue.c 226479 2011-10-17 19:51:38Z yongari $"); 61 62/* 63 * RealTek RTL8150 USB to fast ethernet controller driver. 64 * Datasheet is available from 65 * ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/. 66 */ 67 68#include <sys/stdint.h> 69#include <sys/stddef.h> 70#include <sys/param.h> 71#include <sys/queue.h> 72#include <sys/types.h> 73#include <sys/systm.h> 74#include <sys/kernel.h> 75#include <sys/bus.h> 76#include <sys/module.h> 77#include <sys/lock.h> 78#include <sys/mutex.h> 79#include <sys/condvar.h> 80#include <sys/sysctl.h> 81#include <sys/sx.h> 82#include <sys/unistd.h> 83#include <sys/callout.h> 84#include <sys/malloc.h> 85#include <sys/priv.h> 86 87#include <dev/usb/usb.h> 88#include <dev/usb/usbdi.h> 89#include <dev/usb/usbdi_util.h> 90#include "usbdevs.h" 91 92#define USB_DEBUG_VAR rue_debug 93#include <dev/usb/usb_debug.h> 94#include <dev/usb/usb_process.h> 95 96#include <dev/usb/net/usb_ethernet.h> 97#include <dev/usb/net/if_ruereg.h> 98 99#ifdef USB_DEBUG 100static int rue_debug = 0; 101 102SYSCTL_NODE(_hw_usb, OID_AUTO, rue, CTLFLAG_RW, 0, "USB rue"); 103SYSCTL_INT(_hw_usb_rue, OID_AUTO, debug, CTLFLAG_RW, 104 &rue_debug, 0, "Debug level"); 105#endif 106 107/* 108 * Various supported device vendors/products. 109 */ 110 111static const STRUCT_USB_HOST_ID rue_devs[] = { 112 {USB_VPI(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAKTX, 0)}, 113 {USB_VPI(USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_USBKR100, 0)}, 114 {USB_VPI(USB_VENDOR_OQO, USB_PRODUCT_OQO_ETHER01, 0)}, 115}; 116 117/* prototypes */ 118 119static device_probe_t rue_probe; 120static device_attach_t rue_attach; 121static device_detach_t rue_detach; 122 123static miibus_readreg_t rue_miibus_readreg; 124static miibus_writereg_t rue_miibus_writereg; 125static miibus_statchg_t rue_miibus_statchg; 126 127static usb_callback_t rue_intr_callback; 128static usb_callback_t rue_bulk_read_callback; 129static usb_callback_t rue_bulk_write_callback; 130 131static uether_fn_t rue_attach_post; 132static uether_fn_t rue_init; 133static uether_fn_t rue_stop; 134static uether_fn_t rue_start; 135static uether_fn_t rue_tick; 136static uether_fn_t rue_setmulti; 137static uether_fn_t rue_setpromisc; 138 139static int rue_read_mem(struct rue_softc *, uint16_t, void *, int); 140static int rue_write_mem(struct rue_softc *, uint16_t, void *, int); 141static uint8_t rue_csr_read_1(struct rue_softc *, uint16_t); 142static uint16_t rue_csr_read_2(struct rue_softc *, uint16_t); 143static int rue_csr_write_1(struct rue_softc *, uint16_t, uint8_t); 144static int rue_csr_write_2(struct rue_softc *, uint16_t, uint16_t); 145static int rue_csr_write_4(struct rue_softc *, int, uint32_t); 146 147static void rue_reset(struct rue_softc *); 148static int rue_ifmedia_upd(struct ifnet *); 149static void rue_ifmedia_sts(struct ifnet *, struct ifmediareq *); 150 151static const struct usb_config rue_config[RUE_N_TRANSFER] = { 152 153 [RUE_BULK_DT_WR] = { 154 .type = UE_BULK, 155 .endpoint = UE_ADDR_ANY, 156 .direction = UE_DIR_OUT, 157 .bufsize = MCLBYTES, 158 .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 159 .callback = rue_bulk_write_callback, 160 .timeout = 10000, /* 10 seconds */ 161 }, 162 163 [RUE_BULK_DT_RD] = { 164 .type = UE_BULK, 165 .endpoint = UE_ADDR_ANY, 166 .direction = UE_DIR_IN, 167 .bufsize = (MCLBYTES + 4), 168 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 169 .callback = rue_bulk_read_callback, 170 .timeout = 0, /* no timeout */ 171 }, 172 173 [RUE_INTR_DT_RD] = { 174 .type = UE_INTERRUPT, 175 .endpoint = UE_ADDR_ANY, 176 .direction = UE_DIR_IN, 177 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 178 .bufsize = 0, /* use wMaxPacketSize */ 179 .callback = rue_intr_callback, 180 }, 181}; 182 183static device_method_t rue_methods[] = { 184 /* Device interface */ 185 DEVMETHOD(device_probe, rue_probe), 186 DEVMETHOD(device_attach, rue_attach), 187 DEVMETHOD(device_detach, rue_detach), 188 189 /* Bus interface */ 190 DEVMETHOD(bus_print_child, bus_generic_print_child), 191 192 /* MII interface */ 193 DEVMETHOD(miibus_readreg, rue_miibus_readreg), 194 DEVMETHOD(miibus_writereg, rue_miibus_writereg), 195 DEVMETHOD(miibus_statchg, rue_miibus_statchg), 196 197 {0, 0} 198}; 199 200static driver_t rue_driver = { 201 .name = "rue", 202 .methods = rue_methods, 203 .size = sizeof(struct rue_softc), 204}; 205 206static devclass_t rue_devclass; 207 208DRIVER_MODULE(rue, uhub, rue_driver, rue_devclass, NULL, 0); 209DRIVER_MODULE(miibus, rue, miibus_driver, miibus_devclass, 0, 0); 210MODULE_DEPEND(rue, uether, 1, 1, 1); 211MODULE_DEPEND(rue, usb, 1, 1, 1); 212MODULE_DEPEND(rue, ether, 1, 1, 1); 213MODULE_DEPEND(rue, miibus, 1, 1, 1); 214MODULE_VERSION(rue, 1); 215 216static const struct usb_ether_methods rue_ue_methods = { 217 .ue_attach_post = rue_attach_post, 218 .ue_start = rue_start, 219 .ue_init = rue_init, 220 .ue_stop = rue_stop, 221 .ue_tick = rue_tick, 222 .ue_setmulti = rue_setmulti, 223 .ue_setpromisc = rue_setpromisc, 224 .ue_mii_upd = rue_ifmedia_upd, 225 .ue_mii_sts = rue_ifmedia_sts, 226}; 227 228#define RUE_SETBIT(sc, reg, x) \ 229 rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) | (x)) 230 231#define RUE_CLRBIT(sc, reg, x) \ 232 rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) & ~(x)) 233 234static int 235rue_read_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 236{ 237 struct usb_device_request req; 238 239 req.bmRequestType = UT_READ_VENDOR_DEVICE; 240 req.bRequest = UR_SET_ADDRESS; 241 USETW(req.wValue, addr); 242 USETW(req.wIndex, 0); 243 USETW(req.wLength, len); 244 245 return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 246} 247 248static int 249rue_write_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 250{ 251 struct usb_device_request req; 252 253 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 254 req.bRequest = UR_SET_ADDRESS; 255 USETW(req.wValue, addr); 256 USETW(req.wIndex, 0); 257 USETW(req.wLength, len); 258 259 return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 260} 261 262static uint8_t 263rue_csr_read_1(struct rue_softc *sc, uint16_t reg) 264{ 265 uint8_t val; 266 267 rue_read_mem(sc, reg, &val, 1); 268 return (val); 269} 270 271static uint16_t 272rue_csr_read_2(struct rue_softc *sc, uint16_t reg) 273{ 274 uint8_t val[2]; 275 276 rue_read_mem(sc, reg, &val, 2); 277 return (UGETW(val)); 278} 279 280static int 281rue_csr_write_1(struct rue_softc *sc, uint16_t reg, uint8_t val) 282{ 283 return (rue_write_mem(sc, reg, &val, 1)); 284} 285 286static int 287rue_csr_write_2(struct rue_softc *sc, uint16_t reg, uint16_t val) 288{ 289 uint8_t temp[2]; 290 291 USETW(temp, val); 292 return (rue_write_mem(sc, reg, &temp, 2)); 293} 294 295static int 296rue_csr_write_4(struct rue_softc *sc, int reg, uint32_t val) 297{ 298 uint8_t temp[4]; 299 300 USETDW(temp, val); 301 return (rue_write_mem(sc, reg, &temp, 4)); 302} 303 304static int 305rue_miibus_readreg(device_t dev, int phy, int reg) 306{ 307 struct rue_softc *sc = device_get_softc(dev); 308 uint16_t rval; 309 uint16_t ruereg; 310 int locked; 311 312 if (phy != 0) /* RTL8150 supports PHY == 0, only */ 313 return (0); 314 315 locked = mtx_owned(&sc->sc_mtx); 316 if (!locked) 317 RUE_LOCK(sc); 318 319 switch (reg) { 320 case MII_BMCR: 321 ruereg = RUE_BMCR; 322 break; 323 case MII_BMSR: 324 ruereg = RUE_BMSR; 325 break; 326 case MII_ANAR: 327 ruereg = RUE_ANAR; 328 break; 329 case MII_ANER: 330 ruereg = RUE_AER; 331 break; 332 case MII_ANLPAR: 333 ruereg = RUE_ANLP; 334 break; 335 case MII_PHYIDR1: 336 case MII_PHYIDR2: 337 rval = 0; 338 goto done; 339 default: 340 if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 341 rval = rue_csr_read_1(sc, reg); 342 goto done; 343 } 344 device_printf(sc->sc_ue.ue_dev, "bad phy register\n"); 345 rval = 0; 346 goto done; 347 } 348 349 rval = rue_csr_read_2(sc, ruereg); 350done: 351 if (!locked) 352 RUE_UNLOCK(sc); 353 return (rval); 354} 355 356static int 357rue_miibus_writereg(device_t dev, int phy, int reg, int data) 358{ 359 struct rue_softc *sc = device_get_softc(dev); 360 uint16_t ruereg; 361 int locked; 362 363 if (phy != 0) /* RTL8150 supports PHY == 0, only */ 364 return (0); 365 366 locked = mtx_owned(&sc->sc_mtx); 367 if (!locked) 368 RUE_LOCK(sc); 369 370 switch (reg) { 371 case MII_BMCR: 372 ruereg = RUE_BMCR; 373 break; 374 case MII_BMSR: 375 ruereg = RUE_BMSR; 376 break; 377 case MII_ANAR: 378 ruereg = RUE_ANAR; 379 break; 380 case MII_ANER: 381 ruereg = RUE_AER; 382 break; 383 case MII_ANLPAR: 384 ruereg = RUE_ANLP; 385 break; 386 case MII_PHYIDR1: 387 case MII_PHYIDR2: 388 goto done; 389 default: 390 if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 391 rue_csr_write_1(sc, reg, data); 392 goto done; 393 } 394 device_printf(sc->sc_ue.ue_dev, " bad phy register\n"); 395 goto done; 396 } 397 rue_csr_write_2(sc, ruereg, data); 398done: 399 if (!locked) 400 RUE_UNLOCK(sc); 401 return (0); 402} 403 404static void 405rue_miibus_statchg(device_t dev) 406{ 407 /* 408 * When the code below is enabled the card starts doing weird 409 * things after link going from UP to DOWN and back UP. 410 * 411 * Looks like some of register writes below messes up PHY 412 * interface. 413 * 414 * No visible regressions were found after commenting this code 415 * out, so that disable it for good. 416 */ 417#if 0 418 struct rue_softc *sc = device_get_softc(dev); 419 struct mii_data *mii = GET_MII(sc); 420 uint16_t bmcr; 421 int locked; 422 423 locked = mtx_owned(&sc->sc_mtx); 424 if (!locked) 425 RUE_LOCK(sc); 426 427 RUE_CLRBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 428 429 bmcr = rue_csr_read_2(sc, RUE_BMCR); 430 431 if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) 432 bmcr |= RUE_BMCR_SPD_SET; 433 else 434 bmcr &= ~RUE_BMCR_SPD_SET; 435 436 if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) 437 bmcr |= RUE_BMCR_DUPLEX; 438 else 439 bmcr &= ~RUE_BMCR_DUPLEX; 440 441 rue_csr_write_2(sc, RUE_BMCR, bmcr); 442 443 RUE_SETBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 444 445 if (!locked) 446 RUE_UNLOCK(sc); 447#endif 448} 449 450static void 451rue_setpromisc(struct usb_ether *ue) 452{ 453 struct rue_softc *sc = uether_getsc(ue); 454 struct ifnet *ifp = uether_getifp(ue); 455 456 RUE_LOCK_ASSERT(sc, MA_OWNED); 457 458 /* If we want promiscuous mode, set the allframes bit. */ 459 if (ifp->if_flags & IFF_PROMISC) 460 RUE_SETBIT(sc, RUE_RCR, RUE_RCR_AAP); 461 else 462 RUE_CLRBIT(sc, RUE_RCR, RUE_RCR_AAP); 463} 464 465/* 466 * Program the 64-bit multicast hash filter. 467 */ 468static void 469rue_setmulti(struct usb_ether *ue) 470{ 471 struct rue_softc *sc = uether_getsc(ue); 472 struct ifnet *ifp = uether_getifp(ue); 473 uint16_t rxcfg; 474 int h = 0; 475 uint32_t hashes[2] = { 0, 0 }; 476 struct ifmultiaddr *ifma; 477 int mcnt = 0; 478 479 RUE_LOCK_ASSERT(sc, MA_OWNED); 480 481 rxcfg = rue_csr_read_2(sc, RUE_RCR); 482 483 if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { 484 rxcfg |= (RUE_RCR_AAM | RUE_RCR_AAP); 485 rxcfg &= ~RUE_RCR_AM; 486 rue_csr_write_2(sc, RUE_RCR, rxcfg); 487 rue_csr_write_4(sc, RUE_MAR0, 0xFFFFFFFF); 488 rue_csr_write_4(sc, RUE_MAR4, 0xFFFFFFFF); 489 return; 490 } 491 492 /* first, zot all the existing hash bits */ 493 rue_csr_write_4(sc, RUE_MAR0, 0); 494 rue_csr_write_4(sc, RUE_MAR4, 0); 495 496 /* now program new ones */ 497 if_maddr_rlock(ifp); 498 TAILQ_FOREACH (ifma, &ifp->if_multiaddrs, ifma_link) 499 { 500 if (ifma->ifma_addr->sa_family != AF_LINK) 501 continue; 502 h = ether_crc32_be(LLADDR((struct sockaddr_dl *) 503 ifma->ifma_addr), ETHER_ADDR_LEN) >> 26; 504 if (h < 32) 505 hashes[0] |= (1 << h); 506 else 507 hashes[1] |= (1 << (h - 32)); 508 mcnt++; 509 } 510 if_maddr_runlock(ifp); 511 512 if (mcnt) 513 rxcfg |= RUE_RCR_AM; 514 else 515 rxcfg &= ~RUE_RCR_AM; 516 517 rxcfg &= ~(RUE_RCR_AAM | RUE_RCR_AAP); 518 519 rue_csr_write_2(sc, RUE_RCR, rxcfg); 520 rue_csr_write_4(sc, RUE_MAR0, hashes[0]); 521 rue_csr_write_4(sc, RUE_MAR4, hashes[1]); 522} 523 524static void 525rue_reset(struct rue_softc *sc) 526{ 527 int i; 528 529 rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST); 530 531 for (i = 0; i != RUE_TIMEOUT; i++) { 532 if (uether_pause(&sc->sc_ue, hz / 1000)) 533 break; 534 if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST)) 535 break; 536 } 537 if (i == RUE_TIMEOUT) 538 device_printf(sc->sc_ue.ue_dev, "reset never completed\n"); 539 540 uether_pause(&sc->sc_ue, hz / 100); 541} 542 543static void 544rue_attach_post(struct usb_ether *ue) 545{ 546 struct rue_softc *sc = uether_getsc(ue); 547 548 /* reset the adapter */ 549 rue_reset(sc); 550 551 /* get station address from the EEPROM */ 552 rue_read_mem(sc, RUE_EEPROM_IDR0, ue->ue_eaddr, ETHER_ADDR_LEN); 553} 554 555/* 556 * Probe for a RTL8150 chip. 557 */ 558static int 559rue_probe(device_t dev) 560{ 561 struct usb_attach_arg *uaa = device_get_ivars(dev); 562 563 if (uaa->usb_mode != USB_MODE_HOST) 564 return (ENXIO); 565 if (uaa->info.bConfigIndex != RUE_CONFIG_IDX) 566 return (ENXIO); 567 if (uaa->info.bIfaceIndex != RUE_IFACE_IDX) 568 return (ENXIO); 569 570 return (usbd_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa)); 571} 572 573/* 574 * Attach the interface. Allocate softc structures, do ifmedia 575 * setup and ethernet/BPF attach. 576 */ 577static int 578rue_attach(device_t dev) 579{ 580 struct usb_attach_arg *uaa = device_get_ivars(dev); 581 struct rue_softc *sc = device_get_softc(dev); 582 struct usb_ether *ue = &sc->sc_ue; 583 uint8_t iface_index; 584 int error; 585 586 device_set_usb_desc(dev); 587 mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); 588 589 iface_index = RUE_IFACE_IDX; 590 error = usbd_transfer_setup(uaa->device, &iface_index, 591 sc->sc_xfer, rue_config, RUE_N_TRANSFER, 592 sc, &sc->sc_mtx); 593 if (error) { 594 device_printf(dev, "allocating USB transfers failed\n"); 595 goto detach; 596 } 597 598 ue->ue_sc = sc; 599 ue->ue_dev = dev; 600 ue->ue_udev = uaa->device; 601 ue->ue_mtx = &sc->sc_mtx; 602 ue->ue_methods = &rue_ue_methods; 603 604 error = uether_ifattach(ue); 605 if (error) { 606 device_printf(dev, "could not attach interface\n"); 607 goto detach; 608 } 609 return (0); /* success */ 610 611detach: 612 rue_detach(dev); 613 return (ENXIO); /* failure */ 614} 615 616static int 617rue_detach(device_t dev) 618{ 619 struct rue_softc *sc = device_get_softc(dev); 620 struct usb_ether *ue = &sc->sc_ue; 621 622 usbd_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER); 623 uether_ifdetach(ue); 624 mtx_destroy(&sc->sc_mtx); 625 626 return (0); 627} 628 629static void 630rue_intr_callback(struct usb_xfer *xfer, usb_error_t error) 631{ 632 struct rue_softc *sc = usbd_xfer_softc(xfer); 633 struct ifnet *ifp = uether_getifp(&sc->sc_ue); 634 struct rue_intrpkt pkt; 635 struct usb_page_cache *pc; 636 int actlen; 637 638 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 639 640 switch (USB_GET_STATE(xfer)) { 641 case USB_ST_TRANSFERRED: 642 643 if (ifp && (ifp->if_drv_flags & IFF_DRV_RUNNING) && 644 actlen >= sizeof(pkt)) { 645 646 pc = usbd_xfer_get_frame(xfer, 0); 647 usbd_copy_out(pc, 0, &pkt, sizeof(pkt)); 648 649 ifp->if_ierrors += pkt.rue_rxlost_cnt; 650 ifp->if_ierrors += pkt.rue_crcerr_cnt; 651 ifp->if_collisions += pkt.rue_col_cnt; 652 } 653 /* FALLTHROUGH */ 654 case USB_ST_SETUP: 655tr_setup: 656 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 657 usbd_transfer_submit(xfer); 658 return; 659 660 default: /* Error */ 661 if (error != USB_ERR_CANCELLED) { 662 /* try to clear stall first */ 663 usbd_xfer_set_stall(xfer); 664 goto tr_setup; 665 } 666 return; 667 } 668} 669 670static void 671rue_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 672{ 673 struct rue_softc *sc = usbd_xfer_softc(xfer); 674 struct usb_ether *ue = &sc->sc_ue; 675 struct ifnet *ifp = uether_getifp(ue); 676 struct usb_page_cache *pc; 677 uint16_t status; 678 int actlen; 679 680 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 681 682 switch (USB_GET_STATE(xfer)) { 683 case USB_ST_TRANSFERRED: 684 685 if (actlen < 4) { 686 ifp->if_ierrors++; 687 goto tr_setup; 688 } 689 pc = usbd_xfer_get_frame(xfer, 0); 690 usbd_copy_out(pc, actlen - 4, &status, sizeof(status)); 691 actlen -= 4; 692 693 /* check recieve packet was valid or not */ 694 status = le16toh(status); 695 if ((status & RUE_RXSTAT_VALID) == 0) { 696 ifp->if_ierrors++; 697 goto tr_setup; 698 } 699 uether_rxbuf(ue, pc, 0, actlen); 700 /* FALLTHROUGH */ 701 case USB_ST_SETUP: 702tr_setup: 703 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 704 usbd_transfer_submit(xfer); 705 uether_rxflush(ue); 706 return; 707 708 default: /* Error */ 709 DPRINTF("bulk read error, %s\n", 710 usbd_errstr(error)); 711 712 if (error != USB_ERR_CANCELLED) { 713 /* try to clear stall first */ 714 usbd_xfer_set_stall(xfer); 715 goto tr_setup; 716 } 717 return; 718 } 719} 720 721static void 722rue_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 723{ 724 struct rue_softc *sc = usbd_xfer_softc(xfer); 725 struct ifnet *ifp = uether_getifp(&sc->sc_ue); 726 struct usb_page_cache *pc; 727 struct mbuf *m; 728 int temp_len; 729 730 switch (USB_GET_STATE(xfer)) { 731 case USB_ST_TRANSFERRED: 732 DPRINTFN(11, "transfer complete\n"); 733 ifp->if_opackets++; 734 735 /* FALLTHROUGH */ 736 case USB_ST_SETUP: 737tr_setup: 738 if ((sc->sc_flags & RUE_FLAG_LINK) == 0) { 739 /* 740 * don't send anything if there is no link ! 741 */ 742 return; 743 } 744 IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 745 746 if (m == NULL) 747 return; 748 if (m->m_pkthdr.len > MCLBYTES) 749 m->m_pkthdr.len = MCLBYTES; 750 temp_len = m->m_pkthdr.len; 751 752 pc = usbd_xfer_get_frame(xfer, 0); 753 usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len); 754 755 /* 756 * This is an undocumented behavior. 757 * RTL8150 chip doesn't send frame length smaller than 758 * RUE_MIN_FRAMELEN (60) byte packet. 759 */ 760 if (temp_len < RUE_MIN_FRAMELEN) { 761 usbd_frame_zero(pc, temp_len, 762 RUE_MIN_FRAMELEN - temp_len); 763 temp_len = RUE_MIN_FRAMELEN; 764 } 765 usbd_xfer_set_frame_len(xfer, 0, temp_len); 766 767 /* 768 * if there's a BPF listener, bounce a copy 769 * of this frame to him: 770 */ 771 BPF_MTAP(ifp, m); 772 773 m_freem(m); 774 775 usbd_transfer_submit(xfer); 776 777 return; 778 779 default: /* Error */ 780 DPRINTFN(11, "transfer error, %s\n", 781 usbd_errstr(error)); 782 783 ifp->if_oerrors++; 784 785 if (error != USB_ERR_CANCELLED) { 786 /* try to clear stall first */ 787 usbd_xfer_set_stall(xfer); 788 goto tr_setup; 789 } 790 return; 791 } 792} 793 794static void 795rue_tick(struct usb_ether *ue) 796{ 797 struct rue_softc *sc = uether_getsc(ue); 798 struct mii_data *mii = GET_MII(sc); 799 800 RUE_LOCK_ASSERT(sc, MA_OWNED); 801 802 mii_tick(mii); 803 if ((sc->sc_flags & RUE_FLAG_LINK) == 0 804 && mii->mii_media_status & IFM_ACTIVE && 805 IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) { 806 sc->sc_flags |= RUE_FLAG_LINK; 807 rue_start(ue); 808 } 809} 810 811static void 812rue_start(struct usb_ether *ue) 813{ 814 struct rue_softc *sc = uether_getsc(ue); 815 816 /* 817 * start the USB transfers, if not already started: 818 */ 819 usbd_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]); 820 usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]); 821 usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]); 822} 823 824static void 825rue_init(struct usb_ether *ue) 826{ 827 struct rue_softc *sc = uether_getsc(ue); 828 struct ifnet *ifp = uether_getifp(ue); 829 830 RUE_LOCK_ASSERT(sc, MA_OWNED); 831 832 /* 833 * Cancel pending I/O 834 */ 835 rue_reset(sc); 836 837 /* Set MAC address */ 838 rue_write_mem(sc, RUE_IDR0, IF_LLADDR(ifp), ETHER_ADDR_LEN); 839 840 rue_stop(ue); 841 842 /* 843 * Set the initial TX and RX configuration. 844 */ 845 rue_csr_write_1(sc, RUE_TCR, RUE_TCR_CONFIG); 846 rue_csr_write_2(sc, RUE_RCR, RUE_RCR_CONFIG|RUE_RCR_AB); 847 848 /* Load the multicast filter */ 849 rue_setpromisc(ue); 850 /* Load the multicast filter. */ 851 rue_setmulti(ue); 852 853 /* Enable RX and TX */ 854 rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN)); 855 856 usbd_xfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]); 857 858 ifp->if_drv_flags |= IFF_DRV_RUNNING; 859 rue_start(ue); 860} 861 862/* 863 * Set media options. 864 */ 865static int 866rue_ifmedia_upd(struct ifnet *ifp) 867{ 868 struct rue_softc *sc = ifp->if_softc; 869 struct mii_data *mii = GET_MII(sc); 870 struct mii_softc *miisc; 871 872 RUE_LOCK_ASSERT(sc, MA_OWNED); 873 874 sc->sc_flags &= ~RUE_FLAG_LINK; 875 LIST_FOREACH(miisc, &mii->mii_phys, mii_list) 876 PHY_RESET(miisc); 877 mii_mediachg(mii); 878 return (0); 879} 880 881/* 882 * Report current media status. 883 */ 884static void 885rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) 886{ 887 struct rue_softc *sc = ifp->if_softc; 888 struct mii_data *mii = GET_MII(sc); 889 890 RUE_LOCK(sc); 891 mii_pollstat(mii); 892 ifmr->ifm_active = mii->mii_media_active; 893 ifmr->ifm_status = mii->mii_media_status; 894 RUE_UNLOCK(sc); 895} 896 897static void 898rue_stop(struct usb_ether *ue) 899{ 900 struct rue_softc *sc = uether_getsc(ue); 901 struct ifnet *ifp = uether_getifp(ue); 902 903 RUE_LOCK_ASSERT(sc, MA_OWNED); 904 905 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 906 sc->sc_flags &= ~RUE_FLAG_LINK; 907 908 /* 909 * stop all the transfers, if not already stopped: 910 */ 911 usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]); 912 usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]); 913 usbd_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]); 914 915 rue_csr_write_1(sc, RUE_CR, 0x00); 916 917 rue_reset(sc); 918} 919