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