i8042.c 34.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *  i8042 keyboard and mouse controller driver for Linux
 *
 *  Copyright (c) 1999-2004 Vojtech Pavlik
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

13 14
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

15
#include <linux/types.h>
L
Linus Torvalds 已提交
16 17 18 19 20 21 22 23
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/serio.h>
#include <linux/err.h>
#include <linux/rcupdate.h>
24
#include <linux/platform_device.h>
25
#include <linux/i8042.h>
26
#include <linux/slab.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32 33

#include <asm/io.h>

MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
MODULE_DESCRIPTION("i8042 keyboard and mouse controller driver");
MODULE_LICENSE("GPL");

34
static bool i8042_nokbd;
35 36 37
module_param_named(nokbd, i8042_nokbd, bool, 0);
MODULE_PARM_DESC(nokbd, "Do not probe or use KBD port.");

38
static bool i8042_noaux;
L
Linus Torvalds 已提交
39 40 41
module_param_named(noaux, i8042_noaux, bool, 0);
MODULE_PARM_DESC(noaux, "Do not probe or use AUX (mouse) port.");

42
static bool i8042_nomux;
L
Linus Torvalds 已提交
43
module_param_named(nomux, i8042_nomux, bool, 0);
D
Dominik Brodowski 已提交
44
MODULE_PARM_DESC(nomux, "Do not check whether an active multiplexing controller is present.");
L
Linus Torvalds 已提交
45

46
static bool i8042_unlock;
L
Linus Torvalds 已提交
47 48 49
module_param_named(unlock, i8042_unlock, bool, 0);
MODULE_PARM_DESC(unlock, "Ignore keyboard lock.");

50
static bool i8042_reset;
L
Linus Torvalds 已提交
51 52 53
module_param_named(reset, i8042_reset, bool, 0);
MODULE_PARM_DESC(reset, "Reset controller during init and cleanup.");

54
static bool i8042_direct;
L
Linus Torvalds 已提交
55 56 57
module_param_named(direct, i8042_direct, bool, 0);
MODULE_PARM_DESC(direct, "Put keyboard port into non-translated mode.");

58
static bool i8042_dumbkbd;
L
Linus Torvalds 已提交
59 60 61
module_param_named(dumbkbd, i8042_dumbkbd, bool, 0);
MODULE_PARM_DESC(dumbkbd, "Pretend that controller can only read data from keyboard");

62
static bool i8042_noloop;
L
Linus Torvalds 已提交
63 64 65
module_param_named(noloop, i8042_noloop, bool, 0);
MODULE_PARM_DESC(noloop, "Disable the AUX Loopback command while probing for the AUX port");

66 67 68 69
static bool i8042_notimeout;
module_param_named(notimeout, i8042_notimeout, bool, 0);
MODULE_PARM_DESC(notimeout, "Ignore timeouts signalled by i8042");

70 71 72 73
static bool i8042_kbdreset;
module_param_named(kbdreset, i8042_kbdreset, bool, 0);
MODULE_PARM_DESC(kbdreset, "Reset device connected to KBD port");

74
#ifdef CONFIG_X86
75
static bool i8042_dritek;
76 77 78 79
module_param_named(dritek, i8042_dritek, bool, 0);
MODULE_PARM_DESC(dritek, "Force enable the Dritek keyboard extension");
#endif

L
Linus Torvalds 已提交
80
#ifdef CONFIG_PNP
81
static bool i8042_nopnp;
L
Linus Torvalds 已提交
82 83 84 85 86 87
module_param_named(nopnp, i8042_nopnp, bool, 0);
MODULE_PARM_DESC(nopnp, "Do not use PNP to detect controller settings");
#endif

#define DEBUG
#ifdef DEBUG
88
static bool i8042_debug;
L
Linus Torvalds 已提交
89 90 91 92
module_param_named(debug, i8042_debug, bool, 0600);
MODULE_PARM_DESC(debug, "Turn i8042 debugging mode on and off");
#endif

93
static bool i8042_bypass_aux_irq_test;
94 95
static char i8042_kbd_firmware_id[128];
static char i8042_aux_firmware_id[128];
96

L
Linus Torvalds 已提交
97 98
#include "i8042.h"

99 100 101 102
/*
 * i8042_lock protects serialization between i8042_command and
 * the interrupt handler.
 */
L
Linus Torvalds 已提交
103 104
static DEFINE_SPINLOCK(i8042_lock);

105 106 107 108 109 110 111 112 113 114
/*
 * Writers to AUX and KBD ports as well as users issuing i8042_command
 * directly should acquire i8042_mutex (by means of calling
 * i8042_lock_chip() and i8042_unlock_ship() helpers) to ensure that
 * they do not disturb each other (unfortunately in many i8042
 * implementations write to one of the ports will immediately abort
 * command that is being processed by another port).
 */
static DEFINE_MUTEX(i8042_mutex);

L
Linus Torvalds 已提交
115 116 117
struct i8042_port {
	struct serio *serio;
	int irq;
118
	bool exists;
L
Linus Torvalds 已提交
119 120 121 122 123 124 125
	signed char mux;
};

#define I8042_KBD_PORT_NO	0
#define I8042_AUX_PORT_NO	1
#define I8042_MUX_PORT_NO	2
#define I8042_NUM_PORTS		(I8042_NUM_MUX_PORTS + 2)
126 127

static struct i8042_port i8042_ports[I8042_NUM_PORTS];
L
Linus Torvalds 已提交
128 129 130

static unsigned char i8042_initial_ctr;
static unsigned char i8042_ctr;
131 132 133
static bool i8042_mux_present;
static bool i8042_kbd_irq_registered;
static bool i8042_aux_irq_registered;
134
static unsigned char i8042_suppress_kbd_ack;
L
Linus Torvalds 已提交
135 136
static struct platform_device *i8042_platform_device;

137
static irqreturn_t i8042_interrupt(int irq, void *dev_id);
138 139
static bool (*i8042_platform_filter)(unsigned char data, unsigned char str,
				     struct serio *serio);
L
Linus Torvalds 已提交
140

141 142 143 144 145 146 147 148 149 150 151 152
void i8042_lock_chip(void)
{
	mutex_lock(&i8042_mutex);
}
EXPORT_SYMBOL(i8042_lock_chip);

void i8042_unlock_chip(void)
{
	mutex_unlock(&i8042_mutex);
}
EXPORT_SYMBOL(i8042_unlock_chip);

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
int i8042_install_filter(bool (*filter)(unsigned char data, unsigned char str,
					struct serio *serio))
{
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(&i8042_lock, flags);

	if (i8042_platform_filter) {
		ret = -EBUSY;
		goto out;
	}

	i8042_platform_filter = filter;

out:
	spin_unlock_irqrestore(&i8042_lock, flags);
	return ret;
}
EXPORT_SYMBOL(i8042_install_filter);

