 @@ -336,47 +336,47 @@ static CARD8 wsUsbMap[] = {
 	/* 123 */ KEY_L10,
 	/* 124 */ KEY_L6,
 	/* 125 */ KEY_L8,
 	/* 126 */ KEY_L9,
 	/* 127 */ KEY_Mute,
 	/* 128 */ KEY_AudioRaise,
 	/* 129 */ KEY_AudioLower,
 	/* 130 */ KEY_NOTUSED,
 	/* 131 */ KEY_NOTUSED,
 	/* 132 */ KEY_NOTUSED,
 	/* 133 */ KEY_NOTUSED,
 	/* 134 */ KEY_NOTUSED,
 /*
- * Special keycode for For Japanese keyboard
+ * Special keycodes for Japanese keyboards
- * Override atKeyname HKTG and BSlash2 code to unique for JP106 keybaord
+ * Override atKeyname HKTG and BSlash2 code to unique values for JP106 keyboards
  */
 #undef KEY_HKTG
-#define KEY_HKTG	200	/* Japanee Hiragana Katakana Toggle */
+#define KEY_HKTG	200	/* Japanese Hiragana Katakana Toggle */
 #undef KEY_BSlash2
 #define KEY_BSlash2	203	/* Japanese '\_' key */
 	/* 135 */ KEY_BSlash2,	/* Japanese 106 kbd: '\_' */
 	/* 136 */ KEY_HKTG,	/* Japanese 106 kbd: Hiragana Katakana toggle */
 	/* 137 */ KEY_Yen,	/* Japanese 106 kbd: '\|' */
 	/* 138 */ KEY_XFER,	/* Japanese 106 kbd: Henkan */
 	/* 139 */ KEY_NFER,	/* Japanese 106 kbd: Muhenkan */
 	/* 140 */ KEY_NOTUSED,
 	/* 141 */ KEY_NOTUSED,
 	/* 142 */ KEY_NOTUSED,
 	/* 143 */ KEY_NOTUSED,
 /*
- * Special keycode for For Korean keyboard
+ * Special keycodes for Korean keyboards
- * Define Hangul and Hangul_Hanja unique key code
+ * Define Hangul and Hangul_Hanja unique key codes
- * These keys also use KANA and EISU on some Macintosh Japanese USB Keyboards
+ * These keys also use KANA and EISU on some Macintosh Japanese USB keyboards
  */
 #define KEY_Hangul		201	/* Also KANA Key on Mac JP USB kbd */
 #define KEY_Hangul_Hanja	202	/* Also EISU Key on Mac JP USB kbd */
 	/* 144 */ KEY_Hangul,		/* Korean 106 kbd: Hangul */
 	/* 145 */ KEY_Hangul_Hanja,	/* Korean 106 kbd: Hangul Hanja */
 	/* 146 */ KEY_NOTUSED,
 	/* 147 */ KEY_NOTUSED,
 	/* 148 */ KEY_NOTUSED,
 	/* 149 */ KEY_NOTUSED,
 	/* 150 */ KEY_NOTUSED,
 	/* 151 */ KEY_NOTUSED,
 	/* 152 */ KEY_NOTUSED,
 	/* 153 */ KEY_NOTUSED,

 @@ -35,149 +35,136 @@
 #include "xf86Xinput.h"
 #include "xf86_OSproc.h"
 #include "xf86OSKbd.h"
 #include "compiler.h"
 #include "exevents.h"
 #include <X11/Xatom.h>
 #include "xserver-properties.h"
 #include "xkbstr.h"
 #include "xkbsrv.h"
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 23
 #define HAVE_THREADED_INPUT	1
 #endif
 #define CAPSFLAG	1
 #define NUMFLAG		2
 #define SCROLLFLAG	4
 #define MODEFLAG	8
 #define COMPOSEFLAG	16
 /* Used to know when the first DEVICE_ON after a DEVICE_INIT is called */
 #define INITFLAG	(1U << 31)
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 12
 static InputInfoPtr KbdPreInit(InputDriverPtr drv, IDevPtr dev, int flags);
 #else
 static int KbdPreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags);
 #endif
 static int KbdProc(DeviceIntPtr device, int what);
 static void KbdCtrl(DeviceIntPtr device, KeybdCtrl *ctrl);
 static void KbdBell(int percent, DeviceIntPtr dev, pointer ctrl, int unused);
 static void PostKbdEvent(InputInfoPtr pInfo, unsigned int key, Bool down);
 static void InitKBD(InputInfoPtr pInfo, Bool init);
 static void UpdateLeds(InputInfoPtr pInfo);
 _X_EXPORT InputDriverRec KBD = {
 ,
 	"kbd",
 	NULL,
 	KbdPreInit,
 	NULL,
 	NULL
 };
 _X_EXPORT InputDriverRec KEYBOARD = {
 ,
 	"keyboard",
 	NULL,
 	KbdPreInit,
 	NULL,
 	NULL
 };
 static const char *kbdDefaults[] = {
 #ifdef __NetBSD__
 #ifdef DEFAULT_TO_WSKBD
     "Protocol",		"wskbd",
 #else
     "Protocol",		"standard",
 #endif
 #else /* NetBSD */
     "Protocol",		"standard",
 #endif /* NetBSD */
     "XkbRules",		"base",
     "XkbModel",		"pc105",
     "XkbLayout",	"us",
     NULL
 };
 static char *xkb_rules;
 static char *xkb_model;
 static char *xkb_layout;
 static char *xkb_variant;
 static char *xkb_options;
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 12
+_X_EXPORT InputDriverRec KBD = {
-static int
+,
-NewKbdPreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags);
+    "kbd",
     NULL,
-static InputInfoPtr
+    KbdPreInit,
-KbdPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
+    NULL,
     NULL
-    InputInfoPtr pInfo;
+};
-    if (!(pInfo = xf86AllocateInput(drv, 0)))
+_X_EXPORT InputDriverRec KEYBOARD = {
-	return NULL;
+,
     "keyboard",
     NULL,
     KbdPreInit,
     NULL,
     NULL
 };
-    pInfo->name = dev->identifier;
+static XF86ModuleVersionInfo xf86KbdVersionRec = {
-    pInfo->flags = XI86_KEYBOARD_CAPABLE;
+    "kbd",
-    pInfo->conversion_proc = NULL;
+    MODULEVENDORSTRING,
-    pInfo->reverse_conversion_proc = NULL;
+    MODINFOSTRING1,
-    pInfo->private_flags = 0;
+    MODINFOSTRING2,
-    pInfo->always_core_feedback = NULL;
+    XORG_VERSION_CURRENT,
-    pInfo->conf_idev = dev;
+    PACKAGE_VERSION_MAJOR, PACKAGE_VERSION_MINOR, PACKAGE_VERSION_PATCHLEVEL,
-    pInfo->close_proc = NULL;
+    ABI_CLASS_XINPUT,
     ABI_XINPUT_VERSION,
-    if (NewKbdPreInit(drv, pInfo, flags) == Success)
+    MOD_CLASS_XINPUT,
     {0, 0, 0, 0}
-        pInfo->flags |= XI86_CONFIGURED;
+};
         return pInfo;
-    xf86DeleteInput(pInfo, 0);
+static pointer
-    return NULL;
+xf86KbdPlug(pointer module, pointer options, int *errmaj, int *errmin)
+{
     xf86AddInputDriver(&KBD, module, 0);
     return module;
+}
-static int
+_X_EXPORT XF86ModuleData kbdModuleData = {
-NewKbdPreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags)
+    &xf86KbdVersionRec,
-#else
+    xf86KbdPlug,
     NULL
 };
 static int
 KbdPreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags)
 #endif
+{
     KbdDevPtr pKbd;
     char *s;
     const char **defaults;
     int rc = Success;
     /* Initialise the InputInfoRec. */
     pInfo->type_name = XI_KEYBOARD;
     pInfo->device_control = KbdProc;
     /*
      * We don't specify our own read_input function. We expect
      * an OS specific readInput() function to handle this.
      */
     pInfo->read_input = NULL;
     pInfo->control_proc = NULL;
     pInfo->switch_mode = NULL;
     pInfo->fd = -1;
     pInfo->dev = NULL;
     defaults = kbdDefaults;
-    xf86CollectInputOptions(pInfo, defaults
+    xf86CollectInputOptions(pInfo, defaults);
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 12
             , NULL
 #endif
             );
     xf86ProcessCommonOptions(pInfo, pInfo->options);
     if (!(pKbd = calloc(sizeof(KbdDevRec), 1))) {
         rc = BadAlloc;
         goto out;
+    }
     pInfo->private = pKbd;
     pKbd->PostEvent = PostKbdEvent;
     if (!xf86OSKbdPreInit(pInfo)) {
         rc = BadAlloc;
         goto out;
 @@ -299,115 +286,110 @@ InitKBD(InputInfoPtr pInfo, Bool init)
 	  (leds & INITFLAG ? 0 : leds & NUMFLAG)) {
 	  pKbd->PostEvent(pInfo, KEY_NumLock, TRUE);
 	  pKbd->PostEvent(pInfo, KEY_NumLock, FALSE);
+      }
+  }
+}
 static int
 KbdProc(DeviceIntPtr device, int what)
