freebsd-nq/sys/i386/isa/psm.c

/*-
 * Copyright (c) 1992, 1993 Erik Forsberg.
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY ``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 I 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.
 *
 * $Id$
 */

/*
 *  Ported to 386bsd Oct 17, 1992
 *  Sandi Donno, Computer Science, University of Cape Town, South Africa
 *  Please send bug reports to sandi@cs.uct.ac.za
 *
 *  Thanks are also due to Rick Macklem, rick@snowhite.cis.uoguelph.ca -
 *  although I was only partially successful in getting the alpha release
 *  of his "driver for the Logitech and ATI Inport Bus mice for use with
 *  386bsd and the X386 port" to work with my Microsoft mouse, I nevertheless
 *  found his code to be an invaluable reference when porting this driver
 *  to 386bsd.
 *
 *  Further modifications for latest 386BSD+patchkit and port to NetBSD,
 *  Andrew Herbert <andrew@werple.apana.org.au> - 8 June 1993
 *
 *  Cloned from the Microsoft Bus Mouse driver, also by Erik Forsberg, by
 *  Andrew Herbert - 12 June 1993
 *
 *  Modified for PS/2 mouse by Charles Hannum <mycroft@ai.mit.edu>
 *  - 13 June 1993
 *
 *  Modified for PS/2 AUX mouse by Shoji Yuen <yuen@nuie.nagoya-u.ac.jp>
 *  - 24 October 1993
 *
 *  Hardware access routines and probe logic rewritten by
 *  Kazutaka Yokota <yokota@zodiac.mech.utsunomiya-u.ac.jp>
 *  - 3 October 1996. 
 *  - 14 October 1996.
 *  - 22 October 1996.
 *  - 28 October 1996. Start adding IOCTLs.
 *  - 12 November 1996. IOCTLs and rearranging `psmread', `psmioctl'...
 *  - 14 November 1996. Uses `kbdio.c'.
 */

#include "psm.h"

#if NPSM > 0

#include <limits.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/file.h>
#include <sys/proc.h>
#include <sys/conf.h>
#include <sys/syslog.h>
#ifdef DEVFS
#include <sys/devfsext.h>
#endif /*DEVFS*/

/*
#include <machine/mouse.h>
#include <machine/clock.h>
*/
#include <i386/include/mouse.h>
#include <i386/include/clock.h>

#include <i386/isa/isa.h>
#include <i386/isa/isa_device.h>
#include <i386/isa/kbdio.h>

/* driver specific options: the following options may be set by
   `options' statements in the kernel configuration file. */

/* debugging */
#ifndef PSM_DEBUG
#define PSM_DEBUG	2	/* controls debug logging: 
				   0: no logging, 1: brief, 2: verbose */
#endif

/* version dependency */
#define PSM_CURRENT		/* compiles for FreeBSD-current, if defined.
				   otherwise, compiles for FreeBSD 2.1.x. */

/* features */
/* #define PSM_NOCHECKSYNC	   the driver does not check the header data
				   byte, if defined */

#ifndef PSM_ACCEL
#define PSM_ACCEL	2	/* the default acceleration factor, must 
			           be one or greater; acceleration will be 
				   disabled if zero */
#endif

/* #define PSM_NOEMULATION	   disables protocol emulation */

/* end of driver specific options */

/* default values */
#define PSMD_DEFAULT_RESOLUTION	800	/* resolution: 800 ppi */
#define PSMD_DEFAULT_RATE	100	/* report rate: 100 Hz */

/* misc */
#define TRUE			(-1)
#define FALSE			0

/* some macros */

#define PSM_UNIT(dev)		(minor(dev) >> 1)
#define PSM_NBLOCKIO(dev)	(minor(dev) & 1)
#define PSM_MKMINOR(unit,block)	(((unit) << 1) | ((block) ? 0:1))

#ifndef max
#define max(x,y) 		((x) > (y) ? (x) : (y))
#endif
#ifndef min
#define min(x,y) 		((x) < (y) ? (x) : (y))
#endif

/* mouse status block */

typedef struct mousestatus {
	int button;		/* button status */
	int obutton;		/* previous button status */
	int dx;			/* x movement */
	int dy;			/* y movement */
} mousestatus_t;

/* ring buffer */

#define PSM_BUFSIZE		256

typedef struct ringbuf {
	int count;
	int head;
	int tail;
	mousestatus_t buf[PSM_BUFSIZE];
} ringbuf_t;

/* driver control block */

typedef int (*packetfunc_t) __P((unsigned char *,int *,int,mousestatus_t *));

