1 /* $NetBSD: usbdi_util.c,v 1.42 2004/12/03 08:53:40 augustss Exp $ */
4 * Copyright (c) 1998 The NetBSD Foundation, Inc.
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart@augustsson.net) at
9 * Carlstedt Research & Technology.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
40 #include <sys/cdefs.h>
41 __FBSDID("$FreeBSD$");
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/kernel.h>
46 #include <sys/module.h>
47 #include <sys/malloc.h>
48 #if defined(__NetBSD__) || defined(__OpenBSD__)
50 #include <sys/device.h>
51 #elif defined(__FreeBSD__)
55 #include <dev/usb/usb.h>
56 #include <dev/usb/usbhid.h>
58 #include <dev/usb/usbdi.h>
59 #include <dev/usb/usbdi_util.h>
62 #define DPRINTF(x) if (usbdebug) logprintf x
63 #define DPRINTFN(n,x) if (usbdebug>(n)) logprintf x
71 usbd_get_desc(usbd_device_handle dev, int type, int index, int len, void *desc)
73 usb_device_request_t req;
75 DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n",
78 req.bmRequestType = UT_READ_DEVICE;
79 req.bRequest = UR_GET_DESCRIPTOR;
80 USETW2(req.wValue, type, index);
82 USETW(req.wLength, len);
83 return (usbd_do_request(dev, &req, desc));
87 usbd_get_config_desc(usbd_device_handle dev, int confidx,
88 usb_config_descriptor_t *d)
92 DPRINTFN(3,("usbd_get_config_desc: confidx=%d\n", confidx));
93 err = usbd_get_desc(dev, UDESC_CONFIG, confidx,
94 USB_CONFIG_DESCRIPTOR_SIZE, d);
97 if (d->bDescriptorType != UDESC_CONFIG) {
98 DPRINTFN(-1,("usbd_get_config_desc: confidx=%d, bad desc "
100 confidx, d->bLength, d->bDescriptorType));
103 return (USBD_NORMAL_COMPLETION);
107 usbd_get_config_desc_full(usbd_device_handle dev, int conf, void *d, int size)
109 DPRINTFN(3,("usbd_get_config_desc_full: conf=%d\n", conf));
110 return (usbd_get_desc(dev, UDESC_CONFIG, conf, size, d));
114 usbd_get_device_desc(usbd_device_handle dev, usb_device_descriptor_t *d)
116 DPRINTFN(3,("usbd_get_device_desc:\n"));
117 return (usbd_get_desc(dev, UDESC_DEVICE,
118 0, USB_DEVICE_DESCRIPTOR_SIZE, d));
122 usbd_get_device_status(usbd_device_handle dev, usb_status_t *st)
124 usb_device_request_t req;
126 req.bmRequestType = UT_READ_DEVICE;
127 req.bRequest = UR_GET_STATUS;
128 USETW(req.wValue, 0);
129 USETW(req.wIndex, 0);
130 USETW(req.wLength, sizeof(usb_status_t));
131 return (usbd_do_request(dev, &req, st));
135 usbd_get_hub_status(usbd_device_handle dev, usb_hub_status_t *st)
137 usb_device_request_t req;
139 req.bmRequestType = UT_READ_CLASS_DEVICE;
140 req.bRequest = UR_GET_STATUS;
141 USETW(req.wValue, 0);
142 USETW(req.wIndex, 0);
143 USETW(req.wLength, sizeof(usb_hub_status_t));
144 return (usbd_do_request(dev, &req, st));
148 usbd_set_address(usbd_device_handle dev, int addr)
150 usb_device_request_t req;
152 req.bmRequestType = UT_WRITE_DEVICE;
153 req.bRequest = UR_SET_ADDRESS;
154 USETW(req.wValue, addr);
155 USETW(req.wIndex, 0);
156 USETW(req.wLength, 0);
157 return usbd_do_request(dev, &req, 0);
161 usbd_get_port_status(usbd_device_handle dev, int port, usb_port_status_t *ps)
163 usb_device_request_t req;
165 req.bmRequestType = UT_READ_CLASS_OTHER;
166 req.bRequest = UR_GET_STATUS;
167 USETW(req.wValue, 0);
168 USETW(req.wIndex, port);
169 USETW(req.wLength, sizeof *ps);
170 return (usbd_do_request(dev, &req, ps));
174 usbd_clear_hub_feature(usbd_device_handle dev, int sel)
176 usb_device_request_t req;
178 req.bmRequestType = UT_WRITE_CLASS_DEVICE;
179 req.bRequest = UR_CLEAR_FEATURE;
180 USETW(req.wValue, sel);
181 USETW(req.wIndex, 0);
182 USETW(req.wLength, 0);
183 return (usbd_do_request(dev, &req, 0));
187 usbd_set_hub_feature(usbd_device_handle dev, int sel)
189 usb_device_request_t req;
191 req.bmRequestType = UT_WRITE_CLASS_DEVICE;
192 req.bRequest = UR_SET_FEATURE;
193 USETW(req.wValue, sel);
194 USETW(req.wIndex, 0);
195 USETW(req.wLength, 0);
196 return (usbd_do_request(dev, &req, 0));
200 usbd_clear_port_feature(usbd_device_handle dev, int port, int sel)
202 usb_device_request_t req;
204 req.bmRequestType = UT_WRITE_CLASS_OTHER;
205 req.bRequest = UR_CLEAR_FEATURE;
206 USETW(req.wValue, sel);
207 USETW(req.wIndex, port);
208 USETW(req.wLength, 0);
209 return (usbd_do_request(dev, &req, 0));
213 usbd_set_port_feature(usbd_device_handle dev, int port, int sel)
215 usb_device_request_t req;
217 req.bmRequestType = UT_WRITE_CLASS_OTHER;
218 req.bRequest = UR_SET_FEATURE;
219 USETW(req.wValue, sel);
220 USETW(req.wIndex, port);
221 USETW(req.wLength, 0);
222 return (usbd_do_request(dev, &req, 0));
226 usbd_get_protocol(usbd_interface_handle iface, u_int8_t *report)
228 usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
229 usbd_device_handle dev;
230 usb_device_request_t req;
232 DPRINTFN(4, ("usbd_get_protocol: iface=%p, endpt=%d\n",
233 iface, id->bInterfaceNumber));
235 return (USBD_IOERROR);
236 usbd_interface2device_handle(iface, &dev);
237 req.bmRequestType = UT_READ_CLASS_INTERFACE;
238 req.bRequest = UR_GET_PROTOCOL;
239 USETW(req.wValue, 0);
240 USETW(req.wIndex, id->bInterfaceNumber);
241 USETW(req.wLength, 1);
242 return (usbd_do_request(dev, &req, report));
246 usbd_set_protocol(usbd_interface_handle iface, int report)
248 usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
249 usbd_device_handle dev;
250 usb_device_request_t req;
252 DPRINTFN(4, ("usbd_set_protocol: iface=%p, report=%d, endpt=%d\n",
253 iface, report, id->bInterfaceNumber));
255 return (USBD_IOERROR);
256 usbd_interface2device_handle(iface, &dev);
257 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
258 req.bRequest = UR_SET_PROTOCOL;
259 USETW(req.wValue, report);
260 USETW(req.wIndex, id->bInterfaceNumber);
261 USETW(req.wLength, 0);
262 return (usbd_do_request(dev, &req, 0));
266 usbd_set_report(usbd_interface_handle iface, int type, int id, void *data,
269 usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
270 usbd_device_handle dev;
271 usb_device_request_t req;
273 DPRINTFN(4, ("usbd_set_report: len=%d\n", len));
275 return (USBD_IOERROR);
276 usbd_interface2device_handle(iface, &dev);
277 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
278 req.bRequest = UR_SET_REPORT;
279 USETW2(req.wValue, type, id);
280 USETW(req.wIndex, ifd->bInterfaceNumber);
281 USETW(req.wLength, len);
282 return (usbd_do_request(dev, &req, data));
286 usbd_set_report_async(usbd_interface_handle iface, int type, int id, void *data,
289 usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
290 usbd_device_handle dev;
291 usb_device_request_t req;
293 DPRINTFN(4, ("usbd_set_report_async: len=%d\n", len));
295 return (USBD_IOERROR);
296 usbd_interface2device_handle(iface, &dev);
297 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
298 req.bRequest = UR_SET_REPORT;
299 USETW2(req.wValue, type, id);
300 USETW(req.wIndex, ifd->bInterfaceNumber);
301 USETW(req.wLength, len);
302 return (usbd_do_request_async(dev, &req, data));
306 usbd_get_report(usbd_interface_handle iface, int type, int id, void *data,
309 usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
310 usbd_device_handle dev;
311 usb_device_request_t req;
313 DPRINTFN(4, ("usbd_get_report: len=%d\n", len));
315 return (USBD_IOERROR);
316 usbd_interface2device_handle(iface, &dev);
317 req.bmRequestType = UT_READ_CLASS_INTERFACE;
318 req.bRequest = UR_GET_REPORT;
319 USETW2(req.wValue, type, id);
320 USETW(req.wIndex, ifd->bInterfaceNumber);
321 USETW(req.wLength, len);
322 return (usbd_do_request(dev, &req, data));
326 usbd_set_idle(usbd_interface_handle iface, int duration, int id)
328 usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
329 usbd_device_handle dev;
330 usb_device_request_t req;
332 DPRINTFN(4, ("usbd_set_idle: %d %d\n", duration, id));
334 return (USBD_IOERROR);
335 usbd_interface2device_handle(iface, &dev);
336 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
337 req.bRequest = UR_SET_IDLE;
338 USETW2(req.wValue, duration, id);
339 USETW(req.wIndex, ifd->bInterfaceNumber);
340 USETW(req.wLength, 0);
341 return (usbd_do_request(dev, &req, 0));
345 usbd_get_report_descriptor(usbd_device_handle dev, int ifcno,
348 usb_device_request_t req;
350 req.bmRequestType = UT_READ_INTERFACE;
351 req.bRequest = UR_GET_DESCRIPTOR;
352 USETW2(req.wValue, UDESC_REPORT, 0); /* report id should be 0 */
353 USETW(req.wIndex, ifcno);
354 USETW(req.wLength, size);
355 return (usbd_do_request(dev, &req, d));
358 usb_hid_descriptor_t *
359 usbd_get_hid_descriptor(usbd_interface_handle ifc)
361 usb_interface_descriptor_t *idesc = usbd_get_interface_descriptor(ifc);
362 usbd_device_handle dev;
363 usb_config_descriptor_t *cdesc;
364 usb_hid_descriptor_t *hd;
369 usbd_interface2device_handle(ifc, &dev);
370 cdesc = usbd_get_config_descriptor(dev);
372 p = (char *)idesc + idesc->bLength;
373 end = (char *)cdesc + UGETW(cdesc->wTotalLength);
375 for (; p < end; p += hd->bLength) {
376 hd = (usb_hid_descriptor_t *)p;
377 if (p + hd->bLength <= end && hd->bDescriptorType == UDESC_HID)
379 if (hd->bDescriptorType == UDESC_INTERFACE)
386 usbd_read_report_desc(usbd_interface_handle ifc, void **descp, int *sizep,
389 usb_interface_descriptor_t *id;
390 usb_hid_descriptor_t *hid;
391 usbd_device_handle dev;
394 usbd_interface2device_handle(ifc, &dev);
395 id = usbd_get_interface_descriptor(ifc);
398 hid = usbd_get_hid_descriptor(ifc);
400 return (USBD_IOERROR);
401 *sizep = UGETW(hid->descrs[0].wDescriptorLength);
402 *descp = malloc(*sizep, mem, M_NOWAIT);
405 err = usbd_get_report_descriptor(dev, id->bInterfaceNumber,
412 return (USBD_NORMAL_COMPLETION);
416 usbd_get_config(usbd_device_handle dev, u_int8_t *conf)
418 usb_device_request_t req;
420 req.bmRequestType = UT_READ_DEVICE;
421 req.bRequest = UR_GET_CONFIG;
422 USETW(req.wValue, 0);
423 USETW(req.wIndex, 0);
424 USETW(req.wLength, 1);
425 return (usbd_do_request(dev, &req, conf));
428 Static void usbd_bulk_transfer_cb(usbd_xfer_handle xfer,
429 usbd_private_handle priv, usbd_status status);
431 usbd_bulk_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
438 usbd_bulk_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
439 u_int16_t flags, u_int32_t timeout, void *buf,
440 u_int32_t *size, char *lbl)
445 usbd_setup_xfer(xfer, pipe, 0, buf, *size,
446 flags, timeout, usbd_bulk_transfer_cb);
447 DPRINTFN(1, ("usbd_bulk_transfer: start transfer %d bytes\n", *size));
448 s = splusb(); /* don't want callback until tsleep() */
449 err = usbd_transfer(xfer);
450 if (err != USBD_IN_PROGRESS) {
454 error = tsleep((caddr_t)xfer, PZERO | PCATCH, lbl, 0);
457 DPRINTF(("usbd_bulk_transfer: tsleep=%d\n", error));
458 usbd_abort_pipe(pipe);
459 return (USBD_INTERRUPTED);
461 usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
462 DPRINTFN(1,("usbd_bulk_transfer: transferred %d\n", *size));
464 DPRINTF(("usbd_bulk_transfer: error=%d\n", err));
465 usbd_clear_endpoint_stall(pipe);
470 Static void usbd_intr_transfer_cb(usbd_xfer_handle xfer,
471 usbd_private_handle priv, usbd_status status);
473 usbd_intr_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
480 usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
481 u_int16_t flags, u_int32_t timeout, void *buf,
482 u_int32_t *size, char *lbl)
487 usbd_setup_xfer(xfer, pipe, 0, buf, *size,
488 flags, timeout, usbd_intr_transfer_cb);
489 DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes\n", *size));
490 s = splusb(); /* don't want callback until tsleep() */
491 err = usbd_transfer(xfer);
492 if (err != USBD_IN_PROGRESS) {
496 error = tsleep(xfer, PZERO | PCATCH, lbl, 0);
499 DPRINTF(("usbd_intr_transfer: tsleep=%d\n", error));
500 usbd_abort_pipe(pipe);
501 return (USBD_INTERRUPTED);
503 usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
504 DPRINTFN(1,("usbd_intr_transfer: transferred %d\n", *size));
506 DPRINTF(("usbd_intr_transfer: error=%d\n", err));
507 usbd_clear_endpoint_stall(pipe);
513 usb_detach_wait(device_ptr_t dv)
515 DPRINTF(("usb_detach_wait: waiting for %s\n", USBDEVPTRNAME(dv)));
516 if (tsleep(dv, PZERO, "usbdet", hz * 60))
517 printf("usb_detach_wait: %s didn't detach\n",
519 DPRINTF(("usb_detach_wait: %s done\n", USBDEVPTRNAME(dv)));
523 usb_detach_wakeup(device_ptr_t dv)
525 DPRINTF(("usb_detach_wakeup: for %s\n", USBDEVPTRNAME(dv)));
529 const usb_descriptor_t *
530 usb_find_desc(usbd_device_handle dev, int type, int subtype)
532 usbd_desc_iter_t iter;
533 const usb_descriptor_t *desc;
535 usb_desc_iter_init(dev, &iter);
537 desc = usb_desc_iter_next(&iter);
538 if (!desc || (desc->bDescriptorType == type &&
539 (subtype == USBD_SUBTYPE_ANY ||
540 subtype == desc->bDescriptorSubtype)))