synaptics.c 47.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * Synaptics TouchPad PS/2 mouse driver
 *
 *   2003 Dmitry Torokhov <dtor@mail.ru>
 *     Added support for pass-through port. Special thanks to Peter Berg Larsen
 *     for explaining various Synaptics quirks.
 *
 *   2003 Peter Osterlund <petero2@telia.com>
 *     Ported to 2.5 input device infrastructure.
 *
 *   Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch>
 *     start merging tpconfig and gpm code to a xfree-input module
 *     adding some changes and extensions (ex. 3rd and 4th button)
 *
 *   Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu>
 *   Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com>
 *     code for the special synaptics commands (from the tpconfig-source)
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * Trademarks are the property of their respective owners.
 */

#include <linux/module.h>
27
#include <linux/delay.h>
28
#include <linux/dmi.h>
29
#include <linux/input/mt.h>
L
Linus Torvalds 已提交
30 31
#include <linux/serio.h>
#include <linux/libps2.h>
32 33
#include <linux/rmi.h>
#include <linux/i2c.h>
34
#include <linux/slab.h>
L
Linus Torvalds 已提交
35 36 37 38 39 40 41
#include "psmouse.h"
#include "synaptics.h"

/*
 * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
 * section 2.3.2, which says that they should be valid regardless of the
 * actual size of the sensor.
42 43
 * Note that newer firmware allows querying device for maximum useable
 * coordinates.
L
Linus Torvalds 已提交
44
 */
45 46 47 48
#define XMIN 0
#define XMAX 6143
#define YMIN 0
#define YMAX 6143
L
Linus Torvalds 已提交
49 50 51 52 53
#define XMIN_NOMINAL 1472
#define XMAX_NOMINAL 5472
#define YMIN_NOMINAL 1408
#define YMAX_NOMINAL 4448

54 55 56 57
/* Size in bits of absolute position values reported by the hardware */
#define ABS_POS_BITS 13

/*
58 59 60 61 62 63 64 65 66 67
 * These values should represent the absolute maximum value that will
 * be reported for a positive position value. Some Synaptics firmware
 * uses this value to indicate a finger near the edge of the touchpad
 * whose precise position cannot be determined.
 *
 * At least one touchpad is known to report positions in excess of this
 * value which are actually negative values truncated to the 13-bit
 * reporting range. These values have never been observed to be lower
 * than 8184 (i.e. -8), so we treat all values greater than 8176 as
 * negative and any other value as positive.
68
 */
69 70
#define X_MAX_POSITIVE 8176
#define Y_MAX_POSITIVE 8176
71

72 73 74
/* maximum ABS_MT_POSITION displacement (in mm) */
#define DMAX 10

L
Linus Torvalds 已提交
75
/*****************************************************************************
76
 *	Stuff we need even when we do not want native Synaptics support
L
Linus Torvalds 已提交
77 78 79
 ****************************************************************************/

/*
80
 * Set the synaptics touchpad mode byte by special commands
L
Linus Torvalds 已提交
81
 */
82
static int synaptics_mode_cmd(struct psmouse *psmouse, unsigned char mode)
L
Linus Torvalds 已提交
83
{
84 85 86
	unsigned char param[1];

	if (psmouse_sliced_command(psmouse, mode))
L
Linus Torvalds 已提交
87
		return -1;
88 89
	param[0] = SYN_PS_SET_MODE2;
	if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_SETRATE))
L
Linus Torvalds 已提交
90 91 92 93
		return -1;
	return 0;
}

94
int synaptics_detect(struct psmouse *psmouse, bool set_properties)
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
{
	struct ps2dev *ps2dev = &psmouse->ps2dev;
	unsigned char param[4];

	param[0] = 0;

	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
	ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);

	if (param[1] != 0x47)
		return -ENODEV;

	if (set_properties) {
		psmouse->vendor = "Synaptics";
		psmouse->name = "TouchPad";
	}

	return 0;
}

void synaptics_reset(struct psmouse *psmouse)
{
	/* reset touchpad back to relative mode, gestures enabled */
	synaptics_mode_cmd(psmouse, 0);
}

124 125
#if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \
    defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)
126

127 128 129 130 131 132 133 134 135 136 137 138
/* This list has been kindly provided by Synaptics. */
static const char * const topbuttonpad_pnp_ids[] = {
	"LEN0017",
	"LEN0018",
	"LEN0019",
	"LEN0023",
	"LEN002A",
	"LEN002B",
	"LEN002C",
	"LEN002D",
	"LEN002E",
	"LEN0033", /* Helix */
139
	"LEN0034", /* T431s, L440, L540, T540, W540, X1 Carbon 2nd */
140 141
	"LEN0035", /* X240 */
	"LEN0036", /* T440 */
142
	"LEN0037", /* X1 Carbon 2nd */
143
	"LEN0038",
144
	"LEN0039", /* T440s */
145 146 147 148 149
	"LEN0041",
	"LEN0042", /* Yoga */
	"LEN0045",
	"LEN0047",
	"LEN0049",
150
	"LEN2000", /* S540 */
151
	"LEN2001", /* Edge E431 */
152
	"LEN2002", /* Edge E531 */
153 154 155
	"LEN2003",
	"LEN2004", /* L440 */
	"LEN2005",
156
	"LEN2006", /* Edge E440/E540 */
157 158 159 160 161 162 163
	"LEN2007",
	"LEN2008",
	"LEN2009",
	"LEN200A",
	"LEN200B",
	NULL
};
164

165 166 167 168 169 170
static const char * const smbus_pnp_ids[] = {
	/* all of the topbuttonpad_pnp_ids are valid, we just add some extras */
	"LEN0048", /* X1 Carbon 3 */
	"LEN0046", /* X250 */
	"LEN004a", /* W541 */
	"LEN200f", /* T450s */
171 172 173
	NULL
};

J
JJ Ding 已提交
174
/*
175
 * Send a command to the synpatics touchpad by special commands
J
JJ Ding 已提交
176
 */
177 178
static int synaptics_send_cmd(struct psmouse *psmouse,
			      unsigned char c, unsigned char *param)
J
JJ Ding 已提交
179
{
180 181 182 183 184 185 186 187 188 189 190
	int error;

	error = psmouse_sliced_command(psmouse, c);
	if (error)
		return error;

	error = ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO);
	if (error)
		return error;

	return 0;
J
JJ Ding 已提交
191 192
}

L
Linus Torvalds 已提交
193
/*
194 195
 * Identify Touchpad
 * See also the SYN_ID_* macros
L
Linus Torvalds 已提交
196
 */
197 198
static int synaptics_identify(struct psmouse *psmouse,
			      struct synaptics_device_info *info)
L
Linus Torvalds 已提交
199
{
200 201 202 203 204 205 206 207 208
	unsigned char id[3];
	int error;

	error = synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id);
	if (error)
		return error;

	info->identity = (id[0] << 16) | (id[1] << 8) | id[2];
	return SYN_ID_IS_SYNAPTICS(info->identity) ? 0 : -ENXIO;
L
Linus Torvalds 已提交
209 210 211 212 213 214
}

/*
 * Read the model-id bytes from the touchpad
 * see also SYN_MODEL_* macros
 */
215 216
static int synaptics_model_id(struct psmouse *psmouse,
			      struct synaptics_device_info *info)
L
Linus Torvalds 已提交
217 218
{
	unsigned char mi[3];
219
	int error;
L
Linus Torvalds 已提交
220

221 222 223 224 225
	error = synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi);
	if (error)
		return error;

	info->model_id = (mi[0] << 16) | (mi[1] << 8) | mi[2];
L
Linus Torvalds 已提交
226 227 228
	return 0;
}

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
/*
 * Read the firmware id from the touchpad
 */
static int synaptics_firmware_id(struct psmouse *psmouse,
				 struct synaptics_device_info *info)
{
	unsigned char fwid[3];
	int error;

	error = synaptics_send_cmd(psmouse, SYN_QUE_FIRMWARE_ID, fwid);
	if (error)
		return error;

	info->firmware_id = (fwid[0] << 16) | (fwid[1] << 8) | fwid[2];
	return 0;
}

246 247
static int synaptics_more_extended_queries(struct psmouse *psmouse,
					   struct synaptics_device_info *info)
248 249
{
	unsigned char buf[3];
250
	int error;
251

252 253 254
	error = synaptics_send_cmd(psmouse, SYN_QUE_MEXT_CAPAB_10, buf);
	if (error)
		return error;
255

256
	info->ext_cap_10 = (buf[0] << 16) | (buf[1] << 8) | buf[2];
257 258 259
	return 0;
}

