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