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