No empty .Rs/.Re

[netbsd-mini2440.git] / sys / arch / hp300 / dev / hil.c

/*      $NetBSD: hil.c,v 1.82 2008/06/13 09:41:15 cegger Exp $  */

/*
 * Copyright (c) 1990, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * the Systems Programming Group of the University of Utah Computer
 * Science Department.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * from: Utah $Hdr: hil.c 1.38 92/01/21$
 *
 *      @(#)hil.c       8.2 (Berkeley) 1/12/94
 */
/*
 * Copyright (c) 1988 University of Utah.
 *
 * This code is derived from software contributed to Berkeley by
 * the Systems Programming Group of the University of Utah Computer
 * Science Department.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * from: Utah $Hdr: hil.c 1.38 92/01/21$
 *
 *      @(#)hil.c       8.2 (Berkeley) 1/12/94
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: hil.c,v 1.82 2008/06/13 09:41:15 cegger Exp $");

#include "ite.h"
#include "rnd.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/kernel.h>
#include <sys/poll.h>
#include <sys/proc.h>
#include <sys/tty.h>
#include <sys/uio.h>
#include <sys/kauth.h>

#include <uvm/uvm_extern.h>

#if NRND > 0
#include <sys/rnd.h>
#endif

#include <hp300/dev/intiovar.h>

#include <hp300/dev/hilreg.h>
#include <hp300/dev/hilioctl.h>
#include <hp300/dev/hilvar.h>
#include <hp300/dev/itevar.h>
#include <hp300/dev/kbdmap.h>

#include <machine/bus.h>
#include <machine/cpu.h>

#include "ioconf.h"

static int      hilmatch(device_t, cfdata_t, void *);
static void     hilattach(device_t, device_t, void *);

CFATTACH_DECL_NEW(hil, sizeof(struct hil_softc),
    hilmatch, hilattach, NULL, NULL);

static struct   _hilbell default_bell = { BELLDUR, BELLFREQ };

#ifdef DEBUG
int     hildebug = 0;
#define HDB_FOLLOW      0x01
#define HDB_MMAP        0x02
#define HDB_MASK        0x04
#define HDB_CONFIG      0x08
#define HDB_KEYBOARD    0x10
#define HDB_IDMODULE    0x20
#define HDB_EVENTS      0x80
#endif

extern struct kbdmap kbd_map[];

/* symbolic sleep message strings */
static const char hilin[] = "hilin";

static dev_type_open(hilopen);
static dev_type_close(hilclose);
static dev_type_read(hilread);
static dev_type_ioctl(hilioctl);
static dev_type_poll(hilpoll);
static dev_type_kqfilter(hilkqfilter);

const struct cdevsw hil_cdevsw = {
        hilopen, hilclose, hilread, nullwrite, hilioctl,
        nostop, notty, hilpoll, nommap, hilkqfilter,
};

static void     hilattach_deferred(device_t);

static void     hilinfo(struct hil_softc *);
static void     hilconfig(struct hil_softc *);
static void     hilreset(struct hil_softc *);
static void     hilbeep(struct hil_softc *, const struct _hilbell *);
static int      hiliddev(struct hil_softc *);

static int      hilint(void *);
static void     hil_process_int(struct hil_softc *, uint8_t, uint8_t);
static void     hilevent(struct hil_softc *);
static void     hpuxhilevent(struct hil_softc *, struct hilloopdev *);

static int      hilqalloc(struct hil_softc *, struct hilqinfo *, struct proc *);
static int      hilqfree(struct hil_softc *, int, struct proc *);
static int      hilqmap(struct hil_softc *, int, int, struct lwp *);
static int      hilqunmap(struct hil_softc *, int, int, struct proc *);

#ifdef DEBUG
static void     printhilpollbuf(struct hil_softc *);
static void     printhilcmdbuf(struct hil_softc *);
static void     hilreport(struct hil_softc *);
#endif /* DEBUG */

static int
hilmatch(device_t parent, cfdata_t cf, void *aux)
{
        struct intio_attach_args *ia = aux;

        if (strcmp("hil", ia->ia_modname) != 0)
                return 0;

        return 1;
}

static void
hilattach(device_t parent, device_t self, void *aux)
{
        struct hil_softc *sc = device_private(self);
        struct intio_attach_args *ia = aux;
        int i;

        sc->sc_dev = self;
        aprint_normal("\n");

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                aprint_debug("hilsoftinit(%p, %p)\n", sc,
                    (void *)ia->ia_addr);
#endif
        /*
         * Initialize loop information
         */
        sc->sc_addr = (struct hil_dev *)ia->ia_addr;
        sc->sc_cmdending = false;
        sc->sc_actdev = sc->sc_cmddev = 0;
        sc->sc_cmddone = false;
        sc->sc_cmdbp = sc->sc_cmdbuf;
        sc->sc_pollbp = sc->sc_pollbuf;
        sc->sc_kbddev = 0;
        sc->sc_kbdflags = 0;
        /*
         * Clear all queues and device associations with queues
         */
        for (i = 0; i < NHILQ; i++) {
                sc->sc_queue[i].hq_eventqueue = NULL;
                sc->sc_queue[i].hq_procp = NULL;
                sc->sc_queue[i].hq_devmask = 0;
        }
        for (i = 0; i < NHILD; i++) {
                selinit(&sc->sc_device[i].hd_selr);
                sc->sc_device[i].hd_qmask = 0;
        }
        sc->sc_device[HILLOOPDEV].hd_flags = (HIL_ALIVE|HIL_PSEUDO);

        /*
         * Set up default keyboard language.  We always default
         * to US ASCII - it seems to work OK for non-recognized
         * keyboards.
         */

        sc->sc_kbdlang = KBD_DEFAULT;
#if NITE > 0
        {
                struct kbdmap *km;
                for (km = kbd_map; km->kbd_code; km++) {
                        if (km->kbd_code == KBD_US)
                                iteinstallkeymap(km);
                }
        }
#endif

        (void)intio_intr_establish(hilint, sc, ia->ia_ipl, IPL_TTY);

        config_interrupts(self, hilattach_deferred);
}

static void
hilattach_deferred(device_t self)
{
        struct hil_softc *sc = device_private(self);

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                aprint_debug("hilinit(%p, %p)\n", sc, sc->sc_addr);
#endif
        /*
         * Initialize hardware.
         * Reset the loop hardware, and collect keyboard/id info
         */
        hilreset(sc);
        hilinfo(sc);
        hilkbdenable(sc);
}

/* ARGSUSED */
static int
hilopen(dev_t dev, int flags, int mode, struct lwp *l)
{
        struct hil_softc *sc;
        struct hilloopdev *dptr;
        int s;
#ifdef DEBUG
        struct proc *p = l->l_proc;
#endif

        sc = device_lookup_private(&hil_cd, HILLOOP(dev));

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilopen(%d): loop %x device %x\n",
                    p->p_pid, HILLOOP(dev), HILUNIT(dev));