260
/*
261
 * Read the board id and the "More Extended Queries" from the touchpad
262 263
 * The board id is encoded in the "QUERY MODES" response
 */
264 265
static int synaptics_query_modes(struct psmouse *psmouse,
				 struct synaptics_device_info *info)
266 267
{
	unsigned char bid[3];
268
	int error;
269

270
	/* firmwares prior 7.5 have no board_id encoded */
271
	if (SYN_ID_FULL(info->identity) < 0x705)
272 273
		return 0;

274 275 276 277 278
	error = synaptics_send_cmd(psmouse, SYN_QUE_MODES, bid);
	if (error)
		return error;

	info->board_id = ((bid[0] & 0xfc) << 6) | bid[1];
279 280

	if (SYN_MEXT_CAP_BIT(bid[0]))
281
		return synaptics_more_extended_queries(psmouse, info);
282

283 284 285
	return 0;
}

L
Linus Torvalds 已提交
286 287 288 289
/*
 * Read the capability-bits from the touchpad
 * see also the SYN_CAP_* macros
 */
290 291
static int synaptics_capability(struct psmouse *psmouse,
				struct synaptics_device_info *info)
L
Linus Torvalds 已提交
292 293
{
	unsigned char cap[3];
294
	int error;
L
Linus Torvalds 已提交
295

296 297 298 299 300 301
	error = synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap);
	if (error)
		return error;

	info->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
	info->ext_cap = info->ext_cap_0c = 0;
302

303 304 305
	/*
	 * Older firmwares had submodel ID fixed to 0x47
	 */
306 307 308
	if (SYN_ID_FULL(info->identity) < 0x705 &&
	    SYN_CAP_SUBMODEL_ID(info->capabilities) != 0x47) {
		return -ENXIO;
309
	}
L
Linus Torvalds 已提交
310 311 312 313

	/*
	 * Unless capExtended is set the rest of the flags should be ignored
	 */
314 315
	if (!SYN_CAP_EXTENDED(info->capabilities))
		info->capabilities = 0;
L
Linus Torvalds 已提交
316

317
	if (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 1) {
L
Linus Torvalds 已提交
318
		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
319 320
			psmouse_warn(psmouse,
				     "device claims to have extended capabilities, but I'm not able to read them.\n");
L
Linus Torvalds 已提交
321
		} else {
322
			info->ext_cap = (cap[0] << 16) | (cap[1] << 8) | cap[2];
L
Linus Torvalds 已提交
323 324 325 326 327

			/*
			 * if nExtBtn is greater than 8 it should be considered
			 * invalid and treated as 0
			 */
328 329
			if (SYN_CAP_MULTI_BUTTON_NO(info->ext_cap) > 8)
				info->ext_cap &= 0xff0fff;
L
Linus Torvalds 已提交
330 331
		}
	}
332

333 334 335
	if (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 4) {
		error = synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB_0C, cap);
		if (error)
336 337
			psmouse_warn(psmouse,
				     "device claims to have extended capability 0x0c, but I'm not able to read it.\n");
338 339 340
		else
			info->ext_cap_0c =
				(cap[0] << 16) | (cap[1] << 8) | cap[2];
341 342
	}

L
Linus Torvalds 已提交
343 344 345
	return 0;
}

346
/*
347
 * Read touchpad resolution and maximum reported coordinates
348 349
 * Resolution is left zero if touchpad does not support the query
 */
350 351
static int synaptics_resolution(struct psmouse *psmouse,
				struct synaptics_device_info *info)
352
{
353
	unsigned char resp[3];
354
	int error;
355

356
	if (SYN_ID_MAJOR(info->identity) < 4)
357
		return 0;
358

359 360
	error = synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, resp);
	if (!error) {
361
		if (resp[0] != 0 && (resp[1] & 0x80) && resp[2] != 0) {
362 363
			info->x_res = resp[0]; /* x resolution in units/mm */
			info->y_res = resp[2]; /* y resolution in units/mm */
364 365
		}
	}
366

367 368 369 370 371
	if (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 5 &&
	    SYN_CAP_MAX_DIMENSIONS(info->ext_cap_0c)) {
		error = synaptics_send_cmd(psmouse,
					   SYN_QUE_EXT_MAX_COORDS, resp);
		if (error) {
372 373
			psmouse_warn(psmouse,
				     "device claims to have max coordinates query, but I'm not able to read it.\n");
374
		} else {
375 376
			info->x_max = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
			info->y_max = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
377 378
			psmouse_info(psmouse,
				     "queried max coordinates: x [..%d], y [..%d]\n",
379
				     info->x_max, info->y_max);
380 381 382
		}
	}

383 384
	if (SYN_CAP_MIN_DIMENSIONS(info->ext_cap_0c) &&
	    (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 7 ||
385 386 387 388 389
	     /*
	      * Firmware v8.1 does not report proper number of extended
	      * capabilities, but has been proven to report correct min
	      * coordinates.
	      */
390 391 392 393
	     SYN_ID_FULL(info->identity) == 0x801)) {
		error = synaptics_send_cmd(psmouse,
					   SYN_QUE_EXT_MIN_COORDS, resp);
		if (error) {
394 395
			psmouse_warn(psmouse,
				     "device claims to have min coordinates query, but I'm not able to read it.\n");
396
		} else {
397 398
			info->x_min = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
			info->y_min = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
399 400
			psmouse_info(psmouse,
				     "queried min coordinates: x [%d..], y [%d..]\n",
401
				     info->x_min, info->y_min);
402
		}
403 404 405 406 407
	}

	return 0;
}

408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
static int synaptics_query_hardware(struct psmouse *psmouse,
				    struct synaptics_device_info *info)
{
	int error;

	error = synaptics_identify(psmouse, info);
	if (error)
		return error;

	error = synaptics_model_id(psmouse, info);
	if (error)
		return error;

	error = synaptics_firmware_id(psmouse, info);
	if (error)
		return error;

	error = synaptics_query_modes(psmouse, info);
	if (error)
		return error;

	error = synaptics_capability(psmouse, info);
	if (error)
		return error;

	error = synaptics_resolution(psmouse, info);
	if (error)
		return error;

	return 0;
}

#endif /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */

#ifdef CONFIG_MOUSE_PS2_SYNAPTICS

static bool cr48_profile_sensor;

#define ANY_BOARD_ID 0
struct min_max_quirk {
	const char * const *pnp_ids;
	struct {
		u32 min, max;
	} board_id;
	u32 x_min, x_max, y_min, y_max;
};

static const struct min_max_quirk min_max_pnpid_table[] = {
	{
		(const char * const []){"LEN0033", NULL},
		{ANY_BOARD_ID, ANY_BOARD_ID},
		1024, 5052, 2258, 4832
	},
	{
		(const char * const []){"LEN0042", NULL},
		{ANY_BOARD_ID, ANY_BOARD_ID},
		1232, 5710, 1156, 4696
	},
	{
		(const char * const []){"LEN0034", "LEN0036", "LEN0037",
					"LEN0039", "LEN2002", "LEN2004",
					NULL},
		{ANY_BOARD_ID, 2961},
		1024, 5112, 2024, 4832
	},
	{
		(const char * const []){"LEN2000", NULL},
		{ANY_BOARD_ID, ANY_BOARD_ID},
		1024, 5113, 2021, 4832
	},
	{
		(const char * const []){"LEN2001", NULL},
		{ANY_BOARD_ID, ANY_BOARD_ID},
		1024, 5022, 2508, 4832
	},
	{
		(const char * const []){"LEN2006", NULL},
		{2691, 2691},
		1024, 5045, 2457, 4832
	},
	{
		(const char * const []){"LEN2006", NULL},
		{ANY_BOARD_ID, ANY_BOARD_ID},
		1264, 5675, 1171, 4688
	},
	{ }
};

/* This list has been kindly provided by Synaptics. */
static const char * const forcepad_pnp_ids[] = {
	"SYN300D",
	"SYN3014",
	NULL
};

/*****************************************************************************
 *	Synaptics communications functions
 ****************************************************************************/

/*
 * Synaptics touchpads report the y coordinate from bottom to top, which is
 * opposite from what userspace expects.
 * This function is used to invert y before reporting.
 */
static int synaptics_invert_y(int y)
{
	return YMAX_NOMINAL + YMIN_NOMINAL - y;
}

517 518 519
/*
 * Apply quirk(s) if the hardware matches
 */
