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