#endif

        if ((sc->sc_device[HILLOOPDEV].hd_flags & HIL_ALIVE) == 0)
                return ENXIO;

        dptr = &sc->sc_device[HILUNIT(dev)];
        if ((dptr->hd_flags & HIL_ALIVE) == 0)
                return ENODEV;

        /*
         * Pseudo-devices cannot be read, nothing more to do.
         */
        if (dptr->hd_flags & HIL_PSEUDO)
                return 0;

        /*
         * Open semantics:
         * 1.   Open devices have only one of HIL_READIN/HIL_QUEUEIN.
         * 2.   HPUX processes always get read syscall interface and
         *      must have exclusive use of the device.
         * 3.   BSD processes default to shared queue interface.
         *      Multiple processes can open the device.
         */
        if (dptr->hd_flags & HIL_READIN)
                return EBUSY;
        dptr->hd_flags |= HIL_QUEUEIN;
        if (flags & FNONBLOCK)
                dptr->hd_flags |= HIL_NOBLOCK;
        /*
         * It is safe to flush the read buffer as we are guaranteed
         * that no one else is using it.
         */
        if ((dptr->hd_flags & HIL_OPENED) == 0) {
                dptr->hd_flags |= HIL_OPENED;
                clalloc(&dptr->hd_queue, HILMAXCLIST, 0);
        }

        send_hil_cmd(sc->sc_addr, HIL_INTON, NULL, 0, NULL);
        /*
         * Opened the keyboard, put in raw mode.
         */
        s = splhil();
        if (HILUNIT(dev) == sc->sc_kbddev) {
                uint8_t mask = 0;
                send_hil_cmd(sc->sc_addr, HIL_WRITEKBDSADR, &mask, 1, NULL);
                sc->sc_kbdflags |= KBD_RAW;
#ifdef DEBUG
                if (hildebug & HDB_KEYBOARD)
                        printf("hilopen: keyboard %d raw\n", sc->sc_kbddev);
#endif
        }
        splx(s);
        return 0;
}

/* ARGSUSED */
static int
hilclose(dev_t dev, int flags, int mode, struct lwp *l)
{
        struct hil_softc *sc;
        struct hilloopdev *dptr;
        int i;
        char mask, lpctrl;
        int s;
        extern struct emul emul_netbsd;
#ifdef DEBUG
        struct proc *p = l->l_proc;
#endif

        sc = device_lookup_private(&hil_cd, HILLOOP(dev));

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilclose(%d): device %x\n", p->p_pid, HILUNIT(dev));
#endif

        dptr = &sc->sc_device[HILUNIT(dev)];
        if (HILUNIT(dev) && (dptr->hd_flags & HIL_PSEUDO))
                return 0;

        if (l && l->l_proc->p_emul == &emul_netbsd) {
                /*
                 * If this is the loop device,
                 * free up all queues belonging to this process.
                 */
                if (HILUNIT(dev) == 0) {
                        for (i = 0; i < NHILQ; i++)
                                if (sc->sc_queue[i].hq_procp == l->l_proc)
                                        (void) hilqfree(sc, i, l->l_proc);
                } else {
                        mask = ~hildevmask(HILUNIT(dev));
                        s = splhil();
                        for (i = 0; i < NHILQ; i++)
                                if (sc->sc_queue[i].hq_procp == l->l_proc) {
                                        dptr->hd_qmask &= ~hilqmask(i);
                                        sc->sc_queue[i].hq_devmask &= mask;
                                }
                        splx(s);
                }
        }
        /*
         * The read buffer can go away.
         */
        dptr->hd_flags &= ~(HIL_QUEUEIN|HIL_READIN|HIL_NOBLOCK|HIL_OPENED);
        clfree(&dptr->hd_queue);
        /*
         * Set keyboard back to cooked mode when closed.
         */
        s = splhil();
        if (HILUNIT(dev) && HILUNIT(dev) == sc->sc_kbddev) {
                mask = 1 << (sc->sc_kbddev - 1);
                send_hil_cmd(sc->sc_addr, HIL_WRITEKBDSADR, &mask, 1, NULL);
                sc->sc_kbdflags &= ~(KBD_RAW|KBD_AR1|KBD_AR2);
                /*
                 * XXX: We have had trouble with keyboards remaining raw
                 * after close due to the LPC_KBDCOOK bit getting cleared
                 * somewhere along the line.  Hence we check and reset
                 * LPCTRL if necessary.
                 */
                send_hil_cmd(sc->sc_addr, HIL_READLPCTRL, NULL, 0, &lpctrl);
                if ((lpctrl & LPC_KBDCOOK) == 0) {
                        printf("hilclose: bad LPCTRL %x, reset to %x\n",
                            lpctrl, lpctrl|LPC_KBDCOOK);
                        lpctrl |= LPC_KBDCOOK;
                        send_hil_cmd(sc->sc_addr, HIL_WRITELPCTRL,
                                        &lpctrl, 1, NULL);
                }
#ifdef DEBUG
                if (hildebug & HDB_KEYBOARD)
                        printf("hilclose: keyboard %d cooked\n",
                            sc->sc_kbddev);
#endif
                hilkbdenable(sc);
        }
        splx(s);
        return 0;
}

/*
 * Read interface to HIL device.
 */
/* ARGSUSED */
static int
hilread(dev_t dev, struct uio *uio, int flag)
{
        struct hil_softc *sc;
        struct hilloopdev *dptr;
        int cc;
        uint8_t buf[HILBUFSIZE];
        int error, s;

        sc = device_lookup_private(&hil_cd, HILLOOP(dev));

#if 0
        /*
         * XXX: Don't do this since HP-UX doesn't.
         *
         * Check device number.
         * This check is necessary since loop can reconfigure.
         */
        if (HILUNIT(dev) > sc->sc_maxdev)
                return ENODEV;
#endif

        dptr = &sc->sc_device[HILUNIT(dev)];
        if ((dptr->hd_flags & HIL_READIN) == 0)
                return ENODEV;

        s = splhil();
        while (dptr->hd_queue.c_cc == 0) {
                if (dptr->hd_flags & HIL_NOBLOCK) {
                        spl0();
                        return EWOULDBLOCK;
                }
                dptr->hd_flags |= HIL_ASLEEP;
                if ((error = tsleep((void *)dptr,
                    TTIPRI | PCATCH, hilin, 0))) {
                        (void)spl0();
                        return error;
                }
        }
        splx(s);

        error = 0;
        while (uio->uio_resid > 0 && error == 0) {
                cc = q_to_b(&dptr->hd_queue, buf,
                    min(uio->uio_resid, HILBUFSIZE));
                if (cc <= 0)
                        break;
                error = uiomove(buf, cc, uio);
        }
        return error;
}