520 521
static void synaptics_apply_quirks(struct psmouse *psmouse,
				   struct synaptics_device_info *info)
522 523 524 525
{
	int i;

	for (i = 0; min_max_pnpid_table[i].pnp_ids; i++) {
526 527 528 529 530
		if (!psmouse_matches_pnp_id(psmouse,
					    min_max_pnpid_table[i].pnp_ids))
			continue;

		if (min_max_pnpid_table[i].board_id.min != ANY_BOARD_ID &&
531
		    info->board_id < min_max_pnpid_table[i].board_id.min)
532 533 534
			continue;

		if (min_max_pnpid_table[i].board_id.max != ANY_BOARD_ID &&
535
		    info->board_id > min_max_pnpid_table[i].board_id.max)
536 537
			continue;

538 539 540 541
		info->x_min = min_max_pnpid_table[i].x_min;
		info->x_max = min_max_pnpid_table[i].x_max;
		info->y_min = min_max_pnpid_table[i].y_min;
		info->y_max = min_max_pnpid_table[i].y_max;
542 543
		psmouse_info(psmouse,
			     "quirked min/max coordinates: x [%d..%d], y [%d..%d]\n",
544 545
			     info->x_min, info->x_max,
			     info->y_min, info->y_max);
546
		break;
547 548 549
	}
}

550 551 552 553 554
static int synaptics_set_advanced_gesture_mode(struct psmouse *psmouse)
{
	static unsigned char param = 0xc8;
	struct synaptics_data *priv = psmouse->private;

555 556
	if (!(SYN_CAP_ADV_GESTURE(priv->info.ext_cap_0c) ||
	      SYN_CAP_IMAGE_SENSOR(priv->info.ext_cap_0c)))
557 558 559 560 561 562 563 564 565
		return 0;

	if (psmouse_sliced_command(psmouse, SYN_QUE_MODEL))
		return -1;

	if (ps2_command(&psmouse->ps2dev, &param, PSMOUSE_CMD_SETRATE))
		return -1;

	/* Advanced gesture mode also sends multi finger data */
566
	priv->info.capabilities |= BIT(1);
567 568 569 570 571

	return 0;
}

static int synaptics_set_mode(struct psmouse *psmouse)
L
Linus Torvalds 已提交
572 573 574
{
	struct synaptics_data *priv = psmouse->private;

575
	priv->mode = 0;
576
	if (priv->absolute_mode)
577
		priv->mode |= SYN_BIT_ABSOLUTE_MODE;
578
	if (priv->disable_gesture)
L
Linus Torvalds 已提交
579
		priv->mode |= SYN_BIT_DISABLE_GESTURE;
580 581
	if (psmouse->rate >= 80)
		priv->mode |= SYN_BIT_HIGH_RATE;
582
	if (SYN_CAP_EXTENDED(priv->info.capabilities))
583
		priv->mode |= SYN_BIT_W_MODE;
L
Linus Torvalds 已提交
584 585 586 587

	if (synaptics_mode_cmd(psmouse, priv->mode))
		return -1;

588 589 590 591 592 593
	if (priv->absolute_mode &&
	    synaptics_set_advanced_gesture_mode(psmouse)) {
		psmouse_err(psmouse, "Advanced gesture mode init failed.\n");
		return -1;
	}

L
Linus Torvalds 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
	return 0;
}

static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
{
	struct synaptics_data *priv = psmouse->private;

	if (rate >= 80) {
		priv->mode |= SYN_BIT_HIGH_RATE;
		psmouse->rate = 80;
	} else {
		priv->mode &= ~SYN_BIT_HIGH_RATE;
		psmouse->rate = 40;
	}

	synaptics_mode_cmd(psmouse, priv->mode);
}

/*****************************************************************************
 *	Synaptics pass-through PS/2 port support
 ****************************************************************************/
static int synaptics_pt_write(struct serio *serio, unsigned char c)
{
	struct psmouse *parent = serio_get_drvdata(serio->parent);
	char rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */

	if (psmouse_sliced_command(parent, c))
		return -1;
	if (ps2_command(&parent->ps2dev, &rate_param, PSMOUSE_CMD_SETRATE))
		return -1;
	return 0;
}

627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
static int synaptics_pt_start(struct serio *serio)
{
	struct psmouse *parent = serio_get_drvdata(serio->parent);
	struct synaptics_data *priv = parent->private;

	serio_pause_rx(parent->ps2dev.serio);
	priv->pt_port = serio;
	serio_continue_rx(parent->ps2dev.serio);

	return 0;
}

static void synaptics_pt_stop(struct serio *serio)
{
	struct psmouse *parent = serio_get_drvdata(serio->parent);
	struct synaptics_data *priv = parent->private;

	serio_pause_rx(parent->ps2dev.serio);
	priv->pt_port = NULL;
	serio_continue_rx(parent->ps2dev.serio);
}

static int synaptics_is_pt_packet(unsigned char *buf)
L
Linus Torvalds 已提交
650 651 652 653
{
	return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
}

654
static void synaptics_pass_pt_packet(struct serio *ptport,
655
				     unsigned char *packet)
L
Linus Torvalds 已提交
656 657 658 659
{
	struct psmouse *child = serio_get_drvdata(ptport);

	if (child && child->state == PSMOUSE_ACTIVATED) {
660
		serio_interrupt(ptport, packet[1], 0);
661 662
		serio_interrupt(ptport, packet[4], 0);
		serio_interrupt(ptport, packet[5], 0);
663
		if (child->pktsize == 4)
664
			serio_interrupt(ptport, packet[2], 0);
665
	} else {
666
		serio_interrupt(ptport, packet[1], 0);
667
	}
L
Linus Torvalds 已提交
668 669 670 671 672
}

static void synaptics_pt_activate(struct psmouse *psmouse)
{
	struct synaptics_data *priv = psmouse->private;
673
	struct psmouse *child = serio_get_drvdata(priv->pt_port);
L
Linus Torvalds 已提交
674 675 676

	/* adjust the touchpad to child's choice of protocol */
	if (child) {
677
		if (child->pktsize == 4)
L
Linus Torvalds 已提交
678 679 680 681 682
			priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
		else
			priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT;

		if (synaptics_mode_cmd(psmouse, priv->mode))
683 684
			psmouse_warn(psmouse,
				     "failed to switch guest protocol\n");
L
Linus Torvalds 已提交
685 686 687 688 689 690 691
	}
}

static void synaptics_pt_create(struct psmouse *psmouse)
{
	struct serio *serio;

692
	serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
L
Linus Torvalds 已提交
693
	if (!serio) {
694 695
		psmouse_err(psmouse,
			    "not enough memory for pass-through port\n");
L
Linus Torvalds 已提交
696 697 698 699 700 701 702
		return;
	}

	serio->id.type = SERIO_PS_PSTHRU;
	strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
	strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
	serio->write = synaptics_pt_write;
703 704
	serio->start = synaptics_pt_start;
	serio->stop = synaptics_pt_stop;
L
Linus Torvalds 已提交
705 706 707 708
	serio->parent = psmouse->ps2dev.serio;

	psmouse->pt_activate = synaptics_pt_activate;

709 710
	psmouse_info(psmouse, "serio: %s port at %s\n",
		     serio->name, psmouse->phys);
L
Linus Torvalds 已提交
711 712 713 714 715 716 717
	serio_register_port(serio);
}

/*****************************************************************************
 *	Functions to interpret the absolute mode packets
 ****************************************************************************/

718
static void synaptics_parse_agm(const unsigned char buf[],
719 720
				struct synaptics_data *priv,
				struct synaptics_hw_state *hw)
721 722
{
	struct synaptics_hw_state *agm = &priv->agm;
723 724 725 726 727 728 729 730 731 732 733 734 735
	int agm_packet_type;

	agm_packet_type = (buf[5] & 0x30) >> 4;
	switch (agm_packet_type) {
	case 1:
		/* Gesture packet: (x, y, z) half resolution */
		agm->w = hw->w;
		agm->x = (((buf[4] & 0x0f) << 8) | buf[1]) << 1;
		agm->y = (((buf[4] & 0xf0) << 4) | buf[2]) << 1;
		agm->z = ((buf[3] & 0x30) | (buf[5] & 0x0f)) << 1;
		break;

	case 2:
736 737
		/* AGM-CONTACT packet: we are only interested in the count */
		priv->agm_count = buf[1];
738 739 740 741 742
		break;

	default:
		break;
	}
743 744
}

