11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * AT and PS/2 keyboard driver 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (c) 1999-2002 Vojtech Pavlik 51da177e4SLinus Torvalds */ 61da177e4SLinus Torvalds 71da177e4SLinus Torvalds /* 81da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify it 91da177e4SLinus Torvalds * under the terms of the GNU General Public License version 2 as published by 101da177e4SLinus Torvalds * the Free Software Foundation. 111da177e4SLinus Torvalds */ 121da177e4SLinus Torvalds 131da177e4SLinus Torvalds /* 141da177e4SLinus Torvalds * This driver can handle standard AT keyboards and PS/2 keyboards in 151da177e4SLinus Torvalds * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb 161da177e4SLinus Torvalds * input-only controllers and AT keyboards connected over a one way RS232 171da177e4SLinus Torvalds * converter. 181da177e4SLinus Torvalds */ 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds #include <linux/delay.h> 211da177e4SLinus Torvalds #include <linux/module.h> 221da177e4SLinus Torvalds #include <linux/slab.h> 231da177e4SLinus Torvalds #include <linux/interrupt.h> 241da177e4SLinus Torvalds #include <linux/init.h> 251da177e4SLinus Torvalds #include <linux/input.h> 261da177e4SLinus Torvalds #include <linux/serio.h> 271da177e4SLinus Torvalds #include <linux/workqueue.h> 281da177e4SLinus Torvalds #include <linux/libps2.h> 2933d3f07aSIngo Molnar #include <linux/mutex.h> 30554101e3SGiel de Nijs #include <linux/dmi.h> 311da177e4SLinus Torvalds 321da177e4SLinus Torvalds #define DRIVER_DESC "AT and PS/2 keyboard driver" 331da177e4SLinus Torvalds 341da177e4SLinus Torvalds MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); 351da177e4SLinus Torvalds MODULE_DESCRIPTION(DRIVER_DESC); 361da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds static int atkbd_set = 2; 391da177e4SLinus Torvalds module_param_named(set, atkbd_set, int, 0); 401da177e4SLinus Torvalds MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)"); 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__) 431da177e4SLinus Torvalds static int atkbd_reset; 441da177e4SLinus Torvalds #else 451da177e4SLinus Torvalds static int atkbd_reset = 1; 461da177e4SLinus Torvalds #endif 471da177e4SLinus Torvalds module_param_named(reset, atkbd_reset, bool, 0); 481da177e4SLinus Torvalds MODULE_PARM_DESC(reset, "Reset keyboard during initialization"); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds static int atkbd_softrepeat; 511da177e4SLinus Torvalds module_param_named(softrepeat, atkbd_softrepeat, bool, 0); 521da177e4SLinus Torvalds MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat"); 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds static int atkbd_softraw = 1; 551da177e4SLinus Torvalds module_param_named(softraw, atkbd_softraw, bool, 0); 561da177e4SLinus Torvalds MODULE_PARM_DESC(softraw, "Use software generated rawmode"); 571da177e4SLinus Torvalds 580ae051a1SDmitry Torokhov static int atkbd_scroll; 591da177e4SLinus Torvalds module_param_named(scroll, atkbd_scroll, bool, 0); 601da177e4SLinus Torvalds MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards"); 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds static int atkbd_extra; 631da177e4SLinus Torvalds module_param_named(extra, atkbd_extra, bool, 0); 641da177e4SLinus Torvalds MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards"); 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /* 671da177e4SLinus Torvalds * Scancode to keycode tables. These are just the default setting, and 681da177e4SLinus Torvalds * are loadable via an userland utility. 691da177e4SLinus Torvalds */ 701da177e4SLinus Torvalds 71f6d65610SDmitry Torokhov static const unsigned short atkbd_set2_keycode[512] = { 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /* XXX: need a more general approach */ 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds #include "hpps2atkbd.h" /* include the keyboard scancodes */ 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds #else 801da177e4SLinus Torvalds 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117, 811da177e4SLinus Torvalds 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0, 821da177e4SLinus Torvalds 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183, 831da177e4SLinus Torvalds 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185, 841da177e4SLinus Torvalds 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0, 851da177e4SLinus Torvalds 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85, 861da177e4SLinus Torvalds 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0, 871da177e4SLinus Torvalds 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99, 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 901da177e4SLinus Torvalds 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125, 911da177e4SLinus Torvalds 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127, 9272a42f24SHans de Goede 159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142, 931da177e4SLinus Torvalds 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0, 941da177e4SLinus Torvalds 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0, 951da177e4SLinus Torvalds 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112, 961da177e4SLinus Torvalds 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0, 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds 0, 0, 0, 65, 99, 991da177e4SLinus Torvalds #endif 1001da177e4SLinus Torvalds }; 1011da177e4SLinus Torvalds 102f6d65610SDmitry Torokhov static const unsigned short atkbd_set3_keycode[512] = { 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60, 1051da177e4SLinus Torvalds 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62, 1061da177e4SLinus Torvalds 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64, 1071da177e4SLinus Torvalds 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66, 1081da177e4SLinus Torvalds 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68, 1091da177e4SLinus Torvalds 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70, 1101da177e4SLinus Torvalds 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104, 1111da177e4SLinus Torvalds 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183, 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0, 11472a42f24SHans de Goede 0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168, 1151da177e4SLinus Torvalds 148,149,147,140 1161da177e4SLinus Torvalds }; 1171da177e4SLinus Torvalds 118f6d65610SDmitry Torokhov static const unsigned short atkbd_unxlate_table[128] = { 1191da177e4SLinus Torvalds 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13, 1201da177e4SLinus Torvalds 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27, 1211da177e4SLinus Torvalds 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42, 1221da177e4SLinus Torvalds 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3, 1231da177e4SLinus Torvalds 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105, 1241da177e4SLinus Torvalds 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63, 1251da177e4SLinus Torvalds 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111, 1261da177e4SLinus Torvalds 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110 1271da177e4SLinus Torvalds }; 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds #define ATKBD_CMD_SETLEDS 0x10ed 1301da177e4SLinus Torvalds #define ATKBD_CMD_GSCANSET 0x11f0 1311da177e4SLinus Torvalds #define ATKBD_CMD_SSCANSET 0x10f0 1321da177e4SLinus Torvalds #define ATKBD_CMD_GETID 0x02f2 1331da177e4SLinus Torvalds #define ATKBD_CMD_SETREP 0x10f3 1341da177e4SLinus Torvalds #define ATKBD_CMD_ENABLE 0x00f4 1351da177e4SLinus Torvalds #define ATKBD_CMD_RESET_DIS 0x00f5 1361da177e4SLinus Torvalds #define ATKBD_CMD_SETALL_MBR 0x00fa 1371da177e4SLinus Torvalds #define ATKBD_CMD_RESET_BAT 0x02ff 1381da177e4SLinus Torvalds #define ATKBD_CMD_RESEND 0x00fe 1391da177e4SLinus Torvalds #define ATKBD_CMD_EX_ENABLE 0x10ea 1401da177e4SLinus Torvalds #define ATKBD_CMD_EX_SETLEDS 0x20eb 1411da177e4SLinus Torvalds #define ATKBD_CMD_OK_GETID 0x02e8 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds #define ATKBD_RET_ACK 0xfa 1441da177e4SLinus Torvalds #define ATKBD_RET_NAK 0xfe 1451da177e4SLinus Torvalds #define ATKBD_RET_BAT 0xaa 1461da177e4SLinus Torvalds #define ATKBD_RET_EMUL0 0xe0 1471da177e4SLinus Torvalds #define ATKBD_RET_EMUL1 0xe1 1481da177e4SLinus Torvalds #define ATKBD_RET_RELEASE 0xf0 1490ae051a1SDmitry Torokhov #define ATKBD_RET_HANJA 0xf1 1500ae051a1SDmitry Torokhov #define ATKBD_RET_HANGEUL 0xf2 1511da177e4SLinus Torvalds #define ATKBD_RET_ERR 0xff 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds #define ATKBD_KEY_UNKNOWN 0 1541da177e4SLinus Torvalds #define ATKBD_KEY_NULL 255 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds #define ATKBD_SCR_1 254 1571da177e4SLinus Torvalds #define ATKBD_SCR_2 253 1581da177e4SLinus Torvalds #define ATKBD_SCR_4 252 1591da177e4SLinus Torvalds #define ATKBD_SCR_8 251 1601da177e4SLinus Torvalds #define ATKBD_SCR_CLICK 250 1611da177e4SLinus Torvalds #define ATKBD_SCR_LEFT 249 1621da177e4SLinus Torvalds #define ATKBD_SCR_RIGHT 248 1631da177e4SLinus Torvalds 164f6d65610SDmitry Torokhov #define ATKBD_SPECIAL ATKBD_SCR_RIGHT 1651da177e4SLinus Torvalds 1660d4c8597SDmitry Torokhov #define ATKBD_LED_EVENT_BIT 0 1670d4c8597SDmitry Torokhov #define ATKBD_REP_EVENT_BIT 1 1680d4c8597SDmitry Torokhov 1690ae051a1SDmitry Torokhov #define ATKBD_XL_ERR 0x01 1700ae051a1SDmitry Torokhov #define ATKBD_XL_BAT 0x02 1710ae051a1SDmitry Torokhov #define ATKBD_XL_ACK 0x04 1720ae051a1SDmitry Torokhov #define ATKBD_XL_NAK 0x08 1730ae051a1SDmitry Torokhov #define ATKBD_XL_HANGEUL 0x10 1740ae051a1SDmitry Torokhov #define ATKBD_XL_HANJA 0x20 1750ae051a1SDmitry Torokhov 176f6d65610SDmitry Torokhov static const struct { 1771da177e4SLinus Torvalds unsigned char keycode; 1781da177e4SLinus Torvalds unsigned char set2; 1791da177e4SLinus Torvalds } atkbd_scroll_keys[] = { 1801da177e4SLinus Torvalds { ATKBD_SCR_1, 0xc5 }, 1815212dd58SVojtech Pavlik { ATKBD_SCR_2, 0x9d }, 1825212dd58SVojtech Pavlik { ATKBD_SCR_4, 0xa4 }, 1835212dd58SVojtech Pavlik { ATKBD_SCR_8, 0x9b }, 1841da177e4SLinus Torvalds { ATKBD_SCR_CLICK, 0xe0 }, 1851da177e4SLinus Torvalds { ATKBD_SCR_LEFT, 0xcb }, 1861da177e4SLinus Torvalds { ATKBD_SCR_RIGHT, 0xd2 }, 1871da177e4SLinus Torvalds }; 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds /* 1901da177e4SLinus Torvalds * The atkbd control structure 1911da177e4SLinus Torvalds */ 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds struct atkbd { 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds struct ps2dev ps2dev; 1963c42f0c3SDmitry Torokhov struct input_dev *dev; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds /* Written only during init */ 1991da177e4SLinus Torvalds char name[64]; 2001da177e4SLinus Torvalds char phys[32]; 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds unsigned short id; 203f6d65610SDmitry Torokhov unsigned short keycode[512]; 204554101e3SGiel de Nijs DECLARE_BITMAP(force_release_mask, 512); 2051da177e4SLinus Torvalds unsigned char set; 2061da177e4SLinus Torvalds unsigned char translated; 2071da177e4SLinus Torvalds unsigned char extra; 2081da177e4SLinus Torvalds unsigned char write; 2091da177e4SLinus Torvalds unsigned char softrepeat; 2101da177e4SLinus Torvalds unsigned char softraw; 2111da177e4SLinus Torvalds unsigned char scroll; 2121da177e4SLinus Torvalds unsigned char enabled; 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* Accessed only from interrupt */ 2151da177e4SLinus Torvalds unsigned char emul; 2161da177e4SLinus Torvalds unsigned char resend; 2171da177e4SLinus Torvalds unsigned char release; 2180ae051a1SDmitry Torokhov unsigned long xl_bit; 2191da177e4SLinus Torvalds unsigned int last; 2201da177e4SLinus Torvalds unsigned long time; 22186255d9dSDmitry Torokhov unsigned long err_count; 2220d4c8597SDmitry Torokhov 223da4249c9SDmitry Torokhov struct delayed_work event_work; 224da4249c9SDmitry Torokhov unsigned long event_jiffies; 22533d3f07aSIngo Molnar struct mutex event_mutex; 2260d4c8597SDmitry Torokhov unsigned long event_mask; 2271da177e4SLinus Torvalds }; 2281da177e4SLinus Torvalds 229554101e3SGiel de Nijs /* 230554101e3SGiel de Nijs * System-specific ketymap fixup routine 231554101e3SGiel de Nijs */ 232554101e3SGiel de Nijs static void (*atkbd_platform_fixup)(struct atkbd *); 233554101e3SGiel de Nijs 2341da177e4SLinus Torvalds static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 2351da177e4SLinus Torvalds ssize_t (*handler)(struct atkbd *, char *)); 2361da177e4SLinus Torvalds static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 2371da177e4SLinus Torvalds ssize_t (*handler)(struct atkbd *, const char *, size_t)); 2381da177e4SLinus Torvalds #define ATKBD_DEFINE_ATTR(_name) \ 2391da177e4SLinus Torvalds static ssize_t atkbd_show_##_name(struct atkbd *, char *); \ 2401da177e4SLinus Torvalds static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \ 24186255d9dSDmitry Torokhov static ssize_t atkbd_do_show_##_name(struct device *d, \ 24286255d9dSDmitry Torokhov struct device_attribute *attr, char *b) \ 2431da177e4SLinus Torvalds { \ 2441da177e4SLinus Torvalds return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \ 2451da177e4SLinus Torvalds } \ 24686255d9dSDmitry Torokhov static ssize_t atkbd_do_set_##_name(struct device *d, \ 24786255d9dSDmitry Torokhov struct device_attribute *attr, const char *b, size_t s) \ 2481da177e4SLinus Torvalds { \ 2491da177e4SLinus Torvalds return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \ 2501da177e4SLinus Torvalds } \ 2511da177e4SLinus Torvalds static struct device_attribute atkbd_attr_##_name = \ 2521da177e4SLinus Torvalds __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds ATKBD_DEFINE_ATTR(extra); 2551da177e4SLinus Torvalds ATKBD_DEFINE_ATTR(scroll); 2561da177e4SLinus Torvalds ATKBD_DEFINE_ATTR(set); 2571da177e4SLinus Torvalds ATKBD_DEFINE_ATTR(softrepeat); 2581da177e4SLinus Torvalds ATKBD_DEFINE_ATTR(softraw); 2591da177e4SLinus Torvalds 26086255d9dSDmitry Torokhov #define ATKBD_DEFINE_RO_ATTR(_name) \ 26186255d9dSDmitry Torokhov static ssize_t atkbd_show_##_name(struct atkbd *, char *); \ 26286255d9dSDmitry Torokhov static ssize_t atkbd_do_show_##_name(struct device *d, \ 26386255d9dSDmitry Torokhov struct device_attribute *attr, char *b) \ 26486255d9dSDmitry Torokhov { \ 26586255d9dSDmitry Torokhov return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \ 26686255d9dSDmitry Torokhov } \ 26786255d9dSDmitry Torokhov static struct device_attribute atkbd_attr_##_name = \ 26886255d9dSDmitry Torokhov __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL); 26986255d9dSDmitry Torokhov 27086255d9dSDmitry Torokhov ATKBD_DEFINE_RO_ATTR(err_count); 27186255d9dSDmitry Torokhov 27286255d9dSDmitry Torokhov static struct attribute *atkbd_attributes[] = { 27386255d9dSDmitry Torokhov &atkbd_attr_extra.attr, 27486255d9dSDmitry Torokhov &atkbd_attr_scroll.attr, 27586255d9dSDmitry Torokhov &atkbd_attr_set.attr, 27686255d9dSDmitry Torokhov &atkbd_attr_softrepeat.attr, 27786255d9dSDmitry Torokhov &atkbd_attr_softraw.attr, 27886255d9dSDmitry Torokhov &atkbd_attr_err_count.attr, 27986255d9dSDmitry Torokhov NULL 28086255d9dSDmitry Torokhov }; 28186255d9dSDmitry Torokhov 28286255d9dSDmitry Torokhov static struct attribute_group atkbd_attribute_group = { 28386255d9dSDmitry Torokhov .attrs = atkbd_attributes, 28486255d9dSDmitry Torokhov }; 28586255d9dSDmitry Torokhov 2860ae051a1SDmitry Torokhov static const unsigned int xl_table[] = { 2870ae051a1SDmitry Torokhov ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK, 2880ae051a1SDmitry Torokhov ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL, 2890ae051a1SDmitry Torokhov }; 2901da177e4SLinus Torvalds 2910ae051a1SDmitry Torokhov /* 2920ae051a1SDmitry Torokhov * Checks if we should mangle the scancode to extract 'release' bit 2930ae051a1SDmitry Torokhov * in translated mode. 2940ae051a1SDmitry Torokhov */ 2950ae051a1SDmitry Torokhov static int atkbd_need_xlate(unsigned long xl_bit, unsigned char code) 2961da177e4SLinus Torvalds { 2970ae051a1SDmitry Torokhov int i; 2980ae051a1SDmitry Torokhov 2990ae051a1SDmitry Torokhov if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1) 3000ae051a1SDmitry Torokhov return 0; 3010ae051a1SDmitry Torokhov 3020ae051a1SDmitry Torokhov for (i = 0; i < ARRAY_SIZE(xl_table); i++) 3030ae051a1SDmitry Torokhov if (code == xl_table[i]) 3040ae051a1SDmitry Torokhov return test_bit(i, &xl_bit); 3050ae051a1SDmitry Torokhov 3060ae051a1SDmitry Torokhov return 1; 3070ae051a1SDmitry Torokhov } 3080ae051a1SDmitry Torokhov 3090ae051a1SDmitry Torokhov /* 3100ae051a1SDmitry Torokhov * Calculates new value of xl_bit so the driver can distinguish 3110ae051a1SDmitry Torokhov * between make/break pair of scancodes for select keys and PS/2 3120ae051a1SDmitry Torokhov * protocol responses. 3130ae051a1SDmitry Torokhov */ 3140ae051a1SDmitry Torokhov static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code) 3150ae051a1SDmitry Torokhov { 3160ae051a1SDmitry Torokhov int i; 3170ae051a1SDmitry Torokhov 3180ae051a1SDmitry Torokhov for (i = 0; i < ARRAY_SIZE(xl_table); i++) { 3190ae051a1SDmitry Torokhov if (!((code ^ xl_table[i]) & 0x7f)) { 3200ae051a1SDmitry Torokhov if (code & 0x80) 3210ae051a1SDmitry Torokhov __clear_bit(i, &atkbd->xl_bit); 3220ae051a1SDmitry Torokhov else 3230ae051a1SDmitry Torokhov __set_bit(i, &atkbd->xl_bit); 3240ae051a1SDmitry Torokhov break; 3250ae051a1SDmitry Torokhov } 3260ae051a1SDmitry Torokhov } 3270ae051a1SDmitry Torokhov } 3280ae051a1SDmitry Torokhov 3290ae051a1SDmitry Torokhov /* 3300ae051a1SDmitry Torokhov * Encode the scancode, 0xe0 prefix, and high bit into a single integer, 3310ae051a1SDmitry Torokhov * keeping kernel 2.4 compatibility for set 2 3320ae051a1SDmitry Torokhov */ 3330ae051a1SDmitry Torokhov static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code) 3340ae051a1SDmitry Torokhov { 3350ae051a1SDmitry Torokhov if (atkbd->set == 3) { 3360ae051a1SDmitry Torokhov if (atkbd->emul == 1) 3370ae051a1SDmitry Torokhov code |= 0x100; 3380ae051a1SDmitry Torokhov } else { 3390ae051a1SDmitry Torokhov code = (code & 0x7f) | ((code & 0x80) << 1); 3400ae051a1SDmitry Torokhov if (atkbd->emul == 1) 3410ae051a1SDmitry Torokhov code |= 0x80; 3420ae051a1SDmitry Torokhov } 3430ae051a1SDmitry Torokhov 3440ae051a1SDmitry Torokhov return code; 3451da177e4SLinus Torvalds } 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds /* 3481da177e4SLinus Torvalds * atkbd_interrupt(). Here takes place processing of data received from 3491da177e4SLinus Torvalds * the keyboard into events. 3501da177e4SLinus Torvalds */ 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 3537d12e780SDavid Howells unsigned int flags) 3541da177e4SLinus Torvalds { 3551da177e4SLinus Torvalds struct atkbd *atkbd = serio_get_drvdata(serio); 3560ae051a1SDmitry Torokhov struct input_dev *dev = atkbd->dev; 3571da177e4SLinus Torvalds unsigned int code = data; 358554101e3SGiel de Nijs int scroll = 0, hscroll = 0, click = -1; 3591da177e4SLinus Torvalds int value; 360f6d65610SDmitry Torokhov unsigned short keycode; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds #ifdef ATKBD_DEBUG 3631da177e4SLinus Torvalds printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags); 3641da177e4SLinus Torvalds #endif 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds #if !defined(__i386__) && !defined (__x86_64__) 3671da177e4SLinus Torvalds if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) { 3681da177e4SLinus Torvalds printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags); 3691da177e4SLinus Torvalds serio_write(serio, ATKBD_CMD_RESEND); 3701da177e4SLinus Torvalds atkbd->resend = 1; 3711da177e4SLinus Torvalds goto out; 3721da177e4SLinus Torvalds } 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds if (!flags && data == ATKBD_RET_ACK) 3751da177e4SLinus Torvalds atkbd->resend = 0; 3761da177e4SLinus Torvalds #endif 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK)) 3791da177e4SLinus Torvalds if (ps2_handle_ack(&atkbd->ps2dev, data)) 3801da177e4SLinus Torvalds goto out; 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD)) 3831da177e4SLinus Torvalds if (ps2_handle_response(&atkbd->ps2dev, data)) 3841da177e4SLinus Torvalds goto out; 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds if (!atkbd->enabled) 3871da177e4SLinus Torvalds goto out; 3881da177e4SLinus Torvalds 3890ae051a1SDmitry Torokhov input_event(dev, EV_MSC, MSC_RAW, code); 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds if (atkbd->translated) { 3921da177e4SLinus Torvalds 3930ae051a1SDmitry Torokhov if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) { 3941da177e4SLinus Torvalds atkbd->release = code >> 7; 3951da177e4SLinus Torvalds code &= 0x7f; 3961da177e4SLinus Torvalds } 3971da177e4SLinus Torvalds 3980ae051a1SDmitry Torokhov if (!atkbd->emul) 3990ae051a1SDmitry Torokhov atkbd_calculate_xl_bit(atkbd, data); 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds switch (code) { 4031da177e4SLinus Torvalds case ATKBD_RET_BAT: 4041da177e4SLinus Torvalds atkbd->enabled = 0; 405dbc26344SDmitry Torokhov serio_reconnect(atkbd->ps2dev.serio); 4061da177e4SLinus Torvalds goto out; 4071da177e4SLinus Torvalds case ATKBD_RET_EMUL0: 4081da177e4SLinus Torvalds atkbd->emul = 1; 4091da177e4SLinus Torvalds goto out; 4101da177e4SLinus Torvalds case ATKBD_RET_EMUL1: 4111da177e4SLinus Torvalds atkbd->emul = 2; 4121da177e4SLinus Torvalds goto out; 4131da177e4SLinus Torvalds case ATKBD_RET_RELEASE: 4141da177e4SLinus Torvalds atkbd->release = 1; 4151da177e4SLinus Torvalds goto out; 4160ae051a1SDmitry Torokhov case ATKBD_RET_ACK: 4170ae051a1SDmitry Torokhov case ATKBD_RET_NAK: 4189f7a60d6SQi Yong if (printk_ratelimit()) 4190ae051a1SDmitry Torokhov printk(KERN_WARNING "atkbd.c: Spurious %s on %s. " 4200ae051a1SDmitry Torokhov "Some program might be trying access hardware directly.\n", 4210ae051a1SDmitry Torokhov data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys); 4220ae051a1SDmitry Torokhov goto out; 4231da177e4SLinus Torvalds case ATKBD_RET_ERR: 42486255d9dSDmitry Torokhov atkbd->err_count++; 42586255d9dSDmitry Torokhov #ifdef ATKBD_DEBUG 4261da177e4SLinus Torvalds printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys); 42786255d9dSDmitry Torokhov #endif 4281da177e4SLinus Torvalds goto out; 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds 4310ae051a1SDmitry Torokhov code = atkbd_compat_scancode(atkbd, code); 4320ae051a1SDmitry Torokhov 4330ae051a1SDmitry Torokhov if (atkbd->emul && --atkbd->emul) 4341da177e4SLinus Torvalds goto out; 4351da177e4SLinus Torvalds 4360ae051a1SDmitry Torokhov keycode = atkbd->keycode[code]; 4371da177e4SLinus Torvalds 4380ae051a1SDmitry Torokhov if (keycode != ATKBD_KEY_NULL) 4390ae051a1SDmitry Torokhov input_event(dev, EV_MSC, MSC_SCAN, code); 4400ae051a1SDmitry Torokhov 4410ae051a1SDmitry Torokhov switch (keycode) { 4421da177e4SLinus Torvalds case ATKBD_KEY_NULL: 4431da177e4SLinus Torvalds break; 4441da177e4SLinus Torvalds case ATKBD_KEY_UNKNOWN: 4450ae051a1SDmitry Torokhov printk(KERN_WARNING 4460ae051a1SDmitry Torokhov "atkbd.c: Unknown key %s (%s set %d, code %#x on %s).\n", 4471da177e4SLinus Torvalds atkbd->release ? "released" : "pressed", 4481da177e4SLinus Torvalds atkbd->translated ? "translated" : "raw", 4491da177e4SLinus Torvalds atkbd->set, code, serio->phys); 4500ae051a1SDmitry Torokhov printk(KERN_WARNING 4510ae051a1SDmitry Torokhov "atkbd.c: Use 'setkeycodes %s%02x <keycode>' to make it known.\n", 4521da177e4SLinus Torvalds code & 0x80 ? "e0" : "", code & 0x7f); 4530ae051a1SDmitry Torokhov input_sync(dev); 4541da177e4SLinus Torvalds break; 4551da177e4SLinus Torvalds case ATKBD_SCR_1: 4561da177e4SLinus Torvalds scroll = 1 - atkbd->release * 2; 4571da177e4SLinus Torvalds break; 4581da177e4SLinus Torvalds case ATKBD_SCR_2: 4591da177e4SLinus Torvalds scroll = 2 - atkbd->release * 4; 4601da177e4SLinus Torvalds break; 4611da177e4SLinus Torvalds case ATKBD_SCR_4: 4621da177e4SLinus Torvalds scroll = 4 - atkbd->release * 8; 4631da177e4SLinus Torvalds break; 4641da177e4SLinus Torvalds case ATKBD_SCR_8: 4651da177e4SLinus Torvalds scroll = 8 - atkbd->release * 16; 4661da177e4SLinus Torvalds break; 4671da177e4SLinus Torvalds case ATKBD_SCR_CLICK: 4681da177e4SLinus Torvalds click = !atkbd->release; 4691da177e4SLinus Torvalds break; 4701da177e4SLinus Torvalds case ATKBD_SCR_LEFT: 4711da177e4SLinus Torvalds hscroll = -1; 4721da177e4SLinus Torvalds break; 4731da177e4SLinus Torvalds case ATKBD_SCR_RIGHT: 4741da177e4SLinus Torvalds hscroll = 1; 4751da177e4SLinus Torvalds break; 4761da177e4SLinus Torvalds default: 4770ae051a1SDmitry Torokhov if (atkbd->release) { 4780ae051a1SDmitry Torokhov value = 0; 4791da177e4SLinus Torvalds atkbd->last = 0; 4800ae051a1SDmitry Torokhov } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) { 4810ae051a1SDmitry Torokhov /* Workaround Toshiba laptop multiple keypress */ 4820ae051a1SDmitry Torokhov value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2; 4830ae051a1SDmitry Torokhov } else { 4841da177e4SLinus Torvalds value = 1; 4850ae051a1SDmitry Torokhov atkbd->last = code; 4860ae051a1SDmitry Torokhov atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2; 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 489f8b4c46cSDmitry Torokhov input_event(dev, EV_KEY, keycode, value); 4900ae051a1SDmitry Torokhov input_sync(dev); 4910ae051a1SDmitry Torokhov 492554101e3SGiel de Nijs if (value && test_bit(code, atkbd->force_release_mask)) { 4930ae051a1SDmitry Torokhov input_report_key(dev, keycode, 0); 4940ae051a1SDmitry Torokhov input_sync(dev); 4950ae051a1SDmitry Torokhov } 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds if (atkbd->scroll) { 4991da177e4SLinus Torvalds if (click != -1) 5000ae051a1SDmitry Torokhov input_report_key(dev, BTN_MIDDLE, click); 5010ae051a1SDmitry Torokhov input_report_rel(dev, REL_WHEEL, scroll); 5020ae051a1SDmitry Torokhov input_report_rel(dev, REL_HWHEEL, hscroll); 5030ae051a1SDmitry Torokhov input_sync(dev); 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds atkbd->release = 0; 5071da177e4SLinus Torvalds out: 5081da177e4SLinus Torvalds return IRQ_HANDLED; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 5113d0f0fa0SDmitry Torokhov static int atkbd_set_repeat_rate(struct atkbd *atkbd) 5121da177e4SLinus Torvalds { 5131da177e4SLinus Torvalds const short period[32] = 5141da177e4SLinus Torvalds { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125, 5151da177e4SLinus Torvalds 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 }; 5161da177e4SLinus Torvalds const short delay[4] = 5171da177e4SLinus Torvalds { 250, 500, 750, 1000 }; 5180d4c8597SDmitry Torokhov 5193d0f0fa0SDmitry Torokhov struct input_dev *dev = atkbd->dev; 5203d0f0fa0SDmitry Torokhov unsigned char param; 5213d0f0fa0SDmitry Torokhov int i = 0, j = 0; 5223d0f0fa0SDmitry Torokhov 5233d0f0fa0SDmitry Torokhov while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD]) 5243d0f0fa0SDmitry Torokhov i++; 5253d0f0fa0SDmitry Torokhov dev->rep[REP_PERIOD] = period[i]; 5263d0f0fa0SDmitry Torokhov 5278ea371fbSFlorin Malita while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY]) 5283d0f0fa0SDmitry Torokhov j++; 5293d0f0fa0SDmitry Torokhov dev->rep[REP_DELAY] = delay[j]; 5303d0f0fa0SDmitry Torokhov 5313d0f0fa0SDmitry Torokhov param = i | (j << 5); 5323d0f0fa0SDmitry Torokhov return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP); 5333d0f0fa0SDmitry Torokhov } 5343d0f0fa0SDmitry Torokhov 5353d0f0fa0SDmitry Torokhov static int atkbd_set_leds(struct atkbd *atkbd) 5363d0f0fa0SDmitry Torokhov { 5370d4c8597SDmitry Torokhov struct input_dev *dev = atkbd->dev; 5381da177e4SLinus Torvalds unsigned char param[2]; 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0) 5411da177e4SLinus Torvalds | (test_bit(LED_NUML, dev->led) ? 2 : 0) 5421da177e4SLinus Torvalds | (test_bit(LED_CAPSL, dev->led) ? 4 : 0); 5433d0f0fa0SDmitry Torokhov if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS)) 5443d0f0fa0SDmitry Torokhov return -1; 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds if (atkbd->extra) { 5471da177e4SLinus Torvalds param[0] = 0; 5481da177e4SLinus Torvalds param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0) 5491da177e4SLinus Torvalds | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0) 5501da177e4SLinus Torvalds | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0) 5511da177e4SLinus Torvalds | (test_bit(LED_MISC, dev->led) ? 0x10 : 0) 5521da177e4SLinus Torvalds | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0); 5533d0f0fa0SDmitry Torokhov if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS)) 5543d0f0fa0SDmitry Torokhov return -1; 5551da177e4SLinus Torvalds } 5561da177e4SLinus Torvalds 5573d0f0fa0SDmitry Torokhov return 0; 5580d4c8597SDmitry Torokhov } 5590d4c8597SDmitry Torokhov 5603d0f0fa0SDmitry Torokhov /* 5613d0f0fa0SDmitry Torokhov * atkbd_event_work() is used to complete processing of events that 5623d0f0fa0SDmitry Torokhov * can not be processed by input_event() which is often called from 5633d0f0fa0SDmitry Torokhov * interrupt context. 5643d0f0fa0SDmitry Torokhov */ 5653d0f0fa0SDmitry Torokhov 56665f27f38SDavid Howells static void atkbd_event_work(struct work_struct *work) 5673d0f0fa0SDmitry Torokhov { 568da4249c9SDmitry Torokhov struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work); 5693d0f0fa0SDmitry Torokhov 5703d0f0fa0SDmitry Torokhov mutex_lock(&atkbd->event_mutex); 5713d0f0fa0SDmitry Torokhov 5723d0f0fa0SDmitry Torokhov if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask)) 5733d0f0fa0SDmitry Torokhov atkbd_set_leds(atkbd); 5743d0f0fa0SDmitry Torokhov 5753d0f0fa0SDmitry Torokhov if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask)) 5763d0f0fa0SDmitry Torokhov atkbd_set_repeat_rate(atkbd); 5773d0f0fa0SDmitry Torokhov 57833d3f07aSIngo Molnar mutex_unlock(&atkbd->event_mutex); 5790d4c8597SDmitry Torokhov } 5800d4c8597SDmitry Torokhov 5810d4c8597SDmitry Torokhov /* 582da4249c9SDmitry Torokhov * Schedule switch for execution. We need to throttle requests, 583da4249c9SDmitry Torokhov * otherwise keyboard may become unresponsive. 584da4249c9SDmitry Torokhov */ 585da4249c9SDmitry Torokhov static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit) 586da4249c9SDmitry Torokhov { 587da4249c9SDmitry Torokhov unsigned long delay = msecs_to_jiffies(50); 588da4249c9SDmitry Torokhov 589da4249c9SDmitry Torokhov if (time_after(jiffies, atkbd->event_jiffies + delay)) 590da4249c9SDmitry Torokhov delay = 0; 591da4249c9SDmitry Torokhov 592da4249c9SDmitry Torokhov atkbd->event_jiffies = jiffies; 593da4249c9SDmitry Torokhov set_bit(event_bit, &atkbd->event_mask); 594da4249c9SDmitry Torokhov wmb(); 595da4249c9SDmitry Torokhov schedule_delayed_work(&atkbd->event_work, delay); 596da4249c9SDmitry Torokhov } 597da4249c9SDmitry Torokhov 598da4249c9SDmitry Torokhov /* 5990d4c8597SDmitry Torokhov * Event callback from the input module. Events that change the state of 6000d4c8597SDmitry Torokhov * the hardware are processed here. If action can not be performed in 6010d4c8597SDmitry Torokhov * interrupt context it is offloaded to atkbd_event_work. 6020d4c8597SDmitry Torokhov */ 6030d4c8597SDmitry Torokhov 604da4249c9SDmitry Torokhov static int atkbd_event(struct input_dev *dev, 605da4249c9SDmitry Torokhov unsigned int type, unsigned int code, int value) 6060d4c8597SDmitry Torokhov { 607b356872fSDmitry Torokhov struct atkbd *atkbd = input_get_drvdata(dev); 6080d4c8597SDmitry Torokhov 6090d4c8597SDmitry Torokhov if (!atkbd->write) 6100d4c8597SDmitry Torokhov return -1; 6110d4c8597SDmitry Torokhov 6120d4c8597SDmitry Torokhov switch (type) { 6130d4c8597SDmitry Torokhov 6140d4c8597SDmitry Torokhov case EV_LED: 615da4249c9SDmitry Torokhov atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT); 6160d4c8597SDmitry Torokhov return 0; 6170d4c8597SDmitry Torokhov 6180d4c8597SDmitry Torokhov case EV_REP: 619da4249c9SDmitry Torokhov if (!atkbd->softrepeat) 620da4249c9SDmitry Torokhov atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT); 6211da177e4SLinus Torvalds return 0; 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds return -1; 6251da177e4SLinus Torvalds } 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* 6281da177e4SLinus Torvalds * atkbd_enable() signals that interrupt handler is allowed to 6291da177e4SLinus Torvalds * generate input events. 6301da177e4SLinus Torvalds */ 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds static inline void atkbd_enable(struct atkbd *atkbd) 6331da177e4SLinus Torvalds { 6341da177e4SLinus Torvalds serio_pause_rx(atkbd->ps2dev.serio); 6351da177e4SLinus Torvalds atkbd->enabled = 1; 6361da177e4SLinus Torvalds serio_continue_rx(atkbd->ps2dev.serio); 6371da177e4SLinus Torvalds } 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds /* 6401da177e4SLinus Torvalds * atkbd_disable() tells input handler that all incoming data except 6411da177e4SLinus Torvalds * for ACKs and command response should be dropped. 6421da177e4SLinus Torvalds */ 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds static inline void atkbd_disable(struct atkbd *atkbd) 6451da177e4SLinus Torvalds { 6461da177e4SLinus Torvalds serio_pause_rx(atkbd->ps2dev.serio); 6471da177e4SLinus Torvalds atkbd->enabled = 0; 6481da177e4SLinus Torvalds serio_continue_rx(atkbd->ps2dev.serio); 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds /* 6521da177e4SLinus Torvalds * atkbd_probe() probes for an AT keyboard on a serio port. 6531da177e4SLinus Torvalds */ 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds static int atkbd_probe(struct atkbd *atkbd) 6561da177e4SLinus Torvalds { 6571da177e4SLinus Torvalds struct ps2dev *ps2dev = &atkbd->ps2dev; 6581da177e4SLinus Torvalds unsigned char param[2]; 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds /* 6611da177e4SLinus Torvalds * Some systems, where the bit-twiddling when testing the io-lines of the 6621da177e4SLinus Torvalds * controller may confuse the keyboard need a full reset of the keyboard. On 6631da177e4SLinus Torvalds * these systems the BIOS also usually doesn't do it for us. 6641da177e4SLinus Torvalds */ 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds if (atkbd_reset) 6671da177e4SLinus Torvalds if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT)) 6681da177e4SLinus Torvalds printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys); 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds /* 6711da177e4SLinus Torvalds * Then we check the keyboard ID. We should get 0xab83 under normal conditions. 6721da177e4SLinus Torvalds * Some keyboards report different values, but the first byte is always 0xab or 6731da177e4SLinus Torvalds * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this 6741da177e4SLinus Torvalds * should make sure we don't try to set the LEDs on it. 6751da177e4SLinus Torvalds */ 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds param[0] = param[1] = 0xa5; /* initialize with invalid values */ 6781da177e4SLinus Torvalds if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) { 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds /* 6811da177e4SLinus Torvalds * If the get ID command failed, we check if we can at least set the LEDs on 6821da177e4SLinus Torvalds * the keyboard. This should work on every keyboard out there. It also turns 6831da177e4SLinus Torvalds * the LEDs off, which we want anyway. 6841da177e4SLinus Torvalds */ 6851da177e4SLinus Torvalds param[0] = 0; 6861da177e4SLinus Torvalds if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 6871da177e4SLinus Torvalds return -1; 6881da177e4SLinus Torvalds atkbd->id = 0xabba; 6891da177e4SLinus Torvalds return 0; 6901da177e4SLinus Torvalds } 6911da177e4SLinus Torvalds 6929807879bSDmitry Torokhov if (!ps2_is_keyboard_id(param[0])) 6931da177e4SLinus Torvalds return -1; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds atkbd->id = (param[0] << 8) | param[1]; 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds if (atkbd->id == 0xaca1 && atkbd->translated) { 6981da177e4SLinus Torvalds printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n"); 6991da177e4SLinus Torvalds printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n"); 7001da177e4SLinus Torvalds return -1; 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds return 0; 7041da177e4SLinus Torvalds } 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds /* 7071da177e4SLinus Torvalds * atkbd_select_set checks if a keyboard has a working Set 3 support, and 7081da177e4SLinus Torvalds * sets it into that. Unfortunately there are keyboards that can be switched 7091da177e4SLinus Torvalds * to Set 3, but don't work well in that (BTC Multimedia ...) 7101da177e4SLinus Torvalds */ 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra) 7131da177e4SLinus Torvalds { 7141da177e4SLinus Torvalds struct ps2dev *ps2dev = &atkbd->ps2dev; 7151da177e4SLinus Torvalds unsigned char param[2]; 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds atkbd->extra = 0; 7181da177e4SLinus Torvalds /* 7191da177e4SLinus Torvalds * For known special keyboards we can go ahead and set the correct set. 7201da177e4SLinus Torvalds * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and 7211da177e4SLinus Torvalds * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards. 7221da177e4SLinus Torvalds */ 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds if (atkbd->translated) 7251da177e4SLinus Torvalds return 2; 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds if (atkbd->id == 0xaca1) { 7281da177e4SLinus Torvalds param[0] = 3; 7291da177e4SLinus Torvalds ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET); 7301da177e4SLinus Torvalds return 3; 7311da177e4SLinus Torvalds } 7321da177e4SLinus Torvalds 7331da177e4SLinus Torvalds if (allow_extra) { 7341da177e4SLinus Torvalds param[0] = 0x71; 7351da177e4SLinus Torvalds if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) { 7361da177e4SLinus Torvalds atkbd->extra = 1; 7371da177e4SLinus Torvalds return 2; 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds } 7401da177e4SLinus Torvalds 7411da177e4SLinus Torvalds if (target_set != 3) 7421da177e4SLinus Torvalds return 2; 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) { 7451da177e4SLinus Torvalds atkbd->id = param[0] << 8 | param[1]; 7461da177e4SLinus Torvalds return 2; 7471da177e4SLinus Torvalds } 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds param[0] = 3; 7501da177e4SLinus Torvalds if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 7511da177e4SLinus Torvalds return 2; 7521da177e4SLinus Torvalds 7531da177e4SLinus Torvalds param[0] = 0; 7541da177e4SLinus Torvalds if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET)) 7551da177e4SLinus Torvalds return 2; 7561da177e4SLinus Torvalds 7571da177e4SLinus Torvalds if (param[0] != 3) { 7581da177e4SLinus Torvalds param[0] = 2; 7591da177e4SLinus Torvalds if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET)) 7601da177e4SLinus Torvalds return 2; 7611da177e4SLinus Torvalds } 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR); 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds return 3; 7661da177e4SLinus Torvalds } 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds static int atkbd_activate(struct atkbd *atkbd) 7691da177e4SLinus Torvalds { 7701da177e4SLinus Torvalds struct ps2dev *ps2dev = &atkbd->ps2dev; 7711da177e4SLinus Torvalds unsigned char param[1]; 7721da177e4SLinus Torvalds 7731da177e4SLinus Torvalds /* 7741da177e4SLinus Torvalds * Set the LEDs to a defined state. 7751da177e4SLinus Torvalds */ 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds param[0] = 0; 7781da177e4SLinus Torvalds if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS)) 7791da177e4SLinus Torvalds return -1; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds /* 7821da177e4SLinus Torvalds * Set autorepeat to fastest possible. 7831da177e4SLinus Torvalds */ 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds param[0] = 0; 7861da177e4SLinus Torvalds if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP)) 7871da177e4SLinus Torvalds return -1; 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds /* 7901da177e4SLinus Torvalds * Enable the keyboard to receive keystrokes. 7911da177e4SLinus Torvalds */ 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) { 7941da177e4SLinus Torvalds printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n", 7951da177e4SLinus Torvalds ps2dev->serio->phys); 7961da177e4SLinus Torvalds return -1; 7971da177e4SLinus Torvalds } 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds return 0; 8001da177e4SLinus Torvalds } 8011da177e4SLinus Torvalds 8021da177e4SLinus Torvalds /* 8031da177e4SLinus Torvalds * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a 8041da177e4SLinus Torvalds * reboot. 8051da177e4SLinus Torvalds */ 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds static void atkbd_cleanup(struct serio *serio) 8081da177e4SLinus Torvalds { 8091da177e4SLinus Torvalds struct atkbd *atkbd = serio_get_drvdata(serio); 81057f5b159SDmitry Torokhov 81157f5b159SDmitry Torokhov atkbd_disable(atkbd); 8121da177e4SLinus Torvalds ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT); 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds /* 8171da177e4SLinus Torvalds * atkbd_disconnect() closes and frees. 8181da177e4SLinus Torvalds */ 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds static void atkbd_disconnect(struct serio *serio) 8211da177e4SLinus Torvalds { 8221da177e4SLinus Torvalds struct atkbd *atkbd = serio_get_drvdata(serio); 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds atkbd_disable(atkbd); 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds /* make sure we don't have a command in flight */ 8271da177e4SLinus Torvalds flush_scheduled_work(); 8281da177e4SLinus Torvalds 82986255d9dSDmitry Torokhov sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group); 8303c42f0c3SDmitry Torokhov input_unregister_device(atkbd->dev); 8311da177e4SLinus Torvalds serio_close(serio); 8321da177e4SLinus Torvalds serio_set_drvdata(serio, NULL); 8331da177e4SLinus Torvalds kfree(atkbd); 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds 836554101e3SGiel de Nijs /* 837*61579ba8SMatthew Garrett * Most special keys (Fn+F?) on Dell laptops do not generate release 838554101e3SGiel de Nijs * events so we have to do it ourselves. 839554101e3SGiel de Nijs */ 840*61579ba8SMatthew Garrett static void atkbd_dell_laptop_keymap_fixup(struct atkbd *atkbd) 841554101e3SGiel de Nijs { 842554101e3SGiel de Nijs const unsigned int forced_release_keys[] = { 843554101e3SGiel de Nijs 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, 844554101e3SGiel de Nijs }; 845554101e3SGiel de Nijs int i; 846554101e3SGiel de Nijs 847554101e3SGiel de Nijs if (atkbd->set == 2) 848554101e3SGiel de Nijs for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++) 849554101e3SGiel de Nijs __set_bit(forced_release_keys[i], 850554101e3SGiel de Nijs atkbd->force_release_mask); 851554101e3SGiel de Nijs } 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds /* 8545a54c011SJiri Kosina * Perform fixup for HP system that doesn't generate release 8555a54c011SJiri Kosina * for its video switch 8565a54c011SJiri Kosina */ 8575a54c011SJiri Kosina static void atkbd_hp_keymap_fixup(struct atkbd *atkbd) 8585a54c011SJiri Kosina { 8595a54c011SJiri Kosina const unsigned int forced_release_keys[] = { 8605a54c011SJiri Kosina 0x94, 8615a54c011SJiri Kosina }; 8625a54c011SJiri Kosina int i; 8635a54c011SJiri Kosina 8645a54c011SJiri Kosina if (atkbd->set == 2) 8655a54c011SJiri Kosina for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++) 8665a54c011SJiri Kosina __set_bit(forced_release_keys[i], 8675a54c011SJiri Kosina atkbd->force_release_mask); 8685a54c011SJiri Kosina } 8695a54c011SJiri Kosina 8705a54c011SJiri Kosina /* 8713c42f0c3SDmitry Torokhov * atkbd_set_keycode_table() initializes keyboard's keycode table 8721da177e4SLinus Torvalds * according to the selected scancode set 8731da177e4SLinus Torvalds */ 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds static void atkbd_set_keycode_table(struct atkbd *atkbd) 8761da177e4SLinus Torvalds { 877554101e3SGiel de Nijs unsigned int scancode; 8781da177e4SLinus Torvalds int i, j; 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds memset(atkbd->keycode, 0, sizeof(atkbd->keycode)); 881554101e3SGiel de Nijs bitmap_zero(atkbd->force_release_mask, 512); 8821da177e4SLinus Torvalds 8831da177e4SLinus Torvalds if (atkbd->translated) { 8841da177e4SLinus Torvalds for (i = 0; i < 128; i++) { 885554101e3SGiel de Nijs scancode = atkbd_unxlate_table[i]; 886554101e3SGiel de Nijs atkbd->keycode[i] = atkbd_set2_keycode[scancode]; 887554101e3SGiel de Nijs atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80]; 8881da177e4SLinus Torvalds if (atkbd->scroll) 8891da177e4SLinus Torvalds for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++) 890554101e3SGiel de Nijs if ((scancode | 0x80) == atkbd_scroll_keys[j].set2) 8911da177e4SLinus Torvalds atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode; 8921da177e4SLinus Torvalds } 8931da177e4SLinus Torvalds } else if (atkbd->set == 3) { 8941da177e4SLinus Torvalds memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode)); 8951da177e4SLinus Torvalds } else { 8961da177e4SLinus Torvalds memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode)); 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds if (atkbd->scroll) 899554101e3SGiel de Nijs for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) { 900554101e3SGiel de Nijs scancode = atkbd_scroll_keys[i].set2; 901554101e3SGiel de Nijs atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode; 902554101e3SGiel de Nijs } 9031da177e4SLinus Torvalds } 9040ae051a1SDmitry Torokhov 905554101e3SGiel de Nijs /* 906554101e3SGiel de Nijs * HANGEUL and HANJA keys do not send release events so we need to 907554101e3SGiel de Nijs * generate such events ourselves 908554101e3SGiel de Nijs */ 909554101e3SGiel de Nijs scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL); 910554101e3SGiel de Nijs atkbd->keycode[scancode] = KEY_HANGEUL; 911554101e3SGiel de Nijs __set_bit(scancode, atkbd->force_release_mask); 912554101e3SGiel de Nijs 913554101e3SGiel de Nijs scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA); 914554101e3SGiel de Nijs atkbd->keycode[scancode] = KEY_HANJA; 915554101e3SGiel de Nijs __set_bit(scancode, atkbd->force_release_mask); 916554101e3SGiel de Nijs 917554101e3SGiel de Nijs /* 918554101e3SGiel de Nijs * Perform additional fixups 919554101e3SGiel de Nijs */ 920554101e3SGiel de Nijs if (atkbd_platform_fixup) 921554101e3SGiel de Nijs atkbd_platform_fixup(atkbd); 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds 9241da177e4SLinus Torvalds /* 9251da177e4SLinus Torvalds * atkbd_set_device_attrs() sets up keyboard's input device structure 9261da177e4SLinus Torvalds */ 9271da177e4SLinus Torvalds 9281da177e4SLinus Torvalds static void atkbd_set_device_attrs(struct atkbd *atkbd) 9291da177e4SLinus Torvalds { 9303c42f0c3SDmitry Torokhov struct input_dev *input_dev = atkbd->dev; 9311da177e4SLinus Torvalds int i; 9321da177e4SLinus Torvalds 9333c42f0c3SDmitry Torokhov if (atkbd->extra) 934ea08c6faSDmitry Torokhov snprintf(atkbd->name, sizeof(atkbd->name), 935ea08c6faSDmitry Torokhov "AT Set 2 Extra keyboard"); 9363c42f0c3SDmitry Torokhov else 937ea08c6faSDmitry Torokhov snprintf(atkbd->name, sizeof(atkbd->name), 938ea08c6faSDmitry Torokhov "AT %s Set %d keyboard", 9393c42f0c3SDmitry Torokhov atkbd->translated ? "Translated" : "Raw", atkbd->set); 9401da177e4SLinus Torvalds 941ea08c6faSDmitry Torokhov snprintf(atkbd->phys, sizeof(atkbd->phys), 942ea08c6faSDmitry Torokhov "%s/input0", atkbd->ps2dev.serio->phys); 9431da177e4SLinus Torvalds 9443c42f0c3SDmitry Torokhov input_dev->name = atkbd->name; 9453c42f0c3SDmitry Torokhov input_dev->phys = atkbd->phys; 9463c42f0c3SDmitry Torokhov input_dev->id.bustype = BUS_I8042; 9473c42f0c3SDmitry Torokhov input_dev->id.vendor = 0x0001; 9483c42f0c3SDmitry Torokhov input_dev->id.product = atkbd->translated ? 1 : atkbd->set; 9493c42f0c3SDmitry Torokhov input_dev->id.version = atkbd->id; 9503c42f0c3SDmitry Torokhov input_dev->event = atkbd_event; 951469ba4dfSDmitry Torokhov input_dev->dev.parent = &atkbd->ps2dev.serio->dev; 9521da177e4SLinus Torvalds 953b356872fSDmitry Torokhov input_set_drvdata(input_dev, atkbd); 954b356872fSDmitry Torokhov 9557b19ada2SJiri Slaby input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | 9567b19ada2SJiri Slaby BIT_MASK(EV_MSC); 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds if (atkbd->write) { 9597b19ada2SJiri Slaby input_dev->evbit[0] |= BIT_MASK(EV_LED); 9607b19ada2SJiri Slaby input_dev->ledbit[0] = BIT_MASK(LED_NUML) | 9617b19ada2SJiri Slaby BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL); 9621da177e4SLinus Torvalds } 9631da177e4SLinus Torvalds 9641da177e4SLinus Torvalds if (atkbd->extra) 9657b19ada2SJiri Slaby input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) | 9667b19ada2SJiri Slaby BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) | 9677b19ada2SJiri Slaby BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC); 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds if (!atkbd->softrepeat) { 9703c42f0c3SDmitry Torokhov input_dev->rep[REP_DELAY] = 250; 9713c42f0c3SDmitry Torokhov input_dev->rep[REP_PERIOD] = 33; 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds 9747b19ada2SJiri Slaby input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) : 9757b19ada2SJiri Slaby BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN); 9761da177e4SLinus Torvalds 9771da177e4SLinus Torvalds if (atkbd->scroll) { 9787b19ada2SJiri Slaby input_dev->evbit[0] |= BIT_MASK(EV_REL); 9797b19ada2SJiri Slaby input_dev->relbit[0] = BIT_MASK(REL_WHEEL) | 9807b19ada2SJiri Slaby BIT_MASK(REL_HWHEEL); 981f6d65610SDmitry Torokhov __set_bit(BTN_MIDDLE, input_dev->keybit); 9821da177e4SLinus Torvalds } 9831da177e4SLinus Torvalds 9843c42f0c3SDmitry Torokhov input_dev->keycode = atkbd->keycode; 985f6d65610SDmitry Torokhov input_dev->keycodesize = sizeof(unsigned short); 9863c42f0c3SDmitry Torokhov input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode); 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds for (i = 0; i < 512; i++) 9891da177e4SLinus Torvalds if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL) 990f6d65610SDmitry Torokhov __set_bit(atkbd->keycode[i], input_dev->keybit); 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds /* 9941da177e4SLinus Torvalds * atkbd_connect() is called when the serio module finds an interface 9951da177e4SLinus Torvalds * that isn't handled yet by an appropriate device driver. We check if 9961da177e4SLinus Torvalds * there is an AT keyboard out there and if yes, we register ourselves 9971da177e4SLinus Torvalds * to the input module. 9981da177e4SLinus Torvalds */ 9991da177e4SLinus Torvalds 10001da177e4SLinus Torvalds static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 10011da177e4SLinus Torvalds { 10021da177e4SLinus Torvalds struct atkbd *atkbd; 10033c42f0c3SDmitry Torokhov struct input_dev *dev; 10043c42f0c3SDmitry Torokhov int err = -ENOMEM; 10051da177e4SLinus Torvalds 10063c42f0c3SDmitry Torokhov atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL); 10073c42f0c3SDmitry Torokhov dev = input_allocate_device(); 10083c42f0c3SDmitry Torokhov if (!atkbd || !dev) 10092b03b60eSDmitry Torokhov goto fail1; 10101da177e4SLinus Torvalds 10113c42f0c3SDmitry Torokhov atkbd->dev = dev; 10121da177e4SLinus Torvalds ps2_init(&atkbd->ps2dev, serio); 1013da4249c9SDmitry Torokhov INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work); 101433d3f07aSIngo Molnar mutex_init(&atkbd->event_mutex); 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds switch (serio->id.type) { 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds case SERIO_8042_XL: 10191da177e4SLinus Torvalds atkbd->translated = 1; 10201da177e4SLinus Torvalds case SERIO_8042: 10211da177e4SLinus Torvalds if (serio->write) 10221da177e4SLinus Torvalds atkbd->write = 1; 10231da177e4SLinus Torvalds break; 10241da177e4SLinus Torvalds } 10251da177e4SLinus Torvalds 10261da177e4SLinus Torvalds atkbd->softraw = atkbd_softraw; 10271da177e4SLinus Torvalds atkbd->softrepeat = atkbd_softrepeat; 10281da177e4SLinus Torvalds atkbd->scroll = atkbd_scroll; 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds if (atkbd->softrepeat) 10311da177e4SLinus Torvalds atkbd->softraw = 1; 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds serio_set_drvdata(serio, atkbd); 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds err = serio_open(serio, drv); 10363c42f0c3SDmitry Torokhov if (err) 10372b03b60eSDmitry Torokhov goto fail2; 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds if (atkbd->write) { 10401da177e4SLinus Torvalds 10411da177e4SLinus Torvalds if (atkbd_probe(atkbd)) { 10423c42f0c3SDmitry Torokhov err = -ENODEV; 10432b03b60eSDmitry Torokhov goto fail3; 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra); 10471da177e4SLinus Torvalds atkbd_activate(atkbd); 10481da177e4SLinus Torvalds 10491da177e4SLinus Torvalds } else { 10501da177e4SLinus Torvalds atkbd->set = 2; 10511da177e4SLinus Torvalds atkbd->id = 0xab00; 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds atkbd_set_keycode_table(atkbd); 10551da177e4SLinus Torvalds atkbd_set_device_attrs(atkbd); 10561da177e4SLinus Torvalds 10572b03b60eSDmitry Torokhov err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group); 10582b03b60eSDmitry Torokhov if (err) 10592b03b60eSDmitry Torokhov goto fail3; 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds atkbd_enable(atkbd); 10621da177e4SLinus Torvalds 10632b03b60eSDmitry Torokhov err = input_register_device(atkbd->dev); 10642b03b60eSDmitry Torokhov if (err) 10652b03b60eSDmitry Torokhov goto fail4; 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds return 0; 10683c42f0c3SDmitry Torokhov 10692b03b60eSDmitry Torokhov fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group); 10702b03b60eSDmitry Torokhov fail3: serio_close(serio); 10712b03b60eSDmitry Torokhov fail2: serio_set_drvdata(serio, NULL); 10722b03b60eSDmitry Torokhov fail1: input_free_device(dev); 10733c42f0c3SDmitry Torokhov kfree(atkbd); 10743c42f0c3SDmitry Torokhov return err; 10751da177e4SLinus Torvalds } 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds /* 10781da177e4SLinus Torvalds * atkbd_reconnect() tries to restore keyboard into a sane state and is 10791da177e4SLinus Torvalds * most likely called on resume. 10801da177e4SLinus Torvalds */ 10811da177e4SLinus Torvalds 10821da177e4SLinus Torvalds static int atkbd_reconnect(struct serio *serio) 10831da177e4SLinus Torvalds { 10841da177e4SLinus Torvalds struct atkbd *atkbd = serio_get_drvdata(serio); 10851da177e4SLinus Torvalds struct serio_driver *drv = serio->drv; 10861da177e4SLinus Torvalds 10871da177e4SLinus Torvalds if (!atkbd || !drv) { 10881da177e4SLinus Torvalds printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n"); 10891da177e4SLinus Torvalds return -1; 10901da177e4SLinus Torvalds } 10911da177e4SLinus Torvalds 10921da177e4SLinus Torvalds atkbd_disable(atkbd); 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds if (atkbd->write) { 10951da177e4SLinus Torvalds if (atkbd_probe(atkbd)) 10961da177e4SLinus Torvalds return -1; 10971da177e4SLinus Torvalds if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra)) 10981da177e4SLinus Torvalds return -1; 10991da177e4SLinus Torvalds 11001da177e4SLinus Torvalds atkbd_activate(atkbd); 11011da177e4SLinus Torvalds 11023d0f0fa0SDmitry Torokhov /* 11033d0f0fa0SDmitry Torokhov * Restore repeat rate and LEDs (that were reset by atkbd_activate) 11043d0f0fa0SDmitry Torokhov * to pre-resume state 11053d0f0fa0SDmitry Torokhov */ 11063d0f0fa0SDmitry Torokhov if (!atkbd->softrepeat) 11073d0f0fa0SDmitry Torokhov atkbd_set_repeat_rate(atkbd); 11083d0f0fa0SDmitry Torokhov atkbd_set_leds(atkbd); 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds atkbd_enable(atkbd); 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds return 0; 11141da177e4SLinus Torvalds } 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds static struct serio_device_id atkbd_serio_ids[] = { 11171da177e4SLinus Torvalds { 11181da177e4SLinus Torvalds .type = SERIO_8042, 11191da177e4SLinus Torvalds .proto = SERIO_ANY, 11201da177e4SLinus Torvalds .id = SERIO_ANY, 11211da177e4SLinus Torvalds .extra = SERIO_ANY, 11221da177e4SLinus Torvalds }, 11231da177e4SLinus Torvalds { 11241da177e4SLinus Torvalds .type = SERIO_8042_XL, 11251da177e4SLinus Torvalds .proto = SERIO_ANY, 11261da177e4SLinus Torvalds .id = SERIO_ANY, 11271da177e4SLinus Torvalds .extra = SERIO_ANY, 11281da177e4SLinus Torvalds }, 11291da177e4SLinus Torvalds { 11301da177e4SLinus Torvalds .type = SERIO_RS232, 11311da177e4SLinus Torvalds .proto = SERIO_PS2SER, 11321da177e4SLinus Torvalds .id = SERIO_ANY, 11331da177e4SLinus Torvalds .extra = SERIO_ANY, 11341da177e4SLinus Torvalds }, 11351da177e4SLinus Torvalds { 0 } 11361da177e4SLinus Torvalds }; 11371da177e4SLinus Torvalds 11381da177e4SLinus Torvalds MODULE_DEVICE_TABLE(serio, atkbd_serio_ids); 11391da177e4SLinus Torvalds 11401da177e4SLinus Torvalds static struct serio_driver atkbd_drv = { 11411da177e4SLinus Torvalds .driver = { 11421da177e4SLinus Torvalds .name = "atkbd", 11431da177e4SLinus Torvalds }, 11441da177e4SLinus Torvalds .description = DRIVER_DESC, 11451da177e4SLinus Torvalds .id_table = atkbd_serio_ids, 11461da177e4SLinus Torvalds .interrupt = atkbd_interrupt, 11471da177e4SLinus Torvalds .connect = atkbd_connect, 11481da177e4SLinus Torvalds .reconnect = atkbd_reconnect, 11491da177e4SLinus Torvalds .disconnect = atkbd_disconnect, 11501da177e4SLinus Torvalds .cleanup = atkbd_cleanup, 11511da177e4SLinus Torvalds }; 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf, 11541da177e4SLinus Torvalds ssize_t (*handler)(struct atkbd *, char *)) 11551da177e4SLinus Torvalds { 11561da177e4SLinus Torvalds struct serio *serio = to_serio_port(dev); 11571da177e4SLinus Torvalds int retval; 11581da177e4SLinus Torvalds 11591da177e4SLinus Torvalds retval = serio_pin_driver(serio); 11601da177e4SLinus Torvalds if (retval) 11611da177e4SLinus Torvalds return retval; 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds if (serio->drv != &atkbd_drv) { 11641da177e4SLinus Torvalds retval = -ENODEV; 11651da177e4SLinus Torvalds goto out; 11661da177e4SLinus Torvalds } 11671da177e4SLinus Torvalds 11681da177e4SLinus Torvalds retval = handler((struct atkbd *)serio_get_drvdata(serio), buf); 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds out: 11711da177e4SLinus Torvalds serio_unpin_driver(serio); 11721da177e4SLinus Torvalds return retval; 11731da177e4SLinus Torvalds } 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count, 11761da177e4SLinus Torvalds ssize_t (*handler)(struct atkbd *, const char *, size_t)) 11771da177e4SLinus Torvalds { 11781da177e4SLinus Torvalds struct serio *serio = to_serio_port(dev); 11791da177e4SLinus Torvalds struct atkbd *atkbd; 11801da177e4SLinus Torvalds int retval; 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds retval = serio_pin_driver(serio); 11831da177e4SLinus Torvalds if (retval) 11841da177e4SLinus Torvalds return retval; 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds if (serio->drv != &atkbd_drv) { 11871da177e4SLinus Torvalds retval = -ENODEV; 11881da177e4SLinus Torvalds goto out; 11891da177e4SLinus Torvalds } 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds atkbd = serio_get_drvdata(serio); 11921da177e4SLinus Torvalds atkbd_disable(atkbd); 11931da177e4SLinus Torvalds retval = handler(atkbd, buf, count); 11941da177e4SLinus Torvalds atkbd_enable(atkbd); 11951da177e4SLinus Torvalds 11961da177e4SLinus Torvalds out: 11971da177e4SLinus Torvalds serio_unpin_driver(serio); 11981da177e4SLinus Torvalds return retval; 11991da177e4SLinus Torvalds } 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf) 12021da177e4SLinus Torvalds { 12031da177e4SLinus Torvalds return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0); 12041da177e4SLinus Torvalds } 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count) 12071da177e4SLinus Torvalds { 12082b03b60eSDmitry Torokhov struct input_dev *old_dev, *new_dev; 12091da177e4SLinus Torvalds unsigned long value; 12102b03b60eSDmitry Torokhov int err; 12112b03b60eSDmitry Torokhov unsigned char old_extra, old_set; 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds if (!atkbd->write) 12141da177e4SLinus Torvalds return -EIO; 12151da177e4SLinus Torvalds 1216160f1fefSJoe Rouvier if (strict_strtoul(buf, 10, &value) || value > 1) 12171da177e4SLinus Torvalds return -EINVAL; 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds if (atkbd->extra != value) { 12203c42f0c3SDmitry Torokhov /* 12213c42f0c3SDmitry Torokhov * Since device's properties will change we need to 12222b03b60eSDmitry Torokhov * unregister old device. But allocate and register 12232b03b60eSDmitry Torokhov * new one first to make sure we have it. 12243c42f0c3SDmitry Torokhov */ 12252b03b60eSDmitry Torokhov old_dev = atkbd->dev; 12262b03b60eSDmitry Torokhov old_extra = atkbd->extra; 12272b03b60eSDmitry Torokhov old_set = atkbd->set; 12282b03b60eSDmitry Torokhov 12292b03b60eSDmitry Torokhov new_dev = input_allocate_device(); 12302b03b60eSDmitry Torokhov if (!new_dev) 12313c42f0c3SDmitry Torokhov return -ENOMEM; 12322b03b60eSDmitry Torokhov 12333c42f0c3SDmitry Torokhov atkbd->dev = new_dev; 12341da177e4SLinus Torvalds atkbd->set = atkbd_select_set(atkbd, atkbd->set, value); 12351da177e4SLinus Torvalds atkbd_activate(atkbd); 12362b03b60eSDmitry Torokhov atkbd_set_keycode_table(atkbd); 12371da177e4SLinus Torvalds atkbd_set_device_attrs(atkbd); 12382b03b60eSDmitry Torokhov 12392b03b60eSDmitry Torokhov err = input_register_device(atkbd->dev); 12402b03b60eSDmitry Torokhov if (err) { 12412b03b60eSDmitry Torokhov input_free_device(new_dev); 12422b03b60eSDmitry Torokhov 12432b03b60eSDmitry Torokhov atkbd->dev = old_dev; 12442b03b60eSDmitry Torokhov atkbd->set = atkbd_select_set(atkbd, old_set, old_extra); 12452b03b60eSDmitry Torokhov atkbd_set_keycode_table(atkbd); 12462b03b60eSDmitry Torokhov atkbd_set_device_attrs(atkbd); 12472b03b60eSDmitry Torokhov 12482b03b60eSDmitry Torokhov return err; 12492b03b60eSDmitry Torokhov } 12502b03b60eSDmitry Torokhov input_unregister_device(old_dev); 12512b03b60eSDmitry Torokhov 12521da177e4SLinus Torvalds } 12531da177e4SLinus Torvalds return count; 12541da177e4SLinus Torvalds } 12551da177e4SLinus Torvalds 12561da177e4SLinus Torvalds static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf) 12571da177e4SLinus Torvalds { 12581da177e4SLinus Torvalds return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0); 12591da177e4SLinus Torvalds } 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count) 12621da177e4SLinus Torvalds { 12632b03b60eSDmitry Torokhov struct input_dev *old_dev, *new_dev; 12641da177e4SLinus Torvalds unsigned long value; 12652b03b60eSDmitry Torokhov int err; 12662b03b60eSDmitry Torokhov unsigned char old_scroll; 12671da177e4SLinus Torvalds 1268160f1fefSJoe Rouvier if (strict_strtoul(buf, 10, &value) || value > 1) 12691da177e4SLinus Torvalds return -EINVAL; 12701da177e4SLinus Torvalds 12711da177e4SLinus Torvalds if (atkbd->scroll != value) { 12722b03b60eSDmitry Torokhov old_dev = atkbd->dev; 12732b03b60eSDmitry Torokhov old_scroll = atkbd->scroll; 12742b03b60eSDmitry Torokhov 12752b03b60eSDmitry Torokhov new_dev = input_allocate_device(); 12762b03b60eSDmitry Torokhov if (!new_dev) 12773c42f0c3SDmitry Torokhov return -ENOMEM; 12782b03b60eSDmitry Torokhov 12793c42f0c3SDmitry Torokhov atkbd->dev = new_dev; 12801da177e4SLinus Torvalds atkbd->scroll = value; 12811da177e4SLinus Torvalds atkbd_set_keycode_table(atkbd); 12821da177e4SLinus Torvalds atkbd_set_device_attrs(atkbd); 12832b03b60eSDmitry Torokhov 12842b03b60eSDmitry Torokhov err = input_register_device(atkbd->dev); 12852b03b60eSDmitry Torokhov if (err) { 12862b03b60eSDmitry Torokhov input_free_device(new_dev); 12872b03b60eSDmitry Torokhov 12882b03b60eSDmitry Torokhov atkbd->scroll = old_scroll; 12892b03b60eSDmitry Torokhov atkbd->dev = old_dev; 12902b03b60eSDmitry Torokhov atkbd_set_keycode_table(atkbd); 12912b03b60eSDmitry Torokhov atkbd_set_device_attrs(atkbd); 12922b03b60eSDmitry Torokhov 12932b03b60eSDmitry Torokhov return err; 12942b03b60eSDmitry Torokhov } 12952b03b60eSDmitry Torokhov input_unregister_device(old_dev); 12961da177e4SLinus Torvalds } 12971da177e4SLinus Torvalds return count; 12981da177e4SLinus Torvalds } 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf) 13011da177e4SLinus Torvalds { 13021da177e4SLinus Torvalds return sprintf(buf, "%d\n", atkbd->set); 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count) 13061da177e4SLinus Torvalds { 13072b03b60eSDmitry Torokhov struct input_dev *old_dev, *new_dev; 13081da177e4SLinus Torvalds unsigned long value; 13092b03b60eSDmitry Torokhov int err; 13102b03b60eSDmitry Torokhov unsigned char old_set, old_extra; 13111da177e4SLinus Torvalds 13121da177e4SLinus Torvalds if (!atkbd->write) 13131da177e4SLinus Torvalds return -EIO; 13141da177e4SLinus Torvalds 1315160f1fefSJoe Rouvier if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3)) 13161da177e4SLinus Torvalds return -EINVAL; 13171da177e4SLinus Torvalds 13181da177e4SLinus Torvalds if (atkbd->set != value) { 13192b03b60eSDmitry Torokhov old_dev = atkbd->dev; 13202b03b60eSDmitry Torokhov old_extra = atkbd->extra; 13212b03b60eSDmitry Torokhov old_set = atkbd->set; 13222b03b60eSDmitry Torokhov 13232b03b60eSDmitry Torokhov new_dev = input_allocate_device(); 13242b03b60eSDmitry Torokhov if (!new_dev) 13253c42f0c3SDmitry Torokhov return -ENOMEM; 13262b03b60eSDmitry Torokhov 13273c42f0c3SDmitry Torokhov atkbd->dev = new_dev; 13281da177e4SLinus Torvalds atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra); 13291da177e4SLinus Torvalds atkbd_activate(atkbd); 13301da177e4SLinus Torvalds atkbd_set_keycode_table(atkbd); 13311da177e4SLinus Torvalds atkbd_set_device_attrs(atkbd); 13322b03b60eSDmitry Torokhov 13332b03b60eSDmitry Torokhov err = input_register_device(atkbd->dev); 13342b03b60eSDmitry Torokhov if (err) { 13352b03b60eSDmitry Torokhov input_free_device(new_dev); 13362b03b60eSDmitry Torokhov 13372b03b60eSDmitry Torokhov atkbd->dev = old_dev; 13382b03b60eSDmitry Torokhov atkbd->set = atkbd_select_set(atkbd, old_set, old_extra); 13392b03b60eSDmitry Torokhov atkbd_set_keycode_table(atkbd); 13402b03b60eSDmitry Torokhov atkbd_set_device_attrs(atkbd); 13412b03b60eSDmitry Torokhov 13422b03b60eSDmitry Torokhov return err; 13432b03b60eSDmitry Torokhov } 13442b03b60eSDmitry Torokhov input_unregister_device(old_dev); 13451da177e4SLinus Torvalds } 13461da177e4SLinus Torvalds return count; 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf) 13501da177e4SLinus Torvalds { 13511da177e4SLinus Torvalds return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0); 13521da177e4SLinus Torvalds } 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count) 13551da177e4SLinus Torvalds { 13562b03b60eSDmitry Torokhov struct input_dev *old_dev, *new_dev; 13571da177e4SLinus Torvalds unsigned long value; 13582b03b60eSDmitry Torokhov int err; 13592b03b60eSDmitry Torokhov unsigned char old_softrepeat, old_softraw; 13601da177e4SLinus Torvalds 13611da177e4SLinus Torvalds if (!atkbd->write) 13621da177e4SLinus Torvalds return -EIO; 13631da177e4SLinus Torvalds 1364160f1fefSJoe Rouvier if (strict_strtoul(buf, 10, &value) || value > 1) 13651da177e4SLinus Torvalds return -EINVAL; 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds if (atkbd->softrepeat != value) { 13682b03b60eSDmitry Torokhov old_dev = atkbd->dev; 13692b03b60eSDmitry Torokhov old_softrepeat = atkbd->softrepeat; 13702b03b60eSDmitry Torokhov old_softraw = atkbd->softraw; 13712b03b60eSDmitry Torokhov 13722b03b60eSDmitry Torokhov new_dev = input_allocate_device(); 13732b03b60eSDmitry Torokhov if (!new_dev) 13743c42f0c3SDmitry Torokhov return -ENOMEM; 13752b03b60eSDmitry Torokhov 13763c42f0c3SDmitry Torokhov atkbd->dev = new_dev; 13771da177e4SLinus Torvalds atkbd->softrepeat = value; 13781da177e4SLinus Torvalds if (atkbd->softrepeat) 13791da177e4SLinus Torvalds atkbd->softraw = 1; 13801da177e4SLinus Torvalds atkbd_set_device_attrs(atkbd); 13812b03b60eSDmitry Torokhov 13822b03b60eSDmitry Torokhov err = input_register_device(atkbd->dev); 13832b03b60eSDmitry Torokhov if (err) { 13842b03b60eSDmitry Torokhov input_free_device(new_dev); 13852b03b60eSDmitry Torokhov 13862b03b60eSDmitry Torokhov atkbd->dev = old_dev; 13872b03b60eSDmitry Torokhov atkbd->softrepeat = old_softrepeat; 13882b03b60eSDmitry Torokhov atkbd->softraw = old_softraw; 13892b03b60eSDmitry Torokhov atkbd_set_device_attrs(atkbd); 13902b03b60eSDmitry Torokhov 13912b03b60eSDmitry Torokhov return err; 13922b03b60eSDmitry Torokhov } 13932b03b60eSDmitry Torokhov input_unregister_device(old_dev); 13941da177e4SLinus Torvalds } 13951da177e4SLinus Torvalds return count; 13961da177e4SLinus Torvalds } 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf) 14001da177e4SLinus Torvalds { 14011da177e4SLinus Torvalds return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0); 14021da177e4SLinus Torvalds } 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count) 14051da177e4SLinus Torvalds { 14062b03b60eSDmitry Torokhov struct input_dev *old_dev, *new_dev; 14071da177e4SLinus Torvalds unsigned long value; 14082b03b60eSDmitry Torokhov int err; 14092b03b60eSDmitry Torokhov unsigned char old_softraw; 14101da177e4SLinus Torvalds 1411160f1fefSJoe Rouvier if (strict_strtoul(buf, 10, &value) || value > 1) 14121da177e4SLinus Torvalds return -EINVAL; 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds if (atkbd->softraw != value) { 14152b03b60eSDmitry Torokhov old_dev = atkbd->dev; 14162b03b60eSDmitry Torokhov old_softraw = atkbd->softraw; 14172b03b60eSDmitry Torokhov 14182b03b60eSDmitry Torokhov new_dev = input_allocate_device(); 14192b03b60eSDmitry Torokhov if (!new_dev) 14203c42f0c3SDmitry Torokhov return -ENOMEM; 14212b03b60eSDmitry Torokhov 14223c42f0c3SDmitry Torokhov atkbd->dev = new_dev; 14231da177e4SLinus Torvalds atkbd->softraw = value; 14241da177e4SLinus Torvalds atkbd_set_device_attrs(atkbd); 14252b03b60eSDmitry Torokhov 14262b03b60eSDmitry Torokhov err = input_register_device(atkbd->dev); 14272b03b60eSDmitry Torokhov if (err) { 14282b03b60eSDmitry Torokhov input_free_device(new_dev); 14292b03b60eSDmitry Torokhov 14302b03b60eSDmitry Torokhov atkbd->dev = old_dev; 14312b03b60eSDmitry Torokhov atkbd->softraw = old_softraw; 14322b03b60eSDmitry Torokhov atkbd_set_device_attrs(atkbd); 14332b03b60eSDmitry Torokhov 14342b03b60eSDmitry Torokhov return err; 14352b03b60eSDmitry Torokhov } 14362b03b60eSDmitry Torokhov input_unregister_device(old_dev); 14371da177e4SLinus Torvalds } 14381da177e4SLinus Torvalds return count; 14391da177e4SLinus Torvalds } 14401da177e4SLinus Torvalds 144186255d9dSDmitry Torokhov static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf) 144286255d9dSDmitry Torokhov { 144386255d9dSDmitry Torokhov return sprintf(buf, "%lu\n", atkbd->err_count); 144486255d9dSDmitry Torokhov } 144586255d9dSDmitry Torokhov 1446554101e3SGiel de Nijs static int __init atkbd_setup_fixup(const struct dmi_system_id *id) 1447554101e3SGiel de Nijs { 1448554101e3SGiel de Nijs atkbd_platform_fixup = id->driver_data; 1449554101e3SGiel de Nijs return 0; 1450554101e3SGiel de Nijs } 1451554101e3SGiel de Nijs 1452554101e3SGiel de Nijs static struct dmi_system_id atkbd_dmi_quirk_table[] __initdata = { 1453554101e3SGiel de Nijs { 1454*61579ba8SMatthew Garrett .ident = "Dell Laptop", 1455554101e3SGiel de Nijs .matches = { 1456554101e3SGiel de Nijs DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1457*61579ba8SMatthew Garrett DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */ 1458554101e3SGiel de Nijs }, 1459554101e3SGiel de Nijs .callback = atkbd_setup_fixup, 1460*61579ba8SMatthew Garrett .driver_data = atkbd_dell_laptop_keymap_fixup, 1461554101e3SGiel de Nijs }, 14625a54c011SJiri Kosina { 14635a54c011SJiri Kosina .ident = "HP 2133", 14645a54c011SJiri Kosina .matches = { 14655a54c011SJiri Kosina DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 14665a54c011SJiri Kosina DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"), 14675a54c011SJiri Kosina }, 14685a54c011SJiri Kosina .callback = atkbd_setup_fixup, 14695a54c011SJiri Kosina .driver_data = atkbd_hp_keymap_fixup, 14705a54c011SJiri Kosina }, 1471554101e3SGiel de Nijs { } 1472554101e3SGiel de Nijs }; 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds static int __init atkbd_init(void) 14751da177e4SLinus Torvalds { 1476554101e3SGiel de Nijs dmi_check_system(atkbd_dmi_quirk_table); 1477554101e3SGiel de Nijs 1478153a9df0SAkinobu Mita return serio_register_driver(&atkbd_drv); 14791da177e4SLinus Torvalds } 14801da177e4SLinus Torvalds 14811da177e4SLinus Torvalds static void __exit atkbd_exit(void) 14821da177e4SLinus Torvalds { 14831da177e4SLinus Torvalds serio_unregister_driver(&atkbd_drv); 14841da177e4SLinus Torvalds } 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds module_init(atkbd_init); 14871da177e4SLinus Torvalds module_exit(atkbd_exit); 1488