int i8042_remove_filter(bool (*filter)(unsigned char data, unsigned char str,
				       struct serio *port))
{
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(&i8042_lock, flags);

	if (i8042_platform_filter != filter) {
		ret = -EINVAL;
		goto out;
	}

	i8042_platform_filter = NULL;

out:
	spin_unlock_irqrestore(&i8042_lock, flags);
	return ret;
}
EXPORT_SYMBOL(i8042_remove_filter);

L
Linus Torvalds 已提交
195 196 197 198 199 200 201 202 203
/*
 * The i8042_wait_read() and i8042_wait_write functions wait for the i8042 to
 * be ready for reading values from it / writing values to it.
 * Called always with i8042_lock held.
 */

static int i8042_wait_read(void)
{
	int i = 0;
204

L
Linus Torvalds 已提交
205 206 207 208 209 210 211 212 213 214
	while ((~i8042_read_status() & I8042_STR_OBF) && (i < I8042_CTL_TIMEOUT)) {
		udelay(50);
		i++;
	}
	return -(i == I8042_CTL_TIMEOUT);
}

static int i8042_wait_write(void)
{
	int i = 0;
215

L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	while ((i8042_read_status() & I8042_STR_IBF) && (i < I8042_CTL_TIMEOUT)) {
		udelay(50);
		i++;
	}
	return -(i == I8042_CTL_TIMEOUT);
}

/*
 * i8042_flush() flushes all data that may be in the keyboard and mouse buffers
 * of the i8042 down the toilet.
 */

static int i8042_flush(void)
{
	unsigned long flags;
	unsigned char data, str;
232 233
	int count = 0;
	int retval = 0;
L
Linus Torvalds 已提交
234 235 236

	spin_lock_irqsave(&i8042_lock, flags);

237 238 239 240 241 242 243 244 245 246
	while ((str = i8042_read_status()) & I8042_STR_OBF) {
		if (count++ < I8042_BUFFER_SIZE) {
			udelay(50);
			data = i8042_read_data();
			dbg("%02x <- i8042 (flush, %s)\n",
			    data, str & I8042_STR_AUXDATA ? "aux" : "kbd");
		} else {
			retval = -EIO;
			break;
		}
L
Linus Torvalds 已提交
247 248 249 250
	}

	spin_unlock_irqrestore(&i8042_lock, flags);

251
	return retval;
L
Linus Torvalds 已提交
252 253 254 255 256 257 258 259 260 261
}

/*
 * i8042_command() executes a command on the i8042. It also sends the input
 * parameter(s) of the commands to it, and receives the output value(s). The
 * parameters are to be stored in the param array, and the output is placed
 * into the same array. The number of the parameters and output values is
 * encoded in bits 8-11 of the command number.
 */

262
static int __i8042_command(unsigned char *param, int command)
L
Linus Torvalds 已提交
263
{
264
	int i, error;
L
Linus Torvalds 已提交
265 266 267 268

	if (i8042_noloop && command == I8042_CMD_AUX_LOOP)
		return -1;

269 270 271
	error = i8042_wait_write();
	if (error)
		return error;
272

273
	dbg("%02x -> i8042 (command)\n", command & 0xff);
274 275 276
	i8042_write_command(command & 0xff);

	for (i = 0; i < ((command >> 12) & 0xf); i++) {
277 278 279
		error = i8042_wait_write();
		if (error)
			return error;
280
		dbg("%02x -> i8042 (parameter)\n", param[i]);
281
		i8042_write_data(param[i]);
L
Linus Torvalds 已提交
282 283
	}

284
	for (i = 0; i < ((command >> 8) & 0xf); i++) {
285 286
		error = i8042_wait_read();
		if (error) {
287
			dbg("     -- i8042 (timeout)\n");
288 289
			return error;
		}
L
Linus Torvalds 已提交
290

291 292
		if (command == I8042_CMD_AUX_LOOP &&
		    !(i8042_read_status() & I8042_STR_AUXDATA)) {
293
			dbg("     -- i8042 (auxerr)\n");
294
			return -1;
L
Linus Torvalds 已提交
295 296
		}

297
		param[i] = i8042_read_data();
298
		dbg("%02x <- i8042 (return)\n", param[i]);
299
	}
L
Linus Torvalds 已提交
300

301 302
	return 0;
}
L
Linus Torvalds 已提交
303

304
int i8042_command(unsigned char *param, int command)
305 306 307 308 309 310
{
	unsigned long flags;
	int retval;

	spin_lock_irqsave(&i8042_lock, flags);
	retval = __i8042_command(param, command);
311
	spin_unlock_irqrestore(&i8042_lock, flags);
312

L
Linus Torvalds 已提交
313 314
	return retval;
}
315
EXPORT_SYMBOL(i8042_command);
L
Linus Torvalds 已提交
316 317 318 319 320 321 322 323 324 325 326 327

/*
 * i8042_kbd_write() sends a byte out through the keyboard interface.
 */

static int i8042_kbd_write(struct serio *port, unsigned char c)
{
	unsigned long flags;
	int retval = 0;

	spin_lock_irqsave(&i8042_lock, flags);

328
	if (!(retval = i8042_wait_write())) {
329
		dbg("%02x -> i8042 (kbd-data)\n", c);
L
Linus Torvalds 已提交
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
		i8042_write_data(c);
	}

	spin_unlock_irqrestore(&i8042_lock, flags);

	return retval;
}

/*
 * i8042_aux_write() sends a byte out through the aux interface.
 */

static int i8042_aux_write(struct serio *serio, unsigned char c)
{
	struct i8042_port *port = serio->port_data;

346 347 348
	return i8042_command(&c, port->mux == -1 ?
					I8042_CMD_AUX_SEND :
					I8042_CMD_MUX_SEND + port->mux);
L
Linus Torvalds 已提交
349 350
}

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374

/*
 * i8042_aux_close attempts to clear AUX or KBD port state by disabling
 * and then re-enabling it.
 */

static void i8042_port_close(struct serio *serio)
{
	int irq_bit;
	int disable_bit;
	const char *port_name;

	if (serio == i8042_ports[I8042_AUX_PORT_NO].serio) {
		irq_bit = I8042_CTR_AUXINT;
		disable_bit = I8042_CTR_AUXDIS;
		port_name = "AUX";
	} else {
		irq_bit = I8042_CTR_KBDINT;
		disable_bit = I8042_CTR_KBDDIS;
		port_name = "KBD";
	}

	i8042_ctr &= ~irq_bit;
	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
375
		pr_warn("Can't write CTR while closing %s port\n", port_name);
376 377 378 379 380 381

	udelay(50);

	i8042_ctr &= ~disable_bit;
	i8042_ctr |= irq_bit;
	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
382
		pr_err("Can't reactivate %s port\n", port_name);
383 384 385 386 387 388 389 390

	/*
	 * See if there is any data appeared while we were messing with
	 * port state.
	 */
	i8042_interrupt(0, NULL);
}

