root/dev/usb/usbf_subr.c

DEFINITIONS

1. usbf_errstr
2. usbf_realloc
3. usbf_probe_and_attach
4. usbf_remove_device
5. usbf_new_device
6. usbf_devinfo_setup
7. usbf_devinfo_alloc
8. usbf_devinfo_free
9. usbf_add_string
10. usbf_string_descriptor
11. usbf_get_string
12. usbf_add_config
13. usbf_add_config_desc
14. usbf_add_interface
15. usbf_add_endpoint
16. usbf_end_config
17. usbf_device_descriptor
18. usbf_config_descriptor
19. usbf_interface_number
20. usbf_endpoint_address
21. usbf_endpoint_attributes
22. usbf_open_pipe
23. usbf_open_pipe_ival
24. usbf_setup_pipe
25. usbf_abort_pipe
26. usbf_close_pipe
27. usbf_stall_pipe
28. usbf_iface_endpoint
29. usbf_config_endpoint
30. usbf_set_endpoint_halt
31. usbf_clear_endpoint_halt
32. usbf_set_endpoint_feature
33. usbf_clear_endpoint_feature
34. usbf_alloc_xfer
35. usbf_free_xfer
36. usbf_allocmem
37. usbf_freemem
38. usbf_alloc_buffer
39. usbf_free_buffer
40. usbf_dump_buffer
41. usbf_setup_xfer
42. usbf_setup_default_xfer
43. usbf_get_xfer_status
44. usbf_transfer
45. usbf_insert_transfer
46. usbf_start_next
47. usbf_transfer_complete
48. usbf_softintr_establish
49. usbf_schedsoftintr

    1 /*      $OpenBSD: usbf_subr.c,v 1.10 2007/07/27 09:16:09 mbalmer Exp $  */
    3 /*
    4  * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   19 /*
   20  * USB function driver interface subroutines
   21  */
   23 #include <sys/param.h>
   24 #include <sys/malloc.h>
   25 #include <sys/systm.h>
   26 #include <sys/timeout.h>
   28 #include <machine/bus.h>
   30 #include <dev/usb/usb.h>
   31 #include <dev/usb/usbdi.h>
   32 #include <dev/usb/usbdivar.h>
   33 #include <dev/usb/usb_mem.h>
   34 #include <dev/usb/usbf.h>
   35 #include <dev/usb/usbfvar.h>
   37 #ifndef USBF_DEBUG
   38 #define DPRINTF(l, x)   do {} while (0)
   39 #else
   40 extern int usbfdebug;
   41 #define DPRINTF(l, x)   if ((l) <= usbfdebug) printf x; else {}
   42 #endif
   44 void        *usbf_realloc(void **, size_t *, size_t);
size_t       usbf_get_string(usbf_device_handle, u_int8_t, char *, size_t);
usbf_status  usbf_open_pipe_ival(usbf_interface_handle, u_int8_t,
usbf_pipe_handle *, int);
usbf_status  usbf_setup_pipe(usbf_device_handle, usbf_interface_handle,
   49                              struct usbf_endpoint *, int,
usbf_pipe_handle *);
   51 void         usbf_start_next(usbf_pipe_handle);
   52 void         usbf_set_endpoint_halt(usbf_endpoint_handle);
   53 void         usbf_clear_endpoint_halt(usbf_endpoint_handle);
   55 static const char * const usbf_error_strs[] = USBF_ERROR_STRS;
   57 const char *
usbf_errstr(usbf_status err)
   59 {
   60         static char buffer[5];
   62         if (err < USBF_ERROR_MAX)
   63                 return usbf_error_strs[err];
snprintf(buffer, sizeof buffer, "%d", err);
   66         return buffer;
   67 }
   69 void *
usbf_realloc(void **pp, size_t *sizep, size_t newsize)
   71 {
   72         void *p;
size_t oldsize;
   75         if (newsize == 0) {
   76                 if (*sizep > 0)
free(*pp, M_USB);
   78                 *pp = NULL;
   79                 *sizep = 0;
   80                 return NULL;
   81         }
p = malloc(newsize, M_USB, M_NOWAIT);
   84         if (p == NULL)
   85                 return NULL;
oldsize = MIN(*sizep, newsize);
   88         if (oldsize > 0)
bcopy(*pp, p, oldsize);
   90         *pp = p;
   91         *sizep = newsize;
   92         return p;
   93 }
   95 /*
   96  * Attach a function driver.
   97  */
   98 static usbf_status