static struct psm_softc {	/* Driver status information */
	struct selinfo rsel;	/* Process selecting for Input */
	unsigned char state;	/* Mouse driver state */
	int addr;		/* I/O port address */
	int command_byte;	/* controller command byte */
	mousehw_t hw;		/* hardware information */
	mousemode_t mode;	/* operation mode */
	ringbuf_t queue;	/* mouse status queue */
	packetfunc_t mkpacket;	/* func. to turn queued data 
				   into output format */
	char ipacket[MOUSE_PS2_PACKETSIZE];	/* interim input buffer */
	unsigned char opacket[PSM_BUFSIZE];	/* output buffer */
	int inputbytes;		/* # of bytes in the input buffer */
	int outputbytes;	/* # of bytes in the output buffer */
	int outputhead;		/* points the head of the output buffer */
	int button;		/* the latest button state */
#ifdef DEVFS
	void	*devfs_token;
	void	*n_devfs_token;
#endif
} psm_softc[NPSM];

/* driver state flags (state) */
#define PSM_VALID		0x80
#define PSM_OPEN		1	/* Device is open */
#define PSM_ASLP		2	/* Waiting for mouse data */

/* function prototypes */

static int psmprobe __P((struct isa_device *));
static int psmattach __P((struct isa_device *));
static int mkms __P((unsigned char *,int *,int,mousestatus_t *));
static int mkmsc __P((unsigned char *,int *,int,mousestatus_t *));
static int mkps2 __P((unsigned char *,int *,int,mousestatus_t *));

#ifdef PSM_CURRENT 
static d_open_t psmopen;
static d_close_t psmclose;
static d_read_t psmread;
static d_ioctl_t psmioctl;
static d_select_t psmselect;
#endif /* PSM_CURRENT */

/* device driver declarateion */

struct isa_driver psmdriver = { psmprobe, psmattach, "psm", FALSE };

#ifdef PSM_CURRENT 
#define CDEV_MAJOR		21

static	struct	cdevsw psm_cdevsw = {
	psmopen,	psmclose,	psmread,	nowrite,	/* 21 */
	psmioctl,	nostop, 	nullreset,	nodevtotty,
	psmselect,	nommap, 	NULL,		"psm",	NULL,	-1
};
#endif /* PSM_CURRENT */

/* debug message level */

extern int bootverbose;		/* `-v' option at `boot:' prompt */
static int verbose = PSM_DEBUG;

/* device I/O routines */

static int
enable_aux_dev(int port)
{
	int res;

	res = send_aux_command(port,PSMC_ENABLE_DEV);
	if (verbose >= 2)
	    log(LOG_DEBUG,"psm: ENABLE_DEV return code:%04x\n",res);

	return (res == PSM_ACK);
}

static int
disable_aux_dev(int port)
{
	int res;

	res = send_aux_command(port,PSMC_DISABLE_DEV);
	if (verbose >= 2)
	    log(LOG_DEBUG,"psm: DISABLE_DEV return code:%04x\n",res);

	return (res == PSM_ACK);
}

static int
get_mouse_status(int port,int *status)
{
	int res;

	empty_both_buffers(port);
	res = send_aux_command(port,PSMC_SEND_DEV_STATUS);
	if (verbose >= 2)
	    log(LOG_DEBUG,"psm: SEND_AUX_STATUS return code:%04x\n",res);
	if (res != PSM_ACK)
	    return FALSE;

	status[0] = read_aux_data(port);
	status[1] = read_aux_data(port);
	status[2] = read_aux_data(port);

	return TRUE;
}

static int
get_aux_id(int port)
{
	int retry;
	int id;
	int c;

	for(retry = KBD_MAXRETRY; retry > 0; --retry) {
	    empty_both_buffers(port);
	    write_aux_command(port,PSMC_SEND_DEV_ID);
	    /* 10ms delay */
	    DELAY(10000);
	    c = read_controller_data(port);
	    if (verbose >= 2)
	    	log(LOG_DEBUG,"psm: SEND_DEV_ID return code:%04x\n",c);
	    if (c == PSM_ACK)
		break;
	}
	if (retry <= 0)
	    return -1;

	id = read_aux_data(port);
	if (verbose >= 2)
	    log(LOG_DEBUG,"psm: device ID: %04x\n",id);

	return id;
}

static int
set_mouse_sampling_rate(int port,int rate)
{
	int res;

	res = send_aux_command_and_data(port,PSMC_SET_SAMPLING_RATE,rate);
	if (verbose >= 2)
	    log(LOG_DEBUG,"psm: SET_SAMPLING_RATE (%d) %04x\n",rate,res);

	return ((res == PSM_ACK) ? rate : -1);
}

static int
set_mouse_scaling(int port)
{
	int res;

	res = send_aux_command(port,PSMC_SET_SCALING11);
	if (verbose >= 2)
	    log(LOG_DEBUG,"psm: SET_SCALING11 return code:%04x\n",res);

	return (res == PSM_ACK);
}