745 746 747 748 749
static void synaptics_parse_ext_buttons(const unsigned char buf[],
					struct synaptics_data *priv,
					struct synaptics_hw_state *hw)
{
	unsigned int ext_bits =
750
		(SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap) + 1) >> 1;
751 752 753 754 755 756
	unsigned int ext_mask = GENMASK(ext_bits - 1, 0);

	hw->ext_buttons = buf[4] & ext_mask;
	hw->ext_buttons |= (buf[5] & ext_mask) << ext_bits;
}

757 758 759
static int synaptics_parse_hw_state(const unsigned char buf[],
				    struct synaptics_data *priv,
				    struct synaptics_hw_state *hw)
L
Linus Torvalds 已提交
760 761 762
{
	memset(hw, 0, sizeof(struct synaptics_hw_state));

763
	if (SYN_MODEL_NEWABS(priv->info.model_id)) {
L
Linus Torvalds 已提交
764 765 766 767
		hw->w = (((buf[0] & 0x30) >> 2) |
			 ((buf[0] & 0x04) >> 1) |
			 ((buf[3] & 0x04) >> 2));

768 769
		if ((SYN_CAP_ADV_GESTURE(priv->info.ext_cap_0c) ||
			SYN_CAP_IMAGE_SENSOR(priv->info.ext_cap_0c)) &&
770 771 772 773 774 775 776 777 778 779 780 781 782
		    hw->w == 2) {
			synaptics_parse_agm(buf, priv, hw);
			return 1;
		}

		hw->x = (((buf[3] & 0x10) << 8) |
			 ((buf[1] & 0x0f) << 8) |
			 buf[4]);
		hw->y = (((buf[3] & 0x20) << 7) |
			 ((buf[1] & 0xf0) << 4) |
			 buf[5]);
		hw->z = buf[2];

L
Linus Torvalds 已提交
783 784 785
		hw->left  = (buf[0] & 0x01) ? 1 : 0;
		hw->right = (buf[0] & 0x02) ? 1 : 0;

786
		if (priv->is_forcepad) {
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
			/*
			 * ForcePads, like Clickpads, use middle button
			 * bits to report primary button clicks.
			 * Unfortunately they report primary button not
			 * only when user presses on the pad above certain
			 * threshold, but also when there are more than one
			 * finger on the touchpad, which interferes with
			 * out multi-finger gestures.
			 */
			if (hw->z == 0) {
				/* No contacts */
				priv->press = priv->report_press = false;
			} else if (hw->w >= 4 && ((buf[0] ^ buf[3]) & 0x01)) {
				/*
				 * Single-finger touch with pressure above
				 * the threshold. If pressure stays long
				 * enough, we'll start reporting primary
				 * button. We rely on the device continuing
				 * sending data even if finger does not
				 * move.
				 */
				if  (!priv->press) {
					priv->press_start = jiffies;
					priv->press = true;
				} else if (time_after(jiffies,
						priv->press_start +
							msecs_to_jiffies(50))) {
					priv->report_press = true;
				}
			} else {
				priv->press = false;
			}

			hw->left = priv->report_press;

822
		} else if (SYN_CAP_CLICKPAD(priv->info.ext_cap_0c)) {
823 824 825 826 827 828 829
			/*
			 * Clickpad's button is transmitted as middle button,
			 * however, since it is primary button, we will report
			 * it as BTN_LEFT.
			 */
			hw->left = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;

830
		} else if (SYN_CAP_MIDDLE_BUTTON(priv->info.capabilities)) {
L
Linus Torvalds 已提交
831 832 833 834 835
			hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
			if (hw->w == 2)
				hw->scroll = (signed char)(buf[1]);
		}

836
		if (SYN_CAP_FOUR_BUTTON(priv->info.capabilities)) {
L
Linus Torvalds 已提交
837 838 839 840
			hw->up   = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
			hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
		}

841
		if (SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap) > 0 &&
L
Linus Torvalds 已提交
842
		    ((buf[0] ^ buf[3]) & 0x02)) {
843
			synaptics_parse_ext_buttons(buf, priv, hw);
L
Linus Torvalds 已提交
844 845 846 847 848 849 850 851 852 853 854
		}
	} else {
		hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
		hw->y = (((buf[4] & 0x1f) << 8) | buf[5]);

		hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F));
		hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1));

		hw->left  = (buf[0] & 0x01) ? 1 : 0;
		hw->right = (buf[0] & 0x02) ? 1 : 0;
	}
855

856 857 858 859 860 861
	/*
	 * Convert wrap-around values to negative. (X|Y)_MAX_POSITIVE
	 * is used by some firmware to indicate a finger at the edge of
	 * the touchpad whose precise position cannot be determined, so
	 * convert these values to the maximum axis value.
	 */
862 863
	if (hw->x > X_MAX_POSITIVE)
		hw->x -= 1 << ABS_POS_BITS;
864 865 866
	else if (hw->x == X_MAX_POSITIVE)
		hw->x = XMAX;

867 868
	if (hw->y > Y_MAX_POSITIVE)
		hw->y -= 1 << ABS_POS_BITS;
869 870
	else if (hw->y == Y_MAX_POSITIVE)
		hw->y = YMAX;
871

872 873 874
	return 0;
}

875 876
static void synaptics_report_semi_mt_slot(struct input_dev *dev, int slot,
					  bool active, int x, int y)
877 878 879 880 881
{
	input_mt_slot(dev, slot);
	input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
	if (active) {
		input_report_abs(dev, ABS_MT_POSITION_X, x);
882
		input_report_abs(dev, ABS_MT_POSITION_Y, synaptics_invert_y(y));
883 884 885 886 887 888 889 890 891
	}
}

static void synaptics_report_semi_mt_data(struct input_dev *dev,
					  const struct synaptics_hw_state *a,
					  const struct synaptics_hw_state *b,
					  int num_fingers)
{
	if (num_fingers >= 2) {
892 893 894 895
		synaptics_report_semi_mt_slot(dev, 0, true, min(a->x, b->x),
					      min(a->y, b->y));
		synaptics_report_semi_mt_slot(dev, 1, true, max(a->x, b->x),
					      max(a->y, b->y));
896
	} else if (num_fingers == 1) {
897 898
		synaptics_report_semi_mt_slot(dev, 0, true, a->x, a->y);
		synaptics_report_semi_mt_slot(dev, 1, false, 0, 0);
899
	} else {
900 901
		synaptics_report_semi_mt_slot(dev, 0, false, 0, 0);
		synaptics_report_semi_mt_slot(dev, 1, false, 0, 0);
902
	}
L
Linus Torvalds 已提交
903 904
}

905 906
static void synaptics_report_ext_buttons(struct psmouse *psmouse,
					 const struct synaptics_hw_state *hw)
907 908 909
{
	struct input_dev *dev = psmouse->dev;
	struct synaptics_data *priv = psmouse->private;
910
	int ext_bits = (SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap) + 1) >> 1;
911 912
	int i;

913
	if (!SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap))
914 915
		return;

916
	/* Bug in FW 8.1 & 8.2, buttons are reported only when ExtBit is 1 */
917 918
	if ((SYN_ID_FULL(priv->info.identity) == 0x801 ||
	     SYN_ID_FULL(priv->info.identity) == 0x802) &&
919 920 921
	    !((psmouse->packet[0] ^ psmouse->packet[3]) & 0x02))
		return;

922
	if (!SYN_CAP_EXT_BUTTONS_STICK(priv->info.ext_cap_10)) {
923 924 925 926 927 928 929
		for (i = 0; i < ext_bits; i++) {
			input_report_key(dev, BTN_0 + 2 * i,
				hw->ext_buttons & (1 << i));
			input_report_key(dev, BTN_1 + 2 * i,
				hw->ext_buttons & (1 << (i + ext_bits)));
		}
		return;
930
	}
931 932 933 934 935 936

	/*
	 * This generation of touchpads has the trackstick buttons
	 * physically wired to the touchpad. Re-route them through
	 * the pass-through interface.
	 */
937 938
	if (priv->pt_port) {
		u8 pt_buttons;
939

940
		/* The trackstick expects at most 3 buttons */
941 942 943
		pt_buttons = SYN_EXT_BUTTON_STICK_L(hw->ext_buttons)      |
			     SYN_EXT_BUTTON_STICK_R(hw->ext_buttons) << 1 |
			     SYN_EXT_BUTTON_STICK_M(hw->ext_buttons) << 2;
944

945 946 947 948
		serio_interrupt(priv->pt_port,
				PSMOUSE_OOB_EXTRA_BTNS, SERIO_OOB_DATA);
		serio_interrupt(priv->pt_port, pt_buttons, SERIO_OOB_DATA);
	}
