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 96 static SYSCTL_NODE(_hw_usb, OID_AUTO, ukbd, CTLFLAG_RW, 0, "USB ukbd"); 97 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, debug, CTLFLAG_RW, 98 &ukbd_debug, 0, "Debug level"); 99 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, no_leds, CTLFLAG_RW, 100 &ukbd_no_leds, 0, "Disables setting of keyboard leds"); 101 102 TUNABLE_INT("hw.usb.ukbd.debug", &ukbd_debug); 103 TUNABLE_INT("hw.usb.ukbd.no_leds", &ukbd_no_leds); 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 /* start transfer, if not already started */ 475 usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); 476 } 477 478 if (sc->sc_flags & UKBD_FLAG_POLLING) 479 ukbd_do_poll(sc, wait); 480 481 if (sc->sc_inputs == 0) { 482 c = -1; 483 } else { 484 c = sc->sc_input[sc->sc_inputhead]; 485 --(sc->sc_inputs); 486 ++(sc->sc_inputhead); 487 if (sc->sc_inputhead >= UKBD_IN_BUF_SIZE) { 488 sc->sc_inputhead = 0; 489 } 490 } 491 return (c); 492 } 493 494 static void 495 ukbd_interrupt(struct ukbd_softc *sc) 496 { 497 uint32_t n_mod; 498 uint32_t o_mod; 499 uint32_t now = sc->sc_time_ms; 500 uint32_t dtime; 501 uint8_t key; 502 uint8_t i; 503 uint8_t j; 504 505 UKBD_CTX_LOCK_ASSERT(); 506 507 if (sc->sc_ndata.keycode[0] == KEY_ERROR) 508 return; 509 510 n_mod = sc->sc_ndata.modifiers; 511 o_mod = sc->sc_odata.modifiers; 512 if (n_mod != o_mod) { 513 for (i = 0; i < UKBD_NMOD; i++) { 514 if ((n_mod & ukbd_mods[i].mask) != 515 (o_mod & ukbd_mods[i].mask)) { 516 ukbd_put_key(sc, ukbd_mods[i].key | 517 ((n_mod & ukbd_mods[i].mask) ? 518 KEY_PRESS : KEY_RELEASE)); 519 } 520 } 521 } 522 /* Check for released keys. */ 523 for (i = 0; i < UKBD_NKEYCODE; i++) { 524 key = sc->sc_odata.keycode[i]; 525 if (key == 0) { 526 continue; 527 } 528 for (j = 0; j < UKBD_NKEYCODE; j++) { 529 if (sc->sc_ndata.keycode[j] == 0) { 530 continue; 531 } 532 if (key == sc->sc_ndata.keycode[j]) { 533 goto rfound; 534 } 535 } 536 ukbd_put_key(sc, key | KEY_RELEASE); 537 rfound: ; 538 } 539 540 /* Check for pressed keys. */ 541 for (i = 0; i < UKBD_NKEYCODE; i++) { 542 key = sc->sc_ndata.keycode[i]; 543 if (key == 0) { 544 continue; 545 } 546 sc->sc_ntime[i] = now + sc->sc_kbd.kb_delay1; 547 for (j = 0; j < UKBD_NKEYCODE; j++) { 548 if (sc->sc_odata.keycode[j] == 0) { 549 continue; 550 } 551 if (key == sc->sc_odata.keycode[j]) { 552 553 /* key is still pressed */ 554 555 sc->sc_ntime[i] = sc->sc_otime[j]; 556 dtime = (sc->sc_otime[j] - now); 557 558 if (!(dtime & 0x80000000)) { 559 /* time has not elapsed */ 560 goto pfound; 561 } 562 sc->sc_ntime[i] = now + sc->sc_kbd.kb_delay2; 563 break; 564 } 565 } 566 ukbd_put_key(sc, key | KEY_PRESS); 567 568 /* 569 * If any other key is presently down, force its repeat to be 570 * well in the future (100s). This makes the last key to be 571 * pressed do the autorepeat. 572 */ 573 for (j = 0; j != UKBD_NKEYCODE; j++) { 574 if (j != i) 575 sc->sc_ntime[j] = now + (100 * 1000); 576 } 577 pfound: ; 578 } 579 580 sc->sc_odata = sc->sc_ndata; 581 582 memcpy(sc->sc_otime, sc->sc_ntime, sizeof(sc->sc_otime)); 583 584 ukbd_event_keyinput(sc); 585 } 586 587 static void 588 ukbd_event_keyinput(struct ukbd_softc *sc) 589 { 590 int c; 591 592 UKBD_CTX_LOCK_ASSERT(); 593 594 if ((sc->sc_flags & UKBD_FLAG_POLLING) != 0) 595 return; 596 597 if (sc->sc_inputs == 0) 598 return; 599 600 if (KBD_IS_ACTIVE(&sc->sc_kbd) && 601 KBD_IS_BUSY(&sc->sc_kbd)) { 602 /* let the callback function process the input */ 603 (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT, 604 sc->sc_kbd.kb_callback.kc_arg); 605 } else { 606 /* read and discard the input, no one is waiting for it */ 607 do { 608 c = ukbd_read_char(&sc->sc_kbd, 0); 609 } while (c != NOKEY); 610 } 611 } 612 613 static void 614 ukbd_timeout(void *arg) 615 { 616 struct ukbd_softc *sc = arg; 617 618 UKBD_LOCK_ASSERT(); 619 620 sc->sc_time_ms += 25; /* milliseconds */ 621 622 ukbd_interrupt(sc); 623 624 /* Make sure any leftover key events gets read out */ 625 ukbd_event_keyinput(sc); 626 627 if (ukbd_any_key_pressed(sc) || (sc->sc_inputs != 0)) { 628 ukbd_start_timer(sc); 629 } else { 630 sc->sc_flags &= ~UKBD_FLAG_TIMER_RUNNING; 631 } 632 } 633 634 static uint8_t 635 ukbd_apple_fn(uint8_t keycode) { 636 switch (keycode) { 637 case 0x28: return 0x49; /* RETURN -> INSERT */ 638 case 0x2a: return 0x4c; /* BACKSPACE -> DEL */ 639 case 0x50: return 0x4a; /* LEFT ARROW -> HOME */ 640 case 0x4f: return 0x4d; /* RIGHT ARROW -> END */ 641 case 0x52: return 0x4b; /* UP ARROW -> PGUP */ 642 case 0x51: return 0x4e; /* DOWN ARROW -> PGDN */ 643 default: return keycode; 644 } 645 } 646 647 static uint8_t 648 ukbd_apple_swap(uint8_t keycode) { 649 switch (keycode) { 650 case 0x35: return 0x64; 651 case 0x64: return 0x35; 652 default: return keycode; 653 } 654 } 655 656 static void 657 ukbd_intr_callback(struct usb_xfer *xfer, usb_error_t error) 658 { 659 struct ukbd_softc *sc = usbd_xfer_softc(xfer); 660 struct usb_page_cache *pc; 661 uint8_t i; 662 uint8_t offset; 663 uint8_t id; 664 int len; 665 666 UKBD_LOCK_ASSERT(); 667 668 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 669 pc = usbd_xfer_get_frame(xfer, 0); 670 671 switch (USB_GET_STATE(xfer)) { 672 case USB_ST_TRANSFERRED: 673 DPRINTF("actlen=%d bytes\n", len); 674 675 if (len == 0) { 676 DPRINTF("zero length data\n"); 677 goto tr_setup; 678 } 679 680 if (sc->sc_kbd_id != 0) { 681 /* check and remove HID ID byte */ 682 usbd_copy_out(pc, 0, &id, 1); 683 offset = 1; 684 len--; 685 if (len == 0) { 686 DPRINTF("zero length data\n"); 687 goto tr_setup; 688 } 689 } else { 690 offset = 0; 691 id = 0; 692 } 693 694 if (len > UKBD_BUFFER_SIZE) 695 len = UKBD_BUFFER_SIZE; 696 697 /* get data */ 698 usbd_copy_out(pc, offset, sc->sc_buffer, len); 699 700 /* clear temporary storage */ 701 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); 702 703 /* scan through HID data */ 704 if ((sc->sc_flags & UKBD_FLAG_APPLE_EJECT) && 705 (id == sc->sc_id_apple_eject)) { 706 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_apple_eject)) 707 sc->sc_modifiers |= MOD_EJECT; 708 else 709 sc->sc_modifiers &= ~MOD_EJECT; 710 } 711 if ((sc->sc_flags & UKBD_FLAG_APPLE_FN) && 712 (id == sc->sc_id_apple_fn)) { 713 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_apple_fn)) 714 sc->sc_modifiers |= MOD_FN; 715 else 716 sc->sc_modifiers &= ~MOD_FN; 717 } 718 if ((sc->sc_flags & UKBD_FLAG_CTRL_L) && 719 (id == sc->sc_id_ctrl_l)) { 720 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_ctrl_l)) 721 sc-> sc_modifiers |= MOD_CONTROL_L; 722 else 723 sc-> sc_modifiers &= ~MOD_CONTROL_L; 724 } 725 if ((sc->sc_flags & UKBD_FLAG_CTRL_R) && 726 (id == sc->sc_id_ctrl_r)) { 727 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_ctrl_r)) 728 sc->sc_modifiers |= MOD_CONTROL_R; 729 else 730 sc->sc_modifiers &= ~MOD_CONTROL_R; 731 } 732 if ((sc->sc_flags & UKBD_FLAG_SHIFT_L) && 733 (id == sc->sc_id_shift_l)) { 734 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_shift_l)) 735 sc->sc_modifiers |= MOD_SHIFT_L; 736 else 737 sc->sc_modifiers &= ~MOD_SHIFT_L; 738 } 739 if ((sc->sc_flags & UKBD_FLAG_SHIFT_R) && 740 (id == sc->sc_id_shift_r)) { 741 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_shift_r)) 742 sc->sc_modifiers |= MOD_SHIFT_R; 743 else 744 sc->sc_modifiers &= ~MOD_SHIFT_R; 745 } 746 if ((sc->sc_flags & UKBD_FLAG_ALT_L) && 747 (id == sc->sc_id_alt_l)) { 748 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_alt_l)) 749 sc->sc_modifiers |= MOD_ALT_L; 750 else 751 sc->sc_modifiers &= ~MOD_ALT_L; 752 } 753 if ((sc->sc_flags & UKBD_FLAG_ALT_R) && 754 (id == sc->sc_id_alt_r)) { 755 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_alt_r)) 756 sc->sc_modifiers |= MOD_ALT_R; 757 else 758 sc->sc_modifiers &= ~MOD_ALT_R; 759 } 760 if ((sc->sc_flags & UKBD_FLAG_WIN_L) && 761 (id == sc->sc_id_win_l)) { 762 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_win_l)) 763 sc->sc_modifiers |= MOD_WIN_L; 764 else 765 sc->sc_modifiers &= ~MOD_WIN_L; 766 } 767 if ((sc->sc_flags & UKBD_FLAG_WIN_R) && 768 (id == sc->sc_id_win_r)) { 769 if (hid_get_data(sc->sc_buffer, len, &sc->sc_loc_win_r)) 770 sc->sc_modifiers |= MOD_WIN_R; 771 else 772 sc->sc_modifiers &= ~MOD_WIN_R; 773 } 774 775 sc->sc_ndata.modifiers = sc->sc_modifiers; 776 777 if ((sc->sc_flags & UKBD_FLAG_EVENTS) && 778 (id == sc->sc_id_events)) { 779 i = sc->sc_loc_events.count; 780 if (i > UKBD_NKEYCODE) 781 i = UKBD_NKEYCODE; 782 if (i > len) 783 i = len; 784 while (i--) { 785 sc->sc_ndata.keycode[i] = 786 hid_get_data(sc->sc_buffer + i, len - i, 787 &sc->sc_loc_events); 788 } 789 } 790 791 #ifdef USB_DEBUG 792 DPRINTF("modifiers = 0x%04x\n", (int)sc->sc_modifiers); 793 for (i = 0; i < UKBD_NKEYCODE; i++) { 794 if (sc->sc_ndata.keycode[i]) { 795 DPRINTF("[%d] = 0x%02x\n", 796 (int)i, (int)sc->sc_ndata.keycode[i]); 797 } 798 } 799 #endif 800 if (sc->sc_modifiers & MOD_FN) { 801 for (i = 0; i < UKBD_NKEYCODE; i++) { 802 sc->sc_ndata.keycode[i] = 803 ukbd_apple_fn(sc->sc_ndata.keycode[i]); 804 } 805 } 806 807 if (sc->sc_flags & UKBD_FLAG_APPLE_SWAP) { 808 for (i = 0; i < UKBD_NKEYCODE; i++) { 809 sc->sc_ndata.keycode[i] = 810 ukbd_apple_swap(sc->sc_ndata.keycode[i]); 811 } 812 } 813 814 ukbd_interrupt(sc); 815 816 if (!(sc->sc_flags & UKBD_FLAG_TIMER_RUNNING)) { 817 if (ukbd_any_key_pressed(sc)) { 818 ukbd_start_timer(sc); 819 } 820 } 821 822 case USB_ST_SETUP: 823 tr_setup: 824 if (sc->sc_inputs < UKBD_IN_BUF_FULL) { 825 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 826 usbd_transfer_submit(xfer); 827 } else { 828 DPRINTF("input queue is full!\n"); 829 } 830 break; 831 832 default: /* Error */ 833 DPRINTF("error=%s\n", usbd_errstr(error)); 834 835 if (error != USB_ERR_CANCELLED) { 836 /* try to clear stall first */ 837 usbd_xfer_set_stall(xfer); 838 goto tr_setup; 839 } 840 break; 841 } 842 } 843 844 static void 845 ukbd_set_leds_callback(struct usb_xfer *xfer, usb_error_t error) 846 { 847 struct ukbd_softc *sc = usbd_xfer_softc(xfer); 848 struct usb_device_request req; 849 struct usb_page_cache *pc; 850 uint8_t id; 851 uint8_t any; 852 int len; 853 854 UKBD_LOCK_ASSERT(); 855 856 #ifdef USB_DEBUG 857 if (ukbd_no_leds) 858 return; 859 #endif 860 861 switch (USB_GET_STATE(xfer)) { 862 case USB_ST_TRANSFERRED: 863 case USB_ST_SETUP: 864 if (!(sc->sc_flags & UKBD_FLAG_SET_LEDS)) 865 break; 866 sc->sc_flags &= ~UKBD_FLAG_SET_LEDS; 867 868 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 869 req.bRequest = UR_SET_REPORT; 870 USETW2(req.wValue, UHID_OUTPUT_REPORT, 0); 871 req.wIndex[0] = sc->sc_iface_no; 872 req.wIndex[1] = 0; 873 req.wLength[1] = 0; 874 875 memset(sc->sc_buffer, 0, UKBD_BUFFER_SIZE); 876 877 id = 0; 878 any = 0; 879 880 /* Assumption: All led bits must be in the same ID. */ 881 882 if (sc->sc_flags & UKBD_FLAG_NUMLOCK) { 883 if (sc->sc_leds & NLKED) { 884 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1, 885 &sc->sc_loc_numlock, 1); 886 } 887 id = sc->sc_id_numlock; 888 any = 1; 889 } 890 891 if (sc->sc_flags & UKBD_FLAG_SCROLLLOCK) { 892 if (sc->sc_leds & SLKED) { 893 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1, 894 &sc->sc_loc_scrolllock, 1); 895 } 896 id = sc->sc_id_scrolllock; 897 any = 1; 898 } 899 900 if (sc->sc_flags & UKBD_FLAG_CAPSLOCK) { 901 if (sc->sc_leds & CLKED) { 902 hid_put_data_unsigned(sc->sc_buffer + 1, UKBD_BUFFER_SIZE - 1, 903 &sc->sc_loc_capslock, 1); 904 } 905 id = sc->sc_id_capslock; 906 any = 1; 907 } 908 909 /* if no leds, nothing to do */ 910 if (!any) 911 break; 912 913 /* range check output report length */ 914 len = sc->sc_led_size; 915 if (len > (UKBD_BUFFER_SIZE - 1)) 916 len = (UKBD_BUFFER_SIZE - 1); 917 918 /* check if we need to prefix an ID byte */ 919 sc->sc_buffer[0] = id; 920 921 pc = usbd_xfer_get_frame(xfer, 1); 922 if (id != 0) { 923 len++; 924 usbd_copy_in(pc, 0, sc->sc_buffer, len); 925 } else { 926 usbd_copy_in(pc, 0, sc->sc_buffer + 1, len); 927 } 928 req.wLength[0] = len; 929 usbd_xfer_set_frame_len(xfer, 1, len); 930 931 DPRINTF("len=%d, id=%d\n", len, id); 932 933 /* setup control request last */ 934 pc = usbd_xfer_get_frame(xfer, 0); 935 usbd_copy_in(pc, 0, &req, sizeof(req)); 936 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 937 938 /* start data transfer */ 939 usbd_xfer_set_frames(xfer, 2); 940 usbd_transfer_submit(xfer); 941 break; 942 943 default: /* Error */ 944 DPRINTFN(1, "error=%s\n", usbd_errstr(error)); 945 break; 946 } 947 } 948 949 static const struct usb_config ukbd_config[UKBD_N_TRANSFER] = { 950 951 [UKBD_INTR_DT] = { 952 .type = UE_INTERRUPT, 953 .endpoint = UE_ADDR_ANY, 954 .direction = UE_DIR_IN, 955 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 956 .bufsize = 0, /* use wMaxPacketSize */ 957 .callback = &ukbd_intr_callback, 958 }, 959 960 [UKBD_CTRL_LED] = { 961 .type = UE_CONTROL, 962 .endpoint = 0x00, /* Control pipe */ 963 .direction = UE_DIR_ANY, 964 .bufsize = sizeof(struct usb_device_request) + UKBD_BUFFER_SIZE, 965 .callback = &ukbd_set_leds_callback, 966 .timeout = 1000, /* 1 second */ 967 }, 968 }; 969 970 /* A match on these entries will load ukbd */ 971 static const STRUCT_USB_HOST_ID __used ukbd_devs[] = { 972 {USB_IFACE_CLASS(UICLASS_HID), 973 USB_IFACE_SUBCLASS(UISUBCLASS_BOOT), 974 USB_IFACE_PROTOCOL(UIPROTO_BOOT_KEYBOARD),}, 975 }; 976 977 static int 978 ukbd_probe(device_t dev) 979 { 980 keyboard_switch_t *sw = kbd_get_switch(UKBD_DRIVER_NAME); 981 struct usb_attach_arg *uaa = device_get_ivars(dev); 982 void *d_ptr; 983 int error; 984 uint16_t d_len; 985 986 UKBD_LOCK_ASSERT(); 987 DPRINTFN(11, "\n"); 988 989 if (sw == NULL) { 990 return (ENXIO); 991 } 992 if (uaa->usb_mode != USB_MODE_HOST) { 993 return (ENXIO); 994 } 995 996 if (uaa->info.bInterfaceClass != UICLASS_HID) 997 return (ENXIO); 998 999 if ((uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) && 1000 (uaa->info.bInterfaceProtocol == UIPROTO_BOOT_KEYBOARD)) { 1001 if (usb_test_quirk(uaa, UQ_KBD_IGNORE)) 1002 return (ENXIO); 1003 else 1004 return (BUS_PROBE_DEFAULT); 1005 } 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 /* 1014 * NOTE: we currently don't support USB mouse and USB keyboard 1015 * on the same USB endpoint. 1016 */ 1017 if (hid_is_collection(d_ptr, d_len, 1018 HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE))) { 1019 /* most likely a mouse */ 1020 error = ENXIO; 1021 } else if (hid_is_collection(d_ptr, d_len, 1022 HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD))) { 1023 if (usb_test_quirk(uaa, UQ_KBD_IGNORE)) 1024 error = ENXIO; 1025 else 1026 error = BUS_PROBE_DEFAULT; 1027 } else 1028 error = ENXIO; 1029 1030 free(d_ptr, M_TEMP); 1031 return (error); 1032 } 1033 1034 static void 1035 ukbd_parse_hid(struct ukbd_softc *sc, const uint8_t *ptr, uint32_t len) 1036 { 1037 uint32_t flags; 1038 1039 /* reset detected bits */ 1040 sc->sc_flags &= ~UKBD_FLAG_HID_MASK; 1041 1042 /* check if there is an ID byte */ 1043 sc->sc_kbd_size = hid_report_size(ptr, len, 1044 hid_input, &sc->sc_kbd_id); 1045 1046 /* investigate if this is an Apple Keyboard */ 1047 if (hid_locate(ptr, len, 1048 HID_USAGE2(HUP_CONSUMER, HUG_APPLE_EJECT), 1049 hid_input, 0, &sc->sc_loc_apple_eject, &flags, 1050 &sc->sc_id_apple_eject)) { 1051 if (flags & HIO_VARIABLE) 1052 sc->sc_flags |= UKBD_FLAG_APPLE_EJECT | 1053 UKBD_FLAG_APPLE_SWAP; 1054 DPRINTFN(1, "Found Apple eject-key\n"); 1055 } 1056 if (hid_locate(ptr, len, 1057 HID_USAGE2(0xFFFF, 0x0003), 1058 hid_input, 0, &sc->sc_loc_apple_fn, &flags, 1059 &sc->sc_id_apple_fn)) { 1060 if (flags & HIO_VARIABLE) 1061 sc->sc_flags |= UKBD_FLAG_APPLE_FN; 1062 DPRINTFN(1, "Found Apple FN-key\n"); 1063 } 1064 /* figure out some keys */ 1065 if (hid_locate(ptr, len, 1066 HID_USAGE2(HUP_KEYBOARD, 0xE0), 1067 hid_input, 0, &sc->sc_loc_ctrl_l, &flags, 1068 &sc->sc_id_ctrl_l)) { 1069 if (flags & HIO_VARIABLE) 1070 sc->sc_flags |= UKBD_FLAG_CTRL_L; 1071 DPRINTFN(1, "Found left control\n"); 1072 } 1073 if (hid_locate(ptr, len, 1074 HID_USAGE2(HUP_KEYBOARD, 0xE4), 1075 hid_input, 0, &sc->sc_loc_ctrl_r, &flags, 1076 &sc->sc_id_ctrl_r)) { 1077 if (flags & HIO_VARIABLE) 1078 sc->sc_flags |= UKBD_FLAG_CTRL_R; 1079 DPRINTFN(1, "Found right control\n"); 1080 } 1081 if (hid_locate(ptr, len, 1082 HID_USAGE2(HUP_KEYBOARD, 0xE1), 1083 hid_input, 0, &sc->sc_loc_shift_l, &flags, 1084 &sc->sc_id_shift_l)) { 1085 if (flags & HIO_VARIABLE) 1086 sc->sc_flags |= UKBD_FLAG_SHIFT_L; 1087 DPRINTFN(1, "Found left shift\n"); 1088 } 1089 if (hid_locate(ptr, len, 1090 HID_USAGE2(HUP_KEYBOARD, 0xE5), 1091 hid_input, 0, &sc->sc_loc_shift_r, &flags, 1092 &sc->sc_id_shift_r)) { 1093 if (flags & HIO_VARIABLE) 1094 sc->sc_flags |= UKBD_FLAG_SHIFT_R; 1095 DPRINTFN(1, "Found right shift\n"); 1096 } 1097 if (hid_locate(ptr, len, 1098 HID_USAGE2(HUP_KEYBOARD, 0xE2), 1099 hid_input, 0, &sc->sc_loc_alt_l, &flags, 1100 &sc->sc_id_alt_l)) { 1101 if (flags & HIO_VARIABLE) 1102 sc->sc_flags |= UKBD_FLAG_ALT_L; 1103 DPRINTFN(1, "Found left alt\n"); 1104 } 1105 if (hid_locate(ptr, len, 1106 HID_USAGE2(HUP_KEYBOARD, 0xE6), 1107 hid_input, 0, &sc->sc_loc_alt_r, &flags, 1108 &sc->sc_id_alt_r)) { 1109 if (flags & HIO_VARIABLE) 1110 sc->sc_flags |= UKBD_FLAG_ALT_R; 1111 DPRINTFN(1, "Found right alt\n"); 1112 } 1113 if (hid_locate(ptr, len, 1114 HID_USAGE2(HUP_KEYBOARD, 0xE3), 1115 hid_input, 0, &sc->sc_loc_win_l, &flags, 1116 &sc->sc_id_win_l)) { 1117 if (flags & HIO_VARIABLE) 1118 sc->sc_flags |= UKBD_FLAG_WIN_L; 1119 DPRINTFN(1, "Found left GUI\n"); 1120 } 1121 if (hid_locate(ptr, len, 1122 HID_USAGE2(HUP_KEYBOARD, 0xE7), 1123 hid_input, 0, &sc->sc_loc_win_r, &flags, 1124 &sc->sc_id_win_r)) { 1125 if (flags & HIO_VARIABLE) 1126 sc->sc_flags |= UKBD_FLAG_WIN_R; 1127 DPRINTFN(1, "Found right GUI\n"); 1128 } 1129 /* figure out event buffer */ 1130 if (hid_locate(ptr, len, 1131 HID_USAGE2(HUP_KEYBOARD, 0x00), 1132 hid_input, 0, &sc->sc_loc_events, &flags, 1133 &sc->sc_id_events)) { 1134 sc->sc_flags |= UKBD_FLAG_EVENTS; 1135 DPRINTFN(1, "Found keyboard events\n"); 1136 } 1137 1138 /* figure out leds on keyboard */ 1139 sc->sc_led_size = hid_report_size(ptr, len, 1140 hid_output, NULL); 1141 1142 if (hid_locate(ptr, len, 1143 HID_USAGE2(HUP_LEDS, 0x01), 1144 hid_output, 0, &sc->sc_loc_numlock, &flags, 1145 &sc->sc_id_numlock)) { 1146 if (flags & HIO_VARIABLE) 1147 sc->sc_flags |= UKBD_FLAG_NUMLOCK; 1148 DPRINTFN(1, "Found keyboard numlock\n"); 1149 } 1150 if (hid_locate(ptr, len, 1151 HID_USAGE2(HUP_LEDS, 0x02), 1152 hid_output, 0, &sc->sc_loc_capslock, &flags, 1153 &sc->sc_id_capslock)) { 1154 if (flags & HIO_VARIABLE) 1155 sc->sc_flags |= UKBD_FLAG_CAPSLOCK; 1156 DPRINTFN(1, "Found keyboard capslock\n"); 1157 } 1158 if (hid_locate(ptr, len, 1159 HID_USAGE2(HUP_LEDS, 0x03), 1160 hid_output, 0, &sc->sc_loc_scrolllock, &flags, 1161 &sc->sc_id_scrolllock)) { 1162 if (flags & HIO_VARIABLE) 1163 sc->sc_flags |= UKBD_FLAG_SCROLLLOCK; 1164 DPRINTFN(1, "Found keyboard scrolllock\n"); 1165 } 1166 } 1167 1168 static int 1169 ukbd_attach(device_t dev) 1170 { 1171 struct ukbd_softc *sc = device_get_softc(dev); 1172 struct usb_attach_arg *uaa = device_get_ivars(dev); 1173 int32_t unit = device_get_unit(dev); 1174 keyboard_t *kbd = &sc->sc_kbd; 1175 void *hid_ptr = NULL; 1176 usb_error_t err; 1177 uint16_t n; 1178 uint16_t hid_len; 1179 1180 UKBD_LOCK_ASSERT(); 1181 1182 kbd_init_struct(kbd, UKBD_DRIVER_NAME, KB_OTHER, unit, 0, 0, 0); 1183 1184 kbd->kb_data = (void *)sc; 1185 1186 device_set_usb_desc(dev); 1187 1188 sc->sc_udev = uaa->device; 1189 sc->sc_iface = uaa->iface; 1190 sc->sc_iface_index = uaa->info.bIfaceIndex; 1191 sc->sc_iface_no = uaa->info.bIfaceNum; 1192 sc->sc_mode = K_XLATE; 1193 1194 usb_callout_init_mtx(&sc->sc_callout, &Giant, 0); 1195 1196 err = usbd_transfer_setup(uaa->device, 1197 &uaa->info.bIfaceIndex, sc->sc_xfer, ukbd_config, 1198 UKBD_N_TRANSFER, sc, &Giant); 1199 1200 if (err) { 1201 DPRINTF("error=%s\n", usbd_errstr(err)); 1202 goto detach; 1203 } 1204 /* setup default keyboard maps */ 1205 1206 sc->sc_keymap = key_map; 1207 sc->sc_accmap = accent_map; 1208 for (n = 0; n < UKBD_NFKEY; n++) { 1209 sc->sc_fkeymap[n] = fkey_tab[n]; 1210 } 1211 1212 kbd_set_maps(kbd, &sc->sc_keymap, &sc->sc_accmap, 1213 sc->sc_fkeymap, UKBD_NFKEY); 1214 1215 KBD_FOUND_DEVICE(kbd); 1216 1217 ukbd_clear_state(kbd); 1218 1219 /* 1220 * FIXME: set the initial value for lock keys in "sc_state" 1221 * according to the BIOS data? 1222 */ 1223 KBD_PROBE_DONE(kbd); 1224 1225 /* get HID descriptor */ 1226 err = usbd_req_get_hid_desc(uaa->device, NULL, &hid_ptr, 1227 &hid_len, M_TEMP, uaa->info.bIfaceIndex); 1228 1229 if (err == 0) { 1230 DPRINTF("Parsing HID descriptor of %d bytes\n", 1231 (int)hid_len); 1232 1233 ukbd_parse_hid(sc, hid_ptr, hid_len); 1234 1235 free(hid_ptr, M_TEMP); 1236 } 1237 1238 /* check if we should use the boot protocol */ 1239 if (usb_test_quirk(uaa, UQ_KBD_BOOTPROTO) || 1240 (err != 0) || (!(sc->sc_flags & UKBD_FLAG_EVENTS))) { 1241 1242 DPRINTF("Forcing boot protocol\n"); 1243 1244 err = usbd_req_set_protocol(sc->sc_udev, NULL, 1245 sc->sc_iface_index, 0); 1246 1247 if (err != 0) { 1248 DPRINTF("Set protocol error=%s (ignored)\n", 1249 usbd_errstr(err)); 1250 } 1251 1252 ukbd_parse_hid(sc, ukbd_boot_desc, sizeof(ukbd_boot_desc)); 1253 } 1254 1255 /* ignore if SETIDLE fails, hence it is not crucial */ 1256 usbd_req_set_idle(sc->sc_udev, NULL, sc->sc_iface_index, 0, 0); 1257 1258 ukbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state); 1259 1260 KBD_INIT_DONE(kbd); 1261 1262 if (kbd_register(kbd) < 0) { 1263 goto detach; 1264 } 1265 KBD_CONFIG_DONE(kbd); 1266 1267 ukbd_enable(kbd); 1268 1269 #ifdef KBD_INSTALL_CDEV 1270 if (kbd_attach(kbd)) { 1271 goto detach; 1272 } 1273 #endif 1274 sc->sc_flags |= UKBD_FLAG_ATTACHED; 1275 1276 if (bootverbose) { 1277 genkbd_diag(kbd, bootverbose); 1278 } 1279 1280 /* start the keyboard */ 1281 usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); 1282 1283 return (0); /* success */ 1284 1285 detach: 1286 ukbd_detach(dev); 1287 return (ENXIO); /* error */ 1288 } 1289 1290 static int 1291 ukbd_detach(device_t dev) 1292 { 1293 struct ukbd_softc *sc = device_get_softc(dev); 1294 int error; 1295 1296 UKBD_LOCK_ASSERT(); 1297 1298 DPRINTF("\n"); 1299 1300 sc->sc_flags |= UKBD_FLAG_GONE; 1301 1302 usb_callout_stop(&sc->sc_callout); 1303 1304 ukbd_disable(&sc->sc_kbd); 1305 1306 #ifdef KBD_INSTALL_CDEV 1307 if (sc->sc_flags & UKBD_FLAG_ATTACHED) { 1308 error = kbd_detach(&sc->sc_kbd); 1309 if (error) { 1310 /* usb attach cannot return an error */ 1311 device_printf(dev, "WARNING: kbd_detach() " 1312 "returned non-zero! (ignored)\n"); 1313 } 1314 } 1315 #endif 1316 if (KBD_IS_CONFIGURED(&sc->sc_kbd)) { 1317 error = kbd_unregister(&sc->sc_kbd); 1318 if (error) { 1319 /* usb attach cannot return an error */ 1320 device_printf(dev, "WARNING: kbd_unregister() " 1321 "returned non-zero! (ignored)\n"); 1322 } 1323 } 1324 sc->sc_kbd.kb_flags = 0; 1325 1326 usbd_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER); 1327 1328 usb_callout_drain(&sc->sc_callout); 1329 1330 DPRINTF("%s: disconnected\n", 1331 device_get_nameunit(dev)); 1332 1333 return (0); 1334 } 1335 1336 static int 1337 ukbd_resume(device_t dev) 1338 { 1339 struct ukbd_softc *sc = device_get_softc(dev); 1340 1341 UKBD_LOCK_ASSERT(); 1342 1343 ukbd_clear_state(&sc->sc_kbd); 1344 1345 return (0); 1346 } 1347 1348 /* early keyboard probe, not supported */ 1349 static int 1350 ukbd_configure(int flags) 1351 { 1352 return (0); 1353 } 1354 1355 /* detect a keyboard, not used */ 1356 static int 1357 ukbd__probe(int unit, void *arg, int flags) 1358 { 1359 return (ENXIO); 1360 } 1361 1362 /* reset and initialize the device, not used */ 1363 static int 1364 ukbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 1365 { 1366 return (ENXIO); 1367 } 1368 1369 /* test the interface to the device, not used */ 1370 static int 1371 ukbd_test_if(keyboard_t *kbd) 1372 { 1373 return (0); 1374 } 1375 1376 /* finish using this keyboard, not used */ 1377 static int 1378 ukbd_term(keyboard_t *kbd) 1379 { 1380 return (ENXIO); 1381 } 1382 1383 /* keyboard interrupt routine, not used */ 1384 static int 1385 ukbd_intr(keyboard_t *kbd, void *arg) 1386 { 1387 return (0); 1388 } 1389 1390 /* lock the access to the keyboard, not used */ 1391 static int 1392 ukbd_lock(keyboard_t *kbd, int lock) 1393 { 1394 return (1); 1395 } 1396 1397 /* 1398 * Enable the access to the device; until this function is called, 1399 * the client cannot read from the keyboard. 1400 */ 1401 static int 1402 ukbd_enable(keyboard_t *kbd) 1403 { 1404 1405 UKBD_LOCK(); 1406 KBD_ACTIVATE(kbd); 1407 UKBD_UNLOCK(); 1408 1409 return (0); 1410 } 1411 1412 /* disallow the access to the device */ 1413 static int 1414 ukbd_disable(keyboard_t *kbd) 1415 { 1416 1417 UKBD_LOCK(); 1418 KBD_DEACTIVATE(kbd); 1419 UKBD_UNLOCK(); 1420 1421 return (0); 1422 } 1423 1424 /* check if data is waiting */ 1425 /* Currently unused. */ 1426 static int 1427 ukbd_check(keyboard_t *kbd) 1428 { 1429 struct ukbd_softc *sc = kbd->kb_data; 1430 1431 UKBD_CTX_LOCK_ASSERT(); 1432 1433 if (!KBD_IS_ACTIVE(kbd)) 1434 return (0); 1435 1436 if (sc->sc_flags & UKBD_FLAG_POLLING) 1437 ukbd_do_poll(sc, 0); 1438 1439 #ifdef UKBD_EMULATE_ATSCANCODE 1440 if (sc->sc_buffered_char[0]) { 1441 return (1); 1442 } 1443 #endif 1444 if (sc->sc_inputs > 0) { 1445 return (1); 1446 } 1447 return (0); 1448 } 1449 1450 /* check if char is waiting */ 1451 static int 1452 ukbd_check_char_locked(keyboard_t *kbd) 1453 { 1454 struct ukbd_softc *sc = kbd->kb_data; 1455 1456 UKBD_CTX_LOCK_ASSERT(); 1457 1458 if (!KBD_IS_ACTIVE(kbd)) 1459 return (0); 1460 1461 if ((sc->sc_composed_char > 0) && 1462 (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) { 1463 return (1); 1464 } 1465 return (ukbd_check(kbd)); 1466 } 1467 1468 static int 1469 ukbd_check_char(keyboard_t *kbd) 1470 { 1471 int result; 1472 1473 UKBD_LOCK(); 1474 result = ukbd_check_char_locked(kbd); 1475 UKBD_UNLOCK(); 1476 1477 return (result); 1478 } 1479 1480 /* read one byte from the keyboard if it's allowed */ 1481 /* Currently unused. */ 1482 static int 1483 ukbd_read(keyboard_t *kbd, int wait) 1484 { 1485 struct ukbd_softc *sc = kbd->kb_data; 1486 int32_t usbcode; 1487 #ifdef UKBD_EMULATE_ATSCANCODE 1488 uint32_t keycode; 1489 uint32_t scancode; 1490 1491 #endif 1492 1493 UKBD_CTX_LOCK_ASSERT(); 1494 1495 if (!KBD_IS_ACTIVE(kbd)) 1496 return (-1); 1497 1498 #ifdef UKBD_EMULATE_ATSCANCODE 1499 if (sc->sc_buffered_char[0]) { 1500 scancode = sc->sc_buffered_char[0]; 1501 if (scancode & SCAN_PREFIX) { 1502 sc->sc_buffered_char[0] &= ~SCAN_PREFIX; 1503 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1504 } 1505 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1506 sc->sc_buffered_char[1] = 0; 1507 return (scancode); 1508 } 1509 #endif /* UKBD_EMULATE_ATSCANCODE */ 1510 1511 /* XXX */ 1512 usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1513 if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1)) 1514 return (-1); 1515 1516 ++(kbd->kb_count); 1517 1518 #ifdef UKBD_EMULATE_ATSCANCODE 1519 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1520 if (keycode == NN) { 1521 return -1; 1522 } 1523 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers, 1524 (usbcode & KEY_RELEASE))); 1525 #else /* !UKBD_EMULATE_ATSCANCODE */ 1526 return (usbcode); 1527 #endif /* UKBD_EMULATE_ATSCANCODE */ 1528 } 1529 1530 /* read char from the keyboard */ 1531 static uint32_t 1532 ukbd_read_char_locked(keyboard_t *kbd, int wait) 1533 { 1534 struct ukbd_softc *sc = kbd->kb_data; 1535 uint32_t action; 1536 uint32_t keycode; 1537 int32_t usbcode; 1538 #ifdef UKBD_EMULATE_ATSCANCODE 1539 uint32_t scancode; 1540 #endif 1541 1542 UKBD_CTX_LOCK_ASSERT(); 1543 1544 if (!KBD_IS_ACTIVE(kbd)) 1545 return (NOKEY); 1546 1547 next_code: 1548 1549 /* do we have a composed char to return ? */ 1550 1551 if ((sc->sc_composed_char > 0) && 1552 (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) { 1553 1554 action = sc->sc_composed_char; 1555 sc->sc_composed_char = 0; 1556 1557 if (action > 0xFF) { 1558 goto errkey; 1559 } 1560 goto done; 1561 } 1562 #ifdef UKBD_EMULATE_ATSCANCODE 1563 1564 /* do we have a pending raw scan code? */ 1565 1566 if (sc->sc_mode == K_RAW) { 1567 scancode = sc->sc_buffered_char[0]; 1568 if (scancode) { 1569 if (scancode & SCAN_PREFIX) { 1570 sc->sc_buffered_char[0] = (scancode & ~SCAN_PREFIX); 1571 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1572 } 1573 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1574 sc->sc_buffered_char[1] = 0; 1575 return (scancode); 1576 } 1577 } 1578 #endif /* UKBD_EMULATE_ATSCANCODE */ 1579 1580 /* see if there is something in the keyboard port */ 1581 /* XXX */ 1582 usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1583 if (usbcode == -1) { 1584 return (NOKEY); 1585 } 1586 ++kbd->kb_count; 1587 1588 #ifdef UKBD_EMULATE_ATSCANCODE 1589 /* USB key index -> key code -> AT scan code */ 1590 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1591 if (keycode == NN) { 1592 return (NOKEY); 1593 } 1594 /* return an AT scan code for the K_RAW mode */ 1595 if (sc->sc_mode == K_RAW) { 1596 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers, 1597 (usbcode & KEY_RELEASE))); 1598 } 1599 #else /* !UKBD_EMULATE_ATSCANCODE */ 1600 1601 /* return the byte as is for the K_RAW mode */ 1602 if (sc->sc_mode == K_RAW) { 1603 return (usbcode); 1604 } 1605 /* USB key index -> key code */ 1606 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1607 if (keycode == NN) { 1608 return (NOKEY); 1609 } 1610 #endif /* UKBD_EMULATE_ATSCANCODE */ 1611 1612 switch (keycode) { 1613 case 0x38: /* left alt (compose key) */ 1614 if (usbcode & KEY_RELEASE) { 1615 if (sc->sc_flags & UKBD_FLAG_COMPOSE) { 1616 sc->sc_flags &= ~UKBD_FLAG_COMPOSE; 1617 1618 if (sc->sc_composed_char > 0xFF) { 1619 sc->sc_composed_char = 0; 1620 } 1621 } 1622 } else { 1623 if (!(sc->sc_flags & UKBD_FLAG_COMPOSE)) { 1624 sc->sc_flags |= UKBD_FLAG_COMPOSE; 1625 sc->sc_composed_char = 0; 1626 } 1627 } 1628 break; 1629 /* XXX: I don't like these... */ 1630 case 0x5c: /* print screen */ 1631 if (sc->sc_flags & ALTS) { 1632 keycode = 0x54; /* sysrq */ 1633 } 1634 break; 1635 case 0x68: /* pause/break */ 1636 if (sc->sc_flags & CTLS) { 1637 keycode = 0x6c; /* break */ 1638 } 1639 break; 1640 } 1641 1642 /* return the key code in the K_CODE mode */ 1643 if (usbcode & KEY_RELEASE) { 1644 keycode |= SCAN_RELEASE; 1645 } 1646 if (sc->sc_mode == K_CODE) { 1647 return (keycode); 1648 } 1649 /* compose a character code */ 1650 if (sc->sc_flags & UKBD_FLAG_COMPOSE) { 1651 switch (keycode) { 1652 /* key pressed, process it */ 1653 case 0x47: 1654 case 0x48: 1655 case 0x49: /* keypad 7,8,9 */ 1656 sc->sc_composed_char *= 10; 1657 sc->sc_composed_char += keycode - 0x40; 1658 goto check_composed; 1659 1660 case 0x4B: 1661 case 0x4C: 1662 case 0x4D: /* keypad 4,5,6 */ 1663 sc->sc_composed_char *= 10; 1664 sc->sc_composed_char += keycode - 0x47; 1665 goto check_composed; 1666 1667 case 0x4F: 1668 case 0x50: 1669 case 0x51: /* keypad 1,2,3 */ 1670 sc->sc_composed_char *= 10; 1671 sc->sc_composed_char += keycode - 0x4E; 1672 goto check_composed; 1673 1674 case 0x52: /* keypad 0 */ 1675 sc->sc_composed_char *= 10; 1676 goto check_composed; 1677 1678 /* key released, no interest here */ 1679 case SCAN_RELEASE | 0x47: 1680 case SCAN_RELEASE | 0x48: 1681 case SCAN_RELEASE | 0x49: /* keypad 7,8,9 */ 1682 case SCAN_RELEASE | 0x4B: 1683 case SCAN_RELEASE | 0x4C: 1684 case SCAN_RELEASE | 0x4D: /* keypad 4,5,6 */ 1685 case SCAN_RELEASE | 0x4F: 1686 case SCAN_RELEASE | 0x50: 1687 case SCAN_RELEASE | 0x51: /* keypad 1,2,3 */ 1688 case SCAN_RELEASE | 0x52: /* keypad 0 */ 1689 goto next_code; 1690 1691 case 0x38: /* left alt key */ 1692 break; 1693 1694 default: 1695 if (sc->sc_composed_char > 0) { 1696 sc->sc_flags &= ~UKBD_FLAG_COMPOSE; 1697 sc->sc_composed_char = 0; 1698 goto errkey; 1699 } 1700 break; 1701 } 1702 } 1703 /* keycode to key action */ 1704 action = genkbd_keyaction(kbd, SCAN_CHAR(keycode), 1705 (keycode & SCAN_RELEASE), 1706 &sc->sc_state, &sc->sc_accents); 1707 if (action == NOKEY) { 1708 goto next_code; 1709 } 1710 done: 1711 return (action); 1712 1713 check_composed: 1714 if (sc->sc_composed_char <= 0xFF) { 1715 goto next_code; 1716 } 1717 errkey: 1718 return (ERRKEY); 1719 } 1720 1721 /* Currently wait is always false. */ 1722 static uint32_t 1723 ukbd_read_char(keyboard_t *kbd, int wait) 1724 { 1725 uint32_t keycode; 1726 1727 UKBD_LOCK(); 1728 keycode = ukbd_read_char_locked(kbd, wait); 1729 UKBD_UNLOCK(); 1730 1731 return (keycode); 1732 } 1733 1734 /* some useful control functions */ 1735 static int 1736 ukbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg) 1737 { 1738 struct ukbd_softc *sc = kbd->kb_data; 1739 int i; 1740 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1741 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1742 int ival; 1743 1744 #endif 1745 1746 UKBD_LOCK_ASSERT(); 1747 1748 switch (cmd) { 1749 case KDGKBMODE: /* get keyboard mode */ 1750 *(int *)arg = sc->sc_mode; 1751 break; 1752 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1753 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1754 case _IO('K', 7): 1755 ival = IOCPARM_IVAL(arg); 1756 arg = (caddr_t)&ival; 1757 /* FALLTHROUGH */ 1758 #endif 1759 case KDSKBMODE: /* set keyboard mode */ 1760 switch (*(int *)arg) { 1761 case K_XLATE: 1762 if (sc->sc_mode != K_XLATE) { 1763 /* make lock key state and LED state match */ 1764 sc->sc_state &= ~LOCK_MASK; 1765 sc->sc_state |= KBD_LED_VAL(kbd); 1766 } 1767 /* FALLTHROUGH */ 1768 case K_RAW: 1769 case K_CODE: 1770 if (sc->sc_mode != *(int *)arg) { 1771 if ((sc->sc_flags & UKBD_FLAG_POLLING) == 0) 1772 ukbd_clear_state(kbd); 1773 sc->sc_mode = *(int *)arg; 1774 } 1775 break; 1776 default: 1777 return (EINVAL); 1778 } 1779 break; 1780 1781 case KDGETLED: /* get keyboard LED */ 1782 *(int *)arg = KBD_LED_VAL(kbd); 1783 break; 1784 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1785 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1786 case _IO('K', 66): 1787 ival = IOCPARM_IVAL(arg); 1788 arg = (caddr_t)&ival; 1789 /* FALLTHROUGH */ 1790 #endif 1791 case KDSETLED: /* set keyboard LED */ 1792 /* NOTE: lock key state in "sc_state" won't be changed */ 1793 if (*(int *)arg & ~LOCK_MASK) 1794 return (EINVAL); 1795 1796 i = *(int *)arg; 1797 1798 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */ 1799 if (sc->sc_mode == K_XLATE && 1800 kbd->kb_keymap->n_keys > ALTGR_OFFSET) { 1801 if (i & ALKED) 1802 i |= CLKED; 1803 else 1804 i &= ~CLKED; 1805 } 1806 if (KBD_HAS_DEVICE(kbd)) 1807 ukbd_set_leds(sc, i); 1808 1809 KBD_LED_VAL(kbd) = *(int *)arg; 1810 break; 1811 case KDGKBSTATE: /* get lock key state */ 1812 *(int *)arg = sc->sc_state & LOCK_MASK; 1813 break; 1814 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1815 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1816 case _IO('K', 20): 1817 ival = IOCPARM_IVAL(arg); 1818 arg = (caddr_t)&ival; 1819 /* FALLTHROUGH */ 1820 #endif 1821 case KDSKBSTATE: /* set lock key state */ 1822 if (*(int *)arg & ~LOCK_MASK) { 1823 return (EINVAL); 1824 } 1825 sc->sc_state &= ~LOCK_MASK; 1826 sc->sc_state |= *(int *)arg; 1827 1828 /* set LEDs and quit */ 1829 return (ukbd_ioctl(kbd, KDSETLED, arg)); 1830 1831 case KDSETREPEAT: /* set keyboard repeat rate (new 1832 * interface) */ 1833 if (!KBD_HAS_DEVICE(kbd)) { 1834 return (0); 1835 } 1836 if (((int *)arg)[1] < 0) { 1837 return (EINVAL); 1838 } 1839 if (((int *)arg)[0] < 0) { 1840 return (EINVAL); 1841 } 1842 if (((int *)arg)[0] < 200) /* fastest possible value */ 1843 kbd->kb_delay1 = 200; 1844 else 1845 kbd->kb_delay1 = ((int *)arg)[0]; 1846 kbd->kb_delay2 = ((int *)arg)[1]; 1847 return (0); 1848 1849 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1850 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1851 case _IO('K', 67): 1852 ival = IOCPARM_IVAL(arg); 1853 arg = (caddr_t)&ival; 1854 /* FALLTHROUGH */ 1855 #endif 1856 case KDSETRAD: /* set keyboard repeat rate (old 1857 * interface) */ 1858 return (ukbd_set_typematic(kbd, *(int *)arg)); 1859 1860 case PIO_KEYMAP: /* set keyboard translation table */ 1861 case OPIO_KEYMAP: /* set keyboard translation table 1862 * (compat) */ 1863 case PIO_KEYMAPENT: /* set keyboard translation table 1864 * entry */ 1865 case PIO_DEADKEYMAP: /* set accent key translation table */ 1866 sc->sc_accents = 0; 1867 /* FALLTHROUGH */ 1868 default: 1869 return (genkbd_commonioctl(kbd, cmd, arg)); 1870 } 1871 1872 return (0); 1873 } 1874 1875 static int 1876 ukbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg) 1877 { 1878 int result; 1879 1880 /* 1881 * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any 1882 * context where printf(9) can be called, which among other things 1883 * includes interrupt filters and threads with any kinds of locks 1884 * already held. For this reason it would be dangerous to acquire 1885 * the Giant here unconditionally. On the other hand we have to 1886 * have it to handle the ioctl. 1887 * So we make our best effort to auto-detect whether we can grab 1888 * the Giant or not. Blame syscons(4) for this. 1889 */ 1890 switch (cmd) { 1891 case KDGKBSTATE: 1892 case KDSKBSTATE: 1893 case KDSETLED: 1894 if (!mtx_owned(&Giant) && !SCHEDULER_STOPPED()) 1895 return (EDEADLK); /* best I could come up with */ 1896 /* FALLTHROUGH */ 1897 default: 1898 UKBD_LOCK(); 1899 result = ukbd_ioctl_locked(kbd, cmd, arg); 1900 UKBD_UNLOCK(); 1901 return (result); 1902 } 1903 } 1904 1905 1906 /* clear the internal state of the keyboard */ 1907 static void 1908 ukbd_clear_state(keyboard_t *kbd) 1909 { 1910 struct ukbd_softc *sc = kbd->kb_data; 1911 1912 UKBD_CTX_LOCK_ASSERT(); 1913 1914 sc->sc_flags &= ~(UKBD_FLAG_COMPOSE | UKBD_FLAG_POLLING); 1915 sc->sc_state &= LOCK_MASK; /* preserve locking key state */ 1916 sc->sc_accents = 0; 1917 sc->sc_composed_char = 0; 1918 #ifdef UKBD_EMULATE_ATSCANCODE 1919 sc->sc_buffered_char[0] = 0; 1920 sc->sc_buffered_char[1] = 0; 1921 #endif 1922 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); 1923 memset(&sc->sc_odata, 0, sizeof(sc->sc_odata)); 1924 memset(&sc->sc_ntime, 0, sizeof(sc->sc_ntime)); 1925 memset(&sc->sc_otime, 0, sizeof(sc->sc_otime)); 1926 } 1927 1928 /* save the internal state, not used */ 1929 static int 1930 ukbd_get_state(keyboard_t *kbd, void *buf, size_t len) 1931 { 1932 return (len == 0) ? 1 : -1; 1933 } 1934 1935 /* set the internal state, not used */ 1936 static int 1937 ukbd_set_state(keyboard_t *kbd, void *buf, size_t len) 1938 { 1939 return (EINVAL); 1940 } 1941 1942 static int 1943 ukbd_poll(keyboard_t *kbd, int on) 1944 { 1945 struct ukbd_softc *sc = kbd->kb_data; 1946 1947 UKBD_LOCK(); 1948 if (on) { 1949 sc->sc_flags |= UKBD_FLAG_POLLING; 1950 sc->sc_poll_thread = curthread; 1951 } else { 1952 sc->sc_flags &= ~UKBD_FLAG_POLLING; 1953 ukbd_start_timer(sc); /* start timer */ 1954 } 1955 UKBD_UNLOCK(); 1956 1957 return (0); 1958 } 1959 1960 /* local functions */ 1961 1962 static void 1963 ukbd_set_leds(struct ukbd_softc *sc, uint8_t leds) 1964 { 1965 1966 UKBD_LOCK_ASSERT(); 1967 DPRINTF("leds=0x%02x\n", leds); 1968 1969 sc->sc_leds = leds; 1970 sc->sc_flags |= UKBD_FLAG_SET_LEDS; 1971 1972 /* start transfer, if not already started */ 1973 1974 usbd_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]); 1975 } 1976 1977 static int 1978 ukbd_set_typematic(keyboard_t *kbd, int code) 1979 { 1980 static const int delays[] = {250, 500, 750, 1000}; 1981 static const int rates[] = {34, 38, 42, 46, 50, 55, 59, 63, 1982 68, 76, 84, 92, 100, 110, 118, 126, 1983 136, 152, 168, 184, 200, 220, 236, 252, 1984 272, 304, 336, 368, 400, 440, 472, 504}; 1985 1986 if (code & ~0x7f) { 1987 return (EINVAL); 1988 } 1989 kbd->kb_delay1 = delays[(code >> 5) & 3]; 1990 kbd->kb_delay2 = rates[code & 0x1f]; 1991 return (0); 1992 } 1993 1994 #ifdef UKBD_EMULATE_ATSCANCODE 1995 static int 1996 ukbd_key2scan(struct ukbd_softc *sc, int code, int shift, 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 | SCAN_PREFIX_SHIFT, /* 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, /* XXX 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 - 128 */ 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 }; 2049 2050 if ((code >= 89) && (code < (int)(89 + (sizeof(scan) / sizeof(scan[0]))))) { 2051 code = scan[code - 89]; 2052 } 2053 /* Pause/Break */ 2054 if ((code == 104) && (!(shift & (MOD_CONTROL_L | MOD_CONTROL_R)))) { 2055 code = (0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL); 2056 } 2057 if (shift & (MOD_SHIFT_L | MOD_SHIFT_R)) { 2058 code &= ~SCAN_PREFIX_SHIFT; 2059 } 2060 code |= (up ? SCAN_RELEASE : SCAN_PRESS); 2061 2062 if (code & SCAN_PREFIX) { 2063 if (code & SCAN_PREFIX_CTL) { 2064 /* Ctrl */ 2065 sc->sc_buffered_char[0] = (0x1d | (code & SCAN_RELEASE)); 2066 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX); 2067 } else if (code & SCAN_PREFIX_SHIFT) { 2068 /* Shift */ 2069 sc->sc_buffered_char[0] = (0x2a | (code & SCAN_RELEASE)); 2070 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX_SHIFT); 2071 } else { 2072 sc->sc_buffered_char[0] = (code & ~SCAN_PREFIX); 2073 sc->sc_buffered_char[1] = 0; 2074 } 2075 return ((code & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 2076 } 2077 return (code); 2078 2079 } 2080 2081 #endif /* UKBD_EMULATE_ATSCANCODE */ 2082 2083 static keyboard_switch_t ukbdsw = { 2084 .probe = &ukbd__probe, 2085 .init = &ukbd_init, 2086 .term = &ukbd_term, 2087 .intr = &ukbd_intr, 2088 .test_if = &ukbd_test_if, 2089 .enable = &ukbd_enable, 2090 .disable = &ukbd_disable, 2091 .read = &ukbd_read, 2092 .check = &ukbd_check, 2093 .read_char = &ukbd_read_char, 2094 .check_char = &ukbd_check_char, 2095 .ioctl = &ukbd_ioctl, 2096 .lock = &ukbd_lock, 2097 .clear_state = &ukbd_clear_state, 2098 .get_state = &ukbd_get_state, 2099 .set_state = &ukbd_set_state, 2100 .get_fkeystr = &genkbd_get_fkeystr, 2101 .poll = &ukbd_poll, 2102 .diag = &genkbd_diag, 2103 }; 2104 2105 KEYBOARD_DRIVER(ukbd, ukbdsw, ukbd_configure); 2106 2107 static int 2108 ukbd_driver_load(module_t mod, int what, void *arg) 2109 { 2110 switch (what) { 2111 case MOD_LOAD: 2112 kbd_add_driver(&ukbd_kbd_driver); 2113 break; 2114 case MOD_UNLOAD: 2115 kbd_delete_driver(&ukbd_kbd_driver); 2116 break; 2117 } 2118 return (0); 2119 } 2120 2121 static devclass_t ukbd_devclass; 2122 2123 static device_method_t ukbd_methods[] = { 2124 DEVMETHOD(device_probe, ukbd_probe), 2125 DEVMETHOD(device_attach, ukbd_attach), 2126 DEVMETHOD(device_detach, ukbd_detach), 2127 DEVMETHOD(device_resume, ukbd_resume), 2128 {0, 0} 2129 }; 2130 2131 static driver_t ukbd_driver = { 2132 .name = "ukbd", 2133 .methods = ukbd_methods, 2134 .size = sizeof(struct ukbd_softc), 2135 }; 2136 2137 DRIVER_MODULE(ukbd, uhub, ukbd_driver, ukbd_devclass, ukbd_driver_load, 0); 2138 MODULE_DEPEND(ukbd, usb, 1, 1, 1); 2139 MODULE_VERSION(ukbd, 1); 2140