1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2014-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 /* 32 * MS Windows 7/8/10 compatible HID Multi-touch Device driver. 33 * https://msdn.microsoft.com/en-us/library/windows/hardware/jj151569(v=vs.85).aspx 34 * http://download.microsoft.com/download/7/d/d/7dd44bb7-2a7a-4505-ac1c-7227d3d96d5b/hid-over-i2c-protocol-spec-v1-0.docx 35 * https://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt 36 */ 37 38 #include "opt_hid.h" 39 40 #include <sys/param.h> 41 #include <sys/bus.h> 42 #include <sys/kernel.h> 43 #include <sys/lock.h> 44 #include <sys/malloc.h> 45 #include <sys/module.h> 46 #include <sys/mutex.h> 47 #include <sys/sysctl.h> 48 #include <sys/systm.h> 49 50 #include <dev/evdev/evdev.h> 51 #include <dev/evdev/input.h> 52 53 #define HID_DEBUG_VAR hmt_debug 54 #include <dev/hid/hid.h> 55 #include <dev/hid/hidbus.h> 56 #include <dev/hid/hidquirk.h> 57 58 #include <dev/hid/hconf.h> 59 60 static SYSCTL_NODE(_hw_hid, OID_AUTO, hmt, CTLFLAG_RW, 0, 61 "MSWindows 7/8/10 compatible HID Multi-touch Device"); 62 #ifdef HID_DEBUG 63 static int hmt_debug = 0; 64 SYSCTL_INT(_hw_hid_hmt, OID_AUTO, debug, CTLFLAG_RWTUN, 65 &hmt_debug, 1, "Debug level"); 66 #endif 67 static bool hmt_timestamps = 0; 68 SYSCTL_BOOL(_hw_hid_hmt, OID_AUTO, timestamps, CTLFLAG_RDTUN, 69 &hmt_timestamps, 1, "Enable hardware timestamp reporting"); 70 71 #define HMT_BTN_MAX 8 /* Number of buttons supported */ 72 73 enum hmt_type { 74 HMT_TYPE_UNKNOWN = 0, /* HID report descriptor is not probed */ 75 HMT_TYPE_UNSUPPORTED, /* Repdescr does not belong to MT device */ 76 HMT_TYPE_TOUCHPAD, 77 HMT_TYPE_TOUCHSCREEN, 78 }; 79 80 enum { 81 HMT_TIP_SWITCH = ABS_MT_INDEX(ABS_MT_TOOL_TYPE), 82 HMT_WIDTH = ABS_MT_INDEX(ABS_MT_TOUCH_MAJOR), 83 HMT_HEIGHT = ABS_MT_INDEX(ABS_MT_TOUCH_MINOR), 84 HMT_ORIENTATION = ABS_MT_INDEX(ABS_MT_ORIENTATION), 85 HMT_X = ABS_MT_INDEX(ABS_MT_POSITION_X), 86 HMT_Y = ABS_MT_INDEX(ABS_MT_POSITION_Y), 87 HMT_CONTACTID = ABS_MT_INDEX(ABS_MT_TRACKING_ID), 88 HMT_PRESSURE = ABS_MT_INDEX(ABS_MT_PRESSURE), 89 HMT_IN_RANGE = ABS_MT_INDEX(ABS_MT_DISTANCE), 90 HMT_CONFIDENCE = ABS_MT_INDEX(ABS_MT_BLOB_ID), 91 HMT_TOOL_X = ABS_MT_INDEX(ABS_MT_TOOL_X), 92 HMT_TOOL_Y = ABS_MT_INDEX(ABS_MT_TOOL_Y), 93 }; 94 95 #define HMT_N_USAGES MT_CNT 96 #define HMT_NO_USAGE -1 97 98 struct hmt_hid_map_item { 99 char name[5]; 100 int32_t usage; /* HID usage */ 101 bool reported; /* Item value is passed to evdev */ 102 bool required; /* Required for MT Digitizers */ 103 }; 104 105 static const struct hmt_hid_map_item hmt_hid_map[HMT_N_USAGES] = { 106 [HMT_TIP_SWITCH] = { 107 .name = "TIP", 108 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_SWITCH), 109 .reported = false, 110 .required = true, 111 }, 112 [HMT_WIDTH] = { 113 .name = "WDTH", 114 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_WIDTH), 115 .reported = true, 116 .required = false, 117 }, 118 [HMT_HEIGHT] = { 119 .name = "HGHT", 120 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_HEIGHT), 121 .reported = true, 122 .required = false, 123 }, 124 [HMT_ORIENTATION] = { 125 .name = "ORIE", 126 .usage = HMT_NO_USAGE, 127 .reported = true, 128 .required = false, 129 }, 130 [HMT_X] = { 131 .name = "X", 132 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X), 133 .reported = true, 134 .required = true, 135 }, 136 [HMT_Y] = { 137 .name = "Y", 138 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y), 139 .reported = true, 140 .required = true, 141 }, 142 [HMT_CONTACTID] = { 143 .name = "C_ID", 144 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTID), 145 .reported = true, 146 .required = true, 147 }, 148 [HMT_PRESSURE] = { 149 .name = "PRES", 150 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_PRESSURE), 151 .reported = true, 152 .required = false, 153 }, 154 [HMT_IN_RANGE] = { 155 .name = "RANG", 156 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_IN_RANGE), 157 .reported = true, 158 .required = false, 159 }, 160 [HMT_CONFIDENCE] = { 161 .name = "CONF", 162 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONFIDENCE), 163 .reported = false, 164 .required = false, 165 }, 166 [HMT_TOOL_X] = { /* Shares HID usage with POS_X */ 167 .name = "TL_X", 168 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X), 169 .reported = true, 170 .required = false, 171 }, 172 [HMT_TOOL_Y] = { /* Shares HID usage with POS_Y */ 173 .name = "TL_Y", 174 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y), 175 .reported = true, 176 .required = false, 177 }, 178 }; 179 180 struct hmt_softc { 181 device_t dev; 182 enum hmt_type type; 183 184 int32_t cont_count_max; 185 struct hid_absinfo ai[HMT_N_USAGES]; 186 struct hid_location locs[MAX_MT_SLOTS][HMT_N_USAGES]; 187 struct hid_location cont_count_loc; 188 struct hid_location btn_loc[HMT_BTN_MAX]; 189 struct hid_location int_btn_loc; 190 struct hid_location scan_time_loc; 191 int32_t scan_time_max; 192 int32_t scan_time; 193 int32_t timestamp; 194 bool touch; 195 bool prev_touch; 196 197 struct evdev_dev *evdev; 198 199 union evdev_mt_slot slot_data; 200 uint8_t caps[howmany(HMT_N_USAGES, 8)]; 201 uint8_t buttons[howmany(HMT_BTN_MAX, 8)]; 202 uint32_t nconts_per_report; 203 uint32_t nconts_todo; 204 uint8_t report_id; 205 uint32_t max_button; 206 bool has_int_button; 207 bool has_cont_count; 208 bool has_scan_time; 209 bool is_clickpad; 210 bool do_timestamps; 211 #ifdef IICHID_SAMPLING 212 bool iichid_sampling; 213 #endif 214 215 struct hid_location cont_max_loc; 216 uint32_t cont_max_rlen; 217 uint8_t cont_max_rid; 218 struct hid_location btn_type_loc; 219 uint32_t btn_type_rlen; 220 uint8_t btn_type_rid; 221 uint32_t thqa_cert_rlen; 222 uint8_t thqa_cert_rid; 223 }; 224 225 #define HMT_FOREACH_USAGE(caps, usage) \ 226 for ((usage) = 0; (usage) < HMT_N_USAGES; ++(usage)) \ 227 if (isset((caps), (usage))) 228 229 static enum hmt_type hmt_hid_parse(struct hmt_softc *, const void *, 230 hid_size_t, uint32_t, uint8_t); 231 static int hmt_set_input_mode(struct hmt_softc *, enum hconf_input_mode); 232 233 static hid_intr_t hmt_intr; 234 235 static device_probe_t hmt_probe; 236 static device_attach_t hmt_attach; 237 static device_detach_t hmt_detach; 238 239 static evdev_open_t hmt_ev_open; 240 static evdev_close_t hmt_ev_close; 241 242 static const struct evdev_methods hmt_evdev_methods = { 243 .ev_open = &hmt_ev_open, 244 .ev_close = &hmt_ev_close, 245 }; 246 247 static const struct hid_device_id hmt_devs[] = { 248 { HID_TLC(HUP_DIGITIZERS, HUD_TOUCHSCREEN) }, 249 { HID_TLC(HUP_DIGITIZERS, HUD_TOUCHPAD) }, 250 }; 251 252 static int 253 hmt_ev_close(struct evdev_dev *evdev) 254 { 255 return (hidbus_intr_stop(evdev_get_softc(evdev))); 256 } 257 258 static int 259 hmt_ev_open(struct evdev_dev *evdev) 260 { 261 return (hidbus_intr_start(evdev_get_softc(evdev))); 262 } 263 264 static int 265 hmt_probe(device_t dev) 266 { 267 struct hmt_softc *sc = device_get_softc(dev); 268 void *d_ptr; 269 hid_size_t d_len; 270 int err; 271 272 err = HIDBUS_LOOKUP_DRIVER_INFO(dev, hmt_devs); 273 if (err != 0) 274 return (err); 275 276 err = hid_get_report_descr(dev, &d_ptr, &d_len); 277 if (err != 0) { 278 device_printf(dev, "could not retrieve report descriptor from " 279 "device: %d\n", err); 280 return (ENXIO); 281 } 282 283 /* Check if report descriptor belongs to a HID multitouch device */ 284 if (sc->type == HMT_TYPE_UNKNOWN) 285 sc->type = hmt_hid_parse(sc, d_ptr, d_len, 286 hidbus_get_usage(dev), hidbus_get_index(dev)); 287 if (sc->type == HMT_TYPE_UNSUPPORTED) 288 return (ENXIO); 289 290 hidbus_set_desc(dev, 291 sc->type == HMT_TYPE_TOUCHPAD ? "TouchPad" : "TouchScreen"); 292 293 return (BUS_PROBE_DEFAULT); 294 } 295 296 static int 297 hmt_attach(device_t dev) 298 { 299 struct hmt_softc *sc = device_get_softc(dev); 300 const struct hid_device_info *hw = hid_get_device_info(dev); 301 void *d_ptr; 302 uint8_t *fbuf = NULL; 303 hid_size_t d_len, fsize, rsize; 304 uint32_t cont_count_max; 305 int nbuttons, btn; 306 size_t i; 307 int err; 308 309 err = hid_get_report_descr(dev, &d_ptr, &d_len); 310 if (err != 0) { 311 device_printf(dev, "could not retrieve report descriptor from " 312 "device: %d\n", err); 313 return (ENXIO); 314 } 315 316 sc->dev = dev; 317 318 fsize = hid_report_size_max(d_ptr, d_len, hid_feature, NULL); 319 if (fsize != 0) 320 fbuf = malloc(fsize, M_TEMP, M_WAITOK | M_ZERO); 321 322 /* Fetch and parse "Contact count maximum" feature report */ 323 if (sc->cont_max_rlen > 1) { 324 err = hid_get_report(dev, fbuf, sc->cont_max_rlen, &rsize, 325 HID_FEATURE_REPORT, sc->cont_max_rid); 326 if (err == 0 && (rsize - 1) * 8 >= 327 sc->cont_max_loc.pos + sc->cont_max_loc.size) { 328 cont_count_max = hid_get_udata(fbuf + 1, 329 sc->cont_max_rlen - 1, &sc->cont_max_loc); 330 /* 331 * Feature report is a primary source of 332 * 'Contact Count Maximum' 333 */ 334 if (cont_count_max > 0) 335 sc->cont_count_max = cont_count_max; 336 } else 337 DPRINTF("hid_get_report error=%d\n", err); 338 } 339 if (sc->cont_count_max == 0) 340 sc->cont_count_max = sc->type == HMT_TYPE_TOUCHSCREEN ? 10 : 5; 341 342 /* Fetch and parse "Button type" feature report */ 343 if (sc->btn_type_rlen > 1 && sc->btn_type_rid != sc->cont_max_rid) { 344 bzero(fbuf, fsize); 345 err = hid_get_report(dev, fbuf, sc->btn_type_rlen, &rsize, 346 HID_FEATURE_REPORT, sc->btn_type_rid); 347 if (err != 0) 348 DPRINTF("hid_get_report error=%d\n", err); 349 } 350 if (sc->btn_type_rlen > 1 && err == 0 && (rsize - 1) * 8 >= 351 sc->btn_type_loc.pos + sc->btn_type_loc.size) 352 sc->is_clickpad = hid_get_udata(fbuf + 1, sc->btn_type_rlen - 1, 353 &sc->btn_type_loc) == 0; 354 else 355 sc->is_clickpad = sc->max_button == 0 && sc->has_int_button; 356 357 /* Fetch THQA certificate to enable some devices like WaveShare */ 358 if (sc->thqa_cert_rlen > 1 && sc->thqa_cert_rid != sc->cont_max_rid) 359 (void)hid_get_report(dev, fbuf, sc->thqa_cert_rlen, NULL, 360 HID_FEATURE_REPORT, sc->thqa_cert_rid); 361 362 free(fbuf, M_TEMP); 363 364 /* Switch touchpad in to absolute multitouch mode */ 365 if (sc->type == HMT_TYPE_TOUCHPAD) { 366 err = hmt_set_input_mode(sc, HCONF_INPUT_MODE_MT_TOUCHPAD); 367 if (err != 0) 368 DPRINTF("Failed to set input mode: %d\n", err); 369 } 370 371 /* Cap contact count maximum to MAX_MT_SLOTS */ 372 if (sc->cont_count_max > MAX_MT_SLOTS) { 373 DPRINTF("Hardware reported %d contacts while only %d is " 374 "supported\n", sc->cont_count_max, MAX_MT_SLOTS); 375 sc->cont_count_max = MAX_MT_SLOTS; 376 } 377 378 if (sc->has_scan_time && 379 (hid_test_quirk(hw, HQ_MT_TIMESTAMP) || hmt_timestamps)) 380 sc->do_timestamps = true; 381 #ifdef IICHID_SAMPLING 382 if (hid_test_quirk(hw, HQ_IICHID_SAMPLING)) 383 sc->iichid_sampling = true; 384 #endif 385 386 hidbus_set_intr(dev, hmt_intr, sc); 387 388 sc->evdev = evdev_alloc(); 389 evdev_set_name(sc->evdev, device_get_desc(dev)); 390 evdev_set_phys(sc->evdev, device_get_nameunit(dev)); 391 evdev_set_id(sc->evdev, hw->idBus, hw->idVendor, hw->idProduct, 392 hw->idVersion); 393 evdev_set_serial(sc->evdev, hw->serial); 394 evdev_set_methods(sc->evdev, dev, &hmt_evdev_methods); 395 evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_STCOMPAT); 396 evdev_set_flag(sc->evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */ 397 switch (sc->type) { 398 case HMT_TYPE_TOUCHSCREEN: 399 evdev_support_prop(sc->evdev, INPUT_PROP_DIRECT); 400 break; 401 case HMT_TYPE_TOUCHPAD: 402 evdev_support_prop(sc->evdev, INPUT_PROP_POINTER); 403 if (sc->is_clickpad) 404 evdev_support_prop(sc->evdev, INPUT_PROP_BUTTONPAD); 405 break; 406 default: 407 KASSERT(0, ("hmt_attach: unsupported touch device type")); 408 } 409 evdev_support_event(sc->evdev, EV_SYN); 410 evdev_support_event(sc->evdev, EV_ABS); 411 if (sc->do_timestamps) { 412 evdev_support_event(sc->evdev, EV_MSC); 413 evdev_support_msc(sc->evdev, MSC_TIMESTAMP); 414 } 415 #ifdef IICHID_SAMPLING 416 if (sc->iichid_sampling) 417 evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_AUTOREL); 418 #endif 419 nbuttons = 0; 420 if (sc->max_button != 0 || sc->has_int_button) { 421 evdev_support_event(sc->evdev, EV_KEY); 422 if (sc->has_int_button) 423 evdev_support_key(sc->evdev, BTN_LEFT); 424 for (btn = 0; btn < sc->max_button; ++btn) { 425 if (isset(sc->buttons, btn)) { 426 evdev_support_key(sc->evdev, BTN_MOUSE + btn); 427 nbuttons++; 428 } 429 } 430 } 431 evdev_support_abs(sc->evdev, 432 ABS_MT_SLOT, 0, sc->cont_count_max - 1, 0, 0, 0); 433 HMT_FOREACH_USAGE(sc->caps, i) { 434 if (hmt_hid_map[i].reported) 435 evdev_support_abs(sc->evdev, ABS_MT_FIRST + i, 436 sc->ai[i].min, sc->ai[i].max, 0, 0, sc->ai[i].res); 437 } 438 439 err = evdev_register(sc->evdev); 440 if (err) { 441 hmt_detach(dev); 442 return (ENXIO); 443 } 444 445 /* Announce information about the touch device */ 446 device_printf(sc->dev, "%s %s with %d external button%s%s\n", 447 sc->cont_count_max > 1 ? "Multitouch" : "Singletouch", 448 sc->type == HMT_TYPE_TOUCHSCREEN ? "touchscreen" : "touchpad", 449 nbuttons, nbuttons != 1 ? "s" : "", 450 sc->is_clickpad ? ", click-pad" : ""); 451 device_printf(sc->dev, 452 "%d contact%s with [%s%s%s%s%s] properties. Report range [%d:%d] - [%d:%d]\n", 453 (int)sc->cont_count_max, sc->cont_count_max != 1 ? "s" : "", 454 isset(sc->caps, HMT_IN_RANGE) ? "R" : "", 455 isset(sc->caps, HMT_CONFIDENCE) ? "C" : "", 456 isset(sc->caps, HMT_WIDTH) ? "W" : "", 457 isset(sc->caps, HMT_HEIGHT) ? "H" : "", 458 isset(sc->caps, HMT_PRESSURE) ? "P" : "", 459 (int)sc->ai[HMT_X].min, (int)sc->ai[HMT_Y].min, 460 (int)sc->ai[HMT_X].max, (int)sc->ai[HMT_Y].max); 461 462 return (0); 463 } 464 465 static int 466 hmt_detach(device_t dev) 467 { 468 struct hmt_softc *sc = device_get_softc(dev); 469 470 evdev_free(sc->evdev); 471 472 return (0); 473 } 474 475 static void 476 hmt_intr(void *context, void *buf, hid_size_t len) 477 { 478 struct hmt_softc *sc = context; 479 size_t usage; 480 union evdev_mt_slot *slot_data; 481 uint32_t cont, btn; 482 uint32_t cont_count; 483 uint32_t width; 484 uint32_t height; 485 uint32_t int_btn = 0; 486 uint32_t left_btn = 0; 487 int slot; 488 uint32_t scan_time; 489 int32_t delta; 490 uint8_t id; 491 492 #ifdef IICHID_SAMPLING 493 /* 494 * Special packet of zero length is generated by iichid driver running 495 * in polling mode at the start of inactivity period to workaround 496 * "stuck touch" problem caused by miss of finger release events. 497 * This snippet is to be removed after GPIO interrupt support is added. 498 */ 499 if (sc->iichid_sampling && len == 0) { 500 sc->prev_touch = false; 501 sc->timestamp = 0; 502 /* EVDEV_FLAG_MT_AUTOREL releases all touches for us */ 503 evdev_sync(sc->evdev); 504 return; 505 } 506 #endif 507 508 /* Ignore irrelevant reports */ 509 id = sc->report_id != 0 ? *(uint8_t *)buf : 0; 510 if (sc->report_id != id) { 511 DPRINTF("Skip report with unexpected ID: %hhu\n", id); 512 return; 513 } 514 515 /* Strip leading "report ID" byte */ 516 if (sc->report_id != 0) { 517 len--; 518 buf = (uint8_t *)buf + 1; 519 } 520 521 /* 522 * "In Serial mode, each packet contains information that describes a 523 * single physical contact point. Multiple contacts are streamed 524 * serially. In this mode, devices report all contact information in a 525 * series of packets. The device sends a separate packet for each 526 * concurrent contact." 527 * 528 * "In Parallel mode, devices report all contact information in a 529 * single packet. Each physical contact is represented by a logical 530 * collection that is embedded in the top-level collection." 531 * 532 * Since additional contacts that were not present will still be in the 533 * report with contactid=0 but contactids are zero-based, find 534 * contactcount first. 535 */ 536 if (sc->has_cont_count) 537 cont_count = hid_get_udata(buf, len, &sc->cont_count_loc); 538 else 539 cont_count = 1; 540 /* 541 * "In Hybrid mode, the number of contacts that can be reported in one 542 * report is less than the maximum number of contacts that the device 543 * supports. For example, a device that supports a maximum of 544 * 4 concurrent physical contacts, can set up its top-level collection 545 * to deliver a maximum of two contacts in one report. If four contact 546 * points are present, the device can break these up into two serial 547 * reports that deliver two contacts each. 548 * 549 * "When a device delivers data in this manner, the Contact Count usage 550 * value in the first report should reflect the total number of 551 * contacts that are being delivered in the hybrid reports. The other 552 * serial reports should have a contact count of zero (0)." 553 */ 554 if (cont_count != 0) 555 sc->nconts_todo = cont_count; 556 557 #ifdef HID_DEBUG 558 DPRINTFN(6, "cont_count:%2u", (unsigned)cont_count); 559 if (hmt_debug >= 6) { 560 HMT_FOREACH_USAGE(sc->caps, usage) { 561 if (hmt_hid_map[usage].usage != HMT_NO_USAGE) 562 printf(" %-4s", hmt_hid_map[usage].name); 563 } 564 printf("\n"); 565 } 566 #endif 567 568 /* Find the number of contacts reported in current report */ 569 cont_count = MIN(sc->nconts_todo, sc->nconts_per_report); 570 571 /* Use protocol Type B for reporting events */ 572 for (cont = 0; cont < cont_count; cont++) { 573 slot_data = &sc->slot_data; 574 bzero(slot_data, sizeof(sc->slot_data)); 575 HMT_FOREACH_USAGE(sc->caps, usage) { 576 if (sc->locs[cont][usage].size > 0) 577 slot_data->val[usage] = hid_get_udata( 578 buf, len, &sc->locs[cont][usage]); 579 } 580 581 slot = evdev_mt_id_to_slot(sc->evdev, slot_data->id); 582 583 #ifdef HID_DEBUG 584 DPRINTFN(6, "cont%01x: data = ", cont); 585 if (hmt_debug >= 6) { 586 HMT_FOREACH_USAGE(sc->caps, usage) { 587 if (hmt_hid_map[usage].usage != HMT_NO_USAGE) 588 printf("%04x ", slot_data->val[usage]); 589 } 590 printf("slot = %d\n", slot); 591 } 592 #endif 593 594 if (slot == -1) { 595 DPRINTF("Slot overflow for contact_id %u\n", 596 (unsigned)slot_data->id); 597 continue; 598 } 599 600 if (slot_data->val[HMT_TIP_SWITCH] != 0 && 601 !(isset(sc->caps, HMT_CONFIDENCE) && 602 slot_data->val[HMT_CONFIDENCE] == 0)) { 603 /* This finger is in proximity of the sensor */ 604 sc->touch = true; 605 slot_data->dist = !slot_data->val[HMT_IN_RANGE]; 606 /* Divided by two to match visual scale of touch */ 607 width = slot_data->val[HMT_WIDTH] >> 1; 608 height = slot_data->val[HMT_HEIGHT] >> 1; 609 slot_data->ori = width > height; 610 slot_data->maj = MAX(width, height); 611 slot_data->min = MIN(width, height); 612 } else 613 slot_data = NULL; 614 615 evdev_mt_push_slot(sc->evdev, slot, slot_data); 616 } 617 618 sc->nconts_todo -= cont_count; 619 if (sc->do_timestamps && sc->nconts_todo == 0) { 620 /* HUD_SCAN_TIME is measured in 100us, convert to us. */ 621 scan_time = hid_get_udata(buf, len, &sc->scan_time_loc); 622 if (sc->prev_touch) { 623 delta = scan_time - sc->scan_time; 624 if (delta < 0) 625 delta += sc->scan_time_max; 626 } else 627 delta = 0; 628 sc->scan_time = scan_time; 629 sc->timestamp += delta * 100; 630 evdev_push_msc(sc->evdev, MSC_TIMESTAMP, sc->timestamp); 631 sc->prev_touch = sc->touch; 632 sc->touch = false; 633 if (!sc->prev_touch) 634 sc->timestamp = 0; 635 } 636 if (sc->nconts_todo == 0) { 637 /* Report both the click and external left btns as BTN_LEFT */ 638 if (sc->has_int_button) 639 int_btn = hid_get_data(buf, len, &sc->int_btn_loc); 640 if (isset(sc->buttons, 0)) 641 left_btn = hid_get_data(buf, len, &sc->btn_loc[0]); 642 if (sc->has_int_button || isset(sc->buttons, 0)) 643 evdev_push_key(sc->evdev, BTN_LEFT, 644 (int_btn != 0) | (left_btn != 0)); 645 for (btn = 1; btn < sc->max_button; ++btn) { 646 if (isset(sc->buttons, btn)) 647 evdev_push_key(sc->evdev, BTN_MOUSE + btn, 648 hid_get_data(buf, 649 len, 650 &sc->btn_loc[btn]) != 0); 651 } 652 evdev_sync(sc->evdev); 653 } 654 } 655 656 static enum hmt_type 657 hmt_hid_parse(struct hmt_softc *sc, const void *d_ptr, hid_size_t d_len, 658 uint32_t tlc_usage, uint8_t tlc_index) 659 { 660 struct hid_absinfo ai; 661 struct hid_item hi; 662 struct hid_data *hd; 663 uint32_t flags; 664 size_t i; 665 size_t cont = 0; 666 enum hmt_type type; 667 uint32_t left_btn, btn; 668 int32_t cont_count_max = 0; 669 uint8_t report_id = 0; 670 bool finger_coll = false; 671 bool cont_count_found = false; 672 bool scan_time_found = false; 673 bool has_int_button = false; 674 675 #define HMT_HI_ABSOLUTE(hi) ((hi).nusages != 0 && \ 676 ((hi).flags & (HIO_VARIABLE | HIO_RELATIVE)) == HIO_VARIABLE) 677 #define HUMS_THQA_CERT 0xC5 678 679 /* 680 * Get left button usage taking in account MS Precision Touchpad specs. 681 * For Windows PTP report descriptor assigns buttons in following way: 682 * Button 1 - Indicates Button State for touchpad button integrated 683 * with digitizer. 684 * Button 2 - Indicates Button State for external button for primary 685 * (default left) clicking. 686 * Button 3 - Indicates Button State for external button for secondary 687 * (default right) clicking. 688 * If a device only supports external buttons, it must still use 689 * Button 2 and Button 3 to reference the external buttons. 690 */ 691 switch (tlc_usage) { 692 case HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHSCREEN): 693 type = HMT_TYPE_TOUCHSCREEN; 694 left_btn = 1; 695 break; 696 case HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHPAD): 697 type = HMT_TYPE_TOUCHPAD; 698 left_btn = 2; 699 break; 700 default: 701 return (HMT_TYPE_UNSUPPORTED); 702 } 703 704 /* Parse features for mandatory maximum contact count usage */ 705 if (!hidbus_locate(d_ptr, d_len, 706 HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACT_MAX), hid_feature, 707 tlc_index, 0, &sc->cont_max_loc, &flags, &sc->cont_max_rid, &ai) || 708 (flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE) 709 return (HMT_TYPE_UNSUPPORTED); 710 711 cont_count_max = ai.max; 712 713 /* Parse features for button type usage */ 714 if (hidbus_locate(d_ptr, d_len, 715 HID_USAGE2(HUP_DIGITIZERS, HUD_BUTTON_TYPE), hid_feature, 716 tlc_index, 0, &sc->btn_type_loc, &flags, &sc->btn_type_rid, NULL) 717 && (flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE) 718 sc->btn_type_rid = 0; 719 720 /* Parse features for THQA certificate report ID */ 721 hidbus_locate(d_ptr, d_len, HID_USAGE2(HUP_MICROSOFT, HUMS_THQA_CERT), 722 hid_feature, tlc_index, 0, NULL, NULL, &sc->thqa_cert_rid, NULL); 723 724 /* Parse input for other parameters */ 725 hd = hid_start_parse(d_ptr, d_len, 1 << hid_input); 726 HIDBUS_FOREACH_ITEM(hd, &hi, tlc_index) { 727 switch (hi.kind) { 728 case hid_collection: 729 if (hi.collevel == 2 && 730 hi.usage == HID_USAGE2(HUP_DIGITIZERS, HUD_FINGER)) 731 finger_coll = true; 732 break; 733 case hid_endcollection: 734 if (hi.collevel == 1 && finger_coll) { 735 finger_coll = false; 736 cont++; 737 } 738 break; 739 case hid_input: 740 /* 741 * Ensure that all usages belong to the same report 742 */ 743 if (HMT_HI_ABSOLUTE(hi) && 744 (report_id == 0 || report_id == hi.report_ID)) 745 report_id = hi.report_ID; 746 else 747 break; 748 749 if (hi.collevel == 1 && left_btn == 2 && 750 hi.usage == HID_USAGE2(HUP_BUTTON, 1)) { 751 has_int_button = true; 752 sc->int_btn_loc = hi.loc; 753 break; 754 } 755 if (hi.collevel == 1 && 756 hi.usage >= HID_USAGE2(HUP_BUTTON, left_btn) && 757 hi.usage <= HID_USAGE2(HUP_BUTTON, HMT_BTN_MAX)) { 758 btn = (hi.usage & 0xFFFF) - left_btn; 759 setbit(sc->buttons, btn); 760 sc->btn_loc[btn] = hi.loc; 761 if (btn >= sc->max_button) 762 sc->max_button = btn + 1; 763 break; 764 } 765 if (hi.collevel == 1 && hi.usage == 766 HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTCOUNT)) { 767 cont_count_found = true; 768 sc->cont_count_loc = hi.loc; 769 break; 770 } 771 if (hi.collevel == 1 && hi.usage == 772 HID_USAGE2(HUP_DIGITIZERS, HUD_SCAN_TIME)) { 773 scan_time_found = true; 774 sc->scan_time_loc = hi.loc; 775 sc->scan_time_max = hi.logical_maximum; 776 break; 777 } 778 779 if (!finger_coll || hi.collevel != 2) 780 break; 781 if (cont >= MAX_MT_SLOTS) { 782 DPRINTF("Finger %zu ignored\n", cont); 783 break; 784 } 785 786 for (i = 0; i < HMT_N_USAGES; i++) { 787 if (hi.usage == hmt_hid_map[i].usage) { 788 /* 789 * HUG_X usage is an array mapped to 790 * both ABS_MT_POSITION and ABS_MT_TOOL 791 * events. So don`t stop search if we 792 * already have HUG_X mapping done. 793 */ 794 if (sc->locs[cont][i].size) 795 continue; 796 sc->locs[cont][i] = hi.loc; 797 /* 798 * Hid parser returns valid logical and 799 * physical sizes for first finger only 800 * at least on ElanTS 0x04f3:0x0012. 801 */ 802 if (cont > 0) 803 break; 804 setbit(sc->caps, i); 805 sc->ai[i] = (struct hid_absinfo) { 806 .max = hi.logical_maximum, 807 .min = hi.logical_minimum, 808 .res = hid_item_resolution(&hi), 809 }; 810 break; 811 } 812 } 813 break; 814 default: 815 break; 816 } 817 } 818 hid_end_parse(hd); 819 820 /* Check for required HID Usages */ 821 if ((!cont_count_found && cont != 1) || cont == 0) 822 return (HMT_TYPE_UNSUPPORTED); 823 for (i = 0; i < HMT_N_USAGES; i++) { 824 if (hmt_hid_map[i].required && isclr(sc->caps, i)) 825 return (HMT_TYPE_UNSUPPORTED); 826 } 827 828 /* Touchpads must have at least one button */ 829 if (type == HMT_TYPE_TOUCHPAD && !sc->max_button && !has_int_button) 830 return (HMT_TYPE_UNSUPPORTED); 831 832 /* 833 * According to specifications 'Contact Count Maximum' should be read 834 * from Feature Report rather than from HID descriptor. Set sane 835 * default value now to handle the case of 'Get Report' request failure 836 */ 837 if (cont_count_max < 1) 838 cont_count_max = cont; 839 840 /* Report touch orientation if both width and height are supported */ 841 if (isset(sc->caps, HMT_WIDTH) && isset(sc->caps, HMT_HEIGHT)) { 842 setbit(sc->caps, HMT_ORIENTATION); 843 sc->ai[HMT_ORIENTATION].max = 1; 844 } 845 846 sc->cont_max_rlen = hid_report_size(d_ptr, d_len, hid_feature, 847 sc->cont_max_rid); 848 if (sc->btn_type_rid > 0) 849 sc->btn_type_rlen = hid_report_size(d_ptr, d_len, 850 hid_feature, sc->btn_type_rid); 851 if (sc->thqa_cert_rid > 0) 852 sc->thqa_cert_rlen = hid_report_size(d_ptr, d_len, 853 hid_feature, sc->thqa_cert_rid); 854 855 sc->report_id = report_id; 856 sc->cont_count_max = cont_count_max; 857 sc->nconts_per_report = cont; 858 sc->has_int_button = has_int_button; 859 sc->has_cont_count = cont_count_found; 860 sc->has_scan_time = scan_time_found; 861 862 return (type); 863 } 864 865 static int 866 hmt_set_input_mode(struct hmt_softc *sc, enum hconf_input_mode mode) 867 { 868 devclass_t hconf_devclass; 869 device_t hconf; 870 int err; 871 872 bus_topo_assert(); 873 874 /* Find touchpad's configuration TLC */ 875 hconf = hidbus_find_child(device_get_parent(sc->dev), 876 HID_USAGE2(HUP_DIGITIZERS, HUD_CONFIG)); 877 if (hconf == NULL) 878 return (ENXIO); 879 880 /* Ensure that hconf driver is attached to configuration TLC */ 881 if (device_is_alive(hconf) == 0) 882 device_probe_and_attach(hconf); 883 if (device_is_attached(hconf) == 0) 884 return (ENXIO); 885 hconf_devclass = devclass_find("hconf"); 886 if (device_get_devclass(hconf) != hconf_devclass) 887 return (ENXIO); 888 889 /* hconf_set_input_mode can drop the the topo lock while sleeping */ 890 device_busy(hconf); 891 err = hconf_set_input_mode(hconf, mode); 892 device_unbusy(hconf); 893 894 return (err); 895 } 896 897 static devclass_t hmt_devclass; 898 899 static device_method_t hmt_methods[] = { 900 DEVMETHOD(device_probe, hmt_probe), 901 DEVMETHOD(device_attach, hmt_attach), 902 DEVMETHOD(device_detach, hmt_detach), 903 904 DEVMETHOD_END 905 }; 906 907 static driver_t hmt_driver = { 908 .name = "hmt", 909 .methods = hmt_methods, 910 .size = sizeof(struct hmt_softc), 911 }; 912 913 DRIVER_MODULE(hmt, hidbus, hmt_driver, hmt_devclass, NULL, 0); 914 MODULE_DEPEND(hmt, hidbus, 1, 1, 1); 915 MODULE_DEPEND(hmt, hid, 1, 1, 1); 916 MODULE_DEPEND(hmt, hconf, 1, 1, 1); 917 MODULE_DEPEND(hmt, evdev, 1, 1, 1); 918 MODULE_VERSION(hmt, 1); 919 HID_PNP_INFO(hmt_devs); 920