| 1 | /* |
| 2 | * $NetBSD: uhid.c,v 1.46 2001/11/13 06:24:55 lukem Exp $ |
| 3 | * $FreeBSD: src/sys/dev/usb/uhid.c,v 1.65 2003/11/09 09:17:22 tanimura Exp $ |
| 4 | * $DragonFly: src/sys/dev/usbmisc/uhid/uhid.c,v 1.33 2008/08/14 20:55:53 hasso Exp $ |
| 5 | */ |
| 6 | |
| 7 | /* Also already merged from NetBSD: |
| 8 | * $NetBSD: uhid.c,v 1.54 2002/09/23 05:51:21 simonb Exp $ |
| 9 | */ |
| 10 | |
| 11 | /* |
| 12 | * Copyright (c) 1998 The NetBSD Foundation, Inc. |
| 13 | * All rights reserved. |
| 14 | * |
| 15 | * This code is derived from software contributed to The NetBSD Foundation |
| 16 | * by Lennart Augustsson (lennart@augustsson.net) at |
| 17 | * Carlstedt Research & Technology. |
| 18 | * |
| 19 | * Redistribution and use in source and binary forms, with or without |
| 20 | * modification, are permitted provided that the following conditions |
| 21 | * are met: |
| 22 | * 1. Redistributions of source code must retain the above copyright |
| 23 | * notice, this list of conditions and the following disclaimer. |
| 24 | * 2. Redistributions in binary form must reproduce the above copyright |
| 25 | * notice, this list of conditions and the following disclaimer in the |
| 26 | * documentation and/or other materials provided with the distribution. |
| 27 | * 3. All advertising materials mentioning features or use of this software |
| 28 | * must display the following acknowledgement: |
| 29 | * This product includes software developed by the NetBSD |
| 30 | * Foundation, Inc. and its contributors. |
| 31 | * 4. Neither the name of The NetBSD Foundation nor the names of its |
| 32 | * contributors may be used to endorse or promote products derived |
| 33 | * from this software without specific prior written permission. |
| 34 | * |
| 35 | * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS |
| 36 | * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| 37 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| 38 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS |
| 39 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 40 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 41 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| 42 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| 43 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 44 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 45 | * POSSIBILITY OF SUCH DAMAGE. |
| 46 | */ |
| 47 | |
| 48 | /* |
| 49 | * HID spec: http://www.usb.org/developers/data/usbhid10.pdf |
| 50 | */ |
| 51 | |
| 52 | #include <sys/param.h> |
| 53 | #include <sys/systm.h> |
| 54 | #include <sys/kernel.h> |
| 55 | #include <sys/lock.h> |
| 56 | #include <sys/malloc.h> |
| 57 | #include <sys/signalvar.h> |
| 58 | #include <sys/filio.h> |
| 59 | #include <sys/module.h> |
| 60 | #include <sys/bus.h> |
| 61 | #include <sys/conf.h> |
| 62 | #include <sys/tty.h> |
| 63 | #include <sys/proc.h> |
| 64 | #include <sys/vnode.h> |
| 65 | #include <sys/event.h> |
| 66 | #include <sys/sysctl.h> |
| 67 | #include <sys/thread2.h> |
| 68 | |
| 69 | #include <bus/usb/usb.h> |
| 70 | #include <bus/usb/usbhid.h> |
| 71 | |
| 72 | #include <bus/usb/usbdi.h> |
| 73 | #include <bus/usb/usbdi_util.h> |
| 74 | #include <bus/usb/hid.h> |
| 75 | |
| 76 | /* Report descriptor for broken Wacom Graphire */ |
| 77 | #include <bus/usb/ugraphire_rdesc.h> |
| 78 | |
| 79 | #ifdef USB_DEBUG |
| 80 | #define DPRINTF(x) if (uhiddebug) kprintf x |
| 81 | #define DPRINTFN(n,x) if (uhiddebug>(n)) kprintf x |
| 82 | int uhiddebug = 0; |
| 83 | SYSCTL_NODE(_hw_usb, OID_AUTO, uhid, CTLFLAG_RW, 0, "USB uhid"); |
| 84 | SYSCTL_INT(_hw_usb_uhid, OID_AUTO, debug, CTLFLAG_RW, |
| 85 | &uhiddebug, 0, "uhid debug level"); |
| 86 | #else |
| 87 | #define DPRINTF(x) |
| 88 | #define DPRINTFN(n,x) |
| 89 | #endif |
| 90 | |
| 91 | struct uhid_softc { |
| 92 | device_t sc_dev; /* base device */ |
| 93 | usbd_device_handle sc_udev; |
| 94 | usbd_interface_handle sc_iface; /* interface */ |
| 95 | usbd_pipe_handle sc_intrpipe; /* interrupt pipe */ |
| 96 | int sc_ep_addr; |
| 97 | |
| 98 | int sc_isize; |
| 99 | int sc_osize; |
| 100 | int sc_fsize; |
| 101 | u_int8_t sc_iid; |
| 102 | u_int8_t sc_oid; |
| 103 | u_int8_t sc_fid; |
| 104 | |
| 105 | u_char *sc_ibuf; |
| 106 | u_char *sc_obuf; |
| 107 | |
| 108 | void *sc_repdesc; |
| 109 | int sc_repdesc_size; |
| 110 | |
| 111 | struct clist sc_q; |
| 112 | struct kqinfo sc_rkq; |
| 113 | struct proc *sc_async; /* process that wants SIGIO */ |
| 114 | u_char sc_state; /* driver state */ |
| 115 | #define UHID_OPEN 0x01 /* device is open */ |
| 116 | #define UHID_ASLP 0x02 /* waiting for device data */ |
| 117 | #define UHID_NEEDCLEAR 0x04 /* needs clearing endpoint stall */ |
| 118 | #define UHID_IMMED 0x08 /* return read data immediately */ |
| 119 | |
| 120 | int sc_refcnt; |
| 121 | u_char sc_dying; |
| 122 | }; |
| 123 | |
| 124 | #define UHIDUNIT(dev) (minor(dev)) |
| 125 | #define UHID_CHUNK 128 /* chunk size for read */ |
| 126 | #define UHID_BSIZE 1020 /* buffer size */ |
| 127 | |
| 128 | d_open_t uhidopen; |
| 129 | d_close_t uhidclose; |
| 130 | d_read_t uhidread; |
| 131 | d_write_t uhidwrite; |
| 132 | d_ioctl_t uhidioctl; |
| 133 | d_kqfilter_t uhidkqfilter; |
| 134 | |
| 135 | static void uhidfilt_detach(struct knote *); |
| 136 | static int uhidfilt_read(struct knote *, long); |
| 137 | static int uhidfilt_write(struct knote *, long); |
| 138 | |
| 139 | #define UHID_CDEV_MAJOR 122 |
| 140 | |
| 141 | static struct dev_ops uhid_ops = { |
| 142 | { "uhid", UHID_CDEV_MAJOR, 0 }, |
| 143 | .d_open = uhidopen, |
| 144 | .d_close = uhidclose, |
| 145 | .d_read = uhidread, |
| 146 | .d_write = uhidwrite, |
| 147 | .d_ioctl = uhidioctl, |
| 148 | .d_kqfilter = uhidkqfilter |
| 149 | }; |
| 150 | |
| 151 | static void uhid_intr(usbd_xfer_handle, usbd_private_handle, |
| 152 | usbd_status); |
| 153 | |
| 154 | static int uhid_do_read(struct uhid_softc *, struct uio *uio, int); |
| 155 | static int uhid_do_write(struct uhid_softc *, struct uio *uio, int); |
| 156 | static int uhid_do_ioctl(struct uhid_softc *, u_long, caddr_t, int); |
| 157 | |
| 158 | static device_probe_t uhid_match; |
| 159 | static device_attach_t uhid_attach; |
| 160 | static device_detach_t uhid_detach; |
| 161 | |
| 162 | static devclass_t uhid_devclass; |
| 163 | |
| 164 | static kobj_method_t uhid_methods[] = { |
| 165 | DEVMETHOD(device_probe, uhid_match), |
| 166 | DEVMETHOD(device_attach, uhid_attach), |
| 167 | DEVMETHOD(device_detach, uhid_detach), |
| 168 | {0,0} |
| 169 | }; |
| 170 | |
| 171 | static driver_t uhid_driver = { |
| 172 | "uhid", |
| 173 | uhid_methods, |
| 174 | sizeof(struct uhid_softc) |
| 175 | }; |
| 176 | |
| 177 | MODULE_DEPEND(uhid, usb, 1, 1, 1); |
| 178 | |
| 179 | static int |
| 180 | uhid_match(device_t self) |
| 181 | { |
| 182 | struct usb_attach_arg *uaa = device_get_ivars(self); |
| 183 | usb_interface_descriptor_t *id; |
| 184 | |
| 185 | if (uaa->iface == NULL) |
| 186 | return (UMATCH_NONE); |
| 187 | id = usbd_get_interface_descriptor(uaa->iface); |
| 188 | if (id == NULL || id->bInterfaceClass != UICLASS_HID) |
| 189 | return (UMATCH_NONE); |
| 190 | if (uaa->matchlvl) |
| 191 | return (uaa->matchlvl); |
| 192 | return (UMATCH_IFACECLASS_GENERIC); |
| 193 | } |
| 194 | |
| 195 | static int |
| 196 | uhid_attach(device_t self) |
| 197 | { |
| 198 | struct uhid_softc *sc = device_get_softc(self); |
| 199 | struct usb_attach_arg *uaa = device_get_ivars(self); |
| 200 | usbd_interface_handle iface = uaa->iface; |
| 201 | usb_endpoint_descriptor_t *ed; |
| 202 | int size; |
| 203 | void *desc; |
| 204 | usbd_status err; |
| 205 | |
| 206 | sc->sc_udev = uaa->device; |
| 207 | sc->sc_iface = iface; |
| 208 | sc->sc_dev = self; |
| 209 | |
| 210 | ed = usbd_interface2endpoint_descriptor(iface, 0); |
| 211 | if (ed == NULL) { |
| 212 | kprintf("%s: could not read endpoint descriptor\n", |
| 213 | device_get_nameunit(sc->sc_dev)); |
| 214 | sc->sc_dying = 1; |
| 215 | return ENXIO; |
| 216 | } |
| 217 | |
| 218 | DPRINTFN(10,("uhid_attach: bLength=%d bDescriptorType=%d " |
| 219 | "bEndpointAddress=%d-%s bmAttributes=%d wMaxPacketSize=%d" |
| 220 | " bInterval=%d\n", |
| 221 | ed->bLength, ed->bDescriptorType, |
| 222 | ed->bEndpointAddress & UE_ADDR, |
| 223 | UE_GET_DIR(ed->bEndpointAddress)==UE_DIR_IN? "in" : "out", |
| 224 | ed->bmAttributes & UE_XFERTYPE, |
| 225 | UGETW(ed->wMaxPacketSize), ed->bInterval)); |
| 226 | |
| 227 | if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_IN || |
| 228 | (ed->bmAttributes & UE_XFERTYPE) != UE_INTERRUPT) { |
| 229 | kprintf("%s: unexpected endpoint\n", device_get_nameunit(sc->sc_dev)); |
| 230 | sc->sc_dying = 1; |
| 231 | return ENXIO; |
| 232 | } |
| 233 | |
| 234 | sc->sc_ep_addr = ed->bEndpointAddress; |
| 235 | |
| 236 | /* The report descriptor for the Wacom Graphire is broken. */ |
| 237 | if (uaa->vendor == 0x056a && uaa->product == 0x0010 /* && |
| 238 | uaa->revision == 0x???? */) { /* XXX should use revision */ |
| 239 | size = sizeof uhid_graphire_report_descr; |
| 240 | desc = kmalloc(size, M_USBDEV, M_INTWAIT); |
| 241 | err = USBD_NORMAL_COMPLETION; |
| 242 | memcpy(desc, uhid_graphire_report_descr, size); |
| 243 | } else { |
| 244 | desc = NULL; |
| 245 | err = usbd_read_report_desc(uaa->iface, &desc, &size,M_USBDEV); |
| 246 | } |
| 247 | |
| 248 | if (err) { |
| 249 | kprintf("%s: no report descriptor\n", device_get_nameunit(sc->sc_dev)); |
| 250 | sc->sc_dying = 1; |
| 251 | return ENXIO; |
| 252 | } |
| 253 | |
| 254 | (void)usbd_set_idle(iface, 0, 0); |
| 255 | |
| 256 | sc->sc_isize = hid_report_size(desc, size, hid_input, &sc->sc_iid); |
| 257 | sc->sc_osize = hid_report_size(desc, size, hid_output, &sc->sc_oid); |
| 258 | sc->sc_fsize = hid_report_size(desc, size, hid_feature, &sc->sc_fid); |
| 259 | |
| 260 | sc->sc_repdesc = desc; |
| 261 | sc->sc_repdesc_size = size; |
| 262 | |
| 263 | make_dev(&uhid_ops, device_get_unit(self), |
| 264 | UID_ROOT, GID_OPERATOR, |
| 265 | 0644, "uhid%d", device_get_unit(self)); |
| 266 | |
| 267 | return 0; |
| 268 | } |
| 269 | |
| 270 | static int |
| 271 | uhid_detach(device_t self) |
| 272 | { |
| 273 | struct uhid_softc *sc = device_get_softc(self); |
| 274 | |
| 275 | DPRINTF(("uhid_detach: sc=%p\n", sc)); |
| 276 | |
| 277 | sc->sc_dying = 1; |
| 278 | if (sc->sc_intrpipe != NULL) |
| 279 | usbd_abort_pipe(sc->sc_intrpipe); |
| 280 | |
| 281 | if (sc->sc_state & UHID_OPEN) { |
| 282 | crit_enter(); |
| 283 | if (--sc->sc_refcnt >= 0) { |
| 284 | /* Wake everyone */ |
| 285 | wakeup(&sc->sc_q); |
| 286 | /* Wait for processes to go away. */ |
| 287 | usb_detach_wait(sc->sc_dev); |
| 288 | } |
| 289 | crit_exit(); |
| 290 | } |
| 291 | |
| 292 | dev_ops_remove_minor(&uhid_ops, device_get_unit(self)); |
| 293 | |
| 294 | if (sc->sc_repdesc) |
| 295 | kfree(sc->sc_repdesc, M_USBDEV); |
| 296 | |
| 297 | return (0); |
| 298 | } |
| 299 | |
| 300 | void |
| 301 | uhid_intr(usbd_xfer_handle xfer, usbd_private_handle addr, usbd_status status) |
| 302 | { |
| 303 | struct uhid_softc *sc = addr; |
| 304 | |
| 305 | #ifdef USB_DEBUG |
| 306 | if (uhiddebug > 5) { |
| 307 | u_int32_t cc, i; |
| 308 | |
| 309 | usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL); |
| 310 | DPRINTF(("uhid_intr: status=%d cc=%d\n", status, cc)); |
| 311 | DPRINTF(("uhid_intr: data =")); |
| 312 | for (i = 0; i < cc; i++) |
| 313 | DPRINTF((" %02x", sc->sc_ibuf[i])); |
| 314 | DPRINTF(("\n")); |
| 315 | } |
| 316 | #endif |
| 317 | |
| 318 | if (status == USBD_CANCELLED) |
| 319 | return; |
| 320 | |
| 321 | if (status != USBD_NORMAL_COMPLETION) { |
| 322 | DPRINTF(("uhid_intr: status=%d\n", status)); |
| 323 | if (status == USBD_STALLED) |
| 324 | sc->sc_state |= UHID_NEEDCLEAR; |
| 325 | return; |
| 326 | } |
| 327 | |
| 328 | (void) b_to_q(sc->sc_ibuf, sc->sc_isize, &sc->sc_q); |
| 329 | |
| 330 | if (sc->sc_state & UHID_ASLP) { |
| 331 | sc->sc_state &= ~UHID_ASLP; |
| 332 | DPRINTFN(5, ("uhid_intr: waking %p\n", &sc->sc_q)); |
| 333 | wakeup(&sc->sc_q); |
| 334 | } |
| 335 | KNOTE(&sc->sc_rkq.ki_note, 0); |
| 336 | if (sc->sc_async != NULL) { |
| 337 | DPRINTFN(3, ("uhid_intr: sending SIGIO %p\n", sc->sc_async)); |
| 338 | ksignal(sc->sc_async, SIGIO); |
| 339 | } |
| 340 | } |
| 341 | |
| 342 | int |
| 343 | uhidopen(struct dev_open_args *ap) |
| 344 | { |
| 345 | cdev_t dev = ap->a_head.a_dev; |
| 346 | struct uhid_softc *sc; |
| 347 | usbd_status err; |
| 348 | |
| 349 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 350 | if (sc == NULL) |
| 351 | return (ENXIO); |
| 352 | |
| 353 | DPRINTF(("uhidopen: sc=%p\n", sc)); |
| 354 | |
| 355 | if (sc->sc_dying) |
| 356 | return (ENXIO); |
| 357 | |
| 358 | if (sc->sc_state & UHID_OPEN) |
| 359 | return (EBUSY); |
| 360 | sc->sc_state |= UHID_OPEN; |
| 361 | |
| 362 | if ((clist_alloc_cblocks(&sc->sc_q, UHID_BSIZE, |
| 363 | UHID_BSIZE), 0) == -1) { |
| 364 | sc->sc_state &= ~UHID_OPEN; |
| 365 | return (ENOMEM); |
| 366 | } |
| 367 | |
| 368 | sc->sc_ibuf = kmalloc(sc->sc_isize, M_USBDEV, M_WAITOK); |
| 369 | sc->sc_obuf = kmalloc(sc->sc_osize, M_USBDEV, M_WAITOK); |
| 370 | |
| 371 | /* Set up interrupt pipe. */ |
| 372 | err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_ep_addr, |
| 373 | USBD_SHORT_XFER_OK, &sc->sc_intrpipe, sc, sc->sc_ibuf, |
| 374 | sc->sc_isize, uhid_intr, USBD_DEFAULT_INTERVAL); |
| 375 | if (err) { |
| 376 | DPRINTF(("uhidopen: usbd_open_pipe_intr failed, " |
| 377 | "error=%d\n",err)); |
| 378 | kfree(sc->sc_ibuf, M_USBDEV); |
| 379 | kfree(sc->sc_obuf, M_USBDEV); |
| 380 | sc->sc_ibuf = sc->sc_obuf = NULL; |
| 381 | |
| 382 | sc->sc_state &= ~UHID_OPEN; |
| 383 | return (EIO); |
| 384 | } |
| 385 | |
| 386 | sc->sc_state &= ~UHID_IMMED; |
| 387 | |
| 388 | sc->sc_async = 0; |
| 389 | |
| 390 | return (0); |
| 391 | } |
| 392 | |
| 393 | int |
| 394 | uhidclose(struct dev_close_args *ap) |
| 395 | { |
| 396 | cdev_t dev = ap->a_head.a_dev; |
| 397 | struct uhid_softc *sc; |
| 398 | |
| 399 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 400 | |
| 401 | DPRINTF(("uhidclose: sc=%p\n", sc)); |
| 402 | |
| 403 | /* Disable interrupts. */ |
| 404 | usbd_abort_pipe(sc->sc_intrpipe); |
| 405 | usbd_close_pipe(sc->sc_intrpipe); |
| 406 | sc->sc_intrpipe = 0; |
| 407 | |
| 408 | ndflush(&sc->sc_q, sc->sc_q.c_cc); |
| 409 | clist_free_cblocks(&sc->sc_q); |
| 410 | |
| 411 | kfree(sc->sc_ibuf, M_USBDEV); |
| 412 | kfree(sc->sc_obuf, M_USBDEV); |
| 413 | sc->sc_ibuf = sc->sc_obuf = NULL; |
| 414 | |
| 415 | sc->sc_state &= ~UHID_OPEN; |
| 416 | |
| 417 | sc->sc_async = 0; |
| 418 | |
| 419 | return (0); |
| 420 | } |
| 421 | |
| 422 | int |
| 423 | uhid_do_read(struct uhid_softc *sc, struct uio *uio, int flag) |
| 424 | { |
| 425 | int error = 0; |
| 426 | size_t length; |
| 427 | u_char buffer[UHID_CHUNK]; |
| 428 | usbd_status err; |
| 429 | |
| 430 | DPRINTFN(1, ("uhidread\n")); |
| 431 | if (sc->sc_state & UHID_IMMED) { |
| 432 | DPRINTFN(1, ("uhidread immed\n")); |
| 433 | |
| 434 | err = usbd_get_report(sc->sc_iface, UHID_INPUT_REPORT, |
| 435 | sc->sc_iid, buffer, sc->sc_isize); |
| 436 | if (err) |
| 437 | return (EIO); |
| 438 | return (uiomove(buffer, sc->sc_isize, uio)); |
| 439 | } |
| 440 | |
| 441 | crit_enter(); |
| 442 | while (sc->sc_q.c_cc == 0) { |
| 443 | if (flag & IO_NDELAY) { |
| 444 | crit_exit(); |
| 445 | return (EWOULDBLOCK); |
| 446 | } |
| 447 | sc->sc_state |= UHID_ASLP; |
| 448 | DPRINTFN(5, ("uhidread: sleep on %p\n", &sc->sc_q)); |
| 449 | error = tsleep(&sc->sc_q, PCATCH, "uhidrea", 0); |
| 450 | DPRINTFN(5, ("uhidread: woke, error=%d\n", error)); |
| 451 | if (sc->sc_dying) |
| 452 | error = EIO; |
| 453 | if (error) { |
| 454 | sc->sc_state &= ~UHID_ASLP; |
| 455 | break; |
| 456 | } |
| 457 | if (sc->sc_state & UHID_NEEDCLEAR) { |
| 458 | DPRINTFN(-1,("uhidread: clearing stall\n")); |
| 459 | sc->sc_state &= ~UHID_NEEDCLEAR; |
| 460 | usbd_clear_endpoint_stall(sc->sc_intrpipe); |
| 461 | } |
| 462 | } |
| 463 | crit_exit(); |
| 464 | |
| 465 | /* Transfer as many chunks as possible. */ |
| 466 | while (sc->sc_q.c_cc > 0 && uio->uio_resid > 0 && !error) { |
| 467 | length = szmin(sc->sc_q.c_cc, uio->uio_resid); |
| 468 | if (length > sizeof(buffer)) |
| 469 | length = sizeof(buffer); |
| 470 | |
| 471 | /* Remove a small chunk from the input queue. */ |
| 472 | (void) q_to_b(&sc->sc_q, buffer, length); |
| 473 | DPRINTFN(5, ("uhidread: got %lu chars\n", (u_long)length)); |
| 474 | |
| 475 | /* Copy the data to the user process. */ |
| 476 | if ((error = uiomove(buffer, length, uio)) != 0) |
| 477 | break; |
| 478 | } |
| 479 | |
| 480 | return (error); |
| 481 | } |
| 482 | |
| 483 | int |
| 484 | uhidread(struct dev_read_args *ap) |
| 485 | { |
| 486 | cdev_t dev = ap->a_head.a_dev; |
| 487 | struct uhid_softc *sc; |
| 488 | int error; |
| 489 | |
| 490 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 491 | |
| 492 | sc->sc_refcnt++; |
| 493 | error = uhid_do_read(sc, ap->a_uio, ap->a_ioflag); |
| 494 | if (--sc->sc_refcnt < 0) |
| 495 | usb_detach_wakeup(sc->sc_dev); |
| 496 | return (error); |
| 497 | } |
| 498 | |
| 499 | int |
| 500 | uhid_do_write(struct uhid_softc *sc, struct uio *uio, int flag) |
| 501 | { |
| 502 | int error; |
| 503 | int size; |
| 504 | usbd_status err; |
| 505 | |
| 506 | DPRINTFN(1, ("uhidwrite\n")); |
| 507 | |
| 508 | if (sc->sc_dying) |
| 509 | return (EIO); |
| 510 | |
| 511 | size = sc->sc_osize; |
| 512 | if (uio->uio_resid != size) |
| 513 | return (EINVAL); |
| 514 | error = uiomove(sc->sc_obuf, size, uio); |
| 515 | if (!error) { |
| 516 | if (sc->sc_oid) |
| 517 | err = usbd_set_report(sc->sc_iface, UHID_OUTPUT_REPORT, |
| 518 | sc->sc_obuf[0], sc->sc_obuf+1, size-1); |
| 519 | else |
| 520 | err = usbd_set_report(sc->sc_iface, UHID_OUTPUT_REPORT, |
| 521 | 0, sc->sc_obuf, size); |
| 522 | if (err) |
| 523 | error = EIO; |
| 524 | } |
| 525 | |
| 526 | return (error); |
| 527 | } |
| 528 | |
| 529 | int |
| 530 | uhidwrite(struct dev_write_args *ap) |
| 531 | { |
| 532 | cdev_t dev = ap->a_head.a_dev; |
| 533 | struct uhid_softc *sc; |
| 534 | int error; |
| 535 | |
| 536 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 537 | |
| 538 | sc->sc_refcnt++; |
| 539 | error = uhid_do_write(sc, ap->a_uio, ap->a_ioflag); |
| 540 | if (--sc->sc_refcnt < 0) |
| 541 | usb_detach_wakeup(sc->sc_dev); |
| 542 | return (error); |
| 543 | } |
| 544 | |
| 545 | int |
| 546 | uhid_do_ioctl(struct uhid_softc *sc, u_long cmd, caddr_t addr, int flag) |
| 547 | { |
| 548 | struct usb_ctl_report_desc *rd; |
| 549 | struct usb_ctl_report *re; |
| 550 | int size, id; |
| 551 | usbd_status err; |
| 552 | |
| 553 | DPRINTFN(2, ("uhidioctl: cmd=%lx\n", cmd)); |
| 554 | |
| 555 | if (sc->sc_dying) |
| 556 | return (EIO); |
| 557 | |
| 558 | switch (cmd) { |
| 559 | case FIOASYNC: |
| 560 | if (*(int *)addr) { |
| 561 | if (sc->sc_async != NULL) |
| 562 | return (EBUSY); |
| 563 | sc->sc_async = curproc; |
| 564 | DPRINTF(("uhid_do_ioctl: FIOASYNC %p\n", sc->sc_async)); |
| 565 | } else |
| 566 | sc->sc_async = NULL; |
| 567 | break; |
| 568 | |
| 569 | /* XXX this is not the most general solution. */ |
| 570 | case TIOCSPGRP: |
| 571 | if (sc->sc_async == NULL) |
| 572 | return (EINVAL); |
| 573 | if (*(int *)addr != sc->sc_async->p_pgid) |
| 574 | return (EPERM); |
| 575 | break; |
| 576 | |
| 577 | case USB_GET_REPORT_DESC: |
| 578 | rd = (struct usb_ctl_report_desc *)addr; |
| 579 | size = min(sc->sc_repdesc_size, sizeof rd->ucrd_data); |
| 580 | rd->ucrd_size = size; |
| 581 | memcpy(rd->ucrd_data, sc->sc_repdesc, size); |
| 582 | break; |
| 583 | |
| 584 | case USB_SET_IMMED: |
| 585 | if (*(int *)addr) { |
| 586 | /* XXX should read into ibuf, but does it matter? */ |
| 587 | err = usbd_get_report(sc->sc_iface, UHID_INPUT_REPORT, |
| 588 | sc->sc_iid, sc->sc_ibuf, sc->sc_isize); |
| 589 | if (err) |
| 590 | return (EOPNOTSUPP); |
| 591 | |
| 592 | sc->sc_state |= UHID_IMMED; |
| 593 | } else |
| 594 | sc->sc_state &= ~UHID_IMMED; |
| 595 | break; |
| 596 | |
| 597 | case USB_GET_REPORT: |
| 598 | re = (struct usb_ctl_report *)addr; |
| 599 | switch (re->ucr_report) { |
| 600 | case UHID_INPUT_REPORT: |
| 601 | size = sc->sc_isize; |
| 602 | id = sc->sc_iid; |
| 603 | break; |
| 604 | case UHID_OUTPUT_REPORT: |
| 605 | size = sc->sc_osize; |
| 606 | id = sc->sc_oid; |
| 607 | break; |
| 608 | case UHID_FEATURE_REPORT: |
| 609 | size = sc->sc_fsize; |
| 610 | id = sc->sc_fid; |
| 611 | break; |
| 612 | default: |
| 613 | return (EINVAL); |
| 614 | } |
| 615 | err = usbd_get_report(sc->sc_iface, re->ucr_report, id, re->ucr_data, |
| 616 | size); |
| 617 | if (err) |
| 618 | return (EIO); |
| 619 | break; |
| 620 | |
| 621 | case USB_SET_REPORT: |
| 622 | re = (struct usb_ctl_report *)addr; |
| 623 | switch (re->ucr_report) { |
| 624 | case UHID_INPUT_REPORT: |
| 625 | size = sc->sc_isize; |
| 626 | id = sc->sc_iid; |
| 627 | break; |
| 628 | case UHID_OUTPUT_REPORT: |
| 629 | size = sc->sc_osize; |
| 630 | id = sc->sc_oid; |
| 631 | break; |
| 632 | case UHID_FEATURE_REPORT: |
| 633 | size = sc->sc_fsize; |
| 634 | id = sc->sc_fid; |
| 635 | break; |
| 636 | default: |
| 637 | return (EINVAL); |
| 638 | } |
| 639 | err = usbd_set_report(sc->sc_iface, re->ucr_report, id, re->ucr_data, |
| 640 | size); |
| 641 | if (err) |
| 642 | return (EIO); |
| 643 | break; |
| 644 | |
| 645 | case USB_GET_REPORT_ID: |
| 646 | *(int *)addr = 0; /* XXX: we only support reportid 0? */ |
| 647 | break; |
| 648 | |
| 649 | default: |
| 650 | return (EINVAL); |
| 651 | } |
| 652 | return (0); |
| 653 | } |
| 654 | |
| 655 | int |
| 656 | uhidioctl(struct dev_ioctl_args *ap) |
| 657 | { |
| 658 | cdev_t dev = ap->a_head.a_dev; |
| 659 | struct uhid_softc *sc; |
| 660 | int error; |
| 661 | |
| 662 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 663 | |
| 664 | sc->sc_refcnt++; |
| 665 | error = uhid_do_ioctl(sc, ap->a_cmd, ap->a_data, ap->a_fflag); |
| 666 | if (--sc->sc_refcnt < 0) |
| 667 | usb_detach_wakeup(sc->sc_dev); |
| 668 | return (error); |
| 669 | } |
| 670 | |
| 671 | static struct filterops uhidfiltops_read = |
| 672 | { FILTEROP_ISFD, NULL, uhidfilt_detach, uhidfilt_read }; |
| 673 | static struct filterops uhidfiltops_write = |
| 674 | { FILTEROP_ISFD, NULL, uhidfilt_detach, uhidfilt_write }; |
| 675 | |
| 676 | int |
| 677 | uhidkqfilter(struct dev_kqfilter_args *ap) |
| 678 | { |
| 679 | cdev_t dev = ap->a_head.a_dev; |
| 680 | struct knote *kn = ap->a_kn; |
| 681 | struct uhid_softc *sc; |
| 682 | struct klist *klist; |
| 683 | |
| 684 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 685 | |
| 686 | if (sc->sc_dying) { |
| 687 | ap->a_result = 1; |
| 688 | return (0); |
| 689 | } |
| 690 | |
| 691 | ap->a_result = 0; |
| 692 | |
| 693 | switch (kn->kn_filter) { |
| 694 | case EVFILT_READ: |
| 695 | kn->kn_fop = &uhidfiltops_read; |
| 696 | kn->kn_hook = (caddr_t)sc; |
| 697 | break; |
| 698 | case EVFILT_WRITE: |
| 699 | kn->kn_fop = &uhidfiltops_write; |
| 700 | kn->kn_hook = (caddr_t)sc; |
| 701 | break; |
| 702 | default: |
| 703 | ap->a_result = EOPNOTSUPP; |
| 704 | return (0); |
| 705 | } |
| 706 | |
| 707 | klist = &sc->sc_rkq.ki_note; |
| 708 | knote_insert(klist, kn); |
| 709 | |
| 710 | return (0); |
| 711 | } |
| 712 | |
| 713 | static void |
| 714 | uhidfilt_detach(struct knote *kn) |
| 715 | { |
| 716 | cdev_t dev = (cdev_t)kn->kn_hook; |
| 717 | struct uhid_softc *sc; |
| 718 | struct klist *klist; |
| 719 | |
| 720 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 721 | |
| 722 | klist = &sc->sc_rkq.ki_note; |
| 723 | knote_remove(klist, kn); |
| 724 | } |
| 725 | |
| 726 | static int |
| 727 | uhidfilt_read(struct knote *kn, long hint) |
| 728 | { |
| 729 | cdev_t dev = (cdev_t)kn->kn_hook; |
| 730 | struct uhid_softc *sc; |
| 731 | int ready = 0; |
| 732 | |
| 733 | sc = devclass_get_softc(uhid_devclass, UHIDUNIT(dev)); |
| 734 | |
| 735 | crit_enter(); |
| 736 | if (sc->sc_q.c_cc > 0) |
| 737 | ready = 1; |
| 738 | crit_exit(); |
| 739 | |
| 740 | return (ready); |
| 741 | } |
| 742 | |
| 743 | static int |
| 744 | uhidfilt_write(struct knote *kn, long hint) |
| 745 | { |
| 746 | return (1); |
| 747 | } |
| 748 | |
| 749 | DRIVER_MODULE(uhid, uhub, uhid_driver, uhid_devclass, usbd_driver_load, 0); |
| 750 | |