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