root/dev/usb/if_kue.c

DEFINITIONS

1. kue_setword
2. kue_ctl
3. kue_load_fw
4. kue_setmulti
5. kue_reset
6. kue_match
7. kue_attachhook
8. kue_attach
9. kue_detach
10. kue_activate
11. kue_newbuf
12. kue_rx_list_init
13. kue_tx_list_init
14. kue_rxeof
15. kue_txeof
16. kue_send
17. kue_start
18. kue_init
19. kue_open_pipes
20. kue_ioctl
21. kue_watchdog
22. kue_stop

    1 /*      $OpenBSD: if_kue.c,v 1.55 2007/06/14 10:11:15 mbalmer Exp $ */
    2 /*      $NetBSD: if_kue.c,v 1.50 2002/07/16 22:00:31 augustss Exp $     */
    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  */
   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  */
   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  */
   69 /*
   70  * Ported to NetBSD and somewhat rewritten by Lennart Augustsson.
   71  */
   73 #include "bpfilter.h"
   75 #include <sys/param.h>
   76 #include <sys/systm.h>
   77 #include <sys/sockio.h>
   78 #include <sys/mbuf.h>
   79 #include <sys/malloc.h>
   80 #include <sys/kernel.h>
   81 #include <sys/socket.h>
   82 #include <sys/device.h>
   83 #include <sys/proc.h>
   85 #include <net/if.h>
   86 #include <net/if_dl.h>
   88 #if NBPFILTER > 0
   89 #include <net/bpf.h>
   90 #endif
   92 #ifdef INET
   93 #include <netinet/in.h>
   94 #include <netinet/in_systm.h>
   95 #include <netinet/in_var.h>
   96 #include <netinet/ip.h>
   97 #include <netinet/if_ether.h>
   98 #endif
  100 #include <dev/usb/usb.h>
  101 #include <dev/usb/usbdi.h>
  102 #include <dev/usb/usbdi_util.h>
  103 #include <dev/usb/usbdevs.h>
  105 #include <dev/usb/if_kuereg.h>
  106 #include <dev/usb/if_kuevar.h>
  108 #ifdef KUE_DEBUG
  109 #define DPRINTF(x)      do { if (kuedebug) printf x; } while (0)
  110 #define DPRINTFN(n,x)   do { if (kuedebug >= (n)) printf x; } while (0)
  111 int     kuedebug = 0;
  112 #else
  113 #define DPRINTF(x)
  114 #define DPRINTFN(n,x)
  115 #endif
  117 /*
  118  * Various supported device vendors/products.
  119  */
  120 const struct usb_devno kue_devs[] = {
  121         { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C19250 },
  122         { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C460 },
  123         { USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_URE450 },
  124         { USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BT },
  125         { USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BTX },
  126         { USB_VENDOR_AOX, USB_PRODUCT_AOX_USB101 },
  127         { USB_VENDOR_ASANTE, USB_PRODUCT_ASANTE_EA },
  128         { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC10T },
  129         { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_DSB650C },
  130         { USB_VENDOR_COREGA, USB_PRODUCT_COREGA_ETHER_USB_T },
  131         { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650C },
  132         { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_E45 },
  133         { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_XX1 },
  134         { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_XX2 },
  135         { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBETT },
  136         { USB_VENDOR_JATON, USB_PRODUCT_JATON_EDA },
  137         { USB_VENDOR_KINGSTON, USB_PRODUCT_KINGSTON_XX1 },
  138         { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BT },
  139         { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BTN },
  140         { USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10T },
  141         { USB_VENDOR_MOBILITY, USB_PRODUCT_MOBILITY_EA },
  142         { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101 },
  143         { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101X },
  144         { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET },
  145         { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET2 },
  146         { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET3 },
  147         { USB_VENDOR_PORTGEAR, USB_PRODUCT_PORTGEAR_EA8 },
  148         { USB_VENDOR_PORTGEAR, USB_PRODUCT_PORTGEAR_EA9 },
  149         { USB_VENDOR_PORTSMITH, USB_PRODUCT_PORTSMITH_EEA },
  150         { USB_VENDOR_SHARK, USB_PRODUCT_SHARK_PA },
  151         { USB_VENDOR_SILICOM, USB_PRODUCT_SILICOM_U2E },
  152         { USB_VENDOR_SILICOM, USB_PRODUCT_SILICOM_GPE },
  153         { USB_VENDOR_SMC, USB_PRODUCT_SMC_2102USB },
  154 };
  155 #define kue_lookup(v, p) (usb_lookup(kue_devs, v, p))
  157 int kue_match(struct device *, void *, void *); 
  158 void kue_attach(struct device *, struct device *, void *); 
  159 int kue_detach(struct device *, int); 
  160 int kue_activate(struct device *, enum devact); 
  162 struct cfdriver kue_cd = { 
NULL, "kue", DV_IFNET 
  164 }; 
  166 const struct cfattach kue_ca = { 
  167         sizeof(struct kue_softc), 
kue_match, 
kue_attach, 
kue_detach, 
kue_activate, 
  172 };
  174 int kue_tx_list_init(struct kue_softc *);
  175 int kue_rx_list_init(struct kue_softc *);
  176 int kue_newbuf(struct kue_softc *, struct kue_chain *,struct mbuf *);
  177 int kue_send(struct kue_softc *, struct mbuf *, int);
  178 int kue_open_pipes(struct kue_softc *);
  179 void kue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
  180 void kue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
  181 void kue_start(struct ifnet *);
  182 int kue_ioctl(struct ifnet *, u_long, caddr_t);
  183 void kue_init(void *);
  184 void kue_stop(struct kue_softc *);
  185 void kue_watchdog(struct ifnet *);
  187 void kue_setmulti(struct kue_softc *);
  188 void kue_reset(struct kue_softc *);
