Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * AT and PS/2 keyboard driver
0004  *
0005  * Copyright (c) 1999-2002 Vojtech Pavlik
0006  */
0007 
0008 
0009 /*
0010  * This driver can handle standard AT keyboards and PS/2 keyboards in
0011  * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb
0012  * input-only controllers and AT keyboards connected over a one way RS232
0013  * converter.
0014  */
0015 
0016 #include <linux/delay.h>
0017 #include <linux/module.h>
0018 #include <linux/slab.h>
0019 #include <linux/interrupt.h>
0020 #include <linux/init.h>
0021 #include <linux/input.h>
0022 #include <linux/input/vivaldi-fmap.h>
0023 #include <linux/serio.h>
0024 #include <linux/workqueue.h>
0025 #include <linux/libps2.h>
0026 #include <linux/mutex.h>
0027 #include <linux/dmi.h>
0028 #include <linux/property.h>
0029 
0030 #define DRIVER_DESC "AT and PS/2 keyboard driver"
0031 
0032 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
0033 MODULE_DESCRIPTION(DRIVER_DESC);
0034 MODULE_LICENSE("GPL");
0035 
0036 static int atkbd_set = 2;
0037 module_param_named(set, atkbd_set, int, 0);
0038 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
0039 
0040 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
0041 static bool atkbd_reset;
0042 #else
0043 static bool atkbd_reset = true;
0044 #endif
0045 module_param_named(reset, atkbd_reset, bool, 0);
0046 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
0047 
0048 static bool atkbd_softrepeat;
0049 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
0050 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
0051 
0052 static bool atkbd_softraw = true;
0053 module_param_named(softraw, atkbd_softraw, bool, 0);
0054 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
0055 
0056 static bool atkbd_scroll;
0057 module_param_named(scroll, atkbd_scroll, bool, 0);
0058 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
0059 
0060 static bool atkbd_extra;
0061 module_param_named(extra, atkbd_extra, bool, 0);
0062 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
0063 
0064 static bool atkbd_terminal;
0065 module_param_named(terminal, atkbd_terminal, bool, 0);
0066 MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2");
0067 
0068 #define SCANCODE(keymap)    ((keymap >> 16) & 0xFFFF)
0069 #define KEYCODE(keymap)     (keymap & 0xFFFF)
0070 
0071 /*
0072  * Scancode to keycode tables. These are just the default setting, and
0073  * are loadable via a userland utility.
0074  */
0075 
0076 #define ATKBD_KEYMAP_SIZE   512
0077 
0078 static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
0079 
0080 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
0081 
0082 /* XXX: need a more general approach */
0083 
0084 #include "hpps2atkbd.h" /* include the keyboard scancodes */
0085 
0086 #else
0087       0, 67, 65, 63, 61, 59, 60, 88,  0, 68, 66, 64, 62, 15, 41,117,
0088       0, 56, 42, 93, 29, 16,  2,  0,  0,  0, 44, 31, 30, 17,  3,  0,
0089       0, 46, 45, 32, 18,  5,  4, 95,  0, 57, 47, 33, 20, 19,  6,183,
0090       0, 49, 48, 35, 34, 21,  7,184,  0,  0, 50, 36, 22,  8,  9,185,
0091       0, 51, 37, 23, 24, 11, 10,  0,  0, 52, 53, 38, 39, 25, 12,  0,
0092       0, 89, 40,  0, 26, 13,  0,  0, 58, 54, 28, 27,  0, 43,  0, 85,
0093       0, 86, 91, 90, 92,  0, 14, 94,  0, 79,124, 75, 71,121,  0,  0,
0094      82, 83, 80, 76, 77, 72,  1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
0095 
0096       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0097     217,100,255,  0, 97,165,  0,  0,156,  0,  0,  0,  0,  0,  0,125,
0098     173,114,  0,113,  0,  0,  0,126,128,  0,  0,140,  0,  0,  0,127,
0099     159,  0,115,  0,164,  0,  0,116,158,  0,172,166,  0,  0,  0,142,
0100     157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
0101     226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
0102       0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
0103     110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,
0104 
0105       0,  0,  0, 65, 99,
0106 #endif
0107 };
0108 
0109 static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
0110 
0111       0,  0,  0,  0,  0,  0,  0, 59,  1,138,128,129,130, 15, 41, 60,
0112     131, 29, 42, 86, 58, 16,  2, 61,133, 56, 44, 31, 30, 17,  3, 62,
0113     134, 46, 45, 32, 18,  5,  4, 63,135, 57, 47, 33, 20, 19,  6, 64,
0114     136, 49, 48, 35, 34, 21,  7, 65,137,100, 50, 36, 22,  8,  9, 66,
0115     125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
0116     113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
0117     108,105,119,103,111,107, 14,110,  0, 79,106, 75, 71,109,102,104,
0118      82, 83, 80, 76, 77, 72, 69, 98,  0, 96, 81,  0, 78, 73, 55,183,
0119 
0120     184,185,186,187, 74, 94, 92, 93,  0,  0,  0,125,126,127,112,  0,
0121       0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
0122     148,149,147,140
0123 };
0124 
0125 static const unsigned short atkbd_unxlate_table[128] = {
0126           0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
0127          21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
0128          35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
0129          50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88,  5,  6,  4, 12,  3,
0130          11,  2, 10,  1,  9,119,126,108,117,125,123,107,115,116,121,105,
0131         114,122,112,113,127, 96, 97,120,  7, 15, 23, 31, 39, 47, 55, 63,
0132          71, 79, 86, 94,  8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
0133          19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
0134 };
0135 
0136 #define ATKBD_CMD_SETLEDS   0x10ed
0137 #define ATKBD_CMD_GSCANSET  0x11f0
0138 #define ATKBD_CMD_SSCANSET  0x10f0
0139 #define ATKBD_CMD_GETID     0x02f2
0140 #define ATKBD_CMD_SETREP    0x10f3
0141 #define ATKBD_CMD_ENABLE    0x00f4
0142 #define ATKBD_CMD_RESET_DIS 0x00f5  /* Reset to defaults and disable */
0143 #define ATKBD_CMD_RESET_DEF 0x00f6  /* Reset to defaults */
0144 #define ATKBD_CMD_SETALL_MB 0x00f8  /* Set all keys to give break codes */
0145 #define ATKBD_CMD_SETALL_MBR    0x00fa  /* ... and repeat */
0146 #define ATKBD_CMD_RESET_BAT 0x02ff
0147 #define ATKBD_CMD_RESEND    0x00fe
0148 #define ATKBD_CMD_EX_ENABLE 0x10ea
0149 #define ATKBD_CMD_EX_SETLEDS    0x20eb
0150 #define ATKBD_CMD_OK_GETID  0x02e8
0151 
0152 #define ATKBD_RET_ACK       0xfa
0153 #define ATKBD_RET_NAK       0xfe
0154 #define ATKBD_RET_BAT       0xaa
0155 #define ATKBD_RET_EMUL0     0xe0
0156 #define ATKBD_RET_EMUL1     0xe1
0157 #define ATKBD_RET_RELEASE   0xf0
0158 #define ATKBD_RET_HANJA     0xf1
0159 #define ATKBD_RET_HANGEUL   0xf2
0160 #define ATKBD_RET_ERR       0xff
0161 
0162 #define ATKBD_KEY_UNKNOWN   0
0163 #define ATKBD_KEY_NULL      255
0164 
0165 #define ATKBD_SCR_1     0xfffe
0166 #define ATKBD_SCR_2     0xfffd
0167 #define ATKBD_SCR_4     0xfffc
0168 #define ATKBD_SCR_8     0xfffb
0169 #define ATKBD_SCR_CLICK     0xfffa
0170 #define ATKBD_SCR_LEFT      0xfff9
0171 #define ATKBD_SCR_RIGHT     0xfff8
0172 
0173 #define ATKBD_SPECIAL       ATKBD_SCR_RIGHT
0174 
0175 #define ATKBD_LED_EVENT_BIT 0
0176 #define ATKBD_REP_EVENT_BIT 1
0177 
0178 #define ATKBD_XL_ERR        0x01
0179 #define ATKBD_XL_BAT        0x02
0180 #define ATKBD_XL_ACK        0x04
0181 #define ATKBD_XL_NAK        0x08
0182 #define ATKBD_XL_HANGEUL    0x10
0183 #define ATKBD_XL_HANJA      0x20
0184 
0185 static const struct {
0186     unsigned short keycode;
0187     unsigned char set2;
0188 } atkbd_scroll_keys[] = {
0189     { ATKBD_SCR_1,     0xc5 },
0190     { ATKBD_SCR_2,     0x9d },
0191     { ATKBD_SCR_4,     0xa4 },
0192     { ATKBD_SCR_8,     0x9b },
0193     { ATKBD_SCR_CLICK, 0xe0 },
0194     { ATKBD_SCR_LEFT,  0xcb },
0195     { ATKBD_SCR_RIGHT, 0xd2 },
0196 };
0197 
0198 /*
0199  * The atkbd control structure
0200  */
0201 
0202 struct atkbd {
0203 
0204     struct ps2dev ps2dev;
0205     struct input_dev *dev;
0206 
0207     /* Written only during init */
0208     char name[64];
0209     char phys[32];
0210 
0211     unsigned short id;
0212     unsigned short keycode[ATKBD_KEYMAP_SIZE];
0213     DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
0214     unsigned char set;
0215     bool translated;
0216     bool extra;
0217     bool write;
0218     bool softrepeat;
0219     bool softraw;
0220     bool scroll;
0221     bool enabled;
0222 
0223     /* Accessed only from interrupt */
0224     unsigned char emul;
0225     bool resend;
0226     bool release;
0227     unsigned long xl_bit;
0228     unsigned int last;
0229     unsigned long time;
0230     unsigned long err_count;
0231 
0232     struct delayed_work event_work;
0233     unsigned long event_jiffies;
0234     unsigned long event_mask;
0235 
0236     /* Serializes reconnect(), attr->set() and event work */
0237     struct mutex mutex;
0238 
0239     struct vivaldi_data vdata;
0240 };
0241 
0242 /*
0243  * System-specific keymap fixup routine
0244  */
0245 static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
0246 static void *atkbd_platform_fixup_data;
0247 static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int);
0248 
0249 /*
0250  * Certain keyboards to not like ATKBD_CMD_RESET_DIS and stop responding
0251  * to many commands until full reset (ATKBD_CMD_RESET_BAT) is performed.
0252  */
0253 static bool atkbd_skip_deactivate;
0254 
0255 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
0256                 ssize_t (*handler)(struct atkbd *, char *));
0257 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
0258                 ssize_t (*handler)(struct atkbd *, const char *, size_t));
0259 #define ATKBD_DEFINE_ATTR(_name)                        \
0260 static ssize_t atkbd_show_##_name(struct atkbd *, char *);          \
0261 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t);     \
0262 static ssize_t atkbd_do_show_##_name(struct device *d,              \
0263                 struct device_attribute *attr, char *b)     \
0264 {                                       \
0265     return atkbd_attr_show_helper(d, b, atkbd_show_##_name);        \
0266 }                                       \
0267 static ssize_t atkbd_do_set_##_name(struct device *d,               \
0268             struct device_attribute *attr, const char *b, size_t s) \
0269 {                                       \
0270     return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name);       \
0271 }                                       \
0272 static struct device_attribute atkbd_attr_##_name =             \
0273     __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
0274 
0275 ATKBD_DEFINE_ATTR(extra);
0276 ATKBD_DEFINE_ATTR(force_release);
0277 ATKBD_DEFINE_ATTR(scroll);
0278 ATKBD_DEFINE_ATTR(set);
0279 ATKBD_DEFINE_ATTR(softrepeat);
0280 ATKBD_DEFINE_ATTR(softraw);
0281 
0282 #define ATKBD_DEFINE_RO_ATTR(_name)                     \
0283 static ssize_t atkbd_show_##_name(struct atkbd *, char *);          \
0284 static ssize_t atkbd_do_show_##_name(struct device *d,              \
0285                 struct device_attribute *attr, char *b)     \
0286 {                                       \
0287     return atkbd_attr_show_helper(d, b, atkbd_show_##_name);        \
0288 }                                       \
0289 static struct device_attribute atkbd_attr_##_name =             \
0290     __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
0291 
0292 ATKBD_DEFINE_RO_ATTR(err_count);
0293 ATKBD_DEFINE_RO_ATTR(function_row_physmap);
0294 
0295 static struct attribute *atkbd_attributes[] = {
0296     &atkbd_attr_extra.attr,
0297     &atkbd_attr_force_release.attr,
0298     &atkbd_attr_scroll.attr,
0299     &atkbd_attr_set.attr,
0300     &atkbd_attr_softrepeat.attr,
0301     &atkbd_attr_softraw.attr,
0302     &atkbd_attr_err_count.attr,
0303     &atkbd_attr_function_row_physmap.attr,
0304     NULL
0305 };
0306 
0307 static ssize_t atkbd_show_function_row_physmap(struct atkbd *atkbd, char *buf)
0308 {
0309     return vivaldi_function_row_physmap_show(&atkbd->vdata, buf);
0310 }
0311 
0312 static umode_t atkbd_attr_is_visible(struct kobject *kobj,
0313                 struct attribute *attr, int i)
0314 {
0315     struct device *dev = kobj_to_dev(kobj);
0316     struct serio *serio = to_serio_port(dev);
0317     struct atkbd *atkbd = serio_get_drvdata(serio);
0318 
0319     if (attr == &atkbd_attr_function_row_physmap.attr &&
0320         !atkbd->vdata.num_function_row_keys)
0321         return 0;
0322 
0323     return attr->mode;
0324 }
0325 
0326 static struct attribute_group atkbd_attribute_group = {
0327     .attrs  = atkbd_attributes,
0328     .is_visible = atkbd_attr_is_visible,
0329 };
0330 
0331 static const unsigned int xl_table[] = {
0332     ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
0333     ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
0334 };
0335 
0336 /*
0337  * Checks if we should mangle the scancode to extract 'release' bit
0338  * in translated mode.
0339  */
0340 static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
0341 {
0342     int i;
0343 
0344     if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
0345         return false;
0346 
0347     for (i = 0; i < ARRAY_SIZE(xl_table); i++)
0348         if (code == xl_table[i])
0349             return test_bit(i, &xl_bit);
0350 
0351     return true;
0352 }
0353 
0354 /*
0355  * Calculates new value of xl_bit so the driver can distinguish
0356  * between make/break pair of scancodes for select keys and PS/2
0357  * protocol responses.
0358  */
0359 static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
0360 {
0361     int i;
0362 
0363     for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
0364         if (!((code ^ xl_table[i]) & 0x7f)) {
0365             if (code & 0x80)
0366                 __clear_bit(i, &atkbd->xl_bit);
0367             else
0368                 __set_bit(i, &atkbd->xl_bit);
0369             break;
0370         }
0371     }
0372 }
0373 
0374 /*
0375  * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
0376  * keeping kernel 2.4 compatibility for set 2
0377  */
0378 static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
0379 {
0380     if (atkbd->set == 3) {
0381         if (atkbd->emul == 1)
0382             code |= 0x100;
0383         } else {
0384         code = (code & 0x7f) | ((code & 0x80) << 1);
0385         if (atkbd->emul == 1)
0386             code |= 0x80;
0387     }
0388 
0389     return code;
0390 }
0391 
0392 /*
0393  * atkbd_interrupt(). Here takes place processing of data received from
0394  * the keyboard into events.
0395  */
0396 
0397 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
0398                    unsigned int flags)
0399 {
0400     struct atkbd *atkbd = serio_get_drvdata(serio);
0401     struct input_dev *dev = atkbd->dev;
0402     unsigned int code = data;
0403     int scroll = 0, hscroll = 0, click = -1;
0404     int value;
0405     unsigned short keycode;
0406 
0407     dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
0408 
0409 #if !defined(__i386__) && !defined (__x86_64__)
0410     if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
0411         dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
0412         serio_write(serio, ATKBD_CMD_RESEND);
0413         atkbd->resend = true;
0414         goto out;
0415     }
0416 
0417     if (!flags && data == ATKBD_RET_ACK)
0418         atkbd->resend = false;
0419 #endif
0420 
0421     if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
0422         if  (ps2_handle_ack(&atkbd->ps2dev, data))
0423             goto out;
0424 
0425     if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
0426         if  (ps2_handle_response(&atkbd->ps2dev, data))
0427             goto out;
0428 
0429     pm_wakeup_event(&serio->dev, 0);
0430 
0431     if (!atkbd->enabled)
0432         goto out;
0433 
0434     input_event(dev, EV_MSC, MSC_RAW, code);
0435 
0436     if (atkbd_platform_scancode_fixup)
0437         code = atkbd_platform_scancode_fixup(atkbd, code);
0438 
0439     if (atkbd->translated) {
0440 
0441         if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
0442             atkbd->release = code >> 7;
0443             code &= 0x7f;
0444         }
0445 
0446         if (!atkbd->emul)
0447             atkbd_calculate_xl_bit(atkbd, data);
0448     }
0449 
0450     switch (code) {
0451     case ATKBD_RET_BAT:
0452         atkbd->enabled = false;
0453         serio_reconnect(atkbd->ps2dev.serio);
0454         goto out;
0455     case ATKBD_RET_EMUL0:
0456         atkbd->emul = 1;
0457         goto out;
0458     case ATKBD_RET_EMUL1:
0459         atkbd->emul = 2;
0460         goto out;
0461     case ATKBD_RET_RELEASE:
0462         atkbd->release = true;
0463         goto out;
0464     case ATKBD_RET_ACK:
0465     case ATKBD_RET_NAK:
0466         if (printk_ratelimit())
0467             dev_warn(&serio->dev,
0468                  "Spurious %s on %s. "
0469                  "Some program might be trying to access hardware directly.\n",
0470                  data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
0471         goto out;
0472     case ATKBD_RET_ERR:
0473         atkbd->err_count++;
0474         dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
0475             serio->phys);
0476         goto out;
0477     }
0478 
0479     code = atkbd_compat_scancode(atkbd, code);
0480 
0481     if (atkbd->emul && --atkbd->emul)
0482         goto out;
0483 
0484     keycode = atkbd->keycode[code];
0485 
0486     if (!(atkbd->release && test_bit(code, atkbd->force_release_mask)))
0487         if (keycode != ATKBD_KEY_NULL)
0488             input_event(dev, EV_MSC, MSC_SCAN, code);
0489 
0490     switch (keycode) {
0491     case ATKBD_KEY_NULL:
0492         break;
0493     case ATKBD_KEY_UNKNOWN:
0494         dev_warn(&serio->dev,
0495              "Unknown key %s (%s set %d, code %#x on %s).\n",
0496              atkbd->release ? "released" : "pressed",
0497              atkbd->translated ? "translated" : "raw",
0498              atkbd->set, code, serio->phys);
0499         dev_warn(&serio->dev,
0500              "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
0501              code & 0x80 ? "e0" : "", code & 0x7f);
0502         input_sync(dev);
0503         break;
0504     case ATKBD_SCR_1:
0505         scroll = 1;
0506         break;
0507     case ATKBD_SCR_2:
0508         scroll = 2;
0509         break;
0510     case ATKBD_SCR_4:
0511         scroll = 4;
0512         break;
0513     case ATKBD_SCR_8:
0514         scroll = 8;
0515         break;
0516     case ATKBD_SCR_CLICK:
0517         click = !atkbd->release;
0518         break;
0519     case ATKBD_SCR_LEFT:
0520         hscroll = -1;
0521         break;
0522     case ATKBD_SCR_RIGHT:
0523         hscroll = 1;
0524         break;
0525     default:
0526         if (atkbd->release) {
0527             value = 0;
0528             atkbd->last = 0;
0529         } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
0530             /* Workaround Toshiba laptop multiple keypress */
0531             value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
0532         } else {
0533             value = 1;
0534             atkbd->last = code;
0535             atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
0536         }
0537 
0538         input_event(dev, EV_KEY, keycode, value);
0539         input_sync(dev);
0540 
0541         if (value && test_bit(code, atkbd->force_release_mask)) {
0542             input_event(dev, EV_MSC, MSC_SCAN, code);
0543             input_report_key(dev, keycode, 0);
0544             input_sync(dev);
0545         }
0546     }
0547 
0548     if (atkbd->scroll) {
0549         if (click != -1)
0550             input_report_key(dev, BTN_MIDDLE, click);
0551         input_report_rel(dev, REL_WHEEL,
0552                  atkbd->release ? -scroll : scroll);
0553         input_report_rel(dev, REL_HWHEEL, hscroll);
0554         input_sync(dev);
0555     }
0556 
0557     atkbd->release = false;
0558 out:
0559     return IRQ_HANDLED;
0560 }
0561 
0562 static int atkbd_set_repeat_rate(struct atkbd *atkbd)
0563 {
0564     const short period[32] =
0565         { 33,  37,  42,  46,  50,  54,  58,  63,  67,  75,  83,  92, 100, 109, 116, 125,
0566          133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
0567     const short delay[4] =
0568         { 250, 500, 750, 1000 };
0569 
0570     struct input_dev *dev = atkbd->dev;
0571     unsigned char param;
0572     int i = 0, j = 0;
0573 
0574     while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
0575         i++;
0576     dev->rep[REP_PERIOD] = period[i];
0577 
0578     while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
0579         j++;
0580     dev->rep[REP_DELAY] = delay[j];
0581 
0582     param = i | (j << 5);
0583     return ps2_command(&atkbd->ps2dev, &param, ATKBD_CMD_SETREP);
0584 }
0585 
0586 static int atkbd_set_leds(struct atkbd *atkbd)
0587 {
0588     struct input_dev *dev = atkbd->dev;
0589     unsigned char param[2];
0590 
0591     param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
0592          | (test_bit(LED_NUML,    dev->led) ? 2 : 0)
0593          | (test_bit(LED_CAPSL,   dev->led) ? 4 : 0);
0594     if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
0595         return -1;
0596 
0597     if (atkbd->extra) {
0598         param[0] = 0;
0599         param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
0600              | (test_bit(LED_SLEEP,   dev->led) ? 0x02 : 0)
0601              | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
0602              | (test_bit(LED_MISC,    dev->led) ? 0x10 : 0)
0603              | (test_bit(LED_MUTE,    dev->led) ? 0x20 : 0);
0604         if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
0605             return -1;
0606     }
0607 
0608     return 0;
0609 }
0610 
0611 /*
0612  * atkbd_event_work() is used to complete processing of events that
0613  * can not be processed by input_event() which is often called from
0614  * interrupt context.
0615  */
0616 
0617 static void atkbd_event_work(struct work_struct *work)
0618 {
0619     struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
0620 
0621     mutex_lock(&atkbd->mutex);
0622 
0623     if (!atkbd->enabled) {
0624         /*
0625          * Serio ports are resumed asynchronously so while driver core
0626          * thinks that device is already fully operational in reality
0627          * it may not be ready yet. In this case we need to keep
0628          * rescheduling till reconnect completes.
0629          */
0630         schedule_delayed_work(&atkbd->event_work,
0631                     msecs_to_jiffies(100));
0632     } else {
0633         if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
0634             atkbd_set_leds(atkbd);
0635 
0636         if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
0637             atkbd_set_repeat_rate(atkbd);
0638     }
0639 
0640     mutex_unlock(&atkbd->mutex);
0641 }
0642 
0643 /*
0644  * Schedule switch for execution. We need to throttle requests,
0645  * otherwise keyboard may become unresponsive.
0646  */
0647 static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
0648 {
0649     unsigned long delay = msecs_to_jiffies(50);
0650 
0651     if (time_after(jiffies, atkbd->event_jiffies + delay))
0652         delay = 0;
0653 
0654     atkbd->event_jiffies = jiffies;
0655     set_bit(event_bit, &atkbd->event_mask);
0656     mb();
0657     schedule_delayed_work(&atkbd->event_work, delay);
0658 }
0659 
0660 /*
0661  * Event callback from the input module. Events that change the state of
0662  * the hardware are processed here. If action can not be performed in
0663  * interrupt context it is offloaded to atkbd_event_work.
0664  */
0665 
0666 static int atkbd_event(struct input_dev *dev,
0667             unsigned int type, unsigned int code, int value)
0668 {
0669     struct atkbd *atkbd = input_get_drvdata(dev);
0670 
0671     if (!atkbd->write)
0672         return -1;
0673 
0674     switch (type) {
0675 
0676     case EV_LED:
0677         atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
0678         return 0;
0679 
0680     case EV_REP:
0681         if (!atkbd->softrepeat)
0682             atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
0683         return 0;
0684 
0685     default:
0686         return -1;
0687     }
0688 }
0689 
0690 /*
0691  * atkbd_enable() signals that interrupt handler is allowed to
0692  * generate input events.
0693  */
0694 
0695 static inline void atkbd_enable(struct atkbd *atkbd)
0696 {
0697     serio_pause_rx(atkbd->ps2dev.serio);
0698     atkbd->enabled = true;
0699     serio_continue_rx(atkbd->ps2dev.serio);
0700 }
0701 
0702 /*
0703  * atkbd_disable() tells input handler that all incoming data except
0704  * for ACKs and command response should be dropped.
0705  */
0706 
0707 static inline void atkbd_disable(struct atkbd *atkbd)
0708 {
0709     serio_pause_rx(atkbd->ps2dev.serio);
0710     atkbd->enabled = false;
0711     serio_continue_rx(atkbd->ps2dev.serio);
0712 }
0713 
0714 static int atkbd_activate(struct atkbd *atkbd)
0715 {
0716     struct ps2dev *ps2dev = &atkbd->ps2dev;
0717 
0718 /*
0719  * Enable the keyboard to receive keystrokes.
0720  */
0721 
0722     if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
0723         dev_err(&ps2dev->serio->dev,
0724             "Failed to enable keyboard on %s\n",
0725             ps2dev->serio->phys);
0726         return -1;
0727     }
0728 
0729     return 0;
0730 }
0731 
0732 /*
0733  * atkbd_deactivate() resets and disables the keyboard from sending
0734  * keystrokes.
0735  */
0736 
0737 static void atkbd_deactivate(struct atkbd *atkbd)
0738 {
0739     struct ps2dev *ps2dev = &atkbd->ps2dev;
0740 
0741     if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS))
0742         dev_err(&ps2dev->serio->dev,
0743             "Failed to deactivate keyboard on %s\n",
0744             ps2dev->serio->phys);
0745 }
0746 
0747 /*
0748  * atkbd_probe() probes for an AT keyboard on a serio port.
0749  */
0750 
0751 static int atkbd_probe(struct atkbd *atkbd)
0752 {
0753     struct ps2dev *ps2dev = &atkbd->ps2dev;
0754     unsigned char param[2];
0755 
0756 /*
0757  * Some systems, where the bit-twiddling when testing the io-lines of the
0758  * controller may confuse the keyboard need a full reset of the keyboard. On
0759  * these systems the BIOS also usually doesn't do it for us.
0760  */
0761 
0762     if (atkbd_reset)
0763         if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
0764             dev_warn(&ps2dev->serio->dev,
0765                  "keyboard reset failed on %s\n",
0766                  ps2dev->serio->phys);
0767 
0768 /*
0769  * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
0770  * Some keyboards report different values, but the first byte is always 0xab or
0771  * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
0772  * should make sure we don't try to set the LEDs on it.
0773  */
0774 
0775     param[0] = param[1] = 0xa5; /* initialize with invalid values */
0776     if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
0777 
0778 /*
0779  * If the get ID command failed, we check if we can at least set the LEDs on
0780  * the keyboard. This should work on every keyboard out there. It also turns
0781  * the LEDs off, which we want anyway.
0782  */
0783         param[0] = 0;
0784         if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
0785             return -1;
0786         atkbd->id = 0xabba;
0787         return 0;
0788     }
0789 
0790     if (!ps2_is_keyboard_id(param[0]))
0791         return -1;
0792 
0793     atkbd->id = (param[0] << 8) | param[1];
0794 
0795     if (atkbd->id == 0xaca1 && atkbd->translated) {
0796         dev_err(&ps2dev->serio->dev,
0797             "NCD terminal keyboards are only supported on non-translating controllers. "
0798             "Use i8042.direct=1 to disable translation.\n");
0799         return -1;
0800     }
0801 
0802 /*
0803  * Make sure nothing is coming from the keyboard and disturbs our
0804  * internal state.
0805  */
0806     if (!atkbd_skip_deactivate)
0807         atkbd_deactivate(atkbd);
0808 
0809     return 0;
0810 }
0811 
0812 /*
0813  * atkbd_select_set checks if a keyboard has a working Set 3 support, and
0814  * sets it into that. Unfortunately there are keyboards that can be switched
0815  * to Set 3, but don't work well in that (BTC Multimedia ...)
0816  */
0817 
0818 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
0819 {
0820     struct ps2dev *ps2dev = &atkbd->ps2dev;
0821     unsigned char param[2];
0822 
0823     atkbd->extra = false;
0824 /*
0825  * For known special keyboards we can go ahead and set the correct set.
0826  * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
0827  * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
0828  */
0829 
0830     if (atkbd->translated)
0831         return 2;
0832 
0833     if (atkbd->id == 0xaca1) {
0834         param[0] = 3;
0835         ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
0836         return 3;
0837     }
0838 
0839     if (allow_extra) {
0840         param[0] = 0x71;
0841         if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
0842             atkbd->extra = true;
0843             return 2;
0844         }
0845     }
0846 
0847     if (atkbd_terminal) {
0848         ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
0849         return 3;
0850     }
0851 
0852     if (target_set != 3)
0853         return 2;
0854 
0855     if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
0856         atkbd->id = param[0] << 8 | param[1];
0857         return 2;
0858     }
0859 
0860     param[0] = 3;
0861     if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
0862         return 2;
0863 
0864     param[0] = 0;
0865     if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
0866         return 2;
0867 
0868     if (param[0] != 3) {
0869         param[0] = 2;
0870         if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
0871             return 2;
0872     }
0873 
0874     ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
0875 
0876     return 3;
0877 }
0878 
0879 static int atkbd_reset_state(struct atkbd *atkbd)
0880 {
0881         struct ps2dev *ps2dev = &atkbd->ps2dev;
0882     unsigned char param[1];
0883 
0884 /*
0885  * Set the LEDs to a predefined state (all off).
0886  */
0887 
0888     param[0] = 0;
0889     if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
0890         return -1;
0891 
0892 /*
0893  * Set autorepeat to fastest possible.
0894  */
0895 
0896     param[0] = 0;
0897     if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
0898         return -1;
0899 
0900     return 0;
0901 }
0902 
0903 /*
0904  * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
0905  * reboot.
0906  */
0907 
0908 static void atkbd_cleanup(struct serio *serio)
0909 {
0910     struct atkbd *atkbd = serio_get_drvdata(serio);
0911 
0912     atkbd_disable(atkbd);
0913     ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
0914 }
0915 
0916 
0917 /*
0918  * atkbd_disconnect() closes and frees.
0919  */
0920 
0921 static void atkbd_disconnect(struct serio *serio)
0922 {
0923     struct atkbd *atkbd = serio_get_drvdata(serio);
0924 
0925     sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
0926 
0927     atkbd_disable(atkbd);
0928 
0929     input_unregister_device(atkbd->dev);
0930 
0931     /*
0932      * Make sure we don't have a command in flight.
0933      * Note that since atkbd->enabled is false event work will keep
0934      * rescheduling itself until it gets canceled and will not try
0935      * accessing freed input device or serio port.
0936      */
0937     cancel_delayed_work_sync(&atkbd->event_work);
0938 
0939     serio_close(serio);
0940     serio_set_drvdata(serio, NULL);
0941     kfree(atkbd);
0942 }
0943 
0944 /*
0945  * generate release events for the keycodes given in data
0946  */
0947 static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
0948                         const void *data)
0949 {
0950     const unsigned int *keys = data;
0951     unsigned int i;
0952 
0953     if (atkbd->set == 2)
0954         for (i = 0; keys[i] != -1U; i++)
0955             __set_bit(keys[i], atkbd->force_release_mask);
0956 }
0957 
0958 /*
0959  * Most special keys (Fn+F?) on Dell laptops do not generate release
0960  * events so we have to do it ourselves.
0961  */
0962 static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
0963     0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
0964 };
0965 
0966 /*
0967  * Perform fixup for HP system that doesn't generate release
0968  * for its video switch
0969  */
0970 static unsigned int atkbd_hp_forced_release_keys[] = {
0971     0x94, -1U
0972 };
0973 
0974 /*
0975  * Samsung NC10,NC20 with Fn+F? key release not working
0976  */
0977 static unsigned int atkbd_samsung_forced_release_keys[] = {
0978     0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
0979 };
0980 
0981 /*
0982  * Amilo Pi 3525 key release for Fn+Volume keys not working
0983  */
0984 static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
0985     0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
0986 };
0987 
0988 /*
0989  * Amilo Xi 3650 key release for light touch bar not working
0990  */
0991 static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
0992     0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
0993 };
0994 
0995 /*
0996  * Soltech TA12 system with broken key release on volume keys and mute key
0997  */
0998 static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
0999     0xa0, 0xae, 0xb0, -1U
1000 };
1001 
1002 /*
1003  * Many notebooks don't send key release event for volume up/down
1004  * keys, with key list below common among them
1005  */
1006 static unsigned int atkbd_volume_forced_release_keys[] = {
1007     0xae, 0xb0, -1U
1008 };
1009 
1010 /*
1011  * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
1012  * they should be generating e4-e6 (0x80 | code).
1013  */
1014 static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
1015                             unsigned int code)
1016 {
1017     if (atkbd->translated && atkbd->emul == 1 &&
1018         (code == 0x64 || code == 0x65 || code == 0x66)) {
1019         atkbd->emul = 0;
1020         code |= 0x80;
1021     }
1022 
1023     return code;
1024 }
1025 
1026 static int atkbd_get_keymap_from_fwnode(struct atkbd *atkbd)
1027 {
1028     struct device *dev = &atkbd->ps2dev.serio->dev;
1029     int i, n;
1030     u32 *ptr;
1031     u16 scancode, keycode;
1032 
1033     /* Parse "linux,keymap" property */
1034     n = device_property_count_u32(dev, "linux,keymap");
1035     if (n <= 0 || n > ATKBD_KEYMAP_SIZE)
1036         return -ENXIO;
1037 
1038     ptr = kcalloc(n, sizeof(u32), GFP_KERNEL);
1039     if (!ptr)
1040         return -ENOMEM;
1041 
1042     if (device_property_read_u32_array(dev, "linux,keymap", ptr, n)) {
1043         dev_err(dev, "problem parsing FW keymap property\n");
1044         kfree(ptr);
1045         return -EINVAL;
1046     }
1047 
1048     memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1049     for (i = 0; i < n; i++) {
1050         scancode = SCANCODE(ptr[i]);
1051         keycode = KEYCODE(ptr[i]);
1052         atkbd->keycode[scancode] = keycode;
1053     }
1054 
1055     kfree(ptr);
1056     return 0;
1057 }
1058 
1059 /*
1060  * atkbd_set_keycode_table() initializes keyboard's keycode table
1061  * according to the selected scancode set
1062  */
1063 
1064 static void atkbd_set_keycode_table(struct atkbd *atkbd)
1065 {
1066     struct device *dev = &atkbd->ps2dev.serio->dev;
1067     unsigned int scancode;
1068     int i, j;
1069 
1070     memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1071     bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1072 
1073     if (!atkbd_get_keymap_from_fwnode(atkbd)) {
1074         dev_dbg(dev, "Using FW keymap\n");
1075     } else if (atkbd->translated) {
1076         for (i = 0; i < 128; i++) {
1077             scancode = atkbd_unxlate_table[i];
1078             atkbd->keycode[i] = atkbd_set2_keycode[scancode];
1079             atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
1080             if (atkbd->scroll)
1081                 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
1082                     if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
1083                         atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
1084         }
1085     } else if (atkbd->set == 3) {
1086         memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
1087     } else {
1088         memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
1089 
1090         if (atkbd->scroll)
1091             for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
1092                 scancode = atkbd_scroll_keys[i].set2;
1093                 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
1094         }
1095     }
1096 
1097 /*
1098  * HANGEUL and HANJA keys do not send release events so we need to
1099  * generate such events ourselves
1100  */
1101     scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
1102     atkbd->keycode[scancode] = KEY_HANGEUL;
1103     __set_bit(scancode, atkbd->force_release_mask);
1104 
1105     scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1106     atkbd->keycode[scancode] = KEY_HANJA;
1107     __set_bit(scancode, atkbd->force_release_mask);
1108 
1109 /*
1110  * Perform additional fixups
1111  */
1112     if (atkbd_platform_fixup)
1113         atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1114 }
1115 
1116 /*
1117  * atkbd_set_device_attrs() sets up keyboard's input device structure
1118  */
1119 
1120 static void atkbd_set_device_attrs(struct atkbd *atkbd)
1121 {
1122     struct input_dev *input_dev = atkbd->dev;
1123     int i;
1124 
1125     if (atkbd->extra)
1126         snprintf(atkbd->name, sizeof(atkbd->name),
1127              "AT Set 2 Extra keyboard");
1128     else
1129         snprintf(atkbd->name, sizeof(atkbd->name),
1130              "AT %s Set %d keyboard",
1131              atkbd->translated ? "Translated" : "Raw", atkbd->set);
1132 
1133     snprintf(atkbd->phys, sizeof(atkbd->phys),
1134          "%s/input0", atkbd->ps2dev.serio->phys);
1135 
1136     input_dev->name = atkbd->name;
1137     input_dev->phys = atkbd->phys;
1138     input_dev->id.bustype = BUS_I8042;
1139     input_dev->id.vendor = 0x0001;
1140     input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1141     input_dev->id.version = atkbd->id;
1142     input_dev->event = atkbd_event;
1143     input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1144 
1145     input_set_drvdata(input_dev, atkbd);
1146 
1147     input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1148         BIT_MASK(EV_MSC);
1149 
1150     if (atkbd->write) {
1151         input_dev->evbit[0] |= BIT_MASK(EV_LED);
1152         input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1153             BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1154     }
1155 
1156     if (atkbd->extra)
1157         input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1158             BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1159             BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1160 
1161     if (!atkbd->softrepeat) {
1162         input_dev->rep[REP_DELAY] = 250;
1163         input_dev->rep[REP_PERIOD] = 33;
1164     }
1165 
1166     input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1167         BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1168 
1169     if (atkbd->scroll) {
1170         input_dev->evbit[0] |= BIT_MASK(EV_REL);
1171         input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1172             BIT_MASK(REL_HWHEEL);
1173         __set_bit(BTN_MIDDLE, input_dev->keybit);
1174     }
1175 
1176     input_dev->keycode = atkbd->keycode;
1177     input_dev->keycodesize = sizeof(unsigned short);
1178     input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1179 
1180     for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
1181         if (atkbd->keycode[i] != KEY_RESERVED &&
1182             atkbd->keycode[i] != ATKBD_KEY_NULL &&
1183             atkbd->keycode[i] < ATKBD_SPECIAL) {
1184             __set_bit(atkbd->keycode[i], input_dev->keybit);
1185         }
1186     }
1187 }
1188 
1189 static void atkbd_parse_fwnode_data(struct serio *serio)
1190 {
1191     struct atkbd *atkbd = serio_get_drvdata(serio);
1192     struct device *dev = &serio->dev;
1193     int n;
1194 
1195     /* Parse "function-row-physmap" property */
1196     n = device_property_count_u32(dev, "function-row-physmap");
1197     if (n > 0 && n <= VIVALDI_MAX_FUNCTION_ROW_KEYS &&
1198         !device_property_read_u32_array(dev, "function-row-physmap",
1199                         atkbd->vdata.function_row_physmap,
1200                         n)) {
1201         atkbd->vdata.num_function_row_keys = n;
1202         dev_dbg(dev, "FW reported %d function-row key locations\n", n);
1203     }
1204 }
1205 
1206 /*
1207  * atkbd_connect() is called when the serio module finds an interface
1208  * that isn't handled yet by an appropriate device driver. We check if
1209  * there is an AT keyboard out there and if yes, we register ourselves
1210  * to the input module.
1211  */
1212 
1213 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1214 {
1215     struct atkbd *atkbd;
1216     struct input_dev *dev;
1217     int err = -ENOMEM;
1218 
1219     atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1220     dev = input_allocate_device();
1221     if (!atkbd || !dev)
1222         goto fail1;
1223 
1224     atkbd->dev = dev;
1225     ps2_init(&atkbd->ps2dev, serio);
1226     INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1227     mutex_init(&atkbd->mutex);
1228 
1229     switch (serio->id.type) {
1230 
1231     case SERIO_8042_XL:
1232         atkbd->translated = true;
1233         fallthrough;
1234 
1235     case SERIO_8042:
1236         if (serio->write)
1237             atkbd->write = true;
1238         break;
1239     }
1240 
1241     atkbd->softraw = atkbd_softraw;
1242     atkbd->softrepeat = atkbd_softrepeat;
1243     atkbd->scroll = atkbd_scroll;
1244 
1245     if (atkbd->softrepeat)
1246         atkbd->softraw = true;
1247 
1248     serio_set_drvdata(serio, atkbd);
1249 
1250     err = serio_open(serio, drv);
1251     if (err)
1252         goto fail2;
1253 
1254     if (atkbd->write) {
1255 
1256         if (atkbd_probe(atkbd)) {
1257             err = -ENODEV;
1258             goto fail3;
1259         }
1260 
1261         atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1262         atkbd_reset_state(atkbd);
1263 
1264     } else {
1265         atkbd->set = 2;
1266         atkbd->id = 0xab00;
1267     }
1268 
1269     atkbd_parse_fwnode_data(serio);
1270 
1271     atkbd_set_keycode_table(atkbd);
1272     atkbd_set_device_attrs(atkbd);
1273 
1274     err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1275     if (err)
1276         goto fail3;
1277 
1278     atkbd_enable(atkbd);
1279     if (serio->write)
1280         atkbd_activate(atkbd);
1281 
1282     err = input_register_device(atkbd->dev);
1283     if (err)
1284         goto fail4;
1285 
1286     return 0;
1287 
1288  fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1289  fail3: serio_close(serio);
1290  fail2: serio_set_drvdata(serio, NULL);
1291  fail1: input_free_device(dev);
1292     kfree(atkbd);
1293     return err;
1294 }
1295 
1296 /*
1297  * atkbd_reconnect() tries to restore keyboard into a sane state and is
1298  * most likely called on resume.
1299  */
1300 
1301 static int atkbd_reconnect(struct serio *serio)
1302 {
1303     struct atkbd *atkbd = serio_get_drvdata(serio);
1304     struct serio_driver *drv = serio->drv;
1305     int retval = -1;
1306 
1307     if (!atkbd || !drv) {
1308         dev_dbg(&serio->dev,
1309             "reconnect request, but serio is disconnected, ignoring...\n");
1310         return -1;
1311     }
1312 
1313     mutex_lock(&atkbd->mutex);
1314 
1315     atkbd_disable(atkbd);
1316 
1317     if (atkbd->write) {
1318         if (atkbd_probe(atkbd))
1319             goto out;
1320 
1321         if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1322             goto out;
1323 
1324         /*
1325          * Restore LED state and repeat rate. While input core
1326          * will do this for us at resume time reconnect may happen
1327          * because user requested it via sysfs or simply because
1328          * keyboard was unplugged and plugged in again so we need
1329          * to do it ourselves here.
1330          */
1331         atkbd_set_leds(atkbd);
1332         if (!atkbd->softrepeat)
1333             atkbd_set_repeat_rate(atkbd);
1334 
1335     }
1336 
1337     /*
1338      * Reset our state machine in case reconnect happened in the middle
1339      * of multi-byte scancode.
1340      */
1341     atkbd->xl_bit = 0;
1342     atkbd->emul = 0;
1343 
1344     atkbd_enable(atkbd);
1345     if (atkbd->write)
1346         atkbd_activate(atkbd);
1347 
1348     retval = 0;
1349 
1350  out:
1351     mutex_unlock(&atkbd->mutex);
1352     return retval;
1353 }
1354 
1355 static const struct serio_device_id atkbd_serio_ids[] = {
1356     {
1357         .type   = SERIO_8042,
1358         .proto  = SERIO_ANY,
1359         .id = SERIO_ANY,
1360         .extra  = SERIO_ANY,
1361     },
1362     {
1363         .type   = SERIO_8042_XL,
1364         .proto  = SERIO_ANY,
1365         .id = SERIO_ANY,
1366         .extra  = SERIO_ANY,
1367     },
1368     {
1369         .type   = SERIO_RS232,
1370         .proto  = SERIO_PS2SER,
1371         .id = SERIO_ANY,
1372         .extra  = SERIO_ANY,
1373     },
1374     { 0 }
1375 };
1376 
1377 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1378 
1379 static struct serio_driver atkbd_drv = {
1380     .driver     = {
1381         .name   = "atkbd",
1382     },
1383     .description    = DRIVER_DESC,
1384     .id_table   = atkbd_serio_ids,
1385     .interrupt  = atkbd_interrupt,
1386     .connect    = atkbd_connect,
1387     .reconnect  = atkbd_reconnect,
1388     .disconnect = atkbd_disconnect,
1389     .cleanup    = atkbd_cleanup,
1390 };
1391 
1392 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1393                 ssize_t (*handler)(struct atkbd *, char *))
1394 {
1395     struct serio *serio = to_serio_port(dev);
1396     struct atkbd *atkbd = serio_get_drvdata(serio);
1397 
1398     return handler(atkbd, buf);
1399 }
1400 
1401 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1402                 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1403 {
1404     struct serio *serio = to_serio_port(dev);
1405     struct atkbd *atkbd = serio_get_drvdata(serio);
1406     int retval;
1407 
1408     retval = mutex_lock_interruptible(&atkbd->mutex);
1409     if (retval)
1410         return retval;
1411 
1412     atkbd_disable(atkbd);
1413     retval = handler(atkbd, buf, count);
1414     atkbd_enable(atkbd);
1415 
1416     mutex_unlock(&atkbd->mutex);
1417 
1418     return retval;
1419 }
1420 
1421 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1422 {
1423     return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1424 }
1425 
1426 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1427 {
1428     struct input_dev *old_dev, *new_dev;
1429     unsigned int value;
1430     int err;
1431     bool old_extra;
1432     unsigned char old_set;
1433 
1434     if (!atkbd->write)
1435         return -EIO;
1436 
1437     err = kstrtouint(buf, 10, &value);
1438     if (err)
1439         return err;
1440 
1441     if (value > 1)
1442         return -EINVAL;
1443 
1444     if (atkbd->extra != value) {
1445         /*
1446          * Since device's properties will change we need to
1447          * unregister old device. But allocate and register
1448          * new one first to make sure we have it.
1449          */
1450         old_dev = atkbd->dev;
1451         old_extra = atkbd->extra;
1452         old_set = atkbd->set;
1453 
1454         new_dev = input_allocate_device();
1455         if (!new_dev)
1456             return -ENOMEM;
1457 
1458         atkbd->dev = new_dev;
1459         atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1460         atkbd_reset_state(atkbd);
1461         atkbd_activate(atkbd);
1462         atkbd_set_keycode_table(atkbd);
1463         atkbd_set_device_attrs(atkbd);
1464 
1465         err = input_register_device(atkbd->dev);
1466         if (err) {
1467             input_free_device(new_dev);
1468 
1469             atkbd->dev = old_dev;
1470             atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1471             atkbd_set_keycode_table(atkbd);
1472             atkbd_set_device_attrs(atkbd);
1473 
1474             return err;
1475         }
1476         input_unregister_device(old_dev);
1477 
1478     }
1479     return count;
1480 }
1481 
1482 static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1483 {
1484     size_t len = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
1485                    ATKBD_KEYMAP_SIZE, atkbd->force_release_mask);
1486 
1487     buf[len++] = '\n';
1488     buf[len] = '\0';
1489 
1490     return len;
1491 }
1492 
1493 static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1494                     const char *buf, size_t count)
1495 {
1496     /* 64 bytes on stack should be acceptable */
1497     DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1498     int err;
1499 
1500     err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1501     if (err)
1502         return err;
1503 
1504     memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1505     return count;
1506 }
1507 
1508 
1509 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1510 {
1511     return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1512 }
1513 
1514 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1515 {
1516     struct input_dev *old_dev, *new_dev;
1517     unsigned int value;
1518     int err;
1519     bool old_scroll;
1520 
1521     err = kstrtouint(buf, 10, &value);
1522     if (err)
1523         return err;
1524 
1525     if (value > 1)
1526         return -EINVAL;
1527 
1528     if (atkbd->scroll != value) {
1529         old_dev = atkbd->dev;
1530         old_scroll = atkbd->scroll;
1531 
1532         new_dev = input_allocate_device();
1533         if (!new_dev)
1534             return -ENOMEM;
1535 
1536         atkbd->dev = new_dev;
1537         atkbd->scroll = value;
1538         atkbd_set_keycode_table(atkbd);
1539         atkbd_set_device_attrs(atkbd);
1540 
1541         err = input_register_device(atkbd->dev);
1542         if (err) {
1543             input_free_device(new_dev);
1544 
1545             atkbd->scroll = old_scroll;
1546             atkbd->dev = old_dev;
1547             atkbd_set_keycode_table(atkbd);
1548             atkbd_set_device_attrs(atkbd);
1549 
1550             return err;
1551         }
1552         input_unregister_device(old_dev);
1553     }
1554     return count;
1555 }
1556 
1557 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1558 {
1559     return sprintf(buf, "%d\n", atkbd->set);
1560 }
1561 
1562 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1563 {
1564     struct input_dev *old_dev, *new_dev;
1565     unsigned int value;
1566     int err;
1567     unsigned char old_set;
1568     bool old_extra;
1569 
1570     if (!atkbd->write)
1571         return -EIO;
1572 
1573     err = kstrtouint(buf, 10, &value);
1574     if (err)
1575         return err;
1576 
1577     if (value != 2 && value != 3)
1578         return -EINVAL;
1579 
1580     if (atkbd->set != value) {
1581         old_dev = atkbd->dev;
1582         old_extra = atkbd->extra;
1583         old_set = atkbd->set;
1584 
1585         new_dev = input_allocate_device();
1586         if (!new_dev)
1587             return -ENOMEM;
1588 
1589         atkbd->dev = new_dev;
1590         atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1591         atkbd_reset_state(atkbd);
1592         atkbd_activate(atkbd);
1593         atkbd_set_keycode_table(atkbd);
1594         atkbd_set_device_attrs(atkbd);
1595 
1596         err = input_register_device(atkbd->dev);
1597         if (err) {
1598             input_free_device(new_dev);
1599 
1600             atkbd->dev = old_dev;
1601             atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1602             atkbd_set_keycode_table(atkbd);
1603             atkbd_set_device_attrs(atkbd);
1604 
1605             return err;
1606         }
1607         input_unregister_device(old_dev);
1608     }
1609     return count;
1610 }
1611 
1612 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1613 {
1614     return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1615 }
1616 
1617 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1618 {
1619     struct input_dev *old_dev, *new_dev;
1620     unsigned int value;
1621     int err;
1622     bool old_softrepeat, old_softraw;
1623 
1624     if (!atkbd->write)
1625         return -EIO;
1626 
1627     err = kstrtouint(buf, 10, &value);
1628     if (err)
1629         return err;
1630 
1631     if (value > 1)
1632         return -EINVAL;
1633 
1634     if (atkbd->softrepeat != value) {
1635         old_dev = atkbd->dev;
1636         old_softrepeat = atkbd->softrepeat;
1637         old_softraw = atkbd->softraw;
1638 
1639         new_dev = input_allocate_device();
1640         if (!new_dev)
1641             return -ENOMEM;
1642 
1643         atkbd->dev = new_dev;
1644         atkbd->softrepeat = value;
1645         if (atkbd->softrepeat)
1646             atkbd->softraw = true;
1647         atkbd_set_device_attrs(atkbd);
1648 
1649         err = input_register_device(atkbd->dev);
1650         if (err) {
1651             input_free_device(new_dev);
1652 
1653             atkbd->dev = old_dev;
1654             atkbd->softrepeat = old_softrepeat;
1655             atkbd->softraw = old_softraw;
1656             atkbd_set_device_attrs(atkbd);
1657 
1658             return err;
1659         }
1660         input_unregister_device(old_dev);
1661     }
1662     return count;
1663 }
1664 
1665 
1666 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1667 {
1668     return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1669 }
1670 
1671 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1672 {
1673     struct input_dev *old_dev, *new_dev;
1674     unsigned int value;
1675     int err;
1676     bool old_softraw;
1677 
1678     err = kstrtouint(buf, 10, &value);
1679     if (err)
1680         return err;
1681 
1682     if (value > 1)
1683         return -EINVAL;
1684 
1685     if (atkbd->softraw != value) {
1686         old_dev = atkbd->dev;
1687         old_softraw = atkbd->softraw;
1688 
1689         new_dev = input_allocate_device();
1690         if (!new_dev)
1691             return -ENOMEM;
1692 
1693         atkbd->dev = new_dev;
1694         atkbd->softraw = value;
1695         atkbd_set_device_attrs(atkbd);
1696 
1697         err = input_register_device(atkbd->dev);
1698         if (err) {
1699             input_free_device(new_dev);
1700 
1701             atkbd->dev = old_dev;
1702             atkbd->softraw = old_softraw;
1703             atkbd_set_device_attrs(atkbd);
1704 
1705             return err;
1706         }
1707         input_unregister_device(old_dev);
1708     }
1709     return count;
1710 }
1711 
1712 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1713 {
1714     return sprintf(buf, "%lu\n", atkbd->err_count);
1715 }
1716 
1717 static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1718 {
1719     atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1720     atkbd_platform_fixup_data = id->driver_data;
1721 
1722     return 1;
1723 }
1724 
1725 static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1726 {
1727     atkbd_platform_scancode_fixup = id->driver_data;
1728 
1729     return 1;
1730 }
1731 
1732 static int __init atkbd_deactivate_fixup(const struct dmi_system_id *id)
1733 {
1734     atkbd_skip_deactivate = true;
1735     return 1;
1736 }
1737 
1738 /*
1739  * NOTE: do not add any more "force release" quirks to this table.  The
1740  * task of adjusting list of keys that should be "released" automatically
1741  * by the driver is now delegated to userspace tools, such as udev, so
1742  * submit such quirks there.
1743  */
1744 static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1745     {
1746         .matches = {
1747             DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1748             DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1749         },
1750         .callback = atkbd_setup_forced_release,
1751         .driver_data = atkbd_dell_laptop_forced_release_keys,
1752     },
1753     {
1754         .matches = {
1755             DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1756             DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1757         },
1758         .callback = atkbd_setup_forced_release,
1759         .driver_data = atkbd_dell_laptop_forced_release_keys,
1760     },
1761     {
1762         .matches = {
1763             DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1764             DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1765         },
1766         .callback = atkbd_setup_forced_release,
1767         .driver_data = atkbd_hp_forced_release_keys,
1768     },
1769     {
1770         .matches = {
1771             DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1772             DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1773         },
1774         .callback = atkbd_setup_forced_release,
1775         .driver_data = atkbd_volume_forced_release_keys,
1776     },
1777     {
1778         .matches = {
1779             DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1780             DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1781         },
1782         .callback = atkbd_setup_forced_release,
1783         .driver_data = atkbd_volume_forced_release_keys,
1784     },
1785     {
1786         .matches = {
1787             DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1788             DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1789         },
1790         .callback = atkbd_setup_forced_release,
1791         .driver_data = atkbd_volume_forced_release_keys,
1792     },
1793     {
1794         .matches = {
1795             DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1796             DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1797         },
1798         .callback = atkbd_setup_forced_release,
1799         .driver_data = atkbd_volume_forced_release_keys,
1800     },
1801     {
1802         /* Inventec Symphony */
1803         .matches = {
1804             DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1805             DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1806         },
1807         .callback = atkbd_setup_forced_release,
1808         .driver_data = atkbd_volume_forced_release_keys,
1809     },
1810     {
1811         /* Samsung NC10 */
1812         .matches = {
1813             DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1814             DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1815         },
1816         .callback = atkbd_setup_forced_release,
1817         .driver_data = atkbd_samsung_forced_release_keys,
1818     },
1819     {
1820         /* Samsung NC20 */
1821         .matches = {
1822             DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1823             DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1824         },
1825         .callback = atkbd_setup_forced_release,
1826         .driver_data = atkbd_samsung_forced_release_keys,
1827     },
1828     {
1829         /* Samsung SQ45S70S */
1830         .matches = {
1831             DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1832             DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1833         },
1834         .callback = atkbd_setup_forced_release,
1835         .driver_data = atkbd_samsung_forced_release_keys,
1836     },
1837     {
1838         /* Fujitsu Amilo PA 1510 */
1839         .matches = {
1840             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1841             DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1842         },
1843         .callback = atkbd_setup_forced_release,
1844         .driver_data = atkbd_volume_forced_release_keys,
1845     },
1846     {
1847         /* Fujitsu Amilo Pi 3525 */
1848         .matches = {
1849             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1850             DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1851         },
1852         .callback = atkbd_setup_forced_release,
1853         .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1854     },
1855     {
1856         /* Fujitsu Amilo Xi 3650 */
1857         .matches = {
1858             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1859             DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1860         },
1861         .callback = atkbd_setup_forced_release,
1862         .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1863     },
1864     {
1865         .matches = {
1866             DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1867             DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1868         },
1869         .callback = atkbd_setup_forced_release,
1870         .driver_data = atkdb_soltech_ta12_forced_release_keys,
1871     },
1872     {
1873         /* OQO Model 01+ */
1874         .matches = {
1875             DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1876             DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1877         },
1878         .callback = atkbd_setup_scancode_fixup,
1879         .driver_data = atkbd_oqo_01plus_scancode_fixup,
1880     },
1881     {
1882         .matches = {
1883             DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),
1884         },
1885         .callback = atkbd_deactivate_fixup,
1886     },
1887     { }
1888 };
1889 
1890 static int __init atkbd_init(void)
1891 {
1892     dmi_check_system(atkbd_dmi_quirk_table);
1893 
1894     return serio_register_driver(&atkbd_drv);
1895 }
1896 
1897 static void __exit atkbd_exit(void)
1898 {
1899     serio_unregister_driver(&atkbd_drv);
1900 }
1901 
1902 module_init(atkbd_init);
1903 module_exit(atkbd_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!