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