usbf_probe_and_attach(struct device *parent, usbf_device_handle dev, int port)
  100 {
  101         struct usbf_attach_arg uaa;
  102         struct device *dv;
KASSERT(dev->function == NULL);
bzero(&uaa, sizeof uaa);
uaa.device = dev;
  109         /*
  110          * The softc structure of a USB function driver must begin with a
  111          * "struct usbf_function" member (instead of USBBASEDEV), which must
  112          * be initialized in the function driver's attach routine.  Also, it
  113          * should use usbf_devinfo_setup() to set the device identification.
  114          */
dv = config_found_sm(parent, &uaa, NULL, NULL);
  116         if (dv != NULL) {
dev->function = (struct usbf_function *)dv;
  118                 return USBF_NORMAL_COMPLETION;
  119         }
  121         /*
  122          * We failed to attach a function driver for this device, but the
  123          * device can still function as a generic USB device without any
  124          * interfaces.
  125          */
  126         return USBF_NORMAL_COMPLETION;
  127 }
  129 static void
usbf_remove_device(usbf_device_handle dev, struct usbf_port *up)
  131 {
KASSERT(dev != NULL && dev == up->device);
  134         if (dev->function != NULL)
config_detach((struct device *)dev->function, DETACH_FORCE);
  136         if (dev->default_pipe != NULL)
usbf_close_pipe(dev->default_pipe);
up->device = NULL;
free(dev, M_USB);
  140 }
usbf_status
usbf_new_device(struct device *parent, usbf_bus_handle bus, int depth,
  144     int speed, int port, struct usbf_port *up)
  145 {
  146         struct usbf_device *dev;
usb_device_descriptor_t *ud;
usbf_status err;
  150 #ifdef DIAGNOSTIC
KASSERT(up->device == NULL);
  152 #endif
dev = malloc(sizeof(*dev), M_USB, M_NOWAIT);
  155         if (dev == NULL)
  156                 return USBF_NOMEM;
bzero(dev, sizeof *dev);
dev->bus = bus;
dev->string_id = USBF_STRING_ID_MIN;
SIMPLEQ_INIT(&dev->configs);
  163         /* Initialize device status. */
USETW(dev->status.wStatus, UDS_SELF_POWERED);
  166         /*
  167          * Initialize device descriptor.  The function driver for this
  168          * device (attached below) must complete the device descriptor.
  169          */
ud = &dev->ddesc;
ud->bLength = USB_DEVICE_DESCRIPTOR_SIZE;
ud->bDescriptorType = UDESC_DEVICE;
ud->bMaxPacketSize = bus->ep0_maxp;
  174         if (bus->usbrev >= USBREV_2_0)
USETW(ud->bcdUSB, UD_USB_2_0);
  176         else
USETW(ud->bcdUSB, 0x0101);
  179         /* Set up the default endpoint handle and descriptor. */
dev->def_ep.edesc = &dev->def_ep_desc;
dev->def_ep_desc.bLength = USB_ENDPOINT_DESCRIPTOR_SIZE;
dev->def_ep_desc.bDescriptorType = UDESC_ENDPOINT;
dev->def_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT;
dev->def_ep_desc.bmAttributes = UE_CONTROL;
USETW(dev->def_ep_desc.wMaxPacketSize, ud->bMaxPacketSize);
dev->def_ep_desc.bInterval = 0;
  188         /* Establish the default pipe. */
err = usbf_setup_pipe(dev, NULL, &dev->def_ep, 0,
  190             &dev->default_pipe);
  191         if (err) {
free(dev, M_USB);
  193                 return err;
  194         }
  196         /* Preallocate xfers for default pipe. */
dev->default_xfer = usbf_alloc_xfer(dev);
dev->data_xfer = usbf_alloc_xfer(dev);
  199         if (dev->default_xfer == NULL || dev->data_xfer == NULL) {
  200                 if (dev->default_xfer != NULL)
usbf_free_xfer(dev->default_xfer);
usbf_close_pipe(dev->default_pipe);
free(dev, M_USB);
  204                 return USBF_NOMEM;
  205         }
  207         /* Insert device request xfer. */
usbf_setup_default_xfer(dev->default_xfer, dev->default_pipe,
NULL, &dev->def_req, 0, 0, usbf_do_request);
err = usbf_transfer(dev->default_xfer);
  211         if (err && err != USBF_IN_PROGRESS) {
usbf_free_xfer(dev->default_xfer);
usbf_free_xfer(dev->data_xfer);
usbf_close_pipe(dev->default_pipe);
free(dev, M_USB);
  216                 return err;
  217         }
  219         /* Associate the upstream port with the device. */
bzero(up, sizeof *up);
up->portno = port;
up->device = dev;
  224         /* Attach function driver. */
err = usbf_probe_and_attach(parent, dev, port);
  226         if (err)
usbf_remove_device(dev, up);
  228         return err;
  229 }
  231 /*
  232  * Should be called by the function driver in its attach routine to change
  233  * the default device identification according to the particular function.
  234  */
  235 void
