1 /*- 2 * Copyright (c) 2003 Jake Burkholder. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include "opt_compat.h" 31 #include "opt_kbd.h" 32 #include "opt_sunkbd.h" 33 34 #if (defined(SUNKBD_EMULATE_ATKBD) && defined(SUNKBD_DFLT_KEYMAP)) || \ 35 !defined(SUNKBD_EMULATE_ATKBD) 36 #define KBD_DFLT_KEYMAP 37 #endif 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/bus.h> 42 #include <sys/interrupt.h> 43 #include <sys/kbio.h> 44 #include <sys/kernel.h> 45 #include <sys/limits.h> 46 47 #include <machine/bus.h> 48 49 #include <dev/kbd/kbdreg.h> 50 #include <dev/kbd/kbdtables.h> 51 52 #include <dev/uart/uart.h> 53 #include <dev/uart/uart_bus.h> 54 #include <dev/uart/uart_cpu.h> 55 56 #include <dev/uart/uart_kbd_sun.h> 57 #if !defined(SUNKBD_EMULATE_ATKBD) 58 #include <dev/uart/uart_kbd_sun_tables.h> 59 #endif 60 61 #if defined(SUNKBD_EMULATE_ATKBD) && defined(SUNKBD_DFLT_KEYMAP) 62 #include "sunkbdmap.h" 63 #endif 64 #include "uart_if.h" 65 66 #define SUNKBD_DRIVER_NAME "sunkbd" 67 68 #define TODO printf("%s: unimplemented", __func__) 69 70 struct sunkbd_softc { 71 keyboard_t sc_kbd; 72 struct uart_softc *sc_uart; 73 struct uart_devinfo *sc_sysdev; 74 75 struct callout sc_repeat_callout; 76 int sc_repeat_key; 77 78 int sc_accents; 79 int sc_composed_char; 80 int sc_flags; 81 #define KPCOMPOSE (1 << 0) 82 int sc_mode; 83 int sc_polling; 84 int sc_repeating; 85 int sc_state; 86 87 #if defined(SUNKBD_EMULATE_ATKBD) 88 int sc_buffered_char[2]; 89 #endif 90 }; 91 92 static int sunkbd_configure(int flags); 93 static int sunkbd_probe_keyboard(struct uart_devinfo *di); 94 95 static int sunkbd_probe(int unit, void *arg, int flags); 96 static int sunkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags); 97 static int sunkbd_term(keyboard_t *kbd); 98 static int sunkbd_intr(keyboard_t *kbd, void *arg); 99 static int sunkbd_test_if(keyboard_t *kbd); 100 static int sunkbd_enable(keyboard_t *kbd); 101 static int sunkbd_disable(keyboard_t *kbd); 102 static int sunkbd_read(keyboard_t *kbd, int wait); 103 static int sunkbd_check(keyboard_t *kbd); 104 static u_int sunkbd_read_char(keyboard_t *kbd, int wait); 105 static int sunkbd_check_char(keyboard_t *kbd); 106 static int sunkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t data); 107 static int sunkbd_lock(keyboard_t *kbd, int lock); 108 static void sunkbd_clear_state(keyboard_t *kbd); 109 static int sunkbd_get_state(keyboard_t *kbd, void *buf, size_t len); 110 static int sunkbd_set_state(keyboard_t *kbd, void *buf, size_t len); 111 static int sunkbd_poll_mode(keyboard_t *kbd, int on); 112 static void sunkbd_diag(keyboard_t *kbd, int level); 113 114 static void sunkbd_repeat(void *v); 115 #if defined(SUNKBD_EMULATE_ATKBD) 116 static int keycode2scancode(int keycode, int shift, int up); 117 #endif 118 119 static keyboard_switch_t sunkbdsw = { 120 sunkbd_probe, 121 sunkbd_init, 122 sunkbd_term, 123 sunkbd_intr, 124 sunkbd_test_if, 125 sunkbd_enable, 126 sunkbd_disable, 127 sunkbd_read, 128 sunkbd_check, 129 sunkbd_read_char, 130 sunkbd_check_char, 131 sunkbd_ioctl, 132 sunkbd_lock, 133 sunkbd_clear_state, 134 sunkbd_get_state, 135 sunkbd_set_state, 136 genkbd_get_fkeystr, 137 sunkbd_poll_mode, 138 sunkbd_diag 139 }; 140 141 KEYBOARD_DRIVER(sunkbd, sunkbdsw, sunkbd_configure); 142 143 static struct sunkbd_softc sunkbd_softc; 144 static struct uart_devinfo uart_keyboard; 145 146 #if defined(SUNKBD_EMULATE_ATKBD) 147 148 #define SCAN_PRESS 0x000 149 #define SCAN_RELEASE 0x080 150 #define SCAN_PREFIX_E0 0x100 151 #define SCAN_PREFIX_E1 0x200 152 #define SCAN_PREFIX_CTL 0x400 153 #define SCAN_PREFIX_SHIFT 0x800 154 #define SCAN_PREFIX (SCAN_PREFIX_E0 | SCAN_PREFIX_E1 | \ 155 SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT) 156 157 #define NOTR 0x0 /* no translation */ 158 159 static const uint8_t sunkbd_trtab[] = { 160 NOTR, 0x6d, 0x78, 0x6e, 0x79, 0x3b, 0x3c, 0x44, /* 0x00 - 0x07 */ 161 0x3d, 0x57, 0x3e, 0x58, 0x3f, 0x5d, 0x40, NOTR, /* 0x08 - 0x0f */ 162 0x41, 0x42, 0x43, 0x38, 0x5f, 0x68, 0x5c, 0x46, /* 0x10 - 0x17 */ 163 0x61, 0x6f, 0x70, 0x64, 0x62, 0x01, 0x02, 0x03, /* 0x18 - 0x1f */ 164 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, /* 0x20 - 0x27 */ 165 0x0c, 0x0d, 0x29, 0x0e, 0x66, 0x77, 0x5b, 0x37, /* 0x28 - 0x2f */ 166 0x7a, 0x71, 0x53, 0x74, 0x5e, 0x0f, 0x10, 0x11, /* 0x30 - 0x37 */ 167 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, /* 0x38 - 0x3f */ 168 0x1a, 0x1b, 0x67, 0x6b, 0x47, 0x48, 0x49, 0x4a, /* 0x40 - 0x47 */ 169 0x73, 0x72, 0x63, NOTR, 0x1d, 0x1e, 0x1f, 0x20, /* 0x48 - 0x4f */ 170 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, /* 0x50 - 0x57 */ 171 0x2b, 0x1c, 0x59, 0x4b, 0x4c, 0x4d, 0x52, 0x75, /* 0x58 - 0x5f */ 172 0x60, 0x76, 0x45, 0x2a, 0x2c, 0x2d, 0x2e, 0x2f, /* 0x60 - 0x67 */ 173 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, NOTR, /* 0x68 - 0x6f */ 174 0x4f, 0x50, 0x51, NOTR, NOTR, NOTR, 0x6c, 0x3a, /* 0x70 - 0x77 */ 175 0x69, 0x39, 0x6a, 0x65, 0x56, 0x4e, NOTR, NOTR /* 0x78 - 0x7f */ 176 }; 177 178 #endif 179 180 static int 181 sunkbd_probe_keyboard(struct uart_devinfo *di) 182 { 183 int c, id, ltries, tries; 184 185 for (tries = 5; tries != 0; tries--) { 186 uart_putc(di, SKBD_CMD_RESET); 187 for (ltries = 1000; ltries != 0; ltries--) { 188 if (uart_poll(di) == SKBD_RSP_RESET) 189 break; 190 DELAY(1000); 191 } 192 if (ltries == 0) 193 continue; 194 id = -1; 195 for (ltries = 1000; ltries != 0; ltries--) { 196 switch (c = uart_poll(di)) { 197 case -1: 198 break; 199 case SKBD_RSP_IDLE: 200 return (id); 201 default: 202 id = c; 203 } 204 DELAY(1000); 205 } 206 } 207 return (-1); 208 } 209 210 static int sunkbd_attach(struct uart_softc *sc); 211 static void sunkbd_uart_intr(void *arg); 212 213 static int 214 sunkbd_configure(int flags) 215 { 216 struct sunkbd_softc *sc; 217 218 /* 219 * We are only prepared to be used for the high-level console 220 * when the keyboard is both configured and attached. 221 */ 222 if (!(flags & KB_CONF_PROBE_ONLY)) { 223 if (KBD_IS_INITIALIZED(&sunkbd_softc.sc_kbd)) 224 goto found; 225 else 226 return (0); 227 } 228 229 if (uart_cpu_getdev(UART_DEV_KEYBOARD, &uart_keyboard)) 230 return (0); 231 if (uart_probe(&uart_keyboard)) 232 return (0); 233 uart_init(&uart_keyboard); 234 235 uart_keyboard.type = UART_DEV_KEYBOARD; 236 uart_keyboard.attach = sunkbd_attach; 237 uart_add_sysdev(&uart_keyboard); 238 239 if (sunkbd_probe_keyboard(&uart_keyboard) != KB_SUN4) 240 return (0); 241 242 sc = &sunkbd_softc; 243 callout_init(&sc->sc_repeat_callout, 0); 244 sunkbd_clear_state(&sc->sc_kbd); 245 246 #if defined(SUNKBD_EMULATE_ATKBD) 247 kbd_init_struct(&sc->sc_kbd, SUNKBD_DRIVER_NAME, KB_101, 0, 0, 0, 0); 248 kbd_set_maps(&sc->sc_kbd, &key_map, &accent_map, fkey_tab, 249 sizeof(fkey_tab) / sizeof(fkey_tab[0])); 250 #else 251 kbd_init_struct(&sc->sc_kbd, SUNKBD_DRIVER_NAME, KB_OTHER, 0, 0, 0, 0); 252 kbd_set_maps(&sc->sc_kbd, &keymap_sun_us_unix_kbd, 253 &accentmap_sun_us_unix_kbd, fkey_tab, 254 sizeof(fkey_tab) / sizeof(fkey_tab[0])); 255 #endif 256 sc->sc_mode = K_XLATE; 257 kbd_register(&sc->sc_kbd); 258 259 sc->sc_sysdev = &uart_keyboard; 260 261 found: 262 /* Return number of found keyboards. */ 263 return (1); 264 } 265 266 static int 267 sunkbd_attach(struct uart_softc *sc) 268 { 269 270 /* 271 * Don't attach if we didn't probe the keyboard. Note that 272 * the UART is still marked as a system device in that case. 273 */ 274 if (sunkbd_softc.sc_sysdev == NULL) { 275 device_printf(sc->sc_dev, "keyboard not present\n"); 276 return (0); 277 } 278 279 if (sc->sc_sysdev != NULL) { 280 sunkbd_softc.sc_uart = sc; 281 282 #ifdef KBD_INSTALL_CDEV 283 kbd_attach(&sunkbd_softc.sc_kbd); 284 #endif 285 sunkbd_enable(&sunkbd_softc.sc_kbd); 286 287 swi_add(&tty_intr_event, uart_driver_name, sunkbd_uart_intr, 288 &sunkbd_softc, SWI_TTY, INTR_TYPE_TTY, &sc->sc_softih); 289 290 sc->sc_opened = 1; 291 KBD_INIT_DONE(&sunkbd_softc.sc_kbd); 292 } 293 294 return (0); 295 } 296 297 static void 298 sunkbd_uart_intr(void *arg) 299 { 300 struct sunkbd_softc *sc = arg; 301 int pend; 302 303 if (sc->sc_uart->sc_leaving) 304 return; 305 306 pend = atomic_readandclear_32(&sc->sc_uart->sc_ttypend); 307 if (!(pend & SER_INT_MASK)) 308 return; 309 310 if (pend & SER_INT_RXREADY) { 311 if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) { 312 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd, 313 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg); 314 } 315 } 316 } 317 318 static int 319 sunkbd_probe(int unit, void *arg, int flags) 320 { 321 322 TODO; 323 return (0); 324 } 325 326 static int 327 sunkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 328 { 329 330 TODO; 331 return (0); 332 } 333 334 static int 335 sunkbd_term(keyboard_t *kbd) 336 { 337 338 TODO; 339 return (0); 340 } 341 342 static int 343 sunkbd_intr(keyboard_t *kbd, void *arg) 344 { 345 346 TODO; 347 return (0); 348 } 349 350 static int 351 sunkbd_test_if(keyboard_t *kbd) 352 { 353 354 TODO; 355 return (0); 356 } 357 358 static int 359 sunkbd_enable(keyboard_t *kbd) 360 { 361 362 KBD_ACTIVATE(kbd); 363 return (0); 364 } 365 366 static int 367 sunkbd_disable(keyboard_t *kbd) 368 { 369 370 KBD_DEACTIVATE(kbd); 371 return (0); 372 } 373 374 static int 375 sunkbd_read(keyboard_t *kbd, int wait) 376 { 377 378 TODO; 379 return (0); 380 } 381 382 static int 383 sunkbd_check(keyboard_t *kbd) 384 { 385 struct sunkbd_softc *sc; 386 387 if (!KBD_IS_ACTIVE(kbd)) 388 return (FALSE); 389 390 sc = (struct sunkbd_softc *)kbd; 391 392 #if defined(SUNKBD_EMULATE_ATKBD) 393 if (sc->sc_buffered_char[0]) 394 return (TRUE); 395 #endif 396 397 if (sc->sc_repeating) 398 return (TRUE); 399 400 if (sc->sc_uart != NULL && !uart_rx_empty(sc->sc_uart)) 401 return (TRUE); 402 403 if (sc->sc_polling != 0 && sc->sc_sysdev != NULL && 404 uart_rxready(sc->sc_sysdev)) 405 return (TRUE); 406 407 return (FALSE); 408 } 409 410 static u_int 411 sunkbd_read_char(keyboard_t *kbd, int wait) 412 { 413 struct sunkbd_softc *sc; 414 int key, release, repeated, suncode; 415 416 sc = (struct sunkbd_softc *)kbd; 417 418 #if defined(SUNKBD_EMULATE_ATKBD) 419 if (sc->sc_mode == K_RAW && sc->sc_buffered_char[0]) { 420 key = sc->sc_buffered_char[0]; 421 if (key & SCAN_PREFIX) { 422 sc->sc_buffered_char[0] = key & ~SCAN_PREFIX; 423 return ((key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1); 424 } else { 425 sc->sc_buffered_char[0] = sc->sc_buffered_char[1]; 426 sc->sc_buffered_char[1] = 0; 427 return (key); 428 } 429 } 430 #endif 431 432 repeated = 0; 433 if (sc->sc_repeating) { 434 repeated = 1; 435 sc->sc_repeating = 0; 436 callout_reset(&sc->sc_repeat_callout, hz / 10, 437 sunkbd_repeat, sc); 438 suncode = sc->sc_repeat_key; 439 goto process_code; 440 } 441 442 for (;;) { 443 next_code: 444 if (!(sc->sc_flags & KPCOMPOSE) && (sc->sc_composed_char > 0)) { 445 key = sc->sc_composed_char; 446 sc->sc_composed_char = 0; 447 if (key > UCHAR_MAX) 448 return (ERRKEY); 449 return (key); 450 } 451 452 if (sc->sc_uart != NULL && !uart_rx_empty(sc->sc_uart)) { 453 suncode = uart_rx_get(sc->sc_uart); 454 } else if (sc->sc_polling != 0 && sc->sc_sysdev != NULL) { 455 if (wait) 456 suncode = uart_getc(sc->sc_sysdev); 457 else if ((suncode = uart_poll(sc->sc_sysdev)) == -1) 458 return (NOKEY); 459 } else { 460 return (NOKEY); 461 } 462 463 switch (suncode) { 464 case SKBD_RSP_IDLE: 465 break; 466 default: 467 process_code: 468 ++kbd->kb_count; 469 key = SKBD_KEY_CHAR(suncode); 470 release = suncode & SKBD_KEY_RELEASE; 471 if (!repeated) { 472 if (release == 0) { 473 callout_reset(&sc->sc_repeat_callout, 474 hz / 2, sunkbd_repeat, sc); 475 sc->sc_repeat_key = suncode; 476 } else if (sc->sc_repeat_key == key) { 477 callout_stop(&sc->sc_repeat_callout); 478 sc->sc_repeat_key = -1; 479 } 480 } 481 482 #if defined(SUNKBD_EMULATE_ATKBD) 483 key = sunkbd_trtab[key]; 484 if (key == NOTR) 485 return (NOKEY); 486 487 if (!repeated) { 488 switch (key) { 489 case 0x1d: /* ctrl */ 490 if (release != 0) 491 sc->sc_flags &= ~CTLS; 492 else 493 sc->sc_flags |= CTLS; 494 break; 495 case 0x2a: /* left shift */ 496 case 0x36: /* right shift */ 497 if (release != 0) 498 sc->sc_flags &= ~SHIFTS; 499 else 500 sc->sc_flags |= SHIFTS; 501 break; 502 case 0x38: /* alt */ 503 case 0x5d: /* altgr */ 504 if (release != 0) 505 sc->sc_flags &= ~ALTS; 506 else 507 sc->sc_flags |= ALTS; 508 break; 509 } 510 } 511 if (sc->sc_mode == K_RAW) { 512 key = keycode2scancode(key, sc->sc_flags, 513 release); 514 if (key & SCAN_PREFIX) { 515 if (key & SCAN_PREFIX_CTL) { 516 sc->sc_buffered_char[0] = 517 0x1d | (key & SCAN_RELEASE); 518 sc->sc_buffered_char[1] = 519 key & ~SCAN_PREFIX; 520 } else if (key & SCAN_PREFIX_SHIFT) { 521 sc->sc_buffered_char[0] = 522 0x2a | (key & SCAN_RELEASE); 523 sc->sc_buffered_char[1] = 524 key & ~SCAN_PREFIX_SHIFT; 525 } else { 526 sc->sc_buffered_char[0] = 527 key & ~SCAN_PREFIX; 528 sc->sc_buffered_char[1] = 0; 529 } 530 return ((key & SCAN_PREFIX_E0) ? 531 0xe0 : 0xe1); 532 } 533 return (key); 534 } 535 switch (key) { 536 case 0x5c: /* print screen */ 537 if (sc->sc_flags & ALTS) 538 key = 0x54; /* sysrq */ 539 break; 540 case 0x68: /* pause/break */ 541 if (sc->sc_flags & CTLS) 542 key = 0x6c; /* break */ 543 break; 544 } 545 546 if (sc->sc_mode == K_CODE) 547 return (key | release); 548 #else 549 if (sc->sc_mode == K_RAW || sc->sc_mode == K_CODE) 550 return (suncode); 551 #endif 552 553 #if defined(SUNKBD_EMULATE_ATKBD) 554 if (key == 0x38) { /* left alt (KP compose key) */ 555 #else 556 if (key == 0x13) { /* left alt (KP compose key) */ 557 #endif 558 if (release != 0) { 559 if (sc->sc_flags & KPCOMPOSE) { 560 sc->sc_flags &= ~KPCOMPOSE; 561 if (sc->sc_composed_char > 562 UCHAR_MAX) 563 sc->sc_composed_char = 564 0; 565 } 566 } else { 567 if (!(sc->sc_flags & KPCOMPOSE)) { 568 sc->sc_flags |= KPCOMPOSE; 569 sc->sc_composed_char = 0; 570 } 571 } 572 } 573 if (sc->sc_flags & KPCOMPOSE) { 574 switch (suncode) { 575 case 0x44: /* KP 7 */ 576 case 0x45: /* KP 8 */ 577 case 0x46: /* KP 9 */ 578 sc->sc_composed_char *= 10; 579 sc->sc_composed_char += suncode - 0x3d; 580 if (sc->sc_composed_char > UCHAR_MAX) 581 return (ERRKEY); 582 goto next_code; 583 case 0x5b: /* KP 4 */ 584 case 0x5c: /* KP 5 */ 585 case 0x5d: /* KP 6 */ 586 sc->sc_composed_char *= 10; 587 sc->sc_composed_char += suncode - 0x58; 588 if (sc->sc_composed_char > UCHAR_MAX) 589 return (ERRKEY); 590 goto next_code; 591 case 0x70: /* KP 1 */ 592 case 0x71: /* KP 2 */ 593 case 0x72: /* KP 3 */ 594 sc->sc_composed_char *= 10; 595 sc->sc_composed_char += suncode - 0x6f; 596 if (sc->sc_composed_char > UCHAR_MAX) 597 return (ERRKEY); 598 goto next_code; 599 case 0x5e: /* KP 0 */ 600 sc->sc_composed_char *= 10; 601 if (sc->sc_composed_char > UCHAR_MAX) 602 return (ERRKEY); 603 goto next_code; 604 605 case 0x44 | SKBD_KEY_RELEASE: /* KP 7 */ 606 case 0x45 | SKBD_KEY_RELEASE: /* KP 8 */ 607 case 0x46 | SKBD_KEY_RELEASE: /* KP 9 */ 608 case 0x5b | SKBD_KEY_RELEASE: /* KP 4 */ 609 case 0x5c | SKBD_KEY_RELEASE: /* KP 5 */ 610 case 0x5d | SKBD_KEY_RELEASE: /* KP 6 */ 611 case 0x70 | SKBD_KEY_RELEASE: /* KP 1 */ 612 case 0x71 | SKBD_KEY_RELEASE: /* KP 2 */ 613 case 0x72 | SKBD_KEY_RELEASE: /* KP 3 */ 614 case 0x5e | SKBD_KEY_RELEASE: /* KP 0 */ 615 goto next_code; 616 default: 617 if (sc->sc_composed_char > 0) { 618 sc->sc_flags &= ~KPCOMPOSE; 619 sc->sc_composed_char = 0; 620 return (ERRKEY); 621 } 622 } 623 } 624 625 key = genkbd_keyaction(kbd, key, release, 626 &sc->sc_state, &sc->sc_accents); 627 if (key != NOKEY || repeated) 628 return (key); 629 } 630 } 631 return (0); 632 } 633 634 static int 635 sunkbd_check_char(keyboard_t *kbd) 636 { 637 struct sunkbd_softc *sc; 638 639 if (!KBD_IS_ACTIVE(kbd)) 640 return (FALSE); 641 642 sc = (struct sunkbd_softc *)kbd; 643 if (!(sc->sc_flags & KPCOMPOSE) && (sc->sc_composed_char > 0)) 644 return (TRUE); 645 646 return (sunkbd_check(kbd)); 647 } 648 649 static int 650 sunkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t data) 651 { 652 struct sunkbd_softc *sc; 653 int c, error; 654 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) 655 int ival; 656 #endif 657 658 sc = (struct sunkbd_softc *)kbd; 659 error = 0; 660 switch (cmd) { 661 case KDGKBMODE: 662 *(int *)data = sc->sc_mode; 663 break; 664 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) 665 case _IO('K', 7): 666 ival = IOCPARM_IVAL(data); 667 data = (caddr_t)&ival; 668 /* FALLTHROUGH */ 669 #endif 670 case KDSKBMODE: 671 switch (*(int *)data) { 672 case K_XLATE: 673 if (sc->sc_mode != K_XLATE) { 674 /* make lock key state and LED state match */ 675 sc->sc_state &= ~LOCK_MASK; 676 sc->sc_state |= KBD_LED_VAL(kbd); 677 } 678 /* FALLTHROUGH */ 679 case K_RAW: 680 case K_CODE: 681 if (sc->sc_mode != *(int *)data) { 682 sunkbd_clear_state(kbd); 683 sc->sc_mode = *(int *)data; 684 } 685 break; 686 default: 687 error = EINVAL; 688 break; 689 } 690 break; 691 case KDGETLED: 692 *(int *)data = KBD_LED_VAL(kbd); 693 break; 694 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) 695 case _IO('K', 66): 696 ival = IOCPARM_IVAL(data); 697 data = (caddr_t)&ival; 698 /* FALLTHROUGH */ 699 #endif 700 case KDSETLED: 701 if (*(int *)data & ~LOCK_MASK) { 702 error = EINVAL; 703 break; 704 } 705 if (sc->sc_sysdev == NULL) 706 break; 707 c = 0; 708 if (*(int *)data & CLKED) 709 c |= SKBD_LED_CAPSLOCK; 710 if (*(int *)data & NLKED) 711 c |= SKBD_LED_NUMLOCK; 712 if (*(int *)data & SLKED) 713 c |= SKBD_LED_SCROLLLOCK; 714 uart_lock(sc->sc_sysdev->hwmtx); 715 sc->sc_sysdev->ops->putc(&sc->sc_sysdev->bas, SKBD_CMD_SETLED); 716 sc->sc_sysdev->ops->putc(&sc->sc_sysdev->bas, c); 717 uart_unlock(sc->sc_sysdev->hwmtx); 718 KBD_LED_VAL(kbd) = *(int *)data; 719 break; 720 case KDGKBSTATE: 721 *(int *)data = sc->sc_state & LOCK_MASK; 722 break; 723 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) 724 case _IO('K', 20): 725 ival = IOCPARM_IVAL(data); 726 data = (caddr_t)&ival; 727 /* FALLTHROUGH */ 728 #endif 729 case KDSKBSTATE: 730 if (*(int *)data & ~LOCK_MASK) { 731 error = EINVAL; 732 break; 733 } 734 sc->sc_state &= ~LOCK_MASK; 735 sc->sc_state |= *(int *)data; 736 /* set LEDs and quit */ 737 return (sunkbd_ioctl(kbd, KDSETLED, data)); 738 case KDSETREPEAT: 739 case KDSETRAD: 740 break; 741 case PIO_KEYMAP: 742 case OPIO_KEYMAP: 743 case PIO_KEYMAPENT: 744 case PIO_DEADKEYMAP: 745 default: 746 return (genkbd_commonioctl(kbd, cmd, data)); 747 } 748 return (error); 749 } 750 751 static int 752 sunkbd_lock(keyboard_t *kbd, int lock) 753 { 754 755 TODO; 756 return (0); 757 } 758 759 static void 760 sunkbd_clear_state(keyboard_t *kbd) 761 { 762 struct sunkbd_softc *sc; 763 764 sc = (struct sunkbd_softc *)kbd; 765 sc->sc_repeat_key = -1; 766 sc->sc_accents = 0; 767 sc->sc_composed_char = 0; 768 sc->sc_flags = 0; 769 sc->sc_polling = 0; 770 sc->sc_repeating = 0; 771 sc->sc_state &= LOCK_MASK; /* Preserve locking key state. */ 772 773 #if defined(SUNKBD_EMULATE_ATKBD) 774 sc->sc_buffered_char[0] = 0; 775 sc->sc_buffered_char[1] = 0; 776 #endif 777 } 778 779 static int 780 sunkbd_get_state(keyboard_t *kbd, void *buf, size_t len) 781 { 782 783 TODO; 784 return (0); 785 } 786 787 static int 788 sunkbd_set_state(keyboard_t *kbd, void *buf, size_t len) 789 { 790 791 TODO; 792 return (0); 793 } 794 795 static int 796 sunkbd_poll_mode(keyboard_t *kbd, int on) 797 { 798 struct sunkbd_softc *sc; 799 800 sc = (struct sunkbd_softc *)kbd; 801 if (on) 802 sc->sc_polling++; 803 else 804 sc->sc_polling--; 805 return (0); 806 } 807 808 static void 809 sunkbd_diag(keyboard_t *kbd, int level) 810 { 811 812 TODO; 813 } 814 815 static void 816 sunkbd_repeat(void *v) 817 { 818 struct sunkbd_softc *sc = v; 819 820 if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) { 821 if (sc->sc_repeat_key != -1) { 822 sc->sc_repeating = 1; 823 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd, 824 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg); 825 } 826 } 827 } 828 829 #if defined(SUNKBD_EMULATE_ATKBD) 830 static int 831 keycode2scancode(int keycode, int shift, int up) 832 { 833 static const int scan[] = { 834 /* KP enter, right ctrl, KP divide */ 835 0x1c , 0x1d , 0x35 , 836 /* print screen */ 837 0x37 | SCAN_PREFIX_SHIFT, 838 /* right alt, home, up, page up, left, right, end */ 839 0x38, 0x47, 0x48, 0x49, 0x4b, 0x4d, 0x4f, 840 /* down, page down, insert, delete */ 841 0x50, 0x51, 0x52, 0x53, 842 /* pause/break (see also below) */ 843 0x46, 844 /* 845 * MS: left window, right window, menu 846 * also Sun: left meta, right meta, compose 847 */ 848 0x5b, 0x5c, 0x5d, 849 /* Sun type 6 USB */ 850 /* help, stop, again, props, undo, front, copy */ 851 0x68, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 852 /* open, paste, find, cut, audiomute, audiolower, audioraise */ 853 0x64, 0x65, 0x66, 0x67, 0x25, 0x1f, 0x1e, 854 /* power */ 855 0x20 856 }; 857 int scancode; 858 859 scancode = keycode; 860 if ((keycode >= 89) && (keycode < 89 + sizeof(scan) / sizeof(scan[0]))) 861 scancode = scan[keycode - 89] | SCAN_PREFIX_E0; 862 /* pause/break */ 863 if ((keycode == 104) && !(shift & CTLS)) 864 scancode = 0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL; 865 if (shift & SHIFTS) 866 scancode &= ~SCAN_PREFIX_SHIFT; 867 return (scancode | (up ? SCAN_RELEASE : SCAN_PRESS)); 868 } 869 #endif 870