xorg-old/patches-6.8.2-r10/9002_all_6.7.0-lnx-evdev-mouse.patch

diff -Nurd xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c xc-patched/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c
--- xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c	2003-10-10 07:06:39.000000000 -0400
+++ xc-patched/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c	2003-12-01 12:54:34.757487668 -0500
@@ -6,12 +6,21 @@
 
 #include "X.h"
 #include "xf86.h"
+#include "xf86Priv.h"
 #include "xf86Xinput.h"
 #include "xf86OSmouse.h"
 #include "xf86_OSlib.h"
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include "mipointer.h"
+#include "lnx_evdev.h"
+
+/* Names of protocols that are handled internally here. */
+static const char *internalNames[] = {
+	"evdev",
+	NULL
+};
 
 static int
 SupportedInterfaces(void)
@@ -185,6 +194,272 @@
     return NULL;
 }
 
+static const char **
+BuiltinNames(void)
+{
+    return internalNames;
+}
+
+static Bool
+CheckProtocol(const char *protocol)
+{
+    int i;
+
+    for (i = 0; internalNames[i]; i++)
+	if (xf86NameCmp(protocol, internalNames[i]) == 0)
+	    return TRUE;
+    return FALSE;
+}
+
+typedef struct _evdevMseRec {
+    int packetSize;
+    int buttons;
+    Bool sync;
+    evdevDriver evdev;
+} evdevMseRec, *evdevMsePtr;
+
+static void
+evdevMouseReadInput(InputInfoPtr pInfo)
+{
+    MouseDevPtr pMse;
+    evdevMsePtr evdevMse;
+    struct input_event *ev;
+    int n, bit; 
+    int dx = 0, dy = 0, dz = 0, dw = 0;
+
+    pMse = pInfo->private;
+    ev = (struct input_event *) pMse->buffer;
+    evdevMse = pMse->mousePriv;
+
+    if (pInfo->fd == -1)
+	return;
+
+    do {
+	n = read(pInfo->fd, pMse->buffer, sizeof(struct input_event));
+	if (n == -1) {
+	    xf86Msg(X_ERROR, "%s: Error in reading! (%s) Disabiling.\n",
+		    pInfo->name, strerror(errno));
+	    RemoveEnabledDevice(pInfo->fd);
+	    xf86RemoveSIGIOHandler(pInfo->fd);
+	    close (pInfo->fd);
+	    pMse->device->public.on = FALSE;
+	    pInfo->fd = -1;
+	    pMse->PostEvent(pInfo, evdevMse->buttons, dx, dy, dz, dw);
+	    return;
+	}
+	if (n != sizeof(struct input_event)) {
+	    xf86Msg(X_WARNING, "%s: incomplete packet, size %d\n", pInfo->name, n);
+	    pMse->PostEvent(pInfo, evdevMse->buttons, dx, dy, dz, dw);
+	    return;
+	}
+
+	switch (ev->type) {
+	    case EV_REL:
+		switch (ev->code) {
+		    case EV_REL_X:
+			dx += ev->value;
+			break;
+		    case EV_REL_Y:
+			dy += ev->value;
+			break;
+		    case EV_REL_Z:
+		    case EV_REL_WHEEL:
+			dz -= ev->value;
+			break;
+		    case EV_REL_HWHEEL:
+			dw -= ev->value;
+			break;
+		}
+		break;
+	    case EV_KEY:
+		if ((ev->code < EV_BTN_MOUSE) || (ev->code >= EV_BTN_JOYSTICK))
+		    break;
+		switch (ev->code) {
+		    case EV_BTN_RIGHT: bit = 1 << 0; break;	/* 1 */
+		    case EV_BTN_MIDDLE: bit = 1 << 1; break;	/* 2 */
+		    case EV_BTN_LEFT: bit = 1 << 2; break;	/* 3 */
+		    default: bit = 1 << (ev->code - EV_BTN_MOUSE); break;
+		}
+		evdevMse->buttons &= ~bit;
+		if (ev->value)
+		    evdevMse->buttons |= bit;
+		break;
+	    case EV_SYN:
+		switch (ev->code) {
+		    case EV_SYN_REPORT:
+			pMse->PostEvent(pInfo,evdevMse->buttons,dx, dy, dz, dw);
+			dx = dy = dz = dw = 0;
+			break;
+		}
+		break;
+	}
+	if (!evdevMse->sync) {
+	    pMse->PostEvent(pInfo,evdevMse->buttons,dx, dy, dz, dw);
+	    dx = dy = dz = dw = 0;
+	}
+    } while (xf86WaitForInput(pInfo->fd, 0));
+
+    pMse->PostEvent(pInfo, evdevMse->buttons, dx, dy, dz, dw);
+
+    return;
+}
+
+static void
+evdevMouseSigioReadInput (int fd, void *closure)
+{
+    evdevMouseReadInput ((InputInfoPtr) closure);
+}
+
+static int
+evdevMouseProc(DeviceIntPtr pPointer, int what)
+{
+    InputInfoPtr pInfo;
+    MouseDevPtr pMse;
+    evdevMsePtr evdevMse;
+    unsigned char map[MSE_MAXBUTTONS + 1];
+    int i, j, blocked;
+    unsigned long evtype_bits[NBITS(EV_MAX)];
+    unsigned long evkey_bits[NBITS(EV_KEY_MAX)];
+
+    pInfo = pPointer->public.devicePrivate;
+    pMse = pInfo->private;
+    pMse->device = pPointer;
+    evdevMse = pMse->mousePriv;
+
+    switch (what) {
+    case DEVICE_INIT: 
+	pPointer->public.on = FALSE;
+
+	evdevMse->evdev.name = xf86SetStrOption(pInfo->options,"Dev Name",NULL);
+	evdevMse->evdev.phys = xf86SetStrOption(pInfo->options,"Dev Phys",NULL);
+	evdevMse->evdev.cb_data = pInfo->dev;
+	evdevMse->evdev.callback = evdevMouseProc;
+	if (!evdevNewDriver (&evdevMse->evdev)) {
+	    xf86Msg(X_ERROR, "%s: cannot register with evdev brain\n", pInfo->name);
+	    return BadRequest;
+	}
+	if ((pInfo->fd = evdevGetFDForDriver (&evdevMse->evdev)) == -1) {
+	    xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
+	    return BadRequest;
+	}
+
+	ioctl(pInfo->fd, EVIOCGBIT(0, EV_MAX), evtype_bits);
+	if (test_bit(EV_SYN, evtype_bits))
+	    evdevMse->sync = TRUE;
+	else 
+	    evdevMse->sync = FALSE;
+
+	if (test_bit(EV_KEY, evtype_bits)) {
+	    ioctl(pInfo->fd, EVIOCGBIT(EV_KEY, EV_KEY_MAX), evkey_bits);
+	    i = EV_BTN_LEFT;
+	    for (i = EV_BTN_LEFT, j = 0; i <= EV_BTN_BACK; i++)
+		if (test_bit(i, evkey_bits))
+		    j = i - EV_BTN_LEFT;
+	    if (++j > pMse->buttons) pMse->buttons = j;
+	}
+
+	close(pInfo->fd);
+	pInfo->fd = -1;
+
+	for (i = 0; i < MSE_MAXBUTTONS; ++i)
+	    map[i + 1] = i + 1;
+
+	InitPointerDeviceStruct((DevicePtr)pPointer, map, 
+				min(pMse->buttons, MSE_MAXBUTTONS),
+				miPointerGetMotionEvents, pMse->Ctrl,
+				miPointerGetMotionBufferSize());
+
+	/* X valuator */
+	xf86InitValuatorAxisStruct(pPointer, 0, 0, -1, 1, 0, 1);
+	xf86InitValuatorDefaults(pPointer, 0);
+	/* Y valuator */
+	xf86InitValuatorAxisStruct(pPointer, 1, 0, -1, 1, 0, 1);
+	xf86InitValuatorDefaults(pPointer, 1);
+	xf86MotionHistoryAllocate(pInfo);
+	break;
+
+    case DEVICE_ON:
+	if (pPointer->public.on)
+	    break;
+	if ((pInfo->fd = evdevGetFDForDriver (&evdevMse->evdev)) == -1) {
+	    xf86Msg(X_ERROR, "%s: cannot open input device (name: '%s', phys: '%s')\n", pInfo->name, evdevMse->evdev.name, evdevMse->evdev.phys);
+	    return BadRequest;
+	}
+
+	xf86FlushInput(pInfo->fd);
+	if (!xf86InstallSIGIOHandler (pInfo->fd, evdevMouseSigioReadInput, pInfo))
+	    AddEnabledDevice(pInfo->fd);
+	pMse->lastButtons = 0;
+	pMse->emulateState = 0;
+	evdevMse->buttons = 0;
+	pPointer->public.on = TRUE;
+	/*
+	 * send button up events for sanity. If no button down is pending
+	 * xf86PostButtonEvent() will discard them. So we are on the safe side.
+	 */
+	blocked = xf86BlockSIGIO ();
+	for (i = 1; i <= 5; i++)
+	    xf86PostButtonEvent(pPointer,0,i,0,0,0);
+	xf86UnblockSIGIO (blocked);
+	break;
+
+    case DEVICE_OFF:
+    case DEVICE_CLOSE:
+	if (pInfo->fd != -1) {
+	    RemoveEnabledDevice(pInfo->fd);
+	    xf86RemoveSIGIOHandler(pInfo->fd);
+	    close (pInfo->fd);
+	    pInfo->fd = -1;
+	}
+	pPointer->public.on = FALSE;
+	usleep(300000);
+	break;
+    }
+    return Success;
+}
+
+
+/* This function is called when the protocol is "evdev". */
+static Bool
+evdevMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags)
+{
+    MouseDevPtr pMse = pInfo->private;
+    evdevMsePtr evdevMse;
+
+    pMse->protocol = protocol;
+    xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);
+
+    /* Collect the options, and process the common options. */
+    xf86CollectInputOptions(pInfo, NULL, NULL);
+    xf86ProcessCommonOptions(pInfo, pInfo->options);
+
+    if (sizeof(struct input_event) <= sizeof(pMse->protoBuf))
+	pMse->buffer = pMse->protoBuf;
+    else
+	pMse->buffer = xcalloc(sizeof(struct input_event),1);
+    pMse->mousePriv = evdevMse = xcalloc(sizeof(evdevMseRec), 1);
+    if ((pMse->buffer == NULL) || (pMse->mousePriv == NULL)) {
+	xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
+	xfree(pMse);
+	return FALSE;
+    }
+
+    if (!evdevStart (pInfo->drv)) {
+	xf86Msg(X_ERROR, "%s: cannot start evdev brain\n", pInfo->name);
+	return FALSE;
+    }
+
+    pMse->CommonOptions(pInfo);
+
+    /* Setup the local procs. */
+    pInfo->device_control = evdevMouseProc;
+    pInfo->read_input = evdevMouseReadInput;
+
+    pInfo->flags |= XI86_CONFIGURED;
+
+    return TRUE;
+}
+
 OSMouseInfoPtr
 xf86OSMouseInit(int flags)
 {
@@ -197,6 +472,8 @@
     p->DefaultProtocol = DefaultProtocol;
     p->FindDevice = FindDevice;
     p->GuessProtocol = GuessProtocol;
+    p->CheckProtocol = CheckProtocol;
+    p->BuiltinNames = BuiltinNames;
+    p->PreInit = evdevMousePreInit;
     return p;
 }
