Merge branch 'input-hotplug' of git+ssh://git.freedesktop.org/git/xorg/xserver into input-hotplug

.gitignore

@@ -267,3 +267,4 @@ mfb/mfbteblack.c
 mfb/mfbtewhite.c
 mfb/mfbtileC.c
 mfb/mfbtileG.c
+.*.swp

Makefile.am

@@ -26,10 +26,6 @@ if GLX
 GLX_DIR=GL
 endif
 
-if XINPUT
-XINPUT_DIR=Xi
-endif
-
 if DBE
 DBE_DIR=dbe
 endif
@@ -45,7 +41,7 @@ SUBDIRS = \
 	os \
 	randr \
 	render  \
-	$(XINPUT_DIR) \
+	Xi \
 	xkb \
 	$(DBE_DIR) \
 	$(MFB_DIR) \
@@ -59,6 +55,7 @@ SUBDIRS = \
 	$(COMPOSITE_DIR) \
 	$(GLX_DIR) \
 	exa \
+	config \
 	hw
 
 aclocaldir = $(datadir)/aclocal

Xi/chgdctl.c

@@ -104,6 +104,8 @@ ProcXChangeDeviceControl(ClientPtr client)
     xChangeDeviceControlReply rep;
     AxisInfoPtr a;
     CARD32 *resolution;
+    xDeviceTSCtl *ts;
+    xDeviceCoreCtl *c;
 
     REQUEST(xChangeDeviceControlReq);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
@@ -168,6 +170,54 @@ ProcXChangeDeviceControl(ClientPtr client)
 	    return Success;
 	}
 	break;
+    case DEVICE_TOUCHSCREEN:
+        ts = (xDeviceTSCtl *)&stuff[1];
+
+        if (ts->button_threshold < 0 || ts->button_threshold > 255) {
+            SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+                              BadValue);
+            return Success;
+        }
+
+        status = ChangeDeviceControl(client, dev, (xDeviceCtl *) ts);
+
+        if (status == Success) {
+            dev->touchscreen->min_x = ts->min_x;
+            dev->touchscreen->max_x = ts->max_x;
+            dev->touchscreen->min_y = ts->min_y;
+            dev->touchscreen->max_y = ts->max_y;
+            dev->touchscreen->button_threshold = ts->button_threshold;
+        } else if (status == DeviceBusy) {
+            rep.status = DeviceBusy;
+            WriteReplyToClient(client, sizeof(xChangeDeviceControlReply),
+                               &rep);
+            return Success;
+        } else {
+            SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+                              BadMatch);
+            return Success;
+        }
+
+        break;
+    case DEVICE_CORE:
+        c = (xDeviceCoreCtl *)&stuff[1];
+
+        status = ChangeDeviceControl(client, dev, (xDeviceCtl *) c);
+
+        if (status == Success) {
+            dev->coreEvents = c->status;
+        } else if (status == DeviceBusy) {
+            rep.status = DeviceBusy;
+            WriteReplyToClient(client, sizeof(xChangeDeviceControlReply),
+                               &rep);
+            return Success;
+        } else {
+            SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+                              BadMatch);
+            return Success;
+        }
+
+        break;
     default:
 	SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, BadValue);
 	return Success;

Xi/exevents.c

@@ -302,7 +302,12 @@ _X_EXPORT void
 InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
 		       int resolution, int min_res, int max_res)
 {
-    register AxisInfoPtr ax = dev->valuator->axes + axnum;
+    register AxisInfoPtr ax;
+   
+    if (!dev || !dev->valuator)
+        return NULL;
+
+    ax = dev->valuator->axes + axnum;
 
     ax->min_value = minval;
     ax->max_value = maxval;

Xi/exglobals.h

@@ -51,6 +51,7 @@ extern Mask DeviceMappingNotifyMask;
 extern Mask DeviceOwnerGrabButtonMask;
 extern Mask DeviceButtonGrabMask;
 extern Mask DeviceButtonMotionMask;
+extern Mask DevicePresenceNotifyMask;
 extern Mask PropagateMask[];
 
 extern int DeviceValuator;
@@ -68,12 +69,8 @@ extern int DeviceKeyStateNotify;
 extern int DeviceButtonStateNotify;
 extern int DeviceMappingNotify;
 extern int ChangeDeviceNotify;
+extern int DevicePresenceNotify;
 
 extern int RT_INPUTCLIENT;
 
-#if 0
-/* FIXME: in dix */
-extern InputInfo inputInfo;
-#endif
-
 #endif /* EXGLOBALS_H */

Xi/extinit.c

@@ -166,6 +166,7 @@ Mask DeviceMappingNotifyMask;
 Mask DeviceOwnerGrabButtonMask;
 Mask DeviceButtonGrabMask;
 Mask DeviceButtonMotionMask;
+Mask DevicePresenceNotifyMask;
 
 int DeviceValuator;
 int DeviceKeyPress;
@@ -182,6 +183,7 @@ int DeviceKeyStateNotify;
 int DeviceButtonStateNotify;
 int DeviceMappingNotify;
 int ChangeDeviceNotify;
+int DevicePresenceNotify;
 
 int RT_INPUTCLIENT;
 
@@ -202,8 +204,8 @@ Mask PropagateMask[MAX_DEVICES];
  */
 
 static XExtensionVersion thisversion = { XI_Present,
-    XI_Add_XChangeDeviceControl_Major,
+    XI_Add_DevicePresenceNotify_Major,
-    XI_Add_XChangeDeviceControl_Minor
+    XI_Add_DevicePresenceNotify_Minor
 };
 
 /**********************************************************************
@@ -648,6 +650,16 @@ SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
     swapl(&to->time, n);
 }
 
+void
+SDevicePresenceNotifyEvent (devicePresenceNotify *from, devicePresenceNotify *to)
+{
+    register char n;
+
+    *to = *from;
+    swaps(&to->sequenceNumber,n);
+    swapl(&to->time, n);
+}
+
 /************************************************************************
  *
  * This function sets up extension event types and masks.
@@ -674,6 +686,7 @@ FixExtensionEvents(ExtensionEntry * extEntry)
     ChangeDeviceNotify = DeviceMappingNotify + 1;
     DeviceKeyStateNotify = ChangeDeviceNotify + 1;
     DeviceButtonStateNotify = DeviceKeyStateNotify + 1;
+    DevicePresenceNotify = DeviceButtonStateNotify + 1;
 
     event_base[KeyClass] = DeviceKeyPress;
     event_base[ButtonClass] = DeviceButtonPress;
@@ -746,6 +759,9 @@ FixExtensionEvents(ExtensionEntry * extEntry)
 
     DeviceOwnerGrabButtonMask = GetNextExtEventMask();
     SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
+
+    DevicePresenceNotifyMask = GetNextExtEventMask();
+    SetEventInfo(DevicePresenceNotifyMask, _devicePresence);
     SetEventInfo(0, _noExtensionEvent);
 }
 
@@ -786,6 +802,7 @@ RestoreExtensionEvents(void)
     ChangeDeviceNotify = 12;
     DeviceKeyStateNotify = 13;
     DeviceButtonStateNotify = 13;
+    DevicePresenceNotify = 14;
 
     BadDevice = 0;
     BadEvent = 1;
@@ -823,6 +840,7 @@ IResetProc(ExtensionEntry * unused)
     EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
     EventSwapVector[DeviceMappingNotify] = NotImplemented;
     EventSwapVector[ChangeDeviceNotify] = NotImplemented;
+    EventSwapVector[DevicePresenceNotify] = NotImplemented;
     RestoreExtensionEvents();
 }
 
@@ -857,9 +875,7 @@ MakeDeviceTypeAtoms(void)
 }
 
 /**************************************************************************
- *
  * Return a DeviceIntPtr corresponding to a specified device id.
- * This will not return the pointer or keyboard, or devices that are not on.
  *
  */
 
@@ -869,13 +885,16 @@ LookupDeviceIntRec(CARD8 id)
     DeviceIntPtr dev;
 
     for (dev = inputInfo.devices; dev; dev = dev->next) {
-	if (dev->id == id) {
+	if (dev->id == id)
-	    if (id == inputInfo.pointer->id || id == inputInfo.keyboard->id)
+	    return dev;
-		return (NULL);
-	    return (dev);
-	}
     }
-    return (NULL);
+
+    for (dev = inputInfo.off_devices; dev; dev = dev->next) {
+	if (dev->id == id)
+	    return dev;
+    }
+
+    return NULL;
 }
 
 /**************************************************************************

Xi/getdctl.c

@@ -124,6 +124,18 @@ ProcXGetDeviceControl(ClientPtr client)
 	total_length = sizeof(xDeviceResolutionState) +
 	    (3 * sizeof(int) * dev->valuator->numAxes);
 	break;
+    case DEVICE_TOUCHSCREEN:
+        if (!dev->touchscreen) {
+            SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
+                              BadMatch);
+            return Success;
+        }
+
+        total_length = sizeof(xDeviceTSCtl);
+        break;
+    case DEVICE_CORE:
+        total_length = sizeof(xDeviceCoreCtl);
+        break;
     default:
 	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadValue);
 	return Success;
@@ -140,6 +152,11 @@ ProcXGetDeviceControl(ClientPtr client)
     case DEVICE_RESOLUTION:
 	CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
 	break;
+    case DEVICE_TOUCHSCREEN:
+        CopySwapDeviceTouchscreen(client, dev->touchscreen, buf);
+        break;
+    case DEVICE_CORE:
+        CopySwapDeviceCore(client, dev, buf);
     default:
 	break;
     }
@@ -189,6 +206,48 @@ CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
     }
 }
 
+void CopySwapDeviceTouchscreen (ClientPtr client, TouchscreenClassPtr dts,
+                                char *buf)
+{
+    register char n;
+    xDeviceTSState *ts = (xDeviceTSState *) buf;
+
+    ts->control = DEVICE_TOUCHSCREEN;
+    ts->length = sizeof(ts);
+    ts->min_x = dts->min_x;
+    ts->max_x = dts->max_x;
+    ts->min_y = dts->min_y;
+    ts->max_y = dts->max_y;
+    ts->button_threshold = dts->button_threshold;
+
+    if (client->swapped) {
+        swaps(&ts->control, n);
+        swaps(&ts->length, n);
+        swapl(&ts->min_x, n);
+        swapl(&ts->max_x, n);
+        swapl(&ts->min_y, n);
+        swapl(&ts->max_y, n);
+        swapl(&ts->button_threshold, n);
+    }
+}
+
+void CopySwapDeviceCore (ClientPtr client, DeviceIntPtr dev, char *buf)
+{
+    register char n;
+    xDeviceCoreState *c = (xDeviceCoreState *) buf;
+
+    c->control = DEVICE_CORE;
+    c->length = sizeof(c);
+    c->status = dev->coreEvents;
+
+    if (client->swapped) {
+        swaps(&c->control, n);
+        swaps(&c->length, n);
+        swaps(&c->status, n);
+    }
+}
+
+
 /***********************************************************************
  *
  * This procedure writes the reply for the xGetDeviceControl function,

Xi/getdctl.h

@@ -42,6 +42,16 @@ void CopySwapDeviceResolution(ClientPtr /* client */ ,
 			      int	/* length */
     );
 
+void CopySwapDeviceTouchscreen(ClientPtr /* client */ ,
+                               TouchscreenClassPtr /* ts */ ,
+                               char * /* buf */
+    );
+
+void CopySwapDeviceCore(ClientPtr /* client */ ,
+                        DeviceIntPtr /* dev */ ,
+                        char * /* buf */
+    );
+
 void SRepXGetDeviceControl(ClientPtr /* client */ ,
 			   int /* size */ ,
 			   xGetDeviceControlReply *	/* rep */

Xi/listdev.c

@@ -96,7 +96,7 @@ int
 ProcXListInputDevices(register ClientPtr client)
 {
     xListInputDevicesReply rep;
-    int numdevs;
+    int numdevs = 0;
     int namesize = 1;	/* need 1 extra byte for strcpy */
     int size = 0;
     int total_length;
@@ -115,12 +115,15 @@ ProcXListInputDevices(register ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     AddOtherInputDevices();
-    numdevs = inputInfo.numDevices;
 
-    for (d = inputInfo.devices; d; d = d->next)
+    for (d = inputInfo.devices; d; d = d->next) {
 	SizeDeviceInfo(d, &namesize, &size);
-    for (d = inputInfo.off_devices; d; d = d->next)
+        numdevs++;
+    }
+    for (d = inputInfo.off_devices; d; d = d->next) {
 	SizeDeviceInfo(d, &namesize, &size);
+        numdevs++;
+    }
 
     total_length = numdevs * sizeof(xDeviceInfo) + size + namesize;
     devbuf = (char *)xalloc(total_length);
@@ -241,6 +244,10 @@ CopySwapDevice(register ClientPtr client, DeviceIntPtr d, int num_classes,
 	dev->use = IsXKeyboard;
     else if (d == inputInfo.pointer)
 	dev->use = IsXPointer;
+    else if (d->key && d->kbdfeed)
+        dev->use = IsXExtensionKeyboard;
+    else if (d->valuator && d->button)
+        dev->use = IsXExtensionPointer;
     else
 	dev->use = IsXExtensionDevice;
     if (client->swapped) {

Xi/selectev.c

@@ -74,6 +74,53 @@ SOFTWARE.
 extern Mask ExtExclusiveMasks[];
 extern Mask ExtValidMasks[];
 
+static int
+HandleDevicePresenceMask(ClientPtr client, WindowPtr win,
+                         XEventClass *cls, CARD16 *count)
+{
+    int i, j;
+    Mask mask;
+
+    /* We use the device ID 256 to select events that aren't bound to
+     * any device.  For now we only handle the device presence event,
+     * but this could be extended to other events that aren't bound to
+     * a device.
+     *
+     * In order not to break in CreateMaskFromList() we remove the
+     * entries with device ID 256 from the XEventClass array.
+     */
+
+    mask = 0;
+    for (i = 0, j = 0; i < *count; i++) {
+        if (cls[i] >> 8 != 256) {
+            cls[j] = cls[i];
+            j++;
+            continue;
+        }
+
+        switch (cls[i] & 0xff) {
+        case _devicePresence:
+            mask |= DevicePresenceNotifyMask;
+            break;
+        }
+    }
+
+    *count = j;
+
+    if (mask == 0)
+        return Success;
+
+    /* We always only use mksidx = 0 for events not bound to
+     * devices */
+
+    if (AddExtensionClient (win, client, mask, 0) != Success)
+        return BadAlloc;
+
+    RecalculateDeviceDeliverableEvents(win);
+
+    return Success;
+}
+
 /***********************************************************************
  *
  * Handle requests from clients with a different byte order.
@@ -131,6 +178,13 @@ ProcXSelectExtensionEvent(register ClientPtr client)
 	return Success;
     }
 
+    if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1],
+                                &stuff->count) != Success) {
+       SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
+                         BadAlloc);
+       return Success;
+    }
+
     if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
 				  stuff->count, tmp, NULL,
 				  X_SelectExtensionEvent)) != Success)

Xi/stubs.c

@@ -287,6 +287,10 @@ ChangeDeviceControl(register ClientPtr client, DeviceIntPtr dev,
     switch (control->control) {
     case DEVICE_RESOLUTION:
 	return (BadMatch);
+    case DEVICE_TOUCHSCREEN:
+        return (BadMatch);
+    case DEVICE_CORE:
+        return (BadMatch);
     default:
 	return (BadMatch);
     }

config/Makefile.am

@@ -0,0 +1,10 @@
+AM_CFLAGS = @DIX_CFLAGS@
+
+dbusconfigdir = $(sysconfdir)/dbus-1/system.d
+dbusconfig_DATA = xorg-server.conf
+
+lib_LIBRARIES = libconfig.a
+
+libconfig_a_SOURCES = config.c
+
+EXTRA_DIST = xorg-server.conf

config/config.c

@@ -0,0 +1,297 @@
+/*
+ * Copyright © 2006 Daniel Stone
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the copyright holders and/or authors
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  The copyright holders
+ * and/or authors make no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without express or
+ * implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS AND/OR AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD
+ * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND/OR AUTHORS BE LIABLE
+ * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifdef HAVE_DBUS
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <dbus/dbus.h>
+#include <string.h>
+#include "opaque.h" /* for 'display': there has to be a better way */
+                    /* the above comment lies.  there is no better way. */
+#include "input.h"
+#include "config.h"
+
+#define MATCH_RULE "type='method_call',interface='org.x.config.input'"
+
+static DBusConnection *configConnection = NULL;
+static int configfd = -1;
+static char busobject[32] = { 0 };
+static char busname[64] = { 0 };
+
+void
+configDispatch()
+{
+    if (!configConnection)
+        return;
+
+    dbus_connection_read_write_dispatch(configConnection, 0);
+}
+
+static DBusHandlerResult
+configMessage(DBusConnection *connection, DBusMessage *message, void *closure)
+{
+    InputOption *option = NULL, *ret = NULL;
+    DBusMessageIter iter, subiter;
+    DBusError error;
+    char *tmp = NULL;
+    int deviceid = -1;
+    DeviceIntPtr pDev = NULL;
+
+#ifdef DEBUG
+    ErrorF("[dbus] new message!\n");
+    ErrorF("       source: %s\n", dbus_message_get_sender(message));
+    ErrorF("       destination: %s\n", dbus_message_get_destination(message));
+    ErrorF("       signature: %s\n", dbus_message_get_signature(message));
+    ErrorF("       path: %s\n", dbus_message_get_path(message));
+    ErrorF("       interface: %s\n", dbus_message_get_interface(message));
+    ErrorF("       member: %s\n", dbus_message_get_member(message));
+    ErrorF("       method call? %s\n", (dbus_message_get_type(message) ==
+                                         DBUS_MESSAGE_TYPE_METHOD_CALL) ?
+                                        "yes" : "no");
+#endif
+
+    dbus_error_init(&error);
+
+    if (strcmp(dbus_message_get_interface(message),
+               "org.x.config.input") == 0) {
+        if (!dbus_message_iter_init(message, &iter)) {
+            ErrorF("failed to init iterator! this is probably bad.\n");
+            dbus_error_free(&error);
+            return DBUS_HANDLER_RESULT_NEED_MEMORY; /* ?? */
+        }
+        if (strcmp(dbus_message_get_member(message), "add") == 0) {
+#ifdef DEBUG
+            ErrorF("       we want to add a device!\n");
+#endif
+            /* signature should be [ss][ss]... */
+            while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_ARRAY) {
+                option = (InputOption *)xcalloc(sizeof(InputOption), 1);
+                if (!option) {
+                    while (ret) {
+                        option = ret;
+                        ret = ret->next;
+                        xfree(option);
+                    }
+                    dbus_error_free(&error);
+                    return DBUS_HANDLER_RESULT_NEED_MEMORY;
+                }
+
+                dbus_message_iter_recurse(&iter, &subiter);
+
+                if (dbus_message_iter_get_arg_type(&subiter) !=
+                    DBUS_TYPE_STRING) {
+                    ErrorF("couldn't get the arg type\n");
+                    xfree(option);
+                    dbus_error_free(&error);
+                    return DBUS_HANDLER_RESULT_HANDLED;
+                }
+                dbus_message_iter_get_basic(&subiter, &tmp);
+                if (!tmp) {
+                    ErrorF("couldn't get the key!\n");
+                    xfree(option);
+                    break;
+                }
+                option->key = xstrdup(tmp);
+                if (!option->key) {
+                    ErrorF("couldn't duplicate the key!\n");
+                    xfree(option);
+                    break;
+                }
+
+                if (!dbus_message_iter_has_next(&subiter)) {
+                    ErrorF("broken message: no next\n");
+                    xfree(option->key);
+                    xfree(option);
+                    dbus_error_free(&error);
+                    return DBUS_HANDLER_RESULT_HANDLED;
+                }
+                dbus_message_iter_next(&subiter);
+
+                if (dbus_message_iter_get_arg_type(&subiter) !=
+                    DBUS_TYPE_STRING) {
+                    ErrorF("couldn't get the arg type\n");
+                    xfree(option);
+                    dbus_error_free(&error);
+                    return DBUS_HANDLER_RESULT_HANDLED;
+                }
+                dbus_message_iter_get_basic(&subiter, &tmp);
+                if (!tmp) {
+                    ErrorF("couldn't get the value!\n");
+                    xfree(option->key);
+                    xfree(option);
+                    break;
+                }
+                option->value = xstrdup(tmp);
+                if (!option->value) {
+                    ErrorF("couldn't duplicate the option!\n");
+                    xfree(option->value);
+                    xfree(option);
+                    break;
+                }
+
+                option->next = ret;
+                ret = option;
+                dbus_message_iter_next(&iter);
+            }
+
+            if (NewInputDeviceRequest(ret) != Success) {
+                ErrorF("[config] NIDR failed\n");
+            }
+            dbus_error_free(&error);
+            return DBUS_HANDLER_RESULT_HANDLED;
+        }
+        else if (strcmp(dbus_message_get_member(message), "remove") == 0) {
+#ifdef DEBUG
+            ErrorF("        we want to remove a device!\n");
+#endif
+            if (!dbus_message_get_args(message, &error, DBUS_TYPE_INT32,
+                                       &deviceid, DBUS_TYPE_INVALID)) {
+                ErrorF("couldn't get args: %s %s\n", error.name, error.message);
+                dbus_error_free(&error);
+                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+            }
+            if (deviceid < 0 || !(pDev = LookupDeviceIntRec(deviceid))) {
+                ErrorF("bogus device id %d\n", deviceid);
+                dbus_error_free(&error);
+                return DBUS_HANDLER_RESULT_HANDLED;
+            }
+            /* Call PIE here so we don't try to dereference a device that's
+             * already been removed.  Technically there's still a small race
+             * here, so we should ensure that SIGIO is blocked. */
+            ProcessInputEvents();
+            RemoveDevice(pDev);
+            dbus_error_free(&error);
+            return DBUS_HANDLER_RESULT_HANDLED;
+        }
+    }
+
+    dbus_error_free(&error);
+
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+void
+configInitialise()
+{
+    DBusConnection *bus = NULL;
+    DBusError error;
+    DBusObjectPathVTable vtable;
+
+    configConnection = NULL;
+
+    dbus_error_init(&error);
+    bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
+    if (!bus || dbus_error_is_set(&error)) {
+        dbus_error_free(&error);
+        FatalError("[dbus] some kind of error occurred: %s (%s)\n", error.name,
+                   error.message);
+        return;
+    }
+
+    if (!dbus_connection_get_unix_fd(bus, &configfd)) {
+        dbus_connection_close(bus);
+        configfd = -1;
+        FatalError("[dbus] couldn't get fd for bus\n");
+        return;
+    }
+
+    snprintf(busname, sizeof(busname), "org.x.config.display%d", atoi(display));
+    if (!dbus_bus_request_name(bus, busname, 0, &error) ||
+        dbus_error_is_set(&error)) {
+        dbus_error_free(&error);
+        dbus_connection_close(bus);
+        configfd = -1;
+        FatalError("[dbus] couldn't take over org.x.config: %s (%s)\n",
+                   error.name, error.message);
+        return;
+    }
+
+    /* blocks until we get a reply. */
+    dbus_bus_add_match(bus, MATCH_RULE, &error);
+    if (dbus_error_is_set(&error)) {
+        dbus_error_free(&error);
+        dbus_bus_release_name(bus, busname, &error);
+        dbus_connection_close(bus);
+        configfd = -1;
+        FatalError("[dbus] couldn't match X.Org rule: %s (%s)\n", error.name,
+                   error.message);
+        return;
+    }
+
+    vtable.message_function = configMessage;
+    snprintf(busobject, sizeof(busobject), "/org/x/config/%d", atoi(display));
+    if (!dbus_connection_register_object_path(bus, busobject, &vtable, NULL)) {
+        configfd = -1;
+        dbus_bus_release_name(bus, busname, &error);
+        dbus_bus_remove_match(bus, MATCH_RULE, &error);
+        dbus_connection_close(bus);
+        FatalError("[dbus] couldn't register object path\n");
+        return;
+    }
+#ifdef DEBUG
+    ErrorF("[dbus] registered object path %s\n", busobject);
+    ErrorF("[dbus] registered and listening\n");
+#endif
+
+    dbus_error_free(&error);
+
+    configConnection = bus;
+
+    AddGeneralSocket(configfd);
+}
+
+void
+configFini()
+{
+    DBusError error;
+
+    if (configConnection) {
+        dbus_error_init(&error);
+        dbus_bus_remove_match(configConnection, MATCH_RULE, &error);
+        dbus_bus_release_name(configConnection, busname, &error);
+        dbus_connection_close(configConnection);
+        RemoveGeneralSocket(configfd);
+        configConnection = NULL;
+        configfd = -1;
+        dbus_error_free(&error);
+    }
+}
+#else
+void
+configDispatch()
+{
+}
+
+void
+configInitialise()
+{
+}
+
+void
+configFini()
+{
+}
+#endif

config/xorg-server.conf

@@ -0,0 +1,13 @@
+<!DOCTYPE busconfig PUBLIC
+ "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+	<policy context="default">
+		<allow own="org.x.config.display0"/>
+		<allow send_destination="org.x.config.display0"/>
+		<allow send_interface="org.x.config.display0"/>
+		<allow own="org.x.config.display1"/>
+		<allow send_destination="org.x.config.display1"/>
+		<allow send_interface="org.x.config.display1"/>
+	</policy>
+</busconfig>

configure.ac

@@ -393,6 +393,12 @@ AC_ARG_ENABLE(install-libxf86config,
 				[Install libxf86config (default: disabled)]),
 				[INSTALL_LIBXF86CONFIG=$enableval],
 				[INSTALL_LIBXF86CONFIG=no])
+AC_ARG_ENABLE(builtin-fonts,  AS_HELP_STRING([--enable-builtin-fonts], [Use only built-in fonts (default: use external)]),
+                                [BUILTIN_FONTS=$enableval],
+                                [BUILTIN_FONTS=no])
+AC_ARG_ENABLE(null-root-cursor, AS_HELP_STRING([--enable-null-root-cursor], [Use an empty root cursor (default: use core cursor)]),
+                                 [NULL_ROOT_CURSOR=$enableval],
+                                 [NULL_ROOT_CURSOR=no])
 
 dnl Extensions.
 AC_ARG_ENABLE(composite,      AS_HELP_STRING([--disable-composite], [Build Composite extension (default: enabled)]), [COMPOSITE=$enableval], [COMPOSITE=yes])
@@ -402,7 +408,7 @@ AC_ARG_ENABLE(xtrap,          AS_HELP_STRING([--disable-xtrap], [Build XTrap ext
 AC_ARG_ENABLE(record,         AS_HELP_STRING([--disable-record], [Build Record extension (default: enabled)]), [RECORD=$enableval], [RECORD=yes])
 AC_ARG_ENABLE(xv,             AS_HELP_STRING([--disable-xv], [Build Xv extension (default: enabled)]), [XV=$enableval], [XV=yes])
 AC_ARG_ENABLE(xvmc,           AS_HELP_STRING([--disable-xvmc], [Build XvMC extension (default: enabled)]), [XVMC=$enableval], [XVMC=yes])
-AC_ARG_ENABLE(dga,            AS_HELP_STRING([--disable-dga], [Build DGA extension (default: enabled)]), [DGA=$enableval], [DGA=yes])
+AC_ARG_ENABLE(dga,            AS_HELP_STRING([--disable-dga], [Build DGA extension (default: auto)]), [DGA=$enableval], [DGA=auto])
 AC_ARG_ENABLE(screensaver,    AS_HELP_STRING([--disable-screensaver], [Build ScreenSaver extension (default: enabled)]), [SCREENSAVER=$enableval], [SCREENSAVER=yes])
 AC_ARG_ENABLE(xdmcp,          AS_HELP_STRING([--disable-xdmcp], [Build XDMCP extension (default: auto)]), [XDMCP=$enableval], [XDMCP=auto])
 AC_ARG_ENABLE(xdm-auth-1,     AS_HELP_STRING([--disable-xdm-auth-1], [Build XDM-Auth-1 extension (default: auto)]), [XDMAUTH=$enableval], [XDMAUTH=auto])
@@ -411,8 +417,8 @@ AC_ARG_ENABLE(aiglx,          AS_HELP_STRING([--enable-aiglx], [Build accelerate
 AC_ARG_ENABLE(glx-tls,        AS_HELP_STRING([--enable-glx-tls], [Build GLX with TLS support (default: disabled)]), [GLX_USE_TLS=$enableval], [GLX_USE_TLS=no])
 AC_ARG_ENABLE(dri,            AS_HELP_STRING([--enable-dri], [Build DRI extension (default: auto)]), [DRI=$enableval])
 AC_ARG_ENABLE(xinerama,	      AS_HELP_STRING([--disable-xinerama], [Build Xinerama extension (default: enabled)]), [XINERAMA=$enableval], [XINERAMA=yes])
-AC_ARG_ENABLE(xf86vidmode,    AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: enabled)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=yes])
+AC_ARG_ENABLE(xf86vidmode,    AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: auto)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=auto])
-AC_ARG_ENABLE(xf86misc,       AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: enabled)]), [XF86MISC=$enableval], [XF86MISC=yes])
+AC_ARG_ENABLE(xf86misc,       AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: auto)]), [XF86MISC=$enableval], [XF86MISC=auto])
 AC_ARG_ENABLE(xcsecurity,     AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: enabled)]), [XCSECURITY=$enableval], [XCSECURITY=yes])
 AC_ARG_ENABLE(xcalibrate,     AS_HELP_STRING([--enable-xcalibrate], [Build XCalibrate extension (default: disabled)]), [XCALIBRATE=$enableval], [XCALIBRATE=no])
 AC_ARG_ENABLE(tslib,          AS_HELP_STRING([--enable-tslib], [Build kdrive tslib touchscreen support (default: disabled)]), [TSLIB=$enableval], [TSLIB=no])
@@ -425,7 +431,7 @@ AC_ARG_ENABLE(fontcache,      AS_HELP_STRING([--enable-fontcache], [Build FontCa
 AC_ARG_ENABLE(dbe,            AS_HELP_STRING([--disable-dbe], [Build DBE extension (default: enabled)]), [DBE=$enableval], [DBE=yes])
 AC_ARG_ENABLE(xf86bigfont,    AS_HELP_STRING([--disable-xf86bigfont], [Build XF86 Big Font extension (default: enabled)]), [XF86BIGFONT=$enableval], [XF86BIGFONT=yes])
 AC_ARG_ENABLE(dpms,           AS_HELP_STRING([--disable-dpms], [Build DPMS extension (default: enabled)]), [DPMSExtension=$enableval], [DPMSExtension=yes])
-AC_ARG_ENABLE(xinput,         AS_HELP_STRING([--disable-xinput], [Build XInput Extension (default: enabled)]), [XINPUT=$enableval], [XINPUT=yes])
+AC_ARG_ENABLE(dbus,           AS_HELP_STRING([--disable-dbus], [Build D-BUS support (default: auto)]), [DBUS=$enableval], [DBUS=auto])
 AC_ARG_ENABLE(xfree86-utils,     AS_HELP_STRING([--enable-xfree86-utils], [Build xfree86 DDX utilities (default: enabled)]), [XF86UTILS=$enableval], [XF86UTILS=yes])
 
 dnl DDXes.
@@ -442,6 +448,9 @@ dnl kdrive and its subsystems
 AC_ARG_ENABLE(kdrive,         AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
 AC_ARG_ENABLE(xephyr,         AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=auto])
 AC_ARG_ENABLE(xsdl,           AS_HELP_STRING([--enable-xsdl], [Build the kdrive Xsdl server (default: auto)]), [XSDL=$enableval], [XSDL=auto])
+AC_ARG_ENABLE(xfake,          AS_HELP_STRING([--enable-xfake], [Build the kdrive 'fake' server (default: auto)]), [XFAKE=$enableval], [XFAKE=auto])
+AC_ARG_ENABLE(xfbdev,         AS_HELP_STRING([--enable-xfbdev], [Build the kdrive framebuffer device server (default: auto)]), [XFBDEV=$enableval], [XFBDEV=auto])
+AC_ARG_ENABLE(kdrive-vesa,    AS_HELP_STRING([--enable-kdrive-vesa], [Build the kdrive VESA-based servers (default: auto)]), [KDRIVEVESA=$enableval], [KDRIVEVESA=auto])
 dnl xprint
 AC_ARG_ENABLE(freetype,       AS_HELP_STRING([ --enable-freetype], [Build Xprint FreeType backend (default: yes)]), [XP_USE_FREETYPE=$enableval],[XP_USE_FREETYPE=no])
 AC_ARG_WITH(freetype-config,  AS_HELP_STRING([ --with-freetype-config=PROG], [Use FreeType configuration program PROG (default: auto)]), freetype_config=$withval, freetype_config=auto)
@@ -513,9 +522,21 @@ XEXT_LIB='$(top_builddir)/Xext/libXext.la'
 XEXTXORG_LIB='$(top_builddir)/Xext/libXextbuiltin.la'
 
 dnl Core modules for most extensions, et al.
-REQUIRED_MODULES="randrproto renderproto [fixesproto >= 4.0] damageproto xcmiscproto xextproto xproto xtrans xf86miscproto xf86vidmodeproto xf86bigfontproto [scrnsaverproto >= 1.1] bigreqsproto resourceproto fontsproto inputproto xf86dgaproto [kbproto >= 1.0.3]"
+REQUIRED_MODULES="randrproto renderproto [fixesproto >= 4.0] damageproto xcmiscproto xextproto xproto xtrans [scrnsaverproto >= 1.1] bigreqsproto resourceproto fontsproto [inputproto >= 1.4] [kbproto >= 1.0.3]"
 REQUIRED_LIBS="xfont xau fontenc"
 
+if test "x$DBUS" = xauto; then
+       PKG_CHECK_MODULES(DBUS, dbus-1, [DBUS=yes], [DBUS=no])
+fi
+if test "x$DBUS" = xyes; then
+       PKG_CHECK_MODULES(DBUS, dbus-1)
+       AC_DEFINE(HAVE_DBUS, 1, [Have D-BUS support])
+       REQUIRED_MODULES="$REQUIRED_MODULES dbus-1"
+       REQUIRED_LIBS="$REQUIRED_LIBS dbus-1"
+fi
+CONFIG_LIB='$(top_builddir)/config/libconfig.a'
+AM_CONDITIONAL(DBUS, [test "x$DBUS" = xyes])
+
 AM_CONDITIONAL(XV, [test "x$XV" = xyes])
 if test "x$XV" = xyes; then
 	AC_DEFINE(XV, 1, [Support Xv extension])
@@ -530,10 +551,6 @@ if test "x$XVMC" = xyes; then
 	AC_DEFINE(XvMCExtension, 1, [Build XvMC extension])
 fi
 
-AM_CONDITIONAL(DGA, [test "x$DGA" = xyes])
-if test "x$DGA" = xyes; then
-	AC_DEFINE(DGA, 1, [Support DGA extension])
-fi
 
 AM_CONDITIONAL(COMPOSITE, [test "x$COMPOSITE" = xyes])
 if test "x$COMPOSITE" = xyes; then
@@ -682,14 +699,6 @@ if test "x$DPMSExtension" = xyes; then
 	AC_DEFINE(DPMSExtension, 1, [Support DPMS extension])
 fi
 
-if test "x$XF86VIDMODE" = xyes; then
-	AC_DEFINE(XF86VIDMODE, 1, [Support XFree86 Video Mode extension])
-fi
-
-if test "x$XF86MISC" = xyes; then
-	AC_DEFINE(XF86MISC, 1, [Support XFree86 miscellaneous extensions])
-fi
-
 if test "x$XPRINT" = xauto; then
 	PKG_CHECK_MODULES([XPRINTPROTO], [printproto], [XPRINT=yes], [XPRINT=no])
 fi
@@ -699,6 +708,11 @@ if test "x$XPRINT" = xyes; then
 	REQUIRED_MODULES="$REQUIRED_MODULES printproto"
 fi
 
+if test "x$BUILTIN_FONTS" = xyes; then
+       AC_DEFINE(BUILTIN_FONTS, 1, [Use only built-in fonts])
+       AC_DEFINE(NOFONTSERVERACCESS, 1, [Avoid using a font server])
+fi
+
 if test "x$XCALIBRATE" = xyes && test "$KDRIVE" = yes; then
    AC_DEFINE(XCALIBRATE, 1, [Build XCalibrate extension])
    REQUIRED_MODULES="$REQUIRED_MODULES xcalibrateproto"
@@ -729,12 +743,9 @@ if test "$COMPOSITE" = yes; then
 fi
 MIEXT_DAMAGE_INC='-I$(top_srcdir)/miext/damage'
 
-AM_CONDITIONAL(XINPUT, [test "x$XINPUT" = xyes])
+AC_DEFINE(XINPUT, 1, [Support X Input extension])
-if test "x$XINPUT" = xyes; then
+XI_LIB='$(top_builddir)/Xi/libXi.la'
-   	AC_DEFINE(XINPUT, 1, [Support X Input extension])
+XI_INC='-I$(top_srcdir)/Xi'
-	XI_LIB='$(top_builddir)/Xi/libXi.la'
-	XI_INC='-I$(top_srcdir)/Xi'
-fi
 
 AM_CONDITIONAL(XF86UTILS, test "x$XF86UTILS" = xyes)
 
@@ -750,6 +761,10 @@ XKB_STUB_LIB='$(top_builddir)/xkb/libxkbstubs.la'
 AC_CHECK_FUNC(strcasecmp, [], AC_DEFINE([NEED_STRCASECMP], 1,
                                         [Do not have `strcasecmp'.]))
 
+if test "x$NULL_ROOT_CURSOR" = xyes; then
+        AC_DEFINE(NULL_ROOT_CURSOR, 1, [Use an empty root cursor])
+fi
+
 PKG_CHECK_MODULES([XDMCP], [xdmcp], [have_libxdmcp="yes"], [have_libxdmcp="no"])
 if test "x$have_libxdmcp" = xyes; then
 	AC_CHECK_LIB(Xdmcp, XdmcpWrap, [have_xdmcpwrap="yes"], [have_xdmcpwrap="no"], [$XDMCP_LIBS])
@@ -825,11 +840,35 @@ AC_DEFINE(DDXOSINIT, 1, [Use OsVendorInit])
 AC_DEFINE(SERVER_LOCK, 1, [Use a lock to prevent multiple servers on a display])
 AC_DEFINE(SMART_SCHEDULE, 1, [Include time-based scheduler])
 AC_DEFINE(NO_LIBCWRAPPER, 1, [Define to 1 if modules should avoid the libcwrapper])
-AM_CONDITIONAL(DEBUG, test "x$DEBUGGING" = xyes)
 
-if ! test "x$DEBUGGING" = xyes; then
+if test "x$DEBUGGING" = xyes; then
-  AC_DEFINE(NDEBUG, 1, [Disable some debugging code])
+       AC_DEFINE(DEBUG, 1, [Enable debugging code])
+else
+       AC_DEFINE(NDEBUG, 1, [Disable some debugging code])
 fi
+AM_CONDITIONAL(DEBUG, [test "x$DEBUGGING" = xyes])
+
+# The Xorg binary needs to export symbols so that they can be used from modules
+# Some platforms require extra flags to do this.   gcc should set these flags
+# when -rdynamic is passed to it, other compilers/linkers may need to be added
+# here.
+if test "x$GCC" = "xyes"; then
+       GCC_WARNINGS1="-Wall -Wpointer-arith -Wstrict-prototypes"
+       GCC_WARNINGS2="-Wmissing-prototypes -Wmissing-declarations"
+       GCC_WARNINGS3="-Wnested-externs -fno-strict-aliasing"
+       GCC_WARNINGS="$GCC_WARNINGS1 $GCC_WARNINGS2 $GCC_WARNINGS3"
+       if test "x$WERROR" = "xyes"; then
+               GCC_WARNINGS="${GCC_WARNINGS} -Werror"
+       fi
+       XSERVER_CFLAGS="$GCC_WARNINGS $XSERVER_CFLAGS"
+       LD_EXPORT_SYMBOLS_FLAG="-rdynamic"
+fi
+case $host_os in
+       openbsd*)
+       LD_EXPORT_SYMBOLS_FLAG="-Wl,--export-dynamic"
+       ;;
+esac
+AC_SUBST([LD_EXPORT_SYMBOLS_FLAG])
 
 AC_DEFINE(USE_RGB_TXT, 1, [Use rgb.txt directly])
 AC_DEFINE(MITMISC, 1, [Support MIT Misc extension])
@@ -1021,7 +1060,7 @@ if test "x$XGLX" = xyes; then
 fi
 
 # XORG_CORE_LIBS is needed even if you're not building the Xorg DDX
-XORG_CORE_LIBS="$DIX_LIB"
+XORG_CORE_LIBS="$DIX_LIB $CONFIG_LIB"
 AC_SUBST([XORG_CORE_LIBS])
 
 xorg_bus_linuxpci=no
@@ -1039,6 +1078,37 @@ if test "x$XORG" = xyes -o "x$XGL" = xyes; then
 	XORG_CFLAGS="$XORGSERVER_CFLAGS -DHAVE_XORG_CONFIG_H"
 	XORG_LIBS="$COMPOSITE_LIB $MI_LIB $FIXES_LIB $XEXTXORG_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XPSTUBS_LIB $OS_LIB"
 
+	if test "x$DGA" = xauto; then
+		PKG_CHECK_MODULES(DGA, xf86dgaproto, [DGA=yes], [DGA=no])
+	fi
+	if test "x$DGA" = xyes; then
+		XORG_MODULES="$XORG_MODULES xf86dgaproto"
+		AC_DEFINE(DGA, 1, [Support DGA extension])
+		AC_DEFINE(XFreeXDGA, 1, [Build XDGA support])
+	fi
+
+	if test "x$XF86MISC" = xauto; then
+		PKG_CHECK_MODULES(XF86MISC, xf86miscproto, [XF86MISC=yes], [XF86MISC=no])
+	fi
+	if test "x$XF86MISC" = xyes; then
+		XORG_MODULES="$XORG_MODULES xf86miscproto"
+		AC_DEFINE(XF86MISC, 1, [Support XFree86 miscellaneous extensions])
+	fi
+
+	if test "x$XF86VIDMODE" = xauto; then
+		PKG_CHECK_MODULES(XF86VIDMODE, xf86vidmodeproto, [XF86VIDMODE=yes], [XF86VIDMODE=no])
+	fi
+	if test "x$XF86VIDMODE" = xyes; then
+		XORG_MODULES="$XORG_MODULES xf86vidmodeproto"
+		AC_DEFINE(XF86VIDMODE, 1, [Support XFree86 Video Mode extension])
+	fi
+
+	if test -n "$XORG_MODULES"; then
+	        PKG_CHECK_MODULES(XORG_MODULES, [$XORG_MODULES])
+	        XORG_CFLAGS="$XORG_CFLAGS $XORG_MODULES_CFLAGS"
+	        XORG_LIBS="$XORG_LIBS $XORG_MODULES_LIBS"
+	fi
+
 dnl Check to see if dlopen is in default libraries (like Solaris, which
 dnl has it in libc), or if libdl is needed to get it.
 	AC_CHECK_FUNC([dlopen], [], 
@@ -1051,7 +1121,6 @@ dnl has it in libc), or if libdl is needed to get it.
 		fi
 	  	XORG_OS="linux"
 		XORG_OS_SUBDIR="linux"
-		XORG_OS_KBD="Lnx"
 		xorg_bus_linuxpci="yes"
 		linux_acpi="no"
 		case $host_cpu in
@@ -1093,7 +1162,6 @@ int main () {
 	  freebsd* | kfreebsd*-gnu)
 	  	XORG_OS="freebsd"
 		XORG_OS_SUBDIR="bsd"
-		XORG_OS_KBD="BSD"
 		case $host_cpu in
 		  i*86)
 			;;
@@ -1105,7 +1173,6 @@ int main () {
 	  netbsd*)
 	  	XORG_OS="netbsd"
 		XORG_OS_SUBDIR="bsd"
-		XORG_OS_KBD="BSD"
 		case $host_cpu in
 		  i*86|amd64*|x86_64*|ia64*)
 			;;
@@ -1117,7 +1184,6 @@ int main () {
 	  openbsd*)
 	  	XORG_OS="openbsd"
 		XORG_OS_SUBDIR="bsd"
-		XORG_OS_KBD="BSD"
 		case $host_cpu in
 		  i*86|amd64*|x86_64*|ia64*)
 			;;
@@ -1224,7 +1290,6 @@ int main () {
 	AC_SUBST([XORG_INCS])
 	AC_SUBST([XORG_OS])
 	AC_SUBST([XORG_OS_SUBDIR])
-	AC_SUBST([XORG_OS_KBD])
 
 	dnl only used in hw/xfree86/scanpci, TTBOMK
 	AC_PATH_PROG(PERL, perl, no)
@@ -1234,28 +1299,7 @@ int main () {
 	fi
 	AC_SUBST(PERL)
 
-	# The Xorg binary needs to export symbols so that they can be used from modules
-	# Some platforms require extra flags to do this.   gcc should set these flags
-	# when -rdynamic is passed to it, other compilers/linkers may need to be added
-	# here.
-	if test "x$GCC" = "xyes"; then
-		GCC_WARNINGS1="-Wall -Wpointer-arith -Wstrict-prototypes"
-		GCC_WARNINGS2="-Wmissing-prototypes -Wmissing-declarations"
-		GCC_WARNINGS3="-Wnested-externs -fno-strict-aliasing"
-		GCC_WARNINGS="$GCC_WARNINGS1 $GCC_WARNINGS2 $GCC_WARNINGS3"
-		if test "x$WERROR" = "xyes"; then
-			GCC_WARNINGS="${GCC_WARNINGS} -Werror"
-		fi
-		XSERVER_CFLAGS="$GCC_WARNINGS $XSERVER_CFLAGS"
-		LD_EXPORT_SYMBOLS_FLAG="-rdynamic"
-	fi
-	case $host_os in
-		openbsd*)
-		LD_EXPORT_SYMBOLS_FLAG="-Wl,--export-dynamic"
-		;;
-	esac
 	AC_SUBST([XORG_CFLAGS])
-	AC_SUBST([LD_EXPORT_SYMBOLS_FLAG])
 
 	dnl these only go in xorg-config.h
 	XF86CONFIGFILE="xorg.conf"
@@ -1304,6 +1348,7 @@ AM_CONDITIONAL([SOLARIS_ASM_INLINE], [test "x$solaris_asm_inline" = xyes])
 AM_CONDITIONAL(MFB, [test "x$XORG" = xyes])
 AM_CONDITIONAL(CFB, [test "x$XORG" = xyes])
 AM_CONDITIONAL(AFB, [test "x$XORG" = xyes])
+AM_CONDITIONAL(DGA, [test "x$DGA" = xyes])
 
 dnl Xprint DDX
 
@@ -1313,7 +1358,7 @@ AC_MSG_RESULT([$XPRINT])
 if test "x$XPRINT" = xyes; then
 	PKG_CHECK_MODULES([XPRINT], [printproto x11 xfont $XDMCP_MODULES xau])
 	XPRINT_EXTENSIONS="$XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $RENDER_LIB $COMPOSITE_LIB $RANDR_LIB $XI_LIB $FIXES_LIB $DAMAGE_LIB $XI_LIB $GLX_LIBS"
-	XPRINT_LIBS="$XPRINT_LIBS $DIX_LIB $XKB_LIB $XKB_STUB_LIB $XPRINT_EXTENSIONS $MI_LIB $MIEXT_DAMAGE_LIB $CWRAP_LIB $OS_LIB"
+	XPRINT_LIBS="$XPRINT_LIBS $DIX_LIB $CONFIG_LIB $XKB_LIB $XKB_STUB_LIB $XPRINT_EXTENSIONS $MI_LIB $MIEXT_DAMAGE_LIB $CWRAP_LIB $OS_LIB"
 	AC_SUBST([XPRINT_CFLAGS])
 	AC_SUBST([XPRINT_LIBS])
 
@@ -1442,16 +1487,59 @@ if test "$KDRIVE" = yes; then
     AC_DEFINE(KDRIVEDDXACTIONS,,[Build kdrive ddx])
 
     AC_CHECK_HEADERS([sys/vm86.h sys/io.h])
-    if test "$ac_cv_header_sys_vm86_h" = yes; then
+    if test "$ac_cv_header_sys_vm86_h" = yes && test "x$KDRIVEVESA" = xauto; then
+        KDRIVEVESA=yes
+    fi
+
+    if test "x$KDRIVEVESA" = xyes; then
+        KDRIVEFBDEVLIB=yes
         AC_DEFINE(KDRIVEVESA, 1, [Build VESA-based kdrive servers])
     fi
 
     AC_CHECK_HEADERS([linux/fb.h])
-    if test "$ac_cv_header_linux_fb_h" = yes; then
+    if test "$ac_cv_header_linux_fb_h" = yes && test "x$XFBDEV" = xauto; then
+        XFBDEV=yes
+    fi
+
+    if test "x$XFBDEV" = xyes; then
+        KDRIVEFBDEVLIB=yes
         AC_DEFINE(KDRIVEFBDEV, 1, [Build fbdev-based kdrive server])
     fi
     
     # tslib...
+    AC_CHECK_LIB(ts, ts_open, [HAVE_TSLIB="yes"])
+    if test "x$TSLIB" = xauto && test "x$HAVE_TSLIB" = xyes; then
+        TSLIB=yes
+    fi
+
+    if test "x$TSLIB" = xyes; then
+        if ! test "x$HAVE_TSLIB" = xyes; then
+            AC_MSG_ERROR([tslib must be installed to build the tslib input driver.])
+        fi
+        TSLIB_LIBS="-lts"
+        AC_DEFINE(TSLIB, 1, [Have tslib support])
+    fi
+
+    if test x"$ac_cv_header_SDL_SDL_h" = xyes && test "x$XSDL" = xauto; then
+       XSDL=yes
+    fi
+
+    if test x"$XSDL" = xyes; then
+       # PKG_CHECK_MODULES(XSDL_EXTRA, Xfont xau $XDMCP_MODULES)
+       AC_DEFINE(XSDLSERVER,1,[Build Xsdl server])
+       XSDL_LIBS="`sdl-config --libs` $XSERVER_LIBS"
+       XSDL_INCS="`sdl-config --cflags` $XSERVER_CFLAGS"
+    fi
+
+    PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
+    if test "x$XEPHYR" = xauto; then
+        XEPHYR=$xephyr
+    fi
+
+    # Xephyr needs nanosleep() which is in librt on Solaris
+    AC_CHECK_FUNC([nanosleep], [],
+        AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
+    XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
     if test "x$TSLIB" = xyes; then
         PKG_CHECK_MODULES([TSLIB], [tslib-0.0], [HAVE_TSLIB="yes"], [HAVE_TSLIB="no"])
         if test "x$HAVE_TSLIB" = xno; then
@@ -1475,53 +1563,49 @@ if test "$KDRIVE" = yes; then
     KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a'
     KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
     KDRIVE_STUB_LIB='$(top_builddir)/hw/kdrive/src/libkdrivestubs.a'
-    KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB $TSLIB_LIBS"
+    KDRIVE_LIBS="$XSERVERLIBS_LIBS $DIX_LIB $CONFIG_LIB $KDRIVE_LIB $TSLIB_LIBS $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB"
 
     # check if we can build Xephyr
     PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
-    
+    XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
+
+    # Xephyr needs nanosleep() which is in librt on Solaris
+    AC_CHECK_FUNC([nanosleep], [],
+        AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
+
     # check for SDL SDK
     AC_CHECK_HEADERS([SDL/SDL.h])
     if test "x$XSDL" = xauto; then
         XSDL="$ac_cv_header_SDL_SDL_h"
     fi
+
+    AC_SUBST([XEPHYR_LIBS])
+    AC_SUBST([XEPHYR_INCS])
+    AC_SUBST([XSDL_LIBS])
+    AC_SUBST([XSDL_INCS])
 fi
-AC_SUBST(KDRIVE_INCS)
+AC_SUBST([KDRIVE_INCS])
-AC_SUBST(KDRIVE_PURE_INCS)
+AC_SUBST([KDRIVE_PURE_INCS])
-AC_SUBST(KDRIVE_CFLAGS)
+AC_SUBST([KDRIVE_CFLAGS])
-AC_SUBST(KDRIVE_PURE_LIBS)
+AC_SUBST([KDRIVE_PURE_LIBS])
-AC_SUBST(KDRIVE_LIBS)
+AC_SUBST([KDRIVE_LIBS])
 AM_CONDITIONAL(TSLIB, [test "x$HAVE_TSLIB" = xyes])
 AM_CONDITIONAL(H3600_TS, false)
+AM_CONDITIONAL(KDRIVEVESA, [test "x$KDRIVEVESA" = xyes])
+AM_CONDITIONAL(KDRIVEFBDEV, [test "x$XFBDEV" = xyes])
+AM_CONDITIONAL(XSDLSERVER, [test x"$XSDL" = xyes])
+AM_CONDITIONAL(XEPHYR, [test "x$KDRIVE" = xyes && test "x$XEPHYR" = xyes])
+AM_CONDITIONAL(BUILD_KDRIVEFBDEVLIB, [test "x$KDRIVE" = xyes && test "x$KDRIVEFBDEVLIB" = xyes])
+AM_CONDITIONAL(XFAKESERVER, [test "x$KDRIVE" = xyes && test "x$XFAKE" = xyes])
 AM_CONDITIONAL(KDRIVEVESA, [test x"$ac_cv_header_sys_vm86_h" = xyes])
 AM_CONDITIONAL(KDRIVEFBDEV, [test x"$ac_cv_header_linux_fb_h" = xyes])
 
-# Xephyr needs nanosleep() which is in librt on Solaris
-AC_CHECK_FUNC([nanosleep], [],
-	AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
-
-AM_CONDITIONAL(XEPHYR, [test x"$xephyr" = xyes])
-XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
-AC_SUBST([XEPHYR_LIBS])
-AC_SUBST([XEPHYR_INCS])
-
-if test x"$XSDL" = xyes; then
-    AC_DEFINE(XSDLSERVER,,[Build Xsdl server])
-    XSDL_LIBS="`sdl-config --libs` $XSERVER_LIBS"
-    XSDL_INCS="`sdl-config --cflags` $XSERVER_CFLAGS"
-fi
-AM_CONDITIONAL(XSDLSERVER, [test x"$XSDL" = xyes])
-AC_SUBST([XSDL_LIBS])
-AC_SUBST([XSDL_INCS])
-
-
 dnl these only go in xkb-config.h (which is shared by the Xorg and Xnest servers)
 AC_DEFINE(__XKBDEFRULES__, "xorg", [Default XKB rules])
 AC_DEFINE_DIR(XKB_BASE_DIRECTORY, XKBPATH, [Path to XKB data])
 AC_DEFINE_DIR(XKB_BIN_DIRECTORY, bindir, [Path to XKB bin dir])
 
 # Make sure XKM_OUTPUT_DIR is an absolute path
-
 XKBOUTPUT_FIRSTCHAR=`echo $XKBOUTPUT | cut -b 1`
 
 if [[ x$XKBOUTPUT_FIRSTCHAR != x/ ]] ; then
@@ -1539,7 +1623,6 @@ AC_DEFINE_DIR(XKM_OUTPUT_DIR, XKBOUTPUT, [Path to XKB output dir])
 AC_SUBST(XKB_COMPILED_DIR)
 
 dnl and the rest of these are generic, so they're in config.h
-AC_DEFINE(XFreeXDGA, 1, [Build XDGA support])
 AC_DEFINE(XResExtension, 1, [Build XRes extension])
 
 dnl CYGWIN does not define fd_set if _POSIX_SOURCE is defined
@@ -1560,15 +1643,21 @@ esac
 AC_DEFINE_DIR(PROJECTROOT, prefix, [Overall prefix])
 
 dnl xorgconfig CLI configuration utility
-PKG_CHECK_MODULES([XORGCONFIG_DEP], [xkbfile x11])
+if test "x$XORG" = xyes; then
-AC_SUBST(XORGCONFIG_DEP_CFLAGS)
+    PKG_CHECK_MODULES([XORGCONFIG_DEP], [xkbfile x11])
-AC_SUBST(XORGCONFIG_DEP_LIBS)
+    AC_SUBST(XORGCONFIG_DEP_CFLAGS)
+    AC_SUBST(XORGCONFIG_DEP_LIBS)
+fi
 
 dnl xorgcfg GUI configuration utility
 AC_ARG_ENABLE(xorgcfg, AS_HELP_STRING([--enable-xorgcfg], 
-	[Build xorgcfg GUI configuration utility (default: yes)]),
+	[Build xorgcfg GUI configuration utility (default: auto)]),
-	[XORGCFG=$enableval],[XORGCFG=yes])
+	[XORGCFG=$enableval],[XORGCFG=auto])
-if test x$XORGCFG = xyes ; then
+if test "x$XORGCFG" = xauto && test "x$XORG" = xyes; then
+    XORGCFG=yes
+fi
+
+if test "x$XORGCFG" = xyes; then
 	PKG_CHECK_MODULES([XORGCFG_DEP], 
 	    [xkbui >= 1.0.2 xkbfile xxf86misc xxf86vm xaw7 xmu xt xpm xext x11])
 	AC_CHECK_LIB([curses],[waddstr],
@@ -1654,6 +1743,7 @@ XTrap/Makefile
 mfb/Makefile
 cfb/Makefile
 cfb32/Makefile
+config/Makefile
 mi/Makefile
 miext/Makefile
 miext/damage/Makefile

dix/dispatch.c

@@ -100,6 +100,7 @@ int ProcInitialConnection();
 #include "dispatch.h"
 #include "swaprep.h"
 #include "swapreq.h"
+#include "config.h"
 #ifdef PANORAMIX
 #include "panoramiX.h"
 #include "panoramiXsrv.h"
@@ -382,6 +383,9 @@ Dispatch(void)
 
 	nready = WaitForSomething(clientReady);
 
+        /* this is an enormous hack and NEEDS TO GO AWAY. */
+        configDispatch();
+
 #ifdef SMART_SCHEDULE
 	if (nready && !SmartScheduleDisable)
 	{

dix/dixfonts.c

@@ -155,11 +155,6 @@ QueueFontWakeup(FontPathElementPtr fpe)
 
     for (i = 0; i < num_slept_fpes; i++) {
 	if (slept_fpes[i] == fpe) {
-
-#ifdef DEBUG
-	    fprintf(stderr, "re-queueing fpe wakeup\n");
-#endif
-
 	    return;
 	}
     }
@@ -1886,7 +1881,7 @@ InitFonts ()
 {
     patternCache = MakeFontPatternCache();
 
-#ifndef KDRIVESERVER
+#ifndef BUILTIN_FONTS
     if (screenInfo.numScreens > screenInfo.numVideoScreens) {
 	PrinterFontRegisterFpeFunctions();
 	FontFileCheckRegisterFpeFunctions();
@@ -1894,10 +1889,11 @@ InitFonts ()
     } else 
 #endif
     {
-#ifdef KDRIVESERVER
+#ifdef BUILTIN_FONTS
-	BuiltinRegisterFpeFunctions();
+        BuiltinRegisterFpeFunctions();
-#endif
+#else
 	FontFileRegisterFpeFunctions();
+#endif
 #ifndef NOFONTSERVERACCESS
 	fs_register_fpe_functions();
 #endif
@@ -2059,11 +2055,6 @@ init_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler)
 	fs_handlers_installed = 0;
     }
     if (fs_handlers_installed == 0) {
-
-#ifdef DEBUG
-	fprintf(stderr, "adding FS b & w handlers\n");
-#endif
-
 	if (!RegisterBlockAndWakeupHandlers(block_handler,
 					    FontWakeup, (pointer) 0))
 	    return AllocError;
@@ -2079,55 +2070,9 @@ remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler, Bo
     if (all) {
 	/* remove the handlers if no one else is using them */
 	if (--fs_handlers_installed == 0) {
-
-#ifdef DEBUG
-	    fprintf(stderr, "removing FS b & w handlers\n");
-#endif
-
 	    RemoveBlockAndWakeupHandlers(block_handler, FontWakeup,
 					 (pointer) 0);
 	}
     }
     RemoveFontWakeup(fpe);
 }
-
-#ifdef DEBUG
-#define GLWIDTHBYTESPADDED(bits,nbytes) \
-	((nbytes) == 1 ? (((bits)+7)>>3)        /* pad to 1 byte */ \
-	:(nbytes) == 2 ? ((((bits)+15)>>3)&~1)  /* pad to 2 bytes */ \
-	:(nbytes) == 4 ? ((((bits)+31)>>3)&~3)  /* pad to 4 bytes */ \
-	:(nbytes) == 8 ? ((((bits)+63)>>3)&~7)  /* pad to 8 bytes */ \
-	: 0)
-
-#define GLYPH_SIZE(ch, nbytes)          \
-	GLWIDTHBYTESPADDED((ch)->metrics.rightSideBearing - \
-			(ch)->metrics.leftSideBearing, (nbytes))
-void
-dump_char_ascii(CharInfoPtr cip)
-{
-    int         r,
-                l;
-    int         bpr;
-    int         byte;
-    static unsigned maskTab[] = {
-	(1 << 7), (1 << 6), (1 << 5), (1 << 4),
-	(1 << 3), (1 << 2), (1 << 1), (1 << 0),
-    };
-
-    bpr = GLYPH_SIZE(cip, 4);
-    for (r = 0; r < (cip->metrics.ascent + cip->metrics.descent); r++) {
-	pointer     row = (pointer) cip->bits + r * bpr;
-
-	byte = 0;
-	for (l = 0; l <= (cip->metrics.rightSideBearing -
-			  cip->metrics.leftSideBearing); l++) {
-	    if (maskTab[l & 7] & row[l >> 3])
-		putchar('X');
-	    else
-		putchar('.');
-	}
-	putchar('\n');
-    }
-}
-
-#endif

dix/events.c

@@ -113,6 +113,7 @@ of the copyright holder.
 #endif
 
 #include <X11/X.h>
+#include <X11/keysym.h>
 #include "misc.h"
 #include "resource.h"
 #define NEED_EVENTS
@@ -131,8 +132,10 @@ of the copyright holder.
 #include "globals.h"
 
 #ifdef XKB
+#include <X11/extensions/XKBproto.h>
 #include <X11/extensions/XKBsrv.h>
 extern Bool XkbFilterEvents(ClientPtr, int, xEvent *);
+extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
 #endif
 
 #ifdef XCSECURITY
@@ -154,7 +157,9 @@ xEvent *xeviexE;
 #endif
 
 #include <X11/extensions/XIproto.h>
+#include "exglobals.h"
 #include "exevents.h"
+#include "exglobals.h"
 #include "extnsionst.h"
 
 #include "dixevents.h"
@@ -206,9 +211,6 @@ _X_EXPORT CallbackListPtr DeviceEventCallback;
 Mask DontPropagateMasks[DNPMCOUNT];
 static int DontPropagateRefCnts[DNPMCOUNT];
 
-#ifdef DEBUG
-static debug_events = 0;
-#endif
 _X_EXPORT InputInfo inputInfo;
 
 static struct {
@@ -1531,9 +1533,8 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
     int i;
     int type;
 
-#ifdef DEBUG
+#ifdef DEBUG_EVENTS
-    if (debug_events) ErrorF(
+    ErrorF("Event([%d, %d], mask=0x%x), client=%d",
-	"Event([%d, %d], mask=0x%x), client=%d",
 	pEvents->u.u.type, pEvents->u.u.detail, mask, client->index);
 #endif
     if ((client) && (client != serverClient) && (!client->clientGone) &&
@@ -1549,9 +1550,9 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
 		if (WID(inputInfo.pointer->valuator->motionHintWindow) ==
 		    pEvents->u.keyButtonPointer.event)
 		{
-#ifdef DEBUG
+#ifdef DEBUG_EVENTS
-		    if (debug_events) ErrorF("\n");
+		    ErrorF("\n");
-	    fprintf(stderr,"motionHintWindow == keyButtonPointer.event\n");
+	    ErrorF("motionHintWindow == keyButtonPointer.event\n");
 #endif
 		    return 1; /* don't send, but pretend we did */
 		}
@@ -1589,15 +1590,15 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
 	}
 
 	WriteEventsToClient(client, count, pEvents);
-#ifdef DEBUG
+#ifdef DEBUG_EVENTS
-	if (debug_events) ErrorF(  " delivered\n");
+	ErrorF(  " delivered\n");
 #endif
 	return 1;
     }
     else
     {
-#ifdef DEBUG
+#ifdef DEBUG_EVENTS
-	if (debug_events) ErrorF("\n");
+	ErrorF("\n");
 #endif
 	return 0;
     }
@@ -2777,8 +2778,7 @@ drawable.id:0;
 #endif
 
 #ifdef DEBUG
-    if ((xkbDebugFlags&0x4)&&
+    if (((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
-	((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
 	ErrorF("CoreProcessKbdEvent: Key %d %s\n",key,
 			(xE->u.u.type==KeyPress?"down":"up"));
     }
@@ -2864,8 +2864,7 @@ FixKeyState (register xEvent *xE, register DeviceIntPtr keybd)
     kptr = &keyc->down[key >> 3];
     bit = 1 << (key & 7);
 #ifdef DEBUG
-    if ((xkbDebugFlags&0x4)&&
+    if (((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
-	((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
 	ErrorF("FixKeyState: Key %d %s\n",key,
 			(xE->u.u.type==KeyPress?"down":"up"));
     }
@@ -4593,3 +4592,431 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
 	(void)WriteToClient(pClient, count * sizeof(xEvent), (char *) events);
     }
 }
+
+/* Maximum number of valuators, divided by six, rounded up. */
+#define MAX_VALUATOR_EVENTS 6
+
+/**
+ * Returns the maximum number of events GetKeyboardEvents,
+ * GetKeyboardValuatorEvents, and GetPointerEvents will ever return.
+ *
+ * Should be used in DIX as:
+ * xEvent *events = xcalloc(sizeof(xEvent), GetMaximumEventsNum());
+ */
+int
+GetMaximumEventsNum() {
+    /* Two base events -- core and device, plus valuator events.  Multiply
+     * by two if we're doing key repeats. */
+    int ret = 2 + MAX_VALUATOR_EVENTS;
+
+#ifdef XKB
+    if (noXkbExtension)
+#endif
+        ret *= 2;
+
+    return ret;
+}
+
+/**
+ * Convenience wrapper around GetKeyboardValuatorEvents, that takes no
+ * valuators.
+ */
+int
+GetKeyboardEvents(xEvent *events, DeviceIntPtr pDev, int type, int key_code) {
+    return GetKeyboardValuatorEvents(events, pDev, type, key_code, 0, NULL);
+}
+
+/**
+ * Returns a set of keyboard events for KeyPress/KeyRelease, optionally
+ * also with valuator events.  Handles Xi and XKB.
+ *
+ * events is not NULL-terminated; the return value is the number of events.
+ * The DDX is responsible for allocating the event structure in the first
+ * place via GetMaximumEventsNum(), and for freeing it.
+ *
+ * If pDev is set to send core events, then the keymap on the core
+ * keyboard will be pivoted to that of the new keyboard and the appropriate
+ * MapNotify events (both core and XKB) will be sent.
+ *
+ * Note that this function recurses!  If called for non-XKB, a repeating
+ * key press will trigger a matching KeyRelease, as well as the
+ * KeyPresses.
+ */
+int GetKeyboardValuatorEvents(xEvent *events, DeviceIntPtr pDev, int type,
+                              int key_code, int num_valuators,
+                              int *valuators) {
+    int numEvents = 0, ms = 0, first_valuator = 0;
+    KeySym sym = pDev->key->curKeySyms.map[key_code *
+                                           pDev->key->curKeySyms.mapWidth];
+    deviceKeyButtonPointer *kbp = NULL;
+    deviceValuator *xv = NULL;
+    KeyClassPtr ckeyc;
+
+    if (!events)
+        return 0;
+    
+    if (type != KeyPress && type != KeyRelease)
+        return 0;
+
+    if (!pDev->key || !pDev->focus || !pDev->kbdfeed ||
+        (pDev->coreEvents && !inputInfo.keyboard->key))
+        return 0;
+
+    if (pDev->coreEvents)
+        numEvents = 2;
+    else
+        numEvents = 1;
+
+    if (num_valuators) {
+        if ((num_valuators / 6) + 1 > MAX_VALUATOR_EVENTS)
+            num_valuators = MAX_VALUATOR_EVENTS;
+        numEvents += (num_valuators / 6) + 1;
+    }
+
+#ifdef XKB
+    if (noXkbExtension)
+#endif
+    {
+        switch (sym) {
+            case XK_Num_Lock:
+            case XK_Caps_Lock:
+            case XK_Scroll_Lock:
+            case XK_Shift_Lock:
+                if (type == KeyRelease)
+                    return 0;
+                else if (type == KeyPress &&
+                         (pDev->key->down[key_code >> 3] & (key_code & 7)) & 1)
+                        type = KeyRelease;
+        }
+    }
+
+    /* Handle core repeating, via press/release/press/release.
+     * FIXME: In theory, if you're repeating with two keyboards,
+     *        you could get unbalanced events here. */
+    if (type == KeyPress &&
+        (((pDev->key->down[key_code >> 3] & (key_code & 7))) & 1)) {
+        if (!pDev->kbdfeed->ctrl.autoRepeat ||
+            pDev->key->modifierMap[key_code] ||
+            !(pDev->kbdfeed->ctrl.autoRepeats[key_code >> 3]
+                & (1 << (key_code & 7))))
+            return 0;
+
+#ifdef XKB
+        if (noXkbExtension)
+#endif
+        {
+            numEvents += GetKeyboardValuatorEvents(events, pDev,
+                                                   KeyRelease, key_code,
+                                                   num_valuators, valuators);
+            events += numEvents;
+        }
+    }
+    
+
+    ms = GetTimeInMillis();
+
+    kbp = (deviceKeyButtonPointer *) events;
+    kbp->time = ms;
+    kbp->deviceid = pDev->id;
+    if (type == KeyPress)
+        kbp->type = DeviceKeyPress;
+    else if (type == KeyRelease)
+        kbp->type = DeviceKeyRelease;
+
+    if (num_valuators) {
+        kbp->deviceid |= MORE_EVENTS;
+        while (first_valuator < num_valuators) {
+            xv = (deviceValuator *) ++events;
+            xv->type = DeviceValuator;
+            xv->first_valuator = first_valuator;
+            xv->num_valuators = num_valuators;
+            xv->deviceid = kbp->deviceid;
+            switch (num_valuators - first_valuator) {
+            case 6:
+                xv->valuator5 = valuators[first_valuator+5];
+            case 5:
+                xv->valuator4 = valuators[first_valuator+4];
+            case 4:
+                xv->valuator3 = valuators[first_valuator+3];
+            case 3:
+                xv->valuator2 = valuators[first_valuator+2];
+            case 2:
+                xv->valuator1 = valuators[first_valuator+1];
+            case 1:
+                xv->valuator0 = valuators[first_valuator];
+            }
+            first_valuator += 6;
+        }
+    }
+
+    if (pDev->coreEvents) {
+        events++;
+        events->u.keyButtonPointer.time = ms;
+        events->u.u.type = type;
+        events->u.u.detail = key_code;
+
+        if (inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr !=
+            pDev) {
+            ckeyc = inputInfo.keyboard->key;
+            memcpy(ckeyc->modifierMap, pDev->key->modifierMap, MAP_LENGTH);
+            if (ckeyc->modifierKeyMap)
+                xfree(ckeyc->modifierKeyMap);
+            ckeyc->modifierKeyMap = xalloc(8 * pDev->key->maxKeysPerModifier);
+            memcpy(ckeyc->modifierKeyMap, pDev->key->modifierKeyMap,
+                    (8 * pDev->key->maxKeysPerModifier));
+            ckeyc->maxKeysPerModifier = pDev->key->maxKeysPerModifier;
+            ckeyc->curKeySyms.minKeyCode = pDev->key->curKeySyms.minKeyCode;
+            ckeyc->curKeySyms.maxKeyCode = pDev->key->curKeySyms.maxKeyCode;
+            SetKeySymsMap(&ckeyc->curKeySyms, &pDev->key->curKeySyms);
+#ifdef XKB
+            if (!noXkbExtension && pDev->key->xkbInfo &&
+                pDev->key->xkbInfo->desc) {
+                if (!XkbCopyKeymap(pDev->key->xkbInfo->desc,
+                                   ckeyc->xkbInfo->desc, True))
+                    FatalError("Couldn't pivot keymap from device to core!\n");
+            }
+#endif
+            SendMappingNotify(MappingKeyboard, ckeyc->curKeySyms.minKeyCode,
+                              (ckeyc->curKeySyms.maxKeyCode -
+                               ckeyc->curKeySyms.minKeyCode),
+                              serverClient);
+            inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
+        }
+    }
+
+    return numEvents;
+}
+
+/* Originally a part of xf86PostMotionEvent. */
+static void
+acceleratePointer(DeviceIntPtr pDev, int num_valuators, int *valuators)
+{
+    float mult = 0.0;
+    int dx = num_valuators >= 1 ? valuators[0] : 0;
+    int dy = num_valuators >= 2 ? valuators[1] : 0;
+
+    if (!num_valuators || !valuators)
+        return;
+
+    /*
+     * Accelerate
+     */
+    if (pDev->ptrfeed && pDev->ptrfeed->ctrl.num) {
+        /* modeled from xf86Events.c */
+        if (pDev->ptrfeed->ctrl.threshold) {
+            if ((abs(dx) + abs(dy)) >= pDev->ptrfeed->ctrl.threshold) {
+                pDev->valuator->dxremaind = ((float)dx *
+                                             (float)(pDev->ptrfeed->ctrl.num)) /
+                                             (float)(pDev->ptrfeed->ctrl.den) +
+                                            pDev->valuator->dxremaind;
+                valuators[0] = (int)pDev->valuator->dxremaind;
+                pDev->valuator->dxremaind = pDev->valuator->dxremaind -
+                                            (float)valuators[0];
+
+                pDev->valuator->dyremaind = ((float)dy *
+                                             (float)(pDev->ptrfeed->ctrl.num)) /
+                                             (float)(pDev->ptrfeed->ctrl.den) +
+                                            pDev->valuator->dyremaind;
+                valuators[1] = (int)pDev->valuator->dyremaind;
+                pDev->valuator->dyremaind = pDev->valuator->dyremaind -
+                                            (float)valuators[1];
+            }
+        }
+        else if (dx || dy) {
+            mult = pow((float)(dx * dx + dy * dy),
+                       ((float)(pDev->ptrfeed->ctrl.num) /
+                        (float)(pDev->ptrfeed->ctrl.den) - 1.0) /
+                       2.0) / 2.0;
+            if (dx) {
+                pDev->valuator->dxremaind = mult * (float)dx +
+                                            pDev->valuator->dxremaind;
+                valuators[0] = (int)pDev->valuator->dxremaind;
+                pDev->valuator->dxremaind = pDev->valuator->dxremaind -
+                                            (float)valuators[0];
+            }
+            if (dy) {
+                pDev->valuator->dyremaind = mult * (float)dy +
+                                            pDev->valuator->dyremaind;
+                valuators[1] = (int)pDev->valuator->dyremaind;
+                pDev->valuator->dyremaind = pDev->valuator->dyremaind -
+                                            (float)valuators[1];
+            }
+        }
+    }
+}
+
+/**
+ * Generate a series of xEvents (returned in xE) representing pointer
+ * motion, or button presses.  Xi and XKB-aware.
+ *
+ * events is not NULL-terminated; the return value is the number of events.
+ * The DDX is responsible for allocating the event structure in the first
+ * place via GetMaximumEventsNum(), and for freeing it.
+ */
+int
+GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
+                 int flags, int num_valuators, int *valuators) {
+    int numEvents = 0, ms = 0, first_valuator = 0;
+    deviceKeyButtonPointer *kbp = NULL;
+    deviceValuator *xv = NULL;
+    AxisInfoPtr axes = NULL;
+    Bool sendValuators = (type == MotionNotify || flags & POINTER_ABSOLUTE);
+    DeviceIntPtr cp = inputInfo.pointer;
+
+    if (type != MotionNotify && type != ButtonPress && type != ButtonRelease)
+        return 0;
+
+    if (!pDev->button || (pDev->coreEvents && !(cp->button || !cp->valuator)))
+        return 0;
+
+    if (pDev->coreEvents)
+        numEvents = 2;
+    else
+        numEvents = 1;
+
+    if (num_valuators > 2 && sendValuators) {
+        if (((num_valuators / 6) + 1) > MAX_VALUATOR_EVENTS)
+            num_valuators = MAX_VALUATOR_EVENTS;
+        numEvents += (num_valuators / 6) + 1;
+    }
+    else if (type == MotionNotify && num_valuators < 2) {
+        return 0;
+    }
+
+    ms = GetTimeInMillis();
+
+    kbp = (deviceKeyButtonPointer *) events;
+    kbp->time = ms;
+    kbp->deviceid = pDev->id;
+
+    if (flags & POINTER_ABSOLUTE) {
+        if (num_valuators >= 1) {
+            kbp->root_x = valuators[0];
+        }
+        else {
+            if (pDev->coreEvents)
+                kbp->root_x = cp->valuator->lastx;
+            else
+                kbp->root_x = pDev->valuator->lastx;
+        }
+        if (num_valuators >= 2) {
+            kbp->root_y = valuators[1];
+        }
+        else {
+            if (pDev->coreEvents)
+                kbp->root_x = cp->valuator->lasty;
+            else
+                kbp->root_y = pDev->valuator->lasty;
+        }
+    }
+    else {
+        if (flags & POINTER_ACCELERATE)
+            acceleratePointer(pDev, num_valuators, valuators);
+
+        if (pDev->coreEvents) {
+            if (num_valuators >= 1)
+                kbp->root_x = cp->valuator->lastx + valuators[0];
+            else
+                kbp->root_x = cp->valuator->lastx;
+            if (num_valuators >= 2)
+                kbp->root_y = cp->valuator->lasty + valuators[1];
+            else
+                kbp->root_y = cp->valuator->lasty;
+        }
+        else {
+            if (num_valuators >= 1)
+                kbp->root_x = pDev->valuator->lastx + valuators[0];
+            else
+                kbp->root_x = pDev->valuator->lastx;
+            if (num_valuators >= 2)
+                kbp->root_y = pDev->valuator->lasty + valuators[1];
+            else
+                kbp->root_y = pDev->valuator->lasty;
+        }
+    }
+
+    /* FIXME: need mipointer-like semantics to move on to different screens. */
+    axes = pDev->valuator->axes;
+    if (kbp->root_x < axes->min_value)
+        kbp->root_x = axes->min_value;
+    if (axes->max_value > 0 && kbp->root_x > axes->max_value)
+        kbp->root_x = axes->max_value;
+    axes++;
+    if (kbp->root_y < axes->min_value)
+        kbp->root_y = axes->min_value;
+    if (axes->max_value > 0 && kbp->root_y > axes->max_value)
+        kbp->root_y = axes->max_value;
+
+    if (pDev->coreEvents) {
+        cp->valuator->lastx = kbp->root_x;
+        cp->valuator->lasty = kbp->root_y;
+    }
+    pDev->valuator->lastx = kbp->root_x;
+    pDev->valuator->lasty = kbp->root_y;
+
+    if (type == MotionNotify) {
+        kbp->type = DeviceMotionNotify;
+    }
+    else {
+        if (type == ButtonPress)
+            kbp->type = DeviceButtonPress;
+        else if (type == ButtonRelease)
+            kbp->type = DeviceButtonRelease;
+        kbp->detail = pDev->button->map[buttons];
+    }
+
+    if (num_valuators > 2 && sendValuators) {
+        kbp->deviceid |= MORE_EVENTS;
+        while (first_valuator < num_valuators) {
+            xv = (deviceValuator *) ++events;
+            xv->type = DeviceValuator;
+            xv->first_valuator = first_valuator;
+            xv->num_valuators = num_valuators;
+            xv->deviceid = kbp->deviceid;
+            switch (num_valuators - first_valuator) {
+            case 6:
+                xv->valuator5 = valuators[first_valuator+5];
+            case 5:
+                xv->valuator4 = valuators[first_valuator+4];
+            case 4:
+                xv->valuator3 = valuators[first_valuator+3];
+            case 3:
+                xv->valuator2 = valuators[first_valuator+2];
+            case 2:
+                if (first_valuator == 0)
+                    xv->valuator1 = kbp->root_y;
+                else
+                    xv->valuator1 = valuators[first_valuator+1];
+            case 1:
+                if (first_valuator == 0)
+                    xv->valuator0 = kbp->root_x;
+                else
+                    xv->valuator0 = valuators[first_valuator];
+            }
+            first_valuator += 6;
+        }
+    }
+
+    if (pDev->coreEvents) {
+        events++;
+        events->u.u.type = type;
+        events->u.keyButtonPointer.time = ms;
+        events->u.keyButtonPointer.rootX = kbp->root_x;
+        events->u.keyButtonPointer.rootY = kbp->root_y;
+        cp->valuator->lastx = kbp->root_x;
+        cp->valuator->lasty = kbp->root_y;
+        if (type == ButtonPress || type == ButtonRelease) {
+            /* Core buttons remapping shouldn't be transitive. */
+            events->u.u.detail = pDev->button->map[buttons];
+        }
+        else {
+            events->u.u.detail = 0;
+        }
+
+        if (inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr !=
+            pDev)
+            inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
+    }
+
+    return numEvents;
+}

dix/main.c

@@ -98,6 +98,7 @@ Equipment Corporation.
 #include <X11/fonts/font.h>
 #include "opaque.h"
 #include "servermd.h"
+#include "config.h"
 #include "site.h"
 #include "dixfont.h"
 #include "extnsionst.h"
@@ -248,6 +249,7 @@ main(int argc, char *argv[], char *envp[])
     int		i, j, k, error;
     char	*xauthfile;
     HWEventQueueType	alwaysCheckForInput[2];
+    CursorMetricRec cm;
 
     display = "0";
 
@@ -308,6 +310,7 @@ main(int argc, char *argv[], char *envp[])
 	DPMSPowerLevel = 0;
 #endif
 	InitBlockAndWakeupHandlers();
+        configInitialise();
 	/* Perform any operating system dependent initializations you'd like */
 	OsInit();		
 	if(serverGeneration == 1)
@@ -393,23 +396,40 @@ main(int argc, char *argv[], char *envp[])
 	    if (!CreateRootWindow(pScreen))
 		FatalError("failed to create root window");
 	}
+        InitCoreDevices();
 	InitInput(argc, argv);
 	if (InitAndStartDevices() != Success)
 	    FatalError("failed to initialize core devices");
 
 	InitFonts();
+#ifdef BUILTIN_FONTS
+        defaultFontPath = "built-ins";
+#else
 	if (loadableFonts) {
 	    SetFontPath(0, 0, (unsigned char *)defaultFontPath, &error);
-	} else {
+	} else 
+#endif
+        {
 	    if (SetDefaultFontPath(defaultFontPath) != Success)
 		ErrorF("failed to set default font path '%s'",
 			defaultFontPath);
 	}
 	if (!SetDefaultFont(defaultTextFont))
 	    FatalError("could not open default font '%s'", defaultTextFont);
+#ifdef NULL_ROOT_CURSOR
+        cm.width = 0;
+        cm.height = 0;
+        cm.xhot = 0;
+        cm.yhot = 0;
+
+        if (!(rootCursor = AllocCursor(NULL, NULL, &cm, 0, 0, 0, 0, 0, 0)))
+            FatalError("could not create empty root cursor");
+        AddResource(FakeClientID(0), RT_CURSOR, (pointer)rootCursor);
+#else
 	if (!(rootCursor = CreateRootCursor(defaultCursorFont, 0)))
 	    FatalError("could not open default cursor font '%s'",
 		       defaultCursorFont);
+#endif
 #ifdef DPMSExtension
  	/* check all screens, looking for DPMS Capabilities */
  	DPMSCapableFlag = DPMSSupported();
@@ -460,6 +480,7 @@ main(int argc, char *argv[], char *envp[])
 	FreeAllResources();
 #endif
 
+        configFini();
 	CloseDownDevices();
 	for (i = screenInfo.numScreens - 1; i >= 0; i--)
 	{

hw/darwin/darwinKeyboard.c

@@ -1020,7 +1020,7 @@ int DarwinModifierStringToNXKey(const char *str)
  *      This allows the ddx layer to prevent some keys from being remapped
  *      as modifier keys.
  */
-Bool LegalModifier(unsigned int key, DevicePtr pDev)
+Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return 1;
 }

hw/dmx/dmxinput.c

@@ -53,7 +53,7 @@
 /** Returns TRUE if the key is a valid modifier.  For PC-class
  * keyboards, all keys can be used as modifiers, so return TRUE
  * always. */
-Bool LegalModifier(unsigned int key, DevicePtr pDev)
+Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return TRUE;
 }

hw/kdrive/Makefile.am

@@ -3,10 +3,14 @@ VESA_SUBDIRS = vesa ati chips epson i810 mach64 mga neomagic nvidia pm2 r128 \
                smi via
 endif
 
-if KDRIVEFBDEV
+if BUILD_KDRIVEFBDEVLIB
 FBDEV_SUBDIRS = fbdev
 endif
 
+if XFAKESERVER
+XFAKE_SUBDIRS = fake
+endif
+
 if XSDLSERVER
 XSDL_SUBDIRS = sdl
 endif
@@ -22,7 +26,7 @@ SUBDIRS =			\
 	$(FBDEV_SUBDIRS)	\
 	$(VESA_SUBDIRS)		\
 	$(XEPHYR_SUBDIRS)       \
-	fake
+	$(XFAKE_SUBDIRS)
 
 DIST_SUBDIRS = vesa ati chips epson i810 mach64 mga neomagic nvidia pm2 r128 \
                smi via fbdev sdl ephyr src linux fake sis300

hw/kdrive/ati/Makefile.am

@@ -61,12 +61,4 @@ ATI_LIBS =				\
 Xati_LDADD = \
 	$(ATI_LIBS)			\
 	@KDRIVE_LIBS@			\
-	@XSERVER_LIBS@			
+	@XSERVER_LIBS@
-
-
-Xati_DEPENDENCIES =                     \
-        libati.a                        \
-        $(FBDEV_LIBS)                   \
-        $(VESA_LIBS)                    \
-        $(DRI_LIBS)                     
-

hw/kdrive/ati/ati_stub.c

@@ -53,7 +53,15 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput(int argc, char **argv)
 {
-	KdInitInput(&LinuxMouseFuncs, &LinuxKeyboardFuncs);
+        KdKeyboardInfo *ki = NULL;
+        
+        KdAddPointerDriver(&LinuxMouseDriver);
+        ki = KdNewKeyboard();
+        if (ki) {
+            ki->driver = &LinuxKeyboardDriver;
+            KdAddKeyboard(ki);
+        }
+	KdInitInput();
 }
 
 void

hw/kdrive/chips/Makefile.am

@@ -24,7 +24,3 @@ Xchips_LDADD = \
 	$(CHIPS_LIBS)				\
 	@KDRIVE_LIBS@                           \
 	@XSERVER_LIBS@				
-
-Xchips_DEPENDENCIES =                           \
-        libchips.a                              \
-        $(top_builddir)/hw/kdrive/vesa/libvesa.a 

hw/kdrive/ephyr/Makefile.am

@@ -28,9 +28,4 @@ Xephyr_LDADD = 						\
 	libxephyr-hostx.a			        \
 	../../../exa/libexa.la				\
 	@KDRIVE_LIBS@					\
-	@KDRIVE_LIBS@					\
         @XEPHYR_LIBS@
-
-Xephyr_DEPENDENCIES =					\
-	libxephyr.a					\
-	libxephyr-hostx.a

hw/kdrive/ephyr/ephyr.c

@@ -36,10 +36,16 @@
 #include "inputstr.h"
 
 extern int KdTsPhyScreen;
-extern DeviceIntPtr pKdKeyboard;
+KdKeyboardInfo *ephyrKbd;
+KdPointerInfo *ephyrMouse;
+EphyrKeySyms ephyrKeySyms;
 
 static int mouseState = 0;
 
+typedef struct _EphyrInputPrivate {
+    Bool    enabled;
+} EphyrKbdPrivate, EphyrPointerPrivate;
+
 Bool   EphyrWantGrayScale = 0;
 
 Bool
@@ -206,15 +212,14 @@ ephyrMapFramebuffer (KdScreenInfo *screen)
 {
   EphyrScrPriv  *scrpriv = screen->driver;
   EphyrPriv	  *priv    = screen->card->driver;
-  KdMouseMatrix m;
+  KdPointerMatrix m;
   int buffer_height;
   
   EPHYR_DBG(" screen->width: %d, screen->height: %d",
 	    screen->width, screen->height);
   
-  KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
+  KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
-    
+  KdSetPointerMatrix (&m);
-  KdSetMouseMatrix (&m);
   
   priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
   
@@ -719,8 +724,9 @@ ephyrUpdateModifierState(unsigned int state)
 		kptr = &keyc->down[key >> 3];
 		bit = 1 << (key & 7);
 		
-		if (*kptr & bit)
+		if (*kptr & bit && ephyrKbd &&
-		  KdEnqueueKeyboardEvent(key, TRUE); /* release */
+                    ((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
+		  KdEnqueueKeyboardEvent(ephyrKbd, key, TRUE); /* release */
 		
 		if (--count == 0)
 		  break;
@@ -732,7 +738,9 @@ ephyrUpdateModifierState(unsigned int state)
 	for (key = 0; key < MAP_LENGTH; key++)
 	  if (keyc->modifierMap[key] & mask) 
 	    {
-	      KdEnqueueKeyboardEvent(key, FALSE); /* press */
+              if (keyc->modifierMap[key] & mask && ephyrKbd &&
+                  ((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
+	          KdEnqueueKeyboardEvent(ephyrKbd, key, FALSE); /* press */
 	      break;
 	    }
     }
@@ -748,31 +756,47 @@ ephyrPoll(void)
       switch (ev.type)
 	{
 	case EPHYR_EV_MOUSE_MOTION:
-	  KdEnqueueMouseEvent(kdMouseInfo, mouseState,  
+          if (!ephyrMouse ||
-			      ev.data.mouse_motion.x, 
+              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
-			      ev.data.mouse_motion.y);
+              continue;
+	  KdEnqueuePointerEvent(ephyrMouse, mouseState,  
+			        ev.data.mouse_motion.x, 
+			        ev.data.mouse_motion.y,
+                                0);
 	  break;
 	  
 	case EPHYR_EV_MOUSE_PRESS:
+          if (!ephyrMouse ||
+              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
+              continue;
 	  ephyrUpdateModifierState(ev.key_state);
 	  mouseState |= ev.data.mouse_down.button_num;
-	  KdEnqueueMouseEvent(kdMouseInfo, mouseState|KD_MOUSE_DELTA, 0, 0);
+	  KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
 	  break;
 
 	case EPHYR_EV_MOUSE_RELEASE:
+          if (!ephyrMouse ||
+              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
+              continue;
 	  ephyrUpdateModifierState(ev.key_state);
 	  mouseState &= ~ev.data.mouse_up.button_num;
-	  KdEnqueueMouseEvent(kdMouseInfo, mouseState|KD_MOUSE_DELTA, 0, 0);
+	  KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
 	  break;
 
 	case EPHYR_EV_KEY_PRESS:
+          if (!ephyrKbd ||
+              !((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
+              continue;
 	  ephyrUpdateModifierState(ev.key_state);
-	  KdEnqueueKeyboardEvent (ev.data.key_down.scancode, FALSE);
+	  KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_down.scancode, FALSE);
 	  break;
 
 	case EPHYR_EV_KEY_RELEASE:
+          if (!ephyrKbd ||
+              !((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
+              continue;
 	  ephyrUpdateModifierState(ev.key_state);
-	  KdEnqueueKeyboardEvent (ev.data.key_up.scancode, TRUE);
+	  KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_up.scancode, TRUE);
 	  break;
 
 	default:
@@ -833,59 +857,112 @@ ephyrPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
 
 /* Mouse calls */
 
-static Bool
+static Status
-MouseInit (void)
+MouseInit (KdPointerInfo *pi)
 {
-    return TRUE;
+    pi->driverPrivate = (EphyrPointerPrivate *)
+                         xcalloc(sizeof(EphyrPointerPrivate), 1);
+    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
+    pi->nAxes = 3;
+    pi->nButtons = 32;
+    pi->name = KdSaveString("Xephyr virtual mouse");
+    ephyrMouse = pi;
+    return Success;
+}
+
+static Status
+MouseEnable (KdPointerInfo *pi)
+{
+    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = TRUE;
+    return Success;
 }
 
 static void
-MouseFini (void)
+MouseDisable (KdPointerInfo *pi)
 {
-  ;
+    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
+    return;
 }
 
-KdMouseFuncs EphyrMouseFuncs = {
+static void
+MouseFini (KdPointerInfo *pi)
+{
+    ephyrMouse = NULL; 
+    return;
+}
+
+KdPointerDriver EphyrMouseDriver = {
+    "ephyr",
     MouseInit,
+    MouseEnable,
+    MouseDisable,
     MouseFini,
+    NULL,
 };
 
 /* Keyboard */
 
-static void
+static Status
-EphyrKeyboardLoad (void)
+EphyrKeyboardInit (KdKeyboardInfo *ki)
 {
-  EPHYR_DBG("mark");
+  ki->driverPrivate = (EphyrKbdPrivate *)
-
+                       xcalloc(sizeof(EphyrKbdPrivate), 1);
   hostx_load_keymap();
+  if (!ephyrKeySyms.map) {
+      ErrorF("Couldn't load keymap from host\n");
+      return BadAlloc;
+  }
+  ki->keySyms.minKeyCode = ephyrKeySyms.minKeyCode;
+  ki->keySyms.maxKeyCode = ephyrKeySyms.maxKeyCode;
+  ki->minScanCode = ki->keySyms.minKeyCode;
+  ki->maxScanCode = ki->keySyms.maxKeyCode;
+  ki->keySyms.mapWidth = ephyrKeySyms.mapWidth;
+  ki->keySyms.map = ephyrKeySyms.map;
+  ki->name = KdSaveString("Xephyr virtual keyboard");
+  ephyrKbd = ki;
+  return Success;
 }
 
-static int
+static Status
-EphyrKeyboardInit (void)
+EphyrKeyboardEnable (KdKeyboardInfo *ki)
 {
-  return 0;
+    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = TRUE;
+
+    return Success;
 }
 
 static void
-EphyrKeyboardFini (void)
+EphyrKeyboardDisable (KdKeyboardInfo *ki)
+{
+    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = FALSE;
+}
+
+static void
+EphyrKeyboardFini (KdKeyboardInfo *ki)
+{
+    /* not xfree: we call malloc from hostx.c. */
+    free(ki->keySyms.map);
+    ephyrKbd = NULL;
+    return;
+}
+
+static void
+EphyrKeyboardLeds (KdKeyboardInfo *ki, int leds)
 {
 }
 
 static void
-EphyrKeyboardLeds (int leds)
+EphyrKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
 {
 }
 
-static void
+KdKeyboardDriver EphyrKeyboardDriver = {
-EphyrKeyboardBell (int volume, int frequency, int duration)
+    "ephyr",
-{
-}
-
-KdKeyboardFuncs	EphyrKeyboardFuncs = {
-    EphyrKeyboardLoad,
     EphyrKeyboardInit,
+    EphyrKeyboardEnable,
     EphyrKeyboardLeds,
     EphyrKeyboardBell,
+    EphyrKeyboardDisable,
     EphyrKeyboardFini,
-    0,
+    NULL,
 };

hw/kdrive/ephyr/ephyr.h

@@ -31,7 +31,6 @@
 
 #include "os.h"  		/* for OsSignal() */
 #include "kdrive.h"
-#include "kkeymap.h"
 #include "hostx.h"
 #include "exa.h"
 
@@ -68,7 +67,9 @@ typedef struct _ephyrScrPriv {
     EphyrFakexaPriv *fakexa;
 } EphyrScrPriv;
 
-extern KdCardFuncs  ephyrFuncs;
+extern KdCardFuncs ephyrFuncs;
+extern KdKeyboardInfo *ephyrKbd;
+extern KdPointerInfo *ephyrMouse;
 
 Bool
 ephyrInitialize (KdCardInfo *card, EphyrPriv *priv);
@@ -167,9 +168,9 @@ ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf);
 void
 ephyrUpdateModifierState(unsigned int state);
 
-extern KdMouseFuncs EphyrMouseFuncs;
+extern KdPointerDriver EphyrMouseDriver;
 
-extern KdKeyboardFuncs	EphyrKeyboardFuncs;
+extern KdKeyboardDriver	EphyrKeyboardDriver;
 
 extern KdOsFuncs   EphyrOsFuncs;
 

hw/kdrive/ephyr/ephyrinit.c

@@ -51,7 +51,24 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-  KdInitInput (&EphyrMouseFuncs, &EphyrKeyboardFuncs);
+  KdKeyboardInfo *ki;
+  KdPointerInfo *pi;
+        
+  ki = KdNewKeyboard();
+  if (!ki)
+    FatalError("Couldn't create Xephyr keyboard\n");
+  ki->driver = &EphyrKeyboardDriver;
+  KdAddKeyboardDriver(&EphyrKeyboardDriver);
+  KdAddKeyboard(ki);
+
+  pi = KdNewPointer();
+  if (!pi)
+    FatalError("Couldn't create Xephyr pointer\n");
+  pi->driver = &EphyrMouseDriver;
+  KdAddPointerDriver(&EphyrMouseDriver);
+  KdAddPointer(pi);
+
+  KdInitInput();
 }
 
 void

hw/kdrive/ephyr/hostx.c

@@ -77,14 +77,8 @@ static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
 static int            HostXWantDamageDebug = 0;
 
-extern KeySym         EphyrKeymap[];
+extern EphyrKeySyms   ephyrKeySyms;
 
-extern KeySym	      kdKeymap[];
-extern int	      kdMinScanCode;
-extern int	      kdMaxScanCode;
-extern int	      kdMinKeyCode;
-extern int	      kdMaxKeyCode;
-extern int	      kdKeymapWidth;
 extern int            monitorResolution;
 
 static void
@@ -403,9 +397,9 @@ hostx_get_bpp(void)
 }
 
 void
-hostx_get_visual_masks (unsigned long *rmsk, 
+hostx_get_visual_masks (CARD32 *rmsk, 
-			unsigned long *gmsk, 
+			CARD32 *gmsk, 
-			unsigned long *bmsk)
+			CARD32 *bmsk)
 {
   if (host_depth_matches_server())
     {
@@ -683,19 +677,21 @@ hostx_load_keymap(void)
    */
   width = (host_width > 4) ? 4 : host_width;
 
+  ephyrKeySyms.map = (KeySym *)calloc(sizeof(KeySym),
+                                      (max_keycode - min_keycode + 1) *
+                                      width);
+  if (!ephyrKeySyms.map)
+        return;
+
   for (i=0; i<(max_keycode - min_keycode+1); i++)
     for (j=0; j<width; j++)
-      kdKeymap[ (i*width)+j ] = keymap[ (i*host_width) + j ];
+      ephyrKeySyms.map[(i*width)+j] = keymap[(i*host_width) + j];
 
   EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width);
   
-  /* all kdrive vars - see kkeymap.c */
+  ephyrKeySyms.minKeyCode  = min_keycode;
-
+  ephyrKeySyms.maxKeyCode  = max_keycode;
-  kdMinScanCode = min_keycode;
+  ephyrKeySyms.mapWidth    = width;
-  kdMaxScanCode = max_keycode;
-  kdMinKeyCode  = min_keycode;
-  kdMaxKeyCode  = max_keycode;
-  kdKeymapWidth = width;
 
   XFree(keymap);
 }

hw/kdrive/ephyr/hostx.h

@@ -26,6 +26,9 @@
 #ifndef _XLIBS_STUFF_H_
 #define _XLIBS_STUFF_H_
 
+#include <X11/X.h>
+#include <X11/Xmd.h>
+
 #define EPHYR_WANT_DEBUG 0
 
 #if (EPHYR_WANT_DEBUG)
@@ -48,6 +51,14 @@ typedef enum EphyrHostXEventType
 } 
 EphyrHostXEventType;
 
+/* I can't believe it's not a KeySymsRec. */
+typedef struct {
+  int             minKeyCode;
+  int             maxKeyCode;
+  int             mapWidth;
+  KeySym         *map;
+} EphyrKeySyms;
+
 struct EphyrHostXEvent
 {
   EphyrHostXEventType type;
@@ -126,9 +137,9 @@ int
 hostx_get_bpp(void);
 
 void
-hostx_get_visual_masks (unsigned long *rmsk, 
+hostx_get_visual_masks (CARD32 *rmsk, 
-			unsigned long *gmsk, 
+			CARD32 *gmsk, 
-			unsigned long *bmsk);
+			CARD32 *bmsk);
 void
 hostx_set_cmap_entry(unsigned char idx, 
 		     unsigned char r, 

hw/kdrive/epson/Makefile.am

@@ -24,5 +24,3 @@ Xepson_LDADD = \
 	$(EPSON_LIBS)			       \
 	@KDRIVE_LIBS@                          \
 	@XSERVER_LIBS@				
-
-Xepson_DEPENDENCIES = libepson.a

hw/kdrive/fake/Makefile.am

@@ -6,10 +6,6 @@ noinst_LIBRARIES = libfake.a
 
 bin_PROGRAMS = Xfake
 
-if TSLIB
-TSLIB_FLAG = -lts
-endif
-
 libfake_a_SOURCES =	\
 	fake.c		\
 	kbd.c		\
@@ -23,9 +19,4 @@ Xfake_SOURCES = \
 Xfake_LDADD = 						\
 	libfake.a					\
 	@KDRIVE_LIBS@					\
-	@KDRIVE_LIBS@					\
-	$(TSLIB_FLAG)                                   \
         @XSERVER_LIBS@
-
-Xfake_DEPENDENCIES =					\
-	libfake.a

hw/kdrive/fake/fake.c

@@ -158,7 +158,7 @@ Bool
 fakeMapFramebuffer (KdScreenInfo *screen)
 {
     FakeScrPriv	*scrpriv = screen->driver;
-    KdMouseMatrix	m;
+    KdPointerMatrix	m;
     FakePriv		*priv = screen->card->driver;
 
     if (scrpriv->randr != RR_Rotate_0)
@@ -166,9 +166,9 @@ fakeMapFramebuffer (KdScreenInfo *screen)
     else
 	scrpriv->shadow = FALSE;
     
-    KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
+    KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
     
-    KdSetMouseMatrix (&m);
+    KdSetPointerMatrix (&m);
     
     priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
     if (priv->base)

hw/kdrive/fake/fake.h

@@ -130,9 +130,9 @@ fakeRandRInit (ScreenPtr pScreen);
 
 #endif
 
-extern KdMouseFuncs FakeMouseFuncs;
+extern KdPointerDriver FakePointerDriver;
 
-extern KdKeyboardFuncs	FakeKeyboardFuncs;
+extern KdKeyboardDriver	FakeKeyboardDriver;
 
 extern KdOsFuncs   FakeOsFuncs;
 

hw/kdrive/fake/fakeinit.c

@@ -44,7 +44,22 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-    KdInitInput (&FakeMouseFuncs, &FakeKeyboardFuncs);
+    KdPointerInfo *pi;
+    KdKeyboardInfo *ki;
+
+    pi = KdNewPointer ();
+    if (!pi)
+        return;
+    pi->driver = &FakePointerDriver;
+    KdAddPointer(pi);
+
+    ki = KdNewKeyboard ();
+    if (!ki)
+        return;
+    ki->driver = &FakeKeyboardDriver;
+    KdAddKeyboard(ki);
+
+    KdInitInput ();
 }
 
 void

hw/kdrive/fake/kbd.c

@@ -27,7 +27,6 @@
 #include <kdrive-config.h>
 #endif
 #include "fake.h"
-#include "kkeymap.h"
 #include <X11/keysym.h>
 
 #define FAKE_WIDTH  2
@@ -155,41 +154,58 @@ KeySym FakeKeymap[] = {
 /*    116   123 */	 NoSymbol,	NoSymbol,   /* tiny button */
 };
 
-static void
+static Status
-FakeKeyboardLoad (void)
+FakeKeyboardInit (KdKeyboardInfo *ki)
 {
-    kdMinScanCode = 1;
+    ki->keySyms.minKeyCode = 1;
-    kdKeymapWidth = FAKE_WIDTH;
+    ki->keySyms.maxKeyCode = (sizeof (FakeKeymap) / sizeof (FakeKeymap[0])) / FAKE_WIDTH;
-    kdMaxScanCode = (sizeof (FakeKeymap) / sizeof (FakeKeymap[0])) / FAKE_WIDTH;
+    ki->keySyms.mapWidth = FAKE_WIDTH;
-    memcpy (kdKeymap, FakeKeymap, sizeof (FakeKeymap));
+    if (ki->keySyms.map)
+        xfree(ki->keySyms.map);
+    ki->keySyms.map = (KeySym *)xalloc(sizeof(FakeKeymap));
+    if (!ki->keySyms.map)
+        return BadAlloc;
+    memcpy (ki->keySyms.map, FakeKeymap, sizeof (FakeKeymap));
+
+    return Success;
 }
 
-static int
+static Status
-FakeKeyboardInit (void)
+FakeKeyboardEnable (KdKeyboardInfo *ki)
 {
-    return 0;
+    return Success;
 }
 
 static void
-FakeKeyboardFini (void)
+FakeKeyboardDisable (KdKeyboardInfo *ki)
+{
+    return;
+}
+
+static void
+FakeKeyboardFini (KdKeyboardInfo *ki)
+{
+    xfree(ki->keySyms.map);
+    ki->keySyms.map = NULL;
+}
+
+static void
+FakeKeyboardLeds (KdKeyboardInfo *ki, int leds)
 {
 }
 
 static void
-FakeKeyboardLeds (int leds)
+FakeKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
 {
 }
 
-static void
+KdKeyboardDriver FakeKeyboardDriver = {
-FakeKeyboardBell (int volume, int frequency, int duration)
+    "fake",
-{
-}
-
-KdKeyboardFuncs	FakeKeyboardFuncs = {
-    FakeKeyboardLoad,
     FakeKeyboardInit,
+    FakeKeyboardEnable,
     FakeKeyboardLeds,
     FakeKeyboardBell,
+    FakeKeyboardDisable,
     FakeKeyboardFini,
-    0,
+    NULL,
 };

hw/kdrive/fake/mouse.c

@@ -35,19 +35,35 @@
 #include "scrnintstr.h"
 #include "kdrive.h"
 
-static Bool
+static Status
-MouseInit (void)
+MouseInit (KdPointerInfo *pi)
 {
-    return TRUE;
+    return Success;
+}
+
+static Status
+MouseEnable (KdPointerInfo *pi)
+{
+    return Success;
 }
 
 static void
-MouseFini (void)
+MouseDisable (KdPointerInfo *pi)
 {
+    return;
+}
+
+static void
+MouseFini (KdPointerInfo *pi)
+{
+    return;
 }
 
 
-KdMouseFuncs FakeMouseFuncs = {
+KdPointerDriver FakePointerDriver = {
+    "fake",
     MouseInit,
+    MouseEnable,
+    MouseDisable,
     MouseFini,
 };

hw/kdrive/fbdev/Makefile.am

@@ -4,19 +4,18 @@ INCLUDES = 					\
 
 noinst_LIBRARIES = libfbdev.a
 
-bin_PROGRAMS = Xfbdev
-
 libfbdev_a_SOURCES =	\
 	fbdev.c		\
 	fbdev.h
 
+if KDRIVEFBDEV
+bin_PROGRAMS = Xfbdev
+
 Xfbdev_SOURCES = \
 	fbinit.c
 
 Xfbdev_LDADD = 						\
 	libfbdev.a					\
 	@KDRIVE_LIBS@					\
-	@XSERVER_LIBS@					
+	@XSERVER_LIBS@
-
+endif
-Xfbdev_DEPENDENCIES =					\
-	libfbdev.a

hw/kdrive/fbdev/fbdev.c

@@ -331,7 +331,7 @@ Bool
 fbdevMapFramebuffer (KdScreenInfo *screen)
 {
     FbdevScrPriv	*scrpriv = screen->driver;
-    KdMouseMatrix	m;
+    KdPointerMatrix	m;
     FbdevPriv		*priv = screen->card->driver;
 
     if (scrpriv->randr != RR_Rotate_0)
@@ -339,9 +339,9 @@ fbdevMapFramebuffer (KdScreenInfo *screen)
     else
 	scrpriv->shadow = FALSE;
     
-    KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
+    KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
     
-    KdSetMouseMatrix (&m);
+    KdSetPointerMatrix (&m);
     
     screen->width = priv->var.xres;
     screen->height = priv->var.yres;

hw/kdrive/fbdev/fbinit.c

@@ -45,10 +45,18 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-    KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
+    KdKeyboardInfo *ki;
-#ifdef TOUCHSCREEN
+
-    KdAddMouseDriver (&TsFuncs);
+    KdAddKeyboardDriver (&LinuxKeyboardDriver);
+    KdAddPointerDriver (&LinuxMouseDriver);
+#ifdef TSLIB
+    KdAddPointerDriver (&TsDriver);
 #endif
+
+    ki = KdParseKeyboard ("keybd");
+    KdAddKeyboard(ki);
+
+    KdInitInput ();
 }
 
 void

hw/kdrive/i810/Makefile.am

@@ -27,5 +27,3 @@ Xi810_LDADD = \
 	$(I810_LIBS)					\
 	@KDRIVE_LIBS@                                  \
 	@XSERVER_LIBS@					
-
-Xi810_DEPENDENCIES = libi810.a

hw/kdrive/itsy/kbd.c

@@ -27,7 +27,6 @@
 #include <kdrive-config.h>
 #endif
 #include "itsy.h"
-#include "kkeymap.h"
 #include <X11/keysym.h>
 #include <linux/itsy_buttons.h>
 
@@ -167,28 +166,44 @@ ItsyKeyboardLoad (void)
 {
     KeySym  *k;
 
-    itsyButtonState = 0;
-    kdMinScanCode = 1;
-    kdKeymapWidth = ITSY_WIDTH;
-    kdMaxScanCode = (sizeof (ItsyKeymap) / sizeof (ItsyKeymap[0])) / ITSY_WIDTH;
-    memcpy (kdKeymap, ItsyKeymap, sizeof (ItsyKeymap));
 }
 
-int
+static Status
-ItsyKeyboardInit (void)
+ItsyKeyboardInit (KdKeyboardInfo *ki)
 {
-    int	butPort;
+    if (!ki)
+        return BadImplementation;
 
-    butPort = open ("/dev/buttons", 0);
+    ki->driverPrivate = open ("/dev/buttons", 0);
-    fprintf (stderr, "butPort %d\n", butPort);
+
-    return butPort;
+    itsyButtonState = 0;
+    ki->keySyms.minKeyCode = 1;
+    ki->keySyms.maxKeyCode = (sizeof (ItsyKeymap) / sizeof (ItsyKeymap[0])) / ITSY_WIDTH;
+    ki->minScanCode = ki->keySyms.minKeyCode;
+    ki->maxScanCode = ki->keySyms.maxKeyCode;
+    ki->keySyms.mapWidth = ITSY_WIDTH;
+
+    if (ki->keySyms.map)
+        xfree(ki->keySyms.map);
+    ki->keySyms.map = xalloc(sizeof(ItsyKeymap));
+    if (!ki->keySyms.map)
+        return BadAlloc;
+    memcpy (kdKeymap, ItsyKeymap, sizeof (ItsyKeymap));
+
+    return Success;
 }
 
-void
+static void
-ItsyKeyboardFini (int fd)
+ItsyKeyboardDisable (KdKeybdInfo *ki)
 {
     if (fd >= 0)
-	close (fd);
+	close ((int)ki->driverPrivate);
+}
+
+static void
+ItsyKeyboardFini (KdKeybdInfo *ki)
+{
+    return;
 }
 
 void
@@ -227,11 +242,13 @@ ItsyKeyboardBell (int volume, int frequency, int duration)
 }
 
 KdKeyboardFuncs	itsyKeyboardFuncs = {
-    ItsyKeyboardLoad,
+    "itsy",
     ItsyKeyboardInit,
+    ItsyKeyboardEnable,
     ItsyKeyboardRead,
     ItsyKeyboardLeds,
     ItsyKeyboardBell,
+    ItsyKeyboardDisable
     ItsyKeyboardFini,
-    0,
+    NULL,
 };

hw/kdrive/itsy/ts.c

@@ -63,7 +63,7 @@ itsyTsReadBytes (int fd, char *buf, int len, int min)
 }
 
 void
-itsyTsRead (int tsPort)
+itsyTsRead (KdPointerInfo *pi, int tsPort)
 {
     ts_event	    event;
     long	    buf[3];
@@ -89,7 +89,7 @@ itsyTsRead (int tsPort)
 	    x = 0;
 	    y = 0;
 	}
-	KdEnqueueMouseEvent (flags, x, y);
+	KdEnqueuePointerEvent (pi, flags, x, y, 0);
     }
 }
 
@@ -204,7 +204,8 @@ itsyTsFini (int tsPort)
 	close (tsPort);
 }
 
-KdMouseFuncs itsyTsMouseFuncs = {
+KdPointerDriver itsyTsMouseDriver = {
+    "itsyts",
     itsyTsInit,
     itsyTsRead,
     itsyTsFini

hw/kdrive/linux/Makefile.am

@@ -32,16 +32,3 @@ liblinux_a_SOURCES = 	\
 	$(KDRIVE_HW_SOURCES) \
 	$(TSLIB_C)	\
 	$(TS_C)
-
-liblinux_a_DEPENDENCIES = \
-	agp.c		\
-	bus.c		\
-	keyboard.c	\
-	linux.c		\
-	mouse.c		\
-	evdev.c		\
-	ms.c		\
-	ps2.c		\
-	$(TSLIB_C)	\
-	$(TS_C)
-

hw/kdrive/linux/bus.c

@@ -55,7 +55,7 @@ BusRead (int adbPort, void *closure)
 	    flags |= KD_BUTTON_2;
 	if ((buf[0] & 1) == 0)
 	    flags |= KD_BUTTON_3;
-        KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
+        KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
     }
 }
 
@@ -66,36 +66,71 @@ char	*BusNames[] = {
 
 #define NUM_BUS_NAMES	(sizeof (BusNames) / sizeof (BusNames[0]))
 
-int	BusInputType;
+static int
+BusInit (KdPointerInfo *pi)
+{
+    int	    i, fd = 0;
+
+    if (!pi->path || (strcmp(pi->path, "auto") == 0))
+    {
+        for (i = 0; i < NUM_BUS_NAMES; i++)
+        {
+            if ((fd = open (BusNames[i], 0)) > 0)
+            {
+                close(fd);
+                if (pi->path)
+                    xfree(pi->path);
+                pi->path = KdSaveString(BusNames[i]);
+                return Success;
+            }
+        }
+    }
+    else
+    {
+        if ((fd = open(pi->path, 0)) > 0)
+        {
+            close(fd);
+            return Success;
+        }
+    }
+
+    return !Success;
+}
 
 static int
-BusInit (void)
+BusEnable (KdPointerInfo *pi)
 {
-    int	    i;
+    int fd = open(pi->path, 0);
-    int	    busPort;
-    int	    n = 0;
 
-    if (!BusInputType)
+    if (fd > 0)
-	BusInputType = KdAllocInputType ();
-    
-    for (i = 0; i < NUM_BUS_NAMES; i++)
     {
-	busPort = open (BusNames[i], 0);
+        KdRegisterFd(fd, BusRead, pi);
-	{
+        pi->driverPrivate = (void *)fd;
-	    KdRegisterFd (BusInputType, busPort, BusRead, 0);
+        return Success;
-	    n++;
+    }
-	}
+    else
+    {
+        return !Success;
     }
-    return n;
 }
 
 static void
-BusFini (void)
+BusDisable (KdPointerInfo *pi)
 {
-    KdUnregisterFds (BusInputType, TRUE);
+    KdUnregisterFd(pi, (int)pi->driverPrivate, TRUE);
 }
 
-KdMouseFuncs BusMouseFuncs = {
+static void
+BusFini (KdPointerInfo *pi)
+{
+    return;
+}
+
+KdPointerDriver BusMouseDriver = {
+    "bus",
     BusInit,
-    BusFini
+    BusEnable,
+    BusDisable,
+    BusFini,
+    NULL
 };

hw/kdrive/linux/evdev.c

@@ -43,98 +43,100 @@
 #define ISBITSET(x,y) ((x)[LONG(y)] & BIT(y))
 #define OFF(x)   ((x)%BITS_PER_LONG)
 #define LONG(x)  ((x)/BITS_PER_LONG)
-#define BIT(x)	 (1 << OFF(x))
+#define BIT(x)         (1 << OFF(x))
 #define SETBIT(x,y) ((x)[LONG(y)] |= BIT(y))
 #define CLRBIT(x,y) ((x)[LONG(y)] &= ~BIT(y))
 #define ASSIGNBIT(x,y,z)    ((x)[LONG(y)] = ((x)[LONG(y)] & ~BIT(y)) | (z << OFF(y)))
 
 typedef struct _kevdevMouse {
     /* current device state */
-    int			    rel[REL_MAX + 1];
+    int                            rel[REL_MAX + 1];
-    int			    abs[ABS_MAX + 1];
+    int                            abs[ABS_MAX + 1];
-    int			    prevabs[ABS_MAX + 1];
+    int                            prevabs[ABS_MAX + 1];
-    long		    key[NBITS(KEY_MAX + 1)];
+    long                    key[NBITS(KEY_MAX + 1)];
     
     /* supported device info */
-    long		    relbits[NBITS(REL_MAX + 1)];
+    long                    relbits[NBITS(REL_MAX + 1)];
-    long		    absbits[NBITS(ABS_MAX + 1)];
+    long                    absbits[NBITS(ABS_MAX + 1)];
-    long		    keybits[NBITS(KEY_MAX + 1)];
+    long                    keybits[NBITS(KEY_MAX + 1)];
     struct input_absinfo    absinfo[ABS_MAX + 1];
-    int			    max_rel;
+    int                            max_rel;
-    int			    max_abs;
+    int                            max_abs;
+
+    int                     fd;
 } Kevdev;
 
 static void
-EvdevMotion (KdMouseInfo    *mi)
+EvdevMotion (KdPointerInfo    *pi)
 {
-    Kevdev		*ke = mi->driver;
+    Kevdev                *ke = pi->driverPrivate;
-    int			i;
+    int                        i;
 
     for (i = 0; i <= ke->max_rel; i++)
-	if (ke->rel[i])
+        if (ke->rel[i])
-	{
+        {
-	    int a;
+            int a;
-	    ErrorF ("rel");
+            ErrorF ("rel");
-	    for (a = 0; a <= ke->max_rel; a++)
+            for (a = 0; a <= ke->max_rel; a++)
-	    {
+            {
-		if (ISBITSET (ke->relbits, a))
+                if (ISBITSET (ke->relbits, a))
-		    ErrorF (" %d=%d", a, ke->rel[a]);
+                    ErrorF (" %d=%d", a, ke->rel[a]);
-		ke->rel[a] = 0;
+                ke->rel[a] = 0;
-	    }
+            }
-	    ErrorF ("\n");
+            ErrorF ("\n");
-	    break;
+            break;
-	}
+        }
     for (i = 0; i < ke->max_abs; i++)
-	if (ke->abs[i] != ke->prevabs[i])
+        if (ke->abs[i] != ke->prevabs[i])
-	{
+        {
-	    int a;
+            int a;
-	    ErrorF ("abs");
+            ErrorF ("abs");
-	    for (a = 0; a <= ke->max_abs; a++)
+            for (a = 0; a <= ke->max_abs; a++)
-	    {
+            {
-		if (ISBITSET (ke->absbits, a))
+                if (ISBITSET (ke->absbits, a))
-		    ErrorF (" %d=%d", a, ke->abs[a]);
+                    ErrorF (" %d=%d", a, ke->abs[a]);
-		ke->prevabs[a] = ke->abs[a];
+                ke->prevabs[a] = ke->abs[a];
-	    }
+            }
-	    ErrorF ("\n");
+            ErrorF ("\n");
-	    break;
+            break;
-	}
+        }
 }
 
 static void
 EvdevRead (int evdevPort, void *closure)
 {
-    KdMouseInfo		*mi = closure;
+    KdPointerInfo                *pi = closure;
-    Kevdev		*ke = mi->driver;
+    Kevdev                       *ke = pi->driverPrivate;
-    int			i;
+    int                        i;
-    struct input_event	events[NUM_EVENTS];
+    struct input_event        events[NUM_EVENTS];
-    int			n;
+    int                        n;
 
     n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));
     if (n <= 0)
-	return;
+        return;
     n /= sizeof (struct input_event);
     for (i = 0; i < n; i++)
     {
-	switch (events[i].type) {
+        switch (events[i].type) {
-	case EV_SYN:
+        case EV_SYN:
-	    break;
+            break;
-	case EV_KEY:
+        case EV_KEY:
-	    EvdevMotion (mi);
+            EvdevMotion (pi);
-	    ASSIGNBIT(ke->key,events[i].code, events[i].value);
+            ASSIGNBIT(ke->key,events[i].code, events[i].value);
-	    if (events[i].code < 0x100)
+            if (events[i].code < 0x100)
-		ErrorF ("key %d %d\n", events[i].code, events[i].value);
+                ErrorF ("key %d %d\n", events[i].code, events[i].value);
-	    else
+            else
-		ErrorF ("key 0x%x %d\n", events[i].code, events[i].value);
+                ErrorF ("key 0x%x %d\n", events[i].code, events[i].value);
-	    break;
+            break;
-	case EV_REL:
+        case EV_REL:
-	    ke->rel[events[i].code] += events[i].value;
+            ke->rel[events[i].code] += events[i].value;
-	    break;
+            break;
-	case EV_ABS:
+        case EV_ABS:
-	    ke->abs[events[i].code] = events[i].value;
+            ke->abs[events[i].code] = events[i].value;
-	    break;
+            break;
-	}
+        }
     }
-    EvdevMotion (mi);
+    EvdevMotion (pi);
 }
 
 int EvdevInputType;
@@ -148,143 +150,153 @@ char *kdefaultEvdev[] =  {
 
 #define NUM_DEFAULT_EVDEV    (sizeof (kdefaultEvdev) / sizeof (kdefaultEvdev[0]))
 
-static Bool
+static Status
-EvdevInit (void)
+EvdevInit (KdPointerInfo *pi)
 {
-    int		i;
+    int                i;
-    int		fd;
+    int                fd;
-    KdMouseInfo	*mi, *next;
+    int                n = 0;
-    int		n = 0;
+    char        *prot;
-    char	*prot;
 
-    if (!EvdevInputType)
+    if (!pi->path) {
-	EvdevInputType = KdAllocInputType ();
+        for (i = 0; i < NUM_DEFAULT_EVDEV; i++) {
-
+            fd = open (kdefaultEvdev[i], 2);
-    for (mi = kdMouseInfo; mi; mi = next)
+                if (fd >= 0) {
-    {
+                    pi->path = KdSaveString (kdefaultEvdev[i]);
-	next = mi->next;
+                    break;
-	prot = mi->prot;
+                }
-	if (mi->inputType)
+            }
-	    continue;
-	if (!mi->name)
-	{
-	    for (i = 0; i < NUM_DEFAULT_EVDEV; i++)
-	    {
-		fd = open (kdefaultEvdev[i], 2);
-		if (fd >= 0)
-		{
-		    mi->name = KdSaveString (kdefaultEvdev[i]);
-		    break;
-		}
-	    }
-	}
-	else
-	    fd = open (mi->name, 2);
-	    
-	if (fd >= 0)
-	{
-	    unsigned long   ev[NBITS(EV_MAX)];
-	    Kevdev	    *ke;
-	    
-	    if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0)
-	    {
-		perror ("EVIOCGBIT 0");
-		close (fd);
-		continue;
-	    }
-	    ke = xalloc (sizeof (Kevdev));
-	    if (!ke)
-	    {
-		close (fd);
-		continue;
-	    }
-	    memset (ke, '\0', sizeof (Kevdev));
-	    if (ISBITSET (ev, EV_KEY))
-	    {
-		if (ioctl (fd, EVIOCGBIT (EV_KEY, sizeof (ke->keybits)),
-			   ke->keybits) < 0)
-		{
-		    perror ("EVIOCGBIT EV_KEY");
-		    xfree (ke);
-		    close (fd);
-		    continue;
-		}
-	    }
-	    if (ISBITSET (ev, EV_REL))
-	    {
-		if (ioctl (fd, EVIOCGBIT (EV_REL, sizeof (ke->relbits)),
-			   ke->relbits) < 0)
-		{
-		    perror ("EVIOCGBIT EV_REL");
-		    xfree (ke);
-		    close (fd);
-		    continue;
-		}
-		for (ke->max_rel = REL_MAX; ke->max_rel >= 0; ke->max_rel--)
-		    if (ISBITSET(ke->relbits, ke->max_rel))
-			break;
-	    }
-	    if (ISBITSET (ev, EV_ABS))
-	    {
-		int i;
-
-		if (ioctl (fd, EVIOCGBIT (EV_ABS, sizeof (ke->absbits)),
-			   ke->absbits) < 0)
-		{
-		    perror ("EVIOCGBIT EV_ABS");
-		    xfree (ke);
-		    close (fd);
-		    continue;
-		}
-		for (ke->max_abs = ABS_MAX; ke->max_abs >= 0; ke->max_abs--)
-		    if (ISBITSET(ke->absbits, ke->max_abs))
-			break;
-		for (i = 0; i <= ke->max_abs; i++)
-		{
-		    if (ISBITSET (ke->absbits, i))
-			if (ioctl (fd, EVIOCGABS(i), &ke->absinfo[i]) < 0)
-			{
-			    perror ("EVIOCGABS");
-			    break;
-			}
-		    ke->prevabs[i] = ABS_UNSET;
-		}
-		if (i <= ke->max_abs)
-		{
-		    xfree (ke);
-		    close (fd);
-		    continue;
-		}
-	    }
-	    mi->driver = ke;
-	    mi->inputType = EvdevInputType;
-	    if (KdRegisterFd (EvdevInputType, fd, EvdevRead, (void *) mi))
-		n++;
-	}
     }
-    return TRUE;
+    else {
+        fd = open (pi->path, 2);
+        if (fd < 0) {
+            ErrorF("Failed to open evdev device %s\n", pi->path);
+            return BadMatch;
+        }
+    }
+
+    return Success;
+}
+
+static Status
+EvdevEnable (KdPointerInfo *pi)
+{        
+    int fd;
+
+    if (!pi || !pi->path)
+        return BadImplementation;
+
+    fd = open(pi->path, 2);
+    if (fd < 0)
+        return BadMatch;
+
+    unsigned long   ev[NBITS(EV_MAX)];
+    Kevdev            *ke;
+        
+    if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0)
+    {
+        perror ("EVIOCGBIT 0");
+        close (fd);
+        return BadMatch;
+    }
+    ke = xalloc (sizeof (Kevdev));
+    if (!ke)
+    {
+        close (fd);
+        return BadAlloc;
+    }
+    memset (ke, '\0', sizeof (Kevdev));
+    if (ISBITSET (ev, EV_KEY))
+    {
+        if (ioctl (fd, EVIOCGBIT (EV_KEY, sizeof (ke->keybits)),
+                   ke->keybits) < 0)
+        {
+            perror ("EVIOCGBIT EV_KEY");
+            xfree (ke);
+            close (fd);
+            return BadMatch;
+        }
+    }
+    if (ISBITSET (ev, EV_REL))
+    {
+        if (ioctl (fd, EVIOCGBIT (EV_REL, sizeof (ke->relbits)),
+                       ke->relbits) < 0)
+        {
+            perror ("EVIOCGBIT EV_REL");
+            xfree (ke);
+            close (fd);
+            return BadMatch;
+        }
+        for (ke->max_rel = REL_MAX; ke->max_rel >= 0; ke->max_rel--)
+            if (ISBITSET(ke->relbits, ke->max_rel))
+                break;
+    }
+    if (ISBITSET (ev, EV_ABS))
+    {
+        int i;
+
+        if (ioctl (fd, EVIOCGBIT (EV_ABS, sizeof (ke->absbits)),
+                   ke->absbits) < 0)
+            {
+            perror ("EVIOCGBIT EV_ABS");
+            xfree (ke);
+            close (fd);
+            return BadMatch;
+        }
+        for (ke->max_abs = ABS_MAX; ke->max_abs >= 0; ke->max_abs--)
+            if (ISBITSET(ke->absbits, ke->max_abs))
+                break;
+        for (i = 0; i <= ke->max_abs; i++)
+        {
+            if (ISBITSET (ke->absbits, i))
+                if (ioctl (fd, EVIOCGABS(i), &ke->absinfo[i]) < 0)
+                {
+                    perror ("EVIOCGABS");
+                    break;
+                }
+            ke->prevabs[i] = ABS_UNSET;
+        }
+        if (i <= ke->max_abs)
+        {
+            xfree (ke);
+            close (fd);
+            return BadValue;
+        }
+    }
+    if (!KdRegisterFd (fd, EvdevRead, pi)) {
+        xfree (ke);
+        close (fd);
+        return BadAlloc;
+    }
+    pi->driverPrivate = ke;
+    return Success;
 }
 
 static void
-EvdevFini (void)
+EvdevDisable (KdPointerInfo *pi)
 {
-    KdMouseInfo	*mi;
+    Kevdev              *ke;
 
-    KdUnregisterFds (EvdevInputType, TRUE);
+    if (!pi || !pi->driverPrivate)
-    for (mi = kdMouseInfo; mi; mi = mi->next)
+        return;
-    {
+
-	if (mi->inputType == EvdevInputType)
+    KdUnregisterFd (pi, ke->fd, TRUE);
-	{
+    xfree (ke);
-	    xfree (mi->driver);
+    pi->driverPrivate = 0;
-	    mi->driver = 0;
-	    mi->inputType = 0;
-	}
-    }
 }
 
-KdMouseFuncs LinuxEvdevMouseFuncs = {
+static void
+EvdevFini (KdPointerInfo *pi)
+{
+}
+
+KdPointerDriver LinuxEvdevMouseDriver = {
+    "evdev",
     EvdevInit,
+    EvdevEnable,
+    EvdevDisable,
     EvdevFini,
+    NULL,
 };
 
 #if 0

hw/kdrive/linux/keyboard.c

@@ -2,31 +2,40 @@
  * $RCSId: xc/programs/Xserver/hw/kdrive/linux/keyboard.c,v 1.10 2001/11/08 10:26:24 keithp Exp $
  *
  * Copyright © 1999 Keith Packard
+ * XKB integration © 2006 Nokia Corporation, author: Tomas Frydrych <tf@o-hand.com>
  *
- * Permission to use, copy, modify, distribute, and sell this software and its
+ * LinuxKeyboardRead() XKB code based on xf86KbdLnx.c:
- * documentation for any purpose is hereby granted without fee, provided that
+ * Copyright © 1990,91 by Thomas Roell, Dinkelscherben, Germany.
- * the above copyright notice appear in all copies and that both that
+ * Copyright © 1994-2001 by The XFree86 Project, Inc.
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
  *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * Permission is hereby granted, free of charge, to any person obtaining a
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * copy of this software and associated documentation files (the "Software"),
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * to deal in the Software without restriction, including without limitation
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * and/or sell copies of the Software, and to permit persons to whom the
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * Software is furnished to do so, subject to the following conditions:
- * PERFORMANCE OF THIS SOFTWARE.
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the copyright holder(s)
+ * and author(s) shall not be used in advertising or otherwise to promote
+ * the sale, use or other dealings in this Software without prior written
+ * authorization from the copyright holder(s) and author(s).
  */
 
 #ifdef HAVE_CONFIG_H
 #include <kdrive-config.h>
 #endif
 #include "kdrive.h"
-#include "kkeymap.h"
 #include <linux/keyboard.h>
 #include <linux/kd.h>
 #define XK_PUBLISHING
@@ -34,7 +43,7 @@
 #include <termios.h>
 #include <sys/ioctl.h>
 
-extern int  LinuxConsoleFd;
+extern int LinuxConsoleFd;
 
 static const KeySym linux_to_x[256] = {
 	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
@@ -103,7 +112,108 @@ static const KeySym linux_to_x[256] = {
 	XK_udiaeresis,	XK_yacute,	XK_thorn,	XK_ydiaeresis
 };
 
-static unsigned char tbl[KD_MAX_WIDTH] = 
+#ifdef XKB
+/*
+ * Getting a keycode from scancode
+ *
+ * With XKB
+ * --------
+ *
+ * We have to enqueue keyboard events using standard X keycodes which correspond
+ * to AT scancode + 8; this means that we need to translate the Linux scancode
+ * provided by the kernel to an AT scancode -- this translation is not linear
+ * and requires that we use a LUT.
+ *
+ *
+ * Without XKB
+ * -----------
+ *
+ * We can use custom keycodes, which makes things simpler; we define our custom
+ * keycodes as Linux scancodes + KD_KEY_OFFSET
+*/
+
+/*
+   This LUT translates AT scancodes into Linux ones -- the keymap we create
+   for the core X keyboard protocol has to be AT-scancode based so that it
+   corresponds to the Xkb keymap.
+*/
+static unsigned char at2lnx[] =
+{
+	0x0,    /* no valid scancode */
+	0x01,	/* KEY_Escape */	0x02,	/* KEY_1 */
+	0x03,	/* KEY_2 */		0x04,	/* KEY_3 */
+	0x05,	/* KEY_4 */		0x06,	/* KEY_5 */
+	0x07,	/* KEY_6 */		0x08,	/* KEY_7 */
+	0x09,	/* KEY_8 */		0x0a,	/* KEY_9 */
+	0x0b,	/* KEY_0 */		0x0c,	/* KEY_Minus */
+	0x0d,	/* KEY_Equal */		0x0e,	/* KEY_BackSpace */
+	0x0f,	/* KEY_Tab */		0x10,	/* KEY_Q */
+	0x11,	/* KEY_W */		0x12,	/* KEY_E */
+	0x13,	/* KEY_R */		0x14,	/* KEY_T */
+	0x15,	/* KEY_Y */		0x16,	/* KEY_U */
+	0x17,	/* KEY_I */		0x18,	/* KEY_O */
+	0x19,	/* KEY_P */		0x1a,	/* KEY_LBrace */
+	0x1b,	/* KEY_RBrace */	0x1c,	/* KEY_Enter */
+	0x1d,	/* KEY_LCtrl */		0x1e,	/* KEY_A */
+	0x1f,	/* KEY_S */		0x20,	/* KEY_D */
+	0x21,	/* KEY_F */		0x22,	/* KEY_G */
+	0x23,	/* KEY_H */		0x24,	/* KEY_J */
+	0x25,	/* KEY_K */		0x26,	/* KEY_L */
+	0x27,	/* KEY_SemiColon */	0x28,	/* KEY_Quote */
+	0x29,	/* KEY_Tilde */		0x2a,	/* KEY_ShiftL */
+	0x2b,	/* KEY_BSlash */	0x2c,	/* KEY_Z */
+	0x2d,	/* KEY_X */		0x2e,	/* KEY_C */
+	0x2f,	/* KEY_V */		0x30,	/* KEY_B */
+	0x31,	/* KEY_N */		0x32,	/* KEY_M */
+	0x33,	/* KEY_Comma */		0x34,	/* KEY_Period */
+	0x35,	/* KEY_Slash */		0x36,	/* KEY_ShiftR */
+	0x37,	/* KEY_KP_Multiply */	0x38,	/* KEY_Alt */
+	0x39,	/* KEY_Space */		0x3a,	/* KEY_CapsLock */
+	0x3b,	/* KEY_F1 */		0x3c,	/* KEY_F2 */
+	0x3d,	/* KEY_F3 */		0x3e,	/* KEY_F4 */
+	0x3f,	/* KEY_F5 */		0x40,	/* KEY_F6 */
+	0x41,	/* KEY_F7 */		0x42,	/* KEY_F8 */
+	0x43,	/* KEY_F9 */		0x44,	/* KEY_F10 */
+	0x45,	/* KEY_NumLock */	0x46,	/* KEY_ScrollLock */
+	0x47,	/* KEY_KP_7 */		0x48,	/* KEY_KP_8 */
+	0x49,	/* KEY_KP_9 */		0x4a,	/* KEY_KP_Minus */
+	0x4b,	/* KEY_KP_4 */		0x4c,	/* KEY_KP_5 */
+	0x4d,	/* KEY_KP_6 */		0x4e,	/* KEY_KP_Plus */
+	0x4f,	/* KEY_KP_1 */		0x50,	/* KEY_KP_2 */
+	0x51,	/* KEY_KP_3 */		0x52,	/* KEY_KP_0 */
+	0x53,	/* KEY_KP_Decimal */	0x54,	/* KEY_SysReqest */
+	0x00,	/* 0x55 */		0x56,	/* KEY_Less */
+	0x57,	/* KEY_F11 */		0x58,	/* KEY_F12 */
+	0x66,	/* KEY_Home */		0x67,	/* KEY_Up */
+	0x68,	/* KEY_PgUp */		0x69,	/* KEY_Left */
+	0x5d,	/* KEY_Begin */		0x6a,	/* KEY_Right */
+	0x6b,	/* KEY_End */		0x6c,	/* KEY_Down */
+	0x6d,	/* KEY_PgDown */	0x6e,	/* KEY_Insert */
+	0x6f,	/* KEY_Delete */	0x60,	/* KEY_KP_Enter */
+	0x61,	/* KEY_RCtrl */		0x77,	/* KEY_Pause */
+	0x63,	/* KEY_Print */		0x62,	/* KEY_KP_Divide */
+	0x64,	/* KEY_AltLang */	0x65,	/* KEY_Break */
+	0x00,	/* KEY_LMeta */		0x00,	/* KEY_RMeta */
+	0x7A,	/* KEY_Menu/FOCUS_PF11*/0x00,	/* 0x6e */
+	0x7B,	/* FOCUS_PF12 */	0x00,	/* 0x70 */
+	0x00,	/* 0x71 */		0x00,	/* 0x72 */
+	0x59,	/* FOCUS_PF2 */		0x78,	/* FOCUS_PF9 */
+	0x00,	/* 0x75 */		0x00,	/* 0x76 */
+	0x5A,	/* FOCUS_PF3 */		0x5B,	/* FOCUS_PF4 */
+	0x5C,	/* FOCUS_PF5 */		0x5D,	/* FOCUS_PF6 */
+	0x5E,	/* FOCUS_PF7 */		0x5F,	/* FOCUS_PF8 */
+	0x7C,	/* JAP_86 */		0x79,	/* FOCUS_PF10 */
+	0x00,	/* 0x7f */
+};
+
+#define NUM_AT_KEYS (sizeof(at2lnx)/sizeof(at2lnx[0]))
+#define LNX_KEY_INDEX(n) n < NUM_AT_KEYS ? at2lnx[n] : 0
+
+#else /* not XKB */
+#define LNX_KEY_INDEX(n) n
+#endif
+
+static unsigned char tbl[KD_MAX_WIDTH] =
 {
     0,
     1 << KG_SHIFT,
@@ -112,24 +222,31 @@ static unsigned char tbl[KD_MAX_WIDTH] =
 };
 
 static void
-readKernelMapping(void)
+readKernelMapping(KdKeyboardInfo *ki)
 {
     KeySym	    *k;
     int		    i, j;
     struct kbentry  kbe;
     int		    minKeyCode, maxKeyCode;
     int		    row;
+    int             fd;
 
+    if (!ki)
+        return;
+
+    fd = LinuxConsoleFd;
+    
     minKeyCode = NR_KEYS;
     maxKeyCode = 0;
     row = 0;
+    ki->keySyms.mapWidth = KD_MAX_WIDTH;
     for (i = 0; i < NR_KEYS && row < KD_MAX_LENGTH; ++i)
     {
-	kbe.kb_index = i;
+        kbe.kb_index = LNX_KEY_INDEX(i);
 
-        k = kdKeymap + row * KD_MAX_WIDTH;
+        k = ki->keySyms.map + row * ki->keySyms.mapWidth;
 	
-	for (j = 0; j < KD_MAX_WIDTH; ++j)
+	for (j = 0; j < ki->keySyms.mapWidth; ++j)
 	{
 	    unsigned short kval;
 
@@ -137,7 +254,7 @@ readKernelMapping(void)
 
 	    kbe.kb_table = tbl[j];
 	    kbe.kb_value = 0;
-	    if (ioctl(LinuxConsoleFd, KDGKBENT, &kbe))
+	    if (ioctl(fd, KDGKBENT, &kbe))
 		continue;
 
 	    kval = KVAL(kbe.kb_value);
@@ -362,7 +479,7 @@ readKernelMapping(void)
 
 	if (minKeyCode == NR_KEYS)
 	    continue;
-	
+
 	if (k[3] == k[2]) k[3] = NoSymbol;
 	if (k[2] == k[1]) k[2] = NoSymbol;
 	if (k[1] == k[0]) k[1] = NoSymbol;
@@ -370,28 +487,223 @@ readKernelMapping(void)
 	if (k[3] == k[0] && k[2] == k[1] && k[2] == NoSymbol) k[3] =NoSymbol;
 	row++;
     }
-    kdMinScanCode = minKeyCode;
+    ki->minScanCode = minKeyCode;
-    kdMaxScanCode = maxKeyCode;
+    ki->maxScanCode = maxKeyCode;
 }
 
-static void
+#ifdef XKB
-LinuxKeyboardLoad (void)
+
-{
+/*
-    readKernelMapping ();
+ * We need these to handle extended scancodes correctly (I could just use the
-}
+ * numbers below, but this makes the code more readable
+ */
+
+/* The prefix codes */
+#define KEY_Prefix0      /* special               0x60  */   96
+#define KEY_Prefix1      /* special               0x61  */   97
+
+/* The raw scancodes */
+#define KEY_Enter        /* Enter                 0x1c  */   28
+#define KEY_LCtrl        /* Ctrl(left)            0x1d  */   29
+#define KEY_Slash        /* / (Slash)   ?         0x35  */   53
+#define KEY_KP_Multiply  /* *                     0x37  */   55
+#define KEY_Alt          /* Alt(left)             0x38  */   56
+#define KEY_F3           /* F3                    0x3d  */   61
+#define KEY_F4           /* F4                    0x3e  */   62
+#define KEY_F5           /* F5                    0x3f  */   63
+#define KEY_F6           /* F6                    0x40  */   64
+#define KEY_F7           /* F7                    0x41  */   65
+#define KEY_ScrollLock   /* ScrollLock            0x46  */   70
+#define KEY_KP_7         /* 7           Home      0x47  */   71
+#define KEY_KP_8         /* 8           Up        0x48  */   72
+#define KEY_KP_9         /* 9           PgUp      0x49  */   73
+#define KEY_KP_Minus     /* - (Minus)             0x4a  */   74
+#define KEY_KP_4         /* 4           Left      0x4b  */   75
+#define KEY_KP_5         /* 5                     0x4c  */   76
+#define KEY_KP_6         /* 6           Right     0x4d  */   77
+#define KEY_KP_Plus      /* + (Plus)              0x4e  */   78
+#define KEY_KP_1         /* 1           End       0x4f  */   79
+#define KEY_KP_2         /* 2           Down      0x50  */   80
+#define KEY_KP_3         /* 3           PgDown    0x51  */   81
+#define KEY_KP_0         /* 0           Insert    0x52  */   82
+#define KEY_KP_Decimal   /* . (Decimal) Delete    0x53  */   83
+#define KEY_Home         /* Home                  0x59  */   89
+#define KEY_Up           /* Up                    0x5a  */   90
+#define KEY_PgUp         /* PgUp                  0x5b  */   91
+#define KEY_Left         /* Left                  0x5c  */   92
+#define KEY_Begin        /* Begin                 0x5d  */   93
+#define KEY_Right        /* Right                 0x5e  */   94
+#define KEY_End          /* End                   0x5f  */   95
+#define KEY_Down         /* Down                  0x60  */   96
+#define KEY_PgDown       /* PgDown                0x61  */   97
+#define KEY_Insert       /* Insert                0x62  */   98
+#define KEY_Delete       /* Delete                0x63  */   99
+#define KEY_KP_Enter     /* Enter                 0x64  */  100
+#define KEY_RCtrl        /* Ctrl(right)           0x65  */  101
+#define KEY_Pause        /* Pause                 0x66  */  102
+#define KEY_Print        /* Print                 0x67  */  103
+#define KEY_KP_Divide    /* Divide                0x68  */  104
+#define KEY_AltLang      /* AtlLang(right)        0x69  */  105
+#define KEY_Break        /* Break                 0x6a  */  106
+#define KEY_LMeta        /* Left Meta             0x6b  */  107
+#define KEY_RMeta        /* Right Meta            0x6c  */  108
+#define KEY_Menu         /* Menu                  0x6d  */  109
+#define KEY_F13          /* F13                   0x6e  */  110
+#define KEY_F14          /* F14                   0x6f  */  111
+#define KEY_F15          /* F15                   0x70  */  112
+#define KEY_F16          /* F16                   0x71  */  113
+#define KEY_F17          /* F17                   0x72  */  114
+#define KEY_KP_DEC       /* KP_DEC                0x73  */  115
+
+#endif /* XKB */
+
 
 static void
 LinuxKeyboardRead (int fd, void *closure)
 {
     unsigned char   buf[256], *b;
     int		    n;
+    unsigned char   prefix = 0, scancode = 0;
 
-    while ((n = read (fd, buf, sizeof (buf))) > 0)
+    while ((n = read (fd, buf, sizeof (buf))) > 0) {
-    {
 	b = buf;
-	while (n--)
+	while (n--) {
-	{
+#ifdef XKB
-	    KdEnqueueKeyboardEvent (b[0] & 0x7f, b[0] & 0x80);
+            if (!noXkbExtension) {
+                /*
+                 * With xkb we use RAW mode for reading the console, which allows us
+                 * process extended scancodes.
+                 *
+                 * See if this is a prefix extending the following keycode
+                 */
+                if (!prefix && ((b[0] & 0x7f) == KEY_Prefix0))
+                {
+                        prefix = KEY_Prefix0;
+#ifdef DEBUG
+                        ErrorF("Prefix0");
+#endif
+                        /* swallow this up */
+                        b++;
+                        continue;
+                }
+                else if (!prefix && ((b[0] & 0x7f) == KEY_Prefix1))
+                {
+                        prefix = KEY_Prefix1;
+                        ErrorF("Prefix1");
+                        /* swallow this up */
+                        b++;
+                        continue;
+                }
+                scancode  = b[0] & 0x7f;
+
+                switch (prefix) {
+                        /* from xf86Events.c */
+                        case KEY_Prefix0:
+                        {
+#ifdef DEBUG
+                            ErrorF("Prefix0 scancode: 0x%02x\n", scancode);
+#endif
+                            switch (scancode) {
+                                case KEY_KP_7:
+                                    scancode = KEY_Home;      break;  /* curs home */
+                                case KEY_KP_8:
+                                    scancode = KEY_Up;        break;  /* curs up */
+                                case KEY_KP_9:
+                                    scancode = KEY_PgUp;      break;  /* curs pgup */
+                                case KEY_KP_4:
+                                    scancode = KEY_Left;      break;  /* curs left */
+                                case KEY_KP_5:
+                                    scancode = KEY_Begin;     break;  /* curs begin */
+                                case KEY_KP_6:
+                                    scancode = KEY_Right;     break;  /* curs right */
+                                case KEY_KP_1:
+                                    scancode = KEY_End;       break;  /* curs end */
+                                case KEY_KP_2:
+                                    scancode = KEY_Down;      break;  /* curs down */
+                                case KEY_KP_3:
+                                    scancode = KEY_PgDown;    break;  /* curs pgdown */
+                                case KEY_KP_0:
+                                    scancode = KEY_Insert;    break;  /* curs insert */
+                                case KEY_KP_Decimal:
+                                    scancode = KEY_Delete;    break;  /* curs delete */
+                                case KEY_Enter:
+                                    scancode = KEY_KP_Enter;  break;  /* keypad enter */
+                                case KEY_LCtrl:
+                                    scancode = KEY_RCtrl;     break;  /* right ctrl */
+                                case KEY_KP_Multiply:
+                                    scancode = KEY_Print;     break;  /* print */
+                                case KEY_Slash:
+                                    scancode = KEY_KP_Divide; break;  /* keyp divide */
+                                case KEY_Alt:
+                                    scancode = KEY_AltLang;   break;  /* right alt */
+                                case KEY_ScrollLock:
+                                    scancode = KEY_Break;     break;  /* curs break */
+                                case 0x5b:
+                                    scancode = KEY_LMeta;     break;
+                                case 0x5c:
+                                    scancode = KEY_RMeta;     break;
+                                case 0x5d:
+                                    scancode = KEY_Menu;      break;
+                                case KEY_F3:
+                                    scancode = KEY_F13;       break;
+                                case KEY_F4:
+                                    scancode = KEY_F14;       break;
+                                case KEY_F5:
+                                    scancode = KEY_F15;       break;
+                                case KEY_F6:
+                                    scancode = KEY_F16;       break;
+                                case KEY_F7:
+                                    scancode = KEY_F17;       break;
+                                case KEY_KP_Plus:
+                                    scancode = KEY_KP_DEC;    break;
+                                /* Ignore virtual shifts (E0 2A, E0 AA, E0 36, E0 B6) */
+                                case 0x2A:
+                                case 0x36:
+                                    b++;
+                                    prefix = 0;
+                                    continue;
+                                default:
+#ifdef DEBUG
+                                    ErrorF("Unreported Prefix0 scancode: 0x%02x\n",
+                                           scancode);
+#endif
+                                     /*
+                                      * "Internet" keyboards are generating lots of new
+                                      * codes.  Let them pass.  There is little consistency
+                                      * between them, so don't bother with symbolic names at
+                                      * this level.
+                                      */
+                                    scancode += 0x78;
+                            }
+                            break;
+                        }
+
+                        case KEY_Prefix1:
+                        {
+                            /* we do no handle these */
+#ifdef DEBUG
+                            ErrorF("Prefix1 scancode: 0x%02x\n", scancode);
+#endif
+                            b++;
+                            prefix = 0;
+                            continue;
+                        }
+
+                        default: /* should not happen*/
+                        case 0: /* do nothing */
+#ifdef DEBUG
+                            ErrorF("Plain scancode: 0x%02x\n", scancode);
+#endif
+                            ;
+                }
+
+                prefix = 0;
+            }
+            /* without xkb we use mediumraw mode -- enqueue the scancode as is */
+            else
+#endif
+                scancode = b[0] & 0x7f;
+	    KdEnqueueKeyboardEvent (closure, scancode, b[0] & 0x80);
 	    b++;
 	}
     }
@@ -399,19 +711,30 @@ LinuxKeyboardRead (int fd, void *closure)
 
 static int		LinuxKbdTrans;
 static struct termios	LinuxTermios;
-static int		LinuxKbdType;
 
-static int
+static Status
-LinuxKeyboardEnable (int fd, void *closure)
+LinuxKeyboardEnable (KdKeyboardInfo *ki)
 {
     struct termios nTty;
     unsigned char   buf[256];
     int		    n;
+    int             fd;
+
+    if (!ki)
+        return !Success;
+
+    fd = LinuxConsoleFd;
+    ki->driverPrivate = (void *) fd;
 
     ioctl (fd, KDGKBMODE, &LinuxKbdTrans);
     tcgetattr (fd, &LinuxTermios);
-    
+#ifdef XKB
-    ioctl(fd, KDSKBMODE, K_MEDIUMRAW);
+    if (!noXkbExtension)
+        ioctl(fd, KDSKBMODE, K_RAW);
+    else
+#else
+        ioctl(fd, KDSKBMODE, K_MEDIUMRAW);
+#endif
     nTty = LinuxTermios;
     nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
     nTty.c_oflag = 0;
@@ -422,54 +745,74 @@ LinuxKeyboardEnable (int fd, void *closure)
     cfsetispeed(&nTty, 9600);
     cfsetospeed(&nTty, 9600);
     tcsetattr(fd, TCSANOW, &nTty);
+    /* Our kernel cleverly ignores O_NONBLOCK.  Sigh. */
+#if 0
     /*
      * Flush any pending keystrokes
      */
     while ((n = read (fd, buf, sizeof (buf))) > 0)
 	;
-    return fd;
+#endif
+    KdRegisterFd (fd, LinuxKeyboardRead, ki);
+    return Success;
 }
 
 static void
-LinuxKeyboardDisable (int fd, void *closure)
+LinuxKeyboardDisable (KdKeyboardInfo *ki)
 {
-    ioctl(LinuxConsoleFd, KDSKBMODE, LinuxKbdTrans);
+    int fd;
-    tcsetattr(LinuxConsoleFd, TCSANOW, &LinuxTermios);
+    
+    if (!ki)
+        return;
+
+    fd = (int) ki->driverPrivate;
+
+    KdUnregisterFd(ki, fd, FALSE);
+    ioctl(fd, KDSKBMODE, LinuxKbdTrans);
+    tcsetattr(fd, TCSANOW, &LinuxTermios);
 }
 
-static int
+static Status
-LinuxKeyboardInit (void)
+LinuxKeyboardInit (KdKeyboardInfo *ki)
 {
-    if (!LinuxKbdType)
+    if (!ki)
-	LinuxKbdType = KdAllocInputType ();
+        return !Success;
 
-    KdRegisterFd (LinuxKbdType, LinuxConsoleFd, LinuxKeyboardRead, 0);
+    if (ki->path)
-    LinuxKeyboardEnable (LinuxConsoleFd, 0);
+        xfree(ki->path);
-    KdRegisterFdEnableDisable (LinuxConsoleFd, 
+    ki->path = KdSaveString("console");
-			       LinuxKeyboardEnable,
+    if (ki->name)
-			       LinuxKeyboardDisable);
+        xfree(ki->name);
-    return 1;
+    ki->name = KdSaveString("Linux console keyboard");
+
+    readKernelMapping (ki);
+
+    return Success;
 }
 
 static void
-LinuxKeyboardFini (void)
+LinuxKeyboardFini (KdKeyboardInfo *ki)
 {
-    LinuxKeyboardDisable (LinuxConsoleFd, 0);
-    KdUnregisterFds (LinuxKbdType, FALSE);
 }
 
 static void
-LinuxKeyboardLeds (int leds)
+LinuxKeyboardLeds (KdKeyboardInfo *ki, int leds)
 {
-    ioctl (LinuxConsoleFd, KDSETLED, leds & 7);
+    if (!ki)
+        return;
+
+    ioctl ((int)ki->driverPrivate, KDSETLED, leds & 7);
 }
 
 static void
-LinuxKeyboardBell (int volume, int pitch, int duration)
+LinuxKeyboardBell (KdKeyboardInfo *ki, int volume, int pitch, int duration)
 {
+    if (!ki)
+        return;
+
     if (volume && pitch)
     {
-	ioctl(LinuxConsoleFd, KDMKTONE,
+	ioctl((int)ki->driverPrivate, KDMKTONE,
 	      ((1193190 / pitch) & 0xffff) |
 	      (((unsigned long)duration *
 		volume / 50) << 16));
@@ -477,11 +820,13 @@ LinuxKeyboardBell (int volume, int pitch, int duration)
     }
 }
 
-KdKeyboardFuncs	LinuxKeyboardFuncs = {
+KdKeyboardDriver LinuxKeyboardDriver = {
-    LinuxKeyboardLoad,
+    "keyboard",
     LinuxKeyboardInit,
+    LinuxKeyboardEnable,
     LinuxKeyboardLeds,
     LinuxKeyboardBell,
+    LinuxKeyboardDisable,
     LinuxKeyboardFini,
-    3,
+    NULL,
 };

hw/kdrive/linux/linux.c

@@ -456,6 +456,7 @@ LinuxFini (void)
 	}
     }
     close(LinuxConsoleFd);                /* make the vt-manager happy */
+    LinuxConsoleFd = -1;
     fd = open ("/dev/tty0", O_RDWR|O_NDELAY, 0);
     if (fd >= 0)
     {

hw/kdrive/linux/mouse.c

@@ -206,10 +206,10 @@ MouseWriteBytes (int fd, unsigned char *c, int n, int timeout)
 
 typedef struct _kmouseProt {
     char	    *name;
-    Bool	    (*Complete) (KdMouseInfo *mi, unsigned char *ev, int ne);
+    Bool	    (*Complete) (KdPointerInfo *pi, unsigned char *ev, int ne);
-    int		    (*Valid) (KdMouseInfo *mi, unsigned char *ev, int ne);
+    int		    (*Valid) (KdPointerInfo *pi, unsigned char *ev, int ne);
-    Bool	    (*Parse) (KdMouseInfo *mi, unsigned char *ev, int ne);
+    Bool	    (*Parse) (KdPointerInfo *pi, unsigned char *ev, int ne);
-    Bool	    (*Init) (KdMouseInfo *mi);
+    Bool	    (*Init) (KdPointerInfo *pi);
     unsigned char   headerMask, headerValid;
     unsigned char   dataMask, dataValid;
     Bool	    tty;
@@ -238,9 +238,9 @@ typedef struct _kmouse {
     unsigned long	state;	/* private per protocol, init to prot->state */
 } Kmouse;
     
-static int mouseValid (KdMouseInfo *mi, unsigned char *ev, int ne)
+static int mouseValid (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse		*km = mi->driver;
+    Kmouse		*km = pi->driverPrivate;
     const KmouseProt	*prot = km->prot;
     int	    i;
 
@@ -255,24 +255,24 @@ static int mouseValid (KdMouseInfo *mi, unsigned char *ev, int ne)
     return 0;
 }
 
-static Bool threeComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool threeComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
     return ne == 3;
 }
 
-static Bool fourComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool fourComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
     return ne == 4;
 }
 
-static Bool fiveComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool fiveComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
     return ne == 5;
 }
 
-static Bool MouseReasonable (KdMouseInfo *mi, unsigned long flags, int dx, int dy)
+static Bool MouseReasonable (KdPointerInfo *pi, unsigned long flags, int dx, int dy)
 {
-    Kmouse		*km = mi->driver;
+    Kmouse		*km = pi->driverPrivate;
 
     if (km->stage == MouseWorking) 
 	return TRUE;
@@ -296,9 +296,9 @@ static Bool MouseReasonable (KdMouseInfo *mi, unsigned long flags, int dx, int d
 /*
  * Standard PS/2 mouse protocol
  */
-static Bool ps2Parse (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool ps2Parse (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = mi->driver;
+    Kmouse	    *km = pi->driverPrivate;
     int		    dx, dy, dz;
     unsigned long   flags;
     unsigned long   flagsrelease = 0;
@@ -333,21 +333,21 @@ static Bool ps2Parse (KdMouseInfo *mi, unsigned char *ev, int ne)
     if (ev[0] & 0x20)
 	dy -= 256;
     dy = -dy;
-    if (!MouseReasonable (mi, flags, dx, dy))
+    if (!MouseReasonable (pi, flags, dx, dy))
 	return FALSE;
     if (km->stage == MouseWorking)
     {
-	KdEnqueueMouseEvent (mi, flags, dx, dy);
+	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
 	if (flagsrelease)
 	{
 	    flags &= ~flagsrelease;
-	    KdEnqueueMouseEvent (mi, flags, dx, dy);
+	    KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
 	}
     }
     return TRUE;
 }
 
-static Bool ps2Init (KdMouseInfo *mi);
+static Bool ps2Init (KdPointerInfo *pi);
 
 static const KmouseProt ps2Prot = {
     "ps/2",
@@ -450,9 +450,9 @@ static unsigned char	intelli_init[] = {
 #define NINIT_INTELLI	3
 
 static int
-ps2SkipInit (KdMouseInfo *mi, int ninit, Bool ret_next)
+ps2SkipInit (KdPointerInfo *pi, int ninit, Bool ret_next)
 {
-    Kmouse  *km = mi->driver;
+    Kmouse  *km = pi->driverPrivate;
     int	    c = -1;
     int	    skipping;
     Bool    waiting;
@@ -481,9 +481,9 @@ ps2SkipInit (KdMouseInfo *mi, int ninit, Bool ret_next)
 }
 
 static Bool
-ps2Init (KdMouseInfo *mi)
+ps2Init (KdPointerInfo *pi)
 {
-    Kmouse	    *km = mi->driver;
+    Kmouse	    *km = pi->driverPrivate;
     int		    skipping;
     Bool	    waiting;
     int		    id;
@@ -499,7 +499,7 @@ ps2Init (KdMouseInfo *mi)
 	return FALSE;
     skipping = 0;
     waiting = FALSE;
-    id = ps2SkipInit (mi, 0, TRUE);
+    id = ps2SkipInit (pi, 0, TRUE);
     switch (id) {
     case 3:
 	init = wheel_3button_init;
@@ -524,13 +524,13 @@ ps2Init (KdMouseInfo *mi)
      * initialization string.  Make sure any partial event is
      * skipped
      */
-    (void) ps2SkipInit (mi, ninit, FALSE);
+    (void) ps2SkipInit (pi, ninit, FALSE);
     return TRUE;
 }
 
-static Bool busParse (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool busParse (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = mi->driver;
+    Kmouse	    *km = pi->driverPrivate;
     int		    dx, dy;
     unsigned long   flags;
     
@@ -543,10 +543,10 @@ static Bool busParse (KdMouseInfo *mi, unsigned char *ev, int ne)
 	flags |= KD_BUTTON_2;
     if ((ev[0] & 1) == 0)
 	flags |= KD_BUTTON_3;
-    if (!MouseReasonable (mi, flags, dx, dy))
+    if (!MouseReasonable (pi, flags, dx, dy))
 	return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueueMouseEvent (mi, flags, dx, dy);
+	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -561,9 +561,9 @@ static const KmouseProt busProt = {
  * Standard MS serial protocol, three bytes
  */
 
-static Bool msParse (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool msParse (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = mi->driver;
+    Kmouse	    *km = pi->driverPrivate;
     int		    dx, dy;
     unsigned long   flags;
 
@@ -576,10 +576,10 @@ static Bool msParse (KdMouseInfo *mi, unsigned char *ev, int ne)
 
     dx = (signed char)(((ev[0] & 0x03) << 6) | (ev[1] & 0x3F));
     dy = (signed char)(((ev[0] & 0x0C) << 4) | (ev[2] & 0x3F));
-    if (!MouseReasonable (mi, flags, dx, dy))
+    if (!MouseReasonable (pi, flags, dx, dy))
 	return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueueMouseEvent (mi, flags, dx, dy);
+	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -600,9 +600,9 @@ static const KmouseProt msProt = {
  * first byte of a synchronized protocol stream and see if it's got
  * any bits turned on that can't occur in that fourth byte
  */
-static Bool logiComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool logiComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse		*km = mi->driver;
+    Kmouse		*km = pi->driverPrivate;
 
     if ((ev[0] & 0x40) == 0x40)
 	return ne == 3;
@@ -611,9 +611,9 @@ static Bool logiComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
     return FALSE;
 }
 
-static int logiValid (KdMouseInfo *mi, unsigned char *ev, int ne)
+static int logiValid (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse		*km = mi->driver;
+    Kmouse		*km = pi->driverPrivate;
     const KmouseProt	*prot = km->prot;
     int	    i;
 
@@ -632,9 +632,9 @@ static int logiValid (KdMouseInfo *mi, unsigned char *ev, int ne)
     return 0;
 }
 
-static Bool logiParse (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool logiParse (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = mi->driver;
+    Kmouse	    *km = pi->driverPrivate;
     int		    dx, dy;
     unsigned long   flags;
 
@@ -660,10 +660,10 @@ static Bool logiParse (KdMouseInfo *mi, unsigned char *ev, int ne)
 	flags |= km->state & (KD_BUTTON_1|KD_BUTTON_3);
     }
 
-    if (!MouseReasonable (mi, flags, dx, dy))
+    if (!MouseReasonable (pi, flags, dx, dy))
 	return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueueMouseEvent (mi, flags, dx, dy);
+	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -682,9 +682,9 @@ static const KmouseProt logiProt = {
 /*
  * Mouse systems protocol, 5 bytes
  */
-static Bool mscParse (KdMouseInfo *mi, unsigned char *ev, int ne)
+static Bool mscParse (KdPointerInfo *pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = mi->driver;
+    Kmouse	    *km = pi->driverPrivate;
     int		    dx, dy;
     unsigned long   flags;
 
@@ -699,10 +699,10 @@ static Bool mscParse (KdMouseInfo *mi, unsigned char *ev, int ne)
     dx =    (signed char)(ev[1]) + (signed char)(ev[3]);
     dy = - ((signed char)(ev[2]) + (signed char)(ev[4]));
 
-    if (!MouseReasonable (mi, flags, dx, dy))
+    if (!MouseReasonable (pi, flags, dx, dy))
 	return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueueMouseEvent (mi, flags, dx, dy);
+	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -810,8 +810,8 @@ MouseNextProtocol (Kmouse *km)
 static void
 MouseRead (int mousePort, void *closure)
 {
-    KdMouseInfo	    *mi = closure;
+    KdPointerInfo   *pi = closure;
-    Kmouse	    *km = mi->driver;
+    Kmouse	    *km = pi->driverPrivate;
     unsigned char   event[MAX_MOUSE];
     int		    ne;
     int		    c;
@@ -835,7 +835,7 @@ MouseRead (int mousePort, void *closure)
 	    break;
 	}
 	event[ne++] = c;
-	i = (*km->prot->Valid) (mi, event, ne);
+	i = (*km->prot->Valid) (pi, event, ne);
 	if (i != 0)
 	{
 #ifdef DEBUG
@@ -867,9 +867,9 @@ MouseRead (int mousePort, void *closure)
 	}
 	else
 	{
-	    if ((*km->prot->Complete) (mi, event, ne))
+	    if ((*km->prot->Complete) (pi, event, ne))
 	    {
-		if ((*km->prot->Parse) (mi, event, ne))
+		if ((*km->prot->Parse) (pi, event, ne))
 		{
 		    switch (km->stage)
 		    {
@@ -896,7 +896,7 @@ MouseRead (int mousePort, void *closure)
 			    km->invalid = 0;
 			    km->tested = 0;
 			    km->valid = 0;
-			    if (km->prot->Init && !(*km->prot->Init) (mi))
+			    if (km->prot->Init && !(*km->prot->Init) (pi))
 				km->stage = MouseBroken;
 			}
 			break;
@@ -923,9 +923,9 @@ MouseRead (int mousePort, void *closure)
 int MouseInputType;
 
 char *kdefaultMouse[] =  {
+    "/dev/input/mice",
     "/dev/mouse",
     "/dev/psaux",
-    "/dev/input/mice",
     "/dev/adbmouse",
     "/dev/ttyS0",
     "/dev/ttyS1",
@@ -933,81 +933,97 @@ char *kdefaultMouse[] =  {
 
 #define NUM_DEFAULT_MOUSE    (sizeof (kdefaultMouse) / sizeof (kdefaultMouse[0]))
 
-static Bool
+static Status
-MouseInit (void)
+MouseInit (KdPointerInfo *pi)
 {
     int		i;
     int		fd;
     Kmouse	*km;
-    KdMouseInfo	*mi, *next;
-    int		n = 0;
-    char	*prot;
 
-    if (!MouseInputType)
+    if (!pi)
-	MouseInputType = KdAllocInputType ();
+        return BadImplementation;
-
+    
-    for (mi = kdMouseInfo; mi; mi = next)
+    if (!pi->path || strcmp(pi->path, "auto") == 0) {
-    {
+        for (i = 0; i < NUM_DEFAULT_MOUSE; i++) {
-	next = mi->next;
+            fd = open (kdefaultMouse[i], 2);
-	prot = mi->prot;
+            if (fd >= 0) {
-	if (mi->inputType)
+                pi->path = KdSaveString (kdefaultMouse[i]);
-	    continue;
+                break;
-	if (!mi->name)
+            }
-	{
+        }
-	    for (i = 0; i < NUM_DEFAULT_MOUSE; i++)
-	    {
-		fd = open (kdefaultMouse[i], 2);
-		if (fd >= 0)
-		{
-		    mi->name = KdSaveString (kdefaultMouse[i]);
-		    break;
-		}
-	    }
-	}
-	else
-	    fd = open (mi->name, 2);
-	    
-	if (fd >= 0)
-	{
-	    km = (Kmouse *) xalloc (sizeof (Kmouse));
-	    if (km)
-	    {
-		km->iob.fd = fd;
-		km->iob.avail = km->iob.used = 0;
-		km->prot = 0;
-		km->i_prot = 0;
-		km->tty = isatty (fd);
-		mi->driver = km;
-		mi->inputType = MouseInputType;
-		MouseFirstProtocol (km, mi->prot);
-		if (KdRegisterFd (MouseInputType, fd, MouseRead, (void *) mi))
-		    n++;
-	    }
-	    else
-		close (fd);
-	}
     }
-    return TRUE;
+    else {
+        fd = open (pi->path, 2);
+    }
+	    
+    if (fd < 0)
+        return BadMatch;
+
+    close(fd);
+
+    km = (Kmouse *) xalloc (sizeof (Kmouse));
+    if (km) {
+        km->iob.avail = km->iob.used = 0;
+        MouseFirstProtocol(km, "exps/2");
+        km->i_prot = 0;
+        km->tty = isatty (fd);
+        km->iob.fd = -1;
+        pi->driverPrivate = km;
+    }
+    else {
+        close (fd);
+        return BadAlloc;
+    }
+
+    return Success;
+}
+
+static Status
+MouseEnable (KdPointerInfo *pi)
+{
+    Kmouse *km;
+
+    if (!pi || !pi->driverPrivate || !pi->path)
+        return BadImplementation;
+
+    km = pi->driverPrivate;
+
+    km->iob.fd = open(pi->path, 2);
+    if (km->iob.fd < 0)
+        return BadMatch;
+
+    if (!KdRegisterFd (km->iob.fd, MouseRead, pi))
+    {
+        close(km->iob.fd);
+        return BadAlloc;
+    }
+
+    return Success;
 }
 
 static void
-MouseFini (void)
+MouseDisable (KdPointerInfo *pi)
 {
-    KdMouseInfo	*mi;
+    Kmouse *km;
-
+    if (!pi || !pi->driverPrivate)
-    KdUnregisterFds (MouseInputType, TRUE);
+        return;
-    for (mi = kdMouseInfo; mi; mi = mi->next)
+    
-    {
+    km = pi->driverPrivate;
-	if (mi->inputType == MouseInputType)
+    KdUnregisterFd (pi, km->iob.fd, TRUE);
-	{
-	    xfree (mi->driver);
-	    mi->driver = 0;
-	    mi->inputType = 0;
-	}
-    }
 }
 
-KdMouseFuncs LinuxMouseFuncs = {
+static void
+MouseFini (KdPointerInfo *pi)
+{
+    xfree (pi->driverPrivate);
+    pi->driverPrivate = NULL;
+}
+
+KdPointerDriver LinuxMouseDriver = {
+    "mouse",
     MouseInit,
+    MouseEnable,
+    MouseDisable,
     MouseFini,
+    NULL,
 };

hw/kdrive/linux/ms.c

@@ -90,41 +90,50 @@ MsRead (int port, void *closure)
 	    dy = (char)(((b[0] & 0x0C) << 4) | (b[2] & 0x3F));
             n -= 3;
             b += 3;
-	    KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
+	    KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
 	}
     }
 }
 
-int MsInputType;
+static Status
+MsInit (KdPointerInfo *pi)
+{
+    if (!pi)
+        return BadImplementation;
 
-static int
+    if (!pi->path || strcmp(pi->path, "auto"))
-MsInit (void)
+        pi->path = KdSaveString("/dev/mouse");
+    if (!pi->name)
+        pi->name = KdSaveString("Microsoft protocol mouse");
+    
+    return Success; 
+}
+
+static Status
+MsEnable (KdPointerInfo *pi)
 {
     int port;
-    char *device = "/dev/mouse";
     struct termios t;
     int ret;
 
-    if (!MsInputType)
+    port = open (pi->path, O_RDWR | O_NONBLOCK);
-	MsInputType = KdAllocInputType ();
-    port = open (device, O_RDWR | O_NONBLOCK);
     if(port < 0) {
-        ErrorF("Couldn't open %s (%d)\n", device, (int)errno);
+        ErrorF("Couldn't open %s (%d)\n", pi->path, (int)errno);
         return 0;
     } else if (port == 0) {
         ErrorF("Opening %s returned 0!  Please complain to Keith.\n",
-               device);
+               pi->path);
 	goto bail;
     }
 
     if(!isatty(port)) {
-        ErrorF("%s is not a tty\n", device);
+        ErrorF("%s is not a tty\n", pi->path);
         goto bail;
     }
 
     ret = tcgetattr(port, &t);
     if(ret < 0) {
-        ErrorF("Couldn't tcgetattr(%s): %d\n", device, errno);
+        ErrorF("Couldn't tcgetattr(%s): %d\n", pi->path, errno);
         goto bail;
     }
     t.c_iflag &= ~ (IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR |
@@ -140,24 +149,36 @@ MsInit (void)
     t.c_cc[VTIME] = 0;
     ret = tcsetattr(port, TCSANOW, &t);
     if(ret < 0) {
-        ErrorF("Couldn't tcsetattr(%s): %d\n", device, errno);
+        ErrorF("Couldn't tcsetattr(%s): %d\n", pi->path, errno);
         goto bail;
     }
-    if (KdRegisterFd (MsInputType, port, MsRead, (void *) 0))
+    if (KdRegisterFd (port, MsRead, pi))
-	return 1;
+	return TRUE;
+    pi->driverPrivate = (void *)port;
+
+    return Success;
 
  bail:
     close(port);
-    return 0;
+    return BadMatch;
 }
 
 static void
-MsFini (void)
+MsDisable (KdPointerInfo *pi)
 {
-    KdUnregisterFds (MsInputType, TRUE);
+    KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
 }
 
-KdMouseFuncs MsMouseFuncs = {
+static void
+MsFini (KdPointerInfo *pi)
+{
+}
+
+KdPointerDriver MsMouseDriver = {
+    "ms",
     MsInit,
-    MsFini
+    MsEnable,
+    MsDisable,
+    MsFini,
+    NULL,
 };

hw/kdrive/linux/ps2.c

@@ -112,42 +112,78 @@ Ps2Read (int ps2Port, void *closure)
 	    dy = -dy;
 	    n -= 3;
 	    b += 3;
-	    KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
+	    KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
 	}
     }
 }
 
-int Ps2InputType;
+static Status
-
+Ps2Init (KdPointerInfo *pi)
-static int
-Ps2Init (void)
 {
-    int	    i;
+    int	ps2Port, i;
-    int	    ps2Port;
-    int	    n;
 
-    if (!Ps2InputType)
+    if (!pi->path) {
-	Ps2InputType = KdAllocInputType ();
+        for (i = 0; i < NUM_PS2_NAMES; i++) {
-    n = 0;
+            ps2Port = open (Ps2Names[i], 0);
-    for (i = 0; i < NUM_PS2_NAMES; i++)
+            if (ps2Port >= 0) {
-    {
+                pi->path = KdSaveString (Ps2Names[i]);
-	ps2Port = open (Ps2Names[i], 0);
+                break;
-	if (ps2Port >= 0)
+            }
-	{
-	    if (KdRegisterFd (Ps2InputType, ps2Port, Ps2Read, (void *) i))
-		n++;
 	}
     }
-    return n;
+    else {
+        ps2Port = open (pi->path, 0);
+    }
+
+    if (ps2Port < 0)
+        return BadMatch;
+
+    close(ps2Port);
+    if (!pi->name)
+        pi->name = KdSaveString ("PS/2 Mouse");
+
+    return Success;
+}
+
+static Status
+Ps2Enable (KdPointerInfo *pi)
+{
+    int fd;
+    
+    if (!pi)
+        return BadImplementation;
+
+    fd = open (pi->path, 0);
+    if (fd < 0)
+        return BadMatch;
+
+    if (!KdRegisterFd (fd, Ps2Read, pi)) {
+        close(fd);
+        return BadAlloc;
+    }
+
+    pi->driverPrivate = (void *)fd;
+
+    return Success;
+}
+
+
+static void
+Ps2Disable (KdPointerInfo *pi)
+{
+    KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
 }
 
 static void
-Ps2Fini (void)
+Ps2Fini (KdPointerInfo *pi)
 {
-    KdUnregisterFds (Ps2InputType, TRUE);
 }
 
-KdMouseFuncs Ps2MouseFuncs = {
+KdPointerDriver Ps2MouseDriver = {
+    "ps2",
     Ps2Init,
-    Ps2Fini
+    Ps2Enable,
+    Ps2Disable,
+    Ps2Fini,
+    NULL,
 };

hw/kdrive/linux/ts.c

@@ -75,7 +75,7 @@ TsReadBytes (int fd, char *buf, int len, int min)
 static void
 TsRead (int tsPort, void *closure)
 {
-    KdMouseInfo	    *mi = closure;
+    KdPointerInfo    *pi = closure;
     TS_EVENT	    event;
     int		    n;
     long	    x, y;
@@ -117,7 +117,7 @@ TsRead (int tsPort, void *closure)
 	    lastx = 0;
 	    lasty = 0;
 	}
-	KdEnqueueMouseEvent (mi, flags, x, y);
+	KdEnqueuePointerEvent (pi, flags, x, y, 0);
     }
 }
 
@@ -129,95 +129,83 @@ char	*TsNames[] = {
 
 #define NUM_TS_NAMES	(sizeof (TsNames) / sizeof (TsNames[0]))
 
-int TsInputType;
+static Status
-
+TsInit (KdPointerInfo *pi)
-static int
-TsEnable (int fd, void *closure)
-{
-    KdMouseInfo *mi = (KdMouseInfo *)closure;
-
-    return open (mi->name, 0);
-}
-
-static void
-TsDisable (int fd, void *closure)
-{
-    close (fd);
-}
-
-static int
-TsInit (void)
 {
     int		i;
     int		fd;
-    KdMouseInfo	*mi, *next;
     int		n = 0;
 
-    if (!TsInputType)
+    if (!pi->path || strcmp(pi->path, "auto") == 0) {
-	TsInputType = KdAllocInputType ();
+        for (i = 0; i < NUM_TS_NAMES; i++)    {
-    
+            fd = open (TsNames[i], 0);
-    for (mi = kdMouseInfo; mi; mi = next)
+            if (fd >= 0) {
-    {
+                pi->path = KdSaveString (TsNames[i]);
-	next = mi->next;
+                break;
-	if (mi->inputType)
+            }
-	    continue;
-	if (!mi->name)
-	{
-	    for (i = 0; i < NUM_TS_NAMES; i++)    
-	    {
-		fd = open (TsNames[i], 0);
-		if (fd >= 0) 
-		{
-		    mi->name = KdSaveString (TsNames[i]);
-		    break;
-		}
-	    }
-	}
-	else
-	    fd = open (mi->name, 0);
-	if (fd >= 0)
-	{
-	    struct h3600_ts_calibration cal;
-	    /*
-	     * Check to see if this is a touch screen
-	     */
-	    if (ioctl (fd, TS_GET_CAL, &cal) != -1)
-	    {
-		mi->driver = (void *) fd;
-		mi->inputType = TsInputType;
-		if (KdRegisterFd (TsInputType, fd, TsRead, (void *) mi))
-		{
-		    /* Set callbacks for vt switches etc */
-		    KdRegisterFdEnableDisable (fd, TsEnable, TsDisable);
-
-		    n++;
-		}
-	    }
-	    else
-		close (fd);
 	}
     }
+    else {
+        fd = open (pi->path, 0);
+    }
 
-    return 0;
+    if (fd < 0) {
+        ErrorF("TsInit: Couldn't open %s\n", pi->path);
+        return BadMatch;
+    }
+    close(fd);
+
+    pi->name = KdSaveString("H3600 Touchscreen");
+
+    return Success;
+}
+
+static Status
+TsEnable (KdPointerInfo *pi)
+{
+    int fd;
+
+    if (!pi || !pi->path)
+        return BadImplementation;
+
+    fd = open(pi->path, 0);
+
+    if (fd < 0) {
+        ErrorF("TsInit: Couldn't open %s\n", pi->path);
+        return BadMatch;
+    }
+
+    struct h3600_ts_calibration cal;
+    /*
+     * Check to see if this is a touch screen
+     */
+    if (ioctl (fd, TS_GET_CAL, &cal) != -1) {
+	mi->driverPrivate = (void *) fd;
+	if (!KdRegisterFd (fd, TsRead, (void *) mi)) {
+            close(fd);
+            return BadAlloc;
+	}
+    }
+    else {
+        ErrorF("TsEnable: %s is not a touchscreen\n", pi->path);
+	close (fd);
+        return BadMatch;
+    }
+
+    return Success;
 }
 
 static void
-TsFini (void)
+TsFini (KdPointerInfo *pi)
 {
-    KdMouseInfo	*mi;
+    KdUnregisterFds (pi, (int)pi->driverPrivate, TRUE);
-
+    mi->driverPrivate = NULL;
-    KdUnregisterFds (TsInputType, TRUE);
-    for (mi = kdMouseInfo; mi; mi = mi->next)
-    {
-	if (mi->inputType == TsInputType)
-	{
-	    mi->driver = 0;
-	    mi->inputType = 0;
-	}
-    }
 }
 
-KdMouseFuncs TsFuncs = {
+KdPointerDriver TsDriver = {
     TsInit,
-    TsFini
+    TsEnable,
+    TsDisable,
+    TsFini,
+    NULL,
 };

hw/kdrive/linux/tslib.c

@@ -1,6 +1,6 @@
 /*
- * $RCSId: xc/programs/Xserver/hw/kdrive/linux/tslib.c,v 1.1 2002/11/01 22:27:49 keithp Exp $
+ * TSLIB based touchscreen driver for KDrive
- * TSLIB based touchscreen driver for TinyX
+ * Porting to new input API and event queueing by Daniel Stone.
  * Derived from ts.c by Keith Packard
  * Derived from ps2.c by Jim Gettys
  *
@@ -8,66 +8,33 @@
  * Copyright © 2000 Compaq Computer Corporation
  * Copyright © 2002 MontaVista Software Inc.
  * Copyright © 2005 OpenedHand Ltd.
+ * Copyright © 2006 Nokia Corporation
  * 
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard or Compaq not be used in
+ * documentation, and that the name of the authors and/or copyright holders
- * advertising or publicity pertaining to distribution of the software without
+ * not be used in advertising or publicity pertaining to distribution of the
- * specific, written prior permission.  Keith Packard and Compaq makes no
+ * software without specific, written prior permission.  The authors and/or
- * representations about the suitability of this software for any purpose.  It
+ * copyright holders make no representations about the suitability of this
- * is provided "as is" without express or implied warranty.
+ * software for any purpose.  It is provided "as is" without express or
+ * implied warranty.
  *
- * KEITH PACKARD AND COMPAQ DISCLAIM ALL WARRANTIES WITH REGARD TO THIS 
+ * THE AUTHORS AND/OR COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, 
+ * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- * IN NO EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * AND FITNESS, IN NO EVENT SHALL THE AUTHORS AND/OR COPYRIGHT HOLDERS BE
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * PERFORMANCE OF THIS SOFTWARE.
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- * 
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Michael Taht or MontaVista not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Michael Taht and Montavista make no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * MICHAEL TAHT AND MONTAVISTA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS 
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, 
- * IN NO EVENT SHALL EITHER BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Matthew Allum or OpenedHand not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Matthew Allum and OpenedHand make no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * MATTHEW ALLUM AND OPENEDHAND DISCLAIM ALL WARRANTIES WITH REGARD TO THIS 
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, 
- * IN NO EVENT SHALL EITHER BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
  */
 
 
-#ifdef HAVE_CONFIG_H
+#ifdef HAVE_KDRIVE_CONFIG_H
 #include <kdrive-config.h>
 #endif
+
 #define NEED_EVENTS
 #include <X11/X.h>
 #include <X11/Xproto.h>
@@ -77,186 +44,171 @@
 #include "kdrive.h"
 #include <sys/ioctl.h>
 #include <tslib.h>
+#include <dirent.h>
+#include <linux/input.h>
 
-static struct tsdev *tsDev = NULL;
+struct TslibPrivate {
-
+    int fd;
-static char *TsNames[] = {
+    int lastx, lasty;
-  NULL, 			/* set via TSLIB_TSDEVICE */
+    struct tsdev *tsDev;
-  "/dev/ts",	
+    void (*raw_event_hook)(int x, int y, int pressure, void *closure);
-  "/dev/touchscreen/0",
+    void *raw_event_closure;
+    int phys_screen;
 };
 
-#define NUM_TS_NAMES (sizeof (TsNames) / sizeof (TsNames[0]))
-
-/* For XCalibrate extension */
-void (*tslib_raw_event_hook)(int x, int y, int pressure, void *closure);
-void *tslib_raw_event_closure;
-
-int TsInputType = 0;
-int KdTsPhyScreen = 0; 		/* XXX Togo .. */
 
 static void
-TsRead (int tsPort, void *closure)
+TsRead (int fd, void *closure)
 {
-    KdMouseInfo	    *mi = closure;
+    KdPointerInfo       *pi = closure;
-    struct ts_sample event;
+    struct TslibPrivate *private = pi->driverPrivate;
-    long	    x, y;
+    struct ts_sample    event;
-    unsigned long   flags;
+    long                x = 0, y = 0;
+    unsigned long       flags;
 
-    if (tslib_raw_event_hook)
+    if (private->raw_event_hook) {
-      {
+        while (ts_read_raw(private->tsDev, &event, 1) == 1)
-	/* XCalibrate Ext */
+            private->raw_event_hook (event.x, event.y, event.pressure,
-	if (ts_read_raw(tsDev, &event, 1) == 1)
+                                     private->raw_event_closure);
-	  {
+        return;
-	    tslib_raw_event_hook (event.x, 
-				  event.y, 
-				  event.pressure, 
-				  tslib_raw_event_closure);
-	  }
-	return;
-      }
-
-    while (ts_read(tsDev, &event, 1) == 1)
-      {
-	flags = (event.pressure) ? KD_BUTTON_1 : 0;
-	x = event.x;
-	y = event.y;
-	
-	KdEnqueueMouseEvent (mi, flags, x, y);
-      }
-}
-
-static int
-TsLibOpen(char *dev)
-{
-  if(!(tsDev = ts_open(dev, 0)))
-    return -1;
-
-  if (ts_config(tsDev))
-    return -1;
-
-  return ts_fd(tsDev);
-}
-
-static int
-TslibEnable (int not_needed_fd, void *closure)
-{
-  KdMouseInfo	    *mi = closure;
-  int		     fd = 0;
-
-  if ((fd = TsLibOpen(mi->name)) == -1)
-    ErrorF ("Unable to re-enable TSLib ( on %s )", mi->name);
-
-  return fd;
-}
-
-static void
-TslibDisable (int fd, void *closure)
-{
-  if (tsDev)
-    ts_close(tsDev);
-  tsDev = NULL;
-}
-
-static int
-TslibInit (void)
-{
-  int		i, j = 0;
-  KdMouseInfo	*mi, *next;
-  int		fd = 0;
-  int           req_type;
-
-  if (!TsInputType)
-    {
-      TsInputType = KdAllocInputType ();
-      KdParseMouse(0); /* allocate safe slot in kdMouseInfo */
-      req_type = 0;
     }
-  else req_type = TsInputType; 	/* is being re-inited */
-  
-  for (mi = kdMouseInfo; mi; mi = next)
-    {
-      next = mi->next;
-      
-      /* find a usuable slot */
-      if (mi->inputType != req_type) 
-	continue;
-      
-      /* Check for tslib env var device setting */
-      if ((TsNames[0] = getenv("TSLIB_TSDEVICE")) == NULL)
-	j++;
-      
-      if (!mi->name)
-	{
-	  for (i = j; i < NUM_TS_NAMES; i++)    
-	    {
-	      fd = TsLibOpen(TsNames[i]);
-	      
-	      if (fd >= 0) 
-		{
-		  mi->name = KdSaveString (TsNames[i]);
-		  break;
-		}
-	    }
-	} 
-      else 
-	fd = TsLibOpen(mi->name);
-      
-      if (fd >= 0 && tsDev != NULL) 
-	{
-	  mi->driver    = (void *) fd;
-	  mi->inputType = TsInputType;
-	  
-	  KdRegisterFd (TsInputType, fd, TsRead, (void *) mi);
-	  
-	  /* Set callbacks for vt switches etc */
-	  KdRegisterFdEnableDisable (fd, TslibEnable, TslibDisable);
-	  
-	  return TRUE;
-	} 
-    }
-  
-  ErrorF ("Failed to open TSLib device, tried ");
-  for (i = j; i < NUM_TS_NAMES; i++)    
-    ErrorF ("%s ", TsNames[i]);
-  ErrorF (".\n");
-  if (!TsNames[0]) 
-    ErrorF ("Try setting TSLIB_TSDEVICE to valid /dev entry?\n");
-  
-  if (fd > 0) 
-    close(fd);
-  
-  return FALSE;
-}
 
-static void
+    while (ts_read(private->tsDev, &event, 1) == 1) {
-TslibFini (void)
+#ifdef DEBUG
-{
+        ErrorF("[tslib] originally from (%d, %d)\n", event.x, event.y);
-    KdMouseInfo	*mi;
+#endif
+        if (event.pressure) {
+            if (event.pressure > pi->dixdev->touchscreen->button_threshold) 
+                flags = KD_BUTTON_8;
+            else
+                flags = KD_BUTTON_1;
 
-    KdUnregisterFds (TsInputType, TRUE);
+            /* 
-    for (mi = kdMouseInfo; mi; mi = mi->next)
+             * Here we test for the touch screen driver actually being on the
-    {
+             * touch screen, if it is we send absolute coordinates. If not,
-	if (mi->inputType == TsInputType)
+             * then we send delta's so that we can track the entire vga screen.
-	{
+             */
-	    if(mi->driver) 
+            if (KdCurScreen == private->phys_screen) {
-	      {
+                x = event.x;
-		ts_close(tsDev);
+                y = event.y;
-		tsDev = NULL;
+            } else {
-	      }
+                flags |= KD_MOUSE_DELTA;
-	    mi->driver    = 0;
+                if ((private->lastx == 0) || (private->lasty == 0)) {
+                    x = event.x;
+                    y = event.y;
+                } else {
+                    x = event.x - private->lastx;
+                    y = event.y - private->lasty;
+	    	}
+            }
+            private->lastx = x;
+            private->lasty = y;
+        } else {
+            flags = 0;
+            x = private->lastx;
+            y = private->lasty;
+        }
 
-	    /* If below is set to 0, then MouseInit() will trash it,
+#ifdef DEBUG
-	     * setting to 'mouse type' ( via server reset). Therefore 
+        ErrorF("event at (%lu, %lu), pressure is %d, sending flags %lu\n", x, y, event.pressure, flags);
-             * Leave it alone and work around in TslibInit()  ( see
+#endif
-             * req_type ).
+        KdEnqueuePointerEvent (pi, flags, x, y, event.pressure);
-	    */
-	    /* mi->inputType = 0; */
-	}
     }
 }
 
-KdMouseFuncs TsFuncs = {
+static Status
+TslibEnable (KdPointerInfo *pi)
+{
+  struct TslibPrivate *private = pi->driverPrivate;
+
+    private->holdThumbEvents = 1;
+    private->raw_event_hook = NULL;
+    private->raw_event_closure = NULL;
+    private->tsDev = ts_open(pi->path, 0);
+    private->fd = ts_fd(private->tsDev);
+    if (!private->tsDev || ts_config(private->tsDev) || private->fd < 0) {
+        ErrorF("[tslib/TslibEnable] failed to open %s\n", pi->path);
+        if (private->fd > 0);
+            close(private->fd);
+        return BadAlloc;
+    }
+    if (pi->dixdev && pi->dixdev->touchscreen &&
+        pi->dixdev->touchscreen->button_threshold == 0)
+        pi->dixdev->touchscreen->button_threshold = 115;
+
+#ifdef DEBUG
+    ErrorF("[tslib/TslibEnable] successfully enabled %s\n", pi->path);
+#endif
+
+    KdRegisterFd(private->fd, TsRead, pi);
+  
+    return Success;
+}
+
+
+static void
+TslibDisable (KdPointerInfo *pi)
+{
+    struct TslibPrivate *private = pi->driverPrivate;
+
+    if (private->fd) {
+        KdUnregisterFd(pi, private->fd);
+        close(private->fd);
+    }
+    if (private->tsDev)
+        ts_close(private->tsDev);
+    private->fd = 0;
+    private->tsDev = NULL;
+}
+
+
+static Status
+TslibInit (KdPointerInfo *pi)
+{
+    int		        fd = 0, i = 0;
+    char                devpath[PATH_MAX], devname[TS_NAME_SIZE];
+    DIR                 *inputdir = NULL;
+    struct dirent       *inputent = NULL;
+    struct tsdev        *tsDev = NULL;
+    struct TslibPrivate *private = NULL;
+
+    if (!pi || !pi->dixdev)
+        return !Success;
+    
+    pi->driverPrivate = (struct TslibPrivate *)
+                        xcalloc(sizeof(struct TslibPrivate), 1);
+    if (!pi->driverPrivate)
+        return !Success;
+
+    private = pi->driverPrivate;
+    /* hacktastic */
+    private->phys_screen = 0;
+    pi->nAxes = 3;
+    pi->name = KdSaveString("Touchscreen");
+    pi->inputClass = KD_TOUCHSCREEN;
+#ifdef DEBUG
+    ErrorF("[tslib/TslibInit] successfully inited for device %s\n", pi->path);
+#endif
+
+    return Success;
+}
+
+
+static void
+TslibFini (KdPointerInfo *pi)
+{
+    if (pi->driverPrivate) {
+        xfree(pi->driverPrivate);
+        pi->driverPrivate = NULL;
+    }
+}
+
+
+KdPointerDriver TsDriver = {
+    "tslib",
     TslibInit,
-    TslibFini
+    TslibEnable,
+    TslibDisable,
+    TslibFini,
+    NULL,
 };

hw/kdrive/mach64/Makefile.am

@@ -30,8 +30,4 @@ MACH64_LIBS =						\
 Xmach64_LDADD = 					\
 	$(MACH64_LIBS)					\
 	@KDRIVE_LIBS@					\
-	@XSERVER_LIBS@					\
+	@XSERVER_LIBS@
-	$(TSLIB_FLAG)
-
-
-Xmach64_DEPENDENCIES = $(MACH64_LIBS)

hw/kdrive/mga/Makefile.am

@@ -7,10 +7,6 @@ bin_PROGRAMS = Xmga
 
 noinst_LIBRARIES = libmga.a
 
-if TSLIB
-TSLIB_FLAG = -lts
-endif
-
 libmga_a_SOURCES = 		\
 	mgadraw.c		\
 	g400_composite.c	\
@@ -29,9 +25,4 @@ MGA_LIBS =						\
 Xmga_LDADD = \
 	$(MGA_LIBS)					\
 	@KDRIVE_LIBS@                                  \
-	@XSERVER_LIBS@					\
+	@XSERVER_LIBS@
-	$(TSLIB_FLAG)
-
-Xmga_DEPENDENCIES = 					\
-	libmga.a 					\
-	$(top_builddir)/hw/kdrive/vesa/libvesa.a	

hw/kdrive/neomagic/Makefile.am

@@ -38,9 +38,3 @@ Xneomagic_LDADD = \
 	$(NEOMAGIC_LIBS)            \
 	@KDRIVE_LIBS@               \
 	@XSERVER_LIBS@		  
-
-
-Xneomagic_DEPENDENCIES =                 \
-	libneomagic.a               \
-	${FBDEV_LIBS}               \
-	${VESA_LIBS}                

hw/kdrive/nvidia/Makefile.am

@@ -7,10 +7,6 @@ bin_PROGRAMS = Xnvidia
 
 noinst_LIBRARIES = libnvidia.a
 
-if TSLIB
-TSLIB_FLAG = -lts
-endif
-
 #	nvidiavideo.c
 
 libnvidia_a_SOURCES = 	\
@@ -31,7 +27,3 @@ Xnvidia_LDADD = \
 	$(NVIDIA_LIBS)				\
 	@KDRIVE_LIBS@				\
 	@XSERVER_LIBS@			
-
-Xnvidia_DEPENDENCIES = 				\
-	libnvidia.a 				\
-	$(top_builddir)/hw/kdrive/vesa/libvesa.a 

hw/kdrive/pm2/Makefile.am

@@ -25,8 +25,3 @@ Xpm2_LDADD = \
 	$(PM2_LIBS)				\
 	@KDRIVE_LIBS@                          \
 	@XSERVER_LIBS@			
-
-
-Xpm2_DEPENDENCIES = 				\
-	libpm2.a 				\
-	$(top_builddir)/hw/kdrive/vesa/libvesa.a 

hw/kdrive/r128/Makefile.am

@@ -24,8 +24,3 @@ Xr128_LDADD = \
 	$(R128_LIBS)				\
 	@KDRIVE_LIBS@                          \
 	@XSERVER_LIBS@					
-
-
-Xr128_DEPENDENCIES = 				\
-	libr128.a 				\
-	$(top_builddir)/hw/kdrive/vesa/libvesa.a

hw/kdrive/sdl/Makefile.am

@@ -5,14 +5,9 @@ INCLUDES = 					\
 
 bin_PROGRAMS = Xsdl
 
-if TSLIB
-TSLIB_FLAG = -lts
-endif
-
 Xsdl_SOURCES = sdl.c
 
 Xsdl_LDADD = @KDRIVE_PURE_LIBS@				\
 	@KDRIVE_LIBS@                                  \
 	@XSERVER_LIBS@					\
-	$(TSLIB_FLAG)					\
 	@XSDL_LIBS@

hw/kdrive/sis300/Makefile.am

@@ -17,10 +17,6 @@ INCLUDES = 					\
 
 bin_PROGRAMS = Xsis
 
-if TSLIB
-TSLIB_FLAG = -lts
-endif
-
 noinst_LIBRARIES = libsis.a
 
 libsis_a_SOURCES = 	\
@@ -42,5 +38,3 @@ Xsis_LDADD = \
 	$(SIS_LIBS)				\
 	@KDRIVE_LIBS@                          \
 	$(TSLIB_FLAG)
-
-Xsis_DEPENDENCIES = $(SIS_LIBS)

hw/kdrive/smi/Makefile.am

@@ -29,9 +29,3 @@ Xsmi_LDADD = \
 	$(SMI_LIBS)				\
 	@KDRIVE_LIBS@                          \
 	@XSERVER_LIBS@					
-
-
-Xsmi_DEPENDENCIES = 				\
-	libsmi.a 				\
-	$(top_builddir)/hw/kdrive/fbdev/libfbdev.a \
-	$(top_builddir)/hw/kdrive/vesa/libvesa.a

hw/kdrive/src/Makefile.am

@@ -24,7 +24,7 @@ libkdrive_a_SOURCES =	\
 	kdrive.h	\
 	kinfo.c		\
 	kinput.c	\
-	kkeymap.h	\
+	kkeymap.c	\
 	kmap.c		\
 	kmode.c		\
 	knoop.c		\
@@ -37,5 +37,4 @@ libkdrive_a_SOURCES =	\
         $(top_srcdir)/mi/miinitext.c
 
 libkdrivestubs_a_SOURCES = \
-        $(top_srcdir)/Xi/stubs.c \
         $(top_srcdir)/fb/fbcmap.c

hw/kdrive/src/kdrive.c

@@ -43,6 +43,12 @@
 #include "dpmsproc.h"
 #endif
 
+#ifdef HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+
+#include <signal.h>
+
 typedef struct _kdDepths {
     CARD8   depth;
     CARD8   bpp;
@@ -60,6 +66,8 @@ KdDepths    kdDepths[] = {
 
 #define NUM_KD_DEPTHS (sizeof (kdDepths) / sizeof (kdDepths[0]))
 
+#define KD_DEFAULT_BUTTONS 5
+
 int                 kdScreenPrivateIndex;
 unsigned long       kdGeneration;
 
@@ -76,6 +84,8 @@ Bool		    kdSwitchPending;
 char		    *kdSwitchCmd;
 DDXPointRec	    kdOrigin;
 
+static Bool         kdCaughtSignal = FALSE;
+
 /*
  * Carry arguments from InitOutput through driver initialization
  * to KdScreenInit
@@ -368,6 +378,9 @@ AbortDDX(void)
 	(*kdOsFuncs->Fini) ();
 	KdDoSwitchCmd ("stop");
     }
+
+    if (kdCaughtSignal)
+        abort();
 }
 
 void
@@ -379,7 +392,7 @@ ddxGiveUp ()
 Bool	kdDumbDriver;
 Bool	kdSoftCursor;
 
-static char *
+char *
 KdParseFindNext (char *cur, char *delim, char *save, char *last)
 {
     while (*cur && !strchr (delim, *cur))
@@ -560,97 +573,6 @@ KdSaveString (char *str)
     return n;
 }
 
-/*
- * Parse mouse information.  Syntax:
- *
- *  <device>,<nbutton>,<protocol>{,<option>}...
- *
- * options: {nmo}   pointer mapping (e.g. {321})
- *	    2button emulate middle button
- *	    3button dont emulate middle button
- */
-
-void
-KdParseMouse (char *arg)
-{
-    char	save[1024];
-    char	delim;
-    KdMouseInfo	*mi;
-    int		i;
-    
-    mi = KdMouseInfoAdd ();
-    if (!mi)
-	return;
-    mi->name = 0;
-    mi->prot = 0;
-    mi->emulateMiddleButton = kdEmulateMiddleButton;
-    mi->transformCoordinates = !kdRawPointerCoordinates;
-    mi->nbutton = 3;
-    for (i = 0; i < KD_MAX_BUTTON; i++)
-	mi->map[i] = i + 1;
-    
-    if (!arg)
-	return;
-    if (strlen (arg) >= sizeof (save))
-	return;
-    arg = KdParseFindNext (arg, ",", save, &delim);
-    if (!save[0])
-	return;
-    mi->name = KdSaveString (save);
-    if (delim != ',')
-	return;
-    
-    arg = KdParseFindNext (arg, ",", save, &delim);
-    if (!save[0])
-	return;
-    
-    if ('1' <= save[0] && save[0] <= '0' + KD_MAX_BUTTON && save[1] == '\0')
-    {
-        mi->nbutton = save[0] - '0';
-	if (mi->nbutton > KD_MAX_BUTTON)
-	{
-	    UseMsg ();
-	    return;
-	}
-    }
-    
-    if (!delim != ',')
-	return;
-    
-    arg = KdParseFindNext (arg, ",", save, &delim);
-    
-    if (save[0])
-	mi->prot = KdSaveString (save);
-    
-    while (delim == ',')
-    {
-	arg = KdParseFindNext (arg, ",", save, &delim);
-	if (save[0] == '{')
-	{
-	    char	*s = save + 1;
-	    i = 0;
-	    while (*s && *s != '}')
-	    {
-		if ('1' <= *s && *s <= '0' + mi->nbutton)
-		    mi->map[i] = *s - '0';
-		else
-		    UseMsg ();
-		s++;
-	    }
-	}
-	else if (!strcmp (save, "2button"))
-	    mi->emulateMiddleButton = TRUE;
-	else if (!strcmp (save, "3button"))
-	    mi->emulateMiddleButton = FALSE;
-	else if (!strcmp (save, "rawcoord"))
-	    mi->transformCoordinates = FALSE;
-	else if (!strcmp (save, "transform"))
-	    mi->transformCoordinates = TRUE;
-	else
-	    UseMsg ();
-    }
-}
-
 void
 KdParseRgba (char *rgba)
 {
@@ -697,6 +619,8 @@ KdProcessArgument (int argc, char **argv, int i)
 {
     KdCardInfo	    *card;
     KdScreenInfo    *screen;
+    KdPointerInfo   *pi;
+    KdKeyboardInfo  *ki;
 
     if (!strcmp (argv[i], "-card"))
     {
@@ -736,6 +660,11 @@ KdProcessArgument (int argc, char **argv, int i)
 	kdDontZap = TRUE;
 	return 1;
     }
+    if (!strcmp (argv[i], "-nozap"))
+    {
+	kdDontZap = TRUE;
+	return 1;
+    }
     if (!strcmp (argv[i], "-3button"))
     {
 	kdEmulateMiddleButton = FALSE;
@@ -785,14 +714,6 @@ KdProcessArgument (int argc, char **argv, int i)
 	    UseMsg ();
 	return 2;
     }
-    if (!strcmp (argv[i], "-mouse"))
-    {
-	if ((i+1) < argc)
-	    KdParseMouse (argv[i+1]);
-	else
-	    UseMsg ();
-	return 2;
-    }
     if (!strcmp (argv[i], "-rgba"))
     {
 	if ((i+1) < argc)
@@ -814,6 +735,20 @@ KdProcessArgument (int argc, char **argv, int i)
     {
 	return 1;
     }
+    if (!strcmp (argv[i], "-mouse") ||
+        !strcmp (argv[i], "-pointer")) {
+        if (i + 1 >= argc)
+            UseMsg();
+        KdAddConfigPointer(argv[i + 1]);
+        return 2;
+    }
+    if (!strcmp (argv[i], "-keybd")) {
+        if (i + 1 >= argc)
+            UseMsg();
+        KdAddConfigKeyboard(argv[i + 1]);
+        return 2;
+    }
+
 #ifdef PSEUDO8
     return p8ProcessArgument (argc, argv, i);
 #else
@@ -1420,6 +1355,39 @@ KdDepthToFb (ScreenPtr	pScreen, int depth)
 
 #endif
 
+#ifdef HAVE_BACKTRACE
+/* shamelessly ripped from xf86Events.c */
+void
+KdBacktrace (int signum)
+{
+    void *array[32]; /* more than 32 and you have bigger problems */
+    size_t size, i;
+    char **strings;
+
+    signal(signum, SIG_IGN);
+
+    size = backtrace (array, 32);
+    fprintf (stderr, "\nBacktrace (%d deep):\n", size);
+    strings = backtrace_symbols (array, size);
+    for (i = 0; i < size; i++)
+        fprintf (stderr, "%d: %s\n", i, strings[i]);
+    free (strings);
+    
+    kdCaughtSignal = TRUE;    
+    if (signum == SIGSEGV)
+        FatalError("Segmentation fault caught\n");
+    else if (signum > 0)
+        FatalError("Signal %d caught\n", signum);
+}
+#else
+void
+KdBacktrace (int signum)
+{
+    kdCaughtSignal = TRUE;
+    FatalError("Segmentation fault caught\n");
+}
+#endif
+
 void
 KdInitOutput (ScreenInfo    *pScreenInfo,
 	      int	    argc,
@@ -1427,6 +1395,12 @@ KdInitOutput (ScreenInfo    *pScreenInfo,
 {
     KdCardInfo	    *card;
     KdScreenInfo    *screen;
+
+#ifdef COMPOSITE
+    /* kind of a hack: we want Composite enabled, but it's disabled per
+     * default. */
+    noCompositeExtension = FALSE;
+#endif
     
     if (!kdCardInfo)
     {
@@ -1464,6 +1438,8 @@ KdInitOutput (ScreenInfo    *pScreenInfo,
     for (card = kdCardInfo; card; card = card->next)
 	for (screen = card->screenList; screen; screen = screen->next)
 	    KdAddScreen (pScreenInfo, screen, argc, argv);
+
+    signal(SIGSEGV, KdBacktrace);
 }
 
 #ifdef DPMSExtension

hw/kdrive/src/kdrive.h

@@ -47,6 +47,10 @@
 #include "shadow.h"
 #include "randrstr.h"
 
+#ifdef XKB
+#include <X11/extensions/XKBstr.h>
+#endif
+
 extern WindowPtr    *WindowTable;
 
 #define KD_DPMS_NORMAL	    0
@@ -63,6 +67,8 @@ extern WindowPtr    *WindowTable;
 #define KD_MAX_CARD_ADDRESS 8
 #endif
 
+#define Status int
+
 /*
  * Configuration information per video card
  */
@@ -215,7 +221,7 @@ typedef struct {
 #endif
 } KdPrivScreenRec, *KdPrivScreenPtr;
 
-typedef enum _kdMouseState {
+typedef enum _kdPointerState {
     start,
     button_1_pend,
     button_1_down,
@@ -226,51 +232,135 @@ typedef enum _kdMouseState {
     synth_2_down_3,
     synth_2_down_1,
     num_input_states
-} KdMouseState;
+} KdPointerState;
 
-#define KD_MAX_BUTTON  7
+#define KD_MAX_BUTTON  32
 
-typedef struct _KdMouseInfo {
+#define KD_KEYBOARD 1
-    struct _KdMouseInfo	*next;
+#define KD_MOUSE 2
-    void		*driver;
+#define KD_TOUCHSCREEN 3
-    void		*closure;
-    char		*name;
-    char		*prot;
-    char		map[KD_MAX_BUTTON];
-    int			nbutton;
-    Bool		emulateMiddleButton;
-    unsigned long	emulationTimeout;
-    Bool		timeoutPending;
-    KdMouseState	mouseState;
-    Bool		eventHeld;
-    xEvent		heldEvent;
-    unsigned char	buttonState;
-    int			emulationDx, emulationDy;
-    int			inputType;
-    Bool		transformCoordinates;
-} KdMouseInfo;
 
-extern KdMouseInfo	*kdMouseInfo;
+typedef struct _KdPointerInfo KdPointerInfo;
+
+typedef struct _KdPointerDriver {
+    char                    *name;
+    Status                  (*Init)    (KdPointerInfo *);
+    Status                  (*Enable)  (KdPointerInfo *);
+    void                    (*Disable) (KdPointerInfo *);
+    void                    (*Fini)    (KdPointerInfo *);
+    struct _KdPointerDriver *next;
+} KdPointerDriver;
+
+struct _KdPointerInfo {
+    DeviceIntPtr          dixdev;
+    char                  *name;
+    char                  *path;
+    InputOption           *options;
+    int                   inputClass;
+
+    CARD8                 map[KD_MAX_BUTTON + 1];
+    int                   nButtons;
+    int                   nAxes;
+
+    Bool                  emulateMiddleButton;
+    unsigned long         emulationTimeout;
+    int                   emulationDx, emulationDy;
+
+    Bool                  timeoutPending;
+    KdPointerState        mouseState;
+    Bool                  eventHeld;
+    struct {
+        int type;
+        int x;
+        int y;
+        int z;
+        int flags;
+        int absrel;
+    } heldEvent;         
+    unsigned char         buttonState;
+    Bool                  transformCoordinates;
+    int                   pressureThreshold;
+
+    KdPointerDriver       *driver;
+    void                  *driverPrivate;
+
+    struct _KdPointerInfo *next;
+};
 
 extern int KdCurScreen;
 
-KdMouseInfo *KdMouseInfoAdd (void);
+void KdAddPointerDriver (KdPointerDriver *driver);
-void	    KdMouseInfoDispose (KdMouseInfo *mi);
+void KdRemovePointerDriver (KdPointerDriver *driver);
-void	    KdParseMouse (char *);
+KdPointerInfo *KdNewPointer (void);
+void KdFreePointer (KdPointerInfo *);
+int KdAddPointer (KdPointerInfo *ki);
+int KdAddConfigPointer (char *pointer);
+void KdRemovePointer (KdPointerInfo *ki);
 
-typedef struct _KdMouseFuncs {
-    Bool    	    (*Init) (void);
-    void	    (*Fini) (void);
-} KdMouseFuncs;
 
-typedef struct _KdKeyboardFuncs {
+#define KD_KEY_COUNT 248
-    void	    (*Load) (void);
+#define KD_MIN_KEYCODE  8
-    int		    (*Init) (void);
+#define KD_MAX_KEYCODE  255
-    void	    (*Leds) (int);
+#define KD_MAX_WIDTH    4
-    void	    (*Bell) (int, int, int);
+#define KD_MAX_LENGTH   (KD_MAX_KEYCODE - KD_MIN_KEYCODE + 1)
-    void	    (*Fini) (void);
+
-    int		    LockLed;
+typedef struct {
-} KdKeyboardFuncs;
+    KeySym modsym;
+    int    modbit;
+} KdKeySymModsRec;
+
+extern const KeySym       kdDefaultKeymap[KD_MAX_LENGTH * KD_MAX_WIDTH];
+extern const int          kdDefaultKeymapWidth;
+extern const CARD8        kdDefaultModMap[MAP_LENGTH];
+extern const KeySymsRec   kdDefaultKeySyms;
+
+typedef struct _KdKeyboardInfo KdKeyboardInfo;
+
+typedef struct _KdKeyboardDriver {
+    char                  *name;
+    Bool                  (*Init)    (KdKeyboardInfo *);
+    Bool                  (*Enable)  (KdKeyboardInfo *);
+    void                  (*Leds)    (KdKeyboardInfo *, int);
+    void                  (*Bell)    (KdKeyboardInfo *, int, int, int);
+    void                  (*Disable) (KdKeyboardInfo *);
+    void                  (*Fini)    (KdKeyboardInfo *);
+    struct _KdKeyboardDriver *next;
+} KdKeyboardDriver;
+
+struct _KdKeyboardInfo {
+    struct _KdKeyboardInfo *next;
+    DeviceIntPtr        dixdev;
+    void                *closure;
+    char                *name;
+    char                *path;
+    int                 inputClass;
+#ifdef XKB
+    XkbDescPtr          xkb;
+#endif
+    int                 LockLed;
+
+    CARD8               keyState[KD_KEY_COUNT/8];
+    int                 minScanCode;
+    int                 maxScanCode;
+    CARD8               modmap[MAP_LENGTH];
+    KeySymsRec          keySyms; 
+
+    int                 leds;
+    int                 bellPitch;
+    int                 bellDuration;
+    InputOption         *options;
+
+    KdKeyboardDriver    *driver;
+    void                *driverPrivate;
+};
+
+void KdAddKeyboardDriver (KdKeyboardDriver *driver);
+void KdRemoveKeyboardDriver (KdKeyboardDriver *driver);
+KdKeyboardInfo *KdNewKeyboard (void);
+void KdFreeKeyboard (KdKeyboardInfo *ki);
+int KdAddConfigKeyboard (char *pointer);
+int KdAddKeyboard (KdKeyboardInfo *ki);
+void KdRemoveKeyboard (KdKeyboardInfo *ki);
 
 typedef struct _KdOsFuncs {
     int		    (*Init) (void);
@@ -307,9 +397,9 @@ typedef struct _KdMonitorTiming {
 extern const KdMonitorTiming	kdMonitorTimings[];
 extern const int		kdNumMonitorTimings;
 
-typedef struct _KdMouseMatrix {
+typedef struct _KdPointerMatrix {
     int	    matrix[2][3];
-} KdMouseMatrix;
+} KdPointerMatrix;
 
 typedef struct _KaaTrapezoid {
     float tl, tr, ty;
@@ -628,8 +718,14 @@ KdParseScreen (KdScreenInfo *screen,
 char *
 KdSaveString (char *str);
 
-void
+KdPointerInfo *
-KdParseMouse (char *arg);
+KdParsePointer (char *arg);
+
+KdKeyboardInfo *
+KdParseKeyboard (char *arg);
+
+char *
+KdParseFindNext (char *cur, char *delim, char *save, char *last);
 
 void
 KdParseRgba (char *rgba);
@@ -677,6 +773,9 @@ KdInitOutput (ScreenInfo    *pScreenInfo,
  
 void
 KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr);
+
+void
+KdBacktrace (int signum);
     
 /* kinfo.c */
 KdCardInfo *
@@ -699,53 +798,51 @@ KdScreenInfoDispose (KdScreenInfo *si);
 
 /* kinput.c */
 void
-KdInitInput(KdMouseFuncs *, KdKeyboardFuncs *);
+KdInitInput(void);
 
 void
-KdAddMouseDriver(KdMouseFuncs *);
+KdAddPointerDriver(KdPointerDriver *);
 
-int
+void
-KdAllocInputType (void);
+KdAddKeyboardDriver(KdKeyboardDriver *);
 
 Bool
-KdRegisterFd (int type, int fd, void (*read) (int fd, void *closure), void *closure);
+KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure);
 
 void
-KdRegisterFdEnableDisable (int fd, 
+KdUnregisterFds (void *closure, Bool do_close);
-			   int (*enable) (int fd, void *closure),
-			   void (*disable) (int fd, void *closure));
 
 void
-KdUnregisterFds (int type, Bool do_close);
+KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,
-
+                    unsigned char is_up);
-void
-KdEnqueueKeyboardEvent(unsigned char	scan_code,
-		       unsigned char	is_up);
 
 #define KD_BUTTON_1	0x01
 #define KD_BUTTON_2	0x02
 #define KD_BUTTON_3	0x04
 #define KD_BUTTON_4	0x08
 #define KD_BUTTON_5	0x10
+#define KD_BUTTON_8	0x80
 #define KD_MOUSE_DELTA	0x80000000
 
 void
-KdEnqueueMouseEvent(KdMouseInfo *mi, unsigned long flags, int x, int y);
+KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
+                      int rz);
 
 void
-KdEnqueueMotionEvent (KdMouseInfo *mi, int x, int y);
+_KdEnqueuePointerEvent(KdPointerInfo *pi, int type, int x, int y, int z,
+                       int b, int absrel, Bool force);
 
 void
 KdReleaseAllKeys (void);
     
 void
-KdSetLed (int led, Bool on);
+KdSetLed (KdKeyboardInfo *ki, int led, Bool on);
 
 void
-KdSetMouseMatrix (KdMouseMatrix *matrix);
+KdSetPointerMatrix (KdPointerMatrix *pointer);
 
 void
-KdComputeMouseMatrix (KdMouseMatrix *matrix, Rotation randr, int width, int height);
+KdComputePointerMatrix (KdPointerMatrix *pointer, Rotation randr, int width, int height);
     
 void
 KdBlockHandler (int		screen,
@@ -768,19 +865,17 @@ KdEnableInput (void);
 void
 ProcessInputEvents (void);
 
-extern KdMouseFuncs	LinuxMouseFuncs;
+extern KdPointerDriver	LinuxMouseDriver;
-extern KdMouseFuncs	LinuxEvdevFuncs;
+extern KdPointerDriver	LinuxEvdevDriver;
-extern KdMouseFuncs	Ps2MouseFuncs;
+extern KdPointerDriver	Ps2MouseDriver;
-extern KdMouseFuncs	BusMouseFuncs;
+extern KdPointerDriver	BusMouseDriver;
-extern KdMouseFuncs	MsMouseFuncs;
+extern KdPointerDriver	MsMouseDriver;
-#ifdef TOUCHSCREEN
+extern KdPointerDriver	TsDriver;
-extern KdMouseFuncs	TsFuncs;
+extern KdKeyboardDriver	LinuxKeyboardDriver;
-#endif
-extern KdKeyboardFuncs	LinuxKeyboardFuncs;
 extern KdOsFuncs	LinuxFuncs;
 
-extern KdMouseFuncs	VxWorksMouseFuncs;
+extern KdPointerDriver	VxWorksMouseDriver;
-extern KdKeyboardFuncs	VxWorksKeyboardFuncs;
+extern KdKeyboardDriver	VxWorksKeyboardDriver;
 extern KdOsFuncs	VxWorksFuncs;
 
 /* kmap.c */

hw/kdrive/src/kinfo.c

@@ -101,7 +101,7 @@ KdScreenInfoDispose (KdScreenInfo *si)
     KdCardInfo	    *ci = si->card;
     KdScreenInfo    **prev;
 
-    for (prev = &ci->screenList; *prev; prev = &(*prev)->next)
+    for (prev = &ci->screenList; *prev; prev = &(*prev)->next) {
 	if (*prev == si)
 	{
 	    *prev = si->next;
@@ -110,38 +110,67 @@ KdScreenInfoDispose (KdScreenInfo *si)
 		KdCardInfoDispose (ci);
 	    break;
 	}
+    }
 }
 
-KdMouseInfo *kdMouseInfo;
+KdPointerInfo *
-
+KdNewPointer (void)
-KdMouseInfo *
-KdMouseInfoAdd (void)
 {
-    KdMouseInfo	*mi, **prev;
+    KdPointerInfo *pi;
+    int i;
 
-    mi = (KdMouseInfo *) xalloc (sizeof (KdMouseInfo));
+    pi = (KdPointerInfo *)xcalloc(1, sizeof(KdPointerInfo));
-    if (!mi)
+    if (!pi)
-	return 0;
+        return NULL;
-    bzero (mi, sizeof (KdMouseInfo));
+
-    for (prev = &kdMouseInfo; *prev; prev = &(*prev)->next);
+    pi->name = KdSaveString("Generic Pointer");
-    *prev = mi;
+    pi->path = NULL;
-    return mi;
+    pi->inputClass = KD_MOUSE;
+    pi->driver = NULL;
+    pi->driverPrivate = NULL;
+    pi->next = NULL;
+    pi->options = NULL;
+    pi->nAxes = 3;
+    pi->nButtons = KD_MAX_BUTTON;
+    for (i = 1; i < KD_MAX_BUTTON; i++)
+        pi->map[i] = i;
+
+    return pi;
 }
 
 void
-KdMouseInfoDispose (KdMouseInfo *mi)
+KdFreePointer(KdPointerInfo *pi)
 {
-    KdMouseInfo	**prev;
+    InputOption *option, *prev = NULL;
 
-    for (prev = &kdMouseInfo; *prev; prev = &(*prev)->next)
+    if (pi->name)
-	if (*prev == mi)
+        xfree(pi->name);
-	{
+    if (pi->path)
-	    *prev = mi->next;
+        xfree(pi->path);
-	    if (mi->name)
+
-		xfree (mi->name);
+    for (option = pi->options; option; option = option->next) {
-	    if (mi->prot)
+        if (prev)
-		xfree (mi->prot);
+            xfree(prev);
-	    xfree (mi);
+        if (option->key)
-	    break;
+            xfree(option->key);
-	}
+        if (option->value)
+            xfree(option->value);
+        prev = option;
+    }
+
+    if (prev)
+        xfree(prev);
+    
+    xfree(pi);
+}
+ 
+void
+KdFreeKeyboard(KdKeyboardInfo *ki)
+{
+    if (ki->name)
+        xfree(ki->name);
+    if (ki->path)
+        xfree(ki->path);
+    ki->next = NULL;
+    xfree(ki);
 }

hw/kdrive/src/kkeymap.c

@@ -28,14 +28,13 @@
 #endif
 #include "kdrive.h"
 #include <X11/keysym.h>
-#include "kkeymap.h"
 
 /*
  * Map scan codes (both regular and synthesized from extended keys)
  * to X keysyms
  */
 
-KeySym kdKeymap[(MAX_SCANCODE - MIN_SCANCODE + 1) * MAX_WIDTH] = {
+const KeySym kdDefaultKeymap[KD_MAX_LENGTH * KD_MAX_WIDTH] = {
 /* These are directly mapped from DOS scanset 0 */
 /*      1     8 */	 XK_Escape, NoSymbol,
 /*      2     9 */	 XK_1,	XK_exclam,
@@ -152,58 +151,13 @@ KeySym kdKeymap[(MAX_SCANCODE - MIN_SCANCODE + 1) * MAX_WIDTH] = {
 /*    110   117 */	 NoSymbol,	NoSymbol,
 /*    111   118 */	 NoSymbol,	NoSymbol,
 /*    112   119 */	 NoSymbol,	NoSymbol,
-;
-
-/*
- * Map extended keys to additional scancodes
- */
-KdExtendMap kdExtendMap[] = {
-    0x1d,   89,	    /* Control_R */
-    0x1c,   90,	    /* KP_Enter */
-    0x35,   91,	    /* KP_Divide */
-    0x37,   92,	    /* Sys_Req */
-    0x38,   93,	    /* Alt_R */
-    0x45,   94,	    /* Num_Lock */
-    0x47,   95,	    /* Home */
-    0x48,   96,	    /* Up */
-    0x49,   97,	    /* Page_Up */
-    0x4b,   98,	    /* Left */
-    0x4d,   99,	    /* Right */
-    0x4f,   100,    /* End */
-    0x50,   101,    /* Down */
-    0x51,   102,    /* Page_Down */
-    0x52,   103,    /* Insert */
-    0x53,   104,    /* Delete */
-    0x5b,   105,    /* Super_L (Windows_L) */
-    0x5c,   106,    /* Super_R (Windows_R) */
-    0x5d,   107,    /* Menu */
-    0x46,   69,	    /* Break (with control pressed) */
 };
 
-#define NUM_EXTEND   (sizeof (kdExtendMap)/ sizeof (kdExtendMap[0]))
-
-int kdNumExtend = NUM_EXTEND;
-
-/*
- * Map keys on Japanese keyboard far from zero back to reasonable values
- */
-KdExtendMap kdJapanMap[] = {
-    0x70,   108,    /* next to Alt key */
-    0x73,   109,    /* dash/vbar */
-    0x79,   110,    /* right of space bar */
-    0x7b,   111,    /* left of space bar */
-    0x7d,   112,    /* Yen */
-};
-
-#define NUM_JAPAN   (sizeof (kdJapanMap)/sizeof (kdJapanMap[0]))
-
-int kdNumJapan = NUM_JAPAN;
-
 /*
  * List of locking key codes
  */
 
-CARD8  kdLockMap[] = {
+CARD8 kdLockMap[] = {
     65,
     101,
     77,
@@ -218,7 +172,7 @@ int kdNumLock = NUM_LOCK;
  * the KEYMAP_LOCKING_ALTGR flag is set in CEKeymapFlags
  */
 
-CARD8	kdOptionalLockMap[] = {
+CARD8 kdOptionalLockMap[] = {
     100,
 };
 
@@ -226,13 +180,13 @@ CARD8	kdOptionalLockMap[] = {
 
 int kdNumOptionalLock = NUM_OPTIONAL_LOCK;
 
-CARD8	kdModMap[MAP_LENGTH];
+const CARD8 kdDefaultModMap[MAP_LENGTH];
 
-unsigned long	kdKeymapFlags = 0;
+unsigned long kdDefaultKeymapFlags = 0;
 
-KeySymsRec  kdKeySyms = {
+const KeySymsRec kdDefaultKeySyms = {
-    kdKeymap,
+    kdDefaultKeymap,
-    MIN_KEYCODE,
+    KD_MIN_KEYCODE,
-    MAX_KEYCODE,
+    KD_MAX_KEYCODE,
-    2
+    KD_MAX_WIDTH
 };

hw/kdrive/src/kloadmap.c

@@ -27,7 +27,6 @@
 #include <kdrive-config.h>
 #endif
 #include "kdrive.h"
-#include "kkeymap.h"
 
 #ifdef WINDOWS
 #define KM_BUF	1024

hw/kdrive/vesa/Makefile.am

@@ -22,8 +22,4 @@ Xvesa_SOURCES = \
 Xvesa_LDADD = \
 	libvesa.a 				\
 	@KDRIVE_LIBS@				\
-	@KDRIVE_LIBS@                          \
 	@XSERVER_LIBS@
-
-Xvesa_DEPENDENCIES = \
-	libvesa.a

hw/kdrive/vesa/vesa.c

@@ -871,7 +871,7 @@ vesaComputeFramebufferMapping (KdScreenInfo *screen)
     VesaScreenPrivPtr	pscr = screen->driver;
     int			depth, bpp, fbbpp;
     Pixel		allbits;
-    KdMouseMatrix	m;
+    KdPointerMatrix	m;
 
     if (vesa_linear_fb)
     {
@@ -970,10 +970,10 @@ vesaComputeFramebufferMapping (KdScreenInfo *screen)
 	pscr->mapping = VESA_WINDOWED;
 	pscr->shadow = TRUE;
     }
-    KdComputeMouseMatrix (&m, pscr->randr, 
+    KdComputePointerMatrix (&m, pscr->randr, 
-			  pscr->mode.XResolution, pscr->mode.YResolution);
+                            pscr->mode.XResolution, pscr->mode.YResolution);
     
-    KdSetMouseMatrix (&m);
+    KdSetPointerMatrix (&m);
     
     screen->width = pscr->mode.XResolution;
     screen->height = pscr->mode.YResolution;

hw/kdrive/vesa/vesainit.c

@@ -71,7 +71,16 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-    KdInitInput(&LinuxMouseFuncs, &LinuxKeyboardFuncs);
+    KdKeyboardInfo *ki = NULL;
+        
+    KdAddPointerDriver(&LinuxMouseDriver);
+    KdAddKeyboardDriver(&LinuxKeyboardDriver);
+    ki = KdNewKeyboard();
+    if (ki) {
+        ki->driver = &LinuxKeyboardDriver;
+        KdAddKeyboard(ki);
+    }
+    KdInitInput();
 }
 
 void

hw/kdrive/via/Makefile.am

@@ -5,10 +5,6 @@ INCLUDES = 					\
 
 bin_PROGRAMS = Xvia
 
-if TSLIB
-TSLIB_FLAG = -lts
-endif
-
 noinst_LIBRARIES = libvia.a
 
 libvia_a_SOURCES = 	\
@@ -28,7 +24,4 @@ VIA_LIBS =	\
 Xvia_LDADD =						\
 	$(VIA_LIBS)					\
 	@KDRIVE_LIBS@					\
-	@XSERVER_LIBS@					\
+	@XSERVER_LIBS@
-	$(TSLIB_FLAG)					
-
-Xvia_DEPENDENCIES = $(VIA_LIBS)

hw/kdrive/vxworks/vxkbd.c

@@ -171,7 +171,7 @@ static int  kbdFd = -1;
 #include <event.h>
 #include <kbd_ioctl.h>
 
-extern KeybdCtrl    defaultKeyboardControl;
+extern KeyboardCtrl    defaultKeyboardControl;
 
 static void
 VxWorksSetAutorepeat (unsigned char *repeats, Bool on)
@@ -235,7 +235,7 @@ void
 VxWorksKeyboardLeds (int leds)
 {
     DeviceIntPtr	pKeyboard = (DeviceIntPtr) LookupKeyboardDevice ();
-    KeybdCtrl		*ctrl = &pKeyboard->kbdfeed->ctrl;
+    KeyboardCtrl		*ctrl = &pKeyboard->kbdfeed->ctrl;
     led_ioctl_info	led_info;
     int			i;
 

hw/vfb/InitInput.c

@@ -43,7 +43,7 @@ from The Open Group.
 #include <X11/keysym.h>
 
 Bool
-LegalModifier(unsigned int key, DevicePtr pDev)
+LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return TRUE;
 }

hw/xfree86/common/Makefile.am

@@ -21,8 +21,6 @@ RANDRSOURCES = xf86RandR.c
 
 BUSSOURCES = xf86isaBus.c xf86pciBus.c xf86fbBus.c xf86noBus.c $(SBUS_SOURCES)
 
-KBDSOURCES = xf86Kbd@XORG_OS_KBD@.c
-
 MODEDEFSOURCES = $(srcdir)/vesamodes $(srcdir)/extramodes
 
 xf86DefModeSet.c: $(srcdir)/modeline2c.pl $(MODEDEFSOURCES)
@@ -34,14 +32,13 @@ AM_LDFLAGS = -r
 libcommon_la_SOURCES = xf86Configure.c xf86Bus.c xf86Config.c \
                       xf86Cursor.c xf86cvt.c xf86DGA.c xf86DPMS.c \
                       xf86DoProbe.c xf86DoScanPci.c xf86Events.c \
-                      xf86Globals.c xf86Io.c xf86AutoConfig.c \
+                      xf86Globals.c xf86AutoConfig.c \
                       xf86MiscExt.c xf86Option.c \
                       xf86VidMode.c xf86fbman.c xf86cmap.c \
                       xf86Helper.c xf86PM.c \
                       xf86Mode.c xf86Build.h xorgHelper.c xf86Versions.c \
                       $(XVSOURCES) $(BUSSOURCES) $(XKBSOURCES) \
-                      $(DEBUGSOURCES) $(XISOURCES) $(RANDRSOURCES) \
+                      $(DEBUGSOURCES) $(XISOURCES) $(RANDRSOURCES)
-                      $(KBDSOURCES)
 nodist_libcommon_la_SOURCES = xf86DefModeSet.c
 libinit_a_SOURCES = xf86Build.h xf86Init.c
 
@@ -59,11 +56,6 @@ sdk_HEADERS = compiler.h fourcc.h xf86.h xf86Module.h xf86Opt.h \
 DISTCLEANFILES = xf86Build.h
 CLEANFILES = $(BUILT_SOURCES)
 
-# this is a hack for now.  as above we don't have rules to build all of these
-# yet, but we want to make sure they all get into the distball.  this should
-# eventually go away.
-DISTKBDSOURCES = xf86Kbd.c xf86KbdBSD.c xf86KbdLnx.c xf86KbdMach.c
-
 EXTRA_DIST = \
 	atKeynames.h \
 	compiler.h \

hw/xfree86/common/xf86Config.c

@@ -383,18 +383,6 @@ xf86DriverlistFromConfig()
     return modulearray;
 }
 
-
-Bool
-xf86BuiltinInputDriver(const char *name)
-{
-#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
-    if (xf86NameCmp(name, "keyboard") == 0)
-	return TRUE;
-    else
-#endif
-	return FALSE;
-}
-
 char **
 xf86InputDriverlistFromConfig()
 {
@@ -419,8 +407,7 @@ xf86InputDriverlistFromConfig()
     if (xf86ConfigLayout.inputs) {
         idp = xf86ConfigLayout.inputs;
         while (idp->identifier) {
-	    if (!xf86BuiltinInputDriver(idp->driver))
+	    count++;
-	        count++;
 	    idp++;
         }
     }
@@ -435,10 +422,8 @@ xf86InputDriverlistFromConfig()
     count = 0;
     idp = xf86ConfigLayout.inputs;
     while (idp->identifier) {
-	if (!xf86BuiltinInputDriver(idp->driver)) {
+        modulearray[count] = idp->driver;
-	    modulearray[count] = idp->driver;
+	count++;
-	    count++;
-	}
 	idp++;
     }
     modulearray[count] = NULL;
@@ -1119,304 +1104,6 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
     return TRUE;
 }
 
-/*
- * XXX This function is temporary, and will be removed when the keyboard
- * driver is converted into a regular input driver.
- */
-static Bool
-configInputKbd(IDevPtr inputp)
-{
-  char *s;
-  MessageType from = X_DEFAULT;
-  Bool customKeycodesDefault = FALSE;
-  int verb = 0;
-#if defined(XQUEUE)
-  char *kbdproto = "Xqueue";
-#else
-  char *kbdproto = "standard";
-#endif
-
-  /* Initialize defaults */
-  xf86Info.xleds         = 0L;
-  xf86Info.kbdDelay      = 500;
-  xf86Info.kbdRate       = 30;
-  
-  xf86Info.kbdProc       = NULL;
-  xf86Info.vtinit        = NULL;
-  xf86Info.vtSysreq      = VT_SYSREQ_DEFAULT;
-#if defined(SVR4) && defined(i386)
-  xf86Info.panix106      = FALSE;
-#endif
-  xf86Info.kbdCustomKeycodes = FALSE;
-#ifdef WSCONS_SUPPORT
-  xf86Info.kbdFd 	   = -1;
-#endif
-#ifdef XKB
-  if (!xf86IsPc98()) {
-    xf86Info.xkbrules      = __XKBDEFRULES__;
-    xf86Info.xkbmodel      = "pc105";
-    xf86Info.xkblayout     = "us";
-    xf86Info.xkbvariant    = NULL;
-    xf86Info.xkboptions    = NULL;
-  } else {
-    xf86Info.xkbrules      = "xfree98";
-    xf86Info.xkbmodel      = "pc98";
-    xf86Info.xkblayout     = "nec/jp";
-    xf86Info.xkbvariant    = NULL;
-    xf86Info.xkboptions    = NULL;
-  }
-  xf86Info.xkbcomponents_specified = FALSE;
-  /* Should discourage the use of these. */
-  xf86Info.xkbkeymap     = NULL;
-  xf86Info.xkbtypes      = NULL;
-  xf86Info.xkbcompat     = NULL;
-  xf86Info.xkbkeycodes   = NULL;
-  xf86Info.xkbsymbols    = NULL;
-  xf86Info.xkbgeometry   = NULL;
-#endif
-
-  s = xf86SetStrOption(inputp->commonOptions, "Protocol", kbdproto);
-  if (xf86NameCmp(s, "standard") == 0) {
-     xf86Info.kbdProc    = xf86KbdProc;
-     xf86Info.kbdEvents  = xf86KbdEvents;
-     xfree(s);
-  } else if (xf86NameCmp(s, "xqueue") == 0) {
-#ifdef __UNIXWARE__
-    /*
-     * To retain compatibility with older config files, on UnixWare, we
-     * accept the xqueue protocol but use the normal keyboard procs.
-     */
-     xf86Info.kbdProc    = xf86KbdProc;
-     xf86Info.kbdEvents  = xf86KbdEvents;
-#else
-#ifdef XQUEUE
-    xf86Info.kbdProc = xf86XqueKbdProc;
-    xf86Info.kbdEvents = xf86XqueEvents;
-    xf86Msg(X_CONFIG, "Xqueue selected for keyboard input\n");
-#endif
-#endif
-    xfree(s);
-#ifdef WSCONS_SUPPORT
-  } else if (xf86NameCmp(s, "wskbd") == 0) {
-     xf86Info.kbdProc    = xf86KbdProc;
-     xf86Info.kbdEvents  = xf86WSKbdEvents;
-     xfree(s);
-     s = xf86SetStrOption(inputp->commonOptions, "Device", NULL);
-     xf86Msg(X_CONFIG, "Keyboard: Protocol: wskbd\n");
-     if (s == NULL) {
-	 xf86ConfigError("A \"device\" option is required with"
-			 " the \"wskbd\" keyboard protocol");
-	 return FALSE;
-     }
-     xf86Info.kbdFd = open(s, O_RDWR | O_NONBLOCK | O_EXCL);
-     if (xf86Info.kbdFd == -1) {
-       xf86ConfigError("cannot open \"%s\"", s);
-       xfree(s);
-       return FALSE;
-     }
-     xfree(s);
-     /* Find out keyboard type */
-     if (ioctl(xf86Info.kbdFd, WSKBDIO_GTYPE, &xf86Info.wsKbdType) == -1) {
-	     xf86ConfigError("cannot get keyboard type");
-	     close(xf86Info.kbdFd);
-	     return FALSE;
-     }
-     switch (xf86Info.wsKbdType) {
-     case WSKBD_TYPE_PC_XT:
-	     xf86Msg(X_PROBED, "Keyboard type: XT\n");
-	     break;
-     case WSKBD_TYPE_PC_AT:
-	     xf86Msg(X_PROBED, "Keyboard type: AT\n");
-	     break;
-     case WSKBD_TYPE_USB:
-	     xf86Msg(X_PROBED, "Keyboard type: USB\n");
-	     break;
-#ifdef WSKBD_TYPE_ADB
-     case WSKBD_TYPE_ADB:
-	     xf86Msg(X_PROBED, "Keyboard type: ADB\n");
-	     break;
-#endif
-#ifdef WSKBD_TYPE_SUN
-     case WSKBD_TYPE_SUN:
-	     xf86Msg(X_PROBED, "Keyboard type: Sun\n");
-	     break;
-#endif
-#ifdef WSKBD_TYPE_SUN5
-     case WSKBD_TYPE_SUN5:
-	     xf86Msg(X_PROBED, "Keyboard type: Sun5\n");
-	     break;
-#endif
-     default:
-	     xf86ConfigError("Unsupported wskbd type \"%d\"", 
-			     xf86Info.wsKbdType);
-	     close(xf86Info.kbdFd);
-	     return FALSE;
-     }
-#endif
-  } else {
-    xf86ConfigError("\"%s\" is not a valid keyboard protocol name", s);
-    xfree(s);
-    return FALSE;
-  }
-
-  s = xf86SetStrOption(inputp->commonOptions, "AutoRepeat", NULL);
-  if (s) {
-    if (sscanf(s, "%d %d", &xf86Info.kbdDelay, &xf86Info.kbdRate) != 2) {
-      xf86ConfigError("\"%s\" is not a valid AutoRepeat value", s);
-      xfree(s);
-      return FALSE;
-    }
-  xfree(s);
-  }
-
-  s = xf86SetStrOption(inputp->commonOptions, "XLeds", NULL);
-  if (s) {
-    char *l, *end;
-    unsigned int i;
-    l = strtok(s, " \t\n");
-    while (l) {
-      i = strtoul(l, &end, 0);
-      if (*end == '\0')
-	xf86Info.xleds |= 1L << (i - 1);
-      else {
-	xf86ConfigError("\"%s\" is not a valid XLeds value", l);
-	xfree(s);
-	return FALSE;
-      }
-      l = strtok(NULL, " \t\n");
-    }
-    xfree(s);
-  }
-
-#ifdef XKB
-  from = X_DEFAULT;
-  if (noXkbExtension)
-    from = X_CMDLINE;
-  else if (xf86FindOption(inputp->commonOptions, "XkbDisable")) {
-    xf86Msg(X_WARNING, "KEYBOARD: XKB should be disabled in the "
-	    "ServerFlags section instead\n"
-	    "\tof in the \"keyboard\" InputDevice section.\n");
-    noXkbExtension =
-	xf86SetBoolOption(inputp->commonOptions, "XkbDisable", FALSE);
-    from = X_CONFIG;
-  }
-  if (noXkbExtension)
-    xf86Msg(from, "XKB: disabled\n");
-
-#define NULL_IF_EMPTY(s) (s[0] ? s : (xfree(s), (char *)NULL))
-
-  if (!noXkbExtension) {
-    if ((s = xf86SetStrOption(inputp->commonOptions, "XkbKeymap", NULL))) {
-      xf86Info.xkbkeymap = NULL_IF_EMPTY(s);
-      xf86Msg(X_CONFIG, "XKB: keymap: \"%s\" "
-		"(overrides other XKB settings)\n", xf86Info.xkbkeymap);
-    } else {
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbCompat", NULL))) {
-	xf86Info.xkbcompat = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: compat: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbTypes", NULL))) {
-	xf86Info.xkbtypes = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: types: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbKeycodes", NULL))) {
-	xf86Info.xkbkeycodes = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: keycodes: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbGeometry", NULL))) {
-	xf86Info.xkbgeometry = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: geometry: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbSymbols", NULL))) {
-	xf86Info.xkbsymbols = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: symbols: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbRules", NULL))) {
-	xf86Info.xkbrules = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: rules: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbModel", NULL))) {
-	xf86Info.xkbmodel = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: model: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbLayout", NULL))) {
-	xf86Info.xkblayout = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: layout: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbVariant", NULL))) {
-	xf86Info.xkbvariant = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: variant: \"%s\"\n", s);
-      }
-
-      if ((s = xf86SetStrOption(inputp->commonOptions, "XkbOptions", NULL))) {
-	xf86Info.xkboptions = NULL_IF_EMPTY(s);
-	xf86Info.xkbcomponents_specified = TRUE;
-	xf86Msg(X_CONFIG, "XKB: options: \"%s\"\n", s);
-      }
-    }
-  }
-#undef NULL_IF_EMPTY
-#endif
-#if defined(SVR4) && defined(i386)
-  if ((xf86Info.panix106 =
-	xf86SetBoolOption(inputp->commonOptions, "Panix106", FALSE))) {
-    xf86Msg(X_CONFIG, "PANIX106: enabled\n");
-  }
-#endif
-
-  /*
-   * This was once a compile time option (ASSUME_CUSTOM_KEYCODES)
-   * defaulting to 1 on Linux/PPC. It is no longer necessary, but for
-   * backwards compatibility we provide 'Option "CustomKeycodes"'
-   * and try to autoprobe on Linux/PPC.
-   */
-  from = X_DEFAULT;
-  verb = 2;
-#if defined(__linux__) && defined(__powerpc__)
-  {
-    FILE *f;
-
-    f = fopen("/proc/sys/dev/mac_hid/keyboard_sends_linux_keycodes","r");
-    if (f) {
-      if (fgetc(f) == '0') {
-	customKeycodesDefault = TRUE;
-	from = X_PROBED;
-	verb = 1;
-      }
-      fclose(f);
-    }
-  }
-#endif
-  if (xf86FindOption(inputp->commonOptions, "CustomKeycodes")) {
-    from = X_CONFIG;
-    verb = 1;
-  }
-  xf86Info.kbdCustomKeycodes =
-	xf86SetBoolOption(inputp->commonOptions, "CustomKeycodes",
-			  customKeycodesDefault);
-  xf86MsgVerb(from, verb, "Keyboard: CustomKeycode %s\n",
-		xf86Info.kbdCustomKeycodes ? "enabled" : "disabled");
-
-  return TRUE;
-}
-
 /*
  * Locate the core input devices.  These can be specified/located in
  * the following ways, in order of priority:
@@ -1653,10 +1340,6 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
 	    confInput = xf86findInputByDriver("kbd",
 					      xf86configptr->conf_input_lst);
 	}
-	if (!confInput) {
-	    confInput = xf86findInputByDriver("keyboard",
-					      xf86configptr->conf_input_lst);
-	}
 	if (confInput) {
 	    foundKeyboard = TRUE;
 	    from = X_DEFAULT;
@@ -2563,10 +2246,6 @@ configInput(IDevPtr inputp, XF86ConfInputPtr conf_input, MessageType from)
     inputp->commonOptions = conf_input->inp_option_lst;
     inputp->extraOptions = NULL;
 
-    /* XXX This is required until the keyboard driver is converted */
-    if (!xf86NameCmp(inputp->driver, "keyboard"))
-	return configInputKbd(inputp);
-
     return TRUE;
 }
 

hw/xfree86/common/xf86Configure.c

@@ -76,7 +76,7 @@ Bool foundMouse = FALSE;
 #elif defined(__SCO__)
 static char *DFLT_MOUSE_PROTO = "OSMouse";
 #elif defined(__UNIXWARE__)
-static char *DFLT_MOUSE_PROTO = "Xqueue";
+static char *DFLT_MOUSE_PROTO = "OSMouse";
 static char *DFLT_MOUSE_DEV = "/dev/mouse";
 #elif defined(QNX4)
 static char *DFLT_MOUSE_PROTO = "OSMouse";
@@ -265,11 +265,7 @@ configureInputSection (void)
     parsePrologue (XF86ConfInputPtr, XF86ConfInputRec)
 
     ptr->inp_identifier = "Keyboard0";
-#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
-    ptr->inp_driver = "keyboard";
-#else
     ptr->inp_driver = "kbd";
-#endif
     ptr->list.next = NULL;
 
     /* Crude mechanism to auto-detect mouse (os dependent) */

hw/xfree86/common/xf86Cursor.c

@@ -77,14 +77,9 @@ static miPointerScreenFuncRec xf86PointerScreenFuncs = {
   xf86CursorOffScreen,
   xf86CrossScreen,
   xf86WarpCursor,
-#ifdef XINPUT
-  xf86eqEnqueue,
-  xf86eqSwitchScreen
-#else
   /* let miPointerInitialize take care of these */
   NULL,
   NULL
-#endif
 };
 
 static xf86ScreenLayoutRec xf86ScreenLayout[MAXSCREENS];

hw/xfree86/common/xf86DGA.c

@@ -921,7 +921,7 @@ DGAStealKeyEvent(int index, xEvent *e)
     de.u.u.type = e->u.u.type + *XDGAEventBase;
     de.u.u.detail = e->u.u.detail;
     de.u.event.time = e->u.keyButtonPointer.time;
-    xf86eqEnqueue ((xEvent *) &de);
+    mieqEnqueue ((xEvent *) &de);
    return TRUE;
 }
 
@@ -958,7 +958,7 @@ DGAStealMouseEvent(int index, xEvent *e, int dx, int dy)
     de.u.event.dy = dy;
     de.u.event.pad1 = DGAMouseX;
     de.u.event.pad2 = DGAMouseY;
-    xf86eqEnqueue ((xEvent *) &de);
+    mieqEnqueue ((xEvent *) &de);
     return TRUE;
 }
 

hw/xfree86/common/xf86Debug.c

@@ -163,6 +163,7 @@ void xf86PokeMmio32(pointer Base, unsigned long Offset, CARD32 v)
 }
 
 
+#if 0
 _X_EXPORT void
 xf86STimestamp(xf86TsPtr* timestamp)
 {
@@ -194,3 +195,4 @@ xf86SPTimestamp(xf86TsPtr* timestamp, char *str)
 	gettimeofday((struct timeval*)*timestamp,NULL);
     }
 }
+#endif

hw/xfree86/common/xf86Events.c

@@ -104,11 +104,7 @@ extern Bool noXkbExtension;
 #define XE_POINTER  1
 #define XE_KEYBOARD 2
 
-#ifdef XINPUT
-#define __EqEnqueue(ev) xf86eqEnqueue(ev)
-#else
 #define __EqEnqueue(ev) mieqEnqueue(ev)
-#endif
 
 #define EqEnqueue(ev) { \
     int __sigstate = xf86BlockSIGIO (); \
@@ -146,9 +142,6 @@ Bool VTSwitchEnabled = TRUE;		/* Allows run-time disabling for
 
 extern fd_set EnabledDevices;
 
-#if defined(XQUEUE)
-extern void xf86XqueRequest(void);
-#endif
 #ifdef XF86PM
 extern void (*xf86OSPMClose)(void);
 #endif
@@ -170,6 +163,12 @@ typedef struct x_IHRec {
 static IHPtr InputHandlers = NULL;
 
 
+Bool
+LegalModifier(unsigned int key, DeviceIntPtr pDev)
+{
+    return TRUE;
+}
+
 /*
  * TimeSinceLastInputEvent --
  *      Function used for screensaver purposes by the os module. Returns the
@@ -253,11 +252,7 @@ ProcessInputEvents ()
 
   xf86Info.inputPending = FALSE;
 
-#ifdef XINPUT
-  xf86eqProcessInputEvents();
-#else
   mieqProcessInputEvents();
-#endif
   miPointerUpdate();
 
   miPointerPosition(&x, &y);
@@ -403,679 +398,6 @@ xf86ProcessActionEvent(ActionEvent action, void *arg)
     }
 }
 
-/*
- * xf86PostKbdEvent --
- *	Translate the raw hardware KbdEvent into an XEvent, and tell DIX
- *	about it. Scancode preprocessing and so on is done ...
- *
- *  OS/2 specific xf86PostKbdEvent(key) has been moved to os-support/os2/os2_kbd.c
- *  as some things differ, and I did not want to scatter this routine with
- *  ifdefs further (hv).
- */
-
-#ifdef __linux__
-extern u_char SpecialServerMap[];
-#endif
-
-#if !defined(__UNIXOS2__)
-void
-xf86PostKbdEvent(unsigned key)
-{
-  int         scanCode = (key & 0x7f);
-  int         specialkey = 0;
-  Bool        down = (key & 0x80 ? FALSE : TRUE);
-  KeyClassRec *keyc = ((DeviceIntPtr)xf86Info.pKeyboard)->key;
-  Bool        updateLeds = FALSE;
-  Bool        UsePrefix = FALSE;
-  Bool        Direction = FALSE;
-  xEvent      kevent;
-  KeySym      *keysym;
-  int         keycode;
-  static int  lockkeys = 0;
-#if defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT)
-  static Bool first_time = TRUE;
-#endif
-#if defined(__sparc__) && defined(__linux__)
-  static int  kbdSun = -1;
-#endif
-  /* Disable any keyboard processing while in suspend */
-  if (xf86inSuspend)
-      return;
-
-#if defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT)
-  if (first_time)
-  {
-    first_time = FALSE;
-    VTSwitchEnabled = (xf86Info.consType == SYSCONS)
-	    || (xf86Info.consType == PCVT);
-  }
-#endif
-
-#if defined (__sparc__) && defined(__linux__)
-  if (kbdSun == -1) {
-    if ((xf86Info.xkbmodel && !strcmp(xf86Info.xkbmodel, "sun"))
-	|| (xf86Info.xkbrules && !strcmp(xf86Info.xkbrules, "sun")))
-      kbdSun = 1;
-    else
-      kbdSun = 0;
-  }
-  if (kbdSun)
-    goto special;
-#endif /* __sparc__ && __linux__ */
-
-#ifdef __linux__
-  if (xf86Info.kbdCustomKeycodes) {
-    specialkey = SpecialServerMap[scanCode];
-    goto customkeycodes;
-  }
-#endif
-
-  /*
-   * First do some special scancode remapping ...
-   */
-  if (xf86Info.scanPrefix == 0) {
-
-    switch (scanCode) {
-    case KEY_Prefix0:
-    case KEY_Prefix1:
-#if defined(PCCONS_SUPPORT) || defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT)
-      if (xf86Info.consType == PCCONS || xf86Info.consType == SYSCONS
-	  || xf86Info.consType == PCVT
-#ifdef WSCONS_SUPPORT
-	  || (xf86Info.consType == WSCONS && xf86Info.kbdEvents != xf86WSKbdEvents)
-#endif
-      ) {
-#endif
-        xf86Info.scanPrefix = scanCode;  /* special prefixes */
-        return;
-#if defined(PCCONS_SUPPORT) || defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT)
-      }
-      break;
-#endif
-    }
-#if defined (i386) && defined (SVR4)
-    /* 
-     * PANIX returns DICOP standards based keycodes in using 106jp 
-     * keyboard. We need to remap some keys. 
-     */
-    if(xf86Info.panix106 == TRUE){
-      switch (scanCode) {
-      case 0x56:        scanCode = KEY_BSlash2;	break;  /* Backslash */
-      case 0x5A:        scanCode = KEY_NFER;	break;  /* No Kanji Transfer*/
-      case 0x5B:        scanCode = KEY_XFER;	break;  /* Kanji Tranfer */
-      case 0x5C:        scanCode = KEY_Yen;	break;  /* Yen curs pgup */
-      case 0x6B:        scanCode = KEY_Left;	break;  /* Cur Left */
-      case 0x6F:        scanCode = KEY_PgUp;	break;  /* Cur PageUp */
-      case 0x72:        scanCode = KEY_AltLang;	break;  /* AltLang(right) */
-      case 0x73:        scanCode = KEY_RCtrl;	break;  /* not needed */
-      }
-    } else
-#endif /* i386 && SVR4 */
-    {
-      switch (scanCode) {
-      case 0x59:        scanCode = KEY_0x59; break;
-      case 0x5a:        scanCode = KEY_0x5A; break;
-      case 0x5b:        scanCode = KEY_0x5B; break;
-      case 0x5c:        scanCode = KEY_KP_Equal; break; /* Keypad Equal */
-      case 0x5d:        scanCode = KEY_0x5D; break;
-      case 0x5e:        scanCode = KEY_0x5E; break;
-      case 0x5f:        scanCode = KEY_0x5F; break;
-      case 0x62:        scanCode = KEY_0x62; break;
-      case 0x63:        scanCode = KEY_0x63; break;
-      case 0x64:        scanCode = KEY_0x64; break;
-      case 0x65:        scanCode = KEY_0x65; break;
-      case 0x66:        scanCode = KEY_0x66; break;
-      case 0x67:        scanCode = KEY_0x67; break;
-      case 0x68:        scanCode = KEY_0x68; break;
-      case 0x69:        scanCode = KEY_0x69; break;
-      case 0x6a:        scanCode = KEY_0x6A; break;
-      case 0x6b:        scanCode = KEY_0x6B; break;
-      case 0x6c:        scanCode = KEY_0x6C; break;
-      case 0x6d:        scanCode = KEY_0x6D; break;
-      case 0x6e:        scanCode = KEY_0x6E; break;
-      case 0x6f:        scanCode = KEY_0x6F; break;
-      case 0x70:        scanCode = KEY_0x70; break;
-      case 0x71:        scanCode = KEY_0x71; break;
-      case 0x72:        scanCode = KEY_0x72; break;
-      case 0x73:        scanCode = KEY_0x73; break;
-      case 0x74:        scanCode = KEY_0x74; break;
-      case 0x75:        scanCode = KEY_0x75; break;
-      case 0x76:        scanCode = KEY_0x76; break;
-      }
-    }
-  }
-
-  else if (
-#ifdef CSRG_BASED
-           (xf86Info.consType == PCCONS || xf86Info.consType == SYSCONS
-	    || xf86Info.consType == PCVT
-#ifdef WSCONS_SUPPORT
-	      || (xf86Info.consType == WSCONS && xf86Info.kbdEvents !=
-	      xf86WSKbdEvents)
-#endif
-	      ) &&
-#endif
-           (xf86Info.scanPrefix == KEY_Prefix0)) {
-    xf86Info.scanPrefix = 0;
-	  
-    switch (scanCode) {
-    case KEY_KP_7:        scanCode = KEY_Home;      break;  /* curs home */
-    case KEY_KP_8:        scanCode = KEY_Up;        break;  /* curs up */
-    case KEY_KP_9:        scanCode = KEY_PgUp;      break;  /* curs pgup */
-    case KEY_KP_4:        scanCode = KEY_Left;      break;  /* curs left */
-    case KEY_KP_5:        scanCode = KEY_Begin;     break;  /* curs begin */
-    case KEY_KP_6:        scanCode = KEY_Right;     break;  /* curs right */
-    case KEY_KP_1:        scanCode = KEY_End;       break;  /* curs end */
-    case KEY_KP_2:        scanCode = KEY_Down;      break;  /* curs down */
-    case KEY_KP_3:        scanCode = KEY_PgDown;    break;  /* curs pgdown */
-    case KEY_KP_0:        scanCode = KEY_Insert;    break;  /* curs insert */
-    case KEY_KP_Decimal:  scanCode = KEY_Delete;    break;  /* curs delete */
-    case KEY_Enter:       scanCode = KEY_KP_Enter;  break;  /* keypad enter */
-    case KEY_LCtrl:       scanCode = KEY_RCtrl;     break;  /* right ctrl */
-    case KEY_KP_Multiply: scanCode = KEY_Print;     break;  /* print */
-    case KEY_Slash:       scanCode = KEY_KP_Divide; break;  /* keyp divide */
-    case KEY_Alt:         scanCode = KEY_AltLang;   break;  /* right alt */
-    case KEY_ScrollLock:  scanCode = KEY_Break;     break;  /* curs break */
-    case 0x5b:            scanCode = KEY_LMeta;     break;
-    case 0x5c:            scanCode = KEY_RMeta;     break;
-    case 0x5d:            scanCode = KEY_Menu;      break;
-    case KEY_F3:          scanCode = KEY_F13;       break;
-    case KEY_F4:          scanCode = KEY_F14;       break;
-    case KEY_F5:          scanCode = KEY_F15;       break;
-    case KEY_F6:          scanCode = KEY_F16;       break;
-    case KEY_F7:          scanCode = KEY_F17;       break;
-    case KEY_KP_Plus:     scanCode = KEY_KP_DEC;    break;
-      /*
-       * Ignore virtual shifts (E0 2A, E0 AA, E0 36, E0 B6)
-       */
-    case 0x2A:
-    case 0x36:
-	return;
-    default:
-      xf86MsgVerb(X_INFO, 4, "Unreported Prefix0 scancode: 0x%02x\n",
-		  scanCode);
-      /*
-       * "Internet" keyboards are generating lots of new codes.  Let them
-       * pass.  There is little consistency between them, so don't bother
-       * with symbolic names at this level.
-       */
-      scanCode += 0x78;
-    }
-  }
-  
-  else if (xf86Info.scanPrefix == KEY_Prefix1)
-    {
-      xf86Info.scanPrefix = (scanCode == KEY_LCtrl) ? KEY_LCtrl : 0;
-      return;
-    }
-  
-  else if (xf86Info.scanPrefix == KEY_LCtrl)
-    {
-      xf86Info.scanPrefix = 0;
-      if (scanCode != KEY_NumLock) return;
-      scanCode = KEY_Pause;       /* pause */
-    }
-
-#ifndef __sparc64__
-  /*
-   * PC keyboards generate separate key codes for
-   * Alt+Print and Control+Pause but in the X keyboard model
-   * they need to get the same key code as the base key on the same
-   * physical keyboard key.
-   */
-  if (scanCode == KEY_SysReqest)
-    scanCode = KEY_Print;
-  else if (scanCode == KEY_Break)
-    scanCode = KEY_Pause;
-#endif
-  
-  /*
-   * and now get some special keysequences
-   */
-
-  specialkey = scanCode;
-
-#ifdef __linux__
-customkeycodes:
-#endif
-#if defined(i386) || defined(__i386__)
-  if (xf86IsPc98()) {
-    switch (scanCode) {
-      case 0x0e: specialkey = 0x0e; break; /* KEY_BackSpace */
-      case 0x40: specialkey = 0x4a; break; /* KEY_KP_Minus  */
-      case 0x49: specialkey = 0x4e; break; /* KEY_KP_Plus   */
-
-      /* XXX needs cases for KEY_KP_Divide and KEY_KP_Multiply */
-
-      case 0x62: specialkey = 0x3b; break; /* KEY_F1        */
-      case 0x63: specialkey = 0x3c; break; /* KEY_F2        */
-      case 0x64: specialkey = 0x3d; break; /* KEY_F3        */
-      case 0x65: specialkey = 0x3e; break; /* KEY_F4        */
-      case 0x66: specialkey = 0x3f; break; /* KEY_F5        */
-      case 0x67: specialkey = 0x40; break; /* KEY_F6        */
-      case 0x68: specialkey = 0x41; break; /* KEY_F7        */
-      case 0x69: specialkey = 0x42; break; /* KEY_F8        */
-      case 0x6a: specialkey = 0x43; break; /* KEY_F9        */
-      case 0x6b: specialkey = 0x44; break; /* KEY_F10       */
-      /* case 0x73: specialkey = 0x38; break; KEY_Alt       */
-      /* case 0x74: specialkey = 0x1d; break; KEY_LCtrl     */
-      default:   specialkey = 0x00; break;
-    }
-  }
-#endif
-#if defined (__sparc__) && defined(__linux__)
-special:
-  if (kbdSun) {
-    switch (scanCode) {
-      case 0x2b: specialkey = KEY_BackSpace; break;
-      case 0x47: specialkey = KEY_KP_Minus; break;
-      case 0x7d: specialkey = KEY_KP_Plus; break;
-
-      /* XXX needs cases for KEY_KP_Divide and KEY_KP_Multiply */
-
-      case 0x05: specialkey = KEY_F1; break;
-      case 0x06: specialkey = KEY_F2; break;
-      case 0x08: specialkey = KEY_F3; break;
-      case 0x0a: specialkey = KEY_F4; break;
-      case 0x0c: specialkey = KEY_F5; break;
-      case 0x0e: specialkey = KEY_F6; break;
-      case 0x10: specialkey = KEY_F7; break;
-      case 0x11: specialkey = KEY_F8; break;
-      case 0x12: specialkey = KEY_F9; break;
-      case 0x07: specialkey = KEY_F10; break;
-      case 0x09: specialkey = KEY_F11; break;
-      case 0x0b: specialkey = KEY_F12; break;
-      default: specialkey = 0; break;
-    }
-    /*
-     * XXX XXX XXX:
-     *
-     * I really don't know what's wrong here, but passing the real
-     * scanCode offsets by one from XKB's point of view.
-     *
-     * (ecd@skynet.be, 980405)
-     */
-    scanCode--;
-  }
-#endif /* defined (__sparc__) && defined(__linux__) */
-
-#ifdef XKB
-  if ((xf86Info.ddxSpecialKeys == SKWhenNeeded &&
-       !xf86Info.ActionKeyBindingsSet) ||
-      noXkbExtension || xf86Info.ddxSpecialKeys == SKAlways) {
-#endif
-  if (!(ModifierDown(ShiftMask)) &&
-      ((ModifierDown(ControlMask | AltMask)) ||
-       (ModifierDown(ControlMask | AltLangMask))))
-    {
-      switch (specialkey) {
-	
-      case KEY_BackSpace:
-	xf86ProcessActionEvent(ACTION_TERMINATE, NULL);
-	break;
-
-      /*
-       * Check grabs
-       */
-      case KEY_KP_Divide:
-	xf86ProcessActionEvent(ACTION_DISABLEGRAB, NULL);
-	break;
-      case KEY_KP_Multiply:
-	xf86ProcessActionEvent(ACTION_CLOSECLIENT, NULL);
-	break;
-
-      /*
-       * Video mode switches
-       */
-      case KEY_KP_Minus:   /* Keypad - */
-	if (down) xf86ProcessActionEvent(ACTION_PREV_MODE, NULL);
-	if (!xf86Info.dontZoom) return;
-	break;
-	
-      case KEY_KP_Plus:   /* Keypad + */
-	if (down) xf86ProcessActionEvent(ACTION_NEXT_MODE, NULL);
-	if (!xf86Info.dontZoom) return;
-	break;
-
-	/* Under QNX4, we set the vtPending flag for VT switching and 
-	 * let the VT switch function do the rest...
-	 * This is a little different from the other OS'es.
-	 */
-#if defined(QNX4)
-      case KEY_1:
-      case KEY_2:
-      case KEY_3:
-      case KEY_4:
-      case KEY_5:
-      case KEY_6:
-      case KEY_7:
-      case KEY_8:
-      case KEY_9:
-	if (VTSwitchEnabled && !xf86Info.dontVTSwitch) {
-	  if (down) {
-	    int vtno = specialkey - KEY_1 + 1;
-	    xf86ProcessActionEvent(ACTION_SWITCHSCREEN, (void *) &vtno);
-	  }
-	  return;
-	}
-	break;
-#endif
-
-#if defined(linux) || (defined(CSRG_BASED) && (defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT))) || defined(__SCO__) || defined(__UNIXWARE__)
-	/*
-	 * Under Linux, the raw keycodes are consumed before the kernel
-	 * does any processing on them, so we must emulate the vt switching
-	 * we want ourselves.
-	 */
-      case KEY_F1:
-      case KEY_F2:
-      case KEY_F3:
-      case KEY_F4:
-      case KEY_F5:
-      case KEY_F6:
-      case KEY_F7:
-      case KEY_F8:
-      case KEY_F9:
-      case KEY_F10:
-      case KEY_F11:
-      case KEY_F12:
-	if ((VTSwitchEnabled && !xf86Info.vtSysreq && !xf86Info.dontVTSwitch)
-#if (defined(CSRG_BASED) && (defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT)))
-	    && (xf86Info.consType == SYSCONS || xf86Info.consType == PCVT)
-#endif
-	   ) {
-	    int vtno = specialkey - KEY_F1 + 1;
-	    if (specialkey == KEY_F11 || specialkey == KEY_F12)
-		vtno = specialkey - KEY_F11 + 11;
-	    if (down)
-		xf86ProcessActionEvent(ACTION_SWITCHSCREEN, (void *) &vtno);
-	    return;
-	}
-	break;
-#endif /* linux || BSD with VTs */
-
-      /* just worth mentioning here: any 386bsd keyboard driver
-       * (pccons.c or co_kbd.c) catches CTRL-ALT-DEL and CTRL-ALT-ESC
-       * before any application (e.g. XF86) will see it
-       * OBS: syscons does not, nor does pcvt !
-       */
-      } 
-    }
-
-    /*
-     * Start of actual Solaris VT switching code.  
-     * This should pretty much emulate standard SVR4 switching keys.
-     * 
-     * DWH 12/2/93
-     */
-
-#ifdef USE_VT_SYSREQ
-    if (VTSwitchEnabled && xf86Info.vtSysreq && !xf86Info.dontVTSwitch)
-    {
-      switch (specialkey)
-      {
-      /*
-       * syscons on *BSD doesn't have a VT #0  -- don't think Linux does
-       * either
-       */
-#if defined (sun) && defined (i386) && defined (SVR4)
-      case KEY_H: 
-	if (VTSysreqToggle && down)
-        {
-	  xf86ProcessActionEvent(ACTION_SWITCHSCREEN, NULL);
-          VTSysreqToggle = 0;
-          return; 
-        }
-	break;
-
-      /*
-       * Yah, I know the N, and P keys seem backwards, however that's
-       * how they work under Solaris
-       * XXXX N means go to next active VT not necessarily vtno+1 (or vtno-1)
-       */
-
-      case KEY_N:
-	if (VTSysreqToggle && down)
-	{
-	  xf86ProcessActionEvent(ACTION_SWITCHSCREEN_NEXT, NULL);
-          VTSysreqToggle = FALSE;
-          return;
-        }
-	break;
-
-      case KEY_P:
-	if (VTSysreqToggle && down)
-	{
-	  xf86ProcessActionEvent(ACTION_SWITCHSCREEN_NEXT, NULL);
-          VTSysreqToggle = FALSE;
-          return;
-        }
-	break;
-#endif
-
-      case KEY_F1:
-      case KEY_F2:
-      case KEY_F3:
-      case KEY_F4:
-      case KEY_F5:
-      case KEY_F6:
-      case KEY_F7:
-      case KEY_F8:
-      case KEY_F9:
-      case KEY_F10:
-      case KEY_F11:
-      case KEY_F12:
-	if (VTSysreqToggle && down)
-	{ int vtno = specialkey - KEY_F1 + 1;
-	  if (specialkey == KEY_F11 || specialkey == KEY_F12)
-	    vtno = specialkey - KEY_F11 + 11;
-	  xf86ProcessActionEvent(ACTION_SWITCHSCREEN, (void *) &vtno);
-          VTSysreqToggle = FALSE;
-          return;
-        }
-	break;
-
-      /* Ignore these keys -- ie don't let them cancel an alt-sysreq */
-      case KEY_Alt:
-      case KEY_AltLang:
-	break;
-
-      case KEY_SysReqest:
-        if (down && (ModifierDown(AltMask) || ModifierDown(AltLangMask)))
-          VTSysreqToggle = TRUE;
-	break;
-
-      default:
-        if (VTSysreqToggle)
-	{
-	  /*
-	   * We only land here when Alt-SysReq is followed by a
-	   * non-switching key.
-	   */
-          VTSysreqToggle = FALSE;
-
-        }
-      }
-    }
-
-#endif /* USE_VT_SYSREQ */
-
-#ifdef __SCO__
-    /*
-     *	With the console in raw mode, SCO will not switch consoles,
-     *	you get around this by activating the next console along, if
-     *	this fails then go back to console 0, if there is only one
-     *	then it doesn't matter, switching to yourself is a nop as far
-     *	as the console driver is concerned.
-     *	We could do something similar to linux here but SCO ODT uses
-     *	Ctrl-PrintScrn, so why change?
-     */
-    if (specialkey == KEY_Print && ModifierDown(ControlMask)) {
-      if (down)
-	xf86ProcessActionEvent(ACTION_SWITCHSCREEN_NEXT, NULL);
-      return;
-    }
-#endif /* __SCO__ */
-#ifdef XKB
-    }
-#endif
-
-  /*
-   * Now map the scancodes to real X-keycodes ...
-   */
-  keycode = scanCode + MIN_KEYCODE;
-  keysym = (keyc->curKeySyms.map +
-	    keyc->curKeySyms.mapWidth * 
-	    (keycode - keyc->curKeySyms.minKeyCode));
-#ifdef XKB
-  if (noXkbExtension) {
-#endif
-  /*
-   * Filter autorepeated caps/num/scroll lock keycodes.
-   */
-#define CAPSFLAG 0x01
-#define NUMFLAG 0x02
-#define SCROLLFLAG 0x04
-#define MODEFLAG 0x08
-  if( down ) {
-    switch( keysym[0] ) {
-        case XK_Caps_Lock :
-          if (lockkeys & CAPSFLAG)
-              return;
-	  else
-	      lockkeys |= CAPSFLAG;
-          break;
-
-        case XK_Num_Lock :
-          if (lockkeys & NUMFLAG)
-              return;
-	  else
-	      lockkeys |= NUMFLAG;
-          break;
-
-        case XK_Scroll_Lock :
-          if (lockkeys & SCROLLFLAG)
-              return;
-	  else
-	      lockkeys |= SCROLLFLAG;
-          break;
-    }
-    if (keysym[1] == XF86XK_ModeLock)
-    {
-      if (lockkeys & MODEFLAG)
-          return;
-      else
-          lockkeys |= MODEFLAG;
-    }
-      
-  }
-  else {
-    switch( keysym[0] ) {
-        case XK_Caps_Lock :
-            lockkeys &= ~CAPSFLAG;
-            break;
-
-        case XK_Num_Lock :
-            lockkeys &= ~NUMFLAG;
-            break;
-
-        case XK_Scroll_Lock :
-            lockkeys &= ~SCROLLFLAG;
-            break;
-    }
-    if (keysym[1] == XF86XK_ModeLock)
-      lockkeys &= ~MODEFLAG;
-  }
-
-  /*
-   * LockKey special handling:
-   * ignore releases, toggle on & off on presses.
-   * Don't deal with the Caps_Lock keysym directly, but check the lock modifier
-   */
-  if (keyc->modifierMap[keycode] & LockMask ||
-      keysym[0] == XK_Scroll_Lock ||
-      keysym[1] == XF86XK_ModeLock ||
-      keysym[0] == XK_Num_Lock)
-    {
-      Bool flag;
-
-      if (!down) return;
-      if (KeyPressed(keycode)) {
-	down = !down;
-	flag = FALSE;
-      }
-      else
-	flag = TRUE;
-
-      if (keyc->modifierMap[keycode] & LockMask)   xf86Info.capsLock   = flag;
-      if (keysym[0] == XK_Num_Lock)    xf86Info.numLock    = flag;
-      if (keysym[0] == XK_Scroll_Lock) xf86Info.scrollLock = flag;
-      if (keysym[1] == XF86XK_ModeLock)   xf86Info.modeSwitchLock = flag;
-      updateLeds = TRUE;
-    }
-
-  if (!xf86Info.kbdCustomKeycodes) {
-    /*
-     * normal, non-keypad keys
-     */
-    if (scanCode < KEY_KP_7 || scanCode > KEY_KP_Decimal) {
-#if !defined(CSRG_BASED) && \
-    !defined(__GNU__) && \
-     defined(KB_84)
-      /*
-       * magic ALT_L key on AT84 keyboards for multilingual support
-       */
-      if (xf86Info.kbdType == KB_84 &&
-	  ModifierDown(AltMask) &&
-	  keysym[2] != NoSymbol)
-	{
-	  UsePrefix = TRUE;
-	  Direction = TRUE;
-	}
-#endif /* !CSRG_BASED && ... */
-    }
-  }
-  if (updateLeds) xf86UpdateKbdLeds();
-#ifdef XKB
-  }
-#endif
-
-  /*
-   * check for an autorepeat-event
-   */
-  if (down && KeyPressed(keycode)) {
-      KbdFeedbackClassRec *kbdfeed = ((DeviceIntPtr)xf86Info.pKeyboard)->kbdfeed;
-      if ((xf86Info.autoRepeat != AutoRepeatModeOn) ||
-          keyc->modifierMap[keycode] ||
-          (kbdfeed && !(kbdfeed->ctrl.autoRepeats[keycode>>3] & ( 1<<(keycode&7) ))))
-          return;
-  }
-
-
-  xf86Info.lastEventTime = kevent.u.keyButtonPointer.time = GetTimeInMillis();
-  /*
-   * And now send these prefixes ...
-   * NOTE: There cannot be multiple Mode_Switch keys !!!!
-   */
-  if (UsePrefix)
-    {
-      ENQUEUE(&kevent,
-	      keyc->modifierKeyMap[keyc->maxKeysPerModifier*7],
-	      (Direction ? KeyPress : KeyRelease),
-	      XE_KEYBOARD);
-      ENQUEUE(&kevent, keycode, (down ? KeyPress : KeyRelease), XE_KEYBOARD);
-      ENQUEUE(&kevent,
-	      keyc->modifierKeyMap[keyc->maxKeysPerModifier*7],
-	      (Direction ? KeyRelease : KeyPress),
-	      XE_KEYBOARD);
-    }
-  else 
-    {
-      ENQUEUE(&kevent, keycode, (down ? KeyPress : KeyRelease), XE_KEYBOARD);
-    }
-}
-#endif /* !__UNIXOS2__ */
-
 #define ModifierIsSet(k) ((modifiers & (k)) == (k))
 
 _X_EXPORT Bool
@@ -1137,8 +459,6 @@ xf86Wakeup(pointer blockData, int err, pointer pReadmask)
 
 	XFD_ANDSET(&devicesWithInput, LastSelectMask, &EnabledDevices);
 	if (XFD_ANYSET(&devicesWithInput)) {
-	    if (xf86Info.kbdEvents)
-	    	(xf86Info.kbdEvents)();
 	    pInfo = xf86InputDevs;
 	    while (pInfo) {
 		if (pInfo->read_input && pInfo->fd >= 0 &&
@@ -1161,8 +481,6 @@ xf86Wakeup(pointer blockData, int err, pointer pReadmask)
 
     InputInfoPtr pInfo;
 
-    (xf86Info.kbdEvents)();  /* Under OS/2 and QNX, always call */
-
     pInfo = xf86InputDevs;
     while (pInfo) {
 		if (pInfo->read_input && pInfo->fd >= 0) {
@@ -1470,6 +788,67 @@ xf86SigMemDebug(int signo)
 }
 #endif
 
+static void
+xf86ReleaseKeys(DeviceIntPtr pDev)
+{
+    KeyClassPtr keyc = NULL;
+    KeySym *map = NULL;
+    xEvent *events = NULL, ke;
+    int i = 0, j = 0, nevents = 0;
+
+    ErrorF("releasekeys: called on device %s (%d)\n", pDev->name, pDev->id);
+
+    if (!pDev || !pDev->key)
+        return;
+
+    keyc = pDev->key;
+    map = keyc->curKeySyms.map;
+
+    /*
+     * Hmm... here is the biggest hack of every time !
+     * It may be possible that a switch-vt procedure has finished BEFORE
+     * you released all keys neccessary to do this. That peculiar behavior
+     * can fool the X-server pretty much, cause it assumes that some keys
+     * were not released. TWM may stuck alsmost completly....
+     * OK, what we are doing here is after returning from the vt-switch
+     * exeplicitely unrelease all keyboard keys before the input-devices
+     * are reenabled.
+     */
+
+    for (i = keyc->curKeySyms.minKeyCode, map = keyc->curKeySyms.map;
+         i < keyc->curKeySyms.maxKeyCode;
+         i++, map += keyc->curKeySyms.mapWidth) {
+        ErrorF("key %d: pressed is %s\n", i, KeyPressed(i) ? "true" : "false");
+        if (KeyPressed(i)) {
+            switch (*map) {
+            /* Don't release the lock keys */
+            case XK_Caps_Lock:
+            case XK_Shift_Lock:
+            case XK_Num_Lock:
+            case XK_Scroll_Lock:
+            case XK_Kana_Lock:
+                break;
+            default:
+                if (pDev == inputInfo.keyboard) {
+                    ke.u.keyButtonPointer.time = GetTimeInMillis();
+                    ke.u.keyButtonPointer.rootX = 0;
+                    ke.u.keyButtonPointer.rootY = 0;
+                    ke.u.u.type = KeyRelease;
+                    ke.u.u.detail = i;
+                    (*pDev->public.processInputProc) (&ke, pDev, 1);
+                }
+                else {
+                    nevents = GetKeyboardEvents(&events, pDev, KeyRelease, i);
+                    ErrorF("device %s: got %d events for %d key\n", pDev->name, nevents, i);
+                    for (j = 0; j < nevents; j++)
+                        mieqEnqueue(events++);
+                }
+                break;
+            }
+        }
+    }
+}
+
 /*
  * xf86VTSwitch --
  *      Handle requests for switching the vt.
@@ -1515,7 +894,6 @@ xf86VTSwitch()
      * Keep the order: Disable Device > LeaveVT
      *                        EnterVT > EnableDevice 
      */
-    DisableDevice((DeviceIntPtr)xf86Info.pKeyboard);
     pInfo = xf86InputDevs;
     while (pInfo) {
       DisableDevice(pInfo->dev);
@@ -1556,12 +934,14 @@ xf86VTSwitch()
       SaveScreens(SCREEN_SAVER_FORCER, ScreenSaverReset);
 
 #if !defined(__UNIXOS2__)
-      EnableDevice((DeviceIntPtr)xf86Info.pKeyboard);
       pInfo = xf86InputDevs;
       while (pInfo) {
+        xf86ReleaseKeys(pInfo->dev);
 	EnableDevice(pInfo->dev);
 	pInfo = pInfo->next;
       }
+      /* XXX HACK */
+      xf86ReleaseKeys(inputInfo.keyboard);
 #endif /* !__UNIXOS2__ */
       for (ih = InputHandlers; ih; ih = ih->next)
         xf86EnableInputHandler(ih);
@@ -1618,12 +998,14 @@ xf86VTSwitch()
     SaveScreens(SCREEN_SAVER_FORCER,ScreenSaverReset);
 
 #if !defined(__UNIXOS2__)
-    EnableDevice((DeviceIntPtr)xf86Info.pKeyboard);
     pInfo = xf86InputDevs;
     while (pInfo) {
+      xf86ReleaseKeys(pInfo->dev);
       EnableDevice(pInfo->dev);
       pInfo = pInfo->next;
     }
+    /* XXX HACK */
+    xf86ReleaseKeys(inputInfo.keyboard);
 #endif /* !__UNIXOS2__ */
     
     for (ih = InputHandlers; ih; ih = ih->next)
@@ -1745,9 +1127,6 @@ xf86ReloadInputDevs(int sig)
   
   signal(sig, (void(*)(int))xf86ReloadInputDevs);
 
-  DisableDevice((DeviceIntPtr)xf86Info.pKeyboard);
-  EnableDevice((DeviceIntPtr)xf86Info.pKeyboard);
-
   pInfo = xf86InputDevs;
   while (pInfo) {
     DisableDevice(pInfo->dev);

hw/xfree86/common/xf86Globals.c

@@ -93,36 +93,11 @@ InputInfoPtr xf86InputDevs = NULL;
 /* Globals that video drivers may not access */
 
 xf86InfoRec xf86Info = {
-	NULL,		/* pKeyboard */
-	NULL,		/* kbdProc */
-	NULL,		/* kbdEvents */
 	-1,		/* consoleFd */
-	-1,		/* kbdFd */
 	-1,		/* vtno */
-	-1,		/* kbdType */
-	-1,		/* kbdRate */
-	-1, 		/* kbdDelay */
-	-1,		/* bell_pitch */
-	-1,		/* bell_duration */
-	TRUE,		/* autoRepeat */
-	0,		/* leds */
-	0,		/* xleds */
 	NULL,		/* vtinit */
-	0,		/* scanPrefix */
-	FALSE,		/* capsLock */
-	FALSE,		/* numLock */
-	FALSE,		/* scrollLock */
-	FALSE,		/* modeSwitchLock */
-	FALSE,		/* composeLock */
 	FALSE,		/* vtSysreq */
 	SKWhenNeeded,	/* ddxSpecialKeys */
-	FALSE,		/* ActionKeyBindingsSet */
-#if defined(SVR4) && defined(i386)
-	FALSE,		/* panix106 */
-#endif
-#if defined(__OpenBSD__) || defined(__NetBSD__)
-	0,		/* wskbdType */
-#endif
 	NULL,		/* pMouse */
 #ifdef XINPUT
 	NULL,		/* mouseLocal */
@@ -140,20 +115,6 @@ xf86InfoRec xf86Info = {
 #ifdef CSRG_BASED
 	-1,		/* screenFd */
 	-1,		/* consType */
-#endif
-#ifdef XKB
-	NULL,		/* xkbkeymap */
-	NULL,		/* xkbkeycodes */
-	NULL,		/* xkbtypes */
-	NULL,		/* xkbcompat */
-	NULL,		/* xkbsymbols */
-	NULL,		/* xkbgeometry */
-	FALSE,		/* xkbcomponents_specified */
-	NULL,		/* xkbrules */
-	NULL,		/* xkbmodel */
-	NULL,		/* xkblayout */
-	NULL,		/* xkbvariant */
-	NULL,		/* xkboptions */
 #endif
 	FALSE,		/* allowMouseOpenFail */
 	TRUE,		/* vidModeEnabled */

hw/xfree86/common/xf86Helper.c

@@ -141,6 +141,32 @@ xf86DeleteInputDriver(int drvIndex)
     xf86InputDriverList[drvIndex] = NULL;
 }
 
+InputDriverPtr
+xf86LookupInputDriver(const char *name)
+{
+    int i;
+
+    for (i = 0; i < xf86NumInputDrivers; i++) {
+       if (xf86InputDriverList[i] && xf86InputDriverList[i]->driverName &&
+           xf86NameCmp(name, xf86InputDriverList[i]->driverName) == 0)
+           return xf86InputDriverList[i];
+    }
+    return NULL;
+}
+
+InputInfoPtr
+xf86LookupInput(const char *name)
+{
+    InputInfoPtr p;
+
+    for (p = xf86InputDevs; p != NULL; p = p->next) {
+        if (strcmp(name, p->name) == 0)
+            return p;
+    }
+
+    return NULL;
+}
+
 _X_EXPORT void
 xf86AddModuleInfo(ModuleInfoPtr info, pointer module)
 {
@@ -2550,7 +2576,7 @@ xf86SetSilkenMouse (ScreenPtr pScreen)
     /*
      * XXX quick hack to report correctly for OSs that can't do SilkenMouse
      * yet.  Should handle this differently so that alternate async methods
-     * like Xqueue work correctly with this too.
+     * work correctly with this too.
      */
     pScrn->silkenMouse = useSM && xf86SIGIOSupported();
     if (serverGeneration == 1)

hw/xfree86/common/xf86InPriv.h

@@ -40,4 +40,7 @@ extern int xf86NumInputDrivers;
 /* xf86Xinput.c */
 void xf86ActivateDevice(InputInfoPtr pInfo);
 
+/* xf86Helper.c */
+InputDriverPtr xf86LookupInputDriver(const char *name);
+
 #endif /* _xf86InPriv_h */

hw/xfree86/common/xf86Init.c

@@ -135,18 +135,6 @@ static int numFormats = 6;
 #endif
 static Bool formatsDone = FALSE;
 
-#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
-static InputDriverRec XF86KEYBOARD = {
-	1,
-	"keyboard",
-	NULL,
-	NULL,
-	NULL,
-	NULL,
-	0
-};
-#endif
-
 static Bool
 xf86CreateRootWindow(WindowPtr pWin)
 {
@@ -409,10 +397,6 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
       xfree(modulelist);
     }
 
-#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
-    /* Setup the builtin input drivers */
-    xf86AddInputDriver(&XF86KEYBOARD, NULL, 0);
-#endif
     /* Load all input driver modules specified in the config file. */
     if ((modulelist = xf86InputDriverlistFromConfig())) {
       xf86LoadModules(modulelist, NULL);
@@ -984,21 +968,6 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
 				 NULL);
 }
 
-
-static InputDriverPtr
-MatchInput(IDevPtr pDev)
-{
-    int i;
-
-    for (i = 0; i < xf86NumInputDrivers; i++) {
-	if (xf86InputDriverList[i] && xf86InputDriverList[i]->driverName &&
-	    xf86NameCmp(pDev->driver, xf86InputDriverList[i]->driverName) == 0)
-	    return xf86InputDriverList[i];
-    }
-    return NULL;
-}
-
-
 /*
  * InitInput --
  *      Initialize all supported input devices.
@@ -1020,19 +989,7 @@ InitInput(argc, argv)
     if (serverGeneration == 1) {
 	/* Call the PreInit function for each input device instance. */
 	for (pDev = xf86ConfigLayout.inputs; pDev && pDev->identifier; pDev++) {
-#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
+	    if ((pDrv = xf86LookupInputDriver(pDev->driver)) == NULL) {
-	    /* XXX The keyboard driver is a special case for now. */
-	    if (!xf86NameCmp(pDev->driver, "keyboard")) {
-		xf86MsgVerb(X_WARNING, 0, "*** WARNING the legacy keyboard driver \"keyboard\" is deprecated\n");
-		xf86MsgVerb(X_WARNING, 0, "*** and will be removed in the next release of the Xorg server.\n");
-		xf86MsgVerb(X_WARNING, 0, "*** Please consider using the the new \"kbd\" driver for \"%s\".\n",
-			pDev->identifier);
-
-		continue;
-	    }
-#endif
-
-	    if ((pDrv = MatchInput(pDev)) == NULL) {
 		xf86Msg(X_ERROR, "No Input driver matching `%s'\n", pDev->driver);
 		/* XXX For now, just continue. */
 		continue;
@@ -1054,80 +1011,18 @@ InitInput(argc, argv)
 		xf86DeleteInput(pInfo, 0);
 		continue;
 	    }
-	    if (pInfo->flags & XI86_CORE_KEYBOARD) {
-		if (coreKeyboard) {
-		    xf86Msg(X_ERROR,
-		      "Attempt to register more than one core keyboard (%s)\n",
-		      pInfo->name);
-		    pInfo->flags &= ~XI86_CORE_KEYBOARD;
-		} else {
-		    if (!(pInfo->flags & XI86_KEYBOARD_CAPABLE)) {
-			/* XXX just a warning for now */
-			xf86Msg(X_WARNING,
-			    "%s: does not have core keyboard capabilities\n",
-			    pInfo->name);
-		    }
-		    coreKeyboard = pInfo;
-		}
-	    }
-	    if (pInfo->flags & XI86_CORE_POINTER) {
-		if (corePointer) {
-		    xf86Msg(X_ERROR,
-			"Attempt to register more than one core pointer (%s)\n",
-			pInfo->name);
-		    pInfo->flags &= ~XI86_CORE_POINTER;
-		} else {
-		    if (!(pInfo->flags & XI86_POINTER_CAPABLE)) {
-			/* XXX just a warning for now */
-			xf86Msg(X_WARNING,
-			    "%s: does not have core pointer capabilities\n",
-			    pInfo->name);
-		    }
-		    corePointer = pInfo;
-		}
-	    }
 	}
-	if (!corePointer) {
-	    xf86Msg(X_WARNING, "No core pointer registered\n");
-	    /* XXX register a dummy core pointer */
-	}
-#ifdef NEW_KBD
-	if (!coreKeyboard) {
-	    xf86Msg(X_WARNING, "No core keyboard registered\n");
-	    /* XXX register a dummy core keyboard */
-	}
-#endif
     }
 
     /* Initialise all input devices. */
     pInfo = xf86InputDevs;
     while (pInfo) {
+        xf86Msg(X_INFO, "evaluating device (%s)\n", pInfo->name);
 	xf86ActivateDevice(pInfo);
 	pInfo = pInfo->next;
     }
 
-    if (coreKeyboard) {
+    mieqInit();
-      xf86Info.pKeyboard = coreKeyboard->dev;
-      xf86Info.kbdEvents = NULL; /* to prevent the internal keybord driver usage*/
-    }
-    else {
-#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
-      /* Only set this if we're allowing the old driver. */
-	if (xf86Info.kbdProc != NULL) 
-	    xf86Info.pKeyboard = AddInputDevice(xf86Info.kbdProc, TRUE);
-#endif
-    }
-    if (corePointer)
-	xf86Info.pMouse = corePointer->dev;
-    if (xf86Info.pKeyboard)
-      RegisterKeyboardDevice(xf86Info.pKeyboard); 
-
-  miRegisterPointerDevice(screenInfo.screens[0], xf86Info.pMouse);
-#ifdef XINPUT
-  xf86eqInit ((DevicePtr)xf86Info.pKeyboard, (DevicePtr)xf86Info.pMouse);
-#else
-  mieqInit ((DevicePtr)xf86Info.pKeyboard, (DevicePtr)xf86Info.pMouse);
-#endif
 }
 
 #ifndef SET_STDERR_NONBLOCKING
@@ -1246,12 +1141,6 @@ AbortDDX()
 {
   int i;
 
-  /*
-   * try to deinitialize all input devices
-   */
-  if (xf86Info.kbdProc && xf86Info.pKeyboard)
-    (xf86Info.kbdProc)(xf86Info.pKeyboard, DEVICE_CLOSE);
-
   /*
    * try to restore the original video state
    */

hw/xfree86/common/xf86Io.c

@@ -1,470 +0,0 @@
-/*
- * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Thomas Roell not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Thomas Roell makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- *
- */
-/*
- * Copyright (c) 1992-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-/* $XConsortium: xf86Io.c /main/27 1996/10/19 17:58:55 kaleb $ */
-
-#define NEED_EVENTS
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "inputstr.h"
-#include "scrnintstr.h"
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#define XF86_OS_PRIVS
-#include "xf86_OSlib.h"
-#include "mipointer.h"
-
-#ifdef XINPUT
-#include "xf86Xinput.h"
-#include <X11/extensions/XIproto.h>
-#include "exevents.h"
-#endif
-
-#ifdef XKB
-#include <X11/extensions/XKB.h>
-#include <X11/extensions/XKBstr.h>
-#include <X11/extensions/XKBsrv.h>
-#endif
-
-unsigned int xf86InitialCaps = 0;
-unsigned int xf86InitialNum = 0;
-unsigned int xf86InitialScroll = 0;
-
-#include "atKeynames.h"
-
-/*
- * xf86KbdBell --
- *	Ring the terminal/keyboard bell for an amount of time proportional to
- *      "loudness".
- */
-
-void
-xf86KbdBell(percent, pKeyboard, ctrl, unused)
-     int           percent;          /* Percentage of full volume */
-     DeviceIntPtr  pKeyboard;        /* Keyboard to ring */
-     pointer	   ctrl;	
-     int	   unused;	
-{
-  xf86SoundKbdBell(percent, xf86Info.bell_pitch, xf86Info.bell_duration);
-}
-
-void
-xf86UpdateKbdLeds()
-{
-  int leds = 0;
-  if (xf86Info.capsLock) leds |= XLED1;
-  if (xf86Info.numLock)  leds |= XLED2;
-  if (xf86Info.scrollLock || xf86Info.modeSwitchLock) leds |= XLED3;
-  if (xf86Info.composeLock) leds |= XLED4;
-  xf86Info.leds = (xf86Info.leds & xf86Info.xleds) | (leds & ~xf86Info.xleds);
-  xf86KbdLeds();
-}
-
-void
-xf86KbdLeds ()
-{
-  int leds, real_leds = 0;
-
-#if defined (__sparc__) && defined(__linux__)
-  static int kbdSun = -1;
-  if (kbdSun == -1) {
-  if ((xf86Info.xkbmodel && !strcmp(xf86Info.xkbmodel, "sun")) ||
-      (xf86Info.xkbrules && !strcmp(xf86Info.xkbrules, "sun")))
-      kbdSun = 1;
-  else
-      kbdSun = 0;
-  }
-  if (kbdSun) {
-     if (xf86Info.leds & 0x08) real_leds |= XLED1;
-     if (xf86Info.leds & 0x04) real_leds |= XLED3;
-     if (xf86Info.leds & 0x02) real_leds |= XLED4;
-     if (xf86Info.leds & 0x01) real_leds |= XLED2;
-     leds = real_leds;
-     real_leds = 0;
-  } else {
-     leds = xf86Info.leds;
-  }
-#else
-  leds = xf86Info.leds;
-#endif /* defined (__sparc__) */
-
-#ifdef LED_CAP
-  if (leds & XLED1)  real_leds |= LED_CAP;
-  if (leds & XLED2)  real_leds |= LED_NUM;
-  if (leds & XLED3)  real_leds |= LED_SCR;
-#ifdef LED_COMP
-  if (leds & XLED4)  real_leds |= LED_COMP;
-#else
-  if (leds & XLED4)  real_leds |= LED_SCR;
-#endif
-#endif
-#ifdef sun
-  /* Pass through any additional LEDs, such as Kana LED on Sun Japanese kbd */
-  real_leds |= (leds & 0xFFFFFFF0);
-#endif
-  xf86SetKbdLeds(real_leds);
-  (void)leds;
-}
-
-/*
- * xf86KbdCtrl --
- *      Alter some of the keyboard control parameters. All special protocol
- *      values are handled by dix (ProgChangeKeyboardControl)
- */
-
-void
-xf86KbdCtrl (pKeyboard, ctrl)
-     DevicePtr     pKeyboard;        /* Keyboard to alter */
-     KeybdCtrl     *ctrl;
-{
-  int leds;
-  xf86Info.bell_pitch    = ctrl->bell_pitch;
-  xf86Info.bell_duration = ctrl->bell_duration;
-  xf86Info.autoRepeat    = ctrl->autoRepeat;
-
-  xf86Info.composeLock   = (ctrl->leds & XCOMP) ? TRUE : FALSE;
-
-  leds = (ctrl->leds & ~(XCAPS | XNUM | XSCR));
-#ifdef XKB
-  if (noXkbExtension) {
-#endif
-      xf86Info.leds = (leds & xf86Info.xleds)|(xf86Info.leds & ~xf86Info.xleds);
-#ifdef XKB
-  } else {
-      xf86Info.leds = leds;
-  }
-#endif
-
-  xf86KbdLeds();
-}
-
-/*
- * xf86InitKBD --
- *      Reinitialize the keyboard. Only set Lockkeys according to ours leds.
- *      Depress all other keys.
- */
-
-void
-xf86InitKBD(init)
-Bool init;
-{
-  char            leds = 0, rad;
-  unsigned int    i;
-  xEvent          kevent;
-  DeviceIntPtr    pKeyboard = xf86Info.pKeyboard;
-  KeyClassRec     *keyc = xf86Info.pKeyboard->key;
-  KeySym          *map = keyc->curKeySyms.map;
-
-  kevent.u.keyButtonPointer.time = GetTimeInMillis();
-  kevent.u.keyButtonPointer.rootX = 0;
-  kevent.u.keyButtonPointer.rootY = 0;
-
-  /*
-   * Hmm... here is the biggest hack of every time !
-   * It may be possible that a switch-vt procedure has finished BEFORE
-   * you released all keys neccessary to do this. That peculiar behavior
-   * can fool the X-server pretty much, cause it assumes that some keys
-   * were not released. TWM may stuck alsmost completly....
-   * OK, what we are doing here is after returning from the vt-switch
-   * exeplicitely unrelease all keyboard keys before the input-devices
-   * are reenabled.
-   */
-  for (i = keyc->curKeySyms.minKeyCode, map = keyc->curKeySyms.map;
-       i < keyc->curKeySyms.maxKeyCode;
-       i++, map += keyc->curKeySyms.mapWidth)
-    if (KeyPressed(i))
-      {
-        switch (*map) {
-	/* Don't release the lock keys */
-        case XK_Caps_Lock:
-        case XK_Shift_Lock:
-        case XK_Num_Lock:
-        case XK_Scroll_Lock:
-        case XK_Kana_Lock:
-	  break;
-        default:
-	  kevent.u.u.detail = i;
-	  kevent.u.u.type = KeyRelease;
-	  (* pKeyboard->public.processInputProc)(&kevent, pKeyboard, 1);
-        }
-      }
-  
-  xf86Info.scanPrefix      = 0;
-
-  if (init)
-    {
-      /*
-       * we must deal here with the fact, that on some cases the numlock or
-       * capslock key are enabled BEFORE the server is started up. So look
-       * here at the state on the according LEDS to determine whether a
-       * lock-key is already set.
-       */
-
-      xf86Info.capsLock        = FALSE;
-      xf86Info.numLock         = FALSE;
-      xf86Info.scrollLock      = FALSE;
-      xf86Info.modeSwitchLock  = FALSE;
-      xf86Info.composeLock     = FALSE;
-    
-#ifdef LED_CAP
-#ifdef INHERIT_LOCK_STATE
-      leds = xf86Info.leds;
-
-      for (i = keyc->curKeySyms.minKeyCode, map = keyc->curKeySyms.map;
-           i < keyc->curKeySyms.maxKeyCode;
-           i++, map += keyc->curKeySyms.mapWidth)
-
-        switch(*map) {
-
-        case XK_Caps_Lock:
-        case XK_Shift_Lock:
-          if (leds & LED_CAP) 
-	    {
-	      xf86InitialCaps = i;
-	      xf86Info.capsLock = TRUE;
-	    }
-          break;
-
-        case XK_Num_Lock:
-          if (leds & LED_NUM)
-	    {
-	      xf86InitialNum = i;
-	      xf86Info.numLock = TRUE;
-	    }
-          break;
-
-        case XK_Scroll_Lock:
-        case XK_Kana_Lock:
-          if (leds & LED_SCR)
-	    {
-	      xf86InitialScroll = i;
-	      xf86Info.scrollLock = TRUE;
-	    }
-          break;
-        }
-#endif /* INHERIT_LOCK_STATE */
-      xf86SetKbdLeds(leds);
-#endif /* LED_CAP */
-      (void)leds;
-
-      if      (xf86Info.kbdDelay <= 375) rad = 0x00;
-      else if (xf86Info.kbdDelay <= 625) rad = 0x20;
-      else if (xf86Info.kbdDelay <= 875) rad = 0x40;
-      else                               rad = 0x60;
-    
-      if      (xf86Info.kbdRate <=  2)   rad |= 0x1F;
-      else if (xf86Info.kbdRate >= 30)   rad |= 0x00;
-      else                               rad |= ((58 / xf86Info.kbdRate) - 2);
-    
-      xf86SetKbdRepeat(rad);
-    }
-}
-
-/*
- * xf86KbdProc --
- *	Handle the initialization, etc. of a keyboard.
- */
-
-int
-xf86KbdProc (pKeyboard, what)
-     DeviceIntPtr pKeyboard;	/* Keyboard to manipulate */
-     int       what;	    	/* What to do to it */
-{
-  KeySymsRec           keySyms;
-  CARD8                modMap[MAP_LENGTH];
-  int                  kbdFd;
-
-  switch (what) {
-
-  case DEVICE_INIT:
-    /*
-     * First open and find the current state of the keyboard.
-     */
-
-    xf86KbdInit();
-
-    xf86KbdGetMapping(&keySyms, modMap);
-    
-
-#ifndef XKB
-    defaultKeyboardControl.leds = xf86GetKbdLeds();
-#else
-    defaultKeyboardControl.leds = 0;
-#endif
-
-    /*
-     * Perform final initialization of the system private keyboard
-     * structure and fill in various slots in the device record
-     * itself which couldn't be filled in before.
-     */
-
-    pKeyboard->public.on = FALSE;
-
-#ifdef XKB
-    if (noXkbExtension) {
-#endif
-    InitKeyboardDeviceStruct((DevicePtr)xf86Info.pKeyboard,
-			     &keySyms,
-			     modMap,
-			     xf86KbdBell,
-			     (KbdCtrlProcPtr)xf86KbdCtrl);
-#ifdef XKB
-    } else {
- 	XkbComponentNamesRec	names;
-	XkbDescPtr		desc;
-	Bool			foundTerminate = FALSE;
-	int			keyc;
-	if (xf86Info.xkbkeymap) {
-	    names.keymap = xf86Info.xkbkeymap;
-	    names.keycodes = NULL;
-	    names.types = NULL;
-	    names.compat = NULL;
-	    names.symbols = NULL;
-	    names.geometry = NULL;
-	} else {
-	    names.keymap = NULL;
-	    names.keycodes = xf86Info.xkbkeycodes;
-	    names.types = xf86Info.xkbtypes;
-	    names.compat = xf86Info.xkbcompat;
-	    names.symbols = xf86Info.xkbsymbols;
-	    names.geometry = xf86Info.xkbgeometry;
-	}
-	if ((xf86Info.xkbkeymap || xf86Info.xkbcomponents_specified)
-	   && (xf86Info.xkbmodel == NULL || xf86Info.xkblayout == NULL)) {
-		xf86Info.xkbrules = NULL;
-	}
-	XkbSetRulesDflts(xf86Info.xkbrules, xf86Info.xkbmodel,
-			 xf86Info.xkblayout, xf86Info.xkbvariant,
-			 xf86Info.xkboptions);
-	
-	XkbInitKeyboardDeviceStruct(pKeyboard, 
-				    &names,
-				    &keySyms, 
-				    modMap, 
-				    xf86KbdBell,
-				    (KbdCtrlProcPtr)xf86KbdCtrl);
-
-	/* Search keymap for Terminate action */
-	desc  = pKeyboard->key->xkbInfo->desc;
-	for (keyc = desc->min_key_code; keyc <= desc->max_key_code; keyc++) {
-	    int i;
-	    for (i = 1; i <= XkbKeyNumActions(desc, keyc); i++) {
-		if (XkbKeyAction(desc, keyc, i)
-		  && XkbKeyAction(desc, keyc, i)->type == XkbSA_Terminate) {
-		    foundTerminate = TRUE;
-		    goto searchdone;
-		}
-	    }
-  	}
-searchdone:
-	xf86Info.ActionKeyBindingsSet = foundTerminate;
-	if (!foundTerminate)
-	    xf86Msg(X_INFO, "Server_Terminate keybinding not found\n");
-    }
-#endif
-    
-    xf86InitKBD(TRUE);
-    break;
-    
-  case DEVICE_ON:
-    /*
-     * Set the keyboard into "direct" mode and turn on
-     * event translation.
-     */
-
-    kbdFd = xf86KbdOn();
-    /*
-     * Discard any pending input after a VT switch to prevent the server
-     * passing on parts of the VT switch sequence.
-     */
-    sleep(1);
-#if defined(WSCONS_SUPPORT)
-    if (xf86Info.consType != WSCONS) {
-#endif
-	if (kbdFd != -1) {
-		char buf[16];
-		read(kbdFd, buf, 16);
-    	}
-#if defined(WSCONS_SUPPORT)
-    }
-#endif
-
-#if !defined(__UNIXOS2__) /* Under EMX, keyboard cannot be select()'ed */
-    if (kbdFd != -1)
-      AddEnabledDevice(kbdFd);
-#endif  /* __UNIXOS2__ */
-
-    pKeyboard->public.on = TRUE;
-    xf86InitKBD(FALSE);
-    break;
-    
-  case DEVICE_CLOSE:
-  case DEVICE_OFF:
-    /*
-     * Restore original keyboard directness and translation.
-     */
-
-    kbdFd = xf86KbdOff();
-
-    if (kbdFd != -1)
-      RemoveEnabledDevice(kbdFd);
-
-    pKeyboard->public.on = FALSE;
-    break;
-
-  }
-  return (Success);
-}

hw/xfree86/common/xf86Kbd.c

@@ -1,394 +0,0 @@
-/*
- * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Thomas Roell not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Thomas Roell makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- *
- */
-/*
- * Copyright (c) 1992-2003 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-/* $XConsortium: xf86Kbd.c /main/10 1996/02/21 17:38:32 kaleb $ */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#ifdef __UNIXOS2__
-#define I_NEED_OS2_H
-#endif
-
-#include <X11/X.h>
-#include <X11/Xmd.h>
-#include "input.h"
-#include "scrnintstr.h"
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-#include "atKeynames.h"
-#include "xf86Config.h"
-
-#include "xf86Keymap.h"
-
-#if defined(KDGKBTYPE) && \
-	!defined(Lynx) && \
-	!defined(__UNIXOS2__) && !defined(__mips__) && \
-	!defined(__arm32__) && !defined(__GNU__) && !defined(__QNX__)
-#define HAS_GETKBTYPE
-#endif
-#if defined(GIO_KEYMAP) && \
-	!defined(Lynx) && \
-	!defined(__UNIXOS2__) && !defined(__mips__) && \
-	!defined(__arm32__) && !defined(__GNU__) && !defined(DGUX) && \
-	!defined(__QNX__)
-#define HAS_GETKEYMAP
-
-#define KD_GET_ENTRY(i,n) \
-  eascii_to_x[((keymap.key[i].spcl << (n+1)) & 0x100) + keymap.key[i].map[n]]
-
-/*
- * NOTE: Not all possible remappable symbols are remapped. There are two main
- *       reasons:
- *                 a) The mapping between scancode and SYSV/386 - symboltable
- *                    is inconsistent between different versions and has some
- *                    BIG mistakes.
- *                 b) In X-Windows there is a difference between numpad-keys
- *                    and normal keys. SYSV/386 uses for both kinds of keys
- *                    the same symbol.
- *
- *       Thus only the alpha keypad and the function keys are translated.
- *       Also CapsLock, NumLock, ScrollLock, Shift, Control & Alt.
- */
-
-static unsigned char remap[128] = {
-     0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* 0x00 - 0x07 */
-  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,   /* 0x08 - 0x0f */
-  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,   /* 0x10 - 0x17 */
-  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,   /* 0x18 - 0x1f */
-  0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,   /* 0x20 - 0x27 */
-  0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,   /* 0x28 - 0x2f */
-  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,    0,   /* 0x30 - 0x37 */
-  0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,   /* 0x38 - 0x3f */
-  0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,    0,   /* 0x40 - 0x47 */
-     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x48 - 0x4f */
-     0,    0,    0,    0,    0,    0, 0x56, 0x57,   /* 0x50 - 0x57 */
-  0x58,    0,    0,    0,    0,    0,    0,    0,   /* 0x58 - 0x5f */
-     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x60 - 0x67 */
-     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x68 - 0x6f */
-     0,    0, 0x69, 0x65,    0,    0,    0,    0,   /* 0x70 - 0x77 */
-     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x78 - 0x7f */
-};
-
-static KeySym eascii_to_x[512] = {
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_BackSpace,	XK_Tab,		XK_Linefeed,	NoSymbol,
-	NoSymbol,	XK_Return,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	XK_Escape,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_space,	XK_exclam,	XK_quotedbl,	XK_numbersign,
-	XK_dollar,	XK_percent,	XK_ampersand,	XK_apostrophe,
-	XK_parenleft,	XK_parenright,	XK_asterisk,	XK_plus,
-	XK_comma,	XK_minus,	XK_period,	XK_slash,
-	XK_0,		XK_1,		XK_2,		XK_3,
-	XK_4,		XK_5,		XK_6,		XK_7,
-	XK_8,		XK_9,		XK_colon,	XK_semicolon,
-	XK_less,	XK_equal,	XK_greater,	XK_question,
-	XK_at,		XK_A,		XK_B,		XK_C,
-	XK_D,		XK_E,		XK_F,		XK_G,
-	XK_H,		XK_I,		XK_J,		XK_K,
-	XK_L,		XK_M,		XK_N,		XK_O,
-	XK_P,		XK_Q,		XK_R,		XK_S,
-	XK_T,		XK_U,		XK_V,		XK_W,
-	XK_X,		XK_Y,		XK_Z,		XK_bracketleft,
-	XK_backslash,	XK_bracketright,XK_asciicircum,	XK_underscore,
-	XK_grave,	XK_a,		XK_b,		XK_c,
-	XK_d,		XK_e,		XK_f,		XK_g,
-	XK_h,		XK_i,		XK_j,		XK_k,
-	XK_l,		XK_m,		XK_n,		XK_o,
-	XK_p,		XK_q,		XK_r,		XK_s,
-	XK_t,		XK_u,		XK_v,		XK_w,
-	XK_x,		XK_y,		XK_z,		XK_braceleft,
-	XK_bar,		XK_braceright,	XK_asciitilde,	XK_Delete,
-	XK_Ccedilla,	XK_udiaeresis,	XK_eacute,	XK_acircumflex,
-	XK_adiaeresis,	XK_agrave,	XK_aring,	XK_ccedilla,
-	XK_ecircumflex,	XK_ediaeresis,	XK_egrave,	XK_idiaeresis,
-	XK_icircumflex,	XK_igrave,	XK_Adiaeresis,	XK_Aring,
-	XK_Eacute,	XK_ae,		XK_AE,		XK_ocircumflex,
-	XK_odiaeresis,	XK_ograve,	XK_ucircumflex,	XK_ugrave,
-	XK_ydiaeresis,	XK_Odiaeresis,	XK_Udiaeresis,	XK_cent,
-	XK_sterling,	XK_yen,		XK_paragraph,	XK_section,
-	XK_aacute,	XK_iacute,	XK_oacute,	XK_uacute,
-	XK_ntilde,	XK_Ntilde,	XK_ordfeminine,	XK_masculine,
-	XK_questiondown,XK_hyphen,	XK_notsign,	XK_onehalf,
-	XK_onequarter,	XK_exclamdown,	XK_guillemotleft,XK_guillemotright,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_Greek_alpha,	XK_ssharp,	XK_Greek_GAMMA,	XK_Greek_pi,
-	XK_Greek_SIGMA,	XK_Greek_sigma,	XK_mu,	        XK_Greek_tau,
-	XK_Greek_PHI,	XK_Greek_THETA,	XK_Greek_OMEGA,	XK_Greek_delta,
-	XK_infinity,	XK_Ooblique,	XK_Greek_epsilon, XK_intersection,
-	XK_identical,	XK_plusminus,	XK_greaterthanequal, XK_lessthanequal,
-	XK_topintegral,	XK_botintegral,	XK_division,	XK_similarequal,
-	XK_degree,	NoSymbol,	NoSymbol,	XK_radical,
-	XK_Greek_eta,	XK_twosuperior,	XK_periodcentered, NoSymbol,
-
-	/* 
-	 * special marked entries (256 + x)
-	 */
-
-	NoSymbol,	NoSymbol,	XK_Shift_L,	XK_Shift_R,
-	XK_Caps_Lock,	XK_Num_Lock,	XK_Scroll_Lock,	XK_Alt_L,
-	NoSymbol,	XK_Control_L,	XK_Alt_L,	XK_Alt_R,
-	XK_Control_L,	XK_Control_R,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	XK_F1,
-	XK_F2,		XK_F3,		XK_F4,		XK_F5,
-	XK_F6,		XK_F7,		XK_F8,		XK_F9,
-	XK_F10,		XK_F11,		XK_F12,		NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-      };
-
-#endif /* HAS_GETKEYMAP */
-
-/*
- * LegalModifier --
- *      determine whether a key is a legal modifier key, i.e send a
- *      press/release sequence.
- */
-
-/*ARGSUSED*/
-Bool
-LegalModifier(key, pDev)
-     unsigned int  key;
-     DevicePtr	pDev;
-{
-  return (TRUE);
-}
-
-
-      
-/*
- * xf86KbdGetMapping --
- *	Get the national keyboard mapping. The keyboard type is set, a new map
- *      and the modifiermap is computed.
- */
-
-void
-xf86KbdGetMapping (pKeySyms, pModMap)
-     KeySymsPtr pKeySyms;
-     CARD8      *pModMap;
-{
-  KeySym        *k;
-#ifdef HAS_GETKEYMAP
-  keymap_t      keymap;
-#endif
-  int           i;
-  KeySym        *pMap;
-
-#ifdef HAS_GETKBTYPE
-  char          type;
-  
-  xf86Info.kbdType =
-    ioctl(xf86Info.consoleFd, KDGKBTYPE, &type) != -1 ? type : KB_101;
-  if (xf86Info.kbdType == KB_84)
-    pMap = map84;
-  else
-    pMap = map;
-#else
-/* OS/2 sets the keyboard type during xf86OpenKbd */
-#ifndef __UNIXOS2__
-  xf86Info.kbdType = 0;
-#endif
-  pMap = map;
-#endif
-
-#ifdef HAS_GETKEYMAP
-  /*
-   * use the keymap, which can be gotten from our oringinal vt??.
-   * ( ttymap(1) !!!! )
-   */
-  if (ioctl(xf86Info.consoleFd, GIO_KEYMAP, &keymap) != -1) {
-    for (i = 0; i < keymap.n_keys && i < NUM_KEYCODES; i++)
-      
-      if (remap[i]) {
-	
-	k = pMap + (remap[i] << 2);
-	
-	k[0] = KD_GET_ENTRY(i,0);             /* non-shifed */
-	k[1] = KD_GET_ENTRY(i,1);	      /* shifted */
-	k[2] = KD_GET_ENTRY(i,4);	      /* alt */
-	k[3] = KD_GET_ENTRY(i,5);	      /* alt - shifted */
-
-	if (k[3] == k[2]) k[3] = NoSymbol;
-	if (k[2] == k[1]) k[2] = NoSymbol;
-	if (k[1] == k[0]) k[1] = NoSymbol;
-	if (k[0] == k[2] && k[1] == k[3]) k[2] = k[3] = NoSymbol;
-      }
-  }
-#endif
-
-  /*
-   * compute the modifier map
-   */
-  for (i = 0; i < MAP_LENGTH; i++)
-    pModMap[i] = NoSymbol;  /* make sure it is restored */
-  
-  for (k = pMap, i = MIN_KEYCODE;
-       i < (NUM_KEYCODES + MIN_KEYCODE);
-       i++, k += 4)
-    
-    switch(*k) {
-      
-    case XK_Shift_L:
-    case XK_Shift_R:
-      pModMap[i] = ShiftMask;
-      break;
-      
-    case XK_Control_L:
-    case XK_Control_R:
-      pModMap[i] = ControlMask;
-      break;
-      
-    case XK_Caps_Lock:
-      pModMap[i] = LockMask;
-      break;
-      
-    case XK_Alt_L:
-    case XK_Alt_R:
-      pModMap[i] = AltMask;
-      break;
-      
-    case XK_Num_Lock:
-      pModMap[i] = NumLockMask;
-      break;
-
-    case XK_Scroll_Lock:
-      pModMap[i] = ScrollLockMask;
-      break;
-
-      /* kana support */
-    case XK_Kana_Lock:
-    case XK_Kana_Shift:
-      pModMap[i] = KanaMask;
-      break;
-
-      /* alternate toggle for multinational support */
-    case XK_Mode_switch:
-      pModMap[i] = AltLangMask;
-      break;
-
-    }
-  
-  pKeySyms->map        = pMap;
-  pKeySyms->mapWidth   = GLYPHS_PER_KEY;
-  pKeySyms->minKeyCode = MIN_KEYCODE;
-  pKeySyms->maxKeyCode = MAX_KEYCODE;
-}

hw/xfree86/common/xf86KbdLnx.c

@@ -1,650 +0,0 @@
-/*
- * Linux version of keymapping setup. The kernel (since 0.99.14) has support
- * for fully remapping the keyboard, but there are some differences between
- * the Linux map and the SVR4 map (esp. in the extended keycodes). We also
- * remove the restriction on what keycodes can be remapped.
- * Orest Zborowski.
- */
-/*
- * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Thomas Roell not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Thomas Roell makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- *
- */
-/*
- * Copyright (c) 1994-2001 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-/* $XConsortium: xf86KbdLnx.c /main/7 1996/10/19 17:59:00 kaleb $ */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xmd.h>
-#include "input.h"
-#include "scrnintstr.h"
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-#include "atKeynames.h"
-
-#include "xf86Keymap.h"
-
-/*
- * LegalModifier --
- *      determine whether a key is a legal modifier key, i.e send a
- *      press/release sequence.
- */
-
-/*ARGSUSED*/
-Bool
-LegalModifier(unsigned int key, DevicePtr pDev)
-{
-  return (TRUE);
-}
-
-/*
- * xf86KbdGetMapping --
- *	Get the national keyboard mapping. The keyboard type is set, a new map
- *      and the modifiermap is computed.
- */
-
-static void readKernelMapping(KeySymsPtr pKeySyms, CARD8 *pModMap);
-
-void
-xf86KbdGetMapping (KeySymsPtr pKeySyms, CARD8 *pModMap)
-{
-  KeySym        *k;
-  char          type;
-  int           i;
-
-  readKernelMapping(pKeySyms, pModMap);
-
-  /*
-   * compute the modifier map
-   */
-  for (i = 0; i < MAP_LENGTH; i++)
-    pModMap[i] = NoSymbol;  /* make sure it is restored */
-  
-  for (k = map, i = MIN_KEYCODE;
-       i < (NUM_KEYCODES + MIN_KEYCODE);
-       i++, k += 4)
-    
-    switch(*k) {
-      
-    case XK_Shift_L:
-    case XK_Shift_R:
-      pModMap[i] = ShiftMask;
-      break;
-      
-    case XK_Control_L:
-    case XK_Control_R:
-      pModMap[i] = ControlMask;
-      break;
-      
-    case XK_Caps_Lock:
-      pModMap[i] = LockMask;
-      break;
-      
-    case XK_Alt_L:
-    case XK_Alt_R:
-      pModMap[i] = AltMask;
-      break;
-      
-    case XK_Num_Lock:
-      pModMap[i] = NumLockMask;
-      break;
-
-    case XK_Scroll_Lock:
-      pModMap[i] = ScrollLockMask;
-      break;
-
-      /* kana support */
-    case XK_Kana_Lock:
-    case XK_Kana_Shift:
-      pModMap[i] = KanaMask;
-      break;
-
-      /* alternate toggle for multinational support */
-    case XK_Mode_switch:
-      pModMap[i] = AltLangMask;
-      break;
-
-    }
-  
-  xf86Info.kbdType =
-    ioctl(xf86Info.consoleFd, KDGKBTYPE, &type) != -1 ? type : KB_101;
-
-  pKeySyms->map        = map;
-  pKeySyms->mapWidth   = GLYPHS_PER_KEY;
-  pKeySyms->minKeyCode = MIN_KEYCODE;
-  pKeySyms->maxKeyCode = MAX_KEYCODE; 
-}
-
-#include <linux/keyboard.h>
-
-static KeySym linux_to_x[256] = {
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_BackSpace,	XK_Tab,		XK_Linefeed,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	XK_Escape,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_space,	XK_exclam,	XK_quotedbl,	XK_numbersign,
-	XK_dollar,	XK_percent,	XK_ampersand,	XK_apostrophe,
-	XK_parenleft,	XK_parenright,	XK_asterisk,	XK_plus,
-	XK_comma,	XK_minus,	XK_period,	XK_slash,
-	XK_0,		XK_1,		XK_2,		XK_3,
-	XK_4,		XK_5,		XK_6,		XK_7,
-	XK_8,		XK_9,		XK_colon,	XK_semicolon,
-	XK_less,	XK_equal,	XK_greater,	XK_question,
-	XK_at,		XK_A,		XK_B,		XK_C,
-	XK_D,		XK_E,		XK_F,		XK_G,
-	XK_H,		XK_I,		XK_J,		XK_K,
-	XK_L,		XK_M,		XK_N,		XK_O,
-	XK_P,		XK_Q,		XK_R,		XK_S,
-	XK_T,		XK_U,		XK_V,		XK_W,
-	XK_X,		XK_Y,		XK_Z,		XK_bracketleft,
-	XK_backslash,	XK_bracketright,XK_asciicircum,	XK_underscore,
-	XK_grave,	XK_a,		XK_b,		XK_c,
-	XK_d,		XK_e,		XK_f,		XK_g,
-	XK_h,		XK_i,		XK_j,		XK_k,
-	XK_l,		XK_m,		XK_n,		XK_o,
-	XK_p,		XK_q,		XK_r,		XK_s,
-	XK_t,		XK_u,		XK_v,		XK_w,
-	XK_x,		XK_y,		XK_z,		XK_braceleft,
-	XK_bar,		XK_braceright,	XK_asciitilde,	XK_BackSpace,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_nobreakspace,XK_exclamdown,	XK_cent,	XK_sterling,
-	XK_currency,	XK_yen,		XK_brokenbar,	XK_section,
-	XK_diaeresis,	XK_copyright,	XK_ordfeminine,	XK_guillemotleft,
-	XK_notsign,	XK_hyphen,	XK_registered,	XK_macron,
-	XK_degree,	XK_plusminus,	XK_twosuperior,	XK_threesuperior,
-	XK_acute,	XK_mu,		XK_paragraph,	XK_periodcentered,
-	XK_cedilla,	XK_onesuperior,	XK_masculine,	XK_guillemotright,
-	XK_onequarter,	XK_onehalf,	XK_threequarters,XK_questiondown,
-	XK_Agrave,	XK_Aacute,	XK_Acircumflex,	XK_Atilde,
-	XK_Adiaeresis,	XK_Aring,	XK_AE,		XK_Ccedilla,
-	XK_Egrave,	XK_Eacute,	XK_Ecircumflex,	XK_Ediaeresis,
-	XK_Igrave,	XK_Iacute,	XK_Icircumflex,	XK_Idiaeresis,
-	XK_ETH,		XK_Ntilde,	XK_Ograve,	XK_Oacute,
-	XK_Ocircumflex,	XK_Otilde,	XK_Odiaeresis,	XK_multiply,
-	XK_Ooblique,	XK_Ugrave,	XK_Uacute,	XK_Ucircumflex,
-	XK_Udiaeresis,	XK_Yacute,	XK_THORN,	XK_ssharp,
-	XK_agrave,	XK_aacute,	XK_acircumflex,	XK_atilde,
-	XK_adiaeresis,	XK_aring,	XK_ae,		XK_ccedilla,
-	XK_egrave,	XK_eacute,	XK_ecircumflex,	XK_ediaeresis,
-	XK_igrave,	XK_iacute,	XK_icircumflex,	XK_idiaeresis,
-	XK_eth,		XK_ntilde,	XK_ograve,	XK_oacute,
-	XK_ocircumflex,	XK_otilde,	XK_odiaeresis,	XK_division,
-	XK_oslash,	XK_ugrave,	XK_uacute,	XK_ucircumflex,
-	XK_udiaeresis,	XK_yacute,	XK_thorn,	XK_ydiaeresis
-};
-
-/*
- * Maps the AT keycodes to Linux keycodes
- */
-static unsigned char at2lnx[NUM_KEYCODES] =
-{
-	0x01,	/* KEY_Escape */	0x02,	/* KEY_1 */
-	0x03,	/* KEY_2 */		0x04,	/* KEY_3 */
-	0x05,	/* KEY_4 */		0x06,	/* KEY_5 */
-	0x07,	/* KEY_6 */		0x08,	/* KEY_7 */
-	0x09,	/* KEY_8 */		0x0a,	/* KEY_9 */
-	0x0b,	/* KEY_0 */		0x0c,	/* KEY_Minus */
-	0x0d,	/* KEY_Equal */		0x0e,	/* KEY_BackSpace */
-	0x0f,	/* KEY_Tab */		0x10,	/* KEY_Q */
-	0x11,	/* KEY_W */		0x12,	/* KEY_E */
-	0x13,	/* KEY_R */		0x14,	/* KEY_T */
-	0x15,	/* KEY_Y */		0x16,	/* KEY_U */
-	0x17,	/* KEY_I */		0x18,	/* KEY_O */
-	0x19,	/* KEY_P */		0x1a,	/* KEY_LBrace */
-	0x1b,	/* KEY_RBrace */	0x1c,	/* KEY_Enter */
-	0x1d,	/* KEY_LCtrl */		0x1e,	/* KEY_A */
-	0x1f,	/* KEY_S */		0x20,	/* KEY_D */
-	0x21,	/* KEY_F */		0x22,	/* KEY_G */
-	0x23,	/* KEY_H */		0x24,	/* KEY_J */
-	0x25,	/* KEY_K */		0x26,	/* KEY_L */
-	0x27,	/* KEY_SemiColon */	0x28,	/* KEY_Quote */
-	0x29,	/* KEY_Tilde */		0x2a,	/* KEY_ShiftL */
-	0x2b,	/* KEY_BSlash */	0x2c,	/* KEY_Z */
-	0x2d,	/* KEY_X */		0x2e,	/* KEY_C */
-	0x2f,	/* KEY_V */		0x30,	/* KEY_B */
-	0x31,	/* KEY_N */		0x32,	/* KEY_M */
-	0x33,	/* KEY_Comma */		0x34,	/* KEY_Period */
-	0x35,	/* KEY_Slash */		0x36,	/* KEY_ShiftR */
-	0x37,	/* KEY_KP_Multiply */	0x38,	/* KEY_Alt */
-	0x39,	/* KEY_Space */		0x3a,	/* KEY_CapsLock */
-	0x3b,	/* KEY_F1 */		0x3c,	/* KEY_F2 */
-	0x3d,	/* KEY_F3 */		0x3e,	/* KEY_F4 */
-	0x3f,	/* KEY_F5 */		0x40,	/* KEY_F6 */
-	0x41,	/* KEY_F7 */		0x42,	/* KEY_F8 */
-	0x43,	/* KEY_F9 */		0x44,	/* KEY_F10 */
-	0x45,	/* KEY_NumLock */	0x46,	/* KEY_ScrollLock */
-	0x47,	/* KEY_KP_7 */		0x48,	/* KEY_KP_8 */
-	0x49,	/* KEY_KP_9 */		0x4a,	/* KEY_KP_Minus */
-	0x4b,	/* KEY_KP_4 */		0x4c,	/* KEY_KP_5 */
-	0x4d,	/* KEY_KP_6 */		0x4e,	/* KEY_KP_Plus */
-	0x4f,	/* KEY_KP_1 */		0x50,	/* KEY_KP_2 */
-	0x51,	/* KEY_KP_3 */		0x52,	/* KEY_KP_0 */
-	0x53,	/* KEY_KP_Decimal */	0x54,	/* KEY_SysReqest */
-	0x00,	/* 0x55 */		0x56,	/* KEY_Less */
-	0x57,	/* KEY_F11 */		0x58,	/* KEY_F12 */
-	0x66,	/* KEY_Home */		0x67,	/* KEY_Up */
-	0x68,	/* KEY_PgUp */		0x69,	/* KEY_Left */
-	0x5d,	/* KEY_Begin */		0x6a,	/* KEY_Right */
-	0x6b,	/* KEY_End */		0x6c,	/* KEY_Down */
-	0x6d,	/* KEY_PgDown */	0x6e,	/* KEY_Insert */
-	0x6f,	/* KEY_Delete */	0x60,	/* KEY_KP_Enter */
-	0x61,	/* KEY_RCtrl */		0x77,	/* KEY_Pause */
-	0x63,	/* KEY_Print */		0x62,	/* KEY_KP_Divide */
-	0x64,	/* KEY_AltLang */	0x65,	/* KEY_Break */
-	0x00,	/* KEY_LMeta */		0x00,	/* KEY_RMeta */
-	0x7A,	/* KEY_Menu/FOCUS_PF11*/0x00,	/* 0x6e */
-	0x7B,	/* FOCUS_PF12 */	0x00,	/* 0x70 */
-	0x00,	/* 0x71 */		0x00,	/* 0x72 */
-	0x59,	/* FOCUS_PF2 */		0x78,	/* FOCUS_PF9 */
-	0x00,	/* 0x75 */		0x00,	/* 0x76 */
-	0x5A,	/* FOCUS_PF3 */		0x5B,	/* FOCUS_PF4 */
-	0x5C,	/* FOCUS_PF5 */		0x5D,	/* FOCUS_PF6 */
-	0x5E,	/* FOCUS_PF7 */		0x5F,	/* FOCUS_PF8 */
-	0x7C,	/* JAP_86 */		0x79,	/* FOCUS_PF10 */
-	0x00,	/* 0x7f */
-};
-#define NUM_AT2LNX (sizeof(at2lnx) / sizeof(at2lnx[0]))
-
-#define NUM_CUSTOMKEYS	NR_KEYS
-
-u_char SpecialServerMap[NUM_CUSTOMKEYS];
-
-static void
-readKernelMapping(KeySymsPtr pKeySyms, CARD8 *pModMap)
-{
-  KeySym        *k;
-  int           i;
-  int           maxkey;
-  static unsigned char tbl[GLYPHS_PER_KEY] =
-  {
-	0,	/* unshifted */
-	1,	/* shifted */
-	0,	/* modeswitch unshifted */
-	0	/* modeswitch shifted */
-  };
-
-  /*
-   * Read the mapping from the kernel.
-   * Since we're still using the XFree86 scancode->AT keycode mapping
-   * routines, we need to convert the AT keycodes to Linux keycodes,
-   * then translate the Linux keysyms into X keysyms.
-   *
-   * First, figure out which tables to use for the modeswitch columns
-   * above, from the XF86Config fields.
-   */
-  tbl[2] = 8;	/* alt */
-  tbl[3] = tbl[2] | 1;
-
-  if (xf86Info.kbdCustomKeycodes) {
-    k = map;
-    maxkey = NUM_CUSTOMKEYS;
-  }
-  else {
-    k = map+GLYPHS_PER_KEY;
-    maxkey = NUM_AT2LNX;
-  }
-
-  for (i = 0; i < maxkey; ++i)
-  {
-    struct kbentry kbe;
-    int j;
-
-    if (xf86Info.kbdCustomKeycodes)
-      kbe.kb_index = i;
-    else
-      kbe.kb_index = at2lnx[i];
-
-    for (j = 0; j < GLYPHS_PER_KEY; ++j, ++k)
-    {
-      unsigned short kval;
-
-      *k = NoSymbol;
-
-      kbe.kb_table = tbl[j];
-      if (
-	  (!xf86Info.kbdCustomKeycodes && kbe.kb_index == 0) ||
-	  ioctl(xf86Info.consoleFd, KDGKBENT, &kbe))
-	continue;
-
-      kval = KVAL(kbe.kb_value);
-      switch (KTYP(kbe.kb_value))
-      {
-      case KT_LATIN:
-      case KT_LETTER:
-	*k = linux_to_x[kval];
-	break;
-
-      case KT_FN:
-	if (kval <= 19)
-	  *k = XK_F1 + kval;
-	else switch (kbe.kb_value)
-	{
-	case K_FIND:
-	  *k = XK_Home; /* or XK_Find */
-	  break;
-	case K_INSERT:
-	  *k = XK_Insert;
-	  break;
-	case K_REMOVE:
-	  *k = XK_Delete;
-	  break;
-	case K_SELECT:
-	  *k = XK_End; /* or XK_Select */
-	  break;
-	case K_PGUP:
-	  *k = XK_Prior;
-	  break;
-	case K_PGDN:
-	  *k = XK_Next;
-	  break;
-	case K_HELP:
-	  *k = XK_Help;
-	  break;
-	case K_DO:
-	  *k = XK_Execute;
-	  break;
-	case K_PAUSE:
-	  *k = XK_Pause;
-	  break;
-	case K_MACRO:
-	  *k = XK_Menu;
-	  break;
-	default:
-	  break;
-	}
-	break;
-
-      case KT_SPEC:
-	switch (kbe.kb_value)
-	{
-	case K_ENTER:
-	  *k = XK_Return;
-	  break;
-	case K_BREAK:
-	  *k = XK_Break;
-	  break;
-	case K_CAPS:
-	  *k = XK_Caps_Lock;
-	  break;
-	case K_NUM:
-	  *k = XK_Num_Lock;
-	  break;
-	case K_HOLD:
-	  *k = XK_Scroll_Lock;
-	  break;
-	case K_COMPOSE:
-          *k = XK_Multi_key;
-	  break;
-	default:
-	  break;
-	}
-	break;
-
-      case KT_PAD:
-	switch (kbe.kb_value)
-	{
-	case K_PPLUS:
-	  *k = XK_KP_Add;
-	  break;
-	case K_PMINUS:
-	  *k = XK_KP_Subtract;
-	  break;
-	case K_PSTAR:
-	  *k = XK_KP_Multiply;
-	  break;
-	case K_PSLASH:
-	  *k = XK_KP_Divide;
-	  break;
-	case K_PENTER:
-	  *k = XK_KP_Enter;
-	  break;
-	case K_PCOMMA:
-	  *k = XK_KP_Separator;
-	  break;
-	case K_PDOT:
-	  *k = XK_KP_Decimal;
-	  break;
-	case K_PPLUSMINUS:
-	  *k = XK_KP_Subtract;
-	  break;
-	default:
-	  if (kval <= 9)
-	    *k = XK_KP_0 + kval;
-	  break;
-	}
-	break;
-
-      /*
-       * KT_DEAD keys are for accelerated diacritical creation.
-       */
-      case KT_DEAD:
-	switch (kbe.kb_value)
-	  {
-	  case K_DGRAVE:
-	    *k = XK_dead_grave;
-	    break;
-	  case K_DACUTE:
-	    *k = XK_dead_acute;
-	    break;
-	  case K_DCIRCM:
-	    *k = XK_dead_circumflex;
-	    break;
-	  case K_DTILDE:
-	    *k = XK_dead_tilde;
-	    break;
-	  case K_DDIERE:
-	    *k = XK_dead_diaeresis;
-	    break;
-	  }
-	break;
-
-      case KT_CUR:
-	switch (kbe.kb_value)
-	{
-	case K_DOWN:
-	  *k = XK_Down;
-	  break;
-	case K_LEFT:
-	  *k = XK_Left;
-	  break;
-	case K_RIGHT:
-	  *k = XK_Right;
-	  break;
-	case K_UP:
-	  *k = XK_Up;
-	  break;
-	}
-	break;
-
-      case KT_SHIFT:
-	switch (kbe.kb_value)
-	{
-	case K_ALTGR:
-	  *k = XK_Alt_R;
-	  break;
-	case K_ALT:
-	  *k = (kbe.kb_index == 0x64 ?
-		XK_Alt_R : XK_Alt_L);
-	  break;
-	case K_CTRL:
-	  *k = (kbe.kb_index == 0x61 ?
-		XK_Control_R : XK_Control_L);
-	  break;
-        case K_CTRLL:
-	  *k = XK_Control_L;
-	  break;
-        case K_CTRLR:
-	  *k = XK_Control_R;
-	  break;
-	case K_SHIFT:
-	  *k = (kbe.kb_index == 0x36 ?
-		XK_Shift_R : XK_Shift_L);
-	  break;
-        case K_SHIFTL:
-	  *k = XK_Shift_L;
-	  break;
-        case K_SHIFTR:
-	  *k = XK_Shift_R;
-	  break;
-	default:
-	  break;
-	}
-	break;
-
-      /*
-       * KT_ASCII keys accumulate a 3 digit decimal number that gets
-       * emitted when the shift state changes. We can't emulate that.
-       */
-      case KT_ASCII:
-	break;
-
-      case KT_LOCK:
-	if (kbe.kb_value == K_SHIFTLOCK)
-	  *k = XK_Shift_Lock;
-	break;
-
-      default:
-	break;
-      }
-    }
-
-    if (k[-1] == k[-2]) k[-1] = NoSymbol;
-    if (k[-2] == k[-3]) k[-2] = NoSymbol;
-    if (k[-3] == k[-4]) k[-3] = NoSymbol;
-    if (k[-4] == k[-2] && k[-3] == k[-1]) k[-2] = k[-1] = NoSymbol;
-    if (k[-1] == k[-4] && k[-2] == k[-3] && k[-2] == NoSymbol) k[-1] =NoSymbol;
-  }
-
-  if (!xf86Info.kbdCustomKeycodes)
-    return;
-
-  /*
-   * Find the Mapping for the special server functions
-   */
-  for (i = 0; i < NUM_CUSTOMKEYS; ++i) {
-    struct kbentry kbe;
-    int special = 0;
-
-    kbe.kb_index = i;
-    kbe.kb_table = 0; /* Plain map */
-    if (!ioctl(xf86Info.consoleFd, KDGKBENT, &kbe))
-      switch (kbe.kb_value) {
-	case K(KT_LATIN,0x7f):	/* This catches DEL too... But who cares? */
-	  special = KEY_BackSpace;
-	  break;
-	case K_PMINUS:
-	  special = KEY_KP_Minus;
-	  break;
-	case K_PPLUS:
-	  special = KEY_KP_Plus;
-	  break;
-	case K_F1:
-	  special = KEY_F1;
-	  break;
-	case K_F2:
-	  special = KEY_F2;
-	  break;
-	case K_F3:
-	  special = KEY_F3;
-	  break;
-	case K_F4:
-	  special = KEY_F4;
-	  break;
-	case K_F5:
-	  special = KEY_F5;
-	  break;
-	case K_F6:
-	  special = KEY_F6;
-	  break;
-	case K_F7:
-	  special = KEY_F7;
-	  break;
-	case K_F8:
-	  special = KEY_F8;
-	  break;
-	case K_F9:
-	  special = KEY_F9;
-	  break;
-	case K_F10:
-	  special = KEY_F10;
-	  break;
-	case K_F11:
-	  special = KEY_F11;
-	  break;
-	case K_F12:
-	  special = KEY_F12;
-	  break;
-	case K_ALT:
-	  special = KEY_Alt;
-	  break;
-	case K_ALTGR:
-	  special = KEY_AltLang;
-	  break;
-	case K_CONS:
-	  special = KEY_SysReqest;
-	  break;
-      }
-    SpecialServerMap[i] = special;
-  }
-}

hw/xfree86/common/xf86KbdMach.c

@@ -1,316 +0,0 @@
-/*
- *****************************************************************************
- * HISTORY
- * Log:	xf86KbdMach.c,v
- * Revision 2.1.2.1  92/06/25  10:32:08  moore
- * 	Incorporate the Elliot Dresselhaus's, Ernest Hua's and local changes
- * 	to run Thomas Roell's I386 color X11R5.  Original code only worked
- * 	with SCO Unix.  New code works with 2.5 and 3.0 Mach
- * 	[92/06/24            rvb]
- * 
- * 	EndLog
- * 
- *****************************************************************************
- */
-/*
- * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Thomas Roell not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Thomas Roell makes no representations
- * about the suitability of this software for any purpose.  It is provided
- * "as is" without express or implied warranty.
- *
- * THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- *
- */
-/* $XConsortium: xf86KbdMach.c /main/9 1996/02/21 17:38:43 kaleb $ */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xmd.h>
-#include "input.h"
-#include "scrnintstr.h"
-
-#include "compiler.h"
-
-#include "xf86.h"
-#include "xf86Priv.h"
-#include "xf86_OSlib.h"
-#include "atKeynames.h"
-#include "xf86Config.h"
-
-#include "xf86Keymap.h"
-
-static KeySym ascii_to_x[256] = {
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_BackSpace,	XK_Tab,		XK_Linefeed,	NoSymbol,
-	NoSymbol,	XK_Return,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	XK_Escape,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_space,	XK_exclam,	XK_quotedbl,	XK_numbersign,
-	XK_dollar,	XK_percent,	XK_ampersand,	XK_apostrophe,
-	XK_parenleft,	XK_parenright,	XK_asterisk,	XK_plus,
-	XK_comma,	XK_minus,	XK_period,	XK_slash,
-	XK_0,		XK_1,		XK_2,		XK_3,
-	XK_4,		XK_5,		XK_6,		XK_7,
-	XK_8,		XK_9,		XK_colon,	XK_semicolon,
-	XK_less,	XK_equal,	XK_greater,	XK_question,
-	XK_at,		XK_A,		XK_B,		XK_C,
-	XK_D,		XK_E,		XK_F,		XK_G,
-	XK_H,		XK_I,		XK_J,		XK_K,
-	XK_L,		XK_M,		XK_N,		XK_O,
-	XK_P,		XK_Q,		XK_R,		XK_S,
-	XK_T,		XK_U,		XK_V,		XK_W,
-	XK_X,		XK_Y,		XK_Z,		XK_bracketleft,
-	XK_backslash,	XK_bracketright,XK_asciicircum,	XK_underscore,
-	XK_grave,	XK_a,		XK_b,		XK_c,
-	XK_d,		XK_e,		XK_f,		XK_g,
-	XK_h,		XK_i,		XK_j,		XK_k,
-	XK_l,		XK_m,		XK_n,		XK_o,
-	XK_p,		XK_q,		XK_r,		XK_s,
-	XK_t,		XK_u,		XK_v,		XK_w,
-	XK_x,		XK_y,		XK_z,		XK_braceleft,
-	XK_bar,		XK_braceright,	XK_asciitilde,	XK_Delete,
-	XK_Ccedilla,	XK_udiaeresis,	XK_eacute,	XK_acircumflex,
-	XK_adiaeresis,	XK_agrave,	XK_aring,	XK_ccedilla,
-	XK_ecircumflex,	XK_ediaeresis,	XK_egrave,	XK_idiaeresis,
-	XK_icircumflex,	XK_igrave,	XK_Adiaeresis,	XK_Aring,
-	XK_Eacute,	XK_ae,		XK_AE,		XK_ocircumflex,
-	XK_odiaeresis,	XK_ograve,	XK_ucircumflex,	XK_ugrave,
-	XK_ydiaeresis,	XK_Odiaeresis,	XK_Udiaeresis,	XK_cent,
-	XK_sterling,	XK_yen,		XK_paragraph,	XK_section,
-	XK_aacute,	XK_iacute,	XK_oacute,	XK_uacute,
-	XK_ntilde,	XK_Ntilde,	XK_ordfeminine,	XK_masculine,
-	XK_questiondown,XK_hyphen,	XK_notsign,	XK_onehalf,
-	XK_onequarter,	XK_exclamdown,	XK_guillemotleft,XK_guillemotright,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_Greek_alpha,	XK_ssharp,	XK_Greek_GAMMA,	XK_Greek_pi,
-	XK_Greek_SIGMA,	XK_Greek_sigma,	XK_mu,	        XK_Greek_tau,
-	XK_Greek_PHI,	XK_Greek_THETA,	XK_Greek_OMEGA,	XK_Greek_delta,
-	XK_infinity,	XK_Ooblique,	XK_Greek_epsilon, XK_intersection,
-	XK_identical,	XK_plusminus,	XK_greaterthanequal, XK_lessthanequal,
-	XK_topintegral,	XK_botintegral,	XK_division,	XK_similarequal,
-	XK_degree,	NoSymbol,	NoSymbol,	XK_radical,
-	XK_Greek_eta,	XK_twosuperior,	XK_periodcentered, NoSymbol,
-      };
-
-/*
- * LegalModifier --
- *      determine whether a key is a legal modifier key, i.e send a
- *      press/release sequence.
- */
-
-/*ARGSUSED*/
-Bool
-LegalModifier(key, pDev)
-     unsigned int  key;
-     DevicePtr  pDev;
-{
-  return (TRUE);
-}
-
-
-      
-/*
- * xf86KbdGetMapping --
- *	Get the national keyboard mapping. The keyboard type is set, a new map
- *      and the modifiermap is computed.
- */
-
-void
-xf86KbdGetMapping (pKeySyms, pModMap)
-     KeySymsPtr pKeySyms;
-     CARD8      *pModMap;
-{
-  KeySym        *k;
-  struct	kbentry kbe;
-  char          type;
-  int           i, j;
-  
-  for (i = 0; i < NUMKEYS; i++)
-    {
-      static int states[] = { NORM_STATE, SHIFT_STATE, ALT_STATE, SHIFT_ALT };
-      int j;
-
-      k = &map[i*4];
-      kbe.kb_index = i;
-	
-      for (j = 0; j < 4; j++)
-	{
-	  kbe.kb_state = states[j];
-
-	  if (ioctl (xf86Info.consoleFd, KDGKBENT, &kbe) != -1)
-	    continue;
-      
-	  if (kbe.kb_value [0] == K_SCAN)
-	    {
-	      int keycode = -1;
-	      switch (kbe.kb_value [1])
-		{
-		case K_CTLSC: keycode = XK_Control_L; break;
-		case K_LSHSC: keycode = XK_Shift_L; break;
-		case K_RSHSC: keycode = XK_Shift_R; break;
-		case K_ALTSC: keycode = XK_Alt_L; break;
-		case K_CLCKSC: keycode = XK_Caps_Lock; break;
-		case K_NLCKSC: keycode = XK_Num_Lock; break;
-		default: break;
-		}
-	      if (keycode > 0)
-		k[j] = keycode;
-	    }
-	  else if (kbe.kb_value[1] != NC)
-	    {
-	      /* How to handle multiple characters?
-	         Ignore them for now. */
-	    }
-	  else
-	    {
-	      k[j] = ascii_to_x[kbe.kb_value[0]];
-	    }
-	}
-    }
-
-  /*
-   * Apply the special key mapping specified in XF86Config 
-   */
-  for (k = map, i = MIN_KEYCODE;
-       i < (NUM_KEYCODES + MIN_KEYCODE);
-       i++, k += 4) {
-    switch (k[0]) {
-      case XK_Alt_L:
-        j = K_INDEX_LEFTALT;
-        break;
-      case XK_Alt_R:
-        j = K_INDEX_RIGHTALT;
-        break;
-      case XK_Scroll_Lock:
-        j = K_INDEX_SCROLLLOCK;
-        break;
-      case XK_Control_R:
-        j = K_INDEX_RIGHTCTL;
-        break;
-      default:
-        j = -1;
-    }
-    if (j >= 0)
-      switch (xf86Info.specialKeyMap[j]) {
-        case KM_META:
-          if (k[0] == XK_Alt_R)
-            k[1] = XK_Meta_R;
-          else {
-            k[0] = XK_Alt_L;
-            k[1] = XK_Meta_L;
-          }
-          break;
-        case KM_COMPOSE:
-          k[0] = XK_Multi_key;
-          break;
-        case KM_MODESHIFT:
-          k[0] = XK_Mode_switch;
-          k[1] = NoSymbol;
-          break;
-        case KM_MODELOCK:
-          k[0] = XK_Mode_switch;
-          k[1] = XF86XK_ModeLock;
-          break;
-        case KM_SCROLLLOCK:
-          k[0] = XK_Scroll_Lock;
-          break;
-        case KM_CONTROL:
-          k[0] = XK_Control_R;
-          break;
-      }
-  }
-
-  /*
-   * compute the modifier map
-   */
-  for (i = 0; i < MAP_LENGTH; i++)
-    pModMap[i] = NoSymbol;  /* make sure it is restored */
-  
-  for (k = map, i = MIN_KEYCODE;
-       i < (NUM_KEYCODES + MIN_KEYCODE);
-       i++, k += 4)
-    
-    switch(*k) {
-      
-    case XK_Shift_L:
-    case XK_Shift_R:
-      pModMap[i] = ShiftMask;
-      break;
-      
-    case XK_Control_L:
-    case XK_Control_R:
-      pModMap[i] = ControlMask;
-      break;
-      
-    case XK_Caps_Lock:
-      pModMap[i] = LockMask;
-      break;
-      
-    case XK_Alt_L:
-    case XK_Alt_R:
-      pModMap[i] = AltMask;
-      break;
-      
-    case XK_Num_Lock:
-      if (!xf86Info.serverNumLock) pModMap[i] = NumLockMask;
-      break;
-
-    case XK_Scroll_Lock:
-      pModMap[i] = ScrollLockMask;
-      break;
-
-      /* kana support */
-    case XK_Kana_Lock:
-    case XK_Kana_Shift:
-      pModMap[i] = KanaMask;
-      break;
-
-      /* alternate toggle for multinational support */
-    case XK_Mode_switch:
-      pModMap[i] = AltLangMask;
-      break;
-
-    }
-  
-  xf86Info.kbdType =
-    ioctl(xf86Info.kbdFd, KDGKBDTYPE, &type) != -1 ? type : KB_VANILLAKB;
-
-  pKeySyms->map        = map;
-  pKeySyms->mapWidth   = GLYPHS_PER_KEY;
-  pKeySyms->minKeyCode = MIN_KEYCODE;
-  if (xf86Info.serverNumLock)
-    pKeySyms->maxKeyCode = MAX_KEYCODE; 
-  else
-    pKeySyms->maxKeyCode = MAX_STD_KEYCODE;
-
-}

hw/xfree86/common/xf86MiscExt.c

@@ -89,6 +89,7 @@ typedef struct {
 	int	rate;
 	int	delay;
 	int	serverNumLock;	/* obsolete */
+        pointer private;
 } kbdParamsRec, *kbdParamsPtr;
 
 /*
@@ -256,53 +257,22 @@ _X_EXPORT Bool
 MiscExtGetKbdSettings(pointer *kbd)
 {
     kbdParamsPtr kbdptr;
+    InputInfoPtr pInfo;
 
     DEBUG_P("MiscExtGetKbdSettings");
 
-    kbdptr = MiscExtCreateStruct(MISC_KEYBOARD);
+    return FALSE;
-    if (!kbdptr)
-	return FALSE;
-    kbdptr->type  = xf86Info.kbdType;
-    kbdptr->rate  = xf86Info.kbdRate;
-    kbdptr->delay = xf86Info.kbdDelay;
-    *kbd = kbdptr;
-    return TRUE;
 }
 
 _X_EXPORT int
 MiscExtGetKbdValue(pointer keyboard, MiscExtKbdValType valtype)
 {
-    kbdParamsPtr kbd = keyboard;
-
-    DEBUG_P("MiscExtGetKbdValue");
-    switch (valtype) {
-	case MISC_KBD_TYPE:		return kbd->type;
-	case MISC_KBD_RATE:		return kbd->rate;
-	case MISC_KBD_DELAY:		return kbd->delay;
-	case MISC_KBD_SERVNUMLOCK:	return 0;
-    }
     return 0;
 }
 
 _X_EXPORT Bool
 MiscExtSetKbdValue(pointer keyboard, MiscExtKbdValType valtype, int value)
 {
-    kbdParamsPtr kbd = keyboard;
-
-    DEBUG_P("MiscExtSetKbdValue");
-    switch (valtype) {
-	case MISC_KBD_TYPE:
-		kbd->type = value;
-		return TRUE;
-	case MISC_KBD_RATE:
-		kbd->rate = value;
-		return TRUE;
-	case MISC_KBD_DELAY:
-		kbd->delay = value;
-		return TRUE;
-	case MISC_KBD_SERVNUMLOCK:
-		return TRUE;
-    }
     return FALSE;
 }
 
@@ -365,7 +335,7 @@ MiscExtCreateStruct(MiscExtStructType mse_or_kbd)
 	InputInfoPtr pInfo = xf86InputDevs;
 	
 	while (pInfo) {
-	    if (xf86IsCorePointer(pInfo->dev))
+	    if (pInfo->dev == inputInfo.pointer)
 		break;
 	    pInfo = pInfo->next;
 	}
@@ -463,15 +433,13 @@ MiscExtApply(pointer structure, MiscExtStructType mse_or_kbd)
 	if (!xf86MouseProtocolIDToName)
 	    return MISC_RET_NOMODULE;
 	if (mse->type < MTYPE_MICROSOFT
-		|| ( mse->type > MTYPE_EXPPS2
+		|| (mse->type > MTYPE_EXPPS2
-		    && (mse->type!=MTYPE_OSMOUSE && mse->type!=MTYPE_XQUEUE)))
+		    && (mse->type != MTYPE_OSMOUSE)))
 	    return MISC_RET_BADMSEPROTO;
 #ifdef OSMOUSE_ONLY
 	if (mse->type != MTYPE_OSMOUSE)
 	    return MISC_RET_BADMSEPROTO;
 #else
-	if (mse->type == MTYPE_XQUEUE)
-	    return MISC_RET_BADMSEPROTO;
 	if (mse->type == MTYPE_OSMOUSE)
 	    return MISC_RET_BADMSEPROTO;
 #endif /* OSMOUSE_ONLY */
@@ -492,7 +460,6 @@ MiscExtApply(pointer structure, MiscExtStructType mse_or_kbd)
 	    mse->flags &= ~MF_REOPEN;
 	}
 	if (mse->type != MTYPE_OSMOUSE
-		&& mse->type != MTYPE_XQUEUE
 		&& mse->type != MTYPE_PS_2
 		&& mse->type != MTYPE_BUSMOUSE
 		&& mse->type != MTYPE_IMPS2
@@ -513,7 +480,6 @@ MiscExtApply(pointer structure, MiscExtStructType mse_or_kbd)
 	    return MISC_RET_BADFLAGS;
 
 	if (mse->type != MTYPE_OSMOUSE
-		&& mse->type != MTYPE_XQUEUE
 		&& mse->type != MTYPE_BUSMOUSE)
 	{
 	    if (mse->samplerate < 0)
@@ -586,37 +552,7 @@ MiscExtApply(pointer structure, MiscExtStructType mse_or_kbd)
 	   xf86ReplaceBoolOption(pInfo->options, "ClearRTS",
 				 pMse->mouseFlags | MF_CLEAR_RTS);
     }
-    if (mse_or_kbd == MISC_KEYBOARD) {
+    return MISC_RET_BADVAL;
-	kbdParamsPtr kbd = structure;
-
-	if (kbd->rate < 0)
-	    return MISC_RET_BADVAL;
-	if (kbd->delay < 0)
-	    return MISC_RET_BADVAL;
-	if (kbd->type < KTYPE_UNKNOWN || kbd->type > KTYPE_XQUEUE)
-	    return MISC_RET_BADKBDTYPE;
-
-	if (xf86Info.kbdRate!=kbd->rate || xf86Info.kbdDelay!=kbd->delay) {
-	    char rad;
-
-	    xf86Info.kbdRate = kbd->rate;
-	    xf86Info.kbdDelay = kbd->delay;
-	    if      (xf86Info.kbdDelay <= 375) rad = 0x00;
-	    else if (xf86Info.kbdDelay <= 625) rad = 0x20;
-	    else if (xf86Info.kbdDelay <= 875) rad = 0x40;
-	    else                               rad = 0x60;
-
-	    if      (xf86Info.kbdRate <=  2)   rad |= 0x1F;
-	    else if (xf86Info.kbdRate >= 30)   rad |= 0x00;
-	    else                               rad |= ((58/xf86Info.kbdRate)-2);
-
-	    xf86SetKbdRepeat(rad);
-	}
-#if 0   /* Not done yet */
-	xf86Info.kbdType = kbd->kbdtype;
-#endif
-    }
-    return MISC_RET_SUCCESS;
 }
 
 _X_EXPORT Bool

hw/xfree86/common/xf86Priv.h

@@ -193,20 +193,6 @@ Bool xf86LoadModules(char **list, pointer *optlist);
 int xf86SetVerbosity(int verb);
 int xf86SetLogVerbosity(int verb);
 
-/* xf86Io.c */
-
-void xf86KbdBell(int percent, DeviceIntPtr pKeyboard, pointer ctrl,
-		 int unused);
-void xf86KbdLeds(void);
-void xf86UpdateKbdLeds(void);
-void xf86KbdCtrl(DevicePtr pKeyboard, KeybdCtrl *ctrl); 
-void xf86InitKBD(Bool init);  
-int xf86KbdProc(DeviceIntPtr pKeyboard, int what);
-
-/* xf86Kbd.c */ 
-
-void xf86KbdGetMapping(KeySymsPtr pKeySyms, CARD8 *pModMap);
-
 /* xf86Lock.c */
 
 #ifdef USE_XF86_SERVERLOCK

hw/xfree86/common/xf86Privstr.h

@@ -67,38 +67,11 @@ typedef enum {
  */
 
 typedef struct {
-
-    /* keyboard part */
-    DeviceIntPtr	pKeyboard;
-    DeviceProc		kbdProc;		/* procedure for initializing */
-    void		(* kbdEvents)(void);	/* proc for processing events */
     int			consoleFd;
-    int			kbdFd;
     int			vtno;
-    int			kbdType;		/* AT84 / AT101 */
-    int			kbdRate;
-    int			kbdDelay;
-    int			bell_pitch;
-    int			bell_duration;
-    Bool		autoRepeat;
-    unsigned long	leds;
-    unsigned long	xleds;
     char *		vtinit;
-    int			scanPrefix;		/* scancode-state */
-    Bool		capsLock;
-    Bool		numLock;
-    Bool		scrollLock;
-    Bool		modeSwitchLock;
-    Bool		composeLock;
     Bool		vtSysreq;
     SpecialKeysInDDX	ddxSpecialKeys;
-    Bool		ActionKeyBindingsSet;
-#if defined(SVR4) && defined(i386)
-    Bool		panix106;
-#endif  /* SVR4 && i386 */
-#if defined(__OpenBSD__) || defined(__NetBSD__)
-    int                 wsKbdType;
-#endif
 
     /* mouse part */
     DeviceIntPtr	pMouse;
@@ -125,25 +98,6 @@ typedef struct {
     int			consType;	/* Which console driver? */
 #endif
 
-#ifdef XKB
-    /* 
-     * would like to use an XkbComponentNamesRec here but can't without
-     * pulling in a bunch of header files. :-(
-     */
-    char *		xkbkeymap;
-    char *		xkbkeycodes;
-    char *		xkbtypes;
-    char *		xkbcompat;
-    char *		xkbsymbols;
-    char *		xkbgeometry;
-    Bool		xkbcomponents_specified;
-    char *		xkbrules;
-    char *		xkbmodel;
-    char *		xkblayout;
-    char *		xkbvariant;
-    char *		xkboptions;
-#endif
-
     /* Other things */
     Bool		allowMouseOpenFail;
     Bool		vidModeEnabled;		/* VidMode extension enabled */

hw/xfree86/common/xf86Versions.c

@@ -31,7 +31,6 @@
 
 #include "xf86.h"
 #include "xf86OSmouse.h"
-#include "xf86OSKbd.h"
 
 static CARD32 registeredVersions[NUM_BUILTIN_IFS];
 
@@ -51,8 +50,6 @@ xf86GetBuiltinInterfaceVersion(BuiltinInterface iface, int flags)
     switch (iface) {
     case BUILTIN_IF_OSMOUSE:
 	return OS_MOUSE_VERSION_CURRENT;
-    case BUILTIN_IF_OSKBD:
-	return OS_KBD_VERSION_CURRENT;
     default:
 	xf86Msg(X_ERROR, "xf86GetBuiltinInterfaceVersion: internal error: "
 		"interface %d not handled\n", iface);

hw/xfree86/common/xf86Xinput.h

@@ -146,8 +146,6 @@ typedef struct _LocalDeviceRec {
     unsigned int	    last;
     int			    old_x;
     int			    old_y;
-    float		    dxremaind;
-    float		    dyremaind;
     char *		    type_name;
     IntegerFeedbackPtr	    always_core_feedback;
     IDevPtr		    conf_idev;
@@ -166,16 +164,7 @@ typedef struct _DeviceAssocRec
 extern InputInfoPtr xf86InputDevs;
 
 /* xf86Xinput.c */
-int xf86IsCorePointer(DeviceIntPtr dev);
-int xf86IsCoreKeyboard(DeviceIntPtr dev);
-void xf86XInputSetSendCoreEvents(LocalDevicePtr local, Bool always);
-#define xf86AlwaysCore(a,b) xf86XInputSetSendCoreEvents(a,b)
-
 void InitExtInput(void);
-Bool xf86eqInit(DevicePtr pKbd, DevicePtr pPtr);
-void xf86eqEnqueue(struct _xEvent *event);
-void xf86eqProcessInputEvents (void);
-void xf86eqSwitchScreen(ScreenPtr pScreen, Bool fromDIX);
 void xf86PostMotionEvent(DeviceIntPtr device, int is_absolute,
 			 int first_valuator, int num_valuators, ...);
 void xf86PostProximityEvent(DeviceIntPtr device, int is_in,
@@ -211,10 +200,16 @@ void xf86RemoveEnabledDevice(InputInfoPtr pInfo);
 void xf86AddInputDriver(InputDriverPtr driver, pointer module, int flags);
 void xf86DeleteInputDriver(int drvIndex);
 InputInfoPtr xf86AllocateInput(InputDriverPtr drv, int flags);
+InputDriverPtr xf86LookupInputDriver(const char *name);
+InputInfoPtr xf86LookupInput(const char *name);
 void xf86DeleteInput(InputInfoPtr pInp, int flags);
 
 /* xf86Option.c */
 void xf86CollectInputOptions(InputInfoPtr pInfo, const char **defaultOpts,
 			     pointer extraOpts);
 
+/* Legacy hatred */
+#define SendCoreEvents 59
+#define DontSendCoreEvents 60
+
 #endif /* _xf86Xinput_h */

hw/xfree86/loader/xf86sym.c

@@ -70,7 +70,6 @@
 # include "xf86Xinput.h"
 #endif
 #include "xf86OSmouse.h"
-#include "xf86OSKbd.h"
 #include "xf86xv.h"
 #include "xf86xvmc.h"
 #include "xf86cmap.h"
@@ -280,7 +279,6 @@ _X_HIDDEN void *xfree86LookupTab[] = {
     SYMFUNC(xf86SerialModemClearBits)
     SYMFUNC(xf86LoadKernelModule)
     SYMFUNC(xf86OSMouseInit)
-    SYMFUNC(xf86OSKbdPreInit)
     SYMFUNC(xf86AgpGARTSupported)
     SYMFUNC(xf86GetAGPInfo)
     SYMFUNC(xf86AcquireGART)
@@ -290,10 +288,8 @@ _X_HIDDEN void *xfree86LookupTab[] = {
     SYMFUNC(xf86BindGARTMemory)
     SYMFUNC(xf86UnbindGARTMemory)
     SYMFUNC(xf86EnableAGP)
-    SYMFUNC(xf86SoundKbdBell)
     SYMFUNC(xf86GARTCloseScreen)
 #ifdef XINPUT
-    /* XISB routines  (Merged from Metrolink tree) */
     SYMFUNC(XisbNew)
     SYMFUNC(XisbFree)
     SYMFUNC(XisbRead)
@@ -695,7 +691,6 @@ _X_HIDDEN void *xfree86LookupTab[] = {
     /* xf86Xinput.c */
 #ifdef XINPUT
     SYMFUNC(xf86ProcessCommonOptions)
-    SYMFUNC(xf86IsCorePointer)
     SYMFUNC(xf86PostMotionEvent)
     SYMFUNC(xf86PostProximityEvent)
     SYMFUNC(xf86PostButtonEvent)
@@ -704,13 +699,9 @@ _X_HIDDEN void *xfree86LookupTab[] = {
     SYMFUNC(xf86GetMotionEvents)
     SYMFUNC(xf86MotionHistoryAllocate)
     SYMFUNC(xf86FirstLocalDevice)
-    SYMFUNC(xf86eqEnqueue)
     SYMFUNC(xf86ActivateDevice)
-/* The following segment merged from Metrolink tree */
     SYMFUNC(xf86XInputSetScreen)
     SYMFUNC(xf86ScaleAxis)
-    SYMFUNC(xf86XInputSetSendCoreEvents)
-/* End merged segment */
 #endif
 #ifdef DPMSExtension
     SYMFUNC(DPMSGet)