root/dev/usb/ubt.c

DEFINITIONS

1. ubt_match
2. ubt_attach
3. ubt_detach
4. ubt_activate
5. ubt_set_isoc_config
6. ubt_abortdealloc
7. ubt_enable
8. ubt_disable
9. ubt_xmit_cmd_start
10. ubt_xmit_cmd_complete
11. ubt_xmit_acl_start
12. ubt_xmit_acl_complete
13. ubt_xmit_sco_start
14. ubt_xmit_sco_start1
15. ubt_xmit_sco_complete
16. ubt_mbufload
17. ubt_recv_event
18. ubt_recv_acl_start
19. ubt_recv_acl_complete
20. ubt_recv_sco_start1
21. ubt_recv_sco_complete

    1 /* $OpenBSD: ubt.c,v 1.8 2007/06/14 10:11:15 mbalmer Exp $ */
    3 /*-
    4  * Copyright (c) 2006 Itronix Inc.
    5  * All rights reserved.
    6  *
    7  * Written by Iain Hibbert for Itronix Inc.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions and the following disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  * 3. The name of Itronix Inc. may not be used to endorse
   18  *    or promote products derived from this software without specific
   19  *    prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   23  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
   25  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   28  * ON ANY THEORY OF LIABILITY, WHETHER IN
   29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   31  * POSSIBILITY OF SUCH DAMAGE.
   32  */
   33 /*
   34  * Copyright (c) 2002, 2003 The NetBSD Foundation, Inc.
   35  * All rights reserved.
   36  *
   37  * This code is derived from software contributed to The NetBSD Foundation
   38  * by Lennart Augustsson (lennart@augustsson.net) and
   39  * David Sainty (David.Sainty@dtsp.co.nz).
   40  *
   41  * Redistribution and use in source and binary forms, with or without
   42  * modification, are permitted provided that the following conditions
   43  * are met:
   44  * 1. Redistributions of source code must retain the above copyright
   45  *    notice, this list of conditions and the following disclaimer.
   46  * 2. Redistributions in binary form must reproduce the above copyright
   47  *    notice, this list of conditions and the following disclaimer in the
   48  *    documentation and/or other materials provided with the distribution.
   49  * 3. All advertising materials mentioning features or use of this software
   50  *    must display the following acknowledgement:
   51  *        This product includes software developed by the NetBSD
   52  *        Foundation, Inc. and its contributors.
   53  * 4. Neither the name of The NetBSD Foundation nor the names of its
   54  *    contributors may be used to endorse or promote products derived
   55  *    from this software without specific prior written permission.
   56  *
   57  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   58  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   59  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   60  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   61  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   62  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   63  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   64  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   65  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   66  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   67  * POSSIBILITY OF SUCH DAMAGE.
   68  */
   69 /*
   70  * This driver originally written by Lennart Augustsson and David Sainty,
   71  * but was mostly rewritten for the NetBSD Bluetooth protocol stack by
   72  * Iain Hibbert for Itronix, Inc using the FreeBSD ng_ubt.c driver as a
   73  * reference.
   74  */
   76 #include <sys/cdefs.h>
   78 #include <sys/param.h>
   79 #include <sys/device.h>
   80 #include <sys/ioctl.h>
   81 #include <sys/kernel.h>
   82 #include <sys/malloc.h>
   83 #include <sys/mbuf.h>
   84 #include <sys/proc.h>
   85 #include <sys/sysctl.h>
   86 #include <sys/systm.h>
   88 #include <dev/usb/usb.h>
   89 #include <dev/usb/usbdi.h>
   90 #include <dev/usb/usbdi_util.h>
   91 #include <dev/usb/usbdevs.h>
   93 #include <netbt/bluetooth.h>
   94 #include <netbt/hci.h>
   96 /*******************************************************************************
   97  *
   98  *      debugging stuff
   99  */
  100 #undef DPRINTF
  101 #undef DPRINTFN
  103 #ifdef UBT_DEBUG
  104 int     ubt_debug = UBT_DEBUG;
  106 #define DPRINTF(fmt, args...)           do {            \
  107         if (ubt_debug)                                  \
printf("%s: "fmt, __func__ , ##args);   \
  109 } while (/* CONSTCOND */0)
  111 #define DPRINTFN(n, fmt, args...)       do {            \
  112         if (ubt_debug > (n))                            \
