drivers/input/mouse/synaptics.c

   1 /*
   2  * Synaptics TouchPad PS/2 mouse driver
   3  *
   4  *   2003 Dmitry Torokhov <dtor@mail.ru>
   5  *     Added support for pass-through port. Special thanks to Peter Berg Larsen
   6  *     for explaining various Synaptics quirks.
   7  *
   8  *   2003 Peter Osterlund <petero2@telia.com>
   9  *     Ported to 2.5 input device infrastructure.
  10  *
  11  *   Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch>
  12  *     start merging tpconfig and gpm code to a xfree-input module
  13  *     adding some changes and extensions (ex. 3rd and 4th button)
  14  *
  15  *   Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu>
  16  *   Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com>
  17  *     code for the special synaptics commands (from the tpconfig-source)
  18  *
  19  * This program is free software; you can redistribute it and/or modify it
  20  * under the terms of the GNU General Public License version 2 as published by
  21  * the Free Software Foundation.
  22  *
  23  * Trademarks are the property of their respective owners.
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/delay.h>
  28 #include <linux/dmi.h>
  29 #include <linux/input/mt.h>
  30 #include <linux/serio.h>
  31 #include <linux/libps2.h>
  32 #include <linux/leds.h>
  33 #include <linux/slab.h>
  34 #include "psmouse.h"
  35 #include "synaptics.h"
  36
  37 /*
  38  * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
  39  * section 2.3.2, which says that they should be valid regardless of the
  40  * actual size of the sensor.
  41  * Note that newer firmware allows querying device for maximum useable
  42  * coordinates.
  43  */
  44 #define XMIN_NOMINAL 1472
  45 #define XMAX_NOMINAL 5472
  46 #define YMIN_NOMINAL 1408
  47 #define YMAX_NOMINAL 4448
  48
  49 /*
  50  * Synaptics touchpads report the y coordinate from bottom to top, which is
  51  * opposite from what userspace expects.
  52  * This function is used to invert y before reporting.
  53  */
  54 static int synaptics_invert_y(int y)
  55 {
  56         return YMAX_NOMINAL + YMIN_NOMINAL - y;
  57 }
  58
  59
  60 /*****************************************************************************
  61  *      Stuff we need even when we do not want native Synaptics support
  62  ****************************************************************************/
  63
  64 /*
  65  * Set the synaptics touchpad mode byte by special commands
  66  */
  67 static int synaptics_mode_cmd(struct psmouse *psmouse, unsigned char mode)
  68 {
  69         unsigned char param[1];
  70
  71         if (psmouse_sliced_command(psmouse, mode))
  72                 return -1;
  73         param[0] = SYN_PS_SET_MODE2;
  74         if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_SETRATE))
  75                 return -1;
  76         return 0;
  77 }
  78
  79 int synaptics_detect(struct psmouse *psmouse, bool set_properties)
  80 {
  81         struct ps2dev *ps2dev = &psmouse->ps2dev;
  82         unsigned char param[4];
  83
  84         param[0] = 0;
  85
  86         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
  87         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
  88         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
  89         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
  90         ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
  91
  92         if (param[1] != 0x47)
  93                 return -ENODEV;
  94
  95         if (set_properties) {
  96                 psmouse->vendor = "Synaptics";
  97                 psmouse->name = "TouchPad";
  98         }
  99
 100         return 0;
 101 }
 102
 103 void synaptics_reset(struct psmouse *psmouse)
 104 {
 105         /* reset touchpad back to relative mode, gestures enabled */
 106         synaptics_mode_cmd(psmouse, 0);
 107 }
 108
 109 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
 110
 111 /*****************************************************************************
 112  *      Synaptics communications functions
 113  ****************************************************************************/
 114
 115 /*
 116  * Send a command to the synpatics touchpad by special commands
 117  */
 118 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, unsigned char *param)
 119 {
 120         if (psmouse_sliced_command(psmouse, c))
 121                 return -1;
 122         if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO))
 123                 return -1;
 124         return 0;
 125 }
 126
 127 /*
 128  * Read the model-id bytes from the touchpad
 129  * see also SYN_MODEL_* macros
 130  */
 131 static int synaptics_model_id(struct psmouse *psmouse)
 132 {
 133         struct synaptics_data *priv = psmouse->private;
 134         unsigned char mi[3];
 135
 136         if (synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi))
 137                 return -1;
 138         priv->model_id = (mi[0]<<16) | (mi[1]<<8) | mi[2];
 139         return 0;
 140 }
 141
 142 /*
 143  * Read the capability-bits from the touchpad
 144  * see also the SYN_CAP_* macros
 145  */
 146 static int synaptics_capability(struct psmouse *psmouse)
 147 {
 148         struct synaptics_data *priv = psmouse->private;
 149         unsigned char cap[3];
 150
 151         if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
 152                 return -1;
 153         priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
 154         priv->ext_cap = priv->ext_cap_0c = 0;
 155
 156         /*
 157          * Older firmwares had submodel ID fixed to 0x47
 158          */
 159         if (SYN_ID_FULL(priv->identity) < 0x705 &&
 160             SYN_CAP_SUBMODEL_ID(priv->capabilities) != 0x47) {
 161                 return -1;
 162         }
 163
 164         /*
 165          * Unless capExtended is set the rest of the flags should be ignored
 166          */
 167         if (!SYN_CAP_EXTENDED(priv->capabilities))
 168                 priv->capabilities = 0;
 169
 170         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 1) {
 171                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
 172                         psmouse_warn(psmouse,
 173                                      "device claims to have extended capabilities, but I'm not able to read them.\n");
 174                 } else {
 175                         priv->ext_cap = (cap[0] << 16) | (cap[1] << 8) | cap[2];
 176
 177                         /*
 178                          * if nExtBtn is greater than 8 it should be considered
 179                          * invalid and treated as 0
 180                          */
 181                         if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) > 8)
 182                                 priv->ext_cap &= 0xff0fff;
 183                 }
 184         }
 185
 186         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 4) {
 187                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB_0C, cap)) {
 188                         psmouse_warn(psmouse,
 189                                      "device claims to have extended capability 0x0c, but I'm not able to read it.\n");
 190                 } else {
 191                         priv->ext_cap_0c = (cap[0] << 16) | (cap[1] << 8) | cap[2];
 192                 }
 193         }
 194
 195         return 0;
 196 }
 197
 198 /*
 199  * Identify Touchpad
 200  * See also the SYN_ID_* macros
 201  */
 202 static int synaptics_identify(struct psmouse *psmouse)
 203 {
 204         struct synaptics_data *priv = psmouse->private;
 205         unsigned char id[3];
 206
 207         if (synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id))
 208                 return -1;
 209         priv->identity = (id[0]<<16) | (id[1]<<8) | id[2];
 210         if (SYN_ID_IS_SYNAPTICS(priv->identity))
 211                 return 0;
 212         return -1;
 213 }
 214
 215 /*
 216  * Read touchpad resolution and maximum reported coordinates
 217  * Resolution is left zero if touchpad does not support the query
 218  */
 219 static int synaptics_resolution(struct psmouse *psmouse)
 220 {
 221         struct synaptics_data *priv = psmouse->private;
 222         unsigned char resp[3];
 223
 224         if (SYN_ID_MAJOR(priv->identity) < 4)
 225                 return 0;
 226
 227         if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, resp) == 0) {
 228                 if (resp[0] != 0 && (resp[1] & 0x80) && resp[2] != 0) {
 229                         priv->x_res = resp[0]; /* x resolution in units/mm */
 230                         priv->y_res = resp[2]; /* y resolution in units/mm */
 231                 }
 232         }
 233
 234         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
 235             SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
 236                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_MAX_COORDS, resp)) {
 237                         psmouse_warn(psmouse,
 238                                      "device claims to have max coordinates query, but I'm not able to read it.\n");
 239                 } else {
 240                         priv->x_max = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
 241                         priv->y_max = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
 242                 }
 243         }
 244
 245         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 7 &&
 246             SYN_CAP_MIN_DIMENSIONS(priv->ext_cap_0c)) {
 247                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_MIN_COORDS, resp)) {
 248                         psmouse_warn(psmouse,
 249                                      "device claims to have min coordinates query, but I'm not able to read it.\n");
 250                 } else {
 251                         priv->x_min = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
 252                         priv->y_min = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
 253                 }
 254         }
 255
 256         return 0;
 257 }
 258
 259 static int synaptics_query_hardware(struct psmouse *psmouse)
 260 {
 261         if (synaptics_identify(psmouse))
 262                 return -1;
 263         if (synaptics_model_id(psmouse))
 264                 return -1;
 265         if (synaptics_capability(psmouse))
 266                 return -1;
 267         if (synaptics_resolution(psmouse))
 268                 return -1;
 269
 270         return 0;
 271 }
 272
 273 static int synaptics_set_advanced_gesture_mode(struct psmouse *psmouse)
 274 {
 275         static unsigned char param = 0xc8;
 276         struct synaptics_data *priv = psmouse->private;
 277
 278         if (!SYN_CAP_ADV_GESTURE(priv->ext_cap_0c))
 279                 return 0;
 280
 281         if (psmouse_sliced_command(psmouse, SYN_QUE_MODEL))
 282                 return -1;
 283
 284         if (ps2_command(&psmouse->ps2dev, &param, PSMOUSE_CMD_SETRATE))
 285                 return -1;
 286
 287         /* Advanced gesture mode also sends multi finger data */
 288         priv->capabilities |= BIT(1);
 289
 290         return 0;
 291 }
 292
 293 static int synaptics_set_mode(struct psmouse *psmouse)
 294 {
 295         struct synaptics_data *priv = psmouse->private;
 296
 297         priv->mode = 0;
 298         if (priv->absolute_mode)
 299                 priv->mode |= SYN_BIT_ABSOLUTE_MODE;
 300         if (priv->disable_gesture)
 301                 priv->mode |= SYN_BIT_DISABLE_GESTURE;
 302         if (psmouse->rate >= 80)
 303                 priv->mode |= SYN_BIT_HIGH_RATE;
 304         if (SYN_CAP_EXTENDED(priv->capabilities))
 305                 priv->mode |= SYN_BIT_W_MODE;
 306
 307         if (synaptics_mode_cmd(psmouse, priv->mode))
 308                 return -1;
 309
 310         if (priv->absolute_mode &&
 311             synaptics_set_advanced_gesture_mode(psmouse)) {
 312                 psmouse_err(psmouse, "Advanced gesture mode init failed.\n");
 313                 return -1;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
 320 {
 321         struct synaptics_data *priv = psmouse->private;
 322
 323         if (rate >= 80) {
 324                 priv->mode |= SYN_BIT_HIGH_RATE;
 325                 psmouse->rate = 80;
 326         } else {
 327                 priv->mode &= ~SYN_BIT_HIGH_RATE;
 328                 psmouse->rate = 40;
 329         }
 330
 331         synaptics_mode_cmd(psmouse, priv->mode);
 332 }
 333
 334 /*****************************************************************************
 335  *      Synaptics pass-through PS/2 port support
 336  ****************************************************************************/
 337 static int synaptics_pt_write(struct serio *serio, unsigned char c)
 338 {
 339         struct psmouse *parent = serio_get_drvdata(serio->parent);
 340         char rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */
 341
 342         if (psmouse_sliced_command(parent, c))
 343                 return -1;
 344         if (ps2_command(&parent->ps2dev, &rate_param, PSMOUSE_CMD_SETRATE))
 345                 return -1;
 346         return 0;
 347 }
 348
 349 static int synaptics_pt_start(struct serio *serio)
 350 {
 351         struct psmouse *parent = serio_get_drvdata(serio->parent);
 352         struct synaptics_data *priv = parent->private;
 353
 354         serio_pause_rx(parent->ps2dev.serio);
 355         priv->pt_port = serio;
 356         serio_continue_rx(parent->ps2dev.serio);
 357
 358         return 0;
 359 }
 360
 361 static void synaptics_pt_stop(struct serio *serio)
 362 {
 363         struct psmouse *parent = serio_get_drvdata(serio->parent);
 364         struct synaptics_data *priv = parent->private;
 365
 366         serio_pause_rx(parent->ps2dev.serio);
 367         priv->pt_port = NULL;
 368         serio_continue_rx(parent->ps2dev.serio);
 369 }
 370
 371 static int synaptics_is_pt_packet(unsigned char *buf)
 372 {
 373         return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
 374 }
 375
 376 static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet)
 377 {
 378         struct psmouse *child = serio_get_drvdata(ptport);
 379
 380         if (child && child->state == PSMOUSE_ACTIVATED) {
 381                 serio_interrupt(ptport, packet[1], 0);
 382                 serio_interrupt(ptport, packet[4], 0);
 383                 serio_interrupt(ptport, packet[5], 0);
 384                 if (child->pktsize == 4)
 385                         serio_interrupt(ptport, packet[2], 0);
 386         } else
 387                 serio_interrupt(ptport, packet[1], 0);
 388 }
 389
 390 static void synaptics_pt_activate(struct psmouse *psmouse)
 391 {
 392         struct synaptics_data *priv = psmouse->private;
 393         struct psmouse *child = serio_get_drvdata(priv->pt_port);
 394
 395         /* adjust the touchpad to child's choice of protocol */
 396         if (child) {
 397                 if (child->pktsize == 4)
 398                         priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
 399                 else
 400                         priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT;
 401
 402                 if (synaptics_mode_cmd(psmouse, priv->mode))
 403                         psmouse_warn(psmouse,
 404                                      "failed to switch guest protocol\n");
 405         }
 406 }
 407
 408 static void synaptics_pt_create(struct psmouse *psmouse)
 409 {
 410         struct serio *serio;
 411
 412         serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
 413         if (!serio) {
 414                 psmouse_err(psmouse,
 415                             "not enough memory for pass-through port\n");
 416                 return;
 417         }
 418
 419         serio->id.type = SERIO_PS_PSTHRU;
 420         strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
 421         strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
 422         serio->write = synaptics_pt_write;
 423         serio->start = synaptics_pt_start;
 424         serio->stop = synaptics_pt_stop;
 425         serio->parent = psmouse->ps2dev.serio;
 426
 427         psmouse->pt_activate = synaptics_pt_activate;
 428
 429         psmouse_info(psmouse, "serio: %s port at %s\n",
 430                      serio->name, psmouse->phys);
 431         serio_register_port(serio);
 432 }
 433
 434 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS_LED
 435 /*
 436  * LED handling:
 437  * Some Synaptics devices have an embeded LED at the top-left corner.
 438  */
 439
 440 struct synaptics_led {
 441         struct psmouse *psmouse;
 442         struct work_struct work;
 443         struct led_classdev cdev;
 444 };
 445
 446 static void synaptics_set_led(struct psmouse *psmouse, int on)
 447 {
 448         int i;
 449         unsigned char cmd = on ? 0x88 : 0x10;
 450
 451         ps2_begin_command(&psmouse->ps2dev);
 452         if (__ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11))
 453                 goto out;
 454         for (i = 6; i >= 0; i -= 2) {
 455                 unsigned char d = (cmd >> i) & 3;
 456                 if (__ps2_command(&psmouse->ps2dev, &d, PSMOUSE_CMD_SETRES))
 457                         goto out;
 458         }
 459         cmd = 0x0a;
 460         __ps2_command(&psmouse->ps2dev, &cmd, PSMOUSE_CMD_SETRATE);
 461  out:
 462         ps2_end_command(&psmouse->ps2dev);
 463 }
 464
 465 static void synaptics_led_work(struct work_struct *work)
 466 {
 467         struct synaptics_led *led;
 468
 469         led = container_of(work, struct synaptics_led, work);
 470         synaptics_set_led(led->psmouse, led->cdev.brightness);
 471 }
 472
 473 static void synaptics_led_cdev_brightness_set(struct led_classdev *cdev,
 474                                               enum led_brightness value)
 475 {
 476         struct synaptics_led *led;
 477
 478         led = container_of(cdev, struct synaptics_led, cdev);
 479         schedule_work(&led->work);
 480 }
 481
 482 static void synaptics_sync_led(struct psmouse *psmouse)
 483 {
 484         struct synaptics_data *priv = psmouse->private;
 485
 486         if (priv->led)
 487                 synaptics_set_led(psmouse, priv->led->cdev.brightness);
 488 }
 489
 490 static int synaptics_init_led(struct psmouse *psmouse)
 491 {
 492         struct synaptics_data *priv = psmouse->private;
 493         struct synaptics_led *led;
 494         int err;
 495
 496         /* FIXME: LED is supposedly detectable in cap0c[1] 0x20, but it seems
 497          * not working on real machines.
 498          * So we check the product id to be sure.
 499          */
 500         if (!priv->ext_cap_0c || SYN_CAP_PRODUCT_ID(priv->ext_cap) != 0xe4)
 501                 return 0;
 502
 503         printk(KERN_INFO "synaptics: support LED control\n");
 504         led = kzalloc(sizeof(struct synaptics_led), GFP_KERNEL);
 505         if (!led)
 506                 return -ENOMEM;
 507         led->psmouse = psmouse;
 508         INIT_WORK(&led->work, synaptics_led_work);
 509         led->cdev.name = "psmouse::synaptics";
 510         led->cdev.brightness_set = synaptics_led_cdev_brightness_set;
 511         led->cdev.flags = LED_CORE_SUSPENDRESUME;
 512         err = led_classdev_register(NULL, &led->cdev);
 513         if (err < 0) {
 514                 kfree(led);
 515                 return err;
 516         }
 517         priv->led = led;
 518         return 0;
 519 }
 520
 521 static void synaptics_free_led(struct psmouse *psmouse)
 522 {
 523         struct synaptics_data *priv = psmouse->private;
 524
 525         if (!priv->led)
 526                 return;
 527         cancel_work_sync(&priv->led->work);
 528         synaptics_set_led(psmouse, 0);
 529         led_classdev_unregister(&priv->led->cdev);
 530         kfree(priv->led);
 531 }
 532 #else
 533 #define synaptics_init_led(ps)  0
 534 #define synaptics_free_led(ps)  do {} while (0)
 535 #define synaptics_sync_led(ps)  do {} while (0)
 536 #endif
 537
 538 /*****************************************************************************
 539  *      Functions to interpret the absolute mode packets
 540  ****************************************************************************/
 541
 542 static void synaptics_mt_state_set(struct synaptics_mt_state *state, int count,
 543                                    int sgm, int agm)
 544 {
 545         state->count = count;
 546         state->sgm = sgm;
 547         state->agm = agm;
 548 }
 549
 550 static void synaptics_parse_agm(const unsigned char buf[],
 551                                 struct synaptics_data *priv,
 552                                 struct synaptics_hw_state *hw)
 553 {
 554         struct synaptics_hw_state *agm = &priv->agm;
 555         int agm_packet_type;
 556
 557         agm_packet_type = (buf[5] & 0x30) >> 4;
 558         switch (agm_packet_type) {
 559         case 1:
 560                 /* Gesture packet: (x, y, z) half resolution */
 561                 agm->w = hw->w;
 562                 agm->x = (((buf[4] & 0x0f) << 8) | buf[1]) << 1;
 563                 agm->y = (((buf[4] & 0xf0) << 4) | buf[2]) << 1;
 564                 agm->z = ((buf[3] & 0x30) | (buf[5] & 0x0f)) << 1;
 565                 break;
 566
 567         case 2:
 568                 /* AGM-CONTACT packet: (count, sgm, agm) */
 569                 synaptics_mt_state_set(&agm->mt_state, buf[1], buf[2], buf[4]);
 570                 break;
 571
 572         default:
 573                 break;
 574         }
 575
 576         /* Record that at least one AGM has been received since last SGM */
 577         priv->agm_pending = true;
 578 }
 579
 580 static int synaptics_parse_hw_state(const unsigned char buf[],
 581                                     struct synaptics_data *priv,
 582                                     struct synaptics_hw_state *hw)
 583 {
 584         memset(hw, 0, sizeof(struct synaptics_hw_state));
 585
 586         if (SYN_MODEL_NEWABS(priv->model_id)) {
 587                 hw->w = (((buf[0] & 0x30) >> 2) |
 588                          ((buf[0] & 0x04) >> 1) |
 589                          ((buf[3] & 0x04) >> 2));
 590
 591                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
 592                 hw->right = (buf[0] & 0x02) ? 1 : 0;
 593
 594                 if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
 595                         /*
 596                          * Clickpad's button is transmitted as middle button,
 597                          * however, since it is primary button, we will report
 598                          * it as BTN_LEFT.
 599                          */
 600                         hw->left = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
 601
 602                 } else if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
 603                         hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
 604                         if (hw->w == 2)
 605                                 hw->scroll = (signed char)(buf[1]);
 606                 }
 607
 608                 if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
 609                         hw->up   = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
 610                         hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
 611                 }
 612
 613                 if ((SYN_CAP_ADV_GESTURE(priv->ext_cap_0c) ||
 614                         SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) &&
 615                     hw->w == 2) {
 616                         synaptics_parse_agm(buf, priv, hw);
 617                         return 1;
 618                 }
 619
 620                 hw->x = (((buf[3] & 0x10) << 8) |
 621                          ((buf[1] & 0x0f) << 8) |
 622                          buf[4]);
 623                 hw->y = (((buf[3] & 0x20) << 7) |
 624                          ((buf[1] & 0xf0) << 4) |
 625                          buf[5]);
 626                 hw->z = buf[2];
 627
 628                 if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
 629                     ((buf[0] ^ buf[3]) & 0x02)) {
 630                         switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
 631                         default:
 632                                 /*
 633                                  * if nExtBtn is greater than 8 it should be
 634                                  * considered invalid and treated as 0
 635                                  */
 636                                 break;
 637                         case 8:
 638                                 hw->ext_buttons |= ((buf[5] & 0x08)) ? 0x80 : 0;
 639                                 hw->ext_buttons |= ((buf[4] & 0x08)) ? 0x40 : 0;
 640                         case 6:
 641                                 hw->ext_buttons |= ((buf[5] & 0x04)) ? 0x20 : 0;
 642                                 hw->ext_buttons |= ((buf[4] & 0x04)) ? 0x10 : 0;
 643                         case 4:
 644                                 hw->ext_buttons |= ((buf[5] & 0x02)) ? 0x08 : 0;
 645                                 hw->ext_buttons |= ((buf[4] & 0x02)) ? 0x04 : 0;
 646                         case 2:
 647                                 hw->ext_buttons |= ((buf[5] & 0x01)) ? 0x02 : 0;
 648                                 hw->ext_buttons |= ((buf[4] & 0x01)) ? 0x01 : 0;
 649                         }
 650                 }
 651         } else {
 652                 hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
 653                 hw->y = (((buf[4] & 0x1f) << 8) | buf[5]);
 654
 655                 hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F));
 656                 hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1));
 657
 658                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
 659                 hw->right = (buf[0] & 0x02) ? 1 : 0;
 660         }
 661
 662         return 0;
 663 }
 664
 665 static void synaptics_report_semi_mt_slot(struct input_dev *dev, int slot,
 666                                           bool active, int x, int y)
 667 {
 668         input_mt_slot(dev, slot);
 669         input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
 670         if (active) {
 671                 input_report_abs(dev, ABS_MT_POSITION_X, x);
 672                 input_report_abs(dev, ABS_MT_POSITION_Y, synaptics_invert_y(y));
 673         }
 674 }
 675
 676 static void synaptics_report_semi_mt_data(struct input_dev *dev,
 677                                           const struct synaptics_hw_state *a,
 678                                           const struct synaptics_hw_state *b,
 679                                           int num_fingers)
 680 {
 681         if (num_fingers >= 2) {
 682                 synaptics_report_semi_mt_slot(dev, 0, true, min(a->x, b->x),
 683                                               min(a->y, b->y));
 684                 synaptics_report_semi_mt_slot(dev, 1, true, max(a->x, b->x),
 685                                               max(a->y, b->y));
 686         } else if (num_fingers == 1) {
 687                 synaptics_report_semi_mt_slot(dev, 0, true, a->x, a->y);
 688                 synaptics_report_semi_mt_slot(dev, 1, false, 0, 0);
 689         } else {
 690                 synaptics_report_semi_mt_slot(dev, 0, false, 0, 0);
 691                 synaptics_report_semi_mt_slot(dev, 1, false, 0, 0);
 692         }
 693 }
 694
 695 static void synaptics_report_buttons(struct psmouse *psmouse,
 696                                      const struct synaptics_hw_state *hw)
 697 {
 698         struct input_dev *dev = psmouse->dev;
 699         struct synaptics_data *priv = psmouse->private;
 700         int i;
 701
 702         input_report_key(dev, BTN_LEFT, hw->left);
 703         input_report_key(dev, BTN_RIGHT, hw->right);
 704
 705         if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
 706                 input_report_key(dev, BTN_MIDDLE, hw->middle);
 707
 708         if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
 709                 input_report_key(dev, BTN_FORWARD, hw->up);
 710                 input_report_key(dev, BTN_BACK, hw->down);
 711         }
 712
 713         for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
 714                 input_report_key(dev, BTN_0 + i, hw->ext_buttons & (1 << i));
 715 }
 716
 717 static void synaptics_report_slot(struct input_dev *dev, int slot,
 718                                   const struct synaptics_hw_state *hw)
 719 {
 720         input_mt_slot(dev, slot);
 721         input_mt_report_slot_state(dev, MT_TOOL_FINGER, (hw != NULL));
 722         if (!hw)
 723                 return;
 724
 725         input_report_abs(dev, ABS_MT_POSITION_X, hw->x);
 726         input_report_abs(dev, ABS_MT_POSITION_Y, synaptics_invert_y(hw->y));
 727         input_report_abs(dev, ABS_MT_PRESSURE, hw->z);
 728 }
 729
 730 static void synaptics_report_mt_data(struct psmouse *psmouse,
 731                                      struct synaptics_mt_state *mt_state,
 732                                      const struct synaptics_hw_state *sgm)
 733 {
 734         struct input_dev *dev = psmouse->dev;
 735         struct synaptics_data *priv = psmouse->private;
 736         struct synaptics_hw_state *agm = &priv->agm;
 737         struct synaptics_mt_state *old = &priv->mt_state;
 738
 739         switch (mt_state->count) {
 740         case 0:
 741                 synaptics_report_slot(dev, 0, NULL);
 742                 synaptics_report_slot(dev, 1, NULL);
 743                 break;
 744         case 1:
 745                 if (mt_state->sgm == -1) {
 746                         synaptics_report_slot(dev, 0, NULL);
 747                         synaptics_report_slot(dev, 1, NULL);
 748                 } else if (mt_state->sgm == 0) {
 749                         synaptics_report_slot(dev, 0, sgm);
 750                         synaptics_report_slot(dev, 1, NULL);
 751                 } else {
 752                         synaptics_report_slot(dev, 0, NULL);
 753                         synaptics_report_slot(dev, 1, sgm);
 754                 }
 755                 break;
 756         default:
 757                 /*
 758                  * If the finger slot contained in SGM is valid, and either
 759                  * hasn't changed, or is new, then report SGM in MTB slot 0.
 760                  * Otherwise, empty MTB slot 0.
 761                  */
 762                 if (mt_state->sgm != -1 &&
 763                     (mt_state->sgm == old->sgm || old->sgm == -1))
 764                         synaptics_report_slot(dev, 0, sgm);
 765                 else
 766                         synaptics_report_slot(dev, 0, NULL);
 767
 768                 /*
 769                  * If the finger slot contained in AGM is valid, and either
 770                  * hasn't changed, or is new, then report AGM in MTB slot 1.
 771                  * Otherwise, empty MTB slot 1.
 772                  */
 773                 if (mt_state->agm != -1 &&
 774                     (mt_state->agm == old->agm || old->agm == -1))
 775                         synaptics_report_slot(dev, 1, agm);
 776                 else
 777                         synaptics_report_slot(dev, 1, NULL);
 778                 break;
 779         }
 780
 781         /* Don't use active slot count to generate BTN_TOOL events. */
 782         input_mt_report_pointer_emulation(dev, false);
 783
 784         /* Send the number of fingers reported by touchpad itself. */
 785         input_mt_report_finger_count(dev, mt_state->count);
 786
 787         synaptics_report_buttons(psmouse, sgm);
 788
 789         input_sync(dev);
 790 }
 791
 792 /* Handle case where mt_state->count = 0 */
 793 static void synaptics_image_sensor_0f(struct synaptics_data *priv,
 794                                       struct synaptics_mt_state *mt_state)
 795 {
 796         synaptics_mt_state_set(mt_state, 0, -1, -1);
 797         priv->mt_state_lost = false;
 798 }
 799
 800 /* Handle case where mt_state->count = 1 */
 801 static void synaptics_image_sensor_1f(struct synaptics_data *priv,
 802                                       struct synaptics_mt_state *mt_state)
 803 {
 804         struct synaptics_hw_state *agm = &priv->agm;
 805         struct synaptics_mt_state *old = &priv->mt_state;
 806
 807         /*
 808          * If the last AGM was (0,0,0), and there is only one finger left,
 809          * then we absolutely know that SGM contains slot 0, and all other
 810          * fingers have been removed.
 811          */
 812         if (priv->agm_pending && agm->z == 0) {
 813                 synaptics_mt_state_set(mt_state, 1, 0, -1);
 814                 priv->mt_state_lost = false;
 815                 return;
 816         }
 817
 818         switch (old->count) {
 819         case 0:
 820                 synaptics_mt_state_set(mt_state, 1, 0, -1);
 821                 break;
 822         case 1:
 823                 /*
 824                  * If mt_state_lost, then the previous transition was 3->1,
 825                  * and SGM now contains either slot 0 or 1, but we don't know
 826                  * which.  So, we just assume that the SGM now contains slot 1.
 827                  *
 828                  * If pending AGM and either:
 829                  *   (a) the previous SGM slot contains slot 0, or
 830                  *   (b) there was no SGM slot
 831                  * then, the SGM now contains slot 1
 832                  *
 833                  * Case (a) happens with very rapid "drum roll" gestures, where
 834                  * slot 0 finger is lifted and a new slot 1 finger touches
 835                  * within one reporting interval.
 836                  *
 837                  * Case (b) happens if initially two or more fingers tap
 838                  * briefly, and all but one lift before the end of the first
 839                  * reporting interval.
 840                  *
 841                  * (In both these cases, slot 0 will becomes empty, so SGM
 842                  * contains slot 1 with the new finger)
 843                  *
 844                  * Else, if there was no previous SGM, it now contains slot 0.
 845                  *
 846                  * Otherwise, SGM still contains the same slot.
 847                  */
 848                 if (priv->mt_state_lost ||
 849                     (priv->agm_pending && old->sgm <= 0))
 850                         synaptics_mt_state_set(mt_state, 1, 1, -1);
 851                 else if (old->sgm == -1)
 852                         synaptics_mt_state_set(mt_state, 1, 0, -1);
 853                 break;
 854         case 2:
 855                 /*
 856                  * If mt_state_lost, we don't know which finger SGM contains.
 857                  *
 858                  * So, report 1 finger, but with both slots empty.
 859                  * We will use slot 1 on subsequent 1->1
 860                  */
 861                 if (priv->mt_state_lost) {
 862                         synaptics_mt_state_set(mt_state, 1, -1, -1);
 863                         break;
 864                 }
 865                 /*
 866                  * Since the last AGM was NOT (0,0,0), it was the finger in
 867                  * slot 0 that has been removed.
 868                  * So, SGM now contains previous AGM's slot, and AGM is now
 869                  * empty.
 870                  */
 871                 synaptics_mt_state_set(mt_state, 1, old->agm, -1);
 872                 break;
 873         case 3:
 874                 /*
 875                  * Since last AGM was not (0,0,0), we don't know which finger
 876                  * is left.
 877                  *
 878                  * So, report 1 finger, but with both slots empty.
 879                  * We will use slot 1 on subsequent 1->1
 880                  */
 881                 synaptics_mt_state_set(mt_state, 1, -1, -1);
 882                 priv->mt_state_lost = true;
 883                 break;
 884         case 4:
 885         case 5:
 886                 /* mt_state was updated by AGM-CONTACT packet */
 887                 break;
 888         }
 889 }
 890
 891 /* Handle case where mt_state->count = 2 */
 892 static void synaptics_image_sensor_2f(struct synaptics_data *priv,
 893                                       struct synaptics_mt_state *mt_state)
 894 {
 895         struct synaptics_mt_state *old = &priv->mt_state;
 896
 897         switch (old->count) {
 898         case 0:
 899                 synaptics_mt_state_set(mt_state, 2, 0, 1);
 900                 break;
 901         case 1:
 902                 /*
 903                  * If previous SGM contained slot 1 or higher, SGM now contains
 904                  * slot 0 (the newly touching finger) and AGM contains SGM's
 905                  * previous slot.
 906                  *
 907                  * Otherwise, SGM still contains slot 0 and AGM now contains
 908                  * slot 1.
 909                  */
 910                 if (old->sgm >= 1)
 911                         synaptics_mt_state_set(mt_state, 2, 0, old->sgm);
 912                 else
 913                         synaptics_mt_state_set(mt_state, 2, 0, 1);
 914                 break;
 915         case 2:
 916                 /*
 917                  * If mt_state_lost, SGM now contains either finger 1 or 2, but
 918                  * we don't know which.
 919                  * So, we just assume that the SGM contains slot 0 and AGM 1.
 920                  */
 921                 if (priv->mt_state_lost)
 922                         synaptics_mt_state_set(mt_state, 2, 0, 1);
 923                 /*
 924                  * Otherwise, use the same mt_state, since it either hasn't
 925                  * changed, or was updated by a recently received AGM-CONTACT
 926                  * packet.
 927                  */
 928                 break;
 929         case 3:
 930                 /*
 931                  * 3->2 transitions have two unsolvable problems:
 932                  *  1) no indication is given which finger was removed
 933                  *  2) no way to tell if agm packet was for finger 3
 934                  *     before 3->2, or finger 2 after 3->2.
 935                  *
 936                  * So, report 2 fingers, but empty all slots.
 937                  * We will guess slots [0,1] on subsequent 2->2.
 938                  */
 939                 synaptics_mt_state_set(mt_state, 2, -1, -1);
 940                 priv->mt_state_lost = true;
 941                 break;
 942         case 4:
 943         case 5:
 944                 /* mt_state was updated by AGM-CONTACT packet */
 945                 break;
 946         }
 947 }
 948
 949 /* Handle case where mt_state->count = 3 */
 950 static void synaptics_image_sensor_3f(struct synaptics_data *priv,
 951                                       struct synaptics_mt_state *mt_state)
 952 {
 953         struct synaptics_mt_state *old = &priv->mt_state;
 954
 955         switch (old->count) {
 956         case 0:
 957                 synaptics_mt_state_set(mt_state, 3, 0, 2);
 958                 break;
 959         case 1:
 960                 /*
 961                  * If previous SGM contained slot 2 or higher, SGM now contains
 962                  * slot 0 (one of the newly touching fingers) and AGM contains
 963                  * SGM's previous slot.
 964                  *
 965                  * Otherwise, SGM now contains slot 0 and AGM contains slot 2.
 966                  */
 967                 if (old->sgm >= 2)
 968                         synaptics_mt_state_set(mt_state, 3, 0, old->sgm);
 969                 else
 970                         synaptics_mt_state_set(mt_state, 3, 0, 2);
 971                 break;
 972         case 2:
 973                 /*
 974                  * If the AGM previously contained slot 3 or higher, then the
 975                  * newly touching finger is in the lowest available slot.
 976                  *
 977                  * If SGM was previously 1 or higher, then the new SGM is
 978                  * now slot 0 (with a new finger), otherwise, the new finger
 979                  * is now in a hidden slot between 0 and AGM's slot.
 980                  *
 981                  * In all such cases, the SGM now contains slot 0, and the AGM
 982                  * continues to contain the same slot as before.
 983                  */
 984                 if (old->agm >= 3) {
 985                         synaptics_mt_state_set(mt_state, 3, 0, old->agm);
 986                         break;
 987                 }
 988
 989                 /*
 990                  * After some 3->1 and all 3->2 transitions, we lose track
 991                  * of which slot is reported by SGM and AGM.
 992                  *
 993                  * For 2->3 in this state, report 3 fingers, but empty all
 994                  * slots, and we will guess (0,2) on a subsequent 0->3.
 995                  *
 996                  * To userspace, the resulting transition will look like:
 997                  *    2:[0,1] -> 3:[-1,-1] -> 3:[0,2]
 998                  */
 999                 if (priv->mt_state_lost) {
1000                         synaptics_mt_state_set(mt_state, 3, -1, -1);
1001                         break;
1002                 }
1003
1004                 /*
1005                  * If the (SGM,AGM) really previously contained slots (0, 1),
1006                  * then we cannot know what slot was just reported by the AGM,
1007                  * because the 2->3 transition can occur either before or after
1008                  * the AGM packet. Thus, this most recent AGM could contain
1009                  * either the same old slot 1 or the new slot 2.
1010                  * Subsequent AGMs will be reporting slot 2.
1011                  *
1012                  * To userspace, the resulting transition will look like:
1013                  *    2:[0,1] -> 3:[0,-1] -> 3:[0,2]
1014                  */
1015                 synaptics_mt_state_set(mt_state, 3, 0, -1);
1016                 break;
1017         case 3:
1018                 /*
1019                  * If, for whatever reason, the previous agm was invalid,
1020                  * Assume SGM now contains slot 0, AGM now contains slot 2.
1021                  */
1022                 if (old->agm <= 2)
1023                         synaptics_mt_state_set(mt_state, 3, 0, 2);
1024                 /*
1025                  * mt_state either hasn't changed, or was updated by a recently
1026                  * received AGM-CONTACT packet.
1027                  */
1028                 break;
1029
1030         case 4:
1031         case 5:
1032                 /* mt_state was updated by AGM-CONTACT packet */
1033                 break;
1034         }
1035 }
1036
1037 /* Handle case where mt_state->count = 4, or = 5 */
1038 static void synaptics_image_sensor_45f(struct synaptics_data *priv,
1039                                        struct synaptics_mt_state *mt_state)
1040 {
1041         /* mt_state was updated correctly by AGM-CONTACT packet */
1042         priv->mt_state_lost = false;
1043 }
1044
1045 static void synaptics_image_sensor_process(struct psmouse *psmouse,
1046                                            struct synaptics_hw_state *sgm)
1047 {
1048         struct synaptics_data *priv = psmouse->private;
1049         struct synaptics_hw_state *agm = &priv->agm;
1050         struct synaptics_mt_state mt_state;
1051
1052         /* Initialize using current mt_state (as updated by last agm) */
1053         mt_state = agm->mt_state;
1054
1055         /*
1056          * Update mt_state using the new finger count and current mt_state.
1057          */
1058         if (sgm->z == 0)
1059                 synaptics_image_sensor_0f(priv, &mt_state);
1060         else if (sgm->w >= 4)
1061                 synaptics_image_sensor_1f(priv, &mt_state);
1062         else if (sgm->w == 0)
1063                 synaptics_image_sensor_2f(priv, &mt_state);
1064         else if (sgm->w == 1 && mt_state.count <= 3)
1065                 synaptics_image_sensor_3f(priv, &mt_state);
1066         else
1067                 synaptics_image_sensor_45f(priv, &mt_state);
1068
1069         /* Send resulting input events to user space */
1070         synaptics_report_mt_data(psmouse, &mt_state, sgm);
1071
1072         /* Store updated mt_state */
1073         priv->mt_state = agm->mt_state = mt_state;
1074         priv->agm_pending = false;
1075 }
1076
1077 /*
1078  *  called for each full received packet from the touchpad
1079  */
1080 static void synaptics_process_packet(struct psmouse *psmouse)
1081 {
1082         struct input_dev *dev = psmouse->dev;
1083         struct synaptics_data *priv = psmouse->private;
1084         struct synaptics_hw_state hw;
1085         int num_fingers;
1086         int finger_width;
1087
1088         if (synaptics_parse_hw_state(psmouse->packet, priv, &hw))
1089                 return;
1090
1091         if (SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) {
1092                 synaptics_image_sensor_process(psmouse, &hw);
1093                 return;
1094         }
1095
1096         if (hw.scroll) {
1097                 priv->scroll += hw.scroll;
1098
1099                 while (priv->scroll >= 4) {
1100                         input_report_key(dev, BTN_BACK, !hw.down);
1101                         input_sync(dev);
1102                         input_report_key(dev, BTN_BACK, hw.down);
1103                         input_sync(dev);
1104                         priv->scroll -= 4;
1105                 }
1106                 while (priv->scroll <= -4) {
1107                         input_report_key(dev, BTN_FORWARD, !hw.up);
1108                         input_sync(dev);
1109                         input_report_key(dev, BTN_FORWARD, hw.up);
1110                         input_sync(dev);
1111                         priv->scroll += 4;
1112                 }
1113                 return;
1114         }
1115
1116         if (hw.z > 0 && hw.x > 1) {
1117                 num_fingers = 1;
1118                 finger_width = 5;
1119                 if (SYN_CAP_EXTENDED(priv->capabilities)) {
1120                         switch (hw.w) {
1121                         case 0 ... 1:
1122                                 if (SYN_CAP_MULTIFINGER(priv->capabilities))
1123                                         num_fingers = hw.w + 2;
1124                                 break;
1125                         case 2:
1126                                 if (SYN_MODEL_PEN(priv->model_id))
1127                                         ;   /* Nothing, treat a pen as a single finger */
1128                                 break;
1129                         case 4 ... 15:
1130                                 if (SYN_CAP_PALMDETECT(priv->capabilities))
1131                                         finger_width = hw.w;
1132                                 break;
1133                         }
1134                 }
1135         } else {
1136                 num_fingers = 0;
1137                 finger_width = 0;
1138         }
1139
1140         if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c))
1141                 synaptics_report_semi_mt_data(dev, &hw, &priv->agm,
1142                                               num_fingers);
1143
1144         /* Post events
1145          * BTN_TOUCH has to be first as mousedev relies on it when doing
1146          * absolute -> relative conversion
1147          */
1148         if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
1149         if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
1150
1151         if (num_fingers > 0) {
1152                 input_report_abs(dev, ABS_X, hw.x);
1153                 input_report_abs(dev, ABS_Y, synaptics_invert_y(hw.y));
1154         }
1155         input_report_abs(dev, ABS_PRESSURE, hw.z);
1156
1157         if (SYN_CAP_PALMDETECT(priv->capabilities))
1158                 input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
1159
1160         input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
1161         if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
1162                 input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
1163                 input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
1164         }
1165
1166         synaptics_report_buttons(psmouse, &hw);
1167
1168         input_sync(dev);
1169 }
1170
1171 static int synaptics_validate_byte(struct psmouse *psmouse,
1172                                    int idx, unsigned char pkt_type)
1173 {
1174         static const unsigned char newabs_mask[]        = { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
1175         static const unsigned char newabs_rel_mask[]    = { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
1176         static const unsigned char newabs_rslt[]        = { 0x80, 0x00, 0x00, 0xC0, 0x00 };
1177         static const unsigned char oldabs_mask[]        = { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
1178         static const unsigned char oldabs_rslt[]        = { 0xC0, 0x00, 0x00, 0x80, 0x00 };
1179         const char *packet = psmouse->packet;
1180
1181         if (idx < 0 || idx > 4)
1182                 return 0;
1183
1184         switch (pkt_type) {
1185
1186         case SYN_NEWABS:
1187         case SYN_NEWABS_RELAXED:
1188                 return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
1189
1190         case SYN_NEWABS_STRICT:
1191                 return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
1192
1193         case SYN_OLDABS:
1194                 return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
1195
1196         default:
1197                 psmouse_err(psmouse, "unknown packet type %d\n", pkt_type);
1198                 return 0;
1199         }
1200 }
1201
1202 static unsigned char synaptics_detect_pkt_type(struct psmouse *psmouse)
1203 {
1204         int i;
1205
1206         for (i = 0; i < 5; i++)
1207                 if (!synaptics_validate_byte(psmouse, i, SYN_NEWABS_STRICT)) {
1208                         psmouse_info(psmouse, "using relaxed packet validation\n");
1209                         return SYN_NEWABS_RELAXED;
1210                 }
1211
1212         return SYN_NEWABS_STRICT;
1213 }
1214
1215 static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
1216 {
1217         struct synaptics_data *priv = psmouse->private;
1218
1219         if (psmouse->pktcnt >= 6) { /* Full packet received */
1220                 if (unlikely(priv->pkt_type == SYN_NEWABS))
1221                         priv->pkt_type = synaptics_detect_pkt_type(psmouse);
1222
1223                 if (SYN_CAP_PASS_THROUGH(priv->capabilities) &&
1224                     synaptics_is_pt_packet(psmouse->packet)) {
1225                         if (priv->pt_port)
1226                                 synaptics_pass_pt_packet(priv->pt_port, psmouse->packet);
1227                 } else
1228                         synaptics_process_packet(psmouse);
1229
1230                 return PSMOUSE_FULL_PACKET;
1231         }
1232
1233         return synaptics_validate_byte(psmouse, psmouse->pktcnt - 1, priv->pkt_type) ?
1234                 PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
1235 }
1236
1237 /*****************************************************************************
1238  *      Driver initialization/cleanup functions
1239  ****************************************************************************/
1240 static void set_abs_position_params(struct input_dev *dev,
1241                                     struct synaptics_data *priv, int x_code,
1242                                     int y_code)
1243 {
1244         int x_min = priv->x_min ?: XMIN_NOMINAL;
1245         int x_max = priv->x_max ?: XMAX_NOMINAL;
1246         int y_min = priv->y_min ?: YMIN_NOMINAL;
1247         int y_max = priv->y_max ?: YMAX_NOMINAL;
1248         int fuzz = SYN_CAP_REDUCED_FILTERING(priv->ext_cap_0c) ?
1249                         SYN_REDUCED_FILTER_FUZZ : 0;
1250
1251         input_set_abs_params(dev, x_code, x_min, x_max, fuzz, 0);
1252         input_set_abs_params(dev, y_code, y_min, y_max, fuzz, 0);
1253         input_abs_set_res(dev, x_code, priv->x_res);
1254         input_abs_set_res(dev, y_code, priv->y_res);
1255 }
1256
1257 static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
1258 {
1259         int i;
1260
1261         /* Things that apply to both modes */
1262         __set_bit(INPUT_PROP_POINTER, dev->propbit);
1263         __set_bit(EV_KEY, dev->evbit);
1264         __set_bit(BTN_LEFT, dev->keybit);
1265         __set_bit(BTN_RIGHT, dev->keybit);
1266
1267         if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
1268                 __set_bit(BTN_MIDDLE, dev->keybit);
1269
1270         if (!priv->absolute_mode) {
1271                 /* Relative mode */
1272                 __set_bit(EV_REL, dev->evbit);
1273                 __set_bit(REL_X, dev->relbit);
1274                 __set_bit(REL_Y, dev->relbit);
1275                 return;
1276         }
1277
1278         /* Absolute mode */
1279         __set_bit(EV_ABS, dev->evbit);
1280         set_abs_position_params(dev, priv, ABS_X, ABS_Y);
1281         input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
1282
1283         if (SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) {
1284                 input_mt_init_slots(dev, 2);
1285                 set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
1286                                         ABS_MT_POSITION_Y);
1287                 /* Image sensors can report per-contact pressure */
1288                 input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
1289
1290                 /* Image sensors can signal 4 and 5 finger clicks */
1291                 __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
1292                 __set_bit(BTN_TOOL_QUINTTAP, dev->keybit);
1293         } else if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c)) {
1294                 /* Non-image sensors with AGM use semi-mt */
1295                 __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
1296                 input_mt_init_slots(dev, 2);
1297                 set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
1298                                         ABS_MT_POSITION_Y);
1299         }
1300
1301         if (SYN_CAP_PALMDETECT(priv->capabilities))
1302                 input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
1303
1304         __set_bit(BTN_TOUCH, dev->keybit);
1305         __set_bit(BTN_TOOL_FINGER, dev->keybit);
1306
1307         if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
1308                 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
1309                 __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
1310         }
1311
1312         if (SYN_CAP_FOUR_BUTTON(priv->capabilities) ||
1313             SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
1314                 __set_bit(BTN_FORWARD, dev->keybit);
1315                 __set_bit(BTN_BACK, dev->keybit);
1316         }
1317
1318         for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
1319                 __set_bit(BTN_0 + i, dev->keybit);
1320
1321         __clear_bit(EV_REL, dev->evbit);
1322         __clear_bit(REL_X, dev->relbit);
1323         __clear_bit(REL_Y, dev->relbit);
1324
1325         if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
1326                 __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
1327                 /* Clickpads report only left button */
1328                 __clear_bit(BTN_RIGHT, dev->keybit);
1329                 __clear_bit(BTN_MIDDLE, dev->keybit);
1330         }
1331 }
1332
1333 static ssize_t synaptics_show_disable_gesture(struct psmouse *psmouse,
1334                                               void *data, char *buf)
1335 {
1336         struct synaptics_data *priv = psmouse->private;
1337
1338         return sprintf(buf, "%c\n", priv->disable_gesture ? '1' : '0');
1339 }
1340
1341 static ssize_t synaptics_set_disable_gesture(struct psmouse *psmouse,
1342                                              void *data, const char *buf,
1343                                              size_t len)
1344 {
1345         struct synaptics_data *priv = psmouse->private;
1346         unsigned int value;
1347         int err;
1348
1349         err = kstrtouint(buf, 10, &value);
1350         if (err)
1351                 return err;
1352
1353         if (value > 1)
1354                 return -EINVAL;
1355
1356         if (value == priv->disable_gesture)
1357                 return len;
1358
1359         priv->disable_gesture = value;
1360         if (value)
1361                 priv->mode |= SYN_BIT_DISABLE_GESTURE;
1362         else
1363                 priv->mode &= ~SYN_BIT_DISABLE_GESTURE;
1364
1365         if (synaptics_mode_cmd(psmouse, priv->mode))
1366                 return -EIO;
1367
1368         return len;
1369 }
1370
1371 PSMOUSE_DEFINE_ATTR(disable_gesture, S_IWUSR | S_IRUGO, NULL,
1372                     synaptics_show_disable_gesture,
1373                     synaptics_set_disable_gesture);
1374
1375 static void synaptics_disconnect(struct psmouse *psmouse)
1376 {
1377         struct synaptics_data *priv = psmouse->private;
1378
1379         if (!priv->absolute_mode && SYN_ID_DISGEST_SUPPORTED(priv->identity))
1380                 device_remove_file(&psmouse->ps2dev.serio->dev,
1381                                    &psmouse_attr_disable_gesture.dattr);
1382
1383         synaptics_free_led(psmouse);
1384         synaptics_reset(psmouse);
1385         kfree(priv);
1386         psmouse->private = NULL;
1387 }
1388
1389 static int synaptics_reconnect(struct psmouse *psmouse)
1390 {
1391         struct synaptics_data *priv = psmouse->private;
1392         struct synaptics_data old_priv = *priv;
1393         int retry = 0;
1394         int error;
1395
1396         do {
1397                 psmouse_reset(psmouse);
1398                 if (retry) {
1399                         /*
1400                          * On some boxes, right after resuming, the touchpad
1401                          * needs some time to finish initializing (I assume
1402                          * it needs time to calibrate) and start responding
1403                          * to Synaptics-specific queries, so let's wait a
1404                          * bit.
1405                          */
1406                         ssleep(1);
1407                 }
1408                 error = synaptics_detect(psmouse, 0);
1409         } while (error && ++retry < 3);
1410
1411         if (error)
1412                 return -1;
1413
1414         if (retry > 1)
1415                 psmouse_dbg(psmouse, "reconnected after %d tries\n", retry);
1416
1417         if (synaptics_query_hardware(psmouse)) {
1418                 psmouse_err(psmouse, "Unable to query device.\n");
1419                 return -1;
1420         }
1421
1422         if (synaptics_set_mode(psmouse)) {
1423                 psmouse_err(psmouse, "Unable to initialize device.\n");
1424                 return -1;
1425         }
1426
1427         if (old_priv.identity != priv->identity ||
1428             old_priv.model_id != priv->model_id ||
1429             old_priv.capabilities != priv->capabilities ||
1430             old_priv.ext_cap != priv->ext_cap) {
1431                 psmouse_err(psmouse,
1432                             "hardware appears to be different: id(%ld-%ld), model(%ld-%ld), caps(%lx-%lx), ext(%lx-%lx).\n",
1433                             old_priv.identity, priv->identity,
1434                             old_priv.model_id, priv->model_id,
1435                             old_priv.capabilities, priv->capabilities,
1436                             old_priv.ext_cap, priv->ext_cap);
1437                 return -1;
1438         }
1439
1440         synaptics_sync_led(psmouse);
1441
1442         return 0;
1443 }
1444
1445 static bool impaired_toshiba_kbc;
1446
1447 static const struct dmi_system_id __initconst toshiba_dmi_table[] = {
1448 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1449         {
1450                 /* Toshiba Satellite */
1451                 .matches = {
1452                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1453                         DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
1454                 },
1455         },
1456         {
1457                 /* Toshiba Dynabook */
1458                 .matches = {
1459                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1460                         DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"),
1461                 },
1462         },
1463         {
1464                 /* Toshiba Portege M300 */
1465                 .matches = {
1466                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1467                         DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"),
1468                 },
1469
1470         },
1471         {
1472                 /* Toshiba Portege M300 */
1473                 .matches = {
1474                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1475                         DMI_MATCH(DMI_PRODUCT_NAME, "Portable PC"),
1476                         DMI_MATCH(DMI_PRODUCT_VERSION, "Version 1.0"),
1477                 },
1478
1479         },
1480 #endif
1481         { }
1482 };
1483
1484 static bool broken_olpc_ec;
1485
1486 static const struct dmi_system_id __initconst olpc_dmi_table[] = {
1487 #if defined(CONFIG_DMI) && defined(CONFIG_OLPC)
1488         {
1489                 /* OLPC XO-1 or XO-1.5 */
1490                 .matches = {
1491                         DMI_MATCH(DMI_SYS_VENDOR, "OLPC"),
1492                         DMI_MATCH(DMI_PRODUCT_NAME, "XO"),
1493                 },
1494         },
1495 #endif
1496         { }
1497 };
1498
1499 void __init synaptics_module_init(void)
1500 {
1501         impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
1502         broken_olpc_ec = dmi_check_system(olpc_dmi_table);
1503 }
1504
1505 static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
1506 {
1507         struct synaptics_data *priv;
1508         int err = -1;
1509
1510         /*
1511          * The OLPC XO has issues with Synaptics' absolute mode; the constant
1512          * packet spew overloads the EC such that key presses on the keyboard
1513          * are missed.  Given that, don't even attempt to use Absolute mode.
1514          * Relative mode seems to work just fine.
1515          */
1516         if (absolute_mode && broken_olpc_ec) {
1517                 psmouse_info(psmouse,
1518                              "OLPC XO detected, not enabling Synaptics protocol.\n");
1519                 return -ENODEV;
1520         }
1521
1522         psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
1523         if (!priv)
1524                 return -ENOMEM;
1525
1526         psmouse_reset(psmouse);
1527
1528         if (synaptics_query_hardware(psmouse)) {
1529                 psmouse_err(psmouse, "Unable to query device.\n");
1530                 goto init_fail;
1531         }
1532
1533         priv->absolute_mode = absolute_mode;
1534         if (SYN_ID_DISGEST_SUPPORTED(priv->identity))
1535                 priv->disable_gesture = true;
1536
1537         if (synaptics_set_mode(psmouse)) {
1538                 psmouse_err(psmouse, "Unable to initialize device.\n");
1539                 goto init_fail;
1540         }
1541
1542         priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
1543
1544         psmouse_info(psmouse,
1545                      "Touchpad model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx\n",
1546                      SYN_ID_MODEL(priv->identity),
1547                      SYN_ID_MAJOR(priv->identity), SYN_ID_MINOR(priv->identity),
1548                      priv->model_id,
1549                      priv->capabilities, priv->ext_cap, priv->ext_cap_0c);
1550
1551         if (synaptics_init_led(psmouse) < 0)
1552                 goto init_fail;
1553
1554         set_input_params(psmouse->dev, priv);
1555
1556         /*
1557          * Encode touchpad model so that it can be used to set
1558          * input device->id.version and be visible to userspace.
1559          * Because version is __u16 we have to drop something.
1560          * Hardware info bits seem to be good candidates as they
1561          * are documented to be for Synaptics corp. internal use.
1562          */
1563         psmouse->model = ((priv->model_id & 0x00ff0000) >> 8) |
1564                           (priv->model_id & 0x000000ff);
1565
1566         if (absolute_mode) {
1567                 psmouse->protocol_handler = synaptics_process_byte;
1568                 psmouse->pktsize = 6;
1569         } else {
1570                 /* Relative mode follows standard PS/2 mouse protocol */
1571                 psmouse->protocol_handler = psmouse_process_byte;
1572                 psmouse->pktsize = 3;
1573         }
1574
1575         psmouse->set_rate = synaptics_set_rate;
1576         psmouse->disconnect = synaptics_disconnect;
1577         psmouse->reconnect = synaptics_reconnect;
1578         psmouse->cleanup = synaptics_reset;
1579         /* Synaptics can usually stay in sync without extra help */
1580         psmouse->resync_time = 0;
1581
1582         if (SYN_CAP_PASS_THROUGH(priv->capabilities))
1583                 synaptics_pt_create(psmouse);
1584
1585         /*
1586          * Toshiba's KBC seems to have trouble handling data from
1587          * Synaptics at full rate.  Switch to a lower rate (roughly
1588          * the same rate as a standard PS/2 mouse).
1589          */
1590         if (psmouse->rate >= 80 && impaired_toshiba_kbc) {
1591                 psmouse_info(psmouse,
1592                              "Toshiba %s detected, limiting rate to 40pps.\n",
1593                              dmi_get_system_info(DMI_PRODUCT_NAME));
1594                 psmouse->rate = 40;
1595         }
1596
1597         if (!priv->absolute_mode && SYN_ID_DISGEST_SUPPORTED(priv->identity)) {
1598                 err = device_create_file(&psmouse->ps2dev.serio->dev,
1599                                          &psmouse_attr_disable_gesture.dattr);
1600                 if (err) {
1601                         psmouse_err(psmouse,
1602                                     "Failed to create disable_gesture attribute (%d)",
1603                                     err);
1604                         goto init_fail;
1605                 }
1606         }
1607
1608         return 0;
1609
1610  init_fail:
1611         kfree(priv);
1612         return err;
1613 }
1614
1615 int synaptics_init(struct psmouse *psmouse)
1616 {
1617         return __synaptics_init(psmouse, true);
1618 }
1619
1620 int synaptics_init_relative(struct psmouse *psmouse)
1621 {
1622         return __synaptics_init(psmouse, false);
1623 }
1624
1625 bool synaptics_supported(void)
1626 {
1627         return true;
1628 }
1629
1630 #else /* CONFIG_MOUSE_PS2_SYNAPTICS */
1631
1632 void __init synaptics_module_init(void)
1633 {
1634 }
1635
1636 int synaptics_init(struct psmouse *psmouse)
1637 {
1638         return -ENOSYS;
1639 }
1640
1641 bool synaptics_supported(void)
1642 {
1643         return false;
1644 }
1645
1646 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS */