i8042.c 23.1 KB
Newer Older
1 2
/*
 *  i8042 keyboard and mouse controller driver for Linux
3 4
 *
 *  Copyright (c) 1999-2002 Vojtech Pavlik
5 6 7
 */

/*
8 9 10
 * 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.
11 12 13 14
 */

#include <linux/delay.h>
#include <linux/module.h>
15
#include <linux/moduleparam.h>
16
#include <linux/interrupt.h>
17 18 19 20
#include <linux/ioport.h>
#include <linux/config.h>
#include <linux/reboot.h>
#include <linux/init.h>
21 22
#include <linux/sysdev.h>
#include <linux/pm.h>
23
#include <linux/serio.h>
24 25

#include <asm/io.h>
26

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

31
static unsigned int i8042_noaux;
32 33
module_param_named(noaux, i8042_noaux, bool, 0);
MODULE_PARM_DESC(noaux, "Do not probe or use AUX (mouse) port.");
34

35
static unsigned int i8042_nomux;
36 37
module_param_named(nomux, i8042_nomux, bool, 0);
MODULE_PARM_DESC(nomux, "Do not check whether an active multiplexing conrtoller is present.");
38 39

static unsigned int i8042_unlock;
40 41
module_param_named(unlock, i8042_unlock, bool, 0);
MODULE_PARM_DESC(unlock, "Ignore keyboard lock.");
42 43

static unsigned int i8042_reset;
44 45
module_param_named(reset, i8042_reset, bool, 0);
MODULE_PARM_DESC(reset, "Reset controller during init and cleanup.");
46 47

static unsigned int i8042_direct;
48 49
module_param_named(direct, i8042_direct, bool, 0);
MODULE_PARM_DESC(direct, "Put keyboard port into non-translated mode.");
50 51

static unsigned int i8042_dumbkbd;
52 53
module_param_named(dumbkbd, i8042_dumbkbd, bool, 0);
MODULE_PARM_DESC(dumbkbd, "Pretend that controller can only read data from keyboard");
54

55 56 57 58 59 60 61
__obsolete_setup("i8042_noaux");
__obsolete_setup("i8042_nomux");
__obsolete_setup("i8042_unlock");
__obsolete_setup("i8042_reset");
__obsolete_setup("i8042_direct");
__obsolete_setup("i8042_dumbkbd");

62 63 64
#undef DEBUG
#include "i8042.h"

65 66 67 68 69 70 71
spinlock_t i8042_lock = SPIN_LOCK_UNLOCKED;

struct i8042_values {
	int irq;
	unsigned char disable;
	unsigned char irqen;
	unsigned char exists;
72
	signed char mux;
73 74 75 76 77 78 79 80
	unsigned char *name;
	unsigned char *phys;
};

static struct serio i8042_kbd_port;
static struct serio i8042_aux_port;
static unsigned char i8042_initial_ctr;
static unsigned char i8042_ctr;
81
static unsigned char i8042_mux_open;
82 83 84
static unsigned char i8042_mux_present;
static unsigned char i8042_sysdev_initialized;
static struct pm_dev *i8042_pm_dev;
85
struct timer_list i8042_timer;
86

87 88 89 90 91 92
/*
 * Shared IRQ's require a device pointer, but this driver doesn't support
 * multiple devices
 */
#define i8042_request_irq_cookie (&i8042_timer)

93
static irqreturn_t i8042_interrupt(int irq, void *dev_id, struct pt_regs *regs);
94 95 96 97 98 99 100 101 102

/*
 * 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.
 */

static int i8042_wait_read(void)
{
	int i = 0;
103
	while ((~i8042_read_status() & I8042_STR_OBF) && (i < I8042_CTL_TIMEOUT)) {
104 105 106 107 108 109 110 111 112
		udelay(50);
		i++;
	}
	return -(i == I8042_CTL_TIMEOUT);
}

