atp.c revision 212122
1/*- 2 * Copyright (c) 2009 Rohit Grover 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28__FBSDID("$FreeBSD: head/sys/dev/usb/input/atp.c 212122 2010-09-01 23:47:53Z thompsa $"); 29 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/kernel.h> 33#include <sys/malloc.h> 34#include <sys/module.h> 35#include <sys/lock.h> 36#include <sys/mutex.h> 37#include <sys/bus.h> 38#include <sys/conf.h> 39#include <sys/fcntl.h> 40#include <sys/file.h> 41#include <sys/selinfo.h> 42#include <sys/poll.h> 43#include <sys/sysctl.h> 44#include <sys/uio.h> 45 46#include <dev/usb/usb.h> 47#include <dev/usb/usbdi.h> 48#include <dev/usb/usbdi_util.h> 49#include <dev/usb/usbhid.h> 50#include "usbdevs.h" 51 52#define USB_DEBUG_VAR atp_debug 53#include <dev/usb/usb_debug.h> 54 55#include <sys/mouse.h> 56 57#define ATP_DRIVER_NAME "atp" 58 59/* 60 * Driver specific options: the following options may be set by 61 * `options' statements in the kernel configuration file. 62 */ 63 64/* The multiplier used to translate sensor reported positions to mickeys. */ 65#ifndef ATP_SCALE_FACTOR 66#define ATP_SCALE_FACTOR 48 67#endif 68 69/* 70 * This is the age (in microseconds) beyond which a touch is 71 * considered to be a slide; and therefore a tap event isn't registered. 72 */ 73#ifndef ATP_TOUCH_TIMEOUT 74#define ATP_TOUCH_TIMEOUT 125000 75#endif 76 77/* 78 * A double-tap followed by a single-finger slide is treated as a 79 * special gesture. The driver responds to this gesture by assuming a 80 * virtual button-press for the lifetime of the slide. The following 81 * threshold is the maximum time gap (in microseconds) between the two 82 * tap events preceding the slide for such a gesture. 83 */ 84#ifndef ATP_DOUBLE_TAP_N_DRAG_THRESHOLD 85#define ATP_DOUBLE_TAP_N_DRAG_THRESHOLD 200000 86#endif 87 88/* 89 * The device provides us only with pressure readings from an array of 90 * X and Y sensors; for our algorithms, we need to interpret groups 91 * (typically pairs) of X and Y readings as being related to a single 92 * finger stroke. We can relate X and Y readings based on their times 93 * of incidence. The coincidence window should be at least 10000us 94 * since it is used against values from getmicrotime(), which has a 95 * precision of around 10ms. 96 */ 97#ifndef ATP_COINCIDENCE_THRESHOLD 98#define ATP_COINCIDENCE_THRESHOLD 40000 /* unit: microseconds */ 99#if ATP_COINCIDENCE_THRESHOLD > 100000 100#error "ATP_COINCIDENCE_THRESHOLD too large" 101#endif 102#endif /* #ifndef ATP_COINCIDENCE_THRESHOLD */ 103 104/* 105 * The wait duration (in microseconds) after losing a touch contact 106 * before zombied strokes are reaped and turned into button events. 107 */ 108#define ATP_ZOMBIE_STROKE_REAP_WINDOW 50000 109#if ATP_ZOMBIE_STROKE_REAP_WINDOW > 100000 110#error "ATP_ZOMBIE_STROKE_REAP_WINDOW too large" 111#endif 112 113/* end of driver specific options */ 114 115 116/* Tunables */ 117SYSCTL_NODE(_hw_usb, OID_AUTO, atp, CTLFLAG_RW, 0, "USB atp"); 118 119#ifdef USB_DEBUG 120enum atp_log_level { 121 ATP_LLEVEL_DISABLED = 0, 122 ATP_LLEVEL_ERROR, 123 ATP_LLEVEL_DEBUG, /* for troubleshooting */ 124 ATP_LLEVEL_INFO, /* for diagnostics */ 125}; 126static int atp_debug = ATP_LLEVEL_ERROR; /* the default is to only log errors */ 127SYSCTL_INT(_hw_usb_atp, OID_AUTO, debug, CTLFLAG_RW, 128 &atp_debug, ATP_LLEVEL_ERROR, "ATP debug level"); 129#endif /* USB_DEBUG */ 130 131static u_int atp_touch_timeout = ATP_TOUCH_TIMEOUT; 132SYSCTL_INT(_hw_usb_atp, OID_AUTO, touch_timeout, CTLFLAG_RW, &atp_touch_timeout, 133 125000, "age threshold (in micros) for a touch"); 134 135static u_int atp_double_tap_threshold = ATP_DOUBLE_TAP_N_DRAG_THRESHOLD; 136SYSCTL_INT(_hw_usb_atp, OID_AUTO, double_tap_threshold, CTLFLAG_RW, 137 &atp_double_tap_threshold, ATP_DOUBLE_TAP_N_DRAG_THRESHOLD, 138 "maximum time (in micros) between a double-tap"); 139 140static u_int atp_mickeys_scale_factor = ATP_SCALE_FACTOR; 141static int atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS); 142SYSCTL_PROC(_hw_usb_atp, OID_AUTO, scale_factor, CTLTYPE_UINT | CTLFLAG_RW, 143 &atp_mickeys_scale_factor, sizeof(atp_mickeys_scale_factor), 144 atp_sysctl_scale_factor_handler, "IU", "movement scale factor"); 145 146static u_int atp_small_movement_threshold = ATP_SCALE_FACTOR >> 3; 147SYSCTL_UINT(_hw_usb_atp, OID_AUTO, small_movement, CTLFLAG_RW, 148 &atp_small_movement_threshold, ATP_SCALE_FACTOR >> 3, 149 "the small movement black-hole for filtering noise"); 150/* 151 * The movement threshold for a stroke; this is the maximum difference 152 * in position which will be resolved as a continuation of a stroke 153 * component. 154 */ 155static u_int atp_max_delta_mickeys = ((3 * ATP_SCALE_FACTOR) >> 1); 156SYSCTL_UINT(_hw_usb_atp, OID_AUTO, max_delta_mickeys, CTLFLAG_RW, 157 &atp_max_delta_mickeys, ((3 * ATP_SCALE_FACTOR) >> 1), 158 "max. mickeys-delta which will match against an existing stroke"); 159/* 160 * Strokes which accumulate at least this amount of absolute movement 161 * from the aggregate of their components are considered as 162 * slides. Unit: mickeys. 163 */ 164static u_int atp_slide_min_movement = (ATP_SCALE_FACTOR >> 3); 165SYSCTL_UINT(_hw_usb_atp, OID_AUTO, slide_min_movement, CTLFLAG_RW, 166 &atp_slide_min_movement, (ATP_SCALE_FACTOR >> 3), 167 "strokes with at least this amt. of movement are considered slides"); 168 169/* 170 * The minimum age of a stroke for it to be considered mature; this 171 * helps filter movements (noise) from immature strokes. Units: interrupts. 172 */ 173static u_int atp_stroke_maturity_threshold = 2; 174SYSCTL_UINT(_hw_usb_atp, OID_AUTO, stroke_maturity_threshold, CTLFLAG_RW, 175 &atp_stroke_maturity_threshold, 2, 176 "the minimum age of a stroke for it to be considered mature"); 177 178/* Accept pressure readings from sensors only if above this value. */ 179static u_int atp_sensor_noise_threshold = 2; 180SYSCTL_UINT(_hw_usb_atp, OID_AUTO, sensor_noise_threshold, CTLFLAG_RW, 181 &atp_sensor_noise_threshold, 2, 182 "accept pressure readings from sensors only if above this value"); 183 184/* Ignore pressure spans with cumulative press. below this value. */ 185static u_int atp_pspan_min_cum_pressure = 10; 186SYSCTL_UINT(_hw_usb_atp, OID_AUTO, pspan_min_cum_pressure, CTLFLAG_RW, 187 &atp_pspan_min_cum_pressure, 10, 188 "ignore pressure spans with cumulative press. below this value"); 189 190/* Maximum allowed width for pressure-spans.*/ 191static u_int atp_pspan_max_width = 4; 192SYSCTL_UINT(_hw_usb_atp, OID_AUTO, pspan_max_width, CTLFLAG_RW, 193 &atp_pspan_max_width, 4, 194 "maximum allowed width (in sensors) for pressure-spans"); 195 196/* We support three payload protocols */ 197typedef enum { 198 ATP_PROT_GEYSER1, 199 ATP_PROT_GEYSER2, 200 ATP_PROT_GEYSER3, 201} atp_protocol; 202 203/* Define the various flavours of devices supported by this driver. */ 204enum { 205 ATP_DEV_PARAMS_0, 206 ATP_DEV_PARAMS_PBOOK, 207 ATP_DEV_PARAMS_PBOOK_15A, 208 ATP_DEV_PARAMS_PBOOK_17, 209 ATP_N_DEV_PARAMS 210}; 211struct atp_dev_params { 212 u_int data_len; /* for sensor data */ 213 u_int n_xsensors; 214 u_int n_ysensors; 215 atp_protocol prot; 216} atp_dev_params[ATP_N_DEV_PARAMS] = { 217 [ATP_DEV_PARAMS_0] = { 218 .data_len = 64, 219 .n_xsensors = 20, 220 .n_ysensors = 10, 221 .prot = ATP_PROT_GEYSER3 222 }, 223 [ATP_DEV_PARAMS_PBOOK] = { 224 .data_len = 81, 225 .n_xsensors = 16, 226 .n_ysensors = 16, 227 .prot = ATP_PROT_GEYSER1 228 }, 229 [ATP_DEV_PARAMS_PBOOK_15A] = { 230 .data_len = 64, 231 .n_xsensors = 15, 232 .n_ysensors = 9, 233 .prot = ATP_PROT_GEYSER2 234 }, 235 [ATP_DEV_PARAMS_PBOOK_17] = { 236 .data_len = 81, 237 .n_xsensors = 26, 238 .n_ysensors = 16, 239 .prot = ATP_PROT_GEYSER1 240 }, 241}; 242 243static const struct usb_device_id atp_devs[] = { 244 /* Core Duo MacBook & MacBook Pro */ 245 { USB_VPI(USB_VENDOR_APPLE, 0x0217, ATP_DEV_PARAMS_0) }, 246 { USB_VPI(USB_VENDOR_APPLE, 0x0218, ATP_DEV_PARAMS_0) }, 247 { USB_VPI(USB_VENDOR_APPLE, 0x0219, ATP_DEV_PARAMS_0) }, 248 249 /* Core2 Duo MacBook & MacBook Pro */ 250 { USB_VPI(USB_VENDOR_APPLE, 0x021a, ATP_DEV_PARAMS_0) }, 251 { USB_VPI(USB_VENDOR_APPLE, 0x021b, ATP_DEV_PARAMS_0) }, 252 { USB_VPI(USB_VENDOR_APPLE, 0x021c, ATP_DEV_PARAMS_0) }, 253 254 /* Core2 Duo MacBook3,1 */ 255 { USB_VPI(USB_VENDOR_APPLE, 0x0229, ATP_DEV_PARAMS_0) }, 256 { USB_VPI(USB_VENDOR_APPLE, 0x022a, ATP_DEV_PARAMS_0) }, 257 { USB_VPI(USB_VENDOR_APPLE, 0x022b, ATP_DEV_PARAMS_0) }, 258 259 /* 12 inch PowerBook and iBook */ 260 { USB_VPI(USB_VENDOR_APPLE, 0x030a, ATP_DEV_PARAMS_PBOOK) }, 261 { USB_VPI(USB_VENDOR_APPLE, 0x030b, ATP_DEV_PARAMS_PBOOK) }, 262 263 /* 15 inch PowerBook */ 264 { USB_VPI(USB_VENDOR_APPLE, 0x020e, ATP_DEV_PARAMS_PBOOK) }, 265 { USB_VPI(USB_VENDOR_APPLE, 0x020f, ATP_DEV_PARAMS_PBOOK) }, 266 { USB_VPI(USB_VENDOR_APPLE, 0x0215, ATP_DEV_PARAMS_PBOOK_15A) }, 267 268 /* 17 inch PowerBook */ 269 { USB_VPI(USB_VENDOR_APPLE, 0x020d, ATP_DEV_PARAMS_PBOOK_17) }, 270 271}; 272 273/* 274 * The following structure captures the state of a pressure span along 275 * an axis. Each contact with the touchpad results in separate 276 * pressure spans along the two axes. 277 */ 278typedef struct atp_pspan { 279 u_int width; /* in units of sensors */ 280 u_int cum; /* cumulative compression (from all sensors) */ 281 u_int cog; /* center of gravity */ 282 u_int loc; /* location (scaled using the mickeys factor) */ 283 boolean_t matched; /* to track pspans as they match against strokes. */ 284} atp_pspan; 285 286typedef enum atp_stroke_type { 287 ATP_STROKE_TOUCH, 288 ATP_STROKE_SLIDE, 289} atp_stroke_type; 290 291#define ATP_MAX_PSPANS_PER_AXIS 3 292 293typedef struct atp_stroke_component { 294 /* Fields encapsulating the pressure-span. */ 295 u_int loc; /* location (scaled) */ 296 u_int cum_pressure; /* cumulative compression */ 297 u_int max_cum_pressure; /* max cumulative compression */ 298 boolean_t matched; /*to track components as they match against pspans.*/ 299 300 /* Fields containing information about movement. */ 301 int delta_mickeys; /* change in location (un-smoothened movement)*/ 302 int pending; /* cum. of pending short movements */ 303 int movement; /* current smoothened movement */ 304} atp_stroke_component; 305 306typedef enum atp_axis { 307 X = 0, 308 Y = 1 309} atp_axis; 310 311#define ATP_MAX_STROKES (2 * ATP_MAX_PSPANS_PER_AXIS) 312 313/* 314 * The following structure captures a finger contact with the 315 * touchpad. A stroke comprises two p-span components and some state. 316 */ 317typedef struct atp_stroke { 318 atp_stroke_type type; 319 struct timeval ctime; /* create time; for coincident siblings. */ 320 u_int age; /* 321 * Unit: interrupts; we maintain 322 * this value in addition to 323 * 'ctime' in order to avoid the 324 * expensive call to microtime() 325 * at every interrupt. 326 */ 327 328 atp_stroke_component components[2]; 329 u_int velocity_squared; /* 330 * Average magnitude (squared) 331 * of recent velocity. 332 */ 333 u_int cum_movement; /* cum. absolute movement so far */ 334 335 uint32_t flags; /* the state of this stroke */ 336#define ATSF_ZOMBIE 0x1 337} atp_stroke; 338 339#define ATP_FIFO_BUF_SIZE 8 /* bytes */ 340#define ATP_FIFO_QUEUE_MAXLEN 50 /* units */ 341 342enum { 343 ATP_INTR_DT, 344 ATP_RESET, 345 ATP_N_TRANSFER, 346}; 347 348struct atp_softc { 349 device_t sc_dev; 350 struct usb_device *sc_usb_device; 351#define MODE_LENGTH 8 352 char sc_mode_bytes[MODE_LENGTH]; /* device mode */ 353 struct mtx sc_mutex; /* for synchronization */ 354 struct usb_xfer *sc_xfer[ATP_N_TRANSFER]; 355 struct usb_fifo_sc sc_fifo; 356 357 struct atp_dev_params *sc_params; 358 359 mousehw_t sc_hw; 360 mousemode_t sc_mode; 361 u_int sc_pollrate; 362 mousestatus_t sc_status; 363 u_int sc_state; 364#define ATP_ENABLED 0x01 365#define ATP_ZOMBIES_EXIST 0x02 366#define ATP_DOUBLE_TAP_DRAG 0x04 367#define ATP_VALID 0x08 368 369 u_int sc_left_margin; 370 u_int sc_right_margin; 371 372 atp_stroke sc_strokes[ATP_MAX_STROKES]; 373 u_int sc_n_strokes; 374 375 int8_t *sensor_data; /* from interrupt packet */ 376 int *base_x; /* base sensor readings */ 377 int *base_y; 378 int *cur_x; /* current sensor readings */ 379 int *cur_y; 380 int *pressure_x; /* computed pressures */ 381 int *pressure_y; 382 383 u_int sc_idlecount; /* preceding idle interrupts */ 384#define ATP_IDLENESS_THRESHOLD 10 385 386 struct timeval sc_reap_time; 387 struct timeval sc_reap_ctime; /*ctime of siblings to be reaped*/ 388}; 389 390/* 391 * The last byte of the sensor data contains status bits; the 392 * following values define the meanings of these bits. 393 */ 394enum atp_status_bits { 395 ATP_STATUS_BUTTON = (uint8_t)0x01, /* The button was pressed */ 396 ATP_STATUS_BASE_UPDATE = (uint8_t)0x04, /* Data from an untouched pad.*/ 397}; 398 399typedef enum interface_mode { 400 RAW_SENSOR_MODE = (uint8_t)0x04, 401 HID_MODE = (uint8_t)0x08 402} interface_mode; 403 404/* 405 * function prototypes 406 */ 407static usb_fifo_cmd_t atp_start_read; 408static usb_fifo_cmd_t atp_stop_read; 409static usb_fifo_open_t atp_open; 410static usb_fifo_close_t atp_close; 411static usb_fifo_ioctl_t atp_ioctl; 412 413static struct usb_fifo_methods atp_fifo_methods = { 414 .f_open = &atp_open, 415 .f_close = &atp_close, 416 .f_ioctl = &atp_ioctl, 417 .f_start_read = &atp_start_read, 418 .f_stop_read = &atp_stop_read, 419 .basename[0] = ATP_DRIVER_NAME, 420}; 421 422/* device initialization and shutdown */ 423static usb_error_t atp_req_get_report(struct usb_device *udev, void *data); 424static int atp_set_device_mode(device_t dev, interface_mode mode); 425static void atp_reset_callback(struct usb_xfer *, usb_error_t); 426static int atp_enable(struct atp_softc *sc); 427static void atp_disable(struct atp_softc *sc); 428static int atp_softc_populate(struct atp_softc *); 429static void atp_softc_unpopulate(struct atp_softc *); 430 431/* sensor interpretation */ 432static __inline void atp_interpret_sensor_data(const int8_t *, u_int, atp_axis, 433 int *, atp_protocol); 434static __inline void atp_get_pressures(int *, const int *, const int *, int); 435static void atp_detect_pspans(int *, u_int, u_int, atp_pspan *, 436 u_int *); 437 438/* movement detection */ 439static boolean_t atp_match_stroke_component(atp_stroke_component *, 440 const atp_pspan *, atp_stroke_type); 441static void atp_match_strokes_against_pspans(struct atp_softc *, 442 atp_axis, atp_pspan *, u_int, u_int); 443static boolean_t atp_update_strokes(struct atp_softc *, 444 atp_pspan *, u_int, atp_pspan *, u_int); 445static __inline void atp_add_stroke(struct atp_softc *, const atp_pspan *, 446 const atp_pspan *); 447static void atp_add_new_strokes(struct atp_softc *, atp_pspan *, 448 u_int, atp_pspan *, u_int); 449static void atp_advance_stroke_state(struct atp_softc *, 450 atp_stroke *, boolean_t *); 451static void atp_terminate_stroke(struct atp_softc *, u_int); 452static __inline boolean_t atp_stroke_has_small_movement(const atp_stroke *); 453static __inline void atp_update_pending_mickeys(atp_stroke_component *); 454static void atp_compute_smoothening_scale_ratio(atp_stroke *, int *, 455 int *); 456static boolean_t atp_compute_stroke_movement(atp_stroke *); 457 458/* tap detection */ 459static __inline void atp_setup_reap_time(struct atp_softc *, struct timeval *); 460static void atp_reap_zombies(struct atp_softc *, u_int *, u_int *); 461static void atp_convert_to_slide(struct atp_softc *, atp_stroke *); 462 463/* updating fifo */ 464static void atp_reset_buf(struct atp_softc *sc); 465static void atp_add_to_queue(struct atp_softc *, int, int, uint32_t); 466 467 468usb_error_t 469atp_req_get_report(struct usb_device *udev, void *data) 470{ 471 struct usb_device_request req; 472 473 req.bmRequestType = UT_READ_CLASS_INTERFACE; 474 req.bRequest = UR_GET_REPORT; 475 USETW2(req.wValue, (uint8_t)0x03 /* type */, (uint8_t)0x00 /* id */); 476 USETW(req.wIndex, 0); 477 USETW(req.wLength, MODE_LENGTH); 478 479 return (usbd_do_request(udev, NULL /* mutex */, &req, data)); 480} 481 482static int 483atp_set_device_mode(device_t dev, interface_mode mode) 484{ 485 struct atp_softc *sc; 486 usb_device_request_t req; 487 usb_error_t err; 488 489 if ((mode != RAW_SENSOR_MODE) && (mode != HID_MODE)) 490 return (ENXIO); 491 492 sc = device_get_softc(dev); 493 494 sc->sc_mode_bytes[0] = mode; 495 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 496 req.bRequest = UR_SET_REPORT; 497 USETW2(req.wValue, (uint8_t)0x03 /* type */, (uint8_t)0x00 /* id */); 498 USETW(req.wIndex, 0); 499 USETW(req.wLength, MODE_LENGTH); 500 err = usbd_do_request(sc->sc_usb_device, NULL, &req, sc->sc_mode_bytes); 501 if (err != USB_ERR_NORMAL_COMPLETION) 502 return (ENXIO); 503 504 return (0); 505} 506 507void 508atp_reset_callback(struct usb_xfer *xfer, usb_error_t error) 509{ 510 usb_device_request_t req; 511 struct usb_page_cache *pc; 512 struct atp_softc *sc = usbd_xfer_softc(xfer); 513 514 switch (USB_GET_STATE(xfer)) { 515 case USB_ST_SETUP: 516 sc->sc_mode_bytes[0] = RAW_SENSOR_MODE; 517 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 518 req.bRequest = UR_SET_REPORT; 519 USETW2(req.wValue, 520 (uint8_t)0x03 /* type */, (uint8_t)0x00 /* id */); 521 USETW(req.wIndex, 0); 522 USETW(req.wLength, MODE_LENGTH); 523 524 pc = usbd_xfer_get_frame(xfer, 0); 525 usbd_copy_in(pc, 0, &req, sizeof(req)); 526 pc = usbd_xfer_get_frame(xfer, 1); 527 usbd_copy_in(pc, 0, sc->sc_mode_bytes, MODE_LENGTH); 528 529 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 530 usbd_xfer_set_frame_len(xfer, 1, MODE_LENGTH); 531 usbd_xfer_set_frames(xfer, 2); 532 usbd_transfer_submit(xfer); 533 break; 534 535 case USB_ST_TRANSFERRED: 536 default: 537 break; 538 } 539} 540 541static int 542atp_enable(struct atp_softc *sc) 543{ 544 /* Allocate the dynamic buffers */ 545 if (atp_softc_populate(sc) != 0) { 546 atp_softc_unpopulate(sc); 547 return (ENOMEM); 548 } 549 550 /* reset status */ 551 memset(sc->sc_strokes, 0, sizeof(sc->sc_strokes)); 552 sc->sc_n_strokes = 0; 553 memset(&sc->sc_status, 0, sizeof(sc->sc_status)); 554 sc->sc_idlecount = 0; 555 sc->sc_state |= ATP_ENABLED; 556 557 DPRINTFN(ATP_LLEVEL_INFO, "enabled atp\n"); 558 return (0); 559} 560 561static void 562atp_disable(struct atp_softc *sc) 563{ 564 atp_softc_unpopulate(sc); 565 566 sc->sc_state &= ~(ATP_ENABLED | ATP_VALID); 567 DPRINTFN(ATP_LLEVEL_INFO, "disabled atp\n"); 568} 569 570/* Allocate dynamic memory for some fields in softc. */ 571static int 572atp_softc_populate(struct atp_softc *sc) 573{ 574 const struct atp_dev_params *params = sc->sc_params; 575 576 if (params == NULL) { 577 DPRINTF("params uninitialized!\n"); 578 return (ENXIO); 579 } 580 if (params->data_len) { 581 sc->sensor_data = malloc(params->data_len * sizeof(int8_t), 582 M_USB, M_WAITOK); 583 if (sc->sensor_data == NULL) { 584 DPRINTF("mem for sensor_data\n"); 585 return (ENXIO); 586 } 587 } 588 589 if (params->n_xsensors != 0) { 590 sc->base_x = malloc(params->n_xsensors * sizeof(*(sc->base_x)), 591 M_USB, M_WAITOK); 592 if (sc->base_x == NULL) { 593 DPRINTF("mem for sc->base_x\n"); 594 return (ENXIO); 595 } 596 597 sc->cur_x = malloc(params->n_xsensors * sizeof(*(sc->cur_x)), 598 M_USB, M_WAITOK); 599 if (sc->cur_x == NULL) { 600 DPRINTF("mem for sc->cur_x\n"); 601 return (ENXIO); 602 } 603 604 sc->pressure_x = 605 malloc(params->n_xsensors * sizeof(*(sc->pressure_x)), 606 M_USB, M_WAITOK); 607 if (sc->pressure_x == NULL) { 608 DPRINTF("mem. for pressure_x\n"); 609 return (ENXIO); 610 } 611 } 612 613 if (params->n_ysensors != 0) { 614 sc->base_y = malloc(params->n_ysensors * sizeof(*(sc->base_y)), 615 M_USB, M_WAITOK); 616 if (sc->base_y == NULL) { 617 DPRINTF("mem for base_y\n"); 618 return (ENXIO); 619 } 620 621 sc->cur_y = malloc(params->n_ysensors * sizeof(*(sc->cur_y)), 622 M_USB, M_WAITOK); 623 if (sc->cur_y == NULL) { 624 DPRINTF("mem for cur_y\n"); 625 return (ENXIO); 626 } 627 628 sc->pressure_y = 629 malloc(params->n_ysensors * sizeof(*(sc->pressure_y)), 630 M_USB, M_WAITOK); 631 if (sc->pressure_y == NULL) { 632 DPRINTF("mem. for pressure_y\n"); 633 return (ENXIO); 634 } 635 } 636 637 return (0); 638} 639 640/* Free dynamic memory allocated for some fields in softc. */ 641static void 642atp_softc_unpopulate(struct atp_softc *sc) 643{ 644 const struct atp_dev_params *params = sc->sc_params; 645 646 if (params == NULL) { 647 return; 648 } 649 if (params->n_xsensors != 0) { 650 if (sc->base_x != NULL) { 651 free(sc->base_x, M_USB); 652 sc->base_x = NULL; 653 } 654 655 if (sc->cur_x != NULL) { 656 free(sc->cur_x, M_USB); 657 sc->cur_x = NULL; 658 } 659 660 if (sc->pressure_x != NULL) { 661 free(sc->pressure_x, M_USB); 662 sc->pressure_x = NULL; 663 } 664 } 665 if (params->n_ysensors != 0) { 666 if (sc->base_y != NULL) { 667 free(sc->base_y, M_USB); 668 sc->base_y = NULL; 669 } 670 671 if (sc->cur_y != NULL) { 672 free(sc->cur_y, M_USB); 673 sc->cur_y = NULL; 674 } 675 676 if (sc->pressure_y != NULL) { 677 free(sc->pressure_y, M_USB); 678 sc->pressure_y = NULL; 679 } 680 } 681 if (sc->sensor_data != NULL) { 682 free(sc->sensor_data, M_USB); 683 sc->sensor_data = NULL; 684 } 685} 686 687/* 688 * Interpret the data from the X and Y pressure sensors. This function 689 * is called separately for the X and Y sensor arrays. The data in the 690 * USB packet is laid out in the following manner: 691 * 692 * sensor_data: 693 * --,--,Y1,Y2,--,Y3,Y4,--,Y5,...,Y10, ... X1,X2,--,X3,X4 694 * indices: 0 1 2 3 4 5 6 7 8 ... 15 ... 20 21 22 23 24 695 * 696 * '--' (in the above) indicates that the value is unimportant. 697 * 698 * Information about the above layout was obtained from the 699 * implementation of the AppleTouch driver in Linux. 700 * 701 * parameters: 702 * sensor_data 703 * raw sensor data from the USB packet. 704 * num 705 * The number of elements in the array 'arr'. 706 * axis 707 * Axis of data to fetch 708 * arr 709 * The array to be initialized with the readings. 710 * prot 711 * The protocol to use to interpret the data 712 */ 713static __inline void 714atp_interpret_sensor_data(const int8_t *sensor_data, u_int num, atp_axis axis, 715 int *arr, atp_protocol prot) 716{ 717 u_int i; 718 u_int di; /* index into sensor data */ 719 720 switch (prot) { 721 case ATP_PROT_GEYSER1: 722 /* 723 * For Geyser 1, the sensors are laid out in pairs 724 * every 5 bytes. 725 */ 726 for (i = 0, di = (axis == Y) ? 1 : 2; i < 8; di += 5, i++) { 727 arr[i] = sensor_data[di]; 728 arr[i+8] = sensor_data[di+2]; 729 if (axis == X && num > 16) 730 arr[i+16] = sensor_data[di+40]; 731 } 732 733 break; 734 case ATP_PROT_GEYSER2: 735 case ATP_PROT_GEYSER3: 736 for (i = 0, di = (axis == Y) ? 2 : 20; i < num; /* empty */ ) { 737 arr[i++] = sensor_data[di++]; 738 arr[i++] = sensor_data[di++]; 739 di++; 740 } 741 break; 742 } 743} 744 745static __inline void 746atp_get_pressures(int *p, const int *cur, const int *base, int n) 747{ 748 int i; 749 750 for (i = 0; i < n; i++) { 751 p[i] = cur[i] - base[i]; 752 if (p[i] > 127) 753 p[i] -= 256; 754 if (p[i] < -127) 755 p[i] += 256; 756 if (p[i] < 0) 757 p[i] = 0; 758 759 /* 760 * Shave off pressures below the noise-pressure 761 * threshold; this will reduce the contribution from 762 * lower pressure readings. 763 */ 764 if (p[i] <= atp_sensor_noise_threshold) 765 p[i] = 0; /* filter away noise */ 766 else 767 p[i] -= atp_sensor_noise_threshold; 768 } 769} 770 771static void 772atp_detect_pspans(int *p, u_int num_sensors, 773 u_int max_spans, /* max # of pspans permitted */ 774 atp_pspan *spans, /* finger spans */ 775 u_int *nspans_p) /* num spans detected */ 776{ 777 u_int i; 778 int maxp; /* max pressure seen within a span */ 779 u_int num_spans = 0; 780 781 enum atp_pspan_state { 782 ATP_PSPAN_INACTIVE, 783 ATP_PSPAN_INCREASING, 784 ATP_PSPAN_DECREASING, 785 } state; /* state of the pressure span */ 786 787 /* 788 * The following is a simple state machine to track 789 * the phase of the pressure span. 790 */ 791 memset(spans, 0, max_spans * sizeof(atp_pspan)); 792 maxp = 0; 793 state = ATP_PSPAN_INACTIVE; 794 for (i = 0; i < num_sensors; i++) { 795 if (num_spans >= max_spans) 796 break; 797 798 if (p[i] == 0) { 799 if (state == ATP_PSPAN_INACTIVE) { 800 /* 801 * There is no pressure information for this 802 * sensor, and we aren't tracking a finger. 803 */ 804 continue; 805 } else { 806 state = ATP_PSPAN_INACTIVE; 807 maxp = 0; 808 num_spans++; 809 } 810 } else { 811 switch (state) { 812 case ATP_PSPAN_INACTIVE: 813 state = ATP_PSPAN_INCREASING; 814 maxp = p[i]; 815 break; 816 817 case ATP_PSPAN_INCREASING: 818 if (p[i] > maxp) 819 maxp = p[i]; 820 else if (p[i] <= (maxp >> 1)) 821 state = ATP_PSPAN_DECREASING; 822 break; 823 824 case ATP_PSPAN_DECREASING: 825 if (p[i] > p[i - 1]) { 826 /* 827 * This is the beginning of 828 * another span; change state 829 * to give the appearance that 830 * we're starting from an 831 * inactive span, and then 832 * re-process this reading in 833 * the next iteration. 834 */ 835 num_spans++; 836 state = ATP_PSPAN_INACTIVE; 837 maxp = 0; 838 i--; 839 continue; 840 } 841 break; 842 } 843 844 /* Update the finger span with this reading. */ 845 spans[num_spans].width++; 846 spans[num_spans].cum += p[i]; 847 spans[num_spans].cog += p[i] * (i + 1); 848 } 849 } 850 if (state != ATP_PSPAN_INACTIVE) 851 num_spans++; /* close the last finger span */ 852 853 /* post-process the spans */ 854 for (i = 0; i < num_spans; i++) { 855 /* filter away unwanted pressure spans */ 856 if ((spans[i].cum < atp_pspan_min_cum_pressure) || 857 (spans[i].width > atp_pspan_max_width)) { 858 if ((i + 1) < num_spans) { 859 memcpy(&spans[i], &spans[i + 1], 860 (num_spans - i - 1) * sizeof(atp_pspan)); 861 i--; 862 } 863 num_spans--; 864 continue; 865 } 866 867 /* compute this span's representative location */ 868 spans[i].loc = spans[i].cog * atp_mickeys_scale_factor / 869 spans[i].cum; 870 871 spans[i].matched = FALSE; /* not yet matched against a stroke */ 872 } 873 874 *nspans_p = num_spans; 875} 876 877/* 878 * Match a pressure-span against a stroke-component. If there is a 879 * match, update the component's state and return TRUE. 880 */ 881static boolean_t 882atp_match_stroke_component(atp_stroke_component *component, 883 const atp_pspan *pspan, atp_stroke_type stroke_type) 884{ 885 int delta_mickeys; 886 u_int min_pressure; 887 888 delta_mickeys = pspan->loc - component->loc; 889 890 if (abs(delta_mickeys) > atp_max_delta_mickeys) 891 return (FALSE); /* the finger span is too far out; no match */ 892 893 component->loc = pspan->loc; 894 895 /* 896 * A sudden and significant increase in a pspan's cumulative 897 * pressure indicates the incidence of a new finger 898 * contact. This usually revises the pspan's 899 * centre-of-gravity, and hence the location of any/all 900 * matching stroke component(s). But such a change should 901 * *not* be interpreted as a movement. 902 */ 903 if (pspan->cum > ((3 * component->cum_pressure) >> 1)) 904 delta_mickeys = 0; 905 906 component->cum_pressure = pspan->cum; 907 if (pspan->cum > component->max_cum_pressure) 908 component->max_cum_pressure = pspan->cum; 909 910 /* 911 * Disregard the component's movement if its cumulative 912 * pressure drops below a fraction of the maximum; this 913 * fraction is determined based on the stroke's type. 914 */ 915 if (stroke_type == ATP_STROKE_TOUCH) 916 min_pressure = (3 * component->max_cum_pressure) >> 2; 917 else 918 min_pressure = component->max_cum_pressure >> 2; 919 if (component->cum_pressure < min_pressure) 920 delta_mickeys = 0; 921 922 component->delta_mickeys = delta_mickeys; 923 return (TRUE); 924} 925 926static void 927atp_match_strokes_against_pspans(struct atp_softc *sc, atp_axis axis, 928 atp_pspan *pspans, u_int n_pspans, u_int repeat_count) 929{ 930 u_int i, j; 931 u_int repeat_index = 0; 932 933 /* Determine the index of the multi-span. */ 934 if (repeat_count) { 935 u_int cum = 0; 936 for (i = 0; i < n_pspans; i++) { 937 if (pspans[i].cum > cum) { 938 repeat_index = i; 939 cum = pspans[i].cum; 940 } 941 } 942 } 943 944 for (i = 0; i < sc->sc_n_strokes; i++) { 945 atp_stroke *stroke = &sc->sc_strokes[i]; 946 if (stroke->components[axis].matched) 947 continue; /* skip matched components */ 948 949 for (j = 0; j < n_pspans; j++) { 950 if (pspans[j].matched) 951 continue; /* skip matched pspans */ 952 953 if (atp_match_stroke_component( 954 &stroke->components[axis], &pspans[j], 955 stroke->type)) { 956 /* There is a match. */ 957 stroke->components[axis].matched = TRUE; 958 959 /* Take care to repeat at the multi-span. */ 960 if ((repeat_count > 0) && (j == repeat_index)) 961 repeat_count--; 962 else 963 pspans[j].matched = TRUE; 964 965 break; /* skip to the next stroke */ 966 } 967 } /* loop over pspans */ 968 } /* loop over strokes */ 969} 970 971/* 972 * Update strokes by matching against current pressure-spans. 973 * Return TRUE if any movement is detected. 974 */ 975static boolean_t 976atp_update_strokes(struct atp_softc *sc, atp_pspan *pspans_x, 977 u_int n_xpspans, atp_pspan *pspans_y, u_int n_ypspans) 978{ 979 u_int i, j; 980 atp_stroke *stroke; 981 boolean_t movement = FALSE; 982 u_int repeat_count = 0; 983 984 /* Reset X and Y components of all strokes as unmatched. */ 985 for (i = 0; i < sc->sc_n_strokes; i++) { 986 stroke = &sc->sc_strokes[i]; 987 stroke->components[X].matched = FALSE; 988 stroke->components[Y].matched = FALSE; 989 } 990 991 /* 992 * Usually, the X and Y pspans come in pairs (the common case 993 * being a single pair). It is possible, however, that 994 * multiple contacts resolve to a single pspan along an 995 * axis, as illustrated in the following: 996 * 997 * F = finger-contact 998 * 999 * pspan pspan 1000 * +-----------------------+ 1001 * | . . | 1002 * | . . | 1003 * | . . | 1004 * | . . | 1005 * pspan |.........F......F | 1006 * | | 1007 * | | 1008 * | | 1009 * +-----------------------+ 1010 * 1011 * 1012 * The above case can be detected by a difference in the 1013 * number of X and Y pspans. When this happens, X and Y pspans 1014 * aren't easy to pair or match against strokes. 1015 * 1016 * When X and Y pspans differ in number, the axis with the 1017 * smaller number of pspans is regarded as having a repeating 1018 * pspan (or a multi-pspan)--in the above illustration, the 1019 * Y-axis has a repeating pspan. Our approach is to try to 1020 * match the multi-pspan repeatedly against strokes. The 1021 * difference between the number of X and Y pspans gives us a 1022 * crude repeat_count for matching multi-pspans--i.e. the 1023 * multi-pspan along the Y axis (above) has a repeat_count of 1. 1024 */ 1025 repeat_count = abs(n_xpspans - n_ypspans); 1026 1027 atp_match_strokes_against_pspans(sc, X, pspans_x, n_xpspans, 1028 (((repeat_count != 0) && ((n_xpspans < n_ypspans))) ? 1029 repeat_count : 0)); 1030 atp_match_strokes_against_pspans(sc, Y, pspans_y, n_ypspans, 1031 (((repeat_count != 0) && (n_ypspans < n_xpspans)) ? 1032 repeat_count : 0)); 1033 1034 /* Update the state of strokes based on the above pspan matches. */ 1035 for (i = 0; i < sc->sc_n_strokes; i++) { 1036 stroke = &sc->sc_strokes[i]; 1037 if (stroke->components[X].matched && 1038 stroke->components[Y].matched) { 1039 atp_advance_stroke_state(sc, stroke, &movement); 1040 } else { 1041 /* 1042 * At least one component of this stroke 1043 * didn't match against current pspans; 1044 * terminate it. 1045 */ 1046 atp_terminate_stroke(sc, i); 1047 } 1048 } 1049 1050 /* Add new strokes for pairs of unmatched pspans */ 1051 for (i = 0; i < n_xpspans; i++) { 1052 if (pspans_x[i].matched == FALSE) break; 1053 } 1054 for (j = 0; j < n_ypspans; j++) { 1055 if (pspans_y[j].matched == FALSE) break; 1056 } 1057 if ((i < n_xpspans) && (j < n_ypspans)) { 1058#ifdef USB_DEBUG 1059 if (atp_debug >= ATP_LLEVEL_INFO) { 1060 printf("unmatched pspans:"); 1061 for (; i < n_xpspans; i++) { 1062 if (pspans_x[i].matched) 1063 continue; 1064 printf(" X:[loc:%u,cum:%u]", 1065 pspans_x[i].loc, pspans_x[i].cum); 1066 } 1067 for (; j < n_ypspans; j++) { 1068 if (pspans_y[j].matched) 1069 continue; 1070 printf(" Y:[loc:%u,cum:%u]", 1071 pspans_y[j].loc, pspans_y[j].cum); 1072 } 1073 printf("\n"); 1074 } 1075#endif /* USB_DEBUG */ 1076 if ((n_xpspans == 1) && (n_ypspans == 1)) 1077 /* The common case of a single pair of new pspans. */ 1078 atp_add_stroke(sc, &pspans_x[0], &pspans_y[0]); 1079 else 1080 atp_add_new_strokes(sc, 1081 pspans_x, n_xpspans, 1082 pspans_y, n_ypspans); 1083 } 1084 1085#ifdef USB_DEBUG 1086 if (atp_debug >= ATP_LLEVEL_INFO) { 1087 for (i = 0; i < sc->sc_n_strokes; i++) { 1088 atp_stroke *stroke = &sc->sc_strokes[i]; 1089 1090 printf(" %s%clc:%u,dm:%d,pnd:%d,cum:%d,max:%d,mv:%d%c" 1091 ",%clc:%u,dm:%d,pnd:%d,cum:%d,max:%d,mv:%d%c", 1092 (stroke->flags & ATSF_ZOMBIE) ? "zomb:" : "", 1093 (stroke->type == ATP_STROKE_TOUCH) ? '[' : '<', 1094 stroke->components[X].loc, 1095 stroke->components[X].delta_mickeys, 1096 stroke->components[X].pending, 1097 stroke->components[X].cum_pressure, 1098 stroke->components[X].max_cum_pressure, 1099 stroke->components[X].movement, 1100 (stroke->type == ATP_STROKE_TOUCH) ? ']' : '>', 1101 (stroke->type == ATP_STROKE_TOUCH) ? '[' : '<', 1102 stroke->components[Y].loc, 1103 stroke->components[Y].delta_mickeys, 1104 stroke->components[Y].pending, 1105 stroke->components[Y].cum_pressure, 1106 stroke->components[Y].max_cum_pressure, 1107 stroke->components[Y].movement, 1108 (stroke->type == ATP_STROKE_TOUCH) ? ']' : '>'); 1109 } 1110 if (sc->sc_n_strokes) 1111 printf("\n"); 1112 } 1113#endif /* USB_DEBUG */ 1114 1115 return (movement); 1116} 1117 1118/* Initialize a stroke using a pressure-span. */ 1119static __inline void 1120atp_add_stroke(struct atp_softc *sc, const atp_pspan *pspan_x, 1121 const atp_pspan *pspan_y) 1122{ 1123 atp_stroke *stroke; 1124 1125 if (sc->sc_n_strokes >= ATP_MAX_STROKES) 1126 return; 1127 stroke = &sc->sc_strokes[sc->sc_n_strokes]; 1128 1129 memset(stroke, 0, sizeof(atp_stroke)); 1130 1131 /* 1132 * Strokes begin as potential touches. If a stroke survives 1133 * longer than a threshold, or if it records significant 1134 * cumulative movement, then it is considered a 'slide'. 1135 */ 1136 stroke->type = ATP_STROKE_TOUCH; 1137 microtime(&stroke->ctime); 1138 stroke->age = 1; /* Unit: interrupts */ 1139 1140 stroke->components[X].loc = pspan_x->loc; 1141 stroke->components[X].cum_pressure = pspan_x->cum; 1142 stroke->components[X].max_cum_pressure = pspan_x->cum; 1143 stroke->components[X].matched = TRUE; 1144 1145 stroke->components[Y].loc = pspan_y->loc; 1146 stroke->components[Y].cum_pressure = pspan_y->cum; 1147 stroke->components[Y].max_cum_pressure = pspan_y->cum; 1148 stroke->components[Y].matched = TRUE; 1149 1150 sc->sc_n_strokes++; 1151 if (sc->sc_n_strokes > 1) { 1152 /* Reset double-tap-n-drag if we have more than one strokes. */ 1153 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG; 1154 } 1155 1156 DPRINTFN(ATP_LLEVEL_INFO, "[%u,%u], time: %u,%ld\n", 1157 stroke->components[X].loc, 1158 stroke->components[Y].loc, 1159 (unsigned int)stroke->ctime.tv_sec, 1160 (unsigned long int)stroke->ctime.tv_usec); 1161} 1162 1163static void 1164atp_add_new_strokes(struct atp_softc *sc, atp_pspan *pspans_x, 1165 u_int n_xpspans, atp_pspan *pspans_y, u_int n_ypspans) 1166{ 1167 int i, j; 1168 atp_pspan spans[2][ATP_MAX_PSPANS_PER_AXIS]; 1169 u_int nspans[2]; 1170 1171 /* Copy unmatched pspans into the local arrays. */ 1172 for (i = 0, nspans[X] = 0; i < n_xpspans; i++) { 1173 if (pspans_x[i].matched == FALSE) { 1174 spans[X][nspans[X]] = pspans_x[i]; 1175 nspans[X]++; 1176 } 1177 } 1178 for (j = 0, nspans[Y] = 0; j < n_ypspans; j++) { 1179 if (pspans_y[j].matched == FALSE) { 1180 spans[Y][nspans[Y]] = pspans_y[j]; 1181 nspans[Y]++; 1182 } 1183 } 1184 1185 if (nspans[X] == nspans[Y]) { 1186 /* Create new strokes from pairs of unmatched pspans */ 1187 for (i = 0, j = 0; (i < nspans[X]) && (j < nspans[Y]); i++, j++) 1188 atp_add_stroke(sc, &spans[X][i], &spans[Y][j]); 1189 } else { 1190 u_int cum = 0; 1191 atp_axis repeat_axis; /* axis with multi-pspans */ 1192 u_int repeat_count; /* repeat count for the multi-pspan*/ 1193 u_int repeat_index = 0; /* index of the multi-span */ 1194 1195 repeat_axis = (nspans[X] > nspans[Y]) ? Y : X; 1196 repeat_count = abs(nspans[X] - nspans[Y]); 1197 for (i = 0; i < nspans[repeat_axis]; i++) { 1198 if (spans[repeat_axis][i].cum > cum) { 1199 repeat_index = i; 1200 cum = spans[repeat_axis][i].cum; 1201 } 1202 } 1203 1204 /* Create new strokes from pairs of unmatched pspans */ 1205 i = 0, j = 0; 1206 for (; (i < nspans[X]) && (j < nspans[Y]); i++, j++) { 1207 atp_add_stroke(sc, &spans[X][i], &spans[Y][j]); 1208 1209 /* Take care to repeat at the multi-pspan. */ 1210 if (repeat_count > 0) { 1211 if ((repeat_axis == X) && 1212 (repeat_index == i)) { 1213 i--; /* counter loop increment */ 1214 repeat_count--; 1215 } else if ((repeat_axis == Y) && 1216 (repeat_index == j)) { 1217 j--; /* counter loop increment */ 1218 repeat_count--; 1219 } 1220 } 1221 } 1222 } 1223} 1224 1225/* 1226 * Advance the state of this stroke--and update the out-parameter 1227 * 'movement' as a side-effect. 1228 */ 1229void 1230atp_advance_stroke_state(struct atp_softc *sc, atp_stroke *stroke, 1231 boolean_t *movement) 1232{ 1233 stroke->age++; 1234 if (stroke->age <= atp_stroke_maturity_threshold) { 1235 /* Avoid noise from immature strokes. */ 1236 stroke->components[X].delta_mickeys = 0; 1237 stroke->components[Y].delta_mickeys = 0; 1238 } 1239 1240 /* Revitalize stroke if it had previously been marked as a zombie. */ 1241 if (stroke->flags & ATSF_ZOMBIE) 1242 stroke->flags &= ~ATSF_ZOMBIE; 1243 1244 if (atp_compute_stroke_movement(stroke)) 1245 *movement = TRUE; 1246 1247 if (stroke->type != ATP_STROKE_TOUCH) 1248 return; 1249 1250 /* Convert touch strokes to slides upon detecting movement or age. */ 1251 if (stroke->cum_movement >= atp_slide_min_movement) { 1252 atp_convert_to_slide(sc, stroke); 1253 } else { 1254 /* If a touch stroke is found to be older than the 1255 * touch-timeout threshold, it should be converted to 1256 * a slide; except if there is a co-incident sibling 1257 * with a later creation time. 1258 * 1259 * When multiple fingers make contact with the 1260 * touchpad, they are likely to be separated in their 1261 * times of incidence. During a multi-finger tap, 1262 * therefore, the last finger to make 1263 * contact--i.e. the one with the latest 1264 * 'ctime'--should be used to determine how the 1265 * touch-siblings get treated; otherwise older 1266 * siblings may lapse the touch-timeout and get 1267 * converted into slides prematurely. The following 1268 * loop determines if there exists another touch 1269 * stroke with a larger 'ctime' than the current 1270 * stroke (NOTE: zombies with a larger 'ctime' are 1271 * also considered) . 1272 */ 1273 1274 u_int i; 1275 for (i = 0; i < sc->sc_n_strokes; i++) { 1276 if ((&sc->sc_strokes[i] == stroke) || 1277 (sc->sc_strokes[i].type != ATP_STROKE_TOUCH)) 1278 continue; 1279 1280 if (timevalcmp(&sc->sc_strokes[i].ctime, 1281 &stroke->ctime, >)) 1282 break; 1283 } 1284 if (i == sc->sc_n_strokes) { 1285 /* Found no other touch stroke with a larger 'ctime'. */ 1286 struct timeval tdiff; 1287 1288 /* Compute the stroke's age. */ 1289 getmicrotime(&tdiff); 1290 if (timevalcmp(&tdiff, &stroke->ctime, >)) 1291 timevalsub(&tdiff, &stroke->ctime); 1292 else { 1293 /* 1294 * If we are here, it is because getmicrotime 1295 * reported the current time as being behind 1296 * the stroke's start time; getmicrotime can 1297 * be imprecise. 1298 */ 1299 tdiff.tv_sec = 0; 1300 tdiff.tv_usec = 0; 1301 } 1302 1303 if ((tdiff.tv_sec > (atp_touch_timeout / 1000000)) || 1304 ((tdiff.tv_sec == (atp_touch_timeout / 1000000)) && 1305 (tdiff.tv_usec >= 1306 (atp_touch_timeout % 1000000)))) 1307 atp_convert_to_slide(sc, stroke); 1308 } 1309 } 1310} 1311 1312/* Switch a given touch stroke to being a slide. */ 1313void 1314atp_convert_to_slide(struct atp_softc *sc, atp_stroke *stroke) 1315{ 1316 stroke->type = ATP_STROKE_SLIDE; 1317 1318 /* Are we at the beginning of a double-click-n-drag? */ 1319 if ((sc->sc_n_strokes == 1) && 1320 ((sc->sc_state & ATP_ZOMBIES_EXIST) == 0) && 1321 timevalcmp(&stroke->ctime, &sc->sc_reap_time, >)) { 1322 struct timeval delta; 1323 struct timeval window = { 1324 atp_double_tap_threshold / 1000000, 1325 atp_double_tap_threshold % 1000000 1326 }; 1327 1328 delta = stroke->ctime; 1329 timevalsub(&delta, &sc->sc_reap_time); 1330 if (timevalcmp(&delta, &window, <=)) 1331 sc->sc_state |= ATP_DOUBLE_TAP_DRAG; 1332 } 1333} 1334 1335/* 1336 * Terminate a stroke. While SLIDE strokes are dropped, TOUCH strokes 1337 * are retained as zombies so as to reap all their siblings together; 1338 * this helps establish the number of fingers involved in the tap. 1339 */ 1340static void 1341atp_terminate_stroke(struct atp_softc *sc, 1342 u_int index) /* index of the stroke to be terminated */ 1343{ 1344 atp_stroke *s = &sc->sc_strokes[index]; 1345 1346 if (s->flags & ATSF_ZOMBIE) { 1347 return; 1348 } 1349 1350 if ((s->type == ATP_STROKE_TOUCH) && 1351 (s->age > atp_stroke_maturity_threshold)) { 1352 s->flags |= ATSF_ZOMBIE; 1353 1354 /* If no zombies exist, then prepare to reap zombies later. */ 1355 if ((sc->sc_state & ATP_ZOMBIES_EXIST) == 0) { 1356 atp_setup_reap_time(sc, &s->ctime); 1357 sc->sc_state |= ATP_ZOMBIES_EXIST; 1358 } 1359 } else { 1360 /* Drop this stroke. */ 1361 memcpy(&sc->sc_strokes[index], &sc->sc_strokes[index + 1], 1362 (sc->sc_n_strokes - index - 1) * sizeof(atp_stroke)); 1363 sc->sc_n_strokes--; 1364 1365 /* 1366 * Reset the double-click-n-drag at the termination of 1367 * any slide stroke. 1368 */ 1369 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG; 1370 } 1371} 1372 1373static __inline boolean_t 1374atp_stroke_has_small_movement(const atp_stroke *stroke) 1375{ 1376 return ((abs(stroke->components[X].delta_mickeys) <= 1377 atp_small_movement_threshold) && 1378 (abs(stroke->components[Y].delta_mickeys) <= 1379 atp_small_movement_threshold)); 1380} 1381 1382/* 1383 * Accumulate delta_mickeys into the component's 'pending' bucket; if 1384 * the aggregate exceeds the small_movement_threshold, then retain 1385 * delta_mickeys for later. 1386 */ 1387static __inline void 1388atp_update_pending_mickeys(atp_stroke_component *component) 1389{ 1390 component->pending += component->delta_mickeys; 1391 if (abs(component->pending) <= atp_small_movement_threshold) 1392 component->delta_mickeys = 0; 1393 else { 1394 /* 1395 * Penalise pending mickeys for having accumulated 1396 * over short deltas. This operation has the effect of 1397 * scaling down the cumulative contribution of short 1398 * movements. 1399 */ 1400 component->pending -= (component->delta_mickeys << 1); 1401 } 1402} 1403 1404 1405static void 1406atp_compute_smoothening_scale_ratio(atp_stroke *stroke, int *numerator, 1407 int *denominator) 1408{ 1409 int dxdt; 1410 int dydt; 1411 u_int vel_squared; /* Square of the velocity vector's magnitude. */ 1412 u_int vel_squared_smooth; 1413 1414 /* Table holding (10 * sqrt(x)) for x between 1 and 256. */ 1415 static uint8_t sqrt_table[256] = { 1416 10, 14, 17, 20, 22, 24, 26, 28, 1417 30, 31, 33, 34, 36, 37, 38, 40, 1418 41, 42, 43, 44, 45, 46, 47, 48, 1419 50, 50, 51, 52, 53, 54, 55, 56, 1420 57, 58, 59, 60, 60, 61, 62, 63, 1421 64, 64, 65, 66, 67, 67, 68, 69, 1422 70, 70, 71, 72, 72, 73, 74, 74, 1423 75, 76, 76, 77, 78, 78, 79, 80, 1424 80, 81, 81, 82, 83, 83, 84, 84, 1425 85, 86, 86, 87, 87, 88, 88, 89, 1426 90, 90, 91, 91, 92, 92, 93, 93, 1427 94, 94, 95, 95, 96, 96, 97, 97, 1428 98, 98, 99, 100, 100, 100, 101, 101, 1429 102, 102, 103, 103, 104, 104, 105, 105, 1430 106, 106, 107, 107, 108, 108, 109, 109, 1431 110, 110, 110, 111, 111, 112, 112, 113, 1432 113, 114, 114, 114, 115, 115, 116, 116, 1433 117, 117, 117, 118, 118, 119, 119, 120, 1434 120, 120, 121, 121, 122, 122, 122, 123, 1435 123, 124, 124, 124, 125, 125, 126, 126, 1436 126, 127, 127, 128, 128, 128, 129, 129, 1437 130, 130, 130, 131, 131, 131, 132, 132, 1438 133, 133, 133, 134, 134, 134, 135, 135, 1439 136, 136, 136, 137, 137, 137, 138, 138, 1440 138, 139, 139, 140, 140, 140, 141, 141, 1441 141, 142, 142, 142, 143, 143, 143, 144, 1442 144, 144, 145, 145, 145, 146, 146, 146, 1443 147, 147, 147, 148, 148, 148, 149, 149, 1444 150, 150, 150, 150, 151, 151, 151, 152, 1445 152, 152, 153, 153, 153, 154, 154, 154, 1446 155, 155, 155, 156, 156, 156, 157, 157, 1447 157, 158, 158, 158, 159, 159, 159, 160 1448 }; 1449 const u_int N = sizeof(sqrt_table) / sizeof(sqrt_table[0]); 1450 1451 dxdt = stroke->components[X].delta_mickeys; 1452 dydt = stroke->components[Y].delta_mickeys; 1453 1454 *numerator = 0, *denominator = 0; /* default values. */ 1455 1456 /* Compute a smoothened magnitude_squared of the stroke's velocity. */ 1457 vel_squared = dxdt * dxdt + dydt * dydt; 1458 vel_squared_smooth = (3 * stroke->velocity_squared + vel_squared) >> 2; 1459 stroke->velocity_squared = vel_squared_smooth; /* retained as history */ 1460 if ((vel_squared == 0) || (vel_squared_smooth == 0)) 1461 return; /* returning (numerator == 0) will imply zero movement*/ 1462 1463 /* 1464 * In order to determine the overall movement scale factor, 1465 * we're actually interested in the effect of smoothening upon 1466 * the *magnitude* of velocity; i.e. we need to compute the 1467 * square-root of (vel_squared_smooth / vel_squared) in the 1468 * form of a numerator and denominator. 1469 */ 1470 1471 /* Keep within the bounds of the square-root table. */ 1472 while ((vel_squared > N) || (vel_squared_smooth > N)) { 1473 /* Dividing uniformly by 2 won't disturb the final ratio. */ 1474 vel_squared >>= 1; 1475 vel_squared_smooth >>= 1; 1476 } 1477 1478 *numerator = sqrt_table[vel_squared_smooth - 1]; 1479 *denominator = sqrt_table[vel_squared - 1]; 1480} 1481 1482/* 1483 * Compute a smoothened value for the stroke's movement from 1484 * delta_mickeys in the X and Y components. 1485 */ 1486static boolean_t 1487atp_compute_stroke_movement(atp_stroke *stroke) 1488{ 1489 int num; /* numerator of scale ratio */ 1490 int denom; /* denominator of scale ratio */ 1491 1492 /* 1493 * Short movements are added first to the 'pending' bucket, 1494 * and then acted upon only when their aggregate exceeds a 1495 * threshold. This has the effect of filtering away movement 1496 * noise. 1497 */ 1498 if (atp_stroke_has_small_movement(stroke)) { 1499 atp_update_pending_mickeys(&stroke->components[X]); 1500 atp_update_pending_mickeys(&stroke->components[Y]); 1501 } else { /* large movement */ 1502 /* clear away any pending mickeys if there are large movements*/ 1503 stroke->components[X].pending = 0; 1504 stroke->components[Y].pending = 0; 1505 } 1506 1507 /* Get the scale ratio and smoothen movement. */ 1508 atp_compute_smoothening_scale_ratio(stroke, &num, &denom); 1509 if ((num == 0) || (denom == 0)) { 1510 stroke->components[X].movement = 0; 1511 stroke->components[Y].movement = 0; 1512 stroke->velocity_squared >>= 1; /* Erode velocity_squared. */ 1513 } else { 1514 stroke->components[X].movement = 1515 (stroke->components[X].delta_mickeys * num) / denom; 1516 stroke->components[Y].movement = 1517 (stroke->components[Y].delta_mickeys * num) / denom; 1518 1519 stroke->cum_movement += 1520 abs(stroke->components[X].movement) + 1521 abs(stroke->components[Y].movement); 1522 } 1523 1524 return ((stroke->components[X].movement != 0) || 1525 (stroke->components[Y].movement != 0)); 1526} 1527 1528static __inline void 1529atp_setup_reap_time(struct atp_softc *sc, struct timeval *tvp) 1530{ 1531 struct timeval reap_window = { 1532 ATP_ZOMBIE_STROKE_REAP_WINDOW / 1000000, 1533 ATP_ZOMBIE_STROKE_REAP_WINDOW % 1000000 1534 }; 1535 1536 microtime(&sc->sc_reap_time); 1537 timevaladd(&sc->sc_reap_time, &reap_window); 1538 1539 sc->sc_reap_ctime = *tvp; /* ctime to reap */ 1540} 1541 1542static void 1543atp_reap_zombies(struct atp_softc *sc, u_int *n_reaped, u_int *reaped_xlocs) 1544{ 1545 u_int i; 1546 atp_stroke *stroke; 1547 1548 *n_reaped = 0; 1549 for (i = 0; i < sc->sc_n_strokes; i++) { 1550 struct timeval tdiff; 1551 1552 stroke = &sc->sc_strokes[i]; 1553 1554 if ((stroke->flags & ATSF_ZOMBIE) == 0) 1555 continue; 1556 1557 /* Compare this stroke's ctime with the ctime being reaped. */ 1558 if (timevalcmp(&stroke->ctime, &sc->sc_reap_ctime, >=)) { 1559 tdiff = stroke->ctime; 1560 timevalsub(&tdiff, &sc->sc_reap_ctime); 1561 } else { 1562 tdiff = sc->sc_reap_ctime; 1563 timevalsub(&tdiff, &stroke->ctime); 1564 } 1565 1566 if ((tdiff.tv_sec > (ATP_COINCIDENCE_THRESHOLD / 1000000)) || 1567 ((tdiff.tv_sec == (ATP_COINCIDENCE_THRESHOLD / 1000000)) && 1568 (tdiff.tv_usec > (ATP_COINCIDENCE_THRESHOLD % 1000000)))) { 1569 continue; /* Skip non-siblings. */ 1570 } 1571 1572 /* 1573 * Reap this sibling zombie stroke. 1574 */ 1575 1576 if (reaped_xlocs != NULL) 1577 reaped_xlocs[*n_reaped] = stroke->components[X].loc; 1578 1579 /* Erase the stroke from the sc. */ 1580 memcpy(&stroke[i], &stroke[i + 1], 1581 (sc->sc_n_strokes - i - 1) * sizeof(atp_stroke)); 1582 sc->sc_n_strokes--; 1583 1584 *n_reaped += 1; 1585 --i; /* Decr. i to keep it unchanged for the next iteration */ 1586 } 1587 1588 DPRINTFN(ATP_LLEVEL_INFO, "reaped %u zombies\n", *n_reaped); 1589 1590 /* There could still be zombies remaining in the system. */ 1591 for (i = 0; i < sc->sc_n_strokes; i++) { 1592 stroke = &sc->sc_strokes[i]; 1593 if (stroke->flags & ATSF_ZOMBIE) { 1594 DPRINTFN(ATP_LLEVEL_INFO, "zombies remain!\n"); 1595 atp_setup_reap_time(sc, &stroke->ctime); 1596 return; 1597 } 1598 } 1599 1600 /* If we reach here, then no more zombies remain. */ 1601 sc->sc_state &= ~ATP_ZOMBIES_EXIST; 1602} 1603 1604 1605/* Device methods. */ 1606static device_probe_t atp_probe; 1607static device_attach_t atp_attach; 1608static device_detach_t atp_detach; 1609static usb_callback_t atp_intr; 1610 1611static const struct usb_config atp_config[ATP_N_TRANSFER] = { 1612 [ATP_INTR_DT] = { 1613 .type = UE_INTERRUPT, 1614 .endpoint = UE_ADDR_ANY, 1615 .direction = UE_DIR_IN, 1616 .flags = { 1617 .pipe_bof = 1, 1618 .short_xfer_ok = 1, 1619 }, 1620 .bufsize = 0, /* use wMaxPacketSize */ 1621 .callback = &atp_intr, 1622 }, 1623 [ATP_RESET] = { 1624 .type = UE_CONTROL, 1625 .endpoint = 0, /* Control pipe */ 1626 .direction = UE_DIR_ANY, 1627 .bufsize = sizeof(struct usb_device_request) + MODE_LENGTH, 1628 .callback = &atp_reset_callback, 1629 .interval = 0, /* no pre-delay */ 1630 }, 1631}; 1632 1633static int 1634atp_probe(device_t self) 1635{ 1636 struct usb_attach_arg *uaa = device_get_ivars(self); 1637 1638 if (uaa->usb_mode != USB_MODE_HOST) 1639 return (ENXIO); 1640 1641 if ((uaa->info.bInterfaceClass != UICLASS_HID) || 1642 (uaa->info.bInterfaceProtocol != UIPROTO_MOUSE)) 1643 return (ENXIO); 1644 1645 return (usbd_lookup_id_by_uaa(atp_devs, sizeof(atp_devs), uaa)); 1646} 1647 1648static int 1649atp_attach(device_t dev) 1650{ 1651 struct atp_softc *sc = device_get_softc(dev); 1652 struct usb_attach_arg *uaa = device_get_ivars(dev); 1653 usb_error_t err; 1654 1655 DPRINTFN(ATP_LLEVEL_INFO, "sc=%p\n", sc); 1656 1657 sc->sc_dev = dev; 1658 sc->sc_usb_device = uaa->device; 1659 1660 /* 1661 * By default the touchpad behaves like an HID device, sending 1662 * packets with reportID = 2. Such reports contain only 1663 * limited information--they encode movement deltas and button 1664 * events,--but do not include data from the pressure 1665 * sensors. The device input mode can be switched from HID 1666 * reports to raw sensor data using vendor-specific USB 1667 * control commands; but first the mode must be read. 1668 */ 1669 err = atp_req_get_report(sc->sc_usb_device, sc->sc_mode_bytes); 1670 if (err != USB_ERR_NORMAL_COMPLETION) { 1671 DPRINTF("failed to read device mode (%d)\n", err); 1672 return (ENXIO); 1673 } 1674 1675 if (atp_set_device_mode(dev, RAW_SENSOR_MODE) != 0) { 1676 DPRINTF("failed to set mode to 'RAW_SENSOR' (%d)\n", err); 1677 return (ENXIO); 1678 } 1679 1680 mtx_init(&sc->sc_mutex, "atpmtx", NULL, MTX_DEF | MTX_RECURSE); 1681 1682 err = usbd_transfer_setup(uaa->device, 1683 &uaa->info.bIfaceIndex, sc->sc_xfer, atp_config, 1684 ATP_N_TRANSFER, sc, &sc->sc_mutex); 1685 1686 if (err) { 1687 DPRINTF("error=%s\n", usbd_errstr(err)); 1688 goto detach; 1689 } 1690 1691 if (usb_fifo_attach(sc->sc_usb_device, sc, &sc->sc_mutex, 1692 &atp_fifo_methods, &sc->sc_fifo, 1693 device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex, 1694 UID_ROOT, GID_OPERATOR, 0644)) { 1695 goto detach; 1696 } 1697 1698 device_set_usb_desc(dev); 1699 1700 sc->sc_params = &atp_dev_params[uaa->driver_info]; 1701 1702 sc->sc_hw.buttons = 3; 1703 sc->sc_hw.iftype = MOUSE_IF_USB; 1704 sc->sc_hw.type = MOUSE_PAD; 1705 sc->sc_hw.model = MOUSE_MODEL_GENERIC; 1706 sc->sc_hw.hwid = 0; 1707 sc->sc_mode.protocol = MOUSE_PROTO_MSC; 1708 sc->sc_mode.rate = -1; 1709 sc->sc_mode.resolution = MOUSE_RES_UNKNOWN; 1710 sc->sc_mode.accelfactor = 0; 1711 sc->sc_mode.level = 0; 1712 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE; 1713 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK; 1714 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC; 1715 1716 sc->sc_state = 0; 1717 1718 sc->sc_left_margin = atp_mickeys_scale_factor; 1719 sc->sc_right_margin = (sc->sc_params->n_xsensors - 1) * 1720 atp_mickeys_scale_factor; 1721 1722 return (0); 1723 1724detach: 1725 atp_detach(dev); 1726 return (ENOMEM); 1727} 1728 1729static int 1730atp_detach(device_t dev) 1731{ 1732 struct atp_softc *sc; 1733 1734 sc = device_get_softc(dev); 1735 if (sc->sc_state & ATP_ENABLED) { 1736 mtx_lock(&sc->sc_mutex); 1737 atp_disable(sc); 1738 mtx_unlock(&sc->sc_mutex); 1739 } 1740 1741 usb_fifo_detach(&sc->sc_fifo); 1742 1743 usbd_transfer_unsetup(sc->sc_xfer, ATP_N_TRANSFER); 1744 1745 mtx_destroy(&sc->sc_mutex); 1746 1747 return (0); 1748} 1749 1750static void 1751atp_intr(struct usb_xfer *xfer, usb_error_t error) 1752{ 1753 struct atp_softc *sc = usbd_xfer_softc(xfer); 1754 int len; 1755 struct usb_page_cache *pc; 1756 uint8_t status_bits; 1757 atp_pspan pspans_x[ATP_MAX_PSPANS_PER_AXIS]; 1758 atp_pspan pspans_y[ATP_MAX_PSPANS_PER_AXIS]; 1759 u_int n_xpspans = 0, n_ypspans = 0; 1760 u_int reaped_xlocs[ATP_MAX_STROKES]; 1761 u_int tap_fingers = 0; 1762 1763 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 1764 1765 switch (USB_GET_STATE(xfer)) { 1766 case USB_ST_TRANSFERRED: 1767 if (len > sc->sc_params->data_len) { 1768 DPRINTFN(ATP_LLEVEL_ERROR, 1769 "truncating large packet from %u to %u bytes\n", 1770 len, sc->sc_params->data_len); 1771 len = sc->sc_params->data_len; 1772 } 1773 if (len < sc->sc_params->data_len) 1774 goto tr_setup; 1775 1776 pc = usbd_xfer_get_frame(xfer, 0); 1777 usbd_copy_out(pc, 0, sc->sensor_data, sc->sc_params->data_len); 1778 1779 /* Interpret sensor data */ 1780 atp_interpret_sensor_data(sc->sensor_data, 1781 sc->sc_params->n_xsensors, X, sc->cur_x, 1782 sc->sc_params->prot); 1783 atp_interpret_sensor_data(sc->sensor_data, 1784 sc->sc_params->n_ysensors, Y, sc->cur_y, 1785 sc->sc_params->prot); 1786 1787 /* 1788 * If this is the initial update (from an untouched 1789 * pad), we should set the base values for the sensor 1790 * data; deltas with respect to these base values can 1791 * be used as pressure readings subsequently. 1792 */ 1793 status_bits = sc->sensor_data[sc->sc_params->data_len - 1]; 1794 if ((sc->sc_params->prot == ATP_PROT_GEYSER3 && 1795 (status_bits & ATP_STATUS_BASE_UPDATE)) || 1796 !(sc->sc_state & ATP_VALID)) { 1797 memcpy(sc->base_x, sc->cur_x, 1798 sc->sc_params->n_xsensors * sizeof(*(sc->base_x))); 1799 memcpy(sc->base_y, sc->cur_y, 1800 sc->sc_params->n_ysensors * sizeof(*(sc->base_y))); 1801 sc->sc_state |= ATP_VALID; 1802 goto tr_setup; 1803 } 1804 1805 /* Get pressure readings and detect p-spans for both axes. */ 1806 atp_get_pressures(sc->pressure_x, sc->cur_x, sc->base_x, 1807 sc->sc_params->n_xsensors); 1808 atp_detect_pspans(sc->pressure_x, sc->sc_params->n_xsensors, 1809 ATP_MAX_PSPANS_PER_AXIS, 1810 pspans_x, &n_xpspans); 1811 atp_get_pressures(sc->pressure_y, sc->cur_y, sc->base_y, 1812 sc->sc_params->n_ysensors); 1813 atp_detect_pspans(sc->pressure_y, sc->sc_params->n_ysensors, 1814 ATP_MAX_PSPANS_PER_AXIS, 1815 pspans_y, &n_ypspans); 1816 1817 /* Update strokes with new pspans to detect movements. */ 1818 sc->sc_status.flags &= ~MOUSE_POSCHANGED; 1819 if (atp_update_strokes(sc, 1820 pspans_x, n_xpspans, 1821 pspans_y, n_ypspans)) 1822 sc->sc_status.flags |= MOUSE_POSCHANGED; 1823 1824 /* Reap zombies if it is time. */ 1825 if (sc->sc_state & ATP_ZOMBIES_EXIST) { 1826 struct timeval now; 1827 1828 getmicrotime(&now); 1829 if (timevalcmp(&now, &sc->sc_reap_time, >=)) 1830 atp_reap_zombies(sc, &tap_fingers, 1831 reaped_xlocs); 1832 } 1833 1834 sc->sc_status.flags &= ~MOUSE_STDBUTTONSCHANGED; 1835 sc->sc_status.obutton = sc->sc_status.button; 1836 1837 /* Get the state of the physical buttton. */ 1838 sc->sc_status.button = (status_bits & ATP_STATUS_BUTTON) ? 1839 MOUSE_BUTTON1DOWN : 0; 1840 if (sc->sc_status.button != 0) { 1841 /* Reset DOUBLE_TAP_N_DRAG if the button is pressed. */ 1842 sc->sc_state &= ~ATP_DOUBLE_TAP_DRAG; 1843 } else if (sc->sc_state & ATP_DOUBLE_TAP_DRAG) { 1844 /* Assume a button-press with DOUBLE_TAP_N_DRAG. */ 1845 sc->sc_status.button = MOUSE_BUTTON1DOWN; 1846 } 1847 1848 sc->sc_status.flags |= 1849 sc->sc_status.button ^ sc->sc_status.obutton; 1850 if (sc->sc_status.flags & MOUSE_STDBUTTONSCHANGED) { 1851 DPRINTFN(ATP_LLEVEL_INFO, "button %s\n", 1852 ((sc->sc_status.button & MOUSE_BUTTON1DOWN) ? 1853 "pressed" : "released")); 1854 } else if ((sc->sc_status.obutton == 0) && 1855 (sc->sc_status.button == 0) && 1856 (tap_fingers != 0)) { 1857 /* Ignore single-finger taps at the edges. */ 1858 if ((tap_fingers == 1) && 1859 ((reaped_xlocs[0] <= sc->sc_left_margin) || 1860 (reaped_xlocs[0] > sc->sc_right_margin))) { 1861 tap_fingers = 0; 1862 } 1863 DPRINTFN(ATP_LLEVEL_INFO, 1864 "tap_fingers: %u\n", tap_fingers); 1865 } 1866 1867 if (sc->sc_status.flags & 1868 (MOUSE_POSCHANGED | MOUSE_STDBUTTONSCHANGED)) { 1869 int dx, dy; 1870 u_int n_movements; 1871 1872 dx = 0, dy = 0, n_movements = 0; 1873 for (u_int i = 0; i < sc->sc_n_strokes; i++) { 1874 atp_stroke *stroke = &sc->sc_strokes[i]; 1875 1876 if ((stroke->components[X].movement) || 1877 (stroke->components[Y].movement)) { 1878 dx += stroke->components[X].movement; 1879 dy += stroke->components[Y].movement; 1880 n_movements++; 1881 } 1882 } 1883 /* 1884 * Disregard movement if multiple 1885 * strokes record motion. 1886 */ 1887 if (n_movements != 1) 1888 dx = 0, dy = 0; 1889 1890 sc->sc_status.dx += dx; 1891 sc->sc_status.dy += dy; 1892 atp_add_to_queue(sc, dx, -dy, sc->sc_status.button); 1893 } 1894 1895 if (tap_fingers != 0) { 1896 /* Add a pair of events (button-down and button-up). */ 1897 switch (tap_fingers) { 1898 case 1: atp_add_to_queue(sc, 0, 0, MOUSE_BUTTON1DOWN); 1899 break; 1900 case 2: atp_add_to_queue(sc, 0, 0, MOUSE_BUTTON2DOWN); 1901 break; 1902 case 3: atp_add_to_queue(sc, 0, 0, MOUSE_BUTTON3DOWN); 1903 break; 1904 default: break;/* handle taps of only up to 3 fingers */ 1905 } 1906 atp_add_to_queue(sc, 0, 0, 0); /* button release */ 1907 } 1908 1909 /* 1910 * The device continues to trigger interrupts at a 1911 * fast rate even after touchpad activity has 1912 * stopped. Upon detecting that the device has 1913 * remained idle beyond a threshold, we reinitialize 1914 * it to silence the interrupts. 1915 */ 1916 if ((sc->sc_status.flags == 0) && 1917 (sc->sc_n_strokes == 0) && 1918 (sc->sc_status.button == 0)) { 1919 sc->sc_idlecount++; 1920 if (sc->sc_idlecount >= ATP_IDLENESS_THRESHOLD) { 1921 DPRINTFN(ATP_LLEVEL_INFO, "idle\n"); 1922 1923 /* 1924 * Use the last frame before we go idle for 1925 * calibration on pads which do not send 1926 * calibration frames. 1927 */ 1928 if (sc->sc_params->prot < ATP_PROT_GEYSER3) { 1929 memcpy(sc->base_x, sc->cur_x, 1930 sc->sc_params->n_xsensors * 1931 sizeof(*(sc->base_x))); 1932 memcpy(sc->base_y, sc->cur_y, 1933 sc->sc_params->n_ysensors * 1934 sizeof(*(sc->base_y))); 1935 } 1936 1937 sc->sc_idlecount = 0; 1938 usbd_transfer_start(sc->sc_xfer[ATP_RESET]); 1939 } 1940 } else { 1941 sc->sc_idlecount = 0; 1942 } 1943 1944 case USB_ST_SETUP: 1945 tr_setup: 1946 /* check if we can put more data into the FIFO */ 1947 if (usb_fifo_put_bytes_max( 1948 sc->sc_fifo.fp[USB_FIFO_RX]) != 0) { 1949 usbd_xfer_set_frame_len(xfer, 0, 1950 sc->sc_params->data_len); 1951 usbd_transfer_submit(xfer); 1952 } 1953 break; 1954 1955 default: /* Error */ 1956 if (error != USB_ERR_CANCELLED) { 1957 /* try clear stall first */ 1958 usbd_xfer_set_stall(xfer); 1959 goto tr_setup; 1960 } 1961 break; 1962 } 1963 1964 return; 1965} 1966 1967static void 1968atp_add_to_queue(struct atp_softc *sc, int dx, int dy, uint32_t buttons_in) 1969{ 1970 uint32_t buttons_out; 1971 uint8_t buf[8]; 1972 1973 dx = imin(dx, 254); dx = imax(dx, -256); 1974 dy = imin(dy, 254); dy = imax(dy, -256); 1975 1976 buttons_out = MOUSE_MSC_BUTTONS; 1977 if (buttons_in & MOUSE_BUTTON1DOWN) 1978 buttons_out &= ~MOUSE_MSC_BUTTON1UP; 1979 else if (buttons_in & MOUSE_BUTTON2DOWN) 1980 buttons_out &= ~MOUSE_MSC_BUTTON2UP; 1981 else if (buttons_in & MOUSE_BUTTON3DOWN) 1982 buttons_out &= ~MOUSE_MSC_BUTTON3UP; 1983 1984 DPRINTFN(ATP_LLEVEL_INFO, "dx=%d, dy=%d, buttons=%x\n", 1985 dx, dy, buttons_out); 1986 1987 /* Encode the mouse data in standard format; refer to mouse(4) */ 1988 buf[0] = sc->sc_mode.syncmask[1]; 1989 buf[0] |= buttons_out; 1990 buf[1] = dx >> 1; 1991 buf[2] = dy >> 1; 1992 buf[3] = dx - (dx >> 1); 1993 buf[4] = dy - (dy >> 1); 1994 /* Encode extra bytes for level 1 */ 1995 if (sc->sc_mode.level == 1) { 1996 buf[5] = 0; /* dz */ 1997 buf[6] = 0; /* dz - (dz / 2) */ 1998 buf[7] = MOUSE_SYS_EXTBUTTONS; /* Extra buttons all up. */ 1999 } 2000 2001 usb_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf, 2002 sc->sc_mode.packetsize, 1); 2003} 2004 2005static void 2006atp_reset_buf(struct atp_softc *sc) 2007{ 2008 /* reset read queue */ 2009 usb_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]); 2010} 2011 2012static void 2013atp_start_read(struct usb_fifo *fifo) 2014{ 2015 struct atp_softc *sc = usb_fifo_softc(fifo); 2016 int rate; 2017 2018 /* Check if we should override the default polling interval */ 2019 rate = sc->sc_pollrate; 2020 /* Range check rate */ 2021 if (rate > 1000) 2022 rate = 1000; 2023 /* Check for set rate */ 2024 if ((rate > 0) && (sc->sc_xfer[ATP_INTR_DT] != NULL)) { 2025 /* Stop current transfer, if any */ 2026 usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]); 2027 /* Set new interval */ 2028 usbd_xfer_set_interval(sc->sc_xfer[ATP_INTR_DT], 1000 / rate); 2029 /* Only set pollrate once */ 2030 sc->sc_pollrate = 0; 2031 } 2032 2033 usbd_transfer_start(sc->sc_xfer[ATP_INTR_DT]); 2034} 2035 2036static void 2037atp_stop_read(struct usb_fifo *fifo) 2038{ 2039 struct atp_softc *sc = usb_fifo_softc(fifo); 2040 2041 usbd_transfer_stop(sc->sc_xfer[ATP_INTR_DT]); 2042} 2043 2044 2045static int 2046atp_open(struct usb_fifo *fifo, int fflags) 2047{ 2048 DPRINTFN(ATP_LLEVEL_INFO, "\n"); 2049 2050 if (fflags & FREAD) { 2051 struct atp_softc *sc = usb_fifo_softc(fifo); 2052 int rc; 2053 2054 if (sc->sc_state & ATP_ENABLED) 2055 return (EBUSY); 2056 2057 if (usb_fifo_alloc_buffer(fifo, 2058 ATP_FIFO_BUF_SIZE, ATP_FIFO_QUEUE_MAXLEN)) { 2059 return (ENOMEM); 2060 } 2061 2062 rc = atp_enable(sc); 2063 if (rc != 0) { 2064 usb_fifo_free_buffer(fifo); 2065 return (rc); 2066 } 2067 } 2068 2069 return (0); 2070} 2071 2072static void 2073atp_close(struct usb_fifo *fifo, int fflags) 2074{ 2075 if (fflags & FREAD) { 2076 struct atp_softc *sc = usb_fifo_softc(fifo); 2077 2078 atp_disable(sc); 2079 usb_fifo_free_buffer(fifo); 2080 } 2081} 2082 2083int 2084atp_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags) 2085{ 2086 struct atp_softc *sc = usb_fifo_softc(fifo); 2087 mousemode_t mode; 2088 int error = 0; 2089 2090 mtx_lock(&sc->sc_mutex); 2091 2092 switch(cmd) { 2093 case MOUSE_GETHWINFO: 2094 *(mousehw_t *)addr = sc->sc_hw; 2095 break; 2096 case MOUSE_GETMODE: 2097 *(mousemode_t *)addr = sc->sc_mode; 2098 break; 2099 case MOUSE_SETMODE: 2100 mode = *(mousemode_t *)addr; 2101 2102 if (mode.level == -1) 2103 /* Don't change the current setting */ 2104 ; 2105 else if ((mode.level < 0) || (mode.level > 1)) { 2106 error = EINVAL; 2107 goto done; 2108 } 2109 sc->sc_mode.level = mode.level; 2110 sc->sc_pollrate = mode.rate; 2111 sc->sc_hw.buttons = 3; 2112 2113 if (sc->sc_mode.level == 0) { 2114 sc->sc_mode.protocol = MOUSE_PROTO_MSC; 2115 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE; 2116 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK; 2117 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC; 2118 } else if (sc->sc_mode.level == 1) { 2119 sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE; 2120 sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE; 2121 sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK; 2122 sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC; 2123 } 2124 atp_reset_buf(sc); 2125 break; 2126 case MOUSE_GETLEVEL: 2127 *(int *)addr = sc->sc_mode.level; 2128 break; 2129 case MOUSE_SETLEVEL: 2130 if (*(int *)addr < 0 || *(int *)addr > 1) { 2131 error = EINVAL; 2132 goto done; 2133 } 2134 sc->sc_mode.level = *(int *)addr; 2135 sc->sc_hw.buttons = 3; 2136 2137 if (sc->sc_mode.level == 0) { 2138 sc->sc_mode.protocol = MOUSE_PROTO_MSC; 2139 sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE; 2140 sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK; 2141 sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC; 2142 } else if (sc->sc_mode.level == 1) { 2143 sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE; 2144 sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE; 2145 sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK; 2146 sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC; 2147 } 2148 atp_reset_buf(sc); 2149 break; 2150 case MOUSE_GETSTATUS: { 2151 mousestatus_t *status = (mousestatus_t *)addr; 2152 2153 *status = sc->sc_status; 2154 sc->sc_status.obutton = sc->sc_status.button; 2155 sc->sc_status.button = 0; 2156 sc->sc_status.dx = 0; 2157 sc->sc_status.dy = 0; 2158 sc->sc_status.dz = 0; 2159 2160 if (status->dx || status->dy || status->dz) 2161 status->flags |= MOUSE_POSCHANGED; 2162 if (status->button != status->obutton) 2163 status->flags |= MOUSE_BUTTONSCHANGED; 2164 break; 2165 } 2166 default: 2167 error = ENOTTY; 2168 } 2169 2170done: 2171 mtx_unlock(&sc->sc_mutex); 2172 return (error); 2173} 2174 2175static int 2176atp_sysctl_scale_factor_handler(SYSCTL_HANDLER_ARGS) 2177{ 2178 int error; 2179 u_int tmp; 2180 u_int prev_mickeys_scale_factor; 2181 2182 prev_mickeys_scale_factor = atp_mickeys_scale_factor; 2183 2184 tmp = atp_mickeys_scale_factor; 2185 error = sysctl_handle_int(oidp, &tmp, 0, req); 2186 if (error != 0 || req->newptr == NULL) 2187 return (error); 2188 2189 if (tmp == prev_mickeys_scale_factor) 2190 return (0); /* no change */ 2191 2192 atp_mickeys_scale_factor = tmp; 2193 DPRINTFN(ATP_LLEVEL_INFO, "%s: resetting mickeys_scale_factor to %u\n", 2194 ATP_DRIVER_NAME, tmp); 2195 2196 /* Update dependent thresholds. */ 2197 if (atp_small_movement_threshold == (prev_mickeys_scale_factor >> 3)) 2198 atp_small_movement_threshold = atp_mickeys_scale_factor >> 3; 2199 if (atp_max_delta_mickeys == ((3 * prev_mickeys_scale_factor) >> 1)) 2200 atp_max_delta_mickeys = ((3 * atp_mickeys_scale_factor) >>1); 2201 if (atp_slide_min_movement == (prev_mickeys_scale_factor >> 3)) 2202 atp_slide_min_movement = atp_mickeys_scale_factor >> 3; 2203 2204 return (0); 2205} 2206 2207static device_method_t atp_methods[] = { 2208 /* Device interface */ 2209 DEVMETHOD(device_probe, atp_probe), 2210 DEVMETHOD(device_attach, atp_attach), 2211 DEVMETHOD(device_detach, atp_detach), 2212 { 0, 0 } 2213}; 2214 2215static driver_t atp_driver = { 2216 ATP_DRIVER_NAME, 2217 atp_methods, 2218 sizeof(struct atp_softc) 2219}; 2220 2221static devclass_t atp_devclass; 2222 2223DRIVER_MODULE(atp, uhub, atp_driver, atp_devclass, NULL, 0); 2224MODULE_DEPEND(atp, usb, 1, 1, 1); 2225MODULE_VERSION(atp, 1); 2226