L
Linus Torvalds 已提交
391 392 393 394 395 396 397 398 399
/*
 * i8042_start() is called by serio core when port is about to finish
 * registering. It will mark port as existing so i8042_interrupt can
 * start sending data through it.
 */
static int i8042_start(struct serio *serio)
{
	struct i8042_port *port = serio->port_data;

400
	port->exists = true;
L
Linus Torvalds 已提交
401 402 403 404 405 406 407 408 409 410 411 412 413
	mb();
	return 0;
}

/*
 * i8042_stop() marks serio port as non-existing so i8042_interrupt
 * will not try to send data to the port that is about to go away.
 * The function is called by serio core as part of unregister procedure.
 */
static void i8042_stop(struct serio *serio)
{
	struct i8042_port *port = serio->port_data;

414
	port->exists = false;
415 416 417 418 419 420 421 422

	/*
	 * We synchronize with both AUX and KBD IRQs because there is
	 * a (very unlikely) chance that AUX IRQ is raised for KBD port
	 * and vice versa.
	 */
	synchronize_irq(I8042_AUX_IRQ);
	synchronize_irq(I8042_KBD_IRQ);
L
Linus Torvalds 已提交
423 424 425
	port->serio = NULL;
}

426 427 428 429 430
/*
 * i8042_filter() filters out unwanted bytes from the input data stream.
 * It is called from i8042_interrupt and thus is running with interrupts
 * off and i8042_lock held.
 */
431 432
static bool i8042_filter(unsigned char data, unsigned char str,
			 struct serio *serio)
433 434 435 436 437 438 439 440 441 442
{
	if (unlikely(i8042_suppress_kbd_ack)) {
		if ((~str & I8042_STR_AUXDATA) &&
		    (data == 0xfa || data == 0xfe)) {
			i8042_suppress_kbd_ack--;
			dbg("Extra keyboard ACK - filtered out\n");
			return true;
		}
	}

443
	if (i8042_platform_filter && i8042_platform_filter(data, str, serio)) {
444
		dbg("Filtered out by platform filter\n");
445 446 447
		return true;
	}

448 449 450
	return false;
}

L
Linus Torvalds 已提交
451 452 453 454 455 456
/*
 * i8042_interrupt() is the most important function in this driver -
 * it handles the interrupts from the i8042, and sends incoming bytes
 * to the upper layers.
 */

457
static irqreturn_t i8042_interrupt(int irq, void *dev_id)
L
Linus Torvalds 已提交
458 459
{
	struct i8042_port *port;
460
	struct serio *serio;
L
Linus Torvalds 已提交
461 462 463 464
	unsigned long flags;
	unsigned char str, data;
	unsigned int dfl;
	unsigned int port_no;
465
	bool filtered;
466
	int ret = 1;
L
Linus Torvalds 已提交
467 468

	spin_lock_irqsave(&i8042_lock, flags);
469

L
Linus Torvalds 已提交
470 471 472
	str = i8042_read_status();
	if (unlikely(~str & I8042_STR_OBF)) {
		spin_unlock_irqrestore(&i8042_lock, flags);
473 474
		if (irq)
			dbg("Interrupt %d, without any data\n", irq);
L
Linus Torvalds 已提交
475 476 477
		ret = 0;
		goto out;
	}
478

L
Linus Torvalds 已提交
479 480 481 482 483 484 485 486
	data = i8042_read_data();

	if (i8042_mux_present && (str & I8042_STR_AUXDATA)) {
		static unsigned long last_transmit;
		static unsigned char last_str;

		dfl = 0;
		if (str & I8042_STR_MUXERR) {
487 488
			dbg("MUX error, status is %02x, data is %02x\n",
			    str, data);
L
Linus Torvalds 已提交
489 490 491
/*
 * When MUXERR condition is signalled the data register can only contain
 * 0xfd, 0xfe or 0xff if implementation follows the spec. Unfortunately
492 493 494 495 496 497 498
 * it is not always the case. Some KBCs also report 0xfc when there is
 * nothing connected to the port while others sometimes get confused which
 * port the data came from and signal error leaving the data intact. They
 * _do not_ revert to legacy mode (actually I've never seen KBC reverting
 * to legacy mode yet, when we see one we'll add proper handling).
 * Anyway, we process 0xfc, 0xfd, 0xfe and 0xff as timeouts, and for the
 * rest assume that the data came from the same serio last byte
L
Linus Torvalds 已提交
499 500
 * was transmitted (if transmission happened not too long ago).
 */
501 502 503

			switch (data) {
				default:
L
Linus Torvalds 已提交
504 505 506 507 508
					if (time_before(jiffies, last_transmit + HZ/10)) {
						str = last_str;
						break;
					}
					/* fall through - report timeout */
509
				case 0xfc:
L
Linus Torvalds 已提交
510 511 512 513 514 515 516 517 518 519 520 521
				case 0xfd:
				case 0xfe: dfl = SERIO_TIMEOUT; data = 0xfe; break;
				case 0xff: dfl = SERIO_PARITY;  data = 0xfe; break;
			}
		}

		port_no = I8042_MUX_PORT_NO + ((str >> 6) & 3);
		last_str = str;
		last_transmit = jiffies;
	} else {

		dfl = ((str & I8042_STR_PARITY) ? SERIO_PARITY : 0) |
522
		      ((str & I8042_STR_TIMEOUT && !i8042_notimeout) ? SERIO_TIMEOUT : 0);
L
Linus Torvalds 已提交
523 524 525 526 527 528

		port_no = (str & I8042_STR_AUXDATA) ?
				I8042_AUX_PORT_NO : I8042_KBD_PORT_NO;
	}

	port = &i8042_ports[port_no];
529
	serio = port->exists ? port->serio : NULL;
L
Linus Torvalds 已提交
530

531
	dbg("%02x <- i8042 (interrupt, %d, %d%s%s)\n",
532
	    data, port_no, irq,
L
Linus Torvalds 已提交
533 534 535
	    dfl & SERIO_PARITY ? ", bad parity" : "",
	    dfl & SERIO_TIMEOUT ? ", timeout" : "");

536
	filtered = i8042_filter(data, str, serio);
537 538

	spin_unlock_irqrestore(&i8042_lock, flags);
539

540
	if (likely(port->exists && !filtered))
541
		serio_interrupt(serio, data, dfl);
L
Linus Torvalds 已提交
542

543
 out:
L
Linus Torvalds 已提交
544 545 546
	return IRQ_RETVAL(ret);
}

547
/*
548
 * i8042_enable_kbd_port enables keyboard port on chip
549 550 551 552 553 554 555 556
 */

static int i8042_enable_kbd_port(void)
{
	i8042_ctr &= ~I8042_CTR_KBDDIS;
	i8042_ctr |= I8042_CTR_KBDINT;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
557 558
		i8042_ctr &= ~I8042_CTR_KBDINT;
		i8042_ctr |= I8042_CTR_KBDDIS;
559
		pr_err("Failed to enable KBD port\n");
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
		return -EIO;
	}

	return 0;
}