static int i8042_wait_write(void)
{
	int i = 0;
113
	while ((i8042_read_status() & I8042_STR_IBF) && (i < I8042_CTL_TIMEOUT)) {
114 115 116 117 118 119 120 121 122 123 124 125 126 127
		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;
128
	unsigned char data;
129 130 131 132
	int i = 0;

	spin_lock_irqsave(&i8042_lock, flags);

133 134 135 136 137
	while ((i8042_read_status() & I8042_STR_OBF) && (i++ < I8042_BUFFER_SIZE)) {
		data = i8042_read_data();
		dbg("%02x <- i8042 (flush, %s)", data,
			i8042_read_status() & I8042_STR_AUXDATA ? "aux" : "kbd");
	}
138 139 140 141 142 143 144

	spin_unlock_irqrestore(&i8042_lock, flags);

	return i;
}

/*
145 146 147 148 149
 * 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.
150 151 152
 */

static int i8042_command(unsigned char *param, int command)
153
{
154 155 156 157 158 159 160
	unsigned long flags;
	int retval = 0, i = 0;

	spin_lock_irqsave(&i8042_lock, flags);

	retval = i8042_wait_write();
	if (!retval) {
161
		dbg("%02x -> i8042 (command)", command & 0xff);
162
		i8042_write_command(command & 0xff);
163
	}
164

165 166 167
	if (!retval)
		for (i = 0; i < ((command >> 12) & 0xf); i++) {
			if ((retval = i8042_wait_write())) break;
168
			dbg("%02x -> i8042 (parameter)", param[i]);
169
			i8042_write_data(param[i]);
170 171 172 173 174
		}

	if (!retval)
		for (i = 0; i < ((command >> 8) & 0xf); i++) {
			if ((retval = i8042_wait_read())) break;
175
			if (i8042_read_status() & I8042_STR_AUXDATA)
176
				param[i] = ~i8042_read_data();
177
			else
178
				param[i] = i8042_read_data();
179
			dbg("%02x <- i8042 (return)", param[i]);
180 181 182 183 184
		}

	spin_unlock_irqrestore(&i8042_lock, flags);

	if (retval)
185
		dbg("     -- i8042 (timeout)");
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201

	return retval;
}

/*
 * 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);

	if(!(retval = i8042_wait_write())) {
202
		dbg("%02x -> i8042 (kbd-data)", c);
203
		i8042_write_data(c);
204 205 206 207 208 209 210 211 212 213 214 215 216
	}

	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 *port, unsigned char c)
{
217
	struct i8042_values *values = port->driver;
218 219 220 221 222 223
	int retval;

/*
 * Send the byte out.
 */

224 225 226 227
	if (values->mux == -1)
		retval = i8042_command(&c, I8042_CMD_AUX_SEND);
	else
		retval = i8042_command(&c, I8042_CMD_MUX_SEND + values->mux);
228 229 230 231 232 233 234

/*
 * Make sure the interrupt happens and the character is received even
 * in the case the IRQ isn't wired, so that we can receive further
 * characters later.
 */

235
	i8042_interrupt(0, NULL, NULL);
236 237 238 239
	return retval;
}

/*
240
 * i8042_activate_port() enables port on a chip.
241 242
 */

243
static int i8042_activate_port(struct serio *port)
244 245 246
{
	struct i8042_values *values = port->driver;

247
	i8042_flush();
248

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
	/*
	 * Enable port again here because it is disabled if we are
	 * resuming (normally it is enabled already).
	 */
	i8042_ctr &= ~values->disable;

	i8042_ctr |= values->irqen;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
		i8042_ctr &= ~values->irqen;
		return -1;
	}

	return 0;
}


/*
 * i8042_open() is called when a port is open by the higher layer.
 * It allocates the interrupt and calls i8042_enable_port.
 */

static int i8042_open(struct serio *port)
{
	struct i8042_values *values = port->driver;

275 276 277 278
	if (values->mux != -1)
		if (i8042_mux_open++)
			return 0;

279 280
	if (request_irq(values->irq, i8042_interrupt,
			SA_SHIRQ, "i8042", i8042_request_irq_cookie)) {
281
		printk(KERN_ERR "i8042.c: Can't get irq %d for %s, unregistering the port.\n", values->irq, values->name);
282
		goto irq_fail;
283 284
	}

285 286 287
	if (i8042_activate_port(port)) {
		printk(KERN_ERR "i8042.c: Can't activate %s, unregistering the port\n", values->name);
		goto activate_fail;
288 289
	}

290 291
	i8042_interrupt(0, NULL, NULL);

292
	return 0;
293

294
activate_fail:
295 296 297 298
	free_irq(values->irq, i8042_request_irq_cookie);

irq_fail:
	values->exists = 0;
299
	serio_unregister_port_delayed(port);
300 301

	return -1;
302 303 304
}

