1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2014 Rohit Grover 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 /* 30 * Some tables, structures, definitions and constant values for the 31 * touchpad protocol has been copied from Linux's 32 * "drivers/input/mouse/bcm5974.c" which has the following copyright 33 * holders under GPLv2. All device specific code in this driver has 34 * been written from scratch. The decoding algorithm is based on 35 * output from FreeBSD's usbdump. 36 * 37 * Copyright (C) 2008 Henrik Rydberg (rydberg@euromail.se) 38 * Copyright (C) 2008 Scott Shawcroft (scott.shawcroft@gmail.com) 39 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) 40 * Copyright (C) 2005 Johannes Berg (johannes@sipsolutions.net) 41 * Copyright (C) 2005 Stelian Pop (stelian@popies.net) 42 * Copyright (C) 2005 Frank Arnold (frank@scirocco-5v-turbo.de) 43 * Copyright (C) 2005 Peter Osterlund (petero2@telia.com) 44 * Copyright (C) 2005 Michael Hanselmann (linux-kernel@hansmi.ch) 45 * Copyright (C) 2006 Nicolas Boichat (nicolas@boichat.ch) 46 */ 47 48 /* 49 * Author's note: 'atp' supports two distinct families of Apple trackpad 50 * products: the older Fountain/Geyser and the latest Wellspring trackpads. 51 * The first version made its appearance with FreeBSD 8 and worked only with 52 * the Fountain/Geyser hardware. A fork of this driver for Wellspring was 53 * contributed by Huang Wen Hui. This driver unifies the Wellspring effort 54 * and also improves upon the original work. 55 * 56 * I'm grateful to Stephan Scheunig, Angela Naegele, and Nokia IT-support 57 * for helping me with access to hardware. Thanks also go to Nokia for 58 * giving me an opportunity to do this work. 59 */ 60 61 #include <sys/cdefs.h> 62 __FBSDID("$FreeBSD$"); 63 64 #include <sys/stdint.h> 65 #include <sys/stddef.h> 66 #include <sys/param.h> 67 #include <sys/types.h> 68 #include <sys/systm.h> 69 #include <sys/kernel.h> 70 #include <sys/bus.h> 71 #include <sys/module.h> 72 #include <sys/lock.h> 73 #include <sys/mutex.h> 74 #include <sys/sysctl.h> 75 #include <sys/malloc.h> 76 #include <sys/conf.h> 77 #include <sys/fcntl.h> 78 #include <sys/file.h> 79 #include <sys/selinfo.h> 80 #include <sys/poll.h> 81 82 #include <dev/hid/hid.h> 83 84 #include <dev/usb/usb.h> 85 #include <dev/usb/usbdi.h> 86 #include <dev/usb/usbdi_util.h> 87 #include <dev/usb/usbhid.h> 88 89 #include "usbdevs.h" 90 91 #define USB_DEBUG_VAR atp_debug 92 #include <dev/usb/usb_debug.h> 93 94 #include <sys/mouse.h> 95 96 #define ATP_DRIVER_NAME "atp" 97 98 /* 99 * Driver specific options: the following options may be set by 100 * `options' statements in the kernel configuration file. 101 */ 102 103 /* The divisor used to translate sensor reported positions to mickeys. */ 104 #ifndef ATP_SCALE_FACTOR 105 #define ATP_SCALE_FACTOR 16 106 #endif 107 108 /* Threshold for small movement noise (in mickeys) */ 109 #ifndef ATP_SMALL_MOVEMENT_THRESHOLD 110 #define ATP_SMALL_MOVEMENT_THRESHOLD 30 111 #endif 112 113 /* Threshold of instantaneous deltas beyond which movement is considered fast.*/ 114 #ifndef ATP_FAST_MOVEMENT_TRESHOLD 115 #define ATP_FAST_MOVEMENT_TRESHOLD 150 116 #endif 117 118 /* 119 * This is the age in microseconds beyond which a touch is considered 120 * to be a slide; and therefore a tap event isn't registered. 121 */ 122 #ifndef ATP_TOUCH_TIMEOUT 123 #define ATP_TOUCH_TIMEOUT 125000 124 #endif 125 126 #ifndef ATP_IDLENESS_THRESHOLD 127 #define ATP_IDLENESS_THRESHOLD 10 128 #endif 129 130 #ifndef FG_SENSOR_NOISE_THRESHOLD 131 #define FG_SENSOR_NOISE_THRESHOLD 2 132 #endif 133 134 /* 135 * A double-tap followed by a single-finger slide is treated as a 136 * special gesture. The driver responds to this gesture by assuming a 137 * virtual button-press for the lifetime of the slide. The following 138 * threshold is the maximum time gap (in microseconds) between the two 139 * tap events preceding the slide for such a gesture. 140 */ 141 #ifndef ATP_DOUBLE_TAP_N_DRAG_THRESHOLD 142 #define ATP_DOUBLE_TAP_N_DRAG_THRESHOLD 200000 143 #endif 144 145 /* 146 * The wait duration in ticks after losing a touch contact before 147 * zombied strokes are reaped and turned into button events. 148 */ 149 #define ATP_ZOMBIE_STROKE_REAP_INTERVAL (hz / 20) /* 50 ms */ 150 151 /* The multiplier used to translate sensor reported positions to mickeys. */ 152 #define FG_SCALE_FACTOR 380 153 154 /* 155 * The movement threshold for a stroke; this is the maximum difference 156 * in position which will be resolved as a continuation of a stroke 157 * component. 158 */ 159 #define FG_MAX_DELTA_MICKEYS ((3 * (FG_SCALE_FACTOR)) >> 1) 160 161 /* Distance-squared threshold for matching a finger with a known stroke */ 162 #ifndef WSP_MAX_ALLOWED_MATCH_DISTANCE_SQ 163 #define WSP_MAX_ALLOWED_MATCH_DISTANCE_SQ 1000000 164 #endif 165 166 /* Ignore pressure spans with cumulative press. below this value. */ 167 #define FG_PSPAN_MIN_CUM_PRESSURE 10 168 169 /* Maximum allowed width for pressure-spans.*/ 170 #define FG_PSPAN_MAX_WIDTH 4 171 172 /* end of driver specific options */ 173 174 /* Tunables */ 175 static SYSCTL_NODE(_hw_usb, OID_AUTO, atp, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 176 "USB ATP"); 177 178 #ifdef USB_DEBUG 179 enum atp_log_level { 180 ATP_LLEVEL_DISABLED = 0, 181 ATP_LLEVEL_ERROR, 182 ATP_LLEVEL_DEBUG, /* for troubleshooting */ 183 ATP_LLEVEL_INFO, /* for diagnostics */ 184 }; 185 static int atp_debug = ATP_LLEVEL_ERROR; /* the default is to only log errors */ 186 SYSCTL_INT(_hw_usb_atp, OID_AUTO, debug, CTLFLAG_RWTUN, 187 &atp_debug, ATP_LLEVEL_ERROR, "ATP debug level"); 188 #endif /* USB_DEBUG */ 189 190 static u_int atp_touch_timeout = ATP_TOUCH_TIMEOUT; 191 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, touch_timeout, CTLFLAG_RWTUN, 192 &atp_touch_timeout, 125000, "age threshold in microseconds for a touch"); 193 194 static u_int atp_double_tap_threshold = ATP_DOUBLE_TAP_N_DRAG_THRESHOLD; 195 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, double_tap_threshold, CTLFLAG_RWTUN, 196 &atp_double_tap_threshold, ATP_DOUBLE_TAP_N_DRAG_THRESHOLD, 197 "maximum time in microseconds to allow association between a double-tap and " 198 "drag gesture"); 199 200 static u_int atp_mickeys_scale_factor = ATP_SCALE_FACTOR; 201 static int atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS); 202 SYSCTL_PROC(_hw_usb_atp, OID_AUTO, scale_factor, 203 CTLTYPE_UINT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 204 &atp_mickeys_scale_factor, sizeof(atp_mickeys_scale_factor), 205 atp_sysctl_scale_factor_handler, "IU", 206 "movement scale factor"); 207 208 static u_int atp_small_movement_threshold = ATP_SMALL_MOVEMENT_THRESHOLD; 209 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, small_movement, CTLFLAG_RWTUN, 210 &atp_small_movement_threshold, ATP_SMALL_MOVEMENT_THRESHOLD, 211 "the small movement black-hole for filtering noise"); 212 213 static u_int atp_tap_minimum = 1; 214 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, tap_minimum, CTLFLAG_RWTUN, 215 &atp_tap_minimum, 1, "Minimum number of taps before detection"); 216 217 /* 218 * Strokes which accumulate at least this amount of absolute movement 219 * from the aggregate of their components are considered as 220 * slides. Unit: mickeys. 221 */ 222 static u_int atp_slide_min_movement = 2 * ATP_SMALL_MOVEMENT_THRESHOLD; 223 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, slide_min_movement, CTLFLAG_RWTUN, 224 &atp_slide_min_movement, 2 * ATP_SMALL_MOVEMENT_THRESHOLD, 225 "strokes with at least this amt. of movement are considered slides"); 226 227 /* 228 * The minimum age of a stroke for it to be considered mature; this 229 * helps filter movements (noise) from immature strokes. Units: interrupts. 230 */ 231 static u_int atp_stroke_maturity_threshold = 4; 232 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, stroke_maturity_threshold, CTLFLAG_RWTUN, 233 &atp_stroke_maturity_threshold, 4, 234 "the minimum age of a stroke for it to be considered mature"); 235 236 typedef enum atp_trackpad_family { 237 TRACKPAD_FAMILY_FOUNTAIN_GEYSER, 238 TRACKPAD_FAMILY_WELLSPRING, 239 TRACKPAD_FAMILY_MAX /* keep this at the tail end of the enumeration */ 240 } trackpad_family_t; 241 242 enum fountain_geyser_product { 243 FOUNTAIN, 244 GEYSER1, 245 GEYSER1_17inch, 246 GEYSER2, 247 GEYSER3, 248 GEYSER4, 249 FOUNTAIN_GEYSER_PRODUCT_MAX /* keep this at the end */ 250 }; 251 252 enum wellspring_product { 253 WELLSPRING1, 254 WELLSPRING2, 255 WELLSPRING3, 256 WELLSPRING4, 257 WELLSPRING4A, 258 WELLSPRING5, 259 WELLSPRING6A, 260 WELLSPRING6, 261 WELLSPRING5A, 262 WELLSPRING7, 263 WELLSPRING7A, 264 WELLSPRING8, 265 WELLSPRING_PRODUCT_MAX /* keep this at the end of the enumeration */ 266 }; 267 268 /* trackpad header types */ 269 enum fountain_geyser_trackpad_type { 270 FG_TRACKPAD_TYPE_GEYSER1, 271 FG_TRACKPAD_TYPE_GEYSER2, 272 FG_TRACKPAD_TYPE_GEYSER3, 273 FG_TRACKPAD_TYPE_GEYSER4, 274 }; 275 enum wellspring_trackpad_type { 276 WSP_TRACKPAD_TYPE1, /* plain trackpad */ 277 WSP_TRACKPAD_TYPE2, /* button integrated in trackpad */ 278 WSP_TRACKPAD_TYPE3 /* additional header fields since June 2013 */ 279 }; 280 281 /* 282 * Trackpad family and product and family are encoded together in the 283 * driver_info value associated with a trackpad product. 284 */ 285 #define N_PROD_BITS 8 /* Number of bits used to encode product */ 286 #define ENCODE_DRIVER_INFO(FAMILY, PROD) \ 287 (((FAMILY) << N_PROD_BITS) | (PROD)) 288 #define DECODE_FAMILY_FROM_DRIVER_INFO(INFO) ((INFO) >> N_PROD_BITS) 289 #define DECODE_PRODUCT_FROM_DRIVER_INFO(INFO) \ 290 ((INFO) & ((1 << N_PROD_BITS) - 1)) 291 292 #define FG_DRIVER_INFO(PRODUCT) \ 293 ENCODE_DRIVER_INFO(TRACKPAD_FAMILY_FOUNTAIN_GEYSER, PRODUCT) 294 #define WELLSPRING_DRIVER_INFO(PRODUCT) \ 295 ENCODE_DRIVER_INFO(TRACKPAD_FAMILY_WELLSPRING, PRODUCT) 296 297 /* 298 * The following structure captures the state of a pressure span along 299 * an axis. Each contact with the touchpad results in separate 300 * pressure spans along the two axes. 301 */ 302 typedef struct fg_pspan { 303 u_int width; /* in units of sensors */ 304 u_int cum; /* cumulative compression (from all sensors) */ 305 u_int cog; /* center of gravity */ 306 u_int loc; /* location (scaled using the mickeys factor) */ 307 boolean_t matched; /* to track pspans as they match against strokes. */ 308 } fg_pspan; 309 310 #define FG_MAX_PSPANS_PER_AXIS 3 311 #define FG_MAX_STROKES (2 * FG_MAX_PSPANS_PER_AXIS) 312 313 #define WELLSPRING_INTERFACE_INDEX 1 314 315 /* trackpad finger data offsets, le16-aligned */ 316 #define WSP_TYPE1_FINGER_DATA_OFFSET (13 * 2) 317 #define WSP_TYPE2_FINGER_DATA_OFFSET (15 * 2) 318 #define WSP_TYPE3_FINGER_DATA_OFFSET (19 * 2) 319 320 /* trackpad button data offsets */ 321 #define WSP_TYPE2_BUTTON_DATA_OFFSET 15 322 #define WSP_TYPE3_BUTTON_DATA_OFFSET 23 323 324 /* list of device capability bits */ 325 #define HAS_INTEGRATED_BUTTON 1 326 327 /* trackpad finger structure - little endian */ 328 struct wsp_finger_sensor_data { 329 int16_t origin; /* zero when switching track finger */ 330 int16_t abs_x; /* absolute x coordinate */ 331 int16_t abs_y; /* absolute y coordinate */ 332 int16_t rel_x; /* relative x coordinate */ 333 int16_t rel_y; /* relative y coordinate */ 334 int16_t tool_major; /* tool area, major axis */ 335 int16_t tool_minor; /* tool area, minor axis */ 336 int16_t orientation; /* 16384 when point, else 15 bit angle */ 337 int16_t touch_major; /* touch area, major axis */ 338 int16_t touch_minor; /* touch area, minor axis */ 339 int16_t unused[3]; /* zeros */ 340 int16_t multi; /* one finger: varies, more fingers: constant */ 341 } __packed; 342 343 typedef struct wsp_finger { 344 /* to track fingers as they match against strokes. */ 345 boolean_t matched; 346 347 /* location (scaled using the mickeys factor) */ 348 int x; 349 int y; 350 } wsp_finger_t; 351 352 #define WSP_MAX_FINGERS 16 353 #define WSP_SIZEOF_FINGER_SENSOR_DATA sizeof(struct wsp_finger_sensor_data) 354 #define WSP_SIZEOF_ALL_FINGER_DATA (WSP_MAX_FINGERS * \ 355 WSP_SIZEOF_FINGER_SENSOR_DATA) 356 #define WSP_MAX_FINGER_ORIENTATION 16384 357 358 #define ATP_SENSOR_DATA_BUF_MAX 1024 359 #if (ATP_SENSOR_DATA_BUF_MAX < ((WSP_MAX_FINGERS * 14 * 2) + \ 360 WSP_TYPE3_FINGER_DATA_OFFSET)) 361 /* note: 14 * 2 in the above is based on sizeof(struct wsp_finger_sensor_data)*/ 362 #error "ATP_SENSOR_DATA_BUF_MAX is too small" 363 #endif 364 365 #define ATP_MAX_STROKES MAX(WSP_MAX_FINGERS, FG_MAX_STROKES) 366 367 #define FG_MAX_XSENSORS 26 368 #define FG_MAX_YSENSORS 16 369 370 /* device-specific configuration */ 371 struct fg_dev_params { 372 u_int data_len; /* for sensor data */ 373 u_int n_xsensors; 374 u_int n_ysensors; 375 enum fountain_geyser_trackpad_type prot; 376 }; 377 struct wsp_dev_params { 378 uint8_t caps; /* device capability bitmask */ 379 uint8_t tp_type; /* type of trackpad interface */ 380 uint8_t finger_data_offset; /* offset to trackpad finger data */ 381 }; 382 383 static const struct fg_dev_params fg_dev_params[FOUNTAIN_GEYSER_PRODUCT_MAX] = { 384 [FOUNTAIN] = { 385 .data_len = 81, 386 .n_xsensors = 16, 387 .n_ysensors = 16, 388 .prot = FG_TRACKPAD_TYPE_GEYSER1 389 }, 390 [GEYSER1] = { 391 .data_len = 81, 392 .n_xsensors = 16, 393 .n_ysensors = 16, 394 .prot = FG_TRACKPAD_TYPE_GEYSER1 395 }, 396 [GEYSER1_17inch] = { 397 .data_len = 81, 398 .n_xsensors = 26, 399 .n_ysensors = 16, 400 .prot = FG_TRACKPAD_TYPE_GEYSER1 401 }, 402 [GEYSER2] = { 403 .data_len = 64, 404 .n_xsensors = 15, 405 .n_ysensors = 9, 406 .prot = FG_TRACKPAD_TYPE_GEYSER2 407 }, 408 [GEYSER3] = { 409 .data_len = 64, 410 .n_xsensors = 20, 411 .n_ysensors = 10, 412 .prot = FG_TRACKPAD_TYPE_GEYSER3 413 }, 414 [GEYSER4] = { 415 .data_len = 64, 416 .n_xsensors = 20, 417 .n_ysensors = 10, 418 .prot = FG_TRACKPAD_TYPE_GEYSER4 419 } 420 }; 421 422 static const STRUCT_USB_HOST_ID fg_devs[] = { 423 /* PowerBooks Feb 2005, iBooks G4 */ 424 { USB_VPI(USB_VENDOR_APPLE, 0x020e, FG_DRIVER_INFO(FOUNTAIN)) }, 425 { USB_VPI(USB_VENDOR_APPLE, 0x020f, FG_DRIVER_INFO(FOUNTAIN)) }, 426 { USB_VPI(USB_VENDOR_APPLE, 0x0210, FG_DRIVER_INFO(FOUNTAIN)) }, 427 { USB_VPI(USB_VENDOR_APPLE, 0x030a, FG_DRIVER_INFO(FOUNTAIN)) }, 428 { USB_VPI(USB_VENDOR_APPLE, 0x030b, FG_DRIVER_INFO(GEYSER1)) }, 429 430 /* PowerBooks Oct 2005 */ 431 { USB_VPI(USB_VENDOR_APPLE, 0x0214, FG_DRIVER_INFO(GEYSER2)) }, 432 { USB_VPI(USB_VENDOR_APPLE, 0x0215, FG_DRIVER_INFO(GEYSER2)) }, 433 { USB_VPI(USB_VENDOR_APPLE, 0x0216, FG_DRIVER_INFO(GEYSER2)) }, 434 435 /* Core Duo MacBook & MacBook Pro */ 436 { USB_VPI(USB_VENDOR_APPLE, 0x0217, FG_DRIVER_INFO(GEYSER3)) }, 437 { USB_VPI(USB_VENDOR_APPLE, 0x0218, FG_DRIVER_INFO(GEYSER3)) }, 438 { USB_VPI(USB_VENDOR_APPLE, 0x0219, FG_DRIVER_INFO(GEYSER3)) }, 439 440 /* Core2 Duo MacBook & MacBook Pro */ 441 { USB_VPI(USB_VENDOR_APPLE, 0x021a, FG_DRIVER_INFO(GEYSER4)) }, 442 { USB_VPI(USB_VENDOR_APPLE, 0x021b, FG_DRIVER_INFO(GEYSER4)) }, 443 { USB_VPI(USB_VENDOR_APPLE, 0x021c, FG_DRIVER_INFO(GEYSER4)) }, 444 445 /* Core2 Duo MacBook3,1 */ 446 { USB_VPI(USB_VENDOR_APPLE, 0x0229, FG_DRIVER_INFO(GEYSER4)) }, 447 { USB_VPI(USB_VENDOR_APPLE, 0x022a, FG_DRIVER_INFO(GEYSER4)) }, 448 { USB_VPI(USB_VENDOR_APPLE, 0x022b, FG_DRIVER_INFO(GEYSER4)) }, 449 450 /* 17 inch PowerBook */ 451 { USB_VPI(USB_VENDOR_APPLE, 0x020d, FG_DRIVER_INFO(GEYSER1_17inch)) }, 452 }; 453 454 static const struct wsp_dev_params wsp_dev_params[WELLSPRING_PRODUCT_MAX] = { 455 [WELLSPRING1] = { 456 .caps = 0, 457 .tp_type = WSP_TRACKPAD_TYPE1, 458 .finger_data_offset = WSP_TYPE1_FINGER_DATA_OFFSET, 459 }, 460 [WELLSPRING2] = { 461 .caps = 0, 462 .tp_type = WSP_TRACKPAD_TYPE1, 463 .finger_data_offset = WSP_TYPE1_FINGER_DATA_OFFSET, 464 }, 465 [WELLSPRING3] = { 466 .caps = HAS_INTEGRATED_BUTTON, 467 .tp_type = WSP_TRACKPAD_TYPE2, 468 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 469 }, 470 [WELLSPRING4] = { 471 .caps = HAS_INTEGRATED_BUTTON, 472 .tp_type = WSP_TRACKPAD_TYPE2, 473 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 474 }, 475 [WELLSPRING4A] = { 476 .caps = HAS_INTEGRATED_BUTTON, 477 .tp_type = WSP_TRACKPAD_TYPE2, 478 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 479 }, 480 [WELLSPRING5] = { 481 .caps = HAS_INTEGRATED_BUTTON, 482 .tp_type = WSP_TRACKPAD_TYPE2, 483 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 484 }, 485 [WELLSPRING6] = { 486 .caps = HAS_INTEGRATED_BUTTON, 487 .tp_type = WSP_TRACKPAD_TYPE2, 488 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 489 }, 490 [WELLSPRING5A] = { 491 .caps = HAS_INTEGRATED_BUTTON, 492 .tp_type = WSP_TRACKPAD_TYPE2, 493 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 494 }, 495 [WELLSPRING6A] = { 496 .caps = HAS_INTEGRATED_BUTTON, 497 .tp_type = WSP_TRACKPAD_TYPE2, 498 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 499 }, 500 [WELLSPRING7] = { 501 .caps = HAS_INTEGRATED_BUTTON, 502 .tp_type = WSP_TRACKPAD_TYPE2, 503 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 504 }, 505 [WELLSPRING7A] = { 506 .caps = HAS_INTEGRATED_BUTTON, 507 .tp_type = WSP_TRACKPAD_TYPE2, 508 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET, 509 }, 510 [WELLSPRING8] = { 511 .caps = HAS_INTEGRATED_BUTTON, 512 .tp_type = WSP_TRACKPAD_TYPE3, 513 .finger_data_offset = WSP_TYPE3_FINGER_DATA_OFFSET, 514 }, 515 }; 516 #define ATP_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) } 517 518 /* TODO: STRUCT_USB_HOST_ID */ 519 static const struct usb_device_id wsp_devs[] = { 520 /* MacbookAir1.1 */ 521 ATP_DEV(APPLE, WELLSPRING_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING1)), 522 ATP_DEV(APPLE, WELLSPRING_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING1)), 523 ATP_DEV(APPLE, WELLSPRING_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING1)), 524 525 /* MacbookProPenryn, aka wellspring2 */ 526 ATP_DEV(APPLE, WELLSPRING2_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING2)), 527 ATP_DEV(APPLE, WELLSPRING2_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING2)), 528 ATP_DEV(APPLE, WELLSPRING2_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING2)), 529 530 /* Macbook5,1 (unibody), aka wellspring3 */ 531 ATP_DEV(APPLE, WELLSPRING3_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING3)), 532 ATP_DEV(APPLE, WELLSPRING3_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING3)), 533 ATP_DEV(APPLE, WELLSPRING3_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING3)), 534 535 /* MacbookAir3,2 (unibody), aka wellspring4 */ 536 ATP_DEV(APPLE, WELLSPRING4_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING4)), 537 ATP_DEV(APPLE, WELLSPRING4_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING4)), 538 ATP_DEV(APPLE, WELLSPRING4_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING4)), 539 540 /* MacbookAir3,1 (unibody), aka wellspring4 */ 541 ATP_DEV(APPLE, WELLSPRING4A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING4A)), 542 ATP_DEV(APPLE, WELLSPRING4A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING4A)), 543 ATP_DEV(APPLE, WELLSPRING4A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING4A)), 544 545 /* Macbook8 (unibody, March 2011) */ 546 ATP_DEV(APPLE, WELLSPRING5_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING5)), 547 ATP_DEV(APPLE, WELLSPRING5_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING5)), 548 ATP_DEV(APPLE, WELLSPRING5_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING5)), 549 550 /* MacbookAir4,1 (unibody, July 2011) */ 551 ATP_DEV(APPLE, WELLSPRING6A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING6A)), 552 ATP_DEV(APPLE, WELLSPRING6A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING6A)), 553 ATP_DEV(APPLE, WELLSPRING6A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING6A)), 554 555 /* MacbookAir4,2 (unibody, July 2011) */ 556 ATP_DEV(APPLE, WELLSPRING6_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING6)), 557 ATP_DEV(APPLE, WELLSPRING6_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING6)), 558 ATP_DEV(APPLE, WELLSPRING6_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING6)), 559 560 /* Macbook8,2 (unibody) */ 561 ATP_DEV(APPLE, WELLSPRING5A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING5A)), 562 ATP_DEV(APPLE, WELLSPRING5A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING5A)), 563 ATP_DEV(APPLE, WELLSPRING5A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING5A)), 564 565 /* MacbookPro10,1 (unibody, June 2012) */ 566 /* MacbookPro11,? (unibody, June 2013) */ 567 ATP_DEV(APPLE, WELLSPRING7_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING7)), 568 ATP_DEV(APPLE, WELLSPRING7_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING7)), 569 ATP_DEV(APPLE, WELLSPRING7_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING7)), 570 571 /* MacbookPro10,2 (unibody, October 2012) */ 572 ATP_DEV(APPLE, WELLSPRING7A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING7A)), 573 ATP_DEV(APPLE, WELLSPRING7A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING7A)), 574 ATP_DEV(APPLE, WELLSPRING7A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING7A)), 575 576 /* MacbookAir6,2 (unibody, June 2013) */ 577 ATP_DEV(APPLE, WELLSPRING8_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING8)), 578 ATP_DEV(APPLE, WELLSPRING8_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING8)), 579 ATP_DEV(APPLE, WELLSPRING8_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING8)), 580 }; 581 582 typedef enum atp_stroke_type { 583 ATP_STROKE_TOUCH, 584 ATP_STROKE_SLIDE, 585 } atp_stroke_type; 586 587 typedef enum atp_axis { 588 X = 0, 589 Y = 1, 590 NUM_AXES 591 } atp_axis; 592 593 #define ATP_FIFO_BUF_SIZE 8 /* bytes */ 594 #define ATP_FIFO_QUEUE_MAXLEN 50 /* units */ 595 596 enum { 597 ATP_INTR_DT, 598 ATP_RESET, 599 ATP_N_TRANSFER, 600 }; 601 602 typedef struct fg_stroke_component { 603 /* Fields encapsulating the pressure-span. */ 604 u_int loc; /* location (scaled) */ 605 u_int cum_pressure; /* cumulative compression */ 606 u_int max_cum_pressure; /* max cumulative compression */ 607 boolean_t matched; /*to track components as they match against pspans.*/ 608 609 int delta_mickeys; /* change in location (un-smoothened movement)*/ 610 } fg_stroke_component_t; 611 612 /* 613 * The following structure captures a finger contact with the 614 * touchpad. A stroke comprises two p-span components and some state. 615 */ 616 typedef struct atp_stroke { 617 TAILQ_ENTRY(atp_stroke) entry; 618 619 atp_stroke_type type; 620 uint32_t flags; /* the state of this stroke */ 621 #define ATSF_ZOMBIE 0x1 622 boolean_t matched; /* to track match against fingers.*/ 623 624 struct timeval ctime; /* create time; for coincident siblings. */ 625 626 /* 627 * Unit: interrupts; we maintain this value in 628 * addition to 'ctime' in order to avoid the 629 * expensive call to microtime() at every 630 * interrupt. 631 */ 632 uint32_t age; 633 634 /* Location */ 635 int x; 636 int y; 637 638 /* Fields containing information about movement. */ 639 int instantaneous_dx; /* curr. change in X location (un-smoothened) */ 640 int instantaneous_dy; /* curr. change in Y location (un-smoothened) */ 641 int pending_dx; /* cum. of pending short movements */ 642 int pending_dy; /* cum. of pending short movements */ 643 int movement_dx; /* interpreted smoothened movement */ 644 int movement_dy; /* interpreted smoothened movement */ 645 int cum_movement_x; /* cum. horizontal movement */ 646 int cum_movement_y; /* cum. vertical movement */ 647 648 /* 649 * The following member is relevant only for fountain-geyser trackpads. 650 * For these, there is the need to track pressure-spans and cumulative 651 * pressures for stroke components. 652 */ 653 fg_stroke_component_t components[NUM_AXES]; 654 } atp_stroke_t; 655 656 struct atp_softc; /* forward declaration */ 657 typedef void (*sensor_data_interpreter_t)(struct atp_softc *sc, u_int len); 658 659 struct atp_softc { 660 device_t sc_dev; 661 struct usb_device *sc_usb_device; 662 struct mtx sc_mutex; /* for synchronization */ 663 struct usb_fifo_sc sc_fifo; 664 665 #define MODE_LENGTH 8 666 char sc_mode_bytes[MODE_LENGTH]; /* device mode */ 667 668 trackpad_family_t sc_family; 669 const void *sc_params; /* device configuration */ 670 sensor_data_interpreter_t sensor_data_interpreter; 671 672 mousehw_t sc_hw; 673 mousemode_t sc_mode; 674 mousestatus_t sc_status; 675 676 u_int sc_state; 677 #define ATP_ENABLED 0x01 678 #define ATP_ZOMBIES_EXIST 0x02 679 #define ATP_DOUBLE_TAP_DRAG 0x04 680 #define ATP_VALID 0x08 681 682 struct usb_xfer *sc_xfer[ATP_N_TRANSFER]; 683 684 u_int sc_pollrate; 685 int sc_fflags; 686 687 atp_stroke_t sc_strokes_data[ATP_MAX_STROKES]; 688 TAILQ_HEAD(,atp_stroke) sc_stroke_free; 689 TAILQ_HEAD(,atp_stroke) sc_stroke_used; 690 u_int sc_n_strokes; 691 692 struct callout sc_callout; 693 694 /* 695 * button status. Set to non-zero if the mouse-button is physically 696 * pressed. This state variable is exposed through softc to allow 697 * reap_sibling_zombies to avoid registering taps while the trackpad 698 * button is pressed. 699 */ 700 uint8_t sc_ibtn; 701 702 /* 703 * Time when touch zombies were last reaped; useful for detecting 704 * double-touch-n-drag. 705 */ 706 struct timeval sc_touch_reap_time; 707 708 u_int sc_idlecount; 709 710 /* Regarding the data transferred from t-pad in USB INTR packets. */ 711 u_int sc_expected_sensor_data_len; 712 uint8_t sc_sensor_data[ATP_SENSOR_DATA_BUF_MAX] __aligned(4); 713 714 int sc_cur_x[FG_MAX_XSENSORS]; /* current sensor readings */ 715 int sc_cur_y[FG_MAX_YSENSORS]; 716 int sc_base_x[FG_MAX_XSENSORS]; /* base sensor readings */ 717 int sc_base_y[FG_MAX_YSENSORS]; 718 int sc_pressure_x[FG_MAX_XSENSORS]; /* computed pressures */ 719 int sc_pressure_y[FG_MAX_YSENSORS]; 720 fg_pspan sc_pspans_x[FG_MAX_PSPANS_PER_AXIS]; 721 fg_pspan sc_pspans_y[FG_MAX_PSPANS_PER_AXIS]; 722 }; 723 724 /* 725 * The last byte of the fountain-geyser sensor data contains status bits; the 726 * following values define the meanings of these bits. 727 * (only Geyser 3/4) 728 */ 729 enum geyser34_status_bits { 730 FG_STATUS_BUTTON = (uint8_t)0x01, /* The button was pressed */ 731 FG_STATUS_BASE_UPDATE = (uint8_t)0x04, /* Data from an untouched pad.*/ 732 }; 733 734 typedef enum interface_mode { 735 RAW_SENSOR_MODE = (uint8_t)0x01, 736 HID_MODE = (uint8_t)0x08 737 } interface_mode; 738 739 /* 740 * function prototypes 741 */ 742 static usb_fifo_cmd_t atp_start_read; 743 static usb_fifo_cmd_t atp_stop_read; 744 static usb_fifo_open_t atp_open; 745 static usb_fifo_close_t atp_close; 746 static usb_fifo_ioctl_t atp_ioctl; 747 748 static struct usb_fifo_methods atp_fifo_methods = { 749 .f_open = &atp_open, 750 .f_close = &atp_close, 751 .f_ioctl = &atp_ioctl, 752 .f_start_read = &atp_start_read, 753 .f_stop_read = &atp_stop_read, 754 .basename[0] = ATP_DRIVER_NAME, 755 }; 756 757 /* device initialization and shutdown */ 758 static usb_error_t atp_set_device_mode(struct atp_softc *, interface_mode); 759 static void atp_reset_callback(struct usb_xfer *, usb_error_t); 760 static int atp_enable(struct atp_softc *); 761 static void atp_disable(struct atp_softc *); 762 763 /* sensor interpretation */ 764 static void fg_interpret_sensor_data(struct atp_softc *, u_int); 765 static void fg_extract_sensor_data(const int8_t *, u_int, atp_axis, 766 int *, enum fountain_geyser_trackpad_type); 767 static void fg_get_pressures(int *, const int *, const int *, int); 768 static void fg_detect_pspans(int *, u_int, u_int, fg_pspan *, u_int *); 769 static void wsp_interpret_sensor_data(struct atp_softc *, u_int); 770 771 /* movement detection */ 772 static boolean_t fg_match_stroke_component(fg_stroke_component_t *, 773 const fg_pspan *, atp_stroke_type); 774 static void fg_match_strokes_against_pspans(struct atp_softc *, 775 atp_axis, fg_pspan *, u_int, u_int); 776 static boolean_t wsp_match_strokes_against_fingers(struct atp_softc *, 777 wsp_finger_t *, u_int); 778 static boolean_t fg_update_strokes(struct atp_softc *, fg_pspan *, u_int, 779 fg_pspan *, u_int); 780 static boolean_t wsp_update_strokes(struct atp_softc *, 781 wsp_finger_t [WSP_MAX_FINGERS], u_int); 782 static void fg_add_stroke(struct atp_softc *, const fg_pspan *, const fg_pspan *); 783 static void fg_add_new_strokes(struct atp_softc *, fg_pspan *, 784 u_int, fg_pspan *, u_int); 785 static void wsp_add_stroke(struct atp_softc *, const wsp_finger_t *); 786 static void atp_advance_stroke_state(struct atp_softc *, 787 atp_stroke_t *, boolean_t *); 788 static boolean_t atp_stroke_has_small_movement(const atp_stroke_t *); 789 static void atp_update_pending_mickeys(atp_stroke_t *); 790 static boolean_t atp_compute_stroke_movement(atp_stroke_t *); 791 static void atp_terminate_stroke(struct atp_softc *, atp_stroke_t *); 792 793 /* tap detection */ 794 static boolean_t atp_is_horizontal_scroll(const atp_stroke_t *); 795 static boolean_t atp_is_vertical_scroll(const atp_stroke_t *); 796 static void atp_reap_sibling_zombies(void *); 797 static void atp_convert_to_slide(struct atp_softc *, atp_stroke_t *); 798 799 /* updating fifo */ 800 static void atp_reset_buf(struct atp_softc *); 801 static void atp_add_to_queue(struct atp_softc *, int, int, int, uint32_t); 802 803 /* Device methods. */ 804 static device_probe_t atp_probe; 805 static device_attach_t atp_attach; 806 static device_detach_t atp_detach; 807 static usb_callback_t atp_intr; 808 809 static const struct usb_config atp_xfer_config[ATP_N_TRANSFER] = { 810 [ATP_INTR_DT] = { 811 .type = UE_INTERRUPT, 812 .endpoint = UE_ADDR_ANY, 813 .direction = UE_DIR_IN, 814 .flags = { 815 .pipe_bof = 1, /* block pipe on failure */ 816 .short_xfer_ok = 1, 817 }, 818 .bufsize = ATP_SENSOR_DATA_BUF_MAX, 819 .callback = &atp_intr, 820 }, 821 [ATP_RESET] = { 822 .type = UE_CONTROL, 823 .endpoint = 0, /* Control pipe */ 824 .direction = UE_DIR_ANY, 825 .bufsize = sizeof(struct usb_device_request) + MODE_LENGTH, 826 .callback = &atp_reset_callback, 827 .interval = 0, /* no pre-delay */ 828 }, 829 }; 830 831 static atp_stroke_t * 832 atp_alloc_stroke(struct atp_softc *sc) 833 { 834 atp_stroke_t *pstroke; 835 836 pstroke = TAILQ_FIRST(&sc->sc_stroke_free); 837 if (pstroke == NULL) 838 goto done; 839 840 TAILQ_REMOVE(&sc->sc_stroke_free, pstroke, entry); 841 memset(pstroke, 0, sizeof(*pstroke)); 842 TAILQ_INSERT_TAIL(&sc->sc_stroke_used, pstroke, entry); 843 844 sc->sc_n_strokes++; 845 done: 846 return (pstroke); 847 } 848 849 static void 850 atp_free_stroke(struct atp_softc *sc, atp_stroke_t *pstroke) 851 { 852 if (pstroke == NULL) 853 return; 854 855 sc->sc_n_strokes--; 856 857 TAILQ_REMOVE(&sc->sc_stroke_used, pstroke, entry); 858 TAILQ_INSERT_TAIL(&sc->sc_stroke_free, pstroke, entry); 859 } 860 861 static void 862 atp_init_stroke_pool(struct atp_softc *sc) 863 { 864 u_int x; 865 866 TAILQ_INIT(&sc->sc_stroke_free); 867 TAILQ_INIT(&sc->sc_stroke_used); 868 869 sc->sc_n_strokes = 0; 870 871 memset(&sc->sc_strokes_data, 0, sizeof(sc->sc_strokes_data)); 872 873 for (x = 0; x != ATP_MAX_STROKES; x++) { 874 TAILQ_INSERT_TAIL(&sc->sc_stroke_free, &sc->sc_strokes_data[x], 875 entry); 876 } 877 } 878 879 static usb_error_t 880 atp_set_device_mode(struct atp_softc *sc, interface_mode newMode) 881 { 882 uint8_t mode_value; 883 usb_error_t err; 884 885 if ((newMode != RAW_SENSOR_MODE) && (newMode != HID_MODE)) 886 return (USB_ERR_INVAL); 887 888 if ((newMode == RAW_SENSOR_MODE) && 889 (sc->sc_family == TRACKPAD_FAMILY_FOUNTAIN_GEYSER)) 890 mode_value = (uint8_t)0x04; 891 else 892 mode_value = newMode; 893 894 err = usbd_req_get_report(sc->sc_usb_device, NULL /* mutex */, 895 sc->sc_mode_bytes, sizeof(sc->sc_mode_bytes), 0 /* interface idx */, 896 0x03 /* type */, 0x00 /* id */); 897 if (err != USB_ERR_NORMAL_COMPLETION) { 898 DPRINTF("Failed to read device mode (%d)\n", err); 899 return (err); 900 } 901 902 if (sc->sc_mode_bytes[0] == mode_value) 903 return (err); 904 905 /* 906 * XXX Need to wait at least 250ms for hardware to get 907 * ready. The device mode handling appears to be handled 908 * asynchronously and we should not issue these commands too 909 * quickly. 910 */ 911 pause("WHW", hz / 4); 912 913 sc->sc_mode_bytes[0] = mode_value; 914 return (usbd_req_set_report(sc->sc_usb_device, NULL /* mutex */, 915 sc->sc_mode_bytes, sizeof(sc->sc_mode_bytes), 0 /* interface idx */, 916 0x03 /* type */, 0x00 /* id */)); 917 } 918 919 static void 920 atp_reset_callback(struct usb_xfer *xfer, usb_error_t error) 921 { 922 usb_device_request_t req; 923 struct usb_page_cache *pc; 924 struct atp_softc *sc = usbd_xfer_softc(xfer); 925 926 uint8_t mode_value; 927 if (sc->sc_family == TRACKPAD_FAMILY_FOUNTAIN_GEYSER) 928 mode_value = 0x04; 929 else 930 mode_value = RAW_SENSOR_MODE; 931 932 switch (USB_GET_STATE(xfer)) { 933 case USB_ST_SETUP: 934 sc->sc_mode_bytes[0] = mode_value; 935 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 936 req.bRequest = UR_SET_REPORT; 937 USETW2(req.wValue, 938 (uint8_t)0x03 /* type */, (uint8_t)0x00 /* id */); 939 USETW(req.wIndex, 0); 940 USETW(req.wLength, MODE_LENGTH); 941 942 pc = usbd_xfer_get_frame(xfer, 0); 943 usbd_copy_in(pc, 0, &req, sizeof(req)); 944 pc = usbd_xfer_get_frame(xfer, 1); 945 usbd_copy_in(pc, 0, sc->sc_mode_bytes, MODE_LENGTH); 946 947 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 948 usbd_xfer_set_frame_len(xfer, 1, MODE_LENGTH); 949 usbd_xfer_set_frames(xfer, 2); 950 usbd_transfer_submit(xfer); 951 break; 952 953 case USB_ST_TRANSFERRED: 954 default: 955 break; 956 } 957 } 958 959 static int 960 atp_enable(struct atp_softc *sc) 961 { 962 if (sc->sc_state & ATP_ENABLED) 963 return (0); 964 965 /* reset status */ 966 memset(&sc->sc_status, 0, sizeof(sc->sc_status)); 967 968 atp_init_stroke_pool(sc); 969 970 sc->sc_state |= ATP_ENABLED; 971 972 DPRINTFN(ATP_LLEVEL_INFO, "enabled atp\n"); 973 return (0); 974 } 975 976 static void 977 atp_disable(struct atp_softc *sc) 978 { 979 sc->sc_state &= ~(ATP_ENABLED | ATP_VALID); 980 DPRINTFN(ATP_LLEVEL_INFO, "disabled atp\n"); 981 } 982 983 static void 984 fg_interpret_sensor_data(struct atp_softc *sc, u_int data_len) 985 { 986 u_int n_xpspans = 0; 987 u_int n_ypspans = 0; 988 uint8_t status_bits; 989 990 const struct fg_dev_params *params = 991 (const struct fg_dev_params *)sc->sc_params; 992 993 fg_extract_sensor_data(sc->sc_sensor_data, params->n_xsensors, X, 994 sc->sc_cur_x, params->prot); 995 fg_extract_sensor_data(sc->sc_sensor_data, params->n_ysensors, Y, 996 sc->sc_cur_y, params->prot); 997 998 /* 999 * If this is the initial update (from an untouched 1000 * pad), we should set the base values for the sensor 1001 * data; deltas with respect to these base values can 1002 * be used as pressure readings subsequently. 1003 */ 1004 status_bits = sc->sc_sensor_data[params->data_len - 1]; 1005 if (((params->prot == FG_TRACKPAD_TYPE_GEYSER3) || 1006 (params->prot == FG_TRACKPAD_TYPE_GEYSER4)) && 1007 ((sc->sc_state & ATP_VALID) == 0)) { 1008 if (status_bits & FG_STATUS_BASE_UPDATE) { 1009 memcpy(sc->sc_base_x, sc->sc_cur_x, 1010 params->n_xsensors * sizeof(*sc->sc_base_x)); 1011 memcpy(sc->sc_base_y, sc->sc_cur_y, 1012 params->n_ysensors * sizeof(*sc->sc_base_y)); 1013 sc->sc_state |= ATP_VALID; 1014 return; 1015 } 1016 } 1017 1018 /* Get pressure readings and detect p-spans for both axes. */ 1019 fg_get_pressures(sc->sc_pressure_x, sc->sc_cur_x, sc->sc_base_x, 1020 params->n_xsensors); 1021 fg_detect_pspans(sc->sc_pressure_x, params->n_xsensors, 1022 FG_MAX_PSPANS_PER_AXIS, sc->sc_pspans_x, &n_xpspans); 1023 fg_get_pressures(sc->sc_pressure_y, sc->sc_cur_y, sc->sc_base_y, 1024 params->n_ysensors); 1025 fg_detect_pspans(sc->sc_pressure_y, params->n_ysensors, 1026 FG_MAX_PSPANS_PER_AXIS, sc->sc_pspans_y, &n_ypspans); 1027 1028 /* Update strokes with new pspans to detect movements. */ 1029 if (fg_update_strokes(sc, sc->sc_pspans_x, n_xpspans, sc->sc_pspans_y, n_ypspans)) 1030 sc->sc_status.flags |= MOUSE_POSCHANGED; 1031 1032 sc->sc_ibtn = (status_bits & FG_STATUS_BUTTON) ? MOUSE_BUTTON1DOWN : 0; 1033 sc->sc_status.button = sc->sc_ibtn; 1034 1035 /* 1036 * The Fountain/Geyser device continues to trigger interrupts 1037 * at a fast rate even after touchpad activity has 1038 * stopped. Upon detecting that the device has remained idle 1039 * beyond a threshold, we reinitialize it to silence the 1040 * interrupts. 1041 */ 1042 if ((sc->sc_status.flags == 0) && (sc->sc_n_strokes == 0)) { 1043 sc->sc_idlecount++; 1044 if (sc->sc_idlecount >= ATP_IDLENESS_THRESHOLD) { 1045 /* 1046 * Use the last frame before we go idle for 1047 * calibration on pads which do not send 1048 * calibration frames. 1049 */ 1050 const struct fg_dev_params *params = 1051 (const struct fg_dev_params *)sc->sc_params; 1052 1053 DPRINTFN(ATP_LLEVEL_INFO, "idle\n"); 1054 1055 if (params->prot < FG_TRACKPAD_TYPE_GEYSER3) { 1056 memcpy(sc->sc_base_x, sc->sc_cur_x, 1057 params->n_xsensors * sizeof(*(sc->sc_base_x))); 1058 memcpy(sc->sc_base_y, sc->sc_cur_y, 1059 params->n_ysensors * sizeof(*(sc->sc_base_y))); 1060 } 1061 1062 sc->sc_idlecount = 0; 1063 usbd_transfer_start(sc->sc_xfer[ATP_RESET]); 1064 } 1065 } else { 1066 sc->sc_idlecount = 0; 1067 } 1068 } 1069 1070 /* 1071 * Interpret the data from the X and Y pressure sensors. This function 1072 * is called separately for the X and Y sensor arrays. The data in the 1073 * USB packet is laid out in the following manner: 1074 * 1075 * sensor_data: 1076 * --,--,Y1,Y2,--,Y3,Y4,--,Y5,...,Y10, ... X1,X2,--,X3,X4 1077 * indices: 0 1 2 3 4 5 6 7 8 ... 15 ... 20 21 22 23 24 1078 * 1079 * '--' (in the above) indicates that the value is unimportant. 1080 * 1081 * Information about the above layout was obtained from the 1082 * implementation of the AppleTouch driver in Linux. 1083 * 1084 * parameters: 1085 * sensor_data 1086 * raw sensor data from the USB packet. 1087 * num 1088 * The number of elements in the array 'arr'. 1089 * axis 1090 * Axis of data to fetch 1091 * arr 1092 * The array to be initialized with the readings. 1093 * prot 1094 * The protocol to use to interpret the data 1095 */ 1096 static void 1097 fg_extract_sensor_data(const int8_t *sensor_data, u_int num, atp_axis axis, 1098 int *arr, enum fountain_geyser_trackpad_type prot) 1099 { 1100 u_int i; 1101 u_int di; /* index into sensor data */ 1102 1103 switch (prot) { 1104 case FG_TRACKPAD_TYPE_GEYSER1: 1105 /* 1106 * For Geyser 1, the sensors are laid out in pairs 1107 * every 5 bytes. 1108 */ 1109 for (i = 0, di = (axis == Y) ? 1 : 2; i < 8; di += 5, i++) { 1110 arr[i] = sensor_data[di]; 1111 arr[i+8] = sensor_data[di+2]; 1112 if ((axis == X) && (num > 16)) 1113 arr[i+16] = sensor_data[di+40]; 1114 } 1115 1116 break; 1117 case FG_TRACKPAD_TYPE_GEYSER2: 1118 for (i = 0, di = (axis == Y) ? 1 : 19; i < num; /* empty */ ) { 1119 arr[i++] = sensor_data[di++]; 1120 arr[i++] = sensor_data[di++]; 1121 di++; 1122 } 1123 break; 1124 case FG_TRACKPAD_TYPE_GEYSER3: 1125 case FG_TRACKPAD_TYPE_GEYSER4: 1126 for (i = 0, di = (axis == Y) ? 2 : 20; i < num; /* empty */ ) { 1127 arr[i++] = sensor_data[di++]; 1128 arr[i++] = sensor_data[di++]; 1129 di++; 1130 } 1131 break; 1132 default: 1133 break; 1134 } 1135 } 1136 1137 static void 1138 fg_get_pressures(int *p, const int *cur, const int *base, int n) 1139 { 1140 int i; 1141 1142 for (i = 0; i < n; i++) { 1143 p[i] = cur[i] - base[i]; 1144 if (p[i] > 127) 1145 p[i] -= 256; 1146 if (p[i] < -127) 1147 p[i] += 256; 1148 if (p[i] < 0) 1149 p[i] = 0; 1150 1151 /* 1152 * Shave off pressures below the noise-pressure 1153 * threshold; this will reduce the contribution from 1154 * lower pressure readings. 1155 */ 1156 if ((u_int)p[i] <= FG_SENSOR_NOISE_THRESHOLD) 1157 p[i] = 0; /* filter away noise */ 1158 else 1159 p[i] -= FG_SENSOR_NOISE_THRESHOLD; 1160 } 1161 } 1162 1163 static void 1164 fg_detect_pspans(int *p, u_int num_sensors, 1165 u_int max_spans, /* max # of pspans permitted */ 1166 fg_pspan *spans, /* finger spans */ 1167 u_int *nspans_p) /* num spans detected */ 1168 { 1169 u_int i; 1170 int maxp; /* max pressure seen within a span */ 1171 u_int num_spans = 0; 1172 1173 enum fg_pspan_state { 1174 ATP_PSPAN_INACTIVE, 1175 ATP_PSPAN_INCREASING, 1176 ATP_PSPAN_DECREASING, 1177 } state; /* state of the pressure span */ 1178 1179 /* 1180 * The following is a simple state machine to track 1181 * the phase of the pressure span. 1182 */ 1183 memset(spans, 0, max_spans * sizeof(fg_pspan)); 1184 maxp = 0; 1185 state = ATP_PSPAN_INACTIVE; 1186 for (i = 0; i < num_sensors; i++) { 1187 if (num_spans >= max_spans) 1188 break; 1189 1190 if (p[i] == 0) { 1191 if (state == ATP_PSPAN_INACTIVE) { 1192 /* 1193 * There is no pressure information for this 1194 * sensor, and we aren't tracking a finger. 1195 */ 1196 continue; 1197 } else { 1198 state = ATP_PSPAN_INACTIVE; 1199 maxp = 0; 1200 num_spans++; 1201 } 1202 } else { 1203 switch (state) { 1204 case ATP_PSPAN_INACTIVE: 1205 state = ATP_PSPAN_INCREASING; 1206 maxp = p[i]; 1207 break; 1208 1209 case ATP_PSPAN_INCREASING: 1210 if (p[i] > maxp) 1211 maxp = p[i]; 1212 else if (p[i] <= (maxp >> 1)) 1213 state = ATP_PSPAN_DECREASING; 1214 break; 1215 1216 case ATP_PSPAN_DECREASING: 1217 if (p[i] > p[i - 1]) { 1218 /* 1219 * This is the beginning of 1220 * another span; change state 1221 * to give the appearance that 1222 * we're starting from an 1223 * inactive span, and then 1224 * re-process this reading in 1225 * the next iteration. 1226 */ 1227 num_spans++; 1228 state = ATP_PSPAN_INACTIVE; 1229 maxp = 0; 1230 i--; 1231 continue; 1232 } 1233 break; 1234 } 1235 1236 /* Update the finger span with this reading. */ 1237 spans[num_spans].width++; 1238 spans[num_spans].cum += p[i]; 1239 spans[num_spans].cog += p[i] * (i + 1); 1240 } 1241 } 1242 if (state != ATP_PSPAN_INACTIVE) 1243 num_spans++; /* close the last finger span */ 1244 1245 /* post-process the spans */ 1246 for (i = 0; i < num_spans; i++) { 1247 /* filter away unwanted pressure spans */ 1248 if ((spans[i].cum < FG_PSPAN_MIN_CUM_PRESSURE) || 1249 (spans[i].width > FG_PSPAN_MAX_WIDTH)) { 1250 if ((i + 1) < num_spans) { 1251 memcpy(&spans[i], &spans[i + 1], 1252 (num_spans - i - 1) * sizeof(fg_pspan)); 1253 i--; 1254 } 1255 num_spans--; 1256 continue; 1257 } 1258 1259 /* compute this span's representative location */ 1260 spans[i].loc = spans[i].cog * FG_SCALE_FACTOR / 1261 spans[i].cum; 1262 1263 spans[i].matched = false; /* not yet matched against a stroke */ 1264 } 1265 1266 *nspans_p = num_spans; 1267 } 1268 1269 static void 1270 wsp_interpret_sensor_data(struct atp_softc *sc, u_int data_len) 1271 { 1272 const struct wsp_dev_params *params = sc->sc_params; 1273 wsp_finger_t fingers[WSP_MAX_FINGERS]; 1274 struct wsp_finger_sensor_data *source_fingerp; 1275 u_int n_source_fingers; 1276 u_int n_fingers; 1277 u_int i; 1278 1279 /* validate sensor data length */ 1280 if ((data_len < params->finger_data_offset) || 1281 ((data_len - params->finger_data_offset) % 1282 WSP_SIZEOF_FINGER_SENSOR_DATA) != 0) 1283 return; 1284 1285 /* compute number of source fingers */ 1286 n_source_fingers = (data_len - params->finger_data_offset) / 1287 WSP_SIZEOF_FINGER_SENSOR_DATA; 1288 1289 if (n_source_fingers > WSP_MAX_FINGERS) 1290 n_source_fingers = WSP_MAX_FINGERS; 1291 1292 /* iterate over the source data collecting useful fingers */ 1293 n_fingers = 0; 1294 source_fingerp = (struct wsp_finger_sensor_data *)(sc->sc_sensor_data + 1295 params->finger_data_offset); 1296 1297 for (i = 0; i < n_source_fingers; i++, source_fingerp++) { 1298 /* swap endianness, if any */ 1299 if (le16toh(0x1234) != 0x1234) { 1300 source_fingerp->origin = le16toh((uint16_t)source_fingerp->origin); 1301 source_fingerp->abs_x = le16toh((uint16_t)source_fingerp->abs_x); 1302 source_fingerp->abs_y = le16toh((uint16_t)source_fingerp->abs_y); 1303 source_fingerp->rel_x = le16toh((uint16_t)source_fingerp->rel_x); 1304 source_fingerp->rel_y = le16toh((uint16_t)source_fingerp->rel_y); 1305 source_fingerp->tool_major = le16toh((uint16_t)source_fingerp->tool_major); 1306 source_fingerp->tool_minor = le16toh((uint16_t)source_fingerp->tool_minor); 1307 source_fingerp->orientation = le16toh((uint16_t)source_fingerp->orientation); 1308 source_fingerp->touch_major = le16toh((uint16_t)source_fingerp->touch_major); 1309 source_fingerp->touch_minor = le16toh((uint16_t)source_fingerp->touch_minor); 1310 source_fingerp->multi = le16toh((uint16_t)source_fingerp->multi); 1311 } 1312 1313 /* check for minium threshold */ 1314 if (source_fingerp->touch_major == 0) 1315 continue; 1316 1317 fingers[n_fingers].matched = false; 1318 fingers[n_fingers].x = source_fingerp->abs_x; 1319 fingers[n_fingers].y = -source_fingerp->abs_y; 1320 1321 n_fingers++; 1322 } 1323 1324 if ((sc->sc_n_strokes == 0) && (n_fingers == 0)) 1325 return; 1326 1327 if (wsp_update_strokes(sc, fingers, n_fingers)) 1328 sc->sc_status.flags |= MOUSE_POSCHANGED; 1329 1330 switch(params->tp_type) { 1331 case WSP_TRACKPAD_TYPE2: 1332 sc->sc_ibtn = sc->sc_sensor_data[WSP_TYPE2_BUTTON_DATA_OFFSET]; 1333 break; 1334 case WSP_TRACKPAD_TYPE3: 1335 sc->sc_ibtn = sc->sc_sensor_data[WSP_TYPE3_BUTTON_DATA_OFFSET]; 1336 break; 1337 default: 1338 break; 1339 } 1340 sc->sc_status.button = sc->sc_ibtn ? MOUSE_BUTTON1DOWN : 0; 1341 } 1342 1343 /* 1344 * Match a pressure-span against a stroke-component. If there is a 1345 * match, update the component's state and return true. 1346 */ 1347 static boolean_t 1348 fg_match_stroke_component(fg_stroke_component_t *component, 1349 const fg_pspan *pspan, atp_stroke_type stroke_type) 1350 { 1351 int delta_mickeys; 1352 u_int min_pressure; 1353 1354 delta_mickeys = pspan->loc - component->loc; 1355 1356 if (abs(delta_mickeys) > (int)FG_MAX_DELTA_MICKEYS) 1357 return (false); /* the finger span is too far out; no match */ 1358 1359 component->loc = pspan->loc; 1360 1361 /* 1362 * A sudden and significant increase in a pspan's cumulative 1363 * pressure indicates the incidence of a new finger 1364 * contact. This usually revises the pspan's 1365 * centre-of-gravity, and hence the location of any/all 1366 * matching stroke component(s). But such a change should 1367 * *not* be interpreted as a movement. 1368 */ 1369 if (pspan->cum > ((3 * component->cum_pressure) >> 1)) 1370 delta_mickeys = 0; 1371 1372 component->cum_pressure = pspan->cum; 1373 if (pspan->cum > component->max_cum_pressure) 1374 component->max_cum_pressure = pspan->cum; 1375 1376 /* 1377 * Disregard the component's movement if its cumulative 1378 * pressure drops below a fraction of the maximum; this 1379 * fraction is determined based on the stroke's type. 1380 */ 1381 if (stroke_type == ATP_STROKE_TOUCH) 1382 min_pressure = (3 * component->max_cum_pressure) >> 2; 1383 else 1384 min_pressure = component->max_cum_pressure >> 2; 1385 if (component->cum_pressure < min_pressure) 1386 delta_mickeys = 0; 1387 1388 component->delta_mickeys = delta_mickeys; 1389 return (true); 1390 } 1391 1392 static void 1393 fg_match_strokes_against_pspans(struct atp_softc *sc, atp_axis axis, 1394 fg_pspan *pspans, u_int n_pspans, u_int repeat_count) 1395 { 1396 atp_stroke_t *strokep; 1397 u_int repeat_index = 0; 1398 u_int i; 1399 1400 /* Determine the index of the multi-span. */ 1401 if (repeat_count) { 1402 for (i = 0; i < n_pspans; i++) { 1403 if (pspans[i].cum > pspans[repeat_index].cum) 1404 repeat_index = i; 1405 } 1406 } 1407 1408 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) { 1409 if (strokep->components[axis].matched) 1410 continue; /* skip matched components */ 1411 1412 for (i = 0; i < n_pspans; i++) { 1413 if (pspans[i].matched) 1414 continue; /* skip matched pspans */ 1415 1416 if (fg_match_stroke_component( 1417 &strokep->components[axis], &pspans[i], 1418 strokep->type)) { 1419 /* There is a match. */ 1420 strokep->components[axis].matched = true; 1421 1422 /* Take care to repeat at the multi-span. */ 1423 if ((repeat_count > 0) && (i == repeat_index)) 1424 repeat_count--; 1425 else 1426 pspans[i].matched = true; 1427 1428 break; /* skip to the next strokep */ 1429 } 1430 } /* loop over pspans */ 1431 } /* loop over strokes */ 1432 } 1433 1434 static boolean_t 1435 wsp_match_strokes_against_fingers(struct atp_softc *sc, 1436 wsp_finger_t *fingers, u_int n_fingers) 1437 { 1438 boolean_t movement = false; 1439 atp_stroke_t *strokep; 1440 u_int i; 1441 1442 /* reset the matched status for all strokes */ 1443 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) 1444 strokep->matched = false; 1445 1446 for (i = 0; i != n_fingers; i++) { 1447 u_int least_distance_sq = WSP_MAX_ALLOWED_MATCH_DISTANCE_SQ; 1448 atp_stroke_t *strokep_best = NULL; 1449 1450 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) { 1451 int instantaneous_dx; 1452 int instantaneous_dy; 1453 u_int d_squared; 1454 1455 if (strokep->matched) 1456 continue; 1457 1458 instantaneous_dx = fingers[i].x - strokep->x; 1459 instantaneous_dy = fingers[i].y - strokep->y; 1460 1461 /* skip strokes which are far away */ 1462 d_squared = 1463 (instantaneous_dx * instantaneous_dx) + 1464 (instantaneous_dy * instantaneous_dy); 1465 1466 if (d_squared < least_distance_sq) { 1467 least_distance_sq = d_squared; 1468 strokep_best = strokep; 1469 } 1470 } 1471 1472 strokep = strokep_best; 1473 1474 if (strokep != NULL) { 1475 fingers[i].matched = true; 1476 1477 strokep->matched = true; 1478 strokep->instantaneous_dx = fingers[i].x - strokep->x; 1479 strokep->instantaneous_dy = fingers[i].y - strokep->y; 1480 strokep->x = fingers[i].x; 1481 strokep->y = fingers[i].y; 1482 1483 atp_advance_stroke_state(sc, strokep, &movement); 1484 } 1485 } 1486 return (movement); 1487 } 1488 1489 /* 1490 * Update strokes by matching against current pressure-spans. 1491 * Return true if any movement is detected. 1492 */ 1493 static boolean_t 1494 fg_update_strokes(struct atp_softc *sc, fg_pspan *pspans_x, 1495 u_int n_xpspans, fg_pspan *pspans_y, u_int n_ypspans) 1496 { 1497 atp_stroke_t *strokep; 1498 atp_stroke_t *strokep_next; 1499 boolean_t movement = false; 1500 u_int repeat_count = 0; 1501 u_int i; 1502 u_int j; 1503 1504 /* Reset X and Y components of all strokes as unmatched. */ 1505 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) { 1506 strokep->components[X].matched = false; 1507 strokep->components[Y].matched = false; 1508 } 1509 1510 /* 1511 * Usually, the X and Y pspans come in pairs (the common case 1512 * being a single pair). It is possible, however, that 1513 * multiple contacts resolve to a single pspan along an 1514 * axis, as illustrated in the following: 1515 * 1516 * F = finger-contact 1517 * 1518 * pspan pspan 1519 * +-----------------------+ 1520 * | . . | 1521 * | . . | 1522 * | . . | 1523 * | . . | 1524 * pspan |.........F......F | 1525 * | | 1526 * | | 1527 * | | 1528 * +-----------------------+ 1529 * 1530 * 1531 * The above case can be detected by a difference in the 1532 * number of X and Y pspans. When this happens, X and Y pspans 1533 * aren't easy to pair or match against strokes. 1534 * 1535 * When X and Y pspans differ in number, the axis with the 1536 * smaller number of pspans is regarded as having a repeating 1537 * pspan (or a multi-pspan)--in the above illustration, the 1538 * Y-axis has a repeating pspan. Our approach is to try to 1539 * match the multi-pspan repeatedly against strokes. The 1540 * difference between the number of X and Y pspans gives us a 1541 * crude repeat_count for matching multi-pspans--i.e. the 1542 * multi-pspan along the Y axis (above) has a repeat_count of 1. 1543 */ 1544 repeat_count = abs(n_xpspans - n_ypspans); 1545 1546 fg_match_strokes_against_pspans(sc, X, pspans_x, n_xpspans, 1547 (((repeat_count != 0) && ((n_xpspans < n_ypspans))) ? 1548 repeat_count : 0)); 1549 fg_match_strokes_against_pspans(sc, Y, pspans_y, n_ypspans, 1550 (((repeat_count != 0) && (n_ypspans < n_xpspans)) ? 1551 repeat_count : 0)); 1552 1553 /* Update the state of strokes based on the above pspan matches. */ 1554 TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) { 1555 if (strokep->components[X].matched && 1556 strokep->components[Y].matched) { 1557 strokep->matched = true; 1558 strokep->instantaneous_dx = 1559 strokep->components[X].delta_mickeys; 1560 strokep->instantaneous_dy = 1561 strokep->components[Y].delta_mickeys; 1562 atp_advance_stroke_state(sc, strokep, &movement); 1563 } else { 1564 /* 1565 * At least one component of this stroke 1566 * didn't match against current pspans; 1567 * terminate it. 1568 */ 1569 atp_terminate_stroke(sc, strokep); 1570 } 1571 } 1572 1573 /* Add new strokes for pairs of unmatched pspans */ 1574 for (i = 0; i < n_xpspans; i++) { 1575 if (pspans_x[i].matched == false) break; 1576 } 1577 for (j = 0; j < n_ypspans; j++) { 1578 if (pspans_y[j].matched == false) break; 1579 } 1580 if ((i < n_xpspans) && (j < n_ypspans)) { 1581 #ifdef USB_DEBUG 1582 if (atp_debug >= ATP_LLEVEL_INFO) { 1583 printf("unmatched pspans:"); 1584 for (; i < n_xpspans; i++) { 1585 if (pspans_x[i].matched) 1586 continue; 1587 printf(" X:[loc:%u,cum:%u]", 1588 pspans_x[i].loc, pspans_x[i].cum); 1589 } 1590 for (; j < n_ypspans; j++) { 1591 if (pspans_y[j].matched) 1592 continue; 1593 printf(" Y:[loc:%u,cum:%u]", 1594 pspans_y[j].loc, pspans_y[j].cum); 1595 } 1596 printf("\n"); 1597 } 1598 #endif /* USB_DEBUG */ 1599 if ((n_xpspans == 1) && (n_ypspans == 1)) 1600 /* The common case of a single pair of new pspans. */ 1601 fg_add_stroke(sc, &pspans_x[0], &pspans_y[0]); 1602 else 1603 fg_add_new_strokes(sc, pspans_x, n_xpspans, 1604 pspans_y, n_ypspans); 1605 } 1606 1607 #ifdef USB_DEBUG 1608 if (atp_debug >= ATP_LLEVEL_INFO) { 1609 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) { 1610 printf(" %s%clc:%u,dm:%d,cum:%d,max:%d,%c" 1611 ",%clc:%u,dm:%d,cum:%d,max:%d,%c", 1612 (strokep->flags & ATSF_ZOMBIE) ? "zomb:" : "", 1613 (strokep->type == ATP_STROKE_TOUCH) ? '[' : '<', 1614 strokep->components[X].loc, 1615 strokep->components[X].delta_mickeys, 1616 strokep->components[X].cum_pressure, 1617 strokep->components[X].max_cum_pressure, 1618 (strokep->type == ATP_STROKE_TOUCH) ? ']' : '>', 1619 (strokep->type == ATP_STROKE_TOUCH) ? '[' : '<', 1620 strokep->components[Y].loc, 1621 strokep->components[Y].delta_mickeys, 1622 strokep->components[Y].cum_pressure, 1623 strokep->components[Y].max_cum_pressure, 1624 (strokep->type == ATP_STROKE_TOUCH) ? ']' : '>'); 1625 } 1626 if (TAILQ_FIRST(&sc->sc_stroke_used) != NULL) 1627 printf("\n"); 1628 } 1629 #endif /* USB_DEBUG */ 1630 return (movement); 1631 } 1632 1633 /* 1634 * Update strokes by matching against current pressure-spans. 1635 * Return true if any movement is detected. 1636 */ 1637 static boolean_t 1638 wsp_update_strokes(struct atp_softc *sc, wsp_finger_t *fingers, u_int n_fingers) 1639 { 1640 boolean_t movement = false; 1641 atp_stroke_t *strokep_next; 1642 atp_stroke_t *strokep; 1643 u_int i; 1644 1645 if (sc->sc_n_strokes > 0) { 1646 movement = wsp_match_strokes_against_fingers( 1647 sc, fingers, n_fingers); 1648 1649 /* handle zombie strokes */ 1650 TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) { 1651 if (strokep->matched) 1652 continue; 1653 atp_terminate_stroke(sc, strokep); 1654 } 1655 } 1656 1657 /* initialize unmatched fingers as strokes */ 1658 for (i = 0; i != n_fingers; i++) { 1659 if (fingers[i].matched) 1660 continue; 1661 1662 wsp_add_stroke(sc, fingers + i); 1663 } 1664 return (movement); 1665 } 1666 1667 /* Initialize a stroke using a pressure-span. */ 1668 static void 1669 fg_add_stroke(struct atp_softc *sc, const fg_pspan *pspan_x, 1670 const fg_pspan *pspan_y) 1671 { 1672 atp_stroke_t *strokep; 1673 1674 strokep = atp_alloc_stroke(sc); 1675 if (strokep == NULL) 1676 return; 1677 1678 /* 1679 * Strokes begin as potential touches. If a stroke survives 1680 * longer than a threshold, or if it records significant 1681 * cumulative movement, then it is considered a 'slide'. 1682 */ 1683 strokep->type = ATP_STROKE_TOUCH; 1684 strokep->matched = false; 1685 microtime(&strokep->ctime); 1686 strokep->age = 1; /* number of interrupts */ 1687 strokep->x = pspan_x->loc; 1688 strokep->y = pspan_y->loc; 1689 1690 strokep->components[X].loc = pspan_x->loc; 1691 strokep->components[X].cum_pressure = pspan_x->cum; 1692 strokep->components[X].max_cum_pressure = pspan_x->cum; 1693 strokep->components[X].matched = true; 1694 1695 strokep->components[Y].loc = pspan_y->loc; 1696 strokep->components[Y].cum_pressure = pspan_y->cum; 1697 strokep->components[Y].max_cum_pressure = pspan_y->cum; 1698 strokep->components[Y].matched = true; 1699 1700 if (sc->sc_n_strokes > 1) { 1701 /* Reset double-tap-n-drag if we have more than one strokes. */ 1702 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG; 1703 } 1704 1705 DPRINTFN(ATP_LLEVEL_INFO, "[%u,%u], time: %u,%ld\n", 1706 strokep->components[X].loc, 1707 strokep->components[Y].loc, 1708 (u_int)strokep->ctime.tv_sec, 1709 (unsigned long int)strokep->ctime.tv_usec); 1710 } 1711 1712 static void 1713 fg_add_new_strokes(struct atp_softc *sc, fg_pspan *pspans_x, 1714 u_int n_xpspans, fg_pspan *pspans_y, u_int n_ypspans) 1715 { 1716 fg_pspan spans[2][FG_MAX_PSPANS_PER_AXIS]; 1717 u_int nspans[2]; 1718 u_int i; 1719 u_int j; 1720 1721 /* Copy unmatched pspans into the local arrays. */ 1722 for (i = 0, nspans[X] = 0; i < n_xpspans; i++) { 1723 if (pspans_x[i].matched == false) { 1724 spans[X][nspans[X]] = pspans_x[i]; 1725 nspans[X]++; 1726 } 1727 } 1728 for (j = 0, nspans[Y] = 0; j < n_ypspans; j++) { 1729 if (pspans_y[j].matched == false) { 1730 spans[Y][nspans[Y]] = pspans_y[j]; 1731 nspans[Y]++; 1732 } 1733 } 1734 1735 if (nspans[X] == nspans[Y]) { 1736 /* Create new strokes from pairs of unmatched pspans */ 1737 for (i = 0, j = 0; (i < nspans[X]) && (j < nspans[Y]); i++, j++) 1738 fg_add_stroke(sc, &spans[X][i], &spans[Y][j]); 1739 } else { 1740 u_int cum = 0; 1741 atp_axis repeat_axis; /* axis with multi-pspans */ 1742 u_int repeat_count; /* repeat count for the multi-pspan*/ 1743 u_int repeat_index = 0; /* index of the multi-span */ 1744 1745 repeat_axis = (nspans[X] > nspans[Y]) ? Y : X; 1746 repeat_count = abs(nspans[X] - nspans[Y]); 1747 for (i = 0; i < nspans[repeat_axis]; i++) { 1748 if (spans[repeat_axis][i].cum > cum) { 1749 repeat_index = i; 1750 cum = spans[repeat_axis][i].cum; 1751 } 1752 } 1753 1754 /* Create new strokes from pairs of unmatched pspans */ 1755 i = 0, j = 0; 1756 for (; (i < nspans[X]) && (j < nspans[Y]); i++, j++) { 1757 fg_add_stroke(sc, &spans[X][i], &spans[Y][j]); 1758 1759 /* Take care to repeat at the multi-pspan. */ 1760 if (repeat_count > 0) { 1761 if ((repeat_axis == X) && 1762 (repeat_index == i)) { 1763 i--; /* counter loop increment */ 1764 repeat_count--; 1765 } else if ((repeat_axis == Y) && 1766 (repeat_index == j)) { 1767 j--; /* counter loop increment */ 1768 repeat_count--; 1769 } 1770 } 1771 } 1772 } 1773 } 1774 1775 /* Initialize a stroke from an unmatched finger. */ 1776 static void 1777 wsp_add_stroke(struct atp_softc *sc, const wsp_finger_t *fingerp) 1778 { 1779 atp_stroke_t *strokep; 1780 1781 strokep = atp_alloc_stroke(sc); 1782 if (strokep == NULL) 1783 return; 1784 1785 /* 1786 * Strokes begin as potential touches. If a stroke survives 1787 * longer than a threshold, or if it records significant 1788 * cumulative movement, then it is considered a 'slide'. 1789 */ 1790 strokep->type = ATP_STROKE_TOUCH; 1791 strokep->matched = true; 1792 microtime(&strokep->ctime); 1793 strokep->age = 1; /* number of interrupts */ 1794 strokep->x = fingerp->x; 1795 strokep->y = fingerp->y; 1796 1797 /* Reset double-tap-n-drag if we have more than one strokes. */ 1798 if (sc->sc_n_strokes > 1) 1799 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG; 1800 1801 DPRINTFN(ATP_LLEVEL_INFO, "[%d,%d]\n", strokep->x, strokep->y); 1802 } 1803 1804 static void 1805 atp_advance_stroke_state(struct atp_softc *sc, atp_stroke_t *strokep, 1806 boolean_t *movementp) 1807 { 1808 /* Revitalize stroke if it had previously been marked as a zombie. */ 1809 if (strokep->flags & ATSF_ZOMBIE) 1810 strokep->flags &= ~ATSF_ZOMBIE; 1811 1812 strokep->age++; 1813 if (strokep->age <= atp_stroke_maturity_threshold) { 1814 /* Avoid noise from immature strokes. */ 1815 strokep->instantaneous_dx = 0; 1816 strokep->instantaneous_dy = 0; 1817 } 1818 1819 if (atp_compute_stroke_movement(strokep)) 1820 *movementp = true; 1821 1822 if (strokep->type != ATP_STROKE_TOUCH) 1823 return; 1824 1825 /* Convert touch strokes to slides upon detecting movement or age. */ 1826 if ((abs(strokep->cum_movement_x) > atp_slide_min_movement) || 1827 (abs(strokep->cum_movement_y) > atp_slide_min_movement)) 1828 atp_convert_to_slide(sc, strokep); 1829 else { 1830 /* Compute the stroke's age. */ 1831 struct timeval tdiff; 1832 getmicrotime(&tdiff); 1833 if (timevalcmp(&tdiff, &strokep->ctime, >)) { 1834 timevalsub(&tdiff, &strokep->ctime); 1835 1836 if ((tdiff.tv_sec > (atp_touch_timeout / 1000000)) || 1837 ((tdiff.tv_sec == (atp_touch_timeout / 1000000)) && 1838 (tdiff.tv_usec >= (atp_touch_timeout % 1000000)))) 1839 atp_convert_to_slide(sc, strokep); 1840 } 1841 } 1842 } 1843 1844 static boolean_t 1845 atp_stroke_has_small_movement(const atp_stroke_t *strokep) 1846 { 1847 return (((u_int)abs(strokep->instantaneous_dx) <= 1848 atp_small_movement_threshold) && 1849 ((u_int)abs(strokep->instantaneous_dy) <= 1850 atp_small_movement_threshold)); 1851 } 1852 1853 /* 1854 * Accumulate instantaneous changes into the stroke's 'pending' bucket; if 1855 * the aggregate exceeds the small_movement_threshold, then retain 1856 * instantaneous changes for later. 1857 */ 1858 static void 1859 atp_update_pending_mickeys(atp_stroke_t *strokep) 1860 { 1861 /* accumulate instantaneous movement */ 1862 strokep->pending_dx += strokep->instantaneous_dx; 1863 strokep->pending_dy += strokep->instantaneous_dy; 1864 1865 #define UPDATE_INSTANTANEOUS_AND_PENDING(I, P) \ 1866 if (abs((P)) <= atp_small_movement_threshold) \ 1867 (I) = 0; /* clobber small movement */ \ 1868 else { \ 1869 if ((I) > 0) { \ 1870 /* \ 1871 * Round up instantaneous movement to the nearest \ 1872 * ceiling. This helps preserve small mickey \ 1873 * movements from being lost in following scaling \ 1874 * operation. \ 1875 */ \ 1876 (I) = (((I) + (atp_mickeys_scale_factor - 1)) / \ 1877 atp_mickeys_scale_factor) * \ 1878 atp_mickeys_scale_factor; \ 1879 \ 1880 /* \ 1881 * Deduct the rounded mickeys from pending mickeys. \ 1882 * Note: we multiply by 2 to offset the previous \ 1883 * accumulation of instantaneous movement into \ 1884 * pending. \ 1885 */ \ 1886 (P) -= ((I) << 1); \ 1887 \ 1888 /* truncate pending to 0 if it becomes negative. */ \ 1889 (P) = imax((P), 0); \ 1890 } else { \ 1891 /* \ 1892 * Round down instantaneous movement to the nearest \ 1893 * ceiling. This helps preserve small mickey \ 1894 * movements from being lost in following scaling \ 1895 * operation. \ 1896 */ \ 1897 (I) = (((I) - (atp_mickeys_scale_factor - 1)) / \ 1898 atp_mickeys_scale_factor) * \ 1899 atp_mickeys_scale_factor; \ 1900 \ 1901 /* \ 1902 * Deduct the rounded mickeys from pending mickeys. \ 1903 * Note: we multiply by 2 to offset the previous \ 1904 * accumulation of instantaneous movement into \ 1905 * pending. \ 1906 */ \ 1907 (P) -= ((I) << 1); \ 1908 \ 1909 /* truncate pending to 0 if it becomes positive. */ \ 1910 (P) = imin((P), 0); \ 1911 } \ 1912 } 1913 1914 UPDATE_INSTANTANEOUS_AND_PENDING(strokep->instantaneous_dx, 1915 strokep->pending_dx); 1916 UPDATE_INSTANTANEOUS_AND_PENDING(strokep->instantaneous_dy, 1917 strokep->pending_dy); 1918 } 1919 1920 /* 1921 * Compute a smoothened value for the stroke's movement from 1922 * instantaneous changes in the X and Y components. 1923 */ 1924 static boolean_t 1925 atp_compute_stroke_movement(atp_stroke_t *strokep) 1926 { 1927 /* 1928 * Short movements are added first to the 'pending' bucket, 1929 * and then acted upon only when their aggregate exceeds a 1930 * threshold. This has the effect of filtering away movement 1931 * noise. 1932 */ 1933 if (atp_stroke_has_small_movement(strokep)) 1934 atp_update_pending_mickeys(strokep); 1935 else { /* large movement */ 1936 /* clear away any pending mickeys if there are large movements*/ 1937 strokep->pending_dx = 0; 1938 strokep->pending_dy = 0; 1939 } 1940 1941 /* scale movement */ 1942 strokep->movement_dx = (strokep->instantaneous_dx) / 1943 (int)atp_mickeys_scale_factor; 1944 strokep->movement_dy = (strokep->instantaneous_dy) / 1945 (int)atp_mickeys_scale_factor; 1946 1947 if ((abs(strokep->instantaneous_dx) >= ATP_FAST_MOVEMENT_TRESHOLD) || 1948 (abs(strokep->instantaneous_dy) >= ATP_FAST_MOVEMENT_TRESHOLD)) { 1949 strokep->movement_dx <<= 1; 1950 strokep->movement_dy <<= 1; 1951 } 1952 1953 strokep->cum_movement_x += strokep->movement_dx; 1954 strokep->cum_movement_y += strokep->movement_dy; 1955 1956 return ((strokep->movement_dx != 0) || (strokep->movement_dy != 0)); 1957 } 1958 1959 /* 1960 * Terminate a stroke. Aside from immature strokes, a slide or touch is 1961 * retained as a zombies so as to reap all their termination siblings 1962 * together; this helps establish the number of fingers involved at the 1963 * end of a multi-touch gesture. 1964 */ 1965 static void 1966 atp_terminate_stroke(struct atp_softc *sc, atp_stroke_t *strokep) 1967 { 1968 if (strokep->flags & ATSF_ZOMBIE) 1969 return; 1970 1971 /* Drop immature strokes rightaway. */ 1972 if (strokep->age <= atp_stroke_maturity_threshold) { 1973 atp_free_stroke(sc, strokep); 1974 return; 1975 } 1976 1977 strokep->flags |= ATSF_ZOMBIE; 1978 sc->sc_state |= ATP_ZOMBIES_EXIST; 1979 1980 callout_reset(&sc->sc_callout, ATP_ZOMBIE_STROKE_REAP_INTERVAL, 1981 atp_reap_sibling_zombies, sc); 1982 1983 /* 1984 * Reset the double-click-n-drag at the termination of any 1985 * slide stroke. 1986 */ 1987 if (strokep->type == ATP_STROKE_SLIDE) 1988 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG; 1989 } 1990 1991 static boolean_t 1992 atp_is_horizontal_scroll(const atp_stroke_t *strokep) 1993 { 1994 if (abs(strokep->cum_movement_x) < atp_slide_min_movement) 1995 return (false); 1996 if (strokep->cum_movement_y == 0) 1997 return (true); 1998 return (abs(strokep->cum_movement_x / strokep->cum_movement_y) >= 4); 1999 } 2000 2001 static boolean_t 2002 atp_is_vertical_scroll(const atp_stroke_t *strokep) 2003 { 2004 if (abs(strokep->cum_movement_y) < atp_slide_min_movement) 2005 return (false); 2006 if (strokep->cum_movement_x == 0) 2007 return (true); 2008 return (abs(strokep->cum_movement_y / strokep->cum_movement_x) >= 4); 2009 } 2010 2011 static void 2012 atp_reap_sibling_zombies(void *arg) 2013 { 2014 struct atp_softc *sc = (struct atp_softc *)arg; 2015 u_int8_t n_touches_reaped = 0; 2016 u_int8_t n_slides_reaped = 0; 2017 u_int8_t n_horizontal_scrolls = 0; 2018 u_int8_t n_vertical_scrolls = 0; 2019 int horizontal_scroll = 0; 2020 int vertical_scroll = 0; 2021 atp_stroke_t *strokep; 2022 atp_stroke_t *strokep_next; 2023 2024 DPRINTFN(ATP_LLEVEL_INFO, "\n"); 2025 2026 TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) { 2027 if ((strokep->flags & ATSF_ZOMBIE) == 0) 2028 continue; 2029 2030 if (strokep->type == ATP_STROKE_TOUCH) { 2031 n_touches_reaped++; 2032 } else { 2033 n_slides_reaped++; 2034 2035 if (atp_is_horizontal_scroll(strokep)) { 2036 n_horizontal_scrolls++; 2037 horizontal_scroll += strokep->cum_movement_x; 2038 } else if (atp_is_vertical_scroll(strokep)) { 2039 n_vertical_scrolls++; 2040 vertical_scroll += strokep->cum_movement_y; 2041 } 2042 } 2043 2044 atp_free_stroke(sc, strokep); 2045 } 2046 2047 DPRINTFN(ATP_LLEVEL_INFO, "reaped %u zombies\n", 2048 n_touches_reaped + n_slides_reaped); 2049 sc->sc_state &= ~ATP_ZOMBIES_EXIST; 2050 2051 /* No further processing necessary if physical button is depressed. */ 2052 if (sc->sc_ibtn != 0) 2053 return; 2054 2055 if ((n_touches_reaped == 0) && (n_slides_reaped == 0)) 2056 return; 2057 2058 /* Add a pair of virtual button events (button-down and button-up) if 2059 * the physical button isn't pressed. */ 2060 if (n_touches_reaped != 0) { 2061 if (n_touches_reaped < atp_tap_minimum) 2062 return; 2063 2064 switch (n_touches_reaped) { 2065 case 1: 2066 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON1DOWN); 2067 microtime(&sc->sc_touch_reap_time); /* remember this time */ 2068 break; 2069 case 2: 2070 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON3DOWN); 2071 break; 2072 case 3: 2073 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON2DOWN); 2074 break; 2075 default: 2076 /* we handle taps of only up to 3 fingers */ 2077 return; 2078 } 2079 atp_add_to_queue(sc, 0, 0, 0, 0); /* button release */ 2080 2081 } else if ((n_slides_reaped == 2) && (n_horizontal_scrolls == 2)) { 2082 if (horizontal_scroll < 0) 2083 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON4DOWN); 2084 else 2085 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON5DOWN); 2086 atp_add_to_queue(sc, 0, 0, 0, 0); /* button release */ 2087 } 2088 } 2089 2090 /* Switch a given touch stroke to being a slide. */ 2091 static void 2092 atp_convert_to_slide(struct atp_softc *sc, atp_stroke_t *strokep) 2093 { 2094 strokep->type = ATP_STROKE_SLIDE; 2095 2096 /* Are we at the beginning of a double-click-n-drag? */ 2097 if ((sc->sc_n_strokes == 1) && 2098 ((sc->sc_state & ATP_ZOMBIES_EXIST) == 0) && 2099 timevalcmp(&strokep->ctime, &sc->sc_touch_reap_time, >)) { 2100 struct timeval delta; 2101 struct timeval window = { 2102 atp_double_tap_threshold / 1000000, 2103 atp_double_tap_threshold % 1000000 2104 }; 2105 2106 delta = strokep->ctime; 2107 timevalsub(&delta, &sc->sc_touch_reap_time); 2108 if (timevalcmp(&delta, &window, <=)) 2109 sc->sc_state |= ATP_DOUBLE_TAP_DRAG; 2110 } 2111 } 2112 2113 static void 2114 atp_reset_buf(struct atp_softc *sc) 2115 { 2116 /* reset read queue */ 2117 usb_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]); 2118 } 2119 2120 static void 2121 atp_add_to_queue(struct atp_softc *sc, int dx, int dy, int dz, 2122 uint32_t buttons_in) 2123 { 2124 uint32_t buttons_out; 2125 uint8_t buf[8]; 2126 2127 dx = imin(dx, 254); dx = imax(dx, -256); 2128 dy = imin(dy, 254); dy = imax(dy, -256); 2129 dz = imin(dz, 126); dz = imax(dz, -128); 2130 2131 buttons_out = MOUSE_MSC_BUTTONS; 2132 if (buttons_in & MOUSE_BUTTON1DOWN) 2133 buttons_out &= ~MOUSE_MSC_BUTTON1UP; 2134 else if (buttons_in & MOUSE_BUTTON2DOWN) 2135 buttons_out &= ~MOUSE_MSC_BUTTON2UP; 2136 else if (buttons_in & MOUSE_BUTTON3DOWN) 2137 buttons_out &= ~MOUSE_MSC_BUTTON3UP; 2138 2139 DPRINTFN(ATP_LLEVEL_INFO, "dx=%d, dy=%d, buttons=%x\n", 2140 dx, dy, buttons_out); 2141 2142 /* Encode the mouse data in standard format; refer to mouse(4) */ 2143 buf[0] = sc->sc_mode.syncmask[1]; 2144 buf[0] |= buttons_out; 2145 buf[1] = dx >> 1; 2146 buf[2] = dy >> 1; 2147 buf[3] = dx - (dx >> 1); 2148 buf[4] = dy - (dy >> 1); 2149 /* Encode extra bytes for level 1 */ 2150 if (sc->sc_mode.level == 1) { 2151 buf[5] = dz >> 1; 2152 buf[6] = dz - (dz >> 1); 2153 buf[7] = (((~buttons_in) >> 3) & MOUSE_SYS_EXTBUTTONS); 2154 } 2155 2156 usb_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf, 2157 sc->sc_mode.packetsize, 1); 2158 } 2159 2160 static int 2161 atp_probe(device_t self) 2162 { 2163 struct usb_attach_arg *uaa = device_get_ivars(self); 2164 2165 if (uaa->usb_mode != USB_MODE_HOST) 2166 return (ENXIO); 2167 2168 if (uaa->info.bInterfaceClass != UICLASS_HID) 2169 return (ENXIO); 2170 /* 2171 * Note: for some reason, the check 2172 * (uaa->info.bInterfaceProtocol == UIPROTO_MOUSE) doesn't hold true 2173 * for wellspring trackpads, so we've removed it from the common path. 2174 */ 2175 2176 if ((usbd_lookup_id_by_uaa(fg_devs, sizeof(fg_devs), uaa)) == 0) 2177 return ((uaa->info.bInterfaceProtocol == UIPROTO_MOUSE) ? 2178 0 : ENXIO); 2179 2180 if ((usbd_lookup_id_by_uaa(wsp_devs, sizeof(wsp_devs), uaa)) == 0) 2181 if (uaa->info.bIfaceIndex == WELLSPRING_INTERFACE_INDEX) 2182 return (0); 2183 2184 return (ENXIO); 2185 } 2186 2187 static int 2188 atp_attach(device_t dev) 2189 { 2190 struct atp_softc *sc = device_get_softc(dev); 2191 struct usb_attach_arg *uaa = device_get_ivars(dev); 2192 usb_error_t err; 2193 void *descriptor_ptr = NULL; 2194 uint16_t descriptor_len; 2195 unsigned long di; 2196 2197 DPRINTFN(ATP_LLEVEL_INFO, "sc=%p\n", sc); 2198 2199 sc->sc_dev = dev; 2200 sc->sc_usb_device = uaa->device; 2201 2202 /* Get HID descriptor */ 2203 if (usbd_req_get_hid_desc(uaa->device, NULL, &descriptor_ptr, 2204 &descriptor_len, M_TEMP, uaa->info.bIfaceIndex) != 2205 USB_ERR_NORMAL_COMPLETION) 2206 return (ENXIO); 2207 2208 /* Get HID report descriptor length */ 2209 sc->sc_expected_sensor_data_len = hid_report_size_max(descriptor_ptr, 2210 descriptor_len, hid_input, NULL); 2211 free(descriptor_ptr, M_TEMP); 2212 2213 if ((sc->sc_expected_sensor_data_len <= 0) || 2214 (sc->sc_expected_sensor_data_len > ATP_SENSOR_DATA_BUF_MAX)) { 2215 DPRINTF("atp_attach: datalength invalid or too large: %d\n", 2216 sc->sc_expected_sensor_data_len); 2217 return (ENXIO); 2218 } 2219 2220 di = USB_GET_DRIVER_INFO(uaa); 2221 sc->sc_family = DECODE_FAMILY_FROM_DRIVER_INFO(di); 2222 2223 /* 2224 * By default the touchpad behaves like an HID device, sending 2225 * packets with reportID = 2. Such reports contain only 2226 * limited information--they encode movement deltas and button 2227 * events,--but do not include data from the pressure 2228 * sensors. The device input mode can be switched from HID 2229 * reports to raw sensor data using vendor-specific USB 2230 * control commands. 2231 * FOUNTAIN devices will give an error when trying to switch 2232 * input mode, so we skip this command 2233 */ 2234 if ((sc->sc_family == TRACKPAD_FAMILY_FOUNTAIN_GEYSER) && 2235 (DECODE_PRODUCT_FROM_DRIVER_INFO(di) == FOUNTAIN)) 2236 DPRINTF("device mode switch skipped: Fountain device\n"); 2237 else if ((err = atp_set_device_mode(sc, RAW_SENSOR_MODE)) != 0) { 2238 DPRINTF("failed to set mode to 'RAW_SENSOR' (%d)\n", err); 2239 return (ENXIO); 2240 } 2241 2242 mtx_init(&sc->sc_mutex, "atpmtx", NULL, MTX_DEF | MTX_RECURSE); 2243 2244 switch(sc->sc_family) { 2245 case TRACKPAD_FAMILY_FOUNTAIN_GEYSER: 2246 sc->sc_params = 2247 &fg_dev_params[DECODE_PRODUCT_FROM_DRIVER_INFO(di)]; 2248 sc->sensor_data_interpreter = fg_interpret_sensor_data; 2249 break; 2250 case TRACKPAD_FAMILY_WELLSPRING: 2251 sc->sc_params = 2252 &wsp_dev_params[DECODE_PRODUCT_FROM_DRIVER_INFO(di)]; 2253 sc->sensor_data_interpreter = wsp_interpret_sensor_data; 2254 break; 2255 default: 2256 goto detach; 2257 } 2258 2259 err = usbd_transfer_setup(uaa->device, 2260 &uaa->info.bIfaceIndex, sc->sc_xfer, atp_xfer_config, 2261 ATP_N_TRANSFER, sc, &sc->sc_mutex); 2262 if (err) { 2263 DPRINTF("error=%s\n", usbd_errstr(err)); 2264 goto detach; 2265 } 2266 2267 if (usb_fifo_attach(sc->sc_usb_device, sc, &sc->sc_mutex, 2268 &atp_fifo_methods, &sc->sc_fifo, 2269 device_get_unit(dev), -1, uaa->info.bIfaceIndex, 2270 UID_ROOT, GID_OPERATOR, 0644)) { 2271 goto detach; 2272 } 2273 2274 device_set_usb_desc(dev); 2275 2276 sc->sc_hw.buttons = 3; 2277 sc->sc_hw.iftype = MOUSE_IF_USB; 2278 sc->sc_hw.type = MOUSE_PAD; 2279 sc->sc_hw.model = MOUSE_MODEL_GENERIC; 2280 sc->sc_hw.hwid = 0; 2281 sc->sc_mode.protocol = MOUSE_PROTO_MSC; 2282 sc->sc_mode.rate = -1; 2283 sc->sc_mode.resolution = MOUSE_RES_UNKNOWN; 2284 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE; 2285 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK; 2286 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC; 2287 sc->sc_mode.accelfactor = 0; 2288 sc->sc_mode.level = 0; 2289 2290 sc->sc_state = 0; 2291 sc->sc_ibtn = 0; 2292 2293 callout_init_mtx(&sc->sc_callout, &sc->sc_mutex, 0); 2294 2295 return (0); 2296 2297 detach: 2298 atp_detach(dev); 2299 return (ENOMEM); 2300 } 2301 2302 static int 2303 atp_detach(device_t dev) 2304 { 2305 struct atp_softc *sc; 2306 2307 sc = device_get_softc(dev); 2308 atp_set_device_mode(sc, HID_MODE); 2309 2310 mtx_lock(&sc->sc_mutex); 2311 callout_drain(&sc->sc_callout); 2312 if (sc->sc_state & ATP_ENABLED) 2313 atp_disable(sc); 2314 mtx_unlock(&sc->sc_mutex); 2315 2316 usb_fifo_detach(&sc->sc_fifo); 2317 2318 usbd_transfer_unsetup(sc->sc_xfer, ATP_N_TRANSFER); 2319 2320 mtx_destroy(&sc->sc_mutex); 2321 2322 return (0); 2323 } 2324 2325 static void 2326 atp_intr(struct usb_xfer *xfer, usb_error_t error) 2327 { 2328 struct atp_softc *sc = usbd_xfer_softc(xfer); 2329 struct usb_page_cache *pc; 2330 int len; 2331 2332 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 2333 2334 switch (USB_GET_STATE(xfer)) { 2335 case USB_ST_TRANSFERRED: 2336 pc = usbd_xfer_get_frame(xfer, 0); 2337 usbd_copy_out(pc, 0, sc->sc_sensor_data, len); 2338 if (len < sc->sc_expected_sensor_data_len) { 2339 /* make sure we don't process old data */ 2340 memset(sc->sc_sensor_data + len, 0, 2341 sc->sc_expected_sensor_data_len - len); 2342 } 2343 2344 sc->sc_status.flags &= ~(MOUSE_STDBUTTONSCHANGED | 2345 MOUSE_POSCHANGED); 2346 sc->sc_status.obutton = sc->sc_status.button; 2347 2348 (sc->sensor_data_interpreter)(sc, len); 2349 2350 if (sc->sc_status.button != 0) { 2351 /* Reset DOUBLE_TAP_N_DRAG if the button is pressed. */ 2352 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG; 2353 } else if (sc->sc_state & ATP_DOUBLE_TAP_DRAG) { 2354 /* Assume a button-press with DOUBLE_TAP_N_DRAG. */ 2355 sc->sc_status.button = MOUSE_BUTTON1DOWN; 2356 } 2357 2358 sc->sc_status.flags |= 2359 sc->sc_status.button ^ sc->sc_status.obutton; 2360 if (sc->sc_status.flags & MOUSE_STDBUTTONSCHANGED) { 2361 DPRINTFN(ATP_LLEVEL_INFO, "button %s\n", 2362 ((sc->sc_status.button & MOUSE_BUTTON1DOWN) ? 2363 "pressed" : "released")); 2364 } 2365 2366 if (sc->sc_status.flags & (MOUSE_POSCHANGED | 2367 MOUSE_STDBUTTONSCHANGED)) { 2368 atp_stroke_t *strokep; 2369 u_int8_t n_movements = 0; 2370 int dx = 0; 2371 int dy = 0; 2372 int dz = 0; 2373 2374 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) { 2375 if (strokep->flags & ATSF_ZOMBIE) 2376 continue; 2377 2378 dx += strokep->movement_dx; 2379 dy += strokep->movement_dy; 2380 if (strokep->movement_dx || 2381 strokep->movement_dy) 2382 n_movements++; 2383 } 2384 2385 /* average movement if multiple strokes record motion.*/ 2386 if (n_movements > 1) { 2387 dx /= (int)n_movements; 2388 dy /= (int)n_movements; 2389 } 2390 2391 /* detect multi-finger vertical scrolls */ 2392 if (n_movements >= 2) { 2393 boolean_t all_vertical_scrolls = true; 2394 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) { 2395 if (strokep->flags & ATSF_ZOMBIE) 2396 continue; 2397 2398 if (!atp_is_vertical_scroll(strokep)) 2399 all_vertical_scrolls = false; 2400 } 2401 if (all_vertical_scrolls) { 2402 dz = dy; 2403 dy = dx = 0; 2404 } 2405 } 2406 2407 sc->sc_status.dx += dx; 2408 sc->sc_status.dy += dy; 2409 sc->sc_status.dz += dz; 2410 atp_add_to_queue(sc, dx, -dy, -dz, sc->sc_status.button); 2411 } 2412 2413 case USB_ST_SETUP: 2414 tr_setup: 2415 /* check if we can put more data into the FIFO */ 2416 if (usb_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) != 0) { 2417 usbd_xfer_set_frame_len(xfer, 0, 2418 sc->sc_expected_sensor_data_len); 2419 usbd_transfer_submit(xfer); 2420 } 2421 break; 2422 2423 default: /* Error */ 2424 if (error != USB_ERR_CANCELLED) { 2425 /* try clear stall first */ 2426 usbd_xfer_set_stall(xfer); 2427 goto tr_setup; 2428 } 2429 break; 2430 } 2431 } 2432 2433 static void 2434 atp_start_read(struct usb_fifo *fifo) 2435 { 2436 struct atp_softc *sc = usb_fifo_softc(fifo); 2437 int rate; 2438 2439 /* Check if we should override the default polling interval */ 2440 rate = sc->sc_pollrate; 2441 /* Range check rate */ 2442 if (rate > 1000) 2443 rate = 1000; 2444 /* Check for set rate */ 2445 if ((rate > 0) && (sc->sc_xfer[ATP_INTR_DT] != NULL)) { 2446 /* Stop current transfer, if any */ 2447 usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]); 2448 /* Set new interval */ 2449 usbd_xfer_set_interval(sc->sc_xfer[ATP_INTR_DT], 1000 / rate); 2450 /* Only set pollrate once */ 2451 sc->sc_pollrate = 0; 2452 } 2453 2454 usbd_transfer_start(sc->sc_xfer[ATP_INTR_DT]); 2455 } 2456 2457 static void 2458 atp_stop_read(struct usb_fifo *fifo) 2459 { 2460 struct atp_softc *sc = usb_fifo_softc(fifo); 2461 usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]); 2462 } 2463 2464 static int 2465 atp_open(struct usb_fifo *fifo, int fflags) 2466 { 2467 struct atp_softc *sc = usb_fifo_softc(fifo); 2468 2469 /* check for duplicate open, should not happen */ 2470 if (sc->sc_fflags & fflags) 2471 return (EBUSY); 2472 2473 /* check for first open */ 2474 if (sc->sc_fflags == 0) { 2475 int rc; 2476 if ((rc = atp_enable(sc)) != 0) 2477 return (rc); 2478 } 2479 2480 if (fflags & FREAD) { 2481 if (usb_fifo_alloc_buffer(fifo, 2482 ATP_FIFO_BUF_SIZE, ATP_FIFO_QUEUE_MAXLEN)) { 2483 return (ENOMEM); 2484 } 2485 } 2486 2487 sc->sc_fflags |= (fflags & (FREAD | FWRITE)); 2488 return (0); 2489 } 2490 2491 static void 2492 atp_close(struct usb_fifo *fifo, int fflags) 2493 { 2494 struct atp_softc *sc = usb_fifo_softc(fifo); 2495 if (fflags & FREAD) 2496 usb_fifo_free_buffer(fifo); 2497 2498 sc->sc_fflags &= ~(fflags & (FREAD | FWRITE)); 2499 if (sc->sc_fflags == 0) { 2500 atp_disable(sc); 2501 } 2502 } 2503 2504 static int 2505 atp_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags) 2506 { 2507 struct atp_softc *sc = usb_fifo_softc(fifo); 2508 mousemode_t mode; 2509 int error = 0; 2510 2511 mtx_lock(&sc->sc_mutex); 2512 2513 switch(cmd) { 2514 case MOUSE_GETHWINFO: 2515 *(mousehw_t *)addr = sc->sc_hw; 2516 break; 2517 case MOUSE_GETMODE: 2518 *(mousemode_t *)addr = sc->sc_mode; 2519 break; 2520 case MOUSE_SETMODE: 2521 mode = *(mousemode_t *)addr; 2522 2523 if (mode.level == -1) 2524 /* Don't change the current setting */ 2525 ; 2526 else if ((mode.level < 0) || (mode.level > 1)) { 2527 error = EINVAL; 2528 break; 2529 } 2530 sc->sc_mode.level = mode.level; 2531 sc->sc_pollrate = mode.rate; 2532 sc->sc_hw.buttons = 3; 2533 2534 if (sc->sc_mode.level == 0) { 2535 sc->sc_mode.protocol = MOUSE_PROTO_MSC; 2536 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE; 2537 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK; 2538 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC; 2539 } else if (sc->sc_mode.level == 1) { 2540 sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE; 2541 sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE; 2542 sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK; 2543 sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC; 2544 } 2545 atp_reset_buf(sc); 2546 break; 2547 case MOUSE_GETLEVEL: 2548 *(int *)addr = sc->sc_mode.level; 2549 break; 2550 case MOUSE_SETLEVEL: 2551 if ((*(int *)addr < 0) || (*(int *)addr > 1)) { 2552 error = EINVAL; 2553 break; 2554 } 2555 sc->sc_mode.level = *(int *)addr; 2556 sc->sc_hw.buttons = 3; 2557 2558 if (sc->sc_mode.level == 0) { 2559 sc->sc_mode.protocol = MOUSE_PROTO_MSC; 2560 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE; 2561 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK; 2562 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC; 2563 } else if (sc->sc_mode.level == 1) { 2564 sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE; 2565 sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE; 2566 sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK; 2567 sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC; 2568 } 2569 atp_reset_buf(sc); 2570 break; 2571 case MOUSE_GETSTATUS: { 2572 mousestatus_t *status = (mousestatus_t *)addr; 2573 2574 *status = sc->sc_status; 2575 sc->sc_status.obutton = sc->sc_status.button; 2576 sc->sc_status.button = 0; 2577 sc->sc_status.dx = 0; 2578 sc->sc_status.dy = 0; 2579 sc->sc_status.dz = 0; 2580 2581 if (status->dx || status->dy || status->dz) 2582 status->flags |= MOUSE_POSCHANGED; 2583 if (status->button != status->obutton) 2584 status->flags |= MOUSE_BUTTONSCHANGED; 2585 break; 2586 } 2587 2588 default: 2589 error = ENOTTY; 2590 break; 2591 } 2592 2593 mtx_unlock(&sc->sc_mutex); 2594 return (error); 2595 } 2596 2597 static int 2598 atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS) 2599 { 2600 int error; 2601 u_int tmp; 2602 2603 tmp = atp_mickeys_scale_factor; 2604 error = sysctl_handle_int(oidp, &tmp, 0, req); 2605 if (error != 0 || req->newptr == NULL) 2606 return (error); 2607 2608 if (tmp == atp_mickeys_scale_factor) 2609 return (0); /* no change */ 2610 if ((tmp == 0) || (tmp > (10 * ATP_SCALE_FACTOR))) 2611 return (EINVAL); 2612 2613 atp_mickeys_scale_factor = tmp; 2614 DPRINTFN(ATP_LLEVEL_INFO, "%s: resetting mickeys_scale_factor to %u\n", 2615 ATP_DRIVER_NAME, tmp); 2616 2617 return (0); 2618 } 2619 2620 static devclass_t atp_devclass; 2621 2622 static device_method_t atp_methods[] = { 2623 DEVMETHOD(device_probe, atp_probe), 2624 DEVMETHOD(device_attach, atp_attach), 2625 DEVMETHOD(device_detach, atp_detach), 2626 2627 DEVMETHOD_END 2628 }; 2629 2630 static driver_t atp_driver = { 2631 .name = ATP_DRIVER_NAME, 2632 .methods = atp_methods, 2633 .size = sizeof(struct atp_softc) 2634 }; 2635 2636 DRIVER_MODULE(atp, uhub, atp_driver, atp_devclass, NULL, 0); 2637 MODULE_DEPEND(atp, usb, 1, 1, 1); 2638 MODULE_DEPEND(atp, hid, 1, 1, 1); 2639 MODULE_VERSION(atp, 1); 2640 USB_PNP_HOST_INFO(fg_devs); 2641 USB_PNP_HOST_INFO(wsp_devs); 2642