static int
hilioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
        struct hil_softc *sc;
        struct hilloopdev *dptr;
        uint8_t *buf;
        int i;
        uint8_t hold;
        int error;

        sc = device_lookup_private(&hil_cd, HILLOOP(dev));

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilioctl(%d): dev %x cmd %lx\n",
                    l->l_proc->p_pid, HILUNIT(dev), cmd);
#endif

        dptr = &sc->sc_device[HILUNIT(dev)];
        if ((dptr->hd_flags & HIL_ALIVE) == 0)
                return ENODEV;

        /*
         * Don't allow hardware ioctls on virtual devices.
         * Note that though these are the BSD names, they have the same
         * values as the HP-UX equivalents so we catch them as well.
         */
        if (dptr->hd_flags & HIL_PSEUDO) {
                switch (cmd) {
                case HILIOCSC:
                case HILIOCID:
                case OHILIOCID:
                case HILIOCRN:
                case HILIOCRS:
                case HILIOCED:
                        return ENODEV;

                /*
                 * XXX: should also return ENODEV but HP-UX compat
                 * breaks if we do.  They work ok right now because
                 * we only recognize one keyboard on the loop.  This
                 * will have to change if we remove that restriction.
                 */
                case HILIOCAROFF:
                case HILIOCAR1:
                case HILIOCAR2:
                        break;

                default:
                        break;
                }
        }

        sc->sc_cmdbp = sc->sc_cmdbuf;
        memset((void *)sc->sc_cmdbuf, 0, HILBUFSIZE);
        sc->sc_cmddev = HILUNIT(dev);
        error = 0;
        switch (cmd) {

        case HILIOCSBP:
                /* Send four data bytes to the tone gererator. */
                send_hil_cmd(sc->sc_addr, HIL_STARTCMD, data, 4, NULL);
                /* Send the trigger beeper command to the 8042. */
                send_hil_cmd(sc->sc_addr, (cmd & 0xFF), NULL, 0, NULL);
                break;

        case OHILIOCRRT:
        case HILIOCRRT:
                /* Transfer the real time to the 8042 data buffer */
                send_hil_cmd(sc->sc_addr, (cmd & 0xFF), NULL, 0, NULL);
                /* Read each byte of the real time */
                buf = data;
                for (i = 0; i < 5; i++) {
                        send_hil_cmd(sc->sc_addr, HIL_READTIME + i, NULL,
                                        0, &hold);
                        buf[4 - i] = hold;
                }
                break;

        case HILIOCRT:
                buf = data;
                for (i = 0; i < 4; i++) {
                        send_hil_cmd(sc->sc_addr, (cmd & 0xFF) + i,
                                        NULL, 0, &hold);
                        buf[i] = hold;
                }
                break;

        case HILIOCID:
        case OHILIOCID:
        case HILIOCSC:
        case HILIOCRN:
        case HILIOCRS:
        case HILIOCED:
                send_hildev_cmd(sc, HILUNIT(dev), (cmd & 0xFF));
                memcpy(data, sc->sc_cmdbuf, sc->sc_cmdbp - sc->sc_cmdbuf);
                break;

        case HILIOCAROFF:
        case HILIOCAR1:
        case HILIOCAR2:
                if (sc->sc_kbddev) {
                        sc->sc_cmddev = sc->sc_kbddev;
                        send_hildev_cmd(sc, sc->sc_kbddev, (cmd & 0xFF));
                        sc->sc_kbdflags &= ~(KBD_AR1|KBD_AR2);
                        if (cmd == HILIOCAR1)
                                sc->sc_kbdflags |= KBD_AR1;
                        else if (cmd == HILIOCAR2)
                                sc->sc_kbdflags |= KBD_AR2;
                }
                break;

        case HILIOCBEEP:
                hilbeep(sc, (struct _hilbell *)data);
                break;

        case FIONBIO:
                dptr = &sc->sc_device[HILUNIT(dev)];
                if (*(int *)data)
                        dptr->hd_flags |= HIL_NOBLOCK;
                else
                        dptr->hd_flags &= ~HIL_NOBLOCK;
                break;

        /*
         * FIOASYNC must be present for FIONBIO above to work!
         * (See fcntl in kern_descrip.c).
         */
        case FIOASYNC:
                break;

        case HILIOCALLOCQ:
                error = hilqalloc(sc, (struct hilqinfo *)data, l->l_proc);
                break;

        case HILIOCFREEQ:
                error = hilqfree(sc, ((struct hilqinfo *)data)->qid, l->l_proc);
                break;

        case HILIOCMAPQ:
                error = hilqmap(sc, *(int *)data, HILUNIT(dev), l);
                break;

        case HILIOCUNMAPQ:
                error = hilqunmap(sc, *(int *)data, HILUNIT(dev), l->l_proc);
                break;

        case HILIOCHPUX:
                dptr = &sc->sc_device[HILUNIT(dev)];
                dptr->hd_flags |= HIL_READIN;
                dptr->hd_flags &= ~HIL_QUEUEIN;
                break;

        case HILIOCRESET:
                hilreset(sc);
                break;

#ifdef DEBUG
        case HILIOCTEST:
                hildebug = *(int *)data;
                break;
#endif

        default:
                error = EINVAL;
                break;

        }
        sc->sc_cmddev = 0;
        return error;
}

/*ARGSUSED*/
static int
hilpoll(dev_t dev, int events, struct lwp *l)
{
        struct hil_softc *sc;
        struct hilloopdev *dptr;
        struct hiliqueue *qp;
        int mask;
        int s, revents;

        sc = device_lookup_private(&hil_cd, HILLOOP(dev));

        revents = events & (POLLOUT | POLLWRNORM);

        /* Attempt to save some work. */
        if ((events & (POLLIN | POLLRDNORM)) == 0)
                return revents;

        /*
         * Read interface.
         * Return 1 if there is something in the queue, 0 ow.
         */
        dptr = &sc->sc_device[HILUNIT(dev)];
        if (dptr->hd_flags & HIL_READIN) {
                s = splhil();
                if (dptr->hd_queue.c_cc > 0)
                        revents |= events & (POLLIN | POLLRDNORM);
                else
                        selrecord(l, &dptr->hd_selr);
                splx(s);
                return revents;
        }

        /*
         * Make sure device is alive and real (or the loop device).
         * Note that we do not do this for the read interface.
         * This is primarily to be consistant with HP-UX.
         */
        if (HILUNIT(dev) &&
            (dptr->hd_flags & (HIL_ALIVE|HIL_PSEUDO)) != HIL_ALIVE)
                return revents | (events & (POLLIN | POLLRDNORM));

        /*
         * Select on loop device is special.
         * Check to see if there are any data for any loop device
         * provided it is associated with a queue belonging to this user.
         */
        if (HILUNIT(dev) == 0)
                mask = -1;
        else
                mask = hildevmask(HILUNIT(dev));
        /*
         * Must check everybody with interrupts blocked to prevent races.
         */
        s = splhil();
        for (qp = sc->sc_queue; qp < &sc->sc_queue[NHILQ]; qp++)
                if (qp->hq_procp == l->l_proc && (mask & qp->hq_devmask) &&
                    qp->hq_eventqueue->hil_evqueue.head !=
                    qp->hq_eventqueue->hil_evqueue.tail) {
                        splx(s);
                        return revents | (events & (POLLIN | POLLRDNORM));
                }

        selrecord(l, &dptr->hd_selr);
        splx(s);
        return revents;
}

