1 #include <sys/cdefs.h> 2 /*- 3 * SPDX-License-Identifier: BSD-2-Clause 4 * 5 * Copyright (c) 1998 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Lennart Augustsson (lennart@augustsson.net) at 10 * Carlstedt Research & Technology. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 * 33 */ 34 35 /* 36 * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf 37 */ 38 39 #include "opt_hid.h" 40 #include "opt_kbd.h" 41 #include "opt_hkbd.h" 42 #include "opt_evdev.h" 43 44 #include <sys/stdint.h> 45 #include <sys/stddef.h> 46 #include <sys/param.h> 47 #include <sys/queue.h> 48 #include <sys/types.h> 49 #include <sys/systm.h> 50 #include <sys/kernel.h> 51 #include <sys/bus.h> 52 #include <sys/module.h> 53 #include <sys/lock.h> 54 #include <sys/mutex.h> 55 #include <sys/condvar.h> 56 #include <sys/sysctl.h> 57 #include <sys/sx.h> 58 #include <sys/unistd.h> 59 #include <sys/callout.h> 60 #include <sys/malloc.h> 61 #include <sys/priv.h> 62 #include <sys/proc.h> 63 #include <sys/kdb.h> 64 #include <sys/epoch.h> 65 #include <sys/taskqueue.h> 66 #include <sys/bitstring.h> 67 68 #include <machine/atomic.h> 69 70 #define HID_DEBUG_VAR hkbd_debug 71 #include <dev/hid/hid.h> 72 #include <dev/hid/hidbus.h> 73 #include <dev/hid/hidquirk.h> 74 #include <dev/hid/hidrdesc.h> 75 76 #include "usbdevs.h" 77 78 #ifdef EVDEV_SUPPORT 79 #include <dev/evdev/input.h> 80 #include <dev/evdev/evdev.h> 81 #endif 82 83 #include <sys/ioccom.h> 84 #include <sys/filio.h> 85 #include <sys/kbio.h> 86 87 #include <dev/kbd/kbdreg.h> 88 89 /* the initial key map, accent map and fkey strings */ 90 #if defined(HKBD_DFLT_KEYMAP) && !defined(KLD_MODULE) 91 #define KBD_DFLT_KEYMAP 92 #include "ukbdmap.h" 93 #endif 94 95 /* the following file must be included after "ukbdmap.h" */ 96 #include <dev/kbd/kbdtables.h> 97 98 #ifdef HID_DEBUG 99 static int hkbd_debug = 0; 100 #endif 101 static int hkbd_no_leds = 0; 102 static int hkbd_apple_fn_mode = 0; 103 static int hkbd_apple_swap_cmd_ctl = 0; 104 static int hkbd_apple_swap_cmd_opt = 0; 105 106 static SYSCTL_NODE(_hw_hid, OID_AUTO, hkbd, CTLFLAG_RW, 0, "USB keyboard"); 107 #ifdef HID_DEBUG 108 SYSCTL_INT(_hw_hid_hkbd, OID_AUTO, debug, CTLFLAG_RWTUN, 109 &hkbd_debug, 0, "Debug level"); 110 #endif 111 SYSCTL_INT(_hw_hid_hkbd, OID_AUTO, no_leds, CTLFLAG_RWTUN, 112 &hkbd_no_leds, 0, "Disables setting of keyboard leds"); 113 SYSCTL_INT(_hw_hid_hkbd, OID_AUTO, apple_fn_mode, CTLFLAG_RWTUN, 114 &hkbd_apple_fn_mode, 0, "0 = Fn + F1..12 -> media, 1 = F1..F12 -> media"); 115 SYSCTL_INT(_hw_hid_hkbd, OID_AUTO, apple_swap_cmd_ctl, CTLFLAG_RWTUN, 116 &hkbd_apple_swap_cmd_ctl, 0, "Swap Command & Control keys"); 117 SYSCTL_INT(_hw_hid_hkbd, OID_AUTO, apple_swap_cmd_opt, CTLFLAG_RWTUN, 118 &hkbd_apple_swap_cmd_opt, 0, "Swap Command & Option keys"); 119 120 #define INPUT_EPOCH global_epoch_preempt 121 122 #define HKBD_EMULATE_ATSCANCODE 1 123 #define HKBD_DRIVER_NAME "hkbd" 124 #define HKBD_NKEYCODE 256 /* units */ 125 #define HKBD_IN_BUF_SIZE (4 * HKBD_NKEYCODE) /* scancodes */ 126 #define HKBD_IN_BUF_FULL ((HKBD_IN_BUF_SIZE / 2) - 1) /* scancodes */ 127 #define HKBD_NFKEY (sizeof(fkey_tab)/sizeof(fkey_tab[0])) /* units */ 128 #define HKBD_BUFFER_SIZE 64 /* bytes */ 129 #define HKBD_KEY_PRESSED(map, key) ({ \ 130 CTASSERT((key) >= 0 && (key) < HKBD_NKEYCODE); \ 131 bit_test(map, key); \ 132 }) 133 134 #define MOD_EJECT 0x01 135 #define MOD_FN 0x02 136 137 #define MOD_MIN 0xe0 138 #define MOD_MAX 0xe7 139 140 /* check evdev_usb_scancodes[] for names */ 141 #define APPLE_FN_KEY 0xff 142 #define APPLE_EJECT_KEY 0xec 143 144 struct hkbd_softc { 145 device_t sc_dev; 146 147 keyboard_t sc_kbd; 148 keymap_t sc_keymap; 149 accentmap_t sc_accmap; 150 fkeytab_t sc_fkeymap[HKBD_NFKEY]; 151 bitstr_t bit_decl(sc_loc_key_valid, HKBD_NKEYCODE); 152 struct hid_location sc_loc_apple_eject; 153 struct hid_location sc_loc_apple_fn; 154 struct hid_location sc_loc_key[HKBD_NKEYCODE]; 155 struct hid_location sc_loc_numlock; 156 struct hid_location sc_loc_capslock; 157 struct hid_location sc_loc_scrolllock; 158 struct mtx sc_mtx; 159 struct task sc_task; 160 struct callout sc_callout; 161 /* All reported keycodes */ 162 bitstr_t bit_decl(sc_ndata, HKBD_NKEYCODE); 163 bitstr_t bit_decl(sc_odata, HKBD_NKEYCODE); 164 /* Keycodes reported in array fields only */ 165 bitstr_t bit_decl(sc_ndata0, HKBD_NKEYCODE); 166 bitstr_t bit_decl(sc_odata0, HKBD_NKEYCODE); 167 168 struct thread *sc_poll_thread; 169 #ifdef EVDEV_SUPPORT 170 struct evdev_dev *sc_evdev; 171 #endif 172 173 sbintime_t sc_co_basetime; 174 int sc_delay; 175 uint32_t sc_repeat_time; 176 uint32_t sc_input[HKBD_IN_BUF_SIZE]; /* input buffer */ 177 uint32_t sc_time_ms; 178 uint32_t sc_composed_char; /* composed char code, if non-zero */ 179 #ifdef HKBD_EMULATE_ATSCANCODE 180 uint32_t sc_buffered_char[2]; 181 #endif 182 uint32_t sc_flags; /* flags */ 183 #define HKBD_FLAG_COMPOSE 0x00000001 184 #define HKBD_FLAG_POLLING 0x00000002 185 #define HKBD_FLAG_ATTACHED 0x00000010 186 #define HKBD_FLAG_GONE 0x00000020 187 188 #define HKBD_FLAG_HID_MASK 0x003fffc0 189 #define HKBD_FLAG_APPLE_EJECT 0x00000040 190 #define HKBD_FLAG_APPLE_FN 0x00000080 191 #define HKBD_FLAG_APPLE_SWAP 0x00000100 192 #define HKBD_FLAG_NUMLOCK 0x00080000 193 #define HKBD_FLAG_CAPSLOCK 0x00100000 194 #define HKBD_FLAG_SCROLLLOCK 0x00200000 195 196 int sc_mode; /* input mode (K_XLATE,K_RAW,K_CODE) */ 197 int sc_state; /* shift/lock key state */ 198 int sc_accents; /* accent key index (> 0) */ 199 int sc_polling; /* polling recursion count */ 200 int sc_led_size; 201 int sc_kbd_size; 202 203 uint32_t sc_inputhead; 204 uint32_t sc_inputtail; 205 206 uint8_t sc_iface_index; 207 uint8_t sc_iface_no; 208 uint8_t sc_id_apple_eject; 209 uint8_t sc_id_apple_fn; 210 uint8_t sc_id_loc_key[HKBD_NKEYCODE]; 211 uint8_t sc_id_leds; 212 uint8_t sc_kbd_id; 213 uint8_t sc_repeat_key; 214 215 uint8_t sc_buffer[HKBD_BUFFER_SIZE]; 216 }; 217 218 #define KEY_NONE 0x00 219 #define KEY_ERROR 0x01 220 221 #define KEY_PRESS 0 222 #define KEY_RELEASE 0x400 223 #define KEY_INDEX(c) ((c) & 0xFF) 224 225 #define SCAN_PRESS 0 226 #define SCAN_RELEASE 0x80 227 #define SCAN_PREFIX_E0 0x100 228 #define SCAN_PREFIX_E1 0x200 229 #define SCAN_PREFIX_CTL 0x400 230 #define SCAN_PREFIX_SHIFT 0x800 231 #define SCAN_PREFIX (SCAN_PREFIX_E0 | SCAN_PREFIX_E1 | \ 232 SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT) 233 #define SCAN_CHAR(c) ((c) & 0x7f) 234 235 #define HKBD_LOCK(sc) do { \ 236 if (!HID_IN_POLLING_MODE()) \ 237 mtx_lock(&(sc)->sc_mtx); \ 238 } while (0) 239 #define HKBD_UNLOCK(sc) do { \ 240 if (!HID_IN_POLLING_MODE()) \ 241 mtx_unlock(&(sc)->sc_mtx); \ 242 } while (0) 243 #define HKBD_LOCK_ASSERT(sc) do { \ 244 if (!HID_IN_POLLING_MODE()) \ 245 mtx_assert(&(sc)->sc_mtx, MA_OWNED); \ 246 } while (0) 247 #define SYSCONS_LOCK() do { \ 248 if (!HID_IN_POLLING_MODE()) \ 249 mtx_lock(&Giant); \ 250 } while (0) 251 #define SYSCONS_UNLOCK() do { \ 252 if (!HID_IN_POLLING_MODE()) \ 253 mtx_unlock(&Giant); \ 254 } while (0) 255 #define SYSCONS_LOCK_ASSERT() do { \ 256 if (!HID_IN_POLLING_MODE()) \ 257 mtx_assert(&Giant, MA_OWNED); \ 258 } while (0) 259 260 #define NN 0 /* no translation */ 261 /* 262 * Translate USB keycodes to AT keyboard scancodes. 263 */ 264 /* 265 * FIXME: Mac USB keyboard generates: 266 * 0x53: keypad NumLock/Clear 267 * 0x66: Power 268 * 0x67: keypad = 269 * 0x68: F13 270 * 0x69: F14 271 * 0x6a: F15 272 * 273 * USB Apple Keyboard JIS generates: 274 * 0x90: Kana 275 * 0x91: Eisu 276 */ 277 static const uint8_t hkbd_trtab[256] = { 278 0, 0, 0, 0, 30, 48, 46, 32, /* 00 - 07 */ 279 18, 33, 34, 35, 23, 36, 37, 38, /* 08 - 0F */ 280 50, 49, 24, 25, 16, 19, 31, 20, /* 10 - 17 */ 281 22, 47, 17, 45, 21, 44, 2, 3, /* 18 - 1F */ 282 4, 5, 6, 7, 8, 9, 10, 11, /* 20 - 27 */ 283 28, 1, 14, 15, 57, 12, 13, 26, /* 28 - 2F */ 284 27, 43, 43, 39, 40, 41, 51, 52, /* 30 - 37 */ 285 53, 58, 59, 60, 61, 62, 63, 64, /* 38 - 3F */ 286 65, 66, 67, 68, 87, 88, 92, 70, /* 40 - 47 */ 287 104, 102, 94, 96, 103, 99, 101, 98, /* 48 - 4F */ 288 97, 100, 95, 69, 91, 55, 74, 78,/* 50 - 57 */ 289 89, 79, 80, 81, 75, 76, 77, 71, /* 58 - 5F */ 290 72, 73, 82, 83, 86, 107, 122, NN, /* 60 - 67 */ 291 NN, NN, NN, NN, NN, NN, NN, NN, /* 68 - 6F */ 292 NN, NN, NN, NN, 115, 108, 111, 113, /* 70 - 77 */ 293 109, 110, 112, 118, 114, 116, 117, 119, /* 78 - 7F */ 294 121, 120, NN, NN, NN, NN, NN, 123, /* 80 - 87 */ 295 124, 125, 126, 127, 128, NN, NN, NN, /* 88 - 8F */ 296 129, 130, NN, NN, NN, NN, NN, NN, /* 90 - 97 */ 297 NN, NN, NN, NN, NN, NN, NN, NN, /* 98 - 9F */ 298 NN, NN, NN, NN, NN, NN, NN, NN, /* A0 - A7 */ 299 NN, NN, NN, NN, NN, NN, NN, NN, /* A8 - AF */ 300 NN, NN, NN, NN, NN, NN, NN, NN, /* B0 - B7 */ 301 NN, NN, NN, NN, NN, NN, NN, NN, /* B8 - BF */ 302 NN, NN, NN, NN, NN, NN, NN, NN, /* C0 - C7 */ 303 NN, NN, NN, NN, NN, NN, NN, NN, /* C8 - CF */ 304 NN, NN, NN, NN, NN, NN, NN, NN, /* D0 - D7 */ 305 NN, NN, NN, NN, NN, NN, NN, NN, /* D8 - DF */ 306 29, 42, 56, 105, 90, 54, 93, 106, /* E0 - E7 */ 307 NN, NN, NN, NN, 254, NN, NN, NN, /* E8 - EF */ 308 NN, NN, NN, NN, NN, NN, NN, NN, /* F0 - F7 */ 309 NN, NN, NN, NN, NN, NN, NN, 255, /* F8 - FF */ 310 }; 311 312 static const uint8_t hkbd_boot_desc[] = { HID_KBD_BOOTPROTO_DESCR() }; 313 314 /* prototypes */ 315 static void hkbd_timeout(void *); 316 static int hkbd_set_leds(struct hkbd_softc *, uint8_t); 317 static int hkbd_set_typematic(keyboard_t *, int); 318 #ifdef HKBD_EMULATE_ATSCANCODE 319 static uint32_t hkbd_atkeycode(int, const bitstr_t *); 320 static int hkbd_key2scan(struct hkbd_softc *, int, const bitstr_t *, int); 321 #endif 322 static uint32_t hkbd_read_char(keyboard_t *, int); 323 static void hkbd_clear_state(keyboard_t *); 324 static int hkbd_ioctl(keyboard_t *, u_long, caddr_t); 325 static int hkbd_enable(keyboard_t *); 326 static int hkbd_disable(keyboard_t *); 327 static void hkbd_interrupt(struct hkbd_softc *); 328 329 static task_fn_t hkbd_event_keyinput; 330 331 static device_probe_t hkbd_probe; 332 static device_attach_t hkbd_attach; 333 static device_detach_t hkbd_detach; 334 static device_resume_t hkbd_resume; 335 336 #ifdef EVDEV_SUPPORT 337 static evdev_event_t hkbd_ev_event; 338 339 static const struct evdev_methods hkbd_evdev_methods = { 340 .ev_event = hkbd_ev_event, 341 }; 342 #endif 343 344 static bool 345 hkbd_any_key_pressed(struct hkbd_softc *sc) 346 { 347 int result; 348 349 bit_ffs(sc->sc_odata, HKBD_NKEYCODE, &result); 350 return (result != -1); 351 } 352 353 static bool 354 hkbd_any_key_valid(struct hkbd_softc *sc) 355 { 356 int result; 357 358 bit_ffs(sc->sc_loc_key_valid, HKBD_NKEYCODE, &result); 359 return (result != -1); 360 } 361 362 static bool 363 hkbd_is_modifier_key(uint32_t key) 364 { 365 366 return (key >= MOD_MIN && key <= MOD_MAX); 367 } 368 369 static void 370 hkbd_start_timer(struct hkbd_softc *sc) 371 { 372 sbintime_t delay, now, prec; 373 374 now = sbinuptime(); 375 376 /* check if initial delay passed and fallback to key repeat delay */ 377 if (sc->sc_delay == 0) 378 sc->sc_delay = sc->sc_kbd.kb_delay2; 379 380 /* compute timeout */ 381 delay = SBT_1MS * sc->sc_delay; 382 sc->sc_co_basetime += delay; 383 384 /* check if we are running behind */ 385 if (sc->sc_co_basetime < now) 386 sc->sc_co_basetime = now; 387 388 /* This is rarely called, so prefer precision to efficiency. */ 389 prec = qmin(delay >> 7, SBT_1MS * 10); 390 if (!HID_IN_POLLING_MODE()) 391 callout_reset_sbt(&sc->sc_callout, sc->sc_co_basetime, prec, 392 hkbd_timeout, sc, C_ABSOLUTE); 393 } 394 395 static void 396 hkbd_put_key(struct hkbd_softc *sc, uint32_t key) 397 { 398 uint32_t tail; 399 400 HKBD_LOCK_ASSERT(sc); 401 402 DPRINTF("0x%02x (%d) %s\n", key, key, 403 (key & KEY_RELEASE) ? "released" : "pressed"); 404 405 #ifdef EVDEV_SUPPORT 406 if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD && sc->sc_evdev != NULL) 407 evdev_push_event(sc->sc_evdev, EV_KEY, 408 evdev_hid2key(KEY_INDEX(key)), !(key & KEY_RELEASE)); 409 if (sc->sc_evdev != NULL && evdev_is_grabbed(sc->sc_evdev)) 410 return; 411 #endif 412 413 tail = (sc->sc_inputtail + 1) % HKBD_IN_BUF_SIZE; 414 if (tail != atomic_load_acq_32(&sc->sc_inputhead)) { 415 sc->sc_input[sc->sc_inputtail] = key; 416 atomic_store_rel_32(&sc->sc_inputtail, tail); 417 } else { 418 DPRINTF("input buffer is full\n"); 419 } 420 } 421 422 static void 423 hkbd_do_poll(struct hkbd_softc *sc, uint8_t wait) 424 { 425 426 SYSCONS_LOCK_ASSERT(); 427 KASSERT((sc->sc_flags & HKBD_FLAG_POLLING) != 0, 428 ("hkbd_do_poll called when not polling\n")); 429 DPRINTFN(2, "polling\n"); 430 431 if (!HID_IN_POLLING_MODE()) { 432 /* 433 * In this context the kernel is polling for input, 434 * but the USB subsystem works in normal interrupt-driven 435 * mode, so we just wait on the USB threads to do the job. 436 * Note that we currently hold the Giant, but it's also used 437 * as the transfer mtx, so we must release it while waiting. 438 */ 439 while (sc->sc_inputhead == 440 atomic_load_acq_32(&sc->sc_inputtail)) { 441 /* 442 * Give USB threads a chance to run. Note that 443 * kern_yield performs DROP_GIANT + PICKUP_GIANT. 444 */ 445 kern_yield(PRI_UNCHANGED); 446 if (!wait) 447 break; 448 } 449 return; 450 } 451 452 while (sc->sc_inputhead == sc->sc_inputtail) { 453 hid_intr_poll(sc->sc_dev); 454 455 /* Delay-optimised support for repetition of keys */ 456 if (hkbd_any_key_pressed(sc)) { 457 /* a key is pressed - need timekeeping */ 458 DELAY(1000); 459 460 /* 1 millisecond has passed */ 461 sc->sc_time_ms += 1; 462 } 463 464 hkbd_interrupt(sc); 465 466 if (!wait) 467 break; 468 } 469 } 470 471 static int32_t 472 hkbd_get_key(struct hkbd_softc *sc, uint8_t wait) 473 { 474 uint32_t head; 475 int32_t c; 476 477 SYSCONS_LOCK_ASSERT(); 478 KASSERT(!HID_IN_POLLING_MODE() || 479 (sc->sc_flags & HKBD_FLAG_POLLING) != 0, 480 ("not polling in kdb or panic\n")); 481 482 if (sc->sc_flags & HKBD_FLAG_POLLING) 483 hkbd_do_poll(sc, wait); 484 485 head = sc->sc_inputhead; 486 if (head == atomic_load_acq_32(&sc->sc_inputtail)) { 487 c = -1; 488 } else { 489 c = sc->sc_input[head]; 490 head = (head + 1) % HKBD_IN_BUF_SIZE; 491 atomic_store_rel_32(&sc->sc_inputhead, head); 492 } 493 return (c); 494 } 495 496 static void 497 hkbd_interrupt(struct hkbd_softc *sc) 498 { 499 const uint32_t now = sc->sc_time_ms; 500 unsigned key; 501 502 HKBD_LOCK_ASSERT(sc); 503 504 /* 505 * Check for key changes, the order is: 506 * 1. Regular keys up 507 * 2. Modifier keys up 508 * 3. Modifier keys down 509 * 4. Regular keys down 510 * 511 * This allows devices which send events changing the state of 512 * both a modifier key and a regular key, to be correctly 513 * translated. */ 514 bit_foreach(sc->sc_odata, HKBD_NKEYCODE, key) { 515 if (hkbd_is_modifier_key(key) || bit_test(sc->sc_ndata, key)) 516 continue; 517 hkbd_put_key(sc, key | KEY_RELEASE); 518 519 /* clear repeating key, if any */ 520 if (sc->sc_repeat_key == key) 521 sc->sc_repeat_key = 0; 522 } 523 bit_foreach_at(sc->sc_odata, MOD_MIN, MOD_MAX + 1, key) 524 if (!bit_test(sc->sc_ndata, key)) 525 hkbd_put_key(sc, key | KEY_RELEASE); 526 bit_foreach_at(sc->sc_ndata, MOD_MIN, MOD_MAX + 1, key) 527 if (!bit_test(sc->sc_odata, key)) 528 hkbd_put_key(sc, key | KEY_PRESS); 529 bit_foreach(sc->sc_ndata, HKBD_NKEYCODE, key) { 530 if (hkbd_is_modifier_key(key) || bit_test(sc->sc_odata, key)) 531 continue; 532 hkbd_put_key(sc, key | KEY_PRESS); 533 534 if (key != APPLE_FN_KEY) { 535 sc->sc_co_basetime = sbinuptime(); 536 sc->sc_delay = sc->sc_kbd.kb_delay1; 537 hkbd_start_timer(sc); 538 /* set repeat time for last key */ 539 sc->sc_repeat_time = now + sc->sc_kbd.kb_delay1; 540 sc->sc_repeat_key = key; 541 } 542 } 543 544 /* synchronize old data with new data */ 545 memcpy(sc->sc_odata0, sc->sc_ndata0, bitstr_size(HKBD_NKEYCODE)); 546 memcpy(sc->sc_odata, sc->sc_ndata, bitstr_size(HKBD_NKEYCODE)); 547 548 /* check if last key is still pressed */ 549 if (sc->sc_repeat_key != 0) { 550 const int32_t dtime = (sc->sc_repeat_time - now); 551 552 /* check if time has elapsed */ 553 if (dtime <= 0) { 554 hkbd_put_key(sc, sc->sc_repeat_key | KEY_PRESS); 555 sc->sc_repeat_time = now + sc->sc_kbd.kb_delay2; 556 } 557 } 558 559 #ifdef EVDEV_SUPPORT 560 if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD && sc->sc_evdev != NULL) 561 evdev_sync(sc->sc_evdev); 562 if (sc->sc_evdev != NULL && evdev_is_grabbed(sc->sc_evdev)) 563 return; 564 #endif 565 566 /* wakeup keyboard system */ 567 if (!HID_IN_POLLING_MODE()) 568 taskqueue_enqueue(taskqueue_swi_giant, &sc->sc_task); 569 } 570 571 static void 572 hkbd_event_keyinput(void *context, int pending) 573 { 574 struct hkbd_softc *sc = context; 575 int c; 576 577 SYSCONS_LOCK_ASSERT(); 578 579 if ((sc->sc_flags & HKBD_FLAG_POLLING) != 0) 580 return; 581 582 if (sc->sc_inputhead == atomic_load_acq_32(&sc->sc_inputtail)) 583 return; 584 585 if (KBD_IS_ACTIVE(&sc->sc_kbd) && 586 KBD_IS_BUSY(&sc->sc_kbd)) { 587 /* let the callback function process the input */ 588 (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT, 589 sc->sc_kbd.kb_callback.kc_arg); 590 } else { 591 /* read and discard the input, no one is waiting for it */ 592 do { 593 c = hkbd_read_char(&sc->sc_kbd, 0); 594 } while (c != NOKEY); 595 } 596 } 597 598 static void 599 hkbd_timeout(void *arg) 600 { 601 struct hkbd_softc *sc = arg; 602 #ifdef EVDEV_SUPPORT 603 struct epoch_tracker et; 604 #endif 605 606 HKBD_LOCK_ASSERT(sc); 607 608 sc->sc_time_ms += sc->sc_delay; 609 sc->sc_delay = 0; 610 611 #ifdef EVDEV_SUPPORT 612 epoch_enter_preempt(INPUT_EPOCH, &et); 613 #endif 614 hkbd_interrupt(sc); 615 #ifdef EVDEV_SUPPORT 616 epoch_exit_preempt(INPUT_EPOCH, &et); 617 #endif 618 619 /* Make sure any leftover key events gets read out */ 620 taskqueue_enqueue(taskqueue_swi_giant, &sc->sc_task); 621 622 if (hkbd_any_key_pressed(sc) || 623 atomic_load_acq_32(&sc->sc_inputhead) != sc->sc_inputtail) { 624 hkbd_start_timer(sc); 625 } 626 } 627 628 static uint32_t 629 hkbd_apple_fn(uint32_t keycode) 630 { 631 switch (keycode) { 632 case 0x0b: return 0x50; /* H -> LEFT ARROW */ 633 case 0x0d: return 0x51; /* J -> DOWN ARROW */ 634 case 0x0e: return 0x52; /* K -> UP ARROW */ 635 case 0x0f: return 0x4f; /* L -> RIGHT ARROW */ 636 case 0x36: return 0x4a; /* COMMA -> HOME */ 637 case 0x37: return 0x4d; /* DOT -> END */ 638 case 0x18: return 0x4b; /* U -> PGUP */ 639 case 0x07: return 0x4e; /* D -> PGDN */ 640 case 0x16: return 0x47; /* S -> SCROLLLOCK */ 641 case 0x13: return 0x46; /* P -> SYSRQ/PRTSC */ 642 case 0x28: return 0x49; /* RETURN -> INSERT */ 643 case 0x2a: return 0x4c; /* BACKSPACE -> DEL */ 644 case 0x50: return 0x4a; /* LEFT ARROW -> HOME */ 645 case 0x4f: return 0x4d; /* RIGHT ARROW -> END */ 646 case 0x52: return 0x4b; /* UP ARROW -> PGUP */ 647 case 0x51: return 0x4e; /* DOWN ARROW -> PGDN */ 648 default: return keycode; 649 } 650 } 651 652 /* separate so the sysctl doesn't butcher non-fn keys */ 653 static uint32_t 654 hkbd_apple_fn_media(uint32_t keycode) 655 { 656 switch (keycode) { 657 case 0x3a: return 0xc0; /* F1 -> BRIGHTNESS DOWN */ 658 case 0x3b: return 0xc1; /* F2 -> BRIGHTNESS UP */ 659 case 0x3c: return 0xc2; /* F3 -> SCALE (MISSION CTRL)*/ 660 case 0x3d: return 0xc3; /* F4 -> DASHBOARD (LAUNCHPAD) */ 661 case 0x3e: return 0xc4; /* F5 -> KBD BACKLIGHT DOWN */ 662 case 0x3f: return 0xc5; /* F6 -> KBD BACKLIGHT UP */ 663 case 0x40: return 0xea; /* F7 -> MEDIA PREV */ 664 case 0x41: return 0xe8; /* F8 -> PLAY/PAUSE */ 665 case 0x42: return 0xeb; /* F9 -> MEDIA NEXT */ 666 case 0x43: return 0xef; /* F10 -> MUTE */ 667 case 0x44: return 0xee; /* F11 -> VOLUME DOWN */ 668 case 0x45: return 0xed; /* F12 -> VOLUME UP */ 669 default: return keycode; 670 } 671 } 672 673 static uint32_t 674 hkbd_apple_doswap_cmd_ctl(uint32_t keycode) 675 { 676 switch (keycode) { 677 case 0xe3: return 0xe0; /* LCMD -> LCTL */ 678 case 0xe7: return 0xe4; /* RCMD -> RCTL */ 679 case 0xe0: return 0xe3; /* LCTL -> LCMD */ 680 case 0xe4: return 0xe7; /* RCTL -> RCMD */ 681 default: return keycode; 682 } 683 } 684 685 static uint32_t 686 hkbd_apple_doswap_cmd_opt(uint32_t keycode) 687 { 688 switch (keycode) { 689 case 0xe3: return 0xe2; /* LCMD -> ROPT */ 690 case 0xe7: return 0xe6; /* RCMD -> ROPT */ 691 case 0xe2: return 0xe3; /* LOPT -> LCMD */ 692 case 0xe6: return 0xe7; /* ROPT -> RCMD */ 693 default: return keycode; 694 } 695 } 696 697 static uint32_t 698 hkbd_apple_swap(uint32_t keycode) 699 { 700 switch (keycode) { 701 case 0x35: return 0x64; 702 case 0x64: return 0x35; 703 default: return keycode; 704 } 705 } 706 707 static void 708 hkbd_intr_callback(void *context, void *data, hid_size_t len) 709 { 710 struct hkbd_softc *sc = context; 711 uint8_t *buf = data; 712 uint32_t i; 713 uint8_t id = 0; 714 uint8_t modifiers; 715 716 HKBD_LOCK_ASSERT(sc); 717 718 DPRINTF("actlen=%d bytes\n", len); 719 720 if (len == 0) { 721 DPRINTF("zero length data\n"); 722 return; 723 } 724 725 if (sc->sc_kbd_id != 0) { 726 /* check and remove HID ID byte */ 727 id = buf[0]; 728 buf++; 729 len--; 730 if (len == 0) { 731 DPRINTF("zero length data\n"); 732 return; 733 } 734 } 735 736 /* clear temporary storage */ 737 if (bit_test(sc->sc_loc_key_valid, 0) && id == sc->sc_id_loc_key[0]) { 738 bit_foreach(sc->sc_ndata0, HKBD_NKEYCODE, i) 739 bit_clear(sc->sc_ndata, i); 740 memset(&sc->sc_ndata0, 0, bitstr_size(HKBD_NKEYCODE)); 741 } 742 bit_foreach(sc->sc_ndata, HKBD_NKEYCODE, i) 743 if (id == sc->sc_id_loc_key[i]) 744 bit_clear(sc->sc_ndata, i); 745 746 /* clear modifiers */ 747 modifiers = 0; 748 749 /* scan through HID data and expose magic apple keys */ 750 if ((sc->sc_flags & HKBD_FLAG_APPLE_EJECT) && 751 (id == sc->sc_id_apple_eject)) { 752 if (hid_get_data(buf, len, &sc->sc_loc_apple_eject)) { 753 bit_set(sc->sc_ndata, APPLE_EJECT_KEY); 754 modifiers |= MOD_EJECT; 755 } else { 756 bit_clear(sc->sc_ndata, APPLE_EJECT_KEY); 757 } 758 } 759 if ((sc->sc_flags & HKBD_FLAG_APPLE_FN) && 760 (id == sc->sc_id_apple_fn)) { 761 if (hid_get_data(buf, len, &sc->sc_loc_apple_fn)) { 762 bit_set(sc->sc_ndata, APPLE_FN_KEY); 763 modifiers |= MOD_FN; 764 } else { 765 bit_clear(sc->sc_ndata, APPLE_FN_KEY); 766 } 767 } 768 769 int apply_apple_fn_media = (modifiers & MOD_FN) ? 1 : 0; 770 if (hkbd_apple_fn_mode) /* toggle from sysctl value */ 771 apply_apple_fn_media = !apply_apple_fn_media; 772 773 bit_foreach(sc->sc_loc_key_valid, HKBD_NKEYCODE, i) { 774 if (id != sc->sc_id_loc_key[i]) { 775 continue; /* invalid HID ID */ 776 } else if (i == 0) { 777 struct hid_location tmp_loc = sc->sc_loc_key[0]; 778 /* range check array size */ 779 if (tmp_loc.count > HKBD_NKEYCODE) 780 tmp_loc.count = HKBD_NKEYCODE; 781 while (tmp_loc.count--) { 782 uint32_t key = 783 hid_get_udata(buf, len, &tmp_loc); 784 /* advance to next location */ 785 tmp_loc.pos += tmp_loc.size; 786 if (key == KEY_ERROR) { 787 DPRINTF("KEY_ERROR\n"); 788 memcpy(sc->sc_ndata0, sc->sc_odata0, 789 bitstr_size(HKBD_NKEYCODE)); 790 memcpy(sc->sc_ndata, sc->sc_odata, 791 bitstr_size(HKBD_NKEYCODE)); 792 return; /* ignore */ 793 } 794 if (modifiers & MOD_FN) 795 key = hkbd_apple_fn(key); 796 if (apply_apple_fn_media) 797 key = hkbd_apple_fn_media(key); 798 if (hkbd_apple_swap_cmd_ctl) 799 key = hkbd_apple_doswap_cmd_ctl(key); 800 if (hkbd_apple_swap_cmd_opt) 801 key = hkbd_apple_doswap_cmd_opt(key); 802 if (sc->sc_flags & HKBD_FLAG_APPLE_SWAP) 803 key = hkbd_apple_swap(key); 804 if (key == KEY_NONE || key >= HKBD_NKEYCODE) 805 continue; 806 /* set key in bitmap */ 807 bit_set(sc->sc_ndata, key); 808 bit_set(sc->sc_ndata0, key); 809 } 810 } else if (hid_get_data(buf, len, &sc->sc_loc_key[i])) { 811 uint32_t key = i; 812 813 if (modifiers & MOD_FN) 814 key = hkbd_apple_fn(key); 815 if (apply_apple_fn_media) 816 key = hkbd_apple_fn_media(key); 817 if (hkbd_apple_swap_cmd_ctl) 818 key = hkbd_apple_doswap_cmd_ctl(key); 819 if (hkbd_apple_swap_cmd_opt) 820 key = hkbd_apple_doswap_cmd_opt(key); 821 if (sc->sc_flags & HKBD_FLAG_APPLE_SWAP) 822 key = hkbd_apple_swap(key); 823 if (key == KEY_NONE || key == KEY_ERROR || key >= HKBD_NKEYCODE) 824 continue; 825 /* set key in bitmap */ 826 bit_set(sc->sc_ndata, key); 827 } 828 } 829 #ifdef HID_DEBUG 830 DPRINTF("modifiers = 0x%04x\n", modifiers); 831 bit_foreach(sc->sc_ndata, HKBD_NKEYCODE, i) 832 DPRINTF("Key 0x%02x pressed\n", i); 833 #endif 834 hkbd_interrupt(sc); 835 } 836 837 /* A match on these entries will load ukbd */ 838 static const struct hid_device_id __used hkbd_devs[] = { 839 { HID_TLC(HUP_GENERIC_DESKTOP, HUG_KEYBOARD) }, 840 }; 841 842 static int 843 hkbd_probe(device_t dev) 844 { 845 keyboard_switch_t *sw = kbd_get_switch(HKBD_DRIVER_NAME); 846 int error; 847 848 DPRINTFN(11, "\n"); 849 850 if (sw == NULL) { 851 return (ENXIO); 852 } 853 854 error = HIDBUS_LOOKUP_DRIVER_INFO(dev, hkbd_devs); 855 if (error != 0) 856 return (error); 857 858 hidbus_set_desc(dev, "Keyboard"); 859 860 return (BUS_PROBE_DEFAULT); 861 } 862 863 static void 864 hkbd_parse_hid(struct hkbd_softc *sc, const uint8_t *ptr, uint32_t len, 865 uint8_t tlc_index) 866 { 867 uint32_t flags; 868 uint32_t key; 869 uint8_t id; 870 871 /* reset detected bits */ 872 sc->sc_flags &= ~HKBD_FLAG_HID_MASK; 873 874 /* reset detected keys */ 875 memset(sc->sc_loc_key_valid, 0, bitstr_size(HKBD_NKEYCODE)); 876 877 /* check if there is an ID byte */ 878 sc->sc_kbd_size = hid_report_size_max(ptr, len, 879 hid_input, &sc->sc_kbd_id); 880 881 const struct hid_device_info *hw = hid_get_device_info(sc->sc_dev); 882 883 /* investigate if this is an Apple Keyboard */ 884 if (hw->idVendor == USB_VENDOR_APPLE) { /* belt & braces! */ 885 if (hidbus_locate(ptr, len, 886 HID_USAGE2(HUP_CONSUMER, HUG_APPLE_EJECT), 887 hid_input, tlc_index, 0, &sc->sc_loc_apple_eject, &flags, 888 &sc->sc_id_apple_eject, NULL)) { 889 if (flags & HIO_VARIABLE) 890 sc->sc_flags |= HKBD_FLAG_APPLE_EJECT | 891 HKBD_FLAG_APPLE_SWAP; 892 DPRINTFN(1, "Found Apple eject-key\n"); 893 } 894 /* 895 * check the same vendor pages that linux does to find the one 896 * apple uses for the function key. 897 */ 898 static const uint16_t apple_pages[] = { 899 HUP_APPLE, /* HID_UP_CUSTOM in linux */ 900 HUP_MICROSOFT, /* HID_UP_MSVENDOR in linux */ 901 HUP_HP, /* HID_UP_HPVENDOR2 in linux */ 902 0xFFFF /* Original FreeBSD check (Remove?) */ 903 }; 904 for (int i = 0; i < (int)nitems(apple_pages); i++) { 905 if (hidbus_locate(ptr, len, 906 HID_USAGE2(apple_pages[i], 0x0003), 907 hid_input, tlc_index, 0, &sc->sc_loc_apple_fn, &flags, 908 &sc->sc_id_apple_fn, NULL)) { 909 if (flags & HIO_VARIABLE) 910 sc->sc_flags |= HKBD_FLAG_APPLE_FN; 911 DPRINTFN(1, "Found Apple FN-key on page 0x%04x\n", 912 apple_pages[i]); 913 break; 914 } 915 } 916 } 917 918 /* figure out event buffer */ 919 if (hidbus_locate(ptr, len, 920 HID_USAGE2(HUP_KEYBOARD, 0x00), 921 hid_input, tlc_index, 0, &sc->sc_loc_key[0], &flags, 922 &sc->sc_id_loc_key[0], NULL)) { 923 if (flags & HIO_VARIABLE) { 924 DPRINTFN(1, "Ignoring keyboard event control\n"); 925 } else { 926 bit_set(sc->sc_loc_key_valid, 0); 927 DPRINTFN(1, "Found keyboard event array\n"); 928 } 929 } 930 931 /* figure out the keys */ 932 for (key = 1; key != HKBD_NKEYCODE; key++) { 933 if (hidbus_locate(ptr, len, 934 HID_USAGE2(HUP_KEYBOARD, key), 935 hid_input, tlc_index, 0, &sc->sc_loc_key[key], &flags, 936 &sc->sc_id_loc_key[key], NULL)) { 937 if (flags & HIO_VARIABLE) { 938 bit_set(sc->sc_loc_key_valid, key); 939 DPRINTFN(1, "Found key 0x%02x\n", key); 940 } 941 } 942 } 943 944 /* figure out leds on keyboard */ 945 if (hidbus_locate(ptr, len, 946 HID_USAGE2(HUP_LEDS, 0x01), 947 hid_output, tlc_index, 0, &sc->sc_loc_numlock, &flags, 948 &sc->sc_id_leds, NULL)) { 949 if (flags & HIO_VARIABLE) 950 sc->sc_flags |= HKBD_FLAG_NUMLOCK; 951 DPRINTFN(1, "Found keyboard numlock\n"); 952 } 953 if (hidbus_locate(ptr, len, 954 HID_USAGE2(HUP_LEDS, 0x02), 955 hid_output, tlc_index, 0, &sc->sc_loc_capslock, &flags, 956 &id, NULL)) { 957 if ((sc->sc_flags & HKBD_FLAG_NUMLOCK) == 0) 958 sc->sc_id_leds = id; 959 if (flags & HIO_VARIABLE && sc->sc_id_leds == id) 960 sc->sc_flags |= HKBD_FLAG_CAPSLOCK; 961 DPRINTFN(1, "Found keyboard capslock\n"); 962 } 963 if (hidbus_locate(ptr, len, 964 HID_USAGE2(HUP_LEDS, 0x03), 965 hid_output, tlc_index, 0, &sc->sc_loc_scrolllock, &flags, 966 &id, NULL)) { 967 if ((sc->sc_flags & (HKBD_FLAG_NUMLOCK | HKBD_FLAG_CAPSLOCK)) 968 == 0) 969 sc->sc_id_leds = id; 970 if (flags & HIO_VARIABLE && sc->sc_id_leds == id) 971 sc->sc_flags |= HKBD_FLAG_SCROLLLOCK; 972 DPRINTFN(1, "Found keyboard scrolllock\n"); 973 } 974 975 if ((sc->sc_flags & (HKBD_FLAG_NUMLOCK | HKBD_FLAG_CAPSLOCK | 976 HKBD_FLAG_SCROLLLOCK)) != 0) 977 sc->sc_led_size = hid_report_size(ptr, len, 978 hid_output, sc->sc_id_leds); 979 } 980 981 static int 982 hkbd_attach(device_t dev) 983 { 984 struct hkbd_softc *sc = device_get_softc(dev); 985 const struct hid_device_info *hw = hid_get_device_info(dev); 986 int unit = device_get_unit(dev); 987 keyboard_t *kbd = &sc->sc_kbd; 988 void *hid_ptr = NULL; 989 int err; 990 uint16_t n; 991 hid_size_t hid_len; 992 uint8_t tlc_index = hidbus_get_index(dev); 993 #ifdef EVDEV_SUPPORT 994 struct evdev_dev *evdev; 995 int i; 996 #endif 997 998 sc->sc_dev = dev; 999 SYSCONS_LOCK_ASSERT(); 1000 1001 kbd_init_struct(kbd, HKBD_DRIVER_NAME, KB_OTHER, unit, 0, 0, 0); 1002 1003 kbd->kb_data = (void *)sc; 1004 1005 sc->sc_mode = K_XLATE; 1006 1007 mtx_init(&sc->sc_mtx, "hkbd lock", NULL, MTX_DEF); 1008 TASK_INIT(&sc->sc_task, 0, hkbd_event_keyinput, sc); 1009 callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0); 1010 1011 hidbus_set_intr(dev, hkbd_intr_callback, sc); 1012 /* interrupt handler will be called with hkbd mutex taken */ 1013 hidbus_set_lock(dev, &sc->sc_mtx); 1014 /* interrupt handler can be called during panic */ 1015 hidbus_set_flags(dev, hidbus_get_flags(dev) | HIDBUS_FLAG_CAN_POLL); 1016 1017 /* setup default keyboard maps */ 1018 1019 sc->sc_keymap = key_map; 1020 sc->sc_accmap = accent_map; 1021 for (n = 0; n < HKBD_NFKEY; n++) { 1022 sc->sc_fkeymap[n] = fkey_tab[n]; 1023 } 1024 1025 kbd_set_maps(kbd, &sc->sc_keymap, &sc->sc_accmap, 1026 sc->sc_fkeymap, HKBD_NFKEY); 1027 1028 KBD_FOUND_DEVICE(kbd); 1029 1030 hkbd_clear_state(kbd); 1031 1032 /* 1033 * FIXME: set the initial value for lock keys in "sc_state" 1034 * according to the BIOS data? 1035 */ 1036 KBD_PROBE_DONE(kbd); 1037 1038 /* get HID descriptor */ 1039 err = hid_get_report_descr(dev, &hid_ptr, &hid_len); 1040 1041 if (err == 0) { 1042 DPRINTF("Parsing HID descriptor of %d bytes\n", 1043 (int)hid_len); 1044 1045 hkbd_parse_hid(sc, hid_ptr, hid_len, tlc_index); 1046 } 1047 1048 /* check if we should use the boot protocol */ 1049 if (hid_test_quirk(hw, HQ_KBD_BOOTPROTO) || 1050 (err != 0) || hkbd_any_key_valid(sc) == false) { 1051 DPRINTF("Forcing boot protocol\n"); 1052 1053 err = hid_set_protocol(dev, 0); 1054 1055 if (err != 0) { 1056 DPRINTF("Set protocol error=%d (ignored)\n", err); 1057 } 1058 1059 hkbd_parse_hid(sc, hkbd_boot_desc, sizeof(hkbd_boot_desc), 0); 1060 } 1061 1062 /* ignore if SETIDLE fails, hence it is not crucial */ 1063 hid_set_idle(dev, 0, 0); 1064 1065 hkbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state); 1066 1067 KBD_INIT_DONE(kbd); 1068 1069 if (kbd_register(kbd) < 0) { 1070 goto detach; 1071 } 1072 KBD_CONFIG_DONE(kbd); 1073 1074 hkbd_enable(kbd); 1075 1076 #ifdef KBD_INSTALL_CDEV 1077 if (kbd_attach(kbd)) { 1078 goto detach; 1079 } 1080 #endif 1081 1082 #ifdef EVDEV_SUPPORT 1083 evdev = evdev_alloc(); 1084 evdev_set_name(evdev, device_get_desc(dev)); 1085 evdev_set_phys(evdev, device_get_nameunit(dev)); 1086 evdev_set_id(evdev, hw->idBus, hw->idVendor, hw->idProduct, 1087 hw->idVersion); 1088 evdev_set_serial(evdev, hw->serial); 1089 evdev_set_methods(evdev, kbd, &hkbd_evdev_methods); 1090 evdev_set_flag(evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */ 1091 evdev_support_event(evdev, EV_SYN); 1092 evdev_support_event(evdev, EV_KEY); 1093 if (sc->sc_flags & (HKBD_FLAG_NUMLOCK | HKBD_FLAG_CAPSLOCK | 1094 HKBD_FLAG_SCROLLLOCK)) 1095 evdev_support_event(evdev, EV_LED); 1096 evdev_support_event(evdev, EV_REP); 1097 1098 for (i = 0x00; i <= 0xFF; i++) 1099 evdev_support_key(evdev, evdev_hid2key(i)); 1100 if (sc->sc_flags & HKBD_FLAG_NUMLOCK) 1101 evdev_support_led(evdev, LED_NUML); 1102 if (sc->sc_flags & HKBD_FLAG_CAPSLOCK) 1103 evdev_support_led(evdev, LED_CAPSL); 1104 if (sc->sc_flags & HKBD_FLAG_SCROLLLOCK) 1105 evdev_support_led(evdev, LED_SCROLLL); 1106 1107 if (evdev_register(evdev)) 1108 evdev_free(evdev); 1109 else 1110 sc->sc_evdev = evdev; 1111 #endif 1112 1113 sc->sc_flags |= HKBD_FLAG_ATTACHED; 1114 1115 if (bootverbose) { 1116 kbdd_diag(kbd, bootverbose); 1117 } 1118 1119 /* start the keyboard */ 1120 hid_intr_start(dev); 1121 1122 return (0); /* success */ 1123 1124 detach: 1125 hkbd_detach(dev); 1126 return (ENXIO); /* error */ 1127 } 1128 1129 static int 1130 hkbd_detach(device_t dev) 1131 { 1132 struct hkbd_softc *sc = device_get_softc(dev); 1133 #ifdef EVDEV_SUPPORT 1134 struct epoch_tracker et; 1135 #endif 1136 int error; 1137 1138 SYSCONS_LOCK_ASSERT(); 1139 1140 DPRINTF("\n"); 1141 1142 sc->sc_flags |= HKBD_FLAG_GONE; 1143 1144 HKBD_LOCK(sc); 1145 callout_stop(&sc->sc_callout); 1146 HKBD_UNLOCK(sc); 1147 1148 /* kill any stuck keys */ 1149 if (sc->sc_flags & HKBD_FLAG_ATTACHED) { 1150 /* stop receiving events from the USB keyboard */ 1151 hid_intr_stop(dev); 1152 1153 /* release all leftover keys, if any */ 1154 memset(&sc->sc_ndata, 0, bitstr_size(HKBD_NKEYCODE)); 1155 1156 /* process releasing of all keys */ 1157 HKBD_LOCK(sc); 1158 #ifdef EVDEV_SUPPORT 1159 epoch_enter_preempt(INPUT_EPOCH, &et); 1160 #endif 1161 hkbd_interrupt(sc); 1162 #ifdef EVDEV_SUPPORT 1163 epoch_exit_preempt(INPUT_EPOCH, &et); 1164 #endif 1165 HKBD_UNLOCK(sc); 1166 taskqueue_drain(taskqueue_swi_giant, &sc->sc_task); 1167 } 1168 1169 mtx_destroy(&sc->sc_mtx); 1170 hkbd_disable(&sc->sc_kbd); 1171 1172 #ifdef KBD_INSTALL_CDEV 1173 if (sc->sc_flags & HKBD_FLAG_ATTACHED) { 1174 error = kbd_detach(&sc->sc_kbd); 1175 if (error) { 1176 /* usb attach cannot return an error */ 1177 device_printf(dev, "WARNING: kbd_detach() " 1178 "returned non-zero! (ignored)\n"); 1179 } 1180 } 1181 #endif 1182 1183 #ifdef EVDEV_SUPPORT 1184 evdev_free(sc->sc_evdev); 1185 #endif 1186 1187 if (KBD_IS_CONFIGURED(&sc->sc_kbd)) { 1188 error = kbd_unregister(&sc->sc_kbd); 1189 if (error) { 1190 /* usb attach cannot return an error */ 1191 device_printf(dev, "WARNING: kbd_unregister() " 1192 "returned non-zero! (ignored)\n"); 1193 } 1194 } 1195 sc->sc_kbd.kb_flags = 0; 1196 1197 DPRINTF("%s: disconnected\n", 1198 device_get_nameunit(dev)); 1199 1200 return (0); 1201 } 1202 1203 static int 1204 hkbd_resume(device_t dev) 1205 { 1206 struct hkbd_softc *sc = device_get_softc(dev); 1207 1208 SYSCONS_LOCK_ASSERT(); 1209 1210 hkbd_clear_state(&sc->sc_kbd); 1211 1212 return (0); 1213 } 1214 1215 #ifdef EVDEV_SUPPORT 1216 static void 1217 hkbd_ev_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, 1218 int32_t value) 1219 { 1220 keyboard_t *kbd = evdev_get_softc(evdev); 1221 1222 if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD && 1223 (type == EV_LED || type == EV_REP)) { 1224 mtx_lock(&Giant); 1225 kbd_ev_event(kbd, type, code, value); 1226 mtx_unlock(&Giant); 1227 } 1228 } 1229 #endif 1230 1231 /* early keyboard probe, not supported */ 1232 static int 1233 hkbd_configure(int flags) 1234 { 1235 return (0); 1236 } 1237 1238 /* detect a keyboard, not used */ 1239 static int 1240 hkbd__probe(int unit, void *arg, int flags) 1241 { 1242 return (ENXIO); 1243 } 1244 1245 /* reset and initialize the device, not used */ 1246 static int 1247 hkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 1248 { 1249 return (ENXIO); 1250 } 1251 1252 /* test the interface to the device, not used */ 1253 static int 1254 hkbd_test_if(keyboard_t *kbd) 1255 { 1256 return (0); 1257 } 1258 1259 /* finish using this keyboard, not used */ 1260 static int 1261 hkbd_term(keyboard_t *kbd) 1262 { 1263 return (ENXIO); 1264 } 1265 1266 /* keyboard interrupt routine, not used */ 1267 static int 1268 hkbd_intr(keyboard_t *kbd, void *arg) 1269 { 1270 return (0); 1271 } 1272 1273 /* lock the access to the keyboard, not used */ 1274 static int 1275 hkbd_lock(keyboard_t *kbd, int lock) 1276 { 1277 return (1); 1278 } 1279 1280 /* 1281 * Enable the access to the device; until this function is called, 1282 * the client cannot read from the keyboard. 1283 */ 1284 static int 1285 hkbd_enable(keyboard_t *kbd) 1286 { 1287 1288 SYSCONS_LOCK(); 1289 KBD_ACTIVATE(kbd); 1290 SYSCONS_UNLOCK(); 1291 1292 return (0); 1293 } 1294 1295 /* disallow the access to the device */ 1296 static int 1297 hkbd_disable(keyboard_t *kbd) 1298 { 1299 1300 SYSCONS_LOCK(); 1301 KBD_DEACTIVATE(kbd); 1302 SYSCONS_UNLOCK(); 1303 1304 return (0); 1305 } 1306 1307 /* check if data is waiting */ 1308 /* Currently unused. */ 1309 static int 1310 hkbd_check(keyboard_t *kbd) 1311 { 1312 struct hkbd_softc *sc = kbd->kb_data; 1313 1314 SYSCONS_LOCK_ASSERT(); 1315 1316 if (!KBD_IS_ACTIVE(kbd)) 1317 return (0); 1318 1319 if (sc->sc_flags & HKBD_FLAG_POLLING) 1320 hkbd_do_poll(sc, 0); 1321 1322 #ifdef HKBD_EMULATE_ATSCANCODE 1323 if (sc->sc_buffered_char[0]) { 1324 return (1); 1325 } 1326 #endif 1327 if (sc->sc_inputhead != atomic_load_acq_32(&sc->sc_inputtail)) { 1328 return (1); 1329 } 1330 return (0); 1331 } 1332 1333 /* check if char is waiting */ 1334 static int 1335 hkbd_check_char_locked(keyboard_t *kbd) 1336 { 1337 struct hkbd_softc *sc = kbd->kb_data; 1338 1339 SYSCONS_LOCK_ASSERT(); 1340 1341 if (!KBD_IS_ACTIVE(kbd)) 1342 return (0); 1343 1344 if ((sc->sc_composed_char > 0) && 1345 (!(sc->sc_flags & HKBD_FLAG_COMPOSE))) { 1346 return (1); 1347 } 1348 return (hkbd_check(kbd)); 1349 } 1350 1351 static int 1352 hkbd_check_char(keyboard_t *kbd) 1353 { 1354 int result; 1355 1356 SYSCONS_LOCK(); 1357 result = hkbd_check_char_locked(kbd); 1358 SYSCONS_UNLOCK(); 1359 1360 return (result); 1361 } 1362 1363 /* read one byte from the keyboard if it's allowed */ 1364 /* Currently unused. */ 1365 static int 1366 hkbd_read(keyboard_t *kbd, int wait) 1367 { 1368 struct hkbd_softc *sc = kbd->kb_data; 1369 int32_t usbcode; 1370 #ifdef HKBD_EMULATE_ATSCANCODE 1371 uint32_t keycode; 1372 uint32_t scancode; 1373 1374 #endif 1375 1376 SYSCONS_LOCK_ASSERT(); 1377 1378 if (!KBD_IS_ACTIVE(kbd)) 1379 return (-1); 1380 1381 #ifdef HKBD_EMULATE_ATSCANCODE 1382 if (sc->sc_buffered_char[0]) { 1383 scancode = sc->sc_buffered_char[0]; 1384 if (scancode & SCAN_PREFIX) { 1385 sc->sc_buffered_char[0] &= ~SCAN_PREFIX; 1386 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1387 } 1388 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1389 sc->sc_buffered_char[1] = 0; 1390 return (scancode); 1391 } 1392 #endif /* HKBD_EMULATE_ATSCANCODE */ 1393 1394 /* XXX */ 1395 usbcode = hkbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1396 if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1)) 1397 return (-1); 1398 1399 ++(kbd->kb_count); 1400 1401 #ifdef HKBD_EMULATE_ATSCANCODE 1402 keycode = hkbd_atkeycode(usbcode, sc->sc_ndata); 1403 if (keycode == NN) { 1404 return -1; 1405 } 1406 return (hkbd_key2scan(sc, keycode, sc->sc_ndata, 1407 (usbcode & KEY_RELEASE))); 1408 #else /* !HKBD_EMULATE_ATSCANCODE */ 1409 return (usbcode); 1410 #endif /* HKBD_EMULATE_ATSCANCODE */ 1411 } 1412 1413 /* read char from the keyboard */ 1414 static uint32_t 1415 hkbd_read_char_locked(keyboard_t *kbd, int wait) 1416 { 1417 struct hkbd_softc *sc = kbd->kb_data; 1418 uint32_t action; 1419 uint32_t keycode; 1420 int32_t usbcode; 1421 #ifdef HKBD_EMULATE_ATSCANCODE 1422 uint32_t scancode; 1423 #endif 1424 1425 SYSCONS_LOCK_ASSERT(); 1426 1427 if (!KBD_IS_ACTIVE(kbd)) 1428 return (NOKEY); 1429 1430 next_code: 1431 1432 /* do we have a composed char to return ? */ 1433 1434 if ((sc->sc_composed_char > 0) && 1435 (!(sc->sc_flags & HKBD_FLAG_COMPOSE))) { 1436 action = sc->sc_composed_char; 1437 sc->sc_composed_char = 0; 1438 1439 if (action > 0xFF) { 1440 goto errkey; 1441 } 1442 goto done; 1443 } 1444 #ifdef HKBD_EMULATE_ATSCANCODE 1445 1446 /* do we have a pending raw scan code? */ 1447 1448 if (sc->sc_mode == K_RAW) { 1449 scancode = sc->sc_buffered_char[0]; 1450 if (scancode) { 1451 if (scancode & SCAN_PREFIX) { 1452 sc->sc_buffered_char[0] = (scancode & ~SCAN_PREFIX); 1453 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1454 } 1455 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1456 sc->sc_buffered_char[1] = 0; 1457 return (scancode); 1458 } 1459 } 1460 #endif /* HKBD_EMULATE_ATSCANCODE */ 1461 1462 /* see if there is something in the keyboard port */ 1463 /* XXX */ 1464 usbcode = hkbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1465 if (usbcode == -1) { 1466 return (NOKEY); 1467 } 1468 ++kbd->kb_count; 1469 1470 #ifdef HKBD_EMULATE_ATSCANCODE 1471 /* USB key index -> key code -> AT scan code */ 1472 keycode = hkbd_atkeycode(usbcode, sc->sc_ndata); 1473 if (keycode == NN) { 1474 return (NOKEY); 1475 } 1476 /* return an AT scan code for the K_RAW mode */ 1477 if (sc->sc_mode == K_RAW) { 1478 return (hkbd_key2scan(sc, keycode, sc->sc_ndata, 1479 (usbcode & KEY_RELEASE))); 1480 } 1481 #else /* !HKBD_EMULATE_ATSCANCODE */ 1482 1483 /* return the byte as is for the K_RAW mode */ 1484 if (sc->sc_mode == K_RAW) { 1485 return (usbcode); 1486 } 1487 /* USB key index -> key code */ 1488 keycode = hkbd_trtab[KEY_INDEX(usbcode)]; 1489 if (keycode == NN) { 1490 return (NOKEY); 1491 } 1492 #endif /* HKBD_EMULATE_ATSCANCODE */ 1493 1494 switch (keycode) { 1495 case 0x38: /* left alt (compose key) */ 1496 if (usbcode & KEY_RELEASE) { 1497 if (sc->sc_flags & HKBD_FLAG_COMPOSE) { 1498 sc->sc_flags &= ~HKBD_FLAG_COMPOSE; 1499 1500 if (sc->sc_composed_char > 0xFF) { 1501 sc->sc_composed_char = 0; 1502 } 1503 } 1504 } else { 1505 if (!(sc->sc_flags & HKBD_FLAG_COMPOSE)) { 1506 sc->sc_flags |= HKBD_FLAG_COMPOSE; 1507 sc->sc_composed_char = 0; 1508 } 1509 } 1510 break; 1511 } 1512 1513 /* return the key code in the K_CODE mode */ 1514 if (usbcode & KEY_RELEASE) { 1515 keycode |= SCAN_RELEASE; 1516 } 1517 if (sc->sc_mode == K_CODE) { 1518 return (keycode); 1519 } 1520 /* compose a character code */ 1521 if (sc->sc_flags & HKBD_FLAG_COMPOSE) { 1522 switch (keycode) { 1523 /* key pressed, process it */ 1524 case 0x47: 1525 case 0x48: 1526 case 0x49: /* keypad 7,8,9 */ 1527 sc->sc_composed_char *= 10; 1528 sc->sc_composed_char += keycode - 0x40; 1529 goto check_composed; 1530 1531 case 0x4B: 1532 case 0x4C: 1533 case 0x4D: /* keypad 4,5,6 */ 1534 sc->sc_composed_char *= 10; 1535 sc->sc_composed_char += keycode - 0x47; 1536 goto check_composed; 1537 1538 case 0x4F: 1539 case 0x50: 1540 case 0x51: /* keypad 1,2,3 */ 1541 sc->sc_composed_char *= 10; 1542 sc->sc_composed_char += keycode - 0x4E; 1543 goto check_composed; 1544 1545 case 0x52: /* keypad 0 */ 1546 sc->sc_composed_char *= 10; 1547 goto check_composed; 1548 1549 /* key released, no interest here */ 1550 case SCAN_RELEASE | 0x47: 1551 case SCAN_RELEASE | 0x48: 1552 case SCAN_RELEASE | 0x49: /* keypad 7,8,9 */ 1553 case SCAN_RELEASE | 0x4B: 1554 case SCAN_RELEASE | 0x4C: 1555 case SCAN_RELEASE | 0x4D: /* keypad 4,5,6 */ 1556 case SCAN_RELEASE | 0x4F: 1557 case SCAN_RELEASE | 0x50: 1558 case SCAN_RELEASE | 0x51: /* keypad 1,2,3 */ 1559 case SCAN_RELEASE | 0x52: /* keypad 0 */ 1560 goto next_code; 1561 1562 case 0x38: /* left alt key */ 1563 break; 1564 1565 default: 1566 if (sc->sc_composed_char > 0) { 1567 sc->sc_flags &= ~HKBD_FLAG_COMPOSE; 1568 sc->sc_composed_char = 0; 1569 goto errkey; 1570 } 1571 break; 1572 } 1573 } 1574 /* keycode to key action */ 1575 action = genkbd_keyaction(kbd, SCAN_CHAR(keycode), 1576 (keycode & SCAN_RELEASE), 1577 &sc->sc_state, &sc->sc_accents); 1578 if (action == NOKEY) { 1579 goto next_code; 1580 } 1581 done: 1582 return (action); 1583 1584 check_composed: 1585 if (sc->sc_composed_char <= 0xFF) { 1586 goto next_code; 1587 } 1588 errkey: 1589 return (ERRKEY); 1590 } 1591 1592 /* Currently wait is always false. */ 1593 static uint32_t 1594 hkbd_read_char(keyboard_t *kbd, int wait) 1595 { 1596 uint32_t keycode; 1597 1598 SYSCONS_LOCK(); 1599 keycode = hkbd_read_char_locked(kbd, wait); 1600 SYSCONS_UNLOCK(); 1601 1602 return (keycode); 1603 } 1604 1605 /* some useful control functions */ 1606 static int 1607 hkbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg) 1608 { 1609 struct hkbd_softc *sc = kbd->kb_data; 1610 #ifdef EVDEV_SUPPORT 1611 struct epoch_tracker et; 1612 #endif 1613 int error; 1614 int i; 1615 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1616 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1617 int ival; 1618 1619 #endif 1620 1621 SYSCONS_LOCK_ASSERT(); 1622 1623 switch (cmd) { 1624 case KDGKBMODE: /* get keyboard mode */ 1625 *(int *)arg = sc->sc_mode; 1626 break; 1627 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1628 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1629 case _IO('K', 7): 1630 ival = IOCPARM_IVAL(arg); 1631 arg = (caddr_t)&ival; 1632 /* FALLTHROUGH */ 1633 #endif 1634 case KDSKBMODE: /* set keyboard mode */ 1635 switch (*(int *)arg) { 1636 case K_XLATE: 1637 if (sc->sc_mode != K_XLATE) { 1638 /* make lock key state and LED state match */ 1639 sc->sc_state &= ~LOCK_MASK; 1640 sc->sc_state |= KBD_LED_VAL(kbd); 1641 } 1642 /* FALLTHROUGH */ 1643 case K_RAW: 1644 case K_CODE: 1645 if (sc->sc_mode != *(int *)arg) { 1646 if ((sc->sc_flags & HKBD_FLAG_POLLING) == 0) 1647 hkbd_clear_state(kbd); 1648 sc->sc_mode = *(int *)arg; 1649 } 1650 break; 1651 default: 1652 return (EINVAL); 1653 } 1654 break; 1655 1656 case KDGETLED: /* get keyboard LED */ 1657 *(int *)arg = KBD_LED_VAL(kbd); 1658 break; 1659 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1660 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1661 case _IO('K', 66): 1662 ival = IOCPARM_IVAL(arg); 1663 arg = (caddr_t)&ival; 1664 /* FALLTHROUGH */ 1665 #endif 1666 case KDSETLED: /* set keyboard LED */ 1667 /* NOTE: lock key state in "sc_state" won't be changed */ 1668 if (*(int *)arg & ~LOCK_MASK) 1669 return (EINVAL); 1670 1671 i = *(int *)arg; 1672 1673 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */ 1674 if (sc->sc_mode == K_XLATE && 1675 kbd->kb_keymap->n_keys > ALTGR_OFFSET) { 1676 if (i & ALKED) 1677 i |= CLKED; 1678 else 1679 i &= ~CLKED; 1680 } 1681 if (KBD_HAS_DEVICE(kbd)) { 1682 error = hkbd_set_leds(sc, i); 1683 if (error) 1684 return (error); 1685 } 1686 #ifdef EVDEV_SUPPORT 1687 if (sc->sc_evdev != NULL && !HID_IN_POLLING_MODE()) { 1688 epoch_enter_preempt(INPUT_EPOCH, &et); 1689 evdev_push_leds(sc->sc_evdev, i); 1690 epoch_exit_preempt(INPUT_EPOCH, &et); 1691 } 1692 #endif 1693 1694 KBD_LED_VAL(kbd) = *(int *)arg; 1695 break; 1696 1697 case KDGKBSTATE: /* get lock key state */ 1698 *(int *)arg = sc->sc_state & LOCK_MASK; 1699 break; 1700 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1701 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1702 case _IO('K', 20): 1703 ival = IOCPARM_IVAL(arg); 1704 arg = (caddr_t)&ival; 1705 /* FALLTHROUGH */ 1706 #endif 1707 case KDSKBSTATE: /* set lock key state */ 1708 if (*(int *)arg & ~LOCK_MASK) { 1709 return (EINVAL); 1710 } 1711 sc->sc_state &= ~LOCK_MASK; 1712 sc->sc_state |= *(int *)arg; 1713 1714 /* 1715 * Attempt to set the keyboard LEDs; ignore the return value 1716 * intentionally. Note: Some hypervisors/emulators (e.g., QEMU, 1717 * Parallels—at least as of the time of writing) may fail when 1718 * setting LEDs. This can prevent kbdmux from attaching the 1719 * keyboard, which in turn may block the console from accessing 1720 * it. 1721 */ 1722 (void)hkbd_ioctl_locked(kbd, KDSETLED, arg); 1723 return (0); 1724 1725 case KDSETREPEAT: /* set keyboard repeat rate (new 1726 * interface) */ 1727 if (!KBD_HAS_DEVICE(kbd)) { 1728 return (0); 1729 } 1730 /* 1731 * Convert negative, zero and tiny args to the same limits 1732 * as atkbd. We could support delays of 1 msec, but 1733 * anything much shorter than the shortest atkbd value 1734 * of 250.34 is almost unusable as well as incompatible. 1735 */ 1736 kbd->kb_delay1 = imax(((int *)arg)[0], 250); 1737 kbd->kb_delay2 = imax(((int *)arg)[1], 34); 1738 #ifdef EVDEV_SUPPORT 1739 if (sc->sc_evdev != NULL && !HID_IN_POLLING_MODE()) { 1740 epoch_enter_preempt(INPUT_EPOCH, &et); 1741 evdev_push_repeats(sc->sc_evdev, kbd); 1742 epoch_exit_preempt(INPUT_EPOCH, &et); 1743 } 1744 #endif 1745 return (0); 1746 1747 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1748 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1749 case _IO('K', 67): 1750 ival = IOCPARM_IVAL(arg); 1751 arg = (caddr_t)&ival; 1752 /* FALLTHROUGH */ 1753 #endif 1754 case KDSETRAD: /* set keyboard repeat rate (old 1755 * interface) */ 1756 return (hkbd_set_typematic(kbd, *(int *)arg)); 1757 1758 case PIO_KEYMAP: /* set keyboard translation table */ 1759 case PIO_KEYMAPENT: /* set keyboard translation table 1760 * entry */ 1761 case PIO_DEADKEYMAP: /* set accent key translation table */ 1762 #ifdef COMPAT_FREEBSD13 1763 case OPIO_KEYMAP: /* set keyboard translation table 1764 * (compat) */ 1765 case OPIO_DEADKEYMAP: /* set accent key translation table 1766 * (compat) */ 1767 #endif /* COMPAT_FREEBSD13 */ 1768 sc->sc_accents = 0; 1769 /* FALLTHROUGH */ 1770 default: 1771 return (genkbd_commonioctl(kbd, cmd, arg)); 1772 } 1773 1774 return (0); 1775 } 1776 1777 static int 1778 hkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg) 1779 { 1780 int result; 1781 1782 /* 1783 * XXX Check if someone is calling us from a critical section: 1784 */ 1785 if (curthread->td_critnest != 0) 1786 return (EDEADLK); 1787 1788 /* 1789 * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any 1790 * context where printf(9) can be called, which among other things 1791 * includes interrupt filters and threads with any kinds of locks 1792 * already held. For this reason it would be dangerous to acquire 1793 * the Giant here unconditionally. On the other hand we have to 1794 * have it to handle the ioctl. 1795 * So we make our best effort to auto-detect whether we can grab 1796 * the Giant or not. Blame syscons(4) for this. 1797 */ 1798 switch (cmd) { 1799 case KDGKBSTATE: 1800 case KDSKBSTATE: 1801 case KDSETLED: 1802 if (!mtx_owned(&Giant) && !HID_IN_POLLING_MODE()) 1803 return (EDEADLK); /* best I could come up with */ 1804 /* FALLTHROUGH */ 1805 default: 1806 SYSCONS_LOCK(); 1807 result = hkbd_ioctl_locked(kbd, cmd, arg); 1808 SYSCONS_UNLOCK(); 1809 return (result); 1810 } 1811 } 1812 1813 /* clear the internal state of the keyboard */ 1814 static void 1815 hkbd_clear_state(keyboard_t *kbd) 1816 { 1817 struct hkbd_softc *sc = kbd->kb_data; 1818 1819 SYSCONS_LOCK_ASSERT(); 1820 1821 sc->sc_flags &= ~(HKBD_FLAG_COMPOSE | HKBD_FLAG_POLLING); 1822 sc->sc_state &= LOCK_MASK; /* preserve locking key state */ 1823 sc->sc_accents = 0; 1824 sc->sc_composed_char = 0; 1825 #ifdef HKBD_EMULATE_ATSCANCODE 1826 sc->sc_buffered_char[0] = 0; 1827 sc->sc_buffered_char[1] = 0; 1828 #endif 1829 memset(&sc->sc_ndata, 0, bitstr_size(HKBD_NKEYCODE)); 1830 memset(&sc->sc_odata, 0, bitstr_size(HKBD_NKEYCODE)); 1831 memset(&sc->sc_ndata0, 0, bitstr_size(HKBD_NKEYCODE)); 1832 memset(&sc->sc_odata0, 0, bitstr_size(HKBD_NKEYCODE)); 1833 sc->sc_repeat_time = 0; 1834 sc->sc_repeat_key = 0; 1835 } 1836 1837 /* save the internal state, not used */ 1838 static int 1839 hkbd_get_state(keyboard_t *kbd, void *buf, size_t len) 1840 { 1841 return (len == 0) ? 1 : -1; 1842 } 1843 1844 /* set the internal state, not used */ 1845 static int 1846 hkbd_set_state(keyboard_t *kbd, void *buf, size_t len) 1847 { 1848 return (EINVAL); 1849 } 1850 1851 static int 1852 hkbd_poll(keyboard_t *kbd, int on) 1853 { 1854 struct hkbd_softc *sc = kbd->kb_data; 1855 1856 SYSCONS_LOCK(); 1857 /* 1858 * Keep a reference count on polling to allow recursive 1859 * cngrab() during a panic for example. 1860 */ 1861 if (on) 1862 sc->sc_polling++; 1863 else if (sc->sc_polling > 0) 1864 sc->sc_polling--; 1865 1866 if (sc->sc_polling != 0) { 1867 sc->sc_flags |= HKBD_FLAG_POLLING; 1868 sc->sc_poll_thread = curthread; 1869 } else { 1870 sc->sc_flags &= ~HKBD_FLAG_POLLING; 1871 sc->sc_delay = 0; 1872 } 1873 SYSCONS_UNLOCK(); 1874 1875 return (0); 1876 } 1877 1878 /* local functions */ 1879 1880 static int 1881 hkbd_set_leds(struct hkbd_softc *sc, uint8_t leds) 1882 { 1883 uint8_t id; 1884 uint8_t any; 1885 uint8_t *buf; 1886 int len; 1887 int error; 1888 1889 SYSCONS_LOCK_ASSERT(); 1890 DPRINTF("leds=0x%02x\n", leds); 1891 1892 if (hkbd_no_leds) 1893 return (0); 1894 1895 memset(sc->sc_buffer, 0, HKBD_BUFFER_SIZE); 1896 1897 id = sc->sc_id_leds; 1898 any = 0; 1899 1900 /* Assumption: All led bits must be in the same ID. */ 1901 1902 if (sc->sc_flags & HKBD_FLAG_NUMLOCK) { 1903 hid_put_udata(sc->sc_buffer + 1, HKBD_BUFFER_SIZE - 1, 1904 &sc->sc_loc_numlock, leds & NLKED ? 1 : 0); 1905 any = 1; 1906 } 1907 1908 if (sc->sc_flags & HKBD_FLAG_SCROLLLOCK) { 1909 hid_put_udata(sc->sc_buffer + 1, HKBD_BUFFER_SIZE - 1, 1910 &sc->sc_loc_scrolllock, leds & SLKED ? 1 : 0); 1911 any = 1; 1912 } 1913 1914 if (sc->sc_flags & HKBD_FLAG_CAPSLOCK) { 1915 hid_put_udata(sc->sc_buffer + 1, HKBD_BUFFER_SIZE - 1, 1916 &sc->sc_loc_capslock, leds & CLKED ? 1 : 0); 1917 any = 1; 1918 } 1919 1920 /* if no leds, nothing to do */ 1921 if (!any) 1922 return (0); 1923 1924 /* range check output report length */ 1925 len = sc->sc_led_size; 1926 if (len > (HKBD_BUFFER_SIZE - 1)) 1927 len = (HKBD_BUFFER_SIZE - 1); 1928 1929 /* check if we need to prefix an ID byte */ 1930 1931 if (id != 0) { 1932 sc->sc_buffer[0] = id; 1933 buf = sc->sc_buffer; 1934 } else { 1935 buf = sc->sc_buffer + 1; 1936 } 1937 1938 DPRINTF("len=%d, id=%d\n", len, id); 1939 1940 /* start data transfer */ 1941 SYSCONS_UNLOCK(); 1942 error = hid_write(sc->sc_dev, buf, len); 1943 SYSCONS_LOCK(); 1944 DPRINTF("error %d", error); 1945 1946 return (error); 1947 } 1948 1949 static int 1950 hkbd_set_typematic(keyboard_t *kbd, int code) 1951 { 1952 #ifdef EVDEV_SUPPORT 1953 struct hkbd_softc *sc = kbd->kb_data; 1954 #endif 1955 if (code & ~0x7f) { 1956 return (EINVAL); 1957 } 1958 kbd->kb_delay1 = kbdelays[(code >> 5) & 3]; 1959 kbd->kb_delay2 = kbrates[code & 0x1f]; 1960 #ifdef EVDEV_SUPPORT 1961 if (sc->sc_evdev != NULL) 1962 evdev_push_repeats(sc->sc_evdev, kbd); 1963 #endif 1964 return (0); 1965 } 1966 1967 #ifdef HKBD_EMULATE_ATSCANCODE 1968 static uint32_t 1969 hkbd_atkeycode(int usbcode, const bitstr_t *bitmap) 1970 { 1971 uint32_t keycode; 1972 1973 keycode = hkbd_trtab[KEY_INDEX(usbcode)]; 1974 1975 /* 1976 * Translate Alt-PrintScreen to SysRq. 1977 * 1978 * Some or all AT keyboards connected through USB have already 1979 * mapped Alted PrintScreens to an unusual usbcode (0x8a). 1980 * hkbd_trtab translates this to 0x7e, and key2scan() would 1981 * translate that to 0x79 (Intl' 4). Assume that if we have 1982 * an Alted 0x7e here then it actually is an Alted PrintScreen. 1983 * 1984 * The usual usbcode for all PrintScreens is 0x46. hkbd_trtab 1985 * translates this to 0x5c, so the Alt check to classify 0x5c 1986 * is routine. 1987 */ 1988 if ((keycode == 0x5c || keycode == 0x7e) && 1989 (HKBD_KEY_PRESSED(bitmap, 0xe2 /* ALT-L */) || 1990 HKBD_KEY_PRESSED(bitmap, 0xe6 /* ALT-R */))) 1991 return (0x54); 1992 return (keycode); 1993 } 1994 1995 static int 1996 hkbd_key2scan(struct hkbd_softc *sc, int code, const bitstr_t *bitmap, int up) 1997 { 1998 static const int scan[] = { 1999 /* 89 */ 2000 0x11c, /* Enter */ 2001 /* 90-99 */ 2002 0x11d, /* Ctrl-R */ 2003 0x135, /* Divide */ 2004 0x137, /* PrintScreen */ 2005 0x138, /* Alt-R */ 2006 0x147, /* Home */ 2007 0x148, /* Up */ 2008 0x149, /* PageUp */ 2009 0x14b, /* Left */ 2010 0x14d, /* Right */ 2011 0x14f, /* End */ 2012 /* 100-109 */ 2013 0x150, /* Down */ 2014 0x151, /* PageDown */ 2015 0x152, /* Insert */ 2016 0x153, /* Delete */ 2017 0x146, /* Pause/Break */ 2018 0x15b, /* Win_L(Super_L) */ 2019 0x15c, /* Win_R(Super_R) */ 2020 0x15d, /* Application(Menu) */ 2021 2022 /* SUN TYPE 6 USB KEYBOARD */ 2023 0x168, /* Sun Type 6 Help */ 2024 0x15e, /* Sun Type 6 Stop */ 2025 /* 110 - 119 */ 2026 0x15f, /* Sun Type 6 Again */ 2027 0x160, /* Sun Type 6 Props */ 2028 0x161, /* Sun Type 6 Undo */ 2029 0x162, /* Sun Type 6 Front */ 2030 0x163, /* Sun Type 6 Copy */ 2031 0x164, /* Sun Type 6 Open */ 2032 0x165, /* Sun Type 6 Paste */ 2033 0x166, /* Sun Type 6 Find */ 2034 0x167, /* Sun Type 6 Cut */ 2035 0x125, /* Sun Type 6 Mute */ 2036 /* 120 - 130 */ 2037 0x11f, /* Sun Type 6 VolumeDown */ 2038 0x11e, /* Sun Type 6 VolumeUp */ 2039 0x120, /* Sun Type 6 PowerDown */ 2040 2041 /* Japanese 106/109 keyboard */ 2042 0x73, /* Keyboard Intl' 1 (backslash / underscore) */ 2043 0x70, /* Keyboard Intl' 2 (Katakana / Hiragana) */ 2044 0x7d, /* Keyboard Intl' 3 (Yen sign) (Not using in jp106/109) */ 2045 0x79, /* Keyboard Intl' 4 (Henkan) */ 2046 0x7b, /* Keyboard Intl' 5 (Muhenkan) */ 2047 0x5c, /* Keyboard Intl' 6 (Keypad ,) (For PC-9821 layout) */ 2048 0x71, /* Apple Keyboard JIS (Kana) */ 2049 0x72, /* Apple Keyboard JIS (Eisu) */ 2050 }; 2051 2052 if ((code >= 89) && (code < (int)(89 + nitems(scan)))) { 2053 code = scan[code - 89]; 2054 } 2055 /* PrintScreen */ 2056 if (code == 0x137 && (!( 2057 HKBD_KEY_PRESSED(bitmap, 0xe0 /* CTRL-L */) || 2058 HKBD_KEY_PRESSED(bitmap, 0xe4 /* CTRL-R */) || 2059 HKBD_KEY_PRESSED(bitmap, 0xe1 /* SHIFT-L */) || 2060 HKBD_KEY_PRESSED(bitmap, 0xe5 /* SHIFT-R */)))) { 2061 code |= SCAN_PREFIX_SHIFT; 2062 } 2063 /* Pause/Break */ 2064 if ((code == 0x146) && (!( 2065 HKBD_KEY_PRESSED(bitmap, 0xe0 /* CTRL-L */) || 2066 HKBD_KEY_PRESSED(bitmap, 0xe4 /* CTRL-R */)))) { 2067 code = (0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL); 2068 } 2069 code |= (up ? SCAN_RELEASE : SCAN_PRESS); 2070 2071 if (code & SCAN_PREFIX) { 2072 if (code & SCAN_PREFIX_CTL) { 2073 /* Ctrl */ 2074 sc->sc_buffered_char[0] = (0x1d | (code & SCAN_RELEASE)); 2075 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX); 2076 } else if (code & SCAN_PREFIX_SHIFT) { 2077 /* Shift */ 2078 sc->sc_buffered_char[0] = (0x2a | (code & SCAN_RELEASE)); 2079 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX_SHIFT); 2080 } else { 2081 sc->sc_buffered_char[0] = (code & ~SCAN_PREFIX); 2082 sc->sc_buffered_char[1] = 0; 2083 } 2084 return ((code & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 2085 } 2086 return (code); 2087 2088 } 2089 2090 #endif /* HKBD_EMULATE_ATSCANCODE */ 2091 2092 static keyboard_switch_t hkbdsw = { 2093 .probe = &hkbd__probe, 2094 .init = &hkbd_init, 2095 .term = &hkbd_term, 2096 .intr = &hkbd_intr, 2097 .test_if = &hkbd_test_if, 2098 .enable = &hkbd_enable, 2099 .disable = &hkbd_disable, 2100 .read = &hkbd_read, 2101 .check = &hkbd_check, 2102 .read_char = &hkbd_read_char, 2103 .check_char = &hkbd_check_char, 2104 .ioctl = &hkbd_ioctl, 2105 .lock = &hkbd_lock, 2106 .clear_state = &hkbd_clear_state, 2107 .get_state = &hkbd_get_state, 2108 .set_state = &hkbd_set_state, 2109 .poll = &hkbd_poll, 2110 }; 2111 2112 KEYBOARD_DRIVER(hkbd, hkbdsw, hkbd_configure); 2113 2114 static int 2115 hkbd_driver_load(module_t mod, int what, void *arg) 2116 { 2117 switch (what) { 2118 case MOD_LOAD: 2119 kbd_add_driver(&hkbd_kbd_driver); 2120 break; 2121 case MOD_UNLOAD: 2122 kbd_delete_driver(&hkbd_kbd_driver); 2123 break; 2124 } 2125 return (0); 2126 } 2127 2128 static device_method_t hkbd_methods[] = { 2129 DEVMETHOD(device_probe, hkbd_probe), 2130 DEVMETHOD(device_attach, hkbd_attach), 2131 DEVMETHOD(device_detach, hkbd_detach), 2132 DEVMETHOD(device_resume, hkbd_resume), 2133 2134 DEVMETHOD_END 2135 }; 2136 2137 static driver_t hkbd_driver = { 2138 .name = "hkbd", 2139 .methods = hkbd_methods, 2140 .size = sizeof(struct hkbd_softc), 2141 }; 2142 2143 DRIVER_MODULE(hkbd, hidbus, hkbd_driver, hkbd_driver_load, NULL); 2144 MODULE_DEPEND(hkbd, hid, 1, 1, 1); 2145 MODULE_DEPEND(hkbd, hidbus, 1, 1, 1); 2146 #ifdef EVDEV_SUPPORT 2147 MODULE_DEPEND(hkbd, evdev, 1, 1, 1); 2148 #endif 2149 MODULE_VERSION(hkbd, 1); 2150 HID_PNP_INFO(hkbd_devs); 2151