/*
 * i8042_enable_aux_port enables AUX (mouse) port on chip
 */

static int i8042_enable_aux_port(void)
{
	i8042_ctr &= ~I8042_CTR_AUXDIS;
	i8042_ctr |= I8042_CTR_AUXINT;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
576 577
		i8042_ctr &= ~I8042_CTR_AUXINT;
		i8042_ctr |= I8042_CTR_AUXDIS;
578
		pr_err("Failed to enable AUX port\n");
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
		return -EIO;
	}

	return 0;
}

/*
 * i8042_enable_mux_ports enables 4 individual AUX ports after
 * the controller has been switched into Multiplexed mode
 */

static int i8042_enable_mux_ports(void)
{
	unsigned char param;
	int i;

	for (i = 0; i < I8042_NUM_MUX_PORTS; i++) {
		i8042_command(&param, I8042_CMD_MUX_PFX + i);
		i8042_command(&param, I8042_CMD_AUX_ENABLE);
	}

	return i8042_enable_aux_port();
}

L
Linus Torvalds 已提交
603
/*
604 605 606
 * i8042_set_mux_mode checks whether the controller has an
 * active multiplexor and puts the chip into Multiplexed (true)
 * or Legacy (false) mode.
L
Linus Torvalds 已提交
607 608
 */

609
static int i8042_set_mux_mode(bool multiplex, unsigned char *mux_version)
L
Linus Torvalds 已提交
610 611
{

612
	unsigned char param, val;
L
Linus Torvalds 已提交
613 614 615 616 617 618 619 620
/*
 * Get rid of bytes in the queue.
 */

	i8042_flush();

/*
 * Internal loopback test - send three bytes, they should come back from the
621
 * mouse interface, the last should be version.
L
Linus Torvalds 已提交
622 623
 */

624 625 626 627 628
	param = val = 0xf0;
	if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != val)
		return -1;
	param = val = multiplex ? 0x56 : 0xf6;
	if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != val)
L
Linus Torvalds 已提交
629
		return -1;
630 631
	param = val = multiplex ? 0xa4 : 0xa5;
	if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param == val)
L
Linus Torvalds 已提交
632
		return -1;
633 634 635 636 637 638

/*
 * Workaround for interference with USB Legacy emulation
 * that causes a v10.12 MUX to be found.
 */
	if (param == 0xac)
L
Linus Torvalds 已提交
639 640 641
		return -1;

	if (mux_version)
642
		*mux_version = param;
L
Linus Torvalds 已提交
643 644 645 646 647

	return 0;
}

/*
648 649 650
 * i8042_check_mux() checks whether the controller supports the PS/2 Active
 * Multiplexing specification by Synaptics, Phoenix, Insyde and
 * LCS/Telegraphics.
L
Linus Torvalds 已提交
651 652
 */

653
static int __init i8042_check_mux(void)
L
Linus Torvalds 已提交
654
{
655 656
	unsigned char mux_version;

657
	if (i8042_set_mux_mode(true, &mux_version))
658 659
		return -1;

660
	pr_info("Detected active multiplexing controller, rev %d.%d\n",
661
		(mux_version >> 4) & 0xf, mux_version & 0xf);
L
Linus Torvalds 已提交
662

663 664 665
/*
 * Disable all muxed ports by disabling AUX.
 */
L
Linus Torvalds 已提交
666 667 668 669
	i8042_ctr |= I8042_CTR_AUXDIS;
	i8042_ctr &= ~I8042_CTR_AUXINT;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
670
		pr_err("Failed to disable AUX port, can't use MUX\n");
671
		return -EIO;
L
Linus Torvalds 已提交
672 673
	}

674
	i8042_mux_present = true;
L
Linus Torvalds 已提交
675 676 677 678 679

	return 0;
}

/*
680
 * The following is used to test AUX IRQ delivery.
L
Linus Torvalds 已提交
681
 */
682 683
static struct completion i8042_aux_irq_delivered __initdata;
static bool i8042_irq_being_tested __initdata;
L
Linus Torvalds 已提交
684

685
static irqreturn_t __init i8042_aux_test_irq(int irq, void *dev_id)
L
Linus Torvalds 已提交
686
{
687 688
	unsigned long flags;
	unsigned char str, data;
689
	int ret = 0;
L
Linus Torvalds 已提交
690

691 692 693 694
	spin_lock_irqsave(&i8042_lock, flags);
	str = i8042_read_status();
	if (str & I8042_STR_OBF) {
		data = i8042_read_data();
695 696
		dbg("%02x <- i8042 (aux_test_irq, %s)\n",
		    data, str & I8042_STR_AUXDATA ? "aux" : "kbd");
697 698 699
		if (i8042_irq_being_tested &&
		    data == 0xa5 && (str & I8042_STR_AUXDATA))
			complete(&i8042_aux_irq_delivered);
700
		ret = 1;
701 702
	}
	spin_unlock_irqrestore(&i8042_lock, flags);
L
Linus Torvalds 已提交
703

704
	return IRQ_RETVAL(ret);
L
Linus Torvalds 已提交
705 706
}

707 708 709 710 711
/*
 * i8042_toggle_aux - enables or disables AUX port on i8042 via command and
 * verifies success by readinng CTR. Used when testing for presence of AUX
 * port.
 */
712
static int __init i8042_toggle_aux(bool on)
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
{
	unsigned char param;
	int i;

	if (i8042_command(&param,
			on ? I8042_CMD_AUX_ENABLE : I8042_CMD_AUX_DISABLE))
		return -1;

	/* some chips need some time to set the I8042_CTR_AUXDIS bit */
	for (i = 0; i < 100; i++) {
		udelay(50);

		if (i8042_command(&param, I8042_CMD_CTL_RCTR))
			return -1;

		if (!(param & I8042_CTR_AUXDIS) == on)
			return 0;
	}

	return -1;
}
L
Linus Torvalds 已提交
734 735 736 737 738 739

/*
 * i8042_check_aux() applies as much paranoia as it can at detecting
 * the presence of an AUX interface.
 */