usbf_devinfo_setup(usbf_device_handle dev, u_int8_t devclass,
u_int8_t subclass, u_int8_t proto, u_int16_t vendor, u_int16_t product,
u_int16_t device, const char *manf, const char *prod, const char *ser)
  239 {
usb_device_descriptor_t *dd;
dd = usbf_device_descriptor(dev);
dd->bDeviceClass = devclass;
dd->bDeviceSubClass = subclass;
dd->bDeviceProtocol = proto;
  246         if (vendor != 0)
USETW(dd->idVendor, vendor);
  248         if (product != 0)
USETW(dd->idProduct, product);
  250         if (device != 0)
USETW(dd->bcdDevice, device);
  252         if (manf != NULL)
dd->iManufacturer = usbf_add_string(dev, manf);
  254         if (prod != NULL)
dd->iProduct = usbf_add_string(dev, prod);
  256         if (ser != NULL)
dd->iSerialNumber = usbf_add_string(dev, ser);
  258 }
  260 char *
usbf_devinfo_alloc(usbf_device_handle dev)
  262 {
  263         char manf[40];
  264         char prod[40];
usb_device_descriptor_t *dd;
size_t len;
  267         char *devinfo;
dd = usbf_device_descriptor(dev);
usbf_get_string(dev, dd->iManufacturer, manf, sizeof manf);
usbf_get_string(dev, dd->iProduct, prod, sizeof prod);
len = strlen(manf) + strlen(prod) + 32;
devinfo = malloc(len, M_USB, M_NOWAIT);
  275         if (devinfo == NULL)
  276                 return NULL;
snprintf(devinfo, len, "%s %s, rev %d.%02d/%d.%02d", manf, prod,
  279             (UGETW(dd->bcdUSB)>>8) & 0xff, UGETW(dd->bcdUSB) & 0xff,
  280             (UGETW(dd->bcdDevice)>>8) & 0xff, UGETW(dd->bcdDevice) & 0xff);
  281         return devinfo;
  282 }
  284 void
usbf_devinfo_free(char *devinfo)
  286 {
  287         if (devinfo != NULL)
free(devinfo, M_USB);
  289 }
  291 /*
  292  * Add a string descriptor to a logical device and return the string's id.
  293  *
  294  * If there is not enough memory available for the new string descriptor, or
  295  * if there is no unused string id left, return the id of the empty string
  296  * instead of failing.
  297  */
u_int8_t
usbf_add_string(usbf_device_handle dev, const char *string)
  300 {
usb_string_descriptor_t *sd;
size_t oldsize;
size_t newsize;
size_t len, i;
u_int8_t id;
  307         if (string == NULL || *string == '\0' ||
dev->string_id == USBF_STRING_ID_MAX)
  309                 return USBF_EMPTY_STRING_ID;
  311         if ((len = strlen(string)) >= USB_MAX_STRING_LEN)
len = USB_MAX_STRING_LEN - 1;
oldsize = dev->sdesc_size;
newsize = oldsize + 2 + 2 * len;
sd = usbf_realloc((void **)&dev->sdesc, &dev->sdesc_size,
newsize);
  319         if (sd == NULL)
  320                 return USBF_EMPTY_STRING_ID;
sd = (usb_string_descriptor_t *)((char *)sd + oldsize);
sd->bLength = newsize - oldsize;
sd->bDescriptorType = UDESC_STRING;
  325         for (i = 0; string[i] != '\0' && i < len; i++)
USETW(sd->bString[i], string[i]);
id = dev->string_id++;
  329         return id;
  330 }
usb_string_descriptor_t *
usbf_string_descriptor(usbf_device_handle dev, u_int8_t id)
  334 {
  335         static usb_string_descriptor_t sd0;
  336         static usb_string_descriptor_t sd1;
usb_string_descriptor_t *sd;
  339         /* handle the special string ids */
  340         switch (id) {
  341         case USB_LANGUAGE_TABLE:
sd0.bLength = 4;
sd0.bDescriptorType = UDESC_STRING;
USETW(sd0.bString[0], 0x0409 /* en_US */);
  345                 return &sd0;
  347         case USBF_EMPTY_STRING_ID:
sd1.bLength = 2;
sd1.bDescriptorType = UDESC_STRING;
  350                 return &sd0;
  351         }
  353         /* check if the string id is valid */
  354         if (id > dev->string_id)
  355                 return NULL;
  357         /* seek and return the descriptor of a non-empty string */
id -= USBF_STRING_ID_MIN;
sd = dev->sdesc;
  360         while (id-- > 0)
sd = (usb_string_descriptor_t *)((char *)sd + sd->bLength);
  362         return sd;
  363 }