static void
filt_hilrdetach(struct knote *kn)
{
        dev_t dev = (intptr_t) kn->kn_hook;
        struct hil_softc *sc = device_lookup_private(&hil_cd,HILLOOP(dev));
        struct hilloopdev *dptr = &sc->sc_device[HILUNIT(dev)];
        int s;

        s = splhil();
        SLIST_REMOVE(&dptr->hd_selr.sel_klist, kn, knote, kn_selnext);
        splx(s);
}

static int
filt_hilread(struct knote *kn, long hint)
{
        dev_t dev = (intptr_t) kn->kn_hook;
        int device = HILUNIT(dev);
        struct hil_softc *sc = device_lookup_private(&hil_cd,HILLOOP(dev));
        struct hilloopdev *dptr = &sc->sc_device[device];
        struct hiliqueue *qp;
        int mask;

        if (dptr->hd_flags & HIL_READIN) {
                kn->kn_data = dptr->hd_queue.c_cc;
                return kn->kn_data > 0;
        }

        /*
         * Make sure device is alive and real (or the loop device).
         * Note that we do not do this for the read interface.
         * This is primarily to be consistant with HP-UX.
         */
        if (device && (dptr->hd_flags & (HIL_ALIVE|HIL_PSEUDO)) != HIL_ALIVE) {
                kn->kn_data = 0; /* XXXLUKEM (thorpej): what to put here? */
                return 1;
        }

        /*
         * Select on loop device is special.
         * Check to see if there are any data for any loop device
         * provided it is associated with a queue belonging to this user.
         */
        if (device == 0)
                mask = -1;
        else
                mask = hildevmask(device);
        /*
         * Must check everybody with interrupts blocked to prevent races.
         * (Interrupts are already blocked.)
         */
        for (qp = sc->sc_queue; qp < &sc->sc_queue[NHILQ]; qp++) {
                /* XXXLUKEM (thorpej): PROCESS CHECK! */
                if (/*qp->hq_procp == l->l_proc &&*/ (mask & qp->hq_devmask) &&
                    qp->hq_eventqueue->hil_evqueue.head !=
                    qp->hq_eventqueue->hil_evqueue.tail) {
                        /* XXXLUKEM (thorpej): what to put here? */
                        kn->kn_data = 0;
                        return 1;
                }
        }

        return 0;
}

static const struct filterops hilread_filtops =
        { 1, NULL, filt_hilrdetach, filt_hilread };

static const struct filterops hil_seltrue_filtops =
        { 1, NULL, filt_hilrdetach, filt_seltrue };

static int
hilkqfilter(dev_t dev, struct knote *kn)
{
        struct hil_softc *sc = device_lookup_private(&hil_cd,HILLOOP(dev));
        struct hilloopdev *dptr = &sc->sc_device[HILUNIT(dev)];
        struct klist *klist;
        int s;

        switch (kn->kn_filter) {
        case EVFILT_READ:
                klist = &dptr->hd_selr.sel_klist;
                kn->kn_fop = &hilread_filtops;
                break;

        case EVFILT_WRITE:
                klist = &dptr->hd_selr.sel_klist;
                kn->kn_fop = &hil_seltrue_filtops;
                break;

        default:
                return 1;
        }

        kn->kn_hook = (void *)(intptr_t) dev; /* XXX yuck */

        s = splhil();
        SLIST_INSERT_HEAD(klist, kn, kn_selnext);
        splx(s);

        return 0;
}

/*ARGSUSED*/
static int
hilint(void *v)
{
        struct hil_softc *sc = v;
        struct hil_dev *hildevice = sc->sc_addr;
        uint8_t c, stat;

        stat = READHILSTAT(hildevice);
        c = READHILDATA(hildevice);             /* clears interrupt */
        hil_process_int(sc, stat, c);
#if NRND > 0
        rnd_add_uint32(&sc->rnd_source, (stat<<8)|c);
#endif
        return 1;
}

static void
hil_process_int(struct hil_softc *sc, uint8_t stat, uint8_t c)
{
#ifdef DEBUG
        if (hildebug & HDB_EVENTS)
                printf("hilint: %x %x\n", stat, c);
#endif

        /* the shift enables the compiler to generate a jump table */
        switch ((stat>>HIL_SSHIFT) & HIL_SMASK) {

#if NITE > 0
        case HIL_KEY:
        case HIL_SHIFT:
        case HIL_CTRL:
        case HIL_CTRLSHIFT:
                itefilter(stat, c);
                return;
#endif

        case HIL_STATUS:                        /* The status info. */
                if (c & HIL_ERROR) {
                        sc->sc_cmddone = true;
                        if (c == HIL_RECONFIG)
                                hilconfig(sc);
                        break;
                }
                if (c & HIL_COMMAND) {
                        if (c & HIL_POLLDATA)   /* End of data */
                                hilevent(sc);
                        else                    /* End of command */
                                sc->sc_cmdending = true;
                        sc->sc_actdev = 0;
                } else {
                        if (c & HIL_POLLDATA) { /* Start of polled data */
                                if (sc->sc_actdev != 0)
                                        hilevent(sc);
                                sc->sc_actdev = (c & HIL_DEVMASK);
                                sc->sc_pollbp = sc->sc_pollbuf;
                        } else {                /* Start of command */
                                if (sc->sc_cmddev == (c & HIL_DEVMASK)) {
                                        sc->sc_cmdbp = sc->sc_cmdbuf;
                                        sc->sc_actdev = 0;
                                }
                        }
                }
                return;

        case HIL_DATA:
                if (sc->sc_actdev != 0) /* Collecting poll data */
                        *sc->sc_pollbp++ = c;
                else {
                        if (sc->sc_cmddev != 0) {  /* Collecting cmd data */
                                if (sc->sc_cmdending) {
                                        sc->sc_cmddone = true;
                                        sc->sc_cmdending = false;
                                } else
                                        *sc->sc_cmdbp++ = c;
                        }
                }
                return;

        case 0:         /* force full jump table */
        default:
                return;
        }

}

/*
 * Optimized macro to compute:
 *      eq->head == (eq->tail + 1) % eq->size
 * i.e. has tail caught up with head.  We do this because 32 bit long
 * remaidering is expensive (a function call with our compiler).
 */
#define HQFULL(eq)      (((eq)->head?(eq)->head:(eq)->size) == (eq)->tail+1)
#define HQVALID(eq) \
        ((eq)->size == HEVQSIZE && (eq)->tail >= 0 && (eq)->tail < HEVQSIZE)