static int
set_mouse_resolution(int port,int res)
{
	static struct {
	    int resolution;
	    int code;
	} rescode[] = {
	    {      25, PSMD_RESOLUTION_25 },
	    {      50, PSMD_RESOLUTION_50 },
	    {     100, PSMD_RESOLUTION_100 },
	    {     200, PSMD_RESOLUTION_200 },
	    {     400, PSMD_RESOLUTION_400 }, /* ?? */
	    {     800, PSMD_RESOLUTION_800 }, /* ?? */
	    { INT_MAX, PSMD_MAX_RESOLUTION },
	};
	int ret;
	int i;

	if (res <= 0)
	    return FALSE;
	for(i = 0; rescode[i].resolution > 0; ++i) {
	    if (rescode[i].resolution >= res) 
		break;
	}

	for(; i >= 0; --i) {
	    ret = send_aux_command_and_data(port,
			PSMC_SET_RESOLUTION,rescode[i].code);
	    if (verbose >= 2)
	        log(LOG_DEBUG,"psm: SET_RESOLUTION (%d) %04x\n",
		        rescode[i].code,ret);
	    if (ret == PSM_ACK)
		return rescode[i].resolution;
	}

	return (-1);
}

/* NOTE: once `set_mouse_mode()' is called, the mouse device must be
   re-enabled by calling `enable_aux_dev()' */
static int
set_mouse_mode(int port)
{
	int res;

	res = send_aux_command(port,PSMC_SET_STREAM_MODE);
	if (verbose >= 2)
	    log(LOG_DEBUG,"psm: SET_STREAM_MODE return code:%04x\n",res);

	return (res == PSM_ACK);
}

static int
get_mouse_buttons(int port)
{
	int c = 2;		/* assume two buttons by default */
	int status[3];

	/* NOTE: a special sequence to obtain Logitech-Mouse-specific
	   information: set resolution to 25 ppi, set scaling to 1:1,
	   set scaling to 1:1, set scaling to 1:1. Then the second
	   byte of the mouse status bytes is the number of available 
	   buttons. */
	if (!set_mouse_resolution(port,25))
	    return c;
	if (set_mouse_scaling(port) && set_mouse_scaling(port)
		&& set_mouse_scaling(port) && get_mouse_status(port,status)) {
	    if (verbose) {
	        log(LOG_DEBUG,"psm: status %02x %02x %02x (get_mouse_buttons)\n",
		    status[0],status[1],status[2]);
	    }
	    if (status[1] == 3)	
		return 3;
	}
	return c;
}

/* FIXME: someday, I will get the list of valid pointing devices and
   their IDs... */
static int
is_a_mouse(int id)
{
	static int valid_ids[] = {
		PSM_MOUSE_ID,		/* mouse */
		PSM_BALLPOINT_ID,	/* ballpoint device */
		-1			/* end of table */
	};
	/*
	int i;

	for(i = 0; valid_ids[i] >= 0; ++i) {
	    if (valid_ids[i] == id)
		return TRUE;
	}
	return FALSE;
	*/
	return TRUE;
}

static void
recover_from_error(int port)
{
	/* discard anything left in the output buffer */
	empty_both_buffers(port);

	/* NOTE: KBDC_RESET_KBD may not restore the communication between
	   the keyboard and the controller. */
	/* reset_kbd(port); */
	/* NOTE: somehow diagnostic and keyboard port test commands bring
	   the keyboard back. */
	test_controller(port);
	test_kbd_port(port);
}

static void
restore_controller(int port,int command_byte)
{
	set_controller_command_byte(port,command_byte,0);
}

/* psm driver entry points */

