Merge branch 'master' of ssh+git://idr@git.freedesktop.org/git/xorg/xserver into pci-rework

Conflicts:

	hw/xfree86/common/xf86Configure.c
	hw/xfree86/common/xf86Helper.c
	hw/xfree86/common/xf86pciBus.c
	hw/xfree86/int10/helper_exec.c
	hw/xfree86/os-support/bus/Pci.c
	hw/xfree86/os-support/bus/linuxPci.c
	hw/xfree86/os-support/linux/lnx_pci.c
	hw/xfree86/scanpci/Makefile.am
	hw/xfree86/utils/pcitweak/Makefile.am
	hw/xfree86/utils/scanpci/Makefile.am

.gitignore

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

GL/glx/Makefile.am

@@ -28,7 +28,11 @@ INCLUDES = \
 	-I$(top_srcdir)/mi
 
 
-nodist_libglx_la_SOURCES = indirect_size.h
+nodist_libglx_la_SOURCES = indirect_size.h \
+			   glapi.c \
+			   glcontextmodes.c \
+			   glcontextmode.h \
+			   glthread.c
 
 libglxdri_la_SOURCES = \
         glxdri.c \
@@ -37,10 +41,6 @@ libglxdri_la_SOURCES = \
 
 libglx_la_SOURCES = \
         g_disptab.h \
-        glapi.c \
-        glcontextmodes.c \
-        glcontextmodes.h \
-        glthread.c \
         glxcmds.c \
         glxcmdsswap.c \
         glxcontext.h \

GL/glx/glxext.c

@@ -237,7 +237,7 @@ GLboolean __glXFreeContext(__GLXcontext *cx)
      * __glXDispatch() or as a callback from the resource manager.  In
      * the latter case we need to lift the DRI lock manually. */
 
-    if (glxBlockClients) {
+    if (!glxBlockClients) {
 	__glXleaveServer();
 	cx->destroy(cx);
 	__glXenterServer();

GL/glx/indirect_dispatch.h

@@ -85,8 +85,6 @@ extern HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
 extern HIDDEN int __glXDisp_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
-extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
 extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDisp_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
@@ -123,6 +121,8 @@ extern HIDDEN int __glXDisp_VendorPrivate(struct __GLXclientStateRec *, GLbyte *
 extern HIDDEN int __glXDispSwap_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDisp_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
 extern HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
 extern HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
@@ -279,6 +279,8 @@ extern HIDDEN void __glXDisp_ClearStencil(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_ClearStencil(GLbyte * pc);
 extern HIDDEN void __glXDisp_VertexAttrib3dvARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc);
+extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
 extern HIDDEN void __glXDisp_ConvolutionParameteriv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc);
 extern HIDDEN void __glXDisp_RasterPos2fv(GLbyte * pc);
@@ -327,6 +329,8 @@ extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GL
 extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
+extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
 extern HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc);
 extern HIDDEN void __glXDisp_End(GLbyte * pc);
@@ -457,8 +461,6 @@ extern HIDDEN void __glXDisp_BindFramebufferEXT(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_BindFramebufferEXT(GLbyte * pc);
 extern HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
-extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
 extern HIDDEN int __glXDisp_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
@@ -615,6 +617,8 @@ extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
 extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
 extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
 extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
@@ -783,8 +787,6 @@ extern HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
 extern HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_Rectiv(GLbyte * pc);
-extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
 extern HIDDEN void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc);
 extern HIDDEN void __glXDisp_Vertex2fv(GLbyte * pc);
@@ -919,8 +921,6 @@ extern HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
 extern HIDDEN void __glXDisp_LoadName(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);
-extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
 extern HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
 extern HIDDEN void __glXDisp_CullFace(GLbyte * pc);

GL/glx/indirect_dispatch_swap.c

@@ -28,7 +28,7 @@
 #include <X11/Xmd.h>
 #include <GL/gl.h>
 #include <GL/glxproto.h>
-#ifdef __linux__
+#if defined(__linux__) || defined (__GLIBC__) || defined(__GNU__)
 #include <byteswap.h>
 #elif defined(__OpenBSD__)
 #include <sys/endian.h>

GL/glx/indirect_program.c

@@ -46,7 +46,7 @@
 #include "dispatch.h"
 #include "glapioffsets.h"
 
-#ifdef __linux__
+#if defined(__linux__) || defined (__GLIBC__) || defined (__GNU__)
 #include <byteswap.h>
 #elif defined(__OpenBSD__)
 #include <sys/endian.h>

GL/glx/indirect_reqsize.c

@@ -31,7 +31,7 @@
 #include "indirect_size.h"
 #include "indirect_reqsize.h"
 
-#if defined(linux)
+#if defined(__linux__) || defined (__GLIBC__) || defined(__GNU__)
 #  include <byteswap.h>
 #  define SWAP_32(v)  do { (v) = bswap_32(v); } while(0)
 #else

GL/glx/indirect_table.c

@@ -645,7 +645,7 @@ static const void *Render_function_table[400][2] = {
     /* [ 302] =  4182 */ {__glXDisp_RequestResidentProgramsNV, __glXDispSwap_RequestResidentProgramsNV},
     /* [ 303] =  4183 */ {__glXDisp_LoadProgramNV, __glXDispSwap_LoadProgramNV},
     /* [ 304] =  4184 */ {__glXDisp_ProgramParameter4fvNV, __glXDispSwap_ProgramParameter4fvNV},
-    /* [ 305] =  4185 */ {__glXDisp_ProgramParameter4dvNV, __glXDispSwap_ProgramParameter4dvNV},
+    /* [ 305] =  4185 */ {__glXDisp_ProgramEnvParameter4dvARB, __glXDispSwap_ProgramEnvParameter4dvARB},
     /* [ 306] =  4186 */ {__glXDisp_ProgramParameters4fvNV, __glXDispSwap_ProgramParameters4fvNV},
     /* [ 307] =  4187 */ {__glXDisp_ProgramParameters4dvNV, __glXDispSwap_ProgramParameters4dvNV},
     /* [ 308] =  4188 */ {__glXDisp_TrackMatrixNV, __glXDispSwap_TrackMatrixNV},
@@ -886,10 +886,10 @@ static const int_fast16_t Render_size_table[400][2] = {
     /* [140] =   140 */ {  0, ~0},
     /* [141] =   141 */ {  4, ~0},
     /* [142] =   142 */ {  8, ~0},
-    /* [143] =   143 */ { 40, 20},
+    /* [143] =   143 */ { 28, 20},
-    /* [144] =   144 */ { 28, 21},
+    /* [144] =   144 */ { 20, 21},
-    /* [145] =   145 */ { 64, 22},
+    /* [145] =   145 */ { 48, 22},
-    /* [146] =   146 */ { 44, 23},
+    /* [146] =   146 */ { 32, 23},
     /* [147] =   147 */ { 24, ~0},
     /* [148] =   148 */ { 16, ~0},
     /* [149] =   149 */ { 44, ~0},

GL/glx/indirect_texture_compression.c

@@ -39,7 +39,7 @@
 #include "glthread.h"
 #include "dispatch.h"
 
-#ifdef __linux__
+#if defined(__linux__) || defined (__GLIBC__) || defined (__GNU__)
 #include <byteswap.h>
 #elif defined(__OpenBSD__)
 #include <sys/endian.h>

GL/glx/indirect_util.c

@@ -28,7 +28,7 @@
 #include <X11/Xmd.h>
 #include <GL/gl.h>
 #include <GL/glxproto.h>
-#ifdef __linux__
+#if defined(__linux__) || defined (__GLIBC__) || defined(__GNU__)
 #include <byteswap.h>
 #elif defined(__OpenBSD__)
 #include <sys/endian.h>

GL/glx/swap_interval.c

@@ -40,7 +40,7 @@
 #include "dispatch.h"
 #include "glapioffsets.h"
 
-#ifdef __linux__
+#if defined(__linux__) || defined (__GLIBC__) || defined (__GNU__)
 #include <byteswap.h>
 #elif defined(__OpenBSD__)
 #include <sys/endian.h>

GL/mesa/main/Makefile.am

@@ -60,6 +60,7 @@ nodist_libmain_la_SOURCES = accum.c \
                     light.c \
                     lines.c \
                     matrix.c \
+                    mipmap.c \
                     mm.c \
                     occlude.c \
                     pixel.c \

GL/symlink-mesa.sh

@@ -289,9 +289,9 @@ action() {
 }
 
 usage() {
-    echo symlink.sh src-dir dst-dir
+    echo symlink-mesa.sh src-dir dst-dir
-    echo src-dir: the xc directory of the monolithic source tree
+    echo src-dir: the Mesa source directory
-    echo dst-dir: the modular source tree containing proto, app, lib, ...
+    echo dst-dir: the GL subdirectory of the Xserver modular tree
 }
 
 # Check commandline args

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
@@ -94,6 +91,7 @@ DIST_SUBDIRS = \
 	composite \
 	GL \
 	exa \
+	config \
 	hw
 
 # gross hack

Xext/security.c

@@ -1122,11 +1122,11 @@ CALLBACK(SecurityClientStateCallback)
     switch (client->clientState)
     {
     case ClientStateInitial:
-	TRUSTLEVEL(serverClient) = XSecurityClientTrusted;
+	TRUSTLEVEL(client) = XSecurityClientTrusted;
-	AUTHID(serverClient) = None;
+	AUTHID(client) = None;
 	break;
 
-	case ClientStateRunning:
+    case ClientStateRunning:
 	{ 
 	    XID authId = AuthorizationIDOfClient(client);
 	    SecurityAuthorizationPtr pAuth;
@@ -1146,8 +1146,8 @@ CALLBACK(SecurityClientStateCallback)
 	    }
 	    break;
 	}
-	case ClientStateGone:
+    case ClientStateGone:
-	case ClientStateRetained: /* client disconnected */
+    case ClientStateRetained: /* client disconnected */
 	{
 	    SecurityAuthorizationPtr pAuth;
 
@@ -1167,7 +1167,7 @@ CALLBACK(SecurityClientStateCallback)
 	    }	    
 	    break;
 	}
-	default: break; 
+    default: break; 
     }
 } /* SecurityClientStateCallback */
 
@@ -1251,7 +1251,7 @@ typedef struct _PropertyAccessRec {
 } PropertyAccessRec, *PropertyAccessPtr;
 
 static PropertyAccessPtr PropertyAccessList = NULL;
-static char SecurityDefaultAction = SecurityErrorOperation;
+static char SecurityDefaultAction = XaceErrorOperation;
 static char *SecurityPolicyFile = DEFAULTPOLICYFILE;
 static ATOM SecurityMaxPropertyName = 0;
 
@@ -1410,9 +1410,9 @@ SecurityParsePropertyAccessRule(
     {
 	switch (c)
 	{
-	    case 'i': action = SecurityIgnoreOperation; break;
+	    case 'i': action = XaceIgnoreOperation; break;
-	    case 'a': action = SecurityAllowOperation;  break;
+	    case 'a': action = XaceAllowOperation;  break;
-	    case 'e': action = SecurityErrorOperation;  break;
+	    case 'e': action = XaceErrorOperation;  break;
 
 	    case 'r': readAction    = action; break;
 	    case 'w': writeAction   = action; break;
@@ -1797,7 +1797,7 @@ CALLBACK(SecurityCheckPropertyAccess)
 	     * If pacl doesn't apply, something above should have
 	     * executed a continue, which will skip the follwing code.
 	     */
-	    action = SecurityAllowOperation;
+	    action = XaceAllowOperation;
 	    if (access_mode & SecurityReadAccess)
 		action = max(action, pacl->readAction);
 	    if (access_mode & SecurityWriteAccess)
@@ -1808,11 +1808,11 @@ CALLBACK(SecurityCheckPropertyAccess)
 	} /* end for each pacl */
     } /* end if propertyName <= SecurityMaxPropertyName */
 
-    if (SecurityAllowOperation != action)
+    if (XaceAllowOperation != action)
     { /* audit the access violation */
 	int cid = CLIENT_ID(pWin->drawable.id);
 	int reqtype = ((xReq *)client->requestBuffer)->reqType;
-	char *actionstr = (SecurityIgnoreOperation == action) ?
+	char *actionstr = (XaceIgnoreOperation == action) ?
 							"ignored" : "error";
 	SecurityAudit("client %d attempted request %d with window 0x%x property %s (atom 0x%x) of client %d, %s\n",
 		client->index, reqtype, pWin->drawable.id,

Xext/xace.c

@@ -99,7 +99,7 @@ int XaceHook(int hook, ...)
 		va_arg(ap, WindowPtr),
 		va_arg(ap, Atom),
 		va_arg(ap, Mask),
-		SecurityAllowOperation   /* default allow */
+		XaceAllowOperation   /* default allow */
 	    };
 	    calldata = &rec;
 	    prv = &rec.rval;
@@ -406,12 +406,14 @@ XaceCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
     unsigned int format;
     char * pBuf;
 {
-    ScreenPtr pScreen = pDraw->pScreen;
+    ScreenPtr pScreen;
     RegionRec imageRegion;  /* region representing x,y,w,h */
     RegionRec censorRegion; /* region to obliterate */
     BoxRec imageBox;
     int nRects;
 
+    pScreen = pDraw->pScreen;
+
     imageBox.x1 = x;
     imageBox.y1 = y;
     imageBox.x2 = x + w;

Xext/xace.h

@@ -20,6 +20,13 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #ifndef _XACE_H
 #define _XACE_H
 
+/* Hook return codes */
+#define XaceErrorOperation  0
+#define XaceAllowOperation  1
+#define XaceIgnoreOperation 2
+
+#ifdef XACE
+
 #define XACE_EXTENSION_NAME		"XAccessControlExtension"
 #define XACE_MAJOR_VERSION		1
 #define XACE_MINOR_VERSION		0
@@ -75,11 +82,6 @@ extern int XaceHook(
 /* From the original Security extension...
  */
 
-/* Hook return codes */
-#define SecurityAllowOperation  0
-#define SecurityIgnoreOperation 1
-#define SecurityErrorOperation  2
-
 /* Proc vectors for untrusted clients, swapped and unswapped versions.
  * These are the same as the normal proc vectors except that extensions
  * that haven't declared themselves secure will have ProcBadRequest plugged
@@ -100,4 +102,18 @@ extern void XaceCensorImage(
     char * pBuf
     );
 
+#else /* XACE */
+
+/* Define calls away when XACE is not being built. */
+
+#ifdef __GNUC__
+#define XaceHook(args...) XaceAllowOperation
+#define XaceCensorImage(args...) { ; }
+#else
+#define XaceHook(...) XaceAllowOperation
+#define XaceCensorImage(...) { ; }
+#endif
+
+#endif /* XACE */
+
 #endif /* _XACE_H */

Xi/chgdctl.c

@@ -66,6 +66,7 @@ SOFTWARE.
 #include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
+#include "exevents.h"
 
 #include "chgdctl.h"
 
@@ -98,12 +99,17 @@ int
 ProcXChangeDeviceControl(ClientPtr client)
 {
     unsigned len;
-    int i, status;
+    int i, status, ret = BadValue;
     DeviceIntPtr dev;
     xDeviceResolutionCtl *r;
     xChangeDeviceControlReply rep;
     AxisInfoPtr a;
     CARD32 *resolution;
+    xDeviceAbsCalibCtl *calib;
+    xDeviceAbsAreaCtl *area;
+    xDeviceCoreCtl *c;
+    xDeviceEnableCtl *e;
+    devicePresenceNotify dpn;
 
     REQUEST(xChangeDeviceControlReq);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
@@ -111,9 +117,8 @@ ProcXChangeDeviceControl(ClientPtr client)
     len = stuff->length - (sizeof(xChangeDeviceControlReq) >> 2);
     dev = LookupDeviceIntRec(stuff->deviceid);
     if (dev == NULL) {
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+        ret = BadDevice;
-			  BadDevice);
+        goto out;
-	return Success;
     }
 
     rep.repType = X_Reply;
@@ -126,25 +131,22 @@ ProcXChangeDeviceControl(ClientPtr client)
 	r = (xDeviceResolutionCtl *) & stuff[1];
 	if ((len < (sizeof(xDeviceResolutionCtl) >> 2)) ||
 	    (len != (sizeof(xDeviceResolutionCtl) >> 2) + r->num_valuators)) {
-	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl,
+            ret = BadLength;
-			      0, BadLength);
+            goto out;
-	    return Success;
 	}
 	if (!dev->valuator) {
-	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+            ret = BadMatch;
-			      BadMatch);
+            goto out;
-	    return Success;
 	}
 	if ((dev->grab) && !SameClient(dev->grab, client)) {
 	    rep.status = AlreadyGrabbed;
-	    WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
+            ret = Success;
-	    return Success;
+            goto out;
 	}
 	resolution = (CARD32 *) (r + 1);
 	if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
-	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+            ret = BadValue;
-			      BadValue);
+            goto out;
-	    return Success;
 	}
 	status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
 	if (status == Success) {
@@ -158,21 +160,119 @@ ProcXChangeDeviceControl(ClientPtr client)
 		}
 	    for (i = 0; i < r->num_valuators; i++)
 		(a++)->resolution = *resolution++;
+
+            ret = Success;
 	} else if (status == DeviceBusy) {
 	    rep.status = DeviceBusy;
-	    WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
+            ret = Success;
-	    return Success;
 	} else {
-	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+            ret = BadMatch;
-			      BadMatch);
-	    return Success;
 	}
 	break;
+    case DEVICE_ABS_CALIB:
+        calib = (xDeviceAbsCalibCtl *)&stuff[1];
+
+        if (calib->button_threshold < 0 || calib->button_threshold > 255) {
+            ret = BadValue;
+            goto out;
+        }
+
+        status = ChangeDeviceControl(client, dev, (xDeviceCtl *) calib);
+
+        if (status == Success) {
+            dev->absolute->min_x = calib->min_x;
+            dev->absolute->max_x = calib->max_x;
+            dev->absolute->min_y = calib->min_y;
+            dev->absolute->max_y = calib->max_y;
+            dev->absolute->flip_x = calib->flip_x;
+            dev->absolute->flip_y = calib->flip_y;
+            dev->absolute->rotation = calib->rotation;
+            dev->absolute->button_threshold = calib->button_threshold;
+            ret = Success;
+        } else if (status == DeviceBusy || status == BadValue) {
+            rep.status = status;
+            ret = Success;
+        } else {
+            ret = BadMatch;
+        }
+
+        break;
+    case DEVICE_ABS_AREA:
+        area = (xDeviceAbsAreaCtl *)&stuff[1];
+
+        status = ChangeDeviceControl(client, dev, (xDeviceCtl *) area);
+
+        if (status == Success) {
+            dev->absolute->offset_x = area->offset_x;
+            dev->absolute->offset_y = area->offset_y;
+            dev->absolute->width = area->width;
+            dev->absolute->height = area->height;
+            dev->absolute->screen = area->screen;
+            dev->absolute->following = area->following;
+            ret = Success;
+        } else if (status == DeviceBusy || status == BadValue) {
+            rep.status = status;
+            ret = Success;
+        } else {
+            ret = Success;
+        }
+
+        break;
+    case DEVICE_CORE:
+        c = (xDeviceCoreCtl *)&stuff[1];
+
+        status = ChangeDeviceControl(client, dev, (xDeviceCtl *) c);
+
+        if (status == Success) {
+            dev->coreEvents = c->status;
+            ret = Success;
+        } else if (status == DeviceBusy) {
+            rep.status = DeviceBusy;
+            ret = Success;
+        } else {
+            ret = BadMatch;
+        }
+
+        break;
+    case DEVICE_ENABLE:
+        e = (xDeviceEnableCtl *)&stuff[1];
+
+        status = ChangeDeviceControl(client, dev, (xDeviceCtl *) e);
+
+        if (status == Success) {
+            if (e->enable)
+                EnableDevice(dev);
+            else
+                DisableDevice(dev);
+            ret = Success;
+        } else if (status == DeviceBusy) {
+            rep.status = DeviceBusy;
+            ret = Success;
+        } else {
+            ret = BadMatch;
+        }
+
+        break;
     default:
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, BadValue);
+        ret = BadValue;
-	return Success;
     }
