1 /*- 2 * Copyright (c) 2014-2017 Vladimir Kondratyev <wulf@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 /* 31 * MS Windows 7/8/10 compatible USB HID Multi-touch Device driver. 32 * https://msdn.microsoft.com/en-us/library/windows/hardware/jj151569(v=vs.85).aspx 33 * https://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt 34 */ 35 36 #include <sys/param.h> 37 #include <sys/bus.h> 38 #include <sys/conf.h> 39 #include <sys/kernel.h> 40 #include <sys/lock.h> 41 #include <sys/malloc.h> 42 #include <sys/module.h> 43 #include <sys/mutex.h> 44 #include <sys/stddef.h> 45 #include <sys/sysctl.h> 46 #include <sys/systm.h> 47 48 #include "usbdevs.h" 49 #include <dev/usb/usb.h> 50 #include <dev/usb/usbdi.h> 51 #include <dev/usb/usbdi_util.h> 52 #include <dev/usb/usbhid.h> 53 54 #include <dev/usb/quirk/usb_quirk.h> 55 56 #include <dev/evdev/evdev.h> 57 #include <dev/evdev/input.h> 58 59 #define USB_DEBUG_VAR wmt_debug 60 #include <dev/usb/usb_debug.h> 61 62 #ifdef USB_DEBUG 63 static int wmt_debug = 0; 64 65 static SYSCTL_NODE(_hw_usb, OID_AUTO, wmt, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 66 "USB MSWindows 7/8/10 compatible Multi-touch Device"); 67 SYSCTL_INT(_hw_usb_wmt, OID_AUTO, debug, CTLFLAG_RWTUN, 68 &wmt_debug, 1, "Debug level"); 69 #endif 70 71 #define WMT_BSIZE 1024 /* bytes, buffer size */ 72 73 enum { 74 WMT_INTR_DT, 75 WMT_N_TRANSFER, 76 }; 77 78 enum { 79 WMT_TIP_SWITCH, 80 #define WMT_SLOT WMT_TIP_SWITCH 81 WMT_WIDTH, 82 #define WMT_MAJOR WMT_WIDTH 83 WMT_HEIGHT, 84 #define WMT_MINOR WMT_HEIGHT 85 WMT_ORIENTATION, 86 WMT_X, 87 WMT_Y, 88 WMT_CONTACTID, 89 WMT_PRESSURE, 90 WMT_IN_RANGE, 91 WMT_CONFIDENCE, 92 WMT_TOOL_X, 93 WMT_TOOL_Y, 94 WMT_N_USAGES, 95 }; 96 97 #define WMT_NO_CODE (ABS_MAX + 10) 98 #define WMT_NO_USAGE -1 99 100 struct wmt_hid_map_item { 101 char name[5]; 102 int32_t usage; /* HID usage */ 103 uint32_t code; /* Evdev event code */ 104 bool required; /* Required for MT Digitizers */ 105 }; 106 107 static const struct wmt_hid_map_item wmt_hid_map[WMT_N_USAGES] = { 108 [WMT_TIP_SWITCH] = { /* WMT_SLOT */ 109 .name = "TIP", 110 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_SWITCH), 111 .code = ABS_MT_SLOT, 112 .required = true, 113 }, 114 [WMT_WIDTH] = { /* WMT_MAJOR */ 115 .name = "WDTH", 116 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_WIDTH), 117 .code = ABS_MT_TOUCH_MAJOR, 118 .required = false, 119 }, 120 [WMT_HEIGHT] = { /* WMT_MINOR */ 121 .name = "HGHT", 122 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_HEIGHT), 123 .code = ABS_MT_TOUCH_MINOR, 124 .required = false, 125 }, 126 [WMT_ORIENTATION] = { 127 .name = "ORIE", 128 .usage = WMT_NO_USAGE, 129 .code = ABS_MT_ORIENTATION, 130 .required = false, 131 }, 132 [WMT_X] = { 133 .name = "X", 134 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X), 135 .code = ABS_MT_POSITION_X, 136 .required = true, 137 }, 138 [WMT_Y] = { 139 .name = "Y", 140 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y), 141 .code = ABS_MT_POSITION_Y, 142 .required = true, 143 }, 144 [WMT_CONTACTID] = { 145 .name = "C_ID", 146 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTID), 147 .code = ABS_MT_TRACKING_ID, 148 .required = true, 149 }, 150 [WMT_PRESSURE] = { 151 .name = "PRES", 152 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_PRESSURE), 153 .code = ABS_MT_PRESSURE, 154 .required = false, 155 }, 156 [WMT_IN_RANGE] = { 157 .name = "RANG", 158 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_IN_RANGE), 159 .code = ABS_MT_DISTANCE, 160 .required = false, 161 }, 162 [WMT_CONFIDENCE] = { 163 .name = "CONF", 164 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONFIDENCE), 165 .code = WMT_NO_CODE, 166 .required = false, 167 }, 168 [WMT_TOOL_X] = { /* Shares HID usage with WMT_X */ 169 .name = "TL_X", 170 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X), 171 .code = ABS_MT_TOOL_X, 172 .required = false, 173 }, 174 [WMT_TOOL_Y] = { /* Shares HID usage with WMT_Y */ 175 .name = "TL_Y", 176 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y), 177 .code = ABS_MT_TOOL_Y, 178 .required = false, 179 }, 180 }; 181 182 struct wmt_absinfo { 183 int32_t min; 184 int32_t max; 185 int32_t res; 186 }; 187 188 struct wmt_softc 189 { 190 device_t dev; 191 struct mtx mtx; 192 struct wmt_absinfo ai[WMT_N_USAGES]; 193 struct hid_location locs[MAX_MT_SLOTS][WMT_N_USAGES]; 194 struct hid_location nconts_loc; 195 196 struct usb_xfer *xfer[WMT_N_TRANSFER]; 197 struct evdev_dev *evdev; 198 199 uint32_t slot_data[WMT_N_USAGES]; 200 uint32_t caps; 201 uint32_t isize; 202 uint32_t nconts_max; 203 uint32_t report_len; 204 uint8_t report_id; 205 206 struct hid_location cont_max_loc; 207 uint32_t cont_max_rlen; 208 uint8_t cont_max_rid; 209 uint32_t thqa_cert_rlen; 210 uint8_t thqa_cert_rid; 211 212 uint8_t buf[WMT_BSIZE] __aligned(4); 213 }; 214 215 #define USAGE_SUPPORTED(caps, usage) ((caps) & (1 << (usage))) 216 #define WMT_FOREACH_USAGE(caps, usage) \ 217 for ((usage) = 0; (usage) < WMT_N_USAGES; ++(usage)) \ 218 if (USAGE_SUPPORTED((caps), (usage))) 219 220 static bool wmt_hid_parse(struct wmt_softc *, const void *, uint16_t); 221 static void wmt_cont_max_parse(struct wmt_softc *, const void *, uint16_t); 222 223 static usb_callback_t wmt_intr_callback; 224 225 static device_probe_t wmt_probe; 226 static device_attach_t wmt_attach; 227 static device_detach_t wmt_detach; 228 229 #if __FreeBSD_version >= 1200077 230 static evdev_open_t wmt_ev_open; 231 static evdev_close_t wmt_ev_close; 232 #else 233 static evdev_open_t wmt_ev_open_11; 234 static evdev_close_t wmt_ev_close_11; 235 #endif 236 237 static const struct evdev_methods wmt_evdev_methods = { 238 #if __FreeBSD_version >= 1200077 239 .ev_open = &wmt_ev_open, 240 .ev_close = &wmt_ev_close, 241 #else 242 .ev_open = &wmt_ev_open_11, 243 .ev_close = &wmt_ev_close_11, 244 #endif 245 }; 246 247 static const struct usb_config wmt_config[WMT_N_TRANSFER] = { 248 [WMT_INTR_DT] = { 249 .type = UE_INTERRUPT, 250 .endpoint = UE_ADDR_ANY, 251 .direction = UE_DIR_IN, 252 .flags = { .pipe_bof = 1, .short_xfer_ok = 1 }, 253 .bufsize = WMT_BSIZE, 254 .callback = &wmt_intr_callback, 255 }, 256 }; 257 258 static int 259 wmt_probe(device_t dev) 260 { 261 struct usb_attach_arg *uaa = device_get_ivars(dev); 262 void *d_ptr; 263 uint16_t d_len; 264 int err; 265 266 if (uaa->usb_mode != USB_MODE_HOST) 267 return (ENXIO); 268 269 if (uaa->info.bInterfaceClass != UICLASS_HID) 270 return (ENXIO); 271 272 if (usb_test_quirk(uaa, UQ_WMT_IGNORE)) 273 return (ENXIO); 274 275 err = usbd_req_get_hid_desc(uaa->device, NULL, 276 &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex); 277 if (err) 278 return (ENXIO); 279 280 if (wmt_hid_parse(NULL, d_ptr, d_len)) 281 err = BUS_PROBE_DEFAULT; 282 else 283 err = ENXIO; 284 285 free(d_ptr, M_TEMP); 286 return (err); 287 } 288 289 static int 290 wmt_attach(device_t dev) 291 { 292 struct usb_attach_arg *uaa = device_get_ivars(dev); 293 struct wmt_softc *sc = device_get_softc(dev); 294 void *d_ptr; 295 uint16_t d_len; 296 size_t i; 297 int err; 298 bool hid_ok; 299 300 device_set_usb_desc(dev); 301 sc->dev = dev; 302 303 /* Get HID descriptor */ 304 err = usbd_req_get_hid_desc(uaa->device, NULL, 305 &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex); 306 if (err) { 307 DPRINTF("usbd_req_get_hid_desc error=%s\n", usbd_errstr(err)); 308 return (ENXIO); 309 } 310 311 hid_ok = wmt_hid_parse(sc, d_ptr, d_len); 312 free(d_ptr, M_TEMP); 313 if (!hid_ok) { 314 DPRINTF("multi-touch HID descriptor not found\n"); 315 return (ENXIO); 316 } 317 318 /* Check HID report length */ 319 if (sc->isize <= 0 || sc->isize > WMT_BSIZE) { 320 DPRINTF("Input size invalid or too large: %d\n", sc->isize); 321 return (ENXIO); 322 } 323 324 /* Fetch and parse "Contact count maximum" feature report */ 325 if (sc->cont_max_rlen > 0 && sc->cont_max_rlen <= WMT_BSIZE) { 326 err = usbd_req_get_report(uaa->device, NULL, sc->buf, 327 sc->cont_max_rlen, uaa->info.bIfaceIndex, 328 UHID_FEATURE_REPORT, sc->cont_max_rid); 329 if (err == USB_ERR_NORMAL_COMPLETION) 330 wmt_cont_max_parse(sc, sc->buf, sc->cont_max_rlen); 331 else 332 DPRINTF("usbd_req_get_report error=(%s)\n", 333 usbd_errstr(err)); 334 } else 335 DPRINTF("Feature report %hhu size invalid or too large: %u\n", 336 sc->cont_max_rid, sc->cont_max_rlen); 337 338 /* Fetch THQA certificate to enable some devices like WaveShare */ 339 if (sc->thqa_cert_rlen > 0 && sc->thqa_cert_rlen <= WMT_BSIZE && 340 sc->thqa_cert_rid != sc->cont_max_rid) 341 (void)usbd_req_get_report(uaa->device, NULL, sc->buf, 342 sc->thqa_cert_rlen, uaa->info.bIfaceIndex, 343 UHID_FEATURE_REPORT, sc->thqa_cert_rid); 344 345 mtx_init(&sc->mtx, "wmt lock", NULL, MTX_DEF); 346 347 err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, 348 sc->xfer, wmt_config, WMT_N_TRANSFER, sc, &sc->mtx); 349 if (err != USB_ERR_NORMAL_COMPLETION) { 350 DPRINTF("usbd_transfer_setup error=%s\n", usbd_errstr(err)); 351 goto detach; 352 } 353 354 sc->evdev = evdev_alloc(); 355 evdev_set_name(sc->evdev, device_get_desc(dev)); 356 evdev_set_phys(sc->evdev, device_get_nameunit(dev)); 357 evdev_set_id(sc->evdev, BUS_USB, uaa->info.idVendor, 358 uaa->info.idProduct, 0); 359 evdev_set_serial(sc->evdev, usb_get_serial(uaa->device)); 360 evdev_set_methods(sc->evdev, sc, &wmt_evdev_methods); 361 evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_STCOMPAT); 362 evdev_support_prop(sc->evdev, INPUT_PROP_DIRECT); 363 evdev_support_event(sc->evdev, EV_SYN); 364 evdev_support_event(sc->evdev, EV_ABS); 365 WMT_FOREACH_USAGE(sc->caps, i) { 366 if (wmt_hid_map[i].code != WMT_NO_CODE) 367 evdev_support_abs(sc->evdev, wmt_hid_map[i].code, 0, 368 sc->ai[i].min, sc->ai[i].max, 0, 0, sc->ai[i].res); 369 } 370 371 err = evdev_register_mtx(sc->evdev, &sc->mtx); 372 if (err) 373 goto detach; 374 375 return (0); 376 377 detach: 378 wmt_detach(dev); 379 return (ENXIO); 380 } 381 382 static int 383 wmt_detach(device_t dev) 384 { 385 struct wmt_softc *sc = device_get_softc(dev); 386 387 evdev_free(sc->evdev); 388 usbd_transfer_unsetup(sc->xfer, WMT_N_TRANSFER); 389 mtx_destroy(&sc->mtx); 390 return (0); 391 } 392 393 static void 394 wmt_process_report(struct wmt_softc *sc, uint8_t *buf, int len) 395 { 396 size_t usage; 397 uint32_t *slot_data = sc->slot_data; 398 uint32_t cont; 399 uint32_t nconts; 400 uint32_t width; 401 uint32_t height; 402 int32_t slot; 403 404 nconts = hid_get_data_unsigned(buf, len, &sc->nconts_loc); 405 406 #ifdef USB_DEBUG 407 DPRINTFN(6, "nconts = %u ", (unsigned)nconts); 408 if (wmt_debug >= 6) { 409 WMT_FOREACH_USAGE(sc->caps, usage) { 410 if (wmt_hid_map[usage].usage != WMT_NO_USAGE) 411 printf(" %-4s", wmt_hid_map[usage].name); 412 } 413 printf("\n"); 414 } 415 #endif 416 417 if (nconts > sc->nconts_max) { 418 DPRINTF("Contact count overflow %u\n", (unsigned)nconts); 419 nconts = sc->nconts_max; 420 } 421 422 /* Use protocol Type B for reporting events */ 423 for (cont = 0; cont < nconts; cont++) { 424 bzero(slot_data, sizeof(sc->slot_data)); 425 WMT_FOREACH_USAGE(sc->caps, usage) { 426 if (sc->locs[cont][usage].size > 0) 427 slot_data[usage] = hid_get_data_unsigned( 428 buf, len, &sc->locs[cont][usage]); 429 } 430 431 slot = evdev_get_mt_slot_by_tracking_id(sc->evdev, 432 slot_data[WMT_CONTACTID]); 433 434 #ifdef USB_DEBUG 435 DPRINTFN(6, "cont%01x: data = ", cont); 436 if (wmt_debug >= 6) { 437 WMT_FOREACH_USAGE(sc->caps, usage) { 438 if (wmt_hid_map[usage].usage != WMT_NO_USAGE) 439 printf("%04x ", slot_data[usage]); 440 } 441 printf("slot = %d\n", (int)slot); 442 } 443 #endif 444 445 if (slot == -1) { 446 DPRINTF("Slot overflow for contact_id %u\n", 447 (unsigned)slot_data[WMT_CONTACTID]); 448 continue; 449 } 450 451 if (slot_data[WMT_TIP_SWITCH] != 0 && 452 !(USAGE_SUPPORTED(sc->caps, WMT_CONFIDENCE) && 453 slot_data[WMT_CONFIDENCE] == 0)) { 454 /* This finger is in proximity of the sensor */ 455 slot_data[WMT_SLOT] = slot; 456 slot_data[WMT_IN_RANGE] = !slot_data[WMT_IN_RANGE]; 457 /* Divided by two to match visual scale of touch */ 458 width = slot_data[WMT_WIDTH] >> 1; 459 height = slot_data[WMT_HEIGHT] >> 1; 460 slot_data[WMT_ORIENTATION] = width > height; 461 slot_data[WMT_MAJOR] = MAX(width, height); 462 slot_data[WMT_MINOR] = MIN(width, height); 463 464 WMT_FOREACH_USAGE(sc->caps, usage) 465 if (wmt_hid_map[usage].code != WMT_NO_CODE) 466 evdev_push_abs(sc->evdev, 467 wmt_hid_map[usage].code, 468 slot_data[usage]); 469 } else { 470 evdev_push_abs(sc->evdev, ABS_MT_SLOT, slot); 471 evdev_push_abs(sc->evdev, ABS_MT_TRACKING_ID, -1); 472 } 473 } 474 evdev_sync(sc->evdev); 475 } 476 477 static void 478 wmt_intr_callback(struct usb_xfer *xfer, usb_error_t error) 479 { 480 struct wmt_softc *sc = usbd_xfer_softc(xfer); 481 struct usb_page_cache *pc; 482 uint8_t *buf = sc->buf; 483 int len; 484 485 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 486 487 switch (USB_GET_STATE(xfer)) { 488 case USB_ST_TRANSFERRED: 489 pc = usbd_xfer_get_frame(xfer, 0); 490 491 DPRINTFN(6, "sc=%p actlen=%d\n", sc, len); 492 493 if (len >= (int)sc->report_len || 494 (len > 0 && sc->report_id != 0)) { 495 /* Limit report length to the maximum */ 496 if (len > (int)sc->report_len) 497 len = sc->report_len; 498 499 usbd_copy_out(pc, 0, buf, len); 500 501 /* Ignore irrelevant reports */ 502 if (sc->report_id && *buf != sc->report_id) 503 goto tr_ignore; 504 505 /* Make sure we don't process old data */ 506 if (len < sc->report_len) 507 bzero(buf + len, sc->report_len - len); 508 509 /* Strip leading "report ID" byte */ 510 if (sc->report_id) { 511 len--; 512 buf++; 513 } 514 515 wmt_process_report(sc, buf, len); 516 } else { 517 tr_ignore: 518 DPRINTF("Ignored transfer, %d bytes\n", len); 519 } 520 521 case USB_ST_SETUP: 522 tr_setup: 523 usbd_xfer_set_frame_len(xfer, 0, sc->isize); 524 usbd_transfer_submit(xfer); 525 break; 526 default: 527 if (error != USB_ERR_CANCELLED) { 528 /* Try clear stall first */ 529 usbd_xfer_set_stall(xfer); 530 goto tr_setup; 531 } 532 break; 533 } 534 } 535 536 static void 537 wmt_ev_close_11(struct evdev_dev *evdev, void *ev_softc) 538 { 539 struct wmt_softc *sc = ev_softc; 540 541 mtx_assert(&sc->mtx, MA_OWNED); 542 usbd_transfer_stop(sc->xfer[WMT_INTR_DT]); 543 } 544 545 static int 546 wmt_ev_open_11(struct evdev_dev *evdev, void *ev_softc) 547 { 548 struct wmt_softc *sc = ev_softc; 549 550 mtx_assert(&sc->mtx, MA_OWNED); 551 usbd_transfer_start(sc->xfer[WMT_INTR_DT]); 552 553 return (0); 554 } 555 556 #if __FreeBSD_version >= 1200077 557 static int 558 wmt_ev_close(struct evdev_dev *evdev) 559 { 560 struct wmt_softc *sc = evdev_get_softc(evdev); 561 562 wmt_ev_close_11(evdev, sc); 563 564 return (0); 565 } 566 567 static int 568 wmt_ev_open(struct evdev_dev *evdev) 569 { 570 struct wmt_softc *sc = evdev_get_softc(evdev); 571 572 return (wmt_ev_open_11(evdev, sc)); 573 574 } 575 #endif 576 577 /* port of userland hid_report_size() from usbhid(3) to kernel */ 578 static int 579 wmt_hid_report_size(const void *buf, uint16_t len, enum hid_kind k, uint8_t id) 580 { 581 struct hid_data *d; 582 struct hid_item h; 583 uint32_t temp; 584 uint32_t hpos; 585 uint32_t lpos; 586 int report_id = 0; 587 588 hpos = 0; 589 lpos = 0xFFFFFFFF; 590 591 for (d = hid_start_parse(buf, len, 1 << k); hid_get_item(d, &h);) { 592 if (h.kind == k && h.report_ID == id) { 593 /* compute minimum */ 594 if (lpos > h.loc.pos) 595 lpos = h.loc.pos; 596 /* compute end position */ 597 temp = h.loc.pos + (h.loc.size * h.loc.count); 598 /* compute maximum */ 599 if (hpos < temp) 600 hpos = temp; 601 if (h.report_ID != 0) 602 report_id = 1; 603 } 604 } 605 hid_end_parse(d); 606 607 /* safety check - can happen in case of currupt descriptors */ 608 if (lpos > hpos) 609 temp = 0; 610 else 611 temp = hpos - lpos; 612 613 /* return length in bytes rounded up */ 614 return ((temp + 7) / 8 + report_id); 615 } 616 617 static bool 618 wmt_hid_parse(struct wmt_softc *sc, const void *d_ptr, uint16_t d_len) 619 { 620 struct hid_item hi; 621 struct hid_data *hd; 622 size_t i; 623 size_t cont = 0; 624 uint32_t caps = 0; 625 int32_t cont_count_max = 0; 626 uint8_t report_id = 0; 627 uint8_t cont_max_rid = 0; 628 uint8_t thqa_cert_rid = 0; 629 bool touch_coll = false; 630 bool finger_coll = false; 631 bool cont_count_found = false; 632 bool scan_time_found = false; 633 634 #define WMT_HI_ABSOLUTE(hi) \ 635 (((hi).flags & (HIO_CONST|HIO_VARIABLE|HIO_RELATIVE)) == HIO_VARIABLE) 636 #define HUMS_THQA_CERT 0xC5 637 638 /* Parse features for maximum contact count */ 639 hd = hid_start_parse(d_ptr, d_len, 1 << hid_feature); 640 while (hid_get_item(hd, &hi)) { 641 switch (hi.kind) { 642 case hid_collection: 643 if (hi.collevel == 1 && hi.usage == 644 HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHSCREEN)) 645 touch_coll = true; 646 break; 647 case hid_endcollection: 648 if (hi.collevel == 0 && touch_coll) 649 touch_coll = false; 650 break; 651 case hid_feature: 652 if (hi.collevel == 1 && touch_coll && hi.usage == 653 HID_USAGE2(HUP_MICROSOFT, HUMS_THQA_CERT)) { 654 thqa_cert_rid = hi.report_ID; 655 break; 656 } 657 if (hi.collevel == 1 && touch_coll && hi.usage == 658 HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACT_MAX)) { 659 cont_count_max = hi.logical_maximum; 660 cont_max_rid = hi.report_ID; 661 if (sc != NULL) 662 sc->cont_max_loc = hi.loc; 663 } 664 break; 665 default: 666 break; 667 } 668 } 669 hid_end_parse(hd); 670 671 /* Maximum contact count is required usage */ 672 if (cont_max_rid == 0) 673 return (false); 674 675 touch_coll = false; 676 677 /* Parse input for other parameters */ 678 hd = hid_start_parse(d_ptr, d_len, 1 << hid_input); 679 while (hid_get_item(hd, &hi)) { 680 switch (hi.kind) { 681 case hid_collection: 682 if (hi.collevel == 1 && hi.usage == 683 HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHSCREEN)) 684 touch_coll = true; 685 else if (touch_coll && hi.collevel == 2 && 686 (report_id == 0 || report_id == hi.report_ID) && 687 hi.usage == HID_USAGE2(HUP_DIGITIZERS, HUD_FINGER)) 688 finger_coll = true; 689 break; 690 case hid_endcollection: 691 if (hi.collevel == 1 && finger_coll) { 692 finger_coll = false; 693 cont++; 694 } else if (hi.collevel == 0 && touch_coll) 695 touch_coll = false; 696 break; 697 case hid_input: 698 /* 699 * Ensure that all usages are located within the same 700 * report and proper collection. 701 */ 702 if (WMT_HI_ABSOLUTE(hi) && touch_coll && 703 (report_id == 0 || report_id == hi.report_ID)) 704 report_id = hi.report_ID; 705 else 706 break; 707 708 if (hi.collevel == 1 && hi.usage == 709 HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTCOUNT)) { 710 cont_count_found = true; 711 if (sc != NULL) 712 sc->nconts_loc = hi.loc; 713 break; 714 } 715 /* Scan time is required but clobbered by evdev */ 716 if (hi.collevel == 1 && hi.usage == 717 HID_USAGE2(HUP_DIGITIZERS, HUD_SCAN_TIME)) { 718 scan_time_found = true; 719 break; 720 } 721 722 if (!finger_coll || hi.collevel != 2) 723 break; 724 if (sc == NULL && cont > 0) 725 break; 726 if (cont >= MAX_MT_SLOTS) { 727 DPRINTF("Finger %zu ignored\n", cont); 728 break; 729 } 730 731 for (i = 0; i < WMT_N_USAGES; i++) { 732 if (hi.usage == wmt_hid_map[i].usage) { 733 if (sc == NULL) { 734 if (USAGE_SUPPORTED(caps, i)) 735 continue; 736 caps |= 1 << i; 737 break; 738 } 739 /* 740 * HUG_X usage is an array mapped to 741 * both ABS_MT_POSITION and ABS_MT_TOOL 742 * events. So don`t stop search if we 743 * already have HUG_X mapping done. 744 */ 745 if (sc->locs[cont][i].size) 746 continue; 747 sc->locs[cont][i] = hi.loc; 748 /* 749 * Hid parser returns valid logical and 750 * physical sizes for first finger only 751 * at least on ElanTS 0x04f3:0x0012. 752 */ 753 if (cont > 0) 754 break; 755 caps |= 1 << i; 756 sc->ai[i] = (struct wmt_absinfo) { 757 .max = hi.logical_maximum, 758 .min = hi.logical_minimum, 759 .res = hid_item_resolution(&hi), 760 }; 761 break; 762 } 763 } 764 break; 765 default: 766 break; 767 } 768 } 769 hid_end_parse(hd); 770 771 /* Check for required HID Usages */ 772 if (!cont_count_found || !scan_time_found || cont == 0) 773 return (false); 774 for (i = 0; i < WMT_N_USAGES; i++) { 775 if (wmt_hid_map[i].required && !USAGE_SUPPORTED(caps, i)) 776 return (false); 777 } 778 779 /* Stop probing here */ 780 if (sc == NULL) 781 return (true); 782 783 /* 784 * According to specifications 'Contact Count Maximum' should be read 785 * from Feature Report rather than from HID descriptor. Set sane 786 * default value now to handle the case of 'Get Report' request failure 787 */ 788 if (cont_count_max < 1) 789 cont_count_max = cont; 790 791 /* Cap contact count maximum to MAX_MT_SLOTS */ 792 if (cont_count_max > MAX_MT_SLOTS) 793 cont_count_max = MAX_MT_SLOTS; 794 795 /* Set number of MT protocol type B slots */ 796 sc->ai[WMT_SLOT] = (struct wmt_absinfo) { 797 .min = 0, 798 .max = cont_count_max - 1, 799 .res = 0, 800 }; 801 802 /* Report touch orientation if both width and height are supported */ 803 if (USAGE_SUPPORTED(caps, WMT_WIDTH) && 804 USAGE_SUPPORTED(caps, WMT_HEIGHT)) { 805 caps |= (1 << WMT_ORIENTATION); 806 sc->ai[WMT_ORIENTATION].max = 1; 807 } 808 809 sc->isize = hid_report_size(d_ptr, d_len, hid_input, NULL); 810 sc->report_len = wmt_hid_report_size(d_ptr, d_len, hid_input, 811 report_id); 812 sc->cont_max_rlen = wmt_hid_report_size(d_ptr, d_len, hid_feature, 813 cont_max_rid); 814 if (thqa_cert_rid > 0) 815 sc->thqa_cert_rlen = wmt_hid_report_size(d_ptr, d_len, 816 hid_feature, thqa_cert_rid); 817 818 sc->report_id = report_id; 819 sc->caps = caps; 820 sc->nconts_max = cont; 821 sc->cont_max_rid = cont_max_rid; 822 sc->thqa_cert_rid = thqa_cert_rid; 823 824 /* Announce information about the touch device */ 825 device_printf(sc->dev, 826 "%d contacts and [%s%s%s%s%s]. Report range [%d:%d] - [%d:%d]\n", 827 (int)cont_count_max, 828 USAGE_SUPPORTED(sc->caps, WMT_IN_RANGE) ? "R" : "", 829 USAGE_SUPPORTED(sc->caps, WMT_CONFIDENCE) ? "C" : "", 830 USAGE_SUPPORTED(sc->caps, WMT_WIDTH) ? "W" : "", 831 USAGE_SUPPORTED(sc->caps, WMT_HEIGHT) ? "H" : "", 832 USAGE_SUPPORTED(sc->caps, WMT_PRESSURE) ? "P" : "", 833 (int)sc->ai[WMT_X].min, (int)sc->ai[WMT_Y].min, 834 (int)sc->ai[WMT_X].max, (int)sc->ai[WMT_Y].max); 835 return (true); 836 } 837 838 static void 839 wmt_cont_max_parse(struct wmt_softc *sc, const void *r_ptr, uint16_t r_len) 840 { 841 uint32_t cont_count_max; 842 843 cont_count_max = hid_get_data_unsigned((const uint8_t *)r_ptr + 1, 844 r_len - 1, &sc->cont_max_loc); 845 if (cont_count_max > MAX_MT_SLOTS) { 846 DPRINTF("Hardware reported %d contacts while only %d is " 847 "supported\n", (int)cont_count_max, MAX_MT_SLOTS); 848 cont_count_max = MAX_MT_SLOTS; 849 } 850 /* Feature report is a primary source of 'Contact Count Maximum' */ 851 if (cont_count_max > 0 && 852 cont_count_max != sc->ai[WMT_SLOT].max + 1) { 853 sc->ai[WMT_SLOT].max = cont_count_max - 1; 854 device_printf(sc->dev, "%d feature report contacts", 855 cont_count_max); 856 } 857 } 858 859 static const STRUCT_USB_HOST_ID wmt_devs[] = { 860 /* generic HID class w/o boot interface */ 861 {USB_IFACE_CLASS(UICLASS_HID), 862 USB_IFACE_SUBCLASS(0),}, 863 }; 864 865 static devclass_t wmt_devclass; 866 867 static device_method_t wmt_methods[] = { 868 DEVMETHOD(device_probe, wmt_probe), 869 DEVMETHOD(device_attach, wmt_attach), 870 DEVMETHOD(device_detach, wmt_detach), 871 872 DEVMETHOD_END 873 }; 874 875 static driver_t wmt_driver = { 876 .name = "wmt", 877 .methods = wmt_methods, 878 .size = sizeof(struct wmt_softc), 879 }; 880 881 DRIVER_MODULE(wmt, uhub, wmt_driver, wmt_devclass, NULL, 0); 882 MODULE_DEPEND(wmt, usb, 1, 1, 1); 883 MODULE_DEPEND(wmt, evdev, 1, 1, 1); 884 MODULE_VERSION(wmt, 1); 885 USB_PNP_HOST_INFO(wmt_devs); 886