usb4bsd: Port aue(4), cue(4), ipheth(4) and kue(4) USB ethernet drivers.
[dragonfly.git] / sys / bus / u4b / net / if_kue.c
1 /*-
2  * Copyright (c) 1997, 1998, 1999, 2000
3  *      Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Bill Paul.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30  * THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * $FreeBSD: head/sys/dev/usb/net/if_kue.c 271832 2014-09-18 21:09:22Z glebius $
33  */
34
35 /*
36  * Kawasaki LSI KL5KUSB101B USB to ethernet adapter driver.
37  *
38  * Written by Bill Paul <wpaul@ee.columbia.edu>
39  * Electrical Engineering Department
40  * Columbia University, New York City
41  */
42
43 /*
44  * The KLSI USB to ethernet adapter chip contains an USB serial interface,
45  * ethernet MAC and embedded microcontroller (called the QT Engine).
46  * The chip must have firmware loaded into it before it will operate.
47  * Packets are passed between the chip and host via bulk transfers.
48  * There is an interrupt endpoint mentioned in the software spec, however
49  * it's currently unused. This device is 10Mbps half-duplex only, hence
50  * there is no media selection logic. The MAC supports a 128 entry
51  * multicast filter, though the exact size of the filter can depend
52  * on the firmware. Curiously, while the software spec describes various
53  * ethernet statistics counters, my sample adapter and firmware combination
54  * claims not to support any statistics counters at all.
55  *
56  * Note that once we load the firmware in the device, we have to be
57  * careful not to load it again: if you restart your computer but
58  * leave the adapter attached to the USB controller, it may remain
59  * powered on and retain its firmware. In this case, we don't need
60  * to load the firmware a second time.
61  *
62  * Special thanks to Rob Furr for providing an ADS Technologies
63  * adapter for development and testing. No monkeys were harmed during
64  * the development of this driver.
65  */
66
67 #include <sys/stdint.h>
68 #include <sys/param.h>
69 #include <sys/queue.h>
70 #include <sys/types.h>
71 #include <sys/systm.h>
72 #include <sys/socket.h>
73 #include <sys/kernel.h>
74 #include <sys/bus.h>
75 #include <sys/module.h>
76 #include <sys/lock.h>
77 #include <sys/condvar.h>
78 #include <sys/sysctl.h>
79 #include <sys/unistd.h>
80 #include <sys/callout.h>
81 #include <sys/malloc.h>
82 #include <sys/priv.h>
83
84 #include <net/if.h>
85 #include <net/if_var.h>
86 #include <net/ifq_var.h>
87
88 #include <bus/u4b/usb.h>
89 #include <bus/u4b/usbdi.h>
90 #include <bus/u4b/usbdi_util.h>
91 #include "usbdevs.h"
92
93 #define USB_DEBUG_VAR kue_debug
94 #include <bus/u4b/usb_debug.h>
95 #include <bus/u4b/usb_process.h>
96
97 #include <bus/u4b/net/usb_ethernet.h>
98 #include <bus/u4b/net/if_kuereg.h>
99 #include <bus/u4b/net/if_kuefw.h>
100
101 /*
102  * Various supported device vendors/products.
103  */
104 static const STRUCT_USB_HOST_ID kue_devs[] = {
105 #define KUE_DEV(v,p) { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
106         KUE_DEV(3COM, 3C19250),
107         KUE_DEV(3COM, 3C460),
108         KUE_DEV(ABOCOM, URE450),
109         KUE_DEV(ADS, UBS10BT),
110         KUE_DEV(ADS, UBS10BTX),
111         KUE_DEV(AOX, USB101),
112         KUE_DEV(ASANTE, EA),
113         KUE_DEV(ATEN, DSB650C),
114         KUE_DEV(ATEN, UC10T),
115         KUE_DEV(COREGA, ETHER_USB_T),
116         KUE_DEV(DLINK, DSB650C),
117         KUE_DEV(ENTREGA, E45),
118         KUE_DEV(ENTREGA, XX1),
119         KUE_DEV(ENTREGA, XX2),
120         KUE_DEV(IODATA, USBETT),
121         KUE_DEV(JATON, EDA),
122         KUE_DEV(KINGSTON, XX1),
123         KUE_DEV(KLSI, DUH3E10BT),
124         KUE_DEV(KLSI, DUH3E10BTN),
125         KUE_DEV(LINKSYS, USB10T),
126         KUE_DEV(MOBILITY, EA),
127         KUE_DEV(NETGEAR, EA101),
128         KUE_DEV(NETGEAR, EA101X),
129         KUE_DEV(PERACOM, ENET),
130         KUE_DEV(PERACOM, ENET2),
131         KUE_DEV(PERACOM, ENET3),
132         KUE_DEV(PORTGEAR, EA8),
133         KUE_DEV(PORTGEAR, EA9),
134         KUE_DEV(PORTSMITH, EEA),
135         KUE_DEV(SHARK, PA),
136         KUE_DEV(SILICOM, GPE),
137         KUE_DEV(SILICOM, U2E),
138         KUE_DEV(SMC, 2102USB),
139 #undef KUE_DEV
140 };
141
142 /* prototypes */
143
144 static device_probe_t kue_probe;
145 static device_attach_t kue_attach;
146 static device_detach_t kue_detach;
147
148 static usb_callback_t kue_bulk_read_callback;
149 static usb_callback_t kue_bulk_write_callback;
150
151 static uether_fn_t kue_attach_post;
152 static uether_fn_t kue_init;
153 static uether_fn_t kue_stop;
154 static uether_fn_t kue_start;
155 static uether_fn_t kue_setmulti;
156 static uether_fn_t kue_setpromisc;
157
158 static int      kue_do_request(struct kue_softc *,
159                     struct usb_device_request *, void *);
160 static int      kue_setword(struct kue_softc *, uint8_t, uint16_t);
161 static int      kue_ctl(struct kue_softc *, uint8_t, uint8_t, uint16_t,
162                     void *, int);
163 static int      kue_load_fw(struct kue_softc *);
164 static void     kue_reset(struct kue_softc *);
165
166 #ifdef USB_DEBUG
167 static int kue_debug = 0;
168
169 static SYSCTL_NODE(_hw_usb, OID_AUTO, kue, CTLFLAG_RW, 0, "USB kue");
170 SYSCTL_INT(_hw_usb_kue, OID_AUTO, debug, CTLFLAG_RW, &kue_debug, 0,
171     "Debug level");
172 #endif
173
174 static const struct usb_config kue_config[KUE_N_TRANSFER] = {
175
176         [KUE_BULK_DT_WR] = {
177                 .type = UE_BULK,
178                 .endpoint = UE_ADDR_ANY,
179                 .direction = UE_DIR_OUT,
180                 .bufsize = (MCLBYTES + 2 + 64),
181                 .flags = {.pipe_bof = 1,},
182                 .callback = kue_bulk_write_callback,
183                 .timeout = 10000,       /* 10 seconds */
184         },
185
186         [KUE_BULK_DT_RD] = {
187                 .type = UE_BULK,
188                 .endpoint = UE_ADDR_ANY,
189                 .direction = UE_DIR_IN,
190                 .bufsize = (MCLBYTES + 2),
191                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
192                 .callback = kue_bulk_read_callback,
193                 .timeout = 0,   /* no timeout */
194         },
195 };
196
197 static device_method_t kue_methods[] = {
198         /* Device interface */
199         DEVMETHOD(device_probe, kue_probe),
200         DEVMETHOD(device_attach, kue_attach),
201         DEVMETHOD(device_detach, kue_detach),
202
203         DEVMETHOD_END
204 };
205
206 static driver_t kue_driver = {
207         .name = "kue",
208         .methods = kue_methods,
209         .size = sizeof(struct kue_softc),
210 };
211
212 static devclass_t kue_devclass;
213
214 DRIVER_MODULE(kue, uhub, kue_driver, kue_devclass, NULL, NULL);
215 MODULE_DEPEND(kue, uether, 1, 1, 1);
216 MODULE_DEPEND(kue, usb, 1, 1, 1);
217 MODULE_DEPEND(kue, ether, 1, 1, 1);
218 MODULE_VERSION(kue, 1);
219
220 static const struct usb_ether_methods kue_ue_methods = {
221         .ue_attach_post = kue_attach_post,
222         .ue_start = kue_start,
223         .ue_init = kue_init,
224         .ue_stop = kue_stop,
225         .ue_setmulti = kue_setmulti,
226         .ue_setpromisc = kue_setpromisc,
227 };
228
229 /*
230  * We have a custom do_request function which is almost like the
231  * regular do_request function, except it has a much longer timeout.
232  * Why? Because we need to make requests over the control endpoint
233  * to download the firmware to the device, which can take longer
234  * than the default timeout.
235  */
236 static int
237 kue_do_request(struct kue_softc *sc, struct usb_device_request *req,
238     void *data)
239 {
240         usb_error_t err;
241
242         err = uether_do_request(&sc->sc_ue, req, data, 60000);
243
244         return (err);
245 }
246
247 static int
248 kue_setword(struct kue_softc *sc, uint8_t breq, uint16_t word)
249 {
250         struct usb_device_request req;
251
252         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
253         req.bRequest = breq;
254         USETW(req.wValue, word);
255         USETW(req.wIndex, 0);
256         USETW(req.wLength, 0);
257
258         return (kue_do_request(sc, &req, NULL));
259 }
260
261 static int
262 kue_ctl(struct kue_softc *sc, uint8_t rw, uint8_t breq,
263     uint16_t val, void *data, int len)
264 {
265         struct usb_device_request req;
266
267         if (rw == KUE_CTL_WRITE)
268                 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
269         else
270                 req.bmRequestType = UT_READ_VENDOR_DEVICE;
271
272
273         req.bRequest = breq;
274         USETW(req.wValue, val);
275         USETW(req.wIndex, 0);
276         USETW(req.wLength, len);
277
278         return (kue_do_request(sc, &req, data));
279 }
280
281 static int
282 kue_load_fw(struct kue_softc *sc)
283 {
284         struct usb_device_descriptor *dd;
285         uint16_t hwrev;
286         usb_error_t err;
287
288         dd = usbd_get_device_descriptor(sc->sc_ue.ue_udev);
289         hwrev = UGETW(dd->bcdDevice);
290
291         /*
292          * First, check if we even need to load the firmware.
293          * If the device was still attached when the system was
294          * rebooted, it may already have firmware loaded in it.
295          * If this is the case, we don't need to do it again.
296          * And in fact, if we try to load it again, we'll hang,
297          * so we have to avoid this condition if we don't want
298          * to look stupid.
299          *
300          * We can test this quickly by checking the bcdRevision
301          * code. The NIC will return a different revision code if
302          * it's probed while the firmware is still loaded and
303          * running.
304          */
305         if (hwrev == 0x0202)
306                 return(0);
307
308         /* Load code segment */
309         err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
310             0, kue_code_seg, sizeof(kue_code_seg));
311         if (err) {
312                 device_printf(sc->sc_ue.ue_dev, "failed to load code segment: %s\n",
313                     usbd_errstr(err));
314                 return(ENXIO);
315         }
316
317         /* Load fixup segment */
318         err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
319             0, kue_fix_seg, sizeof(kue_fix_seg));
320         if (err) {
321                 device_printf(sc->sc_ue.ue_dev, "failed to load fixup segment: %s\n",
322                     usbd_errstr(err));
323                 return(ENXIO);
324         }
325
326         /* Send trigger command. */
327         err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
328             0, kue_trig_seg, sizeof(kue_trig_seg));
329         if (err) {
330                 device_printf(sc->sc_ue.ue_dev, "failed to load trigger segment: %s\n",
331                     usbd_errstr(err));
332                 return(ENXIO);
333         }
334
335         return (0);
336 }
337
338 static void
339 kue_setpromisc(struct usb_ether *ue)
340 {
341         struct kue_softc *sc = uether_getsc(ue);
342         struct ifnet *ifp = uether_getifp(ue);
343
344         KUE_LOCK_ASSERT(sc);
345
346         if (ifp->if_flags & IFF_PROMISC)
347                 sc->sc_rxfilt |= KUE_RXFILT_PROMISC;
348         else
349                 sc->sc_rxfilt &= ~KUE_RXFILT_PROMISC;
350
351         kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->sc_rxfilt);
352 }
353
354 static void
355 kue_setmulti(struct usb_ether *ue)
356 {
357         struct kue_softc *sc = uether_getsc(ue);
358         struct ifnet *ifp = uether_getifp(ue);
359         struct ifmultiaddr *ifma;
360         int i = 0;
361
362         KUE_LOCK_ASSERT(sc);
363
364         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
365                 sc->sc_rxfilt |= KUE_RXFILT_ALLMULTI;
366                 sc->sc_rxfilt &= ~KUE_RXFILT_MULTICAST;
367                 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->sc_rxfilt);
368                 return;
369         }
370
371         sc->sc_rxfilt &= ~KUE_RXFILT_ALLMULTI;
372
373         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
374         {
375                 if (ifma->ifma_addr->sa_family != AF_LINK)
376                         continue;
377                 /*
378                  * If there are too many addresses for the
379                  * internal filter, switch over to allmulti mode.
380                  */
381                 if (i == KUE_MCFILTCNT(sc))
382                         break;
383                 memcpy(KUE_MCFILT(sc, i),
384                     LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
385                     ETHER_ADDR_LEN);
386                 i++;
387         }
388
389         if (i == KUE_MCFILTCNT(sc))
390                 sc->sc_rxfilt |= KUE_RXFILT_ALLMULTI;
391         else {
392                 sc->sc_rxfilt |= KUE_RXFILT_MULTICAST;
393                 kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MCAST_FILTERS,
394                     i, sc->sc_mcfilters, i * ETHER_ADDR_LEN);
395         }
396
397         kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->sc_rxfilt);
398 }
399
400 /*
401  * Issue a SET_CONFIGURATION command to reset the MAC. This should be
402  * done after the firmware is loaded into the adapter in order to
403  * bring it into proper operation.
404  */
405 static void
406 kue_reset(struct kue_softc *sc)
407 {
408         struct usb_config_descriptor *cd;
409         usb_error_t err;
410
411         cd = usbd_get_config_descriptor(sc->sc_ue.ue_udev);
412
413         err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_lock,
414             cd->bConfigurationValue);
415         if (err)
416                 DPRINTF("reset failed (ignored)\n");
417
418         /* wait a little while for the chip to get its brains in order */
419         uether_pause(&sc->sc_ue, hz / 100);
420 }
421
422 static void
423 kue_attach_post(struct usb_ether *ue)
424 {
425         struct kue_softc *sc = uether_getsc(ue);
426         int error;
427
428         /* load the firmware into the NIC */
429         error = kue_load_fw(sc);
430         if (error) {
431                 device_printf(sc->sc_ue.ue_dev, "could not load firmware\n");
432                 /* ignore the error */
433         }
434
435         /* reset the adapter */
436         kue_reset(sc);
437
438         /* read ethernet descriptor */
439         kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
440             0, &sc->sc_desc, sizeof(sc->sc_desc));
441
442         /* copy in ethernet address */
443         memcpy(ue->ue_eaddr, sc->sc_desc.kue_macaddr, sizeof(ue->ue_eaddr));
444 }
445
446 /*
447  * Probe for a KLSI chip.
448  */
449 static int
450 kue_probe(device_t dev)
451 {
452         struct usb_attach_arg *uaa = device_get_ivars(dev);
453
454         if (uaa->usb_mode != USB_MODE_HOST)
455                 return (ENXIO);
456         if (uaa->info.bConfigIndex != KUE_CONFIG_IDX)
457                 return (ENXIO);
458         if (uaa->info.bIfaceIndex != KUE_IFACE_IDX)
459                 return (ENXIO);
460
461         return (usbd_lookup_id_by_uaa(kue_devs, sizeof(kue_devs), uaa));
462 }
463
464 /*
465  * Attach the interface. Allocate softc structures, do
466  * setup and ethernet/BPF attach.
467  */
468 static int
469 kue_attach(device_t dev)
470 {
471         struct usb_attach_arg *uaa = device_get_ivars(dev);
472         struct kue_softc *sc = device_get_softc(dev);
473         struct usb_ether *ue = &sc->sc_ue;
474         uint8_t iface_index;
475         int error;
476
477         device_set_usb_desc(dev);
478         lockinit(&sc->sc_lock, device_get_nameunit(dev), 0, LK_CANRECURSE);
479
480         iface_index = KUE_IFACE_IDX;
481         error = usbd_transfer_setup(uaa->device, &iface_index,
482             sc->sc_xfer, kue_config, KUE_N_TRANSFER, sc, &sc->sc_lock);
483         if (error) {
484                 device_printf(dev, "allocating USB transfers failed\n");
485                 goto detach;
486         }
487
488         sc->sc_mcfilters = kmalloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
489             M_USBDEV, M_WAITOK);
490         if (sc->sc_mcfilters == NULL) {
491                 device_printf(dev, "failed allocating USB memory\n");
492                 goto detach;
493         }
494
495         ue->ue_sc = sc;
496         ue->ue_dev = dev;
497         ue->ue_udev = uaa->device;
498         ue->ue_lock = &sc->sc_lock;
499         ue->ue_methods = &kue_ue_methods;
500
501         error = uether_ifattach(ue);
502         if (error) {
503                 device_printf(dev, "could not attach interface\n");
504                 goto detach;
505         }
506         return (0);                     /* success */
507
508 detach:
509         kue_detach(dev);
510         return (ENXIO);                 /* failure */
511 }
512
513 static int
514 kue_detach(device_t dev)
515 {
516         struct kue_softc *sc = device_get_softc(dev);
517         struct usb_ether *ue = &sc->sc_ue;
518
519         usbd_transfer_unsetup(sc->sc_xfer, KUE_N_TRANSFER);
520         uether_ifdetach(ue);
521         lockuninit(&sc->sc_lock);
522         kfree(sc->sc_mcfilters, M_USBDEV);
523
524         return (0);
525 }
526
527 /*
528  * A frame has been uploaded: pass the resulting mbuf chain up to
529  * the higher level protocols.
530  */
531 static void
532 kue_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
533 {
534         struct kue_softc *sc = usbd_xfer_softc(xfer);
535         struct usb_ether *ue = &sc->sc_ue;
536         struct ifnet *ifp = uether_getifp(ue);
537         struct usb_page_cache *pc;
538         uint8_t buf[2];
539         int len;
540         int actlen;
541
542         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
543
544         switch (USB_GET_STATE(xfer)) {
545         case USB_ST_TRANSFERRED:
546
547                 if (actlen <= (int)(2 + sizeof(struct ether_header))) {
548                         IFNET_STAT_INC(ifp, ierrors, 1);
549                         goto tr_setup;
550                 }
551                 pc = usbd_xfer_get_frame(xfer, 0);
552                 usbd_copy_out(pc, 0, buf, 2);
553                 actlen -= 2;
554                 len = buf[0] | (buf[1] << 8);
555                 len = min(actlen, len);
556
557                 uether_rxbuf(ue, pc, 2, len);
558                 /* FALLTHROUGH */
559         case USB_ST_SETUP:
560 tr_setup:
561                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
562                 usbd_transfer_submit(xfer);
563                 uether_rxflush(ue);
564                 return;
565
566         default:                        /* Error */
567                 DPRINTF("bulk read error, %s\n",
568                     usbd_errstr(error));
569
570                 if (error != USB_ERR_CANCELLED) {
571                         /* try to clear stall first */
572                         usbd_xfer_set_stall(xfer);
573                         goto tr_setup;
574                 }
575                 return;
576
577         }
578 }
579
580 static void
581 kue_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
582 {
583         struct kue_softc *sc = usbd_xfer_softc(xfer);
584         struct ifnet *ifp = uether_getifp(&sc->sc_ue);
585         struct usb_page_cache *pc;
586         struct mbuf *m;
587         int total_len;
588         int temp_len;
589         uint8_t buf[2];
590
591         switch (USB_GET_STATE(xfer)) {
592         case USB_ST_TRANSFERRED:
593                 DPRINTFN(11, "transfer complete\n");
594                 IFNET_STAT_INC(ifp, opackets, 1);
595
596                 /* FALLTHROUGH */
597         case USB_ST_SETUP:
598 tr_setup:
599                 m = ifq_dequeue(&ifp->if_snd);
600
601                 if (m == NULL)
602                         return;
603                 if (m->m_pkthdr.len > MCLBYTES)
604                         m->m_pkthdr.len = MCLBYTES;
605                 temp_len = (m->m_pkthdr.len + 2);
606                 total_len = (temp_len + (64 - (temp_len % 64)));
607
608                 /* the first two bytes are the frame length */
609
610                 buf[0] = (uint8_t)(m->m_pkthdr.len);
611                 buf[1] = (uint8_t)(m->m_pkthdr.len >> 8);
612
613                 pc = usbd_xfer_get_frame(xfer, 0);
614                 usbd_copy_in(pc, 0, buf, 2);
615                 usbd_m_copy_in(pc, 2, m, 0, m->m_pkthdr.len);
616
617                 usbd_frame_zero(pc, temp_len, total_len - temp_len);
618                 usbd_xfer_set_frame_len(xfer, 0, total_len);
619
620                 /*
621                  * if there's a BPF listener, bounce a copy
622                  * of this frame to him:
623                  */
624                 BPF_MTAP(ifp, m);
625
626                 m_freem(m);
627
628                 usbd_transfer_submit(xfer);
629
630                 return;
631
632         default:                        /* Error */
633                 DPRINTFN(11, "transfer error, %s\n",
634                     usbd_errstr(error));
635
636                 IFNET_STAT_INC(ifp, oerrors, 1);
637
638                 if (error != USB_ERR_CANCELLED) {
639                         /* try to clear stall first */
640                         usbd_xfer_set_stall(xfer);
641                         goto tr_setup;
642                 }
643                 return;
644
645         }
646 }
647
648 static void
649 kue_start(struct usb_ether *ue)
650 {
651         struct kue_softc *sc = uether_getsc(ue);
652
653         /*
654          * start the USB transfers, if not already started:
655          */
656         usbd_transfer_start(sc->sc_xfer[KUE_BULK_DT_RD]);
657         usbd_transfer_start(sc->sc_xfer[KUE_BULK_DT_WR]);
658 }
659
660 static void
661 kue_init(struct usb_ether *ue)
662 {
663         struct kue_softc *sc = uether_getsc(ue);
664         struct ifnet *ifp = uether_getifp(ue);
665
666         KUE_LOCK_ASSERT(sc);
667
668         /* set MAC address */
669         kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC,
670             0, IF_LLADDR(ifp), ETHER_ADDR_LEN);
671
672         /* I'm not sure how to tune these. */
673 #if 0
674         /*
675          * Leave this one alone for now; setting it
676          * wrong causes lockups on some machines/controllers.
677          */
678         kue_setword(sc, KUE_CMD_SET_SOFS, 1);
679 #endif
680         kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64);
681
682         /* load the multicast filter */
683         kue_setpromisc(ue);
684
685         usbd_xfer_set_stall(sc->sc_xfer[KUE_BULK_DT_WR]);
686
687         ifp->if_flags |= IFF_RUNNING;
688         kue_start(ue);
689 }
690
691 static void
692 kue_stop(struct usb_ether *ue)
693 {
694         struct kue_softc *sc = uether_getsc(ue);
695         struct ifnet *ifp = uether_getifp(ue);
696
697         KUE_LOCK_ASSERT(sc);
698
699         ifp->if_flags &= ~IFF_RUNNING;
700
701         /*
702          * stop all the transfers, if not already stopped:
703          */
704         usbd_transfer_stop(sc->sc_xfer[KUE_BULK_DT_WR]);
705         usbd_transfer_stop(sc->sc_xfer[KUE_BULK_DT_RD]);
706 }