-    WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
+
+out:
+    if (ret == Success) {
+        dpn.type = DevicePresenceNotify;
+        dpn.time = currentTime.milliseconds;
+        dpn.devchange = 1;
+        dpn.deviceid = dev->id;
+        dpn.control = stuff->control;
+        SendEventToAllWindows(dev, DevicePresenceNotifyMask,
+                              (xEvent *) &dpn, 1);
+
+        WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
+    }
+    else {
+        SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, ret);
+    }
+
     return Success;
 }
 

Xi/chgkbd.c

@@ -64,7 +64,6 @@ SOFTWARE.
 #include "XIstubs.h"
 #include "globals.h"
 #include "extnsionst.h"
-#include "extinit.h"	/* LookupDeviceIntRec */
 
 #include "exevents.h"
 #include "exglobals.h"
@@ -99,107 +98,10 @@ SProcXChangeKeyboardDevice(register ClientPtr client)
 int
 ProcXChangeKeyboardDevice(register ClientPtr client)
 {
-    int i;
-    DeviceIntPtr xkbd = inputInfo.keyboard;
-    DeviceIntPtr dev;
-    FocusClassPtr xf = xkbd->focus;
-    FocusClassPtr df;
-    KeyClassPtr k;
-    xChangeKeyboardDeviceReply rep;
-    changeDeviceNotify ev;
-
     REQUEST(xChangeKeyboardDeviceReq);
     REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
 
-    rep.repType = X_Reply;
+    SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
-    rep.RepType = X_ChangeKeyboardDevice;
+                      BadDevice);
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
-	rep.status = -1;
-	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
-			  BadDevice);
-	return Success;
-    }
-
-    k = dev->key;
-    if (k == NULL) {
-	rep.status = -1;
-	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
-			  BadMatch);
-	return Success;
-    }
-
-    if (((dev->grab) && !SameClient(dev->grab, client)) ||
-	((xkbd->grab) && !SameClient(xkbd->grab, client)))
-	rep.status = AlreadyGrabbed;
-    else if ((dev->sync.frozen &&
-	      dev->sync.other && !SameClient(dev->sync.other, client)) ||
-	     (xkbd->sync.frozen &&
-	      xkbd->sync.other && !SameClient(xkbd->sync.other, client)))
-	rep.status = GrabFrozen;
-    else {
-	if (ChangeKeyboardDevice(xkbd, dev) != Success) {
-	    SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
-			      BadDevice);
-	    return Success;
-	}
-	if (!dev->focus)
-	    InitFocusClassDeviceStruct(dev);
-	if (!dev->kbdfeed)
-	    InitKbdFeedbackClassDeviceStruct(dev, (BellProcPtr) NoopDDA,
-					     (KbdCtrlProcPtr) NoopDDA);
-	df = dev->focus;
-	df->win = xf->win;
-	df->revert = xf->revert;
-	df->time = xf->time;
-	df->traceGood = xf->traceGood;
-	if (df->traceSize != xf->traceSize) {
-	    Must_have_memory = TRUE;	/* XXX */
-	    df->trace = (WindowPtr *) xrealloc(df->trace,
-					       xf->traceSize *
-					       sizeof(WindowPtr));
-	    Must_have_memory = FALSE;	/* XXX */
-	}
-	df->traceSize = xf->traceSize;
-	for (i = 0; i < df->traceSize; i++)
-	    df->trace[i] = xf->trace[i];
-	RegisterOtherDevice(xkbd);
-	RegisterKeyboardDevice(dev);
-
-	ev.type = ChangeDeviceNotify;
-	ev.deviceid = stuff->deviceid;
-	ev.time = currentTime.milliseconds;
-	ev.request = NewKeyboard;
-
-	SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
-	SendMappingNotify(MappingKeyboard, k->curKeySyms.minKeyCode,
-			  k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode +
-			  1, client);
-
-	rep.status = 0;
-    }
-
-    WriteReplyToClient(client, sizeof(xChangeKeyboardDeviceReply), &rep);
     return Success;
 }
-
-/***********************************************************************
- *
- * This procedure writes the reply for the XChangeKeyboardDevice 
- * function, if the client and server have a different byte ordering.
- *
- */
-
-void
-SRepXChangeKeyboardDevice(ClientPtr client, int size,
-			  xChangeKeyboardDeviceReply * rep)
-{
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    WriteToClient(client, size, (char *)rep);
-}

Xi/chgkbd.h

@@ -36,9 +36,4 @@ int SProcXChangeKeyboardDevice(ClientPtr	/* client */
 int ProcXChangeKeyboardDevice(ClientPtr	/* client */
     );
 
-void SRepXChangeKeyboardDevice(ClientPtr /* client */ ,
-			       int /* size */ ,
-			       xChangeKeyboardDeviceReply *	/* rep */
-    );
-
 #endif /* CHGKBD_H */

Xi/chgptr.c

@@ -101,138 +101,10 @@ SProcXChangePointerDevice(register ClientPtr client)
 int
 ProcXChangePointerDevice(register ClientPtr client)
 {
-    DeviceIntPtr xptr = inputInfo.pointer;
-    DeviceIntPtr dev;
-    ValuatorClassPtr v;
-    xChangePointerDeviceReply rep;
-    changeDeviceNotify ev;
-
     REQUEST(xChangePointerDeviceReq);
     REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
 
-    rep.repType = X_Reply;
+    SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
-    rep.RepType = X_ChangePointerDevice;
+                      BadDevice);
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
-	rep.status = -1;
-	SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
-			  BadDevice);
-	return Success;
-    }
-
-    v = dev->valuator;
-    if (v == NULL || v->numAxes < 2 ||
-	stuff->xaxis >= v->numAxes || stuff->yaxis >= v->numAxes) {
-	rep.status = -1;
-	SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, BadMatch);
-	return Success;
-    }
-
-    if (((dev->grab) && !SameClient(dev->grab, client)) ||
-	((xptr->grab) && !SameClient(xptr->grab, client)))
-	rep.status = AlreadyGrabbed;
-    else if ((dev->sync.frozen &&
-	      dev->sync.other && !SameClient(dev->sync.other, client)) ||
-	     (xptr->sync.frozen &&
-	      xptr->sync.other && !SameClient(xptr->sync.other, client)))
-	rep.status = GrabFrozen;
-    else {
-	if (ChangePointerDevice(xptr, dev, stuff->xaxis, stuff->yaxis) !=
-	    Success) {
-	    SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
-			      BadDevice);
-	    return Success;
-	}
-	if (dev->focus)
-	    DeleteFocusClassDeviceStruct(dev);
-	if (!dev->button)
-	    InitButtonClassDeviceStruct(dev, 0, NULL);
-	if (!dev->ptrfeed)
-	    InitPtrFeedbackClassDeviceStruct(dev, (PtrCtrlProcPtr) NoopDDA);
-	RegisterOtherDevice(xptr);
-	RegisterPointerDevice(dev);
-
-	ev.type = ChangeDeviceNotify;
-	ev.deviceid = stuff->deviceid;
-	ev.time = currentTime.milliseconds;
-	ev.request = NewPointer;
-
-	SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
-	SendMappingNotify(MappingPointer, 0, 0, client);
-
-	rep.status = 0;
-    }
-
-    WriteReplyToClient(client, sizeof(xChangePointerDeviceReply), &rep);
     return Success;
 }
-
-void
-DeleteFocusClassDeviceStruct(DeviceIntPtr dev)
-{
-    xfree(dev->focus->trace);
-    xfree(dev->focus);
-    dev->focus = NULL;
-}
-
-/***********************************************************************
- *
- * Send an event to interested clients in all windows on all screens.
- *
- */
-
-void
-SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
-{
-    int i;
-    WindowPtr pWin, p1;
-
-    for (i = 0; i < screenInfo.numScreens; i++) {
-	pWin = WindowTable[i];
-	(void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
-	p1 = pWin->firstChild;
-	FindInterestedChildren(dev, p1, mask, ev, count);
-    }
-}
-
-/***********************************************************************
- *
- * Walk through the window tree, finding all clients that want to know
- * about the ChangeDeviceNotify Event.
- *
- */
-
-void
-FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
-		       xEvent * ev, int count)
-{
-    WindowPtr p2;
-
-    while (p1) {
-	p2 = p1->firstChild;
-	(void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
-	FindInterestedChildren(dev, p2, mask, ev, count);
-	p1 = p1->nextSib;
-    }
-}
-
-/***********************************************************************
- *
- * This procedure writes the reply for the XChangePointerDevice 
- * function, if the client and server have a different byte ordering.
- *
- */
-
-void
-SRepXChangePointerDevice(ClientPtr client, int size,
-			 xChangePointerDeviceReply * rep)
-{
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    WriteToClient(client, size, (char *)rep);
-}

Xi/chgptr.h

@@ -53,9 +53,4 @@ void FindInterestedChildren(	/* FIXME: could be static? */
 			       int	/* count */
     );
 
-void SRepXChangePointerDevice(ClientPtr /* client */ ,
-			      int /* size */ ,
-			      xChangePointerDeviceReply *	/* rep */
-    );
-
 #endif /* CHGPTR_H */

Xi/exevents.c

@@ -71,8 +71,7 @@ SOFTWARE.
 #include "exglobals.h"
 #include "dixevents.h"	/* DeliverFocusedEvent */
 #include "dixgrabs.h"	/* CreateGrab() */
-
+#include "scrnintstr.h"
-#include "chgptr.h"
 
 #define WID(w) ((w) ? ((w)->drawable.id) : 0)
 #define AllModifiersMask ( \
@@ -302,7 +301,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;
+
+    ax = dev->valuator->axes + axnum;
 
     ax->min_value = minval;
     ax->max_value = maxval;
@@ -898,7 +902,7 @@ SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
 	return MappingBusy;
     } else {
 	for (i = 0; i < inputMapLen; i++) {
-	    if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr) dev)) {
+	    if (inputMap[i] && !LegalModifier(inputMap[i], dev)) {
 		return MappingFailed;
 	    }
 	}
@@ -1209,3 +1213,44 @@ ShouldFreeInputMasks(WindowPtr pWin, Bool ignoreSelectedEvents)
     else
 	return FALSE;
 }
+
+/***********************************************************************
+ *
+ * Walk through the window tree, finding all clients that want to know
+ * about the Event.
+ *
+ */
+
+void
+FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
+                       xEvent * ev, int count)
+{
+    WindowPtr p2;
+
+    while (p1) {
+        p2 = p1->firstChild;
+        (void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
+        FindInterestedChildren(dev, p2, mask, ev, count);
+        p1 = p1->nextSib;
+    }
+}
+
+/***********************************************************************
+ *
+ * Send an event to interested clients in all windows on all screens.
+ *
+ */
+
+void
+SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
+{
+    int i;
+    WindowPtr pWin, p1;
+
+    for (i = 0; i < screenInfo.numScreens; i++) {
+        pWin = WindowTable[i];
+        (void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
+        p1 = pWin->firstChild;
+        FindInterestedChildren(dev, p1, mask, ev, count);
+    }
+}

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
 };
 
 /**********************************************************************
@@ -463,12 +465,6 @@ SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
     else if (rep->RepType == X_GetDeviceMotionEvents)
 	SRepXGetDeviceMotionEvents(client, len,
 				   (xGetDeviceMotionEventsReply *) rep);
-    else if (rep->RepType == X_ChangeKeyboardDevice)
-	SRepXChangeKeyboardDevice(client, len,
-				  (xChangeKeyboardDeviceReply *) rep);
-    else if (rep->RepType == X_ChangePointerDevice)
-	SRepXChangePointerDevice(client, len,
-				 (xChangePointerDeviceReply *) rep);
     else if (rep->RepType == X_GrabDevice)
 	SRepXGrabDevice(client, len, (xGrabDeviceReply *) rep);
     else if (rep->RepType == X_GetDeviceFocus)
@@ -648,6 +644,17 @@ 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);
+    swaps(&to->control, n);
+}
+
 /************************************************************************
  *
  * This function sets up extension event types and masks.
@@ -674,6 +681,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 +754,9 @@ FixExtensionEvents(ExtensionEntry * extEntry)
 
     DeviceOwnerGrabButtonMask = GetNextExtEventMask();
     SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
+
+    DevicePresenceNotifyMask = GetNextExtEventMask();
+    SetEventInfo(DevicePresenceNotifyMask, _devicePresence);
     SetEventInfo(0, _noExtensionEvent);
 }
 
@@ -786,6 +797,7 @@ RestoreExtensionEvents(void)
     ChangeDeviceNotify = 12;
     DeviceKeyStateNotify = 13;
     DeviceButtonStateNotify = 13;
+    DevicePresenceNotify = 14;
 
     BadDevice = 0;
     BadEvent = 1;
@@ -823,6 +835,7 @@ IResetProc(ExtensionEntry * unused)
     EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
     EventSwapVector[DeviceMappingNotify] = NotImplemented;
     EventSwapVector[ChangeDeviceNotify] = NotImplemented;
+    EventSwapVector[DevicePresenceNotify] = NotImplemented;
     RestoreExtensionEvents();
 }
 
@@ -857,9 +870,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 +880,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,30 @@ ProcXGetDeviceControl(ClientPtr client)
 	total_length = sizeof(xDeviceResolutionState) +
 	    (3 * sizeof(int) * dev->valuator->numAxes);
 	break;
+    case DEVICE_ABS_CALIB:
+        if (!dev->absolute) {
+            SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
+                              BadMatch);
+            return Success;
+        }
+
+        total_length = sizeof(xDeviceAbsCalibCtl);
+        break;
+    case DEVICE_ABS_AREA:
+        if (!dev->absolute) {
+            SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
+                              BadMatch);
+            return Success;
+        }
+
+        total_length = sizeof(xDeviceAbsAreaCtl);
+        break;
+    case DEVICE_CORE:
+        total_length = sizeof(xDeviceCoreCtl);
+        break;
+    case DEVICE_ENABLE:
+        total_length = sizeof(xDeviceEnableCtl);
+        break;
     default:
 	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadValue);
 	return Success;
@@ -140,6 +164,18 @@ ProcXGetDeviceControl(ClientPtr client)
     case DEVICE_RESOLUTION:
 	CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
 	break;
+    case DEVICE_ABS_CALIB:
+        CopySwapDeviceAbsCalib(client, dev->absolute, buf);
+        break;
+    case DEVICE_ABS_AREA:
+        CopySwapDeviceAbsArea(client, dev->absolute, buf);
+        break;
+    case DEVICE_CORE:
+        CopySwapDeviceCore(client, dev, buf);
+        break;
+    case DEVICE_ENABLE:
+        CopySwapDeviceEnable(client, dev, buf);
+        break;
     default:
 	break;
     }
@@ -189,6 +225,98 @@ CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
     }
 }
 
+void CopySwapDeviceAbsCalib (ClientPtr client, AbsoluteClassPtr dts,
+                                char *buf)
+{
+    register char n;
+    xDeviceAbsCalibState *calib = (xDeviceAbsCalibState *) buf;
+
+    calib->control = DEVICE_ABS_CALIB;
+    calib->length = sizeof(calib);
+    calib->min_x = dts->min_x;
+    calib->max_x = dts->max_x;
+    calib->min_y = dts->min_y;
+    calib->max_y = dts->max_y;
+    calib->flip_x = dts->flip_x;
+    calib->flip_y = dts->flip_y;
+    calib->rotation = dts->rotation;
+    calib->button_threshold = dts->button_threshold;
+
+    if (client->swapped) {
+        swaps(&calib->control, n);
+        swaps(&calib->length, n);
+        swapl(&calib->min_x, n);
+        swapl(&calib->max_x, n);
+        swapl(&calib->min_y, n);
+        swapl(&calib->max_y, n);
+        swapl(&calib->flip_x, n);
+        swapl(&calib->flip_y, n);
+        swapl(&calib->rotation, n);
+        swapl(&calib->button_threshold, n);
+    }
+}
+
+void CopySwapDeviceAbsArea (ClientPtr client, AbsoluteClassPtr dts,
+                                char *buf)
+{
+    register char n;
+    xDeviceAbsAreaState *area = (xDeviceAbsAreaState *) buf;
+
+    area->control = DEVICE_ABS_AREA;
+    area->length = sizeof(area);
+    area->offset_x = dts->offset_x;
+    area->offset_y = dts->offset_y;
+    area->width = dts->width;
+    area->height = dts->height;
+    area->screen = dts->screen;
+    area->following = dts->following;
+
+    if (client->swapped) {
+        swaps(&area->control, n);
+        swaps(&area->length, n);
+        swapl(&area->offset_x, n);
+        swapl(&area->offset_y, n);
+        swapl(&area->width, n);
+        swapl(&area->height, n);
+        swapl(&area->screen, n);
+        swapl(&area->following, 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;
+    c->iscore = (dev == inputInfo.keyboard || dev == inputInfo.pointer);
+
+    if (client->swapped) {
+        swaps(&c->control, n);
+        swaps(&c->length, n);
+        swaps(&c->status, n);
+    }
+}
+
+void CopySwapDeviceEnable (ClientPtr client, DeviceIntPtr dev, char *buf)
+{
+    register char n;
+    xDeviceEnableState *e = (xDeviceEnableState *) buf;
+
+    e->control = DEVICE_ENABLE;
+    e->length = sizeof(e);
+    e->enable = dev->enabled;
+
+    if (client->swapped) {
+        swaps(&e->control, n);
+        swaps(&e->length, n);
+        swaps(&e->enable, n);
+    }
+}
+
+
 /***********************************************************************
  *
  * This procedure writes the reply for the xGetDeviceControl function,

Xi/getdctl.h

@@ -42,6 +42,24 @@ void CopySwapDeviceResolution(ClientPtr /* client */ ,
 			      int	/* length */
     );
 
+void CopySwapDeviceAbsCalib (ClientPtr client,
+                             AbsoluteClassPtr dts,
+                             char *buf);
+
+void CopySwapDeviceAbsArea (ClientPtr client,
+                            AbsoluteClassPtr dts,
+                            char *buf);
+
+void CopySwapDeviceCore(ClientPtr /* client */ ,
+                        DeviceIntPtr /* dev */ ,
+                        char * /* buf */
+    );
+
+void CopySwapDeviceEnable(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

@@ -66,86 +66,6 @@ SOFTWARE.
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 
-/***********************************************************************
- *
- * Caller:	ProcXChangeKeyboardDevice
- *
- * This procedure does the implementation-dependent portion of the work
- * needed to change the keyboard device.
- *
- * The X keyboard device has a FocusRec.  If the device that has been 
- * made into the new X keyboard did not have a FocusRec, 
- * ProcXChangeKeyboardDevice will allocate one for it.
- *
- * If you do not want clients to be able to focus the old X keyboard
- * device, call DeleteFocusClassDeviceStruct to free the FocusRec.
- *
- * If you support input devices with keys that you do not want to be 
- * used as the X keyboard, you need to check for them here and return 
- * a BadDevice error.
- *
- * The default implementation is to do nothing (assume you do want
- * clients to be able to focus the old X keyboard).  The commented-out
- * sample code shows what you might do if you don't want the default.
- *
- */
-
-int
-ChangeKeyboardDevice(DeviceIntPtr old_dev, DeviceIntPtr new_dev)
-{
-    /***********************************************************************
-     DeleteFocusClassDeviceStruct(old_dev);	 * defined in xchgptr.c *
-    **********************************************************************/
-    return BadMatch;
-}
-
-/***********************************************************************
- *
- * Caller:	ProcXChangePointerDevice
- *
- * This procedure does the implementation-dependent portion of the work
- * needed to change the pointer device.
- *
- * The X pointer device does not have a FocusRec.  If the device that
- * has been made into the new X pointer had a FocusRec, 
- * ProcXChangePointerDevice will free it.
- *
- * If you want clients to be able to focus the old pointer device that
- * has now become accessible through the input extension, you need to 
- * add a FocusRec to it here.
- *
- * The XChangePointerDevice protocol request also allows the client
- * to choose which axes of the new pointer device are used to move 
- * the X cursor in the X- and Y- directions.  If the axes are different
- * than the default ones, you need to keep track of that here.
- *
- * If you support input devices with valuators that you do not want to be 
- * used as the X pointer, you need to check for them here and return a 
- * BadDevice error.
- *
- * The default implementation is to do nothing (assume you don't want
- * clients to be able to focus the old X pointer).  The commented-out
- * sample code shows what you might do if you don't want the default.
- *
- */
-
-int
-ChangePointerDevice(DeviceIntPtr old_dev,
-		    DeviceIntPtr new_dev, unsigned char x, unsigned char y)
-{
-    /***********************************************************************
-    InitFocusClassDeviceStruct(old_dev);	* allow focusing old ptr*
-
-    x_axis = x;					* keep track of new x-axis*
-    y_axis = y;					* keep track of new y-axis*
-    if (x_axis != 0 || y_axis != 1)
-	axes_changed = TRUE;			* remember axes have changed*
-    else
-	axes_changed = FALSE;
-    *************************************************************************/
-    return BadMatch;
-}
-
 /***********************************************************************
  *
  * Caller:	ProcXCloseDevice
@@ -287,7 +207,26 @@ ChangeDeviceControl(register ClientPtr client, DeviceIntPtr dev,
     switch (control->control) {
     case DEVICE_RESOLUTION:
 	return (BadMatch);
+    case DEVICE_ABS_CALIB:
+    case DEVICE_ABS_AREA:
+        return (BadMatch);
+    case DEVICE_CORE:
+        return (BadMatch);
     default:
 	return (BadMatch);
     }
 }
+
+
+/****************************************************************************
+ *
+ * Caller: configAddDevice (and others)
+ *
+ * Add a new device with the specified options.
+ *
+ */
+int
+NewInputDeviceRequest(InputOption *options)
+{
+    return BadValue;
+}

composite/compext.c

@@ -270,6 +270,9 @@ ProcCompositeNameWindowPixmap (ClientPtr client)
 	return BadWindow;
     }
 
