1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (C) 2008 Nathan Whitehorn 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * $FreeBSD$ 28 */ 29 30 #include <sys/cdefs.h> 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/lock.h> 34 #include <sys/module.h> 35 #include <sys/mutex.h> 36 #include <sys/bus.h> 37 #include <sys/conf.h> 38 #include <sys/kbio.h> 39 #include <sys/condvar.h> 40 #include <sys/callout.h> 41 #include <sys/kernel.h> 42 #include <sys/sysctl.h> 43 44 #include <machine/bus.h> 45 46 #include "opt_kbd.h" 47 #include <dev/kbd/kbdreg.h> 48 #include <dev/kbd/kbdtables.h> 49 #include <dev/ofw/openfirm.h> 50 #include <dev/ofw/ofw_bus.h> 51 52 #include <vm/vm.h> 53 #include <vm/pmap.h> 54 55 #include "adb.h" 56 57 #define KBD_DRIVER_NAME "akbd" 58 59 #define AKBD_EMULATE_ATKBD 1 60 61 static int adb_kbd_probe(device_t dev); 62 static int adb_kbd_attach(device_t dev); 63 static int adb_kbd_detach(device_t dev); 64 static void akbd_repeat(void *xsc); 65 static int adb_fn_keys(SYSCTL_HANDLER_ARGS); 66 67 static u_int adb_kbd_receive_packet(device_t dev, u_char status, 68 u_char command, u_char reg, int len, u_char *data); 69 70 struct adb_kbd_softc { 71 keyboard_t sc_kbd; 72 73 device_t sc_dev; 74 struct mtx sc_mutex; 75 struct cv sc_cv; 76 77 int sc_mode; 78 int sc_state; 79 80 int have_led_control; 81 82 uint8_t buffer[8]; 83 #ifdef AKBD_EMULATE_ATKBD 84 uint8_t at_buffered_char[2]; 85 #endif 86 volatile int buffers; 87 88 struct callout sc_repeater; 89 int sc_repeatstart; 90 int sc_repeatcontinue; 91 uint8_t last_press; 92 }; 93 94 static device_method_t adb_kbd_methods[] = { 95 /* Device interface */ 96 DEVMETHOD(device_probe, adb_kbd_probe), 97 DEVMETHOD(device_attach, adb_kbd_attach), 98 DEVMETHOD(device_detach, adb_kbd_detach), 99 DEVMETHOD(device_shutdown, bus_generic_shutdown), 100 DEVMETHOD(device_suspend, bus_generic_suspend), 101 DEVMETHOD(device_resume, bus_generic_resume), 102 103 /* ADB interface */ 104 DEVMETHOD(adb_receive_packet, adb_kbd_receive_packet), 105 106 { 0, 0 } 107 }; 108 109 static driver_t adb_kbd_driver = { 110 "akbd", 111 adb_kbd_methods, 112 sizeof(struct adb_kbd_softc), 113 }; 114 115 static devclass_t adb_kbd_devclass; 116 117 DRIVER_MODULE(akbd, adb, adb_kbd_driver, adb_kbd_devclass, 0, 0); 118 119 #ifdef AKBD_EMULATE_ATKBD 120 121 #define SCAN_PRESS 0x000 122 #define SCAN_RELEASE 0x080 123 #define SCAN_PREFIX_E0 0x100 124 #define SCAN_PREFIX_E1 0x200 125 #define SCAN_PREFIX_CTL 0x400 126 #define SCAN_PREFIX_SHIFT 0x800 127 #define SCAN_PREFIX (SCAN_PREFIX_E0 | SCAN_PREFIX_E1 | \ 128 SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT) 129 130 static const uint8_t adb_to_at_scancode_map[128] = { 30, 31, 32, 33, 35, 34, 131 44, 45, 46, 47, 0, 48, 16, 17, 18, 19, 21, 20, 2, 3, 4, 5, 7, 6, 13, 132 10, 8, 12, 9, 11, 27, 24, 22, 26, 23, 25, 28, 38, 36, 40, 37, 39, 43, 133 51, 53, 49, 50, 52, 15, 57, 41, 14, 0, 1, 29, 0, 42, 58, 56, 97, 98, 134 100, 95, 0, 0, 83, 0, 55, 0, 78, 0, 69, 0, 0, 0, 91, 89, 0, 74, 13, 0, 135 0, 82, 79, 80, 81, 75, 76, 77, 71, 0, 72, 73, 0, 0, 0, 63, 64, 65, 61, 136 66, 67, 0, 87, 0, 105, 0, 70, 0, 68, 0, 88, 0, 107, 102, 94, 96, 103, 137 62, 99, 60, 101, 59, 54, 93, 90, 0, 0 }; 138 139 static int 140 keycode2scancode(int keycode, int shift, int up) 141 { 142 static const int scan[] = { 143 /* KP enter, right ctrl, KP divide */ 144 0x1c , 0x1d , 0x35 , 145 /* print screen */ 146 0x37 | SCAN_PREFIX_SHIFT, 147 /* right alt, home, up, page up, left, right, end */ 148 0x38, 0x47, 0x48, 0x49, 0x4b, 0x4d, 0x4f, 149 /* down, page down, insert, delete */ 150 0x50, 0x51, 0x52, 0x53, 151 /* pause/break (see also below) */ 152 0x46, 153 /* 154 * MS: left window, right window, menu 155 * also Sun: left meta, right meta, compose 156 */ 157 0x5b, 0x5c, 0x5d, 158 /* Sun type 6 USB */ 159 /* help, stop, again, props, undo, front, copy */ 160 0x68, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 161 /* open, paste, find, cut, audiomute, audiolower, audioraise */ 162 0x64, 0x65, 0x66, 0x67, 0x25, 0x1f, 0x1e, 163 /* power */ 164 0x20 165 }; 166 int scancode; 167 168 scancode = keycode; 169 if ((keycode >= 89) && (keycode < 89 + nitems(scan))) 170 scancode = scan[keycode - 89] | SCAN_PREFIX_E0; 171 /* pause/break */ 172 if ((keycode == 104) && !(shift & CTLS)) 173 scancode = 0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL; 174 if (shift & SHIFTS) 175 scancode &= ~SCAN_PREFIX_SHIFT; 176 return (scancode | (up ? SCAN_RELEASE : SCAN_PRESS)); 177 } 178 #endif 179 180 /* keyboard driver declaration */ 181 static int akbd_configure(int flags); 182 static kbd_probe_t akbd_probe; 183 static kbd_init_t akbd_init; 184 static kbd_term_t akbd_term; 185 static kbd_intr_t akbd_interrupt; 186 static kbd_test_if_t akbd_test_if; 187 static kbd_enable_t akbd_enable; 188 static kbd_disable_t akbd_disable; 189 static kbd_read_t akbd_read; 190 static kbd_check_t akbd_check; 191 static kbd_read_char_t akbd_read_char; 192 static kbd_check_char_t akbd_check_char; 193 static kbd_ioctl_t akbd_ioctl; 194 static kbd_lock_t akbd_lock; 195 static kbd_clear_state_t akbd_clear_state; 196 static kbd_get_state_t akbd_get_state; 197 static kbd_set_state_t akbd_set_state; 198 static kbd_poll_mode_t akbd_poll; 199 200 keyboard_switch_t akbdsw = { 201 .probe = akbd_probe, 202 .init = akbd_init, 203 .term = akbd_term, 204 .intr = akbd_interrupt, 205 .test_if = akbd_test_if, 206 .enable = akbd_enable, 207 .disable = akbd_disable, 208 .read = akbd_read, 209 .check = akbd_check, 210 .read_char = akbd_read_char, 211 .check_char = akbd_check_char, 212 .ioctl = akbd_ioctl, 213 .lock = akbd_lock, 214 .clear_state = akbd_clear_state, 215 .get_state = akbd_get_state, 216 .set_state = akbd_set_state, 217 .poll = akbd_poll, 218 }; 219 220 KEYBOARD_DRIVER(akbd, akbdsw, akbd_configure); 221 222 static int 223 adb_kbd_probe(device_t dev) 224 { 225 uint8_t type; 226 227 type = adb_get_device_type(dev); 228 229 if (type != ADB_DEVICE_KEYBOARD) 230 return (ENXIO); 231 232 switch(adb_get_device_handler(dev)) { 233 case 1: 234 device_set_desc(dev,"Apple Standard Keyboard"); 235 break; 236 case 2: 237 device_set_desc(dev,"Apple Extended Keyboard"); 238 break; 239 case 4: 240 device_set_desc(dev,"Apple ISO Keyboard"); 241 break; 242 case 5: 243 device_set_desc(dev,"Apple Extended ISO Keyboard"); 244 break; 245 case 8: 246 device_set_desc(dev,"Apple Keyboard II"); 247 break; 248 case 9: 249 device_set_desc(dev,"Apple ISO Keyboard II"); 250 break; 251 case 12: 252 device_set_desc(dev,"PowerBook Keyboard"); 253 break; 254 case 13: 255 device_set_desc(dev,"PowerBook ISO Keyboard"); 256 break; 257 case 24: 258 device_set_desc(dev,"PowerBook Extended Keyboard"); 259 break; 260 case 27: 261 device_set_desc(dev,"Apple Design Keyboard"); 262 break; 263 case 195: 264 device_set_desc(dev,"PowerBook G3 Keyboard"); 265 break; 266 case 196: 267 device_set_desc(dev,"iBook Keyboard"); 268 break; 269 default: 270 device_set_desc(dev,"ADB Keyboard"); 271 break; 272 } 273 274 return (0); 275 } 276 277 static int 278 ms_to_ticks(int ms) 279 { 280 if (hz > 1000) 281 return ms*(hz/1000); 282 283 return ms/(1000/hz); 284 } 285 286 static int 287 adb_kbd_attach(device_t dev) 288 { 289 struct adb_kbd_softc *sc; 290 keyboard_switch_t *sw; 291 uint32_t fkeys; 292 phandle_t handle; 293 294 sw = kbd_get_switch(KBD_DRIVER_NAME); 295 if (sw == NULL) { 296 return ENXIO; 297 } 298 299 sc = device_get_softc(dev); 300 sc->sc_dev = dev; 301 sc->sc_mode = K_RAW; 302 sc->sc_state = 0; 303 sc->have_led_control = 0; 304 sc->buffers = 0; 305 306 /* Try stepping forward to the extended keyboard protocol */ 307 adb_set_device_handler(dev,3); 308 309 mtx_init(&sc->sc_mutex, KBD_DRIVER_NAME, NULL, MTX_DEF); 310 cv_init(&sc->sc_cv,KBD_DRIVER_NAME); 311 callout_init(&sc->sc_repeater, 0); 312 313 #ifdef AKBD_EMULATE_ATKBD 314 kbd_init_struct(&sc->sc_kbd, KBD_DRIVER_NAME, KB_101, 0, 0, 0, 0); 315 kbd_set_maps(&sc->sc_kbd, &key_map, &accent_map, fkey_tab, 316 sizeof(fkey_tab) / sizeof(fkey_tab[0])); 317 #else 318 #error ADB raw mode not implemented 319 #endif 320 321 KBD_FOUND_DEVICE(&sc->sc_kbd); 322 KBD_PROBE_DONE(&sc->sc_kbd); 323 KBD_INIT_DONE(&sc->sc_kbd); 324 KBD_CONFIG_DONE(&sc->sc_kbd); 325 326 (*sw->enable)(&sc->sc_kbd); 327 328 kbd_register(&sc->sc_kbd); 329 330 #ifdef KBD_INSTALL_CDEV 331 if (kbd_attach(&sc->sc_kbd)) { 332 adb_kbd_detach(dev); 333 return ENXIO; 334 } 335 #endif 336 337 /* Check if we can read out the LED state from 338 this keyboard by reading the key state register */ 339 if (adb_read_register(dev, 2, NULL) == 2) 340 sc->have_led_control = 1; 341 342 adb_set_autopoll(dev,1); 343 344 handle = OF_finddevice("mac-io/via-pmu/adb/keyboard"); 345 if (handle != -1 && OF_getprop(handle, "AAPL,has-embedded-fn-keys", 346 &fkeys, sizeof(fkeys)) != -1) { 347 static const char *key_names[] = {"F1", "F2", "F3", "F4", "F5", 348 "F6", "F7", "F8", "F9", "F10", "F11", "F12"}; 349 struct sysctl_ctx_list *ctx; 350 struct sysctl_oid *tree; 351 int i; 352 353 if (bootverbose) 354 device_printf(dev, "Keyboard has embedded Fn keys\n"); 355 356 for (i = 0; i < 12; i++) { 357 uint32_t keyval; 358 char buf[3]; 359 if (OF_getprop(handle, key_names[i], &keyval, 360 sizeof(keyval)) < 0) 361 continue; 362 buf[0] = 1; 363 buf[1] = i+1; 364 buf[2] = keyval; 365 adb_write_register(dev, 0, 3, buf); 366 } 367 adb_write_register(dev, 1, 2, &(uint16_t){0}); 368 369 ctx = device_get_sysctl_ctx(dev); 370 tree = device_get_sysctl_tree(dev); 371 372 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 373 "fn_keys_function_as_primary", 374 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 375 0, adb_fn_keys, "I", 376 "Set the Fn keys to be their F-key type as default"); 377 } 378 379 return (0); 380 } 381 382 static int 383 adb_kbd_detach(device_t dev) 384 { 385 struct adb_kbd_softc *sc; 386 keyboard_t *kbd; 387 388 sc = device_get_softc(dev); 389 390 adb_set_autopoll(dev,0); 391 callout_stop(&sc->sc_repeater); 392 393 mtx_lock(&sc->sc_mutex); 394 395 kbd = kbd_get_keyboard(kbd_find_keyboard(KBD_DRIVER_NAME, 396 device_get_unit(dev))); 397 398 kbdd_disable(kbd); 399 400 #ifdef KBD_INSTALL_CDEV 401 kbd_detach(kbd); 402 #endif 403 404 kbdd_term(kbd); 405 406 mtx_unlock(&sc->sc_mutex); 407 408 mtx_destroy(&sc->sc_mutex); 409 cv_destroy(&sc->sc_cv); 410 411 return (0); 412 } 413 414 static u_int 415 adb_kbd_receive_packet(device_t dev, u_char status, 416 u_char command, u_char reg, int len, u_char *data) 417 { 418 struct adb_kbd_softc *sc; 419 420 sc = device_get_softc(dev); 421 422 if (command != ADB_COMMAND_TALK) 423 return 0; 424 425 if (reg != 0 || len != 2) 426 return (0); 427 428 mtx_lock(&sc->sc_mutex); 429 /* 0x7f is always the power button */ 430 if (data[0] == 0x7f) { 431 devctl_notify("PMU", "Button", "pressed", NULL); 432 mtx_unlock(&sc->sc_mutex); 433 return (0); 434 } else if (data[0] == 0xff) { 435 mtx_unlock(&sc->sc_mutex); 436 return (0); /* Ignore power button release. */ 437 } 438 if ((data[0] & 0x7f) == 57 && sc->buffers < 7) { 439 /* Fake the down/up cycle for caps lock */ 440 sc->buffer[sc->buffers++] = data[0] & 0x7f; 441 sc->buffer[sc->buffers++] = (data[0] & 0x7f) | (1 << 7); 442 } else { 443 sc->buffer[sc->buffers++] = data[0]; 444 } 445 if (sc->buffer[sc->buffers-1] < 0xff) 446 sc->last_press = sc->buffer[sc->buffers-1]; 447 448 if ((data[1] & 0x7f) == 57 && sc->buffers < 7) { 449 /* Fake the down/up cycle for caps lock */ 450 sc->buffer[sc->buffers++] = data[1] & 0x7f; 451 sc->buffer[sc->buffers++] = (data[1] & 0x7f) | (1 << 7); 452 } else { 453 sc->buffer[sc->buffers++] = data[1]; 454 } 455 456 if (sc->buffer[sc->buffers-1] < 0xff) 457 sc->last_press = sc->buffer[sc->buffers-1]; 458 459 /* Stop any existing key repeating */ 460 callout_stop(&sc->sc_repeater); 461 462 /* Schedule a repeat callback on keydown */ 463 if (!(sc->last_press & (1 << 7))) { 464 callout_reset(&sc->sc_repeater, 465 ms_to_ticks(sc->sc_kbd.kb_delay1), akbd_repeat, sc); 466 } 467 mtx_unlock(&sc->sc_mutex); 468 469 cv_broadcast(&sc->sc_cv); 470 471 if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) { 472 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd, 473 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg); 474 } 475 476 return (0); 477 } 478 479 static void 480 akbd_repeat(void *xsc) { 481 struct adb_kbd_softc *sc = xsc; 482 int notify_kbd = 0; 483 484 /* Fake an up/down key repeat so long as we have the 485 free buffers */ 486 mtx_lock(&sc->sc_mutex); 487 if (sc->buffers < 7) { 488 sc->buffer[sc->buffers++] = sc->last_press | (1 << 7); 489 sc->buffer[sc->buffers++] = sc->last_press; 490 491 notify_kbd = 1; 492 } 493 mtx_unlock(&sc->sc_mutex); 494 495 if (notify_kbd && KBD_IS_ACTIVE(&sc->sc_kbd) 496 && KBD_IS_BUSY(&sc->sc_kbd)) { 497 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd, 498 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg); 499 } 500 501 /* Reschedule the callout */ 502 callout_reset(&sc->sc_repeater, ms_to_ticks(sc->sc_kbd.kb_delay2), 503 akbd_repeat, sc); 504 } 505 506 static int 507 akbd_configure(int flags) 508 { 509 return 0; 510 } 511 512 static int 513 akbd_probe(int unit, void *arg, int flags) 514 { 515 return 0; 516 } 517 518 static int 519 akbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 520 { 521 return 0; 522 } 523 524 static int 525 akbd_term(keyboard_t *kbd) 526 { 527 return 0; 528 } 529 530 static int 531 akbd_interrupt(keyboard_t *kbd, void *arg) 532 { 533 return 0; 534 } 535 536 static int 537 akbd_test_if(keyboard_t *kbd) 538 { 539 return 0; 540 } 541 542 static int 543 akbd_enable(keyboard_t *kbd) 544 { 545 KBD_ACTIVATE(kbd); 546 return (0); 547 } 548 549 static int 550 akbd_disable(keyboard_t *kbd) 551 { 552 struct adb_kbd_softc *sc; 553 sc = (struct adb_kbd_softc *)(kbd); 554 555 callout_stop(&sc->sc_repeater); 556 KBD_DEACTIVATE(kbd); 557 return (0); 558 } 559 560 static int 561 akbd_read(keyboard_t *kbd, int wait) 562 { 563 return (0); 564 } 565 566 static int 567 akbd_check(keyboard_t *kbd) 568 { 569 struct adb_kbd_softc *sc; 570 571 if (!KBD_IS_ACTIVE(kbd)) 572 return (FALSE); 573 574 sc = (struct adb_kbd_softc *)(kbd); 575 576 mtx_lock(&sc->sc_mutex); 577 #ifdef AKBD_EMULATE_ATKBD 578 if (sc->at_buffered_char[0]) { 579 mtx_unlock(&sc->sc_mutex); 580 return (TRUE); 581 } 582 #endif 583 584 if (sc->buffers > 0) { 585 mtx_unlock(&sc->sc_mutex); 586 return (TRUE); 587 } 588 mtx_unlock(&sc->sc_mutex); 589 590 return (FALSE); 591 } 592 593 static u_int 594 akbd_read_char(keyboard_t *kbd, int wait) 595 { 596 struct adb_kbd_softc *sc; 597 uint16_t key; 598 uint8_t adb_code; 599 int i; 600 601 sc = (struct adb_kbd_softc *)(kbd); 602 603 mtx_lock(&sc->sc_mutex); 604 605 #if defined(AKBD_EMULATE_ATKBD) 606 if (sc->sc_mode == K_RAW && sc->at_buffered_char[0]) { 607 key = sc->at_buffered_char[0]; 608 if (key & SCAN_PREFIX) { 609 sc->at_buffered_char[0] = key & ~SCAN_PREFIX; 610 key = (key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1; 611 } else { 612 sc->at_buffered_char[0] = sc->at_buffered_char[1]; 613 sc->at_buffered_char[1] = 0; 614 } 615 616 mtx_unlock(&sc->sc_mutex); 617 618 return (key); 619 } 620 #endif 621 622 if (!sc->buffers && wait) 623 cv_wait(&sc->sc_cv,&sc->sc_mutex); 624 625 if (!sc->buffers) { 626 mtx_unlock(&sc->sc_mutex); 627 return (NOKEY); 628 } 629 630 adb_code = sc->buffer[0]; 631 632 for (i = 1; i < sc->buffers; i++) 633 sc->buffer[i-1] = sc->buffer[i]; 634 635 sc->buffers--; 636 637 #ifdef AKBD_EMULATE_ATKBD 638 key = adb_to_at_scancode_map[adb_code & 0x7f]; 639 if (sc->sc_mode == K_CODE) { 640 /* Add the key-release bit */ 641 key |= adb_code & 0x80; 642 } else if (sc->sc_mode == K_RAW) { 643 /* 644 * In the raw case, we have to emulate the gross 645 * variable-length AT keyboard thing. Since this code 646 * is copied from sunkbd, which is the same code 647 * as ukbd, it might be nice to have this centralized. 648 */ 649 650 key = keycode2scancode(key, 651 0, adb_code & 0x80); 652 653 if (key & SCAN_PREFIX) { 654 if (key & SCAN_PREFIX_CTL) { 655 sc->at_buffered_char[0] = 656 0x1d | (key & SCAN_RELEASE); 657 sc->at_buffered_char[1] = 658 key & ~SCAN_PREFIX; 659 } else if (key & SCAN_PREFIX_SHIFT) { 660 sc->at_buffered_char[0] = 661 0x2a | (key & SCAN_RELEASE); 662 sc->at_buffered_char[1] = 663 key & ~SCAN_PREFIX_SHIFT; 664 } else { 665 sc->at_buffered_char[0] = 666 key & ~SCAN_PREFIX; 667 sc->at_buffered_char[1] = 0; 668 } 669 670 key = (key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1; 671 } 672 } 673 #else 674 key = adb_code; 675 #endif 676 677 mtx_unlock(&sc->sc_mutex); 678 679 return (key); 680 } 681 682 static int 683 akbd_check_char(keyboard_t *kbd) 684 { 685 if (!KBD_IS_ACTIVE(kbd)) 686 return (FALSE); 687 688 return (akbd_check(kbd)); 689 } 690 691 static int 692 set_typematic(keyboard_t *kbd, int code) 693 { 694 /* These numbers are in microseconds, so convert to ticks */ 695 696 static int delays[] = { 250, 500, 750, 1000 }; 697 static int rates[] = { 34, 38, 42, 46, 50, 55, 59, 63, 698 68, 76, 84, 92, 100, 110, 118, 126, 699 136, 152, 168, 184, 200, 220, 236, 252, 700 272, 304, 336, 368, 400, 440, 472, 504 }; 701 702 if (code & ~0x7f) 703 return EINVAL; 704 kbd->kb_delay1 = delays[(code >> 5) & 3]; 705 kbd->kb_delay2 = rates[code & 0x1f]; 706 return 0; 707 } 708 709 static int akbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t data) 710 { 711 struct adb_kbd_softc *sc; 712 uint16_t r2; 713 int error; 714 715 sc = (struct adb_kbd_softc *)(kbd); 716 error = 0; 717 718 switch (cmd) { 719 case KDGKBMODE: 720 *(int *)data = sc->sc_mode; 721 break; 722 case KDSKBMODE: 723 switch (*(int *)data) { 724 case K_XLATE: 725 if (sc->sc_mode != K_XLATE) { 726 /* make lock key state and LED state match */ 727 sc->sc_state &= ~LOCK_MASK; 728 sc->sc_state |= KBD_LED_VAL(kbd); 729 } 730 /* FALLTHROUGH */ 731 case K_RAW: 732 case K_CODE: 733 if (sc->sc_mode != *(int *)data) 734 sc->sc_mode = *(int *)data; 735 break; 736 default: 737 error = EINVAL; 738 break; 739 } 740 741 break; 742 743 case KDGETLED: 744 *(int *)data = KBD_LED_VAL(kbd); 745 break; 746 747 case KDSKBSTATE: 748 if (*(int *)data & ~LOCK_MASK) { 749 error = EINVAL; 750 break; 751 } 752 sc->sc_state &= ~LOCK_MASK; 753 sc->sc_state |= *(int *)data; 754 755 /* FALLTHROUGH */ 756 757 case KDSETLED: 758 KBD_LED_VAL(kbd) = *(int *)data; 759 760 if (!sc->have_led_control) 761 break; 762 763 r2 = (~0 & 0x04) | 3; 764 765 if (*(int *)data & NLKED) 766 r2 &= ~1; 767 if (*(int *)data & CLKED) 768 r2 &= ~2; 769 if (*(int *)data & SLKED) 770 r2 &= ~4; 771 772 adb_send_packet(sc->sc_dev,ADB_COMMAND_LISTEN,2, 773 sizeof(uint16_t),(u_char *)&r2); 774 775 break; 776 777 case KDGKBSTATE: 778 *(int *)data = sc->sc_state & LOCK_MASK; 779 break; 780 781 case KDSETREPEAT: 782 if (!KBD_HAS_DEVICE(kbd)) 783 return 0; 784 if (((int *)data)[1] < 0) 785 return EINVAL; 786 if (((int *)data)[0] < 0) 787 return EINVAL; 788 else if (((int *)data)[0] == 0) /* fastest possible value */ 789 kbd->kb_delay1 = 200; 790 else 791 kbd->kb_delay1 = ((int *)data)[0]; 792 kbd->kb_delay2 = ((int *)data)[1]; 793 794 break; 795 796 case KDSETRAD: 797 error = set_typematic(kbd, *(int *)data); 798 break; 799 800 case PIO_KEYMAP: 801 case OPIO_KEYMAP: 802 case PIO_KEYMAPENT: 803 case PIO_DEADKEYMAP: 804 default: 805 return (genkbd_commonioctl(kbd, cmd, data)); 806 } 807 808 return (error); 809 } 810 811 static int akbd_lock(keyboard_t *kbd, int lock) 812 { 813 return (0); 814 } 815 816 static void akbd_clear_state(keyboard_t *kbd) 817 { 818 struct adb_kbd_softc *sc; 819 820 sc = (struct adb_kbd_softc *)(kbd); 821 822 mtx_lock(&sc->sc_mutex); 823 824 sc->buffers = 0; 825 callout_stop(&sc->sc_repeater); 826 827 #if defined(AKBD_EMULATE_ATKBD) 828 sc->at_buffered_char[0] = 0; 829 sc->at_buffered_char[1] = 0; 830 #endif 831 mtx_unlock(&sc->sc_mutex); 832 } 833 834 static int akbd_get_state(keyboard_t *kbd, void *buf, size_t len) 835 { 836 return (0); 837 } 838 839 static int akbd_set_state(keyboard_t *kbd, void *buf, size_t len) 840 { 841 return (0); 842 } 843 844 static int akbd_poll(keyboard_t *kbd, int on) 845 { 846 return (0); 847 } 848 849 static int 850 akbd_modevent(module_t mod, int type, void *data) 851 { 852 switch (type) { 853 case MOD_LOAD: 854 kbd_add_driver(&akbd_kbd_driver); 855 break; 856 857 case MOD_UNLOAD: 858 kbd_delete_driver(&akbd_kbd_driver); 859 break; 860 861 default: 862 return (EOPNOTSUPP); 863 } 864 865 return (0); 866 } 867 868 static int 869 adb_fn_keys(SYSCTL_HANDLER_ARGS) 870 { 871 struct adb_kbd_softc *sc = arg1; 872 int error; 873 uint16_t is_fn_enabled; 874 unsigned int is_fn_enabled_sysctl; 875 876 adb_read_register(sc->sc_dev, 1, &is_fn_enabled); 877 is_fn_enabled &= 1; 878 is_fn_enabled_sysctl = is_fn_enabled; 879 error = sysctl_handle_int(oidp, &is_fn_enabled_sysctl, 0, req); 880 881 if (error || !req->newptr) 882 return (error); 883 884 is_fn_enabled = is_fn_enabled_sysctl; 885 if (is_fn_enabled != 1 && is_fn_enabled != 0) 886 return (EINVAL); 887 888 adb_write_register(sc->sc_dev, 1, 2, &is_fn_enabled); 889 return (0); 890 } 891 892 DEV_MODULE(akbd, akbd_modevent, NULL); 893 894