src/evdev-mt-touchpad.c

   1 /*
   2  * Copyright © 2014 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <assert.h>
  26 #include <math.h>
  27 #include <stdbool.h>
  28
  29 #include "evdev-mt-touchpad.h"
  30
  31 #define DEFAULT_ACCEL_NUMERATOR 1200.0
  32 #define DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR 700.0
  33
  34 static inline int
  35 tp_hysteresis(int in, int center, int margin)
  36 {
  37         int diff = in - center;
  38         if (abs(diff) <= margin)
  39                 return center;
  40
  41         if (diff > margin)
  42                 return center + diff - margin;
  43         else
  44                 return center + diff + margin;
  45 }
  46
  47 static inline struct tp_motion *
  48 tp_motion_history_offset(struct tp_touch *t, int offset)
  49 {
  50         int offset_index =
  51                 (t->history.index - offset + TOUCHPAD_HISTORY_LENGTH) %
  52                 TOUCHPAD_HISTORY_LENGTH;
  53
  54         return &t->history.samples[offset_index];
  55 }
  56
  57 static void
  58 tp_filter_motion(struct tp_dispatch *tp,
  59                  double *dx, double *dy, uint64_t time)
  60 {
  61         struct motion_params motion;
  62
  63         motion.dx = *dx * tp->accel.x_scale_coeff;
  64         motion.dy = *dy * tp->accel.y_scale_coeff;
  65
  66         if (motion.dx != 0.0 || motion.dy != 0.0)
  67                 filter_dispatch(tp->filter, &motion, tp, time);
  68
  69         *dx = motion.dx;
  70         *dy = motion.dy;
  71 }
  72
  73 static inline void
  74 tp_motion_history_push(struct tp_touch *t)
  75 {
  76         int motion_index = (t->history.index + 1) % TOUCHPAD_HISTORY_LENGTH;
  77
  78         if (t->history.count < TOUCHPAD_HISTORY_LENGTH)
  79                 t->history.count++;
  80
  81         t->history.samples[motion_index].x = t->x;
  82         t->history.samples[motion_index].y = t->y;
  83         t->history.index = motion_index;
  84 }
  85
  86 static inline void
  87 tp_motion_hysteresis(struct tp_dispatch *tp,
  88                      struct tp_touch *t)
  89 {
  90         int x = t->x,
  91             y = t->y;
  92
  93         if (t->history.count == 0) {
  94                 t->hysteresis.center_x = t->x;
  95                 t->hysteresis.center_y = t->y;
  96         } else {
  97                 x = tp_hysteresis(x,
  98                                   t->hysteresis.center_x,
  99                                   tp->hysteresis.margin_x);
 100                 y = tp_hysteresis(y,
 101                                   t->hysteresis.center_y,
 102                                   tp->hysteresis.margin_y);
 103                 t->hysteresis.center_x = x;
 104                 t->hysteresis.center_y = y;
 105                 t->x = x;
 106                 t->y = y;
 107         }
 108 }
 109
 110 static inline void
 111 tp_motion_history_reset(struct tp_touch *t)
 112 {
 113         t->history.count = 0;
 114 }
 115
 116 static inline struct tp_touch *
 117 tp_current_touch(struct tp_dispatch *tp)
 118 {
 119         return &tp->touches[min(tp->slot, tp->ntouches - 1)];
 120 }
 121
 122 static inline struct tp_touch *
 123 tp_get_touch(struct tp_dispatch *tp, unsigned int slot)
 124 {
 125         assert(slot < tp->ntouches);
 126         return &tp->touches[slot];
 127 }
 128
 129 static inline void
 130 tp_begin_touch(struct tp_dispatch *tp, struct tp_touch *t)
 131 {
 132         if (t->state != TOUCH_UPDATE) {
 133                 tp_motion_history_reset(t);
 134                 t->dirty = true;
 135                 t->state = TOUCH_BEGIN;
 136                 t->pinned.is_pinned = false;
 137                 tp->nfingers_down++;
 138                 assert(tp->nfingers_down >= 1);
 139                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 140         }
 141 }
 142
 143 static inline void
 144 tp_end_touch(struct tp_dispatch *tp, struct tp_touch *t)
 145 {
 146         if (t->state == TOUCH_NONE)
 147                 return;
 148
 149         t->dirty = true;
 150         t->is_pointer = false;
 151         t->palm.is_palm = false;
 152         t->state = TOUCH_END;
 153         t->pinned.is_pinned = false;
 154         assert(tp->nfingers_down >= 1);
 155         tp->nfingers_down--;
 156         tp->queued |= TOUCHPAD_EVENT_MOTION;
 157 }
 158
 159 static double
 160 tp_estimate_delta(int x0, int x1, int x2, int x3)
 161 {
 162         return (x0 + x1 - x2 - x3) / 4;
 163 }
 164
 165 void
 166 tp_get_delta(struct tp_touch *t, double *dx, double *dy)
 167 {
 168         if (t->history.count < 4) {
 169                 *dx = 0;
 170                 *dy = 0;
 171                 return;
 172         }
 173
 174         *dx = tp_estimate_delta(tp_motion_history_offset(t, 0)->x,
 175                                 tp_motion_history_offset(t, 1)->x,
 176                                 tp_motion_history_offset(t, 2)->x,
 177                                 tp_motion_history_offset(t, 3)->x);
 178         *dy = tp_estimate_delta(tp_motion_history_offset(t, 0)->y,
 179                                 tp_motion_history_offset(t, 1)->y,
 180                                 tp_motion_history_offset(t, 2)->y,
 181                                 tp_motion_history_offset(t, 3)->y);
 182 }
 183
 184 static void
 185 tp_process_absolute(struct tp_dispatch *tp,
 186                     const struct input_event *e,
 187                     uint64_t time)
 188 {
 189         struct tp_touch *t = tp_current_touch(tp);
 190
 191         switch(e->code) {
 192         case ABS_MT_POSITION_X:
 193                 t->x = e->value;
 194                 t->millis = time;
 195                 t->dirty = true;
 196                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 197                 break;
 198         case ABS_MT_POSITION_Y:
 199                 t->y = e->value;
 200                 t->millis = time;
 201                 t->dirty = true;
 202                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 203                 break;
 204         case ABS_MT_SLOT:
 205                 tp->slot = e->value;
 206                 break;
 207         case ABS_MT_TRACKING_ID:
 208                 t->millis = time;
 209                 if (e->value != -1)
 210                         tp_begin_touch(tp, t);
 211                 else
 212                         tp_end_touch(tp, t);
 213         }
 214 }
 215
 216 static void
 217 tp_process_absolute_st(struct tp_dispatch *tp,
 218                        const struct input_event *e,
 219                        uint64_t time)
 220 {
 221         struct tp_touch *t = tp_current_touch(tp);
 222
 223         switch(e->code) {
 224         case ABS_X:
 225                 t->x = e->value;
 226                 t->millis = time;
 227                 t->dirty = true;
 228                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 229                 break;
 230         case ABS_Y:
 231                 t->y = e->value;
 232                 t->millis = time;
 233                 t->dirty = true;
 234                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 235                 break;
 236         }
 237 }
 238
 239 static void
 240 tp_process_fake_touch(struct tp_dispatch *tp,
 241                       const struct input_event *e,
 242                       uint64_t time)
 243 {
 244         struct tp_touch *t;
 245         unsigned int fake_touches;
 246         unsigned int nfake_touches;
 247         unsigned int i;
 248         unsigned int shift;
 249
 250         if (e->code != BTN_TOUCH &&
 251             (e->code < BTN_TOOL_DOUBLETAP || e->code > BTN_TOOL_QUADTAP))
 252                 return;
 253
 254         shift = e->code == BTN_TOUCH ? 0 : (e->code - BTN_TOOL_DOUBLETAP + 1);
 255
 256         if (e->value)
 257                 tp->fake_touches |= 1 << shift;
 258         else
 259                 tp->fake_touches &= ~(0x1 << shift);
 260
 261         fake_touches = tp->fake_touches;
 262         nfake_touches = 0;
 263         while (fake_touches) {
 264                 nfake_touches++;
 265                 fake_touches >>= 1;
 266         }
 267
 268         for (i = 0; i < tp->ntouches; i++) {
 269                 t = tp_get_touch(tp, i);
 270                 if (i >= nfake_touches) {
 271                         if (t->state != TOUCH_NONE) {
 272                                 tp_end_touch(tp, t);
 273                                 t->millis = time;
 274                         }
 275                 } else if (t->state != TOUCH_UPDATE &&
 276                            t->state != TOUCH_BEGIN) {
 277                         t->state = TOUCH_NONE;
 278                         tp_begin_touch(tp, t);
 279                         t->millis = time;
 280                         t->fake =true;
 281                 }
 282         }
 283
 284         assert(tp->nfingers_down == nfake_touches);
 285 }
 286
 287 static void
 288 tp_process_key(struct tp_dispatch *tp,
 289                const struct input_event *e,
 290                uint64_t time)
 291 {
 292         switch (e->code) {
 293                 case BTN_LEFT:
 294                 case BTN_MIDDLE:
 295                 case BTN_RIGHT:
 296                         tp_process_button(tp, e, time);
 297                         break;
 298                 case BTN_TOUCH:
 299                 case BTN_TOOL_DOUBLETAP:
 300                 case BTN_TOOL_TRIPLETAP:
 301                 case BTN_TOOL_QUADTAP:
 302                         if (!tp->has_mt)
 303                                 tp_process_fake_touch(tp, e, time);
 304                         break;
 305         }
 306 }
 307
 308 static void
 309 tp_unpin_finger(struct tp_dispatch *tp, struct tp_touch *t)
 310 {
 311         unsigned int xdist, ydist;
 312
 313         if (!t->pinned.is_pinned)
 314                 return;
 315
 316         xdist = abs(t->x - t->pinned.center_x);
 317         ydist = abs(t->y - t->pinned.center_y);
 318
 319         if (xdist * xdist + ydist * ydist >=
 320                         tp->buttons.motion_dist * tp->buttons.motion_dist) {
 321                 t->pinned.is_pinned = false;
 322                 tp_set_pointer(tp, t);
 323         }
 324 }
 325
 326 static void
 327 tp_pin_fingers(struct tp_dispatch *tp)
 328 {
 329         struct tp_touch *t;
 330
 331         tp_for_each_touch(tp, t) {
 332                 t->is_pointer = false;
 333                 t->pinned.is_pinned = true;
 334                 t->pinned.center_x = t->x;
 335                 t->pinned.center_y = t->y;
 336         }
 337 }
 338
 339 static int
 340 tp_touch_active(struct tp_dispatch *tp, struct tp_touch *t)
 341 {
 342         return (t->state == TOUCH_BEGIN || t->state == TOUCH_UPDATE) &&
 343                 !t->palm.is_palm &&
 344                 !t->pinned.is_pinned && tp_button_touch_active(tp, t);
 345 }
 346
 347 void
 348 tp_set_pointer(struct tp_dispatch *tp, struct tp_touch *t)
 349 {
 350         struct tp_touch *tmp = NULL;
 351
 352         /* Only set the touch as pointer if we don't have one yet */
 353         tp_for_each_touch(tp, tmp) {
 354                 if (tmp->is_pointer)
 355                         return;
 356         }
 357
 358         if (tp_touch_active(tp, t))
 359                 t->is_pointer = true;
 360 }
 361
 362 static void
 363 tp_palm_detect(struct tp_dispatch *tp, struct tp_touch *t, uint64_t time)
 364 {
 365         const int PALM_TIMEOUT = 200; /* ms */
 366
 367         /* If labelled a touch as palm, we unlabel as palm when
 368            we move out of the palm edge zone within the timeout.
 369          */
 370         if (t->palm.is_palm) {
 371                 if (time < t->palm.time + PALM_TIMEOUT &&
 372                     (t->x > tp->palm.left_edge && t->x < tp->palm.right_edge)) {
 373                         t->palm.is_palm = false;
 374                         tp_set_pointer(tp, t);
 375                 }
 376                 return;
 377         }
 378
 379         /* palm must start in exclusion zone, it's ok to move into
 380            the zone without being a palm */
 381         if (t->state != TOUCH_BEGIN ||
 382             (t->x > tp->palm.left_edge && t->x < tp->palm.right_edge))
 383                 return;
 384
 385         /* don't detect palm in software button areas, it's
 386            likely that legitimate touches start in the area
 387            covered by the exclusion zone */
 388         if (tp->buttons.is_clickpad &&
 389             tp_button_is_inside_softbutton_area(tp, t))
 390                 return;
 391
 392         t->palm.is_palm = true;
 393         t->palm.time = time;
 394 }
 395
 396 static void
 397 tp_process_state(struct tp_dispatch *tp, uint64_t time)
 398 {
 399         struct tp_touch *t;
 400         struct tp_touch *first = tp_get_touch(tp, 0);
 401
 402         tp_for_each_touch(tp, t) {
 403                 if (!tp->has_mt && t != first && first->fake) {
 404                         t->x = first->x;
 405                         t->y = first->y;
 406                         if (!t->dirty)
 407                                 t->dirty = first->dirty;
 408                 } else if (!t->dirty) {
 409                         continue;
 410                 }
 411
 412                 tp_palm_detect(tp, t, time);
 413
 414                 tp_motion_hysteresis(tp, t);
 415                 tp_motion_history_push(t);
 416
 417                 tp_unpin_finger(tp, t);
 418         }
 419
 420         tp_button_handle_state(tp, time);
 421
 422         /*
 423          * We have a physical button down event on a clickpad. To avoid
 424          * spurious pointer moves by the clicking finger we pin all fingers.
 425          * We unpin fingers when they move more then a certain threshold to
 426          * to allow drag and drop.
 427          */
 428         if ((tp->queued & TOUCHPAD_EVENT_BUTTON_PRESS) &&
 429             tp->buttons.is_clickpad)
 430                 tp_pin_fingers(tp);
 431 }
 432
 433 static void
 434 tp_post_process_state(struct tp_dispatch *tp, uint64_t time)
 435 {
 436         struct tp_touch *t;
 437
 438         tp_for_each_touch(tp, t) {
 439                 if (!t->dirty)
 440                         continue;
 441
 442                 if (t->state == TOUCH_END) {
 443                         t->state = TOUCH_NONE;
 444                         t->fake = false;
 445                 } else if (t->state == TOUCH_BEGIN)
 446                         t->state = TOUCH_UPDATE;
 447
 448                 t->dirty = false;
 449         }
 450
 451         tp->buttons.old_state = tp->buttons.state;
 452
 453         tp->queued = TOUCHPAD_EVENT_NONE;
 454 }
 455
 456 static void
 457 tp_post_twofinger_scroll(struct tp_dispatch *tp, uint64_t time)
 458 {
 459         struct tp_touch *t;
 460         int nchanged = 0;
 461         double dx = 0, dy =0;
 462         double tmpx, tmpy;
 463
 464         tp_for_each_touch(tp, t) {
 465                 if (tp_touch_active(tp, t) && t->dirty) {
 466                         nchanged++;
 467                         tp_get_delta(t, &tmpx, &tmpy);
 468
 469                         dx += tmpx;
 470                         dy += tmpy;
 471                 }
 472                 /* Stop spurious MOTION events at the end of scrolling */
 473                 t->is_pointer = false;
 474         }
 475
 476         if (nchanged == 0)
 477                 return;
 478
 479         dx /= nchanged;
 480         dy /= nchanged;
 481
 482         tp_filter_motion(tp, &dx, &dy, time);
 483
 484         /* Require at least five px scrolling to start */
 485         if (dy <= -5.0 || dy >= 5.0)
 486                 tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
 487
 488         if (dx <= -5.0 || dx >= 5.0)
 489                 tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
 490
 491         if (dy != 0.0 &&
 492             (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))) {
 493                 pointer_notify_axis(&tp->device->base,
 494                                     time,
 495                                     LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
 496                                     dy);
 497         }
 498
 499         if (dx != 0.0 &&
 500             (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))) {
 501                 pointer_notify_axis(&tp->device->base,
 502                                     time,
 503                                     LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
 504                                     dx);
 505         }
 506 }
 507
 508 static void
 509 tp_stop_scroll_events(struct tp_dispatch *tp, uint64_t time)
 510 {
 511         /* terminate scrolling with a zero scroll event */
 512         if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
 513                 pointer_notify_axis(&tp->device->base,
 514                                     time,
 515                                     LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
 516                                     0);
 517         if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))
 518                 pointer_notify_axis(&tp->device->base,
 519                                     time,
 520                                     LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
 521                                     0);
 522
 523         tp->scroll.direction = 0;
 524 }
 525
 526 static int
 527 tp_post_scroll_events(struct tp_dispatch *tp, uint64_t time)
 528 {
 529         struct tp_touch *t;
 530         int nfingers_down = 0;
 531
 532         /* Only count active touches for 2 finger scrolling */
 533         tp_for_each_touch(tp, t) {
 534                 if (tp_touch_active(tp, t))
 535                         nfingers_down++;
 536         }
 537
 538         if (nfingers_down != 2) {
 539                 tp_stop_scroll_events(tp, time);
 540                 return 0;
 541         }
 542
 543         tp_post_twofinger_scroll(tp, time);
 544         return 1;
 545 }
 546
 547 static void
 548 tp_post_events(struct tp_dispatch *tp, uint64_t time)
 549 {
 550         struct tp_touch *t = tp_current_touch(tp);
 551         double dx, dy;
 552         int consumed = 0;
 553
 554         consumed |= tp_tap_handle_state(tp, time);
 555         consumed |= tp_post_button_events(tp, time);
 556
 557         if (consumed) {
 558                 tp_stop_scroll_events(tp, time);
 559                 return;
 560         }
 561
 562         if (tp_post_scroll_events(tp, time) != 0)
 563                 return;
 564
 565         if (!t->is_pointer) {
 566                 tp_for_each_touch(tp, t) {
 567                         if (t->is_pointer)
 568                                 break;
 569                 }
 570         }
 571
 572         if (!t->is_pointer ||
 573             !t->dirty ||
 574             t->history.count < TOUCHPAD_MIN_SAMPLES)
 575                 return;
 576
 577         tp_get_delta(t, &dx, &dy);
 578         tp_filter_motion(tp, &dx, &dy, time);
 579
 580         if (dx != 0.0 || dy != 0.0)
 581                 pointer_notify_motion(&tp->device->base, time, dx, dy);
 582 }
 583
 584 static void
 585 tp_process(struct evdev_dispatch *dispatch,
 586            struct evdev_device *device,
 587            struct input_event *e,
 588            uint64_t time)
 589 {
 590         struct tp_dispatch *tp =
 591                 (struct tp_dispatch *)dispatch;
 592
 593         switch (e->type) {
 594         case EV_ABS:
 595                 if (tp->has_mt)
 596                         tp_process_absolute(tp, e, time);
 597                 else
 598                         tp_process_absolute_st(tp, e, time);
 599                 break;
 600         case EV_KEY:
 601                 tp_process_key(tp, e, time);
 602                 break;
 603         case EV_SYN:
 604                 tp_process_state(tp, time);
 605                 tp_post_events(tp, time);
 606                 tp_post_process_state(tp, time);
 607                 break;
 608         }
 609 }
 610
 611 static void
 612 tp_destroy(struct evdev_dispatch *dispatch)
 613 {
 614         struct tp_dispatch *tp =
 615                 (struct tp_dispatch*)dispatch;
 616
 617         tp_destroy_tap(tp);
 618         tp_destroy_buttons(tp);
 619
 620         filter_destroy(tp->filter);
 621         free(tp->touches);
 622         free(tp);
 623 }
 624
 625 static struct evdev_dispatch_interface tp_interface = {
 626         tp_process,
 627         tp_destroy
 628 };
 629
 630 static void
 631 tp_init_touch(struct tp_dispatch *tp,
 632               struct tp_touch *t)
 633 {
 634         t->tp = tp;
 635 }
 636
 637 static int
 638 tp_init_slots(struct tp_dispatch *tp,
 639               struct evdev_device *device)
 640 {
 641         size_t i;
 642         const struct input_absinfo *absinfo;
 643
 644         absinfo = libevdev_get_abs_info(device->evdev, ABS_MT_SLOT);
 645         if (absinfo) {
 646                 tp->ntouches = absinfo->maximum + 1;
 647                 tp->slot = absinfo->value;
 648                 tp->has_mt = true;
 649         } else {
 650                 struct map {
 651                         unsigned int code;
 652                         int ntouches;
 653                 } max_touches[] = {
 654                         { BTN_TOOL_QUINTTAP, 5 },
 655                         { BTN_TOOL_QUADTAP, 4 },
 656                         { BTN_TOOL_TRIPLETAP, 3 },
 657                         { BTN_TOOL_DOUBLETAP, 2 },
 658                 };
 659                 struct map *m;
 660
 661                 tp->slot = 0;
 662                 tp->has_mt = false;
 663                 tp->ntouches = 1;
 664
 665                 ARRAY_FOR_EACH(max_touches, m) {
 666                         if (libevdev_has_event_code(device->evdev,
 667                                                     EV_KEY,
 668                                                     m->code)) {
 669                                 tp->ntouches = m->ntouches;
 670                                 break;
 671                         }
 672                 }
 673         }
 674         tp->touches = calloc(tp->ntouches,
 675                              sizeof(struct tp_touch));
 676         if (!tp->touches)
 677                 return -1;
 678
 679         for (i = 0; i < tp->ntouches; i++)
 680                 tp_init_touch(tp, &tp->touches[i]);
 681
 682         return 0;
 683 }
 684
 685 static int
 686 tp_init_accel(struct tp_dispatch *tp, double diagonal)
 687 {
 688         struct motion_filter *accel;
 689         int res_x, res_y;
 690
 691         if (tp->has_mt) {
 692                 res_x = libevdev_get_abs_resolution(tp->device->evdev,
 693                                                     ABS_MT_POSITION_X);
 694                 res_y = libevdev_get_abs_resolution(tp->device->evdev,
 695                                                     ABS_MT_POSITION_Y);
 696         } else {
 697                 res_x = libevdev_get_abs_resolution(tp->device->evdev,
 698                                                     ABS_X);
 699                 res_y = libevdev_get_abs_resolution(tp->device->evdev,
 700                                                     ABS_Y);
 701         }
 702
 703         /*
 704          * Not all touchpads report the same amount of units/mm (resolution).
 705          * Normalize motion events to a resolution of 15.74 units/mm
 706          * (== 400 dpi) as base (unaccelerated) speed. This also evens out any
 707          * differences in x and y resolution, so that a circle on the
 708          * touchpad does not turn into an elipse on the screen.
 709          *
 710          * We pick 400dpi as thats one of the many default resolutions
 711          * for USB mice, so we end up with a similar base speed on the device.
 712          */
 713         if (res_x > 1 && res_y > 1) {
 714                 tp->accel.x_scale_coeff = (400/25.4) / res_x;
 715                 tp->accel.y_scale_coeff = (400/25.4) / res_y;
 716         } else {
 717         /*
 718          * For touchpads where the driver does not provide resolution, fall
 719          * back to scaling motion events based on the diagonal size in units.
 720          */
 721                 tp->accel.x_scale_coeff = DEFAULT_ACCEL_NUMERATOR / diagonal;
 722                 tp->accel.y_scale_coeff = DEFAULT_ACCEL_NUMERATOR / diagonal;
 723         }
 724
 725         accel = create_pointer_accelator_filter(
 726                         pointer_accel_profile_smooth_simple);
 727         if (accel == NULL)
 728                 return -1;
 729
 730         tp->filter = accel;
 731
 732         return 0;
 733 }
 734
 735 static int
 736 tp_init_scroll(struct tp_dispatch *tp)
 737 {
 738         tp->scroll.direction = 0;
 739
 740         return 0;
 741 }
 742
 743 static int
 744 tp_init_palmdetect(struct tp_dispatch *tp,
 745                    struct evdev_device *device)
 746 {
 747         int width;
 748
 749         width = abs(device->abs.absinfo_x->maximum -
 750                     device->abs.absinfo_x->minimum);
 751
 752         /* palm edges are 5% of the width on each side */
 753         tp->palm.right_edge = device->abs.absinfo_x->maximum - width * 0.05;
 754         tp->palm.left_edge = device->abs.absinfo_x->minimum + width * 0.05;
 755
 756         return 0;
 757 }
 758
 759
 760 static int
 761 tp_init(struct tp_dispatch *tp,
 762         struct evdev_device *device)
 763 {
 764         int width, height;
 765         double diagonal;
 766
 767         tp->base.interface = &tp_interface;
 768         tp->device = device;
 769
 770         if (tp_init_slots(tp, device) != 0)
 771                 return -1;
 772
 773         width = abs(device->abs.absinfo_x->maximum -
 774                     device->abs.absinfo_x->minimum);
 775         height = abs(device->abs.absinfo_y->maximum -
 776                      device->abs.absinfo_y->minimum);
 777         diagonal = sqrt(width*width + height*height);
 778
 779         tp->hysteresis.margin_x =
 780                 diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
 781         tp->hysteresis.margin_y =
 782                 diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
 783
 784         if (tp_init_scroll(tp) != 0)
 785                 return -1;
 786
 787         if (tp_init_accel(tp, diagonal) != 0)
 788                 return -1;
 789
 790         if (tp_init_tap(tp) != 0)
 791                 return -1;
 792
 793         if (tp_init_buttons(tp, device) != 0)
 794                 return -1;
 795
 796         if (tp_init_palmdetect(tp, device) != 0)
 797                 return -1;
 798
 799         return 0;
 800 }
 801
 802 struct evdev_dispatch *
 803 evdev_mt_touchpad_create(struct evdev_device *device)
 804 {
 805         struct tp_dispatch *tp;
 806
 807         tp = zalloc(sizeof *tp);
 808         if (!tp)
 809                 return NULL;
 810
 811         if (tp_init(tp, device) != 0) {
 812                 tp_destroy(&tp->base);
 813                 return NULL;
 814         }
 815
 816         return  &tp->base;
 817 }