sys/dev/usb/input/wmt.c

   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);