PageRenderTime 107ms CodeModel.GetById 19ms app.highlight 75ms RepoModel.GetById 2ms app.codeStats 0ms

/drivers/input/mouse/psmouse-base.c

http://github.com/mirrors/linux
C | 2088 lines | 1465 code | 337 blank | 286 comment | 280 complexity | cffc29317337b7d08f5d8fc24562ebed MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * PS/2 mouse driver
   4 *
   5 * Copyright (c) 1999-2002 Vojtech Pavlik
   6 * Copyright (c) 2003-2004 Dmitry Torokhov
   7 */
   8
   9
  10#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
  11#define psmouse_fmt(fmt)	fmt
  12
  13#include <linux/bitops.h>
  14#include <linux/delay.h>
  15#include <linux/module.h>
  16#include <linux/slab.h>
  17#include <linux/interrupt.h>
  18#include <linux/input.h>
  19#include <linux/serio.h>
  20#include <linux/init.h>
  21#include <linux/libps2.h>
  22#include <linux/mutex.h>
  23#include <linux/types.h>
  24
  25#include "psmouse.h"
  26#include "synaptics.h"
  27#include "logips2pp.h"
  28#include "alps.h"
  29#include "hgpk.h"
  30#include "lifebook.h"
  31#include "trackpoint.h"
  32#include "touchkit_ps2.h"
  33#include "elantech.h"
  34#include "sentelic.h"
  35#include "cypress_ps2.h"
  36#include "focaltech.h"
  37#include "vmmouse.h"
  38#include "byd.h"
  39
  40#define DRIVER_DESC	"PS/2 mouse driver"
  41
  42MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  43MODULE_DESCRIPTION(DRIVER_DESC);
  44MODULE_LICENSE("GPL");
  45
  46static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
  47static int psmouse_set_maxproto(const char *val, const struct kernel_param *);
  48static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp);
  49static const struct kernel_param_ops param_ops_proto_abbrev = {
  50	.set = psmouse_set_maxproto,
  51	.get = psmouse_get_maxproto,
  52};
  53#define param_check_proto_abbrev(name, p)	__param_check(name, p, unsigned int)
  54module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
  55MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
  56
  57static unsigned int psmouse_resolution = 200;
  58module_param_named(resolution, psmouse_resolution, uint, 0644);
  59MODULE_PARM_DESC(resolution, "Resolution, in dpi.");
  60
  61static unsigned int psmouse_rate = 100;
  62module_param_named(rate, psmouse_rate, uint, 0644);
  63MODULE_PARM_DESC(rate, "Report rate, in reports per second.");
  64
  65static bool psmouse_smartscroll = true;
  66module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);
  67MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
  68
  69static bool psmouse_a4tech_2wheels;
  70module_param_named(a4tech_workaround, psmouse_a4tech_2wheels, bool, 0644);
  71MODULE_PARM_DESC(a4tech_workaround, "A4Tech second scroll wheel workaround, 1 = enabled, 0 = disabled (default).");
  72
  73static unsigned int psmouse_resetafter = 5;
  74module_param_named(resetafter, psmouse_resetafter, uint, 0644);
  75MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
  76
  77static unsigned int psmouse_resync_time;
  78module_param_named(resync_time, psmouse_resync_time, uint, 0644);
  79MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never).");
  80
  81PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO,
  82			NULL,
  83			psmouse_attr_show_protocol, psmouse_attr_set_protocol);
  84PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO,
  85			(void *) offsetof(struct psmouse, rate),
  86			psmouse_show_int_attr, psmouse_attr_set_rate);
  87PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO,
  88			(void *) offsetof(struct psmouse, resolution),
  89			psmouse_show_int_attr, psmouse_attr_set_resolution);
  90PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO,
  91			(void *) offsetof(struct psmouse, resetafter),
  92			psmouse_show_int_attr, psmouse_set_int_attr);
  93PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO,
  94			(void *) offsetof(struct psmouse, resync_time),
  95			psmouse_show_int_attr, psmouse_set_int_attr);
  96
  97static struct attribute *psmouse_attributes[] = {
  98	&psmouse_attr_protocol.dattr.attr,
  99	&psmouse_attr_rate.dattr.attr,
 100	&psmouse_attr_resolution.dattr.attr,
 101	&psmouse_attr_resetafter.dattr.attr,
 102	&psmouse_attr_resync_time.dattr.attr,
 103	NULL
 104};
 105
 106static const struct attribute_group psmouse_attribute_group = {
 107	.attrs	= psmouse_attributes,
 108};
 109
 110/*
 111 * psmouse_mutex protects all operations changing state of mouse
 112 * (connecting, disconnecting, changing rate or resolution via
 113 * sysfs). We could use a per-device semaphore but since there
 114 * rarely more than one PS/2 mouse connected and since semaphore
 115 * is taken in "slow" paths it is not worth it.
 116 */
 117static DEFINE_MUTEX(psmouse_mutex);
 118
 119static struct workqueue_struct *kpsmoused_wq;
 120
 121void psmouse_report_standard_buttons(struct input_dev *dev, u8 buttons)
 122{
 123	input_report_key(dev, BTN_LEFT,   buttons & BIT(0));
 124	input_report_key(dev, BTN_MIDDLE, buttons & BIT(2));
 125	input_report_key(dev, BTN_RIGHT,  buttons & BIT(1));
 126}
 127
 128void psmouse_report_standard_motion(struct input_dev *dev, u8 *packet)
 129{
 130	int x, y;
 131
 132	x = packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0;
 133	y = packet[2] ? packet[2] - ((packet[0] << 3) & 0x100) : 0;
 134
 135	input_report_rel(dev, REL_X, x);
 136	input_report_rel(dev, REL_Y, -y);
 137}
 138
 139void psmouse_report_standard_packet(struct input_dev *dev, u8 *packet)
 140{
 141	psmouse_report_standard_buttons(dev, packet[0]);
 142	psmouse_report_standard_motion(dev, packet);
 143}
 144
 145/*
 146 * psmouse_process_byte() analyzes the PS/2 data stream and reports
 147 * relevant events to the input module once full packet has arrived.
 148 */
 149psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse)
 150{
 151	struct input_dev *dev = psmouse->dev;
 152	u8 *packet = psmouse->packet;
 153	int wheel;
 154
 155	if (psmouse->pktcnt < psmouse->pktsize)
 156		return PSMOUSE_GOOD_DATA;
 157
 158	/* Full packet accumulated, process it */
 159
 160	switch (psmouse->protocol->type) {
 161	case PSMOUSE_IMPS:
 162		/* IntelliMouse has scroll wheel */
 163		input_report_rel(dev, REL_WHEEL, -(s8) packet[3]);
 164		break;
 165
 166	case PSMOUSE_IMEX:
 167		/* Scroll wheel and buttons on IntelliMouse Explorer */
 168		switch (packet[3] & 0xC0) {
 169		case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */
 170			input_report_rel(dev, REL_WHEEL,
 171					 -sign_extend32(packet[3], 5));
 172			break;
 173		case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */
 174			input_report_rel(dev, REL_HWHEEL,
 175					 -sign_extend32(packet[3], 5));
 176			break;
 177		case 0x00:
 178		case 0xC0:
 179			wheel = sign_extend32(packet[3], 3);
 180
 181			/*
 182			 * Some A4Tech mice have two scroll wheels, with first
 183			 * one reporting +/-1 in the lower nibble, and second
 184			 * one reporting +/-2.
 185			 */
 186			if (psmouse_a4tech_2wheels && abs(wheel) > 1)
 187				input_report_rel(dev, REL_HWHEEL, wheel / 2);
 188			else
 189				input_report_rel(dev, REL_WHEEL, -wheel);
 190
 191			input_report_key(dev, BTN_SIDE,  packet[3] & BIT(4));
 192			input_report_key(dev, BTN_EXTRA, packet[3] & BIT(5));
 193			break;
 194		}
 195		break;
 196
 197	case PSMOUSE_GENPS:
 198		/* Report scroll buttons on NetMice */
 199		input_report_rel(dev, REL_WHEEL, -(s8) packet[3]);
 200
 201		/* Extra buttons on Genius NewNet 3D */
 202		input_report_key(dev, BTN_SIDE,  packet[0] & BIT(6));
 203		input_report_key(dev, BTN_EXTRA, packet[0] & BIT(7));
 204		break;
 205
 206	case PSMOUSE_THINKPS:
 207		/* Extra button on ThinkingMouse */
 208		input_report_key(dev, BTN_EXTRA, packet[0] & BIT(3));
 209
 210		/*
 211		 * Without this bit of weirdness moving up gives wildly
 212		 * high Y changes.
 213		 */
 214		packet[1] |= (packet[0] & 0x40) << 1;
 215		break;
 216
 217	case PSMOUSE_CORTRON:
 218		/*
 219		 * Cortron PS2 Trackball reports SIDE button in the
 220		 * 4th bit of the first byte.
 221		 */
 222		input_report_key(dev, BTN_SIDE, packet[0] & BIT(3));
 223		packet[0] |= BIT(3);
 224		break;
 225
 226	default:
 227		break;
 228	}
 229
 230	/* Generic PS/2 Mouse */
 231	packet[0] |= psmouse->extra_buttons;
 232	psmouse_report_standard_packet(dev, packet);
 233
 234	input_sync(dev);
 235
 236	return PSMOUSE_FULL_PACKET;
 237}
 238
 239void psmouse_queue_work(struct psmouse *psmouse, struct delayed_work *work,
 240		unsigned long delay)
 241{
 242	queue_delayed_work(kpsmoused_wq, work, delay);
 243}
 244
 245/*
 246 * __psmouse_set_state() sets new psmouse state and resets all flags.
 247 */
 248static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
 249{
 250	psmouse->state = new_state;
 251	psmouse->pktcnt = psmouse->out_of_sync_cnt = 0;
 252	psmouse->ps2dev.flags = 0;
 253	psmouse->last = jiffies;
 254}
 255
 256/*
 257 * psmouse_set_state() sets new psmouse state and resets all flags and
 258 * counters while holding serio lock so fighting with interrupt handler
 259 * is not a concern.
 260 */
 261void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
 262{
 263	serio_pause_rx(psmouse->ps2dev.serio);
 264	__psmouse_set_state(psmouse, new_state);
 265	serio_continue_rx(psmouse->ps2dev.serio);
 266}
 267
 268/*
 269 * psmouse_handle_byte() processes one byte of the input data stream
 270 * by calling corresponding protocol handler.
 271 */
 272static int psmouse_handle_byte(struct psmouse *psmouse)
 273{
 274	psmouse_ret_t rc = psmouse->protocol_handler(psmouse);
 275
 276	switch (rc) {
 277	case PSMOUSE_BAD_DATA:
 278		if (psmouse->state == PSMOUSE_ACTIVATED) {
 279			psmouse_warn(psmouse,
 280				     "%s at %s lost sync at byte %d\n",
 281				     psmouse->name, psmouse->phys,
 282				     psmouse->pktcnt);
 283			if (++psmouse->out_of_sync_cnt == psmouse->resetafter) {
 284				__psmouse_set_state(psmouse, PSMOUSE_IGNORE);
 285				psmouse_notice(psmouse,
 286						"issuing reconnect request\n");
 287				serio_reconnect(psmouse->ps2dev.serio);
 288				return -EIO;
 289			}
 290		}
 291		psmouse->pktcnt = 0;
 292		break;
 293
 294	case PSMOUSE_FULL_PACKET:
 295		psmouse->pktcnt = 0;
 296		if (psmouse->out_of_sync_cnt) {
 297			psmouse->out_of_sync_cnt = 0;
 298			psmouse_notice(psmouse,
 299					"%s at %s - driver resynced.\n",
 300					psmouse->name, psmouse->phys);
 301		}
 302		break;
 303
 304	case PSMOUSE_GOOD_DATA:
 305		break;
 306	}
 307	return 0;
 308}
 309
 310static void psmouse_handle_oob_data(struct psmouse *psmouse, u8 data)
 311{
 312	switch (psmouse->oob_data_type) {
 313	case PSMOUSE_OOB_NONE:
 314		psmouse->oob_data_type = data;
 315		break;
 316
 317	case PSMOUSE_OOB_EXTRA_BTNS:
 318		psmouse_report_standard_buttons(psmouse->dev, data);
 319		input_sync(psmouse->dev);
 320
 321		psmouse->extra_buttons = data;
 322		psmouse->oob_data_type = PSMOUSE_OOB_NONE;
 323		break;
 324
 325	default:
 326		psmouse_warn(psmouse,
 327			     "unknown OOB_DATA type: 0x%02x\n",
 328			     psmouse->oob_data_type);
 329		psmouse->oob_data_type = PSMOUSE_OOB_NONE;
 330		break;
 331	}
 332}
 333
 334/*
 335 * psmouse_interrupt() handles incoming characters, either passing them
 336 * for normal processing or gathering them as command response.
 337 */
 338static irqreturn_t psmouse_interrupt(struct serio *serio,
 339				     u8 data, unsigned int flags)
 340{
 341	struct psmouse *psmouse = serio_get_drvdata(serio);
 342
 343	if (psmouse->state == PSMOUSE_IGNORE)
 344		goto out;
 345
 346	if (unlikely((flags & SERIO_TIMEOUT) ||
 347		     ((flags & SERIO_PARITY) &&
 348		      !psmouse->protocol->ignore_parity))) {
 349
 350		if (psmouse->state == PSMOUSE_ACTIVATED)
 351			psmouse_warn(psmouse,
 352				     "bad data from KBC -%s%s\n",
 353				     flags & SERIO_TIMEOUT ? " timeout" : "",
 354				     flags & SERIO_PARITY ? " bad parity" : "");
 355		ps2_cmd_aborted(&psmouse->ps2dev);
 356		goto out;
 357	}
 358
 359	if (flags & SERIO_OOB_DATA) {
 360		psmouse_handle_oob_data(psmouse, data);
 361		goto out;
 362	}
 363
 364	if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_ACK))
 365		if  (ps2_handle_ack(&psmouse->ps2dev, data))
 366			goto out;
 367
 368	if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_CMD))
 369		if  (ps2_handle_response(&psmouse->ps2dev, data))
 370			goto out;
 371
 372	pm_wakeup_event(&serio->dev, 0);
 373
 374	if (psmouse->state <= PSMOUSE_RESYNCING)
 375		goto out;
 376
 377	if (psmouse->state == PSMOUSE_ACTIVATED &&
 378	    psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
 379		psmouse_info(psmouse, "%s at %s lost synchronization, throwing %d bytes away.\n",
 380			     psmouse->name, psmouse->phys, psmouse->pktcnt);
 381		psmouse->badbyte = psmouse->packet[0];
 382		__psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
 383		psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
 384		goto out;
 385	}
 386
 387	psmouse->packet[psmouse->pktcnt++] = data;
 388
 389	/* Check if this is a new device announcement (0xAA 0x00) */
 390	if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
 391		if (psmouse->pktcnt == 1) {
 392			psmouse->last = jiffies;
 393			goto out;
 394		}
 395
 396		if (psmouse->packet[1] == PSMOUSE_RET_ID ||
 397		    (psmouse->protocol->type == PSMOUSE_HGPK &&
 398		     psmouse->packet[1] == PSMOUSE_RET_BAT)) {
 399			__psmouse_set_state(psmouse, PSMOUSE_IGNORE);
 400			serio_reconnect(serio);
 401			goto out;
 402		}
 403
 404		/* Not a new device, try processing first byte normally */
 405		psmouse->pktcnt = 1;
 406		if (psmouse_handle_byte(psmouse))
 407			goto out;
 408
 409		psmouse->packet[psmouse->pktcnt++] = data;
 410	}
 411
 412	/*
 413	 * See if we need to force resync because mouse was idle for
 414	 * too long.
 415	 */
 416	if (psmouse->state == PSMOUSE_ACTIVATED &&
 417	    psmouse->pktcnt == 1 && psmouse->resync_time &&
 418	    time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {
 419		psmouse->badbyte = psmouse->packet[0];
 420		__psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
 421		psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
 422		goto out;
 423	}
 424
 425	psmouse->last = jiffies;
 426	psmouse_handle_byte(psmouse);
 427
 428 out:
 429	return IRQ_HANDLED;
 430}
 431
 432/*
 433 * psmouse_reset() resets the mouse into power-on state.
 434 */
 435int psmouse_reset(struct psmouse *psmouse)
 436{
 437	u8 param[2];
 438	int error;
 439
 440	error = ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT);
 441	if (error)
 442		return error;
 443
 444	if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)
 445		return -EIO;
 446
 447	return 0;
 448}
 449
 450/*
 451 * Here we set the mouse resolution.
 452 */
 453void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution)
 454{
 455	static const u8 params[] = { 0, 1, 2, 2, 3 };
 456	u8 p;
 457
 458	if (resolution == 0 || resolution > 200)
 459		resolution = 200;
 460
 461	p = params[resolution / 50];
 462	ps2_command(&psmouse->ps2dev, &p, PSMOUSE_CMD_SETRES);
 463	psmouse->resolution = 25 << p;
 464}
 465
 466/*
 467 * Here we set the mouse report rate.
 468 */
 469static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate)
 470{
 471	static const u8 rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
 472	u8 r;
 473	int i = 0;
 474
 475	while (rates[i] > rate)
 476		i++;
 477	r = rates[i];
 478	ps2_command(&psmouse->ps2dev, &r, PSMOUSE_CMD_SETRATE);
 479	psmouse->rate = r;
 480}
 481
 482/*
 483 * Here we set the mouse scaling.
 484 */
 485static void psmouse_set_scale(struct psmouse *psmouse, enum psmouse_scale scale)
 486{
 487	ps2_command(&psmouse->ps2dev, NULL,
 488		    scale == PSMOUSE_SCALE21 ? PSMOUSE_CMD_SETSCALE21 :
 489					       PSMOUSE_CMD_SETSCALE11);
 490}
 491
 492/*
 493 * psmouse_poll() - default poll handler. Everyone except for ALPS uses it.
 494 */
 495static int psmouse_poll(struct psmouse *psmouse)
 496{
 497	return ps2_command(&psmouse->ps2dev, psmouse->packet,
 498			   PSMOUSE_CMD_POLL | (psmouse->pktsize << 8));
 499}
 500
 501static bool psmouse_check_pnp_id(const char *id, const char * const ids[])
 502{
 503	int i;
 504
 505	for (i = 0; ids[i]; i++)
 506		if (!strcasecmp(id, ids[i]))
 507			return true;
 508
 509	return false;
 510}
 511
 512/*
 513 * psmouse_matches_pnp_id - check if psmouse matches one of the passed in ids.
 514 */
 515bool psmouse_matches_pnp_id(struct psmouse *psmouse, const char * const ids[])
 516{
 517	struct serio *serio = psmouse->ps2dev.serio;
 518	char *p, *fw_id_copy, *save_ptr;
 519	bool found = false;
 520
 521	if (strncmp(serio->firmware_id, "PNP: ", 5))
 522		return false;
 523
 524	fw_id_copy = kstrndup(&serio->firmware_id[5],
 525			      sizeof(serio->firmware_id) - 5,
 526			      GFP_KERNEL);
 527	if (!fw_id_copy)
 528		return false;
 529
 530	save_ptr = fw_id_copy;
 531	while ((p = strsep(&fw_id_copy, " ")) != NULL) {
 532		if (psmouse_check_pnp_id(p, ids)) {
 533			found = true;
 534			break;
 535		}
 536	}
 537
 538	kfree(save_ptr);
 539	return found;
 540}
 541
 542/*
 543 * Genius NetMouse magic init.
 544 */
 545static int genius_detect(struct psmouse *psmouse, bool set_properties)
 546{
 547	struct ps2dev *ps2dev = &psmouse->ps2dev;
 548	u8 param[4];
 549
 550	param[0] = 3;
 551	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 552	ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
 553	ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
 554	ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
 555	ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
 556
 557	if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55)
 558		return -ENODEV;
 559
 560	if (set_properties) {
 561		__set_bit(BTN_MIDDLE, psmouse->dev->keybit);
 562		__set_bit(BTN_EXTRA, psmouse->dev->keybit);
 563		__set_bit(BTN_SIDE, psmouse->dev->keybit);
 564		__set_bit(REL_WHEEL, psmouse->dev->relbit);
 565
 566		psmouse->vendor = "Genius";
 567		psmouse->name = "Mouse";
 568		psmouse->pktsize = 4;
 569	}
 570
 571	return 0;
 572}
 573
 574/*
 575 * IntelliMouse magic init.
 576 */
 577static int intellimouse_detect(struct psmouse *psmouse, bool set_properties)
 578{
 579	struct ps2dev *ps2dev = &psmouse->ps2dev;
 580	u8 param[2];
 581
 582	param[0] = 200;
 583	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 584	param[0] = 100;
 585	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 586	param[0] =  80;
 587	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 588	ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
 589
 590	if (param[0] != 3)
 591		return -ENODEV;
 592
 593	if (set_properties) {
 594		__set_bit(BTN_MIDDLE, psmouse->dev->keybit);
 595		__set_bit(REL_WHEEL, psmouse->dev->relbit);
 596
 597		if (!psmouse->vendor)
 598			psmouse->vendor = "Generic";
 599		if (!psmouse->name)
 600			psmouse->name = "Wheel Mouse";
 601		psmouse->pktsize = 4;
 602	}
 603
 604	return 0;
 605}
 606
 607/*
 608 * Try IntelliMouse/Explorer magic init.
 609 */
 610static int im_explorer_detect(struct psmouse *psmouse, bool set_properties)
 611{
 612	struct ps2dev *ps2dev = &psmouse->ps2dev;
 613	u8 param[2];
 614
 615	intellimouse_detect(psmouse, 0);
 616
 617	param[0] = 200;
 618	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 619	param[0] = 200;
 620	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 621	param[0] =  80;
 622	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 623	ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
 624
 625	if (param[0] != 4)
 626		return -ENODEV;
 627
 628	/* Magic to enable horizontal scrolling on IntelliMouse 4.0 */
 629	param[0] = 200;
 630	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 631	param[0] =  80;
 632	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 633	param[0] =  40;
 634	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 635
 636	if (set_properties) {
 637		__set_bit(BTN_MIDDLE, psmouse->dev->keybit);
 638		__set_bit(REL_WHEEL, psmouse->dev->relbit);
 639		__set_bit(REL_HWHEEL, psmouse->dev->relbit);
 640		__set_bit(BTN_SIDE, psmouse->dev->keybit);
 641		__set_bit(BTN_EXTRA, psmouse->dev->keybit);
 642
 643		if (!psmouse->vendor)
 644			psmouse->vendor = "Generic";
 645		if (!psmouse->name)
 646			psmouse->name = "Explorer Mouse";
 647		psmouse->pktsize = 4;
 648	}
 649
 650	return 0;
 651}
 652
 653/*
 654 * Kensington ThinkingMouse / ExpertMouse magic init.
 655 */
 656static int thinking_detect(struct psmouse *psmouse, bool set_properties)
 657{
 658	struct ps2dev *ps2dev = &psmouse->ps2dev;
 659	u8 param[2];
 660	static const u8 seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20 };
 661	int i;
 662
 663	param[0] = 10;
 664	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 665	param[0] = 0;
 666	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 667	for (i = 0; i < ARRAY_SIZE(seq); i++) {
 668		param[0] = seq[i];
 669		ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 670	}
 671	ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
 672
 673	if (param[0] != 2)
 674		return -ENODEV;
 675
 676	if (set_properties) {
 677		__set_bit(BTN_MIDDLE, psmouse->dev->keybit);
 678		__set_bit(BTN_EXTRA, psmouse->dev->keybit);
 679
 680		psmouse->vendor = "Kensington";
 681		psmouse->name = "ThinkingMouse";
 682	}
 683
 684	return 0;
 685}
 686
 687/*
 688 * Bare PS/2 protocol "detection". Always succeeds.
 689 */
 690static int ps2bare_detect(struct psmouse *psmouse, bool set_properties)
 691{
 692	if (set_properties) {
 693		if (!psmouse->vendor)
 694			psmouse->vendor = "Generic";
 695		if (!psmouse->name)
 696			psmouse->name = "Mouse";
 697
 698		/*
 699		 * We have no way of figuring true number of buttons so let's
 700		 * assume that the device has 3.
 701		 */
 702		input_set_capability(psmouse->dev, EV_KEY, BTN_MIDDLE);
 703	}
 704
 705	return 0;
 706}
 707
 708/*
 709 * Cortron PS/2 protocol detection. There's no special way to detect it, so it
 710 * must be forced by sysfs protocol writing.
 711 */
 712static int cortron_detect(struct psmouse *psmouse, bool set_properties)
 713{
 714	if (set_properties) {
 715		psmouse->vendor = "Cortron";
 716		psmouse->name = "PS/2 Trackball";
 717
 718		__set_bit(BTN_MIDDLE, psmouse->dev->keybit);
 719		__set_bit(BTN_SIDE, psmouse->dev->keybit);
 720	}
 721
 722	return 0;
 723}
 724
 725static const struct psmouse_protocol psmouse_protocols[] = {
 726	{
 727		.type		= PSMOUSE_PS2,
 728		.name		= "PS/2",
 729		.alias		= "bare",
 730		.maxproto	= true,
 731		.ignore_parity	= true,
 732		.detect		= ps2bare_detect,
 733		.try_passthru	= true,
 734	},
 735#ifdef CONFIG_MOUSE_PS2_LOGIPS2PP
 736	{
 737		.type		= PSMOUSE_PS2PP,
 738		.name		= "PS2++",
 739		.alias		= "logitech",
 740		.detect		= ps2pp_detect,
 741	},
 742#endif
 743	{
 744		.type		= PSMOUSE_THINKPS,
 745		.name		= "ThinkPS/2",
 746		.alias		= "thinkps",
 747		.detect		= thinking_detect,
 748	},
 749#ifdef CONFIG_MOUSE_PS2_CYPRESS
 750	{
 751		.type		= PSMOUSE_CYPRESS,
 752		.name		= "CyPS/2",
 753		.alias		= "cypress",
 754		.detect		= cypress_detect,
 755		.init		= cypress_init,
 756	},
 757#endif
 758	{
 759		.type		= PSMOUSE_GENPS,
 760		.name		= "GenPS/2",
 761		.alias		= "genius",
 762		.detect		= genius_detect,
 763	},
 764	{
 765		.type		= PSMOUSE_IMPS,
 766		.name		= "ImPS/2",
 767		.alias		= "imps",
 768		.maxproto	= true,
 769		.ignore_parity	= true,
 770		.detect		= intellimouse_detect,
 771		.try_passthru	= true,
 772	},
 773	{
 774		.type		= PSMOUSE_IMEX,
 775		.name		= "ImExPS/2",
 776		.alias		= "exps",
 777		.maxproto	= true,
 778		.ignore_parity	= true,
 779		.detect		= im_explorer_detect,
 780		.try_passthru	= true,
 781	},
 782#ifdef CONFIG_MOUSE_PS2_SYNAPTICS
 783	{
 784		.type		= PSMOUSE_SYNAPTICS,
 785		.name		= "SynPS/2",
 786		.alias		= "synaptics",
 787		.detect		= synaptics_detect,
 788		.init		= synaptics_init_absolute,
 789	},
 790	{
 791		.type		= PSMOUSE_SYNAPTICS_RELATIVE,
 792		.name		= "SynRelPS/2",
 793		.alias		= "synaptics-relative",
 794		.detect		= synaptics_detect,
 795		.init		= synaptics_init_relative,
 796	},
 797#endif
 798#ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS
 799	{
 800		.type		= PSMOUSE_SYNAPTICS_SMBUS,
 801		.name		= "SynSMBus",
 802		.alias		= "synaptics-smbus",
 803		.detect		= synaptics_detect,
 804		.init		= synaptics_init_smbus,
 805		.smbus_companion = true,
 806	},
 807#endif
 808#ifdef CONFIG_MOUSE_PS2_ALPS
 809	{
 810		.type		= PSMOUSE_ALPS,
 811		.name		= "AlpsPS/2",
 812		.alias		= "alps",
 813		.detect		= alps_detect,
 814		.init		= alps_init,
 815	},
 816#endif
 817#ifdef CONFIG_MOUSE_PS2_LIFEBOOK
 818	{
 819		.type		= PSMOUSE_LIFEBOOK,
 820		.name		= "LBPS/2",
 821		.alias		= "lifebook",
 822		.detect		= lifebook_detect,
 823		.init		= lifebook_init,
 824	},
 825#endif
 826#ifdef CONFIG_MOUSE_PS2_TRACKPOINT
 827	{
 828		.type		= PSMOUSE_TRACKPOINT,
 829		.name		= "TPPS/2",
 830		.alias		= "trackpoint",
 831		.detect		= trackpoint_detect,
 832		.try_passthru	= true,
 833	},
 834#endif
 835#ifdef CONFIG_MOUSE_PS2_TOUCHKIT
 836	{
 837		.type		= PSMOUSE_TOUCHKIT_PS2,
 838		.name		= "touchkitPS/2",
 839		.alias		= "touchkit",
 840		.detect		= touchkit_ps2_detect,
 841	},
 842#endif
 843#ifdef CONFIG_MOUSE_PS2_OLPC
 844	{
 845		.type		= PSMOUSE_HGPK,
 846		.name		= "OLPC HGPK",
 847		.alias		= "hgpk",
 848		.detect		= hgpk_detect,
 849	},
 850#endif
 851#ifdef CONFIG_MOUSE_PS2_ELANTECH
 852	{
 853		.type		= PSMOUSE_ELANTECH,
 854		.name		= "ETPS/2",
 855		.alias		= "elantech",
 856		.detect		= elantech_detect,
 857		.init		= elantech_init_ps2,
 858	},
 859#endif
 860#ifdef CONFIG_MOUSE_PS2_ELANTECH_SMBUS
 861	{
 862		.type		= PSMOUSE_ELANTECH_SMBUS,
 863		.name		= "ETSMBus",
 864		.alias		= "elantech-smbus",
 865		.detect		= elantech_detect,
 866		.init		= elantech_init_smbus,
 867		.smbus_companion = true,
 868	},
 869#endif
 870#ifdef CONFIG_MOUSE_PS2_SENTELIC
 871	{
 872		.type		= PSMOUSE_FSP,
 873		.name		= "FSPPS/2",
 874		.alias		= "fsp",
 875		.detect		= fsp_detect,
 876		.init		= fsp_init,
 877	},
 878#endif
 879	{
 880		.type		= PSMOUSE_CORTRON,
 881		.name		= "CortronPS/2",
 882		.alias		= "cortps",
 883		.detect		= cortron_detect,
 884	},
 885#ifdef CONFIG_MOUSE_PS2_FOCALTECH
 886	{
 887		.type		= PSMOUSE_FOCALTECH,
 888		.name		= "FocalTechPS/2",
 889		.alias		= "focaltech",
 890		.detect		= focaltech_detect,
 891		.init		= focaltech_init,
 892	},
 893#endif
 894#ifdef CONFIG_MOUSE_PS2_VMMOUSE
 895	{
 896		.type		= PSMOUSE_VMMOUSE,
 897		.name		= VMMOUSE_PSNAME,
 898		.alias		= "vmmouse",
 899		.detect		= vmmouse_detect,
 900		.init		= vmmouse_init,
 901	},
 902#endif
 903#ifdef CONFIG_MOUSE_PS2_BYD
 904	{
 905		.type		= PSMOUSE_BYD,
 906		.name		= "BYDPS/2",
 907		.alias		= "byd",
 908		.detect		= byd_detect,
 909		.init		= byd_init,
 910	},
 911#endif
 912	{
 913		.type		= PSMOUSE_AUTO,
 914		.name		= "auto",
 915		.alias		= "any",
 916		.maxproto	= true,
 917	},
 918};
 919
 920static const struct psmouse_protocol *__psmouse_protocol_by_type(enum psmouse_type type)
 921{
 922	int i;
 923
 924	for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++)
 925		if (psmouse_protocols[i].type == type)
 926			return &psmouse_protocols[i];
 927
 928	return NULL;
 929}
 930
 931static const struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type)
 932{
 933	const struct psmouse_protocol *proto;
 934
 935	proto = __psmouse_protocol_by_type(type);
 936	if (proto)
 937		return proto;
 938
 939	WARN_ON(1);
 940	return &psmouse_protocols[0];
 941}
 942
 943static const struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len)
 944{
 945	const struct psmouse_protocol *p;
 946	int i;
 947
 948	for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) {
 949		p = &psmouse_protocols[i];
 950
 951		if ((strlen(p->name) == len && !strncmp(p->name, name, len)) ||
 952		    (strlen(p->alias) == len && !strncmp(p->alias, name, len)))
 953			return &psmouse_protocols[i];
 954	}
 955
 956	return NULL;
 957}
 958
 959/*
 960 * Apply default settings to the psmouse structure. Most of them will
 961 * be overridden by individual protocol initialization routines.
 962 */
 963static void psmouse_apply_defaults(struct psmouse *psmouse)
 964{
 965	struct input_dev *input_dev = psmouse->dev;
 966
 967	bitmap_zero(input_dev->evbit, EV_CNT);
 968	bitmap_zero(input_dev->keybit, KEY_CNT);
 969	bitmap_zero(input_dev->relbit, REL_CNT);
 970	bitmap_zero(input_dev->absbit, ABS_CNT);
 971	bitmap_zero(input_dev->mscbit, MSC_CNT);
 972
 973	input_set_capability(input_dev, EV_KEY, BTN_LEFT);
 974	input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
 975
 976	input_set_capability(input_dev, EV_REL, REL_X);
 977	input_set_capability(input_dev, EV_REL, REL_Y);
 978
 979	__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
 980
 981	psmouse->protocol = &psmouse_protocols[0];
 982
 983	psmouse->set_rate = psmouse_set_rate;
 984	psmouse->set_resolution = psmouse_set_resolution;
 985	psmouse->set_scale = psmouse_set_scale;
 986	psmouse->poll = psmouse_poll;
 987	psmouse->protocol_handler = psmouse_process_byte;
 988	psmouse->pktsize = 3;
 989	psmouse->reconnect = NULL;
 990	psmouse->fast_reconnect = NULL;
 991	psmouse->disconnect = NULL;
 992	psmouse->cleanup = NULL;
 993	psmouse->pt_activate = NULL;
 994	psmouse->pt_deactivate = NULL;
 995}
 996
 997static bool psmouse_do_detect(int (*detect)(struct psmouse *, bool),
 998			      struct psmouse *psmouse, bool allow_passthrough,
 999			      bool set_properties)
