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 akbd_probe, 202 akbd_init, 203 akbd_term, 204 akbd_interrupt, 205 akbd_test_if, 206 akbd_enable, 207 akbd_disable, 208 akbd_read, 209 akbd_check, 210 akbd_read_char, 211 akbd_check_char, 212 akbd_ioctl, 213 akbd_lock, 214 akbd_clear_state, 215 akbd_get_state, 216 akbd_set_state, 217 genkbd_get_fkeystr, 218 akbd_poll, 219 genkbd_diag, 220 }; 221 222 KEYBOARD_DRIVER(akbd, akbdsw, akbd_configure); 223 224 static int 225 adb_kbd_probe(device_t dev) 226 { 227 uint8_t type; 228 229 type = adb_get_device_type(dev); 230 231 if (type != ADB_DEVICE_KEYBOARD) 232 return (ENXIO); 233 234 switch(adb_get_device_handler(dev)) { 235 case 1: 236 device_set_desc(dev,"Apple Standard Keyboard"); 237 break; 238 case 2: 239 device_set_desc(dev,"Apple Extended Keyboard"); 240 break; 241 case 4: 242 device_set_desc(dev,"Apple ISO Keyboard"); 243 break; 244 case 5: 245 device_set_desc(dev,"Apple Extended ISO Keyboard"); 246 break; 247 case 8: 248 device_set_desc(dev,"Apple Keyboard II"); 249 break; 250 case 9: 251 device_set_desc(dev,"Apple ISO Keyboard II"); 252 break; 253 case 12: 254 device_set_desc(dev,"PowerBook Keyboard"); 255 break; 256 case 13: 257 device_set_desc(dev,"PowerBook ISO Keyboard"); 258 break; 259 case 24: 260 device_set_desc(dev,"PowerBook Extended Keyboard"); 261 break; 262 case 27: 263 device_set_desc(dev,"Apple Design Keyboard"); 264 break; 265 case 195: 266 device_set_desc(dev,"PowerBook G3 Keyboard"); 267 break; 268 case 196: 269 device_set_desc(dev,"iBook Keyboard"); 270 break; 271 default: 272 device_set_desc(dev,"ADB Keyboard"); 273 break; 274 } 275 276 return (0); 277 } 278 279 static int 280 ms_to_ticks(int ms) 281 { 282 if (hz > 1000) 283 return ms*(hz/1000); 284 285 return ms/(1000/hz); 286 } 287 288 static int 289 adb_kbd_attach(device_t dev) 290 { 291 struct adb_kbd_softc *sc; 292 keyboard_switch_t *sw; 293 uint32_t fkeys; 294 phandle_t handle; 295 296 sw = kbd_get_switch(KBD_DRIVER_NAME); 297 if (sw == NULL) { 298 return ENXIO; 299 } 300 301 sc = device_get_softc(dev); 302 sc->sc_dev = dev; 303 sc->sc_mode = K_RAW; 304 sc->sc_state = 0; 305 sc->have_led_control = 0; 306 sc->buffers = 0; 307 308 /* Try stepping forward to the extended keyboard protocol */ 309 adb_set_device_handler(dev,3); 310 311 mtx_init(&sc->sc_mutex, KBD_DRIVER_NAME, NULL, MTX_DEF); 312 cv_init(&sc->sc_cv,KBD_DRIVER_NAME); 313 callout_init(&sc->sc_repeater, 0); 314 315 #ifdef AKBD_EMULATE_ATKBD 316 kbd_init_struct(&sc->sc_kbd, KBD_DRIVER_NAME, KB_101, 0, 0, 0, 0); 317 kbd_set_maps(&sc->sc_kbd, &key_map, &accent_map, fkey_tab, 318 sizeof(fkey_tab) / sizeof(fkey_tab[0])); 319 #else 320 #error ADB raw mode not implemented 321 #endif 322 323 KBD_FOUND_DEVICE(&sc->sc_kbd); 324 KBD_PROBE_DONE(&sc->sc_kbd); 325 KBD_INIT_DONE(&sc->sc_kbd); 326 KBD_CONFIG_DONE(&sc->sc_kbd); 327 328 (*sw->enable)(&sc->sc_kbd); 329 330 kbd_register(&sc->sc_kbd); 331 332 #ifdef KBD_INSTALL_CDEV 333 if (kbd_attach(&sc->sc_kbd)) { 334 adb_kbd_detach(dev); 335 return ENXIO; 336 } 337 #endif 338 339 /* Check if we can read out the LED state from 340 this keyboard by reading the key state register */ 341 if (adb_read_register(dev, 2, NULL) == 2) 342 sc->have_led_control = 1; 343 344 adb_set_autopoll(dev,1); 345 346 handle = OF_finddevice("mac-io/via-pmu/adb/keyboard"); 347 if (handle != -1 && OF_getprop(handle, "AAPL,has-embedded-fn-keys", 348 &fkeys, sizeof(fkeys)) != -1) { 349 static const char *key_names[] = {"F1", "F2", "F3", "F4", "F5", 350 "F6", "F7", "F8", "F9", "F10", "F11", "F12"}; 351 struct sysctl_ctx_list *ctx; 352 struct sysctl_oid *tree; 353 int i; 354 355 if (bootverbose) 356 device_printf(dev, "Keyboard has embedded Fn keys\n"); 357 358 for (i = 0; i < 12; i++) { 359 uint32_t keyval; 360 char buf[3]; 361 if (OF_getprop(handle, key_names[i], &keyval, 362 sizeof(keyval)) < 0) 363 continue; 364 buf[0] = 1; 365 buf[1] = i+1; 366 buf[2] = keyval; 367 adb_write_register(dev, 0, 3, buf); 368 } 369 adb_write_register(dev, 1, 2, &(uint16_t){0}); 370 371 ctx = device_get_sysctl_ctx(dev); 372 tree = device_get_sysctl_tree(dev); 373 374 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 375 "fn_keys_function_as_primary", CTLTYPE_INT | CTLFLAG_RW, sc, 376 0, adb_fn_keys, "I", 377 "Set the Fn keys to be their F-key type as default"); 378 } 379 380 return (0); 381 } 382 383 static int 384 adb_kbd_detach(device_t dev) 385 { 386 struct adb_kbd_softc *sc; 387 keyboard_t *kbd; 388 389 sc = device_get_softc(dev); 390 391 adb_set_autopoll(dev,0); 392 callout_stop(&sc->sc_repeater); 393 394 mtx_lock(&sc->sc_mutex); 395 396 kbd = kbd_get_keyboard(kbd_find_keyboard(KBD_DRIVER_NAME, 397 device_get_unit(dev))); 398 399 kbdd_disable(kbd); 400 401 #ifdef KBD_INSTALL_CDEV 402 kbd_detach(kbd); 403 #endif 404 405 kbdd_term(kbd); 406 407 mtx_unlock(&sc->sc_mutex); 408 409 mtx_destroy(&sc->sc_mutex); 410 cv_destroy(&sc->sc_cv); 411 412 return (0); 413 } 414 415 static u_int 416 adb_kbd_receive_packet(device_t dev, u_char status, 417 u_char command, u_char reg, int len, u_char *data) 418 { 419 struct adb_kbd_softc *sc; 420 421 sc = device_get_softc(dev); 422 423 if (command != ADB_COMMAND_TALK) 424 return 0; 425 426 if (reg != 0 || len != 2) 427 return (0); 428 429 mtx_lock(&sc->sc_mutex); 430 /* 0x7f is always the power button */ 431 if (data[0] == 0x7f) { 432 devctl_notify("PMU", "Button", "pressed", NULL); 433 mtx_unlock(&sc->sc_mutex); 434 return (0); 435 } else if (data[0] == 0xff) { 436 mtx_unlock(&sc->sc_mutex); 437 return (0); /* Ignore power button release. */ 438 } 439 if ((data[0] & 0x7f) == 57 && sc->buffers < 7) { 440 /* Fake the down/up cycle for caps lock */ 441 sc->buffer[sc->buffers++] = data[0] & 0x7f; 442 sc->buffer[sc->buffers++] = (data[0] & 0x7f) | (1 << 7); 443 } else { 444 sc->buffer[sc->buffers++] = data[0]; 445 } 446 if (sc->buffer[sc->buffers-1] < 0xff) 447 sc->last_press = sc->buffer[sc->buffers-1]; 448 449 if ((data[1] & 0x7f) == 57 && sc->buffers < 7) { 450 /* Fake the down/up cycle for caps lock */ 451 sc->buffer[sc->buffers++] = data[1] & 0x7f; 452 sc->buffer[sc->buffers++] = (data[1] & 0x7f) | (1 << 7); 453 } else { 454 sc->buffer[sc->buffers++] = data[1]; 455 } 456 457 if (sc->buffer[sc->buffers-1] < 0xff) 458 sc->last_press = sc->buffer[sc->buffers-1]; 459 460 /* Stop any existing key repeating */ 461 callout_stop(&sc->sc_repeater); 462 463 /* Schedule a repeat callback on keydown */ 464 if (!(sc->last_press & (1 << 7))) { 465 callout_reset(&sc->sc_repeater, 466 ms_to_ticks(sc->sc_kbd.kb_delay1), akbd_repeat, sc); 467 } 468 mtx_unlock(&sc->sc_mutex); 469 470 cv_broadcast(&sc->sc_cv); 471 472 if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) { 473 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd, 474 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg); 475 } 476 477 return (0); 478 } 479 480 static void 481 akbd_repeat(void *xsc) { 482 struct adb_kbd_softc *sc = xsc; 483 int notify_kbd = 0; 484 485 /* Fake an up/down key repeat so long as we have the 486 free buffers */ 487 mtx_lock(&sc->sc_mutex); 488 if (sc->buffers < 7) { 489 sc->buffer[sc->buffers++] = sc->last_press | (1 << 7); 490 sc->buffer[sc->buffers++] = sc->last_press; 491 492 notify_kbd = 1; 493 } 494 mtx_unlock(&sc->sc_mutex); 495 496 if (notify_kbd && KBD_IS_ACTIVE(&sc->sc_kbd) 497 && KBD_IS_BUSY(&sc->sc_kbd)) { 498 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd, 499 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg); 500 } 501 502 /* Reschedule the callout */ 503 callout_reset(&sc->sc_repeater, ms_to_ticks(sc->sc_kbd.kb_delay2), 504 akbd_repeat, sc); 505 } 506 507 static int 508 akbd_configure(int flags) 509 { 510 return 0; 511 } 512 513 static int 514 akbd_probe(int unit, void *arg, int flags) 515 { 516 return 0; 517 } 518 519 static int 520 akbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 521 { 522 return 0; 523 } 524 525 static int 526 akbd_term(keyboard_t *kbd) 527 { 528 return 0; 529 } 530 531 static int 532 akbd_interrupt(keyboard_t *kbd, void *arg) 533 { 534 return 0; 535 } 536 537 static int 538 akbd_test_if(keyboard_t *kbd) 539 { 540 return 0; 541 } 542 543 static int 544 akbd_enable(keyboard_t *kbd) 545 { 546 KBD_ACTIVATE(kbd); 547 return (0); 548 } 549 550 static int 551 akbd_disable(keyboard_t *kbd) 552 { 553 struct adb_kbd_softc *sc; 554 sc = (struct adb_kbd_softc *)(kbd); 555 556 callout_stop(&sc->sc_repeater); 557 KBD_DEACTIVATE(kbd); 558 return (0); 559 } 560 561 static int 562 akbd_read(keyboard_t *kbd, int wait) 563 { 564 return (0); 565 } 566 567 static int 568 akbd_check(keyboard_t *kbd) 569 { 570 struct adb_kbd_softc *sc; 571 572 if (!KBD_IS_ACTIVE(kbd)) 573 return (FALSE); 574 575 sc = (struct adb_kbd_softc *)(kbd); 576 577 mtx_lock(&sc->sc_mutex); 578 #ifdef AKBD_EMULATE_ATKBD 579 if (sc->at_buffered_char[0]) { 580 mtx_unlock(&sc->sc_mutex); 581 return (TRUE); 582 } 583 #endif 584 585 if (sc->buffers > 0) { 586 mtx_unlock(&sc->sc_mutex); 587 return (TRUE); 588 } 589 mtx_unlock(&sc->sc_mutex); 590 591 return (FALSE); 592 } 593 594 static u_int 595 akbd_read_char(keyboard_t *kbd, int wait) 596 { 597 struct adb_kbd_softc *sc; 598 uint16_t key; 599 uint8_t adb_code; 600 int i; 601 602 sc = (struct adb_kbd_softc *)(kbd); 603 604 mtx_lock(&sc->sc_mutex); 605 606 #if defined(AKBD_EMULATE_ATKBD) 607 if (sc->sc_mode == K_RAW && sc->at_buffered_char[0]) { 608 key = sc->at_buffered_char[0]; 609 if (key & SCAN_PREFIX) { 610 sc->at_buffered_char[0] = key & ~SCAN_PREFIX; 611 key = (key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1; 612 } else { 613 sc->at_buffered_char[0] = sc->at_buffered_char[1]; 614 sc->at_buffered_char[1] = 0; 615 } 616 617 mtx_unlock(&sc->sc_mutex); 618 619 return (key); 620 } 621 #endif 622 623 if (!sc->buffers && wait) 624 cv_wait(&sc->sc_cv,&sc->sc_mutex); 625 626 if (!sc->buffers) { 627 mtx_unlock(&sc->sc_mutex); 628 return (NOKEY); 629 } 630 631 adb_code = sc->buffer[0]; 632 633 for (i = 1; i < sc->buffers; i++) 634 sc->buffer[i-1] = sc->buffer[i]; 635 636 sc->buffers--; 637 638 #ifdef AKBD_EMULATE_ATKBD 639 key = adb_to_at_scancode_map[adb_code & 0x7f]; 640 if (sc->sc_mode == K_CODE) { 641 /* Add the key-release bit */ 642 key |= adb_code & 0x80; 643 } else if (sc->sc_mode == K_RAW) { 644 /* 645 * In the raw case, we have to emulate the gross 646 * variable-length AT keyboard thing. Since this code 647 * is copied from sunkbd, which is the same code 648 * as ukbd, it might be nice to have this centralized. 649 */ 650 651 key = keycode2scancode(key, 652 0, adb_code & 0x80); 653 654 if (key & SCAN_PREFIX) { 655 if (key & SCAN_PREFIX_CTL) { 656 sc->at_buffered_char[0] = 657 0x1d | (key & SCAN_RELEASE); 658 sc->at_buffered_char[1] = 659 key & ~SCAN_PREFIX; 660 } else if (key & SCAN_PREFIX_SHIFT) { 661 sc->at_buffered_char[0] = 662 0x2a | (key & SCAN_RELEASE); 663 sc->at_buffered_char[1] = 664 key & ~SCAN_PREFIX_SHIFT; 665 } else { 666 sc->at_buffered_char[0] = 667 key & ~SCAN_PREFIX; 668 sc->at_buffered_char[1] = 0; 669 } 670 671 key = (key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1; 672 } 673 } 674 #else 675 key = adb_code; 676 #endif 677 678 mtx_unlock(&sc->sc_mutex); 679 680 return (key); 681 } 682 683 static int 684 akbd_check_char(keyboard_t *kbd) 685 { 686 if (!KBD_IS_ACTIVE(kbd)) 687 return (FALSE); 688 689 return (akbd_check(kbd)); 690 } 691 692 static int 693 set_typematic(keyboard_t *kbd, int code) 694 { 695 /* These numbers are in microseconds, so convert to ticks */ 696 697 static int delays[] = { 250, 500, 750, 1000 }; 698 static int rates[] = { 34, 38, 42, 46, 50, 55, 59, 63, 699 68, 76, 84, 92, 100, 110, 118, 126, 700 136, 152, 168, 184, 200, 220, 236, 252, 701 272, 304, 336, 368, 400, 440, 472, 504 }; 702 703 if (code & ~0x7f) 704 return EINVAL; 705 kbd->kb_delay1 = delays[(code >> 5) & 3]; 706 kbd->kb_delay2 = rates[code & 0x1f]; 707 return 0; 708 } 709 710 static int akbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t data) 711 { 712 struct adb_kbd_softc *sc; 713 uint16_t r2; 714 int error; 715 716 sc = (struct adb_kbd_softc *)(kbd); 717 error = 0; 718 719 switch (cmd) { 720 case KDGKBMODE: 721 *(int *)data = sc->sc_mode; 722 break; 723 case KDSKBMODE: 724 switch (*(int *)data) { 725 case K_XLATE: 726 if (sc->sc_mode != K_XLATE) { 727 /* make lock key state and LED state match */ 728 sc->sc_state &= ~LOCK_MASK; 729 sc->sc_state |= KBD_LED_VAL(kbd); 730 } 731 /* FALLTHROUGH */ 732 case K_RAW: 733 case K_CODE: 734 if (sc->sc_mode != *(int *)data) 735 sc->sc_mode = *(int *)data; 736 break; 737 default: 738 error = EINVAL; 739 break; 740 } 741 742 break; 743 744 case KDGETLED: 745 *(int *)data = KBD_LED_VAL(kbd); 746 break; 747 748 case KDSKBSTATE: 749 if (*(int *)data & ~LOCK_MASK) { 750 error = EINVAL; 751 break; 752 } 753 sc->sc_state &= ~LOCK_MASK; 754 sc->sc_state |= *(int *)data; 755 756 /* FALLTHROUGH */ 757 758 case KDSETLED: 759 KBD_LED_VAL(kbd) = *(int *)data; 760 761 if (!sc->have_led_control) 762 break; 763 764 r2 = (~0 & 0x04) | 3; 765 766 if (*(int *)data & NLKED) 767 r2 &= ~1; 768 if (*(int *)data & CLKED) 769 r2 &= ~2; 770 if (*(int *)data & SLKED) 771 r2 &= ~4; 772 773 adb_send_packet(sc->sc_dev,ADB_COMMAND_LISTEN,2, 774 sizeof(uint16_t),(u_char *)&r2); 775 776 break; 777 778 case KDGKBSTATE: 779 *(int *)data = sc->sc_state & LOCK_MASK; 780 break; 781 782 case KDSETREPEAT: 783 if (!KBD_HAS_DEVICE(kbd)) 784 return 0; 785 if (((int *)data)[1] < 0) 786 return EINVAL; 787 if (((int *)data)[0] < 0) 788 return EINVAL; 789 else if (((int *)data)[0] == 0) /* fastest possible value */ 790 kbd->kb_delay1 = 200; 791 else 792 kbd->kb_delay1 = ((int *)data)[0]; 793 kbd->kb_delay2 = ((int *)data)[1]; 794 795 break; 796 797 case KDSETRAD: 798 error = set_typematic(kbd, *(int *)data); 799 break; 800 801 case PIO_KEYMAP: 802 case OPIO_KEYMAP: 803 case PIO_KEYMAPENT: 804 case PIO_DEADKEYMAP: 805 default: 806 return (genkbd_commonioctl(kbd, cmd, data)); 807 } 808 809 return (error); 810 } 811 812 static int akbd_lock(keyboard_t *kbd, int lock) 813 { 814 return (0); 815 } 816 817 static void akbd_clear_state(keyboard_t *kbd) 818 { 819 struct adb_kbd_softc *sc; 820 821 sc = (struct adb_kbd_softc *)(kbd); 822 823 mtx_lock(&sc->sc_mutex); 824 825 sc->buffers = 0; 826 callout_stop(&sc->sc_repeater); 827 828 #if defined(AKBD_EMULATE_ATKBD) 829 sc->at_buffered_char[0] = 0; 830 sc->at_buffered_char[1] = 0; 831 #endif 832 mtx_unlock(&sc->sc_mutex); 833 } 834 835 static int akbd_get_state(keyboard_t *kbd, void *buf, size_t len) 836 { 837 return (0); 838 } 839 840 static int akbd_set_state(keyboard_t *kbd, void *buf, size_t len) 841 { 842 return (0); 843 } 844 845 static int akbd_poll(keyboard_t *kbd, int on) 846 { 847 return (0); 848 } 849 850 static int 851 akbd_modevent(module_t mod, int type, void *data) 852 { 853 switch (type) { 854 case MOD_LOAD: 855 kbd_add_driver(&akbd_kbd_driver); 856 break; 857 858 case MOD_UNLOAD: 859 kbd_delete_driver(&akbd_kbd_driver); 860 break; 861 862 default: 863 return (EOPNOTSUPP); 864 } 865 866 return (0); 867 } 868 869 static int 870 adb_fn_keys(SYSCTL_HANDLER_ARGS) 871 { 872 struct adb_kbd_softc *sc = arg1; 873 int error; 874 uint16_t is_fn_enabled; 875 unsigned int is_fn_enabled_sysctl; 876 877 adb_read_register(sc->sc_dev, 1, &is_fn_enabled); 878 is_fn_enabled &= 1; 879 is_fn_enabled_sysctl = is_fn_enabled; 880 error = sysctl_handle_int(oidp, &is_fn_enabled_sysctl, 0, req); 881 882 if (error || !req->newptr) 883 return (error); 884 885 is_fn_enabled = is_fn_enabled_sysctl; 886 if (is_fn_enabled != 1 && is_fn_enabled != 0) 887 return (EINVAL); 888 889 adb_write_register(sc->sc_dev, 1, 2, &is_fn_enabled); 890 return (0); 891 } 892 893 DEV_MODULE(akbd, akbd_modevent, NULL); 894 895