sys/dev/netif/rue/if_rue.c

   1 /*-
   2  * Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>.
   3  * 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  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26 /*-
  27  * Copyright (c) 1997, 1998, 1999, 2000
  28  *      Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
  29  *
  30  * Redistribution and use in source and binary forms, with or without
  31  * modification, are permitted provided that the following conditions
  32  * are met:
  33  * 1. Redistributions of source code must retain the above copyright
  34  *    notice, this list of conditions and the following disclaimer.
  35  * 2. Redistributions in binary form must reproduce the above copyright
  36  *    notice, this list of conditions and the following disclaimer in the
  37  *    documentation and/or other materials provided with the distribution.
  38  * 3. All advertising materials mentioning features or use of this software
  39  *    must display the following acknowledgement:
  40  *      This product includes software developed by Bill Paul.
  41  * 4. Neither the name of the author nor the names of any co-contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  48  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  49  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  50  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  51  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  52  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  53  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  54  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  55  * THE POSSIBILITY OF SUCH DAMAGE.
  56  *
  57  * $FreeBSD: src/sys/dev/usb/if_rue.c,v 1.14 2004/06/09 14:34:03 naddy Exp $
  58  * $DragonFly: src/sys/dev/netif/rue/if_rue.c,v 1.13 2008/05/14 11:59:21 sephe Exp $
  59  */
  60
  61 /*
  62  * RealTek RTL8150 USB to fast ethernet controller driver.
  63  * Datasheet is available from
  64  * ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/.
  65  */
  66
  67 #include <sys/param.h>
  68 #include <sys/systm.h>
  69 #include <sys/sockio.h>
  70 #include <sys/mbuf.h>
  71 #include <sys/malloc.h>
  72 #include <sys/kernel.h>
  73 #include <sys/module.h>
  74 #include <sys/socket.h>
  75 #include <sys/sysctl.h>
  76 #include <sys/bus.h>
  77
  78 #include <net/if.h>
  79 #include <net/if_arp.h>
  80 #include <net/ethernet.h>
  81 #include <net/if_dl.h>
  82 #include <net/if_media.h>
  83 #include <net/ifq_var.h>
  84
  85 #include <net/bpf.h>
  86
  87 #include <bus/usb/usb.h>
  88 #include <bus/usb/usbdi.h>
  89 #include <bus/usb/usbdi_util.h>
  90 #include <bus/usb/usbdivar.h>
  91 #include <bus/usb/usb_ethersubr.h>
  92
  93 #include <dev/netif/mii_layer/mii.h>
  94 #include <dev/netif/mii_layer/miivar.h>
  95
  96 #include <dev/netif/rue/if_ruereg.h>
  97
  98 #include "miibus_if.h"
  99
 100 #ifdef RUE_DEBUG
 101 SYSCTL_NODE(_hw, OID_AUTO, rue, CTLFLAG_RW, 0, "USB rue");
 102
 103 static int      rue_debug = 0;
 104 SYSCTL_INT(_hw_rue, OID_AUTO, debug, CTLFLAG_RW, &rue_debug, 0,
 105            "rue debug level");
 106
 107 /* XXX DPRINTF/DPRINTFN can be used only after rue_attach() */
 108 #define DPRINTFN(n, x)  do { if (rue_debug > (n)) if_printf x; } while (0)
 109 #else
 110 #define DPRINTFN(n, x)
 111 #endif
 112 #define DPRINTF(x)      DPRINTFN(0, x)
 113
 114 /*
 115  * Various supported device vendors/products.
 116  */
 117
 118 static const struct usb_devno rue_devs[] = {
 119         { USB_DEVICE(0x0411, 0x0012) }, /* Melco LUA-KTX*/
 120         { USB_DEVICE(0x0bda, 0x8150) }, /* Realtek USBKR100 (GREEN HOUSE) */
 121 };
 122
 123 static int rue_match(device_t);
 124 static int rue_attach(device_t);
 125 static int rue_detach(device_t);
 126
 127 static int rue_tx_list_init(struct rue_softc *);
 128 static int rue_rx_list_init(struct rue_softc *);
 129 static int rue_newbuf(struct rue_softc *, struct rue_chain *, struct mbuf *);
 130 static int rue_encap(struct rue_softc *, struct mbuf *, int);
 131 #ifdef RUE_INTR_PIPE
 132 static void rue_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
 133 #endif
 134 static void rue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
 135 static void rue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
 136 static void rue_tick(void *);
 137 static void rue_rxstart(struct ifnet *);
 138 static void rue_start(struct ifnet *);
 139 static int rue_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
 140 static void rue_init(void *);
 141 static void rue_stop(struct rue_softc *);
 142 static void rue_watchdog(struct ifnet *);
 143 static void rue_shutdown(device_t);
 144 static int rue_ifmedia_upd(struct ifnet *);
 145 static void rue_ifmedia_sts(struct ifnet *, struct ifmediareq *);
 146
 147 static int rue_miibus_readreg(device_t, int, int);
 148 static int rue_miibus_writereg(device_t, int, int, int);
 149 static void rue_miibus_statchg(device_t);
 150
 151 static void rue_setmulti(struct rue_softc *);
 152 static void rue_reset(struct rue_softc *);
 153
 154 static int rue_read_mem(struct rue_softc *, u_int16_t, void *, u_int16_t);
 155 static int rue_write_mem(struct rue_softc *, u_int16_t, void *, u_int16_t);
 156 static int rue_csr_read_1(struct rue_softc *, int);
 157 static int rue_csr_write_1(struct rue_softc *, int, u_int8_t);
 158 static int rue_csr_read_2(struct rue_softc *, int);
 159 static int rue_csr_write_2(struct rue_softc *, int, u_int16_t);
 160 static int rue_csr_write_4(struct rue_softc *, int, u_int32_t);
 161
 162 static device_method_t rue_methods[] = {
 163         /* Device interface */
 164         DEVMETHOD(device_probe, rue_match),
 165         DEVMETHOD(device_attach, rue_attach),
 166         DEVMETHOD(device_detach, rue_detach),
 167         DEVMETHOD(device_shutdown, rue_shutdown),
 168
 169         /* Bus interface */
 170         DEVMETHOD(bus_print_child, bus_generic_print_child),
 171         DEVMETHOD(bus_driver_added, bus_generic_driver_added),
 172
 173         /* MII interface */
 174         DEVMETHOD(miibus_readreg, rue_miibus_readreg),
 175         DEVMETHOD(miibus_writereg, rue_miibus_writereg),
 176         DEVMETHOD(miibus_statchg, rue_miibus_statchg),
 177
 178         { 0, 0 }
 179 };
 180
 181 static driver_t rue_driver = {
 182         "rue",
 183         rue_methods,
 184         sizeof(struct rue_softc)
 185 };
 186
 187 static devclass_t rue_devclass;
 188
 189 DRIVER_MODULE(rue, uhub, rue_driver, rue_devclass, usbd_driver_load, 0);
 190 DRIVER_MODULE(miibus, rue, miibus_driver, miibus_devclass, 0, 0);
 191 MODULE_DEPEND(rue, usb, 1, 1, 1);
 192 MODULE_DEPEND(rue, miibus, 1, 1, 1);
 193
 194 #define RUE_SETBIT(sc, reg, x) \
 195         rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) | (x))
 196
 197 #define RUE_CLRBIT(sc, reg, x) \
 198         rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) & ~(x))
 199
 200 #define RUE_SETBIT_2(sc, reg, x) \
 201         rue_csr_write_2(sc, reg, rue_csr_read_2(sc, reg) | (x))
 202
 203 #define RUE_CLRBIT_2(sc, reg, x) \
 204         rue_csr_write_2(sc, reg, rue_csr_read_2(sc, reg) & ~(x))
 205
 206 static int
 207 rue_read_mem(struct rue_softc *sc, u_int16_t addr, void *buf, u_int16_t len)
 208 {
 209         usb_device_request_t    req;
 210         usbd_status             err;
 211
 212         if (sc->rue_dying)
 213                 return (0);
 214
 215         RUE_LOCK(sc);
 216
 217         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 218         req.bRequest = UR_SET_ADDRESS;
 219         USETW(req.wValue, addr);
 220         USETW(req.wIndex, 0);
 221         USETW(req.wLength, len);
 222
 223         err = usbd_do_request(sc->rue_udev, &req, buf);
 224
 225         RUE_UNLOCK(sc);
 226
 227         if (err) {
 228                 if_printf(&sc->arpcom.ac_if, "control pipe read failed: %s\n",
 229                           usbd_errstr(err));
 230                 return (-1);
 231         }
 232
 233         return (0);
 234 }
 235
 236 static int
 237 rue_write_mem(struct rue_softc *sc, u_int16_t addr, void *buf, u_int16_t len)
 238 {
 239         usb_device_request_t    req;
 240         usbd_status             err;
 241
 242         if (sc->rue_dying)
 243                 return (0);
 244
 245         RUE_LOCK(sc);
 246
 247         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 248         req.bRequest = UR_SET_ADDRESS;
 249         USETW(req.wValue, addr);
 250         USETW(req.wIndex, 0);
 251         USETW(req.wLength, len);
 252
 253         err = usbd_do_request(sc->rue_udev, &req, buf);
 254
 255         RUE_UNLOCK(sc);
 256
 257         if (err) {
 258                 if_printf(&sc->arpcom.ac_if, "control pipe write failed: %s\n",
 259                           usbd_errstr(err));
 260                 return (-1);
 261         }
 262
 263         return (0);
 264 }
 265
 266 static int
 267 rue_csr_read_1(struct rue_softc *sc, int reg)
 268 {
 269         int             err;
 270         u_int8_t        val = 0;
 271
 272         err = rue_read_mem(sc, reg, &val, 1);
 273
 274         if (err)
 275                 return (0);
 276
 277         return (val);
 278 }
 279
 280 static int
 281 rue_csr_read_2(struct rue_softc *sc, int reg)
 282 {
 283         int             err;
 284         u_int16_t       val = 0;
 285         uWord           w;
 286
 287         USETW(w, val);
 288         err = rue_read_mem(sc, reg, &w, 2);
 289         val = UGETW(w);
 290
 291         if (err)
 292                 return (0);
 293
 294         return (val);
 295 }
 296
 297 static int
 298 rue_csr_write_1(struct rue_softc *sc, int reg, u_int8_t val)
 299 {
 300         int     err;
 301
 302         err = rue_write_mem(sc, reg, &val, 1);
 303
 304         if (err)
 305                 return (-1);
 306
 307         return (0);
 308 }
 309
 310 static int
 311 rue_csr_write_2(struct rue_softc *sc, int reg, u_int16_t val)
 312 {
 313         int     err;
 314         uWord   w;
 315
 316         USETW(w, val);
 317         err = rue_write_mem(sc, reg, &w, 2);
 318
 319         if (err)
 320                 return (-1);
 321
 322         return (0);
 323 }
 324
 325 static int
 326 rue_csr_write_4(struct rue_softc *sc, int reg, u_int32_t val)
 327 {
 328         int     err;
 329         uDWord  dw;
 330
 331         USETDW(dw, val);
 332         err = rue_write_mem(sc, reg, &dw, 4);
 333
 334         if (err)
 335                 return (-1);
 336
 337         return (0);
 338 }
 339
 340 static int
 341 rue_miibus_readreg(device_t dev, int phy, int reg)
 342 {
 343         struct rue_softc        *sc = device_get_softc(dev);
 344         int                     rval;
 345         int                     ruereg;
 346
 347         if (phy != 0)           /* RTL8150 supports PHY == 0, only */
 348                 return (0);
 349
 350         switch (reg) {
 351         case MII_BMCR:
 352                 ruereg = RUE_BMCR;
 353                 break;
 354         case MII_BMSR:
 355                 ruereg = RUE_BMSR;
 356                 break;
 357         case MII_ANAR:
 358                 ruereg = RUE_ANAR;
 359                 break;
 360         case MII_ANER:
 361                 ruereg = RUE_AER;
 362                 break;
 363         case MII_ANLPAR:
 364                 ruereg = RUE_ANLP;
 365                 break;
 366         case MII_PHYIDR1:
 367         case MII_PHYIDR2:
 368                 return (0);
 369                 break;
 370         default:
 371                 if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) {
 372                         rval = rue_csr_read_1(sc, reg);
 373                         return (rval);
 374                 }
 375                 if_printf(&sc->arpcom.ac_if, "bad phy register\n");
 376                 return (0);
 377         }
 378
 379         rval = rue_csr_read_2(sc, ruereg);
 380
 381         return (rval);
 382 }
 383
 384 static int
 385 rue_miibus_writereg(device_t dev, int phy, int reg, int data)
 386 {
 387         struct rue_softc        *sc = device_get_softc(dev);
 388         int                     ruereg;
 389
 390         if (phy != 0)           /* RTL8150 supports PHY == 0, only */
 391                 return (0);
 392
 393         switch (reg) {
 394         case MII_BMCR:
 395                 ruereg = RUE_BMCR;
 396                 break;
 397         case MII_BMSR:
 398                 ruereg = RUE_BMSR;
 399                 break;
 400         case MII_ANAR:
 401                 ruereg = RUE_ANAR;
 402                 break;
 403         case MII_ANER:
 404                 ruereg = RUE_AER;
 405                 break;
 406         case MII_ANLPAR:
 407                 ruereg = RUE_ANLP;
 408                 break;
 409         case MII_PHYIDR1:
 410         case MII_PHYIDR2:
 411                 return (0);
 412                 break;
 413         default:
 414                 if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) {
 415                         rue_csr_write_1(sc, reg, data);
 416                         return (0);
 417                 }
 418                 if_printf(&sc->arpcom.ac_if, "bad phy register\n");
 419                 return (0);
 420         }
 421         rue_csr_write_2(sc, ruereg, data);
 422
 423         return (0);
 424 }
 425
 426 static void
 427 rue_miibus_statchg(device_t dev)
 428 {
 429 }
 430
 431 /*
 432  * Program the 64-bit multicast hash filter.
 433  */
 434
 435 static void
 436 rue_setmulti(struct rue_softc *sc)
 437 {
 438         struct ifnet            *ifp;
 439         int                     h = 0;
 440         u_int32_t               hashes[2] = { 0, 0 };
 441         struct ifmultiaddr      *ifma;
 442         u_int32_t               rxcfg;
 443         int                     mcnt = 0;
 444
 445         ifp = &sc->arpcom.ac_if;
 446
 447         rxcfg = rue_csr_read_2(sc, RUE_RCR);
 448
 449         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
 450                 rxcfg |= (RUE_RCR_AAM | RUE_RCR_AAP);
 451                 rxcfg &= ~RUE_RCR_AM;
 452                 rue_csr_write_2(sc, RUE_RCR, rxcfg);
 453                 rue_csr_write_4(sc, RUE_MAR0, 0xFFFFFFFF);
 454                 rue_csr_write_4(sc, RUE_MAR4, 0xFFFFFFFF);
 455                 return;
 456         }
 457
 458         /* first, zot all the existing hash bits */
 459         rue_csr_write_4(sc, RUE_MAR0, 0);
 460         rue_csr_write_4(sc, RUE_MAR4, 0);
 461
 462         /* now program new ones */
 463         TAILQ_FOREACH (ifma, &ifp->if_multiaddrs, ifma_link) {
 464                 if (ifma->ifma_addr->sa_family != AF_LINK)
 465                         continue;
 466                 h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
 467                     ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 468                 if (h < 32)
 469                         hashes[0] |= (1 << h);
 470                 else
 471                         hashes[1] |= (1 << (h - 32));
 472                 mcnt++;
 473         }
 474
 475         if (mcnt)
 476                 rxcfg |= RUE_RCR_AM;
 477         else
 478                 rxcfg &= ~RUE_RCR_AM;
 479
 480         rxcfg &= ~(RUE_RCR_AAM | RUE_RCR_AAP);
 481
 482         rue_csr_write_2(sc, RUE_RCR, rxcfg);
 483         rue_csr_write_4(sc, RUE_MAR0, hashes[0]);
 484         rue_csr_write_4(sc, RUE_MAR4, hashes[1]);
 485 }
 486
 487 static void
 488 rue_reset(struct rue_softc *sc)
 489 {
 490         int     i;
 491
 492         rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST);
 493
 494         for (i = 0; i < RUE_TIMEOUT; i++) {
 495                 DELAY(500);
 496                 if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST))
 497                         break;
 498         }
 499         if (i == RUE_TIMEOUT)
 500                 if_printf(&sc->arpcom.ac_if, "reset never completed!\n");
 501
 502         DELAY(10000);
 503 }
 504
 505 /*
 506  * Probe for a RTL8150 chip.
 507  */
 508
 509 static int
 510 rue_match(device_t self)
 511 {
 512         struct usb_attach_arg *uaa = device_get_ivars(self);
 513
 514         if (uaa->iface == NULL)
 515                 return (UMATCH_NONE);
 516
 517         return (usb_lookup(rue_devs, uaa->vendor, uaa->product) != NULL ?
 518                 UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
 519 }
 520
 521 /*
 522  * Attach the interface. Allocate softc structures, do ifmedia
 523  * setup and ethernet/BPF attach.
 524  */
 525
 526 static int
 527 rue_attach(device_t self)
 528 {
 529         struct rue_softc *sc = device_get_softc(self);
 530         struct usb_attach_arg *uaa = device_get_ivars(self);
 531         uint8_t                         eaddr[ETHER_ADDR_LEN];
 532         struct ifnet                    *ifp;
 533         usb_interface_descriptor_t      *id;
 534         usb_endpoint_descriptor_t       *ed;
 535         int                             i;
 536
 537         sc->rue_udev = uaa->device;
 538
 539         if (usbd_set_config_no(sc->rue_udev, RUE_CONFIG_NO, 0)) {
 540                 device_printf(self, "setting config no %d failed\n",
 541                               RUE_CONFIG_NO);
 542                 return ENXIO;
 543         }
 544
 545         if (usbd_device2interface_handle(uaa->device, RUE_IFACE_IDX,
 546                                          &sc->rue_iface)) {
 547                 device_printf(self, "getting interface handle failed\n");
 548                 return ENXIO;
 549         }
 550
 551         id = usbd_get_interface_descriptor(sc->rue_iface);
 552
 553         /* Find endpoints */
 554         for (i = 0; i < id->bNumEndpoints; i++) {
 555                 ed = usbd_interface2endpoint_descriptor(sc->rue_iface, i);
 556                 if (ed == NULL) {
 557                         device_printf(self, "couldn't get ep %d\n", i);
 558                         return ENXIO;
 559                 }
 560                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 561                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 562                         sc->rue_ed[RUE_ENDPT_RX] = ed->bEndpointAddress;
 563                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 564                            UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 565                         sc->rue_ed[RUE_ENDPT_TX] = ed->bEndpointAddress;
 566                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 567                            UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
 568                         sc->rue_ed[RUE_ENDPT_INTR] = ed->bEndpointAddress;
 569                 }
 570         }
 571
 572         ifp = &sc->arpcom.ac_if;
 573         if_initname(ifp, device_get_name(self), device_get_unit(self));
 574
 575         /* Reset the adapter */
 576         rue_reset(sc);
 577
 578         /* Get station address from the EEPROM */
 579         if (rue_read_mem(sc, RUE_EEPROM_IDR0, eaddr, ETHER_ADDR_LEN)) {
 580                 device_printf(self, "couldn't get station address\n");
 581                 return ENXIO;
 582         }
 583
 584         ifp->if_softc = sc;
 585         ifp->if_mtu = ETHERMTU;
 586         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 587         ifp->if_ioctl = rue_ioctl;
 588         ifp->if_start = rue_start;
 589         ifp->if_watchdog = rue_watchdog;
 590         ifp->if_init = rue_init;
 591         ifp->if_baudrate = 10000000;
 592         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 593         ifq_set_ready(&ifp->if_snd);
 594
 595         /* MII setup */
 596         if (mii_phy_probe(self, &sc->rue_miibus,
 597                           rue_ifmedia_upd, rue_ifmedia_sts)) {
 598                 device_printf(self, "MII without any PHY!\n");
 599                 return ENXIO;
 600         }
 601
 602         /* Call MI attach routine */
 603         ether_ifattach(ifp, eaddr, NULL);
 604
 605         callout_init(&sc->rue_stat_ch);
 606         sc->rue_dying = 0;
 607
 608         usb_register_netisr();
 609
 610         return 0;
 611 }
 612
 613 static int
 614 rue_detach(device_t dev)
 615 {
 616         struct rue_softc        *sc;
 617         struct ifnet            *ifp;
 618
 619         sc = device_get_softc(dev);
 620         RUE_LOCK(sc);
 621         ifp = &sc->arpcom.ac_if;
 622
 623         sc->rue_dying = 1;
 624         callout_stop(&sc->rue_stat_ch);
 625
 626         ether_ifdetach(ifp);
 627
 628         if (sc->rue_ep[RUE_ENDPT_TX] != NULL)
 629                 usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_TX]);
 630         if (sc->rue_ep[RUE_ENDPT_RX] != NULL)
 631                 usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_RX]);
 632 #ifdef RUE_INTR_PIPE
 633         if (sc->rue_ep[RUE_ENDPT_INTR] != NULL)
 634                 usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_INTR]);
 635 #endif
 636
 637         RUE_UNLOCK(sc);
 638
 639         return (0);
 640 }
 641
 642 /*
 643  * Initialize an RX descriptor and attach an MBUF cluster.
 644  */
 645
 646 static int
 647 rue_newbuf(struct rue_softc *sc, struct rue_chain *c, struct mbuf *m)
 648 {
 649         struct mbuf     *m_new = NULL;
 650
 651         if (m == NULL) {
 652                 m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
 653                 if (m_new == NULL) {
 654                         if_printf(&sc->arpcom.ac_if, "no memory for rx list "
 655                                   "-- packet dropped!\n");
 656                         return (ENOBUFS);
 657                 }
 658                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 659         } else {
 660                 m_new = m;
 661                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 662                 m_new->m_data = m_new->m_ext.ext_buf;
 663         }
 664
 665         m_adj(m_new, ETHER_ALIGN);
 666         c->rue_mbuf = m_new;
 667
 668         return (0);
 669 }
 670
 671 static int
 672 rue_rx_list_init(struct rue_softc *sc)
 673 {
 674         struct rue_cdata        *cd;
 675         struct rue_chain        *c;
 676         int                     i;
 677
 678         cd = &sc->rue_cdata;
 679         for (i = 0; i < RUE_RX_LIST_CNT; i++) {
 680                 c = &cd->rue_rx_chain[i];
 681                 c->rue_sc = sc;
 682                 c->rue_idx = i;
 683                 if (rue_newbuf(sc, c, NULL) == ENOBUFS)
 684                         return (ENOBUFS);
 685                 if (c->rue_xfer == NULL) {
 686                         c->rue_xfer = usbd_alloc_xfer(sc->rue_udev);
 687                         if (c->rue_xfer == NULL)
 688                                 return (ENOBUFS);
 689                 }
 690         }
 691
 692         return (0);
 693 }
 694
 695 static int
 696 rue_tx_list_init(struct rue_softc *sc)
 697 {
 698         struct rue_cdata        *cd;
 699         struct rue_chain        *c;
 700         int                     i;
 701
 702         cd = &sc->rue_cdata;
 703         for (i = 0; i < RUE_TX_LIST_CNT; i++) {
 704                 c = &cd->rue_tx_chain[i];
 705                 c->rue_sc = sc;
 706                 c->rue_idx = i;
 707                 c->rue_mbuf = NULL;
 708                 if (c->rue_xfer == NULL) {
 709                         c->rue_xfer = usbd_alloc_xfer(sc->rue_udev);
 710                         if (c->rue_xfer == NULL)
 711                                 return (ENOBUFS);
 712                 }
 713                 c->rue_buf = kmalloc(RUE_BUFSZ, M_USBDEV, M_WAITOK);
 714         }
 715
 716         return (0);
 717 }
 718
 719 #ifdef RUE_INTR_PIPE
 720 static void
 721 rue_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 722 {
 723         struct rue_softc        *sc = priv;
 724         struct ifnet            *ifp;
 725         struct rue_intrpkt      *p;
 726
 727         RUE_LOCK(sc);
 728         ifp = &sc->arpcom.ac_if;
 729
 730         if (!(ifp->if_flags & IFF_RUNNING)) {
 731                 RUE_UNLOCK(sc);
 732                 return;
 733         }
 734
 735         if (status != USBD_NORMAL_COMPLETION) {
 736                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 737                         RUE_UNLOCK(sc);
 738                         return;
 739                 }
 740                 if_printf(ifp, "usb error on intr: %s\n", usbd_errstr(status));
 741                 if (status == USBD_STALLED)
 742                         usbd_clear_endpoint_stall(sc->rue_ep[RUE_ENDPT_INTR]);
 743                 RUE_UNLOCK(sc);
 744                 return;
 745         }
 746
 747         usbd_get_xfer_status(xfer, NULL, (void **)&p, NULL, NULL);
 748
 749         ifp->if_ierrors += p->rue_rxlost_cnt;
 750         ifp->if_ierrors += p->rue_crcerr_cnt;
 751         ifp->if_collisions += p->rue_col_cnt;
 752
 753         RUE_UNLOCK(sc);
 754 }
 755 #endif
 756
 757 static void
 758 rue_rxstart(struct ifnet *ifp)
 759 {
 760         struct rue_softc        *sc;
 761         struct rue_chain        *c;
 762
 763         sc = ifp->if_softc;
 764         RUE_LOCK(sc);
 765         c = &sc->rue_cdata.rue_rx_chain[sc->rue_cdata.rue_rx_prod];
 766
 767         if (rue_newbuf(sc, c, NULL) == ENOBUFS) {
 768                 ifp->if_ierrors++;
 769                 RUE_UNLOCK(sc);
 770                 return;
 771         }
 772
 773         /* Setup new transfer. */
 774         usbd_setup_xfer(c->rue_xfer, sc->rue_ep[RUE_ENDPT_RX],
 775                 c, mtod(c->rue_mbuf, char *), RUE_BUFSZ, USBD_SHORT_XFER_OK,
 776                 USBD_NO_TIMEOUT, rue_rxeof);
 777         usbd_transfer(c->rue_xfer);
 778
 779         RUE_UNLOCK(sc);
 780 }
 781
 782 /*
 783  * A frame has been uploaded: pass the resulting mbuf chain up to
 784  * the higher level protocols.
 785  */
 786
 787 static void
 788 rue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 789 {
 790         struct rue_chain        *c = priv;
 791         struct rue_softc        *sc = c->rue_sc;
 792         struct mbuf             *m;
 793         struct ifnet            *ifp;
 794         int                     total_len = 0;
 795         struct rue_rxpkt        r;
 796
 797         if (sc->rue_dying)
 798                 return;
 799         RUE_LOCK(sc);
 800         ifp = &sc->arpcom.ac_if;
 801
 802         if (!(ifp->if_flags & IFF_RUNNING)) {
 803                 RUE_UNLOCK(sc);
 804                 return;
 805         }
 806
 807         if (status != USBD_NORMAL_COMPLETION) {
 808                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 809                         RUE_UNLOCK(sc);
 810                         return;
 811                 }
 812                 if (usbd_ratecheck(&sc->rue_rx_notice)) {
 813                         if_printf(ifp, "usb error on rx: %s\n",
 814                                   usbd_errstr(status));
 815                 }
 816                 if (status == USBD_STALLED)
 817                         usbd_clear_endpoint_stall(sc->rue_ep[RUE_ENDPT_RX]);
 818                 goto done;
 819         }
 820
 821         usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
 822
 823         if (total_len <= ETHER_CRC_LEN) {
 824                 ifp->if_ierrors++;
 825                 goto done;
 826         }
 827
 828         m = c->rue_mbuf;
 829         bcopy(mtod(m, char *) + total_len - 4, (char *)&r, sizeof (r));
 830
 831         /* Check recieve packet was valid or not */
 832         if ((r.rue_rxstat & RUE_RXSTAT_VALID) == 0) {
 833                 ifp->if_ierrors++;
 834                 goto done;
 835         }
 836
 837         /* No errors; receive the packet. */
 838         total_len -= ETHER_CRC_LEN;
 839
 840         ifp->if_ipackets++;
 841         m->m_pkthdr.rcvif = ifp;
 842         m->m_pkthdr.len = m->m_len = total_len;
 843
 844         /* Put the packet on the special USB input queue. */
 845         usb_ether_input(m);
 846         rue_rxstart(ifp);
 847
 848         RUE_UNLOCK(sc);
 849         return;
 850
 851     done:
 852         /* Setup new transfer. */
 853         usbd_setup_xfer(xfer, sc->rue_ep[RUE_ENDPT_RX],
 854                         c, mtod(c->rue_mbuf, char *), RUE_BUFSZ,
 855                         USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, rue_rxeof);
 856         usbd_transfer(xfer);
 857         RUE_UNLOCK(sc);
 858 }
 859
 860 /*
 861  * A frame was downloaded to the chip. It's safe for us to clean up
 862  * the list buffers.
 863  */
 864
 865 static void
 866 rue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 867 {
 868         struct rue_chain        *c = priv;
 869         struct rue_softc        *sc = c->rue_sc;
 870         struct ifnet            *ifp;
 871         usbd_status             err;
 872
 873         RUE_LOCK(sc);
 874
 875         ifp = &sc->arpcom.ac_if;
 876
 877         if (status != USBD_NORMAL_COMPLETION) {
 878                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 879                         RUE_UNLOCK(sc);
 880                         return;
 881                 }
 882                 if_printf(ifp, "usb error on tx: %s\n", usbd_errstr(status));
 883                 if (status == USBD_STALLED)
 884                         usbd_clear_endpoint_stall(sc->rue_ep[RUE_ENDPT_TX]);
 885                 RUE_UNLOCK(sc);
 886                 return;
 887         }
 888
 889         ifp->if_timer = 0;
 890         ifp->if_flags &= ~IFF_OACTIVE;
 891         usbd_get_xfer_status(c->rue_xfer, NULL, NULL, NULL, &err);
 892
 893         if (c->rue_mbuf != NULL) {
 894                 m_freem(c->rue_mbuf);
 895                 c->rue_mbuf = NULL;
 896         }
 897
 898         if (err)
 899                 ifp->if_oerrors++;
 900         else
 901                 ifp->if_opackets++;
 902
 903         if (!ifq_is_empty(&ifp->if_snd))
 904                 if_devstart(ifp);
 905
 906         RUE_UNLOCK(sc);
 907 }
 908
 909 static void
 910 rue_tick(void *xsc)
 911 {
 912         struct rue_softc        *sc = xsc;
 913         struct ifnet            *ifp;
 914         struct mii_data         *mii;
 915
 916         if (sc == NULL)
 917                 return;
 918
 919         RUE_LOCK(sc);
 920
 921         ifp = &sc->arpcom.ac_if;
 922         mii = GET_MII(sc);
 923         if (mii == NULL) {
 924                 RUE_UNLOCK(sc);
 925                 return;
 926         }
 927
 928         mii_tick(mii);
 929         if (!sc->rue_link && mii->mii_media_status & IFM_ACTIVE &&
 930             IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
 931                 sc->rue_link++;
 932                 if (!ifq_is_empty(&ifp->if_snd))
 933                         if_devstart(ifp);
 934         }
 935
 936         callout_reset(&sc->rue_stat_ch, hz, rue_tick, sc);
 937
 938         RUE_UNLOCK(sc);
 939 }
 940
 941 static int
 942 rue_encap(struct rue_softc *sc, struct mbuf *m, int idx)
 943 {
 944         int                     total_len;
 945         struct rue_chain        *c;
 946         usbd_status             err;
 947
 948         c = &sc->rue_cdata.rue_tx_chain[idx];
 949
 950         /*
 951          * Copy the mbuf data into a contiguous buffer
 952          */
 953         m_copydata(m, 0, m->m_pkthdr.len, c->rue_buf);
 954         c->rue_mbuf = m;
 955
 956         total_len = m->m_pkthdr.len;
 957
 958         /*
 959          * This is an undocumented behavior.
 960          * RTL8150 chip doesn't send frame length smaller than
 961          * RUE_MIN_FRAMELEN (60) byte packet.
 962          */
 963         if (total_len < RUE_MIN_FRAMELEN)
 964                 total_len = RUE_MIN_FRAMELEN;
 965
 966         usbd_setup_xfer(c->rue_xfer, sc->rue_ep[RUE_ENDPT_TX],
 967                         c, c->rue_buf, total_len, USBD_FORCE_SHORT_XFER,
 968                         10000, rue_txeof);
 969
 970         /* Transmit */
 971         err = usbd_transfer(c->rue_xfer);
 972         if (err != USBD_IN_PROGRESS) {
 973                 rue_stop(sc);
 974                 return (EIO);
 975         }
 976
 977         sc->rue_cdata.rue_tx_cnt++;
 978
 979         return (0);
 980 }
 981
 982 static void
 983 rue_start(struct ifnet *ifp)
 984 {
 985         struct rue_softc        *sc = ifp->if_softc;
 986         struct mbuf             *m_head = NULL;
 987
 988         RUE_LOCK(sc);
 989
 990         if (!sc->rue_link) {
 991                 ifq_purge(&ifp->if_snd);
 992                 RUE_UNLOCK(sc);
 993                 return;
 994         }
 995
 996         if (ifp->if_flags & IFF_OACTIVE) {
 997                 RUE_UNLOCK(sc);
 998                 return;
 999         }
1000
1001         m_head = ifq_dequeue(&ifp->if_snd, NULL);
1002         if (m_head == NULL) {
1003                 RUE_UNLOCK(sc);
1004                 return;
1005         }
1006
1007         if (rue_encap(sc, m_head, 0)) {
1008                 /* rue_encap() will free m_head, if we reach here */
1009                 ifp->if_flags |= IFF_OACTIVE;
1010                 RUE_UNLOCK(sc);
1011                 return;
1012         }
1013
1014         /*
1015          * If there's a BPF listener, bounce a copy of this frame
1016          * to him.
1017          */
1018         BPF_MTAP(ifp, m_head);
1019
1020         ifp->if_flags |= IFF_OACTIVE;
1021
1022         /*
1023          * Set a timeout in case the chip goes out to lunch.
1024          */
1025         ifp->if_timer = 5;
1026
1027         RUE_UNLOCK(sc);
1028 }
1029
1030 static void
1031 rue_init(void *xsc)
1032 {
1033         struct rue_softc        *sc = xsc;
1034         struct ifnet            *ifp = &sc->arpcom.ac_if;
1035         struct mii_data         *mii = GET_MII(sc);
1036         struct rue_chain        *c;
1037         usbd_status             err;
1038         int                     i;
1039         int                     rxcfg;
1040
1041         RUE_LOCK(sc);
1042
1043         if (ifp->if_flags & IFF_RUNNING) {
1044                 RUE_UNLOCK(sc);
1045                 return;
1046         }
1047
1048         /*
1049          * Cancel pending I/O and free all RX/TX buffers.
1050          */
1051         rue_reset(sc);
1052
1053         /* Set MAC address */
1054         rue_write_mem(sc, RUE_IDR0, sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
1055
1056         /* Init TX ring. */
1057         if (rue_tx_list_init(sc) == ENOBUFS) {
1058                 if_printf(ifp, "tx list init failed\n");
1059                 RUE_UNLOCK(sc);
1060                 return;
1061         }
1062
1063         /* Init RX ring. */
1064         if (rue_rx_list_init(sc) == ENOBUFS) {
1065                 if_printf(ifp, "rx list init failed\n");
1066                 RUE_UNLOCK(sc);
1067                 return;
1068         }
1069
1070 #ifdef RUE_INTR_PIPE
1071         sc->rue_cdata.rue_ibuf = kmalloc(RUE_INTR_PKTLEN, M_USBDEV, M_WAITOK);
1072 #endif
1073
1074         /*
1075          * Set the initial TX and RX configuration.
1076          */
1077         rue_csr_write_1(sc, RUE_TCR, RUE_TCR_CONFIG);
1078
1079         rxcfg = RUE_RCR_CONFIG;
1080
1081         /* Set capture broadcast bit to capture broadcast frames. */
1082         if (ifp->if_flags & IFF_BROADCAST)
1083                 rxcfg |= RUE_RCR_AB;
1084         else
1085                 rxcfg &= ~RUE_RCR_AB;
1086
1087         /* If we want promiscuous mode, set the allframes bit. */
1088         if (ifp->if_flags & IFF_PROMISC)
1089                 rxcfg |= RUE_RCR_AAP;
1090         else
1091                 rxcfg &= ~RUE_RCR_AAP;
1092
1093         rue_csr_write_2(sc, RUE_RCR, rxcfg);
1094
1095         /* Load the multicast filter. */
1096         rue_setmulti(sc);
1097
1098         /* Enable RX and TX */
1099         rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN));
1100
1101         mii_mediachg(mii);
1102
1103         /* Open RX and TX pipes. */
1104         err = usbd_open_pipe(sc->rue_iface, sc->rue_ed[RUE_ENDPT_RX],
1105                              USBD_EXCLUSIVE_USE, &sc->rue_ep[RUE_ENDPT_RX]);
1106         if (err) {
1107                 if_printf(ifp, "open rx pipe failed: %s\n", usbd_errstr(err));
1108                 RUE_UNLOCK(sc);
1109                 return;
1110         }
1111         err = usbd_open_pipe(sc->rue_iface, sc->rue_ed[RUE_ENDPT_TX],
1112                              USBD_EXCLUSIVE_USE, &sc->rue_ep[RUE_ENDPT_TX]);
1113         if (err) {
1114                 if_printf(ifp, "open tx pipe failed: %s\n", usbd_errstr(err));
1115                 RUE_UNLOCK(sc);
1116                 return;
1117         }
1118
1119 #ifdef RUE_INTR_PIPE
1120         err = usbd_open_pipe_intr(sc->rue_iface, sc->rue_ed[RUE_ENDPT_INTR],
1121                                   USBD_SHORT_XFER_OK,
1122                                   &sc->rue_ep[RUE_ENDPT_INTR], sc,
1123                                   sc->rue_cdata.rue_ibuf, RUE_INTR_PKTLEN,
1124                                   rue_intr, RUE_INTR_INTERVAL);
1125         if (err) {
1126                 if_printf(ifp, "open intr pipe failed: %s\n", usbd_errstr(err));
1127                 RUE_UNLOCK(sc);
1128                 return;
1129         }
1130 #endif
1131
1132         /* Start up the receive pipe. */
1133         for (i = 0; i < RUE_RX_LIST_CNT; i++) {
1134                 c = &sc->rue_cdata.rue_rx_chain[i];
1135                 usbd_setup_xfer(c->rue_xfer, sc->rue_ep[RUE_ENDPT_RX],
1136                                 c, mtod(c->rue_mbuf, char *), RUE_BUFSZ,
1137                                 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, rue_rxeof);
1138                 usbd_transfer(c->rue_xfer);
1139         }
1140
1141         ifp->if_flags |= IFF_RUNNING;
1142         ifp->if_flags &= ~IFF_OACTIVE;
1143
1144         callout_reset(&sc->rue_stat_ch, hz, rue_tick, sc);
1145
1146         RUE_UNLOCK(sc);
1147 }
1148
1149 /*
1150  * Set media options.
1151  */
1152
1153 static int
1154 rue_ifmedia_upd(struct ifnet *ifp)
1155 {
1156         struct rue_softc        *sc = ifp->if_softc;
1157         struct mii_data         *mii = GET_MII(sc);
1158
1159         sc->rue_link = 0;
1160         if (mii->mii_instance) {
1161                 struct mii_softc        *miisc;
1162                 LIST_FOREACH (miisc, &mii->mii_phys, mii_list)
1163                         mii_phy_reset(miisc);
1164         }
1165         mii_mediachg(mii);
1166
1167         return (0);
1168 }
1169
1170 /*
1171  * Report current media status.
1172  */
1173
1174 static void
1175 rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1176 {
1177         struct rue_softc        *sc = ifp->if_softc;
1178         struct mii_data         *mii = GET_MII(sc);
1179
1180         mii_pollstat(mii);
1181         ifmr->ifm_active = mii->mii_media_active;
1182         ifmr->ifm_status = mii->mii_media_status;
1183 }
1184
1185 static int
1186 rue_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
1187 {
1188         struct rue_softc        *sc = ifp->if_softc;
1189         struct ifreq            *ifr = (struct ifreq *)data;
1190         struct mii_data         *mii;
1191         int                     error = 0;
1192
1193         RUE_LOCK(sc);
1194
1195         switch (command) {
1196         case SIOCSIFFLAGS:
1197                 if (ifp->if_flags & IFF_UP) {
1198                         if (ifp->if_flags & IFF_RUNNING &&
1199                             ifp->if_flags & IFF_PROMISC &&
1200                             !(sc->rue_if_flags & IFF_PROMISC)) {
1201                                 RUE_SETBIT_2(sc, RUE_RCR,
1202                                              (RUE_RCR_AAM | RUE_RCR_AAP));
1203                                 rue_setmulti(sc);
1204                         } else if (ifp->if_flags & IFF_RUNNING &&
1205                                    !(ifp->if_flags & IFF_PROMISC) &&
1206                                    sc->rue_if_flags & IFF_PROMISC) {
1207                                 RUE_CLRBIT_2(sc, RUE_RCR,
1208                                              (RUE_RCR_AAM | RUE_RCR_AAP));
1209                                 rue_setmulti(sc);
1210                         } else if (!(ifp->if_flags & IFF_RUNNING))
1211                                 rue_init(sc);
1212                 } else {
1213                         if (ifp->if_flags & IFF_RUNNING)
1214                                 rue_stop(sc);
1215                 }
1216                 sc->rue_if_flags = ifp->if_flags;
1217                 error = 0;
1218                 break;
1219         case SIOCADDMULTI:
1220         case SIOCDELMULTI:
1221                 rue_setmulti(sc);
1222                 error = 0;
1223                 break;
1224         case SIOCGIFMEDIA:
1225         case SIOCSIFMEDIA:
1226                 mii = GET_MII(sc);
1227                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
1228                 break;
1229         default:
1230                 error = ether_ioctl(ifp, command, data);
1231                 break;
1232         }
1233
1234         RUE_UNLOCK(sc);
1235
1236         return (error);
1237 }
1238
1239 static void
1240 rue_watchdog(struct ifnet *ifp)
1241 {
1242         struct rue_softc        *sc = ifp->if_softc;
1243         struct rue_chain        *c;
1244         usbd_status             stat;
1245
1246         RUE_LOCK(sc);
1247
1248         ifp->if_oerrors++;
1249         if_printf(ifp, "watchdog timeout\n");
1250
1251         c = &sc->rue_cdata.rue_tx_chain[0];
1252         usbd_get_xfer_status(c->rue_xfer, NULL, NULL, NULL, &stat);
1253         rue_txeof(c->rue_xfer, c, stat);
1254
1255         if (!ifq_is_empty(&ifp->if_snd))
1256                 if_devstart(ifp);
1257
1258         RUE_UNLOCK(sc);
1259 }
1260
1261 /*
1262  * Stop the adapter and free any mbufs allocated to the
1263  * RX and TX lists.
1264  */
1265
1266 static void
1267 rue_stop(struct rue_softc *sc)
1268 {
1269         usbd_status     err;
1270         struct ifnet    *ifp;
1271         int             i;
1272
1273         RUE_LOCK(sc);
1274
1275         ifp = &sc->arpcom.ac_if;
1276         ifp->if_timer = 0;
1277
1278         rue_csr_write_1(sc, RUE_CR, 0x00);
1279         rue_reset(sc);
1280
1281         callout_stop(&sc->rue_stat_ch);
1282
1283         /* Stop transfers. */
1284         if (sc->rue_ep[RUE_ENDPT_RX] != NULL) {
1285                 err = usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_RX]);
1286                 if (err) {
1287                         if_printf(ifp, "abort rx pipe failed: %s\n",
1288                                   usbd_errstr(err));
1289                 }
1290                 err = usbd_close_pipe(sc->rue_ep[RUE_ENDPT_RX]);
1291                 if (err) {
1292                         if_printf(ifp, "close rx pipe failed: %s\n",
1293                                   usbd_errstr(err));
1294                 }
1295                 sc->rue_ep[RUE_ENDPT_RX] = NULL;
1296         }
1297
1298         if (sc->rue_ep[RUE_ENDPT_TX] != NULL) {
1299                 err = usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_TX]);
1300                 if (err) {
1301                         if_printf(ifp, "abort tx pipe failed: %s\n",
1302                                   usbd_errstr(err));
1303                 }
1304                 err = usbd_close_pipe(sc->rue_ep[RUE_ENDPT_TX]);
1305                 if (err) {
1306                         if_printf(ifp, "close tx pipe failed: %s\n",
1307                                   usbd_errstr(err));
1308                 }
1309                 sc->rue_ep[RUE_ENDPT_TX] = NULL;
1310         }
1311
1312 #ifdef RUE_INTR_PIPE
1313         if (sc->rue_ep[RUE_ENDPT_INTR] != NULL) {
1314                 err = usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_INTR]);
1315                 if (err) {
1316                         if_printf(ifp, "abort intr pipe failed: %s\n",
1317                                   usbd_errstr(err));
1318                 }
1319                 err = usbd_close_pipe(sc->rue_ep[RUE_ENDPT_INTR]);
1320                 if (err) {
1321                         if_printf(ifp, "close intr pipe failed: %s\n",
1322                                   usbd_errstr(err));
1323                 }
1324                 sc->rue_ep[RUE_ENDPT_INTR] = NULL;
1325         }
1326 #endif
1327
1328         /* Free RX resources. */
1329         for (i = 0; i < RUE_RX_LIST_CNT; i++) {
1330                 if (sc->rue_cdata.rue_rx_chain[i].rue_buf != NULL) {
1331                         kfree(sc->rue_cdata.rue_rx_chain[i].rue_buf, M_USBDEV);
1332                         sc->rue_cdata.rue_rx_chain[i].rue_buf = NULL;
1333                 }
1334                 if (sc->rue_cdata.rue_rx_chain[i].rue_mbuf != NULL) {
1335                         m_freem(sc->rue_cdata.rue_rx_chain[i].rue_mbuf);
1336                         sc->rue_cdata.rue_rx_chain[i].rue_mbuf = NULL;
1337                 }
1338                 if (sc->rue_cdata.rue_rx_chain[i].rue_xfer != NULL) {
1339                         usbd_free_xfer(sc->rue_cdata.rue_rx_chain[i].rue_xfer);
1340                         sc->rue_cdata.rue_rx_chain[i].rue_xfer = NULL;
1341                 }
1342         }
1343
1344         /* Free TX resources. */
1345         for (i = 0; i < RUE_TX_LIST_CNT; i++) {
1346                 if (sc->rue_cdata.rue_tx_chain[i].rue_buf != NULL) {
1347                         kfree(sc->rue_cdata.rue_tx_chain[i].rue_buf, M_USBDEV);
1348                         sc->rue_cdata.rue_tx_chain[i].rue_buf = NULL;
1349                 }
1350                 if (sc->rue_cdata.rue_tx_chain[i].rue_mbuf != NULL) {
1351                         m_freem(sc->rue_cdata.rue_tx_chain[i].rue_mbuf);
1352                         sc->rue_cdata.rue_tx_chain[i].rue_mbuf = NULL;
1353                 }
1354                 if (sc->rue_cdata.rue_tx_chain[i].rue_xfer != NULL) {
1355                         usbd_free_xfer(sc->rue_cdata.rue_tx_chain[i].rue_xfer);
1356                         sc->rue_cdata.rue_tx_chain[i].rue_xfer = NULL;
1357                 }
1358         }
1359
1360 #ifdef RUE_INTR_PIPE
1361         if (sc->rue_cdata.rue_ibuf != NULL) {
1362                 kfree(sc->rue_cdata.rue_ibuf, M_USBDEV);
1363                 sc->rue_cdata.rue_ibuf = NULL;
1364         }
1365 #endif
1366
1367         sc->rue_link = 0;
1368
1369         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1370
1371         RUE_UNLOCK(sc);
1372 }
1373
1374 /*
1375  * Stop all chip I/O so that the kernel's probe routines don't
1376  * get confused by errant DMAs when rebooting.
1377  */
1378
1379 static void
1380 rue_shutdown(device_t dev)
1381 {
1382         struct rue_softc        *sc;
1383
1384         sc = device_get_softc(dev);
1385
1386         sc->rue_dying++;
1387         RUE_LOCK(sc);
1388         rue_reset(sc);
1389         rue_stop(sc);
1390         RUE_UNLOCK(sc);
1391 }