printf("%s: "fmt, __func__ , ##args);   \
  114 } while (/* CONSTCOND */0)
  116 #else
  117 #define DPRINTF(...)
  118 #define DPRINTFN(...)
  119 #endif
  121 /*******************************************************************************
  122  *
  123  *      ubt softc structure
  124  *
  125  */
  127 /* buffer sizes */
  128 /*
  129  * NB: although ACL packets can extend to 65535 bytes, most devices
  130  * have max_acl_size at much less (largest I have seen is 384)
  131  */
  132 #define UBT_BUFSIZ_CMD          (HCI_CMD_PKT_SIZE - 1)
  133 #define UBT_BUFSIZ_ACL          (2048 - 1)
  134 #define UBT_BUFSIZ_EVENT        (HCI_EVENT_PKT_SIZE - 1)
  136 /* Transmit timeouts */
  137 #define UBT_CMD_TIMEOUT         USBD_DEFAULT_TIMEOUT
  138 #define UBT_ACL_TIMEOUT         USBD_DEFAULT_TIMEOUT
  140 /*
  141  * ISOC transfers
  142  *
  143  * xfer buffer size depends on the frame size, and the number
  144  * of frames per transfer is fixed, as each frame should be
  145  * 1ms worth of data. This keeps the rate that xfers complete
  146  * fairly constant. We use multiple xfers to keep the hardware
  147  * busy
  148  */
  149 #define UBT_NXFERS              3       /* max xfers to queue */
  150 #define UBT_NFRAMES             10      /* frames per xfer */
  152 struct ubt_isoc_xfer {
  153         struct ubt_softc        *softc;
usbd_xfer_handle         xfer;
uint8_t                 *buf;
uint16_t                 size[UBT_NFRAMES];
  157         int                      busy;
  158 };
  160 struct ubt_softc {
  161         struct device            sc_dev;
usbd_device_handle       sc_udev;
  163         int                      sc_refcnt;
  164         int                      sc_dying;
  166         /* Control Interface */
usbd_interface_handle    sc_iface0;
  169         /* Commands (control) */
usbd_xfer_handle         sc_cmd_xfer;
uint8_t                 *sc_cmd_buf;
  173         /* Events (interrupt) */
  174         int                      sc_evt_addr;   /* endpoint address */
usbd_pipe_handle         sc_evt_pipe;
uint8_t                 *sc_evt_buf;
  178         /* ACL data (in) */
  179         int                      sc_aclrd_addr; /* endpoint address */
usbd_pipe_handle         sc_aclrd_pipe; /* read pipe */
usbd_xfer_handle         sc_aclrd_xfer; /* read xfer */
uint8_t                 *sc_aclrd_buf;  /* read buffer */
  183         int                      sc_aclrd_busy; /* reading */
  185         /* ACL data (out) */
  186         int                      sc_aclwr_addr; /* endpoint address */
usbd_pipe_handle         sc_aclwr_pipe; /* write pipe */
usbd_xfer_handle         sc_aclwr_xfer; /* write xfer */
uint8_t                 *sc_aclwr_buf;  /* write buffer */
  191         /* ISOC interface */
usbd_interface_handle    sc_iface1;     /* ISOC interface */
  193         struct sysctllog        *sc_log;        /* sysctl log */
  194         int                      sc_config;     /* current config no */
  195         int                      sc_alt_config; /* no of alternates */
  197         /* SCO data (in) */
  198         int                      sc_scord_addr; /* endpoint address */
usbd_pipe_handle         sc_scord_pipe; /* read pipe */
  200         int                      sc_scord_size; /* frame length */
  201         struct ubt_isoc_xfer     sc_scord[UBT_NXFERS];
  202         struct mbuf             *sc_scord_mbuf; /* current packet */
  204         /* SCO data (out) */
  205         int                      sc_scowr_addr; /* endpoint address */
usbd_pipe_handle         sc_scowr_pipe; /* write pipe */
  207         int                      sc_scowr_size; /* frame length */
  208         struct ubt_isoc_xfer     sc_scowr[UBT_NXFERS];
  209         struct mbuf             *sc_scowr_mbuf; /* current packet */
  211         /* Protocol structure */
  212         struct hci_unit          sc_unit;
  214         /* Successfully attached */
  215         int                      sc_ok;
  216 };
  218 /*
  219  * Bluetooth unit/USB callback routines
  220  */
  221 int ubt_enable(struct hci_unit *);
  222 void ubt_disable(struct hci_unit *);
  224 void ubt_xmit_cmd_start(struct hci_unit *);
  225 void ubt_xmit_cmd_complete(usbd_xfer_handle,
usbd_private_handle, usbd_status);
  228 void ubt_xmit_acl_start(struct hci_unit *);
  229 void ubt_xmit_acl_complete(usbd_xfer_handle,
usbd_private_handle, usbd_status);
  232 void ubt_xmit_sco_start(struct hci_unit *);
  233 void ubt_xmit_sco_start1(struct ubt_softc *, struct ubt_isoc_xfer *);
  234 void ubt_xmit_sco_complete(usbd_xfer_handle,
usbd_private_handle, usbd_status);
  237 void ubt_recv_event(usbd_xfer_handle,
usbd_private_handle, usbd_status);
  240 void ubt_recv_acl_start(struct ubt_softc *);
  241 void ubt_recv_acl_complete(usbd_xfer_handle,
usbd_private_handle, usbd_status);
  244 void ubt_recv_sco_start1(struct ubt_softc *, struct ubt_isoc_xfer *);
  245 void ubt_recv_sco_complete(usbd_xfer_handle,
usbd_private_handle, usbd_status);
  248 int ubt_match(struct device *, void *, void *); 
  249 void ubt_attach(struct device *, struct device *, void *); 
  250 int ubt_detach(struct device *, int); 
  251 int ubt_activate(struct device *, enum devact); 
  253 struct cfdriver ubt_cd = { 
NULL, "ubt", DV_DULL 
  255 }; 
  257 const struct cfattach ubt_ca = { 
  258         sizeof(struct ubt_softc), 
ubt_match, 
ubt_attach, 
ubt_detach, 
ubt_activate, 
  263 };
  265 static int ubt_set_isoc_config(struct ubt_softc *);
  266 static void ubt_abortdealloc(struct ubt_softc *);
  268 /*
  269  * Match against the whole device, since we want to take
  270  * both interfaces. If a device should be ignored then add
  271  *
  272  *      { VendorID, ProductID }
  273  *
  274  * to the ubt_ignore list.
  275  */
  276 static const struct usb_devno ubt_ignore[] = {
  277         { USB_VENDOR_BROADCOM, USB_PRODUCT_BROADCOM_BCM2033 },
  278         { USB_VENDOR_BROADCOM, USB_PRODUCT_BROADCOM_BCM2033NF },
  279         { 0, 0 }        /* end of list */
  280 };
  282 int
ubt_match(struct device *parent, void *match, void *aux)
  284 {
  286         struct usb_attach_arg *uaa = aux;
usb_device_descriptor_t *dd = usbd_get_device_descriptor(uaa->device);
DPRINTFN(50, "ubt_match\n");
  291         if (usb_lookup(ubt_ignore, uaa->vendor, uaa->product))
  292                 return UMATCH_NONE;
  294         if (dd->bDeviceClass == UDCLASS_WIRELESS
  295             && dd->bDeviceSubClass == UDSUBCLASS_RF
  296             && dd->bDeviceProtocol == UDPROTO_BLUETOOTH)
  297                 return UMATCH_DEVCLASS_DEVSUBCLASS_DEVPROTO;
  299         return UMATCH_NONE;
  300 }
  303 void
