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