/*
305 306
 * i8042_close() frees the interrupt, so that it can possibly be used
 * by another driver. We never know - if the user doesn't have a mouse,
307
 * the BIOS could have used the AUX interrupt for PCI.
308 309 310 311 312 313
 */

static void i8042_close(struct serio *port)
{
	struct i8042_values *values = port->driver;

314 315 316 317
	if (values->mux != -1)
		if (--i8042_mux_open)
			return;

318 319 320 321 322 323 324
	i8042_ctr &= ~values->irqen;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
		printk(KERN_ERR "i8042.c: Can't write CTR while closing %s.\n", values->name);
		return;
	}

325
	free_irq(values->irq, i8042_request_irq_cookie);
326 327

	i8042_flush();
328 329 330 331 332 333 334
}

/*
 * Structures for registering the devices in the serio.c module.
 */

static struct i8042_values i8042_kbd_values = {
335 336 337
	.irqen =	I8042_CTR_KBDINT,
	.disable =	I8042_CTR_KBDDIS,
	.name =		"KBD",
338
	.mux =		-1,
339 340 341 342
};

static struct serio i8042_kbd_port =
{
343
	.type =		SERIO_8042_XL,
344 345 346 347 348 349
	.write =	i8042_kbd_write,
	.open =		i8042_open,
	.close =	i8042_close,
	.driver =	&i8042_kbd_values,
	.name =		"i8042 Kbd Port",
	.phys =		I8042_KBD_PHYS_DESC,
350 351 352
};

static struct i8042_values i8042_aux_values = {
353 354 355
	.irqen =	I8042_CTR_AUXINT,
	.disable =	I8042_CTR_AUXDIS,
	.name =		"AUX",
356
	.mux =		-1,
357 358 359 360
};

static struct serio i8042_aux_port =
{
361 362 363 364 365 366 367
	.type =		SERIO_8042,
	.write =	i8042_aux_write,
	.open =		i8042_open,
	.close =	i8042_close,
	.driver =	&i8042_aux_values,
	.name =		"i8042 Aux Port",
	.phys =		I8042_AUX_PHYS_DESC,
368 369
};

370 371
static struct i8042_values i8042_mux_values[4];
static struct serio i8042_mux_port[4];
372 373
static char i8042_mux_names[4][32];
static char i8042_mux_short[4][16];
374 375
static char i8042_mux_phys[4][32];

376
/*
377 378 379
 * 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.
380 381
 */

382
static irqreturn_t i8042_interrupt(int irq, void *dev_id, struct pt_regs *regs)
383
{
384
	unsigned long flags;
385
	unsigned char str, data = 0;
386
	unsigned int dfl;
387
	int ret;
388

389
	mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
390

391 392 393 394 395
	spin_lock_irqsave(&i8042_lock, flags);
	str = i8042_read_status();
	if (str & I8042_STR_OBF)
		data = i8042_read_data();
	spin_unlock_irqrestore(&i8042_lock, flags);
396

397 398 399 400
	if (~str & I8042_STR_OBF) {
		if (irq) dbg("Interrupt %d, without any data", irq);
		ret = 0;
		goto out;
401
	}
402

403 404
	dfl = ((str & I8042_STR_PARITY) ? SERIO_PARITY : 0) |
	      ((str & I8042_STR_TIMEOUT) ? SERIO_TIMEOUT : 0);
405

406
	if (i8042_mux_values[0].exists && (str & I8042_STR_AUXDATA)) {
407

408 409 410 411 412 413 414 415
		if (str & I8042_STR_MUXERR) {
			switch (data) {
				case 0xfd:
				case 0xfe: dfl = SERIO_TIMEOUT; break;
				case 0xff: dfl = SERIO_PARITY; break;
			}
			data = 0xfe;
		} else dfl = 0;
416

417 418 419 420
		dbg("%02x <- i8042 (interrupt, aux%d, %d%s%s)",
			data, (str >> 6), irq,
			dfl & SERIO_PARITY ? ", bad parity" : "",
			dfl & SERIO_TIMEOUT ? ", timeout" : "");
421

422
		serio_interrupt(i8042_mux_port + ((str >> 6) & 3), data, dfl, regs);
423

424
		goto irq_ret;
425 426
	}

427 428 429 430
	dbg("%02x <- i8042 (interrupt, %s, %d%s%s)",
		data, (str & I8042_STR_AUXDATA) ? "aux" : "kbd", irq,
		dfl & SERIO_PARITY ? ", bad parity" : "",
		dfl & SERIO_TIMEOUT ? ", timeout" : "");
431

432 433 434
	if (i8042_aux_values.exists && (str & I8042_STR_AUXDATA)) {
		serio_interrupt(&i8042_aux_port, data, dfl, regs);
		goto irq_ret;
435 436
	}

437 438
	if (!i8042_kbd_values.exists)
		goto irq_ret;
439

440
	serio_interrupt(&i8042_kbd_port, data, dfl, regs);
441

442 443 444 445 446
irq_ret:
	ret = 1;
out:
	return IRQ_RETVAL(ret);
}
447