ubt_attach(struct device *parent, struct device *self, void *aux)
  305 {
  306         struct ubt_softc *sc = (struct ubt_softc *)self;
  307         struct usb_attach_arg *uaa = aux;
usb_config_descriptor_t *cd;
usb_endpoint_descriptor_t *ed;
  310         char *devinfop;
  311         int err;
uint8_t count, i;
DPRINTFN(50, "ubt_attach: sc=%p\n", sc);
sc->sc_udev = uaa->device;
devinfop = usbd_devinfo_alloc(sc->sc_udev, 0);
printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
usbd_devinfo_free(devinfop);
  322         /*
  323          * Move the device into the configured state
  324          */
err = usbd_set_config_index(sc->sc_udev, 0, 1);
  326         if (err) {
printf("%s: failed to set configuration idx 0: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  330                 return;
  331         }
  333         /*
  334          * Interface 0 must have 3 endpoints
  335          *      1) Interrupt endpoint to receive HCI events
  336          *      2) Bulk IN endpoint to receive ACL data
  337          *      3) Bulk OUT endpoint to send ACL data
  338          */
err = usbd_device2interface_handle(sc->sc_udev, 0, &sc->sc_iface0);
  340         if (err) {
printf("%s: Could not get interface 0 handle %s (%d)\n",
sc->sc_dev.dv_xname, usbd_errstr(err), err);
  344                 return;
  345         }
sc->sc_evt_addr = -1;
sc->sc_aclrd_addr = -1;
sc->sc_aclwr_addr = -1;
count = 0;
  352         (void)usbd_endpoint_count(sc->sc_iface0, &count);
  354         for (i = 0 ; i < count ; i++) {
  355                 int dir, type;
ed = usbd_interface2endpoint_descriptor(sc->sc_iface0, i);
  358                 if (ed == NULL) {
printf("%s: could not read endpoint descriptor %d\n",
sc->sc_dev.dv_xname, i);
  362                         return;
  363                 }
dir = UE_GET_DIR(ed->bEndpointAddress);
type = UE_GET_XFERTYPE(ed->bmAttributes);
  368                 if (dir == UE_DIR_IN && type == UE_INTERRUPT)
sc->sc_evt_addr = ed->bEndpointAddress;
  370                 else if (dir == UE_DIR_IN && type == UE_BULK)
sc->sc_aclrd_addr = ed->bEndpointAddress;
  372                 else if (dir == UE_DIR_OUT && type == UE_BULK)
sc->sc_aclwr_addr = ed->bEndpointAddress;
  374         }
  376         if (sc->sc_evt_addr == -1) {
printf("%s: missing INTERRUPT endpoint on interface 0\n",
sc->sc_dev.dv_xname);
  380                 return;
  381         }
  382         if (sc->sc_aclrd_addr == -1) {
printf("%s: missing BULK IN endpoint on interface 0\n",
sc->sc_dev.dv_xname);
  386                 return;
  387         }
  388         if (sc->sc_aclwr_addr == -1) {
printf("%s: missing BULK OUT endpoint on interface 0\n",
sc->sc_dev.dv_xname);
  392                 return;
  393         }
  395         /*
  396          * Interface 1 must have 2 endpoints
  397          *      1) Isochronous IN endpoint to receive SCO data
  398          *      2) Isochronous OUT endpoint to send SCO data
  399          *
  400          * and will have several configurations, which can be selected
  401          * via a sysctl variable. We select config 0 to start, which
  402          * means that no SCO data will be available.
  403          */
err = usbd_device2interface_handle(sc->sc_udev, 1, &sc->sc_iface1);
  405         if (err) {
printf("%s: Could not get interface 1 handle %s (%d)\n",
sc->sc_dev.dv_xname, usbd_errstr(err), err);
  409                 return;
  410         }
cd = usbd_get_config_descriptor(sc->sc_udev);
  413         if (cd == NULL) {
printf("%s: could not get config descriptor\n",
sc->sc_dev.dv_xname);
  417                 return;
  418         }
sc->sc_alt_config = usbd_get_no_alts(cd, 1);
  422         /* set initial config */
err = ubt_set_isoc_config(sc);
  424         if (err) {
printf("%s: ISOC config failed\n",
sc->sc_dev.dv_xname);
  428                 return;
  429         }
  431         /* Attach HCI */
sc->sc_unit.hci_softc = self;
sc->sc_unit.hci_devname = sc->sc_dev.dv_xname;
sc->sc_unit.hci_enable = ubt_enable;
sc->sc_unit.hci_disable = ubt_disable;
sc->sc_unit.hci_start_cmd = ubt_xmit_cmd_start;
sc->sc_unit.hci_start_acl = ubt_xmit_acl_start;
sc->sc_unit.hci_start_sco = ubt_xmit_sco_start;
sc->sc_unit.hci_ipl = IPL_USB; /* XXX: IPL_SOFTUSB ?? */
hci_attach(&sc->sc_unit);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
  443                            &sc->sc_dev);
sc->sc_ok = 1;
  447         return;
  448 }
  450 int
ubt_detach(struct device *self, int flags)
  452 {
  453         struct ubt_softc *sc = (struct ubt_softc *)self;
  454         int s;
DPRINTF("sc=%p flags=%d\n", sc, flags);
sc->sc_dying = 1;
  460         if (!sc->sc_ok)
  461                 return 0;
  463         /* Detach HCI interface */
hci_detach(&sc->sc_unit);
  466         /*
  467          * Abort all pipes. Causes processes waiting for transfer to wake.
  468          *
  469          * Actually, hci_detach() above will call ubt_disable() which may
  470          * call ubt_abortdealloc(), but lets be sure since doing it twice
  471          * wont cause an error.
  472          */
ubt_abortdealloc(sc);
  475         /* wait for all processes to finish */
s = splusb();
  477         if (sc->sc_refcnt-- > 0)
usb_detach_wait(&sc->sc_dev);
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
  483                            &sc->sc_dev);
DPRINTFN(1, "driver detached\n");
  487         return 0;
  488 }
  490 int
ubt_activate(struct device *self, enum devact act)
  492 {
  493         struct ubt_softc *sc = (struct ubt_softc *)self;
  494         int error = 0;
DPRINTFN(1, "ubt_activate: sc=%p, act=%d\n", sc, act);
  498         switch (act) {
  499         case DVACT_ACTIVATE:
  500                 return EOPNOTSUPP;
  501                 break;
  503         case DVACT_DEACTIVATE:
sc->sc_dying = 1;
  505                 break;
  506         }
  507         return error;
  508 }
  510 /* set ISOC configuration */
  511 int