+{
   InputInfoPtr pInfo = device->public.devicePrivate;
   KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
   XkbRMLVOSet rmlvo;
   KeySymsRec           keySyms;
   CARD8                modMap[MAP_LENGTH];
   int                  ret;
   switch (what) {
      case DEVICE_INIT:
          ret = pKbd->KbdInit(pInfo, what);
          if (ret != Success)
              return ret;
          pKbd->KbdGetMapping(pInfo, &keySyms, modMap);
          device->public.on = FALSE;
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 5
+         rmlvo.rules = xkb_rules;
          rmlvo.model = xkb_model;
-             XkbRMLVOSet rmlvo;
+         rmlvo.layout = xkb_layout;
-             rmlvo.rules = xkb_rules;
+         rmlvo.variant = xkb_variant;
-             rmlvo.model = xkb_model;
+         rmlvo.options = xkb_options;
              rmlvo.layout = xkb_layout;
              rmlvo.variant = xkb_variant;
              rmlvo.options = xkb_options;
-             if (!InitKeyboardDeviceStruct(device, &rmlvo, KbdBell, KbdCtrl))
+         if (!InitKeyboardDeviceStruct(device, &rmlvo, KbdBell, KbdCtrl))
+         {
-                 xf86Msg(X_ERROR, "%s: Keyboard initialization failed. This "
+             xf86Msg(X_ERROR, "%s: Keyboard initialization failed. This "
-                         "could be a missing or incorrect setup of "
+                     "could be a missing or incorrect setup of "
-                         "xkeyboard-config.\n", device->name);
+                     "xkeyboard-config.\n", device->name);
-                 return BadValue;
+             return BadValue;
+         }
 # ifdef XI_PROP_DEVICE_NODE
+         {
              const char *device_node =
                  xf86CheckStrOption(pInfo->options, "Device", NULL);
              if (device_node)
+             {
                  Atom prop_device = MakeAtom(XI_PROP_DEVICE_NODE,
                                              strlen(XI_PROP_DEVICE_NODE), TRUE);
                  XIChangeDeviceProperty(device, prop_device, XA_STRING, 8,
                                         PropModeReplace, strlen(device_node),
                                         device_node, FALSE);
+             }
+         }
 # endif /* XI_PROP_DEVICE_NODE */
 #else
              XkbComponentNamesRec xkbnames;
              memset(&xkbnames, 0, sizeof(xkbnames));
              XkbSetRulesDflts(xkb_rules, xkb_model, xkb_layout,
                               xkb_variant, xkb_options);
              XkbInitKeyboardDeviceStruct(device, &xkbnames, &keySyms,
                                          modMap, KbdBell,
                                          (KbdCtrlProcPtr)KbdCtrl);
 #endif /* XINPUT ABI 5*/
          InitKBD(pInfo, TRUE);
          break;
   case DEVICE_ON:
     if (device->public.on)
 	break;
     /*
      * Set the keyboard into "direct" mode and turn on
      * event translation.
      */
     if ((ret = pKbd->KbdOn(pInfo, what)) != Success)
 	return ret;
     /*
      * Discard any pending input after a VT switch to prevent the server
      * passing on parts of the VT switch sequence.
      */
     if (pInfo->fd >= 0) {
 	xf86FlushInput(pInfo->fd);
 #if HAVE_THREADED_INPUT
 	xf86AddEnabledDevice(pInfo);
 #else
 	AddEnabledDevice(pInfo->fd);
 #endif
+    }
     device->public.on = TRUE;
     InitKBD(pInfo, FALSE);
     break;
   case DEVICE_CLOSE:
   case DEVICE_OFF:
     /*
      * Restore original keyboard directness and translation.
      */
-    if (pInfo->fd != -1)
+    if (pInfo->fd != -1) {
 #if HAVE_THREADED_INPUT
       xf86RemoveEnabledDevice(pInfo);
 #else
       RemoveEnabledDevice(pInfo->fd);
 #endif
+    }
     pKbd->KbdOff(pInfo, what);
     device->public.on = FALSE;
     break;
   default:
     return BadValue;
+  }
   return (Success);
+}
 static void
 PostKbdEvent(InputInfoPtr pInfo, unsigned int scanCode, Bool down)
+{
 @@ -441,50 +423,13 @@ PostKbdEvent(InputInfoPtr pInfo, unsigne
    * they need to get the same key code as the base key on the same
    * physical keyboard key.
    */
   state = XkbStateFieldFromRec(&keyc->xkbInfo->state);
   if (((state & AltMask) == AltMask) && (scanCode == KEY_SysReqest))
     scanCode = KEY_Print;
   else if (scanCode == KEY_Break)
     scanCode = KEY_Pause;
   xf86PostKeyboardEvent(device, scanCode + MIN_KEYCODE, down);
+}
 static void
 xf86KbdUnplug(pointer	p)
 static pointer
 xf86KbdPlug(pointer	module,
 	    pointer	options,
 	    int		*errmaj,
 	    int		*errmin)
     xf86AddInputDriver(&KBD, module, 0);
     return module;
 static XF86ModuleVersionInfo xf86KbdVersionRec =
     "kbd",
     MODULEVENDORSTRING,
     MODINFOSTRING1,
     MODINFOSTRING2,
     XORG_VERSION_CURRENT,
     PACKAGE_VERSION_MAJOR, PACKAGE_VERSION_MINOR, PACKAGE_VERSION_PATCHLEVEL,
     ABI_CLASS_XINPUT,
     ABI_XINPUT_VERSION,
     MOD_CLASS_XINPUT,
     {0, 0, 0, 0}		/* signature, to be patched into the file by */
 				/* a tool */
 };
 _X_EXPORT XF86ModuleData kbdModuleData = {
     &xf86KbdVersionRec,
     xf86KbdPlug,
     xf86KbdUnplug
 };

 @@ -119,40 +119,51 @@ 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;
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 23
 #define HAVE_THREADED_INPUT	1
 #endif
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 24
 #define BLOCK_HANDLER_ARGS     	void *data, void *waitTime
 #define WAKEUP_HANDLER_ARGS	void *data, int i
 #else
 #define BLOCK_HANDLER_ARGS	pointer data, struct timeval **waitTime, pointer LastSelectMask
 #define WAKEUP_HANDLER_ARGS	void *data, int i, pointer LastSelectMask
 #endif
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 12
 static InputInfoPtr MousePreInit(InputDriverPtr drv, IDevPtr dev, int flags);
 #else
 static int MousePreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags);
 #endif
 static int MouseProc(DeviceIntPtr device, int what);
 static void MouseCtrl(DeviceIntPtr device, PtrCtrl *ctrl);
 static void MousePostEvent(InputInfoPtr pInfo, int buttons,
                            int dx, int dy, int dz, int dw);
 static void MouseReadInput(InputInfoPtr pInfo);
-static void MouseBlockHandler(pointer data, struct timeval **waitTime,
+static void MouseBlockHandler(BLOCK_HANDLER_ARGS);
-                              pointer LastSelectMask);
+static void MouseWakeupHandler(WAKEUP_HANDLER_ARGS);
 static void MouseWakeupHandler(pointer data, int i, pointer LastSelectMask);
 static void FlushButtons(MouseDevPtr pMse);
 static Bool SetupMouse(InputInfoPtr pInfo);
 static Bool initMouseHW(InputInfoPtr pInfo);
 #ifdef SUPPORT_MOUSE_RESET
 static Bool mouseReset(InputInfoPtr pInfo, unsigned char val);
 static void ps2WakeupHandler(pointer data, int i, pointer LastSelectMask);
 static void ps2BlockHandler(pointer data, struct timeval **waitTime,
                             pointer LastSelectMask);
 #endif
 static void Emulate3ButtonsSetEnabled(InputInfoPtr pInfo, Bool enable);
 /* mouse autoprobe stuff */
 @@ -2015,43 +2026,53 @@ static char reverseMap[16] = { 0,  4,  2
 , 13, 11, 15 };
 static char hitachMap[16] = {  0,  2,  1,  3,
 , 10,  9, 11,
 ,  6,  5,  7,
 , 14, 13, 15 };
 #define reverseBits(map, b)     (((b) & ~0x0f) | map[(b) & 0x0f])
 static CARD32
 buttonTimer(InputInfoPtr pInfo)
+{
     MouseDevPtr pMse;
 #if !HAVE_THREADED_INPUT
     int sigstate;
 #endif
     int id;
     pMse = pInfo->private;
 #if HAVE_THREADED_INPUT
     input_lock();
 #else
     sigstate = xf86BlockSIGIO ();
 #endif
     pMse->emulate3Pending = FALSE;
     if ((id = stateTab[pMse->emulateState][4][0]) != 0) {
         xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
         pMse->emulateState = stateTab[pMse->emulateState][4][2];
     } else {
         LogMessageVerbSigSafe(X_WARNING, -1,
             "Got unexpected buttonTimer in state %d\n", pMse->emulateState);
+    }
 #if HAVE_THREADED_INPUT
     input_unlock();
 #else
     xf86UnblockSIGIO (sigstate);
 #endif
     return 0;
+}
 static void
 Emulate3ButtonsSetEnabled(InputInfoPtr pInfo, Bool enable)
+{
     MouseDevPtr pMse = pInfo->private;
     if (pMse->emulate3Buttons == enable)
         return;
     pMse->emulate3Buttons = enable;
 @@ -2088,46 +2109,42 @@ Emulate3ButtonsSoft(InputInfoPtr pInfo)
      * 3 buttons.
      */
     return TRUE;
 #else
     LogMessageVerbSigSafe(X_INFO, 4,
         "mouse: 3rd Button detected: disabling emulate3Button\n");
     Emulate3ButtonsSetEnabled(pInfo, FALSE);
     return FALSE;
 #endif
+}
-static void MouseBlockHandler(pointer data,
+static void MouseBlockHandler(BLOCK_HANDLER_ARGS)
                               struct timeval **waitTime,
                               pointer LastSelectMask)
+{
     InputInfoPtr    pInfo = (InputInfoPtr) data;
     MouseDevPtr     pMse = (MouseDevPtr) pInfo->private;
     int             ms;
     if (pMse->emulate3Pending)
+    {
         ms = pMse->emulate3Expires - GetTimeInMillis ();
         if (ms <= 0)
             ms = 0;
         AdjustWaitForDelay (waitTime, ms);
+    }
+}
-static void MouseWakeupHandler(pointer data,
+static void MouseWakeupHandler(WAKEUP_HANDLER_ARGS)
                                int i,
                                pointer LastSelectMask)
+{
     InputInfoPtr    pInfo = (InputInfoPtr) data;
     MouseDevPtr     pMse = (MouseDevPtr) pInfo->private;
     int             ms;
     if (pMse->emulate3Pending)
+    {
         ms = pMse->emulate3Expires - GetTimeInMillis ();
         if (ms <= 0)
             buttonTimer (pInfo);
+    }
+}
 @@ -3266,34 +3283,40 @@ autoOSProtocol(InputInfoPtr pInfo, int *
 /*
  * createProtocolList() -- create a list of protocols which may
  * match on the incoming data stream.
  */
 static void
 createProtoList(MouseDevPtr pMse, MouseProtocolID *protoList)
+{
     int i, j, k  = 0;
     MouseProtocolID prot;
     unsigned char *para;
     mousePrivPtr mPriv = (mousePrivPtr)pMse->mousePriv;
     MouseProtocolID *tmplist = NULL;
 #if !HAVE_THREADED_INPUT
     int blocked;
 #endif
     AP_DBGC(("Autoprobe: "));
     for (i = 0; i < mPriv->count; i++)
         AP_DBGC(("%2.2x ", (unsigned char) mPriv->data[i]));
     AP_DBGC(("\n"));
 #if HAVE_THREADED_INPUT
     input_lock();
 #else
     blocked = xf86BlockSIGIO ();
 #endif
     /* create a private copy first so we can write in the old list */
     if ((tmplist = malloc(sizeof(MouseProtocolID) * NUM_AUTOPROBE_PROTOS))){
         for (i = 0; protoList[i] != PROT_UNKNOWN; i++) {
             tmplist[i] = protoList[i];
+        }
         tmplist[i] = PROT_UNKNOWN;
         protoList = tmplist;
     } else
         return;
     for (i = 0; ((prot = protoList[i]) != PROT_UNKNOWN
                  && (k < NUM_AUTOPROBE_PROTOS - 1)) ; i++) {
 @@ -3382,27 +3405,31 @@ createProtoList(MouseDevPtr pMse, MouseP
+            }
             j = next_header_candidate;
             next_header_candidate = 0;
             /* we have tested number of bytes per package for header */
             if (j > para[4] && ++header_count > para[4])
                 break;
             /* we have not found anything that looks like a header */
             if (!next_header_candidate)
                 break;
             AP_DBG(("Looking for new header\n"));
+        }
+    }
 #if HAVE_THREADED_INPUT
     input_unlock();
 #else
     xf86UnblockSIGIO(blocked);
 #endif
     mPriv->protoList[k] = PROT_UNKNOWN;
     free(tmplist);
+}
 /* This only needs to be done once */
 static void **serialDefaultsList = NULL;
 /*
  * createSerialDefaultsLists() - create a list of the different default
  * settings for the serial interface of the known protocols.

 @@ -1,8 +1,10 @@
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
 includedir=@includedir@
 sdkdir=@sdkdir@
 Name: xorg-mouse
 Description: X.Org mouse input driver for non-evdev OS'es
 Version: @PACKAGE_VERSION@
 Cflags: -I${sdkdir}