+    if (!pWin->viewable)
+	return BadMatch;
+
     LEGAL_NEW_RESOURCE (stuff->pixmap, client);
     
     cw = GetCompWindow (pWin);

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,450 @@
+/*
+ * 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 <X11/X.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 "inputstr.h"
+#include "hotplug.h"
+#include "os.h"
+
+#define CONFIG_MATCH_RULE "type='method_call',interface='org.x.config.input'"
+
+#define MALFORMED_MSG "[config] malformed message, dropping"
+#define MALFORMED_MESSAGE() { DebugF(MALFORMED_MSG "\n"); \
+                            ret = BadValue; \
+                            goto unwind; }
+#define MALFORMED_MESSAGE_ERROR() { DebugF(MALFORMED_MSG ": %s, %s", \
+                                       error->name, error->message); \
+                                  ret = BadValue; \
+                                  goto unwind; }
+
+/* How often to attempt reconnecting when we get booted off the bus. */
+#define RECONNECT_DELAY 10000 /* in ms */
+
+struct config_data {
+    int fd;
+    DBusConnection *connection;
+    char busobject[32];
+    char busname[64];
+};
+
+static struct config_data *configData;
+
+static CARD32 configReconnect(OsTimerPtr timer, CARD32 time, pointer arg);
+
+static void
+configWakeupHandler(pointer blockData, int err, pointer pReadMask)
+{
+    struct config_data *data = blockData;
+
+    if (data->connection && FD_ISSET(data->fd, (fd_set *) pReadMask))
+        dbus_connection_read_write_dispatch(data->connection, 0);
+}
+
+static void
+configBlockHandler(pointer data, struct timeval **tv, pointer pReadMask)
+{
+}
+
+static void
+configTeardown(void)
+{
+    if (configData) {
+        RemoveGeneralSocket(configData->fd);
+        RemoveBlockAndWakeupHandlers(configBlockHandler, configWakeupHandler,
+                                     configData);
+        xfree(configData);
+        configData = NULL;
+    }
+}
+
+static int
+configAddDevice(DBusMessage *message, DBusMessageIter *iter, DBusError *error)
+{
+    DBusMessageIter subiter;
+    InputOption *tmpo = NULL, *options = NULL;
+    char *tmp = NULL;
+    int ret = BadMatch;
+
+    DebugF("[config] adding device\n");
+
+    /* signature should be [ss][ss]... */
+    options = (InputOption *) xcalloc(sizeof(InputOption), 1);
+    if (!options) {
+        ErrorF("[config] couldn't allocate option\n");
+        return BadAlloc;
+    }
+
+    options->key = xstrdup("_source");
+    options->value = xstrdup("client/dbus");
+
+    while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_ARRAY) {
+        tmpo = (InputOption *) xcalloc(sizeof(InputOption), 1);
+        if (!tmpo) {
+            ErrorF("[config] couldn't allocate option\n");
+            ret = BadAlloc;
+            goto unwind;
+        }
+
+        dbus_message_iter_recurse(iter, &subiter);
+
+        if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
+            MALFORMED_MESSAGE();
+
+        dbus_message_iter_get_basic(&subiter, &tmp);
+        if (!tmp)
+            MALFORMED_MESSAGE();
+        if (tmp[0] == '_') {
+            ErrorF("[config] attempted subterfuge: option name %s given\n",
+                   tmp);
+            MALFORMED_MESSAGE();
+        }
+        tmpo->key = xstrdup(tmp);
+        if (!tmpo->key) {
+            ErrorF("[config] couldn't duplicate key!\n");
+            ret = BadAlloc;
+            goto unwind;
+        }
+
+        if (!dbus_message_iter_has_next(&subiter))
+            MALFORMED_MESSAGE();
+        dbus_message_iter_next(&subiter);
+        if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
+            MALFORMED_MESSAGE();
+
+        dbus_message_iter_get_basic(&subiter, &tmp);
+        if (!tmp)
+            MALFORMED_MESSAGE();
+        tmpo->value = xstrdup(tmp);
+        if (!tmpo->value) {
+            ErrorF("[config] couldn't duplicate option!\n");
+            ret = BadAlloc;
+            goto unwind;
+        }
+
+        tmpo->next = options;
+        options = tmpo;
+        dbus_message_iter_next(iter);
+    }
+
+    ret = NewInputDeviceRequest(options);
+    if (ret != Success)
+        DebugF("[config] NewInputDeviceRequest failed\n");
+
+    return ret;
+
+unwind:
+    if (tmpo->key)
+        xfree(tmpo->key);
+    if (tmpo->value)
+        xfree(tmpo->value);
+    if (tmpo)
+        xfree(tmpo);
+
+    while (options) {
+        tmpo = options;
+        options = options->next;
+        if (tmpo->key)
+            xfree(tmpo->key);
+        if (tmpo->value)
+            xfree(tmpo->value);
+        xfree(tmpo);
+    }
+
+    return ret;
+}
+
+static int
+configRemoveDevice(DBusMessage *message, DBusMessageIter *iter,
+                   DBusError *error)
+{
+    int deviceid = -1;
+    int ret = BadMatch;
+    DeviceIntPtr pDev = NULL;
+
+    if (!dbus_message_get_args(message, error, DBUS_TYPE_INT32,
+                               &deviceid, DBUS_TYPE_INVALID)) {
+        MALFORMED_MESSAGE_ERROR();
+    }
+
+    if (deviceid < 0 || !(pDev = LookupDeviceIntRec(deviceid))) {
+        DebugF("[config] bogus device id %d given\n", deviceid);
+        ret = BadMatch;
+        goto unwind;
+    }
+
+    DebugF("[config] removing device %s (id %d)\n", pDev->name, deviceid);
+
+    /* Call PIE here so we don't try to dereference a device that's
+     * already been removed. */
+    OsBlockSignals();
+    ProcessInputEvents();
+    RemoveDevice(pDev);
+    OsReleaseSignals();
+
+    return Success;
+
+unwind:
+    return ret;
+}
+
+static DBusHandlerResult
+configMessage(DBusConnection *connection, DBusMessage *message, void *closure)
+{
+    DBusMessageIter iter;
+    DBusError error;
+    DBusMessage *reply;
+    DBusConnection *bus = closure;
+    int ret = BadDrawable; /* nonsensical value */
+
+    dbus_error_init(&error);
+
+    if (strcmp(dbus_message_get_interface(message),
+               "org.x.config.input") == 0) {
+        if (!dbus_message_iter_init(message, &iter)) {
+            ErrorF("[config] failed to init iterator\n");
+            dbus_error_free(&error);
+            return DBUS_HANDLER_RESULT_NEED_MEMORY; /* ?? */
+        }
+
+        if (strcmp(dbus_message_get_member(message), "add") == 0)
+            ret = configAddDevice(message, &iter, &error);
+        else if (strcmp(dbus_message_get_member(message), "remove") == 0)
+            ret = configRemoveDevice(message, &iter, &error);
+        if (ret != BadDrawable && ret != BadAlloc) {
+            reply = dbus_message_new_method_return(message);
+            dbus_message_iter_init_append(reply, &iter);
+
+            if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret)) {
+                ErrorF("[config] couldn't append to iterator\n");
+                dbus_error_free(&error);
+                return DBUS_HANDLER_RESULT_HANDLED;
+            }
+
+            if (!dbus_connection_send(bus, reply, NULL))
+                ErrorF("[config] failed to send reply\n");
+            dbus_connection_flush(bus);
+
+            dbus_message_unref(reply);
+        }
+    }
+
+    dbus_error_free(&error);
+
+    if (ret == BadAlloc)
+        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+    else if (ret == BadDrawable)
+        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+    else
+        return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+/**
+ * This is a filter, which only handles the disconnected signal, which
+ * doesn't go to the normal message handling function.  This takes
+ * precedence over the message handling function, so have have to be
+ * careful to ignore anything we don't want to deal with here.
+ *
+ * Yes, this is brutally stupid.
+ */
+static DBusHandlerResult
+configFilter(DBusConnection *connection, DBusMessage *message, void *closure)
+{
+    if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL,
+                                    "Disconnected")) {
+        ErrorF("[dbus] disconnected from bus\n");
+        TimerSet(NULL, 0, RECONNECT_DELAY, configReconnect, NULL);
+        configTeardown();
+        return DBUS_HANDLER_RESULT_HANDLED;
+    }
+
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static Bool
+configSetup(void)
+{
+    DBusError error;
+    DBusObjectPathVTable vtable = { .message_function = configMessage };
+
+    if (!configData)
+        configData = (struct config_data *) xcalloc(sizeof(struct config_data), 1);
+    if (!configData) {
+        ErrorF("[dbus] failed to allocate data struct.\n");
+        return FALSE;
+    }
+
+    dbus_error_init(&error);
+    configData->connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
+    if (!configData->connection || dbus_error_is_set(&error)) {
+        ErrorF("[dbus] some kind of error occurred: %s (%s)\n", error.name,
+                error.message);
+        dbus_error_free(&error);
+        xfree(configData);
+        configData = NULL;
+        return FALSE;
+    }
+
+    dbus_connection_set_exit_on_disconnect(configData->connection, FALSE);
+
+    if (!dbus_connection_get_unix_fd(configData->connection, &configData->fd)) {
+        dbus_connection_unref(configData->connection);
+        ErrorF("[dbus] couldn't get fd for bus\n");
+        dbus_error_free(&error);
+        xfree(configData);
+        configData = NULL;
+        return FALSE;
+    }
+
+    snprintf(configData->busname, sizeof(configData->busname),
+             "org.x.config.display%d", atoi(display));
+    if (!dbus_bus_request_name(configData->connection, configData->busname,
+                               0, &error) || dbus_error_is_set(&error)) {
+        ErrorF("[dbus] couldn't take over org.x.config: %s (%s)\n",
+               error.name, error.message);
+        dbus_error_free(&error);
+        dbus_connection_unref(configData->connection);
+        xfree(configData);
+        configData = NULL;
+        return FALSE;
+    }
+
+    /* blocks until we get a reply. */
+    dbus_bus_add_match(configData->connection, CONFIG_MATCH_RULE, &error);
+    if (dbus_error_is_set(&error)) {
+        ErrorF("[dbus] couldn't match X.Org rule: %s (%s)\n", error.name,
+               error.message);
+        dbus_error_free(&error);
+        dbus_bus_release_name(configData->connection, configData->busname,
+                              &error);
+        dbus_connection_unref(configData->connection);
+        xfree(configData);
+        configData = NULL;
+        return FALSE;
+    }
+
+    if (!dbus_connection_add_filter(configData->connection, configFilter,
+                                    configData, NULL)) {
+
+        ErrorF("[dbus] couldn't add signal filter: %s (%s)\n", error.name,
+               error.message);
+        dbus_error_free(&error);
+        dbus_bus_release_name(configData->connection, configData->busname,
+                              &error);
+        dbus_bus_remove_match(configData->connection, CONFIG_MATCH_RULE,
+                              &error);
+        dbus_connection_unref(configData->connection);
+        xfree(configData);
+        configData = NULL;
+        return FALSE;
+    }
+
+    snprintf(configData->busobject, sizeof(configData->busobject),
+             "/org/x/config/%d", atoi(display));
+    if (!dbus_connection_register_object_path(configData->connection,
+                                              configData->busobject, &vtable,
+                                              configData->connection)) {
+        ErrorF("[dbus] couldn't register object path\n");
+        dbus_bus_release_name(configData->connection, configData->busname,
+                              &error);
+        dbus_bus_remove_match(configData->connection, CONFIG_MATCH_RULE,
+                              &error);
+        dbus_connection_unref(configData->connection);
+        dbus_error_free(&error);
+        xfree(configData);
+        configData = NULL;
+        return FALSE;
+    }
+
+    DebugF("[dbus] registered object path %s\n", configData->busobject);
+
+    dbus_error_free(&error);
+    AddGeneralSocket(configData->fd);
+
+    RegisterBlockAndWakeupHandlers(configBlockHandler, configWakeupHandler,
+                                   configData);
+
+    return TRUE;
+}
+
+static CARD32
+configReconnect(OsTimerPtr timer, CARD32 time, pointer arg)
+{
+    if (configSetup())
+        return 0;
+    else
+        return RECONNECT_DELAY;
+}
+
+void
+configInitialise()
+{
+    TimerSet(NULL, 0, 1, configReconnect, NULL);
+}
+
+void
+configFini()
+{
+    DBusError error;
+
+    if (configData) {
+        dbus_error_init(&error);
+        dbus_connection_unregister_object_path(configData->connection,
+                                               configData->busobject);
+        dbus_connection_remove_filter(configData->connection, configFilter,
+                                      configData);
+        dbus_bus_remove_match(configData->connection, CONFIG_MATCH_RULE,
+                              &error);
+        dbus_bus_release_name(configData->connection, configData->busname,
+                              &error);
+        dbus_connection_unref(configData->connection);
+        dbus_error_free(&error);
+        configTeardown();
+    }
+}
+
+#else /* !HAVE_DBUS */
+
+void
+configInitialise()
+{
+}
+
+void
+configFini()
+{
+}
+
+#endif /* HAVE_DBUS */

config/dbus-api

@@ -0,0 +1,35 @@
+D-BUS Configuration API v0.1
+----------------------------
+
+The X server will register the bus name org.x.config.displayN, and the 
+object /org/x/config/N, where N is the display number.
+
+Currently only hotplugging of input devices is supported.
+
+org.x.config.input:
+    org.x.config.input.add:
+        Takes an argument of key/value option pairs in arrays, e.g.:
+         [ss][ss][ss][ss]
+        is the signature for four options.  These options will be passed
+        to the input driver as with any others.
+        Option names beginning with _ are not allowed; they are reserved
+        for internal use.
+
+        Returns one int32, which is an X Status, as defined in X.h.  If
+        everything is successful, Success will be returned.  BadMatch will
+        be returned if the options given do not match any device.  BadValue
+        is returned for a malformed message.
+
+        Notably, BadAlloc is never returned: the server internally signals
+        to D-BUS that the attempt failed for lack of memory.
+
+        The return does not notify the client of which devices were created
+        or modified as a result of this request: clients are encouraged to
+        listen for the XInput DevicePresenceNotify event to monitor changes
+        in the device list.
+
+    org.x.config.input.remove:
+        Takes one int32 argument, which is the device ID to remove, i.e.:
+         i
+        is the signature.
+        Same return values as org.x.config.input.add.

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

@@ -25,7 +25,7 @@ dnl Process this file with autoconf to create configure.
 AC_PREREQ(2.57)
 dnl This is the not the Xorg version number, it's the server version number.
 dnl Yes, that's weird.
