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