xref: /freebsd/sys/dev/usb/input/atp.c (revision 32100375a661c1e16588ddfa7b90ca8d26cb9786)
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/usb/usb.h>
83 #include <dev/usb/usbdi.h>
84 #include <dev/usb/usbdi_util.h>
85 #include <dev/usb/usbhid.h>
86 
87 #include "usbdevs.h"
88 
89 #define USB_DEBUG_VAR atp_debug
90 #include <dev/usb/usb_debug.h>
91 
92 #include <sys/mouse.h>
93 
94 #define ATP_DRIVER_NAME "atp"
95 
96 /*
97  * Driver specific options: the following options may be set by
98  * `options' statements in the kernel configuration file.
99  */
100 
101 /* The divisor used to translate sensor reported positions to mickeys. */
102 #ifndef ATP_SCALE_FACTOR
103 #define ATP_SCALE_FACTOR                  16
104 #endif
105 
106 /* Threshold for small movement noise (in mickeys) */
107 #ifndef ATP_SMALL_MOVEMENT_THRESHOLD
108 #define ATP_SMALL_MOVEMENT_THRESHOLD      30
109 #endif
110 
111 /* Threshold of instantaneous deltas beyond which movement is considered fast.*/
112 #ifndef ATP_FAST_MOVEMENT_TRESHOLD
113 #define ATP_FAST_MOVEMENT_TRESHOLD        150
114 #endif
115 
116 /*
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.
119  */
120 #ifndef ATP_TOUCH_TIMEOUT
121 #define ATP_TOUCH_TIMEOUT                 125000
122 #endif
123 
124 #ifndef ATP_IDLENESS_THRESHOLD
125 #define	ATP_IDLENESS_THRESHOLD 10
126 #endif
127 
128 #ifndef FG_SENSOR_NOISE_THRESHOLD
129 #define FG_SENSOR_NOISE_THRESHOLD 2
130 #endif
131 
132 /*
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.
138  */
139 #ifndef ATP_DOUBLE_TAP_N_DRAG_THRESHOLD
140 #define ATP_DOUBLE_TAP_N_DRAG_THRESHOLD   200000
141 #endif
142 
143 /*
144  * The wait duration in ticks after losing a touch contact before
145  * zombied strokes are reaped and turned into button events.
146  */
147 #define ATP_ZOMBIE_STROKE_REAP_INTERVAL   (hz / 20)	/* 50 ms */
148 
149 /* The multiplier used to translate sensor reported positions to mickeys. */
150 #define FG_SCALE_FACTOR                   380
151 
152 /*
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
155  * component.
156  */
157 #define FG_MAX_DELTA_MICKEYS             ((3 * (FG_SCALE_FACTOR)) >> 1)
158 
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
162 #endif
163 
164 /* Ignore pressure spans with cumulative press. below this value. */
165 #define FG_PSPAN_MIN_CUM_PRESSURE         10
166 
167 /* Maximum allowed width for pressure-spans.*/
168 #define FG_PSPAN_MAX_WIDTH                4
169 
170 /* end of driver specific options */
171 
172 /* Tunables */
173 static SYSCTL_NODE(_hw_usb, OID_AUTO, atp, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
174     "USB ATP");
175 
176 #ifdef USB_DEBUG
177 enum atp_log_level {
178 	ATP_LLEVEL_DISABLED = 0,
179 	ATP_LLEVEL_ERROR,
180 	ATP_LLEVEL_DEBUG,       /* for troubleshooting */
181 	ATP_LLEVEL_INFO,        /* for diagnostics */
182 };
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 */
187 
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");
191 
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 "
196     "drag gesture");
197 
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");
205 
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");
210 
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");
214 
215 /*
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.
219  */
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");
224 
225 /*
226  * The minimum age of a stroke for it to be considered mature; this
227  * helps filter movements (noise) from immature strokes. Units: interrupts.
228  */
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");
233 
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 */
238 } trackpad_family_t;
239 
240 enum fountain_geyser_product {
241 	FOUNTAIN,
242 	GEYSER1,
243 	GEYSER1_17inch,
244 	GEYSER2,
245 	GEYSER3,
246 	GEYSER4,
247 	FOUNTAIN_GEYSER_PRODUCT_MAX /* keep this at the end */
248 };
249 
250 enum wellspring_product {
251 	WELLSPRING1,
252 	WELLSPRING2,
253 	WELLSPRING3,
254 	WELLSPRING4,
255 	WELLSPRING4A,
256 	WELLSPRING5,
257 	WELLSPRING6A,
258 	WELLSPRING6,
259 	WELLSPRING5A,
260 	WELLSPRING7,
261 	WELLSPRING7A,
262 	WELLSPRING8,
263 	WELLSPRING_PRODUCT_MAX /* keep this at the end of the enumeration */
264 };
265 
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,
272 };
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 */
277 };
278 
279 /*
280  * Trackpad family and product and family are encoded together in the
281  * driver_info value associated with a trackpad product.
282  */
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))
289 
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)
294 
295 /*
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.
299  */
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. */
306 } fg_pspan;
307 
308 #define FG_MAX_PSPANS_PER_AXIS 3
309 #define FG_MAX_STROKES         (2 * FG_MAX_PSPANS_PER_AXIS)
310 
311 #define WELLSPRING_INTERFACE_INDEX 1
312 
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)
317 
318 /* trackpad button data offsets */
319 #define WSP_TYPE2_BUTTON_DATA_OFFSET   15
320 #define WSP_TYPE3_BUTTON_DATA_OFFSET   23
321 
322 /* list of device capability bits */
323 #define HAS_INTEGRATED_BUTTON   1
324 
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 */
339 } __packed;
340 
341 typedef struct wsp_finger {
342 	/* to track fingers as they match against strokes. */
343 	boolean_t matched;
344 
345 	/* location (scaled using the mickeys factor) */
346 	int x;
347 	int y;
348 } wsp_finger_t;
349 
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
355 
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"
361 #endif
362 
363 #define ATP_MAX_STROKES               MAX(WSP_MAX_FINGERS, FG_MAX_STROKES)
364 
365 #define FG_MAX_XSENSORS 26
366 #define FG_MAX_YSENSORS 16
367 
368 /* device-specific configuration */
369 struct fg_dev_params {
370 	u_int                              data_len;   /* for sensor data */
371 	u_int                              n_xsensors;
372 	u_int                              n_ysensors;
373 	enum fountain_geyser_trackpad_type prot;
374 };
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 */
379 };
380 
381 static const struct fg_dev_params fg_dev_params[FOUNTAIN_GEYSER_PRODUCT_MAX] = {
382 	[FOUNTAIN] = {
383 		.data_len   = 81,
384 		.n_xsensors = 16,
385 		.n_ysensors = 16,
386 		.prot       = FG_TRACKPAD_TYPE_GEYSER1
387 	},
388 	[GEYSER1] = {
389 		.data_len   = 81,
390 		.n_xsensors = 16,
391 		.n_ysensors = 16,
392 		.prot       = FG_TRACKPAD_TYPE_GEYSER1
393 	},
394 	[GEYSER1_17inch] = {
395 		.data_len   = 81,
396 		.n_xsensors = 26,
397 		.n_ysensors = 16,
398 		.prot       = FG_TRACKPAD_TYPE_GEYSER1
399 	},
400 	[GEYSER2] = {
401 		.data_len   = 64,
402 		.n_xsensors = 15,
403 		.n_ysensors = 9,
404 		.prot       = FG_TRACKPAD_TYPE_GEYSER2
405 	},
406 	[GEYSER3] = {
407 		.data_len   = 64,
408 		.n_xsensors = 20,
409 		.n_ysensors = 10,
410 		.prot       = FG_TRACKPAD_TYPE_GEYSER3
411 	},
412 	[GEYSER4] = {
413 		.data_len   = 64,
414 		.n_xsensors = 20,
415 		.n_ysensors = 10,
416 		.prot       = FG_TRACKPAD_TYPE_GEYSER4
417 	}
418 };
419 
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)) },
427 
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)) },
432 
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)) },
437 
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)) },
442 
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)) },
447 
448 	/* 17 inch PowerBook */
449 	{ USB_VPI(USB_VENDOR_APPLE, 0x020d, FG_DRIVER_INFO(GEYSER1_17inch)) },
450 };
451 
452 static const struct wsp_dev_params wsp_dev_params[WELLSPRING_PRODUCT_MAX] = {
453 	[WELLSPRING1] = {
454 		.caps       = 0,
455 		.tp_type    = WSP_TRACKPAD_TYPE1,
456 		.finger_data_offset  = WSP_TYPE1_FINGER_DATA_OFFSET,
457 	},
458 	[WELLSPRING2] = {
459 		.caps       = 0,
460 		.tp_type    = WSP_TRACKPAD_TYPE1,
461 		.finger_data_offset  = WSP_TYPE1_FINGER_DATA_OFFSET,
462 	},
463 	[WELLSPRING3] = {
464 		.caps       = HAS_INTEGRATED_BUTTON,
465 		.tp_type    = WSP_TRACKPAD_TYPE2,
466 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
467 	},
468 	[WELLSPRING4] = {
469 		.caps       = HAS_INTEGRATED_BUTTON,
470 		.tp_type    = WSP_TRACKPAD_TYPE2,
471 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
472 	},
473 	[WELLSPRING4A] = {
474 		.caps       = HAS_INTEGRATED_BUTTON,
475 		.tp_type    = WSP_TRACKPAD_TYPE2,
476 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
477 	},
478 	[WELLSPRING5] = {
479 		.caps       = HAS_INTEGRATED_BUTTON,
480 		.tp_type    = WSP_TRACKPAD_TYPE2,
481 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
482 	},
483 	[WELLSPRING6] = {
484 		.caps       = HAS_INTEGRATED_BUTTON,
485 		.tp_type    = WSP_TRACKPAD_TYPE2,
486 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
487 	},
488 	[WELLSPRING5A] = {
489 		.caps       = HAS_INTEGRATED_BUTTON,
490 		.tp_type    = WSP_TRACKPAD_TYPE2,
491 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
492 	},
493 	[WELLSPRING6A] = {
494 		.caps       = HAS_INTEGRATED_BUTTON,
495 		.tp_type    = WSP_TRACKPAD_TYPE2,
496 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
497 	},
498 	[WELLSPRING7] = {
499 		.caps       = HAS_INTEGRATED_BUTTON,
500 		.tp_type    = WSP_TRACKPAD_TYPE2,
501 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
502 	},
503 	[WELLSPRING7A] = {
504 		.caps       = HAS_INTEGRATED_BUTTON,
505 		.tp_type    = WSP_TRACKPAD_TYPE2,
506 		.finger_data_offset  = WSP_TYPE2_FINGER_DATA_OFFSET,
507 	},
508 	[WELLSPRING8] = {
509 		.caps       = HAS_INTEGRATED_BUTTON,
510 		.tp_type    = WSP_TRACKPAD_TYPE3,
511 		.finger_data_offset  = WSP_TYPE3_FINGER_DATA_OFFSET,
512 	},
513 };
514 
515 #define ATP_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }
516 
517 /* TODO: STRUCT_USB_HOST_ID */
518 static const struct usb_device_id wsp_devs[] = {
519 	/* MacbookAir1.1 */
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)),
523 
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)),
528 
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)),
533 
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)),
538 
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)),
543 
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)),
548 
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)),
553 
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)),
558 
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)),
563 
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)),
569 
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)),
574 
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)),
579 };
580 
581 typedef enum atp_stroke_type {
582 	ATP_STROKE_TOUCH,
583 	ATP_STROKE_SLIDE,
584 } atp_stroke_type;
585 
586 typedef enum atp_axis {
587 	X = 0,
588 	Y = 1,
589 	NUM_AXES
590 } atp_axis;
591 
592 #define ATP_FIFO_BUF_SIZE        8 /* bytes */
593 #define ATP_FIFO_QUEUE_MAXLEN   50 /* units */
594 
595 enum {
596 	ATP_INTR_DT,
597 	ATP_RESET,
598 	ATP_N_TRANSFER,
599 };
600 
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.*/
607 
608 	int   delta_mickeys;    /* change in location (un-smoothened movement)*/
609 } fg_stroke_component_t;
610 
611 /*
612  * The following structure captures a finger contact with the
613  * touchpad. A stroke comprises two p-span components and some state.
614  */
615 typedef struct atp_stroke {
616 	TAILQ_ENTRY(atp_stroke) entry;
617 
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.*/
622 
623 	struct timeval  ctime; /* create time; for coincident siblings. */
624 
625 	/*
626 	 * Unit: interrupts; we maintain this value in
627 	 * addition to 'ctime' in order to avoid the
628 	 * expensive call to microtime() at every
629 	 * interrupt.
630 	 */
631 	uint32_t age;
632 
633 	/* Location */
634 	int x;
635 	int y;
636 
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 */
646 
647 	/*
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.
651 	 */
652 	fg_stroke_component_t components[NUM_AXES];
653 } atp_stroke_t;
654 
655 struct atp_softc; /* forward declaration */
656 typedef void (*sensor_data_interpreter_t)(struct atp_softc *sc, u_int len);
657 
658 struct atp_softc {
659 	device_t            sc_dev;
660 	struct usb_device  *sc_usb_device;
661 	struct mtx          sc_mutex; /* for synchronization */
662 	struct usb_fifo_sc  sc_fifo;
663 
664 #define	MODE_LENGTH 8
665 	char                sc_mode_bytes[MODE_LENGTH]; /* device mode */
666 
667 	trackpad_family_t   sc_family;
668 	const void         *sc_params; /* device configuration */
669 	sensor_data_interpreter_t sensor_data_interpreter;
670 
671 	mousehw_t           sc_hw;
672 	mousemode_t         sc_mode;
673 	mousestatus_t       sc_status;
674 
675 	u_int               sc_state;
676 #define ATP_ENABLED          0x01
677 #define ATP_ZOMBIES_EXIST    0x02
678 #define ATP_DOUBLE_TAP_DRAG  0x04
679 #define ATP_VALID            0x08
680 
681 	struct usb_xfer    *sc_xfer[ATP_N_TRANSFER];
682 
683 	u_int               sc_pollrate;
684 	int                 sc_fflags;
685 
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;
689 	u_int               sc_n_strokes;
690 
691 	struct callout	    sc_callout;
692 
693 	/*
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
697 	 * button is pressed.
698          */
699 	uint8_t             sc_ibtn;
700 
701 	/*
702 	 * Time when touch zombies were last reaped; useful for detecting
703 	 * double-touch-n-drag.
704 	 */
705 	struct timeval      sc_touch_reap_time;
706 
707 	u_int	            sc_idlecount;
708 
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);
712 
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];
721 };
722 
723 /*
724  * The last byte of the fountain-geyser sensor data contains status bits; the
725  * following values define the meanings of these bits.
726  * (only Geyser 3/4)
727  */
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.*/
731 };
732 
733 typedef enum interface_mode {
734 	RAW_SENSOR_MODE = (uint8_t)0x01,
735 	HID_MODE        = (uint8_t)0x08
736 } interface_mode;
737 
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 
1420 				/* There is a match. */
1421 				strokep->components[axis].matched = true;
1422 
1423 				/* Take care to repeat at the multi-span. */
1424 				if ((repeat_count > 0) && (i == repeat_index))
1425 					repeat_count--;
1426 				else
1427 					pspans[i].matched = true;
1428 
1429 				break; /* skip to the next strokep */
1430 			}
1431 		} /* loop over pspans */
1432 	} /* loop over strokes */
1433 }
1434 
1435 static boolean_t
1436 wsp_match_strokes_against_fingers(struct atp_softc *sc,
1437     wsp_finger_t *fingers, u_int n_fingers)
1438 {
1439 	boolean_t movement = false;
1440 	atp_stroke_t *strokep;
1441 	u_int i;
1442 
1443 	/* reset the matched status for all strokes */
1444 	TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry)
1445 		strokep->matched = false;
1446 
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;
1450 
1451 		TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
1452 			int instantaneous_dx;
1453 			int instantaneous_dy;
1454 			u_int d_squared;
1455 
1456 			if (strokep->matched)
1457 				continue;
1458 
1459 			instantaneous_dx = fingers[i].x - strokep->x;
1460 			instantaneous_dy = fingers[i].y - strokep->y;
1461 
1462 			/* skip strokes which are far away */
1463 			d_squared =
1464 			    (instantaneous_dx * instantaneous_dx) +
1465 			    (instantaneous_dy * instantaneous_dy);
1466 
1467 			if (d_squared < least_distance_sq) {
1468 				least_distance_sq = d_squared;
1469 				strokep_best = strokep;
1470 			}
1471 		}
1472 
1473 		strokep = strokep_best;
1474 
1475 		if (strokep != NULL) {
1476 			fingers[i].matched = true;
1477 
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;
1483 
1484 			atp_advance_stroke_state(sc, strokep, &movement);
1485 		}
1486 	}
1487 	return (movement);
1488 }
1489 
1490 /*
1491  * Update strokes by matching against current pressure-spans.
1492  * Return true if any movement is detected.
1493  */
1494 static boolean_t
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)
1497 {
1498 	atp_stroke_t *strokep;
1499 	atp_stroke_t *strokep_next;
1500 	boolean_t movement = false;
1501 	u_int repeat_count = 0;
1502 	u_int i;
1503 	u_int j;
1504 
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;
1509 	}
1510 
1511 	/*
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:
1516 	 *
1517 	 *   F = finger-contact
1518 	 *
1519 	 *                pspan  pspan
1520 	 *        +-----------------------+
1521 	 *        |         .      .      |
1522 	 *        |         .      .      |
1523 	 *        |         .      .      |
1524 	 *        |         .      .      |
1525 	 *  pspan |.........F......F      |
1526 	 *        |                       |
1527 	 *        |                       |
1528 	 *        |                       |
1529 	 *        +-----------------------+
1530 	 *
1531 	 *
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.
1535 	 *
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.
1544 	 */
1545 	repeat_count = abs(n_xpspans - n_ypspans);
1546 
1547 	fg_match_strokes_against_pspans(sc, X, pspans_x, n_xpspans,
1548 	    (((repeat_count != 0) && ((n_xpspans < n_ypspans))) ?
1549 		repeat_count : 0));
1550 	fg_match_strokes_against_pspans(sc, Y, pspans_y, n_ypspans,
1551 	    (((repeat_count != 0) && (n_ypspans < n_xpspans)) ?
1552 		repeat_count : 0));
1553 
1554 	/* Update the state of strokes based on the above pspan matches. */
1555 	TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) {
1556 
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);
1565 		} else {
1566 			/*
1567 			 * At least one component of this stroke
1568 			 * didn't match against current pspans;
1569 			 * terminate it.
1570 			 */
1571 			atp_terminate_stroke(sc, strokep);
1572 		}
1573 	}
1574 
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;
1578 	}
1579 	for (j = 0; j < n_ypspans; j++) {
1580 		if (pspans_y[j].matched == false) break;
1581 	}
1582 	if ((i < n_xpspans) && (j < n_ypspans)) {
1583 #ifdef USB_DEBUG
1584 		if (atp_debug >= ATP_LLEVEL_INFO) {
1585 			printf("unmatched pspans:");
1586 			for (; i < n_xpspans; i++) {
1587 				if (pspans_x[i].matched)
1588 					continue;
1589 				printf(" X:[loc:%u,cum:%u]",
1590 				    pspans_x[i].loc, pspans_x[i].cum);
1591 			}
1592 			for (; j < n_ypspans; j++) {
1593 				if (pspans_y[j].matched)
1594 					continue;
1595 				printf(" Y:[loc:%u,cum:%u]",
1596 				    pspans_y[j].loc, pspans_y[j].cum);
1597 			}
1598 			printf("\n");
1599 		}
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]);
1604 		else
1605 			fg_add_new_strokes(sc, pspans_x, n_xpspans,
1606 			    pspans_y, n_ypspans);
1607 	}
1608 
1609 #ifdef USB_DEBUG
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) ? ']' : '>');
1627 		}
1628 		if (TAILQ_FIRST(&sc->sc_stroke_used) != NULL)
1629 			printf("\n");
1630 	}
1631 #endif /* USB_DEBUG */
1632 	return (movement);
1633 }
1634 
1635 /*
1636  * Update strokes by matching against current pressure-spans.
1637  * Return true if any movement is detected.
1638  */
1639 static boolean_t
1640 wsp_update_strokes(struct atp_softc *sc, wsp_finger_t *fingers, u_int n_fingers)
1641 {
1642 	boolean_t movement = false;
1643 	atp_stroke_t *strokep_next;
1644 	atp_stroke_t *strokep;
1645 	u_int i;
1646 
1647 	if (sc->sc_n_strokes > 0) {
1648 		movement = wsp_match_strokes_against_fingers(
1649 		    sc, fingers, n_fingers);
1650 
1651 		/* handle zombie strokes */
1652 		TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) {
1653 			if (strokep->matched)
1654 				continue;
1655 			atp_terminate_stroke(sc, strokep);
1656 		}
1657 	}
1658 
1659 	/* initialize unmatched fingers as strokes */
1660 	for (i = 0; i != n_fingers; i++) {
1661 		if (fingers[i].matched)
1662 			continue;
1663 
1664 		wsp_add_stroke(sc, fingers + i);
1665 	}
1666 	return (movement);
1667 }
1668 
1669 /* Initialize a stroke using a pressure-span. */
1670 static void
1671 fg_add_stroke(struct atp_softc *sc, const fg_pspan *pspan_x,
1672     const fg_pspan *pspan_y)
1673 {
1674 	atp_stroke_t *strokep;
1675 
1676 	strokep = atp_alloc_stroke(sc);
1677 	if (strokep == NULL)
1678 		return;
1679 
1680 	/*
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'.
1684 	 */
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;
1691 
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;
1696 
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;
1701 
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;
1705 	}
1706 
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);
1712 }
1713 
1714 static void
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)
1717 {
1718 	fg_pspan spans[2][FG_MAX_PSPANS_PER_AXIS];
1719 	u_int nspans[2];
1720 	u_int i;
1721 	u_int j;
1722 
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];
1727 			nspans[X]++;
1728 		}
1729 	}
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];
1733 			nspans[Y]++;
1734 		}
1735 	}
1736 
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]);
1741 	} else {
1742 		u_int    cum = 0;
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 */
1746 
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) {
1751 				repeat_index = i;
1752 				cum = spans[repeat_axis][i].cum;
1753 			}
1754 		}
1755 
1756 		/* Create new strokes from pairs of unmatched pspans */
1757 		i = 0, j = 0;
1758 		for (; (i < nspans[X]) && (j < nspans[Y]); i++, j++) {
1759 			fg_add_stroke(sc, &spans[X][i], &spans[Y][j]);
1760 
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 */
1766 					repeat_count--;
1767 				} else if ((repeat_axis == Y) &&
1768 				    (repeat_index == j)) {
1769 					j--; /* counter loop increment */
1770 					repeat_count--;
1771 				}
1772 			}
1773 		}
1774 	}
1775 }
1776 
1777 /* Initialize a stroke from an unmatched finger. */
1778 static void
1779 wsp_add_stroke(struct atp_softc *sc, const wsp_finger_t *fingerp)
1780 {
1781 	atp_stroke_t *strokep;
1782 
1783 	strokep = atp_alloc_stroke(sc);
1784 	if (strokep == NULL)
1785 		return;
1786 
1787 	/*
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'.
1791 	 */
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;
1798 
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;
1802 
1803 	DPRINTFN(ATP_LLEVEL_INFO, "[%d,%d]\n", strokep->x, strokep->y);
1804 }
1805 
1806 static void
1807 atp_advance_stroke_state(struct atp_softc *sc, atp_stroke_t *strokep,
1808     boolean_t *movementp)
1809 {
1810 	/* Revitalize stroke if it had previously been marked as a zombie. */
1811 	if (strokep->flags & ATSF_ZOMBIE)
1812 		strokep->flags &= ~ATSF_ZOMBIE;
1813 
1814 	strokep->age++;
1815 	if (strokep->age <= atp_stroke_maturity_threshold) {
1816 		/* Avoid noise from immature strokes. */
1817 		strokep->instantaneous_dx = 0;
1818 		strokep->instantaneous_dy = 0;
1819 	}
1820 
1821 	if (atp_compute_stroke_movement(strokep))
1822 		*movementp = true;
1823 
1824 	if (strokep->type != ATP_STROKE_TOUCH)
1825 		return;
1826 
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);
1831 	else {
1832 		/* Compute the stroke's age. */
1833 		struct timeval tdiff;
1834 		getmicrotime(&tdiff);
1835 		if (timevalcmp(&tdiff, &strokep->ctime, >)) {
1836 			timevalsub(&tdiff, &strokep->ctime);
1837 
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);
1842 		}
1843 	}
1844 }
1845 
1846 static boolean_t
1847 atp_stroke_has_small_movement(const atp_stroke_t *strokep)
1848 {
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));
1853 }
1854 
1855 /*
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.
1859  */
1860 static void
1861 atp_update_pending_mickeys(atp_stroke_t *strokep)
1862 {
1863 	/* accumulate instantaneous movement */
1864 	strokep->pending_dx += strokep->instantaneous_dx;
1865 	strokep->pending_dy += strokep->instantaneous_dy;
1866 
1867 #define UPDATE_INSTANTANEOUS_AND_PENDING(I, P)                          \
1868 	if (abs((P)) <= atp_small_movement_threshold)                   \
1869 		(I) = 0; /* clobber small movement */                   \
1870 	else {                                                          \
1871 		if ((I) > 0) {                                          \
1872 			/*                                              \
1873 			 * Round up instantaneous movement to the nearest \
1874 			 * ceiling. This helps preserve small mickey    \
1875 			 * movements from being lost in following scaling \
1876 			 * operation.                                   \
1877 			 */                                             \
1878 			(I) = (((I) + (atp_mickeys_scale_factor - 1)) / \
1879 			       atp_mickeys_scale_factor) *              \
1880 			      atp_mickeys_scale_factor;                 \
1881 									\
1882 			/*                                              \
1883 			 * Deduct the rounded mickeys from pending mickeys. \
1884 			 * Note: we multiply by 2 to offset the previous \
1885 			 * accumulation of instantaneous movement into  \
1886 			 * pending.                                     \
1887 			 */                                             \
1888 			(P) -= ((I) << 1);                              \
1889 									\
1890 			/* truncate pending to 0 if it becomes negative. */ \
1891 			(P) = imax((P), 0);                             \
1892 		} else {                                                \
1893 			/*                                              \
1894 			 * Round down instantaneous movement to the nearest \
1895 			 * ceiling. This helps preserve small mickey    \
1896 			 * movements from being lost in following scaling \
1897 			 * operation.                                   \
1898 			 */                                             \
1899 			(I) = (((I) - (atp_mickeys_scale_factor - 1)) / \
1900 			       atp_mickeys_scale_factor) *              \
1901 			      atp_mickeys_scale_factor;                 \
1902 									\
1903 			/*                                              \
1904 			 * Deduct the rounded mickeys from pending mickeys. \
1905 			 * Note: we multiply by 2 to offset the previous \
1906 			 * accumulation of instantaneous movement into  \
1907 			 * pending.                                     \
1908 			 */                                             \
1909 			(P) -= ((I) << 1);                              \
1910 									\
1911 			/* truncate pending to 0 if it becomes positive. */ \
1912 			(P) = imin((P), 0);                             \
1913 		}                                                       \
1914 	}
1915 
1916 	UPDATE_INSTANTANEOUS_AND_PENDING(strokep->instantaneous_dx,
1917 	    strokep->pending_dx);
1918 	UPDATE_INSTANTANEOUS_AND_PENDING(strokep->instantaneous_dy,
1919 	    strokep->pending_dy);
1920 }
1921 
1922 /*
1923  * Compute a smoothened value for the stroke's movement from
1924  * instantaneous changes in the X and Y components.
1925  */
1926 static boolean_t
1927 atp_compute_stroke_movement(atp_stroke_t *strokep)
1928 {
1929 	/*
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
1933 	 * noise.
1934 	 */
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;
1941 	}
1942 
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;
1948 
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;
1953 	}
1954 
1955 	strokep->cum_movement_x += strokep->movement_dx;
1956 	strokep->cum_movement_y += strokep->movement_dy;
1957 
1958 	return ((strokep->movement_dx != 0) || (strokep->movement_dy != 0));
1959 }
1960 
1961 /*
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.
1966  */
1967 static void
1968 atp_terminate_stroke(struct atp_softc *sc, atp_stroke_t *strokep)
1969 {
1970 	if (strokep->flags & ATSF_ZOMBIE)
1971 		return;
1972 
1973 	/* Drop immature strokes rightaway. */
1974 	if (strokep->age <= atp_stroke_maturity_threshold) {
1975 		atp_free_stroke(sc, strokep);
1976 		return;
1977 	}
1978 
1979 	strokep->flags |= ATSF_ZOMBIE;
1980 	sc->sc_state |= ATP_ZOMBIES_EXIST;
1981 
1982 	callout_reset(&sc->sc_callout, ATP_ZOMBIE_STROKE_REAP_INTERVAL,
1983 	    atp_reap_sibling_zombies, sc);
1984 
1985 	/*
1986 	 * Reset the double-click-n-drag at the termination of any
1987 	 * slide stroke.
1988 	 */
1989 	if (strokep->type == ATP_STROKE_SLIDE)
1990 		sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG;
1991 }
1992 
1993 static boolean_t
1994 atp_is_horizontal_scroll(const atp_stroke_t *strokep)
1995 {
1996 	if (abs(strokep->cum_movement_x) < atp_slide_min_movement)
1997 		return (false);
1998 	if (strokep->cum_movement_y == 0)
1999 		return (true);
2000 	return (abs(strokep->cum_movement_x / strokep->cum_movement_y) >= 4);
2001 }
2002 
2003 static boolean_t
2004 atp_is_vertical_scroll(const atp_stroke_t *strokep)
2005 {
2006 	if (abs(strokep->cum_movement_y) < atp_slide_min_movement)
2007 		return (false);
2008 	if (strokep->cum_movement_x == 0)
2009 		return (true);
2010 	return (abs(strokep->cum_movement_y / strokep->cum_movement_x) >= 4);
2011 }
2012 
2013 static void
2014 atp_reap_sibling_zombies(void *arg)
2015 {
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;
2025 
2026 	DPRINTFN(ATP_LLEVEL_INFO, "\n");
2027 
2028 	TAILQ_FOREACH_SAFE(strokep, &sc->sc_stroke_used, entry, strokep_next) {
2029 		if ((strokep->flags & ATSF_ZOMBIE) == 0)
2030 			continue;
2031 
2032 		if (strokep->type == ATP_STROKE_TOUCH) {
2033 			n_touches_reaped++;
2034 		} else {
2035 			n_slides_reaped++;
2036 
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;
2043 			}
2044 		}
2045 
2046 		atp_free_stroke(sc, strokep);
2047 	}
2048 
2049 	DPRINTFN(ATP_LLEVEL_INFO, "reaped %u zombies\n",
2050 	    n_touches_reaped + n_slides_reaped);
2051 	sc->sc_state &= ~ATP_ZOMBIES_EXIST;
2052 
2053 	/* No further processing necessary if physical button is depressed. */
2054 	if (sc->sc_ibtn != 0)
2055 		return;
2056 
2057 	if ((n_touches_reaped == 0) && (n_slides_reaped == 0))
2058 		return;
2059 
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)
2064 			return;
2065 
2066 		switch (n_touches_reaped) {
2067 		case 1:
2068 			atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON1DOWN);
2069 			microtime(&sc->sc_touch_reap_time); /* remember this time */
2070 			break;
2071 		case 2:
2072 			atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON3DOWN);
2073 			break;
2074 		case 3:
2075 			atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON2DOWN);
2076 			break;
2077 		default:
2078 			/* we handle taps of only up to 3 fingers */
2079 			return;
2080 		}
2081 		atp_add_to_queue(sc, 0, 0, 0, 0); /* button release */
2082 
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);
2086 		else
2087 			atp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON5DOWN);
2088 		atp_add_to_queue(sc, 0, 0, 0, 0); /* button release */
2089 	}
2090 }
2091 
2092 /* Switch a given touch stroke to being a slide. */
2093 static void
2094 atp_convert_to_slide(struct atp_softc *sc, atp_stroke_t *strokep)
2095 {
2096 	strokep->type = ATP_STROKE_SLIDE;
2097 
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
2106 		};
2107 
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;
2112 	}
2113 }
2114 
2115 static void
2116 atp_reset_buf(struct atp_softc *sc)
2117 {
2118 	/* reset read queue */
2119 	usb_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]);
2120 }
2121 
2122 static void
2123 atp_add_to_queue(struct atp_softc *sc, int dx, int dy, int dz,
2124     uint32_t buttons_in)
2125 {
2126 	uint32_t buttons_out;
2127 	uint8_t  buf[8];
2128 
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);
2132 
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;
2140 
2141 	DPRINTFN(ATP_LLEVEL_INFO, "dx=%d, dy=%d, buttons=%x\n",
2142 	    dx, dy, buttons_out);
2143 
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;
2147 	buf[1] = dx >> 1;
2148 	buf[2] = dy >> 1;
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) {
2153 		buf[5] = dz >> 1;
2154 		buf[6] = dz - (dz >> 1);
2155 		buf[7] = (((~buttons_in) >> 3) & MOUSE_SYS_EXTBUTTONS);
2156 	}
2157 
2158 	usb_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf,
2159 	    sc->sc_mode.packetsize, 1);
2160 }
2161 
2162 static int
2163 atp_probe(device_t self)
2164 {
2165 	struct usb_attach_arg *uaa = device_get_ivars(self);
2166 
2167 	if (uaa->usb_mode != USB_MODE_HOST)
2168 		return (ENXIO);
2169 
2170 	if (uaa->info.bInterfaceClass != UICLASS_HID)
2171 		return (ENXIO);
2172 	/*
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.
2176 	 */
2177 
2178 	if ((usbd_lookup_id_by_uaa(fg_devs, sizeof(fg_devs), uaa)) == 0)
2179 		return ((uaa->info.bInterfaceProtocol == UIPROTO_MOUSE) ?
2180 			0 : ENXIO);
2181 
2182 	if ((usbd_lookup_id_by_uaa(wsp_devs, sizeof(wsp_devs), uaa)) == 0)
2183 		if (uaa->info.bIfaceIndex == WELLSPRING_INTERFACE_INDEX)
2184 			return (0);
2185 
2186 	return (ENXIO);
2187 }
2188 
2189 static int
2190 atp_attach(device_t dev)
2191 {
2192 	struct atp_softc      *sc  = device_get_softc(dev);
2193 	struct usb_attach_arg *uaa = device_get_ivars(dev);
2194 	usb_error_t            err;
2195 	void *descriptor_ptr = NULL;
2196 	uint16_t descriptor_len;
2197 	unsigned long di;
2198 
2199 	DPRINTFN(ATP_LLEVEL_INFO, "sc=%p\n", sc);
2200 
2201 	sc->sc_dev        = dev;
2202 	sc->sc_usb_device = uaa->device;
2203 
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)
2208 		return (ENXIO);
2209 
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);
2214 
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);
2219 		return (ENXIO);
2220 	}
2221 
2222 	di = USB_GET_DRIVER_INFO(uaa);
2223 	sc->sc_family = DECODE_FAMILY_FROM_DRIVER_INFO(di);
2224 
2225 	/*
2226 	 * By default the touchpad behaves like an HID device, sending
2227 	 * packets with reportID = 2. Such reports contain only
2228 	 * limited information--they encode movement deltas and button
2229 	 * events,--but do not include data from the pressure
2230 	 * sensors. The device input mode can be switched from HID
2231 	 * reports to raw sensor data using vendor-specific USB
2232 	 * control commands.
2233 	 * FOUNTAIN devices will give an error when trying to switch
2234 	 * input mode, so we skip this command
2235 	 */
2236 	if ((sc->sc_family == TRACKPAD_FAMILY_FOUNTAIN_GEYSER) &&
2237 		(DECODE_PRODUCT_FROM_DRIVER_INFO(di) == FOUNTAIN))
2238 		DPRINTF("device mode switch skipped: Fountain device\n");
2239 	else if ((err = atp_set_device_mode(sc, RAW_SENSOR_MODE)) != 0) {
2240 		DPRINTF("failed to set mode to 'RAW_SENSOR' (%d)\n", err);
2241 		return (ENXIO);
2242 	}
2243 
2244 	mtx_init(&sc->sc_mutex, "atpmtx", NULL, MTX_DEF | MTX_RECURSE);
2245 
2246 	switch(sc->sc_family) {
2247 	case TRACKPAD_FAMILY_FOUNTAIN_GEYSER:
2248 		sc->sc_params =
2249 		    &fg_dev_params[DECODE_PRODUCT_FROM_DRIVER_INFO(di)];
2250 		sc->sensor_data_interpreter = fg_interpret_sensor_data;
2251 		break;
2252 	case TRACKPAD_FAMILY_WELLSPRING:
2253 		sc->sc_params =
2254 		    &wsp_dev_params[DECODE_PRODUCT_FROM_DRIVER_INFO(di)];
2255 		sc->sensor_data_interpreter = wsp_interpret_sensor_data;
2256 		break;
2257 	default:
2258 		goto detach;
2259 	}
2260 
2261 	err = usbd_transfer_setup(uaa->device,
2262 	    &uaa->info.bIfaceIndex, sc->sc_xfer, atp_xfer_config,
2263 	    ATP_N_TRANSFER, sc, &sc->sc_mutex);
2264 	if (err) {
2265 		DPRINTF("error=%s\n", usbd_errstr(err));
2266 		goto detach;
2267 	}
2268 
2269 	if (usb_fifo_attach(sc->sc_usb_device, sc, &sc->sc_mutex,
2270 	    &atp_fifo_methods, &sc->sc_fifo,
2271 	    device_get_unit(dev), -1, uaa->info.bIfaceIndex,
2272 	    UID_ROOT, GID_OPERATOR, 0644)) {
2273 		goto detach;
2274 	}
2275 
2276 	device_set_usb_desc(dev);
2277 
2278 	sc->sc_hw.buttons       = 3;
2279 	sc->sc_hw.iftype        = MOUSE_IF_USB;
2280 	sc->sc_hw.type          = MOUSE_PAD;
2281 	sc->sc_hw.model         = MOUSE_MODEL_GENERIC;
2282 	sc->sc_hw.hwid          = 0;
2283 	sc->sc_mode.protocol    = MOUSE_PROTO_MSC;
2284 	sc->sc_mode.rate        = -1;
2285 	sc->sc_mode.resolution  = MOUSE_RES_UNKNOWN;
2286 	sc->sc_mode.packetsize  = MOUSE_MSC_PACKETSIZE;
2287 	sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
2288 	sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
2289 	sc->sc_mode.accelfactor = 0;
2290 	sc->sc_mode.level       = 0;
2291 
2292 	sc->sc_state            = 0;
2293 	sc->sc_ibtn             = 0;
2294 
2295 	callout_init_mtx(&sc->sc_callout, &sc->sc_mutex, 0);
2296 
2297 	return (0);
2298 
2299 detach:
2300 	atp_detach(dev);
2301 	return (ENOMEM);
2302 }
2303 
2304 static int
2305 atp_detach(device_t dev)
2306 {
2307 	struct atp_softc *sc;
2308 
2309 	sc = device_get_softc(dev);
2310 	atp_set_device_mode(sc, HID_MODE);
2311 
2312 	mtx_lock(&sc->sc_mutex);
2313 	callout_drain(&sc->sc_callout);
2314 	if (sc->sc_state & ATP_ENABLED)
2315 		atp_disable(sc);
2316 	mtx_unlock(&sc->sc_mutex);
2317 
2318 	usb_fifo_detach(&sc->sc_fifo);
2319 
2320 	usbd_transfer_unsetup(sc->sc_xfer, ATP_N_TRANSFER);
2321 
2322 	mtx_destroy(&sc->sc_mutex);
2323 
2324 	return (0);
2325 }
2326 
2327 static void
2328 atp_intr(struct usb_xfer *xfer, usb_error_t error)
2329 {
2330 	struct atp_softc      *sc = usbd_xfer_softc(xfer);
2331 	struct usb_page_cache *pc;
2332 	int len;
2333 
2334 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
2335 
2336 	switch (USB_GET_STATE(xfer)) {
2337 	case USB_ST_TRANSFERRED:
2338 		pc = usbd_xfer_get_frame(xfer, 0);
2339 		usbd_copy_out(pc, 0, sc->sc_sensor_data, len);
2340 		if (len < sc->sc_expected_sensor_data_len) {
2341 			/* make sure we don't process old data */
2342 			memset(sc->sc_sensor_data + len, 0,
2343 			    sc->sc_expected_sensor_data_len - len);
2344 		}
2345 
2346 		sc->sc_status.flags &= ~(MOUSE_STDBUTTONSCHANGED |
2347 		    MOUSE_POSCHANGED);
2348 		sc->sc_status.obutton = sc->sc_status.button;
2349 
2350 		(sc->sensor_data_interpreter)(sc, len);
2351 
2352 		if (sc->sc_status.button != 0) {
2353 			/* Reset DOUBLE_TAP_N_DRAG if the button is pressed. */
2354 			sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG;
2355 		} else if (sc->sc_state & ATP_DOUBLE_TAP_DRAG) {
2356 			/* Assume a button-press with DOUBLE_TAP_N_DRAG. */
2357 			sc->sc_status.button = MOUSE_BUTTON1DOWN;
2358 		}
2359 
2360 		sc->sc_status.flags |=
2361 		    sc->sc_status.button ^ sc->sc_status.obutton;
2362 		if (sc->sc_status.flags & MOUSE_STDBUTTONSCHANGED) {
2363 		    DPRINTFN(ATP_LLEVEL_INFO, "button %s\n",
2364 			((sc->sc_status.button & MOUSE_BUTTON1DOWN) ?
2365 			"pressed" : "released"));
2366 		}
2367 
2368 		if (sc->sc_status.flags & (MOUSE_POSCHANGED |
2369 		    MOUSE_STDBUTTONSCHANGED)) {
2370 
2371 			atp_stroke_t *strokep;
2372 			u_int8_t n_movements = 0;
2373 			int dx = 0;
2374 			int dy = 0;
2375 			int dz = 0;
2376 
2377 			TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
2378 				if (strokep->flags & ATSF_ZOMBIE)
2379 					continue;
2380 
2381 				dx += strokep->movement_dx;
2382 				dy += strokep->movement_dy;
2383 				if (strokep->movement_dx ||
2384 				    strokep->movement_dy)
2385 					n_movements++;
2386 			}
2387 
2388 			/* average movement if multiple strokes record motion.*/
2389 			if (n_movements > 1) {
2390 				dx /= (int)n_movements;
2391 				dy /= (int)n_movements;
2392 			}
2393 
2394 			/* detect multi-finger vertical scrolls */
2395 			if (n_movements >= 2) {
2396 				boolean_t all_vertical_scrolls = true;
2397 				TAILQ_FOREACH(strokep, &sc->sc_stroke_used, entry) {
2398 					if (strokep->flags & ATSF_ZOMBIE)
2399 						continue;
2400 
2401 					if (!atp_is_vertical_scroll(strokep))
2402 						all_vertical_scrolls = false;
2403 				}
2404 				if (all_vertical_scrolls) {
2405 					dz = dy;
2406 					dy = dx = 0;
2407 				}
2408 			}
2409 
2410 			sc->sc_status.dx += dx;
2411 			sc->sc_status.dy += dy;
2412 			sc->sc_status.dz += dz;
2413 			atp_add_to_queue(sc, dx, -dy, -dz, sc->sc_status.button);
2414 		}
2415 
2416 	case USB_ST_SETUP:
2417 	tr_setup:
2418 		/* check if we can put more data into the FIFO */
2419 		if (usb_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) != 0) {
2420 			usbd_xfer_set_frame_len(xfer, 0,
2421 			    sc->sc_expected_sensor_data_len);
2422 			usbd_transfer_submit(xfer);
2423 		}
2424 		break;
2425 
2426 	default:                        /* Error */
2427 		if (error != USB_ERR_CANCELLED) {
2428 			/* try clear stall first */
2429 			usbd_xfer_set_stall(xfer);
2430 			goto tr_setup;
2431 		}
2432 		break;
2433 	}
2434 }
2435 
2436 static void
2437 atp_start_read(struct usb_fifo *fifo)
2438 {
2439 	struct atp_softc *sc = usb_fifo_softc(fifo);
2440 	int rate;
2441 
2442 	/* Check if we should override the default polling interval */
2443 	rate = sc->sc_pollrate;
2444 	/* Range check rate */
2445 	if (rate > 1000)
2446 		rate = 1000;
2447 	/* Check for set rate */
2448 	if ((rate > 0) && (sc->sc_xfer[ATP_INTR_DT] != NULL)) {
2449 		/* Stop current transfer, if any */
2450 		usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]);
2451 		/* Set new interval */
2452 		usbd_xfer_set_interval(sc->sc_xfer[ATP_INTR_DT], 1000 / rate);
2453 		/* Only set pollrate once */
2454 		sc->sc_pollrate = 0;
2455 	}
2456 
2457 	usbd_transfer_start(sc->sc_xfer[ATP_INTR_DT]);
2458 }
2459 
2460 static void
2461 atp_stop_read(struct usb_fifo *fifo)
2462 {
2463 	struct atp_softc *sc = usb_fifo_softc(fifo);
2464 	usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]);
2465 }
2466 
2467 static int
2468 atp_open(struct usb_fifo *fifo, int fflags)
2469 {
2470 	struct atp_softc *sc = usb_fifo_softc(fifo);
2471 
2472 	/* check for duplicate open, should not happen */
2473 	if (sc->sc_fflags & fflags)
2474 		return (EBUSY);
2475 
2476 	/* check for first open */
2477 	if (sc->sc_fflags == 0) {
2478 		int rc;
2479 		if ((rc = atp_enable(sc)) != 0)
2480 			return (rc);
2481 	}
2482 
2483 	if (fflags & FREAD) {
2484 		if (usb_fifo_alloc_buffer(fifo,
2485 		    ATP_FIFO_BUF_SIZE, ATP_FIFO_QUEUE_MAXLEN)) {
2486 			return (ENOMEM);
2487 		}
2488 	}
2489 
2490 	sc->sc_fflags |= (fflags & (FREAD | FWRITE));
2491 	return (0);
2492 }
2493 
2494 static void
2495 atp_close(struct usb_fifo *fifo, int fflags)
2496 {
2497 	struct atp_softc *sc = usb_fifo_softc(fifo);
2498 	if (fflags & FREAD)
2499 		usb_fifo_free_buffer(fifo);
2500 
2501 	sc->sc_fflags &= ~(fflags & (FREAD | FWRITE));
2502 	if (sc->sc_fflags == 0) {
2503 		atp_disable(sc);
2504 	}
2505 }
2506 
2507 static int
2508 atp_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags)
2509 {
2510 	struct atp_softc *sc = usb_fifo_softc(fifo);
2511 	mousemode_t mode;
2512 	int error = 0;
2513 
2514 	mtx_lock(&sc->sc_mutex);
2515 
2516 	switch(cmd) {
2517 	case MOUSE_GETHWINFO:
2518 		*(mousehw_t *)addr = sc->sc_hw;
2519 		break;
2520 	case MOUSE_GETMODE:
2521 		*(mousemode_t *)addr = sc->sc_mode;
2522 		break;
2523 	case MOUSE_SETMODE:
2524 		mode = *(mousemode_t *)addr;
2525 
2526 		if (mode.level == -1)
2527 			/* Don't change the current setting */
2528 			;
2529 		else if ((mode.level < 0) || (mode.level > 1)) {
2530 			error = EINVAL;
2531 			break;
2532 		}
2533 		sc->sc_mode.level = mode.level;
2534 		sc->sc_pollrate   = mode.rate;
2535 		sc->sc_hw.buttons = 3;
2536 
2537 		if (sc->sc_mode.level == 0) {
2538 			sc->sc_mode.protocol    = MOUSE_PROTO_MSC;
2539 			sc->sc_mode.packetsize  = MOUSE_MSC_PACKETSIZE;
2540 			sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
2541 			sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
2542 		} else if (sc->sc_mode.level == 1) {
2543 			sc->sc_mode.protocol    = MOUSE_PROTO_SYSMOUSE;
2544 			sc->sc_mode.packetsize  = MOUSE_SYS_PACKETSIZE;
2545 			sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
2546 			sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC;
2547 		}
2548 		atp_reset_buf(sc);
2549 		break;
2550 	case MOUSE_GETLEVEL:
2551 		*(int *)addr = sc->sc_mode.level;
2552 		break;
2553 	case MOUSE_SETLEVEL:
2554 		if ((*(int *)addr < 0) || (*(int *)addr > 1)) {
2555 			error = EINVAL;
2556 			break;
2557 		}
2558 		sc->sc_mode.level = *(int *)addr;
2559 		sc->sc_hw.buttons = 3;
2560 
2561 		if (sc->sc_mode.level == 0) {
2562 			sc->sc_mode.protocol    = MOUSE_PROTO_MSC;
2563 			sc->sc_mode.packetsize  = MOUSE_MSC_PACKETSIZE;
2564 			sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
2565 			sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
2566 		} else if (sc->sc_mode.level == 1) {
2567 			sc->sc_mode.protocol    = MOUSE_PROTO_SYSMOUSE;
2568 			sc->sc_mode.packetsize  = MOUSE_SYS_PACKETSIZE;
2569 			sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
2570 			sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC;
2571 		}
2572 		atp_reset_buf(sc);
2573 		break;
2574 	case MOUSE_GETSTATUS: {
2575 		mousestatus_t *status = (mousestatus_t *)addr;
2576 
2577 		*status = sc->sc_status;
2578 		sc->sc_status.obutton = sc->sc_status.button;
2579 		sc->sc_status.button  = 0;
2580 		sc->sc_status.dx      = 0;
2581 		sc->sc_status.dy      = 0;
2582 		sc->sc_status.dz      = 0;
2583 
2584 		if (status->dx || status->dy || status->dz)
2585 			status->flags |= MOUSE_POSCHANGED;
2586 		if (status->button != status->obutton)
2587 			status->flags |= MOUSE_BUTTONSCHANGED;
2588 		break;
2589 	}
2590 
2591 	default:
2592 		error = ENOTTY;
2593 		break;
2594 	}
2595 
2596 	mtx_unlock(&sc->sc_mutex);
2597 	return (error);
2598 }
2599 
2600 static int
2601 atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS)
2602 {
2603 	int error;
2604 	u_int tmp;
2605 
2606 	tmp = atp_mickeys_scale_factor;
2607 	error = sysctl_handle_int(oidp, &tmp, 0, req);
2608 	if (error != 0 || req->newptr == NULL)
2609 		return (error);
2610 
2611 	if (tmp == atp_mickeys_scale_factor)
2612 		return (0);     /* no change */
2613 	if ((tmp == 0) || (tmp > (10 * ATP_SCALE_FACTOR)))
2614 		return (EINVAL);
2615 
2616 	atp_mickeys_scale_factor = tmp;
2617 	DPRINTFN(ATP_LLEVEL_INFO, "%s: resetting mickeys_scale_factor to %u\n",
2618 	    ATP_DRIVER_NAME, tmp);
2619 
2620 	return (0);
2621 }
2622 
2623 static devclass_t atp_devclass;
2624 
2625 static device_method_t atp_methods[] = {
2626 	DEVMETHOD(device_probe,  atp_probe),
2627 	DEVMETHOD(device_attach, atp_attach),
2628 	DEVMETHOD(device_detach, atp_detach),
2629 
2630 	DEVMETHOD_END
2631 };
2632 
2633 static driver_t atp_driver = {
2634 	.name    = ATP_DRIVER_NAME,
2635 	.methods = atp_methods,
2636 	.size    = sizeof(struct atp_softc)
2637 };
2638 
2639 DRIVER_MODULE(atp, uhub, atp_driver, atp_devclass, NULL, 0);
2640 MODULE_DEPEND(atp, usb, 1, 1, 1);
2641 MODULE_VERSION(atp, 1);
2642 USB_PNP_HOST_INFO(fg_devs);
2643 USB_PNP_HOST_INFO(wsp_devs);
2644