usbd_status kue_ctl(struct kue_softc *, int, u_int8_t,
u_int16_t, void *, u_int32_t);
usbd_status kue_setword(struct kue_softc *, u_int8_t, u_int16_t);
  193 int kue_load_fw(struct kue_softc *);
  194 void kue_attachhook(void *);
usbd_status
kue_setword(struct kue_softc *sc, u_int8_t breq, u_int16_t word)
  198 {
usb_device_request_t    req;
DPRINTFN(10,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = breq;
USETW(req.wValue, word);
USETW(req.wIndex, 0);
USETW(req.wLength, 0);
  209         return (usbd_do_request(sc->kue_udev, &req, NULL));
  210 }
usbd_status
kue_ctl(struct kue_softc *sc, int rw, u_int8_t breq, u_int16_t val,
  214         void *data, u_int32_t len)
  215 {
usb_device_request_t    req;
DPRINTFN(10,("%s: %s: enter, len=%d\n", sc->kue_dev.dv_xname,
__func__, len));
  221         if (rw == KUE_CTL_WRITE)
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
  223         else
req.bmRequestType = UT_READ_VENDOR_DEVICE;
req.bRequest = breq;
USETW(req.wValue, val);
USETW(req.wIndex, 0);
USETW(req.wLength, len);
  231         return (usbd_do_request(sc->kue_udev, &req, data));
  232 }
  234 int
kue_load_fw(struct kue_softc *sc)
  236 {
usb_device_descriptor_t dd;
usbd_status             err;
  239         struct kue_firmware     *fw;
u_char                  *buf;
size_t                  buflen;
DPRINTFN(1,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
  245         /*
  246          * First, check if we even need to load the firmware.
  247          * If the device was still attached when the system was
  248          * rebooted, it may already have firmware loaded in it.
  249          * If this is the case, we don't need to do it again.
  250          * And in fact, if we try to load it again, we'll hang,
  251          * so we have to avoid this condition if we don't want
  252          * to look stupid.
  253          *
  254          * We can test this quickly by checking the bcdRevision
  255          * code. The NIC will return a different revision code if
  256          * it's probed while the firmware is still loaded and
  257          * running.
  258          */
  259         if (usbd_get_device_desc(sc->kue_udev, &dd))
  260                 return (EIO);
  261         if (UGETW(dd.bcdDevice) >= KUE_WARM_REV) {
printf("%s: warm boot, no firmware download\n",
sc->kue_dev.dv_xname);
  264                 return (0);
  265         }
err = loadfirmware("kue", &buf, &buflen);
  268         if (err) {
printf("%s: failed loadfirmware of file %s: errno %d\n",
sc->kue_dev.dv_xname, "kue", err);
  271                 return (err);
  272         }
fw = (struct kue_firmware *)buf;
printf("%s: cold boot, downloading firmware\n",
sc->kue_dev.dv_xname);
  278         /* Load code segment */
DPRINTFN(1,("%s: kue_load_fw: download code_seg\n",
sc->kue_dev.dv_xname));
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
  282             0, (void *)&fw->data[0], ntohl(fw->codeseglen));
  283         if (err) {
printf("%s: failed to load code segment: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
free(buf, M_DEVBUF);
  287                 return (EIO);
  288         }
  290         /* Load fixup segment */
DPRINTFN(1,("%s: kue_load_fw: download fix_seg\n",
sc->kue_dev.dv_xname));
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
  294             0, (void *)&fw->data[ntohl(fw->codeseglen)], ntohl(fw->fixseglen));
  295         if (err) {
printf("%s: failed to load fixup segment: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
free(buf, M_DEVBUF);
  299                 return (EIO);
  300         }
  302         /* Send trigger command. */
DPRINTFN(1,("%s: kue_load_fw: download trig_seg\n",
sc->kue_dev.dv_xname));
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
  306             0, (void *)&fw->data[ntohl(fw->codeseglen) + ntohl(fw->fixseglen)],
ntohl(fw->trigseglen));
  308         if (err) {
printf("%s: failed to load trigger segment: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
free(buf, M_DEVBUF);
  312                 return (EIO);
  313         }
free(buf, M_DEVBUF);
usbd_delay_ms(sc->kue_udev, 10);
  318         /*
  319          * Reload device descriptor.
  320          * Why? The chip without the firmware loaded returns
  321          * one revision code. The chip with the firmware
  322          * loaded and running returns a *different* revision
  323          * code. This confuses the quirk mechanism, which is
  324          * dependent on the revision data.
  325          */
  326         (void)usbd_reload_device_desc(sc->kue_udev);
DPRINTFN(1,("%s: %s: done\n", sc->kue_dev.dv_xname, __func__));
  330         /* Reset the adapter. */
kue_reset(sc);
  333         return (0);
  334 }
  336 void
kue_setmulti(struct kue_softc *sc)
  338 {
  339         struct ifnet            *ifp = GET_IFP(sc);
  340         struct ether_multi      *enm;
  341         struct ether_multistep  step;
  342         int                     i;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
  346         if (ifp->if_flags & IFF_PROMISC) {
allmulti:
ifp->if_flags |= IFF_ALLMULTI;
sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI;
sc->kue_rxfilt &= ~KUE_RXFILT_MULTICAST;
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
  352                 return;
  353         }
sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI;
i = 0;
ETHER_FIRST_MULTI(step, &sc->arpcom, enm);
  359         while (enm != NULL) {
  360                 if (i == KUE_MCFILTCNT(sc) ||
memcmp(enm->enm_addrlo, enm->enm_addrhi,
ETHER_ADDR_LEN) != 0)
  363                         goto allmulti;
memcpy(KUE_MCFILT(sc, i), enm->enm_addrlo, ETHER_ADDR_LEN);
ETHER_NEXT_MULTI(step, enm);
i++;
  368         }
ifp->if_flags &= ~IFF_ALLMULTI;
sc->kue_rxfilt |= KUE_RXFILT_MULTICAST;
kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MCAST_FILTERS,
i, sc->kue_mcfilters, i * ETHER_ADDR_LEN);
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
  377 }
  379 /*
  380  * Issue a SET_CONFIGURATION command to reset the MAC. This should be
  381  * done after the firmware is loaded into the adapter in order to
  382  * bring it into proper operation.
  383  */
  384 void
kue_reset(struct kue_softc *sc)
  386 {
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
  389         if (usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 1) ||
usbd_device2interface_handle(sc->kue_udev, KUE_IFACE_IDX,
  391                                          &sc->kue_iface))
printf("%s: reset failed\n", sc->kue_dev.dv_xname);
  394         /* Wait a little while for the chip to get its brains in order. */
usbd_delay_ms(sc->kue_udev, 10);
  396 }
  398 /*
  399  * Probe for a KLSI chip.
  400  */
  401 int
