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