-AC_INIT([xorg-server], 1.1.99.3, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
+AC_INIT([xorg-server], 1.2.99.0, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
 AC_CONFIG_SRCDIR([Makefile.am])
 AM_INIT_AUTOMAKE([dist-bzip2 foreign])
 AM_MAINTAINER_MODE
@@ -50,7 +50,6 @@ AC_CONFIG_HEADERS(include/xwin-config.h)
 dnl kdrive-config.h covers the kdrive DDX
 AC_CONFIG_HEADERS(include/kdrive-config.h)
 
-
 AC_PROG_CC
 AM_PROG_AS
 AC_PROG_INSTALL
@@ -62,8 +61,29 @@ AC_PROG_MAKE_SET
 PKG_PROG_PKG_CONFIG
 AC_PROG_LEX
 AC_PROG_YACC
+AC_SYS_LARGEFILE
 XORG_PROG_RAWCPP
 
+dnl Check for dtrace program (needed to build Xserver dtrace probes)
+AC_ARG_WITH(dtrace, AS_HELP_STRING([--with-dtrace=PATH],
+	     [Enable dtrace probes (default: enabled if dtrace found)]),
+	     [WDTRACE=$withval], [WDTRACE=auto])
+if test "x$WDTRACE" = "xyes" -o "x$WDTRACE" = "xauto" ; then
+	AC_PATH_PROG(DTRACE, [dtrace], [not_found], [$PATH:/usr/sbin])
+	if test "x$DTRACE" = "xnot_found" ; then
+		if test "x$WDTRACE" = "xyes" ; then
+			AC_MSG_FAILURE([dtrace requested but not found])
+		fi
+		WDTRACE="no"
+	fi
+fi
+if test "x$WDTRACE" != "xno" ; then
+  AC_DEFINE(XSERVER_DTRACE, 1, 
+      [Define to 1 if the DTrace Xserver provider probes should be built in.])
+fi
+AM_CONDITIONAL(XSERVER_DTRACE, [test "x$WDTRACE" != "xno"])
+AC_DEFINE_DIR(XERRORDB_PATH, libdir/XErrorDB, [Path to XErrorDB file])
+
 AC_HEADER_DIRENT
 AC_HEADER_STDC
 AC_CHECK_HEADERS([fcntl.h stdlib.h string.h unistd.h])
@@ -154,7 +174,7 @@ AC_CACHE_CHECK([for SYSV IPC],
 		[AC_TRY_LINK([
 #include <sys/shm.h>
 ],[
-int main () { 
+{ 
     int id;
     id = shmget(IPC_PRIVATE, 512, SHM_W | SHM_R);
     if (id < 0) return -1;
@@ -262,6 +282,7 @@ case $host_os in
   *netbsd*)
 	AC_DEFINE(CSRG_BASED, 1, [System is BSD-like])
 	AC_DEFINE(PCCONS_SUPPORT, 1, [System has PC console])
+	AC_DEFINE(PCVT_SUPPORT, 1, [System has PCVT console])
 	AC_DEFINE(WSCONS_SUPPORT, 1, [System has wscons console])
 	DRI=yes
 	;;
@@ -370,7 +391,7 @@ AC_ARG_WITH(mesa-source,     AS_HELP_STRING([--with-mesa-source=MESA_SOURCE], [P
 AC_ARG_WITH(fontdir,         AS_HELP_STRING([--with-fontdir=FONTDIR], [Path to top level dir where fonts are installed (default: ${libdir}/X11/fonts)]),
                                 [ FONTDIR="$withval" ],
                                 [ FONTDIR="${libdir}/X11/fonts" ])
-DEFAULT_FONT_PATH="${FONTDIR}/misc/,${FONTDIR}/TTF/,${FONTDIR}/OTF,${FONTDIR}/Type1/,${FONTDIR}/CID/,${FONTDIR}/100dpi/,${FONTDIR}/75dpi/"
+DEFAULT_FONT_PATH="${FONTDIR}/misc/,${FONTDIR}/TTF/,${FONTDIR}/OTF,${FONTDIR}/Type1/,${FONTDIR}/100dpi/,${FONTDIR}/75dpi/"
 AC_ARG_WITH(default-font-path, AS_HELP_STRING([--with-default-font-path=PATH], [Comma separated list of font dirs]),
 				[ FONTPATH="$withval" ],
 				[ FONTPATH="${DEFAULT_FONT_PATH}" ])
@@ -394,6 +415,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])
@@ -403,7 +430,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])
@@ -412,8 +439,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(xace,     AS_HELP_STRING([--disable-xace], [Build X-ACE extension (default: enabled)]), [XACE=$enableval], [XACE=yes])
 AC_ARG_ENABLE(xcsecurity,     AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: enabled)]), [XCSECURITY=$enableval], [XCSECURITY=$XACE])
 AC_ARG_ENABLE(appgroup,       AS_HELP_STRING([--disable-appgroup], [Build XC-APPGROUP extension (default: enabled)]), [APPGROUP=$enableval], [APPGROUP=$XCSECURITY])
@@ -427,7 +454,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.
@@ -436,7 +463,7 @@ AC_ARG_ENABLE(dmx,    	      AS_HELP_STRING([--enable-dmx], [Build DMX server (d
 AC_ARG_ENABLE(xvfb,    	      AS_HELP_STRING([--enable-xvfb], [Build Xvfb server (default: yes)]), [XVFB=$enableval], [XVFB=yes])
 AC_ARG_ENABLE(xnest,   	      AS_HELP_STRING([--enable-xnest], [Build Xnest server (default: auto)]), [XNEST=$enableval], [XNEST=auto])
 AC_ARG_ENABLE(xwin,    	      AS_HELP_STRING([--enable-xwin], [Build XWin server (default: auto)]), [XWIN=$enableval], [XWIN=auto])
-AC_ARG_ENABLE(xprint,         AS_HELP_STRING([--enable-xprint], [Build Xprint extension and server (default: auto)]), [XPRINT=$enableval], [XPRINT=auto])
+AC_ARG_ENABLE(xprint,         AS_HELP_STRING([--enable-xprint], [Build Xprint extension and server (default: no)]), [XPRINT=$enableval], [XPRINT=no])
 AC_ARG_ENABLE(xgl,            AS_HELP_STRING([--enable-xgl], [Build Xgl server (default: no)]), [XGL=$enableval], [XGL=no])
 AC_ARG_ENABLE(xglx,           AS_HELP_STRING([--enable-xglx], [Build Xglx xgl module (default: no)]), [XGLX=$enableval], [XGLX=no])
 AC_ARG_ENABLE(xegl,           AS_HELP_STRING([--enable-xegl], [Build Xegl xgl module (default: no)]), [XEGL=$enableval], [XEGL=no])
@@ -444,6 +471,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)
@@ -515,9 +545,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 >= 1.2] 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])
@@ -532,10 +574,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
@@ -615,10 +653,14 @@ AM_CONDITIONAL(DRI, test "x$DRI" = xyes)
 if test "x$DRI" = xyes; then
 	AC_DEFINE(XF86DRI, 1, [Build DRI extension])
 	PKG_CHECK_MODULES([DRIPROTO], [xf86driproto])
-	PKG_CHECK_MODULES([LIBDRM], [libdrm])
+	PKG_CHECK_MODULES([LIBDRM], [libdrm >= 2.3.0])
 	PKG_CHECK_MODULES([GL], [glproto >= 1.4.1])
+	PKG_CHECK_EXISTS(libdrm >= 2.2.0,
+			 [AC_DEFINE([HAVE_LIBDRM_2_2], 1,
+			 [Has version 2.2 (or newer) of the drm library])])
 	AC_SUBST(DRIPROTO_CFLAGS)
 	AC_SUBST(LIBDRM_CFLAGS)
+	AC_SUBST(LIBDRM_LIBS)
 	AC_SUBST(GL_CFLAGS)
 fi
 
@@ -696,14 +738,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
@@ -713,6 +747,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"
@@ -743,12 +782,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)
 
@@ -764,6 +800,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])
@@ -840,11 +880,13 @@ 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])
 
 AC_DEFINE(USE_RGB_TXT, 1, [Use rgb.txt directly])
 AC_DEFINE(MITMISC, 1, [Support MIT Misc extension])
@@ -854,8 +896,13 @@ AC_DEFINE(XCMISC, 1, [Support XCMisc extension])
 AC_DEFINE(BIGREQS, 1, [Support BigRequests extension])
 AC_DEFINE(PIXPRIV, 1, [Support pixmap privates])
 
-DIX_LIB='$(top_builddir)/dix/libdix.la'
+if test "x$WDTRACE" != "xno" ; then
-OS_LIB='$(top_builddir)/os/libos.la'
+  DIX_LIB='$(top_builddir)/dix/dix.O'
+  OS_LIB='$(top_builddir)/os/os.O'
+else
+  DIX_LIB='$(top_builddir)/dix/libdix.la'
+  OS_LIB='$(top_builddir)/os/libos.la'
+fi
 CWRAP_LIB='$(top_builddir)/os/libcwrapper.la'
 MI_LIB='$(top_builddir)/mi/libmi.la'
 MINIMI_LIB='$(top_builddir)/mi/libminimi.la'
@@ -872,10 +919,71 @@ PKG_CHECK_MODULES([XSERVERCFLAGS], [$REQUIRED_MODULES $REQUIRED_LIBS])
 PKG_CHECK_MODULES([XSERVERLIBS], [$REQUIRED_LIBS])
 
 XSERVER_CFLAGS="${XSERVERCFLAGS_CFLAGS}"
-XSERVER_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} -lm"
+XSERVER_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} ${LIBS}"
-AC_SUBST([XSERVER_LIBS])
 AC_SUBST([SYS_LIBS])
 
+# 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_CHECK_FUNCS([clock_gettime], [have_clock_gettime=yes],
+               [AC_CHECK_LIB([rt], [clock_gettime], [have_clock_gettime=-lrt],
+                             [have_clock_gettime=no])])
+
+AC_MSG_CHECKING([for a useful monotonic clock ...])
+
+if ! test "x$have_clock_gettime" = xno; then
+    if ! test "x$have_clock_gettime" = xyes; then
+        CLOCK_LIBS="$have_clock_gettime"
+    else
+        CLOCK_LIBS=""
+    fi
+
+    AC_RUN_IFELSE([
+#define _POSIX_C_SOURCE 199309L
+#include <time.h>
+
+int main(int argc, char *argv[]) {
+    struct timespec tp;
+
+    if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
+        return 0;
+    else
+        return 1;
+}
+    ], [MONOTONIC_CLOCK=yes], [MONOTONIC_CLOCK=no],
+       [MONOTONIC_CLOCK="cross compiling"])
+else
+    MONOTONIC_CLOCK=no
+fi
+
+AC_MSG_RESULT([$MONOTONIC_CLOCK])
+
+if test "x$MONOTONIC_CLOCK" = xyes; then
+    AC_DEFINE(MONOTONIC_CLOCK, 1, [Have monotonic clock from clock_gettime()])
+    XSERVER_LIBS="$XSERVER_LIBS $CLOCK_LIBS"
+    LIBS="$LIBS $CLOCK_LIBS"
+fi
+
 dnl Imake defines SVR4 on SVR4 systems, and many files check for it, so
 dnl we need to replicate that here until those can all be fixed
 AC_MSG_CHECKING([if SVR4 needs to be defined])
@@ -890,6 +998,8 @@ AC_MSG_RESULT([yes])], AC_MSG_RESULT([no]))
 XSERVER_CFLAGS="$XSERVER_CFLAGS $CORE_INCS $XEXT_INC $COMPOSITE_INC $DAMAGE_INC $FIXES_INC $XI_INC $MI_INC $MIEXT_SHADOW_INC $MIEXT_LAYER_INC $MIEXT_DAMAGE_INC $RENDER_INC $RANDR_INC $FB_INC"
 AC_DEFINE_UNQUOTED(X_BYTE_ORDER,[$ENDIAN],[Endian order])
 
+AC_SUBST([XSERVER_LIBS])
+
 dnl ---------------------------------------------------------------------------
 dnl DDX section.
 dnl ---------------------------------------------------------------------------
@@ -949,7 +1059,7 @@ AC_MSG_RESULT([$XVFB])
 AM_CONDITIONAL(XVFB, [test "x$XVFB" = xyes])
 
 if test "x$XVFB" = xyes; then
-	XVFB_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB"
+	XVFB_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $CONFIG_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB $LIBS"
 	AC_SUBST([XVFB_LIBS])
 fi
 
@@ -965,7 +1075,7 @@ AC_MSG_RESULT([$XNEST])
 AM_CONDITIONAL(XNEST, [test "x$XNEST" = xyes])
 
 if test "x$XNEST" = xyes; then
-	XNEST_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB"
+	XNEST_LIBS="$XSERVER_LIBS $FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $CONFIG_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB $LIBS"
 	AC_SUBST([XNEST_LIBS])
 fi
 
@@ -1036,7 +1146,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
@@ -1054,6 +1164,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], [], 
@@ -1070,7 +1211,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
@@ -1089,30 +1229,10 @@ dnl has it in libc), or if libdl is needed to get it.
 		  *)
 			;;
 		esac
-
-		# check whether struct kbd_repeat has the 'period' field.
-		# on kernels < 2.5.42 it's called 'rate' instead.
-		AC_TRY_COMPILE([
-#include <linux/kd.h>
-#ifdef __sparc__
-#include <asm/param.h>
-#include <asm/kbio.h>
-#endif
-],[
-int main () { 
-	struct kbd_repeat k;
-	k.period = 0;
-	return 0;
-}],
-		[period_field="period"],
-		[period_field="rate"])
-		AC_DEFINE_UNQUOTED(LNX_KBD_PERIOD_NAME, [$period_field],
-		                   [Name of the period field in struct kbd_repeat])
 		;;
 	  freebsd* | kfreebsd*-gnu)
 	  	XORG_OS="freebsd"
 		XORG_OS_SUBDIR="bsd"
-		XORG_OS_KBD="BSD"
 		case $host_cpu in
 		  i*86)
 			;;
@@ -1124,7 +1244,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*)
 			;;
@@ -1136,7 +1255,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*)
 			;;
@@ -1243,7 +1361,6 @@ int main () {
 	AC_SUBST([XORG_INCS])
 	AC_SUBST([XORG_OS])
 	AC_SUBST([XORG_OS_SUBDIR])
-	AC_SUBST([XORG_OS_KBD])
 
 	AC_PATH_PROG(PERL, perl, no)
 	dnl unlikely as this may be ...
@@ -1252,28 +1369,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"
@@ -1293,6 +1389,7 @@ int main () {
 	AC_DEFINE_DIR(__XCONFIGFILE__, XF86CONFIGFILE, [Name of configuration file])
 	AC_DEFINE_DIR(XF86CONFIGFILE, XF86CONFIGFILE, [Name of configuration file])
 	AC_DEFINE_DIR(DEFAULT_MODULE_PATH, moduledir, [Default module search path])
+	AC_DEFINE_DIR(DEFAULT_LIBRARY_PATH, libdir, [Default library install path])
 	AC_DEFINE_DIR(DEFAULT_LOGPREFIX, LOGPREFIX, [Default log location])
 	AC_DEFINE_UNQUOTED(__VENDORDWEBSUPPORT__, ["$VENDOR_WEB"], [Vendor web address for support])
 
@@ -1322,6 +1419,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
 
@@ -1331,7 +1429,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 $LIBS"
 	AC_SUBST([XPRINT_CFLAGS])
 	AC_SUBST([XPRINT_LIBS])
 
@@ -1460,16 +1558,60 @@ 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
+
+    AC_CHECK_HEADERS([SDL/SDL.h])
+    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
@@ -1491,55 +1633,51 @@ if test "$KDRIVE" = yes; then
     #    $MIEXT_SHADOW_LIB $XPSTUBS_LIB"
     KDRIVE_PURE_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $OS_LIB"
     KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a'
-    KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
+    case $host_os in
+	*linux*)
+	    KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
+            KDRIVELINUX=yes
+	    ;;
+    esac
     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"
 
-    # check for SDL SDK
+    # Xephyr needs nanosleep() which is in librt on Solaris
-    AC_CHECK_HEADERS([SDL/SDL.h])
+    AC_CHECK_FUNC([nanosleep], [],
-    if test "x$XSDL" = xauto; then
+        AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
-        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(KDRIVELINUX, [test "x$KDRIVELINUX" = xyes])
 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
@@ -1557,7 +1695,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
@@ -1578,9 +1715,11 @@ 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], 
@@ -1626,13 +1765,11 @@ AM_CONDITIONAL(BUILD_KBD_MODE, [test x$BUILD_KBD_MODE = xyes])
 AM_CONDITIONAL(BSD_KBD_MODE, [test x$KBD_MODE_TYPE = xbsd])
 AM_CONDITIONAL(SUN_KBD_MODE, [test x$KBD_MODE_TYPE = xsun])
 
-CFLAGS="$XSERVER_CFLAGS $CFLAGS"
-AC_SUBST([CFLAGS])
-
 BUILD_DATE="$(date +'%Y%m%d')"
 AC_SUBST([BUILD_DATE])
 
-DIX_CFLAGS="-DHAVE_DIX_CONFIG_H"
+DIX_CFLAGS="-DHAVE_DIX_CONFIG_H $XSERVER_CFLAGS"
+
 AC_SUBST([DIX_CFLAGS])
 
 AC_SUBST([libdir exec_prefix prefix])
@@ -1672,6 +1809,7 @@ XTrap/Makefile
 mfb/Makefile
 cfb/Makefile
 cfb32/Makefile
+config/Makefile
 mi/Makefile
 miext/Makefile
 miext/damage/Makefile
@@ -1707,7 +1845,6 @@ hw/xfree86/loader/Makefile
 hw/xfree86/os-support/Makefile
 hw/xfree86/os-support/bsd/Makefile
 hw/xfree86/os-support/bus/Makefile
-hw/xfree86/os-support/drm/Makefile
 hw/xfree86/os-support/hurd/Makefile
 hw/xfree86/os-support/misc/Makefile
 hw/xfree86/os-support/linux/Makefile

cpprules.in

@@ -34,6 +34,7 @@ MANDEFS = \
 	-D__miscmansuffix__=$(MISC_MAN_SUFFIX) \
 	-D__drivermansuffix__=$(DRIVER_MAN_SUFFIX) \
 	-D__adminmansuffix__=$(ADMIN_MAN_SUFFIX) \
+	-D__mandir__=$(mandir) \
 	-D__projectroot__=$(prefix) \
 	-D__xconfigfile__=$(__XCONFIGFILE__) -D__xconfigdir__=$(XCONFIGDIR) \
 	-D__xlogfile__=$(XLOGFILE) -D__xservername__=$(XSERVERNAME) 

dix/Makefile.am

@@ -17,6 +17,7 @@ libdix_la_SOURCES = 	\
 	extension.c	\
 	ffs.c		\
 	gc.c		\
+	getevents.c	\
 	globals.c	\
 	glyphcurs.c	\
 	grabs.c		\
@@ -37,4 +38,22 @@ libxpstubs_la_SOURCES =	\
 
 INCLUDES = -I$(top_srcdir)/Xprint
 
-EXTRA_DIST = buildatoms BuiltInAtoms CHANGES
+EXTRA_DIST = buildatoms BuiltInAtoms CHANGES Xserver.d Xserver-dtrace.h.in
+
+if XSERVER_DTRACE
+# Generate dtrace header file for C sources to include
+BUILT_SOURCES = Xserver-dtrace.h
+
+Xserver-dtrace.h: $(srcdir)/Xserver.d
+	$(DTRACE) -C -h -o $@ -s $(srcdir)/Xserver.d \
+		|| cp Xserver-dtrace.h.in $@
+
+# Generate dtrace object code for probes in libdix
+dtrace-dix.o: $(top_srcdir)/dix/Xserver.d $(am_libdix_la_OBJECTS)
+	$(DTRACE) -G -C -o $@ -s $(top_srcdir)/dix/Xserver.d .libs/*.o
+
+noinst_PROGRAMS = dix.O
+
+dix.O: dtrace-dix.o $(am_libdix_la_OBJECTS)
+	ld -r -o $@ .libs/*.o
+endif

dix/Xserver-dtrace.h.in

@@ -0,0 +1,100 @@
+/* Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
+ *
+ * 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, and/or sell copies of the Software, and to permit persons
+ * to whom the Software is furnished to do so, provided that the above
+ * copyright notice(s) and this permission notice appear in all copies of
+ * the Software and that both the above copyright notice(s) and this
+ * permission notice appear in supporting documentation.
+ *
+ * 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
+ * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ *
+ * Except as contained in this notice, the name of a copyright holder
+ * shall not be used in advertising or otherwise to promote the sale, use
+ * or other dealings in this Software without prior written authorization
+ * of the copyright holder.
+ */ 
+
+/*
+ * Generated by dtrace(1M), and then modified for backwards compatibility
+ * with older versions of dtrace.   Used if dtrace -h fails.
+ * (Since _ENABLED support was added after dtrace -h, this  assumes if 
+ *  dtrace -h fails, _ENABLED will too.)
+ */
+
+#ifndef	_XSERVER_DTRACE_H
+#define	_XSERVER_DTRACE_H
+
+#include <unistd.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#if _DTRACE_VERSION
+
+#define	XSERVER_CLIENT_AUTH(arg0, arg1, arg2, arg3) \
+	__dtrace_Xserver___client__auth(arg0, arg1, arg2, arg3)
+#define	XSERVER_CLIENT_CONNECT(arg0, arg1) \
+	__dtrace_Xserver___client__connect(arg0, arg1)
+#define	XSERVER_CLIENT_DISCONNECT(arg0) \
+	__dtrace_Xserver___client__disconnect(arg0)
+#define	XSERVER_REQUEST_DONE(arg0, arg1, arg2, arg3, arg4) \
+	__dtrace_Xserver___request__done(arg0, arg1, arg2, arg3, arg4)
+#define	XSERVER_REQUEST_START(arg0, arg1, arg2, arg3, arg4) \
+	__dtrace_Xserver___request__start(arg0, arg1, arg2, arg3, arg4)
+#define	XSERVER_RESOURCE_ALLOC(arg0, arg1, arg2, arg3) \
+	__dtrace_Xserver___resource__alloc(arg0, arg1, arg2, arg3)
+#define	XSERVER_RESOURCE_FREE(arg0, arg1, arg2, arg3) \
+	__dtrace_Xserver___resource__free(arg0, arg1, arg2, arg3)
+#define	XSERVER_SEND_EVENT(arg0, arg1, arg2) \
+	__dtrace_Xserver___send__event(arg0, arg1, arg2)
+
+
+extern void __dtrace_Xserver___client__auth(int, string, pid_t, zoneid_t);
+extern void __dtrace_Xserver___client__connect(int, int);
+extern void __dtrace_Xserver___client__disconnect(int);
+extern void __dtrace_Xserver___request__done(string, uint8_t, uint32_t, int, int);
+extern void __dtrace_Xserver___request__start(string, uint8_t, uint16_t, int, void *);
+extern void __dtrace_Xserver___resource__alloc(uint32_t, uint32_t, void *, string);
+extern void __dtrace_Xserver___resource__free(uint32_t, uint32_t, void *, string);
+extern void __dtrace_Xserver___send__event(int, uint8_t, void *);
+
+#else
+
+#define	XSERVER_CLIENT_AUTH(arg0, arg1, arg2, arg3)
+#define	XSERVER_CLIENT_CONNECT(arg0, arg1)
+#define	XSERVER_CLIENT_DISCONNECT(arg0)
+#define	XSERVER_REQUEST_DONE(arg0, arg1, arg2, arg3, arg4)
+#define	XSERVER_REQUEST_START(arg0, arg1, arg2, arg3, arg4)
+#define	XSERVER_RESOURCE_ALLOC(arg0, arg1, arg2, arg3)
+#define	XSERVER_RESOURCE_FREE(arg0, arg1, arg2, arg3)
+#define	XSERVER_SEND_EVENT(arg0, arg1, arg2)
+
+#endif
+
+#define	XSERVER_CLIENT_AUTH_ENABLED() (1)
+#define	XSERVER_CLIENT_CONNECT_ENABLED() (1)
+#define	XSERVER_CLIENT_DISCONNECT_ENABLED() (1)
+#define	XSERVER_REQUEST_DONE_ENABLED() (1)
+#define	XSERVER_REQUEST_START_ENABLED() (1)
+#define	XSERVER_RESOURCE_ALLOC_ENABLED() (1)
+#define	XSERVER_RESOURCE_FREE_ENABLED() (1)
+#define	XSERVER_SEND_EVENT_ENABLED() (1)
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _XSERVER_DTRACE_H */

dix/Xserver.d

@@ -0,0 +1,59 @@
+/* Copyright 2005-2006 Sun Microsystems, Inc.  All rights reserved.
+ *
+ * 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, and/or sell copies of the Software, and to permit persons
+ * to whom the Software is furnished to do so, provided that the above
+ * copyright notice(s) and this permission notice appear in all copies of
+ * the Software and that both the above copyright notice(s) and this
+ * permission notice appear in supporting documentation.
+ * 
+ * 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
+ * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * 
+ * Except as contained in this notice, the name of a copyright holder
+ * shall not be used in advertising or otherwise to promote the sale, use
+ * or other dealings in this Software without prior written authorization
+ * of the copyright holder.
+ */
+
+/*
+ * Xserver dtrace provider definition
+ */
+
+#include <sys/types.h>
+
+provider Xserver {
+	/* reqType, data, length, client id, request buffer */
+	probe request__start(string, uint8_t, uint16_t, int, void *);
+	/* reqType, data, sequence, client id, result */
+	probe request__done(string, uint8_t, uint32_t, int, int);
+	/* client id, client fd */
+	probe client__connect(int, int);
+	/* client id, client address, client pid, client zone id */
+	probe client__auth(int, string, pid_t, zoneid_t);
+	/* client id */
+	probe client__disconnect(int);
+	/* resource id, resource type, value, resource type name */
+	probe resource__alloc(uint32_t, uint32_t, void *, string);
+	/* resource id, resource type, value, resource type name */
+	probe resource__free(uint32_t, uint32_t, void *, string);
+	/* client id, event type, event* */
+	probe send__event(int, uint8_t, void *);
+};
+
+#pragma D attributes Unstable/Unstable/Common provider Xserver provider
+#pragma D attributes Private/Private/Unknown  provider Xserver module
+#pragma D attributes Private/Private/Unknown  provider Xserver function
+#pragma D attributes Unstable/Unstable/Common provider Xserver name
+#pragma D attributes Unstable/Unstable/Common provider Xserver args
+

dix/dispatch.c

@@ -74,6 +74,36 @@ Equipment Corporation.
 
 ******************************************************************/
 
+/* XSERVER_DTRACE additions:
+ * Copyright 2005-2006 Sun Microsystems, Inc.  All rights reserved.
+ *
+ * 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, and/or sell copies of the Software, and to permit persons
+ * to whom the Software is furnished to do so, provided that the above
+ * copyright notice(s) and this permission notice appear in all copies of
+ * the Software and that both the above copyright notice(s) and this
+ * permission notice appear in supporting documentation.
+ * 
+ * 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
+ * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * 
+ * Except as contained in this notice, the name of a copyright holder
+ * shall not be used in advertising or otherwise to promote the sale, use
+ * or other dealings in this Software without prior written authorization
+ * of the copyright holder.
+ */
+
+
 
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
@@ -104,9 +134,7 @@ int ProcInitialConnection();
 #include "panoramiX.h"
 #include "panoramiXsrv.h"
 #endif
-#ifdef XACE
 #include "xace.h"
-#endif
 #ifdef XAPPGROUP
 #include "appgroup.h"
 #endif
@@ -118,6 +146,17 @@ int ProcInitialConnection();
 #include <X11/extensions/XKBsrv.h>
 #endif
 
+#ifdef XSERVER_DTRACE
+#include <sys/types.h>
+typedef const char *string;
+#include "Xserver-dtrace.h"
+
+char *RequestNames[256];
+static void LoadRequestNames(void);
+static void FreeRequestNames(void);
+#define GetRequestName(i) (RequestNames[i])
+#endif
+
 #define mskcnt ((MAXCLIENTS + 31) / 32)
 #define BITMASK(i) (1U << ((i) & 31))
 #define MASKIDX(i) ((i) >> 5)
@@ -372,6 +411,10 @@ Dispatch(void)
     if (!clientReady)
 	return;
 
+#ifdef XSERVER_DTRACE
+    LoadRequestNames();
+#endif
+
     while (!dispatchException)
     {
         if (*icheck[0] != *icheck[1])
@@ -447,19 +490,23 @@ Dispatch(void)
 		    client->requestLogIndex = 0;
 		client->requestLog[client->requestLogIndex] = MAJOROP;
 		client->requestLogIndex++;
+#endif
+#ifdef XSERVER_DTRACE
+		XSERVER_REQUEST_START(GetRequestName(MAJOROP), MAJOROP,
+			      ((xReq *)client->requestBuffer)->length,
+			      client->index, client->requestBuffer);
 #endif
 		if (result > (maxBigRequestSize << 2))
 		    result = BadLength;
-		else
+		else {
-#ifdef XACE
-		{
 		    XaceHook(XACE_AUDIT_BEGIN, client);
 		    result = (* client->requestVector[MAJOROP])(client);
 		    XaceHook(XACE_AUDIT_END, client, result);
 		}
-#else
+#ifdef XSERVER_DTRACE
-    		    result = (* client->requestVector[MAJOROP])(client);
+		XSERVER_REQUEST_DONE(GetRequestName(MAJOROP), MAJOROP,
-#endif /* XACE */
+			      client->sequence, client->index, result);
+#endif
 
 		if (result != Success) 
 		{
@@ -491,6 +538,9 @@ Dispatch(void)
     KillAllClients();
     DEALLOCATE_LOCAL(clientReady);
     dispatchException &= ~DE_RESET;
+#ifdef XSERVER_DTRACE
+    FreeRequestNames();
+#endif
 }
 
 #undef MAJOROP
@@ -1106,13 +1156,10 @@ ProcConvertSelection(register ClientPtr client)
 	while ((i < NumCurrentSelections) && 
 	       CurrentSelections[i].selection != stuff->selection) i++;
 	if ((i < NumCurrentSelections) &&
-	    (CurrentSelections[i].window != None)
+	    (CurrentSelections[i].window != None) &&
-#ifdef XACE
+	    XaceHook(XACE_RESOURCE_ACCESS, client,
-	    && XaceHook(XACE_RESOURCE_ACCESS, client,
+		     CurrentSelections[i].window, RT_WINDOW,
-			CurrentSelections[i].window, RT_WINDOW,
+		     SecurityReadAccess, CurrentSelections[i].pWin))
-			SecurityReadAccess, CurrentSelections[i].pWin)
-#endif
-	    )
 	{        
 	    event.u.u.type = SelectionRequest;
 	    event.u.selectionRequest.time = stuff->time;
@@ -2102,9 +2149,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
     Mask		plane = 0;
     char		*pBuf;
     xGetImageReply	xgi;
-#ifdef XACE
     RegionPtr pVisibleRegion = NULL;
-#endif
 
     if ((format != XYPixmap) && (format != ZPixmap))
     {
@@ -2208,17 +2253,16 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 	WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
     }
 
-#ifdef XACE
     if (pDraw->type == DRAWABLE_WINDOW &&
 	!XaceHook(XACE_DRAWABLE_ACCESS, client, pDraw))
     {
 	pVisibleRegion = NotClippedByChildren((WindowPtr)pDraw);
 	if (pVisibleRegion)
 	{
-	    REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion, -pDraw->x, -pDraw->y);
+	    REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion,
+			     -pDraw->x, -pDraw->y);
 	}
     }
-#endif
 
     if (linesPerBuf == 0)
     {
@@ -2238,12 +2282,10 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 				         format,
 				         planemask,
 				         (pointer) pBuf);
-#ifdef XACE
 	    if (pVisibleRegion)
 		XaceCensorImage(client, pVisibleRegion, widthBytesLine,
 			pDraw, x, y + linesDone, width, 
 			nlines, format, pBuf);
-#endif
 
 	    /* Note that this is NOT a call to WriteSwappedDataToClient,
                as we do NOT byte swap */
@@ -2279,13 +2321,11 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 				                 format,
 				                 plane,
 				                 (pointer)pBuf);
