1 /*
2 * AT and PS/2 keyboard driver
3 *
4 * Copyright (c) 1999-2002 Vojtech Pavlik
5 */
6
7 /*
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published by
10 * the Free Software Foundation.
11 */
12
13 /*
14 * This driver can handle standard AT keyboards and PS/2 keyboards in
15 * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb
16 * input-only controllers and AT keyboards connected over a one way RS232
17 * converter.
18 */
19
20 #include <linux/delay.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/input.h>
27 #include <linux/serio.h>
28 #include <linux/workqueue.h>
29 #include <linux/libps2.h>
30
31 #define DRIVER_DESC "AT and PS/2 keyboard driver"
32
33 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
34 MODULE_DESCRIPTION(DRIVER_DESC);
35 MODULE_LICENSE("GPL");
36
37 static int atkbd_set = 2;
38 module_param_named(set, atkbd_set, int, 0);
39 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
40
41 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
42 static int atkbd_reset;
43 #else
44 static int atkbd_reset = 1;
45 #endif
46 module_param_named(reset, atkbd_reset, bool, 0);
47 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
48
49 static int atkbd_softrepeat;
50 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
51 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
52
53 static int atkbd_softraw = 1;
54 module_param_named(softraw, atkbd_softraw, bool, 0);
55 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
56
57 static int atkbd_scroll;
58 module_param_named(scroll, atkbd_scroll, bool, 0);
59 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
60
61 static int atkbd_extra;
62 module_param_named(extra, atkbd_extra, bool, 0);
63 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
64
65 __obsolete_setup("atkbd_set=");
66 __obsolete_setup("atkbd_reset");
67 __obsolete_setup("atkbd_softrepeat=");
68
69 /*
70 * Scancode to keycode tables. These are just the default setting, and
71 * are loadable via an userland utility.
72 */
73
74 #if defined(__hppa__)
75 #include "hpps2atkbd.h"
76 #else
77
78 static unsigned char atkbd_set2_keycode[512] = {
79
80 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
81 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
82 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
83 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
84 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
85 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
86 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
87 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
88
89 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
90 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
91 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
92 159, 0,115, 0,164, 0, 0,116,158, 0,150,166, 0, 0, 0,142,
93 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
94 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
95 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
96 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
97
98 0, 0, 0, 65, 99,
99 };
100
101 #endif
102
103 static unsigned char atkbd_set3_keycode[512] = {
104
105 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
106 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
107 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
108 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
109 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
110 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
111 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
112 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
113
114 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
115 0,139,150,163,165,115,152,150,166,140,160,154,113,114,167,168,
116 148,149,147,140
117 };
118
119 static unsigned char atkbd_unxlate_table[128] = {
120 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
121 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
122 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
123 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
124 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
125 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
126 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
127 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
128 };
129
130 #define ATKBD_CMD_SETLEDS 0x10ed
131 #define ATKBD_CMD_GSCANSET 0x11f0
132 #define ATKBD_CMD_SSCANSET 0x10f0
133 #define ATKBD_CMD_GETID 0x02f2
134 #define ATKBD_CMD_SETREP 0x10f3
135 #define ATKBD_CMD_ENABLE 0x00f4
136 #define ATKBD_CMD_RESET_DIS 0x00f5
137 #define ATKBD_CMD_SETALL_MBR 0x00fa
138 #define ATKBD_CMD_RESET_BAT 0x02ff
139 #define ATKBD_CMD_RESEND 0x00fe
140 #define ATKBD_CMD_EX_ENABLE 0x10ea
141 #define ATKBD_CMD_EX_SETLEDS 0x20eb
142 #define ATKBD_CMD_OK_GETID 0x02e8
143
144
145 #define ATKBD_RET_ACK 0xfa
146 #define ATKBD_RET_NAK 0xfe
147 #define ATKBD_RET_BAT 0xaa
148 #define ATKBD_RET_EMUL0 0xe0
149 #define ATKBD_RET_EMUL1 0xe1
150 #define ATKBD_RET_RELEASE 0xf0
151 #define ATKBD_RET_HANGUEL 0xf1
152 #define ATKBD_RET_HANJA 0xf2
153 #define ATKBD_RET_ERR 0xff
154
155 #define ATKBD_KEY_UNKNOWN 0
156 #define ATKBD_KEY_NULL 255
157
158 #define ATKBD_SCR_1 254
159 #define ATKBD_SCR_2 253
160 #define ATKBD_SCR_4 252
161 #define ATKBD_SCR_8 251
162 #define ATKBD_SCR_CLICK 250
163
164 #define ATKBD_SPECIAL 250
165
166 static unsigned char atkbd_scroll_keys[5][2] = {
167 { ATKBD_SCR_1, 0x45 },
168 { ATKBD_SCR_2, 0x29 },
169 { ATKBD_SCR_4, 0x36 },
170 { ATKBD_SCR_8, 0x27 },
171 { ATKBD_SCR_CLICK, 0x60 },
172 };
173
174 /*
175 * The atkbd control structure
176 */
177
178 struct atkbd {
179
180 struct ps2dev ps2dev;
181
182 /* Written only during init */
183 char name[64];
184 char phys[32];
185 struct input_dev dev;
186
187 unsigned short id;
188 unsigned char keycode[512];
189 unsigned char set;
190 unsigned char translated;
191 unsigned char extra;
192 unsigned char write;
193 unsigned char softrepeat;
194 unsigned char softraw;
195 unsigned char scroll;
196 unsigned char enabled;
197
198 /* Accessed only from interrupt */
199 unsigned char emul;
200 unsigned char resend;
201 unsigned char release;
202 unsigned char bat_xl;
203 unsigned int last;
204 unsigned long time;
205 };
206
207 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
208 ssize_t (*handler)(struct atkbd *, char *));
209 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
210 ssize_t (*handler)(struct atkbd *, const char *, size_t));
211 #define ATKBD_DEFINE_ATTR(_name) \
212 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
213 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
214 static ssize_t atkbd_do_show_##_name(struct device *d, char *b) \
215 { \
216 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
217 } \
218 static ssize_t atkbd_do_set_##_name(struct device *d, const char *b, size_t s) \
219 { \
220 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
221 } \
222 static struct device_attribute atkbd_attr_##_name = \
223 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
224
225 ATKBD_DEFINE_ATTR(extra);
226 ATKBD_DEFINE_ATTR(scroll);
227 ATKBD_DEFINE_ATTR(set);
228 ATKBD_DEFINE_ATTR(softrepeat);
229 ATKBD_DEFINE_ATTR(softraw);
230
231
232 static void atkbd_report_key(struct input_dev *dev, struct pt_regs *regs, int code, int value)
233 {
234 input_regs(dev, regs);
235 if (value == 3) {
236 input_report_key(dev, code, 1);
237 input_sync(dev);
238 input_report_key(dev, code, 0);
239 } else
240 input_event(dev, EV_KEY, code, value);
241 input_sync(dev);
242 }
243
244 /*
245 * atkbd_interrupt(). Here takes place processing of data received from
246 * the keyboard into events.
247 */
248
249 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
250 unsigned int flags, struct pt_regs *regs)
251 {
252 struct atkbd *atkbd = serio->private;
253 unsigned int code = data;
254 int scroll = 0, click = -1;
255 int value;
256
257 #ifdef ATKBD_DEBUG
258 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
259 #endif
260
261 #if !defined(__i386__) && !defined (__x86_64__)
262 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
263 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
264 serio_write(serio, ATKBD_CMD_RESEND);
265 atkbd->resend = 1;
266 goto out;
267 }
268
269 if (!flags && data == ATKBD_RET_ACK)
270 atkbd->resend = 0;
271 #endif
272
273 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
274 if (ps2_handle_ack(&atkbd->ps2dev, data))
275 goto out;
276
277 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
278 if (ps2_handle_response(&atkbd->ps2dev, data))
279 goto out;
280
281 if (!atkbd->enabled)
282 goto out;
283
284 input_event(&atkbd->dev, EV_MSC, MSC_RAW, code);
285
286 if (atkbd->translated) {
287
288 if (atkbd->emul ||
289 !(code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1 ||
290 code == ATKBD_RET_HANGUEL || code == ATKBD_RET_HANJA ||
291 code == ATKBD_RET_ERR ||
292 (code == ATKBD_RET_BAT && !atkbd->bat_xl))) {
293 atkbd->release = code >> 7;
294 code &= 0x7f;
295 }
296
297 if (!atkbd->emul &&
298 (code & 0x7f) == (ATKBD_RET_BAT & 0x7f))
299 atkbd->bat_xl = !atkbd->release;
300 }
301
302 switch (code) {
303 case ATKBD_RET_BAT:
304 atkbd->enabled = 0;
305 serio_rescan(atkbd->ps2dev.serio);
306 goto out;
307 case ATKBD_RET_EMUL0:
308 atkbd->emul = 1;
309 goto out;
310 case ATKBD_RET_EMUL1:
311 atkbd->emul = 2;
312 goto out;
313 case ATKBD_RET_RELEASE:
314 atkbd->release = 1;
315 goto out;
316 case ATKBD_RET_HANGUEL:
317 atkbd_report_key(&atkbd->dev, regs, KEY_HANGUEL, 3);
318 goto out;
319 case ATKBD_RET_HANJA:
320 atkbd_report_key(&atkbd->dev, regs, KEY_HANJA, 3);
321 goto out;
322 case ATKBD_RET_ERR:
323 printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
324 goto out;
325 }
326
327 if (atkbd->set != 3)
328 code = (code & 0x7f) | ((code & 0x80) << 1);
329 if (atkbd->emul) {
330 if (--atkbd->emul)
331 goto out;
332 code |= (atkbd->set != 3) ? 0x80 : 0x100;
333 }
334
335 if (atkbd->keycode[code] != ATKBD_KEY_NULL)
336 input_event(&atkbd->dev, EV_MSC, MSC_SCAN, code);
337
338 switch (atkbd->keycode[code]) {
339 case ATKBD_KEY_NULL:
340 break;
341 case ATKBD_KEY_UNKNOWN:
342 if (data == ATKBD_RET_ACK || data == ATKBD_RET_NAK) {
343 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. Some program, "
344 "like XFree86, might be trying access hardware directly.\n",
345 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
346 } else {
347 printk(KERN_WARNING "atkbd.c: Unknown key %s "
348 "(%s set %d, code %#x on %s).\n",
349 atkbd->release ? "released" : "pressed",
350 atkbd->translated ? "translated" : "raw",
351 atkbd->set, code, serio->phys);
352 printk(KERN_WARNING "atkbd.c: Use 'setkeycodes %s%02x <keycode>' "
353 "to make it known.\n",
354 code & 0x80 ? "e0" : "", code & 0x7f);
355 }
356 input_sync(&atkbd->dev);
357 break;
358 case ATKBD_SCR_1:
359 scroll = 1 - atkbd->release * 2;
360 break;
361 case ATKBD_SCR_2:
362 scroll = 2 - atkbd->release * 4;
363 break;
364 case ATKBD_SCR_4:
365 scroll = 4 - atkbd->release * 8;
366 break;
367 case ATKBD_SCR_8:
368 scroll = 8 - atkbd->release * 16;
369 break;
370 case ATKBD_SCR_CLICK:
371 click = !atkbd->release;
372 break;
373 default:
374 value = atkbd->release ? 0 :
375 (1 + (!atkbd->softrepeat && test_bit(atkbd->keycode[code], atkbd->dev.key)));
376
377 switch (value) { /* Workaround Toshiba laptop multiple keypress */
378 case 0:
379 atkbd->last = 0;
380 break;
381 case 1:
382 atkbd->last = code;
383 atkbd->time = jiffies + (atkbd->dev.rep[REP_DELAY] * HZ + 500) / 1000 / 2;
384 break;
385 case 2:
386 if (!time_after(jiffies, atkbd->time) && atkbd->last == code)
387 value = 1;
388 break;
389 }
390
391 atkbd_report_key(&atkbd->dev, regs, atkbd->keycode[code], value);
392 }
393
394 if (scroll || click != -1) {
395 input_regs(&atkbd->dev, regs);
396 input_report_key(&atkbd->dev, BTN_MIDDLE, click);
397 input_report_rel(&atkbd->dev, REL_WHEEL, scroll);
398 input_sync(&atkbd->dev);
399 }
400
401 atkbd->release = 0;
402 out:
403 return IRQ_HANDLED;
404 }
405
406
407 /*
408 * Event callback from the input module. Events that change the state of
409 * the hardware are processed here.
410 */
411
412 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
413 {
414 struct atkbd *atkbd = dev->private;
415 const short period[32] =
416 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
417 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
418 const short delay[4] =
419 { 250, 500, 750, 1000 };
420 unsigned char param[2];
421 int i, j;
422
423 if (!atkbd->write)
424 return -1;
425
426 switch (type) {
427
428 case EV_LED:
429
430 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
431 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
432 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
433 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS);
434
435 if (atkbd->extra) {
436 param[0] = 0;
437 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
438 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
439 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
440 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
441 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
442 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS);
443 }
444
445 return 0;
446
447
448 case EV_REP:
449
450 if (atkbd->softrepeat) return 0;
451
452 i = j = 0;
453 while (i < 32 && period[i] < dev->rep[REP_PERIOD]) i++;
454 while (j < 4 && delay[j] < dev->rep[REP_DELAY]) j++;
455 dev->rep[REP_PERIOD] = period[i];
456 dev->rep[REP_DELAY] = delay[j];
457 param[0] = i | (j << 5);
458 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP);
459
460 return 0;
461 }
462
463 return -1;
464 }
465
466 /*
467 * atkbd_enable() signals that interrupt handler is allowed to
468 * generate input events.
469 */
470
471 static inline void atkbd_enable(struct atkbd *atkbd)
472 {
473 serio_pause_rx(atkbd->ps2dev.serio);
474 atkbd->enabled = 1;
475 serio_continue_rx(atkbd->ps2dev.serio);
476 }
477
478 /*
479 * atkbd_disable() tells input handler that all incoming data except
480 * for ACKs and command response should be dropped.
481 */
482
483 static inline void atkbd_disable(struct atkbd *atkbd)
484 {
485 serio_pause_rx(atkbd->ps2dev.serio);
486 atkbd->enabled = 0;
487 serio_continue_rx(atkbd->ps2dev.serio);
488 }
489
490 /*
491 * atkbd_probe() probes for an AT keyboard on a serio port.
492 */
493
494 static int atkbd_probe(struct atkbd *atkbd)
495 {
496 struct ps2dev *ps2dev = &atkbd->ps2dev;
497 unsigned char param[2];
498
499 /*
500 * Some systems, where the bit-twiddling when testing the io-lines of the
501 * controller may confuse the keyboard need a full reset of the keyboard. On
502 * these systems the BIOS also usually doesn't do it for us.
503 */
504
505 if (atkbd_reset)
506 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
507 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
508
509 /*
510 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
511 * Some keyboards report different values, but the first byte is always 0xab or
512 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
513 * should make sure we don't try to set the LEDs on it.
514 */
515
516 param[0] = param[1] = 0xa5; /* initialize with invalid values */
517 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
518
519 /*
520 * If the get ID command failed, we check if we can at least set the LEDs on
521 * the keyboard. This should work on every keyboard out there. It also turns
522 * the LEDs off, which we want anyway.
523 */
524 param[0] = 0;
525 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
526 return -1;
527 atkbd->id = 0xabba;
528 return 0;
529 }
530
531 if (param[0] != 0xab && param[0] != 0xac && /* Regular and NCD Sun keyboards */
532 param[0] != 0x2b && param[0] != 0x5d && /* Trust keyboard, raw and translated */
533 param[0] != 0x60 && param[0] != 0x47) /* NMB SGI keyboard, raw and translated */
534 return -1;
535
536 atkbd->id = (param[0] << 8) | param[1];
537
538 if (atkbd->id == 0xaca1 && atkbd->translated) {
539 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
540 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
541 return -1;
542 }
543
544 return 0;
545 }
546
547 /*
548 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
549 * sets it into that. Unfortunately there are keyboards that can be switched
550 * to Set 3, but don't work well in that (BTC Multimedia ...)
551 */
552
553 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
554 {
555 struct ps2dev *ps2dev = &atkbd->ps2dev;
556 unsigned char param[2];
557
558 atkbd->extra = 0;
559 /*
560 * For known special keyboards we can go ahead and set the correct set.
561 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
562 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
563 */
564
565 if (atkbd->translated)
566 return 2;
567
568 if (atkbd->id == 0xaca1) {
569 param[0] = 3;
570 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
571 return 3;
572 }
573
574 if (allow_extra) {
575 param[0] = 0x71;
576 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
577 atkbd->extra = 1;
578 return 2;
579 }
580 }
581
582 if (target_set != 3)
583 return 2;
584
585 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
586 atkbd->id = param[0] << 8 | param[1];
587 return 2;
588 }
589
590 param[0] = 3;
591 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
592 return 2;
593
594 param[0] = 0;
595 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
596 return 2;
597
598 if (param[0] != 3) {
599 param[0] = 2;
600 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
601 return 2;
602 }
603
604 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
605
606 return 3;
607 }
608
609 static int atkbd_activate(struct atkbd *atkbd)
610 {
611 struct ps2dev *ps2dev = &atkbd->ps2dev;
612 unsigned char param[1];
613
614 /*
615 * Set the LEDs to a defined state.
616 */
617
618 param[0] = 0;
619 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
620 return -1;
621
622 /*
623 * Set autorepeat to fastest possible.
624 */
625
626 param[0] = 0;
627 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
628 return -1;
629
630 /*
631 * Enable the keyboard to receive keystrokes.
632 */
633
634 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
635 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
636 ps2dev->serio->phys);
637 return -1;
638 }
639
640 return 0;
641 }
642
643 /*
644 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
645 * reboot.
646 */
647
648 static void atkbd_cleanup(struct serio *serio)
649 {
650 struct atkbd *atkbd = serio->private;
651 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
652 }
653
654
655 /*
656 * atkbd_disconnect() closes and frees.
657 */
658
659 static void atkbd_disconnect(struct serio *serio)
660 {
661 struct atkbd *atkbd = serio->private;
662
663 atkbd_disable(atkbd);
664
665 /* make sure we don't have a command in flight */
666 synchronize_kernel();
667 flush_scheduled_work();
668
669 device_remove_file(&serio->dev, &atkbd_attr_extra);
670 device_remove_file(&serio->dev, &atkbd_attr_scroll);
671 device_remove_file(&serio->dev, &atkbd_attr_set);
672 device_remove_file(&serio->dev, &atkbd_attr_softrepeat);
673 device_remove_file(&serio->dev, &atkbd_attr_softraw);
674
675 input_unregister_device(&atkbd->dev);
676 serio_close(serio);
677 kfree(atkbd);
678 }
679
680
681 /*
682 * atkbd_set_device_attrs() initializes keyboard's keycode table
683 * according to the selected scancode set
684 */
685
686 static void atkbd_set_keycode_table(struct atkbd *atkbd)
687 {
688 int i, j;
689
690 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
691
692 if (atkbd->translated) {
693 for (i = 0; i < 128; i++) {
694 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
695 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
696 if (atkbd->scroll)
697 for (j = 0; i < 5; i++) {
698 if (atkbd_unxlate_table[i] == atkbd_scroll_keys[j][1])
699 atkbd->keycode[i] = atkbd_scroll_keys[j][0];
700 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j][1])
701 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j][0];
702 }
703 }
704 } else if (atkbd->set == 3) {
705 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
706 } else {
707 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
708
709 if (atkbd->scroll)
710 for (i = 0; i < 5; i++)
711 atkbd->keycode[atkbd_scroll_keys[i][1]] = atkbd_scroll_keys[i][0];
712 }
713 }
714
715 /*
716 * atkbd_set_device_attrs() sets up keyboard's input device structure
717 */
718
719 static void atkbd_set_device_attrs(struct atkbd *atkbd)
720 {
721 int i;
722
723 memset(&atkbd->dev, 0, sizeof(struct input_dev));
724
725 init_input_dev(&atkbd->dev);
726
727 atkbd->dev.name = atkbd->name;
728 atkbd->dev.phys = atkbd->phys;
729 atkbd->dev.id.bustype = BUS_I8042;
730 atkbd->dev.id.vendor = 0x0001;
731 atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set;
732 atkbd->dev.id.version = atkbd->id;
733 atkbd->dev.event = atkbd_event;
734 atkbd->dev.private = atkbd;
735 atkbd->dev.dev = &atkbd->ps2dev.serio->dev;
736
737 atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);
738
739 if (atkbd->write) {
740 atkbd->dev.evbit[0] |= BIT(EV_LED);
741 atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
742 }
743
744 if (atkbd->extra)
745 atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |
746 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
747
748 if (!atkbd->softrepeat) {
749 atkbd->dev.rep[REP_DELAY] = 250;
750 atkbd->dev.rep[REP_PERIOD] = 33;
751 }
752
753 atkbd->dev.mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);
754
755 if (atkbd->scroll) {
756 atkbd->dev.evbit[0] |= BIT(EV_REL);
757 atkbd->dev.relbit[0] = BIT(REL_WHEEL);
758 set_bit(BTN_MIDDLE, atkbd->dev.keybit);
759 }
760
761 atkbd->dev.keycode = atkbd->keycode;
762 atkbd->dev.keycodesize = sizeof(unsigned char);
763 atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
764
765 for (i = 0; i < 512; i++)
766 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
767 set_bit(atkbd->keycode[i], atkbd->dev.keybit);
768 }
769
770 /*
771 * atkbd_connect() is called when the serio module finds and interface
772 * that isn't handled yet by an appropriate device driver. We check if
773 * there is an AT keyboard out there and if yes, we register ourselves
774 * to the input module.
775 */
776
777 static void atkbd_connect(struct serio *serio, struct serio_driver *drv)
778 {
779 struct atkbd *atkbd;
780
781 if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL)))
782 return;
783 memset(atkbd, 0, sizeof(struct atkbd));
784
785 ps2_init(&atkbd->ps2dev, serio);
786
787 switch (serio->type & SERIO_TYPE) {
788
789 case SERIO_8042_XL:
790 atkbd->translated = 1;
791 case SERIO_8042:
792 if (serio->write)
793 atkbd->write = 1;
794 break;
795 case SERIO_RS232:
796 if ((serio->type & SERIO_PROTO) == SERIO_PS2SER)
797 break;
798 default:
799 kfree(atkbd);
800 return;
801 }
802
803 atkbd->softraw = atkbd_softraw;
804 atkbd->softrepeat = atkbd_softrepeat;
805 atkbd->scroll = atkbd_scroll;
806
807 if (!atkbd->write)
808 atkbd->softrepeat = 1;
809
810 if (atkbd->softrepeat)
811 atkbd->softraw = 1;
812
813 serio->private = atkbd;
814
815 if (serio_open(serio, drv)) {
816 kfree(atkbd);
817 return;
818 }
819
820 if (atkbd->write) {
821
822 if (atkbd_probe(atkbd)) {
823 serio_close(serio);
824 serio->private = NULL;
825 kfree(atkbd);
826 return;
827 }
828
829 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
830 atkbd_activate(atkbd);
831
832 } else {
833 atkbd->set = 2;
834 atkbd->id = 0xab00;
835 }
836
837 if (atkbd->extra)
838 sprintf(atkbd->name, "AT Set 2 Extra keyboard");
839 else
840 sprintf(atkbd->name, "AT %s Set %d keyboard",
841 atkbd->translated ? "Translated" : "Raw", atkbd->set);
842
843 sprintf(atkbd->phys, "%s/input0", serio->phys);
844
845 atkbd_set_keycode_table(atkbd);
846 atkbd_set_device_attrs(atkbd);
847
848 input_register_device(&atkbd->dev);
849
850 device_create_file(&serio->dev, &atkbd_attr_extra);
851 device_create_file(&serio->dev, &atkbd_attr_scroll);
852 device_create_file(&serio->dev, &atkbd_attr_set);
853 device_create_file(&serio->dev, &atkbd_attr_softrepeat);
854 device_create_file(&serio->dev, &atkbd_attr_softraw);
855
856 atkbd_enable(atkbd);
857
858 printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys);
859 }
860
861 /*
862 * atkbd_reconnect() tries to restore keyboard into a sane state and is
863 * most likely called on resume.
864 */
865
866 static int atkbd_reconnect(struct serio *serio)
867 {
868 struct atkbd *atkbd = serio->private;
869 struct serio_driver *drv = serio->drv;
870 unsigned char param[1];
871
872 if (!atkbd || !drv) {
873 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
874 return -1;
875 }
876
877 atkbd_disable(atkbd);
878
879 if (atkbd->write) {
880 param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0)
881 | (test_bit(LED_NUML, atkbd->dev.led) ? 2 : 0)
882 | (test_bit(LED_CAPSL, atkbd->dev.led) ? 4 : 0);
883
884 if (atkbd_probe(atkbd))
885 return -1;
886 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
887 return -1;
888
889 atkbd_activate(atkbd);
890
891 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
892 return -1;
893 }
894
895 atkbd_enable(atkbd);
896
897 return 0;
898 }
899
900 static struct serio_driver atkbd_drv = {
901 .driver = {
902 .name = "atkbd",
903 },
904 .description = DRIVER_DESC,
905 .interrupt = atkbd_interrupt,
906 .connect = atkbd_connect,
907 .reconnect = atkbd_reconnect,
908 .disconnect = atkbd_disconnect,
909 .cleanup = atkbd_cleanup,
910 };
911
912 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
913 ssize_t (*handler)(struct atkbd *, char *))
914 {
915 struct serio *serio = to_serio_port(dev);
916 int retval;
917
918 retval = serio_pin_driver(serio);
919 if (retval)
920 return retval;
921
922 if (serio->drv != &atkbd_drv) {
923 retval = -ENODEV;
924 goto out;
925 }
926
927 retval = handler((struct atkbd *)serio->private, buf);
928
929 out:
930 serio_unpin_driver(serio);
931 return retval;
932 }
933
934 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
935 ssize_t (*handler)(struct atkbd *, const char *, size_t))
936 {
937 struct serio *serio = to_serio_port(dev);
938 struct atkbd *atkbd;
939 int retval;
940
941 retval = serio_pin_driver(serio);
942 if (retval)
943 return retval;
944
945 if (serio->drv != &atkbd_drv) {
946 retval = -ENODEV;
947 goto out;
948 }
949
950 atkbd = serio->private;
951 atkbd_disable(atkbd);
952 retval = handler(atkbd, buf, count);
953 atkbd_enable(atkbd);
954
955 out:
956 serio_unpin_driver(serio);
957 return retval;
958 }
959
960 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
961 {
962 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
963 }
964
965 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
966 {
967 unsigned long value;
968 char *rest;
969
970 if (!atkbd->write)
971 return -EIO;
972
973 value = simple_strtoul(buf, &rest, 10);
974 if (*rest || value > 1)
975 return -EINVAL;
976
977 if (atkbd->extra != value) {
978 /* unregister device as it's properties will change */
979 input_unregister_device(&atkbd->dev);
980 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
981 atkbd_activate(atkbd);
982 atkbd_set_device_attrs(atkbd);
983 input_register_device(&atkbd->dev);
984 }
985 return count;
986 }
987
988 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
989 {
990 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
991 }
992
993 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
994 {
995 unsigned long value;
996 char *rest;
997
998 value = simple_strtoul(buf, &rest, 10);
999 if (*rest || value > 1)
1000 return -EINVAL;
1001
1002 if (atkbd->scroll != value) {
1003 /* unregister device as it's properties will change */
1004 input_unregister_device(&atkbd->dev);
1005 atkbd->scroll = value;
1006 atkbd_set_keycode_table(atkbd);
1007 atkbd_set_device_attrs(atkbd);
1008 input_register_device(&atkbd->dev);
1009 }
1010 return count;
1011 }
1012
1013 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1014 {
1015 return sprintf(buf, "%d\n", atkbd->set);
1016 }
1017
1018 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1019 {
1020 unsigned long value;
1021 char *rest;
1022
1023 if (!atkbd->write)
1024 return -EIO;
1025
1026 value = simple_strtoul(buf, &rest, 10);
1027 if (*rest || (value != 2 && value != 3))
1028 return -EINVAL;
1029
1030 if (atkbd->set != value) {
1031 /* unregister device as it's properties will change */
1032 input_unregister_device(&atkbd->dev);
1033 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1034 atkbd_activate(atkbd);
1035 atkbd_set_keycode_table(atkbd);
1036 atkbd_set_device_attrs(atkbd);
1037 input_register_device(&atkbd->dev);
1038 }
1039 return count;
1040 }
1041
1042 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1043 {
1044 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1045 }
1046
1047 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1048 {
1049 unsigned long value;
1050 char *rest;
1051
1052 if (!atkbd->write)
1053 return -EIO;
1054
1055 value = simple_strtoul(buf, &rest, 10);
1056 if (*rest || value > 1)
1057 return -EINVAL;
1058
1059 if (atkbd->softrepeat != value) {
1060 /* unregister device as it's properties will change */
1061 input_unregister_device(&atkbd->dev);
1062 atkbd->softrepeat = value;
1063 if (atkbd->softrepeat)
1064 atkbd->softraw = 1;
1065 atkbd_set_device_attrs(atkbd);
1066 input_register_device(&atkbd->dev);
1067 }
1068
1069 return count;
1070 }
1071
1072
1073 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1074 {
1075 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1076 }
1077
1078 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1079 {
1080 unsigned long value;
1081 char *rest;
1082
1083 value = simple_strtoul(buf, &rest, 10);
1084 if (*rest || value > 1)
1085 return -EINVAL;
1086
1087 if (atkbd->softraw != value) {
1088 /* unregister device as it's properties will change */
1089 input_unregister_device(&atkbd->dev);
1090 atkbd->softraw = value;
1091 atkbd_set_device_attrs(atkbd);
1092 input_register_device(&atkbd->dev);
1093 }
1094 return count;
1095 }
1096
1097
1098 int __init atkbd_init(void)
1099 {
1100 serio_register_driver(&atkbd_drv);
1101 return 0;
1102 }
1103
1104 void __exit atkbd_exit(void)
1105 {
1106 serio_unregister_driver(&atkbd_drv);
1107 }
1108
1109 module_init(atkbd_init);
1110 module_exit(atkbd_exit);
1111
|
This page was automatically generated by the
LXR engine.
|