1000{
1001	if (psmouse->ps2dev.serio->id.type == SERIO_PS_PSTHRU &&
1002	    !allow_passthrough) {
1003		return false;
1004	}
1005
1006	if (set_properties)
1007		psmouse_apply_defaults(psmouse);
1008
1009	return detect(psmouse, set_properties) == 0;
1010}
1011
1012static bool psmouse_try_protocol(struct psmouse *psmouse,
1013				 enum psmouse_type type,
1014				 unsigned int *max_proto,
1015				 bool set_properties, bool init_allowed)
1016{
1017	const struct psmouse_protocol *proto;
1018
1019	proto = __psmouse_protocol_by_type(type);
1020	if (!proto)
1021		return false;
1022
1023	if (!psmouse_do_detect(proto->detect, psmouse, proto->try_passthru,
1024			       set_properties))
1025		return false;
1026
1027	if (set_properties && proto->init && init_allowed) {
1028		if (proto->init(psmouse) != 0) {
1029			/*
1030			 * We detected device, but init failed. Adjust
1031			 * max_proto so we only try standard protocols.
1032			 */
1033			if (*max_proto > PSMOUSE_IMEX)
1034				*max_proto = PSMOUSE_IMEX;
1035
1036			return false;
1037		}
1038	}
1039
1040	return true;
1041}
1042
1043/*
1044 * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
1045 * the mouse may have.
1046 */
1047static int psmouse_extensions(struct psmouse *psmouse,
1048			      unsigned int max_proto, bool set_properties)
1049{
1050	bool synaptics_hardware = false;
1051	int ret;
1052
1053	/*
1054	 * Always check for focaltech, this is safe as it uses pnp-id
1055	 * matching.
1056	 */
1057	if (psmouse_do_detect(focaltech_detect,
1058			      psmouse, false, set_properties)) {
1059		if (max_proto > PSMOUSE_IMEX &&
1060		    IS_ENABLED(CONFIG_MOUSE_PS2_FOCALTECH) &&
1061		    (!set_properties || focaltech_init(psmouse) == 0)) {
1062			return PSMOUSE_FOCALTECH;
1063		}
1064		/*
1065		 * Restrict psmouse_max_proto so that psmouse_initialize()
1066		 * does not try to reset rate and resolution, because even
1067		 * that upsets the device.
1068		 * This also causes us to basically fall through to basic
1069		 * protocol detection, where we fully reset the mouse,
1070		 * and set it up as bare PS/2 protocol device.
1071		 */
1072		psmouse_max_proto = max_proto = PSMOUSE_PS2;
1073	}
1074
1075	/*
1076	 * We always check for LifeBook because it does not disturb mouse
1077	 * (it only checks DMI information).
1078	 */
1079	if (psmouse_try_protocol(psmouse, PSMOUSE_LIFEBOOK, &max_proto,
1080				 set_properties, max_proto > PSMOUSE_IMEX))
1081		return PSMOUSE_LIFEBOOK;
1082
1083	if (psmouse_try_protocol(psmouse, PSMOUSE_VMMOUSE, &max_proto,
1084				 set_properties, max_proto > PSMOUSE_IMEX))
1085		return PSMOUSE_VMMOUSE;
1086
1087	/*
1088	 * Try Kensington ThinkingMouse (we try first, because Synaptics
1089	 * probe upsets the ThinkingMouse).
1090	 */
1091	if (max_proto > PSMOUSE_IMEX &&
1092	    psmouse_try_protocol(psmouse, PSMOUSE_THINKPS, &max_proto,
1093				 set_properties, true)) {
1094		return PSMOUSE_THINKPS;
1095	}
1096
1097	/*
1098	 * Try Synaptics TouchPad. Note that probing is done even if
1099	 * Synaptics protocol support is disabled in config - we need to
1100	 * know if it is Synaptics so we can reset it properly after
1101	 * probing for IntelliMouse.
1102	 */
1103	if (max_proto > PSMOUSE_PS2 &&
1104	    psmouse_do_detect(synaptics_detect,
1105			      psmouse, false, set_properties)) {
1106		synaptics_hardware = true;
1107
1108		if (max_proto > PSMOUSE_IMEX) {
1109			/*
1110			 * Try activating protocol, but check if support is
1111			 * enabled first, since we try detecting Synaptics
1112			 * even when protocol is disabled.
1113			 */
1114			if (IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS) ||
1115			    IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)) {
1116				if (!set_properties)
1117					return PSMOUSE_SYNAPTICS;
1118
1119				ret = synaptics_init(psmouse);
1120				if (ret >= 0)
1121					return ret;
1122			}
1123
1124			/*
1125			 * Some Synaptics touchpads can emulate extended
1126			 * protocols (like IMPS/2).  Unfortunately
1127			 * Logitech/Genius probes confuse some firmware
1128			 * versions so we'll have to skip them.
1129			 */
1130			max_proto = PSMOUSE_IMEX;
1131		}
1132
1133		/*
1134		 * Make sure that touchpad is in relative mode, gestures
1135		 * (taps) are enabled.
1136		 */
1137		synaptics_reset(psmouse);
1138	}
1139
1140	/*
1141	 * Try Cypress Trackpad. We must try it before Finger Sensing Pad
1142	 * because Finger Sensing Pad probe upsets some modules of Cypress
1143	 * Trackpads.
1144	 */
1145	if (max_proto > PSMOUSE_IMEX &&
1146	    psmouse_try_protocol(psmouse, PSMOUSE_CYPRESS, &max_proto,
1147				 set_properties, true)) {
1148		return PSMOUSE_CYPRESS;
1149	}
1150
1151	/* Try ALPS TouchPad */
1152	if (max_proto > PSMOUSE_IMEX) {
1153		ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1154		if (psmouse_try_protocol(psmouse, PSMOUSE_ALPS,
1155					 &max_proto, set_properties, true))
1156			return PSMOUSE_ALPS;
1157	}
1158
1159	/* Try OLPC HGPK touchpad */
1160	if (max_proto > PSMOUSE_IMEX &&
1161	    psmouse_try_protocol(psmouse, PSMOUSE_HGPK, &max_proto,
1162				 set_properties, true)) {
1163		return PSMOUSE_HGPK;
1164	}
1165
1166	/* Try Elantech touchpad */
1167	if (max_proto > PSMOUSE_IMEX &&
1168	    psmouse_try_protocol(psmouse, PSMOUSE_ELANTECH,
1169				 &max_proto, set_properties, false)) {
1170		if (!set_properties)
1171			return PSMOUSE_ELANTECH;
1172
1173		ret = elantech_init(psmouse);
1174		if (ret >= 0)
1175			return ret;
1176	}
1177
1178	if (max_proto > PSMOUSE_IMEX) {
1179		if (psmouse_try_protocol(psmouse, PSMOUSE_GENPS,
1180					 &max_proto, set_properties, true))
1181			return PSMOUSE_GENPS;
1182
1183		if (psmouse_try_protocol(psmouse, PSMOUSE_PS2PP,
1184					 &max_proto, set_properties, true))
1185			return PSMOUSE_PS2PP;
1186
1187		if (psmouse_try_protocol(psmouse, PSMOUSE_TRACKPOINT,
1188					 &max_proto, set_properties, true))
1189			return PSMOUSE_TRACKPOINT;
1190
1191		if (psmouse_try_protocol(psmouse, PSMOUSE_TOUCHKIT_PS2,
1192					 &max_proto, set_properties, true))
1193			return PSMOUSE_TOUCHKIT_PS2;
1194	}
1195
1196	/*
1197	 * Try Finger Sensing Pad. We do it here because its probe upsets
1198	 * Trackpoint devices (causing TP_READ_ID command to time out).
1199	 */
1200	if (max_proto > PSMOUSE_IMEX &&
1201	    psmouse_try_protocol(psmouse, PSMOUSE_FSP,
1202				 &max_proto, set_properties, true)) {
1203		return PSMOUSE_FSP;
1204	}
1205
1206	/*
1207	 * Reset to defaults in case the device got confused by extended
1208	 * protocol probes. Note that we follow up with full reset because
1209	 * some mice put themselves to sleep when they see PSMOUSE_RESET_DIS.
1210	 */
1211	ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1212	psmouse_reset(psmouse);
1213
1214	if (max_proto >= PSMOUSE_IMEX &&
1215	    psmouse_try_protocol(psmouse, PSMOUSE_IMEX,
1216				 &max_proto, set_properties, true)) {
1217		return PSMOUSE_IMEX;
1218	}
1219
1220	if (max_proto >= PSMOUSE_IMPS &&
1221	    psmouse_try_protocol(psmouse, PSMOUSE_IMPS,
1222				 &max_proto, set_properties, true)) {
1223		return PSMOUSE_IMPS;
1224	}
1225
1226	/*
1227	 * Okay, all failed, we have a standard mouse here. The number of
1228	 * the buttons is still a question, though. We assume 3.
1229	 */
1230	psmouse_try_protocol(psmouse, PSMOUSE_PS2,
1231			     &max_proto, set_properties, true);
1232
1233	if (synaptics_hardware) {
1234		/*
1235		 * We detected Synaptics hardware but it did not respond to
1236		 * IMPS/2 probes.  We need to reset the touchpad because if
1237		 * there is a track point on the pass through port it could
1238		 * get disabled while probing for protocol extensions.
1239		 */
1240		psmouse_reset(psmouse);
1241	}
1242
1243	return PSMOUSE_PS2;
1244}
1245
1246/*
1247 * psmouse_probe() probes for a PS/2 mouse.
1248 */
1249static int psmouse_probe(struct psmouse *psmouse)
1250{
1251	struct ps2dev *ps2dev = &psmouse->ps2dev;
1252	u8 param[2];
1253	int error;
1254
1255	/*
1256	 * First, we check if it's a mouse. It should send 0x00 or 0x03 in
1257	 * case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer.
1258	 * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and
1259	 * subsequent ID queries, probably due to a firmware bug.
1260	 */
1261	param[0] = 0xa5;
1262	error = ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
1263	if (error)
1264		return error;
1265
1266	if (param[0] != 0x00 && param[0] != 0x03 &&
1267	    param[0] != 0x04 && param[0] != 0xff)
1268		return -ENODEV;
1269
1270	/*
1271	 * Then we reset and disable the mouse so that it doesn't generate
1272	 * events.
1273	 */
1274	error = ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1275	if (error)
1276		psmouse_warn(psmouse, "Failed to reset mouse on %s: %d\n",
1277			     ps2dev->serio->phys, error);
1278
1279	return 0;
1280}
1281
1282/*
1283 * psmouse_initialize() initializes the mouse to a sane state.
1284 */
1285static void psmouse_initialize(struct psmouse *psmouse)
1286{
1287	/*
1288	 * We set the mouse report rate, resolution and scaling.
1289	 */
1290	if (psmouse_max_proto != PSMOUSE_PS2) {
1291		psmouse->set_rate(psmouse, psmouse->rate);
1292		psmouse->set_resolution(psmouse, psmouse->resolution);
1293		psmouse->set_scale(psmouse, PSMOUSE_SCALE11);
1294	}
1295}
1296
1297/*
1298 * psmouse_activate() enables the mouse so that we get motion reports from it.
1299 */
1300int psmouse_activate(struct psmouse *psmouse)
1301{
1302	if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
1303		psmouse_warn(psmouse, "Failed to enable mouse on %s\n",
1304			     psmouse->ps2dev.serio->phys);
1305		return -1;
1306	}
1307
1308	psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
1309	return 0;
1310}
1311
1312/*
1313 * psmouse_deactivate() puts the mouse into poll mode so that we don't get
1314 * motion reports from it unless we explicitly request it.
1315 */
1316int psmouse_deactivate(struct psmouse *psmouse)
1317{
1318	int error;
1319
1320	error = ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE);
1321	if (error) {
1322		psmouse_warn(psmouse, "Failed to deactivate mouse on %s: %d\n",
1323			     psmouse->ps2dev.serio->phys, error);
1324		return error;
1325	}
1326
1327	psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1328	return 0;
1329}
1330
1331/*
1332 * psmouse_resync() attempts to re-validate current protocol.
1333 */
1334static void psmouse_resync(struct work_struct *work)
1335{
1336	struct psmouse *parent = NULL, *psmouse =
1337		container_of(work, struct psmouse, resync_work.work);
1338	struct serio *serio = psmouse->ps2dev.serio;
1339	psmouse_ret_t rc = PSMOUSE_GOOD_DATA;
1340	bool failed = false, enabled = false;
1341	int i;
1342
1343	mutex_lock(&psmouse_mutex);
1344
1345	if (psmouse->state != PSMOUSE_RESYNCING)
1346		goto out;
1347
1348	if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1349		parent = serio_get_drvdata(serio->parent);
1350		psmouse_deactivate(parent);
1351	}
1352
1353	/*
1354	 * Some mice don't ACK commands sent while they are in the middle of
1355	 * transmitting motion packet. To avoid delay we use ps2_sendbyte()
1356	 * instead of ps2_command() which would wait for 200ms for an ACK
1357	 * that may never come.
1358	 * As an additional quirk ALPS touchpads may not only forget to ACK
1359	 * disable command but will stop reporting taps, so if we see that
1360	 * mouse at least once ACKs disable we will do full reconnect if ACK
1361	 * is missing.
1362	 */
1363	psmouse->num_resyncs++;
1364
1365	if (ps2_sendbyte(&psmouse->ps2dev, PSMOUSE_CMD_DISABLE, 20)) {
1366		if (psmouse->num_resyncs < 3 || psmouse->acks_disable_command)
1367			failed = true;
1368	} else
1369		psmouse->acks_disable_command = true;
1370
1371	/*
1372	 * Poll the mouse. If it was reset the packet will be shorter than
1373	 * psmouse->pktsize and ps2_command will fail. We do not expect and
1374	 * do not handle scenario when mouse "upgrades" its protocol while
1375	 * disconnected since it would require additional delay. If we ever
1376	 * see a mouse that does it we'll adjust the code.
1377	 */
1378	if (!failed) {
1379		if (psmouse->poll(psmouse))
1380			failed = true;
1381		else {
1382			psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1383			for (i = 0; i < psmouse->pktsize; i++) {
1384				psmouse->pktcnt++;
1385				rc = psmouse->protocol_handler(psmouse);
1386				if (rc != PSMOUSE_GOOD_DATA)
1387					break;
1388			}
1389			if (rc != PSMOUSE_FULL_PACKET)
1390				failed = true;
1391			psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
1392		}
1393	}
1394
1395	/*
1396	 * Now try to enable mouse. We try to do that even if poll failed
1397	 * and also repeat our attempts 5 times, otherwise we may be left
1398	 * out with disabled mouse.
1399	 */
1400	for (i = 0; i < 5; i++) {
1401		if (!ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
1402			enabled = true;
1403			break;
1404		}
1405		msleep(200);
1406	}
1407
1408	if (!enabled) {
1409		psmouse_warn(psmouse, "failed to re-enable mouse on %s\n",
1410			     psmouse->ps2dev.serio->phys);
1411		failed = true;
1412	}
1413
1414	if (failed) {
1415		psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1416		psmouse_info(psmouse,
1417			     "resync failed, issuing reconnect request\n");
1418		serio_reconnect(serio);
1419	} else
1420		psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
1421
1422	if (parent)
1423		psmouse_activate(parent);
1424 out:
1425	mutex_unlock(&psmouse_mutex);
1426}
1427
1428/*
1429 * psmouse_cleanup() resets the mouse into power-on state.
1430 */
1431static void psmouse_cleanup(struct serio *serio)
1432{
1433	struct psmouse *psmouse = serio_get_drvdata(serio);
1434	struct psmouse *parent = NULL;
1435
1436	mutex_lock(&psmouse_mutex);
1437
1438	if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1439		parent = serio_get_drvdata(serio->parent);
1440		psmouse_deactivate(parent);
1441	}
1442
1443	psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1444
1445	/*
1446	 * Disable stream mode so cleanup routine can proceed undisturbed.
1447	 */
1448	if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE))
1449		psmouse_warn(psmouse, "Failed to disable mouse on %s\n",
1450			     psmouse->ps2dev.serio->phys);
1451
1452	if (psmouse->cleanup)
1453		psmouse->cleanup(psmouse);
1454
1455	/*
1456	 * Reset the mouse to defaults (bare PS/2 protocol).
1457	 */
1458	ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1459
1460	/*
1461	 * Some boxes, such as HP nx7400, get terribly confused if mouse
1462	 * is not fully enabled before suspending/shutting down.
1463	 */
1464	ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
1465
1466	if (parent) {
1467		if (parent->pt_deactivate)
1468			parent->pt_deactivate(parent);
1469
1470		psmouse_activate(parent);
1471	}
1472
1473	mutex_unlock(&psmouse_mutex);
1474}
1475
1476/*
1477 * psmouse_disconnect() closes and frees.
1478 */
1479static void psmouse_disconnect(struct serio *serio)
1480{
1481	struct psmouse *psmouse = serio_get_drvdata(serio);
1482	struct psmouse *parent = NULL;
1483
1484	sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group);
1485
1486	mutex_lock(&psmouse_mutex);
1487
1488	psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1489
1490	/* make sure we don't have a resync in progress */
1491	mutex_unlock(&psmouse_mutex);
1492	flush_workqueue(kpsmoused_wq);
1493	mutex_lock(&psmouse_mutex);
1494
1495	if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1496		parent = serio_get_drvdata(serio->parent);
1497		psmouse_deactivate(parent);
1498	}
1499
1500	if (psmouse->disconnect)
1501		psmouse->disconnect(psmouse);
1502
1503	if (parent && parent->pt_deactivate)
1504		parent->pt_deactivate(parent);
1505
1506	psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1507
1508	serio_close(serio);
1509	serio_set_drvdata(serio, NULL);
1510
1511	if (psmouse->dev)
1512		input_unregister_device(psmouse->dev);
1513
1514	kfree(psmouse);
1515
1516	if (parent)
1517		psmouse_activate(parent);
1518
1519	mutex_unlock(&psmouse_mutex);
1520}
1521
1522static int psmouse_switch_protocol(struct psmouse *psmouse,
1523				   const struct psmouse_protocol *proto)
1524{
1525	const struct psmouse_protocol *selected_proto;
1526	struct input_dev *input_dev = psmouse->dev;
1527	enum psmouse_type type;
1528
1529	input_dev->dev.parent = &psmouse->ps2dev.serio->dev;
1530
1531	if (proto && (proto->detect || proto->init)) {
1532		psmouse_apply_defaults(psmouse);
1533
1534		if (proto->detect && proto->detect(psmouse, true) < 0)
1535			return -1;
1536
1537		if (proto->init && proto->init(psmouse) < 0)
1538			return -1;
1539
1540		selected_proto = proto;
1541	} else {
1542		type = psmouse_extensions(psmouse, psmouse_max_proto, true);
1543		selected_proto = psmouse_protocol_by_type(type);
1544	}
1545
1546	psmouse->protocol = selected_proto;
1547
1548	/*
1549	 * If mouse's packet size is 3 there is no point in polling the
1550	 * device in hopes to detect protocol reset - we won't get less
1551	 * than 3 bytes response anyhow.
1552	 */
1553	if (psmouse->pktsize == 3)
1554		psmouse->resync_time = 0;
1555
1556	/*
1557	 * Some smart KVMs fake response to POLL command returning just
1558	 * 3 bytes and messing up our resync logic, so if initial poll
1559	 * fails we won't try polling the device anymore. Hopefully
1560	 * such KVM will maintain initially selected protocol.
1561	 */
1562	if (psmouse->resync_time && psmouse->poll(psmouse))
1563		psmouse->resync_time = 0;
1564
1565	snprintf(psmouse->devname, sizeof(psmouse->devname), "%s %s %s",
1566		 selected_proto->name, psmouse->vendor, psmouse->name);
1567
1568	input_dev->name = psmouse->devname;
1569	input_dev->phys = psmouse->phys;
1570	input_dev->id.bustype = BUS_I8042;
1571	input_dev->id.vendor = 0x0002;
1572	input_dev->id.product = psmouse->protocol->type;
1573	input_dev->id.version = psmouse->model;
1574
1575	return 0;
1576}
1577
1578/*
1579 * psmouse_connect() is a callback from the serio module when
1580 * an unhandled serio port is found.
1581 */
1582static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
1583{
1584	struct psmouse *psmouse, *parent = NULL;
1585	struct input_dev *input_dev;
1586	int retval = 0, error = -ENOMEM;
1587
1588	mutex_lock(&psmouse_mutex);
1589
1590	/*
1591	 * If this is a pass-through port deactivate parent so the device
1592	 * connected to this port can be successfully identified
1593	 */
1594	if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1595		parent = serio_get_drvdata(serio->parent);
1596		psmouse_deactivate(parent);
1597	}
1598
1599	psmouse = kzalloc(sizeof(struct psmouse), GFP_KERNEL);
1600	input_dev = input_allocate_device();
1601	if (!psmouse || !input_dev)
1602		goto err_free;
1603
1604	ps2_init(&psmouse->ps2dev, serio);
1605	INIT_DELAYED_WORK(&psmouse->resync_work, psmouse_resync);
1606	psmouse->dev = input_dev;
1607	snprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys);
1608
1609	psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1610
1611	serio_set_drvdata(serio, psmouse);
1612
1613	error = serio_open(serio, drv);
1614	if (error)
1615		goto err_clear_drvdata;
1616
1617	/* give PT device some time to settle down before probing */
1618	if (serio->id.type == SERIO_PS_PSTHRU)
1619		usleep_range(10000, 15000);
1620
1621	if (psmouse_probe(psmouse) < 0) {
1622		error = -ENODEV;
1623		goto err_close_serio;
1624	}
1625
1626	psmouse->rate = psmouse_rate;
1627	psmouse->resolution = psmouse_resolution;
1628	psmouse->resetafter = psmouse_resetafter;
1629	psmouse->resync_time = parent ? 0 : psmouse_resync_time;
1630	psmouse->smartscroll = psmouse_smartscroll;
1631
1632	psmouse_switch_protocol(psmouse, NULL);
1633
1634	if (!psmouse->protocol->smbus_companion) {
1635		psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1636		psmouse_initialize(psmouse);
1637
1638		error = input_register_device(input_dev);
1639		if (error)
1640			goto err_protocol_disconnect;
1641	} else {
1642		/* Smbus companion will be reporting events, not us. */
1643		input_free_device(input_dev);
1644		psmouse->dev = input_dev = NULL;
1645	}
1646
1647	if (parent && parent->pt_activate)
1648		parent->pt_activate(parent);
1649
1650	error = sysfs_create_group(&serio->dev.kobj, &psmouse_attribute_group);
1651	if (error)
1652		goto err_pt_deactivate;
1653
1654	/*
1655	 * PS/2 devices having SMBus companions should stay disabled
1656	 * on PS/2 side, in order to have SMBus part operable.
1657	 */
1658	if (!psmouse->protocol->smbus_companion)
1659		psmouse_activate(psmouse);
1660
1661 out:
1662	/* If this is a pass-through port the parent needs to be re-activated */
1663	if (parent)
1664		psmouse_activate(parent);
1665
1666	mutex_unlock(&psmouse_mutex);
1667	return retval;
1668
1669 err_pt_deactivate:
1670	if (parent && parent->pt_deactivate)
1671		parent->pt_deactivate(parent);
1672	if (input_dev) {
1673		input_unregister_device(input_dev);
1674		input_dev = NULL; /* so we don't try to free it below */
1675	}
1676 err_protocol_disconnect:
1677	if (psmouse->disconnect)
1678		psmouse->disconnect(psmouse);
1679	psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1680 err_close_serio:
1681	serio_close(serio);
1682 err_clear_drvdata:
1683	serio_set_drvdata(serio, NULL);
1684 err_free:
1685	input_free_device(input_dev);
1686	kfree(psmouse);
1687
1688	retval = error;
1689	goto out;
1690}
1691
1692static int __psmouse_reconnect(struct serio *serio, bool fast_reconnect)
1693{
1694	struct psmouse *psmouse = serio_get_drvdata(serio);
1695	struct psmouse *parent = NULL;
1696	int (*reconnect_handler)(struct psmouse *);
1697	enum psmouse_type type;
1698	int rc = -1;
1699
1700	mutex_lock(&psmouse_mutex);
1701
1702	if (fast_reconnect) {
1703		reconnect_handler = psmouse->fast_reconnect;
1704		if (!reconnect_handler) {
1705			rc = -ENOENT;
1706			goto out_unlock;
1707		}
1708	} else {
1709		reconnect_handler = psmouse->reconnect;
1710	}
1711
1712	if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1713		parent = serio_get_drvdata(serio->parent);
1714		psmouse_deactivate(parent);
1715	}
1716
1717	psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1718
1719	if (reconnect_handler) {
1720		if (reconnect_handler(psmouse))
1721			goto out;
1722	} else {
1723		psmouse_reset(psmouse);
1724
1725		if (psmouse_probe(psmouse) < 0)
1726			goto out;
1727
1728		type = psmouse_extensions(psmouse, psmouse_max_proto, false);
1729		if (psmouse->protocol->type != type)
1730			goto out;
1731	}
1732
1733	/*
1734	 * OK, the device type (and capabilities) match the old one,
1735	 * we can continue using it, complete initialization
1736	 */
1737	if (!psmouse->protocol->smbus_companion) {
1738		psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1739		psmouse_initialize(psmouse);
1740	}
1741
1742	if (parent && parent->pt_activate)
1743		parent->pt_activate(parent);
1744
1745	/*
1746	 * PS/2 devices having SMBus companions should stay disabled
1747	 * on PS/2 side, in order to have SMBus part operable.
1748	 */
1749	if (!psmouse->protocol->smbus_companion)
1750		psmouse_activate(psmouse);
1751
1752	rc = 0;
1753
1754out:
1755	/* If this is a pass-through port the parent waits to be activated */
1756	if (parent)
1757		psmouse_activate(parent);
1758
1759out_unlock:
1760	mutex_unlock(&psmouse_mutex);
1761	return rc;
1762}
1763
1764static int psmouse_reconnect(struct serio *serio)
1765{
1766	return __psmouse_reconnect(serio, false);
1767}
1768
1769static int psmouse_fast_reconnect(struct serio *serio)
1770{
1771	return __psmouse_reconnect(serio, true);
1772}
1773
1774static struct serio_device_id psmouse_serio_ids[] = {
1775	{
1776		.type	= SERIO_8042,
1777		.proto	= SERIO_ANY,
1778		.id	= SERIO_ANY,
1779		.extra	= SERIO_ANY,
1780	},
1781	{
1782		.type	= SERIO_PS_PSTHRU,
1783		.proto	= SERIO_ANY,
1784		.id	= SERIO_ANY,
1785		.extra	= SERIO_ANY,
1786	},
1787	{ 0 }
1788};
1789
1790MODULE_DEVICE_TABLE(serio, psmouse_serio_ids);
1791
1792static struct serio_driver psmouse_drv = {
1793	.driver		= {
1794		.name	= "psmouse",
1795	},
1796	.description	= DRIVER_DESC,
1797	.id_table	= psmouse_serio_ids,
1798	.interrupt	= psmouse_interrupt,
1799	.connect	= psmouse_connect,
1800	.reconnect	= psmouse_reconnect,
1801	.fast_reconnect	= psmouse_fast_reconnect,
1802	.disconnect	= psmouse_disconnect,
1803	.cleanup	= psmouse_cleanup,
1804};
1805
1806ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *devattr,
1807				 char *buf)
1808{
1809	struct serio *serio = to_serio_port(dev);
1810	struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1811	struct psmouse *psmouse = serio_get_drvdata(serio);
1812
1813	if (psmouse->protocol->smbus_companion &&
1814			devattr != &psmouse_attr_protocol.dattr)
1815		return -ENOENT;
1816
1817	return attr->show(psmouse, attr->data, buf);
1818}
1819
1820ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *devattr,
1821				const char *buf, size_t count)
1822{
1823	struct serio *serio = to_serio_port(dev);
1824	struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1825	struct psmouse *psmouse, *parent = NULL;
1826	int retval;
1827
1828	retval = mutex_lock_interruptible(&psmouse_mutex);
1829	if (retval)
1830		goto out;
1831
1832	psmouse = serio_get_drvdata(serio);
1833
1834	if (psmouse->protocol->smbus_companion &&
1835			devattr != &psmouse_attr_protocol.dattr) {
1836		retval = -ENOENT;
1837		goto out_unlock;
1838	}
1839
1840	if (attr->protect) {
1841		if (psmouse->state == PSMOUSE_IGNORE) {
1842			retval = -ENODEV;
1843			goto out_unlock;
1844		}
1845
1846		if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1847			parent = serio_get_drvdata(serio->parent);
1848			psmouse_deactivate(parent);
1849		}
1850
1851		if (!psmouse->protocol->smbus_companion)
1852			psmouse_deactivate(psmouse);
1853	}
1854
1855	retval = attr->set(psmouse, attr->data, buf, count);
1856
1857	if (attr->protect) {
1858		if (retval != -ENODEV && !psmouse->protocol->smbus_companion)
1859			psmouse_activate(psmouse);
1860
1861		if (parent)
1862			psmouse_activate(parent);
1863	}
1864
1865 out_unlock:
1866	mutex_unlock(&psmouse_mutex);
1867 out:
1868	return retval;
1869}
1870
1871static ssize_t psmouse_show_int_attr(struct psmouse *psmouse, void *offset, char *buf)
1872{
1873	unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1874
1875	return sprintf(buf, "%u\n", *field);
1876}
1877
1878static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count)
1879{
1880	unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1881	unsigned int value;
1882	int err;
1883
1884	err = kstrtouint(buf, 10, &value);
1885	if (err)
1886		return err;
1887
1888	*field = value;
1889
1890	return count;
1891}
1892
1893static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, void *data, char *buf)
1894{
1895	return sprintf(buf, "%s\n", psmouse->protocol->name);
1896}
1897
1898static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1899{
1900	struct serio *serio = psmouse->ps2dev.serio;
1901	struct psmouse *parent = NULL;
1902	struct input_dev *old_dev, *new_dev;
1903	const struct psmouse_protocol *proto, *old_proto;
1904	int error;
1905	int retry = 0;
1906
1907	proto = psmouse_protocol_by_name(buf, count);
1908	if (!proto)
1909		return -EINVAL;
1910
1911	if (psmouse->protocol == proto)
1912		return count;
1913
1914	new_dev = input_allocate_device();
1915	if (!new_dev)
1916		return -ENOMEM;
1917
1918	while (!list_empty(&serio->children)) {
1919		if (++retry > 3) {
1920			psmouse_warn(psmouse,
1921				     "failed to destroy children ports, protocol change aborted.\n");
1922			input_free_device(new_dev);
1923			return -EIO;
1924		}
1925
1926		mutex_unlock(&psmouse_mutex);
1927		serio_unregister_child_port(serio);
1928		mutex_lock(&psmouse_mutex);
1929
1930		if (serio->drv != &psmouse_drv) {
1931			input_free_device(new_dev);
1932			return -ENODEV;
1933		}
1934
1935		if (psmouse->protocol == proto) {
1936			input_free_device(new_dev);
1937			return count; /* switched by other thread */
1938		}
1939	}
1940
1941	if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1942		parent = serio_get_drvdata(serio->parent);
1943		if (parent->pt_deactivate)
1944			parent->pt_deactivate(parent);
1945	}
1946
1947	old_dev = psmouse->dev;
1948	old_proto = psmouse->protocol;
1949
1950	if (psmouse->disconnect)
1951		psmouse->disconnect(psmouse);
1952
1953	psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1954
1955	psmouse->dev = new_dev;
1956	psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1957
1958	if (psmouse_switch_protocol(psmouse, proto) < 0) {
1959		psmouse_reset(psmouse);
1960		/* defa…

Large files files are truncated, but you can click here to view the full file