-#ifdef XACE
 		    if (pVisibleRegion)
 			XaceCensorImage(client, pVisibleRegion,
 				widthBytesLine,
 				pDraw, x, y + linesDone, width, 
 				nlines, format, pBuf);
-#endif
 
 		    /* Note: NOT a call to WriteSwappedDataToClient,
 		       as we do NOT byte swap */
@@ -2307,10 +2347,8 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
             }
 	}
     }
-#ifdef XACE
     if (pVisibleRegion)
 	REGION_DESTROY(pDraw->pScreen, pVisibleRegion);
-#endif
     if (!im_return)
 	DEALLOCATE_LOCAL(pBuf);
     return (client->noClientException);
@@ -2459,7 +2497,7 @@ ProcCreateColormap(register ClientPtr client)
 	    return(result);
     }
     client->errorValue = stuff->visual;
-    return(BadValue);
+    return(BadMatch);
 }
 
 int
@@ -3281,13 +3319,11 @@ ProcListHosts(register ClientPtr client)
     /* REQUEST(xListHostsReq); */
 
     REQUEST_SIZE_MATCH(xListHostsReq);
-#ifdef XACE
+
     /* untrusted clients can't list hosts */
     if (!XaceHook(XACE_HOSTLIST_ACCESS, client, SecurityReadAccess))
-    {
 	return BadAccess;
-    }
+
-#endif
     result = GetHosts(&pdata, &nHosts, &len, &reply.enabled);
     if (result != Success)
 	return(result);
@@ -3565,6 +3601,9 @@ CloseDownClient(register ClientPtr client)
 	    CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
 	} 	    
 	FreeClientResources(client);
+#ifdef XSERVER_DTRACE
+	XSERVER_CLIENT_DISCONNECT(client->index);
+#endif	
 	if (client->index < nextFreeClientID)
 	    nextFreeClientID = client->index;
 	clients[client->index] = NullClient;
@@ -3618,7 +3657,6 @@ extern unsigned totalClientSize;
 
 void InitClient(ClientPtr client, int i, pointer ospriv)
 {
-    bzero(client, totalClientSize);
     client->index = i;
     client->sequence = 0; 
     client->clientAsMask = ((Mask)i) << CLIENTOFFSET;
@@ -3991,3 +4029,60 @@ MarkClientException(ClientPtr client)
 {
     client->noClientException = -1;
 }
+
+#ifdef XSERVER_DTRACE
+#include <ctype.h>
+
+/* Load table of request names for dtrace probes */
+static void LoadRequestNames(void)
+{
+    int i;
+    FILE *xedb;
+    extern void LoadExtensionNames(char **RequestNames);
+
+    bzero(RequestNames, 256 * sizeof(char *));
+
+    xedb = fopen(XERRORDB_PATH, "r");
+    if (xedb != NULL) {
+	char buf[256];
+	while (fgets(buf, sizeof(buf), xedb)) {
+	    if ((strncmp("XRequest.", buf, 9) == 0) && (isdigit(buf[9]))) {
+		char *name;
+		i = strtol(buf + 9, &name, 10);
+		if (RequestNames[i] == 0) {
+		    char *end = strchr(name, '\n');
+		    if (end) { *end = '\0'; }
+		    RequestNames[i] = strdup(name + 1);
+		}
+	    }
+	}
+	fclose(xedb);
+    }
+
+    LoadExtensionNames(RequestNames);
+
+    for (i = 0; i < 256; i++) {
+	if (RequestNames[i] == 0) {
+#define RN_SIZE 12 /* "Request#' + up to 3 digits + \0 */
+	    RequestNames[i] = xalloc(RN_SIZE);
+	    if (RequestNames[i]) {
+		snprintf(RequestNames[i], RN_SIZE, "Request#%d", i);
+	    }
+	}
+	/* fprintf(stderr, "%d: %s\n", i, RequestNames[i]); */
+    }
+}
+
+static void FreeRequestNames(void)
+{
+    int i;
+
+    for (i = 0; i < 256; i++) {
+	if (RequestNames[i] != 0) {
+	    free(RequestNames[i]);
+	    RequestNames[i] = 0;
+	}
+    }
+}
+
+#endif

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/dixutils.c

@@ -95,9 +95,7 @@ Author:  Adobe Systems Incorporated
 #include "scrnintstr.h"
 #define  XK_LATIN1
 #include <X11/keysymdef.h>
-#ifdef XACE
 #include "xace.h"
-#endif
 
 /*
  * CompareTimeStamps returns -1, 0, or +1 depending on if the first

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,12 +132,17 @@ 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 *);
 #endif
 
-#ifdef XACE
 #include "xace.h"
+
+#ifdef XSERVER_DTRACE
+#include <sys/types.h>
+typedef const char *string;
+#include "Xserver-dtrace.h"
 #endif
 
 #ifdef XEVIE
@@ -154,7 +160,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 +214,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 {
@@ -319,11 +324,16 @@ static CARD8 criticalEvents[32] =
 };
 
 #ifdef PANORAMIX
-
 static void ConfineToShape(RegionPtr shape, int *px, int *py);
-static void SyntheticMotion(int x, int y);
 static void PostNewCursor(void);
 
+#define SyntheticMotion(x, y) \
+    PostSyntheticMotion(x, y, noPanoramiXExtension ? 0 : \
+                              sprite.screen->myNum, \
+                        syncEvents.playingEvents ? \
+                          syncEvents.time.milliseconds : \
+                          currentTime.milliseconds);
+
 static Bool
 XineramaSetCursorPosition(
     int x, 
@@ -666,30 +676,6 @@ SetCriticalEvent(int event)
     criticalEvents[event >> 3] |= 1 << (event & 7);
 }
 
-static void
-SyntheticMotion(int x, int y)
-{
-    xEvent xE;
-
-#ifdef PANORAMIX
-    /* Translate back to the sprite screen since processInputProc
-       will translate from sprite screen to screen 0 upon reentry
-       to the DIX layer */
-    if(!noPanoramiXExtension) {
-	x += panoramiXdataPtr[0].x - panoramiXdataPtr[sprite.screen->myNum].x;
-	y += panoramiXdataPtr[0].y - panoramiXdataPtr[sprite.screen->myNum].y;
-    }
-#endif
-    xE.u.keyButtonPointer.rootX = x;
-    xE.u.keyButtonPointer.rootY = y;
-    if (syncEvents.playingEvents)
-	xE.u.keyButtonPointer.time = syncEvents.time.milliseconds;
-    else
-	xE.u.keyButtonPointer.time = currentTime.milliseconds;
-    xE.u.u.type = MotionNotify;
-    (*inputInfo.pointer->public.processInputProc)(&xE, inputInfo.pointer, 1);
-}
-
 #ifdef SHAPE
 static void
 ConfineToShape(RegionPtr shape, int *px, int *py)
@@ -1531,9 +1517,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 +1534,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 +1574,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;
     }