static int
psmprobe(struct isa_device *dvp)
{
	int unit = dvp->id_unit;
	int ioport = dvp->id_iobase;
	struct psm_softc *sc;
	int stat[3];
	int i;

	/* validate unit number */
	if (unit >= NPSM)
	    return (0);

	sc = &psm_softc[unit];
	sc->addr = ioport;
	if (bootverbose)
	    ++verbose;

	/* FIXME: the keyboard interrupt should be disabled while
	   probing a mouse? */

	/* NOTE: two bits in the command byte controls the operation of
	   the aux port (mouse port): the aux port disable bit (bit 5) and
	   the aux port interrupt (IRQ 12) enable bit (bit 2).
	   When this probe routine is called, there are following possibilities
	   about the presence of the aux port and the PS/2 mouse.

	   Case 1: aux port disabled (bit 5:1), aux int. disabled (bit 2:0)
	   The aux port most certainly exists. A device may or may not be
	   connected to the port. No driver is probably installed yet.

	   Case 2: aux port enabled (bit 5:0), aux int. disabled (bit 2:0)
	   Three possibile situations here:

	   Case 2a: 
	   The aux port does not exist, therefore, is not explicitly disabled.
	   Case 2b:
	   The aux port exists. A device and a driver may exist,
	   using the device in the polling(remote) mode.
	   Case 2c:
	   The aux port exists. A device may exist, but someone who knows
	   nothing about the aux port has set the command byte this way
	   (this is the case with `syscons').

	   Case 3: aux port disabled (bit 5:1), aux int. enabled (bit 2:1)
	   The aux port exists, but someone is controlloing the device and
	   temporalily disabled the port.

	   Case 4: aux port enabled (bit 5:0), aux int. enabled (bit 2:1)
	   The aux port exists, a device is attached to the port, and
	   someone is controlling the device. Some BIOS set the bits this
	   way after boot.

	   All in all, it is no use examing the bits for detecting
	   the presence of the port and the mouse device.
	*/

	/* save the current command byte; it will be used later */
	write_controller_command(ioport,KBDC_GET_COMMAND_BYTE);
	sc->command_byte = read_controller_data(ioport);
	if (verbose) {
	    printf("psm%d: current command byte:%04x\n",
		unit,sc->command_byte);
	}
	if (sc->command_byte == -1) {
	    printf("psm%d: unable to get the current command byte value.\n",
		unit);
	    return (0);
	}

	/* disable the keyboard port while probing the aux port, which
	   must be enabled during this routine */
	write_controller_command(ioport,KBDC_DISABLE_KBD_PORT);
	set_controller_command_byte(ioport,
		sc->command_byte 
			& ~(KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS),
		KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
			| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT);

	/* NOTE: `test_aux_port()' is designed to return with zero
	   if the aux port exists and is functioning. However, some
	   controllers appears to respond with zero even when the aux port
	   doesn't exist. (It may be that this is only the case when the
	   controller DOES have the aux port but the port is not wired
	   on the motherboard.) The keyboard controllers without the port,
	   such as the original AT, are supporsed to return with
	   an error code or simply time out. In any case, we have to
	   continue probing the port even when the controller passes 
	   this test.
	*/
	switch((i = test_aux_port(ioport))) {
	    case 0:	/* no error */
		break;
	    case -1: 	/* time out */
	    default: 	/* error */
		recover_from_error(ioport);
		restore_controller(ioport,sc->command_byte);
		if (verbose)
		    printf("psm%d: the aux port is not functioning (%d).\n",
			unit,i);
		if (bootverbose)
		    --verbose;
		return (0);
	}

	/* NOTE: some controllers appears to hang the `keyboard' when
	   the aux port doesn't exist and `PSMC_RESET_DEV' is issued. */
	if (!reset_aux_dev(ioport)) {
	    recover_from_error(ioport);
	    restore_controller(ioport,sc->command_byte);
	    if (verbose)
		printf("psm%d: failed to reset the aux device.\n",unit);
	    return (0);
	}

	/* both the aux port and the aux device is functioning, see
	   if the device can be enabled.
	   NOTE: when enabled, the device will start sending data;
	   we shall immediately disable the device once we know 
	   the device can be enabled. */
	if (!enable_aux_dev(ioport) || !disable_aux_dev(ioport)) {
	    restore_controller(ioport,sc->command_byte);
	    if (verbose)
		printf("psm%d: failed to enable the aux device.\n",unit);
	    if (bootverbose)
	    	--verbose;
	    return (0);
	}
	empty_both_buffers(ioport);	/* remove stray data if any */

	/* hardware information */
	sc->hw.iftype = MOUSE_IF_PS2;

	/* verify the device is a mouse */
	sc->hw.hwid = get_aux_id(ioport);
	if (!is_a_mouse(sc->hw.hwid)) {
	    restore_controller(ioport,sc->command_byte);
	    if (verbose)
		printf("psm%d: unknown device type (%d).\n",unit,sc->hw.hwid);
	    if (bootverbose)
	    	--verbose;
	    return (0);
	}
	switch (sc->hw.hwid) {
	    case PSM_BALLPOINT_ID:
		sc->hw.type = MOUSE_TRACKBALL;
		break;
	    case PSM_MOUSE_ID:
		sc->hw.type = MOUSE_MOUSE;
		break;
	    default:
		sc->hw.type = MOUSE_UNKNOWN;
		break;
	}

	/* # of buttons */
	sc->hw.buttons = get_mouse_buttons(ioport);

	/* set mouse parameters */
	/* FIXME: I don't know if these parameters are reasonable */
	/* FIXME: should we set them in `psmattach()' rather than here? */
	sc->mode.rate = set_mouse_sampling_rate(ioport,PSMD_DEFAULT_RATE);
	sc->mode.resolution = 
		set_mouse_resolution(ioport,PSMD_DEFAULT_RESOLUTION);
	set_mouse_scaling(ioport);			/* 1:1 scaling */
	set_mouse_mode(ioport);				/* stream mode */

	/* just check the status of the mouse */
	if (verbose) {
	    get_mouse_status(ioport,stat);
	    log(LOG_DEBUG,"psm%d: status %02x %02x %02x\n",
	        unit,stat[0],stat[1],stat[2]);
	}

	/* disable the aux port for now... */
	/* WARNING: we save the controller command byte and use it later
	   during `psmopen()' and `psmclose()'. This will be OK, so long
	   as the keyboard/console device driver won't change the command
	   byte in the course of its operation (this is the case with
	   `syscons'). If not,... */
	sc->command_byte &= ~KBD_AUX_CONTROL_BITS;
	set_controller_command_byte(ioport,sc->command_byte,
		KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT);

	/* done */
	return (IO_PSMSIZE);
}

static int
psmattach(struct isa_device *dvp)
{
	int unit = dvp->id_unit;
	struct psm_softc *sc = &psm_softc[unit];

	/* initial operation mode */
	sc->mode.accelfactor = PSM_ACCEL;
	sc->mode.protocol = MOUSE_PROTO_PS2;
	sc->mkpacket = mkps2;

	/* Setup initial state */
	sc->state = PSM_VALID;

	/* Done */
#ifdef	DEVFS
	sc->devfs_token = 
		devfs_add_devswf(&psm_cdevsw, PSM_MKMINOR(unit,TRUE), 
			DV_CHR, 0, 0, 0666, "psm%d", unit);
	sc->n_devfs_token = 
		devfs_add_devswf(&psm_cdevsw, PSM_MKMINOR(unit,FALSE), 
			DV_CHR,0, 0, 0666, "npsm%d", unit);
#endif

	printf("psm%d: device ID %d, %d buttons?\n",
		unit,sc->hw.hwid,sc->hw.buttons);

	if (bootverbose)
	    --verbose;

	return (1);
	/* return (0); XXX eh? usually 1 indicates success */
}

#ifdef PSM_CURRENT
static
#endif
int
psmopen(dev_t dev, int flag, int fmt, struct proc *p)
{
	int unit = PSM_UNIT(dev);
	int ioport;
	struct psm_softc *sc;
	int stat[3];

	/* Validate unit number */
	if (unit >= NPSM)
		return (ENXIO);

	/* Get device data */
	sc = &psm_softc[unit];
	if ((sc->state & PSM_VALID) == 0)
		return (ENXIO);
	ioport = sc->addr;

	/* Disallow multiple opens */
	if (sc->state & PSM_OPEN)
		return (EBUSY);

	/* Initialize state */
	sc->state |= PSM_OPEN;
	sc->rsel.si_flags = 0;
	sc->rsel.si_pid = 0;

	/* flush the event queue */
	sc->queue.count = 0;
	sc->queue.head = 0;
	sc->queue.tail = 0;
	sc->button = 0;

	/* empty input/output buffers */
	sc->inputbytes = 0;
	sc->outputbytes = 0;
	sc->outputhead = 0;

	/* enable the aux port and temporalily disable the keyboard */
	write_controller_command(ioport,KBDC_DISABLE_KBD_PORT);
	set_controller_command_byte(ioport,
		sc->command_byte & ~KBD_KBD_CONTROL_BITS,
		KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
			| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT);

	/* enable the mouse device */
	if (!enable_aux_dev(ioport)) {
	    set_controller_command_byte(ioport,sc->command_byte,
		KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT);
	    log(LOG_ERR,"psm%d: unable to enable the pointing device.\n",unit);
	    return (EIO);
	}

	if (verbose >= 2) {
	    get_mouse_status(ioport,stat);
	    log(LOG_DEBUG,"psm%d: status %02x %02x %02x\n",
	        unit,stat[0],stat[1],stat[2]);
	}

	/* enable the aux port and interrupt */
	set_controller_command_byte(ioport,sc->command_byte,
		KBD_ENABLE_AUX_PORT | KBD_ENABLE_AUX_INT);

	/* done */
	return (0);
}

#ifdef PSM_CURRENT
static
#endif
int
psmclose(dev_t dev, int flag, int fmt, struct proc *p)
{
	struct psm_softc *sc = &psm_softc[PSM_UNIT(dev)];
	int ioport = sc->addr;

	/* disable the aux interrupt */
	set_controller_command_byte(ioport,sc->command_byte,
		KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT);

	/* remove anything left in the output buffer */
	empty_aux_buffer(ioport);	

	/* disable the aux device, port and interrupt */
	disable_aux_dev(ioport);
	set_controller_command_byte(ioport,sc->command_byte,
		KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT);

	/* remove anything left in the output buffer */
	empty_aux_buffer(ioport);	

	/* Complete the close */
	sc->state &= ~PSM_OPEN;

	/* close is almost always successful */
	return (0);
}

static int
mkms(unsigned char *buf,int *len,int maxlen,register mousestatus_t *status)
{
	static int butmap[] = {
	    0, MOUSE_MSS_BUTTON3DOWN, MOUSE_MSS_BUTTON2DOWN,
	    MOUSE_MSS_BUTTON3DOWN | MOUSE_MSS_BUTTON2DOWN,
	    MOUSE_MSS_BUTTON1DOWN,
	    MOUSE_MSS_BUTTON3DOWN | MOUSE_MSS_BUTTON1DOWN,
	    MOUSE_MSS_BUTTON2DOWN | MOUSE_MSS_BUTTON1DOWN,
	    MOUSE_MSS_BUTTON3DOWN | MOUSE_MSS_BUTTON2DOWN | MOUSE_MSS_BUTTON1DOWN,
	};
	unsigned char delta;

	if (maxlen - *len < MOUSE_MSS_PACKETSIZE)
		return FALSE;

	buf[0] = MOUSE_MSS_SYNC;
	buf[0] |= butmap[status->button & BUTSTATMASK];

	if (status->dx < -128)
	    delta = 0x80;	/* -128 */
	else if (status->dx > 127)
	    delta = 0x7f;	/* 127 */
	else
	    delta = (unsigned char)status->dx;
	buf[0] |= (delta & 0xc0) >> 6;	/* bit 6-7 */
	buf[1] = delta & 0x3f;		/* bit 0-5 */

	if (status->dy < -128)
	    delta = 0x80;	/* -128 */
	else if (status->dy > 127)
	    delta = 0x7f;	/* 127 */
	else
	    delta = (unsigned char)status->dy;
	buf[0] |= (delta & 0xc0) >> 4;	/* bit 6-7 */
	buf[2] = delta & 0x3f;		/* bit 0-5 */

	*len += MOUSE_MSS_PACKETSIZE;

	return TRUE;
}

