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