448
/*
449 450 451
 * i8042_enable_mux_mode checks whether the controller has an active
 * multiplexor and puts the chip into Multiplexed (as opposed to
 * Legacy) mode.
452
 */
453 454

static int i8042_enable_mux_mode(struct i8042_values *values, unsigned char *mux_version)
455 456
{

457
	unsigned char param;
458
/*
459
 * Get rid of bytes in the queue.
460 461 462 463 464
 */

	i8042_flush();

/*
465 466 467
 * Internal loopback test - send three bytes, they should come back from the
 * mouse interface, the last should be version. Note that we negate mouseport
 * command responses for the i8042_check_aux() routine.
468 469
 */

470 471
	param = 0xf0;
	if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0x0f)
472
		return -1;
473 474
	param = 0x56;
	if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xa9)
475
		return -1;
476
	param = 0xa4;
477 478 479 480 481 482 483 484 485
	if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param == 0x5b) {

/*
 * Do another loop test with the 0x5a value. Doing anything else upsets
 * Profusion/ServerWorks OSB4 chipsets.
 */

		param = 0x5a;
		i8042_command(&param, I8042_CMD_AUX_LOOP);
486
		return -1;
487
	}
488 489 490

	if (mux_version)
		*mux_version = ~param;
491 492 493 494

	return 0;
}

495

496
/*
497 498
 * i8042_enable_mux_ports enables 4 individual AUX ports after
 * the controller has been switched into Multiplexed mode
499 500
 */

501
static int i8042_enable_mux_ports(struct i8042_values *values)
502
{
503
	unsigned char param;
504
	int i;
505
/*
506
 * Disable all muxed ports by disabling AUX.
507 508
 */

509 510
	i8042_ctr |= I8042_CTR_AUXDIS;
	i8042_ctr &= ~I8042_CTR_AUXINT;
511

512 513 514
	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
		printk(KERN_ERR "i8042.c: Failed to disable AUX port, can't use MUX.\n");
		return -1;
515 516 517
	}

/*
518
 * Enable all muxed ports.
519 520
 */

521 522 523 524
	for (i = 0; i < 4; i++) {
		i8042_command(&param, I8042_CMD_MUX_PFX + i);
		i8042_command(&param, I8042_CMD_AUX_ENABLE);
	}
525

526
	return 0;
527 528
}

529

530
/*
531 532 533
 * i8042_check_mux() checks whether the controller supports the PS/2 Active
 * Multiplexing specification by Synaptics, Phoenix, Insyde and
 * LCS/Telegraphics.
534 535
 */

536 537
static int __init i8042_check_mux(struct i8042_values *values)
{
538
	unsigned char mux_version;
539

540
	if (i8042_enable_mux_mode(values, &mux_version))
541
		return -1;
542

543
	/* Workaround for broken chips which seem to support MUX, but in reality don't. */
544 545
	/* They all report version 10.12 */
	if (mux_version == 0xAC)
546
		return -1;
547

548
	printk(KERN_INFO "i8042.c: Detected active multiplexing controller, rev %d.%d.\n",
549
		(mux_version >> 4) & 0xf, mux_version & 0xf);
550

551
	if (i8042_enable_mux_ports(values))
552 553
		return -1;

554
	i8042_mux_present = 1;
555
	return 0;
556 557
}

558

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

