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