949 950
}

951 952 953 954 955 956 957 958 959
static void synaptics_report_buttons(struct psmouse *psmouse,
				     const struct synaptics_hw_state *hw)
{
	struct input_dev *dev = psmouse->dev;
	struct synaptics_data *priv = psmouse->private;

	input_report_key(dev, BTN_LEFT, hw->left);
	input_report_key(dev, BTN_RIGHT, hw->right);

960
	if (SYN_CAP_MIDDLE_BUTTON(priv->info.capabilities))
961 962
		input_report_key(dev, BTN_MIDDLE, hw->middle);

963
	if (SYN_CAP_FOUR_BUTTON(priv->info.capabilities)) {
964 965 966 967
		input_report_key(dev, BTN_FORWARD, hw->up);
		input_report_key(dev, BTN_BACK, hw->down);
	}

968
	synaptics_report_ext_buttons(psmouse, hw);
969 970 971
}

static void synaptics_report_mt_data(struct psmouse *psmouse,
972 973
				     const struct synaptics_hw_state *sgm,
				     int num_fingers)
974 975 976
{
	struct input_dev *dev = psmouse->dev;
	struct synaptics_data *priv = psmouse->private;
977 978 979
	const struct synaptics_hw_state *hw[2] = { sgm, &priv->agm };
	struct input_mt_pos pos[2];
	int slot[2], nsemi, i;
980

981
	nsemi = clamp_val(num_fingers, 0, 2);
982

983 984 985
	for (i = 0; i < nsemi; i++) {
		pos[i].x = hw[i]->x;
		pos[i].y = synaptics_invert_y(hw[i]->y);
986 987
	}

988
	input_mt_assign_slots(dev, slot, pos, nsemi, DMAX * priv->info.x_res);
989 990 991 992 993 994 995 996 997 998 999

	for (i = 0; i < nsemi; i++) {
		input_mt_slot(dev, slot[i]);
		input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
		input_report_abs(dev, ABS_MT_POSITION_X, pos[i].x);
		input_report_abs(dev, ABS_MT_POSITION_Y, pos[i].y);
		input_report_abs(dev, ABS_MT_PRESSURE, hw[i]->z);
	}

	input_mt_drop_unused(dev);

1000 1001 1002 1003
	/* Don't use active slot count to generate BTN_TOOL events. */
	input_mt_report_pointer_emulation(dev, false);

	/* Send the number of fingers reported by touchpad itself. */
1004
	input_mt_report_finger_count(dev, num_fingers);
1005 1006 1007 1008 1009 1010 1011 1012 1013

	synaptics_report_buttons(psmouse, sgm);

	input_sync(dev);
}

static void synaptics_image_sensor_process(struct psmouse *psmouse,
					   struct synaptics_hw_state *sgm)
{
1014
	struct synaptics_data *priv = psmouse->private;
1015
	int num_fingers;
1016 1017 1018 1019

	/*
	 * Update mt_state using the new finger count and current mt_state.
	 */
1020
	if (sgm->z == 0)
1021
		num_fingers = 0;
1022
	else if (sgm->w >= 4)
1023
		num_fingers = 1;
1024
	else if (sgm->w == 0)
1025 1026 1027
		num_fingers = 2;
	else if (sgm->w == 1)
		num_fingers = priv->agm_count ? priv->agm_count : 3;
1028
	else
1029
		num_fingers = 4;
1030 1031

	/* Send resulting input events to user space */
1032
	synaptics_report_mt_data(psmouse, sgm, num_fingers);
1033 1034
}

L
Linus Torvalds 已提交
1035 1036 1037 1038 1039
/*
 *  called for each full received packet from the touchpad
 */
static void synaptics_process_packet(struct psmouse *psmouse)
{
1040
	struct input_dev *dev = psmouse->dev;
L
Linus Torvalds 已提交
1041
	struct synaptics_data *priv = psmouse->private;
1042
	struct synaptics_device_info *info = &priv->info;
L
Linus Torvalds 已提交
1043 1044 1045 1046
	struct synaptics_hw_state hw;
	int num_fingers;
	int finger_width;

1047 1048
	if (synaptics_parse_hw_state(psmouse->packet, priv, &hw))
		return;
L
Linus Torvalds 已提交
1049

1050
	if (SYN_CAP_IMAGE_SENSOR(info->ext_cap_0c)) {
1051 1052 1053 1054
		synaptics_image_sensor_process(psmouse, &hw);
		return;
	}

L
Linus Torvalds 已提交
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
	if (hw.scroll) {
		priv->scroll += hw.scroll;

		while (priv->scroll >= 4) {
			input_report_key(dev, BTN_BACK, !hw.down);
			input_sync(dev);
			input_report_key(dev, BTN_BACK, hw.down);
			input_sync(dev);
			priv->scroll -= 4;
		}
		while (priv->scroll <= -4) {
			input_report_key(dev, BTN_FORWARD, !hw.up);
			input_sync(dev);
			input_report_key(dev, BTN_FORWARD, hw.up);
			input_sync(dev);
			priv->scroll += 4;
		}
		return;
	}

1075
	if (hw.z > 0 && hw.x > 1) {
L
Linus Torvalds 已提交
1076 1077
		num_fingers = 1;
		finger_width = 5;
1078
		if (SYN_CAP_EXTENDED(info->capabilities)) {
L
Linus Torvalds 已提交
1079 1080
			switch (hw.w) {
			case 0 ... 1:
1081
				if (SYN_CAP_MULTIFINGER(info->capabilities))
L
Linus Torvalds 已提交
1082 1083 1084
					num_fingers = hw.w + 2;
				break;
			case 2:
1085
				if (SYN_MODEL_PEN(info->model_id))
L
Linus Torvalds 已提交
1086 1087 1088
					;   /* Nothing, treat a pen as a single finger */
				break;
			case 4 ... 15:
1089
				if (SYN_CAP_PALMDETECT(info->capabilities))
L
Linus Torvalds 已提交
1090 1091 1092 1093 1094 1095 1096 1097 1098
					finger_width = hw.w;
				break;
			}
		}
	} else {
		num_fingers = 0;
		finger_width = 0;
	}

1099
	if (cr48_profile_sensor) {
1100
		synaptics_report_mt_data(psmouse, &hw, num_fingers);
1101 1102 1103
		return;
	}

1104
	if (SYN_CAP_ADV_GESTURE(info->ext_cap_0c))
1105 1106
		synaptics_report_semi_mt_data(dev, &hw, &priv->agm,
					      num_fingers);
1107

L
Linus Torvalds 已提交
1108 1109 1110 1111 1112 1113 1114
	/* Post events
	 * BTN_TOUCH has to be first as mousedev relies on it when doing
	 * absolute -> relative conversion
	 */
	if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
	if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);

1115
	if (num_fingers > 0) {
L
Linus Torvalds 已提交
1116
		input_report_abs(dev, ABS_X, hw.x);
1117
		input_report_abs(dev, ABS_Y, synaptics_invert_y(hw.y));
L
Linus Torvalds 已提交
1118 1119 1120
	}
	input_report_abs(dev, ABS_PRESSURE, hw.z);

1121
	if (SYN_CAP_PALMDETECT(info->capabilities))
1122 1123
		input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);

L
Linus Torvalds 已提交
1124
	input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
1125
	if (SYN_CAP_MULTIFINGER(info->capabilities)) {
1126 1127 1128 1129
		input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
		input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
	}

1130
	synaptics_report_buttons(psmouse, &hw);
L
Linus Torvalds 已提交
1131 1132 1133 1134

	input_sync(dev);
}

1135 1136
static int synaptics_validate_byte(struct psmouse *psmouse,
				   int idx, unsigned char pkt_type)