740
static int __init i8042_check_aux(void)
L
Linus Torvalds 已提交
741
{
742
	int retval = -1;
743 744
	bool irq_registered = false;
	bool aux_loop_broken = false;
745
	unsigned long flags;
L
Linus Torvalds 已提交
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	unsigned char param;

/*
 * Get rid of bytes in the queue.
 */

	i8042_flush();

/*
 * Internal loopback test - filters out AT-type i8042's. Unfortunately
 * SiS screwed up and their 5597 doesn't support the LOOP command even
 * though it has an AUX port.
 */

	param = 0x5a;
761 762
	retval = i8042_command(&param, I8042_CMD_AUX_LOOP);
	if (retval || param != 0x5a) {
L
Linus Torvalds 已提交
763 764 765 766 767 768 769 770 771

/*
 * External connection test - filters out AT-soldered PS/2 i8042's
 * 0x00 - no error, 0x01-0x03 - clock/data stuck, 0xff - general error
 * 0xfa - no error on some notebooks which ignore the spec
 * Because it's common for chipsets to return error on perfectly functioning
 * AUX ports, we test for this only when the LOOP command failed.
 */

772 773 774
		if (i8042_command(&param, I8042_CMD_AUX_TEST) ||
		    (param && param != 0xfa && param != 0xff))
			return -1;
775

776 777 778 779 780
/*
 * If AUX_LOOP completed without error but returned unexpected data
 * mark it as broken
 */
		if (!retval)
781
			aux_loop_broken = true;
L
Linus Torvalds 已提交
782 783 784 785 786 787
	}

/*
 * Bit assignment test - filters out PS/2 i8042's in AT mode
 */

788
	if (i8042_toggle_aux(false)) {
789 790
		pr_warn("Failed to disable AUX port, but continuing anyway... Is this a SiS?\n");
		pr_warn("If AUX port is really absent please use the 'i8042.noaux' option\n");
L
Linus Torvalds 已提交
791 792
	}

793
	if (i8042_toggle_aux(true))
L
Linus Torvalds 已提交
794 795
		return -1;

796 797 798 799 800 801 802 803 804 805
/*
 * Reset keyboard (needed on some laptops to successfully detect
 * touchpad, e.g., some Gigabyte laptop models with Elantech
 * touchpads).
 */
	if (i8042_kbdreset) {
		pr_warn("Attempting to reset device connected to KBD port\n");
		i8042_kbd_write(NULL, (unsigned char) 0xff);
	}

L
Linus Torvalds 已提交
806
/*
807 808
 * Test AUX IRQ delivery to make sure BIOS did not grab the IRQ and
 * used it for a PCI card or somethig else.
L
Linus Torvalds 已提交
809 810
 */

811
	if (i8042_noloop || i8042_bypass_aux_irq_test || aux_loop_broken) {
812 813 814 815 816 817 818
/*
 * Without LOOP command we can't test AUX IRQ delivery. Assume the port
 * is working and hope we are right.
 */
		retval = 0;
		goto out;
	}
L
Linus Torvalds 已提交
819

820 821 822
	if (request_irq(I8042_AUX_IRQ, i8042_aux_test_irq, IRQF_SHARED,
			"i8042", i8042_platform_device))
		goto out;
L
Linus Torvalds 已提交
823

824
	irq_registered = true;
825 826 827 828 829

	if (i8042_enable_aux_port())
		goto out;

	spin_lock_irqsave(&i8042_lock, flags);
L
Linus Torvalds 已提交
830

831
	init_completion(&i8042_aux_irq_delivered);
832
	i8042_irq_being_tested = true;
833 834 835 836 837 838 839 840

	param = 0xa5;
	retval = __i8042_command(&param, I8042_CMD_AUX_LOOP & 0xf0ff);

	spin_unlock_irqrestore(&i8042_lock, flags);

	if (retval)
		goto out;
L
Linus Torvalds 已提交
841

842 843
	if (wait_for_completion_timeout(&i8042_aux_irq_delivered,
					msecs_to_jiffies(250)) == 0) {
L
Linus Torvalds 已提交
844
/*
845 846
 * AUX IRQ was never delivered so we need to flush the controller to
 * get rid of the byte we put there; otherwise keyboard may not work.
L
Linus Torvalds 已提交
847
 */
848
		dbg("     -- i8042 (aux irq test timeout)\n");
849 850 851
		i8042_flush();
		retval = -1;
	}
L
Linus Torvalds 已提交
852

853
 out:
L
Linus Torvalds 已提交
854

855 856 857
/*
 * Disable the interface.
 */
L
Linus Torvalds 已提交
858

859 860
	i8042_ctr |= I8042_CTR_AUXDIS;
	i8042_ctr &= ~I8042_CTR_AUXINT;
L
Linus Torvalds 已提交
861

862 863
	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
		retval = -1;
L
Linus Torvalds 已提交
864

865 866
	if (irq_registered)
		free_irq(I8042_AUX_IRQ, i8042_platform_device);
L
Linus Torvalds 已提交
867

868 869
	return retval;
}
L
Linus Torvalds 已提交
870

871
static int i8042_controller_check(void)
L
Linus Torvalds 已提交
872
{
873
	if (i8042_flush()) {
874
		pr_err("No controller found\n");
875 876 877 878
		return -ENODEV;
	}

	return 0;
L
Linus Torvalds 已提交
879 880
}

881
static int i8042_controller_selftest(void)
882 883
{
	unsigned char param;
884
	int i = 0;
885

886 887 888 889 890 891 892
	/*
	 * We try this 5 times; on some really fragile systems this does not
	 * take the first time...
	 */
	do {

		if (i8042_command(&param, I8042_CMD_CTL_TEST)) {
893
			pr_err("i8042 controller selftest timeout\n");
894 895 896 897 898
			return -ENODEV;
		}

		if (param == I8042_RET_CTL_TEST)
			return 0;
899

900 901
		dbg("i8042 controller selftest: %#x != %#x\n",
		    param, I8042_RET_CTL_TEST);
902 903
		msleep(50);
	} while (i++ < 5);
904

905 906 907 908 909 910 911
#ifdef CONFIG_X86
	/*
	 * On x86, we don't fail entire i8042 initialization if controller
	 * reset fails in hopes that keyboard port will still be functional
	 * and user will still get a working keyboard. This is especially
	 * important on netbooks. On other arches we trust hardware more.
	 */
912
	pr_info("giving up on controller selftest, continuing anyway...\n");
913
	return 0;
914
#else
915
	pr_err("i8042 controller selftest failed\n");
916 917
	return -EIO;
#endif
918
}
L
Linus Torvalds 已提交
919 920 921 922 923 924 925 926 927 928

/*
 * i8042_controller init initializes the i8042 controller, and,
 * most importantly, sets it into non-xlated mode if that's
 * desired.
 */

