Lines Matching +full:function +full:- +full:row +full:- +full:physmap
1 // SPDX-License-Identifier: GPL-2.0-only
5 * Copyright (c) 1999-2002 Vojtech Pavlik
12 * input-only controllers and AT keyboards connected over a one way RS232
22 #include <linux/input/vivaldi-fmap.h>
58 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
236 /* Serializes reconnect(), attr->set() and event work */
243 * System-specific keymap fixup routine
309 return vivaldi_function_row_physmap_show(&atkbd->vdata, buf);
327 !atkbd->vdata.num_function_row_keys)
330 return attr->mode;
375 __clear_bit(i, &atkbd->xl_bit);
377 __set_bit(i, &atkbd->xl_bit);
389 if (atkbd->set == 3) {
390 if (atkbd->emul == 1)
394 if (atkbd->emul == 1)
410 struct serio *serio = ps2dev->serio;
414 !atkbd->resend && atkbd->write) {
415 dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
417 atkbd->resend = true;
422 atkbd->resend = false;
430 struct serio *serio = ps2dev->serio;
432 dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
444 struct serio *serio = ps2dev->serio;
446 struct input_dev *dev = atkbd->dev;
448 int scroll = 0, hscroll = 0, click = -1;
452 pm_wakeup_event(&serio->dev, 0);
454 if (!atkbd->enabled)
462 if (atkbd->translated) {
464 if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
465 atkbd->release = code >> 7;
469 if (!atkbd->emul)
475 atkbd->enabled = false;
476 serio_reconnect(atkbd->ps2dev.serio);
479 atkbd->emul = 1;
482 atkbd->emul = 2;
485 atkbd->release = true;
490 dev_warn(&serio->dev,
493 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
496 atkbd->err_count++;
497 dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
498 serio->phys);
504 if (atkbd->emul && --atkbd->emul)
507 keycode = atkbd->keycode[code];
509 if (!(atkbd->release && test_bit(code, atkbd->force_release_mask)))
517 dev_warn(&serio->dev,
519 atkbd->release ? "released" : "pressed",
520 atkbd->translated ? "translated" : "raw",
521 atkbd->set, code, serio->phys);
522 dev_warn(&serio->dev,
540 click = !atkbd->release;
543 hscroll = -1;
549 if (atkbd->release) {
551 atkbd->last = 0;
552 } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
554 value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
557 atkbd->last = code;
558 atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
564 if (value && test_bit(code, atkbd->force_release_mask)) {
571 if (atkbd->scroll) {
572 if (click != -1)
575 atkbd->release ? -scroll : scroll);
580 atkbd->release = false;
591 struct input_dev *dev = atkbd->dev;
595 while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
597 dev->rep[REP_PERIOD] = period[i];
599 while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
601 dev->rep[REP_DELAY] = delay[j];
604 return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP);
609 struct input_dev *dev = atkbd->dev;
612 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
613 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
614 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
615 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
616 return -1;
618 if (atkbd->extra) {
620 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
621 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
622 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
623 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
624 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
625 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
626 return -1;
642 mutex_lock(&atkbd->mutex);
644 if (!atkbd->enabled) {
651 schedule_delayed_work(&atkbd->event_work,
654 if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
657 if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
661 mutex_unlock(&atkbd->mutex);
672 if (time_after(jiffies, atkbd->event_jiffies + delay))
675 atkbd->event_jiffies = jiffies;
676 set_bit(event_bit, &atkbd->event_mask);
678 schedule_delayed_work(&atkbd->event_work, delay);
692 if (!atkbd->write)
693 return -1;
702 if (!atkbd->softrepeat)
707 return -1;
718 serio_pause_rx(atkbd->ps2dev.serio);
719 atkbd->enabled = true;
720 serio_continue_rx(atkbd->ps2dev.serio);
730 serio_pause_rx(atkbd->ps2dev.serio);
731 atkbd->enabled = false;
732 serio_continue_rx(atkbd->ps2dev.serio);
737 struct ps2dev *ps2dev = &atkbd->ps2dev;
744 dev_err(&ps2dev->serio->dev,
746 ps2dev->serio->phys);
747 return -1;
760 struct ps2dev *ps2dev = &atkbd->ps2dev;
763 dev_err(&ps2dev->serio->dev,
765 ps2dev->serio->phys);
775 "14", /* Sub-Notebook */
795 * 0xab83 id is ok in translated mode, only atkbd_select_set() checks atkbd->id
796 * and in translated mode that is a no-op.
800 return atkbd->translated && atkbd_is_portable_device();
812 struct ps2dev *ps2dev = &atkbd->ps2dev;
816 * Some systems, where the bit-twiddling when testing the io-lines of the
823 dev_warn(&ps2dev->serio->dev,
825 ps2dev->serio->phys);
828 atkbd->id = 0xab83;
849 return -1;
850 atkbd->id = 0xabba;
855 return -1;
857 atkbd->id = (param[0] << 8) | param[1];
859 if (atkbd->id == 0xaca1 && atkbd->translated) {
860 dev_err(&ps2dev->serio->dev,
861 "NCD terminal keyboards are only supported on non-translating controllers. "
863 return -1;
884 struct ps2dev *ps2dev = &atkbd->ps2dev;
887 atkbd->extra = false;
891 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
894 if (atkbd->translated)
897 if (atkbd->id == 0xaca1) {
906 atkbd->extra = true;
920 atkbd->id = param[0] << 8 | param[1];
945 struct ps2dev *ps2dev = &atkbd->ps2dev;
954 return -1;
962 return -1;
977 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
991 input_unregister_device(atkbd->dev);
995 * Note that since atkbd->enabled is false event work will keep
999 cancel_delayed_work_sync(&atkbd->event_work);
1015 if (atkbd->set == 2)
1016 for (i = 0; keys[i] != -1U; i++)
1017 __set_bit(keys[i], atkbd->force_release_mask);
1025 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
1033 0x94, -1U
1040 0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
1047 0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
1054 0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
1061 0xa0, 0xae, 0xb0, -1U
1069 0xae, 0xb0, -1U
1073 * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
1074 * they should be generating e4-e6 (0x80 | code).
1079 if (atkbd->translated && atkbd->emul == 1 &&
1081 atkbd->emul = 0;
1090 struct device *dev = &atkbd->ps2dev.serio->dev;
1098 return -ENXIO;
1102 return -ENOMEM;
1107 return -EINVAL;
1110 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1114 atkbd->keycode[scancode] = keycode;
1128 struct device *dev = &atkbd->ps2dev.serio->dev;
1132 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1133 bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1137 } else if (atkbd->translated) {
1140 atkbd->keycode[i] = atkbd_set2_keycode[scancode];
1141 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
1142 if (atkbd->scroll)
1145 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
1147 } else if (atkbd->set == 3) {
1148 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
1150 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
1152 if (atkbd->scroll)
1155 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
1164 atkbd->keycode[scancode] = KEY_HANGEUL;
1165 __set_bit(scancode, atkbd->force_release_mask);
1168 atkbd->keycode[scancode] = KEY_HANJA;
1169 __set_bit(scancode, atkbd->force_release_mask);
1184 struct input_dev *input_dev = atkbd->dev;
1187 if (atkbd->extra)
1188 snprintf(atkbd->name, sizeof(atkbd->name),
1191 snprintf(atkbd->name, sizeof(atkbd->name),
1193 atkbd->translated ? "Translated" : "Raw", atkbd->set);
1195 snprintf(atkbd->phys, sizeof(atkbd->phys),
1196 "%s/input0", atkbd->ps2dev.serio->phys);
1198 input_dev->name = atkbd->name;
1199 input_dev->phys = atkbd->phys;
1200 input_dev->id.bustype = BUS_I8042;
1201 input_dev->id.vendor = 0x0001;
1202 input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1203 input_dev->id.version = atkbd->id;
1204 input_dev->event = atkbd_event;
1205 input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1209 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1212 if (atkbd->write) {
1213 input_dev->evbit[0] |= BIT_MASK(EV_LED);
1214 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1218 if (atkbd->extra)
1219 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1223 if (!atkbd->softrepeat) {
1224 input_dev->rep[REP_DELAY] = 250;
1225 input_dev->rep[REP_PERIOD] = 33;
1228 input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1231 if (atkbd->scroll) {
1232 input_dev->evbit[0] |= BIT_MASK(EV_REL);
1233 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1235 __set_bit(BTN_MIDDLE, input_dev->keybit);
1238 input_dev->keycode = atkbd->keycode;
1239 input_dev->keycodesize = sizeof(unsigned short);
1240 input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1243 if (atkbd->keycode[i] != KEY_RESERVED &&
1244 atkbd->keycode[i] != ATKBD_KEY_NULL &&
1245 atkbd->keycode[i] < ATKBD_SPECIAL) {
1246 __set_bit(atkbd->keycode[i], input_dev->keybit);
1254 struct device *dev = &serio->dev;
1257 /* Parse "function-row-physmap" property */
1258 n = device_property_count_u32(dev, "function-row-physmap");
1260 !device_property_read_u32_array(dev, "function-row-physmap",
1261 atkbd->vdata.function_row_physmap,
1263 atkbd->vdata.num_function_row_keys = n;
1264 dev_dbg(dev, "FW reported %d function-row key locations\n", n);
1279 int err = -ENOMEM;
1286 atkbd->dev = dev;
1287 ps2_init(&atkbd->ps2dev, serio,
1289 INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1290 mutex_init(&atkbd->mutex);
1292 switch (serio->id.type) {
1295 atkbd->translated = true;
1299 if (serio->write)
1300 atkbd->write = true;
1304 atkbd->softraw = atkbd_softraw;
1305 atkbd->softrepeat = atkbd_softrepeat;
1306 atkbd->scroll = atkbd_scroll;
1308 if (atkbd->softrepeat)
1309 atkbd->softraw = true;
1317 if (atkbd->write) {
1320 err = -ENODEV;
1324 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1328 atkbd->set = 2;
1329 atkbd->id = 0xab00;
1338 if (serio->write)
1341 err = input_register_device(atkbd->dev);
1362 struct serio_driver *drv = serio->drv;
1363 int retval = -1;
1366 dev_dbg(&serio->dev,
1368 return -1;
1371 mutex_lock(&atkbd->mutex);
1375 if (atkbd->write) {
1379 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1390 if (!atkbd->softrepeat)
1397 * of multi-byte scancode.
1399 atkbd->xl_bit = 0;
1400 atkbd->emul = 0;
1403 if (atkbd->write)
1409 mutex_unlock(&atkbd->mutex);
1467 retval = mutex_lock_interruptible(&atkbd->mutex);
1475 mutex_unlock(&atkbd->mutex);
1482 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1493 if (!atkbd->write)
1494 return -EIO;
1501 return -EINVAL;
1503 if (atkbd->extra != value) {
1509 old_dev = atkbd->dev;
1510 old_extra = atkbd->extra;
1511 old_set = atkbd->set;
1515 return -ENOMEM;
1517 atkbd->dev = new_dev;
1518 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1524 err = input_register_device(atkbd->dev);
1528 atkbd->dev = old_dev;
1529 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1543 size_t len = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
1544 ATKBD_KEYMAP_SIZE, atkbd->force_release_mask);
1563 memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1570 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1585 return -EINVAL;
1587 if (atkbd->scroll != value) {
1588 old_dev = atkbd->dev;
1589 old_scroll = atkbd->scroll;
1593 return -ENOMEM;
1595 atkbd->dev = new_dev;
1596 atkbd->scroll = value;
1600 err = input_register_device(atkbd->dev);
1604 atkbd->scroll = old_scroll;
1605 atkbd->dev = old_dev;
1618 return sprintf(buf, "%d\n", atkbd->set);
1629 if (!atkbd->write)
1630 return -EIO;
1637 return -EINVAL;
1639 if (atkbd->set != value) {
1640 old_dev = atkbd->dev;
1641 old_extra = atkbd->extra;
1642 old_set = atkbd->set;
1646 return -ENOMEM;
1648 atkbd->dev = new_dev;
1649 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1655 err = input_register_device(atkbd->dev);
1659 atkbd->dev = old_dev;
1660 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1673 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1683 if (!atkbd->write)
1684 return -EIO;
1691 return -EINVAL;
1693 if (atkbd->softrepeat != value) {
1694 old_dev = atkbd->dev;
1695 old_softrepeat = atkbd->softrepeat;
1696 old_softraw = atkbd->softraw;
1700 return -ENOMEM;
1702 atkbd->dev = new_dev;
1703 atkbd->softrepeat = value;
1704 if (atkbd->softrepeat)
1705 atkbd->softraw = true;
1708 err = input_register_device(atkbd->dev);
1712 atkbd->dev = old_dev;
1713 atkbd->softrepeat = old_softrepeat;
1714 atkbd->softraw = old_softraw;
1727 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1742 return -EINVAL;
1744 if (atkbd->softraw != value) {
1745 old_dev = atkbd->dev;
1746 old_softraw = atkbd->softraw;
1750 return -ENOMEM;
1752 atkbd->dev = new_dev;
1753 atkbd->softraw = value;
1756 err = input_register_device(atkbd->dev);
1760 atkbd->dev = old_dev;
1761 atkbd->softraw = old_softraw;
1773 return sprintf(buf, "%lu\n", atkbd->err_count);
1779 atkbd_platform_fixup_data = id->driver_data;
1786 atkbd_platform_scancode_fixup = id->driver_data;
1822 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1830 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1838 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1846 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1854 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),