ubt_set_isoc_config(struct ubt_softc *sc)
  513 {
usb_endpoint_descriptor_t *ed;
  515         int rd_addr, wr_addr, rd_size, wr_size;
uint8_t count, i;
  517         int err;
err = usbd_set_interface(sc->sc_iface1, sc->sc_config);
  520         if (err != USBD_NORMAL_COMPLETION) {
printf(
  522                     "%s: Could not set config %d on ISOC interface. %s (%d)\n",
sc->sc_dev.dv_xname, sc->sc_config, usbd_errstr(err), err);
  525                 return err == USBD_IN_USE ? EBUSY : EIO;
  526         }
  528         /*
  529          * We wont get past the above if there are any pipes open, so no
  530          * need to worry about buf/xfer/pipe deallocation. If we get an
  531          * error after this, the frame quantities will be 0 and no SCO
  532          * data will be possible.
  533          */
sc->sc_scord_size = rd_size = 0;
sc->sc_scord_addr = rd_addr = -1;
sc->sc_scowr_size = wr_size = 0;
sc->sc_scowr_addr = wr_addr = -1;
count = 0;
  542         (void)usbd_endpoint_count(sc->sc_iface1, &count);
  544         for (i = 0 ; i < count ; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface1, i);
  546                 if (ed == NULL) {
printf("%s: could not read endpoint descriptor %d\n",
sc->sc_dev.dv_xname, i);
  550                         return EIO;
  551                 }
DPRINTFN(5, "%s: endpoint type %02x (%02x) addr %02x (%s)\n",
sc->sc_dev.dv_xname,
UE_GET_XFERTYPE(ed->bmAttributes),
UE_GET_ISO_TYPE(ed->bmAttributes),
ed->bEndpointAddress,
UE_GET_DIR(ed->bEndpointAddress) ? "in" : "out");
  560                 if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS)
  561                         continue;
  563                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) {
rd_addr = ed->bEndpointAddress;
rd_size = UGETW(ed->wMaxPacketSize);
  566                 } else {
wr_addr = ed->bEndpointAddress;
wr_size = UGETW(ed->wMaxPacketSize);
  569                 }
  570         }
  572         if (rd_addr == -1) {
printf(
  574                     "%s: missing ISOC IN endpoint on interface config %d\n",
sc->sc_dev.dv_xname, sc->sc_config);
  577                 return ENOENT;
  578         }
  579         if (wr_addr == -1) {
printf(
  581                     "%s: missing ISOC OUT endpoint on interface config %d\n",
sc->sc_dev.dv_xname, sc->sc_config);
  584                 return ENOENT;
  585         }
  587 #ifdef DIAGNOSTIC
  588         if (rd_size > MLEN) {
printf("%s: rd_size=%d exceeds MLEN\n",
sc->sc_dev.dv_xname, rd_size);
  592                 return EOVERFLOW;
  593         }
  595         if (wr_size > MLEN) {
printf("%s: wr_size=%d exceeds MLEN\n",
sc->sc_dev.dv_xname, wr_size);
  599                 return EOVERFLOW;
  600         }
  601 #endif
sc->sc_scord_size = rd_size;
sc->sc_scord_addr = rd_addr;
sc->sc_scowr_size = wr_size;
sc->sc_scowr_addr = wr_addr;
  609         return 0;
  610 }
  612 void
ubt_abortdealloc(struct ubt_softc *sc)
  614 {
  615         int i;
DPRINTFN(1, "sc=%p\n", sc);
  619         /* Abort all pipes */
  620         if (sc->sc_evt_pipe != NULL) {
usbd_abort_pipe(sc->sc_evt_pipe);
usbd_close_pipe(sc->sc_evt_pipe);
sc->sc_evt_pipe = NULL;
  624         }
  626         if (sc->sc_aclrd_pipe != NULL) {
usbd_abort_pipe(sc->sc_aclrd_pipe);
usbd_close_pipe(sc->sc_aclrd_pipe);
sc->sc_aclrd_pipe = NULL;
  630         }
  632         if (sc->sc_aclwr_pipe != NULL) {
usbd_abort_pipe(sc->sc_aclwr_pipe);
usbd_close_pipe(sc->sc_aclwr_pipe);
sc->sc_aclwr_pipe = NULL;
  636         }
  638         if (sc->sc_scord_pipe != NULL) {
usbd_abort_pipe(sc->sc_scord_pipe);
usbd_close_pipe(sc->sc_scord_pipe);
sc->sc_scord_pipe = NULL;
  642         }
  644         if (sc->sc_scowr_pipe != NULL) {
usbd_abort_pipe(sc->sc_scowr_pipe);
usbd_close_pipe(sc->sc_scowr_pipe);
sc->sc_scowr_pipe = NULL;
  648         }
  650         /* Free event buffer */
  651         if (sc->sc_evt_buf != NULL) {
free(sc->sc_evt_buf, M_USBDEV);
sc->sc_evt_buf = NULL;
  654         }
  656         /* Free all xfers and xfer buffers (implicit) */
  657         if (sc->sc_cmd_xfer != NULL) {
usbd_free_xfer(sc->sc_cmd_xfer);
sc->sc_cmd_xfer = NULL;
sc->sc_cmd_buf = NULL;
  661         }
  663         if (sc->sc_aclrd_xfer != NULL) {
usbd_free_xfer(sc->sc_aclrd_xfer);
sc->sc_aclrd_xfer = NULL;
sc->sc_aclrd_buf = NULL;
  667         }
  669         if (sc->sc_aclwr_xfer != NULL) {
usbd_free_xfer(sc->sc_aclwr_xfer);
sc->sc_aclwr_xfer = NULL;
sc->sc_aclwr_buf = NULL;
  673         }
  675         for (i = 0 ; i < UBT_NXFERS ; i++) {
  676                 if (sc->sc_scord[i].xfer != NULL) {
usbd_free_xfer(sc->sc_scord[i].xfer);
sc->sc_scord[i].xfer = NULL;
sc->sc_scord[i].buf = NULL;
  680                 }
  682                 if (sc->sc_scowr[i].xfer != NULL) {
usbd_free_xfer(sc->sc_scowr[i].xfer);
sc->sc_scowr[i].xfer = NULL;
sc->sc_scowr[i].buf = NULL;
  686                 }
  687         }
  689         /* Free partial SCO packets */
  690         if (sc->sc_scord_mbuf != NULL) {
m_freem(sc->sc_scord_mbuf);
sc->sc_scord_mbuf = NULL;
  693         }
  695         if (sc->sc_scowr_mbuf != NULL) {
m_freem(sc->sc_scowr_mbuf);
sc->sc_scowr_mbuf = NULL;
  698         }
  699 }
  701 /*******************************************************************************
  702  *
  703  * Bluetooth Unit/USB callbacks
  704  *
  705  * All of this will be called at the IPL_ we specified above
  706  */
  707 int
