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