This source file includes following definitions.
- usbd_get_desc
- usbd_get_config_desc
- usbd_get_config_desc_full
- usbd_get_device_desc
- usbd_get_device_status
- usbd_get_hub_status
- usbd_set_address
- usbd_get_port_status
- usbd_clear_hub_feature
- usbd_set_hub_feature
- usbd_clear_port_feature
- usbd_set_port_feature
- usbd_get_protocol
- usbd_set_protocol
- usbd_set_report
- usbd_set_report_async
- usbd_get_report
- usbd_set_idle
- usbd_get_report_descriptor
- usbd_get_hid_descriptor
- usbd_read_report_desc
- usbd_get_config
- usbd_bulk_transfer_cb
- usbd_bulk_transfer
- usbd_intr_transfer_cb
- usbd_intr_transfer
- usb_detach_wait
- usb_detach_wakeup
- usb_find_desc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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);
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();
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();
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 }