1 #include <sys/cdefs.h> 2 __FBSDID("$FreeBSD$"); 3 4 5 /*- 6 * Copyright (c) 1998 The NetBSD Foundation, Inc. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by Lennart Augustsson (lennart@augustsson.net) at 11 * Carlstedt Research & Technology. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 * 34 */ 35 36 /* 37 * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf 38 */ 39 40 #include "opt_compat.h" 41 #include "opt_kbd.h" 42 #include "opt_ukbd.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/sched.h> 64 #include <sys/kdb.h> 65 66 #include <dev/usb/usb.h> 67 #include <dev/usb/usbdi.h> 68 #include <dev/usb/usbdi_util.h> 69 #include <dev/usb/usbhid.h> 70 71 #define USB_DEBUG_VAR ukbd_debug 72 #include <dev/usb/usb_debug.h> 73 74 #include <dev/usb/quirk/usb_quirk.h> 75 76 #include <sys/ioccom.h> 77 #include <sys/filio.h> 78 #include <sys/tty.h> 79 #include <sys/kbio.h> 80 81 #include <dev/kbd/kbdreg.h> 82 83 /* the initial key map, accent map and fkey strings */ 84 #if defined(UKBD_DFLT_KEYMAP) && !defined(KLD_MODULE) 85 #define KBD_DFLT_KEYMAP 86 #include "ukbdmap.h" 87 #endif 88 89 /* the following file must be included after "ukbdmap.h" */ 90 #include <dev/kbd/kbdtables.h> 91 92 #ifdef USB_DEBUG 93 static int ukbd_debug = 0; 94 static int ukbd_no_leds = 0; 95 static int ukbd_pollrate = 0; 96 97 static SYSCTL_NODE(_hw_usb, OID_AUTO, ukbd, CTLFLAG_RW, 0, "USB keyboard"); 98 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, debug, CTLFLAG_RWTUN, 99 &ukbd_debug, 0, "Debug level"); 100 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, no_leds, CTLFLAG_RWTUN, 101 &ukbd_no_leds, 0, "Disables setting of keyboard leds"); 102 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, pollrate, CTLFLAG_RWTUN, 103 &ukbd_pollrate, 0, "Force this polling rate, 1-1000Hz"); 104 #endif 105 106 #define UKBD_EMULATE_ATSCANCODE 1 107 #define UKBD_DRIVER_NAME "ukbd" 108 #define UKBD_NMOD 8 /* units */ 109 #define UKBD_NKEYCODE 6 /* units */ 110 #define UKBD_IN_BUF_SIZE (2*(UKBD_NMOD + (2*UKBD_NKEYCODE))) /* bytes */ 111 #define UKBD_IN_BUF_FULL (UKBD_IN_BUF_SIZE / 2) /* bytes */ 112 #define UKBD_NFKEY (sizeof(fkey_tab)/sizeof(fkey_tab[0])) /* units */ 113 #define UKBD_BUFFER_SIZE 64 /* bytes */ 114 115 struct ukbd_data { 116 uint16_t modifiers; 117 #define MOD_CONTROL_L 0x01 118 #define MOD_CONTROL_R 0x10 119 #define MOD_SHIFT_L 0x02 120 #define MOD_SHIFT_R 0x20 121 #define MOD_ALT_L 0x04 122 #define MOD_ALT_R 0x40 123 #define MOD_WIN_L 0x08 124 #define MOD_WIN_R 0x80 125 /* internal */ 126 #define MOD_EJECT 0x0100 127 #define MOD_FN 0x0200 128 uint8_t keycode[UKBD_NKEYCODE]; 129 }; 130 131 enum { 132 UKBD_INTR_DT, 133 UKBD_CTRL_LED, 134 UKBD_N_TRANSFER, 135 }; 136 137 struct ukbd_softc { 138 keyboard_t sc_kbd; 139 keymap_t sc_keymap; 140 accentmap_t sc_accmap; 141 fkeytab_t sc_fkeymap[UKBD_NFKEY]; 142 struct hid_location sc_loc_apple_eject; 143 struct hid_location sc_loc_apple_fn; 144 struct hid_location sc_loc_ctrl_l; 145 struct hid_location sc_loc_ctrl_r; 146 struct hid_location sc_loc_shift_l; 147 struct hid_location sc_loc_shift_r; 148 struct hid_location sc_loc_alt_l; 149 struct hid_location sc_loc_alt_r; 150 struct hid_location sc_loc_win_l; 151 struct hid_location sc_loc_win_r; 152 struct hid_location sc_loc_events; 153 struct hid_location sc_loc_numlock; 154 struct hid_location sc_loc_capslock; 155 struct hid_location sc_loc_scrolllock; 156 struct usb_callout sc_callout; 157 struct ukbd_data sc_ndata; 158 struct ukbd_data sc_odata; 159 160 struct thread *sc_poll_thread; 161 struct usb_device *sc_udev; 162 struct usb_interface *sc_iface; 163 struct usb_xfer *sc_xfer[UKBD_N_TRANSFER]; 164 165 uint32_t sc_ntime[UKBD_NKEYCODE]; 166 uint32_t sc_otime[UKBD_NKEYCODE]; 167 uint32_t sc_input[UKBD_IN_BUF_SIZE]; /* input buffer */ 168 uint32_t sc_time_ms; 169 uint32_t sc_composed_char; /* composed char code, if non-zero */ 170 #ifdef UKBD_EMULATE_ATSCANCODE 171 uint32_t sc_buffered_char[2]; 172 #endif 173 uint32_t sc_flags; /* flags */ 174 #define UKBD_FLAG_COMPOSE 0x00000001 175 #define UKBD_FLAG_POLLING 0x00000002 176 #define UKBD_FLAG_SET_LEDS 0x00000004 177 #define UKBD_FLAG_ATTACHED 0x00000010 178 #define UKBD_FLAG_GONE 0x00000020 179 180 #define UKBD_FLAG_HID_MASK 0x003fffc0 181 #define UKBD_FLAG_APPLE_EJECT 0x00000040 182 #define UKBD_FLAG_APPLE_FN 0x00000080 183 #define UKBD_FLAG_APPLE_SWAP 0x00000100 184 #define UKBD_FLAG_TIMER_RUNNING 0x00000200 185 #define UKBD_FLAG_CTRL_L 0x00000400 186 #define UKBD_FLAG_CTRL_R 0x00000800 187 #define UKBD_FLAG_SHIFT_L 0x00001000 188 #define UKBD_FLAG_SHIFT_R 0x00002000 189 #define UKBD_FLAG_ALT_L 0x00004000 190 #define UKBD_FLAG_ALT_R 0x00008000 191 #define UKBD_FLAG_WIN_L 0x00010000 192 #define UKBD_FLAG_WIN_R 0x00020000 193 #define UKBD_FLAG_EVENTS 0x00040000 194 #define UKBD_FLAG_NUMLOCK 0x00080000 195 #define UKBD_FLAG_CAPSLOCK 0x00100000 196 #define UKBD_FLAG_SCROLLLOCK 0x00200000 197 198 int sc_mode; /* input mode (K_XLATE,K_RAW,K_CODE) */ 199 int sc_state; /* shift/lock key state */ 200 int sc_accents; /* accent key index (> 0) */ 201 int sc_led_size; 202 int sc_kbd_size; 203 204 uint16_t sc_inputs; 205 uint16_t sc_inputhead; 206 uint16_t sc_inputtail; 207 uint16_t sc_modifiers; 208 209 uint8_t sc_leds; /* store for async led requests */ 210 uint8_t sc_iface_index; 211 uint8_t sc_iface_no; 212 uint8_t sc_id_apple_eject; 213 uint8_t sc_id_apple_fn; 214 uint8_t sc_id_ctrl_l; 215 uint8_t sc_id_ctrl_r; 216 uint8_t sc_id_shift_l; 217 uint8_t sc_id_shift_r; 218 uint8_t sc_id_alt_l; 219 uint8_t sc_id_alt_r; 220 uint8_t sc_id_win_l; 221 uint8_t sc_id_win_r; 222 uint8_t sc_id_event; 223 uint8_t sc_id_numlock; 224 uint8_t sc_id_capslock; 225 uint8_t sc_id_scrolllock; 226 uint8_t sc_id_events; 227 uint8_t sc_kbd_id; 228 229 uint8_t sc_buffer[UKBD_BUFFER_SIZE]; 230 }; 231 232 #define KEY_ERROR 0x01 233 234 #define KEY_PRESS 0 235 #define KEY_RELEASE 0x400 236 #define KEY_INDEX(c) ((c) & 0xFF) 237 238 #define SCAN_PRESS 0 239 #define SCAN_RELEASE 0x80 240 #define SCAN_PREFIX_E0 0x100 241 #define SCAN_PREFIX_E1 0x200 242 #define SCAN_PREFIX_CTL 0x400 243 #define SCAN_PREFIX_SHIFT 0x800 244 #define SCAN_PREFIX (SCAN_PREFIX_E0 | SCAN_PREFIX_E1 | \ 245 SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT) 246 #define SCAN_CHAR(c) ((c) & 0x7f) 247 248 #define UKBD_LOCK() mtx_lock(&Giant) 249 #define UKBD_UNLOCK() mtx_unlock(&Giant) 250 251 #ifdef INVARIANTS 252 253 /* 254 * Assert that the lock is held in all contexts 255 * where the code can be executed. 256 */ 257 #define UKBD_LOCK_ASSERT() mtx_assert(&Giant, MA_OWNED) 258 259 /* 260 * Assert that the lock is held in the contexts 261 * where it really has to be so. 262 */ 263 #define UKBD_CTX_LOCK_ASSERT() \ 264 do { \ 265 if (!kdb_active && panicstr == NULL) \ 266 mtx_assert(&Giant, MA_OWNED); \ 267 } while (0) 268 #else 269 270 #define UKBD_LOCK_ASSERT() (void)0 271 #define UKBD_CTX_LOCK_ASSERT() (void)0 272 273 #endif 274 275 struct ukbd_mods { 276 uint32_t mask, key; 277 }; 278 279 static const struct ukbd_mods ukbd_mods[UKBD_NMOD] = { 280 {MOD_CONTROL_L, 0xe0}, 281 {MOD_CONTROL_R, 0xe4}, 282 {MOD_SHIFT_L, 0xe1}, 283 {MOD_SHIFT_R, 0xe5}, 284 {MOD_ALT_L, 0xe2}, 285 {MOD_ALT_R, 0xe6}, 286 {MOD_WIN_L, 0xe3}, 287 {MOD_WIN_R, 0xe7}, 288 }; 289 290 #define NN 0 /* no translation */ 291 /* 292 * Translate USB keycodes to AT keyboard scancodes. 293 */ 294 /* 295 * FIXME: Mac USB keyboard generates: 296 * 0x53: keypad NumLock/Clear 297 * 0x66: Power 298 * 0x67: keypad = 299 * 0x68: F13 300 * 0x69: F14 301 * 0x6a: F15 302 */ 303 static const uint8_t ukbd_trtab[256] = { 304 0, 0, 0, 0, 30, 48, 46, 32, /* 00 - 07 */ 305 18, 33, 34, 35, 23, 36, 37, 38, /* 08 - 0F */ 306 50, 49, 24, 25, 16, 19, 31, 20, /* 10 - 17 */ 307 22, 47, 17, 45, 21, 44, 2, 3, /* 18 - 1F */ 308 4, 5, 6, 7, 8, 9, 10, 11, /* 20 - 27 */ 309 28, 1, 14, 15, 57, 12, 13, 26, /* 28 - 2F */ 310 27, 43, 43, 39, 40, 41, 51, 52, /* 30 - 37 */ 311 53, 58, 59, 60, 61, 62, 63, 64, /* 38 - 3F */ 312 65, 66, 67, 68, 87, 88, 92, 70, /* 40 - 47 */ 313 104, 102, 94, 96, 103, 99, 101, 98, /* 48 - 4F */ 314 97, 100, 95, 69, 91, 55, 74, 78,/* 50 - 57 */ 315 89, 79, 80, 81, 75, 76, 77, 71, /* 58 - 5F */ 316 72, 73, 82, 83, 86, 107, 122, NN, /* 60 - 67 */ 317 NN, NN, NN, NN, NN, NN, NN, NN, /* 68 - 6F */ 318 NN, NN, NN, NN, 115, 108, 111, 113, /* 70 - 77 */ 319 109, 110, 112, 118, 114, 116, 117, 119, /* 78 - 7F */ 320 121, 120, NN, NN, NN, NN, NN, 123, /* 80 - 87 */ 321 124, 125, 126, 127, 128, NN, NN, NN, /* 88 - 8F */ 322 NN, NN, NN, NN, NN, NN, NN, NN, /* 90 - 97 */ 323 NN, NN, NN, NN, NN, NN, NN, NN, /* 98 - 9F */ 324 NN, NN, NN, NN, NN, NN, NN, NN, /* A0 - A7 */ 325 NN, NN, NN, NN, NN, NN, NN, NN, /* A8 - AF */ 326 NN, NN, NN, NN, NN, NN, NN, NN, /* B0 - B7 */ 327 NN, NN, NN, NN, NN, NN, NN, NN, /* B8 - BF */ 328 NN, NN, NN, NN, NN, NN, NN, NN, /* C0 - C7 */ 329 NN, NN, NN, NN, NN, NN, NN, NN, /* C8 - CF */ 330 NN, NN, NN, NN, NN, NN, NN, NN, /* D0 - D7 */ 331 NN, NN, NN, NN, NN, NN, NN, NN, /* D8 - DF */ 332 29, 42, 56, 105, 90, 54, 93, 106, /* E0 - E7 */ 333 NN, NN, NN, NN, NN, NN, NN, NN, /* E8 - EF */ 334 NN, NN, NN, NN, NN, NN, NN, NN, /* F0 - F7 */ 335 NN, NN, NN, NN, NN, NN, NN, NN, /* F8 - FF */ 336 }; 337 338 static const uint8_t ukbd_boot_desc[] = { 339 0x05, 0x01, 0x09, 0x06, 0xa1, 340 0x01, 0x05, 0x07, 0x19, 0xe0, 341 0x29, 0xe7, 0x15, 0x00, 0x25, 342 0x01, 0x75, 0x01, 0x95, 0x08, 343 0x81, 0x02, 0x95, 0x01, 0x75, 344 0x08, 0x81, 0x01, 0x95, 0x03, 345 0x75, 0x01, 0x05, 0x08, 0x19, 346 0x01, 0x29, 0x03, 0x91, 0x02, 347 0x95, 0x05, 0x75, 0x01, 0x91, 348 0x01, 0x95, 0x06, 0x75, 0x08, 349 0x15, 0x00, 0x26, 0xff, 0x00, 350 0x05, 0x07, 0x19, 0x00, 0x2a, 351 0xff, 0x00, 0x81, 0x00, 0xc0 352 }; 353 354 /* prototypes */ 355 static void ukbd_timeout(void *); 356 static void ukbd_set_leds(struct ukbd_softc *, uint8_t); 357 static int ukbd_set_typematic(keyboard_t *, int); 358 #ifdef UKBD_EMULATE_ATSCANCODE 359 static int ukbd_key2scan(struct ukbd_softc *, int, int, int); 360 #endif 361 static uint32_t ukbd_read_char(keyboard_t *, int); 362 static void ukbd_clear_state(keyboard_t *); 363 static int ukbd_ioctl(keyboard_t *, u_long, caddr_t); 364 static int ukbd_enable(keyboard_t *); 365 static int ukbd_disable(keyboard_t *); 366 static void ukbd_interrupt(struct ukbd_softc *); 367 static void ukbd_event_keyinput(struct ukbd_softc *); 368 369 static device_probe_t ukbd_probe; 370 static device_attach_t ukbd_attach; 371 static device_detach_t ukbd_detach; 372 static device_resume_t ukbd_resume; 373 374 static uint8_t 375 ukbd_any_key_pressed(struct ukbd_softc *sc) 376 { 377 uint8_t i; 378 uint8_t j; 379 380 for (j = i = 0; i < UKBD_NKEYCODE; i++) 381 j |= sc->sc_odata.keycode[i]; 382 383 return (j ? 1 : 0); 384 } 385 386 static void 387 ukbd_start_timer(struct ukbd_softc *sc) 388 { 389 sc->sc_flags |= UKBD_FLAG_TIMER_RUNNING; 390 usb_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc); 391 } 392 393 static void 394 ukbd_put_key(struct ukbd_softc *sc, uint32_t key) 395 { 396 397 UKBD_CTX_LOCK_ASSERT(); 398 399 DPRINTF("0x%02x (%d) %s\n", key, key, 400 (key & KEY_RELEASE) ? "released" : "pressed"); 401 402 if (sc->sc_inputs < UKBD_IN_BUF_SIZE) { 403 sc->sc_input[sc->sc_inputtail] = key; 404 ++(sc->sc_inputs); 405 ++(sc->sc_inputtail); 406 if (sc->sc_inputtail >= UKBD_IN_BUF_SIZE) { 407 sc->sc_inputtail = 0; 408 } 409 } else { 410 DPRINTF("input buffer is full\n"); 411 } 412 } 413 414 static void 415 ukbd_do_poll(struct ukbd_softc *sc, uint8_t wait) 416 { 417 418 UKBD_CTX_LOCK_ASSERT(); 419 KASSERT((sc->sc_flags & UKBD_FLAG_POLLING) != 0, 420 ("ukbd_do_poll called when not polling\n")); 421 DPRINTFN(2, "polling\n"); 422 423 if (!kdb_active && !SCHEDULER_STOPPED()) { 424 /* 425 * In this context the kernel is polling for input, 426 * but the USB subsystem works in normal interrupt-driven 427 * mode, so we just wait on the USB threads to do the job. 428 * Note that we currently hold the Giant, but it's also used 429 * as the transfer mtx, so we must release it while waiting. 430 */ 431 while (sc->sc_inputs == 0) { 432 /* 433 * Give USB threads a chance to run. Note that 434 * kern_yield performs DROP_GIANT + PICKUP_GIANT. 435 */ 436 kern_yield(PRI_UNCHANGED); 437 if (!wait) 438 break; 439 } 440 return; 441 } 442 443 while (sc->sc_inputs == 0) { 444 445 usbd_transfer_poll(sc->sc_xfer, UKBD_N_TRANSFER); 446 447 /* Delay-optimised support for repetition of keys */ 448 if (ukbd_any_key_pressed(sc)) { 449 /* a key is pressed - need timekeeping */ 450 DELAY(1000); 451 452 /* 1 millisecond has passed */ 453 sc->sc_time_ms += 1; 454 } 455 456 ukbd_interrupt(sc); 457 458 if (!wait) 459 break; 460 } 461 } 462 463 static int32_t 464 ukbd_get_key(struct ukbd_softc *sc, uint8_t wait) 465 { 466 int32_t c; 467 468 UKBD_CTX_LOCK_ASSERT(); 469 KASSERT((!kdb_active && !SCHEDULER_STOPPED()) 470 || (sc->sc_flags & UKBD_FLAG_POLLING) != 0, 471 ("not polling in kdb or panic\n")); 472 473 if (sc->sc_inputs == 0 && 474 (sc->sc_flags & UKBD_FLAG_GONE) == 0) { 475 /* start transfer, if not already started */ 476 usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); 477 } 478 479 if (sc->sc_flags & UKBD_FLAG_POLLING) 480 ukbd_do_poll(sc, wait); 481 482 if (sc->sc_inputs == 0) { 483 c = -1; 484 } else { 485 c = sc->sc_input[sc->sc_inputhead]; 486 --(sc->sc_inputs); 487 ++(sc->sc_inputhead); 488 if (sc->sc_inputhead >= UKBD_IN_BUF_SIZE) { 489 sc->sc_inputhead = 0; 490 } 491 } 492 return (c); 493 } 494 495 static void 496 ukbd_interrupt(struct ukbd_softc *sc) 497 { 498 uint32_t n_mod; 499 uint32_t o_mod; 500 uint32_t now = sc->sc_time_ms; 501 uint32_t dtime; 502 uint8_t key; 503 uint8_t i; 504 uint8_t j; 505 506 UKBD_CTX_LOCK_ASSERT(); 507 508 if (sc->sc_ndata.keycode[0] == KEY_ERROR) 509 return; 510 511 n_mod = sc->sc_ndata.modifiers; 512 o_mod = sc->sc_odata.modifiers; 513 if (n_mod != o_mod) { 514 for (i = 0; i < UKBD_NMOD; i++) { 515 if ((n_mod & ukbd_mods[i].mask) != 516 (o_mod & ukbd_mods[i].mask)) { 517 ukbd_put_key(sc, ukbd_mods[i].key | 518 ((n_mod & ukbd_mods[i].mask) ? 519 KEY_PRESS : KEY_RELEASE)); 520 } 521 } 522 } 523 /* Check for released keys. */ 524 for (i = 0; i < UKBD_NKEYCODE; i++) { 525 key = sc->sc_odata.keycode[i]; 526 if (key == 0) { 527 continue; 528 } 529 for (j = 0; j < UKBD_NKEYCODE; j++) { 530 if (sc->sc_ndata.keycode[j] == 0) { 531 continue; 532 } 533 if (key == sc->sc_ndata.keycode[j]) { 534 goto rfound; 535 } 536 } 537 ukbd_put_key(sc, key | KEY_RELEASE); 538 rfound: ; 539 } 540 541 /* Check for pressed keys. */ 542 for (i = 0; i < UKBD_NKEYCODE; i++) { 543 key = sc->sc_ndata.keycode[i]; 544 if (key == 0) { 545 continue; 546 } 547 sc->sc_ntime[i] = now + sc->sc_kbd.kb_delay1; 548 for (j = 0; j < UKBD_NKEYCODE; j++) { 549 if (sc->sc_odata.keycode[j] == 0) { 550 continue; 551 } 552 if (key == sc->sc_odata.keycode[j]) { 553 554 /* key is still pressed */ 555 556 sc->sc_ntime[i] = sc->sc_otime[j]; 557 dtime = (sc->sc_otime[j] - now); 558 559 if (!(dtime & 0x80000000)) { 560 /* time has not elapsed */ 561 goto pfound; 562 } 563 sc->sc_ntime[i] = now + sc->sc_kbd.kb_delay2; 564 break; 565 } 566 } 567 ukbd_put_key(sc, key | KEY_PRESS); 568 569 /* 570 * If any other key is presently down, force its repeat to be 571 * well in the future (100s). This makes the last key to be 572 * pressed do the autorepeat. 573 */ 574 for (j = 0; j != UKBD_NKEYCODE; j++) { 575 if (j != i) 576 sc->sc_ntime[j] = now + (100 * 1000); 577 } 578 pfound: ; 579 } 580 581 sc->sc_odata = sc->sc_ndata; 582 583 memcpy(sc->sc_otime, sc->sc_ntime, sizeof(sc->sc_otime)); 584 585 ukbd_event_keyinput(sc); 586 } 587 588 static void 589 ukbd_event_keyinput(struct ukbd_softc *sc) 590 { 591 int c; 592 593 UKBD_CTX_LOCK_ASSERT(); 594 595 if ((sc->sc_flags & UKBD_FLAG_POLLING) != 0) 596 return; 597 598 if (sc->sc_inputs == 0) 599 return; 600 601 if (KBD_IS_ACTIVE(&sc->sc_kbd) && 602 KBD_IS_BUSY(&sc->sc_kbd)) { 603 /* let the callback function process the input */ 604 (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT, 605 sc->sc_kbd.kb_callback.kc_arg); 606 } else { 607 /* read and discard the input, no one is waiting for it */ 608 do { 609 c = ukbd_read_char(&sc->sc_kbd, 0); 610 } while (c != NOKEY); 611 } 612 } 613 614 static void 615 ukbd_timeout(void *arg) 616 { 617 struct ukbd_softc *sc = arg; 618 619 UKBD_LOCK_ASSERT(); 620 621 sc->sc_time_ms += 25; /* milliseconds */ 622 623 ukbd_interrupt(sc); 624 625 /* Make sure any leftover key events gets read out */ 626 ukbd_event_keyinput(sc); 627 628 if (ukbd_any_key_pressed(sc) || (sc->sc_inputs != 0)) { 629 ukbd_start_timer(sc); 630 } else { 631 sc->sc_flags &= ~UKBD_FLAG_TIMER_RUNNING; 632 } 633 } 634 635 static uint8_t 636 ukbd_apple_fn(uint8_t keycode) { 637 switch (keycode) { 638 case 0x28: return 0x49; /* RETURN -> INSERT */ 639 case 0x2a: return 0x4c; /* BACKSPACE -> DEL */ 640 case 0x50: return 0x4a; /* LEFT ARROW -> HOME */ 641 case 0x4f: return 0x4d; /* RIGHT ARROW -> END */ 642 case 0x52: return 0x4b; /* UP ARROW -> PGUP */ 643 case 0x51: return 0x4e; /* DOWN ARROW -> PGDN */ 644 default: return keycode; 645 } 646 } 647 648 static uint8_t 649 ukbd_apple_swap(uint8_t keycode) { 650 switch (keycode) { 651 case 0x35: return 0x64; 652 case 0x64: return 0x35; 653 default: return keycode; 654 } 655 } 656 657 static void 658 ukbd_intr_callback(struct usb_xfer *xfer, usb_error_t error) 659 { 660 struct ukbd_softc *sc = usbd_xfer_softc(xfer); 661 struct usb_page_cache *pc; 662 uint8_t i; 663 uint8_t offset; 664 uint8_t id; 665 int len; 666 667 UKBD_LOCK_ASSERT(); 668 669 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 670 pc = usbd_xfer_get_frame(xfer, 0); 671 672 switch (USB_GET_STATE(xfer)) { 673 case USB_ST_TRANSFERRED: 674 DPRINTF("actlen=%d bytes\n", len); 675 676 if (len == 0) { 677 DPRINTF("zero length data\n"); 678 goto tr_setup; 679 } 680 681 if (sc->sc_kbd_id != 0) { 682 /* check and remove HID ID byte */ 683 usbd_copy_out(pc, 0, &id, 1); 684 offset = 1; 685 len--; 686 if (len == 0) { 687 DPRINTF("zero length data\n"); 688 goto tr_setup; 689 } 690 } else { 691 offset = 0; 692 id = 0; 693 } 694 695 if (len > UKBD_BUFFER_SIZE) 696 len = UKBD_BUFFER_SIZE; 697 698 /* get data */ 699 usbd_copy_out(pc, offset, sc->sc_buffer, len); 700 701 /* clear temporary storage */ 702 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); 703 704 /* scan through HID data */ 705 if ((sc->sc_flags & UKBD_FLAG_APPLE_EJECT) && 706 (id == sc->sc_id_apple_eject)) { 707 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_apple_eject)) 708 sc->sc_modifiers |= MOD_EJECT; 709 else 710 sc->sc_modifiers &= ~MOD_EJECT; 711 } 712 if ((sc->sc_flags & UKBD_FLAG_APPLE_FN) && 713 (id == sc->sc_id_apple_fn)) { 714 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_apple_fn)) 715 sc->sc_modifiers |= MOD_FN; 716 else 717 sc->sc_modifiers &= ~MOD_FN; 718 } 719 if ((sc->sc_flags & UKBD_FLAG_CTRL_L) && 720 (id == sc->sc_id_ctrl_l)) { 721 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_ctrl_l)) 722 sc-> sc_modifiers |= MOD_CONTROL_L; 723 else 724 sc-> sc_modifiers &= ~MOD_CONTROL_L; 725 } 726 if ((sc->sc_flags & UKBD_FLAG_CTRL_R) && 727 (id == sc->sc_id_ctrl_r)) { 728 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_ctrl_r)) 729 sc->sc_modifiers |= MOD_CONTROL_R; 730 else 731 sc->sc_modifiers &= ~MOD_CONTROL_R; 732 } 733 if ((sc->sc_flags & UKBD_FLAG_SHIFT_L) && 734 (id == sc->sc_id_shift_l)) { 735 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_shift_l)) 736 sc->sc_modifiers |= MOD_SHIFT_L; 737 else 738 sc->sc_modifiers &= ~MOD_SHIFT_L; 739 } 740 if ((sc->sc_flags & UKBD_FLAG_SHIFT_R) && 741 (id == sc->sc_id_shift_r)) { 742 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_shift_r)) 743 sc->sc_modifiers |= MOD_SHIFT_R; 744 else 745 sc->sc_modifiers &= ~MOD_SHIFT_R; 746 } 747 if ((sc->sc_flags & UKBD_FLAG_ALT_L) && 748 (id == sc->sc_id_alt_l)) { 749 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_alt_l)) 750 sc->sc_modifiers |= MOD_ALT_L; 751 else 752 sc->sc_modifiers &= ~MOD_ALT_L; 753 } 754 if ((sc->sc_flags & UKBD_FLAG_ALT_R) && 755 (id == sc->sc_id_alt_r)) { 756 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_alt_r)) 757 sc->sc_modifiers |= MOD_ALT_R; 758 else 759 sc->sc_modifiers &= ~MOD_ALT_R; 760 } 761 if ((sc->sc_flags & UKBD_FLAG_WIN_L) && 762 (id == sc->sc_id_win_l)) { 763 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_win_l)) 764 sc->sc_modifiers |= MOD_WIN_L; 765 else 766 sc->sc_modifiers &= ~MOD_WIN_L; 767 } 768 if ((sc->sc_flags & UKBD_FLAG_WIN_R) && 769 (id == sc->sc_id_win_r)) { 770 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_win_r)) 771 sc->sc_modifiers |= MOD_WIN_R; 772 else 773 sc->sc_modifiers &= ~MOD_WIN_R; 774 } 775 776 sc->sc_ndata.modifiers = sc->sc_modifiers; 777 778 if ((sc->sc_flags & UKBD_FLAG_EVENTS) && 779 (id == sc->sc_id_events)) { 780 i = sc->sc_loc_events.count; 781 if (i > UKBD_NKEYCODE) 782 i = UKBD_NKEYCODE; 783 if (i > len) 784 i = len; 785 while (i--) { 786 sc->sc_ndata.keycode[i] = 787 hid_get_data(sc->sc_buffer + i, len - i, 788 &sc->sc_loc_events); 789 } 790 } 791 792 #ifdef USB_DEBUG 793 DPRINTF("modifiers = 0x%04x\n", (int)sc->sc_modifiers); 794 for (i = 0; i < UKBD_NKEYCODE; i++) { 795 if (sc->sc_ndata.keycode[i]) { 796 DPRINTF("[%d] = 0x%02x\n", 797 (int)i, (int)sc->sc_ndata.keycode[i]); 798 } 799 } 800 #endif 801 if (sc->sc_modifiers & MOD_FN) { 802 for (i = 0; i < UKBD_NKEYCODE; i++) { 803 sc->sc_ndata.keycode[i] = 804 ukbd_apple_fn(sc->sc_ndata.keycode[i]); 805 } 806 } 807 808 if (sc->sc_flags & UKBD_FLAG_APPLE_SWAP) { 809 for (i = 0; i < UKBD_NKEYCODE; i++) { 810 sc->sc_ndata.keycode[i] = 811 ukbd_apple_swap(sc->sc_ndata.keycode[i]); 812 } 813 } 814 815 ukbd_interrupt(sc); 816 817 if (!(sc->sc_flags & UKBD_FLAG_TIMER_RUNNING)) { 818 if (ukbd_any_key_pressed(sc)) { 819 ukbd_start_timer(sc); 820 } 821 } 822 823 case USB_ST_SETUP: 824 tr_setup: 825 if (sc->sc_inputs < UKBD_IN_BUF_FULL) { 826 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 827 usbd_transfer_submit(xfer); 828 } else { 829 DPRINTF("input queue is full!\n"); 830 } 831 break; 832 833 default: /* Error */ 834 DPRINTF("error=%s\n", usbd_errstr(error)); 835 836 if (error != USB_ERR_CANCELLED) { 837 /* try to clear stall first */ 838 usbd_xfer_set_stall(xfer); 839 goto tr_setup; 840 } 841 break; 842 } 843 } 844 845 static void 846 ukbd_set_leds_callback(struct usb_xfer *xfer, usb_error_t error) 847 { 848 struct ukbd_softc *sc = usbd_xfer_softc(xfer); 849 struct usb_device_request req; 850 struct usb_page_cache *pc; 851 uint8_t id; 852 uint8_t any; 853 int len; 854 855 UKBD_LOCK_ASSERT(); 856 857 #ifdef USB_DEBUG 858 if (ukbd_no_leds) 859 return; 860 #endif 861 862 switch (USB_GET_STATE(xfer)) { 863 case USB_ST_TRANSFERRED: 864 case USB_ST_SETUP: 865 if (!(sc->sc_flags & UKBD_FLAG_SET_LEDS)) 866 break; 867 sc->sc_flags &= ~UKBD_FLAG_SET_LEDS; 868 869 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 870 req.bRequest = UR_SET_REPORT; 871 USETW2(req.wValue, UHID_OUTPUT_REPORT, 0); 872 req.wIndex[0] = sc->sc_iface_no; 873 req.wIndex[1] = 0; 874 req.wLength[1] = 0; 875 876 memset(sc->sc_buffer, 0, UKBD_BUFFER_SIZE); 877 878 id = 0; 879 any = 0; 880 881 /* Assumption: All led bits must be in the same ID. */ 882 883 if (sc->sc_flags & UKBD_FLAG_NUMLOCK) { 884 if (sc->sc_leds & NLKED) { 885 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1, 886 &sc->sc_loc_numlock, 1); 887 } 888 id = sc->sc_id_numlock; 889 any = 1; 890 } 891 892 if (sc->sc_flags & UKBD_FLAG_SCROLLLOCK) { 893 if (sc->sc_leds & SLKED) { 894 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1, 895 &sc->sc_loc_scrolllock, 1); 896 } 897 id = sc->sc_id_scrolllock; 898 any = 1; 899 } 900 901 if (sc->sc_flags & UKBD_FLAG_CAPSLOCK) { 902 if (sc->sc_leds & CLKED) { 903 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1, 904 &sc->sc_loc_capslock, 1); 905 } 906 id = sc->sc_id_capslock; 907 any = 1; 908 } 909 910 /* if no leds, nothing to do */ 911 if (!any) 912 break; 913 914 /* range check output report length */ 915 len = sc->sc_led_size; 916 if (len > (UKBD_BUFFER_SIZE - 1)) 917 len = (UKBD_BUFFER_SIZE - 1); 918 919 /* check if we need to prefix an ID byte */ 920 sc->sc_buffer[0] = id; 921 922 pc = usbd_xfer_get_frame(xfer, 1); 923 if (id != 0) { 924 len++; 925 usbd_copy_in(pc, 0, sc->sc_buffer, len); 926 } else { 927 usbd_copy_in(pc, 0, sc->sc_buffer + 1, len); 928 } 929 req.wLength[0] = len; 930 usbd_xfer_set_frame_len(xfer, 1, len); 931 932 DPRINTF("len=%d, id=%d\n", len, id); 933 934 /* setup control request last */ 935 pc = usbd_xfer_get_frame(xfer, 0); 936 usbd_copy_in(pc, 0, &req, sizeof(req)); 937 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 938 939 /* start data transfer */ 940 usbd_xfer_set_frames(xfer, 2); 941 usbd_transfer_submit(xfer); 942 break; 943 944 default: /* Error */ 945 DPRINTFN(1, "error=%s\n", usbd_errstr(error)); 946 break; 947 } 948 } 949 950 static const struct usb_config ukbd_config[UKBD_N_TRANSFER] = { 951 952 [UKBD_INTR_DT] = { 953 .type = UE_INTERRUPT, 954 .endpoint = UE_ADDR_ANY, 955 .direction = UE_DIR_IN, 956 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 957 .bufsize = 0, /* use wMaxPacketSize */ 958 .callback = &ukbd_intr_callback, 959 }, 960 961 [UKBD_CTRL_LED] = { 962 .type = UE_CONTROL, 963 .endpoint = 0x00, /* Control pipe */ 964 .direction = UE_DIR_ANY, 965 .bufsize = sizeof(struct usb_device_request) + UKBD_BUFFER_SIZE, 966 .callback = &ukbd_set_leds_callback, 967 .timeout = 1000, /* 1 second */ 968 }, 969 }; 970 971 /* A match on these entries will load ukbd */ 972 static const STRUCT_USB_HOST_ID __used ukbd_devs[] = { 973 {USB_IFACE_CLASS(UICLASS_HID), 974 USB_IFACE_SUBCLASS(UISUBCLASS_BOOT), 975 USB_IFACE_PROTOCOL(UIPROTO_BOOT_KEYBOARD),}, 976 }; 977 978 static int 979 ukbd_probe(device_t dev) 980 { 981 keyboard_switch_t *sw = kbd_get_switch(UKBD_DRIVER_NAME); 982 struct usb_attach_arg *uaa = device_get_ivars(dev); 983 void *d_ptr; 984 int error; 985 uint16_t d_len; 986 987 UKBD_LOCK_ASSERT(); 988 DPRINTFN(11, "\n"); 989 990 if (sw == NULL) { 991 return (ENXIO); 992 } 993 if (uaa->usb_mode != USB_MODE_HOST) { 994 return (ENXIO); 995 } 996 997 if (uaa->info.bInterfaceClass != UICLASS_HID) 998 return (ENXIO); 999 1000 if (usb_test_quirk(uaa, UQ_KBD_IGNORE)) 1001 return (ENXIO); 1002 1003 if ((uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) && 1004 (uaa->info.bInterfaceProtocol == UIPROTO_BOOT_KEYBOARD)) 1005 return (BUS_PROBE_DEFAULT); 1006 1007 error = usbd_req_get_hid_desc(uaa->device, NULL, 1008 &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex); 1009 1010 if (error) 1011 return (ENXIO); 1012 1013 if (hid_is_keyboard(d_ptr, d_len)) { 1014 if (hid_is_mouse(d_ptr, d_len)) { 1015 /* 1016 * NOTE: We currently don't support USB mouse 1017 * and USB keyboard on the same USB endpoint. 1018 * Let "ums" driver win. 1019 */ 1020 error = ENXIO; 1021 } else { 1022 error = BUS_PROBE_DEFAULT; 1023 } 1024 } else { 1025 error = ENXIO; 1026 } 1027 free(d_ptr, M_TEMP); 1028 return (error); 1029 } 1030 1031 static void 1032 ukbd_parse_hid(struct ukbd_softc *sc, const uint8_t *ptr, uint32_t len) 1033 { 1034 uint32_t flags; 1035 1036 /* reset detected bits */ 1037 sc->sc_flags &= ~UKBD_FLAG_HID_MASK; 1038 1039 /* check if there is an ID byte */ 1040 sc->sc_kbd_size = hid_report_size(ptr, len, 1041 hid_input, &sc->sc_kbd_id); 1042 1043 /* investigate if this is an Apple Keyboard */ 1044 if (hid_locate(ptr, len, 1045 HID_USAGE2(HUP_CONSUMER, HUG_APPLE_EJECT), 1046 hid_input, 0, &sc->sc_loc_apple_eject, &flags, 1047 &sc->sc_id_apple_eject)) { 1048 if (flags & HIO_VARIABLE) 1049 sc->sc_flags |= UKBD_FLAG_APPLE_EJECT | 1050 UKBD_FLAG_APPLE_SWAP; 1051 DPRINTFN(1, "Found Apple eject-key\n"); 1052 } 1053 if (hid_locate(ptr, len, 1054 HID_USAGE2(0xFFFF, 0x0003), 1055 hid_input, 0, &sc->sc_loc_apple_fn, &flags, 1056 &sc->sc_id_apple_fn)) { 1057 if (flags & HIO_VARIABLE) 1058 sc->sc_flags |= UKBD_FLAG_APPLE_FN; 1059 DPRINTFN(1, "Found Apple FN-key\n"); 1060 } 1061 /* figure out some keys */ 1062 if (hid_locate(ptr, len, 1063 HID_USAGE2(HUP_KEYBOARD, 0xE0), 1064 hid_input, 0, &sc->sc_loc_ctrl_l, &flags, 1065 &sc->sc_id_ctrl_l)) { 1066 if (flags & HIO_VARIABLE) 1067 sc->sc_flags |= UKBD_FLAG_CTRL_L; 1068 DPRINTFN(1, "Found left control\n"); 1069 } 1070 if (hid_locate(ptr, len, 1071 HID_USAGE2(HUP_KEYBOARD, 0xE4), 1072 hid_input, 0, &sc->sc_loc_ctrl_r, &flags, 1073 &sc->sc_id_ctrl_r)) { 1074 if (flags & HIO_VARIABLE) 1075 sc->sc_flags |= UKBD_FLAG_CTRL_R; 1076 DPRINTFN(1, "Found right control\n"); 1077 } 1078 if (hid_locate(ptr, len, 1079 HID_USAGE2(HUP_KEYBOARD, 0xE1), 1080 hid_input, 0, &sc->sc_loc_shift_l, &flags, 1081 &sc->sc_id_shift_l)) { 1082 if (flags & HIO_VARIABLE) 1083 sc->sc_flags |= UKBD_FLAG_SHIFT_L; 1084 DPRINTFN(1, "Found left shift\n"); 1085 } 1086 if (hid_locate(ptr, len, 1087 HID_USAGE2(HUP_KEYBOARD, 0xE5), 1088 hid_input, 0, &sc->sc_loc_shift_r, &flags, 1089 &sc->sc_id_shift_r)) { 1090 if (flags & HIO_VARIABLE) 1091 sc->sc_flags |= UKBD_FLAG_SHIFT_R; 1092 DPRINTFN(1, "Found right shift\n"); 1093 } 1094 if (hid_locate(ptr, len, 1095 HID_USAGE2(HUP_KEYBOARD, 0xE2), 1096 hid_input, 0, &sc->sc_loc_alt_l, &flags, 1097 &sc->sc_id_alt_l)) { 1098 if (flags & HIO_VARIABLE) 1099 sc->sc_flags |= UKBD_FLAG_ALT_L; 1100 DPRINTFN(1, "Found left alt\n"); 1101 } 1102 if (hid_locate(ptr, len, 1103 HID_USAGE2(HUP_KEYBOARD, 0xE6), 1104 hid_input, 0, &sc->sc_loc_alt_r, &flags, 1105 &sc->sc_id_alt_r)) { 1106 if (flags & HIO_VARIABLE) 1107 sc->sc_flags |= UKBD_FLAG_ALT_R; 1108 DPRINTFN(1, "Found right alt\n"); 1109 } 1110 if (hid_locate(ptr, len, 1111 HID_USAGE2(HUP_KEYBOARD, 0xE3), 1112 hid_input, 0, &sc->sc_loc_win_l, &flags, 1113 &sc->sc_id_win_l)) { 1114 if (flags & HIO_VARIABLE) 1115 sc->sc_flags |= UKBD_FLAG_WIN_L; 1116 DPRINTFN(1, "Found left GUI\n"); 1117 } 1118 if (hid_locate(ptr, len, 1119 HID_USAGE2(HUP_KEYBOARD, 0xE7), 1120 hid_input, 0, &sc->sc_loc_win_r, &flags, 1121 &sc->sc_id_win_r)) { 1122 if (flags & HIO_VARIABLE) 1123 sc->sc_flags |= UKBD_FLAG_WIN_R; 1124 DPRINTFN(1, "Found right GUI\n"); 1125 } 1126 /* figure out event buffer */ 1127 if (hid_locate(ptr, len, 1128 HID_USAGE2(HUP_KEYBOARD, 0x00), 1129 hid_input, 0, &sc->sc_loc_events, &flags, 1130 &sc->sc_id_events)) { 1131 if (flags & HIO_VARIABLE) { 1132 DPRINTFN(1, "Ignoring keyboard event control\n"); 1133 } else { 1134 sc->sc_flags |= UKBD_FLAG_EVENTS; 1135 DPRINTFN(1, "Found keyboard event array\n"); 1136 } 1137 } 1138 1139 /* figure out leds on keyboard */ 1140 sc->sc_led_size = hid_report_size(ptr, len, 1141 hid_output, NULL); 1142 1143 if (hid_locate(ptr, len, 1144 HID_USAGE2(HUP_LEDS, 0x01), 1145 hid_output, 0, &sc->sc_loc_numlock, &flags, 1146 &sc->sc_id_numlock)) { 1147 if (flags & HIO_VARIABLE) 1148 sc->sc_flags |= UKBD_FLAG_NUMLOCK; 1149 DPRINTFN(1, "Found keyboard numlock\n"); 1150 } 1151 if (hid_locate(ptr, len, 1152 HID_USAGE2(HUP_LEDS, 0x02), 1153 hid_output, 0, &sc->sc_loc_capslock, &flags, 1154 &sc->sc_id_capslock)) { 1155 if (flags & HIO_VARIABLE) 1156 sc->sc_flags |= UKBD_FLAG_CAPSLOCK; 1157 DPRINTFN(1, "Found keyboard capslock\n"); 1158 } 1159 if (hid_locate(ptr, len, 1160 HID_USAGE2(HUP_LEDS, 0x03), 1161 hid_output, 0, &sc->sc_loc_scrolllock, &flags, 1162 &sc->sc_id_scrolllock)) { 1163 if (flags & HIO_VARIABLE) 1164 sc->sc_flags |= UKBD_FLAG_SCROLLLOCK; 1165 DPRINTFN(1, "Found keyboard scrolllock\n"); 1166 } 1167 } 1168 1169 static int 1170 ukbd_attach(device_t dev) 1171 { 1172 struct ukbd_softc *sc = device_get_softc(dev); 1173 struct usb_attach_arg *uaa = device_get_ivars(dev); 1174 int unit = device_get_unit(dev); 1175 keyboard_t *kbd = &sc->sc_kbd; 1176 void *hid_ptr = NULL; 1177 usb_error_t err; 1178 uint16_t n; 1179 uint16_t hid_len; 1180 #ifdef USB_DEBUG 1181 int rate; 1182 #endif 1183 UKBD_LOCK_ASSERT(); 1184 1185 kbd_init_struct(kbd, UKBD_DRIVER_NAME, KB_OTHER, unit, 0, 0, 0); 1186 1187 kbd->kb_data = (void *)sc; 1188 1189 device_set_usb_desc(dev); 1190 1191 sc->sc_udev = uaa->device; 1192 sc->sc_iface = uaa->iface; 1193 sc->sc_iface_index = uaa->info.bIfaceIndex; 1194 sc->sc_iface_no = uaa->info.bIfaceNum; 1195 sc->sc_mode = K_XLATE; 1196 1197 usb_callout_init_mtx(&sc->sc_callout, &Giant, 0); 1198 1199 err = usbd_transfer_setup(uaa->device, 1200 &uaa->info.bIfaceIndex, sc->sc_xfer, ukbd_config, 1201 UKBD_N_TRANSFER, sc, &Giant); 1202 1203 if (err) { 1204 DPRINTF("error=%s\n", usbd_errstr(err)); 1205 goto detach; 1206 } 1207 /* setup default keyboard maps */ 1208 1209 sc->sc_keymap = key_map; 1210 sc->sc_accmap = accent_map; 1211 for (n = 0; n < UKBD_NFKEY; n++) { 1212 sc->sc_fkeymap[n] = fkey_tab[n]; 1213 } 1214 1215 kbd_set_maps(kbd, &sc->sc_keymap, &sc->sc_accmap, 1216 sc->sc_fkeymap, UKBD_NFKEY); 1217 1218 KBD_FOUND_DEVICE(kbd); 1219 1220 ukbd_clear_state(kbd); 1221 1222 /* 1223 * FIXME: set the initial value for lock keys in "sc_state" 1224 * according to the BIOS data? 1225 */ 1226 KBD_PROBE_DONE(kbd); 1227 1228 /* get HID descriptor */ 1229 err = usbd_req_get_hid_desc(uaa->device, NULL, &hid_ptr, 1230 &hid_len, M_TEMP, uaa->info.bIfaceIndex); 1231 1232 if (err == 0) { 1233 DPRINTF("Parsing HID descriptor of %d bytes\n", 1234 (int)hid_len); 1235 1236 ukbd_parse_hid(sc, hid_ptr, hid_len); 1237 1238 free(hid_ptr, M_TEMP); 1239 } 1240 1241 /* check if we should use the boot protocol */ 1242 if (usb_test_quirk(uaa, UQ_KBD_BOOTPROTO) || 1243 (err != 0) || (!(sc->sc_flags & UKBD_FLAG_EVENTS))) { 1244 1245 DPRINTF("Forcing boot protocol\n"); 1246 1247 err = usbd_req_set_protocol(sc->sc_udev, NULL, 1248 sc->sc_iface_index, 0); 1249 1250 if (err != 0) { 1251 DPRINTF("Set protocol error=%s (ignored)\n", 1252 usbd_errstr(err)); 1253 } 1254 1255 ukbd_parse_hid(sc, ukbd_boot_desc, sizeof(ukbd_boot_desc)); 1256 } 1257 1258 /* ignore if SETIDLE fails, hence it is not crucial */ 1259 usbd_req_set_idle(sc->sc_udev, NULL, sc->sc_iface_index, 0, 0); 1260 1261 ukbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state); 1262 1263 KBD_INIT_DONE(kbd); 1264 1265 if (kbd_register(kbd) < 0) { 1266 goto detach; 1267 } 1268 KBD_CONFIG_DONE(kbd); 1269 1270 ukbd_enable(kbd); 1271 1272 #ifdef KBD_INSTALL_CDEV 1273 if (kbd_attach(kbd)) { 1274 goto detach; 1275 } 1276 #endif 1277 sc->sc_flags |= UKBD_FLAG_ATTACHED; 1278 1279 if (bootverbose) { 1280 genkbd_diag(kbd, bootverbose); 1281 } 1282 1283 #ifdef USB_DEBUG 1284 /* check for polling rate override */ 1285 rate = ukbd_pollrate; 1286 if (rate > 0) { 1287 if (rate > 1000) 1288 rate = 1; 1289 else 1290 rate = 1000 / rate; 1291 1292 /* set new polling interval in ms */ 1293 usbd_xfer_set_interval(sc->sc_xfer[UKBD_INTR_DT], rate); 1294 } 1295 #endif 1296 /* start the keyboard */ 1297 usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); 1298 1299 return (0); /* success */ 1300 1301 detach: 1302 ukbd_detach(dev); 1303 return (ENXIO); /* error */ 1304 } 1305 1306 static int 1307 ukbd_detach(device_t dev) 1308 { 1309 struct ukbd_softc *sc = device_get_softc(dev); 1310 int error; 1311 1312 UKBD_LOCK_ASSERT(); 1313 1314 DPRINTF("\n"); 1315 1316 sc->sc_flags |= UKBD_FLAG_GONE; 1317 1318 usb_callout_stop(&sc->sc_callout); 1319 1320 /* kill any stuck keys */ 1321 if (sc->sc_flags & UKBD_FLAG_ATTACHED) { 1322 /* stop receiving events from the USB keyboard */ 1323 usbd_transfer_stop(sc->sc_xfer[UKBD_INTR_DT]); 1324 1325 /* release all leftover keys, if any */ 1326 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); 1327 1328 /* process releasing of all keys */ 1329 ukbd_interrupt(sc); 1330 } 1331 1332 ukbd_disable(&sc->sc_kbd); 1333 1334 #ifdef KBD_INSTALL_CDEV 1335 if (sc->sc_flags & UKBD_FLAG_ATTACHED) { 1336 error = kbd_detach(&sc->sc_kbd); 1337 if (error) { 1338 /* usb attach cannot return an error */ 1339 device_printf(dev, "WARNING: kbd_detach() " 1340 "returned non-zero! (ignored)\n"); 1341 } 1342 } 1343 #endif 1344 if (KBD_IS_CONFIGURED(&sc->sc_kbd)) { 1345 error = kbd_unregister(&sc->sc_kbd); 1346 if (error) { 1347 /* usb attach cannot return an error */ 1348 device_printf(dev, "WARNING: kbd_unregister() " 1349 "returned non-zero! (ignored)\n"); 1350 } 1351 } 1352 sc->sc_kbd.kb_flags = 0; 1353 1354 usbd_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER); 1355 1356 usb_callout_drain(&sc->sc_callout); 1357 1358 DPRINTF("%s: disconnected\n", 1359 device_get_nameunit(dev)); 1360 1361 return (0); 1362 } 1363 1364 static int 1365 ukbd_resume(device_t dev) 1366 { 1367 struct ukbd_softc *sc = device_get_softc(dev); 1368 1369 UKBD_LOCK_ASSERT(); 1370 1371 ukbd_clear_state(&sc->sc_kbd); 1372 1373 return (0); 1374 } 1375 1376 /* early keyboard probe, not supported */ 1377 static int 1378 ukbd_configure(int flags) 1379 { 1380 return (0); 1381 } 1382 1383 /* detect a keyboard, not used */ 1384 static int 1385 ukbd__probe(int unit, void *arg, int flags) 1386 { 1387 return (ENXIO); 1388 } 1389 1390 /* reset and initialize the device, not used */ 1391 static int 1392 ukbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 1393 { 1394 return (ENXIO); 1395 } 1396 1397 /* test the interface to the device, not used */ 1398 static int 1399 ukbd_test_if(keyboard_t *kbd) 1400 { 1401 return (0); 1402 } 1403 1404 /* finish using this keyboard, not used */ 1405 static int 1406 ukbd_term(keyboard_t *kbd) 1407 { 1408 return (ENXIO); 1409 } 1410 1411 /* keyboard interrupt routine, not used */ 1412 static int 1413 ukbd_intr(keyboard_t *kbd, void *arg) 1414 { 1415 return (0); 1416 } 1417 1418 /* lock the access to the keyboard, not used */ 1419 static int 1420 ukbd_lock(keyboard_t *kbd, int lock) 1421 { 1422 return (1); 1423 } 1424 1425 /* 1426 * Enable the access to the device; until this function is called, 1427 * the client cannot read from the keyboard. 1428 */ 1429 static int 1430 ukbd_enable(keyboard_t *kbd) 1431 { 1432 1433 UKBD_LOCK(); 1434 KBD_ACTIVATE(kbd); 1435 UKBD_UNLOCK(); 1436 1437 return (0); 1438 } 1439 1440 /* disallow the access to the device */ 1441 static int 1442 ukbd_disable(keyboard_t *kbd) 1443 { 1444 1445 UKBD_LOCK(); 1446 KBD_DEACTIVATE(kbd); 1447 UKBD_UNLOCK(); 1448 1449 return (0); 1450 } 1451 1452 /* check if data is waiting */ 1453 /* Currently unused. */ 1454 static int 1455 ukbd_check(keyboard_t *kbd) 1456 { 1457 struct ukbd_softc *sc = kbd->kb_data; 1458 1459 UKBD_CTX_LOCK_ASSERT(); 1460 1461 if (!KBD_IS_ACTIVE(kbd)) 1462 return (0); 1463 1464 if (sc->sc_flags & UKBD_FLAG_POLLING) 1465 ukbd_do_poll(sc, 0); 1466 1467 #ifdef UKBD_EMULATE_ATSCANCODE 1468 if (sc->sc_buffered_char[0]) { 1469 return (1); 1470 } 1471 #endif 1472 if (sc->sc_inputs > 0) { 1473 return (1); 1474 } 1475 return (0); 1476 } 1477 1478 /* check if char is waiting */ 1479 static int 1480 ukbd_check_char_locked(keyboard_t *kbd) 1481 { 1482 struct ukbd_softc *sc = kbd->kb_data; 1483 1484 UKBD_CTX_LOCK_ASSERT(); 1485 1486 if (!KBD_IS_ACTIVE(kbd)) 1487 return (0); 1488 1489 if ((sc->sc_composed_char > 0) && 1490 (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) { 1491 return (1); 1492 } 1493 return (ukbd_check(kbd)); 1494 } 1495 1496 static int 1497 ukbd_check_char(keyboard_t *kbd) 1498 { 1499 int result; 1500 1501 UKBD_LOCK(); 1502 result = ukbd_check_char_locked(kbd); 1503 UKBD_UNLOCK(); 1504 1505 return (result); 1506 } 1507 1508 /* read one byte from the keyboard if it's allowed */ 1509 /* Currently unused. */ 1510 static int 1511 ukbd_read(keyboard_t *kbd, int wait) 1512 { 1513 struct ukbd_softc *sc = kbd->kb_data; 1514 int32_t usbcode; 1515 #ifdef UKBD_EMULATE_ATSCANCODE 1516 uint32_t keycode; 1517 uint32_t scancode; 1518 1519 #endif 1520 1521 UKBD_CTX_LOCK_ASSERT(); 1522 1523 if (!KBD_IS_ACTIVE(kbd)) 1524 return (-1); 1525 1526 #ifdef UKBD_EMULATE_ATSCANCODE 1527 if (sc->sc_buffered_char[0]) { 1528 scancode = sc->sc_buffered_char[0]; 1529 if (scancode & SCAN_PREFIX) { 1530 sc->sc_buffered_char[0] &= ~SCAN_PREFIX; 1531 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1532 } 1533 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1534 sc->sc_buffered_char[1] = 0; 1535 return (scancode); 1536 } 1537 #endif /* UKBD_EMULATE_ATSCANCODE */ 1538 1539 /* XXX */ 1540 usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1541 if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1)) 1542 return (-1); 1543 1544 ++(kbd->kb_count); 1545 1546 #ifdef UKBD_EMULATE_ATSCANCODE 1547 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1548 if (keycode == NN) { 1549 return -1; 1550 } 1551 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers, 1552 (usbcode & KEY_RELEASE))); 1553 #else /* !UKBD_EMULATE_ATSCANCODE */ 1554 return (usbcode); 1555 #endif /* UKBD_EMULATE_ATSCANCODE */ 1556 } 1557 1558 /* read char from the keyboard */ 1559 static uint32_t 1560 ukbd_read_char_locked(keyboard_t *kbd, int wait) 1561 { 1562 struct ukbd_softc *sc = kbd->kb_data; 1563 uint32_t action; 1564 uint32_t keycode; 1565 int32_t usbcode; 1566 #ifdef UKBD_EMULATE_ATSCANCODE 1567 uint32_t scancode; 1568 #endif 1569 1570 UKBD_CTX_LOCK_ASSERT(); 1571 1572 if (!KBD_IS_ACTIVE(kbd)) 1573 return (NOKEY); 1574 1575 next_code: 1576 1577 /* do we have a composed char to return ? */ 1578 1579 if ((sc->sc_composed_char > 0) && 1580 (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) { 1581 1582 action = sc->sc_composed_char; 1583 sc->sc_composed_char = 0; 1584 1585 if (action > 0xFF) { 1586 goto errkey; 1587 } 1588 goto done; 1589 } 1590 #ifdef UKBD_EMULATE_ATSCANCODE 1591 1592 /* do we have a pending raw scan code? */ 1593 1594 if (sc->sc_mode == K_RAW) { 1595 scancode = sc->sc_buffered_char[0]; 1596 if (scancode) { 1597 if (scancode & SCAN_PREFIX) { 1598 sc->sc_buffered_char[0] = (scancode & ~SCAN_PREFIX); 1599 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1600 } 1601 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1602 sc->sc_buffered_char[1] = 0; 1603 return (scancode); 1604 } 1605 } 1606 #endif /* UKBD_EMULATE_ATSCANCODE */ 1607 1608 /* see if there is something in the keyboard port */ 1609 /* XXX */ 1610 usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1611 if (usbcode == -1) { 1612 return (NOKEY); 1613 } 1614 ++kbd->kb_count; 1615 1616 #ifdef UKBD_EMULATE_ATSCANCODE 1617 /* USB key index -> key code -> AT scan code */ 1618 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1619 if (keycode == NN) { 1620 return (NOKEY); 1621 } 1622 /* return an AT scan code for the K_RAW mode */ 1623 if (sc->sc_mode == K_RAW) { 1624 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers, 1625 (usbcode & KEY_RELEASE))); 1626 } 1627 #else /* !UKBD_EMULATE_ATSCANCODE */ 1628 1629 /* return the byte as is for the K_RAW mode */ 1630 if (sc->sc_mode == K_RAW) { 1631 return (usbcode); 1632 } 1633 /* USB key index -> key code */ 1634 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1635 if (keycode == NN) { 1636 return (NOKEY); 1637 } 1638 #endif /* UKBD_EMULATE_ATSCANCODE */ 1639 1640 switch (keycode) { 1641 case 0x38: /* left alt (compose key) */ 1642 if (usbcode & KEY_RELEASE) { 1643 if (sc->sc_flags & UKBD_FLAG_COMPOSE) { 1644 sc->sc_flags &= ~UKBD_FLAG_COMPOSE; 1645 1646 if (sc->sc_composed_char > 0xFF) { 1647 sc->sc_composed_char = 0; 1648 } 1649 } 1650 } else { 1651 if (!(sc->sc_flags & UKBD_FLAG_COMPOSE)) { 1652 sc->sc_flags |= UKBD_FLAG_COMPOSE; 1653 sc->sc_composed_char = 0; 1654 } 1655 } 1656 break; 1657 /* XXX: I don't like these... */ 1658 case 0x5c: /* print screen */ 1659 if (sc->sc_flags & ALTS) { 1660 keycode = 0x54; /* sysrq */ 1661 } 1662 break; 1663 case 0x68: /* pause/break */ 1664 if (sc->sc_flags & CTLS) { 1665 keycode = 0x6c; /* break */ 1666 } 1667 break; 1668 } 1669 1670 /* return the key code in the K_CODE mode */ 1671 if (usbcode & KEY_RELEASE) { 1672 keycode |= SCAN_RELEASE; 1673 } 1674 if (sc->sc_mode == K_CODE) { 1675 return (keycode); 1676 } 1677 /* compose a character code */ 1678 if (sc->sc_flags & UKBD_FLAG_COMPOSE) { 1679 switch (keycode) { 1680 /* key pressed, process it */ 1681 case 0x47: 1682 case 0x48: 1683 case 0x49: /* keypad 7,8,9 */ 1684 sc->sc_composed_char *= 10; 1685 sc->sc_composed_char += keycode - 0x40; 1686 goto check_composed; 1687 1688 case 0x4B: 1689 case 0x4C: 1690 case 0x4D: /* keypad 4,5,6 */ 1691 sc->sc_composed_char *= 10; 1692 sc->sc_composed_char += keycode - 0x47; 1693 goto check_composed; 1694 1695 case 0x4F: 1696 case 0x50: 1697 case 0x51: /* keypad 1,2,3 */ 1698 sc->sc_composed_char *= 10; 1699 sc->sc_composed_char += keycode - 0x4E; 1700 goto check_composed; 1701 1702 case 0x52: /* keypad 0 */ 1703 sc->sc_composed_char *= 10; 1704 goto check_composed; 1705 1706 /* key released, no interest here */ 1707 case SCAN_RELEASE | 0x47: 1708 case SCAN_RELEASE | 0x48: 1709 case SCAN_RELEASE | 0x49: /* keypad 7,8,9 */ 1710 case SCAN_RELEASE | 0x4B: 1711 case SCAN_RELEASE | 0x4C: 1712 case SCAN_RELEASE | 0x4D: /* keypad 4,5,6 */ 1713 case SCAN_RELEASE | 0x4F: 1714 case SCAN_RELEASE | 0x50: 1715 case SCAN_RELEASE | 0x51: /* keypad 1,2,3 */ 1716 case SCAN_RELEASE | 0x52: /* keypad 0 */ 1717 goto next_code; 1718 1719 case 0x38: /* left alt key */ 1720 break; 1721 1722 default: 1723 if (sc->sc_composed_char > 0) { 1724 sc->sc_flags &= ~UKBD_FLAG_COMPOSE; 1725 sc->sc_composed_char = 0; 1726 goto errkey; 1727 } 1728 break; 1729 } 1730 } 1731 /* keycode to key action */ 1732 action = genkbd_keyaction(kbd, SCAN_CHAR(keycode), 1733 (keycode & SCAN_RELEASE), 1734 &sc->sc_state, &sc->sc_accents); 1735 if (action == NOKEY) { 1736 goto next_code; 1737 } 1738 done: 1739 return (action); 1740 1741 check_composed: 1742 if (sc->sc_composed_char <= 0xFF) { 1743 goto next_code; 1744 } 1745 errkey: 1746 return (ERRKEY); 1747 } 1748 1749 /* Currently wait is always false. */ 1750 static uint32_t 1751 ukbd_read_char(keyboard_t *kbd, int wait) 1752 { 1753 uint32_t keycode; 1754 1755 UKBD_LOCK(); 1756 keycode = ukbd_read_char_locked(kbd, wait); 1757 UKBD_UNLOCK(); 1758 1759 return (keycode); 1760 } 1761 1762 /* some useful control functions */ 1763 static int 1764 ukbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg) 1765 { 1766 struct ukbd_softc *sc = kbd->kb_data; 1767 int i; 1768 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1769 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1770 int ival; 1771 1772 #endif 1773 1774 UKBD_LOCK_ASSERT(); 1775 1776 switch (cmd) { 1777 case KDGKBMODE: /* get keyboard mode */ 1778 *(int *)arg = sc->sc_mode; 1779 break; 1780 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1781 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1782 case _IO('K', 7): 1783 ival = IOCPARM_IVAL(arg); 1784 arg = (caddr_t)&ival; 1785 /* FALLTHROUGH */ 1786 #endif 1787 case KDSKBMODE: /* set keyboard mode */ 1788 switch (*(int *)arg) { 1789 case K_XLATE: 1790 if (sc->sc_mode != K_XLATE) { 1791 /* make lock key state and LED state match */ 1792 sc->sc_state &= ~LOCK_MASK; 1793 sc->sc_state |= KBD_LED_VAL(kbd); 1794 } 1795 /* FALLTHROUGH */ 1796 case K_RAW: 1797 case K_CODE: 1798 if (sc->sc_mode != *(int *)arg) { 1799 if ((sc->sc_flags & UKBD_FLAG_POLLING) == 0) 1800 ukbd_clear_state(kbd); 1801 sc->sc_mode = *(int *)arg; 1802 } 1803 break; 1804 default: 1805 return (EINVAL); 1806 } 1807 break; 1808 1809 case KDGETLED: /* get keyboard LED */ 1810 *(int *)arg = KBD_LED_VAL(kbd); 1811 break; 1812 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1813 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1814 case _IO('K', 66): 1815 ival = IOCPARM_IVAL(arg); 1816 arg = (caddr_t)&ival; 1817 /* FALLTHROUGH */ 1818 #endif 1819 case KDSETLED: /* set keyboard LED */ 1820 /* NOTE: lock key state in "sc_state" won't be changed */ 1821 if (*(int *)arg & ~LOCK_MASK) 1822 return (EINVAL); 1823 1824 i = *(int *)arg; 1825 1826 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */ 1827 if (sc->sc_mode == K_XLATE && 1828 kbd->kb_keymap->n_keys > ALTGR_OFFSET) { 1829 if (i & ALKED) 1830 i |= CLKED; 1831 else 1832 i &= ~CLKED; 1833 } 1834 if (KBD_HAS_DEVICE(kbd)) 1835 ukbd_set_leds(sc, i); 1836 1837 KBD_LED_VAL(kbd) = *(int *)arg; 1838 break; 1839 case KDGKBSTATE: /* get lock key state */ 1840 *(int *)arg = sc->sc_state & LOCK_MASK; 1841 break; 1842 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1843 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1844 case _IO('K', 20): 1845 ival = IOCPARM_IVAL(arg); 1846 arg = (caddr_t)&ival; 1847 /* FALLTHROUGH */ 1848 #endif 1849 case KDSKBSTATE: /* set lock key state */ 1850 if (*(int *)arg & ~LOCK_MASK) { 1851 return (EINVAL); 1852 } 1853 sc->sc_state &= ~LOCK_MASK; 1854 sc->sc_state |= *(int *)arg; 1855 1856 /* set LEDs and quit */ 1857 return (ukbd_ioctl(kbd, KDSETLED, arg)); 1858 1859 case KDSETREPEAT: /* set keyboard repeat rate (new 1860 * interface) */ 1861 if (!KBD_HAS_DEVICE(kbd)) { 1862 return (0); 1863 } 1864 if (((int *)arg)[1] < 0) { 1865 return (EINVAL); 1866 } 1867 if (((int *)arg)[0] < 0) { 1868 return (EINVAL); 1869 } 1870 if (((int *)arg)[0] < 200) /* fastest possible value */ 1871 kbd->kb_delay1 = 200; 1872 else 1873 kbd->kb_delay1 = ((int *)arg)[0]; 1874 kbd->kb_delay2 = ((int *)arg)[1]; 1875 return (0); 1876 1877 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1878 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1879 case _IO('K', 67): 1880 ival = IOCPARM_IVAL(arg); 1881 arg = (caddr_t)&ival; 1882 /* FALLTHROUGH */ 1883 #endif 1884 case KDSETRAD: /* set keyboard repeat rate (old 1885 * interface) */ 1886 return (ukbd_set_typematic(kbd, *(int *)arg)); 1887 1888 case PIO_KEYMAP: /* set keyboard translation table */ 1889 case OPIO_KEYMAP: /* set keyboard translation table 1890 * (compat) */ 1891 case PIO_KEYMAPENT: /* set keyboard translation table 1892 * entry */ 1893 case PIO_DEADKEYMAP: /* set accent key translation table */ 1894 sc->sc_accents = 0; 1895 /* FALLTHROUGH */ 1896 default: 1897 return (genkbd_commonioctl(kbd, cmd, arg)); 1898 } 1899 1900 return (0); 1901 } 1902 1903 static int 1904 ukbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg) 1905 { 1906 int result; 1907 1908 /* 1909 * XXX Check if someone is calling us from a critical section: 1910 */ 1911 if (curthread->td_critnest != 0) 1912 return (EDEADLK); 1913 1914 /* 1915 * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any 1916 * context where printf(9) can be called, which among other things 1917 * includes interrupt filters and threads with any kinds of locks 1918 * already held. For this reason it would be dangerous to acquire 1919 * the Giant here unconditionally. On the other hand we have to 1920 * have it to handle the ioctl. 1921 * So we make our best effort to auto-detect whether we can grab 1922 * the Giant or not. Blame syscons(4) for this. 1923 */ 1924 switch (cmd) { 1925 case KDGKBSTATE: 1926 case KDSKBSTATE: 1927 case KDSETLED: 1928 if (!mtx_owned(&Giant) && !SCHEDULER_STOPPED()) 1929 return (EDEADLK); /* best I could come up with */ 1930 /* FALLTHROUGH */ 1931 default: 1932 UKBD_LOCK(); 1933 result = ukbd_ioctl_locked(kbd, cmd, arg); 1934 UKBD_UNLOCK(); 1935 return (result); 1936 } 1937 } 1938 1939 1940 /* clear the internal state of the keyboard */ 1941 static void 1942 ukbd_clear_state(keyboard_t *kbd) 1943 { 1944 struct ukbd_softc *sc = kbd->kb_data; 1945 1946 UKBD_CTX_LOCK_ASSERT(); 1947 1948 sc->sc_flags &= ~(UKBD_FLAG_COMPOSE | UKBD_FLAG_POLLING); 1949 sc->sc_state &= LOCK_MASK; /* preserve locking key state */ 1950 sc->sc_accents = 0; 1951 sc->sc_composed_char = 0; 1952 #ifdef UKBD_EMULATE_ATSCANCODE 1953 sc->sc_buffered_char[0] = 0; 1954 sc->sc_buffered_char[1] = 0; 1955 #endif 1956 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); 1957 memset(&sc->sc_odata, 0, sizeof(sc->sc_odata)); 1958 memset(&sc->sc_ntime, 0, sizeof(sc->sc_ntime)); 1959 memset(&sc->sc_otime, 0, sizeof(sc->sc_otime)); 1960 } 1961 1962 /* save the internal state, not used */ 1963 static int 1964 ukbd_get_state(keyboard_t *kbd, void *buf, size_t len) 1965 { 1966 return (len == 0) ? 1 : -1; 1967 } 1968 1969 /* set the internal state, not used */ 1970 static int 1971 ukbd_set_state(keyboard_t *kbd, void *buf, size_t len) 1972 { 1973 return (EINVAL); 1974 } 1975 1976 static int 1977 ukbd_poll(keyboard_t *kbd, int on) 1978 { 1979 struct ukbd_softc *sc = kbd->kb_data; 1980 1981 UKBD_LOCK(); 1982 if (on) { 1983 sc->sc_flags |= UKBD_FLAG_POLLING; 1984 sc->sc_poll_thread = curthread; 1985 } else { 1986 sc->sc_flags &= ~UKBD_FLAG_POLLING; 1987 ukbd_start_timer(sc); /* start timer */ 1988 } 1989 UKBD_UNLOCK(); 1990 1991 return (0); 1992 } 1993 1994 /* local functions */ 1995 1996 static void 1997 ukbd_set_leds(struct ukbd_softc *sc, uint8_t leds) 1998 { 1999 2000 UKBD_LOCK_ASSERT(); 2001 DPRINTF("leds=0x%02x\n", leds); 2002 2003 sc->sc_leds = leds; 2004 sc->sc_flags |= UKBD_FLAG_SET_LEDS; 2005 2006 /* start transfer, if not already started */ 2007 2008 usbd_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]); 2009 } 2010 2011 static int 2012 ukbd_set_typematic(keyboard_t *kbd, int code) 2013 { 2014 static const int delays[] = {250, 500, 750, 1000}; 2015 static const int rates[] = {34, 38, 42, 46, 50, 55, 59, 63, 2016 68, 76, 84, 92, 100, 110, 118, 126, 2017 136, 152, 168, 184, 200, 220, 236, 252, 2018 272, 304, 336, 368, 400, 440, 472, 504}; 2019 2020 if (code & ~0x7f) { 2021 return (EINVAL); 2022 } 2023 kbd->kb_delay1 = delays[(code >> 5) & 3]; 2024 kbd->kb_delay2 = rates[code & 0x1f]; 2025 return (0); 2026 } 2027 2028 #ifdef UKBD_EMULATE_ATSCANCODE 2029 static int 2030 ukbd_key2scan(struct ukbd_softc *sc, int code, int shift, int up) 2031 { 2032 static const int scan[] = { 2033 /* 89 */ 2034 0x11c, /* Enter */ 2035 /* 90-99 */ 2036 0x11d, /* Ctrl-R */ 2037 0x135, /* Divide */ 2038 0x137 | SCAN_PREFIX_SHIFT, /* PrintScreen */ 2039 0x138, /* Alt-R */ 2040 0x147, /* Home */ 2041 0x148, /* Up */ 2042 0x149, /* PageUp */ 2043 0x14b, /* Left */ 2044 0x14d, /* Right */ 2045 0x14f, /* End */ 2046 /* 100-109 */ 2047 0x150, /* Down */ 2048 0x151, /* PageDown */ 2049 0x152, /* Insert */ 2050 0x153, /* Delete */ 2051 0x146, /* XXX Pause/Break */ 2052 0x15b, /* Win_L(Super_L) */ 2053 0x15c, /* Win_R(Super_R) */ 2054 0x15d, /* Application(Menu) */ 2055 2056 /* SUN TYPE 6 USB KEYBOARD */ 2057 0x168, /* Sun Type 6 Help */ 2058 0x15e, /* Sun Type 6 Stop */ 2059 /* 110 - 119 */ 2060 0x15f, /* Sun Type 6 Again */ 2061 0x160, /* Sun Type 6 Props */ 2062 0x161, /* Sun Type 6 Undo */ 2063 0x162, /* Sun Type 6 Front */ 2064 0x163, /* Sun Type 6 Copy */ 2065 0x164, /* Sun Type 6 Open */ 2066 0x165, /* Sun Type 6 Paste */ 2067 0x166, /* Sun Type 6 Find */ 2068 0x167, /* Sun Type 6 Cut */ 2069 0x125, /* Sun Type 6 Mute */ 2070 /* 120 - 128 */ 2071 0x11f, /* Sun Type 6 VolumeDown */ 2072 0x11e, /* Sun Type 6 VolumeUp */ 2073 0x120, /* Sun Type 6 PowerDown */ 2074 2075 /* Japanese 106/109 keyboard */ 2076 0x73, /* Keyboard Intl' 1 (backslash / underscore) */ 2077 0x70, /* Keyboard Intl' 2 (Katakana / Hiragana) */ 2078 0x7d, /* Keyboard Intl' 3 (Yen sign) (Not using in jp106/109) */ 2079 0x79, /* Keyboard Intl' 4 (Henkan) */ 2080 0x7b, /* Keyboard Intl' 5 (Muhenkan) */ 2081 0x5c, /* Keyboard Intl' 6 (Keypad ,) (For PC-9821 layout) */ 2082 }; 2083 2084 if ((code >= 89) && (code < (int)(89 + (sizeof(scan) / sizeof(scan[0]))))) { 2085 code = scan[code - 89]; 2086 } 2087 /* Pause/Break */ 2088 if ((code == 104) && (!(shift & (MOD_CONTROL_L | MOD_CONTROL_R)))) { 2089 code = (0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL); 2090 } 2091 if (shift & (MOD_SHIFT_L | MOD_SHIFT_R)) { 2092 code &= ~SCAN_PREFIX_SHIFT; 2093 } 2094 code |= (up ? SCAN_RELEASE : SCAN_PRESS); 2095 2096 if (code & SCAN_PREFIX) { 2097 if (code & SCAN_PREFIX_CTL) { 2098 /* Ctrl */ 2099 sc->sc_buffered_char[0] = (0x1d | (code & SCAN_RELEASE)); 2100 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX); 2101 } else if (code & SCAN_PREFIX_SHIFT) { 2102 /* Shift */ 2103 sc->sc_buffered_char[0] = (0x2a | (code & SCAN_RELEASE)); 2104 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX_SHIFT); 2105 } else { 2106 sc->sc_buffered_char[0] = (code & ~SCAN_PREFIX); 2107 sc->sc_buffered_char[1] = 0; 2108 } 2109 return ((code & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 2110 } 2111 return (code); 2112 2113 } 2114 2115 #endif /* UKBD_EMULATE_ATSCANCODE */ 2116 2117 static keyboard_switch_t ukbdsw = { 2118 .probe = &ukbd__probe, 2119 .init = &ukbd_init, 2120 .term = &ukbd_term, 2121 .intr = &ukbd_intr, 2122 .test_if = &ukbd_test_if, 2123 .enable = &ukbd_enable, 2124 .disable = &ukbd_disable, 2125 .read = &ukbd_read, 2126 .check = &ukbd_check, 2127 .read_char = &ukbd_read_char, 2128 .check_char = &ukbd_check_char, 2129 .ioctl = &ukbd_ioctl, 2130 .lock = &ukbd_lock, 2131 .clear_state = &ukbd_clear_state, 2132 .get_state = &ukbd_get_state, 2133 .set_state = &ukbd_set_state, 2134 .get_fkeystr = &genkbd_get_fkeystr, 2135 .poll = &ukbd_poll, 2136 .diag = &genkbd_diag, 2137 }; 2138 2139 KEYBOARD_DRIVER(ukbd, ukbdsw, ukbd_configure); 2140 2141 static int 2142 ukbd_driver_load(module_t mod, int what, void *arg) 2143 { 2144 switch (what) { 2145 case MOD_LOAD: 2146 kbd_add_driver(&ukbd_kbd_driver); 2147 break; 2148 case MOD_UNLOAD: 2149 kbd_delete_driver(&ukbd_kbd_driver); 2150 break; 2151 } 2152 return (0); 2153 } 2154 2155 static devclass_t ukbd_devclass; 2156 2157 static device_method_t ukbd_methods[] = { 2158 DEVMETHOD(device_probe, ukbd_probe), 2159 DEVMETHOD(device_attach, ukbd_attach), 2160 DEVMETHOD(device_detach, ukbd_detach), 2161 DEVMETHOD(device_resume, ukbd_resume), 2162 2163 DEVMETHOD_END 2164 }; 2165 2166 static driver_t ukbd_driver = { 2167 .name = "ukbd", 2168 .methods = ukbd_methods, 2169 .size = sizeof(struct ukbd_softc), 2170 }; 2171 2172 DRIVER_MODULE(ukbd, uhub, ukbd_driver, ukbd_devclass, ukbd_driver_load, 0); 2173 MODULE_DEPEND(ukbd, usb, 1, 1, 1); 2174 MODULE_VERSION(ukbd, 1); 2175