NetBSD/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/user.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