File: [local] / src / usr.sbin / moused / Attic / moused.c (download)
Revision 1.6, Fri Jan 19 17:53:16 2001 UTC (23 years, 4 months ago) by deraadt
Branch: MAIN
CVS Tags: OPENBSD_2_9_BASE, OPENBSD_2_9
Changes since 1.5: +5 -5 lines
mark remaining signal races which are difficult to fix
|
/*
* Copyright (c) 2000 Jean-Baptiste Marchand, Julien Montagne and Jerome Verdon
*
* Copyright (c) 1998 by Kazutaka Yokota
*
* Copyright (c) 1995 Michael Smith
*
* Copyright (c) 1993 by David Dawes <dawes@xfree86.org>
*
* Copyright (c) 1990,91 by Thomas Roell, Dinkelscherben, Germany.
*
* All rights reserved.
*
* Most of this code was taken from the FreeBSD moused daemon, written by
* Michael Smith. The FreeBSD moused daemon already contained code from the
* Xfree Project, written by David Dawes and Thomas Roell and Kazutaka Yokota.
*
* Adaptation to OpenBSD was done by Jean-Baptiste Marchand, Julien Montagne
* and Jerome Verdon.
*
* 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.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by
* David Dawes, Jean-Baptiste Marchand, Julien Montagne, Thomas Roell,
* Michael Smith, Jerome Verdon and Kazutaka Yokota.
* 4. The name authors may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 THE AUTHORS 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.
*
*
*/
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/tty.h>
#include <machine/pcvt_ioctl.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <setjmp.h>
#include <signal.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <syslog.h>
#include <varargs.h>
#include "moused.h"
extern char *optarg;
extern int optind;
extern char *__progname;
int debug = 0;
int nodaemon = FALSE;
int background = FALSE;
int identify = ID_NONE;
char *pidfile = "/var/run/moused.pid";
static sigjmp_buf env;
static jmp_buf restart_env;
/*
* Most of the structures are from the Xfree Project
*/
/* Buttons status (for multiple click detection) */
static struct {
int count; /* 0: up, 1: single click, 2: double click,... */
struct timeval tv; /* timestamp on the last `up' event */
} buttonstate[MOUSE_MAXBUTTON];
/* Mouse physical interfaces */
static symtab_t mouse_ifs[] = {
{ "serial", MOUSE_IF_SERIAL },
{ "bus", MOUSE_IF_BUS },
{ "inport", MOUSE_IF_INPORT },
{ "ps/2", MOUSE_IF_PS2 },
{ "usb", MOUSE_IF_USB },
{ NULL, MOUSE_IF_UNKNOWN }
};
/* Mouse model names */
static symtab_t mouse_models[] = {
{ "NetScroll", MOUSE_MODEL_NETSCROLL },
{ "NetMouse", MOUSE_MODEL_NET },
{ "GlidePoint", MOUSE_MODEL_GLIDEPOINT },
{ "ThinkingMouse", MOUSE_MODEL_THINK },
{ "IntelliMouse", MOUSE_MODEL_INTELLI },
{ "EasyScroll", MOUSE_MODEL_EASYSCROLL },
{ "MouseMan+", MOUSE_MODEL_MOUSEMANPLUS },
{ "Kidspad", MOUSE_MODEL_KIDSPAD },
{ "VersaPad", MOUSE_MODEL_VERSAPAD },
{ "generic", MOUSE_MODEL_GENERIC },
{ NULL, MOUSE_MODEL_UNKNOWN },
};
/*
* Cflags of each mouse protocol, ordered by P_XXX
*/
static unsigned short mousecflags[] =
{
(CS7 | CREAD | CLOCAL | HUPCL ), /* MicroSoft */
(CS8 | CSTOPB | CREAD | CLOCAL | HUPCL ), /* MouseSystems */
(CS8 | CSTOPB | CREAD | CLOCAL | HUPCL ), /* Logitech */
(CS8 | PARENB | PARODD | CREAD | CLOCAL | HUPCL ), /* MMSeries */
(CS7 | CREAD | CLOCAL | HUPCL ), /* MouseMan */
0, /* Bus */
0, /* InPort */
0, /* PS/2 */
(CS8 | CREAD | CLOCAL | HUPCL ), /* MM HitTablet */
(CS7 | CREAD | CLOCAL | HUPCL ), /* GlidePoint */
(CS7 | CREAD | CLOCAL | HUPCL ), /* IntelliMouse */
(CS7 | CREAD | CLOCAL | HUPCL ), /* Thinking Mouse */
};
/* Array ordered by P_XXX giving protocol properties */
static unsigned char proto[][7] = {
/* hd_mask hd_id dp_mask dp_id bytes b4_mask b4_id */
{ 0x40, 0x40, 0x40, 0x00, 3, ~0x23, 0x00 }, /* MicroSoft */
{ 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff }, /* MouseSystems */
{ 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff }, /* Logitech */
{ 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff }, /* MMSeries */
{ 0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00 }, /* MouseMan */
{ 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff }, /* Bus */
{ 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff }, /* InPort */
{ 0xc0, 0x00, 0x00, 0x00, 3, 0x00, 0xff }, /* PS/2 mouse */
{ 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff }, /* MM HitTablet */
{ 0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00 }, /* GlidePoint */
{ 0x40, 0x40, 0x40, 0x00, 3, ~0x3f, 0x00 }, /* IntelliMouse */
{ 0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00 }, /* ThinkingMouse */
};
/*
* array ordered by P_XXX (mouse protocols) giving the protocol corresponding
* to the name of a mouse
*/
static char *mouse_names[] = {
"microsoft",
"mousesystems",
"logitech",
"mmseries",
"mouseman",
"busmouse",
"inportmouse",
"ps/2",
"mmhitab",
"glidepoint",
"intellimouse",
"thinkingmouse",
NULL
};
/* protocol currently used */
static unsigned char cur_proto[7];
mouse_t mouse = {
flags : 0,
portname : NULL,
proto : P_UNKNOWN,
baudrate : 1200,
old_baudrate : 1200,
rate : MOUSE_RATE_UNKNOWN,
resolution : MOUSE_RES_UNKNOWN,
zmap: 0,
wmode: 0,
mfd : -1,
clickthreshold : 500, /* 0.5 sec */
};
/* PnP EISA/product IDs */
static symtab_t pnpprod[] = {
{ "KML0001",P_THINKING,MOUSE_MODEL_THINK}, /* Kensignton ThinkingMouse */
{ "MSH0001",P_IMSERIAL,MOUSE_MODEL_INTELLI},/* MS IntelliMouse */
{ "MSH0004",P_IMSERIAL,MOUSE_MODEL_INTELLI},/* MS IntelliMouse TrackBall */
{ "KYEEZ00",P_MS,MOUSE_MODEL_GENERIC}, /* Genius EZScroll */
{ "KYE0001",P_MS,MOUSE_MODEL_GENERIC}, /* Genius PnP Mouse */
{ "KYE0003",P_IMSERIAL,MOUSE_MODEL_NET},/* Genius NetMouse */
{ "LGI800C",P_IMSERIAL,MOUSE_MODEL_MOUSEMANPLUS}, /* Logitech MouseMan (4 button model) */
{ "LGI8050",P_IMSERIAL,MOUSE_MODEL_MOUSEMANPLUS}, /* Logitech MouseMan+ */
{ "LGI8051",P_IMSERIAL,MOUSE_MODEL_MOUSEMANPLUS}, /* Logitech FirstMouse+ */
{ "LGI8001",P_LOGIMAN,MOUSE_MODEL_GENERIC}, /* Logitech serial */
{ "PNP0F00",P_BM,MOUSE_MODEL_GENERIC }, /* MS bus */
{ "PNP0F01",P_MS,MOUSE_MODEL_GENERIC }, /* MS serial */
{ "PNP0F02",P_BM,MOUSE_MODEL_GENERIC }, /* MS InPort */
{ "PNP0F03",P_PS2,MOUSE_MODEL_GENERIC }, /* MS PS/2 */
/*
* EzScroll returns PNP0F04 in the compatible device field; but it
* doesn't look compatible... XXX
*/
{ "PNP0F04",P_MSC,MOUSE_MODEL_GENERIC }, /* MouseSystems */
{ "PNP0F05",P_MSC,MOUSE_MODEL_GENERIC }, /* MouseSystems */
{ "PNP0F08",P_LOGIMAN,MOUSE_MODEL_GENERIC },/* Logitech serial */
{ "PNP0F09",P_MS ,MOUSE_MODEL_GENERIC }, /* MS BallPoint serial */
{ "PNP0F0A",P_MS ,MOUSE_MODEL_GENERIC }, /* MS PnP serial */
{ "PNP0F0B",P_MS ,MOUSE_MODEL_GENERIC }, /* MS PnP BallPoint serial */
{ "PNP0F0C",P_MS ,MOUSE_MODEL_GENERIC }, /* MS serial comatible */
{ "PNP0F0D",P_BM,MOUSE_MODEL_GENERIC }, /* MS InPort comatible */
{ "PNP0F0E",P_PS2,MOUSE_MODEL_GENERIC }, /* MS PS/2 comatible */
{ "PNP0F0F",P_MS,MOUSE_MODEL_GENERIC }, /* MS BallPoint comatible */
{ "PNP0F11",P_BM,MOUSE_MODEL_GENERIC }, /* MS bus comatible */
{ "PNP0F12",P_PS2,MOUSE_MODEL_GENERIC }, /* Logitech PS/2 */
{ "PNP0F13",P_PS2,MOUSE_MODEL_GENERIC }, /* PS/2 */
{ "PNP0F15",P_BM,MOUSE_MODEL_GENERIC }, /* Logitech bus */
{ "PNP0F17",P_LOGIMAN,MOUSE_MODEL_GENERIC },/* Logitech serial compat */
{ "PNP0F18",P_BM,MOUSE_MODEL_GENERIC }, /* Logitech bus compatible */
{ "PNP0F19",P_PS2,MOUSE_MODEL_GENERIC }, /* Logitech PS/2 compatible */
{ NULL, -1 },
};
/*
* XXX Functions
*/
static char *
skipspace(char *s)
{
while(isspace(*s))
++s;
return s;
}
static char *
gettokenname(symtab_t *tab, int val)
{
int i;
for (i = 0; tab[i].name != NULL; ++i) {
if (tab[i].val == val)
return tab[i].name;
}
return NULL;
}
static symtab_t *
gettoken(symtab_t *tab, char *s, int len)
{
int i;
for (i = 0; tab[i].name != NULL; ++i) {
if (strncmp(tab[i].name, s, len) == 0)
break;
}
return &tab[i];
}
static char *
mouse_name(int type)
{
return ((type == P_UNKNOWN)
|| (type > sizeof(mouse_names)/sizeof(mouse_names[0]) - 1))
? "unknown" : mouse_names[type];
}
static char *
mouse_model(int model)
{
char *s;
s = gettokenname(mouse_models, model);
return (s == NULL) ? "unknown" : s;
}
/* Fills the hardware info in the main structure */
static void
mouse_fill_hwinfo(void)
{
/* default settings */
mouse.hw.iftype = MOUSE_IF_UNKNOWN;
mouse.hw.type = MOUSE_TYPE_MOUSE;
if (mouse.hw.model == 0) { /* If no type has been given */
mouse.hw.model = MOUSE_MODEL_GENERIC;
}
if (strcmp(mouse.portname,PMS_DEV) == 0) {
mouse.hw.iftype = MOUSE_IF_PS2;
}
if (strcmp(mouse.portname,LMS_DEV) == 0) {
mouse.hw.iftype = MOUSE_IF_BUS;
}
if (strcmp(mouse.portname,MMS_DEV) == 0) {
mouse.hw.iftype = MOUSE_IF_INPORT;
}
/* serial device begins with /dev/cua0 (9 caracters) */
if (strncmp(mouse.portname,SERIAL_DEV,9) == 0) {
mouse.hw.iftype = MOUSE_IF_SERIAL;
}
}
/* Fills the mode structure in the main structure */
static void
mouse_fill_mousemode(void)
{
/* default settings */
mouse.mode.protocol = P_UNKNOWN;
mouse.mode.accelfactor = 0; /* no accel */
if (strcmp(mouse.portname,PMS_DEV) == 0) {
mouse.mode.protocol = P_PS2;
if (mouse.hw.model == MOUSE_MODEL_INTELLI)
mouse.mode.packetsize = MOUSE_INTELLI_PACKETSIZE;
else
mouse.mode.packetsize = MOUSE_PS2_PACKETSIZE;
mouse.mode.syncmask[0] = MOUSE_PS2_SYNCMASK;
mouse.mode.syncmask[1] = MOUSE_PS2_SYNC;
}
if (strcmp(mouse.portname,LMS_DEV) == 0) {
mouse.mode.protocol = P_BM;
mouse.mode.packetsize = MOUSE_MSC_PACKETSIZE;
mouse.mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
mouse.mode.syncmask[1] = MOUSE_MSC_SYNC;
}
if (strcmp(mouse.portname,MMS_DEV) == 0) {
mouse.hw.iftype = P_INPORT;
mouse.mode.packetsize = MOUSE_MSC_PACKETSIZE;
mouse.mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
mouse.mode.syncmask[1] = MOUSE_MSC_SYNC;
}
if (mouse.proto != -1)
mouse.mode.protocol = mouse.proto;
/* resolution */
switch (mouse.resolution) {
case MOUSE_RES_HIGH:
case MOUSE_RES_MEDIUMHIGH:
case MOUSE_RES_MEDIUMLOW:
case MOUSE_RES_LOW:
mouse.mode.resolution = mouse.resolution;
break;
case MOUSE_RES_DEFAULT:
case MOUSE_RES_UNKNOWN:
/* default to low resolution */
mouse.mode.resolution = MOUSE_RES_LOW;
break;
default:
if (mouse.resolution >= 200)
mouse.mode.resolution = MOUSE_RES_HIGH;
else if (mouse.resolution >= 100)
mouse.mode.resolution = MOUSE_RES_MEDIUMHIGH;
else if (mouse.resolution >= 50)
mouse.mode.resolution = MOUSE_RES_MEDIUMLOW;
else mouse.mode.resolution = MOUSE_RES_LOW;
}
/* sample rate */
if (mouse.rate != MOUSE_RATE_UNKNOWN) {
if (mouse.rate >= 200)
mouse.mode.rate = MOUSE_RATE_VERY_HIGH;
else if (mouse.rate >= 100)
mouse.mode.rate = MOUSE_RATE_HIGH;
else if (mouse.rate >= 80)
mouse.mode.rate = MOUSE_RATE_MEDIUM_HIGH;
else if (mouse.rate >= 60)
mouse.mode.rate = MOUSE_RATE_MEDIUM_LOW;
else if (mouse.rate >= 40)
mouse.mode.rate = MOUSE_RATE_LOW;
else
mouse.mode.rate = MOUSE_RATE_VERY_LOW;
}
}
static void
freedev(int sig)
{
int save_errno = errno;
/*
* close the device, when a USR1 signal is received.
* Tipically used by an X server so it can open the device for it's
* own purpose.
*/
close(mouse.mfd);
mouse.mfd = -1;
sigpause(0);
errno = save_errno;
}
static void mouse_init(void);
static void
opendev(int sig)
{
/* re-open the mouse device */
if ((mouse.mfd = open(mouse.portname, O_RDWR | O_NONBLOCK, 0)) == -1) {
logerr(1, "unable to open %s", mouse.portname); /* XXX race */
_exit(1);
}
/* re-init the mouse */
mouse_init();
longjmp(restart_env, 1); /* XXX signal/longjmp re-entrancy */
}
static void
cleanup(int sig)
{
char moused_flag = MOUSED_OFF;
ioctl(mouse.cfd, PCVT_MOUSED, &moused_flag);
_exit(0);
}
/*
* Begin of functions from the Xfree Project
*/
/*
* Functions below come from the Xfree Project and are derived from a two files
* of Xfree86 3.3.6 with the following CVS tags :
$XFree86: xc/programs/Xserver/hw/xfree86/common/xf86_Mouse.c,v 3.21.2.24
1999/12/11 19:00:42 hohndel Exp $
and
$XFree86: xc/programs/Xserver/hw/xfree86/common/xf86_PnPMouse.c,v 1.1.2.6
1999/07/29 09:22:51 hohndel Exp $
*/
void SetMouseSpeed(int old, int new, unsigned int cflag)
{
struct termios tty;
char *c;
if (mouse.hw.iftype != MOUSE_IF_SERIAL)
return;
if (tcgetattr(mouse.mfd, &tty) < 0)
{
ErrorF("Warning: %s unable to get status of mouse fd (%s)\n",
mouse.portname, strerror(errno));
return;
}
/* this will query the initial baudrate only once */
if (mouse.old_baudrate < 0) {
switch (cfgetispeed(&tty))
{
case B9600:
mouse.old_baudrate = 9600;
break;
case B4800:
mouse.old_baudrate = 4800;
break;
case B2400:
mouse.old_baudrate = 2400;
break;
case B1200:
default:
mouse.old_baudrate = 1200;
break;
}
}
tty.c_iflag = IGNBRK | IGNPAR;
tty.c_oflag = 0;
tty.c_lflag = 0;
tty.c_cflag = (tcflag_t)cflag;
tty.c_cc[VTIME] = 0;
tty.c_cc[VMIN] = 1;
switch (old)
{
case 9600:
cfsetispeed(&tty, B9600);
cfsetospeed(&tty, B9600);
break;
case 4800:
cfsetispeed(&tty, B4800);
cfsetospeed(&tty, B4800);
break;
case 2400:
cfsetispeed(&tty, B2400);
cfsetospeed(&tty, B2400);
break;
case 1200:
default:
cfsetispeed(&tty, B1200);
cfsetospeed(&tty, B1200);
}
if (tcsetattr(mouse.mfd, TCSADRAIN, &tty) < 0) {
printf("Unable to get mouse status. Exiting...\n");
exit(1);
}
switch (new)
{
case 9600:
c = "*q";
cfsetispeed(&tty, B9600);
cfsetospeed(&tty, B9600);
break;
case 4800:
c = "*p";
cfsetispeed(&tty, B4800);
cfsetospeed(&tty, B4800);
break;
case 2400:
c = "*o";
cfsetispeed(&tty, B2400);
cfsetospeed(&tty, B2400);
break;
case 1200:
default:
c = "*n";
cfsetispeed(&tty, B1200);
cfsetospeed(&tty, B1200);
}
if (mouse.proto == P_LOGIMAN || mouse.proto == P_LOGI)
{
if (write(mouse.mfd, c, 2) != 2) {
printf("Unable to write to mouse. Exiting...\n");
exit(1);
}
}
usleep(100000);
if (tcsetattr(mouse.mfd, TCSADRAIN, &tty) < 0) {
printf("Unable to get mouse status. Exiting...\n");
exit(1);
}
}
int
FlushInput(int fd)
{
struct pollfd pfd[1];
char c[4];
if (tcflush(fd, TCIFLUSH) == 0)
return 0;
pfd[0].fd = fd;
pfd[0].events = POLLIN;
while (poll(pfd, 1, 0) > 0)
read(fd, &c, sizeof(c));
return 0;
}
/*
* Try to elicit a PnP ID as described in
* Microsoft, Hayes: "Plug and Play External COM Device Specification,
* rev 1.00", 1995.
*
* The routine does not fully implement the COM Enumerator as par Section
* 2.1 of the document. In particular, we don't have idle state in which
* the driver software monitors the com port for dynamic connection or
* removal of a device at the port, because `moused' simply quits if no
* device is found.
*
* In addition, as PnP COM device enumeration procedure slightly has
* changed since its first publication, devices which follow earlier
* revisions of the above spec. may fail to respond if the rev 1.0
* procedure is used. XXX
*/
static int
pnpgets(int mouse_fd, char *buf)
{
struct timeval timeout;
struct pollfd pfd[1];
int i;
char c;
pfd[0].fd = mouse_fd;
pfd[0].events = POLLIN;
#if 0
/*
* This is the procedure described in rev 1.0 of PnP COM device spec.
* Unfortunately, some devices which comform to earlier revisions of
* the spec gets confused and do not return the ID string...
*/
/* port initialization (2.1.2) */
ioctl(mouse_fd, TIOCMGET, &i);
i |= TIOCM_DTR; /* DTR = 1 */
i &= ~TIOCM_RTS; /* RTS = 0 */
ioctl(mouse_fd, TIOCMSET, &i);
usleep(200000);
if ((ioctl(mouse_fd, TIOCMGET, &i) == -1) || ((i & TIOCM_DSR) == 0))
goto disconnect_idle;
/* port setup, 1st phase (2.1.3) */
SetMouseSpeed(1200, 1200, (CS7 | CREAD | CLOCAL | HUPCL));
i = TIOCM_DTR | TIOCM_RTS; /* DTR = 0, RTS = 0 */
ioctl(mouse_fd, TIOCMBIC, &i);
usleep(200000);
i = TIOCM_DTR; /* DTR = 1, RTS = 0 */
ioctl(mouse_fd, TIOCMBIS, &i);
usleep(200000);
/* wait for response, 1st phase (2.1.4) */
FlushInput(mouse_fd);
i = TIOCM_RTS; /* DTR = 1, RTS = 1 */
ioctl(mouse_fd, TIOCMBIS, &i);
/* try to read something */
if (poll(pfd, 1, 200000/1000) <= 0) {
/* port setup, 2nd phase (2.1.5) */
i = TIOCM_DTR | TIOCM_RTS; /* DTR = 0, RTS = 0 */
ioctl(mouse_fd, TIOCMBIC, &i);
usleep(200000);
/* wait for respose, 2nd phase (2.1.6) */
FlushInput(mouse_fd);
i = TIOCM_DTR | TIOCM_RTS; /* DTR = 1, RTS = 1 */
ioctl(mouse_fd, TIOCMBIS, &i);
/* try to read something */
if (poll(pfd, 1, 200000/1000) <= 0)
goto connect_idle;
}
#else
/*
* This is a simplified procedure; it simply toggles RTS.
*/
SetMouseSpeed(1200, 1200, (CS7 | CREAD | CLOCAL | HUPCL));
ioctl(mouse_fd, TIOCMGET, &i);
i |= TIOCM_DTR; /* DTR = 1 */
i &= ~TIOCM_RTS; /* RTS = 0 */
ioctl(mouse_fd, TIOCMSET, &i);
usleep(200000);
/* wait for response */
FlushInput(mouse_fd);
i = TIOCM_DTR | TIOCM_RTS; /* DTR = 1, RTS = 1 */
ioctl(mouse_fd, TIOCMBIS, &i);
/* try to read something */
if (poll(pfd, 1, 200000/1000) <= 0)
goto connect_idle;
#endif
/* collect PnP COM device ID (2.1.7) */
i = 0;
usleep(200000); /* the mouse must send `Begin ID' within 200msec */
while (read(mouse_fd, &c, 1) == 1) {
/* we may see "M", or "M3..." before `Begin ID' */
if ((c == 0x08) || (c == 0x28)) { /* Begin ID */
buf[i++] = c;
break;
}
}
if (i <= 0) {
/* we haven't seen `Begin ID' in time... */
goto connect_idle;
}
++c; /* make it `End ID' */
for (;;) {
if (poll(pfd, 1, 200000/1000) <= 0)
break;
read(mouse_fd, &buf[i], 1);
if (buf[i++] == c) /* End ID */
break;
if (i >= 256)
break;
}
if (buf[i - 1] != c)
goto connect_idle;
return i;
#if 0
/*
* According to PnP spec, we should set DTR = 1 and RTS = 0 while
* in idle state. But, `moused' shall set DTR = RTS = 1 and proceed,
* assuming there is something at the port even if it didn't
* respond to the PnP enumeration procedure.
*/
disconnect_idle:
i = TIOCM_DTR | TIOCM_RTS; /* DTR = 1, RTS = 1 */
ioctl(mouse_fd, TIOCMBIS, &i);
#endif
connect_idle:
return 0;
}
/*
* pnpparse : parse a PnP string ID
*/
static int
pnpparse(pnpid_t *id, char *buf, int len)
{
char s[3];
int offset;
int sum = 0;
int i, j;
id->revision = 0;
id->eisaid = NULL;
id->serial = NULL;
id->class = NULL;
id->compat = NULL;
id->description = NULL;
id->neisaid = 0;
id->nserial = 0;
id->nclass = 0;
id->ncompat = 0;
id->ndescription = 0;
offset = 0x28 - buf[0];
/* calculate checksum */
for (i = 0; i < len - 3; ++i) {
sum += buf[i];
buf[i] += offset;
}
sum += buf[len - 1];
for (; i < len; ++i)
buf[i] += offset;
ErrorF("Mouse: PnP ID string: '%*.*s'\n", len, len, buf);
/* revision */
buf[1] -= offset;
buf[2] -= offset;
id->revision = ((buf[1] & 0x3f) << 6) | (buf[2] & 0x3f);
ErrorF("Mouse: PnP rev %d.%02d\n", id->revision / 100, id->revision % 100);
/* EISA vender and product ID */
id->eisaid = &buf[3];
id->neisaid = 7;
/* option strings */
i = 10;
if (buf[i] == '\\') {
/* device serial # */
for (j = ++i; i < len; ++i) {
if (buf[i] == '\\')
break;
}
if (i >= len)
i -= 3;
if (i - j == 8) {
id->serial = &buf[j];
id->nserial = 8;
}
}
if (buf[i] == '\\') {
/* PnP class */
for (j = ++i; i < len; ++i) {
if (buf[i] == '\\')
break;
}
if (i >= len)
i -= 3;
if (i > j + 1) {
id->class = &buf[j];
id->nclass = i - j;
}
}
if (buf[i] == '\\') {
/* compatible driver */
for (j = ++i; i < len; ++i) {
if (buf[i] == '\\')
break;
}
/*
* PnP COM spec prior to v0.96 allowed '*' in this field,
* it's not allowed now; just ignore it.
*/
if (buf[j] == '*')
++j;
if (i >= len)
i -= 3;
if (i > j + 1) {
id->compat = &buf[j];
id->ncompat = i - j;
}
}
if (buf[i] == '\\') {
/* product description */
for (j = ++i; i < len; ++i) {
if (buf[i] == ';')
break;
}
if (i >= len)
i -= 3;
if (i > j + 1) {
id->description = &buf[j];
id->ndescription = i - j;
}
}
/* checksum exists if there are any optional fields */
if ((id->nserial > 0) || (id->nclass > 0)
|| (id->ncompat > 0) || (id->ndescription > 0)) {
#if 0
ErrorF("Mouse: PnP checksum: 0x%02X\n", sum);
#endif
sprintf(s, "%02X", sum & 0x0ff);
if (strncmp(s, &buf[len - 3], 2) != 0) {
#if 0
/*
* Checksum error!!
* I found some mice do not comply with the PnP COM device
* spec regarding checksum... XXX
*/
return FALSE;
#endif
}
}
return 1;
}
/*
* pnpproto : return the prototype used, based on the PnP ID string
*/
static symtab_t *
pnpproto(pnpid_t *id)
{
symtab_t *t;
int i, j;
if (id->nclass > 0)
if (strncmp(id->class, "MOUSE", id->nclass) != 0)
/* this is not a mouse! */
return NULL;
if (id->neisaid > 0) {
t = gettoken(pnpprod, id->eisaid, id->neisaid);
if (t->val != -1)
return t;
}
/*
* The 'Compatible drivers' field may contain more than one
* ID separated by ','.
*/
if (id->ncompat <= 0)
return NULL;
for (i = 0; i < id->ncompat; ++i) {
for (j = i; id->compat[i] != ','; ++i)
if (i >= id->ncompat)
break;
if (i > j) {
t = gettoken(pnpprod, id->compat + j, i - j);
if (t->val != -1)
return t;
}
}
return NULL;
}
/* mouse_if : returns a string giving the name of the physical interface */
static char *
mouse_if(int iftype)
{
char *s;
s = gettokenname(mouse_ifs, iftype);
return (s == NULL) ? "unknown" : s;
}
/* mouse_init : inits the mouse by writing appropriate sequences */
static void
mouse_init(void)
{
struct pollfd pfd[1];
char *s;
char c;
int i;
pfd[0].fd = mouse.mfd;
pfd[0].events = POLLIN;
/**
** This comment is a little out of context here, but it contains
** some useful information...
********************************************************************
**
** The following lines take care of the Logitech MouseMan protocols.
**
** NOTE: There are diffrent versions of both MouseMan and TrackMan!
** Hence I add another protocol P_LOGIMAN, which the user can
** specify as MouseMan in his XF86Config file. This entry was
** formerly handled as a special case of P_MS. However, people
** who don't have the middle button problem, can still specify
** Microsoft and use P_MS.
**
** By default, these mice should use a 3 byte Microsoft protocol
** plus a 4th byte for the middle button. However, the mouse might
** have switched to a different protocol before we use it, so I send
** the proper sequence just in case.
**
** NOTE: - all commands to (at least the European) MouseMan have to
** be sent at 1200 Baud.
** - each command starts with a '*'.
** - whenever the MouseMan receives a '*', it will switch back
** to 1200 Baud. Hence I have to select the desired protocol
** first, then select the baud rate.
**
** The protocols supported by the (European) MouseMan are:
** - 5 byte packed binary protocol, as with the Mouse Systems
** mouse. Selected by sequence "*U".
** - 2 button 3 byte MicroSoft compatible protocol. Selected
** by sequence "*V".
** - 3 button 3+1 byte MicroSoft compatible protocol (default).
** Selected by sequence "*X".
**
** The following baud rates are supported:
** - 1200 Baud (default). Selected by sequence "*n".
** - 9600 Baud. Selected by sequence "*q".
**
** Selecting a sample rate is no longer supported with the MouseMan!
** Some additional lines in xf86Config.c take care of ill configured
** baud rates and sample rates. (The user will get an error.)
*/
switch (mouse.proto) {
case P_LOGI:
/*
* The baud rate selection command must be sent at the current
* baud rate; try all likely settings
*/
SetMouseSpeed(9600, mouse.baudrate, mousecflags[mouse.proto]);
SetMouseSpeed(4800, mouse.baudrate, mousecflags[mouse.proto]);
SetMouseSpeed(2400, mouse.baudrate, mousecflags[mouse.proto]);
// SetMouseSpeed(1200, mouse.baudrate, mousecflags[mouse.proto]);
/* select MM series data format */
write(mouse.mfd, "S", 1);
SetMouseSpeed(mouse.baudrate, mouse.baudrate,
mousecflags[P_MM]);
/* select report rate/frequency */
if (mouse.rate <= 0) write(mouse.mfd, "O", 1);
else if (mouse.rate <= 15) write(mouse.mfd, "J", 1);
else if (mouse.rate <= 27) write(mouse.mfd, "K", 1);
else if (mouse.rate <= 42) write(mouse.mfd, "L", 1);
else if (mouse.rate <= 60) write(mouse.mfd, "R", 1);
else if (mouse.rate <= 85) write(mouse.mfd, "M", 1);
else if (mouse.rate <= 125) write(mouse.mfd, "Q", 1);
else write(mouse.mfd, "N", 1);
break;
case P_LOGIMAN:
/* The command must always be sent at 1200 baud */
SetMouseSpeed(1200, 1200, mousecflags[mouse.proto]);
write(mouse.mfd, "*X", 2);
SetMouseSpeed(1200, mouse.baudrate, mousecflags[mouse.proto]);
break;
case P_MMHIT:
SetMouseSpeed(1200, mouse.baudrate, mousecflags[mouse.proto]);
/*
* Initialize Hitachi PUMA Plus - Model 1212E to desired settings.
* The tablet must be configured to be in MM mode, NO parity,
* Binary Format. xf86Info.sampleRate controls the sensativity
* of the tablet. We only use this tablet for it's 4-button puck
* so we don't run in "Absolute Mode"
*/
write(mouse.mfd, "z8", 2); /* Set Parity = "NONE" */
usleep(50000);
write(mouse.mfd, "zb", 2); /* Set Format = "Binary" */
usleep(50000);
write(mouse.mfd, "@", 1); /* Set Report Mode = "Stream" */
usleep(50000);
write(mouse.mfd, "R", 1); /* Set Output Rate = "45 rps" */
usleep(50000);
write(mouse.mfd, "I\x20", 2); /* Set Incrememtal Mode "20" */
usleep(50000);
write(mouse.mfd, "E", 1); /* Set Data Type = "Relative */
usleep(50000);
/* Resolution is in 'lines per inch' on the Hitachi tablet */
if (mouse.resolution == MOUSE_RES_LOW) c = 'g';
else if (mouse.resolution == MOUSE_RES_MEDIUMLOW) c = 'e';
else if (mouse.resolution == MOUSE_RES_MEDIUMHIGH) c = 'h';
else if (mouse.resolution == MOUSE_RES_HIGH) c = 'd';
else if (mouse.resolution <= 40) c = 'g';
else if (mouse.resolution <= 100) c = 'd';
else if (mouse.resolution <= 200) c = 'e';
else if (mouse.resolution <= 500) c = 'h';
else if (mouse.resolution <= 1000) c = 'j';
else c = 'd';
write(mouse.mfd, &c, 1);
usleep(50000);
write(mouse.mfd, "\021", 1); /* Resume DATA output */
break;
case P_THINKING:
SetMouseSpeed(1200, mouse.baudrate, mousecflags[mouse.proto]);
/* the PnP ID string may be sent again, discard it */
usleep(200000);
i = FREAD;
ioctl(mouse.mfd, TIOCFLUSH, &i);
/* send the command to initialize the beast */
for (s = "E5E5"; *s; ++s) {
write(mouse.mfd, s, 1);
if (poll(pfd, 1, -1) <= 0)
break;
read(mouse.mfd, &c, 1);
debug("%c", c);
if (c != *s)
break;
}
break;
case P_MSC:
SetMouseSpeed(1200, mouse.baudrate, mousecflags[mouse.proto]);
if (mouse.flags & ClearDTR) {
i = TIOCM_DTR;
ioctl(mouse.mfd, TIOCMBIC, &i);
}
if (mouse.flags & ClearRTS) {
i = TIOCM_RTS;
ioctl(mouse.mfd, TIOCMBIC, &i);
}
break;
case P_BM:
break;
case P_PS2:
/* now sets the resolution and rate for PS/2 mice */
/* always sets resolution, to a default value if no value is given */
c = PS2_SET_RES;
write(mouse.mfd, &c, 1);
c = mouse.mode.resolution;
write(mouse.mfd, &c, 1);
if (mouse.rate != MOUSE_RATE_UNKNOWN) {
c = PS2_SET_RATE;
write(mouse.mfd, &c, 1);
c = mouse.mode.rate;
write(mouse.mfd, &c, 1);
}
break;
default:
SetMouseSpeed(1200, mouse.baudrate, mousecflags[mouse.proto]);
break;
}
}
/* mouse_identify : identify the protocol used by the mouse */
static int
mouse_identify(void)
{
char pnpbuf[256]; /* PnP identifier string may be up to 256 bytes long */
pnpid_t pnpid;
symtab_t *t;
int len;
/*
* Note : We don't have the ioctl that exist in FreeBSD so we simulate
* them with the functions mouse_fill_hwinfo() and mouse_fill_mousemode()
*/
mouse_fill_hwinfo();
mouse_fill_mousemode();
if (mouse.proto != P_UNKNOWN)
bcopy(proto[mouse.proto], cur_proto, sizeof(cur_proto));
/* INPORT and BUS are the same... */
if (mouse.mode.protocol == P_INPORT)
mouse.mode.protocol = P_BM;
if (mouse.mode.protocol != mouse.proto) {
/* Hmm, the driver doesn't agree with the user... */
if (mouse.proto != P_UNKNOWN)
logwarn("mouse type mismatch (%s != %s), %s is assumed",
mouse_name(mouse.mode.protocol),
mouse_name(mouse.proto),
mouse_name(mouse.mode.protocol));
mouse.proto = mouse.mode.protocol;
bcopy(proto[mouse.proto], cur_proto, sizeof(cur_proto));
}
cur_proto[4] = mouse.mode.packetsize;
cur_proto[0] = mouse.mode.syncmask[0]; /* header byte bit mask */
cur_proto[1] = mouse.mode.syncmask[1]; /* header bit pattern */
/* maybe this is an PnP mouse... */
if (mouse.mode.protocol == P_UNKNOWN) {
if (mouse.flags & NoPnP)
return mouse.proto;
if (((len = pnpgets(mouse.mfd,pnpbuf)) <= 0)
|| !pnpparse(&pnpid, pnpbuf, len))
return mouse.proto;
debug("PnP serial mouse: '%*.*s' '%*.*s' '%*.*s'",
pnpid.neisaid, pnpid.neisaid, pnpid.eisaid,
pnpid.ncompat, pnpid.ncompat, pnpid.compat,
pnpid.ndescription, pnpid.ndescription, pnpid.description);
/* we have a valid PnP serial device ID */
mouse.hw.iftype = MOUSE_IF_SERIAL;
t = pnpproto(&pnpid);
if (t != NULL) {
mouse.mode.protocol = t->val;
mouse.hw.model = t->val2;
} else {
mouse.mode.protocol = P_UNKNOWN;
}
if (mouse.mode.protocol == P_INPORT)
mouse.mode.protocol = P_BM;
/* make final adjustment */
if (mouse.mode.protocol != P_UNKNOWN) {
if (mouse.mode.protocol != mouse.proto) {
/* Hmm, the device doesn't agree with the user... */
if (mouse.proto != P_UNKNOWN)
logwarn("mouse type mismatch (%s != %s), %s is assumed",
mouse_name(mouse.mode.protocol),
mouse_name(mouse.proto),
mouse_name(mouse.mode.protocol));
mouse.proto = mouse.mode.protocol;
bcopy(proto[mouse.proto], cur_proto, sizeof(cur_proto));
}
}
}
debug("proto params: %02x %02x %02x %02x %d %02x %02x",
cur_proto[0], cur_proto[1], cur_proto[2], cur_proto[3],
cur_proto[4], cur_proto[5], cur_proto[6]);
return mouse.proto;
}
/* mouse_protocol : decode bytes with the current mouse protocol */
static int
mouse_protocol(u_char rBuf, mousestatus_t *act)
{
/* MOUSE_MSS_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */
static int butmapmss[4] = { /* Microsoft, MouseMan, GlidePoint,
IntelliMouse, Thinking Mouse */
0,
MOUSE_BUTTON3DOWN,
MOUSE_BUTTON1DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
};
static int butmapmss2[4] = { /* Microsoft, MouseMan, GlidePoint,
Thinking Mouse */
0,
MOUSE_BUTTON4DOWN,
MOUSE_BUTTON2DOWN,
MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN,
};
/* MOUSE_INTELLI_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */
static int butmapintelli[4] = { /* IntelliMouse, NetMouse, Mie Mouse,
MouseMan+ */
0,
MOUSE_BUTTON2DOWN,
MOUSE_BUTTON4DOWN,
MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN,
};
/* MOUSE_MSC_BUTTON?UP -> MOUSE_BUTTON?DOWN */
static int butmapmsc[8] = { /* MouseSystems, MMSeries, Logitech,
Bus, sysmouse */
0,
MOUSE_BUTTON3DOWN,
MOUSE_BUTTON2DOWN,
MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN,
MOUSE_BUTTON1DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN | MOUSE_BUTTON3DOWN
};
/* MOUSE_PS2_BUTTON?DOWN -> MOUSE_BUTTON?DOWN */
static int butmapps2[8] = { /* PS/2 */
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
};
/* for Hitachi tablet */
static int butmaphit[8] = { /* MM HitTablet */
0,
MOUSE_BUTTON3DOWN,
MOUSE_BUTTON2DOWN,
MOUSE_BUTTON1DOWN,
MOUSE_BUTTON4DOWN,
MOUSE_BUTTON5DOWN,
MOUSE_BUTTON6DOWN,
MOUSE_BUTTON7DOWN,
};
/* for PS/2 VersaPad */
static int butmapversaps2[8] = { /* VersaPad */
0,
MOUSE_BUTTON3DOWN,
0,
MOUSE_BUTTON3DOWN,
MOUSE_BUTTON1DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
MOUSE_BUTTON1DOWN,
MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN,
};
static int pBufP = 0;
static unsigned char pBuf[8];
static int prev_x, prev_y;
static int on = FALSE;
int x, y;
debug("received char 0x%x",(int)rBuf);
/*
* Hack for resyncing: We check here for a package that is:
* a) illegal (detected by wrong data-package header)
* b) invalid (0x80 == -128 and that might be wrong for MouseSystems)
* c) bad header-package
*
* NOTE: b) is a voilation of the MouseSystems-Protocol, since values of
* -128 are allowed, but since they are very seldom we can easily
* use them as package-header with no button pressed.
* NOTE/2: On a PS/2 mouse any byte is valid as a data byte. Furthermore,
* 0x80 is not valid as a header byte. For a PS/2 mouse we skip
* checking data bytes.
* For resyncing a PS/2 mouse we require the two most significant
* bits in the header byte to be 0. These are the overflow bits,
* and in case of an overflow we actually lose sync. Overflows
* are very rare, however, and we quickly gain sync again after
* an overflow condition. This is the best we can do. (Actually,
* we could use bit 0x08 in the header byte for resyncing, since
* that bit is supposed to be always on, but nobody told
* Microsoft...)
*/
if (pBufP != 0 && mouse.proto != P_PS2 &&
((rBuf & cur_proto[2]) != cur_proto[3] || rBuf == 0x80))
{
pBufP = 0; /* skip package */
}
if (pBufP == 0 && (rBuf & cur_proto[0]) != cur_proto[1])
return 0;
/* is there an extra data byte? */
if (pBufP >= cur_proto[4] && (rBuf & cur_proto[0]) != cur_proto[1])
{
/*
* Hack for Logitech MouseMan Mouse - Middle button
*
* Unfortunately this mouse has variable length packets: the standard
* Microsoft 3 byte packet plus an optional 4th byte whenever the
* middle button status changes.
*
* We have already processed the standard packet with the movement
* and button info. Now post an event message with the old status
* of the left and right buttons and the updated middle button.
*/
/*
* Even worse, different MouseMen and TrackMen differ in the 4th
* byte: some will send 0x00/0x20, others 0x01/0x21, or even
* 0x02/0x22, so I have to strip off the lower bits.
*
* [JCH-96/01/21]
* HACK for ALPS "fourth button". (It's bit 0x10 of the "fourth byte"
* and it is activated by tapping the glidepad with the finger! 8^)
* We map it to bit bit3, and the reverse map in xf86Events just has
* to be extended so that it is identified as Button 4. The lower
* half of the reverse-map may remain unchanged.
*/
/*
* [KY-97/08/03]
* Receive the fourth byte only when preceeding three bytes have
* been detected (pBufP >= cur_proto[4]). In the previous
* versions, the test was pBufP == 0; thus, we may have mistakingly
* received a byte even if we didn't see anything preceeding
* the byte.
*/
if ((rBuf & cur_proto[5]) != cur_proto[6]) {
pBufP = 0;
return 0;
}
switch (mouse.proto) {
/*
* IntelliMouse, NetMouse (including NetMouse Pro) and Mie Mouse
* always send the fourth byte, whereas the fourth byte is
* optional for GlidePoint and ThinkingMouse. The fourth byte
* is also optional for MouseMan+ and FirstMouse+ in their
* native mode. It is always sent if they are in the IntelliMouse
* compatible mode.
*/
case P_IMSERIAL: /* IntelliMouse, NetMouse, Mie Mouse,
MouseMan+ */
act->dx = act->dy = 0;
act->dz = (rBuf & 0x08) ? (rBuf & 0x0f) - 16 : (rBuf & 0x0f);
act->obutton = act->button;
act->button = butmapintelli[(rBuf & MOUSE_MSS_BUTTONS) >> 4]
| (act->obutton & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN));
break;
default:
act->dx = act->dy = act->dz = 0;
act->obutton = act->button;
act->button = butmapmss2[(rBuf & MOUSE_MSS_BUTTONS) >> 4]
| (act->obutton & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN));
break;
}
act->flags = ((act->dx || act->dy || act->dz) ? MOUSE_POSCHANGED : 0)
| (act->obutton ^ act->button);
pBufP = 0;
return act->flags;
}
if (pBufP >= cur_proto[4])
pBufP = 0;
pBuf[pBufP++] = rBuf;
if (pBufP != cur_proto[4])
return 0;
/*
* assembly full package
*/
debug("assembled full packet (len %d) %x,%x,%x,%x,%x,%x,%x,%x",
cur_proto[4],
pBuf[0], pBuf[1], pBuf[2], pBuf[3],
pBuf[4], pBuf[5], pBuf[6], pBuf[7]);
act->dz = 0;
act->obutton = act->button;
switch (mouse.proto)
{
case P_MS: /* Microsoft */
case P_LOGIMAN: /* MouseMan/TrackMan */
case P_GLIDEPOINT: /* GlidePoint */
case P_THINKING: /* ThinkingMouse */
case P_IMSERIAL: /* IntelliMouse, NetMouse, Mie Mouse,
MouseMan+ */
act->button = (act->obutton & (MOUSE_BUTTON2DOWN | MOUSE_BUTTON4DOWN))
| butmapmss[(pBuf[0] & MOUSE_MSS_BUTTONS) >> 4];
act->dx = (char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
act->dy = (char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
break;
case P_MSC: /* MouseSystems Corp */
act->button = butmapmsc[(~pBuf[0]) & MOUSE_MSC_BUTTONS];
act->dx = (char)(pBuf[1]) + (char)(pBuf[3]);
act->dy = - ((char)(pBuf[2]) + (char)(pBuf[4]));
break;
case P_MMHIT: /* MM HitTablet */
act->button = butmaphit[pBuf[0] & 0x07];
act->dx = (pBuf[0] & MOUSE_MM_XPOSITIVE) ? pBuf[1] : - pBuf[1];
act->dy = (pBuf[0] & MOUSE_MM_YPOSITIVE) ? - pBuf[2] : pBuf[2];
break;
case P_MM: /* MM Series */
case P_LOGI: /* Logitech Mice */
act->button = butmapmsc[pBuf[0] & MOUSE_MSC_BUTTONS];
act->dx = (pBuf[0] & MOUSE_MM_XPOSITIVE) ? pBuf[1] : - pBuf[1];
act->dy = (pBuf[0] & MOUSE_MM_YPOSITIVE) ? - pBuf[2] : pBuf[2];
break;
case P_BM: /* Bus */
case P_INPORT: /* InPort */
act->button = butmapmsc[(~pBuf[0]) & MOUSE_MSC_BUTTONS];
act->dx = (char)pBuf[1];
act->dy = - (char)pBuf[2];
break;
case P_PS2: /* PS/2 */
act->button = butmapps2[pBuf[0] & MOUSE_PS2_BUTTONS];
act->dx = (pBuf[0] & MOUSE_PS2_XNEG) ? pBuf[1] - 256 : pBuf[1];
act->dy = (pBuf[0] & MOUSE_PS2_YNEG) ? -(pBuf[2] - 256) : -pBuf[2];
/*
* Moused usually operates the psm driver at the operation level 1
* which sends mouse data in P_SYSMOUSE protocol.
* The following code takes effect only when the user explicitly
* requets the level 2 at which wheel movement and additional button
* actions are encoded in model-dependent formats. At the level 0
* the following code is no-op because the psm driver says the model
* is MOUSE_MODEL_GENERIC.
*/
switch (mouse.hw.model) {
case MOUSE_MODEL_INTELLI:
case MOUSE_MODEL_NET:
/* wheel data is in the fourth byte */
act->dz = (char)pBuf[3];
break;
case MOUSE_MODEL_MOUSEMANPLUS:
if (((pBuf[0] & MOUSE_PS2PLUS_SYNCMASK) == MOUSE_PS2PLUS_SYNC)
&& (abs(act->dx) > 191)
&& MOUSE_PS2PLUS_CHECKBITS(pBuf)) {
/* the extended data packet encodes button and wheel events */
switch (MOUSE_PS2PLUS_PACKET_TYPE(pBuf)) {
case 1:
/* wheel data packet */
act->dx = act->dy = 0;
if (pBuf[2] & 0x80) {
/* horizontal roller count - ignore it XXX*/
} else {
/* vertical roller count */
act->dz = (pBuf[2] & MOUSE_PS2PLUS_ZNEG)
? (pBuf[2] & 0x0f) - 16 : (pBuf[2] & 0x0f);
}
act->button |= (pBuf[2] & MOUSE_PS2PLUS_BUTTON4DOWN)
? MOUSE_BUTTON4DOWN : 0;
act->button |= (pBuf[2] & MOUSE_PS2PLUS_BUTTON5DOWN)
? MOUSE_BUTTON5DOWN : 0;
break;
case 2:
/* this packet type is reserved, and currently ignored */
/* FALL THROUGH */
case 0:
/* device type packet - shouldn't happen */
/* FALL THROUGH */
default:
act->dx = act->dy = 0;
act->button = act->obutton;
debug("unknown PS2++ packet type %d: 0x%02x 0x%02x 0x%02x\n",
MOUSE_PS2PLUS_PACKET_TYPE(pBuf),
pBuf[0], pBuf[1], pBuf[2]);
break;
}
} else {
/* preserve button states */
act->button |= act->obutton & MOUSE_EXTBUTTONS;
}
break;
case MOUSE_MODEL_GLIDEPOINT:
/* `tapping' action */
act->button |= ((pBuf[0] & MOUSE_PS2_TAP)) ? 0 : MOUSE_BUTTON4DOWN;
break;
case MOUSE_MODEL_NETSCROLL:
/* three addtional bytes encode button and wheel events */
act->button |= (pBuf[3] & MOUSE_PS2_BUTTON3DOWN)
? MOUSE_BUTTON4DOWN : 0;
act->dz = (pBuf[3] & MOUSE_PS2_XNEG) ? pBuf[4] - 256 : pBuf[4];
break;
case MOUSE_MODEL_THINK:
/* the fourth button state in the first byte */
act->button |= (pBuf[0] & MOUSE_PS2_TAP) ? MOUSE_BUTTON4DOWN : 0;
break;
case MOUSE_MODEL_VERSAPAD:
act->button = butmapversaps2[pBuf[0] & MOUSE_PS2VERSA_BUTTONS];
act->button |=
(pBuf[0] & MOUSE_PS2VERSA_TAP) ? MOUSE_BUTTON4DOWN : 0;
act->dx = act->dy = 0;
if (!(pBuf[0] & MOUSE_PS2VERSA_IN_USE)) {
on = FALSE;
break;
}
x = ((pBuf[4] << 8) & 0xf00) | pBuf[1];
if (x & 0x800)
x -= 0x1000;
y = ((pBuf[4] << 4) & 0xf00) | pBuf[2];
if (y & 0x800)
y -= 0x1000;
if (on) {
act->dx = prev_x - x;
act->dy = prev_y - y;
} else {
on = TRUE;
}
prev_x = x;
prev_y = y;
break;
case MOUSE_MODEL_GENERIC:
default:
break;
}
break;
default:
return 0;
}
/*
* We don't reset pBufP here yet, as there may be an additional data
* byte in some protocols. See above.
*/
/* has something changed? */
act->flags = ((act->dx || act->dy || act->dz) ? MOUSE_POSCHANGED : 0)
| (act->obutton ^ act->button);
if (mouse.flags & Emulate3Button) {
if (((act->flags & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN))
== (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN))
&& ((act->button & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN))
== (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN))) {
act->button &= ~(MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN);
act->button |= MOUSE_BUTTON2DOWN;
} else if ((act->obutton & MOUSE_BUTTON2DOWN)
&& ((act->button & (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN))
!= (MOUSE_BUTTON1DOWN | MOUSE_BUTTON3DOWN))) {
act->button &= ~(MOUSE_BUTTON1DOWN | MOUSE_BUTTON2DOWN
| MOUSE_BUTTON3DOWN);
}
act->flags &= MOUSE_POSCHANGED;
act->flags |= act->obutton ^ act->button;
}
return act->flags;
}
/*
* Buttons remapping
*/
/* physical to logical button mapping */
static int p2l[MOUSE_MAXBUTTON] = {
MOUSE_BUTTON1DOWN, MOUSE_BUTTON2DOWN, MOUSE_BUTTON3DOWN, MOUSE_BUTTON4DOWN,
MOUSE_BUTTON5DOWN, MOUSE_BUTTON6DOWN, MOUSE_BUTTON7DOWN, MOUSE_BUTTON8DOWN,
0x00000100, 0x00000200, 0x00000400, 0x00000800,
0x00001000, 0x00002000, 0x00004000, 0x00008000,
0x00010000, 0x00020000, 0x00040000, 0x00080000,
0x00100000, 0x00200000, 0x00400000, 0x00800000,
0x01000000, 0x02000000, 0x04000000, 0x08000000,
0x10000000, 0x20000000, 0x40000000,
};
/*
* End of functions from the Xfree Project
*/
/* mouse_installmap : install a map between physical and logical buttons */
static int
mouse_installmap(char *arg)
{
int pbutton;
int lbutton;
char *s;
while (*arg) {
arg = skipspace(arg);
s = arg;
while (isdigit(*arg))
++arg;
arg = skipspace(arg);
if ((arg <= s) || (*arg != '='))
return FALSE;
lbutton = atoi(s);
arg = skipspace(++arg);
s = arg;
while (isdigit(*arg))
++arg;
if ((arg <= s) || (!isspace(*arg) && (*arg != '\0')))
return FALSE;
pbutton = atoi(s);
if ((lbutton <= 0) || (lbutton > MOUSE_MAXBUTTON))
return FALSE;
if ((pbutton <= 0) || (pbutton > MOUSE_MAXBUTTON))
return FALSE;
p2l[pbutton - 1] = 1 << (lbutton - 1);
}
return TRUE;
}
/* mouse_map : convert physical buttons to logical buttons */
static void
mouse_map(mousestatus_t *act1, mousestatus_t *act2)
{
int pb;
int pbuttons;
int lbuttons;
pbuttons = act1->button;
lbuttons = 0;
act2->obutton = act2->button;
if (pbuttons & mouse.wmode) {
pbuttons &= ~mouse.wmode;
act1->dz = act1->dy;
act1->dx = 0;
act1->dy = 0;
}
act2->dx = act1->dx;
act2->dy = act1->dy;
act2->dz = act1->dz;
switch (mouse.zmap) {
case 0: /* do nothing */
break;
case MOUSE_XAXIS:
if (act1->dz != 0) {
act2->dx = act1->dz;
act2->dz = 0;
}
break;
case MOUSE_YAXIS:
if (act1->dz != 0) {
act2->dy = act1->dz;
act2->dz = 0;
}
break;
default: /* buttons */
pbuttons &= ~(mouse.zmap | (mouse.zmap << 1));
if (act1->dz < 0)
pbuttons |= mouse.zmap;
else if (act1->dz > 0)
pbuttons |= (mouse.zmap << 1);
act2->dz = 0;
break;
}
for (pb = 0; (pb < MOUSE_MAXBUTTON) && (pbuttons != 0); ++pb) {
lbuttons |= (pbuttons & 1) ? p2l[pb] : 0;
pbuttons >>= 1;
}
act2->button = lbuttons;
act2->flags = ((act2->dx || act2->dy || act2->dz) ? MOUSE_POSCHANGED : 0)
| (act2->obutton ^ act2->button);
}
/*
* Function to handle button click
* Note that an ioctl is sent for each button
*/
static void
mouse_click(mousestatus_t *act)
{
mouse_info_t mouse_infos;
struct timeval tv;
struct timeval tv1;
struct timeval tv2;
struct timezone tz;
int button;
int mask;
int i;
mask = act->flags & MOUSE_BUTTONS;
if (mask == 0)
return;
gettimeofday(&tv1, &tz);
tv2.tv_sec = mouse.clickthreshold/1000;
tv2.tv_usec = (mouse.clickthreshold%1000)*1000;
timersub(&tv1, &tv2, &tv);
debug("tv: %ld %ld", tv.tv_sec, tv.tv_usec);
button = MOUSE_BUTTON1DOWN;
for (i = 0; (i < MOUSE_MAXBUTTON) && (mask != 0); ++i) {
if (mask & 1) {
if (act->button & button) {
/* the button is down */
debug(" : %ld %ld",
buttonstate[i].tv.tv_sec, buttonstate[i].tv.tv_usec);
if (timercmp(&tv, &buttonstate[i].tv, >)) {
buttonstate[i].tv.tv_sec = 0;
buttonstate[i].tv.tv_usec = 0;
buttonstate[i].count = 1;
} else {
++buttonstate[i].count;
}
mouse_infos.u.event.value = buttonstate[i].count;
} else {
/* the button is up */
buttonstate[i].tv = tv1;
mouse_infos.u.event.value = 0;
}
mouse_infos.operation = MOUSE_BUTTON_EVENT;
mouse_infos.u.event.id = button;
ioctl(mouse.cfd, PCVT_MOUSECTL, &mouse_infos);
debug("button %d count %d\n", i + 1, mouse_infos.u.event.value);
}
button <<= 1;
mask >>= 1;
}
}
/*
* moused : main function
* - wait for mouse events
* - translate according to the current protocol
* - execute the actions associated to events
*/
static void
moused(void)
{
mouse_info_t mouse_infos;
mousestatus_t action; /* original mouse action */
mousestatus_t action2; /* mapped action */
struct pollfd pfd[1];
u_char b;
FILE *fp;
char moused_flag;
if ((mouse.cfd = open("/dev/pcvtctl", O_RDWR, 0)) == -1)
logerr(1, "cannot open /dev/pcvtctl");
if (!nodaemon && !background) {
if (daemon(0, 0)) {
logerr(1, "failed to become a daemon");
} else {
background = TRUE;
fp = fopen(pidfile, "w");
if (fp != NULL) {
fprintf(fp, "%d\n", getpid());
fclose(fp);
}
}
}
/* restart point when coming from X */
setjmp(restart_env);
/* display initial cursor */
mouse_infos.operation = MOUSE_INIT;
moused_flag = MOUSED_ON;
ioctl(mouse.cfd, PCVT_MOUSED, &moused_flag);
ioctl(mouse.cfd, PCVT_MOUSECTL, &mouse_infos);
/* clear mouse data */
bzero(&action, sizeof(action));
bzero(&action2, sizeof(action2));
bzero(&buttonstate, sizeof(buttonstate));
bzero(&mouse_infos, sizeof(mouse));
pfd[0].fd = mouse.mfd;
pfd[0].events = POLLIN;
/* process mouse data */
for (;;) {
if (poll(pfd, 1, -1) <= 0)
logwarn("failed to read from mouse");
/* mouse event */
read(mouse.mfd, &b, 1);
if (mouse_protocol(b, &action)) { /* handler detected action */
mouse_map(&action, &action2);
#if 0
fprintf("activity : buttons 0x%08x dx %d dy %d dz %d\n",
action2.button, action2.dx, action2.dy, action2.dz);
#endif
mouse_click(&action2);
if (action2.flags & MOUSE_POSCHANGED) {
mouse_infos.operation = MOUSE_MOTION_EVENT;
mouse_infos.u.data.buttons = action2.button;
mouse_infos.u.data.x = action2.dx;
mouse_infos.u.data.y = action2.dy;
mouse_infos.u.data.z = action2.dz;
ioctl(mouse.cfd, PCVT_MOUSECTL, &mouse_infos);
}
/*
* If the Z axis movement is mapped to a imaginary physical
* button, we need to cook up a corresponding button `up' event
* after sending a button `down' event.
*/
if ((mouse.zmap > 0) && (action.dz != 0)) {
action.obutton = action.button;
action.dx = action.dy = action.dz = 0;
mouse_map(&action, &action2);
debug("activity : buttons 0x%08x dx %d dy %d dz %d",
action2.button, action2.dx, action2.dy, action2.dz);
mouse_click(&action2);
}
/* NOT REACHED */
}
}
}
static void
usage(void)
{
printf("usage : %s [-3DPRcdfs] [-I file] [-F rate] [-r resolution ] [-S baudrate]",__progname);
printf(" [-C threshold] [-t protocol] [-m type] [-M N=M] [-b buttons]");
printf(" [-w N] [-z target] -p port \n");
printf(" %s -i info -p port \n",__progname);
exit(1);
}
int
main(int argc, char **argv)
{
int opt;
int i;
while ((opt = (getopt(argc,argv,"3DPRb:cdfhi:m:st:I:F:r:M:S:C:p:w:z:"))) != -1) {
switch (opt) {
case '3':
mouse.flags |= Emulate3Button;
break;
case 'D':
mouse.flags |= ClearDTR;
break;
case 'P':
mouse.flags |= NoPnP;
break;
case 'R':
mouse.flags |= ClearRTS;
break;
case 'b':
mouse.hw.buttons = atoi(optarg);
break;
case 'c':
mouse.flags |= ChordMiddle;
break;
case 'd':
++debug;
break;
case 'f':
nodaemon = TRUE;
break;
case 'M':
if (!mouse_installmap(optarg)) {
warnx("invalid mapping `%s'\n", optarg);
usage();
}
break;
case 's':
mouse.baudrate = 9600;
break;
case 't':
if (strcmp(optarg, "auto") == 0) {
mouse.proto = P_UNKNOWN;
mouse.flags &= ~NoPnP;
break;
}
for (i = 0; mouse_names[i]; i++)
if (strcmp(optarg,mouse_names[i]) == 0){
mouse.proto = i;
mouse.flags |= NoPnP;
break;
}
if (mouse_names[i])
break;
printf("no such mouse protocol `%s'\n", optarg);
usage();
break;
case 'm':
for (i = 0 ; mouse_models[i].name; i++)
if (strcmp(optarg,mouse_models[i].name) == 0){
mouse.hw.model =
mouse_models[i].val;
break;
}
if (mouse_models[i].name)
break;
printf("no such mouse type `%s'\n", optarg);
usage();
break;
case 'i':
if (strcmp(optarg, "all") == 0)
identify = ID_ALL;
else if (strcmp(optarg, "port") == 0)
identify = ID_PORT;
else if (strcmp(optarg, "if") == 0)
identify = ID_IF;
else if (strcmp(optarg, "type") == 0)
identify = ID_TYPE;
else if (strcmp(optarg, "model") == 0)
identify = ID_MODEL;
else {
printf("invalid argument `%s'", optarg);
usage();
}
break;
case 'I':
pidfile = optarg;
break;
case 'F':
mouse.rate = atoi(optarg);
if (mouse.rate <= 0) {
printf("invalid rate `%s'\n", optarg);
usage();
}
break;
case 'r':
if (strcmp(optarg, "high") == 0)
mouse.resolution = MOUSE_RES_HIGH;
else if (strcmp(optarg, "medium-high") == 0)
mouse.resolution = MOUSE_RES_MEDIUMHIGH;
else if (strcmp(optarg, "medium-low") == 0)
mouse.resolution = MOUSE_RES_MEDIUMLOW;
else if (strcmp(optarg, "low") == 0)
mouse.resolution = MOUSE_RES_LOW;
else if (strcmp(optarg, "default") == 0)
mouse.resolution = MOUSE_RES_DEFAULT;
else {
mouse.resolution = atoi(optarg);
if (mouse.resolution <= 0) {
printf("invalid resolution `%s'\n", optarg);
usage();
}
}
break;
case 'S':
mouse.baudrate = atoi(optarg);
if (mouse.baudrate <= 0) {
printf("invalid baudrate `%s'\n", optarg);
usage();
}
break;
case 'C':
#define MAX_CLICKTHRESHOLD 2000 /* max delay for double click */
mouse.clickthreshold = atoi(optarg);
if ((mouse.clickthreshold < 0) ||
(mouse.clickthreshold > MAX_CLICKTHRESHOLD)) {
printf("invalid threshold `%s': max value is %d\n"
, optarg,MAX_CLICKTHRESHOLD);
usage();
}
break;
case 'p':
mouse.portname = strdup(optarg);
break;
case 'h':
usage();
break;
case 'w':
i = atoi(optarg);
if ((i <= 0) || (i > MOUSE_MAXBUTTON)) {
warnx("invalid argument `%s'", optarg);
usage();
}
mouse.wmode = 1 << (i - 1);
break;
case 'z':
if (strcmp(optarg, "x") == 0)
mouse.zmap = MOUSE_XAXIS;
else if (strcmp(optarg, "y") == 0)
mouse.zmap = MOUSE_YAXIS;
else {
i = atoi(optarg);
/*
* Use button i for negative Z axis movement
* and button (i + 1) for positive Z axis
* movement.
*/
if ((i <= 0) ||
(i > MOUSE_MAXBUTTON - 1)) {
warnx("invalid argument `%s'",
optarg);
usage();
}
mouse.zmap = 1 << (i - 1);
}
break;
default:
usage();
}
}
/*
* mouse device name :
* Logitech bus mouse : /dev/lms0
* Microsoft bus mouse (also refered as inport) : /dev/mms0
* PS/2 mouse : /dev/pms0
*
* Note that Logitech and Microsoft bus mouse speak the same
* protocol (BusMouse).
*/
switch(mouse.proto) {
case P_INPORT:
/* Inport and Bus use the same protocol (BusMouse) */
mouse.proto = P_BM;
mouse.portname = MMS_DEV;
break;
case P_BM:
if (!mouse.portname)
mouse.portname = LMS_DEV;
break;
case P_PS2:
if (!mouse.portname)
mouse.portname = PMS_DEV;
break;
default:
if (mouse.portname) /* serial mouse */
break;
printf("no port name specified\n");
usage();
}
for (;;) {
if (sigsetjmp(env, 1) == 0) {
signal(SIGUSR1, freedev);
signal(SIGUSR2, opendev);
signal(SIGINT , cleanup);
signal(SIGQUIT, cleanup);
signal(SIGTERM, cleanup);
if ((mouse.mfd = open(mouse.portname,
O_RDWR | O_NONBLOCK, 0)) == -1)
logerr(1, "unable to open %s", mouse.portname);
if (mouse_identify() == P_UNKNOWN) {
logwarn("cannot determine mouse type on %s",
mouse.portname);
close(mouse.mfd);
mouse.mfd = -1;
}
/* print some information */
if (identify != ID_NONE) {
if (identify == ID_ALL)
printf("%s %s %s %s\n",
mouse.portname,
mouse_if(mouse.hw.iftype),
mouse_name(mouse.proto),
mouse_model(mouse.hw.model));
else if (identify & ID_PORT)
printf("%s\n", mouse.portname);
else if (identify & ID_IF)
printf("%s\n", mouse_if(mouse.hw.iftype));
else if (identify & ID_TYPE)
printf("%s\n", mouse_name(mouse.proto));
else if (identify & ID_MODEL)
printf("%s\n", mouse_model(mouse.hw.model));
exit(0);
} else {
debug("port: %s interface: %s type: %s model: %s",
mouse.portname, mouse_if(mouse.hw.iftype),
mouse_name(mouse.proto), mouse_model(mouse.hw.model));
}
if (mouse.mfd == -1) {
/*
* We cannot continue because of error. Exit if the
* program has not become a daemon. Otherwise, block
* until the the user corrects the problem and issues
* SIGHUP.
*/
if (!background)
exit(1);
sigpause(0);
}
mouse_init(); /* init mouse */
moused();
}
if (mouse.mfd != -1)
close(mouse.mfd);
}
/* NOT REACHED */
exit(0);
return (0);
}
![[BACK]](/icons/back.gif){kind=icon}
Return to moused.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.sbin / moused