static void
hilevent(struct hil_softc *sc)
{
        struct hilloopdev *dptr = &sc->sc_device[sc->sc_actdev];
        int len, mask, qnum;
        uint8_t *cp, *pp;
        HILQ *hq;
        struct timeval ourtime;
        hil_packet *proto;
        int len0;
        long tenths;

#ifdef DEBUG
        if (hildebug & HDB_EVENTS) {
                printf("hilevent: dev %d pollbuf: ", sc->sc_actdev);
                printhilpollbuf(sc);
                printf("\n");
        }
#endif

        /*
         * Note that HIL_READIN effectively "shuts off" any queues
         * that may have been in use at the time of an HILIOCHPUX call.
         */
        if (dptr->hd_flags & HIL_READIN) {
                hpuxhilevent(sc, dptr);
                return;
        }

        /*
         * If this device isn't on any queue or there are no data
         * in the packet (can this happen?) do nothing.
         */
        if (dptr->hd_qmask == 0 ||
            (len0 = sc->sc_pollbp - sc->sc_pollbuf) <= 0)
                return;

        /*
         * Everybody gets the same time stamp
         */
        microtime(&ourtime);
        tenths = (ourtime.tv_sec * 100) + (ourtime.tv_usec / 10000);

        proto = NULL;
        mask = dptr->hd_qmask;
        for (qnum = 0; mask; qnum++) {
                if ((mask & hilqmask(qnum)) == 0)
                        continue;
                mask &= ~hilqmask(qnum);
                hq = sc->sc_queue[qnum].hq_eventqueue;

                /*
                 * Ensure that queue fields that we rely on are valid
                 * and that there is space in the queue.  If either
                 * test fails, we just skip this queue.
                 */
                if (!HQVALID(&hq->hil_evqueue) || HQFULL(&hq->hil_evqueue))
                        continue;

                /*
                 * Copy data to queue.
                 * If this is the first queue we construct the packet
                 * with length, timestamp and poll buffer data.
                 * For second and successive packets we just duplicate
                 * the first packet.
                 */
                pp = (uint8_t *)&hq->hil_event[hq->hil_evqueue.tail];
                if (proto == NULL) {
                        proto = (hil_packet *)pp;
                        cp = sc->sc_pollbuf;
                        len = len0;
                        *pp++ = len + 6;
                        *pp++ = sc->sc_actdev;
                        *(long *)pp = tenths;
                        pp += sizeof(long);
                        do *pp++ = *cp++; while (--len);
                } else
                        *(hil_packet *)pp = *proto;

                if (++hq->hil_evqueue.tail == hq->hil_evqueue.size)
                        hq->hil_evqueue.tail = 0;
        }

        /*
         * Wake up anyone selecting on this device or the loop itself
         */
        selnotify(&dptr->hd_selr, 0, 0);
        dptr = &sc->sc_device[HILLOOPDEV];
        selnotify(&dptr->hd_selr, 0, 0);
}

#undef HQFULL

static void
hpuxhilevent(struct hil_softc *sc, struct hilloopdev *dptr)
{
        int len;
        struct timeval ourtime;
        long tstamp;

        /*
         * Everybody gets the same time stamp
         */
        microtime(&ourtime);
        tstamp = (ourtime.tv_sec * 100) + (ourtime.tv_usec / 10000);

        /*
         * Each packet that goes into the buffer must be preceded by the
         * number of bytes in the packet, and the timestamp of the packet.
         * This adds 5 bytes to the packet size. Make sure there is enough
         * room in the buffer for it, and if not, toss the packet.
         */
        len = sc->sc_pollbp - sc->sc_pollbuf;
        if (dptr->hd_queue.c_cc <= (HILMAXCLIST - (len + 5))) {
                putc(len+5, &dptr->hd_queue);
                (void)b_to_q((uint8_t *)&tstamp, sizeof tstamp,
                    &dptr->hd_queue);
                (void)b_to_q((uint8_t *)sc->sc_pollbuf, len, &dptr->hd_queue);
        }

        /*
         * Wake up any one blocked on a read or select
         */
        if (dptr->hd_flags & HIL_ASLEEP) {
                dptr->hd_flags &= ~HIL_ASLEEP;
                wakeup((void *)dptr);
        }
        selnotify(&dptr->hd_selr, 0, 0);
}

/*
 * Shared queue manipulation routines
 */

static int
hilqalloc(struct hil_softc *sc, struct hilqinfo *qip, struct proc *p)
{

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilqalloc(%d): addr %p\n", p->p_pid, qip->addr);
#endif
        return EINVAL;
}

static int
hilqfree(struct hil_softc *sc, int qnum, struct proc *p)
{

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilqfree(%d): qnum %d\n", p->p_pid, qnum);
#endif
        return EINVAL;
}

static int
hilqmap(struct hil_softc *sc, int qnum, int device, struct lwp *l)
{
        struct hilloopdev *dptr = &sc->sc_device[device];
        int s;

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilqmap(%d): qnum %d device %x\n",
                    l->l_proc->p_pid, qnum, device);
#endif
        if (qnum >= NHILQ || sc->sc_queue[qnum].hq_procp != l->l_proc)
                return EINVAL;
        if ((dptr->hd_flags & HIL_QUEUEIN) == 0)
                return EINVAL;
        if (dptr->hd_qmask && kauth_cred_geteuid(l->l_cred) &&
            kauth_cred_geteuid(l->l_cred) != dptr->hd_uid)
                return EPERM;

        sc->sc_queue[qnum].hq_devmask |= hildevmask(device);
        if (dptr->hd_qmask == 0)
                dptr->hd_uid = kauth_cred_geteuid(l->l_cred);
        s = splhil();
        dptr->hd_qmask |= hilqmask(qnum);
        splx(s);
#ifdef DEBUG
        if (hildebug & HDB_MASK)
                printf("hilqmap(%d): devmask %x qmask %x\n",
                    l->l_proc->p_pid, sc->sc_queue[qnum].hq_devmask,
                    dptr->hd_qmask);
#endif
        return 0;
}

static int
hilqunmap(struct hil_softc *sc, int qnum, int device, struct proc *p)
{
        int s;

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilqunmap(%d): qnum %d device %x\n",
                    p->p_pid, qnum, device);
#endif

        if (qnum >= NHILQ || sc->sc_queue[qnum].hq_procp != p)
                return EINVAL;

        sc->sc_queue[qnum].hq_devmask &= ~hildevmask(device);
        s = splhil();
        sc->sc_device[device].hd_qmask &= ~hilqmask(qnum);
        splx(s);
#ifdef DEBUG
        if (hildebug & HDB_MASK)
                printf("hilqunmap(%d): devmask %x qmask %x\n",
                    p->p_pid, sc->sc_queue[qnum].hq_devmask,
                    sc->sc_device[device].hd_qmask);
#endif
        return 0;
}

/*
 * Cooked keyboard functions for ite driver.
 * There is only one "cooked" ITE keyboard (the first keyboard found)
 * per loop.  There may be other keyboards, but they will always be "raw".
 */

void
hilkbdbell(void *v)
{
        hilbeep(v, &default_bell);
}

void
hilkbdenable(void *v)
{
        struct hil_softc *sc = v;
        struct hil_dev *hildevice = HILADDR;
        char db;

        if (sc != NULL)
                hildevice = sc->sc_addr;

        /* Set the autorepeat rate */
        db = ar_format(KBD_ARR);
        send_hil_cmd(hildevice, HIL_SETARR, &db, 1, NULL);

        /* Set the autorepeat delay */
        db = ar_format(KBD_ARD);
        send_hil_cmd(hildevice, HIL_SETARD, &db, 1, NULL);

        /* Enable interrupts */
        send_hil_cmd(hildevice, HIL_INTON, NULL, 0, NULL);
}

void
hilkbddisable(void *v)
{
}

#if NITE > 0
/*
 * The following chunk of code implements HIL console keyboard
 * support.
 */

static struct hil_dev *hilkbd_cn_device;
static struct ite_kbdmap hilkbd_cn_map;
static struct ite_kbdops hilkbd_cn_ops = {
        hilkbdcngetc,
        hilkbdenable,
        hilkbdbell,
        NULL,
};

extern char us_keymap[], us_shiftmap[], us_ctrlmap[];

/*
 * XXX: read keyboard directly and return code.
 * Used by console getchar routine.  Could really screw up anybody
 * reading from the keyboard in the normal, interrupt driven fashion.
 */
int
hilkbdcngetc(int *statp)
{
        int c, stat;
        int s;

        if (hilkbd_cn_device == NULL)
                return 0;

        /*
         * XXX needs to be splraise because we could be called
         * XXX at splhigh, e.g. in DDB.
         */
        s = splhil();
        while (((stat = READHILSTAT(hilkbd_cn_device)) & HIL_DATA_RDY) == 0)
                ;
        c = READHILDATA(hilkbd_cn_device);
        splx(s);
        *statp = stat;
        return c;
}

/*
 * Perform basic initialization of the HIL keyboard, suitable
 * for early console use.
 */
int
hilkbdcnattach(bus_space_tag_t bst, bus_addr_t addr)
{
        void *va;
        struct kbdmap *km;
        bus_space_handle_t bsh;
        u_char lang;

        if (bus_space_map(bst, addr, PAGE_SIZE, 0, &bsh))
                return 1;

        va = bus_space_vaddr(bst, bsh);
        hilkbd_cn_device = (struct hil_dev *)va;

        /* Default to US-ASCII keyboard. */
        hilkbd_cn_map.keymap = us_keymap;
        hilkbd_cn_map.shiftmap = us_shiftmap;
        hilkbd_cn_map.ctrlmap = us_ctrlmap;

        HILWAIT(hilkbd_cn_device);
        WRITEHILCMD(hilkbd_cn_device, HIL_SETARR);
        HILWAIT(hilkbd_cn_device);
        WRITEHILDATA(hilkbd_cn_device, ar_format(KBD_ARR));
        HILWAIT(hilkbd_cn_device);
        WRITEHILCMD(hilkbd_cn_device, HIL_READKBDLANG);
        HILDATAWAIT(hilkbd_cn_device);
        lang = READHILDATA(hilkbd_cn_device);
        for (km = kbd_map; km->kbd_code; km++) {
                if (km->kbd_code == lang) {
                        hilkbd_cn_map.keymap = km->kbd_keymap;
                        hilkbd_cn_map.shiftmap = km->kbd_shiftmap;
                        hilkbd_cn_map.ctrlmap = km->kbd_ctrlmap;
                }
        }
        HILWAIT(hilkbd_cn_device);
        WRITEHILCMD(hilkbd_cn_device, HIL_INTON);

        hilkbd_cn_ops.arg = NULL;
        itekbdcnattach(&hilkbd_cn_ops, &hilkbd_cn_map);

        return 0;
}

#endif /* End of HIL console keyboard code. */

/*
 * Recognize and clear keyboard generated NMIs.
 * Returns 1 if it was ours, 0 otherwise.  Note that we cannot use
 * send_hil_cmd() to issue the clear NMI command as that would actually
 * lower the priority to splvm() and it doesn't wait for the completion
 * of the command.  Either of these conditions could result in the
 * interrupt reoccuring.  Note that we issue the CNMT command twice.
 * This seems to be needed, once is not always enough!?!
 */
int
kbdnmi(void)
{
        struct hil_dev *hl_addr = HILADDR;

        if ((*KBDNMISTAT & KBDNMI) == 0)
                return 0;

        HILWAIT(hl_addr);
        WRITEHILCMD(hl_addr, HIL_CNMT);
        HILWAIT(hl_addr);
        WRITEHILCMD(hl_addr, HIL_CNMT);
        HILWAIT(hl_addr);
        return 1;
}

#define HILSECURITY     0x33
#define HILIDENTIFY     0x03
#define HILSCBIT        0x04

/*
 * Called at boot time to print out info about interesting devices
 */
void
hilinfo(struct hil_softc *sc)
{
        int id, len;
        struct kbdmap *km;

        /*
         * Keyboard info.
         */
        if (sc->sc_kbddev) {
                aprint_normal("%s device %d: ", device_xname(sc->sc_dev),
                    sc->sc_kbddev);
                for (km = kbd_map; km->kbd_code; km++)
                        if (km->kbd_code == sc->sc_kbdlang) {
                                aprint_normal("%s ", km->kbd_desc);
                                break;
                        }
                aprint_normal("keyboard\n");
        }
        /*
         * ID module.
         * Attempt to locate the first ID module and print out its
         * security code.  Is this a good idea??
         */
        id = hiliddev(sc);
        if (id) {
                sc->sc_cmdbp = sc->sc_cmdbuf;
                sc->sc_cmddev = id;
                send_hildev_cmd(sc, id, HILSECURITY);
                len = sc->sc_cmdbp - sc->sc_cmdbuf;
                sc->sc_cmdbp = sc->sc_cmdbuf;
                sc->sc_cmddev = 0;
                aprint_normal_dev(sc->sc_dev, "security code");
                for (id = 0; id < len; id++)
                        aprint_normal(" %x", sc->sc_cmdbuf[id]);
                while (id++ < 16)
                        aprint_normal(" 0");
                aprint_normal("\n");
        }
#if NRND > 0
        /*
         * attach the device into the random source list
         * except from ID module (no point)
         */
        if (!id) {
                char buf[10];
                sprintf(buf, "%s", device_xname(sc->sc_dev));
                rnd_attach_source(&sc->rnd_source, buf, RND_TYPE_TTY, 0);
        }
#endif
}

#define HILAR1  0x3E
#define HILAR2  0x3F