static int i8042_controller_init(void)
{
	unsigned long flags;
929 930
	int n = 0;
	unsigned char ctr[2];
L
Linus Torvalds 已提交
931 932

/*
933
 * Save the CTR for restore on unload / reboot.
L
Linus Torvalds 已提交
934 935
 */

936 937
	do {
		if (n >= 10) {
938
			pr_err("Unable to get stable CTR read\n");
939 940 941 942 943 944 945
			return -EIO;
		}

		if (n != 0)
			udelay(50);

		if (i8042_command(&ctr[n++ % 2], I8042_CMD_CTL_RCTR)) {
946
			pr_err("Can't read CTR while initializing i8042\n");
947 948 949 950
			return -EIO;
		}

	} while (n < 2 || ctr[0] != ctr[1]);
L
Linus Torvalds 已提交
951

952
	i8042_initial_ctr = i8042_ctr = ctr[0];
L
Linus Torvalds 已提交
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968

/*
 * Disable the keyboard interface and interrupt.
 */

	i8042_ctr |= I8042_CTR_KBDDIS;
	i8042_ctr &= ~I8042_CTR_KBDINT;

/*
 * Handle keylock.
 */

	spin_lock_irqsave(&i8042_lock, flags);
	if (~i8042_read_status() & I8042_STR_KEYLOCK) {
		if (i8042_unlock)
			i8042_ctr |= I8042_CTR_IGNKEYLOCK;
969
		else
970
			pr_warn("Warning: Keylock active\n");
L
Linus Torvalds 已提交
971 972 973 974 975 976 977 978 979
	}
	spin_unlock_irqrestore(&i8042_lock, flags);

/*
 * If the chip is configured into nontranslated mode by the BIOS, don't
 * bother enabling translating and be happy.
 */

	if (~i8042_ctr & I8042_CTR_XLATE)
980
		i8042_direct = true;
L
Linus Torvalds 已提交
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996

/*
 * Set nontranslated mode for the kbd interface if requested by an option.
 * After this the kbd interface becomes a simple serial in/out, like the aux
 * interface is. We don't do this by default, since it can confuse notebook
 * BIOSes.
 */

	if (i8042_direct)
		i8042_ctr &= ~I8042_CTR_XLATE;

/*
 * Write CTR back.
 */

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
997
		pr_err("Can't write CTR while initializing i8042\n");
998
		return -EIO;
L
Linus Torvalds 已提交
999 1000
	}

1001 1002 1003 1004 1005 1006
/*
 * Flush whatever accumulated while we were disabling keyboard port.
 */

	i8042_flush();

L
Linus Torvalds 已提交
1007 1008 1009 1010 1011
	return 0;
}


/*
1012
 * Reset the controller and reset CRT to the original value set by BIOS.
L
Linus Torvalds 已提交
1013
 */
1014

1015
static void i8042_controller_reset(bool force_reset)
L
Linus Torvalds 已提交
1016
{
1017
	i8042_flush();
L
Linus Torvalds 已提交
1018

1019 1020 1021 1022 1023 1024 1025
/*
 * Disable both KBD and AUX interfaces so they don't get in the way
 */

	i8042_ctr |= I8042_CTR_KBDDIS | I8042_CTR_AUXDIS;
	i8042_ctr &= ~(I8042_CTR_KBDINT | I8042_CTR_AUXINT);

1026
	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
1027
		pr_warn("Can't write CTR while resetting\n");
1028

L
Linus Torvalds 已提交
1029 1030 1031 1032 1033
/*
 * Disable MUX mode if present.
 */

	if (i8042_mux_present)
1034
		i8042_set_mux_mode(false, NULL);
L
Linus Torvalds 已提交
1035 1036

/*
1037
 * Reset the controller if requested.
L
Linus Torvalds 已提交
1038 1039
 */

1040
	if (i8042_reset || force_reset)
1041
		i8042_controller_selftest();
L
Linus Torvalds 已提交
1042

1043 1044 1045 1046 1047
/*
 * Restore the original control register setting.
 */

	if (i8042_command(&i8042_initial_ctr, I8042_CMD_CTL_WCTR))
1048
		pr_warn("Can't restore CTR\n");
L
Linus Torvalds 已提交
1049 1050 1051 1052
}


/*
1053 1054
 * i8042_panic_blink() will turn the keyboard LEDs on or off and is called
 * when kernel panics. Flashing LEDs is useful for users running X who may
1055
 * not see the console and will help distinguishing panics from "real"
L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061 1062 1063
 * lockups.
 *
 * Note that DELAY has a limit of 10ms so we will not get stuck here
 * waiting for KBC to free up even if KBD interrupt is off
 */

#define DELAY do { mdelay(1); if (++delay > 10) return delay; } while(0)

1064
static long i8042_panic_blink(int state)
L
Linus Torvalds 已提交
1065 1066
{
	long delay = 0;
1067
	char led;
L
Linus Torvalds 已提交
1068

1069
	led = (state) ? 0x01 | 0x04 : 0;
L
Linus Torvalds 已提交
1070 1071
	while (i8042_read_status() & I8042_STR_IBF)
		DELAY;
1072
	dbg("%02x -> i8042 (panic blink)\n", 0xed);
1073
	i8042_suppress_kbd_ack = 2;
L
Linus Torvalds 已提交
1074 1075 1076 1077 1078
	i8042_write_data(0xed); /* set leds */
	DELAY;
	while (i8042_read_status() & I8042_STR_IBF)
		DELAY;
	DELAY;
1079
	dbg("%02x -> i8042 (panic blink)\n", led);
L
Linus Torvalds 已提交
1080 1081 1082 1083 1084 1085 1086
	i8042_write_data(led);
	DELAY;
	return delay;
}

#undef DELAY

1087 1088 1089
#ifdef CONFIG_X86
static void i8042_dritek_enable(void)
{
1090
	unsigned char param = 0x90;
1091 1092 1093 1094
	int error;

	error = i8042_command(&param, 0x1059);
	if (error)
1095
		pr_warn("Failed to enable DRITEK extension: %d\n", error);
1096 1097 1098
}
#endif

1099
#ifdef CONFIG_PM
1100

L
Linus Torvalds 已提交
1101
/*
1102 1103
 * Here we try to reset everything back to a state we had
 * before suspending.
L
Linus Torvalds 已提交
1104 1105
 */

1106
static int i8042_controller_resume(bool force_reset)
L
Linus Torvalds 已提交
1107
{
1108
	int error;
L
Linus Torvalds 已提交
1109

1110 1111 1112
	error = i8042_controller_check();
	if (error)
		return error;
1113

1114 1115 1116 1117 1118
	if (i8042_reset || force_reset) {
		error = i8042_controller_selftest();
		if (error)
			return error;
	}
L
Linus Torvalds 已提交
1119 1120

/*
1121
 * Restore original CTR value and disable all ports
L
Linus Torvalds 已提交
1122 1123
 */

1124 1125 1126
	i8042_ctr = i8042_initial_ctr;
	if (i8042_direct)
		i8042_ctr &= ~I8042_CTR_XLATE;
1127 1128 1129
	i8042_ctr |= I8042_CTR_AUXDIS | I8042_CTR_KBDDIS;
	i8042_ctr &= ~(I8042_CTR_AUXINT | I8042_CTR_KBDINT);
	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
1130
		pr_warn("Can't write CTR to resume, retrying...\n");
1131 1132
		msleep(50);
		if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
1133
			pr_err("CTR write retry failed\n");
1134 1135
			return -EIO;
		}
1136
	}
L
Linus Torvalds 已提交
1137

