1 /* $NetBSD: if_kue.c,v 1.86 2016/07/07 06:55:42 msaitoh Exp $ */
2
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 * $FreeBSD: src/sys/dev/usb/if_kue.c,v 1.14 2000/01/14 01:36:15 wpaul Exp $
35 */
36
37 /*
38 * Kawasaki LSI KL5KUSB101B USB to ethernet adapter driver.
39 *
40 * Written by Bill Paul <wpaul@ee.columbia.edu>
41 * Electrical Engineering Department
42 * Columbia University, New York City
43 */
44
45 /*
46 * The KLSI USB to ethernet adapter chip contains an USB serial interface,
47 * ethernet MAC and embedded microcontroller (called the QT Engine).
48 * The chip must have firmware loaded into it before it will operate.
49 * Packets are passed between the chip and host via bulk transfers.
50 * There is an interrupt endpoint mentioned in the software spec, however
51 * it's currently unused. This device is 10Mbps half-duplex only, hence
52 * there is no media selection logic. The MAC supports a 128 entry
53 * multicast filter, though the exact size of the filter can depend
54 * on the firmware. Curiously, while the software spec describes various
55 * ethernet statistics counters, my sample adapter and firmware combination
56 * claims not to support any statistics counters at all.
57 *
58 * Note that once we load the firmware in the device, we have to be
59 * careful not to load it again: if you restart your computer but
60 * leave the adapter attached to the USB controller, it may remain
61 * powered on and retain its firmware. In this case, we don't need
62 * to load the firmware a second time.
63 *
64 * Special thanks to Rob Furr for providing an ADS Technologies
65 * adapter for development and testing. No monkeys were harmed during
66 * the development of this driver.
67 */
68
69 /*
70 * Ported to NetBSD and somewhat rewritten by Lennart Augustsson.
71 */
72
73 #include <sys/cdefs.h>
74 __KERNEL_RCSID(0, "$NetBSD: if_kue.c,v 1.86 2016/07/07 06:55:42 msaitoh Exp $");
75
76 #ifdef _KERNEL_OPT
77 #include "opt_inet.h"
78 #endif
79
80 #include <sys/param.h>
81 #include <sys/systm.h>
82 #include <sys/sockio.h>
83 #include <sys/mbuf.h>
84 #include <sys/kmem.h>
85 #include <sys/kernel.h>
86 #include <sys/socket.h>
87 #include <sys/device.h>
88 #include <sys/proc.h>
89 #include <sys/rndsource.h>
90
91 #include <net/if.h>
92 #include <net/if_arp.h>
93 #include <net/if_dl.h>
94 #include <net/bpf.h>
95 #include <net/if_ether.h>
96
97 #ifdef INET
98 #include <netinet/in.h>
99 #include <netinet/if_inarp.h>
100 #endif
101
102 #include <dev/usb/usb.h>
103 #include <dev/usb/usbdi.h>
104 #include <dev/usb/usbdi_util.h>
105 #include <dev/usb/usbdivar.h>
106 #include <dev/usb/usbdevs.h>
107
108 #include <dev/usb/if_kuereg.h>
109 #include <dev/usb/kue_fw.h>
110
111 #ifdef KUE_DEBUG
112 #define DPRINTF(x) if (kuedebug) printf x
113 #define DPRINTFN(n,x) if (kuedebug >= (n)) printf x
114 int kuedebug = 0;
115 #else
116 #define DPRINTF(x)
117 #define DPRINTFN(n,x)
118 #endif
119
120 /*
121 * Various supported device vendors/products.
122 */
123 static const struct usb_devno kue_devs[] = {
124 { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C19250 },
125 { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C460 },
126 { USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_URE450 },
127 { USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BT },
128 { USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BTX },
129 { USB_VENDOR_AOX, USB_PRODUCT_AOX_USB101 },
130 { USB_VENDOR_ASANTE, USB_PRODUCT_ASANTE_EA },
131 { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC10T },
132 { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_DSB650C },
133 { USB_VENDOR_COREGA, USB_PRODUCT_COREGA_ETHER_USB_T },
134 { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650C },
135 { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_E45 },
136 { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_XX1 },
137 { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_XX2 },
138 { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBETT },
139 { USB_VENDOR_JATON, USB_PRODUCT_JATON_EDA },
140 { USB_VENDOR_KINGSTON, USB_PRODUCT_KINGSTON_XX1 },
141 { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BT },
142 { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BTN },
143 { USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10T },
144 { USB_VENDOR_MOBILITY, USB_PRODUCT_MOBILITY_EA },
145 { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101 },
146 { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101X },
147 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET },
148 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET2 },
149 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET3 },
150 { USB_VENDOR_PORTGEAR, USB_PRODUCT_PORTGEAR_EA8 },
151 { USB_VENDOR_PORTGEAR, USB_PRODUCT_PORTGEAR_EA9 },
152 { USB_VENDOR_PORTSMITH, USB_PRODUCT_PORTSMITH_EEA },
153 { USB_VENDOR_SHARK, USB_PRODUCT_SHARK_PA },
154 { USB_VENDOR_SILICOM, USB_PRODUCT_SILICOM_U2E },
155 { USB_VENDOR_SMC, USB_PRODUCT_SMC_2102USB },
156 };
157 #define kue_lookup(v, p) (usb_lookup(kue_devs, v, p))
158
159 int kue_match(device_t, cfdata_t, void *);
160 void kue_attach(device_t, device_t, void *);
161 int kue_detach(device_t, int);
162 int kue_activate(device_t, enum devact);
163 extern struct cfdriver kue_cd;
164 CFATTACH_DECL_NEW(kue, sizeof(struct kue_softc), kue_match, kue_attach,
165 kue_detach, kue_activate);
166
167 static int kue_tx_list_init(struct kue_softc *);
168 static int kue_rx_list_init(struct kue_softc *);
169 static int kue_send(struct kue_softc *, struct mbuf *, int);
170 static int kue_open_pipes(struct kue_softc *);
171 static void kue_rxeof(struct usbd_xfer *, void *, usbd_status);
172 static void kue_txeof(struct usbd_xfer *, void *, usbd_status);
173 static void kue_start(struct ifnet *);
174 static int kue_ioctl(struct ifnet *, u_long, void *);
175 static void kue_init(void *);
176 static void kue_stop(struct kue_softc *);
177 static void kue_watchdog(struct ifnet *);
178
179 static void kue_setmulti(struct kue_softc *);
180 static void kue_reset(struct kue_softc *);
181
182 static usbd_status kue_ctl(struct kue_softc *, int, uint8_t,
183 uint16_t, void *, uint32_t);
184 static usbd_status kue_setword(struct kue_softc *, uint8_t, uint16_t);
185 static int kue_load_fw(struct kue_softc *);
186
187 static usbd_status
kue_setword(struct kue_softc * sc,uint8_t breq,uint16_t word)188 kue_setword(struct kue_softc *sc, uint8_t breq, uint16_t word)
189 {
190 usb_device_request_t req;
191
192 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
193
194 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
195 req.bRequest = breq;
196 USETW(req.wValue, word);
197 USETW(req.wIndex, 0);
198 USETW(req.wLength, 0);
199
200 return usbd_do_request(sc->kue_udev, &req, NULL);
201 }
202
203 static usbd_status
kue_ctl(struct kue_softc * sc,int rw,uint8_t breq,uint16_t val,void * data,uint32_t len)204 kue_ctl(struct kue_softc *sc, int rw, uint8_t breq, uint16_t val,
205 void *data, uint32_t len)
206 {
207 usb_device_request_t req;
208
209 DPRINTFN(10,("%s: %s: enter, len=%d\n", device_xname(sc->kue_dev),
210 __func__, len));
211
212 if (rw == KUE_CTL_WRITE)
213 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
214 else
215 req.bmRequestType = UT_READ_VENDOR_DEVICE;
216
217 req.bRequest = breq;
218 USETW(req.wValue, val);
219 USETW(req.wIndex, 0);
220 USETW(req.wLength, len);
221
222 return usbd_do_request(sc->kue_udev, &req, data);
223 }
224
225 static int
kue_load_fw(struct kue_softc * sc)226 kue_load_fw(struct kue_softc *sc)
227 {
228 usb_device_descriptor_t dd;
229 usbd_status err;
230
231 DPRINTFN(1,("%s: %s: enter\n", device_xname(sc->kue_dev), __func__));
232
233 /*
234 * First, check if we even need to load the firmware.
235 * If the device was still attached when the system was
236 * rebooted, it may already have firmware loaded in it.
237 * If this is the case, we don't need to do it again.
238 * And in fact, if we try to load it again, we'll hang,
239 * so we have to avoid this condition if we don't want
240 * to look stupid.
241 *
242 * We can test this quickly by checking the bcdRevision
243 * code. The NIC will return a different revision code if
244 * it's probed while the firmware is still loaded and
245 * running.
246 */
247 if (usbd_get_device_desc(sc->kue_udev, &dd))
248 return EIO;
249 if (UGETW(dd.bcdDevice) == KUE_WARM_REV) {
250 printf("%s: warm boot, no firmware download\n",
251 device_xname(sc->kue_dev));
252 return 0;
253 }
254
255 printf("%s: cold boot, downloading firmware\n",
256 device_xname(sc->kue_dev));
257
258 /* Load code segment */
259 DPRINTFN(1,("%s: kue_load_fw: download code_seg\n",
260 device_xname(sc->kue_dev)));
261 /*XXXUNCONST*/
262 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
263 0, __UNCONST(kue_code_seg), sizeof(kue_code_seg));
264 if (err) {
265 printf("%s: failed to load code segment: %s\n",
266 device_xname(sc->kue_dev), usbd_errstr(err));
267 return EIO;
268 }
269
270 /* Load fixup segment */
271 DPRINTFN(1,("%s: kue_load_fw: download fix_seg\n",
272 device_xname(sc->kue_dev)));
273 /*XXXUNCONST*/
274 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
275 0, __UNCONST(kue_fix_seg), sizeof(kue_fix_seg));
276 if (err) {
277 printf("%s: failed to load fixup segment: %s\n",
278 device_xname(sc->kue_dev), usbd_errstr(err));
279 return EIO;
280 }
281
282 /* Send trigger command. */
283 DPRINTFN(1,("%s: kue_load_fw: download trig_seg\n",
284 device_xname(sc->kue_dev)));
285 /*XXXUNCONST*/
286 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
287 0, __UNCONST(kue_trig_seg), sizeof(kue_trig_seg));
288 if (err) {
289 printf("%s: failed to load trigger segment: %s\n",
290 device_xname(sc->kue_dev), usbd_errstr(err));
291 return EIO;
292 }
293
294 usbd_delay_ms(sc->kue_udev, 10);
295
296 /*
297 * Reload device descriptor.
298 * Why? The chip without the firmware loaded returns
299 * one revision code. The chip with the firmware
300 * loaded and running returns a *different* revision
301 * code. This confuses the quirk mechanism, which is
302 * dependent on the revision data.
303 */
304 (void)usbd_reload_device_desc(sc->kue_udev);
305
306 DPRINTFN(1,("%s: %s: done\n", device_xname(sc->kue_dev), __func__));
307
308 /* Reset the adapter. */
309 kue_reset(sc);
310
311 return 0;
312 }
313
314 static void
kue_setmulti(struct kue_softc * sc)315 kue_setmulti(struct kue_softc *sc)
316 {
317 struct ifnet *ifp = GET_IFP(sc);
318 struct ether_multi *enm;
319 struct ether_multistep step;
320 int i;
321
322 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev), __func__));
323
324 if (ifp->if_flags & IFF_PROMISC) {
325 allmulti:
326 ifp->if_flags |= IFF_ALLMULTI;
327 sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI;
328 sc->kue_rxfilt &= ~KUE_RXFILT_MULTICAST;
329 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
330 return;
331 }
332
333 sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI;
334
335 i = 0;
336 ETHER_FIRST_MULTI(step, &sc->kue_ec, enm);
337 while (enm != NULL) {
338 if (i == KUE_MCFILTCNT(sc) ||
339 memcmp(enm->enm_addrlo, enm->enm_addrhi,
340 ETHER_ADDR_LEN) != 0)
341 goto allmulti;
342
343 memcpy(KUE_MCFILT(sc, i), enm->enm_addrlo, ETHER_ADDR_LEN);
344 ETHER_NEXT_MULTI(step, enm);
345 i++;
346 }
347
348 ifp->if_flags &= ~IFF_ALLMULTI;
349
350 sc->kue_rxfilt |= KUE_RXFILT_MULTICAST;
351 kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MCAST_FILTERS,
352 i, sc->kue_mcfilters, i * ETHER_ADDR_LEN);
353
354 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
355 }
356
357 /*
358 * Issue a SET_CONFIGURATION command to reset the MAC. This should be
359 * done after the firmware is loaded into the adapter in order to
360 * bring it into proper operation.
361 */
362 static void
kue_reset(struct kue_softc * sc)363 kue_reset(struct kue_softc *sc)
364 {
365 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev), __func__));
366
367 if (usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 1) ||
368 usbd_device2interface_handle(sc->kue_udev, KUE_IFACE_IDX,
369 &sc->kue_iface))
370 printf("%s: reset failed\n", device_xname(sc->kue_dev));
371
372 /* Wait a little while for the chip to get its brains in order. */
373 usbd_delay_ms(sc->kue_udev, 10);
374 }
375
376 /*
377 * Probe for a KLSI chip.
378 */
379 int
kue_match(device_t parent,cfdata_t match,void * aux)380 kue_match(device_t parent, cfdata_t match, void *aux)
381 {
382 struct usb_attach_arg *uaa = aux;
383
384 DPRINTFN(25,("kue_match: enter\n"));
385
386 return kue_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
387 UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
388 }
389
390 /*
391 * Attach the interface. Allocate softc structures, do
392 * setup and ethernet/BPF attach.
393 */
394 void
kue_attach(device_t parent,device_t self,void * aux)395 kue_attach(device_t parent, device_t self, void *aux)
396 {
397 struct kue_softc *sc = device_private(self);
398 struct usb_attach_arg *uaa = aux;
399 char *devinfop;
400 int s;
401 struct ifnet *ifp;
402 struct usbd_device * dev = uaa->uaa_device;
403 struct usbd_interface * iface;
404 usbd_status err;
405 usb_interface_descriptor_t *id;
406 usb_endpoint_descriptor_t *ed;
407 int i;
408
409 DPRINTFN(5,(" : kue_attach: sc=%p, dev=%p", sc, dev));
410
411 sc->kue_dev = self;
412
413 aprint_naive("\n");
414 aprint_normal("\n");
415
416 devinfop = usbd_devinfo_alloc(dev, 0);
417 aprint_normal_dev(self, "%s\n", devinfop);
418 usbd_devinfo_free(devinfop);
419
420 err = usbd_set_config_no(dev, KUE_CONFIG_NO, 1);
421 if (err) {
422 aprint_error_dev(self, "failed to set configuration"
423 ", err=%s\n", usbd_errstr(err));
424 return;
425 }
426
427 sc->kue_udev = dev;
428 sc->kue_product = uaa->uaa_product;
429 sc->kue_vendor = uaa->uaa_vendor;
430
431 /* Load the firmware into the NIC. */
432 if (kue_load_fw(sc)) {
433 aprint_error_dev(self, "loading firmware failed\n");
434 return;
435 }
436
437 err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface);
438 if (err) {
439 aprint_error_dev(self, "getting interface handle failed\n");
440 return;
441 }
442
443 sc->kue_iface = iface;
444 id = usbd_get_interface_descriptor(iface);
445
446 /* Find endpoints. */
447 for (i = 0; i < id->bNumEndpoints; i++) {
448 ed = usbd_interface2endpoint_descriptor(iface, i);
449 if (ed == NULL) {
450 aprint_error_dev(self, "couldn't get ep %d\n", i);
451 return;
452 }
453 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
454 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
455 sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
456 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
457 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
458 sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
459 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
460 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
461 sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
462 }
463 }
464
465 if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) {
466 aprint_error_dev(self, "missing endpoint\n");
467 return;
468 }
469
470 /* Read ethernet descriptor */
471 err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
472 0, &sc->kue_desc, sizeof(sc->kue_desc));
473 if (err) {
474 aprint_error_dev(self, "could not read Ethernet descriptor\n");
475 return;
476 }
477
478 sc->kue_mcfilters = kmem_alloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
479 KM_SLEEP);
480 if (sc->kue_mcfilters == NULL) {
481 aprint_error_dev(self,
482 "no memory for multicast filter buffer\n");
483 return;
484 }
485
486 s = splnet();
487
488 /*
489 * A KLSI chip was detected. Inform the world.
490 */
491 aprint_normal_dev(self, "Ethernet address %s\n",
492 ether_sprintf(sc->kue_desc.kue_macaddr));
493
494 /* Initialize interface info.*/
495 ifp = GET_IFP(sc);
496 ifp->if_softc = sc;
497 ifp->if_mtu = ETHERMTU;
498 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
499 ifp->if_ioctl = kue_ioctl;
500 ifp->if_start = kue_start;
501 ifp->if_watchdog = kue_watchdog;
502 strncpy(ifp->if_xname, device_xname(sc->kue_dev), IFNAMSIZ);
503
504 IFQ_SET_READY(&ifp->if_snd);
505
506 /* Attach the interface. */
507 if_attach(ifp);
508 ether_ifattach(ifp, sc->kue_desc.kue_macaddr);
509 rnd_attach_source(&sc->rnd_source, device_xname(sc->kue_dev),
510 RND_TYPE_NET, RND_FLAG_DEFAULT);
511
512 sc->kue_attached = true;
513 splx(s);
514
515 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->kue_udev, sc->kue_dev);
516
517 return;
518 }
519
520 int
kue_detach(device_t self,int flags)521 kue_detach(device_t self, int flags)
522 {
523 struct kue_softc *sc = device_private(self);
524 struct ifnet *ifp = GET_IFP(sc);
525 int s;
526
527 s = splusb(); /* XXX why? */
528
529 if (sc->kue_mcfilters != NULL) {
530 kmem_free(sc->kue_mcfilters,
531 KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN);
532 sc->kue_mcfilters = NULL;
533 }
534
535 if (!sc->kue_attached) {
536 /* Detached before attached finished, so just bail out. */
537 splx(s);
538 return 0;
539 }
540
541 if (ifp->if_flags & IFF_RUNNING)
542 kue_stop(sc);
543
544 rnd_detach_source(&sc->rnd_source);
545 ether_ifdetach(ifp);
546
547 if_detach(ifp);
548
549 #ifdef DIAGNOSTIC
550 if (sc->kue_ep[KUE_ENDPT_TX] != NULL ||
551 sc->kue_ep[KUE_ENDPT_RX] != NULL ||
552 sc->kue_ep[KUE_ENDPT_INTR] != NULL)
553 aprint_debug_dev(self, "detach has active endpoints\n");
554 #endif
555
556 sc->kue_attached = false;
557 splx(s);
558
559 return 0;
560 }
561
562 int
kue_activate(device_t self,enum devact act)563 kue_activate(device_t self, enum devact act)
564 {
565 struct kue_softc *sc = device_private(self);
566
567 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->kue_dev), __func__));
568
569 switch (act) {
570 case DVACT_DEACTIVATE:
571 /* Deactivate the interface. */
572 if_deactivate(&sc->kue_ec.ec_if);
573 sc->kue_dying = true;
574 return 0;
575 default:
576 return EOPNOTSUPP;
577 }
578 }
579
580 static int
kue_rx_list_init(struct kue_softc * sc)581 kue_rx_list_init(struct kue_softc *sc)
582 {
583 struct kue_cdata *cd;
584 struct kue_chain *c;
585 int i;
586
587 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev), __func__));
588
589 cd = &sc->kue_cdata;
590 for (i = 0; i < KUE_RX_LIST_CNT; i++) {
591 c = &cd->kue_rx_chain[i];
592 c->kue_sc = sc;
593 c->kue_idx = i;
594 if (c->kue_xfer == NULL) {
595 int error = usbd_create_xfer(sc->kue_ep[KUE_ENDPT_RX],
596 KUE_BUFSZ, USBD_SHORT_XFER_OK, 0, &c->kue_xfer);
597 if (error)
598 return error;
599 c->kue_buf = usbd_get_buffer(c->kue_xfer);
600 }
601 }
602
603 return 0;
604 }
605
606 static int
kue_tx_list_init(struct kue_softc * sc)607 kue_tx_list_init(struct kue_softc *sc)
608 {
609 struct kue_cdata *cd;
610 struct kue_chain *c;
611 int i;
612
613 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev), __func__));
614
615 cd = &sc->kue_cdata;
616 for (i = 0; i < KUE_TX_LIST_CNT; i++) {
617 c = &cd->kue_tx_chain[i];
618 c->kue_sc = sc;
619 c->kue_idx = i;
620 if (c->kue_xfer == NULL) {
621 int error = usbd_create_xfer(sc->kue_ep[KUE_ENDPT_TX],
622 KUE_BUFSZ, 0, 0, &c->kue_xfer);
623 if (error)
624 return error;
625 c->kue_buf = usbd_get_buffer(c->kue_xfer);
626 }
627 }
628
629 return 0;
630 }
631
632 /*
633 * A frame has been uploaded: pass the resulting mbuf chain up to
634 * the higher level protocols.
635 */
636 static void
kue_rxeof(struct usbd_xfer * xfer,void * priv,usbd_status status)637 kue_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
638 {
639 struct kue_chain *c = priv;
640 struct kue_softc *sc = c->kue_sc;
641 struct ifnet *ifp = GET_IFP(sc);
642 struct mbuf *m;
643 int total_len, pktlen;
644 int s;
645
646 DPRINTFN(10,("%s: %s: enter status=%d\n", device_xname(sc->kue_dev),
647 __func__, status));
648
649 if (sc->kue_dying)
650 return;
651
652 if (!(ifp->if_flags & IFF_RUNNING))
653 return;
654
655 if (status != USBD_NORMAL_COMPLETION) {
656 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
657 return;
658 sc->kue_rx_errs++;
659 if (usbd_ratecheck(&sc->kue_rx_notice)) {
660 printf("%s: %u usb errors on rx: %s\n",
661 device_xname(sc->kue_dev), sc->kue_rx_errs,
662 usbd_errstr(status));
663 sc->kue_rx_errs = 0;
664 }
665 if (status == USBD_STALLED)
666 usbd_clear_endpoint_stall_async(sc->kue_ep[KUE_ENDPT_RX]);
667 goto done;
668 }
669
670 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
671
672 DPRINTFN(10,("%s: %s: total_len=%d len=%d\n", device_xname(sc->kue_dev),
673 __func__, total_len,
674 le16dec(c->kue_buf)));
675
676 if (total_len <= 1)
677 goto done;
678
679 pktlen = le16dec(c->kue_buf);
680 if (pktlen > total_len - 2)
681 pktlen = total_len - 2;
682
683 if (pktlen < ETHER_MIN_LEN - ETHER_CRC_LEN ||
684 pktlen > MCLBYTES - ETHER_ALIGN) {
685 ifp->if_ierrors++;
686 goto done;
687 }
688
689 /* No errors; receive the packet. */
690 MGETHDR(m, M_DONTWAIT, MT_DATA);
691 if (m == NULL) {
692 ifp->if_ierrors++;
693 goto done;
694 }
695 if (pktlen > MHLEN - ETHER_ALIGN) {
696 MCLGET(m, M_DONTWAIT);
697 if ((m->m_flags & M_EXT) == 0) {
698 m_freem(m);
699 ifp->if_ierrors++;
700 goto done;
701 }
702 }
703 m->m_data += ETHER_ALIGN;
704
705 /* copy data to mbuf */
706 memcpy(mtod(m, uint8_t *), c->kue_buf + 2, pktlen);
707
708 ifp->if_ipackets++;
709 m->m_pkthdr.len = m->m_len = pktlen;
710 m_set_rcvif(m, ifp);
711
712 s = splnet();
713
714 /*
715 * Handle BPF listeners. Let the BPF user see the packet, but
716 * don't pass it up to the ether_input() layer unless it's
717 * a broadcast packet, multicast packet, matches our ethernet
718 * address or the interface is in promiscuous mode.
719 */
720 bpf_mtap(ifp, m);
721
722 DPRINTFN(10,("%s: %s: deliver %d\n", device_xname(sc->kue_dev),
723 __func__, m->m_len));
724 if_percpuq_enqueue(ifp->if_percpuq, m);
725
726 splx(s);
727
728 done:
729
730 /* Setup new transfer. */
731 usbd_setup_xfer(c->kue_xfer, c, c->kue_buf, KUE_BUFSZ,
732 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, kue_rxeof);
733 usbd_transfer(c->kue_xfer);
734
735 DPRINTFN(10,("%s: %s: start rx\n", device_xname(sc->kue_dev),
736 __func__));
737 }
738
739 /*
740 * A frame was downloaded to the chip. It's safe for us to clean up
741 * the list buffers.
742 */
743
744 static void
kue_txeof(struct usbd_xfer * xfer,void * priv,usbd_status status)745 kue_txeof(struct usbd_xfer *xfer, void *priv,
746 usbd_status status)
747 {
748 struct kue_chain *c = priv;
749 struct kue_softc *sc = c->kue_sc;
750 struct ifnet *ifp = GET_IFP(sc);
751 int s;
752
753 if (sc->kue_dying)
754 return;
755
756 s = splnet();
757
758 DPRINTFN(10,("%s: %s: enter status=%d\n", device_xname(sc->kue_dev),
759 __func__, status));
760
761 ifp->if_timer = 0;
762 ifp->if_flags &= ~IFF_OACTIVE;
763
764 if (status != USBD_NORMAL_COMPLETION) {
765 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
766 splx(s);
767 return;
768 }
769 ifp->if_oerrors++;
770 printf("%s: usb error on tx: %s\n", device_xname(sc->kue_dev),
771 usbd_errstr(status));
772 if (status == USBD_STALLED)
773 usbd_clear_endpoint_stall_async(sc->kue_ep[KUE_ENDPT_TX]);
774 splx(s);
775 return;
776 }
777
778 ifp->if_opackets++;
779
780 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
781 kue_start(ifp);
782
783 splx(s);
784 }
785
786 static int
kue_send(struct kue_softc * sc,struct mbuf * m,int idx)787 kue_send(struct kue_softc *sc, struct mbuf *m, int idx)
788 {
789 int total_len;
790 struct kue_chain *c;
791 usbd_status err;
792
793 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
794
795 c = &sc->kue_cdata.kue_tx_chain[idx];
796
797 /* Frame length is specified in the first 2 bytes of the buffer. */
798 le16enc(c->kue_buf, (uint16_t)m->m_pkthdr.len);
799
800 /*
801 * Copy the mbuf data into a contiguous buffer, leaving two
802 * bytes at the beginning to hold the frame length.
803 */
804 m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2);
805
806 total_len = 2 + m->m_pkthdr.len;
807 total_len = roundup2(total_len, 64);
808
809 usbd_setup_xfer(c->kue_xfer, c, c->kue_buf, total_len, 0,
810 USBD_DEFAULT_TIMEOUT, kue_txeof);
811
812 /* Transmit */
813 err = usbd_transfer(c->kue_xfer);
814 if (err != USBD_IN_PROGRESS) {
815 printf("%s: kue_send error=%s\n", device_xname(sc->kue_dev),
816 usbd_errstr(err));
817 kue_stop(sc);
818 return EIO;
819 }
820
821 sc->kue_cdata.kue_tx_cnt++;
822
823 return 0;
824 }
825
826 static void
kue_start(struct ifnet * ifp)827 kue_start(struct ifnet *ifp)
828 {
829 struct kue_softc *sc = ifp->if_softc;
830 struct mbuf *m;
831
832 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
833
834 if (sc->kue_dying)
835 return;
836
837 if (ifp->if_flags & IFF_OACTIVE)
838 return;
839
840 IFQ_POLL(&ifp->if_snd, m);
841 if (m == NULL)
842 return;
843
844 if (kue_send(sc, m, 0)) {
845 ifp->if_flags |= IFF_OACTIVE;
846 return;
847 }
848
849 IFQ_DEQUEUE(&ifp->if_snd, m);
850
851 /*
852 * If there's a BPF listener, bounce a copy of this frame
853 * to him.
854 */
855 bpf_mtap(ifp, m);
856 m_freem(m);
857
858 ifp->if_flags |= IFF_OACTIVE;
859
860 /*
861 * Set a timeout in case the chip goes out to lunch.
862 */
863 ifp->if_timer = 6;
864 }
865
866 static void
kue_init(void * xsc)867 kue_init(void *xsc)
868 {
869 struct kue_softc *sc = xsc;
870 struct ifnet *ifp = GET_IFP(sc);
871 int s;
872 uint8_t eaddr[ETHER_ADDR_LEN];
873
874 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
875
876 if (ifp->if_flags & IFF_RUNNING)
877 return;
878
879 s = splnet();
880
881 memcpy(eaddr, CLLADDR(ifp->if_sadl), sizeof(eaddr));
882 /* Set MAC address */
883 kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC, 0, eaddr, ETHER_ADDR_LEN);
884
885 sc->kue_rxfilt = KUE_RXFILT_UNICAST | KUE_RXFILT_BROADCAST;
886
887 /* If we want promiscuous mode, set the allframes bit. */
888 if (ifp->if_flags & IFF_PROMISC)
889 sc->kue_rxfilt |= KUE_RXFILT_PROMISC;
890
891 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
892
893 /* I'm not sure how to tune these. */
894 #if 0
895 /*
896 * Leave this one alone for now; setting it
897 * wrong causes lockups on some machines/controllers.
898 */
899 kue_setword(sc, KUE_CMD_SET_SOFS, 1);
900 #endif
901 kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64);
902
903 /* Load the multicast filter. */
904 kue_setmulti(sc);
905
906 if (sc->kue_ep[KUE_ENDPT_RX] == NULL) {
907 if (kue_open_pipes(sc)) {
908 splx(s);
909 return;
910 }
911 }
912 /* Init TX ring. */
913 if (kue_tx_list_init(sc)) {
914 printf("%s: tx list init failed\n", device_xname(sc->kue_dev));
915 splx(s);
916 return;
917 }
918
919 /* Init RX ring. */
920 if (kue_rx_list_init(sc)) {
921 printf("%s: rx list init failed\n", device_xname(sc->kue_dev));
922 splx(s);
923 return;
924 }
925
926 /* Start up the receive pipe. */
927 for (size_t i = 0; i < KUE_RX_LIST_CNT; i++) {
928 struct kue_chain *c = &sc->kue_cdata.kue_rx_chain[i];
929 usbd_setup_xfer(c->kue_xfer, c, c->kue_buf, KUE_BUFSZ,
930 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, kue_rxeof);
931 DPRINTFN(5,("%s: %s: start read\n", device_xname(sc->kue_dev),
932 __func__));
933 usbd_transfer(c->kue_xfer);
934 }
935
936 ifp->if_flags |= IFF_RUNNING;
937 ifp->if_flags &= ~IFF_OACTIVE;
938
939 splx(s);
940 }
941
942 static int
kue_open_pipes(struct kue_softc * sc)943 kue_open_pipes(struct kue_softc *sc)
944 {
945 usbd_status err;
946
947 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
948
949 /* Open RX and TX pipes. */
950 err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_RX],
951 USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_RX]);
952 if (err) {
953 printf("%s: open rx pipe failed: %s\n",
954 device_xname(sc->kue_dev), usbd_errstr(err));
955 return EIO;
956 }
957
958 err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX],
959 USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_TX]);
960 if (err) {
961 printf("%s: open tx pipe failed: %s\n",
962 device_xname(sc->kue_dev), usbd_errstr(err));
963 return EIO;
964 }
965
966 return 0;
967 }
968
969 static int
kue_ioctl(struct ifnet * ifp,u_long command,void * data)970 kue_ioctl(struct ifnet *ifp, u_long command, void *data)
971 {
972 struct kue_softc *sc = ifp->if_softc;
973 struct ifaddr *ifa = (struct ifaddr *)data;
974 struct ifreq *ifr = (struct ifreq *)data;
975 int s, error = 0;
976
977 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
978
979 if (sc->kue_dying)
980 return EIO;
981
982 s = splnet();
983
984 switch(command) {
985 case SIOCINITIFADDR:
986 ifp->if_flags |= IFF_UP;
987 kue_init(sc);
988
989 switch (ifa->ifa_addr->sa_family) {
990 #ifdef INET
991 case AF_INET:
992 arp_ifinit(ifp, ifa);
993 break;
994 #endif /* INET */
995 }
996 break;
997
998 case SIOCSIFMTU:
999 if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > ETHERMTU)
1000 error = EINVAL;
1001 else if ((error = ifioctl_common(ifp, command, data)) == ENETRESET)
1002 error = 0;
1003 break;
1004
1005 case SIOCSIFFLAGS:
1006 if ((error = ifioctl_common(ifp, command, data)) != 0)
1007 break;
1008 if (ifp->if_flags & IFF_UP) {
1009 if (ifp->if_flags & IFF_RUNNING &&
1010 ifp->if_flags & IFF_PROMISC &&
1011 !(sc->kue_if_flags & IFF_PROMISC)) {
1012 sc->kue_rxfilt |= KUE_RXFILT_PROMISC;
1013 kue_setword(sc, KUE_CMD_SET_PKT_FILTER,
1014 sc->kue_rxfilt);
1015 } else if (ifp->if_flags & IFF_RUNNING &&
1016 !(ifp->if_flags & IFF_PROMISC) &&
1017 sc->kue_if_flags & IFF_PROMISC) {
1018 sc->kue_rxfilt &= ~KUE_RXFILT_PROMISC;
1019 kue_setword(sc, KUE_CMD_SET_PKT_FILTER,
1020 sc->kue_rxfilt);
1021 } else if (!(ifp->if_flags & IFF_RUNNING))
1022 kue_init(sc);
1023 } else {
1024 if (ifp->if_flags & IFF_RUNNING)
1025 kue_stop(sc);
1026 }
1027 sc->kue_if_flags = ifp->if_flags;
1028 error = 0;
1029 break;
1030 case SIOCADDMULTI:
1031 case SIOCDELMULTI:
1032 error = ether_ioctl(ifp, command, data);
1033 if (error == ENETRESET) {
1034 if (ifp->if_flags & IFF_RUNNING)
1035 kue_setmulti(sc);
1036 error = 0;
1037 }
1038 break;
1039 default:
1040 error = ether_ioctl(ifp, command, data);
1041 break;
1042 }
1043
1044 splx(s);
1045
1046 return error;
1047 }
1048
1049 static void
kue_watchdog(struct ifnet * ifp)1050 kue_watchdog(struct ifnet *ifp)
1051 {
1052 struct kue_softc *sc = ifp->if_softc;
1053 struct kue_chain *c;
1054 usbd_status stat;
1055 int s;
1056
1057 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
1058
1059 if (sc->kue_dying)
1060 return;
1061
1062 ifp->if_oerrors++;
1063 printf("%s: watchdog timeout\n", device_xname(sc->kue_dev));
1064
1065 s = splusb();
1066 c = &sc->kue_cdata.kue_tx_chain[0];
1067 usbd_get_xfer_status(c->kue_xfer, NULL, NULL, NULL, &stat);
1068 kue_txeof(c->kue_xfer, c, stat);
1069
1070 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1071 kue_start(ifp);
1072 splx(s);
1073 }
1074
1075 /*
1076 * Stop the adapter and free any mbufs allocated to the
1077 * RX and TX lists.
1078 */
1079 static void
kue_stop(struct kue_softc * sc)1080 kue_stop(struct kue_softc *sc)
1081 {
1082 usbd_status err;
1083 struct ifnet *ifp;
1084 int i;
1085
1086 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
1087
1088 ifp = GET_IFP(sc);
1089 ifp->if_timer = 0;
1090
1091 /* Stop transfers. */
1092 if (sc->kue_ep[KUE_ENDPT_RX] != NULL) {
1093 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_RX]);
1094 if (err) {
1095 printf("%s: abort rx pipe failed: %s\n",
1096 device_xname(sc->kue_dev), usbd_errstr(err));
1097 }
1098 }
1099
1100 if (sc->kue_ep[KUE_ENDPT_TX] != NULL) {
1101 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]);
1102 if (err) {
1103 printf("%s: abort tx pipe failed: %s\n",
1104 device_xname(sc->kue_dev), usbd_errstr(err));
1105 }
1106 }
1107
1108 if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) {
1109 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
1110 if (err) {
1111 printf("%s: abort intr pipe failed: %s\n",
1112 device_xname(sc->kue_dev), usbd_errstr(err));
1113 }
1114 }
1115
1116 /* Free RX resources. */
1117 for (i = 0; i < KUE_RX_LIST_CNT; i++) {
1118 if (sc->kue_cdata.kue_rx_chain[i].kue_xfer != NULL) {
1119 usbd_destroy_xfer(sc->kue_cdata.kue_rx_chain[i].kue_xfer);
1120 sc->kue_cdata.kue_rx_chain[i].kue_xfer = NULL;
1121 }
1122 }
1123
1124 /* Free TX resources. */
1125 for (i = 0; i < KUE_TX_LIST_CNT; i++) {
1126 if (sc->kue_cdata.kue_tx_chain[i].kue_xfer != NULL) {
1127 usbd_destroy_xfer(sc->kue_cdata.kue_tx_chain[i].kue_xfer);
1128 sc->kue_cdata.kue_tx_chain[i].kue_xfer = NULL;
1129 }
1130 }
1131
1132 /* Close pipes. */
1133 if (sc->kue_ep[KUE_ENDPT_RX] != NULL) {
1134 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_RX]);
1135 if (err) {
1136 printf("%s: close rx pipe failed: %s\n",
1137 device_xname(sc->kue_dev), usbd_errstr(err));
1138 }
1139 sc->kue_ep[KUE_ENDPT_RX] = NULL;
1140 }
1141
1142 if (sc->kue_ep[KUE_ENDPT_TX] != NULL) {
1143 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_TX]);
1144 if (err) {
1145 printf("%s: close tx pipe failed: %s\n",
1146 device_xname(sc->kue_dev), usbd_errstr(err));
1147 }
1148 sc->kue_ep[KUE_ENDPT_TX] = NULL;
1149 }
1150
1151 if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) {
1152 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
1153 if (err) {
1154 printf("%s: close intr pipe failed: %s\n",
1155 device_xname(sc->kue_dev), usbd_errstr(err));
1156 }
1157 sc->kue_ep[KUE_ENDPT_INTR] = NULL;
1158 }
1159
1160 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1161 }
1162