564
static int __init i8042_check_aux(struct i8042_values *values)
565 566
{
	unsigned char param;
567
	static int i8042_check_aux_cookie;
568

569 570 571 572 573
/*
 * Check if AUX irq is available. If it isn't, then there is no point
 * in trying to detect AUX presence.
 */

574
	if (request_irq(values->irq, i8042_interrupt, SA_SHIRQ,
575
				"i8042", &i8042_check_aux_cookie))
576
                return -1;
577
	free_irq(values->irq, &i8042_check_aux_cookie);
578 579 580 581 582

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

583 584 585
	i8042_flush();

/*
586 587 588
 * 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.
589 590 591
 */

	param = 0x5a;
592
	if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xa5) {
593 594 595

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

602 603 604 605
		if (i8042_command(&param, I8042_CMD_AUX_TEST)
		    	|| (param && param != 0xfa && param != 0xff))
				return -1;
	}
606 607 608 609

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

611 612
	if (i8042_command(&param, I8042_CMD_AUX_DISABLE))
		return -1;
Andrew Morton's avatar
Andrew Morton committed
613 614 615 616
	if (i8042_command(&param, I8042_CMD_CTL_RCTR) || (~param & I8042_CTR_AUXDIS)) {
		printk(KERN_WARNING "Failed to disable AUX port, but continuing anyway... Is this a SiS?\n");
		printk(KERN_WARNING "If AUX port is really absent please use the 'i8042.noaux' option.\n");
	}
617 618 619 620

	if (i8042_command(&param, I8042_CMD_AUX_ENABLE))
		return -1;
	if (i8042_command(&param, I8042_CMD_CTL_RCTR) || (param & I8042_CTR_AUXDIS))
621
		return -1;
622 623 624 625 626 627 628 629 630 631 632 633 634 635

/*
 * Disable the interface.
 */

	i8042_ctr |= I8042_CTR_AUXDIS;
	i8042_ctr &= ~I8042_CTR_AUXINT;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
		return -1;

	return 0;
}

636

637 638 639 640 641 642 643 644
/*
 * i8042_port_register() marks the device as existing,
 * registers it, and reports to the user.
 */

static int __init i8042_port_register(struct i8042_values *values, struct serio *port)
{
	values->exists = 1;
645 646 647 648 649

	i8042_ctr &= ~values->disable;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
		printk(KERN_WARNING "i8042.c: Can't write CTR while registering.\n");
650
		values->exists = 0;
651
		return -1;
652 653
	}

654 655 656 657 658
	printk(KERN_INFO "serio: i8042 %s port at %#lx,%#lx irq %d\n",
	       values->name,
	       (unsigned long) I8042_DATA_REG,
	       (unsigned long) I8042_COMMAND_REG,
	       values->irq);
659

660 661
	serio_register_port(port);

662 663 664
	return 0;
}

665

666 667 668 669 670
static void i8042_timer_func(unsigned long data)
{
	i8042_interrupt(0, NULL, NULL);
}

671 672 673 674 675 676 677 678

/*
 * 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)
679
{
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732

/*
 * Test the i8042. We need to know if it thinks it's working correctly
 * before doing anything else.
 */

	i8042_flush();

	if (i8042_reset) {

		unsigned char param;

		if (i8042_command(&param, I8042_CMD_CTL_TEST)) {
			printk(KERN_ERR "i8042.c: i8042 controller self test timeout.\n");
			return -1;
		}

		if (param != I8042_RET_CTL_TEST) {
			printk(KERN_ERR "i8042.c: i8042 controller selftest failed. (%#x != %#x)\n",
				 param, I8042_RET_CTL_TEST);
			return -1;
		}
	}

/*
 * Save the CTR for restoral on unload / reboot.
 */

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_RCTR)) {
		printk(KERN_ERR "i8042.c: Can't read CTR while initializing i8042.\n");
		return -1;
	}

	i8042_initial_ctr = i8042_ctr;

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

	i8042_ctr |= I8042_CTR_KBDDIS;
	i8042_ctr &= ~I8042_CTR_KBDINT;

/*
 * Handle keylock.
 */

	if (~i8042_read_status() & I8042_STR_KEYLOCK) {
		if (i8042_unlock)
			i8042_ctr |= I8042_CTR_IGNKEYLOCK;
		 else
			printk(KERN_WARNING "i8042.c: Warning: Keylock active.\n");
	}

733 734 735 736 737 738 739 740
/*
 * 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)
		i8042_direct = 1;

741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
/*
 * 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;
		i8042_kbd_port.type = SERIO_8042;
	}

/*
 * Write CTR back.
 */

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
		printk(KERN_ERR "i8042.c: Can't write CTR while initializing i8042.\n");
		return -1;
	}

	return 0;