kue_match(struct device *parent, void *match, void *aux)
  403 {
  404         struct usb_attach_arg   *uaa = aux;
DPRINTFN(25,("kue_match: enter\n"));
  408         if (uaa->iface != NULL)
  409                 return (UMATCH_NONE);
  411         return (kue_lookup(uaa->vendor, uaa->product) != NULL ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
  413 }
  415 void
kue_attachhook(void *xsc)
  417 {
  418         struct kue_softc *sc = xsc;
  419         int                     s;
  420         struct ifnet            *ifp;
usbd_device_handle      dev = sc->kue_udev;
usbd_interface_handle   iface;
usbd_status             err;
usb_interface_descriptor_t      *id;
usb_endpoint_descriptor_t       *ed;
  426         int                     i;
  428         /* Load the firmware into the NIC. */
  429         if (kue_load_fw(sc)) {
printf("%s: loading firmware failed\n",
sc->kue_dev.dv_xname);
  432                 return;
  433         }
err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface);
  436         if (err) {
printf("%s: getting interface handle failed\n",
sc->kue_dev.dv_xname);
  439                 return;
  440         }
sc->kue_iface = iface;
id = usbd_get_interface_descriptor(iface);
  445         /* Find endpoints. */
  446         for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
  448                 if (ed == NULL) {
printf("%s: couldn't get ep %d\n",
sc->kue_dev.dv_xname, i);
  451                         return;
  452                 }
  453                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
  456                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
  459                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
  462                 }
  463         }
  465         if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) {
printf("%s: missing endpoint\n", sc->kue_dev.dv_xname);
  467                 return;
  468         }
  470         /* Read ethernet descriptor */