size_t
usbf_get_string(usbf_device_handle dev, u_int8_t id, char *s, size_t size)
  367 {
usb_string_descriptor_t *sd = NULL;
size_t i, len;
  371         if (id != USB_LANGUAGE_TABLE)
sd = usbf_string_descriptor(dev, id);
  374         if (sd == NULL) {
  375                 if (size > 0)
  376                         *s = '\0';
  377                 return 0;
  378         }
len = (sd->bLength - 2) / 2;
  381         if (size < 1)
  382                 return len;
  384         for (i = 0; i < (size - 1) && i < len; i++)
s[i] = UGETW(sd->bString[i]) & 0xff;
s[i] = '\0';
  387         return len;
  388 }
  390 /*
  391  * Add a new device configuration to an existing USB logical device.
  392  * The new configuration initially has zero interfaces.
  393  */
usbf_status
usbf_add_config(usbf_device_handle dev, usbf_config_handle *ucp)
  396 {
  397         struct usbf_config *uc;
usb_config_descriptor_t *cd;
uc = malloc(sizeof *uc, M_USB, M_NOWAIT);
  401         if (uc == NULL)
  402                 return USBF_NOMEM;
cd = malloc(sizeof *cd, M_USB, M_NOWAIT);
  405         if (cd == NULL) {
free(uc, M_USB);
  407                 return USBF_NOMEM;
  408         }
bzero(uc, sizeof *uc);
uc->uc_device = dev;
uc->uc_cdesc = cd;
uc->uc_cdesc_size = sizeof *cd;
SIMPLEQ_INIT(&uc->iface_head);
bzero(cd, sizeof *cd);
cd->bLength = USB_CONFIG_DESCRIPTOR_SIZE;
cd->bDescriptorType = UDESC_CONFIG;
USETW(cd->wTotalLength, USB_CONFIG_DESCRIPTOR_SIZE);
cd->bConfigurationValue = USB_UNCONFIG_NO + 1 +
dev->ddesc.bNumConfigurations;
cd->iConfiguration = 0;
cd->bmAttributes = UC_BUS_POWERED | UC_SELF_POWERED;
  424 #if 0
cd->bMaxPower = 100 / UC_POWER_FACTOR; /* 100 mA */
  426 #else
cd->bMaxPower = 0; /* XXX 0 mA */
  428 #endif
SIMPLEQ_INSERT_TAIL(&dev->configs, uc, next);
dev->ddesc.bNumConfigurations++;
  433         if (ucp != NULL)
  434                 *ucp = uc;
  435         return USBF_NORMAL_COMPLETION;
  436 }
  438 /*
  439  * Allocate memory for a new descriptor at the end of the existing
  440  * device configuration descriptor.
  441  */
usbf_status
usbf_add_config_desc(usbf_config_handle uc, usb_descriptor_t *d,
usb_descriptor_t **dp)
  445 {
usb_config_descriptor_t *cd;
size_t oldsize;
size_t newsize;
oldsize = uc->uc_cdesc_size;
newsize = oldsize + d->bLength;
  452         if (d->bLength < sizeof(usb_descriptor_t) || newsize > 65535)
  453                 return USBF_INVAL;
cd = usbf_realloc((void **)&uc->uc_cdesc, &uc->uc_cdesc_size,
newsize);
  457         if (cd == NULL)
  458                 return USBF_NOMEM;
bcopy(d, (char *)cd + oldsize, d->bLength);
USETW(cd->wTotalLength, newsize);
  462         if (dp != NULL)
  463                 *dp = (usb_descriptor_t *)((char *)cd + oldsize);
  464         return USBF_NORMAL_COMPLETION;
  465 }
usbf_status
usbf_add_interface(usbf_config_handle uc, u_int8_t bInterfaceClass,
u_int8_t bInterfaceSubClass, u_int8_t bInterfaceProtocol,
  470     const char *string, usbf_interface_handle *uip)
  471 {
  472         struct usbf_interface *ui;
usb_interface_descriptor_t *id;
  475         if (uc->uc_closed)
  476                 return USBF_INVAL;
ui = malloc(sizeof *ui, M_USB, M_NOWAIT);
  479         if (ui == NULL)
  480                 return USBF_NOMEM;
id = malloc(sizeof *id, M_USB, M_NOWAIT);
  483         if (id == NULL) {
free(ui, M_USB);
  485                 return USBF_NOMEM;
  486         }
bzero(ui, sizeof *ui);
ui->config = uc;
ui->idesc = id;
LIST_INIT(&ui->pipes);
SIMPLEQ_INIT(&ui->endpoint_head);
bzero(id, sizeof *id);
id->bLength = USB_INTERFACE_DESCRIPTOR_SIZE;
id->bDescriptorType = UDESC_INTERFACE;
id->bInterfaceNumber = uc->uc_cdesc->bNumInterface;
id->bInterfaceClass = bInterfaceClass;
id->bInterfaceSubClass = bInterfaceSubClass;
id->bInterfaceProtocol = bInterfaceProtocol;
id->iInterface = 0; /*usbf_add_string(uc->uc_device, string);*/ /* XXX */
SIMPLEQ_INSERT_TAIL(&uc->iface_head, ui, next);
uc->uc_cdesc->bNumInterface++;
  506         *uip = ui;
  507         return USBF_NORMAL_COMPLETION;
  508 }