763
}
764 765


Andrew Morton's avatar
Andrew Morton committed
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
/*
 * Reset the controller.
 */
void i8042_controller_reset(void)
{
	if (i8042_reset) {
		unsigned char param;

		if (i8042_command(&param, I8042_CMD_CTL_TEST))
			printk(KERN_ERR "i8042.c: i8042 controller reset timeout.\n");
	}

/*
 * Restore the original control register setting.
 */

	i8042_ctr = i8042_initial_ctr;

	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
		printk(KERN_WARNING "i8042.c: Can't restore CTR.\n");
}


789 790 791 792 793 794
/*
 * Here we try to reset everything back to a state in which the BIOS will be
 * able to talk to the hardware when rebooting.
 */

void i8042_controller_cleanup(void)
795
{
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
	int i;

	i8042_flush();

/*
 * Reset anything that is connected to the ports.
 */

	if (i8042_kbd_values.exists)
		serio_cleanup(&i8042_kbd_port);

	if (i8042_aux_values.exists)
		serio_cleanup(&i8042_aux_port);

	for (i = 0; i < 4; i++)
		if (i8042_mux_values[i].exists)
			serio_cleanup(i8042_mux_port + i);

Andrew Morton's avatar
Andrew Morton committed
814 815
	i8042_controller_reset();
}
816 817 818


/*
Andrew Morton's avatar
Andrew Morton committed
819
 * Here we try to restore the original BIOS settings
820 821
 */

Andrew Morton's avatar
Andrew Morton committed
822 823 824 825
static int i8042_controller_suspend(void)
{
	del_timer_sync(&i8042_timer);
	i8042_controller_reset();
826

Andrew Morton's avatar
Andrew Morton committed
827
	return 0;
828
}
829 830 831 832 833 834 835


/*
 * Here we try to reset everything back to a state in which suspended
 */

static int i8042_controller_resume(void)
836
{
837 838 839 840 841 842 843 844 845 846
	int i;

	if (i8042_controller_init()) {
		printk(KERN_ERR "i8042: resume failed\n");
		return -1;
	}

	if (i8042_mux_present)
		if (i8042_enable_mux_mode(&i8042_aux_values, NULL) ||
		    i8042_enable_mux_ports(&i8042_aux_values)) {
Andrew Morton's avatar
Andrew Morton committed
847
			printk(KERN_WARNING "i8042: failed to resume active multiplexor, mouse won't work.\n");
848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
		}

/*
 * Reconnect anything that was connected to the ports.
 */

	if (i8042_kbd_values.exists && i8042_activate_port(&i8042_kbd_port) == 0)
		serio_reconnect(&i8042_kbd_port);

	if (i8042_aux_values.exists && i8042_activate_port(&i8042_aux_port) == 0)
		serio_reconnect(&i8042_aux_port);

	for (i = 0; i < 4; i++)
		if (i8042_mux_values[i].exists && i8042_activate_port(i8042_mux_port + i) == 0)
			serio_reconnect(i8042_mux_port + i);
Andrew Morton's avatar
Andrew Morton committed
863 864 865 866
/*
 * Restart timer (for polling "stuck" data)
 */
	mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
867 868

	return 0;
869 870
}

871 872

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

877 878 879
static int i8042_notify_sys(struct notifier_block *this, unsigned long code,
        		    void *unused)
{
880
        if (code == SYS_DOWN || code == SYS_HALT)
881 882 883 884 885 886 887 888 889 890 891
        	i8042_controller_cleanup();
        return NOTIFY_DONE;
}

static struct notifier_block i8042_notifier=
{
        i8042_notify_sys,
        NULL,
        0
};

892
/*
Andrew Morton's avatar
Andrew Morton committed
893
 * Suspend/resume handlers for the new PM scheme (driver model)
894
 */
Andrew Morton's avatar
Andrew Morton committed
895 896 897 898 899
static int i8042_suspend(struct sys_device *dev, u32 state)
{
	return i8042_controller_suspend();
}

900 901 902 903 904 905
static int i8042_resume(struct sys_device *dev)
{
	return i8042_controller_resume();
}

static struct sysdev_class kbc_sysclass = {
Andrew Morton's avatar
Andrew Morton committed
906 907 908
	set_kset_name("i8042"),
	.suspend = i8042_suspend,
	.resume = i8042_resume,
909 910 911 912 913 914 915 916
};

