Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/arch/i386/isa/pms.c

451 lines
10 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: pms.c,v 1.9 1993/12/20 09:06:39 mycroft Exp $
*/
#include "pms.h"
#if NPMS > 0
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/malloc.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/file.h>
#ifdef NetBSD
#include <sys/select.h>
#endif
#include <sys/proc.h>
#include <sys/vnode.h>
#include <machine/mouse.h>
#include <machine/pio.h>
#include <i386/isa/isa_device.h>
#define DATA 0 /* Offset for data port, read-write */
#define CNTRL 4 /* Offset for control port, write-only */
#define STATUS 4 /* Offset for status port, read-only */
/* status bits */
#define PMS_OBUF_FULL 0x21
#define PMS_IBUF_FULL 0x02
/* controller commands */
#define PMS_INT_ENABLE 0x47 /* enable controller interrupts */
#define PMS_INT_DISABLE 0x65 /* disable controller interrupts */
#define PMS_AUX_DISABLE 0xa7 /* enable auxiliary port */
#define PMS_AUX_ENABLE 0xa8 /* disable auxiliary port */
#define PMS_MAGIC_1 0xa9 /* XXX */
#define PMS_MAGIC_2 0xaa /* XXX */
/* mouse commands */
#define PMS_SET_SCALE11 0xe6 /* set scaling 1:1 */
#define PMS_SET_SCALE21 0xe7 /* set scaling 2:1 */
#define PMS_SET_RES 0xe8 /* set resolution */
#define PMS_GET_SCALE 0xe9 /* get scaling factor */
#define PMS_SET_STREAM 0xea /* set streaming mode */
#define PMS_SET_SAMPLE 0xf3 /* set sampling rate */
#define PMS_DEV_ENABLE 0xf4 /* mouse on */
#define PMS_DEV_DISABLE 0xf5 /* mouse off */
#define PMS_RESET 0xff /* reset */
#define PMSUNIT(dev) (minor(dev) >> 1)
#ifndef min
#define min(x,y) (x < y ? x : y)
#endif min
int pmsprobe (struct isa_device *);
int pmsattach (struct isa_device *);
static int pmsaddr[NPMS]; /* Base I/O port addresses per unit */
#define MSBSZ 1024 /* Output queue size (pwr of 2 is best) */
struct ringbuf {
int count, first, last;
char queue[MSBSZ];
};
static struct pms_softc { /* Driver status information */
struct ringbuf inq; /* Input queue */
struct selinfo rsel;
unsigned char state; /* Mouse driver state */
unsigned char status; /* Mouse button status */
unsigned char button; /* Previous mouse button status bits */
int x, y; /* accumulated motion in the X,Y axis */
} pms_softc[NPMS];
#define OPEN 1 /* Device is open */
#define ASLP 2 /* Waiting for mouse data */
struct isa_driver pmsdriver = { pmsprobe, pmsattach, "pms" };
static inline void pms_flush(int ioport)
{
u_char c;
while (c = inb(ioport+STATUS) & 0x03)
if ((c & PMS_OBUF_FULL) == PMS_OBUF_FULL)
(void) inb(ioport+DATA);
}
static inline void pms_dev_cmd(int ioport, u_char value)
{
pms_flush(ioport);
outb(ioport+CNTRL, 0xd4);
pms_flush(ioport);
outb(ioport+DATA, value);
}
static inline void pms_aux_cmd(int ioport, u_char value)
{
pms_flush(ioport);
outb(ioport+CNTRL, value);
}
static inline void pms_pit_cmd(int ioport, u_char value)
{
pms_flush(ioport);
outb(ioport+CNTRL, 0x60);
pms_flush(ioport);
outb(ioport+DATA, value);
}
int pmsprobe(struct isa_device *dvp)
{
int unit = dvp->id_unit;
int ioport = dvp->id_iobase;
u_char c;
pms_dev_cmd(ioport, PMS_RESET);
pms_aux_cmd(ioport, PMS_MAGIC_1);
pms_aux_cmd(ioport, PMS_MAGIC_2);
c = inb(ioport+DATA);
pms_pit_cmd(ioport, PMS_INT_DISABLE);
if (c & 0x04)
return 0;
return 1;
}
int pmsattach(struct isa_device *dvp)
{
int unit = dvp->id_unit;
int ioport = dvp->id_iobase;
struct pms_softc *sc = &pms_softc[unit];
/* Save I/O base address */
pmsaddr[unit] = ioport;
/* Disable mouse interrupts and initialize */
pms_pit_cmd(ioport, PMS_INT_DISABLE);
pms_aux_cmd(ioport, PMS_AUX_ENABLE);
pms_dev_cmd(ioport, PMS_DEV_ENABLE);
pms_dev_cmd(ioport, PMS_SET_RES);
pms_dev_cmd(ioport, 3); /* 8 counts/mm */
pms_dev_cmd(ioport, PMS_SET_SCALE21);
pms_dev_cmd(ioport, PMS_SET_SAMPLE);
pms_dev_cmd(ioport, 100); /* 100 samples/sec */
pms_dev_cmd(ioport, PMS_SET_STREAM);
pms_dev_cmd(ioport, PMS_DEV_DISABLE);
pms_aux_cmd(ioport, PMS_AUX_DISABLE);
/* Setup initial driver state */
sc->state = 0;
/* Done */
return(0);
}
int pmsopen(dev_t dev, int flag, int fmt, struct proc *p)
{
int unit = PMSUNIT(dev);
struct pms_softc *sc;
int ioport;
/* Validate unit number */
if (unit >= NPMS)
return(ENXIO);
/* Get device data */
sc = &pms_softc[unit];
ioport = pmsaddr[unit];
/* If device does not exist */
if (ioport == 0)
return(ENXIO);
/* Disallow multiple opens */
if (sc->state & OPEN)
return(EBUSY);
/* Initialize state */
sc->state |= OPEN;
sc->status = 0;
sc->button = 0;
sc->x = 0;
sc->y = 0;
/* Allocate and initialize a ring buffer */
sc->inq.count = sc->inq.first = sc->inq.last = 0;
/* Enable Bus Mouse interrupts */
pms_aux_cmd(ioport, PMS_AUX_ENABLE);
pms_pit_cmd(ioport, PMS_INT_ENABLE);
pms_dev_cmd(ioport, PMS_DEV_ENABLE);
/* Successful open */
return(0);
}
int pmsclose(dev_t dev, int flag, int fmt, struct proc *p)
{
int unit, ioport;
struct pms_softc *sc;
/* Get unit and associated info */
unit = PMSUNIT(dev);
sc = &pms_softc[unit];
ioport = pmsaddr[unit];
/* Disable further mouse interrupts */
pms_dev_cmd(ioport, PMS_DEV_DISABLE);
pms_pit_cmd(ioport, PMS_INT_DISABLE);
pms_aux_cmd(ioport, PMS_AUX_DISABLE);
/* Complete the close */
sc->state &= ~OPEN;
/* close is almost always successful */
return(0);
}
int pmsread(dev_t dev, struct uio *uio, int flag)
{
int s;
int error = 0; /* keep compiler quiet, even though initialisation
is unnecessary */
unsigned length;
struct pms_softc *sc;
unsigned char buffer[100];
/* Get device information */
sc = &pms_softc[PMSUNIT(dev)];
/* Block until mouse activity occured */
s = spltty();
while (sc->inq.count == 0) {
if (minor(dev) & 0x1) {
splx(s);
return(EWOULDBLOCK);
}
sc->state |= ASLP;
error = tsleep((caddr_t)sc, PZERO | PCATCH, "pmsrea", 0);
if (error != 0) {
splx(s);
return(error);
}
}
/* Transfer as many chunks as possible */
while (sc->inq.count > 0 && uio->uio_resid > 0) {
length = min(sc->inq.count, uio->uio_resid);
if (length > sizeof(buffer))
length = sizeof(buffer);
/* Remove a small chunk from input queue */
if (sc->inq.first + length >= MSBSZ) {
bcopy(&sc->inq.queue[sc->inq.first],
buffer, MSBSZ - sc->inq.first);
bcopy(sc->inq.queue, &buffer[MSBSZ-sc->inq.first],
length - (MSBSZ - sc->inq.first));
}
else
bcopy(&sc->inq.queue[sc->inq.first], buffer, length);
sc->inq.first = (sc->inq.first + length) % MSBSZ;
sc->inq.count -= length;
/* Copy data to user process */
error = uiomove(buffer, length, uio);
if (error)
break;
}
sc->x = sc->y = 0;
/* Allow interrupts again */
splx(s);
return(error);
}
int pmsioctl(dev_t dev, caddr_t addr, int cmd, int flag, struct proc *p)
{
struct pms_softc *sc;
struct mouseinfo info;
int s, error;
/* Get device information */
sc = &pms_softc[PMSUNIT(dev)];
/* Perform IOCTL command */
switch (cmd) {
case MOUSEIOCREAD:
/* Don't modify info while calculating */
s = spltty();
/* Build mouse status octet */
info.status = sc->status;
if (sc->x || sc->y)
info.status |= MOVEMENT;
/* Encode X and Y motion as good as we can */
if (sc->x > 127)
info.xmotion = 127;
else if (sc->x < -128)
info.xmotion = -128;
else
info.xmotion = sc->x;
if (sc->y > 127)
info.ymotion = 127;
else if (sc->y < -128)
info.ymotion = -128;
else
info.ymotion = sc->y;
/* Reset historical information */
sc->x = 0;
sc->y = 0;
sc->status &= ~BUTCHNGMASK;
/* Allow interrupts and copy result buffer */
splx(s);
error = copyout(&info, addr, sizeof(struct mouseinfo));
break;
default:
error = EINVAL;
break;
}
/* Return error code */
return(error);
}
void pmsintr(unit)
int unit;
{
struct pms_softc *sc = &pms_softc[unit];
int ioport = pmsaddr[unit];
static int state = 0;
static char buttons, dx, dy;
char changed;
switch (state) {
case 0:
buttons = inb(ioport + DATA);
if (!(buttons & 0xc0))
++state;
break;
case 1:
dx = inb(ioport + DATA);
++state;
break;
case 2:
dy = inb(ioport + DATA);
state = 0;
if (buttons & 0x10)
dx -= 256;
if (buttons & 0x20)
dy -= 256;
if (dx == -128)
dx = -127;
if (dy == -128)
dy = 127;
else
dy = -dy;
buttons = ~(((buttons&1) << 2) | (buttons&3));
changed = buttons ^ sc->button;
sc->button = buttons;
sc->status = buttons | (sc->status & ~BUTSTATMASK) | (changed << 3);
/* Update accumulated movements */
sc->x += dx;
sc->y += dy;
/* If device in use and a change occurred... */
if (sc->state & OPEN && (dx || dy || changed)) {
sc->inq.queue[sc->inq.last++] = 0x40 |
(buttons ^ BUTSTATMASK);
sc->inq.queue[sc->inq.last++ % MSBSZ] = dx;
sc->inq.queue[sc->inq.last++ % MSBSZ] = dy;
sc->inq.queue[sc->inq.last++ % MSBSZ] = 0;
sc->inq.queue[sc->inq.last++ % MSBSZ] = 0;
sc->inq.last = sc->inq.last % MSBSZ;
sc->inq.count += 5;
if (sc->state & ASLP) {
sc->state &= ~ASLP;
wakeup((caddr_t)sc);
}
selwakeup(&sc->rsel);
}
break;
}
}
int pmsselect(dev_t dev, int rw, struct proc *p)
{
int s, ret;
struct pms_softc *sc = &pms_softc[PMSUNIT(dev)];
/* Silly to select for output */
if (rw == FWRITE)
return(0);
/* Return true if a mouse event available */
s = spltty();
if (sc->inq.count)
ret = 1;
else {
selrecord(p, &sc->rsel);
ret = 0;
}
splx(s);
return(ret);
}
#endif
Reference in New Issue View Git Blame Copy Permalink