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