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