1138 1139 1140 1141 1142 1143

#ifdef CONFIG_X86
	if (i8042_dritek)
		i8042_dritek_enable();
#endif

1144
	if (i8042_mux_present) {
1145
		if (i8042_set_mux_mode(true, NULL) || i8042_enable_mux_ports())
1146
			pr_warn("failed to resume active multiplexor, mouse won't work\n");
1147 1148
	} else if (i8042_ports[I8042_AUX_PORT_NO].serio)
		i8042_enable_aux_port();
L
Linus Torvalds 已提交
1149

1150 1151 1152
	if (i8042_ports[I8042_KBD_PORT_NO].serio)
		i8042_enable_kbd_port();

1153
	i8042_interrupt(0, NULL);
L
Linus Torvalds 已提交
1154 1155 1156

	return 0;
}
1157

1158 1159 1160 1161 1162
/*
 * Here we try to restore the original BIOS settings to avoid
 * upsetting it.
 */

1163
static int i8042_pm_suspend(struct device *dev)
1164
{
1165
	i8042_controller_reset(true);
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

	return 0;
}

static int i8042_pm_resume(struct device *dev)
{
	/*
	 * On resume from S2R we always try to reset the controller
	 * to bring it in a sane state. (In case of S2D we expect
	 * BIOS to reset the controller for us.)
	 */
	return i8042_controller_resume(true);
}

1180 1181 1182 1183 1184 1185 1186
static int i8042_pm_thaw(struct device *dev)
{
	i8042_interrupt(0, NULL);

	return 0;
}

1187 1188 1189 1190 1191 1192 1193
static int i8042_pm_reset(struct device *dev)
{
	i8042_controller_reset(false);

	return 0;
}

1194 1195 1196 1197 1198
static int i8042_pm_restore(struct device *dev)
{
	return i8042_controller_resume(false);
}

1199
static const struct dev_pm_ops i8042_pm_ops = {
1200
	.suspend	= i8042_pm_suspend,
1201
	.resume		= i8042_pm_resume,
1202
	.thaw		= i8042_pm_thaw,
1203 1204 1205 1206
	.poweroff	= i8042_pm_reset,
	.restore	= i8042_pm_restore,
};

1207
#endif /* CONFIG_PM */
L
Linus Torvalds 已提交
1208 1209 1210 1211 1212 1213

/*
 * We need to reset the 8042 back to original mode on system shutdown,
 * because otherwise BIOSes will be confused.
 */

1214
static void i8042_shutdown(struct platform_device *dev)
L
Linus Torvalds 已提交
1215
{
1216
	i8042_controller_reset(false);
L
Linus Torvalds 已提交
1217 1218
}

1219
static int __init i8042_create_kbd_port(void)
L
Linus Torvalds 已提交
1220 1221 1222 1223
{
	struct serio *serio;
	struct i8042_port *port = &i8042_ports[I8042_KBD_PORT_NO];

1224
	serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
1225 1226 1227 1228 1229 1230 1231
	if (!serio)
		return -ENOMEM;

	serio->id.type		= i8042_direct ? SERIO_8042 : SERIO_8042_XL;
	serio->write		= i8042_dumbkbd ? NULL : i8042_kbd_write;
	serio->start		= i8042_start;
	serio->stop		= i8042_stop;
1232
	serio->close		= i8042_port_close;
1233 1234
	serio->port_data	= port;
	serio->dev.parent	= &i8042_platform_device->dev;
1235
	strlcpy(serio->name, "i8042 KBD port", sizeof(serio->name));
1236
	strlcpy(serio->phys, I8042_KBD_PHYS_DESC, sizeof(serio->phys));
1237 1238
	strlcpy(serio->firmware_id, i8042_kbd_firmware_id,
		sizeof(serio->firmware_id));
1239 1240

	port->serio = serio;
1241
	port->irq = I8042_KBD_IRQ;
1242

1243
	return 0;
L
Linus Torvalds 已提交
1244 1245
}

1246
static int __init i8042_create_aux_port(int idx)
L
Linus Torvalds 已提交
1247 1248
{
	struct serio *serio;
1249 1250
	int port_no = idx < 0 ? I8042_AUX_PORT_NO : I8042_MUX_PORT_NO + idx;
	struct i8042_port *port = &i8042_ports[port_no];
L
Linus Torvalds 已提交
1251

1252
	serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
1253 1254 1255 1256 1257 1258 1259 1260 1261
	if (!serio)
		return -ENOMEM;

	serio->id.type		= SERIO_8042;
	serio->write		= i8042_aux_write;
	serio->start		= i8042_start;
	serio->stop		= i8042_stop;
	serio->port_data	= port;
	serio->dev.parent	= &i8042_platform_device->dev;
1262 1263 1264
	if (idx < 0) {
		strlcpy(serio->name, "i8042 AUX port", sizeof(serio->name));
		strlcpy(serio->phys, I8042_AUX_PHYS_DESC, sizeof(serio->phys));
1265 1266
		strlcpy(serio->firmware_id, i8042_aux_firmware_id,
			sizeof(serio->firmware_id));
1267
		serio->close = i8042_port_close;
1268 1269 1270
	} else {
		snprintf(serio->name, sizeof(serio->name), "i8042 AUX%d port", idx);
		snprintf(serio->phys, sizeof(serio->phys), I8042_MUX_PHYS_DESC, idx + 1);
1271 1272
		strlcpy(serio->firmware_id, i8042_aux_firmware_id,
			sizeof(serio->firmware_id));
1273
	}
1274 1275

	port->serio = serio;
1276 1277
	port->mux = idx;
	port->irq = I8042_AUX_IRQ;
1278

1279
	return 0;
L
Linus Torvalds 已提交
1280 1281
}

1282
static void __init i8042_free_kbd_port(void)
L
Linus Torvalds 已提交
1283
{
1284 1285 1286
	kfree(i8042_ports[I8042_KBD_PORT_NO].serio);
	i8042_ports[I8042_KBD_PORT_NO].serio = NULL;
}
L
Linus Torvalds 已提交
1287

1288
static void __init i8042_free_aux_ports(void)
1289 1290
{
	int i;
1291

1292 1293 1294 1295 1296
	for (i = I8042_AUX_PORT_NO; i < I8042_NUM_PORTS; i++) {
		kfree(i8042_ports[i].serio);
		i8042_ports[i].serio = NULL;
	}
}
1297

1298
static void __init i8042_register_ports(void)
1299 1300
{
	int i;
1301

1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
	for (i = 0; i < I8042_NUM_PORTS; i++) {
		if (i8042_ports[i].serio) {
			printk(KERN_INFO "serio: %s at %#lx,%#lx irq %d\n",
				i8042_ports[i].serio->name,
				(unsigned long) I8042_DATA_REG,
				(unsigned long) I8042_COMMAND_REG,
				i8042_ports[i].irq);
			serio_register_port(i8042_ports[i].serio);
		}
	}
L
Linus Torvalds 已提交
1312 1313
}

