 @@ -1,15 +1,13 @@
 /* $XdotOrg: driver/xf86-input-mouse/src/mouse.c,v 1.29 2006/04/21 11:15:23 mhopf Exp $ */
 /* $XFree86: xc/programs/Xserver/hw/xfree86/input/mouse/mouse.c,v 1.79 2003/11/03 05:11:48 tsi Exp $ */
 /*
+ *
  * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
  * Copyright 1993 by David Dawes <dawes@xfree86.org>
  * Copyright 2002 by SuSE Linux AG, Author: Egbert Eich
  * Copyright 1994-2002 by The XFree86 Project, Inc.
  * Copyright 2002 by Paul Elliott
+ *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
  * documentation, and that the names of copyright holders not be
 @@ -116,29 +114,27 @@ typedef struct _DragLockRec {
     /* simulate these buttons being down although they are not */
     int simulatedDown;
     /*
      * data to map bits for drag lock buttons to corresponding
      * bits for the target buttons
      */
     int nib_table[NIB_COUNT][NIB_SIZE];
 } DragLockRec, *DragLockPtr;
 #ifdef XFree86LOADER
 static const OptionInfoRec *MouseAvailableOptions(void *unused);
 #endif
 static InputInfoPtr MousePreInit(InputDriverPtr drv, IDevPtr dev, int flags);
 #if 0
 static void MouseUnInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags);
 #endif
 static int MouseProc(DeviceIntPtr device, int what);
 static Bool MouseConvert(LocalDevicePtr local, int first, int num, int v0,
 		 	     int v1, int v2, int v3, int v4, int v5, int *x,
 		 	     int *y);
 static void MouseCtrl(DeviceIntPtr device, PtrCtrl *ctrl);
 static void MousePostEvent(InputInfoPtr pInfo, int buttons,
 			   int dx, int dy, int dz, int dw);
 @@ -207,27 +203,26 @@ typedef enum {
     OPTION_BAUD_RATE,
     OPTION_DATA_BITS,
     OPTION_STOP_BITS,
     OPTION_PARITY,
     OPTION_FLOW_CONTROL,
     OPTION_VTIME,
     OPTION_VMIN,
     OPTION_DRAGLOCKBUTTONS,
     OPTION_DOUBLECLICK_BUTTONS,
     OPTION_BUTTON_MAPPING,
     OPTION_SENSITIVITY
 } MouseOpts;
 #ifdef XFree86LOADER
 static const OptionInfoRec mouseOptions[] = {
     { OPTION_ALWAYS_CORE,	"AlwaysCore",	  OPTV_BOOLEAN,	{0}, FALSE },
     { OPTION_SEND_CORE_EVENTS,	"SendCoreEvents", OPTV_BOOLEAN,	{0}, FALSE },
     { OPTION_CORE_POINTER,	"CorePointer",	  OPTV_BOOLEAN,	{0}, FALSE },
     { OPTION_SEND_DRAG_EVENTS,	"SendDragEvents", OPTV_BOOLEAN,	{0}, FALSE },
     { OPTION_HISTORY_SIZE,	"HistorySize",	  OPTV_INTEGER,	{0}, FALSE },
     { OPTION_DEVICE,		"Device",	  OPTV_STRING,	{0}, FALSE },
     { OPTION_PROTOCOL,		"Protocol",	  OPTV_STRING,	{0}, FALSE },
     { OPTION_BUTTONS,		"Buttons",	  OPTV_INTEGER,	{0}, FALSE },
     { OPTION_EMULATE_3_BUTTONS,	"Emulate3Buttons",OPTV_BOOLEAN,	{0}, FALSE },
     { OPTION_EMULATE_3_TIMEOUT,	"Emulate3Timeout",OPTV_INTEGER,	{0}, FALSE },
     { OPTION_CHORD_MIDDLE,	"ChordMiddle",	  OPTV_BOOLEAN,	{0}, FALSE },
     { OPTION_FLIP_XY,		"FlipXY",	  OPTV_BOOLEAN,	{0}, FALSE },
 @@ -251,27 +246,26 @@ static const OptionInfoRec mouseOptions[
     { OPTION_DATA_BITS,		"DataBits",	  OPTV_INTEGER,	{0}, FALSE },
     { OPTION_STOP_BITS,		"StopBits",	  OPTV_INTEGER,	{0}, FALSE },
     { OPTION_PARITY,		"Parity",	  OPTV_STRING,	{0}, FALSE },
     { OPTION_FLOW_CONTROL,	"FlowControl",	  OPTV_STRING,	{0}, FALSE },
     { OPTION_VTIME,		"VTime",	  OPTV_INTEGER,	{0}, FALSE },
     { OPTION_VMIN,		"VMin",		  OPTV_INTEGER,	{0}, FALSE },
     /* end serial options */
     { OPTION_DRAGLOCKBUTTONS,	"DragLockButtons",OPTV_STRING,	{0}, FALSE },
     { OPTION_DOUBLECLICK_BUTTONS,"DoubleClickButtons", OPTV_STRING, {0}, FALSE },
     { OPTION_BUTTON_MAPPING,   "ButtonMapping",   OPTV_STRING,  {0}, FALSE },
     { OPTION_SENSITIVITY,      "Sensitivity",     OPTV_REAL,    {0}, FALSE },
     { -1,			NULL,		  OPTV_NONE,	{0}, FALSE }
 };
 #endif
 #define RETRY_COUNT 4
 /*
  * Microsoft (all serial models), Logitech MouseMan, First Mouse, etc,
  * ALPS GlidePoint, Thinking Mouse.
  */
 static const char *msDefaults[] = {
 	"BaudRate",	"1200",
 	"DataBits",	"7",
 	"StopBits",	"1",
 	"Parity",	"None",
 	"FlowControl",	"None",
 @@ -368,34 +362,32 @@ static MouseProtocolRec mouseProtocols[]
     /* Bus Mouse */
     { "BusMouse",		MSE_BUS,	NULL,		PROT_BM },
     /* Auto-detect (PnP) */
     { "Auto",			MSE_AUTO,	NULL,		PROT_AUTO },
     /* Misc (usually OS-specific) */
     { "SysMouse",		MSE_MISC,	mlDefaults,	PROT_SYSMOUSE },
     /* end of list */
     { NULL,			MSE_NONE,	NULL,		PROT_UNKNOWN }
 };
 #ifdef XFree86LOADER
 /*ARGSUSED*/
 static const OptionInfoRec *
 MouseAvailableOptions(void *unused)
+{
     return (mouseOptions);
+}
 #endif
 /* Process options common to all mouse types. */
 static void
 MouseCommonOptions(InputInfoPtr pInfo)
+{
     MouseDevPtr pMse;
     MessageType buttons_from = X_CONFIG;
     char *s;
     int origButtons;
     int i;
     pMse = pInfo->private;
 @@ -792,28 +784,28 @@ MouseHWOptions(InputInfoPtr pInfo)
 	xf86Msg(X_CONFIG, "Don't initialize mouse when auto-probing\n");
+    }
     pMse->sampleRate = xf86SetIntOption(pInfo->options, "SampleRate", 0);
     if (pMse->sampleRate) {
 	xf86Msg(X_CONFIG, "%s: SampleRate: %d\n", pInfo->name,
 		pMse->sampleRate);
+    }
     pMse->resolution = xf86SetIntOption(pInfo->options, "Resolution", 0);
     if (pMse->resolution) {
 	xf86Msg(X_CONFIG, "%s: Resolution: %d\n", pInfo->name,
 		pMse->resolution);
+    }
-    if (mPriv->sensitivity
+    if ((mPriv->sensitivity
-	= xf86SetRealOption(pInfo->options, "Sensitivity", 1.0)) {
+	 = xf86SetRealOption(pInfo->options, "Sensitivity", 1.0))) {
 	xf86Msg(X_CONFIG, "%s: Sensitivity: %g\n", pInfo->name,
 		mPriv->sensitivity);
+    }
+}
 static void
 MouseSerialOptions(InputInfoPtr pInfo)
+{
     MouseDevPtr  pMse = pInfo->private;
     Bool clearDTR, clearRTS;
     pMse->baudRate = xf86SetIntOption(pInfo->options, "BaudRate", 0);
 @@ -864,27 +856,27 @@ ProtocolIDToName(MouseProtocolID id)
 	return "Unknown";
 	break;
     case PROT_UNSUP:
 	return "Unsupported";
 	break;
     default:
 	for (i = 0; mouseProtocols[i].name; i++)
 	    if (id == mouseProtocols[i].id)
 		return mouseProtocols[i].name;
 	return "Invalid";
+    }
+}
-const char *
+_X_EXPORT const char *
 xf86MouseProtocolIDToName(MouseProtocolID id)
+{
 	return ProtocolIDToName(id);
+}
 MouseProtocolID
 xf86MouseProtocolNameToID(const char *name)
+{
     return ProtocolNameToID(name);
+}
 static int
 ProtocolIDToClass(MouseProtocolID id)
 @@ -993,27 +985,27 @@ MousePreInit(InputDriverPtr drv, IDevPtr
     pInfo->read_input = MouseReadInput;
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) == 0
     pInfo->motion_history_proc = xf86GetMotionEvents;
     pInfo->history_size = 0;
 #endif
     pInfo->control_proc = NULL;
     pInfo->close_proc = NULL;
     pInfo->switch_mode = NULL;
     pInfo->conversion_proc = MouseConvert;
     pInfo->reverse_conversion_proc = NULL;
     pInfo->fd = -1;
     pInfo->dev = NULL;
     pInfo->private_flags = 0;
-    pInfo->always_core_feedback = 0;
+    pInfo->always_core_feedback = NULL;
     pInfo->conf_idev = dev;
     /* Check if SendDragEvents has been disabled. */
     if (!xf86SetBoolOption(dev->commonOptions, "SendDragEvents", TRUE)) {
 	pInfo->flags &= ~XI86_SEND_DRAG_EVENTS;
+    }
     /* Allocate the MouseDevRec and initialise it. */
     /*
      * XXX This should be done by a function in the core server since the
      * MouseDevRec is defined in the os-support layer.
      */
     if (!(pMse = xcalloc(sizeof(MouseDevRec), 1)))
 @@ -1052,27 +1044,27 @@ MousePreInit(InputDriverPtr drv, IDevPtr
 			protocolID = id;
 			protocol = osProt;
 			detected = FALSE;
+		    }
+		}
+	    }
 	    break;
 	case PROT_UNKNOWN:
 	    /* Check for a builtin OS-specific protocol,
 	     * and call its PreInit. */
 	    if (osInfo->CheckProtocol
 		&& osInfo->CheckProtocol(protocol)) {
 		if (!xf86CheckStrOption(dev->commonOptions, "Device", NULL) &&
-		    HAVE_FIND_DEVICE && osInfo->FindDevice) {
+		    osInfo->FindDevice) {
 		    xf86Msg(X_WARNING, "%s: No Device specified, "
 			    "looking for one...\n", pInfo->name);
 		    if (!osInfo->FindDevice(pInfo, protocol, 0)) {
 			xf86Msg(X_ERROR, "%s: Cannot find which device "
 				"to use.\n", pInfo->name);
 		    } else
 			deviceFrom = X_PROBED;
+		}
 		if (osInfo->PreInit) {
 		    osInfo->PreInit(pInfo, protocol, 0);
+		}
 		return pInfo;
+	    }
 @@ -1083,27 +1075,27 @@ MousePreInit(InputDriverPtr drv, IDevPtr
 	case PROT_UNSUP:
 	    xf86Msg(X_ERROR,
 		    "%s: Protocol \"%s\" is not supported on this "
 		    "platform\n", pInfo->name, protocol);
 	    return pInfo;
 	    break;
 	default:
 	    break;
+	}
     } while (!detected);
     if (!xf86CheckStrOption(dev->commonOptions, "Device", NULL) &&
-	HAVE_FIND_DEVICE && osInfo->FindDevice) {
+	osInfo->FindDevice) {
 	xf86Msg(X_WARNING, "%s: No Device specified, looking for one...\n",
 		pInfo->name);
 	if (!osInfo->FindDevice(pInfo, protocol, 0)) {
 	    xf86Msg(X_ERROR, "%s: Cannot find which device to use.\n",
 		    pInfo->name);
 	} else {
 	    deviceFrom = X_PROBED;
 	    xf86MarkOptionUsedByName(dev->commonOptions, "Device");
+	}
+    }
     device = xf86CheckStrOption(dev->commonOptions, "Device", NULL);
     if (device)
 @@ -1182,32 +1174,31 @@ MouseReadInput(InputInfoPtr pInfo)
      * read. Xisb automatically clears it after one successful read so that
      * succeeding reads are preceeded by a select with a 0 timeout to prevent
      * read from blocking indefinitely.
      */
     XisbBlockDuration(pMse->buffer, -1);
     while ((c = XisbRead(pMse->buffer)) >= 0) {
 	u = (unsigned char)c;
 #if defined (EXTMOUSEDEBUG) || defined (MOUSEDATADEBUG)
 	ErrorF("mouse byte: %2.2x\n",u);
 #endif
 #if 1
 	/* if we do autoprobing collect the data */
 	if (pMse->collectData && pMse->autoProbe)
 	    if (pMse->collectData(pMse,u))
 		continue;
 #endif
 #ifdef SUPPORT_MOUSE_RESET
 	if (mouseReset(pInfo,u)) {
 	    pBufP = 0;
 	    continue;
+	}
 #endif
 	if (pBufP >= pMse->protoPara[4]) {
 	    /*
 	     * Buffer contains a full packet, which has already been processed:
 	     * Empty the buffer and check for optional 4th byte, which will be
 	     * processed directly, without being put into the buffer first.
 	     */
 	    pBufP = 0;
 @@ -1718,27 +1709,27 @@ MouseProc(DeviceIntPtr device, int what)
     case DEVICE_INIT:
 	device->public.on = FALSE;
 	/*
 	 * [KAZU-241097] We don't know exactly how many buttons the
 	 * device has, so setup the map with the maximum number.
 	 */
 	for (i = 0; i < MSE_MAXBUTTONS; i++)
 	    map[i + 1] = i + 1;
 	InitPointerDeviceStruct((DevicePtr)device, map,
 				min(pMse->buttons, MSE_MAXBUTTONS),
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) == 0
 				miPointerGetMotionEvents,
-#else
+#elif GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
                                 GetMotionHistory,
 #endif
                                 pMse->Ctrl,
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) == 0
 				miPointerGetMotionBufferSize()
 #else
                                 GetMotionHistorySize(), 2
 #endif
                                 );
 	/* X valuator */
 	xf86InitValuatorAxisStruct(device, 0, -1, -1, 1, 0, 1);
 	xf86InitValuatorDefaults(device, 0);
 @@ -1850,28 +1841,26 @@ MouseConvert(InputInfoPtr pInfo, int fir
     return TRUE;
+}
 /**********************************************************************
+ *
  * FlushButtons -- reset button states.
+ *
  **********************************************************************/
 static void
 FlushButtons(MouseDevPtr pMse)
+{
     int i, blocked;
     pMse->lastButtons = 0;
     pMse->lastMappedButtons = 0;
+}
 /**********************************************************************
+ *
  *  Emulate3Button support code
+ *
  **********************************************************************/
 /*
  * Lets create a simple finite-state machine for 3 button emulation:
 @@ -3048,27 +3037,27 @@ mouseReset(InputInfoPtr pInfo, unsigned
 	&& (mousepriv->lastEvent - prevEvent) >= 1000) {
 	mousepriv->inReset = FALSE;
 	mousepriv->current = 0;
 	return FALSE;
+    }
     if (mousepriv->inReset)
 	mousepriv->inReset = FALSE;
 #ifdef EXTMOUSEDEBUG
     ErrorF("Mouse Current: %i 0x%x\n",mousepriv->current, val);
 #endif
-    /* here we put the mouse specific reset detction */
+    /* here we put the mouse specific reset detection */
     /* They need to do three things:                 */
     /*  Check if byte may be a reset byte            */
     /*  If so: Set expectReset TRUE                  */
     /*  If convinced: Set inReset TRUE               */
     /*                Register BlockAndWakeupHandler */
     /* PS/2 */
+    {
 	unsigned char seq[] = { 0xaa, 0x00 };
 	int len = sizeof(seq);
 	if (seq[mousepriv->current] == val)
 	    expectReset = TRUE;
 @@ -3146,38 +3135,40 @@ ps2WakeupHandler(pointer data, int i, po
 /************************************************************
+ *
  * Autoprobe stuff
+ *
  ************************************************************/
 #ifdef EXTMOUSEDEBUG
 #  define AP_DBG(x) { ErrorF("Autoprobe: "); ErrorF x; }
 #  define AP_DBGC(x) ErrorF x ;
 # else
 #  define AP_DBG(x)
 #  define AP_DBGC(x)
 #endif
 static
 MouseProtocolID hardProtocolList[] = { 	PROT_MSC, PROT_MM, PROT_LOGI,
 					PROT_LOGIMAN, PROT_MMHIT,
 					PROT_GLIDE, PROT_IMSERIAL,
 					PROT_THINKING, PROT_ACECAD,
 					PROT_THINKPS2, PROT_MMPS2,
 					PROT_GLIDEPS2,
 					PROT_NETSCPS2, PROT_EXPPS2,PROT_IMPS2,
 					PROT_GENPS2, PROT_NETPS2,
 					PROT_MS,
 					PROT_UNKNOWN
 };
 static
 MouseProtocolID softProtocolList[] = { 	PROT_MSC, PROT_MM, PROT_LOGI,
 					PROT_LOGIMAN, PROT_MMHIT,
 					PROT_GLIDE, PROT_IMSERIAL,
 					PROT_THINKING, PROT_ACECAD,
 					PROT_THINKPS2, PROT_MMPS2,
 					PROT_GLIDEPS2,
 					PROT_NETSCPS2 ,PROT_IMPS2,
 					PROT_GENPS2,
 					PROT_MS,
 					PROT_UNKNOWN
 };
 static const char *
 @@ -3211,27 +3202,27 @@ autoOSProtocol(InputInfoPtr pInfo, int *
 		    break;
+	    }
+	}
+    }
     if (!name) {
 	/* A PnP serial mouse? */
 	protocolID = MouseGetPnpProtocol(pInfo);
 	if (protocolID >= 0 && protocolID < PROT_NUMPROTOS) {
 	    name = ProtocolIDToName(protocolID);
 	    xf86Msg(X_PROBED, "%s: PnP-detected protocol: \"%s\"\n",
 		    pInfo->name, name);
+	}
+    }
-    if (!name && HAVE_GUESS_PROTOCOL && osInfo->GuessProtocol) {
+    if (!name && osInfo->GuessProtocol) {
 	name = osInfo->GuessProtocol(pInfo, 0);
 	if (name)
 	    protocolID = ProtocolNameToID(name);
+    }
     if (name) {
 	pMse->protocolID = protocolID;
+    }
     return name;
+}
 /*
 @@ -3285,27 +3276,27 @@ createProtoList(MouseDevPtr pMse, MouseP
 	AP_DBGC(("\n"));
 #endif
 	j = 0;
 	while (1) {
 	    /* look for header */
 	    while (j < mPriv->count) {
 		if (((byte = mPriv->data[j++]) & para[0]) == para[1]){
 		    AP_DBG(("found header %2.2x\n",byte));
 		    next_header_candidate = j;
 		    count = 1;
 		    break;
 		} else {
 		    /*
-		     * Bail ot if number of bytes per package have
+		     * Bail out if number of bytes per package have
 		     * been tested for header.
 		     * Take bytes per package of leading garbage into
 		     * account.
 		     */
 		    if (j > para[4] && ++header_count > para[4]) {
 			j = mPriv->count;
 			break;
+		    }
+		}
+	    }
 	    /* check if remaining data matches protocol */
 	    while (j < mPriv->count) {
 		byte = mPriv->data[j++];
 @@ -3361,27 +3352,27 @@ createProtoList(MouseDevPtr pMse, MouseP
 	    AP_DBG(("Looking for new header\n"));
+	}
+    }
     xf86UnblockSIGIO(blocked);
     mPriv->protoList[k] = PROT_UNKNOWN;
     xfree(tmplist);
+}
 /* This only needs to be done once */
-void **serialDefaultsList = NULL;
+static void **serialDefaultsList = NULL;
 /*
  * createSerialDefaultsLists() - create a list of the different default
  * settings for the serial interface of the known protocols.
  */
 static void
 createSerialDefaultsList(void)
+{
     int i = 0, j, k;
     serialDefaultsList = (void **)xnfalloc(sizeof(void*));
     serialDefaultsList[0] = NULL;
 @@ -3671,30 +3662,30 @@ autoGood(MouseDevPtr pMse)
 #define TOT_THRESHOLD 3000
 #define VAL_THRESHOLD 40
 /*
  * checkForErraticMovements() -- check if mouse 'jumps around'.
  */
 static void
 checkForErraticMovements(InputInfoPtr pInfo, int dx, int dy)
+{
     MouseDevPtr pMse = pInfo->private;
     mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
 #if 1
     if (!mPriv->goodCount)
 	return;
 #endif
 #if 0
     if (abs(dx - mPriv->prevDx) > 300
 	|| abs(dy - mPriv->prevDy) > 300)
 	AP_DBG(("erratic1 behaviour\n"));
 #endif
     if (abs(dx) > VAL_THRESHOLD) {
 	if (sign(dx) == sign(mPriv->prevDx)) {
 	    mPriv->accDx += dx;
 	    if (abs(mPriv->accDx) > mPriv->acc) {
 		mPriv->acc = abs(mPriv->accDx);
 		AP_DBG(("acc=%i\n",mPriv->acc));
+	    }
 	    else
 @@ -3754,54 +3745,48 @@ collectData(MouseDevPtr pMse, unsigned c
     if (mPriv->count < NUM_MSE_AUTOPROBE_TOTAL) {
 	mPriv->data[mPriv->count++] = u;
 	if (mPriv->count <= NUM_MSE_AUTOPROBE_BYTES) {
 		return TRUE;
+	}
+    }
     return FALSE;
+}
 /**************** end of autoprobe stuff *****************/
 #ifdef XFree86LOADER
 ModuleInfoRec MouseInfo = {
 ,
     "MOUSE",
     NULL,
 ,
     MouseAvailableOptions,
 };
 static void
 xf86MouseUnplug(pointer	p)
+{
+}
 static pointer
 xf86MousePlug(pointer	module,
 	    pointer	options,
 	    int		*errmaj,
 	    int		*errmin)
+{
     static Bool Initialised = FALSE;
-    if (!Initialised) {
+    if (!Initialised)
 	Initialised = TRUE;
 #ifndef REMOVE_LOADER_CHECK_MODULE_INFO
 	if (xf86LoaderCheckSymbol("xf86AddModuleInfo"))
 #endif
 	xf86AddModuleInfo(&MouseInfo, module);
     xf86AddInputDriver(&MOUSE, module, 0);
     return module;
+}
 static XF86ModuleVersionInfo xf86MouseVersionRec =
+{
     "mouse",
     MODULEVENDORSTRING,
     MODINFOSTRING1,
     MODINFOSTRING2,
     XORG_VERSION_CURRENT,
 @@ -3812,16 +3797,13 @@ static XF86ModuleVersionInfo xf86MouseVe
     {0, 0, 0, 0}		/* signature, to be patched into the file by */
 				/* a tool */
 };
 _X_EXPORT XF86ModuleData mouseModuleData = {
     &xf86MouseVersionRec,
     xf86MousePlug,
     xf86MouseUnplug
 };
 /*
   Look at hitachi device stuff.
 */
 #endif /* XFree86LOADER */