err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
  472             0, &sc->kue_desc, sizeof(sc->kue_desc));
  473         if (err) {
printf("%s: could not read Ethernet descriptor\n",
sc->kue_dev.dv_xname);
  476                 return;
  477         }
sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
M_USBDEV, M_NOWAIT);
  481         if (sc->kue_mcfilters == NULL) {
printf("%s: no memory for multicast filter buffer\n",
sc->kue_dev.dv_xname);
  484                 return;
  485         }
s = splnet();
  489         /*
  490          * A KLSI chip was detected. Inform the world.
  491          */
printf("%s: address %s\n", sc->kue_dev.dv_xname,
ether_sprintf(sc->kue_desc.kue_macaddr));
bcopy(sc->kue_desc.kue_macaddr,
  496             (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
  498         /* Initialize interface info.*/
ifp = GET_IFP(sc);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = kue_ioctl;
ifp->if_start = kue_start;
ifp->if_watchdog = kue_watchdog;
strlcpy(ifp->if_xname, sc->kue_dev.dv_xname, IFNAMSIZ);
IFQ_SET_READY(&ifp->if_snd);
  509         /* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp);
sc->kue_attached = 1;
splx(s);
  516 }
  518 /*
  519  * Attach the interface. Allocate softc structures, do
  520  * setup and ethernet/BPF attach.
  521  */
  522 void
kue_attach(struct device *parent, struct device *self, void *aux)
  524 {
  525         struct kue_softc        *sc = (struct kue_softc *)self;
  526         struct usb_attach_arg   *uaa = aux;
  527         char                    *devinfop;
usbd_device_handle      dev = uaa->device;
usbd_status             err;
DPRINTFN(5,(" : kue_attach: sc=%p, dev=%p", sc, dev));
devinfop = usbd_devinfo_alloc(dev, 0);
printf("\n%s: %s\n", sc->kue_dev.dv_xname, devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, KUE_CONFIG_NO, 1);
  538         if (err) {
printf("%s: setting config no failed\n",
sc->kue_dev.dv_xname);
  541                 return;
  542         }
sc->kue_udev = dev;
sc->kue_product = uaa->product;
sc->kue_vendor = uaa->vendor;
  548         if (rootvp == NULL)
mountroothook_establish(kue_attachhook, sc);
  550         else
kue_attachhook(sc);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->kue_udev,
  554                            &sc->kue_dev);
  555 }
  557 int
kue_detach(struct device *self, int flags)
  559 {
  560         struct kue_softc        *sc = (struct kue_softc *)self;
  561         struct ifnet            *ifp = GET_IFP(sc);
  562         int                     s;
s = splusb();           /* XXX why? */
  566         if (sc->kue_mcfilters != NULL) {
free(sc->kue_mcfilters, M_USBDEV);
sc->kue_mcfilters = NULL;
  569         }
  571         if (!sc->kue_attached) {
  572                 /* Detached before attached finished, so just bail out. */
splx(s);
  574                 return (0);
  575         }
  577         if (ifp->if_flags & IFF_RUNNING)
kue_stop(sc);
ether_ifdetach(ifp);
if_detach(ifp);
  584 #ifdef DIAGNOSTIC
  585         if (sc->kue_ep[KUE_ENDPT_TX] != NULL ||
sc->kue_ep[KUE_ENDPT_RX] != NULL ||
sc->kue_ep[KUE_ENDPT_INTR] != NULL)
printf("%s: detach has active endpoints\n",
sc->kue_dev.dv_xname);
  590 #endif
sc->kue_attached = 0;
splx(s);
  595         return (0);
  596 }
  598 int
kue_activate(struct device *self, enum devact act)
  600 {
  601         struct kue_softc *sc = (struct kue_softc *)self;
DPRINTFN(2,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
  605         switch (act) {
  606         case DVACT_ACTIVATE:
  607                 break;
  609         case DVACT_DEACTIVATE:
sc->kue_dying = 1;
  611                 break;
  612         }
  613         return (0);
  614 }
  616 /*
  617  * Initialize an RX descriptor and attach an MBUF cluster.
  618  */
  619 int
kue_newbuf(struct kue_softc *sc, struct kue_chain *c, struct mbuf *m)
  621 {
  622         struct mbuf             *m_new = NULL;
DPRINTFN(10,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
  626         if (m == NULL) {
MGETHDR(m_new, M_DONTWAIT, MT_DATA);
  628                 if (m_new == NULL) {
printf("%s: no memory for rx list "
  630                             "-- packet dropped!\n", sc->kue_dev.dv_xname);
  631                         return (ENOBUFS);
  632                 }
MCLGET(m_new, M_DONTWAIT);
  635                 if (!(m_new->m_flags & M_EXT)) {
printf("%s: no memory for rx list "
  637                             "-- packet dropped!\n", sc->kue_dev.dv_xname);
m_freem(m_new);
  639                         return (ENOBUFS);
  640                 }
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
  642         } else {
m_new = m;
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
m_new->m_data = m_new->m_ext.ext_buf;
  646         }
c->kue_mbuf = m_new;
  650         return (0);
  651 }
  653 int
kue_rx_list_init(struct kue_softc *sc)
  655 {
  656         struct kue_cdata        *cd;
  657         struct kue_chain        *c;
  658         int                     i;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
cd = &sc->kue_cdata;
  663         for (i = 0; i < KUE_RX_LIST_CNT; i++) {
c = &cd->kue_rx_chain[i];
c->kue_sc = sc;
c->kue_idx = i;
  667                 if (kue_newbuf(sc, c, NULL) == ENOBUFS)
  668                         return (ENOBUFS);
  669                 if (c->kue_xfer == NULL) {
c->kue_xfer = usbd_alloc_xfer(sc->kue_udev);
  671                         if (c->kue_xfer == NULL)
  672                                 return (ENOBUFS);
c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ);
  674                         if (c->kue_buf == NULL)
  675                                 return (ENOBUFS); /* XXX free xfer */
  676                 }
  677         }
  679         return (0);
  680 }
  682 int
kue_tx_list_init(struct kue_softc *sc)
  684 {
  685         struct kue_cdata        *cd;
  686         struct kue_chain        *c;
  687         int                     i;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
cd = &sc->kue_cdata;
  692         for (i = 0; i < KUE_TX_LIST_CNT; i++) {
c = &cd->kue_tx_chain[i];
c->kue_sc = sc;
c->kue_idx = i;
c->kue_mbuf = NULL;
  697                 if (c->kue_xfer == NULL) {
c->kue_xfer = usbd_alloc_xfer(sc->kue_udev);
  699                         if (c->kue_xfer == NULL)
  700                                 return (ENOBUFS);
c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ);
  702                         if (c->kue_buf == NULL)
  703                                 return (ENOBUFS);
  704                 }
  705         }
  707         return (0);
  708 }
  710 /*
  711  * A frame has been uploaded: pass the resulting mbuf chain up to
  712  * the higher level protocols.
  713  */
  714 void
kue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  716 {
  717         struct kue_chain        *c = priv;
  718         struct kue_softc        *sc = c->kue_sc;
  719         struct ifnet            *ifp = GET_IFP(sc);
  720         struct mbuf             *m;
  721         int                     total_len = 0;
  722         int                     s;
DPRINTFN(10,("%s: %s: enter status=%d\n", sc->kue_dev.dv_xname,
__func__, status));
  727         if (sc->kue_dying)
  728                 return;
  730         if (!(ifp->if_flags & IFF_RUNNING))
  731                 return;
  733         if (status != USBD_NORMAL_COMPLETION) {
  734                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
  735                         return;
sc->kue_rx_errs++;
  737                 if (usbd_ratecheck(&sc->kue_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
sc->kue_dev.dv_xname, sc->kue_rx_errs,
usbd_errstr(status));
sc->kue_rx_errs = 0;
  742                 }
  743                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->kue_ep[KUE_ENDPT_RX]);
  745                 goto done;
  746         }
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
DPRINTFN(10,("%s: %s: total_len=%d len=%d\n", sc->kue_dev.dv_xname,
__func__, total_len,
UGETW(mtod(c->kue_mbuf, u_int8_t *))));
  754         if (total_len <= 1)
  755                 goto done;
m = c->kue_mbuf;
  758         /* copy data to mbuf */
memcpy(mtod(m, char *), c->kue_buf, total_len);
  761         /* No errors; receive the packet. */
total_len = UGETW(mtod(m, u_int8_t *));
m_adj(m, sizeof(u_int16_t));
  765         if (total_len < sizeof(struct ether_header)) {
ifp->if_ierrors++;
  767                 goto done;
  768         }
ifp->if_ipackets++;
m->m_pkthdr.len = m->m_len = total_len;
m->m_pkthdr.rcvif = ifp;
s = splnet();
  777         /* XXX ugly */
  778         if (kue_newbuf(sc, c, NULL) == ENOBUFS) {
ifp->if_ierrors++;
  780                 goto done1;
  781         }
  783 #if NBPFILTER > 0
  784         /*
  785          * Handle BPF listeners. Let the BPF user see the packet, but
  786          * don't pass it up to the ether_input() layer unless it's
  787          * a broadcast packet, multicast packet, matches our ethernet
  788          * address or the interface is in promiscuous mode.
  789          */
  790         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
  792 #endif
DPRINTFN(10,("%s: %s: deliver %d\n", sc->kue_dev.dv_xname,
__func__, m->m_len));
ether_input_mbuf(ifp, m);
done1:
splx(s);
done:
  802         /* Setup new transfer. */
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, kue_rxeof);
usbd_transfer(c->kue_xfer);
DPRINTFN(10,("%s: %s: start rx\n", sc->kue_dev.dv_xname,
__func__));
  810 }
  812 /*
  813  * A frame was downloaded to the chip. It's safe for us to clean up
  814  * the list buffers.
  815  */
  817 void
