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_compat.h" 41 #include "opt_kbd.h" 42 #include "opt_ukbd.h" 43 44 #include <sys/stdint.h> 45 #include <sys/param.h> 46 #include <sys/queue.h> 47 #include <sys/types.h> 48 #include <sys/systm.h> 49 #include <sys/kernel.h> 50 #include <sys/bus.h> 51 #include <sys/module.h> 52 #include <sys/lock.h> 53 #include <sys/condvar.h> 54 #include <sys/sysctl.h> 55 #include <sys/unistd.h> 56 #include <sys/callout.h> 57 #include <sys/malloc.h> 58 #include <sys/priv.h> 59 #include <sys/proc.h> 60 #include <sys/sched.h> 61 #include <sys/thread2.h> 62 63 #include <bus/u4b/usb.h> 64 #include <bus/u4b/usbdi.h> 65 #include <bus/u4b/usbdi_util.h> 66 #include <bus/u4b/usbhid.h> 67 68 #define USB_DEBUG_VAR ukbd_debug 69 #include <bus/u4b/usb_debug.h> 70 71 #include <bus/u4b/quirk/usb_quirk.h> 72 73 #include <sys/ioccom.h> 74 #include <sys/filio.h> 75 #include <sys/tty.h> 76 #include <sys/kbio.h> 77 78 #include <dev/misc/kbd/kbdreg.h> 79 80 /* the initial key map, accent map and fkey strings */ 81 #if defined(UKBD_DFLT_KEYMAP) && !defined(KLD_MODULE) 82 #define KBD_DFLT_KEYMAP 83 #include "ukbdmap.h" 84 #endif 85 86 /* the following file must be included after "ukbdmap.h" */ 87 #include <dev/misc/kbd/kbdtables.h> 88 89 #ifdef USB_DEBUG 90 static int ukbd_debug = 0; 91 static int ukbd_no_leds = 0; 92 static int ukbd_pollrate = 0; 93 94 static SYSCTL_NODE(_hw_usb, OID_AUTO, ukbd, CTLFLAG_RW, 0, "USB keyboard"); 95 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, debug, CTLFLAG_RW, 96 &ukbd_debug, 0, "Debug level"); 97 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, no_leds, CTLFLAG_RW, 98 &ukbd_no_leds, 0, "Disables setting of keyboard leds"); 99 SYSCTL_INT(_hw_usb_ukbd, OID_AUTO, pollrate, CTLFLAG_RW, 100 &ukbd_pollrate, 0, "Force this polling rate, 1-1000Hz"); 101 102 TUNABLE_INT("hw.usb.ukbd.debug", &ukbd_debug); 103 TUNABLE_INT("hw.usb.ukbd.no_leds", &ukbd_no_leds); 104 TUNABLE_INT("hw.usb.ukbd.pollrate", &ukbd_pollrate); 105 #endif 106 107 #define UKBD_EMULATE_ATSCANCODE 1 108 #define UKBD_DRIVER_NAME "ukbd" 109 #define UKBD_NMOD 8 /* units */ 110 #define UKBD_NKEYCODE 6 /* units */ 111 #define UKBD_IN_BUF_SIZE (2*(UKBD_NMOD + (2*UKBD_NKEYCODE))) /* bytes */ 112 #define UKBD_IN_BUF_FULL (UKBD_IN_BUF_SIZE / 2) /* bytes */ 113 #define UKBD_NFKEY (sizeof(fkey_tab)/sizeof(fkey_tab[0])) /* units */ 114 #define UKBD_BUFFER_SIZE 64 /* bytes */ 115 116 struct ukbd_data { 117 uint16_t modifiers; 118 #define MOD_CONTROL_L 0x01 119 #define MOD_CONTROL_R 0x10 120 #define MOD_SHIFT_L 0x02 121 #define MOD_SHIFT_R 0x20 122 #define MOD_ALT_L 0x04 123 #define MOD_ALT_R 0x40 124 #define MOD_WIN_L 0x08 125 #define MOD_WIN_R 0x80 126 /* internal */ 127 #define MOD_EJECT 0x0100 128 #define MOD_FN 0x0200 129 uint8_t keycode[UKBD_NKEYCODE]; 130 }; 131 132 enum { 133 UKBD_INTR_DT, 134 UKBD_CTRL_LED, 135 UKBD_N_TRANSFER, 136 }; 137 138 struct ukbd_softc { 139 device_t sc_dev; 140 keyboard_t sc_kbd; 141 keymap_t sc_keymap; 142 accentmap_t sc_accmap; 143 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(sc) lockmgr(&(sc)->sc_kbd.kb_lock, LK_EXCLUSIVE) 252 #define UKBD_UNLOCK(sc) lockmgr(&(sc)->sc_kbd.kb_lock, LK_RELEASE) 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() 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 #else 268 269 #define UKBD_LOCK_ASSERT() (void)0 270 #define UKBD_CTX_LOCK_ASSERT() (void)0 271 272 #endif 273 274 struct ukbd_mods { 275 uint32_t mask, key; 276 }; 277 278 static const struct ukbd_mods ukbd_mods[UKBD_NMOD] = { 279 {MOD_CONTROL_L, 0xe0}, 280 {MOD_CONTROL_R, 0xe4}, 281 {MOD_SHIFT_L, 0xe1}, 282 {MOD_SHIFT_R, 0xe5}, 283 {MOD_ALT_L, 0xe2}, 284 {MOD_ALT_R, 0xe6}, 285 {MOD_WIN_L, 0xe3}, 286 {MOD_WIN_R, 0xe7}, 287 }; 288 289 #define NN 0 /* no translation */ 290 /* 291 * Translate USB keycodes to AT keyboard scancodes. 292 */ 293 /* 294 * FIXME: Mac USB keyboard generates: 295 * 0x53: keypad NumLock/Clear 296 * 0x66: Power 297 * 0x67: keypad = 298 * 0x68: F13 299 * 0x69: F14 300 * 0x6a: F15 301 */ 302 static const uint8_t ukbd_trtab[256] = { 303 0, 0, 0, 0, 30, 48, 46, 32, /* 00 - 07 */ 304 18, 33, 34, 35, 23, 36, 37, 38, /* 08 - 0F */ 305 50, 49, 24, 25, 16, 19, 31, 20, /* 10 - 17 */ 306 22, 47, 17, 45, 21, 44, 2, 3, /* 18 - 1F */ 307 4, 5, 6, 7, 8, 9, 10, 11, /* 20 - 27 */ 308 28, 1, 14, 15, 57, 12, 13, 26, /* 28 - 2F */ 309 27, 43, 43, 39, 40, 41, 51, 52, /* 30 - 37 */ 310 53, 58, 59, 60, 61, 62, 63, 64, /* 38 - 3F */ 311 65, 66, 67, 68, 87, 88, 92, 70, /* 40 - 47 */ 312 104, 102, 94, 96, 103, 99, 101, 98, /* 48 - 4F */ 313 97, 100, 95, 69, 91, 55, 74, 78,/* 50 - 57 */ 314 89, 79, 80, 81, 75, 76, 77, 71, /* 58 - 5F */ 315 72, 73, 82, 83, 86, 107, 122, NN, /* 60 - 67 */ 316 NN, NN, NN, NN, NN, NN, NN, NN, /* 68 - 6F */ 317 NN, NN, NN, NN, 115, 108, 111, 113, /* 70 - 77 */ 318 109, 110, 112, 118, 114, 116, 117, 119, /* 78 - 7F */ 319 121, 120, NN, NN, NN, NN, NN, 123, /* 80 - 87 */ 320 124, 125, 126, 127, 128, NN, NN, NN, /* 88 - 8F */ 321 NN, NN, NN, NN, NN, NN, NN, NN, /* 90 - 97 */ 322 NN, NN, NN, NN, NN, NN, NN, NN, /* 98 - 9F */ 323 NN, NN, NN, NN, NN, NN, NN, NN, /* A0 - A7 */ 324 NN, NN, NN, NN, NN, NN, NN, NN, /* A8 - AF */ 325 NN, NN, NN, NN, NN, NN, NN, NN, /* B0 - B7 */ 326 NN, NN, NN, NN, NN, NN, NN, NN, /* B8 - BF */ 327 NN, NN, NN, NN, NN, NN, NN, NN, /* C0 - C7 */ 328 NN, NN, NN, NN, NN, NN, NN, NN, /* C8 - CF */ 329 NN, NN, NN, NN, NN, NN, NN, NN, /* D0 - D7 */ 330 NN, NN, NN, NN, NN, NN, NN, NN, /* D8 - DF */ 331 29, 42, 56, 105, 90, 54, 93, 106, /* E0 - E7 */ 332 NN, NN, NN, NN, NN, NN, NN, NN, /* E8 - EF */ 333 NN, NN, NN, NN, NN, NN, NN, NN, /* F0 - F7 */ 334 NN, NN, NN, NN, NN, NN, NN, NN, /* F8 - FF */ 335 }; 336 337 static const uint8_t ukbd_boot_desc[] = { 338 0x05, 0x01, 0x09, 0x06, 0xa1, 339 0x01, 0x05, 0x07, 0x19, 0xe0, 340 0x29, 0xe7, 0x15, 0x00, 0x25, 341 0x01, 0x75, 0x01, 0x95, 0x08, 342 0x81, 0x02, 0x95, 0x01, 0x75, 343 0x08, 0x81, 0x01, 0x95, 0x03, 344 0x75, 0x01, 0x05, 0x08, 0x19, 345 0x01, 0x29, 0x03, 0x91, 0x02, 346 0x95, 0x05, 0x75, 0x01, 0x91, 347 0x01, 0x95, 0x06, 0x75, 0x08, 348 0x15, 0x00, 0x26, 0xff, 0x00, 349 0x05, 0x07, 0x19, 0x00, 0x2a, 350 0xff, 0x00, 0x81, 0x00, 0xc0 351 }; 352 353 /* prototypes */ 354 static void ukbd_timeout(void *); 355 static void ukbd_set_leds(struct ukbd_softc *, uint8_t); 356 static int ukbd_set_typematic(keyboard_t *, int); 357 #ifdef UKBD_EMULATE_ATSCANCODE 358 static int ukbd_key2scan(struct ukbd_softc *, int, int, int); 359 #endif 360 static uint32_t ukbd_read_char(keyboard_t *, int); 361 static void ukbd_clear_state(keyboard_t *); 362 static int ukbd_ioctl(keyboard_t *, u_long, caddr_t); 363 static int ukbd_enable(keyboard_t *); 364 static int ukbd_disable(keyboard_t *); 365 static void ukbd_interrupt(struct ukbd_softc *); 366 static void ukbd_event_keyinput(struct ukbd_softc *); 367 368 static device_probe_t ukbd_probe; 369 static device_attach_t ukbd_attach; 370 static device_detach_t ukbd_detach; 371 static device_resume_t ukbd_resume; 372 373 static uint8_t 374 ukbd_any_key_pressed(struct ukbd_softc *sc) 375 { 376 uint8_t i; 377 uint8_t j; 378 379 for (j = i = 0; i < UKBD_NKEYCODE; i++) 380 j |= sc->sc_odata.keycode[i]; 381 382 return (j ? 1 : 0); 383 } 384 385 static void 386 ukbd_start_timer(struct ukbd_softc *sc) 387 { 388 sc->sc_flags |= UKBD_FLAG_TIMER_RUNNING; 389 usb_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc); 390 } 391 392 static void 393 ukbd_put_key(struct ukbd_softc *sc, uint32_t key) 394 { 395 396 UKBD_CTX_LOCK_ASSERT(); 397 398 DPRINTF("0x%02x (%d) %s\n", key, key, 399 (key & KEY_RELEASE) ? "released" : "pressed"); 400 401 if (sc->sc_inputs < UKBD_IN_BUF_SIZE) { 402 sc->sc_input[sc->sc_inputtail] = key; 403 ++(sc->sc_inputs); 404 ++(sc->sc_inputtail); 405 if (sc->sc_inputtail >= UKBD_IN_BUF_SIZE) { 406 sc->sc_inputtail = 0; 407 } 408 } else { 409 DPRINTF("input buffer is full\n"); 410 } 411 } 412 413 static void 414 ukbd_do_poll(struct ukbd_softc *sc, uint8_t wait) 415 { 416 417 UKBD_CTX_LOCK_ASSERT(); 418 KASSERT((sc->sc_flags & UKBD_FLAG_POLLING) != 0, 419 ("ukbd_do_poll called when not polling\n")); 420 DPRINTFN(2, "polling\n"); 421 #if 0 /* XXX */ 422 if (!kdb_active && !SCHEDULER_STOPPED()) { 423 /* 424 * In this context the kernel is polling for input, 425 * but the USB subsystem works in normal interrupt-driven 426 * mode, so we just wait on the USB threads to do the job. 427 * Note that we currently hold the Giant, but it's also used 428 * as the transfer mtx, so we must release it while waiting. 429 */ 430 while (sc->sc_inputs == 0) { 431 /* 432 * Give USB threads a chance to run. Note that 433 * kern_yield performs DROP_GIANT + PICKUP_GIANT. 434 */ 435 lwkt_yield(); 436 if (!wait) 437 break; 438 } 439 return; 440 } 441 #endif 442 443 while (sc->sc_inputs == 0) { 444 445 usbd_transfer_poll(sc->sc_xfer, UKBD_N_TRANSFER); 446 447 /* Delay-optimised support for repetition of keys */ 448 if (ukbd_any_key_pressed(sc)) { 449 /* a key is pressed - need timekeeping */ 450 DELAY(1000); 451 452 /* 1 millisecond has passed */ 453 sc->sc_time_ms += 1; 454 } 455 456 ukbd_interrupt(sc); 457 458 if (!wait) 459 break; 460 } 461 } 462 463 static int32_t 464 ukbd_get_key(struct ukbd_softc *sc, uint8_t wait) 465 { 466 int32_t c; 467 468 UKBD_CTX_LOCK_ASSERT(); 469 #if 0 470 KASSERT((!kdb_active && !SCHEDULER_STOPPED()) 471 || (sc->sc_flags & UKBD_FLAG_POLLING) != 0, 472 ("not polling in kdb or panic\n")); 473 #endif 474 475 if (sc->sc_inputs == 0 && 476 (sc->sc_flags & UKBD_FLAG_GONE) == 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 kfree(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 int32_t 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, 1188 unit, 0, KB_PRI_USB, 0, 0); 1189 1190 kbd->kb_data = (void *)sc; 1191 1192 device_set_usb_desc(dev); 1193 1194 sc->sc_udev = uaa->device; 1195 sc->sc_iface = uaa->iface; 1196 sc->sc_iface_index = uaa->info.bIfaceIndex; 1197 sc->sc_iface_no = uaa->info.bIfaceNum; 1198 sc->sc_mode = K_XLATE; 1199 1200 usb_callout_init_mtx(&sc->sc_callout, &kbd->kb_lock, 0); 1201 1202 err = usbd_transfer_setup(uaa->device, 1203 &uaa->info.bIfaceIndex, sc->sc_xfer, ukbd_config, 1204 UKBD_N_TRANSFER, sc, &sc->sc_kbd.kb_lock); 1205 1206 if (err) { 1207 DPRINTF("error=%s\n", usbd_errstr(err)); 1208 goto detach; 1209 } 1210 /* setup default keyboard maps */ 1211 1212 sc->sc_keymap = key_map; 1213 sc->sc_accmap = accent_map; 1214 for (n = 0; n < UKBD_NFKEY; n++) { 1215 sc->sc_fkeymap[n] = fkey_tab[n]; 1216 } 1217 1218 kbd_set_maps(kbd, &sc->sc_keymap, &sc->sc_accmap, 1219 sc->sc_fkeymap, UKBD_NFKEY); 1220 1221 KBD_FOUND_DEVICE(kbd); 1222 1223 ukbd_clear_state(kbd); 1224 1225 /* 1226 * FIXME: set the initial value for lock keys in "sc_state" 1227 * according to the BIOS data? 1228 */ 1229 KBD_PROBE_DONE(kbd); 1230 1231 /* get HID descriptor */ 1232 err = usbd_req_get_hid_desc(uaa->device, NULL, &hid_ptr, 1233 &hid_len, M_TEMP, uaa->info.bIfaceIndex); 1234 1235 if (err == 0) { 1236 DPRINTF("Parsing HID descriptor of %d bytes\n", 1237 (int)hid_len); 1238 1239 ukbd_parse_hid(sc, hid_ptr, hid_len); 1240 1241 kfree(hid_ptr, M_TEMP); 1242 } 1243 1244 /* check if we should use the boot protocol */ 1245 if (usb_test_quirk(uaa, UQ_KBD_BOOTPROTO) || 1246 (err != 0) || (!(sc->sc_flags & UKBD_FLAG_EVENTS))) { 1247 1248 DPRINTF("Forcing boot protocol\n"); 1249 1250 err = usbd_req_set_protocol(sc->sc_udev, NULL, 1251 sc->sc_iface_index, 0); 1252 1253 if (err != 0) { 1254 DPRINTF("Set protocol error=%s (ignored)\n", 1255 usbd_errstr(err)); 1256 } 1257 1258 ukbd_parse_hid(sc, ukbd_boot_desc, sizeof(ukbd_boot_desc)); 1259 } 1260 1261 /* ignore if SETIDLE fails, hence it is not crucial */ 1262 usbd_req_set_idle(sc->sc_udev, NULL, sc->sc_iface_index, 0, 0); 1263 1264 ukbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state); 1265 1266 KBD_INIT_DONE(kbd); 1267 1268 if (kbd_register(kbd) < 0) { 1269 goto detach; 1270 } 1271 KBD_CONFIG_DONE(kbd); 1272 1273 ukbd_enable(kbd); 1274 1275 #ifdef KBD_INSTALL_CDEV 1276 if (kbd_attach(kbd)) { 1277 goto detach; 1278 } 1279 #endif 1280 sc->sc_flags |= UKBD_FLAG_ATTACHED; 1281 1282 if (bootverbose) { 1283 genkbd_diag(kbd, bootverbose); 1284 } 1285 1286 #ifdef USB_DEBUG 1287 /* check for polling rate override */ 1288 rate = ukbd_pollrate; 1289 if (rate > 0) { 1290 if (rate > 1000) 1291 rate = 1; 1292 else 1293 rate = 1000 / rate; 1294 1295 /* set new polling interval in ms */ 1296 usbd_xfer_set_interval(sc->sc_xfer[UKBD_INTR_DT], rate); 1297 } 1298 #endif 1299 /* start the keyboard */ 1300 /* XXX mp locking added */ 1301 UKBD_LOCK(sc); 1302 usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); 1303 UKBD_UNLOCK(sc); 1304 1305 1306 return (0); /* success */ 1307 detach: 1308 ukbd_detach(dev); 1309 return (ENXIO); /* error */ 1310 } 1311 1312 static int 1313 ukbd_detach(device_t dev) 1314 { 1315 struct ukbd_softc *sc = device_get_softc(dev); 1316 int error; 1317 1318 UKBD_LOCK_ASSERT(); 1319 1320 DPRINTF("\n"); 1321 1322 crit_enter(); 1323 sc->sc_flags |= UKBD_FLAG_GONE; 1324 1325 usb_callout_stop(&sc->sc_callout); 1326 1327 /* kill any stuck keys */ 1328 if (sc->sc_flags & UKBD_FLAG_ATTACHED) { 1329 /* stop receiving events from the USB keyboard */ 1330 usbd_transfer_stop(sc->sc_xfer[UKBD_INTR_DT]); 1331 1332 /* release all leftover keys, if any */ 1333 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); 1334 1335 /* process releasing of all keys */ 1336 ukbd_interrupt(sc); 1337 } 1338 1339 ukbd_disable(&sc->sc_kbd); 1340 1341 /* 1342 * XXX make sure this is in the correct place here, 1343 * it was taken from below the second if() 1344 */ 1345 usbd_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER); 1346 usb_callout_drain(&sc->sc_callout); 1347 1348 #ifdef KBD_INSTALL_CDEV 1349 if (sc->sc_flags & UKBD_FLAG_ATTACHED) { 1350 error = kbd_detach(&sc->sc_kbd); 1351 if (error) { 1352 /* usb attach cannot return an error */ 1353 device_printf(dev, "WARNING: kbd_detach() " 1354 "returned non-zero! (ignored)\n"); 1355 } 1356 } 1357 #endif 1358 if (KBD_IS_CONFIGURED(&sc->sc_kbd)) { 1359 /* 1360 * kbd_unregister requires kb_lock to be held 1361 * but lockuninits it then 1362 */ 1363 UKBD_LOCK(sc); 1364 error = kbd_unregister(&sc->sc_kbd); 1365 if (error) { 1366 /* usb attach cannot return an error */ 1367 device_printf(dev, "WARNING: kbd_unregister() " 1368 "returned non-zero! (ignored)\n"); 1369 } 1370 } 1371 sc->sc_kbd.kb_flags = 0; 1372 1373 1374 crit_exit(); 1375 1376 DPRINTF("%s: disconnected\n", 1377 device_get_nameunit(dev)); 1378 1379 return (0); 1380 } 1381 1382 static int 1383 ukbd_resume(device_t dev) 1384 { 1385 struct ukbd_softc *sc = device_get_softc(dev); 1386 1387 UKBD_LOCK_ASSERT(); 1388 1389 ukbd_clear_state(&sc->sc_kbd); 1390 1391 return (0); 1392 } 1393 1394 /* early keyboard probe, not supported */ 1395 static int 1396 ukbd_configure(int flags) 1397 { 1398 return (0); 1399 } 1400 1401 /* detect a keyboard, not used */ 1402 static int 1403 ukbd__probe(int unit, void *arg, int flags) 1404 { 1405 return (ENXIO); 1406 } 1407 1408 /* reset and initialize the device, not used */ 1409 static int 1410 ukbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 1411 { 1412 return (ENXIO); 1413 } 1414 1415 /* test the interface to the device, not used */ 1416 static int 1417 ukbd_test_if(keyboard_t *kbd) 1418 { 1419 return (0); 1420 } 1421 1422 /* finish using this keyboard, not used */ 1423 static int 1424 ukbd_term(keyboard_t *kbd) 1425 { 1426 return (ENXIO); 1427 } 1428 1429 /* keyboard interrupt routine, not used */ 1430 static int 1431 ukbd_intr(keyboard_t *kbd, void *arg) 1432 { 1433 return (0); 1434 } 1435 1436 /* lock the access to the keyboard, not used */ 1437 static int 1438 ukbd_lock(keyboard_t *kbd, int lock) 1439 { 1440 return (1); 1441 } 1442 1443 /* 1444 * Enable the access to the device; until this function is called, 1445 * the client cannot read from the keyboard. 1446 */ 1447 static int 1448 ukbd_enable(keyboard_t *kbd) 1449 { 1450 crit_enter(); 1451 KBD_ACTIVATE(kbd); 1452 crit_exit(); 1453 1454 return (0); 1455 } 1456 1457 /* disallow the access to the device */ 1458 static int 1459 ukbd_disable(keyboard_t *kbd) 1460 { 1461 crit_enter(); 1462 KBD_DEACTIVATE(kbd); 1463 crit_exit(); 1464 1465 return (0); 1466 } 1467 1468 /* check if data is waiting */ 1469 /* Currently unused. */ 1470 static int 1471 ukbd_check(keyboard_t *kbd) 1472 { 1473 struct ukbd_softc *sc = kbd->kb_data; 1474 1475 UKBD_CTX_LOCK_ASSERT(); 1476 1477 if (!KBD_IS_ACTIVE(kbd)) 1478 return (0); 1479 1480 if (sc->sc_flags & UKBD_FLAG_POLLING) 1481 ukbd_do_poll(sc, 0); 1482 1483 #ifdef UKBD_EMULATE_ATSCANCODE 1484 if (sc->sc_buffered_char[0]) { 1485 return (1); 1486 } 1487 #endif 1488 if (sc->sc_inputs > 0) { 1489 return (1); 1490 } 1491 return (0); 1492 } 1493 1494 /* check if char is waiting */ 1495 static int 1496 ukbd_check_char_locked(keyboard_t *kbd) 1497 { 1498 struct ukbd_softc *sc = kbd->kb_data; 1499 1500 UKBD_CTX_LOCK_ASSERT(); 1501 1502 if (!KBD_IS_ACTIVE(kbd)) 1503 return (0); 1504 1505 if ((sc->sc_composed_char > 0) && 1506 (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) { 1507 return (1); 1508 } 1509 return (ukbd_check(kbd)); 1510 } 1511 1512 static int 1513 ukbd_check_char(keyboard_t *kbd) 1514 { 1515 int result; 1516 #if 0 1517 struct ukbd_softc *sc = kbd->kb_data; 1518 1519 UKBD_LOCK(sc); 1520 #endif 1521 result = ukbd_check_char_locked(kbd); 1522 #if 0 1523 UKBD_UNLOCK(sc); 1524 #endif 1525 1526 return (result); 1527 } 1528 1529 /* read one byte from the keyboard if it's allowed */ 1530 /* Currently unused. */ 1531 static int 1532 ukbd_read(keyboard_t *kbd, int wait) 1533 { 1534 struct ukbd_softc *sc = kbd->kb_data; 1535 int32_t usbcode; 1536 #ifdef UKBD_EMULATE_ATSCANCODE 1537 uint32_t keycode; 1538 uint32_t scancode; 1539 1540 #endif 1541 1542 UKBD_CTX_LOCK_ASSERT(); 1543 1544 if (!KBD_IS_ACTIVE(kbd)) 1545 return (-1); 1546 1547 #ifdef UKBD_EMULATE_ATSCANCODE 1548 if (sc->sc_buffered_char[0]) { 1549 scancode = sc->sc_buffered_char[0]; 1550 if (scancode & SCAN_PREFIX) { 1551 sc->sc_buffered_char[0] &= ~SCAN_PREFIX; 1552 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1553 } 1554 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1555 sc->sc_buffered_char[1] = 0; 1556 return (scancode); 1557 } 1558 #endif /* UKBD_EMULATE_ATSCANCODE */ 1559 1560 /* XXX */ 1561 usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1562 if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1)) 1563 return (-1); 1564 1565 ++(kbd->kb_count); 1566 1567 #ifdef UKBD_EMULATE_ATSCANCODE 1568 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1569 if (keycode == NN) { 1570 return -1; 1571 } 1572 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers, 1573 (usbcode & KEY_RELEASE))); 1574 #else /* !UKBD_EMULATE_ATSCANCODE */ 1575 return (usbcode); 1576 #endif /* UKBD_EMULATE_ATSCANCODE */ 1577 } 1578 1579 /* read char from the keyboard */ 1580 static uint32_t 1581 ukbd_read_char_locked(keyboard_t *kbd, int wait) 1582 { 1583 struct ukbd_softc *sc = kbd->kb_data; 1584 uint32_t action; 1585 uint32_t keycode; 1586 int32_t usbcode; 1587 #ifdef UKBD_EMULATE_ATSCANCODE 1588 uint32_t scancode; 1589 #endif 1590 1591 UKBD_CTX_LOCK_ASSERT(); 1592 1593 if (!KBD_IS_ACTIVE(kbd)) 1594 return (NOKEY); 1595 1596 next_code: 1597 1598 /* do we have a composed char to return ? */ 1599 1600 if ((sc->sc_composed_char > 0) && 1601 (!(sc->sc_flags & UKBD_FLAG_COMPOSE))) { 1602 1603 action = sc->sc_composed_char; 1604 sc->sc_composed_char = 0; 1605 1606 if (action > 0xFF) { 1607 goto errkey; 1608 } 1609 goto done; 1610 } 1611 #ifdef UKBD_EMULATE_ATSCANCODE 1612 1613 /* do we have a pending raw scan code? */ 1614 1615 if (sc->sc_mode == K_RAW) { 1616 scancode = sc->sc_buffered_char[0]; 1617 if (scancode) { 1618 if (scancode & SCAN_PREFIX) { 1619 sc->sc_buffered_char[0] = (scancode & ~SCAN_PREFIX); 1620 return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 1621 } 1622 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 1623 sc->sc_buffered_char[1] = 0; 1624 return (scancode); 1625 } 1626 } 1627 #endif /* UKBD_EMULATE_ATSCANCODE */ 1628 1629 /* see if there is something in the keyboard port */ 1630 /* XXX */ 1631 usbcode = ukbd_get_key(sc, (wait == FALSE) ? 0 : 1); 1632 if (usbcode == -1) { 1633 return (NOKEY); 1634 } 1635 ++kbd->kb_count; 1636 1637 #ifdef UKBD_EMULATE_ATSCANCODE 1638 /* USB key index -> key code -> AT scan code */ 1639 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1640 if (keycode == NN) { 1641 return (NOKEY); 1642 } 1643 /* return an AT scan code for the K_RAW mode */ 1644 if (sc->sc_mode == K_RAW) { 1645 return (ukbd_key2scan(sc, keycode, sc->sc_ndata.modifiers, 1646 (usbcode & KEY_RELEASE))); 1647 } 1648 #else /* !UKBD_EMULATE_ATSCANCODE */ 1649 1650 /* return the byte as is for the K_RAW mode */ 1651 if (sc->sc_mode == K_RAW) { 1652 return (usbcode); 1653 } 1654 /* USB key index -> key code */ 1655 keycode = ukbd_trtab[KEY_INDEX(usbcode)]; 1656 if (keycode == NN) { 1657 return (NOKEY); 1658 } 1659 #endif /* UKBD_EMULATE_ATSCANCODE */ 1660 1661 switch (keycode) { 1662 case 0x38: /* left alt (compose key) */ 1663 if (usbcode & KEY_RELEASE) { 1664 if (sc->sc_flags & UKBD_FLAG_COMPOSE) { 1665 sc->sc_flags &= ~UKBD_FLAG_COMPOSE; 1666 1667 if (sc->sc_composed_char > 0xFF) { 1668 sc->sc_composed_char = 0; 1669 } 1670 } 1671 } else { 1672 if (!(sc->sc_flags & UKBD_FLAG_COMPOSE)) { 1673 sc->sc_flags |= UKBD_FLAG_COMPOSE; 1674 sc->sc_composed_char = 0; 1675 } 1676 } 1677 break; 1678 /* XXX: I don't like these... */ 1679 case 0x5c: /* print screen */ 1680 if (sc->sc_flags & ALTS) { 1681 keycode = 0x54; /* sysrq */ 1682 } 1683 break; 1684 case 0x68: /* pause/break */ 1685 if (sc->sc_flags & CTLS) { 1686 keycode = 0x6c; /* break */ 1687 } 1688 break; 1689 } 1690 1691 /* return the key code in the K_CODE mode */ 1692 if (usbcode & KEY_RELEASE) { 1693 keycode |= SCAN_RELEASE; 1694 } 1695 if (sc->sc_mode == K_CODE) { 1696 return (keycode); 1697 } 1698 /* compose a character code */ 1699 if (sc->sc_flags & UKBD_FLAG_COMPOSE) { 1700 switch (keycode) { 1701 /* key pressed, process it */ 1702 case 0x47: 1703 case 0x48: 1704 case 0x49: /* keypad 7,8,9 */ 1705 sc->sc_composed_char *= 10; 1706 sc->sc_composed_char += keycode - 0x40; 1707 goto check_composed; 1708 1709 case 0x4B: 1710 case 0x4C: 1711 case 0x4D: /* keypad 4,5,6 */ 1712 sc->sc_composed_char *= 10; 1713 sc->sc_composed_char += keycode - 0x47; 1714 goto check_composed; 1715 1716 case 0x4F: 1717 case 0x50: 1718 case 0x51: /* keypad 1,2,3 */ 1719 sc->sc_composed_char *= 10; 1720 sc->sc_composed_char += keycode - 0x4E; 1721 goto check_composed; 1722 1723 case 0x52: /* keypad 0 */ 1724 sc->sc_composed_char *= 10; 1725 goto check_composed; 1726 1727 /* key released, no interest here */ 1728 case SCAN_RELEASE | 0x47: 1729 case SCAN_RELEASE | 0x48: 1730 case SCAN_RELEASE | 0x49: /* keypad 7,8,9 */ 1731 case SCAN_RELEASE | 0x4B: 1732 case SCAN_RELEASE | 0x4C: 1733 case SCAN_RELEASE | 0x4D: /* keypad 4,5,6 */ 1734 case SCAN_RELEASE | 0x4F: 1735 case SCAN_RELEASE | 0x50: 1736 case SCAN_RELEASE | 0x51: /* keypad 1,2,3 */ 1737 case SCAN_RELEASE | 0x52: /* keypad 0 */ 1738 goto next_code; 1739 1740 case 0x38: /* left alt key */ 1741 break; 1742 1743 default: 1744 if (sc->sc_composed_char > 0) { 1745 sc->sc_flags &= ~UKBD_FLAG_COMPOSE; 1746 sc->sc_composed_char = 0; 1747 goto errkey; 1748 } 1749 break; 1750 } 1751 } 1752 /* keycode to key action */ 1753 action = genkbd_keyaction(kbd, SCAN_CHAR(keycode), 1754 (keycode & SCAN_RELEASE), 1755 &sc->sc_state, &sc->sc_accents); 1756 if (action == NOKEY) { 1757 goto next_code; 1758 } 1759 done: 1760 return (action); 1761 1762 check_composed: 1763 if (sc->sc_composed_char <= 0xFF) { 1764 goto next_code; 1765 } 1766 errkey: 1767 return (ERRKEY); 1768 } 1769 1770 /* Currently wait is always false. */ 1771 static uint32_t 1772 ukbd_read_char(keyboard_t *kbd, int wait) 1773 { 1774 uint32_t keycode; 1775 #if 0 1776 struct ukbd_softc *sc = kbd->kb_data; 1777 1778 UKBD_LOCK(sc); 1779 #endif 1780 keycode = ukbd_read_char_locked(kbd, wait); 1781 #if 0 1782 UKBD_UNLOCK(sc); 1783 #endif 1784 1785 return (keycode); 1786 } 1787 1788 /* some useful control functions */ 1789 static int 1790 ukbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg) 1791 { 1792 struct ukbd_softc *sc = kbd->kb_data; 1793 int i; 1794 #if 0 /* XXX */ 1795 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1796 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1797 int ival; 1798 1799 #endif 1800 #endif 1801 1802 switch (cmd) { 1803 case KDGKBMODE: /* get keyboard mode */ 1804 *(int *)arg = sc->sc_mode; 1805 break; 1806 #if 0 /* XXX */ 1807 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1808 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1809 case _IO('K', 7): 1810 ival = IOCPARM_IVAL(arg); 1811 arg = (caddr_t)&ival; 1812 /* FALLTHROUGH */ 1813 #endif 1814 #endif 1815 case KDSKBMODE: /* set keyboard mode */ 1816 switch (*(int *)arg) { 1817 case K_XLATE: 1818 if (sc->sc_mode != K_XLATE) { 1819 /* make lock key state and LED state match */ 1820 sc->sc_state &= ~LOCK_MASK; 1821 sc->sc_state |= KBD_LED_VAL(kbd); 1822 } 1823 /* FALLTHROUGH */ 1824 case K_RAW: 1825 case K_CODE: 1826 if (sc->sc_mode != *(int *)arg) { 1827 if ((sc->sc_flags & UKBD_FLAG_POLLING) == 0) 1828 ukbd_clear_state(kbd); 1829 sc->sc_mode = *(int *)arg; 1830 } 1831 break; 1832 default: 1833 return (EINVAL); 1834 } 1835 break; 1836 1837 case KDGETLED: /* get keyboard LED */ 1838 *(int *)arg = KBD_LED_VAL(kbd); 1839 break; 1840 #if 0 /* XXX */ 1841 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1842 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1843 case _IO('K', 66): 1844 ival = IOCPARM_IVAL(arg); 1845 arg = (caddr_t)&ival; 1846 /* FALLTHROUGH */ 1847 #endif 1848 #endif 1849 case KDSETLED: /* set keyboard LED */ 1850 /* NOTE: lock key state in "sc_state" won't be changed */ 1851 if (*(int *)arg & ~LOCK_MASK) 1852 return (EINVAL); 1853 1854 i = *(int *)arg; 1855 1856 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */ 1857 if (sc->sc_mode == K_XLATE && 1858 kbd->kb_keymap->n_keys > ALTGR_OFFSET) { 1859 if (i & ALKED) 1860 i |= CLKED; 1861 else 1862 i &= ~CLKED; 1863 } 1864 if (KBD_HAS_DEVICE(kbd)) 1865 ukbd_set_leds(sc, i); 1866 1867 KBD_LED_VAL(kbd) = *(int *)arg; 1868 break; 1869 case KDGKBSTATE: /* get lock key state */ 1870 *(int *)arg = sc->sc_state & LOCK_MASK; 1871 break; 1872 #if 0 /* XXX */ 1873 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1874 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1875 case _IO('K', 20): 1876 ival = IOCPARM_IVAL(arg); 1877 arg = (caddr_t)&ival; 1878 /* FALLTHROUGH */ 1879 #endif 1880 #endif 1881 case KDSKBSTATE: /* set lock key state */ 1882 if (*(int *)arg & ~LOCK_MASK) { 1883 return (EINVAL); 1884 } 1885 sc->sc_state &= ~LOCK_MASK; 1886 sc->sc_state |= *(int *)arg; 1887 1888 /* set LEDs and quit */ 1889 return (ukbd_ioctl(kbd, KDSETLED, arg)); 1890 1891 case KDSETREPEAT: /* set keyboard repeat rate (new 1892 * interface) */ 1893 if (!KBD_HAS_DEVICE(kbd)) { 1894 return (0); 1895 } 1896 if (((int *)arg)[1] < 0) { 1897 return (EINVAL); 1898 } 1899 if (((int *)arg)[0] < 0) { 1900 return (EINVAL); 1901 } 1902 if (((int *)arg)[0] < 200) /* fastest possible value */ 1903 kbd->kb_delay1 = 200; 1904 else 1905 kbd->kb_delay1 = ((int *)arg)[0]; 1906 kbd->kb_delay2 = ((int *)arg)[1]; 1907 return (0); 1908 1909 #if 0 /* XXX */ 1910 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 1911 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 1912 case _IO('K', 67): 1913 ival = IOCPARM_IVAL(arg); 1914 arg = (caddr_t)&ival; 1915 /* FALLTHROUGH */ 1916 #endif 1917 #endif 1918 case KDSETRAD: /* set keyboard repeat rate (old 1919 * interface) */ 1920 return (ukbd_set_typematic(kbd, *(int *)arg)); 1921 1922 case PIO_KEYMAP: /* set keyboard translation table */ 1923 case PIO_KEYMAPENT: /* set keyboard translation table 1924 * entry */ 1925 case PIO_DEADKEYMAP: /* set accent key translation table */ 1926 sc->sc_accents = 0; 1927 /* FALLTHROUGH */ 1928 default: 1929 return (genkbd_commonioctl(kbd, cmd, arg)); 1930 } 1931 1932 return (0); 1933 } 1934 1935 static int 1936 ukbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg) 1937 { 1938 int result; 1939 struct ukbd_softc *sc = kbd->kb_data; 1940 1941 /* 1942 * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any 1943 * context where printf(9) can be called, which among other things 1944 * includes interrupt filters and threads with any kinds of locks 1945 * already held. For this reason it would be dangerous to acquire 1946 * the Giant here unconditionally. On the other hand we have to 1947 * have it to handle the ioctl. 1948 * So we make our best effort to auto-detect whether we can grab 1949 * the Giant or not. Blame syscons(4) for this. 1950 */ 1951 switch (cmd) { 1952 case KDGKBSTATE: 1953 case KDSKBSTATE: 1954 case KDSETLED: 1955 if(!lockowned(&kbd->kb_lock)) { 1956 return (EDEADLK); /* best I could come up with */ 1957 } 1958 /* FALLTHROUGH */ 1959 default: 1960 UKBD_LOCK(sc); 1961 result = ukbd_ioctl_locked(kbd, cmd, arg); 1962 UKBD_UNLOCK(sc); 1963 return (result); 1964 } 1965 } 1966 1967 1968 /* clear the internal state of the keyboard */ 1969 static void 1970 ukbd_clear_state(keyboard_t *kbd) 1971 { 1972 struct ukbd_softc *sc = kbd->kb_data; 1973 1974 UKBD_CTX_LOCK_ASSERT(); 1975 1976 sc->sc_flags &= ~(UKBD_FLAG_COMPOSE | UKBD_FLAG_POLLING); 1977 sc->sc_state &= LOCK_MASK; /* preserve locking key state */ 1978 sc->sc_accents = 0; 1979 sc->sc_composed_char = 0; 1980 #ifdef UKBD_EMULATE_ATSCANCODE 1981 sc->sc_buffered_char[0] = 0; 1982 sc->sc_buffered_char[1] = 0; 1983 #endif 1984 memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); 1985 memset(&sc->sc_odata, 0, sizeof(sc->sc_odata)); 1986 memset(&sc->sc_ntime, 0, sizeof(sc->sc_ntime)); 1987 memset(&sc->sc_otime, 0, sizeof(sc->sc_otime)); 1988 } 1989 1990 /* save the internal state, not used */ 1991 static int 1992 ukbd_get_state(keyboard_t *kbd, void *buf, size_t len) 1993 { 1994 return (len == 0) ? 1 : -1; 1995 } 1996 1997 /* set the internal state, not used */ 1998 static int 1999 ukbd_set_state(keyboard_t *kbd, void *buf, size_t len) 2000 { 2001 return (EINVAL); 2002 } 2003 2004 static int 2005 ukbd_poll(keyboard_t *kbd, int on) 2006 { 2007 struct ukbd_softc *sc = kbd->kb_data; 2008 2009 UKBD_LOCK(sc); 2010 if (on) { 2011 sc->sc_flags |= UKBD_FLAG_POLLING; 2012 sc->sc_poll_thread = curthread; 2013 } else { 2014 sc->sc_flags &= ~UKBD_FLAG_POLLING; 2015 ukbd_start_timer(sc); /* start timer */ 2016 } 2017 UKBD_UNLOCK(sc); 2018 2019 return (0); 2020 } 2021 2022 /* local functions */ 2023 2024 static void 2025 ukbd_set_leds(struct ukbd_softc *sc, uint8_t leds) 2026 { 2027 UKBD_LOCK_ASSERT(); 2028 DPRINTF("leds=0x%02x\n", leds); 2029 2030 sc->sc_leds = leds; 2031 sc->sc_flags |= UKBD_FLAG_SET_LEDS; 2032 2033 /* start transfer, if not already started */ 2034 2035 usbd_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]); 2036 } 2037 2038 static int 2039 ukbd_set_typematic(keyboard_t *kbd, int code) 2040 { 2041 static const int delays[] = {250, 500, 750, 1000}; 2042 static const int rates[] = {34, 38, 42, 46, 50, 55, 59, 63, 2043 68, 76, 84, 92, 100, 110, 118, 126, 2044 136, 152, 168, 184, 200, 220, 236, 252, 2045 272, 304, 336, 368, 400, 440, 472, 504}; 2046 2047 if (code & ~0x7f) { 2048 return (EINVAL); 2049 } 2050 kbd->kb_delay1 = delays[(code >> 5) & 3]; 2051 kbd->kb_delay2 = rates[code & 0x1f]; 2052 return (0); 2053 } 2054 2055 #ifdef UKBD_EMULATE_ATSCANCODE 2056 static int 2057 ukbd_key2scan(struct ukbd_softc *sc, int code, int shift, int up) 2058 { 2059 static const int scan[] = { 2060 /* 89 */ 2061 0x11c, /* Enter */ 2062 /* 90-99 */ 2063 0x11d, /* Ctrl-R */ 2064 0x135, /* Divide */ 2065 0x137 | SCAN_PREFIX_SHIFT, /* PrintScreen */ 2066 0x138, /* Alt-R */ 2067 0x147, /* Home */ 2068 0x148, /* Up */ 2069 0x149, /* PageUp */ 2070 0x14b, /* Left */ 2071 0x14d, /* Right */ 2072 0x14f, /* End */ 2073 /* 100-109 */ 2074 0x150, /* Down */ 2075 0x151, /* PageDown */ 2076 0x152, /* Insert */ 2077 0x153, /* Delete */ 2078 0x146, /* XXX Pause/Break */ 2079 0x15b, /* Win_L(Super_L) */ 2080 0x15c, /* Win_R(Super_R) */ 2081 0x15d, /* Application(Menu) */ 2082 2083 /* SUN TYPE 6 USB KEYBOARD */ 2084 0x168, /* Sun Type 6 Help */ 2085 0x15e, /* Sun Type 6 Stop */ 2086 /* 110 - 119 */ 2087 0x15f, /* Sun Type 6 Again */ 2088 0x160, /* Sun Type 6 Props */ 2089 0x161, /* Sun Type 6 Undo */ 2090 0x162, /* Sun Type 6 Front */ 2091 0x163, /* Sun Type 6 Copy */ 2092 0x164, /* Sun Type 6 Open */ 2093 0x165, /* Sun Type 6 Paste */ 2094 0x166, /* Sun Type 6 Find */ 2095 0x167, /* Sun Type 6 Cut */ 2096 0x125, /* Sun Type 6 Mute */ 2097 /* 120 - 128 */ 2098 0x11f, /* Sun Type 6 VolumeDown */ 2099 0x11e, /* Sun Type 6 VolumeUp */ 2100 0x120, /* Sun Type 6 PowerDown */ 2101 2102 /* Japanese 106/109 keyboard */ 2103 0x73, /* Keyboard Intl' 1 (backslash / underscore) */ 2104 0x70, /* Keyboard Intl' 2 (Katakana / Hiragana) */ 2105 0x7d, /* Keyboard Intl' 3 (Yen sign) (Not using in jp106/109) */ 2106 0x79, /* Keyboard Intl' 4 (Henkan) */ 2107 0x7b, /* Keyboard Intl' 5 (Muhenkan) */ 2108 0x5c, /* Keyboard Intl' 6 (Keypad ,) (For PC-9821 layout) */ 2109 }; 2110 2111 if ((code >= 89) && (code < (int)(89 + NELEM(scan)))) { 2112 code = scan[code - 89]; 2113 } 2114 /* Pause/Break */ 2115 if ((code == 104) && (!(shift & (MOD_CONTROL_L | MOD_CONTROL_R)))) { 2116 code = (0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL); 2117 } 2118 if (shift & (MOD_SHIFT_L | MOD_SHIFT_R)) { 2119 code &= ~SCAN_PREFIX_SHIFT; 2120 } 2121 code |= (up ? SCAN_RELEASE : SCAN_PRESS); 2122 2123 if (code & SCAN_PREFIX) { 2124 if (code & SCAN_PREFIX_CTL) { 2125 /* Ctrl */ 2126 sc->sc_buffered_char[0] = (0x1d | (code & SCAN_RELEASE)); 2127 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX); 2128 } else if (code & SCAN_PREFIX_SHIFT) { 2129 /* Shift */ 2130 sc->sc_buffered_char[0] = (0x2a | (code & SCAN_RELEASE)); 2131 sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX_SHIFT); 2132 } else { 2133 sc->sc_buffered_char[0] = (code & ~SCAN_PREFIX); 2134 sc->sc_buffered_char[1] = 0; 2135 } 2136 return ((code & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 2137 } 2138 return (code); 2139 2140 } 2141 2142 #endif /* UKBD_EMULATE_ATSCANCODE */ 2143 2144 static keyboard_switch_t ukbdsw = { 2145 .probe = &ukbd__probe, 2146 .init = &ukbd_init, 2147 .term = &ukbd_term, 2148 .intr = &ukbd_intr, 2149 .test_if = &ukbd_test_if, 2150 .enable = &ukbd_enable, 2151 .disable = &ukbd_disable, 2152 .read = &ukbd_read, 2153 .check = &ukbd_check, 2154 .read_char = &ukbd_read_char, 2155 .check_char = &ukbd_check_char, 2156 .ioctl = &ukbd_ioctl, 2157 .lock = &ukbd_lock, 2158 .clear_state = &ukbd_clear_state, 2159 .get_state = &ukbd_get_state, 2160 .set_state = &ukbd_set_state, 2161 .get_fkeystr = &genkbd_get_fkeystr, 2162 .poll = &ukbd_poll, 2163 .diag = &genkbd_diag, 2164 }; 2165 2166 KEYBOARD_DRIVER(ukbd, ukbdsw, ukbd_configure); 2167 2168 static int 2169 ukbd_driver_load(module_t mod, int what, void *arg) 2170 { 2171 switch (what) { 2172 case MOD_LOAD: 2173 kbd_add_driver(&ukbd_kbd_driver); 2174 break; 2175 case MOD_UNLOAD: 2176 kbd_delete_driver(&ukbd_kbd_driver); 2177 break; 2178 } 2179 return (0); 2180 } 2181 2182 static devclass_t ukbd_devclass; 2183 2184 static device_method_t ukbd_methods[] = { 2185 DEVMETHOD(device_probe, ukbd_probe), 2186 DEVMETHOD(device_attach, ukbd_attach), 2187 DEVMETHOD(device_detach, ukbd_detach), 2188 DEVMETHOD(device_resume, ukbd_resume), 2189 DEVMETHOD_END 2190 }; 2191 2192 static driver_t ukbd_driver = { 2193 .name = "ukbd", 2194 .methods = ukbd_methods, 2195 .size = sizeof(struct ukbd_softc), 2196 }; 2197 2198 DRIVER_MODULE(ukbd, uhub, ukbd_driver, ukbd_devclass, ukbd_driver_load, NULL); 2199 MODULE_DEPEND(ukbd, usb, 1, 1, 1); 2200 MODULE_VERSION(ukbd, 1); 2201