static int
mkmsc(unsigned char *buf,int *len,int maxlen,register mousestatus_t *status)
{
	static int butmap[] = {
	    0, MOUSE_MSC_BUTTON3UP, MOUSE_MSC_BUTTON2UP,
	    MOUSE_MSC_BUTTON3UP | MOUSE_MSC_BUTTON2UP,
	    MOUSE_MSC_BUTTON1UP,
	    MOUSE_MSC_BUTTON3UP | MOUSE_MSC_BUTTON1UP,
	    MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON1UP,
	    MOUSE_MSC_BUTTON3UP | MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON1UP,
	};
	unsigned char delta;

	if (maxlen - *len < MOUSE_PS2_PACKETSIZE)
		return FALSE;

	buf[0] = MOUSE_MSC_SYNC;
	buf[0] |= ~butmap[status->button & BUTSTATMASK] & MOUSE_MSC_BUTTONS;

	if (status->dx < -128)
	    delta = 0x80;	/* -128 */
	else if (status->dx > 127)
	    delta = 0x7f;	/* 127 */
	else
	    delta = (unsigned char)status->dx;
	buf[1] = delta >> 2;
	buf[3] = delta - buf[1];

	if (status->dy < -128)
	    delta = 0x80;	/* -128 */
	else if (status->dy > 127)
	    delta = 0x7f;	/* 127 */
	else
	    delta = (unsigned char)status->dy;
	buf[2] = delta >> 2;
	buf[4] = delta - buf[2];

	*len += MOUSE_MSC_PACKETSIZE;

	return TRUE;
}

static int
mkps2(unsigned char *buf,int *len,int maxlen,register mousestatus_t *status)
{
	static int butmap[] = {
	    0, MOUSE_PS2_BUTTON3DOWN, MOUSE_PS2_BUTTON2DOWN,
	    MOUSE_PS2_BUTTON3DOWN | MOUSE_PS2_BUTTON2DOWN,
	    MOUSE_PS2_BUTTON1DOWN,
	    MOUSE_PS2_BUTTON3DOWN | MOUSE_PS2_BUTTON1DOWN,
	    MOUSE_PS2_BUTTON2DOWN | MOUSE_PS2_BUTTON1DOWN,
	    MOUSE_PS2_BUTTON3DOWN | MOUSE_PS2_BUTTON2DOWN | MOUSE_PS2_BUTTON1DOWN,
	};
	register int delta;

	if (maxlen - *len < MOUSE_PS2_PACKETSIZE)
		return FALSE;

	buf[0] = MOUSE_PS2_SYNC;
	buf[0] |= butmap[status->button & BUTSTATMASK];

	if (status->dx < -128)
	    delta = -128;
	else if (status->dx > 127)
	    delta = 127;
	else
	    delta = status->dx;
	if (delta < 0) 
	    buf[0] |= MOUSE_PS2_XNEG;
	buf[1] = delta;

	if (status->dy < -128)
	    delta = -128;
	else if (status->dy > 127)
	    delta = 127;
	else
	    delta = status->dy;
	if (delta < 0)
	    buf[0] |= MOUSE_PS2_YNEG;
	buf[2] = delta;

	*len += MOUSE_PS2_PACKETSIZE;

	return TRUE;
}

#ifdef PSM_CURRENT
static
#endif
int
psmread(dev_t dev, struct uio *uio, int flag)
{
	register struct psm_softc *sc = &psm_softc[PSM_UNIT(dev)];
	unsigned int length;
	int error;
	int s;
	int i;

	/* block until mouse activity occured */
	s = spltty();
	if ((sc->outputbytes <= 0) && (sc->queue.count <= 0)) {
		while (sc->queue.count <= 0) {
			if (PSM_NBLOCKIO(dev)) {
				splx(s);
				return (EWOULDBLOCK);
			}
			sc->state |= PSM_ASLP;
			error = tsleep((caddr_t)sc, PZERO | PCATCH, 
					"psmread", 0);
			if (error) {
				splx(s);
				return (error);
			}
		}
	}

	if (sc->outputbytes >= uio->uio_resid) {
		/* nothing to be done */
	} else {
		if (sc->outputbytes > 0) {
			bcopy(&sc->opacket[sc->outputhead],sc->opacket,
				sc->outputbytes);
		}
		sc->outputhead = 0;
		for(i = sc->queue.head; sc->queue.count > 0; 
			i = (i + 1) % PSM_BUFSIZE, --sc->queue.count) {
			if (!(*sc->mkpacket)(&sc->opacket[sc->outputbytes],
				&sc->outputbytes,PSM_BUFSIZE,&sc->queue.buf[i]))
				break;
		}
		sc->queue.head = i;
	}

	/* allow interrupts again */
	splx(s);

	/* copy data to user process */
	length = min(sc->outputbytes,uio->uio_resid);
	error = uiomove(&sc->opacket[sc->outputhead], length, uio);
	if (error) 
		return (error);
	sc->outputhead += length;
	sc->outputbytes -= length;

	return (error);
}

