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