/*
 * Called after the loop has reconfigured.  Here we need to:
 *      - determine how many devices are on the loop
 *        (some may have been added or removed)
 *      - locate the ITE keyboard (if any) and ensure
 *        that it is in the proper state (raw or cooked)
 *        and is set to use the proper language mapping table
 *      - ensure all other keyboards are raw
 * Note that our device state is now potentially invalid as
 * devices may no longer be where they were.  What we should
 * do here is either track where the devices went and move
 * state around accordingly or, more simply, just mark all
 * devices as HIL_DERROR and don't allow any further use until
 * they are closed.  This is a little too brutal for my tastes,
 * we prefer to just assume people won't move things around.
 */
void
hilconfig(struct hil_softc *sc)
{
        u_char db;
        int s;

        s = splhil();
#ifdef DEBUG
        if (hildebug & HDB_CONFIG) {
                printf("hilconfig: reconfigured: ");
                send_hil_cmd(sc->sc_addr, HIL_READLPSTAT, NULL, 0, &db);
                printf("LPSTAT %x, ", db);
                send_hil_cmd(sc->sc_addr, HIL_READLPCTRL, NULL, 0, &db);
                printf("LPCTRL %x, ", db);
                send_hil_cmd(sc->sc_addr, HIL_READKBDSADR, NULL, 0, &db);
                printf("KBDSADR %x\n", db);
                hilreport(sc);
        }
#endif
        /*
         * Determine how many devices are on the loop.
         * Mark those as alive and real, all others as dead.
         */
        db = 0;
        send_hil_cmd(sc->sc_addr, HIL_READLPSTAT, NULL, 0, &db);
        sc->sc_maxdev = db & LPS_DEVMASK;
#ifdef DEBUG
        if (hildebug & HDB_CONFIG)
                printf("hilconfig: %d devices found\n", sc->sc_maxdev);
#endif
        for (db = 1; db < NHILD; db++) {
                if (db <= sc->sc_maxdev)
                        sc->sc_device[db].hd_flags |= HIL_ALIVE;
                else
                        sc->sc_device[db].hd_flags &= ~HIL_ALIVE;
                sc->sc_device[db].hd_flags &= ~HIL_PSEUDO;
        }
#ifdef DEBUG
        if (hildebug & (HDB_CONFIG|HDB_KEYBOARD))
                printf("hilconfig: max device %d\n", sc->sc_maxdev);
#endif
        if (sc->sc_maxdev == 0) {
                sc->sc_kbddev = 0;
                splx(s);
                return;
        }
        /*
         * Find out where the keyboards are and record the ITE keyboard
         * (first one found).  If no keyboards found, we are all done.
         */
        db = 0;
        send_hil_cmd(sc->sc_addr, HIL_READKBDSADR, NULL, 0, &db);
#ifdef DEBUG
        if (hildebug & HDB_KEYBOARD)
                printf("hilconfig: keyboard: KBDSADR %x, old %d, new %d\n",
                    db, sc->sc_kbddev, ffs((int)db));
#endif
        sc->sc_kbddev = ffs((int)db);
        if (sc->sc_kbddev == 0) {
                splx(s);
                return;
        }
        /*
         * Determine if the keyboard should be cooked or raw and configure it.
         */
        db = (sc->sc_kbdflags & KBD_RAW) ? 0 : 1 << (sc->sc_kbddev - 1);
        send_hil_cmd(sc->sc_addr, HIL_WRITEKBDSADR, &db, 1, NULL);
        /*
         * Re-enable autorepeat in raw mode, cooked mode AR is not affected.
         */
        if (sc->sc_kbdflags & (KBD_AR1|KBD_AR2)) {
                db = (sc->sc_kbdflags & KBD_AR1) ? HILAR1 : HILAR2;
                sc->sc_cmddev = sc->sc_kbddev;
                send_hildev_cmd(sc, sc->sc_kbddev, db);
                sc->sc_cmddev = 0;
        }
        /*
         * Determine the keyboard language configuration, but don't
         * override a user-specified setting.
         */
        db = 0;
        send_hil_cmd(sc->sc_addr, HIL_READKBDLANG, NULL, 0, &db);
#ifdef DEBUG
        if (hildebug & HDB_KEYBOARD)
                printf("hilconfig: language: old %x new %x\n",
                    sc->sc_kbdlang, db);
#endif
        if (sc->sc_kbdlang != KBD_SPECIAL) {
                struct kbdmap *km;

#if NITE > 0
                for (km = kbd_map; km->kbd_code; km++) {
                        if (km->kbd_code == db) {
                                sc->sc_kbdlang = db;
                                iteinstallkeymap(km);
                                break;
                        }
                }
#endif
                if (km->kbd_code == 0) {
                        printf("hilconfig: unknown keyboard type 0x%x, "
                            "using default\n", db);
                }
        }
        splx(s);
}

void
hilreset(struct hil_softc *sc)
{
        struct hil_dev *hildevice = sc->sc_addr;
        u_char db;

#ifdef DEBUG
        if (hildebug & HDB_FOLLOW)
                printf("hilreset(%p)\n", sc);
#endif
        /*
         * Initialize the loop: reconfigure, don't report errors,
         * cook keyboards, and enable autopolling.
         */
        db = LPC_RECONF | LPC_KBDCOOK | LPC_NOERROR | LPC_AUTOPOLL;
        send_hil_cmd(hildevice, HIL_WRITELPCTRL, &db, 1, NULL);
        /*
         * Delay one second for reconfiguration and then read the
         * data to clear the interrupt (if the loop reconfigured).
         */
        DELAY(1000000);
        if (READHILSTAT(hildevice) & HIL_DATA_RDY)
                db = READHILDATA(hildevice);
        /*
         * The HIL loop may have reconfigured.  If so we proceed on,
         * if not we loop until a successful reconfiguration is reported
         * back to us.  The HIL loop will continue to attempt forever.
         * Probably not very smart.
         */
        do {
                send_hil_cmd(hildevice, HIL_READLPSTAT, NULL, 0, &db);
        } while ((db & (LPS_CONFFAIL|LPS_CONFGOOD)) == 0);
        /*
         * At this point, the loop should have reconfigured.
         * The reconfiguration interrupt has already called hilconfig()
         * so the keyboard has been determined.
         */
        send_hil_cmd(hildevice, HIL_INTON, NULL, 0, NULL);
}

void
hilbeep(struct hil_softc *sc, const struct _hilbell *bp)
{
        struct hil_dev *hl_addr = HILADDR;
        u_char buf[2];

        if (sc != NULL)
                hl_addr = sc->sc_addr;

        buf[0] = ~((bp->duration - 10) / 10);
        buf[1] = bp->frequency;
        send_hil_cmd(hl_addr, HIL_SETTONE, buf, 2, NULL);
}

/*
 * Locate and return the address of the first ID module, 0 if none present.
 */
