sys/dev/usb/input/usbhid.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-NetBSD
   3  *
   4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   5  * Copyright (c) 2019 Vladimir Kondratyev <wulf@FreeBSD.org>
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Lennart Augustsson (lennart@augustsson.net) at
   9  * Carlstedt Research & Technology.
  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 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 /*
  37  * HID spec: https://www.usb.org/sites/default/files/documents/hid1_11.pdf
  38  */
  39
  40 #include <sys/stdint.h>
  41 #include <sys/stddef.h>
  42 #include <sys/param.h>
  43 #include <sys/queue.h>
  44 #include <sys/types.h>
  45 #include <sys/systm.h>
  46 #include <sys/kernel.h>
  47 #include <sys/bus.h>
  48 #include <sys/module.h>
  49 #include <sys/lock.h>
  50 #include <sys/mutex.h>
  51 #include <sys/condvar.h>
  52 #include <sys/sysctl.h>
  53 #include <sys/sx.h>
  54 #include <sys/unistd.h>
  55 #include <sys/callout.h>
  56 #include <sys/malloc.h>
  57 #include <sys/priv.h>
  58 #include <sys/conf.h>
  59 #include <sys/fcntl.h>
  60
  61 #include <dev/evdev/input.h>
  62
  63 #include <dev/hid/hid.h>
  64 #include <dev/hid/hidquirk.h>
  65
  66 #include <dev/usb/usb.h>
  67 #include <dev/usb/usbdi.h>
  68 #include <dev/usb/usbdi_util.h>
  69 #include <dev/usb/usbhid.h>
  70
  71 #define USB_DEBUG_VAR usbhid_debug
  72 #include <dev/usb/usb_debug.h>
  73
  74 #include <dev/usb/quirk/usb_quirk.h>
  75
  76 #include "hid_if.h"
  77
  78 static SYSCTL_NODE(_hw_usb, OID_AUTO, usbhid, CTLFLAG_RW, 0, "USB usbhid");
  79 static int usbhid_enable = 0;
  80 SYSCTL_INT(_hw_usb_usbhid, OID_AUTO, enable, CTLFLAG_RWTUN,
  81     &usbhid_enable, 0, "Enable usbhid and prefer it to other USB HID drivers");
  82 #ifdef USB_DEBUG
  83 static int usbhid_debug = 0;
  84 SYSCTL_INT(_hw_usb_usbhid, OID_AUTO, debug, CTLFLAG_RWTUN,
  85     &usbhid_debug, 0, "Debug level");
  86 #endif
  87
  88 enum {
  89         USBHID_INTR_OUT_DT,
  90         USBHID_INTR_IN_DT,
  91         USBHID_CTRL_DT,
  92         USBHID_N_TRANSFER,
  93 };
  94
  95 struct usbhid_xfer_ctx;
  96 typedef int usbhid_callback_t(struct usbhid_xfer_ctx *xfer_ctx);
  97
  98 union usbhid_device_request {
  99         struct {                        /* INTR xfers */
 100                 uint16_t maxlen;
 101                 uint16_t actlen;
 102         } intr;
 103         struct usb_device_request ctrl; /* CTRL xfers */
 104 };
 105
 106 /* Syncronous USB transfer context */
 107 struct usbhid_xfer_ctx {
 108         union usbhid_device_request req;
 109         uint8_t *buf;
 110         int error;
 111         usbhid_callback_t *cb;
 112         void *cb_ctx;
 113         int waiters;
 114         bool influx;
 115 };
 116
 117 struct usbhid_softc {
 118         hid_intr_t *sc_intr_handler;
 119         void *sc_intr_ctx;
 120         void *sc_intr_buf;
 121
 122         struct hid_device_info sc_hw;
 123
 124         struct mtx sc_mtx;
 125         struct usb_config sc_config[USBHID_N_TRANSFER];
 126         struct usb_xfer *sc_xfer[USBHID_N_TRANSFER];
 127         struct usbhid_xfer_ctx sc_xfer_ctx[USBHID_N_TRANSFER];
 128
 129         struct usb_device *sc_udev;
 130         uint8_t sc_iface_no;
 131         uint8_t sc_iface_index;
 132 };
 133
 134 /* prototypes */
 135
 136 static device_probe_t usbhid_probe;
 137 static device_attach_t usbhid_attach;
 138 static device_detach_t usbhid_detach;
 139
 140 static usb_callback_t usbhid_intr_out_callback;
 141 static usb_callback_t usbhid_intr_in_callback;
 142 static usb_callback_t usbhid_ctrl_callback;
 143
 144 static usbhid_callback_t usbhid_intr_handler_cb;
 145 static usbhid_callback_t usbhid_sync_wakeup_cb;
 146
 147 static void
 148 usbhid_intr_out_callback(struct usb_xfer *xfer, usb_error_t error)
 149 {
 150         struct usbhid_xfer_ctx *xfer_ctx = usbd_xfer_softc(xfer);
 151         struct usb_page_cache *pc;
 152         int len;
 153
 154         switch (USB_GET_STATE(xfer)) {
 155         case USB_ST_TRANSFERRED:
 156         case USB_ST_SETUP:
 157 tr_setup:
 158                 len = xfer_ctx->req.intr.maxlen;
 159                 if (len == 0) {
 160                         if (USB_IN_POLLING_MODE_FUNC())
 161                                 xfer_ctx->error = 0;
 162                         return;
 163                 }
 164                 pc = usbd_xfer_get_frame(xfer, 0);
 165                 usbd_copy_in(pc, 0, xfer_ctx->buf, len);
 166                 usbd_xfer_set_frame_len(xfer, 0, len);
 167                 usbd_transfer_submit(xfer);
 168                 xfer_ctx->req.intr.maxlen = 0;
 169                 if (USB_IN_POLLING_MODE_FUNC())
 170                         return;
 171                 xfer_ctx->error = 0;
 172                 goto tr_exit;
 173
 174         default:                        /* Error */
 175                 if (error != USB_ERR_CANCELLED) {
 176                         /* try to clear stall first */
 177                         usbd_xfer_set_stall(xfer);
 178                         goto tr_setup;
 179                 }
 180                 xfer_ctx->error = EIO;
 181 tr_exit:
 182                 (void)xfer_ctx->cb(xfer_ctx);
 183                 return;
 184         }
 185 }
 186
 187 static void
 188 usbhid_intr_in_callback(struct usb_xfer *xfer, usb_error_t error)
 189 {
 190         struct usbhid_xfer_ctx *xfer_ctx = usbd_xfer_softc(xfer);
 191         struct usb_page_cache *pc;
 192         int actlen;
 193
 194         switch (USB_GET_STATE(xfer)) {
 195         case USB_ST_TRANSFERRED:
 196                 DPRINTF("transferred!\n");
 197
 198                 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 199                 pc = usbd_xfer_get_frame(xfer, 0);
 200                 usbd_copy_out(pc, 0, xfer_ctx->buf, actlen);
 201                 xfer_ctx->req.intr.actlen = actlen;
 202                 if (xfer_ctx->cb(xfer_ctx) != 0)
 203                         return;
 204
 205         case USB_ST_SETUP:
 206 re_submit:
 207                 usbd_xfer_set_frame_len(xfer, 0, xfer_ctx->req.intr.maxlen);
 208                 usbd_transfer_submit(xfer);
 209                 return;
 210
 211         default:                        /* Error */
 212                 if (error != USB_ERR_CANCELLED) {
 213                         /* try to clear stall first */
 214                         usbd_xfer_set_stall(xfer);
 215                         goto re_submit;
 216                 }
 217                 return;
 218         }
 219 }
 220
 221 static void
 222 usbhid_ctrl_callback(struct usb_xfer *xfer, usb_error_t error)
 223 {
 224         struct usbhid_xfer_ctx *xfer_ctx = usbd_xfer_softc(xfer);
 225         struct usb_device_request *req = &xfer_ctx->req.ctrl;
 226         struct usb_page_cache *pc;
 227         int len = UGETW(req->wLength);
 228         bool is_rd = (req->bmRequestType & UT_READ) != 0;
 229
 230         switch (USB_GET_STATE(xfer)) {
 231         case USB_ST_SETUP:
 232                 if (!is_rd && len != 0) {
 233                         pc = usbd_xfer_get_frame(xfer, 1);
 234                         usbd_copy_in(pc, 0, xfer_ctx->buf, len);
 235                 }
 236
 237                 pc = usbd_xfer_get_frame(xfer, 0);
 238                 usbd_copy_in(pc, 0, req, sizeof(*req));
 239                 usbd_xfer_set_frame_len(xfer, 0, sizeof(*req));
 240                 if (len != 0)
 241                         usbd_xfer_set_frame_len(xfer, 1, len);
 242                 usbd_xfer_set_frames(xfer, len != 0 ? 2 : 1);
 243                 usbd_transfer_submit(xfer);
 244                 return;
 245
 246         case USB_ST_TRANSFERRED:
 247                 if (is_rd && len != 0) {
 248                         pc = usbd_xfer_get_frame(xfer, 0);
 249                         usbd_copy_out(pc, sizeof(*req), xfer_ctx->buf, len);
 250                 }
 251                 xfer_ctx->error = 0;
 252                 goto tr_exit;
 253
 254         default:                        /* Error */
 255                 /* bomb out */
 256                 DPRINTFN(1, "error=%s\n", usbd_errstr(error));
 257                 xfer_ctx->error = EIO;
 258 tr_exit:
 259                 (void)xfer_ctx->cb(xfer_ctx);
 260                 return;
 261         }
 262 }
 263
 264 static int
 265 usbhid_intr_handler_cb(struct usbhid_xfer_ctx *xfer_ctx)
 266 {
 267         struct usbhid_softc *sc = xfer_ctx->cb_ctx;
 268
 269         sc->sc_intr_handler(sc->sc_intr_ctx, xfer_ctx->buf,
 270             xfer_ctx->req.intr.actlen);
 271
 272         return (0);
 273 }
 274
 275 static int
 276 usbhid_sync_wakeup_cb(struct usbhid_xfer_ctx *xfer_ctx)
 277 {
 278
 279         if (!USB_IN_POLLING_MODE_FUNC())
 280                 wakeup(xfer_ctx->cb_ctx);
 281
 282         return (ECANCELED);
 283 }
 284
 285 static const struct usb_config usbhid_config[USBHID_N_TRANSFER] = {
 286
 287         [USBHID_INTR_OUT_DT] = {
 288                 .type = UE_INTERRUPT,
 289                 .endpoint = UE_ADDR_ANY,
 290                 .direction = UE_DIR_OUT,
 291                 .flags = {.pipe_bof = 1,.proxy_buffer = 1},
 292                 .callback = &usbhid_intr_out_callback,
 293         },
 294         [USBHID_INTR_IN_DT] = {
 295                 .type = UE_INTERRUPT,
 296                 .endpoint = UE_ADDR_ANY,
 297                 .direction = UE_DIR_IN,
 298                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1},
 299                 .callback = &usbhid_intr_in_callback,
 300         },
 301         [USBHID_CTRL_DT] = {
 302                 .type = UE_CONTROL,
 303                 .endpoint = 0x00,       /* Control pipe */
 304                 .direction = UE_DIR_ANY,
 305                 .flags = {.proxy_buffer = 1},
 306                 .callback = &usbhid_ctrl_callback,
 307                 .timeout = 1000,        /* 1 second */
 308         },
 309 };
 310
 311 static void
 312 usbhid_intr_setup(device_t dev, hid_intr_t intr, void *context,
 313     struct hid_rdesc_info *rdesc)
 314 {
 315         struct usbhid_softc* sc = device_get_softc(dev);
 316         uint16_t n;
 317         bool nowrite;
 318         int error;
 319
 320         sc->sc_intr_handler = intr;
 321         sc->sc_intr_ctx = context;
 322         bcopy(usbhid_config, sc->sc_config, sizeof(usbhid_config));
 323
 324         /* Set buffer sizes to match HID report sizes */
 325         sc->sc_config[USBHID_INTR_OUT_DT].bufsize = rdesc->osize;
 326         sc->sc_config[USBHID_INTR_IN_DT].bufsize = rdesc->isize;
 327         sc->sc_config[USBHID_CTRL_DT].bufsize =
 328             MAX(rdesc->isize, MAX(rdesc->osize, rdesc->fsize));
 329
 330         nowrite = hid_test_quirk(&sc->sc_hw, HQ_NOWRITE);
 331
 332         /*
 333          * Setup the USB transfers one by one, so they are memory independent
 334          * which allows for handling panics triggered by the HID drivers
 335          * itself, typically by hkbd via CTRL+ALT+ESC sequences. Or if the HID
 336          * keyboard driver was processing a key at the moment of panic.
 337          */
 338         for (n = 0; n != USBHID_N_TRANSFER; n++) {
 339                 if (nowrite && n == USBHID_INTR_OUT_DT)
 340                         continue;
 341                 error = usbd_transfer_setup(sc->sc_udev, &sc->sc_iface_index,
 342                     sc->sc_xfer + n, sc->sc_config + n, 1,
 343                     (void *)(sc->sc_xfer_ctx + n), &sc->sc_mtx);
 344                 if (error)
 345                         break;
 346         }
 347
 348         if (error)
 349                 DPRINTF("error=%s\n", usbd_errstr(error));
 350
 351         rdesc->rdsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]);
 352         rdesc->grsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]);
 353         rdesc->srsize = rdesc->grsize;
 354         rdesc->wrsize = nowrite ? rdesc->srsize :
 355             usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]);
 356
 357         sc->sc_intr_buf = malloc(rdesc->rdsize, M_USBDEV, M_ZERO | M_WAITOK);
 358 }
 359
 360 static void
 361 usbhid_intr_unsetup(device_t dev)
 362 {
 363         struct usbhid_softc* sc = device_get_softc(dev);
 364
 365         usbd_transfer_unsetup(sc->sc_xfer, USBHID_N_TRANSFER);
 366         free(sc->sc_intr_buf, M_USBDEV);
 367 }
 368
 369 static int
 370 usbhid_intr_start(device_t dev)
 371 {
 372         struct usbhid_softc* sc = device_get_softc(dev);
 373
 374         mtx_lock(&sc->sc_mtx);
 375         sc->sc_xfer_ctx[USBHID_INTR_IN_DT] = (struct usbhid_xfer_ctx) {
 376                 .req.intr.maxlen =
 377                     usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]),
 378                 .cb = usbhid_intr_handler_cb,
 379                 .cb_ctx = sc,
 380                 .buf = sc->sc_intr_buf,
 381         };
 382         usbd_transfer_start(sc->sc_xfer[USBHID_INTR_IN_DT]);
 383         mtx_unlock(&sc->sc_mtx);
 384
 385         return (0);
 386 }
 387
 388 static int
 389 usbhid_intr_stop(device_t dev)
 390 {
 391         struct usbhid_softc* sc = device_get_softc(dev);
 392
 393         usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_IN_DT]);
 394         usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_OUT_DT]);
 395
 396         return (0);
 397 }
 398
 399 static void
 400 usbhid_intr_poll(device_t dev)
 401 {
 402         struct usbhid_softc* sc = device_get_softc(dev);
 403
 404         usbd_transfer_poll(sc->sc_xfer + USBHID_INTR_IN_DT, 1);
 405 }
 406
 407 /*
 408  * HID interface
 409  */
 410 static int
 411 usbhid_sync_xfer(struct usbhid_softc* sc, int xfer_idx,
 412     union usbhid_device_request *req, void *buf)
 413 {
 414         int error, timeout;
 415         struct usbhid_xfer_ctx *xfer_ctx, save;
 416
 417         xfer_ctx = sc->sc_xfer_ctx + xfer_idx;
 418
 419         if (USB_IN_POLLING_MODE_FUNC()) {
 420                 save = *xfer_ctx;
 421         } else {
 422                 mtx_lock(&sc->sc_mtx);
 423                 ++xfer_ctx->waiters;
 424                 while (xfer_ctx->influx)
 425                         mtx_sleep(&xfer_ctx->waiters, &sc->sc_mtx, 0,
 426                             "usbhid wt", 0);
 427                 --xfer_ctx->waiters;
 428                 xfer_ctx->influx = true;
 429         }
 430
 431         xfer_ctx->buf = buf;
 432         xfer_ctx->req = *req;
 433         xfer_ctx->error = ETIMEDOUT;
 434         xfer_ctx->cb = &usbhid_sync_wakeup_cb;
 435         xfer_ctx->cb_ctx = xfer_ctx;
 436         timeout = USB_DEFAULT_TIMEOUT;
 437         usbd_transfer_start(sc->sc_xfer[xfer_idx]);
 438
 439         if (USB_IN_POLLING_MODE_FUNC())
 440                 while (timeout > 0 && xfer_ctx->error == ETIMEDOUT) {
 441                         usbd_transfer_poll(sc->sc_xfer + xfer_idx, 1);
 442                         DELAY(1000);
 443                         timeout--;
 444                 }
 445          else
 446                 msleep_sbt(xfer_ctx, &sc->sc_mtx, 0, "usbhid io",
 447                     SBT_1MS * timeout, 0, C_HARDCLOCK);
 448
 449         /* Perform usbhid_write() asyncronously to improve pipelining */
 450         if (USB_IN_POLLING_MODE_FUNC() || xfer_ctx->error != 0 ||
 451             sc->sc_config[xfer_idx].type != UE_INTERRUPT ||
 452             sc->sc_config[xfer_idx].direction != UE_DIR_OUT)
 453                 usbd_transfer_stop(sc->sc_xfer[xfer_idx]);
 454         error = xfer_ctx->error;
 455         if (error == 0)
 456                 *req = xfer_ctx->req;
 457
 458         if (USB_IN_POLLING_MODE_FUNC()) {
 459                 *xfer_ctx = save;
 460         } else {
 461                 xfer_ctx->influx = false;
 462                 if (xfer_ctx->waiters != 0)
 463                         wakeup_one(&xfer_ctx->waiters);
 464                 mtx_unlock(&sc->sc_mtx);
 465         }
 466
 467         if (error)
 468                 DPRINTF("USB IO error:%d\n", error);
 469
 470         return (error);
 471 }
 472
 473 static int
 474 usbhid_get_rdesc(device_t dev, void *buf, hid_size_t len)
 475 {
 476         struct usbhid_softc* sc = device_get_softc(dev);
 477         int error;
 478
 479         error = usbd_req_get_report_descriptor(sc->sc_udev, NULL,
 480             buf, len, sc->sc_iface_index);
 481
 482         if (error)
 483                 DPRINTF("no report descriptor: %s\n", usbd_errstr(error));
 484
 485         return (error == 0 ? 0 : ENXIO);
 486 }
 487
 488 static int
 489 usbhid_get_report(device_t dev, void *buf, hid_size_t maxlen,
 490     hid_size_t *actlen, uint8_t type, uint8_t id)
 491 {
 492         struct usbhid_softc* sc = device_get_softc(dev);
 493         union usbhid_device_request req;
 494         int error;
 495
 496         if (maxlen > usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]))
 497                 return (ENOBUFS);
 498
 499         req.ctrl.bmRequestType = UT_READ_CLASS_INTERFACE;
 500         req.ctrl.bRequest = UR_GET_REPORT;
 501         USETW2(req.ctrl.wValue, type, id);
 502         req.ctrl.wIndex[0] = sc->sc_iface_no;
 503         req.ctrl.wIndex[1] = 0;
 504         USETW(req.ctrl.wLength, maxlen);
 505
 506         error = usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req, buf);
 507         if (!error && actlen != NULL)
 508                 *actlen = maxlen;
 509
 510         return (error);
 511 }
 512
 513 static int
 514 usbhid_set_report(device_t dev, const void *buf, hid_size_t len, uint8_t type,
 515     uint8_t id)
 516 {
 517         struct usbhid_softc* sc = device_get_softc(dev);
 518         union usbhid_device_request req;
 519
 520         if (len > usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]))
 521                 return (ENOBUFS);
 522
 523         req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 524         req.ctrl.bRequest = UR_SET_REPORT;
 525         USETW2(req.ctrl.wValue, type, id);
 526         req.ctrl.wIndex[0] = sc->sc_iface_no;
 527         req.ctrl.wIndex[1] = 0;
 528         USETW(req.ctrl.wLength, len);
 529
 530         return (usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req,
 531             __DECONST(void *, buf)));
 532 }
 533
 534 static int
 535 usbhid_read(device_t dev, void *buf, hid_size_t maxlen, hid_size_t *actlen)
 536 {
 537         struct usbhid_softc* sc = device_get_softc(dev);
 538         union usbhid_device_request req;
 539         int error;
 540
 541         if (maxlen > usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]))
 542                 return (ENOBUFS);
 543
 544         req.intr.maxlen = maxlen;
 545         error = usbhid_sync_xfer(sc, USBHID_INTR_IN_DT, &req, buf);
 546         if (error == 0 && actlen != NULL)
 547                 *actlen = req.intr.actlen;
 548
 549         return (error);
 550 }
 551
 552 static int
 553 usbhid_write(device_t dev, const void *buf, hid_size_t len)
 554 {
 555         struct usbhid_softc* sc = device_get_softc(dev);
 556         union usbhid_device_request req;
 557
 558         if (len > usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]))
 559                 return (ENOBUFS);
 560
 561         req.intr.maxlen = len;
 562         return (usbhid_sync_xfer(sc, USBHID_INTR_OUT_DT, &req,
 563             __DECONST(void *, buf)));
 564 }
 565
 566 static int
 567 usbhid_set_idle(device_t dev, uint16_t duration, uint8_t id)
 568 {
 569         struct usbhid_softc* sc = device_get_softc(dev);
 570         union usbhid_device_request req;
 571
 572         /* Duration is measured in 4 milliseconds per unit. */
 573         req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 574         req.ctrl.bRequest = UR_SET_IDLE;
 575         USETW2(req.ctrl.wValue, (duration + 3) / 4, id);
 576         req.ctrl.wIndex[0] = sc->sc_iface_no;
 577         req.ctrl.wIndex[1] = 0;
 578         USETW(req.ctrl.wLength, 0);
 579
 580         return (usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req, NULL));
 581 }
 582
 583 static int
 584 usbhid_set_protocol(device_t dev, uint16_t protocol)
 585 {
 586         struct usbhid_softc* sc = device_get_softc(dev);
 587         union usbhid_device_request req;
 588
 589         req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 590         req.ctrl.bRequest = UR_SET_PROTOCOL;
 591         USETW(req.ctrl.wValue, protocol);
 592         req.ctrl.wIndex[0] = sc->sc_iface_no;
 593         req.ctrl.wIndex[1] = 0;
 594         USETW(req.ctrl.wLength, 0);
 595
 596         return (usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req, NULL));
 597 }
 598
 599 static void
 600 usbhid_init_device_info(struct usb_attach_arg *uaa, struct hid_device_info *hw)
 601 {
 602
 603         hw->idBus = BUS_USB;
 604         hw->idVendor = uaa->info.idVendor;
 605         hw->idProduct = uaa->info.idProduct;
 606         hw->idVersion = uaa->info.bcdDevice;
 607
 608         /* Set various quirks based on usb_attach_arg */
 609         hid_add_dynamic_quirk(hw, USB_GET_DRIVER_INFO(uaa));
 610 }
 611
 612 static void
 613 usbhid_fill_device_info(struct usb_attach_arg *uaa, struct hid_device_info *hw)
 614 {
 615         struct usb_device *udev = uaa->device;
 616         struct usb_interface *iface = uaa->iface;
 617         struct usb_hid_descriptor *hid;
 618         struct usb_endpoint *ep;
 619
 620         snprintf(hw->name, sizeof(hw->name), "%s %s",
 621             usb_get_manufacturer(udev), usb_get_product(udev));
 622         strlcpy(hw->serial, usb_get_serial(udev), sizeof(hw->serial));
 623
 624         if (uaa->info.bInterfaceClass == UICLASS_HID &&
 625             iface != NULL && iface->idesc != NULL) {
 626                 hid = hid_get_descriptor_from_usb(
 627                     usbd_get_config_descriptor(udev), iface->idesc);
 628                 if (hid != NULL)
 629                         hw->rdescsize =
 630                             UGETW(hid->descrs[0].wDescriptorLength);
 631         }
 632
 633         /* See if there is a interrupt out endpoint. */
 634         ep = usbd_get_endpoint(udev, uaa->info.bIfaceIndex,
 635             usbhid_config + USBHID_INTR_OUT_DT);
 636         if (ep == NULL || ep->methods == NULL)
 637                 hid_add_dynamic_quirk(hw, HQ_NOWRITE);
 638 }
 639
 640 static const STRUCT_USB_HOST_ID usbhid_devs[] = {
 641         /* the Xbox 360 gamepad doesn't use the HID class */
 642         {USB_IFACE_CLASS(UICLASS_VENDOR),
 643          USB_IFACE_SUBCLASS(UISUBCLASS_XBOX360_CONTROLLER),
 644          USB_IFACE_PROTOCOL(UIPROTO_XBOX360_GAMEPAD),
 645          USB_DRIVER_INFO(HQ_IS_XBOX360GP)},
 646         /* HID keyboard with boot protocol support */
 647         {USB_IFACE_CLASS(UICLASS_HID),
 648          USB_IFACE_SUBCLASS(UISUBCLASS_BOOT),
 649          USB_IFACE_PROTOCOL(UIPROTO_BOOT_KEYBOARD),
 650          USB_DRIVER_INFO(HQ_HAS_KBD_BOOTPROTO)},
 651         /* HID mouse with boot protocol support */
 652         {USB_IFACE_CLASS(UICLASS_HID),
 653          USB_IFACE_SUBCLASS(UISUBCLASS_BOOT),
 654          USB_IFACE_PROTOCOL(UIPROTO_MOUSE),
 655          USB_DRIVER_INFO(HQ_HAS_MS_BOOTPROTO)},
 656         /* generic HID class */
 657         {USB_IFACE_CLASS(UICLASS_HID), USB_DRIVER_INFO(HQ_NONE)},
 658 };
 659
 660 static int
 661 usbhid_probe(device_t dev)
 662 {
 663         struct usb_attach_arg *uaa = device_get_ivars(dev);
 664         struct usbhid_softc *sc = device_get_softc(dev);
 665         int error;
 666
 667         DPRINTFN(11, "\n");
 668
 669         if (usbhid_enable == 0)
 670                 return (ENXIO);
 671
 672         if (uaa->usb_mode != USB_MODE_HOST)
 673                 return (ENXIO);
 674
 675         error = usbd_lookup_id_by_uaa(usbhid_devs, sizeof(usbhid_devs), uaa);
 676         if (error)
 677                 return (error);
 678
 679         if (usb_test_quirk(uaa, UQ_HID_IGNORE))
 680                 return (ENXIO);
 681
 682         /*
 683          * Setup temporary hid_device_info so that we can figure out some
 684          * basic quirks for this device.
 685          */
 686         usbhid_init_device_info(uaa, &sc->sc_hw);
 687
 688         if (hid_test_quirk(&sc->sc_hw, HQ_HID_IGNORE))
 689                 return (ENXIO);
 690
 691         return (BUS_PROBE_GENERIC + 1);
 692 }
 693
 694 static int
 695 usbhid_attach(device_t dev)
 696 {
 697         struct usb_attach_arg *uaa = device_get_ivars(dev);
 698         struct usbhid_softc *sc = device_get_softc(dev);
 699         device_t child;
 700         int error = 0;
 701
 702         DPRINTFN(10, "sc=%p\n", sc);
 703
 704         device_set_usb_desc(dev);
 705
 706         sc->sc_udev = uaa->device;
 707         sc->sc_iface_no = uaa->info.bIfaceNum;
 708         sc->sc_iface_index = uaa->info.bIfaceIndex;
 709
 710         usbhid_fill_device_info(uaa, &sc->sc_hw);
 711
 712         error = usbd_req_set_idle(uaa->device, NULL,
 713             uaa->info.bIfaceIndex, 0, 0);
 714         if (error)
 715                 DPRINTF("set idle failed, error=%s (ignored)\n",
 716                     usbd_errstr(error));
 717
 718         mtx_init(&sc->sc_mtx, "usbhid lock", NULL, MTX_DEF);
 719
 720         child = device_add_child(dev, "hidbus", -1);
 721         if (child == NULL) {
 722                 device_printf(dev, "Could not add hidbus device\n");
 723                 usbhid_detach(dev);
 724                 return (ENOMEM);
 725         }
 726
 727         device_set_ivars(child, &sc->sc_hw);
 728         error = bus_generic_attach(dev);
 729         if (error) {
 730                 device_printf(dev, "failed to attach child: %d\n", error);
 731                 usbhid_detach(dev);
 732                 return (error);
 733         }
 734
 735         return (0);                     /* success */
 736 }
 737
 738 static int
 739 usbhid_detach(device_t dev)
 740 {
 741         struct usbhid_softc *sc = device_get_softc(dev);
 742
 743         device_delete_children(dev);
 744         mtx_destroy(&sc->sc_mtx);
 745
 746         return (0);
 747 }
 748
 749 static devclass_t usbhid_devclass;
 750
 751 static device_method_t usbhid_methods[] = {
 752         DEVMETHOD(device_probe,         usbhid_probe),
 753         DEVMETHOD(device_attach,        usbhid_attach),
 754         DEVMETHOD(device_detach,        usbhid_detach),
 755
 756         DEVMETHOD(hid_intr_setup,       usbhid_intr_setup),
 757         DEVMETHOD(hid_intr_unsetup,     usbhid_intr_unsetup),
 758         DEVMETHOD(hid_intr_start,       usbhid_intr_start),
 759         DEVMETHOD(hid_intr_stop,        usbhid_intr_stop),
 760         DEVMETHOD(hid_intr_poll,        usbhid_intr_poll),
 761
 762         /* HID interface */
 763         DEVMETHOD(hid_get_rdesc,        usbhid_get_rdesc),
 764         DEVMETHOD(hid_read,             usbhid_read),
 765         DEVMETHOD(hid_write,            usbhid_write),
 766         DEVMETHOD(hid_get_report,       usbhid_get_report),
 767         DEVMETHOD(hid_set_report,       usbhid_set_report),
 768         DEVMETHOD(hid_set_idle,         usbhid_set_idle),
 769         DEVMETHOD(hid_set_protocol,     usbhid_set_protocol),
 770
 771         DEVMETHOD_END
 772 };
 773
 774 static driver_t usbhid_driver = {
 775         .name = "usbhid",
 776         .methods = usbhid_methods,
 777         .size = sizeof(struct usbhid_softc),
 778 };
 779
 780 DRIVER_MODULE(usbhid, uhub, usbhid_driver, usbhid_devclass, NULL, 0);
 781 MODULE_DEPEND(usbhid, usb, 1, 1, 1);
 782 MODULE_DEPEND(usbhid, hid, 1, 1, 1);
 783 MODULE_DEPEND(usbhid, hidbus, 1, 1, 1);
 784 MODULE_VERSION(usbhid, 1);
 785 USB_PNP_HOST_INFO(usbhid_devs);