B
Bill Pemberton 已提交
1314
static void i8042_unregister_ports(void)
L
Linus Torvalds 已提交
1315
{
1316
	int i;
L
Linus Torvalds 已提交
1317

1318 1319 1320 1321 1322 1323 1324 1325
	for (i = 0; i < I8042_NUM_PORTS; i++) {
		if (i8042_ports[i].serio) {
			serio_unregister_port(i8042_ports[i].serio);
			i8042_ports[i].serio = NULL;
		}
	}
}

1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
/*
 * Checks whether port belongs to i8042 controller.
 */
bool i8042_check_port_owner(const struct serio *port)
{
	int i;

	for (i = 0; i < I8042_NUM_PORTS; i++)
		if (i8042_ports[i].serio == port)
			return true;

	return false;
}
EXPORT_SYMBOL(i8042_check_port_owner);

1341 1342 1343 1344 1345 1346 1347
static void i8042_free_irqs(void)
{
	if (i8042_aux_irq_registered)
		free_irq(I8042_AUX_IRQ, i8042_platform_device);
	if (i8042_kbd_irq_registered)
		free_irq(I8042_KBD_IRQ, i8042_platform_device);

1348
	i8042_aux_irq_registered = i8042_kbd_irq_registered = false;
1349 1350
}

1351
static int __init i8042_setup_aux(void)
1352 1353 1354 1355
{
	int (*aux_enable)(void);
	int error;
	int i;
L
Linus Torvalds 已提交
1356

1357
	if (i8042_check_aux())
1358
		return -ENODEV;
L
Linus Torvalds 已提交
1359

1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
	if (i8042_nomux || i8042_check_mux()) {
		error = i8042_create_aux_port(-1);
		if (error)
			goto err_free_ports;
		aux_enable = i8042_enable_aux_port;
	} else {
		for (i = 0; i < I8042_NUM_MUX_PORTS; i++) {
			error = i8042_create_aux_port(i);
			if (error)
				goto err_free_ports;
1370
		}
1371
		aux_enable = i8042_enable_mux_ports;
L
Linus Torvalds 已提交
1372 1373
	}

1374 1375 1376 1377
	error = request_irq(I8042_AUX_IRQ, i8042_interrupt, IRQF_SHARED,
			    "i8042", i8042_platform_device);
	if (error)
		goto err_free_ports;
1378

1379 1380
	if (aux_enable())
		goto err_free_irq;
L
Linus Torvalds 已提交
1381

1382
	i8042_aux_irq_registered = true;
L
Linus Torvalds 已提交
1383
	return 0;
1384

1385 1386 1387 1388 1389 1390
 err_free_irq:
	free_irq(I8042_AUX_IRQ, i8042_platform_device);
 err_free_ports:
	i8042_free_aux_ports();
	return error;
}
1391

1392
static int __init i8042_setup_kbd(void)
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
{
	int error;

	error = i8042_create_kbd_port();
	if (error)
		return error;

	error = request_irq(I8042_KBD_IRQ, i8042_interrupt, IRQF_SHARED,
			    "i8042", i8042_platform_device);
	if (error)
		goto err_free_port;

	error = i8042_enable_kbd_port();
	if (error)
		goto err_free_irq;

1409
	i8042_kbd_irq_registered = true;
1410 1411 1412 1413 1414 1415 1416
	return 0;

 err_free_irq:
	free_irq(I8042_KBD_IRQ, i8042_platform_device);
 err_free_port:
	i8042_free_kbd_port();
	return error;
L
Linus Torvalds 已提交
1417 1418
}

1419
static int __init i8042_probe(struct platform_device *dev)
L
Linus Torvalds 已提交
1420
{
1421
	int error;
L
Linus Torvalds 已提交
1422

1423 1424
	i8042_platform_device = dev;

1425 1426 1427 1428 1429
	if (i8042_reset) {
		error = i8042_controller_selftest();
		if (error)
			return error;
	}
L
Linus Torvalds 已提交
1430

1431 1432 1433 1434
	error = i8042_controller_init();
	if (error)
		return error;

1435 1436 1437 1438 1439
#ifdef CONFIG_X86
	if (i8042_dritek)
		i8042_dritek_enable();
#endif

1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
	if (!i8042_noaux) {
		error = i8042_setup_aux();
		if (error && error != -ENODEV && error != -EBUSY)
			goto out_fail;
	}

	if (!i8042_nokbd) {
		error = i8042_setup_kbd();
		if (error)
			goto out_fail;
	}
/*
 * Ok, everything is ready, let's register all serio ports
 */
	i8042_register_ports();

	return 0;

 out_fail:
	i8042_free_aux_ports();	/* in case KBD failed but AUX not */
	i8042_free_irqs();
1461
	i8042_controller_reset(false);
1462
	i8042_platform_device = NULL;
1463 1464 1465 1466

	return error;
}

B
Bill Pemberton 已提交
1467
static int i8042_remove(struct platform_device *dev)
1468 1469 1470
{
	i8042_unregister_ports();
	i8042_free_irqs();
1471
	i8042_controller_reset(false);
1472
	i8042_platform_device = NULL;
L
Linus Torvalds 已提交
1473

1474 1475 1476 1477 1478 1479
	return 0;
}

static struct platform_driver i8042_driver = {
	.driver		= {
		.name	= "i8042",
1480 1481 1482
#ifdef CONFIG_PM
		.pm	= &i8042_pm_ops,
#endif
1483
	},
B
Bill Pemberton 已提交
1484
	.remove		= i8042_remove,
1485
	.shutdown	= i8042_shutdown,
1486 1487 1488 1489
};

static int __init i8042_init(void)
{
1490
	struct platform_device *pdev;
1491 1492 1493 1494 1495 1496 1497 1498
	int err;

	dbg_init();

	err = i8042_platform_init();
	if (err)
		return err;

1499 1500 1501
	err = i8042_controller_check();
	if (err)
		goto err_platform_exit;
1502

1503 1504 1505
	pdev = platform_create_bundle(&i8042_driver, i8042_probe, NULL, 0, NULL, 0);
	if (IS_ERR(pdev)) {
		err = PTR_ERR(pdev);
1506
		goto err_platform_exit;
1507 1508
	}

1509 1510
	panic_blink = i8042_panic_blink;

1511 1512 1513 1514 1515 1516 1517 1518 1519
	return 0;

 err_platform_exit:
	i8042_platform_exit();
	return err;
}

static void __exit i8042_exit(void)
{
1520
	platform_device_unregister(i8042_platform_device);
1521
	platform_driver_unregister(&i8042_driver);
L
Linus Torvalds 已提交
1522 1523 1524 1525 1526 1527 1528
	i8042_platform_exit();

	panic_blink = NULL;
}

module_init(i8042_init);
module_exit(i8042_exit);