summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorKaleb Keithley <kaleb@freedesktop.org>2003-11-14 16:48:56 +0000
committerKaleb Keithley <kaleb@freedesktop.org>2003-11-14 16:48:56 +0000
commitc9c7e96897229ba1d457a58f66121dd1f9210382 (patch)
treed8172467d82f1c8fb2e7fa68438b587785f26346
parent95b194f6e3456b46c2f994f4f6655fabfcf89c76 (diff)
Initial revisionXORG-STABLE
Diffstat
-rw-r--r--man/mouse.man228
-rw-r--r--src/mouse.c3521
-rw-r--r--src/mouse.h42
-rw-r--r--src/mousePriv.h74
-rw-r--r--src/pnp.c778
5 files changed, 4643 insertions, 0 deletions
diff --git a/man/mouse.man b/man/mouse.man
new file mode 100644
index 0000000..6dcf0f0
--- /dev/null
+++ b/man/mouse.man
@@ -0,0 +1,228 @@
+.\" $XFree86: xc/programs/Xserver/hw/xfree86/input/mouse/mouse.man,v 1.5 2002/12/17 20:55:21 dawes Exp $
+.\" shorthand for double quote that works everywhere.
+.ds q \N'34'
+.TH MOUSE __drivermansuffix__ __vendorversion__
+.SH NAME
+mouse \- Mouse input driver
+.SH SYNOPSIS
+.nf
+.B "Section \*qInputDevice\*q"
+.BI " Identifier \*q" idevname \*q
+.B " Driver \*qmouse\*q"
+.BI " Option \*qProtocol\*q \*q" protoname \*q
+.BI " Option \*qDevice\*q \*q" devpath \*q
+\ \ ...
+.B EndSection
+.fi
+.SH DESCRIPTION
+.B mouse
+is an XFree86 input driver for mice. The driver supports most available
+mouse types and interfaces. USB mice are only supported on some OSs,
+and the level of support for PS/2 mice depends on the OS.
+.PP
+The
+.B mouse
+driver functions as a pointer input device, and may be used as the
+X server's core pointer. Multiple mice are supported by multiple
+instances of this driver.
+.SH SUPPORTED HARDWARE
+There is a detailed list of hardware that the
+.B mouse
+driver supports in the
+.I README.mouse
+document. This can be found
+in __projectroot__/lib/X11/doc/, or online at
+http://www.xfree86.org/current/mouse.html.
+.SH CONFIGURATION DETAILS
+Please refer to XF86Config(__filemansuffix__) for general configuration
+details and for options that can be used with all input drivers. This
+section only covers configuration details specific to this driver.
+.PP
+The driver can auto-detect the mouse type on some platforms On some
+platforms this is limited to plug and play serial mice, and on some the
+auto-detection works for any mouse that the OS's kernel driver supports.
+On others, it is always necessary to specify the mouse protocol in the
+config file. The
+.I README.mouse
+document contains some detailed information about this.
+.PP
+The following driver
+.B Options
+are supported:
+.TP 7
+.BI "Option \*qProtocol\*q \*q" string \*q
+Specify the mouse protocol. Valid protocol types include:
+.PP
+.RS 12
+Auto, Microsoft, MouseSystems, MMSeries, Logitech, MouseMan, MMHitTab,
+GlidePoint, IntelliMouse, ThinkingMouse, AceCad, PS/2, ImPS/2,
+ExplorerPS/2, ThinkingMousePS/2, MouseManPlusPS/2, GlidePointPS/2,
+NetMousePS/2, NetScrollPS/2, BusMouse, SysMouse, WSMouse, USB, Xqueue.
+.RE
+.PP
+.RS 7
+Not all protocols are supported on all platforms. The "Auto" platform
+specifies that protocol auto-detection should be attempted. There is no
+default protocol setting, and specifying this option is mandatory.
+.RE
+.TP 7
+.BI "Option \*qDevice\*q \*q" string \*q
+Specifies the device through which the mouse can be accessed. A common
+setting is "/dev/mouse", which is often a symbolic link to the real
+device. This option is mandatory, and there is no default setting.
+.TP 7
+.BI "Option \*qButtons\*q \*q" integer \*q
+Specifies the number of mouse buttons. In cases where the number of buttons
+cannot be auto-detected, the default value is 3.
+.TP 7
+.BI "Option \*qEmulate3Buttons\*q \*q" boolean \*q
+Enable/disable the emulation of the third (middle) mouse button for mice
+which only have two physical buttons. The third button is emulated by
+pressing both buttons simultaneously. Default: off
+.TP 7
+.BI "Option \*qEmulate3Timeout\*q \*q" integer \*q
+Sets the timeout (in milliseconds) that the driver waits before deciding
+if two buttons where pressed "simultaneously" when 3 button emulation is
+enabled. Default: 50.
+.TP 7
+.BI "Option \*qChordMiddle\*q \*q" boolean \*q
+Enable/disable handling of mice that send left+right events when the middle
+button is used. Default: off.
+.TP 7
+.BI "Option \*qEmulateWheel\*q \*q" boolean \*q
+Enable/disable "wheel" emulation. Wheel emulation means emulating button
+press/release events when the mouse is moved while a specific real button
+is pressed. Wheel button events (typically buttons 4 and 5) are
+usually used for scrolling. Wheel emulation is useful for getting wheel-like
+behaviour with trackballs. It can also be useful for mice with 4 or
+more buttons but no wheel. See the description of the
+.BR EmulateWheelButton ,
+.BR EmulateWheelInertia ,
+.BR XAxisMapping ,
+and
+.B YAxisMapping
+options below. Default: off.
+.TP 7
+.BI "Option \*qEmulateWheelButton\*q \*q" integer \*q
+Specifies which button must be held down to enable wheel emulation mode.
+While this button is down, X and/or Y pointer movement will generate button
+press/release events as specified for the
+.B XAxisMapping
+and
+.B YAxisMapping
+settings. Default: 4.
+.TP 7
+.BI "Option \*qEmulateWheelInertia\*q \*q" integer \*q
+Specifies how far (in pixels) the pointer must move to generate button
+press/release events in wheel emulation mode. Default: 50.
+.TP 7
+.BI "Option \*qXAxisMapping\*q \*q" "N1 N2" \*q
+Specifies which buttons are mapped to motion in the X direction in wheel
+emulation mode. Button number
+.I N1
+is mapped to the negative X axis motion and button number
+.I N2
+is mapped to the positive X axis motion. Default: no mapping.
+.TP 7
+.BI "Option \*qYAxisMapping\*q \*q" "N1 N2" \*q
+Specifies which buttons are mapped to motion in the Y direction in wheel
+emulation mode. Button number
+.I N1
+is mapped to the negative Y axis motion and button number
+.I N2
+is mapped to the positive Y axis motion. Default: "4 5".
+.TP 7
+.BI "Option \*qZAxisMapping\*q \*qX\*q"
+.TP 7
+.BI "Option \*qZAxisMapping\*q \*qY\*q"
+.TP 7
+.BI "Option \*qZAxisMapping\*q \*q" "N1 N2" \*q
+.TP 7
+.BI "Option \*qZAxisMapping\*q \*q" "N1 N2 N3 N4" \*q
+Set the mapping for the Z axis (wheel) motion to buttons or another axis
+.RB ( X
+or
+.BR Y ).
+Button number
+.I N1
+is mapped to the negative Z axis motion and button number
+.I N2
+is mapped to the positive Z axis motion. For mice with two wheels,
+four button numbers can be specified, with the negative and positive motion
+of the second wheel mapped respectively to buttons number
+.I N3
+and
+.IR N4 .
+Default: no mapping.
+.TP 7
+.BI "Option \*qFlipXY\*q \*q" boolean \*q
+Enable/disable swapping the X and Y axes. This transformation is applied
+after the
+.BR InvX ,
+.B InvY
+and
+.BR AngleOffset
+transformations. Default: off.
+.TP 7
+.BI "Option \*qInvX\*q \*q" boolean \*q
+Invert the X axis. Default: off.
+.TP 7
+.BI "Option \*qInvY\*q \*q" boolean \*q
+Invert the Y axis. Default: off.
+.TP 7
+.BI "Option \*qAngleOffset\*q \*q" integer \*q
+Specify a clockwise angular offset (in degrees) to apply to the pointer
+motion. This transformation is applied before the
+.BR FlipXY ,
+.B InvX
+and
+.B InvY
+transformations. Default: 0.
+.TP 7
+.BI "Option \*qSampleRate\*q \*q" integer \*q
+Sets the number of motion/button events the mouse sends per second. Setting
+this is only supported for some mice, including some Logitech mice and
+some PS/2 mice on some platforms. Default: whatever the mouse is
+already set to.
+.TP 7
+.BI "Option \*qResolution\*q \*q" integer \*q
+Sets the resolution of the device in counts per inch. Setting this is
+only supported for some mice, including some PS/2 mice on some platforms.
+Default: whatever the mouse is already set to.
+.TP 7
+.BI "Option \*qDragLockButtons\*q \*q" "L1 B2 L3 B4" \*q
+Sets \*qdrag lock buttons\*q that simulate holding a button down, so
+that low dexterity people do not have to hold a buttton down at the
+same time they move a mouse cursor. Button numbers occur in pairs,
+with the lock button number occurring first, followed by the button
+number that is the target of the lock button.
+.TP 7
+.BI "Option \*qDragLockButtons\*q \*q" "M1" \*q
+Sets a \*qmaster drag lock button\*q that acts as a \*qMeta Key\*q
+indicating that the next button pressed is to be
+\*qdrag locked\*q.
+.TP 7
+.BI "Option \*qClearDTR\*q \*q" boolean \*q
+Enable/disable clearing the DTR line on the serial port used by the mouse.
+Some dual-protocol mice require the DTR line to be cleared to operate
+in the non-default protocol. This option is for serial mice only.
+Default: off.
+.TP 7
+.BI "Option \*qClearRTS\*q \*q" boolean \*q
+Enable/disable clearing the RTS line on the serial port used by the mouse.
+Some dual-protocol mice require the RTS line to be cleared to operate
+in the non-default protocol. This option is for serial mice only.
+Default: off.
+.TP 7
+.BI "Option \*qBaudRate\*q \*q" integer \*q
+Set the baud rate to use for communicating with a serial mouse. This
+option should rarely be required because the default is correct for almost
+all situations. Valid values include: 300, 1200, 2400, 4800, 9600, 19200.
+Default: 1200.
+.PP
+There are some other options that may be used to control various parameters
+for serial port communication, but they are not documented here because
+the driver sets them correctly for each mouse protocol type.
+.SH "SEE ALSO"
+XFree86(1), XF86Config(__filemansuffix__), xf86config(1), Xserver(1), X(__miscmansuffix__),
+README.mouse.
diff --git a/src/mouse.c b/src/mouse.c
new file mode 100644
index 0000000..3234230
--- /dev/null
+++ b/src/mouse.c
@@ -0,0 +1,3521 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/input/mouse/mouse.c,v 1.69 2003/02/11 03:33:06 dawes Exp $ */
+/*
+ *
+ * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
+ * Copyright 1993 by David Dawes <dawes@xfree86.org>
+ * Copyright 2002 by SuSE Linux AG, Author: Egbert Eich
+ * Copyright 1994-2002 by The XFree86 Project, Inc.
+ * Copyright 2002 by Paul Elliott
+ *
+ * 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
+ */
+
+/*
+ * [PME-02/08/11] Added suport for drag lock buttons
+ * for use with 4 button trackballs for convenience
+ * and to help limited dexterity persons
+ */
+
+#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"
+
+enum {
+ /* number of bits in mapped nibble */
+ NIB_BITS=4,
+ /* size of map of nibbles to bitmask */
+ NIB_SIZE= (1 << NIB_BITS),
+ /* mask for map */
+ NIB_MASK= (NIB_SIZE -1),
+ /* number of maps to map all the buttons */
+ NIB_COUNT = ((MSE_MAXBUTTONS+NIB_BITS-1)/NIB_BITS)
+};
+
+/*data to be used in implementing trackball drag locks.*/
+typedef struct _DragLockRec {
+
+ /* Fields used to implement trackball drag locks. */
+ /* mask for those buttons that are ordinary drag lock buttons */
+ int lockButtonsM;
+
+ /* mask for the master drag lock button if any */
+ int masterLockM;
+
+ /* button state up/down from last time adjusted for drag locks */
+ int lockLastButtons;
+
+ /*
+ * true if master lock state i.e. master drag lock
+ * button has just been pressed
+ */
+ int masterTS;
+
+ /* simulate these buttons being down although they are not */
+ int simulatedDown;
+
+ /*
+ * data to map bits for drag lock buttons to corresponding
+ * bits for the target buttons
+ */
+ int nib_table[NIB_COUNT][NIB_SIZE];
+
+} DragLockRec, *DragLockPtr;
+
+
+
+#ifdef XFree86LOADER
+static const OptionInfoRec *MouseAvailableOptions(void *unused);
+#endif
+static InputInfoPtr MousePreInit(InputDriverPtr drv, IDevPtr dev, int flags);
+#if 0
+static void MouseUnInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags);
+#endif
+
+static int MouseProc(DeviceIntPtr device, int what);
+static Bool MouseConvert(LocalDevicePtr local, int first, int num, int v0,
+ int v1, int v2, int v3, int v4, int v5, int *x,
+ int *y);
+
+static void MouseCtrl(DeviceIntPtr device, PtrCtrl *ctrl);
+static void MousePostEvent(InputInfoPtr pInfo, int buttons,
+ int dx, int dy, int dz, int dw);
+static void MouseReadInput(InputInfoPtr pInfo);
+static void MouseBlockHandler(pointer data, struct timeval **waitTime,
+ pointer LastSelectMask);
+static void MouseWakeupHandler(pointer data, int i, pointer LastSelectMask);
+static void FlushButtons(MouseDevPtr pMse);
+
+static Bool SetupMouse(InputInfoPtr pInfo);
+static Bool initMouseHW(InputInfoPtr pInfo);
+#ifdef SUPPORT_MOUSE_RESET
+static Bool mouseReset(InputInfoPtr pInfo, unsigned char val);
+static void ps2WakeupHandler(pointer data, int i, pointer LastSelectMask);
+static void ps2BlockHandler(pointer data, struct timeval **waitTime,
+ pointer LastSelectMask);
+#endif
+
+/* mouse autoprobe stuff */
+static const char *autoOSProtocol(InputInfoPtr pInfo, int *protoPara);
+static void autoProbeMouse(InputInfoPtr pInfo, Bool inSync, Bool lostSync);
+static void checkForErraticMovements(InputInfoPtr pInfo, int dx, int dy);
+static Bool collectData(MouseDevPtr pMse, unsigned char u);
+static void SetMouseProto(MouseDevPtr pMse, MouseProtocolID protocolID);
+static Bool autoGood(MouseDevPtr pMse);
+
+#undef MOUSE
+InputDriverRec MOUSE = {
+ 1,
+ "mouse",
+ NULL,
+ MousePreInit,
+ /*MouseUnInit,*/NULL,
+ NULL,
+ 0
+};
+
+typedef enum {
+ OPTION_ALWAYS_CORE,
+ OPTION_SEND_CORE_EVENTS,
+ OPTION_CORE_POINTER,
+ OPTION_SEND_DRAG_EVENTS,
+ OPTION_HISTORY_SIZE,
+ OPTION_DEVICE,
+ OPTION_PROTOCOL,
+ OPTION_BUTTONS,
+ OPTION_EMULATE_3_BUTTONS,
+ OPTION_EMULATE_3_TIMEOUT,
+ OPTION_CHORD_MIDDLE,
+ OPTION_FLIP_XY,
+ OPTION_INV_X,
+ OPTION_INV_Y,
+ OPTION_ANGLE_OFFSET,
+ OPTION_Z_AXIS_MAPPING,
+ OPTION_SAMPLE_RATE,
+ OPTION_RESOLUTION,
+ OPTION_EMULATE_WHEEL,
+ OPTION_EMU_WHEEL_BUTTON,
+ OPTION_EMU_WHEEL_INERTIA,
+ OPTION_X_AXIS_MAPPING,
+ OPTION_Y_AXIS_MAPPING,
+ OPTION_AUTO_SOFT,
+ OPTION_CLEAR_DTR,
+ OPTION_CLEAR_RTS,
+ OPTION_BAUD_RATE,
+ OPTION_DATA_BITS,
+ OPTION_STOP_BITS,
+ OPTION_PARITY,
+ OPTION_FLOW_CONTROL,
+ OPTION_VTIME,
+ OPTION_VMIN,
+ OPTION_DRAGLOCKBUTTONS
+} MouseOpts;
+
+static const OptionInfoRec mouseOptions[] = {
+ { OPTION_ALWAYS_CORE, "AlwaysCore", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_SEND_CORE_EVENTS, "SendCoreEvents", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_CORE_POINTER, "CorePointer", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_SEND_DRAG_EVENTS, "SendDragEvents", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_HISTORY_SIZE, "HistorySize", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_DEVICE, "Device", OPTV_STRING, {0}, FALSE },
+ { OPTION_PROTOCOL, "Protocol", OPTV_STRING, {0}, FALSE },
+ { OPTION_BUTTONS, "Buttons", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_EMULATE_3_BUTTONS, "Emulate3Buttons",OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_EMULATE_3_TIMEOUT, "Emulate3Timeout",OPTV_INTEGER, {0}, FALSE },
+ { OPTION_CHORD_MIDDLE, "ChordMiddle", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_FLIP_XY, "FlipXY", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_INV_X, "InvX", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_INV_Y, "InvY", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_ANGLE_OFFSET, "AngleOffset", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_Z_AXIS_MAPPING, "ZAxisMapping", OPTV_STRING, {0}, FALSE },
+ { OPTION_SAMPLE_RATE, "SampleRate", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_RESOLUTION, "Resolution", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_EMULATE_WHEEL, "EmulateWheel", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_EMU_WHEEL_BUTTON, "EmulateWheelButton", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_EMU_WHEEL_INERTIA, "EmulateWheelInertia", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_X_AXIS_MAPPING, "XAxisMapping", OPTV_STRING, {0}, FALSE },
+ { OPTION_Y_AXIS_MAPPING, "YAxisMapping", OPTV_STRING, {0}, FALSE },
+ { OPTION_AUTO_SOFT, "AutoSoft", OPTV_BOOLEAN, {0}, FALSE },
+ /* serial options */
+ { OPTION_CLEAR_DTR, "ClearDTR", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_CLEAR_RTS, "ClearRTS", OPTV_BOOLEAN, {0}, FALSE },
+ { OPTION_BAUD_RATE, "BaudRate", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_DATA_BITS, "DataBits", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_STOP_BITS, "StopBits", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_PARITY, "Parity", OPTV_STRING, {0}, FALSE },
+ { OPTION_FLOW_CONTROL, "FlowControl", OPTV_STRING, {0}, FALSE },
+ { OPTION_VTIME, "VTime", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_VMIN, "VMin", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_DRAGLOCKBUTTONS, "DragLockButtons",OPTV_STRING, {0}, FALSE },
+ /* end serial options */
+ { -1, NULL, OPTV_NONE, {0}, FALSE }
+};
+
+/*
+ * 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",
+ NULL
+};
+/* MouseSystems */
+static const char *mlDefaults[] = {
+ "BaudRate", "1200",
+ "DataBits", "8",
+ "StopBits", "2",
+ "Parity", "None",
+ "FlowControl", "None",
+ "VTime", "0",
+ "VMin", "1",
+ NULL
+};
+/* MMSeries */
+static const char *mmDefaults[] = {
+ "BaudRate", "1200",
+ "DataBits", "8",
+ "StopBits", "1",
+ "Parity", "Odd",
+ "FlowControl", "None",
+ "VTime", "0",
+ "VMin", "1",
+ NULL
+};
+#if 0
+/* Logitech series 9 *//* same as msc: now mlDefaults */
+static const char *logiDefaults[] = {
+ "BaudRate", "1200",
+ "DataBits", "8",
+ "StopBits", "2",
+ "Parity", "None",
+ "FlowControl", "None",
+ "VTime", "0",
+ "VMin", "1",
+ NULL
+};
+#endif
+/* Hitachi Tablet */
+static const char *mmhitDefaults[] = {
+ "BaudRate", "1200",
+ "DataBits", "8",
+ "StopBits", "1",
+ "Parity", "None",
+ "FlowControl", "None",
+ "VTime", "0",
+ "VMin", "1",
+ NULL
+};
+/* AceCad Tablet */
+static const char *acecadDefaults[] = {
+ "BaudRate", "9600",
+ "DataBits", "8",
+ "StopBits", "1",
+ "Parity", "Odd",
+ "FlowControl", "None",
+ "VTime", "0",
+ "VMin", "1",
+ NULL
+};
+
+static MouseProtocolRec mouseProtocols[] = {
+
+ /* Serial protocols */
+ { "Microsoft", MSE_SERIAL, msDefaults, PROT_MS },
+ { "MouseSystems", MSE_SERIAL, mlDefaults, PROT_MSC },
+ { "MMSeries", MSE_SERIAL, mmDefaults, PROT_MM },
+ { "Logitech", MSE_SERIAL, mlDefaults, PROT_LOGI },
+ { "MouseMan", MSE_SERIAL, msDefaults, PROT_LOGIMAN },
+ { "MMHitTab", MSE_SERIAL, mmhitDefaults, PROT_MMHIT },
+ { "GlidePoint", MSE_SERIAL, msDefaults, PROT_GLIDE },
+ { "IntelliMouse", MSE_SERIAL, msDefaults, PROT_IMSERIAL },
+ { "ThinkingMouse", MSE_SERIAL, msDefaults, PROT_THINKING },
+ { "AceCad", MSE_SERIAL, acecadDefaults, PROT_ACECAD },
+
+ /* Standard PS/2 */
+ { "PS/2", MSE_PS2, NULL, PROT_PS2 },
+ { "GenericPS/2", MSE_PS2, NULL, PROT_GENPS2 },
+
+ /* Extended PS/2 */
+ { "ImPS/2", MSE_XPS2, NULL, PROT_IMPS2 },
+ { "ExplorerPS/2", MSE_XPS2, NULL, PROT_EXPPS2 },
+ { "ThinkingMousePS/2", MSE_XPS2, NULL, PROT_THINKPS2 },
+ { "MouseManPlusPS/2", MSE_XPS2, NULL, PROT_MMPS2 },
+ { "GlidePointPS/2", MSE_XPS2, NULL, PROT_GLIDEPS2 },
+ { "NetMousePS/2", MSE_XPS2, NULL, PROT_NETPS2 },
+ { "NetScrollPS/2", MSE_XPS2, NULL, PROT_NETSCPS2 },
+
+ /* Bus Mouse */
+ { "BusMouse", MSE_BUS, NULL, PROT_BM },
+
+ /* Auto-detect (PnP) */
+ { "Auto", MSE_AUTO, NULL, PROT_AUTO },
+
+ /* Misc (usually OS-specific) */
+ { "SysMouse", MSE_MISC, mlDefaults, PROT_SYSMOUSE },
+
+ /* end of list */
+ { NULL, MSE_NONE, NULL, PROT_UNKNOWN }
+};
+
+#ifdef XFree86LOADER
+/*ARGSUSED*/
+static const OptionInfoRec *
+MouseAvailableOptions(void *unused)
+{
+ return (mouseOptions);
+}
+#endif
+
+/* Process options common to all mouse types. */
+static void
+MouseCommonOptions(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse;
+ MessageType from = X_DEFAULT;
+ char *s;
+ int origButtons;
+
+ pMse = pInfo->private;
+
+ pMse->buttons = xf86SetIntOption(pInfo->options, "Buttons", 0);
+ from = X_CONFIG;
+ if (!pMse->buttons) {
+ pMse->buttons = MSE_DFLTBUTTONS;
+ from = X_DEFAULT;
+ }
+ origButtons = pMse->buttons;
+
+ pMse->emulate3Buttons = xf86SetBoolOption(pInfo->options,
+ "Emulate3Buttons", FALSE);
+ if (!xf86FindOptionValue(pInfo->options,"Emulate3Buttons"))
+ pMse->emulate3ButtonsSoft = TRUE;
+
+ pMse->emulate3Timeout = xf86SetIntOption(pInfo->options,
+ "Emulate3Timeout", 50);
+ if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft) {
+ xf86Msg(X_CONFIG, "%s: Emulate3Buttons, Emulate3Timeout: %d\n",
+ pInfo->name, pMse->emulate3Timeout);
+ }
+
+ pMse->chordMiddle = xf86SetBoolOption(pInfo->options, "ChordMiddle", FALSE);
+ if (pMse->chordMiddle)
+ xf86Msg(X_CONFIG, "%s: ChordMiddle\n", pInfo->name);
+ pMse->flipXY = xf86SetBoolOption(pInfo->options, "FlipXY", FALSE);
+ if (pMse->flipXY)
+ xf86Msg(X_CONFIG, "%s: FlipXY\n", pInfo->name);
+ if (xf86SetBoolOption(pInfo->options, "InvX", FALSE)) {
+ pMse->invX = -1;
+ xf86Msg(X_CONFIG, "%s: InvX\n", pInfo->name);
+ } else
+ pMse->invX = 1;
+ if (xf86SetBoolOption(pInfo->options, "InvY", FALSE)) {
+ pMse->invY = -1;
+ xf86Msg(X_CONFIG, "%s: InvY\n", pInfo->name);
+ } else
+ pMse->invY = 1;
+ pMse->angleOffset = xf86SetIntOption(pInfo->options, "AngleOffset", 0);
+
+
+ if (pMse->pDragLock)
+ xfree(pMse->pDragLock);
+ pMse->pDragLock = NULL;
+
+ s = xf86SetStrOption(pInfo->options, "DragLockButtons", NULL);
+
+ if (s) {
+ int lock; /* lock button */
+ int target; /* target button */
+ int lockM,targetM; /* bitmasks for drag lock, target */
+ int i, j; /* indexes */
+ char *s1; /* parse input string */
+ DragLockPtr pLock;
+
+ pLock = pMse->pDragLock = xcalloc(1, sizeof(DragLockRec));
+ /* init code */
+
+ /* initial string to be taken apart */
+ s1 = s;
+
+ /* keep getting numbers which are buttons */
+ while ((s1 != NULL) && (lock = strtol(s1, &s1, 10)) != 0) {
+
+ /* check sanity for a button */
+ if ((lock < 0) || (lock > MSE_MAXBUTTONS)) {
+ xf86Msg(X_WARNING, "DragLock: Invalid button number = %d\n",
+ lock);
+ break;
+ };
+ /* turn into a button mask */
+ lockM = 1 << (lock - 1);
+
+ /* try to get drag lock button */
+ if ((s1 == NULL) || ((target=strtol(s1, &s1, 10)) == 0)) {
+ /*if no target, must be a master drag lock button */
+ /* save master drag lock mask */
+ pLock->masterLockM = lockM;
+ xf86Msg(X_CONFIG,
+ "DragLock button %d is master drag lock",
+ lock);
+ } else {
+ /* have target button number*/
+ /* check target button number for sanity */
+ if ((target < 0) || (target > MSE_MAXBUTTONS)) {
+ xf86Msg(X_WARNING,
+ "DragLock: Invalid button number for target=%d\n",
+ target);
+ break;
+ }
+
+ /* target button mask */
+ targetM = 1 << (target - 1);
+
+ xf86Msg(X_CONFIG,
+ "DragLock: button %d is drag lock for button %d\n",
+ lock,target);
+ lock--;
+
+ /* initialize table that maps drag lock mask to target mask */
+ pLock->nib_table[lock / NIB_SIZE][1 << (lock % NIB_BITS)] =
+ targetM;
+
+ /* add new drag lock to mask of drag locks */
+ pLock->lockButtonsM |= lockM;
+ }
+
+ }
+
+ /*
+ * fill out rest of map that maps sets of drag lock buttons
+ * to sets of target buttons, in the form of masks
+ */
+
+ /* for each nibble */
+ for (i = 0; i < NIB_COUNT; i++) {
+ /* for each possible set of bits for that nibble */
+ for (j = 0; j < NIB_SIZE; j++) {
+ int ff, fM, otherbits;
+
+ /* get first bit set in j*/
+ ff = ffs(j) - 1;
+ /* if 0 bits set nothing to do */
+ if (ff >= 0) {
+ /* form mask for fist bit set */
+ fM = 1 << ff;
+ /* mask off first bit set to get remaining bits set*/
+ otherbits = j & ~fM;
+ /*
+ * if otherbits =0 then only 1 bit set
+ * so j=fM
+ * nib_table[i][fM] already calculated if fM has
+ * only 1 bit set.
+ * nib_table[i][j] has already been filled in
+ * by previous loop. otherwise
+ * otherbits < j so nibtable[i][otherbits]
+ * has already been calculated.
+ */
+ if (otherbits)
+ pLock->nib_table[i][j] =
+ pLock->nib_table[i][fM] |
+ pLock->nib_table[i][otherbits];
+
+ }
+ }
+ }
+ }
+
+ s = xf86SetStrOption(pInfo->options, "ZAxisMapping", NULL);
+ if (s) {
+ int b1 = 0, b2 = 0, b3 = 0, b4 = 0;
+ char *msg = NULL;
+
+ if (!xf86NameCmp(s, "x")) {
+ pMse->negativeZ = pMse->positiveZ = MSE_MAPTOX;
+ pMse->negativeW = pMse->positiveW = MSE_MAPTOX;
+ msg = xstrdup("X axis");
+ } else if (!xf86NameCmp(s, "y")) {
+ pMse->negativeZ = pMse->positiveZ = MSE_MAPTOY;
+ pMse->negativeW = pMse->positiveW = MSE_MAPTOY;
+ msg = xstrdup("Y axis");
+ } else if (sscanf(s, "%d %d %d %d", &b1, &b2, &b3, &b4) >= 2 &&
+ b1 > 0 && b1 <= MSE_MAXBUTTONS &&
+ b2 > 0 && b2 <= MSE_MAXBUTTONS) {
+ msg = xstrdup("buttons XX and YY");
+ if (msg)
+ sprintf(msg, "buttons %d and %d", b1, b2);
+ pMse->negativeZ = pMse->negativeW = 1 << (b1-1);
+ pMse->positiveZ = pMse->positiveW = 1 << (b2-1);
+ if (b3 > 0 && b3 <= MSE_MAXBUTTONS &&
+ b4 > 0 && b4 <= MSE_MAXBUTTONS) {
+ if (msg)
+ xfree(msg);
+ msg = xstrdup("buttons XX, YY, ZZ and WW");
+ if (msg)
+ sprintf(msg, "buttons %d, %d, %d and %d", b1, b2, b3, b4);
+ pMse->negativeW = 1 << (b3-1);
+ pMse->positiveW = 1 << (b4-1);
+ }
+ if (b1 > pMse->buttons) pMse->buttons = b1;
+ if (b2 > pMse->buttons) pMse->buttons = b2;
+ if (b3 > pMse->buttons) pMse->buttons = b3;
+ if (b4 > pMse->buttons) pMse->buttons = b4;
+ } else {
+ pMse->negativeZ = pMse->positiveZ = MSE_NOZMAP;
+ pMse->negativeW = pMse->positiveW = MSE_NOZMAP;
+ }
+ if (msg) {
+ xf86Msg(X_CONFIG, "%s: ZAxisMapping: %s\n", pInfo->name, msg);
+ xfree(msg);
+ } else {
+ xf86Msg(X_WARNING, "%s: Invalid ZAxisMapping value: \"%s\"\n",
+ pInfo->name, s);
+ }
+ }
+ if (xf86SetBoolOption(pInfo->options, "EmulateWheel", FALSE)) {
+ Bool yFromConfig = FALSE;
+ int wheelButton;
+
+ pMse->emulateWheel = TRUE;
+ wheelButton = xf86SetIntOption(pInfo->options,
+ "EmulateWheelButton", 4);
+ if (wheelButton < 0 || wheelButton > MSE_MAXBUTTONS) {
+ xf86Msg(X_WARNING, "%s: Invalid EmulateWheelButton value: %d\n",
+ pInfo->name, wheelButton);
+ wheelButton = 4;
+ }
+ pMse->wheelButtonMask = 1 << (wheelButton - 1);
+
+ pMse->wheelInertia = xf86SetIntOption(pInfo->options,
+ "EmulateWheelInertia", 10);
+ if (pMse->wheelInertia <= 0) {
+ xf86Msg(X_WARNING, "%s: Invalid EmulateWheelInertia value: %d\n",
+ pInfo->name, pMse->wheelInertia);
+ pMse->wheelInertia = 50;
+ }
+
+ pMse->negativeX = MSE_NOAXISMAP;
+ pMse->positiveX = MSE_NOAXISMAP;
+ s = xf86SetStrOption(pInfo->options, "XAxisMapping", NULL);
+ if (s) {
+ int b1 = 0, b2 = 0;
+ char *msg = NULL;
+
+ if ((sscanf(s, "%d %d", &b1, &b2) == 2) &&
+ b1 > 0 && b1 <= MSE_MAXBUTTONS &&
+ b2 > 0 && b2 <= MSE_MAXBUTTONS) {
+ msg = xstrdup("buttons XX and YY");
+ if (msg)
+ sprintf(msg, "buttons %d and %d", b1, b2);
+ pMse->negativeX = b1;
+ pMse->positiveX = b2;
+ if (b1 > pMse->buttons) pMse->buttons = b1;
+ if (b2 > pMse->buttons) pMse->buttons = b2;
+ } else {
+ xf86Msg(X_WARNING, "%s: Invalid XAxisMapping value: \"%s\"\n",
+ pInfo->name, s);
+ }
+ if (msg) {
+ xf86Msg(X_CONFIG, "%s: XAxisMapping: %s\n", pInfo->name, msg);
+ xfree(msg);
+ }
+ }
+ s = xf86SetStrOption(pInfo->options, "YAxisMapping", NULL);
+ if (s) {
+ int b1 = 0, b2 = 0;
+ char *msg = NULL;
+
+ if ((sscanf(s, "%d %d", &b1, &b2) == 2) &&
+ b1 > 0 && b1 <= MSE_MAXBUTTONS &&
+ b2 > 0 && b2 <= MSE_MAXBUTTONS) {
+ msg = xstrdup("buttons XX and YY");
+ if (msg)
+ sprintf(msg, "buttons %d and %d", b1, b2);
+ pMse->negativeY = b1;
+ pMse->positiveY = b2;
+ if (b1 > pMse->buttons) pMse->buttons = b1;
+ if (b2 > pMse->buttons) pMse->buttons = b2;
+ yFromConfig = TRUE;
+ } else {
+ xf86Msg(X_WARNING, "%s: Invalid YAxisMapping value: \"%s\"\n",
+ pInfo->name, s);
+ }
+ if (msg) {
+ xf86Msg(X_CONFIG, "%s: YAxisMapping: %s\n", pInfo->name, msg);
+ xfree(msg);
+ }
+ }
+ if (!yFromConfig) {
+ pMse->negativeY = 4;
+ pMse->positiveY = 5;
+ if (pMse->negativeY > pMse->buttons)
+ pMse->buttons = pMse->negativeY;
+ if (pMse->positiveY > pMse->buttons)
+ pMse->buttons = pMse->positiveY;
+ xf86Msg(X_DEFAULT, "%s: YAxisMapping: buttons %d and %d\n",
+ pInfo->name, pMse->negativeY, pMse->positiveY);
+ }
+ xf86Msg(X_CONFIG, "%s: EmulateWheel, EmulateWheelButton: %d, "
+ "EmulateWheelInertia: %d\n",
+ pInfo->name, wheelButton, pMse->wheelInertia);
+ }
+ if (origButtons != pMse->buttons)
+ from = X_CONFIG;
+ xf86Msg(from, "%s: Buttons: %d\n", pInfo->name, pMse->buttons);
+
+}
+/*
+ * map bits corresponding to lock buttons.
+ * for each bit for a lock button,
+ * turn on bit corresponding to button button that the lock
+ * button services.
+ */
+
+static int
+lock2targetMap(DragLockPtr pLock, int lockMask)
+{
+ int result,i;
+ result = 0;
+
+ /*
+ * for each nibble group of bits, use
+ * map for that group to get corresponding
+ * bits, turn them on.
+ * if 4 or less buttons only first map will
+ * need to be used.
+ */
+ for (i = 0; (i < NIB_COUNT) && lockMask; i++) {
+ result |= pLock->nib_table[i][lockMask& NIB_MASK];
+
+ lockMask &= ~NIB_MASK;
+ lockMask >>= NIB_BITS;
+ }
+ return result;
+}
+
+static void
+MouseHWOptions(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse = pInfo->private;
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+
+ if (mPriv == NULL)
+ return;
+
+ if ((mPriv->soft
+ = xf86SetBoolOption(pInfo->options, "AutoSoft", FALSE))) {
+ xf86Msg(X_CONFIG, "Don't initialize mouse when auto-probing\n");
+ }
+ pMse->sampleRate = xf86SetIntOption(pInfo->options, "SampleRate", 0);
+ if (pMse->sampleRate) {
+ xf86Msg(X_CONFIG, "%s: SampleRate: %d\n", pInfo->name,
+ pMse->sampleRate);
+ }
+ pMse->resolution = xf86SetIntOption(pInfo->options, "Resolution", 0);
+ if (pMse->resolution) {
+ xf86Msg(X_CONFIG, "%s: Resolution: %d\n", pInfo->name,
+ pMse->resolution);
+ }
+}
+
+static void
+MouseSerialOptions(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse = pInfo->private;
+ Bool clearDTR, clearRTS;
+
+
+ pMse->baudRate = xf86SetIntOption(pInfo->options, "BaudRate", 0);
+ if (pMse->baudRate) {
+ xf86Msg(X_CONFIG, "%s: BaudRate: %d\n", pInfo->name,
+ pMse->baudRate);
+ }
+
+ if ((clearDTR = xf86SetBoolOption(pInfo->options, "ClearDTR",FALSE)))
+ pMse->mouseFlags |= MF_CLEAR_DTR;
+
+
+ if ((clearRTS = xf86SetBoolOption(pInfo->options, "ClearRTS",FALSE)))
+ pMse->mouseFlags |= MF_CLEAR_RTS;
+
+ if (clearDTR || clearRTS) {
+ xf86Msg(X_CONFIG, "%s: ", pInfo->name);
+ if (clearDTR) {
+ xf86ErrorF("ClearDTR");
+ if (clearRTS)
+ xf86ErrorF(", ");
+ }
+ if (clearRTS) {
+ xf86ErrorF("ClearRTS");
+ }
+ xf86ErrorF("\n");
+ }
+}
+
+static MouseProtocolID
+ProtocolNameToID(const char *name)
+{
+ int i;
+
+ for (i = 0; mouseProtocols[i].name; i++)
+ if (xf86NameCmp(name, mouseProtocols[i].name) == 0)
+ return mouseProtocols[i].id;
+ return PROT_UNKNOWN;
+}
+
+static const char *
+ProtocolIDToName(MouseProtocolID id)
+{
+ int i;
+
+ switch (id) {
+ case PROT_UNKNOWN:
+ return "Unknown";
+ break;
+ case PROT_UNSUP:
+ return "Unsupported";
+ break;
+ default:
+ for (i = 0; mouseProtocols[i].name; i++)
+ if (id == mouseProtocols[i].id)
+ return mouseProtocols[i].name;
+ return "Invalid";
+ }
+}
+
+const char *
+xf86MouseProtocolIDToName(MouseProtocolID id)
+{
+ return ProtocolIDToName(id);
+}
+
+MouseProtocolID
+xf86MouseProtocolNameToID(const char *name)
+{
+ return ProtocolNameToID(name);
+}
+
+static int
+ProtocolIDToClass(MouseProtocolID id)
+{
+ int i;
+
+ switch (id) {
+ case PROT_UNKNOWN:
+ case PROT_UNSUP:
+ return MSE_NONE;
+ break;
+ default:
+ for (i = 0; mouseProtocols[i].name; i++)
+ if (id == mouseProtocols[i].id)
+ return mouseProtocols[i].class;
+ return MSE_NONE;
+ }
+}
+
+static MouseProtocolPtr
+GetProtocol(MouseProtocolID id) {
+ int i;
+
+ switch (id) {
+ case PROT_UNKNOWN:
+ case PROT_UNSUP:
+ return NULL;
+ break;
+ default:
+ for (i = 0; mouseProtocols[i].name; i++)
+ if (id == mouseProtocols[i].id) {
+ return &mouseProtocols[i];
+ }
+ return NULL;
+ }
+}
+
+static OSMouseInfoPtr osInfo = NULL;
+
+static Bool
+InitProtocols(void)
+{
+ int classes;
+ int i;
+ const char *osname = NULL;
+
+ if (osInfo)
+ return TRUE;
+
+ osInfo = xf86OSMouseInit(0);
+ if (!osInfo)
+ return FALSE;
+ if (!osInfo->SupportedInterfaces)
+ return FALSE;
+
+ classes = osInfo->SupportedInterfaces();
+ if (!classes)
+ return FALSE;
+
+ /* Mark unsupported interface classes. */
+ for (i = 0; mouseProtocols[i].name; i++)
+ if (!(mouseProtocols[i].class & classes))
+ mouseProtocols[i].id = PROT_UNSUP;
+
+ for (i = 0; mouseProtocols[i].name; i++)
+ if (mouseProtocols[i].class & MSE_MISC)
+ if (!osInfo->CheckProtocol ||
+ !osInfo->CheckProtocol(mouseProtocols[i].name))
+ mouseProtocols[i].id = PROT_UNSUP;
+
+ /* NetBSD uses PROT_BM for "PS/2". */
+ xf86GetOS(&osname, NULL, NULL, NULL);
+ if (osname && xf86NameCmp(osname, "netbsd") == 0)
+ for (i = 0; mouseProtocols[i].name; i++)
+ if (mouseProtocols[i].id == PROT_PS2)
+ mouseProtocols[i].id = PROT_BM;
+
+ return TRUE;
+}
+
+static InputInfoPtr
+MousePreInit(InputDriverPtr drv, IDevPtr dev, int flags)
+{
+ InputInfoPtr pInfo;
+ MouseDevPtr pMse;
+ mousePrivPtr mPriv;
+ MessageType from = X_DEFAULT;
+ const char *protocol, *osProt = NULL;
+ MouseProtocolID protocolID;
+ MouseProtocolPtr pProto;
+ Bool detected;
+
+ if (!InitProtocols())
+ return NULL;
+
+ if (!(pInfo = xf86AllocateInput(drv, 0)))
+ return NULL;
+
+ /* Initialise the InputInfoRec. */
+ pInfo->name = dev->identifier;
+ pInfo->type_name = XI_MOUSE;
+ pInfo->flags = XI86_POINTER_CAPABLE | XI86_SEND_DRAG_EVENTS;
+ pInfo->device_control = MouseProc;
+ pInfo->read_input = MouseReadInput;
+ pInfo->motion_history_proc = xf86GetMotionEvents;
+ pInfo->history_size = 0;
+ pInfo->control_proc = NULL;
+ pInfo->close_proc = NULL;
+ pInfo->switch_mode = NULL;
+ pInfo->conversion_proc = MouseConvert;
+ pInfo->reverse_conversion_proc = NULL;
+ pInfo->fd = -1;
+ pInfo->dev = NULL;
+ pInfo->private_flags = 0;
+ pInfo->always_core_feedback = 0;
+ pInfo->conf_idev = dev;
+
+ /* 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.
+ */
+ if (!(pMse = xcalloc(sizeof(MouseDevRec), 1)))
+ return pInfo;
+ pInfo->private = pMse;
+ pMse->Ctrl = MouseCtrl;
+ pMse->PostEvent = MousePostEvent;
+ pMse->CommonOptions = MouseCommonOptions;
+
+ /* Find the protocol type. */
+ protocol = xf86SetStrOption(dev->commonOptions, "Protocol", NULL);
+ if (protocol) {
+ from = X_CONFIG;
+ } else if (osInfo->DefaultProtocol) {
+ protocol = osInfo->DefaultProtocol();
+ from = X_DEFAULT;
+ }
+ if (!protocol) {
+ xf86Msg(X_ERROR, "%s: No Protocol specified\n", pInfo->name);
+ return pInfo;
+ }
+
+ protocolID = ProtocolNameToID(protocol);
+ do {
+ detected = TRUE;
+ switch (protocolID) {
+ case PROT_AUTO:
+ if (osInfo->SetupAuto) {
+ if ((osProt = osInfo->SetupAuto(pInfo,NULL))) {
+ int id = ProtocolNameToID(osProt);
+ if (id == PROT_UNKNOWN || id == PROT_UNSUP) {
+ protocolID = id;
+ protocol = osProt;
+ detected = FALSE;
+ }
+ }
+ }
+ break;
+ case PROT_UNKNOWN:
+ /* Check for a builtin OS-specific protocol,
+ * and call its PreInit. */
+ if (osInfo->CheckProtocol
+ && osInfo->CheckProtocol(protocol)) {
+ if (osInfo->PreInit) {
+ osInfo->PreInit(pInfo, protocol, 0);
+ }
+ return pInfo;
+ }
+ xf86Msg(X_ERROR, "%s: Unknown protocol \"%s\"\n",
+ pInfo->name, protocol);
+ return pInfo;
+ break;
+ case PROT_UNSUP:
+ xf86Msg(X_ERROR,
+ "%s: Protocol \"%s\" is not supported on this "
+ "platform\n", pInfo->name, protocol);
+ return pInfo;
+ break;
+ default:
+ break;
+
+ }
+ } while (!detected);
+
+
+ xf86Msg(from, "%s: Protocol: \"%s\"\n", pInfo->name, protocol);
+ if (!(pProto = GetProtocol(protocolID)))
+ return pInfo;
+
+ pMse->protocolID = protocolID;
+ pMse->oldProtocolID = protocolID; /* hack */
+
+ pMse->autoProbe = FALSE;
+
+ /* Collect the options, and process the common options. */
+ xf86CollectInputOptions(pInfo, pProto->defaults, NULL);
+ xf86ProcessCommonOptions(pInfo, pInfo->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. */
+ pInfo->fd = xf86OpenSerial(pInfo->options);
+ if (pInfo->fd == -1) {
+ if (xf86GetAllowMouseOpenFail())
+ xf86Msg(X_WARNING, "%s: cannot open input device\n", pInfo->name);
+ else {
+ xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
+ if (pMse->mousePriv)
+ xfree(pMse->mousePriv);
+ xfree(pMse);
+ pInfo->private = NULL;
+ return pInfo;
+ }
+ }
+ xf86CloseSerial(pInfo->fd);
+#endif
+ pInfo->fd = -1;
+
+ if (!(mPriv = (pointer) xcalloc(sizeof(mousePrivRec), 1)))
+ return pInfo;
+ pMse->mousePriv = mPriv;
+ pMse->CommonOptions(pInfo);
+ pMse->checkMovements = checkForErraticMovements;
+ pMse->autoProbeMouse = autoProbeMouse;
+ pMse->collectData = collectData;
+ pMse->dataGood = autoGood;
+
+ MouseHWOptions(pInfo);
+ MouseSerialOptions(pInfo);
+
+ pInfo->flags |= XI86_CONFIGURED;
+ return pInfo;
+}
+
+
+static void
+MouseReadInput(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse;
+ int j, buttons, dx, dy, dz, dw, baddata;
+ int pBufP;
+ int c;
+ unsigned char *pBuf, u;
+
+
+ pMse = pInfo->private;
+ pBufP = pMse->protoBufTail;
+ pBuf = pMse->protoBuf;
+
+ /*
+ * 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.
+ */
+ XisbBlockDuration(pMse->buffer, -1);
+
+ while ((c = XisbRead(pMse->buffer)) >= 0) {
+ u = (unsigned char)c;
+#if 1
+ /* if we do autoprobing collect the data */
+ if (pMse->collectData && pMse->autoProbe)
+ if (pMse->collectData(pMse,u))
+ continue;
+#endif
+#ifdef SUPPORT_MOUSE_RESET
+ if (mouseReset(pInfo,u)) {
+ pBufP = 0;
+ continue;
+ }
+#endif
+ if (pBufP >= pMse->protoPara[4]) {
+ /*
+ * 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;
+ if ((u & pMse->protoPara[0]) != pMse->protoPara[1] &&
+ (u & pMse->protoPara[5]) == pMse->protoPara[6]) {
+ /*
+ * 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\n",u);
+#endif
+ dx = dy = dz = dw = 0;
+ 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);
+ if ((dz >= 7) || (dz <= -7))
+ dz = 0;
+ buttons |= ((int)(u & 0x10) >> 3)
+ | ((int)(u & 0x20) >> 2)
+ | (pMse->lastButtons & 0x05);
+ break;
+
+ case PROT_GLIDE:
+ case PROT_THINKING:
+ buttons |= ((int)(u & 0x10) >> 1);
+ /* fall through */
+
+ default:
+ buttons |= ((int)(u & 0x20) >> 4) |
+ (pMse->lastButtons & 0x05);
+ 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.
+ */
+ pBuf[pBufP++] = u;
+ if (pBufP != pMse->protoPara[4]) continue;
+#ifdef EXTMOUSEDEBUG2
+ {
+ int i;
+ ErrorF("received %d bytes",pBufP);
+ for ( i=0; i < pBufP; i++)
+ ErrorF(" %02x",pBuf[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
+ * bad if any byte (header and/or data) contains an invalid value.
+ *
+ * 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++ )
+ if ((pBuf[j] & pMse->protoPara[2]) != pMse->protoPara[3])
+ baddata = 1;
+
+ /* If out of sync, don't mistake a header byte for data. */
+ if ((pMse->protoPara[7] & MPF_SAFE) && !pMse->inSync)
+ for (j = 1; j < pBufP; j++ )
+ if ((pBuf[j] & pMse->protoPara[0]) == pMse->protoPara[1])
+ baddata = 1;
+
+ /* Accept or reject the packet ? */
+ if ((pBuf[0] & pMse->protoPara[0]) != pMse->protoPara[1] || baddata) {
+ if (pMse->inSync) {
+#ifdef EXTMOUSEDEBUG
+ ErrorF("mouse driver lost sync\n");
+#endif
+ }
+#ifdef EXTMOUSEDEBUG
+ ErrorF("skipping byte %02x\n",*pBuf);
+#endif
+ /* Tell auto probe that we are out of sync */
+ if (pMse->autoProbeMouse && pMse->autoProbe)
+ pMse->autoProbeMouse(pInfo, FALSE, pMse->inSync);
+ pMse->protoBufTail = --pBufP;
+ for (j = 0; j < pBufP; j++)
+ pBuf[j] = pBuf[j+1];
+ pMse->inSync = 0;
+ continue;
+ }
+ /* Tell auto probe that we were successful */
+ if (pMse->autoProbeMouse && pMse->autoProbe)
+ pMse->autoProbeMouse(pInfo, TRUE, FALSE);
+
+ if (!pMse->inSync) {
+#ifdef EXTMOUSEDEBUG
+ ErrorF("mouse driver back in sync\n");
+#endif
+ pMse->inSync = 1;
+ }
+
+ if (!pMse->dataGood(pMse))
+ continue;
+
+ /*
+ * Packet complete and verified, now process it ...
+ */
+ REDO_INTERPRET:
+ dz = dw = 0;
+ switch (pMse->protocolID) {
+ case PROT_LOGIMAN: /* MouseMan / TrackMan [CHRIS-211092] */
+ case PROT_MS: /* Microsoft */
+ if (pMse->chordMiddle)
+ buttons = (((int) pBuf[0] & 0x30) == 0x30) ? 2 :
+ ((int)(pBuf[0] & 0x20) >> 3)
+ | ((int)(pBuf[0] & 0x10) >> 4);
+ else
+ buttons = (pMse->lastButtons & 2)
+ | ((int)(pBuf[0] & 0x20) >> 3)
+ | ((int)(pBuf[0] & 0x10) >> 4);
+ dx = (char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
+ dy = (char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
+ break;
+
+ case PROT_GLIDE: /* ALPS GlidePoint */
+ case PROT_THINKING: /* ThinkingMouse */
+ case PROT_IMSERIAL: /* IntelliMouse, NetMouse, Mie Mouse, MouseMan+ */
+ buttons = (pMse->lastButtons & (8 + 2))
+ | ((int)(pBuf[0] & 0x20) >> 3)
+ | ((int)(pBuf[0] & 0x10) >> 4);
+ dx = (char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
+ dy = (char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
+ break;
+
+ case PROT_MSC: /* Mouse Systems Corp */
+ buttons = (~pBuf[0]) & 0x07;
+ dx = (char)(pBuf[1]) + (char)(pBuf[3]);
+ dy = - ((char)(pBuf[2]) + (char)(pBuf[4]));
+ break;
+
+ case PROT_MMHIT: /* MM_HitTablet */
+ buttons = pBuf[0] & 0x07;
+ if (buttons != 0)
+ buttons = 1 << (buttons - 1);
+ dx = (pBuf[0] & 0x10) ? pBuf[1] : - pBuf[1];
+ dy = (pBuf[0] & 0x08) ? - pBuf[2] : pBuf[2];
+ break;
+
+ case PROT_ACECAD: /* ACECAD */
+ /* ACECAD is almost exactly like MM but the buttons are different */
+ buttons = (pBuf[0] & 0x02) | ((pBuf[0] & 0x04) >> 2) |
+ ((pBuf[0] & 1) << 2);
+ dx = (pBuf[0] & 0x10) ? pBuf[1] : - pBuf[1];
+ dy = (pBuf[0] & 0x08) ? - pBuf[2] : pBuf[2];
+ break;
+
+ case PROT_MM: /* MM Series */
+ case PROT_LOGI: /* Logitech Mice */
+ buttons = pBuf[0] & 0x07;
+ dx = (pBuf[0] & 0x10) ? pBuf[1] : - pBuf[1];
+ dy = (pBuf[0] & 0x08) ? - pBuf[2] : pBuf[2];
+ break;
+
+ case PROT_BM: /* BusMouse */
+ buttons = (~pBuf[0]) & 0x07;
+ dx = (char)pBuf[1];
+ dy = - (char)pBuf[2];
+ break;
+
+ case PROT_PS2: /* PS/2 mouse */
+ case PROT_GENPS2: /* generic PS/2 mouse */
+ buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
+ (pBuf[0] & 0x02) >> 1 | /* Right */
+ (pBuf[0] & 0x01) << 2; /* Left */
+ dx = (pBuf[0] & 0x10) ? (int)pBuf[1]-256 : (int)pBuf[1];
+ dy = (pBuf[0] & 0x20) ? -((int)pBuf[2]-256) : -(int)pBuf[2];
+ break;
+
+ /* PS/2 mouse variants */
+ case PROT_IMPS2: /* IntelliMouse PS/2 */
+ case PROT_NETPS2: /* NetMouse PS/2 */
+ buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
+ (pBuf[0] & 0x02) >> 1 | /* Right */
+ (pBuf[0] & 0x01) << 2 | /* Left */
+ (pBuf[0] & 0x40) >> 3 | /* button 4 */
+ (pBuf[0] & 0x80) >> 3; /* button 5 */
+ dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
+ dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
+ dz = (char)pBuf[3];
+ if ((dz >= 7) || (dz <= -8)) {
+ if (pMse->autoProbe && !(pBuf[3] & 0xC0)) {
+ SetMouseProto(pMse, PROT_EXPPS2);
+ xf86Msg(X_INFO,
+ "Mouse autoprobe: Changing protocol to %s\n",
+ pMse->protocol);
+
+ goto REDO_INTERPRET;
+ } else
+ dz = 0;
+ }
+ break;
+
+ case PROT_EXPPS2: /* IntelliMouse Explorer PS/2 */
+ if (pMse->autoProbe && (pBuf[3] & 0xC0)) {
+ SetMouseProto(pMse, PROT_IMPS2);
+ xf86Msg(X_INFO,"Mouse autoprobe: Changing protocol to %s\n",
+ pMse->protocol);
+ goto REDO_INTERPRET;
+ }
+ buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
+ (pBuf[0] & 0x02) >> 1 | /* Right */
+ (pBuf[0] & 0x01) << 2 | /* Left */
+ (pBuf[3] & 0x10) >> 1 | /* button 4 */
+ (pBuf[3] & 0x20) >> 1; /* button 5 */
+ dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
+ dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
+ dz = (pBuf[3] & 0x08) ? (pBuf[3] & 0x0f) - 16 : (pBuf[3] & 0x0f);
+ break;
+
+ case PROT_MMPS2: /* MouseMan+ PS/2 */
+ buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
+ (pBuf[0] & 0x02) >> 1 | /* Right */
+ (pBuf[0] & 0x01) << 2; /* Left */
+ dx = (pBuf[0] & 0x10) ? pBuf[1] - 256 : pBuf[1];
+ if (((pBuf[0] & 0x48) == 0x48) &&
+ (abs(dx) > 191) &&
+ ((((pBuf[2] & 0x03) << 2) | 0x02) == (pBuf[1] & 0x0f))) {
+ /* extended data packet */
+ switch ((((pBuf[0] & 0x30) >> 2) | ((pBuf[1] & 0x30) >> 4))) {
+ case 1: /* wheel data packet */
+ buttons |= ((pBuf[2] & 0x10) ? 0x08 : 0) | /* 4th button */
+ ((pBuf[2] & 0x20) ? 0x10 : 0); /* 5th button */
+ dx = dy = 0;
+ dz = (pBuf[2] & 0x08) ? (pBuf[2] & 0x0f) - 16 :
+ (pBuf[2] & 0x0f);
+ break;
+ case 2: /* Logitech reserves this packet type */
+ /*
+ * IBM ScrollPoint uses this packet to encode its
+ * stick movement.
+ */
+ buttons |= (pMse->lastButtons & ~0x07);
+ dx = dy = 0;
+ dz = (pBuf[2] & 0x80) ? ((pBuf[2] >> 4) & 0x0f) - 16 :
+ ((pBuf[2] >> 4) & 0x0f);
+ dw = (pBuf[2] & 0x08) ? (pBuf[2] & 0x0f) - 16 :
+ (pBuf[2] & 0x0f);
+ break;
+ case 0: /* device type packet - shouldn't happen */
+ default:
+ buttons |= (pMse->lastButtons & ~0x07);
+ dx = dy = 0;
+ dz = 0;
+ break;
+ }
+ } else {
+ buttons |= (pMse->lastButtons & ~0x07);
+ dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
+ dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
+ }
+ break;
+
+ case PROT_GLIDEPS2: /* GlidePoint PS/2 */
+ buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
+ (pBuf[0] & 0x02) >> 1 | /* Right */
+ (pBuf[0] & 0x01) << 2 | /* Left */
+ ((pBuf[0] & 0x08) ? 0 : 0x08);/* fourth button */
+ dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
+ dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
+ break;
+
+ case PROT_NETSCPS2: /* NetScroll PS/2 */
+ buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
+ (pBuf[0] & 0x02) >> 1 | /* Right */
+ (pBuf[0] & 0x01) << 2 | /* Left */
+ ((pBuf[3] & 0x02) ? 0x08 : 0) | /* button 4 */
+ ((pBuf[3] & 0x01) ? 0x10 : 0); /* button 5 */
+ dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
+ dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
+ dz = (pBuf[3] & 0x10) ? pBuf[4] - 256 : pBuf[4];
+ break;
+
+ case PROT_THINKPS2: /* ThinkingMouse PS/2 */
+ buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
+ (pBuf[0] & 0x02) >> 1 | /* Right */
+ (pBuf[0] & 0x01) << 2 | /* Left */
+ ((pBuf[0] & 0x08) ? 0x08 : 0);/* fourth button */
+ pBuf[1] |= (pBuf[0] & 0x40) ? 0x80 : 0x00;
+ dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
+ dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
+ break;
+
+ case PROT_SYSMOUSE: /* sysmouse */
+ buttons = (~pBuf[0]) & 0x07;
+ dx = (char)(pBuf[1]) + (char)(pBuf[3]);
+ dy = - ((char)(pBuf[2]) + (char)(pBuf[4]));
+ /* FreeBSD sysmouse sends additional data bytes */
+ if (pMse->protoPara[4] >= 8) {
+ dz = ((signed char)(pBuf[5] << 1) +
+ (signed char)(pBuf[6] << 1)) >> 1;
+ buttons |= (int)(~pBuf[7] & 0x7f) << 3;
+ }
+ 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++)
+ ErrorF(" %02x",pBuf[j]);
+ ErrorF("\n");
+#endif
+
+post_event:
+#ifdef EXTMOUSEDEBUG
+ ErrorF("dx=%i dy=%i dz=%i dw=%i buttons=%x\n",dx,dy,dz,dw,buttons);
+#endif
+ /* When auto-probing check if data makes sense */
+ if (pMse->checkMovements && pMse->autoProbe)
+ pMse->checkMovements(pInfo,dx,dy);
+ /* post an event */
+ pMse->PostEvent(pInfo, buttons, dx, dy, dz, dw);
+
+ /*
+ * We don't reset pBufP here yet, as there may be an additional data
+ * byte in some protocols. See above.
+ */
+ }
+ pMse->protoBufTail = pBufP;
+}
+
+/*
+ * MouseCtrl --
+ * Alter the control parameters for the mouse. Note that all special
+ * protocol values are handled by dix.
+ */
+
+static void
+MouseCtrl(DeviceIntPtr device, PtrCtrl *ctrl)
+{
+ InputInfoPtr pInfo;
+ MouseDevPtr pMse;
+
+ pInfo = device->public.devicePrivate;
+ pMse = pInfo->private;
+
+#ifdef EXTMOUSEDEBUG
+ ErrorF("MouseCtrl pMse=%p\n", pMse);
+#endif
+
+ pMse->num = ctrl->num;
+ pMse->den = ctrl->den;
+ pMse->threshold = ctrl->threshold;
+}
+
+/*
+ ***************************************************************************
+ *
+ * MouseProc --
+ *
+ ***************************************************************************
+ */
+
+static int
+MouseProc(DeviceIntPtr device, int what)
+{
+ InputInfoPtr pInfo;
+ MouseDevPtr pMse;
+ mousePrivPtr mPriv;
+ unsigned char map[MSE_MAXBUTTONS + 1];
+ int i;
+
+ pInfo = device->public.devicePrivate;
+ pMse = pInfo->private;
+ pMse->device = device;
+ mPriv = (mousePrivPtr)pMse->mousePriv;
+
+ switch (what)
+ {
+ case DEVICE_INIT:
+ device->public.on = FALSE;
+ /*
+ * [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++)
+ map[i + 1] = i + 1;
+
+ InitPointerDeviceStruct((DevicePtr)device, map,
+ min(pMse->buttons, MSE_MAXBUTTONS),
+ miPointerGetMotionEvents, pMse->Ctrl,
+ miPointerGetMotionBufferSize());
+
+ /* X valuator */
+ xf86InitValuatorAxisStruct(device, 0, 0, -1, 1, 0, 1);
+ xf86InitValuatorDefaults(device, 0);
+ /* Y valuator */
+ xf86InitValuatorAxisStruct(device, 1, 0, -1, 1, 0, 1);
+ xf86InitValuatorDefaults(device, 1);
+ xf86MotionHistoryAllocate(pInfo);
+
+#ifdef EXTMOUSEDEBUG
+ ErrorF("assigning %p atom=%d name=%s\n", device, pInfo->atom,
+ pInfo->name);
+#endif
+ break;
+
+ case DEVICE_ON:
+ pInfo->fd = xf86OpenSerial(pInfo->options);
+ if (pInfo->fd == -1)
+ xf86Msg(X_WARNING, "%s: cannot open input device\n", pInfo->name);
+ else {
+ pMse->buffer = XisbNew(pInfo->fd, 64);
+ if (!pMse->buffer) {
+ xf86CloseSerial(pInfo->fd);
+ pInfo->fd = -1;
+ } else {
+ if (!SetupMouse(pInfo)) {
+ xf86CloseSerial(pInfo->fd);
+ pInfo->fd = -1;
+ XisbFree(pMse->buffer);
+ pMse->buffer = NULL;
+ } else {
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+ if (mPriv != NULL) {
+ if ( pMse->protocolID != PROT_AUTO) {
+ pMse->inSync = TRUE; /* @@@ */
+ if (mPriv->soft)
+ mPriv->autoState = AUTOPROBE_GOOD;
+ else
+ mPriv->autoState = AUTOPROBE_H_GOOD;
+ } else {
+ if (mPriv->soft)
+ mPriv->autoState = AUTOPROBE_NOPROTO;
+ else
+ mPriv->autoState = AUTOPROBE_H_NOPROTO;
+ }
+ }
+ xf86FlushInput(pInfo->fd);
+ xf86AddEnabledDevice(pInfo);
+ }
+ }
+ }
+ pMse->lastButtons = 0;
+ pMse->emulateState = 0;
+ pMse->emulate3Pending = FALSE;
+ device->public.on = TRUE;
+ FlushButtons(pMse);
+ if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft)
+ {
+ RegisterBlockAndWakeupHandlers (MouseBlockHandler, MouseWakeupHandler,
+ (pointer) pInfo);
+ }
+ break;
+
+ case DEVICE_OFF:
+ case DEVICE_CLOSE:
+ if (pInfo->fd != -1) {
+ xf86RemoveEnabledDevice(pInfo);
+ if (pMse->buffer) {
+ XisbFree(pMse->buffer);
+ pMse->buffer = NULL;
+ }
+ xf86CloseSerial(pInfo->fd);
+ pInfo->fd = -1;
+ if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft)
+ {
+ RemoveBlockAndWakeupHandlers (MouseBlockHandler, MouseWakeupHandler,
+ (pointer) pInfo);
+ }
+ }
+ device->public.on = FALSE;
+ usleep(300000);
+ break;
+ }
+ return Success;
+}
+
+/*
+ ***************************************************************************
+ *
+ * MouseConvert --
+ * Convert valuators to X and Y.
+ *
+ ***************************************************************************
+ */
+static Bool
+MouseConvert(InputInfoPtr pInfo, int first, int num, int v0, int v1, int v2,
+ int v3, int v4, int v5, int *x, int *y)
+{
+ if (first != 0 || num != 2)
+ return FALSE;
+
+ *x = v0;
+ *y = v1;
+
+ return TRUE;
+}
+
+/**********************************************************************
+ *
+ * FlushButtons -- send button up events for sanity.
+ *
+ **********************************************************************/
+
+static void
+FlushButtons(MouseDevPtr pMse)
+{
+
+ /* If no button down is pending xf86PostButtonEvent()
+ * will discard them. So we are on the safe side. */
+
+ int i, blocked;
+
+ pMse->lastButtons = 0;
+
+ blocked = xf86BlockSIGIO ();
+ for (i = 1; i <= 5; i++)
+ xf86PostButtonEvent(pMse->device,0,i,0,0,0);
+ xf86UnblockSIGIO (blocked);
+}
+
+/**********************************************************************
+ *
+ * Emulate3Button support code
+ *
+ **********************************************************************/
+
+
+/*
+ * 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>.
+ */
+static signed char stateTab[11][5][3] = {
+/* 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
+ */
+static char reverseMap[32] = { 0, 4, 2, 6, 1, 5, 3, 7,
+ 8, 12, 10, 14, 9, 13, 11, 15,
+ 16, 20, 18, 22, 17, 21, 19, 23,
+ 24, 28, 26, 30, 25, 29, 27, 31};
+
+
+static char hitachMap[16] = { 0, 2, 1, 3,
+ 8, 10, 9, 11,
+ 4, 6, 5, 7,
+ 12, 14, 13, 15 };
+
+#define reverseBits(map, b) (((b) & ~0x0f) | map[(b) & 0x0f])
+
+static CARD32
+buttonTimer(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse;
+ int sigstate;
+ int id;
+
+ pMse = pInfo->private;
+
+ sigstate = xf86BlockSIGIO ();
+
+ pMse->emulate3Pending = FALSE;
+ if ((id = stateTab[pMse->emulateState][4][0]) != 0) {
+ xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
+ pMse->emulateState = stateTab[pMse->emulateState][4][2];
+ } else {
+ ErrorF("Got unexpected buttonTimer in state %d\n", pMse->emulateState);
+ }
+
+ xf86UnblockSIGIO (sigstate);
+ return 0;
+}
+
+static Bool
+Emulate3ButtonsSoft(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse = pInfo->private;
+
+ if (!pMse->emulate3ButtonsSoft)
+ return TRUE;
+
+ pMse->emulate3Buttons = FALSE;
+
+ if (pMse->emulate3Pending)
+ buttonTimer(pInfo);
+
+ xf86Msg(X_INFO,"3rd Button detected: disabling emulate3Button\n");
+
+ return FALSE;
+}
+
+static void MouseBlockHandler(pointer data,
+ struct timeval **waitTime,
+ pointer LastSelectMask)
+{
+ InputInfoPtr pInfo = (InputInfoPtr) data;
+ MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
+ int ms;
+
+ if (pMse->emulate3Pending)
+ {
+ ms = pMse->emulate3Expires - GetTimeInMillis ();
+ if (ms <= 0)
+ ms = 0;
+ AdjustWaitForDelay (waitTime, ms);
+ }
+}
+
+static void MouseWakeupHandler(pointer data,
+ int i,
+ pointer LastSelectMask)
+{
+ InputInfoPtr pInfo = (InputInfoPtr) data;
+ MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
+ int ms;
+
+ if (pMse->emulate3Pending)
+ {
+ ms = pMse->emulate3Expires - GetTimeInMillis ();
+ if (ms <= 0)
+ buttonTimer (pInfo);
+ }
+}
+
+/*******************************************************************
+ *
+ * Post mouse events
+ *
+ *******************************************************************/
+
+static void
+MouseDoPostEvent(InputInfoPtr pInfo, int buttons, int dx, int dy)
+{
+ MouseDevPtr pMse;
+ int truebuttons, emulateButtons;
+ int id, change;
+ int emuWheelDelta, emuWheelButton, emuWheelButtonMask;
+
+ pMse = pInfo->private;
+
+ truebuttons = buttons;
+ if (pMse->protocolID == PROT_MMHIT)
+ buttons = reverseBits(hitachMap, buttons);
+ else
+ buttons = reverseBits(reverseMap, buttons);
+
+ /* Intercept wheel emulation. */
+ if (pMse->emulateWheel && (buttons & pMse->wheelButtonMask)) {
+ /* Y axis movement */
+ if (pMse->negativeY != MSE_NOAXISMAP) {
+ pMse->wheelYDistance += dy;
+ if (pMse->wheelYDistance < 0) {
+ emuWheelDelta = -pMse->wheelInertia;
+ emuWheelButton = pMse->negativeY;
+ } else {
+ emuWheelDelta = pMse->wheelInertia;
+ emuWheelButton = pMse->positiveY;
+ }
+ emuWheelButtonMask = 1 << (emuWheelButton - 1);
+ while (abs(pMse->wheelYDistance) > pMse->wheelInertia) {
+ pMse->wheelYDistance -= emuWheelDelta;
+
+ /*
+ * Synthesize the press and release, but not when the button
+ * to be synthesized is already pressed "for real".
+ */
+ if (!(emuWheelButtonMask & buttons) ||
+ (emuWheelButtonMask & pMse->wheelButtonMask)) {
+ xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 1, 0, 0);
+ xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 0, 0, 0);
+ }
+ }
+ }
+
+ /* X axis movement */
+ if (pMse->negativeX != MSE_NOAXISMAP) {
+ pMse->wheelXDistance += dx;
+ if (pMse->wheelXDistance < 0) {
+ emuWheelDelta = -pMse->wheelInertia;
+ emuWheelButton = pMse->negativeX;
+ } else {
+ emuWheelDelta = pMse->wheelInertia;
+ emuWheelButton = pMse->positiveX;
+ }
+ emuWheelButtonMask = 1 << (emuWheelButton - 1);
+ while (abs(pMse->wheelXDistance) > pMse->wheelInertia) {
+ pMse->wheelXDistance -= emuWheelDelta;
+
+ /*
+ * Synthesize the press and release, but not when the button
+ * to be synthesized is already pressed "for real".
+ */
+ if (!(emuWheelButtonMask & buttons) ||
+ (emuWheelButtonMask & pMse->wheelButtonMask)) {
+ xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 1, 0, 0);
+ xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 0, 0, 0);
+ }
+ }
+ }
+
+ /* Absorb the mouse movement and the wheel button press. */
+ dx = 0;
+ dy = 0;
+ buttons &= ~pMse->wheelButtonMask;
+ }
+
+ if (dx || dy)
+ xf86PostMotionEvent(pInfo->dev, 0, 0, 2, dx, dy);
+
+ if (truebuttons != pMse->lastButtons) {
+
+ if (pMse->protocolID == PROT_MMHIT)
+ change = buttons ^ reverseBits(hitachMap, pMse->lastButtons);
+ else
+ change = buttons ^ reverseBits(reverseMap, pMse->lastButtons);
+
+ /*
+ * adjust buttons state for drag locks!
+ * if there is drag locks
+ */
+ if (pMse->pDragLock) {
+ DragLockPtr pLock;
+ int tarOfGoingDown, tarOfDown;
+ int realbuttons;
+
+ /* get drag lock block */
+ pLock = pMse->pDragLock;
+ /* save real buttons */
+ realbuttons = buttons;
+
+ /* if drag lock used */
+
+ /* state of drag lock buttons not seen always up */
+
+ buttons &= ~pLock->lockButtonsM;
+
+ /*
+ * if lock buttons being depressed changes state of
+ * targets simulatedDown.
+ */
+ tarOfGoingDown = lock2targetMap(pLock,
+ realbuttons & change & pLock->lockButtonsM);
+ pLock->simulatedDown ^= tarOfGoingDown;
+
+ /* targets of drag locks down */
+ tarOfDown = lock2targetMap(pLock,
+ realbuttons & pLock->lockButtonsM);
+
+ /*
+ * when simulatedDown set and target pressed,
+ * simulatedDown goes false
+ */
+ pLock->simulatedDown &= ~(realbuttons & change);
+
+ /*
+ * if master drag lock released
+ * then master drag lock state on
+ */
+ pLock->masterTS |= (~realbuttons & change) & pLock->masterLockM;
+
+ /* if master state, buttons going down are simulatedDown */
+ if (pLock->masterTS)
+ pLock->simulatedDown |= (realbuttons & change);
+
+ /* if any button pressed, no longer in master drag lock state */
+ if (realbuttons & change)
+ pLock->masterTS = 0;
+
+ /* if simulatedDown or drag lock down, simulate down */
+ buttons |= (pLock->simulatedDown | tarOfDown);
+
+ /* master button not seen */
+ buttons &= ~(pLock->masterLockM);
+
+ /* buttons changed since last time */
+ change = buttons ^ pLock->lockLastButtons;
+
+ /* save this time for next last time. */
+ pLock->lockLastButtons = buttons;
+ }
+
+ if (pMse->emulate3Buttons
+ && (!(buttons & 0x02) || Emulate3ButtonsSoft(pInfo))) {
+
+ /* handle all but buttons 1 & 3 normally */
+
+ change &= ~05;
+
+ /* emulate the third button by the other two */
+
+ emulateButtons = (buttons & 01) | ((buttons &04) >> 1);
+
+ if ((id = stateTab[pMse->emulateState][emulateButtons][0]) != 0)
+ xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
+ if ((id = stateTab[pMse->emulateState][emulateButtons][1]) != 0)
+ xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
+
+ pMse->emulateState =
+ stateTab[pMse->emulateState][emulateButtons][2];
+
+ if (stateTab[pMse->emulateState][4][0] != 0) {
+ pMse->emulate3Expires = GetTimeInMillis () + pMse->emulate3Timeout;
+ pMse->emulate3Pending = TRUE;
+ } else {
+ pMse->emulate3Pending = FALSE;
+ }
+ }
+
+ while (change) {
+ id = ffs(change);
+ change &= ~(1 << (id - 1));
+ xf86PostButtonEvent(pInfo->dev, 0, id,
+ (buttons & (1 << (id - 1))), 0, 0);
+ }
+
+ pMse->lastButtons = truebuttons;
+ }
+}
+
+static void
+MousePostEvent(InputInfoPtr pInfo, int buttons, int dx, int dy, int dz, int dw)
+{
+ MouseDevPtr pMse;
+ int zbutton = 0;
+
+ pMse = pInfo->private;
+
+ /* Map the Z axis movement. */
+ /* XXX Could this go in the conversion_proc? */
+ switch (pMse->negativeZ) {
+ case MSE_NOZMAP: /* do nothing */
+ break;
+ case MSE_MAPTOX:
+ if (dz != 0) {
+ dx = dz;
+ dz = 0;
+ }
+ break;
+ case MSE_MAPTOY:
+ if (dz != 0) {
+ dy = dz;
+ dz = 0;
+ }
+ break;
+ default: /* buttons */
+ buttons &= ~(pMse->negativeZ | pMse->positiveZ
+ | pMse->negativeW | pMse->positiveW);
+ if (dw < 0 || dz < -1)
+ zbutton = pMse->negativeW;
+ else if (dz < 0)
+ zbutton = pMse->negativeZ;
+ else if (dw > 0 || dz > 1)
+ zbutton = pMse->positiveW;
+ else if (dz > 0)
+ zbutton = pMse->positiveZ;
+ buttons |= zbutton;
+ dz = 0;
+ break;
+ }
+
+ /* Apply angle offset */
+ if (pMse->angleOffset != 0) {
+ double rad = 3.141592653 * pMse->angleOffset / 180.0;
+ int ndx = dx;
+ dx = (int)((dx * cos(rad)) + (dy * sin(rad)) + 0.5);
+ dy = (int)((dy * cos(rad)) - (ndx * sin(rad)) + 0.5);
+ }
+
+ dx = pMse->invX * dx;
+ dy = pMse->invY * dy;
+ if (pMse->flipXY) {
+ int tmp = dx;
+ dx = dy;
+ dy = tmp;
+ }
+ MouseDoPostEvent(pInfo, buttons, dx, dy);
+
+ /*
+ * If dz has been mapped to a button `down' event, we need to cook up
+ * a corresponding button `up' event.
+ */
+ if (zbutton) {
+ buttons &= ~zbutton;
+ MouseDoPostEvent(pInfo, buttons, 0, 0);
+ }
+}
+/******************************************************************
+ *
+ * Mouse Setup Code
+ *
+ ******************************************************************/
+/*
+ * This array is indexed by the MouseProtocolID values, so the order of the entries
+ * must match that of the MouseProtocolID enum in mouse.h.
+ */
+static unsigned char proto[PROT_NUMPROTOS][8] = {
+ /* --header-- ---data--- packet -4th-byte- mouse */
+ /* mask id mask id bytes mask id flags */
+ /* Serial mice */
+ { 0x40, 0x40, 0x40, 0x00, 3, ~0x23, 0x00, MPF_NONE }, /* MicroSoft */
+ { 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff, MPF_SAFE }, /* MouseSystems */
+ { 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* MMSeries */
+ { 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* Logitech */
+ { 0x40, 0x40, 0x40, 0x00, 3, ~0x23, 0x00, MPF_NONE }, /* MouseMan */
+ { 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* MM_HitTablet */
+ { 0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00, MPF_NONE }, /* GlidePoint */
+ { 0x40, 0x40, 0x40, 0x00, 3, ~0x3f, 0x00, MPF_NONE }, /* IntelliMouse */
+ { 0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00, MPF_NONE }, /* ThinkingMouse */
+ { 0x80, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* ACECAD */
+ /* PS/2 variants */
+ { 0xc0, 0x00, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* PS/2 mouse */
+ { 0xc8, 0x08, 0x00, 0x00, 3, 0x00, 0x00, MPF_NONE }, /* genericPS/2 mouse*/
+ { 0x08, 0x08, 0x00, 0x00, 4, 0x00, 0xff, MPF_NONE }, /* IntelliMouse */
+ { 0x08, 0x08, 0x00, 0x00, 4, 0x00, 0xff, MPF_NONE }, /* Explorer */
+ { 0x80, 0x80, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* ThinkingMouse */
+ { 0x08, 0x08, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* MouseMan+ */
+ { 0xc0, 0x00, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* GlidePoint */
+ { 0x08, 0x08, 0x00, 0x00, 4, 0x00, 0xff, MPF_NONE }, /* NetMouse */
+ { 0xc0, 0x00, 0x00, 0x00, 6, 0x00, 0xff, MPF_NONE }, /* NetScroll */
+ /* Bus Mouse */
+ { 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff, MPF_NONE }, /* BusMouse */
+ { 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff, MPF_NONE }, /* Auto (dummy) */
+ { 0xf8, 0x80, 0x00, 0x00, 8, 0x00, 0xff, MPF_NONE }, /* SysMouse */
+};
+
+
+/*
+ * SetupMouse --
+ * Sets up the mouse parameters
+ */
+static Bool
+SetupMouse(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse;
+ mousePrivPtr mPriv;
+ int i;
+ int protoPara[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
+ const char *name = NULL;
+ Bool automatic = FALSE;
+
+ pMse = pInfo->private;
+ mPriv = (mousePrivPtr)pMse->mousePriv;
+
+ /* Handle the "Auto" protocol. */
+ if (pMse->protocolID == PROT_AUTO) {
+ /*
+ * We come here when user specifies protocol "auto" in
+ * the configuration file or thru the xf86misc extensions.
+ * So we initialize autoprobing here.
+ * Probe for PnP/OS mouse first. If unsuccessful
+ * try to guess protocol from incoming data.
+ */
+ automatic = TRUE;
+ pMse->autoProbe = TRUE;
+ name = autoOSProtocol(pInfo,protoPara);
+ if (name) {
+#ifdef EXTMOUSEDEBUG
+ ErrorF("PnP/OS Mouse detected: %s\n",name);
+#endif
+ }
+ }
+
+ SetMouseProto(pMse, pMse->protocolID);
+
+ if (automatic) {
+ if (name) {
+ /* Possible protoPara overrides from SetupAuto. */
+ for (i = 0; i < sizeof(pMse->protoPara); i++)
+ if (protoPara[i] != -1)
+ pMse->protoPara[i] = protoPara[i];
+ /* if we come here PnP/OS mouse probing was successful */
+ } else {
+#if 1
+ /* PnP/OS mouse probing wasn't successful; we look at data */
+#else
+ xf86Msg(X_ERROR, "%s: cannot determine the mouse protocol\n",
+ pInfo->name);
+ return FALSE;
+#endif
+ }
+ }
+
+ /*
+ * If protocol has changed fetch the default options
+ * for the new protocol.
+ */
+ if (pMse->oldProtocolID != pMse->protocolID) {
+ pointer tmp = NULL;
+ if ((pMse->protocolID >= 0)
+ && (pMse->protocolID < PROT_NUMPROTOS)
+ && mouseProtocols[pMse->protocolID].defaults)
+ tmp = xf86OptionListCreate(
+ mouseProtocols[pMse->protocolID].defaults, -1, 0);
+ pInfo->options = xf86OptionListMerge(pInfo->options, tmp);
+ /*
+ * If baudrate is set write it back to the option
+ * list so that the serial interface code can access
+ * the new value. Not set means default.
+ */
+ if (pMse->baudRate)
+ xf86ReplaceIntOption(pInfo->options, "BaudRate", pMse->baudRate);
+ pMse->oldProtocolID = pMse->protocolID; /* hack */
+ }
+
+
+ /* Set the port parameters. */
+ if (!automatic)
+ xf86SetSerial(pInfo->fd, pInfo->options);
+
+ if (!initMouseHW(pInfo))
+ return FALSE;
+
+ pMse->protoBufTail = 0;
+ pMse->inSync = 0;
+
+ return TRUE;
+}
+
+/********************************************************************
+ *
+ * Mouse HW setup code
+ *
+ ********************************************************************/
+
+/*
+** 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]
+*/
+
+/*
+ * Do a reset wrap mode before reset.
+ */
+#define do_ps2Reset(x) { \
+ int i = 10;\
+ while (i-- > 0) { \
+ xf86FlushInput(x->fd); \
+ if (ps2Reset(x)) break; \
+ } \
+ }
+
+
+static Bool
+initMouseHW(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse = pInfo->private;
+ const char *s;
+ unsigned char c;
+ int speed;
+ pointer options;
+ unsigned char *param = NULL;
+ int paramlen = 0;
+ int count = 10;
+ Bool ps2Init = TRUE;
+
+ 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.
+ */
+ speed = pMse->baudRate;
+ 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";
+ }
+ xf86SetSerialSpeed(pInfo->fd, 9600);
+ xf86WriteSerial(pInfo->fd, s, 2);
+ usleep(100000);
+ xf86SetSerialSpeed(pInfo->fd, 4800);
+ xf86WriteSerial(pInfo->fd, s, 2);
+ usleep(100000);
+ xf86SetSerialSpeed(pInfo->fd, 2400);
+ xf86WriteSerial(pInfo->fd, s, 2);
+ usleep(100000);
+ xf86SetSerialSpeed(pInfo->fd, 1200);
+ xf86WriteSerial(pInfo->fd, s, 2);
+ usleep(100000);
+ xf86SetSerialSpeed(pInfo->fd, speed);
+
+ /* Select MM series data format. */
+ xf86WriteSerial(pInfo->fd, "S", 1);
+ usleep(100000);
+ /* Set the parameters up for the MM series protocol. */
+ options = pInfo->options;
+ xf86CollectInputOptions(pInfo, mmDefaults, NULL);
+ xf86SetSerial(pInfo->fd, pInfo->options);
+ pInfo->options = options;
+
+ /* Select report rate/frequency. */
+ if (pMse->sampleRate <= 0) c = 'O'; /* 100 */
+ else if (pMse->sampleRate <= 15) c = 'J'; /* 10 */
+ else if (pMse->sampleRate <= 27) c = 'K'; /* 20 */
+ else if (pMse->sampleRate <= 42) c = 'L'; /* 35 */
+ else if (pMse->sampleRate <= 60) c = 'R'; /* 50 */
+ else if (pMse->sampleRate <= 85) c = 'M'; /* 67 */
+ else if (pMse->sampleRate <= 125) c = 'Q'; /* 100 */
+ else c = 'N'; /* 150 */
+ xf86WriteSerial(pInfo->fd, &c, 1);
+ break;
+
+ case PROT_LOGIMAN:
+ speed = pMse->baudRate;
+ switch (speed) {
+ case 9600:
+ s = "*q";
+ break;
+ case 1200:
+ s = "*n";
+ break;
+ default:
+ /* Fallback value */
+ speed = 1200;
+ s = "*n";
+ }
+ xf86SetSerialSpeed(pInfo->fd, 1200);
+ xf86WriteSerial(pInfo->fd, "*n", 2);
+ xf86WriteSerial(pInfo->fd, "*X", 2);
+ xf86WriteSerial(pInfo->fd, s, 2);
+ usleep(100000);
+ xf86SetSerialSpeed(pInfo->fd, speed);
+ 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".
+ */
+ xf86WriteSerial(pInfo->fd, "z8", 2); /* Set Parity = "NONE" */
+ usleep(50000);
+ xf86WriteSerial(pInfo->fd, "zb", 2); /* Set Format = "Binary" */
+ usleep(50000);
+ xf86WriteSerial(pInfo->fd, "@", 1); /* Set Report Mode = "Stream" */
+ usleep(50000);
+ xf86WriteSerial(pInfo->fd, "R", 1); /* Set Output Rate = "45 rps" */
+ usleep(50000);
+ xf86WriteSerial(pInfo->fd, "I\x20", 2); /* Set Incrememtal Mode "20" */
+ usleep(50000);
+ xf86WriteSerial(pInfo->fd, "E", 1); /* Set Data Type = "Relative */
+ usleep(50000);
+ /*
+ * These sample rates translate to 'lines per inch' on the Hitachi
+ * tablet.
+ */
+ if (pMse->sampleRate <= 40) c = 'g';
+ else if (pMse->sampleRate <= 100) c = 'd';
+ else if (pMse->sampleRate <= 200) c = 'e';
+ else if (pMse->sampleRate <= 500) c = 'h';
+ else if (pMse->sampleRate <= 1000) c = 'j';
+ else c = 'd';
+ xf86WriteSerial(pInfo->fd, &c, 1);
+ usleep(50000);
+ xf86WriteSerial(pInfo->fd, "\021", 1); /* Resume DATA output */
+ break;
+
+ case PROT_THINKING: /* ThinkingMouse */
+ /* This mouse may send a PnP ID string, ignore it. */
+ usleep(200000);
+ xf86FlushInput(pInfo->fd);
+ /* Send the command to initialize the beast. */
+ for (s = "E5E5"; *s; ++s) {
+ xf86WriteSerial(pInfo->fd, s, 1);
+ if ((xf86WaitForInput(pInfo->fd, 1000000) <= 0))
+ break;
+ xf86ReadSerial(pInfo->fd, &c, 1);
+ if (c != *s)
+ break;
+ }
+ break;
+
+ case PROT_MSC: /* MouseSystems Corp */
+ usleep(100000);
+ xf86FlushInput(pInfo->fd);
+ break;
+
+ case PROT_ACECAD:
+ /* initialize */
+ /* A nul character resets. */
+ xf86WriteSerial(pInfo->fd, "", 1);
+ usleep(50000);
+ /* Stream out relative mode high resolution increments of 1. */
+ xf86WriteSerial(pInfo->fd, "@EeI!", 5);
+ break;
+
+ case PROT_BM: /* bus/InPort mouse */
+ if (osInfo->SetBMRes)
+ osInfo->SetBMRes(pInfo, pMse->protocol, pMse->sampleRate,
+ pMse->resolution);
+ break;
+
+ case PROT_GENPS2:
+ ps2Init = FALSE;
+ break;
+
+ case PROT_PS2:
+ case PROT_GLIDEPS2:
+ break;
+
+ case PROT_IMPS2: /* IntelliMouse */
+ {
+ static unsigned char seq[] = { 243, 200, 243, 100, 243, 80, 242 };
+ param = seq;
+ paramlen = sizeof(seq);
+ }
+ break;
+
+ case PROT_EXPPS2: /* IntelliMouse Explorer */
+ {
+ static unsigned char seq[] = { 243, 200, 243, 100, 243, 80,
+ 243, 200, 243, 200, 243, 80, 242 };
+
+ param = seq;
+ paramlen = sizeof(seq);
+ }
+ break;
+
+ case PROT_NETPS2: /* NetMouse, NetMouse Pro, Mie Mouse */
+ case PROT_NETSCPS2: /* NetScroll */
+ {
+ static unsigned char seq[] = { 232, 3, 230, 230, 230, };
+
+ param = seq;
+ paramlen = sizeof(seq);
+ }
+ break;
+
+ case PROT_MMPS2: /* MouseMan+, FirstMouse+ */
+ {
+ static unsigned char seq[] = { 230, 232, 0, 232, 3, 232, 2, 232, 1,
+ 230, 232, 3, 232, 1, 232, 2, 232, 3, };
+ param = seq;
+ paramlen = sizeof(seq);
+ }
+ break;
+
+ case PROT_THINKPS2: /* ThinkingMouse */
+ {
+ static unsigned char seq[] = { 243, 10, 232, 0, 243, 20, 243, 60,
+ 243, 40, 243, 20, 243, 20, 243, 60,
+ 243, 40, 243, 20, 243, 20, };
+ param = seq;
+ paramlen = sizeof(seq);
+ }
+ break;
+ case PROT_SYSMOUSE:
+ if (osInfo->SetMiscRes)
+ osInfo->SetMiscRes(pInfo, pMse->protocol, pMse->sampleRate,
+ pMse->resolution);
+ break;
+
+ default:
+ /* Nothing to do. */
+ break;
+ }
+
+ if (pMse->class & (MSE_PS2 | MSE_XPS2)) {
+ /*
+ * If one part of the PS/2 mouse initialization fails
+ * redo complete initialization. There are mice which
+ * have occasional problems with initialization and
+ * are in an unknown state.
+ */
+ if (ps2Init) {
+ REDO:
+ do_ps2Reset(pInfo);
+ if (paramlen > 0) {
+ if (!ps2SendPacket(pInfo,param,paramlen)) {
+ usleep(30000);
+ xf86FlushInput(pInfo->fd);
+ if (!count--)
+ return TRUE;
+ goto REDO;
+ }
+ usleep(30000);
+ xf86FlushInput(pInfo->fd);
+ }
+
+ if (osInfo->SetPS2Res) {
+ osInfo->SetPS2Res(pInfo, pMse->protocol, pMse->sampleRate,
+ pMse->resolution);
+ } else {
+ unsigned char c2[2];
+
+ c = 0xE6; /*230*/ /* 1:1 scaling */
+ if (!ps2SendPacket(pInfo,&c,1)) {
+ if (!count--)
+ return TRUE;
+ goto REDO;
+ }
+ c2[0] = 0xF3; /*243*/ /* set sampling rate */
+ if (pMse->sampleRate > 0) {
+ if (pMse->sampleRate >= 200)
+ c2[1] = 200;
+ else if (pMse->sampleRate >= 100)
+ c2[1] = 100;
+ else if (pMse->sampleRate >= 80)
+ c2[1] = 80;
+ else if (pMse->sampleRate >= 60)
+ c2[1] = 60;
+ else if (pMse->sampleRate >= 40)
+ c2[1] = 40;
+ else
+ c2[1] = 20;
+ } else {
+ c2[1] = 100;
+ }
+ if (!ps2SendPacket(pInfo,c2,2)) {
+ if (!count--)
+ return TRUE;
+ goto REDO;
+ }
+ c2[0] = 0xE8; /*232*/ /* set device resolution */
+ if (pMse->resolution > 0) {
+ if (pMse->resolution >= 200)
+ c2[1] = 3;
+ else if (pMse->resolution >= 100)
+ c2[1] = 2;
+ else if (pMse->resolution >= 50)
+ c2[1] = 1;
+ else
+ c2[1] = 0;
+ } else {
+ c2[1] = 2;
+ }
+ if (!ps2SendPacket(pInfo,c2,2)) {
+ if (!count--)
+ return TRUE;
+ goto REDO;
+ }
+ usleep(30000);
+ xf86FlushInput(pInfo->fd);
+ if (!ps2EnableDataReporting(pInfo)) {
+ xf86Msg(X_INFO, "%s: ps2EnableDataReporting: failed\n",
+ pInfo->name);
+ xf86FlushInput(pInfo->fd);
+ if (!count--)
+ return TRUE;
+ goto REDO;
+ } else {
+ xf86Msg(X_INFO, "%s: ps2EnableDataReporting: succeeded\n",
+ pInfo->name);
+ }
+ }
+ /*
+ * The PS/2 reset handling needs to be rechecked.
+ * We need to wait until after the 4.3 release.
+ */
+ }
+ } else {
+ if (paramlen > 0) {
+ if (xf86WriteSerial(pInfo->fd, param, paramlen) != paramlen)
+ xf86Msg(X_ERROR, "%s: Mouse initialization failed\n",
+ pInfo->name);
+ usleep(30000);
+ xf86FlushInput(pInfo->fd);
+ }
+ }
+
+ return TRUE;
+}
+
+#ifdef SUPPORT_MOUSE_RESET
+static Bool
+mouseReset(InputInfoPtr pInfo, unsigned char val)
+{
+ MouseDevPtr pMse = pInfo->private;
+ mousePrivPtr mousepriv = (mousePrivPtr)pMse->mousePriv;
+ CARD32 prevEvent = mousepriv->lastEvent;
+ Bool expectReset = FALSE;
+ Bool ret = FALSE;
+
+ mousepriv->lastEvent = GetTimeInMillis();
+
+#ifdef EXTMOUSEDEBUG
+ ErrorF("byte: 0x%x time: %li\n",val,mousepriv->lastEvent);
+#endif
+ /*
+ * We believe that the following is true:
+ * When the mouse is replugged it will send a reset package
+ * It takes several seconds to replug a mouse: We don't see
+ * events for several seconds before we see the replug event package.
+ * There is no significant delay between consecutive bytes
+ * of a replug event package.
+ * There are no bytes sent after the replug event package until
+ * the mouse is reset.
+ */
+
+ if (mousepriv->current == 0
+ && (mousepriv->lastEvent - prevEvent) < 4000)
+ return FALSE;
+
+ if (mousepriv->current > 0
+ && (mousepriv->lastEvent - prevEvent) >= 1000) {
+ mousepriv->inReset = FALSE;
+ mousepriv->current = 0;
+ return FALSE;
+ }
+
+ if (mousepriv->inReset)
+ mousepriv->inReset = FALSE;
+
+#ifdef EXTMOUSEDEBUG
+ ErrorF("Mouse Current: %i 0x%x\n",mousepriv->current, val);
+#endif
+
+ /* here we put the mouse specific reset detction */
+ /* They need to do three things: */
+ /* Check if byte may be a reset byte */
+ /* If so: Set expectReset TRUE */
+ /* If convinced: Set inReset TRUE */
+ /* Register BlockAndWakeupHandler */
+
+ /* PS/2 */
+ {
+ unsigned char seq[] = { 0xaa, 0x00 };
+ int len = sizeof(seq);
+
+ if (seq[mousepriv->current] == val)
+ expectReset = TRUE;
+
+ if (len == mousepriv->current + 1) {
+ mousepriv->inReset = TRUE;
+ mousepriv->expires = GetTimeInMillis() + 1000;
+
+#ifdef EXTMOUSEDEBUG
+ ErrorF("Found PS/2 Reset string\n");
+#endif
+ RegisterBlockAndWakeupHandlers (ps2BlockHandler,
+ ps2WakeupHandler, (pointer) pInfo);
+ ret = TRUE;
+ }
+ }
+
+ if (!expectReset)
+ mousepriv->current = 0;
+ else
+ mousepriv->current++;
+ return ret;
+}
+
+static void
+ps2BlockHandler(pointer data, struct timeval **waitTime,
+ pointer LastSelectMask)
+{
+ InputInfoPtr pInfo = (InputInfoPtr) data;
+ MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
+ mousePrivPtr mousepriv = (mousePrivPtr)pMse->mousePriv;
+ int ms;
+
+ if (mousepriv->inReset) {
+ ms = mousepriv->expires - GetTimeInMillis ();
+ if (ms <= 0)
+ ms = 0;
+ AdjustWaitForDelay (waitTime, ms);
+ } else
+ RemoveBlockAndWakeupHandlers (ps2BlockHandler, ps2WakeupHandler,
+ (pointer) pInfo);
+}
+
+static void
+ps2WakeupHandler(pointer data, int i, pointer LastSelectMask)
+{
+ InputInfoPtr pInfo = (InputInfoPtr) data;
+ MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
+ mousePrivPtr mousepriv = (mousePrivPtr)pMse->mousePriv;
+ int ms;
+
+ if (mousepriv->inReset) {
+ unsigned char val;
+ int blocked;
+
+ ms = mousepriv->expires - GetTimeInMillis();
+ if (ms > 0)
+ return;
+
+ blocked = xf86BlockSIGIO ();
+
+ xf86MsgVerb(X_INFO,3,
+ "Got reinsert event: reinitializing PS/2 mouse\n");
+ val = 0xf4;
+ if (xf86WriteSerial(pInfo->fd, &val, 1) != 1)
+ xf86Msg(X_ERROR, "%s: Write to mouse failed\n",
+ pInfo->name);
+ xf86UnblockSIGIO(blocked);
+ }
+ RemoveBlockAndWakeupHandlers (ps2BlockHandler, ps2WakeupHandler,
+ (pointer) pInfo);
+}
+#endif /* SUPPORT_MOUSE_RESET */
+
+/************************************************************
+ *
+ * Autoprobe stuff
+ *
+ ************************************************************/
+#ifdef EXTMOUSEDEBUG
+# define AP_DBG(x) { ErrorF("Autoprobe: "); ErrorF x; }
+# define AP_DBGC(x) ErrorF x ;
+# else
+# define AP_DBG(x)
+# define AP_DBGC(x)
+#endif
+
+MouseProtocolID hardProtocolList[] = { PROT_MSC, PROT_MM, PROT_LOGI,
+ PROT_LOGIMAN, PROT_MMHIT,
+ PROT_GLIDE, PROT_IMSERIAL,
+ PROT_THINKING, PROT_ACECAD,
+ PROT_THINKPS2, PROT_MMPS2,
+ PROT_GLIDEPS2,
+ PROT_NETSCPS2, PROT_EXPPS2,PROT_IMPS2,
+ PROT_GENPS2, PROT_NETPS2,
+ PROT_MS,
+ PROT_UNKNOWN
+};
+
+MouseProtocolID softProtocolList[] = { PROT_MSC, PROT_MM, PROT_LOGI,
+ PROT_LOGIMAN, PROT_MMHIT,
+ PROT_GLIDE, PROT_IMSERIAL,
+ PROT_THINKING, PROT_ACECAD,
+ PROT_THINKPS2, PROT_MMPS2,
+ PROT_GLIDEPS2,
+ PROT_NETSCPS2 ,PROT_IMPS2,
+ PROT_GENPS2,
+ PROT_MS,
+ PROT_UNKNOWN
+};
+
+static const char *
+autoOSProtocol(InputInfoPtr pInfo, int *protoPara)
+{
+ MouseDevPtr pMse = pInfo->private;
+ const char *name = NULL;
+ MouseProtocolID protocolID = PROT_UNKNOWN;
+
+ /* Check if the OS has a detection mechanism. */
+ if (osInfo->SetupAuto) {
+ name = osInfo->SetupAuto(pInfo, protoPara);
+ if (name) {
+ protocolID = ProtocolNameToID(name);
+ switch (protocolID) {
+ case PROT_UNKNOWN:
+ /* Check for a builtin OS-specific protocol. */
+ if (osInfo->CheckProtocol && osInfo->CheckProtocol(name)) {
+ /* We can only come here if the protocol has been
+ * changed to auto thru the xf86misc extension
+ * and we have detected an OS specific builtin
+ * protocol. Currently we cannot handle this */
+ name = NULL;
+ } else
+ name = NULL;
+ break;
+ case PROT_UNSUP:
+ name = NULL;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+#ifdef PNP_MOUSE
+ if (!name) {
+ /* A PnP serial mouse? */
+ protocolID = MouseGetPnpProtocol(pInfo);
+ if (protocolID >= 0 && protocolID < PROT_NUMPROTOS) {
+ name = ProtocolIDToName(protocolID);
+ xf86Msg(X_PROBED, "%s: PnP-detected protocol: \"%s\"\n",
+ pInfo->name, name);
+ }
+ }
+#endif
+ if (name) {
+ pMse->protocolID = protocolID;
+ }
+
+ return name;
+}
+
+/*
+ * createProtocolList() -- create a list of protocols which may
+ * match on the incoming data stream.
+ */
+static void
+createProtoList(MouseDevPtr pMse, MouseProtocolID *protoList)
+{
+ int i, j, k = 0;
+ MouseProtocolID prot;
+ unsigned char *para;
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+ MouseProtocolID *tmplist = NULL;
+ int blocked;
+
+ AP_DBGC(("Autoprobe: "));
+ for (i = 0; i < mPriv->count; i++)
+ AP_DBGC(("%2.2x ", (unsigned char) mPriv->data[i]));
+ AP_DBGC(("\n"));
+
+ blocked = xf86BlockSIGIO ();
+
+ /* create a private copy first so we can write in the old list */
+ if ((tmplist = xalloc(sizeof(MouseProtocolID) * NUM_AUTOPROBE_PROTOS))){
+ for (i = 0; protoList[i] != PROT_UNKNOWN; i++) {
+ tmplist[i] = protoList[i];
+ }
+ tmplist[i] = PROT_UNKNOWN;
+ protoList = tmplist;
+ } else
+ return;
+
+ for (i = 0; ((prot = protoList[i]) != PROT_UNKNOWN
+ && (k < NUM_AUTOPROBE_PROTOS - 1)) ; i++) {
+ Bool bad = TRUE;
+ unsigned char byte = 0;
+ int count = 0;
+ int next_header_candidate = 0;
+ int header_count = 0;
+
+ if (!GetProtocol(prot))
+ continue;
+ para = proto[prot];
+
+ AP_DBG(("Protocol: %s ", ProtocolIDToName(prot)));
+
+#ifdef EXTMOUSEDEBUG
+ for (j = 0; j < 7; j++)
+ AP_DBGC(("%2.2x ", (unsigned char) para[j]));
+ AP_DBGC(("\n"));
+#endif
+ j = 0;
+ while (1) {
+ /* look for header */
+ while (j < mPriv->count) {
+ if (((byte = mPriv->data[j++]) & para[0]) == para[1]){
+ AP_DBG(("found header %2.2x\n",byte));
+ next_header_candidate = j;
+ count = 1;
+ break;
+ } else {
+ /*
+ * Bail ot if number of bytes per package have
+ * been tested for header.
+ * Take bytes per package of leading garbage into
+ * account.
+ */
+ if (j > para[4] && ++header_count > para[4]) {
+ j = mPriv->count;
+ break;
+ }
+ }
+ }
+ /* check if remaining data matches protocol */
+ while (j < mPriv->count) {
+ byte = mPriv->data[j++];
+ if (count == para[4]) {
+ count = 0;
+ /* check and eat excess byte */
+ if (((byte & para[0]) != para[1])
+ && ((byte & para[5]) == para[6])) {
+ AP_DBG(("excess byte found\n"));
+ continue;
+ }
+ }
+ if (count == 0) {
+ /* validate next header */
+ bad = FALSE;
+ AP_DBG(("Complete set found\n"));
+ if ((byte & para[0]) != para[1]) {
+ AP_DBG(("Autoprobe: header bad\n"));
+ bad = TRUE;
+ break;
+ } else {
+ count++;
+ continue;
+ }
+ }
+ /* validate data */
+ else if (((byte & para[2]) != para[3])
+ || ((para[7] & MPF_SAFE)
+ && ((byte & para[0]) == para[1]))) {
+ AP_DBG(("data bad\n"));
+ bad = TRUE;
+ break;
+ } else {
+ count ++;
+ continue;
+ }
+ }
+ if (!bad) {
+ /* this is a matching protocol */
+ mPriv->protoList[k++] = prot;
+ AP_DBG(("Autoprobe: Adding protocol %s to list (entry %i)\n",
+ ProtocolIDToName(prot),k-1));
+ break;
+ }
+ j = next_header_candidate;
+ next_header_candidate = 0;
+ /* we have tested number of bytes per package for header */
+ if (j > para[4] && ++header_count > para[4])
+ break;
+ /* we have not found anything that looks like a header */
+ if (!next_header_candidate)
+ break;
+ AP_DBG(("Looking for new header\n"));
+ }
+ }
+
+ xf86UnblockSIGIO(blocked);
+
+ mPriv->protoList[k] = PROT_UNKNOWN;
+
+ xfree(tmplist);
+}
+
+
+/* This only needs to be done once */
+void **serialDefaultsList = NULL;
+
+/*
+ * createSerialDefaultsLists() - create a list of the different default
+ * settings for the serial interface of the known protocols.
+ */
+static void
+createSerialDefaultsList(void)
+{
+ int i = 0, j, k;
+
+ serialDefaultsList = (void **)xnfalloc(sizeof(void*));
+ serialDefaultsList[0] = NULL;
+
+ for (j = 0; mouseProtocols[j].name; j++) {
+ if (!mouseProtocols[j].defaults)
+ continue;
+ for (k = 0; k < i; k++)
+ if (mouseProtocols[j].defaults == serialDefaultsList[k])
+ continue;
+ i++;
+ serialDefaultsList = (void**)xnfrealloc(serialDefaultsList,
+ sizeof(void*)*(i+1));
+ serialDefaultsList[i-1] = mouseProtocols[j].defaults;
+ serialDefaultsList[i] = NULL;
+ }
+}
+
+typedef enum {
+ STATE_INVALID,
+ STATE_UNCERTAIN,
+ STATE_VALID
+} validState;
+
+/* Probing threshold values */
+#define PROBE_UNCERTAINTY 50
+#define BAD_CERTAINTY 6
+#define BAD_INC_CERTAINTY 1
+#define BAD_INC_CERTAINTY_WHEN_SYNC_LOST 2
+
+static validState
+validCount(mousePrivPtr mPriv, Bool inSync, Bool lostSync)
+{
+ if (inSync) {
+ if (!--mPriv->goodCount) {
+ /* we are sure to have found the correct protocol */
+ mPriv->badCount = 0;
+ return STATE_VALID;
+ }
+ AP_DBG(("%i successful rounds to go\n",
+ mPriv->goodCount));
+ return STATE_UNCERTAIN;
+ }
+
+
+ /* We are out of sync again */
+ mPriv->goodCount = PROBE_UNCERTAINTY;
+ /* We increase uncertainty of having the correct protocol */
+ mPriv->badCount+= lostSync ? BAD_INC_CERTAINTY_WHEN_SYNC_LOST
+ : BAD_INC_CERTAINTY;
+
+ if (mPriv->badCount < BAD_CERTAINTY) {
+ /* We are not convinced yet to have the wrong protocol */
+ AP_DBG(("Changing protocol after: %i rounds\n",
+ BAD_CERTAINTY - mPriv->badCount));
+ return STATE_UNCERTAIN;
+ }
+ return STATE_INVALID;
+}
+
+#define RESET_VALIDATION mPriv->goodCount = PROBE_UNCERTAINTY;\
+ mPriv->badCount = 0;\
+ mPriv->prevDx = 0;\
+ mPriv->prevDy = 0;\
+ mPriv->accDx = 0;\
+ mPriv->accDy = 0;\
+ mPriv->acc = 0;
+
+static void
+autoProbeMouse(InputInfoPtr pInfo, Bool inSync, Bool lostSync)
+{
+ MouseDevPtr pMse = pInfo->private;
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+
+ MouseProtocolID *protocolList = NULL;
+
+ while (1) {
+ switch (mPriv->autoState) {
+ case AUTOPROBE_GOOD:
+ if (inSync)
+ return;
+ AP_DBG(("State GOOD\n"));
+ RESET_VALIDATION;
+ mPriv->autoState = AUTOPROBE_VALIDATE1;
+ return;
+ case AUTOPROBE_H_GOOD:
+ if (inSync)
+ return;
+ AP_DBG(("State H_GOOD\n"));
+ RESET_VALIDATION;
+ mPriv->autoState = AUTOPROBE_H_VALIDATE2;
+ return;
+ case AUTOPROBE_H_NOPROTO:
+ AP_DBG(("State H_NOPROTO\n"));
+ mPriv->protocolID = 0;
+ mPriv->autoState = AUTOPROBE_H_SETPROTO;
+ break;
+ case AUTOPROBE_H_SETPROTO:
+ AP_DBG(("State H_SETPROTO\n"));
+ if ((pMse->protocolID = hardProtocolList[mPriv->protocolID++])
+ == PROT_UNKNOWN) {
+ mPriv->protocolID = 0;
+ break;
+ } else if (GetProtocol(pMse->protocolID) && SetupMouse(pInfo)) {
+ FlushButtons(pMse);
+ RESET_VALIDATION;
+ AP_DBG(("Autoprobe: Trying Protocol: %s\n",
+ ProtocolIDToName(pMse->protocolID)));
+ mPriv->autoState = AUTOPROBE_H_VALIDATE1;
+ return;
+ }
+ break;
+ case AUTOPROBE_H_VALIDATE1:
+ AP_DBG(("State H_VALIDATE1\n"));
+ switch (validCount(mPriv,inSync,lostSync)) {
+ case STATE_INVALID:
+ mPriv->autoState = AUTOPROBE_H_SETPROTO;
+ break;
+ case STATE_VALID:
+ xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
+ ProtocolIDToName(pMse->protocolID));
+ mPriv->autoState = AUTOPROBE_H_GOOD;
+ return;
+ case STATE_UNCERTAIN:
+ return;
+ default:
+ break;
+ }
+ break;
+ case AUTOPROBE_H_VALIDATE2:
+ AP_DBG(("State H_VALIDATE2\n"));
+ switch (validCount(mPriv,inSync,lostSync)) {
+ case STATE_INVALID:
+ mPriv->autoState = AUTOPROBE_H_AUTODETECT;
+ break;
+ case STATE_VALID:
+ xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
+ ProtocolIDToName(pMse->protocolID));
+ mPriv->autoState = AUTOPROBE_H_GOOD;
+ return;
+ case STATE_UNCERTAIN:
+ return;
+ }
+ break;
+ case AUTOPROBE_H_AUTODETECT:
+ AP_DBG(("State H_AUTODETECT\n"));
+ pMse->protocolID = PROT_AUTO;
+ AP_DBG(("Looking for PnP/OS mouse\n"));
+ mPriv->count = 0;
+ SetupMouse(pInfo);
+ if (pMse->protocolID != PROT_AUTO)
+ mPriv->autoState = AUTOPROBE_H_GOOD;
+ else
+ mPriv->autoState = AUTOPROBE_H_NOPROTO;
+ break;
+ case AUTOPROBE_NOPROTO:
+ AP_DBG(("State NOPROTO\n"));
+ mPriv->count = 0;
+ mPriv->serialDefaultsNum = -1;
+ mPriv->autoState = AUTOPROBE_COLLECT;
+ break;
+ case AUTOPROBE_COLLECT:
+ AP_DBG(("State COLLECT\n"));
+ if (mPriv->count <= NUM_MSE_AUTOPROBE_BYTES)
+ return;
+ protocolList = softProtocolList;
+ mPriv->autoState = AUTOPROBE_CREATE_PROTOLIST;
+ break;
+ case AUTOPROBE_CREATE_PROTOLIST:
+ AP_DBG(("State CREATE_PROTOLIST\n"));
+ createProtoList(pMse, protocolList);
+ mPriv->protocolID = 0;
+ mPriv->autoState = AUTOPROBE_SWITCH_PROTOCOL;
+ break;
+ case AUTOPROBE_AUTODETECT:
+ AP_DBG(("State AUTODETECT\n"));
+ pMse->protocolID = PROT_AUTO;
+ AP_DBG(("Looking for PnP/OS mouse\n"));
+ mPriv->count = 0;
+ SetupMouse(pInfo);
+ if (pMse->protocolID != PROT_AUTO)
+ mPriv->autoState = AUTOPROBE_GOOD;
+ else
+ mPriv->autoState = AUTOPROBE_NOPROTO;
+ break;
+ case AUTOPROBE_VALIDATE1:
+ AP_DBG(("State VALIDATE1\n"));
+ switch (validCount(mPriv,inSync,lostSync)) {
+ case STATE_INVALID:
+ mPriv->autoState = AUTOPROBE_AUTODETECT;
+ break;
+ case STATE_VALID:
+ xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
+ ProtocolIDToName(pMse->protocolID));
+ mPriv->autoState = AUTOPROBE_GOOD;
+ break;
+ case STATE_UNCERTAIN:
+ return;
+ }
+ break;
+ case AUTOPROBE_VALIDATE2:
+ AP_DBG(("State VALIDATE2\n"));
+ switch (validCount(mPriv,inSync,lostSync)) {
+ case STATE_INVALID:
+ protocolList = &mPriv->protoList[mPriv->protocolID];
+ mPriv->autoState = AUTOPROBE_CREATE_PROTOLIST;
+ break;
+ case STATE_VALID:
+ xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
+ ProtocolIDToName(pMse->protocolID));
+ mPriv->autoState = AUTOPROBE_GOOD;
+ break;
+ case STATE_UNCERTAIN:
+ return;
+ }
+ break;
+ case AUTOPROBE_SWITCHSERIAL:
+ {
+ pointer serialDefaults;
+ AP_DBG(("State SWITCHSERIAL\n"));
+
+ if (!serialDefaultsList)
+ createSerialDefaultsList();
+
+ AP_DBG(("Switching serial params\n"));
+ if ((serialDefaults =
+ serialDefaultsList[++mPriv->serialDefaultsNum]) == NULL) {
+ mPriv->serialDefaultsNum = 0;
+ } else {
+ pointer tmp = xf86OptionListCreate(serialDefaults, -1, 0);
+ xf86SetSerial(pInfo->fd, tmp);
+ xf86OptionListFree(tmp);
+ mPriv->count = 0;
+ mPriv->autoState = AUTOPROBE_COLLECT;
+ }
+ break;
+ }
+ case AUTOPROBE_SWITCH_PROTOCOL:
+ {
+ MouseProtocolID proto;
+ void *defaults;
+ AP_DBG(("State SWITCH_PROTOCOL\n"));
+ proto = mPriv->protoList[mPriv->protocolID++];
+ if (proto == PROT_UNKNOWN)
+ mPriv->autoState = AUTOPROBE_SWITCHSERIAL;
+ else if (!(defaults = GetProtocol(proto)->defaults)
+ || (mPriv->serialDefaultsNum == -1
+ && (defaults == msDefaults))
+ || (mPriv->serialDefaultsNum != -1
+ && serialDefaultsList[mPriv->serialDefaultsNum]
+ == defaults)) {
+ AP_DBG(("Changing Protocol to %s\n",
+ ProtocolIDToName(proto)));
+ SetMouseProto(pMse,proto);
+ FlushButtons(pMse);
+ RESET_VALIDATION;
+ mPriv->autoState = AUTOPROBE_VALIDATE2;
+ return;
+ }
+ break;
+ }
+ }
+ }
+}
+
+static Bool
+autoGood(MouseDevPtr pMse)
+{
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+
+ if (!pMse->autoProbe)
+ return TRUE;
+
+ switch (mPriv->autoState) {
+ case AUTOPROBE_GOOD:
+ case AUTOPROBE_H_GOOD:
+ return TRUE;
+ case AUTOPROBE_VALIDATE1: /* @@@ */
+ case AUTOPROBE_H_VALIDATE1: /* @@@ */
+ case AUTOPROBE_VALIDATE2:
+ case AUTOPROBE_H_VALIDATE2:
+ if (mPriv->goodCount < PROBE_UNCERTAINTY/2)
+ return TRUE;
+ default:
+ return FALSE;
+ }
+}
+
+
+#define TOT_THRESHOLD 3000
+#define VAL_THRESHOLD 40
+
+/*
+ * checkForErraticMovements() -- check if mouse 'jumps around'.
+ */
+static void
+checkForErraticMovements(InputInfoPtr pInfo, int dx, int dy)
+{
+ MouseDevPtr pMse = pInfo->private;
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+#if 1
+ if (!mPriv->goodCount)
+ return;
+#endif
+#if 0
+ if (abs(dx - mPriv->prevDx) > 300
+ || abs(dy - mPriv->prevDy) > 300)
+ AP_DBG(("erratic1 behaviour\n"));
+#endif
+ if (abs(dx) > VAL_THRESHOLD) {
+ if (sign(dx) == sign(mPriv->prevDx)) {
+ mPriv->accDx += dx;
+ if (abs(mPriv->accDx) > mPriv->acc) {
+ mPriv->acc = abs(mPriv->accDx);
+ AP_DBG(("acc=%i\n",mPriv->acc));
+ }
+ else
+ AP_DBG(("accDx=%i\n",mPriv->accDx));
+ } else {
+ mPriv->accDx = 0;
+ }
+ }
+
+ if (abs(dy) > VAL_THRESHOLD) {
+ if (sign(dy) == sign(mPriv->prevDy)) {
+ mPriv->accDy += dy;
+ if (abs(mPriv->accDy) > mPriv->acc) {
+ mPriv->acc = abs(mPriv->accDy);
+ AP_DBG(("acc: %i\n",mPriv->acc));
+ } else
+ AP_DBG(("accDy=%i\n",mPriv->accDy));
+ } else {
+ mPriv->accDy = 0;
+ }
+ }
+ mPriv->prevDx = dx;
+ mPriv->prevDy = dy;
+ if (mPriv->acc > TOT_THRESHOLD) {
+ mPriv->goodCount = PROBE_UNCERTAINTY;
+ mPriv->prevDx = 0;
+ mPriv->prevDy = 0;
+ mPriv->accDx = 0;
+ mPriv->accDy = 0;
+ mPriv->acc = 0;
+ AP_DBG(("erratic2 behaviour\n"));
+ autoProbeMouse(pInfo, FALSE,TRUE);
+ }
+}
+
+static void
+SetMouseProto(MouseDevPtr pMse, MouseProtocolID protocolID)
+{
+ pMse->protocolID = protocolID;
+ pMse->protocol = ProtocolIDToName(pMse->protocolID);
+ pMse->class = ProtocolIDToClass(pMse->protocolID);
+ if ((pMse->protocolID >= 0) && (pMse->protocolID < PROT_NUMPROTOS))
+ memcpy(pMse->protoPara, proto[pMse->protocolID],
+ sizeof(pMse->protoPara));
+
+ if (pMse->emulate3ButtonsSoft)
+ pMse->emulate3Buttons = TRUE;
+}
+
+/*
+ * collectData() -- collect data bytes sent by mouse.
+ */
+static Bool
+collectData(MouseDevPtr pMse, unsigned char u)
+{
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+ if (mPriv->count < NUM_MSE_AUTOPROBE_TOTAL) {
+ mPriv->data[mPriv->count++] = u;
+ if (mPriv->count <= NUM_MSE_AUTOPROBE_BYTES) {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/**************** end of autoprobe stuff *****************/
+
+
+
+#ifdef XFree86LOADER
+ModuleInfoRec MouseInfo = {
+ 1,
+ "MOUSE",
+ NULL,
+ 0,
+ MouseAvailableOptions,
+};
+
+static void
+xf86MouseUnplug(pointer p)
+{
+}
+static pointer
+xf86MousePlug(pointer module,
+ pointer options,
+ int *errmaj,
+ int *errmin)
+{
+ static Bool Initialised = FALSE;
+
+ if (!Initialised) {
+ Initialised = TRUE;
+#ifndef REMOVE_LOADER_CHECK_MODULE_INFO
+ if (xf86LoaderCheckSymbol("xf86AddModuleInfo"))
+#endif
+ xf86AddModuleInfo(&MouseInfo, module);
+ }
+
+ xf86AddInputDriver(&MOUSE, module, 0);
+
+ return module;
+}
+
+static XF86ModuleVersionInfo xf86MouseVersionRec =
+{
+ "mouse",
+ MODULEVENDORSTRING,
+ MODINFOSTRING1,
+ MODINFOSTRING2,
+ XF86_VERSION_CURRENT,
+ 1, 0, 0,
+ ABI_CLASS_XINPUT,
+ ABI_XINPUT_VERSION,
+ MOD_CLASS_XINPUT,
+ {0, 0, 0, 0} /* signature, to be patched into the file by */
+ /* a tool */
+};
+
+XF86ModuleData mouseModuleData = {&xf86MouseVersionRec,
+ xf86MousePlug,
+ xf86MouseUnplug};
+
+/*
+ Look at hitachi device stuff.
+*/
+#endif /* XFree86LOADER */
+
+
diff --git a/src/mouse.h b/src/mouse.h
new file mode 100644
index 0000000..76295c7
--- /dev/null
+++ b/src/mouse.h
@@ -0,0 +1,42 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/input/mouse/mouse.h,v 1.11 2002/09/16 18:06:07 eich Exp $ */
+
+/*
+ * Copyright (c) 1997-1999 by The XFree86 Project, Inc.
+ */
+
+#ifndef MOUSE_H_
+#define MOUSE_H_
+
+/* Mouse Protocol IDs. */
+typedef enum {
+ PROT_UNKNOWN = -2,
+ PROT_UNSUP = -1, /* protocol is not supported */
+ PROT_MS = 0,
+ PROT_MSC,
+ PROT_MM,
+ PROT_LOGI,
+ PROT_LOGIMAN,
+ PROT_MMHIT,
+ PROT_GLIDE,
+ PROT_IMSERIAL,
+ PROT_THINKING,
+ PROT_ACECAD,
+ PROT_PS2,
+ PROT_GENPS2,
+ PROT_IMPS2,
+ PROT_EXPPS2,
+ PROT_THINKPS2,
+ PROT_MMPS2,
+ PROT_GLIDEPS2,
+ PROT_NETPS2,
+ PROT_NETSCPS2,
+ PROT_BM,
+ PROT_AUTO,
+ PROT_SYSMOUSE,
+ PROT_NUMPROTOS /* This must always be last. */
+} MouseProtocolID;
+
+const char * xf86MouseProtocolIDToName(MouseProtocolID id);
+MouseProtocolID xf86MouseProtocolNameToID(const char *name);
+
+#endif
diff --git a/src/mousePriv.h b/src/mousePriv.h
new file mode 100644
index 0000000..0b76b1d
--- /dev/null
+++ b/src/mousePriv.h
@@ -0,0 +1,74 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/input/mouse/mousePriv.h,v 1.8 2002/09/16 18:06:08 eich Exp $ */
+/*
+ * Copyright (c) 1997-1999 by The XFree86 Project, Inc.
+ */
+
+#ifndef _X_MOUSEPRIV_H
+#define _X_MOUSEPRIV_H
+
+#include "mouse.h"
+#include "xf86Xinput.h"
+/* Private interface for the mouse driver. */
+
+typedef enum {
+ AUTOPROBE_H_NOPROTO,
+ AUTOPROBE_H_GOOD,
+ AUTOPROBE_H_AUTODETECT,
+ AUTOPROBE_H_VALIDATE1,
+ AUTOPROBE_H_VALIDATE2,
+ AUTOPROBE_H_SETPROTO,
+ AUTOPROBE_NOPROTO,
+ AUTOPROBE_COLLECT,
+ AUTOPROBE_CREATE_PROTOLIST,
+ AUTOPROBE_GOOD,
+ AUTOPROBE_AUTODETECT,
+ AUTOPROBE_VALIDATE1,
+ AUTOPROBE_VALIDATE2,
+ AUTOPROBE_SWITCHSERIAL,
+ AUTOPROBE_SWITCH_PROTOCOL
+} mseAutoProbeStates;
+
+typedef struct {
+ const char * name;
+ int class;
+ const char ** defaults;
+ MouseProtocolID id;
+} MouseProtocolRec, *MouseProtocolPtr;
+
+#define NUM_MSE_AUTOPROBE_BYTES 24 /* multiple of 3,4 and 6 byte packages */
+#define NUM_MSE_AUTOPROBE_TOTAL 64
+#define NUM_AUTOPROBE_PROTOS 17
+
+
+typedef struct {
+ int current;
+ Bool inReset;
+ CARD32 lastEvent;
+ CARD32 expires;
+ Bool soft;
+ int goodCount;
+ int badCount;
+ int protocolID;
+ int count;
+ char data[NUM_MSE_AUTOPROBE_TOTAL];
+ mseAutoProbeStates autoState;
+ int protoList[NUM_AUTOPROBE_PROTOS];
+ int serialDefaultsNum;
+ int prevDx, prevDy;
+ int accDx, accDy;
+ int acc;
+ CARD32 pnpLast;
+ Bool disablePnPauto;
+} mousePrivRec, *mousePrivPtr;
+
+/* mouse proto flags */
+#define MPF_NONE 0x00
+#define MPF_SAFE 0x01
+
+/* pnp.c */
+int MouseGetPnpProtocol(InputInfoPtr pInfo);
+Bool ps2Reset(InputInfoPtr pInfo);
+Bool ps2EnableDataReporting(InputInfoPtr pInfo);
+Bool ps2SendPacket(InputInfoPtr pInfo, unsigned char *bytes, int len);
+
+#endif /* _X_MOUSE_H */
diff --git a/src/pnp.c b/src/pnp.c
new file mode 100644
index 0000000..a5e650d
--- /dev/null
+++ b/src/pnp.c
@@ -0,0 +1,778 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/input/mouse/pnp.c,v 1.16 2003/02/04 15:21:18 eich Exp $ */
+/*
+ * Copyright 1998 by Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
+ *
+ * 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 name of Kazutaka YOKOTA not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Kazutaka YOKOTA makes no representations
+ * about the suitability of this software for any purpose. It is provided
+ * "as is" without express or implied warranty.
+ *
+ * KAZUTAKA YOKOTA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KAZUTAKA YOKOTA 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.
+ */
+
+#define NEED_EVENTS
+#include "X.h"
+#include "Xproto.h"
+#include "inputstr.h"
+#include "scrnintstr.h"
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86Xinput.h"
+#include "xf86_OSproc.h"
+#include "xf86OSmouse.h"
+#include "xf86_ansic.h"
+#include "mouse.h"
+#include "mousePriv.h"
+
+/* serial PnP ID string */
+typedef struct {
+ int revision; /* PnP revision, 100 for 1.00 */
+ char *eisaid; /* EISA ID including mfr ID and product ID */
+ char *serial; /* serial No, optional */
+ char *class; /* device class, optional */
+ char *compat; /* list of compatible drivers, optional */
+ char *description; /* product description, optional */
+ int neisaid; /* length of the above fields... */
+ int nserial;
+ int nclass;
+ int ncompat;
+ int ndescription;
+} pnpid_t;
+
+/* symbol table entry */
+typedef struct {
+ char *name;
+ int val;
+} symtab_t;
+
+/* PnP EISA/product IDs */
+static symtab_t pnpprod[] = {
+ { "KML0001", PROT_THINKING }, /* Kensignton ThinkingMouse */
+ { "MSH0001", PROT_IMSERIAL }, /* MS IntelliMouse */
+ { "MSH0004", PROT_IMSERIAL }, /* MS IntelliMouse TrackBall */
+ { "KYEEZ00", PROT_MS }, /* Genius EZScroll */
+ { "KYE0001", PROT_MS }, /* Genius PnP Mouse */
+ { "KYE0002", PROT_MS }, /* MouseSystem (Genius?) SmartScroll */
+ { "KYE0003", PROT_IMSERIAL }, /* Genius NetMouse */
+ { "LGI800C", PROT_IMSERIAL }, /* Logitech MouseMan (4 button model) */
+ { "LGI8033", PROT_IMSERIAL }, /* Logitech Cordless MouseMan Wheel */
+ { "LGI8050", PROT_IMSERIAL }, /* Logitech MouseMan+ */
+ { "LGI8051", PROT_IMSERIAL }, /* Logitech FirstMouse+ */
+ { "LGI8001", PROT_LOGIMAN }, /* Logitech serial */
+ { "A4W0005", PROT_IMSERIAL }, /* A4 Tech 4D/4D+ Mouse */
+ { "PEC9802", PROT_IMSERIAL }, /* 8D Scroll Mouse */
+
+ { "PNP0F00", PROT_BM }, /* MS bus */
+ { "PNP0F01", PROT_MS }, /* MS serial */
+ { "PNP0F02", PROT_BM }, /* MS InPort */
+ { "PNP0F03", PROT_PS2 }, /* MS PS/2 */
+ /*
+ * EzScroll returns PNP0F04 in the compatible device field; but it
+ * doesn't look compatible... XXX
+ */
+ { "PNP0F04", PROT_MSC }, /* MouseSystems */
+ { "PNP0F05", PROT_MSC }, /* MouseSystems */
+#ifdef notyet
+ { "PNP0F06", PROT_??? }, /* Genius Mouse */
+ { "PNP0F07", PROT_??? }, /* Genius Mouse */
+#endif
+ { "PNP0F08", PROT_LOGIMAN }, /* Logitech serial */
+ { "PNP0F09", PROT_MS }, /* MS BallPoint serial */
+ { "PNP0F0A", PROT_MS }, /* MS PnP serial */
+ { "PNP0F0B", PROT_MS }, /* MS PnP BallPoint serial */
+ { "PNP0F0C", PROT_MS }, /* MS serial comatible */
+ { "PNP0F0D", PROT_BM }, /* MS InPort comatible */
+ { "PNP0F0E", PROT_PS2 }, /* MS PS/2 comatible */
+ { "PNP0F0F", PROT_MS }, /* MS BallPoint comatible */
+#ifdef notyet
+ { "PNP0F10", PROT_??? }, /* TI QuickPort */
+#endif
+ { "PNP0F11", PROT_BM }, /* MS bus comatible */
+ { "PNP0F12", PROT_PS2 }, /* Logitech PS/2 */
+ { "PNP0F13", PROT_PS2 }, /* PS/2 */
+#ifdef notyet
+ { "PNP0F14", PROT_??? }, /* MS Kids Mouse */
+#endif
+ { "PNP0F15", PROT_BM }, /* Logitech bus */
+#ifdef notyet
+ { "PNP0F16", PROT_??? }, /* Logitech SWIFT */
+#endif
+ { "PNP0F17", PROT_LOGIMAN }, /* Logitech serial compat */
+ { "PNP0F18", PROT_BM }, /* Logitech bus compatible */
+ { "PNP0F19", PROT_PS2 }, /* Logitech PS/2 compatible */
+#ifdef notyet
+ { "PNP0F1A", PROT_??? }, /* Logitech SWIFT compatible */
+ { "PNP0F1B", PROT_??? }, /* HP Omnibook */
+ { "PNP0F1C", PROT_??? }, /* Compaq LTE TrackBall PS/2 */
+ { "PNP0F1D", PROT_??? }, /* Compaq LTE TrackBall serial */
+ { "PNP0F1E", PROT_??? }, /* MS Kids Trackball */
+#endif
+ { NULL, -1 },
+};
+
+static const char *pnpSerial[] = {
+ "BaudRate", "1200",
+ "DataBits", "7",
+ "StopBits", "1",
+ "Parity", "None",
+ "FlowControl", "None",
+ "VTime", "0",
+ "VMin", "1",
+ NULL
+};
+
+static int pnpgets(InputInfoPtr, char *, Bool *prePNP);
+static int pnpparse(InputInfoPtr, pnpid_t *, char *, int);
+static int prepnpparse(InputInfoPtr pInfo, char *buf);
+static symtab_t *pnpproto(pnpid_t *);
+static symtab_t *gettoken(symtab_t *, char *, int);
+static MouseProtocolID getPs2ProtocolPnP(InputInfoPtr pInfo);
+static MouseProtocolID probePs2ProtocolPnP(InputInfoPtr pInfo);
+
+static int
+MouseGetSerialPnpProtocol(InputInfoPtr pInfo)
+{
+ char buf[256]; /* PnP ID string may be up to 256 bytes long */
+ pnpid_t pnpid;
+ symtab_t *t;
+ int len;
+ Bool prePNP;
+
+ if ((len = pnpgets(pInfo, buf, &prePNP)) > 0)
+ {
+ if (!prePNP) {
+ if (pnpparse(pInfo, &pnpid, buf, len) &&
+ (t = pnpproto(&pnpid)) != NULL) {
+ xf86MsgVerb(X_INFO, 2, "%s: PnP-detected protocol ID: %d\n",
+ pInfo->name, t->val);
+ return (t->val);
+ }
+ } else
+ return prepnpparse(pInfo,buf);
+ }
+ return PROT_UNKNOWN;
+}
+
+int
+MouseGetPnpProtocol(InputInfoPtr pInfo)
+{
+ MouseDevPtr pMse = pInfo->private;
+ mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
+ int val;
+ CARD32 last;
+
+ if ((val = MouseGetSerialPnpProtocol(pInfo)) != PROT_UNKNOWN) {
+ if (val == MouseGetSerialPnpProtocol(pInfo))
+ return val;
+ }
+
+#if 1
+ last = mPriv->pnpLast;
+ mPriv->pnpLast = currentTime.milliseconds;
+
+ if (last) {
+ if (last - currentTime.milliseconds < 100
+ || (mPriv->disablePnPauto
+ && (last - currentTime.milliseconds < 10000))) {
+#ifdef EXTMOUSEDEBUG
+ xf86ErrorF("Mouse: Disabling PnP\n");
+#endif
+ mPriv->disablePnPauto = TRUE;
+ return PROT_UNKNOWN;
+ }
+ }
+
+#ifdef EXTMOUSEDEBUG
+ if (mPriv->disablePnPauto)
+ xf86ErrorF("Mouse: Enabling PnP\n");
+#endif
+ mPriv->disablePnPauto = FALSE;
+
+ if (mPriv->soft)
+ return getPs2ProtocolPnP(pInfo);
+ else
+ return probePs2ProtocolPnP(pInfo);
+#else
+ return PROT_UNKNOWN;
+#endif
+}
+
+/*
+ * 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 per 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(InputInfoPtr pInfo, char *buf, Bool *prePNP)
+{
+ int i;
+ char c;
+ pointer pnpOpts;
+
+#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) */
+ if ((i = xf86GetSerialModemState(pInfo->fd)) == -1)
+ return 0;
+ i |= XF86_M_DTR; /* DTR = 1 */
+ i &= ~XF86_M_RTS; /* RTS = 0 */
+ if (xf86SetSerialModemState(pInfo->fd, i) == -1)
+ goto disconnect_idle;
+ usleep(200000);
+ if ((i = xf86GetSerialModemState(pInfo->fd)) == -1 ||
+ (i & XF86_M_DSR) == 0)
+ goto disconnect_idle;
+
+ /* port setup, 1st phase (2.1.3) */
+ pnpOpts = xf86OptionListCreate(pnpSerial, -1, 1);
+ xf86SetSerial(pInfo->fd, pnpOpts);
+ i = TIOCM_DTR | TIOCM_RTS; /* DTR = 0, RTS = 0 */
+ xf86SerialModemClearBits(pInfo->fd, i);
+ usleep(200000);
+ i = TIOCM_DTR; /* DTR = 1, RTS = 0 */
+ xf86SerialModemSetBits(pInfo->fd, i);
+ usleep(200000);
+
+ /* wait for response, 1st phase (2.1.4) */
+ xf86FlushInput(pInfo->fd);
+ i = TIOCM_RTS; /* DTR = 1, RTS = 1 */
+ xf86SerialModemSetBits(pInfo->fd, i);
+
+ /* try to read something */
+ if (xf86WaitForInput(pInfo->fd, 200000) <= 0) {
+
+ /* port setup, 2nd phase (2.1.5) */
+ i = TIOCM_DTR | TIOCM_RTS; /* DTR = 0, RTS = 0 */
+ xf86SerialModemClearBits(pInfo->fd, i);
+ usleep(200000);
+
+ /* wait for respose, 2nd phase (2.1.6) */
+ xf86FlushInput(pInfo->fd);
+ i = TIOCM_DTR | TIOCM_RTS; /* DTR = 1, RTS = 1 */
+ xf86SerialModemSetBits(pInfo->fd, i);
+
+ /* try to read something */
+ if (xf86WaitForInput(pInfo->fd, 200000) <= 0)
+ goto connect_idle;
+ }
+#else
+ /*
+ * This is a simplified procedure; it simply toggles RTS.
+ */
+
+ if ((i = xf86GetSerialModemState(pInfo->fd)) == -1)
+ return 0;
+ i |= XF86_M_DTR; /* DTR = 1 */
+ i &= ~XF86_M_RTS; /* RTS = 0 */
+ if (xf86SetSerialModemState(pInfo->fd, i) == -1)
+ goto disconnect_idle;
+ usleep(200000);
+
+ pnpOpts = xf86OptionListCreate(pnpSerial, -1, 1);
+ xf86SetSerial(pInfo->fd, pnpOpts);
+
+ /* wait for respose */
+ xf86FlushInput(pInfo->fd);
+ i = XF86_M_DTR | XF86_M_RTS; /* DTR = 1, RTS = 1 */
+ xf86SerialModemSetBits(pInfo->fd, i);
+
+ /* try to read something */
+ if (xf86WaitForInput(pInfo->fd, 200000) <= 0)
+ goto connect_idle;
+#endif
+
+ /* collect PnP COM device ID (2.1.7) */
+ i = 0;
+ *prePNP = FALSE;
+
+ usleep(200000); /* the mouse must send `Begin ID' within 200msec */
+ while (xf86ReadSerial(pInfo->fd, &c, 1) == 1) {
+ /* we may see "M", or "M3..." before `Begin ID' */
+ if (c == 'M')
+ *prePNP = TRUE;
+
+ if ((c == 0x08) || (c == 0x28)) { /* Begin ID */
+ *prePNP = FALSE;
+ buf[0] = c;
+ i = 1;
+ break;
+ }
+ if (*prePNP)
+ buf[i++] = c;
+
+ if (xf86WaitForInput(pInfo->fd, 200000) <= 0)
+ break;
+ }
+ if (i <= 0) {
+ /* we haven't seen `Begin ID' in time... */
+ goto connect_idle;
+ }
+ if (*prePNP)
+ return i;
+
+ ++c; /* make it `End ID' */
+ for (;;) {
+ if (xf86WaitForInput(pInfo->fd, 200000) <= 0)
+ break;
+
+ xf86ReadSerial(pInfo->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;
+
+ /*
+ * 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 = XF86_M_DTR | XF86_M_RTS; /* DTR = 1, RTS = 1 */
+ xf86SerialModemSetBits(pInfo->fd, i);
+connect_idle:
+ return 0;
+}
+
+static int
+pnpparse(InputInfoPtr pInfo, 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;
+ xf86MsgVerb(X_INFO, 2, "%s: PnP ID string: `%*.*s'\n", pInfo->name,
+ len, len, buf);
+
+ /* revision */
+ buf[1] -= offset;
+ buf[2] -= offset;
+ id->revision = ((buf[1] & 0x3f) << 6) | (buf[2] & 0x3f);
+ xf86MsgVerb(X_INFO, 2, "%s: PnP rev %d.%02d\n", pInfo->name,
+ 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)) {
+ xf86MsgVerb(X_INFO, 4, "PnP checksum: 0x%02X\n", pInfo->name, sum);
+ 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 TRUE;
+}
+
+/* We can only identify MS at the moment */
+static int
+prepnpparse(InputInfoPtr pInfo, char *buf)
+{
+ if (buf[0] == 'M' && buf[1] == '3')
+ return PROT_MS;
+ return PROT_UNKNOWN;
+}
+
+
+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;
+}
+
+/* name/val mapping */
+
+static symtab_t *
+gettoken(tab, s, len)
+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];
+}
+
+/******************* PS/2 PnP probing ****************/
+
+static int
+readMouse(InputInfoPtr pInfo, unsigned char *u)
+{
+
+ if (xf86WaitForInput(pInfo->fd, 200000) <= 0)
+ return FALSE;
+
+ xf86ReadSerial(pInfo->fd, u, 1);
+ return TRUE;
+}
+
+static void
+ps2DisableWrapMode(InputInfoPtr pInfo)
+{
+ unsigned char reset_wrap_mode[] = { 0xEC };
+ ps2SendPacket(pInfo, reset_wrap_mode, sizeof(reset_wrap_mode));
+}
+
+Bool
+ps2SendPacket(InputInfoPtr pInfo, unsigned char *bytes, int len)
+{
+ unsigned char c;
+ int i,j;
+
+#ifdef DEBUG
+ xf86ErrorF("Ps/2 data package:");
+ for (i = 0; i < len; i++)
+ xf86ErrorF(" %x", *(bytes + i));
+ xf86ErrorF("\n");
+#endif
+
+ for (i = 0; i < len; i++) {
+ for (j = 0; j < 10; j++) {
+ xf86WriteSerial(pInfo->fd, bytes + i, 1);
+ usleep(10000);
+ if (!readMouse(pInfo,&c)) {
+#ifdef DEBUG
+ xf86ErrorF("sending 0x%x to PS/2 unsuccessful\n",*(bytes + i));
+#endif
+ return FALSE;
+ }
+#ifdef DEBUG
+ xf86ErrorF("Recieved: 0x%x\n",c);
+#endif
+ if (c == 0xFA) /* ACK */
+ break;
+
+ if (c == 0xFE) /* resend */
+ continue;
+
+
+ if (c == 0xFC) /* error */
+ return FALSE;
+
+ /* Some mice accidently enter wrap mode during init */
+ if (c == *(bytes + i) /* wrap mode */
+ && (*(bytes + i) != 0xEC)) /* avoid recursion */
+ ps2DisableWrapMode(pInfo);
+
+ return FALSE;
+ }
+ if (j == 10)
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static Bool
+ps2DisableDataReporting(InputInfoPtr pInfo)
+{
+ unsigned char packet[] = { 0xF5 };
+ return ps2SendPacket(pInfo, packet, sizeof(packet));
+}
+
+Bool
+ps2EnableDataReporting(InputInfoPtr pInfo)
+{
+ unsigned char packet[] = { 0xF4 };
+ return ps2SendPacket(pInfo, packet, sizeof(packet));
+}
+
+static int
+ps2GetDeviceID(InputInfoPtr pInfo)
+{
+ unsigned char u;
+ unsigned char packet[] = { 0xf2 };
+ if (!ps2SendPacket(pInfo, packet, sizeof(packet)))
+ return -1;
+ while (1) {
+ if (!readMouse(pInfo,&u))
+ return -1;
+ if (u != 0xFA)
+ break;
+ }
+#ifdef DEBUG
+ xf86ErrorF("Obtained Mouse Type: %x\n",u);
+#endif
+ return (int) u;
+}
+
+Bool
+ps2Reset(InputInfoPtr pInfo)
+{
+ unsigned char u;
+ unsigned char packet[] = { 0xff };
+ unsigned char reply[] = { 0xaa, 0x00 };
+ int i;
+#ifdef DEBUG
+ xf86ErrorF("PS/2 Mouse reset\n");
+#endif
+ if (!ps2SendPacket(pInfo, packet, sizeof(packet)))
+ return FALSE;
+ /* we need a little delay here */
+ xf86WaitForInput(pInfo->fd, 500000);
+ for (i = 0; i < sizeof(reply) ; i++) {
+ if (!readMouse(pInfo,&u)) {
+ goto EXIT;
+ }
+ if (u != reply[i])
+ goto EXIT;
+ }
+ return TRUE;
+
+ EXIT:
+ xf86FlushInput(pInfo->fd);
+ return FALSE;
+}
+
+static MouseProtocolID
+probePs2ProtocolPnP(InputInfoPtr pInfo)
+{
+ unsigned char u;
+ MouseProtocolID ret = PROT_UNKNOWN;
+
+ xf86FlushInput(pInfo->fd);
+
+ ps2DisableDataReporting(pInfo);
+
+ if (ps2Reset(pInfo)) { /* Reset PS2 device */
+ unsigned char seq[] = { 243, 200, 243, 100, 243, 80, 242 };
+ /* Try to identify Intelli Mouse */
+ if (ps2SendPacket(pInfo, seq, sizeof(seq))) {
+ readMouse(pInfo,&u);
+ if (u == 0x03) {
+ /* found IntelliMouse now try IntelliExplorer */
+ unsigned char seq[] = { 243, 200, 243, 200, 243, 80, 242 };
+ if (ps2SendPacket(pInfo,seq,sizeof(seq))) {
+ readMouse(pInfo,&u);
+ if (u == 0x05)
+ ret = PROT_EXPPS2;
+ else
+ ret = PROT_IMPS2;
+ }
+ } else if (ps2Reset(pInfo)) /* reset again to find sane state */
+ ret = PROT_PS2;
+ }
+
+ if (ret != PROT_UNKNOWN)
+ ps2EnableDataReporting(pInfo);
+ }
+ return ret;
+}
+
+static struct ps2protos {
+ int Id;
+ MouseProtocolID protoID;
+} ps2 [] = {
+ { 0x0, PROT_PS2 },
+ { 0x3, PROT_IMPS2 },
+ { 0x5, PROT_EXPPS2 },
+ { -1 , PROT_UNKNOWN }
+};
+
+
+static MouseProtocolID
+getPs2ProtocolPnP(InputInfoPtr pInfo)
+{
+ int Id;
+ int i;
+ MouseProtocolID proto;
+ int count = 4;
+
+ xf86FlushInput(pInfo->fd);
+
+ while (--count)
+ if (ps2DisableDataReporting(pInfo))
+ break;
+
+ if (!count) {
+ proto = PROT_UNKNOWN;
+ goto EXIT;
+ }
+
+ if ((Id = ps2GetDeviceID(pInfo)) == -1) {
+ proto = PROT_UNKNOWN;
+ goto EXIT;
+ }
+
+ if (-1 == ps2EnableDataReporting(pInfo)) {
+ proto = PROT_UNKNOWN;
+ goto EXIT;
+ }
+
+ for (i = 0; ps2[i].protoID != PROT_UNKNOWN; i++) {
+ if (ps2[i].Id == Id) {
+ xf86MsgVerb(X_PROBED,2,"Found PS/2 proto ID %x\n",Id);
+ proto = ps2[i].protoID;
+ goto EXIT;
+ }
+ }
+
+ proto = PROT_UNKNOWN;
+ xf86Msg(X_ERROR,"Found unknown PS/2 proto ID %x\n",Id);
+
+ EXIT:
+ xf86FlushInput(pInfo->fd);
+ return proto;
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-05 19:11:48 +0000