sys/dev/atkbdc/atkbdc.c

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