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