#ifdef PSM_CURRENT
static
#endif
int
psmioctl(dev_t dev, int cmd, caddr_t addr, int flag, struct proc *p)
{
	struct psm_softc *sc = &psm_softc[PSM_UNIT(dev)];
	mouseinfo_t info;
	mousestatus_t *ms;
	packetfunc_t func;
	int error = 0;
	int s;

	/* Perform IOCTL command */
	switch (cmd) {

	case MOUSE_GETINFO:
		*(mousehw_t *)addr = sc->hw;
		break;

	case MOUSE_GETMODE:
		*(mousemode_t *)addr = sc->mode;
		break;

	case MOUSE_SETMODE:
		if (((mousemode_t *)addr)->rate < 0) {
			error = EINVAL;
			break;
		}
		if (((mousemode_t *)addr)->resolution < 0) {
			error = EINVAL;
			break;
		}
#ifndef PSM_NOEMULATION
		switch (((mousemode_t *)addr)->protocol) {
		case MOUSE_PROTO_MS:	
			func = mkms;
			break;
		case MOUSE_PROTO_MSC:
			func = mkmsc;
			break;
		case MOUSE_PROTO_PS2:
			func = mkps2;
			break;
		default:
			error = EINVAL;
			func = (packetfunc_t)NULL;
			break;
		}
		if (error)
			break;
#endif /* PSM_NOEMULATION */
		if (((mousemode_t *)addr)->accelfactor < 0) {
			error = EINVAL;
			break;
		}

		s = spltty();	/* disable interrupt while updating */
		sc->mode.rate = (((mousemode_t *)addr)->rate == 0) ?
			PSMD_DEFAULT_RATE : 
			min(((mousemode_t *)addr)->rate,PSMD_MAX_RATE);
		sc->mode.resolution = (((mousemode_t *)addr)->resolution == 0) ?
			PSMD_DEFAULT_RESOLUTION : 
			((mousemode_t *)addr)->resolution;

		/* temporalily disable the keyboard */
		write_controller_command(sc->addr,KBDC_DISABLE_KBD_PORT);
		set_controller_command_byte(sc->addr,
			sc->command_byte & ~KBD_KBD_CONTROL_BITS,
			KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
				| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT);

		/* program the mouse */
		sc->mode.rate = set_mouse_sampling_rate(sc->addr,sc->mode.rate);
		sc->mode.resolution =
			set_mouse_resolution(sc->addr,sc->mode.resolution);

		/* enable the aux port and interrupt */
		set_controller_command_byte(sc->addr,sc->command_byte,
			KBD_ENABLE_AUX_PORT | KBD_ENABLE_AUX_INT);

#ifndef PSM_NOEMULATION
		sc->mode.protocol = ((mousemode_t *)addr)->protocol;
		sc->mkpacket = func;
		sc->outputbytes = 0;
		sc->outputhead = 0;
#endif /* PSM_NOEMULATION */
		sc->mode.accelfactor = ((mousemode_t *)addr)->accelfactor;

		splx(s);
		break;

	case MOUSEIOCREAD:		/* FIXME: this should go... */
		error = EINVAL;
		break;

	case MOUSE_GETSTATE:
		info.status = 0;
		info.xmotion = 0;
		info.ymotion = 0;

		s = spltty();
		if (sc->queue.count > 0) {
			ms = &sc->queue.buf[sc->queue.head];

			/* button status */
			info.status = ms->button;	/* BUT?STAT bits */
			info.status |= 			/* BUT?CHNG bits */
				((ms->button ^ ms->obutton) << 3); 
			/* mouse motion */
			info.xmotion = ms->dx;
			info.ymotion = ms->dy;
			if ((info.xmotion != 0) || (info.ymotion != 0))
				info.status |= MOVEMENT;

			sc->queue.head = (sc->queue.head + 1) % PSM_BUFSIZE;
			--sc->queue.count;
		}
		splx(s);

		*(mouseinfo_t *)addr = info;
		break;

	default:
		error = EINVAL;
		break;
	}

	/* Return error code */
	return (error);
}

