OpenSolaris_b135/uts/sun/io/ms.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Mouse streams module.
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/signal.h>
#include <sys/termios.h>
#include <sys/termio.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/tty.h>
#include <sys/strtty.h>
#include <sys/time.h>
#include <sys/kmem.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/errno.h>
#include <sys/debug.h>
#include <sys/vuid_event.h>
#include <sys/msreg.h>
#include <sys/msio.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
/*
* This is the loadable module wrapper.
*/
static struct streamtab ms_info;
static struct fmodsw fsw = {
"ms",
&ms_info,
D_MP | D_MTPERMOD
};
/*
* Module linkage information for the kernel.
*/
static struct modlstrmod modlstrmod = {
&mod_strmodops, "streams module for mouse", &fsw
};
static struct modlinkage modlinkage = {
MODREV_1, &modlstrmod, NULL
};
int
_init(void)
{
return (mod_install(&modlinkage));
}
int
_fini(void)
{
return (EBUSY);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
#define BYTECLIP(x) (char)((x) > 127 ? 127 : ((x) < -128 ? -128 : (x)))
struct msdata {
struct ms_softc msd_softc;
queue_t *msd_readq; /* upstream read queue */
mblk_t *msd_iocpending; /* "ioctl" awaiting buffer */
int msd_flags; /* random flags */
int msd_iocid; /* ID of "ioctl" being waited for */
int msd_iocerror; /* error return from "ioctl" */
char msd_oldbutt; /* button state at last sample */
short msd_state; /* state counter for input routine */
short msd_jitter;
timeout_id_t msd_timeout_id; /* id returned by timeout() */
bufcall_id_t msd_reioctl_id; /* id returned by bufcall() */
bufcall_id_t msd_resched_id; /* id returned by bufcall() */
int msd_baud_rate; /* mouse baud rate */
int msd_rcnt_baud_chng; /* baud changed recently */
int msd_data_pkt_cnt; /* no of packets since last baud change */
int msd_qenable_more; /* enable msrserv if baud changed recently */
int msd_hold_baud_stup; /* # of packets to wait for baud setup */
};
#define MS_OPEN 0x00000001 /* mouse is open for business */
#define MS_IOCWAIT 0x00000002 /* "open" waiting for ioctl to finish */
#define MS_IOCTOSS 0x00000004 /* Toss ioctl returns */
/*
* Input routine states. See msinput().
*/
#define MS_WAIT_BUTN 0
#define MS_WAIT_X 1
#define MS_WAIT_Y 2
#define MS_WAIT_X2 3
#define MS_WAIT_Y2 4
#define MS_PKT_SZ 5
/*
* This module supports mice runing at 1200, 4800 and 9600 baud rates.
*
* If there was a baud change recently, then we want to wait
* for some time to make sure that no other baud change is on its way.
* If the second baud rate change is done then the packets between
* changes are garbage and are thrown away during the baud change.
*/
/*
* The following #defines were tuned by experimentations.
*/
#define MS_HOLD_BAUD_STUP 48
#define MS_CNT_TOB1200 7
static int ms_overrun_msg; /* Message when overrun circular buffer */
static int ms_overrun_cnt; /* Increment when overrun circular buffer */
/*
* Max pixel delta of jitter controlled. As this number increases the jumpiness
* of the ms increases, i.e., the coarser the motion for medium speeds.
*/
static int ms_jitter_thresh = 0;
/*
* ms_jitter_thresh is the maximum number of jitters suppressed. Thus,
* hz/ms_jitter_thresh is the maximum interval of jitters suppressed. As
* ms_jitter_thresh increases, a wider range of jitter is suppressed. However,
* the more inertia the mouse seems to have, i.e., the slower the mouse is to
* react.
*/
/*
* Measure how many (ms_speed_count) ms deltas exceed threshold
* (ms_speedlimit). If ms_speedlaw then throw away deltas over ms_speedlimit.
* This is to keep really bad mice that jump around from getting too far.
*/
static int ms_speedlimit = 48;
static int ms_speedlaw = 0;
static int ms_speed_count;
static int msjitterrate = 12;
#define JITTER_TIMEOUT (hz/msjitterrate)
static clock_t msjittertimeout; /* Timeout used when mstimeout in effect */
/*
* Mouse buffer size in bytes. Place here as variable so that one could
* massage it using adb if it turns out to be too small.
*/
static int MS_BUF_BYTES = 4096;
static int MS_DEBUG;
/*
* Most of these should be "void", but the people who defined the "streams"
* data structures for S5 didn't understand data types.
*/
static int msopen(queue_t *q, dev_t *devp, int oflag, int sflag,
cred_t *credp);
static int msclose(queue_t *q, int flag, cred_t *credp);
static void mswput(queue_t *q, mblk_t *mp);
static void msrput(queue_t *q, mblk_t *mp);
static void msrserv(queue_t *q);
static struct module_info msmiinfo = {
0,
"ms",
0,
INFPSZ,
2048,
128
};
static struct qinit msrinit = {
(int (*)())msrput,
(int (*)())msrserv,
msopen,
msclose,
(int (*)())NULL,
&msmiinfo
};
static struct module_info msmoinfo = {
0,
"ms",
0,
INFPSZ,
2048,
128
};
static struct qinit mswinit = {
(int (*)())mswput,
(int (*)())NULL,
msopen,
msclose,
(int (*)())NULL,
&msmoinfo
};
static struct streamtab ms_info = {
&msrinit,
&mswinit,
NULL,
NULL,
};
static void msresched(void *);
static void msreioctl(void *);
static void msioctl(queue_t *q, mblk_t *mp);
static int ms_getparms(register Ms_parms *data);
static int ms_setparms(register Ms_parms *data);
static void msflush(struct msdata *msd);
static void msinput(/* struct msdata *msd, char c */); /* XXX */
static void msincr(void *);
/*
* Dummy qbufcall callback routine used by open and close.
* The framework will wake up qwait_sig when we return from
* this routine (as part of leaving the perimeters.)
* (The framework enters the perimeters before calling the qbufcall() callback
* and leaves the perimeters after the callback routine has executed. The
* framework performs an implicit wakeup of any thread in qwait/qwait_sig
* when it leaves the perimeter. See qwait(9E).)
*/
/* ARGSUSED */
static void
dummy_callback(void *arg)
{}
/*
* Open a mouse.
*/
/*ARGSUSED*/
static int
msopen(q, devp, oflag, sflag, credp)
queue_t *q;
dev_t *devp;
int oflag, sflag;
cred_t *credp;
{
register struct mousebuf *b;
register struct ms_softc *ms;
register struct msdata *msd;
mblk_t *mp;
mblk_t *datap;
register struct iocblk *iocb;
register struct termios *cb;
int error = 0;
if (q->q_ptr != NULL)
return (0); /* already attached */
if (sflag != MODOPEN)
return (EINVAL);
/*
* Allocate an msdata structure.
*/
msd = kmem_zalloc(sizeof (struct msdata), KM_SLEEP);
/*
* Set up queue pointers, so that the "put" procedure will accept
* the reply to the "ioctl" message we send down.
*/
q->q_ptr = msd;
WR(q)->q_ptr = msd;
qprocson(q);
/*
* Setup tty modes.
*/
while ((mp = mkiocb(TCSETSF)) == NULL) {
bufcall_id_t id = qbufcall(q, sizeof (struct iocblk),
BPRI_HI, dummy_callback, NULL);
if (!qwait_sig(q)) {
qunbufcall(q, id);
kmem_free(msd, sizeof (struct msdata));
qprocsoff(q);
return (EINTR);
}
}
while ((datap = allocb(sizeof (struct termios), BPRI_HI)) == NULL) {
bufcall_id_t id = qbufcall(q, sizeof (struct termios),
BPRI_HI, dummy_callback, NULL);
if (!qwait_sig(q)) {
qunbufcall(q, id);
freemsg(mp);
kmem_free(msd, sizeof (struct msdata));
qprocsoff(q);
return (EINTR);
}
}
iocb = (struct iocblk *)mp->b_rptr;
iocb->ioc_count = sizeof (struct termios);
cb = (struct termios *)datap->b_wptr;
cb->c_iflag = 0;
cb->c_oflag = 0;
cb->c_cflag = CREAD|CS8|B9600;
cb->c_lflag = 0;
bzero(cb->c_cc, NCCS);
datap->b_wptr += sizeof (*cb);
datap->b_datap->db_type = M_DATA;
mp->b_cont = datap;
msd->msd_flags |= MS_IOCWAIT; /* indicate that we're waiting for */
msd->msd_iocid = iocb->ioc_id; /* this response */
msd->msd_baud_rate = B9600;
msd->msd_rcnt_baud_chng = 1;
msd->msd_data_pkt_cnt = 0;
msd->msd_qenable_more = 0;
msd->msd_hold_baud_stup = MS_HOLD_BAUD_STUP;
putnext(WR(q), mp);
ms = &msd->msd_softc;
/*
* Now wait for it. Let our read queue put routine wake us up
* when it arrives.
*/
while (msd->msd_flags & MS_IOCWAIT) {
if (!qwait_sig(q)) {
error = EINTR;
goto error;
}
}
if ((error = msd->msd_iocerror) != 0)
goto error;
/*
* Set up private data.
*/
msd->msd_state = MS_WAIT_BUTN;
msd->msd_readq = q;
msd->msd_iocpending = NULL;
/*
* Allocate buffer and initialize data.
*/
if (ms->ms_buf == 0) {
ms->ms_bufbytes = MS_BUF_BYTES;
b = kmem_zalloc((uint_t)ms->ms_bufbytes, KM_SLEEP);
b->mb_size = 1 + (ms->ms_bufbytes - sizeof (struct mousebuf))
/ sizeof (struct mouseinfo);
ms->ms_buf = b;
ms->ms_vuidaddr = VKEY_FIRST;
msjittertimeout = JITTER_TIMEOUT;
msflush(msd);
}
msd->msd_flags = MS_OPEN;
/*
* Tell the module below us that it should return input immediately.
*/
(void) putnextctl1(WR(q), M_CTL, MC_SERVICEIMM);
return (0);
error:
qprocsoff(q);
kmem_free(msd, sizeof (struct msdata));
return (error);
}
/*
* Close the mouse
*/
/* ARGSUSED1 */
static int
msclose(q, flag, credp)
queue_t *q;
int flag;
cred_t *credp;
{
register struct msdata *msd = (struct msdata *)q->q_ptr;
register struct ms_softc *ms;
/*
* Tell the module below us that it need not return input immediately.
*/
(void) putnextctl1(q, M_CTL, MC_SERVICEDEF);
qprocsoff(q);
/*
* Since we're about to destroy our private data, turn off
* our open flag first, so we don't accept any more input
* and try to use that data.
*/
msd->msd_flags = 0;
if (msd->msd_jitter) {
(void) quntimeout(q, msd->msd_timeout_id);
msd->msd_jitter = 0;
}
if (msd->msd_reioctl_id) {
qunbufcall(q, msd->msd_reioctl_id);
msd->msd_reioctl_id = 0;
}
if (msd->msd_resched_id) {
qunbufcall(q, msd->msd_resched_id);
msd->msd_resched_id = 0;
}
if (msd->msd_iocpending != NULL) {
/*
* We were holding an "ioctl" response pending the
* availability of an "mblk" to hold data to be passed up;
* another "ioctl" came through, which means that "ioctl"
* must have timed out or been aborted.
*/
freemsg(msd->msd_iocpending);
msd->msd_iocpending = NULL;
}
ms = &msd->msd_softc;
/* Free mouse buffer */
if (ms->ms_buf != NULL)
kmem_free(ms->ms_buf, (uint_t)ms->ms_bufbytes);
/* Free msdata structure */
kmem_free((void *)msd, sizeof (*msd));
return (0);
}
/*
* Read queue service routine.
* Turn buffered mouse events into stream messages.
*/
static void
msrserv(q)
register queue_t *q;
{
struct msdata *msd = (struct msdata *)q->q_ptr;
register struct ms_softc *ms;
register struct mousebuf *b;
register struct mouseinfo *mi;
register int button_number;
register int hwbit;
mblk_t *bp;
/*
* Handle the case of a queue which is backenabled before
* initialization is complete.
*/
if (!(msd->msd_flags & MS_OPEN)) {
return;
}
ms = &msd->msd_softc;
b = ms->ms_buf;
if (msd->msd_rcnt_baud_chng && ms->ms_oldoff != b->mb_off) {
int no_pkt = b->mb_off - ms->ms_oldoff;
int i;
no_pkt = no_pkt > 0 ? no_pkt : (b->mb_size - no_pkt);
if (no_pkt < msd->msd_hold_baud_stup) {
msd->msd_qenable_more = 1;
return;
} else {
/*
* throw away packets in beginning (mostly garbage)
*/
for (i = 0; i < msd->msd_hold_baud_stup; i++) {
ms->ms_oldoff++; /* next event */
/* circular buffer wraparound */
if (ms->ms_oldoff >= b->mb_size)
ms->ms_oldoff = 0;
}
msd->msd_rcnt_baud_chng = 0;
msd->msd_data_pkt_cnt = 0;
msd->msd_qenable_more = 0;
}
}
while (canputnext(q) && ms->ms_oldoff != b->mb_off) {
mi = &b->mb_info[ms->ms_oldoff];
switch (ms->ms_readformat) {
case MS_3BYTE_FORMAT: {
register char *cp;
if ((bp = allocb(3, BPRI_HI)) != NULL) {
cp = (char *)bp->b_wptr;
*cp++ = 0x80 | mi->mi_buttons;
/* Update read buttons */
ms->ms_prevbuttons = mi->mi_buttons;
*cp++ = mi->mi_x;
*cp++ = -mi->mi_y;
/* lower pri to avoid mouse droppings */
bp->b_wptr = (uchar_t *)cp;
putnext(q, bp);
} else {
if (msd->msd_resched_id)
qunbufcall(q, msd->msd_resched_id);
msd->msd_resched_id = qbufcall(q, 3, BPRI_HI,
msresched, msd);
if (msd->msd_resched_id == 0)
return; /* try again later */
/* bufcall failed; just pitch this event */
/* or maybe flush queue? */
}
ms->ms_oldoff++; /* next event */
/* circular buffer wraparound */
if (ms->ms_oldoff >= b->mb_size)
ms->ms_oldoff = 0;
break;
}
case MS_VUID_FORMAT: {
register Firm_event *fep;
bp = NULL;
switch (ms->ms_eventstate) {
case EVENT_BUT3:
case EVENT_BUT2:
case EVENT_BUT1:
/* Test the button. Send an event if it changed. */
button_number = ms->ms_eventstate - EVENT_BUT1;
hwbit = MS_HW_BUT1 >> button_number;
if ((ms->ms_prevbuttons & hwbit) !=
(mi->mi_buttons & hwbit)) {
if ((bp = allocb(sizeof (Firm_event),
BPRI_HI)) != NULL) {
fep = (Firm_event *)bp->b_wptr;
fep->id = vuid_id_addr(ms->ms_vuidaddr) |
vuid_id_offset(BUT(1) + button_number);
fep->pair_type = FE_PAIR_NONE;
fep->pair = 0;
/* Update read buttons and set value */
if (mi->mi_buttons & hwbit) {
fep->value = 0;
ms->ms_prevbuttons |= hwbit;
} else {
fep->value = 1;
ms->ms_prevbuttons &= ~hwbit;
}
fep->time = mi->mi_time;
} else {
if (msd->msd_resched_id)
qunbufcall(q, msd->msd_resched_id);
msd->msd_resched_id = qbufcall(q,
sizeof (Firm_event),
BPRI_HI, msresched, msd);
if (msd->msd_resched_id == 0)
return; /* try again later */
/* bufcall failed; just pitch this event */
/* or maybe flush queue? */
ms->ms_eventstate = EVENT_X;
}
}
break;
case EVENT_Y:
/* Send y if changed. */
if (mi->mi_y != 0) {
if ((bp = allocb(sizeof (Firm_event),
BPRI_HI)) != NULL) {
fep = (Firm_event *)bp->b_wptr;
fep->id = vuid_id_addr(ms->ms_vuidaddr) |
vuid_id_offset(LOC_Y_DELTA);
fep->pair_type = FE_PAIR_ABSOLUTE;
fep->pair = (uchar_t)LOC_Y_ABSOLUTE;
fep->value = -mi->mi_y;
fep->time = mi->mi_time;
} else {
if (msd->msd_resched_id)
qunbufcall(q, msd->msd_resched_id);
msd->msd_resched_id = qbufcall(q,
sizeof (Firm_event),
BPRI_HI, msresched, msd);
if (msd->msd_resched_id == 0)
return; /* try again later */
/* bufcall failed; just pitch this event */
/* or maybe flush queue? */
ms->ms_eventstate = EVENT_X;
}
}
break;
case EVENT_X:
/* Send x if changed. */
if (mi->mi_x != 0) {
if ((bp = allocb(sizeof (Firm_event),
BPRI_HI)) != NULL) {
fep = (Firm_event *)bp->b_wptr;
fep->id = vuid_id_addr(ms->ms_vuidaddr) |
vuid_id_offset(LOC_X_DELTA);
fep->pair_type = FE_PAIR_ABSOLUTE;
fep->pair = (uchar_t)LOC_X_ABSOLUTE;
fep->value = mi->mi_x;
fep->time = mi->mi_time;
} else {
if (msd->msd_resched_id)
qunbufcall(q, msd->msd_resched_id);
msd->msd_resched_id = qbufcall(q,
sizeof (Firm_event),
BPRI_HI, msresched, msd);
if (msd->msd_resched_id == 0)
return; /* try again later */
/* bufcall failed; just pitch this event */
/* or maybe flush queue? */
ms->ms_eventstate = EVENT_X;
}
}
break;
}
if (bp != NULL) {
/* lower pri to avoid mouse droppings */
bp->b_wptr += sizeof (Firm_event);
putnext(q, bp);
}
if (ms->ms_eventstate == EVENT_X) {
ms->ms_eventstate = EVENT_BUT3;
ms->ms_oldoff++; /* next event */
/* circular buffer wraparound */
if (ms->ms_oldoff >= b->mb_size)
ms->ms_oldoff = 0;
} else
ms->ms_eventstate--;
}
}
}
}
static void
msresched(void *msdptr)
{
queue_t *q;
struct msdata *msd = msdptr;
msd->msd_resched_id = 0;
if ((q = msd->msd_readq) != 0)
qenable(q); /* run the service procedure */
}
/*
* Line discipline output queue put procedure: handles M_IOCTL
* messages.
*/
static void
mswput(q, mp)
register queue_t *q;
register mblk_t *mp;
{
/*
* Process M_FLUSH, and some M_IOCTL, messages here; pass
* everything else down.
*/
switch (mp->b_datap->db_type) {
case M_FLUSH:
if (*mp->b_rptr & FLUSHW)
flushq(q, FLUSHDATA);
if (*mp->b_rptr & FLUSHR)
flushq(RD(q), FLUSHDATA);
default:
putnext(q, mp); /* pass it down the line */
break;
case M_IOCTL:
msioctl(q, mp);
break;
}
}
static void
msreioctl(void *msdptr)
{
struct msdata *msd = msdptr;
queue_t *q;
mblk_t *mp;
msd->msd_reioctl_id = 0;
q = msd->msd_readq;
if ((mp = msd->msd_iocpending) != NULL) {
msd->msd_iocpending = NULL; /* not pending any more */
msioctl(WR(q), mp);
}
}
static void
msioctl(q, mp)
register queue_t *q;
register mblk_t *mp;
{
struct msdata *msd;
register struct ms_softc *ms;
register struct iocblk *iocp;
Vuid_addr_probe *addr_probe;
uint_t ioctlrespsize;
int err = 0;
mblk_t *datap;
msd = (struct msdata *)q->q_ptr;
if (msd == NULL) {
err = EINVAL;
goto out;
}
ms = &msd->msd_softc;
iocp = (struct iocblk *)mp->b_rptr;
if (MS_DEBUG)
printf("mswput(M_IOCTL,%x)\n", iocp->ioc_cmd);
switch (iocp->ioc_cmd) {
case VUIDSFORMAT:
err = miocpullup(mp, sizeof (int));
if (err != 0)
break;
if (*(int *)mp->b_cont->b_rptr == ms->ms_readformat)
break;
ms->ms_readformat = *(int *)mp->b_cont->b_rptr;
/*
* Flush mouse buffer because the messages upstream of us
* are in the old format.
*/
msflush(msd);
break;
case VUIDGFORMAT:
if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
ioctlrespsize = sizeof (int);
goto allocfailure;
}
*(int *)datap->b_wptr = ms->ms_readformat;
datap->b_wptr += sizeof (int);
if (mp->b_cont != NULL)
freemsg(mp->b_cont);
mp->b_cont = datap;
iocp->ioc_count = sizeof (int);
break;
case VUIDSADDR:
case VUIDGADDR:
err = miocpullup(mp, sizeof (Vuid_addr_probe));
if (err != 0)
break;
addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr;
if (addr_probe->base != VKEY_FIRST) {
err = ENODEV;
break;
}
if (iocp->ioc_cmd == VUIDSADDR)
ms->ms_vuidaddr = addr_probe->data.next;
else
addr_probe->data.current = ms->ms_vuidaddr;
break;
case MSIOGETPARMS:
if (MS_DEBUG)
printf("ms_getparms\n");
if ((datap = allocb(sizeof (Ms_parms), BPRI_HI)) == NULL) {
ioctlrespsize = sizeof (Ms_parms);
goto allocfailure;
}
err = ms_getparms((Ms_parms *)datap->b_wptr);
datap->b_wptr += sizeof (Ms_parms);
if (mp->b_cont != NULL)
freemsg(mp->b_cont);
mp->b_cont = datap;
iocp->ioc_count = sizeof (Ms_parms);
break;
case MSIOSETPARMS:
if (MS_DEBUG)
printf("ms_setparms\n");
err = miocpullup(mp, sizeof (Ms_parms));
if (err != 0)
break;
err = ms_setparms((Ms_parms *)mp->b_cont->b_rptr);
break;
default:
putnext(q, mp); /* pass it down the line */
return;
}
out:
if (err != 0)
miocnak(q, mp, 0, err);
else {
iocp->ioc_rval = 0;
iocp->ioc_error = 0; /* brain rot */
mp->b_datap->db_type = M_IOCACK;
qreply(q, mp);
}
return;
allocfailure:
/*
* We needed to allocate something to handle this "ioctl", but
* couldn't; save this "ioctl" and arrange to get called back when
* it's more likely that we can get what we need.
* If there's already one being saved, throw it out, since it
* must have timed out.
*/
if (msd->msd_iocpending != NULL)
freemsg(msd->msd_iocpending);
msd->msd_iocpending = mp;
if (msd->msd_reioctl_id)
qunbufcall(q, msd->msd_reioctl_id);
msd->msd_reioctl_id = qbufcall(q, ioctlrespsize, BPRI_HI,
msreioctl, msd);
}
static int
ms_getparms(data)
register Ms_parms *data;
{
data->jitter_thresh = ms_jitter_thresh;
data->speed_law = ms_speedlaw;
data->speed_limit = ms_speedlimit;
return (0);
}
static int
ms_setparms(data)
register Ms_parms *data;
{
ms_jitter_thresh = data->jitter_thresh;
ms_speedlaw = data->speed_law;
ms_speedlimit = data->speed_limit;
return (0);
}
static void
msflush(msd)
register struct msdata *msd;
{
register struct ms_softc *ms = &msd->msd_softc;
register queue_t *q;
ms->ms_oldoff = 0;
ms->ms_eventstate = EVENT_BUT3;
ms->ms_buf->mb_off = 0;
ms->ms_prevbuttons = MS_HW_BUT1 | MS_HW_BUT2 | MS_HW_BUT3;
msd->msd_oldbutt = ms->ms_prevbuttons;
if ((q = msd->msd_readq) != NULL && q->q_next != NULL)
(void) putnextctl1(q, M_FLUSH, FLUSHR);
}
/*
* Mouse read queue put procedure.
*/
static void
msrput(q, mp)
register queue_t *q;
register mblk_t *mp;
{
register struct msdata *msd = (struct msdata *)q->q_ptr;
register mblk_t *bp;
register char *readp;
register mblk_t *imp;
register mblk_t *datap;
register struct iocblk *iocb;
register struct termios *cb;
struct iocblk *iocp;
if (msd == 0)
return;
switch (mp->b_datap->db_type) {
case M_FLUSH:
if (*mp->b_rptr & FLUSHW)
flushq(WR(q), FLUSHDATA);
if (*mp->b_rptr & FLUSHR)
flushq(q, FLUSHDATA);
default:
putnext(q, mp);
return;
case M_BREAK:
if (msd->msd_flags & MS_IOCTOSS) {
freemsg(mp);
return;
}
if (msd->msd_rcnt_baud_chng && msd->msd_data_pkt_cnt == 0) {
freemsg(mp);
return;
}
/*
* If we are sampling a 4800 baud mouse at 9600,
* we want to wait for long time because there is no
* fixed timeframe for receiving break. If we are sampling
* a 1200 baud mouse at 4800 or 9600 baud rate then
* it is guaranteed that break will be received very soon.
*/
if (msd->msd_rcnt_baud_chng) {
switch (msd->msd_baud_rate) {
case B9600:
msd->msd_hold_baud_stup = MS_HOLD_BAUD_STUP/2;
msd->msd_baud_rate = B4800;
break;
case B4800:
if (msd->msd_data_pkt_cnt <= MS_CNT_TOB1200) {
msd->msd_hold_baud_stup =
MS_HOLD_BAUD_STUP/6;
msd->msd_baud_rate = B1200;
} else {
msd->msd_hold_baud_stup =
MS_HOLD_BAUD_STUP;
msd->msd_baud_rate = B9600;
}
break;
case B1200:
default:
msd->msd_hold_baud_stup = MS_HOLD_BAUD_STUP;
msd->msd_baud_rate = B9600;
break;
}
} else {
msd->msd_hold_baud_stup = MS_HOLD_BAUD_STUP;
msd->msd_baud_rate = B9600;
}
/*
* Change baud rate.
*/
if ((imp = mkiocb(TCSETSF)) == NULL) {
return;
}
if ((datap = allocb(sizeof (struct termios),
BPRI_HI)) == NULL) {
freemsg(imp);
return;
}
iocb = (struct iocblk *)imp->b_rptr;
iocb->ioc_count = sizeof (struct termios);
cb = (struct termios *)datap->b_rptr;
cb->c_iflag = 0;
cb->c_oflag = 0;
cb->c_cflag = CREAD|CS8|msd->msd_baud_rate;
cb->c_lflag = 0;
bzero(cb->c_cc, NCCS);
datap->b_wptr += sizeof (*cb);
datap->b_datap->db_type = M_DATA;
imp->b_cont = datap;
msd->msd_flags |= MS_IOCTOSS|MS_IOCWAIT;
msd->msd_iocid = iocb->ioc_id;
msflush(msd);
flushq(q, FLUSHALL);
putnext(WR(q), imp);
freemsg(mp);
msd->msd_rcnt_baud_chng = 1;
msd->msd_data_pkt_cnt = 0;
if (MS_DEBUG)
printf("baud %x\n", msd->msd_baud_rate);
return;
case M_IOCACK:
case M_IOCNAK:
/*
* If we are doing an "ioctl" ourselves, check if this
* is the reply to that code. If so, wake up the
* "open" routine, and toss the reply, otherwise just
* pass it up.
*/
iocp = (struct iocblk *)mp->b_rptr;
if (!(msd->msd_flags & MS_IOCWAIT) ||
iocp->ioc_id != msd->msd_iocid) {
/*
* This isn't the reply we're looking for. Move along.
*/
putnext(q, mp);
} else {
msd->msd_flags &= ~MS_IOCWAIT;
msd->msd_iocerror = iocp->ioc_error;
/*
* If we sent down a request to change the baud rate.
* This is the reply. Just ignore it.
*/
if (msd->msd_flags & MS_IOCTOSS) {
msd->msd_flags &= ~MS_IOCTOSS;
msflush(msd);
flushq(q, FLUSHALL);
}
freemsg(mp);
}
return;
case M_DATA:
if ((msd->msd_flags & MS_IOCTOSS) ||
!(msd->msd_flags & MS_OPEN)) {
freemsg(mp);
return;
}
break;
}
/*
* A data message, consisting of bytes from the mouse.
* Hand each byte to our input routine.
*/
bp = mp;
do {
readp = (char *)bp->b_rptr;
while (readp < (char *)bp->b_wptr) {
if (msd->msd_rcnt_baud_chng)
msd->msd_data_pkt_cnt++;
msinput(msd, *readp++);
}
bp->b_rptr = (unsigned char *)readp;
} while ((bp = bp->b_cont) != NULL); /* next block, if any */
freemsg(mp);
}
/*
* Mouse input routine; process a byte received from a mouse and
* assemble into a mouseinfo message for the window system.
*
* The MSC mice send a five-byte packet organized as
* button, dx, dy, dx, dy
* where dx and dy can be any signed byte value. The mouseinfo message
* is organized as
* dx, dy, button, timestamp
* Our strategy is to add up the 2 dx and the 2 dy in the five-byte
* packet, then send the mouseinfo message up.
*
* Basic algorithm: throw away bytes until we get a [potential]
* button byte. Collect button; Collect dx1; Collect dy1; Collect dx2
* and add it to dx1; Collect dy2 and add it to dy1; Send button,
* dx, dy, timestamp.
*
* Watch out for overflow!
*/
static void
msinput(msd, c)
register struct msdata *msd;
char c;
{
register struct ms_softc *ms;
register struct mousebuf *b;
register struct mouseinfo *mi;
register int jitter_radius;
register int temp;
ms = &msd->msd_softc;
b = ms->ms_buf;
if (b == NULL)
return;
mi = &b->mb_info[b->mb_off];
switch (msd->msd_state) {
case MS_WAIT_BUTN:
if ((c & 0xf8) != 0x80) {
if (MS_DEBUG)
printf("Mouse input char %x discarded\n",
(int)c & 0xff);
if (msd->msd_rcnt_baud_chng) {
msflush(msd);
flushq(msd->msd_readq, FLUSHALL);
msd->msd_hold_baud_stup++;
}
return;
}
/*
* Probably a button byte.
* Lower 3 bits are left, middle, right.
*/
mi->mi_buttons = c & (MS_HW_BUT1 | MS_HW_BUT2 | MS_HW_BUT3);
break;
case MS_WAIT_X:
/*
* Delta X byte. Add the delta X from this sample to
* the delta X we're accumulating in the current event.
*/
temp = (int)(mi->mi_x + c);
mi->mi_x = BYTECLIP(temp);
uniqtime32(&mi->mi_time); /* record time when sample arrived */
break;
case MS_WAIT_Y:
/*
* Delta Y byte. Add the delta Y from this sample to
* the delta Y we're accumulating in the current event.
* (Subtract, actually, because the mouse reports
* increasing Y up the screen.)
*/
temp = (int)(mi->mi_y - c);
mi->mi_y = BYTECLIP(temp);
break;
case MS_WAIT_X2:
/*
* Second delta X byte.
*/
temp = (int)(mi->mi_x + c);
mi->mi_x = BYTECLIP(temp);
uniqtime32(&mi->mi_time);
break;
case MS_WAIT_Y2:
/*
* Second delta Y byte.
*/
temp = (int)(mi->mi_y - c);
mi->mi_y = BYTECLIP(temp);
break;
}
/*
* Done yet?
*/
if (msd->msd_state == MS_WAIT_Y2)
msd->msd_state = MS_WAIT_BUTN; /* BONG. Start again. */
else {
msd->msd_state += 1;
return;
}
if (msd->msd_jitter) {
(void) quntimeout(msd->msd_readq, msd->msd_timeout_id);
msd->msd_jitter = 0;
}
if (mi->mi_buttons == msd->msd_oldbutt) {
/*
* Buttons did not change; did position?
*/
if (mi->mi_x == 0 && mi->mi_y == 0) {
/* no, position did not change - boring event */
return;
}
/*
* Did the mouse move more than the jitter threshhold?
*/
jitter_radius = ms_jitter_thresh;
if (ABS((int)mi->mi_x) <= jitter_radius &&
ABS((int)mi->mi_y) <= jitter_radius) {
/*
* Mouse moved less than the jitter threshhold.
* Don't indicate an event; keep accumulating motions.
* After "msjittertimeout" ticks expire, treat
* the accumulated delta as the real delta.
*/
msd->msd_jitter = 1;
msd->msd_timeout_id = qtimeout(msd->msd_readq,
msincr, msd, msjittertimeout);
return;
}
}
msd->msd_oldbutt = mi->mi_buttons;
msincr(msd);
}
/*
* Increment the mouse sample pointer.
* Called either immediately after a sample or after a jitter timeout.
*/
static void
msincr(void *arg)
{
struct msdata *msd = arg;
register struct ms_softc *ms = &msd->msd_softc;
register struct mousebuf *b;
register struct mouseinfo *mi;
char oldbutt;
register short xc, yc;
register int wake;
register int speedlimit = ms_speedlimit;
register int xabs, yabs;
/*
* No longer waiting for jitter timeout
*/
msd->msd_jitter = 0;
b = ms->ms_buf;
if (b == NULL)
return;
mi = &b->mb_info[b->mb_off];
if (ms_speedlaw) {
xabs = ABS((int)mi->mi_x);
yabs = ABS((int)mi->mi_y);
if (xabs > speedlimit || yabs > speedlimit)
ms_speed_count++;
if (xabs > speedlimit)
mi->mi_x = 0;
if (yabs > speedlimit)
mi->mi_y = 0;
}
oldbutt = mi->mi_buttons;
xc = yc = 0;
/* See if we need to wake up anyone waiting for input */
wake = b->mb_off == ms->ms_oldoff;
/* Adjust circular buffer pointer */
if (++b->mb_off >= b->mb_size) {
b->mb_off = 0;
mi = b->mb_info;
} else {
mi++;
}
/*
* If over-took read index then flush buffer so that mouse state
* is consistent.
*/
if (b->mb_off == ms->ms_oldoff) {
if (ms_overrun_msg)
cmn_err(CE_WARN,
"Mouse buffer flushed when overrun.\n");
msflush(msd);
ms_overrun_cnt++;
mi = b->mb_info;
}
/* Remember current buttons and fractional part of x & y */
mi->mi_buttons = oldbutt;
mi->mi_x = (char)xc;
mi->mi_y = (char)yc;
if (wake || msd->msd_qenable_more)
qenable(msd->msd_readq); /* run the service procedure */
}