-
1	niro	167	diff -Nurd xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c xc-patched/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c
2			--- xc/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c 2003-10-10 07:06:39.000000000 -0400
3			+++ xc-patched/programs/Xserver/hw/xfree86/os-support/linux/lnx_mouse.c 2003-12-01 12:54:34.757487668 -0500
4			@@ -6,12 +6,21 @@
5
6			#include "X.h"
7			#include "xf86.h"
8			+#include "xf86Priv.h"
9			#include "xf86Xinput.h"
10			#include "xf86OSmouse.h"
11			#include "xf86_OSlib.h"
12			#include <sys/types.h>
13			#include <sys/stat.h>
14			#include <unistd.h>
15			+#include "mipointer.h"
16			+#include "lnx_evdev.h"
17			+
18			+/* Names of protocols that are handled internally here. */
19			+static const char *internalNames[] = {
20			+ "evdev",
21			+ NULL
22			+};
23
24			static int
25			SupportedInterfaces(void)
26			@@ -185,6 +194,272 @@
27			return NULL;
28			}
29
30			+static const char **
31			+BuiltinNames(void)
32			+{
33			+ return internalNames;
34			+}
35			+
36			+static Bool
37			+CheckProtocol(const char *protocol)
38			+{
39			+ int i;
40			+
41			+ for (i = 0; internalNames[i]; i++)
42			+ if (xf86NameCmp(protocol, internalNames[i]) == 0)
43			+ return TRUE;
44			+ return FALSE;
45			+}
46			+
47			+typedef struct _evdevMseRec {
48			+ int packetSize;
49			+ int buttons;
50			+ Bool sync;
51			+ evdevDriver evdev;
52			+} evdevMseRec, *evdevMsePtr;
53			+
54			+static void
55			+evdevMouseReadInput(InputInfoPtr pInfo)
56			+{
57			+ MouseDevPtr pMse;
58			+ evdevMsePtr evdevMse;
59			+ struct input_event *ev;
60			+ int n, bit;
61			+ int dx = 0, dy = 0, dz = 0, dw = 0;
62			+
63			+ pMse = pInfo->private;
64			+ ev = (struct input_event *) pMse->buffer;
65			+ evdevMse = pMse->mousePriv;
66			+
67			+ if (pInfo->fd == -1)
68			+ return;
69			+
70			+ do {
71			+ n = read(pInfo->fd, pMse->buffer, sizeof(struct input_event));
72			+ if (n == -1) {
73			+ xf86Msg(X_ERROR, "%s: Error in reading! (%s) Disabiling.\n",
74			+ pInfo->name, strerror(errno));
75			+ RemoveEnabledDevice(pInfo->fd);
76			+ xf86RemoveSIGIOHandler(pInfo->fd);
77			+ close (pInfo->fd);
78			+ pMse->device->public.on = FALSE;
79			+ pInfo->fd = -1;
80			+ pMse->PostEvent(pInfo, evdevMse->buttons, dx, dy, dz, dw);
81			+ return;
82			+ }
83			+ if (n != sizeof(struct input_event)) {
84			+ xf86Msg(X_WARNING, "%s: incomplete packet, size %d\n", pInfo->name, n);
85			+ pMse->PostEvent(pInfo, evdevMse->buttons, dx, dy, dz, dw);
86			+ return;
87			+ }
88			+
89			+ switch (ev->type) {
90			+ case EV_REL:
91			+ switch (ev->code) {
92			+ case EV_REL_X:
93			+ dx += ev->value;
94			+ break;
95			+ case EV_REL_Y:
96			+ dy += ev->value;
97			+ break;
98			+ case EV_REL_Z:
99			+ case EV_REL_WHEEL:
100			+ dz -= ev->value;
101			+ break;
102			+ case EV_REL_HWHEEL:
103			+ dw -= ev->value;
104			+ break;
105			+ }
106			+ break;
107			+ case EV_KEY:
108			+ if ((ev->code < EV_BTN_MOUSE) \|\| (ev->code >= EV_BTN_JOYSTICK))
109			+ break;
110			+ switch (ev->code) {
111			+ case EV_BTN_RIGHT: bit = 1 << 0; break; /* 1 */
112			+ case EV_BTN_MIDDLE: bit = 1 << 1; break; /* 2 */
113			+ case EV_BTN_LEFT: bit = 1 << 2; break; /* 3 */
114			+ default: bit = 1 << (ev->code - EV_BTN_MOUSE); break;
115			+ }
116			+ evdevMse->buttons &= ~bit;
117			+ if (ev->value)
118			+ evdevMse->buttons \|= bit;
119			+ break;
120			+ case EV_SYN:
121			+ switch (ev->code) {
122			+ case EV_SYN_REPORT:
123			+ pMse->PostEvent(pInfo,evdevMse->buttons,dx, dy, dz, dw);
124			+ dx = dy = dz = dw = 0;
125			+ break;
126			+ }
127			+ break;
128			+ }
129			+ if (!evdevMse->sync) {
130			+ pMse->PostEvent(pInfo,evdevMse->buttons,dx, dy, dz, dw);
131			+ dx = dy = dz = dw = 0;
132			+ }
133			+ } while (xf86WaitForInput(pInfo->fd, 0));
134			+
135			+ pMse->PostEvent(pInfo, evdevMse->buttons, dx, dy, dz, dw);
136			+
137			+ return;
138			+}
139			+
140			+static void
141			+evdevMouseSigioReadInput (int fd, void *closure)
142			+{
143			+ evdevMouseReadInput ((InputInfoPtr) closure);
144			+}
145			+
146			+static int
147			+evdevMouseProc(DeviceIntPtr pPointer, int what)
148			+{
149			+ InputInfoPtr pInfo;
150			+ MouseDevPtr pMse;
151			+ evdevMsePtr evdevMse;
152			+ unsigned char map[MSE_MAXBUTTONS + 1];
153			+ int i, j, blocked;
154			+ unsigned long evtype_bits[NBITS(EV_MAX)];
155			+ unsigned long evkey_bits[NBITS(EV_KEY_MAX)];
156			+
157			+ pInfo = pPointer->public.devicePrivate;
158			+ pMse = pInfo->private;
159			+ pMse->device = pPointer;
160			+ evdevMse = pMse->mousePriv;
161			+
162			+ switch (what) {
163			+ case DEVICE_INIT:
164			+ pPointer->public.on = FALSE;
165			+
166			+ evdevMse->evdev.name = xf86SetStrOption(pInfo->options,"Dev Name",NULL);
167			+ evdevMse->evdev.phys = xf86SetStrOption(pInfo->options,"Dev Phys",NULL);
168			+ evdevMse->evdev.cb_data = pInfo->dev;
169			+ evdevMse->evdev.callback = evdevMouseProc;
170			+ if (!evdevNewDriver (&evdevMse->evdev)) {
171			+ xf86Msg(X_ERROR, "%s: cannot register with evdev brain\n", pInfo->name);
172			+ return BadRequest;
173			+ }
174			+ if ((pInfo->fd = evdevGetFDForDriver (&evdevMse->evdev)) == -1) {
175			+ xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
176			+ return BadRequest;
177			+ }
178			+
179			+ ioctl(pInfo->fd, EVIOCGBIT(0, EV_MAX), evtype_bits);
180			+ if (test_bit(EV_SYN, evtype_bits))
181			+ evdevMse->sync = TRUE;
182			+ else
183			+ evdevMse->sync = FALSE;
184			+
185			+ if (test_bit(EV_KEY, evtype_bits)) {
186			+ ioctl(pInfo->fd, EVIOCGBIT(EV_KEY, EV_KEY_MAX), evkey_bits);
187			+ i = EV_BTN_LEFT;
188			+ for (i = EV_BTN_LEFT, j = 0; i <= EV_BTN_BACK; i++)
189			+ if (test_bit(i, evkey_bits))
190			+ j = i - EV_BTN_LEFT;
191			+ if (++j > pMse->buttons) pMse->buttons = j;
192			+ }
193			+
194			+ close(pInfo->fd);
195			+ pInfo->fd = -1;
196			+
197			+ for (i = 0; i < MSE_MAXBUTTONS; ++i)
198			+ map[i + 1] = i + 1;
199			+
200			+ InitPointerDeviceStruct((DevicePtr)pPointer, map,
201			+ min(pMse->buttons, MSE_MAXBUTTONS),
202			+ miPointerGetMotionEvents, pMse->Ctrl,
203			+ miPointerGetMotionBufferSize());
204			+
205			+ /* X valuator */
206			+ xf86InitValuatorAxisStruct(pPointer, 0, 0, -1, 1, 0, 1);
207			+ xf86InitValuatorDefaults(pPointer, 0);
208			+ /* Y valuator */
209			+ xf86InitValuatorAxisStruct(pPointer, 1, 0, -1, 1, 0, 1);
210			+ xf86InitValuatorDefaults(pPointer, 1);
211			+ xf86MotionHistoryAllocate(pInfo);
212			+ break;
213			+
214			+ case DEVICE_ON:
215			+ if (pPointer->public.on)
216			+ break;
217			+ if ((pInfo->fd = evdevGetFDForDriver (&evdevMse->evdev)) == -1) {
218			+ xf86Msg(X_ERROR, "%s: cannot open input device (name: '%s', phys: '%s')\n", pInfo->name, evdevMse->evdev.name, evdevMse->evdev.phys);
219			+ return BadRequest;
220			+ }
221			+
222			+ xf86FlushInput(pInfo->fd);
223			+ if (!xf86InstallSIGIOHandler (pInfo->fd, evdevMouseSigioReadInput, pInfo))
224			+ AddEnabledDevice(pInfo->fd);
225			+ pMse->lastButtons = 0;
226			+ pMse->emulateState = 0;
227			+ evdevMse->buttons = 0;
228			+ pPointer->public.on = TRUE;
229			+ /*
230			+ * send button up events for sanity. If no button down is pending
231			+ * xf86PostButtonEvent() will discard them. So we are on the safe side.
232			+ */
233			+ blocked = xf86BlockSIGIO ();
234			+ for (i = 1; i <= 5; i++)
235			+ xf86PostButtonEvent(pPointer,0,i,0,0,0);
236			+ xf86UnblockSIGIO (blocked);
237			+ break;
238			+
239			+ case DEVICE_OFF:
240			+ case DEVICE_CLOSE:
241			+ if (pInfo->fd != -1) {
242			+ RemoveEnabledDevice(pInfo->fd);
243			+ xf86RemoveSIGIOHandler(pInfo->fd);
244			+ close (pInfo->fd);
245			+ pInfo->fd = -1;
246			+ }
247			+ pPointer->public.on = FALSE;
248			+ usleep(300000);
249			+ break;
250			+ }
251			+ return Success;
252			+}
253			+
254			+
255			+/* This function is called when the protocol is "evdev". */
256			+static Bool
257			+evdevMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags)
258			+{
259			+ MouseDevPtr pMse = pInfo->private;
260			+ evdevMsePtr evdevMse;
261			+
262			+ pMse->protocol = protocol;
263			+ xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);
264			+
265			+ /* Collect the options, and process the common options. */
266			+ xf86CollectInputOptions(pInfo, NULL, NULL);
267			+ xf86ProcessCommonOptions(pInfo, pInfo->options);
268			+
269			+ if (sizeof(struct input_event) <= sizeof(pMse->protoBuf))
270			+ pMse->buffer = pMse->protoBuf;
271			+ else
272			+ pMse->buffer = xcalloc(sizeof(struct input_event),1);
273			+ pMse->mousePriv = evdevMse = xcalloc(sizeof(evdevMseRec), 1);
274			+ if ((pMse->buffer == NULL) \|\| (pMse->mousePriv == NULL)) {
275			+ xf86Msg(X_ERROR, "%s: cannot allocate buffer\n", pInfo->name);
276			+ xfree(pMse);
277			+ return FALSE;
278			+ }
279			+
280			+ if (!evdevStart (pInfo->drv)) {
281			+ xf86Msg(X_ERROR, "%s: cannot start evdev brain\n", pInfo->name);
282			+ return FALSE;
283			+ }
284			+
285			+ pMse->CommonOptions(pInfo);
286			+
287			+ /* Setup the local procs. */
288			+ pInfo->device_control = evdevMouseProc;
289			+ pInfo->read_input = evdevMouseReadInput;
290			+
291			+ pInfo->flags \|= XI86_CONFIGURED;
292			+
293			+ return TRUE;
294			+}
295			+
296			OSMouseInfoPtr
297			xf86OSMouseInit(int flags)
298			{
299			@@ -197,6 +472,8 @@
300			p->DefaultProtocol = DefaultProtocol;
301			p->FindDevice = FindDevice;
302			p->GuessProtocol = GuessProtocol;
303			+ p->CheckProtocol = CheckProtocol;
304			+ p->BuiltinNames = BuiltinNames;
305			+ p->PreInit = evdevMousePreInit;
306			return p;
307			}
308			-