kue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  819 {
  820         struct kue_chain        *c = priv;
  821         struct kue_softc        *sc = c->kue_sc;
  822         struct ifnet            *ifp = GET_IFP(sc);
  823         int                     s;
  825         if (sc->kue_dying)
  826                 return;
s = splnet();
DPRINTFN(10,("%s: %s: enter status=%d\n", sc->kue_dev.dv_xname,
__func__, status));
ifp->if_timer = 0;
ifp->if_flags &= ~IFF_OACTIVE;
  836         if (status != USBD_NORMAL_COMPLETION) {
  837                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
splx(s);
  839                         return;
  840                 }
ifp->if_oerrors++;
printf("%s: usb error on tx: %s\n", sc->kue_dev.dv_xname,
usbd_errstr(status));
  844                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->kue_ep[KUE_ENDPT_TX]);
splx(s);
  847                 return;
  848         }
ifp->if_opackets++;
m_freem(c->kue_mbuf);
c->kue_mbuf = NULL;
  855         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
kue_start(ifp);
splx(s);
  859 }
  861 int
kue_send(struct kue_softc *sc, struct mbuf *m, int idx)
  863 {
  864         int                     total_len;
  865         struct kue_chain        *c;
usbd_status             err;
DPRINTFN(10,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
c = &sc->kue_cdata.kue_tx_chain[idx];
  872         /*
  873          * Copy the mbuf data into a contiguous buffer, leaving two
  874          * bytes at the beginning to hold the frame length.
  875          */
m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2);
c->kue_mbuf = m;
total_len = m->m_pkthdr.len + 2;
  880         /* XXX what's this? */
total_len += 64 - (total_len % 64);
  883         /* Frame length is specified in the first 2 bytes of the buffer. */
c->kue_buf[0] = (u_int8_t)m->m_pkthdr.len;
c->kue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8);
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX],
c, c->kue_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT,
kue_txeof);
  891         /* Transmit */
err = usbd_transfer(c->kue_xfer);
  893         if (err != USBD_IN_PROGRESS) {
printf("%s: kue_send error=%s\n", sc->kue_dev.dv_xname,
usbd_errstr(err));
kue_stop(sc);
  897                 return (EIO);
  898         }
sc->kue_cdata.kue_tx_cnt++;
  902         return (0);
  903 }
  905 void
kue_start(struct ifnet *ifp)
  907 {
  908         struct kue_softc        *sc = ifp->if_softc;
  909         struct mbuf             *m_head = NULL;
DPRINTFN(10,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
  913         if (sc->kue_dying)
  914                 return;
  916         if (ifp->if_flags & IFF_OACTIVE)
  917                 return;
IFQ_POLL(&ifp->if_snd, m_head);
  920         if (m_head == NULL)
  921                 return;
  923         if (kue_send(sc, m_head, 0)) {
ifp->if_flags |= IFF_OACTIVE;
  925                 return;
  926         }
IFQ_DEQUEUE(&ifp->if_snd, m_head);
  930 #if NBPFILTER > 0
  931         /*
  932          * If there's a BPF listener, bounce a copy of this frame
  933          * to him.
  934          */
  935         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT);
  937 #endif
ifp->if_flags |= IFF_OACTIVE;
  941         /*
  942          * Set a timeout in case the chip goes out to lunch.
  943          */
ifp->if_timer = 6;
  945 }
  947 void
