Annotation of sys/dev/usb/usbf_subr.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: usbf_subr.c,v 1.10 2007/07/27 09:16:09 mbalmer Exp $ */
! 2:
! 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: */
! 18:
! 19: /*
! 20: * USB function driver interface subroutines
! 21: */
! 22:
! 23: #include <sys/param.h>
! 24: #include <sys/malloc.h>
! 25: #include <sys/systm.h>
! 26: #include <sys/timeout.h>
! 27:
! 28: #include <machine/bus.h>
! 29:
! 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>
! 36:
! 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
! 43:
! 44: void *usbf_realloc(void **, size_t *, size_t);
! 45: size_t usbf_get_string(usbf_device_handle, u_int8_t, char *, size_t);
! 46: usbf_status usbf_open_pipe_ival(usbf_interface_handle, u_int8_t,
! 47: usbf_pipe_handle *, int);
! 48: usbf_status usbf_setup_pipe(usbf_device_handle, usbf_interface_handle,
! 49: struct usbf_endpoint *, int,
! 50: 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);
! 54:
! 55: static const char * const usbf_error_strs[] = USBF_ERROR_STRS;
! 56:
! 57: const char *
! 58: usbf_errstr(usbf_status err)
! 59: {
! 60: static char buffer[5];
! 61:
! 62: if (err < USBF_ERROR_MAX)
! 63: return usbf_error_strs[err];
! 64:
! 65: snprintf(buffer, sizeof buffer, "%d", err);
! 66: return buffer;
! 67: }
! 68:
! 69: void *
! 70: usbf_realloc(void **pp, size_t *sizep, size_t newsize)
! 71: {
! 72: void *p;
! 73: size_t oldsize;
! 74:
! 75: if (newsize == 0) {
! 76: if (*sizep > 0)
! 77: free(*pp, M_USB);
! 78: *pp = NULL;
! 79: *sizep = 0;
! 80: return NULL;
! 81: }
! 82:
! 83: p = malloc(newsize, M_USB, M_NOWAIT);
! 84: if (p == NULL)
! 85: return NULL;
! 86:
! 87: oldsize = MIN(*sizep, newsize);
! 88: if (oldsize > 0)
! 89: bcopy(*pp, p, oldsize);
! 90: *pp = p;
! 91: *sizep = newsize;
! 92: return p;
! 93: }
! 94:
! 95: /*
! 96: * Attach a function driver.
! 97: */
! 98: static usbf_status
! 99: usbf_probe_and_attach(struct device *parent, usbf_device_handle dev, int port)
! 100: {
! 101: struct usbf_attach_arg uaa;
! 102: struct device *dv;
! 103:
! 104: KASSERT(dev->function == NULL);
! 105:
! 106: bzero(&uaa, sizeof uaa);
! 107: uaa.device = dev;
! 108:
! 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: */
! 115: dv = config_found_sm(parent, &uaa, NULL, NULL);
! 116: if (dv != NULL) {
! 117: dev->function = (struct usbf_function *)dv;
! 118: return USBF_NORMAL_COMPLETION;
! 119: }
! 120:
! 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: }
! 128:
! 129: static void
! 130: usbf_remove_device(usbf_device_handle dev, struct usbf_port *up)
! 131: {
! 132: KASSERT(dev != NULL && dev == up->device);
! 133:
! 134: if (dev->function != NULL)
! 135: config_detach((struct device *)dev->function, DETACH_FORCE);
! 136: if (dev->default_pipe != NULL)
! 137: usbf_close_pipe(dev->default_pipe);
! 138: up->device = NULL;
! 139: free(dev, M_USB);
! 140: }
! 141:
! 142: usbf_status
! 143: 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;
! 147: usb_device_descriptor_t *ud;
! 148: usbf_status err;
! 149:
! 150: #ifdef DIAGNOSTIC
! 151: KASSERT(up->device == NULL);
! 152: #endif
! 153:
! 154: dev = malloc(sizeof(*dev), M_USB, M_NOWAIT);
! 155: if (dev == NULL)
! 156: return USBF_NOMEM;
! 157:
! 158: bzero(dev, sizeof *dev);
! 159: dev->bus = bus;
! 160: dev->string_id = USBF_STRING_ID_MIN;
! 161: SIMPLEQ_INIT(&dev->configs);
! 162:
! 163: /* Initialize device status. */
! 164: USETW(dev->status.wStatus, UDS_SELF_POWERED);
! 165:
! 166: /*
! 167: * Initialize device descriptor. The function driver for this
! 168: * device (attached below) must complete the device descriptor.
! 169: */
! 170: ud = &dev->ddesc;
! 171: ud->bLength = USB_DEVICE_DESCRIPTOR_SIZE;
! 172: ud->bDescriptorType = UDESC_DEVICE;
! 173: ud->bMaxPacketSize = bus->ep0_maxp;
! 174: if (bus->usbrev >= USBREV_2_0)
! 175: USETW(ud->bcdUSB, UD_USB_2_0);
! 176: else
! 177: USETW(ud->bcdUSB, 0x0101);
! 178:
! 179: /* Set up the default endpoint handle and descriptor. */
! 180: dev->def_ep.edesc = &dev->def_ep_desc;
! 181: dev->def_ep_desc.bLength = USB_ENDPOINT_DESCRIPTOR_SIZE;
! 182: dev->def_ep_desc.bDescriptorType = UDESC_ENDPOINT;
! 183: dev->def_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT;
! 184: dev->def_ep_desc.bmAttributes = UE_CONTROL;
! 185: USETW(dev->def_ep_desc.wMaxPacketSize, ud->bMaxPacketSize);
! 186: dev->def_ep_desc.bInterval = 0;
! 187:
! 188: /* Establish the default pipe. */
! 189: err = usbf_setup_pipe(dev, NULL, &dev->def_ep, 0,
! 190: &dev->default_pipe);
! 191: if (err) {
! 192: free(dev, M_USB);
! 193: return err;
! 194: }
! 195:
! 196: /* Preallocate xfers for default pipe. */
! 197: dev->default_xfer = usbf_alloc_xfer(dev);
! 198: dev->data_xfer = usbf_alloc_xfer(dev);
! 199: if (dev->default_xfer == NULL || dev->data_xfer == NULL) {
! 200: if (dev->default_xfer != NULL)
! 201: usbf_free_xfer(dev->default_xfer);
! 202: usbf_close_pipe(dev->default_pipe);
! 203: free(dev, M_USB);
! 204: return USBF_NOMEM;
! 205: }
! 206:
! 207: /* Insert device request xfer. */
! 208: usbf_setup_default_xfer(dev->default_xfer, dev->default_pipe,
! 209: NULL, &dev->def_req, 0, 0, usbf_do_request);
! 210: err = usbf_transfer(dev->default_xfer);
! 211: if (err && err != USBF_IN_PROGRESS) {
! 212: usbf_free_xfer(dev->default_xfer);
! 213: usbf_free_xfer(dev->data_xfer);
! 214: usbf_close_pipe(dev->default_pipe);
! 215: free(dev, M_USB);
! 216: return err;
! 217: }
! 218:
! 219: /* Associate the upstream port with the device. */
! 220: bzero(up, sizeof *up);
! 221: up->portno = port;
! 222: up->device = dev;
! 223:
! 224: /* Attach function driver. */
! 225: err = usbf_probe_and_attach(parent, dev, port);
! 226: if (err)
! 227: usbf_remove_device(dev, up);
! 228: return err;
! 229: }
! 230:
! 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
! 236: usbf_devinfo_setup(usbf_device_handle dev, u_int8_t devclass,
! 237: u_int8_t subclass, u_int8_t proto, u_int16_t vendor, u_int16_t product,
! 238: u_int16_t device, const char *manf, const char *prod, const char *ser)
! 239: {
! 240: usb_device_descriptor_t *dd;
! 241:
! 242: dd = usbf_device_descriptor(dev);
! 243: dd->bDeviceClass = devclass;
! 244: dd->bDeviceSubClass = subclass;
! 245: dd->bDeviceProtocol = proto;
! 246: if (vendor != 0)
! 247: USETW(dd->idVendor, vendor);
! 248: if (product != 0)
! 249: USETW(dd->idProduct, product);
! 250: if (device != 0)
! 251: USETW(dd->bcdDevice, device);
! 252: if (manf != NULL)
! 253: dd->iManufacturer = usbf_add_string(dev, manf);
! 254: if (prod != NULL)
! 255: dd->iProduct = usbf_add_string(dev, prod);
! 256: if (ser != NULL)
! 257: dd->iSerialNumber = usbf_add_string(dev, ser);
! 258: }
! 259:
! 260: char *
! 261: usbf_devinfo_alloc(usbf_device_handle dev)
! 262: {
! 263: char manf[40];
! 264: char prod[40];
! 265: usb_device_descriptor_t *dd;
! 266: size_t len;
! 267: char *devinfo;
! 268:
! 269: dd = usbf_device_descriptor(dev);
! 270: usbf_get_string(dev, dd->iManufacturer, manf, sizeof manf);
! 271: usbf_get_string(dev, dd->iProduct, prod, sizeof prod);
! 272:
! 273: len = strlen(manf) + strlen(prod) + 32;
! 274: devinfo = malloc(len, M_USB, M_NOWAIT);
! 275: if (devinfo == NULL)
! 276: return NULL;
! 277:
! 278: 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: }
! 283:
! 284: void
! 285: usbf_devinfo_free(char *devinfo)
! 286: {
! 287: if (devinfo != NULL)
! 288: free(devinfo, M_USB);
! 289: }
! 290:
! 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: */
! 298: u_int8_t
! 299: usbf_add_string(usbf_device_handle dev, const char *string)
! 300: {
! 301: usb_string_descriptor_t *sd;
! 302: size_t oldsize;
! 303: size_t newsize;
! 304: size_t len, i;
! 305: u_int8_t id;
! 306:
! 307: if (string == NULL || *string == '\0' ||
! 308: dev->string_id == USBF_STRING_ID_MAX)
! 309: return USBF_EMPTY_STRING_ID;
! 310:
! 311: if ((len = strlen(string)) >= USB_MAX_STRING_LEN)
! 312: len = USB_MAX_STRING_LEN - 1;
! 313:
! 314: oldsize = dev->sdesc_size;
! 315: newsize = oldsize + 2 + 2 * len;
! 316:
! 317: sd = usbf_realloc((void **)&dev->sdesc, &dev->sdesc_size,
! 318: newsize);
! 319: if (sd == NULL)
! 320: return USBF_EMPTY_STRING_ID;
! 321:
! 322: sd = (usb_string_descriptor_t *)((char *)sd + oldsize);
! 323: sd->bLength = newsize - oldsize;
! 324: sd->bDescriptorType = UDESC_STRING;
! 325: for (i = 0; string[i] != '\0' && i < len; i++)
! 326: USETW(sd->bString[i], string[i]);
! 327:
! 328: id = dev->string_id++;
! 329: return id;
! 330: }
! 331:
! 332: usb_string_descriptor_t *
! 333: 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;
! 337: usb_string_descriptor_t *sd;
! 338:
! 339: /* handle the special string ids */
! 340: switch (id) {
! 341: case USB_LANGUAGE_TABLE:
! 342: sd0.bLength = 4;
! 343: sd0.bDescriptorType = UDESC_STRING;
! 344: USETW(sd0.bString[0], 0x0409 /* en_US */);
! 345: return &sd0;
! 346:
! 347: case USBF_EMPTY_STRING_ID:
! 348: sd1.bLength = 2;
! 349: sd1.bDescriptorType = UDESC_STRING;
! 350: return &sd0;
! 351: }
! 352:
! 353: /* check if the string id is valid */
! 354: if (id > dev->string_id)
! 355: return NULL;
! 356:
! 357: /* seek and return the descriptor of a non-empty string */
! 358: id -= USBF_STRING_ID_MIN;
! 359: sd = dev->sdesc;
! 360: while (id-- > 0)
! 361: sd = (usb_string_descriptor_t *)((char *)sd + sd->bLength);
! 362: return sd;
! 363: }
! 364:
! 365: size_t
! 366: usbf_get_string(usbf_device_handle dev, u_int8_t id, char *s, size_t size)
! 367: {
! 368: usb_string_descriptor_t *sd = NULL;
! 369: size_t i, len;
! 370:
! 371: if (id != USB_LANGUAGE_TABLE)
! 372: sd = usbf_string_descriptor(dev, id);
! 373:
! 374: if (sd == NULL) {
! 375: if (size > 0)
! 376: *s = '\0';
! 377: return 0;
! 378: }
! 379:
! 380: len = (sd->bLength - 2) / 2;
! 381: if (size < 1)
! 382: return len;
! 383:
! 384: for (i = 0; i < (size - 1) && i < len; i++)
! 385: s[i] = UGETW(sd->bString[i]) & 0xff;
! 386: s[i] = '\0';
! 387: return len;
! 388: }
! 389:
! 390: /*
! 391: * Add a new device configuration to an existing USB logical device.
! 392: * The new configuration initially has zero interfaces.
! 393: */
! 394: usbf_status
! 395: usbf_add_config(usbf_device_handle dev, usbf_config_handle *ucp)
! 396: {
! 397: struct usbf_config *uc;
! 398: usb_config_descriptor_t *cd;
! 399:
! 400: uc = malloc(sizeof *uc, M_USB, M_NOWAIT);
! 401: if (uc == NULL)
! 402: return USBF_NOMEM;
! 403:
! 404: cd = malloc(sizeof *cd, M_USB, M_NOWAIT);
! 405: if (cd == NULL) {
! 406: free(uc, M_USB);
! 407: return USBF_NOMEM;
! 408: }
! 409:
! 410: bzero(uc, sizeof *uc);
! 411: uc->uc_device = dev;
! 412: uc->uc_cdesc = cd;
! 413: uc->uc_cdesc_size = sizeof *cd;
! 414: SIMPLEQ_INIT(&uc->iface_head);
! 415:
! 416: bzero(cd, sizeof *cd);
! 417: cd->bLength = USB_CONFIG_DESCRIPTOR_SIZE;
! 418: cd->bDescriptorType = UDESC_CONFIG;
! 419: USETW(cd->wTotalLength, USB_CONFIG_DESCRIPTOR_SIZE);
! 420: cd->bConfigurationValue = USB_UNCONFIG_NO + 1 +
! 421: dev->ddesc.bNumConfigurations;
! 422: cd->iConfiguration = 0;
! 423: cd->bmAttributes = UC_BUS_POWERED | UC_SELF_POWERED;
! 424: #if 0
! 425: cd->bMaxPower = 100 / UC_POWER_FACTOR; /* 100 mA */
! 426: #else
! 427: cd->bMaxPower = 0; /* XXX 0 mA */
! 428: #endif
! 429:
! 430: SIMPLEQ_INSERT_TAIL(&dev->configs, uc, next);
! 431: dev->ddesc.bNumConfigurations++;
! 432:
! 433: if (ucp != NULL)
! 434: *ucp = uc;
! 435: return USBF_NORMAL_COMPLETION;
! 436: }
! 437:
! 438: /*
! 439: * Allocate memory for a new descriptor at the end of the existing
! 440: * device configuration descriptor.
! 441: */
! 442: usbf_status
! 443: usbf_add_config_desc(usbf_config_handle uc, usb_descriptor_t *d,
! 444: usb_descriptor_t **dp)
! 445: {
! 446: usb_config_descriptor_t *cd;
! 447: size_t oldsize;
! 448: size_t newsize;
! 449:
! 450: oldsize = uc->uc_cdesc_size;
! 451: newsize = oldsize + d->bLength;
! 452: if (d->bLength < sizeof(usb_descriptor_t) || newsize > 65535)
! 453: return USBF_INVAL;
! 454:
! 455: cd = usbf_realloc((void **)&uc->uc_cdesc, &uc->uc_cdesc_size,
! 456: newsize);
! 457: if (cd == NULL)
! 458: return USBF_NOMEM;
! 459:
! 460: bcopy(d, (char *)cd + oldsize, d->bLength);
! 461: USETW(cd->wTotalLength, newsize);
! 462: if (dp != NULL)
! 463: *dp = (usb_descriptor_t *)((char *)cd + oldsize);
! 464: return USBF_NORMAL_COMPLETION;
! 465: }
! 466:
! 467: usbf_status
! 468: usbf_add_interface(usbf_config_handle uc, u_int8_t bInterfaceClass,
! 469: u_int8_t bInterfaceSubClass, u_int8_t bInterfaceProtocol,
! 470: const char *string, usbf_interface_handle *uip)
! 471: {
! 472: struct usbf_interface *ui;
! 473: usb_interface_descriptor_t *id;
! 474:
! 475: if (uc->uc_closed)
! 476: return USBF_INVAL;
! 477:
! 478: ui = malloc(sizeof *ui, M_USB, M_NOWAIT);
! 479: if (ui == NULL)
! 480: return USBF_NOMEM;
! 481:
! 482: id = malloc(sizeof *id, M_USB, M_NOWAIT);
! 483: if (id == NULL) {
! 484: free(ui, M_USB);
! 485: return USBF_NOMEM;
! 486: }
! 487:
! 488: bzero(ui, sizeof *ui);
! 489: ui->config = uc;
! 490: ui->idesc = id;
! 491: LIST_INIT(&ui->pipes);
! 492: SIMPLEQ_INIT(&ui->endpoint_head);
! 493:
! 494: bzero(id, sizeof *id);
! 495: id->bLength = USB_INTERFACE_DESCRIPTOR_SIZE;
! 496: id->bDescriptorType = UDESC_INTERFACE;
! 497: id->bInterfaceNumber = uc->uc_cdesc->bNumInterface;
! 498: id->bInterfaceClass = bInterfaceClass;
! 499: id->bInterfaceSubClass = bInterfaceSubClass;
! 500: id->bInterfaceProtocol = bInterfaceProtocol;
! 501: id->iInterface = 0; /*usbf_add_string(uc->uc_device, string);*/ /* XXX */
! 502:
! 503: SIMPLEQ_INSERT_TAIL(&uc->iface_head, ui, next);
! 504: uc->uc_cdesc->bNumInterface++;
! 505:
! 506: *uip = ui;
! 507: return USBF_NORMAL_COMPLETION;
! 508: }
! 509:
! 510: usbf_status
! 511: usbf_add_endpoint(usbf_interface_handle ui, u_int8_t bEndpointAddress,
! 512: u_int8_t bmAttributes, u_int16_t wMaxPacketSize, u_int8_t bInterval,
! 513: usbf_endpoint_handle *uep)
! 514: {
! 515: struct usbf_endpoint *ue;
! 516: usb_endpoint_descriptor_t *ed;
! 517:
! 518: if (ui->config->uc_closed)
! 519: return USBF_INVAL;
! 520:
! 521: ue = malloc(sizeof *ue, M_USB, M_NOWAIT);
! 522: if (ue == NULL)
! 523: return USBF_NOMEM;
! 524:
! 525: ed = malloc(sizeof *ed, M_USB, M_NOWAIT);
! 526: if (ed == NULL) {
! 527: free(ue, M_USB);
! 528: return USBF_NOMEM;
! 529: }
! 530:
! 531: bzero(ue, sizeof *ue);
! 532: ue->iface = ui;
! 533: ue->edesc = ed;
! 534:
! 535: bzero(ed, sizeof *ed);
! 536: ed->bLength = USB_ENDPOINT_DESCRIPTOR_SIZE;
! 537: ed->bDescriptorType = UDESC_ENDPOINT;
! 538: ed->bEndpointAddress = bEndpointAddress;
! 539: ed->bmAttributes = bmAttributes;
! 540: USETW(ed->wMaxPacketSize, wMaxPacketSize);
! 541: ed->bInterval = bInterval;
! 542:
! 543: SIMPLEQ_INSERT_TAIL(&ui->endpoint_head, ue, next);
! 544: ui->idesc->bNumEndpoints++;
! 545:
! 546: *uep = ue;
! 547: return USBF_NORMAL_COMPLETION;
! 548: }
! 549:
! 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: */
! 554: usbf_status
! 555: usbf_end_config(usbf_config_handle uc)
! 556: {
! 557: struct usbf_interface *ui;
! 558: struct usbf_endpoint *ue;
! 559: usb_descriptor_t *d;
! 560: usbf_status err = USBF_NORMAL_COMPLETION;
! 561:
! 562: if (uc->uc_closed)
! 563: return USBF_INVAL;
! 564:
! 565: SIMPLEQ_FOREACH(ui, &uc->iface_head, next) {
! 566: err = usbf_add_config_desc(uc,
! 567: (usb_descriptor_t *)ui->idesc, &d);
! 568: if (err)
! 569: break;
! 570:
! 571: free(ui->idesc, M_USB);
! 572: ui->idesc = (usb_interface_descriptor_t *)d;
! 573:
! 574: SIMPLEQ_FOREACH(ue, &ui->endpoint_head, next) {
! 575: err = usbf_add_config_desc(uc,
! 576: (usb_descriptor_t *)ue->edesc, &d);
! 577: if (err)
! 578: break;
! 579:
! 580: free(ue->edesc, M_USB);
! 581: ue->edesc = (usb_endpoint_descriptor_t *)d;
! 582: }
! 583: }
! 584:
! 585: uc->uc_closed = 1;
! 586: return err;
! 587: }
! 588:
! 589: usb_device_descriptor_t *
! 590: usbf_device_descriptor(usbf_device_handle dev)
! 591: {
! 592: return &dev->ddesc;
! 593: }
! 594:
! 595: usb_config_descriptor_t *
! 596: usbf_config_descriptor(usbf_device_handle dev, u_int8_t index)
! 597: {
! 598: struct usbf_config *uc;
! 599:
! 600: SIMPLEQ_FOREACH(uc, &dev->configs, next) {
! 601: if (index-- == 0)
! 602: return uc->uc_cdesc;
! 603: }
! 604: return NULL;
! 605: }
! 606:
! 607: int
! 608: usbf_interface_number(usbf_interface_handle iface)
! 609: {
! 610: return iface->idesc->bInterfaceNumber;
! 611: }
! 612:
! 613: u_int8_t
! 614: usbf_endpoint_address(usbf_endpoint_handle endpoint)
! 615: {
! 616: return endpoint->edesc->bEndpointAddress;
! 617: }
! 618:
! 619: u_int8_t
! 620: usbf_endpoint_attributes(usbf_endpoint_handle endpoint)
! 621: {
! 622: return endpoint->edesc->bmAttributes;
! 623: }
! 624:
! 625: usbf_status
! 626: usbf_open_pipe(usbf_interface_handle iface, u_int8_t address,
! 627: usbf_pipe_handle *pipe)
! 628: {
! 629: return usbf_open_pipe_ival(iface, address, pipe, 0);
! 630: }
! 631:
! 632: usbf_status
! 633: usbf_open_pipe_ival(usbf_interface_handle iface, u_int8_t address,
! 634: usbf_pipe_handle *pipe, int ival)
! 635: {
! 636: struct usbf_endpoint *ep;
! 637: usbf_pipe_handle p;
! 638: usbf_status err;
! 639:
! 640: ep = usbf_iface_endpoint(iface, address);
! 641: if (ep == NULL)
! 642: return USBF_BAD_ADDRESS;
! 643:
! 644: err = usbf_setup_pipe(iface->config->uc_device, iface, ep,
! 645: ival, &p);
! 646: if (err)
! 647: return err;
! 648: LIST_INSERT_HEAD(&iface->pipes, p, next);
! 649: *pipe = p;
! 650: return USBF_NORMAL_COMPLETION;
! 651: }
! 652:
! 653: usbf_status
! 654: 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;
! 658: usbf_status err;
! 659:
! 660: p = malloc(dev->bus->pipe_size, M_USB, M_NOWAIT);
! 661: if (p == NULL)
! 662: return USBF_NOMEM;
! 663:
! 664: p->device = dev;
! 665: p->iface = iface;
! 666: p->endpoint = ep;
! 667: ep->refcnt++;
! 668: p->running = 0;
! 669: p->refcnt = 1;
! 670: p->repeat = 0;
! 671: p->interval = ival;
! 672: p->methods = NULL; /* set by bus driver in open_pipe() */
! 673: SIMPLEQ_INIT(&p->queue);
! 674: err = dev->bus->methods->open_pipe(p);
! 675: if (err) {
! 676: free(p, M_USB);
! 677: return err;
! 678: }
! 679: *pipe = p;
! 680: return USBF_NORMAL_COMPLETION;
! 681: }
! 682:
! 683: /* Dequeue all pipe operations. */
! 684: void
! 685: usbf_abort_pipe(usbf_pipe_handle pipe)
! 686: {
! 687: usbf_xfer_handle xfer;
! 688: int s;
! 689:
! 690: s = splusb();
! 691: pipe->repeat = 0;
! 692: pipe->aborting = 1;
! 693:
! 694: while ((xfer = SIMPLEQ_FIRST(&pipe->queue)) != NULL) {
! 695: DPRINTF(0,("usbf_abort_pipe: pipe=%p, xfer=%p\n", pipe,
! 696: xfer));
! 697: /* Make the DC abort it (and invoke the callback). */
! 698: pipe->methods->abort(xfer);
! 699: }
! 700:
! 701: pipe->aborting = 0;
! 702: splx(s);
! 703: }
! 704:
! 705: /* Abort all pipe operations and close the pipe. */
! 706: void
! 707: usbf_close_pipe(usbf_pipe_handle pipe)
! 708: {
! 709: usbf_abort_pipe(pipe);
! 710: pipe->methods->close(pipe);
! 711: pipe->endpoint->refcnt--;
! 712: free(pipe, M_USB);
! 713: }
! 714:
! 715: void
! 716: usbf_stall_pipe(usbf_pipe_handle pipe)
! 717: {
! 718: DPRINTF(0,("usbf_stall_pipe not implemented\n"));
! 719: }
! 720:
! 721: usbf_endpoint_handle
! 722: usbf_iface_endpoint(usbf_interface_handle iface, u_int8_t address)
! 723: {
! 724: usbf_endpoint_handle ep;
! 725:
! 726: SIMPLEQ_FOREACH(ep, &iface->endpoint_head, next) {
! 727: if (ep->edesc->bEndpointAddress == address)
! 728: return ep;
! 729: }
! 730: return NULL;
! 731: }
! 732:
! 733: usbf_endpoint_handle
! 734: usbf_config_endpoint(usbf_config_handle cfg, u_int8_t address)
! 735: {
! 736: usbf_interface_handle iface;
! 737: usbf_endpoint_handle ep;
! 738:
! 739: SIMPLEQ_FOREACH(iface, &cfg->iface_head, next) {
! 740: SIMPLEQ_FOREACH(ep, &iface->endpoint_head, next) {
! 741: if (ep->edesc->bEndpointAddress == address)
! 742: return ep;
! 743: }
! 744: }
! 745: return NULL;
! 746: }
! 747:
! 748: void
! 749: usbf_set_endpoint_halt(usbf_endpoint_handle endpoint)
! 750: {
! 751: }
! 752:
! 753: void
! 754: usbf_clear_endpoint_halt(usbf_endpoint_handle endpoint)
! 755: {
! 756: }
! 757:
! 758: usbf_status
! 759: usbf_set_endpoint_feature(usbf_config_handle cfg, u_int8_t address,
! 760: u_int16_t value)
! 761: {
! 762: usbf_endpoint_handle ep;
! 763:
! 764: DPRINTF(0,("usbf_set_endpoint_feature: cfg=%p address=%#x"
! 765: " value=%#x\n", cfg, address, value));
! 766:
! 767: ep = usbf_config_endpoint(cfg, address);
! 768: if (ep == NULL)
! 769: return USBF_BAD_ADDRESS;
! 770:
! 771: switch (value) {
! 772: case UF_ENDPOINT_HALT:
! 773: 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: }
! 780:
! 781: usbf_status
! 782: usbf_clear_endpoint_feature(usbf_config_handle cfg, u_int8_t address,
! 783: u_int16_t value)
! 784: {
! 785: usbf_endpoint_handle ep;
! 786:
! 787: DPRINTF(0,("usbf_clear_endpoint_feature: cfg=%p address=%#x"
! 788: " value=%#x\n", cfg, address, value));
! 789:
! 790: ep = usbf_config_endpoint(cfg, address);
! 791: if (ep == NULL)
! 792: return USBF_BAD_ADDRESS;
! 793:
! 794: switch (value) {
! 795: case UF_ENDPOINT_HALT:
! 796: 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: }
! 803:
! 804: usbf_xfer_handle
! 805: usbf_alloc_xfer(usbf_device_handle dev)
! 806: {
! 807: struct usbf_xfer *xfer;
! 808:
! 809: /* allocate zero-filled buffer */
! 810: xfer = dev->bus->methods->allocx(dev->bus);
! 811: if (xfer == NULL)
! 812: return NULL;
! 813: xfer->device = dev;
! 814: timeout_set(&xfer->timeout_handle, NULL, NULL);
! 815: DPRINTF(1,("usbf_alloc_xfer() = %p\n", xfer));
! 816: return xfer;
! 817: }
! 818:
! 819: void
! 820: usbf_free_xfer(usbf_xfer_handle xfer)
! 821: {
! 822: DPRINTF(1,("usbf_free_xfer: %p\n", xfer));
! 823: if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))
! 824: usbf_free_buffer(xfer);
! 825: xfer->device->bus->methods->freex(xfer->device->bus, xfer);
! 826: }
! 827:
! 828: usbf_status
! 829: usbf_allocmem(usbf_bus_handle bus, size_t size, size_t align, usb_dma_t *p)
! 830: {
! 831: struct usbd_bus dbus;
! 832: usbd_status err;
! 833:
! 834: /* XXX bad idea, fix usb_mem.c instead! */
! 835: dbus.dmatag = bus->dmatag;
! 836: err = usb_allocmem(&dbus, size, align, p);
! 837: return err ? USBF_NOMEM : USBF_NORMAL_COMPLETION;
! 838: }
! 839:
! 840: void
! 841: usbf_freemem(usbf_bus_handle bus, usb_dma_t *p)
! 842: {
! 843: usb_freemem((usbd_bus_handle)NULL, p);
! 844: }
! 845:
! 846: void *
! 847: usbf_alloc_buffer(usbf_xfer_handle xfer, u_int32_t size)
! 848: {
! 849: struct usbf_bus *bus = xfer->device->bus;
! 850: usbf_status err;
! 851:
! 852: #ifdef DIAGNOSTIC
! 853: if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))
! 854: printf("xfer %p already has a buffer\n", xfer);
! 855: #endif
! 856:
! 857: err = bus->methods->allocm(bus, &xfer->dmabuf, size);
! 858: if (err)
! 859: return NULL;
! 860:
! 861: xfer->rqflags |= URQ_DEV_DMABUF;
! 862: return KERNADDR(&xfer->dmabuf, 0);
! 863: }
! 864:
! 865: void
! 866: usbf_free_buffer(usbf_xfer_handle xfer)
! 867: {
! 868: #ifdef DIAGNOSTIC
! 869: if (!(xfer->rqflags & URQ_DEV_DMABUF)) {
! 870: printf("usbf_free_buffer: no buffer\n");
! 871: return;
! 872: }
! 873: #endif
! 874: xfer->rqflags &= ~URQ_DEV_DMABUF;
! 875: xfer->device->bus->methods->freem(xfer->device->bus, &xfer->dmabuf);
! 876: }
! 877:
! 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
! 884: usbf_dump_buffer(usbf_xfer_handle xfer)
! 885: {
! 886: struct device *dev = (struct device *)xfer->pipe->device->bus->usbfctl;
! 887: usbf_endpoint_handle ep = xfer->pipe->endpoint;
! 888: int index = usbf_endpoint_index(ep);
! 889: int dir = usbf_endpoint_dir(ep);
! 890: u_char *p = xfer->buffer;
! 891: u_int i;
! 892:
! 893: 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")),
! 896: xfer->length, usbf_errstr(xfer->status));
! 897:
! 898: for (i = 0; i < xfer->length; i++) {
! 899: if ((i % 16) == 0)
! 900: printf("\n%4x:", i);
! 901: else if ((i % 8) == 0)
! 902: printf(" ");
! 903: printf(" %02x", p[i]);
! 904: }
! 905: printf("\n");
! 906: }
! 907: #endif
! 908:
! 909: void
! 910: usbf_setup_xfer(usbf_xfer_handle xfer, usbf_pipe_handle pipe,
! 911: usbf_private_handle priv, void *buffer, u_int32_t length,
! 912: u_int16_t flags, u_int32_t timeout, usbf_callback callback)
! 913: {
! 914: xfer->pipe = pipe;
! 915: xfer->priv = priv;
! 916: xfer->buffer = buffer;
! 917: xfer->length = length;
! 918: xfer->actlen = 0;
! 919: xfer->flags = flags;
! 920: xfer->timeout = timeout;
! 921: xfer->status = USBF_NOT_STARTED;
! 922: xfer->callback = callback;
! 923: xfer->rqflags &= ~URQ_REQUEST;
! 924: }
! 925:
! 926: void
! 927: usbf_setup_default_xfer(usbf_xfer_handle xfer, usbf_pipe_handle pipe,
! 928: usbf_private_handle priv, usb_device_request_t *req, u_int16_t flags,
! 929: u_int32_t timeout, usbf_callback callback)
! 930: {
! 931: xfer->pipe = pipe;
! 932: xfer->priv = priv;
! 933: xfer->buffer = req;
! 934: xfer->length = sizeof *req;
! 935: xfer->actlen = 0;
! 936: xfer->flags = flags;
! 937: xfer->timeout = timeout;
! 938: xfer->status = USBF_NOT_STARTED;
! 939: xfer->callback = callback;
! 940: xfer->rqflags |= URQ_REQUEST;
! 941: }
! 942:
! 943: void
! 944: 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: }
! 956:
! 957: usbf_status
! 958: usbf_transfer(usbf_xfer_handle xfer)
! 959: {
! 960: usbf_pipe_handle pipe = xfer->pipe;
! 961: usbf_status err;
! 962:
! 963: err = pipe->methods->transfer(xfer);
! 964: if (err != USBF_IN_PROGRESS && err) {
! 965: if (xfer->rqflags & URQ_AUTO_DMABUF) {
! 966: usbf_free_buffer(xfer);
! 967: xfer->rqflags &= ~URQ_AUTO_DMABUF;
! 968: }
! 969: }
! 970: return err;
! 971: }
! 972:
! 973: usbf_status
! 974: usbf_insert_transfer(usbf_xfer_handle xfer)
! 975: {
! 976: usbf_pipe_handle pipe = xfer->pipe;
! 977: usbf_status err;
! 978: int s;
! 979:
! 980: DPRINTF(1,("usbf_insert_transfer: xfer=%p pipe=%p running=%d\n",
! 981: xfer, pipe, pipe->running));
! 982:
! 983: s = splusb();
! 984: SIMPLEQ_INSERT_TAIL(&pipe->queue, xfer, next);
! 985: if (pipe->running)
! 986: err = USBF_IN_PROGRESS;
! 987: else {
! 988: pipe->running = 1;
! 989: err = USBF_NORMAL_COMPLETION;
! 990: }
! 991: splx(s);
! 992: return err;
! 993: }
! 994:
! 995: void
! 996: usbf_start_next(usbf_pipe_handle pipe)
! 997: {
! 998: usbf_xfer_handle xfer;
! 999: usbf_status err;
! 1000:
! 1001: SPLUSBCHECK;
! 1002:
! 1003: /* Get next request in queue. */
! 1004: xfer = SIMPLEQ_FIRST(&pipe->queue);
! 1005: if (xfer == NULL)
! 1006: pipe->running = 0;
! 1007: else {
! 1008: err = pipe->methods->start(xfer);
! 1009: if (err != USBF_IN_PROGRESS) {
! 1010: printf("usbf_start_next: %s\n", usbf_errstr(err));
! 1011: pipe->running = 0;
! 1012: /* XXX do what? */
! 1013: }
! 1014: }
! 1015: }
! 1016:
! 1017: /* Called at splusb() */
! 1018: void
! 1019: usbf_transfer_complete(usbf_xfer_handle xfer)
! 1020: {
! 1021: usbf_pipe_handle pipe = xfer->pipe;
! 1022: int repeat = pipe->repeat;
! 1023:
! 1024: SPLUSBCHECK;
! 1025: DPRINTF(1,("usbf_transfer_complete: xfer=%p pipe=%p running=%d\n",
! 1026: xfer, pipe, pipe->running));
! 1027: #ifdef USBF_DEBUG
! 1028: if (usbfdebug > 0)
! 1029: usbf_dump_buffer(xfer);
! 1030: #endif
! 1031:
! 1032: if (!repeat) {
! 1033: /* Remove request from queue. */
! 1034: KASSERT(SIMPLEQ_FIRST(&pipe->queue) == xfer);
! 1035: SIMPLEQ_REMOVE_HEAD(&pipe->queue, next);
! 1036: }
! 1037:
! 1038: if (xfer->status == USBF_NORMAL_COMPLETION &&
! 1039: xfer->actlen < xfer->length &&
! 1040: !(xfer->flags & USBD_SHORT_XFER_OK)) {
! 1041: DPRINTF(0,("usbf_transfer_complete: short xfer=%p %u<%u\n",
! 1042: xfer, xfer->actlen, xfer->length));
! 1043: xfer->status = USBF_SHORT_XFER;
! 1044: }
! 1045:
! 1046: if (xfer->callback != NULL)
! 1047: xfer->callback(xfer, xfer->priv, xfer->status);
! 1048:
! 1049: pipe->methods->done(xfer);
! 1050:
! 1051: /* XXX wake up any processes waiting for the transfer to complete */
! 1052:
! 1053: if (!repeat) {
! 1054: if (xfer->status != USBF_NORMAL_COMPLETION &&
! 1055: pipe->iface != NULL) /* not control pipe */
! 1056: pipe->running = 0;
! 1057: else
! 1058: usbf_start_next(pipe);
! 1059: }
! 1060: }
! 1061:
! 1062: /*
! 1063: * Software interrupts
! 1064: */
! 1065:
! 1066: usbf_status
! 1067: usbf_softintr_establish(struct usbf_bus *bus)
! 1068: {
! 1069: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 1070: KASSERT(bus->soft == NULL);
! 1071: /* XXX we should have our own level */
! 1072: bus->soft = softintr_establish(IPL_SOFTNET,
! 1073: bus->methods->soft_intr, bus);
! 1074: if (bus->soft == NULL)
! 1075: return USBF_INVAL;
! 1076: #endif
! 1077: return USBF_NORMAL_COMPLETION;
! 1078: }
! 1079:
! 1080: void
! 1081: usbf_schedsoftintr(struct usbf_bus *bus)
! 1082: {
! 1083: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
! 1084: softintr_schedule(bus->soft);
! 1085: #else
! 1086: bus->methods->soft_intr(bus);
! 1087: #endif /* __HAVE_GENERIC_SOFT_INTERRUPTS */
! 1088: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to usbf_subr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb