d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
af2f22807f
freebsd-nq/sys/i386/isa/psm.c
Bruce Evans f2a6e0bc19 Get select stuff by including <sys/select.h> instead of <sys/proc.h>, 
and don't include <sys/fcntl.h>.  (The select -> poll changes replaced
fcntl macros by poll macros.)

Use <machine/*.h> instead of <i386/include/*.h>.

Fail the probe instead of crashing in the unlikely event that malloc()
fails.
1997-11-18 12:21:32 +00:00

1728 lines
50 KiB
C
Raw Blame History

/*-
* 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: psm.c,v 1.44 1997/11/07 08:52:41 phk Exp $
*/
/*
* 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.
* - 12 November 1996. IOCTLs and rearranging `psmread', `psmioctl'...
* - 14 November 1996. Uses `kbdio.c'.
* - 30 November 1996. More fixes.
* - 13 December 1996. Uses queuing version of `kbdio.c'.
*/
#include "psm.h"
#include "apm.h"
#include "opt_psm.h"
#if NPSM > 0
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/poll.h>
#include <sys/syslog.h>
#include <sys/malloc.h>
#ifdef DEVFS
#include <sys/devfsext.h>
#endif
#include <sys/select.h>
#include <machine/apm_bios.h>
#include <machine/clock.h>
#include <machine/mouse.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 0 /* logging: 0: none, 1: brief, 2: verbose */
#endif
/* #define PSM_CHECKSYNC if defined, check the header data byte */
/* features */
#ifndef PSM_ACCEL
#define PSM_ACCEL 0 /* must be one or greater; acceleration will be
* disabled if zero */
#endif
/* #define PSM_EMULATION enables protocol emulation */
/* #define PSM_HOOKAPM hook the APM resume event */
/* #define PSM_RESETAFTERSUSPEND reset the device at the resume event */
#if NAPM <= 0
#undef PSM_HOOKAPM
#endif /* NAPM */
#ifndef PSM_HOOKAPM
#undef PSM_RESETAFTERSUSPEND
#endif /* PSM_HOOKAPM */
/* end of driver specific options */
/* 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
/* 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 */
KBDC kbdc;
int addr; /* I/O port address */
mousehw_t hw; /* hardware information */
mousemode_t mode; /* operation mode */
mousemode_t dflt_mode; /* default operation mode */
ringbuf_t queue; /* mouse status queue */
packetfunc_t mkpacket; /* func. to turn queued data into output format */
unsigned 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
#ifdef PSM_HOOKAPM
struct apmhook resumehook;
#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 void psm_drvinit __P((void *));
#ifdef PSM_HOOKAPM
static int psmresume __P((void *));
#endif
static d_open_t psmopen;
static d_close_t psmclose;
static d_read_t psmread;
static d_ioctl_t psmioctl;
static d_poll_t psmpoll;
static int enable_aux_dev __P((KBDC));
static int disable_aux_dev __P((KBDC));
static int get_mouse_status __P((KBDC, int *));
static int get_aux_id __P((KBDC));
static int set_mouse_sampling_rate __P((KBDC, int));
static int set_mouse_scaling __P((KBDC));
static int set_mouse_resolution __P((KBDC, int));
static int set_mouse_mode __P((KBDC));
static int get_mouse_buttons __P((KBDC));
static int is_a_mouse __P((int));
static void recover_from_error __P((KBDC));
static int restore_controller __P((KBDC, int));
static int reinitialize __P((int, mousemode_t *));
static int doopen __P((int, int));
static int mkms __P((unsigned char *, int *, int, mousestatus_t *));
static int mkman __P((unsigned char *, int *, int, mousestatus_t *));
static int mkmsc __P((unsigned char *, int *, int, mousestatus_t *));
static int mkmm __P((unsigned char *, int *, int, mousestatus_t *));
static int mkps2 __P((unsigned char *, int *, int, mousestatus_t *));
/* device driver declarateion */
struct isa_driver psmdriver = { psmprobe, psmattach, "psm", FALSE };
#define CDEV_MAJOR 21
static struct cdevsw psm_cdevsw = {
psmopen, psmclose, psmread, nowrite, /* 21 */
psmioctl, nostop, nullreset, nodevtotty,
psmpoll, nommap, NULL, "psm", NULL, -1
};
/* debug message level */
static int verbose = PSM_DEBUG;
/* device I/O routines */
static int
enable_aux_dev(KBDC kbdc)
{
int res;
res = send_aux_command(kbdc, 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(KBDC kbdc)
{
int res;
res = send_aux_command(kbdc, 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(KBDC kbdc, int *status)
{
int res;
empty_aux_buffer(kbdc, 5);
res = send_aux_command(kbdc, 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(kbdc);
status[1] = read_aux_data(kbdc);
status[2] = read_aux_data(kbdc);
return TRUE;
}
static int
get_aux_id(KBDC kbdc)
{
int res;
int id;
empty_aux_buffer(kbdc, 5);
res = send_aux_command(kbdc, PSMC_SEND_DEV_ID);
if (verbose >= 2)
log(LOG_DEBUG, "psm: SEND_DEV_ID return code:%04x\n", res);
if (res != PSM_ACK)
return (-1);
/* 10ms delay */
DELAY(10000);
id = read_aux_data(kbdc);
if (verbose >= 2)
log(LOG_DEBUG, "psm: device ID: %04x\n", id);
return id;
}
static int
set_mouse_sampling_rate(KBDC kbdc, int rate)
{
int res;
res = send_aux_command_and_data(kbdc, 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(KBDC kbdc)
{
int res;
res = send_aux_command(kbdc, PSMC_SET_SCALING11);
if (verbose >= 2)
log(LOG_DEBUG, "psm: SET_SCALING11 return code:%04x\n", res);
return (res == PSM_ACK);
}
/* `val' must be 0 through PSMD_MAX_RESOLUTION */
static int
set_mouse_resolution(KBDC kbdc, int val)
{
int res;
res = send_aux_command_and_data(kbdc, PSMC_SET_RESOLUTION, val);
if (verbose >= 2)
log(LOG_DEBUG, "psm: SET_RESOLUTION (%d) %04x\n", val, res);
return ((res == PSM_ACK) ? val : -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(KBDC kbdc)
{
int res;
res = send_aux_command(kbdc, 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(KBDC kbdc)
{
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(kbdc, PSMD_RES_LOW) != PSMD_RES_LOW)
return c;
if (set_mouse_scaling(kbdc) && set_mouse_scaling(kbdc)
&& set_mouse_scaling(kbdc) && get_mouse_status(kbdc, status)) {
if (verbose) {
log(LOG_DEBUG, "psm: status %02x %02x %02x (get_mouse_buttons)\n",
status[0], status[1], status[2]);
}
if (status[1] != 0)
return status[1];
}
return c;
}
/*
* FIXME:XXX
* someday, I will get the list of valid pointing devices and
* their IDs...
*/
static int
is_a_mouse(int id)
{
#if 0
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;
#else
return TRUE;
#endif
}
static void
recover_from_error(KBDC kbdc)
{
/* discard anything left in the output buffer */
empty_both_buffers(kbdc, 10);
#if 0
/*
* NOTE: KBDC_RESET_KBD may not restore the communication between the
* keyboard and the controller.
*/
reset_kbd(kbdc);
#else
/*
* NOTE: somehow diagnostic and keyboard port test commands bring the
* keyboard back.
*/
if (!test_controller(kbdc))
log(LOG_ERR, "psm: keyboard controller failed.\n");
/* if there isn't a keyboard in the system, the following error is OK */
if (test_kbd_port(kbdc) != 0) {
if (verbose)
log(LOG_ERR, "psm: keyboard port failed.\n");
}
#endif
}
static int
restore_controller(KBDC kbdc, int command_byte)
{
if (!set_controller_command_byte(kbdc, 0xff, command_byte)) {
log(LOG_ERR, "psm: failed to restore the keyboard controller "
"command byte.\n");
return FALSE;
} else {
return TRUE;
}
}
/*
* Re-initialize the aux port and device. The aux port must be enabled
* and its interrupt must be disabled before calling this routine.
* The aux device will be disabled before returning.
* The keyboard controller must be locked via `kbdc_lock()' before
* calling this routine.
*/
static int
reinitialize(int unit, mousemode_t *mode)
{
KBDC kbdc = psm_softc[unit]->kbdc;
int stat[3];
int i;
switch((i = test_aux_port(kbdc))) {
case 1: /* ignore this error */
if (verbose)
log(LOG_DEBUG, "psm%d: strange result for test aux port (%d).\n",
unit, i);
/* fall though */
case 0: /* no error */
break;
case -1: /* time out */
default: /* error */
recover_from_error(kbdc);
log(LOG_ERR, "psm%d: the aux port is not functioning (%d).\n",
unit,i);
return FALSE;
}
/*
* 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(kbdc)) {
recover_from_error(kbdc);
log(LOG_ERR, "psm%d: failed to reset the aux device.\n", unit);
return FALSE;
}
/*
* both the aux port and the aux device is functioning, see
* if the device can be enabled.
*/
if (!enable_aux_dev(kbdc) || !disable_aux_dev(kbdc)) {
log(LOG_ERR, "psm%d: failed to enable the aux device.\n", unit);
return FALSE;
}
empty_both_buffers(kbdc, 10); /* remove stray data if any */
/* set mouse parameters */
if (mode != (mousemode_t *)NULL) {
if (mode->rate > 0)
mode->rate = set_mouse_sampling_rate(kbdc, mode->rate);
if (mode->resolution >= 0)
mode->resolution = set_mouse_resolution(kbdc, mode->resolution);
set_mouse_scaling(kbdc);
set_mouse_mode(kbdc);
}
/* just check the status of the mouse */
i = get_mouse_status(kbdc, stat);
if (!i) {
log(LOG_DEBUG, "psm%d: failed to get status.\n", unit);
} else if (verbose) {
log(LOG_DEBUG, "psm%d: status %02x %02x %02x\n", unit,
stat[0], stat[1], stat[2]);
}
return TRUE;
}
static int
doopen(int unit, int command_byte)
{
struct psm_softc *sc = psm_softc[unit];
int stat[3];
/* enable the mouse device */
if (!enable_aux_dev(sc->kbdc)) {
/* MOUSE ERROR: failed to enable the mouse because:
* 1) the mouse is faulty,
* 2) the mouse has been removed(!?)
* In the latter case, the keyboard may have hung, and need
* recovery procedure...
*/
recover_from_error(sc->kbdc);
#if 0
/* FIXME: we could reset the mouse here and try to enable
* it again. But it will take long time and it's not a good
* idea to disable the keyboard that long...
*/
if (!reinitialize(unit, &sc->mode)) {
if (!enable_aux_dev(sc->kbdc))
recover_from_error(sc->kbdc);
#else
{
#endif
restore_controller(sc->kbdc, command_byte);
/* mark this device is no longer available */
sc->state &= ~PSM_VALID;
log(LOG_ERR, "psm%d: failed to enable the device (doopen).\n",
unit);
return (EIO);
}
}
if (!get_mouse_status(sc->kbdc, stat))
log(LOG_DEBUG, "psm%d: failed to get status (doopen).\n", unit);
/* enable the aux port and interrupt */
if (!set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
(command_byte & KBD_KBD_CONTROL_BITS)
| KBD_ENABLE_AUX_PORT | KBD_ENABLE_AUX_INT)) {
/* CONTROLLER ERROR */
disable_aux_dev(sc->kbdc);
restore_controller(sc->kbdc, command_byte);
log(LOG_ERR, "psm%d: failed to enable the aux interrupt (doopen).\n",
unit);
return (EIO);
}
return (0);
}
/* psm driver entry points */
#define endprobe(v) { if (bootverbose) \
--verbose; \
kbdc_set_device_mask(sc->kbdc, mask); \
kbdc_lock(sc->kbdc, FALSE); \
free(sc, M_DEVBUF); \
return (v); \
}
static int
psmprobe(struct isa_device *dvp)
{
int unit = dvp->id_unit;
struct psm_softc *sc;
int stat[3];
int command_byte;
int mask;
int i;
/* validate unit number */
if (unit >= NPSM)
return (0);
psm_softc[unit] = NULL;
sc = malloc(sizeof *sc, M_DEVBUF, M_NOWAIT);
if (sc == NULL)
return (0);
bzero(sc, sizeof *sc);
sc->addr = dvp->id_iobase;
sc->kbdc = kbdc_open(sc->addr);
if (bootverbose)
++verbose;
if (!kbdc_lock(sc->kbdc, TRUE)) {
printf("psm%d: unable to lock the controller.\n", unit);
if (bootverbose)
--verbose;
free(sc, M_DEVBUF);
return (0);
}
/*
* 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.
*
* 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.
*/
/* discard anything left after the keyboard initialization */
empty_both_buffers(sc->kbdc, 10);
/* save the current command byte; it will be used later */
mask = kbdc_get_device_mask(sc->kbdc) & ~KBD_AUX_CONTROL_BITS;
command_byte = get_controller_command_byte(sc->kbdc);
if (verbose)
printf("psm%d: current command byte:%04x\n", unit, command_byte);
if (command_byte == -1) {
/* CONTROLLER ERROR */
printf("psm%d: unable to get the current command byte value.\n",
unit);
endprobe(0);
}
/*
* disable the keyboard port while probing the aux port, which must be
* enabled during this routine
*/
if (!set_controller_command_byte(sc->kbdc,
KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS,
KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/*
* this is CONTROLLER ERROR; I don't know how to recover
* from this error...
*/
restore_controller(sc->kbdc, command_byte);
printf("psm%d: unable to set the command byte.\n", unit);
endprobe(0);
}
/*
* 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.
*
* XXX: some controllers erroneously return the error code 1 when
* it has the perfectly functional aux port. We have to ignore this
* error code. Even if the controller HAS error with the aux port,
* it will be detected later...
*/
switch ((i = test_aux_port(sc->kbdc))) {
case 1: /* ignore this error */
if (verbose)
printf("psm%d: strange result for test aux port (%d).\n",
unit, i);
/* fall though */
case 0: /* no error */
break;
case -1: /* time out */
default: /* error */
recover_from_error(sc->kbdc);
restore_controller(sc->kbdc, command_byte);
if (verbose)
printf("psm%d: the aux port is not functioning (%d).\n",
unit, i);
endprobe(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(sc->kbdc)) {
recover_from_error(sc->kbdc);
restore_controller(sc->kbdc, command_byte);
if (verbose)
printf("psm%d: failed to reset the aux device.\n", unit);
endprobe(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(sc->kbdc) || !disable_aux_dev(sc->kbdc)) {
/* MOUSE ERROR */
restore_controller(sc->kbdc, command_byte);
if (verbose)
printf("psm%d: failed to enable the aux device.\n", unit);
endprobe(0);
}
/* save the default values after reset */
if (get_mouse_status(sc->kbdc, stat)) {
if (verbose)
printf("psm%d: status after reset %02x %02x %02x\n",
unit, stat[0], stat[1], stat[2]);
sc->dflt_mode.rate = sc->mode.rate = stat[2];
sc->dflt_mode.resolution = sc->mode.resolution = stat[1];
} else {
sc->dflt_mode.rate = sc->mode.rate = -1;
sc->dflt_mode.resolution = sc->mode.resolution = -1;
}
/* hardware information */
sc->hw.iftype = MOUSE_IF_PS2;
/* verify the device is a mouse */
sc->hw.hwid = get_aux_id(sc->kbdc);
if (!is_a_mouse(sc->hw.hwid)) {
restore_controller(sc->kbdc, command_byte);
if (verbose)
printf("psm%d: unknown device type (%d).\n", unit, sc->hw.hwid);
endprobe(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(sc->kbdc);
/* set mouse parameters */
/* FIXME:XXX should we set them in `psmattach()' rather than here? */
/* FIXME:XXX I don't know if these parameters are reasonable */
i = send_aux_command(sc->kbdc, PSMC_SET_DEFAULTS);
if (verbose >= 2)
log(LOG_DEBUG, "psm%d: SET_DEFAULTS return code:%04x\n",
unit, i);
#if 0
set_mouse_scaling(sc->kbdc); /* 1:1 scaling */
set_mouse_mode(sc->kbdc); /* stream mode */
#endif
/* just check the status of the mouse */
/*
* NOTE: XXX there are some arcane controller/mouse combinations out
* there, which hung the controller unless there is data transmission
* after ACK from the mouse.
*/
i = get_mouse_status(sc->kbdc, stat);
if (!i) {
log(LOG_DEBUG, "psm%d: failed to get status.\n", unit);
} else if (verbose) {
log(LOG_DEBUG, "psm%d: status %02x %02x %02x\n",
unit, stat[0], stat[1], stat[2]);
}
/* disable the aux port for now... */
if (!set_controller_command_byte(sc->kbdc,
KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS,
(command_byte & KBD_KBD_CONTROL_BITS)
| KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/*
* this is CONTROLLER ERROR; I don't know the proper way to
* recover from this error...
*/
restore_controller(sc->kbdc, command_byte);
printf("psm%d: unable to set the command byte.\n", unit);
endprobe(0);
}
/* done */
psm_softc[unit] = sc;
kbdc_set_device_mask(sc->kbdc, mask | KBD_AUX_CONTROL_BITS);
kbdc_lock(sc->kbdc, FALSE);
return (IO_PSMSIZE);
}
static int
psmattach(struct isa_device *dvp)
{
int unit = dvp->id_unit;
struct psm_softc *sc = psm_softc[unit];
if (sc == NULL) /* shouldn't happen */
return (0);
/* initial operation mode */
sc->dflt_mode.accelfactor = sc->mode.accelfactor = PSM_ACCEL;
sc->dflt_mode.protocol = 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 /* DEVFS */
#ifdef PSM_HOOKAPM
sc->resumehook.ah_name = "PS/2 mouse";
sc->resumehook.ah_fun = psmresume;
sc->resumehook.ah_arg = (void *)unit;
sc->resumehook.ah_order = APM_MID_ORDER;
apm_hook_establish(APM_HOOK_RESUME , &sc->resumehook);
if (verbose)
printf("psm%d: APM hooks installed.\n", unit);
#endif /* PSM_HOOKAPM */
if (verbose)
printf("psm%d: device ID %d, %d buttons\n",
unit, sc->hw.hwid, sc->hw.buttons);
else
printf("psm%d: device ID %d\n", unit, sc->hw.hwid);
if (bootverbose)
--verbose;
return (1);
}
static int
psmopen(dev_t dev, int flag, int fmt, struct proc *p)
{
int unit = PSM_UNIT(dev);
struct psm_softc *sc;
int command_byte;
int err;
int s;
/* Validate unit number */
if (unit >= NPSM)
return (ENXIO);
/* Get device data */
sc = psm_softc[unit];
if ((sc == NULL) || (sc->state & PSM_VALID) == 0)
/* the device is no longer valid/functioning */
return (ENXIO);
/* Disallow multiple opens */
if (sc->state & PSM_OPEN)
return (EBUSY);
/* Initialize state */
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;
/* don't let timeout routines in the keyboard driver to poll the kbdc */
if (!kbdc_lock(sc->kbdc, TRUE))
return (EIO);
/* save the current controller command byte */
s = spltty();
command_byte = get_controller_command_byte(sc->kbdc);
/* enable the aux port and temporalily disable the keyboard */
if ((command_byte == -1)
|| !set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/* CONTROLLER ERROR; do you know how to get out of this? */
kbdc_lock(sc->kbdc, FALSE);
splx(s);
log(LOG_ERR, "psm%d: unable to set the command byte (psmopen).\n",
unit);
return (EIO);
}
/*
* Now that the keyboard controller is told not to generate
* the keyboard and mouse interrupts, call `splx()' to allow
* the other tty interrupts. The clock interrupt may also occur,
* but timeout routines will be blocked by the poll flag set
* via `kbdc_lock()'
*/
splx(s);
/* enable the mouse device */
err = doopen(unit, command_byte);
/* done */
if (err == 0)
sc->state |= PSM_OPEN;
kbdc_lock(sc->kbdc, FALSE);
return (err);
}
static int
psmclose(dev_t dev, int flag, int fmt, struct proc *p)
{
struct psm_softc *sc = psm_softc[PSM_UNIT(dev)];
int stat[3];
int command_byte;
int ret;
int s;
/* don't let timeout routines in the keyboard driver to poll the kbdc */
if (!kbdc_lock(sc->kbdc, TRUE))
return (EIO);
/* save the current controller command byte */
s = spltty();
command_byte = get_controller_command_byte(sc->kbdc);
if (command_byte == -1) {
kbdc_lock(sc->kbdc, FALSE);
splx(s);
return (EIO);
}
/* disable the aux interrupt and temporalily disable the keyboard */
if (!set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
log(LOG_ERR, "psm%d: failed to disable the aux int (psmclose).\n",
PSM_UNIT(dev));
/* CONTROLLER ERROR;
* NOTE: we shall force our way through. Because the only
* ill effect we shall see is that we may not be able
* to read ACK from the mouse, and it doesn't matter much
* so long as the mouse will accept the DISABLE command.
*/
}
splx(s);
/* remove anything left in the output buffer */
empty_aux_buffer(sc->kbdc, 10);
/* disable the aux device, port and interrupt */
if (!disable_aux_dev(sc->kbdc)) {
/* MOUSE ERROR;
* NOTE: we don't return error and continue, pretending
* we have successfully disabled the device. It's OK because
* the interrupt routine will discard any data from the mouse
* hereafter.
*/
log(LOG_ERR, "psm%d: failed to disable the device (psmclose).\n",
PSM_UNIT(dev));
}
ret = get_mouse_status(sc->kbdc, stat);
if (!ret) {
log(LOG_DEBUG, "psm%d: failed to get status (psmclose).\n",
PSM_UNIT(dev));
} else if (verbose >= 2) {
log(LOG_DEBUG, "psm%d: status %02x %02x %02x (psmclose)\n",
PSM_UNIT(dev), stat[0], stat[1], stat[2]);
}
if (!set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
(command_byte & KBD_KBD_CONTROL_BITS)
| KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/* CONTROLLER ERROR;
* we shall ignore this error; see the above comment.
*/
log(LOG_ERR, "psm%d: failed to disable the aux port (psmclose).\n",
PSM_UNIT(dev));
}
/* remove anything left in the output buffer */
empty_aux_buffer(sc->kbdc, 10);
/* close is almost always successful */
sc->state &= ~(PSM_OPEN | PSM_ASLP);
kbdc_lock(sc->kbdc, FALSE);
return (0);
}
#ifdef PSM_EMULATION
static int
mkms(unsigned char *buf, int *len, int maxlen, register mousestatus_t *status)
{
static int butmap[] = {
0, MOUSE_MSS_BUTTON1DOWN,
0, MOUSE_MSS_BUTTON1DOWN ,
MOUSE_MSS_BUTTON3DOWN, MOUSE_MSS_BUTTON1DOWN | MOUSE_MSS_BUTTON3DOWN,
MOUSE_MSS_BUTTON3DOWN, MOUSE_MSS_BUTTON1DOWN | MOUSE_MSS_BUTTON3DOWN,
};
unsigned char delta;
if (maxlen - *len < MOUSE_MSS_PACKETSIZE)
return FALSE;
buf[0] = MOUSE_MSS_SYNC | butmap[status->button & MOUSE_STDBUTTONS];
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
mkman(unsigned char *buf, int *len, int maxlen, register mousestatus_t *status)
{
static int butmap[] = {
0, MOUSE_MSS_BUTTON1DOWN,
0, MOUSE_MSS_BUTTON1DOWN,
MOUSE_MSS_BUTTON3DOWN, MOUSE_MSS_BUTTON1DOWN | MOUSE_MSS_BUTTON3DOWN,
MOUSE_MSS_BUTTON3DOWN, MOUSE_MSS_BUTTON1DOWN | MOUSE_MSS_BUTTON3DOWN,
};
unsigned char delta;
int l;
l = ((status->button ^ status->obutton) & MOUSE_BUTTON2DOWN) ?
MOUSE_MSS_PACKETSIZE + 1: MOUSE_MSS_PACKETSIZE;
if (maxlen - *len < l)
return FALSE;
buf[0] = MOUSE_MSS_SYNC | butmap[status->button & MOUSE_STDBUTTONS];
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 */
if (l > MOUSE_MSS_PACKETSIZE)
buf[3] = (status->button & MOUSE_BUTTON2DOWN)
? MOUSE_LMAN_BUTTON2DOWN : 0;
*len += l;
return TRUE;
}
static int
mkmsc(unsigned char *buf, int *len, int maxlen, register mousestatus_t *status)
{
static int butmap[] = {
0,
MOUSE_MSC_BUTTON1UP, MOUSE_MSC_BUTTON2UP,
MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP,
MOUSE_MSC_BUTTON3UP,
MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON3UP,
MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
};
register int delta;
if (maxlen - *len < MOUSE_MSC_PACKETSIZE)
return FALSE;
buf[0] = MOUSE_MSC_SYNC
| (~butmap[status->button & MOUSE_STDBUTTONS] & MOUSE_MSC_BUTTONS);
/* data bytes cannot be between 80h (-128) and 87h (-120).
* values we can return is 255 (0ffh) through -251 (10fh = 87h*2 + 1).
*/
if (status->dx < -251)
delta = -251;
else
if (status->dx > 255)
delta = 255;
else
delta = status->dx;
buf[1] = delta/2;
buf[3] = delta - buf[1];
if (status->dy < -251)
delta = -251;
else
if (status->dy > 255)
delta = 255;
else
delta = status->dy;
buf[2] = delta/2;
buf[4] = delta - buf[2];
*len += MOUSE_MSC_PACKETSIZE;
return TRUE;
}
static int
mkmm(unsigned char *buf, int *len, int maxlen, register mousestatus_t *status)
{
static int butmap[] = {
0,
MOUSE_MM_BUTTON1DOWN, MOUSE_MM_BUTTON2DOWN,
MOUSE_MM_BUTTON1DOWN | MOUSE_MM_BUTTON2DOWN,
MOUSE_MM_BUTTON3DOWN,
MOUSE_MM_BUTTON1DOWN | MOUSE_MM_BUTTON3DOWN,
MOUSE_MM_BUTTON2DOWN | MOUSE_MM_BUTTON3DOWN,
MOUSE_MM_BUTTON1DOWN | MOUSE_MM_BUTTON2DOWN | MOUSE_MM_BUTTON3DOWN,
};
int delta;
if (maxlen - *len < MOUSE_MM_PACKETSIZE)
return FALSE;
buf[0] = MOUSE_MM_SYNC
| butmap[status->button & MOUSE_STDBUTTONS]
| ((status->dx > 0) ? MOUSE_MM_XPOSITIVE : 0)
| ((status->dy > 0) ? MOUSE_MM_YPOSITIVE : 0);
delta = (status->dx < 0) ? -status->dx : status->dx;
buf[1] = min(delta, 127);
delta = (status->dy < 0) ? -status->dy : status->dy;
buf[2] = min(delta, 127);
*len += MOUSE_MM_PACKETSIZE;
return TRUE;
}
#endif /* PSM_EMULATION */
static int
mkps2(unsigned char *buf, int *len, int maxlen, register mousestatus_t *status)
{
static int butmap[] = {
0,
MOUSE_PS2_BUTTON1DOWN, MOUSE_PS2_BUTTON2DOWN,
MOUSE_PS2_BUTTON1DOWN | MOUSE_PS2_BUTTON2DOWN,
MOUSE_PS2_BUTTON3DOWN,
MOUSE_PS2_BUTTON1DOWN | MOUSE_PS2_BUTTON3DOWN,
MOUSE_PS2_BUTTON2DOWN | MOUSE_PS2_BUTTON3DOWN,
MOUSE_PS2_BUTTON1DOWN | MOUSE_PS2_BUTTON2DOWN | MOUSE_PS2_BUTTON3DOWN,
};
register int delta;
if (maxlen - *len < MOUSE_PS2_PACKETSIZE)
return FALSE;
buf[0] = ((status->button & MOUSE_BUTTON4DOWN) ? 0 : MOUSE_PS2_BUTTON4UP)
| butmap[status->button & MOUSE_STDBUTTONS];
if ((verbose >= 2) && ((buf[0] & MOUSE_PS2_BUTTON4UP) == 0))
log(LOG_DEBUG, "psm: button 4 down (%04x) (mkps2)\n", buf[0]);
if (status->dx < -256)
delta = -256;
else
if (status->dx > 255)
delta = 255;
else
delta = status->dx;
if (delta < 0)
buf[0] |= MOUSE_PS2_XNEG;
buf[1] = delta;
if (status->dy < -256)
delta = -256;
else
if (status->dy > 255)
delta = 255;
else
delta = status->dy;
if (delta < 0)
buf[0] |= MOUSE_PS2_YNEG;
buf[2] = delta;
*len += MOUSE_PS2_PACKETSIZE;
return TRUE;
}
static 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);
sc->state &= ~PSM_ASLP;
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);
}
static int
psmioctl(dev_t dev, int cmd, caddr_t addr, int flag, struct proc *p)
{
struct psm_softc *sc = psm_softc[PSM_UNIT(dev)];
mousemode_t mode;
mousestatus_t status;
packetfunc_t func;
int command_byte;
int error = 0;
int s;
/* Perform IOCTL command */
switch (cmd) {
case MOUSE_GETHWINFO:
*(mousehw_t *) addr = sc->hw;
break;
case MOUSE_GETMODE:
*(mousemode_t *) addr = sc->mode;
if (sc->mode.resolution >= 0)
((mousemode_t *) addr)->resolution = sc->mode.resolution + 1;
break;
case MOUSE_SETMODE:
mode = *(mousemode_t *) addr;
if (mode.rate == 0) {
mode.rate = sc->dflt_mode.rate;
} else if (mode.rate > 0) {
mode.rate = min(mode.rate, PSMD_MAX_RATE);
} else { /* mode.rate < 0 */
mode.rate = sc->mode.rate;
}
if (mode.resolution == 0) {
mode.resolution = sc->dflt_mode.resolution;
} else if (mode.resolution > 0) {
mode.resolution = min(mode.resolution - 1, PSMD_MAX_RESOLUTION);
} else { /* mode.resolution < 0 */
mode.resolution = sc->mode.resolution;
}
#ifdef PSM_EMULATION
switch (mode.protocol) {
case MOUSE_PROTO_MS:
func = mkms;
break;
case MOUSE_PROTO_LOGIMOUSEMAN:
func = mkman;
break;
case MOUSE_PROTO_MSC:
func = mkmsc;
break;
case MOUSE_PROTO_MM:
func = mkmm;
break;
case MOUSE_PROTO_PS2:
func = mkps2;
break;
default:
error = EINVAL;
func = (packetfunc_t) NULL;
break;
}
if (error)
break;
#else
mode.protocol = sc->mode.protocol;
#endif /* PSM_EMULATION */
if (mode.accelfactor < 0) {
error = EINVAL;
break;
}
/* don't allow anybody to poll the keyboard controller */
if (!kbdc_lock(sc->kbdc, TRUE)) {
error = EIO;
break;
}
/* temporalily disable the keyboard */
s = spltty();
command_byte = get_controller_command_byte(sc->kbdc);
if ((command_byte == -1)
|| !set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/* this is CONTROLLER ERROR; I don't know how to recover
* from this error.
*/
kbdc_lock(sc->kbdc, FALSE);
splx(s);
log(LOG_ERR, "psm%d: failed to set the command byte (psmioctl).\n",
PSM_UNIT(dev));
error = EIO;
break;
}
/*
* The device may be in the middle of status data transmission.
* The transmission will be interrupted, thus, incomplete status
* data must be discarded. Although the aux interrupt is disabled
* at the keyboard controller level, at most one aux interrupt
* may have already been pending and a data byte is in the
* output buffer; throw it away. Note that the second argument
* to `empty_aux_buffer()' is zero, so that the call will just
* flush the internal queue.
* `psmintr()' will be invoked after `splx()' if an interrupt is
* pending; it will see no data and returns immediately.
*/
empty_aux_buffer(sc->kbdc, 0); /* flush the queue */
read_aux_data_no_wait(sc->kbdc); /* throw away data if any */
sc->inputbytes = 0;
splx(s);
if (mode.rate > 0)
mode.rate = set_mouse_sampling_rate(sc->kbdc, mode.rate);
if (mode.resolution >= 0)
mode.resolution = set_mouse_resolution(sc->kbdc, mode.resolution);
/*
* We may have seen a part of status data, which is queued,
* during `set_mouse_XXX()'; flush it.
*/
empty_aux_buffer(sc->kbdc, 0);
/* restore ports and interrupt */
if (!set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
command_byte & (KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS))) {
/* CONTROLLER ERROR; this is serious, we may have
* been left with the unaccessible keyboard and
* the disabled mouse interrupt.
*/
kbdc_lock(sc->kbdc, FALSE);
log(LOG_ERR, "psm%d: failed to re-enable "
"the aux port and int (psmioctl).\n", PSM_UNIT(dev));
error = EIO;
break;
}
sc->mode = mode;
#ifdef PSM_EMULATION
sc->mkpacket = func;
sc->outputbytes = 0;
sc->outputhead = 0;
#endif /* PSM_EMULATION */
kbdc_lock(sc->kbdc, FALSE);
break;
case MOUSEIOCREAD: /* FIXME:XXX this should go... */
error = EINVAL;
break;
case MOUSE_GETSTATE:
s = spltty();
if (sc->queue.count > 0) {
status = sc->queue.buf[sc->queue.head];
sc->queue.head = (sc->queue.head + 1) % PSM_BUFSIZE;
--sc->queue.count;
} else {
status.button = status.obutton = sc->button;
status.dx = status.dy = 0;
}
splx(s);
*(mousestatus_t *) addr = status;
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 `mousestatus' button bits (MOUSE_BUTTON?DOWN).
*/
static int butmap[8] = {
0,
MOUSE_BUTTON1DOWN, MOUSE_BUTTON3DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
MOUSE_BUTTON2DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN,
MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN
};
register struct psm_softc *sc = psm_softc[unit];
mousestatus_t *ms;
int c;
int x, y;
/* read until there is nothing to read */
while((c = read_aux_data_no_wait(sc->kbdc)) != -1) {
/* discard the byte if the device is not open */
if ((sc->state & PSM_OPEN) == 0)
continue;
/*
* FIXME: there seems no way to reliably
* re-synchronize with the PS/2 mouse once we are out of sync. Sure,
* there is a sync bit in the first data byte, but the second and the
* third bytes may have these bits on (oh, it's not functioning as
* sync bit then!). There need to be two consequtive bytes with this
* bit off to re-sync. (This can be done if the user clicks buttons
* without moving the mouse?)
*/
if (sc->inputbytes == 0) {
#ifdef PSM_CHECKSYNC
if ((c & MOUSE_PS2_SYNCMASK) == MOUSE_PS2_SYNC)
sc->ipacket[sc->inputbytes++] = c;
else
log(LOG_DEBUG, "psmintr: sync. bit is off (%04x).\n", c);
#else
sc->ipacket[sc->inputbytes++] = c;
#endif /* PSM_CHECKSYNC */
} 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 0
x = (sc->ipacket[0] & MOUSE_PS2_XOVERFLOW) ?
((sc->ipacket[0] & MOUSE_PS2_XNEG) ? -256 : 255) :
((sc->ipacket[0] & MOUSE_PS2_XNEG) ?
sc->ipacket[1] - 256 : sc->ipacket[1]);
y = (sc->ipacket[0] & MOUSE_PS2_YOVERFLOW) ?
((sc->ipacket[0] & MOUSE_PS2_YNEG) ? -256 : 255) :
((sc->ipacket[0] & MOUSE_PS2_YNEG) ?
sc->ipacket[2] - 256 : sc->ipacket[2]);
#else
/* it seems OK to ignore the OVERFLOW bits... */
x = (sc->ipacket[0] & MOUSE_PS2_XNEG) ?
sc->ipacket[1] - 256 : sc->ipacket[1];
y = (sc->ipacket[0] & MOUSE_PS2_YNEG) ?
sc->ipacket[2] - 256 : sc->ipacket[2];
#endif
if (sc->mode.accelfactor >= 1) {
if (x != 0) {
x = x * x / sc->mode.accelfactor;
if (x == 0)
x = 1;
if (sc->ipacket[0] & MOUSE_PS2_XNEG)
x = -x;
}
if (y != 0) {
y = y * y / sc->mode.accelfactor;
if (y == 0)
y = 1;
if (sc->ipacket[0] & MOUSE_PS2_YNEG)
y = -y;
}
}
/*
* FIXME:XXX
* 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->ipacket[0] & MOUSE_PS2_BUTTON4UP)
? 0 : MOUSE_BUTTON4DOWN);
#if 0
if ((verbose >= 2)
&& ((sc->ipacket[0] & MOUSE_PS2_BUTTON4UP) == 0))
log(LOG_DEBUG, "psm%d: button 4 down (%04x) (psmintr)\n",
unit, sc->ipacket[0]);
#endif
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);
}
}
}
}
static int
psmpoll(dev_t dev, int events, struct proc *p)
{
struct psm_softc *sc = psm_softc[PSM_UNIT(dev)];
int s;
int revents = 0;
/* Return true if a mouse event available */
s = spltty();
if (events & (POLLIN | POLLRDNORM))
if ((sc->outputbytes > 0) || (sc->queue.count > 0))
revents |= events & (POLLIN | POLLRDNORM);
else
selrecord(p, &sc->rsel);
splx(s);
return (revents);
}
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;
}
}
#ifdef PSM_HOOKAPM
static int
psmresume(void *dummy)
{
struct psm_softc *sc = psm_softc[(int)dummy];
int unit = (int)dummy;
int err = 0;
int s;
int c;
if (verbose >= 2)
log(LOG_NOTICE, "psm%d: APM resume hook called.\n", unit);
/* don't let anybody mess with the aux device */
if (!kbdc_lock(sc->kbdc, TRUE))
return (EIO);
s = spltty();
/* save the current controller command byte */
empty_both_buffers(sc->kbdc, 10);
c = get_controller_command_byte(sc->kbdc);
if (verbose >= 2)
log(LOG_DEBUG, "psm%d: current command byte: %04x (psmresume).\n",
unit, c);
/* enable the aux port but disable the aux interrupt and the keyboard */
if ((c == -1) || !set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT
| KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/* CONTROLLER ERROR */
splx(s);
kbdc_lock(sc->kbdc, FALSE);
log(LOG_ERR, "psm%d: unable to set the command byte (psmresume).\n",
unit);
return (EIO);
}
/* flush any data */
if (sc->state & PSM_VALID) {
disable_aux_dev(sc->kbdc); /* this may fail; but never mind... */
empty_aux_buffer(sc->kbdc, 10);
}
sc->inputbytes = 0;
#ifdef PSM_RESETAFTERSUSPEND
/* try to detect the aux device; are you still there? */
if (reinitialize(unit, &sc->mode)) {
/* yes */
sc->state |= PSM_VALID;
} else {
/* the device has gone! */
restore_controller(sc->kbdc, c);
sc->state &= ~PSM_VALID;
log(LOG_ERR, "psm%d: the aux device has gone! (psmresume).\n",
unit);
err = ENXIO;
}
#endif /* PSM_RESETAFTERSUSPEND */
splx(s);
/* restore the driver state */
if ((sc->state & PSM_OPEN) && (err == 0)) {
/* enable the aux device and the port again */
err = doopen(unit, c);
if (err != 0)
log(LOG_ERR, "psm%d: failed to enable the device (psmresume).\n",
unit);
} else {
/* restore the keyboard port and disable the aux port */
if (!set_controller_command_byte(sc->kbdc,
kbdc_get_device_mask(sc->kbdc),
(c & KBD_KBD_CONTROL_BITS)
| KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/* CONTROLLER ERROR */
log(LOG_ERR, "psm%d: failed to disable the aux port (psmresume).\n",
unit);
err = EIO;
}
}
/* done */
kbdc_lock(sc->kbdc, FALSE);
if ((sc->state & PSM_ASLP) && !(sc->state & PSM_VALID)) {
/*
* Release the blocked process; it must be notified that the device
* cannot be accessed anymore.
*/
sc->state &= ~PSM_ASLP;
wakeup((caddr_t)sc);
}
if (verbose >= 2)
log(LOG_DEBUG, "psm%d: APM resume hook exiting.\n", unit);
return (err);
}
#endif /* PSM_HOOKAPM */
SYSINIT(psmdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE + CDEV_MAJOR, psm_drvinit, NULL)
#endif /* NPSM > 0 */
Reference in New Issue View Git Blame Copy Permalink