mouse.c revision 8d6868c7332ea0afd37309d5d919fc5bd546ab6d
/*
*
* Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
* Copyright 1993 by David Dawes <dawes@xfree86.org>
* Copyright 1994-2001 by The XFree86 Project, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the names of copyright holders not be
* used in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission. The copyright holders
* make no representations about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
/* Patch for PS/2 Intellimouse - Tim Goodwin 1997-11-06. */
/*
* [JCH-96/01/21] Added fourth button support for PROT_GLIDEPOINT mouse
* protocol.
*/
/*
* [TVO-97/03/05] Added microsoft IntelliMouse support
*/
#define NEED_EVENTS
#include "X.h"
#include "Xproto.h"
#include "xf86.h"
#ifdef XINPUT
#include "XI.h"
#include "XIproto.h"
#include "extnsionst.h"
#include "extinit.h"
#else
#include "inputstr.h"
#endif
#include "xf86Xinput.h"
#include "xf86_OSproc.h"
#include "xf86OSmouse.h"
#define NEED_XF86_TYPES /* for xisb.h when !XFree86LOADER */
#include "xf86_ansic.h"
#include "compiler.h"
#include "xisb.h"
#include "mouse.h"
#include "mousePriv.h"
#include "mipointer.h"
#ifdef VBOX
#include "VBoxUtils.h"
#include "version-generated.h"
#endif
#if 0
#endif
int *y);
InputDriverRec MOUSE = {
1,
#ifdef VBOX
"vboxmouse",
#else
"mouse",
#endif
NULL,
/*MouseUnInit,*/NULL,
NULL,
0
};
typedef enum {
} MouseOpts;
static const OptionInfoRec mouseOptions[] = {
};
/*
* Microsoft (all serial models), Logitech MouseMan, First Mouse, etc,
* ALPS GlidePoint, Thinking Mouse.
*/
static const char *msDefaults[] = {
"BaudRate", "1200",
"DataBits", "7",
"StopBits", "1",
"Parity", "None",
"FlowControl", "None",
"VTime", "0",
"VMin", "1",
};
/* MouseSystems */
static const char *mscDefaults[] = {
"BaudRate", "1200",
"DataBits", "8",
"StopBits", "2",
"Parity", "None",
"FlowControl", "None",
"VTime", "0",
"VMin", "1",
};
/* MMSeries */
static const char *mmDefaults[] = {
"BaudRate", "1200",
"DataBits", "8",
"StopBits", "1",
"Parity", "Odd",
"FlowControl", "None",
"VTime", "0",
"VMin", "1",
};
/* Logitech series 9 */
static const char *logiDefaults[] = {
"BaudRate", "1200",
"DataBits", "8",
"StopBits", "2",
"Parity", "None",
"FlowControl", "None",
"VTime", "0",
"VMin", "1",
};
/* Hitachi Tablet */
static const char *mmhitDefaults[] = {
"BaudRate", "1200",
"DataBits", "8",
"StopBits", "1",
"Parity", "None",
"FlowControl", "None",
"VTime", "0",
"VMin", "1",
};
/* AceCad Tablet */
static const char *acecadDefaults[] = {
"BaudRate", "9600",
"DataBits", "8",
"StopBits", "1",
"Parity", "Odd",
"FlowControl", "None",
"VTime", "0",
"VMin", "1",
};
static MouseProtocolRec mouseProtocols[] = {
/* Serial protocols */
/* Standard PS/2 */
/* Extended PS/2 */
/* Bus Mouse */
/* Auto-detect (PnP) */
/* Misc (usually OS-specific) */
/* end of list */
};
/*ARGSUSED*/
static const OptionInfoRec *
MouseAvailableOptions(void *unused)
{
return (mouseOptions);
}
static MouseProtocolID
ProtocolNameToID(const char *name)
{
int i;
for (i = 0; mouseProtocols[i].name; i++)
return mouseProtocols[i].id;
return PROT_UNKNOWN;
}
static const char *
{
int i;
switch (id) {
case PROT_UNKNOWN:
return "Unknown";
break;
case PROT_UNSUP:
return "Unsupported";
break;
default:
for (i = 0; mouseProtocols[i].name; i++)
return mouseProtocols[i].name;
return "Invalid";
}
}
const char *
{
return ProtocolIDToName(id);
}
xf86MouseProtocolNameToID(const char *name)
{
return ProtocolNameToID(name);
}
static int
{
int i;
switch (id) {
case PROT_UNKNOWN:
case PROT_UNSUP:
return MSE_NONE;
break;
default:
for (i = 0; mouseProtocols[i].name; i++)
return mouseProtocols[i].class;
return MSE_NONE;
}
}
static MouseProtocolPtr
int i;
switch (id) {
case PROT_UNKNOWN:
case PROT_UNSUP:
return NULL;
break;
default:
for (i = 0; mouseProtocols[i].name; i++)
return &mouseProtocols[i];
return NULL;
}
}
static Bool
InitProtocols(void)
{
int classes;
int i;
if (osInfo)
return TRUE;
osInfo = xf86OSMouseInit(0);
if (!osInfo)
return FALSE;
if (!osInfo->SupportedInterfaces)
return FALSE;
if (!classes)
return FALSE;
/* Mark unsupported interface classes. */
for (i = 0; mouseProtocols[i].name; i++)
for (i = 0; mouseProtocols[i].name; i++)
if (!osInfo->CheckProtocol ||
/* NetBSD uses PROT_BM for "PS/2". */
for (i = 0; mouseProtocols[i].name; i++)
return TRUE;
}
int i,
/* Process options common to all mouse types. */
static void
{
char *s;
int origButtons;
}
"Emulate3Buttons", FALSE);
50);
if (pMse->emulate3Buttons) {
}
if (pMse->chordMiddle)
} else
} else
if (s) {
if (!xf86NameCmp(s, "x")) {
} else if (!xf86NameCmp(s, "y")) {
if (msg)
if (msg)
if (msg)
}
} else {
}
if (msg) {
} else {
}
}
int wheelButton;
"EmulateWheelButton", 4);
wheelButton = 4;
}
"EmulateWheelInertia", 10);
if (pMse->wheelInertia <= 0) {
}
if (s) {
if (msg)
} else {
}
if (msg) {
}
}
if (s) {
if (msg)
yFromConfig = TRUE;
} else {
}
if (msg) {
}
}
if (!yFromConfig) {
}
"EmulateWheelInertia: %d\n",
}
}
static InputInfoPtr
{
const char *protocol;
#ifdef VBOX
"VirtualBox guest additions mouse driver version "
VBOX_VERSION_STRING "\n");
#endif
if (!InitProtocols())
return NULL;
return NULL;
/* Initialise the InputInfoRec. */
pInfo->history_size = 0;
pInfo->private_flags = 0;
pInfo->always_core_feedback = 0;
/* Allocate the MouseDevRec and initialise it. */
/*
* XXX This should be done by a function in the core server since the
* MouseDevRec is defined in the os-support layer.
*/
return pInfo;
#ifdef VBOX
protocol = "ImPS/2";
#else
/* Find the protocol type. */
if (protocol) {
} else if (osInfo->DefaultProtocol) {
}
if (!protocol) {
return pInfo;
}
#endif /* VBOX */
switch (protocolID) {
case PROT_UNKNOWN:
/* Check for a builtin OS-specific protocol, and call its PreInit. */
}
return pInfo;
}
protocol);
return pInfo;
break;
case PROT_UNSUP:
"%s: Protocol \"%s\" is not supported on this platform\n",
return pInfo;
break;
default:
}
return pInfo;
/* Collect the options, and process the common options. */
/* XXX should handle this OS dependency elsewhere. */
#ifndef __OS2ELF__
/* OS/2 has a mouse handled by the OS - it cannot fail here */
/* Check if the device can be opened. */
if (xf86GetAllowMouseOpenFail())
else {
return pInfo;
}
}
#endif
if (pMse->sampleRate) {
pMse->sampleRate);
}
}
if (pMse->resolution) {
pMse->resolution);
}
if (clearDTR) {
xf86ErrorF("ClearDTR");
if (clearRTS)
xf86ErrorF(", ");
}
if (clearRTS) {
xf86ErrorF("ClearRTS");
}
xf86ErrorF("\n");
}
return pInfo;
}
/*
* This array is indexed by the MouseProtocolID values, so the order of the entries
* must match that of the MouseProtocolID enum in mouse.h.
*/
/* --header-- ---data--- packet -4th-byte- mouse */
/* mask id mask id bytes mask id flags */
/* Serial mice */
/* PS/2 variants */
/* Bus Mouse */
};
/*
* SetupMouse --
* Sets up the mouse parameters
*/
static Bool
{
/*
** The following lines take care of the Logitech MouseMan protocols.
** The "Logitech" protocol is for the old "series 9" Logitech products.
** All products since then use the "MouseMan" protocol. Some models
** were programmable, but most (all?) of the current models are not.
**
** NOTE: There are different versions of both MouseMan and TrackMan!
** Hence I add another protocol PROT_LOGIMAN, which the user can
** specify as MouseMan in his XF86Config file. This entry was
** formerly handled as a special case of PROT_MS. However, people
** who don't have the middle button problem, can still specify
** Microsoft and use PROT_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!
** [CHRIS-211092]
*/
unsigned i;
int speed;
const char *s;
unsigned char c;
/* Handle the "Auto" protocol. */
/* Check if the OS has a detection mechanism. */
if (name) {
switch (protocolID) {
case PROT_UNKNOWN:
/* Check for a builtin OS-specific protocol. */
/* XXX need to handle auto-detected builtin protocols */
} else
break;
case PROT_UNSUP:
break;
default:
break;
}
}
}
#ifdef PNP_MOUSE
if (!name) {
/* A PnP serial mouse? */
}
}
#endif
if (name) {
}
}
if (automatic) {
if (name) {
/* Possible protoPara overrides from SetupAuto. */
if (protoPara[i] != -1)
} else {
return FALSE;
}
}
/*
* If protocol has changed fetch the default options
* for the new protocol.
*/
/* baudrate is not explicitely set: fetch the default one */
}
/*
* Write the baudrate back th the option list so that the serial
* interface code can access the new value.
*/
/* Set the port parameters. */
if (!automatic)
switch (pMse->protocolID) {
case PROT_LOGI: /* Logitech Mice */
/*
* The baud rate selection command must be sent at the current
* baud rate; try all likely settings.
*/
switch (speed) {
case 9600:
s = "*q";
break;
case 4800:
s = "*p";
break;
case 2400:
s = "*o";
break;
case 1200:
s = "*n";
break;
default:
/* Fallback value */
speed = 1200;
s = "*n";
}
usleep(100000);
usleep(100000);
usleep(100000);
usleep(100000);
/* Select MM series data format. */
usleep(100000);
/* Set the parameters up for the MM series protocol. */
else c = 'N'; /* 150 */
break;
case PROT_LOGIMAN:
switch (speed) {
case 9600:
s = "*q";
break;
case 1200:
s = "*n";
break;
default:
/* Fallback value */
speed = 1200;
s = "*n";
}
usleep(100000);
break;
case PROT_MMHIT: /* MM_HitTablet */
/*
* Initialize Hitachi PUMA Plus - Model 1212E to desired settings.
* The tablet must be configured to be in MM mode, NO parity,
* Binary Format. pMse->sampleRate controls the sensitivity
* of the tablet. We only use this tablet for it's 4-button puck
* so we don't run in "Absolute Mode".
*/
usleep(50000);
usleep(50000);
usleep(50000);
usleep(50000);
usleep(50000);
usleep(50000);
/*
* These sample rates translate to 'lines per inch' on the Hitachi
* tablet.
*/
else c = 'd';
usleep(50000);
break;
case PROT_THINKING: /* ThinkingMouse */
/* This mouse may send a PnP ID string, ignore it. */
usleep(200000);
/* Send the command to initialize the beast. */
for (s = "E5E5"; *s; ++s) {
break;
if (c != *s)
break;
}
break;
case PROT_MSC: /* MouseSystems Corp */
usleep(100000);
break;
case PROT_ACECAD:
/* initialize */
/* A nul character resets. */
usleep(50000);
/* Stream out relative mode high resolution increments of 1. */
break;
pMse->resolution);
break;
case PROT_PS2:
case PROT_IMPS2: /* IntelliMouse */
case PROT_EXPPS2: /* IntelliMouse Explorer */
case PROT_THINKPS2: /* ThinkingMouse */
case PROT_MMPS2: /* MouseMan+, FirstMouse+ */
case PROT_GLIDEPS2:
case PROT_NETPS2: /* NetMouse, NetMouse Pro, Mie Mouse */
case PROT_NETSCPS2: /* NetScroll */
#ifndef VBOX
return FALSE;
#endif
break;
case PROT_SYSMOUSE:
if (osInfo->SetMiscRes)
pMse->resolution);
break;
default:
/* Nothing to do. */
break;
}
pMse->protoBufTail = 0;
return TRUE;
}
static void
{
int pBufP;
int c;
unsigned char *pBuf, u;
/*
* Set blocking to -1 on the first call because we know there is data to
* read. Xisb automatically clears it after one successful read so that
* succeeding reads are preceeded by a select with a 0 timeout to prevent
* read from blocking indefinitely.
*/
u = (unsigned char)c;
if (ps2mouseReset(pInfo,u)) {
pBufP = 0;
continue;
}
}
/*
* Buffer contains a full packet, which has already been processed:
* Empty the buffer and check for optional 4th byte, which will be
* processed directly, without being put into the buffer first.
*/
pBufP = 0;
/*
* 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.
* [CHRIS-211092]
*
* [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.
*/
/*
* [KAZU-030897]
* Receive the fourth byte only when preceeding three bytes
* have been detected (pBufP >= pMse->protoPara[4]). In the
* previous versions, the test was pBufP == 0; we may have
* mistakingly received a byte even if we didn't see anything
* preceeding the byte.
*/
#ifdef EXTMOUSEDEBUG
ErrorF("mouse 4th byte %02x",u);
#endif
buttons = 0;
switch (pMse->protocolID) {
/*
* [KAZU-221197]
* 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 PROT_IMSERIAL: /* IntelliMouse, NetMouse, Mie Mouse,
MouseMan+ */
dz = (u & 0x08) ?
(u & 0x0f) - 16 : (u & 0x0f);
dz = 0;
| ((int)(u & 0x20) >> 2)
break;
case PROT_GLIDE:
case PROT_THINKING:
/* fall through */
default:
break;
}
goto post_event;
}
}
/* End of packet buffer flush and 4th byte hack. */
/*
* Append next byte to buffer (which is empty or contains an
* incomplete packet); iterate if packet (still) not complete.
*/
#ifdef EXTMOUSEDEBUG2
{
int i;
for ( i=0; i < pBufP; i++)
ErrorF("\n");
}
#endif
/*
* 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 violation 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...)
*/
/*
* [KAZU,OYVIND-120398]
* The above hack is wrong! Because of b) above, we shall see
* erroneous mouse events so often when the MouseSystem mouse is
* moved quickly. As for the PS/2 and its variants, we don't need
* to treat them as special cases, because protoPara[2] and
* protoPara[3] are both 0x00 for them, thus, any data bytes will
* never be discarded. 0x80 is rejected for MMSeries, Logitech
* and MMHittab protocols, because protoPara[2] and protoPara[3]
* are 0x80 and 0x00 respectively. The other protocols are 7-bit
* protocols; there is no use checking 0x80.
*
* All in all we should check the condition a) only.
*/
/*
* [OYVIND-120498]
* Check packet for valid data:
* If driver is in sync with datastream, the packet is considered
*
* If packet is bad, we discard the first byte and shift the buffer.
* Next iteration will then check the new situation for validity.
*
* If flag MF_SAFE is set in proto[7] and the driver
* is out of sync, the packet is also considered bad if
* any of the data bytes contains a valid header byte value.
* This situation could occur if the buffer contains
* the tail of one packet and the header of the next.
*
* Note: The driver starts in out-of-sync mode (pMse->inSync = 0).
*/
baddata = 0;
/* All databytes must be valid. */
for (j = 1; j < pBufP; j++ )
baddata = 1;
/* If out of sync, don't mistake a header byte for data. */
for (j = 1; j < pBufP; j++ )
baddata = 1;
/* Accept or reject the packet ? */
#ifdef EXTMOUSEDEBUG
ErrorF("mouse driver lost sync\n");
#endif
for (j = 0; j < pBufP; j++)
continue;
}
#ifdef EXTMOUSEDEBUG
ErrorF("mouse driver back in sync\n");
#endif
}
/*
* Packet complete and verified, now process it ...
*/
switch (pMse->protocolID) {
case PROT_LOGIMAN: /* MouseMan / TrackMan [CHRIS-211092] */
case PROT_MS: /* Microsoft */
if (pMse->chordMiddle)
else
break;
case PROT_GLIDE: /* ALPS GlidePoint */
case PROT_THINKING: /* ThinkingMouse */
case PROT_IMSERIAL: /* IntelliMouse, NetMouse, Mie Mouse, MouseMan+ */
break;
case PROT_MSC: /* Mouse Systems Corp */
break;
case PROT_MMHIT: /* MM_HitTablet */
if (buttons != 0)
break;
case PROT_ACECAD: /* ACECAD */
/* ACECAD is almost exactly like MM but the buttons are different */
break;
case PROT_MM: /* MM Series */
case PROT_LOGI: /* Logitech Mice */
break;
case PROT_BM: /* BusMouse */
break;
case PROT_PS2: /* PS/2 mouse */
break;
/* PS/2 mouse variants */
case PROT_IMPS2: /* IntelliMouse PS/2 */
case PROT_NETPS2: /* NetMouse PS/2 */
dz = 0;
break;
case PROT_EXPPS2: /* IntelliMouse Explorer PS/2 */
break;
case PROT_MMPS2: /* MouseMan+ PS/2 */
/* extended data packet */
case 1: /* wheel data packet */
break;
case 2: /* Logitech reserves this packet type */
/*
* IBM ScrollPoint uses this packet to encode its
* stick movement.
*/
break;
case 0: /* device type packet - shouldn't happen */
default:
dz = 0;
break;
}
} else {
}
break;
case PROT_GLIDEPS2: /* GlidePoint PS/2 */
break;
case PROT_NETSCPS2: /* NetScroll PS/2 */
break;
case PROT_THINKPS2: /* ThinkingMouse PS/2 */
break;
case PROT_SYSMOUSE: /* sysmouse */
/* FreeBSD sysmouse sends additional data bytes */
}
break;
default: /* There's a table error */
#ifdef EXTMOUSEDEBUG
ErrorF("mouse table error\n");
#endif
continue;
}
#ifdef EXTMOUSEDEBUG
ErrorF("packet");
for ( j=0; j < pBufP; j++)
#endif
/* post an event */
/*
* We don't reset pBufP here yet, as there may be an additional data
* byte in some protocols. See above.
*/
}
}
/*
* MouseCtrl --
* Alter the control parameters for the mouse. Note that all special
* protocol values are handled by dix.
*/
static void
{
#ifdef EXTMOUSEDEBUG
#endif
}
/*
***************************************************************************
*
* MouseProc --
*
***************************************************************************
*/
static int
{
int i, blocked;
#ifdef VBOX
#endif
#ifdef VBOX
#endif
switch (what)
{
case DEVICE_INIT:
/*
* [KAZU-241097] We don't know exactly how many buttons the
* device has, so setup the map with the maximum number.
*/
for (i = 0; i < MSE_MAXBUTTONS; i++)
/* X valuator */
/* Y valuator */
#ifdef EXTMOUSEDEBUG
#endif
break;
case DEVICE_ON:
#ifdef VBOX
if (!pPriv)
{
if (pPriv)
{
"ScreenNo", 0);
}
}
if (pPriv)
{
{
}
}
#endif
else {
} else {
if (!SetupMouse(pInfo)) {
} else {
}
}
}
pMse->lastButtons = 0;
pMse->emulateState = 0;
/*
* send button up events for sanity. If no button down is pending
* xf86PostButtonEvent() will discard them. So we are on the safe side.
*/
blocked = xf86BlockSIGIO ();
for (i = 1; i <= 5; i++)
xf86PostButtonEvent(device,0,i,0,0,0);
if (pMse->emulate3Buttons)
{
}
break;
case DEVICE_OFF:
case DEVICE_CLOSE:
#ifdef VBOX
if (VBoxMouseFini())
{
/** @todo what to do? */
}
#endif
}
if (pMse->emulate3Buttons)
{
}
}
usleep(300000);
break;
}
return Success;
}
/*
***************************************************************************
*
* MouseConvert --
* Convert valuators to X and Y.
*
***************************************************************************
*/
static Bool
{
return FALSE;
*x = v0;
*y = v1;
return TRUE;
}
/*
* Lets create a simple finite-state machine for 3 button emulation:
*
* We track buttons 1 and 3 (left and right). There are 11 states:
* 0 ground - initial state
* 1 delayed left - left pressed, waiting for right
* 2 delayed right - right pressed, waiting for left
* 3 pressed middle - right and left pressed, emulated middle sent
* 4 pressed left - left pressed and sent
* 5 pressed right - right pressed and sent
* 6 released left - left released after emulated middle
* 7 released right - right released after emulated middle
* 8 repressed left - left pressed after released left
* 9 repressed right - right pressed after released right
* 10 pressed both - both pressed, not emulating middle
*
* At each state, we need handlers for the following events
* 0: no buttons down
* 1: left button down
* 2: right button down
* 3: both buttons down
* 4: emulate3Timeout passed without a button change
* Note that button events are not deltas, they are the set of buttons being
* pressed now. It's possible (ie, mouse hardware does it) to go from (eg)
* left down to right down without anything in between, so all cases must be
* handled.
*
* a handler consists of three values:
* 0: action1
* 1: action2
* 2: new emulation state
*
* action > 0: ButtonPress
* action = 0: nothing
* action < 0: ButtonRelease
*
* The comment preceeding each section is the current emulation state.
* The comments to the right are of the form
* <button state> (<events>) -> <new emulation state>
* which should be read as
* If the buttons are in <button state>, generate <events> then go to
* <new emulation state>.
*/
/* 0 ground */
{
{ 0, 0, 0 }, /* nothing -> ground (no change) */
{ 0, 0, 1 }, /* left -> delayed left */
{ 0, 0, 2 }, /* right -> delayed right */
{ 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
{ 0, 0, -1 } /* timeout N/A */
},
/* 1 delayed left */
{
{ 1, -1, 0 }, /* nothing (left event) -> ground */
{ 0, 0, 1 }, /* left -> delayed left (no change) */
{ 1, -1, 2 }, /* right (left event) -> delayed right */
{ 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
{ 1, 0, 4 }, /* timeout (left press) -> pressed left */
},
/* 2 delayed right */
{
{ 3, -3, 0 }, /* nothing (right event) -> ground */
{ 3, -3, 1 }, /* left (right event) -> delayed left (no change) */
{ 0, 0, 2 }, /* right -> delayed right (no change) */
{ 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
{ 3, 0, 5 }, /* timeout (right press) -> pressed right */
},
/* 3 pressed middle */
{
{ -2, 0, 0 }, /* nothing (middle release) -> ground */
{ 0, 0, 7 }, /* left -> released right */
{ 0, 0, 6 }, /* right -> released left */
{ 0, 0, 3 }, /* left & right -> pressed middle (no change) */
{ 0, 0, -1 }, /* timeout N/A */
},
/* 4 pressed left */
{
{ -1, 0, 0 }, /* nothing (left release) -> ground */
{ 0, 0, 4 }, /* left -> pressed left (no change) */
{ -1, 0, 2 }, /* right (left release) -> delayed right */
{ 3, 0, 10 }, /* left & right (right press) -> pressed both */
{ 0, 0, -1 }, /* timeout N/A */
},
/* 5 pressed right */
{
{ -3, 0, 0 }, /* nothing (right release) -> ground */
{ -3, 0, 1 }, /* left (right release) -> delayed left */
{ 0, 0, 5 }, /* right -> pressed right (no change) */
{ 1, 0, 10 }, /* left & right (left press) -> pressed both */
{ 0, 0, -1 }, /* timeout N/A */
},
/* 6 released left */
{
{ -2, 0, 0 }, /* nothing (middle release) -> ground */
{ -2, 0, 1 }, /* left (middle release) -> delayed left */
{ 0, 0, 6 }, /* right -> released left (no change) */
{ 1, 0, 8 }, /* left & right (left press) -> repressed left */
{ 0, 0, -1 }, /* timeout N/A */
},
/* 7 released right */
{
{ -2, 0, 0 }, /* nothing (middle release) -> ground */
{ 0, 0, 7 }, /* left -> released right (no change) */
{ -2, 0, 2 }, /* right (middle release) -> delayed right */
{ 3, 0, 9 }, /* left & right (right press) -> repressed right */
{ 0, 0, -1 }, /* timeout N/A */
},
/* 8 repressed left */
{
{ -2, -1, 0 }, /* nothing (middle release, left release) -> ground */
{ -2, 0, 4 }, /* left (middle release) -> pressed left */
{ -1, 0, 6 }, /* right (left release) -> released left */
{ 0, 0, 8 }, /* left & right -> repressed left (no change) */
{ 0, 0, -1 }, /* timeout N/A */
},
/* 9 repressed right */
{
{ -2, -3, 0 }, /* nothing (middle release, right release) -> ground */
{ -3, 0, 7 }, /* left (right release) -> released right */
{ -2, 0, 5 }, /* right (middle release) -> pressed right */
{ 0, 0, 9 }, /* left & right -> repressed right (no change) */
{ 0, 0, -1 }, /* timeout N/A */
},
/* 10 pressed both */
{
{ -1, -3, 0 }, /* nothing (left release, right release) -> ground */
{ -3, 0, 4 }, /* left (right release) -> pressed left */
{ -1, 0, 5 }, /* right (left release) -> pressed right */
{ 0, 0, 10 }, /* left & right -> pressed both (no change) */
{ 0, 0, -1 }, /* timeout N/A */
},
};
/*
* Table to allow quick reversal of natural button mapping to correct mapping
*/
/*
* [JCH-96/01/21] The ALPS GlidePoint pad extends the MS protocol
* with a fourth button activated by tapping the PAD.
* The 2nd line corresponds to 4th button on; the drv sends
* the buttons in the following map (MSBit described first) :
* 0 | 4th | 1st | 2nd | 3rd
* And we remap them (MSBit described first) :
* 0 | 4th | 3rd | 2nd | 1st
*/
8, 12, 10, 14, 9, 13, 11, 15,
16, 20, 18, 22, 17, 21, 19, 23,
24, 28, 26, 30, 25, 29, 27, 31};
8, 10, 9, 11,
4, 6, 5, 7,
12, 14, 13, 15 };
static CARD32
{
int sigstate;
int id;
sigstate = xf86BlockSIGIO ();
} else {
}
return 0;
}
{
int ms;
if (pMse->emulate3Pending)
{
if (ms <= 0)
ms = 0;
}
}
int i,
{
int ms;
if (pMse->emulate3Pending)
{
if (ms <= 0)
buttonTimer (pInfo);
}
}
static void
{
int truebuttons, emulateButtons;
else
/* Intercept wheel emulation. */
/* Y axis movement */
if (pMse->wheelYDistance < 0) {
} else {
}
/*
* Synthesize the press and release, but not when the button
* to be synthesized is already pressed "for real".
*/
if (!(emuWheelButtonMask & buttons) ||
}
}
}
/* X axis movement */
if (pMse->wheelXDistance < 0) {
} else {
}
/*
* Synthesize the press and release, but not when the button
* to be synthesized is already pressed "for real".
*/
if (!(emuWheelButtonMask & buttons) ||
}
}
}
/* Absorb the mouse movement and the wheel button press. */
dx = 0;
dy = 0;
}
#ifdef VBOX
{
{
unsigned int abs_x;
unsigned int abs_y;
{
/* convert to screen resolution */
int x, y;
/* send absolute movement */
}
else
{
/* send relative event */
}
}
else
{
/* send relative event */
}
}
#else
#endif /* !VBOX */
else
if (pMse->emulate3Buttons) {
/* handle all but buttons 1 & 3 normally */
change &= ~05;
/* emulate the third button by the other two */
pMse->emulateState =
} else {
}
}
while (change) {
}
}
}
static void
{
int zbutton = 0;
/* Map the Z axis movement. */
/* XXX Could this go in the conversion_proc? */
case MSE_NOZMAP: /* do nothing */
break;
case MSE_MAPTOX:
if (dz != 0) {
dz = 0;
}
break;
case MSE_MAPTOY:
if (dz != 0) {
dz = 0;
}
break;
default: /* buttons */
else if (dz < 0)
else if (dz > 0)
dz = 0;
break;
}
}
/*
* If dz has been mapped to a button `down' event, we need to cook up
* a corresponding button `up' event.
*/
if (zbutton) {
}
}
static void
{
int paramlen = 0;
unsigned char c;
if (reinsert) {
unsigned char init = 0xF4;
usleep(30000);
}
switch (pMse->protocolID) {
case PROT_IMPS2: /* IntelliMouse */
{
}
break;
case PROT_EXPPS2: /* IntelliMouse Explorer */
{
243, 200, 243, 200, 243, 80, 242 };
}
break;
case PROT_NETPS2: /* NetMouse, NetMouse Pro, Mie Mouse */
case PROT_NETSCPS2: /* NetScroll */
{
}
break;
case PROT_MMPS2: /* MouseMan+, FirstMouse+ */
{
230, 232, 3, 232, 1, 232, 2, 232, 3, };
}
break;
case PROT_THINKPS2: /* ThinkingMouse */
{
243, 40, 243, 20, 243, 20, 243, 60,
243, 40, 243, 20, 243, 20, };
}
}
if (paramlen > 0) {
#ifdef EXTMOUSEDEBUG
for (i = 0; i < paramlen; ++i) {
ErrorF("SetupMouse: Write to mouse failed (%s)\n",
usleep(30000);
ErrorF("SetupMouse: got %02x\n", c);
}
#else
#endif
usleep(30000);
}
#ifdef VBOX
#else
#endif
pMse->resolution);
} else {
unsigned char c2[2];
c = 230; /* 1:1 scaling */
c = 244; /* enable mouse */
if (pMse->sampleRate > 0) {
else
} else {
}
if (pMse->resolution > 0) {
else
c2[1] = 0;
} else {
}
usleep(30000);
}
}
static Bool
{
#ifdef VBOX
#else
#endif
#ifdef EXTMOUSEDEBUG
#endif
#ifdef VBOX
case 0:
if (val == 0xaa)
else
return FALSE;
case 1:
if (val == 0x00) {
"Got reinsert event: reinitializing PS/2 mouse\n");
return TRUE;
} else
return FALSE;
default:
return FALSE;
}
#else /* !VBOX */
case 0:
if (val == 0xaa)
else
return FALSE;
case 1:
if (val == 0x00) {
"Got reinsert event: reinitializing PS/2 mouse\n");
return TRUE;
} else
return FALSE;
default:
return FALSE;
}
#endif /* !VBOX */
}
#ifdef XFree86LOADER
1,
"MOUSE",
NULL,
0,
};
static void
{
}
static pointer
int *errmaj,
int *errmin)
{
if (!Initialised) {
Initialised = TRUE;
#ifndef REMOVE_LOADER_CHECK_MODULE_INFO
if (xf86LoaderCheckSymbol("xf86AddModuleInfo"))
#endif
}
return module;
}
static XF86ModuleVersionInfo xf86MouseVersionRec =
{
#ifdef VBOX
"vboxmouse",
"Sun Microsystems, Inc.",
#else
"mouse",
#endif
1, 0, 0,
{0, 0, 0, 0} /* signature, to be patched into the file by */
/* a tool */
};
#ifndef VBOX
#else
#endif
{
};
#endif /* XFree86LOADER */