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