L
Linus Torvalds 已提交
1137
{
H
Helge Deller 已提交
1138 1139 1140 1141 1142
	static const unsigned char newabs_mask[]	= { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
	static const unsigned char newabs_rel_mask[]	= { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
	static const unsigned char newabs_rslt[]	= { 0x80, 0x00, 0x00, 0xC0, 0x00 };
	static const unsigned char oldabs_mask[]	= { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
	static const unsigned char oldabs_rslt[]	= { 0xC0, 0x00, 0x00, 0x80, 0x00 };
1143
	const char *packet = psmouse->packet;
L
Linus Torvalds 已提交
1144 1145 1146 1147 1148 1149

	if (idx < 0 || idx > 4)
		return 0;

	switch (pkt_type) {

1150 1151 1152
	case SYN_NEWABS:
	case SYN_NEWABS_RELAXED:
		return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
L
Linus Torvalds 已提交
1153

1154 1155
	case SYN_NEWABS_STRICT:
		return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
L
Linus Torvalds 已提交
1156

1157 1158 1159 1160
	case SYN_OLDABS:
		return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];

	default:
1161
		psmouse_err(psmouse, "unknown packet type %d\n", pkt_type);
1162
		return 0;
L
Linus Torvalds 已提交
1163 1164 1165 1166 1167 1168 1169 1170
	}
}

static unsigned char synaptics_detect_pkt_type(struct psmouse *psmouse)
{
	int i;

	for (i = 0; i < 5; i++)
1171 1172
		if (!synaptics_validate_byte(psmouse, i, SYN_NEWABS_STRICT)) {
			psmouse_info(psmouse, "using relaxed packet validation\n");
L
Linus Torvalds 已提交
1173 1174 1175 1176 1177 1178
			return SYN_NEWABS_RELAXED;
		}

	return SYN_NEWABS_STRICT;
}

1179
static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186
{
	struct synaptics_data *priv = psmouse->private;

	if (psmouse->pktcnt >= 6) { /* Full packet received */
		if (unlikely(priv->pkt_type == SYN_NEWABS))
			priv->pkt_type = synaptics_detect_pkt_type(psmouse);

1187
		if (SYN_CAP_PASS_THROUGH(priv->info.capabilities) &&
1188 1189
		    synaptics_is_pt_packet(psmouse->packet)) {
			if (priv->pt_port)
1190
				synaptics_pass_pt_packet(priv->pt_port,
1191
							 psmouse->packet);
L
Linus Torvalds 已提交
1192 1193 1194 1195 1196 1197
		} else
			synaptics_process_packet(psmouse);

		return PSMOUSE_FULL_PACKET;
	}

1198
	return synaptics_validate_byte(psmouse, psmouse->pktcnt - 1, priv->pkt_type) ?
L
Linus Torvalds 已提交
1199 1200 1201 1202 1203 1204
		PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
}

/*****************************************************************************
 *	Driver initialization/cleanup functions
 ****************************************************************************/
1205
static void set_abs_position_params(struct input_dev *dev,
1206 1207
				    struct synaptics_device_info *info,
				    int x_code, int y_code)
L
Linus Torvalds 已提交
1208
{
1209 1210 1211 1212 1213
	int x_min = info->x_min ?: XMIN_NOMINAL;
	int x_max = info->x_max ?: XMAX_NOMINAL;
	int y_min = info->y_min ?: YMIN_NOMINAL;
	int y_max = info->y_max ?: YMAX_NOMINAL;
	int fuzz = SYN_CAP_REDUCED_FILTERING(info->ext_cap_0c) ?
1214
			SYN_REDUCED_FILTER_FUZZ : 0;
L
Linus Torvalds 已提交
1215

1216 1217
	input_set_abs_params(dev, x_code, x_min, x_max, fuzz, 0);
	input_set_abs_params(dev, y_code, y_min, y_max, fuzz, 0);
1218 1219
	input_abs_set_res(dev, x_code, info->x_res);
	input_abs_set_res(dev, y_code, info->y_res);
1220 1221
}

1222 1223
static void set_input_params(struct psmouse *psmouse,
			     struct synaptics_data *priv)
1224
{
1225
	struct input_dev *dev = psmouse->dev;
1226
	struct synaptics_device_info *info = &priv->info;
1227 1228
	int i;

1229
	/* Things that apply to both modes */
1230
	__set_bit(INPUT_PROP_POINTER, dev->propbit);
1231 1232 1233
	__set_bit(EV_KEY, dev->evbit);
	__set_bit(BTN_LEFT, dev->keybit);
	__set_bit(BTN_RIGHT, dev->keybit);
1234

1235
	if (SYN_CAP_MIDDLE_BUTTON(info->capabilities))
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
		__set_bit(BTN_MIDDLE, dev->keybit);

	if (!priv->absolute_mode) {
		/* Relative mode */
		__set_bit(EV_REL, dev->evbit);
		__set_bit(REL_X, dev->relbit);
		__set_bit(REL_Y, dev->relbit);
		return;
	}

	/* Absolute mode */
1247
	__set_bit(EV_ABS, dev->evbit);
1248
	set_abs_position_params(dev, &priv->info, ABS_X, ABS_Y);
L
Linus Torvalds 已提交
1249
	input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
1250

1251 1252 1253
	if (cr48_profile_sensor)
		input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);

1254 1255 1256
	if (SYN_CAP_IMAGE_SENSOR(info->ext_cap_0c)) {
		set_abs_position_params(dev, info,
					ABS_MT_POSITION_X, ABS_MT_POSITION_Y);
1257 1258
		/* Image sensors can report per-contact pressure */
		input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
1259
		input_mt_init_slots(dev, 2, INPUT_MT_POINTER | INPUT_MT_TRACK);
1260 1261 1262 1263

		/* Image sensors can signal 4 and 5 finger clicks */
		__set_bit(BTN_TOOL_QUADTAP, dev->keybit);
		__set_bit(BTN_TOOL_QUINTTAP, dev->keybit);
1264 1265 1266
	} else if (SYN_CAP_ADV_GESTURE(info->ext_cap_0c)) {
		set_abs_position_params(dev, info,
					ABS_MT_POSITION_X, ABS_MT_POSITION_Y);
1267 1268 1269 1270
		/*
		 * Profile sensor in CR-48 tracks contacts reasonably well,
		 * other non-image sensors with AGM use semi-mt.
		 */
1271
		input_mt_init_slots(dev, 2,
1272 1273 1274
				    INPUT_MT_POINTER |
				    (cr48_profile_sensor ?
					INPUT_MT_TRACK : INPUT_MT_SEMI_MT));
1275 1276
	}

1277
	if (SYN_CAP_PALMDETECT(info->capabilities))
1278
		input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
L
Linus Torvalds 已提交
1279

1280 1281
	__set_bit(BTN_TOUCH, dev->keybit);
	__set_bit(BTN_TOOL_FINGER, dev->keybit);
L
Linus Torvalds 已提交
1282

1283
	if (SYN_CAP_MULTIFINGER(info->capabilities)) {
1284 1285
		__set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
		__set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
1286 1287
	}

1288 1289
	if (SYN_CAP_FOUR_BUTTON(info->capabilities) ||
	    SYN_CAP_MIDDLE_BUTTON(info->capabilities)) {
1290 1291
		__set_bit(BTN_FORWARD, dev->keybit);
		__set_bit(BTN_BACK, dev->keybit);
L
Linus Torvalds 已提交
1292 1293
	}

1294 1295
	if (!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10))
		for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(info->ext_cap); i++)
1296
			__set_bit(BTN_0 + i, dev->keybit);
L
Linus Torvalds 已提交
1297

1298 1299 1300
	__clear_bit(EV_REL, dev->evbit);
	__clear_bit(REL_X, dev->relbit);
	__clear_bit(REL_Y, dev->relbit);
1301

1302
	if (SYN_CAP_CLICKPAD(info->ext_cap_0c)) {
1303
		__set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
1304
		if (psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
1305
		    !SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10))
1306
			__set_bit(INPUT_PROP_TOPBUTTONPAD, dev->propbit);
1307 1308 1309 1310
		/* Clickpads report only left button */
		__clear_bit(BTN_RIGHT, dev->keybit);
		__clear_bit(BTN_MIDDLE, dev->keybit);
	}
L
Linus Torvalds 已提交
1311 1312
}

1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
static ssize_t synaptics_show_disable_gesture(struct psmouse *psmouse,
					      void *data, char *buf)
{
	struct synaptics_data *priv = psmouse->private;

	return sprintf(buf, "%c\n", priv->disable_gesture ? '1' : '0');
}

static ssize_t synaptics_set_disable_gesture(struct psmouse *psmouse,
					     void *data, const char *buf,
					     size_t len)
{
	struct synaptics_data *priv = psmouse->private;
	unsigned int value;
	int err;

	err = kstrtouint(buf, 10, &value);
	if (err)
		return err;

	if (value > 1)
		return -EINVAL;

	if (value == priv->disable_gesture)
		return len;

	priv->disable_gesture = value;
	if (value)
		priv->mode |= SYN_BIT_DISABLE_GESTURE;
	else
		priv->mode &= ~SYN_BIT_DISABLE_GESTURE;

	if (synaptics_mode_cmd(psmouse, priv->mode))
		return -EIO;

	return len;
}