int
hiliddev(struct hil_softc *sc)
{
        int i, len;

#ifdef DEBUG
        if (hildebug & HDB_IDMODULE)
                printf("hiliddev(%p): max %d, looking for idmodule...",
                    sc, sc->sc_maxdev);
#endif
        for (i = 1; i <= sc->sc_maxdev; i++) {
                sc->sc_cmdbp = sc->sc_cmdbuf;
                sc->sc_cmddev = i;
                send_hildev_cmd(sc, i, HILIDENTIFY);
                /*
                 * XXX: the final condition checks to ensure that the
                 * device ID byte is in the range of the ID module (0x30-0x3F)
                 */
                len = sc->sc_cmdbp - sc->sc_cmdbuf;
                if (len > 1 && (sc->sc_cmdbuf[1] & HILSCBIT) &&
                    (sc->sc_cmdbuf[0] & 0xF0) == 0x30) {
                        sc->sc_cmdbp = sc->sc_cmdbuf;
                        sc->sc_cmddev = i;
                        send_hildev_cmd(sc, i, HILSECURITY);
                        break;
                }
        }
        sc->sc_cmdbp = sc->sc_cmdbuf;
        sc->sc_cmddev = 0;
#ifdef DEBUG
        if (hildebug & HDB_IDMODULE) {
                if (i <= sc->sc_maxdev)
                        printf("found at %d\n", i);
                else
                        printf("not found\n");
        }
#endif
        return i <= sc->sc_maxdev ? i : 0;
}

/*
 * Low level routines which actually talk to the 8042 chip.
 */

/*
 * Send a command to the 8042 with zero or more bytes of data.
 * If rdata is non-null, wait for and return a byte of data.
 * We run at splvm() to make the transaction as atomic as
 * possible without blocking the clock (is this necessary?)
 */
void
send_hil_cmd(struct hil_dev *hildevice, u_char cmd, u_char *data, u_char dlen,
    u_char *rdata)
{
        u_char status;
        int s = splvm();

        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, cmd);
        while (dlen--) {
                HILWAIT(hildevice);
                WRITEHILDATA(hildevice, *data++);
        }
        if (rdata) {
                do {
                        HILDATAWAIT(hildevice);
                        status = READHILSTAT(hildevice);
                        *rdata = READHILDATA(hildevice);
                } while (((status >> HIL_SSHIFT) & HIL_SMASK) != HIL_68K);
        }
        splx(s);
}

/*
 * Send a command to a device on the loop.
 * Since only one command can be active on the loop at any time,
 * we must ensure that we are not interrupted during this process.
 * Hence we mask interrupts to prevent potential access from most
 * interrupt routines and turn off auto-polling to disable the
 * internally generated poll commands.
 *
 * splhigh is extremely conservative but insures atomic operation,
 * splvm (clock only interrupts) seems to be good enough in practice.
 */
void
send_hildev_cmd(struct hil_softc *sc, char device, char cmd)
{
        struct hil_dev *hildevice = sc->sc_addr;
        uint8_t status, c;
        int s = splvm();

        polloff(hildevice);

        /*
         * Transfer the command and device info to the chip
         */
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_STARTCMD);
        HILWAIT(hildevice);
        WRITEHILDATA(hildevice, 8 + device);
        HILWAIT(hildevice);
        WRITEHILDATA(hildevice, cmd);
        HILWAIT(hildevice);
        WRITEHILDATA(hildevice, HIL_TIMEOUT);
        /*
         * Trigger the command and wait for completion
         */
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_TRIGGER);
        sc->sc_cmddone = false;
        do {
                HILDATAWAIT(hildevice);
                status = READHILSTAT(hildevice);
                c = READHILDATA(hildevice);
                hil_process_int(sc, status, c);
        } while (!sc->sc_cmddone);

        pollon(hildevice);
        splx(s);
}

/*
 * Turn auto-polling off and on.
 * Also disables and enable auto-repeat.  Why?
 */
void
polloff(struct hil_dev *hildevice)
{
        char db;

        /*
         * Turn off auto repeat
         */
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_SETARR);
        HILWAIT(hildevice);
        WRITEHILDATA(hildevice, 0);
        /*
         * Turn off auto-polling
         */
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_READLPCTRL);
        HILDATAWAIT(hildevice);
        db = READHILDATA(hildevice);
        db &= ~LPC_AUTOPOLL;
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_WRITELPCTRL);
        HILWAIT(hildevice);
        WRITEHILDATA(hildevice, db);
        /*
         * Must wait til polling is really stopped
         */
        do {
                HILWAIT(hildevice);
                WRITEHILCMD(hildevice, HIL_READBUSY);
                HILDATAWAIT(hildevice);
                db = READHILDATA(hildevice);
        } while (db & BSY_LOOPBUSY);
}

void
pollon(struct hil_dev *hildevice)
{
        char db;

        /*
         * Turn on auto polling
         */
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_READLPCTRL);
        HILDATAWAIT(hildevice);
        db = READHILDATA(hildevice);
        db |= LPC_AUTOPOLL;
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_WRITELPCTRL);
        HILWAIT(hildevice);
        WRITEHILDATA(hildevice, db);
        /*
         * Turn on auto repeat
         */
        HILWAIT(hildevice);
        WRITEHILCMD(hildevice, HIL_SETARR);
        HILWAIT(hildevice);
        WRITEHILDATA(hildevice, ar_format(KBD_ARR));
}

#ifdef DEBUG
static void
printhilpollbuf(struct hil_softc *sc)
{
        u_char *cp;
        int i, len;

        cp = sc->sc_pollbuf;
        len = sc->sc_pollbp - cp;
        for (i = 0; i < len; i++)
                printf("%x ", sc->sc_pollbuf[i]);
        printf("\n");
}

static void
printhilcmdbuf(struct hil_softc *sc)
{
        u_char *cp;
        int i, len;

        cp = sc->sc_cmdbuf;
        len = sc->sc_cmdbp - cp;
        for (i = 0; i < len; i++)
                printf("%x ", sc->sc_cmdbuf[i]);
        printf("\n");
}

static void
hilreport(struct hil_softc *sc)
{
        int i, len;
        int s = splhil();

        for (i = 1; i <= sc->sc_maxdev; i++) {
                sc->sc_cmdbp = sc->sc_cmdbuf;
                sc->sc_cmddev = i;
                send_hildev_cmd(sc, i, HILIDENTIFY);
                printf("hil%d: id: ", i);
                printhilcmdbuf(sc);
                len = sc->sc_cmdbp - sc->sc_cmdbuf;
                if (len > 1 && (sc->sc_cmdbuf[1] & HILSCBIT)) {
                        sc->sc_cmdbp = sc->sc_cmdbuf;
                        sc->sc_cmddev = i;
                        send_hildev_cmd(sc, i, HILSECURITY);
                        printf("hil%d: sc: ", i);
                        printhilcmdbuf(sc);
                }
        }
        sc->sc_cmdbp = sc->sc_cmdbuf;
        sc->sc_cmddev = 0;
        splx(s);
}
#endif