Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * i8042 keyboard and mouse controller driver for Linux
4 : : *
5 : : * Copyright (c) 1999-2004 Vojtech Pavlik
6 : : */
7 : :
8 : :
9 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 : :
11 : : #include <linux/types.h>
12 : : #include <linux/delay.h>
13 : : #include <linux/module.h>
14 : : #include <linux/interrupt.h>
15 : : #include <linux/ioport.h>
16 : : #include <linux/init.h>
17 : : #include <linux/serio.h>
18 : : #include <linux/err.h>
19 : : #include <linux/rcupdate.h>
20 : : #include <linux/platform_device.h>
21 : : #include <linux/i8042.h>
22 : : #include <linux/slab.h>
23 : : #include <linux/suspend.h>
24 : :
25 : : #include <asm/io.h>
26 : :
27 : : MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
28 : : MODULE_DESCRIPTION("i8042 keyboard and mouse controller driver");
29 : : MODULE_LICENSE("GPL");
30 : :
31 : : static bool i8042_nokbd;
32 : : module_param_named(nokbd, i8042_nokbd, bool, 0);
33 : : MODULE_PARM_DESC(nokbd, "Do not probe or use KBD port.");
34 : :
35 : : static bool i8042_noaux;
36 : : module_param_named(noaux, i8042_noaux, bool, 0);
37 : : MODULE_PARM_DESC(noaux, "Do not probe or use AUX (mouse) port.");
38 : :
39 : : static bool i8042_nomux;
40 : : module_param_named(nomux, i8042_nomux, bool, 0);
41 : : MODULE_PARM_DESC(nomux, "Do not check whether an active multiplexing controller is present.");
42 : :
43 : : static bool i8042_unlock;
44 : : module_param_named(unlock, i8042_unlock, bool, 0);
45 : : MODULE_PARM_DESC(unlock, "Ignore keyboard lock.");
46 : :
47 : : enum i8042_controller_reset_mode {
48 : : I8042_RESET_NEVER,
49 : : I8042_RESET_ALWAYS,
50 : : I8042_RESET_ON_S2RAM,
51 : : #define I8042_RESET_DEFAULT I8042_RESET_ON_S2RAM
52 : : };
53 : : static enum i8042_controller_reset_mode i8042_reset = I8042_RESET_DEFAULT;
54 : 0 : static int i8042_set_reset(const char *val, const struct kernel_param *kp)
55 : : {
56 : 0 : enum i8042_controller_reset_mode *arg = kp->arg;
57 : 0 : int error;
58 : 0 : bool reset;
59 : :
60 [ # # ]: 0 : if (val) {
61 : 0 : error = kstrtobool(val, &reset);
62 [ # # ]: 0 : if (error)
63 : : return error;
64 : : } else {
65 : 0 : reset = true;
66 : : }
67 : :
68 : 0 : *arg = reset ? I8042_RESET_ALWAYS : I8042_RESET_NEVER;
69 : 0 : return 0;
70 : : }
71 : :
72 : : static const struct kernel_param_ops param_ops_reset_param = {
73 : : .flags = KERNEL_PARAM_OPS_FL_NOARG,
74 : : .set = i8042_set_reset,
75 : : };
76 : : #define param_check_reset_param(name, p) \
77 : : __param_check(name, p, enum i8042_controller_reset_mode)
78 : : module_param_named(reset, i8042_reset, reset_param, 0);
79 : : MODULE_PARM_DESC(reset, "Reset controller on resume, cleanup or both");
80 : :
81 : : static bool i8042_direct;
82 : : module_param_named(direct, i8042_direct, bool, 0);
83 : : MODULE_PARM_DESC(direct, "Put keyboard port into non-translated mode.");
84 : :
85 : : static bool i8042_dumbkbd;
86 : : module_param_named(dumbkbd, i8042_dumbkbd, bool, 0);
87 : : MODULE_PARM_DESC(dumbkbd, "Pretend that controller can only read data from keyboard");
88 : :
89 : : static bool i8042_noloop;
90 : : module_param_named(noloop, i8042_noloop, bool, 0);
91 : : MODULE_PARM_DESC(noloop, "Disable the AUX Loopback command while probing for the AUX port");
92 : :
93 : : static bool i8042_notimeout;
94 : : module_param_named(notimeout, i8042_notimeout, bool, 0);
95 : : MODULE_PARM_DESC(notimeout, "Ignore timeouts signalled by i8042");
96 : :
97 : : static bool i8042_kbdreset;
98 : : module_param_named(kbdreset, i8042_kbdreset, bool, 0);
99 : : MODULE_PARM_DESC(kbdreset, "Reset device connected to KBD port");
100 : :
101 : : #ifdef CONFIG_X86
102 : : static bool i8042_dritek;
103 : : module_param_named(dritek, i8042_dritek, bool, 0);
104 : : MODULE_PARM_DESC(dritek, "Force enable the Dritek keyboard extension");
105 : : #endif
106 : :
107 : : #ifdef CONFIG_PNP
108 : : static bool i8042_nopnp;
109 : : module_param_named(nopnp, i8042_nopnp, bool, 0);
110 : : MODULE_PARM_DESC(nopnp, "Do not use PNP to detect controller settings");
111 : : #endif
112 : :
113 : : #define DEBUG
114 : : #ifdef DEBUG
115 : : static bool i8042_debug;
116 : : module_param_named(debug, i8042_debug, bool, 0600);
117 : : MODULE_PARM_DESC(debug, "Turn i8042 debugging mode on and off");
118 : :
119 : : static bool i8042_unmask_kbd_data;
120 : : module_param_named(unmask_kbd_data, i8042_unmask_kbd_data, bool, 0600);
121 : : MODULE_PARM_DESC(unmask_kbd_data, "Unconditional enable (may reveal sensitive data) of normally sanitize-filtered kbd data traffic debug log [pre-condition: i8042.debug=1 enabled]");
122 : : #endif
123 : :
124 : : static bool i8042_bypass_aux_irq_test;
125 : : static char i8042_kbd_firmware_id[128];
126 : : static char i8042_aux_firmware_id[128];
127 : :
128 : : #include "i8042.h"
129 : :
130 : : /*
131 : : * i8042_lock protects serialization between i8042_command and
132 : : * the interrupt handler.
133 : : */
134 : : static DEFINE_SPINLOCK(i8042_lock);
135 : :
136 : : /*
137 : : * Writers to AUX and KBD ports as well as users issuing i8042_command
138 : : * directly should acquire i8042_mutex (by means of calling
139 : : * i8042_lock_chip() and i8042_unlock_ship() helpers) to ensure that
140 : : * they do not disturb each other (unfortunately in many i8042
141 : : * implementations write to one of the ports will immediately abort
142 : : * command that is being processed by another port).
143 : : */
144 : : static DEFINE_MUTEX(i8042_mutex);
145 : :
146 : : struct i8042_port {
147 : : struct serio *serio;
148 : : int irq;
149 : : bool exists;
150 : : bool driver_bound;
151 : : signed char mux;
152 : : };
153 : :
154 : : #define I8042_KBD_PORT_NO 0
155 : : #define I8042_AUX_PORT_NO 1
156 : : #define I8042_MUX_PORT_NO 2
157 : : #define I8042_NUM_PORTS (I8042_NUM_MUX_PORTS + 2)
158 : :
159 : : static struct i8042_port i8042_ports[I8042_NUM_PORTS];
160 : :
161 : : static unsigned char i8042_initial_ctr;
162 : : static unsigned char i8042_ctr;
163 : : static bool i8042_mux_present;
164 : : static bool i8042_kbd_irq_registered;
165 : : static bool i8042_aux_irq_registered;
166 : : static unsigned char i8042_suppress_kbd_ack;
167 : : static struct platform_device *i8042_platform_device;
168 : : static struct notifier_block i8042_kbd_bind_notifier_block;
169 : :
170 : : static irqreturn_t i8042_interrupt(int irq, void *dev_id);
171 : : static bool (*i8042_platform_filter)(unsigned char data, unsigned char str,
172 : : struct serio *serio);
173 : :
174 : 0 : void i8042_lock_chip(void)
175 : : {
176 : 0 : mutex_lock(&i8042_mutex);
177 : 0 : }
178 : : EXPORT_SYMBOL(i8042_lock_chip);
179 : :
180 : 0 : void i8042_unlock_chip(void)
181 : : {
182 : 0 : mutex_unlock(&i8042_mutex);
183 : 0 : }
184 : : EXPORT_SYMBOL(i8042_unlock_chip);
185 : :
186 : 0 : int i8042_install_filter(bool (*filter)(unsigned char data, unsigned char str,
187 : : struct serio *serio))
188 : : {
189 : 0 : unsigned long flags;
190 : 0 : int ret = 0;
191 : :
192 : 0 : spin_lock_irqsave(&i8042_lock, flags);
193 : :
194 [ # # ]: 0 : if (i8042_platform_filter) {
195 : 0 : ret = -EBUSY;
196 : 0 : goto out;
197 : : }
198 : :
199 : 0 : i8042_platform_filter = filter;
200 : :
201 : 0 : out:
202 : 0 : spin_unlock_irqrestore(&i8042_lock, flags);
203 : 0 : return ret;
204 : : }
205 : : EXPORT_SYMBOL(i8042_install_filter);
206 : :
207 : 0 : int i8042_remove_filter(bool (*filter)(unsigned char data, unsigned char str,
208 : : struct serio *port))
209 : : {
210 : 0 : unsigned long flags;
211 : 0 : int ret = 0;
212 : :
213 : 0 : spin_lock_irqsave(&i8042_lock, flags);
214 : :
215 [ # # ]: 0 : if (i8042_platform_filter != filter) {
216 : 0 : ret = -EINVAL;
217 : 0 : goto out;
218 : : }
219 : :
220 : 0 : i8042_platform_filter = NULL;
221 : :
222 : 0 : out:
223 : 0 : spin_unlock_irqrestore(&i8042_lock, flags);
224 : 0 : return ret;
225 : : }
226 : : EXPORT_SYMBOL(i8042_remove_filter);
227 : :
228 : : /*
229 : : * The i8042_wait_read() and i8042_wait_write functions wait for the i8042 to
230 : : * be ready for reading values from it / writing values to it.
231 : : * Called always with i8042_lock held.
232 : : */
233 : :
234 : 104 : static int i8042_wait_read(void)
235 : : {
236 : 104 : int i = 0;
237 : :
238 [ - + - - ]: 104 : while ((~i8042_read_status() & I8042_STR_OBF) && (i < I8042_CTL_TIMEOUT)) {
239 : 0 : udelay(50);
240 : 0 : i++;
241 : : }
242 : 104 : return -(i == I8042_CTL_TIMEOUT);
243 : : }
244 : :
245 : 3146 : static int i8042_wait_write(void)
246 : : {
247 : 3146 : int i = 0;
248 : :
249 [ - + - - ]: 3146 : while ((i8042_read_status() & I8042_STR_IBF) && (i < I8042_CTL_TIMEOUT)) {
250 : 0 : udelay(50);
251 : 0 : i++;
252 : : }
253 : 3146 : return -(i == I8042_CTL_TIMEOUT);
254 : : }
255 : :
256 : : /*
257 : : * i8042_flush() flushes all data that may be in the keyboard and mouse buffers
258 : : * of the i8042 down the toilet.
259 : : */
260 : :
261 : 52 : static int i8042_flush(void)
262 : : {
263 : 52 : unsigned long flags;
264 : 52 : unsigned char data, str;
265 : 52 : int count = 0;
266 : 52 : int retval = 0;
267 : :
268 : 52 : spin_lock_irqsave(&i8042_lock, flags);
269 : :
270 [ - + ]: 52 : while ((str = i8042_read_status()) & I8042_STR_OBF) {
271 [ # # ]: 0 : if (count++ < I8042_BUFFER_SIZE) {
272 : 0 : udelay(50);
273 : 0 : data = i8042_read_data();
274 [ # # # # ]: 0 : dbg("%02x <- i8042 (flush, %s)\n",
275 : : data, str & I8042_STR_AUXDATA ? "aux" : "kbd");
276 : : } else {
277 : : retval = -EIO;
278 : : break;
279 : : }
280 : : }
281 : :
282 : 52 : spin_unlock_irqrestore(&i8042_lock, flags);
283 : :
284 : 52 : return retval;
285 : : }
286 : :
287 : : /*
288 : : * i8042_command() executes a command on the i8042. It also sends the input
289 : : * parameter(s) of the commands to it, and receives the output value(s). The
290 : : * parameters are to be stored in the param array, and the output is placed
291 : : * into the same array. The number of the parameters and output values is
292 : : * encoded in bits 8-11 of the command number.
293 : : */
294 : :
295 : 1573 : static int __i8042_command(unsigned char *param, int command)
296 : : {
297 : 1573 : int i, error;
298 : :
299 [ - + - - ]: 1573 : if (i8042_noloop && command == I8042_CMD_AUX_LOOP)
300 : : return -1;
301 : :
302 : 1573 : error = i8042_wait_write();
303 [ + - ]: 1573 : if (error)
304 : : return error;
305 : :
306 [ - + ]: 1573 : dbg("%02x -> i8042 (command)\n", command & 0xff);
307 : 1573 : i8042_write_command(command & 0xff);
308 : :
309 [ + + ]: 4628 : for (i = 0; i < ((command >> 12) & 0xf); i++) {
310 : 1482 : error = i8042_wait_write();
311 [ - + ]: 1482 : if (error) {
312 [ # # ]: 0 : dbg(" -- i8042 (wait write timeout)\n");
313 : 0 : return error;
314 : : }
315 [ - + ]: 1482 : dbg("%02x -> i8042 (parameter)\n", param[i]);
316 : 1482 : i8042_write_data(param[i]);
317 : : }
318 : :
319 [ + + ]: 1677 : for (i = 0; i < ((command >> 8) & 0xf); i++) {
320 : 104 : error = i8042_wait_read();
321 [ - + ]: 104 : if (error) {
322 [ # # ]: 0 : dbg(" -- i8042 (wait read timeout)\n");
323 : 0 : return error;
324 : : }
325 : :
326 [ + + - + ]: 156 : if (command == I8042_CMD_AUX_LOOP &&
327 : : !(i8042_read_status() & I8042_STR_AUXDATA)) {
328 [ # # ]: 0 : dbg(" -- i8042 (auxerr)\n");
329 : 0 : return -1;
330 : : }
331 : :
332 : 104 : param[i] = i8042_read_data();
333 [ - + ]: 104 : dbg("%02x <- i8042 (return)\n", param[i]);
334 : : }
335 : :
336 : : return 0;
337 : : }
338 : :
339 : 1560 : int i8042_command(unsigned char *param, int command)
340 : : {
341 : 1560 : unsigned long flags;
342 : 1560 : int retval;
343 : :
344 : 1560 : spin_lock_irqsave(&i8042_lock, flags);
345 : 1560 : retval = __i8042_command(param, command);
346 : 1560 : spin_unlock_irqrestore(&i8042_lock, flags);
347 : :
348 : 1560 : return retval;
349 : : }
350 : : EXPORT_SYMBOL(i8042_command);
351 : :
352 : : /*
353 : : * i8042_kbd_write() sends a byte out through the keyboard interface.
354 : : */
355 : :
356 : 91 : static int i8042_kbd_write(struct serio *port, unsigned char c)
357 : : {
358 : 91 : unsigned long flags;
359 : 91 : int retval = 0;
360 : :
361 : 91 : spin_lock_irqsave(&i8042_lock, flags);
362 : :
363 [ + - ]: 91 : if (!(retval = i8042_wait_write())) {
364 [ - + ]: 91 : dbg("%02x -> i8042 (kbd-data)\n", c);
365 : 91 : i8042_write_data(c);
366 : : }
367 : :
368 : 91 : spin_unlock_irqrestore(&i8042_lock, flags);
369 : :
370 : 91 : return retval;
371 : : }
372 : :
373 : : /*
374 : : * i8042_aux_write() sends a byte out through the aux interface.
375 : : */
376 : :
377 : 1313 : static int i8042_aux_write(struct serio *serio, unsigned char c)
378 : : {
379 : 1313 : struct i8042_port *port = serio->port_data;
380 : :
381 [ - + ]: 1313 : return i8042_command(&c, port->mux == -1 ?
382 : : I8042_CMD_AUX_SEND :
383 : 0 : I8042_CMD_MUX_SEND + port->mux);
384 : : }
385 : :
386 : :
387 : : /*
388 : : * i8042_port_close attempts to clear AUX or KBD port state by disabling
389 : : * and then re-enabling it.
390 : : */
391 : :
392 : 13 : static void i8042_port_close(struct serio *serio)
393 : : {
394 : 13 : int irq_bit;
395 : 13 : int disable_bit;
396 : 13 : const char *port_name;
397 : :
398 [ - + ]: 13 : if (serio == i8042_ports[I8042_AUX_PORT_NO].serio) {
399 : : irq_bit = I8042_CTR_AUXINT;
400 : : disable_bit = I8042_CTR_AUXDIS;
401 : : port_name = "AUX";
402 : : } else {
403 : 0 : irq_bit = I8042_CTR_KBDINT;
404 : 0 : disable_bit = I8042_CTR_KBDDIS;
405 : 0 : port_name = "KBD";
406 : : }
407 : :
408 : 13 : i8042_ctr &= ~irq_bit;
409 [ - + ]: 13 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
410 : 0 : pr_warn("Can't write CTR while closing %s port\n", port_name);
411 : :
412 : 13 : udelay(50);
413 : :
414 : 13 : i8042_ctr &= ~disable_bit;
415 : 13 : i8042_ctr |= irq_bit;
416 [ - + ]: 13 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
417 : 0 : pr_err("Can't reactivate %s port\n", port_name);
418 : :
419 : : /*
420 : : * See if there is any data appeared while we were messing with
421 : : * port state.
422 : : */
423 : 13 : i8042_interrupt(0, NULL);
424 : 13 : }
425 : :
426 : : /*
427 : : * i8042_start() is called by serio core when port is about to finish
428 : : * registering. It will mark port as existing so i8042_interrupt can
429 : : * start sending data through it.
430 : : */
431 : 26 : static int i8042_start(struct serio *serio)
432 : : {
433 : 26 : struct i8042_port *port = serio->port_data;
434 : :
435 : 26 : device_set_wakeup_capable(&serio->dev, true);
436 : :
437 : : /*
438 : : * On platforms using suspend-to-idle, allow the keyboard to
439 : : * wake up the system from sleep by enabling keyboard wakeups
440 : : * by default. This is consistent with keyboard wakeup
441 : : * behavior on many platforms using suspend-to-RAM (ACPI S3)
442 : : * by default.
443 : : */
444 [ - + ]: 26 : if (pm_suspend_default_s2idle() &&
445 [ # # ]: 0 : serio == i8042_ports[I8042_KBD_PORT_NO].serio) {
446 : 0 : device_set_wakeup_enable(&serio->dev, true);
447 : : }
448 : :
449 : 26 : spin_lock_irq(&i8042_lock);
450 : 26 : port->exists = true;
451 : 26 : spin_unlock_irq(&i8042_lock);
452 : :
453 : 26 : return 0;
454 : : }
455 : :
456 : : /*
457 : : * i8042_stop() marks serio port as non-existing so i8042_interrupt
458 : : * will not try to send data to the port that is about to go away.
459 : : * The function is called by serio core as part of unregister procedure.
460 : : */
461 : 0 : static void i8042_stop(struct serio *serio)
462 : : {
463 : 0 : struct i8042_port *port = serio->port_data;
464 : :
465 : 0 : spin_lock_irq(&i8042_lock);
466 : 0 : port->exists = false;
467 : 0 : port->serio = NULL;
468 : 0 : spin_unlock_irq(&i8042_lock);
469 : :
470 : : /*
471 : : * We need to make sure that interrupt handler finishes using
472 : : * our serio port before we return from this function.
473 : : * We synchronize with both AUX and KBD IRQs because there is
474 : : * a (very unlikely) chance that AUX IRQ is raised for KBD port
475 : : * and vice versa.
476 : : */
477 : 0 : synchronize_irq(I8042_AUX_IRQ);
478 : 0 : synchronize_irq(I8042_KBD_IRQ);
479 : 0 : }
480 : :
481 : : /*
482 : : * i8042_filter() filters out unwanted bytes from the input data stream.
483 : : * It is called from i8042_interrupt and thus is running with interrupts
484 : : * off and i8042_lock held.
485 : : */
486 : 1729 : static bool i8042_filter(unsigned char data, unsigned char str,
487 : : struct serio *serio)
488 : : {
489 [ - + ]: 1729 : if (unlikely(i8042_suppress_kbd_ack)) {
490 [ # # ]: 0 : if ((~str & I8042_STR_AUXDATA) &&
491 [ # # ]: 0 : (data == 0xfa || data == 0xfe)) {
492 : 0 : i8042_suppress_kbd_ack--;
493 [ # # ]: 0 : dbg("Extra keyboard ACK - filtered out\n");
494 : 0 : return true;
495 : : }
496 : : }
497 : :
498 [ - + - - ]: 1729 : if (i8042_platform_filter && i8042_platform_filter(data, str, serio)) {
499 [ # # ]: 0 : dbg("Filtered out by platform filter\n");
500 : 0 : return true;
501 : : }
502 : :
503 : : return false;
504 : : }
505 : :
506 : : /*
507 : : * i8042_interrupt() is the most important function in this driver -
508 : : * it handles the interrupts from the i8042, and sends incoming bytes
509 : : * to the upper layers.
510 : : */
511 : :
512 : 1742 : static irqreturn_t i8042_interrupt(int irq, void *dev_id)
513 : : {
514 : 1742 : struct i8042_port *port;
515 : 1742 : struct serio *serio;
516 : 1742 : unsigned long flags;
517 : 1742 : unsigned char str, data;
518 : 1742 : unsigned int dfl;
519 : 1742 : unsigned int port_no;
520 : 1742 : bool filtered;
521 : 1742 : int ret = 1;
522 : :
523 : 1742 : spin_lock_irqsave(&i8042_lock, flags);
524 : :
525 : 1742 : str = i8042_read_status();
526 [ + + ]: 1742 : if (unlikely(~str & I8042_STR_OBF)) {
527 : 13 : spin_unlock_irqrestore(&i8042_lock, flags);
528 [ - + ]: 13 : if (irq)
529 [ # # ]: 0 : dbg("Interrupt %d, without any data\n", irq);
530 : 13 : ret = 0;
531 : 13 : goto out;
532 : : }
533 : :
534 : 1729 : data = i8042_read_data();
535 : :
536 [ - + - - ]: 1729 : if (i8042_mux_present && (str & I8042_STR_AUXDATA)) {
537 : 0 : static unsigned long last_transmit;
538 : 0 : static unsigned char last_str;
539 : :
540 : 0 : dfl = 0;
541 [ # # ]: 0 : if (str & I8042_STR_MUXERR) {
542 [ # # ]: 0 : dbg("MUX error, status is %02x, data is %02x\n",
543 : : str, data);
544 : : /*
545 : : * When MUXERR condition is signalled the data register can only contain
546 : : * 0xfd, 0xfe or 0xff if implementation follows the spec. Unfortunately
547 : : * it is not always the case. Some KBCs also report 0xfc when there is
548 : : * nothing connected to the port while others sometimes get confused which
549 : : * port the data came from and signal error leaving the data intact. They
550 : : * _do not_ revert to legacy mode (actually I've never seen KBC reverting
551 : : * to legacy mode yet, when we see one we'll add proper handling).
552 : : * Anyway, we process 0xfc, 0xfd, 0xfe and 0xff as timeouts, and for the
553 : : * rest assume that the data came from the same serio last byte
554 : : * was transmitted (if transmission happened not too long ago).
555 : : */
556 : :
557 [ # # # ]: 0 : switch (data) {
558 : : default:
559 [ # # ]: 0 : if (time_before(jiffies, last_transmit + HZ/10)) {
560 : 0 : str = last_str;
561 : 0 : break;
562 : : }
563 : : /* fall through - report timeout */
564 : : case 0xfc:
565 : : case 0xfd:
566 : : case 0xfe: dfl = SERIO_TIMEOUT; data = 0xfe; break;
567 : : case 0xff: dfl = SERIO_PARITY; data = 0xfe; break;
568 : : }
569 : 0 : }
570 : :
571 : 0 : port_no = I8042_MUX_PORT_NO + ((str >> 6) & 3);
572 : 0 : last_str = str;
573 : 0 : last_transmit = jiffies;
574 : : } else {
575 : :
576 [ - + ]: 1729 : dfl = ((str & I8042_STR_PARITY) ? SERIO_PARITY : 0) |
577 [ # # ]: 0 : ((str & I8042_STR_TIMEOUT && !i8042_notimeout) ? SERIO_TIMEOUT : 0);
578 : :
579 : 1729 : port_no = (str & I8042_STR_AUXDATA) ?
580 : 1729 : I8042_AUX_PORT_NO : I8042_KBD_PORT_NO;
581 : : }
582 : :
583 : 1729 : port = &i8042_ports[port_no];
584 [ + - ]: 1729 : serio = port->exists ? port->serio : NULL;
585 : :
586 [ - + - - : 1729 : filter_dbg(port->driver_bound, data, "<- i8042 (interrupt, %d, %d%s%s)\n",
- - - - -
- - - -
- ]
587 : : port_no, irq,
588 : : dfl & SERIO_PARITY ? ", bad parity" : "",
589 : : dfl & SERIO_TIMEOUT ? ", timeout" : "");
590 : :
591 : 1729 : filtered = i8042_filter(data, str, serio);
592 : :
593 : 1729 : spin_unlock_irqrestore(&i8042_lock, flags);
594 : :
595 [ - + ]: 1729 : if (likely(serio && !filtered))
596 : 1729 : serio_interrupt(serio, data, dfl);
597 : :
598 : 0 : out:
599 : 1742 : return IRQ_RETVAL(ret);
600 : : }
601 : :
602 : : /*
603 : : * i8042_enable_kbd_port enables keyboard port on chip
604 : : */
605 : :
606 : 13 : static int i8042_enable_kbd_port(void)
607 : : {
608 : 13 : i8042_ctr &= ~I8042_CTR_KBDDIS;
609 : 13 : i8042_ctr |= I8042_CTR_KBDINT;
610 : :
611 [ - + ]: 13 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
612 : 0 : i8042_ctr &= ~I8042_CTR_KBDINT;
613 : 0 : i8042_ctr |= I8042_CTR_KBDDIS;
614 : 0 : pr_err("Failed to enable KBD port\n");
615 : 0 : return -EIO;
616 : : }
617 : :
618 : : return 0;
619 : : }
620 : :
621 : : /*
622 : : * i8042_enable_aux_port enables AUX (mouse) port on chip
623 : : */
624 : :
625 : 26 : static int i8042_enable_aux_port(void)
626 : : {
627 : 26 : i8042_ctr &= ~I8042_CTR_AUXDIS;
628 : 26 : i8042_ctr |= I8042_CTR_AUXINT;
629 : :
630 [ - + ]: 26 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
631 : 0 : i8042_ctr &= ~I8042_CTR_AUXINT;
632 : 0 : i8042_ctr |= I8042_CTR_AUXDIS;
633 : 0 : pr_err("Failed to enable AUX port\n");
634 : 0 : return -EIO;
635 : : }
636 : :
637 : : return 0;
638 : : }
639 : :
640 : : /*
641 : : * i8042_enable_mux_ports enables 4 individual AUX ports after
642 : : * the controller has been switched into Multiplexed mode
643 : : */
644 : :
645 : 0 : static int i8042_enable_mux_ports(void)
646 : : {
647 : 0 : unsigned char param;
648 : 0 : int i;
649 : :
650 [ # # ]: 0 : for (i = 0; i < I8042_NUM_MUX_PORTS; i++) {
651 : 0 : i8042_command(¶m, I8042_CMD_MUX_PFX + i);
652 : 0 : i8042_command(¶m, I8042_CMD_AUX_ENABLE);
653 : : }
654 : :
655 : 0 : return i8042_enable_aux_port();
656 : : }
657 : :
658 : : /*
659 : : * i8042_set_mux_mode checks whether the controller has an
660 : : * active multiplexor and puts the chip into Multiplexed (true)
661 : : * or Legacy (false) mode.
662 : : */
663 : :
664 : 13 : static int i8042_set_mux_mode(bool multiplex, unsigned char *mux_version)
665 : : {
666 : :
667 : 13 : unsigned char param, val;
668 : : /*
669 : : * Get rid of bytes in the queue.
670 : : */
671 : :
672 : 13 : i8042_flush();
673 : :
674 : : /*
675 : : * Internal loopback test - send three bytes, they should come back from the
676 : : * mouse interface, the last should be version.
677 : : */
678 : :
679 : 13 : param = val = 0xf0;
680 [ + - + - ]: 13 : if (i8042_command(¶m, I8042_CMD_AUX_LOOP) || param != val)
681 : : return -1;
682 [ - + ]: 13 : param = val = multiplex ? 0x56 : 0xf6;
683 [ + - + - ]: 13 : if (i8042_command(¶m, I8042_CMD_AUX_LOOP) || param != val)
684 : : return -1;
685 [ - + ]: 13 : param = val = multiplex ? 0xa4 : 0xa5;
686 [ + - - + ]: 13 : if (i8042_command(¶m, I8042_CMD_AUX_LOOP) || param == val)
687 : : return -1;
688 : :
689 : : /*
690 : : * Workaround for interference with USB Legacy emulation
691 : : * that causes a v10.12 MUX to be found.
692 : : */
693 [ # # ]: 0 : if (param == 0xac)
694 : : return -1;
695 : :
696 [ # # ]: 0 : if (mux_version)
697 : 0 : *mux_version = param;
698 : :
699 : : return 0;
700 : : }
701 : :
702 : : /*
703 : : * i8042_check_mux() checks whether the controller supports the PS/2 Active
704 : : * Multiplexing specification by Synaptics, Phoenix, Insyde and
705 : : * LCS/Telegraphics.
706 : : */
707 : :
708 : 13 : static int __init i8042_check_mux(void)
709 : : {
710 : 13 : unsigned char mux_version;
711 : :
712 [ - + ]: 13 : if (i8042_set_mux_mode(true, &mux_version))
713 : : return -1;
714 : :
715 : 0 : pr_info("Detected active multiplexing controller, rev %d.%d\n",
716 : : (mux_version >> 4) & 0xf, mux_version & 0xf);
717 : :
718 : : /*
719 : : * Disable all muxed ports by disabling AUX.
720 : : */
721 : 0 : i8042_ctr |= I8042_CTR_AUXDIS;
722 : 0 : i8042_ctr &= ~I8042_CTR_AUXINT;
723 : :
724 [ # # ]: 0 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
725 : 0 : pr_err("Failed to disable AUX port, can't use MUX\n");
726 : 0 : return -EIO;
727 : : }
728 : :
729 : 0 : i8042_mux_present = true;
730 : :
731 : 0 : return 0;
732 : : }
733 : :
734 : : /*
735 : : * The following is used to test AUX IRQ delivery.
736 : : */
737 : : static struct completion i8042_aux_irq_delivered __initdata;
738 : : static bool i8042_irq_being_tested __initdata;
739 : :
740 : 13 : static irqreturn_t __init i8042_aux_test_irq(int irq, void *dev_id)
741 : : {
742 : 13 : unsigned long flags;
743 : 13 : unsigned char str, data;
744 : 13 : int ret = 0;
745 : :
746 : 13 : spin_lock_irqsave(&i8042_lock, flags);
747 : 13 : str = i8042_read_status();
748 [ + - ]: 13 : if (str & I8042_STR_OBF) {
749 : 13 : data = i8042_read_data();
750 [ - + - - ]: 13 : dbg("%02x <- i8042 (aux_test_irq, %s)\n",
751 : : data, str & I8042_STR_AUXDATA ? "aux" : "kbd");
752 [ + - + - ]: 13 : if (i8042_irq_being_tested &&
753 [ + - ]: 13 : data == 0xa5 && (str & I8042_STR_AUXDATA))
754 : 13 : complete(&i8042_aux_irq_delivered);
755 : : ret = 1;
756 : : }
757 : 13 : spin_unlock_irqrestore(&i8042_lock, flags);
758 : :
759 : 13 : return IRQ_RETVAL(ret);
760 : : }
761 : :
762 : : /*
763 : : * i8042_toggle_aux - enables or disables AUX port on i8042 via command and
764 : : * verifies success by readinng CTR. Used when testing for presence of AUX
765 : : * port.
766 : : */
767 : 26 : static int __init i8042_toggle_aux(bool on)
768 : : {
769 : 26 : unsigned char param;
770 : 26 : int i;
771 : :
772 [ + + + - ]: 39 : if (i8042_command(¶m,
773 : : on ? I8042_CMD_AUX_ENABLE : I8042_CMD_AUX_DISABLE))
774 : : return -1;
775 : :
776 : : /* some chips need some time to set the I8042_CTR_AUXDIS bit */
777 [ + - ]: 26 : for (i = 0; i < 100; i++) {
778 : 26 : udelay(50);
779 : :
780 [ + - ]: 26 : if (i8042_command(¶m, I8042_CMD_CTL_RCTR))
781 : : return -1;
782 : :
783 [ - + ]: 26 : if (!(param & I8042_CTR_AUXDIS) == on)
784 : : return 0;
785 : : }
786 : :
787 : : return -1;
788 : : }
789 : :
790 : : /*
791 : : * i8042_check_aux() applies as much paranoia as it can at detecting
792 : : * the presence of an AUX interface.
793 : : */
794 : :
795 : 13 : static int __init i8042_check_aux(void)
796 : : {
797 : 13 : int retval = -1;
798 : 13 : bool irq_registered = false;
799 : 13 : bool aux_loop_broken = false;
800 : 13 : unsigned long flags;
801 : 13 : unsigned char param;
802 : :
803 : : /*
804 : : * Get rid of bytes in the queue.
805 : : */
806 : :
807 : 13 : i8042_flush();
808 : :
809 : : /*
810 : : * Internal loopback test - filters out AT-type i8042's. Unfortunately
811 : : * SiS screwed up and their 5597 doesn't support the LOOP command even
812 : : * though it has an AUX port.
813 : : */
814 : :
815 : 13 : param = 0x5a;
816 : 13 : retval = i8042_command(¶m, I8042_CMD_AUX_LOOP);
817 [ + - - + ]: 13 : if (retval || param != 0x5a) {
818 : :
819 : : /*
820 : : * External connection test - filters out AT-soldered PS/2 i8042's
821 : : * 0x00 - no error, 0x01-0x03 - clock/data stuck, 0xff - general error
822 : : * 0xfa - no error on some notebooks which ignore the spec
823 : : * Because it's common for chipsets to return error on perfectly functioning
824 : : * AUX ports, we test for this only when the LOOP command failed.
825 : : */
826 : :
827 [ # # ]: 0 : if (i8042_command(¶m, I8042_CMD_AUX_TEST) ||
828 [ # # # # ]: 0 : (param && param != 0xfa && param != 0xff))
829 : : return -1;
830 : :
831 : : /*
832 : : * If AUX_LOOP completed without error but returned unexpected data
833 : : * mark it as broken
834 : : */
835 [ # # ]: 0 : if (!retval)
836 : 0 : aux_loop_broken = true;
837 : : }
838 : :
839 : : /*
840 : : * Bit assignment test - filters out PS/2 i8042's in AT mode
841 : : */
842 : :
843 [ - + ]: 13 : if (i8042_toggle_aux(false)) {
844 : 0 : pr_warn("Failed to disable AUX port, but continuing anyway... Is this a SiS?\n");
845 : 0 : pr_warn("If AUX port is really absent please use the 'i8042.noaux' option\n");
846 : : }
847 : :
848 [ + - ]: 13 : if (i8042_toggle_aux(true))
849 : : return -1;
850 : :
851 : : /*
852 : : * Reset keyboard (needed on some laptops to successfully detect
853 : : * touchpad, e.g., some Gigabyte laptop models with Elantech
854 : : * touchpads).
855 : : */
856 [ - + ]: 13 : if (i8042_kbdreset) {
857 : 0 : pr_warn("Attempting to reset device connected to KBD port\n");
858 : 0 : i8042_kbd_write(NULL, (unsigned char) 0xff);
859 : : }
860 : :
861 : : /*
862 : : * Test AUX IRQ delivery to make sure BIOS did not grab the IRQ and
863 : : * used it for a PCI card or somethig else.
864 : : */
865 : :
866 [ + - - + ]: 13 : if (i8042_noloop || i8042_bypass_aux_irq_test || aux_loop_broken) {
867 : : /*
868 : : * Without LOOP command we can't test AUX IRQ delivery. Assume the port
869 : : * is working and hope we are right.
870 : : */
871 : 0 : retval = 0;
872 : 0 : goto out;
873 : : }
874 : :
875 [ - + ]: 13 : if (request_irq(I8042_AUX_IRQ, i8042_aux_test_irq, IRQF_SHARED,
876 : : "i8042", i8042_platform_device))
877 : 0 : goto out;
878 : :
879 : 13 : irq_registered = true;
880 : :
881 [ - + ]: 13 : if (i8042_enable_aux_port())
882 : 0 : goto out;
883 : :
884 : 13 : spin_lock_irqsave(&i8042_lock, flags);
885 : :
886 : 13 : init_completion(&i8042_aux_irq_delivered);
887 : 13 : i8042_irq_being_tested = true;
888 : :
889 : 13 : param = 0xa5;
890 : 13 : retval = __i8042_command(¶m, I8042_CMD_AUX_LOOP & 0xf0ff);
891 : :
892 : 13 : spin_unlock_irqrestore(&i8042_lock, flags);
893 : :
894 [ - + ]: 13 : if (retval)
895 : 0 : goto out;
896 : :
897 [ + - ]: 13 : if (wait_for_completion_timeout(&i8042_aux_irq_delivered,
898 : : msecs_to_jiffies(250)) == 0) {
899 : : /*
900 : : * AUX IRQ was never delivered so we need to flush the controller to
901 : : * get rid of the byte we put there; otherwise keyboard may not work.
902 : : */
903 [ # # ]: 0 : dbg(" -- i8042 (aux irq test timeout)\n");
904 : 0 : i8042_flush();
905 : 0 : retval = -1;
906 : : }
907 : :
908 : 13 : out:
909 : :
910 : : /*
911 : : * Disable the interface.
912 : : */
913 : :
914 : 13 : i8042_ctr |= I8042_CTR_AUXDIS;
915 : 13 : i8042_ctr &= ~I8042_CTR_AUXINT;
916 : :
917 [ - + ]: 13 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
918 : 0 : retval = -1;
919 : :
920 [ + - ]: 13 : if (irq_registered)
921 : 13 : free_irq(I8042_AUX_IRQ, i8042_platform_device);
922 : :
923 : : return retval;
924 : : }
925 : :
926 : 13 : static int i8042_controller_check(void)
927 : : {
928 [ + - - - ]: 13 : if (i8042_flush()) {
929 : 0 : pr_info("No controller found\n");
930 : 0 : return -ENODEV;
931 : : }
932 : :
933 : : return 0;
934 : : }
935 : :
936 : 0 : static int i8042_controller_selftest(void)
937 : : {
938 : 0 : unsigned char param;
939 : 0 : int i = 0;
940 : :
941 : : /*
942 : : * We try this 5 times; on some really fragile systems this does not
943 : : * take the first time...
944 : : */
945 : 0 : do {
946 : :
947 [ # # ]: 0 : if (i8042_command(¶m, I8042_CMD_CTL_TEST)) {
948 : 0 : pr_err("i8042 controller selftest timeout\n");
949 : 0 : return -ENODEV;
950 : : }
951 : :
952 [ # # ]: 0 : if (param == I8042_RET_CTL_TEST)
953 : : return 0;
954 : :
955 [ # # ]: 0 : dbg("i8042 controller selftest: %#x != %#x\n",
956 : : param, I8042_RET_CTL_TEST);
957 : 0 : msleep(50);
958 [ # # ]: 0 : } while (i++ < 5);
959 : :
960 : : #ifdef CONFIG_X86
961 : : /*
962 : : * On x86, we don't fail entire i8042 initialization if controller
963 : : * reset fails in hopes that keyboard port will still be functional
964 : : * and user will still get a working keyboard. This is especially
965 : : * important on netbooks. On other arches we trust hardware more.
966 : : */
967 : 0 : pr_info("giving up on controller selftest, continuing anyway...\n");
968 : 0 : return 0;
969 : : #else
970 : : pr_err("i8042 controller selftest failed\n");
971 : : return -EIO;
972 : : #endif
973 : : }
974 : :
975 : : /*
976 : : * i8042_controller init initializes the i8042 controller, and,
977 : : * most importantly, sets it into non-xlated mode if that's
978 : : * desired.
979 : : */
980 : :
981 : 13 : static int i8042_controller_init(void)
982 : : {
983 : 13 : unsigned long flags;
984 : 13 : int n = 0;
985 : 26 : unsigned char ctr[2];
986 : :
987 : : /*
988 : : * Save the CTR for restore on unload / reboot.
989 : : */
990 : :
991 : 26 : do {
992 [ - + ]: 26 : if (n >= 10) {
993 : 0 : pr_err("Unable to get stable CTR read\n");
994 : 0 : return -EIO;
995 : : }
996 : :
997 [ + + ]: 26 : if (n != 0)
998 : 13 : udelay(50);
999 : :
1000 [ - + ]: 26 : if (i8042_command(&ctr[n++ % 2], I8042_CMD_CTL_RCTR)) {
1001 : 0 : pr_err("Can't read CTR while initializing i8042\n");
1002 : 0 : return -EIO;
1003 : : }
1004 : :
1005 [ + + - + ]: 26 : } while (n < 2 || ctr[0] != ctr[1]);
1006 : :
1007 : 13 : i8042_initial_ctr = i8042_ctr = ctr[0];
1008 : :
1009 : : /*
1010 : : * Disable the keyboard interface and interrupt.
1011 : : */
1012 : :
1013 : 13 : i8042_ctr |= I8042_CTR_KBDDIS;
1014 : 13 : i8042_ctr &= ~I8042_CTR_KBDINT;
1015 : :
1016 : : /*
1017 : : * Handle keylock.
1018 : : */
1019 : :
1020 : 13 : spin_lock_irqsave(&i8042_lock, flags);
1021 [ - + ]: 13 : if (~i8042_read_status() & I8042_STR_KEYLOCK) {
1022 [ # # ]: 0 : if (i8042_unlock)
1023 : 0 : i8042_ctr |= I8042_CTR_IGNKEYLOCK;
1024 : : else
1025 : 0 : pr_warn("Warning: Keylock active\n");
1026 : : }
1027 : 13 : spin_unlock_irqrestore(&i8042_lock, flags);
1028 : :
1029 : : /*
1030 : : * If the chip is configured into nontranslated mode by the BIOS, don't
1031 : : * bother enabling translating and be happy.
1032 : : */
1033 : :
1034 [ - + ]: 13 : if (~i8042_ctr & I8042_CTR_XLATE)
1035 : 0 : i8042_direct = true;
1036 : :
1037 : : /*
1038 : : * Set nontranslated mode for the kbd interface if requested by an option.
1039 : : * After this the kbd interface becomes a simple serial in/out, like the aux
1040 : : * interface is. We don't do this by default, since it can confuse notebook
1041 : : * BIOSes.
1042 : : */
1043 : :
1044 [ - + ]: 13 : if (i8042_direct)
1045 : 0 : i8042_ctr &= ~I8042_CTR_XLATE;
1046 : :
1047 : : /*
1048 : : * Write CTR back.
1049 : : */
1050 : :
1051 [ - + ]: 13 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
1052 : 0 : pr_err("Can't write CTR while initializing i8042\n");
1053 : 0 : return -EIO;
1054 : : }
1055 : :
1056 : : /*
1057 : : * Flush whatever accumulated while we were disabling keyboard port.
1058 : : */
1059 : :
1060 : 13 : i8042_flush();
1061 : :
1062 : 13 : return 0;
1063 : : }
1064 : :
1065 : :
1066 : : /*
1067 : : * Reset the controller and reset CRT to the original value set by BIOS.
1068 : : */
1069 : :
1070 : 0 : static void i8042_controller_reset(bool s2r_wants_reset)
1071 : : {
1072 : 0 : i8042_flush();
1073 : :
1074 : : /*
1075 : : * Disable both KBD and AUX interfaces so they don't get in the way
1076 : : */
1077 : :
1078 : 0 : i8042_ctr |= I8042_CTR_KBDDIS | I8042_CTR_AUXDIS;
1079 : 0 : i8042_ctr &= ~(I8042_CTR_KBDINT | I8042_CTR_AUXINT);
1080 : :
1081 [ # # ]: 0 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
1082 : 0 : pr_warn("Can't write CTR while resetting\n");
1083 : :
1084 : : /*
1085 : : * Disable MUX mode if present.
1086 : : */
1087 : :
1088 [ # # ]: 0 : if (i8042_mux_present)
1089 : 0 : i8042_set_mux_mode(false, NULL);
1090 : :
1091 : : /*
1092 : : * Reset the controller if requested.
1093 : : */
1094 : :
1095 [ # # # # ]: 0 : if (i8042_reset == I8042_RESET_ALWAYS ||
1096 [ # # ]: 0 : (i8042_reset == I8042_RESET_ON_S2RAM && s2r_wants_reset)) {
1097 : 0 : i8042_controller_selftest();
1098 : : }
1099 : :
1100 : : /*
1101 : : * Restore the original control register setting.
1102 : : */
1103 : :
1104 [ # # ]: 0 : if (i8042_command(&i8042_initial_ctr, I8042_CMD_CTL_WCTR))
1105 : 0 : pr_warn("Can't restore CTR\n");
1106 : 0 : }
1107 : :
1108 : :
1109 : : /*
1110 : : * i8042_panic_blink() will turn the keyboard LEDs on or off and is called
1111 : : * when kernel panics. Flashing LEDs is useful for users running X who may
1112 : : * not see the console and will help distinguishing panics from "real"
1113 : : * lockups.
1114 : : *
1115 : : * Note that DELAY has a limit of 10ms so we will not get stuck here
1116 : : * waiting for KBC to free up even if KBD interrupt is off
1117 : : */
1118 : :
1119 : : #define DELAY do { mdelay(1); if (++delay > 10) return delay; } while(0)
1120 : :
1121 : 0 : static long i8042_panic_blink(int state)
1122 : : {
1123 : 0 : long delay = 0;
1124 : 0 : char led;
1125 : :
1126 [ # # ]: 0 : led = (state) ? 0x01 | 0x04 : 0;
1127 [ # # ]: 0 : while (i8042_read_status() & I8042_STR_IBF)
1128 [ # # ]: 0 : DELAY;
1129 [ # # ]: 0 : dbg("%02x -> i8042 (panic blink)\n", 0xed);
1130 : 0 : i8042_suppress_kbd_ack = 2;
1131 : 0 : i8042_write_data(0xed); /* set leds */
1132 [ # # ]: 0 : DELAY;
1133 [ # # ]: 0 : while (i8042_read_status() & I8042_STR_IBF)
1134 [ # # ]: 0 : DELAY;
1135 [ # # ]: 0 : DELAY;
1136 [ # # ]: 0 : dbg("%02x -> i8042 (panic blink)\n", led);
1137 : 0 : i8042_write_data(led);
1138 : 0 : DELAY;
1139 : : return delay;
1140 : : }
1141 : :
1142 : : #undef DELAY
1143 : :
1144 : : #ifdef CONFIG_X86
1145 : 0 : static void i8042_dritek_enable(void)
1146 : : {
1147 : 0 : unsigned char param = 0x90;
1148 : 0 : int error;
1149 : :
1150 : 0 : error = i8042_command(¶m, 0x1059);
1151 [ # # ]: 0 : if (error)
1152 : 0 : pr_warn("Failed to enable DRITEK extension: %d\n", error);
1153 : 0 : }
1154 : : #endif
1155 : :
1156 : : #ifdef CONFIG_PM
1157 : :
1158 : : /*
1159 : : * Here we try to reset everything back to a state we had
1160 : : * before suspending.
1161 : : */
1162 : :
1163 : 0 : static int i8042_controller_resume(bool s2r_wants_reset)
1164 : : {
1165 : 0 : int error;
1166 : :
1167 : 0 : error = i8042_controller_check();
1168 : 0 : if (error)
1169 : 0 : return error;
1170 : :
1171 [ # # # # ]: 0 : if (i8042_reset == I8042_RESET_ALWAYS ||
1172 [ # # ]: 0 : (i8042_reset == I8042_RESET_ON_S2RAM && s2r_wants_reset)) {
1173 : 0 : error = i8042_controller_selftest();
1174 [ # # ]: 0 : if (error)
1175 : : return error;
1176 : : }
1177 : :
1178 : : /*
1179 : : * Restore original CTR value and disable all ports
1180 : : */
1181 : :
1182 : 0 : i8042_ctr = i8042_initial_ctr;
1183 [ # # ]: 0 : if (i8042_direct)
1184 : 0 : i8042_ctr &= ~I8042_CTR_XLATE;
1185 : 0 : i8042_ctr |= I8042_CTR_AUXDIS | I8042_CTR_KBDDIS;
1186 : 0 : i8042_ctr &= ~(I8042_CTR_AUXINT | I8042_CTR_KBDINT);
1187 [ # # ]: 0 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
1188 : 0 : pr_warn("Can't write CTR to resume, retrying...\n");
1189 : 0 : msleep(50);
1190 [ # # ]: 0 : if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
1191 : 0 : pr_err("CTR write retry failed\n");
1192 : 0 : return -EIO;
1193 : : }
1194 : : }
1195 : :
1196 : :
1197 : : #ifdef CONFIG_X86
1198 [ # # ]: 0 : if (i8042_dritek)
1199 : 0 : i8042_dritek_enable();
1200 : : #endif
1201 : :
1202 [ # # ]: 0 : if (i8042_mux_present) {
1203 [ # # # # ]: 0 : if (i8042_set_mux_mode(true, NULL) || i8042_enable_mux_ports())
1204 : 0 : pr_warn("failed to resume active multiplexor, mouse won't work\n");
1205 [ # # ]: 0 : } else if (i8042_ports[I8042_AUX_PORT_NO].serio)
1206 : 0 : i8042_enable_aux_port();
1207 : :
1208 [ # # ]: 0 : if (i8042_ports[I8042_KBD_PORT_NO].serio)
1209 : 0 : i8042_enable_kbd_port();
1210 : :
1211 : 0 : i8042_interrupt(0, NULL);
1212 : :
1213 : 0 : return 0;
1214 : : }
1215 : :
1216 : : /*
1217 : : * Here we try to restore the original BIOS settings to avoid
1218 : : * upsetting it.
1219 : : */
1220 : :
1221 : 0 : static int i8042_pm_suspend(struct device *dev)
1222 : : {
1223 : 0 : int i;
1224 : :
1225 [ # # ]: 0 : if (pm_suspend_via_firmware())
1226 : 0 : i8042_controller_reset(true);
1227 : :
1228 : : /* Set up serio interrupts for system wakeup. */
1229 [ # # ]: 0 : for (i = 0; i < I8042_NUM_PORTS; i++) {
1230 : 0 : struct serio *serio = i8042_ports[i].serio;
1231 : :
1232 [ # # # # ]: 0 : if (serio && device_may_wakeup(&serio->dev))
1233 : 0 : enable_irq_wake(i8042_ports[i].irq);
1234 : : }
1235 : :
1236 : 0 : return 0;
1237 : : }
1238 : :
1239 : 0 : static int i8042_pm_resume_noirq(struct device *dev)
1240 : : {
1241 [ # # ]: 0 : if (!pm_resume_via_firmware())
1242 : 0 : i8042_interrupt(0, NULL);
1243 : :
1244 : 0 : return 0;
1245 : : }
1246 : :
1247 : 0 : static int i8042_pm_resume(struct device *dev)
1248 : : {
1249 : 0 : bool want_reset;
1250 : 0 : int i;
1251 : :
1252 [ # # ]: 0 : for (i = 0; i < I8042_NUM_PORTS; i++) {
1253 : 0 : struct serio *serio = i8042_ports[i].serio;
1254 : :
1255 [ # # # # ]: 0 : if (serio && device_may_wakeup(&serio->dev))
1256 : 0 : disable_irq_wake(i8042_ports[i].irq);
1257 : : }
1258 : :
1259 : : /*
1260 : : * If platform firmware was not going to be involved in suspend, we did
1261 : : * not restore the controller state to whatever it had been at boot
1262 : : * time, so we do not need to do anything.
1263 : : */
1264 [ # # ]: 0 : if (!pm_suspend_via_firmware())
1265 : : return 0;
1266 : :
1267 : : /*
1268 : : * We only need to reset the controller if we are resuming after handing
1269 : : * off control to the platform firmware, otherwise we can simply restore
1270 : : * the mode.
1271 : : */
1272 : 0 : want_reset = pm_resume_via_firmware();
1273 : :
1274 : 0 : return i8042_controller_resume(want_reset);
1275 : : }
1276 : :
1277 : 0 : static int i8042_pm_thaw(struct device *dev)
1278 : : {
1279 : 0 : i8042_interrupt(0, NULL);
1280 : :
1281 : 0 : return 0;
1282 : : }
1283 : :
1284 : 0 : static int i8042_pm_reset(struct device *dev)
1285 : : {
1286 : 0 : i8042_controller_reset(false);
1287 : :
1288 : 0 : return 0;
1289 : : }
1290 : :
1291 : 0 : static int i8042_pm_restore(struct device *dev)
1292 : : {
1293 : 0 : return i8042_controller_resume(false);
1294 : : }
1295 : :
1296 : : static const struct dev_pm_ops i8042_pm_ops = {
1297 : : .suspend = i8042_pm_suspend,
1298 : : .resume_noirq = i8042_pm_resume_noirq,
1299 : : .resume = i8042_pm_resume,
1300 : : .thaw = i8042_pm_thaw,
1301 : : .poweroff = i8042_pm_reset,
1302 : : .restore = i8042_pm_restore,
1303 : : };
1304 : :
1305 : : #endif /* CONFIG_PM */
1306 : :
1307 : : /*
1308 : : * We need to reset the 8042 back to original mode on system shutdown,
1309 : : * because otherwise BIOSes will be confused.
1310 : : */
1311 : :
1312 : 0 : static void i8042_shutdown(struct platform_device *dev)
1313 : : {
1314 : 0 : i8042_controller_reset(false);
1315 : 0 : }
1316 : :
1317 : 13 : static int __init i8042_create_kbd_port(void)
1318 : : {
1319 : 13 : struct serio *serio;
1320 : 13 : struct i8042_port *port = &i8042_ports[I8042_KBD_PORT_NO];
1321 : :
1322 : 13 : serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
1323 [ + - ]: 13 : if (!serio)
1324 : : return -ENOMEM;
1325 : :
1326 [ + - ]: 13 : serio->id.type = i8042_direct ? SERIO_8042 : SERIO_8042_XL;
1327 [ + - ]: 13 : serio->write = i8042_dumbkbd ? NULL : i8042_kbd_write;
1328 : 13 : serio->start = i8042_start;
1329 : 13 : serio->stop = i8042_stop;
1330 : 13 : serio->close = i8042_port_close;
1331 : 13 : serio->ps2_cmd_mutex = &i8042_mutex;
1332 : 13 : serio->port_data = port;
1333 : 13 : serio->dev.parent = &i8042_platform_device->dev;
1334 : 13 : strlcpy(serio->name, "i8042 KBD port", sizeof(serio->name));
1335 : 13 : strlcpy(serio->phys, I8042_KBD_PHYS_DESC, sizeof(serio->phys));
1336 : 13 : strlcpy(serio->firmware_id, i8042_kbd_firmware_id,
1337 : : sizeof(serio->firmware_id));
1338 : :
1339 : 13 : port->serio = serio;
1340 : 13 : port->irq = I8042_KBD_IRQ;
1341 : :
1342 : 13 : return 0;
1343 : : }
1344 : :
1345 : 13 : static int __init i8042_create_aux_port(int idx)
1346 : : {
1347 : 13 : struct serio *serio;
1348 : 13 : int port_no = idx < 0 ? I8042_AUX_PORT_NO : I8042_MUX_PORT_NO + idx;
1349 : 13 : struct i8042_port *port = &i8042_ports[port_no];
1350 : :
1351 : 13 : serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
1352 [ + - ]: 13 : if (!serio)
1353 : : return -ENOMEM;
1354 : :
1355 : 13 : serio->id.type = SERIO_8042;
1356 : 13 : serio->write = i8042_aux_write;
1357 : 13 : serio->start = i8042_start;
1358 : 13 : serio->stop = i8042_stop;
1359 : 13 : serio->ps2_cmd_mutex = &i8042_mutex;
1360 : 13 : serio->port_data = port;
1361 : 13 : serio->dev.parent = &i8042_platform_device->dev;
1362 [ + - ]: 13 : if (idx < 0) {
1363 : 13 : strlcpy(serio->name, "i8042 AUX port", sizeof(serio->name));
1364 : 13 : strlcpy(serio->phys, I8042_AUX_PHYS_DESC, sizeof(serio->phys));
1365 : 13 : strlcpy(serio->firmware_id, i8042_aux_firmware_id,
1366 : : sizeof(serio->firmware_id));
1367 : 13 : serio->close = i8042_port_close;
1368 : : } else {
1369 : 0 : snprintf(serio->name, sizeof(serio->name), "i8042 AUX%d port", idx);
1370 : 0 : snprintf(serio->phys, sizeof(serio->phys), I8042_MUX_PHYS_DESC, idx + 1);
1371 : 0 : strlcpy(serio->firmware_id, i8042_aux_firmware_id,
1372 : : sizeof(serio->firmware_id));
1373 : : }
1374 : :
1375 : 13 : port->serio = serio;
1376 : 13 : port->mux = idx;
1377 : 13 : port->irq = I8042_AUX_IRQ;
1378 : :
1379 : 13 : return 0;
1380 : : }
1381 : :
1382 : 0 : static void __init i8042_free_kbd_port(void)
1383 : : {
1384 : 0 : kfree(i8042_ports[I8042_KBD_PORT_NO].serio);
1385 : 0 : i8042_ports[I8042_KBD_PORT_NO].serio = NULL;
1386 : 0 : }
1387 : :
1388 : 0 : static void __init i8042_free_aux_ports(void)
1389 : : {
1390 : 0 : int i;
1391 : :
1392 [ # # ]: 0 : for (i = I8042_AUX_PORT_NO; i < I8042_NUM_PORTS; i++) {
1393 : 0 : kfree(i8042_ports[i].serio);
1394 : 0 : i8042_ports[i].serio = NULL;
1395 : : }
1396 : 0 : }
1397 : :
1398 : 13 : static void __init i8042_register_ports(void)
1399 : : {
1400 : 13 : int i;
1401 : :
1402 [ + + ]: 91 : for (i = 0; i < I8042_NUM_PORTS; i++) {
1403 : 78 : struct serio *serio = i8042_ports[i].serio;
1404 : :
1405 [ + + ]: 78 : if (!serio)
1406 : 52 : continue;
1407 : :
1408 : 26 : printk(KERN_INFO "serio: %s at %#lx,%#lx irq %d\n",
1409 : 26 : serio->name,
1410 : : (unsigned long) I8042_DATA_REG,
1411 : : (unsigned long) I8042_COMMAND_REG,
1412 : : i8042_ports[i].irq);
1413 : 26 : serio_register_port(serio);
1414 : : }
1415 : 13 : }
1416 : :
1417 : 0 : static void i8042_unregister_ports(void)
1418 : : {
1419 : 0 : int i;
1420 : :
1421 [ # # ]: 0 : for (i = 0; i < I8042_NUM_PORTS; i++) {
1422 [ # # ]: 0 : if (i8042_ports[i].serio) {
1423 : 0 : serio_unregister_port(i8042_ports[i].serio);
1424 : 0 : i8042_ports[i].serio = NULL;
1425 : : }
1426 : : }
1427 : 0 : }
1428 : :
1429 : 0 : static void i8042_free_irqs(void)
1430 : : {
1431 [ # # ]: 0 : if (i8042_aux_irq_registered)
1432 : 0 : free_irq(I8042_AUX_IRQ, i8042_platform_device);
1433 [ # # ]: 0 : if (i8042_kbd_irq_registered)
1434 : 0 : free_irq(I8042_KBD_IRQ, i8042_platform_device);
1435 : :
1436 : 0 : i8042_aux_irq_registered = i8042_kbd_irq_registered = false;
1437 : 0 : }
1438 : :
1439 : 13 : static int __init i8042_setup_aux(void)
1440 : : {
1441 : 13 : int (*aux_enable)(void);
1442 : 13 : int error;
1443 : 13 : int i;
1444 : :
1445 [ + - ]: 13 : if (i8042_check_aux())
1446 : : return -ENODEV;
1447 : :
1448 [ + - + - ]: 13 : if (i8042_nomux || i8042_check_mux()) {
1449 : 13 : error = i8042_create_aux_port(-1);
1450 [ - + ]: 13 : if (error)
1451 : 0 : goto err_free_ports;
1452 : : aux_enable = i8042_enable_aux_port;
1453 : : } else {
1454 [ # # ]: 0 : for (i = 0; i < I8042_NUM_MUX_PORTS; i++) {
1455 : 0 : error = i8042_create_aux_port(i);
1456 [ # # ]: 0 : if (error)
1457 : 0 : goto err_free_ports;
1458 : : }
1459 : : aux_enable = i8042_enable_mux_ports;
1460 : : }
1461 : :
1462 : 13 : error = request_irq(I8042_AUX_IRQ, i8042_interrupt, IRQF_SHARED,
1463 : : "i8042", i8042_platform_device);
1464 [ - + ]: 13 : if (error)
1465 : 0 : goto err_free_ports;
1466 : :
1467 [ - + ]: 13 : if (aux_enable())
1468 : 0 : goto err_free_irq;
1469 : :
1470 : 13 : i8042_aux_irq_registered = true;
1471 : 13 : return 0;
1472 : :
1473 : : err_free_irq:
1474 : 0 : free_irq(I8042_AUX_IRQ, i8042_platform_device);
1475 : 0 : err_free_ports:
1476 : 0 : i8042_free_aux_ports();
1477 : 0 : return error;
1478 : : }
1479 : :
1480 : 13 : static int __init i8042_setup_kbd(void)
1481 : : {
1482 : 13 : int error;
1483 : :
1484 : 13 : error = i8042_create_kbd_port();
1485 [ + - ]: 13 : if (error)
1486 : : return error;
1487 : :
1488 : 13 : error = request_irq(I8042_KBD_IRQ, i8042_interrupt, IRQF_SHARED,
1489 : : "i8042", i8042_platform_device);
1490 [ - + ]: 13 : if (error)
1491 : 0 : goto err_free_port;
1492 : :
1493 : 13 : error = i8042_enable_kbd_port();
1494 [ - + ]: 13 : if (error)
1495 : 0 : goto err_free_irq;
1496 : :
1497 : 13 : i8042_kbd_irq_registered = true;
1498 : 13 : return 0;
1499 : :
1500 : : err_free_irq:
1501 : 0 : free_irq(I8042_KBD_IRQ, i8042_platform_device);
1502 : 0 : err_free_port:
1503 : 0 : i8042_free_kbd_port();
1504 : 0 : return error;
1505 : : }
1506 : :
1507 : 78 : static int i8042_kbd_bind_notifier(struct notifier_block *nb,
1508 : : unsigned long action, void *data)
1509 : : {
1510 : 78 : struct device *dev = data;
1511 : 78 : struct serio *serio = to_serio_port(dev);
1512 : 78 : struct i8042_port *port = serio->port_data;
1513 : :
1514 [ + + ]: 78 : if (serio != i8042_ports[I8042_KBD_PORT_NO].serio)
1515 : : return 0;
1516 : :
1517 [ + - + ]: 26 : switch (action) {
1518 : 13 : case BUS_NOTIFY_BOUND_DRIVER:
1519 : 13 : port->driver_bound = true;
1520 : 13 : break;
1521 : :
1522 : 0 : case BUS_NOTIFY_UNBIND_DRIVER:
1523 : 0 : port->driver_bound = false;
1524 : 0 : break;
1525 : : }
1526 : :
1527 : : return 0;
1528 : : }
1529 : :
1530 : 13 : static int __init i8042_probe(struct platform_device *dev)
1531 : : {
1532 : 13 : int error;
1533 : :
1534 : 13 : i8042_platform_device = dev;
1535 : :
1536 [ - + ]: 13 : if (i8042_reset == I8042_RESET_ALWAYS) {
1537 : 0 : error = i8042_controller_selftest();
1538 [ # # ]: 0 : if (error)
1539 : : return error;
1540 : : }
1541 : :
1542 : 13 : error = i8042_controller_init();
1543 [ + - ]: 13 : if (error)
1544 : : return error;
1545 : :
1546 : : #ifdef CONFIG_X86
1547 [ - + ]: 13 : if (i8042_dritek)
1548 : 0 : i8042_dritek_enable();
1549 : : #endif
1550 : :
1551 [ + - ]: 13 : if (!i8042_noaux) {
1552 : 13 : error = i8042_setup_aux();
1553 [ - + - - ]: 13 : if (error && error != -ENODEV && error != -EBUSY)
1554 : 0 : goto out_fail;
1555 : : }
1556 : :
1557 [ + - ]: 13 : if (!i8042_nokbd) {
1558 : 13 : error = i8042_setup_kbd();
1559 [ - + ]: 13 : if (error)
1560 : 0 : goto out_fail;
1561 : : }
1562 : : /*
1563 : : * Ok, everything is ready, let's register all serio ports
1564 : : */
1565 : 13 : i8042_register_ports();
1566 : :
1567 : 13 : return 0;
1568 : :
1569 : 0 : out_fail:
1570 : 0 : i8042_free_aux_ports(); /* in case KBD failed but AUX not */
1571 : 0 : i8042_free_irqs();
1572 : 0 : i8042_controller_reset(false);
1573 : 0 : i8042_platform_device = NULL;
1574 : :
1575 : 0 : return error;
1576 : : }
1577 : :
1578 : 0 : static int i8042_remove(struct platform_device *dev)
1579 : : {
1580 : 0 : i8042_unregister_ports();
1581 : 0 : i8042_free_irqs();
1582 : 0 : i8042_controller_reset(false);
1583 : 0 : i8042_platform_device = NULL;
1584 : :
1585 : 0 : return 0;
1586 : : }
1587 : :
1588 : : static struct platform_driver i8042_driver = {
1589 : : .driver = {
1590 : : .name = "i8042",
1591 : : #ifdef CONFIG_PM
1592 : : .pm = &i8042_pm_ops,
1593 : : #endif
1594 : : },
1595 : : .remove = i8042_remove,
1596 : : .shutdown = i8042_shutdown,
1597 : : };
1598 : :
1599 : : static struct notifier_block i8042_kbd_bind_notifier_block = {
1600 : : .notifier_call = i8042_kbd_bind_notifier,
1601 : : };
1602 : :
1603 : 13 : static int __init i8042_init(void)
1604 : : {
1605 : 13 : struct platform_device *pdev;
1606 : 13 : int err;
1607 : :
1608 : 13 : dbg_init();
1609 : :
1610 : 13 : err = i8042_platform_init();
1611 [ + - ]: 13 : if (err)
1612 : : return err;
1613 : :
1614 : 13 : err = i8042_controller_check();
1615 : 13 : if (err)
1616 : 0 : goto err_platform_exit;
1617 : :
1618 : 13 : pdev = platform_create_bundle(&i8042_driver, i8042_probe, NULL, 0, NULL, 0);
1619 [ - + ]: 13 : if (IS_ERR(pdev)) {
1620 : 0 : err = PTR_ERR(pdev);
1621 : 0 : goto err_platform_exit;
1622 : : }
1623 : :
1624 : 13 : bus_register_notifier(&serio_bus, &i8042_kbd_bind_notifier_block);
1625 : 13 : panic_blink = i8042_panic_blink;
1626 : :
1627 : 13 : return 0;
1628 : :
1629 : 0 : err_platform_exit:
1630 : 0 : i8042_platform_exit();
1631 : 0 : return err;
1632 : : }
1633 : :
1634 : 0 : static void __exit i8042_exit(void)
1635 : : {
1636 : 0 : platform_device_unregister(i8042_platform_device);
1637 : 0 : platform_driver_unregister(&i8042_driver);
1638 : 0 : i8042_platform_exit();
1639 : :
1640 : 0 : bus_unregister_notifier(&serio_bus, &i8042_kbd_bind_notifier_block);
1641 : 0 : panic_blink = NULL;
1642 : 0 : }
1643 : :
1644 : : module_init(i8042_init);
1645 : : module_exit(i8042_exit);
|
