sys/dev/hid/hidbus.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019-2020 Vladimir Kondratyev <wulf@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/bus.h>
  33 #include <sys/ck.h>
  34 #include <sys/epoch.h>
  35 #include <sys/kdb.h>
  36 #include <sys/kernel.h>
  37 #include <sys/libkern.h>
  38 #include <sys/lock.h>
  39 #include <sys/malloc.h>
  40 #include <sys/module.h>
  41 #include <sys/mutex.h>
  42 #include <sys/proc.h>
  43 #include <sys/sbuf.h>
  44 #include <sys/sx.h>
  45 #include <sys/systm.h>
  46
  47 #define HID_DEBUG_VAR   hid_debug
  48 #include <dev/hid/hid.h>
  49 #include <dev/hid/hidbus.h>
  50 #include <dev/hid/hidquirk.h>
  51
  52 #include "hid_if.h"
  53
  54 #define INPUT_EPOCH     global_epoch_preempt
  55 #define HID_RSIZE_MAX   1024
  56
  57 static hid_intr_t       hidbus_intr;
  58
  59 static device_probe_t   hidbus_probe;
  60 static device_attach_t  hidbus_attach;
  61 static device_detach_t  hidbus_detach;
  62
  63 struct hidbus_ivars {
  64         int32_t                         usage;
  65         uint8_t                         index;
  66         uint32_t                        flags;
  67         uintptr_t                       driver_info;    /* for internal use */
  68         struct mtx                      *mtx;           /* child intr mtx */
  69         hid_intr_t                      *intr_handler;  /* executed under mtx*/
  70         void                            *intr_ctx;
  71         unsigned int                    refcnt;         /* protected by mtx */
  72         struct epoch_context            epoch_ctx;
  73         CK_STAILQ_ENTRY(hidbus_ivars)   link;
  74 };
  75
  76 struct hidbus_softc {
  77         device_t                        dev;
  78         struct sx                       sx;
  79         struct mtx                      mtx;
  80
  81         bool                            nowrite;
  82
  83         struct hid_rdesc_info           rdesc;
  84         bool                            overloaded;
  85         int                             nest;   /* Child attach nesting lvl */
  86         int                             nauto;  /* Number of autochildren */
  87
  88         CK_STAILQ_HEAD(, hidbus_ivars)  tlcs;
  89 };
  90
  91 static int
  92 hidbus_fill_rdesc_info(struct hid_rdesc_info *hri, const void *data,
  93     hid_size_t len)
  94 {
  95         int error = 0;
  96
  97         hri->data = __DECONST(void *, data);
  98         hri->len = len;
  99
 100         /*
 101          * If report descriptor is not available yet, set maximal
 102          * report sizes high enough to allow hidraw to work.
 103          */
 104         hri->isize = len == 0 ? HID_RSIZE_MAX :
 105             hid_report_size_max(data, len, hid_input, &hri->iid);
 106         hri->osize = len == 0 ? HID_RSIZE_MAX :
 107             hid_report_size_max(data, len, hid_output, &hri->oid);
 108         hri->fsize = len == 0 ? HID_RSIZE_MAX :
 109             hid_report_size_max(data, len, hid_feature, &hri->fid);
 110
 111         if (hri->isize > HID_RSIZE_MAX) {
 112                 DPRINTF("input size is too large, %u bytes (truncating)\n",
 113                     hri->isize);
 114                 hri->isize = HID_RSIZE_MAX;
 115                 error = EOVERFLOW;
 116         }
 117         if (hri->osize > HID_RSIZE_MAX) {
 118                 DPRINTF("output size is too large, %u bytes (truncating)\n",
 119                     hri->osize);
 120                 hri->osize = HID_RSIZE_MAX;
 121                 error = EOVERFLOW;
 122         }
 123         if (hri->fsize > HID_RSIZE_MAX) {
 124                 DPRINTF("feature size is too large, %u bytes (truncating)\n",
 125                     hri->fsize);
 126                 hri->fsize = HID_RSIZE_MAX;
 127                 error = EOVERFLOW;
 128         }
 129
 130         return (error);
 131 }
 132
 133 int
 134 hidbus_locate(const void *desc, hid_size_t size, int32_t u, enum hid_kind k,
 135     uint8_t tlc_index, uint8_t index, struct hid_location *loc,
 136     uint32_t *flags, uint8_t *id, struct hid_absinfo *ai)
 137 {
 138         struct hid_data *d;
 139         struct hid_item h;
 140         int i;
 141
 142         d = hid_start_parse(desc, size, 1 << k);
 143         HIDBUS_FOREACH_ITEM(d, &h, tlc_index) {
 144                 for (i = 0; i < h.nusages; i++) {
 145                         if (h.kind == k && h.usages[i] == u) {
 146                                 if (index--)
 147                                         break;
 148                                 if (loc != NULL)
 149                                         *loc = h.loc;
 150                                 if (flags != NULL)
 151                                         *flags = h.flags;
 152                                 if (id != NULL)
 153                                         *id = h.report_ID;
 154                                 if (ai != NULL && (h.flags&HIO_RELATIVE) == 0)
 155                                         *ai = (struct hid_absinfo) {
 156                                             .max = h.logical_maximum,
 157                                             .min = h.logical_minimum,
 158                                             .res = hid_item_resolution(&h),
 159                                         };
 160                                 hid_end_parse(d);
 161                                 return (1);
 162                         }
 163                 }
 164         }
 165         if (loc != NULL)
 166                 loc->size = 0;
 167         if (flags != NULL)
 168                 *flags = 0;
 169         if (id != NULL)
 170                 *id = 0;
 171         hid_end_parse(d);
 172         return (0);
 173 }
 174
 175 static device_t
 176 hidbus_add_child(device_t dev, u_int order, const char *name, int unit)
 177 {
 178         struct hidbus_softc *sc = device_get_softc(dev);
 179         struct hidbus_ivars *tlc;
 180         device_t child;
 181
 182         child = device_add_child_ordered(dev, order, name, unit);
 183         if (child == NULL)
 184                         return (child);
 185
 186         tlc = malloc(sizeof(struct hidbus_ivars), M_DEVBUF, M_WAITOK | M_ZERO);
 187         tlc->mtx = &sc->mtx;
 188         device_set_ivars(child, tlc);
 189         sx_xlock(&sc->sx);
 190         CK_STAILQ_INSERT_TAIL(&sc->tlcs, tlc, link);
 191         sx_unlock(&sc->sx);
 192
 193         return (child);
 194 }
 195
 196 static int
 197 hidbus_enumerate_children(device_t dev, const void* data, hid_size_t len)
 198 {
 199         struct hidbus_softc *sc = device_get_softc(dev);
 200         struct hid_data *hd;
 201         struct hid_item hi;
 202         device_t child;
 203         uint8_t index = 0;
 204
 205         if (data == NULL || len == 0)
 206                 return (ENXIO);
 207
 208         /* Add a child for each top level collection */
 209         hd = hid_start_parse(data, len, 1 << hid_input);
 210         while (hid_get_item(hd, &hi)) {
 211                 if (hi.kind != hid_collection || hi.collevel != 1)
 212                         continue;
 213                 child = BUS_ADD_CHILD(dev, 0, NULL, -1);
 214                 if (child == NULL) {
 215                         device_printf(dev, "Could not add HID device\n");
 216                         continue;
 217                 }
 218                 hidbus_set_index(child, index);
 219                 hidbus_set_usage(child, hi.usage);
 220                 hidbus_set_flags(child, HIDBUS_FLAG_AUTOCHILD);
 221                 index++;
 222                 DPRINTF("Add child TLC: 0x%04x:0x%04x\n",
 223                     HID_GET_USAGE_PAGE(hi.usage), HID_GET_USAGE(hi.usage));
 224         }
 225         hid_end_parse(hd);
 226
 227         if (index == 0)
 228                 return (ENXIO);
 229
 230         sc->nauto = index;
 231
 232         return (0);
 233 }
 234
 235 static int
 236 hidbus_attach_children(device_t dev)
 237 {
 238         struct hidbus_softc *sc = device_get_softc(dev);
 239         int error;
 240
 241         HID_INTR_SETUP(device_get_parent(dev), hidbus_intr, sc, &sc->rdesc);
 242
 243         error = hidbus_enumerate_children(dev, sc->rdesc.data, sc->rdesc.len);
 244         if (error != 0)
 245                 DPRINTF("failed to enumerate children: error %d\n", error);
 246
 247         /*
 248          * hidbus_attach_children() can recurse through device_identify->
 249          * hid_set_report_descr() call sequence. Do not perform children
 250          * attach twice in that case.
 251          */
 252         sc->nest++;
 253         bus_generic_probe(dev);
 254         sc->nest--;
 255         if (sc->nest != 0)
 256                 return (0);
 257
 258         if (hid_is_keyboard(sc->rdesc.data, sc->rdesc.len) != 0)
 259                 error = bus_generic_attach(dev);
 260         else
 261                 error = bus_delayed_attach_children(dev);
 262         if (error != 0)
 263                 device_printf(dev, "failed to attach child: error %d\n", error);
 264
 265         return (error);
 266 }
 267
 268 static int
 269 hidbus_detach_children(device_t dev)
 270 {
 271         device_t *children, bus;
 272         bool is_bus;
 273         int i, error;
 274
 275         error = 0;
 276
 277         is_bus = device_get_devclass(dev) == hidbus_devclass;
 278         bus = is_bus ? dev : device_get_parent(dev);
 279
 280         KASSERT(device_get_devclass(bus) == hidbus_devclass,
 281             ("Device is not hidbus or it's child"));
 282
 283         if (is_bus) {
 284                 /* If hidbus is passed, delete all children. */
 285                 bus_generic_detach(bus);
 286                 device_delete_children(bus);
 287         } else {
 288                 /*
 289                  * If hidbus child is passed, delete all hidbus children
 290                  * except caller. Deleting the caller may result in deadlock.
 291                  */
 292                 error = device_get_children(bus, &children, &i);
 293                 if (error != 0)
 294                         return (error);
 295                 while (i-- > 0) {
 296                         if (children[i] == dev)
 297                                 continue;
 298                         DPRINTF("Delete child. index=%d (%s)\n",
 299                             hidbus_get_index(children[i]),
 300                             device_get_nameunit(children[i]));
 301                         error = device_delete_child(bus, children[i]);
 302                         if (error) {
 303                                 DPRINTF("Failed deleting %s\n",
 304                                     device_get_nameunit(children[i]));
 305                                 break;
 306                         }
 307                 }
 308                 free(children, M_TEMP);
 309         }
 310
 311         HID_INTR_UNSETUP(device_get_parent(bus));
 312
 313         return (error);
 314 }
 315
 316 static int
 317 hidbus_probe(device_t dev)
 318 {
 319
 320         device_set_desc(dev, "HID bus");
 321
 322         /* Allow other subclasses to override this driver. */
 323         return (BUS_PROBE_GENERIC);
 324 }
 325
 326 static int
 327 hidbus_attach(device_t dev)
 328 {
 329         struct hidbus_softc *sc = device_get_softc(dev);
 330         struct hid_device_info *devinfo = device_get_ivars(dev);
 331         void *d_ptr = NULL;
 332         hid_size_t d_len;
 333         int error;
 334
 335         sc->dev = dev;
 336         CK_STAILQ_INIT(&sc->tlcs);
 337         mtx_init(&sc->mtx, "hidbus ivar lock", NULL, MTX_DEF);
 338         sx_init(&sc->sx, "hidbus ivar list lock");
 339
 340         /*
 341          * Ignore error. It is possible for non-HID device e.g. XBox360 gamepad
 342          * to emulate HID through overloading of report descriptor.
 343          */
 344         d_len = devinfo->rdescsize;
 345         if (d_len != 0) {
 346                 d_ptr = malloc(d_len, M_DEVBUF, M_ZERO | M_WAITOK);
 347                 error = hid_get_rdesc(dev, d_ptr, d_len);
 348                 if (error != 0) {
 349                         free(d_ptr, M_DEVBUF);
 350                         d_len = 0;
 351                         d_ptr = NULL;
 352                 }
 353         }
 354
 355         hidbus_fill_rdesc_info(&sc->rdesc, d_ptr, d_len);
 356
 357         sc->nowrite = hid_test_quirk(devinfo, HQ_NOWRITE);
 358
 359         error = hidbus_attach_children(dev);
 360         if (error != 0) {
 361                 hidbus_detach(dev);
 362                 return (ENXIO);
 363         }
 364
 365         return (0);
 366 }
 367
 368 static int
 369 hidbus_detach(device_t dev)
 370 {
 371         struct hidbus_softc *sc = device_get_softc(dev);
 372
 373         hidbus_detach_children(dev);
 374         sx_destroy(&sc->sx);
 375         mtx_destroy(&sc->mtx);
 376         free(sc->rdesc.data, M_DEVBUF);
 377
 378         return (0);
 379 }
 380
 381 static void
 382 hidbus_child_detached(device_t bus, device_t child)
 383 {
 384         struct hidbus_softc *sc = device_get_softc(bus);
 385         struct hidbus_ivars *tlc = device_get_ivars(child);
 386
 387         KASSERT(tlc->refcnt == 0, ("Child device is running"));
 388         tlc->mtx = &sc->mtx;
 389         tlc->intr_handler = NULL;
 390         tlc->flags &= ~HIDBUS_FLAG_CAN_POLL;
 391 }
 392
 393 /*
 394  * Epoch callback indicating tlc is safe to destroy
 395  */
 396 static void
 397 hidbus_ivar_dtor(epoch_context_t ctx)
 398 {
 399         struct hidbus_ivars *tlc;
 400
 401         tlc = __containerof(ctx, struct hidbus_ivars, epoch_ctx);
 402         free(tlc, M_DEVBUF);
 403 }
 404
 405 static void
 406 hidbus_child_deleted(device_t bus, device_t child)
 407 {
 408         struct hidbus_softc *sc = device_get_softc(bus);
 409         struct hidbus_ivars *tlc = device_get_ivars(child);
 410
 411         sx_xlock(&sc->sx);
 412         KASSERT(tlc->refcnt == 0, ("Child device is running"));
 413         CK_STAILQ_REMOVE(&sc->tlcs, tlc, hidbus_ivars, link);
 414         sx_unlock(&sc->sx);
 415         epoch_call(INPUT_EPOCH, hidbus_ivar_dtor, &tlc->epoch_ctx);
 416 }
 417
 418 static int
 419 hidbus_read_ivar(device_t bus, device_t child, int which, uintptr_t *result)
 420 {
 421         struct hidbus_softc *sc = device_get_softc(bus);
 422         struct hidbus_ivars *tlc = device_get_ivars(child);
 423
 424         switch (which) {
 425         case HIDBUS_IVAR_INDEX:
 426                 *result = tlc->index;
 427                 break;
 428         case HIDBUS_IVAR_USAGE:
 429                 *result = tlc->usage;
 430                 break;
 431         case HIDBUS_IVAR_FLAGS:
 432                 *result = tlc->flags;
 433                 break;
 434         case HIDBUS_IVAR_DRIVER_INFO:
 435                 *result = tlc->driver_info;
 436                 break;
 437         case HIDBUS_IVAR_LOCK:
 438                 *result = (uintptr_t)(tlc->mtx == &sc->mtx ? NULL : tlc->mtx);
 439                 break;
 440         default:
 441                 return (EINVAL);
 442         }
 443         return (0);
 444 }
 445
 446 static int
 447 hidbus_write_ivar(device_t bus, device_t child, int which, uintptr_t value)
 448 {
 449         struct hidbus_softc *sc = device_get_softc(bus);
 450         struct hidbus_ivars *tlc = device_get_ivars(child);
 451
 452         switch (which) {
 453         case HIDBUS_IVAR_INDEX:
 454                 tlc->index = value;
 455                 break;
 456         case HIDBUS_IVAR_USAGE:
 457                 tlc->usage = value;
 458                 break;
 459         case HIDBUS_IVAR_FLAGS:
 460                 tlc->flags = value;
 461                 if ((value & HIDBUS_FLAG_CAN_POLL) != 0)
 462                         HID_INTR_SETUP(
 463                             device_get_parent(bus), NULL, NULL, NULL);
 464                 break;
 465         case HIDBUS_IVAR_DRIVER_INFO:
 466                 tlc->driver_info = value;
 467                 break;
 468         case HIDBUS_IVAR_LOCK:
 469                 tlc->mtx = (struct mtx *)value == NULL ?
 470                     &sc->mtx : (struct mtx *)value;
 471                 break;
 472         default:
 473                 return (EINVAL);
 474         }
 475         return (0);
 476 }
 477
 478 /* Location hint for devctl(8) */
 479 static int
 480 hidbus_child_location(device_t bus, device_t child, struct sbuf *sb)
 481 {
 482         struct hidbus_ivars *tlc = device_get_ivars(child);
 483
 484         sbuf_printf(sb, "index=%hhu", tlc->index);
 485         return (0);
 486 }
 487
 488 /* PnP information for devctl(8) */
 489 static int
 490 hidbus_child_pnpinfo(device_t bus, device_t child, struct sbuf *sb)
 491 {
 492         struct hidbus_ivars *tlc = device_get_ivars(child);
 493         struct hid_device_info *devinfo = device_get_ivars(bus);
 494
 495         sbuf_printf(sb, "page=0x%04x usage=0x%04x bus=0x%02hx "
 496             "vendor=0x%04hx product=0x%04hx version=0x%04hx%s%s",
 497             HID_GET_USAGE_PAGE(tlc->usage), HID_GET_USAGE(tlc->usage),
 498             devinfo->idBus, devinfo->idVendor, devinfo->idProduct,
 499             devinfo->idVersion, devinfo->idPnP[0] == '\0' ? "" : " _HID=",
 500             devinfo->idPnP[0] == '\0' ? "" : devinfo->idPnP);
 501         return (0);
 502 }
 503
 504 void
 505 hidbus_set_desc(device_t child, const char *suffix)
 506 {
 507         device_t bus = device_get_parent(child);
 508         struct hidbus_softc *sc = device_get_softc(bus);
 509         struct hid_device_info *devinfo = device_get_ivars(bus);
 510         struct hidbus_ivars *tlc = device_get_ivars(child);
 511         char buf[80];
 512
 513         /* Do not add NULL suffix or if device name already contains it. */
 514         if (suffix != NULL && strcasestr(devinfo->name, suffix) == NULL &&
 515             (sc->nauto > 1 || (tlc->flags & HIDBUS_FLAG_AUTOCHILD) == 0)) {
 516                 snprintf(buf, sizeof(buf), "%s %s", devinfo->name, suffix);
 517                 device_set_desc_copy(child, buf);
 518         } else
 519                 device_set_desc(child, devinfo->name);
 520 }
 521
 522 device_t
 523 hidbus_find_child(device_t bus, int32_t usage)
 524 {
 525         device_t *children, child;
 526         int ccount, i;
 527
 528         GIANT_REQUIRED;
 529
 530         /* Get a list of all hidbus children */
 531         if (device_get_children(bus, &children, &ccount) != 0)
 532                 return (NULL);
 533
 534         /* Scan through to find required TLC */
 535         for (i = 0, child = NULL; i < ccount; i++) {
 536                 if (hidbus_get_usage(children[i]) == usage) {
 537                         child = children[i];
 538                         break;
 539                 }
 540         }
 541         free(children, M_TEMP);
 542
 543         return (child);
 544 }
 545
 546 void
 547 hidbus_intr(void *context, void *buf, hid_size_t len)
 548 {
 549         struct hidbus_softc *sc = context;
 550         struct hidbus_ivars *tlc;
 551         struct epoch_tracker et;
 552
 553         /*
 554          * Broadcast input report to all subscribers.
 555          * TODO: Add check for input report ID.
 556          *
 557          * Relock mutex on every TLC item as we can't hold any locks over whole
 558          * TLC list here due to LOR with open()/close() handlers.
 559          */
 560         if (!HID_IN_POLLING_MODE())
 561                 epoch_enter_preempt(INPUT_EPOCH, &et);
 562         CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
 563                 if (tlc->refcnt == 0 || tlc->intr_handler == NULL)
 564                         continue;
 565                 if (HID_IN_POLLING_MODE()) {
 566                         if ((tlc->flags & HIDBUS_FLAG_CAN_POLL) != 0)
 567                                 tlc->intr_handler(tlc->intr_ctx, buf, len);
 568                 } else {
 569                         mtx_lock(tlc->mtx);
 570                         tlc->intr_handler(tlc->intr_ctx, buf, len);
 571                         mtx_unlock(tlc->mtx);
 572                 }
 573         }
 574         if (!HID_IN_POLLING_MODE())
 575                 epoch_exit_preempt(INPUT_EPOCH, &et);
 576 }
 577
 578 void
 579 hidbus_set_intr(device_t child, hid_intr_t *handler, void *context)
 580 {
 581         struct hidbus_ivars *tlc = device_get_ivars(child);
 582
 583         tlc->intr_handler = handler;
 584         tlc->intr_ctx = context;
 585 }
 586
 587 int
 588 hidbus_intr_start(device_t child)
 589 {
 590         device_t bus = device_get_parent(child);
 591         struct hidbus_softc *sc = device_get_softc(bus);
 592         struct hidbus_ivars *ivar = device_get_ivars(child);
 593         struct hidbus_ivars *tlc;
 594         int refcnt = 0;
 595         int error;
 596
 597         if (sx_xlock_sig(&sc->sx) != 0)
 598                 return (EINTR);
 599         CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
 600                 refcnt += tlc->refcnt;
 601                 if (tlc == ivar) {
 602                         mtx_lock(tlc->mtx);
 603                         ++tlc->refcnt;
 604                         mtx_unlock(tlc->mtx);
 605                 }
 606         }
 607         error = refcnt != 0 ? 0 : HID_INTR_START(device_get_parent(bus));
 608         sx_unlock(&sc->sx);
 609
 610         return (error);
 611 }
 612
 613 int
 614 hidbus_intr_stop(device_t child)
 615 {
 616         device_t bus = device_get_parent(child);
 617         struct hidbus_softc *sc = device_get_softc(bus);
 618         struct hidbus_ivars *ivar = device_get_ivars(child);
 619         struct hidbus_ivars *tlc;
 620         bool refcnt = 0;
 621         int error;
 622
 623         if (sx_xlock_sig(&sc->sx) != 0)
 624                 return (EINTR);
 625         CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
 626                 if (tlc == ivar) {
 627                         mtx_lock(tlc->mtx);
 628                         MPASS(tlc->refcnt != 0);
 629                         --tlc->refcnt;
 630                         mtx_unlock(tlc->mtx);
 631                 }
 632                 refcnt += tlc->refcnt;
 633         }
 634         error = refcnt != 0 ? 0 : HID_INTR_STOP(device_get_parent(bus));
 635         sx_unlock(&sc->sx);
 636
 637         return (error);
 638 }
 639
 640 void
 641 hidbus_intr_poll(device_t child)
 642 {
 643         device_t bus = device_get_parent(child);
 644
 645         HID_INTR_POLL(device_get_parent(bus));
 646 }
 647
 648 struct hid_rdesc_info *
 649 hidbus_get_rdesc_info(device_t child)
 650 {
 651         device_t bus = device_get_parent(child);
 652         struct hidbus_softc *sc = device_get_softc(bus);
 653
 654         return (&sc->rdesc);
 655 }
 656
 657 /*
 658  * HID interface.
 659  *
 660  * Hidbus as well as any hidbus child can be passed as first arg.
 661  */
 662
 663 /* Read cached report descriptor */
 664 int
 665 hid_get_report_descr(device_t dev, void **data, hid_size_t *len)
 666 {
 667         device_t bus;
 668         struct hidbus_softc *sc;
 669
 670         bus = device_get_devclass(dev) == hidbus_devclass ?
 671             dev : device_get_parent(dev);
 672         sc = device_get_softc(bus);
 673
 674         /*
 675          * Do not send request to a transport backend.
 676          * Use cached report descriptor instead of it.
 677          */
 678         if (sc->rdesc.data == NULL || sc->rdesc.len == 0)
 679                 return (ENXIO);
 680
 681         if (data != NULL)
 682                 *data = sc->rdesc.data;
 683         if (len != NULL)
 684                 *len = sc->rdesc.len;
 685
 686         return (0);
 687 }
 688
 689 /*
 690  * Replace cached report descriptor with top level driver provided one.
 691  *
 692  * It deletes all hidbus children except caller and enumerates them again after
 693  * new descriptor has been registered. Currently it can not be called from
 694  * autoenumerated (by report's TLC) child device context as it results in child
 695  * duplication. To overcome this limitation hid_set_report_descr() should be
 696  * called from device_identify driver's handler with hidbus itself passed as
 697  * 'device_t dev' parameter.
 698  */
 699 int
 700 hid_set_report_descr(device_t dev, const void *data, hid_size_t len)
 701 {
 702         struct hid_rdesc_info rdesc;
 703         device_t bus;
 704         struct hidbus_softc *sc;
 705         bool is_bus;
 706         int error;
 707
 708         GIANT_REQUIRED;
 709
 710         is_bus = device_get_devclass(dev) == hidbus_devclass;
 711         bus = is_bus ? dev : device_get_parent(dev);
 712         sc = device_get_softc(bus);
 713
 714         /*
 715          * Do not overload already overloaded report descriptor in
 716          * device_identify handler. It causes infinite recursion loop.
 717          */
 718         if (is_bus && sc->overloaded)
 719                 return(0);
 720
 721         DPRINTFN(5, "len=%d\n", len);
 722         DPRINTFN(5, "data = %*D\n", len, data, " ");
 723
 724         error = hidbus_fill_rdesc_info(&rdesc, data, len);
 725         if (error != 0)
 726                 return (error);
 727
 728         error = hidbus_detach_children(dev);
 729         if (error != 0)
 730                 return(error);
 731
 732         /* Make private copy to handle a case of dynamicaly allocated data. */
 733         rdesc.data = malloc(len, M_DEVBUF, M_ZERO | M_WAITOK);
 734         bcopy(data, rdesc.data, len);
 735         sc->overloaded = true;
 736         free(sc->rdesc.data, M_DEVBUF);
 737         bcopy(&rdesc, &sc->rdesc, sizeof(struct hid_rdesc_info));
 738
 739         error = hidbus_attach_children(bus);
 740
 741         return (error);
 742 }
 743
 744 static int
 745 hidbus_write(device_t dev, const void *data, hid_size_t len)
 746 {
 747         struct hidbus_softc *sc;
 748         uint8_t id;
 749
 750         sc = device_get_softc(dev);
 751         /*
 752          * Output interrupt endpoint is often optional. If HID device
 753          * does not provide it, send reports via control pipe.
 754          */
 755         if (sc->nowrite) {
 756                 /* try to extract the ID byte */
 757                 id = (sc->rdesc.oid & (len > 0)) ? *(const uint8_t*)data : 0;
 758                 return (hid_set_report(dev, data, len, HID_OUTPUT_REPORT, id));
 759         }
 760
 761         return (hid_write(dev, data, len));
 762 }
 763
 764 /*------------------------------------------------------------------------*
 765  *      hidbus_lookup_id
 766  *
 767  * This functions takes an array of "struct hid_device_id" and tries
 768  * to match the entries with the information in "struct hid_device_info".
 769  *
 770  * Return values:
 771  * NULL: No match found.
 772  * Else: Pointer to matching entry.
 773  *------------------------------------------------------------------------*/
 774 const struct hid_device_id *
 775 hidbus_lookup_id(device_t dev, const struct hid_device_id *id, int nitems_id)
 776 {
 777         const struct hid_device_id *id_end;
 778         const struct hid_device_info *info;
 779         int32_t usage;
 780         bool is_child;
 781
 782         if (id == NULL) {
 783                 goto done;
 784         }
 785
 786         id_end = id + nitems_id;
 787         info = hid_get_device_info(dev);
 788         is_child = device_get_devclass(dev) != hidbus_devclass;
 789         if (is_child)
 790                 usage = hidbus_get_usage(dev);
 791
 792         /*
 793          * Keep on matching array entries until we find a match or
 794          * until we reach the end of the matching array:
 795          */
 796         for (; id != id_end; id++) {
 797
 798                 if (is_child && (id->match_flag_page) &&
 799                     (id->page != HID_GET_USAGE_PAGE(usage))) {
 800                         continue;
 801                 }
 802                 if (is_child && (id->match_flag_usage) &&
 803                     (id->usage != HID_GET_USAGE(usage))) {
 804                         continue;
 805                 }
 806                 if ((id->match_flag_bus) &&
 807                     (id->idBus != info->idBus)) {
 808                         continue;
 809                 }
 810                 if ((id->match_flag_vendor) &&
 811                     (id->idVendor != info->idVendor)) {
 812                         continue;
 813                 }
 814                 if ((id->match_flag_product) &&
 815                     (id->idProduct != info->idProduct)) {
 816                         continue;
 817                 }
 818                 if ((id->match_flag_ver_lo) &&
 819                     (id->idVersion_lo > info->idVersion)) {
 820                         continue;
 821                 }
 822                 if ((id->match_flag_ver_hi) &&
 823                     (id->idVersion_hi < info->idVersion)) {
 824                         continue;
 825                 }
 826                 if (id->match_flag_pnp &&
 827                     strncmp(id->idPnP, info->idPnP, HID_PNP_ID_SIZE) != 0) {
 828                         continue;
 829                 }
 830                 /* We found a match! */
 831                 return (id);
 832         }
 833
 834 done:
 835         return (NULL);
 836 }
 837
 838 /*------------------------------------------------------------------------*
 839  *      hidbus_lookup_driver_info - factored out code
 840  *
 841  * Return values:
 842  *    0: Success
 843  * Else: Failure
 844  *------------------------------------------------------------------------*/
 845 int
 846 hidbus_lookup_driver_info(device_t child, const struct hid_device_id *id,
 847     int nitems_id)
 848 {
 849
 850         id = hidbus_lookup_id(child, id, nitems_id);
 851         if (id) {
 852                 /* copy driver info */
 853                 hidbus_set_driver_info(child, id->driver_info);
 854                 return (0);
 855         }
 856         return (ENXIO);
 857 }
 858
 859 const struct hid_device_info *
 860 hid_get_device_info(device_t dev)
 861 {
 862         device_t bus;
 863
 864         bus = device_get_devclass(dev) == hidbus_devclass ?
 865             dev : device_get_parent(dev);
 866
 867         return (device_get_ivars(bus));
 868 }
 869
 870 static device_method_t hidbus_methods[] = {
 871         /* device interface */
 872         DEVMETHOD(device_probe,         hidbus_probe),
 873         DEVMETHOD(device_attach,        hidbus_attach),
 874         DEVMETHOD(device_detach,        hidbus_detach),
 875         DEVMETHOD(device_suspend,       bus_generic_suspend),
 876         DEVMETHOD(device_resume,        bus_generic_resume),
 877
 878         /* bus interface */
 879         DEVMETHOD(bus_add_child,        hidbus_add_child),
 880         DEVMETHOD(bus_child_detached,   hidbus_child_detached),
 881         DEVMETHOD(bus_child_deleted,    hidbus_child_deleted),
 882         DEVMETHOD(bus_read_ivar,        hidbus_read_ivar),
 883         DEVMETHOD(bus_write_ivar,       hidbus_write_ivar),
 884         DEVMETHOD(bus_child_pnpinfo,    hidbus_child_pnpinfo),
 885         DEVMETHOD(bus_child_location,   hidbus_child_location),
 886
 887         /* hid interface */
 888         DEVMETHOD(hid_get_rdesc,        hid_get_rdesc),
 889         DEVMETHOD(hid_read,             hid_read),
 890         DEVMETHOD(hid_write,            hidbus_write),
 891         DEVMETHOD(hid_get_report,       hid_get_report),
 892         DEVMETHOD(hid_set_report,       hid_set_report),
 893         DEVMETHOD(hid_set_idle,         hid_set_idle),
 894         DEVMETHOD(hid_set_protocol,     hid_set_protocol),
 895
 896         DEVMETHOD_END
 897 };
 898
 899 devclass_t hidbus_devclass;
 900 driver_t hidbus_driver = {
 901         "hidbus",
 902         hidbus_methods,
 903         sizeof(struct hidbus_softc),
 904 };
 905
 906 MODULE_DEPEND(hidbus, hid, 1, 1, 1);
 907 MODULE_VERSION(hidbus, 1);
 908 DRIVER_MODULE(hidbus, iichid, hidbus_driver, hidbus_devclass, 0, 0);
 909 DRIVER_MODULE(hidbus, usbhid, hidbus_driver, hidbus_devclass, 0, 0);