kue_init(void *xsc)
  949 {
  950         struct kue_softc        *sc = xsc;
  951         struct ifnet            *ifp = GET_IFP(sc);
  952         int                     s;
u_char                  *eaddr;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
  957         if (ifp->if_flags & IFF_RUNNING)
  958                 return;
s = splnet();
eaddr = sc->arpcom.ac_enaddr;
  963         /* Set MAC address */
kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC, 0, eaddr, ETHER_ADDR_LEN);
sc->kue_rxfilt = KUE_RXFILT_UNICAST | KUE_RXFILT_BROADCAST;
  968          /* If we want promiscuous mode, set the allframes bit. */
  969         if (ifp->if_flags & IFF_PROMISC)
sc->kue_rxfilt |= KUE_RXFILT_PROMISC;
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
  974         /* I'm not sure how to tune these. */
  975 #if 0
  976         /*
  977          * Leave this one alone for now; setting it
  978          * wrong causes lockups on some machines/controllers.
  979          */
kue_setword(sc, KUE_CMD_SET_SOFS, 1);
  981 #endif
kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64);
  984         /* Init TX ring. */
  985         if (kue_tx_list_init(sc) == ENOBUFS) {
printf("%s: tx list init failed\n", sc->kue_dev.dv_xname);
splx(s);
  988                 return;
  989         }
  991         /* Init RX ring. */
  992         if (kue_rx_list_init(sc) == ENOBUFS) {
printf("%s: rx list init failed\n", sc->kue_dev.dv_xname);
splx(s);
  995                 return;
  996         }
  998         /* Load the multicast filter. */
kue_setmulti(sc);
 1001         if (sc->kue_ep[KUE_ENDPT_RX] == NULL) {
 1002                 if (kue_open_pipes(sc)) {
splx(s);
 1004                         return;
 1005                 }
 1006         }
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
splx(s);
 1012 }
 1014 int
kue_open_pipes(struct kue_softc *sc)
 1016 {
usbd_status             err;
 1018         struct kue_chain        *c;
 1019         int                     i;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
 1023         /* Open RX and TX pipes. */
err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_RX],
USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_RX]);
 1026         if (err) {
printf("%s: open rx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1029                 return (EIO);
 1030         }
err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX],
USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_TX]);
 1034         if (err) {
printf("%s: open tx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1037                 return (EIO);
 1038         }
 1040         /* Start up the receive pipe. */
 1041         for (i = 0; i < KUE_RX_LIST_CNT; i++) {
c = &sc->kue_cdata.kue_rx_chain[i];
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
c, c->kue_buf, KUE_BUFSZ,
USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
kue_rxeof);
DPRINTFN(5,("%s: %s: start read\n", sc->kue_dev.dv_xname,
__func__));
usbd_transfer(c->kue_xfer);
 1050         }
 1052         return (0);
 1053 }
 1055 int
kue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 1057 {
 1058         struct kue_softc        *sc = ifp->if_softc;
 1059         struct ifaddr           *ifa = (struct ifaddr *)data;
 1060         struct ifreq            *ifr = (struct ifreq *)data;
 1061         int                     s, error = 0;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
 1065         if (sc->kue_dying)
 1066                 return (EIO);
 1068 #ifdef DIAGNOSTIC
 1069         if (!curproc) {
printf("%s: no proc!!\n", sc->kue_dev.dv_xname);
 1071                 return EIO;
 1072         }
 1073 #endif
s = splnet();
 1077         switch(command) {
 1078         case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
kue_init(sc);
 1082                 switch (ifa->ifa_addr->sa_family) {
 1083 #ifdef INET
 1084                 case AF_INET:
arp_ifinit(&sc->arpcom, ifa);
 1086                         break;
 1087 #endif /* INET */
 1088                 }
 1089                 break;
 1091         case SIOCSIFMTU:
 1092                 if (ifr->ifr_mtu > ETHERMTU)
error = EINVAL;
 1094                 else
ifp->if_mtu = ifr->ifr_mtu;
 1096                 break;
 1098         case SIOCSIFFLAGS:
 1099                 if (ifp->if_flags & IFF_UP) {
 1100                         if (ifp->if_flags & IFF_RUNNING &&
ifp->if_flags & IFF_PROMISC &&
 1102                             !(sc->kue_if_flags & IFF_PROMISC)) {
sc->kue_rxfilt |= KUE_RXFILT_PROMISC;
kue_setword(sc, KUE_CMD_SET_PKT_FILTER,
sc->kue_rxfilt);
 1106                         } else if (ifp->if_flags & IFF_RUNNING &&
 1107                             !(ifp->if_flags & IFF_PROMISC) &&
sc->kue_if_flags & IFF_PROMISC) {
sc->kue_rxfilt &= ~KUE_RXFILT_PROMISC;
kue_setword(sc, KUE_CMD_SET_PKT_FILTER,
sc->kue_rxfilt);
 1112                         } else if (!(ifp->if_flags & IFF_RUNNING))
kue_init(sc);
 1114                 } else {
 1115                         if (ifp->if_flags & IFF_RUNNING)
kue_stop(sc);
 1117                 }
sc->kue_if_flags = ifp->if_flags;
error = 0;
 1120                 break;
 1121         case SIOCADDMULTI:
 1122         case SIOCDELMULTI:
error = (command == SIOCADDMULTI) ?
ether_addmulti(ifr, &sc->arpcom) :
ether_delmulti(ifr, &sc->arpcom);
 1127                 if (error == ENETRESET) {
 1128                         /*
 1129                          * Multicast list has changed; set the hardware
 1130                          * filter accordingly.
 1131                          */
 1132                         if (ifp->if_flags & IFF_RUNNING)
kue_setmulti(sc);
error = 0;
 1135                 }
 1136                 break;
 1137         default:
error = EINVAL;
 1139                 break;
 1140         }
splx(s);
 1144         return (error);
 1145 }
 1147 void
