uhidev.c revision 1.61 1 /* $NetBSD: uhidev.c,v 1.61 2014/08/10 16:44:36 tls 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.61 2014/08/10 16:44:36 tls 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,
362 RND_FLAG_DEFAULT);
363 }
364 }
365 }
366 free(repsizes, M_TEMP);
367
368 return;
369 }
370
371 int
372 uhidev_maxrepid(void *buf, int len)
373 {
374 struct hid_data *d;
375 struct hid_item h;
376 int maxid;
377
378 maxid = -1;
379 h.report_ID = 0;
380 for (d = hid_start_parse(buf, len, hid_none); hid_get_item(d, &h); )
381 if (h.report_ID > maxid)
382 maxid = h.report_ID;
383 hid_end_parse(d);
384 return (maxid);
385 }
386
387 int
388 uhidevprint(void *aux, const char *pnp)
389 {
390 struct uhidev_attach_arg *uha = aux;
391
392 if (pnp)
393 aprint_normal("uhid at %s", pnp);
394 if (uha->reportid != 0)
395 aprint_normal(" reportid %d", uha->reportid);
396 return (UNCONF);
397 }
398
399 int
400 uhidev_activate(device_t self, enum devact act)
401 {
402 struct uhidev_softc *sc = device_private(self);
403
404 switch (act) {
405 case DVACT_DEACTIVATE:
406 sc->sc_dying = 1;
407 return 0;
408 default:
409 return EOPNOTSUPP;
410 }
411 }
412
413 void
414 uhidev_childdet(device_t self, device_t child)
415 {
416 int i;
417 struct uhidev_softc *sc = device_private(self);
418
419 for (i = 0; i < sc->sc_nrepid; i++) {
420 if (sc->sc_subdevs[i] == child)
421 break;
422 }
423 KASSERT(i < sc->sc_nrepid);
424 sc->sc_subdevs[i] = NULL;
425 }
426
427 int
428 uhidev_detach(device_t self, int flags)
429 {
430 struct uhidev_softc *sc = device_private(self);
431 int i, rv;
432 struct uhidev *csc;
433
434 DPRINTF(("uhidev_detach: sc=%p flags=%d\n", sc, flags));
435
436 sc->sc_dying = 1;
437 if (sc->sc_ipipe != NULL)
438 usbd_abort_pipe(sc->sc_ipipe);
439
440 if (sc->sc_repdesc != NULL)
441 free(sc->sc_repdesc, M_USBDEV);
442
443 rv = 0;
444 for (i = 0; i < sc->sc_nrepid; i++) {
445 if (sc->sc_subdevs[i] != NULL) {
446 csc = device_private(sc->sc_subdevs[i]);
447 rnd_detach_source(&csc->rnd_source);
448 rv |= config_detach(sc->sc_subdevs[i], flags);
449 }
450 }
451
452 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
453 sc->sc_dev);
454
455 pmf_device_deregister(self);
456 mutex_destroy(&sc->sc_lock);
457
458 return (rv);
459 }
460
461 void
462 uhidev_intr(usbd_xfer_handle xfer, usbd_private_handle addr, usbd_status status)
463 {
464 struct uhidev_softc *sc = addr;
465 device_t cdev;
466 struct uhidev *scd;
467 u_char *p;
468 u_int rep;
469 u_int32_t cc;
470
471 usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL);
472
473 #ifdef UHIDEV_DEBUG
474 if (uhidevdebug > 5) {
475 u_int32_t i;
476
477 DPRINTF(("uhidev_intr: status=%d cc=%d\n", status, cc));
478 DPRINTF(("uhidev_intr: data ="));
479 for (i = 0; i < cc; i++)
480 DPRINTF((" %02x", sc->sc_ibuf[i]));
481 DPRINTF(("\n"));
482 }
483 #endif
484
485 if (status == USBD_CANCELLED)
486 return;
487
488 if (status != USBD_NORMAL_COMPLETION) {
489 DPRINTF(("%s: interrupt status=%d\n", device_xname(sc->sc_dev),
490 status));
491 usbd_clear_endpoint_stall_async(sc->sc_ipipe);
492 return;
493 }
494
495 p = sc->sc_ibuf;
496 if (sc->sc_nrepid != 1)
497 rep = *p++, cc--;
498 else
499 rep = 0;
500 if (rep >= sc->sc_nrepid) {
501 printf("uhidev_intr: bad repid %d\n", rep);
502 return;
503 }
504 cdev = sc->sc_subdevs[rep];
505 if (!cdev)
506 return;
507 scd = device_private(cdev);
508 DPRINTFN(5,("uhidev_intr: rep=%d, scd=%p state=0x%x\n",
509 rep, scd, scd ? scd->sc_state : 0));
510 if (!(scd->sc_state & UHIDEV_OPEN))
511 return;
512 #ifdef UHIDEV_DEBUG
513 if (scd->sc_in_rep_size != cc) {
514 DPRINTF(("%s: expected %d bytes, got %d\n",
515 device_xname(sc->sc_dev), scd->sc_in_rep_size, cc));
516 }
517 #endif
518 if (cc == 0) {
519 DPRINTF(("%s: 0-length input ignored\n",
520 device_xname(sc->sc_dev)));
521 return;
522 }
523 rnd_add_uint32(&scd->rnd_source, (uintptr_t)(sc->sc_ibuf));
524 scd->sc_intr(scd, p, cc);
525 }
526
527 void
528 uhidev_get_report_desc(struct uhidev_softc *sc, void **desc, int *size)
529 {
530 *desc = sc->sc_repdesc;
531 *size = sc->sc_repdesc_size;
532 }
533
534 int
535 uhidev_open(struct uhidev *scd)
536 {
537 struct uhidev_softc *sc = scd->sc_parent;
538 usbd_status err;
539 int error;
540
541 DPRINTF(("uhidev_open: open pipe, state=%d\n", scd->sc_state));
542
543 mutex_enter(&sc->sc_lock);
544 if (scd->sc_state & UHIDEV_OPEN) {
545 mutex_exit(&sc->sc_lock);
546 return (EBUSY);
547 }
548 scd->sc_state |= UHIDEV_OPEN;
549 if (sc->sc_refcnt++) {
550 mutex_exit(&sc->sc_lock);
551 return (0);
552 }
553 mutex_exit(&sc->sc_lock);
554
555 if (sc->sc_isize == 0)
556 return (0);
557
558 sc->sc_ibuf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
559
560 /* Set up input interrupt pipe. */
561 DPRINTF(("uhidev_open: isize=%d, ep=0x%02x\n", sc->sc_isize,
562 sc->sc_iep_addr));
563
564 err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_iep_addr,
565 USBD_SHORT_XFER_OK, &sc->sc_ipipe, sc, sc->sc_ibuf,
566 sc->sc_isize, uhidev_intr, USBD_DEFAULT_INTERVAL);
567 if (err != USBD_NORMAL_COMPLETION) {
568 DPRINTF(("uhidopen: usbd_open_pipe_intr failed, "
569 "error=%d\n", err));
570 error = EIO;
571 goto out1;
572 }
573
574 /*
575 * Set up output interrupt pipe if an output interrupt endpoint
576 * exists.
577 */
578 if (sc->sc_oep_addr != -1) {
579 DPRINTF(("uhidev_open: oep=0x%02x\n", sc->sc_oep_addr));
580
581 err = usbd_open_pipe(sc->sc_iface, sc->sc_oep_addr,
582 0, &sc->sc_opipe);
583
584 if (err != USBD_NORMAL_COMPLETION) {
585 DPRINTF(("uhidev_open: usbd_open_pipe failed, "
586 "error=%d\n", err));
587 error = EIO;
588 goto out2;
589 }
590 DPRINTF(("uhidev_open: sc->sc_opipe=%p\n", sc->sc_opipe));
591
592 sc->sc_oxfer = usbd_alloc_xfer(sc->sc_udev);
593 if (sc->sc_oxfer == NULL) {
594 DPRINTF(("uhidev_open: couldn't allocate an xfer\n"));
595 error = ENOMEM;
596 goto out3;
597 }
598 }
599
600 return (0);
601 out3:
602 /* Abort output pipe */
603 usbd_close_pipe(sc->sc_opipe);
604 out2:
605 /* Abort input pipe */
606 usbd_close_pipe(sc->sc_ipipe);
607 out1:
608 DPRINTF(("uhidev_open: failed in someway"));
609 free(sc->sc_ibuf, M_USBDEV);
610 mutex_enter(&sc->sc_lock);
611 scd->sc_state &= ~UHIDEV_OPEN;
612 sc->sc_refcnt = 0;
613 sc->sc_ibuf = NULL;
614 sc->sc_ipipe = NULL;
615 sc->sc_opipe = NULL;
616 sc->sc_oxfer = NULL;
617 mutex_exit(&sc->sc_lock);
618 return error;
619 }
620
621 void
622 uhidev_close(struct uhidev *scd)
623 {
624 struct uhidev_softc *sc = scd->sc_parent;
625
626 mutex_enter(&sc->sc_lock);
627 if (!(scd->sc_state & UHIDEV_OPEN)) {
628 mutex_exit(&sc->sc_lock);
629 return;
630 }
631 scd->sc_state &= ~UHIDEV_OPEN;
632 if (--sc->sc_refcnt) {
633 mutex_exit(&sc->sc_lock);
634 return;
635 }
636 mutex_exit(&sc->sc_lock);
637
638 DPRINTF(("uhidev_close: close pipe\n"));
639
640 if (sc->sc_oxfer != NULL) {
641 usbd_free_xfer(sc->sc_oxfer);
642 sc->sc_oxfer = NULL;
643 }
644
645 /* Disable interrupts. */
646 if (sc->sc_opipe != NULL) {
647 usbd_abort_pipe(sc->sc_opipe);
648 usbd_close_pipe(sc->sc_opipe);
649 sc->sc_opipe = NULL;
650 }
651
652 if (sc->sc_ipipe != NULL) {
653 usbd_abort_pipe(sc->sc_ipipe);
654 usbd_close_pipe(sc->sc_ipipe);
655 sc->sc_ipipe = NULL;
656 }
657
658 if (sc->sc_ibuf != NULL) {
659 free(sc->sc_ibuf, M_USBDEV);
660 sc->sc_ibuf = NULL;
661 }
662 }
663
664 usbd_status
665 uhidev_set_report(struct uhidev *scd, int type, void *data, int len)
666 {
667 char *buf;
668 usbd_status retstat;
669
670 if (scd->sc_report_id == 0)
671 return usbd_set_report(scd->sc_parent->sc_iface, type,
672 scd->sc_report_id, data, len);
673
674 buf = malloc(len + 1, M_TEMP, M_WAITOK);
675 buf[0] = scd->sc_report_id;
676 memcpy(buf+1, data, len);
677
678 retstat = usbd_set_report(scd->sc_parent->sc_iface, type,
679 scd->sc_report_id, buf, len + 1);
680
681 free(buf, M_TEMP);
682
683 return retstat;
684 }
685
686 usbd_status
687 uhidev_get_report(struct uhidev *scd, int type, void *data, int len)
688 {
689 return usbd_get_report(scd->sc_parent->sc_iface, type,
690 scd->sc_report_id, data, len);
691 }
692
693 usbd_status
694 uhidev_write(struct uhidev_softc *sc, void *data, int len)
695 {
696
697 DPRINTF(("uhidev_write: data=%p, len=%d\n", data, len));
698
699 if (sc->sc_opipe == NULL)
700 return USBD_INVAL;
701
702 #ifdef UHIDEV_DEBUG
703 if (uhidevdebug > 50) {
704
705 u_int32_t i;
706 u_int8_t *d = data;
707
708 DPRINTF(("uhidev_write: data ="));
709 for (i = 0; i < len; i++)
710 DPRINTF((" %02x", d[i]));
711 DPRINTF(("\n"));
712 }
713 #endif
714 return usbd_intr_transfer(sc->sc_oxfer, sc->sc_opipe, 0,
715 USBD_NO_TIMEOUT, data, &len, "uhidevwi");
716 }
717