1 /*- 2 * Copyright (c) 1996-1999 3 * Kazutaka YOKOTA (yokota@zodiac.mech.utsunomiya-u.ac.jp) 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote 15 * products derived from this software without specific prior written 16 * permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 * $FreeBSD$ 31 * from kbdio.c,v 1.13 1998/09/25 11:55:46 yokota Exp 32 */ 33 34 #include "opt_kbd.h" 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/bus.h> 39 #include <sys/malloc.h> 40 #include <sys/syslog.h> 41 #include <machine/bus_pio.h> 42 #include <machine/bus.h> 43 #include <machine/resource.h> 44 #include <sys/rman.h> 45 46 47 #include <dev/kbd/atkbdcreg.h> 48 49 #include <isa/isareg.h> 50 51 /* constants */ 52 53 #define MAXKBDC 1 /* XXX */ 54 55 /* macros */ 56 57 #ifndef MAX 58 #define MAX(x, y) ((x) > (y) ? (x) : (y)) 59 #endif 60 61 #define kbdcp(p) ((atkbdc_softc_t *)(p)) 62 #define nextq(i) (((i) + 1) % KBDQ_BUFSIZE) 63 #define availq(q) ((q)->head != (q)->tail) 64 #if KBDIO_DEBUG >= 2 65 #define emptyq(q) ((q)->tail = (q)->head = (q)->qcount = 0) 66 #else 67 #define emptyq(q) ((q)->tail = (q)->head = 0) 68 #endif 69 70 #define read_data(k) (bus_space_read_1((k)->iot, (k)->ioh0, 0)) 71 #define read_status(k) (bus_space_read_1((k)->iot, (k)->ioh1, 0)) 72 #define write_data(k, d) \ 73 (bus_space_write_1((k)->iot, (k)->ioh0, 0, (d))) 74 #define write_command(k, d) \ 75 (bus_space_write_1((k)->iot, (k)->ioh1, 0, (d))) 76 77 /* local variables */ 78 79 /* 80 * We always need at least one copy of the kbdc_softc struct for the 81 * low-level console. As the low-level console accesses the keyboard 82 * controller before kbdc, and all other devices, is probed, we 83 * statically allocate one entry. XXX 84 */ 85 static atkbdc_softc_t default_kbdc; 86 static atkbdc_softc_t *atkbdc_softc[MAXKBDC] = { &default_kbdc }; 87 88 static int verbose = KBDIO_DEBUG; 89 90 /* function prototypes */ 91 92 static int atkbdc_setup(atkbdc_softc_t *sc, bus_space_tag_t tag, 93 bus_space_handle_t h0, bus_space_handle_t h1); 94 static int addq(kqueue *q, int c); 95 static int removeq(kqueue *q); 96 static int wait_while_controller_busy(atkbdc_softc_t *kbdc); 97 static int wait_for_data(atkbdc_softc_t *kbdc); 98 static int wait_for_kbd_data(atkbdc_softc_t *kbdc); 99 static int wait_for_kbd_ack(atkbdc_softc_t *kbdc); 100 static int wait_for_aux_data(atkbdc_softc_t *kbdc); 101 static int wait_for_aux_ack(atkbdc_softc_t *kbdc); 102 103 atkbdc_softc_t 104 *atkbdc_get_softc(int unit) 105 { 106 atkbdc_softc_t *sc; 107 108 if (unit >= sizeof(atkbdc_softc)/sizeof(atkbdc_softc[0])) 109 return NULL; 110 sc = atkbdc_softc[unit]; 111 if (sc == NULL) { 112 sc = atkbdc_softc[unit] 113 = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT | M_ZERO); 114 if (sc == NULL) 115 return NULL; 116 } 117 return sc; 118 } 119 120 int 121 atkbdc_probe_unit(int unit, struct resource *port0, struct resource *port1) 122 { 123 if (rman_get_start(port0) <= 0) 124 return ENXIO; 125 if (rman_get_start(port1) <= 0) 126 return ENXIO; 127 return 0; 128 } 129 130 int 131 atkbdc_attach_unit(int unit, atkbdc_softc_t *sc, struct resource *port0, 132 struct resource *port1) 133 { 134 return atkbdc_setup(sc, rman_get_bustag(port0), 135 rman_get_bushandle(port0), 136 rman_get_bushandle(port1)); 137 } 138 139 /* the backdoor to the keyboard controller! XXX */ 140 int 141 atkbdc_configure(void) 142 { 143 bus_space_tag_t tag; 144 bus_space_handle_t h0; 145 bus_space_handle_t h1; 146 int port0; 147 int port1; 148 149 port0 = IO_KBD; 150 resource_int_value("atkbdc", 0, "port", &port0); 151 port1 = IO_KBD + KBD_STATUS_PORT; 152 #if 0 153 resource_int_value("atkbdc", 0, "port", &port0); 154 #endif 155 156 /* XXX: tag should be passed from the caller */ 157 #if defined(__i386__) 158 tag = I386_BUS_SPACE_IO; 159 #elif defined(__alpha__) 160 tag = busspace_isa_io; 161 #elif defined(__ia64__) 162 tag = IA64_BUS_SPACE_IO; 163 #else 164 #error "define tag!" 165 #endif 166 167 #if notyet 168 bus_space_map(tag, port0, IO_KBDSIZE, 0, &h0); 169 bus_space_map(tag, port1, IO_KBDSIZE, 0, &h1); 170 #else 171 h0 = (bus_space_handle_t)port0; 172 h1 = (bus_space_handle_t)port1; 173 #endif 174 return atkbdc_setup(atkbdc_softc[0], tag, h0, h1); 175 } 176 177 static int 178 atkbdc_setup(atkbdc_softc_t *sc, bus_space_tag_t tag, bus_space_handle_t h0, 179 bus_space_handle_t h1) 180 { 181 if (sc->ioh0 == 0) { /* XXX */ 182 sc->command_byte = -1; 183 sc->command_mask = 0; 184 sc->lock = FALSE; 185 sc->kbd.head = sc->kbd.tail = 0; 186 sc->aux.head = sc->aux.tail = 0; 187 #if KBDIO_DEBUG >= 2 188 sc->kbd.call_count = 0; 189 sc->kbd.qcount = sc->kbd.max_qcount = 0; 190 sc->aux.call_count = 0; 191 sc->aux.qcount = sc->aux.max_qcount = 0; 192 #endif 193 } 194 sc->iot = tag; 195 sc->ioh0 = h0; 196 sc->ioh1 = h1; 197 return 0; 198 } 199 200 /* open a keyboard controller */ 201 KBDC 202 atkbdc_open(int unit) 203 { 204 if (unit <= 0) 205 unit = 0; 206 if (unit >= MAXKBDC) 207 return NULL; 208 if ((atkbdc_softc[unit]->port0 != NULL) 209 || (atkbdc_softc[unit]->ioh0 != 0)) /* XXX */ 210 return (KBDC)atkbdc_softc[unit]; 211 return NULL; 212 } 213 214 /* 215 * I/O access arbitration in `kbdio' 216 * 217 * The `kbdio' module uses a simplistic convention to arbitrate 218 * I/O access to the controller/keyboard/mouse. The convention requires 219 * close cooperation of the calling device driver. 220 * 221 * The device drivers which utilize the `kbdio' module are assumed to 222 * have the following set of routines. 223 * a. An interrupt handler (the bottom half of the driver). 224 * b. Timeout routines which may briefly poll the keyboard controller. 225 * c. Routines outside interrupt context (the top half of the driver). 226 * They should follow the rules below: 227 * 1. The interrupt handler may assume that it always has full access 228 * to the controller/keyboard/mouse. 229 * 2. The other routines must issue `spltty()' if they wish to 230 * prevent the interrupt handler from accessing 231 * the controller/keyboard/mouse. 232 * 3. The timeout routines and the top half routines of the device driver 233 * arbitrate I/O access by observing the lock flag in `kbdio'. 234 * The flag is manipulated via `kbdc_lock()'; when one wants to 235 * perform I/O, call `kbdc_lock(kbdc, TRUE)' and proceed only if 236 * the call returns with TRUE. Otherwise the caller must back off. 237 * Call `kbdc_lock(kbdc, FALSE)' when necessary I/O operaion 238 * is finished. This mechanism does not prevent the interrupt 239 * handler from being invoked at any time and carrying out I/O. 240 * Therefore, `spltty()' must be strategically placed in the device 241 * driver code. Also note that the timeout routine may interrupt 242 * `kbdc_lock()' called by the top half of the driver, but this 243 * interruption is OK so long as the timeout routine observes 244 * rule 4 below. 245 * 4. The interrupt and timeout routines should not extend I/O operation 246 * across more than one interrupt or timeout; they must complete any 247 * necessary I/O operation within one invocation of the routine. 248 * This means that if the timeout routine acquires the lock flag, 249 * it must reset the flag to FALSE before it returns. 250 */ 251 252 /* set/reset polling lock */ 253 int 254 kbdc_lock(KBDC p, int lock) 255 { 256 int prevlock; 257 258 prevlock = kbdcp(p)->lock; 259 kbdcp(p)->lock = lock; 260 261 return (prevlock != lock); 262 } 263 264 /* check if any data is waiting to be processed */ 265 int 266 kbdc_data_ready(KBDC p) 267 { 268 return (availq(&kbdcp(p)->kbd) || availq(&kbdcp(p)->aux) 269 || (read_status(kbdcp(p)) & KBDS_ANY_BUFFER_FULL)); 270 } 271 272 /* queuing functions */ 273 274 static int 275 addq(kqueue *q, int c) 276 { 277 if (nextq(q->tail) != q->head) { 278 q->q[q->tail] = c; 279 q->tail = nextq(q->tail); 280 #if KBDIO_DEBUG >= 2 281 ++q->call_count; 282 ++q->qcount; 283 if (q->qcount > q->max_qcount) 284 q->max_qcount = q->qcount; 285 #endif 286 return TRUE; 287 } 288 return FALSE; 289 } 290 291 static int 292 removeq(kqueue *q) 293 { 294 int c; 295 296 if (q->tail != q->head) { 297 c = q->q[q->head]; 298 q->head = nextq(q->head); 299 #if KBDIO_DEBUG >= 2 300 --q->qcount; 301 #endif 302 return c; 303 } 304 return -1; 305 } 306 307 /* 308 * device I/O routines 309 */ 310 static int 311 wait_while_controller_busy(struct atkbdc_softc *kbdc) 312 { 313 /* CPU will stay inside the loop for 100msec at most */ 314 int retry = 5000; 315 int f; 316 317 while ((f = read_status(kbdc)) & KBDS_INPUT_BUFFER_FULL) { 318 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 319 DELAY(KBDD_DELAYTIME); 320 addq(&kbdc->kbd, read_data(kbdc)); 321 } else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 322 DELAY(KBDD_DELAYTIME); 323 addq(&kbdc->aux, read_data(kbdc)); 324 } 325 DELAY(KBDC_DELAYTIME); 326 if (--retry < 0) 327 return FALSE; 328 } 329 return TRUE; 330 } 331 332 /* 333 * wait for any data; whether it's from the controller, 334 * the keyboard, or the aux device. 335 */ 336 static int 337 wait_for_data(struct atkbdc_softc *kbdc) 338 { 339 /* CPU will stay inside the loop for 200msec at most */ 340 int retry = 10000; 341 int f; 342 343 while ((f = read_status(kbdc) & KBDS_ANY_BUFFER_FULL) == 0) { 344 DELAY(KBDC_DELAYTIME); 345 if (--retry < 0) 346 return 0; 347 } 348 DELAY(KBDD_DELAYTIME); 349 return f; 350 } 351 352 /* wait for data from the keyboard */ 353 static int 354 wait_for_kbd_data(struct atkbdc_softc *kbdc) 355 { 356 /* CPU will stay inside the loop for 200msec at most */ 357 int retry = 10000; 358 int f; 359 360 while ((f = read_status(kbdc) & KBDS_BUFFER_FULL) 361 != KBDS_KBD_BUFFER_FULL) { 362 if (f == KBDS_AUX_BUFFER_FULL) { 363 DELAY(KBDD_DELAYTIME); 364 addq(&kbdc->aux, read_data(kbdc)); 365 } 366 DELAY(KBDC_DELAYTIME); 367 if (--retry < 0) 368 return 0; 369 } 370 DELAY(KBDD_DELAYTIME); 371 return f; 372 } 373 374 /* 375 * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the keyboard. 376 * queue anything else. 377 */ 378 static int 379 wait_for_kbd_ack(struct atkbdc_softc *kbdc) 380 { 381 /* CPU will stay inside the loop for 200msec at most */ 382 int retry = 10000; 383 int f; 384 int b; 385 386 while (retry-- > 0) { 387 if ((f = read_status(kbdc)) & KBDS_ANY_BUFFER_FULL) { 388 DELAY(KBDD_DELAYTIME); 389 b = read_data(kbdc); 390 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 391 if ((b == KBD_ACK) || (b == KBD_RESEND) 392 || (b == KBD_RESET_FAIL)) 393 return b; 394 addq(&kbdc->kbd, b); 395 } else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 396 addq(&kbdc->aux, b); 397 } 398 } 399 DELAY(KBDC_DELAYTIME); 400 } 401 return -1; 402 } 403 404 /* wait for data from the aux device */ 405 static int 406 wait_for_aux_data(struct atkbdc_softc *kbdc) 407 { 408 /* CPU will stay inside the loop for 200msec at most */ 409 int retry = 10000; 410 int f; 411 412 while ((f = read_status(kbdc) & KBDS_BUFFER_FULL) 413 != KBDS_AUX_BUFFER_FULL) { 414 if (f == KBDS_KBD_BUFFER_FULL) { 415 DELAY(KBDD_DELAYTIME); 416 addq(&kbdc->kbd, read_data(kbdc)); 417 } 418 DELAY(KBDC_DELAYTIME); 419 if (--retry < 0) 420 return 0; 421 } 422 DELAY(KBDD_DELAYTIME); 423 return f; 424 } 425 426 /* 427 * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the aux device. 428 * queue anything else. 429 */ 430 static int 431 wait_for_aux_ack(struct atkbdc_softc *kbdc) 432 { 433 /* CPU will stay inside the loop for 200msec at most */ 434 int retry = 10000; 435 int f; 436 int b; 437 438 while (retry-- > 0) { 439 if ((f = read_status(kbdc)) & KBDS_ANY_BUFFER_FULL) { 440 DELAY(KBDD_DELAYTIME); 441 b = read_data(kbdc); 442 if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 443 if ((b == PSM_ACK) || (b == PSM_RESEND) 444 || (b == PSM_RESET_FAIL)) 445 return b; 446 addq(&kbdc->aux, b); 447 } else if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 448 addq(&kbdc->kbd, b); 449 } 450 } 451 DELAY(KBDC_DELAYTIME); 452 } 453 return -1; 454 } 455 456 /* write a one byte command to the controller */ 457 int 458 write_controller_command(KBDC p, int c) 459 { 460 if (!wait_while_controller_busy(kbdcp(p))) 461 return FALSE; 462 write_command(kbdcp(p), c); 463 return TRUE; 464 } 465 466 /* write a one byte data to the controller */ 467 int 468 write_controller_data(KBDC p, int c) 469 { 470 if (!wait_while_controller_busy(kbdcp(p))) 471 return FALSE; 472 write_data(kbdcp(p), c); 473 return TRUE; 474 } 475 476 /* write a one byte keyboard command */ 477 int 478 write_kbd_command(KBDC p, int c) 479 { 480 if (!wait_while_controller_busy(kbdcp(p))) 481 return FALSE; 482 write_data(kbdcp(p), c); 483 return TRUE; 484 } 485 486 /* write a one byte auxiliary device command */ 487 int 488 write_aux_command(KBDC p, int c) 489 { 490 if (!write_controller_command(p, KBDC_WRITE_TO_AUX)) 491 return FALSE; 492 return write_controller_data(p, c); 493 } 494 495 /* send a command to the keyboard and wait for ACK */ 496 int 497 send_kbd_command(KBDC p, int c) 498 { 499 int retry = KBD_MAXRETRY; 500 int res = -1; 501 502 while (retry-- > 0) { 503 if (!write_kbd_command(p, c)) 504 continue; 505 res = wait_for_kbd_ack(kbdcp(p)); 506 if (res == KBD_ACK) 507 break; 508 } 509 return res; 510 } 511 512 /* send a command to the auxiliary device and wait for ACK */ 513 int 514 send_aux_command(KBDC p, int c) 515 { 516 int retry = KBD_MAXRETRY; 517 int res = -1; 518 519 while (retry-- > 0) { 520 if (!write_aux_command(p, c)) 521 continue; 522 /* 523 * FIXME: XXX 524 * The aux device may have already sent one or two bytes of 525 * status data, when a command is received. It will immediately 526 * stop data transmission, thus, leaving an incomplete data 527 * packet in our buffer. We have to discard any unprocessed 528 * data in order to remove such packets. Well, we may remove 529 * unprocessed, but necessary data byte as well... 530 */ 531 emptyq(&kbdcp(p)->aux); 532 res = wait_for_aux_ack(kbdcp(p)); 533 if (res == PSM_ACK) 534 break; 535 } 536 return res; 537 } 538 539 /* send a command and a data to the keyboard, wait for ACKs */ 540 int 541 send_kbd_command_and_data(KBDC p, int c, int d) 542 { 543 int retry; 544 int res = -1; 545 546 for (retry = KBD_MAXRETRY; retry > 0; --retry) { 547 if (!write_kbd_command(p, c)) 548 continue; 549 res = wait_for_kbd_ack(kbdcp(p)); 550 if (res == KBD_ACK) 551 break; 552 else if (res != KBD_RESEND) 553 return res; 554 } 555 if (retry <= 0) 556 return res; 557 558 for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) { 559 if (!write_kbd_command(p, d)) 560 continue; 561 res = wait_for_kbd_ack(kbdcp(p)); 562 if (res != KBD_RESEND) 563 break; 564 } 565 return res; 566 } 567 568 /* send a command and a data to the auxiliary device, wait for ACKs */ 569 int 570 send_aux_command_and_data(KBDC p, int c, int d) 571 { 572 int retry; 573 int res = -1; 574 575 for (retry = KBD_MAXRETRY; retry > 0; --retry) { 576 if (!write_aux_command(p, c)) 577 continue; 578 emptyq(&kbdcp(p)->aux); 579 res = wait_for_aux_ack(kbdcp(p)); 580 if (res == PSM_ACK) 581 break; 582 else if (res != PSM_RESEND) 583 return res; 584 } 585 if (retry <= 0) 586 return res; 587 588 for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) { 589 if (!write_aux_command(p, d)) 590 continue; 591 res = wait_for_aux_ack(kbdcp(p)); 592 if (res != PSM_RESEND) 593 break; 594 } 595 return res; 596 } 597 598 /* 599 * read one byte from any source; whether from the controller, 600 * the keyboard, or the aux device 601 */ 602 int 603 read_controller_data(KBDC p) 604 { 605 if (availq(&kbdcp(p)->kbd)) 606 return removeq(&kbdcp(p)->kbd); 607 if (availq(&kbdcp(p)->aux)) 608 return removeq(&kbdcp(p)->aux); 609 if (!wait_for_data(kbdcp(p))) 610 return -1; /* timeout */ 611 return read_data(kbdcp(p)); 612 } 613 614 #if KBDIO_DEBUG >= 2 615 static int call = 0; 616 #endif 617 618 /* read one byte from the keyboard */ 619 int 620 read_kbd_data(KBDC p) 621 { 622 #if KBDIO_DEBUG >= 2 623 if (++call > 2000) { 624 call = 0; 625 log(LOG_DEBUG, "kbdc: kbd q: %d calls, max %d chars, " 626 "aux q: %d calls, max %d chars\n", 627 kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount, 628 kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount); 629 } 630 #endif 631 632 if (availq(&kbdcp(p)->kbd)) 633 return removeq(&kbdcp(p)->kbd); 634 if (!wait_for_kbd_data(kbdcp(p))) 635 return -1; /* timeout */ 636 return read_data(kbdcp(p)); 637 } 638 639 /* read one byte from the keyboard, but return immediately if 640 * no data is waiting 641 */ 642 int 643 read_kbd_data_no_wait(KBDC p) 644 { 645 int f; 646 647 #if KBDIO_DEBUG >= 2 648 if (++call > 2000) { 649 call = 0; 650 log(LOG_DEBUG, "kbdc: kbd q: %d calls, max %d chars, " 651 "aux q: %d calls, max %d chars\n", 652 kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount, 653 kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount); 654 } 655 #endif 656 657 if (availq(&kbdcp(p)->kbd)) 658 return removeq(&kbdcp(p)->kbd); 659 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 660 if (f == KBDS_AUX_BUFFER_FULL) { 661 DELAY(KBDD_DELAYTIME); 662 addq(&kbdcp(p)->aux, read_data(kbdcp(p))); 663 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 664 } 665 if (f == KBDS_KBD_BUFFER_FULL) { 666 DELAY(KBDD_DELAYTIME); 667 return read_data(kbdcp(p)); 668 } 669 return -1; /* no data */ 670 } 671 672 /* read one byte from the aux device */ 673 int 674 read_aux_data(KBDC p) 675 { 676 if (availq(&kbdcp(p)->aux)) 677 return removeq(&kbdcp(p)->aux); 678 if (!wait_for_aux_data(kbdcp(p))) 679 return -1; /* timeout */ 680 return read_data(kbdcp(p)); 681 } 682 683 /* read one byte from the aux device, but return immediately if 684 * no data is waiting 685 */ 686 int 687 read_aux_data_no_wait(KBDC p) 688 { 689 int f; 690 691 if (availq(&kbdcp(p)->aux)) 692 return removeq(&kbdcp(p)->aux); 693 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 694 if (f == KBDS_KBD_BUFFER_FULL) { 695 DELAY(KBDD_DELAYTIME); 696 addq(&kbdcp(p)->kbd, read_data(kbdcp(p))); 697 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 698 } 699 if (f == KBDS_AUX_BUFFER_FULL) { 700 DELAY(KBDD_DELAYTIME); 701 return read_data(kbdcp(p)); 702 } 703 return -1; /* no data */ 704 } 705 706 /* discard data from the keyboard */ 707 void 708 empty_kbd_buffer(KBDC p, int wait) 709 { 710 int t; 711 int b; 712 int f; 713 #if KBDIO_DEBUG >= 2 714 int c1 = 0; 715 int c2 = 0; 716 #endif 717 int delta = 2; 718 719 for (t = wait; t > 0; ) { 720 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) { 721 DELAY(KBDD_DELAYTIME); 722 b = read_data(kbdcp(p)); 723 if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 724 addq(&kbdcp(p)->aux, b); 725 #if KBDIO_DEBUG >= 2 726 ++c2; 727 } else { 728 ++c1; 729 #endif 730 } 731 t = wait; 732 } else { 733 t -= delta; 734 } 735 DELAY(delta*1000); 736 } 737 #if KBDIO_DEBUG >= 2 738 if ((c1 > 0) || (c2 > 0)) 739 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_kbd_buffer)\n", c1, c2); 740 #endif 741 742 emptyq(&kbdcp(p)->kbd); 743 } 744 745 /* discard data from the aux device */ 746 void 747 empty_aux_buffer(KBDC p, int wait) 748 { 749 int t; 750 int b; 751 int f; 752 #if KBDIO_DEBUG >= 2 753 int c1 = 0; 754 int c2 = 0; 755 #endif 756 int delta = 2; 757 758 for (t = wait; t > 0; ) { 759 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) { 760 DELAY(KBDD_DELAYTIME); 761 b = read_data(kbdcp(p)); 762 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 763 addq(&kbdcp(p)->kbd, b); 764 #if KBDIO_DEBUG >= 2 765 ++c1; 766 } else { 767 ++c2; 768 #endif 769 } 770 t = wait; 771 } else { 772 t -= delta; 773 } 774 DELAY(delta*1000); 775 } 776 #if KBDIO_DEBUG >= 2 777 if ((c1 > 0) || (c2 > 0)) 778 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_aux_buffer)\n", c1, c2); 779 #endif 780 781 emptyq(&kbdcp(p)->aux); 782 } 783 784 /* discard any data from the keyboard or the aux device */ 785 void 786 empty_both_buffers(KBDC p, int wait) 787 { 788 int t; 789 int f; 790 #if KBDIO_DEBUG >= 2 791 int c1 = 0; 792 int c2 = 0; 793 #endif 794 int delta = 2; 795 796 for (t = wait; t > 0; ) { 797 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) { 798 DELAY(KBDD_DELAYTIME); 799 (void)read_data(kbdcp(p)); 800 #if KBDIO_DEBUG >= 2 801 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) 802 ++c1; 803 else 804 ++c2; 805 #endif 806 t = wait; 807 } else { 808 t -= delta; 809 } 810 DELAY(delta*1000); 811 } 812 #if KBDIO_DEBUG >= 2 813 if ((c1 > 0) || (c2 > 0)) 814 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_both_buffers)\n", c1, c2); 815 #endif 816 817 emptyq(&kbdcp(p)->kbd); 818 emptyq(&kbdcp(p)->aux); 819 } 820 821 /* keyboard and mouse device control */ 822 823 /* NOTE: enable the keyboard port but disable the keyboard 824 * interrupt before calling "reset_kbd()". 825 */ 826 int 827 reset_kbd(KBDC p) 828 { 829 int retry = KBD_MAXRETRY; 830 int again = KBD_MAXWAIT; 831 int c = KBD_RESEND; /* keep the compiler happy */ 832 833 while (retry-- > 0) { 834 empty_both_buffers(p, 10); 835 if (!write_kbd_command(p, KBDC_RESET_KBD)) 836 continue; 837 emptyq(&kbdcp(p)->kbd); 838 c = read_controller_data(p); 839 if (verbose || bootverbose) 840 log(LOG_DEBUG, "kbdc: RESET_KBD return code:%04x\n", c); 841 if (c == KBD_ACK) /* keyboard has agreed to reset itself... */ 842 break; 843 } 844 if (retry < 0) 845 return FALSE; 846 847 while (again-- > 0) { 848 /* wait awhile, well, in fact we must wait quite loooooooooooong */ 849 DELAY(KBD_RESETDELAY*1000); 850 c = read_controller_data(p); /* RESET_DONE/RESET_FAIL */ 851 if (c != -1) /* wait again if the controller is not ready */ 852 break; 853 } 854 if (verbose || bootverbose) 855 log(LOG_DEBUG, "kbdc: RESET_KBD status:%04x\n", c); 856 if (c != KBD_RESET_DONE) 857 return FALSE; 858 return TRUE; 859 } 860 861 /* NOTE: enable the aux port but disable the aux interrupt 862 * before calling `reset_aux_dev()'. 863 */ 864 int 865 reset_aux_dev(KBDC p) 866 { 867 int retry = KBD_MAXRETRY; 868 int again = KBD_MAXWAIT; 869 int c = PSM_RESEND; /* keep the compiler happy */ 870 871 while (retry-- > 0) { 872 empty_both_buffers(p, 10); 873 if (!write_aux_command(p, PSMC_RESET_DEV)) 874 continue; 875 emptyq(&kbdcp(p)->aux); 876 /* NOTE: Compaq Armada laptops require extra delay here. XXX */ 877 for (again = KBD_MAXWAIT; again > 0; --again) { 878 DELAY(KBD_RESETDELAY*1000); 879 c = read_aux_data_no_wait(p); 880 if (c != -1) 881 break; 882 } 883 if (verbose || bootverbose) 884 log(LOG_DEBUG, "kbdc: RESET_AUX return code:%04x\n", c); 885 if (c == PSM_ACK) /* aux dev is about to reset... */ 886 break; 887 } 888 if (retry < 0) 889 return FALSE; 890 891 for (again = KBD_MAXWAIT; again > 0; --again) { 892 /* wait awhile, well, quite looooooooooooong */ 893 DELAY(KBD_RESETDELAY*1000); 894 c = read_aux_data_no_wait(p); /* RESET_DONE/RESET_FAIL */ 895 if (c != -1) /* wait again if the controller is not ready */ 896 break; 897 } 898 if (verbose || bootverbose) 899 log(LOG_DEBUG, "kbdc: RESET_AUX status:%04x\n", c); 900 if (c != PSM_RESET_DONE) /* reset status */ 901 return FALSE; 902 903 c = read_aux_data(p); /* device ID */ 904 if (verbose || bootverbose) 905 log(LOG_DEBUG, "kbdc: RESET_AUX ID:%04x\n", c); 906 /* NOTE: we could check the device ID now, but leave it later... */ 907 return TRUE; 908 } 909 910 /* controller diagnostics and setup */ 911 912 int 913 test_controller(KBDC p) 914 { 915 int retry = KBD_MAXRETRY; 916 int again = KBD_MAXWAIT; 917 int c = KBD_DIAG_FAIL; 918 919 while (retry-- > 0) { 920 empty_both_buffers(p, 10); 921 if (write_controller_command(p, KBDC_DIAGNOSE)) 922 break; 923 } 924 if (retry < 0) 925 return FALSE; 926 927 emptyq(&kbdcp(p)->kbd); 928 while (again-- > 0) { 929 /* wait awhile */ 930 DELAY(KBD_RESETDELAY*1000); 931 c = read_controller_data(p); /* DIAG_DONE/DIAG_FAIL */ 932 if (c != -1) /* wait again if the controller is not ready */ 933 break; 934 } 935 if (verbose || bootverbose) 936 log(LOG_DEBUG, "kbdc: DIAGNOSE status:%04x\n", c); 937 return (c == KBD_DIAG_DONE); 938 } 939 940 int 941 test_kbd_port(KBDC p) 942 { 943 int retry = KBD_MAXRETRY; 944 int again = KBD_MAXWAIT; 945 int c = -1; 946 947 while (retry-- > 0) { 948 empty_both_buffers(p, 10); 949 if (write_controller_command(p, KBDC_TEST_KBD_PORT)) 950 break; 951 } 952 if (retry < 0) 953 return FALSE; 954 955 emptyq(&kbdcp(p)->kbd); 956 while (again-- > 0) { 957 c = read_controller_data(p); 958 if (c != -1) /* try again if the controller is not ready */ 959 break; 960 } 961 if (verbose || bootverbose) 962 log(LOG_DEBUG, "kbdc: TEST_KBD_PORT status:%04x\n", c); 963 return c; 964 } 965 966 int 967 test_aux_port(KBDC p) 968 { 969 int retry = KBD_MAXRETRY; 970 int again = KBD_MAXWAIT; 971 int c = -1; 972 973 while (retry-- > 0) { 974 empty_both_buffers(p, 10); 975 if (write_controller_command(p, KBDC_TEST_AUX_PORT)) 976 break; 977 } 978 if (retry < 0) 979 return FALSE; 980 981 emptyq(&kbdcp(p)->kbd); 982 while (again-- > 0) { 983 c = read_controller_data(p); 984 if (c != -1) /* try again if the controller is not ready */ 985 break; 986 } 987 if (verbose || bootverbose) 988 log(LOG_DEBUG, "kbdc: TEST_AUX_PORT status:%04x\n", c); 989 return c; 990 } 991 992 int 993 kbdc_get_device_mask(KBDC p) 994 { 995 return kbdcp(p)->command_mask; 996 } 997 998 void 999 kbdc_set_device_mask(KBDC p, int mask) 1000 { 1001 kbdcp(p)->command_mask = 1002 mask & (KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS); 1003 } 1004 1005 int 1006 get_controller_command_byte(KBDC p) 1007 { 1008 if (kbdcp(p)->command_byte != -1) 1009 return kbdcp(p)->command_byte; 1010 if (!write_controller_command(p, KBDC_GET_COMMAND_BYTE)) 1011 return -1; 1012 emptyq(&kbdcp(p)->kbd); 1013 kbdcp(p)->command_byte = read_controller_data(p); 1014 return kbdcp(p)->command_byte; 1015 } 1016 1017 int 1018 set_controller_command_byte(KBDC p, int mask, int command) 1019 { 1020 if (get_controller_command_byte(p) == -1) 1021 return FALSE; 1022 1023 command = (kbdcp(p)->command_byte & ~mask) | (command & mask); 1024 if (command & KBD_DISABLE_KBD_PORT) { 1025 if (!write_controller_command(p, KBDC_DISABLE_KBD_PORT)) 1026 return FALSE; 1027 } 1028 if (!write_controller_command(p, KBDC_SET_COMMAND_BYTE)) 1029 return FALSE; 1030 if (!write_controller_data(p, command)) 1031 return FALSE; 1032 kbdcp(p)->command_byte = command; 1033 1034 if (verbose) 1035 log(LOG_DEBUG, "kbdc: new command byte:%04x (set_controller...)\n", 1036 command); 1037 1038 return TRUE; 1039 } 1040