usbf_status
usbf_add_endpoint(usbf_interface_handle ui, u_int8_t bEndpointAddress,
u_int8_t bmAttributes, u_int16_t wMaxPacketSize, u_int8_t bInterval,
usbf_endpoint_handle *uep)
  514 {
  515         struct usbf_endpoint *ue;
usb_endpoint_descriptor_t *ed;
  518         if (ui->config->uc_closed)
  519                 return USBF_INVAL;
ue = malloc(sizeof *ue, M_USB, M_NOWAIT);
  522         if (ue == NULL)
  523                 return USBF_NOMEM;
ed = malloc(sizeof *ed, M_USB, M_NOWAIT);
  526         if (ed == NULL) {
free(ue, M_USB);
  528                 return USBF_NOMEM;
  529         }
bzero(ue, sizeof *ue);
ue->iface = ui;
ue->edesc = ed;
bzero(ed, sizeof *ed);
ed->bLength = USB_ENDPOINT_DESCRIPTOR_SIZE;
ed->bDescriptorType = UDESC_ENDPOINT;
ed->bEndpointAddress = bEndpointAddress;
ed->bmAttributes = bmAttributes;
USETW(ed->wMaxPacketSize, wMaxPacketSize);
ed->bInterval = bInterval;
SIMPLEQ_INSERT_TAIL(&ui->endpoint_head, ue, next);
ui->idesc->bNumEndpoints++;
  546         *uep = ue;
  547         return USBF_NORMAL_COMPLETION;
  548 }
  550 /*
  551  * Close the configuration, thereby combining all descriptors and creating
  552  * the real USB configuration descriptor that can be sent to the USB host.
  553  */
usbf_status
usbf_end_config(usbf_config_handle uc)
  556 {
  557         struct usbf_interface *ui;
  558         struct usbf_endpoint *ue;
usb_descriptor_t *d;
usbf_status err = USBF_NORMAL_COMPLETION;
  562         if (uc->uc_closed)
  563                 return USBF_INVAL;
SIMPLEQ_FOREACH(ui, &uc->iface_head, next) {
err = usbf_add_config_desc(uc,
  567                     (usb_descriptor_t *)ui->idesc, &d);
  568                 if (err)
  569                         break;
free(ui->idesc, M_USB);
ui->idesc = (usb_interface_descriptor_t *)d;
SIMPLEQ_FOREACH(ue, &ui->endpoint_head, next) {
err = usbf_add_config_desc(uc,
  576                             (usb_descriptor_t *)ue->edesc, &d);
  577                         if (err)
  578                                 break;
free(ue->edesc, M_USB);
ue->edesc = (usb_endpoint_descriptor_t *)d;
  582                 }
  583         }
uc->uc_closed = 1;
  586         return err;
  587 }
usb_device_descriptor_t *
usbf_device_descriptor(usbf_device_handle dev)
  591 {
  592         return &dev->ddesc;
  593 }
usb_config_descriptor_t *
usbf_config_descriptor(usbf_device_handle dev, u_int8_t index)
  597 {
  598         struct usbf_config *uc;
SIMPLEQ_FOREACH(uc, &dev->configs, next) {
  601                 if (index-- == 0)
  602                         return uc->uc_cdesc;
  603         }
  604         return NULL;
  605 }
  607 int
usbf_interface_number(usbf_interface_handle iface)
  609 {
  610         return iface->idesc->bInterfaceNumber;
  611 }
u_int8_t
usbf_endpoint_address(usbf_endpoint_handle endpoint)
  615 {
  616         return endpoint->edesc->bEndpointAddress;
  617 }
u_int8_t
usbf_endpoint_attributes(usbf_endpoint_handle endpoint)
  621 {
  622         return endpoint->edesc->bmAttributes;
  623 }
usbf_status
usbf_open_pipe(usbf_interface_handle iface, u_int8_t address,
usbf_pipe_handle *pipe)
  628 {
  629         return usbf_open_pipe_ival(iface, address, pipe, 0);
  630 }
usbf_status
usbf_open_pipe_ival(usbf_interface_handle iface, u_int8_t address,
usbf_pipe_handle *pipe, int ival)
  635 {
  636         struct usbf_endpoint *ep;
usbf_pipe_handle p;
usbf_status err;
ep = usbf_iface_endpoint(iface, address);
  641         if (ep == NULL)
  642                 return USBF_BAD_ADDRESS;
err = usbf_setup_pipe(iface->config->uc_device, iface, ep,
ival, &p);
  646         if (err)
  647                 return err;
LIST_INSERT_HEAD(&iface->pipes, p, next);
  649         *pipe = p;
  650         return USBF_NORMAL_COMPLETION;
  651 }
