Pileus Git - ~andy/linux/blob - drivers/input/mouse/synaptics.c

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