ubt_enable(struct hci_unit *unit)
  709 {
  710         struct ubt_softc *sc = (struct ubt_softc *)unit->hci_softc;
usbd_status err;
  712         int i, error;
DPRINTFN(1, "sc=%p\n", sc);
  716         if (unit->hci_flags & BTF_RUNNING)
  717                 return 0;
  719         /* Events */
sc->sc_evt_buf = malloc(UBT_BUFSIZ_EVENT, M_USBDEV, M_NOWAIT);
  721         if (sc->sc_evt_buf == NULL) {
error = ENOMEM;
  723                 goto bad;
  724         }
err = usbd_open_pipe_intr(sc->sc_iface0,
sc->sc_evt_addr,
USBD_SHORT_XFER_OK,
  728                                   &sc->sc_evt_pipe,
sc,
sc->sc_evt_buf,
UBT_BUFSIZ_EVENT,
ubt_recv_event,
USBD_DEFAULT_INTERVAL);
  734         if (err != USBD_NORMAL_COMPLETION) {
error = EIO;
  736                 goto bad;
  737         }
  739         /* Commands */
sc->sc_cmd_xfer = usbd_alloc_xfer(sc->sc_udev);
  741         if (sc->sc_cmd_xfer == NULL) {
error = ENOMEM;
  743                 goto bad;
  744         }
sc->sc_cmd_buf = usbd_alloc_buffer(sc->sc_cmd_xfer, UBT_BUFSIZ_CMD);
  746         if (sc->sc_cmd_buf == NULL) {
error = ENOMEM;
  748                 goto bad;
  749         }
  751         /* ACL read */
err = usbd_open_pipe(sc->sc_iface0, sc->sc_aclrd_addr,
USBD_EXCLUSIVE_USE, &sc->sc_aclrd_pipe);
  754         if (err != USBD_NORMAL_COMPLETION) {
error = EIO;
  756                 goto bad;
  757         }
sc->sc_aclrd_xfer = usbd_alloc_xfer(sc->sc_udev);
  759         if (sc->sc_aclrd_xfer == NULL) {
error = ENOMEM;
  761                 goto bad;
  762         }
sc->sc_aclrd_buf = usbd_alloc_buffer(sc->sc_aclrd_xfer, UBT_BUFSIZ_ACL);
  764         if (sc->sc_aclrd_buf == NULL) {
error = ENOMEM;
  766                 goto bad;
  767         }
sc->sc_aclrd_busy = 0;
ubt_recv_acl_start(sc);
  771         /* ACL write */
err = usbd_open_pipe(sc->sc_iface0, sc->sc_aclwr_addr,
USBD_EXCLUSIVE_USE, &sc->sc_aclwr_pipe);
  774         if (err != USBD_NORMAL_COMPLETION) {
error = EIO;
  776                 goto bad;
  777         }
sc->sc_aclwr_xfer = usbd_alloc_xfer(sc->sc_udev);
  779         if (sc->sc_aclwr_xfer == NULL) {
error = ENOMEM;
  781                 goto bad;
  782         }
sc->sc_aclwr_buf = usbd_alloc_buffer(sc->sc_aclwr_xfer, UBT_BUFSIZ_ACL);
  784         if (sc->sc_aclwr_buf == NULL) {
error = ENOMEM;
  786                 goto bad;
  787         }
  789         /* SCO read */
  790         if (sc->sc_scord_size > 0) {
err = usbd_open_pipe(sc->sc_iface1, sc->sc_scord_addr,
USBD_EXCLUSIVE_USE, &sc->sc_scord_pipe);
  793                 if (err != USBD_NORMAL_COMPLETION) {
error = EIO;
  795                         goto bad;
  796                 }
  798                 for (i = 0 ; i < UBT_NXFERS ; i++) {
sc->sc_scord[i].xfer = usbd_alloc_xfer(sc->sc_udev);
  800                         if (sc->sc_scord[i].xfer == NULL) {
error = ENOMEM;
  802                                 goto bad;
  803                         }
sc->sc_scord[i].buf = usbd_alloc_buffer(sc->sc_scord[i].xfer,
sc->sc_scord_size * UBT_NFRAMES);
  806                         if (sc->sc_scord[i].buf == NULL) {
error = ENOMEM;
  808                                 goto bad;
  809                         }
sc->sc_scord[i].softc = sc;
sc->sc_scord[i].busy = 0;
ubt_recv_sco_start1(sc, &sc->sc_scord[i]);
  813                 }
  814         }
  816         /* SCO write */
  817         if (sc->sc_scowr_size > 0) {
err = usbd_open_pipe(sc->sc_iface1, sc->sc_scowr_addr,
USBD_EXCLUSIVE_USE, &sc->sc_scowr_pipe);
  820                 if (err != USBD_NORMAL_COMPLETION) {
error = EIO;
  822                         goto bad;
  823                 }
  825                 for (i = 0 ; i < UBT_NXFERS ; i++) {
sc->sc_scowr[i].xfer = usbd_alloc_xfer(sc->sc_udev);
  827                         if (sc->sc_scowr[i].xfer == NULL) {
error = ENOMEM;
  829                                 goto bad;
  830                         }
sc->sc_scowr[i].buf = usbd_alloc_buffer(sc->sc_scowr[i].xfer,
sc->sc_scowr_size * UBT_NFRAMES);
  833                         if (sc->sc_scowr[i].buf == NULL) {
error = ENOMEM;
  835                                 goto bad;
  836                         }
sc->sc_scowr[i].softc = sc;
sc->sc_scowr[i].busy = 0;
  839                 }
  840         }
unit->hci_flags &= ~BTF_XMIT;
unit->hci_flags |= BTF_RUNNING;
  844         return 0;
bad:
ubt_abortdealloc(sc);
  848         return error;
  849 }
  851 void
ubt_disable(struct hci_unit *unit)
  853 {
  854         struct ubt_softc *sc = (struct ubt_softc *)unit->hci_softc;
DPRINTFN(1, "sc=%p\n", sc);
  858         if ((unit->hci_flags & BTF_RUNNING) == 0)
  859                 return;
ubt_abortdealloc(sc);
unit->hci_flags &= ~BTF_RUNNING;
  864 }
  866 void
ubt_xmit_cmd_start(struct hci_unit *unit)
  868 {
  869         struct ubt_softc *sc = (struct ubt_softc *)unit->hci_softc;
usb_device_request_t req;
usbd_status status;
  872         struct mbuf *m;
  873         int len;
  875         if (sc->sc_dying)
  876                 return;
  878         if (IF_IS_EMPTY(&unit->hci_cmdq))
  879                 return;
IF_DEQUEUE(&unit->hci_cmdq, m);
DPRINTFN(15, "%s: xmit CMD packet (%d bytes)\n",
unit->hci_devname, m->m_pkthdr.len);
sc->sc_refcnt++;
unit->hci_flags |= BTF_XMIT_CMD;
len = m->m_pkthdr.len - 1;
m_copydata(m, 1, len, sc->sc_cmd_buf);
m_freem(m);
memset(&req, 0, sizeof(req));
req.bmRequestType = UT_WRITE_CLASS_DEVICE;
USETW(req.wLength, len);
usbd_setup_default_xfer(sc->sc_cmd_xfer,
sc->sc_udev,
unit,
UBT_CMD_TIMEOUT,
  901                                 &req,
sc->sc_cmd_buf,
len,
USBD_NO_COPY | USBD_FORCE_SHORT_XFER,
ubt_xmit_cmd_complete);
status = usbd_transfer(sc->sc_cmd_xfer);
KASSERT(status != USBD_NORMAL_COMPLETION);
  911         if (status != USBD_IN_PROGRESS) {
DPRINTF("usbd_transfer status=%s (%d)\n",
usbd_errstr(status), status);
sc->sc_refcnt--;
unit->hci_flags &= ~BTF_XMIT_CMD;
  917         }
  918 }
  920 void
