Annotation of sys/dev/usb/usbf.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: usbf.c,v 1.9 2007/06/19 11:52:07 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 2.0 logical device driver
21: *
22: * Specification non-comformities:
23: *
24: * - not all Standard Device Requests are supported (see 9.4)
25: * - USB 2.0 devices (device_descriptor.bcdUSB >= 0x0200) must support
26: * the other_speed requests but we do not
27: *
28: * Missing functionality:
29: *
30: * - isochronous pipes/transfers
31: * - clever, automatic endpoint address assignment to make optimal use
32: * of available hardware endpoints
33: * - alternate settings for interfaces are unsupported
34: */
35:
36: /*
37: * The source code below is marked an can be split into a number of pieces
38: * (in that order):
39: *
40: * - USB logical device match/attach/detach
41: * - USB device tasks
42: * - Bus event handling
43: * - Device request handling
44: *
45: * Stylistic issues:
46: *
47: * - "endpoint number" and "endpoint address" are sometimes confused in
48: * this source code, OTOH the endpoint number is just the address, aside
49: * from the direction bit that is added to the number to form a unique
50: * endpoint address
51: */
52:
53: #include <sys/param.h>
54: #include <sys/device.h>
55: #include <sys/kthread.h>
56: #include <sys/malloc.h>
57: #include <sys/systm.h>
58:
59: #include <machine/bus.h>
60:
61: #include <dev/usb/usb.h>
62: #include <dev/usb/usbdi.h>
63: #include <dev/usb/usbdivar.h>
64: #include <dev/usb/usbf.h>
65: #include <dev/usb/usbfvar.h>
66:
67: #ifndef USBF_DEBUG
68: #define DPRINTF(l, x) do {} while (0)
69: #else
70: int usbfdebug = 0;
71: #define DPRINTF(l, x) if ((l) <= usbfdebug) printf x; else {}
72: #endif
73:
74: struct usbf_softc {
75: struct device sc_dev; /* base device */
76: usbf_bus_handle sc_bus; /* USB device controller */
77: struct usbf_port sc_port; /* dummy port for function */
78: struct proc *sc_proc; /* task thread */
79: TAILQ_HEAD(,usbf_task) sc_tskq; /* task queue head */
80: int sc_dying;
81: };
82:
83: #define DEVNAME(sc) ((sc)->sc_dev.dv_xname)
84:
85: int usbf_match(struct device *, void *, void *);
86: void usbf_attach(struct device *, struct device *, void *);
87: void usbf_create_thread(void *);
88: void usbf_task_thread(void *);
89:
90: usbf_status usbf_get_descriptor(usbf_device_handle, usb_device_request_t *,
91: void **);
92: void usbf_set_address(usbf_device_handle, u_int8_t);
93: usbf_status usbf_set_config(usbf_device_handle, u_int8_t);
94:
95: #ifdef USBF_DEBUG
96: void usbf_dump_request(usbf_device_handle, usb_device_request_t *);
97: #endif
98:
99: struct cfattach usbf_ca = {
100: sizeof(struct usbf_softc), usbf_match, usbf_attach
101: };
102:
103: struct cfdriver usbf_cd = {
104: NULL, "usbf", DV_DULL
105: };
106:
107: static const char * const usbrev_str[] = USBREV_STR;
108:
109: int
110: usbf_match(struct device *parent, void *match, void *aux)
111: {
112: return UMATCH_GENERIC;
113: }
114:
115: void
116: usbf_attach(struct device *parent, struct device *self, void *aux)
117: {
118: struct usbf_softc *sc = (struct usbf_softc *)self;
119: int usbrev;
120: int speed;
121: usbf_status err;
122:
123: /* Continue to set up the bus struct. */
124: sc->sc_bus = aux;
125: sc->sc_bus->usbfctl = sc;
126:
127: usbrev = sc->sc_bus->usbrev;
128: printf(": USB revision %s", usbrev_str[usbrev]);
129: switch (usbrev) {
130: case USBREV_2_0:
131: speed = USB_SPEED_HIGH;
132: break;
133: case USBREV_1_1:
134: case USBREV_1_0:
135: speed = USB_SPEED_FULL;
136: break;
137: default:
138: printf(", not supported\n");
139: sc->sc_dying = 1;
140: return;
141: }
142: printf("\n");
143:
144: /* Initialize the usbf struct. */
145: TAILQ_INIT(&sc->sc_tskq);
146:
147: /* Establish the software interrupt. */
148: if (usbf_softintr_establish(sc->sc_bus)) {
149: printf("%s: can't establish softintr\n", DEVNAME(sc));
150: sc->sc_dying = 1;
151: return;
152: }
153:
154: /* Attach the function driver. */
155: err = usbf_new_device(self, sc->sc_bus, 0, speed, 0, &sc->sc_port);
156: if (err) {
157: printf("%s: usbf_new_device failed, %s\n", DEVNAME(sc),
158: usbf_errstr(err));
159: sc->sc_dying = 1;
160: return;
161: }
162:
163: /* Create a process context for asynchronous tasks. */
164: config_pending_incr();
165: kthread_create_deferred(usbf_create_thread, sc);
166: }
167:
168: /*
169: * USB device tasks
170: */
171:
172: /*
173: * Add a task to be performed by the task thread. This function can be
174: * called from any context and the task function will be executed in a
175: * process context ASAP.
176: */
177: void
178: usbf_add_task(usbf_device_handle dev, struct usbf_task *task)
179: {
180: struct usbf_softc *sc = dev->bus->usbfctl;
181: int s;
182:
183: s = splusb();
184: if (!task->onqueue) {
185: DPRINTF(1,("usbf_add_task: task=%p, proc=%s\n",
186: task, sc->sc_bus->intr_context ? "(null)" :
187: curproc->p_comm));
188: TAILQ_INSERT_TAIL(&sc->sc_tskq, task, next);
189: task->onqueue = 1;
190: } else {
191: DPRINTF(0,("usbf_add_task: task=%p on q, proc=%s\n",
192: task, sc->sc_bus->intr_context ? "(null)" :
193: curproc->p_comm));
194: }
195: wakeup(&sc->sc_tskq);
196: splx(s);
197: }
198:
199: void
200: usbf_rem_task(usbf_device_handle dev, struct usbf_task *task)
201: {
202: struct usbf_softc *sc = dev->bus->usbfctl;
203: int s;
204:
205: s = splusb();
206: if (task->onqueue) {
207: DPRINTF(1,("usbf_rem_task: task=%p\n", task));
208: TAILQ_REMOVE(&sc->sc_tskq, task, next);
209: task->onqueue = 0;
210:
211: } else {
212: DPRINTF(0,("usbf_rem_task: task=%p not on q", task));
213: }
214: splx(s);
215: }
216:
217: /*
218: * Called from the kernel proper when it can create threads.
219: */
220: void
221: usbf_create_thread(void *arg)
222: {
223: struct usbf_softc *sc = arg;
224:
225: if (kthread_create(usbf_task_thread, sc, &sc->sc_proc, "%s",
226: DEVNAME(sc)) != 0) {
227: printf("%s: can't create task thread\n", DEVNAME(sc));
228: return;
229: }
230: config_pending_decr();
231: }
232:
233: /*
234: * Process context for USB function tasks.
235: */
236: void
237: usbf_task_thread(void *arg)
238: {
239: struct usbf_softc *sc = arg;
240: struct usbf_task *task;
241: int s;
242:
243: DPRINTF(0,("usbf_task_thread: start (pid %d)\n", curproc->p_pid));
244:
245: s = splusb();
246: while (!sc->sc_dying) {
247: task = TAILQ_FIRST(&sc->sc_tskq);
248: if (task == NULL) {
249: tsleep(&sc->sc_tskq, PWAIT, "usbtsk", 0);
250: task = TAILQ_FIRST(&sc->sc_tskq);
251: }
252: DPRINTF(1,("usbf_task_thread: woke up task=%p\n", task));
253: if (task != NULL) {
254: TAILQ_REMOVE(&sc->sc_tskq, task, next);
255: task->onqueue = 0;
256: splx(s);
257: task->fun(task->arg);
258: s = splusb();
259: DPRINTF(1,("usbf_task_thread: done task=%p\n", task));
260: }
261: }
262: splx(s);
263:
264: DPRINTF(0,("usbf_task_thread: exit\n"));
265: kthread_exit(0);
266: }
267:
268: /*
269: * Bus event handling
270: */
271:
272: void
273: usbf_host_reset(usbf_bus_handle bus)
274: {
275: usbf_device_handle dev = bus->usbfctl->sc_port.device;
276:
277: DPRINTF(0,("usbf_host_reset\n"));
278:
279: /* Change device state from any state backe to Default. */
280: (void)usbf_set_config(dev, USB_UNCONFIG_NO);
281: dev->address = 0;
282: }
283:
284: /*
285: * Device request handling
286: */
287:
288: /* XXX */
289: static u_int8_t hs_config[65536];
290:
291: usbf_status
292: usbf_get_descriptor(usbf_device_handle dev, usb_device_request_t *req,
293: void **data)
294: {
295: u_int8_t type = UGETW(req->wValue) >> 8;
296: u_int8_t index = UGETW(req->wValue) & 0xff;
297: usb_device_descriptor_t *dd;
298: usb_config_descriptor_t *cd;
299: usb_string_descriptor_t *sd;
300:
301: switch (type) {
302: case UDESC_DEVICE:
303: dd = usbf_device_descriptor(dev);
304: *data = dd;
305: USETW(req->wLength, MIN(UGETW(req->wLength), dd->bLength));;
306: return USBF_NORMAL_COMPLETION;
307:
308: case UDESC_DEVICE_QUALIFIER: {
309: static usb_device_qualifier_t dq;
310:
311: dd = usbf_device_descriptor(dev);
312: bzero(&dq, sizeof dq);
313: dq.bLength = USB_DEVICE_QUALIFIER_SIZE;
314: dq.bDescriptorType = UDESC_DEVICE_QUALIFIER;
315: USETW(dq.bcdUSB, 0x0200);
316: dq.bDeviceClass = dd->bDeviceClass;
317: dq.bDeviceSubClass = dd->bDeviceSubClass;
318: dq.bDeviceProtocol = dd->bDeviceProtocol;
319: dq.bMaxPacketSize0 = dd->bMaxPacketSize;
320: dq.bNumConfigurations = dd->bNumConfigurations;
321: *data = &dq;
322: USETW(req->wLength, MIN(UGETW(req->wLength), dq.bLength));;
323: return USBF_NORMAL_COMPLETION;
324: }
325:
326: case UDESC_CONFIG:
327: cd = usbf_config_descriptor(dev, index);
328: if (cd == NULL)
329: return USBF_INVAL;
330: *data = cd;
331: USETW(req->wLength, MIN(UGETW(req->wLength),
332: UGETW(cd->wTotalLength)));
333: return USBF_NORMAL_COMPLETION;
334:
335: /* XXX */
336: case UDESC_OTHER_SPEED_CONFIGURATION:
337: cd = usbf_config_descriptor(dev, index);
338: if (cd == NULL)
339: return USBF_INVAL;
340: bcopy(cd, &hs_config, UGETW(cd->wTotalLength));
341: *data = &hs_config;
342: ((usb_config_descriptor_t *)&hs_config)->bDescriptorType =
343: UDESC_OTHER_SPEED_CONFIGURATION;
344: USETW(req->wLength, MIN(UGETW(req->wLength),
345: UGETW(cd->wTotalLength)));
346: return USBF_NORMAL_COMPLETION;
347:
348: case UDESC_STRING:
349: sd = usbf_string_descriptor(dev, index);
350: if (sd == NULL)
351: return USBF_INVAL;
352: *data = sd;
353: USETW(req->wLength, MIN(UGETW(req->wLength), sd->bLength));
354: return USBF_NORMAL_COMPLETION;
355:
356: default:
357: DPRINTF(0,("usbf_get_descriptor: unknown descriptor type=%u\n",
358: type));
359: return USBF_INVAL;
360: }
361: }
362:
363: /*
364: * Change device state from Default to Address, or change the device address
365: * if the device is not currently in the Default state.
366: */
367: void
368: usbf_set_address(usbf_device_handle dev, u_int8_t address)
369: {
370: DPRINTF(0,("usbf_set_address: dev=%p, %u -> %u\n", dev,
371: dev->address, address));
372: dev->address = address;
373: }
374:
375: /*
376: * If the device was in the Addressed state (dev->config == NULL) before, it
377: * will be in the Configured state upon successful return from this routine.
378: */
379: usbf_status
380: usbf_set_config(usbf_device_handle dev, u_int8_t new)
381: {
382: usbf_config_handle cfg = dev->config;
383: usbf_function_handle fun = dev->function;
384: usbf_status err = USBF_NORMAL_COMPLETION;
385: u_int8_t old = cfg ? cfg->uc_cdesc->bConfigurationValue :
386: USB_UNCONFIG_NO;
387:
388: if (old == new)
389: return USBF_NORMAL_COMPLETION;
390:
391: DPRINTF(0,("usbf_set_config: dev=%p, %u -> %u\n", dev, old, new));
392:
393: /*
394: * Resetting the device state to Unconfigured must always succeed.
395: * This happens typically when the host resets the bus.
396: */
397: if (new == USB_UNCONFIG_NO) {
398: if (dev->function->methods->set_config)
399: err = fun->methods->set_config(fun, NULL);
400: if (err) {
401: DPRINTF(0,("usbf_set_config: %s\n", usbf_errstr(err)));
402: }
403: dev->config = NULL;
404: return USBF_NORMAL_COMPLETION;
405: }
406:
407: /*
408: * Changing the device configuration may fail. The function
409: * may decline to set the new configuration.
410: */
411: SIMPLEQ_FOREACH(cfg, &dev->configs, next) {
412: if (cfg->uc_cdesc->bConfigurationValue == new) {
413: if (dev->function->methods->set_config)
414: err = fun->methods->set_config(fun, cfg);
415: if (!err)
416: dev->config = cfg;
417: return err;
418: }
419: }
420: return USBF_INVAL;
421: }
422:
423: /*
424: * Handle device requests coming in via endpoint 0 pipe.
425: */
426: void
427: usbf_do_request(usbf_xfer_handle xfer, usbf_private_handle priv,
428: usbf_status err)
429: {
430: usbf_device_handle dev = xfer->pipe->device;
431: usb_device_request_t *req = xfer->buffer;
432: usbf_config_handle cfg;
433: void *data = NULL;
434: u_int16_t value;
435: u_int16_t index;
436:
437: if (err) {
438: DPRINTF(0,("usbf_do_request: receive failed, %s\n",
439: usbf_errstr(err)));
440: return;
441: }
442:
443: #ifdef USBF_DEBUG
444: if (usbfdebug >= 0)
445: usbf_dump_request(dev, req);
446: #endif
447:
448: #define C(x,y) ((x) | ((y) << 8))
449: switch (C(req->bRequest, req->bmRequestType)) {
450:
451: case C(UR_SET_ADDRESS, UT_WRITE_DEVICE):
452: /* Change device state from Default to Address. */
453: usbf_set_address(dev, UGETW(req->wValue));
454: break;
455:
456: case C(UR_SET_CONFIG, UT_WRITE_DEVICE):
457: /* Change device state from Address to Configured. */
458: printf("set config activated\n");
459: err = usbf_set_config(dev, UGETW(req->wValue) & 0xff);
460: break;
461:
462: case C(UR_GET_CONFIG, UT_READ_DEVICE):
463: { /* XXX */
464: if ((cfg = dev->config) == NULL) {
465: static u_int8_t zero = 0;
466: data = &zero;
467: } else
468: data = &cfg->uc_cdesc->bConfigurationValue;
469: USETW(req->wLength, MIN(UGETW(req->wLength), 1));;
470: }
471: break;
472:
473: case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
474: err = usbf_get_descriptor(dev, req, &data);
475: break;
476:
477: case C(UR_GET_STATUS, UT_READ_DEVICE):
478: DPRINTF(1,("usbf_do_request: UR_GET_STATUS %d\n",
479: UGETW(req->wLength)));
480: data = &dev->status;
481: USETW(req->wLength, MIN(UGETW(req->wLength),
482: sizeof dev->status));
483: break;
484:
485: case C(UR_GET_STATUS, UT_READ_ENDPOINT): {
486: //u_int8_t addr = UGETW(req->wIndex) & 0xff;
487: static u_int16_t status = 0;
488:
489: data = &status;
490: USETW(req->wLength, MIN(UGETW(req->wLength), sizeof status));
491: break;
492: }
493:
494: case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT):
495: value = UGETW(req->wValue);
496: index = UGETW(req->wIndex);
497: if ((cfg = dev->config) == NULL)
498: err = USBF_STALLED;
499: else
500: err = usbf_set_endpoint_feature(cfg, index, value);
501: break;
502:
503: case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT):
504: value = UGETW(req->wValue);
505: index = UGETW(req->wIndex);
506: if ((cfg = dev->config) == NULL)
507: err = USBF_STALLED;
508: else
509: err = usbf_clear_endpoint_feature(cfg, index, value);
510: break;
511:
512: /* Alternate settings for interfaces are unsupported. */
513: case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE):
514: if (UGETW(req->wValue) != 0)
515: err = USBF_STALLED;
516: break;
517: case C(UR_GET_INTERFACE, UT_READ_INTERFACE): {
518: static u_int8_t zero = 0;
519: data = &zero;
520: USETW(req->wLength, MIN(UGETW(req->wLength), 1));
521: break;
522: }
523:
524: default: {
525: usbf_function_handle fun = dev->function;
526:
527: if (fun == NULL)
528: err = USBF_STALLED;
529: else
530: /* XXX change prototype for this method to remove
531: * XXX the data argument. */
532: err = fun->methods->do_request(fun, req, &data);
533: }
534: }
535:
536: if (err) {
537: DPRINTF(0,("usbf_do_request: request=%#x, type=%#x "
538: "failed, %s\n", req->bRequest, req->bmRequestType,
539: usbf_errstr(err)));
540: usbf_stall_pipe(dev->default_pipe);
541: } else if (UGETW(req->wLength) > 0) {
542: if (data == NULL) {
543: DPRINTF(0,("usbf_do_request: no data, "
544: "sending ZLP\n"));
545: USETW(req->wLength, 0);
546: }
547: /* Transfer IN data in response to the request. */
548: usbf_setup_xfer(dev->data_xfer, dev->default_pipe,
549: NULL, data, UGETW(req->wLength), 0, 0, NULL);
550: err = usbf_transfer(dev->data_xfer);
551: if (err && err != USBF_IN_PROGRESS) {
552: DPRINTF(0,("usbf_do_request: data xfer=%p, %s\n",
553: xfer, usbf_errstr(err)));
554: }
555: }
556:
557: /* Schedule another request transfer. */
558: usbf_setup_default_xfer(dev->default_xfer, dev->default_pipe,
559: NULL, &dev->def_req, 0, 0, usbf_do_request);
560: err = usbf_transfer(dev->default_xfer);
561: if (err && err != USBF_IN_PROGRESS) {
562: DPRINTF(0,("usbf_do_request: ctrl xfer=%p, %s\n", xfer,
563: usbf_errstr(err)));
564: }
565: }
566:
567: #ifdef USBF_DEBUG
568: struct usb_enum_str {
569: int code;
570: const char * const str;
571: };
572:
573: static const struct usb_enum_str usb_request_str[] = {
574: { UR_GET_STATUS, "GET STATUS" },
575: { UR_CLEAR_FEATURE, "CLEAR FEATURE" },
576: { UR_SET_FEATURE, "SET FEATURE" },
577: { UR_SET_ADDRESS, "SET ADDRESS" },
578: { UR_GET_DESCRIPTOR, "GET DESCRIPTOR" },
579: { UR_SET_DESCRIPTOR, "SET DESCRIPTOR" },
580: { UR_GET_CONFIG, "GET CONFIG" },
581: { UR_SET_CONFIG, "SET CONFIG" },
582: { UR_GET_INTERFACE, "GET INTERFACE" },
583: { UR_SET_INTERFACE, "SET INTERFACE" },
584: { UR_SYNCH_FRAME, "SYNCH FRAME" },
585: { 0, NULL }
586: };
587:
588: static const struct usb_enum_str usb_request_type_str[] = {
589: { UT_READ_DEVICE, "Read Device" },
590: { UT_READ_INTERFACE, "Read Interface" },
591: { UT_READ_ENDPOINT, "Read Endpoint" },
592: { UT_WRITE_DEVICE, "Write Device" },
593: { UT_WRITE_INTERFACE, "Write Interface" },
594: { UT_WRITE_ENDPOINT, "Write Endpoint" },
595: { UT_READ_CLASS_DEVICE, "Read Class Device" },
596: { UT_READ_CLASS_INTERFACE, "Read Class Interface" },
597: { UT_READ_CLASS_OTHER, "Read Class Other" },
598: { UT_READ_CLASS_ENDPOINT, "Read Class Endpoint" },
599: { UT_WRITE_CLASS_DEVICE, "Write Class Device" },
600: { UT_WRITE_CLASS_INTERFACE, "Write Class Interface" },
601: { UT_WRITE_CLASS_OTHER, "Write Class Other" },
602: { UT_WRITE_CLASS_ENDPOINT, "Write Class Endpoint" },
603: { UT_READ_VENDOR_DEVICE, "Read Vendor Device" },
604: { UT_READ_VENDOR_INTERFACE, "Read Vendor Interface" },
605: { UT_READ_VENDOR_OTHER, "Read Vendor Other" },
606: { UT_READ_VENDOR_ENDPOINT, "Read Vendor Endpoint" },
607: { UT_WRITE_VENDOR_DEVICE, "Write Vendor Device" },
608: { UT_WRITE_VENDOR_INTERFACE, "Write Vendor Interface" },
609: { UT_WRITE_VENDOR_OTHER, "Write Vendor Other" },
610: { UT_WRITE_VENDOR_ENDPOINT, "Write Vendor Endpoint" },
611: { 0, NULL }
612: };
613:
614: static const struct usb_enum_str usb_request_desc_str[] = {
615: { UDESC_DEVICE, "Device" },
616: { UDESC_CONFIG, "Configuration" },
617: { UDESC_STRING, "String" },
618: { UDESC_INTERFACE, "Interface" },
619: { UDESC_ENDPOINT, "Endpoint" },
620: { UDESC_DEVICE_QUALIFIER, "Device Qualifier" },
621: { UDESC_OTHER_SPEED_CONFIGURATION, "Other Speed Configuration" },
622: { UDESC_INTERFACE_POWER, "Interface Power" },
623: { UDESC_OTG, "OTG" },
624: { UDESC_CS_DEVICE, "Class-specific Device" },
625: { UDESC_CS_CONFIG, "Class-specific Configuration" },
626: { UDESC_CS_STRING, "Class-specific String" },
627: { UDESC_CS_INTERFACE, "Class-specific Interface" },
628: { UDESC_CS_ENDPOINT, "Class-specific Endpoint" },
629: { UDESC_HUB, "Hub" },
630: { 0, NULL }
631: };
632:
633: static const char *
634: usb_enum_string(const struct usb_enum_str *tab, int code)
635: {
636: static char buf[16];
637:
638: while (tab->str != NULL) {
639: if (tab->code == code)
640: return tab->str;
641: tab++;
642: }
643:
644: (void)snprintf(buf, sizeof buf, "0x%02x", code);
645: return buf;
646: }
647:
648: static const char *
649: usbf_request_code_string(usb_device_request_t *req)
650: {
651: static char buf[32];
652:
653: (void)snprintf(buf, sizeof buf, "%s",
654: usb_enum_string(usb_request_str, req->bRequest));
655: return buf;
656: }
657:
658: static const char *
659: usbf_request_type_string(usb_device_request_t *req)
660: {
661: static char buf[32];
662:
663: (void)snprintf(buf, sizeof buf, "%s",
664: usb_enum_string(usb_request_type_str, req->bmRequestType));
665: return buf;
666: }
667:
668: static const char *
669: usbf_request_desc_string(usb_device_request_t *req)
670: {
671: static char buf[32];
672: u_int8_t type = UGETW(req->wValue) >> 8;
673: u_int8_t index = UGETW(req->wValue) & 0xff;
674:
675: (void)snprintf(buf, sizeof buf, "%s/%u",
676: usb_enum_string(usb_request_desc_str, type), index);
677: return buf;
678: }
679:
680: void
681: usbf_dump_request(usbf_device_handle dev, usb_device_request_t *req)
682: {
683: struct usbf_softc *sc = dev->bus->usbfctl;
684:
685: printf("%s: %s request %s\n",
686: DEVNAME(sc), usbf_request_type_string(req),
687: usbf_request_code_string(req));
688:
689: if (req->bRequest == UR_GET_DESCRIPTOR)
690: printf("%s: VALUE: 0x%04x (%s)\n", DEVNAME(sc),
691: UGETW(req->wValue), usbf_request_desc_string(req));
692: else
693: printf("%s: VALUE: 0x%04x\n", DEVNAME(sc),
694: UGETW(req->wValue));
695:
696: printf("%s: INDEX: 0x%04x\n", DEVNAME(sc), UGETW(req->wIndex));
697: printf("%s: LENGTH: 0x%04x\n", DEVNAME(sc), UGETW(req->wLength));
698: }
699: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to usbf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb