sys/dev/usb/input/uhid.c

   1 /*      $NetBSD: uhid.c,v 1.46 2001/11/13 06:24:55 lukem Exp $  */
   2
   3 /* Also already merged from NetBSD:
   4  *      $NetBSD: uhid.c,v 1.54 2002/09/23 05:51:21 simonb Exp $
   5  */
   6
   7 #include <sys/cdefs.h>
   8 __FBSDID("$FreeBSD$");
   9
  10 /*-
  11  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  12  * All rights reserved.
  13  *
  14  * This code is derived from software contributed to The NetBSD Foundation
  15  * by Lennart Augustsson (lennart@augustsson.net) at
  16  * Carlstedt Research & Technology.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 /*
  41  * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
  42  */
  43
  44 #include <sys/stdint.h>
  45 #include <sys/stddef.h>
  46 #include <sys/param.h>
  47 #include <sys/queue.h>
  48 #include <sys/types.h>
  49 #include <sys/systm.h>
  50 #include <sys/kernel.h>
  51 #include <sys/bus.h>
  52 #include <sys/module.h>
  53 #include <sys/lock.h>
  54 #include <sys/mutex.h>
  55 #include <sys/condvar.h>
  56 #include <sys/sysctl.h>
  57 #include <sys/sx.h>
  58 #include <sys/unistd.h>
  59 #include <sys/callout.h>
  60 #include <sys/malloc.h>
  61 #include <sys/priv.h>
  62 #include <sys/conf.h>
  63 #include <sys/fcntl.h>
  64
  65 #include "usbdevs.h"
  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 #include <dev/usb/usb_ioctl.h>
  71
  72 #define USB_DEBUG_VAR uhid_debug
  73 #include <dev/usb/usb_debug.h>
  74
  75 #include <dev/usb/input/usb_rdesc.h>
  76 #include <dev/usb/quirk/usb_quirk.h>
  77
  78 #ifdef USB_DEBUG
  79 static int uhid_debug = 0;
  80
  81 SYSCTL_NODE(_hw_usb, OID_AUTO, uhid, CTLFLAG_RW, 0, "USB uhid");
  82 SYSCTL_INT(_hw_usb_uhid, OID_AUTO, debug, CTLFLAG_RW,
  83     &uhid_debug, 0, "Debug level");
  84 #endif
  85
  86 #define UHID_BSIZE      1024            /* bytes, buffer size */
  87 #define UHID_FRAME_NUM    50            /* bytes, frame number */
  88
  89 enum {
  90         UHID_INTR_DT_RD,
  91         UHID_CTRL_DT_WR,
  92         UHID_CTRL_DT_RD,
  93         UHID_N_TRANSFER,
  94 };
  95
  96 struct uhid_softc {
  97         struct usb_fifo_sc sc_fifo;
  98         struct mtx sc_mtx;
  99
 100         struct usb_xfer *sc_xfer[UHID_N_TRANSFER];
 101         struct usb_device *sc_udev;
 102         void   *sc_repdesc_ptr;
 103
 104         uint32_t sc_isize;
 105         uint32_t sc_osize;
 106         uint32_t sc_fsize;
 107
 108         uint16_t sc_repdesc_size;
 109
 110         uint8_t sc_iface_no;
 111         uint8_t sc_iface_index;
 112         uint8_t sc_iid;
 113         uint8_t sc_oid;
 114         uint8_t sc_fid;
 115         uint8_t sc_flags;
 116 #define UHID_FLAG_IMMED        0x01     /* set if read should be immediate */
 117 #define UHID_FLAG_STATIC_DESC  0x04     /* set if report descriptors are
 118                                          * static */
 119 };
 120
 121 static const uint8_t uhid_xb360gp_report_descr[] = {UHID_XB360GP_REPORT_DESCR()};
 122 static const uint8_t uhid_graphire_report_descr[] = {UHID_GRAPHIRE_REPORT_DESCR()};
 123 static const uint8_t uhid_graphire3_4x5_report_descr[] = {UHID_GRAPHIRE3_4X5_REPORT_DESCR()};
 124
 125 /* prototypes */
 126
 127 static device_probe_t uhid_probe;
 128 static device_attach_t uhid_attach;
 129 static device_detach_t uhid_detach;
 130
 131 static usb_callback_t uhid_intr_callback;
 132 static usb_callback_t uhid_write_callback;
 133 static usb_callback_t uhid_read_callback;
 134
 135 static usb_fifo_cmd_t uhid_start_read;
 136 static usb_fifo_cmd_t uhid_stop_read;
 137 static usb_fifo_cmd_t uhid_start_write;
 138 static usb_fifo_cmd_t uhid_stop_write;
 139 static usb_fifo_open_t uhid_open;
 140 static usb_fifo_close_t uhid_close;
 141 static usb_fifo_ioctl_t uhid_ioctl;
 142
 143 static struct usb_fifo_methods uhid_fifo_methods = {
 144         .f_open = &uhid_open,
 145         .f_close = &uhid_close,
 146         .f_ioctl = &uhid_ioctl,
 147         .f_start_read = &uhid_start_read,
 148         .f_stop_read = &uhid_stop_read,
 149         .f_start_write = &uhid_start_write,
 150         .f_stop_write = &uhid_stop_write,
 151         .basename[0] = "uhid",
 152 };
 153
 154 static void
 155 uhid_intr_callback(struct usb_xfer *xfer, usb_error_t error)
 156 {
 157         struct uhid_softc *sc = usbd_xfer_softc(xfer);
 158         struct usb_page_cache *pc;
 159         int actlen;
 160
 161         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 162
 163         switch (USB_GET_STATE(xfer)) {
 164         case USB_ST_TRANSFERRED:
 165                 DPRINTF("transferred!\n");
 166
 167                 pc = usbd_xfer_get_frame(xfer, 0);
 168
 169                 /*
 170                  * If the ID byte is non zero we allow descriptors
 171                  * having multiple sizes:
 172                  */
 173                 if ((actlen >= sc->sc_isize) ||
 174                     ((actlen > 0) && (sc->sc_iid != 0))) {
 175                         /* limit report length to the maximum */
 176                         if (actlen > sc->sc_isize)
 177                                 actlen = sc->sc_isize;
 178                         usb_fifo_put_data(sc->sc_fifo.fp[USB_FIFO_RX], pc,
 179                             0, actlen, 1);
 180                 } else {
 181                         /* ignore it */
 182                         DPRINTF("ignored transfer, %d bytes\n", actlen);
 183                 }
 184
 185         case USB_ST_SETUP:
 186 re_submit:
 187                 if (usb_fifo_put_bytes_max(
 188                     sc->sc_fifo.fp[USB_FIFO_RX]) != 0) {
 189                         usbd_xfer_set_frame_len(xfer, 0, sc->sc_isize);
 190                         usbd_transfer_submit(xfer);
 191                 }
 192                 return;
 193
 194         default:                        /* Error */
 195                 if (error != USB_ERR_CANCELLED) {
 196                         /* try to clear stall first */
 197                         usbd_xfer_set_stall(xfer);
 198                         goto re_submit;
 199                 }
 200                 return;
 201         }
 202 }
 203
 204 static void
 205 uhid_fill_set_report(struct usb_device_request *req, uint8_t iface_no,
 206     uint8_t type, uint8_t id, uint16_t size)
 207 {
 208         req->bmRequestType = UT_WRITE_CLASS_INTERFACE;
 209         req->bRequest = UR_SET_REPORT;
 210         USETW2(req->wValue, type, id);
 211         req->wIndex[0] = iface_no;
 212         req->wIndex[1] = 0;
 213         USETW(req->wLength, size);
 214 }
 215
 216 static void
 217 uhid_fill_get_report(struct usb_device_request *req, uint8_t iface_no,
 218     uint8_t type, uint8_t id, uint16_t size)
 219 {
 220         req->bmRequestType = UT_READ_CLASS_INTERFACE;
 221         req->bRequest = UR_GET_REPORT;
 222         USETW2(req->wValue, type, id);
 223         req->wIndex[0] = iface_no;
 224         req->wIndex[1] = 0;
 225         USETW(req->wLength, size);
 226 }
 227
 228 static void
 229 uhid_write_callback(struct usb_xfer *xfer, usb_error_t error)
 230 {
 231         struct uhid_softc *sc = usbd_xfer_softc(xfer);
 232         struct usb_device_request req;
 233         struct usb_page_cache *pc;
 234         uint32_t size = sc->sc_osize;
 235         uint32_t actlen;
 236         uint8_t id;
 237
 238         switch (USB_GET_STATE(xfer)) {
 239         case USB_ST_TRANSFERRED:
 240         case USB_ST_SETUP:
 241                 /* try to extract the ID byte */
 242                 if (sc->sc_oid) {
 243                         pc = usbd_xfer_get_frame(xfer, 0);
 244                         if (usb_fifo_get_data(sc->sc_fifo.fp[USB_FIFO_TX], pc,
 245                             0, 1, &actlen, 0)) {
 246                                 if (actlen != 1) {
 247                                         goto tr_error;
 248                                 }
 249                                 usbd_copy_out(pc, 0, &id, 1);
 250
 251                         } else {
 252                                 return;
 253                         }
 254                         if (size) {
 255                                 size--;
 256                         }
 257                 } else {
 258                         id = 0;
 259                 }
 260
 261                 pc = usbd_xfer_get_frame(xfer, 1);
 262                 if (usb_fifo_get_data(sc->sc_fifo.fp[USB_FIFO_TX], pc,
 263                     0, UHID_BSIZE, &actlen, 1)) {
 264                         if (actlen != size) {
 265                                 goto tr_error;
 266                         }
 267                         uhid_fill_set_report
 268                             (&req, sc->sc_iface_no,
 269                             UHID_OUTPUT_REPORT, id, size);
 270
 271                         pc = usbd_xfer_get_frame(xfer, 0);
 272                         usbd_copy_in(pc, 0, &req, sizeof(req));
 273
 274                         usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
 275                         usbd_xfer_set_frame_len(xfer, 1, size);
 276                         usbd_xfer_set_frames(xfer, size ? 2 : 1);
 277                         usbd_transfer_submit(xfer);
 278                 }
 279                 return;
 280
 281         default:
 282 tr_error:
 283                 /* bomb out */
 284                 usb_fifo_get_data_error(sc->sc_fifo.fp[USB_FIFO_TX]);
 285                 return;
 286         }
 287 }
 288
 289 static void
 290 uhid_read_callback(struct usb_xfer *xfer, usb_error_t error)
 291 {
 292         struct uhid_softc *sc = usbd_xfer_softc(xfer);
 293         struct usb_device_request req;
 294         struct usb_page_cache *pc;
 295
 296         pc = usbd_xfer_get_frame(xfer, 0);
 297
 298         switch (USB_GET_STATE(xfer)) {
 299         case USB_ST_TRANSFERRED:
 300                 usb_fifo_put_data(sc->sc_fifo.fp[USB_FIFO_RX], pc, sizeof(req),
 301                     sc->sc_isize, 1);
 302                 return;
 303
 304         case USB_ST_SETUP:
 305
 306                 if (usb_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) > 0) {
 307
 308                         uhid_fill_get_report
 309                             (&req, sc->sc_iface_no, UHID_INPUT_REPORT,
 310                             sc->sc_iid, sc->sc_isize);
 311
 312                         usbd_copy_in(pc, 0, &req, sizeof(req));
 313
 314                         usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
 315                         usbd_xfer_set_frame_len(xfer, 1, sc->sc_isize);
 316                         usbd_xfer_set_frames(xfer, sc->sc_isize ? 2 : 1);
 317                         usbd_transfer_submit(xfer);
 318                 }
 319                 return;
 320
 321         default:                        /* Error */
 322                 /* bomb out */
 323                 usb_fifo_put_data_error(sc->sc_fifo.fp[USB_FIFO_RX]);
 324                 return;
 325         }
 326 }
 327
 328 static const struct usb_config uhid_config[UHID_N_TRANSFER] = {
 329
 330         [UHID_INTR_DT_RD] = {
 331                 .type = UE_INTERRUPT,
 332                 .endpoint = UE_ADDR_ANY,
 333                 .direction = UE_DIR_IN,
 334                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 335                 .bufsize = UHID_BSIZE,
 336                 .callback = &uhid_intr_callback,
 337         },
 338
 339         [UHID_CTRL_DT_WR] = {
 340                 .type = UE_CONTROL,
 341                 .endpoint = 0x00,       /* Control pipe */
 342                 .direction = UE_DIR_ANY,
 343                 .bufsize = sizeof(struct usb_device_request) + UHID_BSIZE,
 344                 .callback = &uhid_write_callback,
 345                 .timeout = 1000,        /* 1 second */
 346         },
 347
 348         [UHID_CTRL_DT_RD] = {
 349                 .type = UE_CONTROL,
 350                 .endpoint = 0x00,       /* Control pipe */
 351                 .direction = UE_DIR_ANY,
 352                 .bufsize = sizeof(struct usb_device_request) + UHID_BSIZE,
 353                 .callback = &uhid_read_callback,
 354                 .timeout = 1000,        /* 1 second */
 355         },
 356 };
 357
 358 static void
 359 uhid_start_read(struct usb_fifo *fifo)
 360 {
 361         struct uhid_softc *sc = usb_fifo_softc(fifo);
 362
 363         if (sc->sc_flags & UHID_FLAG_IMMED) {
 364                 usbd_transfer_start(sc->sc_xfer[UHID_CTRL_DT_RD]);
 365         } else {
 366                 usbd_transfer_start(sc->sc_xfer[UHID_INTR_DT_RD]);
 367         }
 368 }
 369
 370 static void
 371 uhid_stop_read(struct usb_fifo *fifo)
 372 {
 373         struct uhid_softc *sc = usb_fifo_softc(fifo);
 374
 375         usbd_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_RD]);
 376         usbd_transfer_stop(sc->sc_xfer[UHID_INTR_DT_RD]);
 377 }
 378
 379 static void
 380 uhid_start_write(struct usb_fifo *fifo)
 381 {
 382         struct uhid_softc *sc = usb_fifo_softc(fifo);
 383
 384         usbd_transfer_start(sc->sc_xfer[UHID_CTRL_DT_WR]);
 385 }
 386
 387 static void
 388 uhid_stop_write(struct usb_fifo *fifo)
 389 {
 390         struct uhid_softc *sc = usb_fifo_softc(fifo);
 391
 392         usbd_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_WR]);
 393 }
 394
 395 static int
 396 uhid_get_report(struct uhid_softc *sc, uint8_t type,
 397     uint8_t id, void *kern_data, void *user_data,
 398     uint16_t len)
 399 {
 400         int err;
 401         uint8_t free_data = 0;
 402
 403         if (kern_data == NULL) {
 404                 kern_data = malloc(len, M_USBDEV, M_WAITOK);
 405                 if (kern_data == NULL) {
 406                         err = ENOMEM;
 407                         goto done;
 408                 }
 409                 free_data = 1;
 410         }
 411         err = usbd_req_get_report(sc->sc_udev, NULL, kern_data,
 412             len, sc->sc_iface_index, type, id);
 413         if (err) {
 414                 err = ENXIO;
 415                 goto done;
 416         }
 417         if (user_data) {
 418                 /* dummy buffer */
 419                 err = copyout(kern_data, user_data, len);
 420                 if (err) {
 421                         goto done;
 422                 }
 423         }
 424 done:
 425         if (free_data) {
 426                 free(kern_data, M_USBDEV);
 427         }
 428         return (err);
 429 }
 430
 431 static int
 432 uhid_set_report(struct uhid_softc *sc, uint8_t type,
 433     uint8_t id, void *kern_data, void *user_data,
 434     uint16_t len)
 435 {
 436         int err;
 437         uint8_t free_data = 0;
 438
 439         if (kern_data == NULL) {
 440                 kern_data = malloc(len, M_USBDEV, M_WAITOK);
 441                 if (kern_data == NULL) {
 442                         err = ENOMEM;
 443                         goto done;
 444                 }
 445                 free_data = 1;
 446                 err = copyin(user_data, kern_data, len);
 447                 if (err) {
 448                         goto done;
 449                 }
 450         }
 451         err = usbd_req_set_report(sc->sc_udev, NULL, kern_data,
 452             len, sc->sc_iface_index, type, id);
 453         if (err) {
 454                 err = ENXIO;
 455                 goto done;
 456         }
 457 done:
 458         if (free_data) {
 459                 free(kern_data, M_USBDEV);
 460         }
 461         return (err);
 462 }
 463
 464 static int
 465 uhid_open(struct usb_fifo *fifo, int fflags)
 466 {
 467         struct uhid_softc *sc = usb_fifo_softc(fifo);
 468
 469         /*
 470          * The buffers are one byte larger than maximum so that one
 471          * can detect too large read/writes and short transfers:
 472          */
 473         if (fflags & FREAD) {
 474                 /* reset flags */
 475                 sc->sc_flags &= ~UHID_FLAG_IMMED;
 476
 477                 if (usb_fifo_alloc_buffer(fifo,
 478                     sc->sc_isize + 1, UHID_FRAME_NUM)) {
 479                         return (ENOMEM);
 480                 }
 481         }
 482         if (fflags & FWRITE) {
 483                 if (usb_fifo_alloc_buffer(fifo,
 484                     sc->sc_osize + 1, UHID_FRAME_NUM)) {
 485                         return (ENOMEM);
 486                 }
 487         }
 488         return (0);
 489 }
 490
 491 static void
 492 uhid_close(struct usb_fifo *fifo, int fflags)
 493 {
 494         if (fflags & (FREAD | FWRITE)) {
 495                 usb_fifo_free_buffer(fifo);
 496         }
 497 }
 498
 499 static int
 500 uhid_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr,
 501     int fflags)
 502 {
 503         struct uhid_softc *sc = usb_fifo_softc(fifo);
 504         struct usb_gen_descriptor *ugd;
 505         uint32_t size;
 506         int error = 0;
 507         uint8_t id;
 508
 509         switch (cmd) {
 510         case USB_GET_REPORT_DESC:
 511                 ugd = addr;
 512                 if (sc->sc_repdesc_size > ugd->ugd_maxlen) {
 513                         size = ugd->ugd_maxlen;
 514                 } else {
 515                         size = sc->sc_repdesc_size;
 516                 }
 517                 ugd->ugd_actlen = size;
 518                 if (ugd->ugd_data == NULL)
 519                         break;          /* descriptor length only */
 520                 error = copyout(sc->sc_repdesc_ptr, ugd->ugd_data, size);
 521                 break;
 522
 523         case USB_SET_IMMED:
 524                 if (!(fflags & FREAD)) {
 525                         error = EPERM;
 526                         break;
 527                 }
 528                 if (*(int *)addr) {
 529
 530                         /* do a test read */
 531
 532                         error = uhid_get_report(sc, UHID_INPUT_REPORT,
 533                             sc->sc_iid, NULL, NULL, sc->sc_isize);
 534                         if (error) {
 535                                 break;
 536                         }
 537                         mtx_lock(&sc->sc_mtx);
 538                         sc->sc_flags |= UHID_FLAG_IMMED;
 539                         mtx_unlock(&sc->sc_mtx);
 540                 } else {
 541                         mtx_lock(&sc->sc_mtx);
 542                         sc->sc_flags &= ~UHID_FLAG_IMMED;
 543                         mtx_unlock(&sc->sc_mtx);
 544                 }
 545                 break;
 546
 547         case USB_GET_REPORT:
 548                 if (!(fflags & FREAD)) {
 549                         error = EPERM;
 550                         break;
 551                 }
 552                 ugd = addr;
 553                 switch (ugd->ugd_report_type) {
 554                 case UHID_INPUT_REPORT:
 555                         size = sc->sc_isize;
 556                         id = sc->sc_iid;
 557                         break;
 558                 case UHID_OUTPUT_REPORT:
 559                         size = sc->sc_osize;
 560                         id = sc->sc_oid;
 561                         break;
 562                 case UHID_FEATURE_REPORT:
 563                         size = sc->sc_fsize;
 564                         id = sc->sc_fid;
 565                         break;
 566                 default:
 567                         return (EINVAL);
 568                 }
 569                 error = uhid_get_report(sc, ugd->ugd_report_type, id,
 570                     NULL, ugd->ugd_data, size);
 571                 break;
 572
 573         case USB_SET_REPORT:
 574                 if (!(fflags & FWRITE)) {
 575                         error = EPERM;
 576                         break;
 577                 }
 578                 ugd = addr;
 579                 switch (ugd->ugd_report_type) {
 580                 case UHID_INPUT_REPORT:
 581                         size = sc->sc_isize;
 582                         id = sc->sc_iid;
 583                         break;
 584                 case UHID_OUTPUT_REPORT:
 585                         size = sc->sc_osize;
 586                         id = sc->sc_oid;
 587                         break;
 588                 case UHID_FEATURE_REPORT:
 589                         size = sc->sc_fsize;
 590                         id = sc->sc_fid;
 591                         break;
 592                 default:
 593                         return (EINVAL);
 594                 }
 595                 error = uhid_set_report(sc, ugd->ugd_report_type, id,
 596                     NULL, ugd->ugd_data, size);
 597                 break;
 598
 599         case USB_GET_REPORT_ID:
 600                 *(int *)addr = 0;       /* XXX: we only support reportid 0? */
 601                 break;
 602
 603         default:
 604                 error = EINVAL;
 605                 break;
 606         }
 607         return (error);
 608 }
 609
 610 static const STRUCT_USB_HOST_ID uhid_devs[] = {
 611         /* generic HID class */
 612         {USB_IFACE_CLASS(UICLASS_HID),},
 613         /* the Xbox 360 gamepad doesn't use the HID class */
 614         {USB_IFACE_CLASS(UICLASS_VENDOR),
 615          USB_IFACE_SUBCLASS(UISUBCLASS_XBOX360_CONTROLLER),
 616          USB_IFACE_PROTOCOL(UIPROTO_XBOX360_GAMEPAD),},
 617 };
 618
 619 static int
 620 uhid_probe(device_t dev)
 621 {
 622         struct usb_attach_arg *uaa = device_get_ivars(dev);
 623         int error;
 624
 625         DPRINTFN(11, "\n");
 626
 627         if (uaa->usb_mode != USB_MODE_HOST)
 628                 return (ENXIO);
 629
 630         error = usbd_lookup_id_by_uaa(uhid_devs, sizeof(uhid_devs), uaa);
 631         if (error)
 632                 return (error);
 633
 634         if (usb_test_quirk(uaa, UQ_HID_IGNORE))
 635                 return (ENXIO);
 636
 637         /*
 638          * Don't attach to mouse and keyboard devices, hence then no
 639          * "nomatch" event is generated and then ums and ukbd won't
 640          * attach properly when loaded.
 641          */
 642         if ((uaa->info.bInterfaceClass == UICLASS_HID) &&
 643             (uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) &&
 644             ((uaa->info.bInterfaceProtocol == UIPROTO_BOOT_KEYBOARD) ||
 645              (uaa->info.bInterfaceProtocol == UIPROTO_MOUSE))) {
 646                 return (ENXIO);
 647         }
 648
 649         return (BUS_PROBE_GENERIC);
 650 }
 651
 652 static int
 653 uhid_attach(device_t dev)
 654 {
 655         struct usb_attach_arg *uaa = device_get_ivars(dev);
 656         struct uhid_softc *sc = device_get_softc(dev);
 657         int unit = device_get_unit(dev);
 658         int error = 0;
 659
 660         DPRINTFN(10, "sc=%p\n", sc);
 661
 662         device_set_usb_desc(dev);
 663
 664         mtx_init(&sc->sc_mtx, "uhid lock", NULL, MTX_DEF | MTX_RECURSE);
 665
 666         sc->sc_udev = uaa->device;
 667
 668         sc->sc_iface_no = uaa->info.bIfaceNum;
 669         sc->sc_iface_index = uaa->info.bIfaceIndex;
 670
 671         error = usbd_transfer_setup(uaa->device,
 672             &uaa->info.bIfaceIndex, sc->sc_xfer, uhid_config,
 673             UHID_N_TRANSFER, sc, &sc->sc_mtx);
 674
 675         if (error) {
 676                 DPRINTF("error=%s\n", usbd_errstr(error));
 677                 goto detach;
 678         }
 679         if (uaa->info.idVendor == USB_VENDOR_WACOM) {
 680
 681                 /* the report descriptor for the Wacom Graphire is broken */
 682
 683                 if (uaa->info.idProduct == USB_PRODUCT_WACOM_GRAPHIRE) {
 684
 685                         sc->sc_repdesc_size = sizeof(uhid_graphire_report_descr);
 686                         sc->sc_repdesc_ptr = (void *)&uhid_graphire_report_descr;
 687                         sc->sc_flags |= UHID_FLAG_STATIC_DESC;
 688
 689                 } else if (uaa->info.idProduct == USB_PRODUCT_WACOM_GRAPHIRE3_4X5) {
 690
 691                         static uint8_t reportbuf[] = {2, 2, 2};
 692
 693                         /*
 694                          * The Graphire3 needs 0x0202 to be written to
 695                          * feature report ID 2 before it'll start
 696                          * returning digitizer data.
 697                          */
 698                         error = usbd_req_set_report(uaa->device, NULL,
 699                             reportbuf, sizeof(reportbuf),
 700                             uaa->info.bIfaceIndex, UHID_FEATURE_REPORT, 2);
 701
 702                         if (error) {
 703                                 DPRINTF("set report failed, error=%s (ignored)\n",
 704                                     usbd_errstr(error));
 705                         }
 706                         sc->sc_repdesc_size = sizeof(uhid_graphire3_4x5_report_descr);
 707                         sc->sc_repdesc_ptr = (void *)&uhid_graphire3_4x5_report_descr;
 708                         sc->sc_flags |= UHID_FLAG_STATIC_DESC;
 709                 }
 710         } else if ((uaa->info.bInterfaceClass == UICLASS_VENDOR) &&
 711                     (uaa->info.bInterfaceSubClass == UISUBCLASS_XBOX360_CONTROLLER) &&
 712             (uaa->info.bInterfaceProtocol == UIPROTO_XBOX360_GAMEPAD)) {
 713
 714                 /* the Xbox 360 gamepad has no report descriptor */
 715                 sc->sc_repdesc_size = sizeof(uhid_xb360gp_report_descr);
 716                 sc->sc_repdesc_ptr = (void *)&uhid_xb360gp_report_descr;
 717                 sc->sc_flags |= UHID_FLAG_STATIC_DESC;
 718         }
 719         if (sc->sc_repdesc_ptr == NULL) {
 720
 721                 error = usbd_req_get_hid_desc(uaa->device, NULL,
 722                     &sc->sc_repdesc_ptr, &sc->sc_repdesc_size,
 723                     M_USBDEV, uaa->info.bIfaceIndex);
 724
 725                 if (error) {
 726                         device_printf(dev, "no report descriptor\n");
 727                         goto detach;
 728                 }
 729         }
 730         error = usbd_req_set_idle(uaa->device, NULL,
 731             uaa->info.bIfaceIndex, 0, 0);
 732
 733         if (error) {
 734                 DPRINTF("set idle failed, error=%s (ignored)\n",
 735                     usbd_errstr(error));
 736         }
 737         sc->sc_isize = hid_report_size
 738             (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_input, &sc->sc_iid);
 739
 740         sc->sc_osize = hid_report_size
 741             (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_output, &sc->sc_oid);
 742
 743         sc->sc_fsize = hid_report_size
 744             (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_feature, &sc->sc_fid);
 745
 746         if (sc->sc_isize > UHID_BSIZE) {
 747                 DPRINTF("input size is too large, "
 748                     "%d bytes (truncating)\n",
 749                     sc->sc_isize);
 750                 sc->sc_isize = UHID_BSIZE;
 751         }
 752         if (sc->sc_osize > UHID_BSIZE) {
 753                 DPRINTF("output size is too large, "
 754                     "%d bytes (truncating)\n",
 755                     sc->sc_osize);
 756                 sc->sc_osize = UHID_BSIZE;
 757         }
 758         if (sc->sc_fsize > UHID_BSIZE) {
 759                 DPRINTF("feature size is too large, "
 760                     "%d bytes (truncating)\n",
 761                     sc->sc_fsize);
 762                 sc->sc_fsize = UHID_BSIZE;
 763         }
 764
 765         error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
 766             &uhid_fifo_methods, &sc->sc_fifo,
 767             unit, 0 - 1, uaa->info.bIfaceIndex,
 768             UID_ROOT, GID_OPERATOR, 0644);
 769         if (error) {
 770                 goto detach;
 771         }
 772         return (0);                     /* success */
 773
 774 detach:
 775         uhid_detach(dev);
 776         return (ENOMEM);
 777 }
 778
 779 static int
 780 uhid_detach(device_t dev)
 781 {
 782         struct uhid_softc *sc = device_get_softc(dev);
 783
 784         usb_fifo_detach(&sc->sc_fifo);
 785
 786         usbd_transfer_unsetup(sc->sc_xfer, UHID_N_TRANSFER);
 787
 788         if (sc->sc_repdesc_ptr) {
 789                 if (!(sc->sc_flags & UHID_FLAG_STATIC_DESC)) {
 790                         free(sc->sc_repdesc_ptr, M_USBDEV);
 791                 }
 792         }
 793         mtx_destroy(&sc->sc_mtx);
 794
 795         return (0);
 796 }
 797
 798 static devclass_t uhid_devclass;
 799
 800 static device_method_t uhid_methods[] = {
 801         DEVMETHOD(device_probe, uhid_probe),
 802         DEVMETHOD(device_attach, uhid_attach),
 803         DEVMETHOD(device_detach, uhid_detach),
 804         {0, 0}
 805 };
 806
 807 static driver_t uhid_driver = {
 808         .name = "uhid",
 809         .methods = uhid_methods,
 810         .size = sizeof(struct uhid_softc),
 811 };
 812
 813 DRIVER_MODULE(uhid, uhub, uhid_driver, uhid_devclass, NULL, 0);
 814 MODULE_DEPEND(uhid, usb, 1, 1, 1);
 815 MODULE_VERSION(uhid, 1);