1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */ 22 /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */ 23 /* All Rights Reserved */ 24 25 /* 26 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 #include <sys/types.h> 33 #include <sys/errno.h> 34 #include <sys/inline.h> 35 #include <sys/termio.h> 36 #include <sys/stropts.h> 37 #include <sys/termios.h> 38 #include <sys/stream.h> 39 #include <sys/strtty.h> 40 #include <sys/strsubr.h> 41 #include <sys/strsun.h> 42 #include <sys/ddi.h> 43 #include <sys/sunddi.h> 44 #include <sys/note.h> 45 #include "sys/consdev.h" 46 #include <sys/kbd.h> 47 #include <sys/kbtrans.h> 48 #include "kb8042.h" 49 50 #include <sys/i8042.h> 51 52 #include "sys/kbio.h" /* for KIOCSLAYOUT */ 53 #include "sys/stat.h" 54 #include "sys/reboot.h" 55 #include <sys/promif.h> 56 #include <sys/beep.h> 57 #include <sys/inttypes.h> 58 59 /* 60 * For any keyboard, there is a unique code describing the position 61 * of the key on a keyboard. We refer to the code as "station number". 62 * The following table is used to map the station numbers from ps2 63 * AT/XT keyboards to that of a USB one. 64 * 65 * A mapping was added for entry K8042_STOP, to map to USB key code 120 (which 66 * maps to the STOP key) when in KB_USB mode, and maps to a HOLE entry 67 * when in KB_PC mode. Note that this does not need to be made conditional 68 * on the architecture for which this module is complied because there are no 69 * keys that map to K8042_STOP on non-SPARC platforms. 70 */ 71 static kbtrans_key_t keytab_pc2usb[KBTRANS_KEYNUMS_MAX] = { 72 /* 0 */ 0, 53, 30, 31, 32, 33, 34, 35, 73 /* 8 */ 36, 37, 38, 39, 45, 46, 137, 42, 74 /* 16 */ 43, 20, 26, 8, 21, 23, 28, 24, 75 /* 24 */ 12, 18, 19, 47, 48, 49, 57, 4, 76 /* 32 */ 22, 7, 9, 10, 11, 13, 14, 15, 77 /* 40 */ 51, 52, 50, 40, 225, 100, 29, 27, 78 /* 48 */ 6, 25, 5, 17, 16, 54, 55, 56, 79 /* 56 */ 135, 229, 224, 227, 226, 44, 230, 231, 80 /* 64 */ 228, 101, 0, 0, 0, 0, 0, 0, 81 /* 72 */ 0, 0, 0, 73, 76, 0, 0, 80, 82 /* 80 */ 74, 77, 0, 82, 81, 75, 78, 0, 83 /* 88 */ 0, 79, 83, 95, 92, 89, 0, 84, 84 /* 96 */ 96, 93, 90, 98, 85, 97, 94, 91, 85 /* 104 */ 99, 86, 87, 133, 88, 0, 41, 0, 86 /* 112 */ 58, 59, 60, 61, 62, 63, 64, 65, 87 /* 120 */ 66, 67, 68, 69, 70, 71, 72, 0, 88 /* 128 */ 0, 0, 0, 139, 138, 136, 0, 0, 89 /* 136 */ 0, 0, 0, 0, 0, 0, 0, 0, 90 /* 144 */ 0, 0, 0, 0, 0, 0, 0, 0, 91 /* 152 */ 0, 0, 0, 0, 0, 0, 0, 0, 92 /* 160 */ 120, 0, 0, 0, 0, 0, 0, 0, 93 /* 168 */ 0, 0, 0, 0, 0, 0, 0, 0, 94 /* 176 */ 0, 0, 0, 0, 0, 0, 0, 0, 95 /* 184 */ 0, 0, 0, 0, 0, 0, 0, 0, 96 /* 192 */ 0, 0, 0, 0, 0, 0, 0, 0, 97 /* 200 */ 0, 0, 0, 0, 0, 0, 0, 0, 98 /* 208 */ 0, 0, 0, 0, 0, 0, 0, 0, 99 /* 216 */ 0, 0, 0, 0, 0, 0, 0, 0, 100 /* 224 */ 0, 0, 0, 0, 0, 0, 0, 0, 101 /* 232 */ 0, 0, 0, 0, 0, 0, 0, 0, 102 /* 240 */ 0, 0, 0, 0, 0, 0, 0, 0, 103 /* 248 */ 0, 0, 0, 0 104 }; 105 106 /* 107 * DEBUG (or KD_DEBUG for just this module) turns on a flag called 108 * kb8042_enable_debug_hotkey. If kb8042_enable_debug_hotkey is true, 109 * then the following hotkeys are enabled: 110 * F10 - turn on debugging "normal" translations 111 * F9 - turn on debugging "getchar" translations 112 * F8 - turn on "low level" debugging 113 * F7 - turn on terse press/release debugging 114 * F1 - turn off all debugging 115 * The default value for kb8042_enable_debug_hotkey is false, disabling 116 * these hotkeys. 117 */ 118 119 #if defined(DEBUG) || defined(lint) 120 #define KD_DEBUG 121 #endif 122 123 #ifdef KD_DEBUG 124 boolean_t kb8042_enable_debug_hotkey = B_FALSE; 125 boolean_t kb8042_debug = B_FALSE; 126 boolean_t kb8042_getchar_debug = B_FALSE; 127 boolean_t kb8042_low_level_debug = B_FALSE; 128 boolean_t kb8042_pressrelease_debug = B_FALSE; 129 static void kb8042_debug_hotkey(int scancode); 130 #endif 131 132 #ifdef __sparc 133 #define USECS_PER_WAIT 100 134 #define MAX_WAIT_USECS 100000 /* in usecs = 100 ms */ 135 #define MIN_DELAY_USECS USECS_PER_WAIT 136 137 boolean_t kb8042_warn_unknown_scanset = B_TRUE; 138 int kb8042_default_scanset = 2; 139 140 #endif 141 142 enum state_return { STATE_NORMAL, STATE_INTERNAL }; 143 144 static void kb8042_init(struct kb8042 *kb8042, boolean_t from_resume); 145 static uint_t kb8042_intr(caddr_t arg); 146 static void kb8042_wait_poweron(struct kb8042 *kb8042); 147 static void kb8042_start_state_machine(struct kb8042 *, boolean_t); 148 static enum state_return kb8042_state_machine(struct kb8042 *, int, boolean_t); 149 static void kb8042_send_to_keyboard(struct kb8042 *, int, boolean_t); 150 static int kb8042_xlate_leds(int); 151 static void kb8042_setled(struct kb8042 *, int led_state, boolean_t polled); 152 static void kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state); 153 static void kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state); 154 static boolean_t kb8042_polled_keycheck( 155 struct kbtrans_hardware *hw, int *key, 156 enum keystate *state); 157 static void kb8042_get_initial_leds(struct kb8042 *, int *, int *); 158 static boolean_t kb8042_autorepeat_detect(struct kb8042 *kb8042, int key_pos, 159 enum keystate state); 160 static void kb8042_type4_cmd(struct kb8042 *kb8042, int cmd); 161 static void kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *, mblk_t *); 162 static void kb8042_iocdatamsg(queue_t *, mblk_t *); 163 static void kb8042_process_key(struct kb8042 *, kbtrans_key_t, enum keystate); 164 static int kb8042_polled_ischar(cons_polledio_arg_t arg); 165 static int kb8042_polled_getchar(cons_polledio_arg_t arg); 166 static void kb8042_cleanup(struct kb8042 *kb8042); 167 168 static struct kbtrans_callbacks kb8042_callbacks = { 169 kb8042_streams_setled, 170 kb8042_polled_setled, 171 kb8042_polled_keycheck, 172 }; 173 174 extern struct keyboard keyindex_pc; 175 176 #define DRIVER_NAME(dip) ddi_driver_name(dip) 177 178 static char module_name[] = "kb8042"; 179 180 static int kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag, 181 cred_t *credp); 182 static int kb8042_close(queue_t *qp, int flag, cred_t *credp); 183 static int kb8042_wsrv(); 184 185 struct module_info kb8042_sinfo = { 186 42, /* Module ID */ 187 module_name, 188 0, 32, /* Minimum and maximum packet sizes */ 189 256, 128 /* High and low water marks */ 190 }; 191 192 static struct qinit kb8042_rinit = { 193 NULL, NULL, kb8042_open, kb8042_close, NULL, &kb8042_sinfo, NULL 194 }; 195 196 static struct qinit kb8042_winit = { 197 putq, kb8042_wsrv, kb8042_open, kb8042_close, NULL, &kb8042_sinfo, NULL 198 }; 199 200 struct streamtab 201 kb8042_str_info = { &kb8042_rinit, &kb8042_winit, NULL, NULL }; 202 203 struct kb8042 Kdws = {0}; 204 static dev_info_t *kb8042_dip = NULL; 205 206 static int kb8042_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 207 void **result); 208 static int kb8042_attach(dev_info_t *, ddi_attach_cmd_t); 209 static int kb8042_detach(dev_info_t *, ddi_detach_cmd_t); 210 211 static struct cb_ops cb_kb8042_ops = { 212 nulldev, /* cb_open */ 213 nulldev, /* cb_close */ 214 nodev, /* cb_strategy */ 215 nodev, /* cb_print */ 216 nodev, /* cb_dump */ 217 nodev, /* cb_read */ 218 nodev, /* cb_write */ 219 nodev, /* cb_ioctl */ 220 nodev, /* cb_devmap */ 221 nodev, /* cb_mmap */ 222 nodev, /* cb_segmap */ 223 nochpoll, /* cb_chpoll */ 224 ddi_prop_op, /* cb_prop_op */ 225 &kb8042_str_info, /* cb_stream */ 226 D_MP 227 }; 228 229 struct dev_ops kb8042_ops = { 230 DEVO_REV, /* devo_rev */ 231 0, /* devo_refcnt */ 232 kb8042_getinfo, /* devo_getinfo */ 233 nulldev, /* devo_identify */ 234 nulldev, /* devo_probe */ 235 kb8042_attach, /* devo_attach */ 236 kb8042_detach, /* devo_detach */ 237 nodev, /* devo_reset */ 238 &cb_kb8042_ops, /* devo_cb_ops */ 239 (struct bus_ops *)NULL /* devo_bus_ops */ 240 }; 241 242 243 /* 244 * This is the loadable module wrapper. 245 */ 246 #include <sys/modctl.h> 247 248 /* 249 * Module linkage information for the kernel. 250 */ 251 static struct modldrv modldrv = { 252 &mod_driverops, /* Type of module. This one is a driver */ 253 "PS/2 Keyboard %I%, %E%", 254 &kb8042_ops, /* driver ops */ 255 }; 256 257 static struct modlinkage modlinkage = { 258 MODREV_1, 259 (void *) &modldrv, 260 NULL 261 }; 262 263 int 264 _init(void) 265 { 266 int rv; 267 268 rv = mod_install(&modlinkage); 269 return (rv); 270 } 271 272 273 int 274 _fini(void) 275 { 276 return (mod_remove(&modlinkage)); 277 } 278 279 int 280 _info(struct modinfo *modinfop) 281 { 282 return (mod_info(&modlinkage, modinfop)); 283 } 284 285 #ifdef __sparc 286 static boolean_t 287 kb8042_is_input_avail(struct kb8042 *kb8042, int timeout_usec, boolean_t polled) 288 { 289 int i; 290 int port = (polled == B_TRUE) ? I8042_POLL_INPUT_AVAIL : 291 I8042_INT_INPUT_AVAIL; 292 int reps = timeout_usec / USECS_PER_WAIT; 293 294 for (i = 0; i < reps; i++) { 295 if (ddi_get8(kb8042->handle, kb8042->addr + port) != 0) 296 return (B_TRUE); 297 298 if (i < (reps - 1)) 299 drv_usecwait(USECS_PER_WAIT); 300 } 301 return (B_FALSE); 302 } 303 304 static void 305 kb8042_clear_input_buffer(struct kb8042 *kb8042, boolean_t polled) 306 { 307 int port = (polled == B_TRUE) ? I8042_POLL_INPUT_DATA : 308 I8042_INT_INPUT_DATA; 309 310 while (kb8042_is_input_avail(kb8042, MIN_DELAY_USECS, polled)) { 311 (void) ddi_get8(kb8042->handle, kb8042->addr + port); 312 } 313 } 314 315 static boolean_t 316 kb8042_send_and_expect(struct kb8042 *kb8042, uint8_t send, uint8_t expect, 317 boolean_t polled, int timeout, int *error, uint8_t *got) 318 { 319 int port = (polled == B_TRUE) ? I8042_POLL_INPUT_DATA : 320 I8042_INT_INPUT_DATA; 321 uint8_t datab; 322 int err; 323 boolean_t rval; 324 325 kb8042_send_to_keyboard(kb8042, send, polled); 326 327 if (kb8042_is_input_avail(kb8042, timeout, polled)) { 328 err = 0; 329 datab = ddi_get8(kb8042->handle, kb8042->addr + port); 330 rval = ((datab == expect) ? B_TRUE : B_FALSE); 331 } else { 332 err = EAGAIN; 333 rval = B_FALSE; 334 } 335 336 if (error != NULL) 337 *error = err; 338 if (got != NULL) 339 *got = datab; 340 return (rval); 341 } 342 343 static const char * 344 kb8042_error_string(int errcode) 345 { 346 switch (errcode) { 347 case EAGAIN: 348 return ("Timed out"); 349 default: 350 return ("Unknown error"); 351 } 352 } 353 354 static int 355 kb8042_read_scanset(struct kb8042 *kb8042, boolean_t polled) 356 { 357 int scanset = -1; 358 int port = (polled == B_TRUE) ? I8042_POLL_INPUT_DATA : 359 I8042_INT_INPUT_DATA; 360 int err; 361 uint8_t got; 362 363 kb8042_clear_input_buffer(kb8042, B_TRUE); 364 365 /* 366 * Send a "change scan code set" command to the keyboard. 367 * It should respond with an ACK. 368 */ 369 if (kb8042_send_and_expect(kb8042, KB_SET_SCAN, KB_ACK, polled, 370 MAX_WAIT_USECS, &err, &got) != B_TRUE) { 371 goto fail_read_scanset; 372 } 373 374 /* 375 * Send a 0. The keyboard should ACK the 0, then it send the scan code 376 * set in use. 377 */ 378 if (kb8042_send_and_expect(kb8042, 0, KB_ACK, polled, 379 MAX_WAIT_USECS, &err, &got) != B_TRUE) { 380 goto fail_read_scanset; 381 } 382 383 /* 384 * The next input byte from the keyboard should be the scan code 385 * set in use, though some keyboards like to send a few more acks 386 * just for fun, so blow past those to get the keyboard scan code. 387 */ 388 while (kb8042_is_input_avail(kb8042, MAX_WAIT_USECS, B_TRUE) && 389 (scanset = ddi_get8(kb8042->handle, kb8042->addr + port)) 390 == KB_ACK) 391 ; 392 393 #ifdef KD_DEBUG 394 cmn_err(CE_NOTE, "!Scan code set from keyboard is `%d'.", 395 scanset); 396 #endif 397 398 return (scanset); 399 400 fail_read_scanset: 401 #ifdef KD_DEBUG 402 if (err == 0) 403 cmn_err(CE_NOTE, "Could not read current scan set from " 404 "keyboard: %s. (Expected 0x%x, but got 0x%x).", 405 kb8042_error_string(err), KB_ACK, got); 406 else 407 cmn_err(CE_NOTE, "Could not read current scan set from " 408 "keyboard: %s.", kb8042_error_string(err)); 409 #endif 410 return (-1); 411 } 412 #endif 413 414 static int 415 kb8042_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 416 { 417 int rc; 418 int scanset; 419 int leds; 420 421 struct kb8042 *kb8042 = &Kdws; 422 static ddi_device_acc_attr_t attr = { 423 DDI_DEVICE_ATTR_V0, 424 DDI_NEVERSWAP_ACC, 425 DDI_STRICTORDER_ACC, 426 }; 427 428 switch (cmd) { 429 case DDI_RESUME: 430 leds = kb8042->leds.commanded; 431 kb8042->w_init = 0; 432 kb8042_init(kb8042, B_TRUE); 433 kb8042_setled(kb8042, leds, B_FALSE); 434 return (DDI_SUCCESS); 435 436 case DDI_ATTACH: 437 if (kb8042_dip != NULL) 438 return (DDI_FAILURE); 439 /* The rest of the function is for attach */ 440 break; 441 442 default: 443 return (DDI_FAILURE); 444 } 445 446 kb8042->debugger.mod1 = 58; /* Left Ctrl */ 447 kb8042->debugger.mod2 = 60; /* Left Alt */ 448 kb8042->debugger.trigger = 33; /* D */ 449 kb8042->debugger.mod1_down = B_FALSE; 450 kb8042->debugger.mod2_down = B_FALSE; 451 kb8042->debugger.enabled = B_FALSE; 452 453 kb8042_dip = devi; 454 kb8042->init_state = KB8042_UNINITIALIZED; 455 456 kb8042->polled_synthetic_release_pending = B_FALSE; 457 458 if (ddi_create_minor_node(devi, module_name, S_IFCHR, 0, 459 DDI_NT_KEYBOARD, 0) == DDI_FAILURE) { 460 goto failure; 461 } 462 463 kb8042->init_state |= KB8042_MINOR_NODE_CREATED; 464 465 rc = ddi_regs_map_setup(devi, 0, (caddr_t *)&kb8042->addr, 466 (offset_t)0, (offset_t)0, &attr, &kb8042->handle); 467 if (rc != DDI_SUCCESS) { 468 #if defined(KD_DEBUG) 469 cmn_err(CE_WARN, "kb8042_attach: can't map registers"); 470 #endif 471 goto failure; 472 } 473 474 kb8042->init_state |= KB8042_REGS_MAPPED; 475 476 if (ddi_get_iblock_cookie(devi, 0, &kb8042->w_iblock) != 477 DDI_SUCCESS) { 478 cmn_err(CE_WARN, "kb8042_attach: Can't get iblock cookie"); 479 goto failure; 480 } 481 482 mutex_init(&kb8042->w_hw_mutex, NULL, MUTEX_DRIVER, kb8042->w_iblock); 483 484 kb8042->init_state |= KB8042_HW_MUTEX_INITTED; 485 486 kb8042_init(kb8042, B_FALSE); 487 488 #ifdef __sparc 489 /* Detect the scan code set currently in use */ 490 scanset = kb8042_read_scanset(kb8042, B_TRUE); 491 492 if (scanset < 0 && kb8042_warn_unknown_scanset) { 493 494 cmn_err(CE_WARN, "Cannot determine keyboard scan code set "); 495 cmn_err(CE_CONT, "(is the keyboard plugged in?). "); 496 cmn_err(CE_CONT, "Defaulting to scan code set %d. If the " 497 "keyboard does not ", kb8042_default_scanset); 498 cmn_err(CE_CONT, "work properly, add " 499 "`set kb8042:kb8042_default_scanset=%d' to /etc/system ", 500 (kb8042_default_scanset == 1) ? 2 : 1); 501 cmn_err(CE_CONT, "(via network or with a USB keyboard) and " 502 "restart the system. If you "); 503 cmn_err(CE_CONT, "do not want to see this message in the " 504 "future, add "); 505 cmn_err(CE_CONT, "`set kb8042:kb8042_warn_unknown_scanset=0' " 506 "to /etc/system.\n"); 507 508 /* Use the default scan code set. */ 509 scanset = kb8042_default_scanset; 510 } 511 #else 512 /* x86 systems use scan code set 1 -- no detection required */ 513 scanset = 1; 514 #endif 515 if (KeyboardConvertScan_init(kb8042, scanset) != DDI_SUCCESS) { 516 cmn_err(CE_WARN, "Cannot initialize keyboard scan converter: " 517 "Unknown scan code set `%d'.", scanset); 518 /* Scan code set is not supported */ 519 goto failure; 520 } 521 522 /* 523 * Turn on interrupts... 524 */ 525 if (ddi_add_intr(devi, 0, 526 &kb8042->w_iblock, (ddi_idevice_cookie_t *)NULL, 527 kb8042_intr, (caddr_t)kb8042) != DDI_SUCCESS) { 528 cmn_err(CE_WARN, "kb8042_attach: cannot add interrupt"); 529 goto failure; 530 } 531 532 kb8042->init_state |= KB8042_INTR_ADDED; 533 534 ddi_report_dev(devi); 535 536 #ifdef KD_DEBUG 537 cmn_err(CE_CONT, "?%s #%d: version %s\n", 538 DRIVER_NAME(devi), ddi_get_instance(devi), "%I% (%E%)"); 539 #endif 540 541 return (DDI_SUCCESS); 542 543 failure: 544 kb8042_cleanup(kb8042); 545 return (DDI_FAILURE); 546 } 547 548 static int 549 kb8042_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 550 { 551 struct kb8042 *kb8042 = &Kdws; 552 553 switch (cmd) { 554 case DDI_SUSPEND: 555 return (DDI_SUCCESS); 556 557 case DDI_DETACH: 558 /* If someone has a stream open, fail to detach */ 559 if (kb8042->w_qp != NULL) 560 return (DDI_FAILURE); 561 562 ASSERT(kb8042_dip == dip); 563 564 kb8042_cleanup(kb8042); 565 566 return (DDI_SUCCESS); 567 568 default: 569 return (DDI_FAILURE); 570 } 571 } 572 573 574 /*ARGSUSED*/ 575 static int 576 kb8042_getinfo( 577 dev_info_t *dip, 578 ddi_info_cmd_t infocmd, 579 void *arg, 580 void **result) 581 { 582 register int error; 583 584 switch (infocmd) { 585 case DDI_INFO_DEVT2DEVINFO: 586 if (kb8042_dip == NULL) { 587 error = DDI_FAILURE; 588 } else { 589 *result = (void *) kb8042_dip; 590 error = DDI_SUCCESS; 591 } 592 break; 593 case DDI_INFO_DEVT2INSTANCE: 594 *result = (void *)0; 595 error = DDI_SUCCESS; 596 break; 597 default: 598 error = DDI_FAILURE; 599 break; 600 } 601 return (error); 602 } 603 604 static void 605 kb8042_cleanup(struct kb8042 *kb8042) 606 { 607 ASSERT(kb8042_dip != NULL); 608 609 if (kb8042->init_state & KB8042_HW_MUTEX_INITTED) 610 mutex_destroy(&kb8042->w_hw_mutex); 611 612 if (kb8042->init_state & KB8042_INTR_ADDED) 613 ddi_remove_intr(kb8042_dip, 0, kb8042->w_iblock); 614 615 if (kb8042->init_state & KB8042_REGS_MAPPED) 616 ddi_regs_map_free(&kb8042->handle); 617 618 if (kb8042->init_state & KB8042_MINOR_NODE_CREATED) 619 ddi_remove_minor_node(kb8042_dip, NULL); 620 621 kb8042->init_state = KB8042_UNINITIALIZED; 622 kb8042_dip = NULL; 623 } 624 625 static void 626 kb8042_init(struct kb8042 *kb8042, boolean_t from_resume) 627 { 628 if (kb8042->w_init) 629 return; 630 631 if (!from_resume) { 632 kb8042->w_kblayout = 0; /* Default to US */ 633 kb8042->w_qp = (queue_t *)NULL; 634 kb8042->simulated_kbd_type = KB_PC; 635 kb8042->leds.commanded = -1; /* Unknown initial state */ 636 kb8042->leds.desired = -1; /* Unknown initial state */ 637 } 638 639 kb8042_wait_poweron(kb8042); 640 641 kb8042->kb_old_key_pos = 0; 642 643 /* Set up the command state machine and start it running. */ 644 kb8042->command_state = KB_COMMAND_STATE_WAIT; 645 kb8042_send_to_keyboard(kb8042, KB_ENABLE, B_FALSE); 646 647 kb8042->w_init++; 648 649 (void) drv_setparm(SYSRINT, 1); /* reset keyboard interrupts */ 650 } 651 652 /*ARGSUSED2*/ 653 static int 654 kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag, cred_t *credp) 655 { 656 struct kb8042 *kb8042; 657 int err; 658 int initial_leds; 659 int initial_led_mask; 660 661 kb8042 = &Kdws; 662 663 kb8042->w_dev = *devp; 664 665 if (qp->q_ptr) { 666 return (0); 667 } 668 qp->q_ptr = (caddr_t)kb8042; 669 WR(qp)->q_ptr = qp->q_ptr; 670 if (!kb8042->w_qp) 671 kb8042->w_qp = qp; 672 673 kb8042_get_initial_leds(kb8042, &initial_leds, &initial_led_mask); 674 err = kbtrans_streams_init(qp, sflag, credp, 675 (struct kbtrans_hardware *)kb8042, &kb8042_callbacks, 676 &kb8042->hw_kbtrans, 677 initial_leds, initial_led_mask); 678 if (err != 0) 679 return (err); 680 681 kbtrans_streams_set_keyboard(kb8042->hw_kbtrans, KB_PC, &keyindex_pc); 682 683 kb8042->polledio.cons_polledio_version = CONSPOLLEDIO_V1; 684 kb8042->polledio.cons_polledio_argument = 685 (cons_polledio_arg_t)kb8042; 686 kb8042->polledio.cons_polledio_putchar = NULL; 687 kb8042->polledio.cons_polledio_getchar = 688 (int (*)(cons_polledio_arg_t))kb8042_polled_getchar; 689 kb8042->polledio.cons_polledio_ischar = 690 (boolean_t (*)(cons_polledio_arg_t))kb8042_polled_ischar; 691 kb8042->polledio.cons_polledio_enter = NULL; 692 kb8042->polledio.cons_polledio_exit = NULL; 693 kb8042->polledio.cons_polledio_setled = 694 (void (*)(cons_polledio_arg_t, int))kb8042_polled_setled; 695 kb8042->polledio.cons_polledio_keycheck = 696 (boolean_t (*)(cons_polledio_arg_t, int *, 697 enum keystate *))kb8042_polled_keycheck; 698 699 qprocson(qp); 700 701 kbtrans_streams_enable(kb8042->hw_kbtrans); 702 703 return (0); 704 } 705 706 /*ARGSUSED1*/ 707 static int 708 kb8042_close(queue_t *qp, int flag, cred_t *credp) 709 { 710 struct kb8042 *kb8042; 711 712 /* If a beep is in progress, stop that */ 713 (void) beeper_off(); 714 715 kb8042 = (struct kb8042 *)qp->q_ptr; 716 717 (void) kbtrans_streams_fini(kb8042->hw_kbtrans); 718 719 kb8042->w_qp = (queue_t *)NULL; 720 qprocsoff(qp); 721 722 return (0); 723 } 724 725 static int 726 kb8042_wsrv(queue_t *qp) 727 { 728 struct kb8042 *kb8042; 729 730 mblk_t *mp; 731 732 kb8042 = (struct kb8042 *)qp->q_ptr; 733 734 while ((mp = getq(qp))) { 735 switch (kbtrans_streams_message(kb8042->hw_kbtrans, mp)) { 736 case KBTRANS_MESSAGE_HANDLED: 737 continue; 738 case KBTRANS_MESSAGE_NOT_HANDLED: 739 break; 740 } 741 switch (mp->b_datap->db_type) { 742 case M_IOCTL: 743 kb8042_ioctlmsg(kb8042, qp, mp); 744 continue; 745 case M_IOCDATA: 746 kb8042_iocdatamsg(qp, mp); 747 continue; 748 case M_DELAY: 749 case M_STARTI: 750 case M_STOPI: 751 case M_READ: /* ignore, no buffered data */ 752 freemsg(mp); 753 continue; 754 case M_FLUSH: 755 *mp->b_rptr &= ~FLUSHW; 756 if (*mp->b_rptr & FLUSHR) 757 qreply(qp, mp); 758 else 759 freemsg(mp); 760 continue; 761 default: 762 cmn_err(CE_NOTE, "kb8042_wsrv: bad msg %x", 763 mp->b_datap->db_type); 764 freemsg(mp); 765 continue; 766 } 767 } 768 return (0); 769 } 770 771 static void 772 kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *qp, mblk_t *mp) 773 { 774 struct iocblk *iocp; 775 mblk_t *datap; 776 int error; 777 int tmp; 778 int cycles; 779 int frequency; 780 int msecs; 781 782 iocp = (struct iocblk *)mp->b_rptr; 783 784 switch (iocp->ioc_cmd) { 785 786 case CONSOPENPOLLEDIO: 787 error = miocpullup(mp, sizeof (struct cons_polledio *)); 788 if (error != 0) { 789 miocnak(qp, mp, 0, error); 790 return; 791 } 792 793 /* 794 * We are given an appropriate-sized data block, 795 * and return a pointer to our structure in it. 796 */ 797 *(struct cons_polledio **)mp->b_cont->b_rptr = 798 &kb8042->polledio; 799 mp->b_datap->db_type = M_IOCACK; 800 iocp->ioc_error = 0; 801 qreply(qp, mp); 802 break; 803 804 case CONSCLOSEPOLLEDIO: 805 miocack(qp, mp, 0, 0); 806 break; 807 808 case CONSSETABORTENABLE: 809 if (iocp->ioc_count != TRANSPARENT) { 810 miocnak(qp, mp, 0, EINVAL); 811 return; 812 } 813 814 kb8042->debugger.enabled = *(intptr_t *)mp->b_cont->b_rptr; 815 miocack(qp, mp, 0, 0); 816 break; 817 818 /* 819 * Valid only in TR_UNTRANS_MODE mode. 820 */ 821 case CONSSETKBDTYPE: 822 error = miocpullup(mp, sizeof (int)); 823 if (error != 0) { 824 miocnak(qp, mp, 0, error); 825 return; 826 } 827 tmp = *(int *)mp->b_cont->b_rptr; 828 if (tmp != KB_PC && tmp != KB_USB) { 829 miocnak(qp, mp, 0, EINVAL); 830 break; 831 } 832 kb8042->simulated_kbd_type = tmp; 833 miocack(qp, mp, 0, 0); 834 break; 835 836 case KIOCLAYOUT: 837 if (kb8042->w_kblayout == -1) { 838 miocnak(qp, mp, 0, EINVAL); 839 return; 840 } 841 842 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 843 miocnak(qp, mp, 0, ENOMEM); 844 return; 845 } 846 847 if (kb8042->simulated_kbd_type == KB_USB) 848 *(int *)datap->b_wptr = KBTRANS_USBKB_DEFAULT_LAYOUT; 849 else 850 *(int *)datap->b_wptr = kb8042->w_kblayout; 851 852 datap->b_wptr += sizeof (int); 853 if (mp->b_cont) 854 freemsg(mp->b_cont); 855 mp->b_cont = datap; 856 iocp->ioc_count = sizeof (int); 857 mp->b_datap->db_type = M_IOCACK; 858 iocp->ioc_error = 0; 859 qreply(qp, mp); 860 break; 861 862 case KIOCSLAYOUT: 863 if (iocp->ioc_count != TRANSPARENT) { 864 miocnak(qp, mp, 0, EINVAL); 865 return; 866 } 867 868 kb8042->w_kblayout = *(intptr_t *)mp->b_cont->b_rptr; 869 miocack(qp, mp, 0, 0); 870 break; 871 872 case KIOCCMD: 873 error = miocpullup(mp, sizeof (int)); 874 if (error != 0) { 875 miocnak(qp, mp, 0, error); 876 return; 877 } 878 879 kb8042_type4_cmd(kb8042, *(int *)mp->b_cont->b_rptr); 880 miocack(qp, mp, 0, 0); 881 break; 882 883 case KIOCMKTONE: 884 if (iocp->ioc_count != TRANSPARENT) { 885 miocnak(qp, mp, 0, EINVAL); 886 return; 887 } 888 889 tmp = (int)(*(intptr_t *)mp->b_cont->b_rptr); 890 cycles = tmp & 0xffff; 891 msecs = (tmp >> 16) & 0xffff; 892 893 if (cycles == 0) 894 frequency = UINT16_MAX; 895 else if (cycles == UINT16_MAX) 896 frequency = 0; 897 else { 898 frequency = (PIT_HZ + cycles / 2) / cycles; 899 if (frequency > UINT16_MAX) 900 frequency = UINT16_MAX; 901 } 902 903 error = beep_mktone(frequency, msecs); 904 if (error != 0) 905 miocnak(qp, mp, 0, error); 906 else 907 miocack(qp, mp, 0, 0); 908 break; 909 910 default: 911 #ifdef DEBUG1 912 cmn_err(CE_NOTE, "!kb8042_ioctlmsg %x", iocp->ioc_cmd); 913 #endif 914 miocnak(qp, mp, 0, EINVAL); 915 return; 916 } 917 } 918 919 /* 920 * Process a byte received from the keyboard 921 */ 922 static void 923 kb8042_received_byte( 924 struct kb8042 *kb8042, 925 int scancode) /* raw scan code */ 926 { 927 boolean_t legit; /* is this a legit key pos'n? */ 928 int key_pos = -1; 929 enum keystate state; 930 boolean_t synthetic_release_needed; 931 932 #ifdef KD_DEBUG 933 kb8042_debug_hotkey(scancode); 934 #endif 935 936 if (!kb8042->w_init) /* can't do anything anyway */ 937 return; 938 939 legit = KeyboardConvertScan(kb8042, scancode, &key_pos, &state, 940 &synthetic_release_needed); 941 942 if (legit == 0) { 943 /* Eaten by translation */ 944 #ifdef KD_DEBUG 945 if (kb8042_debug) 946 prom_printf("kb8042_intr: 0x%x -> ignored\n", scancode); 947 #endif 948 return; 949 } 950 951 #ifdef KD_DEBUG 952 if (kb8042_debug) { 953 prom_printf("kb8042_intr: 0x%x -> %s %d", 954 scancode, 955 state == KEY_RELEASED ? "released" : "pressed", 956 key_pos); 957 } 958 #endif 959 960 /* 961 * Don't know if we want this permanently, but it seems interesting 962 * for the moment. 963 */ 964 if (key_pos == kb8042->debugger.mod1) { 965 #ifdef KD_DEBUG 966 if (kb8042_debug) 967 prom_printf(" -> debug mod1"); 968 #endif 969 kb8042->debugger.mod1_down = (state == KEY_PRESSED); 970 } 971 if (key_pos == kb8042->debugger.mod2) { 972 #ifdef KD_DEBUG 973 if (kb8042_debug) 974 prom_printf(" -> debug mod2"); 975 #endif 976 kb8042->debugger.mod2_down = (state == KEY_PRESSED); 977 } 978 if (kb8042->debugger.enabled && 979 key_pos == kb8042->debugger.trigger && 980 kb8042->debugger.mod1_down && 981 kb8042->debugger.mod2_down) { 982 #ifdef KD_DEBUG 983 if (kb8042_debug) 984 prom_printf(" -> debugger\n"); 985 #endif 986 /* 987 * Require new presses of the modifiers. 988 */ 989 kb8042->debugger.mod1_down = B_FALSE; 990 kb8042->debugger.mod2_down = B_FALSE; 991 abort_sequence_enter(NULL); 992 return; 993 } 994 995 /* 996 * If there's no queue above us - as can happen if we've been 997 * attached but not opened - drop the keystroke. 998 * Note that we do this here instead of above so that 999 * Ctrl-Alt-D still works. 1000 */ 1001 if (kb8042->w_qp == NULL) { 1002 #ifdef KD_DEBUG 1003 if (kb8042_debug) 1004 prom_printf(" -> nobody home\n"); 1005 #endif 1006 return; 1007 } 1008 1009 /* 1010 * This is to filter out auto repeat since it can't be 1011 * turned off at the hardware. (Yeah, yeah, PS/2 keyboards 1012 * can. Don't know whether they've taken over the world. 1013 * Don't think so.) 1014 */ 1015 if (kb8042_autorepeat_detect(kb8042, key_pos, state)) { 1016 #ifdef KD_DEBUG 1017 if (kb8042_debug) 1018 prom_printf(" -> autorepeat ignored\n"); 1019 #endif 1020 return; 1021 } 1022 1023 #ifdef KD_DEBUG 1024 if (kb8042_debug) 1025 prom_printf(" -> OK\n"); 1026 #endif 1027 1028 #if defined(KD_DEBUG) 1029 if (kb8042_pressrelease_debug) { 1030 prom_printf(" %s%d ", 1031 state == KEY_PRESSED ? "+" : "-", 1032 key_pos); 1033 } 1034 #endif 1035 1036 kb8042_process_key(kb8042, key_pos, state); 1037 1038 /* 1039 * This is a total hack. For some stupid reason, the two additional 1040 * keys on Korean keyboards (Hangul and Hangul/Hanja) report press 1041 * only. We synthesize a release immediately. 1042 */ 1043 if (synthetic_release_needed) { 1044 #if defined(KD_DEBUG) 1045 if (kb8042_debug) 1046 prom_printf("synthetic release %d\n", key_pos); 1047 if (kb8042_pressrelease_debug) 1048 prom_printf(" -%d(s) ", key_pos); 1049 #endif 1050 (void) kb8042_autorepeat_detect(kb8042, key_pos, KEY_RELEASED); 1051 kb8042_process_key(kb8042, key_pos, state); 1052 } 1053 } 1054 1055 1056 static void 1057 kb8042_process_key(struct kb8042 *kb8042, kbtrans_key_t key_pos, 1058 enum keystate state) 1059 { 1060 kbtrans_key_t key; 1061 1062 ASSERT(key_pos >= 0 && key_pos <= 255); 1063 if (kb8042->simulated_kbd_type == KB_PC) { 1064 kbtrans_streams_key(kb8042->hw_kbtrans, key_pos, state); 1065 } else if (kb8042->simulated_kbd_type == KB_USB) { 1066 key = keytab_pc2usb[key_pos]; 1067 if (key != 0) { 1068 kbtrans_streams_key(kb8042->hw_kbtrans, key, state); 1069 } 1070 } 1071 } 1072 1073 /* 1074 * Called from interrupt handler when keyboard interrupt occurs. 1075 */ 1076 static uint_t 1077 kb8042_intr(caddr_t arg) 1078 { 1079 uchar_t scancode; /* raw scan code */ 1080 int rc; 1081 struct kb8042 *kb8042 = (struct kb8042 *)arg; 1082 1083 rc = DDI_INTR_UNCLAIMED; 1084 1085 if (kb8042->init_state == KB8042_UNINITIALIZED) 1086 return (DDI_INTR_UNCLAIMED); 1087 1088 /* don't care if drv_setparm succeeds */ 1089 (void) drv_setparm(SYSRINT, 1); 1090 1091 while (ddi_get8(kb8042->handle, kb8042->addr + I8042_INT_INPUT_AVAIL) 1092 != 0) { 1093 rc = DDI_INTR_CLAIMED; 1094 1095 scancode = ddi_get8(kb8042->handle, 1096 kb8042->addr + I8042_INT_INPUT_DATA); 1097 1098 #if defined(KD_DEBUG) 1099 if (kb8042_low_level_debug) 1100 prom_printf(" <K:%x ", scancode); 1101 #endif 1102 1103 mutex_enter(&kb8042->w_hw_mutex); 1104 1105 if (kb8042_state_machine(kb8042, scancode, B_FALSE) != 1106 STATE_NORMAL) { 1107 mutex_exit(&kb8042->w_hw_mutex); 1108 continue; 1109 } 1110 1111 1112 mutex_exit(&kb8042->w_hw_mutex); 1113 1114 kb8042_received_byte(kb8042, scancode); 1115 } 1116 1117 return (rc); 1118 } 1119 1120 static void 1121 kb8042_iocdatamsg(queue_t *qp, mblk_t *mp) 1122 { 1123 struct copyresp *csp; 1124 1125 csp = (struct copyresp *)mp->b_rptr; 1126 if (csp->cp_rval) { 1127 freemsg(mp); 1128 return; 1129 } 1130 1131 switch (csp->cp_cmd) { 1132 default: 1133 miocack(qp, mp, 0, 0); 1134 break; 1135 } 1136 } 1137 1138 static boolean_t 1139 kb8042_polled_keycheck( 1140 struct kbtrans_hardware *hw, 1141 int *key, 1142 enum keystate *state) 1143 { 1144 struct kb8042 *kb8042 = (struct kb8042 *)hw; 1145 int scancode; 1146 boolean_t legit; 1147 boolean_t synthetic_release_needed; 1148 1149 if (kb8042->polled_synthetic_release_pending) { 1150 *key = kb8042->polled_synthetic_release_key; 1151 *state = KEY_RELEASED; 1152 kb8042->polled_synthetic_release_pending = B_FALSE; 1153 #if defined(KD_DEBUG) 1154 if (kb8042_getchar_debug) 1155 prom_printf("synthetic release 0x%x\n", *key); 1156 #endif 1157 (void) kb8042_autorepeat_detect(kb8042, *key, *state); 1158 return (B_TRUE); 1159 } 1160 1161 for (;;) { 1162 if (ddi_get8(kb8042->handle, 1163 kb8042->addr + I8042_POLL_INPUT_AVAIL) == 0) { 1164 return (B_FALSE); 1165 } 1166 1167 scancode = ddi_get8(kb8042->handle, 1168 kb8042->addr + I8042_POLL_INPUT_DATA); 1169 1170 #if defined(KD_DEBUG) 1171 if (kb8042_low_level_debug) 1172 prom_printf(" g<%x ", scancode); 1173 #endif 1174 1175 if (kb8042_state_machine(kb8042, scancode, B_FALSE) != 1176 STATE_NORMAL) { 1177 continue; 1178 } 1179 1180 #ifdef KD_DEBUG 1181 kb8042_debug_hotkey(scancode); 1182 if (kb8042_getchar_debug) 1183 prom_printf("polled 0x%x", scancode); 1184 #endif 1185 1186 legit = KeyboardConvertScan(kb8042, scancode, key, state, 1187 &synthetic_release_needed); 1188 if (!legit) { 1189 #ifdef KD_DEBUG 1190 if (kb8042_getchar_debug) 1191 prom_printf(" -> ignored\n"); 1192 #endif 1193 continue; 1194 } 1195 #ifdef KD_DEBUG 1196 if (kb8042_getchar_debug) { 1197 prom_printf(" -> %s %d\n", 1198 *state == KEY_PRESSED ? "pressed" : "released", 1199 *key); 1200 } 1201 #endif 1202 /* 1203 * For the moment at least, we rely on hardware autorepeat 1204 * for polled I/O autorepeat. However, for coordination 1205 * with the interrupt-driven code, maintain the last key 1206 * pressed. 1207 */ 1208 (void) kb8042_autorepeat_detect(kb8042, *key, *state); 1209 1210 /* 1211 * This is a total hack to support two additional keys 1212 * on Korean keyboards. They report only on press, and 1213 * so we synthesize a release. Most likely this will 1214 * never be important to polled I/O, but if I do it 1215 * "right" the first time it _won't_ be an issue. 1216 */ 1217 if (synthetic_release_needed) { 1218 kb8042->polled_synthetic_release_pending = B_TRUE; 1219 kb8042->polled_synthetic_release_key = *key; 1220 } 1221 1222 if (kb8042->simulated_kbd_type == KB_USB) { 1223 *key = keytab_pc2usb[*key]; 1224 } 1225 return (B_TRUE); 1226 } 1227 } 1228 1229 static void 1230 kb8042_setled(struct kb8042 *kb8042, int led_state, boolean_t polled) 1231 { 1232 kb8042->leds.desired = led_state; 1233 1234 if (!polled) 1235 mutex_enter(&kb8042->w_hw_mutex); 1236 1237 kb8042_start_state_machine(kb8042, polled); 1238 1239 if (!polled) 1240 mutex_exit(&kb8042->w_hw_mutex); 1241 } 1242 1243 static void 1244 kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state) 1245 { 1246 struct kb8042 *kb8042 = (struct kb8042 *)hw; 1247 kb8042_setled(kb8042, led_state, B_TRUE); 1248 } 1249 1250 static void 1251 kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state) 1252 { 1253 struct kb8042 *kb8042 = (struct kb8042 *)hw; 1254 kb8042_setled(kb8042, led_state, B_FALSE); 1255 } 1256 1257 static void 1258 kb8042_send_to_keyboard(struct kb8042 *kb8042, int byte, boolean_t polled) 1259 { 1260 if (polled) { 1261 ddi_put8(kb8042->handle, 1262 kb8042->addr + I8042_POLL_OUTPUT_DATA, byte); 1263 } else { 1264 ddi_put8(kb8042->handle, 1265 kb8042->addr + I8042_INT_OUTPUT_DATA, byte); 1266 } 1267 1268 #if defined(KD_DEBUG) 1269 if (kb8042_low_level_debug) 1270 prom_printf(" >K:%x ", byte); 1271 #endif 1272 } 1273 1274 /* 1275 * Wait until the keyboard is fully up, maybe. 1276 * We may be the first person to talk to the keyboard, in which case 1277 * it's patiently waiting to say "AA" to us to tell us it's up. 1278 * In theory it sends the AA in 300ms < n < 9s, but it's a pretty 1279 * good bet that we've already spent that long getting to that point, 1280 * so we'll only wait long enough for the communications electronics to 1281 * run. 1282 */ 1283 static void 1284 kb8042_wait_poweron(struct kb8042 *kb8042) 1285 { 1286 int cnt; 1287 int ready; 1288 unsigned char byt; 1289 1290 /* wait for up to 250 ms for a response */ 1291 for (cnt = 0; cnt < 250; cnt++) { 1292 ready = ddi_get8(kb8042->handle, 1293 kb8042->addr + I8042_INT_INPUT_AVAIL); 1294 if (ready != 0) 1295 break; 1296 drv_usecwait(1000); 1297 } 1298 1299 /* 1300 * If there's something pending, read and discard it. If not, 1301 * assume things are OK anyway - maybe somebody else ate it 1302 * already. (On a PC, the BIOS almost certainly did.) 1303 */ 1304 if (ready != 0) { 1305 byt = ddi_get8(kb8042->handle, 1306 kb8042->addr + I8042_INT_INPUT_DATA); 1307 #if defined(KD_DEBUG) 1308 if (kb8042_low_level_debug) 1309 prom_printf(" <K:%x ", byt); 1310 #endif 1311 } 1312 } 1313 1314 static void 1315 kb8042_start_state_machine(struct kb8042 *kb8042, boolean_t polled) 1316 { 1317 if (kb8042->command_state == KB_COMMAND_STATE_IDLE) { 1318 if (kb8042->leds.desired != kb8042->leds.commanded) { 1319 kb8042_send_to_keyboard(kb8042, KB_SET_LED, polled); 1320 kb8042->command_state = KB_COMMAND_STATE_LED; 1321 } 1322 } 1323 } 1324 1325 enum state_return 1326 kb8042_state_machine(struct kb8042 *kb8042, int scancode, boolean_t polled) 1327 { 1328 switch (kb8042->command_state) { 1329 case KB_COMMAND_STATE_IDLE: 1330 break; 1331 1332 case KB_COMMAND_STATE_LED: 1333 if (scancode == KB_ACK) { 1334 kb8042_send_to_keyboard(kb8042, 1335 kb8042_xlate_leds(kb8042->leds.desired), 1336 polled); 1337 kb8042->leds.commanded = kb8042->leds.desired; 1338 kb8042->command_state = KB_COMMAND_STATE_WAIT; 1339 return (STATE_INTERNAL); 1340 } 1341 /* Drop normal scan codes through. */ 1342 break; 1343 1344 case KB_COMMAND_STATE_WAIT: 1345 if (scancode == KB_ACK) { 1346 kb8042->command_state = KB_COMMAND_STATE_IDLE; 1347 kb8042_start_state_machine(kb8042, polled); 1348 return (STATE_INTERNAL); 1349 } 1350 /* Drop normal scan codes through. */ 1351 break; 1352 } 1353 return (STATE_NORMAL); 1354 } 1355 1356 static int 1357 kb8042_xlate_leds(int led) 1358 { 1359 int res; 1360 1361 res = 0; 1362 1363 if (led & LED_NUM_LOCK) 1364 res |= LED_NUM; 1365 if (led & LED_SCROLL_LOCK) 1366 res |= LED_SCR; 1367 if (led & LED_CAPS_LOCK) 1368 res |= LED_CAP; 1369 1370 return (res); 1371 } 1372 1373 /*ARGSUSED*/ 1374 static void 1375 kb8042_get_initial_leds( 1376 struct kb8042 *kb8042, 1377 int *initial_leds, 1378 int *initial_led_mask) 1379 { 1380 #if defined(i86pc) 1381 extern caddr_t p0_va; 1382 uint8_t bios_kb_flag; 1383 1384 bios_kb_flag = p0_va[BIOS_KB_FLAG]; 1385 1386 *initial_led_mask = LED_CAPS_LOCK | LED_NUM_LOCK | LED_SCROLL_LOCK; 1387 *initial_leds = 0; 1388 if (bios_kb_flag & BIOS_CAPS_STATE) 1389 *initial_leds |= LED_CAPS_LOCK; 1390 if (bios_kb_flag & BIOS_NUM_STATE) 1391 *initial_leds |= LED_NUM_LOCK; 1392 if (bios_kb_flag & BIOS_SCROLL_STATE) 1393 *initial_leds |= LED_SCROLL_LOCK; 1394 #else 1395 *initial_leds = 0; 1396 *initial_led_mask = 0; 1397 #endif 1398 } 1399 1400 #if defined(KD_DEBUG) 1401 static void 1402 kb8042_debug_hotkey(int scancode) 1403 { 1404 if (!kb8042_enable_debug_hotkey) 1405 return; 1406 1407 switch (scancode) { 1408 case 0x44: /* F10 in Scan Set 1 code. (Set 2 code is 0x09) */ 1409 if (!kb8042_debug) { 1410 prom_printf("\nKeyboard: normal debugging on\n"); 1411 kb8042_debug = B_TRUE; 1412 } 1413 break; 1414 case 0x43: /* F9 in Scan Set 1 code. (Set 2 code is 0x01) */ 1415 if (!kb8042_getchar_debug) { 1416 prom_printf("\nKeyboard: getchar debugging on\n"); 1417 kb8042_getchar_debug = B_TRUE; 1418 } 1419 break; 1420 case 0x42: /* F8 in Scan Set 1 code. (Set 2 code is 0x0a) */ 1421 if (!kb8042_low_level_debug) { 1422 prom_printf("\nKeyboard: low-level debugging on\n"); 1423 kb8042_low_level_debug = B_TRUE; 1424 } 1425 break; 1426 case 0x41: /* F7 in Scan Set 1 code. (Set 2 code is 0x83) */ 1427 if (!kb8042_pressrelease_debug) { 1428 prom_printf( 1429 "\nKeyboard: press/release debugging on\n"); 1430 kb8042_pressrelease_debug = B_TRUE; 1431 } 1432 break; 1433 case 0x3b: /* F1 in Scan Set 1 code. (Set 2 code is 0x05) */ 1434 if (kb8042_debug || 1435 kb8042_getchar_debug || 1436 kb8042_low_level_debug || 1437 kb8042_pressrelease_debug) { 1438 prom_printf("\nKeyboard: all debugging off\n"); 1439 kb8042_debug = B_FALSE; 1440 kb8042_getchar_debug = B_FALSE; 1441 kb8042_low_level_debug = B_FALSE; 1442 kb8042_pressrelease_debug = B_FALSE; 1443 } 1444 break; 1445 } 1446 } 1447 #endif 1448 1449 static boolean_t 1450 kb8042_autorepeat_detect( 1451 struct kb8042 *kb8042, 1452 int key_pos, 1453 enum keystate state) 1454 { 1455 if (state == KEY_RELEASED) { 1456 if (kb8042->kb_old_key_pos == key_pos) 1457 kb8042->kb_old_key_pos = 0; 1458 } else { 1459 if (kb8042->kb_old_key_pos == key_pos) { 1460 return (B_TRUE); 1461 } 1462 kb8042->kb_old_key_pos = key_pos; 1463 } 1464 return (B_FALSE); 1465 } 1466 1467 /* ARGSUSED */ 1468 static void 1469 kb8042_type4_cmd(struct kb8042 *kb8042, int cmd) 1470 { 1471 switch (cmd) { 1472 case KBD_CMD_BELL: 1473 (void) beeper_on(BEEP_TYPE4); 1474 break; 1475 case KBD_CMD_NOBELL: 1476 (void) beeper_off(); 1477 break; 1478 } 1479 } 1480 1481 1482 /* 1483 * This is a pass-thru routine to get a character at poll time. 1484 */ 1485 static int 1486 kb8042_polled_getchar(cons_polledio_arg_t arg) 1487 { 1488 struct kb8042 *kb8042; 1489 1490 kb8042 = (struct kb8042 *)arg; 1491 1492 return (kbtrans_getchar(kb8042->hw_kbtrans)); 1493 } 1494 1495 /* 1496 * This is a pass-thru routine to get a character at poll time. 1497 */ 1498 static int 1499 kb8042_polled_ischar(cons_polledio_arg_t arg) 1500 { 1501 struct kb8042 *kb8042; 1502 1503 kb8042 = (struct kb8042 *)arg; 1504 1505 return (kbtrans_ischar(kb8042->hw_kbtrans)); 1506 } 1507