usbf_status
usbf_setup_pipe(usbf_device_handle dev, usbf_interface_handle iface,
  655     struct usbf_endpoint *ep, int ival, usbf_pipe_handle *pipe)
  656 {
  657         struct usbf_pipe *p;
usbf_status err;
p = malloc(dev->bus->pipe_size, M_USB, M_NOWAIT);
  661         if (p == NULL)
  662                 return USBF_NOMEM;
p->device = dev;
p->iface = iface;
p->endpoint = ep;
ep->refcnt++;
p->running = 0;
p->refcnt = 1;
p->repeat = 0;
p->interval = ival;
p->methods = NULL;      /* set by bus driver in open_pipe() */
SIMPLEQ_INIT(&p->queue);
err = dev->bus->methods->open_pipe(p);
  675         if (err) {
free(p, M_USB);
  677                 return err;
  678         }
  679         *pipe = p;
  680         return USBF_NORMAL_COMPLETION;
  681 }
  683 /* Dequeue all pipe operations. */
  684 void
usbf_abort_pipe(usbf_pipe_handle pipe)
  686 {
usbf_xfer_handle xfer;
  688         int s;
s = splusb();
pipe->repeat = 0;
pipe->aborting = 1;
  694         while ((xfer = SIMPLEQ_FIRST(&pipe->queue)) != NULL) {
DPRINTF(0,("usbf_abort_pipe: pipe=%p, xfer=%p\n", pipe,
xfer));
  697                 /* Make the DC abort it (and invoke the callback). */
pipe->methods->abort(xfer);
  699         }
pipe->aborting = 0;
splx(s);
  703 }
  705 /* Abort all pipe operations and close the pipe. */
  706 void
usbf_close_pipe(usbf_pipe_handle pipe)
  708 {
usbf_abort_pipe(pipe);
pipe->methods->close(pipe);
pipe->endpoint->refcnt--;
free(pipe, M_USB);
  713 }
  715 void
usbf_stall_pipe(usbf_pipe_handle pipe)
  717 {
DPRINTF(0,("usbf_stall_pipe not implemented\n"));
  719 }
usbf_endpoint_handle
usbf_iface_endpoint(usbf_interface_handle iface, u_int8_t address)
  723 {
usbf_endpoint_handle ep;
SIMPLEQ_FOREACH(ep, &iface->endpoint_head, next) {
  727                 if (ep->edesc->bEndpointAddress == address)
  728                         return ep;
  729         }
  730         return NULL;
  731 }
usbf_endpoint_handle
usbf_config_endpoint(usbf_config_handle cfg, u_int8_t address)
  735 {
usbf_interface_handle iface;
usbf_endpoint_handle ep;
SIMPLEQ_FOREACH(iface, &cfg->iface_head, next) {
SIMPLEQ_FOREACH(ep, &iface->endpoint_head, next) {
  741                         if (ep->edesc->bEndpointAddress == address)
  742                                 return ep;
  743                 }
  744         }
  745         return NULL;
  746 }
  748 void
usbf_set_endpoint_halt(usbf_endpoint_handle endpoint)
  750 {
  751 }
  753 void
usbf_clear_endpoint_halt(usbf_endpoint_handle endpoint)
  755 {
  756 }
usbf_status
usbf_set_endpoint_feature(usbf_config_handle cfg, u_int8_t address,
u_int16_t value)
  761 {
usbf_endpoint_handle ep;
DPRINTF(0,("usbf_set_endpoint_feature: cfg=%p address=%#x"
  765             " value=%#x\n", cfg, address, value));
ep = usbf_config_endpoint(cfg, address);
  768         if (ep == NULL)
  769                 return USBF_BAD_ADDRESS;
  771         switch (value) {
  772         case UF_ENDPOINT_HALT:
usbf_set_endpoint_halt(ep);
  774                 return USBF_NORMAL_COMPLETION;
  775         default:
  776                 /* unsupported feature, send STALL in data/status phase */
  777                 return USBF_STALLED;
  778         }
  779 }
usbf_status
usbf_clear_endpoint_feature(usbf_config_handle cfg, u_int8_t address,
u_int16_t value)
  784 {
usbf_endpoint_handle ep;
DPRINTF(0,("usbf_clear_endpoint_feature: cfg=%p address=%#x"
  788             " value=%#x\n", cfg, address, value));
ep = usbf_config_endpoint(cfg, address);
  791         if (ep == NULL)
  792                 return USBF_BAD_ADDRESS;
  794         switch (value) {
  795         case UF_ENDPOINT_HALT:
usbf_clear_endpoint_halt(ep);
  797                 return USBF_NORMAL_COMPLETION;
  798         default:
  799                 /* unsupported feature, send STALL in data/status phase */
  800                 return USBF_STALLED;
  801         }
  802 }
