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