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