--- sys/arch/arm32/conf/files.arm32.orig Sun Jan 24 21:21:31 1999 +++ sys/arch/arm32/conf/files.arm32 Tue Mar 9 04:16:00 1999 @@ -155,10 +155,12 @@ device opms: tty file arch/arm32/dev/pms.c opms & opms_iomd needs-flag file arch/arm32/shark/pms.c opms & ofw needs-flag +file arch/arm32/isa/pms.c opms & opms_pckbc needs-flag major {opms = 40} attach opms at spckbd with opms attach opms at iomd with opms_iomd +attach opms at pckbc with opms_pckbc file arch/arm32/iomd/pms_iomd.c opms_iomd # Standard keyboard driver --- sys/arch/arm32/conf/CATS.orig Tue Mar 9 05:07:28 1999 +++ sys/arch/arm32/conf/CATS Tue Mar 9 05:08:29 1999 @@ -288,11 +288,12 @@ # wscons pckbc0 at isa? # pc keyboard controller pckbd* at pckbc? # PC keyboard -pms* at pckbc? # PS/2 mouse for wsmouse -pmsi* at pckbc? # PS/2 "Intelli"mouse for wsmouse +#pms* at pckbc? # PS/2 mouse for wsmouse +#pmsi* at pckbc? # PS/2 "Intelli"mouse for wsmouse +opms* at pckbc? # backwards compatible PS/2 mouse wskbd* at pckbd? console ? -wsmouse* at pms? -wsmouse* at pmsi? +#wsmouse* at pms? +#wsmouse* at pmsi? pcppi0 at isa? sysbeep0 at pcppi? --- /dev/null Tue Mar 23 12:40:20 1999 +++ sys/arch/arm32/isa/pms.c Tue Mar 9 23:06:58 1999 @@ -0,0 +1,452 @@ +/* $NetBSD: pms.c,v 1.42 1999/01/23 15:07:10 drochner Exp $ */ + +/*- + * Copyright (c) 1994, 1997 Charles M. Hannum. + * 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. + */ + +/* + * XXXX + * This is a hack. This driver should really be combined with the + * keyboard driver, since they go through the same buffer and use the + * same I/O ports. Frobbing the mouse and keyboard at the same time + * may result in dropped characters and/or corrupted mouse events. + */ + +#include "opms.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if (NOPMS_PCKBC > 0) +#include +#include +#endif +#include +#include + +/* 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 PMS_CHUNK 128 /* chunk size for read */ +#define PMS_BSIZE 1020 /* buffer size */ + +/* XXX */ +#define MOUSEIOC ('M'<<8) +#define MOUSEIOCREAD (MOUSEIOC|60) + +struct opms_softc { /* driver status information */ + struct device sc_dev; +#if (NOPMS_PCKBC > 0) + pckbc_tag_t sc_kbctag; + pckbc_slot_t sc_kbcslot; +#endif + + struct clist sc_q; + struct selinfo sc_rsel; + u_char sc_state; /* mouse driver state */ +#define PMS_OPEN 0x01 /* device is open */ +#define PMS_ASLP 0x02 /* waiting for mouse data */ + u_char sc_status; /* mouse button status */ + int sc_x, sc_y; /* accumulated motion in the X,Y axis */ +}; + +#if (NOPMS_PCKBC > 0) +int opms_pckbc_probe __P((struct device *, struct cfdata *, void *)); +void opms_pckbc_attach __P((struct device *, struct device *, void *)); + +struct cfattach opms_pckbc_ca = { + sizeof(struct opms_softc), opms_pckbc_probe, opms_pckbc_attach, +}; +#endif + +void opmsinput __P((void *, int)); + +extern struct cfdriver opms_cd; + +#define PMSUNIT(dev) (minor(dev)) + +#if (NOPMS_PCKBC > 0) +int +opms_pckbc_probe(parent, match, aux) + struct device *parent; + struct cfdata *match; + void *aux; +{ + struct pckbc_attach_args *pa = aux; + u_char cmd[1], resp[2]; + int res; + + if (pa->pa_slot != PCKBC_AUX_SLOT) + return (0); + + /* Flush any garbage. */ + pckbc_flush(pa->pa_tag, pa->pa_slot); + + /* reset the device */ + cmd[0] = PMS_RESET; + res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 2, resp, 1); + if (res) { + printf("opmsprobe: command error\n"); + return(0); + } + if (resp[0] != 0xaa) { + printf("opmsprobe: reset error\n"); + return(0); + } + + /* get type number (0 = mouse) */ + if (resp[1] != 0) { +#ifdef DIAGNOSTIC + printf("opmsprobe: type 0x%x\n", resp[1]); +#endif + return(0); + } + + return (1); +} + +void +opms_pckbc_attach(parent, self, aux) + struct device *parent, *self; + void *aux; +{ + struct opms_softc *sc = (void *)self; + struct pckbc_attach_args *pa = aux; + u_char cmd[1]; + int res; + + sc->sc_kbctag = pa->pa_tag; + sc->sc_kbcslot = pa->pa_slot; + + printf("\n"); + + /* Other initialization was done by pmsprobe. */ + sc->sc_state = 0; + + pckbc_set_inputhandler(sc->sc_kbctag, sc->sc_kbcslot, + opmsinput, sc); + + /* no interrupts until enabled */ + cmd[0] = PMS_DEV_DISABLE; + res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 0, 0, 0); + if (res) + printf("opmsattach: disable error\n"); + pckbc_slot_enable(sc->sc_kbctag, sc->sc_kbcslot, 0); +} +#endif + +int +pmsopen(dev, flag, mode, p) + dev_t dev; + int flag; + int mode; + struct proc *p; +{ + int unit = PMSUNIT(dev); + struct opms_softc *sc; +#if (NOPMS_PCKBC > 0) + u_char cmd[1]; + int res; +#endif + + if (unit >= opms_cd.cd_ndevs) + return ENXIO; + sc = opms_cd.cd_devs[unit]; + if (!sc) + return ENXIO; + + if (sc->sc_state & PMS_OPEN) + return EBUSY; + + if (clalloc(&sc->sc_q, PMS_BSIZE, 0) == -1) + return ENOMEM; + + sc->sc_state |= PMS_OPEN; + sc->sc_status = 0; + sc->sc_x = sc->sc_y = 0; + + /* Enable interrupts. */ +#if (NOPMS_PCKBC > 0) + pckbc_slot_enable(sc->sc_kbctag, sc->sc_kbcslot, 1); + + cmd[0] = PMS_DEV_ENABLE; + res = pckbc_enqueue_cmd(sc->sc_kbctag, sc->sc_kbcslot, + cmd, 1, 0, 1, 0); + if (res) { + printf("opms_enable: command error\n"); + return (res); + } +#endif + +#if 0 + pms_dev_cmd(PMS_SET_RES); + pms_dev_cmd(3); /* 8 counts/mm */ + pms_dev_cmd(PMS_SET_SCALE21); + pms_dev_cmd(PMS_SET_SAMPLE); + pms_dev_cmd(100); /* 100 samples/sec */ + pms_dev_cmd(PMS_SET_STREAM); +#endif + + return 0; +} + +int +pmsclose(dev, flag, mode, p) + dev_t dev; + int flag; + int mode; + struct proc *p; +{ + struct opms_softc *sc = opms_cd.cd_devs[PMSUNIT(dev)]; +#if (NOPMS_PCKBC > 0) + u_char cmd[1]; + int res; +#endif + + /* Disable interrupts. */ +#if (NOPMS_PCKBC > 0) + cmd[0] = PMS_DEV_DISABLE; + res = pckbc_enqueue_cmd(sc->sc_kbctag, sc->sc_kbcslot, + cmd, 1, 0, 1, 0); + if (res) + printf("opms_disable: command error\n"); + + pckbc_slot_enable(sc->sc_kbctag, sc->sc_kbcslot, 0); +#endif + + sc->sc_state &= ~PMS_OPEN; + + clfree(&sc->sc_q); + + return 0; +} + +int +pmsread(dev, uio, flag) + dev_t dev; + struct uio *uio; + int flag; +{ + struct opms_softc *sc = opms_cd.cd_devs[PMSUNIT(dev)]; + int s; + int error = 0; + size_t length; + u_char buffer[PMS_CHUNK]; + + /* Block until mouse activity occured. */ + + s = spltty(); + while (sc->sc_q.c_cc == 0) { + if (flag & IO_NDELAY) { + splx(s); + return EWOULDBLOCK; + } + sc->sc_state |= PMS_ASLP; + error = tsleep((caddr_t)sc, PZERO | PCATCH, "pmsrea", 0); + if (error) { + sc->sc_state &= ~PMS_ASLP; + splx(s); + return error; + } + } + splx(s); + + /* Transfer as many chunks as possible. */ + + while (sc->sc_q.c_cc > 0 && uio->uio_resid > 0) { + length = min(sc->sc_q.c_cc, uio->uio_resid); + if (length > sizeof(buffer)) + length = sizeof(buffer); + + /* Remove a small chunk from the input queue. */ + (void) q_to_b(&sc->sc_q, buffer, length); + + /* Copy the data to the user process. */ + if ((error = uiomove(buffer, length, uio)) != 0) + break; + } + + return error; +} + +int +pmsioctl(dev, cmd, addr, flag, p) + dev_t dev; + u_long cmd; + caddr_t addr; + int flag; + struct proc *p; +{ + struct opms_softc *sc = opms_cd.cd_devs[PMSUNIT(dev)]; + struct mouseinfo info; + int s; + int error; + + switch (cmd) { + case MOUSEIOCREAD: + s = spltty(); + + info.status = sc->sc_status; + if (sc->sc_x || sc->sc_y) + info.status |= MOVEMENT; + + if (sc->sc_x > 127) + info.xmotion = 127; + else if (sc->sc_x < -127) + /* Bounding at -127 avoids a bug in XFree86. */ + info.xmotion = -127; + else + info.xmotion = sc->sc_x; + + if (sc->sc_y > 127) + info.ymotion = 127; + else if (sc->sc_y < -127) + info.ymotion = -127; + else + info.ymotion = sc->sc_y; + + /* Reset historical information. */ + sc->sc_x = sc->sc_y = 0; + sc->sc_status &= ~BUTCHNGMASK; + ndflush(&sc->sc_q, sc->sc_q.c_cc); + + splx(s); + error = copyout(&info, addr, sizeof(struct mouseinfo)); + break; + + default: + error = EINVAL; + break; + } + + return error; +} + +/* Masks for the first byte of a packet */ +#define PS2LBUTMASK 0x01 +#define PS2RBUTMASK 0x02 +#define PS2MBUTMASK 0x04 + +void +opmsinput(arg, data) + void *arg; + int data; +{ + struct opms_softc *sc = arg; + static int state = 0; + static u_char buttons; + u_char changed; + static int8_t dx, dy; + u_char buffer[5]; + + if ((sc->sc_state & PMS_OPEN) == 0) { + /* Interrupts are not expected. Discard the byte. */ + return; + } + + switch (state) { + + case 0: + buttons = data; + if ((buttons & 0xc0) == 0) + ++state; + break; + + case 1: + dx = data; + /* Bounding at -127 avoids a bug in XFree86. */ + dx = (dx == -128) ? -127 : dx; + ++state; + break; + + case 2: + dy = data; + dy = (dy == -128) ? -127 : dy; + state = 0; + + buttons = ((buttons & PS2LBUTMASK) << 2) | + ((buttons & (PS2RBUTMASK | PS2MBUTMASK)) >> 1); + changed = ((buttons ^ sc->sc_status) & BUTSTATMASK) << 3; + sc->sc_status = buttons | (sc->sc_status & ~BUTSTATMASK) | changed; + + if (dx || dy || changed) { + /* Update accumulated movements. */ + sc->sc_x += dx; + sc->sc_y += dy; + + /* Add this event to the queue. */ + buffer[0] = 0x80 | (buttons ^ BUTSTATMASK); + buffer[1] = dx; + buffer[2] = dy; + buffer[3] = buffer[4] = 0; + (void) b_to_q(buffer, sizeof buffer, &sc->sc_q); + + if (sc->sc_state & PMS_ASLP) { + sc->sc_state &= ~PMS_ASLP; + wakeup((caddr_t)sc); + } + selwakeup(&sc->sc_rsel); + } + + break; + } +} + +int +pmspoll(dev, events, p) + dev_t dev; + int events; + struct proc *p; +{ + struct opms_softc *sc = opms_cd.cd_devs[PMSUNIT(dev)]; + int revents = 0; + int s = spltty(); + + if (events & (POLLIN | POLLRDNORM)) { + if (sc->sc_q.c_cc > 0) + revents |= events & (POLLIN | POLLRDNORM); + else + selrecord(p, &sc->sc_rsel); + } + + splx(s); + return (revents); +}