ubt_xmit_cmd_complete(usbd_xfer_handle xfer,
usbd_private_handle h, usbd_status status)
  923 {
  924         struct hci_unit *unit = h;
  925         struct ubt_softc *sc = (struct ubt_softc *)unit->hci_softc;
uint32_t count;
DPRINTFN(15, "%s: CMD complete status=%s (%d)\n",
unit->hci_devname, usbd_errstr(status), status);
unit->hci_flags &= ~BTF_XMIT_CMD;
  933         if (--sc->sc_refcnt < 0) {
DPRINTF("sc_refcnt=%d\n", sc->sc_refcnt);
usb_detach_wakeup(&sc->sc_dev);
  936                 return;
  937         }
  939         if (sc->sc_dying) {
DPRINTF("sc_dying\n");
  941                 return;
  942         }
  944         if (status != USBD_NORMAL_COMPLETION) {
DPRINTF("status=%s (%d)\n",
usbd_errstr(status), status);
unit->hci_stats.err_tx++;
  949                 return;
  950         }
usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
unit->hci_stats.cmd_tx++;
unit->hci_stats.byte_tx += count;
ubt_xmit_cmd_start(unit);
  957 }
  959 void
ubt_xmit_acl_start(struct hci_unit *unit)
  961 {
  962         struct ubt_softc *sc = (struct ubt_softc *)unit->hci_softc;
  963         struct mbuf *m;
usbd_status status;
  965         int len;
  967         if (sc->sc_dying)
  968                 return;
  970         if (IF_IS_EMPTY(&unit->hci_acltxq) == NULL)
  971                 return;
sc->sc_refcnt++;
unit->hci_flags |= BTF_XMIT_ACL;
IF_DEQUEUE(&unit->hci_acltxq, m);
DPRINTFN(15, "%s: xmit ACL packet (%d bytes)\n",
unit->hci_devname, m->m_pkthdr.len);
len = m->m_pkthdr.len - 1;
  982         if (len > UBT_BUFSIZ_ACL) {
DPRINTF("%s: truncating ACL packet (%d => %d)!\n",
unit->hci_devname, len, UBT_BUFSIZ_ACL);
len = UBT_BUFSIZ_ACL;
  987         }
m_copydata(m, 1, len, sc->sc_aclwr_buf);
m_freem(m);
unit->hci_stats.acl_tx++;
unit->hci_stats.byte_tx += len;
usbd_setup_xfer(sc->sc_aclwr_xfer,
sc->sc_aclwr_pipe,
unit,
sc->sc_aclwr_buf,
len,
USBD_NO_COPY | USBD_FORCE_SHORT_XFER,
UBT_ACL_TIMEOUT,
ubt_xmit_acl_complete);
status = usbd_transfer(sc->sc_aclwr_xfer);
KASSERT(status != USBD_NORMAL_COMPLETION);
 1008         if (status != USBD_IN_PROGRESS) {
DPRINTF("usbd_transfer status=%s (%d)\n",
usbd_errstr(status), status);
sc->sc_refcnt--;
unit->hci_flags &= ~BTF_XMIT_ACL;
 1014         }
 1015 }
 1017 void
ubt_xmit_acl_complete(usbd_xfer_handle xfer,
usbd_private_handle h, usbd_status status)
 1020 {
 1021         struct hci_unit *unit = h;
 1022         struct ubt_softc *sc = (struct ubt_softc *)unit->hci_softc;
DPRINTFN(15, "%s: ACL complete status=%s (%d)\n",
unit->hci_devname, usbd_errstr(status), status);
unit->hci_flags &= ~BTF_XMIT_ACL;
 1029         if (--sc->sc_refcnt < 0) {
usb_detach_wakeup(&sc->sc_dev);
 1031                 return;
 1032         }
 1034         if (sc->sc_dying)
 1035                 return;
 1037         if (status != USBD_NORMAL_COMPLETION) {
DPRINTF("status=%s (%d)\n",
usbd_errstr(status), status);
unit->hci_stats.err_tx++;
 1043                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->sc_aclwr_pipe);
 1045                 else
 1046                         return;
 1047         }
ubt_xmit_acl_start(unit);
 1050 }
 1052 void
ubt_xmit_sco_start(struct hci_unit *unit)
 1054 {
 1055         struct ubt_softc *sc = (struct ubt_softc *)unit->hci_softc;
 1056         int i;
 1058         if (sc->sc_dying || sc->sc_scowr_size == 0)
 1059                 return;
 1061         for (i = 0 ; i < UBT_NXFERS ; i++) {
 1062                 if (sc->sc_scowr[i].busy)
 1063                         continue;
ubt_xmit_sco_start1(sc, &sc->sc_scowr[i]);
 1066         }
 1067 }
 1069 void