PSMOUSE_DEFINE_ATTR(disable_gesture, S_IWUSR | S_IRUGO, NULL,
		    synaptics_show_disable_gesture,
		    synaptics_set_disable_gesture);

L
Linus Torvalds 已提交
1355 1356
static void synaptics_disconnect(struct psmouse *psmouse)
{
1357 1358
	struct synaptics_data *priv = psmouse->private;

1359 1360 1361 1362 1363 1364
	/*
	 * We might have left a breadcrumb when trying to
	 * set up SMbus companion.
	 */
	psmouse_smbus_cleanup(psmouse);

1365 1366
	if (!priv->absolute_mode &&
			SYN_ID_DISGEST_SUPPORTED(priv->info.identity))
1367 1368 1369
		device_remove_file(&psmouse->ps2dev.serio->dev,
				   &psmouse_attr_disable_gesture.dattr);

L
Linus Torvalds 已提交
1370
	synaptics_reset(psmouse);
1371
	kfree(priv);
L
Linus Torvalds 已提交
1372 1373 1374 1375 1376 1377
	psmouse->private = NULL;
}

static int synaptics_reconnect(struct psmouse *psmouse)
{
	struct synaptics_data *priv = psmouse->private;
1378
	struct synaptics_device_info info;
1379
	unsigned char param[2];
1380 1381
	int retry = 0;
	int error;
L
Linus Torvalds 已提交
1382

1383 1384
	do {
		psmouse_reset(psmouse);
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
		if (retry) {
			/*
			 * On some boxes, right after resuming, the touchpad
			 * needs some time to finish initializing (I assume
			 * it needs time to calibrate) and start responding
			 * to Synaptics-specific queries, so let's wait a
			 * bit.
			 */
			ssleep(1);
		}
1395
		ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETID);
1396 1397
		error = synaptics_detect(psmouse, 0);
	} while (error && ++retry < 3);
1398

1399
	if (error)
L
Linus Torvalds 已提交
1400 1401
		return -1;

1402
	if (retry > 1)
1403
		psmouse_dbg(psmouse, "reconnected after %d tries\n", retry);
1404

1405
	if (synaptics_query_hardware(psmouse, &info)) {
1406
		psmouse_err(psmouse, "Unable to query device.\n");
L
Linus Torvalds 已提交
1407 1408 1409
		return -1;
	}

1410
	if (synaptics_set_mode(psmouse)) {
1411
		psmouse_err(psmouse, "Unable to initialize device.\n");
L
Linus Torvalds 已提交
1412 1413 1414
		return -1;
	}

1415 1416 1417 1418
	if (info.identity != priv->info.identity ||
	    info.model_id != priv->info.model_id ||
	    info.capabilities != priv->info.capabilities ||
	    info.ext_cap != priv->info.ext_cap) {
1419
		psmouse_err(psmouse,
1420 1421 1422 1423 1424
			    "hardware appears to be different: id(%u-%u), model(%u-%u), caps(%x-%x), ext(%x-%x).\n",
			    priv->info.identity, info.identity,
			    priv->info.model_id, info.model_id,
			    priv->info.capabilities, info.capabilities,
			    priv->info.ext_cap, info.ext_cap);
1425 1426 1427
		return -1;
	}

L
Linus Torvalds 已提交
1428 1429 1430
	return 0;
}

1431 1432
static bool impaired_toshiba_kbc;

1433
static const struct dmi_system_id toshiba_dmi_table[] __initconst = {
1434
#if defined(CONFIG_DMI) && defined(CONFIG_X86)
L
Linus Torvalds 已提交
1435
	{
1436
		/* Toshiba Satellite */
L
Linus Torvalds 已提交
1437 1438
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1439
			DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
L
Linus Torvalds 已提交
1440 1441
		},
	},
1442
	{
1443
		/* Toshiba Dynabook */
1444 1445
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1446 1447 1448 1449
			DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"),
		},
	},
	{
1450
		/* Toshiba Portege M300 */
1451 1452 1453
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"),
1454
		},
1455 1456 1457

	},
	{
1458
		/* Toshiba Portege M300 */
1459 1460 1461 1462 1463 1464
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Portable PC"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Version 1.0"),
		},

1465
	},
L
Linus Torvalds 已提交
1466
#endif
1467
	{ }
1468 1469
};

1470 1471
static bool broken_olpc_ec;

1472
static const struct dmi_system_id olpc_dmi_table[] __initconst = {
1473 1474 1475 1476 1477 1478 1479 1480 1481
#if defined(CONFIG_DMI) && defined(CONFIG_OLPC)
	{
		/* OLPC XO-1 or XO-1.5 */
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "OLPC"),
			DMI_MATCH(DMI_PRODUCT_NAME, "XO"),
		},
	},
#endif
1482
	{ }
1483 1484
};

1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
static const struct dmi_system_id __initconst cr48_dmi_table[] = {
#if defined(CONFIG_DMI) && defined(CONFIG_X86)
	{
		/* Cr-48 Chromebook (Codename Mario) */
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "IEC"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
		},
	},
#endif
	{ }
};

1498 1499 1500
void __init synaptics_module_init(void)
{
	impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
1501
	broken_olpc_ec = dmi_check_system(olpc_dmi_table);
1502
	cr48_profile_sensor = dmi_check_system(cr48_dmi_table);
1503
}
L
Linus Torvalds 已提交
1504

1505 1506 1507
static int synaptics_init_ps2(struct psmouse *psmouse,
			      struct synaptics_device_info *info,
			      bool absolute_mode)
L
Linus Torvalds 已提交
1508 1509
{
	struct synaptics_data *priv;
1510
	int err;
L
Linus Torvalds 已提交
1511

1512
	synaptics_apply_quirks(psmouse, info);
1513

1514
	psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
L
Linus Torvalds 已提交
1515
	if (!priv)
1516
		return -ENOMEM;
L
Linus Torvalds 已提交
1517

1518
	priv->info = *info;
1519
	priv->absolute_mode = absolute_mode;
1520
	if (SYN_ID_DISGEST_SUPPORTED(info->identity))
1521
		priv->disable_gesture = true;
L
Linus Torvalds 已提交
1522

1523 1524 1525 1526 1527 1528
	/*
	 * Unfortunately ForcePad capability is not exported over PS/2,
	 * so we have to resort to checking PNP IDs.
	 */
	priv->is_forcepad = psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids);

1529 1530
	err = synaptics_set_mode(psmouse);
	if (err) {
1531
		psmouse_err(psmouse, "Unable to initialize device.\n");
1532 1533 1534
		goto init_fail;
	}

1535 1536
	priv->pkt_type = SYN_MODEL_NEWABS(info->model_id) ?
					SYN_NEWABS : SYN_OLDABS;
L
Linus Torvalds 已提交
1537

1538
	psmouse_info(psmouse,
1539 1540 1541 1542 1543 1544
		     "Touchpad model: %u, fw: %u.%u, id: %#x, caps: %#x/%#x/%#x/%#x, board id: %u, fw id: %u\n",
		     SYN_ID_MODEL(info->identity),
		     SYN_ID_MAJOR(info->identity), SYN_ID_MINOR(info->identity),
		     info->model_id,
		     info->capabilities, info->ext_cap, info->ext_cap_0c,
		     info->ext_cap_10, info->board_id, info->firmware_id);
1545

1546
	set_input_params(psmouse, priv);
L
Linus Torvalds 已提交
1547

1548 1549 1550 1551 1552 1553 1554
	/*
	 * Encode touchpad model so that it can be used to set
	 * input device->id.version and be visible to userspace.
	 * Because version is __u16 we have to drop something.
	 * Hardware info bits seem to be good candidates as they
	 * are documented to be for Synaptics corp. internal use.
	 */
1555 1556
	psmouse->model = ((info->model_id & 0x00ff0000) >> 8) |
			  (info->model_id & 0x000000ff);
1557

1558 1559 1560 1561 1562 1563 1564 1565 1566
	if (absolute_mode) {
		psmouse->protocol_handler = synaptics_process_byte;
		psmouse->pktsize = 6;
	} else {
		/* Relative mode follows standard PS/2 mouse protocol */
		psmouse->protocol_handler = psmouse_process_byte;
		psmouse->pktsize = 3;
	}

L
Linus Torvalds 已提交
1567 1568 1569
	psmouse->set_rate = synaptics_set_rate;
	psmouse->disconnect = synaptics_disconnect;
	psmouse->reconnect = synaptics_reconnect;
1570
	psmouse->cleanup = synaptics_reset;
1571 1572
	/* Synaptics can usually stay in sync without extra help */
	psmouse->resync_time = 0;
L
Linus Torvalds 已提交
1573

1574
	if (SYN_CAP_PASS_THROUGH(info->capabilities))
L
Linus Torvalds 已提交
1575 1576 1577 1578
		synaptics_pt_create(psmouse);

	/*
	 * Toshiba's KBC seems to have trouble handling data from
1579 1580
	 * Synaptics at full rate.  Switch to a lower rate (roughly
	 * the same rate as a standard PS/2 mouse).
L
Linus Torvalds 已提交
1581
	 */
1582
	if (psmouse->rate >= 80 && impaired_toshiba_kbc) {
1583 1584 1585
		psmouse_info(psmouse,
			     "Toshiba %s detected, limiting rate to 40pps.\n",
			     dmi_get_system_info(DMI_PRODUCT_NAME));
L
Linus Torvalds 已提交
1586 1587 1588
		psmouse->rate = 40;
	}

1589
	if (!priv->absolute_mode && SYN_ID_DISGEST_SUPPORTED(info->identity)) {
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
		err = device_create_file(&psmouse->ps2dev.serio->dev,
					 &psmouse_attr_disable_gesture.dattr);
		if (err) {
			psmouse_err(psmouse,
				    "Failed to create disable_gesture attribute (%d)",
				    err);
			goto init_fail;
		}
	}

L
Linus Torvalds 已提交
1600 1601 1602 1603
	return 0;

 init_fail:
	kfree(priv);
1604 1605 1606
	return err;
}

1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
{
	struct synaptics_device_info info;
	int error;

	psmouse_reset(psmouse);

	error = synaptics_query_hardware(psmouse, &info);
	if (error) {
		psmouse_err(psmouse, "Unable to query device: %d\n", error);
		return error;
	}

	return synaptics_init_ps2(psmouse, &info, absolute_mode);
}

int synaptics_init_absolute(struct psmouse *psmouse)
1624 1625 1626 1627 1628 1629 1630
{
	return __synaptics_init(psmouse, true);
}

int synaptics_init_relative(struct psmouse *psmouse)
{
	return __synaptics_init(psmouse, false);
L
Linus Torvalds 已提交
1631 1632
}

1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
static int synaptics_setup_ps2(struct psmouse *psmouse,
			       struct synaptics_device_info *info)
{
	bool absolute_mode = true;
	int error;

	/*
	 * The OLPC XO has issues with Synaptics' absolute mode; the constant
	 * packet spew overloads the EC such that key presses on the keyboard
	 * are missed.  Given that, don't even attempt to use Absolute mode.
	 * Relative mode seems to work just fine.
	 */
	if (broken_olpc_ec) {
		psmouse_info(psmouse,
			     "OLPC XO detected, forcing relative protocol.\n");
		absolute_mode = false;
	}

	error = synaptics_init_ps2(psmouse, info, absolute_mode);
	if (error)
		return error;

	return absolute_mode ? PSMOUSE_SYNAPTICS : PSMOUSE_SYNAPTICS_RELATIVE;
}

1658 1659
#else /* CONFIG_MOUSE_PS2_SYNAPTICS */

1660 1661 1662 1663
void __init synaptics_module_init(void)
{
}

1664 1665 1666
static int __maybe_unused
synaptics_setup_ps2(struct psmouse *psmouse,
		    struct synaptics_device_info *info)
1667 1668 1669 1670 1671
{
	return -ENOSYS;
}

#endif /* CONFIG_MOUSE_PS2_SYNAPTICS */
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833

#ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS

/*
 * The newest Synaptics device can use a secondary bus (called InterTouch) which
 * provides a better bandwidth and allow a better control of the touchpads.
 * This is used to decide if we need to use this bus or not.
 */
enum {
	SYNAPTICS_INTERTOUCH_NOT_SET = -1,
	SYNAPTICS_INTERTOUCH_OFF,
	SYNAPTICS_INTERTOUCH_ON,
};

static int synaptics_intertouch = SYNAPTICS_INTERTOUCH_NOT_SET;
module_param_named(synaptics_intertouch, synaptics_intertouch, int, 0644);
MODULE_PARM_DESC(synaptics_intertouch, "Use a secondary bus for the Synaptics device.");

static int synaptics_create_intertouch(struct psmouse *psmouse,
				       struct synaptics_device_info *info,
				       bool leave_breadcrumbs)
{
	bool topbuttonpad =
		psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
		!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10);
	const struct rmi_device_platform_data pdata = {
		.sensor_pdata = {
			.sensor_type = rmi_sensor_touchpad,
			.axis_align.flip_y = true,
			/* to prevent cursors jumps: */
			.kernel_tracking = true,
			.topbuttonpad = topbuttonpad,
		},
		.f30_data = {
			.buttonpad = SYN_CAP_CLICKPAD(info->ext_cap_0c),
			.trackstick_buttons =
				!!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10),
		},
	};
	const struct i2c_board_info intertouch_board = {
		I2C_BOARD_INFO("rmi4_smbus", 0x2c),
		.flags = I2C_CLIENT_HOST_NOTIFY,
	};

	return psmouse_smbus_init(psmouse, &intertouch_board,
				  &pdata, sizeof(pdata),
				  leave_breadcrumbs);
}

/**
 * synaptics_setup_intertouch - called once the PS/2 devices are enumerated
 * and decides to instantiate a SMBus InterTouch device.
 */
static int synaptics_setup_intertouch(struct psmouse *psmouse,
				      struct synaptics_device_info *info,
				      bool leave_breadcrumbs)
{
	int error;

	if (synaptics_intertouch == SYNAPTICS_INTERTOUCH_OFF)
		return -ENXIO;

	if (synaptics_intertouch == SYNAPTICS_INTERTOUCH_NOT_SET) {
		if (!psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
		    !psmouse_matches_pnp_id(psmouse, smbus_pnp_ids))
			return -ENXIO;
	}

	psmouse_info(psmouse, "Trying to set up SMBus access\n");

	error = synaptics_create_intertouch(psmouse, info, leave_breadcrumbs);
	if (error) {
		if (error == -EAGAIN)
			psmouse_info(psmouse, "SMbus companion is not ready yet\n");
		else
			psmouse_err(psmouse, "unable to create intertouch device\n");

		return error;
	}

	return 0;
}

int synaptics_init_smbus(struct psmouse *psmouse)
{
	struct synaptics_device_info info;
	int error;

	psmouse_reset(psmouse);

	error = synaptics_query_hardware(psmouse, &info);
	if (error) {
		psmouse_err(psmouse, "Unable to query device: %d\n", error);
		return error;
	}

	if (!SYN_CAP_INTERTOUCH(info.ext_cap_0c))
		return -ENXIO;

	return synaptics_create_intertouch(psmouse, &info, false);
}

#else /* CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */

static int __maybe_unused
synaptics_setup_intertouch(struct psmouse *psmouse,
			   struct synaptics_device_info *info,
			   bool leave_breadcrumbs)
{
	return -ENOSYS;
}

int synaptics_init_smbus(struct psmouse *psmouse)
{
	return -ENOSYS;
}

#endif /* CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */

#if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \
    defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)

int synaptics_init(struct psmouse *psmouse)
{
	struct synaptics_device_info info;
	int error;
	int retval;

	psmouse_reset(psmouse);

	error = synaptics_query_hardware(psmouse, &info);
	if (error) {
		psmouse_err(psmouse, "Unable to query device: %d\n", error);
		return error;
	}

	if (SYN_CAP_INTERTOUCH(info.ext_cap_0c)) {
		error = synaptics_setup_intertouch(psmouse, &info, true);
		if (!error)
			return PSMOUSE_SYNAPTICS_SMBUS;
	}

	retval = synaptics_setup_ps2(psmouse, &info);
	if (retval < 0) {
		/*
		 * Not using any flavor of Synaptics support, so clean up
		 * SMbus breadcrumbs, if any.
		 */
		psmouse_smbus_cleanup(psmouse);
	}

	return retval;
}

#else /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */

int synaptics_init(struct psmouse *psmouse)
{
	return -ENOSYS;
}

#endif /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */