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