usbf_xfer_handle
usbf_alloc_xfer(usbf_device_handle dev)
  806 {
  807         struct usbf_xfer *xfer;
  809         /* allocate zero-filled buffer */
xfer = dev->bus->methods->allocx(dev->bus);
  811         if (xfer == NULL)
  812                 return NULL;
xfer->device = dev;
timeout_set(&xfer->timeout_handle, NULL, NULL);
DPRINTF(1,("usbf_alloc_xfer() = %p\n", xfer));
  816         return xfer;
  817 }
  819 void
usbf_free_xfer(usbf_xfer_handle xfer)
  821 {
DPRINTF(1,("usbf_free_xfer: %p\n", xfer));
  823         if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))
usbf_free_buffer(xfer);
xfer->device->bus->methods->freex(xfer->device->bus, xfer);
  826 }
usbf_status
usbf_allocmem(usbf_bus_handle bus, size_t size, size_t align, usb_dma_t *p)
  830 {
  831         struct usbd_bus dbus;
usbd_status err;
  834         /* XXX bad idea, fix usb_mem.c instead! */
dbus.dmatag = bus->dmatag;
err = usb_allocmem(&dbus, size, align, p);
  837         return err ? USBF_NOMEM : USBF_NORMAL_COMPLETION;
  838 }
  840 void
usbf_freemem(usbf_bus_handle bus, usb_dma_t *p)
  842 {
usb_freemem((usbd_bus_handle)NULL, p);
  844 }
  846 void *
usbf_alloc_buffer(usbf_xfer_handle xfer, u_int32_t size)
  848 {
  849         struct usbf_bus *bus = xfer->device->bus;
usbf_status err;
  852 #ifdef DIAGNOSTIC
  853         if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))
printf("xfer %p already has a buffer\n", xfer);
  855 #endif
err = bus->methods->allocm(bus, &xfer->dmabuf, size);
  858         if (err)
  859                 return NULL;
xfer->rqflags |= URQ_DEV_DMABUF;
  862         return KERNADDR(&xfer->dmabuf, 0);
  863 }
  865 void
usbf_free_buffer(usbf_xfer_handle xfer)
  867 {
  868 #ifdef DIAGNOSTIC
  869         if (!(xfer->rqflags & URQ_DEV_DMABUF)) {
printf("usbf_free_buffer: no buffer\n");
  871                 return;
  872         }
  873 #endif
xfer->rqflags &= ~URQ_DEV_DMABUF;
xfer->device->bus->methods->freem(xfer->device->bus, &xfer->dmabuf);
  876 }
  878 #ifdef USBF_DEBUG
  879 /*
  880  * The dump format is similar to Linux' Gadget driver so that we can
  881  * easily compare traces.
  882  */
  883 static void
usbf_dump_buffer(usbf_xfer_handle xfer)
  885 {
  886         struct device *dev = (struct device *)xfer->pipe->device->bus->usbfctl;
usbf_endpoint_handle ep = xfer->pipe->endpoint;
  888         int index = usbf_endpoint_index(ep);
  889         int dir = usbf_endpoint_dir(ep);
u_char *p = xfer->buffer;
u_int i;
printf("%s: ep%d-%s, length=%u, %s", dev->dv_xname, index,
  894             (xfer->rqflags & URQ_REQUEST) ? "setup" :
  895             (index == 0 ? "in" : (dir == UE_DIR_IN ? "in" : "out")),
xfer->length, usbf_errstr(xfer->status));
  898         for (i = 0; i < xfer->length; i++) {
  899                 if ((i % 16) == 0)
printf("\n%4x:", i);
  901                 else if ((i % 8) == 0)
printf(" ");
printf(" %02x", p[i]);
  904         }
printf("\n");
  906 }
  907 #endif
  909 void
usbf_setup_xfer(usbf_xfer_handle xfer, usbf_pipe_handle pipe,
usbf_private_handle priv, void *buffer, u_int32_t length,
u_int16_t flags, u_int32_t timeout, usbf_callback callback)
  913 {
xfer->pipe = pipe;
xfer->priv = priv;
xfer->buffer = buffer;
xfer->length = length;
xfer->actlen = 0;
xfer->flags = flags;
xfer->timeout = timeout;
xfer->status = USBF_NOT_STARTED;
xfer->callback = callback;
xfer->rqflags &= ~URQ_REQUEST;
  924 }
  926 void
usbf_setup_default_xfer(usbf_xfer_handle xfer, usbf_pipe_handle pipe,
usbf_private_handle priv, usb_device_request_t *req, u_int16_t flags,
u_int32_t timeout, usbf_callback callback)
  930 {
xfer->pipe = pipe;
xfer->priv = priv;
xfer->buffer = req;
xfer->length = sizeof *req;
xfer->actlen = 0;
xfer->flags = flags;
xfer->timeout = timeout;
xfer->status = USBF_NOT_STARTED;
xfer->callback = callback;
xfer->rqflags |= URQ_REQUEST;
  941 }
  943 void
