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