kue_watchdog(struct ifnet *ifp)
 1149 {
 1150         struct kue_softc        *sc = ifp->if_softc;
 1151         struct kue_chain        *c;
usbd_status             stat;
 1153         int                     s;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
 1157         if (sc->kue_dying)
 1158                 return;
ifp->if_oerrors++;
printf("%s: watchdog timeout\n", sc->kue_dev.dv_xname);
s = splusb();
c = &sc->kue_cdata.kue_tx_chain[0];
usbd_get_xfer_status(c->kue_xfer, NULL, NULL, NULL, &stat);
kue_txeof(c->kue_xfer, c, stat);
 1168         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
kue_start(ifp);
splx(s);
 1171 }
 1173 /*
 1174  * Stop the adapter and free any mbufs allocated to the
 1175  * RX and TX lists.
 1176  */
 1177 void
kue_stop(struct kue_softc *sc)
 1179 {
usbd_status             err;
 1181         struct ifnet            *ifp;
 1182         int                     i;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
ifp = GET_IFP(sc);
ifp->if_timer = 0;
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 1190         /* Stop transfers. */
 1191         if (sc->kue_ep[KUE_ENDPT_RX] != NULL) {
err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_RX]);
 1193                 if (err) {
printf("%s: abort rx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1196                 }
err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_RX]);
 1198                 if (err) {
printf("%s: close rx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1201                 }
sc->kue_ep[KUE_ENDPT_RX] = NULL;
 1203         }
 1205         if (sc->kue_ep[KUE_ENDPT_TX] != NULL) {
err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]);
 1207                 if (err) {
printf("%s: abort tx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1210                 }
err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_TX]);
 1212                 if (err) {
printf("%s: close tx pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1215                 }
sc->kue_ep[KUE_ENDPT_TX] = NULL;
 1217         }
 1219         if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) {
err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
 1221                 if (err) {
printf("%s: abort intr pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1224                 }
err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
 1226                 if (err) {
printf("%s: close intr pipe failed: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
 1229                 }
sc->kue_ep[KUE_ENDPT_INTR] = NULL;
 1231         }
 1233         /* Free RX resources. */
 1234         for (i = 0; i < KUE_RX_LIST_CNT; i++) {
 1235                 if (sc->kue_cdata.kue_rx_chain[i].kue_mbuf != NULL) {
m_freem(sc->kue_cdata.kue_rx_chain[i].kue_mbuf);
sc->kue_cdata.kue_rx_chain[i].kue_mbuf = NULL;
 1238                 }
 1239                 if (sc->kue_cdata.kue_rx_chain[i].kue_xfer != NULL) {
usbd_free_xfer(sc->kue_cdata.kue_rx_chain[i].kue_xfer);
sc->kue_cdata.kue_rx_chain[i].kue_xfer = NULL;
 1242                 }
 1243         }
 1245         /* Free TX resources. */
 1246         for (i = 0; i < KUE_TX_LIST_CNT; i++) {
 1247                 if (sc->kue_cdata.kue_tx_chain[i].kue_mbuf != NULL) {
m_freem(sc->kue_cdata.kue_tx_chain[i].kue_mbuf);
sc->kue_cdata.kue_tx_chain[i].kue_mbuf = NULL;
 1250                 }
 1251                 if (sc->kue_cdata.kue_tx_chain[i].kue_xfer != NULL) {
usbd_free_xfer(sc->kue_cdata.kue_tx_chain[i].kue_xfer);
sc->kue_cdata.kue_tx_chain[i].kue_xfer = NULL;
 1254                 }
 1255         }
 1256 }