Annotation of sys/dev/usb/usbdi_util.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: usbdi_util.c,v 1.24 2007/06/18 11:53:11 mbalmer Exp $ */
2: /* $NetBSD: usbdi_util.c,v 1.40 2002/07/11 21:14:36 augustss Exp $ */
3: /* $FreeBSD: src/sys/dev/usb/usbdi_util.c,v 1.14 1999/11/17 22:33:50 n_hibma Exp $ */
4:
5: /*
6: * Copyright (c) 1998 The NetBSD Foundation, Inc.
7: * All rights reserved.
8: *
9: * This code is derived from software contributed to The NetBSD Foundation
10: * by Lennart Augustsson (lennart@augustsson.net) at
11: * Carlstedt Research & Technology.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. All advertising materials mentioning features or use of this software
22: * must display the following acknowledgement:
23: * This product includes software developed by the NetBSD
24: * Foundation, Inc. and its contributors.
25: * 4. Neither the name of The NetBSD Foundation nor the names of its
26: * contributors may be used to endorse or promote products derived
27: * from this software without specific prior written permission.
28: *
29: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
30: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
31: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
32: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
33: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39: * POSSIBILITY OF SUCH DAMAGE.
40: */
41:
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/kernel.h>
45: #include <sys/malloc.h>
46: #include <sys/proc.h>
47: #include <sys/device.h>
48:
49: #include <dev/usb/usb.h>
50: #include <dev/usb/usbhid.h>
51:
52: #include <dev/usb/usbdi.h>
53: #include <dev/usb/usbdi_util.h>
54:
55: #ifdef USB_DEBUG
56: #define DPRINTF(x) do { if (usbdebug) printf x; } while (0)
57: #define DPRINTFN(n,x) do { if (usbdebug>(n)) printf x; } while (0)
58: extern int usbdebug;
59: #else
60: #define DPRINTF(x)
61: #define DPRINTFN(n,x)
62: #endif
63:
64: usbd_status
65: usbd_get_desc(usbd_device_handle dev, int type, int index, int len, void *desc)
66: {
67: usb_device_request_t req;
68:
69: DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n", type, index,
70: len));
71:
72: req.bmRequestType = UT_READ_DEVICE;
73: req.bRequest = UR_GET_DESCRIPTOR;
74: USETW2(req.wValue, type, index);
75: USETW(req.wIndex, 0);
76: USETW(req.wLength, len);
77: return (usbd_do_request(dev, &req, desc));
78: }
79:
80: usbd_status
81: usbd_get_config_desc(usbd_device_handle dev, int confidx,
82: usb_config_descriptor_t *d)
83: {
84: usbd_status err;
85:
86: DPRINTFN(3,("usbd_get_config_desc: confidx=%d\n", confidx));
87: err = usbd_get_desc(dev, UDESC_CONFIG, confidx,
88: USB_CONFIG_DESCRIPTOR_SIZE, d);
89: if (err)
90: return (err);
91: if (d->bDescriptorType != UDESC_CONFIG) {
92: DPRINTFN(-1,("usbd_get_config_desc: confidx=%d, bad desc "
93: "len=%d type=%d\n", confidx, d->bLength,
94: d->bDescriptorType));
95: return (USBD_INVAL);
96: }
97: return (USBD_NORMAL_COMPLETION);
98: }
99:
100: usbd_status
101: usbd_get_config_desc_full(usbd_device_handle dev, int conf, void *d, int size)
102: {
103: DPRINTFN(3,("usbd_get_config_desc_full: conf=%d\n", conf));
104: return (usbd_get_desc(dev, UDESC_CONFIG, conf, size, d));
105: }
106:
107: usbd_status
108: usbd_get_device_desc(usbd_device_handle dev, usb_device_descriptor_t *d)
109: {
110: DPRINTFN(3,("usbd_get_device_desc:\n"));
111: return (usbd_get_desc(dev, UDESC_DEVICE, 0, USB_DEVICE_DESCRIPTOR_SIZE,
112: d));
113: }
114:
115: usbd_status
116: usbd_get_device_status(usbd_device_handle dev, usb_status_t *st)
117: {
118: usb_device_request_t req;
119:
120: req.bmRequestType = UT_READ_DEVICE;
121: req.bRequest = UR_GET_STATUS;
122: USETW(req.wValue, 0);
123: USETW(req.wIndex, 0);
124: USETW(req.wLength, sizeof(usb_status_t));
125: return (usbd_do_request(dev, &req, st));
126: }
127:
128: usbd_status
129: usbd_get_hub_status(usbd_device_handle dev, usb_hub_status_t *st)
130: {
131: usb_device_request_t req;
132:
133: req.bmRequestType = UT_READ_CLASS_DEVICE;
134: req.bRequest = UR_GET_STATUS;
135: USETW(req.wValue, 0);
136: USETW(req.wIndex, 0);
137: USETW(req.wLength, sizeof(usb_hub_status_t));
138: return (usbd_do_request(dev, &req, st));
139: }
140:
141: usbd_status
142: usbd_set_address(usbd_device_handle dev, int addr)
143: {
144: usb_device_request_t req;
145:
146: req.bmRequestType = UT_WRITE_DEVICE;
147: req.bRequest = UR_SET_ADDRESS;
148: USETW(req.wValue, addr);
149: USETW(req.wIndex, 0);
150: USETW(req.wLength, 0);
151: return usbd_do_request(dev, &req, 0);
152: }
153:
154: usbd_status
155: usbd_get_port_status(usbd_device_handle dev, int port, usb_port_status_t *ps)
156: {
157: usb_device_request_t req;
158:
159: req.bmRequestType = UT_READ_CLASS_OTHER;
160: req.bRequest = UR_GET_STATUS;
161: USETW(req.wValue, 0);
162: USETW(req.wIndex, port);
163: USETW(req.wLength, sizeof *ps);
164: return (usbd_do_request(dev, &req, ps));
165: }
166:
167: usbd_status
168: usbd_clear_hub_feature(usbd_device_handle dev, int sel)
169: {
170: usb_device_request_t req;
171:
172: req.bmRequestType = UT_WRITE_CLASS_DEVICE;
173: req.bRequest = UR_CLEAR_FEATURE;
174: USETW(req.wValue, sel);
175: USETW(req.wIndex, 0);
176: USETW(req.wLength, 0);
177: return (usbd_do_request(dev, &req, 0));
178: }
179:
180: usbd_status
181: usbd_set_hub_feature(usbd_device_handle dev, int sel)
182: {
183: usb_device_request_t req;
184:
185: req.bmRequestType = UT_WRITE_CLASS_DEVICE;
186: req.bRequest = UR_SET_FEATURE;
187: USETW(req.wValue, sel);
188: USETW(req.wIndex, 0);
189: USETW(req.wLength, 0);
190: return (usbd_do_request(dev, &req, 0));
191: }
192:
193: usbd_status
194: usbd_clear_port_feature(usbd_device_handle dev, int port, int sel)
195: {
196: usb_device_request_t req;
197:
198: req.bmRequestType = UT_WRITE_CLASS_OTHER;
199: req.bRequest = UR_CLEAR_FEATURE;
200: USETW(req.wValue, sel);
201: USETW(req.wIndex, port);
202: USETW(req.wLength, 0);
203: return (usbd_do_request(dev, &req, 0));
204: }
205:
206: usbd_status
207: usbd_set_port_feature(usbd_device_handle dev, int port, int sel)
208: {
209: usb_device_request_t req;
210:
211: req.bmRequestType = UT_WRITE_CLASS_OTHER;
212: req.bRequest = UR_SET_FEATURE;
213: USETW(req.wValue, sel);
214: USETW(req.wIndex, port);
215: USETW(req.wLength, 0);
216: return (usbd_do_request(dev, &req, 0));
217: }
218:
219: usbd_status
220: usbd_get_protocol(usbd_interface_handle iface, u_int8_t *report)
221: {
222: usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
223: usbd_device_handle dev;
224: usb_device_request_t req;
225:
226: DPRINTFN(4, ("usbd_get_protocol: iface=%p, endpt=%d\n", iface,
227: id->bInterfaceNumber));
228: if (id == NULL)
229: return (USBD_IOERROR);
230: usbd_interface2device_handle(iface, &dev);
231: req.bmRequestType = UT_READ_CLASS_INTERFACE;
232: req.bRequest = UR_GET_PROTOCOL;
233: USETW(req.wValue, 0);
234: USETW(req.wIndex, id->bInterfaceNumber);
235: USETW(req.wLength, 1);
236: return (usbd_do_request(dev, &req, report));
237: }
238:
239: usbd_status
240: usbd_set_protocol(usbd_interface_handle iface, int report)
241: {
242: usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
243: usbd_device_handle dev;
244: usb_device_request_t req;
245:
246: DPRINTFN(4, ("usbd_set_protocol: iface=%p, report=%d, endpt=%d\n",
247: iface, report, id->bInterfaceNumber));
248: if (id == NULL)
249: return (USBD_IOERROR);
250: usbd_interface2device_handle(iface, &dev);
251: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
252: req.bRequest = UR_SET_PROTOCOL;
253: USETW(req.wValue, report);
254: USETW(req.wIndex, id->bInterfaceNumber);
255: USETW(req.wLength, 0);
256: return (usbd_do_request(dev, &req, 0));
257: }
258:
259: usbd_status
260: usbd_set_report(usbd_interface_handle iface, int type, int id, void *data,
261: int len)
262: {
263: usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
264: usbd_device_handle dev;
265: usb_device_request_t req;
266:
267: DPRINTFN(4, ("usbd_set_report: len=%d\n", len));
268: if (ifd == NULL)
269: return (USBD_IOERROR);
270: usbd_interface2device_handle(iface, &dev);
271: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
272: req.bRequest = UR_SET_REPORT;
273: USETW2(req.wValue, type, id);
274: USETW(req.wIndex, ifd->bInterfaceNumber);
275: USETW(req.wLength, len);
276: return (usbd_do_request(dev, &req, data));
277: }
278:
279: usbd_status
280: usbd_set_report_async(usbd_interface_handle iface, int type, int id,
281: void *data, int len)
282: {
283: usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
284: usbd_device_handle dev;
285: usb_device_request_t req;
286:
287: DPRINTFN(4, ("usbd_set_report_async: len=%d\n", len));
288: if (ifd == NULL)
289: return (USBD_IOERROR);
290: usbd_interface2device_handle(iface, &dev);
291: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
292: req.bRequest = UR_SET_REPORT;
293: USETW2(req.wValue, type, id);
294: USETW(req.wIndex, ifd->bInterfaceNumber);
295: USETW(req.wLength, len);
296: return (usbd_do_request_async(dev, &req, data));
297: }
298:
299: usbd_status
300: usbd_get_report(usbd_interface_handle iface, int type, int id, void *data,
301: int len)
302: {
303: usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
304: usbd_device_handle dev;
305: usb_device_request_t req;
306:
307: DPRINTFN(4, ("usbd_get_report: len=%d\n", len));
308: if (ifd == NULL)
309: return (USBD_IOERROR);
310: usbd_interface2device_handle(iface, &dev);
311: req.bmRequestType = UT_READ_CLASS_INTERFACE;
312: req.bRequest = UR_GET_REPORT;
313: USETW2(req.wValue, type, id);
314: USETW(req.wIndex, ifd->bInterfaceNumber);
315: USETW(req.wLength, len);
316: return (usbd_do_request(dev, &req, data));
317: }
318:
319: usbd_status
320: usbd_set_idle(usbd_interface_handle iface, int duration, int id)
321: {
322: usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
323: usbd_device_handle dev;
324: usb_device_request_t req;
325:
326: DPRINTFN(4, ("usbd_set_idle: %d %d\n", duration, id));
327: if (ifd == NULL)
328: return (USBD_IOERROR);
329: usbd_interface2device_handle(iface, &dev);
330: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
331: req.bRequest = UR_SET_IDLE;
332: USETW2(req.wValue, duration, id);
333: USETW(req.wIndex, ifd->bInterfaceNumber);
334: USETW(req.wLength, 0);
335: return (usbd_do_request(dev, &req, 0));
336: }
337:
338: usbd_status
339: usbd_get_report_descriptor(usbd_device_handle dev, int ifcno, int size,
340: void *d)
341: {
342: usb_device_request_t req;
343:
344: req.bmRequestType = UT_READ_INTERFACE;
345: req.bRequest = UR_GET_DESCRIPTOR;
346: USETW2(req.wValue, UDESC_REPORT, 0); /* report id should be 0 */
347: USETW(req.wIndex, ifcno);
348: USETW(req.wLength, size);
349: return (usbd_do_request(dev, &req, d));
350: }
351:
352: usb_hid_descriptor_t *
353: usbd_get_hid_descriptor(usbd_interface_handle ifc)
354: {
355: usb_interface_descriptor_t *idesc = usbd_get_interface_descriptor(ifc);
356: usbd_device_handle dev;
357: usb_config_descriptor_t *cdesc;
358: usb_hid_descriptor_t *hd;
359: char *p, *end;
360:
361: if (idesc == NULL)
362: return (0);
363: usbd_interface2device_handle(ifc, &dev);
364: cdesc = usbd_get_config_descriptor(dev);
365:
366: p = (char *)idesc + idesc->bLength;
367: end = (char *)cdesc + UGETW(cdesc->wTotalLength);
368:
369: for (; p < end; p += hd->bLength) {
370: hd = (usb_hid_descriptor_t *)p;
371: if (p + hd->bLength <= end && hd->bDescriptorType == UDESC_HID)
372: return (hd);
373: if (hd->bDescriptorType == UDESC_INTERFACE)
374: break;
375: }
376: return (0);
377: }
378:
379: usbd_status
380: usbd_read_report_desc(usbd_interface_handle ifc, void **descp, int *sizep,
381: int mem)
382: {
383: usb_interface_descriptor_t *id;
384: usb_hid_descriptor_t *hid;
385: usbd_device_handle dev;
386: usbd_status err;
387:
388: usbd_interface2device_handle(ifc, &dev);
389: id = usbd_get_interface_descriptor(ifc);
390: if (id == NULL)
391: return (USBD_INVAL);
392: hid = usbd_get_hid_descriptor(ifc);
393: if (hid == NULL)
394: return (USBD_IOERROR);
395: *sizep = UGETW(hid->descrs[0].wDescriptorLength);
396: *descp = malloc(*sizep, mem, M_NOWAIT);
397: if (*descp == NULL)
398: return (USBD_NOMEM);
399: err = usbd_get_report_descriptor(dev, id->bInterfaceNumber, *sizep,
400: *descp);
401: if (err) {
402: free(*descp, mem);
403: *descp = NULL;
404: return (err);
405: }
406: return (USBD_NORMAL_COMPLETION);
407: }
408:
409: usbd_status
410: usbd_get_config(usbd_device_handle dev, u_int8_t *conf)
411: {
412: usb_device_request_t req;
413:
414: req.bmRequestType = UT_READ_DEVICE;
415: req.bRequest = UR_GET_CONFIG;
416: USETW(req.wValue, 0);
417: USETW(req.wIndex, 0);
418: USETW(req.wLength, 1);
419: return (usbd_do_request(dev, &req, conf));
420: }
421:
422: void usbd_bulk_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
423: usbd_status status);
424: void
425: usbd_bulk_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
426: usbd_status status)
427: {
428: wakeup(xfer);
429: }
430:
431: usbd_status
432: usbd_bulk_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
433: u_int16_t flags, u_int32_t timeout, void *buf, u_int32_t *size, char *lbl)
434: {
435: usbd_status err;
436: int s, error;
437:
438: usbd_setup_xfer(xfer, pipe, 0, buf, *size, flags, timeout,
439: usbd_bulk_transfer_cb);
440: DPRINTFN(1, ("usbd_bulk_transfer: start transfer %d bytes\n", *size));
441: s = splusb(); /* don't want callback until tsleep() */
442: err = usbd_transfer(xfer);
443: if (err != USBD_IN_PROGRESS) {
444: splx(s);
445: return (err);
446: }
447: error = tsleep((caddr_t)xfer, PZERO | PCATCH, lbl, 0);
448: splx(s);
449: if (error) {
450: DPRINTF(("usbd_bulk_transfer: tsleep=%d\n", error));
451: usbd_abort_pipe(pipe);
452: return (USBD_INTERRUPTED);
453: }
454: usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
455: DPRINTFN(1,("usbd_bulk_transfer: transferred %d\n", *size));
456: if (err) {
457: DPRINTF(("usbd_bulk_transfer: error=%d\n", err));
458: usbd_clear_endpoint_stall(pipe);
459: }
460: return (err);
461: }
462:
463: void usbd_intr_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
464: usbd_status status);
465: void
466: usbd_intr_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
467: usbd_status status)
468: {
469: wakeup(xfer);
470: }
471:
472: usbd_status
473: usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
474: u_int16_t flags, u_int32_t timeout, void *buf, u_int32_t *size, char *lbl)
475: {
476: usbd_status err;
477: int s, error;
478:
479: usbd_setup_xfer(xfer, pipe, 0, buf, *size, flags, timeout,
480: usbd_intr_transfer_cb);
481: DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes\n", *size));
482: s = splusb(); /* don't want callback until tsleep() */
483: err = usbd_transfer(xfer);
484: if (err != USBD_IN_PROGRESS) {
485: splx(s);
486: return (err);
487: }
488: error = tsleep(xfer, PZERO | PCATCH, lbl, 0);
489: splx(s);
490: if (error) {
491: DPRINTF(("usbd_intr_transfer: tsleep=%d\n", error));
492: usbd_abort_pipe(pipe);
493: return (USBD_INTERRUPTED);
494: }
495: usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
496: DPRINTFN(1,("usbd_intr_transfer: transferred %d\n", *size));
497: if (err) {
498: DPRINTF(("usbd_intr_transfer: error=%d\n", err));
499: usbd_clear_endpoint_stall(pipe);
500: }
501: return (err);
502: }
503:
504: void
505: usb_detach_wait(struct device *dv)
506: {
507: DPRINTF(("usb_detach_wait: waiting for %s\n", dv->dv_xname));
508: if (tsleep(dv, PZERO, "usbdet", hz * 60))
509: printf("usb_detach_wait: %s didn't detach\n", dv->dv_xname);
510: DPRINTF(("usb_detach_wait: %s done\n", dv->dv_xname));
511: }
512:
513: void
514: usb_detach_wakeup(struct device *dv)
515: {
516: DPRINTF(("usb_detach_wakeup: for %s\n", dv->dv_xname));
517: wakeup(dv);
518: }
519:
520: usb_descriptor_t *
521: usb_find_desc(usbd_device_handle dev, int type)
522: {
523: usb_descriptor_t *desc;
524: usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev);
525: uByte *p = (uByte *)cd;
526: uByte *end = p + UGETW(cd->wTotalLength);
527:
528: while (p < end) {
529: desc = (usb_descriptor_t *)p;
530: if (desc->bDescriptorType == type)
531: return (desc);
532: p += desc->bLength;
533: }
534:
535: return (NULL);
536: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to usbdi_util.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb