VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/xmouse/xorg14/mouse.c@ 8878

Last change on this file since 8878 was 8155, checked in by vboxsync, 17 years ago

The Big Sun Rebranding Header Change
  • Property svn:eol-style set to native
File size: 110.3 KB
Line 
1/** @file
2 *
3 */
4
5/*
6 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
17 * Clara, CA 95054 USA or visit http://www.sun.com if you need
18 * additional information or have any questions.
19 * --------------------------------------------------------------------
20 *
21 * This code is based on:
22 *
23 * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
24 * Copyright 1993 by David Dawes <[email protected]>
25 * Copyright 2002 by SuSE Linux AG, Author: Egbert Eich
26 * Copyright 1994-2002 by The XFree86 Project, Inc.
27 * Copyright 2002 by Paul Elliott
28 *
29 * Permission to use, copy, modify, distribute, and sell this software and its
30 * documentation for any purpose is hereby granted without fee, provided that
31 * the above copyright notice appear in all copies and that both that
32 * copyright notice and this permission notice appear in supporting
33 * documentation, and that the names of copyright holders not be
34 * used in advertising or publicity pertaining to distribution of the
35 * software without specific, written prior permission. The copyright holders
36 * make no representations about the suitability of this
37 * software for any purpose. It is provided "as is" without express or
38 * implied warranty.
39 *
40 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
41 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
42 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
43 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
44 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
45 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
46 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
47 *
48 */
49/* Patch for PS/2 Intellimouse - Tim Goodwin 1997-11-06. */
50
51/*
52 * [JCH-96/01/21] Added fourth button support for PROT_GLIDEPOINT mouse
53 * protocol.
54 */
55
56/*
57 * [TVO-97/03/05] Added microsoft IntelliMouse support
58 */
59
60/*
61 * [PME-02/08/11] Added suport for drag lock buttons
62 * for use with 4 button trackballs for convenience
63 * and to help limited dexterity persons
64 */
65
66#ifdef VBOX
67/* this is necessary to prevent redirecting sscanf to isoc99_sscanf which is
68 * glibc 2.7++ only */
69#define _GNU_SOURCE
70#endif
71
72#ifdef XFree86LOADER
73# include "xorg-server.h"
74#else
75# ifdef HAVE_CONFIG_H
76# include "config.h"
77# endif
78#endif
79
80#include <math.h>
81#include <string.h>
82#include <stdio.h>
83#define NEED_EVENTS
84#include <X11/X.h>
85#include <X11/Xproto.h>
86
87#include "xf86.h"
88
89#ifdef XINPUT
90#include <X11/extensions/XI.h>
91#include <X11/extensions/XIproto.h>
92#include "extnsionst.h"
93#include "extinit.h"
94#else
95#include "inputstr.h"
96#endif
97
98#include "xf86Xinput.h"
99#include "xf86_OSproc.h"
100#include "xf86OSmouse.h"
101#ifndef NEED_XF86_TYPES
102#define NEED_XF86_TYPES /* for xisb.h when !XFree86LOADER */
103#endif
104#include "compiler.h"
105
106#include "xisb.h"
107#include "mouse.h"
108#include "mousePriv.h"
109#include "input.h"
110
111#ifdef VBOX
112#include "VBoxUtils.h"
113#include "version-generated.h"
114/* Xorg 7.1 does not include xf86_ansic.h anymore. Don't reinclude this
115 * file as it renamed ANSI C functions to xf86*. */
116extern int abs(int);
117extern long strtol(const char*,char**,int);
118#endif
119
120enum {
121 /* number of bits in mapped nibble */
122 NIB_BITS=4,
123 /* size of map of nibbles to bitmask */
124 NIB_SIZE= (1 << NIB_BITS),
125 /* mask for map */
126 NIB_MASK= (NIB_SIZE -1),
127 /* number of maps to map all the buttons */
128 NIB_COUNT = ((MSE_MAXBUTTONS+NIB_BITS-1)/NIB_BITS)
129};
130
131/*data to be used in implementing trackball drag locks.*/
132typedef struct _DragLockRec {
133
134 /* Fields used to implement trackball drag locks. */
135 /* mask for those buttons that are ordinary drag lock buttons */
136 int lockButtonsM;
137
138 /* mask for the master drag lock button if any */
139 int masterLockM;
140
141 /* button state up/down from last time adjusted for drag locks */
142 int lockLastButtons;
143
144 /*
145 * true if master lock state i.e. master drag lock
146 * button has just been pressed
147 */
148 int masterTS;
149
150 /* simulate these buttons being down although they are not */
151 int simulatedDown;
152
153 /*
154 * data to map bits for drag lock buttons to corresponding
155 * bits for the target buttons
156 */
157 int nib_table[NIB_COUNT][NIB_SIZE];
158
159} DragLockRec, *DragLockPtr;
160
161
162
163#ifdef XFree86LOADER
164static const OptionInfoRec *MouseAvailableOptions(void *unused);
165#endif
166static InputInfoPtr MousePreInit(InputDriverPtr drv, IDevPtr dev, int flags);
167#if 0
168static void MouseUnInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags);
169#endif
170
171static int MouseProc(DeviceIntPtr device, int what);
172static Bool MouseConvert(LocalDevicePtr local, int first, int num, int v0,
173 int v1, int v2, int v3, int v4, int v5, int *x,
174 int *y);
175
176static void MouseCtrl(DeviceIntPtr device, PtrCtrl *ctrl);
177static void MousePostEvent(InputInfoPtr pInfo, int buttons,
178 int dx, int dy, int dz, int dw);
179static void MouseReadInput(InputInfoPtr pInfo);
180static void MouseBlockHandler(pointer data, struct timeval **waitTime,
181 pointer LastSelectMask);
182static void MouseWakeupHandler(pointer data, int i, pointer LastSelectMask);
183static void FlushButtons(MouseDevPtr pMse);
184
185static Bool SetupMouse(InputInfoPtr pInfo);
186static Bool initMouseHW(InputInfoPtr pInfo);
187#ifdef SUPPORT_MOUSE_RESET
188static Bool mouseReset(InputInfoPtr pInfo, unsigned char val);
189static void ps2WakeupHandler(pointer data, int i, pointer LastSelectMask);
190static void ps2BlockHandler(pointer data, struct timeval **waitTime,
191 pointer LastSelectMask);
192#endif
193
194/* mouse autoprobe stuff */
195static const char *autoOSProtocol(InputInfoPtr pInfo, int *protoPara);
196static void autoProbeMouse(InputInfoPtr pInfo, Bool inSync, Bool lostSync);
197static void checkForErraticMovements(InputInfoPtr pInfo, int dx, int dy);
198static Bool collectData(MouseDevPtr pMse, unsigned char u);
199static void SetMouseProto(MouseDevPtr pMse, MouseProtocolID protocolID);
200static Bool autoGood(MouseDevPtr pMse);
201
202#undef MOUSE
203_X_EXPORT InputDriverRec MOUSE = {
204 1,
205#ifdef VBOX
206 "vboxmouse",
207#else
208 "mouse",
209#endif
210 NULL,
211 MousePreInit,
212 /*MouseUnInit,*/NULL,
213 NULL,
214 0
215};
216
217typedef enum {
218 OPTION_ALWAYS_CORE,
219 OPTION_SEND_CORE_EVENTS,
220 OPTION_CORE_POINTER,
221 OPTION_SEND_DRAG_EVENTS,
222 OPTION_HISTORY_SIZE,
223 OPTION_DEVICE,
224 OPTION_PROTOCOL,
225 OPTION_BUTTONS,
226 OPTION_EMULATE_3_BUTTONS,
227 OPTION_EMULATE_3_TIMEOUT,
228 OPTION_CHORD_MIDDLE,
229 OPTION_FLIP_XY,
230 OPTION_INV_X,
231 OPTION_INV_Y,
232 OPTION_ANGLE_OFFSET,
233 OPTION_Z_AXIS_MAPPING,
234 OPTION_SAMPLE_RATE,
235 OPTION_RESOLUTION,
236 OPTION_EMULATE_WHEEL,
237 OPTION_EMU_WHEEL_BUTTON,
238 OPTION_EMU_WHEEL_INERTIA,
239 OPTION_EMU_WHEEL_TIMEOUT,
240 OPTION_X_AXIS_MAPPING,
241 OPTION_Y_AXIS_MAPPING,
242 OPTION_AUTO_SOFT,
243 OPTION_CLEAR_DTR,
244 OPTION_CLEAR_RTS,
245 OPTION_BAUD_RATE,
246 OPTION_DATA_BITS,
247 OPTION_STOP_BITS,
248 OPTION_PARITY,
249 OPTION_FLOW_CONTROL,
250 OPTION_VTIME,
251 OPTION_VMIN,
252 OPTION_DRAGLOCKBUTTONS,
253 OPTION_DOUBLECLICK_BUTTONS,
254 OPTION_BUTTON_MAPPING
255} MouseOpts;
256
257#ifdef XFree86LOADER
258static const OptionInfoRec mouseOptions[] = {
259 { OPTION_ALWAYS_CORE, "AlwaysCore", OPTV_BOOLEAN, {0}, FALSE },
260 { OPTION_SEND_CORE_EVENTS, "SendCoreEvents", OPTV_BOOLEAN, {0}, FALSE },
261 { OPTION_CORE_POINTER, "CorePointer", OPTV_BOOLEAN, {0}, FALSE },
262 { OPTION_SEND_DRAG_EVENTS, "SendDragEvents", OPTV_BOOLEAN, {0}, FALSE },
263 { OPTION_HISTORY_SIZE, "HistorySize", OPTV_INTEGER, {0}, FALSE },
264 { OPTION_DEVICE, "Device", OPTV_STRING, {0}, FALSE },
265 { OPTION_PROTOCOL, "Protocol", OPTV_STRING, {0}, FALSE },
266 { OPTION_BUTTONS, "Buttons", OPTV_INTEGER, {0}, FALSE },
267 { OPTION_EMULATE_3_BUTTONS, "Emulate3Buttons",OPTV_BOOLEAN, {0}, FALSE },
268 { OPTION_EMULATE_3_TIMEOUT, "Emulate3Timeout",OPTV_INTEGER, {0}, FALSE },
269 { OPTION_CHORD_MIDDLE, "ChordMiddle", OPTV_BOOLEAN, {0}, FALSE },
270 { OPTION_FLIP_XY, "FlipXY", OPTV_BOOLEAN, {0}, FALSE },
271 { OPTION_INV_X, "InvX", OPTV_BOOLEAN, {0}, FALSE },
272 { OPTION_INV_Y, "InvY", OPTV_BOOLEAN, {0}, FALSE },
273 { OPTION_ANGLE_OFFSET, "AngleOffset", OPTV_INTEGER, {0}, FALSE },
274 { OPTION_Z_AXIS_MAPPING, "ZAxisMapping", OPTV_STRING, {0}, FALSE },
275 { OPTION_SAMPLE_RATE, "SampleRate", OPTV_INTEGER, {0}, FALSE },
276 { OPTION_RESOLUTION, "Resolution", OPTV_INTEGER, {0}, FALSE },
277 { OPTION_EMULATE_WHEEL, "EmulateWheel", OPTV_BOOLEAN, {0}, FALSE },
278 { OPTION_EMU_WHEEL_BUTTON, "EmulateWheelButton", OPTV_INTEGER, {0}, FALSE },
279 { OPTION_EMU_WHEEL_INERTIA, "EmulateWheelInertia", OPTV_INTEGER, {0}, FALSE },
280 { OPTION_EMU_WHEEL_TIMEOUT, "EmulateWheelTimeout", OPTV_INTEGER, {0}, FALSE },
281 { OPTION_X_AXIS_MAPPING, "XAxisMapping", OPTV_STRING, {0}, FALSE },
282 { OPTION_Y_AXIS_MAPPING, "YAxisMapping", OPTV_STRING, {0}, FALSE },
283 { OPTION_AUTO_SOFT, "AutoSoft", OPTV_BOOLEAN, {0}, FALSE },
284 /* serial options */
285 { OPTION_CLEAR_DTR, "ClearDTR", OPTV_BOOLEAN, {0}, FALSE },
286 { OPTION_CLEAR_RTS, "ClearRTS", OPTV_BOOLEAN, {0}, FALSE },
287 { OPTION_BAUD_RATE, "BaudRate", OPTV_INTEGER, {0}, FALSE },
288 { OPTION_DATA_BITS, "DataBits", OPTV_INTEGER, {0}, FALSE },
289 { OPTION_STOP_BITS, "StopBits", OPTV_INTEGER, {0}, FALSE },
290 { OPTION_PARITY, "Parity", OPTV_STRING, {0}, FALSE },
291 { OPTION_FLOW_CONTROL, "FlowControl", OPTV_STRING, {0}, FALSE },
292 { OPTION_VTIME, "VTime", OPTV_INTEGER, {0}, FALSE },
293 { OPTION_VMIN, "VMin", OPTV_INTEGER, {0}, FALSE },
294 /* end serial options */
295 { OPTION_DRAGLOCKBUTTONS, "DragLockButtons",OPTV_STRING, {0}, FALSE },
296 { OPTION_DOUBLECLICK_BUTTONS,"DoubleClickButtons", OPTV_STRING, {0}, FALSE },
297 { OPTION_BUTTON_MAPPING, "ButtonMapping", OPTV_STRING, {0}, FALSE },
298 { -1, NULL, OPTV_NONE, {0}, FALSE }
299};
300#endif
301
302#define RETRY_COUNT 4
303
304/*
305 * Microsoft (all serial models), Logitech MouseMan, First Mouse, etc,
306 * ALPS GlidePoint, Thinking Mouse.
307 */
308static const char *msDefaults[] = {
309 "BaudRate", "1200",
310 "DataBits", "7",
311 "StopBits", "1",
312 "Parity", "None",
313 "FlowControl", "None",
314 "VTime", "0",
315 "VMin", "1",
316 NULL
317};
318/* MouseSystems */
319static const char *mlDefaults[] = {
320 "BaudRate", "1200",
321 "DataBits", "8",
322 "StopBits", "2",
323 "Parity", "None",
324 "FlowControl", "None",
325 "VTime", "0",
326 "VMin", "1",
327 NULL
328};
329/* MMSeries */
330static const char *mmDefaults[] = {
331 "BaudRate", "1200",
332 "DataBits", "8",
333 "StopBits", "1",
334 "Parity", "Odd",
335 "FlowControl", "None",
336 "VTime", "0",
337 "VMin", "1",
338 NULL
339};
340#if 0
341/* Logitech series 9 *//* same as msc: now mlDefaults */
342static const char *logiDefaults[] = {
343 "BaudRate", "1200",
344 "DataBits", "8",
345 "StopBits", "2",
346 "Parity", "None",
347 "FlowControl", "None",
348 "VTime", "0",
349 "VMin", "1",
350 NULL
351};
352#endif
353/* Hitachi Tablet */
354static const char *mmhitDefaults[] = {
355 "BaudRate", "1200",
356 "DataBits", "8",
357 "StopBits", "1",
358 "Parity", "None",
359 "FlowControl", "None",
360 "VTime", "0",
361 "VMin", "1",
362 NULL
363};
364/* AceCad Tablet */
365static const char *acecadDefaults[] = {
366 "BaudRate", "9600",
367 "DataBits", "8",
368 "StopBits", "1",
369 "Parity", "Odd",
370 "FlowControl", "None",
371 "VTime", "0",
372 "VMin", "1",
373 NULL
374};
375
376static MouseProtocolRec mouseProtocols[] = {
377
378 /* Serial protocols */
379 { "Microsoft", MSE_SERIAL, msDefaults, PROT_MS },
380 { "MouseSystems", MSE_SERIAL, mlDefaults, PROT_MSC },
381 { "MMSeries", MSE_SERIAL, mmDefaults, PROT_MM },
382 { "Logitech", MSE_SERIAL, mlDefaults, PROT_LOGI },
383 { "MouseMan", MSE_SERIAL, msDefaults, PROT_LOGIMAN },
384 { "MMHitTab", MSE_SERIAL, mmhitDefaults, PROT_MMHIT },
385 { "GlidePoint", MSE_SERIAL, msDefaults, PROT_GLIDE },
386 { "IntelliMouse", MSE_SERIAL, msDefaults, PROT_IMSERIAL },
387 { "ThinkingMouse", MSE_SERIAL, msDefaults, PROT_THINKING },
388 { "AceCad", MSE_SERIAL, acecadDefaults, PROT_ACECAD },
389 { "ValuMouseScroll", MSE_SERIAL, msDefaults, PROT_VALUMOUSESCROLL },
390
391 /* Standard PS/2 */
392 { "PS/2", MSE_PS2, NULL, PROT_PS2 },
393 { "GenericPS/2", MSE_PS2, NULL, PROT_GENPS2 },
394
395 /* Extended PS/2 */
396 { "ImPS/2", MSE_XPS2, NULL, PROT_IMPS2 },
397 { "ExplorerPS/2", MSE_XPS2, NULL, PROT_EXPPS2 },
398 { "ThinkingMousePS/2", MSE_XPS2, NULL, PROT_THINKPS2 },
399 { "MouseManPlusPS/2", MSE_XPS2, NULL, PROT_MMPS2 },
400 { "GlidePointPS/2", MSE_XPS2, NULL, PROT_GLIDEPS2 },
401 { "NetMousePS/2", MSE_XPS2, NULL, PROT_NETPS2 },
402 { "NetScrollPS/2", MSE_XPS2, NULL, PROT_NETSCPS2 },
403
404 /* Bus Mouse */
405 { "BusMouse", MSE_BUS, NULL, PROT_BM },
406
407 /* Auto-detect (PnP) */
408 { "Auto", MSE_AUTO, NULL, PROT_AUTO },
409
410 /* Misc (usually OS-specific) */
411 { "SysMouse", MSE_MISC, mlDefaults, PROT_SYSMOUSE },
412
413 /* end of list */
414 { NULL, MSE_NONE, NULL, PROT_UNKNOWN }
415};
416
417#ifdef XFree86LOADER
418/*ARGSUSED*/
419static const OptionInfoRec *
420MouseAvailableOptions(void *unused)
421{
422 return (mouseOptions);
423}
424#endif
425
426/* Process options common to all mouse types. */
427static void
428MouseCommonOptions(InputInfoPtr pInfo)
429{
430 MouseDevPtr pMse;
431 MessageType buttons_from = X_CONFIG;
432 char *s;
433 int origButtons;
434 int i;
435
436 pMse = pInfo->private;
437
438 pMse->buttons = xf86SetIntOption(pInfo->options, "Buttons", 0);
439 if (!pMse->buttons) {
440 pMse->buttons = MSE_DFLTBUTTONS;
441 buttons_from = X_DEFAULT;
442 }
443 origButtons = pMse->buttons;
444
445 pMse->emulate3Buttons = xf86SetBoolOption(pInfo->options,
446 "Emulate3Buttons", FALSE);
447 if (!xf86FindOptionValue(pInfo->options,"Emulate3Buttons")) {
448 pMse->emulate3ButtonsSoft = TRUE;
449 pMse->emulate3Buttons = TRUE;
450 }
451
452 pMse->emulate3Timeout = xf86SetIntOption(pInfo->options,
453 "Emulate3Timeout", 50);
454 if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft) {
455 MessageType from = X_CONFIG;
456 if (pMse->emulate3ButtonsSoft)
457 from = X_DEFAULT;
458 xf86Msg(from, "%s: Emulate3Buttons, Emulate3Timeout: %d\n",
459 pInfo->name, pMse->emulate3Timeout);
460 }
461
462 pMse->chordMiddle = xf86SetBoolOption(pInfo->options, "ChordMiddle", FALSE);
463 if (pMse->chordMiddle)
464 xf86Msg(X_CONFIG, "%s: ChordMiddle\n", pInfo->name);
465 pMse->flipXY = xf86SetBoolOption(pInfo->options, "FlipXY", FALSE);
466 if (pMse->flipXY)
467 xf86Msg(X_CONFIG, "%s: FlipXY\n", pInfo->name);
468 if (xf86SetBoolOption(pInfo->options, "InvX", FALSE)) {
469 pMse->invX = -1;
470 xf86Msg(X_CONFIG, "%s: InvX\n", pInfo->name);
471 } else
472 pMse->invX = 1;
473 if (xf86SetBoolOption(pInfo->options, "InvY", FALSE)) {
474 pMse->invY = -1;
475 xf86Msg(X_CONFIG, "%s: InvY\n", pInfo->name);
476 } else
477 pMse->invY = 1;
478 pMse->angleOffset = xf86SetIntOption(pInfo->options, "AngleOffset", 0);
479
480
481 if (pMse->pDragLock)
482 xfree(pMse->pDragLock);
483 pMse->pDragLock = NULL;
484
485 s = xf86SetStrOption(pInfo->options, "DragLockButtons", NULL);
486
487 if (s) {
488 int lock; /* lock button */
489 int target; /* target button */
490 int lockM,targetM; /* bitmasks for drag lock, target */
491 int i, j; /* indexes */
492 char *s1; /* parse input string */
493 DragLockPtr pLock;
494
495 pLock = pMse->pDragLock = xcalloc(1, sizeof(DragLockRec));
496 /* init code */
497
498 /* initial string to be taken apart */
499 s1 = s;
500
501 /* keep getting numbers which are buttons */
502 while ((s1 != NULL) && (lock = strtol(s1, &s1, 10)) != 0) {
503
504 /* check sanity for a button */
505 if ((lock < 0) || (lock > MSE_MAXBUTTONS)) {
506 xf86Msg(X_WARNING, "DragLock: Invalid button number = %d\n",
507 lock);
508 break;
509 };
510 /* turn into a button mask */
511 lockM = 1 << (lock - 1);
512
513 /* try to get drag lock button */
514 if ((s1 == NULL) || ((target=strtol(s1, &s1, 10)) == 0)) {
515 /*if no target, must be a master drag lock button */
516 /* save master drag lock mask */
517 pLock->masterLockM = lockM;
518 xf86Msg(X_CONFIG,
519 "DragLock button %d is master drag lock",
520 lock);
521 } else {
522 /* have target button number*/
523 /* check target button number for sanity */
524 if ((target < 0) || (target > MSE_MAXBUTTONS)) {
525 xf86Msg(X_WARNING,
526 "DragLock: Invalid button number for target=%d\n",
527 target);
528 break;
529 }
530
531 /* target button mask */
532 targetM = 1 << (target - 1);
533
534 xf86Msg(X_CONFIG,
535 "DragLock: button %d is drag lock for button %d\n",
536 lock,target);
537 lock--;
538
539 /* initialize table that maps drag lock mask to target mask */
540 pLock->nib_table[lock / NIB_BITS][1 << (lock % NIB_BITS)] =
541 targetM;
542
543 /* add new drag lock to mask of drag locks */
544 pLock->lockButtonsM |= lockM;
545 }
546
547 }
548
549 /*
550 * fill out rest of map that maps sets of drag lock buttons
551 * to sets of target buttons, in the form of masks
552 */
553
554 /* for each nibble */
555 for (i = 0; i < NIB_COUNT; i++) {
556 /* for each possible set of bits for that nibble */
557 for (j = 0; j < NIB_SIZE; j++) {
558 int ff, fM, otherbits;
559
560 /* get first bit set in j*/
561 ff = ffs(j) - 1;
562 /* if 0 bits set nothing to do */
563 if (ff >= 0) {
564 /* form mask for fist bit set */
565 fM = 1 << ff;
566 /* mask off first bit set to get remaining bits set*/
567 otherbits = j & ~fM;
568 /*
569 * if otherbits =0 then only 1 bit set
570 * so j=fM
571 * nib_table[i][fM] already calculated if fM has
572 * only 1 bit set.
573 * nib_table[i][j] has already been filled in
574 * by previous loop. otherwise
575 * otherbits < j so nibtable[i][otherbits]
576 * has already been calculated.
577 */
578 if (otherbits)
579 pLock->nib_table[i][j] =
580 pLock->nib_table[i][fM] |
581 pLock->nib_table[i][otherbits];
582
583 }
584 }
585 }
586 xfree(s);
587 }
588
589 s = xf86SetStrOption(pInfo->options, "ZAxisMapping", "4 5 6 7");
590 if (s) {
591 int b1 = 0, b2 = 0, b3 = 0, b4 = 0;
592 char *msg = NULL;
593
594 if (!xf86NameCmp(s, "x")) {
595 pMse->negativeZ = pMse->positiveZ = MSE_MAPTOX;
596 pMse->negativeW = pMse->positiveW = MSE_MAPTOX;
597 msg = xstrdup("X axis");
598 } else if (!xf86NameCmp(s, "y")) {
599 pMse->negativeZ = pMse->positiveZ = MSE_MAPTOY;
600 pMse->negativeW = pMse->positiveW = MSE_MAPTOY;
601 msg = xstrdup("Y axis");
602 } else if (sscanf(s, "%d %d %d %d", &b1, &b2, &b3, &b4) >= 2 &&
603 b1 > 0 && b1 <= MSE_MAXBUTTONS &&
604 b2 > 0 && b2 <= MSE_MAXBUTTONS) {
605 msg = xstrdup("buttons XX and YY");
606 if (msg)
607 sprintf(msg, "buttons %d and %d", b1, b2);
608 pMse->negativeZ = pMse->negativeW = 1 << (b1-1);
609 pMse->positiveZ = pMse->positiveW = 1 << (b2-1);
610 if (b3 > 0 && b3 <= MSE_MAXBUTTONS &&
611 b4 > 0 && b4 <= MSE_MAXBUTTONS) {
612 if (msg)
613 xfree(msg);
614 msg = xstrdup("buttons XX, YY, ZZ and WW");
615 if (msg)
616 sprintf(msg, "buttons %d, %d, %d and %d", b1, b2, b3, b4);
617 pMse->negativeW = 1 << (b3-1);
618 pMse->positiveW = 1 << (b4-1);
619 }
620 if (b1 > pMse->buttons) pMse->buttons = b1;
621 if (b2 > pMse->buttons) pMse->buttons = b2;
622 if (b3 > pMse->buttons) pMse->buttons = b3;
623 if (b4 > pMse->buttons) pMse->buttons = b4;
624 } else {
625 pMse->negativeZ = pMse->positiveZ = MSE_NOZMAP;
626 pMse->negativeW = pMse->positiveW = MSE_NOZMAP;
627 }
628 if (msg) {
629 xf86Msg(X_CONFIG, "%s: ZAxisMapping: %s\n", pInfo->name, msg);
630 xfree(msg);
631 } else {
632 xf86Msg(X_WARNING, "%s: Invalid ZAxisMapping value: \"%s\"\n",
633 pInfo->name, s);
634 }
635 xfree(s);
636 }
637 if (xf86SetBoolOption(pInfo->options, "EmulateWheel", FALSE)) {
638 Bool yFromConfig = FALSE;
639 int wheelButton;
640
641 pMse->emulateWheel = TRUE;
642 wheelButton = xf86SetIntOption(pInfo->options,
643 "EmulateWheelButton", 4);
644 if (wheelButton < 0 || wheelButton > MSE_MAXBUTTONS) {
645 xf86Msg(X_WARNING, "%s: Invalid EmulateWheelButton value: %d\n",
646 pInfo->name, wheelButton);
647 wheelButton = 4;
648 }
649 pMse->wheelButton = wheelButton;
650
651 pMse->wheelInertia = xf86SetIntOption(pInfo->options,
652 "EmulateWheelInertia", 10);
653 if (pMse->wheelInertia <= 0) {
654 xf86Msg(X_WARNING, "%s: Invalid EmulateWheelInertia value: %d\n",
655 pInfo->name, pMse->wheelInertia);
656 pMse->wheelInertia = 10;
657 }
658 pMse->wheelButtonTimeout = xf86SetIntOption(pInfo->options,
659 "EmulateWheelTimeout", 200);
660 if (pMse->wheelButtonTimeout <= 0) {
661 xf86Msg(X_WARNING, "%s: Invalid EmulateWheelTimeout value: %d\n",
662 pInfo->name, pMse->wheelButtonTimeout);
663 pMse->wheelButtonTimeout = 200;
664 }
665
666 pMse->negativeX = MSE_NOAXISMAP;
667 pMse->positiveX = MSE_NOAXISMAP;
668 s = xf86SetStrOption(pInfo->options, "XAxisMapping", NULL);
669 if (s) {
670 int b1 = 0, b2 = 0;
671 char *msg = NULL;
672
673 if ((sscanf(s, "%d %d", &b1, &b2) == 2) &&
674 b1 > 0 && b1 <= MSE_MAXBUTTONS &&
675 b2 > 0 && b2 <= MSE_MAXBUTTONS) {
676 msg = xstrdup("buttons XX and YY");
677 if (msg)
678 sprintf(msg, "buttons %d and %d", b1, b2);
679 pMse->negativeX = b1;
680 pMse->positiveX = b2;
681 if (b1 > pMse->buttons) pMse->buttons = b1;
682 if (b2 > pMse->buttons) pMse->buttons = b2;
683 } else {
684 xf86Msg(X_WARNING, "%s: Invalid XAxisMapping value: \"%s\"\n",
685 pInfo->name, s);
686 }
687 if (msg) {
688 xf86Msg(X_CONFIG, "%s: XAxisMapping: %s\n", pInfo->name, msg);
689 xfree(msg);
690 }
691 xfree(s);
692 }
693 s = xf86SetStrOption(pInfo->options, "YAxisMapping", NULL);
694 if (s) {
695 int b1 = 0, b2 = 0;
696 char *msg = NULL;
697
698 if ((sscanf(s, "%d %d", &b1, &b2) == 2) &&
699 b1 > 0 && b1 <= MSE_MAXBUTTONS &&
700 b2 > 0 && b2 <= MSE_MAXBUTTONS) {
701 msg = xstrdup("buttons XX and YY");
702 if (msg)
703 sprintf(msg, "buttons %d and %d", b1, b2);
704 pMse->negativeY = b1;
705 pMse->positiveY = b2;
706 if (b1 > pMse->buttons) pMse->buttons = b1;
707 if (b2 > pMse->buttons) pMse->buttons = b2;
708 yFromConfig = TRUE;
709 } else {
710 xf86Msg(X_WARNING, "%s: Invalid YAxisMapping value: \"%s\"\n",
711 pInfo->name, s);
712 }
713 if (msg) {
714 xf86Msg(X_CONFIG, "%s: YAxisMapping: %s\n", pInfo->name, msg);
715 xfree(msg);
716 }
717 xfree(s);
718 }
719 if (!yFromConfig) {
720 pMse->negativeY = 4;
721 pMse->positiveY = 5;
722 if (pMse->negativeY > pMse->buttons)
723 pMse->buttons = pMse->negativeY;
724 if (pMse->positiveY > pMse->buttons)
725 pMse->buttons = pMse->positiveY;
726 xf86Msg(X_DEFAULT, "%s: YAxisMapping: buttons %d and %d\n",
727 pInfo->name, pMse->negativeY, pMse->positiveY);
728 }
729 xf86Msg(X_CONFIG, "%s: EmulateWheel, EmulateWheelButton: %d, "
730 "EmulateWheelInertia: %d, "
731 "EmulateWheelTimeout: %d\n",
732 pInfo->name, wheelButton, pMse->wheelInertia,
733 pMse->wheelButtonTimeout);
734 }
735 s = xf86SetStrOption(pInfo->options, "ButtonMapping", NULL);
736 if (s) {
737 int b, n = 0;
738 char *s1 = s;
739 /* keep getting numbers which are buttons */
740 while (s1 && n < MSE_MAXBUTTONS && (b = strtol(s1, &s1, 10)) != 0) {
741 /* check sanity for a button */
742 if (b < 0 || b > MSE_MAXBUTTONS) {
743 xf86Msg(X_WARNING,
744 "ButtonMapping: Invalid button number = %d\n", b);
745 break;
746 };
747 pMse->buttonMap[n++] = 1 << (b-1);
748 if (b > pMse->buttons) pMse->buttons = b;
749 }
750 xfree(s);
751 }
752 /* get maximum of mapped buttons */
753 for (i = pMse->buttons-1; i >= 0; i--) {
754 int f = ffs (pMse->buttonMap[i]);
755 if (f > pMse->buttons)
756 pMse->buttons = f;
757 }
758 if (origButtons != pMse->buttons)
759 buttons_from = X_CONFIG;
760 xf86Msg(buttons_from, "%s: Buttons: %d\n", pInfo->name, pMse->buttons);
761
762 pMse->doubleClickSourceButtonMask = 0;
763 pMse->doubleClickTargetButtonMask = 0;
764 pMse->doubleClickTargetButton = 0;
765 s = xf86SetStrOption(pInfo->options, "DoubleClickButtons", NULL);
766 if (s) {
767 int b1 = 0, b2 = 0;
768 char *msg = NULL;
769
770 if ((sscanf(s, "%d %d", &b1, &b2) == 2) &&
771 (b1 > 0) && (b1 <= MSE_MAXBUTTONS) && (b2 > 0) && (b2 <= MSE_MAXBUTTONS)) {
772 msg = xstrdup("buttons XX and YY");
773 if (msg)
774 sprintf(msg, "buttons %d and %d", b1, b2);
775 pMse->doubleClickTargetButton = b1;
776 pMse->doubleClickTargetButtonMask = 1 << (b1 - 1);
777 pMse->doubleClickSourceButtonMask = 1 << (b2 - 1);
778 if (b1 > pMse->buttons) pMse->buttons = b1;
779 if (b2 > pMse->buttons) pMse->buttons = b2;
780 } else {
781 xf86Msg(X_WARNING, "%s: Invalid DoubleClickButtons value: \"%s\"\n",
782 pInfo->name, s);
783 }
784 if (msg) {
785 xf86Msg(X_CONFIG, "%s: DoubleClickButtons: %s\n", pInfo->name, msg);
786 xfree(msg);
787 }
788 }
789}
790/*
791 * map bits corresponding to lock buttons.
792 * for each bit for a lock button,
793 * turn on bit corresponding to button button that the lock
794 * button services.
795 */
796
797static int
798lock2targetMap(DragLockPtr pLock, int lockMask)
799{
800 int result,i;
801 result = 0;
802
803 /*
804 * for each nibble group of bits, use
805 * map for that group to get corresponding
806 * bits, turn them on.
807 * if 4 or less buttons only first map will
808 * need to be used.
809 */
810 for (i = 0; (i < NIB_COUNT) && lockMask; i++) {
811 result |= pLock->nib_table[i][lockMask& NIB_MASK];
812
813 lockMask &= ~NIB_MASK;
814 lockMask >>= NIB_BITS;
815 }
816 return result;
817}
818
819static void
820MouseHWOptions(InputInfoPtr pInfo)
821{
822 MouseDevPtr pMse = pInfo->private;
823 mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
824
825 if (mPriv == NULL)
826 return;
827
828 if ((mPriv->soft
829 = xf86SetBoolOption(pInfo->options, "AutoSoft", FALSE))) {
830 xf86Msg(X_CONFIG, "Don't initialize mouse when auto-probing\n");
831 }
832 pMse->sampleRate = xf86SetIntOption(pInfo->options, "SampleRate", 0);
833 if (pMse->sampleRate) {
834 xf86Msg(X_CONFIG, "%s: SampleRate: %d\n", pInfo->name,
835 pMse->sampleRate);
836 }
837 pMse->resolution = xf86SetIntOption(pInfo->options, "Resolution", 0);
838 if (pMse->resolution) {
839 xf86Msg(X_CONFIG, "%s: Resolution: %d\n", pInfo->name,
840 pMse->resolution);
841 }
842}
843
844static void
845MouseSerialOptions(InputInfoPtr pInfo)
846{
847 MouseDevPtr pMse = pInfo->private;
848 Bool clearDTR, clearRTS;
849
850
851 pMse->baudRate = xf86SetIntOption(pInfo->options, "BaudRate", 0);
852 if (pMse->baudRate) {
853 xf86Msg(X_CONFIG, "%s: BaudRate: %d\n", pInfo->name,
854 pMse->baudRate);
855 }
856
857 if ((clearDTR = xf86SetBoolOption(pInfo->options, "ClearDTR",FALSE)))
858 pMse->mouseFlags |= MF_CLEAR_DTR;
859
860
861 if ((clearRTS = xf86SetBoolOption(pInfo->options, "ClearRTS",FALSE)))
862 pMse->mouseFlags |= MF_CLEAR_RTS;
863
864 if (clearDTR || clearRTS) {
865 xf86Msg(X_CONFIG, "%s: ", pInfo->name);
866 if (clearDTR) {
867 xf86ErrorF("ClearDTR");
868 if (clearRTS)
869 xf86ErrorF(", ");
870 }
871 if (clearRTS) {
872 xf86ErrorF("ClearRTS");
873 }
874 xf86ErrorF("\n");
875 }
876}
877
878static MouseProtocolID
879ProtocolNameToID(const char *name)
880{
881 int i;
882
883 for (i = 0; mouseProtocols[i].name; i++)
884 if (xf86NameCmp(name, mouseProtocols[i].name) == 0)
885 return mouseProtocols[i].id;
886 return PROT_UNKNOWN;
887}
888
889static const char *
890ProtocolIDToName(MouseProtocolID id)
891{
892 int i;
893
894 switch (id) {
895 case PROT_UNKNOWN:
896 return "Unknown";
897 break;
898 case PROT_UNSUP:
899 return "Unsupported";
900 break;
901 default:
902 for (i = 0; mouseProtocols[i].name; i++)
903 if (id == mouseProtocols[i].id)
904 return mouseProtocols[i].name;
905 return "Invalid";
906 }
907}
908
909const char *
910xf86MouseProtocolIDToName(MouseProtocolID id)
911{
912 return ProtocolIDToName(id);
913}
914
915MouseProtocolID
916xf86MouseProtocolNameToID(const char *name)
917{
918 return ProtocolNameToID(name);
919}
920
921static int
922ProtocolIDToClass(MouseProtocolID id)
923{
924 int i;
925
926 switch (id) {
927 case PROT_UNKNOWN:
928 case PROT_UNSUP:
929 return MSE_NONE;
930 break;
931 default:
932 for (i = 0; mouseProtocols[i].name; i++)
933 if (id == mouseProtocols[i].id)
934 return mouseProtocols[i].class;
935 return MSE_NONE;
936 }
937}
938
939static MouseProtocolPtr
940GetProtocol(MouseProtocolID id) {
941 int i;
942
943 switch (id) {
944 case PROT_UNKNOWN:
945 case PROT_UNSUP:
946 return NULL;
947 break;
948 default:
949 for (i = 0; mouseProtocols[i].name; i++)
950 if (id == mouseProtocols[i].id) {
951 return &mouseProtocols[i];
952 }
953 return NULL;
954 }
955}
956
957static OSMouseInfoPtr osInfo = NULL;
958
959static Bool
960InitProtocols(void)
961{
962 int classes;
963 int i;
964 const char *osname = NULL;
965
966 if (osInfo)
967 return TRUE;
968
969 osInfo = xf86OSMouseInit(0);
970 if (!osInfo)
971 return FALSE;
972 if (!osInfo->SupportedInterfaces)
973 return FALSE;
974
975 classes = osInfo->SupportedInterfaces();
976 if (!classes)
977 return FALSE;
978
979 /* Mark unsupported interface classes. */
980 for (i = 0; mouseProtocols[i].name; i++)
981 if (!(mouseProtocols[i].class & classes))
982 mouseProtocols[i].id = PROT_UNSUP;
983
984 for (i = 0; mouseProtocols[i].name; i++)
985 if (mouseProtocols[i].class & MSE_MISC)
986 if (!osInfo->CheckProtocol ||
987 !osInfo->CheckProtocol(mouseProtocols[i].name))
988 mouseProtocols[i].id = PROT_UNSUP;
989
990 /* NetBSD uses PROT_BM for "PS/2". */
991 xf86GetOS(&osname, NULL, NULL, NULL);
992 if (osname && xf86NameCmp(osname, "netbsd") == 0)
993 for (i = 0; mouseProtocols[i].name; i++)
994 if (mouseProtocols[i].id == PROT_PS2)
995 mouseProtocols[i].id = PROT_BM;
996
997 return TRUE;
998}
999
1000static InputInfoPtr
1001MousePreInit(InputDriverPtr drv, IDevPtr dev, int flags)
1002{
1003 InputInfoPtr pInfo;
1004 MouseDevPtr pMse;
1005 mousePrivPtr mPriv;
1006 MessageType protocolFrom = X_DEFAULT, deviceFrom = X_CONFIG;
1007 const char *protocol, *osProt = NULL;
1008 const char *device;
1009 MouseProtocolID protocolID;
1010 MouseProtocolPtr pProto;
1011 Bool detected;
1012 int i;
1013
1014#ifdef VBOX
1015 xf86Msg(X_INFO,
1016 "VirtualBox guest additions mouse driver version "
1017 VBOX_VERSION_STRING "\n");
1018#endif
1019
1020 if (!InitProtocols())
1021 return NULL;
1022
1023 if (!(pInfo = xf86AllocateInput(drv, 0)))
1024 return NULL;
1025
1026 /* Initialise the InputInfoRec. */
1027 pInfo->name = dev->identifier;
1028 pInfo->type_name = XI_MOUSE;
1029 pInfo->flags = XI86_POINTER_CAPABLE | XI86_SEND_DRAG_EVENTS;
1030 pInfo->device_control = MouseProc;
1031 pInfo->read_input = MouseReadInput;
1032/* pInfo->motion_history_proc = xf86GetMotionEvents; */
1033 pInfo->history_size = 0;
1034 pInfo->control_proc = NULL;
1035 pInfo->close_proc = NULL;
1036 pInfo->switch_mode = NULL;
1037 pInfo->conversion_proc = MouseConvert;
1038 pInfo->reverse_conversion_proc = NULL;
1039 pInfo->fd = -1;
1040 pInfo->dev = NULL;
1041 pInfo->private_flags = 0;
1042 pInfo->always_core_feedback = 0;
1043 pInfo->conf_idev = dev;
1044
1045 /* Check if SendDragEvents has been disabled. */
1046 if (!xf86SetBoolOption(dev->commonOptions, "SendDragEvents", TRUE)) {
1047 pInfo->flags &= ~XI86_SEND_DRAG_EVENTS;
1048 }
1049
1050 /* Allocate the MouseDevRec and initialise it. */
1051 /*
1052 * XXX This should be done by a function in the core server since the
1053 * MouseDevRec is defined in the os-support layer.
1054 */
1055 if (!(pMse = xcalloc(sizeof(MouseDevRec), 1)))
1056 return pInfo;
1057 pInfo->private = pMse;
1058 pMse->Ctrl = MouseCtrl;
1059 pMse->PostEvent = MousePostEvent;
1060 pMse->CommonOptions = MouseCommonOptions;
1061
1062#ifdef VBOX
1063
1064/* ImPS/2 is not supported on FreeBSD */
1065# ifdef RT_OS_FREEBSD
1066 protocol = "PS/2";
1067# else
1068 protocol = "ImPS/2";
1069# endif
1070 protocolFrom = X_CONFIG;
1071#else
1072 /* Find the protocol type. */
1073 protocol = xf86SetStrOption(dev->commonOptions, "Protocol", NULL);
1074 if (protocol) {
1075 protocolFrom = X_CONFIG;
1076 } else if (osInfo->DefaultProtocol) {
1077 protocol = osInfo->DefaultProtocol();
1078 protocolFrom = X_DEFAULT;
1079 }
1080 if (!protocol) {
1081 xf86Msg(X_ERROR, "%s: No Protocol specified\n", pInfo->name);
1082 return pInfo;
1083 }
1084#endif
1085
1086 /* Default Mapping: 1 2 3 8 9 10 11 ... */
1087 for (i = 0; i < MSE_MAXBUTTONS; i++)
1088 pMse->buttonMap[i] = 1 << (i > 2 && i < MSE_MAXBUTTONS-4 ? i+4 : i);
1089
1090 protocolID = ProtocolNameToID(protocol);
1091 do {
1092 detected = TRUE;
1093 switch (protocolID) {
1094 case PROT_AUTO:
1095 if (osInfo->SetupAuto) {
1096 if ((osProt = osInfo->SetupAuto(pInfo,NULL))) {
1097 MouseProtocolID id = ProtocolNameToID(osProt);
1098 if (id == PROT_UNKNOWN || id == PROT_UNSUP) {
1099 protocolID = id;
1100 protocol = osProt;
1101 detected = FALSE;
1102 }
1103 }
1104 }
1105 break;
1106 case PROT_UNKNOWN:
1107 /* Check for a builtin OS-specific protocol,
1108 * and call its PreInit. */
1109 if (osInfo->CheckProtocol
1110 && osInfo->CheckProtocol(protocol)) {
1111 if (!xf86CheckStrOption(dev->commonOptions, "Device", NULL) &&
1112 HAVE_FIND_DEVICE && osInfo->FindDevice) {
1113 xf86Msg(X_WARNING, "%s: No Device specified, "
1114 "looking for one...\n", pInfo->name);
1115 if (!osInfo->FindDevice(pInfo, protocol, 0)) {
1116 xf86Msg(X_ERROR, "%s: Cannot find which device "
1117 "to use.\n", pInfo->name);
1118 } else
1119 deviceFrom = X_PROBED;
1120 }
1121 if (osInfo->PreInit) {
1122 osInfo->PreInit(pInfo, protocol, 0);
1123 }
1124 return pInfo;
1125 }
1126 xf86Msg(X_ERROR, "%s: Unknown protocol \"%s\"\n",
1127 pInfo->name, protocol);
1128 return pInfo;
1129 break;
1130 case PROT_UNSUP:
1131 xf86Msg(X_ERROR,
1132 "%s: Protocol \"%s\" is not supported on this "
1133 "platform\n", pInfo->name, protocol);
1134 return pInfo;
1135 break;
1136 default:
1137 break;
1138
1139 }
1140 } while (!detected);
1141
1142 if (!xf86CheckStrOption(dev->commonOptions, "Device", NULL) &&
1143 HAVE_FIND_DEVICE && osInfo->FindDevice) {
1144 xf86Msg(X_WARNING, "%s: No Device specified, looking for one...\n",
1145 pInfo->name);
1146 if (!osInfo->FindDevice(pInfo, protocol, 0)) {
1147 xf86Msg(X_ERROR, "%s: Cannot find which device to use.\n",
1148 pInfo->name);
1149 } else {
1150 deviceFrom = X_PROBED;
1151 xf86MarkOptionUsedByName(dev->commonOptions, "Device");
1152 }
1153 }
1154
1155 device = xf86CheckStrOption(dev->commonOptions, "Device", NULL);
1156 if (device)
1157 xf86Msg(deviceFrom, "%s: Device: \"%s\"\n", pInfo->name, device);
1158
1159 xf86Msg(protocolFrom, "%s: Protocol: \"%s\"\n", pInfo->name, protocol);
1160 if (!(pProto = GetProtocol(protocolID)))
1161 return pInfo;
1162
1163 pMse->protocolID = protocolID;
1164 pMse->oldProtocolID = protocolID; /* hack */
1165
1166 pMse->autoProbe = FALSE;
1167 /* Collect the options, and process the common options. */
1168 xf86CollectInputOptions(pInfo, pProto->defaults, NULL);
1169 xf86ProcessCommonOptions(pInfo, pInfo->options);
1170
1171 /* XXX should handle this OS dependency elsewhere. */
1172#ifndef __OS2ELF__
1173 /* OS/2 has a mouse handled by the OS - it cannot fail here */
1174
1175 /* Check if the device can be opened. */
1176 pInfo->fd = xf86OpenSerial(pInfo->options);
1177 if (pInfo->fd == -1) {
1178 if (xf86GetAllowMouseOpenFail())
1179 xf86Msg(X_WARNING, "%s: cannot open input device\n", pInfo->name);
1180 else {
1181 xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
1182 if (pMse->mousePriv)
1183 xfree(pMse->mousePriv);
1184 xfree(pMse);
1185 pInfo->private = NULL;
1186 return pInfo;
1187 }
1188 }
1189 xf86CloseSerial(pInfo->fd);
1190#endif
1191 pInfo->fd = -1;
1192
1193#ifdef VBOX
1194 mPriv = NULL; /* later */
1195#else
1196 if (!(mPriv = (pointer) xcalloc(sizeof(mousePrivRec), 1)))
1197 return pInfo;
1198#endif
1199 pMse->mousePriv = mPriv;
1200 pMse->CommonOptions(pInfo);
1201 pMse->checkMovements = checkForErraticMovements;
1202 pMse->autoProbeMouse = autoProbeMouse;
1203 pMse->collectData = collectData;
1204 pMse->dataGood = autoGood;
1205
1206 MouseHWOptions(pInfo);
1207 MouseSerialOptions(pInfo);
1208
1209 pInfo->flags |= XI86_CONFIGURED;
1210 return pInfo;
1211}
1212
1213
1214static void
1215MouseReadInput(InputInfoPtr pInfo)
1216{
1217 MouseDevPtr pMse;
1218 int j, buttons, dx, dy, dz, dw, baddata;
1219 int pBufP;
1220 int c;
1221 unsigned char *pBuf, u;
1222
1223
1224 pMse = pInfo->private;
1225 pBufP = pMse->protoBufTail;
1226 pBuf = pMse->protoBuf;
1227
1228 /*
1229 * Set blocking to -1 on the first call because we know there is data to
1230 * read. Xisb automatically clears it after one successful read so that
1231 * succeeding reads are preceeded by a select with a 0 timeout to prevent
1232 * read from blocking indefinitely.
1233 */
1234 XisbBlockDuration(pMse->buffer, -1);
1235
1236 while ((c = XisbRead(pMse->buffer)) >= 0) {
1237 u = (unsigned char)c;
1238
1239#if defined (EXTMOUSEDEBUG) || defined (MOUSEDATADEBUG)
1240 ErrorF("mouse byte: %2.2x\n",u);
1241#endif
1242
1243#if 1
1244 /* if we do autoprobing collect the data */
1245 if (pMse->collectData && pMse->autoProbe)
1246 if (pMse->collectData(pMse,u))
1247 continue;
1248#endif
1249#ifdef SUPPORT_MOUSE_RESET
1250 if (mouseReset(pInfo,u)) {
1251 pBufP = 0;
1252 continue;
1253 }
1254#endif
1255 if (pBufP >= pMse->protoPara[4]) {
1256 /*
1257 * Buffer contains a full packet, which has already been processed:
1258 * Empty the buffer and check for optional 4th byte, which will be
1259 * processed directly, without being put into the buffer first.
1260 */
1261 pBufP = 0;
1262 if ((u & pMse->protoPara[0]) != pMse->protoPara[1] &&
1263 (u & pMse->protoPara[5]) == pMse->protoPara[6]) {
1264 /*
1265 * Hack for Logitech MouseMan Mouse - Middle button
1266 *
1267 * Unfortunately this mouse has variable length packets: the
1268 * standard Microsoft 3 byte packet plus an optional 4th byte
1269 * whenever the middle button status changes.
1270 *
1271 * We have already processed the standard packet with the
1272 * movement and button info. Now post an event message with
1273 * the old status of the left and right buttons and the
1274 * updated middle button.
1275 */
1276 /*
1277 * Even worse, different MouseMen and TrackMen differ in the
1278 * 4th byte: some will send 0x00/0x20, others 0x01/0x21, or
1279 * even 0x02/0x22, so I have to strip off the lower bits.
1280 * [CHRIS-211092]
1281 *
1282 * [JCH-96/01/21]
1283 * HACK for ALPS "fourth button". (It's bit 0x10 of the
1284 * "fourth byte" and it is activated by tapping the glidepad
1285 * with the finger! 8^) We map it to bit bit3, and the
1286 * reverse map in xf86Events just has to be extended so that
1287 * it is identified as Button 4. The lower half of the
1288 * reverse-map may remain unchanged.
1289 */
1290 /*
1291 * [KAZU-030897]
1292 * Receive the fourth byte only when preceeding three bytes
1293 * have been detected (pBufP >= pMse->protoPara[4]). In the
1294 * previous versions, the test was pBufP == 0; we may have
1295 * mistakingly received a byte even if we didn't see anything
1296 * preceeding the byte.
1297 */
1298#ifdef EXTMOUSEDEBUG
1299 ErrorF("mouse 4th byte %02x\n",u);
1300#endif
1301 dx = dy = dz = dw = 0;
1302 buttons = 0;
1303 switch (pMse->protocolID) {
1304
1305 /*
1306 * [KAZU-221197]
1307 * IntelliMouse, NetMouse (including NetMouse Pro) and Mie
1308 * Mouse always send the fourth byte, whereas the fourth byte
1309 * is optional for GlidePoint and ThinkingMouse. The fourth
1310 * byte is also optional for MouseMan+ and FirstMouse+ in
1311 * their native mode. It is always sent if they are in the
1312 * IntelliMouse compatible mode.
1313 */
1314 case PROT_IMSERIAL: /* IntelliMouse, NetMouse, Mie Mouse,
1315 MouseMan+ */
1316 dz = (u & 0x08) ?
1317 (u & 0x0f) - 16 : (u & 0x0f);
1318 if ((dz >= 7) || (dz <= -7))
1319 dz = 0;
1320 buttons |= ((int)(u & 0x10) >> 3)
1321 | ((int)(u & 0x20) >> 2)
1322 | (pMse->lastButtons & 0x05);
1323 break;
1324
1325 case PROT_GLIDE:
1326 case PROT_THINKING:
1327 buttons |= ((int)(u & 0x10) >> 1);
1328 /* fall through */
1329
1330 default:
1331 buttons |= ((int)(u & 0x20) >> 4) |
1332 (pMse->lastButtons & 0x05);
1333 break;
1334 }
1335 goto post_event;
1336 }
1337 }
1338 /* End of packet buffer flush and 4th byte hack. */
1339
1340 /*
1341 * Append next byte to buffer (which is empty or contains an
1342 * incomplete packet); iterate if packet (still) not complete.
1343 */
1344 pBuf[pBufP++] = u;
1345 if (pBufP != pMse->protoPara[4]) continue;
1346#ifdef EXTMOUSEDEBUG2
1347 {
1348 int i;
1349 ErrorF("received %d bytes",pBufP);
1350 for ( i=0; i < pBufP; i++)
1351 ErrorF(" %02x",pBuf[i]);
1352 ErrorF("\n");
1353 }
1354#endif
1355
1356 /*
1357 * Hack for resyncing: We check here for a package that is:
1358 * a) illegal (detected by wrong data-package header)
1359 * b) invalid (0x80 == -128 and that might be wrong for MouseSystems)
1360 * c) bad header-package
1361 *
1362 * NOTE: b) is a violation of the MouseSystems-Protocol, since values
1363 * of -128 are allowed, but since they are very seldom we can
1364 * easily use them as package-header with no button pressed.
1365 * NOTE/2: On a PS/2 mouse any byte is valid as a data byte.
1366 * Furthermore, 0x80 is not valid as a header byte. For a PS/2
1367 * mouse we skip checking data bytes. For resyncing a PS/2
1368 * mouse we require the two most significant bits in the header
1369 * byte to be 0. These are the overflow bits, and in case of
1370 * an overflow we actually lose sync. Overflows are very rare,
1371 * however, and we quickly gain sync again after an overflow
1372 * condition. This is the best we can do. (Actually, we could
1373 * use bit 0x08 in the header byte for resyncing, since that
1374 * bit is supposed to be always on, but nobody told Microsoft...)
1375 */
1376
1377 /*
1378 * [KAZU,OYVIND-120398]
1379 * The above hack is wrong! Because of b) above, we shall see
1380 * erroneous mouse events so often when the MouseSystem mouse is
1381 * moved quickly. As for the PS/2 and its variants, we don't need
1382 * to treat them as special cases, because protoPara[2] and
1383 * protoPara[3] are both 0x00 for them, thus, any data bytes will
1384 * never be discarded. 0x80 is rejected for MMSeries, Logitech
1385 * and MMHittab protocols, because protoPara[2] and protoPara[3]
1386 * are 0x80 and 0x00 respectively. The other protocols are 7-bit
1387 * protocols; there is no use checking 0x80.
1388 *
1389 * All in all we should check the condition a) only.
1390 */
1391
1392 /*
1393 * [OYVIND-120498]
1394 * Check packet for valid data:
1395 * If driver is in sync with datastream, the packet is considered
1396 * bad if any byte (header and/or data) contains an invalid value.
1397 *
1398 * If packet is bad, we discard the first byte and shift the buffer.
1399 * Next iteration will then check the new situation for validity.
1400 *
1401 * If flag MF_SAFE is set in proto[7] and the driver
1402 * is out of sync, the packet is also considered bad if
1403 * any of the data bytes contains a valid header byte value.
1404 * This situation could occur if the buffer contains
1405 * the tail of one packet and the header of the next.
1406 *
1407 * Note: The driver starts in out-of-sync mode (pMse->inSync = 0).
1408 */
1409
1410 baddata = 0;
1411
1412 /* All databytes must be valid. */
1413 for (j = 1; j < pBufP; j++ )
1414 if ((pBuf[j] & pMse->protoPara[2]) != pMse->protoPara[3])
1415 baddata = 1;
1416
1417 /* If out of sync, don't mistake a header byte for data. */
1418 if ((pMse->protoPara[7] & MPF_SAFE) && !pMse->inSync)
1419 for (j = 1; j < pBufP; j++ )
1420 if ((pBuf[j] & pMse->protoPara[0]) == pMse->protoPara[1])
1421 baddata = 1;
1422
1423 /* Accept or reject the packet ? */
1424 if ((pBuf[0] & pMse->protoPara[0]) != pMse->protoPara[1] || baddata) {
1425 if (pMse->inSync) {
1426#ifdef EXTMOUSEDEBUG
1427 ErrorF("mouse driver lost sync\n");
1428#endif
1429 }
1430#ifdef EXTMOUSEDEBUG
1431 ErrorF("skipping byte %02x\n",*pBuf);
1432#endif
1433 /* Tell auto probe that we are out of sync */
1434 if (pMse->autoProbeMouse && pMse->autoProbe)
1435 pMse->autoProbeMouse(pInfo, FALSE, pMse->inSync);
1436 pMse->protoBufTail = --pBufP;
1437 for (j = 0; j < pBufP; j++)
1438 pBuf[j] = pBuf[j+1];
1439 pMse->inSync = 0;
1440 continue;
1441 }
1442 /* Tell auto probe that we were successful */
1443 if (pMse->autoProbeMouse && pMse->autoProbe)
1444 pMse->autoProbeMouse(pInfo, TRUE, FALSE);
1445
1446 if (!pMse->inSync) {
1447#ifdef EXTMOUSEDEBUG
1448 ErrorF("mouse driver back in sync\n");
1449#endif
1450 pMse->inSync = 1;
1451 }
1452
1453 if (!pMse->dataGood(pMse))
1454 continue;
1455
1456 /*
1457 * Packet complete and verified, now process it ...
1458 */
1459 REDO_INTERPRET:
1460 dz = dw = 0;
1461 switch (pMse->protocolID) {
1462 case PROT_LOGIMAN: /* MouseMan / TrackMan [CHRIS-211092] */
1463 case PROT_MS: /* Microsoft */
1464 if (pMse->chordMiddle)
1465 buttons = (((int) pBuf[0] & 0x30) == 0x30) ? 2 :
1466 ((int)(pBuf[0] & 0x20) >> 3)
1467 | ((int)(pBuf[0] & 0x10) >> 4);
1468 else
1469 buttons = (pMse->lastButtons & 2)
1470 | ((int)(pBuf[0] & 0x20) >> 3)
1471 | ((int)(pBuf[0] & 0x10) >> 4);
1472 dx = (char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
1473 dy = (char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
1474 break;
1475
1476 case PROT_GLIDE: /* ALPS GlidePoint */
1477 case PROT_THINKING: /* ThinkingMouse */
1478 case PROT_IMSERIAL: /* IntelliMouse, NetMouse, Mie Mouse, MouseMan+ */
1479 buttons = (pMse->lastButtons & (8 + 2))
1480 | ((int)(pBuf[0] & 0x20) >> 3)
1481 | ((int)(pBuf[0] & 0x10) >> 4);
1482 dx = (char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
1483 dy = (char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
1484 break;
1485
1486 case PROT_MSC: /* Mouse Systems Corp */
1487 buttons = (~pBuf[0]) & 0x07;
1488 dx = (char)(pBuf[1]) + (char)(pBuf[3]);
1489 dy = - ((char)(pBuf[2]) + (char)(pBuf[4]));
1490 break;
1491
1492 case PROT_MMHIT: /* MM_HitTablet */
1493 buttons = pBuf[0] & 0x07;
1494 if (buttons != 0)
1495 buttons = 1 << (buttons - 1);
1496 dx = (pBuf[0] & 0x10) ? pBuf[1] : - pBuf[1];
1497 dy = (pBuf[0] & 0x08) ? - pBuf[2] : pBuf[2];
1498 break;
1499
1500 case PROT_ACECAD: /* ACECAD */
1501 /* ACECAD is almost exactly like MM but the buttons are different */
1502 buttons = (pBuf[0] & 0x02) | ((pBuf[0] & 0x04) >> 2) |
1503 ((pBuf[0] & 1) << 2);
1504 dx = (pBuf[0] & 0x10) ? pBuf[1] : - pBuf[1];
1505 dy = (pBuf[0] & 0x08) ? - pBuf[2] : pBuf[2];
1506 break;
1507
1508 case PROT_MM: /* MM Series */
1509 case PROT_LOGI: /* Logitech Mice */
1510 buttons = pBuf[0] & 0x07;
1511 dx = (pBuf[0] & 0x10) ? pBuf[1] : - pBuf[1];
1512 dy = (pBuf[0] & 0x08) ? - pBuf[2] : pBuf[2];
1513 break;
1514
1515 case PROT_BM: /* BusMouse */
1516 buttons = (~pBuf[0]) & 0x07;
1517 dx = (char)pBuf[1];
1518 dy = - (char)pBuf[2];
1519 break;
1520
1521 case PROT_PS2: /* PS/2 mouse */
1522 case PROT_GENPS2: /* generic PS/2 mouse */
1523 buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
1524 (pBuf[0] & 0x02) >> 1 | /* Right */
1525 (pBuf[0] & 0x01) << 2; /* Left */
1526 dx = (pBuf[0] & 0x10) ? (int)pBuf[1]-256 : (int)pBuf[1];
1527 dy = (pBuf[0] & 0x20) ? -((int)pBuf[2]-256) : -(int)pBuf[2];
1528 break;
1529
1530 /* PS/2 mouse variants */
1531 case PROT_IMPS2: /* IntelliMouse PS/2 */
1532 case PROT_NETPS2: /* NetMouse PS/2 */
1533 buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
1534 (pBuf[0] & 0x02) >> 1 | /* Right */
1535 (pBuf[0] & 0x01) << 2 | /* Left */
1536 (pBuf[0] & 0x40) >> 3 | /* button 4 */
1537 (pBuf[0] & 0x80) >> 3; /* button 5 */
1538 dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
1539 dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
1540 /*
1541 * The next cast must be 'signed char' for platforms (like PPC)
1542 * where char defaults to unsigned.
1543 */
1544 dz = (signed char)(pBuf[3] | ((pBuf[3] & 0x08) ? 0xf8 : 0));
1545 if ((pBuf[3] & 0xf8) && ((pBuf[3] & 0xf8) != 0xf8)) {
1546 if (pMse->autoProbe) {
1547 SetMouseProto(pMse, PROT_EXPPS2);
1548 xf86Msg(X_INFO,
1549 "Mouse autoprobe: Changing protocol to %s\n",
1550 pMse->protocol);
1551
1552 goto REDO_INTERPRET;
1553 } else
1554 dz = 0;
1555 }
1556 break;
1557
1558 case PROT_EXPPS2: /* IntelliMouse Explorer PS/2 */
1559 if (pMse->autoProbe && (pBuf[3] & 0xC0)) {
1560 SetMouseProto(pMse, PROT_IMPS2);
1561 xf86Msg(X_INFO,"Mouse autoprobe: Changing protocol to %s\n",
1562 pMse->protocol);
1563 goto REDO_INTERPRET;
1564 }
1565 buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
1566 (pBuf[0] & 0x02) >> 1 | /* Right */
1567 (pBuf[0] & 0x01) << 2 | /* Left */
1568 (pBuf[3] & 0x10) >> 1 | /* button 4 */
1569 (pBuf[3] & 0x20) >> 1; /* button 5 */
1570 dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
1571 dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
1572 dz = (pBuf[3] & 0x08) ? (pBuf[3] & 0x0f) - 16 : (pBuf[3] & 0x0f);
1573 break;
1574
1575 case PROT_MMPS2: /* MouseMan+ PS/2 */
1576 buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
1577 (pBuf[0] & 0x02) >> 1 | /* Right */
1578 (pBuf[0] & 0x01) << 2; /* Left */
1579 dx = (pBuf[0] & 0x10) ? pBuf[1] - 256 : pBuf[1];
1580 if (((pBuf[0] & 0x48) == 0x48) &&
1581 (abs(dx) > 191) &&
1582 ((((pBuf[2] & 0x03) << 2) | 0x02) == (pBuf[1] & 0x0f))) {
1583 /* extended data packet */
1584 switch ((((pBuf[0] & 0x30) >> 2) | ((pBuf[1] & 0x30) >> 4))) {
1585 case 1: /* wheel data packet */
1586 buttons |= ((pBuf[2] & 0x10) ? 0x08 : 0) | /* 4th button */
1587 ((pBuf[2] & 0x20) ? 0x10 : 0); /* 5th button */
1588 dx = dy = 0;
1589 dz = (pBuf[2] & 0x08) ? (pBuf[2] & 0x0f) - 16 :
1590 (pBuf[2] & 0x0f);
1591 break;
1592 case 2: /* Logitech reserves this packet type */
1593 /*
1594 * IBM ScrollPoint uses this packet to encode its
1595 * stick movement.
1596 */
1597 buttons |= (pMse->lastButtons & ~0x07);
1598 dx = dy = 0;
1599 dz = (pBuf[2] & 0x80) ? ((pBuf[2] >> 4) & 0x0f) - 16 :
1600 ((pBuf[2] >> 4) & 0x0f);
1601 dw = (pBuf[2] & 0x08) ? (pBuf[2] & 0x0f) - 16 :
1602 (pBuf[2] & 0x0f);
1603 break;
1604 case 0: /* device type packet - shouldn't happen */
1605 default:
1606 buttons |= (pMse->lastButtons & ~0x07);
1607 dx = dy = 0;
1608 dz = 0;
1609 break;
1610 }
1611 } else {
1612 buttons |= (pMse->lastButtons & ~0x07);
1613 dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
1614 dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
1615 }
1616 break;
1617
1618 case PROT_GLIDEPS2: /* GlidePoint PS/2 */
1619 buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
1620 (pBuf[0] & 0x02) >> 1 | /* Right */
1621 (pBuf[0] & 0x01) << 2 | /* Left */
1622 ((pBuf[0] & 0x08) ? 0 : 0x08);/* fourth button */
1623 dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
1624 dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
1625 break;
1626
1627 case PROT_NETSCPS2: /* NetScroll PS/2 */
1628 buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
1629 (pBuf[0] & 0x02) >> 1 | /* Right */
1630 (pBuf[0] & 0x01) << 2 | /* Left */
1631 ((pBuf[3] & 0x02) ? 0x08 : 0) | /* button 4 */
1632 ((pBuf[3] & 0x01) ? 0x10 : 0); /* button 5 */
1633 dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
1634 dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
1635 dz = (pBuf[3] & 0x10) ? pBuf[4] - 256 : pBuf[4];
1636 break;
1637
1638 case PROT_THINKPS2: /* ThinkingMouse PS/2 */
1639 buttons = (pBuf[0] & 0x04) >> 1 | /* Middle */
1640 (pBuf[0] & 0x02) >> 1 | /* Right */
1641 (pBuf[0] & 0x01) << 2 | /* Left */
1642 ((pBuf[0] & 0x08) ? 0x08 : 0);/* fourth button */
1643 pBuf[1] |= (pBuf[0] & 0x40) ? 0x80 : 0x00;
1644 dx = (pBuf[0] & 0x10) ? pBuf[1]-256 : pBuf[1];
1645 dy = (pBuf[0] & 0x20) ? -(pBuf[2]-256) : -pBuf[2];
1646 break;
1647
1648 case PROT_SYSMOUSE: /* sysmouse */
1649 buttons = (~pBuf[0]) & 0x07;
1650 dx = (signed char)(pBuf[1]) + (signed char)(pBuf[3]);
1651 dy = - ((signed char)(pBuf[2]) + (signed char)(pBuf[4]));
1652 /* FreeBSD sysmouse sends additional data bytes */
1653 if (pMse->protoPara[4] >= 8) {
1654 /*
1655 * These casts must be 'signed char' for platforms (like PPC)
1656 * where char defaults to unsigned.
1657 */
1658 dz = ((signed char)(pBuf[5] << 1) +
1659 (signed char)(pBuf[6] << 1)) >> 1;
1660 buttons |= (int)(~pBuf[7] & 0x7f) << 3;
1661 }
1662 break;
1663
1664 case PROT_VALUMOUSESCROLL: /* Kensington ValuMouseScroll */
1665 buttons = ((int)(pBuf[0] & 0x20) >> 3)
1666 | ((int)(pBuf[0] & 0x10) >> 4)
1667 | ((int)(pBuf[3] & 0x10) >> 3);
1668 dx = (char)(((pBuf[0] & 0x03) << 6) | (pBuf[1] & 0x3F));
1669 dy = (char)(((pBuf[0] & 0x0C) << 4) | (pBuf[2] & 0x3F));
1670 dz = (pBuf[3] & 0x08) ? ((int)(pBuf[3] & 0x0F) - 0x10) :
1671 ((int)(pBuf[3] & 0x0F));
1672 break;
1673
1674 default: /* There's a table error */
1675#ifdef EXTMOUSEDEBUG
1676 ErrorF("mouse table error\n");
1677#endif
1678 continue;
1679 }
1680#ifdef EXTMOUSEDEBUG
1681 ErrorF("packet");
1682 for ( j=0; j < pBufP; j++)
1683 ErrorF(" %02x",pBuf[j]);
1684 ErrorF("\n");
1685#endif
1686
1687post_event:
1688#ifdef EXTMOUSEDEBUG
1689 ErrorF("dx=%i dy=%i dz=%i dw=%i buttons=%x\n",dx,dy,dz,dw,buttons);
1690#endif
1691 /* When auto-probing check if data makes sense */
1692 if (pMse->checkMovements && pMse->autoProbe)
1693 pMse->checkMovements(pInfo,dx,dy);
1694 /* post an event */
1695 pMse->PostEvent(pInfo, buttons, dx, dy, dz, dw);
1696
1697 /*
1698 * We don't reset pBufP here yet, as there may be an additional data
1699 * byte in some protocols. See above.
1700 */
1701 }
1702 pMse->protoBufTail = pBufP;
1703}
1704
1705/*
1706 * MouseCtrl --
1707 * Alter the control parameters for the mouse. Note that all special
1708 * protocol values are handled by dix.
1709 */
1710
1711static void
1712MouseCtrl(DeviceIntPtr device, PtrCtrl *ctrl)
1713{
1714 InputInfoPtr pInfo;
1715 MouseDevPtr pMse;
1716
1717 pInfo = device->public.devicePrivate;
1718 pMse = pInfo->private;
1719
1720#ifdef EXTMOUSEDEBUG
1721 ErrorF("MouseCtrl pMse=%p\n", pMse);
1722#endif
1723
1724 pMse->num = ctrl->num;
1725 pMse->den = ctrl->den;
1726 pMse->threshold = ctrl->threshold;
1727}
1728
1729/*
1730 ***************************************************************************
1731 *
1732 * MouseProc --
1733 *
1734 ***************************************************************************
1735 */
1736
1737static int
1738MouseProc(DeviceIntPtr device, int what)
1739{
1740 InputInfoPtr pInfo;
1741 MouseDevPtr pMse;
1742 mousePrivPtr mPriv;
1743 unsigned char map[MSE_MAXBUTTONS + 1];
1744 int i;
1745#ifdef VBOX
1746 mousePrivPtr pPriv;
1747#endif
1748
1749 pInfo = device->public.devicePrivate;
1750 pMse = pInfo->private;
1751 pMse->device = device;
1752
1753#ifdef VBOX
1754 pPriv = pMse->mousePriv;
1755#endif
1756
1757 switch (what)
1758 {
1759 case DEVICE_INIT:
1760 device->public.on = FALSE;
1761 /*
1762 * [KAZU-241097] We don't know exactly how many buttons the
1763 * device has, so setup the map with the maximum number.
1764 */
1765 for (i = 0; i < MSE_MAXBUTTONS; i++)
1766 map[i + 1] = i + 1;
1767
1768 InitPointerDeviceStruct((DevicePtr)device, map,
1769 min(pMse->buttons, MSE_MAXBUTTONS),
1770 GetMotionHistory, pMse->Ctrl,
1771 GetMotionHistorySize(), 2 /* Number of axes */);
1772
1773 /* X valuator */
1774 xf86InitValuatorAxisStruct(device, 0, 0, -1, 1, 0, 1);
1775 xf86InitValuatorDefaults(device, 0);
1776 /* Y valuator */
1777 xf86InitValuatorAxisStruct(device, 1, 0, -1, 1, 0, 1);
1778 xf86InitValuatorDefaults(device, 1);
1779 xf86MotionHistoryAllocate(pInfo);
1780
1781#ifdef EXTMOUSEDEBUG
1782 ErrorF("assigning %p atom=%d name=%s\n", device, pInfo->atom,
1783 pInfo->name);
1784#endif
1785 break;
1786
1787 case DEVICE_ON:
1788#ifdef VBOX
1789 if (!pPriv)
1790 {
1791 pPriv = (pointer)xcalloc(sizeof(mousePrivRec), 1);
1792 if (pPriv)
1793 {
1794 pMse->mousePriv = pPriv;
1795 pPriv->pScrn = 0;
1796 pPriv->screen_no = xf86SetIntOption(pInfo->options, "ScreenNo", 0);
1797 xf86Msg(X_CONFIG, "VirtualBox Mouse Integration associated with screen %d\n",
1798 pPriv->screen_no);
1799 }
1800 }
1801 if (pPriv)
1802 {
1803 if ( pPriv->screen_no >= screenInfo.numScreens
1804 || pPriv->screen_no < 0)
1805 {
1806 pPriv->screen_no = 0;
1807 }
1808 VBoxMouseInit();
1809 pPriv->pScrn = screenInfo.screens[pPriv->screen_no];
1810 }
1811#endif
1812 pInfo->fd = xf86OpenSerial(pInfo->options);
1813 if (pInfo->fd == -1)
1814 xf86Msg(X_WARNING, "%s: cannot open input device\n", pInfo->name);
1815 else {
1816 if (pMse->xisbscale)
1817 pMse->buffer = XisbNew(pInfo->fd, pMse->xisbscale * 4);
1818 else
1819 pMse->buffer = XisbNew(pInfo->fd, 64);
1820 if (!pMse->buffer) {
1821 xf86CloseSerial(pInfo->fd);
1822 pInfo->fd = -1;
1823 } else {
1824 if (!SetupMouse(pInfo)) {
1825 xf86CloseSerial(pInfo->fd);
1826 pInfo->fd = -1;
1827 XisbFree(pMse->buffer);
1828 pMse->buffer = NULL;
1829 } else {
1830 mPriv = (mousePrivPtr)pMse->mousePriv;
1831 if (mPriv != NULL) {
1832 if ( pMse->protocolID != PROT_AUTO) {
1833 pMse->inSync = TRUE; /* @@@ */
1834 if (mPriv->soft)
1835 mPriv->autoState = AUTOPROBE_GOOD;
1836 else
1837 mPriv->autoState = AUTOPROBE_H_GOOD;
1838 } else {
1839 if (mPriv->soft)
1840 mPriv->autoState = AUTOPROBE_NOPROTO;
1841 else
1842 mPriv->autoState = AUTOPROBE_H_NOPROTO;
1843 }
1844 }
1845 xf86FlushInput(pInfo->fd);
1846 xf86AddEnabledDevice(pInfo);
1847 }
1848 }
1849 }
1850 pMse->lastButtons = 0;
1851 pMse->lastMappedButtons = 0;
1852 pMse->emulateState = 0;
1853 pMse->emulate3Pending = FALSE;
1854 pMse->wheelButtonExpires = GetTimeInMillis ();
1855 device->public.on = TRUE;
1856 FlushButtons(pMse);
1857 if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft)
1858 {
1859 RegisterBlockAndWakeupHandlers (MouseBlockHandler, MouseWakeupHandler,
1860 (pointer) pInfo);
1861 }
1862 break;
1863
1864 case DEVICE_OFF:
1865 case DEVICE_CLOSE:
1866#ifdef VBOX
1867 if (VBoxMouseFini())
1868 {
1869 /** @todo what to do? */
1870 }
1871#endif
1872 if (pInfo->fd != -1) {
1873 xf86RemoveEnabledDevice(pInfo);
1874 if (pMse->buffer) {
1875 XisbFree(pMse->buffer);
1876 pMse->buffer = NULL;
1877 }
1878 xf86CloseSerial(pInfo->fd);
1879 pInfo->fd = -1;
1880 if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft)
1881 {
1882 RemoveBlockAndWakeupHandlers (MouseBlockHandler, MouseWakeupHandler,
1883 (pointer) pInfo);
1884 }
1885 }
1886 device->public.on = FALSE;
1887 usleep(300000);
1888 break;
1889 }
1890 return Success;
1891}
1892
1893/*
1894 ***************************************************************************
1895 *
1896 * MouseConvert --
1897 * Convert valuators to X and Y.
1898 *
1899 ***************************************************************************
1900 */
1901static Bool
1902MouseConvert(InputInfoPtr pInfo, int first, int num, int v0, int v1, int v2,
1903 int v3, int v4, int v5, int *x, int *y)
1904{
1905 if (first != 0 || num != 2)
1906 return FALSE;
1907
1908 *x = v0;
1909 *y = v1;
1910
1911 return TRUE;
1912}
1913
1914/**********************************************************************
1915 *
1916 * FlushButtons -- send button up events for sanity.
1917 *
1918 **********************************************************************/
1919
1920static void
1921FlushButtons(MouseDevPtr pMse)
1922{
1923
1924 /* If no button down is pending xf86PostButtonEvent()
1925 * will discard them. So we are on the safe side. */
1926
1927 int i, blocked;
1928
1929 pMse->lastButtons = 0;
1930 pMse->lastMappedButtons = 0;
1931
1932 blocked = xf86BlockSIGIO ();
1933 for (i = 1; i <= 5; i++)
1934 xf86PostButtonEvent(pMse->device,0,i,0,0,0);
1935 xf86UnblockSIGIO (blocked);
1936}
1937
1938/**********************************************************************
1939 *
1940 * Emulate3Button support code
1941 *
1942 **********************************************************************/
1943
1944
1945/*
1946 * Lets create a simple finite-state machine for 3 button emulation:
1947 *
1948 * We track buttons 1 and 3 (left and right). There are 11 states:
1949 * 0 ground - initial state
1950 * 1 delayed left - left pressed, waiting for right
1951 * 2 delayed right - right pressed, waiting for left
1952 * 3 pressed middle - right and left pressed, emulated middle sent
1953 * 4 pressed left - left pressed and sent
1954 * 5 pressed right - right pressed and sent
1955 * 6 released left - left released after emulated middle
1956 * 7 released right - right released after emulated middle
1957 * 8 repressed left - left pressed after released left
1958 * 9 repressed right - right pressed after released right
1959 * 10 pressed both - both pressed, not emulating middle
1960 *
1961 * At each state, we need handlers for the following events
1962 * 0: no buttons down
1963 * 1: left button down
1964 * 2: right button down
1965 * 3: both buttons down
1966 * 4: emulate3Timeout passed without a button change
1967 * Note that button events are not deltas, they are the set of buttons being
1968 * pressed now. It's possible (ie, mouse hardware does it) to go from (eg)
1969 * left down to right down without anything in between, so all cases must be
1970 * handled.
1971 *
1972 * a handler consists of three values:
1973 * 0: action1
1974 * 1: action2
1975 * 2: new emulation state
1976 *
1977 * action > 0: ButtonPress
1978 * action = 0: nothing
1979 * action < 0: ButtonRelease
1980 *
1981 * The comment preceeding each section is the current emulation state.
1982 * The comments to the right are of the form
1983 * <button state> (<events>) -> <new emulation state>
1984 * which should be read as
1985 * If the buttons are in <button state>, generate <events> then go to
1986 * <new emulation state>.
1987 */
1988static signed char stateTab[11][5][3] = {
1989/* 0 ground */
1990 {
1991 { 0, 0, 0 }, /* nothing -> ground (no change) */
1992 { 0, 0, 1 }, /* left -> delayed left */
1993 { 0, 0, 2 }, /* right -> delayed right */
1994 { 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
1995 { 0, 0, -1 } /* timeout N/A */
1996 },
1997/* 1 delayed left */
1998 {
1999 { 1, -1, 0 }, /* nothing (left event) -> ground */
2000 { 0, 0, 1 }, /* left -> delayed left (no change) */
2001 { 1, -1, 2 }, /* right (left event) -> delayed right */
2002 { 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
2003 { 1, 0, 4 }, /* timeout (left press) -> pressed left */
2004 },
2005/* 2 delayed right */
2006 {
2007 { 3, -3, 0 }, /* nothing (right event) -> ground */
2008 { 3, -3, 1 }, /* left (right event) -> delayed left (no change) */
2009 { 0, 0, 2 }, /* right -> delayed right (no change) */
2010 { 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
2011 { 3, 0, 5 }, /* timeout (right press) -> pressed right */
2012 },
2013/* 3 pressed middle */
2014 {
2015 { -2, 0, 0 }, /* nothing (middle release) -> ground */
2016 { 0, 0, 7 }, /* left -> released right */
2017 { 0, 0, 6 }, /* right -> released left */
2018 { 0, 0, 3 }, /* left & right -> pressed middle (no change) */
2019 { 0, 0, -1 }, /* timeout N/A */
2020 },
2021/* 4 pressed left */
2022 {
2023 { -1, 0, 0 }, /* nothing (left release) -> ground */
2024 { 0, 0, 4 }, /* left -> pressed left (no change) */
2025 { -1, 0, 2 }, /* right (left release) -> delayed right */
2026 { 3, 0, 10 }, /* left & right (right press) -> pressed both */
2027 { 0, 0, -1 }, /* timeout N/A */
2028 },
2029/* 5 pressed right */
2030 {
2031 { -3, 0, 0 }, /* nothing (right release) -> ground */
2032 { -3, 0, 1 }, /* left (right release) -> delayed left */
2033 { 0, 0, 5 }, /* right -> pressed right (no change) */
2034 { 1, 0, 10 }, /* left & right (left press) -> pressed both */
2035 { 0, 0, -1 }, /* timeout N/A */
2036 },
2037/* 6 released left */
2038 {
2039 { -2, 0, 0 }, /* nothing (middle release) -> ground */
2040 { -2, 0, 1 }, /* left (middle release) -> delayed left */
2041 { 0, 0, 6 }, /* right -> released left (no change) */
2042 { 1, 0, 8 }, /* left & right (left press) -> repressed left */
2043 { 0, 0, -1 }, /* timeout N/A */
2044 },
2045/* 7 released right */
2046 {
2047 { -2, 0, 0 }, /* nothing (middle release) -> ground */
2048 { 0, 0, 7 }, /* left -> released right (no change) */
2049 { -2, 0, 2 }, /* right (middle release) -> delayed right */
2050 { 3, 0, 9 }, /* left & right (right press) -> repressed right */
2051 { 0, 0, -1 }, /* timeout N/A */
2052 },
2053/* 8 repressed left */
2054 {
2055 { -2, -1, 0 }, /* nothing (middle release, left release) -> ground */
2056 { -2, 0, 4 }, /* left (middle release) -> pressed left */
2057 { -1, 0, 6 }, /* right (left release) -> released left */
2058 { 0, 0, 8 }, /* left & right -> repressed left (no change) */
2059 { 0, 0, -1 }, /* timeout N/A */
2060 },
2061/* 9 repressed right */
2062 {
2063 { -2, -3, 0 }, /* nothing (middle release, right release) -> ground */
2064 { -3, 0, 7 }, /* left (right release) -> released right */
2065 { -2, 0, 5 }, /* right (middle release) -> pressed right */
2066 { 0, 0, 9 }, /* left & right -> repressed right (no change) */
2067 { 0, 0, -1 }, /* timeout N/A */
2068 },
2069/* 10 pressed both */
2070 {
2071 { -1, -3, 0 }, /* nothing (left release, right release) -> ground */
2072 { -3, 0, 4 }, /* left (right release) -> pressed left */
2073 { -1, 0, 5 }, /* right (left release) -> pressed right */
2074 { 0, 0, 10 }, /* left & right -> pressed both (no change) */
2075 { 0, 0, -1 }, /* timeout N/A */
2076 },
2077};
2078
2079/*
2080 * Table to allow quick reversal of natural button mapping to correct mapping
2081 */
2082
2083/*
2084 * [JCH-96/01/21] The ALPS GlidePoint pad extends the MS protocol
2085 * with a fourth button activated by tapping the PAD.
2086 * The 2nd line corresponds to 4th button on; the drv sends
2087 * the buttons in the following map (MSBit described first) :
2088 * 0 | 4th | 1st | 2nd | 3rd
2089 * And we remap them (MSBit described first) :
2090 * 0 | 4th | 3rd | 2nd | 1st
2091 */
2092static char reverseMap[16] = { 0, 4, 2, 6,
2093 1, 5, 3, 7,
2094 8, 12, 10, 14,
2095 9, 13, 11, 15 };
2096
2097static char hitachMap[16] = { 0, 2, 1, 3,
2098 8, 10, 9, 11,
2099 4, 6, 5, 7,
2100 12, 14, 13, 15 };
2101
2102#define reverseBits(map, b) (((b) & ~0x0f) | map[(b) & 0x0f])
2103
2104static CARD32
2105buttonTimer(InputInfoPtr pInfo)
2106{
2107 MouseDevPtr pMse;
2108 int sigstate;
2109 int id;
2110
2111 pMse = pInfo->private;
2112
2113 sigstate = xf86BlockSIGIO ();
2114
2115 pMse->emulate3Pending = FALSE;
2116 if ((id = stateTab[pMse->emulateState][4][0]) != 0) {
2117 xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
2118 pMse->emulateState = stateTab[pMse->emulateState][4][2];
2119 } else {
2120 ErrorF("Got unexpected buttonTimer in state %d\n", pMse->emulateState);
2121 }
2122
2123 xf86UnblockSIGIO (sigstate);
2124 return 0;
2125}
2126
2127static Bool
2128Emulate3ButtonsSoft(InputInfoPtr pInfo)
2129{
2130 MouseDevPtr pMse = pInfo->private;
2131
2132 if (!pMse->emulate3ButtonsSoft)
2133 return TRUE;
2134
2135 pMse->emulate3Buttons = FALSE;
2136
2137 if (pMse->emulate3Pending)
2138 buttonTimer(pInfo);
2139
2140 xf86Msg(X_INFO,"3rd Button detected: disabling emulate3Button\n");
2141
2142 return FALSE;
2143}
2144
2145static void MouseBlockHandler(pointer data,
2146 struct timeval **waitTime,
2147 pointer LastSelectMask)
2148{
2149 InputInfoPtr pInfo = (InputInfoPtr) data;
2150 MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
2151 int ms;
2152
2153 if (pMse->emulate3Pending)
2154 {
2155 ms = pMse->emulate3Expires - GetTimeInMillis ();
2156 if (ms <= 0)
2157 ms = 0;
2158 AdjustWaitForDelay (waitTime, ms);
2159 }
2160}
2161
2162static void MouseWakeupHandler(pointer data,
2163 int i,
2164 pointer LastSelectMask)
2165{
2166 InputInfoPtr pInfo = (InputInfoPtr) data;
2167 MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
2168 int ms;
2169
2170 if (pMse->emulate3Pending)
2171 {
2172 ms = pMse->emulate3Expires - GetTimeInMillis ();
2173 if (ms <= 0)
2174 buttonTimer (pInfo);
2175 }
2176}
2177
2178/*******************************************************************
2179 *
2180 * Post mouse events
2181 *
2182 *******************************************************************/
2183
2184static void
2185MouseDoPostEvent(InputInfoPtr pInfo, int buttons, int dx, int dy)
2186{
2187 MouseDevPtr pMse;
2188 int emulateButtons;
2189 int id, change;
2190 int emuWheelDelta, emuWheelButton, emuWheelButtonMask;
2191 int wheelButtonMask;
2192 int ms;
2193
2194 pMse = pInfo->private;
2195
2196 change = buttons ^ pMse->lastMappedButtons;
2197 pMse->lastMappedButtons = buttons;
2198
2199 /* Do single button double click */
2200 if (pMse->doubleClickSourceButtonMask) {
2201 if (buttons & pMse->doubleClickSourceButtonMask) {
2202 if (!(pMse->doubleClickOldSourceState)) {
2203 /* double-click button has just been pressed. Ignore it if target button
2204 * is already down.
2205 */
2206 if (!(buttons & pMse->doubleClickTargetButtonMask)) {
2207 /* Target button isn't down, so send a double-click */
2208 xf86PostButtonEvent(pInfo->dev, 0, pMse->doubleClickTargetButton, 1, 0, 0);
2209 xf86PostButtonEvent(pInfo->dev, 0, pMse->doubleClickTargetButton, 0, 0, 0);
2210 xf86PostButtonEvent(pInfo->dev, 0, pMse->doubleClickTargetButton, 1, 0, 0);
2211 xf86PostButtonEvent(pInfo->dev, 0, pMse->doubleClickTargetButton, 0, 0, 0);
2212 }
2213 }
2214 pMse->doubleClickOldSourceState = 1;
2215 }
2216 else
2217 pMse->doubleClickOldSourceState = 0;
2218
2219 /* Whatever happened, mask the double-click button so it doesn't get
2220 * processed as a normal button as well.
2221 */
2222 buttons &= ~(pMse->doubleClickSourceButtonMask);
2223 change &= ~(pMse->doubleClickSourceButtonMask);
2224 }
2225
2226 if (pMse->emulateWheel) {
2227 /* Emulate wheel button handling */
2228 wheelButtonMask = 1 << (pMse->wheelButton - 1);
2229
2230 if (change & wheelButtonMask) {
2231 if (buttons & wheelButtonMask) {
2232 /* Start timeout handling */
2233 pMse->wheelButtonExpires = GetTimeInMillis () + pMse->wheelButtonTimeout;
2234 ms = - pMse->wheelButtonTimeout;
2235 } else {
2236 ms = pMse->wheelButtonExpires - GetTimeInMillis ();
2237
2238 if (0 < ms) {
2239 /*
2240 * If the button is released early enough emit the button
2241 * press/release events
2242 */
2243 xf86PostButtonEvent(pInfo->dev, 0, pMse->wheelButton, 1, 0, 0);
2244 xf86PostButtonEvent(pInfo->dev, 0, pMse->wheelButton, 0, 0, 0);
2245 }
2246 }
2247 } else
2248 ms = pMse->wheelButtonExpires - GetTimeInMillis ();
2249
2250 /* Intercept wheel emulation. */
2251 if (buttons & wheelButtonMask) {
2252 if (ms <= 0) {
2253 /* Y axis movement */
2254 if (pMse->negativeY != MSE_NOAXISMAP) {
2255 pMse->wheelYDistance += dy;
2256 if (pMse->wheelYDistance < 0) {
2257 emuWheelDelta = -pMse->wheelInertia;
2258 emuWheelButton = pMse->negativeY;
2259 } else {
2260 emuWheelDelta = pMse->wheelInertia;
2261 emuWheelButton = pMse->positiveY;
2262 }
2263 emuWheelButtonMask = 1 << (emuWheelButton - 1);
2264 while (abs(pMse->wheelYDistance) > pMse->wheelInertia) {
2265 pMse->wheelYDistance -= emuWheelDelta;
2266
2267 /*
2268 * Synthesize the press and release, but not when
2269 * the button to be synthesized is already pressed
2270 * "for real".
2271 */
2272 if (!(emuWheelButtonMask & buttons) ||
2273 (emuWheelButtonMask & wheelButtonMask)) {
2274 xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 1, 0, 0);
2275 xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 0, 0, 0);
2276 }
2277 }
2278 }
2279
2280 /* X axis movement */
2281 if (pMse->negativeX != MSE_NOAXISMAP) {
2282 pMse->wheelXDistance += dx;
2283 if (pMse->wheelXDistance < 0) {
2284 emuWheelDelta = -pMse->wheelInertia;
2285 emuWheelButton = pMse->negativeX;
2286 } else {
2287 emuWheelDelta = pMse->wheelInertia;
2288 emuWheelButton = pMse->positiveX;
2289 }
2290 emuWheelButtonMask = 1 << (emuWheelButton - 1);
2291 while (abs(pMse->wheelXDistance) > pMse->wheelInertia) {
2292 pMse->wheelXDistance -= emuWheelDelta;
2293
2294 /*
2295 * Synthesize the press and release, but not when
2296 * the button to be synthesized is already pressed
2297 * "for real".
2298 */
2299 if (!(emuWheelButtonMask & buttons) ||
2300 (emuWheelButtonMask & wheelButtonMask)) {
2301 xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 1, 0, 0);
2302 xf86PostButtonEvent(pInfo->dev, 0, emuWheelButton, 0, 0, 0);
2303 }
2304 }
2305 }
2306 }
2307
2308 /* Absorb the mouse movement while the wheel button is pressed. */
2309 dx = 0;
2310 dy = 0;
2311 }
2312 /*
2313 * Button events for the wheel button are only emitted through
2314 * the timeout code.
2315 */
2316 buttons &= ~wheelButtonMask;
2317 change &= ~wheelButtonMask;
2318 }
2319
2320 if (pMse->emulate3ButtonsSoft && pMse->emulate3Pending && (dx || dy))
2321 buttonTimer(pInfo);
2322
2323#ifdef VBOX
2324 if (dx || dy)
2325 {
2326 mousePrivPtr pPriv = pMse->mousePriv;
2327 if (pPriv && pPriv->pScrn)
2328 {
2329 unsigned int abs_x;
2330 unsigned int abs_y;
2331 if (VBoxMouseQueryPosition(&abs_x, &abs_y) == 0)
2332 {
2333 /* convert to screen resolution */
2334 int x, y;
2335 x = (abs_x * pPriv->pScrn->width) / 65535;
2336 y = (abs_y * pPriv->pScrn->height) / 65535;
2337 /* send absolute movement */
2338 xf86PostMotionEvent(pInfo->dev, 1, 0, 2, x, y);
2339 }
2340 else
2341 {
2342 /* send relative event */
2343 xf86PostMotionEvent(pInfo->dev, 0, 0, 2, dx, dy);
2344 }
2345 }
2346 else
2347 {
2348 /* send relative event */
2349 xf86PostMotionEvent(pInfo->dev, 0, 0, 2, dx, dy);
2350 }
2351 }
2352#else
2353 if (dx || dy)
2354 xf86PostMotionEvent(pInfo->dev, 0, 0, 2, dx, dy);
2355#endif
2356
2357 if (change) {
2358
2359 /*
2360 * adjust buttons state for drag locks!
2361 * if there is drag locks
2362 */
2363 if (pMse->pDragLock) {
2364 DragLockPtr pLock;
2365 int tarOfGoingDown, tarOfDown;
2366 int realbuttons;
2367
2368 /* get drag lock block */
2369 pLock = pMse->pDragLock;
2370 /* save real buttons */
2371 realbuttons = buttons;
2372
2373 /* if drag lock used */
2374
2375 /* state of drag lock buttons not seen always up */
2376
2377 buttons &= ~pLock->lockButtonsM;
2378
2379 /*
2380 * if lock buttons being depressed changes state of
2381 * targets simulatedDown.
2382 */
2383 tarOfGoingDown = lock2targetMap(pLock,
2384 realbuttons & change & pLock->lockButtonsM);
2385 pLock->simulatedDown ^= tarOfGoingDown;
2386
2387 /* targets of drag locks down */
2388 tarOfDown = lock2targetMap(pLock,
2389 realbuttons & pLock->lockButtonsM);
2390
2391 /*
2392 * when simulatedDown set and target pressed,
2393 * simulatedDown goes false
2394 */
2395 pLock->simulatedDown &= ~(realbuttons & change);
2396
2397 /*
2398 * if master drag lock released
2399 * then master drag lock state on
2400 */
2401 pLock->masterTS |= (~realbuttons & change) & pLock->masterLockM;
2402
2403 /* if master state, buttons going down are simulatedDown */
2404 if (pLock->masterTS)
2405 pLock->simulatedDown |= (realbuttons & change);
2406
2407 /* if any button pressed, no longer in master drag lock state */
2408 if (realbuttons & change)
2409 pLock->masterTS = 0;
2410
2411 /* if simulatedDown or drag lock down, simulate down */
2412 buttons |= (pLock->simulatedDown | tarOfDown);
2413
2414 /* master button not seen */
2415 buttons &= ~(pLock->masterLockM);
2416
2417 /* buttons changed since last time */
2418 change = buttons ^ pLock->lockLastButtons;
2419
2420 /* save this time for next last time. */
2421 pLock->lockLastButtons = buttons;
2422 }
2423
2424 if (pMse->emulate3Buttons
2425 && (!(buttons & 0x02) || Emulate3ButtonsSoft(pInfo))) {
2426
2427 /* handle all but buttons 1 & 3 normally */
2428
2429 change &= ~05;
2430
2431 /* emulate the third button by the other two */
2432
2433 emulateButtons = (buttons & 01) | ((buttons &04) >> 1);
2434
2435 if ((id = stateTab[pMse->emulateState][emulateButtons][0]) != 0)
2436 xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
2437 if ((id = stateTab[pMse->emulateState][emulateButtons][1]) != 0)
2438 xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
2439
2440 pMse->emulateState =
2441 stateTab[pMse->emulateState][emulateButtons][2];
2442
2443 if (stateTab[pMse->emulateState][4][0] != 0) {
2444 pMse->emulate3Expires = GetTimeInMillis () + pMse->emulate3Timeout;
2445 pMse->emulate3Pending = TRUE;
2446 } else {
2447 pMse->emulate3Pending = FALSE;
2448 }
2449 }
2450
2451 while (change) {
2452 id = ffs(change);
2453 change &= ~(1 << (id - 1));
2454 xf86PostButtonEvent(pInfo->dev, 0, id,
2455 (buttons & (1 << (id - 1))), 0, 0);
2456 }
2457
2458 }
2459}
2460
2461static void
2462MousePostEvent(InputInfoPtr pInfo, int truebuttons,
2463 int dx, int dy, int dz, int dw)
2464{
2465 MouseDevPtr pMse;
2466 int zbutton = 0;
2467 int i, b, buttons = 0;
2468
2469 pMse = pInfo->private;
2470 if (pMse->protocolID == PROT_MMHIT)
2471 b = reverseBits(hitachMap, truebuttons);
2472 else
2473 b = reverseBits(reverseMap, truebuttons);
2474
2475 /* Remap mouse buttons */
2476 b &= (1<<MSE_MAXBUTTONS)-1;
2477 for (i = 0; b; i++) {
2478 if (b & 1)
2479 buttons |= pMse->buttonMap[i];
2480 b >>= 1;
2481 }
2482
2483 /* Map the Z axis movement. */
2484 /* XXX Could this go in the conversion_proc? */
2485 switch (pMse->negativeZ) {
2486 case MSE_NOZMAP: /* do nothing */
2487 break;
2488 case MSE_MAPTOX:
2489 if (dz != 0) {
2490 dx = dz;
2491 dz = 0;
2492 }
2493 break;
2494 case MSE_MAPTOY:
2495 if (dz != 0) {
2496 dy = dz;
2497 dz = 0;
2498 }
2499 break;
2500 default: /* buttons */
2501 buttons &= ~(pMse->negativeZ | pMse->positiveZ
2502 | pMse->negativeW | pMse->positiveW);
2503 if (dw < 0 || dz < -1)
2504 zbutton = pMse->negativeW;
2505 else if (dz < 0)
2506 zbutton = pMse->negativeZ;
2507 else if (dw > 0 || dz > 1)
2508 zbutton = pMse->positiveW;
2509 else if (dz > 0)
2510 zbutton = pMse->positiveZ;
2511 buttons |= zbutton;
2512 dz = 0;
2513 break;
2514 }
2515
2516 /* Apply angle offset */
2517 if (pMse->angleOffset != 0) {
2518 double rad = 3.141592653 * pMse->angleOffset / 180.0;
2519 int ndx = dx;
2520 dx = (int)((dx * cos(rad)) + (dy * sin(rad)) + 0.5);
2521 dy = (int)((dy * cos(rad)) - (ndx * sin(rad)) + 0.5);
2522 }
2523
2524 dx = pMse->invX * dx;
2525 dy = pMse->invY * dy;
2526 if (pMse->flipXY) {
2527 int tmp = dx;
2528 dx = dy;
2529 dy = tmp;
2530 }
2531 MouseDoPostEvent(pInfo, buttons, dx, dy);
2532
2533 /*
2534 * If dz has been mapped to a button `down' event, we need to cook up
2535 * a corresponding button `up' event.
2536 */
2537 if (zbutton) {
2538 buttons &= ~zbutton;
2539 MouseDoPostEvent(pInfo, buttons, 0, 0);
2540 }
2541
2542 pMse->lastButtons = truebuttons;
2543}
2544/******************************************************************
2545 *
2546 * Mouse Setup Code
2547 *
2548 ******************************************************************/
2549/*
2550 * This array is indexed by the MouseProtocolID values, so the order of the
2551 * entries must match that of the MouseProtocolID enum in xf86OSmouse.h.
2552 */
2553static unsigned char proto[PROT_NUMPROTOS][8] = {
2554 /* --header-- ---data--- packet -4th-byte- mouse */
2555 /* mask id mask id bytes mask id flags */
2556 /* Serial mice */
2557 { 0x40, 0x40, 0x40, 0x00, 3, ~0x23, 0x00, MPF_NONE }, /* MicroSoft */
2558 { 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff, MPF_SAFE }, /* MouseSystems */
2559 { 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* MMSeries */
2560 { 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* Logitech */
2561 { 0x40, 0x40, 0x40, 0x00, 3, ~0x23, 0x00, MPF_NONE }, /* MouseMan */
2562 { 0xe0, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* MM_HitTablet */
2563 { 0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00, MPF_NONE }, /* GlidePoint */
2564 { 0x40, 0x40, 0x40, 0x00, 3, ~0x3f, 0x00, MPF_NONE }, /* IntelliMouse */
2565 { 0x40, 0x40, 0x40, 0x00, 3, ~0x33, 0x00, MPF_NONE }, /* ThinkingMouse */
2566 { 0x80, 0x80, 0x80, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* ACECAD */
2567 { 0x40, 0x40, 0x40, 0x00, 4, 0x00, 0xff, MPF_NONE }, /* ValuMouseScroll */
2568 /* PS/2 variants */
2569 { 0xc0, 0x00, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* PS/2 mouse */
2570 { 0xc8, 0x08, 0x00, 0x00, 3, 0x00, 0x00, MPF_NONE }, /* genericPS/2 mouse*/
2571 { 0x08, 0x08, 0x00, 0x00, 4, 0x00, 0xff, MPF_NONE }, /* IntelliMouse */
2572 { 0x08, 0x08, 0x00, 0x00, 4, 0x00, 0xff, MPF_NONE }, /* Explorer */
2573 { 0x80, 0x80, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* ThinkingMouse */
2574 { 0x08, 0x08, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* MouseMan+ */
2575 { 0xc0, 0x00, 0x00, 0x00, 3, 0x00, 0xff, MPF_NONE }, /* GlidePoint */
2576 { 0x08, 0x08, 0x00, 0x00, 4, 0x00, 0xff, MPF_NONE }, /* NetMouse */
2577 { 0xc0, 0x00, 0x00, 0x00, 6, 0x00, 0xff, MPF_NONE }, /* NetScroll */
2578 /* Bus Mouse */
2579 { 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff, MPF_NONE }, /* BusMouse */
2580 { 0xf8, 0x80, 0x00, 0x00, 5, 0x00, 0xff, MPF_NONE }, /* Auto (dummy) */
2581 { 0xf8, 0x80, 0x00, 0x00, 8, 0x00, 0xff, MPF_NONE }, /* SysMouse */
2582};
2583
2584
2585/*
2586 * SetupMouse --
2587 * Sets up the mouse parameters
2588 */
2589static Bool
2590SetupMouse(InputInfoPtr pInfo)
2591{
2592 MouseDevPtr pMse;
2593 int i;
2594 int protoPara[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
2595 const char *name = NULL;
2596 Bool automatic = FALSE;
2597
2598 pMse = pInfo->private;
2599
2600 /* Handle the "Auto" protocol. */
2601 if (pMse->protocolID == PROT_AUTO) {
2602 /*
2603 * We come here when user specifies protocol "auto" in
2604 * the configuration file or thru the xf86misc extensions.
2605 * So we initialize autoprobing here.
2606 * Probe for PnP/OS mouse first. If unsuccessful
2607 * try to guess protocol from incoming data.
2608 */
2609 automatic = TRUE;
2610 pMse->autoProbe = TRUE;
2611 name = autoOSProtocol(pInfo,protoPara);
2612 if (name) {
2613#ifdef EXTMOUSEDEBUG
2614 ErrorF("PnP/OS Mouse detected: %s\n",name);
2615#endif
2616 }
2617 }
2618
2619 SetMouseProto(pMse, pMse->protocolID);
2620
2621 if (automatic) {
2622 if (name) {
2623 /* Possible protoPara overrides from SetupAuto. */
2624 for (i = 0; i < sizeof(pMse->protoPara); i++)
2625 if (protoPara[i] != -1)
2626 pMse->protoPara[i] = protoPara[i];
2627 /* if we come here PnP/OS mouse probing was successful */
2628 } else {
2629#if 1
2630 /* PnP/OS mouse probing wasn't successful; we look at data */
2631#else
2632 xf86Msg(X_ERROR, "%s: cannot determine the mouse protocol\n",
2633 pInfo->name);
2634 return FALSE;
2635#endif
2636 }
2637 }
2638
2639 /*
2640 * If protocol has changed fetch the default options
2641 * for the new protocol.
2642 */
2643 if (pMse->oldProtocolID != pMse->protocolID) {
2644 pointer tmp = NULL;
2645 if ((pMse->protocolID >= 0)
2646 && (pMse->protocolID < PROT_NUMPROTOS)
2647 && mouseProtocols[pMse->protocolID].defaults)
2648 tmp = xf86OptionListCreate(
2649 mouseProtocols[pMse->protocolID].defaults, -1, 0);
2650 pInfo->options = xf86OptionListMerge(pInfo->options, tmp);
2651 /*
2652 * If baudrate is set write it back to the option
2653 * list so that the serial interface code can access
2654 * the new value. Not set means default.
2655 */
2656 if (pMse->baudRate)
2657 xf86ReplaceIntOption(pInfo->options, "BaudRate", pMse->baudRate);
2658 pMse->oldProtocolID = pMse->protocolID; /* hack */
2659 }
2660
2661
2662 /* Set the port parameters. */
2663 if (!automatic)
2664 xf86SetSerial(pInfo->fd, pInfo->options);
2665
2666 if (!initMouseHW(pInfo))
2667 return FALSE;
2668
2669 pMse->protoBufTail = 0;
2670 pMse->inSync = 0;
2671
2672 return TRUE;
2673}
2674
2675/********************************************************************
2676 *
2677 * Mouse HW setup code
2678 *
2679 ********************************************************************/
2680
2681/*
2682** The following lines take care of the Logitech MouseMan protocols.
2683** The "Logitech" protocol is for the old "series 9" Logitech products.
2684** All products since then use the "MouseMan" protocol. Some models
2685** were programmable, but most (all?) of the current models are not.
2686**
2687** NOTE: There are different versions of both MouseMan and TrackMan!
2688** Hence I add another protocol PROT_LOGIMAN, which the user can
2689** specify as MouseMan in his XF86Config file. This entry was
2690** formerly handled as a special case of PROT_MS. However, people
2691** who don't have the middle button problem, can still specify
2692** Microsoft and use PROT_MS.
2693**
2694** By default, these mice should use a 3 byte Microsoft protocol
2695** plus a 4th byte for the middle button. However, the mouse might
2696** have switched to a different protocol before we use it, so I send
2697** the proper sequence just in case.
2698**
2699** NOTE: - all commands to (at least the European) MouseMan have to
2700** be sent at 1200 Baud.
2701** - each command starts with a '*'.
2702** - whenever the MouseMan receives a '*', it will switch back
2703** to 1200 Baud. Hence I have to select the desired protocol
2704** first, then select the baud rate.
2705**
2706** The protocols supported by the (European) MouseMan are:
2707** - 5 byte packed binary protocol, as with the Mouse Systems
2708** mouse. Selected by sequence "*U".
2709** - 2 button 3 byte MicroSoft compatible protocol. Selected
2710** by sequence "*V".
2711** - 3 button 3+1 byte MicroSoft compatible protocol (default).
2712** Selected by sequence "*X".
2713**
2714** The following baud rates are supported:
2715** - 1200 Baud (default). Selected by sequence "*n".
2716** - 9600 Baud. Selected by sequence "*q".
2717**
2718** Selecting a sample rate is no longer supported with the MouseMan!
2719** [CHRIS-211092]
2720*/
2721
2722/*
2723 * Do a reset wrap mode before reset.
2724 */
2725#define do_ps2Reset(x) { \
2726 int i = RETRY_COUNT;\
2727 while (i-- > 0) { \
2728 xf86FlushInput(x->fd); \
2729 if (ps2Reset(x)) break; \
2730 } \
2731 }
2732
2733
2734static Bool
2735initMouseHW(InputInfoPtr pInfo)
2736{
2737 MouseDevPtr pMse = pInfo->private;
2738 const char *s;
2739 unsigned char c;
2740 int speed;
2741 pointer options;
2742 unsigned char *param = NULL;
2743 int paramlen = 0;
2744 int count = RETRY_COUNT;
2745 Bool ps2Init = TRUE;
2746
2747 switch (pMse->protocolID) {
2748 case PROT_LOGI: /* Logitech Mice */
2749 /*
2750 * The baud rate selection command must be sent at the current
2751 * baud rate; try all likely settings.
2752 */
2753 speed = pMse->baudRate;
2754 switch (speed) {
2755 case 9600:
2756 s = "*q";
2757 break;
2758 case 4800:
2759 s = "*p";
2760 break;
2761 case 2400:
2762 s = "*o";
2763 break;
2764 case 1200:
2765 s = "*n";
2766 break;
2767 default:
2768 /* Fallback value */
2769 speed = 1200;
2770 s = "*n";
2771 }
2772 xf86SetSerialSpeed(pInfo->fd, 9600);
2773 xf86WriteSerial(pInfo->fd, s, 2);
2774 usleep(100000);
2775 xf86SetSerialSpeed(pInfo->fd, 4800);
2776 xf86WriteSerial(pInfo->fd, s, 2);
2777 usleep(100000);
2778 xf86SetSerialSpeed(pInfo->fd, 2400);
2779 xf86WriteSerial(pInfo->fd, s, 2);
2780 usleep(100000);
2781 xf86SetSerialSpeed(pInfo->fd, 1200);
2782 xf86WriteSerial(pInfo->fd, s, 2);
2783 usleep(100000);
2784 xf86SetSerialSpeed(pInfo->fd, speed);
2785
2786 /* Select MM series data format. */
2787 xf86WriteSerial(pInfo->fd, "S", 1);
2788 usleep(100000);
2789 /* Set the parameters up for the MM series protocol. */
2790 options = pInfo->options;
2791 xf86CollectInputOptions(pInfo, mmDefaults, NULL);
2792 xf86SetSerial(pInfo->fd, pInfo->options);
2793 pInfo->options = options;
2794
2795 /* Select report rate/frequency. */
2796 if (pMse->sampleRate <= 0) c = 'O'; /* 100 */
2797 else if (pMse->sampleRate <= 15) c = 'J'; /* 10 */
2798 else if (pMse->sampleRate <= 27) c = 'K'; /* 20 */
2799 else if (pMse->sampleRate <= 42) c = 'L'; /* 35 */
2800 else if (pMse->sampleRate <= 60) c = 'R'; /* 50 */
2801 else if (pMse->sampleRate <= 85) c = 'M'; /* 67 */
2802 else if (pMse->sampleRate <= 125) c = 'Q'; /* 100 */
2803 else c = 'N'; /* 150 */
2804 xf86WriteSerial(pInfo->fd, &c, 1);
2805 break;
2806
2807 case PROT_LOGIMAN:
2808 speed = pMse->baudRate;
2809 switch (speed) {
2810 case 9600:
2811 s = "*q";
2812 break;
2813 case 1200:
2814 s = "*n";
2815 break;
2816 default:
2817 /* Fallback value */
2818 speed = 1200;
2819 s = "*n";
2820 }
2821 xf86SetSerialSpeed(pInfo->fd, 1200);
2822 xf86WriteSerial(pInfo->fd, "*n", 2);
2823 xf86WriteSerial(pInfo->fd, "*X", 2);
2824 xf86WriteSerial(pInfo->fd, s, 2);
2825 usleep(100000);
2826 xf86SetSerialSpeed(pInfo->fd, speed);
2827 break;
2828
2829 case PROT_MMHIT: /* MM_HitTablet */
2830 /*
2831 * Initialize Hitachi PUMA Plus - Model 1212E to desired settings.
2832 * The tablet must be configured to be in MM mode, NO parity,
2833 * Binary Format. pMse->sampleRate controls the sensitivity
2834 * of the tablet. We only use this tablet for it's 4-button puck
2835 * so we don't run in "Absolute Mode".
2836 */
2837 xf86WriteSerial(pInfo->fd, "z8", 2); /* Set Parity = "NONE" */
2838 usleep(50000);
2839 xf86WriteSerial(pInfo->fd, "zb", 2); /* Set Format = "Binary" */
2840 usleep(50000);
2841 xf86WriteSerial(pInfo->fd, "@", 1); /* Set Report Mode = "Stream" */
2842 usleep(50000);
2843 xf86WriteSerial(pInfo->fd, "R", 1); /* Set Output Rate = "45 rps" */
2844 usleep(50000);
2845 xf86WriteSerial(pInfo->fd, "I\x20", 2); /* Set Incrememtal Mode "20" */
2846 usleep(50000);
2847 xf86WriteSerial(pInfo->fd, "E", 1); /* Set Data Type = "Relative */
2848 usleep(50000);
2849 /*
2850 * These sample rates translate to 'lines per inch' on the Hitachi
2851 * tablet.
2852 */
2853 if (pMse->sampleRate <= 40) c = 'g';
2854 else if (pMse->sampleRate <= 100) c = 'd';
2855 else if (pMse->sampleRate <= 200) c = 'e';
2856 else if (pMse->sampleRate <= 500) c = 'h';
2857 else if (pMse->sampleRate <= 1000) c = 'j';
2858 else c = 'd';
2859 xf86WriteSerial(pInfo->fd, &c, 1);
2860 usleep(50000);
2861 xf86WriteSerial(pInfo->fd, "\021", 1); /* Resume DATA output */
2862 break;
2863
2864 case PROT_THINKING: /* ThinkingMouse */
2865 /* This mouse may send a PnP ID string, ignore it. */
2866 usleep(200000);
2867 xf86FlushInput(pInfo->fd);
2868 /* Send the command to initialize the beast. */
2869 for (s = "E5E5"; *s; ++s) {
2870 xf86WriteSerial(pInfo->fd, s, 1);
2871 if ((xf86WaitForInput(pInfo->fd, 1000000) <= 0))
2872 break;
2873 xf86ReadSerial(pInfo->fd, &c, 1);
2874 if (c != *s)
2875 break;
2876 }
2877 break;
2878
2879 case PROT_MSC: /* MouseSystems Corp */
2880 usleep(100000);
2881 xf86FlushInput(pInfo->fd);
2882 break;
2883
2884 case PROT_ACECAD:
2885 /* initialize */
2886 /* A nul character resets. */
2887 xf86WriteSerial(pInfo->fd, "", 1);
2888 usleep(50000);
2889 /* Stream out relative mode high resolution increments of 1. */
2890 xf86WriteSerial(pInfo->fd, "@EeI!", 5);
2891 break;
2892
2893 case PROT_BM: /* bus/InPort mouse */
2894 if (osInfo->SetBMRes)
2895 osInfo->SetBMRes(pInfo, pMse->protocol, pMse->sampleRate,
2896 pMse->resolution);
2897 break;
2898
2899 case PROT_GENPS2:
2900 ps2Init = FALSE;
2901 break;
2902
2903 case PROT_PS2:
2904 case PROT_GLIDEPS2:
2905 break;
2906
2907 case PROT_IMPS2: /* IntelliMouse */
2908 {
2909 static unsigned char seq[] = { 243, 200, 243, 100, 243, 80 };
2910 param = seq;
2911 paramlen = sizeof(seq);
2912 }
2913 break;
2914
2915 case PROT_EXPPS2: /* IntelliMouse Explorer */
2916 {
2917 static unsigned char seq[] = { 243, 200, 243, 100, 243, 80,
2918 243, 200, 243, 200, 243, 80 };
2919
2920 param = seq;
2921 paramlen = sizeof(seq);
2922 }
2923 break;
2924
2925 case PROT_NETPS2: /* NetMouse, NetMouse Pro, Mie Mouse */
2926 case PROT_NETSCPS2: /* NetScroll */
2927 {
2928 static unsigned char seq[] = { 232, 3, 230, 230, 230, 233 };
2929
2930 param = seq;
2931 paramlen = sizeof(seq);
2932 }
2933 break;
2934
2935 case PROT_MMPS2: /* MouseMan+, FirstMouse+ */
2936 {
2937 static unsigned char seq[] = { 230, 232, 0, 232, 3, 232, 2, 232, 1,
2938 230, 232, 3, 232, 1, 232, 2, 232, 3 };
2939 param = seq;
2940 paramlen = sizeof(seq);
2941 }
2942 break;
2943
2944 case PROT_THINKPS2: /* ThinkingMouse */
2945 {
2946 static unsigned char seq[] = { 243, 10, 232, 0, 243, 20, 243, 60,
2947 243, 40, 243, 20, 243, 20, 243, 60,
2948 243, 40, 243, 20, 243, 20 };
2949 param = seq;
2950 paramlen = sizeof(seq);
2951 }
2952 break;
2953 case PROT_SYSMOUSE:
2954 if (osInfo->SetMiscRes)
2955 osInfo->SetMiscRes(pInfo, pMse->protocol, pMse->sampleRate,
2956 pMse->resolution);
2957 break;
2958
2959 default:
2960 /* Nothing to do. */
2961 break;
2962 }
2963
2964 if (pMse->class & (MSE_PS2 | MSE_XPS2)) {
2965 /*
2966 * If one part of the PS/2 mouse initialization fails
2967 * redo complete initialization. There are mice which
2968 * have occasional problems with initialization and
2969 * are in an unknown state.
2970 */
2971 if (ps2Init) {
2972 REDO:
2973 do_ps2Reset(pInfo);
2974 if (paramlen > 0) {
2975 if (!ps2SendPacket(pInfo,param,paramlen)) {
2976 usleep(30000);
2977 xf86FlushInput(pInfo->fd);
2978 if (!count--)
2979 return TRUE;
2980 goto REDO;
2981 }
2982 ps2GetDeviceID(pInfo);
2983 usleep(30000);
2984 xf86FlushInput(pInfo->fd);
2985 }
2986
2987 if (osInfo->SetPS2Res) {
2988 osInfo->SetPS2Res(pInfo, pMse->protocol, pMse->sampleRate,
2989 pMse->resolution);
2990 } else {
2991 unsigned char c2[2];
2992
2993 c = 0xE6; /*230*/ /* 1:1 scaling */
2994 if (!ps2SendPacket(pInfo,&c,1)) {
2995 if (!count--)
2996 return TRUE;
2997 goto REDO;
2998 }
2999 c2[0] = 0xF3; /*243*/ /* set sampling rate */
3000 if (pMse->sampleRate > 0) {
3001 if (pMse->sampleRate >= 200)
3002 c2[1] = 200;
3003 else if (pMse->sampleRate >= 100)
3004 c2[1] = 100;
3005 else if (pMse->sampleRate >= 80)
3006 c2[1] = 80;
3007 else if (pMse->sampleRate >= 60)
3008 c2[1] = 60;
3009 else if (pMse->sampleRate >= 40)
3010 c2[1] = 40;
3011 else
3012 c2[1] = 20;
3013 } else {
3014 c2[1] = 100;
3015 }
3016 if (!ps2SendPacket(pInfo,c2,2)) {
3017 if (!count--)
3018 return TRUE;
3019 goto REDO;
3020 }
3021 c2[0] = 0xE8; /*232*/ /* set device resolution */
3022 if (pMse->resolution > 0) {
3023 if (pMse->resolution >= 200)
3024 c2[1] = 3;
3025 else if (pMse->resolution >= 100)
3026 c2[1] = 2;
3027 else if (pMse->resolution >= 50)
3028 c2[1] = 1;
3029 else
3030 c2[1] = 0;
3031 } else {
3032 c2[1] = 3; /* used to be 2, W. uses 3 */
3033 }
3034 if (!ps2SendPacket(pInfo,c2,2)) {
3035 if (!count--)
3036 return TRUE;
3037 goto REDO;
3038 }
3039 usleep(30000);
3040 xf86FlushInput(pInfo->fd);
3041 if (!ps2EnableDataReporting(pInfo)) {
3042 xf86Msg(X_INFO, "%s: ps2EnableDataReporting: failed\n",
3043 pInfo->name);
3044 xf86FlushInput(pInfo->fd);
3045 if (!count--)
3046 return TRUE;
3047 goto REDO;
3048 } else {
3049 xf86Msg(X_INFO, "%s: ps2EnableDataReporting: succeeded\n",
3050 pInfo->name);
3051 }
3052 }
3053 /*
3054 * The PS/2 reset handling needs to be rechecked.
3055 * We need to wait until after the 4.3 release.
3056 */
3057 }
3058 } else {
3059 if (paramlen > 0) {
3060 if (xf86WriteSerial(pInfo->fd, param, paramlen) != paramlen)
3061 xf86Msg(X_ERROR, "%s: Mouse initialization failed\n",
3062 pInfo->name);
3063 usleep(30000);
3064 xf86FlushInput(pInfo->fd);
3065 }
3066 }
3067
3068 return TRUE;
3069}
3070
3071#ifdef SUPPORT_MOUSE_RESET
3072static Bool
3073mouseReset(InputInfoPtr pInfo, unsigned char val)
3074{
3075 MouseDevPtr pMse = pInfo->private;
3076 mousePrivPtr mousepriv = (mousePrivPtr)pMse->mousePriv;
3077 CARD32 prevEvent = mousepriv->lastEvent;
3078 Bool expectReset = FALSE;
3079 Bool ret = FALSE;
3080
3081 mousepriv->lastEvent = GetTimeInMillis();
3082
3083#ifdef EXTMOUSEDEBUG
3084 ErrorF("byte: 0x%x time: %li\n",val,mousepriv->lastEvent);
3085#endif
3086 /*
3087 * We believe that the following is true:
3088 * When the mouse is replugged it will send a reset package
3089 * It takes several seconds to replug a mouse: We don't see
3090 * events for several seconds before we see the replug event package.
3091 * There is no significant delay between consecutive bytes
3092 * of a replug event package.
3093 * There are no bytes sent after the replug event package until
3094 * the mouse is reset.
3095 */
3096
3097 if (mousepriv->current == 0
3098 && (mousepriv->lastEvent - prevEvent) < 4000)
3099 return FALSE;
3100
3101 if (mousepriv->current > 0
3102 && (mousepriv->lastEvent - prevEvent) >= 1000) {
3103 mousepriv->inReset = FALSE;
3104 mousepriv->current = 0;
3105 return FALSE;
3106 }
3107
3108 if (mousepriv->inReset)
3109 mousepriv->inReset = FALSE;
3110
3111#ifdef EXTMOUSEDEBUG
3112 ErrorF("Mouse Current: %i 0x%x\n",mousepriv->current, val);
3113#endif
3114
3115 /* here we put the mouse specific reset detction */
3116 /* They need to do three things: */
3117 /* Check if byte may be a reset byte */
3118 /* If so: Set expectReset TRUE */
3119 /* If convinced: Set inReset TRUE */
3120 /* Register BlockAndWakeupHandler */
3121
3122 /* PS/2 */
3123 {
3124 unsigned char seq[] = { 0xaa, 0x00 };
3125 int len = sizeof(seq);
3126
3127 if (seq[mousepriv->current] == val)
3128 expectReset = TRUE;
3129
3130 if (len == mousepriv->current + 1) {
3131 mousepriv->inReset = TRUE;
3132 mousepriv->expires = GetTimeInMillis() + 1000;
3133
3134#ifdef EXTMOUSEDEBUG
3135 ErrorF("Found PS/2 Reset string\n");
3136#endif
3137 RegisterBlockAndWakeupHandlers (ps2BlockHandler,
3138 ps2WakeupHandler, (pointer) pInfo);
3139 ret = TRUE;
3140 }
3141 }
3142
3143 if (!expectReset)
3144 mousepriv->current = 0;
3145 else
3146 mousepriv->current++;
3147 return ret;
3148}
3149
3150static void
3151ps2BlockHandler(pointer data, struct timeval **waitTime,
3152 pointer LastSelectMask)
3153{
3154 InputInfoPtr pInfo = (InputInfoPtr) data;
3155 MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
3156 mousePrivPtr mousepriv = (mousePrivPtr)pMse->mousePriv;
3157 int ms;
3158
3159 if (mousepriv->inReset) {
3160 ms = mousepriv->expires - GetTimeInMillis ();
3161 if (ms <= 0)
3162 ms = 0;
3163 AdjustWaitForDelay (waitTime, ms);
3164 } else
3165 RemoveBlockAndWakeupHandlers (ps2BlockHandler, ps2WakeupHandler,
3166 (pointer) pInfo);
3167}
3168
3169static void
3170ps2WakeupHandler(pointer data, int i, pointer LastSelectMask)
3171{
3172 InputInfoPtr pInfo = (InputInfoPtr) data;
3173 MouseDevPtr pMse = (MouseDevPtr) pInfo->private;
3174 mousePrivPtr mousepriv = (mousePrivPtr)pMse->mousePriv;
3175 int ms;
3176
3177 if (mousepriv->inReset) {
3178 unsigned char val;
3179 int blocked;
3180
3181 ms = mousepriv->expires - GetTimeInMillis();
3182 if (ms > 0)
3183 return;
3184
3185 blocked = xf86BlockSIGIO ();
3186
3187 xf86MsgVerb(X_INFO,3,
3188 "Got reinsert event: reinitializing PS/2 mouse\n");
3189 val = 0xf4;
3190 if (xf86WriteSerial(pInfo->fd, &val, 1) != 1)
3191 xf86Msg(X_ERROR, "%s: Write to mouse failed\n",
3192 pInfo->name);
3193 xf86UnblockSIGIO(blocked);
3194 }
3195 RemoveBlockAndWakeupHandlers (ps2BlockHandler, ps2WakeupHandler,
3196 (pointer) pInfo);
3197}
3198#endif /* SUPPORT_MOUSE_RESET */
3199
3200/************************************************************
3201 *
3202 * Autoprobe stuff
3203 *
3204 ************************************************************/
3205#ifdef EXTMOUSEDEBUG
3206# define AP_DBG(x) { ErrorF("Autoprobe: "); ErrorF x; }
3207# define AP_DBGC(x) ErrorF x ;
3208# else
3209# define AP_DBG(x)
3210# define AP_DBGC(x)
3211#endif
3212
3213MouseProtocolID hardProtocolList[] = { PROT_MSC, PROT_MM, PROT_LOGI,
3214 PROT_LOGIMAN, PROT_MMHIT,
3215 PROT_GLIDE, PROT_IMSERIAL,
3216 PROT_THINKING, PROT_ACECAD,
3217 PROT_THINKPS2, PROT_MMPS2,
3218 PROT_GLIDEPS2,
3219 PROT_NETSCPS2, PROT_EXPPS2,PROT_IMPS2,
3220 PROT_GENPS2, PROT_NETPS2,
3221 PROT_MS,
3222 PROT_UNKNOWN
3223};
3224
3225MouseProtocolID softProtocolList[] = { PROT_MSC, PROT_MM, PROT_LOGI,
3226 PROT_LOGIMAN, PROT_MMHIT,
3227 PROT_GLIDE, PROT_IMSERIAL,
3228 PROT_THINKING, PROT_ACECAD,
3229 PROT_THINKPS2, PROT_MMPS2,
3230 PROT_GLIDEPS2,
3231 PROT_NETSCPS2 ,PROT_IMPS2,
3232 PROT_GENPS2,
3233 PROT_MS,
3234 PROT_UNKNOWN
3235};
3236
3237static const char *
3238autoOSProtocol(InputInfoPtr pInfo, int *protoPara)
3239{
3240 MouseDevPtr pMse = pInfo->private;
3241 const char *name = NULL;
3242 MouseProtocolID protocolID = PROT_UNKNOWN;
3243
3244 /* Check if the OS has a detection mechanism. */
3245 if (osInfo->SetupAuto) {
3246 name = osInfo->SetupAuto(pInfo, protoPara);
3247 if (name) {
3248 protocolID = ProtocolNameToID(name);
3249 switch (protocolID) {
3250 case PROT_UNKNOWN:
3251 /* Check for a builtin OS-specific protocol. */
3252 if (osInfo->CheckProtocol && osInfo->CheckProtocol(name)) {
3253 /* We can only come here if the protocol has been
3254 * changed to auto thru the xf86misc extension
3255 * and we have detected an OS specific builtin
3256 * protocol. Currently we cannot handle this */
3257 name = NULL;
3258 } else
3259 name = NULL;
3260 break;
3261 case PROT_UNSUP:
3262 name = NULL;
3263 break;
3264 default:
3265 break;
3266 }
3267 }
3268 }
3269 if (!name) {
3270 /* A PnP serial mouse? */
3271 protocolID = MouseGetPnpProtocol(pInfo);
3272 if (protocolID >= 0 && protocolID < PROT_NUMPROTOS) {
3273 name = ProtocolIDToName(protocolID);
3274 xf86Msg(X_PROBED, "%s: PnP-detected protocol: \"%s\"\n",
3275 pInfo->name, name);
3276 }
3277 }
3278 if (!name && HAVE_GUESS_PROTOCOL && osInfo->GuessProtocol) {
3279 name = osInfo->GuessProtocol(pInfo, 0);
3280 if (name)
3281 protocolID = ProtocolNameToID(name);
3282 }
3283
3284 if (name) {
3285 pMse->protocolID = protocolID;
3286 }
3287
3288 return name;
3289}
3290
3291/*
3292 * createProtocolList() -- create a list of protocols which may
3293 * match on the incoming data stream.
3294 */
3295static void
3296createProtoList(MouseDevPtr pMse, MouseProtocolID *protoList)
3297{
3298 int i, j, k = 0;
3299 MouseProtocolID prot;
3300 unsigned char *para;
3301 mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
3302 MouseProtocolID *tmplist = NULL;
3303 int blocked;
3304
3305 AP_DBGC(("Autoprobe: "));
3306 for (i = 0; i < mPriv->count; i++)
3307 AP_DBGC(("%2.2x ", (unsigned char) mPriv->data[i]));
3308 AP_DBGC(("\n"));
3309
3310 blocked = xf86BlockSIGIO ();
3311
3312 /* create a private copy first so we can write in the old list */
3313 if ((tmplist = xalloc(sizeof(MouseProtocolID) * NUM_AUTOPROBE_PROTOS))){
3314 for (i = 0; protoList[i] != PROT_UNKNOWN; i++) {
3315 tmplist[i] = protoList[i];
3316 }
3317 tmplist[i] = PROT_UNKNOWN;
3318 protoList = tmplist;
3319 } else
3320 return;
3321
3322 for (i = 0; ((prot = protoList[i]) != PROT_UNKNOWN
3323 && (k < NUM_AUTOPROBE_PROTOS - 1)) ; i++) {
3324 Bool bad = TRUE;
3325 unsigned char byte = 0;
3326 int count = 0;
3327 int next_header_candidate = 0;
3328 int header_count = 0;
3329
3330 if (!GetProtocol(prot))
3331 continue;
3332 para = proto[prot];
3333
3334 AP_DBG(("Protocol: %s ", ProtocolIDToName(prot)));
3335
3336#ifdef EXTMOUSEDEBUG
3337 for (j = 0; j < 7; j++)
3338 AP_DBGC(("%2.2x ", (unsigned char) para[j]));
3339 AP_DBGC(("\n"));
3340#endif
3341 j = 0;
3342 while (1) {
3343 /* look for header */
3344 while (j < mPriv->count) {
3345 if (((byte = mPriv->data[j++]) & para[0]) == para[1]){
3346 AP_DBG(("found header %2.2x\n",byte));
3347 next_header_candidate = j;
3348 count = 1;
3349 break;
3350 } else {
3351 /*
3352 * Bail ot if number of bytes per package have
3353 * been tested for header.
3354 * Take bytes per package of leading garbage into
3355 * account.
3356 */
3357 if (j > para[4] && ++header_count > para[4]) {
3358 j = mPriv->count;
3359 break;
3360 }
3361 }
3362 }
3363 /* check if remaining data matches protocol */
3364 while (j < mPriv->count) {
3365 byte = mPriv->data[j++];
3366 if (count == para[4]) {
3367 count = 0;
3368 /* check and eat excess byte */
3369 if (((byte & para[0]) != para[1])
3370 && ((byte & para[5]) == para[6])) {
3371 AP_DBG(("excess byte found\n"));
3372 continue;
3373 }
3374 }
3375 if (count == 0) {
3376 /* validate next header */
3377 bad = FALSE;
3378 AP_DBG(("Complete set found\n"));
3379 if ((byte & para[0]) != para[1]) {
3380 AP_DBG(("Autoprobe: header bad\n"));
3381 bad = TRUE;
3382 break;
3383 } else {
3384 count++;
3385 continue;
3386 }
3387 }
3388 /* validate data */
3389 else if (((byte & para[2]) != para[3])
3390 || ((para[7] & MPF_SAFE)
3391 && ((byte & para[0]) == para[1]))) {
3392 AP_DBG(("data bad\n"));
3393 bad = TRUE;
3394 break;
3395 } else {
3396 count ++;
3397 continue;
3398 }
3399 }
3400 if (!bad) {
3401 /* this is a matching protocol */
3402 mPriv->protoList[k++] = prot;
3403 AP_DBG(("Autoprobe: Adding protocol %s to list (entry %i)\n",
3404 ProtocolIDToName(prot),k-1));
3405 break;
3406 }
3407 j = next_header_candidate;
3408 next_header_candidate = 0;
3409 /* we have tested number of bytes per package for header */
3410 if (j > para[4] && ++header_count > para[4])
3411 break;
3412 /* we have not found anything that looks like a header */
3413 if (!next_header_candidate)
3414 break;
3415 AP_DBG(("Looking for new header\n"));
3416 }
3417 }
3418
3419 xf86UnblockSIGIO(blocked);
3420
3421 mPriv->protoList[k] = PROT_UNKNOWN;
3422
3423 xfree(tmplist);
3424}
3425
3426
3427/* This only needs to be done once */
3428void **serialDefaultsList = NULL;
3429
3430/*
3431 * createSerialDefaultsLists() - create a list of the different default
3432 * settings for the serial interface of the known protocols.
3433 */
3434static void
3435createSerialDefaultsList(void)
3436{
3437 int i = 0, j, k;
3438
3439 serialDefaultsList = (void **)xnfalloc(sizeof(void*));
3440 serialDefaultsList[0] = NULL;
3441
3442 for (j = 0; mouseProtocols[j].name; j++) {
3443 if (!mouseProtocols[j].defaults)
3444 continue;
3445 for (k = 0; k < i; k++)
3446 if (mouseProtocols[j].defaults == serialDefaultsList[k])
3447 continue;
3448 i++;
3449 serialDefaultsList = (void**)xnfrealloc(serialDefaultsList,
3450 sizeof(void*)*(i+1));
3451 serialDefaultsList[i-1] = mouseProtocols[j].defaults;
3452 serialDefaultsList[i] = NULL;
3453 }
3454}
3455
3456typedef enum {
3457 STATE_INVALID,
3458 STATE_UNCERTAIN,
3459 STATE_VALID
3460} validState;
3461
3462/* Probing threshold values */
3463#define PROBE_UNCERTAINTY 50
3464#define BAD_CERTAINTY 6
3465#define BAD_INC_CERTAINTY 1
3466#define BAD_INC_CERTAINTY_WHEN_SYNC_LOST 2
3467
3468static validState
3469validCount(mousePrivPtr mPriv, Bool inSync, Bool lostSync)
3470{
3471 if (inSync) {
3472 if (!--mPriv->goodCount) {
3473 /* we are sure to have found the correct protocol */
3474 mPriv->badCount = 0;
3475 return STATE_VALID;
3476 }
3477 AP_DBG(("%i successful rounds to go\n",
3478 mPriv->goodCount));
3479 return STATE_UNCERTAIN;
3480 }
3481
3482
3483 /* We are out of sync again */
3484 mPriv->goodCount = PROBE_UNCERTAINTY;
3485 /* We increase uncertainty of having the correct protocol */
3486 mPriv->badCount+= lostSync ? BAD_INC_CERTAINTY_WHEN_SYNC_LOST
3487 : BAD_INC_CERTAINTY;
3488
3489 if (mPriv->badCount < BAD_CERTAINTY) {
3490 /* We are not convinced yet to have the wrong protocol */
3491 AP_DBG(("Changing protocol after: %i rounds\n",
3492 BAD_CERTAINTY - mPriv->badCount));
3493 return STATE_UNCERTAIN;
3494 }
3495 return STATE_INVALID;
3496}
3497
3498#define RESET_VALIDATION mPriv->goodCount = PROBE_UNCERTAINTY;\
3499 mPriv->badCount = 0;\
3500 mPriv->prevDx = 0;\
3501 mPriv->prevDy = 0;\
3502 mPriv->accDx = 0;\
3503 mPriv->accDy = 0;\
3504 mPriv->acc = 0;
3505
3506static void
3507autoProbeMouse(InputInfoPtr pInfo, Bool inSync, Bool lostSync)
3508{
3509 MouseDevPtr pMse = pInfo->private;
3510 mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
3511
3512 MouseProtocolID *protocolList = NULL;
3513
3514 while (1) {
3515 switch (mPriv->autoState) {
3516 case AUTOPROBE_GOOD:
3517 if (inSync)
3518 return;
3519 AP_DBG(("State GOOD\n"));
3520 RESET_VALIDATION;
3521 mPriv->autoState = AUTOPROBE_VALIDATE1;
3522 return;
3523 case AUTOPROBE_H_GOOD:
3524 if (inSync)
3525 return;
3526 AP_DBG(("State H_GOOD\n"));
3527 RESET_VALIDATION;
3528 mPriv->autoState = AUTOPROBE_H_VALIDATE2;
3529 return;
3530 case AUTOPROBE_H_NOPROTO:
3531 AP_DBG(("State H_NOPROTO\n"));
3532 mPriv->protocolID = 0;
3533 mPriv->autoState = AUTOPROBE_H_SETPROTO;
3534 break;
3535 case AUTOPROBE_H_SETPROTO:
3536 AP_DBG(("State H_SETPROTO\n"));
3537 if ((pMse->protocolID = hardProtocolList[mPriv->protocolID++])
3538 == PROT_UNKNOWN) {
3539 mPriv->protocolID = 0;
3540 break;
3541 } else if (GetProtocol(pMse->protocolID) && SetupMouse(pInfo)) {
3542 FlushButtons(pMse);
3543 RESET_VALIDATION;
3544 AP_DBG(("Autoprobe: Trying Protocol: %s\n",
3545 ProtocolIDToName(pMse->protocolID)));
3546 mPriv->autoState = AUTOPROBE_H_VALIDATE1;
3547 return;
3548 }
3549 break;
3550 case AUTOPROBE_H_VALIDATE1:
3551 AP_DBG(("State H_VALIDATE1\n"));
3552 switch (validCount(mPriv,inSync,lostSync)) {
3553 case STATE_INVALID:
3554 mPriv->autoState = AUTOPROBE_H_SETPROTO;
3555 break;
3556 case STATE_VALID:
3557 xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
3558 ProtocolIDToName(pMse->protocolID));
3559 mPriv->autoState = AUTOPROBE_H_GOOD;
3560 return;
3561 case STATE_UNCERTAIN:
3562 return;
3563 default:
3564 break;
3565 }
3566 break;
3567 case AUTOPROBE_H_VALIDATE2:
3568 AP_DBG(("State H_VALIDATE2\n"));
3569 switch (validCount(mPriv,inSync,lostSync)) {
3570 case STATE_INVALID:
3571 mPriv->autoState = AUTOPROBE_H_AUTODETECT;
3572 break;
3573 case STATE_VALID:
3574 xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
3575 ProtocolIDToName(pMse->protocolID));
3576 mPriv->autoState = AUTOPROBE_H_GOOD;
3577 return;
3578 case STATE_UNCERTAIN:
3579 return;
3580 }
3581 break;
3582 case AUTOPROBE_H_AUTODETECT:
3583 AP_DBG(("State H_AUTODETECT\n"));
3584 pMse->protocolID = PROT_AUTO;
3585 AP_DBG(("Looking for PnP/OS mouse\n"));
3586 mPriv->count = 0;
3587 SetupMouse(pInfo);
3588 if (pMse->protocolID != PROT_AUTO)
3589 mPriv->autoState = AUTOPROBE_H_GOOD;
3590 else
3591 mPriv->autoState = AUTOPROBE_H_NOPROTO;
3592 break;
3593 case AUTOPROBE_NOPROTO:
3594 AP_DBG(("State NOPROTO\n"));
3595 mPriv->count = 0;
3596 mPriv->serialDefaultsNum = -1;
3597 mPriv->autoState = AUTOPROBE_COLLECT;
3598 break;
3599 case AUTOPROBE_COLLECT:
3600 AP_DBG(("State COLLECT\n"));
3601 if (mPriv->count <= NUM_MSE_AUTOPROBE_BYTES)
3602 return;
3603 protocolList = softProtocolList;
3604 mPriv->autoState = AUTOPROBE_CREATE_PROTOLIST;
3605 break;
3606 case AUTOPROBE_CREATE_PROTOLIST:
3607 AP_DBG(("State CREATE_PROTOLIST\n"));
3608 createProtoList(pMse, protocolList);
3609 mPriv->protocolID = 0;
3610 mPriv->autoState = AUTOPROBE_SWITCH_PROTOCOL;
3611 break;
3612 case AUTOPROBE_AUTODETECT:
3613 AP_DBG(("State AUTODETECT\n"));
3614 pMse->protocolID = PROT_AUTO;
3615 AP_DBG(("Looking for PnP/OS mouse\n"));
3616 mPriv->count = 0;
3617 SetupMouse(pInfo);
3618 if (pMse->protocolID != PROT_AUTO)
3619 mPriv->autoState = AUTOPROBE_GOOD;
3620 else
3621 mPriv->autoState = AUTOPROBE_NOPROTO;
3622 break;
3623 case AUTOPROBE_VALIDATE1:
3624 AP_DBG(("State VALIDATE1\n"));
3625 switch (validCount(mPriv,inSync,lostSync)) {
3626 case STATE_INVALID:
3627 mPriv->autoState = AUTOPROBE_AUTODETECT;
3628 break;
3629 case STATE_VALID:
3630 xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
3631 ProtocolIDToName(pMse->protocolID));
3632 mPriv->autoState = AUTOPROBE_GOOD;
3633 break;
3634 case STATE_UNCERTAIN:
3635 return;
3636 }
3637 break;
3638 case AUTOPROBE_VALIDATE2:
3639 AP_DBG(("State VALIDATE2\n"));
3640 switch (validCount(mPriv,inSync,lostSync)) {
3641 case STATE_INVALID:
3642 protocolList = &mPriv->protoList[mPriv->protocolID];
3643 mPriv->autoState = AUTOPROBE_CREATE_PROTOLIST;
3644 break;
3645 case STATE_VALID:
3646 xf86Msg(X_INFO,"Mouse autoprobe: selecting %s protocol\n",
3647 ProtocolIDToName(pMse->protocolID));
3648 mPriv->autoState = AUTOPROBE_GOOD;
3649 break;
3650 case STATE_UNCERTAIN:
3651 return;
3652 }
3653 break;
3654 case AUTOPROBE_SWITCHSERIAL:
3655 {
3656 pointer serialDefaults;
3657 AP_DBG(("State SWITCHSERIAL\n"));
3658
3659 if (!serialDefaultsList)
3660 createSerialDefaultsList();
3661
3662 AP_DBG(("Switching serial params\n"));
3663 if ((serialDefaults =
3664 serialDefaultsList[++mPriv->serialDefaultsNum]) == NULL) {
3665 mPriv->serialDefaultsNum = 0;
3666 } else {
3667 pointer tmp = xf86OptionListCreate(serialDefaults, -1, 0);
3668 xf86SetSerial(pInfo->fd, tmp);
3669 xf86OptionListFree(tmp);
3670 mPriv->count = 0;
3671 mPriv->autoState = AUTOPROBE_COLLECT;
3672 }
3673 break;
3674 }
3675 case AUTOPROBE_SWITCH_PROTOCOL:
3676 {
3677 MouseProtocolID proto;
3678 void *defaults;
3679 AP_DBG(("State SWITCH_PROTOCOL\n"));
3680 proto = mPriv->protoList[mPriv->protocolID++];
3681 if (proto == PROT_UNKNOWN)
3682 mPriv->autoState = AUTOPROBE_SWITCHSERIAL;
3683 else if (!(defaults = GetProtocol(proto)->defaults)
3684 || (mPriv->serialDefaultsNum == -1
3685 && (defaults == msDefaults))
3686 || (mPriv->serialDefaultsNum != -1
3687 && serialDefaultsList[mPriv->serialDefaultsNum]
3688 == defaults)) {
3689 AP_DBG(("Changing Protocol to %s\n",
3690 ProtocolIDToName(proto)));
3691 SetMouseProto(pMse,proto);
3692 FlushButtons(pMse);
3693 RESET_VALIDATION;
3694 mPriv->autoState = AUTOPROBE_VALIDATE2;
3695 return;
3696 }
3697 break;
3698 }
3699 }
3700 }
3701}
3702
3703static Bool
3704autoGood(MouseDevPtr pMse)
3705{
3706 mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
3707
3708 if (!pMse->autoProbe)
3709 return TRUE;
3710
3711 switch (mPriv->autoState) {
3712 case AUTOPROBE_GOOD:
3713 case AUTOPROBE_H_GOOD:
3714 return TRUE;
3715 case AUTOPROBE_VALIDATE1: /* @@@ */
3716 case AUTOPROBE_H_VALIDATE1: /* @@@ */
3717 case AUTOPROBE_VALIDATE2:
3718 case AUTOPROBE_H_VALIDATE2:
3719 if (mPriv->goodCount < PROBE_UNCERTAINTY/2)
3720 return TRUE;
3721 default:
3722 return FALSE;
3723 }
3724}
3725
3726
3727#define TOT_THRESHOLD 3000
3728#define VAL_THRESHOLD 40
3729
3730/*
3731 * checkForErraticMovements() -- check if mouse 'jumps around'.
3732 */
3733static void
3734checkForErraticMovements(InputInfoPtr pInfo, int dx, int dy)
3735{
3736 MouseDevPtr pMse = pInfo->private;
3737 mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
3738#if 1
3739 if (!mPriv->goodCount)
3740 return;
3741#endif
3742#if 0
3743 if (abs(dx - mPriv->prevDx) > 300
3744 || abs(dy - mPriv->prevDy) > 300)
3745 AP_DBG(("erratic1 behaviour\n"));
3746#endif
3747 if (abs(dx) > VAL_THRESHOLD) {
3748 if (sign(dx) == sign(mPriv->prevDx)) {
3749 mPriv->accDx += dx;
3750 if (abs(mPriv->accDx) > mPriv->acc) {
3751 mPriv->acc = abs(mPriv->accDx);
3752 AP_DBG(("acc=%i\n",mPriv->acc));
3753 }
3754 else
3755 AP_DBG(("accDx=%i\n",mPriv->accDx));
3756 } else {
3757 mPriv->accDx = 0;
3758 }
3759 }
3760
3761 if (abs(dy) > VAL_THRESHOLD) {
3762 if (sign(dy) == sign(mPriv->prevDy)) {
3763 mPriv->accDy += dy;
3764 if (abs(mPriv->accDy) > mPriv->acc) {
3765 mPriv->acc = abs(mPriv->accDy);
3766 AP_DBG(("acc: %i\n",mPriv->acc));
3767 } else
3768 AP_DBG(("accDy=%i\n",mPriv->accDy));
3769 } else {
3770 mPriv->accDy = 0;
3771 }
3772 }
3773 mPriv->prevDx = dx;
3774 mPriv->prevDy = dy;
3775 if (mPriv->acc > TOT_THRESHOLD) {
3776 mPriv->goodCount = PROBE_UNCERTAINTY;
3777 mPriv->prevDx = 0;
3778 mPriv->prevDy = 0;
3779 mPriv->accDx = 0;
3780 mPriv->accDy = 0;
3781 mPriv->acc = 0;
3782 AP_DBG(("erratic2 behaviour\n"));
3783 autoProbeMouse(pInfo, FALSE,TRUE);
3784 }
3785}
3786
3787static void
3788SetMouseProto(MouseDevPtr pMse, MouseProtocolID protocolID)
3789{
3790 pMse->protocolID = protocolID;
3791 pMse->protocol = ProtocolIDToName(pMse->protocolID);
3792 pMse->class = ProtocolIDToClass(pMse->protocolID);
3793 if ((pMse->protocolID >= 0) && (pMse->protocolID < PROT_NUMPROTOS))
3794 memcpy(pMse->protoPara, proto[pMse->protocolID],
3795 sizeof(pMse->protoPara));
3796
3797 if (pMse->emulate3ButtonsSoft)
3798 pMse->emulate3Buttons = TRUE;
3799}
3800
3801/*
3802 * collectData() -- collect data bytes sent by mouse.
3803 */
3804static Bool
3805collectData(MouseDevPtr pMse, unsigned char u)
3806{
3807 mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
3808 if (mPriv->count < NUM_MSE_AUTOPROBE_TOTAL) {
3809 mPriv->data[mPriv->count++] = u;
3810 if (mPriv->count <= NUM_MSE_AUTOPROBE_BYTES) {
3811 return TRUE;
3812 }
3813 }
3814 return FALSE;
3815}
3816
3817/**************** end of autoprobe stuff *****************/
3818
3819
3820
3821#ifdef XFree86LOADER
3822ModuleInfoRec MouseInfo = {
3823 1,
3824 "MOUSE",
3825 NULL,
3826 0,
3827 MouseAvailableOptions,
3828};
3829
3830static void
3831xf86MouseUnplug(pointer p)
3832{
3833}
3834static pointer
3835xf86MousePlug(pointer module,
3836 pointer options,
3837 int *errmaj,
3838 int *errmin)
3839{
3840 static Bool Initialised = FALSE;
3841
3842 if (!Initialised) {
3843 Initialised = TRUE;
3844#ifndef REMOVE_LOADER_CHECK_MODULE_INFO
3845 if (xf86LoaderCheckSymbol("xf86AddModuleInfo"))
3846#endif
3847 xf86AddModuleInfo(&MouseInfo, module);
3848 }
3849
3850 xf86AddInputDriver(&MOUSE, module, 0);
3851
3852 return module;
3853}
3854
3855static XF86ModuleVersionInfo xf86MouseVersionRec =
3856{
3857#ifdef VBOX
3858 "vboxmouse",
3859 "Sun Microsystems, Inc.",
3860#else
3861 "mouse",
3862 MODULEVENDORSTRING,
3863#endif
3864 MODINFOSTRING1,
3865 MODINFOSTRING2,
3866 XORG_VERSION_CURRENT,
3867 1, 1, 0,
3868 ABI_CLASS_XINPUT,
3869 ABI_XINPUT_VERSION,
3870 MOD_CLASS_XINPUT,
3871 {0, 0, 0, 0} /* signature, to be patched into the file by */
3872 /* a tool */
3873};
3874
3875#ifdef VBOX
3876_X_EXPORT XF86ModuleData vboxmouseModuleData = {
3877 &xf86MouseVersionRec,
3878 xf86MousePlug,
3879 xf86MouseUnplug
3880};
3881#else
3882_X_EXPORT XF86ModuleData mouseModuleData = {
3883 &xf86MouseVersionRec,
3884 xf86MousePlug,
3885 xf86MouseUnplug
3886};
3887#endif
3888
3889/*
3890 Look at hitachi device stuff.
3891*/
3892#endif /* XFree86LOADER */
3893
3894
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette