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