ubt_xmit_sco_start1(struct ubt_softc *sc, struct ubt_isoc_xfer *isoc)
 1071 {
 1072         struct mbuf *m;
uint8_t *buf;
 1074         int num, len, size, space;
space = sc->sc_scowr_size * UBT_NFRAMES;
buf = isoc->buf;
len = 0;
 1080         /*
 1081          * Fill the request buffer with data from the queue,
 1082          * keeping any leftover packet on our private hook.
 1083          *
 1084          * Complete packets are passed back up to the stack
 1085          * for disposal, since we can't rely on the controller
 1086          * to tell us when it has finished with them.
 1087          */
m = sc->sc_scowr_mbuf;
 1090         while (space > 0) {
 1091                 if (m == NULL) {
IF_DEQUEUE(&sc->sc_unit.hci_scotxq, m);
 1093                         if (m == NULL)
 1094                                 break;
m_adj(m, 1);    /* packet type */
 1097                 }
 1099                 if (m->m_pkthdr.len > 0) {
size = MIN(m->m_pkthdr.len, space);
m_copydata(m, 0, size, buf);
m_adj(m, size);
buf += size;
len += size;
space -= size;
 1108                 }
 1110                 if (m->m_pkthdr.len == 0) {
sc->sc_unit.hci_stats.sco_tx++;
hci_complete_sco(&sc->sc_unit, m);
m = NULL;
 1114                 }
 1115         }
sc->sc_scowr_mbuf = m;
DPRINTFN(15, "isoc=%p, len=%d, space=%d\n", isoc, len, space);
 1120         if (len == 0)   /* nothing to send */
 1121                 return;
sc->sc_refcnt++;
sc->sc_unit.hci_flags |= BTF_XMIT_SCO;
sc->sc_unit.hci_stats.byte_tx += len;
isoc->busy = 1;
 1128         /*
 1129          * calculate number of isoc frames and sizes
 1130          */
 1132         for (num = 0 ; len > 0 ; num++) {
size = MIN(sc->sc_scowr_size, len);
isoc->size[num] = size;
len -= size;
 1137         }
usbd_setup_isoc_xfer(isoc->xfer,
sc->sc_scowr_pipe,
isoc,
isoc->size,
num,
USBD_NO_COPY | USBD_FORCE_SHORT_XFER,
ubt_xmit_sco_complete);
usbd_transfer(isoc->xfer);
 1148 }
 1150 void
ubt_xmit_sco_complete(usbd_xfer_handle xfer,
usbd_private_handle h, usbd_status status)
 1153 {
 1154         struct ubt_isoc_xfer *isoc = h;
 1155         struct ubt_softc *sc;
 1156         int i;
KASSERT(xfer == isoc->xfer);
sc = isoc->softc;
DPRINTFN(15, "isoc=%p, status=%s (%d)\n",
isoc, usbd_errstr(status), status);
isoc->busy = 0;
 1166         for (i = 0 ; ; i++) {
 1167                 if (i == UBT_NXFERS) {
sc->sc_unit.hci_flags &= ~BTF_XMIT_SCO;
 1169                         break;
 1170                 }
 1172                 if (sc->sc_scowr[i].busy)
 1173                         break;
 1174         }
 1176         if (--sc->sc_refcnt < 0) {
usb_detach_wakeup(&sc->sc_dev);
 1178                 return;
 1179         }
 1181         if (sc->sc_dying)
 1182                 return;
 1184         if (status != USBD_NORMAL_COMPLETION) {
DPRINTF("status=%s (%d)\n",
usbd_errstr(status), status);
sc->sc_unit.hci_stats.err_tx++;
 1190                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->sc_scowr_pipe);
 1192                 else
 1193                         return;
 1194         }
ubt_xmit_sco_start(&sc->sc_unit);
 1197 }
 1199 /*
 1200  * load incoming data into an mbuf with
 1201  * leading type byte
 1202  */
 1203 static struct mbuf *
ubt_mbufload(uint8_t *buf, int count, uint8_t type)
 1205 {
 1206         struct mbuf *m;
MGETHDR(m, M_DONTWAIT, MT_DATA);
 1209         if (m == NULL)
 1210                 return NULL;
 1212         *mtod(m, uint8_t *) = type;
m->m_pkthdr.len = m->m_len = MHLEN;
m_copyback(m, 1, count, buf);   // (extends if necessary)
 1215         if (m->m_pkthdr.len != MAX(MHLEN, count + 1)) {
m_free(m);
 1217                 return NULL;
 1218         }
m->m_pkthdr.len = count + 1;
m->m_len = MIN(MHLEN, m->m_pkthdr.len);
 1223         return m;
 1224 }
 1226 void
ubt_recv_event(usbd_xfer_handle xfer, usbd_private_handle h, usbd_status status)
 1228 {
 1229         struct ubt_softc *sc = h;
 1230         struct mbuf *m;
uint32_t count;
 1232         void *buf;
DPRINTFN(15, "sc=%p status=%s (%d)\n",
sc, usbd_errstr(status), status);
 1237         if (status != USBD_NORMAL_COMPLETION || sc->sc_dying)
 1238                 return;
usbd_get_xfer_status(xfer, NULL, &buf, &count, NULL);
 1242         if (count < sizeof(hci_event_hdr_t) - 1) {
DPRINTF("dumped undersized event (count = %d)\n", count);
sc->sc_unit.hci_stats.err_rx++;
 1245                 return;
 1246         }
sc->sc_unit.hci_stats.evt_rx++;
sc->sc_unit.hci_stats.byte_rx += count;
m = ubt_mbufload(buf, count, HCI_EVENT_PKT);
 1252         if (m != NULL)
hci_input_event(&sc->sc_unit, m);
 1254         else
sc->sc_unit.hci_stats.err_rx++;
 1256 }
 1258 void
ubt_recv_acl_start(struct ubt_softc *sc)
 1260 {
usbd_status status;
DPRINTFN(15, "sc=%p\n", sc);
 1265         if (sc->sc_aclrd_busy || sc->sc_dying) {
DPRINTF("sc_aclrd_busy=%d, sc_dying=%d\n",
sc->sc_aclrd_busy,
sc->sc_dying);
 1270                 return;
 1271         }
sc->sc_refcnt++;
sc->sc_aclrd_busy = 1;
usbd_setup_xfer(sc->sc_aclrd_xfer,
sc->sc_aclrd_pipe,
sc,
sc->sc_aclrd_buf,
UBT_BUFSIZ_ACL,
USBD_NO_COPY | USBD_SHORT_XFER_OK,
USBD_NO_TIMEOUT,
ubt_recv_acl_complete);
status = usbd_transfer(sc->sc_aclrd_xfer);
KASSERT(status != USBD_NORMAL_COMPLETION);
 1289         if (status != USBD_IN_PROGRESS) {
DPRINTF("usbd_transfer status=%s (%d)\n",
usbd_errstr(status), status);
sc->sc_refcnt--;
sc->sc_aclrd_busy = 0;
 1295         }
 1296 }
 1298 void
ubt_recv_acl_complete(usbd_xfer_handle xfer,
usbd_private_handle h, usbd_status status)
 1301 {
 1302         struct ubt_softc *sc = h;
 1303         struct mbuf *m;
uint32_t count;
 1305         void *buf;
DPRINTFN(15, "sc=%p status=%s (%d)\n",
sc, usbd_errstr(status), status);
sc->sc_aclrd_busy = 0;
 1312         if (--sc->sc_refcnt < 0) {
DPRINTF("refcnt = %d\n", sc->sc_refcnt);
usb_detach_wakeup(&sc->sc_dev);
 1315                 return;
 1316         }
 1318         if (sc->sc_dying) {
DPRINTF("sc_dying\n");
 1320                 return;
 1321         }
 1323         if (status != USBD_NORMAL_COMPLETION) {
DPRINTF("status=%s (%d)\n",
usbd_errstr(status), status);
sc->sc_unit.hci_stats.err_rx++;
 1329                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->sc_aclrd_pipe);
 1331                 else
 1332                         return;
 1333         } else {
usbd_get_xfer_status(xfer, NULL, &buf, &count, NULL);
 1336                 if (count < sizeof(hci_acldata_hdr_t) - 1) {
DPRINTF("dumped undersized packet (%d)\n", count);
sc->sc_unit.hci_stats.err_rx++;
 1339                 } else {
sc->sc_unit.hci_stats.acl_rx++;
sc->sc_unit.hci_stats.byte_rx += count;
m = ubt_mbufload(buf, count, HCI_ACL_DATA_PKT);
 1344                         if (m != NULL)
hci_input_acl(&sc->sc_unit, m);
 1346                         else
sc->sc_unit.hci_stats.err_rx++;
 1348                 }
 1349         }
 1351         /* and restart */
ubt_recv_acl_start(sc);
 1353 }
 1355 void
ubt_recv_sco_start1(struct ubt_softc *sc, struct ubt_isoc_xfer *isoc)
 1357 {
 1358         int i;
DPRINTFN(15, "sc=%p, isoc=%p\n", sc, isoc);
 1362         if (isoc->busy || sc->sc_dying || sc->sc_scord_size == 0) {
DPRINTF("%s%s%s\n",
isoc->busy ? " busy" : "",
sc->sc_dying ? " dying" : "",
sc->sc_scord_size == 0 ? " size=0" : "");
 1368                 return;
 1369         }
sc->sc_refcnt++;
isoc->busy = 1;
 1374         for (i = 0 ; i < UBT_NFRAMES ; i++)
isoc->size[i] = sc->sc_scord_size;
usbd_setup_isoc_xfer(isoc->xfer,
sc->sc_scord_pipe,
isoc,
isoc->size,
UBT_NFRAMES,
USBD_NO_COPY | USBD_SHORT_XFER_OK,
ubt_recv_sco_complete);
usbd_transfer(isoc->xfer);
 1386 }
 1388 void
ubt_recv_sco_complete(usbd_xfer_handle xfer,
usbd_private_handle h, usbd_status status)
 1391 {
 1392         struct ubt_isoc_xfer *isoc = h;
 1393         struct ubt_softc *sc;
 1394         struct mbuf *m;
uint32_t count;
uint8_t *ptr, *frame;
 1397         int i, size, got, want;
KASSERT(isoc != NULL);
KASSERT(isoc->xfer == xfer);
sc = isoc->softc;
isoc->busy = 0;
 1405         if (--sc->sc_refcnt < 0) {
DPRINTF("refcnt=%d\n", sc->sc_refcnt);
usb_detach_wakeup(&sc->sc_dev);
 1408                 return;
 1409         }
 1411         if (sc->sc_dying) {
DPRINTF("sc_dying\n");
 1413                 return;
 1414         }
 1416         if (status != USBD_NORMAL_COMPLETION) {
DPRINTF("status=%s (%d)\n",
usbd_errstr(status), status);
sc->sc_unit.hci_stats.err_rx++;
 1422                 if (status == USBD_STALLED) {
usbd_clear_endpoint_stall_async(sc->sc_scord_pipe);
 1424                         goto restart;
 1425                 }
 1427                 return;
 1428         }
usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
 1431         if (count == 0)
 1432                 goto restart;
DPRINTFN(15, "sc=%p, isoc=%p, count=%u\n",
sc, isoc, count);
sc->sc_unit.hci_stats.byte_rx += count;
 1439         /*
 1440          * Extract SCO packets from ISOC frames. The way we have it,
 1441          * no SCO packet can be bigger than MHLEN. This is unlikely
 1442          * to actually happen, but if we ran out of mbufs and lost
 1443          * sync then we may get spurious data that makes it seem that
 1444          * way, so we discard data that wont fit. This doesnt really
 1445          * help with the lost sync situation alas.
 1446          */
m = sc->sc_scord_mbuf;
 1449         if (m != NULL) {
sc->sc_scord_mbuf = NULL;
ptr = mtod(m, uint8_t *) + m->m_pkthdr.len;
got = m->m_pkthdr.len;
want = sizeof(hci_scodata_hdr_t);
 1454                 if (got >= want)
want += mtod(m, hci_scodata_hdr_t *)->length ;
 1456         } else {
ptr = NULL;
got = 0;
want = 0;
 1460         }
 1462         for (i = 0 ; i < UBT_NFRAMES ; i++) {
frame = isoc->buf + (i * sc->sc_scord_size);
 1465                 while (isoc->size[i] > 0) {
size = isoc->size[i];
 1468                         if (m == NULL) {
MGETHDR(m, M_DONTWAIT, MT_DATA);
 1470                                 if (m == NULL) {
printf("%s: out of memory (xfer halted)\n",
sc->sc_dev.dv_xname);
sc->sc_unit.hci_stats.err_rx++;
 1475                                         return;         /* lost sync */
 1476                                 }
ptr = mtod(m, uint8_t *);
 1479                                 *ptr++ = HCI_SCO_DATA_PKT;
got = 1;
want = sizeof(hci_scodata_hdr_t);
 1482                         }
 1484                         if (got + size > want)
size = want - got;
 1487                         if (got + size > MHLEN)
memcpy(ptr, frame, MHLEN - got);
 1489                         else
memcpy(ptr, frame, size);
ptr += size;
got += size;
frame += size;
 1496                         if (got == want) {
 1497                                 /*
 1498                                  * If we only got a header, add the packet
 1499                                  * length to our want count. Send complete
 1500                                  * packets up to protocol stack.
 1501                                  */
 1502                                 if (want == sizeof(hci_scodata_hdr_t))
want += mtod(m, hci_scodata_hdr_t *)->length;
 1505                                 if (got == want) {
m->m_pkthdr.len = m->m_len = got;
sc->sc_unit.hci_stats.sco_rx++;
hci_input_sco(&sc->sc_unit, m);
m = NULL;
 1510                                 }
 1511                         }
isoc->size[i] -= size;
 1514                 }
 1515         }
 1517         if (m != NULL) {
m->m_pkthdr.len = m->m_len = got;
sc->sc_scord_mbuf = m;
 1520         }
restart: /* and restart */
ubt_recv_sco_start1(sc, isoc);
 1524 }