usbf_get_xfer_status(usbf_xfer_handle xfer, usbf_private_handle *priv,
  945     void **buffer, u_int32_t *actlen, usbf_status *status)
  946 {
  947         if (priv != NULL)
  948                 *priv = xfer->priv;
  949         if (buffer != NULL)
  950                 *buffer = xfer->buffer;
  951         if (actlen != NULL)
  952                 *actlen = xfer->actlen;
  953         if (status != NULL)
  954                 *status = xfer->status;
  955 }
usbf_status
usbf_transfer(usbf_xfer_handle xfer)
  959 {
usbf_pipe_handle pipe = xfer->pipe;
usbf_status err;
err = pipe->methods->transfer(xfer);
  964         if (err != USBF_IN_PROGRESS && err) {
  965                 if (xfer->rqflags & URQ_AUTO_DMABUF) {
usbf_free_buffer(xfer);
xfer->rqflags &= ~URQ_AUTO_DMABUF;
  968                 }
  969         }
  970         return err;
  971 }
usbf_status
usbf_insert_transfer(usbf_xfer_handle xfer)
  975 {
usbf_pipe_handle pipe = xfer->pipe;
usbf_status err;
  978         int s;
DPRINTF(1,("usbf_insert_transfer: xfer=%p pipe=%p running=%d\n",
xfer, pipe, pipe->running));
s = splusb();
SIMPLEQ_INSERT_TAIL(&pipe->queue, xfer, next);
  985         if (pipe->running)
err = USBF_IN_PROGRESS;
  987         else {
pipe->running = 1;
err = USBF_NORMAL_COMPLETION;
  990         }
splx(s);
  992         return err;
  993 }
  995 void
usbf_start_next(usbf_pipe_handle pipe)
  997 {
usbf_xfer_handle xfer;
usbf_status err;
SPLUSBCHECK;
 1003         /* Get next request in queue. */
xfer = SIMPLEQ_FIRST(&pipe->queue);
 1005         if (xfer == NULL)
pipe->running = 0;
 1007         else {
err = pipe->methods->start(xfer);
 1009                 if (err != USBF_IN_PROGRESS) {
printf("usbf_start_next: %s\n", usbf_errstr(err));
pipe->running = 0;
 1012                         /* XXX do what? */
 1013                 }
 1014         }
 1015 }
 1017 /* Called at splusb() */
 1018 void
usbf_transfer_complete(usbf_xfer_handle xfer)
 1020 {
usbf_pipe_handle pipe = xfer->pipe;
 1022         int repeat = pipe->repeat;
SPLUSBCHECK;
DPRINTF(1,("usbf_transfer_complete: xfer=%p pipe=%p running=%d\n",
xfer, pipe, pipe->running));
 1027 #ifdef USBF_DEBUG
 1028         if (usbfdebug > 0)
usbf_dump_buffer(xfer);
 1030 #endif
 1032         if (!repeat) {
 1033                 /* Remove request from queue. */
KASSERT(SIMPLEQ_FIRST(&pipe->queue) == xfer);
SIMPLEQ_REMOVE_HEAD(&pipe->queue, next);
 1036         }
 1038         if (xfer->status == USBF_NORMAL_COMPLETION &&
xfer->actlen < xfer->length &&
 1040             !(xfer->flags & USBD_SHORT_XFER_OK)) {
DPRINTF(0,("usbf_transfer_complete: short xfer=%p %u<%u\n",
xfer, xfer->actlen, xfer->length));
xfer->status = USBF_SHORT_XFER;
 1044         }
 1046         if (xfer->callback != NULL)
xfer->callback(xfer, xfer->priv, xfer->status);
pipe->methods->done(xfer);
 1051         /* XXX wake up any processes waiting for the transfer to complete */
 1053         if (!repeat) {
 1054                 if (xfer->status != USBF_NORMAL_COMPLETION &&
pipe->iface != NULL) /* not control pipe */
pipe->running = 0;
 1057                 else
usbf_start_next(pipe);
 1059         }
 1060 }
 1062 /*
 1063  * Software interrupts
 1064  */
usbf_status
usbf_softintr_establish(struct usbf_bus *bus)
 1068 {
 1069 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
KASSERT(bus->soft == NULL);
 1071         /* XXX we should have our own level */
bus->soft = softintr_establish(IPL_SOFTNET,
bus->methods->soft_intr, bus);
 1074         if (bus->soft == NULL)
 1075                 return USBF_INVAL;
 1076 #endif
 1077         return USBF_NORMAL_COMPLETION;
 1078 }
 1080 void
usbf_schedsoftintr(struct usbf_bus *bus)
 1082 {
 1083 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
softintr_schedule(bus->soft);
 1085 #else
bus->methods->soft_intr(bus);
 1087 #endif /* __HAVE_GENERIC_SOFT_INTERRUPTS */
 1088 }