2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2014 Rohit Grover
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
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.
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)
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.
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.
61 #include <sys/cdefs.h>
62 __FBSDID("$FreeBSD$");
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>
71 #include <sys/module.h>
73 #include <sys/mutex.h>
74 #include <sys/sysctl.h>
75 #include <sys/malloc.h>
77 #include <sys/fcntl.h>
79 #include <sys/selinfo.h>
82 #include <dev/usb/usb.h>
83 #include <dev/usb/usbdi.h>
84 #include <dev/usb/usbdi_util.h>
85 #include <dev/usb/usbhid.h>
89 #define USB_DEBUG_VAR atp_debug
90 #include <dev/usb/usb_debug.h>
92 #include <sys/mouse.h>
94 #define ATP_DRIVER_NAME "atp"
97 * Driver specific options: the following options may be set by
98 * `options' statements in the kernel configuration file.
101 /* The divisor used to translate sensor reported positions to mickeys. */
102 #ifndef ATP_SCALE_FACTOR
103 #define ATP_SCALE_FACTOR 16
106 /* Threshold for small movement noise (in mickeys) */
107 #ifndef ATP_SMALL_MOVEMENT_THRESHOLD
108 #define ATP_SMALL_MOVEMENT_THRESHOLD 30
111 /* Threshold of instantaneous deltas beyond which movement is considered fast.*/
112 #ifndef ATP_FAST_MOVEMENT_TRESHOLD
113 #define ATP_FAST_MOVEMENT_TRESHOLD 150
117 * This is the age in microseconds beyond which a touch is considered
118 * to be a slide; and therefore a tap event isn't registered.
120 #ifndef ATP_TOUCH_TIMEOUT
121 #define ATP_TOUCH_TIMEOUT 125000
124 #ifndef ATP_IDLENESS_THRESHOLD
125 #define ATP_IDLENESS_THRESHOLD 10
128 #ifndef FG_SENSOR_NOISE_THRESHOLD
129 #define FG_SENSOR_NOISE_THRESHOLD 2
133 * A double-tap followed by a single-finger slide is treated as a
134 * special gesture. The driver responds to this gesture by assuming a
135 * virtual button-press for the lifetime of the slide. The following
136 * threshold is the maximum time gap (in microseconds) between the two
137 * tap events preceding the slide for such a gesture.
139 #ifndef ATP_DOUBLE_TAP_N_DRAG_THRESHOLD
140 #define ATP_DOUBLE_TAP_N_DRAG_THRESHOLD 200000
144 * The wait duration in ticks after losing a touch contact before
145 * zombied strokes are reaped and turned into button events.
147 #define ATP_ZOMBIE_STROKE_REAP_INTERVAL (hz / 20) /* 50 ms */
149 /* The multiplier used to translate sensor reported positions to mickeys. */
150 #define FG_SCALE_FACTOR 380
153 * The movement threshold for a stroke; this is the maximum difference
154 * in position which will be resolved as a continuation of a stroke
157 #define FG_MAX_DELTA_MICKEYS ((3 * (FG_SCALE_FACTOR)) >> 1)
159 /* Distance-squared threshold for matching a finger with a known stroke */
160 #ifndef WSP_MAX_ALLOWED_MATCH_DISTANCE_SQ
161 #define WSP_MAX_ALLOWED_MATCH_DISTANCE_SQ 1000000
164 /* Ignore pressure spans with cumulative press. below this value. */
165 #define FG_PSPAN_MIN_CUM_PRESSURE 10
167 /* Maximum allowed width for pressure-spans.*/
168 #define FG_PSPAN_MAX_WIDTH 4
170 /* end of driver specific options */
173 static SYSCTL_NODE(_hw_usb, OID_AUTO, atp, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
178 ATP_LLEVEL_DISABLED = 0,
180 ATP_LLEVEL_DEBUG, /* for troubleshooting */
181 ATP_LLEVEL_INFO, /* for diagnostics */
183 static int atp_debug = ATP_LLEVEL_ERROR; /* the default is to only log errors */
184 SYSCTL_INT(_hw_usb_atp, OID_AUTO, debug, CTLFLAG_RWTUN,
185 &atp_debug, ATP_LLEVEL_ERROR, "ATP debug level");
186 #endif /* USB_DEBUG */
188 static u_int atp_touch_timeout = ATP_TOUCH_TIMEOUT;
189 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, touch_timeout, CTLFLAG_RWTUN,
190 &atp_touch_timeout, 125000, "age threshold in microseconds for a touch");
192 static u_int atp_double_tap_threshold = ATP_DOUBLE_TAP_N_DRAG_THRESHOLD;
193 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, double_tap_threshold, CTLFLAG_RWTUN,
194 &atp_double_tap_threshold, ATP_DOUBLE_TAP_N_DRAG_THRESHOLD,
195 "maximum time in microseconds to allow association between a double-tap and "
198 static u_int atp_mickeys_scale_factor = ATP_SCALE_FACTOR;
199 static int atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS);
200 SYSCTL_PROC(_hw_usb_atp, OID_AUTO, scale_factor,
201 CTLTYPE_UINT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
202 &atp_mickeys_scale_factor, sizeof(atp_mickeys_scale_factor),
203 atp_sysctl_scale_factor_handler, "IU",
204 "movement scale factor");
206 static u_int atp_small_movement_threshold = ATP_SMALL_MOVEMENT_THRESHOLD;
207 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, small_movement, CTLFLAG_RWTUN,
208 &atp_small_movement_threshold, ATP_SMALL_MOVEMENT_THRESHOLD,
209 "the small movement black-hole for filtering noise");
211 static u_int atp_tap_minimum = 1;
212 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, tap_minimum, CTLFLAG_RWTUN,
213 &atp_tap_minimum, 1, "Minimum number of taps before detection");
216 * Strokes which accumulate at least this amount of absolute movement
217 * from the aggregate of their components are considered as
218 * slides. Unit: mickeys.
220 static u_int atp_slide_min_movement = 2 * ATP_SMALL_MOVEMENT_THRESHOLD;
221 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, slide_min_movement, CTLFLAG_RWTUN,
222 &atp_slide_min_movement, 2 * ATP_SMALL_MOVEMENT_THRESHOLD,
223 "strokes with at least this amt. of movement are considered slides");
226 * The minimum age of a stroke for it to be considered mature; this
227 * helps filter movements (noise) from immature strokes. Units: interrupts.
229 static u_int atp_stroke_maturity_threshold = 4;
230 SYSCTL_UINT(_hw_usb_atp, OID_AUTO, stroke_maturity_threshold, CTLFLAG_RWTUN,
231 &atp_stroke_maturity_threshold, 4,
232 "the minimum age of a stroke for it to be considered mature");
234 typedef enum atp_trackpad_family {
235 TRACKPAD_FAMILY_FOUNTAIN_GEYSER,
236 TRACKPAD_FAMILY_WELLSPRING,
237 TRACKPAD_FAMILY_MAX /* keep this at the tail end of the enumeration */
240 enum fountain_geyser_product {
247 FOUNTAIN_GEYSER_PRODUCT_MAX /* keep this at the end */
250 enum wellspring_product {
263 WELLSPRING_PRODUCT_MAX /* keep this at the end of the enumeration */
266 /* trackpad header types */
267 enum fountain_geyser_trackpad_type {
268 FG_TRACKPAD_TYPE_GEYSER1,
269 FG_TRACKPAD_TYPE_GEYSER2,
270 FG_TRACKPAD_TYPE_GEYSER3,
271 FG_TRACKPAD_TYPE_GEYSER4,
273 enum wellspring_trackpad_type {
274 WSP_TRACKPAD_TYPE1, /* plain trackpad */
275 WSP_TRACKPAD_TYPE2, /* button integrated in trackpad */
276 WSP_TRACKPAD_TYPE3 /* additional header fields since June 2013 */
280 * Trackpad family and product and family are encoded together in the
281 * driver_info value associated with a trackpad product.
283 #define N_PROD_BITS 8 /* Number of bits used to encode product */
284 #define ENCODE_DRIVER_INFO(FAMILY, PROD) \
285 (((FAMILY) << N_PROD_BITS) | (PROD))
286 #define DECODE_FAMILY_FROM_DRIVER_INFO(INFO) ((INFO) >> N_PROD_BITS)
287 #define DECODE_PRODUCT_FROM_DRIVER_INFO(INFO) \
288 ((INFO) & ((1 << N_PROD_BITS) - 1))
290 #define FG_DRIVER_INFO(PRODUCT) \
291 ENCODE_DRIVER_INFO(TRACKPAD_FAMILY_FOUNTAIN_GEYSER, PRODUCT)
292 #define WELLSPRING_DRIVER_INFO(PRODUCT) \
293 ENCODE_DRIVER_INFO(TRACKPAD_FAMILY_WELLSPRING, PRODUCT)
296 * The following structure captures the state of a pressure span along
297 * an axis. Each contact with the touchpad results in separate
298 * pressure spans along the two axes.
300 typedef struct fg_pspan {
301 u_int width; /* in units of sensors */
302 u_int cum; /* cumulative compression (from all sensors) */
303 u_int cog; /* center of gravity */
304 u_int loc; /* location (scaled using the mickeys factor) */
305 boolean_t matched; /* to track pspans as they match against strokes. */
308 #define FG_MAX_PSPANS_PER_AXIS 3
309 #define FG_MAX_STROKES (2 * FG_MAX_PSPANS_PER_AXIS)
311 #define WELLSPRING_INTERFACE_INDEX 1
313 /* trackpad finger data offsets, le16-aligned */
314 #define WSP_TYPE1_FINGER_DATA_OFFSET (13 * 2)
315 #define WSP_TYPE2_FINGER_DATA_OFFSET (15 * 2)
316 #define WSP_TYPE3_FINGER_DATA_OFFSET (19 * 2)
318 /* trackpad button data offsets */
319 #define WSP_TYPE2_BUTTON_DATA_OFFSET 15
320 #define WSP_TYPE3_BUTTON_DATA_OFFSET 23
322 /* list of device capability bits */
323 #define HAS_INTEGRATED_BUTTON 1
325 /* trackpad finger structure - little endian */
326 struct wsp_finger_sensor_data {
327 int16_t origin; /* zero when switching track finger */
328 int16_t abs_x; /* absolute x coordinate */
329 int16_t abs_y; /* absolute y coordinate */
330 int16_t rel_x; /* relative x coordinate */
331 int16_t rel_y; /* relative y coordinate */
332 int16_t tool_major; /* tool area, major axis */
333 int16_t tool_minor; /* tool area, minor axis */
334 int16_t orientation; /* 16384 when point, else 15 bit angle */
335 int16_t touch_major; /* touch area, major axis */
336 int16_t touch_minor; /* touch area, minor axis */
337 int16_t unused[3]; /* zeros */
338 int16_t multi; /* one finger: varies, more fingers: constant */
341 typedef struct wsp_finger {
342 /* to track fingers as they match against strokes. */
345 /* location (scaled using the mickeys factor) */
350 #define WSP_MAX_FINGERS 16
351 #define WSP_SIZEOF_FINGER_SENSOR_DATA sizeof(struct wsp_finger_sensor_data)
352 #define WSP_SIZEOF_ALL_FINGER_DATA (WSP_MAX_FINGERS * \
353 WSP_SIZEOF_FINGER_SENSOR_DATA)
354 #define WSP_MAX_FINGER_ORIENTATION 16384
356 #define ATP_SENSOR_DATA_BUF_MAX 1024
357 #if (ATP_SENSOR_DATA_BUF_MAX < ((WSP_MAX_FINGERS * 14 * 2) + \
358 WSP_TYPE3_FINGER_DATA_OFFSET))
359 /* note: 14 * 2 in the above is based on sizeof(struct wsp_finger_sensor_data)*/
360 #error "ATP_SENSOR_DATA_BUF_MAX is too small"
363 #define ATP_MAX_STROKES MAX(WSP_MAX_FINGERS, FG_MAX_STROKES)
365 #define FG_MAX_XSENSORS 26
366 #define FG_MAX_YSENSORS 16
368 /* device-specific configuration */
369 struct fg_dev_params {
370 u_int data_len; /* for sensor data */
373 enum fountain_geyser_trackpad_type prot;
375 struct wsp_dev_params {
376 uint8_t caps; /* device capability bitmask */
377 uint8_t tp_type; /* type of trackpad interface */
378 uint8_t finger_data_offset; /* offset to trackpad finger data */
381 static const struct fg_dev_params fg_dev_params[FOUNTAIN_GEYSER_PRODUCT_MAX] = {
386 .prot = FG_TRACKPAD_TYPE_GEYSER1
392 .prot = FG_TRACKPAD_TYPE_GEYSER1
398 .prot = FG_TRACKPAD_TYPE_GEYSER1
404 .prot = FG_TRACKPAD_TYPE_GEYSER2
410 .prot = FG_TRACKPAD_TYPE_GEYSER3
416 .prot = FG_TRACKPAD_TYPE_GEYSER4
420 static const STRUCT_USB_HOST_ID fg_devs[] = {
421 /* PowerBooks Feb 2005, iBooks G4 */
422 { USB_VPI(USB_VENDOR_APPLE, 0x020e, FG_DRIVER_INFO(FOUNTAIN)) },
423 { USB_VPI(USB_VENDOR_APPLE, 0x020f, FG_DRIVER_INFO(FOUNTAIN)) },
424 { USB_VPI(USB_VENDOR_APPLE, 0x0210, FG_DRIVER_INFO(FOUNTAIN)) },
425 { USB_VPI(USB_VENDOR_APPLE, 0x030a, FG_DRIVER_INFO(FOUNTAIN)) },
426 { USB_VPI(USB_VENDOR_APPLE, 0x030b, FG_DRIVER_INFO(GEYSER1)) },
428 /* PowerBooks Oct 2005 */
429 { USB_VPI(USB_VENDOR_APPLE, 0x0214, FG_DRIVER_INFO(GEYSER2)) },
430 { USB_VPI(USB_VENDOR_APPLE, 0x0215, FG_DRIVER_INFO(GEYSER2)) },
431 { USB_VPI(USB_VENDOR_APPLE, 0x0216, FG_DRIVER_INFO(GEYSER2)) },
433 /* Core Duo MacBook & MacBook Pro */
434 { USB_VPI(USB_VENDOR_APPLE, 0x0217, FG_DRIVER_INFO(GEYSER3)) },
435 { USB_VPI(USB_VENDOR_APPLE, 0x0218, FG_DRIVER_INFO(GEYSER3)) },
436 { USB_VPI(USB_VENDOR_APPLE, 0x0219, FG_DRIVER_INFO(GEYSER3)) },
438 /* Core2 Duo MacBook & MacBook Pro */
439 { USB_VPI(USB_VENDOR_APPLE, 0x021a, FG_DRIVER_INFO(GEYSER4)) },
440 { USB_VPI(USB_VENDOR_APPLE, 0x021b, FG_DRIVER_INFO(GEYSER4)) },
441 { USB_VPI(USB_VENDOR_APPLE, 0x021c, FG_DRIVER_INFO(GEYSER4)) },
443 /* Core2 Duo MacBook3,1 */
444 { USB_VPI(USB_VENDOR_APPLE, 0x0229, FG_DRIVER_INFO(GEYSER4)) },
445 { USB_VPI(USB_VENDOR_APPLE, 0x022a, FG_DRIVER_INFO(GEYSER4)) },
446 { USB_VPI(USB_VENDOR_APPLE, 0x022b, FG_DRIVER_INFO(GEYSER4)) },
448 /* 17 inch PowerBook */
449 { USB_VPI(USB_VENDOR_APPLE, 0x020d, FG_DRIVER_INFO(GEYSER1_17inch)) },
452 static const struct wsp_dev_params wsp_dev_params[WELLSPRING_PRODUCT_MAX] = {
455 .tp_type = WSP_TRACKPAD_TYPE1,
456 .finger_data_offset = WSP_TYPE1_FINGER_DATA_OFFSET,
460 .tp_type = WSP_TRACKPAD_TYPE1,
461 .finger_data_offset = WSP_TYPE1_FINGER_DATA_OFFSET,
464 .caps = HAS_INTEGRATED_BUTTON,
465 .tp_type = WSP_TRACKPAD_TYPE2,
466 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
469 .caps = HAS_INTEGRATED_BUTTON,
470 .tp_type = WSP_TRACKPAD_TYPE2,
471 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
474 .caps = HAS_INTEGRATED_BUTTON,
475 .tp_type = WSP_TRACKPAD_TYPE2,
476 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
479 .caps = HAS_INTEGRATED_BUTTON,
480 .tp_type = WSP_TRACKPAD_TYPE2,
481 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
484 .caps = HAS_INTEGRATED_BUTTON,
485 .tp_type = WSP_TRACKPAD_TYPE2,
486 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
489 .caps = HAS_INTEGRATED_BUTTON,
490 .tp_type = WSP_TRACKPAD_TYPE2,
491 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
494 .caps = HAS_INTEGRATED_BUTTON,
495 .tp_type = WSP_TRACKPAD_TYPE2,
496 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
499 .caps = HAS_INTEGRATED_BUTTON,
500 .tp_type = WSP_TRACKPAD_TYPE2,
501 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
504 .caps = HAS_INTEGRATED_BUTTON,
505 .tp_type = WSP_TRACKPAD_TYPE2,
506 .finger_data_offset = WSP_TYPE2_FINGER_DATA_OFFSET,
509 .caps = HAS_INTEGRATED_BUTTON,
510 .tp_type = WSP_TRACKPAD_TYPE3,
511 .finger_data_offset = WSP_TYPE3_FINGER_DATA_OFFSET,
515 #define ATP_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }
517 /* TODO: STRUCT_USB_HOST_ID */
518 static const struct usb_device_id wsp_devs[] = {
520 ATP_DEV(APPLE, WELLSPRING_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING1)),
521 ATP_DEV(APPLE, WELLSPRING_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING1)),
522 ATP_DEV(APPLE, WELLSPRING_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING1)),
524 /* MacbookProPenryn, aka wellspring2 */
525 ATP_DEV(APPLE, WELLSPRING2_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING2)),
526 ATP_DEV(APPLE, WELLSPRING2_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING2)),
527 ATP_DEV(APPLE, WELLSPRING2_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING2)),
529 /* Macbook5,1 (unibody), aka wellspring3 */
530 ATP_DEV(APPLE, WELLSPRING3_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING3)),
531 ATP_DEV(APPLE, WELLSPRING3_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING3)),
532 ATP_DEV(APPLE, WELLSPRING3_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING3)),
534 /* MacbookAir3,2 (unibody), aka wellspring4 */
535 ATP_DEV(APPLE, WELLSPRING4_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING4)),
536 ATP_DEV(APPLE, WELLSPRING4_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING4)),
537 ATP_DEV(APPLE, WELLSPRING4_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING4)),
539 /* MacbookAir3,1 (unibody), aka wellspring4 */
540 ATP_DEV(APPLE, WELLSPRING4A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING4A)),
541 ATP_DEV(APPLE, WELLSPRING4A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING4A)),
542 ATP_DEV(APPLE, WELLSPRING4A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING4A)),
544 /* Macbook8 (unibody, March 2011) */
545 ATP_DEV(APPLE, WELLSPRING5_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING5)),
546 ATP_DEV(APPLE, WELLSPRING5_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING5)),
547 ATP_DEV(APPLE, WELLSPRING5_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING5)),
549 /* MacbookAir4,1 (unibody, July 2011) */
550 ATP_DEV(APPLE, WELLSPRING6A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING6A)),
551 ATP_DEV(APPLE, WELLSPRING6A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING6A)),
552 ATP_DEV(APPLE, WELLSPRING6A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING6A)),
554 /* MacbookAir4,2 (unibody, July 2011) */
555 ATP_DEV(APPLE, WELLSPRING6_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING6)),
556 ATP_DEV(APPLE, WELLSPRING6_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING6)),
557 ATP_DEV(APPLE, WELLSPRING6_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING6)),
559 /* Macbook8,2 (unibody) */
560 ATP_DEV(APPLE, WELLSPRING5A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING5A)),
561 ATP_DEV(APPLE, WELLSPRING5A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING5A)),
562 ATP_DEV(APPLE, WELLSPRING5A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING5A)),
564 /* MacbookPro10,1 (unibody, June 2012) */
565 /* MacbookPro11,? (unibody, June 2013) */
566 ATP_DEV(APPLE, WELLSPRING7_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING7)),
567 ATP_DEV(APPLE, WELLSPRING7_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING7)),
568 ATP_DEV(APPLE, WELLSPRING7_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING7)),
570 /* MacbookPro10,2 (unibody, October 2012) */
571 ATP_DEV(APPLE, WELLSPRING7A_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING7A)),
572 ATP_DEV(APPLE, WELLSPRING7A_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING7A)),
573 ATP_DEV(APPLE, WELLSPRING7A_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING7A)),
575 /* MacbookAir6,2 (unibody, June 2013) */
576 ATP_DEV(APPLE, WELLSPRING8_ANSI, WELLSPRING_DRIVER_INFO(WELLSPRING8)),
577 ATP_DEV(APPLE, WELLSPRING8_ISO, WELLSPRING_DRIVER_INFO(WELLSPRING8)),
578 ATP_DEV(APPLE, WELLSPRING8_JIS, WELLSPRING_DRIVER_INFO(WELLSPRING8)),
581 typedef enum atp_stroke_type {
586 typedef enum atp_axis {
592 #define ATP_FIFO_BUF_SIZE 8 /* bytes */
593 #define ATP_FIFO_QUEUE_MAXLEN 50 /* units */
601 typedef struct fg_stroke_component {
602 /* Fields encapsulating the pressure-span. */
603 u_int loc; /* location (scaled) */
604 u_int cum_pressure; /* cumulative compression */
605 u_int max_cum_pressure; /* max cumulative compression */
606 boolean_t matched; /*to track components as they match against pspans.*/
608 int delta_mickeys; /* change in location (un-smoothened movement)*/
609 } fg_stroke_component_t;
612 * The following structure captures a finger contact with the
613 * touchpad. A stroke comprises two p-span components and some state.
615 typedef struct atp_stroke {
616 TAILQ_ENTRY(atp_stroke) entry;
618 atp_stroke_type type;
619 uint32_t flags; /* the state of this stroke */
620 #define ATSF_ZOMBIE 0x1
621 boolean_t matched; /* to track match against fingers.*/
623 struct timeval ctime; /* create time; for coincident siblings. */
626 * Unit: interrupts; we maintain this value in
627 * addition to 'ctime' in order to avoid the
628 * expensive call to microtime() at every
637 /* Fields containing information about movement. */
638 int instantaneous_dx; /* curr. change in X location (un-smoothened) */
639 int instantaneous_dy; /* curr. change in Y location (un-smoothened) */
640 int pending_dx; /* cum. of pending short movements */
641 int pending_dy; /* cum. of pending short movements */
642 int movement_dx; /* interpreted smoothened movement */
643 int movement_dy; /* interpreted smoothened movement */
644 int cum_movement_x; /* cum. horizontal movement */
645 int cum_movement_y; /* cum. vertical movement */
648 * The following member is relevant only for fountain-geyser trackpads.
649 * For these, there is the need to track pressure-spans and cumulative
650 * pressures for stroke components.
652 fg_stroke_component_t components[NUM_AXES];
655 struct atp_softc; /* forward declaration */
656 typedef void (*sensor_data_interpreter_t)(struct atp_softc *sc, u_int len);
660 struct usb_device *sc_usb_device;
661 struct mtx sc_mutex; /* for synchronization */
662 struct usb_fifo_sc sc_fifo;
664 #define MODE_LENGTH 8
665 char sc_mode_bytes[MODE_LENGTH]; /* device mode */
667 trackpad_family_t sc_family;
668 const void *sc_params; /* device configuration */
669 sensor_data_interpreter_t sensor_data_interpreter;
673 mousestatus_t sc_status;
676 #define ATP_ENABLED 0x01
677 #define ATP_ZOMBIES_EXIST 0x02
678 #define ATP_DOUBLE_TAP_DRAG 0x04
679 #define ATP_VALID 0x08
681 struct usb_xfer *sc_xfer[ATP_N_TRANSFER];
686 atp_stroke_t sc_strokes_data[ATP_MAX_STROKES];
687 TAILQ_HEAD(,atp_stroke) sc_stroke_free;
688 TAILQ_HEAD(,atp_stroke) sc_stroke_used;
691 struct callout sc_callout;
694 * button status. Set to non-zero if the mouse-button is physically
695 * pressed. This state variable is exposed through softc to allow
696 * reap_sibling_zombies to avoid registering taps while the trackpad
702 * Time when touch zombies were last reaped; useful for detecting
703 * double-touch-n-drag.
705 struct timeval sc_touch_reap_time;
709 /* Regarding the data transferred from t-pad in USB INTR packets. */
710 u_int sc_expected_sensor_data_len;
711 uint8_t sc_sensor_data[ATP_SENSOR_DATA_BUF_MAX] __aligned(4);
713 int sc_cur_x[FG_MAX_XSENSORS]; /* current sensor readings */
714 int sc_cur_y[FG_MAX_YSENSORS];
715 int sc_base_x[FG_MAX_XSENSORS]; /* base sensor readings */
716 int sc_base_y[FG_MAX_YSENSORS];
717 int sc_pressure_x[FG_MAX_XSENSORS]; /* computed pressures */
718 int sc_pressure_y[FG_MAX_YSENSORS];
719 fg_pspan sc_pspans_x[FG_MAX_PSPANS_PER_AXIS];
720 fg_pspan sc_pspans_y[FG_MAX_PSPANS_PER_AXIS];
724 * The last byte of the fountain-geyser sensor data contains status bits; the
725 * following values define the meanings of these bits.
728 enum geyser34_status_bits {
729 FG_STATUS_BUTTON = (uint8_t)0x01, /* The button was pressed */
730 FG_STATUS_BASE_UPDATE = (uint8_t)0x04, /* Data from an untouched pad.*/
733 typedef enum interface_mode {
734 RAW_SENSOR_MODE = (uint8_t)0x01,
735 HID_MODE = (uint8_t)0x08
740 * function prototypes
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;
748 static struct usb_fifo_methods atp_fifo_methods = {
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,
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 *);
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);
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,
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 *);
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 *);
800 static void atp_reset_buf(struct atp_softc *);
801 static void atp_add_to_queue(struct atp_softc *, int, int, int, uint32_t);
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;
809 static const struct usb_config atp_xfer_config[ATP_N_TRANSFER] = {
811 .type = UE_INTERRUPT,
812 .endpoint = UE_ADDR_ANY,
813 .direction = UE_DIR_IN,
815 .pipe_bof = 1, /* block pipe on failure */
818 .bufsize = ATP_SENSOR_DATA_BUF_MAX,
819 .callback = &atp_intr,
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 */
831 static atp_stroke_t *
832 atp_alloc_stroke(struct atp_softc *sc)
834 atp_stroke_t *pstroke;
836 pstroke = TAILQ_FIRST(&sc->sc_stroke_free);
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);
850 atp_free_stroke(struct atp_softc *sc, atp_stroke_t *pstroke)
857 TAILQ_REMOVE(&sc->sc_stroke_used, pstroke, entry);
858 TAILQ_INSERT_TAIL(&sc->sc_stroke_free, pstroke, entry);
862 atp_init_stroke_pool(struct atp_softc *sc)
866 TAILQ_INIT(&sc->sc_stroke_free);
867 TAILQ_INIT(&sc->sc_stroke_used);
869 sc->sc_n_strokes = 0;
871 memset(&sc->sc_strokes_data, 0, sizeof(sc->sc_strokes_data));
873 for (x = 0; x != ATP_MAX_STROKES; x++) {
874 TAILQ_INSERT_TAIL(&sc->sc_stroke_free, &sc->sc_strokes_data[x],
880 atp_set_device_mode(struct atp_softc *sc, interface_mode newMode)
885 if ((newMode != RAW_SENSOR_MODE) && (newMode != HID_MODE))
886 return (USB_ERR_INVAL);
888 if ((newMode == RAW_SENSOR_MODE) &&
889 (sc->sc_family == TRACKPAD_FAMILY_FOUNTAIN_GEYSER))
890 mode_value = (uint8_t)0x04;
892 mode_value = newMode;
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);
902 if (sc->sc_mode_bytes[0] == mode_value)
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
911 pause("WHW", hz / 4);
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 */));
920 atp_reset_callback(struct usb_xfer *xfer, usb_error_t error)
922 usb_device_request_t req;
923 struct usb_page_cache *pc;
924 struct atp_softc *sc = usbd_xfer_softc(xfer);
927 if (sc->sc_family == TRACKPAD_FAMILY_FOUNTAIN_GEYSER)
930 mode_value = RAW_SENSOR_MODE;
932 switch (USB_GET_STATE(xfer)) {
934 sc->sc_mode_bytes[0] = mode_value;
935 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
936 req.bRequest = UR_SET_REPORT;
938 (uint8_t)0x03 /* type */, (uint8_t)0x00 /* id */);
939 USETW(req.wIndex, 0);
940 USETW(req.wLength, MODE_LENGTH);
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);
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);
953 case USB_ST_TRANSFERRED:
960 atp_enable(struct atp_softc *sc)
962 if (sc->sc_state & ATP_ENABLED)
966 memset(&sc->sc_status, 0, sizeof(sc->sc_status));
968 atp_init_stroke_pool(sc);
970 sc->sc_state |= ATP_ENABLED;
972 DPRINTFN(ATP_LLEVEL_INFO, "enabled atp\n");
977 atp_disable(struct atp_softc *sc)
979 sc->sc_state &= ~(ATP_ENABLED | ATP_VALID);
980 DPRINTFN(ATP_LLEVEL_INFO, "disabled atp\n");
984 fg_interpret_sensor_data(struct atp_softc *sc, u_int data_len)
990 const struct fg_dev_params *params =
991 (const struct fg_dev_params *)sc->sc_params;
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);
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.
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;
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);
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;
1032 sc->sc_ibtn = (status_bits & FG_STATUS_BUTTON) ? MOUSE_BUTTON1DOWN : 0;
1033 sc->sc_status.button = sc->sc_ibtn;
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
1042 if ((sc->sc_status.flags == 0) && (sc->sc_n_strokes == 0)) {
1044 if (sc->sc_idlecount >= ATP_IDLENESS_THRESHOLD) {
1046 * Use the last frame before we go idle for
1047 * calibration on pads which do not send
1048 * calibration frames.
1050 const struct fg_dev_params *params =
1051 (const struct fg_dev_params *)sc->sc_params;
1053 DPRINTFN(ATP_LLEVEL_INFO, "idle\n");
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)));
1062 sc->sc_idlecount = 0;
1063 usbd_transfer_start(sc->sc_xfer[ATP_RESET]);
1066 sc->sc_idlecount = 0;
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:
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
1079 * '--' (in the above) indicates that the value is unimportant.
1081 * Information about the above layout was obtained from the
1082 * implementation of the AppleTouch driver in Linux.
1086 * raw sensor data from the USB packet.
1088 * The number of elements in the array 'arr'.
1090 * Axis of data to fetch
1092 * The array to be initialized with the readings.
1094 * The protocol to use to interpret the data
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)
1101 u_int di; /* index into sensor data */
1104 case FG_TRACKPAD_TYPE_GEYSER1:
1106 * For Geyser 1, the sensors are laid out in pairs
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];
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++];
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++];
1138 fg_get_pressures(int *p, const int *cur, const int *base, int n)
1142 for (i = 0; i < n; i++) {
1143 p[i] = cur[i] - base[i];
1152 * Shave off pressures below the noise-pressure
1153 * threshold; this will reduce the contribution from
1154 * lower pressure readings.
1156 if ((u_int)p[i] <= FG_SENSOR_NOISE_THRESHOLD)
1157 p[i] = 0; /* filter away noise */
1159 p[i] -= FG_SENSOR_NOISE_THRESHOLD;
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 */
1170 int maxp; /* max pressure seen within a span */
1171 u_int num_spans = 0;
1173 enum fg_pspan_state {
1175 ATP_PSPAN_INCREASING,
1176 ATP_PSPAN_DECREASING,
1177 } state; /* state of the pressure span */
1180 * The following is a simple state machine to track
1181 * the phase of the pressure span.
1183 memset(spans, 0, max_spans * sizeof(fg_pspan));
1185 state = ATP_PSPAN_INACTIVE;
1186 for (i = 0; i < num_sensors; i++) {
1187 if (num_spans >= max_spans)
1191 if (state == ATP_PSPAN_INACTIVE) {
1193 * There is no pressure information for this
1194 * sensor, and we aren't tracking a finger.
1198 state = ATP_PSPAN_INACTIVE;
1204 case ATP_PSPAN_INACTIVE:
1205 state = ATP_PSPAN_INCREASING;
1209 case ATP_PSPAN_INCREASING:
1212 else if (p[i] <= (maxp >> 1))
1213 state = ATP_PSPAN_DECREASING;
1216 case ATP_PSPAN_DECREASING:
1217 if (p[i] > p[i - 1]) {
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.
1228 state = ATP_PSPAN_INACTIVE;
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);
1242 if (state != ATP_PSPAN_INACTIVE)
1243 num_spans++; /* close the last finger span */
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));
1259 /* compute this span's representative location */
1260 spans[i].loc = spans[i].cog * FG_SCALE_FACTOR /
1263 spans[i].matched = false; /* not yet matched against a stroke */
1266 *nspans_p = num_spans;
1270 wsp_interpret_sensor_data(struct atp_softc *sc, u_int data_len)
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;
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)
1285 /* compute number of source fingers */
1286 n_source_fingers = (data_len - params->finger_data_offset) /
1287 WSP_SIZEOF_FINGER_SENSOR_DATA;
1289 if (n_source_fingers > WSP_MAX_FINGERS)
1290 n_source_fingers = WSP_MAX_FINGERS;
1292 /* iterate over the source data collecting useful fingers */
1294 source_fingerp = (struct wsp_finger_sensor_data *)(sc->sc_sensor_data +
1295 params->finger_data_offset);
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);
1313 /* check for minium threshold */
1314 if (source_fingerp->touch_major == 0)
1317 fingers[n_fingers].matched = false;
1318 fingers[n_fingers].x = source_fingerp->abs_x;
1319 fingers[n_fingers].y = -source_fingerp->abs_y;
1324 if ((sc->sc_n_strokes == 0) && (n_fingers == 0))
1327 if (wsp_update_strokes(sc, fingers, n_fingers))
1328 sc->sc_status.flags |= MOUSE_POSCHANGED;
1330 switch(params->tp_type) {
1331 case WSP_TRACKPAD_TYPE2:
1332 sc->sc_ibtn = sc->sc_sensor_data[WSP_TYPE2_BUTTON_DATA_OFFSET];
1334 case WSP_TRACKPAD_TYPE3:
1335 sc->sc_ibtn = sc->sc_sensor_data[WSP_TYPE3_BUTTON_DATA_OFFSET];
1340 sc->sc_status.button = sc->sc_ibtn ? MOUSE_BUTTON1DOWN : 0;
1344 * Match a pressure-span against a stroke-component. If there is a
1345 * match, update the component's state and return true.
1348 fg_match_stroke_component(fg_stroke_component_t *component,
1349 const fg_pspan *pspan, atp_stroke_type stroke_type)
1354 delta_mickeys = pspan->loc - component->loc;
1356 if (abs(delta_mickeys) > (int)FG_MAX_DELTA_MICKEYS)
1357 return (false); /* the finger span is too far out; no match */
1359 component->loc = pspan->loc;
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.
1369 if (pspan->cum > ((3 * component->cum_pressure) >> 1))
1372 component->cum_pressure = pspan->cum;
1373 if (pspan->cum > component->max_cum_pressure)
1374 component->max_cum_pressure = pspan->cum;
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.
1381 if (stroke_type == ATP_STROKE_TOUCH)
1382 min_pressure = (3 * component->max_cum_pressure) >> 2;
1384 min_pressure = component->max_cum_pressure >> 2;
1385 if (component->cum_pressure < min_pressure)
1388 component->delta_mickeys = delta_mickeys;
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)
1396 atp_stroke_t *strokep;
1397 u_int repeat_index = 0;
1400 /* Determine the index of the multi-span. */
1402 for (i = 0; i < n_pspans; i++) {
1403 if (pspans[i].cum > pspans[repeat_index].cum)
1408 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
1409 if (strokep->components[axis].matched)
1410 continue; /* skip matched components */
1412 for (i = 0; i < n_pspans; i++) {
1413 if (pspans[i].matched)
1414 continue; /* skip matched pspans */
1416 if (fg_match_stroke_component(
1417 &strokep->components[axis], &pspans[i],
1420 /* There is a match. */
1421 strokep->components[axis].matched = true;
1423 /* Take care to repeat at the multi-span. */
1424 if ((repeat_count > 0) && (i == repeat_index))
1427 pspans[i].matched = true;
1429 break; /* skip to the next strokep */
1431 } /* loop over pspans */
1432 } /* loop over strokes */
1436 wsp_match_strokes_against_fingers(struct atp_softc *sc,
1437 wsp_finger_t *fingers, u_int n_fingers)
1439 boolean_t movement = false;
1440 atp_stroke_t *strokep;
1443 /* reset the matched status for all strokes */
1444 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry)
1445 strokep->matched = false;
1447 for (i = 0; i != n_fingers; i++) {
1448 u_int least_distance_sq = WSP_MAX_ALLOWED_MATCH_DISTANCE_SQ;
1449 atp_stroke_t *strokep_best = NULL;
1451 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
1452 int instantaneous_dx;
1453 int instantaneous_dy;
1456 if (strokep->matched)
1459 instantaneous_dx = fingers[i].x - strokep->x;
1460 instantaneous_dy = fingers[i].y - strokep->y;
1462 /* skip strokes which are far away */
1464 (instantaneous_dx * instantaneous_dx) +
1465 (instantaneous_dy * instantaneous_dy);
1467 if (d_squared < least_distance_sq) {
1468 least_distance_sq = d_squared;
1469 strokep_best = strokep;
1473 strokep = strokep_best;
1475 if (strokep != NULL) {
1476 fingers[i].matched = true;
1478 strokep->matched = true;
1479 strokep->instantaneous_dx = fingers[i].x - strokep->x;
1480 strokep->instantaneous_dy = fingers[i].y - strokep->y;
1481 strokep->x = fingers[i].x;
1482 strokep->y = fingers[i].y;
1484 atp_advance_stroke_state(sc, strokep, &movement);
1491 * Update strokes by matching against current pressure-spans.
1492 * Return true if any movement is detected.
1495 fg_update_strokes(struct atp_softc *sc, fg_pspan *pspans_x,
1496 u_int n_xpspans, fg_pspan *pspans_y, u_int n_ypspans)
1498 atp_stroke_t *strokep;
1499 atp_stroke_t *strokep_next;
1500 boolean_t movement = false;
1501 u_int repeat_count = 0;
1505 /* Reset X and Y components of all strokes as unmatched. */
1506 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
1507 strokep->components[X].matched = false;
1508 strokep->components[Y].matched = false;
1512 * Usually, the X and Y pspans come in pairs (the common case
1513 * being a single pair). It is possible, however, that
1514 * multiple contacts resolve to a single pspan along an
1515 * axis, as illustrated in the following:
1517 * F = finger-contact
1520 * +-----------------------+
1525 * pspan |.........F......F |
1529 * +-----------------------+
1532 * The above case can be detected by a difference in the
1533 * number of X and Y pspans. When this happens, X and Y pspans
1534 * aren't easy to pair or match against strokes.
1536 * When X and Y pspans differ in number, the axis with the
1537 * smaller number of pspans is regarded as having a repeating
1538 * pspan (or a multi-pspan)--in the above illustration, the
1539 * Y-axis has a repeating pspan. Our approach is to try to
1540 * match the multi-pspan repeatedly against strokes. The
1541 * difference between the number of X and Y pspans gives us a
1542 * crude repeat_count for matching multi-pspans--i.e. the
1543 * multi-pspan along the Y axis (above) has a repeat_count of 1.
1545 repeat_count = abs(n_xpspans - n_ypspans);
1547 fg_match_strokes_against_pspans(sc, X, pspans_x, n_xpspans,
1548 (((repeat_count != 0) && ((n_xpspans < n_ypspans))) ?
1550 fg_match_strokes_against_pspans(sc, Y, pspans_y, n_ypspans,
1551 (((repeat_count != 0) && (n_ypspans < n_xpspans)) ?
1554 /* Update the state of strokes based on the above pspan matches. */
1555 TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) {
1557 if (strokep->components[X].matched &&
1558 strokep->components[Y].matched) {
1559 strokep->matched = true;
1560 strokep->instantaneous_dx =
1561 strokep->components[X].delta_mickeys;
1562 strokep->instantaneous_dy =
1563 strokep->components[Y].delta_mickeys;
1564 atp_advance_stroke_state(sc, strokep, &movement);
1567 * At least one component of this stroke
1568 * didn't match against current pspans;
1571 atp_terminate_stroke(sc, strokep);
1575 /* Add new strokes for pairs of unmatched pspans */
1576 for (i = 0; i < n_xpspans; i++) {
1577 if (pspans_x[i].matched == false) break;
1579 for (j = 0; j < n_ypspans; j++) {
1580 if (pspans_y[j].matched == false) break;
1582 if ((i < n_xpspans) && (j < n_ypspans)) {
1584 if (atp_debug >= ATP_LLEVEL_INFO) {
1585 printf("unmatched pspans:");
1586 for (; i < n_xpspans; i++) {
1587 if (pspans_x[i].matched)
1589 printf(" X:[loc:%u,cum:%u]",
1590 pspans_x[i].loc, pspans_x[i].cum);
1592 for (; j < n_ypspans; j++) {
1593 if (pspans_y[j].matched)
1595 printf(" Y:[loc:%u,cum:%u]",
1596 pspans_y[j].loc, pspans_y[j].cum);
1600 #endif /* USB_DEBUG */
1601 if ((n_xpspans == 1) && (n_ypspans == 1))
1602 /* The common case of a single pair of new pspans. */
1603 fg_add_stroke(sc, &pspans_x[0], &pspans_y[0]);
1605 fg_add_new_strokes(sc, pspans_x, n_xpspans,
1606 pspans_y, n_ypspans);
1610 if (atp_debug >= ATP_LLEVEL_INFO) {
1611 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
1612 printf(" %s%clc:%u,dm:%d,cum:%d,max:%d,%c"
1613 ",%clc:%u,dm:%d,cum:%d,max:%d,%c",
1614 (strokep->flags & ATSF_ZOMBIE) ? "zomb:" : "",
1615 (strokep->type == ATP_STROKE_TOUCH) ? '[' : '<',
1616 strokep->components[X].loc,
1617 strokep->components[X].delta_mickeys,
1618 strokep->components[X].cum_pressure,
1619 strokep->components[X].max_cum_pressure,
1620 (strokep->type == ATP_STROKE_TOUCH) ? ']' : '>',
1621 (strokep->type == ATP_STROKE_TOUCH) ? '[' : '<',
1622 strokep->components[Y].loc,
1623 strokep->components[Y].delta_mickeys,
1624 strokep->components[Y].cum_pressure,
1625 strokep->components[Y].max_cum_pressure,
1626 (strokep->type == ATP_STROKE_TOUCH) ? ']' : '>');
1628 if (TAILQ_FIRST(&sc->sc_stroke_used) != NULL)
1631 #endif /* USB_DEBUG */
1636 * Update strokes by matching against current pressure-spans.
1637 * Return true if any movement is detected.
1640 wsp_update_strokes(struct atp_softc *sc, wsp_finger_t *fingers, u_int n_fingers)
1642 boolean_t movement = false;
1643 atp_stroke_t *strokep_next;
1644 atp_stroke_t *strokep;
1647 if (sc->sc_n_strokes > 0) {
1648 movement = wsp_match_strokes_against_fingers(
1649 sc, fingers, n_fingers);
1651 /* handle zombie strokes */
1652 TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) {
1653 if (strokep->matched)
1655 atp_terminate_stroke(sc, strokep);
1659 /* initialize unmatched fingers as strokes */
1660 for (i = 0; i != n_fingers; i++) {
1661 if (fingers[i].matched)
1664 wsp_add_stroke(sc, fingers + i);
1669 /* Initialize a stroke using a pressure-span. */
1671 fg_add_stroke(struct atp_softc *sc, const fg_pspan *pspan_x,
1672 const fg_pspan *pspan_y)
1674 atp_stroke_t *strokep;
1676 strokep = atp_alloc_stroke(sc);
1677 if (strokep == NULL)
1681 * Strokes begin as potential touches. If a stroke survives
1682 * longer than a threshold, or if it records significant
1683 * cumulative movement, then it is considered a 'slide'.
1685 strokep->type = ATP_STROKE_TOUCH;
1686 strokep->matched = false;
1687 microtime(&strokep->ctime);
1688 strokep->age = 1; /* number of interrupts */
1689 strokep->x = pspan_x->loc;
1690 strokep->y = pspan_y->loc;
1692 strokep->components[X].loc = pspan_x->loc;
1693 strokep->components[X].cum_pressure = pspan_x->cum;
1694 strokep->components[X].max_cum_pressure = pspan_x->cum;
1695 strokep->components[X].matched = true;
1697 strokep->components[Y].loc = pspan_y->loc;
1698 strokep->components[Y].cum_pressure = pspan_y->cum;
1699 strokep->components[Y].max_cum_pressure = pspan_y->cum;
1700 strokep->components[Y].matched = true;
1702 if (sc->sc_n_strokes > 1) {
1703 /* Reset double-tap-n-drag if we have more than one strokes. */
1704 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG;
1707 DPRINTFN(ATP_LLEVEL_INFO, "[%u,%u], time: %u,%ld\n",
1708 strokep->components[X].loc,
1709 strokep->components[Y].loc,
1710 (u_int)strokep->ctime.tv_sec,
1711 (unsigned long int)strokep->ctime.tv_usec);
1715 fg_add_new_strokes(struct atp_softc *sc, fg_pspan *pspans_x,
1716 u_int n_xpspans, fg_pspan *pspans_y, u_int n_ypspans)
1718 fg_pspan spans[2][FG_MAX_PSPANS_PER_AXIS];
1723 /* Copy unmatched pspans into the local arrays. */
1724 for (i = 0, nspans[X] = 0; i < n_xpspans; i++) {
1725 if (pspans_x[i].matched == false) {
1726 spans[X][nspans[X]] = pspans_x[i];
1730 for (j = 0, nspans[Y] = 0; j < n_ypspans; j++) {
1731 if (pspans_y[j].matched == false) {
1732 spans[Y][nspans[Y]] = pspans_y[j];
1737 if (nspans[X] == nspans[Y]) {
1738 /* Create new strokes from pairs of unmatched pspans */
1739 for (i = 0, j = 0; (i < nspans[X]) && (j < nspans[Y]); i++, j++)
1740 fg_add_stroke(sc, &spans[X][i], &spans[Y][j]);
1743 atp_axis repeat_axis; /* axis with multi-pspans */
1744 u_int repeat_count; /* repeat count for the multi-pspan*/
1745 u_int repeat_index = 0; /* index of the multi-span */
1747 repeat_axis = (nspans[X] > nspans[Y]) ? Y : X;
1748 repeat_count = abs(nspans[X] - nspans[Y]);
1749 for (i = 0; i < nspans[repeat_axis]; i++) {
1750 if (spans[repeat_axis][i].cum > cum) {
1752 cum = spans[repeat_axis][i].cum;
1756 /* Create new strokes from pairs of unmatched pspans */
1758 for (; (i < nspans[X]) && (j < nspans[Y]); i++, j++) {
1759 fg_add_stroke(sc, &spans[X][i], &spans[Y][j]);
1761 /* Take care to repeat at the multi-pspan. */
1762 if (repeat_count > 0) {
1763 if ((repeat_axis == X) &&
1764 (repeat_index == i)) {
1765 i--; /* counter loop increment */
1767 } else if ((repeat_axis == Y) &&
1768 (repeat_index == j)) {
1769 j--; /* counter loop increment */
1777 /* Initialize a stroke from an unmatched finger. */
1779 wsp_add_stroke(struct atp_softc *sc, const wsp_finger_t *fingerp)
1781 atp_stroke_t *strokep;
1783 strokep = atp_alloc_stroke(sc);
1784 if (strokep == NULL)
1788 * Strokes begin as potential touches. If a stroke survives
1789 * longer than a threshold, or if it records significant
1790 * cumulative movement, then it is considered a 'slide'.
1792 strokep->type = ATP_STROKE_TOUCH;
1793 strokep->matched = true;
1794 microtime(&strokep->ctime);
1795 strokep->age = 1; /* number of interrupts */
1796 strokep->x = fingerp->x;
1797 strokep->y = fingerp->y;
1799 /* Reset double-tap-n-drag if we have more than one strokes. */
1800 if (sc->sc_n_strokes > 1)
1801 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG;
1803 DPRINTFN(ATP_LLEVEL_INFO, "[%d,%d]\n", strokep->x, strokep->y);
1807 atp_advance_stroke_state(struct atp_softc *sc, atp_stroke_t *strokep,
1808 boolean_t *movementp)
1810 /* Revitalize stroke if it had previously been marked as a zombie. */
1811 if (strokep->flags & ATSF_ZOMBIE)
1812 strokep->flags &= ~ATSF_ZOMBIE;
1815 if (strokep->age <= atp_stroke_maturity_threshold) {
1816 /* Avoid noise from immature strokes. */
1817 strokep->instantaneous_dx = 0;
1818 strokep->instantaneous_dy = 0;
1821 if (atp_compute_stroke_movement(strokep))
1824 if (strokep->type != ATP_STROKE_TOUCH)
1827 /* Convert touch strokes to slides upon detecting movement or age. */
1828 if ((abs(strokep->cum_movement_x) > atp_slide_min_movement) ||
1829 (abs(strokep->cum_movement_y) > atp_slide_min_movement))
1830 atp_convert_to_slide(sc, strokep);
1832 /* Compute the stroke's age. */
1833 struct timeval tdiff;
1834 getmicrotime(&tdiff);
1835 if (timevalcmp(&tdiff, &strokep->ctime, >)) {
1836 timevalsub(&tdiff, &strokep->ctime);
1838 if ((tdiff.tv_sec > (atp_touch_timeout / 1000000)) ||
1839 ((tdiff.tv_sec == (atp_touch_timeout / 1000000)) &&
1840 (tdiff.tv_usec >= (atp_touch_timeout % 1000000))))
1841 atp_convert_to_slide(sc, strokep);
1847 atp_stroke_has_small_movement(const atp_stroke_t *strokep)
1849 return (((u_int)abs(strokep->instantaneous_dx) <=
1850 atp_small_movement_threshold) &&
1851 ((u_int)abs(strokep->instantaneous_dy) <=
1852 atp_small_movement_threshold));
1856 * Accumulate instantaneous changes into the stroke's 'pending' bucket; if
1857 * the aggregate exceeds the small_movement_threshold, then retain
1858 * instantaneous changes for later.
1861 atp_update_pending_mickeys(atp_stroke_t *strokep)
1863 /* accumulate instantaneous movement */
1864 strokep->pending_dx += strokep->instantaneous_dx;
1865 strokep->pending_dy += strokep->instantaneous_dy;
1867 #define UPDATE_INSTANTANEOUS_AND_PENDING(I, P) \
1868 if (abs((P)) <= atp_small_movement_threshold) \
1869 (I) = 0; /* clobber small movement */ \
1873 * Round up instantaneous movement to the nearest \
1874 * ceiling. This helps preserve small mickey \
1875 * movements from being lost in following scaling \
1878 (I) = (((I) + (atp_mickeys_scale_factor - 1)) / \
1879 atp_mickeys_scale_factor) * \
1880 atp_mickeys_scale_factor; \
1883 * Deduct the rounded mickeys from pending mickeys. \
1884 * Note: we multiply by 2 to offset the previous \
1885 * accumulation of instantaneous movement into \
1888 (P) -= ((I) << 1); \
1890 /* truncate pending to 0 if it becomes negative. */ \
1891 (P) = imax((P), 0); \
1894 * Round down instantaneous movement to the nearest \
1895 * ceiling. This helps preserve small mickey \
1896 * movements from being lost in following scaling \
1899 (I) = (((I) - (atp_mickeys_scale_factor - 1)) / \
1900 atp_mickeys_scale_factor) * \
1901 atp_mickeys_scale_factor; \
1904 * Deduct the rounded mickeys from pending mickeys. \
1905 * Note: we multiply by 2 to offset the previous \
1906 * accumulation of instantaneous movement into \
1909 (P) -= ((I) << 1); \
1911 /* truncate pending to 0 if it becomes positive. */ \
1912 (P) = imin((P), 0); \
1916 UPDATE_INSTANTANEOUS_AND_PENDING(strokep->instantaneous_dx,
1917 strokep->pending_dx);
1918 UPDATE_INSTANTANEOUS_AND_PENDING(strokep->instantaneous_dy,
1919 strokep->pending_dy);
1923 * Compute a smoothened value for the stroke's movement from
1924 * instantaneous changes in the X and Y components.
1927 atp_compute_stroke_movement(atp_stroke_t *strokep)
1930 * Short movements are added first to the 'pending' bucket,
1931 * and then acted upon only when their aggregate exceeds a
1932 * threshold. This has the effect of filtering away movement
1935 if (atp_stroke_has_small_movement(strokep))
1936 atp_update_pending_mickeys(strokep);
1937 else { /* large movement */
1938 /* clear away any pending mickeys if there are large movements*/
1939 strokep->pending_dx = 0;
1940 strokep->pending_dy = 0;
1943 /* scale movement */
1944 strokep->movement_dx = (strokep->instantaneous_dx) /
1945 (int)atp_mickeys_scale_factor;
1946 strokep->movement_dy = (strokep->instantaneous_dy) /
1947 (int)atp_mickeys_scale_factor;
1949 if ((abs(strokep->instantaneous_dx) >= ATP_FAST_MOVEMENT_TRESHOLD) ||
1950 (abs(strokep->instantaneous_dy) >= ATP_FAST_MOVEMENT_TRESHOLD)) {
1951 strokep->movement_dx <<= 1;
1952 strokep->movement_dy <<= 1;
1955 strokep->cum_movement_x += strokep->movement_dx;
1956 strokep->cum_movement_y += strokep->movement_dy;
1958 return ((strokep->movement_dx != 0) || (strokep->movement_dy != 0));
1962 * Terminate a stroke. Aside from immature strokes, a slide or touch is
1963 * retained as a zombies so as to reap all their termination siblings
1964 * together; this helps establish the number of fingers involved at the
1965 * end of a multi-touch gesture.
1968 atp_terminate_stroke(struct atp_softc *sc, atp_stroke_t *strokep)
1970 if (strokep->flags & ATSF_ZOMBIE)
1973 /* Drop immature strokes rightaway. */
1974 if (strokep->age <= atp_stroke_maturity_threshold) {
1975 atp_free_stroke(sc, strokep);
1979 strokep->flags |= ATSF_ZOMBIE;
1980 sc->sc_state |= ATP_ZOMBIES_EXIST;
1982 callout_reset(&sc->sc_callout, ATP_ZOMBIE_STROKE_REAP_INTERVAL,
1983 atp_reap_sibling_zombies, sc);
1986 * Reset the double-click-n-drag at the termination of any
1989 if (strokep->type == ATP_STROKE_SLIDE)
1990 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG;
1994 atp_is_horizontal_scroll(const atp_stroke_t *strokep)
1996 if (abs(strokep->cum_movement_x) < atp_slide_min_movement)
1998 if (strokep->cum_movement_y == 0)
2000 return (abs(strokep->cum_movement_x / strokep->cum_movement_y) >= 4);
2004 atp_is_vertical_scroll(const atp_stroke_t *strokep)
2006 if (abs(strokep->cum_movement_y) < atp_slide_min_movement)
2008 if (strokep->cum_movement_x == 0)
2010 return (abs(strokep->cum_movement_y / strokep->cum_movement_x) >= 4);
2014 atp_reap_sibling_zombies(void *arg)
2016 struct atp_softc *sc = (struct atp_softc *)arg;
2017 u_int8_t n_touches_reaped = 0;
2018 u_int8_t n_slides_reaped = 0;
2019 u_int8_t n_horizontal_scrolls = 0;
2020 u_int8_t n_vertical_scrolls = 0;
2021 int horizontal_scroll = 0;
2022 int vertical_scroll = 0;
2023 atp_stroke_t *strokep;
2024 atp_stroke_t *strokep_next;
2026 DPRINTFN(ATP_LLEVEL_INFO, "\n");
2028 TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) {
2029 if ((strokep->flags & ATSF_ZOMBIE) == 0)
2032 if (strokep->type == ATP_STROKE_TOUCH) {
2037 if (atp_is_horizontal_scroll(strokep)) {
2038 n_horizontal_scrolls++;
2039 horizontal_scroll += strokep->cum_movement_x;
2040 } else if (atp_is_vertical_scroll(strokep)) {
2041 n_vertical_scrolls++;
2042 vertical_scroll += strokep->cum_movement_y;
2046 atp_free_stroke(sc, strokep);
2049 DPRINTFN(ATP_LLEVEL_INFO, "reaped %u zombies\n",
2050 n_touches_reaped + n_slides_reaped);
2051 sc->sc_state &= ~ATP_ZOMBIES_EXIST;
2053 /* No further processing necessary if physical button is depressed. */
2054 if (sc->sc_ibtn != 0)
2057 if ((n_touches_reaped == 0) && (n_slides_reaped == 0))
2060 /* Add a pair of virtual button events (button-down and button-up) if
2061 * the physical button isn't pressed. */
2062 if (n_touches_reaped != 0) {
2063 if (n_touches_reaped < atp_tap_minimum)
2066 switch (n_touches_reaped) {
2068 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON1DOWN);
2069 microtime(&sc->sc_touch_reap_time); /* remember this time */
2072 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON3DOWN);
2075 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON2DOWN);
2078 /* we handle taps of only up to 3 fingers */
2081 atp_add_to_queue(sc, 0, 0, 0, 0); /* button release */
2083 } else if ((n_slides_reaped == 2) && (n_horizontal_scrolls == 2)) {
2084 if (horizontal_scroll < 0)
2085 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON4DOWN);
2087 atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON5DOWN);
2088 atp_add_to_queue(sc, 0, 0, 0, 0); /* button release */
2092 /* Switch a given touch stroke to being a slide. */
2094 atp_convert_to_slide(struct atp_softc *sc, atp_stroke_t *strokep)
2096 strokep->type = ATP_STROKE_SLIDE;
2098 /* Are we at the beginning of a double-click-n-drag? */
2099 if ((sc->sc_n_strokes == 1) &&
2100 ((sc->sc_state & ATP_ZOMBIES_EXIST) == 0) &&
2101 timevalcmp(&strokep->ctime, &sc->sc_touch_reap_time, >)) {
2102 struct timeval delta;
2103 struct timeval window = {
2104 atp_double_tap_threshold / 1000000,
2105 atp_double_tap_threshold % 1000000
2108 delta = strokep->ctime;
2109 timevalsub(&delta, &sc->sc_touch_reap_time);
2110 if (timevalcmp(&delta, &window, <=))
2111 sc->sc_state |= ATP_DOUBLE_TAP_DRAG;
2116 atp_reset_buf(struct atp_softc *sc)
2118 /* reset read queue */
2119 usb_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]);
2123 atp_add_to_queue(struct atp_softc *sc, int dx, int dy, int dz,
2124 uint32_t buttons_in)
2126 uint32_t buttons_out;
2129 dx = imin(dx, 254); dx = imax(dx, -256);
2130 dy = imin(dy, 254); dy = imax(dy, -256);
2131 dz = imin(dz, 126); dz = imax(dz, -128);
2133 buttons_out = MOUSE_MSC_BUTTONS;
2134 if (buttons_in & MOUSE_BUTTON1DOWN)
2135 buttons_out &= ~MOUSE_MSC_BUTTON1UP;
2136 else if (buttons_in & MOUSE_BUTTON2DOWN)
2137 buttons_out &= ~MOUSE_MSC_BUTTON2UP;
2138 else if (buttons_in & MOUSE_BUTTON3DOWN)
2139 buttons_out &= ~MOUSE_MSC_BUTTON3UP;
2141 DPRINTFN(ATP_LLEVEL_INFO, "dx=%d, dy=%d, buttons=%x\n",
2142 dx, dy, buttons_out);
2144 /* Encode the mouse data in standard format; refer to mouse(4) */
2145 buf[0] = sc->sc_mode.syncmask[1];
2146 buf[0] |= buttons_out;
2149 buf[3] = dx - (dx >> 1);
2150 buf[4] = dy - (dy >> 1);
2151 /* Encode extra bytes for level 1 */
2152 if (sc->sc_mode.level == 1) {
2154 buf[6] = dz - (dz >> 1);
2155 buf[7] = (((~buttons_in) >> 3) & MOUSE_SYS_EXTBUTTONS);
2158 usb_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf,
2159 sc->sc_mode.packetsize, 1);
2163 atp_probe(device_t self)
2165 struct usb_attach_arg *uaa = device_get_ivars(self);
2167 if (uaa->usb_mode != USB_MODE_HOST)
2170 if (uaa->info.bInterfaceClass != UICLASS_HID)
2173 * Note: for some reason, the check
2174 * (uaa->info.bInterfaceProtocol == UIPROTO_MOUSE) doesn't hold true
2175 * for wellspring trackpads, so we've removed it from the common path.
2178 if ((usbd_lookup_id_by_uaa(fg_devs, sizeof(fg_devs), uaa)) == 0)
2179 return ((uaa->info.bInterfaceProtocol == UIPROTO_MOUSE) ?
2182 if ((usbd_lookup_id_by_uaa(wsp_devs, sizeof(wsp_devs), uaa)) == 0)
2183 if (uaa->info.bIfaceIndex == WELLSPRING_INTERFACE_INDEX)
2190 atp_attach(device_t dev)
2192 struct atp_softc *sc = device_get_softc(dev);
2193 struct usb_attach_arg *uaa = device_get_ivars(dev);
2195 void *descriptor_ptr = NULL;
2196 uint16_t descriptor_len;
2199 DPRINTFN(ATP_LLEVEL_INFO, "sc=%p\n", sc);
2202 sc->sc_usb_device = uaa->device;
2204 /* Get HID descriptor */
2205 if (usbd_req_get_hid_desc(uaa->device, NULL, &descriptor_ptr,
2206 &descriptor_len, M_TEMP, uaa->info.bIfaceIndex) !=
2207 USB_ERR_NORMAL_COMPLETION)
2210 /* Get HID report descriptor length */
2211 sc->sc_expected_sensor_data_len = hid_report_size(descriptor_ptr,
2212 descriptor_len, hid_input, NULL);
2213 free(descriptor_ptr, M_TEMP);
2215 if ((sc->sc_expected_sensor_data_len <= 0) ||
2216 (sc->sc_expected_sensor_data_len > ATP_SENSOR_DATA_BUF_MAX)) {
2217 DPRINTF("atp_attach: datalength invalid or too large: %d\n",
2218 sc->sc_expected_sensor_data_len);
2223 * By default the touchpad behaves like an HID device, sending
2224 * packets with reportID = 2. Such reports contain only
2225 * limited information--they encode movement deltas and button
2226 * events,--but do not include data from the pressure
2227 * sensors. The device input mode can be switched from HID
2228 * reports to raw sensor data using vendor-specific USB
2231 if ((err = atp_set_device_mode(sc, RAW_SENSOR_MODE)) != 0) {
2232 DPRINTF("failed to set mode to 'RAW_SENSOR' (%d)\n", err);
2236 mtx_init(&sc->sc_mutex, "atpmtx", NULL, MTX_DEF | MTX_RECURSE);
2238 di = USB_GET_DRIVER_INFO(uaa);
2240 sc->sc_family = DECODE_FAMILY_FROM_DRIVER_INFO(di);
2242 switch(sc->sc_family) {
2243 case TRACKPAD_FAMILY_FOUNTAIN_GEYSER:
2245 &fg_dev_params[DECODE_PRODUCT_FROM_DRIVER_INFO(di)];
2246 sc->sensor_data_interpreter = fg_interpret_sensor_data;
2248 case TRACKPAD_FAMILY_WELLSPRING:
2250 &wsp_dev_params[DECODE_PRODUCT_FROM_DRIVER_INFO(di)];
2251 sc->sensor_data_interpreter = wsp_interpret_sensor_data;
2257 err = usbd_transfer_setup(uaa->device,
2258 &uaa->info.bIfaceIndex, sc->sc_xfer, atp_xfer_config,
2259 ATP_N_TRANSFER, sc, &sc->sc_mutex);
2261 DPRINTF("error=%s\n", usbd_errstr(err));
2265 if (usb_fifo_attach(sc->sc_usb_device, sc, &sc->sc_mutex,
2266 &atp_fifo_methods, &sc->sc_fifo,
2267 device_get_unit(dev), -1, uaa->info.bIfaceIndex,
2268 UID_ROOT, GID_OPERATOR, 0644)) {
2272 device_set_usb_desc(dev);
2274 sc->sc_hw.buttons = 3;
2275 sc->sc_hw.iftype = MOUSE_IF_USB;
2276 sc->sc_hw.type = MOUSE_PAD;
2277 sc->sc_hw.model = MOUSE_MODEL_GENERIC;
2279 sc->sc_mode.protocol = MOUSE_PROTO_MSC;
2280 sc->sc_mode.rate = -1;
2281 sc->sc_mode.resolution = MOUSE_RES_UNKNOWN;
2282 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE;
2283 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
2284 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
2285 sc->sc_mode.accelfactor = 0;
2286 sc->sc_mode.level = 0;
2291 callout_init_mtx(&sc->sc_callout, &sc->sc_mutex, 0);
2301 atp_detach(device_t dev)
2303 struct atp_softc *sc;
2305 sc = device_get_softc(dev);
2306 atp_set_device_mode(sc, HID_MODE);
2308 mtx_lock(&sc->sc_mutex);
2309 callout_drain(&sc->sc_callout);
2310 if (sc->sc_state & ATP_ENABLED)
2312 mtx_unlock(&sc->sc_mutex);
2314 usb_fifo_detach(&sc->sc_fifo);
2316 usbd_transfer_unsetup(sc->sc_xfer, ATP_N_TRANSFER);
2318 mtx_destroy(&sc->sc_mutex);
2324 atp_intr(struct usb_xfer *xfer, usb_error_t error)
2326 struct atp_softc *sc = usbd_xfer_softc(xfer);
2327 struct usb_page_cache *pc;
2330 usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
2332 switch (USB_GET_STATE(xfer)) {
2333 case USB_ST_TRANSFERRED:
2334 pc = usbd_xfer_get_frame(xfer, 0);
2335 usbd_copy_out(pc, 0, sc->sc_sensor_data, len);
2336 if (len < sc->sc_expected_sensor_data_len) {
2337 /* make sure we don't process old data */
2338 memset(sc->sc_sensor_data + len, 0,
2339 sc->sc_expected_sensor_data_len - len);
2342 sc->sc_status.flags &= ~(MOUSE_STDBUTTONSCHANGED |
2344 sc->sc_status.obutton = sc->sc_status.button;
2346 (sc->sensor_data_interpreter)(sc, len);
2348 if (sc->sc_status.button != 0) {
2349 /* Reset DOUBLE_TAP_N_DRAG if the button is pressed. */
2350 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG;
2351 } else if (sc->sc_state & ATP_DOUBLE_TAP_DRAG) {
2352 /* Assume a button-press with DOUBLE_TAP_N_DRAG. */
2353 sc->sc_status.button = MOUSE_BUTTON1DOWN;
2356 sc->sc_status.flags |=
2357 sc->sc_status.button ^ sc->sc_status.obutton;
2358 if (sc->sc_status.flags & MOUSE_STDBUTTONSCHANGED) {
2359 DPRINTFN(ATP_LLEVEL_INFO, "button %s\n",
2360 ((sc->sc_status.button & MOUSE_BUTTON1DOWN) ?
2361 "pressed" : "released"));
2364 if (sc->sc_status.flags & (MOUSE_POSCHANGED |
2365 MOUSE_STDBUTTONSCHANGED)) {
2367 atp_stroke_t *strokep;
2368 u_int8_t n_movements = 0;
2373 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
2374 if (strokep->flags & ATSF_ZOMBIE)
2377 dx += strokep->movement_dx;
2378 dy += strokep->movement_dy;
2379 if (strokep->movement_dx ||
2380 strokep->movement_dy)
2384 /* average movement if multiple strokes record motion.*/
2385 if (n_movements > 1) {
2386 dx /= (int)n_movements;
2387 dy /= (int)n_movements;
2390 /* detect multi-finger vertical scrolls */
2391 if (n_movements >= 2) {
2392 boolean_t all_vertical_scrolls = true;
2393 TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
2394 if (strokep->flags & ATSF_ZOMBIE)
2397 if (!atp_is_vertical_scroll(strokep))
2398 all_vertical_scrolls = false;
2400 if (all_vertical_scrolls) {
2406 sc->sc_status.dx += dx;
2407 sc->sc_status.dy += dy;
2408 sc->sc_status.dz += dz;
2409 atp_add_to_queue(sc, dx, -dy, -dz, sc->sc_status.button);
2414 /* check if we can put more data into the FIFO */
2415 if (usb_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) != 0) {
2416 usbd_xfer_set_frame_len(xfer, 0,
2417 sc->sc_expected_sensor_data_len);
2418 usbd_transfer_submit(xfer);
2422 default: /* Error */
2423 if (error != USB_ERR_CANCELLED) {
2424 /* try clear stall first */
2425 usbd_xfer_set_stall(xfer);
2433 atp_start_read(struct usb_fifo *fifo)
2435 struct atp_softc *sc = usb_fifo_softc(fifo);
2438 /* Check if we should override the default polling interval */
2439 rate = sc->sc_pollrate;
2440 /* Range check rate */
2443 /* Check for set rate */
2444 if ((rate > 0) && (sc->sc_xfer[ATP_INTR_DT] != NULL)) {
2445 /* Stop current transfer, if any */
2446 usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]);
2447 /* Set new interval */
2448 usbd_xfer_set_interval(sc->sc_xfer[ATP_INTR_DT], 1000 / rate);
2449 /* Only set pollrate once */
2450 sc->sc_pollrate = 0;
2453 usbd_transfer_start(sc->sc_xfer[ATP_INTR_DT]);
2457 atp_stop_read(struct usb_fifo *fifo)
2459 struct atp_softc *sc = usb_fifo_softc(fifo);
2460 usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]);
2464 atp_open(struct usb_fifo *fifo, int fflags)
2466 struct atp_softc *sc = usb_fifo_softc(fifo);
2468 /* check for duplicate open, should not happen */
2469 if (sc->sc_fflags & fflags)
2472 /* check for first open */
2473 if (sc->sc_fflags == 0) {
2475 if ((rc = atp_enable(sc)) != 0)
2479 if (fflags & FREAD) {
2480 if (usb_fifo_alloc_buffer(fifo,
2481 ATP_FIFO_BUF_SIZE, ATP_FIFO_QUEUE_MAXLEN)) {
2486 sc->sc_fflags |= (fflags & (FREAD | FWRITE));
2491 atp_close(struct usb_fifo *fifo, int fflags)
2493 struct atp_softc *sc = usb_fifo_softc(fifo);
2495 usb_fifo_free_buffer(fifo);
2497 sc->sc_fflags &= ~(fflags & (FREAD | FWRITE));
2498 if (sc->sc_fflags == 0) {
2504 atp_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags)
2506 struct atp_softc *sc = usb_fifo_softc(fifo);
2510 mtx_lock(&sc->sc_mutex);
2513 case MOUSE_GETHWINFO:
2514 *(mousehw_t *)addr = sc->sc_hw;
2517 *(mousemode_t *)addr = sc->sc_mode;
2520 mode = *(mousemode_t *)addr;
2522 if (mode.level == -1)
2523 /* Don't change the current setting */
2525 else if ((mode.level < 0) || (mode.level > 1)) {
2529 sc->sc_mode.level = mode.level;
2530 sc->sc_pollrate = mode.rate;
2531 sc->sc_hw.buttons = 3;
2533 if (sc->sc_mode.level == 0) {
2534 sc->sc_mode.protocol = MOUSE_PROTO_MSC;
2535 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE;
2536 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
2537 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
2538 } else if (sc->sc_mode.level == 1) {
2539 sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE;
2540 sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE;
2541 sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
2542 sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC;
2546 case MOUSE_GETLEVEL:
2547 *(int *)addr = sc->sc_mode.level;
2549 case MOUSE_SETLEVEL:
2550 if ((*(int *)addr < 0) || (*(int *)addr > 1)) {
2554 sc->sc_mode.level = *(int *)addr;
2555 sc->sc_hw.buttons = 3;
2557 if (sc->sc_mode.level == 0) {
2558 sc->sc_mode.protocol = MOUSE_PROTO_MSC;
2559 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE;
2560 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
2561 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
2562 } else if (sc->sc_mode.level == 1) {
2563 sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE;
2564 sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE;
2565 sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
2566 sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC;
2570 case MOUSE_GETSTATUS: {
2571 mousestatus_t *status = (mousestatus_t *)addr;
2573 *status = sc->sc_status;
2574 sc->sc_status.obutton = sc->sc_status.button;
2575 sc->sc_status.button = 0;
2576 sc->sc_status.dx = 0;
2577 sc->sc_status.dy = 0;
2578 sc->sc_status.dz = 0;
2580 if (status->dx || status->dy || status->dz)
2581 status->flags |= MOUSE_POSCHANGED;
2582 if (status->button != status->obutton)
2583 status->flags |= MOUSE_BUTTONSCHANGED;
2592 mtx_unlock(&sc->sc_mutex);
2597 atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS)
2602 tmp = atp_mickeys_scale_factor;
2603 error = sysctl_handle_int(oidp, &tmp, 0, req);
2604 if (error != 0 || req->newptr == NULL)
2607 if (tmp == atp_mickeys_scale_factor)
2608 return (0); /* no change */
2609 if ((tmp == 0) || (tmp > (10 * ATP_SCALE_FACTOR)))
2612 atp_mickeys_scale_factor = tmp;
2613 DPRINTFN(ATP_LLEVEL_INFO, "%s: resetting mickeys_scale_factor to %u\n",
2614 ATP_DRIVER_NAME, tmp);
2619 static devclass_t atp_devclass;
2621 static device_method_t atp_methods[] = {
2622 DEVMETHOD(device_probe, atp_probe),
2623 DEVMETHOD(device_attach, atp_attach),
2624 DEVMETHOD(device_detach, atp_detach),
2629 static driver_t atp_driver = {
2630 .name = ATP_DRIVER_NAME,
2631 .methods = atp_methods,
2632 .size = sizeof(struct atp_softc)
2635 DRIVER_MODULE(atp, uhub, atp_driver, atp_devclass, NULL, 0);
2636 MODULE_DEPEND(atp, usb, 1, 1, 1);
2637 MODULE_VERSION(atp, 1);
2638 USB_PNP_HOST_INFO(fg_devs);
2639 USB_PNP_HOST_INFO(wsp_devs);