@@ -2476,10 +2461,8 @@ CheckPassiveGrabsOnWindow(
 	     (grab->confineTo->realized && 
 				BorderSizeNotEmpty(grab->confineTo))))
 	{
-#ifdef XACE
 	    if (!XaceHook(XACE_DEVICE_ACCESS, wClient(pWin), device, FALSE))
 		return FALSE;
-#endif
 #ifdef XKB
 	    if (!noXkbExtension) {
 		XE_KBPTR.state &= 0x1f00;
@@ -2776,13 +2759,6 @@ drawable.id:0;
     }
 #endif
 
-#ifdef DEBUG
-    if ((xkbDebugFlags&0x4)&&
-	((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
-	ErrorF("CoreProcessKbdEvent: Key %d %s\n",key,
-			(xE->u.u.type==KeyPress?"down":"up"));
-    }
-#endif
     switch (xE->u.u.type)
     {
 	case KeyPress: 
@@ -2847,9 +2823,7 @@ drawable.id:0;
     if (deactivateGrab)
         (*keybd->DeactivateGrab)(keybd);
 
-#ifdef XACE
     XaceHook(XACE_KEY_AVAIL, xE, keybd, count);
-#endif
 }
 
 #ifdef XKB
@@ -2867,13 +2841,12 @@ FixKeyState (register xEvent *xE, register DeviceIntPtr keybd)
     key = xE->u.u.detail;
     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))) {
+	DebugF("FixKeyState: Key %d %s\n",key,
-	ErrorF("FixKeyState: Key %d %s\n",key,
 			(xE->u.u.type==KeyPress?"down":"up"));
     }
-#endif
+
     switch (xE->u.u.type)
     {
 	case KeyPress: 
@@ -3101,12 +3074,7 @@ EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask ma
     if (wClient (pWin) == client)
     {
 	check = pWin->eventMask;
-#ifdef SGIMISC
-	pWin->eventMask =
-	    (mask & ~SGIMiscSpecialDestroyMask) | (pWin->eventMask & SGIMiscSpecialDestroyMask);
-#else
 	pWin->eventMask = mask;
-#endif
     }
     else
     {
@@ -3115,9 +3083,6 @@ EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask ma
 	    if (SameClient(others, client))
 	    {
 		check = others->mask;
-#ifdef SGIMISC
-		mask = (mask & ~SGIMiscSpecialDestroyMask) | (others->mask & SGIMiscSpecialDestroyMask);
-#endif
 		if (mask == 0)
 		{
 		    FreeResource(others->resource, RT_NONE);
@@ -3282,17 +3247,13 @@ EnterLeaveEvent(
     if ((type == EnterNotify) && (mask & KeymapStateMask))
     {
 	xKeymapEvent ke;
-
-#ifdef XACE
 	ClientPtr client = grab ? rClient(grab)
 				: clients[CLIENT_ID(pWin->drawable.id)];
-	if (!XaceHook(XACE_DEVICE_ACCESS, client, keybd, FALSE))
+	if (XaceHook(XACE_DEVICE_ACCESS, client, keybd, FALSE))
-	{
+	    memmove((char *)&ke.map[0], (char *)&keybd->key->down[1], 31);
-	    bzero((char *)&ke.map[0], 31);
-	}
 	else
-#endif
+	    bzero((char *)&ke.map[0], 31);
-	memmove((char *)&ke.map[0], (char *)&keybd->key->down[1], 31);
+
 	ke.type = KeymapNotify;
 	if (grab)
 	    (void)TryClientEvents(rClient(grab), (xEvent *)&ke, 1, mask,
@@ -3378,15 +3339,12 @@ FocusEvent(DeviceIntPtr dev, int type, int mode, int detail, register WindowPtr
 	((pWin->eventMask | wOtherEventMasks(pWin)) & KeymapStateMask))
     {
 	xKeymapEvent ke;
-#ifdef XACE
 	ClientPtr client = clients[CLIENT_ID(pWin->drawable.id)];
-	if (!XaceHook(XACE_DEVICE_ACCESS, client, dev, FALSE))
+	if (XaceHook(XACE_DEVICE_ACCESS, client, dev, FALSE))
-	{
+	    memmove((char *)&ke.map[0], (char *)&dev->key->down[1], 31);
-	    bzero((char *)&ke.map[0], 31);
-	}
 	else
-#endif
+	    bzero((char *)&ke.map[0], 31);
-	memmove((char *)&ke.map[0], (char *)&dev->key->down[1], 31);
+
 	ke.type = KeymapNotify;
 	(void)DeliverEventsToWindow(pWin, (xEvent *)&ke, 1,
 				    KeymapStateMask, NullGrab, 0);
@@ -3649,10 +3607,10 @@ ProcSetInputFocus(client)
     REQUEST(xSetInputFocusReq);
 
     REQUEST_SIZE_MATCH(xSetInputFocusReq);
-#ifdef XACE
+
     if (!XaceHook(XACE_DEVICE_ACCESS, client, inputInfo.keyboard, TRUE))
 	return Success;
-#endif
+
     return SetInputFocus(client, inputInfo.keyboard, stuff->focus,
 			 stuff->revertTo, stuff->time, FALSE);
 }
@@ -3914,18 +3872,17 @@ ProcGrabKeyboard(ClientPtr client)
     int result;
 
     REQUEST_SIZE_MATCH(xGrabKeyboardReq);
-#ifdef XACE
+
-    if (!XaceHook(XACE_DEVICE_ACCESS, client, inputInfo.keyboard, TRUE))
+    if (XaceHook(XACE_DEVICE_ACCESS, client, inputInfo.keyboard, TRUE))
-    {
+	result = GrabDevice(client, inputInfo.keyboard, stuff->keyboardMode,
+			    stuff->pointerMode, stuff->grabWindow,
+			    stuff->ownerEvents, stuff->time,
+			    KeyPressMask | KeyReleaseMask, &rep.status);
+    else {
 	result = Success;
 	rep.status = AlreadyGrabbed;
     }
-    else
+
-#endif
-    result = GrabDevice(client, inputInfo.keyboard, stuff->keyboardMode,
-			stuff->pointerMode, stuff->grabWindow,
-			stuff->ownerEvents, stuff->time,
-			KeyPressMask | KeyReleaseMask, &rep.status);
     if (result != Success)
 	return result;
     rep.type = X_Reply;
@@ -4580,6 +4537,14 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
 	eventinfo.count = count;
 	CallCallbacks(&EventCallback, (pointer)&eventinfo);
     }
+#ifdef XSERVER_DTRACE
+    if (XSERVER_SEND_EVENT_ENABLED()) {
+	for (i = 0; i < count; i++)
+	{
+	    XSERVER_SEND_EVENT(pClient->index, events[i].u.u.type, &events[i]);
+	}
+    }
+#endif	
     if(pClient->swapped)
     {
 	for(i = 0; i < count; i++)

dix/extension.c

@@ -59,9 +59,7 @@ SOFTWARE.
 #include "gcstruct.h"
 #include "scrnintstr.h"
 #include "dispatch.h"
-#ifdef XACE
 #include "xace.h"
-#endif
 
 #define EXTENSION_BASE  128
 #define EXTENSION_EVENT_BASE  64
@@ -256,11 +254,9 @@ GetExtensionEntry(int major)
 _X_EXPORT void
 DeclareExtensionSecurity(char *extname, Bool secure)
 {
-#ifdef XACE
     int i = FindExtension(extname, strlen(extname));
     if (i >= 0)
 	XaceHook(XACE_DECLARE_EXT_SECURE, extensions[i], secure);
-#endif
 }
 
 _X_EXPORT unsigned short
@@ -336,12 +332,7 @@ ProcQueryExtension(ClientPtr client)
     else
     {
 	i = FindExtension((char *)&stuff[1], stuff->nbytes);
-        if (i < 0
+        if (i < 0 || !XaceHook(XACE_EXT_ACCESS, client, extensions[i]))
-#ifdef XACE
-	    /* call callbacks to find out whether to show extension */
-	    || !XaceHook(XACE_EXT_ACCESS, client, extensions[i])
-#endif
-	    )
             reply.present = xFalse;
         else
         {            
@@ -376,11 +367,10 @@ ProcListExtensions(ClientPtr client)
 
         for (i=0;  i<NumExtensions; i++)
 	{
-#ifdef XACE
 	    /* call callbacks to find out whether to show extension */
 	    if (!XaceHook(XACE_EXT_ACCESS, client, extensions[i]))
 		continue;
-#endif
+
 	    total_length += strlen(extensions[i]->name) + 1;
 	    reply.nExtensions += 1 + extensions[i]->num_aliases;
 	    for (j = extensions[i]->num_aliases; --j >= 0;)
@@ -393,10 +383,9 @@ ProcListExtensions(ClientPtr client)
         for (i=0;  i<NumExtensions; i++)
         {
 	    int len;
-#ifdef XACE
 	    if (!XaceHook(XACE_EXT_ACCESS, client, extensions[i]))
 		continue;
-#endif
+
             *bufptr++ = len = strlen(extensions[i]->name);
 	    memmove(bufptr, extensions[i]->name,  len);
 	    bufptr += len;
@@ -482,3 +471,17 @@ RegisterScreenProc(char *name, ScreenPtr pScreen, ExtensionLookupProc proc)
     }
     return TRUE;
 }
+
+#ifdef XSERVER_DTRACE
+void LoadExtensionNames(char **RequestNames) {
+    int i;
+
+    for (i=0; i<NumExtensions; i++) {
+	int r = extensions[i]->base;
+
+	if (RequestNames[r] == NULL) {
+	    RequestNames[r] = strdup(extensions[i]->name);
+	}
+    }
+}
+#endif

dix/ffs.c

@@ -26,10 +26,18 @@ The Open Group.
 
 */
 
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "dix.h"
+
 int
 ffs(int i)
 {
     int j;
+    if (i == 0)
+        return 0;
     for (j = 1; (i & 1) == 0; j++)
 	i >>= 1;
     return j;

dix/getevents.c

@@ -0,0 +1,785 @@
+/*
+ * Copyright © 2006 Nokia Corporation
+ * 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 this copyright notice and this permission notice appear in
+ * supporting electronic documentation.
+ *
+ * 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 HOLDERS OR AUTHORS 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.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/keysym.h>
+#define NEED_EVENTS
+#define NEED_REPLIES
+#include <X11/Xproto.h>
+
+#include "misc.h"
+#include "resource.h"
+#include "inputstr.h"
+#include "scrnintstr.h"
+#include "cursorstr.h"
+#include "dixstruct.h"
+#include "globals.h"
+#include "dixevents.h"
+#include "mipointer.h"
+
+#ifdef XKB
+#include <X11/extensions/XKBproto.h>
+#include <X11/extensions/XKBsrv.h>
+extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
+#endif
+
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#endif
+
+#include <X11/extensions/XI.h>
+#include <X11/extensions/XIproto.h>
+#include "exglobals.h"
+#include "exevents.h"
+#include "exglobals.h"
+#include "extnsionst.h"
+
+
+/* Maximum number of valuators, divided by six, rounded up, to get number
+ * of events. */
+#define MAX_VALUATOR_EVENTS 6
+
+/* Number of motion history events to store. */
+#define MOTION_HISTORY_SIZE 256
+
+
+/**
+ * Pick some arbitrary size for Xi motion history.
+ */
+_X_EXPORT int
+GetMotionHistorySize()
+{
+    return MOTION_HISTORY_SIZE;
+}
+
+
+/**
+ * Allocate the motion history buffer.
+ */
+_X_EXPORT void
+AllocateMotionHistory(DeviceIntPtr pDev)
+{
+    if (pDev->valuator->motion)
+        xfree(pDev->valuator->motion);
+
+    if (pDev->valuator->numMotionEvents < 1)
+        return;
+
+    pDev->valuator->motion = xalloc(((sizeof(INT32) * pDev->valuator->numAxes) +
+                                     sizeof(Time)) *
+                                    pDev->valuator->numMotionEvents);
+    pDev->valuator->first_motion = 0;
+    pDev->valuator->last_motion = 0;
+}
+
+
+/**
+ * Dump the motion history between start and stop into the supplied buffer.
+ * Only records the event for a given screen in theory, but in practice, we
+ * sort of ignore this.
+ */
+_X_EXPORT int
+GetMotionHistory(DeviceIntPtr pDev, xTimecoord *buff, unsigned long start,
+                 unsigned long stop, ScreenPtr pScreen)
+{
+    char *ibuff = NULL, *obuff = (char *) buff;
+    int i = 0, ret = 0;
+    Time current;
+    /* The size of a single motion event. */
+    int size = (sizeof(INT32) * pDev->valuator->numAxes) + sizeof(Time);
+
+    if (!pDev->valuator || !pDev->valuator->numMotionEvents)
+        return 0;
+
+    for (i = pDev->valuator->first_motion;
+         i != pDev->valuator->last_motion;
+         i = (i + 1) % pDev->valuator->numMotionEvents) {
+        /* We index the input buffer by which element we're accessing, which
+         * is not monotonic, and the output buffer by how many events we've
+         * written so far. */
+        ibuff = (char *) pDev->valuator->motion + (i * size);
+        memcpy(&current, ibuff, sizeof(Time));
+
+        if (current > stop) {
+            return ret;
+        }
+        else if (current >= start) {
+            memcpy(obuff, ibuff, size);
+            obuff += size;
+            ret++;
+        }
+    }
+
+    return ret;
+}
+
+
+/**
+ * Update the motion history for a specific device, with the list of
+ * valuators.
+ */
+static void
+updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, int first_valuator,
+                    int num_valuators, int *valuators)
+{
+    char *buff = (char *) pDev->valuator->motion;
+
+    if (!pDev->valuator->numMotionEvents)
+        return;
+
+    buff += ((sizeof(INT32) * pDev->valuator->numAxes) + sizeof(CARD32)) *
+            pDev->valuator->last_motion;
+    memcpy(buff, &ms, sizeof(Time));
+
+    buff += sizeof(Time);
+    bzero(buff, sizeof(INT32) * pDev->valuator->numAxes);
+
+    buff += sizeof(INT32) * first_valuator;
+    memcpy(buff, valuators, sizeof(INT32) * num_valuators);
+
+    pDev->valuator->last_motion = (pDev->valuator->last_motion + 1) %
+                                  pDev->valuator->numMotionEvents;
+
+    /* If we're wrapping around, just keep the circular buffer going. */
+    if (pDev->valuator->first_motion == pDev->valuator->last_motion)
+        pDev->valuator->first_motion = (pDev->valuator->first_motion + 1) %
+                                       pDev->valuator->numMotionEvents;
+
+    return;
+}
+
+
+/**
+ * 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());
+ */
+_X_EXPORT 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;
+}
+
+
+/* Originally a part of xf86PostMotionEvent; modifies valuators
+ * in-place. */
+static void
+acceleratePointer(DeviceIntPtr pDev, int first_valuator, int num_valuators,
+                  int *valuators)
+{
+    float mult = 0.0;
+    int dx = 0, dy = 0;
+    int *px = NULL, *py = NULL;
+
+    if (!num_valuators || !valuators)
+        return;
+
+    if (first_valuator == 0) {
+        dx = valuators[0];
+        px = &valuators[0];
+    }
+    if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
+        dy = valuators[1 - first_valuator];
+        py = &valuators[1 - first_valuator];
+    }
+
+    if (!dx && !dy)
+        return;
+
+    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;
+                if (px) {
+                    *px = (int)pDev->valuator->dxremaind;
+                    pDev->valuator->dxremaind = pDev->valuator->dxremaind -
+                                                (float)(*px);
+                }
+
+                pDev->valuator->dyremaind = ((float)dy *
+                                             (float)(pDev->ptrfeed->ctrl.num)) /
+                                             (float)(pDev->ptrfeed->ctrl.den) +
+                                            pDev->valuator->dyremaind;
+                if (py) {
+                    *py = (int)pDev->valuator->dyremaind;
+                    pDev->valuator->dyremaind = pDev->valuator->dyremaind -
+                                                (float)(*py);
+                }
+            }
+        }
+        else {
+            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;
+                *px = (int)pDev->valuator->dxremaind;
+                pDev->valuator->dxremaind = pDev->valuator->dxremaind -
+                                            (float)(*px);
+            }
+            if (dy) {
+                pDev->valuator->dyremaind = mult * (float)dy +
+                                            pDev->valuator->dyremaind;
+                *py = (int)pDev->valuator->dyremaind;
+                pDev->valuator->dyremaind = pDev->valuator->dyremaind -
+                                            (float)(*py);
+            }
+        }
+    }
+}
+
+
+/**
+ * Clip an axis to its bounds, which are declared in the call to
+ * InitValuatorAxisClassStruct.
+ */
+static void
+clipAxis(DeviceIntPtr pDev, int axisNum, int *val)
+{
+    AxisInfoPtr axes = pDev->valuator->axes + axisNum;
+
+    if (*val < axes->min_value)
+        *val = axes->min_value;
+    if (axes->max_value >= 0 && *val > axes->max_value)
+        *val = axes->max_value;
+}
+
+/**
+ * Clip every axis in the list of valuators to its bounds.
+ */
+static void
+clipValuators(DeviceIntPtr pDev, int first_valuator, int num_valuators,
+              int *valuators)
+{
+    AxisInfoPtr axes = pDev->valuator->axes + first_valuator;
+    int i;
+
+    for (i = 0; i < num_valuators; i++, axes++)
+        clipAxis(pDev, i + first_valuator, &(valuators[i]));
+}
+
+
+/**
+ * Fills events with valuator events for pDev, as given by the other
+ * parameters.
+ *
+ * FIXME: Need to fix ValuatorClassRec to store all the valuators as
+ *        last posted, not just x and y; otherwise relative non-x/y
+ *        valuators, though a very narrow use case, will be broken.
+ */
+static xEvent *
+getValuatorEvents(xEvent *events, DeviceIntPtr pDev, int first_valuator,
+                  int num_valuators, int *valuators) {
+    deviceValuator *xv = (deviceValuator *) events;
+    int i = 0, final_valuator = first_valuator + num_valuators;
+
+    for (i = first_valuator; i < final_valuator; i += 6, xv++, events++) {
+        xv->type = DeviceValuator;
+        xv->first_valuator = i;
+        xv->num_valuators = num_valuators;
+        xv->deviceid = pDev->id;
+        switch (final_valuator - i) {
+        case 6:
+            xv->valuator5 = valuators[i + 5];
+        case 5:
+            xv->valuator4 = valuators[i + 4];
+        case 4:
+            xv->valuator3 = valuators[i + 3];
+        case 3:
+            xv->valuator2 = valuators[i + 2];
+        case 2:
+            xv->valuator1 = valuators[i + 1];
+        case 1:
+            xv->valuator0 = valuators[i];
+        }
+
+        if (i + 6 < final_valuator)
+            xv->deviceid |= MORE_EVENTS;
+    }
+
+    return events;
+}
+
+
+/**
+ * Convenience wrapper around GetKeyboardValuatorEvents, that takes no
+ * valuators.
+ */
+_X_EXPORT int
+GetKeyboardEvents(xEvent *events, DeviceIntPtr pDev, int type, int key_code) {
+    return GetKeyboardValuatorEvents(events, pDev, type, key_code, 0, 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.
+ *
+ * This function does not change the core keymap to that of the device;
+ * that is done by SwitchCoreKeyboard, which is called from
+ * mieqProcessInputEvents.  If replacing that function, take care to call
+ * SetCoreKeyboard before processInputProc, so keymaps are altered to suit.
+ *
+ * Note that this function recurses!  If called for non-XKB, a repeating
+ * key press will trigger a matching KeyRelease, as well as the
+ * KeyPresses.
+ */
+_X_EXPORT int
+GetKeyboardValuatorEvents(xEvent *events, DeviceIntPtr pDev, int type,
+                          int key_code, int first_valuator,
+                          int num_valuators, int *valuators) {
+    int numEvents = 0;
+    CARD32 ms = 0;
+    KeySym *map = pDev->key->curKeySyms.map;
+    KeySym sym = map[key_code * pDev->key->curKeySyms.mapWidth];
+    deviceKeyButtonPointer *kbp = NULL;
+
+    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 in non-XKB,
+     *        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,
+                                                   first_valuator, 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;
+
+    events++;
+    if (num_valuators) {
+        kbp->deviceid |= MORE_EVENTS;
+        clipValuators(pDev, first_valuator, num_valuators, valuators);
+        events = getValuatorEvents(events, pDev, first_valuator,
+                                   num_valuators, valuators);
+    }
+
+    if (pDev->coreEvents) {
+        events->u.keyButtonPointer.time = ms;
+        events->u.u.type = type;
+        events->u.u.detail = key_code;
+    }
+
+    return numEvents;
+}
+
+
+/**
+ * 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.
+ */
+_X_EXPORT int
+GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
+                 int flags, int first_valuator, int num_valuators,
+                 int *valuators) {
+    int num_events = 0, final_valuator = 0;
+    CARD32 ms = 0;
+    deviceKeyButtonPointer *kbp = NULL;
+    /* Thanks to a broken lib, we _always_ have to chase DeviceMotionNotifies
+     * with DeviceValuators. */
+    Bool sendValuators = (type == MotionNotify || flags & POINTER_ABSOLUTE);
+    DeviceIntPtr cp = inputInfo.pointer;
+    int x = 0, y = 0;
+
+    /* Sanity checks. */
+    if (type != MotionNotify && type != ButtonPress && type != ButtonRelease)
+        return 0;
+
+    if ((type == ButtonPress || type == ButtonRelease) && !pDev->button)
+        return 0;
+
+    if (pDev->coreEvents)
+        num_events = 2;
+    else
+        num_events = 1;
+
+    if (type == MotionNotify && num_valuators <= 0) {
+        return 0;
+    }
+
+    /* Do we need to send a DeviceValuator event? */
+    if (sendValuators) {
+        if ((((num_valuators - 1) / 6) + 1) > MAX_VALUATOR_EVENTS)
+            num_valuators = MAX_VALUATOR_EVENTS * 6;
+        num_events += ((num_valuators - 1) / 6) + 1;
+    }
+
+    final_valuator = num_valuators + first_valuator;
+
+    /* You fail. */
+    if (first_valuator < 0 || final_valuator > pDev->valuator->numAxes)
+        return 0;
+
+    ms = GetTimeInMillis();
+
+    kbp = (deviceKeyButtonPointer *) events;
+    kbp->time = ms;
+    kbp->deviceid = pDev->id;
+
+    /* Set x and y based on whether this is absolute or relative, and
+     * accelerate if we need to. */
+    if (flags & POINTER_ABSOLUTE) {
+        if (num_valuators >= 1 && first_valuator == 0) {
+            x = valuators[0];
+        }
+        else {
+            if (pDev->coreEvents)
+                x = cp->valuator->lastx;
+            else
+                x = pDev->valuator->lastx;
+        }
+
+        if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
+            y = valuators[1 - first_valuator];
+        }
+        else {
+            if (pDev->coreEvents)
+                y = cp->valuator->lasty;
+            else
+                y = pDev->valuator->lasty;
+        }
+    }
+    else {
+        if (flags & POINTER_ACCELERATE)
+            acceleratePointer(pDev, first_valuator, num_valuators,
+                              valuators);
+
+        if (pDev->coreEvents) {
+            if (first_valuator == 0 && num_valuators >= 1)
+                x = cp->valuator->lastx + valuators[0];
+            else
+                x = cp->valuator->lastx;
+
+            if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
+                y = cp->valuator->lasty + valuators[1 - first_valuator];
+            else
+                y = cp->valuator->lasty;
+        }
+        else {
+            if (first_valuator == 0 && num_valuators >= 1)
+                x = pDev->valuator->lastx + valuators[0];
+            else
+                x = pDev->valuator->lastx;
+
+            if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
+                y = pDev->valuator->lasty + valuators[1 - first_valuator];
+            else
+                y = pDev->valuator->lasty;
+        }
+    }
+
+    /* Clip both x and y to the defined limits (usually co-ord space limit). */
+    clipAxis(pDev, 0, &x);
+    clipAxis(pDev, 1, &y);
+
+    /* This takes care of crossing screens for us, as well as clipping
+     * to the current screen.  Right now, we only have one history buffer,
+     * so we don't set this for both the device and core.*/
+    miPointerSetPosition(pDev, &x, &y, ms);
+
+    /* Drop x and y back into the valuators list, if they were originally
+     * present. */
+    if (first_valuator == 0 && num_valuators >= 1)
+        valuators[0] = x;
+    if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
+        valuators[1 - first_valuator] = y;
+
+    updateMotionHistory(pDev, ms, first_valuator, num_valuators, valuators);
+
+    if (pDev->coreEvents) {
+        cp->valuator->lastx = x;
+        cp->valuator->lasty = y;
+    }
+    pDev->valuator->lastx = x;
+    pDev->valuator->lasty = 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];
+    }
+
+    kbp->root_x = x;
+    kbp->root_y = y;
+
+    events++;
+    if (sendValuators) {
+        kbp->deviceid |= MORE_EVENTS;
+        clipValuators(pDev, first_valuator, num_valuators, valuators);
+        events = getValuatorEvents(events, pDev, first_valuator,
+                                   num_valuators, valuators);
+    }
+
+    if (pDev->coreEvents) {
+        events->u.u.type = type;
+        events->u.keyButtonPointer.time = ms;
+        events->u.keyButtonPointer.rootX = x;
+        events->u.keyButtonPointer.rootY = y;
+
+        if (type == ButtonPress || type == ButtonRelease) {
+            /* We hijack SetPointerMapping to work on all core-sending
+             * devices, so we use the device-specific map here instead of
+             * the core one. */
+            events->u.u.detail = pDev->button->map[buttons];
+        }
+        else {
+            events->u.u.detail = 0;
+        }
+    }
+
+    return num_events;
+}
+
+
+/**
+ * Post ProximityIn/ProximityOut events, accompanied by valuators.
+ *
+ * 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.
+ */
+_X_EXPORT int
+GetProximityEvents(xEvent *events, DeviceIntPtr pDev, int type,
+                   int first_valuator, int num_valuators, int *valuators)
+{
+    int num_events = 0;
+    deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer *) events;
+
+    /* Sanity checks. */
+    if (type != ProximityIn && type != ProximityOut)
+        return 0;
+
+    if (!pDev->valuator)
+        return 0;
+
+    /* Do we need to send a DeviceValuator event? */
+    if ((pDev->valuator->mode & 1) == Relative)
+        num_valuators = 0;
+
+    if (num_valuators) {
+        if ((((num_valuators - 1) / 6) + 1) > MAX_VALUATOR_EVENTS)
+            num_valuators = MAX_VALUATOR_EVENTS * 6;
+        num_events += ((num_valuators - 1) / 6) + 1;
+    }
+
+    /* You fail. */
+    if (first_valuator < 0 ||
+        (num_valuators + first_valuator) > pDev->valuator->numAxes)
+        return 0;
+
+    kbp->type = type;
+    kbp->deviceid = pDev->id;
+    kbp->detail = 0;
+    kbp->time = GetTimeInMillis();
+
+    if (num_valuators) {
+        kbp->deviceid |= MORE_EVENTS;
+        events++;
+        clipValuators(pDev, first_valuator, num_valuators, valuators);
+        events = getValuatorEvents(events, pDev, first_valuator,
+                                   num_valuators, valuators);
+    }
+
+    return num_events;
+}
+
+
+/**
+ * Note that pDev was the last device to send a core event.  This function
+ * copies the complete keymap from the originating device to the core
+ * device, and makes sure the appropriate notifications are generated.
+ *
+ * Call this just before processInputProc.
+ */
+_X_EXPORT void
+SwitchCoreKeyboard(DeviceIntPtr pDev)
+{
+    KeyClassPtr ckeyc = inputInfo.keyboard->key;
+
+    if (inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr != pDev) {
+        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;
+    }
+}
+
+
+/**
+ * Note that pDev was the last function to send a core pointer event.
+ * Currently a no-op.
+ *
+ * Call this just before processInputProc.
+ */
+_X_EXPORT void
+SwitchCorePointer(DeviceIntPtr pDev)
+{
+    if (inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr != pDev)
+        inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
+}
+
+
+/**
+ * Synthesize a single motion event for the core pointer.
+ *
+ * Used in cursor functions, e.g. when cursor confinement changes, and we need
+ * to shift the pointer to get it inside the new bounds.
+ */
+void
+PostSyntheticMotion(int x, int y, ScreenPtr pScreen, unsigned long time)
+{
+    xEvent xE;
+
+#ifdef PANORAMIX
+    /* Translate back to the sprite screen since processInputProc
+       will translate from sprite screen to screen 0 upon reentry
+       to the DIX layer. */
+    if (!noPanoramiXExtension) {
+        x += panoramiXdataPtr[0].x - panoramiXdataPtr[pScreen->myNum].x;
+        y += panoramiXdataPtr[0].y - panoramiXdataPtr[pScreen->myNum].y;
+    }
+#endif
+
+    memset(&xE, 0, sizeof(xEvent));
+    xE.u.u.type = MotionNotify;
+    xE.u.keyButtonPointer.rootX = x;
+    xE.u.keyButtonPointer.rootY = y;
+    xE.u.keyButtonPointer.time = time;
+
+    (*inputInfo.pointer->public.processInputProc)(&xE, inputInfo.pointer, 1);
+}

dix/globals.c

@@ -105,7 +105,7 @@ int  ScreenSaverAllowExposures;
 #  define DEFAULT_OFF_TIME DEFAULT_SCREEN_SAVER_TIME * 4
 # endif
 # ifndef DEFAULT_DPMS_ENABLED
-#  define DEFAULT_DPMS_ENABLED FALSE
+#  define DEFAULT_DPMS_ENABLED TRUE
 # endif
 CARD32 defaultDPMSStandbyTime = DEFAULT_STANDBY_TIME;
 CARD32 defaultDPMSSuspendTime = DEFAULT_SUSPEND_TIME;

dix/main.c

@@ -98,6 +98,7 @@ Equipment Corporation.
 #include <X11/fonts/font.h>
 #include "opaque.h"
 #include "servermd.h"
+#include "hotplug.h"
 #include "site.h"
 #include "dixfont.h"
 #include "extnsionst.h"
@@ -310,6 +311,7 @@ main(int argc, char *argv[], char *envp[])
 	InitBlockAndWakeupHandlers();
 	/* Perform any operating system dependent initializations you'd like */
 	OsInit();
+        configInitialise();
 	if(serverGeneration == 1)
 	{
 	    CreateWellKnownSockets();
@@ -394,23 +396,43 @@ 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))
+	if (!SetDefaultFont(defaultTextFont)) {
 	    FatalError("could not open default font '%s'", defaultTextFont);
-	if (!(rootCursor = CreateRootCursor(defaultCursorFont, 0)))
+	}
+#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();
@@ -433,13 +455,15 @@ main(int argc, char *argv[], char *envp[])
 
 #ifdef PANORAMIX
 	if (!noPanoramiXExtension) {
-	    if (!PanoramiXCreateConnectionBlock())
+	    if (!PanoramiXCreateConnectionBlock()) {
 		FatalError("could not create connection block info");
+	    }
 	} else
 #endif
 	{
-	    if (!CreateConnectionBlock())
+	    if (!CreateConnectionBlock()) {
 	    	FatalError("could not create connection block info");
+	    }
 	}
 
 	Dispatch();
@@ -461,6 +485,7 @@ main(int argc, char *argv[], char *envp[])
 	FreeAllResources();
 #endif
 
+        configFini();
 	CloseDownDevices();
 	for (i = screenInfo.numScreens - 1; i >= 0; i--)
 	{
@@ -681,9 +706,6 @@ AddScreen(
     int i;
     int scanlinepad, format, depth, bitsPerPixel, j, k;
     ScreenPtr pScreen;
-#ifdef DEBUG
-    void	(**jNI) ();
-#endif /* DEBUG */
 
     i = screenInfo.numScreens;
     if (i == MAXSCREENS)
@@ -717,13 +739,6 @@ AddScreen(
     pScreen->ClipNotify = 0;	/* for R4 ddx compatibility */
     pScreen->CreateScreenResources = 0;
     
-#ifdef DEBUG
-    for (jNI = &pScreen->QueryBestSize; 
-	 jNI < (void (**) ()) &pScreen->SendGraphicsExpose;
-	 jNI++)
-	*jNI = NotImplemented;
-#endif /* DEBUG */
-
     /*
      * This loop gets run once for every Screen that gets added,
      * but thats ok.  If the ddx layer initializes the formats

dix/property.c

@@ -58,9 +58,7 @@ SOFTWARE.
 #include "dixstruct.h"
 #include "dispatch.h"
 #include "swaprep.h"
-#ifdef XACE
 #include "xace.h"
-#endif
 
 /*****************************************************************
  * Property Stuff
@@ -118,27 +116,19 @@ ProcRotateProperties(ClientPtr client)
 	return(BadAlloc);
     for (i = 0; i < stuff->nAtoms; i++)
     {
-#ifdef XACE
 	char action = XaceHook(XACE_PROPERTY_ACCESS, client, pWin, atoms[i],
 				SecurityReadAccess|SecurityWriteAccess);
-#endif
+
-        if (!ValidAtom(atoms[i])
+        if (!ValidAtom(atoms[i]) || (XaceErrorOperation == action)) {
-#ifdef XACE
-	    || (SecurityErrorOperation == action)
-#endif
-	   )
-        {
             DEALLOCATE_LOCAL(props);
 	    client->errorValue = atoms[i];
             return BadAtom;
         }
-#ifdef XACE
+	if (XaceIgnoreOperation == action) {
-	if (SecurityIgnoreOperation == action)
-        {
             DEALLOCATE_LOCAL(props);
 	    return Success;
 	}
-#endif
+
         for (j = i + 1; j < stuff->nAtoms; j++)
             if (atoms[j] == atoms[i])
             {
@@ -233,17 +223,15 @@ ProcChangeProperty(ClientPtr client)
 	return(BadAtom);
     }
 
-#ifdef XACE
     switch (XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
-					SecurityWriteAccess))
+		     SecurityWriteAccess))
     {
-	case SecurityErrorOperation:
+    case XaceErrorOperation:
-	    client->errorValue = stuff->property;
+	client->errorValue = stuff->property;
-	    return BadAtom;
+	return BadAtom;
-	case SecurityIgnoreOperation:
+    case XaceIgnoreOperation:
-	    return Success;
+	return Success;
     }
-#endif
 
     err = ChangeWindowProperty(pWin, stuff->property, stuff->type, (int)format,
 			       (int)mode, len, (pointer)&stuff[1], TRUE);
@@ -460,6 +448,7 @@ ProcGetProperty(ClientPtr client)
     unsigned long n, len, ind;
     WindowPtr pWin;
     xGetPropertyReply reply;
+    Mask access_mode = SecurityReadAccess;
     REQUEST(xGetPropertyReq);
 
     REQUEST_SIZE_MATCH(xGetPropertyReq);
@@ -501,24 +490,18 @@ ProcGetProperty(ClientPtr client)
     if (!pProp) 
 	return NullPropertyReply(client, None, 0, &reply);
 
-#ifdef XACE
+    if (stuff->delete)
+	access_mode |= SecurityDestroyAccess;
+    switch (XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
+		     access_mode))
     {
-	Mask access_mode = SecurityReadAccess;
+    case XaceErrorOperation:
-
+	client->errorValue = stuff->property;
-	if (stuff->delete)
+	return BadAtom;;
-	    access_mode |= SecurityDestroyAccess;
+    case XaceIgnoreOperation:
-	switch(XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
+	return NullPropertyReply(client, pProp->type, pProp->format, &reply);
-					   access_mode))
-	{
-	    case SecurityErrorOperation:
-		client->errorValue = stuff->property;
-		return BadAtom;;
-	    case SecurityIgnoreOperation:
-		return NullPropertyReply(client, pProp->type, pProp->format,
-					 &reply);
-	}
     }
-#endif
+
     /* If the request type and actual type don't match. Return the
     property information, but not the data. */
 
@@ -663,17 +646,15 @@ ProcDeleteProperty(register ClientPtr client)
 	return (BadAtom);
     }
 
-#ifdef XACE
+    switch (XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
-    switch(XaceHook(XACE_PROPERTY_ACCESS, client, pWin, stuff->property,
+		     SecurityDestroyAccess))
-				       SecurityDestroyAccess))
     {
-	case SecurityErrorOperation:
+    case XaceErrorOperation:
-	    client->errorValue = stuff->property;
+	client->errorValue = stuff->property;
-	    return BadAtom;;
+	return BadAtom;;
-	case SecurityIgnoreOperation:
+    case XaceIgnoreOperation:
-	    return Success;
+	return Success;
     }
-#endif
 
     result = DeleteProperty(pWin, stuff->property);
     if (client->noClientException != Success)

dix/resource.c

@@ -72,6 +72,34 @@ dealings in this Software without prior written authorization from Digital
 Equipment Corporation.
 
 ******************************************************************/
+/* XSERVER_DTRACE additions:
+ * Copyright 2005-2006 Sun Microsystems, Inc.  All rights reserved.
+ *
+ * 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, and/or sell copies of the Software, and to permit persons
+ * to whom the Software is furnished to do so, provided that the above
+ * copyright notice(s) and this permission notice appear in all copies of
+ * the Software and that both the above copyright notice(s) and this
+ * permission notice appear in supporting documentation.
+ * 
+ * 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
+ * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * 
+ * Except as contained in this notice, the name of a copyright holder
+ * shall not be used in advertising or otherwise to promote the sale, use
+ * or other dealings in this Software without prior written authorization
+ * of the copyright holder.
+ */
 
 /* $TOG: resource.c /main/41 1998/02/09 14:20:31 kaleb $ */
 
@@ -120,11 +148,17 @@ Equipment Corporation.
 #include "panoramiX.h"
 #include "panoramiXsrv.h"
 #endif
-#ifdef XACE
 #include "xace.h"
-#endif
 #include <assert.h>
 
+#ifdef XSERVER_DTRACE
+#include <sys/types.h>
+typedef const char *string;
+#include "Xserver-dtrace.h"
+
+#define TypeNameString(t) NameForAtom(ResourceNames[t & TypeMask])
+#endif
+
 static void RebuildTable(
     int /*client*/
 );
@@ -429,6 +463,9 @@ AddResource(XID id, RESTYPE type, pointer value)
     register ClientResourceRec *rrec;
     register ResourcePtr res, *head;
     	
+#ifdef XSERVER_DTRACE
+    XSERVER_RESOURCE_ALLOC(id, type, value, TypeNameString(type));
+#endif
     client = CLIENT_ID(id);
     rrec = &clientTable[client];
     if (!rrec->buckets)
@@ -528,6 +565,11 @@ FreeResource(XID id, RESTYPE skipDeleteFuncType)
 	    if (res->id == id)
 	    {
 		RESTYPE rtype = res->type;
+
+#ifdef XSERVER_DTRACE
+		XSERVER_RESOURCE_FREE(res->id, res->type,
+			      res->value, TypeNameString(res->type));
+#endif		    
 		*prev = res->next;
 		elements = --*eltptr;
 		if (rtype & RC_CACHED)
@@ -569,6 +611,10 @@ FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
 	{
 	    if (res->id == id && res->type == type)
 	    {
+#ifdef XSERVER_DTRACE
+		XSERVER_RESOURCE_FREE(res->id, res->type,
+			      res->value, TypeNameString(res->type));
+#endif		    		    
 		*prev = res->next;
 		if (type & RC_CACHED)
 		    FlushClientCaches(res->id);
@@ -731,6 +777,10 @@ FreeClientNeverRetainResources(ClientPtr client)
 	    RESTYPE rtype = this->type;
 	    if (rtype & RC_NEVERRETAIN)
 	    {
+#ifdef XSERVER_DTRACE
+		XSERVER_RESOURCE_FREE(this->id, this->type,
+			      this->value, TypeNameString(this->type));
+#endif		    
 		*prev = this->next;
 		if (rtype & RC_CACHED)
 		    FlushClientCaches(this->id);
@@ -777,6 +827,10 @@ FreeClientResources(ClientPtr client)
         for (this = *head; this; this = *head)
 	{
 	    RESTYPE rtype = this->type;
+#ifdef XSERVER_DTRACE
+	    XSERVER_RESOURCE_FREE(this->id, this->type,
+			  this->value, TypeNameString(this->type));
+#endif		    
 	    *head = this->next;
 	    if (rtype & RC_CACHED)
 		FlushClientCaches(this->id);
@@ -848,11 +902,10 @@ SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
 		break;
 	    }
     }
-#ifdef XACE
     if (retval && client && 
 	!XaceHook(XACE_RESOURCE_ACCESS, client, id, rtype, mode, retval))
 	retval = NULL;
-#endif
+
     return retval;
 }
 
@@ -876,11 +929,10 @@ SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
 		break;
 	    }
     }
-#ifdef XACE
     if (retval && client &&
 	!XaceHook(XACE_RESOURCE_ACCESS, client, id, res->type, mode, retval))
 	retval = NULL;
-#endif
+
     return retval;
 }
 

dix/window.c

@@ -126,9 +126,7 @@ Equipment Corporation.
 #ifdef XAPPGROUP
 #include "appgroup.h"
 #endif
-#ifdef XACE
 #include "xace.h"
-#endif
 
 /******
  * Window stuff for server 
@@ -187,7 +185,7 @@ _X_EXPORT int deltaSaveUndersViewable = 0;
  *    For debugging only
  ******/
 
-int
+static void
 PrintChildren(WindowPtr p1, int indent)
 {
     WindowPtr p2;
@@ -197,14 +195,15 @@ PrintChildren(WindowPtr p1, int indent)
     {
 	p2 = p1->firstChild;
 	for (i=0; i<indent; i++) ErrorF( " ");
-	ErrorF( "%x\n", p1->drawable.id);
+	ErrorF( "%lx\n", p1->drawable.id);
 	miPrintRegion(&p1->clipList);
 	PrintChildren(p2, indent+4);
 	p1 = p1->nextSib;
     }
 }
 
-PrintWindowTree()
+static void
+PrintWindowTree(void)
 {
     int i;
     WindowPtr pWin, p1;
@@ -530,9 +529,7 @@ InitRootWindow(WindowPtr pWin)
     /* We SHOULD check for an error value here XXX */
     (*pScreen->ChangeWindowAttributes)(pWin, backFlag);
 
-#ifdef XACE
     XaceHook(XACE_WINDOW_INIT, serverClient, pWin);
-#endif
 
     MapWindow(pWin, serverClient);
 }
@@ -547,9 +544,11 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
                      register int x, register int y,
                      register int w, register int h)
 {
-    ScreenPtr pScreen = pWin->drawable.pScreen;
+    ScreenPtr pScreen;
     BoxRec box;
 
+    pScreen = pWin->drawable.pScreen;
+
     box = *(REGION_EXTENTS(pScreen, &pWin->winSize));
     /* we do these calculations to avoid overflows */
     if (x > box.x1)
@@ -735,18 +734,16 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
     }
 
     pWin->borderWidth = bw;
