uhidev.c revision 1.58 1 /* $NetBSD: uhidev.c,v 1.58 2013/10/05 07:05:01 skrll Exp $ */
2
3 /*
4 * Copyright (c) 2001, 2012 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart (at) augustsson.net) at
9 * Carlstedt Research & Technology and Matthew R. Green (mrg (at) eterna.com.au).
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /*
34 * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
35 */
36
37 #include <sys/cdefs.h>
38 __KERNEL_RCSID(0, "$NetBSD: uhidev.c,v 1.58 2013/10/05 07:05:01 skrll Exp $");
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/kernel.h>
43 #include <sys/malloc.h>
44 #include <sys/signalvar.h>
45 #include <sys/device.h>
46 #include <sys/ioctl.h>
47 #include <sys/conf.h>
48
49 #include <dev/usb/usb.h>
50 #include <dev/usb/usbhid.h>
51
52 #include <dev/usb/usbdevs.h>
53 #include <dev/usb/usbdi.h>
54 #include <dev/usb/usbdi_util.h>
55 #include <dev/usb/hid.h>
56 #include <dev/usb/usb_quirks.h>
57
58 #include <dev/usb/uhidev.h>
59
60 /* Report descriptor for broken Wacom Graphire */
61 #include <dev/usb/ugraphire_rdesc.h>
62 /* Report descriptor for game controllers in "XInput" mode */
63 #include <dev/usb/xinput_rdesc.h>
64
65 #include "locators.h"
66
67 #ifdef UHIDEV_DEBUG
68 #define DPRINTF(x) if (uhidevdebug) printf x
69 #define DPRINTFN(n,x) if (uhidevdebug>(n)) printf x
70 int uhidevdebug = 0;
71 #else
72 #define DPRINTF(x)
73 #define DPRINTFN(n,x)
74 #endif
75
76 Static void uhidev_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
77
78 Static int uhidev_maxrepid(void *, int);
79 Static int uhidevprint(void *, const char *);
80
81 int uhidev_match(device_t, cfdata_t, void *);
82 void uhidev_attach(device_t, device_t, void *);
83 void uhidev_childdet(device_t, device_t);
84 int uhidev_detach(device_t, int);
85 int uhidev_activate(device_t, enum devact);
86 extern struct cfdriver uhidev_cd;
87 CFATTACH_DECL2_NEW(uhidev, sizeof(struct uhidev_softc), uhidev_match,
88 uhidev_attach, uhidev_detach, uhidev_activate, NULL, uhidev_childdet);
89
90 int
91 uhidev_match(device_t parent, cfdata_t match, void *aux)
92 {
93 struct usbif_attach_arg *uaa = aux;
94
95 /* Game controllers in "XInput" mode */
96 if (USBIF_IS_XINPUT(uaa))
97 return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
98 if (uaa->class != UICLASS_HID)
99 return (UMATCH_NONE);
100 if (usbd_get_quirks(uaa->device)->uq_flags & UQ_HID_IGNORE)
101 return (UMATCH_NONE);
102 return (UMATCH_IFACECLASS_GENERIC);
103 }
104
105 void
106 uhidev_attach(device_t parent, device_t self, void *aux)
107 {
108 struct uhidev_softc *sc = device_private(self);
109 struct usbif_attach_arg *uaa = aux;
110 usbd_interface_handle iface = uaa->iface;
111 usb_interface_descriptor_t *id;
112 usb_endpoint_descriptor_t *ed;
113 struct uhidev_attach_arg uha;
114 device_t dev;
115 struct uhidev *csc;
116 int maxinpktsize, size, nrepid, repid, repsz;
117 int *repsizes;
118 int i;
119 void *desc;
120 const void *descptr;
121 usbd_status err;
122 char *devinfop;
123 int locs[UHIDBUSCF_NLOCS];
124
125 sc->sc_dev = self;
126 sc->sc_udev = uaa->device;
127 sc->sc_iface = iface;
128
129 aprint_naive("\n");
130 aprint_normal("\n");
131
132 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_USB);
133
134 id = usbd_get_interface_descriptor(iface);
135
136 devinfop = usbd_devinfo_alloc(uaa->device, 0);
137 aprint_normal_dev(self, "%s, iclass %d/%d\n",
138 devinfop, id->bInterfaceClass, id->bInterfaceSubClass);
139 usbd_devinfo_free(devinfop);
140
141 if (!pmf_device_register(self, NULL, NULL))
142 aprint_error_dev(self, "couldn't establish power handler\n");
143
144 (void)usbd_set_idle(iface, 0, 0);
145 #if 0
146
147 qflags = usbd_get_quirks(sc->sc_udev)->uq_flags;
148 if ((qflags & UQ_NO_SET_PROTO) == 0 &&
149 id->bInterfaceSubClass != UISUBCLASS_BOOT)
150 (void)usbd_set_protocol(iface, 1);
151 #endif
152
153 maxinpktsize = 0;
154 sc->sc_iep_addr = sc->sc_oep_addr = -1;
155 for (i = 0; i < id->bNumEndpoints; i++) {
156 ed = usbd_interface2endpoint_descriptor(iface, i);
157 if (ed == NULL) {
158 aprint_error_dev(self,
159 "could not read endpoint descriptor\n");
160 sc->sc_dying = 1;
161 return;
162 }
163
164 DPRINTFN(10,("uhidev_attach: bLength=%d bDescriptorType=%d "
165 "bEndpointAddress=%d-%s bmAttributes=%d wMaxPacketSize=%d"
166 " bInterval=%d\n",
167 ed->bLength, ed->bDescriptorType,
168 ed->bEndpointAddress & UE_ADDR,
169 UE_GET_DIR(ed->bEndpointAddress)==UE_DIR_IN? "in" : "out",
170 ed->bmAttributes & UE_XFERTYPE,
171 UGETW(ed->wMaxPacketSize), ed->bInterval));
172
173 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
174 (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
175 maxinpktsize = UGETW(ed->wMaxPacketSize);
176 sc->sc_iep_addr = ed->bEndpointAddress;
177 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
178 (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
179 sc->sc_oep_addr = ed->bEndpointAddress;
180 } else {
181 aprint_verbose_dev(self, "endpoint %d: ignored\n", i);
182 }
183 }
184
185 /*
186 * Check that we found an input interrupt endpoint. The output interrupt
187 * endpoint is optional
188 */
189 if (sc->sc_iep_addr == -1) {
190 aprint_error_dev(self, "no input interrupt endpoint\n");
191 sc->sc_dying = 1;
192 return;
193 }
194
195 /* XXX need to extend this */
196 descptr = NULL;
197 if (uaa->vendor == USB_VENDOR_WACOM) {
198 static uByte reportbuf[] = {2, 2, 2};
199
200 /* The report descriptor for the Wacom Graphire is broken. */
201 switch (uaa->product) {
202 case USB_PRODUCT_WACOM_GRAPHIRE:
203 case USB_PRODUCT_WACOM_GRAPHIRE2:
204 case USB_PRODUCT_WACOM_GRAPHIRE3_4X5:
205 case USB_PRODUCT_WACOM_GRAPHIRE3_6X8:
206 case USB_PRODUCT_WACOM_GRAPHIRE4_4X5: /* The 6x8 too? */
207 /*
208 * The Graphire3 needs 0x0202 to be written to
209 * feature report ID 2 before it'll start
210 * returning digitizer data.
211 */
212 usbd_set_report(uaa->iface, UHID_FEATURE_REPORT, 2,
213 &reportbuf, sizeof reportbuf);
214
215 size = sizeof uhid_graphire3_4x5_report_descr;
216 descptr = uhid_graphire3_4x5_report_descr;
217 break;
218 default:
219 /* Keep descriptor */
220 break;
221 }
222 }
223 if (USBIF_IS_XINPUT(uaa)) {
224 size = sizeof uhid_xinput_report_descr;
225 descptr = uhid_xinput_report_descr;
226 }
227
228 if (descptr) {
229 desc = malloc(size, M_USBDEV, M_NOWAIT);
230 if (desc == NULL)
231 err = USBD_NOMEM;
232 else {
233 err = USBD_NORMAL_COMPLETION;
234 memcpy(desc, descptr, size);
235 }
236 } else {
237 desc = NULL;
238 err = usbd_read_report_desc(uaa->iface, &desc, &size,
239 M_USBDEV);
240 }
241 if (err) {
242 aprint_error_dev(self, "no report descriptor\n");
243 sc->sc_dying = 1;
244 return;
245 }
246
247 if (uaa->vendor == USB_VENDOR_HOSIDEN &&
248 uaa->product == USB_PRODUCT_HOSIDEN_PPP) {
249 static uByte reportbuf[] = { 1 };
250 /*
251 * This device was sold by Konami with its ParaParaParadise
252 * game for PlayStation2. It needs to be "turned on"
253 * before it will send any reports.
254 */
255
256 usbd_set_report(uaa->iface, UHID_FEATURE_REPORT, 0,
257 &reportbuf, sizeof reportbuf);
258 }
259
260 if (uaa->vendor == USB_VENDOR_LOGITECH &&
261 uaa->product == USB_PRODUCT_LOGITECH_CBT44 && size == 0xb1) {
262 uint8_t *data = desc;
263 /*
264 * This device has a odd USAGE_MINIMUM value that would
265 * cause the multimedia keys to have their usage number
266 * shifted up one usage. Adjust so the usages are sane.
267 */
268
269 if (data[0x56] == 0x19 && data[0x57] == 0x01 &&
270 data[0x58] == 0x2a && data[0x59] == 0x8c)
271 data[0x57] = 0x00;
272 }
273
274 /*
275 * Enable the Six Axis and DualShock 3 controllers.
276 * See http://ps3.jim.sh/sixaxis/usb/
277 */
278 if (uaa->vendor == USB_VENDOR_SONY &&
279 uaa->product == USB_PRODUCT_SONY_PS3CONTROLLER) {
280 usb_device_request_t req;
281 char data[17];
282 int actlen;
283
284 req.bmRequestType = UT_READ_CLASS_INTERFACE;
285 req.bRequest = 1;
286 USETW(req.wValue, 0x3f2);
287 USETW(req.wIndex, 0);
288 USETW(req.wLength, sizeof data);
289
290 usbd_do_request_flags(sc->sc_udev, &req, data,
291 USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT);
292 }
293
294 sc->sc_repdesc = desc;
295 sc->sc_repdesc_size = size;
296
297 uha.uaa = uaa;
298 nrepid = uhidev_maxrepid(desc, size);
299 if (nrepid < 0)
300 return;
301 if (nrepid > 0)
302 aprint_normal_dev(self, "%d report ids\n", nrepid);
303 nrepid++;
304 repsizes = malloc(nrepid * sizeof(*repsizes), M_TEMP, M_NOWAIT);
305 if (repsizes == NULL)
306 goto nomem;
307 sc->sc_subdevs = malloc(nrepid * sizeof(device_t),
308 M_USBDEV, M_NOWAIT | M_ZERO);
309 if (sc->sc_subdevs == NULL) {
310 free(repsizes, M_TEMP);
311 nomem:
312 aprint_error_dev(self, "no memory\n");
313 return;
314 }
315
316 /* Just request max packet size for the interrupt pipe */
317 sc->sc_isize = maxinpktsize;
318 sc->sc_nrepid = nrepid;
319
320 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
321 sc->sc_dev);
322
323 for (repid = 0; repid < nrepid; repid++) {
324 repsz = hid_report_size(desc, size, hid_input, repid);
325 DPRINTF(("uhidev_match: repid=%d, repsz=%d\n", repid, repsz));
326 repsizes[repid] = repsz;
327 }
328
329 DPRINTF(("uhidev_attach: isize=%d\n", sc->sc_isize));
330
331 uha.parent = sc;
332 for (repid = 0; repid < nrepid; repid++) {
333 DPRINTF(("uhidev_match: try repid=%d\n", repid));
334 if (hid_report_size(desc, size, hid_input, repid) == 0 &&
335 hid_report_size(desc, size, hid_output, repid) == 0 &&
336 hid_report_size(desc, size, hid_feature, repid) == 0) {
337 ; /* already NULL in sc->sc_subdevs[repid] */
338 } else {
339 uha.reportid = repid;
340 locs[UHIDBUSCF_REPORTID] = repid;
341
342 dev = config_found_sm_loc(self,
343 "uhidbus", locs, &uha,
344 uhidevprint, config_stdsubmatch);
345 sc->sc_subdevs[repid] = dev;
346 if (dev != NULL) {
347 csc = device_private(dev);
348 csc->sc_in_rep_size = repsizes[repid];
349 #ifdef DIAGNOSTIC
350 DPRINTF(("uhidev_match: repid=%d dev=%p\n",
351 repid, dev));
352 if (csc->sc_intr == NULL) {
353 free(repsizes, M_TEMP);
354 aprint_error_dev(self,
355 "sc_intr == NULL\n");
356 return;
357 }
358 #endif
359 rnd_attach_source(&csc->rnd_source,
360 device_xname(dev),
361 RND_TYPE_TTY, 0);
362 }
363 }
364 }
365 free(repsizes, M_TEMP);
366
367 return;
368 }
369
370 int
371 uhidev_maxrepid(void *buf, int len)
372 {
373 struct hid_data *d;
374 struct hid_item h;
375 int maxid;
376
377 maxid = -1;
378 h.report_ID = 0;
379 for (d = hid_start_parse(buf, len, hid_none); hid_get_item(d, &h); )
380 if (h.report_ID > maxid)
381 maxid = h.report_ID;
382 hid_end_parse(d);
383 return (maxid);
384 }
385
386 int
387 uhidevprint(void *aux, const char *pnp)
388 {
389 struct uhidev_attach_arg *uha = aux;
390
391 if (pnp)
392 aprint_normal("uhid at %s", pnp);
393 if (uha->reportid != 0)
394 aprint_normal(" reportid %d", uha->reportid);
395 return (UNCONF);
396 }
397
398 int
399 uhidev_activate(device_t self, enum devact act)
400 {
401 struct uhidev_softc *sc = device_private(self);
402
403 switch (act) {
404 case DVACT_DEACTIVATE:
405 sc->sc_dying = 1;
406 return 0;
407 default:
408 return EOPNOTSUPP;
409 }
410 }
411
412 void
413 uhidev_childdet(device_t self, device_t child)
414 {
415 int i;
416 struct uhidev_softc *sc = device_private(self);
417
418 for (i = 0; i < sc->sc_nrepid; i++) {
419 if (sc->sc_subdevs[i] == child)
420 break;
421 }
422 KASSERT(i < sc->sc_nrepid);
423 sc->sc_subdevs[i] = NULL;
424 }
425
426 int
427 uhidev_detach(device_t self, int flags)
428 {
429 struct uhidev_softc *sc = device_private(self);
430 int i, rv;
431 struct uhidev *csc;
432
433 DPRINTF(("uhidev_detach: sc=%p flags=%d\n", sc, flags));
434
435 sc->sc_dying = 1;
436 if (sc->sc_ipipe != NULL)
437 usbd_abort_pipe(sc->sc_ipipe);
438
439 if (sc->sc_repdesc != NULL)
440 free(sc->sc_repdesc, M_USBDEV);
441
442 rv = 0;
443 for (i = 0; i < sc->sc_nrepid; i++) {
444 if (sc->sc_subdevs[i] != NULL) {
445 csc = device_private(sc->sc_subdevs[i]);
446 rnd_detach_source(&csc->rnd_source);
447 rv |= config_detach(sc->sc_subdevs[i], flags);
448 }
449 }
450
451 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
452 sc->sc_dev);
453
454 pmf_device_deregister(self);
455 mutex_destroy(&sc->sc_lock);
456
457 return (rv);
458 }
459
460 void
461 uhidev_intr(usbd_xfer_handle xfer, usbd_private_handle addr, usbd_status status)
462 {
463 struct uhidev_softc *sc = addr;
464 device_t cdev;
465 struct uhidev *scd;
466 u_char *p;
467 u_int rep;
468 u_int32_t cc;
469
470 usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL);
471
472 #ifdef UHIDEV_DEBUG
473 if (uhidevdebug > 5) {
474 u_int32_t i;
475
476 DPRINTF(("uhidev_intr: status=%d cc=%d\n", status, cc));
477 DPRINTF(("uhidev_intr: data ="));
478 for (i = 0; i < cc; i++)
479 DPRINTF((" %02x", sc->sc_ibuf[i]));
480 DPRINTF(("\n"));
481 }
482 #endif
483
484 if (status == USBD_CANCELLED)
485 return;
486
487 if (status != USBD_NORMAL_COMPLETION) {
488 DPRINTF(("%s: interrupt status=%d\n", device_xname(sc->sc_dev),
489 status));
490 usbd_clear_endpoint_stall_async(sc->sc_ipipe);
491 return;
492 }
493
494 p = sc->sc_ibuf;
495 if (sc->sc_nrepid != 1)
496 rep = *p++, cc--;
497 else
498 rep = 0;
499 if (rep >= sc->sc_nrepid) {
500 printf("uhidev_intr: bad repid %d\n", rep);
501 return;
502 }
503 cdev = sc->sc_subdevs[rep];
504 if (!cdev)
505 return;
506 scd = device_private(cdev);
507 DPRINTFN(5,("uhidev_intr: rep=%d, scd=%p state=0x%x\n",
508 rep, scd, scd ? scd->sc_state : 0));
509 if (!(scd->sc_state & UHIDEV_OPEN))
510 return;
511 #ifdef UHIDEV_DEBUG
512 if (scd->sc_in_rep_size != cc) {
513 DPRINTF(("%s: expected %d bytes, got %d\n",
514 device_xname(sc->sc_dev), scd->sc_in_rep_size, cc));
515 }
516 #endif
517 if (cc == 0) {
518 DPRINTF(("%s: 0-length input ignored\n",
519 device_xname(sc->sc_dev)));
520 return;
521 }
522 rnd_add_uint32(&scd->rnd_source, (uintptr_t)(sc->sc_ibuf));
523 scd->sc_intr(scd, p, cc);
524 }
525
526 void
527 uhidev_get_report_desc(struct uhidev_softc *sc, void **desc, int *size)
528 {
529 *desc = sc->sc_repdesc;
530 *size = sc->sc_repdesc_size;
531 }
532
533 int
534 uhidev_open(struct uhidev *scd)
535 {
536 struct uhidev_softc *sc = scd->sc_parent;
537 usbd_status err;
538 int error;
539
540 DPRINTF(("uhidev_open: open pipe, state=%d\n", scd->sc_state));
541
542 mutex_enter(&sc->sc_lock);
543 if (scd->sc_state & UHIDEV_OPEN) {
544 mutex_exit(&sc->sc_lock);
545 return (EBUSY);
546 }
547 scd->sc_state |= UHIDEV_OPEN;
548 mutex_exit(&sc->sc_lock);
549
550 if (sc->sc_isize == 0)
551 return (0);
552
553 sc->sc_ibuf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
554
555 /* Set up input interrupt pipe. */
556 DPRINTF(("uhidev_open: isize=%d, ep=0x%02x\n", sc->sc_isize,
557 sc->sc_iep_addr));
558
559 err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_iep_addr,
560 USBD_SHORT_XFER_OK, &sc->sc_ipipe, sc, sc->sc_ibuf,
561 sc->sc_isize, uhidev_intr, USBD_DEFAULT_INTERVAL);
562 if (err != USBD_NORMAL_COMPLETION) {
563 DPRINTF(("uhidopen: usbd_open_pipe_intr failed, "
564 "error=%d\n", err));
565 error = EIO;
566 goto out1;
567 }
568
569 /*
570 * Set up output interrupt pipe if an output interrupt endpoint
571 * exists.
572 */
573 if (sc->sc_oep_addr != -1) {
574 DPRINTF(("uhidev_open: oep=0x%02x\n", sc->sc_oep_addr));
575
576 err = usbd_open_pipe(sc->sc_iface, sc->sc_oep_addr,
577 0, &sc->sc_opipe);
578
579 if (err != USBD_NORMAL_COMPLETION) {
580 DPRINTF(("uhidev_open: usbd_open_pipe failed, "
581 "error=%d\n", err));
582 error = EIO;
583 goto out2;
584 }
585 DPRINTF(("uhidev_open: sc->sc_opipe=%p\n", sc->sc_opipe));
586
587 sc->sc_oxfer = usbd_alloc_xfer(sc->sc_udev);
588 if (sc->sc_oxfer == NULL) {
589 DPRINTF(("uhidev_open: couldn't allocate an xfer\n"));
590 error = ENOMEM;
591 goto out3;
592 }
593 }
594
595 return (0);
596 out3:
597 /* Abort output pipe */
598 usbd_close_pipe(sc->sc_opipe);
599 out2:
600 /* Abort input pipe */
601 usbd_close_pipe(sc->sc_ipipe);
602 out1:
603 DPRINTF(("uhidev_open: failed in someway"));
604 free(sc->sc_ibuf, M_USBDEV);
605 mutex_enter(&sc->sc_lock);
606 scd->sc_state &= ~UHIDEV_OPEN;
607 sc->sc_ipipe = NULL;
608 sc->sc_opipe = NULL;
609 sc->sc_oxfer = NULL;
610 mutex_exit(&sc->sc_lock);
611 return error;
612 }
613
614 void
615 uhidev_close(struct uhidev *scd)
616 {
617 struct uhidev_softc *sc = scd->sc_parent;
618
619 mutex_enter(&sc->sc_lock);
620 if (!(scd->sc_state & UHIDEV_OPEN)) {
621 mutex_exit(&sc->sc_lock);
622 return;
623 }
624 scd->sc_state &= ~UHIDEV_OPEN;
625 mutex_exit(&sc->sc_lock);
626
627 DPRINTF(("uhidev_close: close pipe\n"));
628
629 if (sc->sc_oxfer != NULL)
630 usbd_free_xfer(sc->sc_oxfer);
631
632 /* Disable interrupts. */
633 if (sc->sc_opipe != NULL) {
634 usbd_abort_pipe(sc->sc_opipe);
635 usbd_close_pipe(sc->sc_opipe);
636 sc->sc_opipe = NULL;
637 }
638
639 if (sc->sc_ipipe != NULL) {
640 usbd_abort_pipe(sc->sc_ipipe);
641 usbd_close_pipe(sc->sc_ipipe);
642 sc->sc_ipipe = NULL;
643 }
644
645 if (sc->sc_ibuf != NULL) {
646 free(sc->sc_ibuf, M_USBDEV);
647 sc->sc_ibuf = NULL;
648 }
649 }
650
651 usbd_status
652 uhidev_set_report(struct uhidev *scd, int type, void *data, int len)
653 {
654 char *buf;
655 usbd_status retstat;
656
657 if (scd->sc_report_id == 0)
658 return usbd_set_report(scd->sc_parent->sc_iface, type,
659 scd->sc_report_id, data, len);
660
661 buf = malloc(len + 1, M_TEMP, M_WAITOK);
662 buf[0] = scd->sc_report_id;
663 memcpy(buf+1, data, len);
664
665 retstat = usbd_set_report(scd->sc_parent->sc_iface, type,
666 scd->sc_report_id, buf, len + 1);
667
668 free(buf, M_TEMP);
669
670 return retstat;
671 }
672
673 usbd_status
674 uhidev_get_report(struct uhidev *scd, int type, void *data, int len)
675 {
676 return usbd_get_report(scd->sc_parent->sc_iface, type,
677 scd->sc_report_id, data, len);
678 }
679
680 usbd_status
681 uhidev_write(struct uhidev_softc *sc, void *data, int len)
682 {
683
684 DPRINTF(("uhidev_write: data=%p, len=%d\n", data, len));
685
686 if (sc->sc_opipe == NULL)
687 return USBD_INVAL;
688
689 #ifdef UHIDEV_DEBUG
690 if (uhidevdebug > 50) {
691
692 u_int32_t i;
693 u_int8_t *d = data;
694
695 DPRINTF(("uhidev_write: data ="));
696 for (i = 0; i < len; i++)
697 DPRINTF((" %02x", d[i]));
698 DPRINTF(("\n"));
699 }
700 #endif
701 return usbd_intr_transfer(sc->sc_oxfer, sc->sc_opipe, 0,
702 USBD_NO_TIMEOUT, data, &len, "uhidevwi");
703 }
704