1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1996-1999
5 * Kazutaka YOKOTA (yokota@zodiac.mech.utsunomiya-u.ac.jp)
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of the author may not be used to endorse or promote
17 * products derived from this software without specific prior written
18 * permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * from kbdio.c,v 1.13 1998/09/25 11:55:46 yokota Exp
33 */
34
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD: stable/12/sys/dev/atkbdc/atkbdc.c 368689 2020-12-16 07:59:47Z wulf $");
37
38 #include "opt_kbd.h"
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/bus.h>
43 #include <sys/malloc.h>
44 #include <sys/syslog.h>
45 #include <machine/bus.h>
46 #include <machine/resource.h>
47 #include <sys/rman.h>
48
49 #if defined(__amd64__)
50 #include <machine/clock.h>
51 #endif
52
53 #include <dev/atkbdc/atkbdcreg.h>
54
55 #ifdef __sparc64__
56 #include <dev/ofw/openfirm.h>
57 #include <machine/bus_private.h>
58 #include <machine/ofw_machdep.h>
59 #else
60 #include <isa/isareg.h>
61 #endif
62
63 /* constants */
64
65 #define MAXKBDC 1 /* XXX */
66
67 /* macros */
68
69 #ifndef MAX
70 #define MAX(x, y) ((x) > (y) ? (x) : (y))
71 #endif
72
73 #define kbdcp(p) ((atkbdc_softc_t *)(p))
74 #define nextq(i) (((i) + 1) % KBDQ_BUFSIZE)
75 #define availq(q) ((q)->head != (q)->tail)
76 #if KBDIO_DEBUG >= 2
77 #define emptyq(q) ((q)->tail = (q)->head = (q)->qcount = 0)
78 #else
79 #define emptyq(q) ((q)->tail = (q)->head = 0)
80 #endif
81
82 #define read_data(k) (bus_space_read_1((k)->iot, (k)->ioh0, 0))
83 #define read_status(k) (bus_space_read_1((k)->iot, (k)->ioh1, 0))
84 #define write_data(k, d) \
85 (bus_space_write_1((k)->iot, (k)->ioh0, 0, (d)))
86 #define write_command(k, d) \
87 (bus_space_write_1((k)->iot, (k)->ioh1, 0, (d)))
88
89 /* local variables */
90
91 /*
92 * We always need at least one copy of the kbdc_softc struct for the
93 * low-level console. As the low-level console accesses the keyboard
94 * controller before kbdc, and all other devices, is probed, we
95 * statically allocate one entry. XXX
96 */
97 static atkbdc_softc_t default_kbdc;
98 static atkbdc_softc_t *atkbdc_softc[MAXKBDC] = { &default_kbdc };
99
100 static int verbose = KBDIO_DEBUG;
101
102 #ifdef __sparc64__
103 static struct bus_space_tag atkbdc_bst_store[MAXKBDC];
104 #endif
105
106 /* function prototypes */
107
108 static int atkbdc_setup(atkbdc_softc_t *sc, bus_space_tag_t tag,
109 bus_space_handle_t h0, bus_space_handle_t h1);
110 static int addq(kqueue *q, int c);
111 static int removeq(kqueue *q);
112 static int wait_while_controller_busy(atkbdc_softc_t *kbdc);
113 static int wait_for_data(atkbdc_softc_t *kbdc);
114 static int wait_for_kbd_data(atkbdc_softc_t *kbdc);
115 static int wait_for_kbd_ack(atkbdc_softc_t *kbdc);
116 static int wait_for_aux_data(atkbdc_softc_t *kbdc);
117 static int wait_for_aux_ack(atkbdc_softc_t *kbdc);
118
119 struct atkbdc_quirks {
120 const char* bios_vendor;
121 const char* maker;
122 const char* product;
123 int quirk;
124 };
125
126 static struct atkbdc_quirks quirks[] = {
127 {"coreboot", "System76", NULL, 0},
128 {"coreboot", NULL, NULL,
129 KBDC_QUIRK_KEEP_ACTIVATED | KBDC_QUIRK_IGNORE_PROBE_RESULT |
130 KBDC_QUIRK_RESET_AFTER_PROBE | KBDC_QUIRK_SETLEDS_ON_INIT},
131 /* KBDC hangs on Lenovo X120e and X121e after disabling AUX MUX */
132 {NULL, "LENOVO", NULL, KBDC_QUIRK_DISABLE_MUX_PROBE},
133 };
134
135 #define QUIRK_STR_MATCH(s1, s2) (s1 == NULL || \
136 (s2 != NULL && !strcmp(s1, s2)))
137
138 static int
atkbdc_getquirks(void)139 atkbdc_getquirks(void)
140 {
141 int i;
142 char* bios_vendor = kern_getenv("smbios.bios.vendor");
143 char* maker = kern_getenv("smbios.system.maker");
144 char* product = kern_getenv("smbios.system.product");
145
146 for (i = 0; i < nitems(quirks); i++)
147 if (QUIRK_STR_MATCH(quirks[i].bios_vendor, bios_vendor) &&
148 QUIRK_STR_MATCH(quirks[i].maker, maker) &&
149 QUIRK_STR_MATCH(quirks[i].product, product))
150 return (quirks[i].quirk);
151
152 return (0);
153 }
154
155 atkbdc_softc_t
atkbdc_get_softc(int unit)156 *atkbdc_get_softc(int unit)
157 {
158 atkbdc_softc_t *sc;
159
160 if (unit >= nitems(atkbdc_softc))
161 return NULL;
162 sc = atkbdc_softc[unit];
163 if (sc == NULL) {
164 sc = atkbdc_softc[unit]
165 = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT | M_ZERO);
166 if (sc == NULL)
167 return NULL;
168 }
169 return sc;
170 }
171
172 int
atkbdc_probe_unit(int unit,struct resource * port0,struct resource * port1)173 atkbdc_probe_unit(int unit, struct resource *port0, struct resource *port1)
174 {
175 if (rman_get_start(port0) <= 0)
176 return ENXIO;
177 if (rman_get_start(port1) <= 0)
178 return ENXIO;
179 return 0;
180 }
181
182 int
atkbdc_attach_unit(int unit,atkbdc_softc_t * sc,struct resource * port0,struct resource * port1)183 atkbdc_attach_unit(int unit, atkbdc_softc_t *sc, struct resource *port0,
184 struct resource *port1)
185 {
186 return atkbdc_setup(sc, rman_get_bustag(port0),
187 rman_get_bushandle(port0),
188 rman_get_bushandle(port1));
189 }
190
191 /* the backdoor to the keyboard controller! XXX */
192 int
atkbdc_configure(void)193 atkbdc_configure(void)
194 {
195 bus_space_tag_t tag;
196 bus_space_handle_t h0;
197 bus_space_handle_t h1;
198 #if defined(__i386__) || defined(__amd64__)
199 volatile int i;
200 register_t flags;
201 #endif
202 #ifdef __sparc64__
203 char name[32];
204 phandle_t chosen, node;
205 ihandle_t stdin;
206 bus_addr_t port0;
207 bus_addr_t port1;
208 int space;
209 #else
210 int port0;
211 int port1;
212 #endif
213
214 /* XXX: tag should be passed from the caller */
215 #if defined(__amd64__) || defined(__i386__)
216 tag = X86_BUS_SPACE_IO;
217 #elif defined(__sparc64__)
218 tag = &atkbdc_bst_store[0];
219 #else
220 #error "define tag!"
221 #endif
222
223 #ifdef __sparc64__
224 if ((chosen = OF_finddevice("/chosen")) == -1)
225 return 0;
226 if (OF_getprop(chosen, "stdin", &stdin, sizeof(stdin)) == -1)
227 return 0;
228 if ((node = OF_instance_to_package(stdin)) == -1)
229 return 0;
230 if (OF_getprop(node, "name", name, sizeof(name)) == -1)
231 return 0;
232 name[sizeof(name) - 1] = '\0';
233 if (strcmp(name, "kb_ps2") != 0)
234 return 0;
235 /*
236 * The stdin handle points to an instance of a PS/2 keyboard
237 * package but we want the 8042 controller, which is the parent
238 * of that keyboard node.
239 */
240 if ((node = OF_parent(node)) == 0)
241 return 0;
242 if (OF_decode_addr(node, 0, &space, &port0) != 0)
243 return 0;
244 h0 = sparc64_fake_bustag(space, port0, tag);
245 bus_space_subregion(tag, h0, KBD_DATA_PORT, 1, &h0);
246 if (OF_decode_addr(node, 1, &space, &port1) != 0)
247 return 0;
248 h1 = sparc64_fake_bustag(space, port1, tag);
249 bus_space_subregion(tag, h1, KBD_STATUS_PORT, 1, &h1);
250 #else
251 port0 = IO_KBD;
252 resource_int_value("atkbdc", 0, "port", &port0);
253 port1 = IO_KBD + KBD_STATUS_PORT;
254 #ifdef notyet
255 bus_space_map(tag, port0, IO_KBDSIZE, 0, &h0);
256 bus_space_map(tag, port1, IO_KBDSIZE, 0, &h1);
257 #else
258 h0 = (bus_space_handle_t)port0;
259 h1 = (bus_space_handle_t)port1;
260 #endif
261 #endif
262
263 #if defined(__i386__) || defined(__amd64__)
264 /*
265 * Check if we really have AT keyboard controller. Poll status
266 * register until we get "all clear" indication. If no such
267 * indication comes, it probably means that there is no AT
268 * keyboard controller present. Give up in such case. Check relies
269 * on the fact that reading from non-existing in/out port returns
270 * 0xff on i386. May or may not be true on other platforms.
271 */
272 flags = intr_disable();
273 for (i = 0; i != 65535; i++) {
274 if ((bus_space_read_1(tag, h1, 0) & 0x2) == 0)
275 break;
276 }
277 intr_restore(flags);
278 if (i == 65535)
279 return ENXIO;
280 #endif
281
282 return atkbdc_setup(atkbdc_softc[0], tag, h0, h1);
283 }
284
285 static int
atkbdc_setup(atkbdc_softc_t * sc,bus_space_tag_t tag,bus_space_handle_t h0,bus_space_handle_t h1)286 atkbdc_setup(atkbdc_softc_t *sc, bus_space_tag_t tag, bus_space_handle_t h0,
287 bus_space_handle_t h1)
288 {
289 #if defined(__amd64__)
290 u_int64_t tscval[3], read_delay;
291 register_t flags;
292 #endif
293
294 if (sc->ioh0 == 0) { /* XXX */
295 sc->command_byte = -1;
296 sc->command_mask = 0;
297 sc->lock = FALSE;
298 sc->kbd.head = sc->kbd.tail = 0;
299 sc->aux.head = sc->aux.tail = 0;
300 sc->aux_mux_enabled = FALSE;
301 #if KBDIO_DEBUG >= 2
302 sc->kbd.call_count = 0;
303 sc->kbd.qcount = sc->kbd.max_qcount = 0;
304 sc->aux.call_count = 0;
305 sc->aux.qcount = sc->aux.max_qcount = 0;
306 #endif
307 }
308 sc->iot = tag;
309 sc->ioh0 = h0;
310 sc->ioh1 = h1;
311
312 #if defined(__amd64__)
313 /*
314 * On certain chipsets AT keyboard controller isn't present and is
315 * emulated by BIOS using SMI interrupt. On those chipsets reading
316 * from the status port may be thousand times slower than usually.
317 * Sometimes this emilation is not working properly resulting in
318 * commands timing our and since we assume that inb() operation
319 * takes very little time to complete we need to adjust number of
320 * retries to keep waiting time within a designed limits (100ms).
321 * Measure time it takes to make read_status() call and adjust
322 * number of retries accordingly.
323 */
324 flags = intr_disable();
325 tscval[0] = rdtsc();
326 read_status(sc);
327 tscval[1] = rdtsc();
328 DELAY(1000);
329 tscval[2] = rdtsc();
330 intr_restore(flags);
331 read_delay = tscval[1] - tscval[0];
332 read_delay /= (tscval[2] - tscval[1]) / 1000;
333 sc->retry = 100000 / ((KBDD_DELAYTIME * 2) + read_delay);
334 #else
335 sc->retry = 5000;
336 #endif
337 sc->quirks = atkbdc_getquirks();
338
339 return 0;
340 }
341
342 /* open a keyboard controller */
343 KBDC
atkbdc_open(int unit)344 atkbdc_open(int unit)
345 {
346 if (unit <= 0)
347 unit = 0;
348 if (unit >= MAXKBDC)
349 return NULL;
350 if ((atkbdc_softc[unit]->port0 != NULL)
351 || (atkbdc_softc[unit]->ioh0 != 0)) /* XXX */
352 return (KBDC)atkbdc_softc[unit];
353 return NULL;
354 }
355
356 /*
357 * I/O access arbitration in `kbdio'
358 *
359 * The `kbdio' module uses a simplistic convention to arbitrate
360 * I/O access to the controller/keyboard/mouse. The convention requires
361 * close cooperation of the calling device driver.
362 *
363 * The device drivers which utilize the `kbdio' module are assumed to
364 * have the following set of routines.
365 * a. An interrupt handler (the bottom half of the driver).
366 * b. Timeout routines which may briefly poll the keyboard controller.
367 * c. Routines outside interrupt context (the top half of the driver).
368 * They should follow the rules below:
369 * 1. The interrupt handler may assume that it always has full access
370 * to the controller/keyboard/mouse.
371 * 2. The other routines must issue `spltty()' if they wish to
372 * prevent the interrupt handler from accessing
373 * the controller/keyboard/mouse.
374 * 3. The timeout routines and the top half routines of the device driver
375 * arbitrate I/O access by observing the lock flag in `kbdio'.
376 * The flag is manipulated via `kbdc_lock()'; when one wants to
377 * perform I/O, call `kbdc_lock(kbdc, TRUE)' and proceed only if
378 * the call returns with TRUE. Otherwise the caller must back off.
379 * Call `kbdc_lock(kbdc, FALSE)' when necessary I/O operaion
380 * is finished. This mechanism does not prevent the interrupt
381 * handler from being invoked at any time and carrying out I/O.
382 * Therefore, `spltty()' must be strategically placed in the device
383 * driver code. Also note that the timeout routine may interrupt
384 * `kbdc_lock()' called by the top half of the driver, but this
385 * interruption is OK so long as the timeout routine observes
386 * rule 4 below.
387 * 4. The interrupt and timeout routines should not extend I/O operation
388 * across more than one interrupt or timeout; they must complete any
389 * necessary I/O operation within one invocation of the routine.
390 * This means that if the timeout routine acquires the lock flag,
391 * it must reset the flag to FALSE before it returns.
392 */
393
394 /* set/reset polling lock */
395 int
kbdc_lock(KBDC p,int lock)396 kbdc_lock(KBDC p, int lock)
397 {
398 int prevlock;
399
400 prevlock = kbdcp(p)->lock;
401 kbdcp(p)->lock = lock;
402
403 return (prevlock != lock);
404 }
405
406 /* check if any data is waiting to be processed */
407 int
kbdc_data_ready(KBDC p)408 kbdc_data_ready(KBDC p)
409 {
410 return (availq(&kbdcp(p)->kbd) || availq(&kbdcp(p)->aux)
411 || (read_status(kbdcp(p)) & KBDS_ANY_BUFFER_FULL));
412 }
413
414 /* queuing functions */
415
416 static int
addq(kqueue * q,int c)417 addq(kqueue *q, int c)
418 {
419 if (nextq(q->tail) != q->head) {
420 q->q[q->tail] = c;
421 q->tail = nextq(q->tail);
422 #if KBDIO_DEBUG >= 2
423 ++q->call_count;
424 ++q->qcount;
425 if (q->qcount > q->max_qcount)
426 q->max_qcount = q->qcount;
427 #endif
428 return TRUE;
429 }
430 return FALSE;
431 }
432
433 static int
removeq(kqueue * q)434 removeq(kqueue *q)
435 {
436 int c;
437
438 if (q->tail != q->head) {
439 c = q->q[q->head];
440 q->head = nextq(q->head);
441 #if KBDIO_DEBUG >= 2
442 --q->qcount;
443 #endif
444 return c;
445 }
446 return -1;
447 }
448
449 /*
450 * device I/O routines
451 */
452 static int
wait_while_controller_busy(struct atkbdc_softc * kbdc)453 wait_while_controller_busy(struct atkbdc_softc *kbdc)
454 {
455 int retry;
456 int f;
457
458 /* CPU will stay inside the loop for 100msec at most */
459 retry = kbdc->retry;
460
461 while ((f = read_status(kbdc)) & KBDS_INPUT_BUFFER_FULL) {
462 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
463 DELAY(KBDD_DELAYTIME);
464 addq(&kbdc->kbd, read_data(kbdc));
465 } else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
466 DELAY(KBDD_DELAYTIME);
467 addq(&kbdc->aux, read_data(kbdc));
468 }
469 DELAY(KBDC_DELAYTIME);
470 if (--retry < 0)
471 return FALSE;
472 }
473 return TRUE;
474 }
475
476 /*
477 * wait for any data; whether it's from the controller,
478 * the keyboard, or the aux device.
479 */
480 static int
wait_for_data(struct atkbdc_softc * kbdc)481 wait_for_data(struct atkbdc_softc *kbdc)
482 {
483 int retry;
484 int f;
485
486 /* CPU will stay inside the loop for 200msec at most */
487 retry = kbdc->retry * 2;
488
489 while ((f = read_status(kbdc) & KBDS_ANY_BUFFER_FULL) == 0) {
490 DELAY(KBDC_DELAYTIME);
491 if (--retry < 0)
492 return 0;
493 }
494 DELAY(KBDD_DELAYTIME);
495 return f;
496 }
497
498 /* wait for data from the keyboard */
499 static int
wait_for_kbd_data(struct atkbdc_softc * kbdc)500 wait_for_kbd_data(struct atkbdc_softc *kbdc)
501 {
502 int retry;
503 int f;
504
505 /* CPU will stay inside the loop for 200msec at most */
506 retry = kbdc->retry * 2;
507
508 while ((f = read_status(kbdc) & KBDS_BUFFER_FULL)
509 != KBDS_KBD_BUFFER_FULL) {
510 if (f == KBDS_AUX_BUFFER_FULL) {
511 DELAY(KBDD_DELAYTIME);
512 addq(&kbdc->aux, read_data(kbdc));
513 }
514 DELAY(KBDC_DELAYTIME);
515 if (--retry < 0)
516 return 0;
517 }
518 DELAY(KBDD_DELAYTIME);
519 return f;
520 }
521
522 /*
523 * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the keyboard.
524 * queue anything else.
525 */
526 static int
wait_for_kbd_ack(struct atkbdc_softc * kbdc)527 wait_for_kbd_ack(struct atkbdc_softc *kbdc)
528 {
529 int retry;
530 int f;
531 int b;
532
533 /* CPU will stay inside the loop for 200msec at most */
534 retry = kbdc->retry * 2;
535
536 while (retry-- > 0) {
537 if ((f = read_status(kbdc)) & KBDS_ANY_BUFFER_FULL) {
538 DELAY(KBDD_DELAYTIME);
539 b = read_data(kbdc);
540 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
541 if ((b == KBD_ACK) || (b == KBD_RESEND)
542 || (b == KBD_RESET_FAIL))
543 return b;
544 addq(&kbdc->kbd, b);
545 } else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
546 addq(&kbdc->aux, b);
547 }
548 }
549 DELAY(KBDC_DELAYTIME);
550 }
551 return -1;
552 }
553
554 /* wait for data from the aux device */
555 static int
wait_for_aux_data(struct atkbdc_softc * kbdc)556 wait_for_aux_data(struct atkbdc_softc *kbdc)
557 {
558 int retry;
559 int f;
560
561 /* CPU will stay inside the loop for 200msec at most */
562 retry = kbdc->retry * 2;
563
564 while ((f = read_status(kbdc) & KBDS_BUFFER_FULL)
565 != KBDS_AUX_BUFFER_FULL) {
566 if (f == KBDS_KBD_BUFFER_FULL) {
567 DELAY(KBDD_DELAYTIME);
568 addq(&kbdc->kbd, read_data(kbdc));
569 }
570 DELAY(KBDC_DELAYTIME);
571 if (--retry < 0)
572 return 0;
573 }
574 DELAY(KBDD_DELAYTIME);
575 return f;
576 }
577
578 /*
579 * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the aux device.
580 * queue anything else.
581 */
582 static int
wait_for_aux_ack(struct atkbdc_softc * kbdc)583 wait_for_aux_ack(struct atkbdc_softc *kbdc)
584 {
585 int retry;
586 int f;
587 int b;
588
589 /* CPU will stay inside the loop for 200msec at most */
590 retry = kbdc->retry * 2;
591
592 while (retry-- > 0) {
593 if ((f = read_status(kbdc)) & KBDS_ANY_BUFFER_FULL) {
594 DELAY(KBDD_DELAYTIME);
595 b = read_data(kbdc);
596 if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
597 if ((b == PSM_ACK) || (b == PSM_RESEND)
598 || (b == PSM_RESET_FAIL))
599 return b;
600 addq(&kbdc->aux, b);
601 } else if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
602 addq(&kbdc->kbd, b);
603 }
604 }
605 DELAY(KBDC_DELAYTIME);
606 }
607 return -1;
608 }
609
610 /* write a one byte command to the controller */
611 int
write_controller_command(KBDC p,int c)612 write_controller_command(KBDC p, int c)
613 {
614 if (!wait_while_controller_busy(kbdcp(p)))
615 return FALSE;
616 write_command(kbdcp(p), c);
617 return TRUE;
618 }
619
620 /* write a one byte data to the controller */
621 int
write_controller_data(KBDC p,int c)622 write_controller_data(KBDC p, int c)
623 {
624 if (!wait_while_controller_busy(kbdcp(p)))
625 return FALSE;
626 write_data(kbdcp(p), c);
627 return TRUE;
628 }
629
630 /* write a one byte keyboard command */
631 int
write_kbd_command(KBDC p,int c)632 write_kbd_command(KBDC p, int c)
633 {
634 if (!wait_while_controller_busy(kbdcp(p)))
635 return FALSE;
636 write_data(kbdcp(p), c);
637 return TRUE;
638 }
639
640 /* write a one byte auxiliary device command */
641 int
write_aux_command(KBDC p,int c)642 write_aux_command(KBDC p, int c)
643 {
644 int f;
645
646 f = aux_mux_is_enabled(p) ?
647 KBDC_WRITE_TO_AUX_MUX + kbdcp(p)->aux_mux_port : KBDC_WRITE_TO_AUX;
648
649 if (!write_controller_command(p, f))
650 return FALSE;
651 return write_controller_data(p, c);
652 }
653
654 /* send a command to the keyboard and wait for ACK */
655 int
send_kbd_command(KBDC p,int c)656 send_kbd_command(KBDC p, int c)
657 {
658 int retry = KBD_MAXRETRY;
659 int res = -1;
660
661 while (retry-- > 0) {
662 if (!write_kbd_command(p, c))
663 continue;
664 res = wait_for_kbd_ack(kbdcp(p));
665 if (res == KBD_ACK)
666 break;
667 }
668 return res;
669 }
670
671 /* send a command to the auxiliary device and wait for ACK */
672 int
send_aux_command(KBDC p,int c)673 send_aux_command(KBDC p, int c)
674 {
675 int retry = KBD_MAXRETRY;
676 int res = -1;
677
678 while (retry-- > 0) {
679 if (!write_aux_command(p, c))
680 continue;
681 /*
682 * FIXME: XXX
683 * The aux device may have already sent one or two bytes of
684 * status data, when a command is received. It will immediately
685 * stop data transmission, thus, leaving an incomplete data
686 * packet in our buffer. We have to discard any unprocessed
687 * data in order to remove such packets. Well, we may remove
688 * unprocessed, but necessary data byte as well...
689 */
690 emptyq(&kbdcp(p)->aux);
691 res = wait_for_aux_ack(kbdcp(p));
692 if (res == PSM_ACK)
693 break;
694 }
695 return res;
696 }
697
698 /* send a command and a data to the keyboard, wait for ACKs */
699 int
send_kbd_command_and_data(KBDC p,int c,int d)700 send_kbd_command_and_data(KBDC p, int c, int d)
701 {
702 int retry;
703 int res = -1;
704
705 for (retry = KBD_MAXRETRY; retry > 0; --retry) {
706 if (!write_kbd_command(p, c))
707 continue;
708 res = wait_for_kbd_ack(kbdcp(p));
709 if (res == KBD_ACK)
710 break;
711 else if (res != KBD_RESEND)
712 return res;
713 }
714 if (retry <= 0)
715 return res;
716
717 for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) {
718 if (!write_kbd_command(p, d))
719 continue;
720 res = wait_for_kbd_ack(kbdcp(p));
721 if (res != KBD_RESEND)
722 break;
723 }
724 return res;
725 }
726
727 /* send a command and a data to the auxiliary device, wait for ACKs */
728 int
send_aux_command_and_data(KBDC p,int c,int d)729 send_aux_command_and_data(KBDC p, int c, int d)
730 {
731 int retry;
732 int res = -1;
733
734 for (retry = KBD_MAXRETRY; retry > 0; --retry) {
735 if (!write_aux_command(p, c))
736 continue;
737 emptyq(&kbdcp(p)->aux);
738 res = wait_for_aux_ack(kbdcp(p));
739 if (res == PSM_ACK)
740 break;
741 else if (res != PSM_RESEND)
742 return res;
743 }
744 if (retry <= 0)
745 return res;
746
747 for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) {
748 if (!write_aux_command(p, d))
749 continue;
750 res = wait_for_aux_ack(kbdcp(p));
751 if (res != PSM_RESEND)
752 break;
753 }
754 return res;
755 }
756
757 /*
758 * read one byte from any source; whether from the controller,
759 * the keyboard, or the aux device
760 */
761 int
read_controller_data(KBDC p)762 read_controller_data(KBDC p)
763 {
764 if (availq(&kbdcp(p)->kbd))
765 return removeq(&kbdcp(p)->kbd);
766 if (availq(&kbdcp(p)->aux))
767 return removeq(&kbdcp(p)->aux);
768 if (!wait_for_data(kbdcp(p)))
769 return -1; /* timeout */
770 return read_data(kbdcp(p));
771 }
772
773 #if KBDIO_DEBUG >= 2
774 static int call = 0;
775 #endif
776
777 /* read one byte from the keyboard */
778 int
read_kbd_data(KBDC p)779 read_kbd_data(KBDC p)
780 {
781 #if KBDIO_DEBUG >= 2
782 if (++call > 2000) {
783 call = 0;
784 log(LOG_DEBUG, "kbdc: kbd q: %d calls, max %d chars, "
785 "aux q: %d calls, max %d chars\n",
786 kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount,
787 kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount);
788 }
789 #endif
790
791 if (availq(&kbdcp(p)->kbd))
792 return removeq(&kbdcp(p)->kbd);
793 if (!wait_for_kbd_data(kbdcp(p)))
794 return -1; /* timeout */
795 return read_data(kbdcp(p));
796 }
797
798 /* read one byte from the keyboard, but return immediately if
799 * no data is waiting
800 */
801 int
read_kbd_data_no_wait(KBDC p)802 read_kbd_data_no_wait(KBDC p)
803 {
804 int f;
805
806 #if KBDIO_DEBUG >= 2
807 if (++call > 2000) {
808 call = 0;
809 log(LOG_DEBUG, "kbdc: kbd q: %d calls, max %d chars, "
810 "aux q: %d calls, max %d chars\n",
811 kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount,
812 kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount);
813 }
814 #endif
815
816 if (availq(&kbdcp(p)->kbd))
817 return removeq(&kbdcp(p)->kbd);
818 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL;
819 if (f == KBDS_AUX_BUFFER_FULL) {
820 DELAY(KBDD_DELAYTIME);
821 addq(&kbdcp(p)->aux, read_data(kbdcp(p)));
822 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL;
823 }
824 if (f == KBDS_KBD_BUFFER_FULL) {
825 DELAY(KBDD_DELAYTIME);
826 return read_data(kbdcp(p));
827 }
828 return -1; /* no data */
829 }
830
831 /* read one byte from the aux device */
832 int
read_aux_data(KBDC p)833 read_aux_data(KBDC p)
834 {
835 if (availq(&kbdcp(p)->aux))
836 return removeq(&kbdcp(p)->aux);
837 if (!wait_for_aux_data(kbdcp(p)))
838 return -1; /* timeout */
839 return read_data(kbdcp(p));
840 }
841
842 /* read one byte from the aux device, but return immediately if
843 * no data is waiting
844 */
845 int
read_aux_data_no_wait(KBDC p)846 read_aux_data_no_wait(KBDC p)
847 {
848 int f;
849
850 if (availq(&kbdcp(p)->aux))
851 return removeq(&kbdcp(p)->aux);
852 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL;
853 if (f == KBDS_KBD_BUFFER_FULL) {
854 DELAY(KBDD_DELAYTIME);
855 addq(&kbdcp(p)->kbd, read_data(kbdcp(p)));
856 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL;
857 }
858 if (f == KBDS_AUX_BUFFER_FULL) {
859 DELAY(KBDD_DELAYTIME);
860 return read_data(kbdcp(p));
861 }
862 return -1; /* no data */
863 }
864
865 /* discard data from the keyboard */
866 void
empty_kbd_buffer(KBDC p,int wait)867 empty_kbd_buffer(KBDC p, int wait)
868 {
869 int t;
870 int b;
871 int f;
872 #if KBDIO_DEBUG >= 2
873 int c1 = 0;
874 int c2 = 0;
875 #endif
876 int delta = 2;
877
878 for (t = wait; t > 0; ) {
879 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) {
880 DELAY(KBDD_DELAYTIME);
881 b = read_data(kbdcp(p));
882 if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
883 addq(&kbdcp(p)->aux, b);
884 #if KBDIO_DEBUG >= 2
885 ++c2;
886 } else {
887 ++c1;
888 #endif
889 }
890 t = wait;
891 } else {
892 t -= delta;
893 }
894 DELAY(delta*1000);
895 }
896 #if KBDIO_DEBUG >= 2
897 if ((c1 > 0) || (c2 > 0))
898 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_kbd_buffer)\n", c1, c2);
899 #endif
900
901 emptyq(&kbdcp(p)->kbd);
902 }
903
904 /* discard data from the aux device */
905 void
empty_aux_buffer(KBDC p,int wait)906 empty_aux_buffer(KBDC p, int wait)
907 {
908 int t;
909 int b;
910 int f;
911 #if KBDIO_DEBUG >= 2
912 int c1 = 0;
913 int c2 = 0;
914 #endif
915 int delta = 2;
916
917 for (t = wait; t > 0; ) {
918 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) {
919 DELAY(KBDD_DELAYTIME);
920 b = read_data(kbdcp(p));
921 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
922 addq(&kbdcp(p)->kbd, b);
923 #if KBDIO_DEBUG >= 2
924 ++c1;
925 } else {
926 ++c2;
927 #endif
928 }
929 t = wait;
930 } else {
931 t -= delta;
932 }
933 DELAY(delta*1000);
934 }
935 #if KBDIO_DEBUG >= 2
936 if ((c1 > 0) || (c2 > 0))
937 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_aux_buffer)\n", c1, c2);
938 #endif
939
940 emptyq(&kbdcp(p)->aux);
941 }
942
943 /* discard any data from the keyboard or the aux device */
944 void
empty_both_buffers(KBDC p,int wait)945 empty_both_buffers(KBDC p, int wait)
946 {
947 int t;
948 int f;
949 int waited = 0;
950 #if KBDIO_DEBUG >= 2
951 int c1 = 0;
952 int c2 = 0;
953 #endif
954 int delta = 2;
955
956 for (t = wait; t > 0; ) {
957 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) {
958 DELAY(KBDD_DELAYTIME);
959 (void)read_data(kbdcp(p));
960 #if KBDIO_DEBUG >= 2
961 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL)
962 ++c1;
963 else
964 ++c2;
965 #endif
966 t = wait;
967 } else {
968 t -= delta;
969 }
970
971 /*
972 * Some systems (Intel/IBM blades) do not have keyboard devices and
973 * will thus hang in this procedure. Time out after delta seconds to
974 * avoid this hang -- the keyboard attach will fail later on.
975 */
976 waited += (delta * 1000);
977 if (waited == (delta * 1000000))
978 return;
979
980 DELAY(delta*1000);
981 }
982 #if KBDIO_DEBUG >= 2
983 if ((c1 > 0) || (c2 > 0))
984 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_both_buffers)\n", c1, c2);
985 #endif
986
987 emptyq(&kbdcp(p)->kbd);
988 emptyq(&kbdcp(p)->aux);
989 }
990
991 /* keyboard and mouse device control */
992
993 /* NOTE: enable the keyboard port but disable the keyboard
994 * interrupt before calling "reset_kbd()".
995 */
996 int
reset_kbd(KBDC p)997 reset_kbd(KBDC p)
998 {
999 int retry = KBD_MAXRETRY;
1000 int again = KBD_MAXWAIT;
1001 int c = KBD_RESEND; /* keep the compiler happy */
1002
1003 while (retry-- > 0) {
1004 empty_both_buffers(p, 10);
1005 if (!write_kbd_command(p, KBDC_RESET_KBD))
1006 continue;
1007 emptyq(&kbdcp(p)->kbd);
1008 c = read_controller_data(p);
1009 if (verbose || bootverbose)
1010 log(LOG_DEBUG, "kbdc: RESET_KBD return code:%04x\n", c);
1011 if (c == KBD_ACK) /* keyboard has agreed to reset itself... */
1012 break;
1013 }
1014 if (retry < 0)
1015 return FALSE;
1016
1017 while (again-- > 0) {
1018 /* wait awhile, well, in fact we must wait quite loooooooooooong */
1019 DELAY(KBD_RESETDELAY*1000);
1020 c = read_controller_data(p); /* RESET_DONE/RESET_FAIL */
1021 if (c != -1) /* wait again if the controller is not ready */
1022 break;
1023 }
1024 if (verbose || bootverbose)
1025 log(LOG_DEBUG, "kbdc: RESET_KBD status:%04x\n", c);
1026 if (c != KBD_RESET_DONE)
1027 return FALSE;
1028 return TRUE;
1029 }
1030
1031 /* NOTE: enable the aux port but disable the aux interrupt
1032 * before calling `reset_aux_dev()'.
1033 */
1034 int
reset_aux_dev(KBDC p)1035 reset_aux_dev(KBDC p)
1036 {
1037 int retry = KBD_MAXRETRY;
1038 int again = KBD_MAXWAIT;
1039 int c = PSM_RESEND; /* keep the compiler happy */
1040
1041 while (retry-- > 0) {
1042 empty_both_buffers(p, 10);
1043 if (!write_aux_command(p, PSMC_RESET_DEV))
1044 continue;
1045 emptyq(&kbdcp(p)->aux);
1046 /* NOTE: Compaq Armada laptops require extra delay here. XXX */
1047 for (again = KBD_MAXWAIT; again > 0; --again) {
1048 DELAY(KBD_RESETDELAY*1000);
1049 c = read_aux_data_no_wait(p);
1050 if (c != -1)
1051 break;
1052 }
1053 if (verbose || bootverbose)
1054 log(LOG_DEBUG, "kbdc: RESET_AUX return code:%04x\n", c);
1055 if (c == PSM_ACK) /* aux dev is about to reset... */
1056 break;
1057 }
1058 if (retry < 0)
1059 return FALSE;
1060
1061 for (again = KBD_MAXWAIT; again > 0; --again) {
1062 /* wait awhile, well, quite looooooooooooong */
1063 DELAY(KBD_RESETDELAY*1000);
1064 c = read_aux_data_no_wait(p); /* RESET_DONE/RESET_FAIL */
1065 if (c != -1) /* wait again if the controller is not ready */
1066 break;
1067 }
1068 if (verbose || bootverbose)
1069 log(LOG_DEBUG, "kbdc: RESET_AUX status:%04x\n", c);
1070 if (c != PSM_RESET_DONE) /* reset status */
1071 return FALSE;
1072
1073 c = read_aux_data(p); /* device ID */
1074 if (verbose || bootverbose)
1075 log(LOG_DEBUG, "kbdc: RESET_AUX ID:%04x\n", c);
1076 /* NOTE: we could check the device ID now, but leave it later... */
1077 return TRUE;
1078 }
1079
1080 /* controller diagnostics and setup */
1081
1082 int
test_controller(KBDC p)1083 test_controller(KBDC p)
1084 {
1085 int retry = KBD_MAXRETRY;
1086 int again = KBD_MAXWAIT;
1087 int c = KBD_DIAG_FAIL;
1088
1089 while (retry-- > 0) {
1090 empty_both_buffers(p, 10);
1091 if (write_controller_command(p, KBDC_DIAGNOSE))
1092 break;
1093 }
1094 if (retry < 0)
1095 return FALSE;
1096
1097 emptyq(&kbdcp(p)->kbd);
1098 while (again-- > 0) {
1099 /* wait awhile */
1100 DELAY(KBD_RESETDELAY*1000);
1101 c = read_controller_data(p); /* DIAG_DONE/DIAG_FAIL */
1102 if (c != -1) /* wait again if the controller is not ready */
1103 break;
1104 }
1105 if (verbose || bootverbose)
1106 log(LOG_DEBUG, "kbdc: DIAGNOSE status:%04x\n", c);
1107 return (c == KBD_DIAG_DONE);
1108 }
1109
1110 int
test_kbd_port(KBDC p)1111 test_kbd_port(KBDC p)
1112 {
1113 int retry = KBD_MAXRETRY;
1114 int again = KBD_MAXWAIT;
1115 int c = -1;
1116
1117 while (retry-- > 0) {
1118 empty_both_buffers(p, 10);
1119 if (write_controller_command(p, KBDC_TEST_KBD_PORT))
1120 break;
1121 }
1122 if (retry < 0)
1123 return FALSE;
1124
1125 emptyq(&kbdcp(p)->kbd);
1126 while (again-- > 0) {
1127 c = read_controller_data(p);
1128 if (c != -1) /* try again if the controller is not ready */
1129 break;
1130 }
1131 if (verbose || bootverbose)
1132 log(LOG_DEBUG, "kbdc: TEST_KBD_PORT status:%04x\n", c);
1133 return c;
1134 }
1135
1136 int
test_aux_port(KBDC p)1137 test_aux_port(KBDC p)
1138 {
1139 int retry = KBD_MAXRETRY;
1140 int again = KBD_MAXWAIT;
1141 int c = -1;
1142
1143 while (retry-- > 0) {
1144 empty_both_buffers(p, 10);
1145 if (write_controller_command(p, KBDC_TEST_AUX_PORT))
1146 break;
1147 }
1148 if (retry < 0)
1149 return FALSE;
1150
1151 emptyq(&kbdcp(p)->kbd);
1152 while (again-- > 0) {
1153 c = read_controller_data(p);
1154 if (c != -1) /* try again if the controller is not ready */
1155 break;
1156 }
1157 if (verbose || bootverbose)
1158 log(LOG_DEBUG, "kbdc: TEST_AUX_PORT status:%04x\n", c);
1159 return c;
1160 }
1161
1162 int
kbdc_get_device_mask(KBDC p)1163 kbdc_get_device_mask(KBDC p)
1164 {
1165 return kbdcp(p)->command_mask;
1166 }
1167
1168 void
kbdc_set_device_mask(KBDC p,int mask)1169 kbdc_set_device_mask(KBDC p, int mask)
1170 {
1171 kbdcp(p)->command_mask =
1172 mask & (((kbdcp(p)->quirks & KBDC_QUIRK_KEEP_ACTIVATED)
1173 ? 0 : KBD_KBD_CONTROL_BITS) | KBD_AUX_CONTROL_BITS);
1174 }
1175
1176 int
get_controller_command_byte(KBDC p)1177 get_controller_command_byte(KBDC p)
1178 {
1179 if (kbdcp(p)->command_byte != -1)
1180 return kbdcp(p)->command_byte;
1181 if (!write_controller_command(p, KBDC_GET_COMMAND_BYTE))
1182 return -1;
1183 emptyq(&kbdcp(p)->kbd);
1184 kbdcp(p)->command_byte = read_controller_data(p);
1185 return kbdcp(p)->command_byte;
1186 }
1187
1188 int
set_controller_command_byte(KBDC p,int mask,int command)1189 set_controller_command_byte(KBDC p, int mask, int command)
1190 {
1191 if (get_controller_command_byte(p) == -1)
1192 return FALSE;
1193
1194 command = (kbdcp(p)->command_byte & ~mask) | (command & mask);
1195 if (command & KBD_DISABLE_KBD_PORT) {
1196 if (!write_controller_command(p, KBDC_DISABLE_KBD_PORT))
1197 return FALSE;
1198 }
1199 if (!write_controller_command(p, KBDC_SET_COMMAND_BYTE))
1200 return FALSE;
1201 if (!write_controller_data(p, command))
1202 return FALSE;
1203 kbdcp(p)->command_byte = command;
1204
1205 if (verbose)
1206 log(LOG_DEBUG, "kbdc: new command byte:%04x (set_controller...)\n",
1207 command);
1208
1209 return TRUE;
1210 }
1211
1212 /*
1213 * Rudimentary support for active PS/2 AUX port multiplexing.
1214 * Only write commands can be routed to a selected AUX port.
1215 * Source port of data processed by read commands is totally ignored.
1216 */
1217 static int
set_aux_mux_state(KBDC p,int enabled)1218 set_aux_mux_state(KBDC p, int enabled)
1219 {
1220 int command, version;
1221
1222 if (write_controller_command(p, KBDC_FORCE_AUX_OUTPUT) == 0 ||
1223 write_controller_data(p, 0xF0) == 0 ||
1224 read_controller_data(p) != 0xF0)
1225 return (-1);
1226
1227 if (write_controller_command(p, KBDC_FORCE_AUX_OUTPUT) == 0 ||
1228 write_controller_data(p, 0x56) == 0 ||
1229 read_controller_data(p) != 0x56)
1230 return (-1);
1231
1232 command = enabled ? 0xa4 : 0xa5;
1233 if (write_controller_command(p, KBDC_FORCE_AUX_OUTPUT) == 0 ||
1234 write_controller_data(p, command) == 0 ||
1235 (version = read_controller_data(p)) == command)
1236 return (-1);
1237
1238 return (version);
1239 }
1240
1241 int
set_active_aux_mux_port(KBDC p,int port)1242 set_active_aux_mux_port(KBDC p, int port)
1243 {
1244
1245 if (!aux_mux_is_enabled(p))
1246 return (FALSE);
1247
1248 if (port < 0 || port >= KBDC_AUX_MUX_NUM_PORTS)
1249 return (FALSE);
1250
1251 kbdcp(p)->aux_mux_port = port;
1252
1253 return (TRUE);
1254 }
1255
1256 /* Checks for active multiplexing support and enables it */
1257 int
enable_aux_mux(KBDC p)1258 enable_aux_mux(KBDC p)
1259 {
1260 int version;
1261
1262 version = set_aux_mux_state(p, TRUE);
1263 if (version >= 0) {
1264 kbdcp(p)->aux_mux_enabled = TRUE;
1265 set_active_aux_mux_port(p, 0);
1266 }
1267
1268 return (version);
1269 }
1270
1271 int
disable_aux_mux(KBDC p)1272 disable_aux_mux(KBDC p)
1273 {
1274
1275 kbdcp(p)->aux_mux_enabled = FALSE;
1276
1277 return (set_aux_mux_state(p, FALSE));
1278 }
1279
1280 int
aux_mux_is_enabled(KBDC p)1281 aux_mux_is_enabled(KBDC p)
1282 {
1283
1284 return (kbdcp(p)->aux_mux_enabled);
1285 }
1286