static struct sys_device device_i8042 = {
       .id     = 0,
       .cls    = &kbc_sysclass,
};

/*
Andrew Morton's avatar
Andrew Morton committed
917
 * Suspend/resume handler for the old PM scheme (APM)
918 919 920
 */
static int i8042_pm_callback(struct pm_dev *dev, pm_request_t request, void *dummy)
{
Andrew Morton's avatar
Andrew Morton committed
921 922 923 924 925 926 927
	switch (request) {
		case PM_SUSPEND:
			return i8042_controller_suspend();

		case PM_RESUME:
			return i8042_controller_resume();
	}
928 929 930 931

	return 0;
}

932 933 934 935 936 937 938 939 940
static void __init i8042_init_mux_values(struct i8042_values *values, struct serio *port, int index)
{
	memcpy(port, &i8042_aux_port, sizeof(struct serio));
	memcpy(values, &i8042_aux_values, sizeof(struct i8042_values));
	sprintf(i8042_mux_names[index], "i8042 Aux-%d Port", index);
	sprintf(i8042_mux_phys[index], I8042_MUX_PHYS_DESC, index + 1);
	sprintf(i8042_mux_short[index], "AUX%d", index);
	port->name = i8042_mux_names[index];
	port->phys = i8042_mux_phys[index];
941
	port->driver = values;
942 943 944 945
	values->name = i8042_mux_short[index];
	values->mux = index;
}

946 947
int __init i8042_init(void)
{
948
	int i;
949

950
	dbg_init();
951

952 953 954
	init_timer(&i8042_timer);
	i8042_timer.function = i8042_timer_func;

955
	if (i8042_platform_init())
956 957
		return -EBUSY;

958 959
	i8042_aux_values.irq = I8042_AUX_IRQ;
	i8042_kbd_values.irq = I8042_KBD_IRQ;
960

961 962
	if (i8042_controller_init())
		return -ENODEV;
963 964 965 966

	if (i8042_dumbkbd)
		i8042_kbd_port.write = NULL;

967 968 969 970 971 972 973
	if (!i8042_noaux && !i8042_check_aux(&i8042_aux_values)) {
		if (!i8042_nomux && !i8042_check_mux(&i8042_aux_values))
			for (i = 0; i < 4; i++) {
				i8042_init_mux_values(i8042_mux_values + i, i8042_mux_port + i, i);
				i8042_port_register(i8042_mux_values + i, i8042_mux_port + i);
			}
		else
974
			i8042_port_register(&i8042_aux_values, &i8042_aux_port);
975
	}
976

977 978 979
	i8042_port_register(&i8042_kbd_values, &i8042_kbd_port);

	mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
980

981
        if (sysdev_class_register(&kbc_sysclass) == 0) {
982
                if (sysdev_register(&device_i8042) == 0)
983 984 985 986 987 988 989
			i8042_sysdev_initialized = 1;
		else
			sysdev_class_unregister(&kbc_sysclass);
        }

	i8042_pm_dev = pm_register(PM_SYS_DEV, PM_SYS_UNKNOWN, i8042_pm_callback);

990
	register_reboot_notifier(&i8042_notifier);
991

992 993 994 995 996
	return 0;
}

void __exit i8042_exit(void)
{
997 998
	int i;

999
	unregister_reboot_notifier(&i8042_notifier);
1000

1001 1002 1003 1004
	if (i8042_pm_dev)
		pm_unregister(i8042_pm_dev);

	if (i8042_sysdev_initialized) {
1005
		sysdev_unregister(&device_i8042);
1006 1007 1008
		sysdev_class_unregister(&kbc_sysclass);
	}

1009
	i8042_controller_cleanup();
1010

1011 1012 1013 1014 1015
	if (i8042_kbd_values.exists)
		serio_unregister_port(&i8042_kbd_port);

	if (i8042_aux_values.exists)
		serio_unregister_port(&i8042_aux_port);
1016

1017 1018 1019
	for (i = 0; i < 4; i++)
		if (i8042_mux_values[i].exists)
			serio_unregister_port(i8042_mux_port + i);
Dmitry Torokhov's avatar
Dmitry Torokhov committed
1020
	del_timer_sync(&i8042_timer);
1021

1022
	i8042_platform_exit();
1023 1024 1025 1026
}

module_init(i8042_init);
module_exit(i8042_exit);