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