2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2014-2020 Vladimir Kondratyev <wulf@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
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
40 #include <sys/param.h>
42 #include <sys/kernel.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>
50 #include <dev/evdev/evdev.h>
51 #include <dev/evdev/input.h>
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>
58 #include <dev/hid/hconf.h>
60 static SYSCTL_NODE(_hw_hid, OID_AUTO, hmt, CTLFLAG_RW, 0,
61 "MSWindows 7/8/10 compatible HID Multi-touch Device");
63 static int hmt_debug = 0;
64 SYSCTL_INT(_hw_hid_hmt, OID_AUTO, debug, CTLFLAG_RWTUN,
65 &hmt_debug, 1, "Debug level");
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");
71 #define HMT_BTN_MAX 8 /* Number of buttons supported */
74 HMT_TYPE_UNKNOWN = 0, /* HID report descriptor is not probed */
75 HMT_TYPE_UNSUPPORTED, /* Repdescr does not belong to MT device */
82 #define HMT_SLOT HMT_TIP_SWITCH
84 #define HMT_MAJOR HMT_WIDTH
86 #define HMT_MINOR HMT_HEIGHT
99 #define HMT_NO_CODE (ABS_MAX + 10)
100 #define HMT_NO_USAGE -1
102 struct hmt_hid_map_item {
104 int32_t usage; /* HID usage */
105 uint32_t code; /* Evdev event code */
106 bool required; /* Required for MT Digitizers */
109 static const struct hmt_hid_map_item hmt_hid_map[HMT_N_USAGES] = {
110 [HMT_TIP_SWITCH] = { /* HMT_SLOT */
112 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_SWITCH),
116 [HMT_WIDTH] = { /* HMT_MAJOR */
118 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_WIDTH),
119 .code = ABS_MT_TOUCH_MAJOR,
122 [HMT_HEIGHT] = { /* HMT_MINOR */
124 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_HEIGHT),
125 .code = ABS_MT_TOUCH_MINOR,
128 [HMT_ORIENTATION] = {
130 .usage = HMT_NO_USAGE,
131 .code = ABS_MT_ORIENTATION,
136 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
137 .code = ABS_MT_POSITION_X,
142 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
143 .code = ABS_MT_POSITION_Y,
148 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTID),
149 .code = ABS_MT_TRACKING_ID,
154 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_PRESSURE),
155 .code = ABS_MT_PRESSURE,
160 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_IN_RANGE),
161 .code = ABS_MT_DISTANCE,
166 .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONFIDENCE),
170 [HMT_TOOL_X] = { /* Shares HID usage with HMT_X */
172 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
173 .code = ABS_MT_TOOL_X,
176 [HMT_TOOL_Y] = { /* Shares HID usage with HMT_Y */
178 .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
179 .code = ABS_MT_TOOL_Y,
188 struct hid_absinfo ai[HMT_N_USAGES];
189 struct hid_location locs[MAX_MT_SLOTS][HMT_N_USAGES];
190 struct hid_location cont_count_loc;
191 struct hid_location btn_loc[HMT_BTN_MAX];
192 struct hid_location int_btn_loc;
193 struct hid_location scan_time_loc;
194 int32_t scan_time_max;
200 struct evdev_dev *evdev;
202 uint32_t slot_data[HMT_N_USAGES];
203 uint8_t caps[howmany(HMT_N_USAGES, 8)];
204 uint8_t buttons[howmany(HMT_BTN_MAX, 8)];
205 uint32_t nconts_per_report;
206 uint32_t nconts_todo;
212 #ifdef IICHID_SAMPLING
213 bool iichid_sampling;
216 struct hid_location cont_max_loc;
217 uint32_t cont_max_rlen;
218 uint8_t cont_max_rid;
219 struct hid_location btn_type_loc;
220 uint32_t btn_type_rlen;
221 uint8_t btn_type_rid;
222 uint32_t thqa_cert_rlen;
223 uint8_t thqa_cert_rid;
226 #define HMT_FOREACH_USAGE(caps, usage) \
227 for ((usage) = 0; (usage) < HMT_N_USAGES; ++(usage)) \
228 if (isset((caps), (usage)))
230 static enum hmt_type hmt_hid_parse(struct hmt_softc *, const void *,
231 hid_size_t, uint32_t, uint8_t);
232 static int hmt_set_input_mode(struct hmt_softc *, enum hconf_input_mode);
234 static hid_intr_t hmt_intr;
236 static device_probe_t hmt_probe;
237 static device_attach_t hmt_attach;
238 static device_detach_t hmt_detach;
240 static evdev_open_t hmt_ev_open;
241 static evdev_close_t hmt_ev_close;
243 static const struct evdev_methods hmt_evdev_methods = {
244 .ev_open = &hmt_ev_open,
245 .ev_close = &hmt_ev_close,
248 static const struct hid_device_id hmt_devs[] = {
249 { HID_TLC(HUP_DIGITIZERS, HUD_TOUCHSCREEN) },
250 { HID_TLC(HUP_DIGITIZERS, HUD_TOUCHPAD) },
254 hmt_ev_close(struct evdev_dev *evdev)
256 return (hidbus_intr_stop(evdev_get_softc(evdev)));
260 hmt_ev_open(struct evdev_dev *evdev)
262 return (hidbus_intr_start(evdev_get_softc(evdev)));
266 hmt_probe(device_t dev)
268 struct hmt_softc *sc = device_get_softc(dev);
273 err = HIDBUS_LOOKUP_DRIVER_INFO(dev, hmt_devs);
277 err = hid_get_report_descr(dev, &d_ptr, &d_len);
279 device_printf(dev, "could not retrieve report descriptor from "
280 "device: %d\n", err);
284 /* Check if report descriptor belongs to a HID multitouch device */
285 if (sc->type == HMT_TYPE_UNKNOWN)
286 sc->type = hmt_hid_parse(sc, d_ptr, d_len,
287 hidbus_get_usage(dev), hidbus_get_index(dev));
288 if (sc->type == HMT_TYPE_UNSUPPORTED)
292 sc->type == HMT_TYPE_TOUCHPAD ? "TouchPad" : "TouchScreen");
294 return (BUS_PROBE_DEFAULT);
298 hmt_attach(device_t dev)
300 struct hmt_softc *sc = device_get_softc(dev);
301 const struct hid_device_info *hw = hid_get_device_info(dev);
303 uint8_t *fbuf = NULL;
304 hid_size_t d_len, fsize;
305 uint32_t cont_count_max;
310 err = hid_get_report_descr(dev, &d_ptr, &d_len);
312 device_printf(dev, "could not retrieve report descriptor from "
313 "device: %d\n", err);
319 fsize = hid_report_size_max(d_ptr, d_len, hid_feature, NULL);
321 fbuf = malloc(fsize, M_TEMP, M_WAITOK | M_ZERO);
323 /* Fetch and parse "Contact count maximum" feature report */
324 if (sc->cont_max_rlen > 1) {
325 err = hid_get_report(dev, fbuf, sc->cont_max_rlen, NULL,
326 HID_FEATURE_REPORT, sc->cont_max_rid);
328 cont_count_max = hid_get_udata(fbuf + 1,
329 sc->cont_max_rlen - 1, &sc->cont_max_loc);
331 * Feature report is a primary source of
332 * 'Contact Count Maximum'
334 if (cont_count_max > 0)
335 sc->ai[HMT_SLOT].max = cont_count_max - 1;
337 DPRINTF("hid_get_report error=%d\n", err);
339 DPRINTF("Feature report %hhu size invalid: %u\n",
340 sc->cont_max_rid, sc->cont_max_rlen);
342 /* Fetch and parse "Button type" feature report */
343 if (sc->btn_type_rlen > 1 && sc->btn_type_rid != sc->cont_max_rid) {
345 err = hid_get_report(dev, fbuf, sc->btn_type_rlen, NULL,
346 HID_FEATURE_REPORT, sc->btn_type_rid);
348 if (sc->btn_type_rlen > 1) {
350 sc->is_clickpad = hid_get_udata(fbuf + 1,
351 sc->btn_type_rlen - 1, &sc->btn_type_loc) == 0;
353 DPRINTF("hid_get_report error=%d\n", err);
356 /* Fetch THQA certificate to enable some devices like WaveShare */
357 if (sc->thqa_cert_rlen > 1 && sc->thqa_cert_rid != sc->cont_max_rid)
358 (void)hid_get_report(dev, fbuf, sc->thqa_cert_rlen, NULL,
359 HID_FEATURE_REPORT, sc->thqa_cert_rid);
363 /* Switch touchpad in to absolute multitouch mode */
364 if (sc->type == HMT_TYPE_TOUCHPAD) {
365 err = hmt_set_input_mode(sc, HCONF_INPUT_MODE_MT_TOUCHPAD);
367 DPRINTF("Failed to set input mode: %d\n", err);
370 /* Cap contact count maximum to MAX_MT_SLOTS */
371 if (sc->ai[HMT_SLOT].max >= MAX_MT_SLOTS) {
372 DPRINTF("Hardware reported %d contacts while only %d is "
373 "supported\n", (int)sc->ai[HMT_SLOT].max+1, MAX_MT_SLOTS);
374 sc->ai[HMT_SLOT].max = MAX_MT_SLOTS - 1;
377 if (hid_test_quirk(hw, HQ_MT_TIMESTAMP) || hmt_timestamps)
378 sc->do_timestamps = true;
379 #ifdef IICHID_SAMPLING
380 if (hid_test_quirk(hw, HQ_IICHID_SAMPLING))
381 sc->iichid_sampling = true;
384 hidbus_set_intr(dev, hmt_intr, sc);
386 sc->evdev = evdev_alloc();
387 evdev_set_name(sc->evdev, device_get_desc(dev));
388 evdev_set_phys(sc->evdev, device_get_nameunit(dev));
389 evdev_set_id(sc->evdev, hw->idBus, hw->idVendor, hw->idProduct,
391 evdev_set_serial(sc->evdev, hw->serial);
392 evdev_set_methods(sc->evdev, dev, &hmt_evdev_methods);
393 evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_STCOMPAT);
394 evdev_set_flag(sc->evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */
396 case HMT_TYPE_TOUCHSCREEN:
397 evdev_support_prop(sc->evdev, INPUT_PROP_DIRECT);
399 case HMT_TYPE_TOUCHPAD:
400 evdev_support_prop(sc->evdev, INPUT_PROP_POINTER);
402 evdev_support_prop(sc->evdev, INPUT_PROP_BUTTONPAD);
405 KASSERT(0, ("hmt_attach: unsupported touch device type"));
407 evdev_support_event(sc->evdev, EV_SYN);
408 evdev_support_event(sc->evdev, EV_ABS);
409 if (sc->do_timestamps) {
410 evdev_support_event(sc->evdev, EV_MSC);
411 evdev_support_msc(sc->evdev, MSC_TIMESTAMP);
413 #ifdef IICHID_SAMPLING
414 if (sc->iichid_sampling)
415 evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_AUTOREL);
418 if (sc->max_button != 0 || sc->has_int_button) {
419 evdev_support_event(sc->evdev, EV_KEY);
420 if (sc->has_int_button)
421 evdev_support_key(sc->evdev, BTN_LEFT);
422 for (btn = 0; btn < sc->max_button; ++btn) {
423 if (isset(sc->buttons, btn)) {
424 evdev_support_key(sc->evdev, BTN_MOUSE + btn);
429 HMT_FOREACH_USAGE(sc->caps, i) {
430 if (hmt_hid_map[i].code != HMT_NO_CODE)
431 evdev_support_abs(sc->evdev, hmt_hid_map[i].code,
432 sc->ai[i].min, sc->ai[i].max, 0, 0, sc->ai[i].res);
435 err = evdev_register(sc->evdev);
441 /* Announce information about the touch device */
442 device_printf(sc->dev, "Multitouch %s with %d external button%s%s\n",
443 sc->type == HMT_TYPE_TOUCHSCREEN ? "touchscreen" : "touchpad",
444 nbuttons, nbuttons != 1 ? "s" : "",
445 sc->is_clickpad ? ", click-pad" : "");
446 device_printf(sc->dev,
447 "%d contacts with [%s%s%s%s%s] properties. Report range [%d:%d] - [%d:%d]\n",
448 (int)sc->ai[HMT_SLOT].max + 1,
449 isset(sc->caps, HMT_IN_RANGE) ? "R" : "",
450 isset(sc->caps, HMT_CONFIDENCE) ? "C" : "",
451 isset(sc->caps, HMT_WIDTH) ? "W" : "",
452 isset(sc->caps, HMT_HEIGHT) ? "H" : "",
453 isset(sc->caps, HMT_PRESSURE) ? "P" : "",
454 (int)sc->ai[HMT_X].min, (int)sc->ai[HMT_Y].min,
455 (int)sc->ai[HMT_X].max, (int)sc->ai[HMT_Y].max);
461 hmt_detach(device_t dev)
463 struct hmt_softc *sc = device_get_softc(dev);
465 evdev_free(sc->evdev);
471 hmt_intr(void *context, void *buf, hid_size_t len)
473 struct hmt_softc *sc = context;
475 uint32_t *slot_data = sc->slot_data;
480 uint32_t int_btn = 0;
481 uint32_t left_btn = 0;
487 #ifdef IICHID_SAMPLING
489 * Special packet of zero length is generated by iichid driver running
490 * in polling mode at the start of inactivity period to workaround
491 * "stuck touch" problem caused by miss of finger release events.
492 * This snippet is to be removed after GPIO interrupt support is added.
494 if (sc->iichid_sampling && len == 0) {
495 sc->prev_touch = false;
497 for (slot = 0; slot <= sc->ai[HMT_SLOT].max; slot++) {
498 evdev_push_abs(sc->evdev, ABS_MT_SLOT, slot);
499 evdev_push_abs(sc->evdev, ABS_MT_TRACKING_ID, -1);
501 evdev_sync(sc->evdev);
506 /* Ignore irrelevant reports */
507 id = sc->report_id != 0 ? *(uint8_t *)buf : 0;
508 if (sc->report_id != id) {
509 DPRINTF("Skip report with unexpected ID: %hhu\n", id);
513 /* Strip leading "report ID" byte */
514 if (sc->report_id != 0) {
516 buf = (uint8_t *)buf + 1;
520 * "In Parallel mode, devices report all contact information in a
521 * single packet. Each physical contact is represented by a logical
522 * collection that is embedded in the top-level collection."
524 * Since additional contacts that were not present will still be in the
525 * report with contactid=0 but contactids are zero-based, find
526 * contactcount first.
528 cont_count = hid_get_udata(buf, len, &sc->cont_count_loc);
530 * "In Hybrid mode, the number of contacts that can be reported in one
531 * report is less than the maximum number of contacts that the device
532 * supports. For example, a device that supports a maximum of
533 * 4 concurrent physical contacts, can set up its top-level collection
534 * to deliver a maximum of two contacts in one report. If four contact
535 * points are present, the device can break these up into two serial
536 * reports that deliver two contacts each.
538 * "When a device delivers data in this manner, the Contact Count usage
539 * value in the first report should reflect the total number of
540 * contacts that are being delivered in the hybrid reports. The other
541 * serial reports should have a contact count of zero (0)."
544 sc->nconts_todo = cont_count;
547 DPRINTFN(6, "cont_count:%2u", (unsigned)cont_count);
548 if (hmt_debug >= 6) {
549 HMT_FOREACH_USAGE(sc->caps, usage) {
550 if (hmt_hid_map[usage].usage != HMT_NO_USAGE)
551 printf(" %-4s", hmt_hid_map[usage].name);
557 /* Find the number of contacts reported in current report */
558 cont_count = MIN(sc->nconts_todo, sc->nconts_per_report);
560 /* Use protocol Type B for reporting events */
561 for (cont = 0; cont < cont_count; cont++) {
562 bzero(slot_data, sizeof(sc->slot_data));
563 HMT_FOREACH_USAGE(sc->caps, usage) {
564 if (sc->locs[cont][usage].size > 0)
565 slot_data[usage] = hid_get_udata(
566 buf, len, &sc->locs[cont][usage]);
569 slot = evdev_get_mt_slot_by_tracking_id(sc->evdev,
570 slot_data[HMT_CONTACTID]);
573 DPRINTFN(6, "cont%01x: data = ", cont);
574 if (hmt_debug >= 6) {
575 HMT_FOREACH_USAGE(sc->caps, usage) {
576 if (hmt_hid_map[usage].usage != HMT_NO_USAGE)
577 printf("%04x ", slot_data[usage]);
579 printf("slot = %d\n", (int)slot);
584 DPRINTF("Slot overflow for contact_id %u\n",
585 (unsigned)slot_data[HMT_CONTACTID]);
589 if (slot_data[HMT_TIP_SWITCH] != 0 &&
590 !(isset(sc->caps, HMT_CONFIDENCE) &&
591 slot_data[HMT_CONFIDENCE] == 0)) {
592 /* This finger is in proximity of the sensor */
594 slot_data[HMT_SLOT] = slot;
595 slot_data[HMT_IN_RANGE] = !slot_data[HMT_IN_RANGE];
596 /* Divided by two to match visual scale of touch */
597 width = slot_data[HMT_WIDTH] >> 1;
598 height = slot_data[HMT_HEIGHT] >> 1;
599 slot_data[HMT_ORIENTATION] = width > height;
600 slot_data[HMT_MAJOR] = MAX(width, height);
601 slot_data[HMT_MINOR] = MIN(width, height);
603 HMT_FOREACH_USAGE(sc->caps, usage)
604 if (hmt_hid_map[usage].code != HMT_NO_CODE)
605 evdev_push_abs(sc->evdev,
606 hmt_hid_map[usage].code,
609 evdev_push_abs(sc->evdev, ABS_MT_SLOT, slot);
610 evdev_push_abs(sc->evdev, ABS_MT_TRACKING_ID, -1);
614 sc->nconts_todo -= cont_count;
615 if (sc->do_timestamps && sc->nconts_todo == 0) {
616 /* HUD_SCAN_TIME is measured in 100us, convert to us. */
617 scan_time = hid_get_udata(buf, len, &sc->scan_time_loc);
618 if (sc->prev_touch) {
619 delta = scan_time - sc->scan_time;
621 delta += sc->scan_time_max;
624 sc->scan_time = scan_time;
625 sc->timestamp += delta * 100;
626 evdev_push_msc(sc->evdev, MSC_TIMESTAMP, sc->timestamp);
627 sc->prev_touch = sc->touch;
632 if (sc->nconts_todo == 0) {
633 /* Report both the click and external left btns as BTN_LEFT */
634 if (sc->has_int_button)
635 int_btn = hid_get_data(buf, len, &sc->int_btn_loc);
636 if (isset(sc->buttons, 0))
637 left_btn = hid_get_data(buf, len, &sc->btn_loc[0]);
638 if (sc->has_int_button || isset(sc->buttons, 0))
639 evdev_push_key(sc->evdev, BTN_LEFT,
640 (int_btn != 0) | (left_btn != 0));
641 for (btn = 1; btn < sc->max_button; ++btn) {
642 if (isset(sc->buttons, btn))
643 evdev_push_key(sc->evdev, BTN_MOUSE + btn,
646 &sc->btn_loc[btn]) != 0);
648 evdev_sync(sc->evdev);
653 hmt_hid_parse(struct hmt_softc *sc, const void *d_ptr, hid_size_t d_len,
654 uint32_t tlc_usage, uint8_t tlc_index)
656 struct hid_absinfo ai;
663 uint32_t left_btn, btn;
664 int32_t cont_count_max = 0;
665 uint8_t report_id = 0;
666 bool finger_coll = false;
667 bool cont_count_found = false;
668 bool scan_time_found = false;
669 bool has_int_button = false;
671 #define HMT_HI_ABSOLUTE(hi) \
672 (((hi).flags & (HIO_CONST|HIO_VARIABLE|HIO_RELATIVE)) == HIO_VARIABLE)
673 #define HUMS_THQA_CERT 0xC5
676 * Get left button usage taking in account MS Precision Touchpad specs.
677 * For Windows PTP report descriptor assigns buttons in following way:
678 * Button 1 - Indicates Button State for touchpad button integrated
680 * Button 2 - Indicates Button State for external button for primary
681 * (default left) clicking.
682 * Button 3 - Indicates Button State for external button for secondary
683 * (default right) clicking.
684 * If a device only supports external buttons, it must still use
685 * Button 2 and Button 3 to reference the external buttons.
688 case HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHSCREEN):
689 type = HMT_TYPE_TOUCHSCREEN;
692 case HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHPAD):
693 type = HMT_TYPE_TOUCHPAD;
697 return (HMT_TYPE_UNSUPPORTED);
700 /* Parse features for mandatory maximum contact count usage */
701 if (!hidbus_locate(d_ptr, d_len,
702 HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACT_MAX), hid_feature,
703 tlc_index, 0, &sc->cont_max_loc, &flags, &sc->cont_max_rid, &ai) ||
704 (flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE)
705 return (HMT_TYPE_UNSUPPORTED);
707 cont_count_max = ai.max;
709 /* Parse features for button type usage */
710 if (hidbus_locate(d_ptr, d_len,
711 HID_USAGE2(HUP_DIGITIZERS, HUD_BUTTON_TYPE), hid_feature,
712 tlc_index, 0, &sc->btn_type_loc, &flags, &sc->btn_type_rid, NULL)
713 && (flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE)
714 sc->btn_type_rid = 0;
716 /* Parse features for THQA certificate report ID */
717 hidbus_locate(d_ptr, d_len, HID_USAGE2(HUP_MICROSOFT, HUMS_THQA_CERT),
718 hid_feature, tlc_index, 0, NULL, NULL, &sc->thqa_cert_rid, NULL);
720 /* Parse input for other parameters */
721 hd = hid_start_parse(d_ptr, d_len, 1 << hid_input);
722 HIDBUS_FOREACH_ITEM(hd, &hi, tlc_index) {
725 if (hi.collevel == 2 &&
726 hi.usage == HID_USAGE2(HUP_DIGITIZERS, HUD_FINGER))
729 case hid_endcollection:
730 if (hi.collevel == 1 && finger_coll) {
737 * Ensure that all usages belong to the same report
739 if (HMT_HI_ABSOLUTE(hi) &&
740 (report_id == 0 || report_id == hi.report_ID))
741 report_id = hi.report_ID;
745 if (hi.collevel == 1 && left_btn == 2 &&
746 hi.usage == HID_USAGE2(HUP_BUTTON, 1)) {
747 has_int_button = true;
748 sc->int_btn_loc = hi.loc;
751 if (hi.collevel == 1 &&
752 hi.usage >= HID_USAGE2(HUP_BUTTON, left_btn) &&
753 hi.usage <= HID_USAGE2(HUP_BUTTON, HMT_BTN_MAX)) {
754 btn = (hi.usage & 0xFFFF) - left_btn;
755 setbit(sc->buttons, btn);
756 sc->btn_loc[btn] = hi.loc;
757 if (btn >= sc->max_button)
758 sc->max_button = btn + 1;
761 if (hi.collevel == 1 && hi.usage ==
762 HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTCOUNT)) {
763 cont_count_found = true;
764 sc->cont_count_loc = hi.loc;
767 /* Scan time is required but clobbered by evdev */
768 if (hi.collevel == 1 && hi.usage ==
769 HID_USAGE2(HUP_DIGITIZERS, HUD_SCAN_TIME)) {
770 scan_time_found = true;
771 sc->scan_time_loc = hi.loc;
772 sc->scan_time_max = hi.logical_maximum;
776 if (!finger_coll || hi.collevel != 2)
778 if (cont >= MAX_MT_SLOTS) {
779 DPRINTF("Finger %zu ignored\n", cont);
783 for (i = 0; i < HMT_N_USAGES; i++) {
784 if (hi.usage == hmt_hid_map[i].usage) {
786 * HUG_X usage is an array mapped to
787 * both ABS_MT_POSITION and ABS_MT_TOOL
788 * events. So don`t stop search if we
789 * already have HUG_X mapping done.
791 if (sc->locs[cont][i].size)
793 sc->locs[cont][i] = hi.loc;
795 * Hid parser returns valid logical and
796 * physical sizes for first finger only
797 * at least on ElanTS 0x04f3:0x0012.
802 sc->ai[i] = (struct hid_absinfo) {
803 .max = hi.logical_maximum,
804 .min = hi.logical_minimum,
805 .res = hid_item_resolution(&hi),
817 /* Check for required HID Usages */
818 if (!cont_count_found || !scan_time_found || cont == 0)
819 return (HMT_TYPE_UNSUPPORTED);
820 for (i = 0; i < HMT_N_USAGES; i++) {
821 if (hmt_hid_map[i].required && isclr(sc->caps, i))
822 return (HMT_TYPE_UNSUPPORTED);
825 /* Touchpads must have at least one button */
826 if (type == HMT_TYPE_TOUCHPAD && !sc->max_button && !has_int_button)
827 return (HMT_TYPE_UNSUPPORTED);
830 * According to specifications 'Contact Count Maximum' should be read
831 * from Feature Report rather than from HID descriptor. Set sane
832 * default value now to handle the case of 'Get Report' request failure
834 if (cont_count_max < 1)
835 cont_count_max = cont;
837 /* Set number of MT protocol type B slots */
838 sc->ai[HMT_SLOT] = (struct hid_absinfo) {
840 .max = cont_count_max - 1,
844 /* Report touch orientation if both width and height are supported */
845 if (isset(sc->caps, HMT_WIDTH) && isset(sc->caps, HMT_HEIGHT)) {
846 setbit(sc->caps, HMT_ORIENTATION);
847 sc->ai[HMT_ORIENTATION].max = 1;
850 sc->cont_max_rlen = hid_report_size(d_ptr, d_len, hid_feature,
852 if (sc->btn_type_rid > 0)
853 sc->btn_type_rlen = hid_report_size(d_ptr, d_len,
854 hid_feature, sc->btn_type_rid);
855 if (sc->thqa_cert_rid > 0)
856 sc->thqa_cert_rlen = hid_report_size(d_ptr, d_len,
857 hid_feature, sc->thqa_cert_rid);
859 sc->report_id = report_id;
860 sc->nconts_per_report = cont;
861 sc->has_int_button = has_int_button;
867 hmt_set_input_mode(struct hmt_softc *sc, enum hconf_input_mode mode)
869 devclass_t hconf_devclass;
875 /* Find touchpad's configuration TLC */
876 hconf = hidbus_find_child(device_get_parent(sc->dev),
877 HID_USAGE2(HUP_DIGITIZERS, HUD_CONFIG));
881 /* Ensure that hconf driver is attached to configuration TLC */
882 if (device_is_alive(hconf) == 0)
883 device_probe_and_attach(hconf);
884 if (device_is_attached(hconf) == 0)
886 hconf_devclass = devclass_find("hconf");
887 if (device_get_devclass(hconf) != hconf_devclass)
890 /* hconf_set_input_mode can drop the Giant while sleeping */
892 err = hconf_set_input_mode(hconf, mode);
893 device_unbusy(hconf);
898 static devclass_t hmt_devclass;
900 static device_method_t hmt_methods[] = {
901 DEVMETHOD(device_probe, hmt_probe),
902 DEVMETHOD(device_attach, hmt_attach),
903 DEVMETHOD(device_detach, hmt_detach),
908 static driver_t hmt_driver = {
910 .methods = hmt_methods,
911 .size = sizeof(struct hmt_softc),
914 DRIVER_MODULE(hmt, hidbus, hmt_driver, hmt_devclass, NULL, 0);
915 MODULE_DEPEND(hmt, hidbus, 1, 1, 1);
916 MODULE_DEPEND(hmt, hid, 1, 1, 1);
917 MODULE_DEPEND(hmt, hconf, 1, 1, 1);
918 MODULE_DEPEND(hmt, evdev, 1, 1, 1);
919 MODULE_VERSION(hmt, 1);
920 HID_PNP_INFO(hmt_devs);