-#ifdef XACE
+
     /*  can't let untrusted clients have background None windows;
      *  they make it too easy to steal window contents
      */
-    if (!XaceHook(XACE_BACKGRND_ACCESS, client, pWin))
+    if (XaceHook(XACE_BACKGRND_ACCESS, client, pWin))
-    {
+	pWin->backgroundState = None;
+    else {
 	pWin->backgroundState = BackgroundPixel;
 	pWin->background.pixel = 0;
     }
-    else
-#endif
-    pWin->backgroundState = None;
 
     pWin->borderIsPixel = pParent->borderIsPixel;
     pWin->border = pParent->border;
@@ -766,9 +763,7 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
     REGION_NULL(pScreen, &pWin->winSize);
     REGION_NULL(pScreen, &pWin->borderSize);
 
-#ifdef XACE
     XaceHook(XACE_WINDOW_INIT, client, pWin);
-#endif
 
     pHead = RealChildHead(pParent);
     if (pHead)
@@ -1033,24 +1028,18 @@ ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPt
 		borderRelative = TRUE;
 	    if (pixID == None)
 	    {
-#ifdef XACE
 		/*  can't let untrusted clients have background None windows */
-		if (XaceHook(XACE_BACKGRND_ACCESS, client, pWin))
+		if (XaceHook(XACE_BACKGRND_ACCESS, client, pWin)) {
-		{
+		    if (pWin->backgroundState == BackgroundPixmap)
-#endif
+			(*pScreen->DestroyPixmap)(pWin->background.pixmap);
-		if (pWin->backgroundState == BackgroundPixmap)
+		    if (!pWin->parent)
-		    (*pScreen->DestroyPixmap)(pWin->background.pixmap);
+			MakeRootTile(pWin);
-		if (!pWin->parent)
+		    else
-		    MakeRootTile(pWin);
+			pWin->backgroundState = None;
-		else
+		} else {
-		    pWin->backgroundState = None;
+		    /* didn't change the backgrnd to None, so don't tell ddx */
-#ifdef XACE
-		}
-		else
-		{ /* didn't change the background to None, so don't tell ddx */
 		    index2 = 0; 
 		}
-#endif
 	    }
 	    else if (pixID == ParentRelative)
 	    {
@@ -1663,7 +1652,8 @@ CreateUnclippedWinSize (register WindowPtr pWin)
     pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
 #ifdef SHAPE
     if (wBoundingShape (pWin) || wClipShape (pWin)) {
-	ScreenPtr pScreen = pWin->drawable.pScreen;
+	ScreenPtr pScreen;
+        pScreen = pWin->drawable.pScreen;
 
 	REGION_TRANSLATE(pScreen, pRgn, - pWin->drawable.x,
 			 - pWin->drawable.y);
@@ -1699,7 +1689,8 @@ SetWinSize (register WindowPtr pWin)
 			 (int)pWin->drawable.height);
 #ifdef SHAPE
     if (wBoundingShape (pWin) || wClipShape (pWin)) {
-	ScreenPtr pScreen = pWin->drawable.pScreen;
+	ScreenPtr pScreen;
+        pScreen = pWin->drawable.pScreen;
 
 	REGION_TRANSLATE(pScreen, &pWin->winSize, - pWin->drawable.x,
 			 - pWin->drawable.y);
@@ -1741,7 +1732,8 @@ SetBorderSize (register WindowPtr pWin)
 		(int)(pWin->drawable.height + (bw<<1)));
 #ifdef SHAPE
 	if (wBoundingShape (pWin)) {
-	    ScreenPtr pScreen = pWin->drawable.pScreen;
+	    ScreenPtr pScreen;
+            pScreen = pWin->drawable.pScreen;
 
 	    REGION_TRANSLATE(pScreen, &pWin->borderSize, - pWin->drawable.x,
 			     - pWin->drawable.y);
@@ -1952,7 +1944,8 @@ MakeBoundingRegion (
     BoxPtr	pBox)
 {
     RegionPtr	pRgn;
-    ScreenPtr   pScreen = pWin->drawable.pScreen;
+    ScreenPtr   pScreen;
+    pScreen = pWin->drawable.pScreen;
 
     pRgn = REGION_CREATE(pScreen, pBox, 1);
     if (wBoundingShape (pWin)) {
@@ -2732,11 +2725,9 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
     if (pWin->mapped)
 	return(Success);
 
-#ifdef XACE
     /*  general check for permission to map window */
     if (!XaceHook(XACE_MAP_ACCESS, client, pWin))
 	 return Success;
-#endif	
 
     pScreen = pWin->drawable.pScreen;
     if ( (pParent = pWin->parent) )

doc/c-extensions

@@ -0,0 +1,32 @@
+Use of extensions throughout the X server tree
+----------------------------------------------
+
+Optional extensions:
+The server will still build if your toolchain does not support these
+extensions, although the results may not be optimal.
+
+    * _X_SENTINEL(x): member x of the passed structure must be NULL, e.g.:
+                      void parseOptions(Option *options _X_SENTINEL(0));
+                      parseOptions("foo", "bar", NULL); /* this is OK */
+                      parseOptions("foo", "bar", "baz"); /* this is not */
+                      This definition comes from Xfuncproto.h in the core
+                      protocol headers.
+    * _X_ATTRIBUTE_PRINTF(x, y): This function has printf-like semantics;
+                                 check the format string when built with
+                                 -Wformat (gcc) or similar.
+    * _X_EXPORT: this function should appear in symbol tables.
+    * _X_HIDDEN: this function should not appear in the _dynamic_ symbol
+                 table.
+    * _X_INTERNAL: like _X_HIDDEN, but attempt to ensure that this function
+                   is never called from another module.
+    * _X_INLINE: inline this functon if possible (generally obeyed unless
+                 disabling optimisations).
+    * _X_DEPRECATED: warn on use of this function.
+
+Mandatory extensions:
+The server will not build if your toolchain does not support these extensions.
+
+    * named initialisers: explicitly initialising structure members, e.g.:
+                          struct foo bar = { .baz = quux, .brian = "dog" };
+    * variadic macros: macros with a variable number of arguments, e.g.:
+                       #define DebugF(x, ...) /**/

fb/fb.h

@@ -1341,6 +1341,9 @@ fbCreateDefColormap(ScreenPtr pScreen);
 void
 fbClearVisualTypes(void);
 
+Bool
+fbHasVisualTypes (int depth);
+
 Bool
 fbSetVisualTypes (int depth, int visuals, int bitsPerRGB);
 

fb/fbpict.c

@@ -930,9 +930,8 @@ fbComposite (CARD8      op,
     case PictOpOver:
 	if (pMask)
 	{
-	    if (srcRepeat &&
+	    if (fbCanGetSolid(pSrc) &&
-		pSrc->pDrawable->width == 1 &&
+		!maskRepeat)
-		pSrc->pDrawable->height == 1)
 	    {
 		srcRepeat = FALSE;
 		if (PICT_FORMAT_COLOR(pSrc->format)) {
@@ -1044,7 +1043,7 @@ fbComposite (CARD8      op,
 	    {
 		if (pSrc->pDrawable == pMask->pDrawable &&
 		    xSrc == xMask && ySrc == yMask &&
-		    !pMask->componentAlpha)
+		    !pMask->componentAlpha && !maskRepeat)
 		{
 		    /* source == mask: non-premultiplied data */
 		    switch (pSrc->format) {
@@ -1108,9 +1107,7 @@ fbComposite (CARD8      op,
 		else
 		{
 		    /* non-repeating source, repeating mask => translucent window */
-		    if (maskRepeat &&
+		    if (fbCanGetSolid(pMask))
-			pMask->pDrawable->width == 1 &&
-			pMask->pDrawable->height == 1)
 		    {
 			if (pSrc->format == PICT_x8r8g8b8 &&
 			    pDst->format == PICT_x8r8g8b8 &&
@@ -1127,9 +1124,7 @@ fbComposite (CARD8      op,
 	}
 	else /* no mask */
 	{
-	    if (srcRepeat &&
+	    if (fbCanGetSolid(pSrc))
-		pSrc->pDrawable->width == 1 &&
-		pSrc->pDrawable->height == 1)
 	    {
 		/* no mask and repeating source */
 		switch (pSrc->format) {

fb/fbpict.h

@@ -30,6 +30,13 @@
 
 #include "renderedge.h"
 
+
+#if defined(__GNUC__)
+#define INLINE __inline__
+#else
+#define INLINE
+#endif
+
 #define FbIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) )
 #define FbIntDiv(a,b)	 (((CARD16) (a) * 255) / (b))
 
@@ -67,6 +74,40 @@
 #define Green(x) (((x) >> 8) & 0xff)
 #define Blue(x) ((x) & 0xff)
 
+/**
+ * Returns TRUE if the fbComposeGetSolid can be used to get a single solid
+ * color representing every source sampling location of the picture.
+ */
+static INLINE Bool
+fbCanGetSolid(PicturePtr pict)
+{
+    if (pict->pDrawable == NULL ||
+	pict->pDrawable->width != 1 ||
+	pict->pDrawable->height != 1)
+    {
+	return FALSE;
+    }
+    if (pict->repeat != RepeatNormal)
+	return FALSE;
+
+    switch (pict->format) {
+    case PICT_a8r8g8b8:
+    case PICT_x8r8g8b8:
+    case PICT_a8b8g8r8:
+    case PICT_x8b8g8r8:
+    case PICT_r8g8b8:
+    case PICT_b8g8r8:
+    case PICT_r5g6b5:
+    case PICT_b5g6r5:
+	return TRUE;
+    default:
+	return FALSE;
+    }
+}
+
+#define fbCanGetSolid(pict) \
+(pict->pDrawable != NULL && pict->pDrawable->width == 1 && pict->pDrawable->height == 1)
+
 #define fbComposeGetSolid(pict, bits, fmt) { \
     FbBits	*__bits__; \
     FbStride	__stride__; \
@@ -322,12 +363,6 @@
 #define FASTCALL
 #endif
 
-#if defined(__GNUC__)
-#define INLINE __inline__
-#else
-#define INLINE
-#endif
-
 typedef struct _FbComposeData {
     CARD8	op;
     PicturePtr	src;

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/config/Makefile.am

@@ -27,7 +27,7 @@ endif
 
 AM_YFLAGS = -d
 AM_CFLAGS = \
-	 \
+	$(DIX_CFLAGS) \
 	-I$(top_srcdir)/hw/dmx \
 	$(GLX_INCS) \
 	-DHAVE_DMX_CONFIG_H \

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/dmx/glxProxy/Makefile.am

@@ -32,7 +32,7 @@ libglxproxy_a_SOURCES = compsize.c \
                         unpack.h
 
 AM_CFLAGS = \
- \
+            $(DIX_CFLAGS) \
             -I$(top_srcdir)/hw/dmx \
             -I$(top_srcdir)/include \
             -I$(top_srcdir)/GL/include \

hw/dmx/input/Makefile.am

@@ -60,7 +60,7 @@ GLX_DEFS = @GL_CFLAGS@
 GLX_INCS = -I@MESA_SOURCE@/include
 endif	    
 
-AM_CFLAGS = \
+AM_CFLAGS = $(DIX_CFLAGS) \
             -I$(top_srcdir)/hw/dmx \
             -I$(top_srcdir)/hw/xfree86/common \
             $(GLX_INCS) \

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
@@ -15,14 +19,18 @@ if XEPHYR
 XEPHYR_SUBDIRS = ephyr
 endif
 
+if KDRIVELINUX
+LINUX_SUBDIRS = linux
+endif
+
 SUBDIRS =			\
 	src			\
-	linux			\
+	$(LINUX_SUBDIRS)	\
 	$(XSDL_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

@@ -62,11 +62,3 @@ Xati_LDADD = \
 	$(ATI_LIBS)			\
 	@KDRIVE_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/chips/chipsstub.c

@@ -48,7 +48,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-    KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
+    KdOsAddInputDrivers ();
+    KdInitInput ();
 }
 
 void

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/ephyr/os.c

@@ -34,34 +34,8 @@ EphyrInit (void)
   return hostx_init();
 }
 
-static void
-EphyrEnable (void)
-{
-  EPHYR_DBG("mark");
-}
-
-static Bool
-EphyrSpecialKey (KeySym sym)
-{
-    return FALSE;
-}
-
-static void
-EphyrDisable (void)
-{
-}
-
-static void
-EphyrFini (void)
-{
-}
-
 KdOsFuncs   EphyrOsFuncs = {
-    EphyrInit,
+    .Init = EphyrInit,
-    EphyrEnable,
+    .pollEvents = ephyrPoll,
-    EphyrSpecialKey,
-    EphyrDisable,
-    EphyrFini,
-    ephyrPoll
 };
 

hw/kdrive/epson/Makefile.am

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

hw/kdrive/epson/epson13806stub.c

@@ -53,10 +53,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-    KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
+    KdOsAddInputDrivers ();
-#ifdef TOUCHSCREEN
+    KdInitInput ();
-    KdAddMouseDriver (&TsFuncs);
-#endif
 }
 
 int

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,12 +4,13 @@ INCLUDES = 					\
 
 noinst_LIBRARIES = libfbdev.a
 
-bin_PROGRAMS = Xfbdev
-
 libfbdev_a_SOURCES =	\
 	fbdev.c		\
 	fbdev.h
 
+if KDRIVEFBDEV
+bin_PROGRAMS = Xfbdev
+
 Xfbdev_SOURCES = \
 	fbinit.c
 
@@ -17,6 +18,4 @@ Xfbdev_LDADD = 						\
 	libfbdev.a					\
 	@KDRIVE_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/i810/i810stub.c

@@ -73,7 +73,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-    KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
+    KdOsAddInputDrivers ();
+    KdInitInput ();
 }
 
 void

hw/kdrive/igs/igsstub.c

@@ -56,7 +56,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
 void
 InitInput (int argc, char **argv)
 {
-    KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
+    KdOsAddInputDrivers ();
+    KdInitInput ();
 }
 
 void

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,6 +112,107 @@ static const KeySym linux_to_x[256] = {
 	XK_udiaeresis,	XK_yacute,	XK_thorn,	XK_ydiaeresis
 };
 
+#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,
@@ -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);
@@ -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;
@@ -427,61 +750,56 @@ LinuxKeyboardEnable (int fd, void *closure)
      */
     while ((n = read (fd, buf, sizeof (buf))) > 0)
 	;
-    return fd;
+    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)
+LinuxKeyboardLeds (KdKeyboardInfo *ki, int leds)
 {
-    LinuxKeyboardDisable (LinuxConsoleFd, 0);
+    if (!ki)
-    KdUnregisterFds (LinuxKbdType, FALSE);
+        return;
+
+    ioctl ((int)ki->driverPrivate, KDSETLED, leds & 7);
 }
 
-static void
+KdKeyboardDriver LinuxKeyboardDriver = {
-LinuxKeyboardLeds (int leds)
+    "keyboard",
-{
+    .Init = LinuxKeyboardInit,
-    ioctl (LinuxConsoleFd, KDSETLED, leds & 7);
+    .Enable = LinuxKeyboardEnable,
-}
+    .Leds = LinuxKeyboardLeds,
-
+    .Disable = LinuxKeyboardDisable,
-static void
-LinuxKeyboardBell (int volume, int pitch, int duration)
-{
-    if (volume && pitch)
-    {
-	ioctl(LinuxConsoleFd, KDMKTONE,
-	      ((1193190 / pitch) & 0xffff) |
-	      (((unsigned long)duration *
-		volume / 50) << 16));
-
-    }
-}
-
-KdKeyboardFuncs	LinuxKeyboardFuncs = {
-    LinuxKeyboardLoad,
-    LinuxKeyboardInit,
-    LinuxKeyboardLeds,
-    LinuxKeyboardBell,
-    LinuxKeyboardFini,
-    3,
 };

hw/kdrive/linux/linux.c

@@ -373,26 +373,6 @@ LinuxEnable (void)
     enabled = TRUE;
 }
 
-static Bool
-LinuxSpecialKey (KeySym sym)
-{
-    struct vt_stat  vts;
-    int		    con;
-    
-    if (XK_F1 <= sym && sym <= XK_F12)
-    {
-	con = sym - XK_F1 + 1;
-	memset (&vts, '\0', sizeof (vts));	/* valgrind */
-	ioctl (LinuxConsoleFd, VT_GETSTATE, &vts);
-	if (con != vts.v_active && (vts.v_state & (1 << con)))
-	{
-	    ioctl (LinuxConsoleFd, VT_ACTIVATE, con);
-	    return TRUE;
-	}
-    }
-    return FALSE;
-}
-
 static void
 LinuxDisable (void)
 {
@@ -456,6 +436,7 @@ LinuxFini (void)
 	}
     }
     close(LinuxConsoleFd);                /* make the vt-manager happy */
+    LinuxConsoleFd = -1;
     fd = open ("/dev/tty0", O_RDWR|O_NDELAY, 0);
     if (fd >= 0)
     {
@@ -468,13 +449,32 @@ LinuxFini (void)
     return;
 }
 
+void
+KdOsAddInputDrivers ()
+{
+    KdAddPointerDriver(&LinuxMouseDriver);
+    KdAddPointerDriver(&MsMouseDriver);
+    KdAddPointerDriver(&Ps2MouseDriver);
+#ifdef TSLIB
+    KdAddPointerDriver(&TsDriver);
+#endif
+    KdAddKeyboardDriver(&LinuxKeyboardDriver);
+}
+
+static void
+LinuxBell(int volume, int pitch, int duration)
+{
+    if (volume && pitch)
+        ioctl(LinuxConsoleFd, KDMKTONE, ((1193190 / pitch) & 0xffff) |
+              (((unsigned long)duration * volume / 50) << 16));
+}
+
 KdOsFuncs   LinuxFuncs = {
-    LinuxInit,
+    .Init = LinuxInit,
-    LinuxEnable,
+    .Enable = LinuxEnable,
-    LinuxSpecialKey,
+    .Disable = LinuxDisable,
-    LinuxDisable,
+    .Fini = LinuxFini,
-    LinuxFini,
+    .Bell = LinuxBell,
-    0
 };
 
 void

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)
+        return;
     
-    KdUnregisterFds (MouseInputType, TRUE);
+    km = pi->driverPrivate;
-    for (mi = kdMouseInfo; mi; mi = mi->next)
+    KdUnregisterFd (pi, km->iob.fd, TRUE);
-    {
-	if (mi->inputType == MouseInputType)
-	{
-	    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,150 @@
 #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 ");
+    while (ts_read(private->tsDev, &event, 1) == 1) {
-  for (i = j; i < NUM_TS_NAMES; i++)    
+        if (event.pressure) {
-    ErrorF ("%s ", TsNames[i]);
+            flags = KD_BUTTON_1;
-  ErrorF (".\n");
-  if (!TsNames[0]) 
-    ErrorF ("Try setting TSLIB_TSDEVICE to valid /dev entry?\n");
 
-  if (fd > 0) 
+            /* 
-    close(fd);
+             * Here we test for the touch screen driver actually being on the
+             * touch screen, if it is we send absolute coordinates. If not,
+             * then we send delta's so that we can track the entire vga screen.
+             */
+            if (KdCurScreen == private->phys_screen) {
+                x = event.x;
+                y = event.y;
+            } else {
+                flags |= KD_MOUSE_DELTA;
+                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;
+        }
 
-  return FALSE;
+        KdEnqueuePointerEvent (pi, flags, x, y, event.pressure);
-}
-
-static void
-TslibFini (void)
-{
-    KdMouseInfo	*mi;
-
-    KdUnregisterFds (TsInputType, TRUE);
-    for (mi = kdMouseInfo; mi; mi = mi->next)
-    {
-	if (mi->inputType == TsInputType)
-	{
-	    if(mi->driver) 
-	      {
-		ts_close(tsDev);
-		tsDev = NULL;
-	      }
-	    mi->driver    = 0;
-
-	    /* If below is set to 0, then MouseInit() will trash it,
-	     * setting to 'mouse type' ( via server reset). Therefore 
-             * Leave it alone and work around in TslibInit()  ( see
-             * req_type ).
-	    */
-	    /* mi->inputType = 0; */
-	}
     }
 }
 
-KdMouseFuncs TsFuncs = {
+static Status
+TslibEnable (KdPointerInfo *pi)
+{
+    struct TslibPrivate *private = pi->driverPrivate;
+
+    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;
+    }
+
+    KdRegisterFd(private->fd, TsRead, pi);
+  
+    return Success;
+}
+
+
+static void
+TslibDisable (KdPointerInfo *pi)
+{
+    struct TslibPrivate *private = pi->driverPrivate;
+
+    if (private->fd)
+        KdUnregisterFd(pi, private->fd, TRUE);
+
+    if (private->tsDev)
+        ts_close(private->tsDev);
+
+    private->fd = 0;
+    private->tsDev = NULL;
+}
+
+
+static Status
+TslibInit (KdPointerInfo *pi)
+{
+    int		        fd = 0, i = 0;
+    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;
+
+    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,
 };