void
psmintr(int unit)
{
	/* the table to turn PS/2 mouse button bits (MOUSE_PS2_BUTTON?DOWN) 
	   into `mouseinfo' button bits (BUT?STAT). */
	static butmap[8] = { 
		0, BUT1STAT, BUT3STAT, BUT1STAT | BUT3STAT,
		BUT2STAT, BUT1STAT | BUT2STAT, BUT2STAT | BUT3STAT,
		BUT1STAT | BUT2STAT | BUT3STAT 
	};
	register struct psm_softc *sc = &psm_softc[unit];
	int ioport = sc->addr;
	mousestatus_t *ms;
	unsigned char c;
	int x, y;

	/* is this really for us? */
	if ((inb(ioport + KBD_STATUS_PORT) & KBDS_BUFFER_FULL)
		!= KBDS_AUX_BUFFER_FULL) 
	    return;

	/* read a byte */
	c = inb(ioport + KBD_DATA_PORT);

	/* discard the byte if the device is not open */
	if ((sc->state & PSM_OPEN) == 0) 
	    return;

	/* interpret data bytes 
	   FIXME: there seems no way to reliably re-synchronize with 
	   the PS/2 mouse once we are out of sync. Sure, there is
	   sync bits in the first data byte, but the second and the 
	   third bytes may have these bits on (they are not functioning
	   as sync bits then!). There need to be two consequtive 
	   bytes with these bits off to re-sync. (This can be done
	   if the user clicks buttons without moving the mouse?)
	*/
	if (sc->inputbytes == 0) {
#ifndef PSM_NOCHECKSYNC
		if ((c & MOUSE_PS2_SYNCMASK) == MOUSE_PS2_SYNC) 
#endif /* PSM_NOCHECKSYNC */
			sc->ipacket[sc->inputbytes++] = c;
	} else {
		sc->ipacket[sc->inputbytes++] = c;
		if (sc->inputbytes >= MOUSE_PS2_PACKETSIZE) {
			if (sc->queue.count >= PSM_BUFSIZE) {
				/* no room in the queue */
				sc->inputbytes = 0;
				return;
			}
			if (sc->mode.accelfactor >= 1) {
				x = (sc->ipacket[0] & MOUSE_PS2_XOVERFLOW) ?
					128 : sc->ipacket[1]; 
				if (x != 0) {
					x = x*x/sc->mode.accelfactor;
					if (x == 0)
						x = 1;
					if (sc->ipacket[0] & MOUSE_PS2_XNEG)
						x = -x;
				}
				y = (sc->ipacket[0] & MOUSE_PS2_YOVERFLOW) ?
					128 : sc->ipacket[2]; 
				if (y != 0) {
					y = y*y/sc->mode.accelfactor;
					if (y == 0)
						y = 1;
					if (sc->ipacket[0] & MOUSE_PS2_YNEG)
						y = -y;
				}
			} else { /* sc->mode.accelfactor <= 0 */
				x = (sc->ipacket[0] & MOUSE_PS2_XOVERFLOW) ?
					((sc->ipacket[0] & MOUSE_PS2_XNEG) ? 
						-128 : 127) : sc->ipacket[1]; 
				y = (sc->ipacket[0] & MOUSE_PS2_YOVERFLOW) ?
					((sc->ipacket[0] & MOUSE_PS2_YNEG) ? 
						-128 : 127) : sc->ipacket[2]; 
			}

			/* FIXME: we shouldn't store data if no movement 
			   and no button status change is detected? */
			ms = &sc->queue.buf[sc->queue.tail];
			ms->dx = x;
			ms->dy = y;
			ms->obutton = sc->button; /* previous button state */
			sc->button = ms->button = /* latest button state */
				butmap[sc->ipacket[0] & MOUSE_PS2_BUTTONS];
			sc->queue.tail = 
				(sc->queue.tail + 1) % PSM_BUFSIZE;
			++sc->queue.count;
			sc->inputbytes = 0;
		}
	}

	if (sc->state & PSM_ASLP) {
		sc->state &= ~PSM_ASLP;
		wakeup((caddr_t)sc);
	}
	selwakeup(&sc->rsel);
}

#ifdef PSM_CURRENT
static
#endif
int
psmselect(dev_t dev, int rw, struct proc *p)
{
	struct psm_softc *sc = &psm_softc[PSM_UNIT(dev)];
	int s, ret;

	/* Silly to select for output */
	if (rw == FWRITE)
		return (0);

	/* Return true if a mouse event available */
	s = spltty();
	if ((sc->outputbytes > 0) || (sc->queue.count > 0)) {
		ret = 1;
	} else {
		selrecord(p, &sc->rsel);
		ret = 0;
	}
	splx(s);

	return (ret);
}

#ifdef PSM_CURRENT 

static int psm_devsw_installed = FALSE;

static void
psm_drvinit(void *unused)
{
	dev_t dev;

	if (!psm_devsw_installed) {
		dev = makedev(CDEV_MAJOR, 0);
		cdevsw_add(&dev,&psm_cdevsw, NULL);
		psm_devsw_installed = TRUE;
    	}
}

SYSINIT(psmdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE + CDEV_MAJOR,psm_drvinit,NULL)

#endif /* PSM_CURRENT */

#endif /* NPSM > 0 */