Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>

51 files changed, 11012 insertions, 11663 deletions

diff --git a/hw/kdrive/ephyr/XF86dri.c b/hw/kdrive/ephyr/XF86dri.c
index e7c88b335..74bf67678 100644
--- a/hw/kdrive/ephyr/XF86dri.c
+++ b/hw/kdrive/ephyr/XF86dri.c
@@ -78,80 +78,84 @@ static char xf86dri_extension_name[] = XF86DRINAME;
  *                                                                           *
  *****************************************************************************/
 
-static int close_display(Display *dpy, XExtCodes *extCodes);
+static int close_display(Display * dpy, XExtCodes * extCodes);
+
 static /* const */ XExtensionHooks xf86dri_extension_hooks = {
-    NULL,				/* create_gc */
-    NULL,				/* copy_gc */
-    NULL,				/* flush_gc */
-    NULL,				/* free_gc */
-    NULL,				/* create_font */
-    NULL,				/* free_font */
-    close_display,			/* close_display */
-    NULL,				/* wire_to_event */
-    NULL,				/* event_to_wire */
-    NULL,				/* error */
-    NULL,				/* error_string */
+    NULL,                       /* create_gc */
+    NULL,                       /* copy_gc */
+    NULL,                       /* flush_gc */
+    NULL,                       /* free_gc */
+    NULL,                       /* create_font */
+    NULL,                       /* free_font */
+    close_display,              /* close_display */
+    NULL,                       /* wire_to_event */
+    NULL,                       /* event_to_wire */
+    NULL,                       /* error */
+    NULL,                       /* error_string */
 };
 
-static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info, 
-				   xf86dri_extension_name, 
-				   &xf86dri_extension_hooks, 
-				   0, NULL)
-
-static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
+static
+XEXT_GENERATE_FIND_DISPLAY(find_display, xf86dri_info,
+                           xf86dri_extension_name,
+                           &xf86dri_extension_hooks, 0, NULL)
 
+static
+XEXT_GENERATE_CLOSE_DISPLAY(close_display, xf86dri_info)
 
 /*****************************************************************************
  *                                                                           *
  *		    public XFree86-DRI Extension routines                    *
  *                                                                           *
  *****************************************************************************/
-
 #if 0
 #include <stdio.h>
 #define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);
 #else
 #define TRACE(msg)
 #endif
+Bool
+XF86DRIOpenFullScreen(Display * dpy, int screen, Drawable drawable);
+Bool
+XF86DRICloseFullScreen(Display * dpy, int screen, Drawable drawable);
 
-Bool XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable);
-Bool XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable);
-
-Bool XF86DRIQueryExtension (Display *dpy, int *event_basep, int *error_basep)
+Bool
+XF86DRIQueryExtension(Display * dpy, int *event_basep, int *error_basep)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
 
     TRACE("QueryExtension...");
     if (XextHasExtension(info)) {
-	*event_basep = info->codes->first_event;
-	*error_basep = info->codes->first_error;
+        *event_basep = info->codes->first_event;
+        *error_basep = info->codes->first_error;
         TRACE("QueryExtension... return True");
-	return True;
-    } else {
+        return True;
+    }
+    else {
         TRACE("QueryExtension... return False");
-	return False;
+        return False;
     }
 }
 
-Bool XF86DRIQueryVersion(Display *dpy, int *majorVersion, int *minorVersion,
-                         int *patchVersion)
+Bool
+XF86DRIQueryVersion(Display * dpy, int *majorVersion, int *minorVersion,
+                    int *patchVersion)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIQueryVersionReply rep;
     xXF86DRIQueryVersionReq *req;
 
     TRACE("QueryVersion...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIQueryVersion, req);
     req->reqType = info->codes->major_opcode;
     req->driReqType = X_XF86DRIQueryVersion;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("QueryVersion... return False");
-	return False;
+        return False;
     }
     *majorVersion = rep.majorVersion;
     *minorVersion = rep.minorVersion;
@@ -163,21 +167,21 @@ Bool XF86DRIQueryVersion(Display *dpy, int *majorVersion, int *minorVersion,
 }
 
 Bool
-XF86DRIQueryDirectRenderingCapable (Display *dpy, int screen, Bool *isCapable)
+XF86DRIQueryDirectRenderingCapable(Display * dpy, int screen, Bool *isCapable)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIQueryDirectRenderingCapableReply rep;
     xXF86DRIQueryDirectRenderingCapableReq *req;
 
     TRACE("QueryDirectRenderingCapable...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIQueryDirectRenderingCapable, req);
     req->reqType = info->codes->major_opcode;
     req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
     req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
         UnlockDisplay(dpy);
         SyncHandle();
         TRACE("QueryDirectRenderingCapable... return False");
@@ -191,23 +195,22 @@ XF86DRIQueryDirectRenderingCapable (Display *dpy, int screen, Bool *isCapable)
 }
 
 Bool
-XF86DRIOpenConnection (Display *dpy, int screen,
-                       drm_handle_t *hSAREA,
-                       char **busIdString)
+XF86DRIOpenConnection(Display * dpy, int screen,
+                      drm_handle_t * hSAREA, char **busIdString)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIOpenConnectionReply rep;
     xXF86DRIOpenConnectionReq *req;
 
     TRACE("OpenConnection...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIOpenConnection, req);
     req->reqType = info->codes->major_opcode;
     req->driReqType = X_XF86DRIOpenConnection;
     req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
         UnlockDisplay(dpy);
         SyncHandle();
         TRACE("OpenConnection... return False");
@@ -216,20 +219,22 @@ XF86DRIOpenConnection (Display *dpy, int screen,
 
     *hSAREA = rep.hSAREALow;
     if (sizeof(drm_handle_t) == 8) {
-        int shift = 32; /* var to prevent warning on next line */
+        int shift = 32;         /* var to prevent warning on next line */
+
         *hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;
     }
 
     if (rep.length) {
-        if (!(*busIdString = (char *)calloc(rep.busIdStringLength + 1, 1))) {
-            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
+        if (!(*busIdString = (char *) calloc(rep.busIdStringLength + 1, 1))) {
+            _XEatData(dpy, ((rep.busIdStringLength + 3) & ~3));
             UnlockDisplay(dpy);
             SyncHandle();
             TRACE("OpenConnection... return False");
             return False;
         }
         _XReadPad(dpy, *busIdString, rep.busIdStringLength);
-    } else {
+    }
+    else {
         *busIdString = NULL;
     }
     UnlockDisplay(dpy);
@@ -238,14 +243,15 @@ XF86DRIOpenConnection (Display *dpy, int screen,
     return True;
 }
 
-Bool XF86DRIAuthConnection(Display *dpy, int screen, drm_magic_t magic)
+Bool
+XF86DRIAuthConnection(Display * dpy, int screen, drm_magic_t magic)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIAuthConnectionReq *req;
     xXF86DRIAuthConnectionReply rep;
 
     TRACE("AuthConnection...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIAuthConnection, req);
@@ -254,11 +260,11 @@ Bool XF86DRIAuthConnection(Display *dpy, int screen, drm_magic_t magic)
     req->screen = screen;
     req->magic = magic;
     rep.authenticated = 0;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
-	UnlockDisplay(dpy);
-	SyncHandle();
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse) || !rep.authenticated) {
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("AuthConnection... return False");
-	return False;
+        return False;
     }
     UnlockDisplay(dpy);
     SyncHandle();
@@ -266,14 +272,15 @@ Bool XF86DRIAuthConnection(Display *dpy, int screen, drm_magic_t magic)
     return True;
 }
 
-Bool XF86DRICloseConnection(Display *dpy, int screen)
+Bool
+XF86DRICloseConnection(Display * dpy, int screen)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRICloseConnectionReq *req;
 
     TRACE("CloseConnection...");
 
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRICloseConnection, req);
@@ -286,29 +293,29 @@ Bool XF86DRICloseConnection(Display *dpy, int screen)
     return True;
 }
 
-Bool XF86DRIGetClientDriverName(Display *dpy, int screen,
-                                int *ddxDriverMajorVersion,
-	                        int *ddxDriverMinorVersion,
-                                int *ddxDriverPatchVersion,
-                                char **clientDriverName)
+Bool
+XF86DRIGetClientDriverName(Display * dpy, int screen,
+                           int *ddxDriverMajorVersion,
+                           int *ddxDriverMinorVersion,
+                           int *ddxDriverPatchVersion, char **clientDriverName)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIGetClientDriverNameReply rep;
     xXF86DRIGetClientDriverNameReq *req;
 
     TRACE("GetClientDriverName...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIGetClientDriverName, req);
     req->reqType = info->codes->major_opcode;
     req->driReqType = X_XF86DRIGetClientDriverName;
     req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("GetClientDriverName... return False");
-	return False;
+        return False;
     }
 
     *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
@@ -316,15 +323,18 @@ Bool XF86DRIGetClientDriverName(Display *dpy, int screen,
     *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
 
     if (rep.length) {
-        if (!(*clientDriverName = (char *)calloc(rep.clientDriverNameLength + 1, 1))) {
-            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
+        if (!
+            (*clientDriverName =
+             (char *) calloc(rep.clientDriverNameLength + 1, 1))) {
+            _XEatData(dpy, ((rep.clientDriverNameLength + 3) & ~3));
             UnlockDisplay(dpy);
             SyncHandle();
             TRACE("GetClientDriverName... return False");
             return False;
         }
-	_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
-    } else {
+        _XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
+    }
+    else {
         *clientDriverName = NULL;
     }
     UnlockDisplay(dpy);
@@ -333,15 +343,16 @@ Bool XF86DRIGetClientDriverName(Display *dpy, int screen,
     return True;
 }
 
-Bool XF86DRICreateContextWithConfig(Display *dpy, int screen, int configID,
-                                    XID *context, drm_context_t *hHWContext)
+Bool
+XF86DRICreateContextWithConfig(Display * dpy, int screen, int configID,
+                               XID *context, drm_context_t * hHWContext)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRICreateContextReply rep;
     xXF86DRICreateContextReq *req;
 
     TRACE("CreateContext...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRICreateContext, req);
@@ -351,11 +362,11 @@ Bool XF86DRICreateContextWithConfig(Display *dpy, int screen, int configID,
     req->screen = screen;
     *context = XAllocID(dpy);
     req->context = *context;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("CreateContext... return False");
-	return False;
+        return False;
     }
     *hHWContext = rep.hHWContext;
     UnlockDisplay(dpy);
@@ -364,20 +375,22 @@ Bool XF86DRICreateContextWithConfig(Display *dpy, int screen, int configID,
     return True;
 }
 
-Bool XF86DRICreateContext(Display *dpy, int screen, Visual *visual,
-                          XID *context, drm_context_t *hHWContext)
+Bool
+XF86DRICreateContext(Display * dpy, int screen, Visual * visual,
+                     XID *context, drm_context_t * hHWContext)
 {
-    return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
-					   context, hHWContext );
+    return XF86DRICreateContextWithConfig(dpy, screen, visual->visualid,
+                                          context, hHWContext);
 }
 
-GLboolean XF86DRIDestroyContext( Display *dpy, int screen, XID context)
+GLboolean
+XF86DRIDestroyContext(Display * dpy, int screen, XID context)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIDestroyContextReq *req;
 
     TRACE("DestroyContext...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIDestroyContext, req);
@@ -392,15 +405,15 @@ GLboolean XF86DRIDestroyContext( Display *dpy, int screen, XID context)
 }
 
 GLboolean
-XF86DRICreateDrawable (Display *dpy, int screen,
-                       XID drawable, drm_drawable_t * hHWDrawable)
+XF86DRICreateDrawable(Display * dpy, int screen,
+                      XID drawable, drm_drawable_t * hHWDrawable)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRICreateDrawableReply rep;
     xXF86DRICreateDrawableReq *req;
 
     TRACE("CreateDrawable...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRICreateDrawable, req);
@@ -408,11 +421,11 @@ XF86DRICreateDrawable (Display *dpy, int screen,
     req->driReqType = X_XF86DRICreateDrawable;
     req->screen = screen;
     req->drawable = drawable;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("CreateDrawable... return False");
-	return False;
+        return False;
     }
     *hHWDrawable = rep.hHWDrawable;
     UnlockDisplay(dpy);
@@ -421,20 +434,21 @@ XF86DRICreateDrawable (Display *dpy, int screen,
     return True;
 }
 
-static int noopErrorHandler(Display *dpy, XErrorEvent *xerr)
+static int
+noopErrorHandler(Display * dpy, XErrorEvent * xerr)
 {
     return 0;
 }
 
-GLboolean XF86DRIDestroyDrawable( Display *dpy, int screen,
-    XID drawable )
+GLboolean
+XF86DRIDestroyDrawable(Display * dpy, int screen, XID drawable)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIDestroyDrawableReq *req;
-    int (*oldXErrorHandler)(Display *, XErrorEvent *);
+    int (*oldXErrorHandler) (Display *, XErrorEvent *);
 
     TRACE("DestroyDrawable...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     /* This is called from the DRI driver, which used call it like this
      *
@@ -466,20 +480,21 @@ GLboolean XF86DRIDestroyDrawable( Display *dpy, int screen,
     return True;
 }
 
-Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
-    unsigned int* index, unsigned int* stamp,
-    int* X, int* Y, int* W, int* H,
-    int* numClipRects, drm_clip_rect_t ** pClipRects,
-    int* backX, int* backY,
-    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
+Bool
+XF86DRIGetDrawableInfo(Display * dpy, int screen, Drawable drawable,
+                       unsigned int *index, unsigned int *stamp,
+                       int *X, int *Y, int *W, int *H,
+                       int *numClipRects, drm_clip_rect_t ** pClipRects,
+                       int *backX, int *backY,
+                       int *numBackClipRects, drm_clip_rect_t ** pBackClipRects)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIGetDrawableInfoReply rep;
-    xXF86DRIGetDrawableInfoReq *req=NULL;
+    xXF86DRIGetDrawableInfoReq *req = NULL;
     int total_rects;
 
     TRACE("GetDrawableInfo...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIGetDrawableInfo, req);
@@ -488,19 +503,18 @@ Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
     req->screen = screen;
     req->drawable = drawable;
 
-    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 
-    {
-	UnlockDisplay(dpy);
-	SyncHandle();
+    if (!_XReply(dpy, (xReply *) & rep, 1, xFalse)) {
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("GetDrawableInfo... return False");
-	return False;
+        return False;
     }
     *index = rep.drawableTableIndex;
     *stamp = rep.drawableTableStamp;
-    *X = (int)rep.drawableX;
-    *Y = (int)rep.drawableY;
-    *W = (int)rep.drawableWidth;
-    *H = (int)rep.drawableHeight;
+    *X = (int) rep.drawableX;
+    *Y = (int) rep.drawableY;
+    *W = (int) rep.drawableWidth;
+    *H = (int) rep.drawableHeight;
     *numClipRects = rep.numClipRects;
     total_rects = *numClipRects;
 
@@ -514,34 +528,37 @@ Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
      * backwards compatibility (Because of the >> 2 shift) but the fix
      * enables multi-threaded apps to work.
      */
-    if (rep.length !=  ((((SIZEOF(xXF86DRIGetDrawableInfoReply) - 
-		       SIZEOF(xGenericReply) + 
-		       total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
+    if (rep.length != ((((SIZEOF(xXF86DRIGetDrawableInfoReply) -
+                          SIZEOF(xGenericReply) +
+                          total_rects * sizeof(drm_clip_rect_t)) +
+                         3) & ~3) >> 2)) {
         _XEatData(dpy, rep.length);
-	UnlockDisplay(dpy);
-	SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("GetDrawableInfo... return False");
         return False;
     }
 #endif
 
     if (*numClipRects) {
-       int len = sizeof(drm_clip_rect_t) * (*numClipRects);
+        int len = sizeof(drm_clip_rect_t) * (*numClipRects);
 
-       *pClipRects = (drm_clip_rect_t *)calloc(len, 1);
-       if (*pClipRects)
-	  _XRead(dpy, (char*)*pClipRects, len);
-    } else {
+        *pClipRects = (drm_clip_rect_t *) calloc(len, 1);
+        if (*pClipRects)
+            _XRead(dpy, (char *) *pClipRects, len);
+    }
+    else {
         *pClipRects = NULL;
     }
 
     if (*numBackClipRects) {
-       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
+        int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
 
-       *pBackClipRects = (drm_clip_rect_t *)calloc(len, 1);
-       if (*pBackClipRects) 
-	  _XRead(dpy, (char*)*pBackClipRects, len);
-    } else {
+        *pBackClipRects = (drm_clip_rect_t *) calloc(len, 1);
+        if (*pBackClipRects)
+            _XRead(dpy, (char *) *pBackClipRects, len);
+    }
+    else {
         *pBackClipRects = NULL;
     }
 
@@ -552,33 +569,34 @@ Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
 }
 
 Bool
-XF86DRIGetDeviceInfo (Display *dpy, int screen, drm_handle_t *hFrameBuffer,
-                      int *fbOrigin, int *fbSize, int *fbStride,
-                      int *devPrivateSize, void **pDevPrivate)
+XF86DRIGetDeviceInfo(Display * dpy, int screen, drm_handle_t * hFrameBuffer,
+                     int *fbOrigin, int *fbSize, int *fbStride,
+                     int *devPrivateSize, void **pDevPrivate)
 {
-    XExtDisplayInfo *info = find_display (dpy);
+    XExtDisplayInfo *info = find_display(dpy);
     xXF86DRIGetDeviceInfoReply rep;
     xXF86DRIGetDeviceInfoReq *req;
 
     TRACE("GetDeviceInfo...");
-    XF86DRICheckExtension (dpy, info, False);
+    XF86DRICheckExtension(dpy, info, False);
 
     LockDisplay(dpy);
     GetReq(XF86DRIGetDeviceInfo, req);
     req->reqType = info->codes->major_opcode;
     req->driReqType = X_XF86DRIGetDeviceInfo;
     req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
+        UnlockDisplay(dpy);
+        SyncHandle();
         TRACE("GetDeviceInfo... return False");
-	return False;
+        return False;
     }
 
     *hFrameBuffer = rep.hFrameBufferLow;
     if (sizeof(drm_handle_t) == 8) {
-       int shift = 32; /* var to prevent warning on next line */
-       *hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
+        int shift = 32;         /* var to prevent warning on next line */
+
+        *hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
     }
 
     *fbOrigin = rep.framebufferOrigin;
@@ -587,15 +605,16 @@ XF86DRIGetDeviceInfo (Display *dpy, int screen, drm_handle_t *hFrameBuffer,
     *devPrivateSize = rep.devPrivateSize;
 
     if (rep.length) {
-        if (!(*pDevPrivate = (void *)calloc(rep.devPrivateSize, 1))) {
-            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
+        if (!(*pDevPrivate = (void *) calloc(rep.devPrivateSize, 1))) {
+            _XEatData(dpy, ((rep.devPrivateSize + 3) & ~3));
             UnlockDisplay(dpy);
             SyncHandle();
             TRACE("GetDeviceInfo... return False");
             return False;
         }
-	_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
-    } else {
+        _XRead(dpy, (char *) *pDevPrivate, rep.devPrivateSize);
+    }
+    else {
         *pDevPrivate = NULL;
     }
 
@@ -606,7 +625,7 @@ XF86DRIGetDeviceInfo (Display *dpy, int screen, drm_handle_t *hFrameBuffer,
 }
 
 Bool
-XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable)
+XF86DRIOpenFullScreen(Display * dpy, int screen, Drawable drawable)
 {
     /* This function and the underlying X protocol are deprecated.
      */
@@ -617,7 +636,7 @@ XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable)
 }
 
 Bool
-XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable)
+XF86DRICloseFullScreen(Display * dpy, int screen, Drawable drawable)
 {
     /* This function and the underlying X protocol are deprecated.
      */
diff --git a/hw/kdrive/ephyr/ephyr.c b/hw/kdrive/ephyr/ephyr.c
index 7ebf1c253..8eda539aa 100644
--- a/hw/kdrive/ephyr/ephyr.c
+++ b/hw/kdrive/ephyr/ephyr.c
@@ -36,11 +36,12 @@
 #include "ephyrdri.h"
 #include "ephyrdriext.h"
 #include "ephyrglxext.h"
-#endif /* XF86DRI */
+#endif                          /* XF86DRI */
 
 #include "xkbsrv.h"
 
 extern int KdTsPhyScreen;
+
 #ifdef GLXEXT
 extern Bool noGlxVisualInit;
 #endif
@@ -48,179 +49,162 @@ extern Bool noGlxVisualInit;
 KdKeyboardInfo *ephyrKbd;
 KdPointerInfo *ephyrMouse;
 EphyrKeySyms ephyrKeySyms;
-Bool ephyrNoDRI=FALSE ;
-Bool ephyrNoXV=FALSE ;
+Bool ephyrNoDRI = FALSE;
+Bool ephyrNoXV = FALSE;
 
 static int mouseState = 0;
 static Rotation ephyrRandr = RR_Rotate_0;
 
 typedef struct _EphyrInputPrivate {
-    Bool    enabled;
+    Bool enabled;
 } EphyrKbdPrivate, EphyrPointerPrivate;
 
-Bool   EphyrWantGrayScale = 0;
-
+Bool EphyrWantGrayScale = 0;
 
 Bool
-ephyrInitialize (KdCardInfo *card, EphyrPriv *priv)
+ephyrInitialize(KdCardInfo * card, EphyrPriv * priv)
 {
-  OsSignal(SIGUSR1, hostx_handle_signal);
-  
-  priv->base = 0;
-  priv->bytes_per_line = 0;
-  return TRUE;
+    OsSignal(SIGUSR1, hostx_handle_signal);
+
+    priv->base = 0;
+    priv->bytes_per_line = 0;
+    return TRUE;
 }
 
 Bool
-ephyrCardInit (KdCardInfo *card)
+ephyrCardInit(KdCardInfo * card)
 {
-  EphyrPriv	*priv;
-  
-  priv = (EphyrPriv *) malloc(sizeof (EphyrPriv));
-  if (!priv)
-    return FALSE;
-  
-  if (!ephyrInitialize (card, priv))
-    {
-      free(priv);
-      return FALSE;
+    EphyrPriv *priv;
+
+    priv = (EphyrPriv *) malloc(sizeof(EphyrPriv));
+    if (!priv)
+        return FALSE;
+
+    if (!ephyrInitialize(card, priv)) {
+        free(priv);
+        return FALSE;
     }
-  card->driver = priv;
-  
-  return TRUE;
+    card->driver = priv;
+
+    return TRUE;
 }
 
 Bool
-ephyrScreenInitialize (KdScreenInfo *screen, EphyrScrPriv *scrpriv)
+ephyrScreenInitialize(KdScreenInfo * screen, EphyrScrPriv * scrpriv)
 {
-  int width = 640, height = 480; 
-  CARD32 redMask, greenMask, blueMask;
-  
-  if (hostx_want_screen_size(screen, &width, &height)
-      || !screen->width || !screen->height)
-    {
-      screen->width = width;
-      screen->height = height;
+    int width = 640, height = 480;
+    CARD32 redMask, greenMask, blueMask;
+
+    if (hostx_want_screen_size(screen, &width, &height)
+        || !screen->width || !screen->height) {
+        screen->width = width;
+        screen->height = height;
     }
 
-  if (EphyrWantGrayScale)
-    screen->fb.depth = 8;
-
-  if (screen->fb.depth && screen->fb.depth != hostx_get_depth())
-    {
-      if (screen->fb.depth < hostx_get_depth()
-	  && (screen->fb.depth == 24 || screen->fb.depth == 16
-	      || screen->fb.depth == 8))
-	{
-	  hostx_set_server_depth(screen, screen->fb.depth);
-	}
-      else
-	ErrorF("\nXephyr: requested screen depth not supported, setting to match hosts.\n");
+    if (EphyrWantGrayScale)
+        screen->fb.depth = 8;
+
+    if (screen->fb.depth && screen->fb.depth != hostx_get_depth()) {
+        if (screen->fb.depth < hostx_get_depth()
+            && (screen->fb.depth == 24 || screen->fb.depth == 16
+                || screen->fb.depth == 8)) {
+            hostx_set_server_depth(screen, screen->fb.depth);
+        }
+        else
+            ErrorF
+                ("\nXephyr: requested screen depth not supported, setting to match hosts.\n");
     }
-  
-  screen->fb.depth = hostx_get_server_depth(screen);
-  screen->rate = 72;
-  
-  if (screen->fb.depth <= 8)
-    {
-      if (EphyrWantGrayScale)
-	screen->fb.visuals = ((1 << StaticGray) | (1 << GrayScale));
-      else
-	screen->fb.visuals = ((1 << StaticGray) |
-			      (1 << GrayScale) |
-			      (1 << StaticColor) |
-			      (1 << PseudoColor) |
-			      (1 << TrueColor) |
-			      (1 << DirectColor));
-      
-      screen->fb.redMask   = 0x00;
-      screen->fb.greenMask = 0x00;
-      screen->fb.blueMask  = 0x00;
-      screen->fb.depth        = 8;
-      screen->fb.bitsPerPixel = 8;
+
+    screen->fb.depth = hostx_get_server_depth(screen);
+    screen->rate = 72;
+
+    if (screen->fb.depth <= 8) {
+        if (EphyrWantGrayScale)
+            screen->fb.visuals = ((1 << StaticGray) | (1 << GrayScale));
+        else
+            screen->fb.visuals = ((1 << StaticGray) |
+                                  (1 << GrayScale) |
+                                  (1 << StaticColor) |
+                                  (1 << PseudoColor) |
+                                  (1 << TrueColor) | (1 << DirectColor));
+
+        screen->fb.redMask = 0x00;
+        screen->fb.greenMask = 0x00;
+        screen->fb.blueMask = 0x00;
+        screen->fb.depth = 8;
+        screen->fb.bitsPerPixel = 8;
     }
-  else 
-    {
-      screen->fb.visuals = (1 << TrueColor);
-      
-      if (screen->fb.depth <= 15)
-	{
-	  screen->fb.depth = 15;
-	  screen->fb.bitsPerPixel = 16;
-	}
-      else if (screen->fb.depth <= 16)
-	{
-	  screen->fb.depth = 16;
-	  screen->fb.bitsPerPixel = 16;
-	}
-      else if (screen->fb.depth <= 24)
-	{
-	  screen->fb.depth = 24;
-	  screen->fb.bitsPerPixel = 32;
-	}
-      else if (screen->fb.depth <= 30)
-	{
-	  screen->fb.depth = 30;
-	  screen->fb.bitsPerPixel = 32;
-	}
-      else
-	{
-	  ErrorF("\nXephyr: Unsupported screen depth %d\n",
-	         screen->fb.depth);
-	  return FALSE;
-	}
-
-      hostx_get_visual_masks (screen, &redMask, &greenMask, &blueMask);
-
-      screen->fb.redMask = (Pixel) redMask;
-      screen->fb.greenMask = (Pixel) greenMask;
-      screen->fb.blueMask = (Pixel) blueMask;
+    else {
+        screen->fb.visuals = (1 << TrueColor);
+
+        if (screen->fb.depth <= 15) {
+            screen->fb.depth = 15;
+            screen->fb.bitsPerPixel = 16;
+        }
+        else if (screen->fb.depth <= 16) {
+            screen->fb.depth = 16;
+            screen->fb.bitsPerPixel = 16;
+        }
+        else if (screen->fb.depth <= 24) {
+            screen->fb.depth = 24;
+            screen->fb.bitsPerPixel = 32;
+        }
+        else if (screen->fb.depth <= 30) {
+            screen->fb.depth = 30;
+            screen->fb.bitsPerPixel = 32;
+        }
+        else {
+            ErrorF("\nXephyr: Unsupported screen depth %d\n", screen->fb.depth);
+            return FALSE;
+        }
+
+        hostx_get_visual_masks(screen, &redMask, &greenMask, &blueMask);
+
+        screen->fb.redMask = (Pixel) redMask;
+        screen->fb.greenMask = (Pixel) greenMask;
+        screen->fb.blueMask = (Pixel) blueMask;
 
     }
-  
-  scrpriv->randr = screen->randr;
 
-  return ephyrMapFramebuffer (screen);
+    scrpriv->randr = screen->randr;
+
+    return ephyrMapFramebuffer(screen);
 }
 
 Bool
-ephyrScreenInit (KdScreenInfo *screen)
+ephyrScreenInit(KdScreenInfo * screen)
 {
-  EphyrScrPriv *scrpriv;
-  
-  scrpriv = calloc(1, sizeof (EphyrScrPriv));
+    EphyrScrPriv *scrpriv;
 
-  if (!scrpriv)
-    return FALSE;
+    scrpriv = calloc(1, sizeof(EphyrScrPriv));
+
+    if (!scrpriv)
+        return FALSE;
 
-  screen->driver = scrpriv;
+    screen->driver = scrpriv;
 
-  if (!ephyrScreenInitialize (screen, scrpriv))
-    {
-      screen->driver = 0;
-      free(scrpriv);
-      return FALSE;
+    if (!ephyrScreenInitialize(screen, scrpriv)) {
+        screen->driver = 0;
+        free(scrpriv);
+        return FALSE;
     }
 
-  return TRUE;
+    return TRUE;
 }
-    
-void*
-ephyrWindowLinear (ScreenPtr	pScreen,
-		   CARD32	row,
-		   CARD32	offset,
-		   int		mode,
-		   CARD32	*size,
-		   void		*closure)
+
+void *
+ephyrWindowLinear(ScreenPtr pScreen,
+                  CARD32 row,
+                  CARD32 offset, int mode, CARD32 *size, void *closure)
 {
-  KdScreenPriv(pScreen);
-  EphyrPriv	    *priv = pScreenPriv->card->driver;
-  
-  if (!pScreenPriv->enabled)
-    return 0;
-
-  *size = priv->bytes_per_line;
-  return priv->base + row * priv->bytes_per_line + offset;
+    KdScreenPriv(pScreen);
+    EphyrPriv *priv = pScreenPriv->card->driver;
+
+    if (!pScreenPriv->enabled)
+        return 0;
+
+    *size = priv->bytes_per_line;
+    return priv->base + row * priv->bytes_per_line + offset;
 }
 
 /**
@@ -228,529 +212,509 @@ ephyrWindowLinear (ScreenPtr	pScreen,
  * buffer so that fakexa has space to put offscreen pixmaps.
  */
 int
-ephyrBufferHeight(KdScreenInfo *screen)
+ephyrBufferHeight(KdScreenInfo * screen)
 {
     int buffer_height;
+
     if (ephyrFuncs.initAccel == NULL)
-	buffer_height = screen->height;
+        buffer_height = screen->height;
     else
-	buffer_height = 3 * screen->height;
+        buffer_height = 3 * screen->height;
     return buffer_height;
 }
 
-
 Bool
-ephyrMapFramebuffer (KdScreenInfo *screen)
+ephyrMapFramebuffer(KdScreenInfo * screen)
 {
-  EphyrScrPriv  *scrpriv = screen->driver;
-  EphyrPriv	  *priv    = screen->card->driver;
-  KdPointerMatrix m;
-  int buffer_height;
-  
-  EPHYR_LOG("screen->width: %d, screen->height: %d index=%d",
-	     screen->width, screen->height, screen->mynum);
-  
-  /*
-   * Use the rotation last applied to ourselves (in the Xephyr case the fb
-   * coordinate system moves independently of the pointer coordiante system).
-   */
-  KdComputePointerMatrix (&m, ephyrRandr, screen->width, screen->height);
-  KdSetPointerMatrix (&m);
-  
-  priv->bytes_per_line = ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
-
-  buffer_height = ephyrBufferHeight(screen);
-
-  priv->base = hostx_screen_init (screen, screen->width, screen->height, buffer_height);
-
-  if ((scrpriv->randr & RR_Rotate_0) && !(scrpriv->randr & RR_Reflect_All))
-    {
-      scrpriv->shadow = FALSE;
-      
-      screen->fb.byteStride = priv->bytes_per_line;
-      screen->fb.pixelStride = screen->width;
-      screen->fb.frameBuffer = (CARD8 *) (priv->base);
+    EphyrScrPriv *scrpriv = screen->driver;
+    EphyrPriv *priv = screen->card->driver;
+    KdPointerMatrix m;
+    int buffer_height;
+
+    EPHYR_LOG("screen->width: %d, screen->height: %d index=%d",
+              screen->width, screen->height, screen->mynum);
+
+    /*
+     * Use the rotation last applied to ourselves (in the Xephyr case the fb
+     * coordinate system moves independently of the pointer coordiante system).
+     */
+    KdComputePointerMatrix(&m, ephyrRandr, screen->width, screen->height);
+    KdSetPointerMatrix(&m);
+
+    priv->bytes_per_line =
+        ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
+
+    buffer_height = ephyrBufferHeight(screen);
+
+    priv->base =
+        hostx_screen_init(screen, screen->width, screen->height, buffer_height);
+
+    if ((scrpriv->randr & RR_Rotate_0) && !(scrpriv->randr & RR_Reflect_All)) {
+        scrpriv->shadow = FALSE;
+
+        screen->fb.byteStride = priv->bytes_per_line;
+        screen->fb.pixelStride = screen->width;
+        screen->fb.frameBuffer = (CARD8 *) (priv->base);
     }
-  else
-    {
-      /* Rotated/Reflected so we need to use shadow fb */
-      scrpriv->shadow = TRUE;
-      
-      EPHYR_LOG("allocing shadow");
-      
-      KdShadowFbAlloc (screen,
-		       scrpriv->randr & (RR_Rotate_90|RR_Rotate_270));
+    else {
+        /* Rotated/Reflected so we need to use shadow fb */
+        scrpriv->shadow = TRUE;
+
+        EPHYR_LOG("allocing shadow");
+
+        KdShadowFbAlloc(screen,
+                        scrpriv->randr & (RR_Rotate_90 | RR_Rotate_270));
     }
-  
-  return TRUE;
+
+    return TRUE;
 }
 
 void
-ephyrSetScreenSizes (ScreenPtr pScreen)
+ephyrSetScreenSizes(ScreenPtr pScreen)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	*screen = pScreenPriv->screen;
-  EphyrScrPriv	*scrpriv = screen->driver;
-  
-  if (scrpriv->randr & (RR_Rotate_0|RR_Rotate_180))
-    {
-      pScreen->width = screen->width;
-      pScreen->height = screen->height;
-      pScreen->mmWidth = screen->width_mm;
-      pScreen->mmHeight = screen->height_mm;
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    EphyrScrPriv *scrpriv = screen->driver;
+
+    if (scrpriv->randr & (RR_Rotate_0 | RR_Rotate_180)) {
+        pScreen->width = screen->width;
+        pScreen->height = screen->height;
+        pScreen->mmWidth = screen->width_mm;
+        pScreen->mmHeight = screen->height_mm;
     }
-  else 
-    {
-      pScreen->width = screen->height;
-      pScreen->height = screen->width;
-      pScreen->mmWidth = screen->height_mm;
-      pScreen->mmHeight = screen->width_mm;
+    else {
+        pScreen->width = screen->height;
+        pScreen->height = screen->width;
+        pScreen->mmWidth = screen->height_mm;
+        pScreen->mmHeight = screen->width_mm;
     }
 }
 
 Bool
-ephyrUnmapFramebuffer (KdScreenInfo *screen)
+ephyrUnmapFramebuffer(KdScreenInfo * screen)
 {
-  EphyrScrPriv  *scrpriv = screen->driver;
-  
-  if (scrpriv->shadow)
-    KdShadowFbFree (screen);
-  
-  /* Note, priv->base will get freed when XImage recreated */
-  
-  return TRUE;
+    EphyrScrPriv *scrpriv = screen->driver;
+
+    if (scrpriv->shadow)
+        KdShadowFbFree(screen);
+
+    /* Note, priv->base will get freed when XImage recreated */
+
+    return TRUE;
 }
 
-void 
-ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf)
+void
+ephyrShadowUpdate(ScreenPtr pScreen, shadowBufPtr pBuf)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo *screen = pScreenPriv->screen;
-  
-  EPHYR_LOG("slow paint");
-  
-  /* FIXME: Slow Rotated/Reflected updates could be much
-   * much faster efficiently updating via tranforming 
-   * pBuf->pDamage  regions     
-  */
-  shadowUpdateRotatePacked(pScreen, pBuf);
-  hostx_paint_rect(screen, 0,0,0,0, screen->width, screen->height);
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+
+    EPHYR_LOG("slow paint");
+
+    /* FIXME: Slow Rotated/Reflected updates could be much
+     * much faster efficiently updating via tranforming 
+     * pBuf->pDamage  regions     
+     */
+    shadowUpdateRotatePacked(pScreen, pBuf);
+    hostx_paint_rect(screen, 0, 0, 0, 0, screen->width, screen->height);
 }
 
 static void
-ephyrInternalDamageRedisplay (ScreenPtr pScreen)
+ephyrInternalDamageRedisplay(ScreenPtr pScreen)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	*screen = pScreenPriv->screen;
-  EphyrScrPriv	*scrpriv = screen->driver;
-  RegionPtr	 pRegion;
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    EphyrScrPriv *scrpriv = screen->driver;
+    RegionPtr pRegion;
 
-  if (!scrpriv || !scrpriv->pDamage)
-    return;
+    if (!scrpriv || !scrpriv->pDamage)
+        return;
 
-  pRegion = DamageRegion (scrpriv->pDamage);
+    pRegion = DamageRegion(scrpriv->pDamage);
 
-  if (RegionNotEmpty(pRegion))
-    {
-      int           nbox;
-      BoxPtr        pbox;
+    if (RegionNotEmpty(pRegion)) {
+        int nbox;
+        BoxPtr pbox;
 
-      nbox = RegionNumRects (pRegion);
-      pbox = RegionRects (pRegion);
+        nbox = RegionNumRects(pRegion);
+        pbox = RegionRects(pRegion);
 
-      while (nbox--)
-        {
-          hostx_paint_rect(screen,
-                           pbox->x1, pbox->y1,
-                           pbox->x1, pbox->y1,
-                           pbox->x2 - pbox->x1,
-                           pbox->y2 - pbox->y1);
-          pbox++;
+        while (nbox--) {
+            hostx_paint_rect(screen,
+                             pbox->x1, pbox->y1,
+                             pbox->x1, pbox->y1,
+                             pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
+            pbox++;
         }
-      DamageEmpty (scrpriv->pDamage);
+        DamageEmpty(scrpriv->pDamage);
     }
 }
 
 static void
-ephyrInternalDamageBlockHandler (pointer   data,
-				 OSTimePtr pTimeout,
-				 pointer   pRead)
+ephyrInternalDamageBlockHandler(pointer data, OSTimePtr pTimeout, pointer pRead)
 {
-  ScreenPtr pScreen = (ScreenPtr) data;
-  
-  ephyrInternalDamageRedisplay (pScreen);
+    ScreenPtr pScreen = (ScreenPtr) data;
+
+    ephyrInternalDamageRedisplay(pScreen);
 }
 
 static void
-ephyrInternalDamageWakeupHandler (pointer data, int i, pointer LastSelectMask)
+ephyrInternalDamageWakeupHandler(pointer data, int i, pointer LastSelectMask)
 {
-  /* FIXME: Not needed ? */
+    /* FIXME: Not needed ? */
 }
 
 Bool
-ephyrSetInternalDamage (ScreenPtr pScreen)
+ephyrSetInternalDamage(ScreenPtr pScreen)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	*screen = pScreenPriv->screen;
-  EphyrScrPriv	*scrpriv = screen->driver;
-  PixmapPtr      pPixmap = NULL;
-  
-  scrpriv->pDamage = DamageCreate ((DamageReportFunc) 0,
-				   (DamageDestroyFunc) 0,
-				   DamageReportNone,
-				   TRUE,
-				   pScreen,
-				   pScreen);
-  
-  if (!RegisterBlockAndWakeupHandlers (ephyrInternalDamageBlockHandler,
-				       ephyrInternalDamageWakeupHandler,
-				       (pointer) pScreen))
-    return FALSE;
-  
-  pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
-  
-  DamageRegister (&pPixmap->drawable, scrpriv->pDamage);
-      
-  return TRUE;
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    EphyrScrPriv *scrpriv = screen->driver;
+    PixmapPtr pPixmap = NULL;
+
+    scrpriv->pDamage = DamageCreate((DamageReportFunc) 0,
+                                    (DamageDestroyFunc) 0,
+                                    DamageReportNone, TRUE, pScreen, pScreen);
+
+    if (!RegisterBlockAndWakeupHandlers(ephyrInternalDamageBlockHandler,
+                                        ephyrInternalDamageWakeupHandler,
+                                        (pointer) pScreen))
+        return FALSE;
+
+    pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
+
+    DamageRegister(&pPixmap->drawable, scrpriv->pDamage);
+
+    return TRUE;
 }
 
 void
-ephyrUnsetInternalDamage (ScreenPtr pScreen)
+ephyrUnsetInternalDamage(ScreenPtr pScreen)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	*screen = pScreenPriv->screen;
-  EphyrScrPriv	*scrpriv = screen->driver;
-  PixmapPtr      pPixmap = NULL;
-  
-  pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
-  DamageUnregister (&pPixmap->drawable, scrpriv->pDamage);
-  DamageDestroy (scrpriv->pDamage);
-  
-  RemoveBlockAndWakeupHandlers (ephyrInternalDamageBlockHandler,
-				ephyrInternalDamageWakeupHandler,
-				(pointer) pScreen);
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    EphyrScrPriv *scrpriv = screen->driver;
+    PixmapPtr pPixmap = NULL;
+
+    pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
+    DamageUnregister(&pPixmap->drawable, scrpriv->pDamage);
+    DamageDestroy(scrpriv->pDamage);
+
+    RemoveBlockAndWakeupHandlers(ephyrInternalDamageBlockHandler,
+                                 ephyrInternalDamageWakeupHandler,
+                                 (pointer) pScreen);
 }
 
 #ifdef RANDR
 Bool
-ephyrRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
+ephyrRandRGetInfo(ScreenPtr pScreen, Rotation * rotations)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	    *screen = pScreenPriv->screen;
-  EphyrScrPriv	    *scrpriv = screen->driver;
-  RRScreenSizePtr	    pSize;
-  Rotation		    randr;
-  int			    n = 0;
- 
-  struct { int width, height; } sizes[] = 
-    {
-      { 1600, 1200 },
-      { 1400, 1050 },
-      { 1280, 960  },
-      { 1280, 1024 },
-      { 1152, 864 },
-      { 1024, 768 },
-      { 832, 624 },
-      { 800, 600 },
-      { 720, 400 },
-      { 480, 640 },
-      { 640, 480 },
-      { 640, 400 },
-      { 320, 240 },
-      { 240, 320 },
-      { 160, 160 }, 
-      { 0, 0 }
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    EphyrScrPriv *scrpriv = screen->driver;
+    RRScreenSizePtr pSize;
+    Rotation randr;
+    int n = 0;
+
+    struct {
+        int width, height;
+    } sizes[] = {
+        {
+        1600, 1200}, {
+        1400, 1050}, {
+        1280, 960}, {
+        1280, 1024}, {
+        1152, 864}, {
+        1024, 768}, {
+        832, 624}, {
+        800, 600}, {
+        720, 400}, {
+        480, 640}, {
+        640, 480}, {
+        640, 400}, {
+        320, 240}, {
+        240, 320}, {
+        160, 160}, {
+        0, 0}
     };
 
-  EPHYR_LOG("mark");
-
-  *rotations = RR_Rotate_All|RR_Reflect_All;
-
-  if (!hostx_want_preexisting_window (screen)
-      && !hostx_want_fullscreen ()) /* only if no -parent switch */
-    {
-      while (sizes[n].width != 0 && sizes[n].height != 0)
-	{
-	  RRRegisterSize (pScreen,
-			  sizes[n].width,
-			  sizes[n].height, 
-			  (sizes[n].width * screen->width_mm)/screen->width,
-			  (sizes[n].height *screen->height_mm)/screen->height
-			  );
-	  n++;
-	}
+    EPHYR_LOG("mark");
+
+    *rotations = RR_Rotate_All | RR_Reflect_All;
+
+    if (!hostx_want_preexisting_window(screen)
+        && !hostx_want_fullscreen()) {  /* only if no -parent switch */
+        while (sizes[n].width != 0 && sizes[n].height != 0) {
+            RRRegisterSize(pScreen,
+                           sizes[n].width,
+                           sizes[n].height,
+                           (sizes[n].width * screen->width_mm) / screen->width,
+                           (sizes[n].height * screen->height_mm) /
+                           screen->height);
+            n++;
+        }
     }
-  
-  pSize = RRRegisterSize (pScreen,
-			  screen->width,
-			  screen->height, 
-			  screen->width_mm,
-			  screen->height_mm);
-    
-  randr = KdSubRotation (scrpriv->randr, screen->randr);
-  
-  RRSetCurrentConfig (pScreen, randr, 0, pSize);
-    
-  return TRUE;
+
+    pSize = RRRegisterSize(pScreen,
+                           screen->width,
+                           screen->height, screen->width_mm, screen->height_mm);
+
+    randr = KdSubRotation(scrpriv->randr, screen->randr);
+
+    RRSetCurrentConfig(pScreen, randr, 0, pSize);
+
+    return TRUE;
 }
 
 Bool
-ephyrRandRSetConfig (ScreenPtr		pScreen,
-		     Rotation		randr,
-		     int		rate,
-		     RRScreenSizePtr	pSize)
+ephyrRandRSetConfig(ScreenPtr pScreen,
+                    Rotation randr, int rate, RRScreenSizePtr pSize)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	*screen    = pScreenPriv->screen;
-  EphyrScrPriv	*scrpriv   = screen->driver;
-  Bool		wasEnabled = pScreenPriv->enabled;
-  EphyrScrPriv	oldscr;
-  int		oldwidth, oldheight, oldmmwidth, oldmmheight;
-  Bool          oldshadow;
-  int		newwidth, newheight;
-  
-  if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
-    {
-      newwidth = pSize->width;
-      newheight = pSize->height;
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    EphyrScrPriv *scrpriv = screen->driver;
+    Bool wasEnabled = pScreenPriv->enabled;
+    EphyrScrPriv oldscr;
+    int oldwidth, oldheight, oldmmwidth, oldmmheight;
+    Bool oldshadow;
+    int newwidth, newheight;
+
+    if (screen->randr & (RR_Rotate_0 | RR_Rotate_180)) {
+        newwidth = pSize->width;
+        newheight = pSize->height;
     }
-  else
-    {
-      newwidth = pSize->height;
-      newheight = pSize->width;
+    else {
+        newwidth = pSize->height;
+        newheight = pSize->width;
     }
-  
-  if (wasEnabled)
-    KdDisableScreen (pScreen);
-
-  oldscr = *scrpriv;
-    
-  oldwidth    = screen->width;
-  oldheight   = screen->height;
-  oldmmwidth  = pScreen->mmWidth;
-  oldmmheight = pScreen->mmHeight;
-  oldshadow   = scrpriv->shadow;
-  
-  /*
-   * Set new configuration
-   */
-  
-  /*
-   * We need to store the rotation value for pointer coords transformation;
-   * though initially the pointer and fb rotation are identical, when we map
-   * the fb, the screen will be reinitialized and return into an unrotated
-   * state (presumably the HW is taking care of the rotation of the fb), but the
-   * pointer still needs to be transformed.
-   */
-  ephyrRandr = KdAddRotation (screen->randr, randr);
-  scrpriv->randr = ephyrRandr;
-  
-  ephyrUnmapFramebuffer (screen); 
-  
-  screen->width  = newwidth;
-  screen->height = newheight;
-  
-  if (!ephyrMapFramebuffer (screen))
-    goto bail4;
-  
-  /* FIXME below should go in own call */
-  
-  if (oldshadow)
-    KdShadowUnset (screen->pScreen);
-  else
-    ephyrUnsetInternalDamage(screen->pScreen);
-  
-  if (scrpriv->shadow)
-    {
-      if (!KdShadowSet (screen->pScreen, 
-			scrpriv->randr, 
-			ephyrShadowUpdate, 
-			ephyrWindowLinear))
-	goto bail4;
+
+    if (wasEnabled)
+        KdDisableScreen(pScreen);
+
+    oldscr = *scrpriv;
+
+    oldwidth = screen->width;
+    oldheight = screen->height;
+    oldmmwidth = pScreen->mmWidth;
+    oldmmheight = pScreen->mmHeight;
+    oldshadow = scrpriv->shadow;
+
+    /*
+     * Set new configuration
+     */
+
+    /*
+     * We need to store the rotation value for pointer coords transformation;
+     * though initially the pointer and fb rotation are identical, when we map
+     * the fb, the screen will be reinitialized and return into an unrotated
+     * state (presumably the HW is taking care of the rotation of the fb), but the
+     * pointer still needs to be transformed.
+     */
+    ephyrRandr = KdAddRotation(screen->randr, randr);
+    scrpriv->randr = ephyrRandr;
+
+    ephyrUnmapFramebuffer(screen);
+
+    screen->width = newwidth;
+    screen->height = newheight;
+
+    if (!ephyrMapFramebuffer(screen))
+        goto bail4;
+
+    /* FIXME below should go in own call */
+
+    if (oldshadow)
+        KdShadowUnset(screen->pScreen);
+    else
+        ephyrUnsetInternalDamage(screen->pScreen);
+
+    if (scrpriv->shadow) {
+        if (!KdShadowSet(screen->pScreen,
+                         scrpriv->randr, ephyrShadowUpdate, ephyrWindowLinear))
+            goto bail4;
     }
-  else
-    {
-      /* Without shadow fb ( non rotated ) we need 
-       * to use damage to efficiently update display
-       * via signal regions what to copy from 'fb'.
-       */
-      if (!ephyrSetInternalDamage(screen->pScreen))
-	goto bail4;
+    else {
+        /* Without shadow fb ( non rotated ) we need 
+         * to use damage to efficiently update display
+         * via signal regions what to copy from 'fb'.
+         */
+        if (!ephyrSetInternalDamage(screen->pScreen))
+            goto bail4;
     }
-  
-  ephyrSetScreenSizes (screen->pScreen);
-  
-  /*
-   * Set frame buffer mapping
-   */
-  (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
-				  pScreen->width,
-				  pScreen->height,
-				  screen->fb.depth,
-				  screen->fb.bitsPerPixel,
-				  screen->fb.byteStride,
-				  screen->fb.frameBuffer);
-  
-  /* set the subpixel order */
-  
-  KdSetSubpixelOrder (pScreen, scrpriv->randr);
-  
-  if (wasEnabled)
-    KdEnableScreen (pScreen);
-  
-  return TRUE;
-  
+
+    ephyrSetScreenSizes(screen->pScreen);
+
+    /*
+     * Set frame buffer mapping
+     */
+    (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap(pScreen),
+                                    pScreen->width,
+                                    pScreen->height,
+                                    screen->fb.depth,
+                                    screen->fb.bitsPerPixel,
+                                    screen->fb.byteStride,
+                                    screen->fb.frameBuffer);
+
+    /* set the subpixel order */
+
+    KdSetSubpixelOrder(pScreen, scrpriv->randr);
+
+    if (wasEnabled)
+        KdEnableScreen(pScreen);
+
+    return TRUE;
+
  bail4:
-  EPHYR_LOG("bailed");
-  
-  ephyrUnmapFramebuffer (screen);
-  *scrpriv = oldscr;
-  (void) ephyrMapFramebuffer (screen);
-  
-  pScreen->width = oldwidth;
-  pScreen->height = oldheight;
-  pScreen->mmWidth = oldmmwidth;
-  pScreen->mmHeight = oldmmheight;
-  
-  if (wasEnabled)
-    KdEnableScreen (pScreen);
-  return FALSE;
+    EPHYR_LOG("bailed");
+
+    ephyrUnmapFramebuffer(screen);
+    *scrpriv = oldscr;
+    (void) ephyrMapFramebuffer(screen);
+
+    pScreen->width = oldwidth;
+    pScreen->height = oldheight;
+    pScreen->mmWidth = oldmmwidth;
+    pScreen->mmHeight = oldmmheight;
+
+    if (wasEnabled)
+        KdEnableScreen(pScreen);
+    return FALSE;
 }
 
 Bool
-ephyrRandRInit (ScreenPtr pScreen)
+ephyrRandRInit(ScreenPtr pScreen)
 {
-  rrScrPrivPtr    pScrPriv;
-  
-  if (!RRScreenInit (pScreen))
-    return FALSE;
-  
-  pScrPriv = rrGetScrPriv(pScreen);
-  pScrPriv->rrGetInfo = ephyrRandRGetInfo;
-  pScrPriv->rrSetConfig = ephyrRandRSetConfig;
-  return TRUE;
+    rrScrPrivPtr pScrPriv;
+
+    if (!RRScreenInit(pScreen))
+        return FALSE;
+
+    pScrPriv = rrGetScrPriv(pScreen);
+    pScrPriv->rrGetInfo = ephyrRandRGetInfo;
+    pScrPriv->rrSetConfig = ephyrRandRSetConfig;
+    return TRUE;
 }
 #endif
 
 Bool
-ephyrCreateColormap (ColormapPtr pmap)
+ephyrCreateColormap(ColormapPtr pmap)
 {
-  return fbInitializeColormap (pmap);
+    return fbInitializeColormap(pmap);
 }
 
 Bool
-ephyrInitScreen (ScreenPtr pScreen)
+ephyrInitScreen(ScreenPtr pScreen)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	*screen    = pScreenPriv->screen;
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
 
-  EPHYR_LOG ("pScreen->myNum:%d\n", pScreen->myNum) ;
-  hostx_set_screen_number (screen, pScreen->myNum);
-  hostx_set_win_title (screen, "(ctrl+shift grabs mouse and keyboard)") ;
-  pScreen->CreateColormap = ephyrCreateColormap;
+    EPHYR_LOG("pScreen->myNum:%d\n", pScreen->myNum);
+    hostx_set_screen_number(screen, pScreen->myNum);
+    hostx_set_win_title(screen, "(ctrl+shift grabs mouse and keyboard)");
+    pScreen->CreateColormap = ephyrCreateColormap;
 
 #ifdef XV
-  if (!ephyrNoXV) {
-      if (!ephyrInitVideo (pScreen)) {
-          EPHYR_LOG_ERROR ("failed to initialize xvideo\n") ;
-      } else {
-          EPHYR_LOG ("initialized xvideo okay\n") ;
-      }
-  }
+    if (!ephyrNoXV) {
+        if (!ephyrInitVideo(pScreen)) {
+            EPHYR_LOG_ERROR("failed to initialize xvideo\n");
+        }
+        else {
+            EPHYR_LOG("initialized xvideo okay\n");
+        }
+    }
 #endif /*XV*/
-
 #ifdef XF86DRI
-  if (!ephyrNoDRI && !hostx_has_dri ()) {
-      EPHYR_LOG ("host x does not support DRI. Disabling DRI forwarding\n") ;
-      ephyrNoDRI = TRUE ;
+        if (!ephyrNoDRI && !hostx_has_dri()) {
+        EPHYR_LOG("host x does not support DRI. Disabling DRI forwarding\n");
+        ephyrNoDRI = TRUE;
 #ifdef GLXEXT
-      noGlxVisualInit = FALSE ;
+        noGlxVisualInit = FALSE;
 #endif
-  }
-  if (!ephyrNoDRI) {
-    ephyrDRIExtensionInit (pScreen) ;
-    ephyrHijackGLXExtension () ;
-  }
+    }
+    if (!ephyrNoDRI) {
+        ephyrDRIExtensionInit(pScreen);
+        ephyrHijackGLXExtension();
+    }
 #endif
 
 #ifdef GLXEXT
-  if (ephyrNoDRI) {
-      noGlxVisualInit = FALSE ;
-  }
+    if (ephyrNoDRI) {
+        noGlxVisualInit = FALSE;
+    }
 #endif
 
-  return TRUE;
+    return TRUE;
 }
 
 Bool
-ephyrFinishInitScreen (ScreenPtr pScreen)
+ephyrFinishInitScreen(ScreenPtr pScreen)
 {
-  /* FIXME: Calling this even if not using shadow.  
-   * Seems harmless enough. But may be safer elsewhere.
-   */
-  if (!shadowSetup (pScreen))
-    return FALSE;
+    /* FIXME: Calling this even if not using shadow.  
+     * Seems harmless enough. But may be safer elsewhere.
+     */
+    if (!shadowSetup(pScreen))
+        return FALSE;
 
 #ifdef RANDR
-  if (!ephyrRandRInit (pScreen))
-    return FALSE;
+    if (!ephyrRandRInit(pScreen))
+        return FALSE;
 #endif
 
-  return TRUE;
+    return TRUE;
 }
 
 Bool
-ephyrCreateResources (ScreenPtr pScreen)
+ephyrCreateResources(ScreenPtr pScreen)
 {
-  KdScreenPriv(pScreen);
-  KdScreenInfo	*screen    = pScreenPriv->screen;
-  EphyrScrPriv	*scrpriv   = screen->driver;
-
-  EPHYR_LOG("mark pScreen=%p mynum=%d shadow=%d",
-            pScreen, pScreen->myNum, scrpriv->shadow);
-
-  if (scrpriv->shadow) 
-    return KdShadowSet (pScreen, 
-			scrpriv->randr, 
-			ephyrShadowUpdate, 
-			ephyrWindowLinear);
-  else
-    return ephyrSetInternalDamage(pScreen); 
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    EphyrScrPriv *scrpriv = screen->driver;
+
+    EPHYR_LOG("mark pScreen=%p mynum=%d shadow=%d",
+              pScreen, pScreen->myNum, scrpriv->shadow);
+
+    if (scrpriv->shadow)
+        return KdShadowSet(pScreen,
+                           scrpriv->randr,
+                           ephyrShadowUpdate, ephyrWindowLinear);
+    else
+        return ephyrSetInternalDamage(pScreen);
 }
 
 void
-ephyrPreserve (KdCardInfo *card)
+ephyrPreserve(KdCardInfo * card)
 {
 }
 
 Bool
-ephyrEnable (ScreenPtr pScreen)
+ephyrEnable(ScreenPtr pScreen)
 {
-  return TRUE;
+    return TRUE;
 }
 
 Bool
-ephyrDPMS (ScreenPtr pScreen, int mode)
+ephyrDPMS(ScreenPtr pScreen, int mode)
 {
-  return TRUE;
+    return TRUE;
 }
 
 void
-ephyrDisable (ScreenPtr pScreen)
+ephyrDisable(ScreenPtr pScreen)
 {
 }
 
 void
-ephyrRestore (KdCardInfo *card)
+ephyrRestore(KdCardInfo * card)
 {
 }
 
 void
-ephyrScreenFini (KdScreenInfo *screen)
+ephyrScreenFini(KdScreenInfo * screen)
 {
-    EphyrScrPriv  *scrpriv = screen->driver;
+    EphyrScrPriv *scrpriv = screen->driver;
+
     if (scrpriv->shadow) {
-        KdShadowFbFree (screen);
+        KdShadowFbFree(screen);
     }
     free(screen->driver);
     screen->driver = NULL;
@@ -764,99 +728,99 @@ void
 ephyrUpdateModifierState(unsigned int state)
 {
 
-  DeviceIntPtr pDev = inputInfo.keyboard;
-  KeyClassPtr keyc = pDev->key;
-  int i;
-  CARD8 mask;
-  int xkb_state;
-  
-  if (!pDev)
-      return;
+    DeviceIntPtr pDev = inputInfo.keyboard;
+    KeyClassPtr keyc = pDev->key;
+    int i;
+    CARD8 mask;
+    int xkb_state;
 
-  xkb_state = XkbStateFieldFromRec(&pDev->key->xkbInfo->state);
-  state = state & 0xff;
+    if (!pDev)
+        return;
 
-  if (xkb_state == state)
-    return;
-      
-  for (i = 0, mask = 1; i < 8; i++, mask <<= 1) {
-    int key;
+    xkb_state = XkbStateFieldFromRec(&pDev->key->xkbInfo->state);
+    state = state & 0xff;
 
-    /* Modifier is down, but shouldn't be
-     */
-    if ((xkb_state & mask) && !(state & mask)) {
-      int count = keyc->modifierKeyCount[i];
+    if (xkb_state == state)
+        return;
 
-      for (key = 0; key < MAP_LENGTH; key++)
-        if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
-          if (key_is_down(pDev, key, KEY_PROCESSED))
-	        KdEnqueueKeyboardEvent (ephyrKbd, key, TRUE);
+    for (i = 0, mask = 1; i < 8; i++, mask <<= 1) {
+        int key;
 
-          if (--count == 0)
-            break;
-        }
-    }
+        /* Modifier is down, but shouldn't be
+         */
+        if ((xkb_state & mask) && !(state & mask)) {
+            int count = keyc->modifierKeyCount[i];
 
-    /* Modifier shoud be down, but isn't
-     */
-    if (!(xkb_state & mask) && (state & mask))
-      for (key = 0; key < MAP_LENGTH; key++)
-        if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
-	        KdEnqueueKeyboardEvent (ephyrKbd, key, FALSE);
-          break;
+            for (key = 0; key < MAP_LENGTH; key++)
+                if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
+                    if (key_is_down(pDev, key, KEY_PROCESSED))
+                        KdEnqueueKeyboardEvent(ephyrKbd, key, TRUE);
+
+                    if (--count == 0)
+                        break;
+                }
         }
-  }
+
+        /* Modifier shoud be down, but isn't
+         */
+        if (!(xkb_state & mask) && (state & mask))
+            for (key = 0; key < MAP_LENGTH; key++)
+                if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
+                    KdEnqueueKeyboardEvent(ephyrKbd, key, FALSE);
+                    break;
+                }
+    }
 }
 
 static void
-ephyrBlockSigio (void)
+ephyrBlockSigio(void)
 {
     sigset_t set;
 
-    sigemptyset (&set);
-    sigaddset (&set, SIGIO);
-    sigprocmask (SIG_BLOCK, &set, 0);
+    sigemptyset(&set);
+    sigaddset(&set, SIGIO);
+    sigprocmask(SIG_BLOCK, &set, 0);
 }
 
 static void
-ephyrUnblockSigio (void)
+ephyrUnblockSigio(void)
 {
     sigset_t set;
 
-    sigemptyset (&set);
-    sigaddset (&set, SIGIO);
-    sigprocmask (SIG_UNBLOCK, &set, 0);
+    sigemptyset(&set);
+    sigaddset(&set, SIGIO);
+    sigprocmask(SIG_UNBLOCK, &set, 0);
 }
 
 static Bool
 ephyrCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)
 {
-  return FALSE;
+    return FALSE;
 }
 
 static void
-ephyrCrossScreen (ScreenPtr pScreen, Bool entering)
+ephyrCrossScreen(ScreenPtr pScreen, Bool entering)
 {
 }
 
-int ephyrCurScreen; /*current event screen*/
+int ephyrCurScreen;             /*current event screen */
 
 static void
-ephyrWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+ephyrWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
 {
-    ephyrBlockSigio ();
+    ephyrBlockSigio();
     ephyrCurScreen = pScreen->myNum;
-    miPointerWarpCursor (inputInfo.pointer, pScreen, x, y);
-    ephyrUnblockSigio ();
+    miPointerWarpCursor(inputInfo.pointer, pScreen, x, y);
+
+    ephyrUnblockSigio();
 }
 
-miPointerScreenFuncRec ephyrPointerScreenFuncs =
-{
-  ephyrCursorOffScreen,
-  ephyrCrossScreen,
-  ephyrWarpCursor,
-  NULL,
-  NULL
+miPointerScreenFuncRec ephyrPointerScreenFuncs = {
+    ephyrCursorOffScreen,
+    ephyrCrossScreen,
+    ephyrWarpCursor,
+    NULL,
+    NULL
 };
 
 #ifdef XF86DRI
@@ -875,198 +839,192 @@ miPointerScreenFuncRec ephyrPointerScreenFuncs =
  * expose events and send those events to clients.
  */
 static void
-ephyrExposePairedWindow (int a_remote)
+ephyrExposePairedWindow(int a_remote)
 {
     EphyrWindowPair *pair = NULL;
     RegionRec reg;
     ScreenPtr screen;
 
-    if (!findWindowPairFromRemote (a_remote, &pair)) {
-	EPHYR_LOG ("did not find a pair for this window\n");
-	return;
+    if (!findWindowPairFromRemote(a_remote, &pair)) {
+        EPHYR_LOG("did not find a pair for this window\n");
+        return;
     }
     screen = pair->local->drawable.pScreen;
     RegionNull(&reg);
     RegionCopy(&reg, &pair->local->clipList);
-    screen->WindowExposures (pair->local, &reg, NullRegion);
+    screen->WindowExposures(pair->local, &reg, NullRegion);
     RegionUninit(&reg);
 }
-#endif /* XF86DRI */
+#endif                          /* XF86DRI */
 
 void
 ephyrPoll(void)
 {
-  EphyrHostXEvent ev;
+    EphyrHostXEvent ev;
 
-  while (hostx_get_event(&ev))
-    {
-      switch (ev.type)
-        {
+    while (hostx_get_event(&ev)) {
+        switch (ev.type) {
         case EPHYR_EV_MOUSE_MOTION:
-          if (!ephyrMouse ||
-              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {
-              EPHYR_LOG ("skipping mouse motion:%d\n", ephyrCurScreen) ;
-              continue;
-          }
-          {
-            if (ev.data.mouse_motion.screen >=0
-                && (ephyrCurScreen != ev.data.mouse_motion.screen))
-              {
-                  EPHYR_LOG ("warping mouse cursor. "
-                             "cur_screen%d, motion_screen:%d\n",
-                             ephyrCurScreen, ev.data.mouse_motion.screen) ;
-                  if (ev.data.mouse_motion.screen >= 0)
-                    {
-                      ephyrWarpCursor
-                            (inputInfo.pointer, screenInfo.screens[ev.data.mouse_motion.screen],
-                             ev.data.mouse_motion.x,
-                             ev.data.mouse_motion.y );
+            if (!ephyrMouse ||
+                !((EphyrPointerPrivate *) ephyrMouse->driverPrivate)->enabled) {
+                EPHYR_LOG("skipping mouse motion:%d\n", ephyrCurScreen);
+                continue;
+            }
+            {
+                if (ev.data.mouse_motion.screen >= 0
+                    && (ephyrCurScreen != ev.data.mouse_motion.screen)) {
+                    EPHYR_LOG("warping mouse cursor. "
+                              "cur_screen%d, motion_screen:%d\n",
+                              ephyrCurScreen, ev.data.mouse_motion.screen);
+                    if (ev.data.mouse_motion.screen >= 0) {
+                        ephyrWarpCursor
+                            (inputInfo.pointer,
+                             screenInfo.screens[ev.data.mouse_motion.screen],
+                             ev.data.mouse_motion.x, ev.data.mouse_motion.y);
                     }
-              }
-            else
-              {
-                  int x=0, y=0;
+                }
+                else {
+                    int x = 0, y = 0;
+
 #ifdef XF86DRI
-                  EphyrWindowPair *pair = NULL;
+                    EphyrWindowPair *pair = NULL;
 #endif
-                  EPHYR_LOG ("enqueuing mouse motion:%d\n", ephyrCurScreen) ;
-                  x = ev.data.mouse_motion.x;
-                  y = ev.data.mouse_motion.y;
-                  EPHYR_LOG ("initial (x,y):(%d,%d)\n", x, y) ;
+                    EPHYR_LOG("enqueuing mouse motion:%d\n", ephyrCurScreen);
+                    x = ev.data.mouse_motion.x;
+                    y = ev.data.mouse_motion.y;
+                    EPHYR_LOG("initial (x,y):(%d,%d)\n", x, y);
 #ifdef XF86DRI
-                  EPHYR_LOG ("is this window peered by a gl drawable ?\n") ;
-                  if (findWindowPairFromRemote (ev.data.mouse_motion.window,
-                                                &pair))
-                    {
-                        EPHYR_LOG ("yes, it is peered\n") ;
+                    EPHYR_LOG("is this window peered by a gl drawable ?\n");
+                    if (findWindowPairFromRemote(ev.data.mouse_motion.window,
+                                                 &pair)) {
+                        EPHYR_LOG("yes, it is peered\n");
                         x += pair->local->drawable.x;
                         y += pair->local->drawable.y;
                     }
-                  else
-                    {
-                        EPHYR_LOG ("no, it is not peered\n") ;
+                    else {
+                        EPHYR_LOG("no, it is not peered\n");
                     }
-                  EPHYR_LOG ("final (x,y):(%d,%d)\n", x, y) ;
+                    EPHYR_LOG("final (x,y):(%d,%d)\n", x, y);
 #endif
-                  KdEnqueuePointerEvent(ephyrMouse, mouseState, x, y, 0);
-              }
-          }
-          break;
+                    KdEnqueuePointerEvent(ephyrMouse, mouseState, x, y, 0);
+                }
+            }
+            break;
 
         case EPHYR_EV_MOUSE_PRESS:
-          if (!ephyrMouse ||
-              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {
-              EPHYR_LOG ("skipping mouse press:%d\n", ephyrCurScreen) ;
-              continue;
-          }
-          EPHYR_LOG ("enqueuing mouse press:%d\n", ephyrCurScreen) ;
-	  ephyrUpdateModifierState(ev.key_state);
-	  mouseState |= ev.data.mouse_down.button_num;
-	  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;
-          EPHYR_LOG ("enqueuing mouse release:%d\n", ephyrCurScreen) ;
-	  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 (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 (ephyrKbd, ev.data.key_up.scancode, TRUE);
-	  break;
+            if (!ephyrMouse ||
+                !((EphyrPointerPrivate *) ephyrMouse->driverPrivate)->enabled) {
+                EPHYR_LOG("skipping mouse press:%d\n", ephyrCurScreen);
+                continue;
+            }
+            EPHYR_LOG("enqueuing mouse press:%d\n", ephyrCurScreen);
+            ephyrUpdateModifierState(ev.key_state);
+            mouseState |= ev.data.mouse_down.button_num;
+            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;
+            EPHYR_LOG("enqueuing mouse release:%d\n", ephyrCurScreen);
+            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(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(ephyrKbd, ev.data.key_up.scancode, TRUE);
+            break;
 
 #ifdef XF86DRI
-	case EPHYR_EV_EXPOSE:
-	  /*
-	   * We only receive expose events when the expose event have
-	   * be generated for a drawable that is a host X window managed
-	   * by Xephyr. Host X windows managed by Xephyr exists for instance
-	   * when Xephyr is asked to create a GL drawable in a DRI environment.
-	   */
-	  ephyrExposePairedWindow (ev.data.expose.window);
-	  break;
-#endif /* XF86DRI */
-
-	default:
-	  break;
-	}
+        case EPHYR_EV_EXPOSE:
+            /*
+             * We only receive expose events when the expose event have
+             * be generated for a drawable that is a host X window managed
+             * by Xephyr. Host X windows managed by Xephyr exists for instance
+             * when Xephyr is asked to create a GL drawable in a DRI environment.
+             */
+            ephyrExposePairedWindow(ev.data.expose.window);
+            break;
+#endif                          /* XF86DRI */
+
+        default:
+            break;
+        }
     }
 }
 
 void
-ephyrCardFini (KdCardInfo *card)
+ephyrCardFini(KdCardInfo * card)
 {
-  EphyrPriv	*priv = card->driver;
-  free(priv);
+    EphyrPriv *priv = card->driver;
+
+    free(priv);
 }
 
 void
-ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+ephyrGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
 {
-  /* XXX Not sure if this is right */
-  
-  EPHYR_LOG("mark");
-  
-  while (n--)
-    {
-      pdefs->red = 0;
-      pdefs->green = 0;
-      pdefs->blue = 0;
-      pdefs++;
+    /* XXX Not sure if this is right */
+
+    EPHYR_LOG("mark");
+
+    while (n--) {
+        pdefs->red = 0;
+        pdefs->green = 0;
+        pdefs->blue = 0;
+        pdefs++;
     }
 
 }
 
 void
-ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+ephyrPutColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
 {
-  int min, max, p;
-
-  /* XXX Not sure if this is right */
-
-  min = 256;
-  max = 0;
-  
-  while (n--)
-    {
-      p = pdefs->pixel;
-      if (p < min)
-	min = p;
-      if (p > max)
-	max = p;
-
-      hostx_set_cmap_entry(p, 		
-			   pdefs->red >> 8,
-			   pdefs->green >> 8,
-			   pdefs->blue >> 8);
-      pdefs++;
+    int min, max, p;
+
+    /* XXX Not sure if this is right */
+
+    min = 256;
+    max = 0;
+
+    while (n--) {
+        p = pdefs->pixel;
+        if (p < min)
+            min = p;
+        if (p > max)
+            max = p;
+
+        hostx_set_cmap_entry(p,
+                             pdefs->red >> 8,
+                             pdefs->green >> 8, pdefs->blue >> 8);
+        pdefs++;
     }
 }
 
 /* Mouse calls */
 
 static Status
-MouseInit (KdPointerInfo *pi)
+MouseInit(KdPointerInfo * pi)
 {
     pi->driverPrivate = (EphyrPointerPrivate *)
-                         calloc(sizeof(EphyrPointerPrivate), 1);
-    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
+        calloc(sizeof(EphyrPointerPrivate), 1);
+    ((EphyrPointerPrivate *) pi->driverPrivate)->enabled = FALSE;
     pi->nAxes = 3;
     pi->nButtons = 32;
     free(pi->name);
@@ -1084,23 +1042,23 @@ MouseInit (KdPointerInfo *pi)
 }
 
 static Status
-MouseEnable (KdPointerInfo *pi)
+MouseEnable(KdPointerInfo * pi)
 {
-    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = TRUE;
+    ((EphyrPointerPrivate *) pi->driverPrivate)->enabled = TRUE;
     return Success;
 }
 
 static void
-MouseDisable (KdPointerInfo *pi)
+MouseDisable(KdPointerInfo * pi)
 {
-    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
+    ((EphyrPointerPrivate *) pi->driverPrivate)->enabled = FALSE;
     return;
 }
 
 static void
-MouseFini (KdPointerInfo *pi)
+MouseFini(KdPointerInfo * pi)
 {
-    ephyrMouse = NULL; 
+    ephyrMouse = NULL;
     return;
 }
 
@@ -1116,55 +1074,54 @@ KdPointerDriver EphyrMouseDriver = {
 /* Keyboard */
 
 static Status
-EphyrKeyboardInit (KdKeyboardInfo *ki)
+EphyrKeyboardInit(KdKeyboardInfo * ki)
 {
-  ki->driverPrivate = (EphyrKbdPrivate *)
-                       calloc(sizeof(EphyrKbdPrivate), 1);
-  hostx_load_keymap();
-  if (!ephyrKeySyms.map) {
-      ErrorF("Couldn't load keymap from host\n");
-      return BadAlloc;
-  }
-  ki->minScanCode = ephyrKeySyms.minKeyCode;
-  ki->maxScanCode = ephyrKeySyms.maxKeyCode;
-  free(ki->name);
-  ki->name = strdup("Xephyr virtual keyboard");
-  ephyrKbd = ki;
-  return Success;
+    ki->driverPrivate = (EphyrKbdPrivate *)
+        calloc(sizeof(EphyrKbdPrivate), 1);
+    hostx_load_keymap();
+    if (!ephyrKeySyms.map) {
+        ErrorF("Couldn't load keymap from host\n");
+        return BadAlloc;
+    }
+    ki->minScanCode = ephyrKeySyms.minKeyCode;
+    ki->maxScanCode = ephyrKeySyms.maxKeyCode;
+    free(ki->name);
+    ki->name = strdup("Xephyr virtual keyboard");
+    ephyrKbd = ki;
+    return Success;
 }
 
 static Status
-EphyrKeyboardEnable (KdKeyboardInfo *ki)
+EphyrKeyboardEnable(KdKeyboardInfo * ki)
 {
-    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = TRUE;
+    ((EphyrKbdPrivate *) ki->driverPrivate)->enabled = TRUE;
 
     return Success;
 }
 
 static void
-EphyrKeyboardDisable (KdKeyboardInfo *ki)
+EphyrKeyboardDisable(KdKeyboardInfo * ki)
 {
-    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = FALSE;
+    ((EphyrKbdPrivate *) ki->driverPrivate)->enabled = FALSE;
 }
 
 static void
-EphyrKeyboardFini (KdKeyboardInfo *ki)
+EphyrKeyboardFini(KdKeyboardInfo * ki)
 {
     ephyrKbd = NULL;
     return;
 }
 
 static void
-EphyrKeyboardLeds (KdKeyboardInfo *ki, int leds)
+EphyrKeyboardLeds(KdKeyboardInfo * ki, int leds)
 {
 }
 
 static void
-EphyrKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
+EphyrKeyboardBell(KdKeyboardInfo * ki, int volume, int frequency, int duration)
 {
 }
 
-
 KdKeyboardDriver EphyrKeyboardDriver = {
     "ephyr",
     EphyrKeyboardInit,
diff --git a/hw/kdrive/ephyr/ephyr.h b/hw/kdrive/ephyr/ephyr.h
index 23848004c..be910c19e 100644
--- a/hw/kdrive/ephyr/ephyr.h
+++ b/hw/kdrive/ephyr/ephyr.h
@@ -30,7 +30,7 @@
 #include <signal.h>
 #include <libgen.h>
 
-#include "os.h"  		/* for OsSignal() */
+#include "os.h"                 /* for OsSignal() */
 #include "kdrive.h"
 #include "hostx.h"
 #include "exa.h"
@@ -42,8 +42,8 @@
 #include "damage.h"
 
 typedef struct _ephyrPriv {
-    CARD8	*base;
-    int		bytes_per_line;
+    CARD8 *base;
+    int bytes_per_line;
 } EphyrPriv;
 
 typedef struct _ephyrFakexaPriv {
@@ -61,9 +61,9 @@ typedef struct _ephyrFakexaPriv {
 } EphyrFakexaPriv;
 
 typedef struct _ephyrScrPriv {
-    Rotation	randr;
-    Bool	shadow;
-    DamagePtr   pDamage;
+    Rotation randr;
+    Bool shadow;
+    DamagePtr pDamage;
     EphyrFakexaPriv *fakexa;
 } EphyrScrPriv;
 
@@ -74,130 +74,125 @@ extern KdPointerInfo *ephyrMouse;
 extern miPointerScreenFuncRec ephyrPointerScreenFuncs;
 
 Bool
-ephyrInitialize (KdCardInfo *card, EphyrPriv *priv);
+ ephyrInitialize(KdCardInfo * card, EphyrPriv * priv);
 
 Bool
-ephyrCardInit (KdCardInfo *card);
+ ephyrCardInit(KdCardInfo * card);
 
 Bool
-ephyrScreenInit (KdScreenInfo *screen);
+ ephyrScreenInit(KdScreenInfo * screen);
 
 Bool
-ephyrScreenInitialize (KdScreenInfo *screen, EphyrScrPriv *scrpriv);
-    
+ ephyrScreenInitialize(KdScreenInfo * screen, EphyrScrPriv * scrpriv);
+
 Bool
-ephyrInitScreen (ScreenPtr pScreen);
+ ephyrInitScreen(ScreenPtr pScreen);
 
 Bool
-ephyrFinishInitScreen (ScreenPtr pScreen);
+ ephyrFinishInitScreen(ScreenPtr pScreen);
 
 Bool
-ephyrCreateResources (ScreenPtr pScreen);
+ ephyrCreateResources(ScreenPtr pScreen);
 
 void
-ephyrPreserve (KdCardInfo *card);
+ ephyrPreserve(KdCardInfo * card);
 
 Bool
-ephyrEnable (ScreenPtr pScreen);
+ ephyrEnable(ScreenPtr pScreen);
 
 Bool
-ephyrDPMS (ScreenPtr pScreen, int mode);
+ ephyrDPMS(ScreenPtr pScreen, int mode);
 
 void
-ephyrDisable (ScreenPtr pScreen);
+ ephyrDisable(ScreenPtr pScreen);
 
 void
-ephyrRestore (KdCardInfo *card);
+ ephyrRestore(KdCardInfo * card);
 
 void
-ephyrScreenFini (KdScreenInfo *screen);
+ ephyrScreenFini(KdScreenInfo * screen);
 
 void
-ephyrCardFini (KdCardInfo *card);
+ ephyrCardFini(KdCardInfo * card);
 
 void
-ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+ ephyrGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
 
 void
-ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+ ephyrPutColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
 
 Bool
-ephyrMapFramebuffer (KdScreenInfo *screen);
+ ephyrMapFramebuffer(KdScreenInfo * screen);
 
-void *
-ephyrWindowLinear (ScreenPtr	pScreen,
-		   CARD32	row,
-		   CARD32	offset,
-		   int		mode,
-		   CARD32	*size,
-		   void		*closure);
+void *ephyrWindowLinear(ScreenPtr pScreen,
+                        CARD32 row,
+                        CARD32 offset, int mode, CARD32 *size, void *closure);
 
 void
-ephyrSetScreenSizes (ScreenPtr pScreen);
+ ephyrSetScreenSizes(ScreenPtr pScreen);
 
 Bool
-ephyrUnmapFramebuffer (KdScreenInfo *screen);
+ ephyrUnmapFramebuffer(KdScreenInfo * screen);
 
 void
-ephyrUnsetInternalDamage (ScreenPtr pScreen);
+ ephyrUnsetInternalDamage(ScreenPtr pScreen);
 
 Bool
-ephyrSetInternalDamage (ScreenPtr pScreen);
+ ephyrSetInternalDamage(ScreenPtr pScreen);
 
 Bool
-ephyrCreateColormap (ColormapPtr pmap);
+ ephyrCreateColormap(ColormapPtr pmap);
 
 void
-ephyrPoll(void);
-    
+ ephyrPoll(void);
+
 #ifdef RANDR
 Bool
-ephyrRandRGetInfo (ScreenPtr pScreen, Rotation *rotations);
+ ephyrRandRGetInfo(ScreenPtr pScreen, Rotation * rotations);
 
 Bool
-ephyrRandRSetConfig (ScreenPtr		pScreen,
-		     Rotation		randr,
-		     int		rate,
-		     RRScreenSizePtr	pSize);
+
+ephyrRandRSetConfig(ScreenPtr pScreen,
+                    Rotation randr, int rate, RRScreenSizePtr pSize);
 Bool
-ephyrRandRInit (ScreenPtr pScreen);
+ ephyrRandRInit(ScreenPtr pScreen);
 
-void 
-ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf);
+void
+ ephyrShadowUpdate(ScreenPtr pScreen, shadowBufPtr pBuf);
 
 #endif
 
 void
-ephyrUpdateModifierState(unsigned int state);
+ ephyrUpdateModifierState(unsigned int state);
 
 extern KdPointerDriver EphyrMouseDriver;
 
-extern KdKeyboardDriver	EphyrKeyboardDriver;
+extern KdKeyboardDriver EphyrKeyboardDriver;
 
-extern KdOsFuncs   EphyrOsFuncs;
+extern KdOsFuncs EphyrOsFuncs;
 
 extern Bool ephyrCursorInit(ScreenPtr pScreen);
 
 extern void ephyrCursorEnable(ScreenPtr pScreen);
 
-extern int ephyrBufferHeight(KdScreenInfo *screen);
+extern int ephyrBufferHeight(KdScreenInfo * screen);
 
 /* ephyr_draw.c */
 
 Bool
-ephyrDrawInit(ScreenPtr pScreen);
+ ephyrDrawInit(ScreenPtr pScreen);
 
 void
-ephyrDrawEnable(ScreenPtr pScreen);
+ ephyrDrawEnable(ScreenPtr pScreen);
 
 void
-ephyrDrawDisable(ScreenPtr pScreen);
+ ephyrDrawDisable(ScreenPtr pScreen);
 
 void
-ephyrDrawFini(ScreenPtr pScreen);
+ ephyrDrawFini(ScreenPtr pScreen);
 
 /*ephyvideo.c*/
 
-Bool ephyrInitVideo(ScreenPtr pScreen) ;
+Bool ephyrInitVideo(ScreenPtr pScreen);
 
 #endif
diff --git a/hw/kdrive/ephyr/ephyr_draw.c b/hw/kdrive/ephyr/ephyr_draw.c
index cf5f55394..5b8a1d504 100644
--- a/hw/kdrive/ephyr/ephyr_draw.c
+++ b/hw/kdrive/ephyr/ephyr_draw.c
@@ -64,7 +64,7 @@ ephyrPreparePipelinedAccess(PixmapPtr pPix, int index)
     fakexa->saved_ptrs[index] = pPix->devPrivate.ptr;
 
     if (pPix->devPrivate.ptr != NULL)
-	return;
+        return;
 
     pPix->devPrivate.ptr = fakexa->exa->memoryBase + exaGetPixmapOffset(pPix);
 }
@@ -93,6 +93,7 @@ static Bool
 ephyrPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg)
 {
     ScreenPtr pScreen = pPix->drawable.pScreen;
+
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     EphyrScrPriv *scrpriv = screen->driver;
@@ -107,7 +108,8 @@ ephyrPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg)
     tmpval[0].val = alu;
     tmpval[1].val = pm;
     tmpval[2].val = fg;
-    ChangeGC(NullClient, fakexa->pGC, GCFunction | GCPlaneMask | GCForeground, tmpval);
+    ChangeGC(NullClient, fakexa->pGC, GCFunction | GCPlaneMask | GCForeground,
+             tmpval);
 
     ValidateGC(&pPix->drawable, fakexa->pGC);
 
@@ -123,6 +125,7 @@ static void
 ephyrSolid(PixmapPtr pPix, int x1, int y1, int x2, int y2)
 {
     ScreenPtr pScreen = pPix->drawable.pScreen;
+
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     EphyrScrPriv *scrpriv = screen->driver;
@@ -138,6 +141,7 @@ static void
 ephyrDoneSolid(PixmapPtr pPix)
 {
     ScreenPtr pScreen = pPix->drawable.pScreen;
+
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     EphyrScrPriv *scrpriv = screen->driver;
@@ -154,9 +158,10 @@ ephyrDoneSolid(PixmapPtr pPix)
  */
 static Bool
 ephyrPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int dx, int dy, int alu,
-		 Pixel pm)
+                 Pixel pm)
 {
     ScreenPtr pScreen = pDst->drawable.pScreen;
+
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     EphyrScrPriv *scrpriv = screen->driver;
@@ -172,7 +177,7 @@ ephyrPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int dx, int dy, int alu,
 
     tmpval[0].val = alu;
     tmpval[1].val = pm;
-    ChangeGC (NullClient, fakexa->pGC, GCFunction | GCPlaneMask, tmpval);
+    ChangeGC(NullClient, fakexa->pGC, GCFunction | GCPlaneMask, tmpval);
 
     ValidateGC(&pDst->drawable, fakexa->pGC);
 
@@ -188,13 +193,14 @@ static void
 ephyrCopy(PixmapPtr pDst, int srcX, int srcY, int dstX, int dstY, int w, int h)
 {
     ScreenPtr pScreen = pDst->drawable.pScreen;
+
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     EphyrScrPriv *scrpriv = screen->driver;
     EphyrFakexaPriv *fakexa = scrpriv->fakexa;
 
     fbCopyArea(&fakexa->pSrc->drawable, &fakexa->pDst->drawable, fakexa->pGC,
-	       srcX, srcY, w, h, dstX, dstY);
+               srcX, srcY, w, h, dstX, dstY);
 }
 
 /**
@@ -204,12 +210,13 @@ static void
 ephyrDoneCopy(PixmapPtr pDst)
 {
     ScreenPtr pScreen = pDst->drawable.pScreen;
+
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     EphyrScrPriv *scrpriv = screen->driver;
     EphyrFakexaPriv *fakexa = scrpriv->fakexa;
 
-    FreeScratchGC (fakexa->pGC);
+    FreeScratchGC(fakexa->pGC);
 
     ephyrFinishPipelinedAccess(fakexa->pSrc, EXA_PREPARE_SRC);
     ephyrFinishPipelinedAccess(fakexa->pDst, EXA_PREPARE_DEST);
@@ -222,13 +229,13 @@ ephyrDoneCopy(PixmapPtr pDst)
  */
 static Bool
 ephyrCheckComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
-		    PicturePtr pDstPicture)
+                    PicturePtr pDstPicture)
 {
     /* Exercise the component alpha helper, so fail on this case like a normal
      * driver
      */
     if (pMaskPicture && pMaskPicture->componentAlpha && op == PictOpOver)
-	return FALSE;
+        return FALSE;
 
     return TRUE;
 }
@@ -238,8 +245,8 @@ ephyrCheckComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
  */
 static Bool
 ephyrPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
-		      PicturePtr pDstPicture, PixmapPtr pSrc, PixmapPtr pMask,
-		      PixmapPtr pDst)
+                      PicturePtr pDstPicture, PixmapPtr pSrc, PixmapPtr pMask,
+                      PixmapPtr pDst)
 {
     KdScreenPriv(pDst->drawable.pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
@@ -249,7 +256,7 @@ ephyrPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
     ephyrPreparePipelinedAccess(pDst, EXA_PREPARE_DEST);
     ephyrPreparePipelinedAccess(pSrc, EXA_PREPARE_SRC);
     if (pMask != NULL)
-	ephyrPreparePipelinedAccess(pMask, EXA_PREPARE_MASK);
+        ephyrPreparePipelinedAccess(pMask, EXA_PREPARE_MASK);
 
     fakexa->op = op;
     fakexa->pSrcPicture = pSrcPicture;
@@ -269,7 +276,7 @@ ephyrPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
  */
 static void
 ephyrComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY,
-	       int dstX, int dstY, int w, int h)
+               int dstX, int dstY, int w, int h)
 {
     KdScreenPriv(pDst->drawable.pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
@@ -277,8 +284,8 @@ ephyrComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY,
     EphyrFakexaPriv *fakexa = scrpriv->fakexa;
 
     fbComposite(fakexa->op, fakexa->pSrcPicture, fakexa->pMaskPicture,
-		fakexa->pDstPicture, srcX, srcY, maskX, maskY, dstX, dstY,
-		w, h);
+                fakexa->pDstPicture, srcX, srcY, maskX, maskY, dstX, dstY,
+                w, h);
 }
 
 static void
@@ -290,7 +297,7 @@ ephyrDoneComposite(PixmapPtr pDst)
     EphyrFakexaPriv *fakexa = scrpriv->fakexa;
 
     if (fakexa->pMask != NULL)
-	ephyrFinishPipelinedAccess(fakexa->pMask, EXA_PREPARE_MASK);
+        ephyrFinishPipelinedAccess(fakexa->pMask, EXA_PREPARE_MASK);
     ephyrFinishPipelinedAccess(fakexa->pSrc, EXA_PREPARE_SRC);
     ephyrFinishPipelinedAccess(fakexa->pDst, EXA_PREPARE_DEST);
 }
@@ -300,7 +307,7 @@ ephyrDoneComposite(PixmapPtr pDst)
  */
 static Bool
 ephyrDownloadFromScreen(PixmapPtr pSrc, int x, int y, int w, int h, char *dst,
-			int dst_pitch)
+                        int dst_pitch)
 {
     KdScreenPriv(pSrc->drawable.pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
@@ -310,7 +317,7 @@ ephyrDownloadFromScreen(PixmapPtr pSrc, int x, int y, int w, int h, char *dst,
     int src_pitch, cpp;
 
     if (pSrc->drawable.bitsPerPixel < 8)
-	return FALSE;
+        return FALSE;
 
     ephyrPreparePipelinedAccess(pSrc, EXA_PREPARE_SRC);
 
@@ -320,9 +327,9 @@ ephyrDownloadFromScreen(PixmapPtr pSrc, int x, int y, int w, int h, char *dst,
     src += y * src_pitch + x * cpp;
 
     for (; h > 0; h--) {
-	memcpy(dst, src, w * cpp);
-	dst += dst_pitch;
-	src += src_pitch;
+        memcpy(dst, src, w * cpp);
+        dst += dst_pitch;
+        src += src_pitch;
     }
 
     exaMarkSync(pSrc->drawable.pScreen);
@@ -337,7 +344,7 @@ ephyrDownloadFromScreen(PixmapPtr pSrc, int x, int y, int w, int h, char *dst,
  */
 static Bool
 ephyrUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h, char *src,
-		    int src_pitch)
+                    int src_pitch)
 {
     KdScreenPriv(pDst->drawable.pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
@@ -347,7 +354,7 @@ ephyrUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h, char *src,
     int dst_pitch, cpp;
 
     if (pDst->drawable.bitsPerPixel < 8)
-	return FALSE;
+        return FALSE;
 
     ephyrPreparePipelinedAccess(pDst, EXA_PREPARE_DEST);
 
@@ -357,9 +364,9 @@ ephyrUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h, char *src,
     dst += y * dst_pitch + x * cpp;
 
     for (; h > 0; h--) {
-	memcpy(dst, src, w * cpp);
-	dst += dst_pitch;
-	src += src_pitch;
+        memcpy(dst, src, w * cpp);
+        dst += dst_pitch;
+        src += src_pitch;
     }
 
     exaMarkSync(pDst->drawable.pScreen);
@@ -433,12 +440,12 @@ ephyrDrawInit(ScreenPtr pScreen)
 
     fakexa = calloc(1, sizeof(*fakexa));
     if (fakexa == NULL)
-	return FALSE;
+        return FALSE;
 
     fakexa->exa = exaDriverAlloc();
     if (fakexa->exa == NULL) {
-	free(fakexa);
-	return FALSE;
+        free(fakexa);
+        return FALSE;
     }
 
     fakexa->exa->memoryBase = (CARD8 *) (priv->base);
@@ -482,12 +489,13 @@ ephyrDrawInit(ScreenPtr pScreen)
 
     success = exaDriverInit(pScreen, fakexa->exa);
     if (success) {
-	ErrorF("Initialized fake EXA acceleration\n");
-	scrpriv->fakexa = fakexa;
-    } else {
-	ErrorF("Failed to initialize EXA\n");
-	free(fakexa->exa);
-	free(fakexa);
+        ErrorF("Initialized fake EXA acceleration\n");
+        scrpriv->fakexa = fakexa;
+    }
+    else {
+        ErrorF("Failed to initialize EXA\n");
+        free(fakexa->exa);
+        free(fakexa);
     }
 
     return success;
diff --git a/hw/kdrive/ephyr/ephyrdri.c b/hw/kdrive/ephyr/ephyrdri.c
index 932e46886..50554364c 100644
--- a/hw/kdrive/ephyr/ephyrdri.c
+++ b/hw/kdrive/ephyr/ephyrdri.c
@@ -43,244 +43,228 @@
 #ifndef TRUE
 #define TRUE 1
 #endif /*TRUE*/
-
 #ifndef FALSE
 #define FALSE 0
 #endif /*FALSE*/
-
-Bool
-ephyrDRIQueryDirectRenderingCapable (int a_screen, Bool *a_is_capable)
+    Bool
+ephyrDRIQueryDirectRenderingCapable(int a_screen, Bool *a_is_capable)
 {
-    Display *dpy=hostx_get_display () ;
-    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = FALSE;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_is_capable, FALSE) ;
-    EPHYR_LOG ("enter\n") ;
-    is_ok = XF86DRIQueryDirectRenderingCapable (dpy, DefaultScreen (dpy),
-                                                a_is_capable) ;
-    EPHYR_LOG ("leave. is_capable:%d, is_ok=%d\n", *a_is_capable, is_ok) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_is_capable, FALSE);
+    EPHYR_LOG("enter\n");
+    is_ok = XF86DRIQueryDirectRenderingCapable(dpy, DefaultScreen(dpy),
+                                               a_is_capable);
+    EPHYR_LOG("leave. is_capable:%d, is_ok=%d\n", *a_is_capable, is_ok);
 
-    return is_ok ;
+    return is_ok;
 }
 
 Bool
-ephyrDRIOpenConnection (int a_screen,
-                        drm_handle_t *a_sarea,
-                        char **a_bus_id_string)
+ephyrDRIOpenConnection(int a_screen,
+                       drm_handle_t * a_sarea, char **a_bus_id_string)
 {
-    Display *dpy = hostx_get_display () ;
-    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = FALSE;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_bus_id_string, FALSE) ;
-    EPHYR_LOG ("enter. screen:%d\n", a_screen) ;
-    is_ok = XF86DRIOpenConnection (dpy, DefaultScreen (dpy),
-                                   a_sarea,
-                                   a_bus_id_string) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_bus_id_string, FALSE);
+    EPHYR_LOG("enter. screen:%d\n", a_screen);
+    is_ok = XF86DRIOpenConnection(dpy, DefaultScreen(dpy),
+                                  a_sarea, a_bus_id_string);
     if (*a_bus_id_string) {
-        EPHYR_LOG ("leave. bus_id_string:%s, is_ok:%d\n",
-                   *a_bus_id_string, is_ok) ;
-    } else {
-        EPHYR_LOG ("leave. bus_id_string:null, is_ok:%d\n",
-                   is_ok) ;
+        EPHYR_LOG("leave. bus_id_string:%s, is_ok:%d\n",
+                  *a_bus_id_string, is_ok);
+    }
+    else {
+        EPHYR_LOG("leave. bus_id_string:null, is_ok:%d\n", is_ok);
     }
-    return is_ok ;
+    return is_ok;
 }
 
 Bool
-ephyrDRIAuthConnection (int a_screen, drm_magic_t a_magic)
+ephyrDRIAuthConnection(int a_screen, drm_magic_t a_magic)
 {
-    Display *dpy = hostx_get_display () ;
-    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = FALSE;
 
-    EPHYR_LOG ("enter\n") ;
-    is_ok = XF86DRIAuthConnection (dpy, DefaultScreen (dpy), a_magic) ;
-    EPHYR_LOG ("leave. is_ok:%d\n", is_ok) ;
-    return is_ok ;
+    EPHYR_LOG("enter\n");
+    is_ok = XF86DRIAuthConnection(dpy, DefaultScreen(dpy), a_magic);
+    EPHYR_LOG("leave. is_ok:%d\n", is_ok);
+    return is_ok;
 }
 
 Bool
-ephyrDRICloseConnection (int a_screen)
+ephyrDRICloseConnection(int a_screen)
 {
-    Display *dpy = hostx_get_display () ;
-    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = FALSE;
 
-    EPHYR_LOG ("enter\n") ;
-    is_ok = XF86DRICloseConnection (dpy, DefaultScreen (dpy)) ;
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    EPHYR_LOG("enter\n");
+    is_ok = XF86DRICloseConnection(dpy, DefaultScreen(dpy));
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 Bool
-ephyrDRIGetClientDriverName (int a_screen,
-                             int *a_ddx_driver_major_version,
-                             int *a_ddx_driver_minor_version,
-                             int *a_ddx_driver_patch_version,
-                             char ** a_client_driver_name)
+ephyrDRIGetClientDriverName(int a_screen,
+                            int *a_ddx_driver_major_version,
+                            int *a_ddx_driver_minor_version,
+                            int *a_ddx_driver_patch_version,
+                            char **a_client_driver_name)
 {
-    Display *dpy = hostx_get_display () ;
-    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = FALSE;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_ddx_driver_major_version
-                              && a_ddx_driver_minor_version
-                              && a_ddx_driver_patch_version
-                              && a_client_driver_name,
-                              FALSE);
-    EPHYR_LOG ("enter\n") ;
-    is_ok = XF86DRIGetClientDriverName (dpy, DefaultScreen (dpy),
-                                        a_ddx_driver_major_version,
-                                        a_ddx_driver_minor_version,
-                                        a_ddx_driver_patch_version,
-                                        a_client_driver_name) ;
-    EPHYR_LOG ("major:%d, minor:%d, patch:%d, name:%s\n",
-                *a_ddx_driver_major_version,
-                *a_ddx_driver_minor_version,
-                *a_ddx_driver_patch_version,
-                *a_client_driver_name) ;
-    EPHYR_LOG ("leave:%d\n", is_ok) ;
-    return is_ok ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_ddx_driver_major_version
+                             && a_ddx_driver_minor_version
+                             && a_ddx_driver_patch_version
+                             && a_client_driver_name, FALSE);
+    EPHYR_LOG("enter\n");
+    is_ok = XF86DRIGetClientDriverName(dpy, DefaultScreen(dpy),
+                                       a_ddx_driver_major_version,
+                                       a_ddx_driver_minor_version,
+                                       a_ddx_driver_patch_version,
+                                       a_client_driver_name);
+    EPHYR_LOG("major:%d, minor:%d, patch:%d, name:%s\n",
+              *a_ddx_driver_major_version,
+              *a_ddx_driver_minor_version,
+              *a_ddx_driver_patch_version, *a_client_driver_name);
+    EPHYR_LOG("leave:%d\n", is_ok);
+    return is_ok;
 }
 
 Bool
-ephyrDRICreateContext (int a_screen,
-                       int a_visual_id,
-                       XID *a_returned_ctxt_id,
-                       drm_context_t *a_hw_ctxt)
+ephyrDRICreateContext(int a_screen,
+                      int a_visual_id,
+                      XID *a_returned_ctxt_id, drm_context_t * a_hw_ctxt)
 {
-    Display *dpy = hostx_get_display () ;
-    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = FALSE;
     Visual v;
 
-    EPHYR_LOG ("enter. screen:%d, visual:%d\n", a_screen, a_visual_id) ;
-    memset (&v, 0, sizeof (v)) ;
-    v.visualid = a_visual_id ;
-    is_ok = XF86DRICreateContext (dpy,
-                                  DefaultScreen (dpy),
-                                  &v,
-                                  a_returned_ctxt_id,
-                                  a_hw_ctxt) ;
-    EPHYR_LOG ("leave:%d\n", is_ok) ;
-    return is_ok ;
+    EPHYR_LOG("enter. screen:%d, visual:%d\n", a_screen, a_visual_id);
+    memset(&v, 0, sizeof(v));
+    v.visualid = a_visual_id;
+    is_ok = XF86DRICreateContext(dpy,
+                                 DefaultScreen(dpy),
+                                 &v, a_returned_ctxt_id, a_hw_ctxt);
+    EPHYR_LOG("leave:%d\n", is_ok);
+    return is_ok;
 }
 
 Bool
-ephyrDRIDestroyContext (int a_screen,
-                        int a_context_id)
+ephyrDRIDestroyContext(int a_screen, int a_context_id)
 {
-    Display *dpy = hostx_get_display () ;
-    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = FALSE;
 
-    EPHYR_LOG ("enter\n") ;
-    is_ok = XF86DRIDestroyContext (dpy, DefaultScreen (dpy), a_context_id) ;
-    EPHYR_LOG ("leave:%d\n", is_ok) ;
-    return is_ok ;
+    EPHYR_LOG("enter\n");
+    is_ok = XF86DRIDestroyContext(dpy, DefaultScreen(dpy), a_context_id);
+    EPHYR_LOG("leave:%d\n", is_ok);
+    return is_ok;
 }
 
 Bool
-ephyrDRICreateDrawable (int a_screen,
-                        int a_drawable,
-                        drm_drawable_t *a_hw_drawable)
+ephyrDRICreateDrawable(int a_screen,
+                       int a_drawable, drm_drawable_t * a_hw_drawable)
 {
-    Bool is_ok=FALSE;
-    Display *dpy=hostx_get_display () ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_LOG ("enter\n") ;
-    is_ok = XF86DRICreateDrawable (dpy, DefaultScreen (dpy),
-                                   a_drawable, a_hw_drawable) ;
-    EPHYR_LOG ("leave. is_ok:%d\n", is_ok) ;
-    return is_ok ;
+    EPHYR_LOG("enter\n");
+    is_ok = XF86DRICreateDrawable(dpy, DefaultScreen(dpy),
+                                  a_drawable, a_hw_drawable);
+    EPHYR_LOG("leave. is_ok:%d\n", is_ok);
+    return is_ok;
 }
 
 Bool
-ephyrDRIDestroyDrawable (int a_screen, int a_drawable)
+ephyrDRIDestroyDrawable(int a_screen, int a_drawable)
 {
-    EPHYR_LOG ("enter\n") ;
-    EPHYR_LOG_ERROR ("not implemented yet\n") ;
-    EPHYR_LOG ("leave\n") ;
-    return FALSE ;
+    EPHYR_LOG("enter\n");
+    EPHYR_LOG_ERROR("not implemented yet\n");
+    EPHYR_LOG("leave\n");
+    return FALSE;
 }
 
 Bool
-ephyrDRIGetDrawableInfo (int a_screen,
-                         int a_drawable,
-                         unsigned int *a_index,
-                         unsigned int *a_stamp,
-                         int *a_x,
-                         int *a_y,
-                         int *a_w,
-                         int *a_h,
-                         int *a_num_clip_rects,
-                         drm_clip_rect_t **a_clip_rects,
-                         int *a_back_x,
-                         int *a_back_y,
-                         int *a_num_back_clip_rects,
-                         drm_clip_rect_t **a_back_clip_rects)
+ephyrDRIGetDrawableInfo(int a_screen,
+                        int a_drawable,
+                        unsigned int *a_index,
+                        unsigned int *a_stamp,
+                        int *a_x,
+                        int *a_y,
+                        int *a_w,
+                        int *a_h,
+                        int *a_num_clip_rects,
+                        drm_clip_rect_t ** a_clip_rects,
+                        int *a_back_x,
+                        int *a_back_y,
+                        int *a_num_back_clip_rects,
+                        drm_clip_rect_t ** a_back_clip_rects)
 {
-    Bool is_ok=FALSE;
-    Display *dpy=hostx_get_display ()  ;
-    EphyrHostWindowAttributes attrs ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    EphyrHostWindowAttributes attrs;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_x && a_y && a_w && a_h
-                              && a_num_clip_rects,
-                              FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_x && a_y && a_w && a_h
+                             && a_num_clip_rects, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
-    memset (&attrs, 0, sizeof (attrs)) ;
-    if (!hostx_get_window_attributes (a_drawable, &attrs)) {
-        EPHYR_LOG_ERROR ("failed to query host window attributes\n") ;
+    EPHYR_LOG("enter\n");
+    memset(&attrs, 0, sizeof(attrs));
+    if (!hostx_get_window_attributes(a_drawable, &attrs)) {
+        EPHYR_LOG_ERROR("failed to query host window attributes\n");
         goto out;
     }
-    if (!XF86DRIGetDrawableInfo (dpy, DefaultScreen (dpy), a_drawable,
-                                 a_index, a_stamp,
-                                 a_x, a_y,
-                                 a_w, a_h,
-                                 a_num_clip_rects, a_clip_rects,
-                                 a_back_x, a_back_y,
-                                 a_num_back_clip_rects,
-                                 a_back_clip_rects)) {
-        EPHYR_LOG_ERROR ("XF86DRIGetDrawableInfo ()\n") ;
-        goto out ;
+    if (!XF86DRIGetDrawableInfo(dpy, DefaultScreen(dpy), a_drawable,
+                                a_index, a_stamp,
+                                a_x, a_y,
+                                a_w, a_h,
+                                a_num_clip_rects, a_clip_rects,
+                                a_back_x, a_back_y,
+                                a_num_back_clip_rects, a_back_clip_rects)) {
+        EPHYR_LOG_ERROR("XF86DRIGetDrawableInfo ()\n");
+        goto out;
     }
-    EPHYR_LOG ("host x,y,w,h: (%d,%d,%d,%d)\n", *a_x, *a_y, *a_w, *a_h) ;
+    EPHYR_LOG("host x,y,w,h: (%d,%d,%d,%d)\n", *a_x, *a_y, *a_w, *a_h);
     if (*a_num_clip_rects) {
-        free (*a_back_clip_rects) ;
-        *a_back_clip_rects = calloc (*a_num_clip_rects,
-                                     sizeof (drm_clip_rect_t)) ;
-        memmove (*a_back_clip_rects,
-                 *a_clip_rects,
-                 *a_num_clip_rects * sizeof (drm_clip_rect_t)) ;
+        free(*a_back_clip_rects);
+        *a_back_clip_rects = calloc(*a_num_clip_rects, sizeof(drm_clip_rect_t));
+        memmove(*a_back_clip_rects,
+                *a_clip_rects, *a_num_clip_rects * sizeof(drm_clip_rect_t));
         *a_num_back_clip_rects = *a_num_clip_rects;
     }
-    EPHYR_LOG ("num back clip rects:%d, num clip rects:%d\n",
-               *a_num_clip_rects, *a_num_back_clip_rects) ;
-    *a_back_x = *a_x ;
-    *a_back_y = *a_y ;
+    EPHYR_LOG("num back clip rects:%d, num clip rects:%d\n",
+              *a_num_clip_rects, *a_num_back_clip_rects);
+    *a_back_x = *a_x;
+    *a_back_y = *a_y;
     *a_w = attrs.width;
     *a_h = attrs.height;
 
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("leave. index:%d, stamp:%d, x,y:(%d,%d), w,y:(%d,%d)\n",
-               *a_index, *a_stamp, *a_x, *a_y, *a_w, *a_h) ;
-    return is_ok ;
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("leave. index:%d, stamp:%d, x,y:(%d,%d), w,y:(%d,%d)\n",
+              *a_index, *a_stamp, *a_x, *a_y, *a_w, *a_h);
+    return is_ok;
 }
 
 Bool
-ephyrDRIGetDeviceInfo (int a_screen,
-                       drm_handle_t *a_frame_buffer,
-                       int *a_fb_origin,
-                       int *a_fb_size,
-                       int *a_fb_stride,
-                       int *a_dev_private_size,
-                       void **a_dev_private)
+ephyrDRIGetDeviceInfo(int a_screen,
+                      drm_handle_t * a_frame_buffer,
+                      int *a_fb_origin,
+                      int *a_fb_size,
+                      int *a_fb_stride,
+                      int *a_dev_private_size, void **a_dev_private)
 {
-    Bool is_ok = FALSE ;
-    Display *dpy = hostx_get_display () ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
-    EPHYR_LOG ("enter\n") ;
-    is_ok = XF86DRIGetDeviceInfo (dpy, DefaultScreen (dpy), a_frame_buffer,
-                                  a_fb_origin, a_fb_size, a_fb_stride,
-                                  a_dev_private_size, a_dev_private) ;
-    EPHYR_LOG ("leave:%d\n", is_ok) ;
-    return is_ok ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
+    EPHYR_LOG("enter\n");
+    is_ok = XF86DRIGetDeviceInfo(dpy, DefaultScreen(dpy), a_frame_buffer,
+                                 a_fb_origin, a_fb_size, a_fb_stride,
+                                 a_dev_private_size, a_dev_private);
+    EPHYR_LOG("leave:%d\n", is_ok);
+    return is_ok;
 }
diff --git a/hw/kdrive/ephyr/ephyrdri.h b/hw/kdrive/ephyr/ephyrdri.h
index 28ae8eae0..d28910f29 100644
--- a/hw/kdrive/ephyr/ephyrdri.h
+++ b/hw/kdrive/ephyr/ephyrdri.h
@@ -31,45 +31,40 @@
 
 #include <xf86drm.h>
 
-Bool ephyrDRIQueryDirectRenderingCapable (int a_screen, Bool *a_is_capable) ;
-Bool ephyrDRIOpenConnection (int screen, drm_handle_t *a_sarea, char **a_bus_id_string) ;
-Bool ephyrDRIAuthConnection (int a_screen, drm_magic_t a_magic) ;
-Bool ephyrDRICloseConnection (int a_screen) ;
-Bool ephyrDRIGetClientDriverName (int a_screen,
-                                  int *a_ddx_driver_major_version,
-                                  int *a_ddx_driver_minor_version,
-                                  int *a_ddx_driver_patch_version,
-                                  char ** a_client_driver_name) ;
-Bool ephyrDRICreateContext (int a_screen,
-                            int a_visual_id,
-                            XID *a_returned_ctx_id,
-                            drm_context_t *a_hw_ctx) ;
-Bool ephyrDRIDestroyContext (int a_screen,
-                             int a_context_id) ;
-Bool ephyrDRICreateDrawable (int a_screen,
-                             int a_drawable,
-                             drm_drawable_t *a_hw_drawable) ;
-Bool ephyrDRIDestroyDrawable (int a_screen, int a_drawable) ;
-Bool ephyrDRIGetDrawableInfo (int a_screen,
-                              int /*Drawable*/a_drawable,
-                              unsigned int *a_index,
-                              unsigned int *a_stamp,
-                              int *a_x,
-                              int *a_y,
-                              int *a_w,
-                              int *a_h,
-                              int *a_num_clip_rects,
-                              drm_clip_rect_t **a_clip_rects,
-                              int *a_back_x,
-                              int *a_back_y,
-                              int *num_back_clip_rects,
-                              drm_clip_rect_t **a_back_clip_rects) ;
-Bool ephyrDRIGetDeviceInfo (int a_screen,
-                            drm_handle_t *a_frame_buffer,
-                            int *a_fb_origin,
-                            int *a_fb_size,
-                            int *a_fb_stride,
-                            int *a_dev_private_size,
-                            void **a_dev_private) ;
+Bool ephyrDRIQueryDirectRenderingCapable(int a_screen, Bool *a_is_capable);
+Bool ephyrDRIOpenConnection(int screen, drm_handle_t * a_sarea,
+                            char **a_bus_id_string);
+Bool ephyrDRIAuthConnection(int a_screen, drm_magic_t a_magic);
+Bool ephyrDRICloseConnection(int a_screen);
+Bool ephyrDRIGetClientDriverName(int a_screen,
+                                 int *a_ddx_driver_major_version,
+                                 int *a_ddx_driver_minor_version,
+                                 int *a_ddx_driver_patch_version,
+                                 char **a_client_driver_name);
+Bool ephyrDRICreateContext(int a_screen,
+                           int a_visual_id,
+                           XID *a_returned_ctx_id, drm_context_t * a_hw_ctx);
+Bool ephyrDRIDestroyContext(int a_screen, int a_context_id);
+Bool ephyrDRICreateDrawable(int a_screen,
+                            int a_drawable, drm_drawable_t * a_hw_drawable);
+Bool ephyrDRIDestroyDrawable(int a_screen, int a_drawable);
+Bool ephyrDRIGetDrawableInfo(int a_screen, int /*Drawable */ a_drawable,
+                             unsigned int *a_index,
+                             unsigned int *a_stamp,
+                             int *a_x,
+                             int *a_y,
+                             int *a_w,
+                             int *a_h,
+                             int *a_num_clip_rects,
+                             drm_clip_rect_t ** a_clip_rects,
+                             int *a_back_x,
+                             int *a_back_y,
+                             int *num_back_clip_rects,
+                             drm_clip_rect_t ** a_back_clip_rects);
+Bool ephyrDRIGetDeviceInfo(int a_screen,
+                           drm_handle_t * a_frame_buffer,
+                           int *a_fb_origin,
+                           int *a_fb_size,
+                           int *a_fb_stride,
+                           int *a_dev_private_size, void **a_dev_private);
 #endif /*__EPHYRDRI_H__*/
-
diff --git a/hw/kdrive/ephyr/ephyrdriext.c b/hw/kdrive/ephyr/ephyrdriext.c
index 0741a7294..28486f516 100644
--- a/hw/kdrive/ephyr/ephyrdriext.c
+++ b/hw/kdrive/ephyr/ephyrdriext.c
@@ -59,43 +59,40 @@
 typedef struct {
     int foo;
 } EphyrDRIWindowPrivRec;
-typedef EphyrDRIWindowPrivRec* EphyrDRIWindowPrivPtr;
+typedef EphyrDRIWindowPrivRec *EphyrDRIWindowPrivPtr;
 
 typedef struct {
-    CreateWindowProcPtr CreateWindow ;
-    DestroyWindowProcPtr DestroyWindow ;
-    MoveWindowProcPtr MoveWindow ;
-    PositionWindowProcPtr PositionWindow ;
-    ClipNotifyProcPtr ClipNotify ;
+    CreateWindowProcPtr CreateWindow;
+    DestroyWindowProcPtr DestroyWindow;
+    MoveWindowProcPtr MoveWindow;
+    PositionWindowProcPtr PositionWindow;
+    ClipNotifyProcPtr ClipNotify;
 } EphyrDRIScreenPrivRec;
-typedef EphyrDRIScreenPrivRec* EphyrDRIScreenPrivPtr;
+typedef EphyrDRIScreenPrivRec *EphyrDRIScreenPrivPtr;
 
 static int DRIErrorBase;
 
+static Bool ephyrDRIScreenInit(ScreenPtr a_screen);
+static Bool ephyrDRICreateWindow(WindowPtr a_win);
+static Bool ephyrDRIDestroyWindow(WindowPtr a_win);
+static void ephyrDRIMoveWindow(WindowPtr a_win,
+                               int a_x, int a_y,
+                               WindowPtr a_siblings, VTKind a_kind);
+static Bool ephyrDRIPositionWindow(WindowPtr a_win, int x, int y);
+static void ephyrDRIClipNotify(WindowPtr a_win, int a_x, int a_y);
 
-
-static Bool ephyrDRIScreenInit (ScreenPtr a_screen) ;
-static Bool ephyrDRICreateWindow (WindowPtr a_win) ;
-static Bool ephyrDRIDestroyWindow (WindowPtr a_win) ;
-static void ephyrDRIMoveWindow (WindowPtr a_win,
-                                int a_x, int a_y,
-                                WindowPtr a_siblings,
-                                VTKind a_kind);
-static Bool ephyrDRIPositionWindow (WindowPtr a_win,
-                                    int x, int y) ;
-static void ephyrDRIClipNotify (WindowPtr a_win,
-                                int a_x, int a_y) ;
-
-static Bool EphyrMirrorHostVisuals (ScreenPtr a_screen) ;
-static Bool destroyHostPeerWindow (const WindowPtr a_win) ;
-static Bool findWindowPairFromLocal (WindowPtr a_local,
-                                     EphyrWindowPair **a_pair);
+static Bool EphyrMirrorHostVisuals(ScreenPtr a_screen);
+static Bool destroyHostPeerWindow(const WindowPtr a_win);
+static Bool findWindowPairFromLocal(WindowPtr a_local,
+                                    EphyrWindowPair ** a_pair);
 
 static unsigned char DRIReqCode = 0;
 
 static DevPrivateKeyRec ephyrDRIWindowKeyRec;
+
 #define ephyrDRIWindowKey (&ephyrDRIWindowKeyRec)
 static DevPrivateKeyRec ephyrDRIScreenKeyRec;
+
 #define ephyrDRIScreenKey (&ephyrDRIScreenKeyRec)
 
 #define GET_EPHYR_DRI_WINDOW_PRIV(win) ((EphyrDRIWindowPrivPtr) \
@@ -104,251 +101,239 @@ static DevPrivateKeyRec ephyrDRIScreenKeyRec;
     dixLookupPrivate(&(screen)->devPrivates, ephyrDRIScreenKey))
 
 static Bool
-ephyrDRIScreenInit (ScreenPtr a_screen)
+ephyrDRIScreenInit(ScreenPtr a_screen)
 {
-    Bool is_ok=FALSE ;
-    EphyrDRIScreenPrivPtr screen_priv=NULL ;
+    Bool is_ok = FALSE;
+    EphyrDRIScreenPrivPtr screen_priv = NULL;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_screen, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_screen, FALSE);
 
-    screen_priv=GET_EPHYR_DRI_SCREEN_PRIV (a_screen) ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen_priv, FALSE) ;
+    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV(a_screen);
+    EPHYR_RETURN_VAL_IF_FAIL(screen_priv, FALSE);
 
-    screen_priv->CreateWindow = a_screen->CreateWindow ;
-    screen_priv->DestroyWindow = a_screen->DestroyWindow ;
-    screen_priv->MoveWindow = a_screen->MoveWindow ;
-    screen_priv->PositionWindow = a_screen->PositionWindow ;
-    screen_priv->ClipNotify = a_screen->ClipNotify ;
+    screen_priv->CreateWindow = a_screen->CreateWindow;
+    screen_priv->DestroyWindow = a_screen->DestroyWindow;
+    screen_priv->MoveWindow = a_screen->MoveWindow;
+    screen_priv->PositionWindow = a_screen->PositionWindow;
+    screen_priv->ClipNotify = a_screen->ClipNotify;
 
-    a_screen->CreateWindow = ephyrDRICreateWindow ;
-    a_screen->DestroyWindow = ephyrDRIDestroyWindow ;
-    a_screen->MoveWindow = ephyrDRIMoveWindow ;
-    a_screen->PositionWindow = ephyrDRIPositionWindow ;
-    a_screen->ClipNotify = ephyrDRIClipNotify ;
+    a_screen->CreateWindow = ephyrDRICreateWindow;
+    a_screen->DestroyWindow = ephyrDRIDestroyWindow;
+    a_screen->MoveWindow = ephyrDRIMoveWindow;
+    a_screen->PositionWindow = ephyrDRIPositionWindow;
+    a_screen->ClipNotify = ephyrDRIClipNotify;
 
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-    return is_ok ;
+    return is_ok;
 }
 
 static Bool
-ephyrDRICreateWindow (WindowPtr a_win)
+ephyrDRICreateWindow(WindowPtr a_win)
 {
-    Bool is_ok=FALSE ;
-    ScreenPtr screen=NULL ;
-    EphyrDRIScreenPrivPtr screen_priv =NULL;
+    Bool is_ok = FALSE;
+    ScreenPtr screen = NULL;
+    EphyrDRIScreenPrivPtr screen_priv = NULL;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_win, FALSE) ;
-    screen = a_win->drawable.pScreen ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen, FALSE) ;
-    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV (screen) ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen_priv
-                              && screen_priv->CreateWindow,
-                              FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_win, FALSE);
+    screen = a_win->drawable.pScreen;
+    EPHYR_RETURN_VAL_IF_FAIL(screen, FALSE);
+    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV(screen);
+    EPHYR_RETURN_VAL_IF_FAIL(screen_priv && screen_priv->CreateWindow, FALSE);
 
-    EPHYR_LOG ("enter. win:%p\n", a_win) ;
+    EPHYR_LOG("enter. win:%p\n", a_win);
 
-    screen->CreateWindow = screen_priv->CreateWindow ;
-    is_ok = (*screen->CreateWindow) (a_win) ;
-    screen->CreateWindow = ephyrDRICreateWindow ;
+    screen->CreateWindow = screen_priv->CreateWindow;
+    is_ok = (*screen->CreateWindow) (a_win);
+    screen->CreateWindow = ephyrDRICreateWindow;
 
     if (is_ok) {
-	dixSetPrivate(&a_win->devPrivates, ephyrDRIWindowKey, NULL);
+        dixSetPrivate(&a_win->devPrivates, ephyrDRIWindowKey, NULL);
     }
-    return is_ok ;
+    return is_ok;
 }
 
 static Bool
-ephyrDRIDestroyWindow (WindowPtr a_win)
+ephyrDRIDestroyWindow(WindowPtr a_win)
 {
-    Bool is_ok=FALSE ;
-    ScreenPtr screen=NULL ;
-    EphyrDRIScreenPrivPtr screen_priv =NULL;
-
-    EPHYR_RETURN_VAL_IF_FAIL (a_win, FALSE) ;
-    screen = a_win->drawable.pScreen ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen, FALSE) ;
-    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV (screen) ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen_priv
-                              && screen_priv->DestroyWindow,
-                              FALSE) ;
-
-    screen->DestroyWindow = screen_priv->DestroyWindow ;
+    Bool is_ok = FALSE;
+    ScreenPtr screen = NULL;
+    EphyrDRIScreenPrivPtr screen_priv = NULL;
+
+    EPHYR_RETURN_VAL_IF_FAIL(a_win, FALSE);
+    screen = a_win->drawable.pScreen;
+    EPHYR_RETURN_VAL_IF_FAIL(screen, FALSE);
+    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV(screen);
+    EPHYR_RETURN_VAL_IF_FAIL(screen_priv && screen_priv->DestroyWindow, FALSE);
+
+    screen->DestroyWindow = screen_priv->DestroyWindow;
     if (screen->DestroyWindow) {
-        is_ok = (*screen->DestroyWindow) (a_win) ;
+        is_ok = (*screen->DestroyWindow) (a_win);
     }
-    screen->DestroyWindow = ephyrDRIDestroyWindow ;
+    screen->DestroyWindow = ephyrDRIDestroyWindow;
 
     if (is_ok) {
-        EphyrDRIWindowPrivPtr win_priv=GET_EPHYR_DRI_WINDOW_PRIV (a_win) ;
+        EphyrDRIWindowPrivPtr win_priv = GET_EPHYR_DRI_WINDOW_PRIV(a_win);
+
         if (win_priv) {
-            destroyHostPeerWindow (a_win) ;
-            free(win_priv) ;
-	    dixSetPrivate(&a_win->devPrivates, ephyrDRIWindowKey, NULL);
-            EPHYR_LOG ("destroyed the remote peer window\n") ;
+            destroyHostPeerWindow(a_win);
+            free(win_priv);
+            dixSetPrivate(&a_win->devPrivates, ephyrDRIWindowKey, NULL);
+            EPHYR_LOG("destroyed the remote peer window\n");
         }
     }
-    return is_ok ;
+    return is_ok;
 }
 
 static void
-ephyrDRIMoveWindow (WindowPtr a_win,
-                    int a_x, int a_y,
-                    WindowPtr a_siblings,
-                    VTKind a_kind)
+ephyrDRIMoveWindow(WindowPtr a_win,
+                   int a_x, int a_y, WindowPtr a_siblings, VTKind a_kind)
 {
-    Bool is_ok=FALSE ;
-    ScreenPtr screen=NULL ;
-    EphyrDRIScreenPrivPtr screen_priv =NULL;
-    EphyrDRIWindowPrivPtr win_priv=NULL ;
-    EphyrWindowPair *pair=NULL ;
+    Bool is_ok = FALSE;
+    ScreenPtr screen = NULL;
+    EphyrDRIScreenPrivPtr screen_priv = NULL;
+    EphyrDRIWindowPrivPtr win_priv = NULL;
+    EphyrWindowPair *pair = NULL;
     EphyrBox geo;
-    int x=0,y=0;/*coords relative to parent window*/
+    int x = 0, y = 0;           /*coords relative to parent window */
 
-    EPHYR_RETURN_IF_FAIL (a_win) ;
+    EPHYR_RETURN_IF_FAIL(a_win);
 
-    EPHYR_LOG ("enter\n") ;
-    screen = a_win->drawable.pScreen ;
-    EPHYR_RETURN_IF_FAIL (screen) ;
-    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV (screen) ;
-    EPHYR_RETURN_IF_FAIL (screen_priv
-                          && screen_priv->MoveWindow) ;
+    EPHYR_LOG("enter\n");
+    screen = a_win->drawable.pScreen;
+    EPHYR_RETURN_IF_FAIL(screen);
+    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV(screen);
+    EPHYR_RETURN_IF_FAIL(screen_priv && screen_priv->MoveWindow);
 
-    screen->MoveWindow = screen_priv->MoveWindow ;
+    screen->MoveWindow = screen_priv->MoveWindow;
     if (screen->MoveWindow) {
-        (*screen->MoveWindow) (a_win, a_x, a_y, a_siblings, a_kind) ;
+        (*screen->MoveWindow) (a_win, a_x, a_y, a_siblings, a_kind);
     }
-    screen->MoveWindow = ephyrDRIMoveWindow ;
+    screen->MoveWindow = ephyrDRIMoveWindow;
 
-    EPHYR_LOG ("window: %p\n", a_win) ;
+    EPHYR_LOG("window: %p\n", a_win);
     if (!a_win->parent) {
-        EPHYR_LOG ("cannot move root window\n") ;
-        is_ok = TRUE ;
-        goto out ;
+        EPHYR_LOG("cannot move root window\n");
+        is_ok = TRUE;
+        goto out;
     }
-    win_priv = GET_EPHYR_DRI_WINDOW_PRIV (a_win) ;
+    win_priv = GET_EPHYR_DRI_WINDOW_PRIV(a_win);
     if (!win_priv) {
-        EPHYR_LOG ("not a DRI peered window\n") ;
-        is_ok = TRUE ;
-        goto out ;
-    }
-    if (!findWindowPairFromLocal (a_win, &pair) || !pair) {
-        EPHYR_LOG_ERROR ("failed to get window pair\n") ;
-        goto out ;
-    }
-    /*compute position relative to parent window*/
-    x = a_win->drawable.x - a_win->parent->drawable.x ;
-    y = a_win->drawable.y - a_win->parent->drawable.y ;
-    /*set the geometry to pass to hostx_set_window_geometry*/
-    memset (&geo, 0, sizeof (geo)) ;
-    geo.x = x ;
-    geo.y = y ;
-    geo.width = a_win->drawable.width ;
-    geo.height = a_win->drawable.height ;
-    hostx_set_window_geometry (pair->remote, &geo) ;
-    is_ok = TRUE ;
-
-out:
-    EPHYR_LOG ("leave. is_ok:%d\n", is_ok) ;
-    /*do cleanup here*/
+        EPHYR_LOG("not a DRI peered window\n");
+        is_ok = TRUE;
+        goto out;
+    }
+    if (!findWindowPairFromLocal(a_win, &pair) || !pair) {
+        EPHYR_LOG_ERROR("failed to get window pair\n");
+        goto out;
+    }
+    /*compute position relative to parent window */
+    x = a_win->drawable.x - a_win->parent->drawable.x;
+    y = a_win->drawable.y - a_win->parent->drawable.y;
+    /*set the geometry to pass to hostx_set_window_geometry */
+    memset(&geo, 0, sizeof(geo));
+    geo.x = x;
+    geo.y = y;
+    geo.width = a_win->drawable.width;
+    geo.height = a_win->drawable.height;
+    hostx_set_window_geometry(pair->remote, &geo);
+    is_ok = TRUE;
+
+ out:
+    EPHYR_LOG("leave. is_ok:%d\n", is_ok);
+    /*do cleanup here */
 }
 
 static Bool
-ephyrDRIPositionWindow (WindowPtr a_win,
-                        int a_x, int a_y)
+ephyrDRIPositionWindow(WindowPtr a_win, int a_x, int a_y)
 {
-    Bool is_ok=FALSE ;
-    ScreenPtr screen=NULL ;
-    EphyrDRIScreenPrivPtr screen_priv =NULL;
-    EphyrDRIWindowPrivPtr win_priv=NULL ;
-    EphyrWindowPair *pair=NULL ;
+    Bool is_ok = FALSE;
+    ScreenPtr screen = NULL;
+    EphyrDRIScreenPrivPtr screen_priv = NULL;
+    EphyrDRIWindowPrivPtr win_priv = NULL;
+    EphyrWindowPair *pair = NULL;
     EphyrBox geo;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_win, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_win, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
-    screen = a_win->drawable.pScreen ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen, FALSE) ;
-    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV (screen) ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen_priv
-                              && screen_priv->PositionWindow,
-                              FALSE) ;
+    EPHYR_LOG("enter\n");
+    screen = a_win->drawable.pScreen;
+    EPHYR_RETURN_VAL_IF_FAIL(screen, FALSE);
+    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV(screen);
+    EPHYR_RETURN_VAL_IF_FAIL(screen_priv && screen_priv->PositionWindow, FALSE);
 
-    screen->PositionWindow = screen_priv->PositionWindow ;
+    screen->PositionWindow = screen_priv->PositionWindow;
     if (screen->PositionWindow) {
-        (*screen->PositionWindow) (a_win, a_x, a_y) ;
+        (*screen->PositionWindow) (a_win, a_x, a_y);
     }
-    screen->PositionWindow = ephyrDRIPositionWindow ;
+    screen->PositionWindow = ephyrDRIPositionWindow;
 
-    EPHYR_LOG ("window: %p\n", a_win) ;
-    win_priv = GET_EPHYR_DRI_WINDOW_PRIV (a_win) ;
+    EPHYR_LOG("window: %p\n", a_win);
+    win_priv = GET_EPHYR_DRI_WINDOW_PRIV(a_win);
     if (!win_priv) {
-        EPHYR_LOG ("not a DRI peered window\n") ;
-        is_ok = TRUE ;
-        goto out ;
-    }
-    if (!findWindowPairFromLocal (a_win, &pair) || !pair) {
-        EPHYR_LOG_ERROR ("failed to get window pair\n") ;
-        goto out ;
-    }
-    /*set the geometry to pass to hostx_set_window_geometry*/
-    memset (&geo, 0, sizeof (geo)) ;
-    geo.x = a_x ;
-    geo.y = a_y ;
-    geo.width = a_win->drawable.width ;
-    geo.height = a_win->drawable.height ;
-    hostx_set_window_geometry (pair->remote, &geo) ;
-    is_ok = TRUE ;
-
-out:
-    EPHYR_LOG ("leave. is_ok:%d\n", is_ok) ;
-    /*do cleanup here*/
-    return is_ok ;
+        EPHYR_LOG("not a DRI peered window\n");
+        is_ok = TRUE;
+        goto out;
+    }
+    if (!findWindowPairFromLocal(a_win, &pair) || !pair) {
+        EPHYR_LOG_ERROR("failed to get window pair\n");
+        goto out;
+    }
+    /*set the geometry to pass to hostx_set_window_geometry */
+    memset(&geo, 0, sizeof(geo));
+    geo.x = a_x;
+    geo.y = a_y;
+    geo.width = a_win->drawable.width;
+    geo.height = a_win->drawable.height;
+    hostx_set_window_geometry(pair->remote, &geo);
+    is_ok = TRUE;
+
+ out:
+    EPHYR_LOG("leave. is_ok:%d\n", is_ok);
+    /*do cleanup here */
+    return is_ok;
 }
 
 static void
-ephyrDRIClipNotify (WindowPtr a_win,
-                    int a_x, int a_y)
+ephyrDRIClipNotify(WindowPtr a_win, int a_x, int a_y)
 {
-    Bool is_ok=FALSE ;
-    ScreenPtr screen=NULL ;
-    EphyrDRIScreenPrivPtr screen_priv =NULL;
-    EphyrDRIWindowPrivPtr win_priv=NULL ;
-    EphyrWindowPair *pair=NULL ;
-    EphyrRect *rects=NULL;
-    int i=0 ;
-
-    EPHYR_RETURN_IF_FAIL (a_win) ;
-
-    EPHYR_LOG ("enter\n") ;
-    screen = a_win->drawable.pScreen ;
-    EPHYR_RETURN_IF_FAIL (screen) ;
-    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV (screen) ;
-    EPHYR_RETURN_IF_FAIL (screen_priv && screen_priv->ClipNotify) ;
-
-    screen->ClipNotify = screen_priv->ClipNotify ;
+    Bool is_ok = FALSE;
+    ScreenPtr screen = NULL;
+    EphyrDRIScreenPrivPtr screen_priv = NULL;
+    EphyrDRIWindowPrivPtr win_priv = NULL;
+    EphyrWindowPair *pair = NULL;
+    EphyrRect *rects = NULL;
+    int i = 0;
+
+    EPHYR_RETURN_IF_FAIL(a_win);
+
+    EPHYR_LOG("enter\n");
+    screen = a_win->drawable.pScreen;
+    EPHYR_RETURN_IF_FAIL(screen);
+    screen_priv = GET_EPHYR_DRI_SCREEN_PRIV(screen);
+    EPHYR_RETURN_IF_FAIL(screen_priv && screen_priv->ClipNotify);
+
+    screen->ClipNotify = screen_priv->ClipNotify;
     if (screen->ClipNotify) {
-        (*screen->ClipNotify) (a_win, a_x, a_y) ;
+        (*screen->ClipNotify) (a_win, a_x, a_y);
     }
-    screen->ClipNotify = ephyrDRIClipNotify ;
+    screen->ClipNotify = ephyrDRIClipNotify;
 
-    EPHYR_LOG ("window: %p\n", a_win) ;
-    win_priv = GET_EPHYR_DRI_WINDOW_PRIV (a_win) ;
+    EPHYR_LOG("window: %p\n", a_win);
+    win_priv = GET_EPHYR_DRI_WINDOW_PRIV(a_win);
     if (!win_priv) {
-        EPHYR_LOG ("not a DRI peered window\n") ;
-        is_ok = TRUE ;
-        goto out ;
-    }
-    if (!findWindowPairFromLocal (a_win, &pair) || !pair) {
-        EPHYR_LOG_ERROR ("failed to get window pair\n") ;
-        goto out ;
-    }
-    rects = calloc(RegionNumRects (&a_win->clipList),
-                     sizeof (EphyrRect)) ;
-    for (i=0; i < RegionNumRects (&a_win->clipList); i++) {
-        memmove (&rects[i],
-                 &RegionRects (&a_win->clipList)[i],
-                 sizeof (EphyrRect)) ;
+        EPHYR_LOG("not a DRI peered window\n");
+        is_ok = TRUE;
+        goto out;
+    }
+    if (!findWindowPairFromLocal(a_win, &pair) || !pair) {
+        EPHYR_LOG_ERROR("failed to get window pair\n");
+        goto out;
+    }
+    rects = calloc(RegionNumRects(&a_win->clipList), sizeof(EphyrRect));
+    for (i = 0; i < RegionNumRects(&a_win->clipList); i++) {
+        memmove(&rects[i],
+                &RegionRects(&a_win->clipList)[i], sizeof(EphyrRect));
         rects[i].x1 -= a_win->drawable.x;
         rects[i].x2 -= a_win->drawable.x;
         rects[i].y1 -= a_win->drawable.y;
@@ -359,17 +344,15 @@ ephyrDRIClipNotify (WindowPtr a_win,
      * to the peer window in the host
      */
     is_ok = hostx_set_window_bounding_rectangles
-                                (pair->remote,
-                                 rects,
-                                 RegionNumRects (&a_win->clipList)) ;
-    is_ok = TRUE ;
+        (pair->remote, rects, RegionNumRects(&a_win->clipList));
+    is_ok = TRUE;
 
-out:
-    free(rects) ;
-    rects = NULL ;
+ out:
+    free(rects);
+    rects = NULL;
 
-    EPHYR_LOG ("leave. is_ok:%d\n", is_ok) ;
-    /*do cleanup here*/
+    EPHYR_LOG("leave. is_ok:%d\n", is_ok);
+    /*do cleanup here */
 }
 
 /**
@@ -382,119 +365,115 @@ out:
  * of the screen.
  */
 static Bool
-EphyrDuplicateVisual (unsigned int a_screen,
-                      short a_depth,
-                      short a_class,
-                      short a_bits_per_rgb_values,
-                      short a_colormap_entries,
-                      unsigned int a_red_mask,
-                      unsigned int a_green_mask,
-                      unsigned int a_blue_mask,
-                      unsigned int a_new_id)
+EphyrDuplicateVisual(unsigned int a_screen,
+                     short a_depth,
+                     short a_class,
+                     short a_bits_per_rgb_values,
+                     short a_colormap_entries,
+                     unsigned int a_red_mask,
+                     unsigned int a_green_mask,
+                     unsigned int a_blue_mask, unsigned int a_new_id)
 {
-    Bool is_ok = FALSE, found_visual=FALSE, found_depth=FALSE ;
-    ScreenPtr screen=NULL ;
-    VisualRec new_visual, *new_visuals=NULL ;
-    int i=0 ;
+    Bool is_ok = FALSE, found_visual = FALSE, found_depth = FALSE;
+    ScreenPtr screen = NULL;
+    VisualRec new_visual, *new_visuals = NULL;
+    int i = 0;
 
-    EPHYR_LOG ("enter\n") ; 
+    EPHYR_LOG("enter\n");
     if (a_screen >= screenInfo.numScreens) {
-        EPHYR_LOG_ERROR ("bad screen number\n") ;
+        EPHYR_LOG_ERROR("bad screen number\n");
         goto out;
     }
-    memset (&new_visual, 0, sizeof (VisualRec)) ;
+    memset(&new_visual, 0, sizeof(VisualRec));
 
-    /*get the screen pointed to by a_screen*/
-    screen = screenInfo.screens[a_screen] ;
-    EPHYR_RETURN_VAL_IF_FAIL (screen, FALSE) ;
+    /*get the screen pointed to by a_screen */
+    screen = screenInfo.screens[a_screen];
+    EPHYR_RETURN_VAL_IF_FAIL(screen, FALSE);
 
     /*
      * In that screen, first look for an existing visual that has the
      * same characteristics as those passed in parameter
      * to this function and copy it.
      */
-    for (i=0; i < screen->numVisuals; i++) {
+    for (i = 0; i < screen->numVisuals; i++) {
         if (screen->visuals[i].bitsPerRGBValue == a_bits_per_rgb_values &&
-            screen->visuals[i].ColormapEntries == a_colormap_entries ) {
-            /*copy the visual found*/
-            memcpy (&new_visual, &screen->visuals[i], sizeof (new_visual)) ;
-            new_visual.vid = a_new_id ;
-            new_visual.class = a_class ;
-            new_visual.redMask = a_red_mask ;
-            new_visual.greenMask = a_green_mask ;
-            new_visual.blueMask = a_blue_mask ;
-            found_visual = TRUE ;
-            EPHYR_LOG ("found a visual that matches visual id: %d\n",
-                       a_new_id) ;
+            screen->visuals[i].ColormapEntries == a_colormap_entries) {
+            /*copy the visual found */
+            memcpy(&new_visual, &screen->visuals[i], sizeof(new_visual));
+            new_visual.vid = a_new_id;
+            new_visual.class = a_class;
+            new_visual.redMask = a_red_mask;
+            new_visual.greenMask = a_green_mask;
+            new_visual.blueMask = a_blue_mask;
+            found_visual = TRUE;
+            EPHYR_LOG("found a visual that matches visual id: %d\n", a_new_id);
             break;
         }
     }
     if (!found_visual) {
-        EPHYR_LOG ("did not find any visual matching %d\n", a_new_id) ;
-        goto out ;
+        EPHYR_LOG("did not find any visual matching %d\n", a_new_id);
+        goto out;
     }
     /*
      * be prepare to extend screen->visuals to add new_visual to it
      */
-    new_visuals = calloc(screen->numVisuals+1, sizeof (VisualRec)) ;
-    memmove (new_visuals,
-             screen->visuals,
-             screen->numVisuals*sizeof (VisualRec)) ;
-    memmove (&new_visuals[screen->numVisuals],
-             &new_visual,
-             sizeof (VisualRec)) ;
+    new_visuals = calloc(screen->numVisuals + 1, sizeof(VisualRec));
+    memmove(new_visuals,
+            screen->visuals, screen->numVisuals * sizeof(VisualRec));
+    memmove(&new_visuals[screen->numVisuals], &new_visual, sizeof(VisualRec));
     /*
      * Now, in that same screen, update the screen->allowedDepths member.
      * In that array, each element represents the visuals applicable to
      * a given depth. So we need to add an entry matching the new visual
      * that we are going to add to screen->visuals
      */
-    for (i=0; i<screen->numDepths; i++) {
-        VisualID *vids=NULL;
-        DepthPtr cur_depth=NULL ;
-        /*find the entry matching a_depth*/
+    for (i = 0; i < screen->numDepths; i++) {
+        VisualID *vids = NULL;
+        DepthPtr cur_depth = NULL;
+
+        /*find the entry matching a_depth */
         if (screen->allowedDepths[i].depth != a_depth)
-            continue ;
+            continue;
         cur_depth = &screen->allowedDepths[i];
         /*
          * extend the list of visual IDs in that entry,
          * so to add a_new_id in there.
          */
         vids = realloc(cur_depth->vids,
-                         (cur_depth->numVids+1)*sizeof (VisualID));
+                       (cur_depth->numVids + 1) * sizeof(VisualID));
         if (!vids) {
-            EPHYR_LOG_ERROR ("failed to realloc numids\n") ;
-            goto out ;
+            EPHYR_LOG_ERROR("failed to realloc numids\n");
+            goto out;
         }
-        vids[cur_depth->numVids] = a_new_id ;
+        vids[cur_depth->numVids] = a_new_id;
         /*
          * Okay now commit our change.
          * Do really update screen->allowedDepths[i]
          */
-        cur_depth->numVids++ ;
-        cur_depth->vids = vids ;
-        found_depth=TRUE;
+        cur_depth->numVids++;
+        cur_depth->vids = vids;
+        found_depth = TRUE;
     }
     if (!found_depth) {
-        EPHYR_LOG_ERROR ("failed to update screen[%d]->allowedDepth\n",
-                         a_screen) ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to update screen[%d]->allowedDepth\n",
+                        a_screen);
+        goto out;
     }
     /*
      * Commit our change to screen->visuals
      */
-    free(screen->visuals) ;
-    screen->visuals = new_visuals ;
-    screen->numVisuals++ ;
-    new_visuals = NULL ;
-
-    is_ok = TRUE ;
-out:
-    free(new_visuals) ;
-    new_visuals = NULL ;
-
-    EPHYR_LOG ("leave\n") ; 
-    return is_ok ;
+    free(screen->visuals);
+    screen->visuals = new_visuals;
+    screen->numVisuals++;
+    new_visuals = NULL;
+
+    is_ok = TRUE;
+ out:
+    free(new_visuals);
+    new_visuals = NULL;
+
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 /**
@@ -504,46 +483,45 @@ out:
  * GLX.
  */
 static Bool
-EphyrMirrorHostVisuals (ScreenPtr a_screen)
+EphyrMirrorHostVisuals(ScreenPtr a_screen)
 {
-    Bool is_ok=FALSE;
-    EphyrHostVisualInfo  *visuals=NULL;
-    int nb_visuals=0, i=0;
-
-    EPHYR_LOG ("enter\n") ;
-    if (!hostx_get_visuals_info (&visuals, &nb_visuals)) {
-        EPHYR_LOG_ERROR ("failed to get host visuals\n") ;
-        goto out ;
-    }
-    for (i=0; i<nb_visuals; i++) {
-        if (!EphyrDuplicateVisual (a_screen->myNum,
-                                   visuals[i].depth,
-                                   visuals[i].class,
-                                   visuals[i].bits_per_rgb,
-                                   visuals[i].colormap_size,
-                                   visuals[i].red_mask,
-                                   visuals[i].green_mask,
-                                   visuals[i].blue_mask,
-                                   visuals[i].visualid)) {
-            EPHYR_LOG_ERROR ("failed to duplicate host visual %d\n",
-                             (int)visuals[i].visualid) ;
+    Bool is_ok = FALSE;
+    EphyrHostVisualInfo *visuals = NULL;
+    int nb_visuals = 0, i = 0;
+
+    EPHYR_LOG("enter\n");
+    if (!hostx_get_visuals_info(&visuals, &nb_visuals)) {
+        EPHYR_LOG_ERROR("failed to get host visuals\n");
+        goto out;
+    }
+    for (i = 0; i < nb_visuals; i++) {
+        if (!EphyrDuplicateVisual(a_screen->myNum,
+                                  visuals[i].depth,
+                                  visuals[i].class,
+                                  visuals[i].bits_per_rgb,
+                                  visuals[i].colormap_size,
+                                  visuals[i].red_mask,
+                                  visuals[i].green_mask,
+                                  visuals[i].blue_mask, visuals[i].visualid)) {
+            EPHYR_LOG_ERROR("failed to duplicate host visual %d\n",
+                            (int) visuals[i].visualid);
         }
     }
 
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("leave\n") ;
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("leave\n");
     return is_ok;
 }
 
-
 static int
-ProcXF86DRIQueryVersion (register ClientPtr client)
+ProcXF86DRIQueryVersion(register ClientPtr client)
 {
     xXF86DRIQueryVersionReply rep;
+
     REQUEST_SIZE_MATCH(xXF86DRIQueryVersionReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     rep.type = X_Reply;
     rep.length = 0;
@@ -552,72 +530,73 @@ ProcXF86DRIQueryVersion (register ClientPtr client)
     rep.minorVersion = SERVER_XF86DRI_MINOR_VERSION;
     rep.patchVersion = SERVER_XF86DRI_PATCH_VERSION;
     if (client->swapped) {
-    swaps(&rep.sequenceNumber);
-    swapl(&rep.length);
-	swaps(&rep.majorVersion);
-	swaps(&rep.minorVersion);
-	swapl(&rep.patchVersion);
-    }
-    WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), (char *)&rep);
-    EPHYR_LOG ("leave\n") ;
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.majorVersion);
+        swaps(&rep.minorVersion);
+        swapl(&rep.patchVersion);
+    }
+    WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), (char *) &rep);
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRIQueryDirectRenderingCapable (register ClientPtr client)
+ProcXF86DRIQueryDirectRenderingCapable(register ClientPtr client)
 {
-    xXF86DRIQueryDirectRenderingCapableReply	rep;
+    xXF86DRIQueryDirectRenderingCapableReply rep;
     Bool isCapable;
+
     REQUEST(xXF86DRIQueryDirectRenderingCapableReq);
     REQUEST_SIZE_MATCH(xXF86DRIQueryDirectRenderingCapableReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
-	client->errorValue = stuff->screen;
-	return BadValue;
+        client->errorValue = stuff->screen;
+        return BadValue;
     }
 
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    if (!ephyrDRIQueryDirectRenderingCapable (stuff->screen, &isCapable)) {
+    if (!ephyrDRIQueryDirectRenderingCapable(stuff->screen, &isCapable)) {
         return BadValue;
     }
     rep.isCapable = isCapable;
 
     if (!LocalClient(client) || client->swapped)
-	rep.isCapable = 0;
+        rep.isCapable = 0;
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
     }
 
-    WriteToClient(client, sizeof(xXF86DRIQueryDirectRenderingCapableReply), (char *)&rep);
-    EPHYR_LOG ("leave\n") ;
+    WriteToClient(client, sizeof(xXF86DRIQueryDirectRenderingCapableReply),
+                  (char *) &rep);
+    EPHYR_LOG("leave\n");
 
     return Success;
 }
 
 static int
-ProcXF86DRIOpenConnection (register ClientPtr client)
+ProcXF86DRIOpenConnection(register ClientPtr client)
 {
     xXF86DRIOpenConnectionReply rep;
-    drm_handle_t			hSAREA;
-    char*			busIdString = NULL;
+    drm_handle_t hSAREA;
+    char *busIdString = NULL;
+
     REQUEST(xXF86DRIOpenConnectionReq);
     REQUEST_SIZE_MATCH(xXF86DRIOpenConnectionReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
-	client->errorValue = stuff->screen;
-	return BadValue;
+        client->errorValue = stuff->screen;
+        return BadValue;
     }
 
-    if (!ephyrDRIOpenConnection(stuff->screen,
-                                &hSAREA,
-                                &busIdString)) {
+    if (!ephyrDRIOpenConnection(stuff->screen, &hSAREA, &busIdString)) {
         return BadValue;
     }
 
@@ -625,36 +604,39 @@ ProcXF86DRIOpenConnection (register ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.busIdStringLength = 0;
     if (busIdString)
-	rep.busIdStringLength = strlen(busIdString);
-    rep.length = bytes_to_int32(SIZEOF(xXF86DRIOpenConnectionReply) - SIZEOF(xGenericReply) +
-                  pad_to_int32(rep.busIdStringLength));
+        rep.busIdStringLength = strlen(busIdString);
+    rep.length =
+        bytes_to_int32(SIZEOF(xXF86DRIOpenConnectionReply) -
+                       SIZEOF(xGenericReply) +
+                       pad_to_int32(rep.busIdStringLength));
 
-    rep.hSAREALow  = (CARD32)(hSAREA & 0xffffffff);
+    rep.hSAREALow = (CARD32) (hSAREA & 0xffffffff);
 #if defined(LONG64) && !defined(__linux__)
-    rep.hSAREAHigh = (CARD32)(hSAREA >> 32);
+    rep.hSAREAHigh = (CARD32) (hSAREA >> 32);
 #else
     rep.hSAREAHigh = 0;
 #endif
 
-    WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), (char *) &rep);
     if (rep.busIdStringLength)
         WriteToClient(client, rep.busIdStringLength, busIdString);
     free(busIdString);
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRIAuthConnection  (register ClientPtr client)
+ProcXF86DRIAuthConnection(register ClientPtr client)
 {
     xXF86DRIAuthConnectionReply rep;
+
     REQUEST(xXF86DRIAuthConnectionReq);
     REQUEST_SIZE_MATCH(xXF86DRIAuthConnectionReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
-	client->errorValue = stuff->screen;
-	return BadValue;
+        client->errorValue = stuff->screen;
+        return BadValue;
     }
 
     rep.type = X_Reply;
@@ -662,88 +644,88 @@ ProcXF86DRIAuthConnection  (register ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.authenticated = 1;
 
-    if (!ephyrDRIAuthConnection (stuff->screen, stuff->magic)) {
-        ErrorF("Failed to authenticate %lu\n", (unsigned long)stuff->magic);
+    if (!ephyrDRIAuthConnection(stuff->screen, stuff->magic)) {
+        ErrorF("Failed to authenticate %lu\n", (unsigned long) stuff->magic);
         rep.authenticated = 0;
     }
-    WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), (char *)&rep);
-    EPHYR_LOG ("leave\n") ;
+    WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), (char *) &rep);
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRICloseConnection (register ClientPtr client)
+ProcXF86DRICloseConnection(register ClientPtr client)
 {
     REQUEST(xXF86DRICloseConnectionReq);
     REQUEST_SIZE_MATCH(xXF86DRICloseConnectionReq);
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
         client->errorValue = stuff->screen;
         return BadValue;
     }
 
     /*
-    DRICloseConnection( screenInfo.screens[stuff->screen]);
-    */
+       DRICloseConnection( screenInfo.screens[stuff->screen]);
+     */
 
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRIGetClientDriverName (register ClientPtr client)
+ProcXF86DRIGetClientDriverName(register ClientPtr client)
 {
-    xXF86DRIGetClientDriverNameReply	rep;
-    char* clientDriverName;
+    xXF86DRIGetClientDriverNameReply rep;
+    char *clientDriverName;
+
     REQUEST(xXF86DRIGetClientDriverNameReq);
     REQUEST_SIZE_MATCH(xXF86DRIGetClientDriverNameReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
-	client->errorValue = stuff->screen;
-	return BadValue;
+        client->errorValue = stuff->screen;
+        return BadValue;
     }
 
-    ephyrDRIGetClientDriverName (stuff->screen,
-                                 (int *)&rep.ddxDriverMajorVersion,
-                                 (int *)&rep.ddxDriverMinorVersion,
-                                 (int *)&rep.ddxDriverPatchVersion,
-                                 &clientDriverName);
+    ephyrDRIGetClientDriverName(stuff->screen,
+                                (int *) &rep.ddxDriverMajorVersion,
+                                (int *) &rep.ddxDriverMinorVersion,
+                                (int *) &rep.ddxDriverPatchVersion,
+                                &clientDriverName);
 
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.clientDriverNameLength = 0;
     if (clientDriverName)
-	rep.clientDriverNameLength = strlen(clientDriverName);
+        rep.clientDriverNameLength = strlen(clientDriverName);
     rep.length = bytes_to_int32(SIZEOF(xXF86DRIGetClientDriverNameReply) -
-			SIZEOF(xGenericReply) +
-			pad_to_int32(rep.clientDriverNameLength));
+                                SIZEOF(xGenericReply) +
+                                pad_to_int32(rep.clientDriverNameLength));
 
-    WriteToClient(client, 
-	sizeof(xXF86DRIGetClientDriverNameReply), (char *)&rep);
+    WriteToClient(client,
+                  sizeof(xXF86DRIGetClientDriverNameReply), (char *) &rep);
     if (rep.clientDriverNameLength)
-	WriteToClient(client, 
-                      rep.clientDriverNameLength, 
-                      clientDriverName);
-    EPHYR_LOG ("leave\n") ;
+        WriteToClient(client, rep.clientDriverNameLength, clientDriverName);
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRICreateContext (register ClientPtr client)
+ProcXF86DRICreateContext(register ClientPtr client)
 {
-    xXF86DRICreateContextReply	rep;
+    xXF86DRICreateContextReply rep;
     ScreenPtr pScreen;
     VisualPtr visual;
-    int i=0;
-    unsigned long context_id=0;
+    int i = 0;
+    unsigned long context_id = 0;
+
     REQUEST(xXF86DRICreateContextReq);
     REQUEST_SIZE_MATCH(xXF86DRICreateContextReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
-	client->errorValue = stuff->screen;
-	return BadValue;
+        client->errorValue = stuff->screen;
+        return BadValue;
     }
 
     rep.type = X_Reply;
@@ -755,205 +737,196 @@ ProcXF86DRICreateContext (register ClientPtr client)
 
     /* Find the requested X visual */
     for (i = 0; i < pScreen->numVisuals; i++, visual++)
-	if (visual->vid == stuff->visual)
-	    break;
+        if (visual->vid == stuff->visual)
+            break;
     if (i == pScreen->numVisuals) {
-	/* No visual found */
-	return BadValue;
+        /* No visual found */
+        return BadValue;
     }
 
-    context_id = stuff->context ;
-    if (!ephyrDRICreateContext (stuff->screen,
-                                stuff->visual,
-                                &context_id,
-                                (drm_context_t *)&rep.hHWContext)) {
+    context_id = stuff->context;
+    if (!ephyrDRICreateContext(stuff->screen,
+                               stuff->visual,
+                               &context_id,
+                               (drm_context_t *) & rep.hHWContext)) {
         return BadValue;
     }
 
-    WriteToClient(client, sizeof(xXF86DRICreateContextReply), (char *)&rep);
-    EPHYR_LOG ("leave\n") ;
+    WriteToClient(client, sizeof(xXF86DRICreateContextReply), (char *) &rep);
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRIDestroyContext (register ClientPtr client)
+ProcXF86DRIDestroyContext(register ClientPtr client)
 {
     REQUEST(xXF86DRIDestroyContextReq);
     REQUEST_SIZE_MATCH(xXF86DRIDestroyContextReq);
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     if (stuff->screen >= screenInfo.numScreens) {
         client->errorValue = stuff->screen;
         return BadValue;
     }
 
-   if (!ephyrDRIDestroyContext (stuff->screen, stuff->context)) {
-       return BadValue;
-   }
+    if (!ephyrDRIDestroyContext(stuff->screen, stuff->context)) {
+        return BadValue;
+    }
 
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static Bool
-getWindowVisual (const WindowPtr a_win,
-                 VisualPtr *a_visual)
+getWindowVisual(const WindowPtr a_win, VisualPtr * a_visual)
 {
-    int i=0, visual_id=0 ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_win
-                              && a_win->drawable.pScreen
-                              && a_win->drawable.pScreen->visuals,
-                              FALSE) ;
-
-    visual_id = wVisual (a_win) ;
-    for (i=0; i < a_win->drawable.pScreen->numVisuals; i++) {
+    int i = 0, visual_id = 0;
+
+    EPHYR_RETURN_VAL_IF_FAIL(a_win
+                             && a_win->drawable.pScreen
+                             && a_win->drawable.pScreen->visuals, FALSE);
+
+    visual_id = wVisual(a_win);
+    for (i = 0; i < a_win->drawable.pScreen->numVisuals; i++) {
         if (a_win->drawable.pScreen->visuals[i].vid == visual_id) {
-            *a_visual = &a_win->drawable.pScreen->visuals[i] ;
-            return TRUE ;
+            *a_visual = &a_win->drawable.pScreen->visuals[i];
+            return TRUE;
         }
     }
-    return FALSE ;
+    return FALSE;
 }
 
-
 #define NUM_WINDOW_PAIRS 256
-static EphyrWindowPair window_pairs[NUM_WINDOW_PAIRS] ;
+static EphyrWindowPair window_pairs[NUM_WINDOW_PAIRS];
 
 static Bool
-appendWindowPairToList (WindowPtr a_local,
-                        int a_remote)
+appendWindowPairToList(WindowPtr a_local, int a_remote)
 {
-    int i=0 ;
+    int i = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_local, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_local, FALSE);
 
-    EPHYR_LOG ("(local,remote):(%p, %d)\n", a_local, a_remote) ;
+    EPHYR_LOG("(local,remote):(%p, %d)\n", a_local, a_remote);
 
-    for (i=0; i < NUM_WINDOW_PAIRS; i++) {
+    for (i = 0; i < NUM_WINDOW_PAIRS; i++) {
         if (window_pairs[i].local == NULL) {
-            window_pairs[i].local = a_local ;
-            window_pairs[i].remote = a_remote ;
-            return TRUE ;
+            window_pairs[i].local = a_local;
+            window_pairs[i].remote = a_remote;
+            return TRUE;
         }
     }
-    return FALSE ;
+    return FALSE;
 }
 
 static Bool
-findWindowPairFromLocal (WindowPtr a_local,
-                         EphyrWindowPair **a_pair)
+findWindowPairFromLocal(WindowPtr a_local, EphyrWindowPair ** a_pair)
 {
-    int i=0 ;
+    int i = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_pair && a_local, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_pair && a_local, FALSE);
 
-    for (i=0; i < NUM_WINDOW_PAIRS; i++) {
+    for (i = 0; i < NUM_WINDOW_PAIRS; i++) {
         if (window_pairs[i].local == a_local) {
-            *a_pair = &window_pairs[i] ;
-            EPHYR_LOG ("found (%p, %d)\n",
-                       (*a_pair)->local,
-                       (*a_pair)->remote) ;
-            return TRUE ;
+            *a_pair = &window_pairs[i];
+            EPHYR_LOG("found (%p, %d)\n", (*a_pair)->local, (*a_pair)->remote);
+            return TRUE;
         }
     }
-    return FALSE ;
+    return FALSE;
 }
 
 Bool
-findWindowPairFromRemote (int a_remote,
-                          EphyrWindowPair **a_pair)
+findWindowPairFromRemote(int a_remote, EphyrWindowPair ** a_pair)
 {
-    int i=0 ;
+    int i = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_pair, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_pair, FALSE);
 
-    for (i=0; i < NUM_WINDOW_PAIRS; i++) {
+    for (i = 0; i < NUM_WINDOW_PAIRS; i++) {
         if (window_pairs[i].remote == a_remote) {
-            *a_pair = &window_pairs[i] ;
-            EPHYR_LOG ("found (%p, %d)\n",
-                       (*a_pair)->local,
-                       (*a_pair)->remote) ;
-            return TRUE ;
+            *a_pair = &window_pairs[i];
+            EPHYR_LOG("found (%p, %d)\n", (*a_pair)->local, (*a_pair)->remote);
+            return TRUE;
         }
     }
-    return FALSE ;
+    return FALSE;
 }
 
 static Bool
-createHostPeerWindow (const WindowPtr a_win,
-                      int *a_peer_win)
+createHostPeerWindow(const WindowPtr a_win, int *a_peer_win)
 {
-    Bool is_ok=FALSE ;
-    VisualPtr visual=NULL;
-    EphyrBox geo ;
+    Bool is_ok = FALSE;
+    VisualPtr visual = NULL;
+    EphyrBox geo;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_win && a_peer_win, FALSE) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_win->drawable.pScreen,
-                              FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_win && a_peer_win, FALSE);
+    EPHYR_RETURN_VAL_IF_FAIL(a_win->drawable.pScreen, FALSE);
 
-    EPHYR_LOG ("enter. a_win '%p'\n", a_win) ;
-    if (!getWindowVisual (a_win, &visual)) {
-        EPHYR_LOG_ERROR ("failed to get window visual\n") ;
-        goto out ;
+    EPHYR_LOG("enter. a_win '%p'\n", a_win);
+    if (!getWindowVisual(a_win, &visual)) {
+        EPHYR_LOG_ERROR("failed to get window visual\n");
+        goto out;
     }
     if (!visual) {
-        EPHYR_LOG_ERROR ("failed to create visual\n") ;
-        goto out ;
-    }
-    memset (&geo, 0, sizeof (geo)) ;
-    geo.x = a_win->drawable.x ;
-    geo.y = a_win->drawable.y ;
-    geo.width = a_win->drawable.width ;
-    geo.height = a_win->drawable.height ;
-    if (!hostx_create_window (a_win->drawable.pScreen->myNum,
-                              &geo, visual->vid, a_peer_win)) {
-        EPHYR_LOG_ERROR ("failed to create host peer window\n") ;
-        goto out ;
-    }
-    if (!appendWindowPairToList (a_win, *a_peer_win)) {
-        EPHYR_LOG_ERROR ("failed to append window to pair list\n") ;
-        goto out ;
-    }
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("leave:remote win%d\n", *a_peer_win) ;
-    return is_ok ;
+        EPHYR_LOG_ERROR("failed to create visual\n");
+        goto out;
+    }
+    memset(&geo, 0, sizeof(geo));
+    geo.x = a_win->drawable.x;
+    geo.y = a_win->drawable.y;
+    geo.width = a_win->drawable.width;
+    geo.height = a_win->drawable.height;
+    if (!hostx_create_window(a_win->drawable.pScreen->myNum,
+                             &geo, visual->vid, a_peer_win)) {
+        EPHYR_LOG_ERROR("failed to create host peer window\n");
+        goto out;
+    }
+    if (!appendWindowPairToList(a_win, *a_peer_win)) {
+        EPHYR_LOG_ERROR("failed to append window to pair list\n");
+        goto out;
+    }
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("leave:remote win%d\n", *a_peer_win);
+    return is_ok;
 }
 
 static Bool
-destroyHostPeerWindow (const WindowPtr a_win)
+destroyHostPeerWindow(const WindowPtr a_win)
 {
-    Bool is_ok = FALSE ;
-    EphyrWindowPair *pair=NULL ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_win, FALSE) ;
+    Bool is_ok = FALSE;
+    EphyrWindowPair *pair = NULL;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_win, FALSE);
 
-    if (!findWindowPairFromLocal (a_win, &pair) || !pair) {
-        EPHYR_LOG_ERROR ("failed to find peer to local window\n") ;
+    EPHYR_LOG("enter\n");
+
+    if (!findWindowPairFromLocal(a_win, &pair) || !pair) {
+        EPHYR_LOG_ERROR("failed to find peer to local window\n");
         goto out;
     }
-    hostx_destroy_window (pair->remote) ;
-    is_ok = TRUE ;
+    hostx_destroy_window(pair->remote);
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
+ out:
+    EPHYR_LOG("leave\n");
     return is_ok;
 }
 
 static int
-ProcXF86DRICreateDrawable (ClientPtr client)
+ProcXF86DRICreateDrawable(ClientPtr client)
 {
-    xXF86DRICreateDrawableReply	rep;
-    DrawablePtr drawable=NULL;
-    WindowPtr window=NULL ;
-    EphyrWindowPair *pair=NULL ;
-    EphyrDRIWindowPrivPtr win_priv=NULL;
-    int rc=0, remote_win=0;
+    xXF86DRICreateDrawableReply rep;
+    DrawablePtr drawable = NULL;
+    WindowPtr window = NULL;
+    EphyrWindowPair *pair = NULL;
+    EphyrDRIWindowPrivPtr win_priv = NULL;
+    int rc = 0, remote_win = 0;
+
     REQUEST(xXF86DRICreateDrawableReq);
     REQUEST_SIZE_MATCH(xXF86DRICreateDrawableReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
         client->errorValue = stuff->screen;
         return BadValue;
@@ -963,108 +936,107 @@ ProcXF86DRICreateDrawable (ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    rc = dixLookupDrawable (&drawable, stuff->drawable, client, 0,
-                            DixReadAccess);
+    rc = dixLookupDrawable(&drawable, stuff->drawable, client, 0,
+                           DixReadAccess);
     if (rc != Success)
         return rc;
     if (drawable->type != DRAWABLE_WINDOW) {
-        EPHYR_LOG_ERROR ("non drawable windows are not yet supported\n") ;
-        return BadImplementation ;
-    }
-    EPHYR_LOG ("lookedup drawable %p\n", drawable) ;
-    window = (WindowPtr)drawable;
-    if (findWindowPairFromLocal (window, &pair) && pair) {
-        remote_win = pair->remote ;
-        EPHYR_LOG ("found window '%p' paire with remote '%d'\n",
-                   window, remote_win) ;
-    } else if (!createHostPeerWindow (window, &remote_win)) {
-        EPHYR_LOG_ERROR ("failed to create host peer window\n") ;
-        return BadAlloc ;
-    }
-
-    if (!ephyrDRICreateDrawable (stuff->screen,
-                                 remote_win,
-                                 (drm_drawable_t *)&rep.hHWDrawable)) {
-        EPHYR_LOG_ERROR ("failed to create dri drawable\n") ;
+        EPHYR_LOG_ERROR("non drawable windows are not yet supported\n");
+        return BadImplementation;
+    }
+    EPHYR_LOG("lookedup drawable %p\n", drawable);
+    window = (WindowPtr) drawable;
+    if (findWindowPairFromLocal(window, &pair) && pair) {
+        remote_win = pair->remote;
+        EPHYR_LOG("found window '%p' paire with remote '%d'\n",
+                  window, remote_win);
+    }
+    else if (!createHostPeerWindow(window, &remote_win)) {
+        EPHYR_LOG_ERROR("failed to create host peer window\n");
+        return BadAlloc;
+    }
+
+    if (!ephyrDRICreateDrawable(stuff->screen,
+                                remote_win,
+                                (drm_drawable_t *) & rep.hHWDrawable)) {
+        EPHYR_LOG_ERROR("failed to create dri drawable\n");
         return BadValue;
     }
 
-    win_priv = GET_EPHYR_DRI_WINDOW_PRIV (window) ;
+    win_priv = GET_EPHYR_DRI_WINDOW_PRIV(window);
     if (!win_priv) {
-        win_priv = calloc(1, sizeof (EphyrDRIWindowPrivRec)) ;
+        win_priv = calloc(1, sizeof(EphyrDRIWindowPrivRec));
         if (!win_priv) {
-            EPHYR_LOG_ERROR ("failed to allocate window private\n") ;
-            return BadAlloc ;
+            EPHYR_LOG_ERROR("failed to allocate window private\n");
+            return BadAlloc;
         }
-	dixSetPrivate(&window->devPrivates, ephyrDRIWindowKey, win_priv);
-        EPHYR_LOG ("paired window '%p' with remote '%d'\n",
-                   window, remote_win) ;
+        dixSetPrivate(&window->devPrivates, ephyrDRIWindowKey, win_priv);
+        EPHYR_LOG("paired window '%p' with remote '%d'\n", window, remote_win);
     }
 
-    WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), (char *)&rep);
-    EPHYR_LOG ("leave\n") ;
+    WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), (char *) &rep);
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRIDestroyDrawable (register ClientPtr client)
+ProcXF86DRIDestroyDrawable(register ClientPtr client)
 {
-    DrawablePtr drawable=NULL;
-    WindowPtr window=NULL;
-    EphyrWindowPair *pair=NULL;
-    int rc=0;
+    DrawablePtr drawable = NULL;
+    WindowPtr window = NULL;
+    EphyrWindowPair *pair = NULL;
+    int rc = 0;
+
     REQUEST(xXF86DRIDestroyDrawableReq);
     REQUEST_SIZE_MATCH(xXF86DRIDestroyDrawableReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
         client->errorValue = stuff->screen;
         return BadValue;
     }
 
     rc = dixLookupDrawable(&drawable,
-                           stuff->drawable,
-                           client,
-                           0,
-                           DixReadAccess);
+                           stuff->drawable, client, 0, DixReadAccess);
     if (rc != Success)
         return rc;
     if (drawable->type != DRAWABLE_WINDOW) {
-        EPHYR_LOG_ERROR ("non drawable windows are not yet supported\n") ;
-        return BadImplementation ;
+        EPHYR_LOG_ERROR("non drawable windows are not yet supported\n");
+        return BadImplementation;
     }
-    window = (WindowPtr)drawable;
-    if (!findWindowPairFromLocal (window, &pair) && pair) {
-        EPHYR_LOG_ERROR ("failed to find pair window\n") ;
+    window = (WindowPtr) drawable;
+    if (!findWindowPairFromLocal(window, &pair) && pair) {
+        EPHYR_LOG_ERROR("failed to find pair window\n");
         return BadImplementation;
     }
     if (!ephyrDRIDestroyDrawable(stuff->screen,
-                                 pair->remote/*drawable in host x*/)) {
-        EPHYR_LOG_ERROR ("failed to destroy dri drawable\n") ;
+                                 pair->remote /*drawable in host x */ )) {
+        EPHYR_LOG_ERROR("failed to destroy dri drawable\n");
         return BadImplementation;
     }
-    pair->local=NULL ;
-    pair->remote=0;
+    pair->local = NULL;
+    pair->remote = 0;
 
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRIGetDrawableInfo (register ClientPtr client)
+ProcXF86DRIGetDrawableInfo(register ClientPtr client)
 {
     xXF86DRIGetDrawableInfoReply rep;
     DrawablePtr drawable;
-    WindowPtr window=NULL;
-    EphyrWindowPair *pair=NULL;
-    int X=0, Y=0, W=0, H=0, backX=0, backY=0, rc=0, i=0;
-    drm_clip_rect_t *clipRects=NULL;
-    drm_clip_rect_t *backClipRects=NULL;
+    WindowPtr window = NULL;
+    EphyrWindowPair *pair = NULL;
+    int X = 0, Y = 0, W = 0, H = 0, backX = 0, backY = 0, rc = 0, i = 0;
+    drm_clip_rect_t *clipRects = NULL;
+    drm_clip_rect_t *backClipRects = NULL;
+
     REQUEST(xXF86DRIGetDrawableInfoReq);
     REQUEST_SIZE_MATCH(xXF86DRIGetDrawableInfoReq);
 
-    EPHYR_LOG ("enter\n") ;
-    memset (&rep, 0, sizeof (rep)) ;
+    EPHYR_LOG("enter\n");
+    memset(&rep, 0, sizeof(rep));
     if (stuff->screen >= screenInfo.numScreens) {
         client->errorValue = stuff->screen;
         return BadValue;
@@ -1077,123 +1049,125 @@ ProcXF86DRIGetDrawableInfo (register ClientPtr client)
     rc = dixLookupDrawable(&drawable, stuff->drawable, client, 0,
                            DixReadAccess);
     if (rc != Success || !drawable) {
-        EPHYR_LOG_ERROR ("could not get drawable\n") ;
+        EPHYR_LOG_ERROR("could not get drawable\n");
         return rc;
     }
 
     if (drawable->type != DRAWABLE_WINDOW) {
-        EPHYR_LOG_ERROR ("non windows type drawables are not yes supported\n") ;
-        return BadImplementation ;
-    }
-    window = (WindowPtr)drawable ;
-    memset (&pair, 0, sizeof (pair)) ;
-    if (!findWindowPairFromLocal (window, &pair) || !pair) {
-        EPHYR_LOG_ERROR ("failed to find remote peer drawable\n") ;
-        return BadMatch ;
-    }
-    EPHYR_LOG ("clip list of xephyr gl drawable:\n") ;
-    for (i=0; i < RegionNumRects (&window->clipList); i++) {
-        EPHYR_LOG ("x1:%d, y1:%d, x2:%d, y2:%d\n",
-                   RegionRects (&window->clipList)[i].x1,
-                   RegionRects (&window->clipList)[i].y1,
-                   RegionRects (&window->clipList)[i].x2,
-                   RegionRects (&window->clipList)[i].y2) ;
-    }
-
-    if (!ephyrDRIGetDrawableInfo (stuff->screen,
-                                  pair->remote/*the drawable in hostx*/,
-                                  (unsigned int*)&rep.drawableTableIndex,
-                                  (unsigned int*)&rep.drawableTableStamp,
-                                  (int*)&X,
-                                  (int*)&Y,
-                                  (int*)&W,
-                                  (int*)&H,
-                                  (int*)&rep.numClipRects,
-                                  &clipRects,
-                                  &backX,
-                                  &backY,
-                                  (int*)&rep.numBackClipRects,
-                                  &backClipRects)) {
+        EPHYR_LOG_ERROR("non windows type drawables are not yes supported\n");
+        return BadImplementation;
+    }
+    window = (WindowPtr) drawable;
+    memset(&pair, 0, sizeof(pair));
+    if (!findWindowPairFromLocal(window, &pair) || !pair) {
+        EPHYR_LOG_ERROR("failed to find remote peer drawable\n");
+        return BadMatch;
+    }
+    EPHYR_LOG("clip list of xephyr gl drawable:\n");
+    for (i = 0; i < RegionNumRects(&window->clipList); i++) {
+        EPHYR_LOG("x1:%d, y1:%d, x2:%d, y2:%d\n",
+                  RegionRects(&window->clipList)[i].x1,
+                  RegionRects(&window->clipList)[i].y1,
+                  RegionRects(&window->clipList)[i].x2,
+                  RegionRects(&window->clipList)[i].y2);
+    }
+
+    if (!ephyrDRIGetDrawableInfo(stuff->screen,
+                                 pair->remote /*the drawable in hostx */ ,
+                                 (unsigned int *) &rep.drawableTableIndex,
+                                 (unsigned int *) &rep.drawableTableStamp,
+                                 (int *) &X,
+                                 (int *) &Y,
+                                 (int *) &W,
+                                 (int *) &H,
+                                 (int *) &rep.numClipRects,
+                                 &clipRects,
+                                 &backX,
+                                 &backY,
+                                 (int *) &rep.numBackClipRects,
+                                 &backClipRects)) {
         return BadValue;
     }
-    EPHYR_LOG ("num clip rects:%d, num back clip rects:%d\n",
-               (int)rep.numClipRects, (int)rep.numBackClipRects) ;
+    EPHYR_LOG("num clip rects:%d, num back clip rects:%d\n",
+              (int) rep.numClipRects, (int) rep.numBackClipRects);
 
     rep.drawableX = X;
     rep.drawableY = Y;
     rep.drawableWidth = W;
     rep.drawableHeight = H;
-    rep.length = (SIZEOF(xXF86DRIGetDrawableInfoReply) -
-                  SIZEOF(xGenericReply));
+    rep.length = (SIZEOF(xXF86DRIGetDrawableInfoReply) - SIZEOF(xGenericReply));
 
     rep.backX = backX;
     rep.backY = backY;
 
-
     if (rep.numClipRects) {
         if (clipRects) {
             ScreenPtr pScreen = screenInfo.screens[stuff->screen];
-            int i=0;
-            EPHYR_LOG ("clip list of host gl drawable:\n") ;
+            int i = 0;
+
+            EPHYR_LOG("clip list of host gl drawable:\n");
             for (i = 0; i < rep.numClipRects; i++) {
-                clipRects[i].x1 = max (clipRects[i].x1, 0);
-                clipRects[i].y1 = max (clipRects[i].y1, 0);
-                clipRects[i].x2 = min (clipRects[i].x2,
-                                       pScreen->width + clipRects[i].x1) ;
-                clipRects[i].y2 = min (clipRects[i].y2,
-                                       pScreen->width + clipRects[i].y1) ;
-
-                EPHYR_LOG ("x1:%d, y1:%d, x2:%d, y2:%d\n",
-                           clipRects[i].x1, clipRects[i].y1,
-                           clipRects[i].x2, clipRects[i].y2) ;
+                clipRects[i].x1 = max(clipRects[i].x1, 0);
+                clipRects[i].y1 = max(clipRects[i].y1, 0);
+                clipRects[i].x2 = min(clipRects[i].x2,
+                                      pScreen->width + clipRects[i].x1);
+                clipRects[i].y2 = min(clipRects[i].y2,
+                                      pScreen->width + clipRects[i].y1);
+
+                EPHYR_LOG("x1:%d, y1:%d, x2:%d, y2:%d\n",
+                          clipRects[i].x1, clipRects[i].y1,
+                          clipRects[i].x2, clipRects[i].y2);
             }
-        } else {
+        }
+        else {
             rep.numClipRects = 0;
         }
-    } else {
-        EPHYR_LOG ("got zero host gl drawable clipping rects\n") ;
+    }
+    else {
+        EPHYR_LOG("got zero host gl drawable clipping rects\n");
     }
     rep.length += sizeof(drm_clip_rect_t) * rep.numClipRects;
-    backClipRects = clipRects ;
-    rep.numBackClipRects = rep.numClipRects ;
+    backClipRects = clipRects;
+    rep.numBackClipRects = rep.numClipRects;
     if (rep.numBackClipRects)
         rep.length += sizeof(drm_clip_rect_t) * rep.numBackClipRects;
-    EPHYR_LOG ("num host clip rects:%d\n", (int)rep.numClipRects) ;
-    EPHYR_LOG ("num host back clip rects:%d\n", (int)rep.numBackClipRects) ;
+    EPHYR_LOG("num host clip rects:%d\n", (int) rep.numClipRects);
+    EPHYR_LOG("num host back clip rects:%d\n", (int) rep.numBackClipRects);
 
     rep.length = bytes_to_int32(rep.length);
 
-    WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), (char *) &rep);
 
     if (rep.numClipRects) {
         WriteToClient(client,
                       sizeof(drm_clip_rect_t) * rep.numClipRects,
-                      (char *)clipRects);
+                      (char *) clipRects);
     }
 
     if (rep.numBackClipRects) {
         WriteToClient(client,
                       sizeof(drm_clip_rect_t) * rep.numBackClipRects,
-                      (char *)backClipRects);
+                      (char *) backClipRects);
     }
     free(clipRects);
-    clipRects = NULL ;
+    clipRects = NULL;
 
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
 
     return Success;
 }
 
 static int
-ProcXF86DRIGetDeviceInfo (register ClientPtr client)
+ProcXF86DRIGetDeviceInfo(register ClientPtr client)
 {
-    xXF86DRIGetDeviceInfoReply	rep;
+    xXF86DRIGetDeviceInfoReply rep;
     drm_handle_t hFrameBuffer;
     void *pDevPrivate;
+
     REQUEST(xXF86DRIGetDeviceInfoReq);
     REQUEST_SIZE_MATCH(xXF86DRIGetDeviceInfoReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     if (stuff->screen >= screenInfo.numScreens) {
         client->errorValue = stuff->screen;
         return BadValue;
@@ -1203,19 +1177,18 @@ ProcXF86DRIGetDeviceInfo (register ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    if (!ephyrDRIGetDeviceInfo (stuff->screen,
-                &hFrameBuffer,
-                (int*)&rep.framebufferOrigin,
-                (int*)&rep.framebufferSize,
-                (int*)&rep.framebufferStride,
-                (int*)&rep.devPrivateSize,
-                &pDevPrivate)) {
+    if (!ephyrDRIGetDeviceInfo(stuff->screen,
+                               &hFrameBuffer,
+                               (int *) &rep.framebufferOrigin,
+                               (int *) &rep.framebufferSize,
+                               (int *) &rep.framebufferStride,
+                               (int *) &rep.devPrivateSize, &pDevPrivate)) {
         return BadValue;
     }
 
-    rep.hFrameBufferLow  = (CARD32)(hFrameBuffer & 0xffffffff);
+    rep.hFrameBufferLow = (CARD32) (hFrameBuffer & 0xffffffff);
 #if defined(LONG64) && !defined(__linux__)
-    rep.hFrameBufferHigh = (CARD32)(hFrameBuffer >> 32);
+    rep.hFrameBufferHigh = (CARD32) (hFrameBuffer >> 32);
 #else
     rep.hFrameBufferHigh = 0;
 #endif
@@ -1223,91 +1196,89 @@ ProcXF86DRIGetDeviceInfo (register ClientPtr client)
     rep.length = 0;
     if (rep.devPrivateSize) {
         rep.length = bytes_to_int32(SIZEOF(xXF86DRIGetDeviceInfoReply) -
-                SIZEOF(xGenericReply) +
-                pad_to_int32(rep.devPrivateSize));
+                                    SIZEOF(xGenericReply) +
+                                    pad_to_int32(rep.devPrivateSize));
     }
 
-    WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), (char *) &rep);
     if (rep.length) {
-        WriteToClient(client, rep.devPrivateSize, (char *)pDevPrivate);
+        WriteToClient(client, rep.devPrivateSize, (char *) pDevPrivate);
     }
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
     return Success;
 }
 
 static int
-ProcXF86DRIDispatch (register ClientPtr	client)
+ProcXF86DRIDispatch(register ClientPtr client)
 {
     REQUEST(xReq);
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    switch (stuff->data)
-    {
-        case X_XF86DRIQueryVersion: {
-                EPHYR_LOG ("leave\n") ;
-                return ProcXF86DRIQueryVersion(client);
-        }
-        case X_XF86DRIQueryDirectRenderingCapable: {
-                EPHYR_LOG ("leave\n") ;
-                return ProcXF86DRIQueryDirectRenderingCapable(client);
-        }
+    switch (stuff->data) {
+    case X_XF86DRIQueryVersion:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIQueryVersion(client);
+    }
+    case X_XF86DRIQueryDirectRenderingCapable:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIQueryDirectRenderingCapable(client);
+    }
     }
 
     if (!LocalClient(client))
         return DRIErrorBase + XF86DRIClientNotLocal;
 
-    switch (stuff->data)
-    {
-        case X_XF86DRIOpenConnection: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRIOpenConnection(client);
-        }
-        case X_XF86DRICloseConnection: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRICloseConnection(client);
-        }
-        case X_XF86DRIGetClientDriverName: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRIGetClientDriverName(client);
-        }
-        case X_XF86DRICreateContext: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRICreateContext(client);
-        }
-        case X_XF86DRIDestroyContext: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRIDestroyContext(client);
-        }
-        case X_XF86DRICreateDrawable: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRICreateDrawable(client);
-        }
-        case X_XF86DRIDestroyDrawable: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRIDestroyDrawable(client);
-        }
-        case X_XF86DRIGetDrawableInfo: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRIGetDrawableInfo(client);
-        }
-        case X_XF86DRIGetDeviceInfo: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRIGetDeviceInfo(client);
-        }
-        case X_XF86DRIAuthConnection: {
-            EPHYR_LOG ("leave\n") ;
-            return ProcXF86DRIAuthConnection(client);
-        }
-            /* {Open,Close}FullScreen are deprecated now */
-        default: {
-            EPHYR_LOG ("leave\n") ;
-            return BadRequest;
-        }
+    switch (stuff->data) {
+    case X_XF86DRIOpenConnection:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIOpenConnection(client);
+    }
+    case X_XF86DRICloseConnection:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRICloseConnection(client);
+    }
+    case X_XF86DRIGetClientDriverName:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIGetClientDriverName(client);
+    }
+    case X_XF86DRICreateContext:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRICreateContext(client);
+    }
+    case X_XF86DRIDestroyContext:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIDestroyContext(client);
+    }
+    case X_XF86DRICreateDrawable:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRICreateDrawable(client);
+    }
+    case X_XF86DRIDestroyDrawable:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIDestroyDrawable(client);
+    }
+    case X_XF86DRIGetDrawableInfo:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIGetDrawableInfo(client);
+    }
+    case X_XF86DRIGetDeviceInfo:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIGetDeviceInfo(client);
+    }
+    case X_XF86DRIAuthConnection:{
+        EPHYR_LOG("leave\n");
+        return ProcXF86DRIAuthConnection(client);
+    }
+        /* {Open,Close}FullScreen are deprecated now */
+    default:{
+        EPHYR_LOG("leave\n");
+        return BadRequest;
+    }
     }
 }
 
 static int
-SProcXF86DRIQueryVersion (register ClientPtr	client)
+SProcXF86DRIQueryVersion(register ClientPtr client)
 {
     REQUEST(xXF86DRIQueryVersionReq);
     swaps(&stuff->length);
@@ -1315,7 +1286,7 @@ SProcXF86DRIQueryVersion (register ClientPtr	client)
 }
 
 static int
-SProcXF86DRIQueryDirectRenderingCapable (register ClientPtr client)
+SProcXF86DRIQueryDirectRenderingCapable(register ClientPtr client)
 {
     REQUEST(xXF86DRIQueryDirectRenderingCapableReq);
     swaps(&stuff->length);
@@ -1324,90 +1295,89 @@ SProcXF86DRIQueryDirectRenderingCapable (register ClientPtr client)
 }
 
 static int
-SProcXF86DRIDispatch (register ClientPtr client)
+SProcXF86DRIDispatch(register ClientPtr client)
 {
     REQUEST(xReq);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     /*
      * Only local clients are allowed DRI access, but remote clients still need
      * these requests to find out cleanly.
      */
-    switch (stuff->data)
-    {
-        case X_XF86DRIQueryVersion: {
-            EPHYR_LOG ("leave\n") ;
-            return SProcXF86DRIQueryVersion(client);
-        }
-        case X_XF86DRIQueryDirectRenderingCapable: {
-            EPHYR_LOG ("leave\n") ;
-            return SProcXF86DRIQueryDirectRenderingCapable(client);
-        }
-        default: {
-            EPHYR_LOG ("leave\n") ;
-            return DRIErrorBase + XF86DRIClientNotLocal;
-        }
+    switch (stuff->data) {
+    case X_XF86DRIQueryVersion:{
+        EPHYR_LOG("leave\n");
+        return SProcXF86DRIQueryVersion(client);
+    }
+    case X_XF86DRIQueryDirectRenderingCapable:{
+        EPHYR_LOG("leave\n");
+        return SProcXF86DRIQueryDirectRenderingCapable(client);
+    }
+    default:{
+        EPHYR_LOG("leave\n");
+        return DRIErrorBase + XF86DRIClientNotLocal;
+    }
     }
 }
 
 Bool
-ephyrDRIExtensionInit (ScreenPtr a_screen)
+ephyrDRIExtensionInit(ScreenPtr a_screen)
 {
-    Bool is_ok=FALSE ;
-    ExtensionEntry* extEntry=NULL;
-    EphyrDRIScreenPrivPtr screen_priv=NULL ;
+    Bool is_ok = FALSE;
+    ExtensionEntry *extEntry = NULL;
+    EphyrDRIScreenPrivPtr screen_priv = NULL;
 
-    EPHYR_LOG ("enter\n") ;
-    if (!hostx_has_dri ()) {
-        EPHYR_LOG ("host does not have DRI extension\n") ;
-        goto out ;
+    EPHYR_LOG("enter\n");
+    if (!hostx_has_dri()) {
+        EPHYR_LOG("host does not have DRI extension\n");
+        goto out;
     }
-    EPHYR_LOG ("host X does have DRI extension\n") ;
-    if (!hostx_has_xshape ()) {
-        EPHYR_LOG ("host does not have XShape extension\n") ;
-        goto out ;
+    EPHYR_LOG("host X does have DRI extension\n");
+    if (!hostx_has_xshape()) {
+        EPHYR_LOG("host does not have XShape extension\n");
+        goto out;
     }
-    EPHYR_LOG ("host X does have XShape extension\n") ;
+    EPHYR_LOG("host X does have XShape extension\n");
 
 #ifdef XF86DRI_EVENTS
-    EventType = CreateNewResourceType (XF86DRIFreeEvents, "DRIEvents");
+    EventType = CreateNewResourceType(XF86DRIFreeEvents, "DRIEvents");
     if (!EventType) {
-        EPHYR_LOG_ERROR ("failed to register DRI event resource type\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to register DRI event resource type\n");
+        goto out;
     }
 #endif
 
     if ((extEntry = AddExtension(XF86DRINAME,
-				 XF86DRINumberEvents,
-				 XF86DRINumberErrors,
-				 ProcXF86DRIDispatch,
-				 SProcXF86DRIDispatch,
-				 NULL,
-				 StandardMinorOpcode))) {
-	DRIReqCode = (unsigned char)extEntry->base;
-	DRIErrorBase = extEntry->errorBase;
-    } else {
-        EPHYR_LOG_ERROR ("failed to register DRI extension\n") ;
-        goto out ;
+                                 XF86DRINumberEvents,
+                                 XF86DRINumberErrors,
+                                 ProcXF86DRIDispatch,
+                                 SProcXF86DRIDispatch,
+                                 NULL, StandardMinorOpcode))) {
+        DRIReqCode = (unsigned char) extEntry->base;
+        DRIErrorBase = extEntry->errorBase;
+    }
+    else {
+        EPHYR_LOG_ERROR("failed to register DRI extension\n");
+        goto out;
     }
     if (!dixRegisterPrivateKey(&ephyrDRIScreenKeyRec, PRIVATE_SCREEN, 0))
-        goto out ;
+        goto out;
     if (!dixRegisterPrivateKey(&ephyrDRIWindowKeyRec, PRIVATE_WINDOW, 0))
-        goto out ;
-    screen_priv = calloc(1, sizeof (EphyrDRIScreenPrivRec)) ;
+        goto out;
+    screen_priv = calloc(1, sizeof(EphyrDRIScreenPrivRec));
     if (!screen_priv) {
-        EPHYR_LOG_ERROR ("failed to allocate screen_priv\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to allocate screen_priv\n");
+        goto out;
     }
     dixSetPrivate(&a_screen->devPrivates, ephyrDRIScreenKey, screen_priv);
 
-    if (!ephyrDRIScreenInit (a_screen)) {
-        EPHYR_LOG_ERROR ("ephyrDRIScreenInit() failed\n") ;
-        goto out ;
+    if (!ephyrDRIScreenInit(a_screen)) {
+        EPHYR_LOG_ERROR("ephyrDRIScreenInit() failed\n");
+        goto out;
     }
-    EphyrMirrorHostVisuals (a_screen) ;
-    is_ok=TRUE ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    EphyrMirrorHostVisuals(a_screen);
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
diff --git a/hw/kdrive/ephyr/ephyrdriext.h b/hw/kdrive/ephyr/ephyrdriext.h
index 01c9421fb..5808576fe 100644
--- a/hw/kdrive/ephyr/ephyrdriext.h
+++ b/hw/kdrive/ephyr/ephyrdriext.h
@@ -29,14 +29,12 @@
 #define __EPHYRDRIEXT_H__
 
 typedef struct {
-    WindowPtr local ;
-    int remote ;
+    WindowPtr local;
+    int remote;
 } EphyrWindowPair;
 
-Bool ephyrDRIExtensionInit (ScreenPtr a_screen) ;
+Bool ephyrDRIExtensionInit(ScreenPtr a_screen);
 
-Bool findWindowPairFromRemote (int a_remote,
-			       EphyrWindowPair **a_pair);
+Bool findWindowPairFromRemote(int a_remote, EphyrWindowPair ** a_pair);
 
 #endif /*__EPHYRDRIEXT_H__*/
-
diff --git a/hw/kdrive/ephyr/ephyrglxext.c b/hw/kdrive/ephyr/ephyrglxext.c
index dfc43e1d1..dab028bf3 100644
--- a/hw/kdrive/ephyr/ephyrglxext.c
+++ b/hw/kdrive/ephyr/ephyrglxext.c
@@ -41,7 +41,6 @@
 #include "glx/unpack.h"
 #include "hostx.h"
 
-
 #ifndef TRUE
 #define TRUE 1
 #endif
@@ -50,90 +49,89 @@
 #define FALSE 0
 #endif
 
-
-int ephyrGLXQueryVersion (__GLXclientState *cl, GLbyte *pc) ;
-int ephyrGLXQueryVersionSwap (__GLXclientState *cl, GLbyte *pc) ;
-int ephyrGLXGetVisualConfigs (__GLXclientState *cl, GLbyte *pc) ;
-int ephyrGLXGetVisualConfigsSwap (__GLXclientState *cl, GLbyte *pc) ;
-int ephyrGLXClientInfo(__GLXclientState *cl, GLbyte *pc) ;
-int ephyrGLXClientInfoSwap(__GLXclientState *cl, GLbyte *pc) ;
-int ephyrGLXQueryServerString(__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXQueryServerStringSwap(__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXGetFBConfigsSGIX (__GLXclientState *a_cl, GLbyte *a_pc);
-int ephyrGLXGetFBConfigsSGIXSwap (__GLXclientState *a_cl, GLbyte *a_pc);
-int ephyrGLXCreateContext (__GLXclientState *a_cl, GLbyte *a_pc);
-int ephyrGLXCreateContextSwap (__GLXclientState *a_cl, GLbyte *a_pc);
-int ephyrGLXDestroyContext (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXDestroyContextSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXMakeCurrent (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXMakeCurrentSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXGetString (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXGetStringSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXGetIntegerv (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXGetIntegervSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXIsDirect (__GLXclientState *a_cl, GLbyte *a_pc) ;
-int ephyrGLXIsDirectSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
+int ephyrGLXQueryVersion(__GLXclientState * cl, GLbyte * pc);
+int ephyrGLXQueryVersionSwap(__GLXclientState * cl, GLbyte * pc);
+int ephyrGLXGetVisualConfigs(__GLXclientState * cl, GLbyte * pc);
+int ephyrGLXGetVisualConfigsSwap(__GLXclientState * cl, GLbyte * pc);
+int ephyrGLXClientInfo(__GLXclientState * cl, GLbyte * pc);
+int ephyrGLXClientInfoSwap(__GLXclientState * cl, GLbyte * pc);
+int ephyrGLXQueryServerString(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXQueryServerStringSwap(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXGetFBConfigsSGIX(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXGetFBConfigsSGIXSwap(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXCreateContext(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXCreateContextSwap(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXDestroyContext(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXDestroyContextSwap(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXMakeCurrent(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXMakeCurrentSwap(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXGetString(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXGetStringSwap(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXGetIntegerv(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXGetIntegervSwap(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXIsDirect(__GLXclientState * a_cl, GLbyte * a_pc);
+int ephyrGLXIsDirectSwap(__GLXclientState * a_cl, GLbyte * a_pc);
 
 Bool
-ephyrHijackGLXExtension (void)
+ephyrHijackGLXExtension(void)
 {
     const void *(*dispatch_functions)[2];
 
-    if (!hostx_has_glx ()) {
-        EPHYR_LOG ("host X does not have GLX\n") ;
-        return FALSE ;
+    if (!hostx_has_glx()) {
+        EPHYR_LOG("host X does not have GLX\n");
+        return FALSE;
     }
-    EPHYR_LOG ("host X does have GLX\n") ;
+    EPHYR_LOG("host X does have GLX\n");
 
     if (!Single_dispatch_info.dispatch_functions) {
-        EPHYR_LOG_ERROR ("could not get dispatch functions table\n") ;
-        return FALSE ;
+        EPHYR_LOG_ERROR("could not get dispatch functions table\n");
+        return FALSE;
     }
     /*
      * hijack some single entry point dispatch functions
      */
-    dispatch_functions = Single_dispatch_info.dispatch_functions ;
-    EPHYR_RETURN_VAL_IF_FAIL (dispatch_functions, FALSE) ;
+    dispatch_functions = Single_dispatch_info.dispatch_functions;
+    EPHYR_RETURN_VAL_IF_FAIL(dispatch_functions, FALSE);
 
-    dispatch_functions[X_GLXQueryVersion][0] = ephyrGLXQueryVersion ;
-    dispatch_functions[X_GLXQueryVersion][1] = ephyrGLXQueryVersionSwap ;
+    dispatch_functions[X_GLXQueryVersion][0] = ephyrGLXQueryVersion;
+    dispatch_functions[X_GLXQueryVersion][1] = ephyrGLXQueryVersionSwap;
 
-    dispatch_functions[X_GLXGetVisualConfigs][0] = ephyrGLXGetVisualConfigs ;
-    dispatch_functions[X_GLXGetVisualConfigs][1] = ephyrGLXGetVisualConfigsSwap ;
-    dispatch_functions[X_GLXClientInfo][0] = ephyrGLXClientInfo ;
-    dispatch_functions[X_GLXClientInfo][1] = ephyrGLXClientInfoSwap ;
+    dispatch_functions[X_GLXGetVisualConfigs][0] = ephyrGLXGetVisualConfigs;
+    dispatch_functions[X_GLXGetVisualConfigs][1] = ephyrGLXGetVisualConfigsSwap;
+    dispatch_functions[X_GLXClientInfo][0] = ephyrGLXClientInfo;
+    dispatch_functions[X_GLXClientInfo][1] = ephyrGLXClientInfoSwap;
 
-    dispatch_functions[X_GLXQueryServerString][0] = ephyrGLXQueryServerString ;
+    dispatch_functions[X_GLXQueryServerString][0] = ephyrGLXQueryServerString;
     dispatch_functions[X_GLXQueryServerString][1] =
-                                                ephyrGLXQueryServerStringSwap ;
+        ephyrGLXQueryServerStringSwap;
 
-    dispatch_functions[X_GLXCreateContext][0] = ephyrGLXCreateContext ;
-    dispatch_functions[X_GLXCreateContext][1] = ephyrGLXCreateContextSwap ;
+    dispatch_functions[X_GLXCreateContext][0] = ephyrGLXCreateContext;
+    dispatch_functions[X_GLXCreateContext][1] = ephyrGLXCreateContextSwap;
 
-    dispatch_functions[X_GLXDestroyContext][0] = ephyrGLXDestroyContext ;
-    dispatch_functions[X_GLXDestroyContext][1] = ephyrGLXDestroyContextSwap ;
+    dispatch_functions[X_GLXDestroyContext][0] = ephyrGLXDestroyContext;
+    dispatch_functions[X_GLXDestroyContext][1] = ephyrGLXDestroyContextSwap;
 
-    dispatch_functions[X_GLXMakeCurrent][0] = ephyrGLXMakeCurrent ;
-    dispatch_functions[X_GLXMakeCurrent][1] = ephyrGLXMakeCurrentSwap ;
+    dispatch_functions[X_GLXMakeCurrent][0] = ephyrGLXMakeCurrent;
+    dispatch_functions[X_GLXMakeCurrent][1] = ephyrGLXMakeCurrentSwap;
 
-    dispatch_functions[X_GLXIsDirect][0] = ephyrGLXIsDirect ;
-    dispatch_functions[X_GLXIsDirect][1] = ephyrGLXIsDirectSwap ;
+    dispatch_functions[X_GLXIsDirect][0] = ephyrGLXIsDirect;
+    dispatch_functions[X_GLXIsDirect][1] = ephyrGLXIsDirectSwap;
 
-    dispatch_functions[73][0] = ephyrGLXGetString ;
-    dispatch_functions[73][1] = ephyrGLXGetStringSwap ;
+    dispatch_functions[73][0] = ephyrGLXGetString;
+    dispatch_functions[73][1] = ephyrGLXGetStringSwap;
 
-    dispatch_functions[61][0] = ephyrGLXGetIntegerv ;
-    dispatch_functions[61][1] = ephyrGLXGetIntegervSwap ;
+    dispatch_functions[61][0] = ephyrGLXGetIntegerv;
+    dispatch_functions[61][1] = ephyrGLXGetIntegervSwap;
 
     /*
      * hijack some vendor priv entry point dispatch functions
      */
-    dispatch_functions = VendorPriv_dispatch_info.dispatch_functions ;
+    dispatch_functions = VendorPriv_dispatch_info.dispatch_functions;
     dispatch_functions[92][0] = ephyrGLXGetFBConfigsSGIX;
     dispatch_functions[92][1] = ephyrGLXGetFBConfigsSGIXSwap;
-    EPHYR_LOG ("hijacked glx entry points to forward requests to host X\n") ;
+    EPHYR_LOG("hijacked glx entry points to forward requests to host X\n");
 
-    return TRUE ;
+    return TRUE;
 }
 
 /*********************
@@ -143,85 +141,83 @@ ephyrHijackGLXExtension (void)
  ********************/
 
 int
-ephyrGLXQueryVersion(__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXQueryVersion(__GLXclientState * a_cl, GLbyte * a_pc)
 {
     ClientPtr client = a_cl->client;
     xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) a_pc;
     xGLXQueryVersionReply reply;
     int major, minor;
-    int res = BadImplementation ;
+    int res = BadImplementation;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    major = req->majorVersion ;
-    minor = req->minorVersion ;
+    major = req->majorVersion;
+    minor = req->minorVersion;
 
-    if (!ephyrHostGLXQueryVersion (&major, &minor)) {
-        EPHYR_LOG_ERROR ("ephyrHostGLXQueryVersion() failed\n") ;
-        goto out ;
+    if (!ephyrHostGLXQueryVersion(&major, &minor)) {
+        EPHYR_LOG_ERROR("ephyrHostGLXQueryVersion() failed\n");
+        goto out;
     }
-    EPHYR_LOG ("major:%d, minor:%d\n",
-                major, minor);
-    reply.majorVersion = major ;
-    reply.minorVersion = minor ;
-    reply.length = 0 ;
-    reply.type = X_Reply ;
-    reply.sequenceNumber = client->sequence ;
+    EPHYR_LOG("major:%d, minor:%d\n", major, minor);
+    reply.majorVersion = major;
+    reply.minorVersion = minor;
+    reply.length = 0;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
 
     if (client->swapped) {
         __glXSwapQueryVersionReply(client, &reply);
-    } else {
-        WriteToClient(client, sz_xGLXQueryVersionReply, (char *)&reply);
+    }
+    else {
+        WriteToClient(client, sz_xGLXQueryVersionReply, (char *) &reply);
     }
 
-    res = Success ;
-out:
-    EPHYR_LOG ("leave\n") ;
+    res = Success;
+ out:
+    EPHYR_LOG("leave\n");
     return res;
 }
 
 int
-ephyrGLXQueryVersionSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXQueryVersionSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
     xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) a_pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
-    __GLX_SWAP_SHORT (&req->length);
-    __GLX_SWAP_INT (&req->majorVersion);
-    __GLX_SWAP_INT (&req->minorVersion);
-    return ephyrGLXQueryVersion (a_cl, a_pc) ;
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->majorVersion);
+    __GLX_SWAP_INT(&req->minorVersion);
+    return ephyrGLXQueryVersion(a_cl, a_pc);
 }
 
 static int
-ephyrGLXGetVisualConfigsReal (__GLXclientState *a_cl,
-                              GLbyte *a_pc,
-                              Bool a_do_swap)
+ephyrGLXGetVisualConfigsReal(__GLXclientState * a_cl,
+                             GLbyte * a_pc, Bool a_do_swap)
 {
     xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) a_pc;
     ClientPtr client = a_cl->client;
     xGLXGetVisualConfigsReply reply;
-    int32_t *props_buf=NULL, num_visuals=0,
-            num_props=0, res=BadImplementation, i=0,
-            props_per_visual_size=0,
-            props_buf_size=0;
+    int32_t *props_buf = NULL, num_visuals = 0,
+        num_props = 0, res = BadImplementation, i = 0,
+        props_per_visual_size = 0, props_buf_size = 0;
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    if (!ephyrHostGLXGetVisualConfigs (req->screen,
-                                       &num_visuals,
-                                       &num_props,
-                                       &props_buf_size,
-                                       &props_buf)) {
-        EPHYR_LOG_ERROR ("ephyrHostGLXGetVisualConfigs() failed\n") ;
-        goto out ;
+    if (!ephyrHostGLXGetVisualConfigs(req->screen,
+                                      &num_visuals,
+                                      &num_props,
+                                      &props_buf_size, &props_buf)) {
+        EPHYR_LOG_ERROR("ephyrHostGLXGetVisualConfigs() failed\n");
+        goto out;
     }
-    EPHYR_LOG ("num_visuals:%d, num_props:%d\n", num_visuals, num_props) ;
+    EPHYR_LOG("num_visuals:%d, num_props:%d\n", num_visuals, num_props);
 
     reply.numVisuals = num_visuals;
     reply.numProps = num_props;
-    reply.length = (num_visuals *__GLX_SIZE_CARD32 * num_props) >> 2;
+    reply.length = (num_visuals * __GLX_SIZE_CARD32 * num_props) >> 2;
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
 
@@ -230,51 +226,48 @@ ephyrGLXGetVisualConfigsReal (__GLXclientState *a_cl,
         __GLX_SWAP_INT(&reply.length);
         __GLX_SWAP_INT(&reply.numVisuals);
         __GLX_SWAP_INT(&reply.numProps);
-        __GLX_SWAP_INT_ARRAY (props_buf, num_props) ;
+        __GLX_SWAP_INT_ARRAY(props_buf, num_props);
     }
-    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char*)&reply);
-    props_per_visual_size = props_buf_size/num_visuals ;
-    for (i=0; i < num_visuals; i++) {
-        WriteToClient (client,
-                       props_per_visual_size,
-                       (char*)props_buf +i*props_per_visual_size);
+    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
+    props_per_visual_size = props_buf_size / num_visuals;
+    for (i = 0; i < num_visuals; i++) {
+        WriteToClient(client,
+                      props_per_visual_size,
+                      (char *) props_buf + i * props_per_visual_size);
     }
-    res = Success ;
+    res = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    free(props_buf) ;
-    props_buf = NULL ;
+ out:
+    EPHYR_LOG("leave\n");
+    free(props_buf);
+    props_buf = NULL;
 
-    return res ;
+    return res;
 }
 
 static int
-ephyrGLXGetFBConfigsSGIXReal (__GLXclientState *a_cl,
-                              GLbyte *a_pc,
-                              Bool a_do_swap)
+ephyrGLXGetFBConfigsSGIXReal(__GLXclientState * a_cl,
+                             GLbyte * a_pc, Bool a_do_swap)
 {
-    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)a_pc;
+    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) a_pc;
     ClientPtr client = a_cl->client;
     xGLXGetVisualConfigsReply reply;
-    int32_t *props_buf=NULL, num_visuals=0,
-            num_props=0, res=BadImplementation, i=0,
-            props_per_visual_size=0,
-            props_buf_size=0;
+    int32_t *props_buf = NULL, num_visuals = 0,
+        num_props = 0, res = BadImplementation, i = 0,
+        props_per_visual_size = 0, props_buf_size = 0;
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    if (!ephyrHostGLXVendorPrivGetFBConfigsSGIX (req->screen,
-                                                 &num_visuals,
-                                                 &num_props,
-                                                 &props_buf_size,
-                                                 &props_buf)) {
-        EPHYR_LOG_ERROR ("ephyrHostGLXGetVisualConfigs() failed\n") ;
-        goto out ;
+    if (!ephyrHostGLXVendorPrivGetFBConfigsSGIX(req->screen,
+                                                &num_visuals,
+                                                &num_props,
+                                                &props_buf_size, &props_buf)) {
+        EPHYR_LOG_ERROR("ephyrHostGLXGetVisualConfigs() failed\n");
+        goto out;
     }
-    EPHYR_LOG ("num_visuals:%d, num_props:%d\n", num_visuals, num_props) ;
+    EPHYR_LOG("num_visuals:%d, num_props:%d\n", num_visuals, num_props);
 
     reply.numVisuals = num_visuals;
     reply.numProps = num_props;
@@ -287,146 +280,146 @@ ephyrGLXGetFBConfigsSGIXReal (__GLXclientState *a_cl,
         __GLX_SWAP_INT(&reply.length);
         __GLX_SWAP_INT(&reply.numVisuals);
         __GLX_SWAP_INT(&reply.numProps);
-        __GLX_SWAP_INT_ARRAY (props_buf, num_props) ;
+        __GLX_SWAP_INT_ARRAY(props_buf, num_props);
     }
-    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char*)&reply);
-    props_per_visual_size = props_buf_size/num_visuals ;
-    for (i=0; i < num_visuals; i++) {
-        WriteToClient (client,
-                       props_per_visual_size,
-                       &((char*)props_buf)[i*props_per_visual_size]);
+    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
+    props_per_visual_size = props_buf_size / num_visuals;
+    for (i = 0; i < num_visuals; i++) {
+        WriteToClient(client,
+                      props_per_visual_size,
+                      &((char *) props_buf)[i * props_per_visual_size]);
     }
-    res = Success ;
+    res = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    free(props_buf) ;
-    props_buf = NULL ;
+ out:
+    EPHYR_LOG("leave\n");
+    free(props_buf);
+    props_buf = NULL;
 
-    return res ;
+    return res;
 }
 
 int
-ephyrGLXGetVisualConfigs (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetVisualConfigs(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetVisualConfigsReal (a_cl, a_pc, FALSE) ;
+    return ephyrGLXGetVisualConfigsReal(a_cl, a_pc, FALSE);
 }
 
 int
-ephyrGLXGetVisualConfigsSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetVisualConfigsSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetVisualConfigsReal (a_cl, a_pc, TRUE) ;
+    return ephyrGLXGetVisualConfigsReal(a_cl, a_pc, TRUE);
 }
 
-
 int
-ephyrGLXClientInfo(__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXClientInfo(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    int res=BadImplementation ;
+    int res = BadImplementation;
     xGLXClientInfoReq *req = (xGLXClientInfoReq *) a_pc;
 
-    EPHYR_LOG ("enter\n") ;
-    if (!ephyrHostGLXSendClientInfo (req->major, req->minor, (char*)req+1)) {
-        EPHYR_LOG_ERROR ("failed to send client info to host\n") ;
-        goto out ;
+    EPHYR_LOG("enter\n");
+    if (!ephyrHostGLXSendClientInfo(req->major, req->minor, (char *) req + 1)) {
+        EPHYR_LOG_ERROR("failed to send client info to host\n");
+        goto out;
     }
-    res = Success ;
+    res = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 int
-ephyrGLXClientInfoSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXClientInfoSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    xGLXClientInfoReq *req = (xGLXClientInfoReq *)a_pc;
+    xGLXClientInfoReq *req = (xGLXClientInfoReq *) a_pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
-    __GLX_SWAP_SHORT (&req->length);
-    __GLX_SWAP_INT (&req->major);
-    __GLX_SWAP_INT (&req->minor);
-    __GLX_SWAP_INT (&req->numbytes);
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->major);
+    __GLX_SWAP_INT(&req->minor);
+    __GLX_SWAP_INT(&req->numbytes);
 
-    return ephyrGLXClientInfo (a_cl, a_pc) ;
+    return ephyrGLXClientInfo(a_cl, a_pc);
 }
 
 int
-ephyrGLXQueryServerString(__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXQueryServerString(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    int res = BadImplementation ;
+    int res = BadImplementation;
     ClientPtr client = a_cl->client;
     xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) a_pc;
     xGLXQueryServerStringReply reply;
-    char *server_string=NULL, *buf=NULL;
-    int length=0 ;
-
-    EPHYR_LOG ("enter\n") ;
-    if (!ephyrHostGLXGetStringFromServer (req->screen,
-                                          req->name,
-                                          EPHYR_HOST_GLX_QueryServerString,
-                                          &server_string)) {
-        EPHYR_LOG_ERROR ("failed to query string from host\n") ;
-        goto out ;
+    char *server_string = NULL, *buf = NULL;
+    int length = 0;
+
+    EPHYR_LOG("enter\n");
+    if (!ephyrHostGLXGetStringFromServer(req->screen,
+                                         req->name,
+                                         EPHYR_HOST_GLX_QueryServerString,
+                                         &server_string)) {
+        EPHYR_LOG_ERROR("failed to query string from host\n");
+        goto out;
     }
-    EPHYR_LOG ("string: %s\n", server_string) ;
-    length= strlen (server_string) + 1;
-    reply.type = X_Reply ;
-    reply.sequenceNumber = client->sequence ;
-    reply.length = __GLX_PAD (length) >> 2 ;
-    reply.n = length ;
+    EPHYR_LOG("string: %s\n", server_string);
+    length = strlen(server_string) + 1;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.length = __GLX_PAD(length) >> 2;
+    reply.n = length;
     buf = calloc(reply.length << 2, 1);
     if (!buf) {
-        EPHYR_LOG_ERROR ("failed to allocate string\n;");
+        EPHYR_LOG_ERROR("failed to allocate string\n;");
         return BadAlloc;
     }
-    memcpy (buf, server_string, length);
+    memcpy(buf, server_string, length);
 
-    WriteToClient(client, sz_xGLXQueryServerStringReply, (char*)&reply);
-    WriteToClient(client, (int)(reply.length << 2), server_string);
+    WriteToClient(client, sz_xGLXQueryServerStringReply, (char *) &reply);
+    WriteToClient(client, (int) (reply.length << 2), server_string);
 
-    res = Success ;
+    res = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    free(server_string) ;
+ out:
+    EPHYR_LOG("leave\n");
+    free(server_string);
     server_string = NULL;
 
     free(buf);
     buf = NULL;
 
-    return res ;
+    return res;
 }
 
 int
-ephyrGLXQueryServerStringSwap(__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXQueryServerStringSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    EPHYR_LOG_ERROR ("not yet implemented\n") ;
-    return BadImplementation ;
+    EPHYR_LOG_ERROR("not yet implemented\n");
+    return BadImplementation;
 }
 
-
 int
-ephyrGLXGetFBConfigsSGIX (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetFBConfigsSGIX(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetFBConfigsSGIXReal (a_cl, a_pc, FALSE) ;
+    return ephyrGLXGetFBConfigsSGIXReal(a_cl, a_pc, FALSE);
 }
 
 int
-ephyrGLXGetFBConfigsSGIXSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetFBConfigsSGIXSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetFBConfigsSGIXReal (a_cl, a_pc, TRUE) ;
+    return ephyrGLXGetFBConfigsSGIXReal(a_cl, a_pc, TRUE);
 }
 
 static int
-ephyrGLXCreateContextReal (xGLXCreateContextReq *a_req, Bool a_do_swap)
+ephyrGLXCreateContextReal(xGLXCreateContextReq * a_req, Bool a_do_swap)
 {
-    int res=BadImplementation;
-    EphyrHostWindowAttributes host_w_attrs ;
+    int res = BadImplementation;
+    EphyrHostWindowAttributes host_w_attrs;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_req, BadValue) ;
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_req, BadValue);
+    EPHYR_LOG("enter\n");
 
     if (a_do_swap) {
         __GLX_SWAP_SHORT(&a_req->length);
@@ -436,108 +429,104 @@ ephyrGLXCreateContextReal (xGLXCreateContextReq *a_req, Bool a_do_swap)
         __GLX_SWAP_INT(&a_req->shareList);
     }
 
-    EPHYR_LOG ("context creation requested. localid:%d, "
-               "screen:%d, visual:%d, direct:%d\n",
-               (int)a_req->context, (int)a_req->screen,
-               (int)a_req->visual, (int)a_req->isDirect) ;
+    EPHYR_LOG("context creation requested. localid:%d, "
+              "screen:%d, visual:%d, direct:%d\n",
+              (int) a_req->context, (int) a_req->screen,
+              (int) a_req->visual, (int) a_req->isDirect);
 
-    memset (&host_w_attrs, 0, sizeof (host_w_attrs)) ;
-    if (!hostx_get_window_attributes (hostx_get_window (a_req->screen),
-                                      &host_w_attrs)) {
-        EPHYR_LOG_ERROR ("failed to get host window attrs\n") ;
-        goto out ;
+    memset(&host_w_attrs, 0, sizeof(host_w_attrs));
+    if (!hostx_get_window_attributes(hostx_get_window(a_req->screen),
+                                     &host_w_attrs)) {
+        EPHYR_LOG_ERROR("failed to get host window attrs\n");
+        goto out;
     }
 
-    EPHYR_LOG ("host window visual id: %d\n", host_w_attrs.visualid) ;
+    EPHYR_LOG("host window visual id: %d\n", host_w_attrs.visualid);
 
-    if (!ephyrHostGLXCreateContext (a_req->screen,
-                                    host_w_attrs.visualid,
-                                    a_req->context,
-                                    a_req->shareList,
-                                    a_req->isDirect)) {
-        EPHYR_LOG_ERROR ("ephyrHostGLXCreateContext() failed\n") ;
-        goto out ;
+    if (!ephyrHostGLXCreateContext(a_req->screen,
+                                   host_w_attrs.visualid,
+                                   a_req->context,
+                                   a_req->shareList, a_req->isDirect)) {
+        EPHYR_LOG_ERROR("ephyrHostGLXCreateContext() failed\n");
+        goto out;
     }
     res = Success;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 int
-ephyrGLXCreateContext (__GLXclientState *cl, GLbyte *pc)
+ephyrGLXCreateContext(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
 
-    return ephyrGLXCreateContextReal (req, FALSE) ;
+    return ephyrGLXCreateContextReal(req, FALSE);
 }
 
-int ephyrGLXCreateContextSwap (__GLXclientState *cl, GLbyte *pc)
+int
+ephyrGLXCreateContextSwap(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
-    return ephyrGLXCreateContextReal (req, TRUE) ;
+
+    return ephyrGLXCreateContextReal(req, TRUE);
 }
 
 static int
-ephyrGLXDestroyContextReal (__GLXclientState *a_cl,
-                            GLbyte *a_pc,
-                            Bool a_do_swap)
+ephyrGLXDestroyContextReal(__GLXclientState * a_cl,
+                           GLbyte * a_pc, Bool a_do_swap)
 {
-    int res=BadImplementation;
+    int res = BadImplementation;
     ClientPtr client = a_cl->client;
     xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) a_pc;
 
-    EPHYR_LOG ("enter. id:%d\n", (int)req->context) ;
-    if (!ephyrHostDestroyContext (req->context)) {
-        EPHYR_LOG_ERROR ("ephyrHostDestroyContext() failed\n") ;
-        client->errorValue = req->context ;
-        goto out ;
+    EPHYR_LOG("enter. id:%d\n", (int) req->context);
+    if (!ephyrHostDestroyContext(req->context)) {
+        EPHYR_LOG_ERROR("ephyrHostDestroyContext() failed\n");
+        client->errorValue = req->context;
+        goto out;
     }
-    res = Success ;
+    res = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 int
-ephyrGLXDestroyContext (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXDestroyContext(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXDestroyContextReal (a_cl, a_pc, FALSE) ;
+    return ephyrGLXDestroyContextReal(a_cl, a_pc, FALSE);
 }
 
 int
-ephyrGLXDestroyContextSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXDestroyContextSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXDestroyContextReal (a_cl, a_pc, TRUE) ;
+    return ephyrGLXDestroyContextReal(a_cl, a_pc, TRUE);
 }
 
 static int
-ephyrGLXMakeCurrentReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
+ephyrGLXMakeCurrentReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap)
 {
-    int res=BadImplementation;
+    int res = BadImplementation;
     xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) a_pc;
-    xGLXMakeCurrentReply reply ;
-    DrawablePtr drawable=NULL;
-    int rc=0;
-
-    EPHYR_LOG ("enter\n") ;
-    rc = dixLookupDrawable (&drawable,
-                            req->drawable,
-                            a_cl->client,
-                            0,
-                            DixReadAccess);
-    EPHYR_RETURN_VAL_IF_FAIL (drawable, BadValue) ;
-    EPHYR_RETURN_VAL_IF_FAIL (drawable->pScreen, BadValue) ;
-    EPHYR_LOG ("screen nummber requested:%d\n",
-               drawable->pScreen->myNum) ;
-
-    memset (&reply, 0, sizeof (reply)) ;
-    if (!ephyrHostGLXMakeCurrent (hostx_get_window (drawable->pScreen->myNum),
-                                  req->context,
-                                  req->oldContextTag,
-                                  (int*)&reply.contextTag)) {
-        EPHYR_LOG_ERROR ("ephyrHostGLXMakeCurrent() failed\n") ;
+    xGLXMakeCurrentReply reply;
+    DrawablePtr drawable = NULL;
+    int rc = 0;
+
+    EPHYR_LOG("enter\n");
+    rc = dixLookupDrawable(&drawable,
+                           req->drawable, a_cl->client, 0, DixReadAccess);
+    EPHYR_RETURN_VAL_IF_FAIL(drawable, BadValue);
+    EPHYR_RETURN_VAL_IF_FAIL(drawable->pScreen, BadValue);
+    EPHYR_LOG("screen nummber requested:%d\n", drawable->pScreen->myNum);
+
+    memset(&reply, 0, sizeof(reply));
+    if (!ephyrHostGLXMakeCurrent(hostx_get_window(drawable->pScreen->myNum),
+                                 req->context,
+                                 req->oldContextTag,
+                                 (int *) &reply.contextTag)) {
+        EPHYR_LOG_ERROR("ephyrHostGLXMakeCurrent() failed\n");
         goto out;
     }
     reply.length = 0;
@@ -549,175 +538,174 @@ ephyrGLXMakeCurrentReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
         __GLX_SWAP_INT(&reply.length);
         __GLX_SWAP_INT(&reply.contextTag);
     }
-    WriteToClient(a_cl->client, sz_xGLXMakeCurrentReply, (char *)&reply);
+    WriteToClient(a_cl->client, sz_xGLXMakeCurrentReply, (char *) &reply);
 
-    res = Success ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+    res = Success;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 int
-ephyrGLXMakeCurrent (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXMakeCurrent(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXMakeCurrentReal (a_cl, a_pc, FALSE) ;
+    return ephyrGLXMakeCurrentReal(a_cl, a_pc, FALSE);
 }
 
 int
-ephyrGLXMakeCurrentSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXMakeCurrentSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXMakeCurrentReal (a_cl, a_pc, TRUE) ;
+    return ephyrGLXMakeCurrentReal(a_cl, a_pc, TRUE);
 }
 
 static int
-ephyrGLXGetStringReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
+ephyrGLXGetStringReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap)
 {
-    ClientPtr client=NULL ;
-    int context_tag=0, name=0, res=BadImplementation, length=0 ;
-    char *string=NULL;
+    ClientPtr client = NULL;
+    int context_tag = 0, name = 0, res = BadImplementation, length = 0;
+    char *string = NULL;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, BadValue) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_cl && a_pc, BadValue);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    client = a_cl->client ;
+    client = a_cl->client;
 
     if (a_do_swap) {
-        __GLX_SWAP_INT (a_pc + 4);
-        __GLX_SWAP_INT (a_pc + __GLX_SINGLE_HDR_SIZE);
+        __GLX_SWAP_INT(a_pc + 4);
+        __GLX_SWAP_INT(a_pc + __GLX_SINGLE_HDR_SIZE);
     }
-    context_tag = __GLX_GET_SINGLE_CONTEXT_TAG (a_pc) ;
+    context_tag = __GLX_GET_SINGLE_CONTEXT_TAG(a_pc);
     a_pc += __GLX_SINGLE_HDR_SIZE;
-    name = *(GLenum*)(a_pc + 0);
-    EPHYR_LOG ("context_tag:%d, name:%d\n", context_tag, name) ;
-    if (!ephyrHostGLXGetStringFromServer (context_tag,
-                                          name,
-                                          EPHYR_HOST_GLX_GetString,
-                                          &string)) {
-        EPHYR_LOG_ERROR ("failed to get string from server\n") ;
-        goto out ;
+    name = *(GLenum *) (a_pc + 0);
+    EPHYR_LOG("context_tag:%d, name:%d\n", context_tag, name);
+    if (!ephyrHostGLXGetStringFromServer(context_tag,
+                                         name,
+                                         EPHYR_HOST_GLX_GetString, &string)) {
+        EPHYR_LOG_ERROR("failed to get string from server\n");
+        goto out;
     }
     if (string) {
-        length = strlen (string) + 1;
-        EPHYR_LOG ("got string:'%s', size:%d\n", string, length) ;
-    } else {
-        EPHYR_LOG ("got string: string (null)\n") ;
+        length = strlen(string) + 1;
+        EPHYR_LOG("got string:'%s', size:%d\n", string, length);
+    }
+    else {
+        EPHYR_LOG("got string: string (null)\n");
     }
-    __GLX_BEGIN_REPLY (length);
-    __GLX_PUT_SIZE (length);
-    __GLX_SEND_HEADER ();
+    __GLX_BEGIN_REPLY(length);
+    __GLX_PUT_SIZE(length);
+    __GLX_SEND_HEADER();
     if (a_do_swap) {
-        __GLX_SWAP_REPLY_SIZE ();
-        __GLX_SWAP_REPLY_HEADER ();
+        __GLX_SWAP_REPLY_SIZE();
+        __GLX_SWAP_REPLY_HEADER();
     }
-    WriteToClient (client, length, (char *)string);
+    WriteToClient(client, length, (char *) string);
 
-    res = Success ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+    res = Success;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 int
-ephyrGLXGetString (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetString(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetStringReal (a_cl, a_pc, FALSE) ;
+    return ephyrGLXGetStringReal(a_cl, a_pc, FALSE);
 }
 
 int
-ephyrGLXGetStringSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetStringSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetStringReal (a_cl, a_pc, TRUE) ;
+    return ephyrGLXGetStringReal(a_cl, a_pc, TRUE);
 }
 
 static int
-ephyrGLXGetIntegervReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
+ephyrGLXGetIntegervReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap)
 {
-    int res=BadImplementation;
-    xGLXSingleReq * const req = (xGLXSingleReq *) a_pc;
-    GLenum int_name ;
-    int value=0 ;
+    int res = BadImplementation;
+    xGLXSingleReq *const req = (xGLXSingleReq *) a_pc;
+    GLenum int_name;
+    int value = 0;
     GLint answer_buf_room[200];
-    GLint *buf=NULL ;
+    GLint *buf = NULL;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     a_pc += __GLX_SINGLE_HDR_SIZE;
 
-    int_name = *(GLenum*) (a_pc+0) ;
-    if (!ephyrHostGetIntegerValue (req->contextTag, int_name, &value)) {
-        EPHYR_LOG_ERROR ("ephyrHostGetIntegerValue() failed\n") ;
-        goto out ;
+    int_name = *(GLenum *) (a_pc + 0);
+    if (!ephyrHostGetIntegerValue(req->contextTag, int_name, &value)) {
+        EPHYR_LOG_ERROR("ephyrHostGetIntegerValue() failed\n");
+        goto out;
     }
-    buf = __glXGetAnswerBuffer (a_cl, sizeof (value),
-                                answer_buf_room,
-                                sizeof (answer_buf_room),
-                                4) ;
+    buf = __glXGetAnswerBuffer(a_cl, sizeof(value),
+                               answer_buf_room, sizeof(answer_buf_room), 4);
 
     if (!buf) {
-        EPHYR_LOG_ERROR ("failed to allocate reply buffer\n") ;
-        res = BadAlloc ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to allocate reply buffer\n");
+        res = BadAlloc;
+        goto out;
     }
-    __glXSendReply (a_cl->client, buf, 1, sizeof (value), GL_FALSE, 0) ;
-    res = Success ;
+    __glXSendReply(a_cl->client, buf, 1, sizeof(value), GL_FALSE, 0);
+    res = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 int
-ephyrGLXGetIntegerv (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetIntegerv(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetIntegervReal (a_cl, a_pc, FALSE) ;
+    return ephyrGLXGetIntegervReal(a_cl, a_pc, FALSE);
 }
 
 int
-ephyrGLXGetIntegervSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXGetIntegervSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXGetIntegervReal (a_cl, a_pc, TRUE) ;
+    return ephyrGLXGetIntegervReal(a_cl, a_pc, TRUE);
 }
 
 static int
-ephyrGLXIsDirectReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
+ephyrGLXIsDirectReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap)
 {
-    int res=BadImplementation;
+    int res = BadImplementation;
     ClientPtr client = a_cl->client;
     xGLXIsDirectReq *req = (xGLXIsDirectReq *) a_pc;
     xGLXIsDirectReply reply;
-    int is_direct=0 ;
+    int is_direct = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_cl && a_pc, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    memset (&reply, 0, sizeof (reply)) ;
-    if (!ephyrHostIsContextDirect (req->context, (int*)&is_direct)) {
-        EPHYR_LOG_ERROR ("ephyrHostIsContextDirect() failed\n") ;
-        goto out ;
+    memset(&reply, 0, sizeof(reply));
+    if (!ephyrHostIsContextDirect(req->context, (int *) &is_direct)) {
+        EPHYR_LOG_ERROR("ephyrHostIsContextDirect() failed\n");
+        goto out;
     }
-    reply.isDirect = is_direct ;
+    reply.isDirect = is_direct;
     reply.length = 0;
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
-    WriteToClient(client, sz_xGLXIsDirectReply, (char *)&reply);
-    res = Success ;
+    WriteToClient(client, sz_xGLXIsDirectReply, (char *) &reply);
+    res = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 int
-ephyrGLXIsDirect (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXIsDirect(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXIsDirectReal (a_cl, a_pc, FALSE) ;
+    return ephyrGLXIsDirectReal(a_cl, a_pc, FALSE);
 }
 
 int
-ephyrGLXIsDirectSwap (__GLXclientState *a_cl, GLbyte *a_pc)
+ephyrGLXIsDirectSwap(__GLXclientState * a_cl, GLbyte * a_pc)
 {
-    return ephyrGLXIsDirectReal (a_cl, a_pc, TRUE) ;
+    return ephyrGLXIsDirectReal(a_cl, a_pc, TRUE);
 }
diff --git a/hw/kdrive/ephyr/ephyrglxext.h b/hw/kdrive/ephyr/ephyrglxext.h
index 22ea605d7..053f8d303 100644
--- a/hw/kdrive/ephyr/ephyrglxext.h
+++ b/hw/kdrive/ephyr/ephyrglxext.h
@@ -29,7 +29,6 @@
 #define __EPHYR_GLXEXT_H__
 
 #include <X11/Xdefs.h>
-Bool ephyrHijackGLXExtension (void) ;
+Bool ephyrHijackGLXExtension(void);
 
 #endif /*__EPHYR_GLXEXT_H__*/
-
diff --git a/hw/kdrive/ephyr/ephyrhostglx.c b/hw/kdrive/ephyr/ephyrhostglx.c
index 728687b46..6b9da6fb1 100644
--- a/hw/kdrive/ephyr/ephyrhostglx.c
+++ b/hw/kdrive/ephyr/ephyrhostglx.c
@@ -56,79 +56,76 @@ enum VisualConfRequestType {
     EPHYR_GET_FB_CONFIG,
     EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX,
     EPHYR_GET_VISUAL_CONFIGS
-
 };
 
 static Bool ephyrHostGLXGetVisualConfigsInternal
-                                        (enum VisualConfRequestType a_type,
-                                         int32_t a_screen,
-                                         int32_t *a_num_visuals,
-                                         int32_t *a_num_props,
-                                         int32_t *a_props_buf_size,
-                                         int32_t **a_props_buf);
+    (enum VisualConfRequestType a_type,
+     int32_t a_screen,
+     int32_t * a_num_visuals,
+     int32_t * a_num_props, int32_t * a_props_buf_size, int32_t ** a_props_buf);
 Bool
-ephyrHostGLXGetMajorOpcode (int *a_opcode)
+ephyrHostGLXGetMajorOpcode(int *a_opcode)
 {
-    Bool is_ok=FALSE ;
-    Display *dpy=hostx_get_display () ;
-    static int opcode ;
-    int first_event_return=0, first_error_return=0;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    static int opcode;
+    int first_event_return = 0, first_error_return = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
+    EPHYR_LOG("enter\n");
     if (!opcode) {
-        if (!XQueryExtension (dpy, GLX_EXTENSION_NAME, &opcode,
-                              &first_event_return, &first_error_return)) {
-            EPHYR_LOG_ERROR ("XQueryExtension() failed\n") ;
-            goto out ;
+        if (!XQueryExtension(dpy, GLX_EXTENSION_NAME, &opcode,
+                             &first_event_return, &first_error_return)) {
+            EPHYR_LOG_ERROR("XQueryExtension() failed\n");
+            goto out;
         }
     }
-    *a_opcode = opcode ;
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("release\n") ;
-    return is_ok ;
+    *a_opcode = opcode;
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("release\n");
+    return is_ok;
 }
 
 Bool
-ephyrHostGLXQueryVersion (int *a_major, int *a_minor)
+ephyrHostGLXQueryVersion(int *a_major, int *a_minor)
 {
-    Bool is_ok = FALSE ;
-    Display *dpy = hostx_get_display () ;
-    int major_opcode=0;
-    xGLXQueryVersionReq *req=NULL;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    int major_opcode = 0;
+    xGLXQueryVersionReq *req = NULL;
     xGLXQueryVersionReply reply;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_major && a_minor, FALSE) ;
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_major && a_minor, FALSE);
+    EPHYR_LOG("enter\n");
 
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
-    EPHYR_LOG ("major opcode: %d\n", major_opcode) ;
+    EPHYR_LOG("major opcode: %d\n", major_opcode);
 
     /* Send the glXQueryVersion request */
-    memset (&reply, 0, sizeof (reply)) ;
-    LockDisplay (dpy);
-    GetReq (GLXQueryVersion, req);
+    memset(&reply, 0, sizeof(reply));
+    LockDisplay(dpy);
+    GetReq(GLXQueryVersion, req);
     req->reqType = major_opcode;
     req->glxCode = X_GLXQueryVersion;
     req->majorVersion = 2;
     req->minorVersion = 1;
-    _XReply(dpy, (xReply*) &reply, 0, False);
-    UnlockDisplay (dpy);
-    SyncHandle ();
+    _XReply(dpy, (xReply *) & reply, 0, False);
+    UnlockDisplay(dpy);
+    SyncHandle();
 
-    *a_major = reply.majorVersion ;
-    *a_minor = reply.minorVersion ;
+    *a_major = reply.majorVersion;
+    *a_minor = reply.minorVersion;
 
-    EPHYR_LOG ("major:%d, minor:%d\n", *a_major, *a_minor) ;
+    EPHYR_LOG("major:%d, minor:%d\n", *a_major, *a_minor);
 
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 /**
@@ -154,165 +151,161 @@ typedef struct GLXGenericGetString {
 #define X_GLXGenericGetString 0
 
 Bool
-ephyrHostGLXGetStringFromServer (int a_screen_number,
-                                 int a_string_name,
-                                 enum EphyrHostGLXGetStringOps a_op,
-                                 char **a_string)
+ephyrHostGLXGetStringFromServer(int a_screen_number,
+                                int a_string_name,
+                                enum EphyrHostGLXGetStringOps a_op,
+                                char **a_string)
 {
-    Bool is_ok=FALSE ;
-    Display *dpy = hostx_get_display () ;
-    int default_screen = DefaultScreen (dpy);
-    xGLXGenericGetStringReq *req=NULL;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    int default_screen = DefaultScreen(dpy);
+    xGLXGenericGetStringReq *req = NULL;
     xGLXSingleReply reply;
-    int length=0, numbytes=0, major_opcode=0, get_string_op=0;
+    int length = 0, numbytes = 0, major_opcode = 0, get_string_op = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_string, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy && a_string, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
     switch (a_op) {
-        case EPHYR_HOST_GLX_QueryServerString:
-            get_string_op = X_GLXQueryServerString;
-            break ;
-        case EPHYR_HOST_GLX_GetString:
-            get_string_op = X_GLsop_GetString;
-            EPHYR_LOG ("Going to glXGetString. strname:%#x, ctxttag:%d\n",
-                       a_string_name, a_screen_number) ;
-            break ;
-        default:
-            EPHYR_LOG_ERROR ("unknown EphyrHostGLXGetStringOp:%d\n", a_op) ;
-            goto out ;
+    case EPHYR_HOST_GLX_QueryServerString:
+        get_string_op = X_GLXQueryServerString;
+        break;
+    case EPHYR_HOST_GLX_GetString:
+        get_string_op = X_GLsop_GetString;
+        EPHYR_LOG("Going to glXGetString. strname:%#x, ctxttag:%d\n",
+                  a_string_name, a_screen_number);
+        break;
+    default:
+        EPHYR_LOG_ERROR("unknown EphyrHostGLXGetStringOp:%d\n", a_op);
+        goto out;
     }
 
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
-    EPHYR_LOG ("major opcode: %d\n", major_opcode) ;
+    EPHYR_LOG("major opcode: %d\n", major_opcode);
 
-    LockDisplay (dpy);
+    LockDisplay(dpy);
 
     /* All of the GLX protocol requests for getting a string from the server
      * look the same.  The exact meaning of the a_for_whom field is usually
      * either the screen number (for glXQueryServerString) or the context tag
      * (for GLXSingle).
      */
-    GetReq (GLXGenericGetString, req);
+    GetReq(GLXGenericGetString, req);
     req->reqType = major_opcode;
     req->glxCode = get_string_op;
     req->for_whom = default_screen;
     req->name = a_string_name;
 
-    _XReply (dpy, (xReply *)&reply, 0, False);
+    _XReply(dpy, (xReply *) & reply, 0, False);
 
     length = reply.length * 4;
     if (!length) {
         numbytes = 0;
-    } else {
+    }
+    else {
         numbytes = reply.size;
     }
-    EPHYR_LOG ("going to get a string of size:%d\n", numbytes) ;
+    EPHYR_LOG("going to get a string of size:%d\n", numbytes);
 
-    *a_string = (char *) Xmalloc (numbytes +1);
+    *a_string = (char *) Xmalloc(numbytes + 1);
     if (!a_string) {
-        EPHYR_LOG_ERROR ("allocation failed\n") ;
+        EPHYR_LOG_ERROR("allocation failed\n");
         goto out;
     }
 
-    memset (*a_string, 0, numbytes+1) ;
-    if (_XRead (dpy, *a_string, numbytes)) {
-        UnlockDisplay (dpy);
-        SyncHandle ();
-        EPHYR_LOG_ERROR ("read failed\n") ;
-        goto out ;
+    memset(*a_string, 0, numbytes + 1);
+    if (_XRead(dpy, *a_string, numbytes)) {
+        UnlockDisplay(dpy);
+        SyncHandle();
+        EPHYR_LOG_ERROR("read failed\n");
+        goto out;
     }
     length -= numbytes;
-    _XEatData (dpy, length) ;
-    UnlockDisplay (dpy);
-    SyncHandle ();
-    EPHYR_LOG ("strname:%#x, strvalue:'%s', strlen:%d\n",
-               a_string_name, *a_string, numbytes) ;
-
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    _XEatData(dpy, length);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    EPHYR_LOG("strname:%#x, strvalue:'%s', strlen:%d\n",
+              a_string_name, *a_string, numbytes);
+
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 static Bool
-ephyrHostGLXGetVisualConfigsInternal (enum VisualConfRequestType a_type,
-                                      int32_t a_screen,
-                                      int32_t *a_num_visuals,
-                                      int32_t *a_num_props,
-                                      int32_t *a_props_buf_size,
-                                      int32_t **a_props_buf)
+ephyrHostGLXGetVisualConfigsInternal(enum VisualConfRequestType a_type,
+                                     int32_t a_screen,
+                                     int32_t * a_num_visuals,
+                                     int32_t * a_num_props,
+                                     int32_t * a_props_buf_size,
+                                     int32_t ** a_props_buf)
 {
-    Bool is_ok = FALSE ;
-    Display *dpy = hostx_get_display () ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
     xGLXGetVisualConfigsReq *req;
     xGLXGetFBConfigsReq *fb_req;
     xGLXVendorPrivateWithReplyReq *vpreq;
     xGLXGetFBConfigsSGIXReq *sgi_req;
     xGLXGetVisualConfigsReply reply;
-    char *server_glx_version=NULL,
-         *server_glx_extensions=NULL ;
-    int j=0,
-        screens=0,
-        major_opcode=0,
-        num_props=0,
-        num_visuals=0,
-        props_buf_size=0,
-        props_per_visual_size=0;
-    int32_t *props_buf=NULL;
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
-
-    screens = ScreenCount (dpy);
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get opcode\n") ;
-        goto out ;
+    char *server_glx_version = NULL, *server_glx_extensions = NULL;
+    int j = 0,
+        screens = 0,
+        major_opcode = 0,
+        num_props = 0,
+        num_visuals = 0, props_buf_size = 0, props_per_visual_size = 0;
+    int32_t *props_buf = NULL;
+
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
+
+    screens = ScreenCount(dpy);
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get opcode\n");
+        goto out;
     }
 
     LockDisplay(dpy);
     switch (a_type) {
-        case EPHYR_GET_FB_CONFIG:
-        GetReq(GLXGetFBConfigs,fb_req);
+    case EPHYR_GET_FB_CONFIG:
+        GetReq(GLXGetFBConfigs, fb_req);
         fb_req->reqType = major_opcode;
         fb_req->glxCode = X_GLXGetFBConfigs;
-        fb_req->screen = DefaultScreen (dpy);
+        fb_req->screen = DefaultScreen(dpy);
         break;
 
-        case EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX:
+    case EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX:
         GetReqExtra(GLXVendorPrivateWithReply,
                     sz_xGLXGetFBConfigsSGIXReq
-                         -
-                    sz_xGLXVendorPrivateWithReplyReq,
-                    vpreq);
+                    - sz_xGLXVendorPrivateWithReplyReq, vpreq);
         sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
         sgi_req->reqType = major_opcode;
         sgi_req->glxCode = X_GLXVendorPrivateWithReply;
         sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
-        sgi_req->screen = DefaultScreen (dpy);
+        sgi_req->screen = DefaultScreen(dpy);
         break;
 
-        case EPHYR_GET_VISUAL_CONFIGS:
-        GetReq(GLXGetVisualConfigs,req);
+    case EPHYR_GET_VISUAL_CONFIGS:
+        GetReq(GLXGetVisualConfigs, req);
         req->reqType = major_opcode;
         req->glxCode = X_GLXGetVisualConfigs;
-        req->screen = DefaultScreen (dpy);
+        req->screen = DefaultScreen(dpy);
         break;
     }
 
-    if (!_XReply(dpy, (xReply*) &reply, 0, False)) {
-        EPHYR_LOG_ERROR ("unknown error\n") ;
+    if (!_XReply(dpy, (xReply *) & reply, 0, False)) {
+        EPHYR_LOG_ERROR("unknown error\n");
         UnlockDisplay(dpy);
-        goto out ;
+        goto out;
     }
-   if (!reply.numVisuals) {
-        EPHYR_LOG_ERROR ("screen does not support GL rendering\n") ;
+    if (!reply.numVisuals) {
+        EPHYR_LOG_ERROR("screen does not support GL rendering\n");
         UnlockDisplay(dpy);
-        goto out ;
+        goto out;
     }
-   num_visuals = reply.numVisuals ;
+    num_visuals = reply.numVisuals;
 
     /* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for
      * FIXME: FBconfigs? 
@@ -322,9 +315,9 @@ ephyrHostGLXGetVisualConfigsInternal (enum VisualConfRequestType a_type,
     if ((num_props < __GLX_MIN_CONFIG_PROPS) ||
         (num_props > __GLX_MAX_CONFIG_PROPS)) {
         /* Huh?  Not in protocol defined limits.  Punt */
-        EPHYR_LOG_ERROR ("got a bad reply to request\n") ;
+        EPHYR_LOG_ERROR("got a bad reply to request\n");
         UnlockDisplay(dpy);
-        goto out ;
+        goto out;
     }
 
     if (a_type != EPHYR_GET_VISUAL_CONFIGS) {
@@ -332,250 +325,242 @@ ephyrHostGLXGetVisualConfigsInternal (enum VisualConfRequestType a_type,
     }
     props_per_visual_size = num_props * __GLX_SIZE_INT32;
     props_buf_size = props_per_visual_size * reply.numVisuals;
-    props_buf = malloc (props_buf_size) ;
+    props_buf = malloc(props_buf_size);
     for (j = 0; j < reply.numVisuals; j++) {
-        if (_XRead (dpy,
-                    &((char*)props_buf)[j*props_per_visual_size],
-                    props_per_visual_size) != Success) {
-            EPHYR_LOG_ERROR ("read failed\n") ;
+        if (_XRead(dpy,
+                   &((char *) props_buf)[j * props_per_visual_size],
+                   props_per_visual_size) != Success) {
+            EPHYR_LOG_ERROR("read failed\n");
         }
     }
     UnlockDisplay(dpy);
 
-    *a_num_visuals = num_visuals ;
-    *a_num_props = reply.numProps ;
-    *a_props_buf_size = props_buf_size ;
-    *a_props_buf = props_buf ;
-    is_ok = TRUE ;
+    *a_num_visuals = num_visuals;
+    *a_num_props = reply.numProps;
+    *a_props_buf_size = props_buf_size;
+    *a_props_buf = props_buf;
+    is_ok = TRUE;
 
-out:
+ out:
     if (server_glx_version) {
-        XFree (server_glx_version) ;
-        server_glx_version = NULL ;
+        XFree(server_glx_version);
+        server_glx_version = NULL;
     }
     if (server_glx_extensions) {
-        XFree (server_glx_extensions) ;
-        server_glx_extensions = NULL ;
+        XFree(server_glx_extensions);
+        server_glx_extensions = NULL;
     }
-    SyncHandle () ;
+    SyncHandle();
     return is_ok;
 }
 
 Bool
-ephyrHostGLXGetVisualConfigs (int32_t a_screen,
-                              int32_t *a_num_visuals,
-                              int32_t *a_num_props,
-                              int32_t *a_props_buf_size,
-                              int32_t **a_props_buf)
+ephyrHostGLXGetVisualConfigs(int32_t a_screen,
+                             int32_t * a_num_visuals,
+                             int32_t * a_num_props,
+                             int32_t * a_props_buf_size, int32_t ** a_props_buf)
 {
     Bool is_ok = FALSE;
 
-    EPHYR_LOG ("enter\n") ;
-    is_ok = ephyrHostGLXGetVisualConfigsInternal (EPHYR_GET_VISUAL_CONFIGS,
-                                                  a_screen,
-                                                  a_num_visuals,
-                                                  a_num_props,
-                                                  a_props_buf_size,
-                                                  a_props_buf) ;
+    EPHYR_LOG("enter\n");
+    is_ok = ephyrHostGLXGetVisualConfigsInternal(EPHYR_GET_VISUAL_CONFIGS,
+                                                 a_screen,
+                                                 a_num_visuals,
+                                                 a_num_props,
+                                                 a_props_buf_size, a_props_buf);
 
-    EPHYR_LOG ("leave:%d\n", is_ok) ;
+    EPHYR_LOG("leave:%d\n", is_ok);
     return is_ok;
 }
 
 Bool
-ephyrHostGLXVendorPrivGetFBConfigsSGIX (int a_screen,
-                                        int32_t *a_num_visuals,
-                                        int32_t *a_num_props,
-                                        int32_t *a_props_buf_size,
-                                        int32_t **a_props_buf)
+ephyrHostGLXVendorPrivGetFBConfigsSGIX(int a_screen,
+                                       int32_t * a_num_visuals,
+                                       int32_t * a_num_props,
+                                       int32_t * a_props_buf_size,
+                                       int32_t ** a_props_buf)
 {
-    Bool is_ok=FALSE ;
-    EPHYR_LOG ("enter\n") ;
+    Bool is_ok = FALSE;
+
+    EPHYR_LOG("enter\n");
     is_ok = ephyrHostGLXGetVisualConfigsInternal
-                                        (EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX,
-                                         a_screen,
-                                         a_num_visuals,
-                                         a_num_props,
-                                         a_props_buf_size,
-                                         a_props_buf) ;
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+        (EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX,
+         a_screen, a_num_visuals, a_num_props, a_props_buf_size, a_props_buf);
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 Bool
-ephyrHostGLXSendClientInfo (int32_t a_major, int32_t a_minor,
-                            const char* a_extension_list)
+ephyrHostGLXSendClientInfo(int32_t a_major, int32_t a_minor,
+                           const char *a_extension_list)
 {
-    Bool is_ok = FALSE ;
-    Display *dpy = hostx_get_display () ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
     xGLXClientInfoReq *req;
     int size;
-    int32_t major_opcode=0 ;
+    int32_t major_opcode = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_extension_list, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy && a_extension_list, FALSE);
 
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
 
-    LockDisplay (dpy);
+    LockDisplay(dpy);
 
-    GetReq (GLXClientInfo,req);
+    GetReq(GLXClientInfo, req);
     req->reqType = major_opcode;
     req->glxCode = X_GLXClientInfo;
     req->major = a_major;
     req->minor = a_minor;
 
-    size = strlen (a_extension_list) + 1;
+    size = strlen(a_extension_list) + 1;
     req->length += bytes_to_int32(size);
     req->numbytes = size;
-    Data (dpy, a_extension_list, size);
+    Data(dpy, a_extension_list, size);
 
     UnlockDisplay(dpy);
     SyncHandle();
 
-    is_ok=TRUE ;
+    is_ok = TRUE;
 
-out:
-    return is_ok ;
+ out:
+    return is_ok;
 }
 
 Bool
-ephyrHostGLXCreateContext (int a_screen,
-                           int a_visual_id,
-                           int a_context_id,
-                           int a_share_list_ctxt_id,
-                           Bool a_direct)
+ephyrHostGLXCreateContext(int a_screen,
+                          int a_visual_id,
+                          int a_context_id,
+                          int a_share_list_ctxt_id, Bool a_direct)
 {
     Bool is_ok = FALSE;
-    Display *dpy = hostx_get_display ();
-    int major_opcode=0, remote_context_id=0;
+    Display *dpy = hostx_get_display();
+    int major_opcode = 0, remote_context_id = 0;
     xGLXCreateContextReq *req;
 
-    EPHYR_LOG ("enter. screen:%d, visual:%d, contextid:%d, direct:%d\n",
-               a_screen, a_visual_id, a_context_id, a_direct) ;
+    EPHYR_LOG("enter. screen:%d, visual:%d, contextid:%d, direct:%d\n",
+              a_screen, a_visual_id, a_context_id, a_direct);
 
-    if (!hostx_allocate_resource_id_peer (a_context_id, &remote_context_id)) {
-        EPHYR_LOG_ERROR ("failed to peer the context id %d host X",
-                         remote_context_id) ;
-        goto out ;
+    if (!hostx_allocate_resource_id_peer(a_context_id, &remote_context_id)) {
+        EPHYR_LOG_ERROR("failed to peer the context id %d host X",
+                        remote_context_id);
+        goto out;
     }
 
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
 
-    LockDisplay (dpy) ;
+    LockDisplay(dpy);
 
     /* Send the glXCreateContext request */
-    GetReq(GLXCreateContext,req);
+    GetReq(GLXCreateContext, req);
     req->reqType = major_opcode;
     req->glxCode = X_GLXCreateContext;
     req->context = remote_context_id;
     req->visual = a_visual_id;
-    req->screen = DefaultScreen (dpy);
+    req->screen = DefaultScreen(dpy);
     req->shareList = a_share_list_ctxt_id;
     req->isDirect = a_direct;
 
-    UnlockDisplay (dpy);
-    SyncHandle ();
+    UnlockDisplay(dpy);
+    SyncHandle();
 
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 Bool
-ephyrHostDestroyContext (int a_ctxt_id)
+ephyrHostDestroyContext(int a_ctxt_id)
 {
-    Bool is_ok=FALSE;
-    Display *dpy=hostx_get_display ();
-    int major_opcode=0, remote_ctxt_id=0 ;
-    xGLXDestroyContextReq *req=NULL;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    int major_opcode = 0, remote_ctxt_id = 0;
+    xGLXDestroyContextReq *req = NULL;
 
-    EPHYR_LOG ("enter:%d\n", a_ctxt_id) ;
+    EPHYR_LOG("enter:%d\n", a_ctxt_id);
 
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
-    if (!hostx_get_resource_id_peer (a_ctxt_id, &remote_ctxt_id)) {
-        EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
-        goto out ;
+    if (!hostx_get_resource_id_peer(a_ctxt_id, &remote_ctxt_id)) {
+        EPHYR_LOG_ERROR("failed to get remote glx ctxt id\n");
+        goto out;
     }
-    EPHYR_LOG ("host context id:%d\n", remote_ctxt_id) ;
+    EPHYR_LOG("host context id:%d\n", remote_ctxt_id);
 
-    LockDisplay (dpy);
-    GetReq (GLXDestroyContext,req);
+    LockDisplay(dpy);
+    GetReq(GLXDestroyContext, req);
     req->reqType = major_opcode;
     req->glxCode = X_GLXDestroyContext;
     req->context = remote_ctxt_id;
-    UnlockDisplay (dpy);
-    SyncHandle ();
+    UnlockDisplay(dpy);
+    SyncHandle();
 
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 Bool
-ephyrHostGLXMakeCurrent (int a_drawable,
-                         int a_glx_ctxt_id,
-                         int a_old_ctxt_tag,
-                         int *a_ctxt_tag)
+ephyrHostGLXMakeCurrent(int a_drawable,
+                        int a_glx_ctxt_id, int a_old_ctxt_tag, int *a_ctxt_tag)
 {
-    Bool is_ok=FALSE ;
-    Display *dpy = hostx_get_display () ;
-    int32_t major_opcode=0 ;
-    int remote_glx_ctxt_id=0 ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    int32_t major_opcode = 0;
+    int remote_glx_ctxt_id = 0;
     xGLXMakeCurrentReq *req;
     xGLXMakeCurrentReply reply;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_ctxt_tag, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_ctxt_tag, FALSE);
 
-    EPHYR_LOG ("enter. drawable:%d, context:%d, oldtag:%d\n",
-               a_drawable, a_glx_ctxt_id, a_old_ctxt_tag) ;
+    EPHYR_LOG("enter. drawable:%d, context:%d, oldtag:%d\n",
+              a_drawable, a_glx_ctxt_id, a_old_ctxt_tag);
 
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
-    if (!hostx_get_resource_id_peer (a_glx_ctxt_id, &remote_glx_ctxt_id)) {
-        EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
-        goto out ;
+    if (!hostx_get_resource_id_peer(a_glx_ctxt_id, &remote_glx_ctxt_id)) {
+        EPHYR_LOG_ERROR("failed to get remote glx ctxt id\n");
+        goto out;
     }
 
-    LockDisplay (dpy);
+    LockDisplay(dpy);
 
-    GetReq (GLXMakeCurrent,req);
+    GetReq(GLXMakeCurrent, req);
     req->reqType = major_opcode;
     req->glxCode = X_GLXMakeCurrent;
     req->drawable = a_drawable;
     req->context = remote_glx_ctxt_id;
     req->oldContextTag = a_old_ctxt_tag;
 
-    memset (&reply, 0, sizeof (reply)) ;
-    if (!_XReply (dpy, (xReply*)&reply, 0, False)) {
-        EPHYR_LOG_ERROR ("failed to get reply from host\n") ;
-        UnlockDisplay (dpy);
-        SyncHandle ();
-        goto out ;
+    memset(&reply, 0, sizeof(reply));
+    if (!_XReply(dpy, (xReply *) & reply, 0, False)) {
+        EPHYR_LOG_ERROR("failed to get reply from host\n");
+        UnlockDisplay(dpy);
+        SyncHandle();
+        goto out;
     }
-    UnlockDisplay (dpy);
-    SyncHandle ();
-    *a_ctxt_tag = reply.contextTag ;
-    EPHYR_LOG ("context tag:%d\n", *a_ctxt_tag) ;
-    is_ok = TRUE ;
-
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    *a_ctxt_tag = reply.contextTag;
+    EPHYR_LOG("context tag:%d\n", *a_ctxt_tag);
+    is_ok = TRUE;
+
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 #define X_GLXSingle 0
@@ -614,86 +599,85 @@ out:
     *p = *(GLfloat *)&reply.pad3;
 
 Bool
-ephyrHostGetIntegerValue (int a_current_context_tag, int a_int, int *a_val)
+ephyrHostGetIntegerValue(int a_current_context_tag, int a_int, int *a_val)
 {
-    Bool is_ok=FALSE;
-    Display *dpy = hostx_get_display () ;
-    int major_opcode=0, size=0;
-    xGLXSingleReq *req=NULL;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    int major_opcode = 0, size = 0;
+    xGLXSingleReq *req = NULL;
     xGLXSingleReply reply;
-    unsigned char* pc=NULL ;
+    unsigned char *pc = NULL;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_val, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_val, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    EPHYR_LOG("enter\n");
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
-    LockDisplay (dpy) ;
-    GetReqExtra (GLXSingle, 4, req) ;
-    req->reqType = major_opcode ;
-    req->glxCode = X_GLsop_GetIntegerv ;
+    LockDisplay(dpy);
+    GetReqExtra(GLXSingle, 4, req);
+    req->reqType = major_opcode;
+    req->glxCode = X_GLsop_GetIntegerv;
     req->contextTag = a_current_context_tag;
-    pc = ((unsigned char *)(req) + sz_xGLXSingleReq) ;
-    EPHYR_GLX_SINGLE_PUT_LONG (0, a_int) ;
-    EPHYR_GLX_SINGLE_READ_XREPLY () ;
-    EPHYR_GLX_SINGLE_GET_SIZE (size) ;
+    pc = ((unsigned char *) (req) + sz_xGLXSingleReq);
+    EPHYR_GLX_SINGLE_PUT_LONG(0, a_int);
+    EPHYR_GLX_SINGLE_READ_XREPLY();
+    EPHYR_GLX_SINGLE_GET_SIZE(size);
     if (!size) {
-        UnlockDisplay (dpy) ;
-        SyncHandle () ;
-        EPHYR_LOG_ERROR ("X_GLsop_GetIngerv failed\n") ;
-        goto out ;
+        UnlockDisplay(dpy);
+        SyncHandle();
+        EPHYR_LOG_ERROR("X_GLsop_GetIngerv failed\n");
+        goto out;
     }
-    EPHYR_GLX_SINGLE_GET_LONG (a_val) ;
-    UnlockDisplay (dpy) ;
-    SyncHandle () ;
-    is_ok = TRUE ;
-
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    EPHYR_GLX_SINGLE_GET_LONG(a_val);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    is_ok = TRUE;
+
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 Bool
-ephyrHostIsContextDirect (int a_ctxt_id,
-                          int *a_is_direct)
+ephyrHostIsContextDirect(int a_ctxt_id, int *a_is_direct)
 {
-    Bool is_ok=FALSE;
-    Display *dpy = hostx_get_display () ;
-    xGLXIsDirectReq *req=NULL;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    xGLXIsDirectReq *req = NULL;
     xGLXIsDirectReply reply;
-    int major_opcode=0, remote_glx_ctxt_id=0;
+    int major_opcode = 0, remote_glx_ctxt_id = 0;
 
-    EPHYR_LOG ("enter\n") ;
-    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
-        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
-        goto out ;
+    EPHYR_LOG("enter\n");
+    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {
+        EPHYR_LOG_ERROR("failed to get major opcode\n");
+        goto out;
     }
-    if (!hostx_get_resource_id_peer (a_ctxt_id, &remote_glx_ctxt_id)) {
-        EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
-        goto out ;
+    if (!hostx_get_resource_id_peer(a_ctxt_id, &remote_glx_ctxt_id)) {
+        EPHYR_LOG_ERROR("failed to get remote glx ctxt id\n");
+        goto out;
     }
-    memset (&reply, 0, sizeof (reply)) ;
+    memset(&reply, 0, sizeof(reply));
 
     /* Send the glXIsDirect request */
-    LockDisplay (dpy);
-    GetReq (GLXIsDirect,req);
+    LockDisplay(dpy);
+    GetReq(GLXIsDirect, req);
     req->reqType = major_opcode;
     req->glxCode = X_GLXIsDirect;
     req->context = remote_glx_ctxt_id;
-    if (!_XReply (dpy, (xReply*) &reply, 0, False)) {
-        EPHYR_LOG_ERROR ("fail in reading reply from host\n") ;
-        UnlockDisplay (dpy);
-        SyncHandle ();
-        goto out ;
+    if (!_XReply(dpy, (xReply *) & reply, 0, False)) {
+        EPHYR_LOG_ERROR("fail in reading reply from host\n");
+        UnlockDisplay(dpy);
+        SyncHandle();
+        goto out;
     }
-    UnlockDisplay (dpy);
-    SyncHandle ();
-    *a_is_direct = reply.isDirect ;
-    is_ok = TRUE ;
-
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    *a_is_direct = reply.isDirect;
+    is_ok = TRUE;
+
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
diff --git a/hw/kdrive/ephyr/ephyrhostglx.h b/hw/kdrive/ephyr/ephyrhostglx.h
index 6db362f30..9c6012070 100644
--- a/hw/kdrive/ephyr/ephyrhostglx.h
+++ b/hw/kdrive/ephyr/ephyrhostglx.h
@@ -34,43 +34,38 @@ enum EphyrHostGLXGetStringOps {
     EPHYR_HOST_GLX_GetString,
 };
 
-Bool ephyrHostGLXQueryVersion (int *a_maj, int *a_min) ;
-Bool ephyrHostGLXGetStringFromServer (int a_screen_number,
-                                      int a_string_name,
-                                      enum EphyrHostGLXGetStringOps a_op,
-                                      char **a_string) ;
-Bool ephyrHostGLXGetVisualConfigs (int a_screen,
-                                   int32_t *a_num_visuals,
-                                   int32_t *a_num_props,
-                                   int32_t *a_props_buf_size,
-                                   int32_t **a_props_buf) ;
+Bool ephyrHostGLXQueryVersion(int *a_maj, int *a_min);
+Bool ephyrHostGLXGetStringFromServer(int a_screen_number,
+                                     int a_string_name,
+                                     enum EphyrHostGLXGetStringOps a_op,
+                                     char **a_string);
+Bool ephyrHostGLXGetVisualConfigs(int a_screen,
+                                  int32_t * a_num_visuals,
+                                  int32_t * a_num_props,
+                                  int32_t * a_props_buf_size,
+                                  int32_t ** a_props_buf);
 Bool
-ephyrHostGLXVendorPrivGetFBConfigsSGIX (int a_screen,
-                                        int32_t *a_num_visuals,
-                                        int32_t *a_num_props,
-                                        int32_t *a_props_buf_size,
-                                        int32_t **a_props_buf);
-Bool ephyrHostGLXGetMajorOpcode (int32_t *a_opcode) ;
-Bool ephyrHostGLXSendClientInfo (int32_t a_major, int32_t a_minor,
-                                 const char* a_extension_list) ;
-Bool ephyrHostGLXCreateContext (int a_screen,
-                                int a_visual_id,
-                                int a_context_id,
-                                int a_shared_list_ctx_id,
-                                Bool a_direct) ;
 
-Bool ephyrHostDestroyContext (int a_ctxt_id) ;
+ephyrHostGLXVendorPrivGetFBConfigsSGIX(int a_screen,
+                                       int32_t * a_num_visuals,
+                                       int32_t * a_num_props,
+                                       int32_t * a_props_buf_size,
+                                       int32_t ** a_props_buf);
+Bool ephyrHostGLXGetMajorOpcode(int32_t * a_opcode);
+Bool ephyrHostGLXSendClientInfo(int32_t a_major, int32_t a_minor,
+                                const char *a_extension_list);
+Bool ephyrHostGLXCreateContext(int a_screen,
+                               int a_visual_id,
+                               int a_context_id,
+                               int a_shared_list_ctx_id, Bool a_direct);
 
-Bool ephyrHostGLXMakeCurrent (int a_drawable, int a_glx_ctxt_id,
-                              int a_olg_ctxt_tag, int *a_ctxt_tag) ;
+Bool ephyrHostDestroyContext(int a_ctxt_id);
 
-Bool ephyrHostGetIntegerValue (int a_current_context_tag,
-                               int a_int,
-                               int *a_val) ;
+Bool ephyrHostGLXMakeCurrent(int a_drawable, int a_glx_ctxt_id,
+                             int a_olg_ctxt_tag, int *a_ctxt_tag);
 
-Bool ephyrHostIsContextDirect (int a_ctxt_id,
-                               int *a_is_direct) ;
+Bool ephyrHostGetIntegerValue(int a_current_context_tag, int a_int, int *a_val);
 
+Bool ephyrHostIsContextDirect(int a_ctxt_id, int *a_is_direct);
 
 #endif /*__EPHYRHOSTGLX_H__*/
-
diff --git a/hw/kdrive/ephyr/ephyrhostproxy.c b/hw/kdrive/ephyr/ephyrhostproxy.c
index 3137055ca..410e6b6e4 100644
--- a/hw/kdrive/ephyr/ephyrhostproxy.c
+++ b/hw/kdrive/ephyr/ephyrhostproxy.c
@@ -50,45 +50,42 @@
     dpy->bufptr += SIZEOF(xReq);\
     dpy->request++
 
-
 Bool
-ephyrHostProxyDoForward (pointer a_request_buffer,
-                         struct XReply *a_reply,
-                         Bool a_do_swap)
+ephyrHostProxyDoForward(pointer a_request_buffer,
+                        struct XReply *a_reply, Bool a_do_swap)
 {
-    Bool is_ok = FALSE ;
-    int n=0 ;
-    Display *dpy=hostx_get_display () ;
-    xReq *in_req = (xReq*) a_request_buffer ;
-    xReq *forward_req=NULL ;
-    struct XReply reply ;
+    Bool is_ok = FALSE;
+    int n = 0;
+    Display *dpy = hostx_get_display();
+    xReq *in_req = (xReq *) a_request_buffer;
+    xReq *forward_req = NULL;
+    struct XReply reply;
 
-    EPHYR_RETURN_VAL_IF_FAIL (in_req && dpy, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(in_req && dpy, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     if (a_do_swap) {
-        swaps(&in_req->length) ;
+        swaps(&in_req->length);
     }
-    EPHYR_LOG ("Req {type:%d, data:%d, length:%d}\n",
-               in_req->reqType, in_req->data, in_req->length) ;
-    GetXReq (forward_req) ;
-    memmove (forward_req, in_req, 4) ;
+    EPHYR_LOG("Req {type:%d, data:%d, length:%d}\n",
+              in_req->reqType, in_req->data, in_req->length);
+    GetXReq(forward_req);
+    memmove(forward_req, in_req, 4);
 
-    if (!_XReply (dpy, (xReply*) &reply, 0, FALSE)) {
-        EPHYR_LOG_ERROR ("failed to get reply\n") ;
+    if (!_XReply(dpy, (xReply *) & reply, 0, FALSE)) {
+        EPHYR_LOG_ERROR("failed to get reply\n");
         goto out;
     }
-    EPHYR_LOG ("XReply{type:%d, foo:%d, seqnum:%d, length:%d}\n",
-               reply.type, reply.foo, reply.sequence_number, reply.length) ;
+    EPHYR_LOG("XReply{type:%d, foo:%d, seqnum:%d, length:%d}\n",
+              reply.type, reply.foo, reply.sequence_number, reply.length);
 
     if (a_reply) {
-        memmove (a_reply, &reply, sizeof (reply)) ;
+        memmove(a_reply, &reply, sizeof(reply));
     }
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
-
diff --git a/hw/kdrive/ephyr/ephyrhostproxy.h b/hw/kdrive/ephyr/ephyrhostproxy.h
index 720c986ff..13721606a 100644
--- a/hw/kdrive/ephyr/ephyrhostproxy.h
+++ b/hw/kdrive/ephyr/ephyrhostproxy.h
@@ -30,22 +30,22 @@
 #define __EPHYRHOSTPROXY_H__
 
 struct XReply {
-    int8_t type ;/*X_Reply*/
+    int8_t type;                /*X_Reply */
     int8_t foo;
-    int16_t sequence_number ;
-    int32_t length ;
-    /*following is some data up to 32 bytes lenght*/
-    int32_t pad0 ;
-    int32_t pad1 ;
-    int32_t pad2 ;
-    int32_t pad3 ;
-    int32_t pad4 ;
-    int32_t pad5 ;
+    int16_t sequence_number;
+    int32_t length;
+    /*following is some data up to 32 bytes lenght */
+    int32_t pad0;
+    int32_t pad1;
+    int32_t pad2;
+    int32_t pad3;
+    int32_t pad4;
+    int32_t pad5;
 };
 
 Bool
-ephyrHostProxyDoForward (pointer a_request_buffer,
-                         struct XReply *a_reply,
-                         Bool a_do_swap) ;
+
+ephyrHostProxyDoForward(pointer a_request_buffer,
+                        struct XReply *a_reply, Bool a_do_swap);
 
 #endif /*__EPHYRHOSTPROXY_H__*/
diff --git a/hw/kdrive/ephyr/ephyrhostvideo.c b/hw/kdrive/ephyr/ephyrhostvideo.c
index 69ad8a517..05a821b39 100644
--- a/hw/kdrive/ephyr/ephyrhostvideo.c
+++ b/hw/kdrive/ephyr/ephyrhostvideo.c
@@ -53,42 +53,37 @@
 #ifndef TRUE
 #define TRUE 1
 #endif /*TRUE*/
-
 #ifndef FALSE
 #define FALSE 0
 #endif /*FALSE*/
-
 static XExtensionInfo _xv_info_data;
 static XExtensionInfo *xv_info = &_xv_info_data;
 static char *xv_extension_name = XvName;
-static char *xv_error_string(Display *dpy, int code, XExtCodes *codes,
-                             char * buf, int n);
-static int xv_close_display(Display *dpy, XExtCodes *codes);
-static Bool xv_wire_to_event(Display *dpy, XEvent *host, xEvent *wire);
+static char *xv_error_string(Display * dpy, int code, XExtCodes * codes,
+                             char *buf, int n);
+static int xv_close_display(Display * dpy, XExtCodes * codes);
+static Bool xv_wire_to_event(Display * dpy, XEvent * host, xEvent *wire);
 
 static XExtensionHooks xv_extension_hooks = {
-    NULL,                               /* create_gc */
-    NULL,                               /* copy_gc */
-    NULL,                               /* flush_gc */
-    NULL,                               /* free_gc */
-    NULL,                               /* create_font */
-    NULL,                               /* free_font */
-    xv_close_display,                   /* close_display */
-    xv_wire_to_event,                   /* wire_to_event */
-    NULL,                               /* event_to_wire */
-    NULL,                               /* error */
-    xv_error_string                     /* error_string */
+    NULL,                       /* create_gc */
+    NULL,                       /* copy_gc */
+    NULL,                       /* flush_gc */
+    NULL,                       /* free_gc */
+    NULL,                       /* create_font */
+    NULL,                       /* free_font */
+    xv_close_display,           /* close_display */
+    xv_wire_to_event,           /* wire_to_event */
+    NULL,                       /* event_to_wire */
+    NULL,                       /* error */
+    xv_error_string             /* error_string */
 };
 
-
-static char *xv_error_list[] =
-{
-   "BadPort",       /* XvBadPort     */
-   "BadEncoding",   /* XvBadEncoding */
-   "BadControl"     /* XvBadControl  */
+static char *xv_error_list[] = {
+    "BadPort",                  /* XvBadPort     */
+    "BadEncoding",              /* XvBadEncoding */
+    "BadControl"                /* XvBadControl  */
 };
 
-
 #define XvCheckExtension(dpy, i, val) \
   XextCheckExtension(dpy, i, xv_extension_name, val)
 #define XvGetReq(name, req) \
@@ -102,51 +97,51 @@ static char *xv_error_list[] =
         dpy->bufptr += SIZEOF(xv##name##Req);\
         dpy->request++
 
-static XEXT_GENERATE_CLOSE_DISPLAY (xv_close_display, xv_info)
-
+static
+XEXT_GENERATE_CLOSE_DISPLAY(xv_close_display, xv_info)
 
-static XEXT_GENERATE_FIND_DISPLAY (xv_find_display, xv_info,
-                                   xv_extension_name,
-                                   &xv_extension_hooks,
-                                   XvNumEvents, NULL)
+static
+XEXT_GENERATE_FIND_DISPLAY(xv_find_display, xv_info,
+                           xv_extension_name,
+                           &xv_extension_hooks, XvNumEvents, NULL)
 
-static XEXT_GENERATE_ERROR_STRING (xv_error_string, xv_extension_name,
-                                   XvNumErrors, xv_error_list)
+static
+XEXT_GENERATE_ERROR_STRING(xv_error_string, xv_extension_name,
+                           XvNumErrors, xv_error_list)
 
 struct _EphyrHostXVAdaptorArray {
-    XvAdaptorInfo *adaptors ;
-    unsigned int nb_adaptors ;
+    XvAdaptorInfo *adaptors;
+    unsigned int nb_adaptors;
 };
 
 /*heavily copied from libx11*/
 #define BUFSIZE 2048
 static void
-ephyrHostXVLogXErrorEvent (Display *a_display,
-                           XErrorEvent *a_err_event,
-                           FILE *a_fp)
+ephyrHostXVLogXErrorEvent(Display * a_display,
+                          XErrorEvent * a_err_event, FILE * a_fp)
 {
     char buffer[BUFSIZ];
     char mesg[BUFSIZ];
     char number[32];
     const char *mtype = "XlibMessage";
-    register _XExtension *ext = (_XExtension *)NULL;
-    _XExtension *bext = (_XExtension *)NULL;
-    Display *dpy = a_display ;
+    register _XExtension *ext = (_XExtension *) NULL;
+    _XExtension *bext = (_XExtension *) NULL;
+    Display *dpy = a_display;
 
     XGetErrorText(dpy, a_err_event->error_code, buffer, BUFSIZ);
     XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
     (void) fprintf(a_fp, "%s:  %s\n  ", mesg, buffer);
     XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d",
-            mesg, BUFSIZ);
+                          mesg, BUFSIZ);
     (void) fprintf(a_fp, mesg, a_err_event->request_code);
     if (a_err_event->request_code < 128) {
         snprintf(number, sizeof(number), "%d", a_err_event->request_code);
         XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
-    } else {
+    }
+    else {
         for (ext = dpy->ext_procs;
-                ext && (ext->codes.major_opcode != a_err_event->request_code);
-                ext = ext->next)
-            ; 
+             ext && (ext->codes.major_opcode != a_err_event->request_code);
+             ext = ext->next);
         if (ext)
             strcpy(buffer, ext->name);
         else
@@ -155,7 +150,7 @@ ephyrHostXVLogXErrorEvent (Display *a_display,
     (void) fprintf(a_fp, " (%s)\n", buffer);
     if (a_err_event->request_code >= 128) {
         XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code %d",
-                mesg, BUFSIZ);
+                              mesg, BUFSIZ);
         fputs("  ", a_fp);
         (void) fprintf(a_fp, mesg, a_err_event->minor_code);
         if (ext) {
@@ -166,20 +161,20 @@ ephyrHostXVLogXErrorEvent (Display *a_display,
         }
         fputs("\n", a_fp);
     }
-    if (a_err_event->error_code >= 128) { 
+    if (a_err_event->error_code >= 128) {
         /* kludge, try to find the extension that caused it */
         buffer[0] = '\0';
         for (ext = dpy->ext_procs; ext; ext = ext->next) {
             if (ext->error_string)
-                (*ext->error_string)(dpy, a_err_event->error_code, &ext->codes,
-                        buffer, BUFSIZ);
+                (*ext->error_string) (dpy, a_err_event->error_code, &ext->codes,
+                                      buffer, BUFSIZ);
             if (buffer[0]) {
                 bext = ext;
                 break;
             }
             if (ext->codes.first_error &&
-                    ext->codes.first_error < (int)a_err_event->error_code &&
-                    (!bext || ext->codes.first_error > bext->codes.first_error))
+                ext->codes.first_error < (int) a_err_event->error_code &&
+                (!bext || ext->codes.first_error > bext->codes.first_error))
                 bext = ext;
         }
         if (bext)
@@ -196,505 +191,476 @@ ephyrHostXVLogXErrorEvent (Display *a_display,
         /* let extensions try to print the values */
         for (ext = dpy->ext_procs; ext; ext = ext->next) {
             if (ext->error_values)
-                (*ext->error_values)(dpy, a_err_event, a_fp);
+                (*ext->error_values) (dpy, a_err_event, a_fp);
         }
-    } else if ((a_err_event->error_code == BadWindow) ||
-            (a_err_event->error_code == BadPixmap) ||
-            (a_err_event->error_code == BadCursor) ||
-            (a_err_event->error_code == BadFont) ||
-            (a_err_event->error_code == BadDrawable) ||
-            (a_err_event->error_code == BadColor) ||
-            (a_err_event->error_code == BadGC) ||
-            (a_err_event->error_code == BadIDChoice) ||
-            (a_err_event->error_code == BadValue) ||
-            (a_err_event->error_code == BadAtom)) {
+    }
+    else if ((a_err_event->error_code == BadWindow) ||
+             (a_err_event->error_code == BadPixmap) ||
+             (a_err_event->error_code == BadCursor) ||
+             (a_err_event->error_code == BadFont) ||
+             (a_err_event->error_code == BadDrawable) ||
+             (a_err_event->error_code == BadColor) ||
+             (a_err_event->error_code == BadGC) ||
+             (a_err_event->error_code == BadIDChoice) ||
+             (a_err_event->error_code == BadValue) ||
+             (a_err_event->error_code == BadAtom)) {
         if (a_err_event->error_code == BadValue)
             XGetErrorDatabaseText(dpy, mtype, "Value", "Value 0x%x",
-                    mesg, BUFSIZ);
+                                  mesg, BUFSIZ);
         else if (a_err_event->error_code == BadAtom)
             XGetErrorDatabaseText(dpy, mtype, "AtomID", "AtomID 0x%x",
-                    mesg, BUFSIZ);
+                                  mesg, BUFSIZ);
         else
             XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
-                    mesg, BUFSIZ);
+                                  mesg, BUFSIZ);
         fputs("  ", a_fp);
         (void) fprintf(a_fp, mesg, a_err_event->resourceid);
         fputs("\n", a_fp);
     }
     XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d",
-            mesg, BUFSIZ);
+                          mesg, BUFSIZ);
     fputs("  ", a_fp);
     (void) fprintf(a_fp, mesg, a_err_event->serial);
     XGetErrorDatabaseText(dpy, mtype, "CurrentSerial", "Current Serial #%d",
-            mesg, BUFSIZ);
+                          mesg, BUFSIZ);
     fputs("\n  ", a_fp);
     (void) fprintf(a_fp, mesg, dpy->request);
     fputs("\n", a_fp);
 }
 
 static int
-ephyrHostXVErrorHandler (Display *a_display,
-                         XErrorEvent *a_error_event)
+ephyrHostXVErrorHandler(Display * a_display, XErrorEvent * a_error_event)
 {
-    EPHYR_LOG_ERROR ("got an error from the host xserver:\n") ;
-    ephyrHostXVLogXErrorEvent (a_display, a_error_event, stderr) ;
-    return Success ;
+    EPHYR_LOG_ERROR("got an error from the host xserver:\n");
+    ephyrHostXVLogXErrorEvent(a_display, a_error_event, stderr);
+    return Success;
 }
 
 void
-ephyrHostXVInit (void)
+ephyrHostXVInit(void)
 {
-    static Bool s_initialized ;
+    static Bool s_initialized;
 
     if (s_initialized)
-        return ;
-    XSetErrorHandler (ephyrHostXVErrorHandler) ;
-    s_initialized = TRUE ;
+        return;
+    XSetErrorHandler(ephyrHostXVErrorHandler);
+    s_initialized = TRUE;
 }
 
 Bool
-ephyrHostXVQueryAdaptors (EphyrHostXVAdaptorArray **a_adaptors)
+ephyrHostXVQueryAdaptors(EphyrHostXVAdaptorArray ** a_adaptors)
 {
-    EphyrHostXVAdaptorArray *result=NULL ;
-    int ret=0 ;
-    Bool is_ok=FALSE ;
+    EphyrHostXVAdaptorArray *result = NULL;
+    int ret = 0;
+    Bool is_ok = FALSE;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_adaptors, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_adaptors, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    result = calloc (1, sizeof (EphyrHostXVAdaptorArray)) ;
+    result = calloc(1, sizeof(EphyrHostXVAdaptorArray));
     if (!result)
-        goto out ;
+        goto out;
 
-    ret = XvQueryAdaptors (hostx_get_display (),
-                           DefaultRootWindow (hostx_get_display ()),
-                           &result->nb_adaptors,
-                           &result->adaptors) ;
+    ret = XvQueryAdaptors(hostx_get_display(),
+                          DefaultRootWindow(hostx_get_display()),
+                          &result->nb_adaptors, &result->adaptors);
     if (ret != Success) {
-        EPHYR_LOG_ERROR ("failed to query host adaptors: %d\n", ret) ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to query host adaptors: %d\n", ret);
+        goto out;
     }
-    *a_adaptors = result ;
-    is_ok = TRUE ;
+    *a_adaptors = result;
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 void
-ephyrHostXVAdaptorArrayDelete (EphyrHostXVAdaptorArray *a_adaptors)
+ephyrHostXVAdaptorArrayDelete(EphyrHostXVAdaptorArray * a_adaptors)
 {
     if (!a_adaptors)
-        return ;
+        return;
     if (a_adaptors->adaptors) {
-        XvFreeAdaptorInfo (a_adaptors->adaptors) ;
-        a_adaptors->adaptors = NULL ;
-        a_adaptors->nb_adaptors = 0 ;
+        XvFreeAdaptorInfo(a_adaptors->adaptors);
+        a_adaptors->adaptors = NULL;
+        a_adaptors->nb_adaptors = 0;
     }
-    XFree (a_adaptors) ;
+    XFree(a_adaptors);
 }
 
 int
-ephyrHostXVAdaptorArrayGetSize (const EphyrHostXVAdaptorArray *a_this)
+ephyrHostXVAdaptorArrayGetSize(const EphyrHostXVAdaptorArray * a_this)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, -1) ;
-    return a_this->nb_adaptors ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, -1);
+    return a_this->nb_adaptors;
 }
 
-EphyrHostXVAdaptor*
-ephyrHostXVAdaptorArrayAt (const EphyrHostXVAdaptorArray *a_this,
-                           int a_index)
+EphyrHostXVAdaptor *
+ephyrHostXVAdaptorArrayAt(const EphyrHostXVAdaptorArray * a_this, int a_index)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, NULL) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, NULL);
 
     if (a_index >= a_this->nb_adaptors)
-        return NULL ;
-    return (EphyrHostXVAdaptor*)&a_this->adaptors[a_index] ;
+        return NULL;
+    return (EphyrHostXVAdaptor *) & a_this->adaptors[a_index];
 }
 
 char
-ephyrHostXVAdaptorGetType (const EphyrHostXVAdaptor *a_this)
+ephyrHostXVAdaptorGetType(const EphyrHostXVAdaptor * a_this)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, -1) ;
-    return ((XvAdaptorInfo*)a_this)->type ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, -1);
+    return ((XvAdaptorInfo *) a_this)->type;
 }
 
-const char*
-ephyrHostXVAdaptorGetName (const EphyrHostXVAdaptor *a_this)
+const char *
+ephyrHostXVAdaptorGetName(const EphyrHostXVAdaptor * a_this)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, NULL) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, NULL);
 
-    return ((XvAdaptorInfo*)a_this)->name ;
+    return ((XvAdaptorInfo *) a_this)->name;
 }
 
-EphyrHostVideoFormat*
-ephyrHostXVAdaptorGetVideoFormats (const EphyrHostXVAdaptor *a_this,
-                                   int *a_nb_formats)
+EphyrHostVideoFormat *
+ephyrHostXVAdaptorGetVideoFormats(const EphyrHostXVAdaptor * a_this,
+                                  int *a_nb_formats)
 {
-    EphyrHostVideoFormat *formats=NULL ;
-    int nb_formats=0, i=0 ;
-    XVisualInfo *visual_info, visual_info_template ;
-    int nb_visual_info ;
+    EphyrHostVideoFormat *formats = NULL;
+    int nb_formats = 0, i = 0;
+    XVisualInfo *visual_info, visual_info_template;
+    int nb_visual_info;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, NULL) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, NULL);
 
-    nb_formats = ((XvAdaptorInfo*)a_this)->num_formats ;
-    formats = calloc (nb_formats, sizeof (EphyrHostVideoFormat)) ;
-    for (i=0; i < nb_formats; i++) {
-        memset (&visual_info_template, 0, sizeof (visual_info_template)) ;
+    nb_formats = ((XvAdaptorInfo *) a_this)->num_formats;
+    formats = calloc(nb_formats, sizeof(EphyrHostVideoFormat));
+    for (i = 0; i < nb_formats; i++) {
+        memset(&visual_info_template, 0, sizeof(visual_info_template));
         visual_info_template.visualid =
-                            ((XvAdaptorInfo*)a_this)->formats[i].visual_id;
-        visual_info = XGetVisualInfo (hostx_get_display (),
-                                      VisualIDMask,
-                                      &visual_info_template,
-                                      &nb_visual_info) ;
-        formats[i].depth = ((XvAdaptorInfo*)a_this)->formats[i].depth ;
-        formats[i].visual_class = visual_info->class ;
-        XFree (visual_info) ;
+            ((XvAdaptorInfo *) a_this)->formats[i].visual_id;
+        visual_info = XGetVisualInfo(hostx_get_display(),
+                                     VisualIDMask,
+                                     &visual_info_template, &nb_visual_info);
+        formats[i].depth = ((XvAdaptorInfo *) a_this)->formats[i].depth;
+        formats[i].visual_class = visual_info->class;
+        XFree(visual_info);
     }
     if (a_nb_formats)
-        *a_nb_formats = nb_formats ;
-    return formats ;
+        *a_nb_formats = nb_formats;
+    return formats;
 }
 
 int
-ephyrHostXVAdaptorGetNbPorts (const EphyrHostXVAdaptor *a_this)
+ephyrHostXVAdaptorGetNbPorts(const EphyrHostXVAdaptor * a_this)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, -1) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, -1);
 
-    return ((XvAdaptorInfo*)a_this)->num_ports ;
+    return ((XvAdaptorInfo *) a_this)->num_ports;
 }
 
 int
-ephyrHostXVAdaptorGetFirstPortID (const EphyrHostXVAdaptor *a_this)
+ephyrHostXVAdaptorGetFirstPortID(const EphyrHostXVAdaptor * a_this)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, -1) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, -1);
 
-    return ((XvAdaptorInfo*)a_this)->base_id ;
+    return ((XvAdaptorInfo *) a_this)->base_id;
 }
 
 Bool
-ephyrHostXVAdaptorHasPutVideo (const EphyrHostXVAdaptor *a_this,
-                               Bool *a_result)
+ephyrHostXVAdaptorHasPutVideo(const EphyrHostXVAdaptor * a_this, Bool *a_result)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this && a_result, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this && a_result, FALSE);
 
-    if ((((XvAdaptorInfo*)a_this)->type & (XvVideoMask | XvInputMask)) ==
-		    (XvVideoMask | XvInputMask))
-        *a_result = TRUE ;
+    if ((((XvAdaptorInfo *) a_this)->type & (XvVideoMask | XvInputMask)) ==
+        (XvVideoMask | XvInputMask))
+        *a_result = TRUE;
     else
-        *a_result = FALSE ;
-    return TRUE ;
+        *a_result = FALSE;
+    return TRUE;
 }
 
 Bool
-ephyrHostXVAdaptorHasGetVideo (const EphyrHostXVAdaptor *a_this,
-                               Bool *a_result)
+ephyrHostXVAdaptorHasGetVideo(const EphyrHostXVAdaptor * a_this, Bool *a_result)
 {
-    if ((((XvAdaptorInfo*)a_this)->type & (XvVideoMask | XvOutputMask)) ==
-		    (XvVideoMask | XvOutputMask))
-        *a_result = TRUE ;
+    if ((((XvAdaptorInfo *) a_this)->type & (XvVideoMask | XvOutputMask)) ==
+        (XvVideoMask | XvOutputMask))
+        *a_result = TRUE;
     else
-        *a_result = FALSE ;
-    return TRUE ;
+        *a_result = FALSE;
+    return TRUE;
 }
 
 Bool
-ephyrHostXVAdaptorHasPutStill (const EphyrHostXVAdaptor *a_this,
-                               Bool *a_result)
+ephyrHostXVAdaptorHasPutStill(const EphyrHostXVAdaptor * a_this, Bool *a_result)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this && a_result, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this && a_result, FALSE);
 
-    if ((((XvAdaptorInfo*)a_this)->type & (XvStillMask | XvInputMask)) ==
-		    (XvStillMask | XvInputMask))
-        *a_result = TRUE ;
+    if ((((XvAdaptorInfo *) a_this)->type & (XvStillMask | XvInputMask)) ==
+        (XvStillMask | XvInputMask))
+        *a_result = TRUE;
     else
-        *a_result = FALSE ;
-    return TRUE ;
+        *a_result = FALSE;
+    return TRUE;
 }
 
 Bool
-ephyrHostXVAdaptorHasGetStill (const EphyrHostXVAdaptor *a_this,
-                               Bool *a_result)
+ephyrHostXVAdaptorHasGetStill(const EphyrHostXVAdaptor * a_this, Bool *a_result)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this && a_result, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this && a_result, FALSE);
 
-    if ((((XvAdaptorInfo*)a_this)->type & (XvStillMask | XvOutputMask)) ==
-		    (XvStillMask | XvOutputMask))
-        *a_result = TRUE ;
+    if ((((XvAdaptorInfo *) a_this)->type & (XvStillMask | XvOutputMask)) ==
+        (XvStillMask | XvOutputMask))
+        *a_result = TRUE;
     else
-        *a_result = FALSE ;
-    return TRUE ;
+        *a_result = FALSE;
+    return TRUE;
 }
 
 Bool
-ephyrHostXVAdaptorHasPutImage (const EphyrHostXVAdaptor *a_this,
-                               Bool *a_result)
+ephyrHostXVAdaptorHasPutImage(const EphyrHostXVAdaptor * a_this, Bool *a_result)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_this && a_result, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this && a_result, FALSE);
 
-    if ((((XvAdaptorInfo*)a_this)->type & (XvImageMask | XvInputMask)) ==
-		    (XvImageMask | XvInputMask))
-        *a_result = TRUE ;
+    if ((((XvAdaptorInfo *) a_this)->type & (XvImageMask | XvInputMask)) ==
+        (XvImageMask | XvInputMask))
+        *a_result = TRUE;
     else
-        *a_result = FALSE ;
-    return TRUE ;
+        *a_result = FALSE;
+    return TRUE;
 }
 
 Bool
-ephyrHostXVQueryEncodings (int a_port_id,
-                           EphyrHostEncoding **a_encodings,
-                           unsigned int *a_num_encodings)
+ephyrHostXVQueryEncodings(int a_port_id,
+                          EphyrHostEncoding ** a_encodings,
+                          unsigned int *a_num_encodings)
 {
-    EphyrHostEncoding *encodings=NULL ;
-    XvEncodingInfo *encoding_info=NULL ;
-    unsigned int num_encodings=0, i;
-    int ret=0 ;
+    EphyrHostEncoding *encodings = NULL;
+    XvEncodingInfo *encoding_info = NULL;
+    unsigned int num_encodings = 0, i;
+    int ret = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_encodings && a_num_encodings, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_encodings && a_num_encodings, FALSE);
 
-    ret = XvQueryEncodings (hostx_get_display (),
-                            a_port_id,
-                            &num_encodings,
-                            &encoding_info) ;
+    ret = XvQueryEncodings(hostx_get_display(),
+                           a_port_id, &num_encodings, &encoding_info);
     if (num_encodings && encoding_info) {
-        encodings = calloc (num_encodings, sizeof (EphyrHostEncoding)) ;
-        for (i=0; i<num_encodings; i++) {
-            encodings[i].id = encoding_info[i].encoding_id ;
-            encodings[i].name = strdup (encoding_info[i].name) ;
-            encodings[i].width = encoding_info[i].width ;
-            encodings[i].height = encoding_info[i].height ;
-            encodings[i].rate.numerator = encoding_info[i].rate.numerator ;
-            encodings[i].rate.denominator = encoding_info[i].rate.denominator ;
+        encodings = calloc(num_encodings, sizeof(EphyrHostEncoding));
+        for (i = 0; i < num_encodings; i++) {
+            encodings[i].id = encoding_info[i].encoding_id;
+            encodings[i].name = strdup(encoding_info[i].name);
+            encodings[i].width = encoding_info[i].width;
+            encodings[i].height = encoding_info[i].height;
+            encodings[i].rate.numerator = encoding_info[i].rate.numerator;
+            encodings[i].rate.denominator = encoding_info[i].rate.denominator;
         }
     }
     if (encoding_info) {
-        XvFreeEncodingInfo (encoding_info) ;
-        encoding_info = NULL ;
+        XvFreeEncodingInfo(encoding_info);
+        encoding_info = NULL;
     }
-    *a_encodings = encodings ;
-    *a_num_encodings = num_encodings ;
+    *a_encodings = encodings;
+    *a_num_encodings = num_encodings;
 
     if (ret != Success)
-        return FALSE ;
-    return TRUE ;
+        return FALSE;
+    return TRUE;
 }
 
 void
-ephyrHostEncodingsDelete (EphyrHostEncoding *a_encodings,
-                          int a_num_encodings)
+ephyrHostEncodingsDelete(EphyrHostEncoding * a_encodings, int a_num_encodings)
 {
-    int i=0 ;
+    int i = 0;
 
     if (!a_encodings)
-        return ;
-    for (i=0; i < a_num_encodings; i++) {
-        free(a_encodings[i].name) ;
-        a_encodings[i].name = NULL ;
+        return;
+    for (i = 0; i < a_num_encodings; i++) {
+        free(a_encodings[i].name);
+        a_encodings[i].name = NULL;
     }
-    free(a_encodings) ;
+    free(a_encodings);
 }
 
 void
-ephyrHostAttributesDelete (EphyrHostAttribute *a_attributes)
+ephyrHostAttributesDelete(EphyrHostAttribute * a_attributes)
 {
     if (!a_attributes)
-        return ;
-    XFree (a_attributes) ;
+        return;
+    XFree(a_attributes);
 }
 
 Bool
-ephyrHostXVQueryPortAttributes (int a_port_id,
-                                EphyrHostAttribute **a_attributes,
-                                int *a_num_attributes)
+ephyrHostXVQueryPortAttributes(int a_port_id,
+                               EphyrHostAttribute ** a_attributes,
+                               int *a_num_attributes)
 {
-    EPHYR_RETURN_VAL_IF_FAIL (a_attributes && a_num_attributes, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_attributes && a_num_attributes, FALSE);
 
     *a_attributes =
-        (EphyrHostAttribute*)XvQueryPortAttributes (hostx_get_display (),
-                                                    a_port_id,
-                                                    a_num_attributes);
+        (EphyrHostAttribute *) XvQueryPortAttributes(hostx_get_display(),
+                                                     a_port_id,
+                                                     a_num_attributes);
 
-    return TRUE ;
+    return TRUE;
 }
 
 Bool
-ephyrHostXVQueryImageFormats (int a_port_id,
-                              EphyrHostImageFormat **a_formats,
-                              int *a_num_format)
+ephyrHostXVQueryImageFormats(int a_port_id,
+                             EphyrHostImageFormat ** a_formats,
+                             int *a_num_format)
 {
-    XvImageFormatValues *result=NULL ;
+    XvImageFormatValues *result = NULL;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_formats && a_num_format, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_formats && a_num_format, FALSE);
 
-    result = XvListImageFormats (hostx_get_display (),
-                                 a_port_id,
-                                 a_num_format) ;
-    *a_formats = (EphyrHostImageFormat*) result ;
-    return TRUE ;
+    result = XvListImageFormats(hostx_get_display(), a_port_id, a_num_format);
+    *a_formats = (EphyrHostImageFormat *) result;
+    return TRUE;
 
 }
 
 Bool
-ephyrHostXVSetPortAttribute (int a_port_id,
-                             int a_atom,
-                             int a_attr_value)
+ephyrHostXVSetPortAttribute(int a_port_id, int a_atom, int a_attr_value)
 {
-    int res=Success ;
+    int res = Success;
 
-    EPHYR_LOG ("atom,name,value: (%d,%s,%d)\n",
-               a_atom,
-               XGetAtomName (hostx_get_display (), a_atom),
-               a_attr_value) ;
+    EPHYR_LOG("atom,name,value: (%d,%s,%d)\n",
+              a_atom, XGetAtomName(hostx_get_display(), a_atom), a_attr_value);
 
-    res = XvSetPortAttribute (hostx_get_display (),
-                              a_port_id,
-                              a_atom,
-                              a_attr_value) ;
+    res = XvSetPortAttribute(hostx_get_display(),
+                             a_port_id, a_atom, a_attr_value);
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvSetPortAttribute() failed: %d\n", res) ;
-        return FALSE ;
+        EPHYR_LOG_ERROR("XvSetPortAttribute() failed: %d\n", res);
+        return FALSE;
     }
-    XFlush (hostx_get_display ()) ;
-    EPHYR_LOG ("leave\n") ;
+    XFlush(hostx_get_display());
+    EPHYR_LOG("leave\n");
 
-    return TRUE ;
+    return TRUE;
 }
 
 Bool
-ephyrHostXVGetPortAttribute (int a_port_id,
-                             int a_atom,
-                             int *a_attr_value)
+ephyrHostXVGetPortAttribute(int a_port_id, int a_atom, int *a_attr_value)
 {
-    int res=Success ;
-    Bool ret=FALSE ;
+    int res = Success;
+    Bool ret = FALSE;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_attr_value, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_attr_value, FALSE);
 
-    EPHYR_LOG ("enter, a_port_id: %d, a_atomid: %d, attr_name: %s\n",
-               a_port_id, a_atom, XGetAtomName (hostx_get_display (), a_atom)) ;
+    EPHYR_LOG("enter, a_port_id: %d, a_atomid: %d, attr_name: %s\n",
+              a_port_id, a_atom, XGetAtomName(hostx_get_display(), a_atom));
 
-    res = XvGetPortAttribute (hostx_get_display (),
-                              a_port_id,
-                              a_atom,
-                              a_attr_value) ;
+    res = XvGetPortAttribute(hostx_get_display(),
+                             a_port_id, a_atom, a_attr_value);
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvGetPortAttribute() failed: %d \n", res) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvGetPortAttribute() failed: %d \n", res);
+        goto out;
     }
-    EPHYR_LOG ("atom,value: (%d, %d)\n", a_atom, *a_attr_value) ;
+    EPHYR_LOG("atom,value: (%d, %d)\n", a_atom, *a_attr_value);
 
-    ret = TRUE ;
+    ret = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return ret ;
+ out:
+    EPHYR_LOG("leave\n");
+    return ret;
 }
 
 Bool
-ephyrHostXVQueryBestSize (int a_port_id,
-                          Bool a_motion,
-                          unsigned int a_frame_w,
-                          unsigned int a_frame_h,
-                          unsigned int a_drw_w,
-                          unsigned int a_drw_h,
-                          unsigned int *a_actual_w,
-                          unsigned int *a_actual_h)
-{
-    int res=0 ;
-    Bool is_ok=FALSE ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (a_actual_w && a_actual_h, FALSE) ;
-
-    EPHYR_LOG ("enter: frame (%dx%d), drw (%dx%d)\n",
-               a_frame_w, a_frame_h,
-               a_drw_w, a_drw_h) ;
-
-    res = XvQueryBestSize (hostx_get_display (),
-                           a_port_id,
-                           a_motion,
-                           a_frame_w, a_frame_h,
-                           a_drw_w, a_drw_h,
-                           a_actual_w, a_actual_h) ;
+ephyrHostXVQueryBestSize(int a_port_id,
+                         Bool a_motion,
+                         unsigned int a_frame_w,
+                         unsigned int a_frame_h,
+                         unsigned int a_drw_w,
+                         unsigned int a_drw_h,
+                         unsigned int *a_actual_w, unsigned int *a_actual_h)
+{
+    int res = 0;
+    Bool is_ok = FALSE;
+
+    EPHYR_RETURN_VAL_IF_FAIL(a_actual_w && a_actual_h, FALSE);
+
+    EPHYR_LOG("enter: frame (%dx%d), drw (%dx%d)\n",
+              a_frame_w, a_frame_h, a_drw_w, a_drw_h);
+
+    res = XvQueryBestSize(hostx_get_display(),
+                          a_port_id,
+                          a_motion,
+                          a_frame_w, a_frame_h,
+                          a_drw_w, a_drw_h, a_actual_w, a_actual_h);
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvQueryBestSize() failed: %d\n", res) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvQueryBestSize() failed: %d\n", res);
+        goto out;
     }
-    XSync (hostx_get_display (), FALSE) ;
+    XSync(hostx_get_display(), FALSE);
 
-    EPHYR_LOG ("actual (%dx%d)\n", *a_actual_w, *a_actual_h) ;
-    is_ok = TRUE ;
+    EPHYR_LOG("actual (%dx%d)\n", *a_actual_w, *a_actual_h);
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 static Bool
-xv_wire_to_event(Display *dpy, XEvent *host, xEvent *wire)
+xv_wire_to_event(Display * dpy, XEvent * host, xEvent *wire)
 {
-    XExtDisplayInfo *info = xv_find_display (dpy);
-    XvEvent *re    = (XvEvent *)host;
-    xvEvent *event = (xvEvent *)wire;
+    XExtDisplayInfo *info = xv_find_display(dpy);
+    XvEvent *re = (XvEvent *) host;
+    xvEvent *event = (xvEvent *) wire;
 
     XvCheckExtension(dpy, info, False);
 
     switch ((event->u.u.type & 0x7F) - info->codes->first_event) {
-        case XvVideoNotify:
-            re->xvvideo.type = event->u.u.type & 0x7f;
-            re->xvvideo.serial =
-            _XSetLastRequestRead(dpy, (xGenericReply *)event);
-            re->xvvideo.send_event = ((event->u.u.type & 0x80) != 0);
-            re->xvvideo.display = dpy;
-            re->xvvideo.time = event->u.videoNotify.time;
-            re->xvvideo.reason = event->u.videoNotify.reason;
-            re->xvvideo.drawable = event->u.videoNotify.drawable;
-            re->xvvideo.port_id = event->u.videoNotify.port;
-            break;
-        case XvPortNotify:
-            re->xvport.type = event->u.u.type & 0x7f;
-            re->xvport.serial =
-            _XSetLastRequestRead(dpy, (xGenericReply *)event);
-            re->xvport.send_event = ((event->u.u.type & 0x80) != 0);
-            re->xvport.display = dpy;
-            re->xvport.time = event->u.portNotify.time;
-            re->xvport.port_id = event->u.portNotify.port;
-            re->xvport.attribute = event->u.portNotify.attribute;
-            re->xvport.value = event->u.portNotify.value;
-            break;
-        default:
-            return False;
-    }
-
-    return True ;
+    case XvVideoNotify:
+        re->xvvideo.type = event->u.u.type & 0x7f;
+        re->xvvideo.serial = _XSetLastRequestRead(dpy, (xGenericReply *) event);
+        re->xvvideo.send_event = ((event->u.u.type & 0x80) != 0);
+        re->xvvideo.display = dpy;
+        re->xvvideo.time = event->u.videoNotify.time;
+        re->xvvideo.reason = event->u.videoNotify.reason;
+        re->xvvideo.drawable = event->u.videoNotify.drawable;
+        re->xvvideo.port_id = event->u.videoNotify.port;
+        break;
+    case XvPortNotify:
+        re->xvport.type = event->u.u.type & 0x7f;
+        re->xvport.serial = _XSetLastRequestRead(dpy, (xGenericReply *) event);
+        re->xvport.send_event = ((event->u.u.type & 0x80) != 0);
+        re->xvport.display = dpy;
+        re->xvport.time = event->u.portNotify.time;
+        re->xvport.port_id = event->u.portNotify.port;
+        re->xvport.attribute = event->u.portNotify.attribute;
+        re->xvport.value = event->u.portNotify.value;
+        break;
+    default:
+        return False;
+    }
+
+    return True;
 }
 
 Bool
-ephyrHostXVQueryImageAttributes (int a_port_id,
-                                 int a_image_id /*image fourcc code*/,
-                                 unsigned short *a_width,
-                                 unsigned short *a_height,
-                                 int *a_image_size,
-                                 int *a_pitches,
-                                 int *a_offsets)
-{
-    Display *dpy = hostx_get_display () ;
-    Bool ret=FALSE ;
-    XExtDisplayInfo *info = xv_find_display (dpy);
-    xvQueryImageAttributesReq *req=NULL;
+ephyrHostXVQueryImageAttributes(int a_port_id,
+                                int a_image_id /*image fourcc code */ ,
+                                unsigned short *a_width,
+                                unsigned short *a_height,
+                                int *a_image_size,
+                                int *a_pitches, int *a_offsets)
+{
+    Display *dpy = hostx_get_display();
+    Bool ret = FALSE;
+    XExtDisplayInfo *info = xv_find_display(dpy);
+    xvQueryImageAttributesReq *req = NULL;
     xvQueryImageAttributesReply rep;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_width, FALSE) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_height, FALSE) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_image_size, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_width, FALSE);
+    EPHYR_RETURN_VAL_IF_FAIL(a_height, FALSE);
+    EPHYR_RETURN_VAL_IF_FAIL(a_image_size, FALSE);
 
-    XvCheckExtension (dpy, info, FALSE);
+    XvCheckExtension(dpy, info, FALSE);
 
-    LockDisplay (dpy);
+    LockDisplay(dpy);
 
-    XvGetReq (QueryImageAttributes, req);
+    XvGetReq(QueryImageAttributes, req);
     req->id = a_image_id;
     req->port = a_port_id;
     req->width = *a_width;
@@ -702,315 +668,308 @@ ephyrHostXVQueryImageAttributes (int a_port_id,
     /*
      * read the reply
      */
-    if (!_XReply (dpy, (xReply *)&rep, 0, xFalse)) {
-        EPHYR_LOG_ERROR ("QeryImageAttribute req failed\n") ;
-        goto out ;
+    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
+        EPHYR_LOG_ERROR("QeryImageAttribute req failed\n");
+        goto out;
     }
     if (a_pitches && a_offsets) {
-        _XRead (dpy,
-                (char*)a_pitches,
-                rep.num_planes << 2);
-        _XRead (dpy,
-                (char*)a_offsets,
-                rep.num_planes << 2);
-    } else {
+        _XRead(dpy, (char *) a_pitches, rep.num_planes << 2);
+        _XRead(dpy, (char *) a_offsets, rep.num_planes << 2);
+    }
+    else {
         _XEatData(dpy, rep.length << 2);
     }
-    *a_width = rep.width ;
-    *a_height = rep.height ;
-    *a_image_size = rep.data_size ;
+    *a_width = rep.width;
+    *a_height = rep.height;
+    *a_image_size = rep.data_size;
 
-    ret = TRUE ;
+    ret = TRUE;
 
-out:
-    UnlockDisplay (dpy) ;
-    SyncHandle ();
-    return ret ;
+ out:
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return ret;
 }
 
 Bool
-ephyrHostGetAtom (const char* a_name,
-                  Bool a_create_if_not_exists,
-                  int *a_atom)
+ephyrHostGetAtom(const char *a_name, Bool a_create_if_not_exists, int *a_atom)
 {
-    int atom=None ;
+    int atom = None;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_atom, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_atom, FALSE);
 
-    atom = XInternAtom (hostx_get_display (), a_name, a_create_if_not_exists);
+    atom = XInternAtom(hostx_get_display(), a_name, a_create_if_not_exists);
     if (atom == None) {
-        return FALSE ;
+        return FALSE;
     }
-    *a_atom = atom ;
-    return TRUE ;
+    *a_atom = atom;
+    return TRUE;
 }
 
-char*
-ephyrHostGetAtomName (int a_atom)
+char *
+ephyrHostGetAtomName(int a_atom)
 {
-    return XGetAtomName (hostx_get_display (), a_atom) ;
+    return XGetAtomName(hostx_get_display(), a_atom);
 }
 
 void
-ephyrHostFree (void *a_pointer)
+ephyrHostFree(void *a_pointer)
 {
     if (a_pointer)
-        XFree (a_pointer) ;
+        XFree(a_pointer);
 }
 
 Bool
-ephyrHostXVPutImage (int a_screen_num,
-                     int a_port_id,
-                     int a_image_id,
-                     int a_drw_x,
-                     int a_drw_y,
-                     int a_drw_w,
-                     int a_drw_h,
-                     int a_src_x,
-                     int a_src_y,
-                     int a_src_w,
-                     int a_src_h,
-                     int a_image_width,
-                     int a_image_height,
-                     unsigned char *a_buf,
-                     EphyrHostBox *a_clip_rects,
-                     int a_clip_rect_nums )
-{
-    Bool is_ok=TRUE ;
-    XvImage *xv_image=NULL ;
-    GC gc=0 ;
+ephyrHostXVPutImage(int a_screen_num,
+                    int a_port_id,
+                    int a_image_id,
+                    int a_drw_x,
+                    int a_drw_y,
+                    int a_drw_w,
+                    int a_drw_h,
+                    int a_src_x,
+                    int a_src_y,
+                    int a_src_w,
+                    int a_src_h,
+                    int a_image_width,
+                    int a_image_height,
+                    unsigned char *a_buf,
+                    EphyrHostBox * a_clip_rects, int a_clip_rect_nums)
+{
+    Bool is_ok = TRUE;
+    XvImage *xv_image = NULL;
+    GC gc = 0;
     XGCValues gc_values;
-    Display *dpy = hostx_get_display () ;
-    XRectangle *rects=NULL ;
-    int res = 0 ;
+    Display *dpy = hostx_get_display();
+    XRectangle *rects = NULL;
+    int res = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_buf, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_buf, FALSE);
 
-    EPHYR_LOG ("enter, num_clip_rects: %d\n", a_clip_rect_nums) ;
+    EPHYR_LOG("enter, num_clip_rects: %d\n", a_clip_rect_nums);
 
-    memset (&gc_values, 0, sizeof (gc_values)) ;
-    gc = XCreateGC (dpy, hostx_get_window (a_screen_num), 0L, &gc_values);
+    memset(&gc_values, 0, sizeof(gc_values));
+    gc = XCreateGC(dpy, hostx_get_window(a_screen_num), 0L, &gc_values);
     if (!gc) {
-        EPHYR_LOG_ERROR ("failed to create gc \n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create gc \n");
+        goto out;
     }
-    xv_image = (XvImage*) XvCreateImage (hostx_get_display (),
+    xv_image = (XvImage *) XvCreateImage(hostx_get_display(),
                                          a_port_id, a_image_id,
-                                         NULL, a_image_width, a_image_height) ;
+                                         NULL, a_image_width, a_image_height);
     if (!xv_image) {
-        EPHYR_LOG_ERROR ("failed to create image\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create image\n");
+        goto out;
     }
-    xv_image->data = (char*)a_buf ;
+    xv_image->data = (char *) a_buf;
     if (a_clip_rect_nums) {
-        int i=0 ;
-        rects = calloc (a_clip_rect_nums, sizeof (XRectangle)) ;
-        for (i=0; i < a_clip_rect_nums; i++) {
-            rects[i].x = a_clip_rects[i].x1 ;
-            rects[i].y = a_clip_rects[i].y1 ;
+        int i = 0;
+
+        rects = calloc(a_clip_rect_nums, sizeof(XRectangle));
+        for (i = 0; i < a_clip_rect_nums; i++) {
+            rects[i].x = a_clip_rects[i].x1;
+            rects[i].y = a_clip_rects[i].y1;
             rects[i].width = a_clip_rects[i].x2 - a_clip_rects[i].x1;
             rects[i].height = a_clip_rects[i].y2 - a_clip_rects[i].y1;
-            EPHYR_LOG ("(x,y,w,h): (%d,%d,%d,%d)\n",
-                       rects[i].x, rects[i].y,
-                       rects[i].width, rects[i].height) ;
+            EPHYR_LOG("(x,y,w,h): (%d,%d,%d,%d)\n",
+                      rects[i].x, rects[i].y, rects[i].width, rects[i].height);
         }
-        XSetClipRectangles (dpy, gc, 0, 0, rects, a_clip_rect_nums, YXBanded) ;
-        /*this always returns 1*/
-    }
-    res = XvPutImage (dpy, a_port_id,
-                      hostx_get_window (a_screen_num),
-                      gc, xv_image,
-                      a_src_x, a_src_y, a_src_w, a_src_h,
-                      a_drw_x, a_drw_y, a_drw_w, a_drw_h) ;
+        XSetClipRectangles(dpy, gc, 0, 0, rects, a_clip_rect_nums, YXBanded);
+        /*this always returns 1 */
+    }
+    res = XvPutImage(dpy, a_port_id,
+                     hostx_get_window(a_screen_num),
+                     gc, xv_image,
+                     a_src_x, a_src_y, a_src_w, a_src_h,
+                     a_drw_x, a_drw_y, a_drw_w, a_drw_h);
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvPutImage() failed: %d\n", res) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvPutImage() failed: %d\n", res);
+        goto out;
     }
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
+ out:
     if (xv_image) {
-        XFree (xv_image) ;
-        xv_image = NULL ;
+        XFree(xv_image);
+        xv_image = NULL;
     }
     if (gc) {
-        XFreeGC (dpy, gc) ;
-        gc = NULL ;
+        XFreeGC(dpy, gc);
+        gc = NULL;
     }
     free(rects);
     rects = NULL;
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 Bool
-ephyrHostXVPutVideo (int a_screen_num, int a_port_id,
-                     int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                     int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
+ephyrHostXVPutVideo(int a_screen_num, int a_port_id,
+                    int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                    int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
 {
-    Bool is_ok=FALSE ;
-    int res=FALSE ;
-    GC gc=0 ;
+    Bool is_ok = FALSE;
+    int res = FALSE;
+    GC gc = 0;
     XGCValues gc_values;
-    Display *dpy=hostx_get_display () ;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
 
-    gc = XCreateGC (dpy, hostx_get_window (a_screen_num), 0L, &gc_values);
+    gc = XCreateGC(dpy, hostx_get_window(a_screen_num), 0L, &gc_values);
     if (!gc) {
-        EPHYR_LOG_ERROR ("failed to create gc \n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create gc \n");
+        goto out;
     }
-    res = XvPutVideo (dpy, a_port_id, hostx_get_window (a_screen_num), gc,
-                      a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                      a_drw_x, a_drw_y, a_drw_w, a_drw_h) ;
+    res = XvPutVideo(dpy, a_port_id, hostx_get_window(a_screen_num), gc,
+                     a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                     a_drw_x, a_drw_y, a_drw_w, a_drw_h);
 
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvPutVideo() failed: %d\n", res) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvPutVideo() failed: %d\n", res);
+        goto out;
     }
 
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
+ out:
     if (gc) {
-        XFreeGC (dpy, gc) ;
-        gc = NULL ;
+        XFreeGC(dpy, gc);
+        gc = NULL;
     }
-    return is_ok ;
+    return is_ok;
 }
 
 Bool
-ephyrHostXVGetVideo (int a_screen_num, int a_port_id,
-                     int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                     int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
+ephyrHostXVGetVideo(int a_screen_num, int a_port_id,
+                    int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                    int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
 {
-    Bool is_ok=FALSE ;
-    int res=FALSE ;
-    GC gc=0 ;
+    Bool is_ok = FALSE;
+    int res = FALSE;
+    GC gc = 0;
     XGCValues gc_values;
-    Display *dpy=hostx_get_display () ;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
 
-    gc = XCreateGC (dpy, hostx_get_window (a_screen_num), 0L, &gc_values);
+    gc = XCreateGC(dpy, hostx_get_window(a_screen_num), 0L, &gc_values);
     if (!gc) {
-        EPHYR_LOG_ERROR ("failed to create gc \n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create gc \n");
+        goto out;
     }
-    res = XvGetVideo (dpy, a_port_id, hostx_get_window (a_screen_num), gc,
-                      a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                      a_drw_x, a_drw_y, a_drw_w, a_drw_h) ;
+    res = XvGetVideo(dpy, a_port_id, hostx_get_window(a_screen_num), gc,
+                     a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                     a_drw_x, a_drw_y, a_drw_w, a_drw_h);
 
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvGetVideo() failed: %d\n", res) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvGetVideo() failed: %d\n", res);
+        goto out;
     }
 
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
+ out:
     if (gc) {
-        XFreeGC (dpy, gc) ;
-        gc = NULL ;
+        XFreeGC(dpy, gc);
+        gc = NULL;
     }
-    return is_ok ;
+    return is_ok;
 }
 
 Bool
-ephyrHostXVPutStill (int a_screen_num, int a_port_id,
-                     int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                     int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
+ephyrHostXVPutStill(int a_screen_num, int a_port_id,
+                    int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                    int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
 {
-    Bool is_ok=FALSE ;
-    int res=FALSE ;
-    GC gc=0 ;
+    Bool is_ok = FALSE;
+    int res = FALSE;
+    GC gc = 0;
     XGCValues gc_values;
-    Display *dpy=hostx_get_display () ;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
 
-    gc = XCreateGC (dpy, hostx_get_window (a_screen_num), 0L, &gc_values);
+    gc = XCreateGC(dpy, hostx_get_window(a_screen_num), 0L, &gc_values);
     if (!gc) {
-        EPHYR_LOG_ERROR ("failed to create gc \n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create gc \n");
+        goto out;
     }
-    res = XvPutStill (dpy, a_port_id, hostx_get_window (a_screen_num), gc,
-                      a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                      a_drw_x, a_drw_y, a_drw_w, a_drw_h) ;
+    res = XvPutStill(dpy, a_port_id, hostx_get_window(a_screen_num), gc,
+                     a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                     a_drw_x, a_drw_y, a_drw_w, a_drw_h);
 
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvPutStill() failed: %d\n", res) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvPutStill() failed: %d\n", res);
+        goto out;
     }
 
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
+ out:
     if (gc) {
-        XFreeGC (dpy, gc) ;
-        gc = NULL ;
+        XFreeGC(dpy, gc);
+        gc = NULL;
     }
-    return is_ok ;
+    return is_ok;
 }
 
 Bool
-ephyrHostXVGetStill (int a_screen_num, int a_port_id,
-                     int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                     int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
+ephyrHostXVGetStill(int a_screen_num, int a_port_id,
+                    int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                    int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h)
 {
-    Bool is_ok=FALSE ;
-    int res=FALSE ;
-    GC gc=0 ;
+    Bool is_ok = FALSE;
+    int res = FALSE;
+    GC gc = 0;
     XGCValues gc_values;
-    Display *dpy=hostx_get_display () ;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
 
-    gc = XCreateGC (dpy, hostx_get_window (a_screen_num), 0L, &gc_values);
+    gc = XCreateGC(dpy, hostx_get_window(a_screen_num), 0L, &gc_values);
     if (!gc) {
-        EPHYR_LOG_ERROR ("failed to create gc \n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create gc \n");
+        goto out;
     }
-    res = XvGetStill (dpy, a_port_id, hostx_get_window (a_screen_num), gc,
-                      a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                      a_drw_x, a_drw_y, a_drw_w, a_drw_h) ;
+    res = XvGetStill(dpy, a_port_id, hostx_get_window(a_screen_num), gc,
+                     a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                     a_drw_x, a_drw_y, a_drw_w, a_drw_h);
 
     if (res != Success) {
-        EPHYR_LOG_ERROR ("XvGetStill() failed: %d\n", res) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvGetStill() failed: %d\n", res);
+        goto out;
     }
 
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
+ out:
     if (gc) {
-        XFreeGC (dpy, gc) ;
-        gc = NULL ;
+        XFreeGC(dpy, gc);
+        gc = NULL;
     }
-    return is_ok ;
+    return is_ok;
 }
 
 Bool
-ephyrHostXVStopVideo (int a_screen_num, int a_port_id)
+ephyrHostXVStopVideo(int a_screen_num, int a_port_id)
 {
-    int ret=0 ;
-    Bool is_ok=FALSE ;
-    Display *dpy = hostx_get_display () ;
+    int ret = 0;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    ret = XvStopVideo (dpy, a_port_id, hostx_get_window (a_screen_num)) ;
+    ret = XvStopVideo(dpy, a_port_id, hostx_get_window(a_screen_num));
     if (ret != Success) {
-        EPHYR_LOG_ERROR ("XvStopVideo() failed: %d \n", ret) ;
-        goto out ;
+        EPHYR_LOG_ERROR("XvStopVideo() failed: %d \n", ret);
+        goto out;
     }
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
-
diff --git a/hw/kdrive/ephyr/ephyrhostvideo.h b/hw/kdrive/ephyr/ephyrhostvideo.h
index 05ee38a03..0d3177277 100644
--- a/hw/kdrive/ephyr/ephyrhostvideo.h
+++ b/hw/kdrive/ephyr/ephyrhostvideo.h
@@ -28,40 +28,40 @@
 #ifndef __EPHYRHOSTVIDEO_H__
 #define __EPHYRHOSTVIDEO_H__
 
-typedef void* EphyrHostXVAdaptor ;
-typedef struct _EphyrHostXVAdaptorArray EphyrHostXVAdaptorArray ;
+typedef void *EphyrHostXVAdaptor;
+typedef struct _EphyrHostXVAdaptorArray EphyrHostXVAdaptorArray;
 
 typedef struct _EphyrHostVideoFormat {
-    char depth ;
+    char depth;
     short visual_class;
-} EphyrHostVideoFormat ;
+} EphyrHostVideoFormat;
 
 typedef struct _EphyrHostRational {
-    int numerator ;
-    int denominator ;
+    int numerator;
+    int denominator;
 } EphyrHostRational;
 
 typedef struct _EphyrHostEncoding {
-    int id ;
-    char *name ;
-    unsigned short width, height ;
-    EphyrHostRational rate ;
-} EphyrHostEncoding ;
+    int id;
+    char *name;
+    unsigned short width, height;
+    EphyrHostRational rate;
+} EphyrHostEncoding;
 
 typedef struct _EphyrHostAttribute {
     int flags;
     int min_value;
     int max_value;
     char *name;
-} EphyrHostAttribute ;
+} EphyrHostAttribute;
 
 typedef struct _EphyrHostImageFormat {
-    int id;                      /* Unique descriptor for the format */
-    int type;                    /* XvRGB, XvYUV */
-    int byte_order;              /* LSBFirst, MSBFirst */
-    char guid[16];               /* Globally Unique IDentifier */
+    int id;                     /* Unique descriptor for the format */
+    int type;                   /* XvRGB, XvYUV */
+    int byte_order;             /* LSBFirst, MSBFirst */
+    char guid[16];              /* Globally Unique IDentifier */
     int bits_per_pixel;
-    int format;                  /* XvPacked, XvPlanar */
+    int format;                 /* XvPacked, XvPlanar */
     int num_planes;
 
     /* for RGB formats only */
@@ -80,159 +80,152 @@ typedef struct _EphyrHostImageFormat {
     unsigned int vert_y_period;
     unsigned int vert_u_period;
     unsigned int vert_v_period;
-    char component_order[32];    /* eg. UYVY */
-    int scanline_order;          /* XvTopToBottom, XvBottomToTop */
-} EphyrHostImageFormat ;
+    char component_order[32];   /* eg. UYVY */
+    int scanline_order;         /* XvTopToBottom, XvBottomToTop */
+} EphyrHostImageFormat;
 
 typedef struct {
-    unsigned short x1, y1, x2, y2 ;
-} EphyrHostBox ;
+    unsigned short x1, y1, x2, y2;
+} EphyrHostBox;
 
-void ephyrHostXVInit (void) ;
+void ephyrHostXVInit(void);
 
-void ephyrHostFree (void *a_pointer) ;
+void ephyrHostFree(void *a_pointer);
 
 /*
  * host adaptor array
  */
-Bool ephyrHostXVQueryAdaptors (EphyrHostXVAdaptorArray **a_adaptors) ;
-void ephyrHostXVAdaptorArrayDelete (EphyrHostXVAdaptorArray *a_adaptors) ;
-int ephyrHostXVAdaptorArrayGetSize (const EphyrHostXVAdaptorArray *a_this) ;
-EphyrHostXVAdaptor* ephyrHostXVAdaptorArrayAt (const EphyrHostXVAdaptorArray *a_this,
-                                               int a_index) ;
+Bool ephyrHostXVQueryAdaptors(EphyrHostXVAdaptorArray ** a_adaptors);
+void ephyrHostXVAdaptorArrayDelete(EphyrHostXVAdaptorArray * a_adaptors);
+int ephyrHostXVAdaptorArrayGetSize(const EphyrHostXVAdaptorArray * a_this);
+EphyrHostXVAdaptor *ephyrHostXVAdaptorArrayAt(const EphyrHostXVAdaptorArray *
+                                              a_this, int a_index);
 
 /*
  * host adaptor
  */
 
-char ephyrHostXVAdaptorGetType (const EphyrHostXVAdaptor *a_this) ;
-const char* ephyrHostXVAdaptorGetName (const EphyrHostXVAdaptor *a_this) ;
-EphyrHostVideoFormat* ephyrHostXVAdaptorGetVideoFormats
-                                                (const EphyrHostXVAdaptor *a_this,
-                                                 int *a_nb_formats) ;
-int ephyrHostXVAdaptorGetNbPorts (const EphyrHostXVAdaptor *a_this) ;
-int ephyrHostXVAdaptorGetFirstPortID (const EphyrHostXVAdaptor *a_this) ;
-
-Bool ephyrHostXVAdaptorHasPutVideo (const EphyrHostXVAdaptor *a_this,
-                                    Bool *a_result) ;
-Bool ephyrHostXVAdaptorHasGetVideo (const EphyrHostXVAdaptor *a_this,
-                                    Bool *a_result) ;
-Bool ephyrHostXVAdaptorHasPutStill (const EphyrHostXVAdaptor *a_this,
-                                    Bool *a_result) ;
-Bool ephyrHostXVAdaptorHasGetStill (const EphyrHostXVAdaptor *a_this,
-                                    Bool *a_result) ;
-Bool ephyrHostXVAdaptorHasPutImage (const EphyrHostXVAdaptor *a_this,
-                                    Bool *a_result) ;
+char ephyrHostXVAdaptorGetType(const EphyrHostXVAdaptor * a_this);
+const char *ephyrHostXVAdaptorGetName(const EphyrHostXVAdaptor * a_this);
+EphyrHostVideoFormat *ephyrHostXVAdaptorGetVideoFormats
+    (const EphyrHostXVAdaptor * a_this, int *a_nb_formats);
+int ephyrHostXVAdaptorGetNbPorts(const EphyrHostXVAdaptor * a_this);
+int ephyrHostXVAdaptorGetFirstPortID(const EphyrHostXVAdaptor * a_this);
+
+Bool ephyrHostXVAdaptorHasPutVideo(const EphyrHostXVAdaptor * a_this,
+                                   Bool *a_result);
+Bool ephyrHostXVAdaptorHasGetVideo(const EphyrHostXVAdaptor * a_this,
+                                   Bool *a_result);
+Bool ephyrHostXVAdaptorHasPutStill(const EphyrHostXVAdaptor * a_this,
+                                   Bool *a_result);
+Bool ephyrHostXVAdaptorHasGetStill(const EphyrHostXVAdaptor * a_this,
+                                   Bool *a_result);
+Bool ephyrHostXVAdaptorHasPutImage(const EphyrHostXVAdaptor * a_this,
+                                   Bool *a_result);
 
 /*
  * encoding
  */
-Bool ephyrHostXVQueryEncodings (int a_port_id,
-                                EphyrHostEncoding **a_encodings,
-                                unsigned int *a_num_encodings) ;
+Bool ephyrHostXVQueryEncodings(int a_port_id,
+                               EphyrHostEncoding ** a_encodings,
+                               unsigned int *a_num_encodings);
 
-void ephyrHostEncodingsDelete (EphyrHostEncoding *a_encodings,
-                               int a_num_encodings) ;
+void ephyrHostEncodingsDelete(EphyrHostEncoding * a_encodings,
+                              int a_num_encodings);
 
 /*
  * attribute
  */
-Bool ephyrHostXVQueryPortAttributes (int a_port_id,
-                                     EphyrHostAttribute **a_attributes,
-                                     int *a_num_attributes) ;
+Bool ephyrHostXVQueryPortAttributes(int a_port_id,
+                                    EphyrHostAttribute ** a_attributes,
+                                    int *a_num_attributes);
+
+void ephyrHostAttributesDelete(EphyrHostAttribute * a_attributes);
 
-void ephyrHostAttributesDelete (EphyrHostAttribute *a_attributes) ;
 /*
  * image format
  */
 
-Bool ephyrHostXVQueryImageFormats (int a_port_id,
-                                   EphyrHostImageFormat **a_formats,
-                                   int *a_num_format) ;
+Bool ephyrHostXVQueryImageFormats(int a_port_id,
+                                  EphyrHostImageFormat ** a_formats,
+                                  int *a_num_format);
 /*
  * Port Attribute Get/Set
  */
-Bool ephyrHostXVSetPortAttribute (int a_port_id,
-                                  int a_atom,
-                                  int a_attr_value) ;
-Bool ephyrHostXVGetPortAttribute (int a_port_id,
-                                  int a_atom,
-                                  int *a_attr_value) ;
+Bool ephyrHostXVSetPortAttribute(int a_port_id, int a_atom, int a_attr_value);
+Bool ephyrHostXVGetPortAttribute(int a_port_id, int a_atom, int *a_attr_value);
+
 /*
  *size query
  */
-Bool ephyrHostXVQueryBestSize (int a_port_id,
-                               Bool a_motion,
-                               unsigned int a_frame_w,
-                               unsigned int a_frame_h,
-                               unsigned int a_drw_w,
-                               unsigned int a_drw_h,
-                               unsigned int *a_actual_w,
-                               unsigned int *a_actual_h) ;
-
-Bool ephyrHostXVQueryImageAttributes (int a_port_id,
-                                      int a_image_id /*image fourcc code*/,
-                                      unsigned short *a_width,
-                                      unsigned short *a_height,
-                                      int *a_image_size,
-                                      int *a_pitches,
-                                      int *a_offsets) ;
+Bool ephyrHostXVQueryBestSize(int a_port_id,
+                              Bool a_motion,
+                              unsigned int a_frame_w,
+                              unsigned int a_frame_h,
+                              unsigned int a_drw_w,
+                              unsigned int a_drw_h,
+                              unsigned int *a_actual_w,
+                              unsigned int *a_actual_h);
+
+Bool ephyrHostXVQueryImageAttributes(int a_port_id,
+                                     int a_image_id /*image fourcc code */ ,
+                                     unsigned short *a_width,
+                                     unsigned short *a_height,
+                                     int *a_image_size,
+                                     int *a_pitches, int *a_offsets);
 /*
  * atom
  */
-Bool ephyrHostGetAtom (const char* a_name,
-                       Bool a_create_if_not_exists,
-                       int *a_atom) ;
-char* ephyrHostGetAtomName (int a_atom) ;
+Bool ephyrHostGetAtom(const char *a_name,
+                      Bool a_create_if_not_exists, int *a_atom);
+char *ephyrHostGetAtomName(int a_atom);
 
 /*
  *PutImage
  * (ignore clipping for now)
  */
-Bool ephyrHostXVPutImage (int a_screen_num,
-                          int a_port_id,
-                          int a_image_id,
-                          int a_drw_x,
-                          int a_drw_y,
-                          int a_drw_w,
-                          int a_drw_h,
-                          int a_src_x,
-                          int a_src_y,
-                          int a_src_w,
-                          int a_src_h,
-                          int a_image_width,
-                          int a_image_height,
-                          unsigned char *a_buf,
-                          EphyrHostBox *a_clip_rects,
-                          int a_clip_rect_nums) ;
+Bool ephyrHostXVPutImage(int a_screen_num,
+                         int a_port_id,
+                         int a_image_id,
+                         int a_drw_x,
+                         int a_drw_y,
+                         int a_drw_w,
+                         int a_drw_h,
+                         int a_src_x,
+                         int a_src_y,
+                         int a_src_w,
+                         int a_src_h,
+                         int a_image_width,
+                         int a_image_height,
+                         unsigned char *a_buf,
+                         EphyrHostBox * a_clip_rects, int a_clip_rect_nums);
 
 /*
  * Putvideo/PutStill/GetVideo
  */
-Bool ephyrHostXVPutVideo (int a_screen_num,
-                          int a_port_id,
-                          int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                          int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
-
-Bool ephyrHostXVGetVideo (int a_screen_num,
-                          int a_port_id,
-                          int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                          int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
-
-Bool ephyrHostXVPutStill (int a_screen_num,
-                          int a_port_id,
-                          int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                          int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
-
-Bool ephyrHostXVGetStill (int a_screen_num,
-                          int a_port_id,
-                          int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
-                          int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
+Bool ephyrHostXVPutVideo(int a_screen_num,
+                         int a_port_id,
+                         int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                         int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h);
+
+Bool ephyrHostXVGetVideo(int a_screen_num,
+                         int a_port_id,
+                         int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                         int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h);
+
+Bool ephyrHostXVPutStill(int a_screen_num,
+                         int a_port_id,
+                         int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                         int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h);
+
+Bool ephyrHostXVGetStill(int a_screen_num,
+                         int a_port_id,
+                         int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
+                         int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h);
 
 /*
  * StopVideo
  */
-Bool ephyrHostXVStopVideo (int a_screen_num, int a_port_id) ;
+Bool ephyrHostXVStopVideo(int a_screen_num, int a_port_id);
 
 #endif /*__EPHYRHOSTVIDEO_H__*/
-
diff --git a/hw/kdrive/ephyr/ephyrinit.c b/hw/kdrive/ephyr/ephyrinit.c
index b674bb8d0..a62b49d4b 100644
--- a/hw/kdrive/ephyr/ephyrinit.c
+++ b/hw/kdrive/ephyr/ephyrinit.c
@@ -30,301 +30,274 @@
 #include "ephyrlog.h"
 
 extern Window EphyrPreExistingHostWin;
-extern Bool   EphyrWantGrayScale;
-extern Bool   kdHasPointer;
-extern Bool   kdHasKbd;
+extern Bool EphyrWantGrayScale;
+extern Bool kdHasPointer;
+extern Bool kdHasKbd;
 
 #ifdef GLXEXT
-extern Bool   ephyrNoDRI;
+extern Bool ephyrNoDRI;
 extern Bool noGlxVisualInit;
 #endif
-extern Bool   ephyrNoXV;
+extern Bool ephyrNoXV;
 
 #ifdef KDRIVE_EVDEV
-extern KdPointerDriver	LinuxEvdevMouseDriver;
+extern KdPointerDriver LinuxEvdevMouseDriver;
 extern KdKeyboardDriver LinuxEvdevKeyboardDriver;
 #endif
 
-void processScreenArg (char *screen_size, char *parent_id) ;
+void processScreenArg(char *screen_size, char *parent_id);
 
 void
-InitCard (char *name)
+InitCard(char *name)
 {
     EPHYR_DBG("mark");
-    KdCardInfoAdd (&ephyrFuncs, 0);
+    KdCardInfoAdd(&ephyrFuncs, 0);
 }
 
 void
-InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
+InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
 {
-  KdInitOutput (pScreenInfo, argc, argv);
+    KdInitOutput(pScreenInfo, argc, argv);
 }
 
 void
-InitInput (int argc, char **argv)
+InitInput(int argc, char **argv)
 {
-  KdKeyboardInfo *ki;
-  KdPointerInfo *pi;
+    KdKeyboardInfo *ki;
+    KdPointerInfo *pi;
 
-  KdAddKeyboardDriver(&EphyrKeyboardDriver);
+    KdAddKeyboardDriver(&EphyrKeyboardDriver);
 #ifdef KDRIVE_EVDEV
-  KdAddKeyboardDriver(&LinuxEvdevKeyboardDriver);
+    KdAddKeyboardDriver(&LinuxEvdevKeyboardDriver);
 #endif
-  KdAddPointerDriver(&EphyrMouseDriver);
+    KdAddPointerDriver(&EphyrMouseDriver);
 #ifdef KDRIVE_EVDEV
-  KdAddPointerDriver(&LinuxEvdevMouseDriver);
+    KdAddPointerDriver(&LinuxEvdevMouseDriver);
 #endif
 
-  if (!kdHasKbd) {
-    ki = KdNewKeyboard();
-    if (!ki)
-      FatalError("Couldn't create Xephyr keyboard\n");
-    ki->driver = &EphyrKeyboardDriver;
-    KdAddKeyboard(ki);
-  }
-
-  if (!kdHasPointer) {
-    pi = KdNewPointer();
-    if (!pi)
-      FatalError("Couldn't create Xephyr pointer\n");
-    pi->driver = &EphyrMouseDriver;
-    KdAddPointer(pi);
-  }
-
-  KdInitInput();
+    if (!kdHasKbd) {
+        ki = KdNewKeyboard();
+        if (!ki)
+            FatalError("Couldn't create Xephyr keyboard\n");
+        ki->driver = &EphyrKeyboardDriver;
+        KdAddKeyboard(ki);
+    }
+
+    if (!kdHasPointer) {
+        pi = KdNewPointer();
+        if (!pi)
+            FatalError("Couldn't create Xephyr pointer\n");
+        pi->driver = &EphyrMouseDriver;
+        KdAddPointer(pi);
+    }
+
+    KdInitInput();
 }
 
 void
-CloseInput (void)
+CloseInput(void)
 {
-  KdCloseInput();
+    KdCloseInput();
 }
 
 #ifdef DDXBEFORERESET
 void
-ddxBeforeReset (void)
+ddxBeforeReset(void)
 {
 }
 #endif
 
 void
-ddxUseMsg (void)
+ddxUseMsg(void)
 {
-  KdUseMsg();
-
-  ErrorF("\nXephyr Option Usage:\n");
-  ErrorF("-parent <XID>        Use existing window as Xephyr root win\n");
-  ErrorF("-host-cursor         Re-use exisiting X host server cursor\n");
-  ErrorF("-fullscreen          Attempt to run Xephyr fullscreen\n");
-  ErrorF("-grayscale           Simulate 8bit grayscale\n");
-  ErrorF("-fakexa              Simulate acceleration using software rendering\n");
-  ErrorF("-verbosity <level>   Set log verbosity level\n");
+    KdUseMsg();
+
+    ErrorF("\nXephyr Option Usage:\n");
+    ErrorF("-parent <XID>        Use existing window as Xephyr root win\n");
+    ErrorF("-host-cursor         Re-use exisiting X host server cursor\n");
+    ErrorF("-fullscreen          Attempt to run Xephyr fullscreen\n");
+    ErrorF("-grayscale           Simulate 8bit grayscale\n");
+    ErrorF
+        ("-fakexa              Simulate acceleration using software rendering\n");
+    ErrorF("-verbosity <level>   Set log verbosity level\n");
 #ifdef GLXEXT
-  ErrorF("-nodri               do not use DRI\n");
+    ErrorF("-nodri               do not use DRI\n");
 #endif
-  ErrorF("-noxv                do not use XV\n");
-  ErrorF("-name [name]         define the name in the WM_CLASS property\n");
-  ErrorF("-title [title]       set the window title in the WM_NAME property\n");
-  ErrorF("\n");
+    ErrorF("-noxv                do not use XV\n");
+    ErrorF("-name [name]         define the name in the WM_CLASS property\n");
+    ErrorF
+        ("-title [title]       set the window title in the WM_NAME property\n");
+    ErrorF("\n");
 
-  exit(1);
+    exit(1);
 }
 
 void
-processScreenArg (char *screen_size, char *parent_id)
+processScreenArg(char *screen_size, char *parent_id)
 {
-  KdCardInfo   *card;
+    KdCardInfo *card;
 
-  InitCard (0);  /*Put each screen on a separate card*/
-  card = KdCardInfoLast ();
+    InitCard(0);                /*Put each screen on a separate card */
+    card = KdCardInfoLast();
 
-  if (card)
-    {
-      KdScreenInfo *screen;
-      unsigned long p_id = 0;
+    if (card) {
+        KdScreenInfo *screen;
+        unsigned long p_id = 0;
 
-      screen = KdScreenInfoAdd (card);
-      KdParseScreen (screen, screen_size);
+        screen = KdScreenInfoAdd(card);
+        KdParseScreen(screen, screen_size);
 
-      if (parent_id)
-        {
-          p_id = strtol (parent_id, NULL, 0);
+        if (parent_id) {
+            p_id = strtol(parent_id, NULL, 0);
         }
-      EPHYR_DBG ("screen number:%d\n", screen->mynum) ;
-      hostx_add_screen (screen, p_id, screen->mynum);
+        EPHYR_DBG("screen number:%d\n", screen->mynum);
+        hostx_add_screen(screen, p_id, screen->mynum);
     }
-  else
-    {
-      ErrorF("No matching card found!\n");
+    else {
+        ErrorF("No matching card found!\n");
     }
 }
 
 int
-ddxProcessArgument (int argc, char **argv, int i)
+ddxProcessArgument(int argc, char **argv, int i)
 {
-  static char* parent = NULL;
-  EPHYR_DBG("mark argv[%d]='%s'", i, argv[i] );
+    static char *parent = NULL;
 
-  if (i == 1)
-    {
-      hostx_use_resname(basename(argv[0]), 0);
+    EPHYR_DBG("mark argv[%d]='%s'", i, argv[i]);
+
+    if (i == 1) {
+        hostx_use_resname(basename(argv[0]), 0);
     }
 
-  if (!strcmp (argv[i], "-parent"))
-    {
-      if(i+1 < argc)
-	{
-	  int j;
-	  /* If parent is specified and a screen argument follows, don't do
-           * anything, let the -screen handling init the rest */
-	  for (j = i; j < argc; j++)
-	    {
-	      if (!strcmp(argv[j], "-screen"))
-		{
-		  parent = argv[i + 1];
-		  return 2;
-		}
-	    }
-
-	  processScreenArg ("100x100", argv[i+1]);
-	  return 2;
-	}
-
-      UseMsg();
-      exit(1);
+    if (!strcmp(argv[i], "-parent")) {
+        if (i + 1 < argc) {
+            int j;
+
+            /* If parent is specified and a screen argument follows, don't do
+             * anything, let the -screen handling init the rest */
+            for (j = i; j < argc; j++) {
+                if (!strcmp(argv[j], "-screen")) {
+                    parent = argv[i + 1];
+                    return 2;
+                }
+            }
+
+            processScreenArg("100x100", argv[i + 1]);
+            return 2;
+        }
+
+        UseMsg();
+        exit(1);
     }
-  else if (!strcmp (argv[i], "-screen"))
-    {
-      if ((i+1) < argc)
-	{
-	  processScreenArg (argv[i+1], parent);
-	  parent = NULL;
-	  return 2;
-	}
-
-      UseMsg();
-      exit(1);
+    else if (!strcmp(argv[i], "-screen")) {
+        if ((i + 1) < argc) {
+            processScreenArg(argv[i + 1], parent);
+            parent = NULL;
+            return 2;
+        }
+
+        UseMsg();
+        exit(1);
     }
-  else if (!strcmp (argv[i], "-host-cursor"))
-    {
-      hostx_use_host_cursor();
-      return 1;
+    else if (!strcmp(argv[i], "-host-cursor")) {
+        hostx_use_host_cursor();
+        return 1;
     }
-  else if (!strcmp (argv[i], "-fullscreen"))
-    {
-      hostx_use_fullscreen();
-      return 1;
+    else if (!strcmp(argv[i], "-fullscreen")) {
+        hostx_use_fullscreen();
+        return 1;
     }
-  else if (!strcmp (argv[i], "-grayscale"))
-    {
-      EphyrWantGrayScale = 1;      
-      return 1;
+    else if (!strcmp(argv[i], "-grayscale")) {
+        EphyrWantGrayScale = 1;
+        return 1;
     }
-  else if (!strcmp (argv[i], "-fakexa"))
-    {
-      ephyrFuncs.initAccel = ephyrDrawInit;
-      ephyrFuncs.enableAccel = ephyrDrawEnable;
-      ephyrFuncs.disableAccel = ephyrDrawDisable;
-      ephyrFuncs.finiAccel = ephyrDrawFini;
-      return 1;
+    else if (!strcmp(argv[i], "-fakexa")) {
+        ephyrFuncs.initAccel = ephyrDrawInit;
+        ephyrFuncs.enableAccel = ephyrDrawEnable;
+        ephyrFuncs.disableAccel = ephyrDrawDisable;
+        ephyrFuncs.finiAccel = ephyrDrawFini;
+        return 1;
     }
-  else if (!strcmp (argv[i], "-verbosity"))
-    {
-      if(i+1 < argc && argv[i+1][0] != '-')
-	{
-	  int verbosity=atoi (argv[i+1]) ;
-	  LogSetParameter (XLOG_VERBOSITY, verbosity) ;
-	  EPHYR_LOG ("set verbosiry to %d\n", verbosity) ;
-	  return 2 ;
-	}
-      else
-	{
-	  UseMsg() ;
-	  exit(1) ;
-	}
+    else if (!strcmp(argv[i], "-verbosity")) {
+        if (i + 1 < argc && argv[i + 1][0] != '-') {
+            int verbosity = atoi(argv[i + 1]);
+
+            LogSetParameter(XLOG_VERBOSITY, verbosity);
+            EPHYR_LOG("set verbosiry to %d\n", verbosity);
+            return 2;
+        }
+        else {
+            UseMsg();
+            exit(1);
+        }
     }
 #ifdef GLXEXT
-  else if (!strcmp (argv[i], "-nodri"))
-   {
-       noGlxVisualInit = FALSE ;
-       ephyrNoDRI = TRUE ;
-       EPHYR_LOG ("no direct rendering enabled\n") ;
-       return 1 ;
-   }
+    else if (!strcmp(argv[i], "-nodri")) {
+        noGlxVisualInit = FALSE;
+        ephyrNoDRI = TRUE;
+        EPHYR_LOG("no direct rendering enabled\n");
+        return 1;
+    }
 #endif
-  else if (!strcmp (argv[i], "-noxv"))
-   {
-       ephyrNoXV = TRUE ;
-       EPHYR_LOG ("no XVideo enabled\n") ;
-       return 1 ;
-   }
-  else if (!strcmp (argv[i], "-name"))
-   {
-       if (i+1 < argc && argv[i+1][0] != '-')
-         {
-           hostx_use_resname(argv[i+1], 1);
-           return 2;
-         }
-       else
-         {
-           UseMsg();
-           return 0;
-         }
-   }
-  else if (!strcmp (argv[i], "-title"))
-   {
-       if (i+1 < argc && argv[i+1][0] != '-')
-         {
-           hostx_set_title(argv[i+1]);
-           return 2;
-         }
-       else
-         {
-           UseMsg();
-           return 0;
-         }
-   }
-  else if (argv[i][0] == ':')
-    {
-      hostx_set_display_name(argv[i]);
+    else if (!strcmp(argv[i], "-noxv")) {
+        ephyrNoXV = TRUE;
+        EPHYR_LOG("no XVideo enabled\n");
+        return 1;
     }
-  /* Xnest compatibility */
-  else if (!strcmp(argv[i], "-display"))
-  {
-      hostx_set_display_name(argv[i+1]);
-      return 2;
-  }
-  else if (!strcmp(argv[i], "-sync") ||
-	   !strcmp(argv[i], "-full") ||
-	   !strcmp(argv[i], "-sss") ||
-	   !strcmp(argv[i], "-install"))
-  {
-      return 1;
-  }
-  else if (!strcmp(argv[i], "-bw") ||
-	   !strcmp(argv[i], "-class") ||
-	   !strcmp(argv[i], "-geometry") ||
-	   !strcmp(argv[i], "-scrns"))
-  {
-      return 2;
-  }
-  /* end Xnest compat */
-
-  return KdProcessArgument (argc, argv, i);
+    else if (!strcmp(argv[i], "-name")) {
+        if (i + 1 < argc && argv[i + 1][0] != '-') {
+            hostx_use_resname(argv[i + 1], 1);
+            return 2;
+        }
+        else {
+            UseMsg();
+            return 0;
+        }
+    }
+    else if (!strcmp(argv[i], "-title")) {
+        if (i + 1 < argc && argv[i + 1][0] != '-') {
+            hostx_set_title(argv[i + 1]);
+            return 2;
+        }
+        else {
+            UseMsg();
+            return 0;
+        }
+    }
+    else if (argv[i][0] == ':') {
+        hostx_set_display_name(argv[i]);
+    }
+    /* Xnest compatibility */
+    else if (!strcmp(argv[i], "-display")) {
+        hostx_set_display_name(argv[i + 1]);
+        return 2;
+    }
+    else if (!strcmp(argv[i], "-sync") ||
+             !strcmp(argv[i], "-full") ||
+             !strcmp(argv[i], "-sss") || !strcmp(argv[i], "-install")) {
+        return 1;
+    }
+    else if (!strcmp(argv[i], "-bw") ||
+             !strcmp(argv[i], "-class") ||
+             !strcmp(argv[i], "-geometry") || !strcmp(argv[i], "-scrns")) {
+        return 2;
+    }
+    /* end Xnest compat */
+
+    return KdProcessArgument(argc, argv, i);
 }
 
 void
-OsVendorInit (void)
+OsVendorInit(void)
 {
-  EPHYR_DBG("mark");
+    EPHYR_DBG("mark");
 
-  if (hostx_want_host_cursor())
-    {
-      ephyrFuncs.initCursor   = &ephyrCursorInit;
-      ephyrFuncs.enableCursor = &ephyrCursorEnable;
+    if (hostx_want_host_cursor()) {
+        ephyrFuncs.initCursor = &ephyrCursorInit;
+        ephyrFuncs.enableCursor = &ephyrCursorEnable;
     }
 
-  KdOsInit (&EphyrOsFuncs);
+    KdOsInit(&EphyrOsFuncs);
 }
 
 /* 'Fake' cursor stuff, could be improved */
@@ -332,31 +305,32 @@ OsVendorInit (void)
 static Bool
 ephyrRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 {
-  return TRUE;
+    return TRUE;
 }
 
 static Bool
 ephyrUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 {
-  return TRUE;
+    return TRUE;
 }
 
 static void
-ephyrSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
+ephyrSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x,
+               int y)
 {
-  ;
+    ;
 }
 
 static void
 ephyrMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
 {
-  ;
+    ;
 }
 
 static Bool
 ephyrDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
 {
-  return TRUE;
+    return TRUE;
 }
 
 static void
@@ -365,57 +339,55 @@ ephyrDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
 }
 
 miPointerSpriteFuncRec EphyrPointerSpriteFuncs = {
-	ephyrRealizeCursor,
-	ephyrUnrealizeCursor,
-	ephyrSetCursor,
-	ephyrMoveCursor,
-	ephyrDeviceCursorInitialize,
-	ephyrDeviceCursorCleanup
+    ephyrRealizeCursor,
+    ephyrUnrealizeCursor,
+    ephyrSetCursor,
+    ephyrMoveCursor,
+    ephyrDeviceCursorInitialize,
+    ephyrDeviceCursorCleanup
 };
 
-
 Bool
 ephyrCursorInit(ScreenPtr pScreen)
 {
-  miPointerInitialize(pScreen,
-		      &EphyrPointerSpriteFuncs,
-		      &ephyrPointerScreenFuncs,
-		      FALSE);
+    miPointerInitialize(pScreen,
+                        &EphyrPointerSpriteFuncs,
+                        &ephyrPointerScreenFuncs, FALSE);
 
-  return TRUE;
+    return TRUE;
 }
 
 void
 ephyrCursorEnable(ScreenPtr pScreen)
 {
-  ;
+    ;
 }
 
 KdCardFuncs ephyrFuncs = {
-    ephyrCardInit,	    /* cardinit */
-    ephyrScreenInit,	    /* scrinit */
-    ephyrInitScreen,	    /* initScreen */
-    ephyrFinishInitScreen,  /* finishInitScreen */
-    ephyrCreateResources,   /* createRes */
-    ephyrPreserve,	    /* preserve */
-    ephyrEnable,	    /* enable */
-    ephyrDPMS,		    /* dpms */
-    ephyrDisable,	    /* disable */
-    ephyrRestore,	    /* restore */
-    ephyrScreenFini,	    /* scrfini */
-    ephyrCardFini,	    /* cardfini */
-
-    0,			    /* initCursor */
-    0,			    /* enableCursor */
-    0,			    /* disableCursor */
-    0,			    /* finiCursor */
-    0,			    /* recolorCursor */
-
-    0,			    /* initAccel */
-    0,			    /* enableAccel */
-    0,			    /* disableAccel */
-    0,			    /* finiAccel */
-
-    ephyrGetColors,/* getColors */
-    ephyrPutColors,	    /* putColors */
+    ephyrCardInit,              /* cardinit */
+    ephyrScreenInit,            /* scrinit */
+    ephyrInitScreen,            /* initScreen */
+    ephyrFinishInitScreen,      /* finishInitScreen */
+    ephyrCreateResources,       /* createRes */
+    ephyrPreserve,              /* preserve */
+    ephyrEnable,                /* enable */
+    ephyrDPMS,                  /* dpms */
+    ephyrDisable,               /* disable */
+    ephyrRestore,               /* restore */
+    ephyrScreenFini,            /* scrfini */
+    ephyrCardFini,              /* cardfini */
+
+    0,                          /* initCursor */
+    0,                          /* enableCursor */
+    0,                          /* disableCursor */
+    0,                          /* finiCursor */
+    0,                          /* recolorCursor */
+
+    0,                          /* initAccel */
+    0,                          /* enableAccel */
+    0,                          /* disableAccel */
+    0,                          /* finiAccel */
+
+    ephyrGetColors,             /* getColors */
+    ephyrPutColors,             /* putColors */
 };
diff --git a/hw/kdrive/ephyr/ephyrlog.h b/hw/kdrive/ephyr/ephyrlog.h
index a07a0a097..0da0a2518 100644
--- a/hw/kdrive/ephyr/ephyrlog.h
+++ b/hw/kdrive/ephyr/ephyrlog.h
@@ -35,7 +35,7 @@
 /*we are not in debug mode*/
 #define EPHYR_LOG(...)
 #define EPHYR_LOG_ERROR(...)
-#endif /*!DEBUG*/
+#endif                          /*!DEBUG */
 
 #define ERROR_LOG_LEVEL 3
 #define INFO_LOG_LEVEL 4
@@ -45,23 +45,23 @@
 LogMessageVerb(X_NOTICE, INFO_LOG_LEVEL, "in %s:%d:%s: ",\
                       __FILE__, __LINE__, __func__) ; \
 LogMessageVerb(X_NOTICE, INFO_LOG_LEVEL, __VA_ARGS__)
-#endif /*nomadik_log*/
+#endif                          /*nomadik_log */
 
 #ifndef EPHYR_LOG_ERROR
 #define EPHYR_LOG_ERROR(...) \
 LogMessageVerb(X_NOTICE, ERROR_LOG_LEVEL, "Error:in %s:%d:%s: ",\
                       __FILE__, __LINE__, __func__) ; \
 LogMessageVerb(X_NOTICE, ERROR_LOG_LEVEL, __VA_ARGS__)
-#endif /*EPHYR_LOG_ERROR*/
+#endif                          /*EPHYR_LOG_ERROR */
 
 #ifndef EPHYR_RETURN_IF_FAIL
 #define EPHYR_RETURN_IF_FAIL(cond) \
 if (!(cond)) {EPHYR_LOG_ERROR("condition %s failed\n", #cond);return;}
-#endif /*nomadik_return_if_fail*/
+#endif                          /*nomadik_return_if_fail */
 
 #ifndef EPHYR_RETURN_VAL_IF_FAIL
 #define EPHYR_RETURN_VAL_IF_FAIL(cond,val) \
 if (!(cond)) {EPHYR_LOG_ERROR("condition %s failed\n", #cond);return val;}
-#endif /*nomadik_return_val_if_fail*/
+#endif                          /*nomadik_return_val_if_fail */
 
 #endif /*__EPHYRLOG_H__*/
diff --git a/hw/kdrive/ephyr/ephyrproxyext.c b/hw/kdrive/ephyr/ephyrproxyext.c
index 0c070f4c7..3d86d2db1 100644
--- a/hw/kdrive/ephyr/ephyrproxyext.c
+++ b/hw/kdrive/ephyr/ephyrproxyext.c
@@ -46,74 +46,70 @@
 #include "ephyrhostproxy.h"
 #include "hostx.h"
 
-static Bool ephyrProxyGetHostExtensionInfo (const char *a_ext_name,
-                                            int *a_major_opcode,
-                                            int *a_first_event,
-                                            int *a_first_error) ;
+static Bool ephyrProxyGetHostExtensionInfo(const char *a_ext_name,
+                                           int *a_major_opcode,
+                                           int *a_first_event,
+                                           int *a_first_error);
 
-static int ephyrProxyProcDispatch (ClientPtr client) ;
+static int ephyrProxyProcDispatch(ClientPtr client);
 
 static Bool
-ephyrProxyGetHostExtensionInfo (const char *a_ext_name,
-                                int *a_major_opcode,
-                                int *a_first_event,
-                                int *a_first_error)
+ephyrProxyGetHostExtensionInfo(const char *a_ext_name,
+                               int *a_major_opcode,
+                               int *a_first_event, int *a_first_error)
 {
-    return hostx_get_extension_info (a_ext_name, a_major_opcode,
-                                     a_first_event, a_first_error) ;
+    return hostx_get_extension_info(a_ext_name, a_major_opcode,
+                                    a_first_event, a_first_error);
 }
 
 static int
-ephyrProxyProcDispatch (ClientPtr a_client)
+ephyrProxyProcDispatch(ClientPtr a_client)
 {
-    int res=BadImplementation ;
-    struct XReply reply ;
+    int res = BadImplementation;
+    struct XReply reply;
 
-    if (!ephyrHostProxyDoForward (a_client->requestBuffer, &reply, FALSE)) {
-        EPHYR_LOG_ERROR ("forwarding failed\n") ;
-        goto out ;
+    if (!ephyrHostProxyDoForward(a_client->requestBuffer, &reply, FALSE)) {
+        EPHYR_LOG_ERROR("forwarding failed\n");
+        goto out;
     }
     reply.sequence_number = a_client->sequence;
-    res = Success ;
+    res = Success;
 
-    WriteToClient(a_client, 32, (char *)&reply);
+    WriteToClient(a_client, 32, (char *) &reply);
 
-out:
-    return res ;
+ out:
+    return res;
 }
 
 static void
-ephyrProxyProcReset (ExtensionEntry *a_entry)
+ephyrProxyProcReset(ExtensionEntry * a_entry)
 {
 }
 
 Bool
-ephyrProxyExtensionInit (const char *a_extension_name)
+ephyrProxyExtensionInit(const char *a_extension_name)
 {
-    Bool is_ok = FALSE ;
-    int major_opcode=0, first_event=0, first_error=0;
-    ExtensionEntry *ext=NULL ;
+    Bool is_ok = FALSE;
+    int major_opcode = 0, first_event = 0, first_error = 0;
+    ExtensionEntry *ext = NULL;
 
-    if (!ephyrProxyGetHostExtensionInfo (a_extension_name,
-                                         &major_opcode,
-                                         &first_event,
-                                         &first_error)) {
-        EPHYR_LOG ("failed to query extension %s from host\n", a_extension_name) ;
+    if (!ephyrProxyGetHostExtensionInfo(a_extension_name,
+                                        &major_opcode,
+                                        &first_event, &first_error)) {
+        EPHYR_LOG("failed to query extension %s from host\n", a_extension_name);
         goto out;
     }
-    ext = AddExtension ((char*)a_extension_name, 0, 0,
-                        ephyrProxyProcDispatch,
-                        ephyrProxyProcDispatch,
-                        ephyrProxyProcReset,
-                        StandardMinorOpcode) ;
+    ext = AddExtension((char *) a_extension_name, 0, 0,
+                       ephyrProxyProcDispatch,
+                       ephyrProxyProcDispatch,
+                       ephyrProxyProcReset, StandardMinorOpcode);
     if (!ext) {
-        EPHYR_LOG_ERROR ("failed to add the extension\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to add the extension\n");
+        goto out;
     }
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
-
diff --git a/hw/kdrive/ephyr/ephyrproxyext.h b/hw/kdrive/ephyr/ephyrproxyext.h
index e52f8d887..018b69b34 100644
--- a/hw/kdrive/ephyr/ephyrproxyext.h
+++ b/hw/kdrive/ephyr/ephyrproxyext.h
@@ -28,7 +28,6 @@
 #ifndef __EPHYRPROXYEXT_H__
 #define __EPHYRPROXYEXT_H__
 
-Bool ephyrProxyExtensionInit (const char *a_extension_name) ;
+Bool ephyrProxyExtensionInit(const char *a_extension_name);
 
 #endif /*__EPHYRPROXYEXT_H__*/
-
diff --git a/hw/kdrive/ephyr/ephyrvideo.c b/hw/kdrive/ephyr/ephyrvideo.c
index 69a89ae61..67eadd121 100644
--- a/hw/kdrive/ephyr/ephyrvideo.c
+++ b/hw/kdrive/ephyr/ephyrvideo.c
@@ -39,171 +39,154 @@
 #include "ephyrhostvideo.h"
 
 struct _EphyrXVPriv {
-    EphyrHostXVAdaptorArray *host_adaptors ;
-    KdVideoAdaptorPtr adaptors ;
-    int num_adaptors ;
+    EphyrHostXVAdaptorArray *host_adaptors;
+    KdVideoAdaptorPtr adaptors;
+    int num_adaptors;
 };
-typedef struct _EphyrXVPriv EphyrXVPriv ;
+typedef struct _EphyrXVPriv EphyrXVPriv;
 
 struct _EphyrPortPriv {
-    int port_number ;
-    KdVideoAdaptorPtr current_adaptor ;
+    int port_number;
+    KdVideoAdaptorPtr current_adaptor;
     EphyrXVPriv *xv_priv;
-    unsigned char *image_buf ;
-    int image_buf_size ;
-    int image_id ;
-    int drw_x, drw_y, drw_w, drw_h ;
-    int src_x, src_y, src_w, src_h ;
-    int image_width, image_height ;
+    unsigned char *image_buf;
+    int image_buf_size;
+    int image_id;
+    int drw_x, drw_y, drw_w, drw_h;
+    int src_x, src_y, src_w, src_h;
+    int image_width, image_height;
 };
-typedef struct _EphyrPortPriv EphyrPortPriv ;
+typedef struct _EphyrPortPriv EphyrPortPriv;
 
-static Bool DoSimpleClip (BoxPtr a_dst_drw,
-                          BoxPtr a_clipper,
-                          BoxPtr a_result) ;
+static Bool DoSimpleClip(BoxPtr a_dst_drw, BoxPtr a_clipper, BoxPtr a_result);
 
-static Bool ephyrLocalAtomToHost (int a_local_atom, int *a_host_atom) ;
+static Bool ephyrLocalAtomToHost(int a_local_atom, int *a_host_atom);
 
 /*
 static Bool ephyrHostAtomToLocal (int a_host_atom, int *a_local_atom) ;
 */
 
-static EphyrXVPriv* ephyrXVPrivNew (void) ;
-static void ephyrXVPrivDelete (EphyrXVPriv *a_this) ;
-static Bool ephyrXVPrivQueryHostAdaptors (EphyrXVPriv *a_this) ;
-static Bool ephyrXVPrivSetAdaptorsHooks (EphyrXVPriv *a_this) ;
-static Bool ephyrXVPrivRegisterAdaptors (EphyrXVPriv *a_this,
-                                         ScreenPtr a_screen) ;
-
-static Bool ephyrXVPrivIsAttrValueValid (KdAttributePtr a_attrs,
-                                         int a_attrs_len,
-                                         const char *a_attr_name,
-                                         int a_attr_value,
-                                         Bool *a_is_valid) ;
-
-static Bool ephyrXVPrivGetImageBufSize (int a_port_id,
-                                        int a_image_id,
-                                        unsigned short a_width,
-                                        unsigned short a_height,
-                                        int *a_size) ;
-
-static Bool ephyrXVPrivSaveImageToPortPriv (EphyrPortPriv *a_port_priv,
-                                            const unsigned char *a_image,
-                                            int a_image_len) ;
-
-static void ephyrStopVideo (KdScreenInfo *a_info,
-                            pointer a_xv_priv,
-                            Bool a_exit);
-
-static int ephyrSetPortAttribute (KdScreenInfo *a_info,
-                                  Atom a_attr_name,
-                                  int a_attr_value,
-                                  pointer a_port_priv);
-
-static int ephyrGetPortAttribute (KdScreenInfo *a_screen_info,
-                                  Atom a_attr_name,
-                                  int *a_attr_value,
-                                  pointer a_port_priv);
-
-static void ephyrQueryBestSize (KdScreenInfo *a_info,
-                                Bool a_motion,
-                                short a_src_w,
-                                short a_src_h,
-                                short a_drw_w,
-                                short a_drw_h,
-                                unsigned int *a_prefered_w,
-                                unsigned int *a_prefered_h,
-                                pointer a_port_priv);
-
-static int ephyrPutImage (KdScreenInfo *a_info,
-                          DrawablePtr a_drawable,
-                          short a_src_x,
-                          short a_src_y,
-                          short a_drw_x,
-                          short a_drw_y,
-                          short a_src_w,
-                          short a_src_h,
-                          short a_drw_w,
-                          short a_drw_h,
-                          int a_id,
-                          unsigned char *a_buf,
-                          short a_width,
-                          short a_height,
-                          Bool a_sync,
-                          RegionPtr a_clipping_region,
-                          pointer a_port_priv);
-
-static int ephyrReputImage (KdScreenInfo *a_info,
-                            DrawablePtr a_drawable,
-                            short a_drw_x,
-                            short a_drw_y,
-                            RegionPtr a_clipping_region,
-                            pointer a_port_priv) ;
-
-static int ephyrPutVideo (KdScreenInfo *a_info,
-                          DrawablePtr a_drawable,
-                          short a_vid_x, short a_vid_y,
-                          short a_drw_x, short a_drw_y,
-                          short a_vid_w, short a_vid_h,
-                          short a_drw_w, short a_drw_h,
-                          RegionPtr a_clip_region,
-                          pointer a_port_priv) ;
-
-static int ephyrGetVideo (KdScreenInfo *a_info,
-                          DrawablePtr a_drawable,
-                          short a_vid_x, short a_vid_y,
-                          short a_drw_x, short a_drw_y,
-                          short a_vid_w, short a_vid_h,
-                          short a_drw_w, short a_drw_h,
-                          RegionPtr a_clip_region,
-                          pointer a_port_priv) ;
-
-static int ephyrPutStill (KdScreenInfo *a_info,
-                          DrawablePtr a_drawable,
-                          short a_vid_x, short a_vid_y,
-                          short a_drw_x, short a_drw_y,
-                          short a_vid_w, short a_vid_h,
-                          short a_drw_w, short a_drw_h,
-                          RegionPtr a_clip_region,
-                          pointer a_port_priv) ;
-
-static int ephyrGetStill (KdScreenInfo *a_info,
-                          DrawablePtr a_drawable,
-                          short a_vid_x, short a_vid_y,
-                          short a_drw_x, short a_drw_y,
-                          short a_vid_w, short a_vid_h,
-                          short a_drw_w, short a_drw_h,
-                          RegionPtr a_clip_region,
-                          pointer a_port_priv) ;
-
-static int ephyrQueryImageAttributes (KdScreenInfo *a_info,
-                                      int a_id,
-                                      unsigned short *a_w,
-                                      unsigned short *a_h,
-                                      int *a_pitches,
-                                      int *a_offsets);
-static int s_base_port_id ;
+static EphyrXVPriv *ephyrXVPrivNew(void);
+static void ephyrXVPrivDelete(EphyrXVPriv * a_this);
+static Bool ephyrXVPrivQueryHostAdaptors(EphyrXVPriv * a_this);
+static Bool ephyrXVPrivSetAdaptorsHooks(EphyrXVPriv * a_this);
+static Bool ephyrXVPrivRegisterAdaptors(EphyrXVPriv * a_this,
+                                        ScreenPtr a_screen);
+
+static Bool ephyrXVPrivIsAttrValueValid(KdAttributePtr a_attrs,
+                                        int a_attrs_len,
+                                        const char *a_attr_name,
+                                        int a_attr_value, Bool *a_is_valid);
+
+static Bool ephyrXVPrivGetImageBufSize(int a_port_id,
+                                       int a_image_id,
+                                       unsigned short a_width,
+                                       unsigned short a_height, int *a_size);
+
+static Bool ephyrXVPrivSaveImageToPortPriv(EphyrPortPriv * a_port_priv,
+                                           const unsigned char *a_image,
+                                           int a_image_len);
+
+static void ephyrStopVideo(KdScreenInfo * a_info,
+                           pointer a_xv_priv, Bool a_exit);
+
+static int ephyrSetPortAttribute(KdScreenInfo * a_info,
+                                 Atom a_attr_name,
+                                 int a_attr_value, pointer a_port_priv);
+
+static int ephyrGetPortAttribute(KdScreenInfo * a_screen_info,
+                                 Atom a_attr_name,
+                                 int *a_attr_value, pointer a_port_priv);
+
+static void ephyrQueryBestSize(KdScreenInfo * a_info,
+                               Bool a_motion,
+                               short a_src_w,
+                               short a_src_h,
+                               short a_drw_w,
+                               short a_drw_h,
+                               unsigned int *a_prefered_w,
+                               unsigned int *a_prefered_h, pointer a_port_priv);
+
+static int ephyrPutImage(KdScreenInfo * a_info,
+                         DrawablePtr a_drawable,
+                         short a_src_x,
+                         short a_src_y,
+                         short a_drw_x,
+                         short a_drw_y,
+                         short a_src_w,
+                         short a_src_h,
+                         short a_drw_w,
+                         short a_drw_h,
+                         int a_id,
+                         unsigned char *a_buf,
+                         short a_width,
+                         short a_height,
+                         Bool a_sync,
+                         RegionPtr a_clipping_region, pointer a_port_priv);
+
+static int ephyrReputImage(KdScreenInfo * a_info,
+                           DrawablePtr a_drawable,
+                           short a_drw_x,
+                           short a_drw_y,
+                           RegionPtr a_clipping_region, pointer a_port_priv);
+
+static int ephyrPutVideo(KdScreenInfo * a_info,
+                         DrawablePtr a_drawable,
+                         short a_vid_x, short a_vid_y,
+                         short a_drw_x, short a_drw_y,
+                         short a_vid_w, short a_vid_h,
+                         short a_drw_w, short a_drw_h,
+                         RegionPtr a_clip_region, pointer a_port_priv);
+
+static int ephyrGetVideo(KdScreenInfo * a_info,
+                         DrawablePtr a_drawable,
+                         short a_vid_x, short a_vid_y,
+                         short a_drw_x, short a_drw_y,
+                         short a_vid_w, short a_vid_h,
+                         short a_drw_w, short a_drw_h,
+                         RegionPtr a_clip_region, pointer a_port_priv);
+
+static int ephyrPutStill(KdScreenInfo * a_info,
+                         DrawablePtr a_drawable,
+                         short a_vid_x, short a_vid_y,
+                         short a_drw_x, short a_drw_y,
+                         short a_vid_w, short a_vid_h,
+                         short a_drw_w, short a_drw_h,
+                         RegionPtr a_clip_region, pointer a_port_priv);
+
+static int ephyrGetStill(KdScreenInfo * a_info,
+                         DrawablePtr a_drawable,
+                         short a_vid_x, short a_vid_y,
+                         short a_drw_x, short a_drw_y,
+                         short a_vid_w, short a_vid_h,
+                         short a_drw_w, short a_drw_h,
+                         RegionPtr a_clip_region, pointer a_port_priv);
+
+static int ephyrQueryImageAttributes(KdScreenInfo * a_info,
+                                     int a_id,
+                                     unsigned short *a_w,
+                                     unsigned short *a_h,
+                                     int *a_pitches, int *a_offsets);
+static int s_base_port_id;
 
 /**************
  * <helpers>
  * ************/
 
 static Bool
-DoSimpleClip (BoxPtr a_dst_box,
-              BoxPtr a_clipper,
-              BoxPtr a_result)
+DoSimpleClip(BoxPtr a_dst_box, BoxPtr a_clipper, BoxPtr a_result)
 {
-    BoxRec dstClippedBox ;
+    BoxRec dstClippedBox;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_dst_box && a_clipper && a_result, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_dst_box && a_clipper && a_result, FALSE);
 
     /*
      * setup the clipbox inside the destination.
      */
-    dstClippedBox.x1 = a_dst_box->x1 ;
-    dstClippedBox.x2 = a_dst_box->x2 ;
-    dstClippedBox.y1 = a_dst_box->y1 ;
-    dstClippedBox.y2 = a_dst_box->y2 ;
+    dstClippedBox.x1 = a_dst_box->x1;
+    dstClippedBox.x2 = a_dst_box->x2;
+    dstClippedBox.y1 = a_dst_box->y1;
+    dstClippedBox.y2 = a_dst_box->y2;
 
     /*
      * if the cliper leftmost edge is inside
@@ -211,7 +194,7 @@ DoSimpleClip (BoxPtr a_dst_box,
      * clipped box is the leftmost edge of the cliper.
      */
     if (a_clipper->x1 > dstClippedBox.x1)
-        dstClippedBox.x1 = a_clipper->x1 ;
+        dstClippedBox.x1 = a_clipper->x1;
 
     /*
      * if the cliper top edge is inside the destination area
@@ -219,43 +202,42 @@ DoSimpleClip (BoxPtr a_dst_box,
      * is the bottom edge of the cliper
      */
     if (a_clipper->y1 > dstClippedBox.y1)
-        dstClippedBox.y1 = a_clipper->y1 ;
+        dstClippedBox.y1 = a_clipper->y1;
 
-    /*ditto for right edge*/
+    /*ditto for right edge */
     if (a_clipper->x2 < dstClippedBox.x2)
-        dstClippedBox.x2 = a_clipper->x2 ;
+        dstClippedBox.x2 = a_clipper->x2;
 
-    /*ditto for bottom edge*/
+    /*ditto for bottom edge */
     if (a_clipper->y2 < dstClippedBox.y2)
-        dstClippedBox.y2 = a_clipper->y2 ;
+        dstClippedBox.y2 = a_clipper->y2;
 
-    memcpy (a_result, &dstClippedBox, sizeof (dstClippedBox)) ;
-    return TRUE ;
+    memcpy(a_result, &dstClippedBox, sizeof(dstClippedBox));
+    return TRUE;
 }
 
 static Bool
-ephyrLocalAtomToHost (int a_local_atom, int *a_host_atom)
+ephyrLocalAtomToHost(int a_local_atom, int *a_host_atom)
 {
-    const char *atom_name=NULL;
-    int host_atom=None ;
+    const char *atom_name = NULL;
+    int host_atom = None;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_host_atom, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_host_atom, FALSE);
 
-    if (!ValidAtom (a_local_atom))
-        return FALSE ;
+    if (!ValidAtom(a_local_atom))
+        return FALSE;
 
-    atom_name = NameForAtom (a_local_atom) ;
+    atom_name = NameForAtom(a_local_atom);
 
     if (!atom_name)
-        return FALSE ;
+        return FALSE;
 
-    if (!ephyrHostGetAtom (atom_name, FALSE, &host_atom) || host_atom == None) {
-        EPHYR_LOG_ERROR ("no atom for string %s defined in host X\n",
-                         atom_name) ;
-        return FALSE ;
+    if (!ephyrHostGetAtom(atom_name, FALSE, &host_atom) || host_atom == None) {
+        EPHYR_LOG_ERROR("no atom for string %s defined in host X\n", atom_name);
+        return FALSE;
     }
-    *a_host_atom = host_atom ;
-    return TRUE ;
+    *a_host_atom = host_atom;
+    return TRUE;
 }
 
 /*
@@ -293,981 +275,944 @@ out:
  * ************/
 
 Bool
-ephyrInitVideo (ScreenPtr pScreen)
+ephyrInitVideo(ScreenPtr pScreen)
 {
-    Bool is_ok = FALSE ;
+    Bool is_ok = FALSE;
+
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     static EphyrXVPriv *xv_priv;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     if (screen->fb.bitsPerPixel == 8) {
-        EPHYR_LOG_ERROR ("8 bits depth not supported\n") ;
-        return FALSE ;
+        EPHYR_LOG_ERROR("8 bits depth not supported\n");
+        return FALSE;
     }
 
     if (!xv_priv) {
-        xv_priv = ephyrXVPrivNew () ;
+        xv_priv = ephyrXVPrivNew();
     }
     if (!xv_priv) {
-        EPHYR_LOG_ERROR ("failed to create xv_priv\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create xv_priv\n");
+        goto out;
     }
 
-    if (!ephyrXVPrivRegisterAdaptors (xv_priv, pScreen)) {
-        EPHYR_LOG_ERROR ("failed to register adaptors\n") ;
-        goto out ;
+    if (!ephyrXVPrivRegisterAdaptors(xv_priv, pScreen)) {
+        EPHYR_LOG_ERROR("failed to register adaptors\n");
+        goto out;
     }
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
-    return is_ok ;
+ out:
+    return is_ok;
 }
 
-static EphyrXVPriv*
-ephyrXVPrivNew (void)
+static EphyrXVPriv *
+ephyrXVPrivNew(void)
 {
-    EphyrXVPriv *xv_priv=NULL ;
+    EphyrXVPriv *xv_priv = NULL;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    xv_priv = calloc(1, sizeof (EphyrXVPriv)) ;
+    xv_priv = calloc(1, sizeof(EphyrXVPriv));
     if (!xv_priv) {
-        EPHYR_LOG_ERROR ("failed to create EphyrXVPriv\n") ;
-        goto error ;
+        EPHYR_LOG_ERROR("failed to create EphyrXVPriv\n");
+        goto error;
     }
 
-    ephyrHostXVInit () ;
+    ephyrHostXVInit();
 
-    if (!ephyrXVPrivQueryHostAdaptors (xv_priv)) {
-        EPHYR_LOG_ERROR ("failed to query the host x for xv properties\n") ;
-        goto error ;
+    if (!ephyrXVPrivQueryHostAdaptors(xv_priv)) {
+        EPHYR_LOG_ERROR("failed to query the host x for xv properties\n");
+        goto error;
     }
-    if (!ephyrXVPrivSetAdaptorsHooks (xv_priv)) {
-        EPHYR_LOG_ERROR ("failed to set xv_priv hooks\n") ;
-        goto error ;
+    if (!ephyrXVPrivSetAdaptorsHooks(xv_priv)) {
+        EPHYR_LOG_ERROR("failed to set xv_priv hooks\n");
+        goto error;
     }
 
-    EPHYR_LOG ("leave\n") ;
-    return xv_priv ;
+    EPHYR_LOG("leave\n");
+    return xv_priv;
 
-error:
+ error:
     if (xv_priv) {
-        ephyrXVPrivDelete (xv_priv) ;
-        xv_priv = NULL ;
+        ephyrXVPrivDelete(xv_priv);
+        xv_priv = NULL;
     }
-    return NULL ;
+    return NULL;
 }
 
 static void
-ephyrXVPrivDelete (EphyrXVPriv *a_this)
+ephyrXVPrivDelete(EphyrXVPriv * a_this)
 {
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     if (!a_this)
-        return ;
+        return;
     if (a_this->host_adaptors) {
-        ephyrHostXVAdaptorArrayDelete (a_this->host_adaptors) ;
-        a_this->host_adaptors = NULL ;
+        ephyrHostXVAdaptorArrayDelete(a_this->host_adaptors);
+        a_this->host_adaptors = NULL;
     }
-    free(a_this->adaptors) ;
-    a_this->adaptors = NULL ;
-    free(a_this) ;
-    EPHYR_LOG ("leave\n") ;
+    free(a_this->adaptors);
+    a_this->adaptors = NULL;
+    free(a_this);
+    EPHYR_LOG("leave\n");
 }
 
 static KdVideoEncodingPtr
-videoEncodingDup (EphyrHostEncoding *a_encodings,
-                   int a_num_encodings)
+videoEncodingDup(EphyrHostEncoding * a_encodings, int a_num_encodings)
 {
-    KdVideoEncodingPtr result = NULL ;
-    int i=0 ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (a_encodings && a_num_encodings, NULL) ;
-
-    result = calloc(a_num_encodings, sizeof (KdVideoEncodingRec)) ;
-    for (i=0 ; i < a_num_encodings; i++) {
-        result[i].id = a_encodings[i].id ;
-        result[i].name = strdup (a_encodings[i].name) ;
-        result[i].width = a_encodings[i].width ;
-        result[i].height = a_encodings[i].height ;
-        result[i].rate.numerator = a_encodings[i].rate.numerator ;
-        result[i].rate.denominator = a_encodings[i].rate.denominator ;
+    KdVideoEncodingPtr result = NULL;
+    int i = 0;
+
+    EPHYR_RETURN_VAL_IF_FAIL(a_encodings && a_num_encodings, NULL);
+
+    result = calloc(a_num_encodings, sizeof(KdVideoEncodingRec));
+    for (i = 0; i < a_num_encodings; i++) {
+        result[i].id = a_encodings[i].id;
+        result[i].name = strdup(a_encodings[i].name);
+        result[i].width = a_encodings[i].width;
+        result[i].height = a_encodings[i].height;
+        result[i].rate.numerator = a_encodings[i].rate.numerator;
+        result[i].rate.denominator = a_encodings[i].rate.denominator;
     }
-    return result ;
+    return result;
 }
 
 static KdAttributePtr
-portAttributesDup (EphyrHostAttribute *a_encodings,
-                   int a_num_encodings)
+portAttributesDup(EphyrHostAttribute * a_encodings, int a_num_encodings)
 {
-    int i=0 ;
-    KdAttributePtr result=NULL ;
+    int i = 0;
+    KdAttributePtr result = NULL;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_encodings && a_num_encodings, NULL) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_encodings && a_num_encodings, NULL);
 
-    result = calloc(a_num_encodings, sizeof (KdAttributeRec)) ;
+    result = calloc(a_num_encodings, sizeof(KdAttributeRec));
     if (!result) {
-        EPHYR_LOG_ERROR ("failed to allocate attributes\n") ;
-        return NULL ;
+        EPHYR_LOG_ERROR("failed to allocate attributes\n");
+        return NULL;
     }
-    for (i=0; i < a_num_encodings; i++) {
-        result[i].flags = a_encodings[i].flags ;
-        result[i].min_value = a_encodings[i].min_value ;
-        result[i].max_value = a_encodings[i].max_value ;
-        result[i].name = strdup (a_encodings[i].name) ;
+    for (i = 0; i < a_num_encodings; i++) {
+        result[i].flags = a_encodings[i].flags;
+        result[i].min_value = a_encodings[i].min_value;
+        result[i].max_value = a_encodings[i].max_value;
+        result[i].name = strdup(a_encodings[i].name);
     }
-    return result ;
+    return result;
 }
 
 static Bool
-ephyrXVPrivQueryHostAdaptors (EphyrXVPriv *a_this)
+ephyrXVPrivQueryHostAdaptors(EphyrXVPriv * a_this)
 {
-    EphyrHostXVAdaptor *cur_host_adaptor=NULL ;
-    EphyrHostVideoFormat *video_formats=NULL ;
-    EphyrHostEncoding *encodings=NULL ;
-    EphyrHostAttribute *attributes=NULL ;
-    EphyrHostImageFormat *image_formats=NULL ;
-    int num_video_formats=0, base_port_id=0,
-        num_attributes=0, num_formats=0, i=0,
-        port_priv_offset=0;
-    unsigned num_encodings=0 ;
-    Bool is_ok = FALSE ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, FALSE) ;
-
-    EPHYR_LOG ("enter\n") ;
-
-    if (!ephyrHostXVQueryAdaptors (&a_this->host_adaptors)) {
-        EPHYR_LOG_ERROR ("failed to query host adaptors\n") ;
-        goto out ;
+    EphyrHostXVAdaptor *cur_host_adaptor = NULL;
+    EphyrHostVideoFormat *video_formats = NULL;
+    EphyrHostEncoding *encodings = NULL;
+    EphyrHostAttribute *attributes = NULL;
+    EphyrHostImageFormat *image_formats = NULL;
+    int num_video_formats = 0, base_port_id = 0,
+        num_attributes = 0, num_formats = 0, i = 0, port_priv_offset = 0;
+    unsigned num_encodings = 0;
+    Bool is_ok = FALSE;
+
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, FALSE);
+
+    EPHYR_LOG("enter\n");
+
+    if (!ephyrHostXVQueryAdaptors(&a_this->host_adaptors)) {
+        EPHYR_LOG_ERROR("failed to query host adaptors\n");
+        goto out;
     }
     if (a_this->host_adaptors)
         a_this->num_adaptors =
-                    ephyrHostXVAdaptorArrayGetSize (a_this->host_adaptors) ;
+            ephyrHostXVAdaptorArrayGetSize(a_this->host_adaptors);
     if (a_this->num_adaptors < 0) {
-        EPHYR_LOG_ERROR ("failed to get number of host adaptors\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to get number of host adaptors\n");
+        goto out;
     }
-    EPHYR_LOG ("host has %d adaptors\n", a_this->num_adaptors) ;
+    EPHYR_LOG("host has %d adaptors\n", a_this->num_adaptors);
     /*
      * copy what we can from adaptors into a_this->adaptors
      */
     if (a_this->num_adaptors) {
         a_this->adaptors = calloc(a_this->num_adaptors,
-                                    sizeof (KdVideoAdaptorRec)) ;
+                                  sizeof(KdVideoAdaptorRec));
         if (!a_this->adaptors) {
-            EPHYR_LOG_ERROR ("failed to create internal adaptors\n") ;
-            goto out ;
+            EPHYR_LOG_ERROR("failed to create internal adaptors\n");
+            goto out;
         }
     }
-    for (i=0; i < a_this->num_adaptors; i++) {
-        int j=0 ;
-        cur_host_adaptor =
-                   ephyrHostXVAdaptorArrayAt (a_this->host_adaptors, i) ;
+    for (i = 0; i < a_this->num_adaptors; i++) {
+        int j = 0;
+
+        cur_host_adaptor = ephyrHostXVAdaptorArrayAt(a_this->host_adaptors, i);
         if (!cur_host_adaptor)
-            continue ;
+            continue;
         a_this->adaptors[i].nPorts =
-                            ephyrHostXVAdaptorGetNbPorts (cur_host_adaptor) ;
-        if (a_this->adaptors[i].nPorts <=0) {
-            EPHYR_LOG_ERROR ("Could not find any port of adaptor %d\n", i) ;
-            continue ;
+            ephyrHostXVAdaptorGetNbPorts(cur_host_adaptor);
+        if (a_this->adaptors[i].nPorts <= 0) {
+            EPHYR_LOG_ERROR("Could not find any port of adaptor %d\n", i);
+            continue;
         }
-        a_this->adaptors[i].type =
-                        ephyrHostXVAdaptorGetType (cur_host_adaptor) ;
-        a_this->adaptors[i].type |= XvWindowMask ;
+        a_this->adaptors[i].type = ephyrHostXVAdaptorGetType(cur_host_adaptor);
+        a_this->adaptors[i].type |= XvWindowMask;
         a_this->adaptors[i].flags =
-                        VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
-        if (ephyrHostXVAdaptorGetName (cur_host_adaptor))
+            VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
+        if (ephyrHostXVAdaptorGetName(cur_host_adaptor))
             a_this->adaptors[i].name =
-                    strdup (ephyrHostXVAdaptorGetName (cur_host_adaptor)) ;
+                strdup(ephyrHostXVAdaptorGetName(cur_host_adaptor));
         else
-            a_this->adaptors[i].name = strdup ("Xephyr Video Overlay");
-        base_port_id = ephyrHostXVAdaptorGetFirstPortID (cur_host_adaptor) ;
+            a_this->adaptors[i].name = strdup("Xephyr Video Overlay");
+        base_port_id = ephyrHostXVAdaptorGetFirstPortID(cur_host_adaptor);
         if (base_port_id < 0) {
-            EPHYR_LOG_ERROR ("failed to get port id for adaptor %d\n", i) ;
-            continue ;
+            EPHYR_LOG_ERROR("failed to get port id for adaptor %d\n", i);
+            continue;
         }
         if (!s_base_port_id)
-            s_base_port_id = base_port_id ;
-
-        if (!ephyrHostXVQueryEncodings (base_port_id,
-                                        &encodings,
-                                        &num_encodings)) {
-            EPHYR_LOG_ERROR ("failed to get encodings for port port id %d,"
-                             " adaptors %d\n",
-                             base_port_id, i) ;
-            continue ;
+            s_base_port_id = base_port_id;
+
+        if (!ephyrHostXVQueryEncodings(base_port_id,
+                                       &encodings, &num_encodings)) {
+            EPHYR_LOG_ERROR("failed to get encodings for port port id %d,"
+                            " adaptors %d\n", base_port_id, i);
+            continue;
         }
-        a_this->adaptors[i].nEncodings = num_encodings ;
+        a_this->adaptors[i].nEncodings = num_encodings;
         a_this->adaptors[i].pEncodings =
-                            videoEncodingDup (encodings, num_encodings) ;
-        video_formats = (EphyrHostVideoFormat*)
-            ephyrHostXVAdaptorGetVideoFormats (cur_host_adaptor,
-                                               &num_video_formats);
-        a_this->adaptors[i].pFormats = (KdVideoFormatPtr) video_formats ;
-        a_this->adaptors[i].nFormats = num_video_formats ;
+            videoEncodingDup(encodings, num_encodings);
+        video_formats = (EphyrHostVideoFormat *)
+            ephyrHostXVAdaptorGetVideoFormats(cur_host_adaptor,
+                                              &num_video_formats);
+        a_this->adaptors[i].pFormats = (KdVideoFormatPtr) video_formats;
+        a_this->adaptors[i].nFormats = num_video_formats;
         /* got a_this->adaptors[i].nPorts already
-        a_this->adaptors[i].nPorts =
-                            ephyrHostXVAdaptorGetNbPorts (cur_host_adaptor) ;
-        */
+           a_this->adaptors[i].nPorts =
+           ephyrHostXVAdaptorGetNbPorts (cur_host_adaptor) ;
+         */
         a_this->adaptors[i].pPortPrivates =
-                calloc(a_this->adaptors[i].nPorts,
-                         sizeof (DevUnion) + sizeof (EphyrPortPriv)) ;
+            calloc(a_this->adaptors[i].nPorts,
+                   sizeof(DevUnion) + sizeof(EphyrPortPriv));
         port_priv_offset = a_this->adaptors[i].nPorts;
-        for (j=0; j < a_this->adaptors[i].nPorts; j++) {
+        for (j = 0; j < a_this->adaptors[i].nPorts; j++) {
             EphyrPortPriv *port_privs_base =
-                    (EphyrPortPriv*)&a_this->adaptors[i].pPortPrivates[port_priv_offset];
-            EphyrPortPriv *port_priv = &port_privs_base[j] ;
+                (EphyrPortPriv *) & a_this->adaptors[i].
+                pPortPrivates[port_priv_offset];
+            EphyrPortPriv *port_priv = &port_privs_base[j];
+
             port_priv->port_number = base_port_id + j;
-            port_priv->current_adaptor = &a_this->adaptors[i] ;
-            port_priv->xv_priv = a_this ;
+            port_priv->current_adaptor = &a_this->adaptors[i];
+            port_priv->xv_priv = a_this;
             a_this->adaptors[i].pPortPrivates[j].ptr = port_priv;
         }
-        if (!ephyrHostXVQueryPortAttributes (base_port_id,
-                                             &attributes,
-                                             &num_attributes)) {
-            EPHYR_LOG_ERROR ("failed to get port attribute "
-                             "for adaptor %d\n", i) ;
-            continue ;
+        if (!ephyrHostXVQueryPortAttributes(base_port_id,
+                                            &attributes, &num_attributes)) {
+            EPHYR_LOG_ERROR("failed to get port attribute "
+                            "for adaptor %d\n", i);
+            continue;
         }
         a_this->adaptors[i].pAttributes =
-                    portAttributesDup (attributes, num_attributes);
-        a_this->adaptors[i].nAttributes = num_attributes ;
-        /*make sure atoms of attrs names are created in xephyr*/
-        for (j=0; j < a_this->adaptors[i].nAttributes; j++) {
+            portAttributesDup(attributes, num_attributes);
+        a_this->adaptors[i].nAttributes = num_attributes;
+        /*make sure atoms of attrs names are created in xephyr */
+        for (j = 0; j < a_this->adaptors[i].nAttributes; j++) {
             if (a_this->adaptors[i].pAttributes[j].name)
-                MakeAtom (a_this->adaptors[i].pAttributes[j].name,
-                          strlen (a_this->adaptors[i].pAttributes[j].name),
-                          TRUE) ;
+                MakeAtom(a_this->adaptors[i].pAttributes[j].name,
+                         strlen(a_this->adaptors[i].pAttributes[j].name), TRUE);
         }
-        if (!ephyrHostXVQueryImageFormats (base_port_id,
-                                           &image_formats,
-                                           &num_formats)) {
-            EPHYR_LOG_ERROR ("failed to get image formats "
-                             "for adaptor %d\n", i) ;
-            continue ;
+        if (!ephyrHostXVQueryImageFormats(base_port_id,
+                                          &image_formats, &num_formats)) {
+            EPHYR_LOG_ERROR("failed to get image formats "
+                            "for adaptor %d\n", i);
+            continue;
         }
-        a_this->adaptors[i].pImages = (KdImagePtr) image_formats ;
-        a_this->adaptors[i].nImages = num_formats ;
+        a_this->adaptors[i].pImages = (KdImagePtr) image_formats;
+        a_this->adaptors[i].nImages = num_formats;
     }
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
+ out:
     if (encodings) {
-        ephyrHostEncodingsDelete (encodings, num_encodings) ;
-        encodings = NULL ;
+        ephyrHostEncodingsDelete(encodings, num_encodings);
+        encodings = NULL;
     }
     if (attributes) {
-        ephyrHostAttributesDelete (attributes) ;
-        attributes = NULL ;
+        ephyrHostAttributesDelete(attributes);
+        attributes = NULL;
     }
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 static Bool
-ephyrXVPrivSetAdaptorsHooks (EphyrXVPriv *a_this)
+ephyrXVPrivSetAdaptorsHooks(EphyrXVPriv * a_this)
 {
-    int i=0 ;
-    Bool has_it=FALSE ;
-    EphyrHostXVAdaptor *cur_host_adaptor=NULL ;
+    int i = 0;
+    Bool has_it = FALSE;
+    EphyrHostXVAdaptor *cur_host_adaptor = NULL;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_this, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    for (i=0; i < a_this->num_adaptors; i++) {
-        a_this->adaptors[i].ReputImage = ephyrReputImage ;
-        a_this->adaptors[i].StopVideo = ephyrStopVideo ;
-        a_this->adaptors[i].SetPortAttribute = ephyrSetPortAttribute ;
-        a_this->adaptors[i].GetPortAttribute = ephyrGetPortAttribute ;
-        a_this->adaptors[i].QueryBestSize = ephyrQueryBestSize ;
-        a_this->adaptors[i].QueryImageAttributes = ephyrQueryImageAttributes ;
+    for (i = 0; i < a_this->num_adaptors; i++) {
+        a_this->adaptors[i].ReputImage = ephyrReputImage;
+        a_this->adaptors[i].StopVideo = ephyrStopVideo;
+        a_this->adaptors[i].SetPortAttribute = ephyrSetPortAttribute;
+        a_this->adaptors[i].GetPortAttribute = ephyrGetPortAttribute;
+        a_this->adaptors[i].QueryBestSize = ephyrQueryBestSize;
+        a_this->adaptors[i].QueryImageAttributes = ephyrQueryImageAttributes;
 
-        cur_host_adaptor =
-                   ephyrHostXVAdaptorArrayAt (a_this->host_adaptors, i) ;
+        cur_host_adaptor = ephyrHostXVAdaptorArrayAt(a_this->host_adaptors, i);
         if (!cur_host_adaptor) {
-            EPHYR_LOG_ERROR ("failed to get host adaptor at index %d\n", i) ;
-            continue ;
+            EPHYR_LOG_ERROR("failed to get host adaptor at index %d\n", i);
+            continue;
         }
-        has_it = FALSE ;
-        if (!ephyrHostXVAdaptorHasPutImage (cur_host_adaptor, &has_it)) {
-            EPHYR_LOG_ERROR ("error\n") ;
+        has_it = FALSE;
+        if (!ephyrHostXVAdaptorHasPutImage(cur_host_adaptor, &has_it)) {
+            EPHYR_LOG_ERROR("error\n");
         }
         if (has_it) {
             a_this->adaptors[i].PutImage = ephyrPutImage;
         }
 
-        has_it = FALSE ;
-        if (!ephyrHostXVAdaptorHasPutVideo (cur_host_adaptor, &has_it)) {
-            EPHYR_LOG_ERROR ("error\n") ;
+        has_it = FALSE;
+        if (!ephyrHostXVAdaptorHasPutVideo(cur_host_adaptor, &has_it)) {
+            EPHYR_LOG_ERROR("error\n");
         }
         if (has_it) {
             a_this->adaptors[i].PutVideo = ephyrPutVideo;
         }
 
-        has_it = FALSE ;
-        if (!ephyrHostXVAdaptorHasGetVideo (cur_host_adaptor, &has_it)) {
-            EPHYR_LOG_ERROR ("error\n") ;
+        has_it = FALSE;
+        if (!ephyrHostXVAdaptorHasGetVideo(cur_host_adaptor, &has_it)) {
+            EPHYR_LOG_ERROR("error\n");
         }
         if (has_it) {
             a_this->adaptors[i].GetVideo = ephyrGetVideo;
         }
 
-        has_it = FALSE ;
-        if (!ephyrHostXVAdaptorHasPutStill (cur_host_adaptor, &has_it)) {
-            EPHYR_LOG_ERROR ("error\n") ;
+        has_it = FALSE;
+        if (!ephyrHostXVAdaptorHasPutStill(cur_host_adaptor, &has_it)) {
+            EPHYR_LOG_ERROR("error\n");
         }
         if (has_it) {
             a_this->adaptors[i].PutStill = ephyrPutStill;
         }
 
-        has_it = FALSE ;
-        if (!ephyrHostXVAdaptorHasGetStill (cur_host_adaptor, &has_it)) {
-            EPHYR_LOG_ERROR ("error\n") ;
+        has_it = FALSE;
+        if (!ephyrHostXVAdaptorHasGetStill(cur_host_adaptor, &has_it)) {
+            EPHYR_LOG_ERROR("error\n");
         }
         if (has_it) {
             a_this->adaptors[i].GetStill = ephyrGetStill;
         }
     }
-    EPHYR_LOG ("leave\n") ;
-    return TRUE ;
+    EPHYR_LOG("leave\n");
+    return TRUE;
 }
 
 static Bool
-ephyrXVPrivRegisterAdaptors (EphyrXVPriv *a_this,
-                             ScreenPtr a_screen)
+ephyrXVPrivRegisterAdaptors(EphyrXVPriv * a_this, ScreenPtr a_screen)
 {
     KdScreenPriv(a_screen);
     KdScreenInfo *screen = pScreenPriv->screen;
-    Bool is_ok = FALSE ;
-    KdVideoAdaptorPtr *adaptors=NULL, *registered_adaptors=NULL ;
-    int num_registered_adaptors=0, i=0, num_adaptors=0 ;
+    Bool is_ok = FALSE;
+    KdVideoAdaptorPtr *adaptors = NULL, *registered_adaptors = NULL;
+    int num_registered_adaptors = 0, i = 0, num_adaptors = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_this && a_screen, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_this && a_screen, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     if (!a_this->num_adaptors)
-        goto out ;
+        goto out;
     num_registered_adaptors =
-                KdXVListGenericAdaptors (screen, &registered_adaptors);
+        KdXVListGenericAdaptors(screen, &registered_adaptors);
 
-    num_adaptors = num_registered_adaptors + a_this->num_adaptors ;
-    adaptors = calloc(num_adaptors, sizeof (KdVideoAdaptorPtr)) ;
+    num_adaptors = num_registered_adaptors + a_this->num_adaptors;
+    adaptors = calloc(num_adaptors, sizeof(KdVideoAdaptorPtr));
     if (!adaptors) {
-        EPHYR_LOG_ERROR ("failed to allocate adaptors tab\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to allocate adaptors tab\n");
+        goto out;
     }
-    memmove (adaptors, registered_adaptors, num_registered_adaptors) ;
-    for (i=0 ; i < a_this->num_adaptors; i++) {
-        *(adaptors + num_registered_adaptors + i) = &a_this->adaptors[i] ;
+    memmove(adaptors, registered_adaptors, num_registered_adaptors);
+    for (i = 0; i < a_this->num_adaptors; i++) {
+        *(adaptors + num_registered_adaptors + i) = &a_this->adaptors[i];
     }
-    if (!KdXVScreenInit (a_screen, adaptors, num_adaptors)) {
-        EPHYR_LOG_ERROR ("failed to register adaptors\n");
-        goto out ;
+    if (!KdXVScreenInit(a_screen, adaptors, num_adaptors)) {
+        EPHYR_LOG_ERROR("failed to register adaptors\n");
+        goto out;
     }
-    EPHYR_LOG ("there are  %d registered adaptors\n", num_adaptors) ;
-    is_ok = TRUE ;
+    EPHYR_LOG("there are  %d registered adaptors\n", num_adaptors);
+    is_ok = TRUE;
 
-out:
-    free(registered_adaptors) ;
-    registered_adaptors = NULL ;
-    free(adaptors) ;
-    adaptors = NULL ;
+ out:
+    free(registered_adaptors);
+    registered_adaptors = NULL;
+    free(adaptors);
+    adaptors = NULL;
 
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 static Bool
-ephyrXVPrivIsAttrValueValid (KdAttributePtr a_attrs,
-                             int a_attrs_len,
-                             const char *a_attr_name,
-                             int a_attr_value,
-                             Bool *a_is_valid)
+ephyrXVPrivIsAttrValueValid(KdAttributePtr a_attrs,
+                            int a_attrs_len,
+                            const char *a_attr_name,
+                            int a_attr_value, Bool *a_is_valid)
 {
-    int i=0 ;
+    int i = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_attrs && a_attr_name && a_is_valid,
-                              FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_attrs && a_attr_name && a_is_valid, FALSE);
 
-    for (i=0; i < a_attrs_len; i++) {
-        if (a_attrs[i].name && strcmp (a_attrs[i].name, a_attr_name))
-            continue ;
+    for (i = 0; i < a_attrs_len; i++) {
+        if (a_attrs[i].name && strcmp(a_attrs[i].name, a_attr_name))
+            continue;
         if (a_attrs[i].min_value > a_attr_value ||
             a_attrs[i].max_value < a_attr_value) {
-            *a_is_valid = FALSE ;
-            EPHYR_LOG_ERROR ("attribute was not valid\n"
-                             "value:%d. min:%d. max:%d\n",
-                             a_attr_value,
-                             a_attrs[i].min_value,
-                             a_attrs[i].max_value) ;
-        } else {
-            *a_is_valid = TRUE ;
+            *a_is_valid = FALSE;
+            EPHYR_LOG_ERROR("attribute was not valid\n"
+                            "value:%d. min:%d. max:%d\n",
+                            a_attr_value,
+                            a_attrs[i].min_value, a_attrs[i].max_value);
         }
-        return TRUE ;
+        else {
+            *a_is_valid = TRUE;
+        }
+        return TRUE;
     }
-    return FALSE ;
+    return FALSE;
 }
 
 static Bool
-ephyrXVPrivGetImageBufSize (int a_port_id,
-                            int a_image_id,
-                            unsigned short a_width,
-                            unsigned short a_height,
-                            int *a_size)
+ephyrXVPrivGetImageBufSize(int a_port_id,
+                           int a_image_id,
+                           unsigned short a_width,
+                           unsigned short a_height, int *a_size)
 {
-    Bool is_ok=FALSE ;
-    unsigned short width=a_width, height=a_height ;
+    Bool is_ok = FALSE;
+    unsigned short width = a_width, height = a_height;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_size, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_size, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    if (!ephyrHostXVQueryImageAttributes (a_port_id, a_image_id,
-                                          &width, &height, a_size, NULL, NULL)) {
-        EPHYR_LOG_ERROR ("failed to get image attributes\n") ;
-        goto out ;
+    if (!ephyrHostXVQueryImageAttributes(a_port_id, a_image_id,
+                                         &width, &height, a_size, NULL, NULL)) {
+        EPHYR_LOG_ERROR("failed to get image attributes\n");
+        goto out;
     }
-    is_ok = TRUE ;
+    is_ok = TRUE;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 static Bool
-ephyrXVPrivSaveImageToPortPriv (EphyrPortPriv *a_port_priv,
-                                const unsigned char *a_image_buf,
-                                int a_image_len)
+ephyrXVPrivSaveImageToPortPriv(EphyrPortPriv * a_port_priv,
+                               const unsigned char *a_image_buf,
+                               int a_image_len)
 {
-    Bool is_ok=FALSE ;
+    Bool is_ok = FALSE;
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     if (a_port_priv->image_buf_size < a_image_len) {
-        unsigned char *buf=NULL ;
-        buf = realloc (a_port_priv->image_buf, a_image_len) ;
+        unsigned char *buf = NULL;
+
+        buf = realloc(a_port_priv->image_buf, a_image_len);
         if (!buf) {
-            EPHYR_LOG_ERROR ("failed to realloc image buffer\n") ;
-            goto out ;
+            EPHYR_LOG_ERROR("failed to realloc image buffer\n");
+            goto out;
         }
-        a_port_priv->image_buf = buf ;
+        a_port_priv->image_buf = buf;
         a_port_priv->image_buf_size = a_image_len;
     }
-    memmove (a_port_priv->image_buf, a_image_buf, a_image_len) ;
-    is_ok = TRUE ;
+    memmove(a_port_priv->image_buf, a_image_buf, a_image_len);
+    is_ok = TRUE;
 
-out:
-    return is_ok ;
-    EPHYR_LOG ("leave\n") ;
+ out:
+    return is_ok;
+    EPHYR_LOG("leave\n");
 }
 
 static void
-ephyrStopVideo (KdScreenInfo *a_info, pointer a_port_priv, Bool a_exit)
+ephyrStopVideo(KdScreenInfo * a_info, pointer a_port_priv, Bool a_exit)
 {
-    EphyrPortPriv *port_priv = a_port_priv ;
+    EphyrPortPriv *port_priv = a_port_priv;
 
-    EPHYR_RETURN_IF_FAIL (a_info && a_info->pScreen) ;
-    EPHYR_RETURN_IF_FAIL (port_priv) ;
+    EPHYR_RETURN_IF_FAIL(a_info && a_info->pScreen);
+    EPHYR_RETURN_IF_FAIL(port_priv);
 
-    EPHYR_LOG ("enter\n") ;
-    if (!ephyrHostXVStopVideo (a_info->pScreen->myNum,
-                               port_priv->port_number)) {
-        EPHYR_LOG_ERROR ("XvStopVideo() failed\n") ;
+    EPHYR_LOG("enter\n");
+    if (!ephyrHostXVStopVideo(a_info->pScreen->myNum, port_priv->port_number)) {
+        EPHYR_LOG_ERROR("XvStopVideo() failed\n");
     }
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
 }
 
 static int
-ephyrSetPortAttribute (KdScreenInfo *a_info,
-                       Atom a_attr_name,
-                       int a_attr_value,
-                       pointer a_port_priv)
+ephyrSetPortAttribute(KdScreenInfo * a_info,
+                      Atom a_attr_name, int a_attr_value, pointer a_port_priv)
 {
-    int res=Success, host_atom=0 ;
-    EphyrPortPriv *port_priv = a_port_priv ;
-    Bool is_attr_valid=FALSE ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (port_priv, BadMatch) ;
-    EPHYR_RETURN_VAL_IF_FAIL (port_priv->current_adaptor, BadMatch) ;
-    EPHYR_RETURN_VAL_IF_FAIL (port_priv->current_adaptor->pAttributes,
-                              BadMatch) ;
-    EPHYR_RETURN_VAL_IF_FAIL (port_priv->current_adaptor->nAttributes,
-                              BadMatch) ;
-    EPHYR_RETURN_VAL_IF_FAIL (ValidAtom (a_attr_name), BadMatch) ;
-
-    EPHYR_LOG ("enter, portnum:%d, atomid:%d, attr_name:%s, attr_val:%d\n",
-               port_priv->port_number,
-               (int)a_attr_name,
-               NameForAtom (a_attr_name),
-               a_attr_value) ;
-
-    if (!ephyrLocalAtomToHost (a_attr_name, &host_atom)) {
-        EPHYR_LOG_ERROR ("failed to convert local atom to host atom\n") ;
-        res = BadMatch ;
-        goto out ;
+    int res = Success, host_atom = 0;
+    EphyrPortPriv *port_priv = a_port_priv;
+    Bool is_attr_valid = FALSE;
+
+    EPHYR_RETURN_VAL_IF_FAIL(port_priv, BadMatch);
+    EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor, BadMatch);
+    EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor->pAttributes, BadMatch);
+    EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor->nAttributes, BadMatch);
+    EPHYR_RETURN_VAL_IF_FAIL(ValidAtom(a_attr_name), BadMatch);
+
+    EPHYR_LOG("enter, portnum:%d, atomid:%d, attr_name:%s, attr_val:%d\n",
+              port_priv->port_number,
+              (int) a_attr_name, NameForAtom(a_attr_name), a_attr_value);
+
+    if (!ephyrLocalAtomToHost(a_attr_name, &host_atom)) {
+        EPHYR_LOG_ERROR("failed to convert local atom to host atom\n");
+        res = BadMatch;
+        goto out;
     }
 
-    if (!ephyrXVPrivIsAttrValueValid (port_priv->current_adaptor->pAttributes,
-                                      port_priv->current_adaptor->nAttributes,
-                                      NameForAtom (a_attr_name),
-                                      a_attr_value,
-                                      &is_attr_valid)) {
-        EPHYR_LOG_ERROR ("failed to validate attribute %s\n",
-                         NameForAtom (a_attr_name)) ;
+    if (!ephyrXVPrivIsAttrValueValid(port_priv->current_adaptor->pAttributes,
+                                     port_priv->current_adaptor->nAttributes,
+                                     NameForAtom(a_attr_name),
+                                     a_attr_value, &is_attr_valid)) {
+        EPHYR_LOG_ERROR("failed to validate attribute %s\n",
+                        NameForAtom(a_attr_name));
         /*
-         res = BadMatch ;
-         goto out ;
+           res = BadMatch ;
+           goto out ;
          */
     }
     if (!is_attr_valid) {
-        EPHYR_LOG_ERROR ("attribute %s is not valid\n",
-                         NameForAtom (a_attr_name)) ;
+        EPHYR_LOG_ERROR("attribute %s is not valid\n",
+                        NameForAtom(a_attr_name));
         /*
-        res = BadMatch ;
-        goto out ;
-        */
+           res = BadMatch ;
+           goto out ;
+         */
     }
 
-    if (!ephyrHostXVSetPortAttribute (port_priv->port_number,
-                                      host_atom,
-                                      a_attr_value)) {
-        EPHYR_LOG_ERROR ("failed to set port attribute\n") ;
-        res = BadMatch ;
-        goto out ;
+    if (!ephyrHostXVSetPortAttribute(port_priv->port_number,
+                                     host_atom, a_attr_value)) {
+        EPHYR_LOG_ERROR("failed to set port attribute\n");
+        res = BadMatch;
+        goto out;
     }
 
-    res = Success ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+    res = Success;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 static int
-ephyrGetPortAttribute (KdScreenInfo *a_screen_info,
-                       Atom a_attr_name,
-                       int *a_attr_value,
-                       pointer a_port_priv)
+ephyrGetPortAttribute(KdScreenInfo * a_screen_info,
+                      Atom a_attr_name, int *a_attr_value, pointer a_port_priv)
 {
-    int res=Success, host_atom=0 ;
-    EphyrPortPriv *port_priv = a_port_priv ;
+    int res = Success, host_atom = 0;
+    EphyrPortPriv *port_priv = a_port_priv;
 
-    EPHYR_RETURN_VAL_IF_FAIL (port_priv, BadMatch) ;
-    EPHYR_RETURN_VAL_IF_FAIL (ValidAtom (a_attr_name), BadMatch) ;
+    EPHYR_RETURN_VAL_IF_FAIL(port_priv, BadMatch);
+    EPHYR_RETURN_VAL_IF_FAIL(ValidAtom(a_attr_name), BadMatch);
 
-    EPHYR_LOG ("enter, portnum:%d, atomid:%d, attr_name:%s\n",
-               port_priv->port_number,
-               (int)a_attr_name,
-               NameForAtom (a_attr_name)) ;
+    EPHYR_LOG("enter, portnum:%d, atomid:%d, attr_name:%s\n",
+              port_priv->port_number,
+              (int) a_attr_name, NameForAtom(a_attr_name));
 
-    if (!ephyrLocalAtomToHost (a_attr_name, &host_atom)) {
-        EPHYR_LOG_ERROR ("failed to convert local atom to host atom\n") ;
-        res = BadMatch ;
-        goto out ;
+    if (!ephyrLocalAtomToHost(a_attr_name, &host_atom)) {
+        EPHYR_LOG_ERROR("failed to convert local atom to host atom\n");
+        res = BadMatch;
+        goto out;
     }
 
-    if (!ephyrHostXVGetPortAttribute (port_priv->port_number,
-                                      host_atom,
-                                      a_attr_value)) {
-        EPHYR_LOG_ERROR ("failed to get port attribute\n") ;
-        res = BadMatch ;
-        goto out ;
+    if (!ephyrHostXVGetPortAttribute(port_priv->port_number,
+                                     host_atom, a_attr_value)) {
+        EPHYR_LOG_ERROR("failed to get port attribute\n");
+        res = BadMatch;
+        goto out;
     }
 
-    res = Success ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return res ;
+    res = Success;
+ out:
+    EPHYR_LOG("leave\n");
+    return res;
 }
 
 static void
-ephyrQueryBestSize (KdScreenInfo *a_info,
-                    Bool a_motion,
-                    short a_src_w,
-                    short a_src_h,
-                    short a_drw_w,
-                    short a_drw_h,
-                    unsigned int *a_prefered_w,
-                    unsigned int *a_prefered_h,
-                    pointer a_port_priv)
+ephyrQueryBestSize(KdScreenInfo * a_info,
+                   Bool a_motion,
+                   short a_src_w,
+                   short a_src_h,
+                   short a_drw_w,
+                   short a_drw_h,
+                   unsigned int *a_prefered_w,
+                   unsigned int *a_prefered_h, pointer a_port_priv)
 {
-    int res=0 ;
-    EphyrPortPriv *port_priv = a_port_priv ;
+    int res = 0;
+    EphyrPortPriv *port_priv = a_port_priv;
 
-    EPHYR_RETURN_IF_FAIL (port_priv) ;
+    EPHYR_RETURN_IF_FAIL(port_priv);
 
-    EPHYR_LOG ("enter\n") ;
-    res = ephyrHostXVQueryBestSize (port_priv->port_number,
-                                    a_motion,
-                                    a_src_w, a_src_h,
-                                    a_drw_w, a_drw_h,
-                                    a_prefered_w, a_prefered_h) ;
+    EPHYR_LOG("enter\n");
+    res = ephyrHostXVQueryBestSize(port_priv->port_number,
+                                   a_motion,
+                                   a_src_w, a_src_h,
+                                   a_drw_w, a_drw_h,
+                                   a_prefered_w, a_prefered_h);
     if (!res) {
-        EPHYR_LOG_ERROR ("Failed to query best size\n") ;
+        EPHYR_LOG_ERROR("Failed to query best size\n");
     }
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
 }
 
 static int
-ephyrPutImage (KdScreenInfo *a_info,
-               DrawablePtr a_drawable,
-               short a_src_x,
-               short a_src_y,
-               short a_drw_x,
-               short a_drw_y,
-               short a_src_w,
-               short a_src_h,
-               short a_drw_w,
-               short a_drw_h,
-               int a_id,
-               unsigned char *a_buf,
-               short a_width,
-               short a_height,
-               Bool a_sync,
-               RegionPtr a_clipping_region,
-               pointer a_port_priv)
+ephyrPutImage(KdScreenInfo * a_info,
+              DrawablePtr a_drawable,
+              short a_src_x,
+              short a_src_y,
+              short a_drw_x,
+              short a_drw_y,
+              short a_src_w,
+              short a_src_h,
+              short a_drw_w,
+              short a_drw_h,
+              int a_id,
+              unsigned char *a_buf,
+              short a_width,
+              short a_height,
+              Bool a_sync, RegionPtr a_clipping_region, pointer a_port_priv)
 {
-    EphyrPortPriv *port_priv = a_port_priv ;
-    Bool is_ok=FALSE ;
-    int result=BadImplementation, image_size=0 ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (a_info && a_info->pScreen, BadValue) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_drawable, BadValue) ;
-
-    EPHYR_LOG ("enter\n") ;
-
-    if (!ephyrHostXVPutImage (a_info->pScreen->myNum,
-                              port_priv->port_number,
-                              a_id,
-                              a_drw_x, a_drw_y, a_drw_w, a_drw_h,
-                              a_src_x, a_src_y, a_src_w, a_src_h,
-                              a_width, a_height, a_buf,
-                              (EphyrHostBox*)RegionRects (a_clipping_region),
-                              RegionNumRects (a_clipping_region))) {
-        EPHYR_LOG_ERROR ("EphyrHostXVPutImage() failed\n") ;
-        goto out ;
+    EphyrPortPriv *port_priv = a_port_priv;
+    Bool is_ok = FALSE;
+    int result = BadImplementation, image_size = 0;
+
+    EPHYR_RETURN_VAL_IF_FAIL(a_info && a_info->pScreen, BadValue);
+    EPHYR_RETURN_VAL_IF_FAIL(a_drawable, BadValue);
+
+    EPHYR_LOG("enter\n");
+
+    if (!ephyrHostXVPutImage(a_info->pScreen->myNum,
+                             port_priv->port_number,
+                             a_id,
+                             a_drw_x, a_drw_y, a_drw_w, a_drw_h,
+                             a_src_x, a_src_y, a_src_w, a_src_h,
+                             a_width, a_height, a_buf,
+                             (EphyrHostBox *) RegionRects(a_clipping_region),
+                             RegionNumRects(a_clipping_region))) {
+        EPHYR_LOG_ERROR("EphyrHostXVPutImage() failed\n");
+        goto out;
     }
 
     /*
      * Now save the image so that we can resend it to host it
      * later, in ReputImage.
      */
-    if (!ephyrXVPrivGetImageBufSize (port_priv->port_number,
-                                     a_id, a_width, a_height, &image_size)) {
-        EPHYR_LOG_ERROR ("failed to get image size\n") ;
-        /*this is a minor error so we won't get bail out abruptly*/
-        is_ok = FALSE ;
-    } else {
-        is_ok = TRUE ;
+    if (!ephyrXVPrivGetImageBufSize(port_priv->port_number,
+                                    a_id, a_width, a_height, &image_size)) {
+        EPHYR_LOG_ERROR("failed to get image size\n");
+        /*this is a minor error so we won't get bail out abruptly */
+        is_ok = FALSE;
+    }
+    else {
+        is_ok = TRUE;
     }
     if (is_ok) {
-        if (!ephyrXVPrivSaveImageToPortPriv (port_priv, a_buf, image_size)) {
-            is_ok=FALSE ;
-        } else {
+        if (!ephyrXVPrivSaveImageToPortPriv(port_priv, a_buf, image_size)) {
+            is_ok = FALSE;
+        }
+        else {
             port_priv->image_id = a_id;
             port_priv->drw_x = a_drw_x;
             port_priv->drw_y = a_drw_y;
-            port_priv->drw_w = a_drw_w ;
-            port_priv->drw_h = a_drw_h ;
+            port_priv->drw_w = a_drw_w;
+            port_priv->drw_h = a_drw_h;
             port_priv->src_x = a_src_x;
-            port_priv->src_y = a_src_y ;
-            port_priv->src_w = a_src_w ;
-            port_priv->src_h = a_src_h ;
-            port_priv->image_width = a_width ;
-            port_priv->image_height = a_height ;
+            port_priv->src_y = a_src_y;
+            port_priv->src_w = a_src_w;
+            port_priv->src_h = a_src_h;
+            port_priv->image_width = a_width;
+            port_priv->image_height = a_height;
         }
     }
     if (!is_ok) {
         if (port_priv->image_buf) {
-            free (port_priv->image_buf) ;
-            port_priv->image_buf = NULL ;
-            port_priv->image_buf_size = 0 ;
+            free(port_priv->image_buf);
+            port_priv->image_buf = NULL;
+            port_priv->image_buf_size = 0;
         }
     }
 
-    result = Success ;
+    result = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return result ;
+ out:
+    EPHYR_LOG("leave\n");
+    return result;
 }
 
 static int
-ephyrReputImage (KdScreenInfo *a_info,
-                 DrawablePtr a_drawable,
-                 short a_drw_x,
-                 short a_drw_y,
-                 RegionPtr a_clipping_region,
-                 pointer a_port_priv)
+ephyrReputImage(KdScreenInfo * a_info,
+                DrawablePtr a_drawable,
+                short a_drw_x,
+                short a_drw_y, RegionPtr a_clipping_region, pointer a_port_priv)
 {
-    EphyrPortPriv *port_priv = a_port_priv ;
-    int result=BadImplementation ;
+    EphyrPortPriv *port_priv = a_port_priv;
+    int result = BadImplementation;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_info->pScreen, FALSE) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_drawable && port_priv, BadValue) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_info->pScreen, FALSE);
+    EPHYR_RETURN_VAL_IF_FAIL(a_drawable && port_priv, BadValue);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
     if (!port_priv->image_buf_size || !port_priv->image_buf) {
-        EPHYR_LOG_ERROR ("has null image buf in cache\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("has null image buf in cache\n");
+        goto out;
     }
-    if (!ephyrHostXVPutImage (a_info->pScreen->myNum,
-                              port_priv->port_number,
-                              port_priv->image_id,
-                              a_drw_x, a_drw_y,
-                              port_priv->drw_w, port_priv->drw_h,
-                              port_priv->src_x, port_priv->src_y,
-                              port_priv->src_w, port_priv->src_h,
-                              port_priv->image_width, port_priv->image_height,
-                              port_priv->image_buf,
-                              (EphyrHostBox*)RegionRects (a_clipping_region),
-                              RegionNumRects (a_clipping_region))) {
-        EPHYR_LOG_ERROR ("ephyrHostXVPutImage() failed\n") ;
-        goto out ;
+    if (!ephyrHostXVPutImage(a_info->pScreen->myNum,
+                             port_priv->port_number,
+                             port_priv->image_id,
+                             a_drw_x, a_drw_y,
+                             port_priv->drw_w, port_priv->drw_h,
+                             port_priv->src_x, port_priv->src_y,
+                             port_priv->src_w, port_priv->src_h,
+                             port_priv->image_width, port_priv->image_height,
+                             port_priv->image_buf,
+                             (EphyrHostBox *) RegionRects(a_clipping_region),
+                             RegionNumRects(a_clipping_region))) {
+        EPHYR_LOG_ERROR("ephyrHostXVPutImage() failed\n");
+        goto out;
     }
 
-    result = Success ;
+    result = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return result ;
+ out:
+    EPHYR_LOG("leave\n");
+    return result;
 }
 
 static int
-ephyrPutVideo (KdScreenInfo *a_info,
-               DrawablePtr a_drawable,
-               short a_vid_x, short a_vid_y,
-               short a_drw_x, short a_drw_y,
-               short a_vid_w, short a_vid_h,
-               short a_drw_w, short a_drw_h,
-               RegionPtr a_clipping_region,
-               pointer a_port_priv)
+ephyrPutVideo(KdScreenInfo * a_info,
+              DrawablePtr a_drawable,
+              short a_vid_x, short a_vid_y,
+              short a_drw_x, short a_drw_y,
+              short a_vid_w, short a_vid_h,
+              short a_drw_w, short a_drw_h,
+              RegionPtr a_clipping_region, pointer a_port_priv)
 {
-    EphyrPortPriv *port_priv = a_port_priv ;
-    BoxRec clipped_area, dst_box ;
-    int result=BadImplementation ;
-    int drw_x=0, drw_y=0, drw_w=0, drw_h=0 ;
+    EphyrPortPriv *port_priv = a_port_priv;
+    BoxRec clipped_area, dst_box;
+    int result = BadImplementation;
+    int drw_x = 0, drw_y = 0, drw_w = 0, drw_h = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_info->pScreen, BadValue) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_drawable && port_priv, BadValue) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_info->pScreen, BadValue);
+    EPHYR_RETURN_VAL_IF_FAIL(a_drawable && port_priv, BadValue);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    dst_box.x1 = a_drw_x ;
+    dst_box.x1 = a_drw_x;
     dst_box.x2 = a_drw_x + a_drw_w;
-    dst_box.y1 = a_drw_y ;
+    dst_box.y1 = a_drw_y;
     dst_box.y2 = a_drw_y + a_drw_h;
 
-    if (!DoSimpleClip (&dst_box,
-                       RegionExtents(a_clipping_region),
-                       &clipped_area)) {
-        EPHYR_LOG_ERROR ("failed to simple clip\n") ;
-        goto out ;
+    if (!DoSimpleClip(&dst_box,
+                      RegionExtents(a_clipping_region), &clipped_area)) {
+        EPHYR_LOG_ERROR("failed to simple clip\n");
+        goto out;
     }
 
-    drw_x = clipped_area.x1 ;
-    drw_y = clipped_area.y1 ;
-    drw_w = clipped_area.x2 - clipped_area.x1 ;
-    drw_h = clipped_area.y2 - clipped_area.y1 ;
-
-    if (!ephyrHostXVPutVideo (a_info->pScreen->myNum,
-                              port_priv->port_number,
-                              a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                              a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
-        EPHYR_LOG_ERROR ("ephyrHostXVPutVideo() failed\n") ;
-        goto out ;
+    drw_x = clipped_area.x1;
+    drw_y = clipped_area.y1;
+    drw_w = clipped_area.x2 - clipped_area.x1;
+    drw_h = clipped_area.y2 - clipped_area.y1;
+
+    if (!ephyrHostXVPutVideo(a_info->pScreen->myNum,
+                             port_priv->port_number,
+                             a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                             a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
+        EPHYR_LOG_ERROR("ephyrHostXVPutVideo() failed\n");
+        goto out;
     }
-    result = Success ;
+    result = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return result ;
+ out:
+    EPHYR_LOG("leave\n");
+    return result;
 }
 
 static int
-ephyrGetVideo (KdScreenInfo *a_info,
-               DrawablePtr a_drawable,
-               short a_vid_x, short a_vid_y,
-               short a_drw_x, short a_drw_y,
-               short a_vid_w, short a_vid_h,
-               short a_drw_w, short a_drw_h,
-               RegionPtr a_clipping_region,
-               pointer a_port_priv)
+ephyrGetVideo(KdScreenInfo * a_info,
+              DrawablePtr a_drawable,
+              short a_vid_x, short a_vid_y,
+              short a_drw_x, short a_drw_y,
+              short a_vid_w, short a_vid_h,
+              short a_drw_w, short a_drw_h,
+              RegionPtr a_clipping_region, pointer a_port_priv)
 {
-    EphyrPortPriv *port_priv = a_port_priv ;
-    BoxRec clipped_area, dst_box ;
-    int result=BadImplementation ;
-    int drw_x=0, drw_y=0, drw_w=0, drw_h=0 ;
+    EphyrPortPriv *port_priv = a_port_priv;
+    BoxRec clipped_area, dst_box;
+    int result = BadImplementation;
+    int drw_x = 0, drw_y = 0, drw_w = 0, drw_h = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_info && a_info->pScreen, BadValue) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_drawable && port_priv, BadValue) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_info && a_info->pScreen, BadValue);
+    EPHYR_RETURN_VAL_IF_FAIL(a_drawable && port_priv, BadValue);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    dst_box.x1 = a_drw_x ;
+    dst_box.x1 = a_drw_x;
     dst_box.x2 = a_drw_x + a_drw_w;
-    dst_box.y1 = a_drw_y ;
+    dst_box.y1 = a_drw_y;
     dst_box.y2 = a_drw_y + a_drw_h;
 
-    if (!DoSimpleClip (&dst_box,
-                       RegionExtents(a_clipping_region),
-                       &clipped_area)) {
-        EPHYR_LOG_ERROR ("failed to simple clip\n") ;
-        goto out ;
+    if (!DoSimpleClip(&dst_box,
+                      RegionExtents(a_clipping_region), &clipped_area)) {
+        EPHYR_LOG_ERROR("failed to simple clip\n");
+        goto out;
     }
 
-    drw_x = clipped_area.x1 ;
-    drw_y = clipped_area.y1 ;
-    drw_w = clipped_area.x2 - clipped_area.x1 ;
-    drw_h = clipped_area.y2 - clipped_area.y1 ;
-
-    if (!ephyrHostXVGetVideo (a_info->pScreen->myNum,
-                              port_priv->port_number,
-                              a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                              a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
-        EPHYR_LOG_ERROR ("ephyrHostXVGetVideo() failed\n") ;
-        goto out ;
+    drw_x = clipped_area.x1;
+    drw_y = clipped_area.y1;
+    drw_w = clipped_area.x2 - clipped_area.x1;
+    drw_h = clipped_area.y2 - clipped_area.y1;
+
+    if (!ephyrHostXVGetVideo(a_info->pScreen->myNum,
+                             port_priv->port_number,
+                             a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                             a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
+        EPHYR_LOG_ERROR("ephyrHostXVGetVideo() failed\n");
+        goto out;
     }
-    result = Success ;
+    result = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return result ;
+ out:
+    EPHYR_LOG("leave\n");
+    return result;
 }
 
 static int
-ephyrPutStill (KdScreenInfo *a_info,
-               DrawablePtr a_drawable,
-               short a_vid_x, short a_vid_y,
-               short a_drw_x, short a_drw_y,
-               short a_vid_w, short a_vid_h,
-               short a_drw_w, short a_drw_h,
-               RegionPtr a_clipping_region,
-               pointer a_port_priv)
+ephyrPutStill(KdScreenInfo * a_info,
+              DrawablePtr a_drawable,
+              short a_vid_x, short a_vid_y,
+              short a_drw_x, short a_drw_y,
+              short a_vid_w, short a_vid_h,
+              short a_drw_w, short a_drw_h,
+              RegionPtr a_clipping_region, pointer a_port_priv)
 {
-    EphyrPortPriv *port_priv = a_port_priv ;
-    BoxRec clipped_area, dst_box ;
-    int result=BadImplementation ;
-    int drw_x=0, drw_y=0, drw_w=0, drw_h=0 ;
+    EphyrPortPriv *port_priv = a_port_priv;
+    BoxRec clipped_area, dst_box;
+    int result = BadImplementation;
+    int drw_x = 0, drw_y = 0, drw_w = 0, drw_h = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_info && a_info->pScreen, BadValue) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_drawable && port_priv, BadValue) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_info && a_info->pScreen, BadValue);
+    EPHYR_RETURN_VAL_IF_FAIL(a_drawable && port_priv, BadValue);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    dst_box.x1 = a_drw_x ;
+    dst_box.x1 = a_drw_x;
     dst_box.x2 = a_drw_x + a_drw_w;
-    dst_box.y1 = a_drw_y ;
+    dst_box.y1 = a_drw_y;
     dst_box.y2 = a_drw_y + a_drw_h;
 
-    if (!DoSimpleClip (&dst_box,
-                       RegionExtents(a_clipping_region),
-                       &clipped_area)) {
-        EPHYR_LOG_ERROR ("failed to simple clip\n") ;
-        goto out ;
+    if (!DoSimpleClip(&dst_box,
+                      RegionExtents(a_clipping_region), &clipped_area)) {
+        EPHYR_LOG_ERROR("failed to simple clip\n");
+        goto out;
     }
 
-    drw_x = clipped_area.x1 ;
-    drw_y = clipped_area.y1 ;
-    drw_w = clipped_area.x2 - clipped_area.x1 ;
-    drw_h = clipped_area.y2 - clipped_area.y1 ;
-
-    if (!ephyrHostXVPutStill (a_info->pScreen->myNum,
-                              port_priv->port_number,
-                              a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                              a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
-        EPHYR_LOG_ERROR ("ephyrHostXVPutStill() failed\n") ;
-        goto out ;
+    drw_x = clipped_area.x1;
+    drw_y = clipped_area.y1;
+    drw_w = clipped_area.x2 - clipped_area.x1;
+    drw_h = clipped_area.y2 - clipped_area.y1;
+
+    if (!ephyrHostXVPutStill(a_info->pScreen->myNum,
+                             port_priv->port_number,
+                             a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                             a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
+        EPHYR_LOG_ERROR("ephyrHostXVPutStill() failed\n");
+        goto out;
     }
-    result = Success ;
+    result = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return result ;
+ out:
+    EPHYR_LOG("leave\n");
+    return result;
 }
 
 static int
-ephyrGetStill (KdScreenInfo *a_info,
-               DrawablePtr a_drawable,
-               short a_vid_x, short a_vid_y,
-               short a_drw_x, short a_drw_y,
-               short a_vid_w, short a_vid_h,
-               short a_drw_w, short a_drw_h,
-               RegionPtr a_clipping_region,
-               pointer a_port_priv)
+ephyrGetStill(KdScreenInfo * a_info,
+              DrawablePtr a_drawable,
+              short a_vid_x, short a_vid_y,
+              short a_drw_x, short a_drw_y,
+              short a_vid_w, short a_vid_h,
+              short a_drw_w, short a_drw_h,
+              RegionPtr a_clipping_region, pointer a_port_priv)
 {
-    EphyrPortPriv *port_priv = a_port_priv ;
-    BoxRec clipped_area, dst_box ;
-    int result=BadImplementation ;
-    int drw_x=0, drw_y=0, drw_w=0, drw_h=0 ;
+    EphyrPortPriv *port_priv = a_port_priv;
+    BoxRec clipped_area, dst_box;
+    int result = BadImplementation;
+    int drw_x = 0, drw_y = 0, drw_w = 0, drw_h = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_info && a_info->pScreen, BadValue) ;
-    EPHYR_RETURN_VAL_IF_FAIL (a_drawable && port_priv, BadValue) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_info && a_info->pScreen, BadValue);
+    EPHYR_RETURN_VAL_IF_FAIL(a_drawable && port_priv, BadValue);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-    dst_box.x1 = a_drw_x ;
+    dst_box.x1 = a_drw_x;
     dst_box.x2 = a_drw_x + a_drw_w;
-    dst_box.y1 = a_drw_y ;
+    dst_box.y1 = a_drw_y;
     dst_box.y2 = a_drw_y + a_drw_h;
 
-    if (!DoSimpleClip (&dst_box,
-                       RegionExtents(a_clipping_region),
-                       &clipped_area)) {
-        EPHYR_LOG_ERROR ("failed to simple clip\n") ;
-        goto out ;
+    if (!DoSimpleClip(&dst_box,
+                      RegionExtents(a_clipping_region), &clipped_area)) {
+        EPHYR_LOG_ERROR("failed to simple clip\n");
+        goto out;
     }
 
-    drw_x = clipped_area.x1 ;
-    drw_y = clipped_area.y1 ;
-    drw_w = clipped_area.x2 - clipped_area.x1 ;
-    drw_h = clipped_area.y2 - clipped_area.y1 ;
-
-    if (!ephyrHostXVGetStill (a_info->pScreen->myNum,
-                              port_priv->port_number,
-                              a_vid_x, a_vid_y, a_vid_w, a_vid_h,
-                              a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
-        EPHYR_LOG_ERROR ("ephyrHostXVGetStill() failed\n") ;
-        goto out ;
+    drw_x = clipped_area.x1;
+    drw_y = clipped_area.y1;
+    drw_w = clipped_area.x2 - clipped_area.x1;
+    drw_h = clipped_area.y2 - clipped_area.y1;
+
+    if (!ephyrHostXVGetStill(a_info->pScreen->myNum,
+                             port_priv->port_number,
+                             a_vid_x, a_vid_y, a_vid_w, a_vid_h,
+                             a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {
+        EPHYR_LOG_ERROR("ephyrHostXVGetStill() failed\n");
+        goto out;
     }
-    result = Success ;
+    result = Success;
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return result ;
+ out:
+    EPHYR_LOG("leave\n");
+    return result;
 }
 
 static int
-ephyrQueryImageAttributes (KdScreenInfo *a_info,
-                           int a_id,
-                           unsigned short *a_w,
-                           unsigned short *a_h,
-                           int *a_pitches,
-                           int *a_offsets)
+ephyrQueryImageAttributes(KdScreenInfo * a_info,
+                          int a_id,
+                          unsigned short *a_w,
+                          unsigned short *a_h, int *a_pitches, int *a_offsets)
 {
-    int image_size=0 ;
+    int image_size = 0;
 
-    EPHYR_RETURN_VAL_IF_FAIL (a_w && a_h, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(a_w && a_h, FALSE);
 
-    EPHYR_LOG ("enter: dim (%dx%d), pitches: %p, offsets: %p\n",
-               *a_w, *a_h, a_pitches, a_offsets) ;
+    EPHYR_LOG("enter: dim (%dx%d), pitches: %p, offsets: %p\n",
+              *a_w, *a_h, a_pitches, a_offsets);
 
-   if (!ephyrHostXVQueryImageAttributes (s_base_port_id,
+    if (!ephyrHostXVQueryImageAttributes(s_base_port_id,
                                          a_id,
                                          a_w, a_h,
-                                         &image_size,
-                                         a_pitches, a_offsets)) {
-       EPHYR_LOG_ERROR ("EphyrHostXVQueryImageAttributes() failed\n") ;
-       goto out ;
-   }
-   EPHYR_LOG ("image size: %d, dim (%dx%d)\n", image_size, *a_w, *a_h) ;
+                                         &image_size, a_pitches, a_offsets)) {
+        EPHYR_LOG_ERROR("EphyrHostXVQueryImageAttributes() failed\n");
+        goto out;
+    }
+    EPHYR_LOG("image size: %d, dim (%dx%d)\n", image_size, *a_w, *a_h);
 
-out:
-    EPHYR_LOG ("leave\n") ;
-    return image_size ;
+ out:
+    EPHYR_LOG("leave\n");
+    return image_size;
 }
diff --git a/hw/kdrive/ephyr/hostx.c b/hw/kdrive/ephyr/hostx.c
index ebe4e52ed..6988f1625 100644
--- a/hw/kdrive/ephyr/hostx.c
+++ b/hw/kdrive/ephyr/hostx.c
@@ -38,13 +38,12 @@
 #undef _XSERVER64
 #endif
 
-
 #include "hostx.h"
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
-#include <string.h> 		/* for memset */
+#include <string.h>             /* for memset */
 #include <errno.h>
 #include <time.h>
 
@@ -60,13 +59,12 @@
 #include <X11/extensions/shape.h>
 #ifdef XF86DRI
 #include <GL/glx.h>
-#endif /* XF86DRI */
+#endif                          /* XF86DRI */
 #include "ephyrlog.h"
 
 #ifdef XF86DRI
-extern Bool XF86DRIQueryExtension (Display *dpy,
-                                   int *event_basep,
-                                   int *error_basep);
+extern Bool XF86DRIQueryExtension(Display * dpy,
+                                  int *event_basep, int *error_basep);
 #endif
 
 /*  
@@ -75,261 +73,248 @@ extern Bool XF86DRIQueryExtension (Display *dpy,
  * to get clobbered. 
  */
 
-struct EphyrHostScreen
-{
-  Window          win;
-  Window          win_pre_existing; 	/* Set via -parent option like xnest */
-  Window          peer_win;          /* Used for GL; should be at most one */
-  XImage         *ximg;
-  int             win_width, win_height;
-  int             server_depth;
-  unsigned char  *fb_data;   	/* only used when host bpp != server bpp */
-  XShmSegmentInfo shminfo;
-
-  void           *info;   /* Pointer to the screen this is associated with */
-  int             mynum;  /* Screen number */
+struct EphyrHostScreen {
+    Window win;
+    Window win_pre_existing;    /* Set via -parent option like xnest */
+    Window peer_win;            /* Used for GL; should be at most one */
+    XImage *ximg;
+    int win_width, win_height;
+    int server_depth;
+    unsigned char *fb_data;     /* only used when host bpp != server bpp */
+    XShmSegmentInfo shminfo;
+
+    void *info;                 /* Pointer to the screen this is associated with */
+    int mynum;                  /* Screen number */
 };
 
-struct EphyrHostXVars
-{
-  char           *server_dpy_name;
-  Display        *dpy;
-  int             screen;
-  Visual         *visual;
-  Window          winroot;
-  GC              gc;
-  int             depth;
-  Bool            use_host_cursor;
-  Bool            use_fullscreen;
-  Bool            have_shm;
-
-  int             n_screens;
-  struct EphyrHostScreen *screens;
-
-  long            damage_debug_msec;
-
-  unsigned long   cmap[256];
+struct EphyrHostXVars {
+    char *server_dpy_name;
+    Display *dpy;
+    int screen;
+    Visual *visual;
+    Window winroot;
+    GC gc;
+    int depth;
+    Bool use_host_cursor;
+    Bool use_fullscreen;
+    Bool have_shm;
+
+    int n_screens;
+    struct EphyrHostScreen *screens;
+
+    long damage_debug_msec;
+
+    unsigned long cmap[256];
 };
 
 /* memset ( missing> ) instead of below  */
 /*static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};*/
 static EphyrHostXVars HostX;
 
-static int            HostXWantDamageDebug = 0;
+static int HostXWantDamageDebug = 0;
 
-extern EphyrKeySyms   ephyrKeySyms;
+extern EphyrKeySyms ephyrKeySyms;
 
-extern int            monitorResolution;
+extern int monitorResolution;
 
-char           *ephyrResName = NULL;
-int             ephyrResNameFromCmd = 0;
-char	       *ephyrTitle = NULL;
+char *ephyrResName = NULL;
+int ephyrResNameFromCmd = 0;
+char *ephyrTitle = NULL;
 
 static void
-hostx_set_fullscreen_hint(void);
+ hostx_set_fullscreen_hint(void);
 
 /* X Error traps */
 
 static int trapped_error_code = 0;
-static int (*old_error_handler) (Display *d, XErrorEvent *e);
+static int (*old_error_handler) (Display * d, XErrorEvent * e);
 
 #define host_depth_matches_server(_vars) (HostX.depth == (_vars)->server_depth)
 
 static struct EphyrHostScreen *
-host_screen_from_screen_info (EphyrScreenInfo *screen)
+host_screen_from_screen_info(EphyrScreenInfo * screen)
 {
-  int i;
+    int i;
 
-  for (i = 0 ; i < HostX.n_screens ; i++)
-    {
-      if ( HostX.screens[i].info == screen)
-        {
-          return &HostX.screens[i];
+    for (i = 0; i < HostX.n_screens; i++) {
+        if (HostX.screens[i].info == screen) {
+            return &HostX.screens[i];
         }
     }
-  return NULL;
+    return NULL;
 }
 
 static int
-error_handler(Display     *display,
-              XErrorEvent *error)
+error_handler(Display * display, XErrorEvent * error)
 {
-  trapped_error_code = error->error_code;
-  return 0;
+    trapped_error_code = error->error_code;
+    return 0;
 }
 
 static void
 hostx_errors_trap(void)
 {
-  trapped_error_code = 0;
-  old_error_handler = XSetErrorHandler(error_handler);
+    trapped_error_code = 0;
+    old_error_handler = XSetErrorHandler(error_handler);
 }
 
 static int
 hostx_errors_untrap(void)
 {
-  XSetErrorHandler(old_error_handler);
-  return trapped_error_code;
+    XSetErrorHandler(old_error_handler);
+    return trapped_error_code;
 }
 
 int
-hostx_want_screen_size (EphyrScreenInfo screen, int *width, int *height )
+hostx_want_screen_size(EphyrScreenInfo screen, int *width, int *height)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-
-  if (host_screen &&
-       (host_screen->win_pre_existing != None ||
-         HostX.use_fullscreen == True))
-    {
-      *width  = host_screen->win_width;
-      *height = host_screen->win_height;
-      return 1;
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
+
+    if (host_screen &&
+        (host_screen->win_pre_existing != None ||
+         HostX.use_fullscreen == True)) {
+        *width = host_screen->win_width;
+        *height = host_screen->win_height;
+        return 1;
     }
 
- return 0;
+    return 0;
 }
 
 void
-hostx_add_screen (EphyrScreenInfo screen,
-                  unsigned long win_id,
-                  int screen_num)
+hostx_add_screen(EphyrScreenInfo screen, unsigned long win_id, int screen_num)
 {
-  int index = HostX.n_screens;
+    int index = HostX.n_screens;
 
-  HostX.n_screens += 1;
-  HostX.screens = realloc (HostX.screens,
-                           HostX.n_screens * sizeof(struct EphyrHostScreen));
-  memset (&HostX.screens[index], 0, sizeof (struct EphyrHostScreen));
+    HostX.n_screens += 1;
+    HostX.screens = realloc(HostX.screens,
+                            HostX.n_screens * sizeof(struct EphyrHostScreen));
+    memset(&HostX.screens[index], 0, sizeof(struct EphyrHostScreen));
 
-  HostX.screens[index].info       = screen;
-  HostX.screens[index].win_pre_existing = win_id;
+    HostX.screens[index].info = screen;
+    HostX.screens[index].win_pre_existing = win_id;
 }
 
-
 void
-hostx_set_display_name (char *name)
+hostx_set_display_name(char *name)
 {
-  HostX.server_dpy_name = strdup (name);
+    HostX.server_dpy_name = strdup(name);
 }
 
 void
 hostx_set_screen_number(EphyrScreenInfo screen, int number)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-  if (host_screen) {
-    host_screen->mynum = number;
-    hostx_set_win_title (host_screen->info, "") ;
-  }}
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
+
+    if (host_screen) {
+        host_screen->mynum = number;
+        hostx_set_win_title(host_screen->info, "");
+    }
+}
 
 void
-hostx_set_win_title (EphyrScreenInfo screen, char *extra_text)
+hostx_set_win_title(EphyrScreenInfo screen, char *extra_text)
 {
-    struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
 
     if (!host_screen)
-    return;
+        return;
 
     if (ephyrTitle) {
-      XStoreName(HostX.dpy, host_screen->win, ephyrTitle);
-    } else {
+        XStoreName(HostX.dpy, host_screen->win, ephyrTitle);
+    }
+    else {
 #define BUF_LEN 256
-      char buf[BUF_LEN+1];
+        char buf[BUF_LEN + 1];
 
-      memset (buf, 0, BUF_LEN+1) ;
-      snprintf (buf, BUF_LEN, "Xephyr on %s.%d %s", 
-		HostX.server_dpy_name, 
-		host_screen->mynum,
-		(extra_text != NULL) ? extra_text : "");
+        memset(buf, 0, BUF_LEN + 1);
+        snprintf(buf, BUF_LEN, "Xephyr on %s.%d %s",
+                 HostX.server_dpy_name,
+                 host_screen->mynum, (extra_text != NULL) ? extra_text : "");
 
-      XStoreName (HostX.dpy, host_screen->win, buf);
+        XStoreName(HostX.dpy, host_screen->win, buf);
     }
 }
 
 int
-hostx_want_host_cursor (void)
+hostx_want_host_cursor(void)
 {
-  return HostX.use_host_cursor;
+    return HostX.use_host_cursor;
 }
 
 void
-hostx_use_host_cursor (void)
+hostx_use_host_cursor(void)
 {
-  HostX.use_host_cursor = True;
+    HostX.use_host_cursor = True;
 }
 
 int
-hostx_want_preexisting_window (EphyrScreenInfo screen)
+hostx_want_preexisting_window(EphyrScreenInfo screen)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
 
-  if (host_screen && host_screen->win_pre_existing)
-    {
-      return 1;
+    if (host_screen && host_screen->win_pre_existing) {
+        return 1;
     }
-  else
-    {
-    return 0;
+    else {
+        return 0;
     }
 }
 
 void
-hostx_use_fullscreen (void)
+hostx_use_fullscreen(void)
 {
-  HostX.use_fullscreen = True;
+    HostX.use_fullscreen = True;
 }
 
 int
-hostx_want_fullscreen (void)
+hostx_want_fullscreen(void)
 {
-  return HostX.use_fullscreen;
+    return HostX.use_fullscreen;
 }
 
 static void
-hostx_set_fullscreen_hint (void)
+hostx_set_fullscreen_hint(void)
 {
-  Atom atom_WINDOW_STATE, atom_WINDOW_STATE_FULLSCREEN;
-  int index;
-
-  atom_WINDOW_STATE 
-    = XInternAtom(HostX.dpy, "_NET_WM_STATE", False);
-  atom_WINDOW_STATE_FULLSCREEN 
-    = XInternAtom(HostX.dpy, "_NET_WM_STATE_FULLSCREEN",False);
-
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      XChangeProperty (HostX.dpy, HostX.screens[index].win,
-                       atom_WINDOW_STATE, XA_ATOM, 32,
-                       PropModeReplace,
-                       (unsigned char *)&atom_WINDOW_STATE_FULLSCREEN, 1);
+    Atom atom_WINDOW_STATE, atom_WINDOW_STATE_FULLSCREEN;
+    int index;
+
+    atom_WINDOW_STATE = XInternAtom(HostX.dpy, "_NET_WM_STATE", False);
+    atom_WINDOW_STATE_FULLSCREEN
+        = XInternAtom(HostX.dpy, "_NET_WM_STATE_FULLSCREEN", False);
+
+    for (index = 0; index < HostX.n_screens; index++) {
+        XChangeProperty(HostX.dpy, HostX.screens[index].win,
+                        atom_WINDOW_STATE, XA_ATOM, 32,
+                        PropModeReplace,
+                        (unsigned char *) &atom_WINDOW_STATE_FULLSCREEN, 1);
     }
 }
 
-
 static void
-hostx_toggle_damage_debug (void)
+hostx_toggle_damage_debug(void)
 {
-  HostXWantDamageDebug ^= 1;
+    HostXWantDamageDebug ^= 1;
 }
 
 void
-hostx_handle_signal (int signum)
+hostx_handle_signal(int signum)
 {
-  hostx_toggle_damage_debug();
-  EPHYR_DBG ("Signal caught. Damage Debug:%i\n",
-              HostXWantDamageDebug);
+    hostx_toggle_damage_debug();
+    EPHYR_DBG("Signal caught. Damage Debug:%i\n", HostXWantDamageDebug);
 }
 
 void
-hostx_use_resname (char *name, int fromcmd)
+hostx_use_resname(char *name, int fromcmd)
 {
-  ephyrResName = name;
-  ephyrResNameFromCmd = fromcmd;
+    ephyrResName = name;
+    ephyrResNameFromCmd = fromcmd;
 }
 
 void
-hostx_set_title (char *title)
+hostx_set_title(char *title)
 {
-  ephyrTitle = title;
+    ephyrTitle = title;
 }
 
 #ifdef __SUNPRO_C
@@ -338,7 +323,8 @@ hostx_set_title (char *title)
 #endif
 
 static int _X_NORETURN
-x_io_error_handler (Display *dpy) {
+x_io_error_handler(Display * dpy)
+{
     ErrorF("Lost connection to X server: %s\n", strerror(errno));
     CloseWellKnownConnections();
     OsCleanup(1);
@@ -346,297 +332,271 @@ x_io_error_handler (Display *dpy) {
 }
 
 int
-hostx_init (void)
+hostx_init(void)
 {
-  XSetWindowAttributes  attr;
-  Cursor                empty_cursor;
-  Pixmap                cursor_pxm;
-  XColor                col;
-  int                   index;
-  char                  *tmpstr;
-  XClassHint            *class_hint;
-
-  attr.event_mask =
-    ButtonPressMask
-    |ButtonReleaseMask
-    |PointerMotionMask
-    |KeyPressMask
-    |KeyReleaseMask
-    |ExposureMask;
-
-  EPHYR_DBG("mark");
-
-  if ((HostX.dpy = XOpenDisplay(getenv("DISPLAY"))) == NULL)
-    {
-      fprintf(stderr, "\nXephyr cannot open host display. Is DISPLAY set?\n");
-      exit(1);
+    XSetWindowAttributes attr;
+    Cursor empty_cursor;
+    Pixmap cursor_pxm;
+    XColor col;
+    int index;
+    char *tmpstr;
+    XClassHint *class_hint;
+
+    attr.event_mask =
+        ButtonPressMask
+        | ButtonReleaseMask
+        | PointerMotionMask | KeyPressMask | KeyReleaseMask | ExposureMask;
+
+    EPHYR_DBG("mark");
+
+    if ((HostX.dpy = XOpenDisplay(getenv("DISPLAY"))) == NULL) {
+        fprintf(stderr, "\nXephyr cannot open host display. Is DISPLAY set?\n");
+        exit(1);
     }
 
-  XSetIOErrorHandler(x_io_error_handler);
+    XSetIOErrorHandler(x_io_error_handler);
 
-  HostX.screen  = DefaultScreen(HostX.dpy);
-  HostX.winroot = RootWindow(HostX.dpy, HostX.screen);
-  HostX.gc      = XCreateGC(HostX.dpy, HostX.winroot, 0, NULL);
-  HostX.depth   = DefaultDepth(HostX.dpy, HostX.screen);
-  HostX.visual  = DefaultVisual(HostX.dpy, HostX.screen);
+    HostX.screen = DefaultScreen(HostX.dpy);
+    HostX.winroot = RootWindow(HostX.dpy, HostX.screen);
+    HostX.gc = XCreateGC(HostX.dpy, HostX.winroot, 0, NULL);
+    HostX.depth = DefaultDepth(HostX.dpy, HostX.screen);
+    HostX.visual = DefaultVisual(HostX.dpy, HostX.screen);
 
-  class_hint = XAllocClassHint();
+    class_hint = XAllocClassHint();
 
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      struct EphyrHostScreen *host_screen = &HostX.screens[index];
+    for (index = 0; index < HostX.n_screens; index++) {
+        struct EphyrHostScreen *host_screen = &HostX.screens[index];
 
-      host_screen->server_depth = HostX.depth;
-      if (host_screen->win_pre_existing != None)
-        {
-          Status            result;
-          XWindowAttributes prewin_attr;
-
-          /* Get screen size from existing window */
-
-          hostx_errors_trap();
-
-          result = XGetWindowAttributes (HostX.dpy,
-                                         host_screen->win_pre_existing,
-                                         &prewin_attr);
-
-
-          if (hostx_errors_untrap() || !result)
-          {
-              fprintf (stderr, "\nXephyr -parent window' does not exist!\n");
-              exit (1);
-          }
-
-          host_screen->win_width  = prewin_attr.width;
-          host_screen->win_height = prewin_attr.height;
-
-          host_screen->win = XCreateWindow (HostX.dpy,
-                                            host_screen->win_pre_existing,
-                                            0,0,
-                                            host_screen->win_width,
-                                            host_screen->win_height,
-                                            0,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CWEventMask,
-                                            &attr);
-        }
-      else
-        {
-          host_screen->win = XCreateWindow (HostX.dpy,
-                                            HostX.winroot,
-                                            0,0,100,100, /* will resize */
-                                            0,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CopyFromParent,
-                                            CWEventMask,
-                                            &attr);
-
-          hostx_set_win_title (host_screen->info,
-                               "(ctrl+shift grabs mouse and keyboard)");
-
-          if (HostX.use_fullscreen)
-            {
-              host_screen->win_width  = DisplayWidth(HostX.dpy, HostX.screen);
-              host_screen->win_height = DisplayHeight(HostX.dpy, HostX.screen);
+        host_screen->server_depth = HostX.depth;
+        if (host_screen->win_pre_existing != None) {
+            Status result;
+            XWindowAttributes prewin_attr;
+
+            /* Get screen size from existing window */
+
+            hostx_errors_trap();
 
-              hostx_set_fullscreen_hint();
+            result = XGetWindowAttributes(HostX.dpy,
+                                          host_screen->win_pre_existing,
+                                          &prewin_attr);
+
+            if (hostx_errors_untrap() || !result) {
+                fprintf(stderr, "\nXephyr -parent window' does not exist!\n");
+                exit(1);
             }
 
-          if (class_hint) 
-            {
-              tmpstr = getenv("RESOURCE_NAME");
-              if (tmpstr && (!ephyrResNameFromCmd))
-                ephyrResName = tmpstr;
-              class_hint->res_name = ephyrResName;
-              class_hint->res_class = "Xephyr";
-              XSetClassHint(hostx_get_display(), host_screen->win, class_hint);
+            host_screen->win_width = prewin_attr.width;
+            host_screen->win_height = prewin_attr.height;
+
+            host_screen->win = XCreateWindow(HostX.dpy,
+                                             host_screen->win_pre_existing,
+                                             0, 0,
+                                             host_screen->win_width,
+                                             host_screen->win_height,
+                                             0,
+                                             CopyFromParent,
+                                             CopyFromParent,
+                                             CopyFromParent,
+                                             CWEventMask, &attr);
+        }
+        else {
+            host_screen->win = XCreateWindow(HostX.dpy, HostX.winroot, 0, 0, 100, 100,  /* will resize */
+                                             0,
+                                             CopyFromParent,
+                                             CopyFromParent,
+                                             CopyFromParent,
+                                             CWEventMask, &attr);
+
+            hostx_set_win_title(host_screen->info,
+                                "(ctrl+shift grabs mouse and keyboard)");
+
+            if (HostX.use_fullscreen) {
+                host_screen->win_width = DisplayWidth(HostX.dpy, HostX.screen);
+                host_screen->win_height =
+                    DisplayHeight(HostX.dpy, HostX.screen);
+
+                hostx_set_fullscreen_hint();
+            }
+
+            if (class_hint) {
+                tmpstr = getenv("RESOURCE_NAME");
+                if (tmpstr && (!ephyrResNameFromCmd))
+                    ephyrResName = tmpstr;
+                class_hint->res_name = ephyrResName;
+                class_hint->res_class = "Xephyr";
+                XSetClassHint(hostx_get_display(), host_screen->win,
+                              class_hint);
 
             }
 
         }
     }
 
-  if (class_hint)
-      XFree(class_hint);
-
-  XParseColor (HostX.dpy, DefaultColormap (HostX.dpy,HostX.screen),
-               "red", &col);
-  XAllocColor (HostX.dpy, DefaultColormap (HostX.dpy, HostX.screen),
-               &col);
-  XSetForeground (HostX.dpy, HostX.gc, col.pixel);
-
-  if (!hostx_want_host_cursor ())
-    {
-      /* Ditch the cursor, we provide our 'own' */
-      cursor_pxm = XCreatePixmap (HostX.dpy, HostX.winroot, 1, 1, 1);
-      memset (&col, 0, sizeof (col));
-      empty_cursor = XCreatePixmapCursor (HostX.dpy,
-                                          cursor_pxm, cursor_pxm, 
-                                          &col, &col, 1, 1);
-      for ( index = 0 ; index < HostX.n_screens ; index++ )
-        {
-          XDefineCursor (HostX.dpy,
-                         HostX.screens[index].win,
-                         empty_cursor);
+    if (class_hint)
+        XFree(class_hint);
+
+    XParseColor(HostX.dpy, DefaultColormap(HostX.dpy, HostX.screen),
+                "red", &col);
+    XAllocColor(HostX.dpy, DefaultColormap(HostX.dpy, HostX.screen), &col);
+    XSetForeground(HostX.dpy, HostX.gc, col.pixel);
+
+    if (!hostx_want_host_cursor()) {
+        /* Ditch the cursor, we provide our 'own' */
+        cursor_pxm = XCreatePixmap(HostX.dpy, HostX.winroot, 1, 1, 1);
+        memset(&col, 0, sizeof(col));
+        empty_cursor = XCreatePixmapCursor(HostX.dpy,
+                                           cursor_pxm, cursor_pxm,
+                                           &col, &col, 1, 1);
+        for (index = 0; index < HostX.n_screens; index++) {
+            XDefineCursor(HostX.dpy, HostX.screens[index].win, empty_cursor);
         }
-      XFreePixmap (HostX.dpy, cursor_pxm);
+        XFreePixmap(HostX.dpy, cursor_pxm);
     }
 
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      HostX.screens[index].ximg   = NULL;
+    for (index = 0; index < HostX.n_screens; index++) {
+        HostX.screens[index].ximg = NULL;
     }
-  /* Try to get share memory ximages for a little bit more speed */
+    /* Try to get share memory ximages for a little bit more speed */
 
-  if (!XShmQueryExtension(HostX.dpy) || getenv("XEPHYR_NO_SHM"))
-    {
-      fprintf(stderr, "\nXephyr unable to use SHM XImages\n");
-      HostX.have_shm = False;
+    if (!XShmQueryExtension(HostX.dpy) || getenv("XEPHYR_NO_SHM")) {
+        fprintf(stderr, "\nXephyr unable to use SHM XImages\n");
+        HostX.have_shm = False;
     }
-  else
-    {
-      /* Really really check we have shm - better way ?*/
-      XShmSegmentInfo shminfo;
+    else {
+        /* Really really check we have shm - better way ? */
+        XShmSegmentInfo shminfo;
 
         HostX.have_shm = True;
 
-        shminfo.shmid=shmget(IPC_PRIVATE, 1, IPC_CREAT|0777);
-        shminfo.shmaddr=shmat(shminfo.shmid,0,0);
-        shminfo.readOnly=True;
+        shminfo.shmid = shmget(IPC_PRIVATE, 1, IPC_CREAT | 0777);
+        shminfo.shmaddr = shmat(shminfo.shmid, 0, 0);
+        shminfo.readOnly = True;
 
         hostx_errors_trap();
 
         XShmAttach(HostX.dpy, &shminfo);
         XSync(HostX.dpy, False);
 
-        if (hostx_errors_untrap())
-          {
+        if (hostx_errors_untrap()) {
             fprintf(stderr, "\nXephyr unable to use SHM XImages\n");
             HostX.have_shm = False;
-          }
+        }
 
         shmdt(shminfo.shmaddr);
         shmctl(shminfo.shmid, IPC_RMID, 0);
-}
+    }
 
-  XFlush(HostX.dpy);
+    XFlush(HostX.dpy);
 
-  /* Setup the pause time between paints when debugging updates */
+    /* Setup the pause time between paints when debugging updates */
 
-  HostX.damage_debug_msec = 20000; /* 1/50 th of a second */
+    HostX.damage_debug_msec = 20000;    /* 1/50 th of a second */
 
-  if (getenv ("XEPHYR_PAUSE"))
-    {
-      HostX.damage_debug_msec = strtol (getenv ("XEPHYR_PAUSE"), NULL, 0);
-      EPHYR_DBG ("pause is %li\n", HostX.damage_debug_msec);
+    if (getenv("XEPHYR_PAUSE")) {
+        HostX.damage_debug_msec = strtol(getenv("XEPHYR_PAUSE"), NULL, 0);
+        EPHYR_DBG("pause is %li\n", HostX.damage_debug_msec);
     }
 
-  return 1;
+    return 1;
 }
 
 int
-hostx_get_depth (void)
+hostx_get_depth(void)
 {
-  return HostX.depth;
+    return HostX.depth;
 }
 
 int
-hostx_get_server_depth (EphyrScreenInfo screen)
+hostx_get_server_depth(EphyrScreenInfo screen)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
 
-  return host_screen ? host_screen->server_depth : 0;
+    return host_screen ? host_screen->server_depth : 0;
 }
 
 void
-hostx_set_server_depth (EphyrScreenInfo screen, int depth)
+hostx_set_server_depth(EphyrScreenInfo screen, int depth)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
 
-  if (host_screen)
-    host_screen->server_depth = depth;
+    if (host_screen)
+        host_screen->server_depth = depth;
 }
 
 int
-hostx_get_bpp (EphyrScreenInfo screen)
+hostx_get_bpp(EphyrScreenInfo screen)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
 
-  if (!host_screen)
-    return 0;
+    if (!host_screen)
+        return 0;
 
-  if (host_depth_matches_server (host_screen))
-    return HostX.visual->bits_per_rgb;
-  else
-    return host_screen->server_depth; /*XXX correct ?*/
+    if (host_depth_matches_server(host_screen))
+        return HostX.visual->bits_per_rgb;
+    else
+        return host_screen->server_depth;       /*XXX correct ? */
 }
 
 void
-hostx_get_visual_masks (EphyrScreenInfo screen,
-			CARD32 *rmsk,
-			CARD32 *gmsk,
-			CARD32 *bmsk)
+hostx_get_visual_masks(EphyrScreenInfo screen,
+                       CARD32 *rmsk, CARD32 *gmsk, CARD32 *bmsk)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
 
-  if (!host_screen)
-    return;
+    if (!host_screen)
+        return;
 
-  if (host_depth_matches_server(host_screen))
-    {
-      *rmsk = HostX.visual->red_mask;
-      *gmsk = HostX.visual->green_mask;
-      *bmsk = HostX.visual->blue_mask;
+    if (host_depth_matches_server(host_screen)) {
+        *rmsk = HostX.visual->red_mask;
+        *gmsk = HostX.visual->green_mask;
+        *bmsk = HostX.visual->blue_mask;
     }
-  else if (host_screen->server_depth == 16)
-    {
-      /* Assume 16bpp 565 */
-      *rmsk = 0xf800;
-      *gmsk = 0x07e0;
-      *bmsk = 0x001f;
+    else if (host_screen->server_depth == 16) {
+        /* Assume 16bpp 565 */
+        *rmsk = 0xf800;
+        *gmsk = 0x07e0;
+        *bmsk = 0x001f;
     }
-  else
-    {
-      *rmsk = 0x0;
-      *gmsk = 0x0;
-      *bmsk = 0x0;
+    else {
+        *rmsk = 0x0;
+        *gmsk = 0x0;
+        *bmsk = 0x0;
     }
 }
 
-static int 
+static int
 hostx_calculate_color_shift(unsigned long mask)
 {
     int shift = 1;
+
     /* count # of bits in mask */
-    while ((mask = (mask >> 1))) shift++;
+    while ((mask = (mask >> 1)))
+        shift++;
     /* cmap entry is an unsigned char so adjust it by size of that */
     shift = shift - sizeof(unsigned char) * 8;
-    if (shift < 0) shift = 0;
+    if (shift < 0)
+        shift = 0;
     return shift;
 }
 
 void
 hostx_set_cmap_entry(unsigned char idx,
-		     unsigned char r,
-		     unsigned char g,
-		     unsigned char b)
+                     unsigned char r, unsigned char g, unsigned char b)
 {
 /* need to calculate the shifts for RGB because server could be BGR. */
 /* XXX Not sure if this is correct for 8 on 16, but this works for 8 on 24.*/
     static int rshift, bshift, gshift = 0;
     static int first_time = 1;
+
     if (first_time) {
-	first_time = 0;
-	rshift = hostx_calculate_color_shift(HostX.visual->red_mask);
-	gshift = hostx_calculate_color_shift(HostX.visual->green_mask);
-	bshift = hostx_calculate_color_shift(HostX.visual->blue_mask);
+        first_time = 0;
+        rshift = hostx_calculate_color_shift(HostX.visual->red_mask);
+        gshift = hostx_calculate_color_shift(HostX.visual->green_mask);
+        bshift = hostx_calculate_color_shift(HostX.visual->blue_mask);
     }
     HostX.cmap[idx] = ((r << rshift) & HostX.visual->red_mask) |
-		      ((g << gshift) & HostX.visual->green_mask) |
-		      ((b << bshift) & HostX.visual->blue_mask);
+        ((g << gshift) & HostX.visual->green_mask) |
+        ((b << bshift) & HostX.visual->blue_mask);
 }
 
 /**
@@ -651,813 +611,765 @@ hostx_set_cmap_entry(unsigned char idx,
  * buffer_height can be used to create a larger offscreen buffer, which is used
  * by fakexa for storing offscreen pixmap data.
  */
-void*
-hostx_screen_init (EphyrScreenInfo screen,
-                   int width, int height,
-                   int buffer_height)
+void *
+hostx_screen_init(EphyrScreenInfo screen,
+                  int width, int height, int buffer_height)
 {
-  int         bitmap_pad;
-  Bool        shm_success = False;
-  XSizeHints *size_hints;
-
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
-  if (!host_screen)
-    {
-      fprintf (stderr, "%s: Error in accessing hostx data\n", __func__ );
-      exit(1);
+    int bitmap_pad;
+    Bool shm_success = False;
+    XSizeHints *size_hints;
+
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
+
+    if (!host_screen) {
+        fprintf(stderr, "%s: Error in accessing hostx data\n", __func__);
+        exit(1);
     }
 
-  EPHYR_DBG ("host_screen=%p wxh=%dx%d, buffer_height=%d",
-             host_screen, width, height, buffer_height);
-
-  if (host_screen->ximg != NULL)
-    {
-      /* Free up the image data if previously used
-       * i.ie called by server reset
-       */
-
-      if (HostX.have_shm)
-	{
-	  XShmDetach(HostX.dpy, &host_screen->shminfo);
-	  XDestroyImage (host_screen->ximg);
-	  shmdt(host_screen->shminfo.shmaddr);
-	  shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);
-	}
-      else
-	{
-	  free(host_screen->ximg->data);
-	  host_screen->ximg->data = NULL;
-
-	  XDestroyImage(host_screen->ximg);
-	}
+    EPHYR_DBG("host_screen=%p wxh=%dx%d, buffer_height=%d",
+              host_screen, width, height, buffer_height);
+
+    if (host_screen->ximg != NULL) {
+        /* Free up the image data if previously used
+         * i.ie called by server reset
+         */
+
+        if (HostX.have_shm) {
+            XShmDetach(HostX.dpy, &host_screen->shminfo);
+            XDestroyImage(host_screen->ximg);
+            shmdt(host_screen->shminfo.shmaddr);
+            shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);
+        }
+        else {
+            free(host_screen->ximg->data);
+            host_screen->ximg->data = NULL;
+
+            XDestroyImage(host_screen->ximg);
+        }
     }
 
-  if (HostX.have_shm)
-    {
-      host_screen->ximg = XShmCreateImage (HostX.dpy, HostX.visual, HostX.depth,
-                                           ZPixmap, NULL, &host_screen->shminfo,
-                                           width, buffer_height );
-
-      host_screen->shminfo.shmid =
-                      shmget(IPC_PRIVATE,
-                             host_screen->ximg->bytes_per_line * buffer_height,
-                             IPC_CREAT|0777);
-      host_screen->ximg->data = shmat(host_screen->shminfo.shmid, 0, 0);
-      host_screen->shminfo.shmaddr = host_screen->ximg->data;
-
-      if (host_screen->ximg->data == (char *)-1)
-	{
-	  EPHYR_DBG("Can't attach SHM Segment, falling back to plain XImages");
-	  HostX.have_shm = False;
-	  XDestroyImage(host_screen->ximg);
-	  shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);
-	}
-      else
-	{
-	  EPHYR_DBG("SHM segment attached %p", host_screen->shminfo.shmaddr);
-	  host_screen->shminfo.readOnly = False;
-	  XShmAttach(HostX.dpy, &host_screen->shminfo);
-	  shm_success = True;
-	}
+    if (HostX.have_shm) {
+        host_screen->ximg =
+            XShmCreateImage(HostX.dpy, HostX.visual, HostX.depth, ZPixmap, NULL,
+                            &host_screen->shminfo, width, buffer_height);
+
+        host_screen->shminfo.shmid =
+            shmget(IPC_PRIVATE,
+                   host_screen->ximg->bytes_per_line * buffer_height,
+                   IPC_CREAT | 0777);
+        host_screen->ximg->data = shmat(host_screen->shminfo.shmid, 0, 0);
+        host_screen->shminfo.shmaddr = host_screen->ximg->data;
+
+        if (host_screen->ximg->data == (char *) -1) {
+            EPHYR_DBG
+                ("Can't attach SHM Segment, falling back to plain XImages");
+            HostX.have_shm = False;
+            XDestroyImage(host_screen->ximg);
+            shmctl(host_screen->shminfo.shmid, IPC_RMID, 0);
+        }
+        else {
+            EPHYR_DBG("SHM segment attached %p", host_screen->shminfo.shmaddr);
+            host_screen->shminfo.readOnly = False;
+            XShmAttach(HostX.dpy, &host_screen->shminfo);
+            shm_success = True;
+        }
     }
 
-  if (!shm_success)
-    {
-      bitmap_pad = ( HostX.depth > 16 )? 32 : (( HostX.depth > 8 )? 16 : 8 );
-
-      EPHYR_DBG("Creating image %dx%d for screen host_screen=%p\n",
-                width, buffer_height, host_screen );
-      host_screen->ximg = XCreateImage (HostX.dpy,
-                                        HostX.visual,
-                                        HostX.depth,
-                                        ZPixmap, 0, 0,
-                                        width,
-                                        buffer_height,
-                                        bitmap_pad,
-                                        0);
-
-      host_screen->ximg->data =
-              malloc (host_screen->ximg->bytes_per_line * buffer_height);
+    if (!shm_success) {
+        bitmap_pad = (HostX.depth > 16) ? 32 : ((HostX.depth > 8) ? 16 : 8);
+
+        EPHYR_DBG("Creating image %dx%d for screen host_screen=%p\n",
+                  width, buffer_height, host_screen);
+        host_screen->ximg = XCreateImage(HostX.dpy,
+                                         HostX.visual,
+                                         HostX.depth,
+                                         ZPixmap, 0, 0,
+                                         width, buffer_height, bitmap_pad, 0);
+
+        host_screen->ximg->data =
+            malloc(host_screen->ximg->bytes_per_line * buffer_height);
     }
 
-  XResizeWindow (HostX.dpy, host_screen->win, width, height);
+    XResizeWindow(HostX.dpy, host_screen->win, width, height);
 
-  /* Ask the WM to keep our size static */
-  size_hints = XAllocSizeHints();
-  size_hints->max_width = size_hints->min_width = width;
-  size_hints->max_height = size_hints->min_height = height;
-  size_hints->flags = PMinSize|PMaxSize;
-  XSetWMNormalHints(HostX.dpy, host_screen->win, size_hints);
-  XFree(size_hints);
+    /* Ask the WM to keep our size static */
+    size_hints = XAllocSizeHints();
+    size_hints->max_width = size_hints->min_width = width;
+    size_hints->max_height = size_hints->min_height = height;
+    size_hints->flags = PMinSize | PMaxSize;
+    XSetWMNormalHints(HostX.dpy, host_screen->win, size_hints);
+    XFree(size_hints);
 
-  XMapWindow(HostX.dpy, host_screen->win);
+    XMapWindow(HostX.dpy, host_screen->win);
 
-  XSync(HostX.dpy, False);
+    XSync(HostX.dpy, False);
 
-  host_screen->win_width  = width;
-  host_screen->win_height = height;
+    host_screen->win_width = width;
+    host_screen->win_height = height;
 
-  if (host_depth_matches_server(host_screen))
-    {
-      EPHYR_DBG("Host matches server");
-      return host_screen->ximg->data;
+    if (host_depth_matches_server(host_screen)) {
+        EPHYR_DBG("Host matches server");
+        return host_screen->ximg->data;
     }
-  else
-    {
-      EPHYR_DBG("server bpp %i", host_screen->server_depth>>3);
-      host_screen->fb_data = malloc(width*buffer_height*(host_screen->server_depth>>3));
-      return host_screen->fb_data;
+    else {
+        EPHYR_DBG("server bpp %i", host_screen->server_depth >> 3);
+        host_screen->fb_data =
+            malloc(width * buffer_height * (host_screen->server_depth >> 3));
+        return host_screen->fb_data;
     }
 }
 
-static void hostx_paint_debug_rect (struct EphyrHostScreen *host_screen,
-                                    int x,     int y,
-                                    int width, int height);
+static void hostx_paint_debug_rect(struct EphyrHostScreen *host_screen,
+                                   int x, int y, int width, int height);
 
 void
-hostx_paint_rect (EphyrScreenInfo screen,
-                  int sx,    int sy,
-                  int dx,    int dy,
-                  int width, int height)
+hostx_paint_rect(EphyrScreenInfo screen,
+                 int sx, int sy, int dx, int dy, int width, int height)
 {
-  struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen);
+    struct EphyrHostScreen *host_screen = host_screen_from_screen_info(screen);
 
-  EPHYR_DBG ("painting in screen %d\n", host_screen->mynum) ;
+    EPHYR_DBG("painting in screen %d\n", host_screen->mynum);
 
-  /*
-   *  Copy the image data updated by the shadow layer
-   *  on to the window
-   */
+    /*
+     *  Copy the image data updated by the shadow layer
+     *  on to the window
+     */
 
-  if (HostXWantDamageDebug)
-    {
-      hostx_paint_debug_rect(host_screen, dx, dy, width, height);
+    if (HostXWantDamageDebug) {
+        hostx_paint_debug_rect(host_screen, dx, dy, width, height);
     }
 
-  /* 
-   * If the depth of the ephyr server is less than that of the host,
-   * the kdrive fb does not point to the ximage data but to a buffer
-   * ( fb_data ), we shift the various bits from this onto the XImage
-   * so they match the host.
-   *
-   * Note, This code is pretty new ( and simple ) so may break on 
-   *       endian issues, 32 bpp host etc. 
-   *       Not sure if 8bpp case is right either. 
-   *       ... and it will be slower than the matching depth case.
-   */
-
-  if (!host_depth_matches_server(host_screen))
-    {
-      int            x,y,idx, bytes_per_pixel = (host_screen->server_depth>>3);
-      unsigned char  r,g,b;
-      unsigned long  host_pixel;
-
-      EPHYR_DBG("Unmatched host depth host_screen=%p\n", host_screen);
-      for (y=sy; y<sy+height; y++)
-	for (x=sx; x<sx+width; x++)
-	  {
-	    idx = (host_screen->win_width*y*bytes_per_pixel)+(x*bytes_per_pixel);
-
-	    switch (host_screen->server_depth)
-	      {
-	      case 16:
-		{
-		  unsigned short pixel = *(unsigned short*)(host_screen->fb_data+idx);
-
-		  r = ((pixel & 0xf800) >> 8);
-		  g = ((pixel & 0x07e0) >> 3);
-		  b = ((pixel & 0x001f) << 3);
-
-		  host_pixel = (r << 16) | (g << 8) | (b);
-		  
-		  XPutPixel(host_screen->ximg, x, y, host_pixel);
-		  break;
-		}
-	      case 8:
-		{
-		  unsigned char pixel = *(unsigned char*)(host_screen->fb_data+idx);
-		  XPutPixel(host_screen->ximg, x, y, HostX.cmap[pixel]);
-		  break;
-		}
-	      default:
-		break;
-	      }
-	  }
+    /* 
+     * If the depth of the ephyr server is less than that of the host,
+     * the kdrive fb does not point to the ximage data but to a buffer
+     * ( fb_data ), we shift the various bits from this onto the XImage
+     * so they match the host.
+     *
+     * Note, This code is pretty new ( and simple ) so may break on 
+     *       endian issues, 32 bpp host etc. 
+     *       Not sure if 8bpp case is right either. 
+     *       ... and it will be slower than the matching depth case.
+     */
+
+    if (!host_depth_matches_server(host_screen)) {
+        int x, y, idx, bytes_per_pixel = (host_screen->server_depth >> 3);
+        unsigned char r, g, b;
+        unsigned long host_pixel;
+
+        EPHYR_DBG("Unmatched host depth host_screen=%p\n", host_screen);
+        for (y = sy; y < sy + height; y++)
+            for (x = sx; x < sx + width; x++) {
+                idx =
+                    (host_screen->win_width * y * bytes_per_pixel) +
+                    (x * bytes_per_pixel);
+
+                switch (host_screen->server_depth) {
+                case 16:
+                {
+                    unsigned short pixel =
+                        *(unsigned short *) (host_screen->fb_data + idx);
+
+                    r = ((pixel & 0xf800) >> 8);
+                    g = ((pixel & 0x07e0) >> 3);
+                    b = ((pixel & 0x001f) << 3);
+
+                    host_pixel = (r << 16) | (g << 8) | (b);
+
+                    XPutPixel(host_screen->ximg, x, y, host_pixel);
+                    break;
+                }
+                case 8:
+                {
+                    unsigned char pixel =
+                        *(unsigned char *) (host_screen->fb_data + idx);
+                    XPutPixel(host_screen->ximg, x, y, HostX.cmap[pixel]);
+                    break;
+                }
+                default:
+                    break;
+                }
+            }
     }
 
-  if (HostX.have_shm)
-    {
-      XShmPutImage (HostX.dpy, host_screen->win,
-                    HostX.gc, host_screen->ximg,
-                    sx, sy, dx, dy, width, height, False);
+    if (HostX.have_shm) {
+        XShmPutImage(HostX.dpy, host_screen->win,
+                     HostX.gc, host_screen->ximg,
+                     sx, sy, dx, dy, width, height, False);
     }
-  else
-    {
-      XPutImage (HostX.dpy, host_screen->win, HostX.gc, host_screen->ximg, 
-                 sx, sy, dx, dy, width, height);
+    else {
+        XPutImage(HostX.dpy, host_screen->win, HostX.gc, host_screen->ximg,
+                  sx, sy, dx, dy, width, height);
     }
 
-  XSync (HostX.dpy, False);
+    XSync(HostX.dpy, False);
 }
 
 static void
-hostx_paint_debug_rect (struct EphyrHostScreen *host_screen,
-                        int x,     int y,
-                        int width, int height)
+hostx_paint_debug_rect(struct EphyrHostScreen *host_screen,
+                       int x, int y, int width, int height)
 {
-  struct timespec tspec;
+    struct timespec tspec;
 
-  tspec.tv_sec  = HostX.damage_debug_msec / (1000000);
-  tspec.tv_nsec = (HostX.damage_debug_msec % 1000000) * 1000;
+    tspec.tv_sec = HostX.damage_debug_msec / (1000000);
+    tspec.tv_nsec = (HostX.damage_debug_msec % 1000000) * 1000;
 
-  EPHYR_DBG("msec: %li tv_sec %li, tv_msec %li", 
-	    HostX.damage_debug_msec, tspec.tv_sec, tspec.tv_nsec);
+    EPHYR_DBG("msec: %li tv_sec %li, tv_msec %li",
+              HostX.damage_debug_msec, tspec.tv_sec, tspec.tv_nsec);
 
-  /* fprintf(stderr, "Xephyr updating: %i+%i %ix%i\n", x, y, width, height); */
+    /* fprintf(stderr, "Xephyr updating: %i+%i %ix%i\n", x, y, width, height); */
 
-  XFillRectangle (HostX.dpy, host_screen->win, HostX.gc, x, y, width,height);
-  XSync (HostX.dpy, False);
+    XFillRectangle(HostX.dpy, host_screen->win, HostX.gc, x, y, width, height);
+    XSync(HostX.dpy, False);
 
-  /* nanosleep seems to work better than usleep for me... */
-  nanosleep(&tspec, NULL);
+    /* nanosleep seems to work better than usleep for me... */
+    nanosleep(&tspec, NULL);
 }
 
 void
 hostx_load_keymap(void)
 {
-  XID             *keymap;
-  int              host_width, min_keycode, max_keycode, width;
-  int              i,j;
-
-  XDisplayKeycodes (HostX.dpy, &min_keycode, &max_keycode);
-
-  EPHYR_DBG ("min: %d, max: %d", min_keycode, max_keycode);
-
-  keymap = XGetKeyboardMapping (HostX.dpy,
-			        min_keycode,
-			        max_keycode - min_keycode + 1,
-			        &host_width);
-
-  /* Try and copy the hosts keymap into our keymap to avoid loads
-   * of messing around.
-   *
-   * kdrive cannot can have more than 4 keysyms per keycode
-   * so we only copy at most the first 4 ( xorg has 6 per keycode, XVNC 2 )
-   */
-  width = (host_width > 4) ? 4 : host_width;
-
-  ephyrKeySyms.map = (CARD32 *)calloc(sizeof(CARD32),
-                                      (max_keycode - min_keycode + 1) *
-                                      width);
-  if (!ephyrKeySyms.map)
+    XID *keymap;
+    int host_width, min_keycode, max_keycode, width;
+    int i, j;
+
+    XDisplayKeycodes(HostX.dpy, &min_keycode, &max_keycode);
+
+    EPHYR_DBG("min: %d, max: %d", min_keycode, max_keycode);
+
+    keymap = XGetKeyboardMapping(HostX.dpy,
+                                 min_keycode,
+                                 max_keycode - min_keycode + 1, &host_width);
+
+    /* Try and copy the hosts keymap into our keymap to avoid loads
+     * of messing around.
+     *
+     * kdrive cannot can have more than 4 keysyms per keycode
+     * so we only copy at most the first 4 ( xorg has 6 per keycode, XVNC 2 )
+     */
+    width = (host_width > 4) ? 4 : host_width;
+
+    ephyrKeySyms.map = (CARD32 *) calloc(sizeof(CARD32),
+                                         (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++)
-      ephyrKeySyms.map[(i*width)+j] = (CARD32) keymap[(i*host_width) + j];
+    for (i = 0; i < (max_keycode - min_keycode + 1); i++)
+        for (j = 0; j < width; j++)
+            ephyrKeySyms.map[(i * width) + j] =
+                (CARD32) keymap[(i * host_width) + j];
 
-  EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width);
+    EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width);
 
-  ephyrKeySyms.minKeyCode  = min_keycode;
-  ephyrKeySyms.maxKeyCode  = max_keycode;
-  ephyrKeySyms.mapWidth    = width;
+    ephyrKeySyms.minKeyCode = min_keycode;
+    ephyrKeySyms.maxKeyCode = max_keycode;
+    ephyrKeySyms.mapWidth = width;
 
-  XFree(keymap);
+    XFree(keymap);
 }
 
 static struct EphyrHostScreen *
-host_screen_from_window (Window w)
+host_screen_from_window(Window w)
 {
-  int index = 0;
-  struct EphyrHostScreen *result  = NULL;
+    int index = 0;
+    struct EphyrHostScreen *result = NULL;
 
-  for (index = 0 ; index < HostX.n_screens ; index++)
-    {
-      if (HostX.screens[index].win == w || HostX.screens[index].peer_win == w)
-        {
-          result = &HostX.screens[index];
-          goto out;
+    for (index = 0; index < HostX.n_screens; index++) {
+        if (HostX.screens[index].win == w || HostX.screens[index].peer_win == w) {
+            result = &HostX.screens[index];
+            goto out;
         }
     }
 
-out:
-  return result;
+ out:
+    return result;
 }
 
 int
-hostx_get_event(EphyrHostXEvent *ev)
+hostx_get_event(EphyrHostXEvent * ev)
 {
-  XEvent      xev;
-  static int  grabbed_screen = -1;
-
-  if (XPending(HostX.dpy))
-    {
-      XNextEvent(HostX.dpy, &xev);
-
-      switch (xev.type) 
-	{
-	case Expose:
-	  /* Not so great event compression, but works ok */
-	  while (XCheckTypedWindowEvent(HostX.dpy, xev.xexpose.window,
-					Expose, &xev));
-	  {
-	    struct EphyrHostScreen *host_screen =
-                host_screen_from_window (xev.xexpose.window);
-            if (host_screen)
-              {
-                hostx_paint_rect (host_screen->info, 0, 0, 0, 0,
-                                  host_screen->win_width,
-                                  host_screen->win_height);
-              }
-            else
-              {
-                EPHYR_LOG_ERROR ("failed to get host screen\n");
-                ev->type = EPHYR_EV_EXPOSE;
-                ev->data.expose.window = xev.xexpose.window;
-                return 1;
-              }
-	  }
-	  return 0;
-
-	case MotionNotify:
-	  {
-	    struct EphyrHostScreen *host_screen =
-                host_screen_from_window (xev.xmotion.window);
-
-	    ev->type = EPHYR_EV_MOUSE_MOTION;
-	    ev->data.mouse_motion.x = xev.xmotion.x;
-	    ev->data.mouse_motion.y = xev.xmotion.y;
-	    ev->data.mouse_motion.window = xev.xmotion.window;
-	    ev->data.mouse_motion.screen = (host_screen ? host_screen->mynum : -1);
-	  }
-	  return 1;
-
-	case ButtonPress:
-	  ev->type = EPHYR_EV_MOUSE_PRESS;
-	  ev->key_state = xev.xkey.state;
-	  /* 
-	   * This is a bit hacky. will break for button 5 ( defined as 0x10 )
-           * Check KD_BUTTON defines in kdrive.h 
-	   */
-	  ev->data.mouse_down.button_num = 1<<(xev.xbutton.button-1);
-	  return 1;
-
-	case ButtonRelease:
-	  ev->type = EPHYR_EV_MOUSE_RELEASE;
-	  ev->key_state = xev.xkey.state;
-	  ev->data.mouse_up.button_num = 1<<(xev.xbutton.button-1);
-	  return 1;
-
-	case KeyPress:
-	  {
-	    ev->type = EPHYR_EV_KEY_PRESS;
-	    ev->key_state = xev.xkey.state;
-	    ev->data.key_down.scancode = xev.xkey.keycode;  
-	    return 1;
-	  }
-	case KeyRelease:
-
-	  if ((XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_L
-	       || XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_R)
-	      && (xev.xkey.state & ControlMask))
-	    {
-	      struct EphyrHostScreen *host_screen =
-                  host_screen_from_window (xev.xexpose.window);
-
-	      if (grabbed_screen != -1)
-		{
-		  XUngrabKeyboard (HostX.dpy, CurrentTime);
-		  XUngrabPointer (HostX.dpy, CurrentTime);
-		  grabbed_screen = -1;
-		  hostx_set_win_title (host_screen->info,
-                                       "(ctrl+shift grabs mouse and keyboard)");
-		}
-	      else
-		{
-		  /* Attempt grab */
-		  if (XGrabKeyboard (HostX.dpy, host_screen->win, True, 
-				     GrabModeAsync, 
-				     GrabModeAsync, 
-				     CurrentTime) == 0)
-		    {
-		      if (XGrabPointer (HostX.dpy, host_screen->win, True, 
-					NoEventMask, 
-					GrabModeAsync, 
-					GrabModeAsync, 
-					host_screen->win, None, CurrentTime) == 0)
-			{
-			  grabbed_screen = host_screen->mynum;
-			  hostx_set_win_title
-                                  (host_screen->info,
-                                   "(ctrl+shift releases mouse and keyboard)");
-			}
-		      else 	/* Failed pointer grabm  ungrab keyboard */
-			XUngrabKeyboard (HostX.dpy, CurrentTime);
-		    }
-		}
-	    }
-
-	  /* Still send the release event even if above has happened
-           * server will get confused with just an up event. 
-           * Maybe it would be better to just block shift+ctrls getting to
-           * kdrive all togeather. 
- 	   */
-	  ev->type = EPHYR_EV_KEY_RELEASE;
-	  ev->key_state = xev.xkey.state;
-	  ev->data.key_up.scancode = xev.xkey.keycode;
-	  return 1;
-
-	default:
-	  break;
-
-	}
+    XEvent xev;
+    static int grabbed_screen = -1;
+
+    if (XPending(HostX.dpy)) {
+        XNextEvent(HostX.dpy, &xev);
+
+        switch (xev.type) {
+        case Expose:
+            /* Not so great event compression, but works ok */
+            while (XCheckTypedWindowEvent(HostX.dpy, xev.xexpose.window,
+                                          Expose, &xev));
+            {
+                struct EphyrHostScreen *host_screen =
+                    host_screen_from_window(xev.xexpose.window);
+                if (host_screen) {
+                    hostx_paint_rect(host_screen->info, 0, 0, 0, 0,
+                                     host_screen->win_width,
+                                     host_screen->win_height);
+                }
+                else {
+                    EPHYR_LOG_ERROR("failed to get host screen\n");
+                    ev->type = EPHYR_EV_EXPOSE;
+                    ev->data.expose.window = xev.xexpose.window;
+                    return 1;
+                }
+            }
+            return 0;
+
+        case MotionNotify:
+        {
+            struct EphyrHostScreen *host_screen =
+                host_screen_from_window(xev.xmotion.window);
+
+            ev->type = EPHYR_EV_MOUSE_MOTION;
+            ev->data.mouse_motion.x = xev.xmotion.x;
+            ev->data.mouse_motion.y = xev.xmotion.y;
+            ev->data.mouse_motion.window = xev.xmotion.window;
+            ev->data.mouse_motion.screen =
+                (host_screen ? host_screen->mynum : -1);
+        }
+            return 1;
+
+        case ButtonPress:
+            ev->type = EPHYR_EV_MOUSE_PRESS;
+            ev->key_state = xev.xkey.state;
+            /* 
+             * This is a bit hacky. will break for button 5 ( defined as 0x10 )
+             * Check KD_BUTTON defines in kdrive.h 
+             */
+            ev->data.mouse_down.button_num = 1 << (xev.xbutton.button - 1);
+            return 1;
+
+        case ButtonRelease:
+            ev->type = EPHYR_EV_MOUSE_RELEASE;
+            ev->key_state = xev.xkey.state;
+            ev->data.mouse_up.button_num = 1 << (xev.xbutton.button - 1);
+            return 1;
+
+        case KeyPress:
+        {
+            ev->type = EPHYR_EV_KEY_PRESS;
+            ev->key_state = xev.xkey.state;
+            ev->data.key_down.scancode = xev.xkey.keycode;
+            return 1;
+        }
+        case KeyRelease:
+
+            if ((XKeycodeToKeysym(HostX.dpy, xev.xkey.keycode, 0) == XK_Shift_L
+                 || XKeycodeToKeysym(HostX.dpy, xev.xkey.keycode,
+                                     0) == XK_Shift_R)
+                && (xev.xkey.state & ControlMask)) {
+                struct EphyrHostScreen *host_screen =
+                    host_screen_from_window(xev.xexpose.window);
+
+                if (grabbed_screen != -1) {
+                    XUngrabKeyboard(HostX.dpy, CurrentTime);
+                    XUngrabPointer(HostX.dpy, CurrentTime);
+                    grabbed_screen = -1;
+                    hostx_set_win_title(host_screen->info,
+                                        "(ctrl+shift grabs mouse and keyboard)");
+                }
+                else {
+                    /* Attempt grab */
+                    if (XGrabKeyboard(HostX.dpy, host_screen->win, True,
+                                      GrabModeAsync,
+                                      GrabModeAsync, CurrentTime) == 0) {
+                        if (XGrabPointer(HostX.dpy, host_screen->win, True,
+                                         NoEventMask,
+                                         GrabModeAsync,
+                                         GrabModeAsync,
+                                         host_screen->win, None,
+                                         CurrentTime) == 0) {
+                            grabbed_screen = host_screen->mynum;
+                            hostx_set_win_title
+                                (host_screen->info,
+                                 "(ctrl+shift releases mouse and keyboard)");
+                        }
+                        else    /* Failed pointer grabm  ungrab keyboard */
+                            XUngrabKeyboard(HostX.dpy, CurrentTime);
+                    }
+                }
+            }
+
+            /* Still send the release event even if above has happened
+             * server will get confused with just an up event. 
+             * Maybe it would be better to just block shift+ctrls getting to
+             * kdrive all togeather. 
+             */
+            ev->type = EPHYR_EV_KEY_RELEASE;
+            ev->key_state = xev.xkey.state;
+            ev->data.key_up.scancode = xev.xkey.keycode;
+            return 1;
+
+        default:
+            break;
+
+        }
     }
-  return 0;
+    return 0;
 }
 
-void*
+void *
 hostx_get_display(void)
 {
-    return HostX.dpy ;
+    return HostX.dpy;
 }
 
 int
-hostx_get_window (int a_screen_number)
+hostx_get_window(int a_screen_number)
 {
     if (a_screen_number < 0 || a_screen_number >= HostX.n_screens) {
-        EPHYR_LOG_ERROR ("bad screen number:%d\n", a_screen_number) ;
+        EPHYR_LOG_ERROR("bad screen number:%d\n", a_screen_number);
         return 0;
     }
-    return HostX.screens[a_screen_number].win ;
+    return HostX.screens[a_screen_number].win;
 }
 
 int
-hostx_get_window_attributes (int a_window, EphyrHostWindowAttributes *a_attrs)
+hostx_get_window_attributes(int a_window, EphyrHostWindowAttributes * a_attrs)
 {
-    XWindowAttributes attrs ;
+    XWindowAttributes attrs;
 
-    memset (&attrs, 0, sizeof (attrs)) ;
+    memset(&attrs, 0, sizeof(attrs));
 
-    if (!XGetWindowAttributes (hostx_get_display (),
-                               a_window,
-                               &attrs)) {
-        return FALSE ;
+    if (!XGetWindowAttributes(hostx_get_display(), a_window, &attrs)) {
+        return FALSE;
     }
-    a_attrs->x = attrs.x ;
-    a_attrs->y = attrs.y ;
-    a_attrs->width = attrs.width ;
-    a_attrs->height = attrs.height ;
+    a_attrs->x = attrs.x;
+    a_attrs->y = attrs.y;
+    a_attrs->width = attrs.width;
+    a_attrs->height = attrs.height;
     if (attrs.visual)
-        a_attrs->visualid = attrs.visual->visualid ;
-    return TRUE ;
+        a_attrs->visualid = attrs.visual->visualid;
+    return TRUE;
 }
 
 int
-hostx_get_extension_info (const char *a_ext_name,
-                          int *a_major_opcode,
-                          int *a_first_event,
-                          int *a_first_error)
+hostx_get_extension_info(const char *a_ext_name,
+                         int *a_major_opcode,
+                         int *a_first_event, int *a_first_error)
 {
     if (!a_ext_name || !a_major_opcode || !a_first_event || !a_first_error)
-      return 0 ;
-   if (!XQueryExtension (HostX.dpy,
+        return 0;
+    if (!XQueryExtension(HostX.dpy,
                          a_ext_name,
-                         a_major_opcode,
-                         a_first_event,
-                         a_first_error))
-     {
-       return 0 ;
-     }
-   return 1 ;
+                         a_major_opcode, a_first_event, a_first_error)) {
+        return 0;
+    }
+    return 1;
 }
 
 int
-hostx_get_visuals_info (EphyrHostVisualInfo **a_visuals,
-                        int *a_num_entries)
+hostx_get_visuals_info(EphyrHostVisualInfo ** a_visuals, int *a_num_entries)
 {
-    Display *dpy=hostx_get_display () ;
-    Bool is_ok=False ;
-    XVisualInfo templ, *visuals=NULL;
-    EphyrHostVisualInfo *host_visuals=NULL ;
-    int nb_items=0, i=0;
-
-    EPHYR_RETURN_VAL_IF_FAIL (a_visuals && a_num_entries && dpy,
-                              False) ;
-    EPHYR_LOG ("enter\n") ;
-    memset (&templ, 0, sizeof (templ)) ;
-    visuals = XGetVisualInfo (dpy, VisualNoMask, &templ, &nb_items) ;
+    Display *dpy = hostx_get_display();
+    Bool is_ok = False;
+    XVisualInfo templ, *visuals = NULL;
+    EphyrHostVisualInfo *host_visuals = NULL;
+    int nb_items = 0, i = 0;
+
+    EPHYR_RETURN_VAL_IF_FAIL(a_visuals && a_num_entries && dpy, False);
+    EPHYR_LOG("enter\n");
+    memset(&templ, 0, sizeof(templ));
+    visuals = XGetVisualInfo(dpy, VisualNoMask, &templ, &nb_items);
     if (!visuals) {
-        EPHYR_LOG_ERROR ("host does not advertise any visual\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("host does not advertise any visual\n");
+        goto out;
     }
-    EPHYR_LOG ("host advertises %d visuals\n", nb_items) ;
-    host_visuals = calloc (nb_items, sizeof (EphyrHostVisualInfo)) ;
-    for (i=0; i<nb_items; i++) {
-        host_visuals[i].visualid = visuals[i].visualid ;
-        host_visuals[i].screen = visuals[i].screen ;
-        host_visuals[i].depth = visuals[i].depth ;
-        host_visuals[i].class = visuals[i].class ;
-        host_visuals[i].red_mask = visuals[i].red_mask ;
-        host_visuals[i].green_mask = visuals[i].green_mask ;
-        host_visuals[i].blue_mask = visuals[i].blue_mask ;
-        host_visuals[i].colormap_size = visuals[i].colormap_size ;
-        host_visuals[i].bits_per_rgb = visuals[i].bits_per_rgb ;
+    EPHYR_LOG("host advertises %d visuals\n", nb_items);
+    host_visuals = calloc(nb_items, sizeof(EphyrHostVisualInfo));
+    for (i = 0; i < nb_items; i++) {
+        host_visuals[i].visualid = visuals[i].visualid;
+        host_visuals[i].screen = visuals[i].screen;
+        host_visuals[i].depth = visuals[i].depth;
+        host_visuals[i].class = visuals[i].class;
+        host_visuals[i].red_mask = visuals[i].red_mask;
+        host_visuals[i].green_mask = visuals[i].green_mask;
+        host_visuals[i].blue_mask = visuals[i].blue_mask;
+        host_visuals[i].colormap_size = visuals[i].colormap_size;
+        host_visuals[i].bits_per_rgb = visuals[i].bits_per_rgb;
     }
-    *a_visuals = host_visuals ;
+    *a_visuals = host_visuals;
     *a_num_entries = nb_items;
-    host_visuals=NULL;
+    host_visuals = NULL;
 
     is_ok = TRUE;
-out:
+ out:
     if (visuals) {
-        XFree (visuals) ;
+        XFree(visuals);
         visuals = NULL;
     }
     free(host_visuals);
     host_visuals = NULL;
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    EPHYR_LOG("leave\n");
+    return is_ok;
 
 }
 
 int
-hostx_create_window (int a_screen_number,
-                     EphyrBox *a_geometry,
-                     int a_visual_id,
-                     int *a_host_peer /*out parameter*/)
+hostx_create_window(int a_screen_number,
+                    EphyrBox * a_geometry,
+                    int a_visual_id, int *a_host_peer /*out parameter */ )
 {
-    Bool is_ok=FALSE ;
-    Display *dpy=hostx_get_display () ;
-    XVisualInfo *visual_info=NULL, visual_info_templ;
-    int visual_mask=VisualIDMask ;
-    Window win=None ;
-    int nb_visuals=0, winmask=0;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    XVisualInfo *visual_info = NULL, visual_info_templ;
+    int visual_mask = VisualIDMask;
+    Window win = None;
+    int nb_visuals = 0, winmask = 0;
     XSetWindowAttributes attrs;
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geometry, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy && a_geometry, FALSE);
 
-    EPHYR_LOG ("enter\n") ;
+    EPHYR_LOG("enter\n");
 
-     /*get visual*/
-    memset (&visual_info, 0, sizeof (visual_info)) ;
-    visual_info_templ.visualid = a_visual_id ;
-    visual_info = XGetVisualInfo (dpy, visual_mask,
-                                  &visual_info_templ,
-                                  &nb_visuals) ;
+    /*get visual */
+    memset(&visual_info, 0, sizeof(visual_info));
+    visual_info_templ.visualid = a_visual_id;
+    visual_info = XGetVisualInfo(dpy, visual_mask,
+                                 &visual_info_templ, &nb_visuals);
     if (!visual_info) {
-        EPHYR_LOG_ERROR ("argh, could not find a remote visual with id:%d\n",
-                         a_visual_id) ;
-        goto out ;
+        EPHYR_LOG_ERROR("argh, could not find a remote visual with id:%d\n",
+                        a_visual_id);
+        goto out;
     }
-    memset (&attrs, 0, sizeof (attrs)) ;
-    attrs.colormap = XCreateColormap (dpy,
-                                      RootWindow (dpy,
-                                                  visual_info->screen),
-                                      visual_info->visual,
-                                      AllocNone) ;
+    memset(&attrs, 0, sizeof(attrs));
+    attrs.colormap = XCreateColormap(dpy,
+                                     RootWindow(dpy,
+                                                visual_info->screen),
+                                     visual_info->visual, AllocNone);
     attrs.event_mask = ButtonPressMask
-                       |ButtonReleaseMask
-                       |PointerMotionMask
-                       |KeyPressMask
-                       |KeyReleaseMask
-                       |ExposureMask;
-    winmask = CWColormap|CWEventMask;
-
-    win = XCreateWindow (dpy, hostx_get_window (a_screen_number),
-                         a_geometry->x, a_geometry->y,
-                         a_geometry->width, a_geometry->height, 0,
-                         visual_info->depth, CopyFromParent,
-                         visual_info->visual, winmask, &attrs) ;
+        | ButtonReleaseMask
+        | PointerMotionMask | KeyPressMask | KeyReleaseMask | ExposureMask;
+    winmask = CWColormap | CWEventMask;
+
+    win = XCreateWindow(dpy, hostx_get_window(a_screen_number),
+                        a_geometry->x, a_geometry->y,
+                        a_geometry->width, a_geometry->height, 0,
+                        visual_info->depth, CopyFromParent,
+                        visual_info->visual, winmask, &attrs);
     if (win == None) {
-        EPHYR_LOG_ERROR ("failed to create peer window\n") ;
-        goto out ;
+        EPHYR_LOG_ERROR("failed to create peer window\n");
+        goto out;
     }
     if (HostX.screens[a_screen_number].peer_win == None) {
-	HostX.screens[a_screen_number].peer_win = win;
-    } else {
-        EPHYR_LOG_ERROR ("multiple peer windows created for same screen\n") ;
+        HostX.screens[a_screen_number].peer_win = win;
+    }
+    else {
+        EPHYR_LOG_ERROR("multiple peer windows created for same screen\n");
     }
-    XFlush (dpy) ;
-    XMapWindow (dpy, win) ;
-    *a_host_peer = win ;
-    is_ok = TRUE ;
-out:
-    EPHYR_LOG ("leave\n") ;
-    return is_ok ;
+    XFlush(dpy);
+    XMapWindow(dpy, win);
+    *a_host_peer = win;
+    is_ok = TRUE;
+ out:
+    EPHYR_LOG("leave\n");
+    return is_ok;
 }
 
 int
-hostx_destroy_window (int a_win)
+hostx_destroy_window(int a_win)
 {
-    Display *dpy=hostx_get_display () ;
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
-    XDestroyWindow (dpy, a_win) ;
-    XFlush (dpy) ;
-    return TRUE ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy, FALSE);
+    XDestroyWindow(dpy, a_win);
+    XFlush(dpy);
+    return TRUE;
 }
 
 int
-hostx_set_window_geometry (int a_win, EphyrBox *a_geo)
+hostx_set_window_geometry(int a_win, EphyrBox * a_geo)
 {
-    Display *dpy=hostx_get_display ();
+    Display *dpy = hostx_get_display();
 
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geo, FALSE) ;
+    EPHYR_RETURN_VAL_IF_FAIL(dpy && a_geo, FALSE);
 
-    EPHYR_LOG ("enter. x,y,w,h:(%d,%d,%d,%d)\n",
-               a_geo->x, a_geo->y,
-               a_geo->width, a_geo->height) ;
+    EPHYR_LOG("enter. x,y,w,h:(%d,%d,%d,%d)\n",
+              a_geo->x, a_geo->y, a_geo->width, a_geo->height);
 
-    XMoveWindow (dpy, a_win, a_geo->x, a_geo->y) ;
-    XResizeWindow (dpy, a_win, a_geo->width, a_geo->height) ;
-    EPHYR_LOG ("leave\n") ;
+    XMoveWindow(dpy, a_win, a_geo->x, a_geo->y);
+    XResizeWindow(dpy, a_win, a_geo->width, a_geo->height);
+    EPHYR_LOG("leave\n");
     return TRUE;
 }
 
 int
-hostx_set_window_bounding_rectangles (int a_window,
-                                      EphyrRect *a_rects,
-                                      int a_num_rects)
+hostx_set_window_bounding_rectangles(int a_window,
+                                     EphyrRect * a_rects, int a_num_rects)
 {
-    Bool is_ok=FALSE;
-    Display *dpy=hostx_get_display () ;
-    int i=0 ;
-    XRectangle *rects=NULL ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;
-
-    EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;
-
-    rects = calloc (a_num_rects, sizeof (XRectangle)) ;
-    for (i=0; i<a_num_rects; i++) {
-        rects[i].x = a_rects[i].x1 ;
-        rects[i].y = a_rects[i].y1 ;
-        rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);
-        rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;
-        EPHYR_LOG ("borders clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
-                   rects[i].x, rects[i].y,
-                   rects[i].width, rects[i].height) ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    int i = 0;
+    XRectangle *rects = NULL;
+
+    EPHYR_RETURN_VAL_IF_FAIL(dpy && a_rects, FALSE);
+
+    EPHYR_LOG("enter. num rects:%d\n", a_num_rects);
+
+    rects = calloc(a_num_rects, sizeof(XRectangle));
+    for (i = 0; i < a_num_rects; i++) {
+        rects[i].x = a_rects[i].x1;
+        rects[i].y = a_rects[i].y1;
+        rects[i].width = abs(a_rects[i].x2 - a_rects[i].x1);
+        rects[i].height = abs(a_rects[i].y2 - a_rects[i].y1);
+        EPHYR_LOG("borders clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
+                  rects[i].x, rects[i].y, rects[i].width, rects[i].height);
     }
-    /*this aways returns 1*/
-    XShapeCombineRectangles (dpy, a_window, ShapeBounding, 0, 0,
-                             rects, a_num_rects, ShapeSet, YXBanded) ;
-    is_ok = TRUE ;
+    /*this aways returns 1 */
+    XShapeCombineRectangles(dpy, a_window, ShapeBounding, 0, 0,
+                            rects, a_num_rects, ShapeSet, YXBanded);
+    is_ok = TRUE;
 
     free(rects);
     rects = NULL;
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
     return is_ok;
 }
 
 int
-hostx_set_window_clipping_rectangles (int a_window,
-                                      EphyrRect *a_rects,
-                                      int a_num_rects)
+hostx_set_window_clipping_rectangles(int a_window,
+                                     EphyrRect * a_rects, int a_num_rects)
 {
-    Bool is_ok=FALSE;
-    Display *dpy=hostx_get_display () ;
-    int i=0 ;
-    XRectangle *rects=NULL ;
-
-    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;
-
-    EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;
-
-    rects = calloc (a_num_rects, sizeof (XRectangle)) ;
-    for (i=0; i<a_num_rects; i++) {
-        rects[i].x = a_rects[i].x1 ;
-        rects[i].y = a_rects[i].y1 ;
-        rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);
-        rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;
-        EPHYR_LOG ("clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
-                   rects[i].x, rects[i].y,
-                   rects[i].width, rects[i].height) ;
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display();
+    int i = 0;
+    XRectangle *rects = NULL;
+
+    EPHYR_RETURN_VAL_IF_FAIL(dpy && a_rects, FALSE);
+
+    EPHYR_LOG("enter. num rects:%d\n", a_num_rects);
+
+    rects = calloc(a_num_rects, sizeof(XRectangle));
+    for (i = 0; i < a_num_rects; i++) {
+        rects[i].x = a_rects[i].x1;
+        rects[i].y = a_rects[i].y1;
+        rects[i].width = abs(a_rects[i].x2 - a_rects[i].x1);
+        rects[i].height = abs(a_rects[i].y2 - a_rects[i].y1);
+        EPHYR_LOG("clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
+                  rects[i].x, rects[i].y, rects[i].width, rects[i].height);
     }
-    /*this aways returns 1*/
-    XShapeCombineRectangles (dpy, a_window, ShapeClip, 0, 0,
-                             rects, a_num_rects, ShapeSet, YXBanded) ;
-    is_ok = TRUE ;
+    /*this aways returns 1 */
+    XShapeCombineRectangles(dpy, a_window, ShapeClip, 0, 0,
+                            rects, a_num_rects, ShapeSet, YXBanded);
+    is_ok = TRUE;
 
     free(rects);
     rects = NULL;
-    EPHYR_LOG ("leave\n") ;
+    EPHYR_LOG("leave\n");
     return is_ok;
 }
 
 int
-hostx_has_xshape (void)
+hostx_has_xshape(void)
 {
-    int event_base=0, error_base=0 ;
-    Display *dpy=hostx_get_display () ;
-    if (!XShapeQueryExtension (dpy,
-                               &event_base,
-                               &error_base)) {
-        return FALSE ;
+    int event_base = 0, error_base = 0;
+    Display *dpy = hostx_get_display();
+
+    if (!XShapeQueryExtension(dpy, &event_base, &error_base)) {
+        return FALSE;
     }
     return TRUE;
 }
 
 #ifdef XF86DRI
 typedef struct {
-    int is_valid ;
-    int local_id ;
-    int remote_id ;
-} ResourcePair ;
+    int is_valid;
+    int local_id;
+    int remote_id;
+} ResourcePair;
 
 #define RESOURCE_PEERS_SIZE 1024*10
-static ResourcePair resource_peers[RESOURCE_PEERS_SIZE] ;
-
+static ResourcePair resource_peers[RESOURCE_PEERS_SIZE];
 
 int
-hostx_allocate_resource_id_peer (int a_local_resource_id,
-                                 int *a_remote_resource_id)
+hostx_allocate_resource_id_peer(int a_local_resource_id,
+                                int *a_remote_resource_id)
 {
-    int i=0 ;
-    ResourcePair *peer=NULL ;
-    Display *dpy=hostx_get_display ();
+    int i = 0;
+    ResourcePair *peer = NULL;
+    Display *dpy = hostx_get_display();
 
     /*
      * first make sure a resource peer
      * does not exist already for
      * a_local_resource_id
      */
-    for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
+    for (i = 0; i < RESOURCE_PEERS_SIZE; i++) {
         if (resource_peers[i].is_valid
             && resource_peers[i].local_id == a_local_resource_id) {
-            peer = &resource_peers[i] ;
-            break ;
+            peer = &resource_peers[i];
+            break;
         }
     }
     /*
      * find one free peer entry, an feed it with
      */
     if (!peer) {
-        for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
+        for (i = 0; i < RESOURCE_PEERS_SIZE; i++) {
             if (!resource_peers[i].is_valid) {
-                peer = &resource_peers[i] ;
-                break ;
+                peer = &resource_peers[i];
+                break;
             }
         }
         if (peer) {
-            peer->remote_id = XAllocID (dpy);
-            peer->local_id = a_local_resource_id ;
-            peer->is_valid = TRUE ;
+            peer->remote_id = XAllocID(dpy);
+            peer->local_id = a_local_resource_id;
+            peer->is_valid = TRUE;
         }
     }
     if (peer) {
-        *a_remote_resource_id = peer->remote_id ;
-        return TRUE ;
+        *a_remote_resource_id = peer->remote_id;
+        return TRUE;
     }
-    return FALSE ;
+    return FALSE;
 }
 
 int
-hostx_get_resource_id_peer (int a_local_resource_id,
-                            int *a_remote_resource_id)
+hostx_get_resource_id_peer(int a_local_resource_id, int *a_remote_resource_id)
 {
-    int i=0 ;
-    ResourcePair *peer=NULL ;
-    for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
+    int i = 0;
+    ResourcePair *peer = NULL;
+
+    for (i = 0; i < RESOURCE_PEERS_SIZE; i++) {
         if (resource_peers[i].is_valid
             && resource_peers[i].local_id == a_local_resource_id) {
-            peer = &resource_peers[i] ;
-            break ;
+            peer = &resource_peers[i];
+            break;
         }
     }
     if (peer) {
-        *a_remote_resource_id = peer->remote_id ;
-        return TRUE ;
+        *a_remote_resource_id = peer->remote_id;
+        return TRUE;
     }
-    return FALSE ;
+    return FALSE;
 }
 
 int
-hostx_has_dri (void)
+hostx_has_dri(void)
 {
-    int event_base=0, error_base=0 ;
-    Display *dpy=hostx_get_display () ;
+    int event_base = 0, error_base = 0;
+    Display *dpy = hostx_get_display();
 
     if (!dpy)
-        return FALSE ;
+        return FALSE;
 
-    if (!XF86DRIQueryExtension (dpy,
-                                &event_base,
-                                &error_base)) {
-        return FALSE ;
+    if (!XF86DRIQueryExtension(dpy, &event_base, &error_base)) {
+        return FALSE;
     }
-    return TRUE ;
+    return TRUE;
 }
 
 int
-hostx_has_glx (void)
+hostx_has_glx(void)
 {
-    Display *dpy=hostx_get_display () ;
-    int event_base=0, error_base=0 ;
+    Display *dpy = hostx_get_display();
+    int event_base = 0, error_base = 0;
 
-    if (!glXQueryExtension (dpy, &event_base, &error_base)) {
-        return FALSE ;
+    if (!glXQueryExtension(dpy, &event_base, &error_base)) {
+        return FALSE;
     }
-    return TRUE ;
+    return TRUE;
 }
 
-#endif /* XF86DRI */
+#endif                          /* XF86DRI */
diff --git a/hw/kdrive/ephyr/hostx.h b/hw/kdrive/ephyr/hostx.h
index 42578576a..d6217119a 100644
--- a/hw/kdrive/ephyr/hostx.h
+++ b/hw/kdrive/ephyr/hostx.h
@@ -35,230 +35,212 @@
 #define EPHYR_DBG(x, a...) \
  fprintf(stderr, __FILE__ ":%d,%s() " x "\n", __LINE__, __func__, ##a)
 #else
-#define EPHYR_DBG(x, a...) do {} while (0) 
+#define EPHYR_DBG(x, a...) do {} while (0)
 #endif
 
-typedef struct EphyrHostXVars  EphyrHostXVars;
+typedef struct EphyrHostXVars EphyrHostXVars;
 typedef struct EphyrHostXEvent EphyrHostXEvent;
-typedef void* EphyrScreenInfo ;
-typedef enum EphyrHostXEventType
-{
-  EPHYR_EV_MOUSE_MOTION,
-  EPHYR_EV_MOUSE_PRESS,
-  EPHYR_EV_MOUSE_RELEASE,
-  EPHYR_EV_KEY_PRESS,
-  EPHYR_EV_KEY_RELEASE,
-  EPHYR_EV_EXPOSE
-} 
-EphyrHostXEventType;
+typedef void *EphyrScreenInfo;
+typedef enum EphyrHostXEventType {
+    EPHYR_EV_MOUSE_MOTION,
+    EPHYR_EV_MOUSE_PRESS,
+    EPHYR_EV_MOUSE_RELEASE,
+    EPHYR_EV_KEY_PRESS,
+    EPHYR_EV_KEY_RELEASE,
+    EPHYR_EV_EXPOSE
+} EphyrHostXEventType;
 
 /* I can't believe it's not a KeySymsRec. */
 typedef struct {
-  int             minKeyCode;
-  int             maxKeyCode;
-  int             mapWidth;
-  CARD32         *map;
+    int minKeyCode;
+    int maxKeyCode;
+    int mapWidth;
+    CARD32 *map;
 } EphyrKeySyms;
 
-struct EphyrHostXEvent
-{
-  EphyrHostXEventType type;
+struct EphyrHostXEvent {
+    EphyrHostXEventType type;
 
-  union 
-  {
-    struct mouse_motion { 	
-      int x;
-      int y;
-      int screen;
-      int window;
-    } mouse_motion;
+    union {
+        struct mouse_motion {
+            int x;
+            int y;
+            int screen;
+            int window;
+        } mouse_motion;
 
-    struct mouse_down { 	
-      int button_num;
-    } mouse_down;
+        struct mouse_down {
+            int button_num;
+        } mouse_down;
 
-    struct mouse_up {
-      int button_num;
-    } mouse_up;
+        struct mouse_up {
+            int button_num;
+        } mouse_up;
 
-    struct key_up {
-      int scancode;
-    } key_up;
+        struct key_up {
+            int scancode;
+        } key_up;
 
-    struct key_down {
-      int scancode;
-    } key_down;
+        struct key_down {
+            int scancode;
+        } key_down;
 
-    struct expose {
-      int window;
-    } expose;
+        struct expose {
+            int window;
+        } expose;
 
-  } data;
+    } data;
 
-  int key_state;
+    int key_state;
 };
 
 typedef struct {
-  VisualID visualid;
-  int screen;
-  int depth;
-  int class;
-  unsigned long red_mask;
-  unsigned long green_mask;
-  unsigned long blue_mask;
-  int colormap_size;
-  int bits_per_rgb;
+    VisualID visualid;
+    int screen;
+    int depth;
+    int class;
+    unsigned long red_mask;
+    unsigned long green_mask;
+    unsigned long blue_mask;
+    int colormap_size;
+    int bits_per_rgb;
 } EphyrHostVisualInfo;
 
 typedef struct {
     int x, y;
-    int width, height ;
-    int visualid ;
+    int width, height;
+    int visualid;
 } EphyrHostWindowAttributes;
 
 typedef struct {
-    int x,y,width,height;
+    int x, y, width, height;
 } EphyrBox;
 
 typedef struct {
-    short x1,y1,x2,y2;
+    short x1, y1, x2, y2;
 } EphyrRect;
 
 int
-hostx_want_screen_size(EphyrScreenInfo screen, int *width, int *height);
+ hostx_want_screen_size(EphyrScreenInfo screen, int *width, int *height);
 
 int
-hostx_want_host_cursor(void);
+ hostx_want_host_cursor(void);
 
 void
-hostx_use_host_cursor(void);
+ hostx_use_host_cursor(void);
 
 void
-hostx_use_fullscreen(void);
+ hostx_use_fullscreen(void);
 
 int
-hostx_want_fullscreen(void);
+ hostx_want_fullscreen(void);
 
 int
-hostx_want_preexisting_window(EphyrScreenInfo screen);
+ hostx_want_preexisting_window(EphyrScreenInfo screen);
 
 void
-hostx_use_preexisting_window(unsigned long win_id);
+ hostx_use_preexisting_window(unsigned long win_id);
 
 void
-hostx_use_resname (char *name, int fromcmd);
+ hostx_use_resname(char *name, int fromcmd);
 
 void
-hostx_set_title(char *name);
+ hostx_set_title(char *name);
 
-void 
-hostx_handle_signal(int signum);
+void
+ hostx_handle_signal(int signum);
 
 int
-hostx_init(void);
+ hostx_init(void);
 
 void
-hostx_add_screen(EphyrScreenInfo screen, unsigned long win_id, int screen_num);
+ hostx_add_screen(EphyrScreenInfo screen, unsigned long win_id, int screen_num);
 
 void
-hostx_set_display_name(char *name);
+ hostx_set_display_name(char *name);
 
 void
-hostx_set_screen_number(EphyrScreenInfo screen, int number);
+ hostx_set_screen_number(EphyrScreenInfo screen, int number);
 
 void
-hostx_set_win_title(EphyrScreenInfo screen, char *extra_text);
+ hostx_set_win_title(EphyrScreenInfo screen, char *extra_text);
 
 int
-hostx_get_depth (void);
+ hostx_get_depth(void);
 
 int
-hostx_get_server_depth (EphyrScreenInfo screen);
+ hostx_get_server_depth(EphyrScreenInfo screen);
 
 void
-hostx_set_server_depth(EphyrScreenInfo screen, int depth);
+ hostx_set_server_depth(EphyrScreenInfo screen, int depth);
 
 int
-hostx_get_bpp(void *info);
+ hostx_get_bpp(void *info);
 
 void
-hostx_get_visual_masks (void   *info,
-			CARD32 *rmsk, 
-			CARD32 *gmsk, 
-			CARD32 *bmsk);
+ hostx_get_visual_masks(void *info, CARD32 *rmsk, CARD32 *gmsk, CARD32 *bmsk);
 void
-hostx_set_cmap_entry(unsigned char idx, 
-		     unsigned char r, 
-		     unsigned char g, 
-		     unsigned char b);
 
-void*
-hostx_screen_init (EphyrScreenInfo screen,
-                   int width, int height,
-                   int buffer_height);
+hostx_set_cmap_entry(unsigned char idx,
+                     unsigned char r, unsigned char g, unsigned char b);
+
+void *hostx_screen_init(EphyrScreenInfo screen,
+                        int width, int height, int buffer_height);
 
 void
-hostx_paint_rect(EphyrScreenInfo screen,
-		 int sx,    int sy,
-		 int dx,    int dy,
-		 int width, int height);
 
+hostx_paint_rect(EphyrScreenInfo screen,
+                 int sx, int sy, int dx, int dy, int width, int height);
 
 void
-hostx_load_keymap (void);
+ hostx_load_keymap(void);
 
 int
-hostx_get_event (EphyrHostXEvent *ev);
+ hostx_get_event(EphyrHostXEvent * ev);
 
-void*
-hostx_get_display (void) ;
+void *hostx_get_display(void);
 
 int
-hostx_get_window (int a_screen_number) ;
+ hostx_get_window(int a_screen_number);
 
 int
-hostx_get_window_attributes (int a_window, EphyrHostWindowAttributes *a_attr)  ;
+ hostx_get_window_attributes(int a_window, EphyrHostWindowAttributes * a_attr);
 
 int
-hostx_get_extension_info (const char *a_ext_name,
-                          int *a_major_opcode,
-                          int *a_first_even,
-                          int *a_first_error) ;
-int
-hostx_get_visuals_info (EphyrHostVisualInfo **a_visuals,
-                        int *a_num_entries) ;
 
-int hostx_create_window (int a_screen_number,
-                         EphyrBox *a_geometry,
-                         int a_visual_id,
-                         int *a_host_win /*out parameter*/) ;
+hostx_get_extension_info(const char *a_ext_name,
+                         int *a_major_opcode,
+                         int *a_first_even, int *a_first_error);
+int
+ hostx_get_visuals_info(EphyrHostVisualInfo ** a_visuals, int *a_num_entries);
 
-int hostx_destroy_window (int a_win) ;
+int hostx_create_window(int a_screen_number,
+                        EphyrBox * a_geometry,
+                        int a_visual_id, int *a_host_win /*out parameter */ );
 
-int hostx_set_window_geometry (int a_win, EphyrBox *a_geo) ;
+int hostx_destroy_window(int a_win);
 
+int hostx_set_window_geometry(int a_win, EphyrBox * a_geo);
 
-int hostx_set_window_bounding_rectangles (int a_window,
-                                          EphyrRect *a_rects,
-                                          int a_num_rects) ;
+int hostx_set_window_bounding_rectangles(int a_window,
+                                         EphyrRect * a_rects, int a_num_rects);
 
-int hostx_set_window_clipping_rectangles (int a_window,
-                                          EphyrRect *a_rects,
-                                          int a_num_rects) ;
-int hostx_has_xshape (void) ;
+int hostx_set_window_clipping_rectangles(int a_window,
+                                         EphyrRect * a_rects, int a_num_rects);
+int hostx_has_xshape(void);
 
 #ifdef XF86DRI
-int hostx_lookup_peer_window (void *a_local_window,
-                              int *a_host_peer /*out parameter*/) ;
+int hostx_lookup_peer_window(void *a_local_window,
+                             int *a_host_peer /*out parameter */ );
 int
-hostx_allocate_resource_id_peer (int a_local_resource_id,
-                                 int *a_remote_resource_id) ;
+
+hostx_allocate_resource_id_peer(int a_local_resource_id,
+                                int *a_remote_resource_id);
 int
-hostx_get_resource_id_peer (int a_local_resource_id,
-                            int *a_remote_resource_id) ;
-int hostx_has_dri (void) ;
+ hostx_get_resource_id_peer(int a_local_resource_id, int *a_remote_resource_id);
+int hostx_has_dri(void);
 
-int hostx_has_glx (void) ;
-#endif /* XF86DRI */
+int hostx_has_glx(void);
+#endif                          /* XF86DRI */
 
 #endif /*_XLIBS_STUFF_H_*/
diff --git a/hw/kdrive/ephyr/os.c b/hw/kdrive/ephyr/os.c
index e4dc6787d..a2a705dd9 100644
--- a/hw/kdrive/ephyr/os.c
+++ b/hw/kdrive/ephyr/os.c
@@ -28,24 +28,22 @@
 #endif
 #include "ephyr.h"
 
-extern void processScreenArg (char *screen_size, char *parent_id) ;
+extern void processScreenArg(char *screen_size, char *parent_id);
 
 static int
-EphyrInit (void)
+EphyrInit(void)
 {
-  /*
-   * make sure at least one screen
-   * has been added to the system.
-   */
-  if (!KdCardInfoLast ())
-    {
-        processScreenArg ("640x480", NULL) ;
+    /*
+     * make sure at least one screen
+     * has been added to the system.
+     */
+    if (!KdCardInfoLast()) {
+        processScreenArg("640x480", NULL);
     }
-  return hostx_init();
+    return hostx_init();
 }
 
-KdOsFuncs   EphyrOsFuncs = {
+KdOsFuncs EphyrOsFuncs = {
     .Init = EphyrInit,
     .pollEvents = ephyrPoll,
 };
-
diff --git a/hw/kdrive/ephyr/xf86dri.h b/hw/kdrive/ephyr/xf86dri.h
index cd650b582..88d3f3bf1 100644
--- a/hw/kdrive/ephyr/xf86dri.h
+++ b/hw/kdrive/ephyr/xf86dri.h
@@ -54,8 +54,8 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define X_XF86DRIGetDrawableInfo		9
 #define X_XF86DRIGetDeviceInfo			10
 #define X_XF86DRIAuthConnection                 11
-#define X_XF86DRIOpenFullScreen                 12   /* Deprecated */
-#define X_XF86DRICloseFullScreen                13   /* Deprecated */
+#define X_XF86DRIOpenFullScreen                 12      /* Deprecated */
+#define X_XF86DRICloseFullScreen                13      /* Deprecated */
 
 #define XF86DRINumberEvents		0
 
@@ -67,54 +67,58 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 _XFUNCPROTOBEGIN
 
-Bool XF86DRIQueryExtension( Display *dpy, int *event_base, int *error_base );
+Bool XF86DRIQueryExtension(Display * dpy, int *event_base, int *error_base);
 
-Bool XF86DRIQueryVersion( Display *dpy, int *majorVersion, int *minorVersion,
-    int *patchVersion );
+Bool XF86DRIQueryVersion(Display * dpy, int *majorVersion, int *minorVersion,
+                         int *patchVersion);
 
-Bool XF86DRIQueryDirectRenderingCapable( Display *dpy, int screen,
-    Bool *isCapable );
+Bool XF86DRIQueryDirectRenderingCapable(Display * dpy, int screen,
+                                        Bool *isCapable);
 
-Bool XF86DRIOpenConnection( Display *dpy, int screen, drm_handle_t *hSAREA,
-    char **busIDString );
+Bool XF86DRIOpenConnection(Display * dpy, int screen, drm_handle_t * hSAREA,
+                           char **busIDString);
 
-Bool XF86DRIAuthConnection( Display *dpy, int screen, drm_magic_t magic );
+Bool XF86DRIAuthConnection(Display * dpy, int screen, drm_magic_t magic);
 
-Bool XF86DRICloseConnection( Display *dpy, int screen );
+Bool XF86DRICloseConnection(Display * dpy, int screen);
 
-Bool XF86DRIGetClientDriverName( Display *dpy, int screen,
-    int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
-    int *ddxDriverPatchVersion, char **clientDriverName );
+Bool XF86DRIGetClientDriverName(Display * dpy, int screen,
+                                int *ddxDriverMajorVersion,
+                                int *ddxDriverMinorVersion,
+                                int *ddxDriverPatchVersion,
+                                char **clientDriverName);
 
-Bool XF86DRICreateContext( Display *dpy, int screen, Visual *visual,
-    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+Bool XF86DRICreateContext(Display * dpy, int screen, Visual * visual,
+                          XID *ptr_to_returned_context_id,
+                          drm_context_t * hHWContext);
 
-Bool XF86DRICreateContextWithConfig( Display *dpy, int screen, int configID,
-    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+Bool XF86DRICreateContextWithConfig(Display * dpy, int screen, int configID,
+                                    XID *ptr_to_returned_context_id,
+                                    drm_context_t * hHWContext);
 
-extern GLboolean XF86DRIDestroyContext( Display *dpy, int screen,
-    XID context_id );
+extern GLboolean XF86DRIDestroyContext(Display * dpy, int screen,
+                                       XID context_id);
 
-extern GLboolean XF86DRICreateDrawable( Display *dpy, int screen,
-    XID drawable, drm_drawable_t *hHWDrawable );
+extern GLboolean XF86DRICreateDrawable(Display * dpy, int screen,
+                                       XID drawable,
+                                       drm_drawable_t * hHWDrawable);
 
-extern GLboolean XF86DRIDestroyDrawable( Display *dpy, int screen, 
-    XID drawable);
+extern GLboolean XF86DRIDestroyDrawable(Display * dpy, int screen,
+                                        XID drawable);
 
-Bool XF86DRIGetDrawableInfo( Display *dpy, int screen, Drawable drawable,
-    unsigned int *index, unsigned int *stamp, 
-    int *X, int *Y, int *W, int *H,
-    int *numClipRects, drm_clip_rect_t ** pClipRects,
-    int *backX, int *backY,
-    int *numBackClipRects, drm_clip_rect_t **pBackClipRects );
+Bool XF86DRIGetDrawableInfo(Display * dpy, int screen, Drawable drawable,
+                            unsigned int *index, unsigned int *stamp,
+                            int *X, int *Y, int *W, int *H,
+                            int *numClipRects, drm_clip_rect_t ** pClipRects,
+                            int *backX, int *backY,
+                            int *numBackClipRects,
+                            drm_clip_rect_t ** pBackClipRects);
 
-Bool XF86DRIGetDeviceInfo( Display *dpy, int screen,
-    drm_handle_t *hFrameBuffer, int *fbOrigin, int *fbSize,
-    int *fbStride, int *devPrivateSize, void **pDevPrivate );
+Bool XF86DRIGetDeviceInfo(Display * dpy, int screen,
+                          drm_handle_t * hFrameBuffer, int *fbOrigin,
+                          int *fbSize, int *fbStride, int *devPrivateSize,
+                          void **pDevPrivate);
 
 _XFUNCPROTOEND
-
-#endif /* _XF86DRI_SERVER_ */
-
-#endif /* _XF86DRI_H_ */
-
+#endif                          /* _XF86DRI_SERVER_ */
+#endif                          /* _XF86DRI_H_ */
diff --git a/hw/kdrive/fake/fake.c b/hw/kdrive/fake/fake.c
index ba05234dc..90e3ec9a6 100644
--- a/hw/kdrive/fake/fake.c
+++ b/hw/kdrive/fake/fake.c
@@ -28,7 +28,7 @@
 extern int KdTsPhyScreen;
 
 Bool
-fakeInitialize (KdCardInfo *card, FakePriv *priv)
+fakeInitialize(KdCardInfo * card, FakePriv * priv)
 {
     priv->base = 0;
     priv->bytes_per_line = 0;
@@ -36,337 +36,317 @@ fakeInitialize (KdCardInfo *card, FakePriv *priv)
 }
 
 Bool
-fakeCardInit (KdCardInfo *card)
+fakeCardInit(KdCardInfo * card)
 {
-    FakePriv	*priv;
+    FakePriv *priv;
 
-    priv = (FakePriv *) malloc(sizeof (FakePriv));
+    priv = (FakePriv *) malloc(sizeof(FakePriv));
     if (!priv)
-	return FALSE;
-    
-    if (!fakeInitialize (card, priv))
-    {
-	free(priv);
-	return FALSE;
+        return FALSE;
+
+    if (!fakeInitialize(card, priv)) {
+        free(priv);
+        return FALSE;
     }
     card->driver = priv;
-    
+
     return TRUE;
 }
 
 Bool
-fakeScreenInitialize (KdScreenInfo *screen, FakeScrPriv *scrpriv)
+fakeScreenInitialize(KdScreenInfo * screen, FakeScrPriv * scrpriv)
 {
-    if (!screen->width || !screen->height)
-    {
-	screen->width = 1024;
-	screen->height = 768;
-	screen->rate = 72;
+    if (!screen->width || !screen->height) {
+        screen->width = 1024;
+        screen->height = 768;
+        screen->rate = 72;
     }
 
     if (screen->width <= 0)
-	screen->width = 1;
+        screen->width = 1;
     if (screen->height <= 0)
-	screen->height = 1;
-    
+        screen->height = 1;
+
     if (!screen->fb.depth)
-	screen->fb.depth = 16;
-
-    if (screen->fb.depth <= 8)
-    {
-	screen->fb.visuals = ((1 << StaticGray) |
-			      (1 << GrayScale) |
-			      (1 << StaticColor) |
-			      (1 << PseudoColor) |
-			      (1 << TrueColor) |
-			      (1 << DirectColor));
+        screen->fb.depth = 16;
+
+    if (screen->fb.depth <= 8) {
+        screen->fb.visuals = ((1 << StaticGray) |
+                              (1 << GrayScale) |
+                              (1 << StaticColor) |
+                              (1 << PseudoColor) |
+                              (1 << TrueColor) | (1 << DirectColor));
     }
-    else 
-    {
-	screen->fb.visuals = (1 << TrueColor);
+    else {
+        screen->fb.visuals = (1 << TrueColor);
 #define Mask(o,l)   (((1 << l) - 1) << o)
-	if (screen->fb.depth <= 15)
-	{
-	    screen->fb.depth = 15;
-	    screen->fb.bitsPerPixel = 16;
-	    screen->fb.redMask = Mask (10, 5);
-	    screen->fb.greenMask = Mask (5, 5);
-	    screen->fb.blueMask = Mask (0, 5);
-	}
-	else if (screen->fb.depth <= 16)
-	{
-	    screen->fb.depth = 16;
-	    screen->fb.bitsPerPixel = 16;
-	    screen->fb.redMask = Mask (11, 5);
-	    screen->fb.greenMask = Mask (5, 6);
-	    screen->fb.blueMask = Mask (0, 5);
-	}
-	else
-	{
-	    screen->fb.depth = 24;
-	    screen->fb.bitsPerPixel = 32;
-	    screen->fb.redMask = Mask (16, 8);
-	    screen->fb.greenMask = Mask (8, 8);
-	    screen->fb.blueMask = Mask (0, 8);
-	}
+        if (screen->fb.depth <= 15) {
+            screen->fb.depth = 15;
+            screen->fb.bitsPerPixel = 16;
+            screen->fb.redMask = Mask (10, 5);
+            screen->fb.greenMask = Mask (5, 5);
+            screen->fb.blueMask = Mask (0, 5);
+        }
+        else if (screen->fb.depth <= 16) {
+            screen->fb.depth = 16;
+            screen->fb.bitsPerPixel = 16;
+            screen->fb.redMask = Mask (11, 5);
+            screen->fb.greenMask = Mask (5, 6);
+            screen->fb.blueMask = Mask (0, 5);
+        }
+        else {
+            screen->fb.depth = 24;
+            screen->fb.bitsPerPixel = 32;
+            screen->fb.redMask = Mask (16, 8);
+            screen->fb.greenMask = Mask (8, 8);
+            screen->fb.blueMask = Mask (0, 8);
+        }
     }
 
     scrpriv->randr = screen->randr;
 
-    return fakeMapFramebuffer (screen);
+    return fakeMapFramebuffer(screen);
 }
 
 Bool
-fakeScreenInit (KdScreenInfo *screen)
+fakeScreenInit(KdScreenInfo * screen)
 {
     FakeScrPriv *scrpriv;
 
-    scrpriv = calloc(1, sizeof (FakeScrPriv));
+    scrpriv = calloc(1, sizeof(FakeScrPriv));
     if (!scrpriv)
-	return FALSE;
+        return FALSE;
     screen->driver = scrpriv;
-    if (!fakeScreenInitialize (screen, scrpriv))
-    {
-	screen->driver = 0;
-	free(scrpriv);
-	return FALSE;
+    if (!fakeScreenInitialize(screen, scrpriv)) {
+        screen->driver = 0;
+        free(scrpriv);
+        return FALSE;
     }
     return TRUE;
 }
-    
+
 void *
-fakeWindowLinear (ScreenPtr	pScreen,
-		   CARD32	row,
-		   CARD32	offset,
-		   int		mode,
-		   CARD32	*size,
-		   void		*closure)
+fakeWindowLinear(ScreenPtr pScreen,
+                 CARD32 row,
+                 CARD32 offset, int mode, CARD32 *size, void *closure)
 {
     KdScreenPriv(pScreen);
-    FakePriv	    *priv = pScreenPriv->card->driver;
+    FakePriv *priv = pScreenPriv->card->driver;
 
     if (!pScreenPriv->enabled)
-	return 0;
+        return 0;
     *size = priv->bytes_per_line;
     return priv->base + row * priv->bytes_per_line;
 }
 
 Bool
-fakeMapFramebuffer (KdScreenInfo *screen)
+fakeMapFramebuffer(KdScreenInfo * screen)
 {
-    FakeScrPriv	*scrpriv = screen->driver;
-    KdPointerMatrix	m;
-    FakePriv		*priv = screen->card->driver;
+    FakeScrPriv *scrpriv = screen->driver;
+    KdPointerMatrix m;
+    FakePriv *priv = screen->card->driver;
 
     if (scrpriv->randr != RR_Rotate_0)
-	scrpriv->shadow = TRUE;
+        scrpriv->shadow = TRUE;
     else
-	scrpriv->shadow = FALSE;
-    
-    KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
-    
-    KdSetPointerMatrix (&m);
-    
-    priv->bytes_per_line = ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
+        scrpriv->shadow = FALSE;
+
+    KdComputePointerMatrix(&m, scrpriv->randr, screen->width, screen->height);
+
+    KdSetPointerMatrix(&m);
+
+    priv->bytes_per_line =
+        ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
     free(priv->base);
-    priv->base = malloc (priv->bytes_per_line * screen->height);
-    
-    if (scrpriv->shadow)
-    {
-	if (!KdShadowFbAlloc (screen, scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
-	    return FALSE;
+    priv->base = malloc(priv->bytes_per_line * screen->height);
+
+    if (scrpriv->shadow) {
+        if (!KdShadowFbAlloc
+            (screen, scrpriv->randr & (RR_Rotate_90 | RR_Rotate_270)))
+            return FALSE;
     }
-    else
-    {
+    else {
         screen->fb.byteStride = priv->bytes_per_line;
-        screen->fb.pixelStride = (priv->bytes_per_line * 8/
-				     screen->fb.bitsPerPixel);
+        screen->fb.pixelStride = (priv->bytes_per_line * 8 /
+                                  screen->fb.bitsPerPixel);
         screen->fb.frameBuffer = (CARD8 *) (priv->base);
     }
-    
+
     return TRUE;
 }
 
 void
-fakeSetScreenSizes (ScreenPtr pScreen)
+fakeSetScreenSizes(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    FakeScrPriv	*scrpriv = screen->driver;
-
-    if (scrpriv->randr & (RR_Rotate_0|RR_Rotate_180))
-    {
-	pScreen->width = screen->width;
-	pScreen->height = screen->height;
-	pScreen->mmWidth = screen->width_mm;
-	pScreen->mmHeight = screen->height_mm;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FakeScrPriv *scrpriv = screen->driver;
+
+    if (scrpriv->randr & (RR_Rotate_0 | RR_Rotate_180)) {
+        pScreen->width = screen->width;
+        pScreen->height = screen->height;
+        pScreen->mmWidth = screen->width_mm;
+        pScreen->mmHeight = screen->height_mm;
     }
-    else
-    {
-	pScreen->width = screen->width;
-	pScreen->height = screen->height;
-	pScreen->mmWidth = screen->height_mm;
-	pScreen->mmHeight = screen->width_mm;
+    else {
+        pScreen->width = screen->width;
+        pScreen->height = screen->height;
+        pScreen->mmWidth = screen->height_mm;
+        pScreen->mmHeight = screen->width_mm;
     }
 }
 
 Bool
-fakeUnmapFramebuffer (KdScreenInfo *screen)
+fakeUnmapFramebuffer(KdScreenInfo * screen)
 {
-    FakePriv		*priv = screen->card->driver;
-    KdShadowFbFree (screen);
+    FakePriv *priv = screen->card->driver;
+
+    KdShadowFbFree(screen);
     free(priv->base);
     priv->base = NULL;
     return TRUE;
 }
 
 Bool
-fakeSetShadow (ScreenPtr pScreen)
+fakeSetShadow(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    FakeScrPriv	*scrpriv = screen->driver;
-    ShadowUpdateProc	update;
-    ShadowWindowProc	window;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FakeScrPriv *scrpriv = screen->driver;
+    ShadowUpdateProc update;
+    ShadowWindowProc window;
 
     window = fakeWindowLinear;
     update = 0;
     if (scrpriv->randr)
-	update = shadowUpdateRotatePacked;
+        update = shadowUpdateRotatePacked;
     else
-	update = shadowUpdatePacked;
-    return KdShadowSet (pScreen, scrpriv->randr, update, window);
+        update = shadowUpdatePacked;
+    return KdShadowSet(pScreen, scrpriv->randr, update, window);
 }
 
-
 #ifdef RANDR
 Bool
-fakeRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
+fakeRandRGetInfo(ScreenPtr pScreen, Rotation * rotations)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	    *screen = pScreenPriv->screen;
-    FakeScrPriv	    *scrpriv = screen->driver;
-    RRScreenSizePtr	    pSize;
-    Rotation		    randr;
-    int			    n;
-    
-    *rotations = RR_Rotate_All|RR_Reflect_All;
-    
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FakeScrPriv *scrpriv = screen->driver;
+    RRScreenSizePtr pSize;
+    Rotation randr;
+    int n;
+
+    *rotations = RR_Rotate_All | RR_Reflect_All;
+
     for (n = 0; n < pScreen->numDepths; n++)
-	if (pScreen->allowedDepths[n].numVids)
-	    break;
+        if (pScreen->allowedDepths[n].numVids)
+            break;
     if (n == pScreen->numDepths)
-	return FALSE;
-    
-    pSize = RRRegisterSize (pScreen,
-			    screen->width,
-			    screen->height,
-			    screen->width_mm,
-			    screen->height_mm);
-    
-    randr = KdSubRotation (scrpriv->randr, screen->randr);
-    
-    RRSetCurrentConfig (pScreen, randr, 0, pSize);
-    
+        return FALSE;
+
+    pSize = RRRegisterSize(pScreen,
+                           screen->width,
+                           screen->height, screen->width_mm, screen->height_mm);
+
+    randr = KdSubRotation(scrpriv->randr, screen->randr);
+
+    RRSetCurrentConfig(pScreen, randr, 0, pSize);
+
     return TRUE;
 }
 
 Bool
-fakeRandRSetConfig (ScreenPtr		pScreen,
-		     Rotation		randr,
-		     int		rate,
-		     RRScreenSizePtr	pSize)
+fakeRandRSetConfig(ScreenPtr pScreen,
+                   Rotation randr, int rate, RRScreenSizePtr pSize)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    FakeScrPriv	*scrpriv = screen->driver;
-    Bool		wasEnabled = pScreenPriv->enabled;
-    FakeScrPriv	oldscr;
-    int			oldwidth;
-    int			oldheight;
-    int			oldmmwidth;
-    int			oldmmheight;
-    int			newwidth, newheight;
-
-    if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
-    {
-	newwidth = pSize->width;
-	newheight = pSize->height;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FakeScrPriv *scrpriv = screen->driver;
+    Bool wasEnabled = pScreenPriv->enabled;
+    FakeScrPriv oldscr;
+    int oldwidth;
+    int oldheight;
+    int oldmmwidth;
+    int oldmmheight;
+    int newwidth, newheight;
+
+    if (screen->randr & (RR_Rotate_0 | RR_Rotate_180)) {
+        newwidth = pSize->width;
+        newheight = pSize->height;
     }
-    else
-    {
-	newwidth = pSize->height;
-	newheight = pSize->width;
+    else {
+        newwidth = pSize->height;
+        newheight = pSize->width;
     }
 
     if (wasEnabled)
-	KdDisableScreen (pScreen);
+        KdDisableScreen(pScreen);
 
     oldscr = *scrpriv;
-    
+
     oldwidth = screen->width;
     oldheight = screen->height;
     oldmmwidth = pScreen->mmWidth;
     oldmmheight = pScreen->mmHeight;
-    
+
     /*
      * Set new configuration
      */
-    
-    scrpriv->randr = KdAddRotation (screen->randr, randr);
 
-    fakeUnmapFramebuffer (screen);
-    
-    if (!fakeMapFramebuffer (screen))
-	goto bail4;
+    scrpriv->randr = KdAddRotation(screen->randr, randr);
+
+    fakeUnmapFramebuffer(screen);
+
+    if (!fakeMapFramebuffer(screen))
+        goto bail4;
 
-    KdShadowUnset (screen->pScreen);
+    KdShadowUnset(screen->pScreen);
 
-    if (!fakeSetShadow (screen->pScreen))
-	goto bail4;
+    if (!fakeSetShadow(screen->pScreen))
+        goto bail4;
 
-    fakeSetScreenSizes (screen->pScreen);
+    fakeSetScreenSizes(screen->pScreen);
 
     /*
      * Set frame buffer mapping
      */
-    (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
-				    pScreen->width,
-				    pScreen->height,
-				    screen->fb.depth,
-				    screen->fb.bitsPerPixel,
-				    screen->fb.byteStride,
-				    screen->fb.frameBuffer);
-    
+    (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap(pScreen),
+                                    pScreen->width,
+                                    pScreen->height,
+                                    screen->fb.depth,
+                                    screen->fb.bitsPerPixel,
+                                    screen->fb.byteStride,
+                                    screen->fb.frameBuffer);
+
     /* set the subpixel order */
-    
-    KdSetSubpixelOrder (pScreen, scrpriv->randr);
+
+    KdSetSubpixelOrder(pScreen, scrpriv->randr);
     if (wasEnabled)
-	KdEnableScreen (pScreen);
+        KdEnableScreen(pScreen);
 
     return TRUE;
 
-bail4:
-    fakeUnmapFramebuffer (screen);
+ bail4:
+    fakeUnmapFramebuffer(screen);
     *scrpriv = oldscr;
-    (void) fakeMapFramebuffer (screen);
+    (void) fakeMapFramebuffer(screen);
     pScreen->width = oldwidth;
     pScreen->height = oldheight;
     pScreen->mmWidth = oldmmwidth;
     pScreen->mmHeight = oldmmheight;
-    
+
     if (wasEnabled)
-	KdEnableScreen (pScreen);
+        KdEnableScreen(pScreen);
     return FALSE;
 }
 
 Bool
-fakeRandRInit (ScreenPtr pScreen)
+fakeRandRInit(ScreenPtr pScreen)
 {
-    rrScrPrivPtr    pScrPriv;
-    
-    if (!RRScreenInit (pScreen))
-	return FALSE;
+    rrScrPrivPtr pScrPriv;
+
+    if (!RRScreenInit(pScreen))
+        return FALSE;
 
     pScrPriv = rrGetScrPriv(pScreen);
     pScrPriv->rrGetInfo = fakeRandRGetInfo;
@@ -376,13 +356,13 @@ fakeRandRInit (ScreenPtr pScreen)
 #endif
 
 Bool
-fakeCreateColormap (ColormapPtr pmap)
+fakeCreateColormap(ColormapPtr pmap)
 {
-    return fbInitializeColormap (pmap);
+    return fbInitializeColormap(pmap);
 }
 
 Bool
-fakeInitScreen (ScreenPtr pScreen)
+fakeInitScreen(ScreenPtr pScreen)
 {
 #ifdef TOUCHSCREEN
     KdTsPhyScreen = pScreen->myNum;
@@ -393,80 +373,78 @@ fakeInitScreen (ScreenPtr pScreen)
 }
 
 Bool
-fakeFinishInitScreen (ScreenPtr pScreen)
+fakeFinishInitScreen(ScreenPtr pScreen)
 {
-    if (!shadowSetup (pScreen))
-	return FALSE;
+    if (!shadowSetup(pScreen))
+        return FALSE;
 
 #ifdef RANDR
-    if (!fakeRandRInit (pScreen))
-	return FALSE;
+    if (!fakeRandRInit(pScreen))
+        return FALSE;
 #endif
-    
+
     return TRUE;
 }
 
-
 Bool
-fakeCreateResources (ScreenPtr pScreen)
+fakeCreateResources(ScreenPtr pScreen)
 {
-    return fakeSetShadow (pScreen);
+    return fakeSetShadow(pScreen);
 }
 
 void
-fakePreserve (KdCardInfo *card)
+fakePreserve(KdCardInfo * card)
 {
 }
 
 Bool
-fakeEnable (ScreenPtr pScreen)
+fakeEnable(ScreenPtr pScreen)
 {
     return TRUE;
 }
 
 Bool
-fakeDPMS (ScreenPtr pScreen, int mode)
+fakeDPMS(ScreenPtr pScreen, int mode)
 {
     return TRUE;
 }
 
 void
-fakeDisable (ScreenPtr pScreen)
+fakeDisable(ScreenPtr pScreen)
 {
 }
 
 void
-fakeRestore (KdCardInfo *card)
+fakeRestore(KdCardInfo * card)
 {
 }
 
 void
-fakeScreenFini (KdScreenInfo *screen)
+fakeScreenFini(KdScreenInfo * screen)
 {
 }
 
 void
-fakeCardFini (KdCardInfo *card)
+fakeCardFini(KdCardInfo * card)
 {
-    FakePriv	*priv = card->driver;
+    FakePriv *priv = card->driver;
 
-    free (priv->base);
+    free(priv->base);
     free(priv);
 }
 
 void
-fakeGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+fakeGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
 {
-    while (n--)
-    {
-	pdefs->red = 0;
-	pdefs->green = 0;
-	pdefs->blue = 0;
-	pdefs++;
+    while (n--) {
+        pdefs->red = 0;
+        pdefs->green = 0;
+        pdefs->blue = 0;
+        pdefs++;
     }
 }
 
 void
-fakePutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+fakePutColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
 {
 }
diff --git a/hw/kdrive/fake/fake.h b/hw/kdrive/fake/fake.h
index d5058606a..ae33fc6d0 100644
--- a/hw/kdrive/fake/fake.h
+++ b/hw/kdrive/fake/fake.h
@@ -31,106 +31,101 @@
 #endif
 
 typedef struct _fakePriv {
-    CARD8	*base;
-    int		bytes_per_line;
+    CARD8 *base;
+    int bytes_per_line;
 } FakePriv;
-    
+
 typedef struct _fakeScrPriv {
-    Rotation	randr;
-    Bool	shadow;
+    Rotation randr;
+    Bool shadow;
 } FakeScrPriv;
 
-extern KdCardFuncs  fakeFuncs;
+extern KdCardFuncs fakeFuncs;
 
 Bool
-fakeInitialize (KdCardInfo *card, FakePriv *priv);
+ fakeInitialize(KdCardInfo * card, FakePriv * priv);
 
 Bool
-fakeCardInit (KdCardInfo *card);
+ fakeCardInit(KdCardInfo * card);
 
 Bool
-fakeScreenInit (KdScreenInfo *screen);
+ fakeScreenInit(KdScreenInfo * screen);
 
 Bool
-fakeScreenInitialize (KdScreenInfo *screen, FakeScrPriv *scrpriv);
-    
+ fakeScreenInitialize(KdScreenInfo * screen, FakeScrPriv * scrpriv);
+
 Bool
-fakeInitScreen (ScreenPtr pScreen);
+ fakeInitScreen(ScreenPtr pScreen);
 
 Bool
-fakeFinishInitScreen (ScreenPtr pScreen);
+ fakeFinishInitScreen(ScreenPtr pScreen);
 
 Bool
-fakeCreateResources (ScreenPtr pScreen);
+ fakeCreateResources(ScreenPtr pScreen);
 
 void
-fakePreserve (KdCardInfo *card);
+ fakePreserve(KdCardInfo * card);
 
 Bool
-fakeEnable (ScreenPtr pScreen);
+ fakeEnable(ScreenPtr pScreen);
 
 Bool
-fakeDPMS (ScreenPtr pScreen, int mode);
+ fakeDPMS(ScreenPtr pScreen, int mode);
 
 void
-fakeDisable (ScreenPtr pScreen);
+ fakeDisable(ScreenPtr pScreen);
 
 void
-fakeRestore (KdCardInfo *card);
+ fakeRestore(KdCardInfo * card);
 
 void
-fakeScreenFini (KdScreenInfo *screen);
+ fakeScreenFini(KdScreenInfo * screen);
 
 void
-fakeCardFini (KdCardInfo *card);
+ fakeCardFini(KdCardInfo * card);
 
 void
-fakeGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+ fakeGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
 
 void
-fakePutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+ fakePutColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
 
 Bool
-fakeMapFramebuffer (KdScreenInfo *screen);
+ fakeMapFramebuffer(KdScreenInfo * screen);
 
-void *
-fakeWindowLinear (ScreenPtr	pScreen,
-		   CARD32	row,
-		   CARD32	offset,
-		   int		mode,
-		   CARD32	*size,
-		   void		*closure);
+void *fakeWindowLinear(ScreenPtr pScreen,
+                       CARD32 row,
+                       CARD32 offset, int mode, CARD32 *size, void *closure);
 
 void
-fakeSetScreenSizes (ScreenPtr pScreen);
+ fakeSetScreenSizes(ScreenPtr pScreen);
 
 Bool
-fakeUnmapFramebuffer (KdScreenInfo *screen);
+ fakeUnmapFramebuffer(KdScreenInfo * screen);
 
 Bool
-fakeSetShadow (ScreenPtr pScreen);
+ fakeSetShadow(ScreenPtr pScreen);
 
 Bool
-fakeCreateColormap (ColormapPtr pmap);
-    
+ fakeCreateColormap(ColormapPtr pmap);
+
 #ifdef RANDR
 Bool
-fakeRandRGetInfo (ScreenPtr pScreen, Rotation *rotations);
+ fakeRandRGetInfo(ScreenPtr pScreen, Rotation * rotations);
 
 Bool
-fakeRandRSetConfig (ScreenPtr		pScreen,
-		     Rotation		randr,
-		     int		rate,
-		     RRScreenSizePtr	pSize);
+
+fakeRandRSetConfig(ScreenPtr pScreen,
+                   Rotation randr, int rate, RRScreenSizePtr pSize);
 Bool
-fakeRandRInit (ScreenPtr pScreen);
+ fakeRandRInit(ScreenPtr pScreen);
 
 #endif
 
 extern KdPointerDriver FakePointerDriver;
 
-extern KdKeyboardDriver	FakeKeyboardDriver;
+extern KdKeyboardDriver FakeKeyboardDriver;
 
-extern KdOsFuncs   FakeOsFuncs;
+extern KdOsFuncs FakeOsFuncs;
 
-#endif /* _FBDEV_H_ */
+#endif                          /* _FBDEV_H_ */
diff --git a/hw/kdrive/fake/fakeinit.c b/hw/kdrive/fake/fakeinit.c
index e25093fbf..0aae1ddc1 100644
--- a/hw/kdrive/fake/fakeinit.c
+++ b/hw/kdrive/fake/fakeinit.c
@@ -26,94 +26,94 @@
 #include "fake.h"
 
 void
-InitCard (char *name)
+InitCard(char *name)
 {
-    KdCardInfoAdd (&fakeFuncs, 0);
+    KdCardInfoAdd(&fakeFuncs, 0);
 }
 
 void
-InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
+InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
 {
-    KdInitOutput (pScreenInfo, argc, argv);
+    KdInitOutput(pScreenInfo, argc, argv);
 }
 
 void
-InitInput (int argc, char **argv)
+InitInput(int argc, char **argv)
 {
     KdPointerInfo *pi;
     KdKeyboardInfo *ki;
 
-    pi = KdNewPointer ();
+    pi = KdNewPointer();
     if (!pi)
         return;
     pi->driver = &FakePointerDriver;
     KdAddPointer(pi);
 
-    ki = KdNewKeyboard ();
+    ki = KdNewKeyboard();
     if (!ki)
         return;
     ki->driver = &FakeKeyboardDriver;
     KdAddKeyboard(ki);
 
-    KdInitInput ();
+    KdInitInput();
 }
 
 void
-CloseInput (void)
+CloseInput(void)
 {
-    KdCloseInput ();
+    KdCloseInput();
 }
 
 #ifdef DDXBEFORERESET
 void
-ddxBeforeReset (void)
+ddxBeforeReset(void)
 {
 }
 #endif
 
 void
-ddxUseMsg (void)
+ddxUseMsg(void)
 {
     KdUseMsg();
 }
 
 int
-ddxProcessArgument (int argc, char **argv, int i)
+ddxProcessArgument(int argc, char **argv, int i)
 {
-    return KdProcessArgument (argc, argv, i);
+    return KdProcessArgument(argc, argv, i);
 }
 
 void
-OsVendorInit (void)
+OsVendorInit(void)
 {
-    KdOsInit (&FakeOsFuncs);
+    KdOsInit(&FakeOsFuncs);
 }
 
-KdCardFuncs	fakeFuncs = {
-    fakeCardInit,	    /* cardinit */
-    fakeScreenInit,	    /* scrinit */
-    fakeInitScreen,	    /* initScreen */
-    fakeFinishInitScreen,  /* finishInitScreen */
-    fakeCreateResources,   /* createRes */
-    fakePreserve,	    /* preserve */
-    fakeEnable,	    /* enable */
-    fakeDPMS,		    /* dpms */
-    fakeDisable,	    /* disable */
-    fakeRestore,	    /* restore */
-    fakeScreenFini,	    /* scrfini */
-    fakeCardFini,	    /* cardfini */
-    
-    0,			    /* initCursor */
-    0,			    /* enableCursor */
-    0,			    /* disableCursor */
-    0,			    /* finiCursor */
-    0,			    /* recolorCursor */
-    
-    0,			    /* initAccel */
-    0,			    /* enableAccel */
-    0,			    /* disableAccel */
-    0,			    /* finiAccel */
-    
-    fakeGetColors,    	    /* getColors */
-    fakePutColors,	    /* putColors */
+KdCardFuncs fakeFuncs = {
+    fakeCardInit,               /* cardinit */
+    fakeScreenInit,             /* scrinit */
+    fakeInitScreen,             /* initScreen */
+    fakeFinishInitScreen,       /* finishInitScreen */
+    fakeCreateResources,        /* createRes */
+    fakePreserve,               /* preserve */
+    fakeEnable,                 /* enable */
+    fakeDPMS,                   /* dpms */
+    fakeDisable,                /* disable */
+    fakeRestore,                /* restore */
+    fakeScreenFini,             /* scrfini */
+    fakeCardFini,               /* cardfini */
+
+    0,                          /* initCursor */
+    0,                          /* enableCursor */
+    0,                          /* disableCursor */
+    0,                          /* finiCursor */
+    0,                          /* recolorCursor */
+
+    0,                          /* initAccel */
+    0,                          /* enableAccel */
+    0,                          /* disableAccel */
+    0,                          /* finiAccel */
+
+    fakeGetColors,              /* getColors */
+    fakePutColors,              /* putColors */
 };
diff --git a/hw/kdrive/fake/kbd.c b/hw/kdrive/fake/kbd.c
index 769730d64..83a3c66cf 100644
--- a/hw/kdrive/fake/kbd.c
+++ b/hw/kdrive/fake/kbd.c
@@ -29,7 +29,7 @@
 #define FAKE_WIDTH  2
 
 static Status
-FakeKeyboardInit (KdKeyboardInfo *ki)
+FakeKeyboardInit(KdKeyboardInfo * ki)
 {
     ki->minScanCode = 8;
     ki->maxScanCode = 255;
@@ -37,29 +37,29 @@ FakeKeyboardInit (KdKeyboardInfo *ki)
 }
 
 static Status
-FakeKeyboardEnable (KdKeyboardInfo *ki)
+FakeKeyboardEnable(KdKeyboardInfo * ki)
 {
     return Success;
 }
 
 static void
-FakeKeyboardDisable (KdKeyboardInfo *ki)
+FakeKeyboardDisable(KdKeyboardInfo * ki)
 {
     return;
 }
 
 static void
-FakeKeyboardFini (KdKeyboardInfo *ki)
+FakeKeyboardFini(KdKeyboardInfo * ki)
 {
 }
 
 static void
-FakeKeyboardLeds (KdKeyboardInfo *ki, int leds)
+FakeKeyboardLeds(KdKeyboardInfo * ki, int leds)
 {
 }
 
 static void
-FakeKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
+FakeKeyboardBell(KdKeyboardInfo * ki, int volume, int frequency, int duration)
 {
 }
 
diff --git a/hw/kdrive/fake/mouse.c b/hw/kdrive/fake/mouse.c
index 758f6cd22..bb4c25eeb 100644
--- a/hw/kdrive/fake/mouse.c
+++ b/hw/kdrive/fake/mouse.c
@@ -33,30 +33,29 @@
 #include "kdrive.h"
 
 static Status
-MouseInit (KdPointerInfo *pi)
+MouseInit(KdPointerInfo * pi)
 {
     return Success;
 }
 
 static Status
-MouseEnable (KdPointerInfo *pi)
+MouseEnable(KdPointerInfo * pi)
 {
     return Success;
 }
 
 static void
-MouseDisable (KdPointerInfo *pi)
+MouseDisable(KdPointerInfo * pi)
 {
     return;
 }
 
 static void
-MouseFini (KdPointerInfo *pi)
+MouseFini(KdPointerInfo * pi)
 {
     return;
 }
 
-
 KdPointerDriver FakePointerDriver = {
     "fake",
     MouseInit,
diff --git a/hw/kdrive/fake/os.c b/hw/kdrive/fake/os.c
index 76cd9e728..01bb37bd5 100644
--- a/hw/kdrive/fake/os.c
+++ b/hw/kdrive/fake/os.c
@@ -26,33 +26,33 @@
 #include "fake.h"
 
 static int
-FakeInit (void)
+FakeInit(void)
 {
     return 1;
 }
 
 static void
-FakeEnable (void)
+FakeEnable(void)
 {
 }
 
 static Bool
-FakeSpecialKey (KeySym sym)
+FakeSpecialKey(KeySym sym)
 {
     return FALSE;
 }
 
 static void
-FakeDisable (void)
+FakeDisable(void)
 {
 }
 
 static void
-FakeFini (void)
+FakeFini(void)
 {
 }
 
-KdOsFuncs   FakeOsFuncs = {
+KdOsFuncs FakeOsFuncs = {
     FakeInit,
     FakeEnable,
     FakeSpecialKey,
@@ -60,4 +60,3 @@ KdOsFuncs   FakeOsFuncs = {
     FakeFini,
     0
 };
-
diff --git a/hw/kdrive/fbdev/fbdev.c b/hw/kdrive/fbdev/fbdev.c
index 661e5b491..fd14afa92 100644
--- a/hw/kdrive/fbdev/fbdev.c
+++ b/hw/kdrive/fbdev/fbdev.c
@@ -33,46 +33,43 @@ extern int KdTsPhyScreen;
 char *fbdevDevicePath = NULL;
 
 static Bool
-fbdevInitialize (KdCardInfo *card, FbdevPriv *priv)
+fbdevInitialize(KdCardInfo * card, FbdevPriv * priv)
 {
-    unsigned long   off;
+    unsigned long off;
 
     if (fbdevDevicePath == NULL)
-      fbdevDevicePath = "/dev/fb0";
+        fbdevDevicePath = "/dev/fb0";
 
-    if ((priv->fd = open(fbdevDevicePath, O_RDWR)) < 0)
-      {
-	ErrorF("Error opening framebuffer %s: %s\n",
-	       fbdevDevicePath, strerror(errno));
+    if ((priv->fd = open(fbdevDevicePath, O_RDWR)) < 0) {
+        ErrorF("Error opening framebuffer %s: %s\n",
+               fbdevDevicePath, strerror(errno));
         return FALSE;
-      }
+    }
 
     /* quiet valgrind */
-    memset (&priv->fix, '\0', sizeof (priv->fix));
+    memset(&priv->fix, '\0', sizeof(priv->fix));
     if (ioctl(priv->fd, FBIOGET_FSCREENINFO, &priv->fix) < 0) {
-	perror("Error with /dev/fb ioctl FIOGET_FSCREENINFO");
-	close (priv->fd);
-	return FALSE;
+        perror("Error with /dev/fb ioctl FIOGET_FSCREENINFO");
+        close(priv->fd);
+        return FALSE;
     }
     /* quiet valgrind */
-    memset (&priv->var, '\0', sizeof (priv->var));
+    memset(&priv->var, '\0', sizeof(priv->var));
     if (ioctl(priv->fd, FBIOGET_VSCREENINFO, &priv->var) < 0) {
-	perror("Error with /dev/fb ioctl FIOGET_VSCREENINFO");
-	close (priv->fd);
-	return FALSE;
+        perror("Error with /dev/fb ioctl FIOGET_VSCREENINFO");
+        close(priv->fd);
+        return FALSE;
     }
 
-    priv->fb_base = (char *) mmap ((caddr_t) NULL,
-				   priv->fix.smem_len,
-				   PROT_READ|PROT_WRITE,
-				   MAP_SHARED,
-				   priv->fd, 0);
+    priv->fb_base = (char *) mmap((caddr_t) NULL,
+                                  priv->fix.smem_len,
+                                  PROT_READ | PROT_WRITE,
+                                  MAP_SHARED, priv->fd, 0);
 
-    if (priv->fb_base == (char *)-1)
-    {
+    if (priv->fb_base == (char *) -1) {
         perror("ERROR: mmap framebuffer fails!");
-	close (priv->fd);
-	return FALSE;
+        close(priv->fd);
+        return FALSE;
     }
     off = (unsigned long) priv->fix.smem_start % (unsigned long) getpagesize();
     priv->fb = priv->fb_base + off;
@@ -80,18 +77,17 @@ fbdevInitialize (KdCardInfo *card, FbdevPriv *priv)
 }
 
 Bool
-fbdevCardInit (KdCardInfo *card)
+fbdevCardInit(KdCardInfo * card)
 {
-    FbdevPriv	*priv;
+    FbdevPriv *priv;
 
-    priv = (FbdevPriv *) malloc(sizeof (FbdevPriv));
+    priv = (FbdevPriv *) malloc(sizeof(FbdevPriv));
     if (!priv)
-	return FALSE;
+        return FALSE;
 
-    if (!fbdevInitialize (card, priv))
-    {
-	free(priv);
-	return FALSE;
+    if (!fbdevInitialize(card, priv)) {
+        free(priv);
+        return FALSE;
     }
     card->driver = priv;
 
@@ -99,30 +95,29 @@ fbdevCardInit (KdCardInfo *card)
 }
 
 static Pixel
-fbdevMakeContig (Pixel orig, Pixel others)
+fbdevMakeContig(Pixel orig, Pixel others)
 {
-    Pixel   low;
+    Pixel low;
 
-    low = lowbit (orig) >> 1;
-    while (low && (others & low) == 0)
-    {
-	orig |= low;
-	low >>= 1;
+    low = lowbit(orig) >> 1;
+    while (low && (others & low) == 0) {
+        orig |= low;
+        low >>= 1;
     }
     return orig;
 }
 
 static Bool
-fbdevModeSupported (KdScreenInfo		*screen,
-		    const KdMonitorTiming	*t)
+fbdevModeSupported(KdScreenInfo * screen, const KdMonitorTiming * t)
 {
     return TRUE;
 }
 
 static void
-fbdevConvertMonitorTiming (const KdMonitorTiming *t, struct fb_var_screeninfo *var)
+fbdevConvertMonitorTiming(const KdMonitorTiming * t,
+                          struct fb_var_screeninfo *var)
 {
-    memset (var, 0, sizeof (struct fb_var_screeninfo));
+    memset(var, 0, sizeof(struct fb_var_screeninfo));
 
     var->xres = t->horizontal;
     var->yres = t->vertical;
@@ -142,56 +137,51 @@ fbdevConvertMonitorTiming (const KdMonitorTiming *t, struct fb_var_screeninfo *v
     var->vmode = 0;
 
     if (t->hpol == KdSyncPositive)
-      var->sync |= FB_SYNC_HOR_HIGH_ACT;
+        var->sync |= FB_SYNC_HOR_HIGH_ACT;
     if (t->vpol == KdSyncPositive)
-      var->sync |= FB_SYNC_VERT_HIGH_ACT;
+        var->sync |= FB_SYNC_VERT_HIGH_ACT;
 }
 
 static Bool
-fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv)
+fbdevScreenInitialize(KdScreenInfo * screen, FbdevScrPriv * scrpriv)
 {
-    FbdevPriv	*priv = screen->card->driver;
-    Pixel	allbits;
-    int		depth;
-    Bool	gray;
+    FbdevPriv *priv = screen->card->driver;
+    Pixel allbits;
+    int depth;
+    Bool gray;
     struct fb_var_screeninfo var;
     const KdMonitorTiming *t;
     int k;
 
-    k = ioctl (priv->fd, FBIOGET_VSCREENINFO, &var);
-
-    if (!screen->width || !screen->height)
-    {
-	if (k >= 0)
-	{
-	    screen->width = var.xres;
-	    screen->height = var.yres;
-	}
-	else
-	{
-	    screen->width = 1024;
-	    screen->height = 768;
-	}
-	screen->rate = 103; /* FIXME: should get proper value from fb driver */
+    k = ioctl(priv->fd, FBIOGET_VSCREENINFO, &var);
+
+    if (!screen->width || !screen->height) {
+        if (k >= 0) {
+            screen->width = var.xres;
+            screen->height = var.yres;
+        }
+        else {
+            screen->width = 1024;
+            screen->height = 768;
+        }
+        screen->rate = 103;     /* FIXME: should get proper value from fb driver */
     }
-    if (!screen->fb.depth)
-    {
-	if (k >= 0)
-	    screen->fb.depth = var.bits_per_pixel;
-	else
-	    screen->fb.depth = 16;
+    if (!screen->fb.depth) {
+        if (k >= 0)
+            screen->fb.depth = var.bits_per_pixel;
+        else
+            screen->fb.depth = 16;
     }
 
-    if ((screen->width != var.xres) || (screen->height != var.yres))
-    {
-      t = KdFindMode (screen, fbdevModeSupported);
-      screen->rate = t->rate;
-      screen->width = t->horizontal;
-      screen->height = t->vertical;
+    if ((screen->width != var.xres) || (screen->height != var.yres)) {
+        t = KdFindMode(screen, fbdevModeSupported);
+        screen->rate = t->rate;
+        screen->width = t->horizontal;
+        screen->height = t->vertical;
 
-      /* Now try setting the mode */
-      if (k < 0 || (t->horizontal != var.xres || t->vertical != var.yres))
-          fbdevConvertMonitorTiming (t, &var);
+        /* Now try setting the mode */
+        if (k < 0 || (t->horizontal != var.xres || t->vertical != var.yres))
+            fbdevConvertMonitorTiming(t, &var);
     }
 
     var.activate = FB_ACTIVATE_NOW;
@@ -199,163 +189,154 @@ fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv)
     var.nonstd = 0;
     var.grayscale = 0;
 
-    k = ioctl (priv->fd, FBIOPUT_VSCREENINFO, &var);
+    k = ioctl(priv->fd, FBIOPUT_VSCREENINFO, &var);
 
-    if (k < 0)
-    {
-	fprintf (stderr, "error: %s\n", strerror (errno));
-	return FALSE;
+    if (k < 0) {
+        fprintf(stderr, "error: %s\n", strerror(errno));
+        return FALSE;
     }
 
     /* Re-get the "fixed" parameters since they might have changed */
-    k = ioctl (priv->fd, FBIOGET_FSCREENINFO, &priv->fix);
+    k = ioctl(priv->fd, FBIOGET_FSCREENINFO, &priv->fix);
     if (k < 0)
-        perror ("FBIOGET_FSCREENINFO");
+        perror("FBIOGET_FSCREENINFO");
 
     /* Now get the new screeninfo */
-    ioctl (priv->fd, FBIOGET_VSCREENINFO, &priv->var);
+    ioctl(priv->fd, FBIOGET_VSCREENINFO, &priv->var);
     depth = priv->var.bits_per_pixel;
     gray = priv->var.grayscale;
 
     switch (priv->fix.visual) {
     case FB_VISUAL_PSEUDOCOLOR:
-	if (gray)
-	{
-	    screen->fb.visuals = (1 << StaticGray);
-	    /* could also support GrayScale, but what's the point? */
-	}
-	else
-	{
-	    screen->fb.visuals = ((1 << StaticGray) |
-			       (1 << GrayScale) |
-			       (1 << StaticColor) |
-			       (1 << PseudoColor) |
-			       (1 << TrueColor) |
-			       (1 << DirectColor));
-	}
-	screen->fb.blueMask  = 0x00;
-	screen->fb.greenMask = 0x00;
-	screen->fb.redMask   = 0x00;
-	break;
+        if (gray) {
+            screen->fb.visuals = (1 << StaticGray);
+            /* could also support GrayScale, but what's the point? */
+        }
+        else {
+            screen->fb.visuals = ((1 << StaticGray) |
+                                  (1 << GrayScale) |
+                                  (1 << StaticColor) |
+                                  (1 << PseudoColor) |
+                                  (1 << TrueColor) | (1 << DirectColor));
+        }
+        screen->fb.blueMask = 0x00;
+        screen->fb.greenMask = 0x00;
+        screen->fb.redMask = 0x00;
+        break;
     case FB_VISUAL_STATIC_PSEUDOCOLOR:
-	if (gray)
-	{
-	    screen->fb.visuals = (1 << StaticGray);
-	}
-	else
-	{
-	    screen->fb.visuals = (1 << StaticColor);
-	}
-	screen->fb.blueMask  = 0x00;
-	screen->fb.greenMask = 0x00;
-	screen->fb.redMask   = 0x00;
-	break;
+        if (gray) {
+            screen->fb.visuals = (1 << StaticGray);
+        }
+        else {
+            screen->fb.visuals = (1 << StaticColor);
+        }
+        screen->fb.blueMask = 0x00;
+        screen->fb.greenMask = 0x00;
+        screen->fb.redMask = 0x00;
+        break;
     case FB_VISUAL_TRUECOLOR:
     case FB_VISUAL_DIRECTCOLOR:
-	screen->fb.visuals = (1 << TrueColor);
+        screen->fb.visuals = (1 << TrueColor);
 #define Mask(o,l)   (((1 << l) - 1) << o)
-	screen->fb.redMask = Mask (priv->var.red.offset, priv->var.red.length);
-	screen->fb.greenMask = Mask (priv->var.green.offset, priv->var.green.length);
-	screen->fb.blueMask = Mask (priv->var.blue.offset, priv->var.blue.length);
-
-	/*
-	 * This is a kludge so that Render will work -- fill in the gaps
-	 * in the pixel
-	 */
-	screen->fb.redMask = fbdevMakeContig (screen->fb.redMask,
-						 screen->fb.greenMask|
-						 screen->fb.blueMask);
-
-	screen->fb.greenMask = fbdevMakeContig (screen->fb.greenMask,
-						   screen->fb.redMask|
-						   screen->fb.blueMask);
-
-	screen->fb.blueMask = fbdevMakeContig (screen->fb.blueMask,
-						  screen->fb.redMask|
-						  screen->fb.greenMask);
-
-	allbits = screen->fb.redMask | screen->fb.greenMask | screen->fb.blueMask;
-	depth = 32;
-	while (depth && !(allbits & (1 << (depth - 1))))
-	    depth--;
-	break;
+        screen->fb.redMask = Mask (priv->var.red.offset, priv->var.red.length);
+        screen->fb.greenMask =
+            Mask (priv->var.green.offset, priv->var.green.length);
+        screen->fb.blueMask =
+            Mask (priv->var.blue.offset, priv->var.blue.length);
+
+        /*
+         * This is a kludge so that Render will work -- fill in the gaps
+         * in the pixel
+         */
+        screen->fb.redMask = fbdevMakeContig(screen->fb.redMask,
+                                             screen->fb.greenMask |
+                                             screen->fb.blueMask);
+
+        screen->fb.greenMask = fbdevMakeContig(screen->fb.greenMask,
+                                               screen->fb.redMask |
+                                               screen->fb.blueMask);
+
+        screen->fb.blueMask = fbdevMakeContig(screen->fb.blueMask,
+                                              screen->fb.redMask |
+                                              screen->fb.greenMask);
+
+        allbits =
+            screen->fb.redMask | screen->fb.greenMask | screen->fb.blueMask;
+        depth = 32;
+        while (depth && !(allbits & (1 << (depth - 1))))
+            depth--;
+        break;
     default:
-	return FALSE;
-	break;
+        return FALSE;
+        break;
     }
     screen->fb.depth = depth;
     screen->fb.bitsPerPixel = priv->var.bits_per_pixel;
 
     scrpriv->randr = screen->randr;
 
-    return fbdevMapFramebuffer (screen);
+    return fbdevMapFramebuffer(screen);
 }
 
 Bool
-fbdevScreenInit (KdScreenInfo *screen)
+fbdevScreenInit(KdScreenInfo * screen)
 {
     FbdevScrPriv *scrpriv;
 
-    scrpriv = calloc(1, sizeof (FbdevScrPriv));
+    scrpriv = calloc(1, sizeof(FbdevScrPriv));
     if (!scrpriv)
-	return FALSE;
+        return FALSE;
     screen->driver = scrpriv;
-    if (!fbdevScreenInitialize (screen, scrpriv))
-    {
-	screen->driver = 0;
-	free(scrpriv);
-	return FALSE;
+    if (!fbdevScreenInitialize(screen, scrpriv)) {
+        screen->driver = 0;
+        free(scrpriv);
+        return FALSE;
     }
     return TRUE;
 }
 
 static void *
-fbdevWindowLinear (ScreenPtr	pScreen,
-		   CARD32	row,
-		   CARD32	offset,
-		   int		mode,
-		   CARD32	*size,
-		   void		*closure)
+fbdevWindowLinear(ScreenPtr pScreen,
+                  CARD32 row,
+                  CARD32 offset, int mode, CARD32 *size, void *closure)
 {
     KdScreenPriv(pScreen);
-    FbdevPriv	    *priv = pScreenPriv->card->driver;
+    FbdevPriv *priv = pScreenPriv->card->driver;
 
     if (!pScreenPriv->enabled)
-	return 0;
+        return 0;
     *size = priv->fix.line_length;
     return (CARD8 *) priv->fb + row * priv->fix.line_length + offset;
 }
 
 Bool
-fbdevMapFramebuffer (KdScreenInfo *screen)
+fbdevMapFramebuffer(KdScreenInfo * screen)
 {
-    FbdevScrPriv	*scrpriv = screen->driver;
-    KdPointerMatrix	m;
-    FbdevPriv		*priv = screen->card->driver;
+    FbdevScrPriv *scrpriv = screen->driver;
+    KdPointerMatrix m;
+    FbdevPriv *priv = screen->card->driver;
 
     if (scrpriv->randr != RR_Rotate_0)
-	scrpriv->shadow = TRUE;
+        scrpriv->shadow = TRUE;
     else
-	scrpriv->shadow = FALSE;
+        scrpriv->shadow = FALSE;
 
-    KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
+    KdComputePointerMatrix(&m, scrpriv->randr, screen->width, screen->height);
 
-    KdSetPointerMatrix (&m);
+    KdSetPointerMatrix(&m);
 
     screen->width = priv->var.xres;
     screen->height = priv->var.yres;
 
-    if (scrpriv->shadow)
-    {
-	if (!KdShadowFbAlloc (screen,
-			      scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
-	    return FALSE;
+    if (scrpriv->shadow) {
+        if (!KdShadowFbAlloc(screen,
+                             scrpriv->randr & (RR_Rotate_90 | RR_Rotate_270)))
+            return FALSE;
     }
-    else
-    {
+    else {
         screen->fb.byteStride = priv->fix.line_length;
         screen->fb.pixelStride = (priv->fix.line_length * 8 /
-    				 priv->var.bits_per_pixel);
+                                  priv->var.bits_per_pixel);
         screen->fb.frameBuffer = (CARD8 *) (priv->fb);
     }
 
@@ -363,46 +344,44 @@ fbdevMapFramebuffer (KdScreenInfo *screen)
 }
 
 static void
-fbdevSetScreenSizes (ScreenPtr pScreen)
+fbdevSetScreenSizes(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    FbdevScrPriv	*scrpriv = screen->driver;
-    FbdevPriv		*priv = screen->card->driver;
-
-    if (scrpriv->randr & (RR_Rotate_0|RR_Rotate_180))
-    {
-	pScreen->width = priv->var.xres;
-	pScreen->height = priv->var.yres;
-	pScreen->mmWidth = screen->width_mm;
-	pScreen->mmHeight = screen->height_mm;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FbdevScrPriv *scrpriv = screen->driver;
+    FbdevPriv *priv = screen->card->driver;
+
+    if (scrpriv->randr & (RR_Rotate_0 | RR_Rotate_180)) {
+        pScreen->width = priv->var.xres;
+        pScreen->height = priv->var.yres;
+        pScreen->mmWidth = screen->width_mm;
+        pScreen->mmHeight = screen->height_mm;
     }
-    else
-    {
-	pScreen->width = priv->var.yres;
-	pScreen->height = priv->var.xres;
-	pScreen->mmWidth = screen->height_mm;
-	pScreen->mmHeight = screen->width_mm;
+    else {
+        pScreen->width = priv->var.yres;
+        pScreen->height = priv->var.xres;
+        pScreen->mmWidth = screen->height_mm;
+        pScreen->mmHeight = screen->width_mm;
     }
 }
 
 static Bool
-fbdevUnmapFramebuffer (KdScreenInfo *screen)
+fbdevUnmapFramebuffer(KdScreenInfo * screen)
 {
-    KdShadowFbFree (screen);
+    KdShadowFbFree(screen);
     return TRUE;
 }
 
 static Bool
-fbdevSetShadow (ScreenPtr pScreen)
+fbdevSetShadow(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    FbdevScrPriv	*scrpriv = screen->driver;
-    FbdevPriv		*priv = screen->card->driver;
-    ShadowUpdateProc	update;
-    ShadowWindowProc	window;
-    int			useYX = 0;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FbdevScrPriv *scrpriv = screen->driver;
+    FbdevPriv *priv = screen->card->driver;
+    ShadowUpdateProc update;
+    ShadowWindowProc window;
+    int useYX = 0;
 
 #ifdef __arm__
     /* Use variant copy routines that always read left to right in the
@@ -414,97 +393,91 @@ fbdevSetShadow (ScreenPtr pScreen)
     window = fbdevWindowLinear;
     update = 0;
     if (scrpriv->randr)
-	if (priv->var.bits_per_pixel == 16) {
-	    switch (scrpriv->randr) {
-	    case RR_Rotate_90:
-		if (useYX)
-		    update = shadowUpdateRotate16_90YX;
-		else
-		    update =  shadowUpdateRotate16_90;
-		break;
-	    case RR_Rotate_180:
-		update = shadowUpdateRotate16_180;
-		break;
-	    case RR_Rotate_270:
-		if (useYX)
-		    update = shadowUpdateRotate16_270YX;
-		else
-		    update =  shadowUpdateRotate16_270;
-		break;
-	    default:
-		update = shadowUpdateRotate16;
-		break;
-	    }
-	} else
-	    update = shadowUpdateRotatePacked;
+        if (priv->var.bits_per_pixel == 16) {
+            switch (scrpriv->randr) {
+            case RR_Rotate_90:
+                if (useYX)
+                    update = shadowUpdateRotate16_90YX;
+                else
+                    update = shadowUpdateRotate16_90;
+                break;
+            case RR_Rotate_180:
+                update = shadowUpdateRotate16_180;
+                break;
+            case RR_Rotate_270:
+                if (useYX)
+                    update = shadowUpdateRotate16_270YX;
+                else
+                    update = shadowUpdateRotate16_270;
+                break;
+            default:
+                update = shadowUpdateRotate16;
+                break;
+            }
+        }
+        else
+            update = shadowUpdateRotatePacked;
     else
-	update = shadowUpdatePacked;
-    return KdShadowSet (pScreen, scrpriv->randr, update, window);
+        update = shadowUpdatePacked;
+    return KdShadowSet(pScreen, scrpriv->randr, update, window);
 }
 
-
 #ifdef RANDR
 static Bool
-fbdevRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
+fbdevRandRGetInfo(ScreenPtr pScreen, Rotation * rotations)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	    *screen = pScreenPriv->screen;
-    FbdevScrPriv	    *scrpriv = screen->driver;
-    RRScreenSizePtr	    pSize;
-    Rotation		    randr;
-    int			    n;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FbdevScrPriv *scrpriv = screen->driver;
+    RRScreenSizePtr pSize;
+    Rotation randr;
+    int n;
 
-    *rotations = RR_Rotate_All|RR_Reflect_All;
+    *rotations = RR_Rotate_All | RR_Reflect_All;
 
     for (n = 0; n < pScreen->numDepths; n++)
-	if (pScreen->allowedDepths[n].numVids)
-	    break;
+        if (pScreen->allowedDepths[n].numVids)
+            break;
     if (n == pScreen->numDepths)
-	return FALSE;
+        return FALSE;
 
-    pSize = RRRegisterSize (pScreen,
-			    screen->width,
-			    screen->height,
-			    screen->width_mm,
-			    screen->height_mm);
+    pSize = RRRegisterSize(pScreen,
+                           screen->width,
+                           screen->height, screen->width_mm, screen->height_mm);
 
-    randr = KdSubRotation (scrpriv->randr, screen->randr);
+    randr = KdSubRotation(scrpriv->randr, screen->randr);
 
-    RRSetCurrentConfig (pScreen, randr, 0, pSize);
+    RRSetCurrentConfig(pScreen, randr, 0, pSize);
 
     return TRUE;
 }
 
 static Bool
-fbdevRandRSetConfig (ScreenPtr		pScreen,
-		     Rotation		randr,
-		     int		rate,
-		     RRScreenSizePtr	pSize)
+fbdevRandRSetConfig(ScreenPtr pScreen,
+                    Rotation randr, int rate, RRScreenSizePtr pSize)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    FbdevScrPriv	*scrpriv = screen->driver;
-    Bool		wasEnabled = pScreenPriv->enabled;
-    FbdevScrPriv	oldscr;
-    int			oldwidth;
-    int			oldheight;
-    int			oldmmwidth;
-    int			oldmmheight;
-    int			newwidth, newheight;
-
-    if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
-    {
-	newwidth = pSize->width;
-	newheight = pSize->height;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    FbdevScrPriv *scrpriv = screen->driver;
+    Bool wasEnabled = pScreenPriv->enabled;
+    FbdevScrPriv oldscr;
+    int oldwidth;
+    int oldheight;
+    int oldmmwidth;
+    int oldmmheight;
+    int newwidth, newheight;
+
+    if (screen->randr & (RR_Rotate_0 | RR_Rotate_180)) {
+        newwidth = pSize->width;
+        newheight = pSize->height;
     }
-    else
-    {
-	newwidth = pSize->height;
-	newheight = pSize->width;
+    else {
+        newwidth = pSize->height;
+        newheight = pSize->width;
     }
 
     if (wasEnabled)
-	KdDisableScreen (pScreen);
+        KdDisableScreen(pScreen);
 
     oldscr = *scrpriv;
 
@@ -517,60 +490,60 @@ fbdevRandRSetConfig (ScreenPtr		pScreen,
      * Set new configuration
      */
 
-    scrpriv->randr = KdAddRotation (screen->randr, randr);
+    scrpriv->randr = KdAddRotation(screen->randr, randr);
 
-    fbdevUnmapFramebuffer (screen);
+    fbdevUnmapFramebuffer(screen);
 
-    if (!fbdevMapFramebuffer (screen))
-	goto bail4;
+    if (!fbdevMapFramebuffer(screen))
+        goto bail4;
 
-    KdShadowUnset (screen->pScreen);
+    KdShadowUnset(screen->pScreen);
 
-    if (!fbdevSetShadow (screen->pScreen))
-	goto bail4;
+    if (!fbdevSetShadow(screen->pScreen))
+        goto bail4;
 
-    fbdevSetScreenSizes (screen->pScreen);
+    fbdevSetScreenSizes(screen->pScreen);
 
     /*
      * Set frame buffer mapping
      */
-    (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
-				    pScreen->width,
-				    pScreen->height,
-				    screen->fb.depth,
-				    screen->fb.bitsPerPixel,
-				    screen->fb.byteStride,
-				    screen->fb.frameBuffer);
+    (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap(pScreen),
+                                    pScreen->width,
+                                    pScreen->height,
+                                    screen->fb.depth,
+                                    screen->fb.bitsPerPixel,
+                                    screen->fb.byteStride,
+                                    screen->fb.frameBuffer);
 
     /* set the subpixel order */
 
-    KdSetSubpixelOrder (pScreen, scrpriv->randr);
+    KdSetSubpixelOrder(pScreen, scrpriv->randr);
     if (wasEnabled)
-	KdEnableScreen (pScreen);
+        KdEnableScreen(pScreen);
 
     return TRUE;
 
-bail4:
-    fbdevUnmapFramebuffer (screen);
+ bail4:
+    fbdevUnmapFramebuffer(screen);
     *scrpriv = oldscr;
-    (void) fbdevMapFramebuffer (screen);
+    (void) fbdevMapFramebuffer(screen);
     pScreen->width = oldwidth;
     pScreen->height = oldheight;
     pScreen->mmWidth = oldmmwidth;
     pScreen->mmHeight = oldmmheight;
 
     if (wasEnabled)
-	KdEnableScreen (pScreen);
+        KdEnableScreen(pScreen);
     return FALSE;
 }
 
 static Bool
-fbdevRandRInit (ScreenPtr pScreen)
+fbdevRandRInit(ScreenPtr pScreen)
 {
-    rrScrPrivPtr    pScrPriv;
+    rrScrPrivPtr pScrPriv;
 
-    if (!RRScreenInit (pScreen))
-	return FALSE;
+    if (!RRScreenInit(pScreen))
+        return FALSE;
 
     pScrPriv = rrGetScrPriv(pScreen);
     pScrPriv->rrGetInfo = fbdevRandRGetInfo;
@@ -580,41 +553,41 @@ fbdevRandRInit (ScreenPtr pScreen)
 #endif
 
 static Bool
-fbdevCreateColormap (ColormapPtr pmap)
+fbdevCreateColormap(ColormapPtr pmap)
 {
-    ScreenPtr		pScreen = pmap->pScreen;
+    ScreenPtr pScreen = pmap->pScreen;
+
     KdScreenPriv(pScreen);
-    FbdevPriv		*priv = pScreenPriv->card->driver;
-    VisualPtr		pVisual;
-    int			i;
-    int			nent;
-    xColorItem		*pdefs;
+    FbdevPriv *priv = pScreenPriv->card->driver;
+    VisualPtr pVisual;
+    int i;
+    int nent;
+    xColorItem *pdefs;
 
     switch (priv->fix.visual) {
     case FB_VISUAL_STATIC_PSEUDOCOLOR:
-	pVisual = pmap->pVisual;
-	nent = pVisual->ColormapEntries;
-	pdefs = malloc(nent * sizeof (xColorItem));
-	if (!pdefs)
-	    return FALSE;
-	for (i = 0; i < nent; i++)
-	    pdefs[i].pixel = i;
-	fbdevGetColors (pScreen, nent, pdefs);
-	for (i = 0; i < nent; i++)
-	{
-	    pmap->red[i].co.local.red = pdefs[i].red;
-	    pmap->red[i].co.local.green = pdefs[i].green;
-	    pmap->red[i].co.local.blue = pdefs[i].blue;
-	}
-	free(pdefs);
-	return TRUE;
+        pVisual = pmap->pVisual;
+        nent = pVisual->ColormapEntries;
+        pdefs = malloc(nent * sizeof(xColorItem));
+        if (!pdefs)
+            return FALSE;
+        for (i = 0; i < nent; i++)
+            pdefs[i].pixel = i;
+        fbdevGetColors(pScreen, nent, pdefs);
+        for (i = 0; i < nent; i++) {
+            pmap->red[i].co.local.red = pdefs[i].red;
+            pmap->red[i].co.local.green = pdefs[i].green;
+            pmap->red[i].co.local.blue = pdefs[i].blue;
+        }
+        free(pdefs);
+        return TRUE;
     default:
-	return fbInitializeColormap (pmap);
+        return fbInitializeColormap(pmap);
     }
 }
 
 Bool
-fbdevInitScreen (ScreenPtr pScreen)
+fbdevInitScreen(ScreenPtr pScreen)
 {
 #ifdef TOUCHSCREEN
     KdTsPhyScreen = pScreen->myNum;
@@ -625,33 +598,32 @@ fbdevInitScreen (ScreenPtr pScreen)
 }
 
 Bool
-fbdevFinishInitScreen (ScreenPtr pScreen)
+fbdevFinishInitScreen(ScreenPtr pScreen)
 {
-    if (!shadowSetup (pScreen))
-	return FALSE;
+    if (!shadowSetup(pScreen))
+        return FALSE;
 
 #ifdef RANDR
-    if (!fbdevRandRInit (pScreen))
-	return FALSE;
+    if (!fbdevRandRInit(pScreen))
+        return FALSE;
 #endif
 
     return TRUE;
 }
 
-
 Bool
-fbdevCreateResources (ScreenPtr pScreen)
+fbdevCreateResources(ScreenPtr pScreen)
 {
-    return fbdevSetShadow (pScreen);
+    return fbdevSetShadow(pScreen);
 }
 
 void
-fbdevPreserve (KdCardInfo *card)
+fbdevPreserve(KdCardInfo * card)
 {
 }
 
 static int
-fbdevUpdateFbColormap(FbdevPriv *priv, int minidx, int maxidx)
+fbdevUpdateFbColormap(FbdevPriv * priv, int minidx, int maxidx)
 {
     struct fb_cmap cmap;
 
@@ -666,89 +638,84 @@ fbdevUpdateFbColormap(FbdevPriv *priv, int minidx, int maxidx)
 }
 
 Bool
-fbdevEnable (ScreenPtr pScreen)
+fbdevEnable(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    FbdevPriv		*priv = pScreenPriv->card->driver;
-    int			k;
+    FbdevPriv *priv = pScreenPriv->card->driver;
+    int k;
 
-    priv->var.activate = FB_ACTIVATE_NOW|FB_CHANGE_CMAP_VBL;
+    priv->var.activate = FB_ACTIVATE_NOW | FB_CHANGE_CMAP_VBL;
 
     /* display it on the LCD */
-    k = ioctl (priv->fd, FBIOPUT_VSCREENINFO, &priv->var);
-    if (k < 0)
-    {
-	perror ("FBIOPUT_VSCREENINFO");
-	return FALSE;
+    k = ioctl(priv->fd, FBIOPUT_VSCREENINFO, &priv->var);
+    if (k < 0) {
+        perror("FBIOPUT_VSCREENINFO");
+        return FALSE;
     }
 
-    if (priv->fix.visual == FB_VISUAL_DIRECTCOLOR)
-    {
-	int		i;
-
-	for (i = 0;
-	     i < (1 << priv->var.red.length) ||
-	     i < (1 << priv->var.green.length) ||
-	     i < (1 << priv->var.blue.length); i++)
-	{
-	    priv->red[i] = i * 65535 / ((1 << priv->var.red.length) - 1);
-	    priv->green[i] = i * 65535 / ((1 << priv->var.green.length) - 1);
-	    priv->blue[i] = i * 65535 / ((1 << priv->var.blue.length) - 1);
-	}
-
-	fbdevUpdateFbColormap(priv, 0, i);
+    if (priv->fix.visual == FB_VISUAL_DIRECTCOLOR) {
+        int i;
+
+        for (i = 0;
+             i < (1 << priv->var.red.length) ||
+             i < (1 << priv->var.green.length) ||
+             i < (1 << priv->var.blue.length); i++) {
+            priv->red[i] = i * 65535 / ((1 << priv->var.red.length) - 1);
+            priv->green[i] = i * 65535 / ((1 << priv->var.green.length) - 1);
+            priv->blue[i] = i * 65535 / ((1 << priv->var.blue.length) - 1);
+        }
+
+        fbdevUpdateFbColormap(priv, 0, i);
     }
     return TRUE;
 }
 
 Bool
-fbdevDPMS (ScreenPtr pScreen, int mode)
+fbdevDPMS(ScreenPtr pScreen, int mode)
 {
     KdScreenPriv(pScreen);
-    FbdevPriv	*priv = pScreenPriv->card->driver;
+    FbdevPriv *priv = pScreenPriv->card->driver;
     static int oldmode = -1;
 
     if (mode == oldmode)
-	return TRUE;
+        return TRUE;
 #ifdef FBIOPUT_POWERMODE
-    if (ioctl (priv->fd, FBIOPUT_POWERMODE, &mode) >= 0)
-    {
-	oldmode = mode;
-	return TRUE;
+    if (ioctl(priv->fd, FBIOPUT_POWERMODE, &mode) >= 0) {
+        oldmode = mode;
+        return TRUE;
     }
 #endif
 #ifdef FBIOBLANK
-    if (ioctl (priv->fd, FBIOBLANK, mode ? mode + 1 : 0) >= 0)
-    {
-	oldmode = mode;
-	return TRUE;
+    if (ioctl(priv->fd, FBIOBLANK, mode ? mode + 1 : 0) >= 0) {
+        oldmode = mode;
+        return TRUE;
     }
 #endif
     return FALSE;
 }
 
 void
-fbdevDisable (ScreenPtr pScreen)
+fbdevDisable(ScreenPtr pScreen)
 {
 }
 
 void
-fbdevRestore (KdCardInfo *card)
+fbdevRestore(KdCardInfo * card)
 {
 }
 
 void
-fbdevScreenFini (KdScreenInfo *screen)
+fbdevScreenFini(KdScreenInfo * screen)
 {
 }
 
 void
-fbdevCardFini (KdCardInfo *card)
+fbdevCardFini(KdCardInfo * card)
 {
-    FbdevPriv	*priv = card->driver;
+    FbdevPriv *priv = card->driver;
 
-    munmap (priv->fb_base, priv->fix.smem_len);
-    close (priv->fd);
+    munmap(priv->fb_base, priv->fix.smem_len);
+    close(priv->fd);
     free(priv);
 }
 
@@ -756,23 +723,22 @@ fbdevCardFini (KdCardInfo *card)
  * Retrieve actual colormap and return selected n entries in pdefs.
  */
 void
-fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+fbdevGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
 {
     KdScreenPriv(pScreen);
-    FbdevPriv	    *priv = pScreenPriv->card->driver;
-    struct fb_cmap  cmap;
-    int		    p;
-    int		    k;
-    int		    min, max;
+    FbdevPriv *priv = pScreenPriv->card->driver;
+    struct fb_cmap cmap;
+    int p;
+    int k;
+    int min, max;
 
     min = 256;
     max = 0;
-    for (k = 0; k < n; k++)
-    {
-	if (pdefs[k].pixel < min)
-	    min = pdefs[k].pixel;
-	if (pdefs[k].pixel > max)
-	    max = pdefs[k].pixel;
+    for (k = 0; k < n; k++) {
+        if (pdefs[k].pixel < min)
+            min = pdefs[k].pixel;
+        if (pdefs[k].pixel > max)
+            max = pdefs[k].pixel;
     }
     cmap.start = min;
     cmap.len = max - min + 1;
@@ -780,19 +746,17 @@ fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
     cmap.green = &priv->green[min];
     cmap.blue = &priv->blue[min];
     cmap.transp = 0;
-    k = ioctl (priv->fd, FBIOGETCMAP, &cmap);
-    if (k < 0)
-    {
-	perror ("can't get colormap");
-	return;
+    k = ioctl(priv->fd, FBIOGETCMAP, &cmap);
+    if (k < 0) {
+        perror("can't get colormap");
+        return;
     }
-    while (n--)
-    {
-	p = pdefs->pixel;
-	pdefs->red = priv->red[p];
-	pdefs->green = priv->green[p];
-	pdefs->blue = priv->blue[p];
-	pdefs++;
+    while (n--) {
+        p = pdefs->pixel;
+        pdefs->red = priv->red[p];
+        pdefs->green = priv->green[p];
+        pdefs->blue = priv->blue[p];
+        pdefs++;
     }
 }
 
@@ -800,26 +764,25 @@ fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
  * Change colormap by updating n entries described in pdefs.
  */
 void
-fbdevPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+fbdevPutColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
 {
     KdScreenPriv(pScreen);
-    FbdevPriv	*priv = pScreenPriv->card->driver;
-    int		    p;
-    int		    min, max;
+    FbdevPriv *priv = pScreenPriv->card->driver;
+    int p;
+    int min, max;
 
     min = 256;
     max = 0;
-    while (n--)
-    {
-	p = pdefs->pixel;
-	priv->red[p] = pdefs->red;
-	priv->green[p] = pdefs->green;
-	priv->blue[p] = pdefs->blue;
-	if (p < min)
-	    min = p;
-	if (p > max)
-	    max = p;
-	pdefs++;
+    while (n--) {
+        p = pdefs->pixel;
+        priv->red[p] = pdefs->red;
+        priv->green[p] = pdefs->green;
+        priv->blue[p] = pdefs->blue;
+        if (p < min)
+            min = p;
+        if (p > max)
+            max = p;
+        pdefs++;
     }
 
     fbdevUpdateFbColormap(priv, min, max);
diff --git a/hw/kdrive/fbdev/fbdev.h b/hw/kdrive/fbdev/fbdev.h
index ec53784af..0706f4e11 100644
--- a/hw/kdrive/fbdev/fbdev.h
+++ b/hw/kdrive/fbdev/fbdev.h
@@ -33,67 +33,67 @@
 #endif
 
 typedef struct _fbdevPriv {
-    struct fb_var_screeninfo	var;
-    struct fb_fix_screeninfo	fix;
-    __u16			red[256];
-    __u16			green[256];
-    __u16			blue[256];
-    int				fd;
-    char			*fb;
-    char			*fb_base;
+    struct fb_var_screeninfo var;
+    struct fb_fix_screeninfo fix;
+    __u16 red[256];
+    __u16 green[256];
+    __u16 blue[256];
+    int fd;
+    char *fb;
+    char *fb_base;
 } FbdevPriv;
 
 typedef struct _fbdevScrPriv {
-    Rotation			randr;
-    Bool			shadow;
+    Rotation randr;
+    Bool shadow;
 } FbdevScrPriv;
 
-extern KdCardFuncs  fbdevFuncs;
-extern char*        fbdevDevicePath;
+extern KdCardFuncs fbdevFuncs;
+extern char *fbdevDevicePath;
 
 Bool
-fbdevCardInit (KdCardInfo *card);
+ fbdevCardInit(KdCardInfo * card);
 
 Bool
-fbdevScreenInit (KdScreenInfo *screen);
+ fbdevScreenInit(KdScreenInfo * screen);
 
 Bool
-fbdevInitScreen (ScreenPtr pScreen);
+ fbdevInitScreen(ScreenPtr pScreen);
 
 Bool
-fbdevFinishInitScreen (ScreenPtr pScreen);
+ fbdevFinishInitScreen(ScreenPtr pScreen);
 
 Bool
-fbdevCreateResources (ScreenPtr pScreen);
+ fbdevCreateResources(ScreenPtr pScreen);
 
 void
-fbdevPreserve (KdCardInfo *card);
+ fbdevPreserve(KdCardInfo * card);
 
 Bool
-fbdevEnable (ScreenPtr pScreen);
+ fbdevEnable(ScreenPtr pScreen);
 
 Bool
-fbdevDPMS (ScreenPtr pScreen, int mode);
+ fbdevDPMS(ScreenPtr pScreen, int mode);
 
 void
-fbdevDisable (ScreenPtr pScreen);
+ fbdevDisable(ScreenPtr pScreen);
 
 void
-fbdevRestore (KdCardInfo *card);
+ fbdevRestore(KdCardInfo * card);
 
 void
-fbdevScreenFini (KdScreenInfo *screen);
+ fbdevScreenFini(KdScreenInfo * screen);
 
 void
-fbdevCardFini (KdCardInfo *card);
+ fbdevCardFini(KdCardInfo * card);
 
 void
-fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+ fbdevGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
 
 void
-fbdevPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+ fbdevPutColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
 
 Bool
-fbdevMapFramebuffer (KdScreenInfo *screen);
+ fbdevMapFramebuffer(KdScreenInfo * screen);
 
-#endif /* _FBDEV_H_ */
+#endif                          /* _FBDEV_H_ */
diff --git a/hw/kdrive/fbdev/fbinit.c b/hw/kdrive/fbdev/fbinit.c
index 1d66fce32..d2a14019d 100644
--- a/hw/kdrive/fbdev/fbinit.c
+++ b/hw/kdrive/fbdev/fbinit.c
@@ -26,82 +26,80 @@
 #include <fbdev.h>
 
 void
-InitCard (char *name)
+InitCard(char *name)
 {
-    KdCardInfoAdd (&fbdevFuncs, 0);
+    KdCardInfoAdd(&fbdevFuncs, 0);
 }
 
 void
-InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
+InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
 {
-    KdInitOutput (pScreenInfo, argc, argv);
+    KdInitOutput(pScreenInfo, argc, argv);
 }
 
 void
-InitInput (int argc, char **argv)
+InitInput(int argc, char **argv)
 {
-    KdOsAddInputDrivers ();
-    KdInitInput ();
+    KdOsAddInputDrivers();
+    KdInitInput();
 }
 
 void
-CloseInput (void)
+CloseInput(void)
 {
-    KdCloseInput ();
+    KdCloseInput();
 }
 
 void
-ddxUseMsg (void)
+ddxUseMsg(void)
 {
-  KdUseMsg();
-  ErrorF("\nXfbdev Device Usage:\n");
-  ErrorF("-fb path         Framebuffer device to use. Defaults to /dev/fb0\n");
-  ErrorF("\n");
+    KdUseMsg();
+    ErrorF("\nXfbdev Device Usage:\n");
+    ErrorF
+        ("-fb path         Framebuffer device to use. Defaults to /dev/fb0\n");
+    ErrorF("\n");
 }
 
 int
-ddxProcessArgument (int argc, char **argv, int i)
+ddxProcessArgument(int argc, char **argv, int i)
 {
-  if (!strcmp (argv[i], "-fb"))
-    {
-      if (i+1 < argc)
-	{
-	  fbdevDevicePath = argv[i+1];
-	  return 2;
-	}
-      UseMsg();
-      exit(1);
+    if (!strcmp(argv[i], "-fb")) {
+        if (i + 1 < argc) {
+            fbdevDevicePath = argv[i + 1];
+            return 2;
+        }
+        UseMsg();
+        exit(1);
     }
 
-  return KdProcessArgument (argc, argv, i);
+    return KdProcessArgument(argc, argv, i);
 }
 
+KdCardFuncs fbdevFuncs = {
+    fbdevCardInit,              /* cardinit */
+    fbdevScreenInit,            /* scrinit */
+    fbdevInitScreen,            /* initScreen */
+    fbdevFinishInitScreen,      /* finishInitScreen */
+    fbdevCreateResources,       /* createRes */
+    fbdevPreserve,              /* preserve */
+    fbdevEnable,                /* enable */
+    fbdevDPMS,                  /* dpms */
+    fbdevDisable,               /* disable */
+    fbdevRestore,               /* restore */
+    fbdevScreenFini,            /* scrfini */
+    fbdevCardFini,              /* cardfini */
 
-KdCardFuncs	fbdevFuncs = {
-    fbdevCardInit,	    /* cardinit */
-    fbdevScreenInit,	    /* scrinit */
-    fbdevInitScreen,	    /* initScreen */
-    fbdevFinishInitScreen,  /* finishInitScreen */
-    fbdevCreateResources,   /* createRes */
-    fbdevPreserve,	    /* preserve */
-    fbdevEnable,	    /* enable */
-    fbdevDPMS,		    /* dpms */
-    fbdevDisable,	    /* disable */
-    fbdevRestore,	    /* restore */
-    fbdevScreenFini,	    /* scrfini */
-    fbdevCardFini,	    /* cardfini */
+    0,                          /* initCursor */
+    0,                          /* enableCursor */
+    0,                          /* disableCursor */
+    0,                          /* finiCursor */
+    0,                          /* recolorCursor */
 
-    0,			    /* initCursor */
-    0,			    /* enableCursor */
-    0,			    /* disableCursor */
-    0,			    /* finiCursor */
-    0,			    /* recolorCursor */
+    0,                          /* initAccel */
+    0,                          /* enableAccel */
+    0,                          /* disableAccel */
+    0,                          /* finiAccel */
 
-    0,			    /* initAccel */
-    0,			    /* enableAccel */
-    0,			    /* disableAccel */
-    0,			    /* finiAccel */
-
-    fbdevGetColors,    	    /* getColors */
-    fbdevPutColors,	    /* putColors */
+    fbdevGetColors,             /* getColors */
+    fbdevPutColors,             /* putColors */
 };
diff --git a/hw/kdrive/linux/evdev.c b/hw/kdrive/linux/evdev.c
index 3797f0926..9982fad36 100644
--- a/hw/kdrive/linux/evdev.c
+++ b/hw/kdrive/linux/evdev.c
@@ -44,24 +44,24 @@
 
 typedef struct _kevdev {
     /* current device state */
-    int                            rel[REL_MAX + 1];
-    int                            abs[ABS_MAX + 1];
-    int                            prevabs[ABS_MAX + 1];
-    long                    key[NBITS(KEY_MAX + 1)];
+    int rel[REL_MAX + 1];
+    int abs[ABS_MAX + 1];
+    int prevabs[ABS_MAX + 1];
+    long key[NBITS(KEY_MAX + 1)];
 
     /* supported device info */
-    long                    relbits[NBITS(REL_MAX + 1)];
-    long                    absbits[NBITS(ABS_MAX + 1)];
-    long                    keybits[NBITS(KEY_MAX + 1)];
-    struct input_absinfo    absinfo[ABS_MAX + 1];
-    int                            max_rel;
-    int                            max_abs;
-
-    int                     fd;
+    long relbits[NBITS(REL_MAX + 1)];
+    long absbits[NBITS(ABS_MAX + 1)];
+    long keybits[NBITS(KEY_MAX + 1)];
+    struct input_absinfo absinfo[ABS_MAX + 1];
+    int max_rel;
+    int max_abs;
+
+    int fd;
 } Kevdev;
 
 static void
-EvdevPtrBtn (KdPointerInfo    *pi, struct input_event *ev)
+EvdevPtrBtn(KdPointerInfo * pi, struct input_event *ev)
 {
     int flags = KD_MOUSE_DELTA | pi->buttonState;
 
@@ -70,127 +70,123 @@ EvdevPtrBtn (KdPointerInfo    *pi, struct input_event *ev)
         case BTN_LEFT:
             if (ev->value == 1)
                 flags |= KD_BUTTON_1;
-	    else
+            else
                 flags &= ~KD_BUTTON_1;
-             break;
+            break;
         case BTN_MIDDLE:
             if (ev->value == 1)
                 flags |= KD_BUTTON_2;
-	    else
-		flags &= ~KD_BUTTON_2;
+            else
+                flags &= ~KD_BUTTON_2;
             break;
         case BTN_RIGHT:
             if (ev->value == 1)
                 flags |= KD_BUTTON_3;
-	    else
-		flags &= ~KD_BUTTON_3;
+            else
+                flags &= ~KD_BUTTON_3;
             break;
         default:
             /* Unknow button */
             break;
         }
 
-        KdEnqueuePointerEvent (pi, flags, 0, 0, 0);
+        KdEnqueuePointerEvent(pi, flags, 0, 0, 0);
     }
 }
+
 static void
-EvdevPtrMotion (KdPointerInfo    *pi, struct input_event *ev)
+EvdevPtrMotion(KdPointerInfo * pi, struct input_event *ev)
 {
-    Kevdev                *ke = pi->driverPrivate;
+    Kevdev *ke = pi->driverPrivate;
     int i;
     int flags = KD_MOUSE_DELTA | pi->buttonState;
 
     for (i = 0; i <= ke->max_rel; i++)
-        if (ke->rel[i])
-        {
+        if (ke->rel[i]) {
             int a;
-            for (a = 0; a <= ke->max_rel; a++)
-            {
-                if (ISBITSET (ke->relbits, a))
-		{
+
+            for (a = 0; a <= ke->max_rel; a++) {
+                if (ISBITSET(ke->relbits, a)) {
                     if (a == 0)
                         KdEnqueuePointerEvent(pi, flags, ke->rel[a], 0, 0);
                     else if (a == 1)
                         KdEnqueuePointerEvent(pi, flags, 0, ke->rel[a], 0);
                 }
-		ke->rel[a] = 0;
+                ke->rel[a] = 0;
             }
             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;
-            ErrorF ("abs");
-            for (a = 0; a <= ke->max_abs; a++)
-            {
-                if (ISBITSET (ke->absbits, a))
-                    ErrorF (" %d=%d", a, ke->abs[a]);
+
+            ErrorF("abs");
+            for (a = 0; a <= ke->max_abs; a++) {
+                if (ISBITSET(ke->absbits, a))
+                    ErrorF(" %d=%d", a, ke->abs[a]);
                 ke->prevabs[a] = ke->abs[a];
             }
-            ErrorF ("\n");
+            ErrorF("\n");
             break;
         }
 
     if (ev->code == REL_WHEEL) {
-      for (i = 0; i < abs (ev->value); i++)
-      {
-        if (ev->value > 0)
-          flags |= KD_BUTTON_4;
-        else
-          flags |= KD_BUTTON_5;
+        for (i = 0; i < abs(ev->value); i++) {
+            if (ev->value > 0)
+                flags |= KD_BUTTON_4;
+            else
+                flags |= KD_BUTTON_5;
 
-        KdEnqueuePointerEvent (pi, flags, 0, 0, 0);
+            KdEnqueuePointerEvent(pi, flags, 0, 0, 0);
 
-        if (ev->value > 0)
-          flags &= ~KD_BUTTON_4;
-        else
-          flags &= ~KD_BUTTON_5;
+            if (ev->value > 0)
+                flags &= ~KD_BUTTON_4;
+            else
+                flags &= ~KD_BUTTON_5;
 
-        KdEnqueuePointerEvent (pi, flags, 0, 0, 0);
-      }
+            KdEnqueuePointerEvent(pi, flags, 0, 0, 0);
+        }
     }
 
 }
 
 static void
-EvdevPtrRead (int evdevPort, void *closure)
+EvdevPtrRead(int evdevPort, void *closure)
 {
-    KdPointerInfo                *pi = closure;
-    Kevdev                       *ke = pi->driverPrivate;
-    int                        i;
-    struct input_event        events[NUM_EVENTS];
-    int                        n;
+    KdPointerInfo *pi = closure;
+    Kevdev *ke = pi->driverPrivate;
+    int i;
+    struct input_event events[NUM_EVENTS];
+    int n;
 
-    n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));
+    n = read(evdevPort, &events, NUM_EVENTS * sizeof(struct input_event));
     if (n <= 0) {
         if (errno == ENODEV)
             DeleteInputDeviceRequest(pi->dixdev);
         return;
     }
 
-    n /= sizeof (struct input_event);
-    for (i = 0; i < n; i++)
-    {
+    n /= sizeof(struct input_event);
+    for (i = 0; i < n; i++) {
         switch (events[i].type) {
         case EV_SYN:
             break;
         case EV_KEY:
-            EvdevPtrBtn (pi, &events[i]);
+            EvdevPtrBtn(pi, &events[i]);
             break;
         case EV_REL:
             ke->rel[events[i].code] += events[i].value;
-            EvdevPtrMotion (pi, &events[i]);
+            EvdevPtrMotion(pi, &events[i]);
             break;
         case EV_ABS:
             ke->abs[events[i].code] = events[i].value;
-            EvdevPtrMotion (pi, &events[i]);
+            EvdevPtrMotion(pi, &events[i]);
             break;
         }
     }
 }
 
-char *kdefaultEvdev[] =  {
+char *kdefaultEvdev[] = {
     "/dev/input/event0",
     "/dev/input/event1",
     "/dev/input/event2",
@@ -200,22 +196,22 @@ char *kdefaultEvdev[] =  {
 #define NUM_DEFAULT_EVDEV    (sizeof (kdefaultEvdev) / sizeof (kdefaultEvdev[0]))
 
 static Status
-EvdevPtrInit (KdPointerInfo *pi)
+EvdevPtrInit(KdPointerInfo * pi)
 {
-    int                i;
-    int                fd;
+    int i;
+    int fd;
 
     if (!pi->path) {
         for (i = 0; i < NUM_DEFAULT_EVDEV; i++) {
-            fd = open (kdefaultEvdev[i], 2);
+            fd = open(kdefaultEvdev[i], 2);
             if (fd >= 0) {
-                pi->path = strdup (kdefaultEvdev[i]);
+                pi->path = strdup(kdefaultEvdev[i]);
                 break;
             }
         }
     }
     else {
-        fd = open (pi->path, O_RDWR);
+        fd = open(pi->path, O_RDWR);
         if (fd < 0) {
             ErrorF("Failed to open evdev device %s\n", pi->path);
             return BadMatch;
@@ -230,11 +226,11 @@ EvdevPtrInit (KdPointerInfo *pi)
 }
 
 static Status
-EvdevPtrEnable (KdPointerInfo *pi)
+EvdevPtrEnable(KdPointerInfo * pi)
 {
     int fd;
-    unsigned long   ev[NBITS(EV_MAX)];
-    Kevdev            *ke;
+    unsigned long ev[NBITS(EV_MAX)];
+    Kevdev *ke;
 
     if (!pi || !pi->path)
         return BadImplementation;
@@ -243,81 +239,67 @@ EvdevPtrEnable (KdPointerInfo *pi)
     if (fd < 0)
         return BadMatch;
 
-    if (ioctl (fd, EVIOCGRAB, 1) < 0)
-        perror ("Grabbing evdev mouse device failed");
+    if (ioctl(fd, EVIOCGRAB, 1) < 0)
+        perror("Grabbing evdev mouse device failed");
 
-    if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0)
-    {
-        perror ("EVIOCGBIT 0");
-        close (fd);
+    if (ioctl(fd, EVIOCGBIT(0 /*EV*/, sizeof(ev)), ev) < 0) {
+        perror("EVIOCGBIT 0");
+        close(fd);
         return BadMatch;
     }
-    ke = calloc(1, sizeof (Kevdev));
-    if (!ke)
-    {
-        close (fd);
+    ke = calloc(1, sizeof(Kevdev));
+    if (!ke) {
+        close(fd);
         return BadAlloc;
     }
-    if (ISBITSET (ev, EV_KEY))
-    {
-        if (ioctl (fd, EVIOCGBIT (EV_KEY, sizeof (ke->keybits)),
-                   ke->keybits) < 0)
-        {
-            perror ("EVIOCGBIT EV_KEY");
+    if (ISBITSET(ev, EV_KEY)) {
+        if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(ke->keybits)), ke->keybits) < 0) {
+            perror("EVIOCGBIT EV_KEY");
             free(ke);
-            close (fd);
+            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");
+    if (ISBITSET(ev, EV_REL)) {
+        if (ioctl(fd, EVIOCGBIT(EV_REL, sizeof(ke->relbits)), ke->relbits) < 0) {
+            perror("EVIOCGBIT EV_REL");
             free(ke);
-            close (fd);
+            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))
-    {
+    if (ISBITSET(ev, EV_ABS)) {
         int i;
 
-        if (ioctl (fd, EVIOCGBIT (EV_ABS, sizeof (ke->absbits)),
-                   ke->absbits) < 0)
-            {
-            perror ("EVIOCGBIT EV_ABS");
+        if (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(ke->absbits)), ke->absbits) < 0) {
+            perror("EVIOCGBIT EV_ABS");
             free(ke);
-            close (fd);
+            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");
+        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)
-        {
+        if (i <= ke->max_abs) {
             free(ke);
-            close (fd);
+            close(fd);
             return BadValue;
         }
     }
-    if (!KdRegisterFd (fd, EvdevPtrRead, pi)) {
+    if (!KdRegisterFd(fd, EvdevPtrRead, pi)) {
         free(ke);
-        close (fd);
+        close(fd);
         return BadAlloc;
     }
     pi->driverPrivate = ke;
@@ -327,36 +309,35 @@ EvdevPtrEnable (KdPointerInfo *pi)
 }
 
 static void
-EvdevPtrDisable (KdPointerInfo *pi)
+EvdevPtrDisable(KdPointerInfo * pi)
 {
-    Kevdev              *ke;
+    Kevdev *ke;
 
     ke = pi->driverPrivate;
 
     if (!pi || !pi->driverPrivate)
         return;
 
-    KdUnregisterFd (pi, ke->fd, TRUE);
+    KdUnregisterFd(pi, ke->fd, TRUE);
 
-    if (ioctl (ke->fd, EVIOCGRAB, 0) < 0)
-        perror ("Ungrabbing evdev mouse device failed");
+    if (ioctl(ke->fd, EVIOCGRAB, 0) < 0)
+        perror("Ungrabbing evdev mouse device failed");
 
     free(ke);
     pi->driverPrivate = 0;
 }
 
 static void
-EvdevPtrFini (KdPointerInfo *pi)
+EvdevPtrFini(KdPointerInfo * pi)
 {
 }
 
-
 /*
  * Evdev keyboard functions
  */
 
 static void
-readMapping (KdKeyboardInfo *ki)
+readMapping(KdKeyboardInfo * ki)
 {
     if (!ki)
         return;
@@ -366,24 +347,23 @@ readMapping (KdKeyboardInfo *ki)
 }
 
 static void
-EvdevKbdRead (int evdevPort, void *closure)
+EvdevKbdRead(int evdevPort, void *closure)
 {
-    KdKeyboardInfo	 *ki = closure;
-    struct input_event	 events[NUM_EVENTS];
-    int			 i, n;
+    KdKeyboardInfo *ki = closure;
+    struct input_event events[NUM_EVENTS];
+    int i, n;
 
-    n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));
+    n = read(evdevPort, &events, NUM_EVENTS * sizeof(struct input_event));
     if (n <= 0) {
         if (errno == ENODEV)
             DeleteInputDeviceRequest(ki->dixdev);
         return;
     }
 
-    n /= sizeof (struct input_event);
-    for (i = 0; i < n; i++)
-    {
+    n /= sizeof(struct input_event);
+    for (i = 0; i < n; i++) {
         if (events[i].type == EV_KEY)
-	    KdEnqueueKeyboardEvent (ki, events[i].code, !events[i].value);
+            KdEnqueueKeyboardEvent(ki, events[i].code, !events[i].value);
 /* FIXME: must implement other types of events
         else
             ErrorF("Event type (%d) not delivered\n", events[i].type);
@@ -392,7 +372,7 @@ EvdevKbdRead (int evdevPort, void *closure)
 }
 
 static Status
-EvdevKbdInit (KdKeyboardInfo *ki)
+EvdevKbdInit(KdKeyboardInfo * ki)
 {
     int fd;
 
@@ -401,14 +381,14 @@ EvdevKbdInit (KdKeyboardInfo *ki)
         return BadValue;
     }
     else {
-        fd = open (ki->path, O_RDWR);
+        fd = open(ki->path, O_RDWR);
         if (fd < 0) {
             ErrorF("Failed to open evdev device %s\n", ki->path);
             return BadMatch;
         }
     }
 
-    close (fd);
+    close(fd);
 
     ki->name = strdup("Evdev keyboard");
 
@@ -418,11 +398,11 @@ EvdevKbdInit (KdKeyboardInfo *ki)
 }
 
 static Status
-EvdevKbdEnable (KdKeyboardInfo *ki)
+EvdevKbdEnable(KdKeyboardInfo * ki)
 {
-    unsigned long       ev[NBITS(EV_MAX)];
-    Kevdev              *ke;
-    int                 fd;
+    unsigned long ev[NBITS(EV_MAX)];
+    Kevdev *ke;
+    int fd;
 
     if (!ki || !ki->path)
         return BadImplementation;
@@ -431,24 +411,24 @@ EvdevKbdEnable (KdKeyboardInfo *ki)
     if (fd < 0)
         return BadMatch;
 
-    if (ioctl (fd, EVIOCGRAB, 1) < 0)
-        perror ("Grabbing evdev keyboard device failed");
+    if (ioctl(fd, EVIOCGRAB, 1) < 0)
+        perror("Grabbing evdev keyboard device failed");
 
-    if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0) {
-        perror ("EVIOCGBIT 0");
-        close (fd);
+    if (ioctl(fd, EVIOCGBIT(0 /*EV*/, sizeof(ev)), ev) < 0) {
+        perror("EVIOCGBIT 0");
+        close(fd);
         return BadMatch;
     }
 
-    ke = calloc(1, sizeof (Kevdev));
+    ke = calloc(1, sizeof(Kevdev));
     if (!ke) {
-        close (fd);
+        close(fd);
         return BadAlloc;
     }
 
-    if (!KdRegisterFd (fd, EvdevKbdRead, ki)) {
+    if (!KdRegisterFd(fd, EvdevKbdRead, ki)) {
         free(ke);
-        close (fd);
+        close(fd);
         return BadAlloc;
     }
     ki->driverPrivate = ke;
@@ -458,7 +438,7 @@ EvdevKbdEnable (KdKeyboardInfo *ki)
 }
 
 static void
-EvdevKbdLeds (KdKeyboardInfo *ki, int leds)
+EvdevKbdLeds(KdKeyboardInfo * ki, int leds)
 {
 /*    struct input_event event;
     Kevdev             *ke;
@@ -490,31 +470,31 @@ EvdevKbdLeds (KdKeyboardInfo *ki, int leds)
 }
 
 static void
-EvdevKbdBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
+EvdevKbdBell(KdKeyboardInfo * ki, int volume, int frequency, int duration)
 {
 }
 
 static void
-EvdevKbdDisable (KdKeyboardInfo *ki)
+EvdevKbdDisable(KdKeyboardInfo * ki)
 {
-    Kevdev              *ke;
+    Kevdev *ke;
 
     ke = ki->driverPrivate;
 
     if (!ki || !ki->driverPrivate)
         return;
 
-    KdUnregisterFd (ki, ke->fd, TRUE);
+    KdUnregisterFd(ki, ke->fd, TRUE);
 
-    if (ioctl (ke->fd, EVIOCGRAB, 0) < 0)
-        perror ("Ungrabbing evdev keyboard device failed");
+    if (ioctl(ke->fd, EVIOCGRAB, 0) < 0)
+        perror("Ungrabbing evdev keyboard device failed");
 
     free(ke);
     ki->driverPrivate = 0;
 }
 
 static void
-EvdevKbdFini (KdKeyboardInfo *ki)
+EvdevKbdFini(KdKeyboardInfo * ki)
 {
 }
 
diff --git a/hw/kdrive/linux/keyboard.c b/hw/kdrive/linux/keyboard.c
index ba2637b58..9a6ee2d93 100644
--- a/hw/kdrive/linux/keyboard.c
+++ b/hw/kdrive/linux/keyboard.c
@@ -44,70 +44,70 @@
 extern int LinuxConsoleFd;
 
 static const KeySym linux_to_x[256] = {
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_BackSpace,	XK_Tab,		XK_Linefeed,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	XK_Escape,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_space,	XK_exclam,	XK_quotedbl,	XK_numbersign,
-	XK_dollar,	XK_percent,	XK_ampersand,	XK_apostrophe,
-	XK_parenleft,	XK_parenright,	XK_asterisk,	XK_plus,
-	XK_comma,	XK_minus,	XK_period,	XK_slash,
-	XK_0,		XK_1,		XK_2,		XK_3,
-	XK_4,		XK_5,		XK_6,		XK_7,
-	XK_8,		XK_9,		XK_colon,	XK_semicolon,
-	XK_less,	XK_equal,	XK_greater,	XK_question,
-	XK_at,		XK_A,		XK_B,		XK_C,
-	XK_D,		XK_E,		XK_F,		XK_G,
-	XK_H,		XK_I,		XK_J,		XK_K,
-	XK_L,		XK_M,		XK_N,		XK_O,
-	XK_P,		XK_Q,		XK_R,		XK_S,
-	XK_T,		XK_U,		XK_V,		XK_W,
-	XK_X,		XK_Y,		XK_Z,		XK_bracketleft,
-	XK_backslash,	XK_bracketright,XK_asciicircum,	XK_underscore,
-	XK_grave,	XK_a,		XK_b,		XK_c,
-	XK_d,		XK_e,		XK_f,		XK_g,
-	XK_h,		XK_i,		XK_j,		XK_k,
-	XK_l,		XK_m,		XK_n,		XK_o,
-	XK_p,		XK_q,		XK_r,		XK_s,
-	XK_t,		XK_u,		XK_v,		XK_w,
-	XK_x,		XK_y,		XK_z,		XK_braceleft,
-	XK_bar,		XK_braceright,	XK_asciitilde,	XK_BackSpace,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
-	XK_nobreakspace,XK_exclamdown,	XK_cent,	XK_sterling,
-	XK_currency,	XK_yen,		XK_brokenbar,	XK_section,
-	XK_diaeresis,	XK_copyright,	XK_ordfeminine,	XK_guillemotleft,
-	XK_notsign,	XK_hyphen,	XK_registered,	XK_macron,
-	XK_degree,	XK_plusminus,	XK_twosuperior,	XK_threesuperior,
-	XK_acute,	XK_mu,		XK_paragraph,	XK_periodcentered,
-	XK_cedilla,	XK_onesuperior,	XK_masculine,	XK_guillemotright,
-	XK_onequarter,	XK_onehalf,	XK_threequarters,XK_questiondown,
-	XK_Agrave,	XK_Aacute,	XK_Acircumflex,	XK_Atilde,
-	XK_Adiaeresis,	XK_Aring,	XK_AE,		XK_Ccedilla,
-	XK_Egrave,	XK_Eacute,	XK_Ecircumflex,	XK_Ediaeresis,
-	XK_Igrave,	XK_Iacute,	XK_Icircumflex,	XK_Idiaeresis,
-	XK_ETH,		XK_Ntilde,	XK_Ograve,	XK_Oacute,
-	XK_Ocircumflex,	XK_Otilde,	XK_Odiaeresis,	XK_multiply,
-	XK_Ooblique,	XK_Ugrave,	XK_Uacute,	XK_Ucircumflex,
-	XK_Udiaeresis,	XK_Yacute,	XK_THORN,	XK_ssharp,
-	XK_agrave,	XK_aacute,	XK_acircumflex,	XK_atilde,
-	XK_adiaeresis,	XK_aring,	XK_ae,		XK_ccedilla,
-	XK_egrave,	XK_eacute,	XK_ecircumflex,	XK_ediaeresis,
-	XK_igrave,	XK_iacute,	XK_icircumflex,	XK_idiaeresis,
-	XK_eth,		XK_ntilde,	XK_ograve,	XK_oacute,
-	XK_ocircumflex,	XK_otilde,	XK_odiaeresis,	XK_division,
-	XK_oslash,	XK_ugrave,	XK_uacute,	XK_ucircumflex,
-	XK_udiaeresis,	XK_yacute,	XK_thorn,	XK_ydiaeresis
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    XK_BackSpace, XK_Tab, XK_Linefeed, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, XK_Escape,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    XK_space, XK_exclam, XK_quotedbl, XK_numbersign,
+    XK_dollar, XK_percent, XK_ampersand, XK_apostrophe,
+    XK_parenleft, XK_parenright, XK_asterisk, XK_plus,
+    XK_comma, XK_minus, XK_period, XK_slash,
+    XK_0, XK_1, XK_2, XK_3,
+    XK_4, XK_5, XK_6, XK_7,
+    XK_8, XK_9, XK_colon, XK_semicolon,
+    XK_less, XK_equal, XK_greater, XK_question,
+    XK_at, XK_A, XK_B, XK_C,
+    XK_D, XK_E, XK_F, XK_G,
+    XK_H, XK_I, XK_J, XK_K,
+    XK_L, XK_M, XK_N, XK_O,
+    XK_P, XK_Q, XK_R, XK_S,
+    XK_T, XK_U, XK_V, XK_W,
+    XK_X, XK_Y, XK_Z, XK_bracketleft,
+    XK_backslash, XK_bracketright, XK_asciicircum, XK_underscore,
+    XK_grave, XK_a, XK_b, XK_c,
+    XK_d, XK_e, XK_f, XK_g,
+    XK_h, XK_i, XK_j, XK_k,
+    XK_l, XK_m, XK_n, XK_o,
+    XK_p, XK_q, XK_r, XK_s,
+    XK_t, XK_u, XK_v, XK_w,
+    XK_x, XK_y, XK_z, XK_braceleft,
+    XK_bar, XK_braceright, XK_asciitilde, XK_BackSpace,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    NoSymbol, NoSymbol, NoSymbol, NoSymbol,
+    XK_nobreakspace, XK_exclamdown, XK_cent, XK_sterling,
+    XK_currency, XK_yen, XK_brokenbar, XK_section,
+    XK_diaeresis, XK_copyright, XK_ordfeminine, XK_guillemotleft,
+    XK_notsign, XK_hyphen, XK_registered, XK_macron,
+    XK_degree, XK_plusminus, XK_twosuperior, XK_threesuperior,
+    XK_acute, XK_mu, XK_paragraph, XK_periodcentered,
+    XK_cedilla, XK_onesuperior, XK_masculine, XK_guillemotright,
+    XK_onequarter, XK_onehalf, XK_threequarters, XK_questiondown,
+    XK_Agrave, XK_Aacute, XK_Acircumflex, XK_Atilde,
+    XK_Adiaeresis, XK_Aring, XK_AE, XK_Ccedilla,
+    XK_Egrave, XK_Eacute, XK_Ecircumflex, XK_Ediaeresis,
+    XK_Igrave, XK_Iacute, XK_Icircumflex, XK_Idiaeresis,
+    XK_ETH, XK_Ntilde, XK_Ograve, XK_Oacute,
+    XK_Ocircumflex, XK_Otilde, XK_Odiaeresis, XK_multiply,
+    XK_Ooblique, XK_Ugrave, XK_Uacute, XK_Ucircumflex,
+    XK_Udiaeresis, XK_Yacute, XK_THORN, XK_ssharp,
+    XK_agrave, XK_aacute, XK_acircumflex, XK_atilde,
+    XK_adiaeresis, XK_aring, XK_ae, XK_ccedilla,
+    XK_egrave, XK_eacute, XK_ecircumflex, XK_ediaeresis,
+    XK_igrave, XK_iacute, XK_icircumflex, XK_idiaeresis,
+    XK_eth, XK_ntilde, XK_ograve, XK_oacute,
+    XK_ocircumflex, XK_otilde, XK_odiaeresis, XK_division,
+    XK_oslash, XK_ugrave, XK_uacute, XK_ucircumflex,
+    XK_udiaeresis, XK_yacute, XK_thorn, XK_ydiaeresis
 };
 
 /*
@@ -135,80 +135,78 @@ static const KeySym linux_to_x[256] = {
    corresponds to the Xkb keymap.
 */
 #if 0
-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 */
+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
 
-static unsigned char tbl[KD_MAX_WIDTH] =
-{
+static unsigned char tbl[KD_MAX_WIDTH] = {
     0,
     1 << KG_SHIFT,
     (1 << KG_ALTGR),
@@ -217,15 +215,15 @@ static unsigned char tbl[KD_MAX_WIDTH] =
 #endif
 
 static void
-readKernelMapping(KdKeyboardInfo *ki)
+readKernelMapping(KdKeyboardInfo * ki)
 {
 #if 0
-    KeySym	    *k;
-    int		    i, j;
-    struct kbentry  kbe;
-    int		    minKeyCode, maxKeyCode;
-    int		    row;
-    int             fd;
+    KeySym *k;
+    int i, j;
+    struct kbentry kbe;
+    int minKeyCode, maxKeyCode;
+    int row;
+    int fd;
 
     if (!ki)
         return;
@@ -236,252 +234,248 @@ readKernelMapping(KdKeyboardInfo *ki)
     maxKeyCode = 0;
     row = 0;
     ki->keySyms.mapWidth = KD_MAX_WIDTH;
-    for (i = 0; i < NR_KEYS && row < KD_MAX_LENGTH; ++i)
-    {
+    for (i = 0; i < NR_KEYS && row < KD_MAX_LENGTH; ++i) {
         kbe.kb_index = LNX_KEY_INDEX(i);
 
         k = ki->keySyms.map + row * ki->keySyms.mapWidth;
 
-	for (j = 0; j < ki->keySyms.mapWidth; ++j)
-	{
-	    unsigned short kval;
-
-	    k[j] = NoSymbol;
-
-	    kbe.kb_table = tbl[j];
-	    kbe.kb_value = 0;
-	    if (ioctl(fd, KDGKBENT, &kbe))
-		continue;
-
-	    kval = KVAL(kbe.kb_value);
-	    switch (KTYP(kbe.kb_value))
-	    {
-	    case KT_LATIN:
-	    case KT_LETTER:
-		k[j] = linux_to_x[kval];
-		break;
-
-	    case KT_FN:
-		if (kval <= 19)
-		    k[j] = XK_F1 + kval;
-		else switch (kbe.kb_value)
-		{
-		case K_FIND:
-		    k[j] = XK_Home; /* or XK_Find */
-		    break;
-		case K_INSERT:
-		    k[j] = XK_Insert;
-		    break;
-		case K_REMOVE:
-		    k[j] = XK_Delete;
-		    break;
-		case K_SELECT:
-		    k[j] = XK_End; /* or XK_Select */
-		    break;
-		case K_PGUP:
-		    k[j] = XK_Prior;
-		    break;
-		case K_PGDN:
-		    k[j] = XK_Next;
-		    break;
-		case K_HELP:
-		    k[j] = XK_Help;
-		    break;
-		case K_DO:
-		    k[j] = XK_Execute;
-		    break;
-		case K_PAUSE:
-		    k[j] = XK_Pause;
-		    break;
-		case K_MACRO:
-		    k[j] = XK_Menu;
-		    break;
-		default:
-		    break;
-		}
-		break;
-
-	    case KT_SPEC:
-		switch (kbe.kb_value)
-		{
-		case K_ENTER:
-		    k[j] = XK_Return;
-		    break;
-		case K_BREAK:
-		    k[j] = XK_Break;
-		    break;
-		case K_CAPS:
-		    k[j] = XK_Caps_Lock;
-		    break;
-		case K_NUM:
-		    k[j] = XK_Num_Lock;
-		    break;
-		case K_HOLD:
-		    k[j] = XK_Scroll_Lock;
-		    break;
-		case K_COMPOSE:
-		    k[j] = XK_Multi_key;
-		    break;
-		default:
-		    break;
-		}
-		break;
-
-	    case KT_PAD:
-		switch (kbe.kb_value)
-		{
-		case K_PPLUS:
-		    k[j] = XK_KP_Add;
-		    break;
-		case K_PMINUS:
-		    k[j] = XK_KP_Subtract;
-		    break;
-		case K_PSTAR:
-		    k[j] = XK_KP_Multiply;
-		    break;
-		case K_PSLASH:
-		    k[j] = XK_KP_Divide;
-		    break;
-		case K_PENTER:
-		    k[j] = XK_KP_Enter;
-		    break;
-		case K_PCOMMA:
-		    k[j] = XK_KP_Separator;
-		    break;
-		case K_PDOT:
-		    k[j] = XK_KP_Decimal;
-		    break;
-		case K_PPLUSMINUS:
-		    k[j] = XK_KP_Subtract;
-		    break;
-		default:
-		    if (kval <= 9)
-			k[j] = XK_KP_0 + kval;
-		    break;
-		}
-		break;
-
-		/*
-		 * KT_DEAD keys are for accelerated diacritical creation.
-		 */
-	    case KT_DEAD:
-		switch (kbe.kb_value)
-		{
-		case K_DGRAVE:
-		    k[j] = XK_dead_grave;
-		    break;
-		case K_DACUTE:
-		    k[j] = XK_dead_acute;
-		    break;
-		case K_DCIRCM:
-		    k[j] = XK_dead_circumflex;
-		    break;
-		case K_DTILDE:
-		    k[j] = XK_dead_tilde;
-		    break;
-		case K_DDIERE:
-		    k[j] = XK_dead_diaeresis;
-		    break;
-		}
-		break;
-
-	    case KT_CUR:
-		switch (kbe.kb_value)
-		{
-		case K_DOWN:
-		    k[j] = XK_Down;
-		    break;
-		case K_LEFT:
-		    k[j] = XK_Left;
-		    break;
-		case K_RIGHT:
-		    k[j] = XK_Right;
-		    break;
-		case K_UP:
-		    k[j] = XK_Up;
-		    break;
-		}
-		break;
-
-	    case KT_SHIFT:
-		switch (kbe.kb_value)
-		{
-		case K_ALTGR:
-		    k[j] = XK_Mode_switch;
-		    break;
-		case K_ALT:
-		    k[j] = (kbe.kb_index == 0x64 ?
-			  XK_Alt_R : XK_Alt_L);
-		    break;
-		case K_CTRL:
-		    k[j] = (kbe.kb_index == 0x61 ?
-			  XK_Control_R : XK_Control_L);
-		    break;
-		case K_CTRLL:
-		    k[j] = XK_Control_L;
-		    break;
-		case K_CTRLR:
-		    k[j] = XK_Control_R;
-		    break;
-		case K_SHIFT:
-		    k[j] = (kbe.kb_index == 0x36 ?
-			  XK_Shift_R : XK_Shift_L);
-		    break;
-		case K_SHIFTL:
-		    k[j] = XK_Shift_L;
-		    break;
-		case K_SHIFTR:
-		    k[j] = XK_Shift_R;
-		    break;
-		default:
-		    break;
-		}
-		break;
-
-		/*
-		 * KT_ASCII keys accumulate a 3 digit decimal number that gets
-		 * emitted when the shift state changes. We can't emulate that.
-		 */
-	    case KT_ASCII:
-		break;
-
-	    case KT_LOCK:
-		if (kbe.kb_value == K_SHIFTLOCK)
-		    k[j] = XK_Shift_Lock;
-		break;
+        for (j = 0; j < ki->keySyms.mapWidth; ++j) {
+            unsigned short kval;
+
+            k[j] = NoSymbol;
+
+            kbe.kb_table = tbl[j];
+            kbe.kb_value = 0;
+            if (ioctl(fd, KDGKBENT, &kbe))
+                continue;
+
+            kval = KVAL(kbe.kb_value);
+            switch (KTYP(kbe.kb_value)) {
+            case KT_LATIN:
+            case KT_LETTER:
+                k[j] = linux_to_x[kval];
+                break;
+
+            case KT_FN:
+                if (kval <= 19)
+                    k[j] = XK_F1 + kval;
+                else
+                    switch (kbe.kb_value) {
+                    case K_FIND:
+                        k[j] = XK_Home; /* or XK_Find */
+                        break;
+                    case K_INSERT:
+                        k[j] = XK_Insert;
+                        break;
+                    case K_REMOVE:
+                        k[j] = XK_Delete;
+                        break;
+                    case K_SELECT:
+                        k[j] = XK_End;  /* or XK_Select */
+                        break;
+                    case K_PGUP:
+                        k[j] = XK_Prior;
+                        break;
+                    case K_PGDN:
+                        k[j] = XK_Next;
+                        break;
+                    case K_HELP:
+                        k[j] = XK_Help;
+                        break;
+                    case K_DO:
+                        k[j] = XK_Execute;
+                        break;
+                    case K_PAUSE:
+                        k[j] = XK_Pause;
+                        break;
+                    case K_MACRO:
+                        k[j] = XK_Menu;
+                        break;
+                    default:
+                        break;
+                    }
+                break;
+
+            case KT_SPEC:
+                switch (kbe.kb_value) {
+                case K_ENTER:
+                    k[j] = XK_Return;
+                    break;
+                case K_BREAK:
+                    k[j] = XK_Break;
+                    break;
+                case K_CAPS:
+                    k[j] = XK_Caps_Lock;
+                    break;
+                case K_NUM:
+                    k[j] = XK_Num_Lock;
+                    break;
+                case K_HOLD:
+                    k[j] = XK_Scroll_Lock;
+                    break;
+                case K_COMPOSE:
+                    k[j] = XK_Multi_key;
+                    break;
+                default:
+                    break;
+                }
+                break;
+
+            case KT_PAD:
+                switch (kbe.kb_value) {
+                case K_PPLUS:
+                    k[j] = XK_KP_Add;
+                    break;
+                case K_PMINUS:
+                    k[j] = XK_KP_Subtract;
+                    break;
+                case K_PSTAR:
+                    k[j] = XK_KP_Multiply;
+                    break;
+                case K_PSLASH:
+                    k[j] = XK_KP_Divide;
+                    break;
+                case K_PENTER:
+                    k[j] = XK_KP_Enter;
+                    break;
+                case K_PCOMMA:
+                    k[j] = XK_KP_Separator;
+                    break;
+                case K_PDOT:
+                    k[j] = XK_KP_Decimal;
+                    break;
+                case K_PPLUSMINUS:
+                    k[j] = XK_KP_Subtract;
+                    break;
+                default:
+                    if (kval <= 9)
+                        k[j] = XK_KP_0 + kval;
+                    break;
+                }
+                break;
+
+                /*
+                 * KT_DEAD keys are for accelerated diacritical creation.
+                 */
+            case KT_DEAD:
+                switch (kbe.kb_value) {
+                case K_DGRAVE:
+                    k[j] = XK_dead_grave;
+                    break;
+                case K_DACUTE:
+                    k[j] = XK_dead_acute;
+                    break;
+                case K_DCIRCM:
+                    k[j] = XK_dead_circumflex;
+                    break;
+                case K_DTILDE:
+                    k[j] = XK_dead_tilde;
+                    break;
+                case K_DDIERE:
+                    k[j] = XK_dead_diaeresis;
+                    break;
+                }
+                break;
+
+            case KT_CUR:
+                switch (kbe.kb_value) {
+                case K_DOWN:
+                    k[j] = XK_Down;
+                    break;
+                case K_LEFT:
+                    k[j] = XK_Left;
+                    break;
+                case K_RIGHT:
+                    k[j] = XK_Right;
+                    break;
+                case K_UP:
+                    k[j] = XK_Up;
+                    break;
+                }
+                break;
+
+            case KT_SHIFT:
+                switch (kbe.kb_value) {
+                case K_ALTGR:
+                    k[j] = XK_Mode_switch;
+                    break;
+                case K_ALT:
+                    k[j] = (kbe.kb_index == 0x64 ? XK_Alt_R : XK_Alt_L);
+                    break;
+                case K_CTRL:
+                    k[j] = (kbe.kb_index == 0x61 ? XK_Control_R : XK_Control_L);
+                    break;
+                case K_CTRLL:
+                    k[j] = XK_Control_L;
+                    break;
+                case K_CTRLR:
+                    k[j] = XK_Control_R;
+                    break;
+                case K_SHIFT:
+                    k[j] = (kbe.kb_index == 0x36 ? XK_Shift_R : XK_Shift_L);
+                    break;
+                case K_SHIFTL:
+                    k[j] = XK_Shift_L;
+                    break;
+                case K_SHIFTR:
+                    k[j] = XK_Shift_R;
+                    break;
+                default:
+                    break;
+                }
+                break;
+
+                /*
+                 * KT_ASCII keys accumulate a 3 digit decimal number that gets
+                 * emitted when the shift state changes. We can't emulate that.
+                 */
+            case KT_ASCII:
+                break;
+
+            case KT_LOCK:
+                if (kbe.kb_value == K_SHIFTLOCK)
+                    k[j] = XK_Shift_Lock;
+                break;
 
 #ifdef KT_X
-	    case KT_X:
-		/* depends on new keyboard symbols in file linux/keyboard.h */
-		if(kbe.kb_value == K_XMENU) k[j] = XK_Menu;
-		if(kbe.kb_value == K_XTELEPHONE) k[j] = XK_telephone;
-		break;
+            case KT_X:
+                /* depends on new keyboard symbols in file linux/keyboard.h */
+                if (kbe.kb_value == K_XMENU)
+                    k[j] = XK_Menu;
+                if (kbe.kb_value == K_XTELEPHONE)
+                    k[j] = XK_telephone;
+                break;
 #endif
 #ifdef KT_XF
-	    case KT_XF:
-		/* special linux keysyms which map directly to XF86 keysyms */
-		k[j] = (kbe.kb_value & 0xFF) + 0x1008FF00;
-		break;
+            case KT_XF:
+                /* special linux keysyms which map directly to XF86 keysyms */
+                k[j] = (kbe.kb_value & 0xFF) + 0x1008FF00;
+                break;
 #endif
 
-	    default:
-		break;
-	    }
-	    if (i < minKeyCode)
-		minKeyCode = i;
-	    if (i > maxKeyCode)
-		maxKeyCode = i;
-	}
-
-	if (minKeyCode == NR_KEYS)
-	    continue;
-
-	if (k[3] == k[2]) k[3] = NoSymbol;
-	if (k[2] == k[1]) k[2] = NoSymbol;
-	if (k[1] == k[0]) k[1] = NoSymbol;
-	if (k[0] == k[2] && k[1] == k[3]) k[2] = k[3] = NoSymbol;
-	if (k[3] == k[0] && k[2] == k[1] && k[2] == NoSymbol) k[3] =NoSymbol;
-	row++;
+            default:
+                break;
+            }
+            if (i < minKeyCode)
+                minKeyCode = i;
+            if (i > maxKeyCode)
+                maxKeyCode = i;
+        }
+
+        if (minKeyCode == NR_KEYS)
+            continue;
+
+        if (k[3] == k[2])
+            k[3] = NoSymbol;
+        if (k[2] == k[1])
+            k[2] = NoSymbol;
+        if (k[1] == k[0])
+            k[1] = NoSymbol;
+        if (k[0] == k[2] && k[1] == k[3])
+            k[2] = k[3] = NoSymbol;
+        if (k[3] == k[0] && k[2] == k[1] && k[2] == NoSymbol)
+            k[3] = NoSymbol;
+        row++;
     }
     ki->minScanCode = minKeyCode;
     ki->maxScanCode = maxKeyCode;
@@ -551,142 +545,166 @@ readKernelMapping(KdKeyboardInfo *ki)
 #define KEY_KP_DEC       /* KP_DEC                0x73  */  115
 
 static void
-LinuxKeyboardRead (int fd, void *closure)
+LinuxKeyboardRead(int fd, void *closure)
 {
-    unsigned char   buf[256], *b;
-    int		    n;
-    unsigned char   prefix = 0, scancode = 0;
+    unsigned char buf[256], *b;
+    int n;
+    unsigned char prefix = 0, scancode = 0;
 
-    while ((n = read (fd, buf, sizeof (buf))) > 0) {
-	b = buf;
-	while (n--) {
+    while ((n = read(fd, buf, sizeof(buf))) > 0) {
+        b = buf;
+        while (n--) {
             /*
              * 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;
-                    /* swallow this up */
-                    b++;
-                    continue;
+            if (!prefix && ((b[0] & 0x7f) == KEY_Prefix0)) {
+                prefix = KEY_Prefix0;
+                /* swallow this up */
+                b++;
+                continue;
             }
-            else if (!prefix && ((b[0] & 0x7f) == KEY_Prefix1))
-            {
-                    prefix = KEY_Prefix1;
-                    /* swallow this up */
-                    b++;
-                    continue;
+            else if (!prefix && ((b[0] & 0x7f) == KEY_Prefix1)) {
+                prefix = KEY_Prefix1;
+                /* swallow this up */
+                b++;
+                continue;
             }
             scancode = b[0] & 0x7f;
 
             switch (prefix) {
-                    /* from xf86Events.c */
-                    case KEY_Prefix0:
-                    {
-                        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:
-                                 /*
-                                  * "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;
-                    }
+                /* from xf86Events.c */
+            case KEY_Prefix0:
+            {
+                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:
+                    /*
+                     * "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 */
-                        b++;
-                        prefix = 0;
-                        continue;
-                    }
+            case KEY_Prefix1:
+            {
+                /* we do no handle these */
+                b++;
+                prefix = 0;
+                continue;
+            }
 
-                    default: /* should not happen*/
-                    case 0: /* do nothing */
-                        ;
+            default:           /* should not happen */
+            case 0:            /* do nothing */
+                ;
             }
 
             prefix = 0;
-	    KdEnqueueKeyboardEvent (closure, scancode, b[0] & 0x80);
-	    b++;
-	}
+            KdEnqueueKeyboardEvent(closure, scancode, b[0] & 0x80);
+            b++;
+        }
     }
 }
 
-static int		LinuxKbdTrans;
-static struct termios	LinuxTermios;
+static int LinuxKbdTrans;
+static struct termios LinuxTermios;
 
 static Status
-LinuxKeyboardEnable (KdKeyboardInfo *ki)
+LinuxKeyboardEnable(KdKeyboardInfo * ki)
 {
     struct termios nTty;
-    unsigned char   buf[256];
-    int		    n;
-    int             fd;
+    unsigned char buf[256];
+    int n;
+    int fd;
 
     if (!ki)
         return !Success;
@@ -694,30 +712,29 @@ LinuxKeyboardEnable (KdKeyboardInfo *ki)
     fd = LinuxConsoleFd;
     ki->driverPrivate = (void *) (intptr_t) fd;
 
-    ioctl (fd, KDGKBMODE, &LinuxKbdTrans);
-    tcgetattr (fd, &LinuxTermios);
+    ioctl(fd, KDGKBMODE, &LinuxKbdTrans);
+    tcgetattr(fd, &LinuxTermios);
     ioctl(fd, KDSKBMODE, K_RAW);
     nTty = LinuxTermios;
     nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
     nTty.c_oflag = 0;
     nTty.c_cflag = CREAD | CS8;
     nTty.c_lflag = 0;
-    nTty.c_cc[VTIME]=0;
-    nTty.c_cc[VMIN]=1;
+    nTty.c_cc[VTIME] = 0;
+    nTty.c_cc[VMIN] = 1;
     cfsetispeed(&nTty, 9600);
     cfsetospeed(&nTty, 9600);
     tcsetattr(fd, TCSANOW, &nTty);
     /*
      * Flush any pending keystrokes
      */
-    while ((n = read (fd, buf, sizeof (buf))) > 0)
-	;
-    KdRegisterFd (fd, LinuxKeyboardRead, ki);
+    while ((n = read(fd, buf, sizeof(buf))) > 0);
+    KdRegisterFd(fd, LinuxKeyboardRead, ki);
     return Success;
 }
 
 static void
-LinuxKeyboardDisable (KdKeyboardInfo *ki)
+LinuxKeyboardDisable(KdKeyboardInfo * ki)
 {
     int fd;
 
@@ -732,7 +749,7 @@ LinuxKeyboardDisable (KdKeyboardInfo *ki)
 }
 
 static Status
-LinuxKeyboardInit (KdKeyboardInfo *ki)
+LinuxKeyboardInit(KdKeyboardInfo * ki)
 {
     if (!ki)
         return !Success;
@@ -742,18 +759,18 @@ LinuxKeyboardInit (KdKeyboardInfo *ki)
     free(ki->name);
     ki->name = strdup("Linux console keyboard");
 
-    readKernelMapping (ki);
+    readKernelMapping(ki);
 
     return Success;
 }
 
 static void
-LinuxKeyboardLeds (KdKeyboardInfo *ki, int leds)
+LinuxKeyboardLeds(KdKeyboardInfo * ki, int leds)
 {
     if (!ki)
         return;
 
-    ioctl ((int)(intptr_t)ki->driverPrivate, KDSETLED, leds & 7);
+    ioctl((int) (intptr_t) ki->driverPrivate, KDSETLED, leds & 7);
 }
 
 KdKeyboardDriver LinuxKeyboardDriver = {
diff --git a/hw/kdrive/linux/linux.c b/hw/kdrive/linux/linux.c
index 194e7cd59..498c2398d 100644
--- a/hw/kdrive/linux/linux.c
+++ b/hw/kdrive/linux/linux.c
@@ -34,51 +34,51 @@
 #include <linux/apm_bios.h>
 
 #ifdef KDRIVE_MOUSE
-extern KdPointerDriver	LinuxMouseDriver;
-extern KdPointerDriver	Ps2MouseDriver;
-extern KdPointerDriver	MsMouseDriver;
+extern KdPointerDriver LinuxMouseDriver;
+extern KdPointerDriver Ps2MouseDriver;
+extern KdPointerDriver MsMouseDriver;
 #endif
 #ifdef TSLIB
-extern KdPointerDriver	TsDriver;
+extern KdPointerDriver TsDriver;
 #endif
 #ifdef KDRIVE_EVDEV
-extern KdPointerDriver	LinuxEvdevMouseDriver;
+extern KdPointerDriver LinuxEvdevMouseDriver;
 extern KdKeyboardDriver LinuxEvdevKeyboardDriver;
 #endif
 #ifdef KDRIVE_KBD
-extern KdKeyboardDriver	LinuxKeyboardDriver;
+extern KdKeyboardDriver LinuxKeyboardDriver;
 #endif
 
-static int  vtno;
-int  LinuxConsoleFd;
-int  LinuxApmFd = -1;
-static int  activeVT;
+static int vtno;
+int LinuxConsoleFd;
+int LinuxApmFd = -1;
+static int activeVT;
 static Bool enabled;
 
 static void
-LinuxVTRequest (int sig)
+LinuxVTRequest(int sig)
 {
     kdSwitchPending = TRUE;
 }
 
 /* Check before chowning -- this avoids touching the file system */
 static void
-LinuxCheckChown (char *file)
+LinuxCheckChown(char *file)
 {
-    struct stat	    st;
-    __uid_t	    u;
-    __gid_t	    g;
-
-    if (stat (file, &st) < 0)
-	return;
-    u = getuid ();
-    g = getgid ();
+    struct stat st;
+    __uid_t u;
+    __gid_t g;
+
+    if (stat(file, &st) < 0)
+        return;
+    u = getuid();
+    g = getgid();
     if (st.st_uid != u || st.st_gid != g)
-	chown (file, u, g);
+        chown(file, u, g);
 }
 
 static int
-LinuxInit (void)
+LinuxInit(void)
 {
     int fd = -1;
     char vtname[11];
@@ -86,39 +86,31 @@ LinuxInit (void)
 
     LinuxConsoleFd = -1;
     /* check if we're run with euid==0 */
-    if (geteuid() != 0)
-    {
-	FatalError("LinuxInit: Server must be suid root\n");
+    if (geteuid() != 0) {
+        FatalError("LinuxInit: Server must be suid root\n");
     }
 
     if (kdVirtualTerminal >= 0)
-	vtno = kdVirtualTerminal;
-    else
-    {
-	if ((fd = open("/dev/tty0",O_WRONLY,0)) < 0)
-	{
-	    FatalError(
-		       "LinuxInit: Cannot open /dev/tty0 (%s)\n",
-		       strerror(errno));
-	}
-	if ((ioctl(fd, VT_OPENQRY, &vtno) < 0) ||
-	    (vtno == -1))
-	{
-	    FatalError("xf86OpenConsole: Cannot find a free VT\n");
-	}
-	close(fd);
+        vtno = kdVirtualTerminal;
+    else {
+        if ((fd = open("/dev/tty0", O_WRONLY, 0)) < 0) {
+            FatalError("LinuxInit: Cannot open /dev/tty0 (%s)\n",
+                       strerror(errno));
+        }
+        if ((ioctl(fd, VT_OPENQRY, &vtno) < 0) || (vtno == -1)) {
+            FatalError("xf86OpenConsole: Cannot find a free VT\n");
+        }
+        close(fd);
     }
 
-    snprintf(vtname,sizeof(vtname),"/dev/tty%d",vtno); /* /dev/tty1-64 */
+    snprintf(vtname, sizeof(vtname), "/dev/tty%d", vtno);       /* /dev/tty1-64 */
 
-    if ((LinuxConsoleFd = open(vtname, O_RDWR|O_NDELAY, 0)) < 0)
-    {
-	FatalError("LinuxInit: Cannot open %s (%s)\n",
-		   vtname, strerror(errno));
+    if ((LinuxConsoleFd = open(vtname, O_RDWR | O_NDELAY, 0)) < 0) {
+        FatalError("LinuxInit: Cannot open %s (%s)\n", vtname, strerror(errno));
     }
 
     /* change ownership of the vt */
-    LinuxCheckChown (vtname);
+    LinuxCheckChown(vtname);
 
     /*
      * the current VT device we're running on is not "console", we want
@@ -126,109 +118,100 @@ LinuxInit (void)
      *
      * Why is this needed?
      */
-    LinuxCheckChown ("/dev/tty0");
+    LinuxCheckChown("/dev/tty0");
     /*
      * Linux doesn't switch to an active vt after the last close of a vt,
      * so we do this ourselves by remembering which is active now.
      */
-    memset (&vts, '\0', sizeof (vts));	/* valgrind */
-    if (ioctl(LinuxConsoleFd, VT_GETSTATE, &vts) == 0)
-    {
-	activeVT = vts.v_active;
+    memset(&vts, '\0', sizeof(vts));    /* valgrind */
+    if (ioctl(LinuxConsoleFd, VT_GETSTATE, &vts) == 0) {
+        activeVT = vts.v_active;
     }
 
     return 1;
 }
 
 static void
-LinuxSetSwitchMode (int mode)
+LinuxSetSwitchMode(int mode)
 {
-    struct sigaction	act;
-    struct vt_mode	VT;
+    struct sigaction act;
+    struct vt_mode VT;
 
-    if (ioctl(LinuxConsoleFd, VT_GETMODE, &VT) < 0)
-    {
-	FatalError ("LinuxInit: VT_GETMODE failed\n");
+    if (ioctl(LinuxConsoleFd, VT_GETMODE, &VT) < 0) {
+        FatalError("LinuxInit: VT_GETMODE failed\n");
     }
 
-    if (mode == VT_PROCESS)
-    {
-	act.sa_handler = LinuxVTRequest;
-	sigemptyset (&act.sa_mask);
-	act.sa_flags = 0;
-	sigaction (SIGUSR1, &act, 0);
+    if (mode == VT_PROCESS) {
+        act.sa_handler = LinuxVTRequest;
+        sigemptyset(&act.sa_mask);
+        act.sa_flags = 0;
+        sigaction(SIGUSR1, &act, 0);
 
-	VT.mode = mode;
-	VT.relsig = SIGUSR1;
-	VT.acqsig = SIGUSR1;
+        VT.mode = mode;
+        VT.relsig = SIGUSR1;
+        VT.acqsig = SIGUSR1;
     }
-    else
-    {
-	act.sa_handler = SIG_IGN;
-	sigemptyset (&act.sa_mask);
-	act.sa_flags = 0;
-	sigaction (SIGUSR1, &act, 0);
-
-	VT.mode = mode;
-	VT.relsig = 0;
-	VT.acqsig = 0;
+    else {
+        act.sa_handler = SIG_IGN;
+        sigemptyset(&act.sa_mask);
+        act.sa_flags = 0;
+        sigaction(SIGUSR1, &act, 0);
+
+        VT.mode = mode;
+        VT.relsig = 0;
+        VT.acqsig = 0;
     }
-    if (ioctl(LinuxConsoleFd, VT_SETMODE, &VT) < 0)
-    {
-	FatalError("LinuxInit: VT_SETMODE failed\n");
+    if (ioctl(LinuxConsoleFd, VT_SETMODE, &VT) < 0) {
+        FatalError("LinuxInit: VT_SETMODE failed\n");
     }
 }
 
 static void
-LinuxApmBlock (pointer blockData, OSTimePtr pTimeout, pointer pReadmask)
+LinuxApmBlock(pointer blockData, OSTimePtr pTimeout, pointer pReadmask)
 {
 }
 
 static Bool LinuxApmRunning;
 
 static void
-LinuxApmWakeup (pointer blockData, int result, pointer pReadmask)
+LinuxApmWakeup(pointer blockData, int result, pointer pReadmask)
 {
-    fd_set  *readmask = (fd_set *) pReadmask;
-
-    if (result > 0 && LinuxApmFd >= 0 && FD_ISSET (LinuxApmFd, readmask))
-    {
-	apm_event_t event;
-	Bool	    running = LinuxApmRunning;
-	int	    cmd = APM_IOC_SUSPEND;
-
-	while (read (LinuxApmFd, &event, sizeof (event)) == sizeof (event))
-	{
-	    switch (event) {
-	    case APM_SYS_STANDBY:
-	    case APM_USER_STANDBY:
-		running = FALSE;
-		cmd = APM_IOC_STANDBY;
-		break;
-	    case APM_SYS_SUSPEND:
-	    case APM_USER_SUSPEND:
-	    case APM_CRITICAL_SUSPEND:
-		running = FALSE;
-		cmd = APM_IOC_SUSPEND;
-		break;
-	    case APM_NORMAL_RESUME:
-	    case APM_CRITICAL_RESUME:
-	    case APM_STANDBY_RESUME:
-		running = TRUE;
-		break;
-	    }
-	}
-	if (running && !LinuxApmRunning)
-	{
-	    KdResume ();
-	    LinuxApmRunning = TRUE;
-	}
-	else if (!running && LinuxApmRunning)
-	{
-	    KdSuspend ();
-	    LinuxApmRunning = FALSE;
-	    ioctl (LinuxApmFd, cmd, 0);
-	}
+    fd_set *readmask = (fd_set *) pReadmask;
+
+    if (result > 0 && LinuxApmFd >= 0 && FD_ISSET(LinuxApmFd, readmask)) {
+        apm_event_t event;
+        Bool running = LinuxApmRunning;
+        int cmd = APM_IOC_SUSPEND;
+
+        while (read(LinuxApmFd, &event, sizeof(event)) == sizeof(event)) {
+            switch (event) {
+            case APM_SYS_STANDBY:
+            case APM_USER_STANDBY:
+                running = FALSE;
+                cmd = APM_IOC_STANDBY;
+                break;
+            case APM_SYS_SUSPEND:
+            case APM_USER_SUSPEND:
+            case APM_CRITICAL_SUSPEND:
+                running = FALSE;
+                cmd = APM_IOC_SUSPEND;
+                break;
+            case APM_NORMAL_RESUME:
+            case APM_CRITICAL_RESUME:
+            case APM_STANDBY_RESUME:
+                running = TRUE;
+                break;
+            }
+        }
+        if (running && !LinuxApmRunning) {
+            KdResume();
+            LinuxApmRunning = TRUE;
+        }
+        else if (!running && LinuxApmRunning) {
+            KdSuspend();
+            LinuxApmRunning = FALSE;
+            ioctl(LinuxApmFd, cmd, 0);
+        }
     }
 }
 
@@ -239,127 +222,115 @@ LinuxApmWakeup (pointer blockData, int result, pointer pReadmask)
 #endif
 
 static void
-LinuxEnable (void)
+LinuxEnable(void)
 {
     if (enabled)
-	return;
-    if (kdSwitchPending)
-    {
-	kdSwitchPending = FALSE;
-	ioctl (LinuxConsoleFd, VT_RELDISP, VT_ACKACQ);
+        return;
+    if (kdSwitchPending) {
+        kdSwitchPending = FALSE;
+        ioctl(LinuxConsoleFd, VT_RELDISP, VT_ACKACQ);
     }
     /*
      * Open the APM driver
      */
-    LinuxApmFd = open ("/dev/apm_bios", 2);
+    LinuxApmFd = open("/dev/apm_bios", 2);
     if (LinuxApmFd < 0 && errno == ENOENT)
-	LinuxApmFd = open ("/dev/misc/apm_bios", 2);
-    if (LinuxApmFd >= 0)
-    {
-	LinuxApmRunning = TRUE;
-	fcntl (LinuxApmFd, F_SETFL, fcntl (LinuxApmFd, F_GETFL) | NOBLOCK);
-	RegisterBlockAndWakeupHandlers (LinuxApmBlock, LinuxApmWakeup, 0);
-	AddEnabledDevice (LinuxApmFd);
+        LinuxApmFd = open("/dev/misc/apm_bios", 2);
+    if (LinuxApmFd >= 0) {
+        LinuxApmRunning = TRUE;
+        fcntl(LinuxApmFd, F_SETFL, fcntl(LinuxApmFd, F_GETFL) | NOBLOCK);
+        RegisterBlockAndWakeupHandlers(LinuxApmBlock, LinuxApmWakeup, 0);
+        AddEnabledDevice(LinuxApmFd);
     }
 
     /*
      * now get the VT
      */
-    LinuxSetSwitchMode (VT_AUTO);
-    if (ioctl(LinuxConsoleFd, VT_ACTIVATE, vtno) != 0)
-    {
-	FatalError("LinuxInit: VT_ACTIVATE failed\n");
+    LinuxSetSwitchMode(VT_AUTO);
+    if (ioctl(LinuxConsoleFd, VT_ACTIVATE, vtno) != 0) {
+        FatalError("LinuxInit: VT_ACTIVATE failed\n");
     }
-    if (ioctl(LinuxConsoleFd, VT_WAITACTIVE, vtno) != 0)
-    {
-	FatalError("LinuxInit: VT_WAITACTIVE failed\n");
+    if (ioctl(LinuxConsoleFd, VT_WAITACTIVE, vtno) != 0) {
+        FatalError("LinuxInit: VT_WAITACTIVE failed\n");
     }
-    LinuxSetSwitchMode (VT_PROCESS);
-    if (ioctl(LinuxConsoleFd, KDSETMODE, KD_GRAPHICS) < 0)
-    {
-	FatalError("LinuxInit: KDSETMODE KD_GRAPHICS failed\n");
+    LinuxSetSwitchMode(VT_PROCESS);
+    if (ioctl(LinuxConsoleFd, KDSETMODE, KD_GRAPHICS) < 0) {
+        FatalError("LinuxInit: KDSETMODE KD_GRAPHICS failed\n");
     }
     enabled = TRUE;
 }
 
 static void
-LinuxDisable (void)
+LinuxDisable(void)
 {
     ioctl(LinuxConsoleFd, KDSETMODE, KD_TEXT);  /* Back to text mode ... */
-    if (kdSwitchPending)
-    {
-	kdSwitchPending = FALSE;
-	ioctl (LinuxConsoleFd, VT_RELDISP, 1);
+    if (kdSwitchPending) {
+        kdSwitchPending = FALSE;
+        ioctl(LinuxConsoleFd, VT_RELDISP, 1);
     }
     enabled = FALSE;
-    if (LinuxApmFd >= 0)
-    {
-	RemoveBlockAndWakeupHandlers (LinuxApmBlock, LinuxApmWakeup, 0);
-	RemoveEnabledDevice (LinuxApmFd);
-	close (LinuxApmFd);
-	LinuxApmFd = -1;
+    if (LinuxApmFd >= 0) {
+        RemoveBlockAndWakeupHandlers(LinuxApmBlock, LinuxApmWakeup, 0);
+        RemoveEnabledDevice(LinuxApmFd);
+        close(LinuxApmFd);
+        LinuxApmFd = -1;
     }
 }
 
 static void
-LinuxFini (void)
+LinuxFini(void)
 {
-    struct vt_mode   VT;
-    struct vt_stat  vts;
-    int		    fd;
+    struct vt_mode VT;
+    struct vt_stat vts;
+    int fd;
 
     if (LinuxConsoleFd < 0)
-	return;
+        return;
 
-    if (ioctl(LinuxConsoleFd, VT_GETMODE, &VT) != -1)
-    {
-	VT.mode = VT_AUTO;
-	ioctl(LinuxConsoleFd, VT_SETMODE, &VT); /* set dflt vt handling */
+    if (ioctl(LinuxConsoleFd, VT_GETMODE, &VT) != -1) {
+        VT.mode = VT_AUTO;
+        ioctl(LinuxConsoleFd, VT_SETMODE, &VT); /* set dflt vt handling */
     }
-    memset (&vts, '\0', sizeof (vts));	/* valgrind */
-    ioctl (LinuxConsoleFd, VT_GETSTATE, &vts);
-    if (vtno == vts.v_active)
-    {
-	/*
-	 * Find a legal VT to switch to, either the one we started from
-	 * or the lowest active one that isn't ours
-	 */
-	if (activeVT < 0 ||
-	    activeVT == vts.v_active ||
-	    !(vts.v_state & (1 << activeVT)))
-	{
-	    for (activeVT = 1; activeVT < 16; activeVT++)
-		if (activeVT != vtno && (vts.v_state & (1 << activeVT)))
-		    break;
-	    if (activeVT == 16)
-		activeVT = -1;
-	}
-	/*
-	 * Perform a switch back to the active VT when we were started
-	 */
-	if (activeVT >= -1)
-	{
-	    ioctl (LinuxConsoleFd, VT_ACTIVATE, activeVT);
-	    ioctl (LinuxConsoleFd, VT_WAITACTIVE, activeVT);
-	    activeVT = -1;
-	}
+    memset(&vts, '\0', sizeof(vts));    /* valgrind */
+    ioctl(LinuxConsoleFd, VT_GETSTATE, &vts);
+    if (vtno == vts.v_active) {
+        /*
+         * Find a legal VT to switch to, either the one we started from
+         * or the lowest active one that isn't ours
+         */
+        if (activeVT < 0 ||
+            activeVT == vts.v_active || !(vts.v_state & (1 << activeVT))) {
+            for (activeVT = 1; activeVT < 16; activeVT++)
+                if (activeVT != vtno && (vts.v_state & (1 << activeVT)))
+                    break;
+            if (activeVT == 16)
+                activeVT = -1;
+        }
+        /*
+         * Perform a switch back to the active VT when we were started
+         */
+        if (activeVT >= -1) {
+            ioctl(LinuxConsoleFd, VT_ACTIVATE, activeVT);
+            ioctl(LinuxConsoleFd, VT_WAITACTIVE, activeVT);
+            activeVT = -1;
+        }
     }
-    close(LinuxConsoleFd);                /* make the vt-manager happy */
+    close(LinuxConsoleFd);      /* make the vt-manager happy */
     LinuxConsoleFd = -1;
-    fd = open ("/dev/tty0", O_RDWR|O_NDELAY, 0);
-    if (fd >= 0)
-    {
-	memset (&vts, '\0', sizeof (vts));	/* valgrind */
-	ioctl (fd, VT_GETSTATE, &vts);
-	if (ioctl (fd, VT_DISALLOCATE, vtno) < 0)
-	    fprintf (stderr, "Can't deallocate console %d %s\n", vtno, strerror(errno));
-	close (fd);
+    fd = open("/dev/tty0", O_RDWR | O_NDELAY, 0);
+    if (fd >= 0) {
+        memset(&vts, '\0', sizeof(vts));        /* valgrind */
+        ioctl(fd, VT_GETSTATE, &vts);
+        if (ioctl(fd, VT_DISALLOCATE, vtno) < 0)
+            fprintf(stderr, "Can't deallocate console %d %s\n", vtno,
+                    strerror(errno));
+        close(fd);
     }
     return;
 }
 
 void
-KdOsAddInputDrivers (void)
+KdOsAddInputDrivers(void)
 {
 #ifdef KDRIVE_MOUSE
     KdAddPointerDriver(&LinuxMouseDriver);
@@ -383,10 +354,10 @@ LinuxBell(int volume, int pitch, int duration)
 {
     if (volume && pitch)
         ioctl(LinuxConsoleFd, KDMKTONE, ((1193190 / pitch) & 0xffff) |
-              (((unsigned long)duration * volume / 50) << 16));
+              (((unsigned long) duration * volume / 50) << 16));
 }
 
-KdOsFuncs   LinuxFuncs = {
+KdOsFuncs LinuxFuncs = {
     .Init = LinuxInit,
     .Enable = LinuxEnable,
     .Disable = LinuxDisable,
@@ -395,7 +366,7 @@ KdOsFuncs   LinuxFuncs = {
 };
 
 void
-OsVendorInit (void)
+OsVendorInit(void)
 {
-    KdOsInit (&LinuxFuncs);
+    KdOsInit(&LinuxFuncs);
 }
diff --git a/hw/kdrive/linux/mouse.c b/hw/kdrive/linux/mouse.c
index 93c207817..c87507790 100644
--- a/hw/kdrive/linux/mouse.c
+++ b/hw/kdrive/linux/mouse.c
@@ -38,185 +38,176 @@
 #define MOUSE_TIMEOUT	100
 
 typedef struct _kbufio {
-    int		    fd;
-    unsigned char   buf[KBUFIO_SIZE];
-    int		    avail;
-    int		    used;
+    int fd;
+    unsigned char buf[KBUFIO_SIZE];
+    int avail;
+    int used;
 } Kbufio;
 
 static Bool
-MouseWaitForReadable (int fd, int timeout)
+MouseWaitForReadable(int fd, int timeout)
 {
-    fd_set	    set;
-    struct timeval  tv, *tp;
-    int		    n;
-    CARD32	    done;
-
-    done = GetTimeInMillis () + timeout;
-    for (;;)
-    {
-	FD_ZERO (&set);
-	FD_SET (fd, &set);
-	if (timeout == -1)
-	    tp = 0;
-	else
-	{
-	    tv.tv_sec = timeout / 1000;
-	    tv.tv_usec = (timeout % 1000) * 1000;
-	    tp = &tv;
-	}
-	n = select (fd + 1, &set, 0, 0, tp);
-	if (n > 0)
-	    return TRUE;
-	if (n < 0 && (errno == EAGAIN || errno == EINTR))
-	{
-	    timeout = (int) (done - GetTimeInMillis ());
-	    if (timeout > 0)
-		continue;
-	}
-	break;
+    fd_set set;
+    struct timeval tv, *tp;
+    int n;
+    CARD32 done;
+
+    done = GetTimeInMillis() + timeout;
+    for (;;) {
+        FD_ZERO(&set);
+        FD_SET(fd, &set);
+        if (timeout == -1)
+            tp = 0;
+        else {
+            tv.tv_sec = timeout / 1000;
+            tv.tv_usec = (timeout % 1000) * 1000;
+            tp = &tv;
+        }
+        n = select(fd + 1, &set, 0, 0, tp);
+        if (n > 0)
+            return TRUE;
+        if (n < 0 && (errno == EAGAIN || errno == EINTR)) {
+            timeout = (int) (done - GetTimeInMillis());
+            if (timeout > 0)
+                continue;
+        }
+        break;
     }
     return FALSE;
 }
 
 static int
-MouseReadByte (Kbufio *b, int timeout)
+MouseReadByte(Kbufio * b, int timeout)
 {
-    int	n;
-    if (b->avail <= b->used)
-    {
-	if (timeout && !MouseWaitForReadable (b->fd, timeout))
-	{
+    int n;
+
+    if (b->avail <= b->used) {
+        if (timeout && !MouseWaitForReadable(b->fd, timeout)) {
 #ifdef DEBUG_BYTES
-	    ErrorF ("\tTimeout %d\n", timeout);
+            ErrorF("\tTimeout %d\n", timeout);
 #endif
-	    return -1;
-	}
-	n = read (b->fd, b->buf, KBUFIO_SIZE);
-	if (n <= 0)
-	    return -1;
+            return -1;
+        }
+        n = read(b->fd, b->buf, KBUFIO_SIZE);
+        if (n <= 0)
+            return -1;
         b->avail = n;
         b->used = 0;
     }
 #ifdef DEBUG_BYTES
-    ErrorF ("\tget %02x\n", b->buf[b->used]);
+    ErrorF("\tget %02x\n", b->buf[b->used]);
 #endif
     return b->buf[b->used++];
 }
 
 #if NOTUSED
 static int
-MouseFlush (Kbufio *b, char *buf, int size)
+MouseFlush(Kbufio * b, char *buf, int size)
 {
-    CARD32  now = GetTimeInMillis ();
-    CARD32  done = now + 100;
-    int	    c;
-    int	    n = 0;
-
-    while ((c = MouseReadByte (b, done - now)) != -1)
-    {
-	if (buf)
-	{
-	    if (n == size)
-	    {
-		memmove (buf, buf + 1, size - 1);
-		n--;
-	    }
-	    buf[n++] = c;
-	}
-	now = GetTimeInMillis ();
-	if ((INT32) (now - done) >= 0)
-	    break;
+    CARD32 now = GetTimeInMillis();
+    CARD32 done = now + 100;
+    int c;
+    int n = 0;
+
+    while ((c = MouseReadByte(b, done - now)) != -1) {
+        if (buf) {
+            if (n == size) {
+                memmove(buf, buf + 1, size - 1);
+                n--;
+            }
+            buf[n++] = c;
+        }
+        now = GetTimeInMillis();
+        if ((INT32) (now - done) >= 0)
+            break;
     }
     return n;
 }
 
 static int
-MousePeekByte (Kbufio *b, int timeout)
+MousePeekByte(Kbufio * b, int timeout)
 {
-    int	    c;
+    int c;
 
-    c = MouseReadByte (b, timeout);
+    c = MouseReadByte(b, timeout);
     if (c != -1)
-	--b->used;
+        --b->used;
     return c;
 }
-#endif /* NOTUSED */
+#endif                          /* NOTUSED */
 
 static Bool
-MouseWaitForWritable (int fd, int timeout)
+MouseWaitForWritable(int fd, int timeout)
 {
-    fd_set	    set;
-    struct timeval  tv, *tp;
-    int		    n;
+    fd_set set;
+    struct timeval tv, *tp;
+    int n;
 
-    FD_ZERO (&set);
-    FD_SET (fd, &set);
+    FD_ZERO(&set);
+    FD_SET(fd, &set);
     if (timeout == -1)
-	tp = 0;
-    else
-    {
-	tv.tv_sec = timeout / 1000;
-	tv.tv_usec = (timeout % 1000) * 1000;
-	tp = &tv;
+        tp = 0;
+    else {
+        tv.tv_sec = timeout / 1000;
+        tv.tv_usec = (timeout % 1000) * 1000;
+        tp = &tv;
     }
-    n = select (fd + 1, 0, &set, 0, tp);
+    n = select(fd + 1, 0, &set, 0, tp);
     if (n > 0)
-	return TRUE;
+        return TRUE;
     return FALSE;
 }
 
 static Bool
-MouseWriteByte (int fd, unsigned char c, int timeout)
+MouseWriteByte(int fd, unsigned char c, int timeout)
 {
-    int	ret;
+    int ret;
 
 #ifdef DEBUG_BYTES
-    ErrorF ("\tput %02x\n", c);
+    ErrorF("\tput %02x\n", c);
 #endif
-    for (;;)
-    {
-	ret = write (fd, &c, 1);
-	if (ret == 1)
-	    return TRUE;
-	if (ret == 0)
-	    return FALSE;
-	if (errno != EWOULDBLOCK)
-	    return FALSE;
-	if (!MouseWaitForWritable (fd, timeout))
-	    return FALSE;
+    for (;;) {
+        ret = write(fd, &c, 1);
+        if (ret == 1)
+            return TRUE;
+        if (ret == 0)
+            return FALSE;
+        if (errno != EWOULDBLOCK)
+            return FALSE;
+        if (!MouseWaitForWritable(fd, timeout))
+            return FALSE;
     }
 }
 
 static Bool
-MouseWriteBytes (int fd, unsigned char *c, int n, int timeout)
+MouseWriteBytes(int fd, unsigned char *c, int n, int timeout)
 {
     while (n--)
-	if (!MouseWriteByte (fd, *c++, timeout))
-	    return FALSE;
+        if (!MouseWriteByte(fd, *c++, timeout))
+            return FALSE;
     return TRUE;
 }
 
-#define MAX_MOUSE   10	    /* maximum length of mouse protocol */
-#define MAX_SKIP    16	    /* number of error bytes before switching */
-#define MAX_VALID   4	    /* number of valid packets before accepting */
+#define MAX_MOUSE   10          /* maximum length of mouse protocol */
+#define MAX_SKIP    16          /* number of error bytes before switching */
+#define MAX_VALID   4           /* number of valid packets before accepting */
 
 typedef struct _kmouseProt {
-    char	    *name;
-    Bool	    (*Complete) (KdPointerInfo *pi, unsigned char *ev, int ne);
-    int		    (*Valid) (KdPointerInfo *pi, unsigned char *ev, int ne);
-    Bool	    (*Parse) (KdPointerInfo *pi, unsigned char *ev, int ne);
-    Bool	    (*Init) (KdPointerInfo *pi);
-    unsigned char   headerMask, headerValid;
-    unsigned char   dataMask, dataValid;
-    Bool	    tty;
-    unsigned int    c_iflag;
-    unsigned int    c_oflag;
-    unsigned int    c_lflag;
-    unsigned int    c_cflag;
-    unsigned int    speed;
-    unsigned char   *init;
-    unsigned long   state;
+    char *name;
+    Bool (*Complete) (KdPointerInfo * pi, unsigned char *ev, int ne);
+    int (*Valid) (KdPointerInfo * pi, unsigned char *ev, int ne);
+    Bool (*Parse) (KdPointerInfo * pi, unsigned char *ev, int ne);
+    Bool (*Init) (KdPointerInfo * pi);
+    unsigned char headerMask, headerValid;
+    unsigned char dataMask, dataValid;
+    Bool tty;
+    unsigned int c_iflag;
+    unsigned int c_oflag;
+    unsigned int c_lflag;
+    unsigned int c_cflag;
+    unsigned int speed;
+    unsigned char *init;
+    unsigned long state;
 } KmouseProt;
 
 typedef enum _kmouseStage {
@@ -224,68 +215,71 @@ typedef enum _kmouseStage {
 } KmouseStage;
 
 typedef struct _kmouse {
-    Kbufio		iob;
-    const KmouseProt	*prot;
-    int			i_prot;
-    KmouseStage		stage;	/* protocol verification stage */
-    Bool		tty;	/* mouse device is a tty */
-    int			valid;	/* sequential valid events */
-    int			tested;	/* bytes scanned during Testing phase */
-    int			invalid;/* total invalid bytes for this protocol */
-    unsigned long	state;	/* private per protocol, init to prot->state */
+    Kbufio iob;
+    const KmouseProt *prot;
+    int i_prot;
+    KmouseStage stage;          /* protocol verification stage */
+    Bool tty;                   /* mouse device is a tty */
+    int valid;                  /* sequential valid events */
+    int tested;                 /* bytes scanned during Testing phase */
+    int invalid;                /* total invalid bytes for this protocol */
+    unsigned long state;        /* private per protocol, init to prot->state */
 } Kmouse;
 
-static int mouseValid (KdPointerInfo *pi, unsigned char *ev, int ne)
+static int
+mouseValid(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse		*km = pi->driverPrivate;
-    const KmouseProt	*prot = km->prot;
-    int	    i;
+    Kmouse *km = pi->driverPrivate;
+    const KmouseProt *prot = km->prot;
+    int i;
 
     for (i = 0; i < ne; i++)
-	if ((ev[i] & prot->headerMask) == prot->headerValid)
-	    break;
+        if ((ev[i] & prot->headerMask) == prot->headerValid)
+            break;
     if (i != 0)
-	return i;
+        return i;
     for (i = 1; i < ne; i++)
-	if ((ev[i] & prot->dataMask) != prot->dataValid)
-	    return -1;
+        if ((ev[i] & prot->dataMask) != prot->dataValid)
+            return -1;
     return 0;
 }
 
-static Bool threeComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+threeComplete(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
     return ne == 3;
 }
 
-static Bool fourComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+fourComplete(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
     return ne == 4;
 }
 
-static Bool fiveComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+fiveComplete(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
     return ne == 5;
 }
 
-static Bool MouseReasonable (KdPointerInfo *pi, unsigned long flags, int dx, int dy)
+static Bool
+MouseReasonable(KdPointerInfo * pi, unsigned long flags, int dx, int dy)
 {
-    Kmouse		*km = pi->driverPrivate;
+    Kmouse *km = pi->driverPrivate;
 
     if (km->stage == MouseWorking)
-	return TRUE;
-    if (dx < -50 || dx > 50)
-    {
+        return TRUE;
+    if (dx < -50 || dx > 50) {
 #ifdef DEBUG
-	ErrorF ("Large X %d\n", dx);
+        ErrorF("Large X %d\n", dx);
 #endif
-	return FALSE;
+        return FALSE;
     }
-    if (dy < -50 || dy > 50)
-    {
+    if (dy < -50 || dy > 50) {
 #ifdef DEBUG
-	ErrorF ("Large Y %d\n", dy);
+        ErrorF("Large Y %d\n", dy);
 #endif
-	return FALSE;
+        return FALSE;
     }
     return TRUE;
 }
@@ -293,58 +287,54 @@ static Bool MouseReasonable (KdPointerInfo *pi, unsigned long flags, int dx, int
 /*
  * Standard PS/2 mouse protocol
  */
-static Bool ps2Parse (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+ps2Parse(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = pi->driverPrivate;
-    int		    dx, dy, dz;
-    unsigned long   flags;
-    unsigned long   flagsrelease = 0;
+    Kmouse *km = pi->driverPrivate;
+    int dx, dy, dz;
+    unsigned long flags;
+    unsigned long flagsrelease = 0;
 
     flags = KD_MOUSE_DELTA;
     if (ev[0] & 4)
-	flags |= KD_BUTTON_2;
+        flags |= KD_BUTTON_2;
     if (ev[0] & 2)
-	flags |= KD_BUTTON_3;
+        flags |= KD_BUTTON_3;
     if (ev[0] & 1)
-	flags |= KD_BUTTON_1;
-
-    if (ne > 3)
-    {
-	dz = (int) (signed char) ev[3];
-	if (dz < 0)
-	{
-	    flags |= KD_BUTTON_4;
-	    flagsrelease = KD_BUTTON_4;
-	}
-	else if (dz > 0)
-	{
-	    flags |= KD_BUTTON_5;
-	    flagsrelease = KD_BUTTON_5;
-	}
+        flags |= KD_BUTTON_1;
+
+    if (ne > 3) {
+        dz = (int) (signed char) ev[3];
+        if (dz < 0) {
+            flags |= KD_BUTTON_4;
+            flagsrelease = KD_BUTTON_4;
+        }
+        else if (dz > 0) {
+            flags |= KD_BUTTON_5;
+            flagsrelease = KD_BUTTON_5;
+        }
     }
 
     dx = ev[1];
     if (ev[0] & 0x10)
-	dx -= 256;
+        dx -= 256;
     dy = ev[2];
     if (ev[0] & 0x20)
-	dy -= 256;
+        dy -= 256;
     dy = -dy;
-    if (!MouseReasonable (pi, flags, dx, dy))
-	return FALSE;
-    if (km->stage == MouseWorking)
-    {
-	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
-	if (flagsrelease)
-	{
-	    flags &= ~flagsrelease;
-	    KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
-	}
+    if (!MouseReasonable(pi, flags, dx, dy))
+        return FALSE;
+    if (km->stage == MouseWorking) {
+        KdEnqueuePointerEvent(pi, flags, dx, dy, 0);
+        if (flagsrelease) {
+            flags &= ~flagsrelease;
+            KdEnqueuePointerEvent(pi, flags, dx, dy, 0);
+        }
     }
     return TRUE;
 }
 
-static Bool ps2Init (KdPointerInfo *pi);
+static Bool ps2Init(KdPointerInfo * pi);
 
 static const KmouseProt ps2Prot = {
     "ps/2",
@@ -407,143 +397,143 @@ static const KmouseProt exps2Prot = {
 #define PSM_4DMOUSE_ID          6
 #define PSM_4DPLUS_ID           8
 
-static unsigned char	ps2_init[] = {
+static unsigned char ps2_init[] = {
     PSMC_ENABLE_DEV,
     0,
 };
 
 #define NINIT_PS2   1
 
-static unsigned char    wheel_3button_init[] = {
+static unsigned char wheel_3button_init[] = {
     PSMC_SET_SAMPLING_RATE, 200,
     PSMC_SET_SAMPLING_RATE, 100,
-    PSMC_SET_SAMPLING_RATE,  80,
+    PSMC_SET_SAMPLING_RATE, 80,
     PSMC_SEND_DEV_ID,
     0,
 };
 
 #define NINIT_IMPS2 4
 
-static unsigned char    wheel_5button_init[] = {
+static unsigned char wheel_5button_init[] = {
     PSMC_SET_SAMPLING_RATE, 200,
     PSMC_SET_SAMPLING_RATE, 100,
-    PSMC_SET_SAMPLING_RATE,  80,
+    PSMC_SET_SAMPLING_RATE, 80,
     PSMC_SET_SAMPLING_RATE, 200,
     PSMC_SET_SAMPLING_RATE, 200,
-    PSMC_SET_SAMPLING_RATE,  80,
+    PSMC_SET_SAMPLING_RATE, 80,
     PSMC_SEND_DEV_ID,
     0
 };
 
 #define NINIT_EXPS2 7
 
-static unsigned char	intelli_init[] = {
+static unsigned char intelli_init[] = {
     PSMC_SET_SAMPLING_RATE, 200,
     PSMC_SET_SAMPLING_RATE, 100,
-    PSMC_SET_SAMPLING_RATE,  80,
+    PSMC_SET_SAMPLING_RATE, 80,
     0
 };
 
 #define NINIT_INTELLI	3
 
 static int
-ps2SkipInit (KdPointerInfo *pi, int ninit, Bool ret_next)
+ps2SkipInit(KdPointerInfo * pi, int ninit, Bool ret_next)
 {
-    Kmouse  *km = pi->driverPrivate;
-    int	    c = -1;
-    int	    skipping;
-    Bool    waiting;
+    Kmouse *km = pi->driverPrivate;
+    int c = -1;
+    int skipping;
+    Bool waiting;
 
     skipping = 0;
     waiting = FALSE;
-    while (ninit || ret_next)
-    {
-	c = MouseReadByte (&km->iob, MOUSE_TIMEOUT);
-	if (c == -1)
-	    break;
-	/* look for ACK */
-	if (c == 0xfa)
-	{
-	    ninit--;
-	    if (ret_next)
-		waiting = TRUE;
-	}
-	/* look for packet start -- not the response */
-	else if ((c & 0x08) == 0x08)
-	    waiting = FALSE;
-	else if (waiting)
-	    break;
+    while (ninit || ret_next) {
+        c = MouseReadByte(&km->iob, MOUSE_TIMEOUT);
+        if (c == -1)
+            break;
+        /* look for ACK */
+        if (c == 0xfa) {
+            ninit--;
+            if (ret_next)
+                waiting = TRUE;
+        }
+        /* look for packet start -- not the response */
+        else if ((c & 0x08) == 0x08)
+            waiting = FALSE;
+        else if (waiting)
+            break;
     }
     return c;
 }
 
 static Bool
-ps2Init (KdPointerInfo *pi)
+ps2Init(KdPointerInfo * pi)
 {
-    Kmouse	    *km = pi->driverPrivate;
-    int		    skipping;
-    Bool	    waiting;
-    int		    id;
-    unsigned char   *init;
-    int		    ninit;
+    Kmouse *km = pi->driverPrivate;
+    int skipping;
+    Bool waiting;
+    int id;
+    unsigned char *init;
+    int ninit;
 
     /* Send Intellimouse initialization sequence */
-    MouseWriteBytes (km->iob.fd, intelli_init, strlen ((char *) intelli_init), 100);
+    MouseWriteBytes(km->iob.fd, intelli_init, strlen((char *) intelli_init),
+                    100);
     /*
      * Send ID command
      */
-    if (!MouseWriteByte (km->iob.fd, PSMC_SEND_DEV_ID, 100))
-	return FALSE;
+    if (!MouseWriteByte(km->iob.fd, PSMC_SEND_DEV_ID, 100))
+        return FALSE;
     skipping = 0;
     waiting = FALSE;
-    id = ps2SkipInit (pi, 0, TRUE);
+    id = ps2SkipInit(pi, 0, TRUE);
     switch (id) {
     case 3:
-	init = wheel_3button_init;
-	ninit = NINIT_IMPS2;
-	km->prot = &imps2Prot;
-	break;
+        init = wheel_3button_init;
+        ninit = NINIT_IMPS2;
+        km->prot = &imps2Prot;
+        break;
     case 4:
-	init = wheel_5button_init;
-	ninit = NINIT_EXPS2;
-	km->prot = &exps2Prot;
-	break;
+        init = wheel_5button_init;
+        ninit = NINIT_EXPS2;
+        km->prot = &exps2Prot;
+        break;
     default:
-	init = ps2_init;
-	ninit = NINIT_PS2;
-	km->prot = &ps2Prot;
-	break;
+        init = ps2_init;
+        ninit = NINIT_PS2;
+        km->prot = &ps2Prot;
+        break;
     }
     if (init)
-	MouseWriteBytes (km->iob.fd, init, strlen ((char *) init), 100);
+        MouseWriteBytes(km->iob.fd, init, strlen((char *) init), 100);
     /*
      * Flush out the available data to eliminate responses to the
      * initialization string.  Make sure any partial event is
      * skipped
      */
-    (void) ps2SkipInit (pi, ninit, FALSE);
+    (void) ps2SkipInit(pi, ninit, FALSE);
     return TRUE;
 }
 
-static Bool busParse (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+busParse(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = pi->driverPrivate;
-    int		    dx, dy;
-    unsigned long   flags;
+    Kmouse *km = pi->driverPrivate;
+    int dx, dy;
+    unsigned long flags;
 
     flags = KD_MOUSE_DELTA;
     dx = (signed char) ev[1];
     dy = -(signed char) ev[2];
     if ((ev[0] & 4) == 0)
-	flags |= KD_BUTTON_1;
+        flags |= KD_BUTTON_1;
     if ((ev[0] & 2) == 0)
-	flags |= KD_BUTTON_2;
+        flags |= KD_BUTTON_2;
     if ((ev[0] & 1) == 0)
-	flags |= KD_BUTTON_3;
-    if (!MouseReasonable (pi, flags, dx, dy))
-	return FALSE;
+        flags |= KD_BUTTON_3;
+    if (!MouseReasonable(pi, flags, dx, dy))
+        return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
+        KdEnqueuePointerEvent(pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -558,25 +548,26 @@ static const KmouseProt busProt = {
  * Standard MS serial protocol, three bytes
  */
 
-static Bool msParse (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+msParse(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = pi->driverPrivate;
-    int		    dx, dy;
-    unsigned long   flags;
+    Kmouse *km = pi->driverPrivate;
+    int dx, dy;
+    unsigned long flags;
 
     flags = KD_MOUSE_DELTA;
 
     if (ev[0] & 0x20)
-	flags |= KD_BUTTON_1;
+        flags |= KD_BUTTON_1;
     if (ev[0] & 0x10)
-	flags |= KD_BUTTON_3;
+        flags |= KD_BUTTON_3;
 
-    dx = (signed char)(((ev[0] & 0x03) << 6) | (ev[1] & 0x3F));
-    dy = (signed char)(((ev[0] & 0x0C) << 4) | (ev[2] & 0x3F));
-    if (!MouseReasonable (pi, flags, dx, dy))
-	return FALSE;
+    dx = (signed char) (((ev[0] & 0x03) << 6) | (ev[1] & 0x3F));
+    dy = (signed char) (((ev[0] & 0x0C) << 4) | (ev[2] & 0x3F));
+    if (!MouseReasonable(pi, flags, dx, dy))
+        return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
+        KdEnqueuePointerEvent(pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -597,70 +588,70 @@ 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 (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+logiComplete(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse		*km = pi->driverPrivate;
+    Kmouse *km = pi->driverPrivate;
 
     if ((ev[0] & 0x40) == 0x40)
-	return ne == 3;
+        return ne == 3;
     if (km->stage != MouseBroken && (ev[0] & ~0x23) == 0)
-	return ne == 1;
+        return ne == 1;
     return FALSE;
 }
 
-static int logiValid (KdPointerInfo *pi, unsigned char *ev, int ne)
+static int
+logiValid(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse		*km = pi->driverPrivate;
-    const KmouseProt	*prot = km->prot;
-    int	    i;
-
-    for (i = 0; i < ne; i++)
-    {
-	if ((ev[i] & 0x40) == 0x40)
-	    break;
-	if (km->stage != MouseBroken && (ev[i] & ~0x23) == 0)
-	    break;
+    Kmouse *km = pi->driverPrivate;
+    const KmouseProt *prot = km->prot;
+    int i;
+
+    for (i = 0; i < ne; i++) {
+        if ((ev[i] & 0x40) == 0x40)
+            break;
+        if (km->stage != MouseBroken && (ev[i] & ~0x23) == 0)
+            break;
     }
     if (i != 0)
-	return i;
+        return i;
     for (i = 1; i < ne; i++)
-	if ((ev[i] & prot->dataMask) != prot->dataValid)
-	    return -1;
+        if ((ev[i] & prot->dataMask) != prot->dataValid)
+            return -1;
     return 0;
 }
 
-static Bool logiParse (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+logiParse(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = pi->driverPrivate;
-    int		    dx, dy;
-    unsigned long   flags;
+    Kmouse *km = pi->driverPrivate;
+    int dx, dy;
+    unsigned long flags;
 
     flags = KD_MOUSE_DELTA;
 
-    if (ne == 3)
-    {
-	if (ev[0] & 0x20)
-	    flags |= KD_BUTTON_1;
-	if (ev[0] & 0x10)
-	    flags |= KD_BUTTON_3;
+    if (ne == 3) {
+        if (ev[0] & 0x20)
+            flags |= KD_BUTTON_1;
+        if (ev[0] & 0x10)
+            flags |= KD_BUTTON_3;
 
-	dx = (signed char)(((ev[0] & 0x03) << 6) | (ev[1] & 0x3F));
-	dy = (signed char)(((ev[0] & 0x0C) << 4) | (ev[2] & 0x3F));
-	flags |= km->state & KD_BUTTON_2;
+        dx = (signed char) (((ev[0] & 0x03) << 6) | (ev[1] & 0x3F));
+        dy = (signed char) (((ev[0] & 0x0C) << 4) | (ev[2] & 0x3F));
+        flags |= km->state & KD_BUTTON_2;
     }
-    else
-    {
-	if (ev[0] & 0x20)
-	    flags |= KD_BUTTON_2;
-	dx = 0;
-	dy = 0;
-	flags |= km->state & (KD_BUTTON_1|KD_BUTTON_3);
+    else {
+        if (ev[0] & 0x20)
+            flags |= KD_BUTTON_2;
+        dx = 0;
+        dy = 0;
+        flags |= km->state & (KD_BUTTON_1 | KD_BUTTON_3);
     }
 
-    if (!MouseReasonable (pi, flags, dx, dy))
-	return FALSE;
+    if (!MouseReasonable(pi, flags, dx, dy))
+        return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
+        KdEnqueuePointerEvent(pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -679,27 +670,28 @@ static const KmouseProt logiProt = {
 /*
  * Mouse systems protocol, 5 bytes
  */
-static Bool mscParse (KdPointerInfo *pi, unsigned char *ev, int ne)
+static Bool
+mscParse(KdPointerInfo * pi, unsigned char *ev, int ne)
 {
-    Kmouse	    *km = pi->driverPrivate;
-    int		    dx, dy;
-    unsigned long   flags;
+    Kmouse *km = pi->driverPrivate;
+    int dx, dy;
+    unsigned long flags;
 
     flags = KD_MOUSE_DELTA;
 
     if (!(ev[0] & 0x4))
-	flags |= KD_BUTTON_1;
+        flags |= KD_BUTTON_1;
     if (!(ev[0] & 0x2))
-	flags |= KD_BUTTON_2;
+        flags |= KD_BUTTON_2;
     if (!(ev[0] & 0x1))
-	flags |= KD_BUTTON_3;
-    dx =    (signed char)(ev[1]) + (signed char)(ev[3]);
-    dy = - ((signed char)(ev[2]) + (signed char)(ev[4]));
+        flags |= KD_BUTTON_3;
+    dx = (signed char) (ev[1]) + (signed char) (ev[3]);
+    dy = -((signed char) (ev[2]) + (signed char) (ev[4]));
 
-    if (!MouseReasonable (pi, flags, dx, dy))
-	return FALSE;
+    if (!MouseReasonable(pi, flags, dx, dy))
+        return FALSE;
     if (km->stage == MouseWorking)
-	KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
+        KdEnqueuePointerEvent(pi, flags, dx, dy, 0);
     return TRUE;
 }
 
@@ -726,25 +718,23 @@ static const KmouseProt *kmouseProts[] = {
 #define NUM_PROT    (sizeof (kmouseProts) / sizeof (kmouseProts[0]))
 
 static void
-MouseInitProtocol (Kmouse *km)
+MouseInitProtocol(Kmouse * km)
 {
-    int		    ret;
-    struct termios  t;
-
-    if (km->prot->tty)
-    {
-	ret = tcgetattr (km->iob.fd, &t);
-
-	if (ret >= 0)
-	{
-	    t.c_iflag = km->prot->c_iflag;
-	    t.c_oflag = km->prot->c_oflag;
-	    t.c_lflag = km->prot->c_lflag;
-	    t.c_cflag = km->prot->c_cflag;
-	    cfsetispeed (&t, km->prot->speed);
-	    cfsetospeed (&t, km->prot->speed);
-	    ret = tcsetattr (km->iob.fd, TCSANOW, &t);
-	}
+    int ret;
+    struct termios t;
+
+    if (km->prot->tty) {
+        ret = tcgetattr(km->iob.fd, &t);
+
+        if (ret >= 0) {
+            t.c_iflag = km->prot->c_iflag;
+            t.c_oflag = km->prot->c_oflag;
+            t.c_lflag = km->prot->c_lflag;
+            t.c_cflag = km->prot->c_cflag;
+            cfsetispeed(&t, km->prot->speed);
+            cfsetospeed(&t, km->prot->speed);
+            ret = tcsetattr(km->iob.fd, TCSANOW, &t);
+        }
     }
     km->stage = MouseBroken;
     km->valid = 0;
@@ -754,172 +744,156 @@ MouseInitProtocol (Kmouse *km)
 }
 
 static void
-MouseFirstProtocol (Kmouse *km, char *prot)
+MouseFirstProtocol(Kmouse * km, char *prot)
 {
-    if (prot)
-    {
-	for (km->i_prot = 0; km->i_prot < NUM_PROT; km->i_prot++)
-	    if (!strcmp (prot, kmouseProts[km->i_prot]->name))
-		break;
-	if (km->i_prot == NUM_PROT)
-	{
-	    int	i;
-	    ErrorF ("Unknown mouse protocol \"%s\". Pick one of:", prot);
-	    for (i = 0; i < NUM_PROT; i++)
-		ErrorF (" %s", kmouseProts[i]->name);
-	    ErrorF ("\n");
-	}
-	else
-	{
-	    km->prot = kmouseProts[km->i_prot];
-	    if (km->tty && !km->prot->tty)
-		ErrorF ("Mouse device is serial port, protocol %s is not serial protocol\n",
-			prot);
-	    else if (!km->tty && km->prot->tty)
-		ErrorF ("Mouse device is not serial port, protocol %s is serial protocol\n",
-			prot);
-	}
+    if (prot) {
+        for (km->i_prot = 0; km->i_prot < NUM_PROT; km->i_prot++)
+            if (!strcmp(prot, kmouseProts[km->i_prot]->name))
+                break;
+        if (km->i_prot == NUM_PROT) {
+            int i;
+
+            ErrorF("Unknown mouse protocol \"%s\". Pick one of:", prot);
+            for (i = 0; i < NUM_PROT; i++)
+                ErrorF(" %s", kmouseProts[i]->name);
+            ErrorF("\n");
+        }
+        else {
+            km->prot = kmouseProts[km->i_prot];
+            if (km->tty && !km->prot->tty)
+                ErrorF
+                    ("Mouse device is serial port, protocol %s is not serial protocol\n",
+                     prot);
+            else if (!km->tty && km->prot->tty)
+                ErrorF
+                    ("Mouse device is not serial port, protocol %s is serial protocol\n",
+                     prot);
+        }
     }
-    if (!km->prot)
-    {
-	for (km->i_prot = 0; kmouseProts[km->i_prot]->tty != km->tty; km->i_prot++)
-	    ;
-	km->prot = kmouseProts[km->i_prot];
+    if (!km->prot) {
+        for (km->i_prot = 0; kmouseProts[km->i_prot]->tty != km->tty;
+             km->i_prot++);
+        km->prot = kmouseProts[km->i_prot];
     }
-    MouseInitProtocol (km);
+    MouseInitProtocol(km);
 }
 
 static void
-MouseNextProtocol (Kmouse *km)
+MouseNextProtocol(Kmouse * km)
 {
-    do
-    {
-	if (!km->prot)
-	    km->i_prot = 0;
-	else
-	    if (++km->i_prot == NUM_PROT) km->i_prot = 0;
-	km->prot = kmouseProts[km->i_prot];
+    do {
+        if (!km->prot)
+            km->i_prot = 0;
+        else if (++km->i_prot == NUM_PROT)
+            km->i_prot = 0;
+        km->prot = kmouseProts[km->i_prot];
     } while (km->prot->tty != km->tty);
-    MouseInitProtocol (km);
-    ErrorF ("Switching to mouse protocol \"%s\"\n", km->prot->name);
+    MouseInitProtocol(km);
+    ErrorF("Switching to mouse protocol \"%s\"\n", km->prot->name);
 }
 
 static void
-MouseRead (int mousePort, void *closure)
+MouseRead(int mousePort, void *closure)
 {
-    KdPointerInfo   *pi = closure;
-    Kmouse	    *km = pi->driverPrivate;
-    unsigned char   event[MAX_MOUSE];
-    int		    ne;
-    int		    c;
-    int		    i;
-    int		    timeout;
+    KdPointerInfo *pi = closure;
+    Kmouse *km = pi->driverPrivate;
+    unsigned char event[MAX_MOUSE];
+    int ne;
+    int c;
+    int i;
+    int timeout;
 
     timeout = 0;
     ne = 0;
-    for(;;)
-    {
-	c = MouseReadByte (&km->iob, timeout);
-	if (c == -1)
-	{
-	    if (ne)
-	    {
-		km->invalid += ne + km->tested;
-		km->valid = 0;
-		km->tested = 0;
-		km->stage = MouseBroken;
-	    }
-	    break;
-	}
-	event[ne++] = c;
-	i = (*km->prot->Valid) (pi, event, ne);
-	if (i != 0)
-	{
+    for (;;) {
+        c = MouseReadByte(&km->iob, timeout);
+        if (c == -1) {
+            if (ne) {
+                km->invalid += ne + km->tested;
+                km->valid = 0;
+                km->tested = 0;
+                km->stage = MouseBroken;
+            }
+            break;
+        }
+        event[ne++] = c;
+        i = (*km->prot->Valid) (pi, event, ne);
+        if (i != 0) {
 #ifdef DEBUG
-	    ErrorF ("Mouse protocol %s broken %d of %d bytes bad\n",
-		    km->prot->name, i > 0 ? i : ne, ne);
+            ErrorF("Mouse protocol %s broken %d of %d bytes bad\n",
+                   km->prot->name, i > 0 ? i : ne, ne);
 #endif
-	    if (i > 0 && i < ne)
-	    {
-		ne -= i;
-		memmove (event, event + i, ne);
-	    }
-	    else
-	    {
-		i = ne;
-		ne = 0;
-	    }
-	    km->invalid += i + km->tested;
-	    km->valid = 0;
-	    km->tested = 0;
-	    if (km->stage == MouseWorking)
-		km->i_prot--;
-	    km->stage = MouseBroken;
-	    if (km->invalid > MAX_SKIP)
-	    {
-		MouseNextProtocol (km);
-		ne = 0;
-	    }
-	    timeout = 0;
-	}
-	else
-	{
-	    if ((*km->prot->Complete) (pi, event, ne))
-	    {
-		if ((*km->prot->Parse) (pi, event, ne))
-		{
-		    switch (km->stage)
-		    {
-		    case MouseBroken:
+            if (i > 0 && i < ne) {
+                ne -= i;
+                memmove(event, event + i, ne);
+            }
+            else {
+                i = ne;
+                ne = 0;
+            }
+            km->invalid += i + km->tested;
+            km->valid = 0;
+            km->tested = 0;
+            if (km->stage == MouseWorking)
+                km->i_prot--;
+            km->stage = MouseBroken;
+            if (km->invalid > MAX_SKIP) {
+                MouseNextProtocol(km);
+                ne = 0;
+            }
+            timeout = 0;
+        }
+        else {
+            if ((*km->prot->Complete) (pi, event, ne)) {
+                if ((*km->prot->Parse) (pi, event, ne)) {
+                    switch (km->stage) {
+                    case MouseBroken:
 #ifdef DEBUG
-			ErrorF ("Mouse protocol %s seems OK\n",
-				km->prot->name);
+                        ErrorF("Mouse protocol %s seems OK\n", km->prot->name);
 #endif
-			/* do not zero invalid to accumulate invalid bytes */
-			km->valid = 0;
-			km->tested = 0;
-			km->stage = MouseTesting;
-			/* fall through ... */
-		    case MouseTesting:
-			km->valid++;
-			km->tested += ne;
-			if (km->valid > MAX_VALID)
-			{
+                        /* do not zero invalid to accumulate invalid bytes */
+                        km->valid = 0;
+                        km->tested = 0;
+                        km->stage = MouseTesting;
+                        /* fall through ... */
+                    case MouseTesting:
+                        km->valid++;
+                        km->tested += ne;
+                        if (km->valid > MAX_VALID) {
 #ifdef DEBUG
-			    ErrorF ("Mouse protocol %s working\n",
-				    km->prot->name);
+                            ErrorF("Mouse protocol %s working\n",
+                                   km->prot->name);
 #endif
-			    km->stage = MouseWorking;
-			    km->invalid = 0;
-			    km->tested = 0;
-			    km->valid = 0;
-			    if (km->prot->Init && !(*km->prot->Init) (pi))
-				km->stage = MouseBroken;
-			}
-			break;
-		    case MouseWorking:
-			break;
-		    }
-		}
-		else
-		{
-		    km->invalid += ne + km->tested;
-		    km->valid = 0;
-		    km->tested = 0;
-		    km->stage = MouseBroken;
-		}
-		ne = 0;
-		timeout = 0;
-	    }
-	    else
-		timeout = MOUSE_TIMEOUT;
-	}
+                            km->stage = MouseWorking;
+                            km->invalid = 0;
+                            km->tested = 0;
+                            km->valid = 0;
+                            if (km->prot->Init && !(*km->prot->Init) (pi))
+                                km->stage = MouseBroken;
+                        }
+                        break;
+                    case MouseWorking:
+                        break;
+                    }
+                }
+                else {
+                    km->invalid += ne + km->tested;
+                    km->valid = 0;
+                    km->tested = 0;
+                    km->stage = MouseBroken;
+                }
+                ne = 0;
+                timeout = 0;
+            }
+            else
+                timeout = MOUSE_TIMEOUT;
+        }
     }
 }
 
 int MouseInputType;
 
-char *kdefaultMouse[] =  {
+char *kdefaultMouse[] = {
     "/dev/input/mice",
     "/dev/mouse",
     "/dev/psaux",
@@ -931,26 +905,26 @@ char *kdefaultMouse[] =  {
 #define NUM_DEFAULT_MOUSE    (sizeof (kdefaultMouse) / sizeof (kdefaultMouse[0]))
 
 static Status
-MouseInit (KdPointerInfo *pi)
+MouseInit(KdPointerInfo * pi)
 {
-    int		i;
-    int		fd;
-    Kmouse	*km;
+    int i;
+    int fd;
+    Kmouse *km;
 
     if (!pi)
         return BadImplementation;
 
     if (!pi->path || strcmp(pi->path, "auto") == 0) {
         for (i = 0; i < NUM_DEFAULT_MOUSE; i++) {
-            fd = open (kdefaultMouse[i], 2);
+            fd = open(kdefaultMouse[i], 2);
             if (fd >= 0) {
-                pi->path = strdup (kdefaultMouse[i]);
+                pi->path = strdup(kdefaultMouse[i]);
                 break;
             }
         }
     }
     else {
-        fd = open (pi->path, 2);
+        fd = open(pi->path, 2);
     }
 
     if (fd < 0)
@@ -958,21 +932,21 @@ MouseInit (KdPointerInfo *pi)
 
     close(fd);
 
-    km = (Kmouse *) malloc(sizeof (Kmouse));
+    km = (Kmouse *) malloc(sizeof(Kmouse));
     if (km) {
         km->iob.avail = km->iob.used = 0;
         MouseFirstProtocol(km, pi->protocol ? pi->protocol : "exps/2");
         /* MouseFirstProtocol sets state to MouseBroken for later protocol
          * checks. Skip these checks if a protocol was supplied */
         if (pi->protocol)
-                km->state = MouseWorking;
+            km->state = MouseWorking;
         km->i_prot = 0;
-        km->tty = isatty (fd);
+        km->tty = isatty(fd);
         km->iob.fd = -1;
         pi->driverPrivate = km;
     }
     else {
-        close (fd);
+        close(fd);
         return BadAlloc;
     }
 
@@ -980,7 +954,7 @@ MouseInit (KdPointerInfo *pi)
 }
 
 static Status
-MouseEnable (KdPointerInfo *pi)
+MouseEnable(KdPointerInfo * pi)
 {
     Kmouse *km;
 
@@ -993,8 +967,7 @@ MouseEnable (KdPointerInfo *pi)
     if (km->iob.fd < 0)
         return BadMatch;
 
-    if (!KdRegisterFd (km->iob.fd, MouseRead, pi))
-    {
+    if (!KdRegisterFd(km->iob.fd, MouseRead, pi)) {
         close(km->iob.fd);
         return BadAlloc;
     }
@@ -1003,18 +976,19 @@ MouseEnable (KdPointerInfo *pi)
 }
 
 static void
-MouseDisable (KdPointerInfo *pi)
+MouseDisable(KdPointerInfo * pi)
 {
     Kmouse *km;
+
     if (!pi || !pi->driverPrivate)
         return;
 
     km = pi->driverPrivate;
-    KdUnregisterFd (pi, km->iob.fd, TRUE);
+    KdUnregisterFd(pi, km->iob.fd, TRUE);
 }
 
 static void
-MouseFini (KdPointerInfo *pi)
+MouseFini(KdPointerInfo * pi)
 {
     free(pi->driverPrivate);
     pi->driverPrivate = NULL;
diff --git a/hw/kdrive/linux/ms.c b/hw/kdrive/linux/ms.c
index 176e12550..e82350ac5 100644
--- a/hw/kdrive/linux/ms.c
+++ b/hw/kdrive/linux/ms.c
@@ -34,67 +34,63 @@ THE SOFTWARE.
 #include "kdrive.h"
 
 static int
-MsReadBytes (int fd, char *buf, int len, int min)
+MsReadBytes(int fd, char *buf, int len, int min)
 {
-    int		    n, tot;
-    fd_set	    set;
-    struct timeval  tv;
+    int n, tot;
+    fd_set set;
+    struct timeval tv;
 
     tot = 0;
-    while (len)
-    {
-	n = read (fd, buf, len);
-	if (n > 0)
-	{
-	    tot += n;
-	    buf += n;
-	    len -= n;
-	}
-	if (tot % min == 0)
-	    break;
-	FD_ZERO (&set);
-	FD_SET (fd, &set);
-	tv.tv_sec = 0;
-	tv.tv_usec = 100 * 1000;
-	n = select (fd + 1, &set, 0, 0, &tv);
-	if (n <= 0)
-	    break;
+    while (len) {
+        n = read(fd, buf, len);
+        if (n > 0) {
+            tot += n;
+            buf += n;
+            len -= n;
+        }
+        if (tot % min == 0)
+            break;
+        FD_ZERO(&set);
+        FD_SET(fd, &set);
+        tv.tv_sec = 0;
+        tv.tv_usec = 100 * 1000;
+        n = select(fd + 1, &set, 0, 0, &tv);
+        if (n <= 0)
+            break;
     }
     return tot;
 }
 
 static void
-MsRead (int port, void *closure)
+MsRead(int port, void *closure)
 {
-    unsigned char   buf[3 * 200];
-    unsigned char   *b;
-    int		    n;
-    int		    dx, dy;
-    unsigned long   flags;
-
-    while ((n = MsReadBytes (port, (char *) buf, sizeof (buf), 3)) > 0)
-    {
-	b = buf;
-	while (n >= 3)
-	{
-	    flags = KD_MOUSE_DELTA;
-
-	    if (b[0] & 0x20)
-		flags |= KD_BUTTON_1;
-	    if (b[0] & 0x10)
-		flags |= KD_BUTTON_3;
-
-	    dx = (char)(((b[0] & 0x03) << 6) | (b[1] & 0x3F));
-	    dy = (char)(((b[0] & 0x0C) << 4) | (b[2] & 0x3F));
+    unsigned char buf[3 * 200];
+    unsigned char *b;
+    int n;
+    int dx, dy;
+    unsigned long flags;
+
+    while ((n = MsReadBytes(port, (char *) buf, sizeof(buf), 3)) > 0) {
+        b = buf;
+        while (n >= 3) {
+            flags = KD_MOUSE_DELTA;
+
+            if (b[0] & 0x20)
+                flags |= KD_BUTTON_1;
+            if (b[0] & 0x10)
+                flags |= KD_BUTTON_3;
+
+            dx = (char) (((b[0] & 0x03) << 6) | (b[1] & 0x3F));
+            dy = (char) (((b[0] & 0x0C) << 4) | (b[2] & 0x3F));
             n -= 3;
             b += 3;
-	    KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
-	}
+            KdEnqueuePointerEvent(closure, flags, dx, dy, 0);
+        }
     }
 }
 
 static Status
-MsInit (KdPointerInfo *pi)
+MsInit(KdPointerInfo * pi)
 {
     if (!pi)
         return BadImplementation;
@@ -108,51 +104,51 @@ MsInit (KdPointerInfo *pi)
 }
 
 static Status
-MsEnable (KdPointerInfo *pi)
+MsEnable(KdPointerInfo * pi)
 {
     int port;
     struct termios t;
     int ret;
 
-    port = open (pi->path, O_RDWR | O_NONBLOCK);
-    if(port < 0) {
-        ErrorF("Couldn't open %s (%d)\n", pi->path, (int)errno);
+    port = open(pi->path, O_RDWR | O_NONBLOCK);
+    if (port < 0) {
+        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",
-               pi->path);
-	goto bail;
+    }
+    else if (port == 0) {
+        ErrorF("Opening %s returned 0!  Please complain to Keith.\n", pi->path);
+        goto bail;
     }
 
-    if(!isatty(port)) {
+    if (!isatty(port)) {
         ErrorF("%s is not a tty\n", pi->path);
         goto bail;
     }
 
     ret = tcgetattr(port, &t);
-    if(ret < 0) {
+    if (ret < 0) {
         ErrorF("Couldn't tcgetattr(%s): %d\n", pi->path, errno);
         goto bail;
     }
-    t.c_iflag &= ~ (IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR |
+    t.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR |
                    IGNCR | ICRNL | IXON | IXOFF);
-    t.c_oflag &= ~ OPOST;
-    t.c_lflag &= ~ (ECHO | ECHONL | ICANON | ISIG | IEXTEN);
-    t.c_cflag &= ~ (CSIZE | PARENB);
+    t.c_oflag &= ~OPOST;
+    t.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+    t.c_cflag &= ~(CSIZE | PARENB);
     t.c_cflag |= CS8 | CLOCAL | CSTOPB;
 
-    cfsetispeed (&t, B1200);
-    cfsetospeed (&t, B1200);
+    cfsetispeed(&t, B1200);
+    cfsetospeed(&t, B1200);
     t.c_cc[VMIN] = 1;
     t.c_cc[VTIME] = 0;
     ret = tcsetattr(port, TCSANOW, &t);
-    if(ret < 0) {
+    if (ret < 0) {
         ErrorF("Couldn't tcsetattr(%s): %d\n", pi->path, errno);
         goto bail;
     }
-    if (KdRegisterFd (port, MsRead, pi))
-	return TRUE;
-    pi->driverPrivate = (void *)(intptr_t)port;
+    if (KdRegisterFd(port, MsRead, pi))
+        return TRUE;
+    pi->driverPrivate = (void *) (intptr_t) port;
 
     return Success;
 
@@ -162,13 +158,13 @@ MsEnable (KdPointerInfo *pi)
 }
 
 static void
-MsDisable (KdPointerInfo *pi)
+MsDisable(KdPointerInfo * pi)
 {
-    KdUnregisterFd (pi, (int)(intptr_t)pi->driverPrivate, TRUE);
+    KdUnregisterFd(pi, (int) (intptr_t) pi->driverPrivate, TRUE);
 }
 
 static void
-MsFini (KdPointerInfo *pi)
+MsFini(KdPointerInfo * pi)
 {
 }
 
diff --git a/hw/kdrive/linux/ps2.c b/hw/kdrive/linux/ps2.c
index b62d769f2..d1522a2d0 100644
--- a/hw/kdrive/linux/ps2.c
+++ b/hw/kdrive/linux/ps2.c
@@ -31,36 +31,34 @@
 #include "kdrive.h"
 
 static int
-Ps2ReadBytes (int fd, char *buf, int len, int min)
+Ps2ReadBytes(int fd, char *buf, int len, int min)
 {
-    int		    n, tot;
-    fd_set	    set;
-    struct timeval  tv;
+    int n, tot;
+    fd_set set;
+    struct timeval tv;
 
     tot = 0;
-    while (len)
-    {
-	n = read (fd, buf, len);
-	if (n > 0)
-	{
-	    tot += n;
-	    buf += n;
-	    len -= n;
-	}
-	if (tot % min == 0)
-	    break;
-	FD_ZERO (&set);
-	FD_SET (fd, &set);
-	tv.tv_sec = 0;
-	tv.tv_usec = 100 * 1000;
-	n = select (fd + 1, &set, 0, 0, &tv);
-	if (n <= 0)
-	    break;
+    while (len) {
+        n = read(fd, buf, len);
+        if (n > 0) {
+            tot += n;
+            buf += n;
+            len -= n;
+        }
+        if (tot % min == 0)
+            break;
+        FD_ZERO(&set);
+        FD_SET(fd, &set);
+        tv.tv_sec = 0;
+        tv.tv_usec = 100 * 1000;
+        n = select(fd + 1, &set, 0, 0, &tv);
+        if (n <= 0)
+            break;
     }
     return tot;
 }
 
-char	*Ps2Names[] = {
+char *Ps2Names[] = {
     "/dev/psaux",
 /*    "/dev/mouse", */
     "/dev/input/mice",
@@ -69,67 +67,64 @@ char	*Ps2Names[] = {
 #define NUM_PS2_NAMES	(sizeof (Ps2Names) / sizeof (Ps2Names[0]))
 
 static void
-Ps2Read (int ps2Port, void *closure)
+Ps2Read(int ps2Port, void *closure)
 {
-    unsigned char   buf[3 * 200];
-    unsigned char   *b;
-    int		    n;
-    int		    dx, dy;
-    unsigned long   flags;
-    unsigned long   left_button = KD_BUTTON_1;
-    unsigned long   right_button = KD_BUTTON_3;
+    unsigned char buf[3 * 200];
+    unsigned char *b;
+    int n;
+    int dx, dy;
+    unsigned long flags;
+    unsigned long left_button = KD_BUTTON_1;
+    unsigned long right_button = KD_BUTTON_3;
 
 #undef SWAP_USB
 #ifdef SWAP_USB
-    if (id == 2)
-    {
-	left_button = KD_BUTTON_3;
-	right_button = KD_BUTTON_1;
+    if (id == 2) {
+        left_button = KD_BUTTON_3;
+        right_button = KD_BUTTON_1;
     }
 #endif
-    while ((n = Ps2ReadBytes (ps2Port, (char *) buf, sizeof (buf), 3)) > 0)
-    {
-	b = buf;
-	while (n >= 3)
-	{
-	    flags = KD_MOUSE_DELTA;
-	    if (b[0] & 4)
-		flags |= KD_BUTTON_2;
-	    if (b[0] & 2)
-		flags |= right_button;
-	    if (b[0] & 1)
-		flags |= left_button;
-
-	    dx = b[1];
-	    if (b[0] & 0x10)
-		dx -= 256;
-	    dy = b[2];
-	    if (b[0] & 0x20)
-		dy -= 256;
-	    dy = -dy;
-	    n -= 3;
-	    b += 3;
-	    KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
-	}
+    while ((n = Ps2ReadBytes(ps2Port, (char *) buf, sizeof(buf), 3)) > 0) {
+        b = buf;
+        while (n >= 3) {
+            flags = KD_MOUSE_DELTA;
+            if (b[0] & 4)
+                flags |= KD_BUTTON_2;
+            if (b[0] & 2)
+                flags |= right_button;
+            if (b[0] & 1)
+                flags |= left_button;
+
+            dx = b[1];
+            if (b[0] & 0x10)
+                dx -= 256;
+            dy = b[2];
+            if (b[0] & 0x20)
+                dy -= 256;
+            dy = -dy;
+            n -= 3;
+            b += 3;
+            KdEnqueuePointerEvent(closure, flags, dx, dy, 0);
+        }
     }
 }
 
 static Status
-Ps2Init (KdPointerInfo *pi)
+Ps2Init(KdPointerInfo * pi)
 {
-    int	ps2Port, i;
+    int ps2Port, i;
 
     if (!pi->path) {
         for (i = 0; i < NUM_PS2_NAMES; i++) {
-            ps2Port = open (Ps2Names[i], 0);
+            ps2Port = open(Ps2Names[i], 0);
             if (ps2Port >= 0) {
-                pi->path = strdup (Ps2Names[i]);
+                pi->path = strdup(Ps2Names[i]);
                 break;
             }
-	}
+        }
     }
     else {
-        ps2Port = open (pi->path, 0);
+        ps2Port = open(pi->path, 0);
     }
 
     if (ps2Port < 0)
@@ -137,42 +132,41 @@ Ps2Init (KdPointerInfo *pi)
 
     close(ps2Port);
     if (!pi->name)
-        pi->name = strdup ("PS/2 Mouse");
+        pi->name = strdup("PS/2 Mouse");
 
     return Success;
 }
 
 static Status
-Ps2Enable (KdPointerInfo *pi)
+Ps2Enable(KdPointerInfo * pi)
 {
     int fd;
 
     if (!pi)
         return BadImplementation;
 
-    fd = open (pi->path, 0);
+    fd = open(pi->path, 0);
     if (fd < 0)
         return BadMatch;
 
-    if (!KdRegisterFd (fd, Ps2Read, pi)) {
+    if (!KdRegisterFd(fd, Ps2Read, pi)) {
         close(fd);
         return BadAlloc;
     }
 
-    pi->driverPrivate = (void *)(intptr_t)fd;
+    pi->driverPrivate = (void *) (intptr_t) fd;
 
     return Success;
 }
 
-
 static void
-Ps2Disable (KdPointerInfo *pi)
+Ps2Disable(KdPointerInfo * pi)
 {
-    KdUnregisterFd (pi, (int)(intptr_t)pi->driverPrivate, TRUE);
+    KdUnregisterFd(pi, (int) (intptr_t) pi->driverPrivate, TRUE);
 }
 
 static void
-Ps2Fini (KdPointerInfo *pi)
+Ps2Fini(KdPointerInfo * pi)
 {
 }
 
diff --git a/hw/kdrive/linux/tslib.c b/hw/kdrive/linux/tslib.c
index 1f30ccae7..1403c7968 100644
--- a/hw/kdrive/linux/tslib.c
+++ b/hw/kdrive/linux/tslib.c
@@ -30,7 +30,6 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-
 #ifdef HAVE_KDRIVE_CONFIG_H
 #include <kdrive-config.h>
 #endif
@@ -50,25 +49,24 @@ struct TslibPrivate {
     int fd;
     int lastx, lasty;
     struct tsdev *tsDev;
-    void (*raw_event_hook)(int x, int y, int pressure, void *closure);
+    void (*raw_event_hook) (int x, int y, int pressure, void *closure);
     void *raw_event_closure;
     int phys_screen;
 };
 
-
 static void
-TsRead (int fd, void *closure)
+TsRead(int fd, void *closure)
 {
-    KdPointerInfo       *pi = closure;
+    KdPointerInfo *pi = closure;
     struct TslibPrivate *private = pi->driverPrivate;
-    struct ts_sample    event;
-    long                x = 0, y = 0;
-    unsigned long       flags;
+    struct ts_sample event;
+    long x = 0, y = 0;
+    unsigned long flags;
 
     if (private->raw_event_hook) {
         while (ts_read_raw(private->tsDev, &event, 1) == 1)
-            private->raw_event_hook (event.x, event.y, event.pressure,
-                                     private->raw_event_closure);
+            private->raw_event_hook(event.x, event.y, event.pressure,
+                                    private->raw_event_closure);
         return;
     }
 
@@ -84,30 +82,33 @@ TsRead (int fd, void *closure)
             if (KdCurScreen == private->phys_screen) {
                 x = event.x;
                 y = event.y;
-            } else {
+            }
+            else {
                 flags |= KD_MOUSE_DELTA;
                 if ((private->lastx == 0) || (private->lasty == 0)) {
                     x = event.x;
                     y = event.y;
-                } else {
+                }
+                else {
                     x = event.x - private->lastx;
                     y = event.y - private->lasty;
-	    	}
+                }
             }
             private->lastx = event.x;
             private->lasty = event.y;
-        } else {
+        }
+        else {
             flags = 0;
             x = private->lastx;
             y = private->lasty;
         }
 
-        KdEnqueuePointerEvent (pi, flags, x, y, event.pressure);
+        KdEnqueuePointerEvent(pi, flags, x, y, event.pressure);
     }
 }
 
 static Status
-TslibEnable (KdPointerInfo *pi)
+TslibEnable(KdPointerInfo * pi)
 {
     struct TslibPrivate *private = pi->driverPrivate;
 
@@ -115,7 +116,8 @@ TslibEnable (KdPointerInfo *pi)
     private->raw_event_closure = NULL;
     if (!pi->path) {
         pi->path = strdup("/dev/input/touchscreen0");
-        ErrorF("[tslib/TslibEnable] no device path given, trying %s\n", pi->path);
+        ErrorF("[tslib/TslibEnable] no device path given, trying %s\n",
+               pi->path);
     }
 
     private->tsDev = ts_open(pi->path, 0);
@@ -138,9 +140,8 @@ TslibEnable (KdPointerInfo *pi)
     return Success;
 }
 
-
 static void
-TslibDisable (KdPointerInfo *pi)
+TslibDisable(KdPointerInfo * pi)
 {
     struct TslibPrivate *private = pi->driverPrivate;
 
@@ -154,9 +155,8 @@ TslibDisable (KdPointerInfo *pi)
     private->tsDev = NULL;
 }
 
-
 static Status
-TslibInit (KdPointerInfo *pi)
+TslibInit(KdPointerInfo * pi)
 {
     struct TslibPrivate *private = NULL;
 
@@ -164,7 +164,7 @@ TslibInit (KdPointerInfo *pi)
         return !Success;
 
     pi->driverPrivate = (struct TslibPrivate *)
-                        calloc(sizeof(struct TslibPrivate), 1);
+        calloc(sizeof(struct TslibPrivate), 1);
     if (!pi->driverPrivate)
         return !Success;
 
@@ -178,15 +178,13 @@ TslibInit (KdPointerInfo *pi)
     return Success;
 }
 
-
 static void
-TslibFini (KdPointerInfo *pi)
+TslibFini(KdPointerInfo * pi)
 {
     free(pi->driverPrivate);
     pi->driverPrivate = NULL;
 }
 
-
 KdPointerDriver TsDriver = {
     "tslib",
     TslibInit,
diff --git a/hw/kdrive/src/fourcc.h b/hw/kdrive/src/fourcc.h
index 54be7ebe8..534ec452f 100644
--- a/hw/kdrive/src/fourcc.h
+++ b/hw/kdrive/src/fourcc.h
@@ -69,7 +69,6 @@
 	XvTopToBottom \
    }
 
-
 #define FOURCC_UYVY 0x59565955
 #define XVIMAGE_UYVY \
    { \
@@ -130,4 +129,4 @@
         XvTopToBottom \
    }
 
-#endif /* _XF86_FOURCC_H_ */
+#endif                          /* _XF86_FOURCC_H_ */
diff --git a/hw/kdrive/src/kcmap.c b/hw/kdrive/src/kcmap.c
index 6e0fc1417..c93c2f4d3 100644
--- a/hw/kdrive/src/kcmap.c
+++ b/hw/kdrive/src/kcmap.c
@@ -30,25 +30,25 @@
  */
 
 void
-KdSetColormap (ScreenPtr pScreen)
+KdSetColormap(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    ColormapPtr	pCmap = pScreenPriv->pInstalledmap;
-    Pixel	pixels[KD_MAX_PSEUDO_SIZE];
-    xrgb	colors[KD_MAX_PSEUDO_SIZE];
-    xColorItem	defs[KD_MAX_PSEUDO_SIZE];
-    int		i;
+    ColormapPtr pCmap = pScreenPriv->pInstalledmap;
+    Pixel pixels[KD_MAX_PSEUDO_SIZE];
+    xrgb colors[KD_MAX_PSEUDO_SIZE];
+    xColorItem defs[KD_MAX_PSEUDO_SIZE];
+    int i;
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
+        return;
     if (pScreenPriv->screen->fb.depth > KD_MAX_PSEUDO_DEPTH)
-	return;
+        return;
 
     if (!pScreenPriv->enabled)
-	return;
+        return;
 
     if (!pCmap)
-	return;
+        return;
 
     /*
      * Make DIX convert pixels into RGB values -- this handles
@@ -56,26 +56,26 @@ KdSetColormap (ScreenPtr pScreen)
      */
 
     for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
-	pixels[i] = i;
+        pixels[i] = i;
 
-    QueryColors (pCmap, (1 << pScreenPriv->screen->fb.depth), pixels, colors, serverClient);
+    QueryColors(pCmap, (1 << pScreenPriv->screen->fb.depth), pixels, colors,
+                serverClient);
 
-    for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
-    {
-	defs[i].pixel = i;
-	defs[i].red = colors[i].red;
-	defs[i].green = colors[i].green;
-	defs[i].blue = colors[i].blue;
-	defs[i].flags = DoRed|DoGreen|DoBlue;
+    for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++) {
+        defs[i].pixel = i;
+        defs[i].red = colors[i].red;
+        defs[i].green = colors[i].green;
+        defs[i].blue = colors[i].blue;
+        defs[i].flags = DoRed | DoGreen | DoBlue;
     }
 
     (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen,
-					     (1 << pScreenPriv->screen->fb.depth),
-					     defs);
+                                             (1 << pScreenPriv->screen->fb.
+                                              depth), defs);
 
     /* recolor hardware cursor */
     if (pScreenPriv->card->cfuncs->recolorCursor)
-	(*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, 0, 0);
+        (*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, 0, 0);
 }
 
 /*
@@ -83,38 +83,38 @@ KdSetColormap (ScreenPtr pScreen)
  * the current colormap
  */
 void
-KdEnableColormap (ScreenPtr pScreen)
+KdEnableColormap(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    int	    i;
+    int i;
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
-
-    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH)
-    {
-	for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
-	    pScreenPriv->systemPalette[i].pixel = i;
-	(*pScreenPriv->card->cfuncs->getColors) (pScreen,
-						 (1 << pScreenPriv->screen->fb.depth),
-						 pScreenPriv->systemPalette);
+        return;
+
+    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH) {
+        for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
+            pScreenPriv->systemPalette[i].pixel = i;
+        (*pScreenPriv->card->cfuncs->getColors) (pScreen,
+                                                 (1 << pScreenPriv->screen->fb.
+                                                  depth),
+                                                 pScreenPriv->systemPalette);
     }
-    KdSetColormap (pScreen);
+    KdSetColormap(pScreen);
 }
 
 void
-KdDisableColormap (ScreenPtr pScreen)
+KdDisableColormap(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
+        return;
 
-    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH)
-    {
-	(*pScreenPriv->card->cfuncs->putColors) (pScreen,
-						 (1 << pScreenPriv->screen->fb.depth),
-						 pScreenPriv->systemPalette);
+    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH) {
+        (*pScreenPriv->card->cfuncs->putColors) (pScreen,
+                                                 (1 << pScreenPriv->screen->fb.
+                                                  depth),
+                                                 pScreenPriv->systemPalette);
     }
 }
 
@@ -128,22 +128,22 @@ KdDisableColormap (ScreenPtr pScreen)
  * colormap and realize it into the Windows system palette.
  */
 void
-KdInstallColormap (ColormapPtr pCmap)
+KdInstallColormap(ColormapPtr pCmap)
 {
     KdScreenPriv(pCmap->pScreen);
 
     if (pCmap == pScreenPriv->pInstalledmap)
-	return;
+        return;
 
     /* Tell X clients that the installed colormap is going away. */
     if (pScreenPriv->pInstalledmap)
-	WalkTree(pScreenPriv->pInstalledmap->pScreen, TellLostMap,
-		 (pointer) &(pScreenPriv->pInstalledmap->mid));
+        WalkTree(pScreenPriv->pInstalledmap->pScreen, TellLostMap,
+                 (pointer) &(pScreenPriv->pInstalledmap->mid));
 
     /* Take note of the new installed colorscreen-> */
     pScreenPriv->pInstalledmap = pCmap;
 
-    KdSetColormap (pCmap->pScreen);
+    KdSetColormap(pCmap->pScreen);
 
     /* Tell X clients of the new colormap */
     WalkTree(pCmap->pScreen, TellGainedMap, (pointer) &(pCmap->mid));
@@ -157,45 +157,42 @@ KdInstallColormap (ColormapPtr pCmap)
  * The default X colormap itself cannot be uninstalled.
  */
 void
-KdUninstallColormap (ColormapPtr pCmap)
+KdUninstallColormap(ColormapPtr pCmap)
 {
     KdScreenPriv(pCmap->pScreen);
-    Colormap	defMapID;
+    Colormap defMapID;
     ColormapPtr defMap;
 
     /* ignore if not installed */
     if (pCmap != pScreenPriv->pInstalledmap)
-	return;
+        return;
 
     /* ignore attempts to uninstall default colormap */
     defMapID = pCmap->pScreen->defColormap;
     if ((Colormap) pCmap->mid == defMapID)
-	return;
+        return;
 
     /* install default */
-    dixLookupResourceByType((pointer *)&defMap, defMapID, RT_COLORMAP,
-			    serverClient, DixInstallAccess);
+    dixLookupResourceByType((pointer *) &defMap, defMapID, RT_COLORMAP,
+                            serverClient, DixInstallAccess);
     if (defMap)
-	(*pCmap->pScreen->InstallColormap)(defMap);
-    else
-    {
-	/* uninstall and clear colormap pointer */
-	WalkTree(pCmap->pScreen, TellLostMap,
-		 (pointer) &(pCmap->mid));
-	pScreenPriv->pInstalledmap = 0;
+        (*pCmap->pScreen->InstallColormap) (defMap);
+    else {
+        /* uninstall and clear colormap pointer */
+        WalkTree(pCmap->pScreen, TellLostMap, (pointer) &(pCmap->mid));
+        pScreenPriv->pInstalledmap = 0;
     }
 }
 
 int
-KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps)
+KdListInstalledColormaps(ScreenPtr pScreen, Colormap * pCmaps)
 {
     KdScreenPriv(pScreen);
-    int		n = 0;
+    int n = 0;
 
-    if (pScreenPriv->pInstalledmap)
-    {
-	*pCmaps++ = pScreenPriv->pInstalledmap->mid;
-	n++;
+    if (pScreenPriv->pInstalledmap) {
+        *pCmaps++ = pScreenPriv->pInstalledmap->mid;
+        n++;
     }
     return n;
 }
@@ -208,39 +205,39 @@ KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps)
  * colormap; it can be either the default colormap or a private colorscreen->
  */
 void
-KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs)
+KdStoreColors(ColormapPtr pCmap, int ndef, xColorItem * pdefs)
 {
     KdScreenPriv(pCmap->pScreen);
-    VisualPtr           pVisual;
-    xColorItem          expanddefs[KD_MAX_PSEUDO_SIZE];
+    VisualPtr pVisual;
+    xColorItem expanddefs[KD_MAX_PSEUDO_SIZE];
 
     if (pCmap != pScreenPriv->pInstalledmap)
-	return;
+        return;
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
+        return;
 
     if (pScreenPriv->screen->fb.depth > KD_MAX_PSEUDO_DEPTH)
-	return;
+        return;
 
     if (!pScreenPriv->enabled)
-	return;
+        return;
 
     /* Check for DirectColor or TrueColor being simulated on a PseudoColor device. */
     pVisual = pCmap->pVisual;
-    if ((pVisual->class | DynamicClass) == DirectColor)
-    {
-	/*
-	 * Expand DirectColor or TrueColor color values into a PseudoColor
-	 * format.  Defer to the Color Framebuffer (CFB) code to do that.
-	 */
-	ndef = fbExpandDirectColors(pCmap, ndef, pdefs, expanddefs);
-	pdefs = expanddefs;
+    if ((pVisual->class | DynamicClass) == DirectColor) {
+        /*
+         * Expand DirectColor or TrueColor color values into a PseudoColor
+         * format.  Defer to the Color Framebuffer (CFB) code to do that.
+         */
+        ndef = fbExpandDirectColors(pCmap, ndef, pdefs, expanddefs);
+        pdefs = expanddefs;
     }
 
     (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, ndef, pdefs);
 
     /* recolor hardware cursor */
     if (pScreenPriv->card->cfuncs->recolorCursor)
-	(*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, ndef, pdefs);
+        (*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, ndef,
+                                                     pdefs);
 }
diff --git a/hw/kdrive/src/kdrive.c b/hw/kdrive/src/kdrive.c
index f6cc351cd..f65ab96bc 100644
--- a/hw/kdrive/src/kdrive.c
+++ b/hw/kdrive/src/kdrive.c
@@ -46,197 +46,191 @@
 #include <signal.h>
 
 typedef struct _kdDepths {
-    CARD8   depth;
-    CARD8   bpp;
+    CARD8 depth;
+    CARD8 bpp;
 } KdDepths;
 
-KdDepths    kdDepths[] = {
-    { 1, 1 },
-    { 4, 4 },
-    { 8, 8 },
-    { 15, 16 },
-    { 16, 16 },
-    { 24, 32 },
-    { 32, 32 }
+KdDepths kdDepths[] = {
+    {1, 1},
+    {4, 4},
+    {8, 8},
+    {15, 16},
+    {16, 16},
+    {24, 32},
+    {32, 32}
 };
 
 #define NUM_KD_DEPTHS (sizeof (kdDepths) / sizeof (kdDepths[0]))
 
 #define KD_DEFAULT_BUTTONS 5
 
-DevPrivateKeyRec    kdScreenPrivateKeyRec;
-unsigned long	    kdGeneration;
-
-Bool                kdVideoTest;
-unsigned long       kdVideoTestTime;
-Bool		    kdEmulateMiddleButton;
-Bool		    kdRawPointerCoordinates;
-Bool		    kdDisableZaphod;
-Bool                kdAllowZap;
-Bool		    kdEnabled;
-int		    kdSubpixelOrder;
-int		    kdVirtualTerminal = -1;
-Bool		    kdSwitchPending;
-char		    *kdSwitchCmd;
-DDXPointRec	    kdOrigin;
-Bool		    kdHasPointer = FALSE;
-Bool		    kdHasKbd = FALSE;
-
-static Bool         kdCaughtSignal = FALSE;
+DevPrivateKeyRec kdScreenPrivateKeyRec;
+unsigned long kdGeneration;
+
+Bool kdVideoTest;
+unsigned long kdVideoTestTime;
+Bool kdEmulateMiddleButton;
+Bool kdRawPointerCoordinates;
+Bool kdDisableZaphod;
+Bool kdAllowZap;
+Bool kdEnabled;
+int kdSubpixelOrder;
+int kdVirtualTerminal = -1;
+Bool kdSwitchPending;
+char *kdSwitchCmd;
+DDXPointRec kdOrigin;
+Bool kdHasPointer = FALSE;
+Bool kdHasKbd = FALSE;
+
+static Bool kdCaughtSignal = FALSE;
 
 /*
  * Carry arguments from InitOutput through driver initialization
  * to KdScreenInit
  */
 
-KdOsFuncs	*kdOsFuncs;
+KdOsFuncs *kdOsFuncs;
 
 void
-KdDisableScreen (ScreenPtr pScreen)
+KdDisableScreen(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
 
     if (!pScreenPriv->enabled)
-	return;
+        return;
     if (!pScreenPriv->closed)
-	SetRootClip (pScreen, FALSE);
-    KdDisableColormap (pScreen);
+        SetRootClip(pScreen, FALSE);
+    KdDisableColormap(pScreen);
     if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->disableAccel)
-	(*pScreenPriv->card->cfuncs->disableAccel) (pScreen);
-    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->disableCursor)
-	(*pScreenPriv->card->cfuncs->disableCursor) (pScreen);
+        (*pScreenPriv->card->cfuncs->disableAccel) (pScreen);
+    if (!pScreenPriv->screen->softCursor &&
+        pScreenPriv->card->cfuncs->disableCursor)
+        (*pScreenPriv->card->cfuncs->disableCursor) (pScreen);
     if (pScreenPriv->card->cfuncs->dpms)
-	(*pScreenPriv->card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
+        (*pScreenPriv->card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
     pScreenPriv->enabled = FALSE;
-    if(pScreenPriv->card->cfuncs->disable)
+    if (pScreenPriv->card->cfuncs->disable)
         (*pScreenPriv->card->cfuncs->disable) (pScreen);
 }
 
 static void
-KdDoSwitchCmd (const char *reason)
+KdDoSwitchCmd(const char *reason)
 {
-    if (kdSwitchCmd)
-    {
-	char    *command;
-
-	if (asprintf(&command, "%s %s", kdSwitchCmd, reason) == -1)
-	    return;
-	system (command);
-	free(command);
+    if (kdSwitchCmd) {
+        char *command;
+
+        if (asprintf(&command, "%s %s", kdSwitchCmd, reason) == -1)
+            return;
+        system(command);
+        free(command);
     }
 }
 
 void
-KdSuspend (void)
+KdSuspend(void)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (kdEnabled)
-    {
-	for (card = kdCardInfo; card; card = card->next)
-	{
-	    for (screen = card->screenList; screen; screen = screen->next)
-		if (screen->mynum == card->selected && screen->pScreen)
-		    KdDisableScreen (screen->pScreen);
-	    if (card->driver && card->cfuncs->restore)
-		(*card->cfuncs->restore) (card);
-	}
-	KdDisableInput ();
-	KdDoSwitchCmd ("suspend");
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (kdEnabled) {
+        for (card = kdCardInfo; card; card = card->next) {
+            for (screen = card->screenList; screen; screen = screen->next)
+                if (screen->mynum == card->selected && screen->pScreen)
+                    KdDisableScreen(screen->pScreen);
+            if (card->driver && card->cfuncs->restore)
+                (*card->cfuncs->restore) (card);
+        }
+        KdDisableInput();
+        KdDoSwitchCmd("suspend");
     }
 }
 
 void
-KdDisableScreens (void)
+KdDisableScreens(void)
 {
-    KdSuspend ();
-    if (kdEnabled)
-    {
+    KdSuspend();
+    if (kdEnabled) {
         if (kdOsFuncs->Disable)
             (*kdOsFuncs->Disable) ();
-	kdEnabled = FALSE;
+        kdEnabled = FALSE;
     }
 }
 
 Bool
-KdEnableScreen (ScreenPtr pScreen)
+KdEnableScreen(ScreenPtr pScreen)
 {
-    KdScreenPriv (pScreen);
+    KdScreenPriv(pScreen);
 
     if (pScreenPriv->enabled)
-	return TRUE;
-    if(pScreenPriv->card->cfuncs->enable)
-	if (!(*pScreenPriv->card->cfuncs->enable) (pScreen))
-	    return FALSE;
+        return TRUE;
+    if (pScreenPriv->card->cfuncs->enable)
+        if (!(*pScreenPriv->card->cfuncs->enable) (pScreen))
+            return FALSE;
     pScreenPriv->enabled = TRUE;
     pScreenPriv->dpmsState = KD_DPMS_NORMAL;
     pScreenPriv->card->selected = pScreenPriv->screen->mynum;
-    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->enableCursor)
-	(*pScreenPriv->card->cfuncs->enableCursor) (pScreen);
+    if (!pScreenPriv->screen->softCursor &&
+        pScreenPriv->card->cfuncs->enableCursor)
+        (*pScreenPriv->card->cfuncs->enableCursor) (pScreen);
     if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->enableAccel)
-	(*pScreenPriv->card->cfuncs->enableAccel) (pScreen);
-    KdEnableColormap (pScreen);
-    SetRootClip (pScreen, TRUE);
+        (*pScreenPriv->card->cfuncs->enableAccel) (pScreen);
+    KdEnableColormap(pScreen);
+    SetRootClip(pScreen, TRUE);
     if (pScreenPriv->card->cfuncs->dpms)
-	(*pScreenPriv->card->cfuncs->dpms) (pScreen, pScreenPriv->dpmsState);
+        (*pScreenPriv->card->cfuncs->dpms) (pScreen, pScreenPriv->dpmsState);
     return TRUE;
 }
 
 void
-KdResume (void)
+KdResume(void)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (kdEnabled)
-    {
-	KdDoSwitchCmd ("resume");
-	for (card = kdCardInfo; card; card = card->next)
-	{
-	    if(card->cfuncs->preserve)
-		(*card->cfuncs->preserve) (card);
-	    for (screen = card->screenList; screen; screen = screen->next)
-		if (screen->mynum == card->selected && screen->pScreen)
-		    KdEnableScreen (screen->pScreen);
-	}
-	KdEnableInput ();
-	KdReleaseAllKeys ();
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (kdEnabled) {
+        KdDoSwitchCmd("resume");
+        for (card = kdCardInfo; card; card = card->next) {
+            if (card->cfuncs->preserve)
+                (*card->cfuncs->preserve) (card);
+            for (screen = card->screenList; screen; screen = screen->next)
+                if (screen->mynum == card->selected && screen->pScreen)
+                    KdEnableScreen(screen->pScreen);
+        }
+        KdEnableInput();
+        KdReleaseAllKeys();
     }
 }
 
 void
-KdEnableScreens (void)
+KdEnableScreens(void)
 {
-    if (!kdEnabled)
-    {
-	kdEnabled = TRUE;
+    if (!kdEnabled) {
+        kdEnabled = TRUE;
         if (kdOsFuncs->Enable)
             (*kdOsFuncs->Enable) ();
     }
-    KdResume ();
+    KdResume();
 }
 
 void
-KdProcessSwitch (void)
+KdProcessSwitch(void)
 {
     if (kdEnabled)
-	KdDisableScreens ();
+        KdDisableScreens();
     else
-	KdEnableScreens ();
+        KdEnableScreens();
 }
 
 void
 AbortDDX(enum ExitCode error)
 {
-    KdDisableScreens ();
-    if (kdOsFuncs)
-    {
-	if (kdEnabled && kdOsFuncs->Disable)
-	    (*kdOsFuncs->Disable) ();
+    KdDisableScreens();
+    if (kdOsFuncs) {
+        if (kdEnabled && kdOsFuncs->Disable)
+            (*kdOsFuncs->Disable) ();
         if (kdOsFuncs->Fini)
             (*kdOsFuncs->Fini) ();
-	KdDoSwitchCmd ("stop");
+        KdDoSwitchCmd("stop");
     }
 
     if (kdCaughtSignal)
@@ -244,58 +238,56 @@ AbortDDX(enum ExitCode error)
 }
 
 void
-ddxGiveUp (enum ExitCode error)
+ddxGiveUp(enum ExitCode error)
 {
-    AbortDDX (error);
+    AbortDDX(error);
 }
 
-Bool	kdDumbDriver;
-Bool	kdSoftCursor;
+Bool kdDumbDriver;
+Bool kdSoftCursor;
 
 char *
-KdParseFindNext (char *cur, const char *delim, char *save, char *last)
+KdParseFindNext(char *cur, const char *delim, char *save, char *last)
 {
-    while (*cur && !strchr (delim, *cur))
-    {
-	*save++ = *cur++;
+    while (*cur && !strchr(delim, *cur)) {
+        *save++ = *cur++;
     }
     *save = 0;
     *last = *cur;
     if (*cur)
-	cur++;
+        cur++;
     return cur;
 }
 
 Rotation
-KdAddRotation (Rotation a, Rotation b)
+KdAddRotation(Rotation a, Rotation b)
 {
-    Rotation	rotate = (a & RR_Rotate_All) * (b & RR_Rotate_All);
-    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
+    Rotation rotate = (a & RR_Rotate_All) * (b & RR_Rotate_All);
+    Rotation reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
 
     if (rotate > RR_Rotate_270)
-	rotate /= (RR_Rotate_270 * RR_Rotate_90);
+        rotate /= (RR_Rotate_270 * RR_Rotate_90);
     return reflect | rotate;
 }
 
 Rotation
-KdSubRotation (Rotation a, Rotation b)
+KdSubRotation(Rotation a, Rotation b)
 {
-    Rotation	rotate = (a & RR_Rotate_All) * 16 / (b & RR_Rotate_All);
-    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
+    Rotation rotate = (a & RR_Rotate_All) * 16 / (b & RR_Rotate_All);
+    Rotation reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
 
     if (rotate > RR_Rotate_270)
-	rotate /= (RR_Rotate_270 * RR_Rotate_90);
+        rotate /= (RR_Rotate_270 * RR_Rotate_90);
     return reflect | rotate;
 }
 
 void
-KdParseScreen (KdScreenInfo *screen,
-	       char	    *arg)
+KdParseScreen(KdScreenInfo * screen, char *arg)
 {
-    char    delim;
-    char    save[1024];
-    int	    i;
-    int	    pixels, mm;
+    char delim;
+    char save[1024];
+    int i;
+    int pixels, mm;
 
     screen->dumb = kdDumbDriver;
     screen->softCursor = kdSoftCursor;
@@ -309,39 +301,35 @@ KdParseScreen (KdScreenInfo *screen,
     screen->rate = 0;
     screen->fb.depth = 0;
     if (!arg)
-	return;
-    if (strlen (arg) >= sizeof (save))
-	return;
-
-    for (i = 0; i < 2; i++)
-    {
-	arg = KdParseFindNext (arg, "x/@XY", save, &delim);
-	if (!save[0])
-	    return;
-
-	pixels = atoi(save);
-	mm = 0;
-
-	if (delim == '/')
-	{
-	    arg = KdParseFindNext (arg, "x@XY", save, &delim);
-	    if (!save[0])
-		return;
-	    mm = atoi(save);
-	}
-
-	if (i == 0)
-	{
-	    screen->width = pixels;
-	    screen->width_mm = mm;
-	}
-	else
-	{
-	    screen->height = pixels;
-	    screen->height_mm = mm;
-	}
-	if (delim != 'x' && delim != '@' && delim != 'X' && delim != 'Y')
-	    return;
+        return;
+    if (strlen(arg) >= sizeof(save))
+        return;
+
+    for (i = 0; i < 2; i++) {
+        arg = KdParseFindNext(arg, "x/@XY", save, &delim);
+        if (!save[0])
+            return;
+
+        pixels = atoi(save);
+        mm = 0;
+
+        if (delim == '/') {
+            arg = KdParseFindNext(arg, "x@XY", save, &delim);
+            if (!save[0])
+                return;
+            mm = atoi(save);
+        }
+
+        if (i == 0) {
+            screen->width = pixels;
+            screen->width_mm = mm;
+        }
+        else {
+            screen->height = pixels;
+            screen->height_mm = mm;
+        }
+        if (delim != 'x' && delim != '@' && delim != 'X' && delim != 'Y')
+            return;
     }
 
     kdOrigin.x += screen->width;
@@ -350,55 +338,49 @@ KdParseScreen (KdScreenInfo *screen,
     kdSoftCursor = FALSE;
     kdSubpixelOrder = SubPixelUnknown;
 
-    if (delim == '@')
-    {
-	arg = KdParseFindNext (arg, "xXY", save, &delim);
-	if (save[0])
-	{
-	    int	    rotate = atoi (save);
-	    if (rotate < 45)
-		screen->randr = RR_Rotate_0;
-	    else if (rotate < 135)
-		screen->randr = RR_Rotate_90;
-	    else if (rotate < 225)
-		screen->randr = RR_Rotate_180;
-	    else if (rotate < 315)
-		screen->randr = RR_Rotate_270;
-	    else
-		screen->randr = RR_Rotate_0;
-	}
+    if (delim == '@') {
+        arg = KdParseFindNext(arg, "xXY", save, &delim);
+        if (save[0]) {
+            int rotate = atoi(save);
+
+            if (rotate < 45)
+                screen->randr = RR_Rotate_0;
+            else if (rotate < 135)
+                screen->randr = RR_Rotate_90;
+            else if (rotate < 225)
+                screen->randr = RR_Rotate_180;
+            else if (rotate < 315)
+                screen->randr = RR_Rotate_270;
+            else
+                screen->randr = RR_Rotate_0;
+        }
     }
-    if (delim == 'X')
-    {
-	arg = KdParseFindNext (arg, "xY", save, &delim);
-	screen->randr |= RR_Reflect_X;
+    if (delim == 'X') {
+        arg = KdParseFindNext(arg, "xY", save, &delim);
+        screen->randr |= RR_Reflect_X;
     }
 
-    if (delim == 'Y')
-    {
-	arg = KdParseFindNext (arg, "xY", save, &delim);
-	screen->randr |= RR_Reflect_Y;
+    if (delim == 'Y') {
+        arg = KdParseFindNext(arg, "xY", save, &delim);
+        screen->randr |= RR_Reflect_Y;
     }
 
-    arg = KdParseFindNext (arg, "x/,", save, &delim);
-    if (save[0])
-    {
-	screen->fb.depth = atoi(save);
-	if (delim == '/')
-	{
-	    arg = KdParseFindNext (arg, "x,", save, &delim);
-	    if (save[0])
-		screen->fb.bitsPerPixel = atoi (save);
-	}
-	else
-	    screen->fb.bitsPerPixel = 0;
+    arg = KdParseFindNext(arg, "x/,", save, &delim);
+    if (save[0]) {
+        screen->fb.depth = atoi(save);
+        if (delim == '/') {
+            arg = KdParseFindNext(arg, "x,", save, &delim);
+            if (save[0])
+                screen->fb.bitsPerPixel = atoi(save);
+        }
+        else
+            screen->fb.bitsPerPixel = 0;
     }
 
-    if (delim == 'x')
-    {
-	arg = KdParseFindNext (arg, "x", save, &delim);
-	if (save[0])
-	    screen->rate = atoi(save);
+    if (delim == 'x') {
+        arg = KdParseFindNext(arg, "x", save, &delim);
+        if (save[0])
+            screen->rate = atoi(save);
     }
 }
 
@@ -414,162 +396,154 @@ KdParseScreen (KdScreenInfo *screen,
  */
 
 void
-KdParseRgba (char *rgba)
+KdParseRgba(char *rgba)
 {
-    if (!strcmp (rgba, "rgb"))
-	kdSubpixelOrder = SubPixelHorizontalRGB;
-    else if (!strcmp (rgba, "bgr"))
-	kdSubpixelOrder = SubPixelHorizontalBGR;
-    else if (!strcmp (rgba, "vrgb"))
-	kdSubpixelOrder = SubPixelVerticalRGB;
-    else if (!strcmp (rgba, "vbgr"))
-	kdSubpixelOrder = SubPixelVerticalBGR;
-    else if (!strcmp (rgba, "none"))
-	kdSubpixelOrder = SubPixelNone;
+    if (!strcmp(rgba, "rgb"))
+        kdSubpixelOrder = SubPixelHorizontalRGB;
+    else if (!strcmp(rgba, "bgr"))
+        kdSubpixelOrder = SubPixelHorizontalBGR;
+    else if (!strcmp(rgba, "vrgb"))
+        kdSubpixelOrder = SubPixelVerticalRGB;
+    else if (!strcmp(rgba, "vbgr"))
+        kdSubpixelOrder = SubPixelVerticalBGR;
+    else if (!strcmp(rgba, "none"))
+        kdSubpixelOrder = SubPixelNone;
     else
-	kdSubpixelOrder = SubPixelUnknown;
+        kdSubpixelOrder = SubPixelUnknown;
 }
 
 void
-KdUseMsg (void)
+KdUseMsg(void)
 {
     ErrorF("\nTinyX Device Dependent Usage:\n");
-    ErrorF("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP[xFREQ]]  Specify screen characteristics\n");
-    ErrorF("-rgba rgb/bgr/vrgb/vbgr/none   Specify subpixel ordering for LCD panels\n");
-    ErrorF("-mouse driver [,n,,options]    Specify the pointer driver and its options (n is the number of buttons)\n");
-    ErrorF("-keybd driver [,,options]      Specify the keyboard driver and its options\n");
+    ErrorF
+        ("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP[xFREQ]]  Specify screen characteristics\n");
+    ErrorF
+        ("-rgba rgb/bgr/vrgb/vbgr/none   Specify subpixel ordering for LCD panels\n");
+    ErrorF
+        ("-mouse driver [,n,,options]    Specify the pointer driver and its options (n is the number of buttons)\n");
+    ErrorF
+        ("-keybd driver [,,options]      Specify the keyboard driver and its options\n");
     ErrorF("-zaphod          Disable cursor screen switching\n");
     ErrorF("-2button         Emulate 3 button mouse\n");
     ErrorF("-3button         Disable 3 button mouse emulation\n");
-    ErrorF("-rawcoord        Don't transform pointer coordinates on rotation\n");
+    ErrorF
+        ("-rawcoord        Don't transform pointer coordinates on rotation\n");
     ErrorF("-dumb            Disable hardware acceleration\n");
     ErrorF("-softCursor      Force software cursor\n");
     ErrorF("-videoTest       Start the server, pause momentarily and exit\n");
-    ErrorF("-origin X,Y      Locates the next screen in the the virtual screen (Xinerama)\n");
+    ErrorF
+        ("-origin X,Y      Locates the next screen in the the virtual screen (Xinerama)\n");
     ErrorF("-switchCmd       Command to execute on vt switch\n");
     ErrorF("-zap             Terminate server on Ctrl+Alt+Backspace\n");
-    ErrorF("vtxx             Use virtual terminal xx instead of the next available\n");
+    ErrorF
+        ("vtxx             Use virtual terminal xx instead of the next available\n");
 }
 
 int
-KdProcessArgument (int argc, char **argv, int i)
+KdProcessArgument(int argc, char **argv, int i)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (!strcmp (argv[i], "-screen"))
-    {
-	if ((i+1) < argc)
-	{
-	    card = KdCardInfoLast ();
-	    if (!card)
-	    {
-		InitCard (0);
-		card = KdCardInfoLast ();
-	    }
-	    if (card) {
-		screen = KdScreenInfoAdd (card);
-		KdParseScreen (screen, argv[i+1]);
-	    } else
-		ErrorF("No matching card found!\n");
-	}
-	else
-	    UseMsg ();
-	return 2;
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (!strcmp(argv[i], "-screen")) {
+        if ((i + 1) < argc) {
+            card = KdCardInfoLast();
+            if (!card) {
+                InitCard(0);
+                card = KdCardInfoLast();
+            }
+            if (card) {
+                screen = KdScreenInfoAdd(card);
+                KdParseScreen(screen, argv[i + 1]);
+            }
+            else
+                ErrorF("No matching card found!\n");
+        }
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strcmp (argv[i], "-zaphod"))
-    {
-	kdDisableZaphod = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-zaphod")) {
+        kdDisableZaphod = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-zap"))
-    {
-	kdAllowZap = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-zap")) {
+        kdAllowZap = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-3button"))
-    {
-	kdEmulateMiddleButton = FALSE;
-	return 1;
+    if (!strcmp(argv[i], "-3button")) {
+        kdEmulateMiddleButton = FALSE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-2button"))
-    {
-	kdEmulateMiddleButton = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-2button")) {
+        kdEmulateMiddleButton = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-rawcoord"))
-    {
-	kdRawPointerCoordinates = 1;
-	return 1;
+    if (!strcmp(argv[i], "-rawcoord")) {
+        kdRawPointerCoordinates = 1;
+        return 1;
     }
-    if (!strcmp (argv[i], "-dumb"))
-    {
-	kdDumbDriver = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-dumb")) {
+        kdDumbDriver = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-softCursor"))
-    {
-	kdSoftCursor = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-softCursor")) {
+        kdSoftCursor = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-videoTest"))
-    {
-	kdVideoTest = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-videoTest")) {
+        kdVideoTest = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-origin"))
-    {
-	if ((i+1) < argc)
-	{
-	    char    *x = argv[i+1];
-	    char    *y = strchr (x, ',');
-	    if (x)
-		kdOrigin.x = atoi (x);
-	    else
-		kdOrigin.x = 0;
-	    if (y)
-		kdOrigin.y = atoi(y+1);
-	    else
-		kdOrigin.y = 0;
-	}
-	else
-	    UseMsg ();
-	return 2;
+    if (!strcmp(argv[i], "-origin")) {
+        if ((i + 1) < argc) {
+            char *x = argv[i + 1];
+            char *y = strchr(x, ',');
+
+            if (x)
+                kdOrigin.x = atoi(x);
+            else
+                kdOrigin.x = 0;
+            if (y)
+                kdOrigin.y = atoi(y + 1);
+            else
+                kdOrigin.y = 0;
+        }
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strcmp (argv[i], "-rgba"))
-    {
-	if ((i+1) < argc)
-	    KdParseRgba (argv[i+1]);
-	else
-	    UseMsg ();
-	return 2;
+    if (!strcmp(argv[i], "-rgba")) {
+        if ((i + 1) < argc)
+            KdParseRgba(argv[i + 1]);
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strcmp (argv[i], "-switchCmd"))
-    {
-	if ((i+1) < argc)
-	    kdSwitchCmd = argv[i+1];
-	else
-	    UseMsg ();
-	return 2;
+    if (!strcmp(argv[i], "-switchCmd")) {
+        if ((i + 1) < argc)
+            kdSwitchCmd = argv[i + 1];
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strncmp (argv[i], "vt", 2) &&
-	sscanf (argv[i], "vt%2d", &kdVirtualTerminal) == 1)
-    {
-	return 1;
+    if (!strncmp(argv[i], "vt", 2) &&
+        sscanf(argv[i], "vt%2d", &kdVirtualTerminal) == 1) {
+        return 1;
     }
-    if (!strcmp (argv[i], "-mouse") ||
-        !strcmp (argv[i], "-pointer")) {
+    if (!strcmp(argv[i], "-mouse") || !strcmp(argv[i], "-pointer")) {
         if (i + 1 >= argc)
             UseMsg();
         KdAddConfigPointer(argv[i + 1]);
-	kdHasPointer = TRUE;
+        kdHasPointer = TRUE;
         return 2;
     }
-    if (!strcmp (argv[i], "-keybd")) {
+    if (!strcmp(argv[i], "-keybd")) {
         if (i + 1 >= argc)
             UseMsg();
         KdAddConfigKeyboard(argv[i + 1]);
-	kdHasKbd = TRUE;
+        kdHasKbd = TRUE;
         return 2;
     }
 
@@ -582,116 +556,110 @@ KdProcessArgument (int argc, char **argv, int i)
  */
 
 void
-KdOsInit (KdOsFuncs *pOsFuncs)
+KdOsInit(KdOsFuncs * pOsFuncs)
 {
     kdOsFuncs = pOsFuncs;
-    if (pOsFuncs)
-    {
-	if (serverGeneration == 1)
-	{
-	    KdDoSwitchCmd ("start");
+    if (pOsFuncs) {
+        if (serverGeneration == 1) {
+            KdDoSwitchCmd("start");
             if (pOsFuncs->Init)
                 (*pOsFuncs->Init) ();
-	}
+        }
     }
 }
 
 Bool
-KdAllocatePrivates (ScreenPtr pScreen)
+KdAllocatePrivates(ScreenPtr pScreen)
 {
-    KdPrivScreenPtr	pScreenPriv;
+    KdPrivScreenPtr pScreenPriv;
 
     if (kdGeneration != serverGeneration)
-	kdGeneration = serverGeneration;
+        kdGeneration = serverGeneration;
 
     if (!dixRegisterPrivateKey(&kdScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        return FALSE;
 
-    pScreenPriv = calloc(1, sizeof (*pScreenPriv));
+    pScreenPriv = calloc(1, sizeof(*pScreenPriv));
     if (!pScreenPriv)
-	return FALSE;
-    KdSetScreenPriv (pScreen, pScreenPriv);
+        return FALSE;
+    KdSetScreenPriv(pScreen, pScreenPriv);
     return TRUE;
 }
 
 Bool
-KdCreateScreenResources (ScreenPtr pScreen)
+KdCreateScreenResources(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdCardInfo	    *card = pScreenPriv->card;
+    KdCardInfo *card = pScreenPriv->card;
     Bool ret;
 
     pScreen->CreateScreenResources = pScreenPriv->CreateScreenResources;
-    if(pScreen->CreateScreenResources)
-	ret = (*pScreen->CreateScreenResources) (pScreen);
+    if (pScreen->CreateScreenResources)
+        ret = (*pScreen->CreateScreenResources) (pScreen);
     else
-	ret= -1;
+        ret = -1;
     pScreenPriv->CreateScreenResources = pScreen->CreateScreenResources;
     pScreen->CreateScreenResources = KdCreateScreenResources;
     if (ret && card->cfuncs->createRes)
-	ret = (*card->cfuncs->createRes) (pScreen);
+        ret = (*card->cfuncs->createRes) (pScreen);
     return ret;
 }
 
 Bool
-KdCloseScreen (int index, ScreenPtr pScreen)
+KdCloseScreen(int index, ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo    *screen = pScreenPriv->screen;
-    KdCardInfo	    *card = pScreenPriv->card;
-    Bool	    ret;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    KdCardInfo *card = pScreenPriv->card;
+    Bool ret;
 
     pScreenPriv->closed = TRUE;
     pScreen->CloseScreen = pScreenPriv->CloseScreen;
-    if(pScreen->CloseScreen)
+    if (pScreen->CloseScreen)
         ret = (*pScreen->CloseScreen) (index, pScreen);
     else
-	ret = TRUE;
+        ret = TRUE;
 
     if (pScreenPriv->dpmsState != KD_DPMS_NORMAL)
-	(*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
+        (*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
 
     if (screen->mynum == card->selected)
-	KdDisableScreen (pScreen);
+        KdDisableScreen(pScreen);
 
     /*
      * Restore video hardware when last screen is closed
      */
-    if (screen == card->screenList)
-    {
-	if (kdEnabled && card->cfuncs->restore)
-	    (*card->cfuncs->restore) (card);
+    if (screen == card->screenList) {
+        if (kdEnabled && card->cfuncs->restore)
+            (*card->cfuncs->restore) (card);
     }
 
     if (!pScreenPriv->screen->dumb && card->cfuncs->finiAccel)
-	(*card->cfuncs->finiAccel) (pScreen);
+        (*card->cfuncs->finiAccel) (pScreen);
 
     if (!pScreenPriv->screen->softCursor && card->cfuncs->finiCursor)
-	(*card->cfuncs->finiCursor) (pScreen);
+        (*card->cfuncs->finiCursor) (pScreen);
 
-    if(card->cfuncs->scrfini)
+    if (card->cfuncs->scrfini)
         (*card->cfuncs->scrfini) (screen);
 
     /*
      * Clean up card when last screen is closed, DIX closes them in
      * reverse order, thus we check for when the first in the list is closed
      */
-    if (screen == card->screenList)
-    {
-	if(card->cfuncs->cardfini)
-	    (*card->cfuncs->cardfini) (card);
-	/*
-	 * Clean up OS when last card is closed
-	 */
-	if (card == kdCardInfo)
-	{
-	    if (kdEnabled)
-	    {
-		kdEnabled = FALSE;
-		if(kdOsFuncs->Disable)
-		    (*kdOsFuncs->Disable) ();
-	    }
-	}
+    if (screen == card->screenList) {
+        if (card->cfuncs->cardfini)
+            (*card->cfuncs->cardfini) (card);
+        /*
+         * Clean up OS when last card is closed
+         */
+        if (card == kdCardInfo) {
+            if (kdEnabled) {
+                kdEnabled = FALSE;
+                if (kdOsFuncs->Disable)
+                    (*kdOsFuncs->Disable) ();
+            }
+        }
     }
 
     pScreenPriv->screen->pScreen = 0;
@@ -701,112 +669,107 @@ KdCloseScreen (int index, ScreenPtr pScreen)
 }
 
 Bool
-KdSaveScreen (ScreenPtr pScreen, int on)
+KdSaveScreen(ScreenPtr pScreen, int on)
 {
     KdScreenPriv(pScreen);
-    int	    dpmsState;
+    int dpmsState;
 
     if (!pScreenPriv->card->cfuncs->dpms)
-	return FALSE;
+        return FALSE;
 
     dpmsState = pScreenPriv->dpmsState;
     switch (on) {
     case SCREEN_SAVER_OFF:
-	dpmsState = KD_DPMS_NORMAL;
-	break;
+        dpmsState = KD_DPMS_NORMAL;
+        break;
     case SCREEN_SAVER_ON:
-	if (dpmsState == KD_DPMS_NORMAL)
-	    dpmsState = KD_DPMS_NORMAL+1;
-	break;
+        if (dpmsState == KD_DPMS_NORMAL)
+            dpmsState = KD_DPMS_NORMAL + 1;
+        break;
     case SCREEN_SAVER_CYCLE:
-	if (dpmsState < KD_DPMS_MAX)
-	    dpmsState++;
-	break;
+        if (dpmsState < KD_DPMS_MAX)
+            dpmsState++;
+        break;
     case SCREEN_SAVER_FORCER:
-	break;
+        break;
     }
-    if (dpmsState != pScreenPriv->dpmsState)
-    {
-	if (pScreenPriv->enabled)
-	    (*pScreenPriv->card->cfuncs->dpms) (pScreen, dpmsState);
-	pScreenPriv->dpmsState = dpmsState;
+    if (dpmsState != pScreenPriv->dpmsState) {
+        if (pScreenPriv->enabled)
+            (*pScreenPriv->card->cfuncs->dpms) (pScreen, dpmsState);
+        pScreenPriv->dpmsState = dpmsState;
     }
     return TRUE;
 }
 
 static Bool
-KdCreateWindow (WindowPtr pWin)
+KdCreateWindow(WindowPtr pWin)
 {
 #ifndef PHOENIX
-    if (!pWin->parent)
-    {
-	KdScreenPriv(pWin->drawable.pScreen);
-
-	if (!pScreenPriv->enabled)
-	{
-	    RegionEmpty(&pWin->borderClip);
-	    RegionBreak(&pWin->clipList);
-	}
+    if (!pWin->parent) {
+        KdScreenPriv(pWin->drawable.pScreen);
+
+        if (!pScreenPriv->enabled) {
+            RegionEmpty(&pWin->borderClip);
+            RegionBreak(&pWin->clipList);
+        }
     }
 #endif
-    return fbCreateWindow (pWin);
+    return fbCreateWindow(pWin);
 }
 
 void
-KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr)
+KdSetSubpixelOrder(ScreenPtr pScreen, Rotation randr)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    int			subpixel_order = screen->subpixel_order;
-    Rotation		subpixel_dir;
-    int			i;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int subpixel_order = screen->subpixel_order;
+    Rotation subpixel_dir;
+    int i;
 
     static struct {
-	int	    subpixel_order;
-	Rotation    direction;
+        int subpixel_order;
+        Rotation direction;
     } orders[] = {
-	{ SubPixelHorizontalRGB, 	RR_Rotate_0 },
-	{ SubPixelHorizontalBGR,	RR_Rotate_180 },
-	{ SubPixelVerticalRGB,		RR_Rotate_270 },
-	{ SubPixelVerticalBGR,		RR_Rotate_90 },
-    };
+        {
+        SubPixelHorizontalRGB, RR_Rotate_0}, {
+        SubPixelHorizontalBGR, RR_Rotate_180}, {
+        SubPixelVerticalRGB, RR_Rotate_270}, {
+    SubPixelVerticalBGR, RR_Rotate_90},};
 
     static struct {
-	int	bit;
-	int	normal;
-	int	reflect;
+        int bit;
+        int normal;
+        int reflect;
     } reflects[] = {
-	{ RR_Reflect_X, SubPixelHorizontalRGB,	SubPixelHorizontalBGR },
-	{ RR_Reflect_X, SubPixelHorizontalBGR,	SubPixelHorizontalRGB },
-	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalBGR },
-	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalRGB },
-    };
+        {
+        RR_Reflect_X, SubPixelHorizontalRGB, SubPixelHorizontalBGR}, {
+        RR_Reflect_X, SubPixelHorizontalBGR, SubPixelHorizontalRGB}, {
+        RR_Reflect_Y, SubPixelVerticalRGB, SubPixelVerticalBGR}, {
+    RR_Reflect_Y, SubPixelVerticalRGB, SubPixelVerticalRGB},};
 
     /* map subpixel to direction */
     for (i = 0; i < 4; i++)
-	if (orders[i].subpixel_order == subpixel_order)
-	    break;
-    if (i < 4)
-    {
-	subpixel_dir = KdAddRotation (randr & RR_Rotate_All, orders[i].direction);
-
-	/* map back to subpixel order */
-	for (i = 0; i < 4; i++)
-	    if (orders[i].direction & subpixel_dir)
-	    {
-		subpixel_order = orders[i].subpixel_order;
-		break;
-	    }
-	/* reflect */
-	for (i = 0; i < 4; i++)
-	    if ((randr & reflects[i].bit) &&
-		reflects[i].normal == subpixel_order)
-	    {
-		subpixel_order = reflects[i].reflect;
-		break;
-	    }
+        if (orders[i].subpixel_order == subpixel_order)
+            break;
+    if (i < 4) {
+        subpixel_dir =
+            KdAddRotation(randr & RR_Rotate_All, orders[i].direction);
+
+        /* map back to subpixel order */
+        for (i = 0; i < 4; i++)
+            if (orders[i].direction & subpixel_dir) {
+                subpixel_order = orders[i].subpixel_order;
+                break;
+            }
+        /* reflect */
+        for (i = 0; i < 4; i++)
+            if ((randr & reflects[i].bit) &&
+                reflects[i].normal == subpixel_order) {
+                subpixel_order = reflects[i].reflect;
+                break;
+            }
     }
-    PictureSetSubpixelOrder (pScreen, subpixel_order);
+    PictureSetSubpixelOrder(pScreen, subpixel_order);
 }
 
 /* Pass through AddScreen, which doesn't take any closure */
@@ -815,34 +778,33 @@ static KdScreenInfo *kdCurrentScreen;
 Bool
 KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
 {
-    KdScreenInfo	*screen = kdCurrentScreen;
-    KdCardInfo		*card = screen->card;
-    KdPrivScreenPtr	pScreenPriv;
+    KdScreenInfo *screen = kdCurrentScreen;
+    KdCardInfo *card = screen->card;
+    KdPrivScreenPtr pScreenPriv;
+
     /*
      * note that screen->fb is set up for the nominal orientation
      * of the screen; that means if randr is rotated, the values
      * there should reflect a rotated frame buffer (or shadow).
      */
-    Bool		rotated = (screen->randr & (RR_Rotate_90|RR_Rotate_270)) != 0;
-    int			width, height, *width_mmp, *height_mmp;
+    Bool rotated = (screen->randr & (RR_Rotate_90 | RR_Rotate_270)) != 0;
+    int width, height, *width_mmp, *height_mmp;
 
-    KdAllocatePrivates (pScreen);
+    KdAllocatePrivates(pScreen);
 
     pScreenPriv = KdGetScreenPriv(pScreen);
 
-    if (!rotated)
-    {
-	width = screen->width;
-	height = screen->height;
-	width_mmp = &screen->width_mm;
-	height_mmp = &screen->height_mm;
+    if (!rotated) {
+        width = screen->width;
+        height = screen->height;
+        width_mmp = &screen->width_mm;
+        height_mmp = &screen->height_mm;
     }
-    else
-    {
-	width = screen->height;
-	height = screen->width;
-	width_mmp = &screen->height_mm;
-	height_mmp = &screen->width_mm;
+    else {
+        width = screen->height;
+        height = screen->width;
+        width_mmp = &screen->height_mm;
+        height_mmp = &screen->width_mm;
     }
     screen->pScreen = pScreen;
     pScreenPriv->screen = screen;
@@ -853,41 +815,37 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
     pScreen->y = screen->origin.y;
 
     if (!monitorResolution)
-	monitorResolution = 75;
+        monitorResolution = 75;
     /*
      * This is done in this order so that backing store wraps
      * our GC functions; fbFinishScreenInit initializes MI
      * backing store
      */
-    if (!fbSetupScreen (pScreen,
-			screen->fb.frameBuffer,
-			width, height,
-			monitorResolution, monitorResolution,
-			screen->fb.pixelStride,
-			screen->fb.bitsPerPixel))
-    {
-	return FALSE;
+    if (!fbSetupScreen(pScreen,
+                       screen->fb.frameBuffer,
+                       width, height,
+                       monitorResolution, monitorResolution,
+                       screen->fb.pixelStride, screen->fb.bitsPerPixel)) {
+        return FALSE;
     }
 
     /*
      * Set colormap functions
      */
-    pScreen->InstallColormap	= KdInstallColormap;
-    pScreen->UninstallColormap	= KdUninstallColormap;
+    pScreen->InstallColormap = KdInstallColormap;
+    pScreen->UninstallColormap = KdUninstallColormap;
     pScreen->ListInstalledColormaps = KdListInstalledColormaps;
-    pScreen->StoreColors	= KdStoreColors;
-
-    pScreen->SaveScreen		= KdSaveScreen;
-    pScreen->CreateWindow	= KdCreateWindow;
-
-    if (!fbFinishScreenInit (pScreen,
-			     screen->fb.frameBuffer,
-			     width, height,
-			     monitorResolution, monitorResolution,
-			     screen->fb.pixelStride,
-			     screen->fb.bitsPerPixel))
-    {
-	return FALSE;
+    pScreen->StoreColors = KdStoreColors;
+
+    pScreen->SaveScreen = KdSaveScreen;
+    pScreen->CreateWindow = KdCreateWindow;
+
+    if (!fbFinishScreenInit(pScreen,
+                            screen->fb.frameBuffer,
+                            width, height,
+                            monitorResolution, monitorResolution,
+                            screen->fb.pixelStride, screen->fb.bitsPerPixel)) {
+        return FALSE;
     }
 
     /*
@@ -895,44 +853,44 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
      * Rounding errors are annoying
      */
     if (*width_mmp)
-	pScreen->mmWidth = *width_mmp;
+        pScreen->mmWidth = *width_mmp;
     else
-	*width_mmp = pScreen->mmWidth;
+        *width_mmp = pScreen->mmWidth;
     if (*height_mmp)
-	pScreen->mmHeight = *height_mmp;
+        pScreen->mmHeight = *height_mmp;
     else
-	*height_mmp = pScreen->mmHeight;
+        *height_mmp = pScreen->mmHeight;
 
     /*
      * Plug in our own block/wakeup handlers.
      * miScreenInit installs NoopDDA in both places
      */
-    pScreen->BlockHandler	= KdBlockHandler;
-    pScreen->WakeupHandler	= KdWakeupHandler;
+    pScreen->BlockHandler = KdBlockHandler;
+    pScreen->WakeupHandler = KdWakeupHandler;
 
-    if (!fbPictureInit (pScreen, 0, 0))
-	return FALSE;
+    if (!fbPictureInit(pScreen, 0, 0))
+        return FALSE;
     if (card->cfuncs->initScreen)
-	if (!(*card->cfuncs->initScreen) (pScreen))
-	    return FALSE;
+        if (!(*card->cfuncs->initScreen) (pScreen))
+            return FALSE;
 
     if (!screen->dumb && card->cfuncs->initAccel)
-	if (!(*card->cfuncs->initAccel) (pScreen))
-	    screen->dumb = TRUE;
+        if (!(*card->cfuncs->initAccel) (pScreen))
+            screen->dumb = TRUE;
 
     if (card->cfuncs->finishInitScreen)
-	if (!(*card->cfuncs->finishInitScreen) (pScreen))
-	    return FALSE;
+        if (!(*card->cfuncs->finishInitScreen) (pScreen))
+            return FALSE;
 
 #if 0
-    fbInitValidateTree (pScreen);
+    fbInitValidateTree(pScreen);
 #endif
 
     /*
      * Wrap CloseScreen, the order now is:
-     *	KdCloseScreen
-     *	miBSCloseScreen
-     *	fbCloseScreen
+     *  KdCloseScreen
+     *  miBSCloseScreen
+     *  fbCloseScreen
      */
     pScreenPriv->CloseScreen = pScreen->CloseScreen;
     pScreen->CloseScreen = KdCloseScreen;
@@ -941,78 +899,70 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
     pScreen->CreateScreenResources = KdCreateScreenResources;
 
     if (screen->softCursor ||
-	!card->cfuncs->initCursor ||
-	!(*card->cfuncs->initCursor) (pScreen))
-    {
-	/* Use MI for cursor display and event queueing. */
-	screen->softCursor = TRUE;
-	miDCInitialize(pScreen, &kdPointerScreenFuncs);
+        !card->cfuncs->initCursor || !(*card->cfuncs->initCursor) (pScreen)) {
+        /* Use MI for cursor display and event queueing. */
+        screen->softCursor = TRUE;
+        miDCInitialize(pScreen, &kdPointerScreenFuncs);
     }
 
-
-    if (!fbCreateDefColormap (pScreen))
-    {
-	return FALSE;
+    if (!fbCreateDefColormap(pScreen)) {
+        return FALSE;
     }
 
-    KdSetSubpixelOrder (pScreen, screen->randr);
+    KdSetSubpixelOrder(pScreen, screen->randr);
 
     /*
      * Enable the hardware
      */
-    if (!kdEnabled)
-    {
-	kdEnabled = TRUE;
-	if(kdOsFuncs->Enable)
-	    (*kdOsFuncs->Enable) ();
+    if (!kdEnabled) {
+        kdEnabled = TRUE;
+        if (kdOsFuncs->Enable)
+            (*kdOsFuncs->Enable) ();
     }
 
-    if (screen->mynum == card->selected)
-    {
-	if(card->cfuncs->preserve)
-	    (*card->cfuncs->preserve) (card);
-	if(card->cfuncs->enable)
-	    if (!(*card->cfuncs->enable) (pScreen))
-		return FALSE;
-	pScreenPriv->enabled = TRUE;
-	if (!screen->softCursor && card->cfuncs->enableCursor)
-	    (*card->cfuncs->enableCursor) (pScreen);
-	KdEnableColormap (pScreen);
-	if (!screen->dumb && card->cfuncs->enableAccel)
-	    (*card->cfuncs->enableAccel) (pScreen);
+    if (screen->mynum == card->selected) {
+        if (card->cfuncs->preserve)
+            (*card->cfuncs->preserve) (card);
+        if (card->cfuncs->enable)
+            if (!(*card->cfuncs->enable) (pScreen))
+                return FALSE;
+        pScreenPriv->enabled = TRUE;
+        if (!screen->softCursor && card->cfuncs->enableCursor)
+            (*card->cfuncs->enableCursor) (pScreen);
+        KdEnableColormap(pScreen);
+        if (!screen->dumb && card->cfuncs->enableAccel)
+            (*card->cfuncs->enableAccel) (pScreen);
     }
 
     return TRUE;
 }
 
 void
-KdInitScreen (ScreenInfo    *pScreenInfo,
-	      KdScreenInfo  *screen,
-	      int	    argc,
-	      char	    **argv)
+KdInitScreen(ScreenInfo * pScreenInfo,
+             KdScreenInfo * screen, int argc, char **argv)
 {
-    KdCardInfo	*card = screen->card;
+    KdCardInfo *card = screen->card;
 
     (*card->cfuncs->scrinit) (screen);
 
     if (!card->cfuncs->initAccel)
-	screen->dumb = TRUE;
+        screen->dumb = TRUE;
     if (!card->cfuncs->initCursor)
-	screen->softCursor = TRUE;
+        screen->softCursor = TRUE;
 }
 
 static Bool
-KdSetPixmapFormats (ScreenInfo	*pScreenInfo)
+KdSetPixmapFormats(ScreenInfo * pScreenInfo)
 {
-    CARD8	    depthToBpp[33];	/* depth -> bpp map */
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-    int		    i;
-    int		    bpp;
+    CARD8 depthToBpp[33];       /* depth -> bpp map */
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+    int i;
+    int bpp;
     PixmapFormatRec *format;
 
     for (i = 1; i <= 32; i++)
-	depthToBpp[i] = 0;
+        depthToBpp[i] = 0;
 
     /*
      * Generate mappings between bitsPerPixel and depth,
@@ -1020,148 +970,135 @@ KdSetPixmapFormats (ScreenInfo	*pScreenInfo)
      * restrictions on equivalent formats for the same
      * depth on different screens
      */
-    for (card = kdCardInfo; card; card = card->next)
-    {
-	for (screen = card->screenList; screen; screen = screen->next)
-	{
-	    bpp = screen->fb.bitsPerPixel;
-	    if (bpp == 24)
-		bpp = 32;
-	    if (!depthToBpp[screen->fb.depth])
-		depthToBpp[screen->fb.depth] = bpp;
-	    else if (depthToBpp[screen->fb.depth] != bpp)
-		return FALSE;
-	}
+    for (card = kdCardInfo; card; card = card->next) {
+        for (screen = card->screenList; screen; screen = screen->next) {
+            bpp = screen->fb.bitsPerPixel;
+            if (bpp == 24)
+                bpp = 32;
+            if (!depthToBpp[screen->fb.depth])
+                depthToBpp[screen->fb.depth] = bpp;
+            else if (depthToBpp[screen->fb.depth] != bpp)
+                return FALSE;
+        }
     }
 
     /*
      * Fill in additional formats
      */
     for (i = 0; i < NUM_KD_DEPTHS; i++)
-	if (!depthToBpp[kdDepths[i].depth])
-	    depthToBpp[kdDepths[i].depth] = kdDepths[i].bpp;
+        if (!depthToBpp[kdDepths[i].depth])
+            depthToBpp[kdDepths[i].depth] = kdDepths[i].bpp;
 
-    pScreenInfo->imageByteOrder     = IMAGE_BYTE_ORDER;
+    pScreenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
     pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
-    pScreenInfo->bitmapScanlinePad  = BITMAP_SCANLINE_PAD;
-    pScreenInfo->bitmapBitOrder     = BITMAP_BIT_ORDER;
+    pScreenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
+    pScreenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
 
     pScreenInfo->numPixmapFormats = 0;
 
-    for (i = 1; i <= 32; i++)
-    {
-	if (depthToBpp[i])
-	{
-	    format = &pScreenInfo->formats[pScreenInfo->numPixmapFormats++];
-	    format->depth = i;
-	    format->bitsPerPixel = depthToBpp[i];
-	    format->scanlinePad = BITMAP_SCANLINE_PAD;
-	}
+    for (i = 1; i <= 32; i++) {
+        if (depthToBpp[i]) {
+            format = &pScreenInfo->formats[pScreenInfo->numPixmapFormats++];
+            format->depth = i;
+            format->bitsPerPixel = depthToBpp[i];
+            format->scanlinePad = BITMAP_SCANLINE_PAD;
+        }
     }
 
     return TRUE;
 }
 
 static void
-KdAddScreen (ScreenInfo	    *pScreenInfo,
-	     KdScreenInfo   *screen,
-	     int	    argc,
-	     char	    **argv)
+KdAddScreen(ScreenInfo * pScreenInfo,
+            KdScreenInfo * screen, int argc, char **argv)
 {
-    int	    i;
+    int i;
+
     /*
      * Fill in fb visual type masks for this screen
      */
-    for (i = 0; i < pScreenInfo->numPixmapFormats; i++)
-    {
-	unsigned long	visuals;
-	Pixel		rm, gm, bm;
-
-	visuals = 0;
-	rm = gm = bm = 0;
-	if (pScreenInfo->formats[i].depth == screen->fb.depth)
-	{
-	    visuals = screen->fb.visuals;
-	    rm = screen->fb.redMask;
-	    gm = screen->fb.greenMask;
-	    bm = screen->fb.blueMask;
-	}
-	fbSetVisualTypesAndMasks (pScreenInfo->formats[i].depth,
-				  visuals,
-				  8,
-				  rm, gm, bm);
+    for (i = 0; i < pScreenInfo->numPixmapFormats; i++) {
+        unsigned long visuals;
+        Pixel rm, gm, bm;
+
+        visuals = 0;
+        rm = gm = bm = 0;
+        if (pScreenInfo->formats[i].depth == screen->fb.depth) {
+            visuals = screen->fb.visuals;
+            rm = screen->fb.redMask;
+            gm = screen->fb.greenMask;
+            bm = screen->fb.blueMask;
+        }
+        fbSetVisualTypesAndMasks(pScreenInfo->formats[i].depth,
+                                 visuals, 8, rm, gm, bm);
     }
 
     kdCurrentScreen = screen;
 
-    AddScreen (KdScreenInit, argc, argv);
+    AddScreen(KdScreenInit, argc, argv);
 }
 
-#if 0 /* This function is not used currently */
+#if 0                           /* This function is not used currently */
 
 int
-KdDepthToFb (ScreenPtr	pScreen, int depth)
+KdDepthToFb(ScreenPtr pScreen, int depth)
 {
     KdScreenPriv(pScreen);
 
     for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb.frameBuffer; fb++)
-	if (pScreenPriv->screen->fb.depth == depth)
-	    return fb;
+        if (pScreenPriv->screen->fb.depth == depth)
+            return fb;
 }
 
 #endif
 
 static int
-KdSignalWrapper (int signum)
+KdSignalWrapper(int signum)
 {
     kdCaughtSignal = TRUE;
-    return 1; /* use generic OS layer cleanup & abort */
+    return 1;                   /* use generic OS layer cleanup & abort */
 }
 
 void
-KdInitOutput (ScreenInfo    *pScreenInfo,
-	      int	    argc,
-	      char	    **argv)
+KdInitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (!kdCardInfo)
-    {
-	InitCard (0);
-	if (!(card = KdCardInfoLast ()))
-	    FatalError("No matching cards found!\n");
-	screen = KdScreenInfoAdd (card);
-	KdParseScreen (screen, 0);
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (!kdCardInfo) {
+        InitCard(0);
+        if (!(card = KdCardInfoLast()))
+            FatalError("No matching cards found!\n");
+        screen = KdScreenInfoAdd(card);
+        KdParseScreen(screen, 0);
     }
     /*
      * Initialize all of the screens for all of the cards
      */
-    for (card = kdCardInfo; card; card = card->next)
-    {
-	int ret=1;
-	if(card->cfuncs->cardinit)
-		ret=(*card->cfuncs->cardinit) (card);
-	if (ret)
-	{
-	    for (screen = card->screenList; screen; screen = screen->next)
-		KdInitScreen (pScreenInfo, screen, argc, argv);
-	}
+    for (card = kdCardInfo; card; card = card->next) {
+        int ret = 1;
+
+        if (card->cfuncs->cardinit)
+            ret = (*card->cfuncs->cardinit) (card);
+        if (ret) {
+            for (screen = card->screenList; screen; screen = screen->next)
+                KdInitScreen(pScreenInfo, screen, argc, argv);
+        }
     }
 
     /*
      * Merge the various pixmap formats together, this can fail
      * when two screens share depth but not bitsPerPixel
      */
-    if (!KdSetPixmapFormats (pScreenInfo))
-	return;
+    if (!KdSetPixmapFormats(pScreenInfo))
+        return;
 
     /*
      * Add all of the screens
      */
     for (card = kdCardInfo; card; card = card->next)
-	for (screen = card->screenList; screen; screen = screen->next)
-	    KdAddScreen (pScreenInfo, screen, argc, argv);
+        for (screen = card->screenList; screen; screen = screen->next)
+            KdAddScreen(pScreenInfo, screen, argc, argv);
 
     OsRegisterSigWrapper(KdSignalWrapper);
 }
@@ -1178,7 +1115,7 @@ DPMSSet(ClientPtr client, int level)
 }
 
 Bool
-DPMSSupported (void)
+DPMSSupported(void)
 {
     return FALSE;
 }
diff --git a/hw/kdrive/src/kdrive.h b/hw/kdrive/src/kdrive.h
index cda965d84..6c2f29309 100644
--- a/hw/kdrive/src/kdrive.h
+++ b/hw/kdrive/src/kdrive.h
@@ -56,80 +56,80 @@
 #define Status int
 
 typedef struct _KdCardInfo {
-    struct _KdCardFuncs	    *cfuncs;
-    void		    *closure;
-    void		    *driver;
-    struct _KdScreenInfo    *screenList;
-    int			    selected;
-    struct _KdCardInfo	    *next;
+    struct _KdCardFuncs *cfuncs;
+    void *closure;
+    void *driver;
+    struct _KdScreenInfo *screenList;
+    int selected;
+    struct _KdCardInfo *next;
 } KdCardInfo;
 
-extern KdCardInfo	*kdCardInfo;
+extern KdCardInfo *kdCardInfo;
 
 /*
  * Configuration information per X screen
  */
 typedef struct _KdFrameBuffer {
-    CARD8	*frameBuffer;
-    int		depth;
-    int		bitsPerPixel;
-    int		pixelStride;
-    int		byteStride;
-    Bool	shadow;
-    unsigned long   visuals;
-    Pixel       redMask, greenMask, blueMask;
-    void	*closure;
+    CARD8 *frameBuffer;
+    int depth;
+    int bitsPerPixel;
+    int pixelStride;
+    int byteStride;
+    Bool shadow;
+    unsigned long visuals;
+    Pixel redMask, greenMask, blueMask;
+    void *closure;
 } KdFrameBuffer;
 
 #define RR_Rotate_All	(RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270)
 #define RR_Reflect_All	(RR_Reflect_X|RR_Reflect_Y)
 
 typedef struct _KdScreenInfo {
-    struct _KdScreenInfo    *next;
-    KdCardInfo	*card;
-    ScreenPtr	pScreen;
-    void	*driver;
-    Rotation	randr;	/* rotation and reflection */
-    int		width;
-    int		height;
-    int		rate;
-    int		width_mm;
-    int		height_mm;
-    int		subpixel_order;
-    Bool        dumb;
-    Bool        softCursor;
-    int		mynum;
-    DDXPointRec	origin;
-    KdFrameBuffer   fb;
+    struct _KdScreenInfo *next;
+    KdCardInfo *card;
+    ScreenPtr pScreen;
+    void *driver;
+    Rotation randr;             /* rotation and reflection */
+    int width;
+    int height;
+    int rate;
+    int width_mm;
+    int height_mm;
+    int subpixel_order;
+    Bool dumb;
+    Bool softCursor;
+    int mynum;
+    DDXPointRec origin;
+    KdFrameBuffer fb;
 } KdScreenInfo;
 
 typedef struct _KdCardFuncs {
-    Bool	(*cardinit) (KdCardInfo *); /* detect and map device */
-    Bool	(*scrinit) (KdScreenInfo *);/* initialize screen information */
-    Bool	(*initScreen) (ScreenPtr);  /* initialize ScreenRec */
-    Bool	(*finishInitScreen) (ScreenPtr pScreen);
-    Bool	(*createRes) (ScreenPtr);   /* create screen resources */
-    void	(*preserve) (KdCardInfo *); /* save graphics card state */
-    Bool        (*enable) (ScreenPtr);      /* set up for rendering */
-    Bool	(*dpms) (ScreenPtr, int);   /* set DPMS screen saver */
-    void        (*disable) (ScreenPtr);     /* turn off rendering */
-    void	(*restore) (KdCardInfo *);  /* restore graphics card state */
-    void	(*scrfini) (KdScreenInfo *);/* close down screen */
-    void        (*cardfini) (KdCardInfo *); /* close down */
-
-    Bool        (*initCursor) (ScreenPtr);      /* detect and map cursor */
-    void        (*enableCursor) (ScreenPtr);    /* enable cursor */
-    void        (*disableCursor) (ScreenPtr);   /* disable cursor */
-    void        (*finiCursor) (ScreenPtr);      /* close down */
-    void        (*recolorCursor) (ScreenPtr, int, xColorItem *);
-
-    Bool        (*initAccel) (ScreenPtr);
-    void        (*enableAccel) (ScreenPtr);
-    void        (*disableAccel) (ScreenPtr);
-    void        (*finiAccel) (ScreenPtr);
-
-    void        (*getColors) (ScreenPtr, int, xColorItem *);
-    void        (*putColors) (ScreenPtr, int, xColorItem *);
+    Bool (*cardinit) (KdCardInfo *);    /* detect and map device */
+    Bool (*scrinit) (KdScreenInfo *);   /* initialize screen information */
+    Bool (*initScreen) (ScreenPtr);     /* initialize ScreenRec */
+    Bool (*finishInitScreen) (ScreenPtr pScreen);
+    Bool (*createRes) (ScreenPtr);      /* create screen resources */
+    void (*preserve) (KdCardInfo *);    /* save graphics card state */
+    Bool (*enable) (ScreenPtr); /* set up for rendering */
+    Bool (*dpms) (ScreenPtr, int);      /* set DPMS screen saver */
+    void (*disable) (ScreenPtr);        /* turn off rendering */
+    void (*restore) (KdCardInfo *);     /* restore graphics card state */
+    void (*scrfini) (KdScreenInfo *);   /* close down screen */
+    void (*cardfini) (KdCardInfo *);    /* close down */
+
+    Bool (*initCursor) (ScreenPtr);     /* detect and map cursor */
+    void (*enableCursor) (ScreenPtr);   /* enable cursor */
+    void (*disableCursor) (ScreenPtr);  /* disable cursor */
+    void (*finiCursor) (ScreenPtr);     /* close down */
+    void (*recolorCursor) (ScreenPtr, int, xColorItem *);
+
+    Bool (*initAccel) (ScreenPtr);
+    void (*enableAccel) (ScreenPtr);
+    void (*disableAccel) (ScreenPtr);
+    void (*finiAccel) (ScreenPtr);
+
+    void (*getColors) (ScreenPtr, int, xColorItem *);
+    void (*putColors) (ScreenPtr, int, xColorItem *);
 
 } KdCardFuncs;
 
@@ -137,20 +137,20 @@ typedef struct _KdCardFuncs {
 #define KD_MAX_PSEUDO_SIZE	    (1 << KD_MAX_PSEUDO_DEPTH)
 
 typedef struct {
-    KdScreenInfo    *screen;
-    KdCardInfo	    *card;
+    KdScreenInfo *screen;
+    KdCardInfo *card;
 
-    Bool	    enabled;
-    Bool	    closed;
-    int		    bytesPerPixel;
+    Bool enabled;
+    Bool closed;
+    int bytesPerPixel;
 
-    int		    dpmsState;
+    int dpmsState;
 
-    ColormapPtr     pInstalledmap;                    /* current colormap */
-    xColorItem      systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */
+    ColormapPtr pInstalledmap;  /* current colormap */
+    xColorItem systemPalette[KD_MAX_PSEUDO_SIZE];       /* saved windows colors */
 
-    CreateScreenResourcesProcPtr    CreateScreenResources;
-    CloseScreenProcPtr  CloseScreen;
+    CreateScreenResourcesProcPtr CreateScreenResources;
+    CloseScreenProcPtr CloseScreen;
 } KdPrivScreenRec, *KdPrivScreenPtr;
 
 typedef enum _kdPointerState {
@@ -175,33 +175,33 @@ typedef enum _kdPointerState {
 typedef struct _KdPointerInfo KdPointerInfo;
 
 typedef struct _KdPointerDriver {
-    char                    *name;
-    Status                  (*Init)    (KdPointerInfo *);
-    Status                  (*Enable)  (KdPointerInfo *);
-    void                    (*Disable) (KdPointerInfo *);
-    void                    (*Fini)    (KdPointerInfo *);
+    char *name;
+     Status(*Init) (KdPointerInfo *);
+     Status(*Enable) (KdPointerInfo *);
+    void (*Disable) (KdPointerInfo *);
+    void (*Fini) (KdPointerInfo *);
     struct _KdPointerDriver *next;
 } KdPointerDriver;
 
 struct _KdPointerInfo {
-    DeviceIntPtr          dixdev;
-    char                  *name;
-    char                  *path;
-    char                  *protocol;
-    InputOption           *options;
-    int                   inputClass;
-
-    CARD8                 map[KD_MAX_BUTTON + 1];
-    int                   nButtons;
-    int                   nAxes;
-
-    Bool                  emulateMiddleButton;
-    unsigned long         emulationTimeout;
-    int                   emulationDx, emulationDy;
-
-    Bool                  timeoutPending;
-    KdPointerState        mouseState;
-    Bool                  eventHeld;
+    DeviceIntPtr dixdev;
+    char *name;
+    char *path;
+    char *protocol;
+    InputOption *options;
+    int inputClass;
+
+    CARD8 map[KD_MAX_BUTTON + 1];
+    int nButtons;
+    int nAxes;
+
+    Bool emulateMiddleButton;
+    unsigned long emulationTimeout;
+    int emulationDx, emulationDy;
+
+    Bool timeoutPending;
+    KdPointerState mouseState;
+    Bool eventHeld;
     struct {
         int type;
         int x;
@@ -210,26 +210,25 @@ struct _KdPointerInfo {
         int flags;
         int absrel;
     } heldEvent;
-    unsigned char         buttonState;
-    Bool                  transformCoordinates;
-    int                   pressureThreshold;
+    unsigned char buttonState;
+    Bool transformCoordinates;
+    int pressureThreshold;
 
-    KdPointerDriver       *driver;
-    void                  *driverPrivate;
+    KdPointerDriver *driver;
+    void *driverPrivate;
 
     struct _KdPointerInfo *next;
 };
 
 extern int KdCurScreen;
 
-void KdAddPointerDriver (KdPointerDriver *driver);
-void KdRemovePointerDriver (KdPointerDriver *driver);
-KdPointerInfo *KdNewPointer (void);
-void KdFreePointer (KdPointerInfo *);
-int KdAddPointer (KdPointerInfo *ki);
-int KdAddConfigPointer (char *pointer);
-void KdRemovePointer (KdPointerInfo *ki);
-
+void KdAddPointerDriver(KdPointerDriver * driver);
+void KdRemovePointerDriver(KdPointerDriver * driver);
+KdPointerInfo *KdNewPointer(void);
+void KdFreePointer(KdPointerInfo *);
+int KdAddPointer(KdPointerInfo * ki);
+int KdAddConfigPointer(char *pointer);
+void KdRemovePointer(KdPointerInfo * ki);
 
 #define KD_KEY_COUNT 248
 #define KD_MIN_KEYCODE  8
@@ -239,64 +238,64 @@ void KdRemovePointer (KdPointerInfo *ki);
 
 typedef struct {
     KeySym modsym;
-    int    modbit;
+    int modbit;
 } KdKeySymModsRec;
 
 typedef struct _KdKeyboardInfo KdKeyboardInfo;
 
 typedef struct _KdKeyboardDriver {
-    char                  *name;
-    Bool                  (*Init)    (KdKeyboardInfo *);
-    Bool                  (*Enable)  (KdKeyboardInfo *);
-    void                  (*Leds)    (KdKeyboardInfo *, int);
-    void                  (*Bell)    (KdKeyboardInfo *, int, int, int);
-    void                  (*Disable) (KdKeyboardInfo *);
-    void                  (*Fini)    (KdKeyboardInfo *);
+    char *name;
+    Bool (*Init) (KdKeyboardInfo *);
+    Bool (*Enable) (KdKeyboardInfo *);
+    void (*Leds) (KdKeyboardInfo *, int);
+    void (*Bell) (KdKeyboardInfo *, int, int, int);
+    void (*Disable) (KdKeyboardInfo *);
+    void (*Fini) (KdKeyboardInfo *);
     struct _KdKeyboardDriver *next;
 } KdKeyboardDriver;
 
 struct _KdKeyboardInfo {
     struct _KdKeyboardInfo *next;
-    DeviceIntPtr        dixdev;
-    void                *closure;
-    char                *name;
-    char                *path;
-    int                 inputClass;
-    char                *xkbRules;
-    char                *xkbModel;
-    char                *xkbLayout;
-    char                *xkbVariant;
-    char                *xkbOptions;
-    int                 LockLed;
-
-    int                 minScanCode;
-    int                 maxScanCode;
-
-    int                 leds;
-    int                 bellPitch;
-    int                 bellDuration;
-    InputOption         *options;
-
-    KdKeyboardDriver    *driver;
-    void                *driverPrivate;
+    DeviceIntPtr dixdev;
+    void *closure;
+    char *name;
+    char *path;
+    int inputClass;
+    char *xkbRules;
+    char *xkbModel;
+    char *xkbLayout;
+    char *xkbVariant;
+    char *xkbOptions;
+    int LockLed;
+
+    int minScanCode;
+    int maxScanCode;
+
+    int leds;
+    int bellPitch;
+    int bellDuration;
+    InputOption *options;
+
+    KdKeyboardDriver *driver;
+    void *driverPrivate;
 };
 
-void KdAddKeyboardDriver (KdKeyboardDriver *driver);
-void KdRemoveKeyboardDriver (KdKeyboardDriver *driver);
-KdKeyboardInfo *KdNewKeyboard (void);
-void KdFreeKeyboard (KdKeyboardInfo *ki);
-int KdAddConfigKeyboard (char *pointer);
-int KdAddKeyboard (KdKeyboardInfo *ki);
-void KdRemoveKeyboard (KdKeyboardInfo *ki);
+void KdAddKeyboardDriver(KdKeyboardDriver * driver);
+void KdRemoveKeyboardDriver(KdKeyboardDriver * driver);
+KdKeyboardInfo *KdNewKeyboard(void);
+void KdFreeKeyboard(KdKeyboardInfo * ki);
+int KdAddConfigKeyboard(char *pointer);
+int KdAddKeyboard(KdKeyboardInfo * ki);
+void KdRemoveKeyboard(KdKeyboardInfo * ki);
 
 typedef struct _KdOsFuncs {
-    int		    (*Init) (void);
-    void	    (*Enable) (void);
-    Bool	    (*SpecialKey) (KeySym);
-    void	    (*Disable) (void);
-    void	    (*Fini) (void);
-    void	    (*pollEvents) (void);
-    void            (*Bell) (int, int, int);
+    int (*Init) (void);
+    void (*Enable) (void);
+    Bool (*SpecialKey) (KeySym);
+    void (*Disable) (void);
+    void (*Fini) (void);
+    void (*pollEvents) (void);
+    void (*Bell) (int, int, int);
 } KdOsFuncs;
 
 typedef enum _KdSyncPolarity {
@@ -305,28 +304,28 @@ typedef enum _KdSyncPolarity {
 
 typedef struct _KdMonitorTiming {
     /* label */
-    int		    horizontal;
-    int		    vertical;
-    int		    rate;
+    int horizontal;
+    int vertical;
+    int rate;
     /* pixel clock */
-    int		    clock;  /* in KHz */
+    int clock;                  /* in KHz */
     /* horizontal timing */
-    int		    hfp;    /* front porch */
-    int		    hbp;    /* back porch */
-    int		    hblank; /* blanking */
-    KdSyncPolarity  hpol;   /* polarity */
+    int hfp;                    /* front porch */
+    int hbp;                    /* back porch */
+    int hblank;                 /* blanking */
+    KdSyncPolarity hpol;        /* polarity */
     /* vertical timing */
-    int		    vfp;    /* front porch */
-    int		    vbp;    /* back porch */
-    int		    vblank; /* blanking */
-    KdSyncPolarity  vpol;   /* polarity */
+    int vfp;                    /* front porch */
+    int vbp;                    /* back porch */
+    int vblank;                 /* blanking */
+    KdSyncPolarity vpol;        /* polarity */
 } KdMonitorTiming;
 
-extern const KdMonitorTiming	kdMonitorTimings[];
-extern const int		kdNumMonitorTimings;
+extern const KdMonitorTiming kdMonitorTimings[];
+extern const int kdNumMonitorTimings;
 
 typedef struct _KdPointerMatrix {
-    int	    matrix[2][3];
+    int matrix[2][3];
 } KdPointerMatrix;
 
 /*
@@ -342,18 +341,19 @@ typedef struct _KdPointerMatrix {
     (PixmapWidthPaddingInfo[d].padRoundUp+1)))
 #endif
 
-extern DevPrivateKeyRec	kdScreenPrivateKeyRec;
+extern DevPrivateKeyRec kdScreenPrivateKeyRec;
+
 #define kdScreenPrivateKey (&kdScreenPrivateKeyRec)
 
-extern unsigned long	kdGeneration;
-extern Bool		kdEnabled;
-extern Bool		kdSwitchPending;
-extern Bool		kdEmulateMiddleButton;
-extern Bool		kdDisableZaphod;
-extern Bool		kdAllowZap;
-extern int		kdVirtualTerminal;
-extern char		*kdSwitchCmd;
-extern KdOsFuncs	*kdOsFuncs;
+extern unsigned long kdGeneration;
+extern Bool kdEnabled;
+extern Bool kdSwitchPending;
+extern Bool kdEmulateMiddleButton;
+extern Bool kdDisableZaphod;
+extern Bool kdAllowZap;
+extern int kdVirtualTerminal;
+extern char *kdSwitchCmd;
+extern KdOsFuncs *kdOsFuncs;
 
 #define KdGetScreenPriv(pScreen) ((KdPrivScreenPtr) \
     dixLookupPrivate(&(pScreen)->devPrivates, kdScreenPrivateKey))
@@ -363,158 +363,142 @@ extern KdOsFuncs	*kdOsFuncs;
 
 /* kcmap.c */
 void
-KdSetColormap (ScreenPtr pScreen);
+ KdSetColormap(ScreenPtr pScreen);
 
 void
-KdEnableColormap (ScreenPtr pScreen);
+ KdEnableColormap(ScreenPtr pScreen);
 
 void
-KdDisableColormap (ScreenPtr pScreen);
+ KdDisableColormap(ScreenPtr pScreen);
 
 void
-KdInstallColormap (ColormapPtr pCmap);
+ KdInstallColormap(ColormapPtr pCmap);
 
 void
-KdUninstallColormap (ColormapPtr pCmap);
+ KdUninstallColormap(ColormapPtr pCmap);
 
 int
-KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps);
+ KdListInstalledColormaps(ScreenPtr pScreen, Colormap * pCmaps);
 
 void
-KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs);
+ KdStoreColors(ColormapPtr pCmap, int ndef, xColorItem * pdefs);
 
 /* kdrive.c */
 extern miPointerScreenFuncRec kdPointerScreenFuncs;
 
 void
-KdDisableScreen (ScreenPtr pScreen);
+ KdDisableScreen(ScreenPtr pScreen);
 
 void
-KdDisableScreens (void);
+ KdDisableScreens(void);
 
 Bool
-KdEnableScreen (ScreenPtr pScreen);
+ KdEnableScreen(ScreenPtr pScreen);
 
 void
-KdEnableScreens (void);
+ KdEnableScreens(void);
 
 void
-KdSuspend (void);
+ KdSuspend(void);
 
 void
-KdResume (void);
+ KdResume(void);
 
 void
-KdProcessSwitch (void);
+ KdProcessSwitch(void);
 
-Rotation
-KdAddRotation (Rotation a, Rotation b);
+Rotation KdAddRotation(Rotation a, Rotation b);
 
-Rotation
-KdSubRotation (Rotation a, Rotation b);
+Rotation KdSubRotation(Rotation a, Rotation b);
 
 void
-KdParseScreen (KdScreenInfo *screen,
-	       char	    *arg);
+ KdParseScreen(KdScreenInfo * screen, char *arg);
 
-KdPointerInfo *
-KdParsePointer (char *arg);
+KdPointerInfo *KdParsePointer(char *arg);
 
-KdKeyboardInfo *
-KdParseKeyboard (char *arg);
+KdKeyboardInfo *KdParseKeyboard(char *arg);
 
-char *
-KdParseFindNext (char *cur, const char *delim, char *save, char *last);
+char *KdParseFindNext(char *cur, const char *delim, char *save, char *last);
 
 void
-KdParseRgba (char *rgba);
+ KdParseRgba(char *rgba);
 
 void
-KdUseMsg (void);
+ KdUseMsg(void);
 
 int
-KdProcessArgument (int argc, char **argv, int i);
+ KdProcessArgument(int argc, char **argv, int i);
 
 void
-KdOsInit (KdOsFuncs *pOsFuncs);
+ KdOsInit(KdOsFuncs * pOsFuncs);
 
 void
-KdOsAddInputDrivers (void);
+ KdOsAddInputDrivers(void);
 
 Bool
-KdAllocatePrivates (ScreenPtr pScreen);
+ KdAllocatePrivates(ScreenPtr pScreen);
 
 Bool
-KdCreateScreenResources (ScreenPtr pScreen);
+ KdCreateScreenResources(ScreenPtr pScreen);
 
 Bool
-KdCloseScreen (int index, ScreenPtr pScreen);
+ KdCloseScreen(int index, ScreenPtr pScreen);
 
 Bool
-KdSaveScreen (ScreenPtr pScreen, int on);
+ KdSaveScreen(ScreenPtr pScreen, int on);
 
 Bool
-KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv);
+ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv);
 
 void
-KdInitScreen (ScreenInfo    *pScreenInfo,
-	      KdScreenInfo  *screen,
-	      int	    argc,
-	      char	    **argv);
+
+KdInitScreen(ScreenInfo * pScreenInfo,
+             KdScreenInfo * screen, int argc, char **argv);
 
 void
-KdInitCard (ScreenInfo	    *pScreenInfo,
-	    KdCardInfo	    *card,
-	    int		    argc,
-	    char	    **argv);
+ KdInitCard(ScreenInfo * pScreenInfo, KdCardInfo * card, int argc, char **argv);
 
 void
-KdInitOutput (ScreenInfo    *pScreenInfo,
-	      int	    argc,
-	      char	    **argv);
+ KdInitOutput(ScreenInfo * pScreenInfo, int argc, char **argv);
 
 void
-KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr);
+ KdSetSubpixelOrder(ScreenPtr pScreen, Rotation randr);
 
 void
-KdBacktrace (int signum);
+ KdBacktrace(int signum);
 
 /* kinfo.c */
-KdCardInfo *
-KdCardInfoAdd (KdCardFuncs  *funcs,
-	       void	    *closure);
+KdCardInfo *KdCardInfoAdd(KdCardFuncs * funcs, void *closure);
 
-KdCardInfo *
-KdCardInfoLast (void);
+KdCardInfo *KdCardInfoLast(void);
 
 void
-KdCardInfoDispose (KdCardInfo *ci);
+ KdCardInfoDispose(KdCardInfo * ci);
 
-KdScreenInfo *
-KdScreenInfoAdd (KdCardInfo *ci);
+KdScreenInfo *KdScreenInfoAdd(KdCardInfo * ci);
 
 void
-KdScreenInfoDispose (KdScreenInfo *si);
-
+ KdScreenInfoDispose(KdScreenInfo * si);
 
 /* kinput.c */
 void
-KdInitInput(void);
+ KdInitInput(void);
 void
-KdCloseInput(void);
+ KdCloseInput(void);
 
 Bool
-KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure);
+ KdRegisterFd(int fd, void (*read) (int fd, void *closure), void *closure);
 
 void
-KdUnregisterFds (void *closure, Bool do_close);
+ KdUnregisterFds(void *closure, Bool do_close);
 
 void
-KdUnregisterFd (void *closure, int fd, Bool do_close);
+ KdUnregisterFd(void *closure, int fd, Bool do_close);
 
 void
-KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,
-                    unsigned char is_up);
+
+KdEnqueueKeyboardEvent(KdKeyboardInfo * ki, unsigned char scan_code,
+                       unsigned char is_up);
 
 #define KD_BUTTON_1	0x01
 #define KD_BUTTON_2	0x02
@@ -525,97 +509,96 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,
 #define KD_MOUSE_DELTA	0x80000000
 
 void
-KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
+
+KdEnqueuePointerEvent(KdPointerInfo * pi, unsigned long flags, int rx, int ry,
                       int rz);
 
 void
-_KdEnqueuePointerEvent(KdPointerInfo *pi, int type, int x, int y, int z,
+
+_KdEnqueuePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z,
                        int b, int absrel, Bool force);
 
 void
-KdReleaseAllKeys (void);
+ KdReleaseAllKeys(void);
 
 void
-KdSetLed (KdKeyboardInfo *ki, int led, Bool on);
+ KdSetLed(KdKeyboardInfo * ki, int led, Bool on);
 
 void
-KdSetPointerMatrix (KdPointerMatrix *pointer);
+ KdSetPointerMatrix(KdPointerMatrix * pointer);
 
 void
-KdComputePointerMatrix (KdPointerMatrix *pointer, Rotation randr, int width, int height);
+
+KdComputePointerMatrix(KdPointerMatrix * pointer, Rotation randr, int width,
+                       int height);
 
 void
-KdScreenToPointerCoords (int *x, int *y);
+ KdScreenToPointerCoords(int *x, int *y);
 
 void
-KdBlockHandler (int		screen,
-		pointer		blockData,
-		pointer		timeout,
-		pointer		readmask);
+
+KdBlockHandler(int screen,
+               pointer blockData, pointer timeout, pointer readmask);
 
 void
-KdWakeupHandler (int		screen,
-		 pointer    	data,
-		 unsigned long	result,
-		 pointer	readmask);
+
+KdWakeupHandler(int screen,
+                pointer data, unsigned long result, pointer readmask);
 
 void
-KdDisableInput (void);
+ KdDisableInput(void);
 
 void
-KdEnableInput (void);
+ KdEnableInput(void);
 
 void
-ProcessInputEvents (void);
+ ProcessInputEvents(void);
 
 void
-KdRingBell (KdKeyboardInfo      *ki,
-            int                 volume,
-            int                 pitch,
-            int                 duration);
+ KdRingBell(KdKeyboardInfo * ki, int volume, int pitch, int duration);
 
 /* kmode.c */
-const KdMonitorTiming *
-KdFindMode (KdScreenInfo    *screen,
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *));
+const KdMonitorTiming *KdFindMode(KdScreenInfo * screen,
+                                  Bool (*supported) (KdScreenInfo *,
+                                                     const KdMonitorTiming *));
 
 Bool
-KdTuneMode (KdScreenInfo    *screen,
-	    Bool	    (*usable) (KdScreenInfo *),
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *));
+
+KdTuneMode(KdScreenInfo * screen,
+           Bool (*usable) (KdScreenInfo *),
+           Bool (*supported) (KdScreenInfo *, const KdMonitorTiming *));
 
 #ifdef RANDR
 Bool
-KdRandRGetInfo (ScreenPtr pScreen,
-		int randr,
-		Bool (*supported) (ScreenPtr pScreen,
-				   const KdMonitorTiming *));
-
-const KdMonitorTiming *
-KdRandRGetTiming (ScreenPtr	    pScreen,
-		  Bool		    (*supported) (ScreenPtr pScreen,
-						  const KdMonitorTiming *),
-		  int		    rate,
-		  RRScreenSizePtr   pSize);
+
+KdRandRGetInfo(ScreenPtr pScreen,
+               int randr,
+               Bool (*supported) (ScreenPtr pScreen, const KdMonitorTiming *));
+
+const KdMonitorTiming *KdRandRGetTiming(ScreenPtr pScreen,
+                                        Bool (*supported) (ScreenPtr pScreen,
+                                                           const KdMonitorTiming
+                                                           *), int rate,
+                                        RRScreenSizePtr pSize);
 #endif
 
 /* kshadow.c */
 Bool
-KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate);
+ KdShadowFbAlloc(KdScreenInfo * screen, Bool rotate);
 
 void
-KdShadowFbFree (KdScreenInfo *screen);
+ KdShadowFbFree(KdScreenInfo * screen);
 
 Bool
-KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindowProc window);
+
+KdShadowSet(ScreenPtr pScreen, int randr, ShadowUpdateProc update,
+            ShadowWindowProc window);
 
 void
-KdShadowUnset (ScreenPtr pScreen);
+ KdShadowUnset(ScreenPtr pScreen);
 
 /* function prototypes to be implemented by the drivers */
 void
-InitCard (char *name);
+ InitCard(char *name);
 
-#endif /* _KDRIVE_H_ */
+#endif                          /* _KDRIVE_H_ */
diff --git a/hw/kdrive/src/kinfo.c b/hw/kdrive/src/kinfo.c
index 0055b16db..01ae1e491 100644
--- a/hw/kdrive/src/kinfo.c
+++ b/hw/kdrive/src/kinfo.c
@@ -25,17 +25,16 @@
 #endif
 #include "kdrive.h"
 
-KdCardInfo  *kdCardInfo;
+KdCardInfo *kdCardInfo;
 
 KdCardInfo *
-KdCardInfoAdd (KdCardFuncs  *funcs,
-	       void	    *closure)
+KdCardInfoAdd(KdCardFuncs * funcs, void *closure)
 {
-    KdCardInfo	*ci, **prev;
+    KdCardInfo *ci, **prev;
 
-    ci = calloc(1, sizeof (KdCardInfo));
+    ci = calloc(1, sizeof(KdCardInfo));
     if (!ci)
-	return 0;
+        return 0;
     for (prev = &kdCardInfo; *prev; prev = &(*prev)->next);
     *prev = ci;
     ci->cfuncs = funcs;
@@ -47,39 +46,38 @@ KdCardInfoAdd (KdCardFuncs  *funcs,
 }
 
 KdCardInfo *
-KdCardInfoLast (void)
+KdCardInfoLast(void)
 {
-    KdCardInfo	*ci;
+    KdCardInfo *ci;
 
     if (!kdCardInfo)
-	return 0;
+        return 0;
     for (ci = kdCardInfo; ci->next; ci = ci->next);
     return ci;
 }
 
 void
-KdCardInfoDispose (KdCardInfo *ci)
+KdCardInfoDispose(KdCardInfo * ci)
 {
-    KdCardInfo	**prev;
+    KdCardInfo **prev;
 
     for (prev = &kdCardInfo; *prev; prev = &(*prev)->next)
-	if (*prev == ci)
-	{
-	    *prev = ci->next;
-	    free(ci);
-	    break;
-	}
+        if (*prev == ci) {
+            *prev = ci->next;
+            free(ci);
+            break;
+        }
 }
 
 KdScreenInfo *
-KdScreenInfoAdd (KdCardInfo *ci)
+KdScreenInfoAdd(KdCardInfo * ci)
 {
-    KdScreenInfo    *si, **prev;
-    int		    n;
+    KdScreenInfo *si, **prev;
+    int n;
 
-    si = calloc(1, sizeof (KdScreenInfo));
+    si = calloc(1, sizeof(KdScreenInfo));
     if (!si)
-	return 0;
+        return 0;
     for (prev = &ci->screenList, n = 0; *prev; prev = &(*prev)->next, n++);
     *prev = si;
     si->next = 0;
@@ -89,30 +87,29 @@ KdScreenInfoAdd (KdCardInfo *ci)
 }
 
 void
-KdScreenInfoDispose (KdScreenInfo *si)
+KdScreenInfoDispose(KdScreenInfo * si)
 {
-    KdCardInfo	    *ci = si->card;
-    KdScreenInfo    **prev;
+    KdCardInfo *ci = si->card;
+    KdScreenInfo **prev;
 
     for (prev = &ci->screenList; *prev; prev = &(*prev)->next) {
-	if (*prev == si)
-	{
-	    *prev = si->next;
-	    free(si);
-	    if (!ci->screenList)
-		KdCardInfoDispose (ci);
-	    break;
-	}
+        if (*prev == si) {
+            *prev = si->next;
+            free(si);
+            if (!ci->screenList)
+                KdCardInfoDispose(ci);
+            break;
+        }
     }
 }
 
 KdPointerInfo *
-KdNewPointer (void)
+KdNewPointer(void)
 {
     KdPointerInfo *pi;
     int i;
 
-    pi = (KdPointerInfo *)calloc(1, sizeof(KdPointerInfo));
+    pi = (KdPointerInfo *) calloc(1, sizeof(KdPointerInfo));
     if (!pi)
         return NULL;
 
@@ -132,7 +129,7 @@ KdNewPointer (void)
 }
 
 void
-KdFreePointer(KdPointerInfo *pi)
+KdFreePointer(KdPointerInfo * pi)
 {
     free(pi->name);
     free(pi->path);
@@ -141,7 +138,7 @@ KdFreePointer(KdPointerInfo *pi)
 }
 
 void
-KdFreeKeyboard(KdKeyboardInfo *ki)
+KdFreeKeyboard(KdKeyboardInfo * ki)
 {
     free(ki->name);
     free(ki->path);
diff --git a/hw/kdrive/src/kinput.c b/hw/kdrive/src/kinput.c
index 968ebb159..692e511a8 100644
--- a/hw/kdrive/src/kinput.c
+++ b/hw/kdrive/src/kinput.c
@@ -35,14 +35,14 @@
 #include <signal.h>
 #include <stdio.h>
 #ifdef sun
-#include <sys/file.h> /* needed for FNONBLOCK & FASYNC */
+#include <sys/file.h>           /* needed for FNONBLOCK & FASYNC */
 #endif
 
 #include "xkbsrv.h"
 
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "XIstubs.h" /* even though we don't use stubs.  cute, no? */
+#include "XIstubs.h"            /* even though we don't use stubs.  cute, no? */
 #include "exevents.h"
 #include "extinit.h"
 #include "exglobals.h"
@@ -59,79 +59,80 @@ struct KdConfigDevice {
 };
 
 /* kdKeyboards and kdPointers hold all the real devices. */
-static KdKeyboardInfo *kdKeyboards         = NULL;
-static KdPointerInfo  *kdPointers          = NULL;
-static struct KdConfigDevice *kdConfigKeyboards   = NULL;
-static struct KdConfigDevice *kdConfigPointers    = NULL;
+static KdKeyboardInfo *kdKeyboards = NULL;
+static KdPointerInfo *kdPointers = NULL;
+static struct KdConfigDevice *kdConfigKeyboards = NULL;
+static struct KdConfigDevice *kdConfigPointers = NULL;
 
 static KdKeyboardDriver *kdKeyboardDrivers = NULL;
-static KdPointerDriver  *kdPointerDrivers  = NULL;
-
-static Bool		kdInputEnabled;
-static Bool		kdOffScreen;
-static unsigned long	kdOffScreenTime;
-static KdPointerMatrix	kdPointerMatrix = {
-   { { 1, 0, 0 },
-     { 0, 1, 0 } }
+static KdPointerDriver *kdPointerDrivers = NULL;
+
+static Bool kdInputEnabled;
+static Bool kdOffScreen;
+static unsigned long kdOffScreenTime;
+
+static KdPointerMatrix kdPointerMatrix = {
+    {{1, 0, 0},
+     {0, 1, 0}}
 };
 
-void KdResetInputMachine (void);
+void KdResetInputMachine(void);
 
 #define KD_MAX_INPUT_FDS    8
 
 typedef struct _kdInputFd {
-    int	        fd;
-    void        (*read) (int fd, void *closure);
-    int	        (*enable) (int fd, void *closure);
-    void        (*disable) (int fd, void *closure);
-    void        *closure;
+    int fd;
+    void (*read) (int fd, void *closure);
+    int (*enable) (int fd, void *closure);
+    void (*disable) (int fd, void *closure);
+    void *closure;
 } KdInputFd;
 
 static KdInputFd kdInputFds[KD_MAX_INPUT_FDS];
-static int	 kdNumInputFds;
+static int kdNumInputFds;
 
-extern Bool      kdRawPointerCoordinates;
+extern Bool kdRawPointerCoordinates;
 
 static void
-KdSigio (int sig)
+KdSigio(int sig)
 {
-    int	i;
+    int i;
 
     for (i = 0; i < kdNumInputFds; i++)
-	(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
+        (*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
 }
 
 static void
-KdBlockSigio (void)
+KdBlockSigio(void)
 {
-    sigset_t	set;
+    sigset_t set;
 
-    sigemptyset (&set);
-    sigaddset (&set, SIGIO);
-    sigprocmask (SIG_BLOCK, &set, 0);
+    sigemptyset(&set);
+    sigaddset(&set, SIGIO);
+    sigprocmask(SIG_BLOCK, &set, 0);
 }
 
 static void
-KdUnblockSigio (void)
+KdUnblockSigio(void)
 {
-    sigset_t	set;
+    sigset_t set;
 
-    sigemptyset (&set);
-    sigaddset (&set, SIGIO);
-    sigprocmask (SIG_UNBLOCK, &set, 0);
+    sigemptyset(&set);
+    sigaddset(&set, SIGIO);
+    sigprocmask(SIG_UNBLOCK, &set, 0);
 }
 
 #ifdef DEBUG_SIGIO
 
 void
-KdAssertSigioBlocked (char *where)
+KdAssertSigioBlocked(char *where)
 {
-    sigset_t	set, old;
+    sigset_t set, old;
 
-    sigemptyset (&set);
-    sigprocmask (SIG_BLOCK, &set, &old);
-    if (!sigismember (&old, SIGIO)) {
-	ErrorF ("SIGIO not blocked at %s\n", where);
+    sigemptyset(&set);
+    sigprocmask(SIG_BLOCK, &set, &old);
+    if (!sigismember(&old, SIGIO)) {
+        ErrorF("SIGIO not blocked at %s\n", where);
         KdBacktrace(0);
     }
 }
@@ -142,7 +143,7 @@ KdAssertSigioBlocked (char *where)
 
 #endif
 
-static int  kdnFds;
+static int kdnFds;
 
 #ifdef FNONBLOCK
 #define NOBLOCK FNONBLOCK
@@ -151,7 +152,7 @@ static int  kdnFds;
 #endif
 
 void
-KdResetInputMachine (void)
+KdResetInputMachine(void)
 {
     KdPointerInfo *pi;
 
@@ -162,60 +163,60 @@ KdResetInputMachine (void)
 }
 
 static void
-KdNonBlockFd (int fd)
+KdNonBlockFd(int fd)
 {
-    int	flags;
-    flags = fcntl (fd, F_GETFL);
-    flags |= FASYNC|NOBLOCK;
-    fcntl (fd, F_SETFL, flags);
+    int flags;
+
+    flags = fcntl(fd, F_GETFL);
+    flags |= FASYNC | NOBLOCK;
+    fcntl(fd, F_SETFL, flags);
 }
 
 static void
-KdAddFd (int fd)
+KdAddFd(int fd)
 {
-    struct sigaction	act;
-    sigset_t		set;
+    struct sigaction act;
+    sigset_t set;
 
     kdnFds++;
-    fcntl (fd, F_SETOWN, getpid());
-    KdNonBlockFd (fd);
-    AddEnabledDevice (fd);
-    memset (&act, '\0', sizeof act);
+    fcntl(fd, F_SETOWN, getpid());
+    KdNonBlockFd(fd);
+    AddEnabledDevice(fd);
+    memset(&act, '\0', sizeof act);
     act.sa_handler = KdSigio;
-    sigemptyset (&act.sa_mask);
-    sigaddset (&act.sa_mask, SIGIO);
-    sigaddset (&act.sa_mask, SIGALRM);
-    sigaddset (&act.sa_mask, SIGVTALRM);
-    sigaction (SIGIO, &act, 0);
-    sigemptyset (&set);
-    sigprocmask (SIG_SETMASK, &set, 0);
+    sigemptyset(&act.sa_mask);
+    sigaddset(&act.sa_mask, SIGIO);
+    sigaddset(&act.sa_mask, SIGALRM);
+    sigaddset(&act.sa_mask, SIGVTALRM);
+    sigaction(SIGIO, &act, 0);
+    sigemptyset(&set);
+    sigprocmask(SIG_SETMASK, &set, 0);
 }
 
 static void
-KdRemoveFd (int fd)
+KdRemoveFd(int fd)
 {
-    struct sigaction	act;
-    int			flags;
+    struct sigaction act;
+    int flags;
 
     kdnFds--;
-    RemoveEnabledDevice (fd);
-    flags = fcntl (fd, F_GETFL);
-    flags &= ~(FASYNC|NOBLOCK);
-    fcntl (fd, F_SETFL, flags);
-    if (kdnFds == 0)
-    {
-	memset (&act, '\0', sizeof act);
-	act.sa_handler = SIG_IGN;
-	sigemptyset (&act.sa_mask);
-	sigaction (SIGIO, &act, 0);
+    RemoveEnabledDevice(fd);
+    flags = fcntl(fd, F_GETFL);
+    flags &= ~(FASYNC | NOBLOCK);
+    fcntl(fd, F_SETFL, flags);
+    if (kdnFds == 0) {
+        memset(&act, '\0', sizeof act);
+        act.sa_handler = SIG_IGN;
+        sigemptyset(&act.sa_mask);
+        sigaction(SIGIO, &act, 0);
     }
 }
 
 Bool
-KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure)
+KdRegisterFd(int fd, void (*read) (int fd, void *closure), void *closure)
 {
     if (kdNumInputFds == KD_MAX_INPUT_FDS)
-	return FALSE;
+        return FALSE;
     kdInputFds[kdNumInputFds].fd = fd;
     kdInputFds[kdNumInputFds].read = read;
     kdInputFds[kdNumInputFds].enable = 0;
@@ -223,38 +224,38 @@ KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure)
     kdInputFds[kdNumInputFds].closure = closure;
     kdNumInputFds++;
     if (kdInputEnabled)
-	KdAddFd (fd);
+        KdAddFd(fd);
     return TRUE;
 }
 
 void
-KdUnregisterFd (void *closure, int fd, Bool do_close)
+KdUnregisterFd(void *closure, int fd, Bool do_close)
 {
-    int	i, j;
+    int i, j;
 
     for (i = 0; i < kdNumInputFds; i++) {
-	if (kdInputFds[i].closure == closure &&
+        if (kdInputFds[i].closure == closure &&
             (fd == -1 || kdInputFds[i].fd == fd)) {
-	    if (kdInputEnabled)
-		KdRemoveFd (kdInputFds[i].fd);
-	    if (do_close)
-		close (kdInputFds[i].fd);
-	    kdNumInputFds--;
-	    for (j = i; j < kdNumInputFds; j++)
-		kdInputFds[j] = kdInputFds[j+1];
+            if (kdInputEnabled)
+                KdRemoveFd(kdInputFds[i].fd);
+            if (do_close)
+                close(kdInputFds[i].fd);
+            kdNumInputFds--;
+            for (j = i; j < kdNumInputFds; j++)
+                kdInputFds[j] = kdInputFds[j + 1];
             break;
-	}
+        }
     }
 }
 
 void
-KdUnregisterFds (void *closure, Bool do_close)
+KdUnregisterFds(void *closure, Bool do_close)
 {
     KdUnregisterFd(closure, -1, do_close);
 }
 
 void
-KdDisableInput (void)
+KdDisableInput(void)
 {
     KdKeyboardInfo *ki;
     KdPointerInfo *pi;
@@ -283,7 +284,7 @@ KdDisableInput (void)
                     ErrorF("    fd %d belongs to keybd driver %s\n",
                            kdInputFds[i].fd,
                            ki->driver && ki->driver->name ?
-                             ki->driver->name : "(unnamed!)");
+                           ki->driver->name : "(unnamed!)");
                     found = 1;
                     break;
                 }
@@ -299,7 +300,7 @@ KdDisableInput (void)
                     ErrorF("    fd %d belongs to pointer driver %s\n",
                            kdInputFds[i].fd,
                            pi->driver && pi->driver->name ?
-                             pi->driver->name : "(unnamed!)");
+                           pi->driver->name : "(unnamed!)");
                     break;
                 }
             }
@@ -319,7 +320,7 @@ KdDisableInput (void)
 }
 
 void
-KdEnableInput (void)
+KdEnableInput(void)
 {
     InternalEvent ev;
     KdKeyboardInfo *ki;
@@ -338,14 +339,14 @@ KdEnableInput (void)
     }
 
     /* reset screen saver */
-    ev.any.time = GetTimeInMillis ();
-    NoticeEventTime (&ev);
+    ev.any.time = GetTimeInMillis();
+    NoticeEventTime(&ev);
 
-    KdUnblockSigio ();
+    KdUnblockSigio();
 }
 
 static KdKeyboardDriver *
-KdFindKeyboardDriver (const char *name)
+KdFindKeyboardDriver(const char *name)
 {
     KdKeyboardDriver *ret;
 
@@ -362,7 +363,7 @@ KdFindKeyboardDriver (const char *name)
 }
 
 static KdPointerDriver *
-KdFindPointerDriver (const char *name)
+KdFindPointerDriver(const char *name)
 {
     KdPointerDriver *ret;
 
@@ -381,14 +382,14 @@ KdFindPointerDriver (const char *name)
 static int
 KdPointerProc(DeviceIntPtr pDevice, int onoff)
 {
-    DevicePtr       pDev = (DevicePtr)pDevice;
-    KdPointerInfo   *pi;
-    Atom            xiclass;
-    Atom            *btn_labels;
-    Atom            *axes_labels;
+    DevicePtr pDev = (DevicePtr) pDevice;
+    KdPointerInfo *pi;
+    Atom xiclass;
+    Atom *btn_labels;
+    Atom *axes_labels;
 
     if (!pDev)
-	return BadImplementation;
+        return BadImplementation;
 
     for (pi = kdPointers; pi; pi = pi->next) {
         if (pi->dixdev && pi->dixdev->id == pDevice->id)
@@ -401,8 +402,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
         return BadImplementation;
     }
 
-    switch (onoff)
-    {
+    switch (onoff) {
     case DEVICE_INIT:
 #ifdef DEBUG
         ErrorF("initialising pointer %s ...\n", pi->name);
@@ -433,44 +433,43 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
             return !Success;
         }
 
-	btn_labels = calloc(pi->nButtons, sizeof(Atom));
-	if (!btn_labels)
-	    return BadAlloc;
-	axes_labels = calloc(pi->nAxes, sizeof(Atom));
-	if (!axes_labels) {
-	    free(btn_labels);
-	    return BadAlloc;
-	}
-
-	switch(pi->nAxes)
-	{
-	    default:
-	    case 7:
-		btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
-	    case 6:
-		btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
-	    case 5:
-		btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
-	    case 4:
-		btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
-	    case 3:
-		btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
-	    case 2:
-		btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
-	    case 1:
-		btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
-	    case 0:
-		break;
-	}
-
-	if (pi->nAxes >= 2) {
-	    axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
-	    axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
-	}
-
-	InitPointerDeviceStruct(pDev, pi->map, pi->nButtons, btn_labels,
-	    (PtrCtrlProcPtr)NoopDDA,
-	    GetMotionHistorySize(), pi->nAxes, axes_labels);
+        btn_labels = calloc(pi->nButtons, sizeof(Atom));
+        if (!btn_labels)
+            return BadAlloc;
+        axes_labels = calloc(pi->nAxes, sizeof(Atom));
+        if (!axes_labels) {
+            free(btn_labels);
+            return BadAlloc;
+        }
+
+        switch (pi->nAxes) {
+        default:
+        case 7:
+            btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
+        case 6:
+            btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
+        case 5:
+            btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
+        case 4:
+            btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
+        case 3:
+            btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
+        case 2:
+            btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
+        case 1:
+            btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
+        case 0:
+            break;
+        }
+
+        if (pi->nAxes >= 2) {
+            axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
+            axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
+        }
+
+        InitPointerDeviceStruct(pDev, pi->map, pi->nButtons, btn_labels,
+                                (PtrCtrlProcPtr) NoopDDA,
+                                GetMotionHistorySize(), pi->nAxes, axes_labels);
 
         free(btn_labels);
         free(axes_labels);
@@ -485,7 +484,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
         AssignTypeAndName(pi->dixdev, xiclass,
                           pi->name ? pi->name : "Generic KDrive Pointer");
 
-	return Success;
+        return Success;
 
     case DEVICE_ON:
         if (pDev->on == TRUE)
@@ -504,7 +503,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
             return BadImplementation;
         }
 
-	return Success;
+        return Success;
 
     case DEVICE_OFF:
         if (pDev->on == FALSE) {
@@ -523,7 +522,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
         return Success;
 
     case DEVICE_CLOSE:
-	if (pDev->on) {
+        if (pDev->on) {
             if (!pi->driver->Disable) {
                 return BadImplementation;
             }
@@ -552,7 +551,7 @@ LegalModifier(unsigned int key, DeviceIntPtr pDev)
 }
 
 static void
-KdBell (int volume, DeviceIntPtr pDev, pointer arg, int something)
+KdBell(int volume, DeviceIntPtr pDev, pointer arg, int something)
 {
     KeybdCtrl *ctrl = arg;
     KdKeyboardInfo *ki = NULL;
@@ -574,7 +573,7 @@ DDXRingBell(int volume, int pitch, int duration)
     KdKeyboardInfo *ki = NULL;
 
     if (kdOsFuncs->Bell) {
-        (*kdOsFuncs->Bell)(volume, pitch, duration);
+        (*kdOsFuncs->Bell) (volume, pitch, duration);
     }
     else {
         for (ki = kdKeyboards; ki; ki = ki->next) {
@@ -585,7 +584,7 @@ DDXRingBell(int volume, int pitch, int duration)
 }
 
 void
-KdRingBell(KdKeyboardInfo *ki, int volume, int pitch, int duration)
+KdRingBell(KdKeyboardInfo * ki, int volume, int pitch, int duration)
 {
     if (!ki || !ki->driver || !ki->driver->Bell)
         return;
@@ -594,9 +593,8 @@ KdRingBell(KdKeyboardInfo *ki, int volume, int pitch, int duration)
         (*ki->driver->Bell) (ki, volume, pitch, duration);
 }
 
-
 static void
-KdSetLeds (KdKeyboardInfo *ki, int leds)
+KdSetLeds(KdKeyboardInfo * ki, int leds)
 {
     if (!ki || !ki->driver)
         return;
@@ -608,75 +606,85 @@ KdSetLeds (KdKeyboardInfo *ki, int leds)
 }
 
 void
-KdSetLed (KdKeyboardInfo *ki, int led, Bool on)
+KdSetLed(KdKeyboardInfo * ki, int led, Bool on)
 {
     if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed)
         return;
 
-    NoteLedState (ki->dixdev, led, on);
-    KdSetLeds (ki, ki->dixdev->kbdfeed->ctrl.leds);
+    NoteLedState(ki->dixdev, led, on);
+    KdSetLeds(ki, ki->dixdev->kbdfeed->ctrl.leds);
 }
 
 void
-KdSetPointerMatrix (KdPointerMatrix *matrix)
+KdSetPointerMatrix(KdPointerMatrix * matrix)
 {
     kdPointerMatrix = *matrix;
 }
 
 void
-KdComputePointerMatrix (KdPointerMatrix *m, Rotation randr, int width,
-                        int height)
+KdComputePointerMatrix(KdPointerMatrix * m, Rotation randr, int width,
+                       int height)
 {
-    int		    x_dir = 1, y_dir = 1;
-    int		    i, j;
-    int		    size[2];
+    int x_dir = 1, y_dir = 1;
+    int i, j;
+    int size[2];
 
-    size[0] = width; size[1] = height;
+    size[0] = width;
+    size[1] = height;
     if (randr & RR_Reflect_X)
-	x_dir = -1;
+        x_dir = -1;
     if (randr & RR_Reflect_Y)
-	y_dir = -1;
+        y_dir = -1;
     switch (randr & (RR_Rotate_All)) {
     case RR_Rotate_0:
-	m->matrix[0][0] = x_dir; m->matrix[0][1] = 0;
-	m->matrix[1][0] = 0; m->matrix[1][1] = y_dir;
-	break;
+        m->matrix[0][0] = x_dir;
+        m->matrix[0][1] = 0;
+        m->matrix[1][0] = 0;
+        m->matrix[1][1] = y_dir;
+        break;
     case RR_Rotate_90:
-	m->matrix[0][0] = 0; m->matrix[0][1] = -x_dir;
-	m->matrix[1][0] = y_dir; m->matrix[1][1] = 0;
-	break;
+        m->matrix[0][0] = 0;
+        m->matrix[0][1] = -x_dir;
+        m->matrix[1][0] = y_dir;
+        m->matrix[1][1] = 0;
+        break;
     case RR_Rotate_180:
-	m->matrix[0][0] = -x_dir; m->matrix[0][1] = 0;
-	m->matrix[1][0] = 0; m->matrix[1][1] = -y_dir;
-	break;
+        m->matrix[0][0] = -x_dir;
+        m->matrix[0][1] = 0;
+        m->matrix[1][0] = 0;
+        m->matrix[1][1] = -y_dir;
+        break;
     case RR_Rotate_270:
-	m->matrix[0][0] = 0; m->matrix[0][1] = x_dir;
-	m->matrix[1][0] = -y_dir; m->matrix[1][1] = 0;
-	break;
+        m->matrix[0][0] = 0;
+        m->matrix[0][1] = x_dir;
+        m->matrix[1][0] = -y_dir;
+        m->matrix[1][1] = 0;
+        break;
     }
-    for (i = 0; i < 2; i++)
-    {
-	m->matrix[i][2] = 0;
-	for (j = 0 ; j < 2; j++)
-	    if (m->matrix[i][j] < 0)
-		m->matrix[i][2] = size[j] - 1;
+    for (i = 0; i < 2; i++) {
+        m->matrix[i][2] = 0;
+        for (j = 0; j < 2; j++)
+            if (m->matrix[i][j] < 0)
+                m->matrix[i][2] = size[j] - 1;
     }
 }
 
 void
-KdScreenToPointerCoords (int *x, int *y)
+KdScreenToPointerCoords(int *x, int *y)
 {
-    int	(*m)[3] = kdPointerMatrix.matrix;
+    int (*m)[3] = kdPointerMatrix.matrix;
     int div = m[0][1] * m[1][0] - m[1][1] * m[0][0];
     int sx = *x;
     int sy = *y;
 
-    *x = (m[0][1] * sy - m[0][1] * m[1][2] + m[1][1] * m[0][2] - m[1][1] * sx) / div;
-    *y = (m[1][0] * sx + m[0][0] * m[1][2] - m[1][0] * m[0][2] - m[0][0] * sy) / div;
+    *x = (m[0][1] * sy - m[0][1] * m[1][2] + m[1][1] * m[0][2] -
+          m[1][1] * sx) / div;
+    *y = (m[1][0] * sx + m[0][0] * m[1][2] - m[1][0] * m[0][2] -
+          m[0][0] * sy) / div;
 }
 
 static void
-KdKbdCtrl (DeviceIntPtr pDevice, KeybdCtrl *ctrl)
+KdKbdCtrl(DeviceIntPtr pDevice, KeybdCtrl * ctrl)
 {
     KdKeyboardInfo *ki;
 
@@ -698,14 +706,14 @@ extern KeybdCtrl defaultKeyboardControl;
 static int
 KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
 {
-    Bool        ret;
-    DevicePtr   pDev = (DevicePtr)pDevice;
+    Bool ret;
+    DevicePtr pDev = (DevicePtr) pDevice;
     KdKeyboardInfo *ki;
     Atom xiclass;
     XkbRMLVOSet rmlvo;
 
     if (!pDev)
-	return BadImplementation;
+        return BadImplementation;
 
     for (ki = kdKeyboards; ki; ki = ki->next) {
         if (ki->dixdev && ki->dixdev->id == pDevice->id)
@@ -716,8 +724,7 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
         return BadImplementation;
     }
 
-    switch (onoff)
-    {
+    switch (onoff) {
     case DEVICE_INIT:
 #ifdef DEBUG
         ErrorF("initialising keyboard %s\n", ki->name);
@@ -754,10 +761,10 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
         rmlvo.layout = ki->xkbLayout;
         rmlvo.variant = ki->xkbVariant;
         rmlvo.options = ki->xkbOptions;
-        ret = InitKeyboardDeviceStruct (pDevice, &rmlvo, KdBell, KdKbdCtrl);
-	if (!ret) {
+        ret = InitKeyboardDeviceStruct(pDevice, &rmlvo, KdBell, KdKbdCtrl);
+        if (!ret) {
             ErrorF("Couldn't initialise keyboard %s\n", ki->name);
-	    return BadImplementation;
+            return BadImplementation;
         }
 
         xiclass = AtomFromName(XI_KEYBOARD);
@@ -797,13 +804,13 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
         break;
 
     case DEVICE_CLOSE:
-	if (pDev->on) {
+        if (pDev->on) {
             if (!ki->driver->Disable)
                 return BadImplementation;
 
             (*ki->driver->Disable) (ki);
             pDev->on = FALSE;
-	}
+        }
 
         if (!ki->driver->Fini)
             return BadImplementation;
@@ -820,7 +827,7 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
 }
 
 void
-KdAddPointerDriver (KdPointerDriver *driver)
+KdAddPointerDriver(KdPointerDriver * driver)
 {
     KdPointerDriver **prev;
 
@@ -835,7 +842,7 @@ KdAddPointerDriver (KdPointerDriver *driver)
 }
 
 void
-KdRemovePointerDriver (KdPointerDriver *driver)
+KdRemovePointerDriver(KdPointerDriver * driver)
 {
     KdPointerDriver *tmp;
 
@@ -852,7 +859,7 @@ KdRemovePointerDriver (KdPointerDriver *driver)
 }
 
 void
-KdAddKeyboardDriver (KdKeyboardDriver *driver)
+KdAddKeyboardDriver(KdKeyboardDriver * driver)
 {
     KdKeyboardDriver **prev;
 
@@ -867,7 +874,7 @@ KdAddKeyboardDriver (KdKeyboardDriver *driver)
 }
 
 void
-KdRemoveKeyboardDriver (KdKeyboardDriver *driver)
+KdRemoveKeyboardDriver(KdKeyboardDriver * driver)
 {
     KdKeyboardDriver *tmp;
 
@@ -884,9 +891,10 @@ KdRemoveKeyboardDriver (KdKeyboardDriver *driver)
 }
 
 KdKeyboardInfo *
-KdNewKeyboard (void)
+KdNewKeyboard(void)
 {
     KdKeyboardInfo *ki = calloc(sizeof(KdKeyboardInfo), 1);
+
     if (!ki)
         return NULL;
 
@@ -907,7 +915,7 @@ KdNewKeyboard (void)
 }
 
 int
-KdAddConfigKeyboard (char *keyboard)
+KdAddConfigKeyboard(char *keyboard)
 {
     struct KdConfigDevice **prev, *new;
 
@@ -928,7 +936,7 @@ KdAddConfigKeyboard (char *keyboard)
 }
 
 int
-KdAddKeyboard (KdKeyboardInfo *ki)
+KdAddKeyboard(KdKeyboardInfo * ki)
 {
     KdKeyboardInfo **prev;
 
@@ -953,7 +961,7 @@ KdAddKeyboard (KdKeyboardInfo *ki)
 }
 
 void
-KdRemoveKeyboard (KdKeyboardInfo *ki)
+KdRemoveKeyboard(KdKeyboardInfo * ki)
 {
     KdKeyboardInfo **prev;
 
@@ -971,7 +979,7 @@ KdRemoveKeyboard (KdKeyboardInfo *ki)
 }
 
 int
-KdAddConfigPointer (char *pointer)
+KdAddConfigPointer(char *pointer)
 {
     struct KdConfigDevice **prev, *new;
 
@@ -992,7 +1000,7 @@ KdAddConfigPointer (char *pointer)
 }
 
 int
-KdAddPointer (KdPointerInfo *pi)
+KdAddPointer(KdPointerInfo * pi)
 {
     KdPointerInfo **prev;
 
@@ -1016,7 +1024,7 @@ KdAddPointer (KdPointerInfo *pi)
 }
 
 void
-KdRemovePointer (KdPointerInfo *pi)
+KdRemovePointer(KdPointerInfo * pi)
 {
     KdPointerInfo **prev;
 
@@ -1039,15 +1047,13 @@ KdRemovePointer (KdPointerInfo *pi)
  * evdev,,device=/dev/input/event1,xkbmodel=abnt2,xkblayout=br
  */
 static Bool
-KdGetOptions (InputOption **options, char *string)
+KdGetOptions(InputOption **options, char *string)
 {
-    InputOption     *newopt = NULL;
-    char            *key = NULL,
-                    *value = NULL;
-    int             tam_key = 0;
+    InputOption *newopt = NULL;
+    char *key = NULL, *value = NULL;
+    int tam_key = 0;
 
-    if (strchr(string, '='))
-    {
+    if (strchr(string, '=')) {
         tam_key = (strchr(string, '=') - string);
         key = strndup(string, tam_key);
         if (!key)
@@ -1057,8 +1063,7 @@ KdGetOptions (InputOption **options, char *string)
         if (!value)
             goto out;
     }
-    else
-    {
+    else {
         key = strdup(string);
         value = NULL;
     }
@@ -1067,7 +1072,7 @@ KdGetOptions (InputOption **options, char *string)
     if (newopt)
         *options = newopt;
 
-out:
+ out:
     free(key);
     free(value);
 
@@ -1075,12 +1080,11 @@ out:
 }
 
 static void
-KdParseKbdOptions (KdKeyboardInfo *ki)
+KdParseKbdOptions(KdKeyboardInfo * ki)
 {
     InputOption *option = NULL;
 
-    nt_list_for_each_entry(option, ki->options, list.next)
-    {
+    nt_list_for_each_entry(option, ki->options, list.next) {
         const char *key = input_option_get_key(option);
         const char *value = input_option_get_value(option);
 
@@ -1094,21 +1098,21 @@ KdParseKbdOptions (KdKeyboardInfo *ki)
             ki->xkbVariant = strdup(value);
         else if (strcasecmp(key, "XkbOptions") == 0)
             ki->xkbOptions = strdup(value);
-        else if (!strcasecmp (key, "device"))
+        else if (!strcasecmp(key, "device"))
             ki->path = strdup(value);
         else
-           ErrorF("Kbd option key (%s) of value (%s) not assigned!\n",
-                    key, value);
+            ErrorF("Kbd option key (%s) of value (%s) not assigned!\n",
+                   key, value);
     }
 }
 
 KdKeyboardInfo *
-KdParseKeyboard (char *arg)
+KdParseKeyboard(char *arg)
 {
-    char            save[1024];
-    char            delim;
-    InputOption     *options = NULL;
-    KdKeyboardInfo     *ki = NULL;
+    char save[1024];
+    char delim;
+    InputOption *options = NULL;
+    KdKeyboardInfo *ki = NULL;
 
     ki = KdNewKeyboard();
     if (!ki)
@@ -1120,53 +1124,46 @@ KdParseKeyboard (char *arg)
     ki->driverPrivate = NULL;
     ki->next = NULL;
 
-    if (!arg)
-    {
+    if (!arg) {
         ErrorF("keybd: no arg\n");
-        KdFreeKeyboard (ki);
+        KdFreeKeyboard(ki);
         return NULL;
     }
 
-    if (strlen (arg) >= sizeof (save))
-    {
+    if (strlen(arg) >= sizeof(save)) {
         ErrorF("keybd: arg too long\n");
-        KdFreeKeyboard (ki);
+        KdFreeKeyboard(ki);
         return NULL;
     }
 
-    arg = KdParseFindNext (arg, ",", save, &delim);
-    if (!save[0])
-    {
+    arg = KdParseFindNext(arg, ",", save, &delim);
+    if (!save[0]) {
         ErrorF("keybd: failed on save[0]\n");
-        KdFreeKeyboard (ki);
+        KdFreeKeyboard(ki);
         return NULL;
     }
 
-    if (strcmp (save, "auto") == 0)
+    if (strcmp(save, "auto") == 0)
         ki->driverPrivate = NULL;
     else
         ki->driverPrivate = strdup(save);
 
-    if (delim != ',')
-    {
+    if (delim != ',') {
         return ki;
     }
 
-    arg = KdParseFindNext (arg, ",", save, &delim);
+    arg = KdParseFindNext(arg, ",", save, &delim);
 
-    while (delim == ',')
-    {
-        arg = KdParseFindNext (arg, ",", save, &delim);
+    while (delim == ',') {
+        arg = KdParseFindNext(arg, ",", save, &delim);
 
-	if (!KdGetOptions(&options, save))
-	{
-	    KdFreeKeyboard(ki);
-	    return NULL;
+        if (!KdGetOptions(&options, save)) {
+            KdFreeKeyboard(ki);
+            return NULL;
         }
     }
 
-    if (options)
-    {
+    if (options) {
         ki->options = options;
         KdParseKbdOptions(ki);
     }
@@ -1175,41 +1172,40 @@ KdParseKeyboard (char *arg)
 }
 
 static void
-KdParsePointerOptions (KdPointerInfo *pi)
+KdParsePointerOptions(KdPointerInfo * pi)
 {
     InputOption *option = NULL;
 
-    nt_list_for_each_entry(option, pi->options, list.next)
-    {
+    nt_list_for_each_entry(option, pi->options, list.next) {
         const char *key = input_option_get_key(option);
         const char *value = input_option_get_value(option);
 
-        if (!strcmp (key, "emulatemiddle"))
+        if (!strcmp(key, "emulatemiddle"))
             pi->emulateMiddleButton = TRUE;
-        else if (!strcmp (key, "noemulatemiddle"))
+        else if (!strcmp(key, "noemulatemiddle"))
             pi->emulateMiddleButton = FALSE;
-        else if (!strcmp (key, "transformcoord"))
+        else if (!strcmp(key, "transformcoord"))
             pi->transformCoordinates = TRUE;
-        else if (!strcmp (key, "rawcoord"))
+        else if (!strcmp(key, "rawcoord"))
             pi->transformCoordinates = FALSE;
-        else if (!strcasecmp (key, "device"))
+        else if (!strcasecmp(key, "device"))
             pi->path = strdup(value);
-        else if (!strcasecmp (key, "protocol"))
+        else if (!strcasecmp(key, "protocol"))
             pi->protocol = strdup(value);
         else
             ErrorF("Pointer option key (%s) of value (%s) not assigned!\n",
-                    key, value);
+                   key, value);
     }
 }
 
 KdPointerInfo *
-KdParsePointer (char *arg)
+KdParsePointer(char *arg)
 {
-    char            save[1024];
-    char            delim;
-    KdPointerInfo   *pi = NULL;
-    InputOption     *options = NULL;
-    int             i = 0;
+    char save[1024];
+    char delim;
+    KdPointerInfo *pi = NULL;
+    InputOption *options = NULL;
+    int i = 0;
 
     pi = KdNewPointer();
     if (!pi)
@@ -1217,27 +1213,24 @@ KdParsePointer (char *arg)
     pi->emulateMiddleButton = kdEmulateMiddleButton;
     pi->transformCoordinates = !kdRawPointerCoordinates;
     pi->protocol = NULL;
-    pi->nButtons = 5; /* XXX should not be hardcoded */
+    pi->nButtons = 5;           /* XXX should not be hardcoded */
     pi->inputClass = KD_MOUSE;
 
-    if (!arg)
-    {
+    if (!arg) {
         ErrorF("mouse: no arg\n");
-        KdFreePointer (pi);
+        KdFreePointer(pi);
         return NULL;
     }
 
-    if (strlen (arg) >= sizeof (save))
-    {
+    if (strlen(arg) >= sizeof(save)) {
         ErrorF("mouse: arg too long\n");
-        KdFreePointer (pi);
+        KdFreePointer(pi);
         return NULL;
     }
-    arg = KdParseFindNext (arg, ",", save, &delim);
-    if (!save[0])
-    {
+    arg = KdParseFindNext(arg, ",", save, &delim);
+    if (!save[0]) {
         ErrorF("failed on save[0]\n");
-        KdFreePointer (pi);
+        KdFreePointer(pi);
         return NULL;
     }
 
@@ -1246,41 +1239,35 @@ KdParsePointer (char *arg)
     else
         pi->driverPrivate = strdup(save);
 
-    if (delim != ',')
-    {
+    if (delim != ',') {
         return pi;
     }
 
-    arg = KdParseFindNext (arg, ",", save, &delim);
+    arg = KdParseFindNext(arg, ",", save, &delim);
 
-    while (delim == ',')
-    {
-        arg = KdParseFindNext (arg, ",", save, &delim);
-        if (save[0] == '{')
-        {
+    while (delim == ',') {
+        arg = KdParseFindNext(arg, ",", save, &delim);
+        if (save[0] == '{') {
             char *s = save + 1;
-             i = 0;
-             while (*s && *s != '}')
-             {
+
+            i = 0;
+            while (*s && *s != '}') {
                 if ('1' <= *s && *s <= '0' + pi->nButtons)
                     pi->map[i] = *s - '0';
                 else
-                    UseMsg ();
+                    UseMsg();
                 s++;
-             }
+            }
         }
-        else
-        {
-            if (!KdGetOptions(&options, save))
-            {
+        else {
+            if (!KdGetOptions(&options, save)) {
                 KdFreePointer(pi);
                 return NULL;
             }
         }
     }
 
-    if (options)
-    {
+    if (options) {
         pi->options = options;
         KdParsePointerOptions(pi);
     }
@@ -1288,9 +1275,8 @@ KdParsePointer (char *arg)
     return pi;
 }
 
-
 void
-KdInitInput (void)
+KdInitInput(void)
 {
     KdPointerInfo *pi;
     KdKeyboardInfo *ki;
@@ -1317,7 +1303,7 @@ KdInitInput (void)
 }
 
 void
-KdCloseInput (void)
+KdCloseInput(void)
 {
     mieqFini();
 }
@@ -1480,195 +1466,203 @@ typedef enum _inputAction {
 #define MAX_ACTIONS 2
 
 typedef struct _inputTransition {
-    KdInputAction  actions[MAX_ACTIONS];
+    KdInputAction actions[MAX_ACTIONS];
     KdPointerState nextState;
 } KdInputTransition;
 
 static const
-KdInputTransition  kdInputMachine[num_input_states][num_input_class] = {
+KdInputTransition kdInputMachine[num_input_states][num_input_class] = {
     /* start */
     {
-	{ { hold, setto },	    button_1_pend },	/* v1 */
-	{ { deliver, noop },	    start },		/* ^1 */
-	{ { deliver, noop },	    button_2_down },	/* v2 */
-	{ { deliver, noop },	    start },		/* ^2 */
-	{ { hold, setto },	    button_3_pend },	/* v3 */
-	{ { deliver, noop },	    start },		/* ^3 */
-	{ { deliver, noop },	    start },		/* vo */
-	{ { deliver, noop },	    start },		/* ^o */
-	{ { deliver, noop },	    start },		/* <> */
-	{ { deliver, noop },	    start },		/* <-> */
-	{ { noop, noop },	    start },		/* k */
-	{ { noop, noop },	    start },		/* ... */
-    },
+     {{hold, setto}, button_1_pend},    /* v1 */
+     {{deliver, noop}, start},  /* ^1 */
+     {{deliver, noop}, button_2_down},  /* v2 */
+     {{deliver, noop}, start},  /* ^2 */
+     {{hold, setto}, button_3_pend},    /* v3 */
+     {{deliver, noop}, start},  /* ^3 */
+     {{deliver, noop}, start},  /* vo */
+     {{deliver, noop}, start},  /* ^o */
+     {{deliver, noop}, start},  /* <> */
+     {{deliver, noop}, start},  /* <-> */
+     {{noop, noop}, start},     /* k */
+     {{noop, noop}, start},     /* ... */
+     },
     /* button_1_pend */
     {
-	{ { noop, noop },	    button_1_pend },	/* v1 */
-	{ { release, deliver },	    start },		/* ^1 */
-	{ { release, deliver },	    button_1_down },	/* v2 */
-	{ { release, deliver },	    button_1_down },	/* ^2 */
-	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v3 */
-	{ { release, deliver },	    button_1_down },	/* ^3 */
-	{ { release, deliver },	    button_1_down },	/* vo */
-	{ { release, deliver },	    button_1_down },	/* ^o */
-	{ { deliver, noop },	    button_1_pend },	/* <> */
-	{ { release, deliver },	    button_1_down },	/* <-> */
-	{ { noop, noop },	    button_1_down },	/* k */
-	{ { release, noop },	    button_1_down },	/* ... */
-    },
+     {{noop, noop}, button_1_pend},     /* v1 */
+     {{release, deliver}, start},       /* ^1 */
+     {{release, deliver}, button_1_down},       /* v2 */
+     {{release, deliver}, button_1_down},       /* ^2 */
+     {{clearto, gen_down_2}, synth_2_down_13},  /* v3 */
+     {{release, deliver}, button_1_down},       /* ^3 */
+     {{release, deliver}, button_1_down},       /* vo */
+     {{release, deliver}, button_1_down},       /* ^o */
+     {{deliver, noop}, button_1_pend},  /* <> */
+     {{release, deliver}, button_1_down},       /* <-> */
+     {{noop, noop}, button_1_down},     /* k */
+     {{release, noop}, button_1_down},  /* ... */
+     },
     /* button_1_down */
     {
-	{ { noop, noop },	    button_1_down },	/* v1 */
-	{ { deliver, noop },	    start },		/* ^1 */
-	{ { deliver, noop },	    button_1_down },	/* v2 */
-	{ { deliver, noop },	    button_1_down },	/* ^2 */
-	{ { deliver, noop },	    button_1_down },	/* v3 */
-	{ { deliver, noop },	    button_1_down },	/* ^3 */
-	{ { deliver, noop },	    button_1_down },	/* vo */
-	{ { deliver, noop },	    button_1_down },	/* ^o */
-	{ { deliver, noop },	    button_1_down },	/* <> */
-	{ { deliver, noop },	    button_1_down },	/* <-> */
-	{ { noop, noop },	    button_1_down },	/* k */
-	{ { noop, noop },	    button_1_down },	/* ... */
-    },
+     {{noop, noop}, button_1_down},     /* v1 */
+     {{deliver, noop}, start},  /* ^1 */
+     {{deliver, noop}, button_1_down},  /* v2 */
+     {{deliver, noop}, button_1_down},  /* ^2 */
+     {{deliver, noop}, button_1_down},  /* v3 */
+     {{deliver, noop}, button_1_down},  /* ^3 */
+     {{deliver, noop}, button_1_down},  /* vo */
+     {{deliver, noop}, button_1_down},  /* ^o */
+     {{deliver, noop}, button_1_down},  /* <> */
+     {{deliver, noop}, button_1_down},  /* <-> */
+     {{noop, noop}, button_1_down},     /* k */
+     {{noop, noop}, button_1_down},     /* ... */
+     },
     /* button_2_down */
     {
-	{ { deliver, noop },	    button_2_down },	/* v1 */
-	{ { deliver, noop },	    button_2_down },	/* ^1 */
-	{ { noop, noop },	    button_2_down },	/* v2 */
-	{ { deliver, noop },	    start },		/* ^2 */
-	{ { deliver, noop },	    button_2_down },	/* v3 */
-	{ { deliver, noop },	    button_2_down },	/* ^3 */
-	{ { deliver, noop },	    button_2_down },	/* vo */
-	{ { deliver, noop },	    button_2_down },	/* ^o */
-	{ { deliver, noop },	    button_2_down },	/* <> */
-	{ { deliver, noop },	    button_2_down },	/* <-> */
-	{ { noop, noop },	    button_2_down },	/* k */
-	{ { noop, noop },	    button_2_down },	/* ... */
-    },
+     {{deliver, noop}, button_2_down},  /* v1 */
+     {{deliver, noop}, button_2_down},  /* ^1 */
+     {{noop, noop}, button_2_down},     /* v2 */
+     {{deliver, noop}, start},  /* ^2 */
+     {{deliver, noop}, button_2_down},  /* v3 */
+     {{deliver, noop}, button_2_down},  /* ^3 */
+     {{deliver, noop}, button_2_down},  /* vo */
+     {{deliver, noop}, button_2_down},  /* ^o */
+     {{deliver, noop}, button_2_down},  /* <> */
+     {{deliver, noop}, button_2_down},  /* <-> */
+     {{noop, noop}, button_2_down},     /* k */
+     {{noop, noop}, button_2_down},     /* ... */
+     },
     /* button_3_pend */
     {
-	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v1 */
-	{ { release, deliver },	    button_3_down },	/* ^1 */
-	{ { release, deliver },	    button_3_down },	/* v2 */
-	{ { release, deliver },	    button_3_down },	/* ^2 */
-	{ { release, deliver },	    button_3_down },	/* v3 */
-	{ { release, deliver },	    start },		/* ^3 */
-	{ { release, deliver },	    button_3_down },	/* vo */
-	{ { release, deliver },	    button_3_down },	/* ^o */
-	{ { deliver, noop },	    button_3_pend },	/* <> */
-	{ { release, deliver },	    button_3_down },	/* <-> */
-	{ { release, noop },	    button_3_down },	/* k */
-	{ { release, noop },	    button_3_down },	/* ... */
-    },
+     {{clearto, gen_down_2}, synth_2_down_13},  /* v1 */
+     {{release, deliver}, button_3_down},       /* ^1 */
+     {{release, deliver}, button_3_down},       /* v2 */
+     {{release, deliver}, button_3_down},       /* ^2 */
+     {{release, deliver}, button_3_down},       /* v3 */
+     {{release, deliver}, start},       /* ^3 */
+     {{release, deliver}, button_3_down},       /* vo */
+     {{release, deliver}, button_3_down},       /* ^o */
+     {{deliver, noop}, button_3_pend},  /* <> */
+     {{release, deliver}, button_3_down},       /* <-> */
+     {{release, noop}, button_3_down},  /* k */
+     {{release, noop}, button_3_down},  /* ... */
+     },
     /* button_3_down */
     {
-	{ { deliver, noop },	    button_3_down },	/* v1 */
-	{ { deliver, noop },	    button_3_down },	/* ^1 */
-	{ { deliver, noop },	    button_3_down },	/* v2 */
-	{ { deliver, noop },	    button_3_down },	/* ^2 */
-	{ { noop, noop },	    button_3_down },	/* v3 */
-	{ { deliver, noop },	    start },		/* ^3 */
-	{ { deliver, noop },	    button_3_down },	/* vo */
-	{ { deliver, noop },	    button_3_down },	/* ^o */
-	{ { deliver, noop },	    button_3_down },	/* <> */
-	{ { deliver, noop },	    button_3_down },	/* <-> */
-	{ { noop, noop },	    button_3_down },	/* k */
-	{ { noop, noop },	    button_3_down },	/* ... */
-    },
+     {{deliver, noop}, button_3_down},  /* v1 */
+     {{deliver, noop}, button_3_down},  /* ^1 */
+     {{deliver, noop}, button_3_down},  /* v2 */
+     {{deliver, noop}, button_3_down},  /* ^2 */
+     {{noop, noop}, button_3_down},     /* v3 */
+     {{deliver, noop}, start},  /* ^3 */
+     {{deliver, noop}, button_3_down},  /* vo */
+     {{deliver, noop}, button_3_down},  /* ^o */
+     {{deliver, noop}, button_3_down},  /* <> */
+     {{deliver, noop}, button_3_down},  /* <-> */
+     {{noop, noop}, button_3_down},     /* k */
+     {{noop, noop}, button_3_down},     /* ... */
+     },
     /* synthetic_2_down_13 */
     {
-	{ { noop, noop },	    synth_2_down_13 },	/* v1 */
-	{ { gen_up_2, noop },	    synth_2_down_3 },	/* ^1 */
-	{ { noop, noop },	    synth_2_down_13 },	/* v2 */
-	{ { noop, noop },	    synth_2_down_13 },	/* ^2 */
-	{ { noop, noop },	    synth_2_down_13 },	/* v3 */
-	{ { gen_up_2, noop },	    synth_2_down_1 },	/* ^3 */
-	{ { deliver, noop },	    synth_2_down_13 },	/* vo */
-	{ { deliver, noop },	    synth_2_down_13 },	/* ^o */
-	{ { deliver, noop },	    synth_2_down_13 },	/* <> */
-	{ { deliver, noop },	    synth_2_down_13 },	/* <-> */
-	{ { noop, noop },	    synth_2_down_13 },	/* k */
-	{ { noop, noop },	    synth_2_down_13 },	/* ... */
-    },
+     {{noop, noop}, synth_2_down_13},   /* v1 */
+     {{gen_up_2, noop}, synth_2_down_3},        /* ^1 */
+     {{noop, noop}, synth_2_down_13},   /* v2 */
+     {{noop, noop}, synth_2_down_13},   /* ^2 */
+     {{noop, noop}, synth_2_down_13},   /* v3 */
+     {{gen_up_2, noop}, synth_2_down_1},        /* ^3 */
+     {{deliver, noop}, synth_2_down_13},        /* vo */
+     {{deliver, noop}, synth_2_down_13},        /* ^o */
+     {{deliver, noop}, synth_2_down_13},        /* <> */
+     {{deliver, noop}, synth_2_down_13},        /* <-> */
+     {{noop, noop}, synth_2_down_13},   /* k */
+     {{noop, noop}, synth_2_down_13},   /* ... */
+     },
     /* synthetic_2_down_3 */
     {
-	{ { deliver, noop },	    synth_2_down_3 },	/* v1 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* ^1 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* v2 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* ^2 */
-	{ { noop, noop },	    synth_2_down_3 },	/* v3 */
-	{ { noop, noop },	    start },		/* ^3 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* vo */
-	{ { deliver, noop },	    synth_2_down_3 },	/* ^o */
-	{ { deliver, noop },	    synth_2_down_3 },	/* <> */
-	{ { deliver, noop },	    synth_2_down_3 },	/* <-> */
-	{ { noop, noop },	    synth_2_down_3 },	/* k */
-	{ { noop, noop },	    synth_2_down_3 },	/* ... */
-    },
+     {{deliver, noop}, synth_2_down_3}, /* v1 */
+     {{deliver, noop}, synth_2_down_3}, /* ^1 */
+     {{deliver, noop}, synth_2_down_3}, /* v2 */
+     {{deliver, noop}, synth_2_down_3}, /* ^2 */
+     {{noop, noop}, synth_2_down_3},    /* v3 */
+     {{noop, noop}, start},     /* ^3 */
+     {{deliver, noop}, synth_2_down_3}, /* vo */
+     {{deliver, noop}, synth_2_down_3}, /* ^o */
+     {{deliver, noop}, synth_2_down_3}, /* <> */
+     {{deliver, noop}, synth_2_down_3}, /* <-> */
+     {{noop, noop}, synth_2_down_3},    /* k */
+     {{noop, noop}, synth_2_down_3},    /* ... */
+     },
     /* synthetic_2_down_1 */
     {
-	{ { noop, noop },	    synth_2_down_1 },	/* v1 */
-	{ { noop, noop },	    start },		/* ^1 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* v2 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* ^2 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* v3 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* ^3 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* vo */
-	{ { deliver, noop },	    synth_2_down_1 },	/* ^o */
-	{ { deliver, noop },	    synth_2_down_1 },	/* <> */
-	{ { deliver, noop },	    synth_2_down_1 },	/* <-> */
-	{ { noop, noop },	    synth_2_down_1 },	/* k */
-	{ { noop, noop },	    synth_2_down_1 },	/* ... */
-    },
+     {{noop, noop}, synth_2_down_1},    /* v1 */
+     {{noop, noop}, start},     /* ^1 */
+     {{deliver, noop}, synth_2_down_1}, /* v2 */
+     {{deliver, noop}, synth_2_down_1}, /* ^2 */
+     {{deliver, noop}, synth_2_down_1}, /* v3 */
+     {{deliver, noop}, synth_2_down_1}, /* ^3 */
+     {{deliver, noop}, synth_2_down_1}, /* vo */
+     {{deliver, noop}, synth_2_down_1}, /* ^o */
+     {{deliver, noop}, synth_2_down_1}, /* <> */
+     {{deliver, noop}, synth_2_down_1}, /* <-> */
+     {{noop, noop}, synth_2_down_1},    /* k */
+     {{noop, noop}, synth_2_down_1},    /* ... */
+     },
 };
 
 #define EMULATION_WINDOW    10
 #define EMULATION_TIMEOUT   100
 
 static int
-KdInsideEmulationWindow (KdPointerInfo *pi, int x, int y, int z)
+KdInsideEmulationWindow(KdPointerInfo * pi, int x, int y, int z)
 {
     pi->emulationDx = pi->heldEvent.x - x;
     pi->emulationDy = pi->heldEvent.y - y;
 
-    return (abs (pi->emulationDx) < EMULATION_WINDOW &&
-	    abs (pi->emulationDy) < EMULATION_WINDOW);
+    return (abs(pi->emulationDx) < EMULATION_WINDOW &&
+            abs(pi->emulationDy) < EMULATION_WINDOW);
 }
 
 static KdInputClass
-KdClassifyInput (KdPointerInfo *pi, int type, int x, int y, int z, int b)
+KdClassifyInput(KdPointerInfo * pi, int type, int x, int y, int z, int b)
 {
     switch (type) {
     case ButtonPress:
-	switch (b) {
-	case 1: return down_1;
-	case 2: return down_2;
-	case 3: return down_3;
-	default: return down_o;
-	}
-	break;
+        switch (b) {
+        case 1:
+            return down_1;
+        case 2:
+            return down_2;
+        case 3:
+            return down_3;
+        default:
+            return down_o;
+        }
+        break;
     case ButtonRelease:
-	switch (b) {
-	case 1: return up_1;
-	case 2: return up_2;
-	case 3: return up_3;
-	default: return up_o;
-	}
-	break;
+        switch (b) {
+        case 1:
+            return up_1;
+        case 2:
+            return up_2;
+        case 3:
+            return up_3;
+        default:
+            return up_o;
+        }
+        break;
     case MotionNotify:
-	if (pi->eventHeld && !KdInsideEmulationWindow(pi, x, y, z))
-	    return outside_box;
-	else
-	    return motion;
+        if (pi->eventHeld && !KdInsideEmulationWindow(pi, x, y, z))
+            return outside_box;
+        else
+            return motion;
     default:
-	return keyboard;
+        return keyboard;
     }
     return keyboard;
 }
 
 #ifdef DEBUG
-char	*kdStateNames[] = {
+char *kdStateNames[] = {
     "start",
     "button_1_pend",
     "button_1_down",
@@ -1681,7 +1675,7 @@ char	*kdStateNames[] = {
     "num_input_states"
 };
 
-char	*kdClassNames[] = {
+char *kdClassNames[] = {
     "down_1", "up_1",
     "down_2", "up_2",
     "down_3", "up_3",
@@ -1700,95 +1694,92 @@ char *kdActionNames[] = {
     "gen_down_2",
     "gen_up_2",
 };
-#endif /* DEBUG */
+#endif                          /* DEBUG */
 
 static void
-KdQueueEvent (DeviceIntPtr pDev, InternalEvent *ev)
+KdQueueEvent(DeviceIntPtr pDev, InternalEvent *ev)
 {
-    KdAssertSigioBlocked ("KdQueueEvent");
-    mieqEnqueue (pDev, ev);
+    KdAssertSigioBlocked("KdQueueEvent");
+    mieqEnqueue(pDev, ev);
 }
 
 /* We return true if we're stealing the event. */
 static Bool
-KdRunMouseMachine (KdPointerInfo *pi, KdInputClass c, int type, int x, int y,
-                   int z, int b, int absrel)
+KdRunMouseMachine(KdPointerInfo * pi, KdInputClass c, int type, int x, int y,
+                  int z, int b, int absrel)
 {
     const KdInputTransition *t;
-    int	a;
+    int a;
 
     c = KdClassifyInput(pi, type, x, y, z, b);
     t = &kdInputMachine[pi->mouseState][c];
-    for (a = 0; a < MAX_ACTIONS; a++)
-    {
-	switch (t->actions[a]) {
-	case noop:
-	    break;
-	case hold:
-	    pi->eventHeld = TRUE;
-	    pi->emulationDx = 0;
-	    pi->emulationDy = 0;
-	    pi->heldEvent.type = type;
+    for (a = 0; a < MAX_ACTIONS; a++) {
+        switch (t->actions[a]) {
+        case noop:
+            break;
+        case hold:
+            pi->eventHeld = TRUE;
+            pi->emulationDx = 0;
+            pi->emulationDy = 0;
+            pi->heldEvent.type = type;
             pi->heldEvent.x = x;
             pi->heldEvent.y = y;
             pi->heldEvent.z = z;
             pi->heldEvent.flags = b;
             pi->heldEvent.absrel = absrel;
             return TRUE;
-	    break;
-	case setto:
-	    pi->emulationTimeout = GetTimeInMillis () + EMULATION_TIMEOUT;
-	    pi->timeoutPending = TRUE;
-	    break;
-	case deliver:
-            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,
-                                    pi->heldEvent.y, pi->heldEvent.z,
-                                    pi->heldEvent.flags, pi->heldEvent.absrel,
-                                    TRUE);
-	    break;
-	case release:
-	    pi->eventHeld = FALSE;
-	    pi->timeoutPending = FALSE;
-            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,
-                                    pi->heldEvent.y, pi->heldEvent.z,
-                                    pi->heldEvent.flags, pi->heldEvent.absrel,
-                                    TRUE);
+            break;
+        case setto:
+            pi->emulationTimeout = GetTimeInMillis() + EMULATION_TIMEOUT;
+            pi->timeoutPending = TRUE;
+            break;
+        case deliver:
+            _KdEnqueuePointerEvent(pi, pi->heldEvent.type, pi->heldEvent.x,
+                                   pi->heldEvent.y, pi->heldEvent.z,
+                                   pi->heldEvent.flags, pi->heldEvent.absrel,
+                                   TRUE);
+            break;
+        case release:
+            pi->eventHeld = FALSE;
+            pi->timeoutPending = FALSE;
+            _KdEnqueuePointerEvent(pi, pi->heldEvent.type, pi->heldEvent.x,
+                                   pi->heldEvent.y, pi->heldEvent.z,
+                                   pi->heldEvent.flags, pi->heldEvent.absrel,
+                                   TRUE);
             return TRUE;
-	    break;
-	case clearto:
-	    pi->timeoutPending = FALSE;
-	    break;
-	case gen_down_2:
-            _KdEnqueuePointerEvent (pi, ButtonPress, x, y, z, 2, absrel,
-                                    TRUE);
-	    pi->eventHeld = FALSE;
+            break;
+        case clearto:
+            pi->timeoutPending = FALSE;
+            break;
+        case gen_down_2:
+            _KdEnqueuePointerEvent(pi, ButtonPress, x, y, z, 2, absrel, TRUE);
+            pi->eventHeld = FALSE;
             return TRUE;
-	    break;
-	case gen_up_2:
-            _KdEnqueuePointerEvent (pi, ButtonRelease, x, y, z, 2, absrel,
-                                    TRUE);
+            break;
+        case gen_up_2:
+            _KdEnqueuePointerEvent(pi, ButtonRelease, x, y, z, 2, absrel, TRUE);
             return TRUE;
-	    break;
-	}
+            break;
+        }
     }
     pi->mouseState = t->nextState;
     return FALSE;
 }
 
 static int
-KdHandlePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z, int b,
-                      int absrel)
+KdHandlePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z, int b,
+                     int absrel)
 {
     if (pi->emulateMiddleButton)
-        return KdRunMouseMachine (pi, KdClassifyInput(pi, type, x, y, z, b),
-                                  type, x, y, z, b, absrel);
+        return KdRunMouseMachine(pi, KdClassifyInput(pi, type, x, y, z, b),
+                                 type, x, y, z, b, absrel);
     return FALSE;
 }
 
 static void
-KdReceiveTimeout (KdPointerInfo *pi)
+KdReceiveTimeout(KdPointerInfo * pi)
 {
-    KdRunMouseMachine (pi, timeout, 0, 0, 0, 0, 0, 0);
+    KdRunMouseMachine(pi, timeout, 0, 0, 0, 0, 0, 0);
 }
 
 /*
@@ -1805,17 +1796,16 @@ KdReceiveTimeout (KdPointerInfo *pi)
 extern int nClients;
 
 void
-KdReleaseAllKeys (void)
+KdReleaseAllKeys(void)
 {
 #if 0
-    int	key;
+    int key;
     KdKeyboardInfo *ki;
 
-    KdBlockSigio ();
+    KdBlockSigio();
 
     for (ki = kdKeyboards; ki; ki = ki->next) {
-        for (key = ki->keySyms.minKeyCode; key < ki->keySyms.maxKeyCode;
-             key++) {
+        for (key = ki->keySyms.minKeyCode; key < ki->keySyms.maxKeyCode; key++) {
             if (key_is_down(ki->dixdev, key, KEY_POSTED | KEY_PROCESSED)) {
                 KdHandleKeyboardEvent(ki, KeyRelease, key);
                 QueueGetKeyboardEvents(ki->dixdev, KeyRelease, key, NULL);
@@ -1823,56 +1813,55 @@ KdReleaseAllKeys (void)
         }
     }
 
-    KdUnblockSigio ();
+    KdUnblockSigio();
 #endif
 }
 
 static void
-KdCheckLock (void)
+KdCheckLock(void)
 {
-    KeyClassPtr	    keyc = NULL;
-    Bool	    isSet = FALSE, shouldBeSet = FALSE;
-    KdKeyboardInfo     *tmp = NULL;
+    KeyClassPtr keyc = NULL;
+    Bool isSet = FALSE, shouldBeSet = FALSE;
+    KdKeyboardInfo *tmp = NULL;
 
     for (tmp = kdKeyboards; tmp; tmp = tmp->next) {
         if (tmp->LockLed && tmp->dixdev && tmp->dixdev->key) {
             keyc = tmp->dixdev->key;
-            isSet = (tmp->leds & (1 << (tmp->LockLed-1))) != 0;
+            isSet = (tmp->leds & (1 << (tmp->LockLed - 1))) != 0;
             /* FIXME: Just use XKB indicators! */
-            shouldBeSet = !!(XkbStateFieldFromRec(&keyc->xkbInfo->state) & LockMask);
+            shouldBeSet =
+                ! !(XkbStateFieldFromRec(&keyc->xkbInfo->state) & LockMask);
             if (isSet != shouldBeSet)
-                KdSetLed (tmp, tmp->LockLed, shouldBeSet);
+                KdSetLed(tmp, tmp->LockLed, shouldBeSet);
         }
     }
 }
 
 void
-KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,
-                       unsigned char scan_code,
-		       unsigned char is_up)
+KdEnqueueKeyboardEvent(KdKeyboardInfo * ki,
+                       unsigned char scan_code, unsigned char is_up)
 {
     unsigned char key_code;
-    KeyClassPtr	keyc = NULL;
+    KeyClassPtr keyc = NULL;
     KeybdCtrl *ctrl = NULL;
     int type;
 
     if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed || !ki->dixdev->key)
-	return;
+        return;
 
     keyc = ki->dixdev->key;
     ctrl = &ki->dixdev->kbdfeed->ctrl;
 
-    if (scan_code >= ki->minScanCode && scan_code <= ki->maxScanCode)
-    {
-	key_code = scan_code + KD_MIN_KEYCODE - ki->minScanCode;
+    if (scan_code >= ki->minScanCode && scan_code <= ki->maxScanCode) {
+        key_code = scan_code + KD_MIN_KEYCODE - ki->minScanCode;
 
-	/*
-	 * Set up this event -- the type may be modified below
-	 */
-	if (is_up)
-	    type = KeyRelease;
-	else
-	    type = KeyPress;
+        /*
+         * Set up this event -- the type may be modified below
+         */
+        if (is_up)
+            type = KeyRelease;
+        else
+            type = KeyPress;
 
         QueueKeyboardEvents(ki->dixdev, type, key_code, NULL);
     }
@@ -1893,74 +1882,72 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,
 
 /* FIXME do something a little more clever to deal with multiple axes here */
 void
-KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
+KdEnqueuePointerEvent(KdPointerInfo * pi, unsigned long flags, int rx, int ry,
                       int rz)
 {
-    CARD32        ms;
+    CARD32 ms;
     unsigned char buttons;
-    int           x, y, z;
-    int           (*matrix)[3] = kdPointerMatrix.matrix;
+    int x, y, z;
+    int (*matrix)[3] = kdPointerMatrix.matrix;
     unsigned long button;
-    int           n;
-    int           dixflags = 0;
+    int n;
+    int dixflags = 0;
 
     if (!pi)
-	return;
+        return;
 
     ms = GetTimeInMillis();
 
     /* we don't need to transform z, so we don't. */
     if (flags & KD_MOUSE_DELTA) {
-	if (pi->transformCoordinates) {
-	    x = matrix[0][0] * rx + matrix[0][1] * ry;
-	    y = matrix[1][0] * rx + matrix[1][1] * ry;
-	}
-	else {
-	    x = rx;
-	    y = ry;
-	}
+        if (pi->transformCoordinates) {
+            x = matrix[0][0] * rx + matrix[0][1] * ry;
+            y = matrix[1][0] * rx + matrix[1][1] * ry;
+        }
+        else {
+            x = rx;
+            y = ry;
+        }
     }
     else {
-	if (pi->transformCoordinates) {
-	    x = matrix[0][0] * rx + matrix[0][1] * ry + matrix[0][2];
-	    y = matrix[1][0] * rx + matrix[1][1] * ry + matrix[1][2];
-	}
-	else {
-	    x = rx;
-	    y = ry;
-	}
+        if (pi->transformCoordinates) {
+            x = matrix[0][0] * rx + matrix[0][1] * ry + matrix[0][2];
+            y = matrix[1][0] * rx + matrix[1][1] * ry + matrix[1][2];
+        }
+        else {
+            x = rx;
+            y = ry;
+        }
     }
     z = rz;
 
-    if (flags & KD_MOUSE_DELTA)
-    {
-        if (x || y || z)
-        {
+    if (flags & KD_MOUSE_DELTA) {
+        if (x || y || z) {
             dixflags = POINTER_RELATIVE | POINTER_ACCELERATE;
-            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);
+            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags,
+                                   FALSE);
         }
-    } else
-    {
+    }
+    else {
         dixflags = POINTER_ABSOLUTE;
         if (x != pi->dixdev->last.valuators[0] ||
             y != pi->dixdev->last.valuators[1])
-            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);
+            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags,
+                                   FALSE);
     }
 
     buttons = flags;
 
-    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;
-         button <<= 1, n++) {
+    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons; button <<= 1, n++) {
         if (((pi->buttonState & button) ^ (buttons & button)) &&
-           !(buttons & button)) {
+            !(buttons & button)) {
             _KdEnqueuePointerEvent(pi, ButtonRelease, x, y, z, n,
                                    dixflags, FALSE);
-	}
+        }
     }
-    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;
-         button <<= 1, n++) {
-	if (((pi->buttonState & button) ^ (buttons & button)) &&
-	    (buttons & button)) {
+    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons; button <<= 1, n++) {
+        if (((pi->buttonState & button) ^ (buttons & button)) &&
+            (buttons & button)) {
             _KdEnqueuePointerEvent(pi, ButtonPress, x, y, z, n,
                                    dixflags, FALSE);
         }
@@ -1970,8 +1957,8 @@ KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
 }
 
 void
-_KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
-                        int b, int absrel, Bool force)
+_KdEnqueuePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z,
+                       int b, int absrel, Bool force)
 {
     int valuators[3] = { x, y, z };
     ValuatorMask mask;
@@ -1986,73 +1973,60 @@ _KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
 }
 
 void
-KdBlockHandler (int		screen,
-		pointer		blockData,
-		pointer		timeout,
-		pointer		readmask)
+KdBlockHandler(int screen, pointer blockData, pointer timeout, pointer readmask)
 {
-    KdPointerInfo		    *pi;
-    int myTimeout=0;
-
-    for (pi = kdPointers; pi; pi = pi->next)
-    {
-	if (pi->timeoutPending)
-	{
-	    int	ms;
+    KdPointerInfo *pi;
+    int myTimeout = 0;
 
-	    ms = pi->emulationTimeout - GetTimeInMillis ();
-	    if (ms < 1)
-		ms = 1;
-	    if(ms<myTimeout || myTimeout==0)
-		    myTimeout=ms;
-	}
+    for (pi = kdPointers; pi; pi = pi->next) {
+        if (pi->timeoutPending) {
+            int ms;
+
+            ms = pi->emulationTimeout - GetTimeInMillis();
+            if (ms < 1)
+                ms = 1;
+            if (ms < myTimeout || myTimeout == 0)
+                myTimeout = ms;
+        }
     }
     /* if we need to poll for events, do that */
-    if(kdOsFuncs->pollEvents)
-    {
-	    (*kdOsFuncs->pollEvents)();
-	    myTimeout=20;
+    if (kdOsFuncs->pollEvents) {
+        (*kdOsFuncs->pollEvents) ();
+        myTimeout = 20;
     }
-    if(myTimeout>0)
-    	AdjustWaitForDelay (timeout, myTimeout);
+    if (myTimeout > 0)
+        AdjustWaitForDelay(timeout, myTimeout);
 }
 
 void
-KdWakeupHandler (int		screen,
-		 pointer    	data,
-		 unsigned long	lresult,
-		 pointer	readmask)
+KdWakeupHandler(int screen,
+                pointer data, unsigned long lresult, pointer readmask)
 {
-    int		result = (int) lresult;
-    fd_set	*pReadmask = (fd_set *) readmask;
-    int		i;
-    KdPointerInfo	*pi;
+    int result = (int) lresult;
+    fd_set *pReadmask = (fd_set *) readmask;
+    int i;
+    KdPointerInfo *pi;
 
-    if (kdInputEnabled && result > 0)
-    {
-	for (i = 0; i < kdNumInputFds; i++)
-	    if (FD_ISSET (kdInputFds[i].fd, pReadmask))
-	    {
-		KdBlockSigio ();
-		(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
-		KdUnblockSigio ();
-	    }
-    }
-    for (pi = kdPointers; pi; pi = pi->next)
-    {
-	if (pi->timeoutPending)
-	{
-	    if ((long) (GetTimeInMillis () - pi->emulationTimeout) >= 0)
-	    {
-		pi->timeoutPending = FALSE;
-		KdBlockSigio ();
-		KdReceiveTimeout (pi);
-		KdUnblockSigio ();
-	    }
-	}
+    if (kdInputEnabled && result > 0) {
+        for (i = 0; i < kdNumInputFds; i++)
+            if (FD_ISSET(kdInputFds[i].fd, pReadmask)) {
+                KdBlockSigio();
+                (*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
+                KdUnblockSigio();
+            }
+    }
+    for (pi = kdPointers; pi; pi = pi->next) {
+        if (pi->timeoutPending) {
+            if ((long) (GetTimeInMillis() - pi->emulationTimeout) >= 0) {
+                pi->timeoutPending = FALSE;
+                KdBlockSigio();
+                KdReceiveTimeout(pi);
+                KdUnblockSigio();
+            }
+        }
     }
     if (kdSwitchPending)
-	KdProcessSwitch ();
+        KdProcessSwitch();
 }
 
 #define KdScreenOrigin(pScreen) (&(KdGetScreenPriv(pScreen)->screen->origin))
@@ -2060,84 +2034,75 @@ KdWakeupHandler (int		screen,
 static Bool
 KdCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)
 {
-    ScreenPtr	pScreen  = *ppScreen;
-    ScreenPtr	pNewScreen;
-    int		n;
-    int		dx, dy;
-    int		best_x, best_y;
-    int		n_best_x, n_best_y;
-    CARD32	ms;
+    ScreenPtr pScreen = *ppScreen;
+    ScreenPtr pNewScreen;
+    int n;
+    int dx, dy;
+    int best_x, best_y;
+    int n_best_x, n_best_y;
+    CARD32 ms;
 
     if (kdDisableZaphod || screenInfo.numScreens <= 1)
-	return FALSE;
+        return FALSE;
 
     if (0 <= *x && *x < pScreen->width && 0 <= *y && *y < pScreen->height)
-	return FALSE;
+        return FALSE;
 
-    ms = GetTimeInMillis ();
+    ms = GetTimeInMillis();
     if (kdOffScreen && (int) (ms - kdOffScreenTime) < 1000)
-	return FALSE;
+        return FALSE;
     kdOffScreen = TRUE;
     kdOffScreenTime = ms;
     n_best_x = -1;
     best_x = 32767;
     n_best_y = -1;
     best_y = 32767;
-    for (n = 0; n < screenInfo.numScreens; n++)
-    {
-	pNewScreen = screenInfo.screens[n];
-	if (pNewScreen == pScreen)
-	    continue;
-	dx = KdScreenOrigin(pNewScreen)->x - KdScreenOrigin(pScreen)->x;
-	dy = KdScreenOrigin(pNewScreen)->y - KdScreenOrigin(pScreen)->y;
-	if (*x < 0)
-	{
-	    if (dx <= 0 && -dx < best_x)
-	    {
-		best_x = -dx;
-		n_best_x = n;
-	    }
-	}
-	else if (*x >= pScreen->width)
-	{
-	    if (dx >= 0 && dx < best_x)
-	    {
-		best_x = dx;
-		n_best_x = n;
-	    }
-	}
-	if (*y < 0)
-	{
-	    if (dy <= 0 && -dy < best_y)
-	    {
-		best_y = -dy;
-		n_best_y = n;
-	    }
-	}
-	else if (*y >= pScreen->height)
-	{
-	    if (dy >= 0 && dy < best_y)
-	    {
-		best_y = dy;
-		n_best_y = n;
-	    }
-	}
+    for (n = 0; n < screenInfo.numScreens; n++) {
+        pNewScreen = screenInfo.screens[n];
+        if (pNewScreen == pScreen)
+            continue;
+        dx = KdScreenOrigin(pNewScreen)->x - KdScreenOrigin(pScreen)->x;
+        dy = KdScreenOrigin(pNewScreen)->y - KdScreenOrigin(pScreen)->y;
+        if (*x < 0) {
+            if (dx <= 0 && -dx < best_x) {
+                best_x = -dx;
+                n_best_x = n;
+            }
+        }
+        else if (*x >= pScreen->width) {
+            if (dx >= 0 && dx < best_x) {
+                best_x = dx;
+                n_best_x = n;
+            }
+        }
+        if (*y < 0) {
+            if (dy <= 0 && -dy < best_y) {
+                best_y = -dy;
+                n_best_y = n;
+            }
+        }
+        else if (*y >= pScreen->height) {
+            if (dy >= 0 && dy < best_y) {
+                best_y = dy;
+                n_best_y = n;
+            }
+        }
     }
     if (best_y < best_x)
-	n_best_x = n_best_y;
+        n_best_x = n_best_y;
     if (n_best_x == -1)
-	return FALSE;
+        return FALSE;
     pNewScreen = screenInfo.screens[n_best_x];
 
     if (*x < 0)
-	*x += pNewScreen->width;
+        *x += pNewScreen->width;
     if (*y < 0)
-	*y += pNewScreen->height;
+        *y += pNewScreen->height;
 
     if (*x >= pScreen->width)
-	*x -= pScreen->width;
+        *x -= pScreen->width;
     if (*y >= pScreen->height)
-	*y -= pScreen->height;
+        *y -= pScreen->height;
 
     *ppScreen = pNewScreen;
     return TRUE;
@@ -2148,31 +2113,30 @@ KdCrossScreen(ScreenPtr pScreen, Bool entering)
 {
 }
 
-int KdCurScreen;	/* current event screen */
+int KdCurScreen;                /* current event screen */
 
 static void
-KdWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+KdWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
 {
-    KdBlockSigio ();
+    KdBlockSigio();
     KdCurScreen = pScreen->myNum;
     miPointerWarpCursor(pDev, pScreen, x, y);
-    KdUnblockSigio ();
+    KdUnblockSigio();
 }
 
-miPointerScreenFuncRec kdPointerScreenFuncs =
-{
+miPointerScreenFuncRec kdPointerScreenFuncs = {
     KdCursorOffScreen,
     KdCrossScreen,
     KdWarpCursor
 };
 
 void
-ProcessInputEvents (void)
+ProcessInputEvents(void)
 {
     mieqProcessInputEvents();
     if (kdSwitchPending)
-	KdProcessSwitch ();
-    KdCheckLock ();
+        KdProcessSwitch();
+    KdCheckLock();
 }
 
 /* At the moment, absolute/relative is up to the client. */
@@ -2191,7 +2155,7 @@ SetDeviceValuators(register ClientPtr client, DeviceIntPtr pDev,
 
 int
 ChangeDeviceControl(register ClientPtr client, DeviceIntPtr pDev,
-                        xDeviceCtl *control)
+                    xDeviceCtl * control)
 {
     switch (control->control) {
     case DEVICE_RESOLUTION:
@@ -2214,7 +2178,7 @@ ChangeDeviceControl(register ClientPtr client, DeviceIntPtr pDev,
 }
 
 int
-NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
+NewInputDeviceRequest(InputOption *options, InputAttributes * attrs,
                       DeviceIntPtr *pdev)
 {
     InputOption *option = NULL;
@@ -2243,16 +2207,14 @@ NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
         }
 #ifdef CONFIG_HAL
         else if (strcmp(key, "_source") == 0 &&
-                 strcmp(value, "server/hal") == 0)
-        {
+                 strcmp(value, "server/hal") == 0) {
             ErrorF("Ignoring device from HAL.\n");
             return BadValue;
         }
 #endif
 #ifdef CONFIG_UDEV
         else if (strcmp(key, "_source") == 0 &&
-                 strcmp(value, "server/udev") == 0)
-        {
+                 strcmp(value, "server/udev") == 0) {
             ErrorF("Ignoring device from udev.\n");
             return BadValue;
         }
@@ -2317,7 +2279,8 @@ NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
 
     if (pi) {
         *pdev = pi->dixdev;
-    } else if(ki) {
+    }
+    else if (ki) {
         *pdev = ki->dixdev;
     }
 
diff --git a/hw/kdrive/src/kmode.c b/hw/kdrive/src/kmode.c
index 38b7bc881..ef1b6b4fa 100644
--- a/hw/kdrive/src/kmode.c
+++ b/hw/kdrive/src/kmode.c
@@ -26,223 +26,222 @@
 #endif
 #include "kdrive.h"
 
-const KdMonitorTiming  kdMonitorTimings[] = {
-    /*	H	V	Hz	KHz */
-		/*  FP	    BP	    BLANK   POLARITY */
+const KdMonitorTiming kdMonitorTimings[] = {
+    /*  H       V       Hz      KHz */
+    /*  FP      BP      BLANK   POLARITY */
 
     /* IPAQ modeline:
      *
      * Modeline "320x240"      5.7222 320 337 340 352   240 241 244 254"
      */
-    {   320,	240,	64,	16256,
-	            17,	    12,	    32,     KdSyncNegative,
-	            1,      11,     14,     KdSyncNegative,
-    },
+    {320, 240, 64, 16256,
+     17, 12, 32, KdSyncNegative,
+     1, 11, 14, KdSyncNegative,
+     },
 
     /* Other VESA modes */
-    {	640,	350,	85,	31500,			    /* VESA */
-		    32,	    96,	    192,    KdSyncPositive, /* 26.413 */
-		    32,	    60,	    95,	    KdSyncNegative, /* 59.354 */
-    },
-    {	640,	400,	60,	31500,			    /* VESA */
-		    32,	    96,	    192,    KdSyncNegative, /* 26.413 */
-		    1,	    41,	    45,	    KdSyncPositive, /* 59.354 */
-    },
-    {	720,	400,	85,	35500,			    /* VESA */
-		    36,	    108,    216,    KdSyncNegative, /* 37.927 */
-		    1,	    42,	    46,	    KdSyncPositive, /* 85.039 */
-    },
-
+    {640, 350, 85, 31500,       /* VESA */
+     32, 96, 192, KdSyncPositive,       /* 26.413 */
+     32, 60, 95, KdSyncNegative,        /* 59.354 */
+     },
+    {640, 400, 60, 31500,       /* VESA */
+     32, 96, 192, KdSyncNegative,       /* 26.413 */
+     1, 41, 45, KdSyncPositive, /* 59.354 */
+     },
+    {720, 400, 85, 35500,       /* VESA */
+     36, 108, 216, KdSyncNegative,      /* 37.927 */
+     1, 42, 46, KdSyncPositive, /* 85.039 */
+     },
 
     /* Modeline "720x576"     29.000 720  736  800  880   576  577  580  625 */
     {
-        720,    576,    52,     32954,                      /* PAL Video */
-        16,     80,  160, KdSyncPositive, /* 32.954 */
-        1,      45,   49, KdSyncPositive, /* 52.727 */
-    },
+     720, 576, 52, 32954,       /* PAL Video */
+     16, 80, 160, KdSyncPositive,       /* 32.954 */
+     1, 45, 49, KdSyncPositive, /* 52.727 */
+     },
 
     /* 640x480 modes */
-    {	640,	480,	85,	36000,			    /* VESA */
-		    56,	    80,	    192,    KdSyncNegative, /* 43.269 */
-		    1,	    25,	    29,	    KdSyncNegative, /* 85.008 */
-    },
-    {	640,	480,	75,	31500,			    /* VESA */
-		    16,	    120,    200,    KdSyncNegative, /* 37.500 */
-		    1,	    16,	    20,	    KdSyncNegative, /* 75.000 */
-    },
-    {	640,	480,	72,	31500,			    /* VESA */
-		    16,	    120,    176,    KdSyncNegative, /* 37.861 */
-		    1,	    20,	    24,	    KdSyncNegative, /* 72.809 */
-    },
-    {	640,	480,	60,	25175,			    /* VESA */
-		   16,	    48,	    160,    KdSyncNegative, /* 31.469 */
-		   10,	    33,	    45,	    KdSyncNegative, /* 59.940 */
-    },
+    {640, 480, 85, 36000,       /* VESA */
+     56, 80, 192, KdSyncNegative,       /* 43.269 */
+     1, 25, 29, KdSyncNegative, /* 85.008 */
+     },
+    {640, 480, 75, 31500,       /* VESA */
+     16, 120, 200, KdSyncNegative,      /* 37.500 */
+     1, 16, 20, KdSyncNegative, /* 75.000 */
+     },
+    {640, 480, 72, 31500,       /* VESA */
+     16, 120, 176, KdSyncNegative,      /* 37.861 */
+     1, 20, 24, KdSyncNegative, /* 72.809 */
+     },
+    {640, 480, 60, 25175,       /* VESA */
+     16, 48, 160, KdSyncNegative,       /* 31.469 */
+     10, 33, 45, KdSyncNegative,        /* 59.940 */
+     },
 
     /* 800x600 modes */
-    {	800,	600,	85,	56250,			    /* VESA */
-		    32,	    152,    248,    KdSyncPositive, /* 53.674 */
-		    1,	    27,	    31,	    KdSyncPositive, /* 85.061 */
-    },
-    {	800,	600,	75,	49500,			    /* VESA */
-		    16,	    160,    256,    KdSyncPositive, /* 46.875 */
-		    1,	    21,	    25,	    KdSyncPositive, /* 75.000 */
-    },
+    {800, 600, 85, 56250,       /* VESA */
+     32, 152, 248, KdSyncPositive,      /* 53.674 */
+     1, 27, 31, KdSyncPositive, /* 85.061 */
+     },
+    {800, 600, 75, 49500,       /* VESA */
+     16, 160, 256, KdSyncPositive,      /* 46.875 */
+     1, 21, 25, KdSyncPositive, /* 75.000 */
+     },
     /* DEFAULT */
 #define MONITOR_TIMING_DEFAULT	9
-    {	800,	600,	72,	50000,			    /* VESA */
-		    56,	    64,	    240,    KdSyncPositive, /* 48.077 */
-		    37,	    23,	    66,	    KdSyncPositive, /* 72.188 */
-    },
-    {	800,	600,	60,	40000,			    /* VESA */
-		    40,	    88,	    256,    KdSyncPositive, /* 37.879 */
-		    1,	    23,	    28,	    KdSyncPositive, /* 60.317 */
-    },
-    {	800,	600,	56,	36000,			    /* VESA */
-		    24,	    128,    224,    KdSyncPositive, /* 35.156 */
-		    1,	    22,	    25,	    KdSyncPositive, /* 56.250 */
-    },
+    {800, 600, 72, 50000,       /* VESA */
+     56, 64, 240, KdSyncPositive,       /* 48.077 */
+     37, 23, 66, KdSyncPositive,        /* 72.188 */
+     },
+    {800, 600, 60, 40000,       /* VESA */
+     40, 88, 256, KdSyncPositive,       /* 37.879 */
+     1, 23, 28, KdSyncPositive, /* 60.317 */
+     },
+    {800, 600, 56, 36000,       /* VESA */
+     24, 128, 224, KdSyncPositive,      /* 35.156 */
+     1, 22, 25, KdSyncPositive, /* 56.250 */
+     },
 
     /* 1024x768 modes */
-    {	1024,	768,	85,	94500,			    /* VESA */
-		    48,	    208,    352,    KdSyncPositive, /* 68.677 */
-		    1,	    36,	    40,	    KdSyncPositive, /* 84.997 */
-    },
-    {	1024,	768,	75,	78750,			    /* VESA */
-		    16,	    176,    288,    KdSyncPositive, /* 60.023 */
-		    1,	    28,	    32,	    KdSyncPositive, /* 75.029 */
-    },
-    {	1024,	768,	70,	75000,			    /* VESA */
-		    24,	    144,    304,    KdSyncNegative, /* 56.476 */
-		    3,	    29,	    38,	    KdSyncNegative, /* 70.069 */
-    },
-    {	1024,	768,	60,	65000,			    /* VESA */
-		    24,	    160,    320,    KdSyncNegative, /* 48.363 */
-		    3,	    29,	    38,	    KdSyncNegative, /* 60.004 */
-    },
+    {1024, 768, 85, 94500,      /* VESA */
+     48, 208, 352, KdSyncPositive,      /* 68.677 */
+     1, 36, 40, KdSyncPositive, /* 84.997 */
+     },
+    {1024, 768, 75, 78750,      /* VESA */
+     16, 176, 288, KdSyncPositive,      /* 60.023 */
+     1, 28, 32, KdSyncPositive, /* 75.029 */
+     },
+    {1024, 768, 70, 75000,      /* VESA */
+     24, 144, 304, KdSyncNegative,      /* 56.476 */
+     3, 29, 38, KdSyncNegative, /* 70.069 */
+     },
+    {1024, 768, 60, 65000,      /* VESA */
+     24, 160, 320, KdSyncNegative,      /* 48.363 */
+     3, 29, 38, KdSyncNegative, /* 60.004 */
+     },
 
     /* 1152x864 mode */
-    {	1152,	864,	75,	108000,			    /* VESA */
-		    64,	    256,    448,    KdSyncPositive, /* 67.500 */
-		    1,	    32,	    36,	    KdSyncPositive, /* 75.000 */
-    },
+    {1152, 864, 75, 108000,     /* VESA */
+     64, 256, 448, KdSyncPositive,      /* 67.500 */
+     1, 32, 36, KdSyncPositive, /* 75.000 */
+     },
 
     /* 1152x900 modes */
-    {	1152,	900,	85,	122500,			    /* ADDED */
-		    48,	    208,    384,    KdSyncPositive, /* 79.753 */
-		    1,	    32,	    38,	    KdSyncPositive, /* 85.024 */
-    },
-    {	1152,	900,	75,	108250,			    /* ADDED */
-		    32,	    208,    384,    KdSyncPositive, /* 70.475 */
-		    1,	    32,	    38,	    KdSyncPositive, /* 75.133 */
-    },
-    {	1152,	900,	70,	100250,			    /* ADDED */
-		    32,	    208,    384,    KdSyncPositive, /* 65.267 */
-		    2,	    32,	    38,	    KdSyncPositive, /* 69.581 */
-    },
-    {	1152,	900,	66,	95000,			    /* ADDED */
-		    32,	    208,    384,    KdSyncPositive, /* 61.849 */
-		    1,	    32,	    38,	    KdSyncPositive, /* 65.937 */
-    },
+    {1152, 900, 85, 122500,     /* ADDED */
+     48, 208, 384, KdSyncPositive,      /* 79.753 */
+     1, 32, 38, KdSyncPositive, /* 85.024 */
+     },
+    {1152, 900, 75, 108250,     /* ADDED */
+     32, 208, 384, KdSyncPositive,      /* 70.475 */
+     1, 32, 38, KdSyncPositive, /* 75.133 */
+     },
+    {1152, 900, 70, 100250,     /* ADDED */
+     32, 208, 384, KdSyncPositive,      /* 65.267 */
+     2, 32, 38, KdSyncPositive, /* 69.581 */
+     },
+    {1152, 900, 66, 95000,      /* ADDED */
+     32, 208, 384, KdSyncPositive,      /* 61.849 */
+     1, 32, 38, KdSyncPositive, /* 65.937 */
+     },
 
     /* 1280x854 modes */
-    {   1280,   854,   103,     12500,			    /* ADDED */
-	            56,     16,     128,    KdSyncPositive, /* 102.554 */
-	            1,     216,     12,     KdSyncPositive,
-    },
+    {1280, 854, 103, 12500,     /* ADDED */
+     56, 16, 128, KdSyncPositive,       /* 102.554 */
+     1, 216, 12, KdSyncPositive,
+     },
 
     /* 1280x960 modes */
-    {	1280,	960,	85,	148500,			    /* VESA */
-		    64,	    224,    448,    KdSyncPositive, /* 85.938 */
-		    1,	    47,	    51,	    KdSyncPositive, /* 85.002 */
-    },
-    {	1280,	960,	60,	108000,			    /* VESA */
-		    96,	    312,    520,    KdSyncPositive, /* 60.000 */
-		    1,	    36,	    40,	    KdSyncPositive, /* 60.000 */
-    },
+    {1280, 960, 85, 148500,     /* VESA */
+     64, 224, 448, KdSyncPositive,      /* 85.938 */
+     1, 47, 51, KdSyncPositive, /* 85.002 */
+     },
+    {1280, 960, 60, 108000,     /* VESA */
+     96, 312, 520, KdSyncPositive,      /* 60.000 */
+     1, 36, 40, KdSyncPositive, /* 60.000 */
+     },
 
     /* 1280x1024 modes */
-    {	1280,	1024,	85,	157500,			    /* VESA */
-		    64,	    224,    448,    KdSyncPositive, /* 91.146 */
-		    1,	    44,	    48,	    KdSyncPositive, /* 85.024 */
-    },
-    {	1280,	1024,	75,	135000,			    /* VESA */
-		    16,	    248,    408,    KdSyncPositive, /* 79.976 */
-		    1,	    38,	    42,	    KdSyncPositive, /* 75.025 */
-    },
-    {	1280,	1024,	60,	108000,			    /* VESA */
-		    48,	    248,    408,    KdSyncPositive, /* 63.981 */
-		    1,	    38,	    42,	    KdSyncPositive, /* 60.020 */
-    },
+    {1280, 1024, 85, 157500,    /* VESA */
+     64, 224, 448, KdSyncPositive,      /* 91.146 */
+     1, 44, 48, KdSyncPositive, /* 85.024 */
+     },
+    {1280, 1024, 75, 135000,    /* VESA */
+     16, 248, 408, KdSyncPositive,      /* 79.976 */
+     1, 38, 42, KdSyncPositive, /* 75.025 */
+     },
+    {1280, 1024, 60, 108000,    /* VESA */
+     48, 248, 408, KdSyncPositive,      /* 63.981 */
+     1, 38, 42, KdSyncPositive, /* 60.020 */
+     },
 
     /* 1600x1200 modes */
-    {	1600,	1200,	85,	229500,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 106.250 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 85.000 */
-    },
-    {	1600,	1200,	75,	202500,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 93.750 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 75.000 */
-    },
-    {	1600,	1200,	70,	189000,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 87.500 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 70.000 */
-    },
-    {	1600,	1200,	65,	175500,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 81.250 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 65.000 */
-    },
-    {	1600,	1200,	60,	162000,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 75.000 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 60.000 */
-    },
+    {1600, 1200, 85, 229500,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 106.250 */
+     1, 46, 50, KdSyncPositive, /* 85.000 */
+     },
+    {1600, 1200, 75, 202500,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 93.750 */
+     1, 46, 50, KdSyncPositive, /* 75.000 */
+     },
+    {1600, 1200, 70, 189000,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 87.500 */
+     1, 46, 50, KdSyncPositive, /* 70.000 */
+     },
+    {1600, 1200, 65, 175500,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 81.250 */
+     1, 46, 50, KdSyncPositive, /* 65.000 */
+     },
+    {1600, 1200, 60, 162000,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 75.000 */
+     1, 46, 50, KdSyncPositive, /* 60.000 */
+     },
 
     /* 1792x1344 modes */
-    {	1792,	1344,	85,	301500,			    /* ADDED */
-		    96,	    352,    672,    KdSyncNegative, /* 122.362 */
-		    1,	    92,	    96,	    KdSyncPositive, /* 84.974 */
-    },
-    {	1792,	1344,	75,	261000,			    /* VESA */
-		    96,	    352,    664,    KdSyncNegative, /* 106.270 */
-		    1,	    69,	    73,	    KdSyncPositive, /* 74.997 */
-    },
-    {	1792,	1344,	60,	204750,			    /* VESA */
-		    128,    328,    656,    KdSyncNegative, /* 83.640 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 60.000 */
-    },
+    {1792, 1344, 85, 301500,    /* ADDED */
+     96, 352, 672, KdSyncNegative,      /* 122.362 */
+     1, 92, 96, KdSyncPositive, /* 84.974 */
+     },
+    {1792, 1344, 75, 261000,    /* VESA */
+     96, 352, 664, KdSyncNegative,      /* 106.270 */
+     1, 69, 73, KdSyncPositive, /* 74.997 */
+     },
+    {1792, 1344, 60, 204750,    /* VESA */
+     128, 328, 656, KdSyncNegative,     /* 83.640 */
+     1, 46, 50, KdSyncPositive, /* 60.000 */
+     },
 
 #if 0
-    { 1800, 1012, 75 },
-    { 1906, 1072, 68 },
+    {1800, 1012, 75},
+    {1906, 1072, 68},
 #endif
 
     /* 1856x1392 modes */
-    {	1856,	1392,	85,	330500,			    /* ADDED */
-		    160,    352,    736,    KdSyncNegative, /* 127.508 */
-		    1,	    104,    108,    KdSyncPositive, /* 85.001 */
-    },
-    {	1856,	1392,	75,	288000,			    /* VESA */
-		    128,    352,    704,    KdSyncNegative, /* 112.500 */
-		    1,	    104,    108,    KdSyncPositive, /* 75.000 */
-    },
-    {	1856,	1392,	60,	218250,			    /* VESA */
-		    96,	    352,    672,    KdSyncNegative, /* 86.333 */
-		    1,	    43,	    47,	    KdSyncPositive, /* 59.995 */
-    },
+    {1856, 1392, 85, 330500,    /* ADDED */
+     160, 352, 736, KdSyncNegative,     /* 127.508 */
+     1, 104, 108, KdSyncPositive,       /* 85.001 */
+     },
+    {1856, 1392, 75, 288000,    /* VESA */
+     128, 352, 704, KdSyncNegative,     /* 112.500 */
+     1, 104, 108, KdSyncPositive,       /* 75.000 */
+     },
+    {1856, 1392, 60, 218250,    /* VESA */
+     96, 352, 672, KdSyncNegative,      /* 86.333 */
+     1, 43, 47, KdSyncPositive, /* 59.995 */
+     },
 
     /* 1920x1440 modes */
-    {	1920,	1440,	85,	341750,			    /* ADDED */
-		    160,    352,    760,    KdSyncNegative, /* 127.512 */
-		    1,	    56,	    60,	    KdSyncPositive, /* 85.012 */
-    },
-    {	1920,	1440,	75,	297000,			    /* VESA */
-		    144,    352,    720,    KdSyncNegative, /* 112.500 */
-		    1,	    56,	    60,	    KdSyncPositive, /* 75.000 */
-    },
-    {	1920,	1440,	60,	234000,			    /* VESA */
-		    128,    244,    680,    KdSyncNegative, /* 90.000 */
-		    1,	    56,	    60,	    KdSyncPositive, /* 60.000 */
-    },
+    {1920, 1440, 85, 341750,    /* ADDED */
+     160, 352, 760, KdSyncNegative,     /* 127.512 */
+     1, 56, 60, KdSyncPositive, /* 85.012 */
+     },
+    {1920, 1440, 75, 297000,    /* VESA */
+     144, 352, 720, KdSyncNegative,     /* 112.500 */
+     1, 56, 60, KdSyncPositive, /* 75.000 */
+     },
+    {1920, 1440, 60, 234000,    /* VESA */
+     128, 244, 680, KdSyncNegative,     /* 90.000 */
+     1, 56, 60, KdSyncPositive, /* 60.000 */
+     },
 };
 
 #define NUM_MONITOR_TIMINGS (sizeof kdMonitorTimings/sizeof kdMonitorTimings[0])
@@ -250,148 +249,129 @@ const KdMonitorTiming  kdMonitorTimings[] = {
 const int kdNumMonitorTimings = NUM_MONITOR_TIMINGS;
 
 const KdMonitorTiming *
-KdFindMode (KdScreenInfo    *screen,
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *))
+KdFindMode(KdScreenInfo * screen,
+           Bool (*supported) (KdScreenInfo *, const KdMonitorTiming *))
 {
-    int			    i;
-    const KdMonitorTiming   *t;
-
-    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
-    {
-	if ((*supported) (screen, t) &&
-	    t->horizontal == screen->width &&
-	    t->vertical == screen->height &&
-	    (!screen->rate || t->rate <= screen->rate))
-	{
-	    return t;
-	}
+    int i;
+    const KdMonitorTiming *t;
+
+    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++) {
+        if ((*supported) (screen, t) &&
+            t->horizontal == screen->width &&
+            t->vertical == screen->height &&
+            (!screen->rate || t->rate <= screen->rate)) {
+            return t;
+        }
     }
     ErrorF("Warning: mode not found, using default\n");
     return &kdMonitorTimings[MONITOR_TIMING_DEFAULT];
 }
 
 static const KdMonitorTiming *
-kdFindPrevSize (const KdMonitorTiming *old)
+kdFindPrevSize(const KdMonitorTiming * old)
 {
-    const KdMonitorTiming   *new, *prev;
+    const KdMonitorTiming *new, *prev;
 
     if (old == kdMonitorTimings)
-	return 0;
+        return 0;
     new = old;
     /*
      * Search for the previous size
      */
-    while (new != kdMonitorTimings)
-    {
-	new--;
-	if (new->horizontal != old->horizontal &&
-	    new->vertical != old->vertical)
-	{
-	    break;
-	}
+    while (new != kdMonitorTimings) {
+        new--;
+        if (new->horizontal != old->horizontal &&
+            new->vertical != old->vertical) {
+            break;
+        }
     }
     /*
      * Match the refresh rate (<=)
      */
-    while (new != kdMonitorTimings)
-    {
-	prev = new - 1;
-	if (prev->horizontal == new->horizontal &&
-	    prev->vertical == new->vertical &&
-	    prev->rate > old->rate)
-	{
-	    break;
-	}
-	new--;
+    while (new != kdMonitorTimings) {
+        prev = new - 1;
+        if (prev->horizontal == new->horizontal &&
+            prev->vertical == new->vertical && prev->rate > old->rate) {
+            break;
+        }
+        new--;
     }
     return new;
 }
 
 Bool
-KdTuneMode (KdScreenInfo    *screen,
-	    Bool	    (*usable) (KdScreenInfo *),
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *))
+KdTuneMode(KdScreenInfo * screen,
+           Bool (*usable) (KdScreenInfo *),
+           Bool (*supported) (KdScreenInfo *, const KdMonitorTiming *))
 {
-    const KdMonitorTiming   *t;
-
-    while (!(*usable) (screen))
-    {
-	/*
-	 * Fix requested depth and geometry until it works
-	 */
-	if (screen->fb.depth > 16)
-	    screen->fb.depth = 16;
-	else if (screen->fb.depth > 8)
-	    screen->fb.depth = 8;
-	else
-	{
-	    t = kdFindPrevSize (KdFindMode (screen, supported));
-	    if (!t)
-		return FALSE;
-	    screen->width = t->horizontal;
-	    screen->height = t->vertical;
-	    screen->rate = t->rate;
-	}
+    const KdMonitorTiming *t;
+
+    while (!(*usable) (screen)) {
+        /*
+         * Fix requested depth and geometry until it works
+         */
+        if (screen->fb.depth > 16)
+            screen->fb.depth = 16;
+        else if (screen->fb.depth > 8)
+            screen->fb.depth = 8;
+        else {
+            t = kdFindPrevSize(KdFindMode(screen, supported));
+            if (!t)
+                return FALSE;
+            screen->width = t->horizontal;
+            screen->height = t->vertical;
+            screen->rate = t->rate;
+        }
     }
     return TRUE;
 }
 
 #ifdef RANDR
 Bool
-KdRandRGetInfo (ScreenPtr pScreen,
-		int randr,
-		Bool (*supported) (ScreenPtr pScreen,
-				   const KdMonitorTiming *))
+KdRandRGetInfo(ScreenPtr pScreen,
+               int randr,
+               Bool (*supported) (ScreenPtr pScreen, const KdMonitorTiming *))
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	    *screen = pScreenPriv->screen;
-    int			    i;
-    const KdMonitorTiming   *t;
-
-    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
-    {
-	if ((*supported) (pScreen, t))
-	{
-	    RRScreenSizePtr pSize;
-
-	    pSize = RRRegisterSize (pScreen,
-				    t->horizontal,
-				    t->vertical,
-				    screen->width_mm,
-				    screen->height_mm);
-	    if (!pSize)
-		return FALSE;
-	    if (!RRRegisterRate (pScreen, pSize, t->rate))
-		return FALSE;
-	    if (t->horizontal == screen->width &&
-		t->vertical == screen->height &&
-		t->rate == screen->rate)
-		RRSetCurrentConfig (pScreen, randr, t->rate, pSize);
-	}
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int i;
+    const KdMonitorTiming *t;
+
+    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++) {
+        if ((*supported) (pScreen, t)) {
+            RRScreenSizePtr pSize;
+
+            pSize = RRRegisterSize(pScreen,
+                                   t->horizontal,
+                                   t->vertical,
+                                   screen->width_mm, screen->height_mm);
+            if (!pSize)
+                return FALSE;
+            if (!RRRegisterRate(pScreen, pSize, t->rate))
+                return FALSE;
+            if (t->horizontal == screen->width &&
+                t->vertical == screen->height && t->rate == screen->rate)
+                RRSetCurrentConfig(pScreen, randr, t->rate, pSize);
+        }
     }
 
     return TRUE;
 }
 
 const KdMonitorTiming *
-KdRandRGetTiming (ScreenPtr	    pScreen,
-		  Bool		    (*supported) (ScreenPtr pScreen,
-						  const KdMonitorTiming *),
-		  int		    rate,
-		  RRScreenSizePtr   pSize)
+KdRandRGetTiming(ScreenPtr pScreen,
+                 Bool (*supported) (ScreenPtr pScreen,
+                                    const KdMonitorTiming *),
+                 int rate, RRScreenSizePtr pSize)
 {
-    int			    i;
-    const KdMonitorTiming   *t;
-
-    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
-    {
-	if (t->horizontal == pSize->width &&
-	    t->vertical == pSize->height &&
-	    t->rate == rate &&
-	    (*supported) (pScreen, t))
-	    return t;
+    int i;
+    const KdMonitorTiming *t;
+
+    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++) {
+        if (t->horizontal == pSize->width &&
+            t->vertical == pSize->height &&
+            t->rate == rate && (*supported) (pScreen, t))
+            return t;
     }
     return 0;
 }
diff --git a/hw/kdrive/src/kshadow.c b/hw/kdrive/src/kshadow.c
index 63bb87bc6..828ea19a6 100644
--- a/hw/kdrive/src/kshadow.c
+++ b/hw/kdrive/src/kshadow.c
@@ -26,21 +26,21 @@
 #include "kdrive.h"
 
 Bool
-KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate)
+KdShadowFbAlloc(KdScreenInfo * screen, Bool rotate)
 {
-    int	    paddedWidth;
-    void    *buf;
-    int	    width = rotate ? screen->height : screen->width;
-    int	    height = rotate ? screen->width : screen->height;
-    int	    bpp = screen->fb.bitsPerPixel;
+    int paddedWidth;
+    void *buf;
+    int width = rotate ? screen->height : screen->width;
+    int height = rotate ? screen->width : screen->height;
+    int bpp = screen->fb.bitsPerPixel;
 
     /* use fb computation for width */
-    paddedWidth = ((width * bpp + FB_MASK) >> FB_SHIFT) * sizeof (FbBits);
+    paddedWidth = ((width * bpp + FB_MASK) >> FB_SHIFT) * sizeof(FbBits);
     buf = malloc(paddedWidth * height);
     if (!buf)
-	return FALSE;
+        return FALSE;
     if (screen->fb.shadow)
-	free(screen->fb.frameBuffer);
+        free(screen->fb.frameBuffer);
     screen->fb.shadow = TRUE;
     screen->fb.frameBuffer = buf;
     screen->fb.byteStride = paddedWidth;
@@ -49,33 +49,32 @@ KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate)
 }
 
 void
-KdShadowFbFree (KdScreenInfo *screen)
+KdShadowFbFree(KdScreenInfo * screen)
 {
-    if (screen->fb.shadow)
-    {
-	free(screen->fb.frameBuffer);
-	screen->fb.frameBuffer = 0;
-	screen->fb.shadow = FALSE;
+    if (screen->fb.shadow) {
+        free(screen->fb.frameBuffer);
+        screen->fb.frameBuffer = 0;
+        screen->fb.shadow = FALSE;
     }
 }
 
 Bool
-KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindowProc window)
+KdShadowSet(ScreenPtr pScreen, int randr, ShadowUpdateProc update,
+            ShadowWindowProc window)
 {
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
 
-    shadowRemove (pScreen, pScreen->GetScreenPixmap(pScreen));
-    if(screen->fb.shadow)
-    {
-	return shadowAdd (pScreen, pScreen->GetScreenPixmap(pScreen),
-			  update, window, randr, 0);
+    shadowRemove(pScreen, pScreen->GetScreenPixmap(pScreen));
+    if (screen->fb.shadow) {
+        return shadowAdd(pScreen, pScreen->GetScreenPixmap(pScreen),
+                         update, window, randr, 0);
     }
     return TRUE;
 }
 
 void
-KdShadowUnset (ScreenPtr pScreen)
+KdShadowUnset(ScreenPtr pScreen)
 {
     shadowRemove(pScreen, pScreen->GetScreenPixmap(pScreen));
 }
diff --git a/hw/kdrive/src/kxv.c b/hw/kdrive/src/kxv.c
index 50dc23529..7097aee5c 100644
--- a/hw/kdrive/src/kxv.c
+++ b/hw/kdrive/src/kxv.c
@@ -56,7 +56,6 @@ of the copyright holder.
 #include "kxv.h"
 #include "fourcc.h"
 
-
 /* XvScreenRec fields */
 
 static Bool KdXVCloseScreen(int, ScreenPtr);
@@ -64,34 +63,32 @@ static int KdXVQueryAdaptors(ScreenPtr, XvAdaptorPtr *, int *);
 
 /* XvAdaptorRec fields */
 
-static int KdXVAllocatePort(unsigned long, XvPortPtr, XvPortPtr*);
+static int KdXVAllocatePort(unsigned long, XvPortPtr, XvPortPtr *);
 static int KdXVFreePort(XvPortPtr);
-static int KdXVPutVideo(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
-static int KdXVPutStill(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
-static int KdXVGetVideo(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
-static int KdXVGetStill(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+static int KdXVPutVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
+static int KdXVPutStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
+static int KdXVGetVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
+static int KdXVGetStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
 static int KdXVStopVideo(ClientPtr, XvPortPtr, DrawablePtr);
 static int KdXVSetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32);
 static int KdXVGetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32 *);
 static int KdXVQueryBestSize(ClientPtr, XvPortPtr, CARD8,
-   				CARD16, CARD16,CARD16, CARD16,
-				unsigned int*, unsigned int*);
+                             CARD16, CARD16, CARD16, CARD16,
+                             unsigned int *, unsigned int *);
 static int KdXVPutImage(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16,
-				XvImagePtr, unsigned char*, Bool,
-				CARD16, CARD16);
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16,
+                        XvImagePtr, unsigned char *, Bool, CARD16, CARD16);
 static int KdXVQueryImageAttributes(ClientPtr, XvPortPtr, XvImagePtr,
-				CARD16*, CARD16*, int*, int*);
-
+                                    CARD16 *, CARD16 *, int *, int *);
 
 /* ScreenRec fields */
 
@@ -101,17 +98,18 @@ static void KdXVWindowExposures(WindowPtr pWin, RegionPtr r1, RegionPtr r2);
 static void KdXVClipNotify(WindowPtr pWin, int dx, int dy);
 
 /* misc */
-static Bool KdXVInitAdaptors(ScreenPtr, KdVideoAdaptorPtr*, int);
+static Bool KdXVInitAdaptors(ScreenPtr, KdVideoAdaptorPtr *, int);
 
 static DevPrivateKeyRec KdXVWindowKeyRec;
+
 #define KdXVWindowKey (&KdXVWindowKeyRec)
 static DevPrivateKey KdXvScreenKey;
 static unsigned long KdXVGeneration = 0;
 static unsigned long PortResource = 0;
 
-DevPrivateKey (*XvGetScreenKeyProc)(void) = XvGetScreenKey;
-unsigned long (*XvGetRTPortProc)(void) = XvGetRTPort;
-int (*XvScreenInitProc)(ScreenPtr) = XvScreenInit;
+DevPrivateKey (*XvGetScreenKeyProc) (void) = XvGetScreenKey;
+unsigned long (*XvGetRTPortProc) (void) = XvGetRTPort;
+int (*XvScreenInitProc) (ScreenPtr) = XvScreenInit;
 
 #define GET_XV_SCREEN(pScreen) ((XvScreenPtr) \
     dixLookupPrivate(&(pScreen)->devPrivates, KdXvScreenKey))
@@ -126,44 +124,41 @@ static KdXVInitGenericAdaptorPtr *GenDrivers = NULL;
 static int NumGenDrivers = 0;
 
 int
-KdXVRegisterGenericAdaptorDriver(
-    KdXVInitGenericAdaptorPtr InitFunc
-){
-  KdXVInitGenericAdaptorPtr *newdrivers;
+KdXVRegisterGenericAdaptorDriver(KdXVInitGenericAdaptorPtr InitFunc)
+{
+    KdXVInitGenericAdaptorPtr *newdrivers;
 
 /*   fprintf(stderr,"KdXVRegisterGenericAdaptorDriver\n"); */
 
-  newdrivers = realloc(GenDrivers, sizeof(KdXVInitGenericAdaptorPtr) *
-			(1 + NumGenDrivers));
-  if (!newdrivers)
-    return 0;
-  GenDrivers = newdrivers;
+    newdrivers = realloc(GenDrivers, sizeof(KdXVInitGenericAdaptorPtr) *
+                         (1 + NumGenDrivers));
+    if (!newdrivers)
+        return 0;
+    GenDrivers = newdrivers;
 
-  GenDrivers[NumGenDrivers++] = InitFunc;
+    GenDrivers[NumGenDrivers++] = InitFunc;
 
-  return 1;
+    return 1;
 }
 
 int
-KdXVListGenericAdaptors(
-    KdScreenInfo *          screen,
-    KdVideoAdaptorPtr **adaptors
-){
-    int i,j,n,num;
-    KdVideoAdaptorPtr *DrivAdap,*new;
+KdXVListGenericAdaptors(KdScreenInfo * screen, KdVideoAdaptorPtr ** adaptors)
+{
+    int i, j, n, num;
+    KdVideoAdaptorPtr *DrivAdap, *new;
 
     num = 0;
     *adaptors = NULL;
     for (i = 0; i < NumGenDrivers; i++) {
-	n = GenDrivers[i](screen,&DrivAdap);
-	if (0 == n)
-	    continue;
-	new = realloc(*adaptors, sizeof(KdVideoAdaptorPtr) * (num+n));
-	if (NULL == new)
-	    continue;
-	*adaptors = new;
-	for (j = 0; j < n; j++, num++)
-	    (*adaptors)[num] = DrivAdap[j];
+        n = GenDrivers[i] (screen, &DrivAdap);
+        if (0 == n)
+            continue;
+        new = realloc(*adaptors, sizeof(KdVideoAdaptorPtr) * (num + n));
+        if (NULL == new)
+            continue;
+        *adaptors = new;
+        for (j = 0; j < n; j++, num++)
+            (*adaptors)[num] = DrivAdap[j];
     }
     return num;
 }
@@ -180,389 +175,379 @@ KdXVFreeVideoAdaptorRec(KdVideoAdaptorPtr ptr)
     free(ptr);
 }
 
-
 Bool
-KdXVScreenInit(
-   ScreenPtr pScreen,
-   KdVideoAdaptorPtr *adaptors,
-   int num
-){
-  KdXVScreenPtr ScreenPriv;
-  XvScreenPtr pxvs;
+KdXVScreenInit(ScreenPtr pScreen, KdVideoAdaptorPtr * adaptors, int num)
+{
+    KdXVScreenPtr ScreenPriv;
+    XvScreenPtr pxvs;
 
 /*   fprintf(stderr,"KdXVScreenInit initializing %d adaptors\n",num); */
 
-  if (KdXVGeneration != serverGeneration)
-      KdXVGeneration = serverGeneration;
-
-  if(!XvGetScreenKeyProc || !XvGetRTPortProc || !XvScreenInitProc)
-	return FALSE;
-
-  if (!dixRegisterPrivateKey(&KdXVWindowKeyRec, PRIVATE_WINDOW, 0))
-      return FALSE;
+    if (KdXVGeneration != serverGeneration)
+        KdXVGeneration = serverGeneration;
 
-  if(Success != (*XvScreenInitProc)(pScreen)) return FALSE;
+    if (!XvGetScreenKeyProc || !XvGetRTPortProc || !XvScreenInitProc)
+        return FALSE;
 
-  KdXvScreenKey = (*XvGetScreenKeyProc)();
-  PortResource = (*XvGetRTPortProc)();
+    if (!dixRegisterPrivateKey(&KdXVWindowKeyRec, PRIVATE_WINDOW, 0))
+        return FALSE;
 
-  pxvs = GET_XV_SCREEN(pScreen);
+    if (Success != (*XvScreenInitProc) (pScreen))
+        return FALSE;
 
+    KdXvScreenKey = (*XvGetScreenKeyProc) ();
+    PortResource = (*XvGetRTPortProc) ();
 
-  /* Anyone initializing the Xv layer must provide these two.
-     The Xv di layer calls them without even checking if they exist! */
+    pxvs = GET_XV_SCREEN(pScreen);
 
-  pxvs->ddCloseScreen = KdXVCloseScreen;
-  pxvs->ddQueryAdaptors = KdXVQueryAdaptors;
+    /* Anyone initializing the Xv layer must provide these two.
+       The Xv di layer calls them without even checking if they exist! */
 
-  /* The Xv di layer provides us with a private hook so that we don't
-     have to allocate our own screen private.  They also provide
-     a CloseScreen hook so that we don't have to wrap it.  I'm not
-     sure that I appreciate that.  */
+    pxvs->ddCloseScreen = KdXVCloseScreen;
+    pxvs->ddQueryAdaptors = KdXVQueryAdaptors;
 
-  ScreenPriv = malloc(sizeof(KdXVScreenRec));
-  pxvs->devPriv.ptr = (pointer)ScreenPriv;
+    /* The Xv di layer provides us with a private hook so that we don't
+       have to allocate our own screen private.  They also provide
+       a CloseScreen hook so that we don't have to wrap it.  I'm not
+       sure that I appreciate that.  */
 
-  if(!ScreenPriv) return FALSE;
+    ScreenPriv = malloc(sizeof(KdXVScreenRec));
+    pxvs->devPriv.ptr = (pointer) ScreenPriv;
 
+    if (!ScreenPriv)
+        return FALSE;
 
-  ScreenPriv->CreateWindow = pScreen->CreateWindow;
-  ScreenPriv->DestroyWindow = pScreen->DestroyWindow;
-  ScreenPriv->WindowExposures = pScreen->WindowExposures;
-  ScreenPriv->ClipNotify = pScreen->ClipNotify;
+    ScreenPriv->CreateWindow = pScreen->CreateWindow;
+    ScreenPriv->DestroyWindow = pScreen->DestroyWindow;
+    ScreenPriv->WindowExposures = pScreen->WindowExposures;
+    ScreenPriv->ClipNotify = pScreen->ClipNotify;
 
 /*   fprintf(stderr,"XV: Wrapping screen funcs\n"); */
 
-  pScreen->CreateWindow = KdXVCreateWindow;
-  pScreen->DestroyWindow = KdXVDestroyWindow;
-  pScreen->WindowExposures = KdXVWindowExposures;
-  pScreen->ClipNotify = KdXVClipNotify;
+    pScreen->CreateWindow = KdXVCreateWindow;
+    pScreen->DestroyWindow = KdXVDestroyWindow;
+    pScreen->WindowExposures = KdXVWindowExposures;
+    pScreen->ClipNotify = KdXVClipNotify;
 
-  if(!KdXVInitAdaptors(pScreen, adaptors, num))
-	return FALSE;
+    if (!KdXVInitAdaptors(pScreen, adaptors, num))
+        return FALSE;
 
-  return TRUE;
+    return TRUE;
 }
 
 static void
 KdXVFreeAdaptor(XvAdaptorPtr pAdaptor)
 {
-   int i;
-
-   free(pAdaptor->name);
+    int i;
 
-   if(pAdaptor->pEncodings) {
-      XvEncodingPtr pEncode = pAdaptor->pEncodings;
+    free(pAdaptor->name);
 
-      for(i = 0; i < pAdaptor->nEncodings; i++, pEncode++) {
-          free(pEncode->name);
-      }
-      free(pAdaptor->pEncodings);
-   }
+    if (pAdaptor->pEncodings) {
+        XvEncodingPtr pEncode = pAdaptor->pEncodings;
 
-   free(pAdaptor->pFormats);
-
-   if(pAdaptor->pPorts) {
-      XvPortPtr pPort = pAdaptor->pPorts;
-      XvPortRecPrivatePtr pPriv;
+        for (i = 0; i < pAdaptor->nEncodings; i++, pEncode++) {
+            free(pEncode->name);
+        }
+        free(pAdaptor->pEncodings);
+    }
 
-      for(i = 0; i < pAdaptor->nPorts; i++, pPort++) {
-          pPriv = (XvPortRecPrivatePtr)pPort->devPriv.ptr;
-	  if(pPriv) {
-	     if(pPriv->clientClip)
-		RegionDestroy(pPriv->clientClip);
-             if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)
-		RegionDestroy(pPriv->pCompositeClip);
-	     free(pPriv);
-	  }
-      }
-      free(pAdaptor->pPorts);
-   }
+    free(pAdaptor->pFormats);
+
+    if (pAdaptor->pPorts) {
+        XvPortPtr pPort = pAdaptor->pPorts;
+        XvPortRecPrivatePtr pPriv;
+
+        for (i = 0; i < pAdaptor->nPorts; i++, pPort++) {
+            pPriv = (XvPortRecPrivatePtr) pPort->devPriv.ptr;
+            if (pPriv) {
+                if (pPriv->clientClip)
+                    RegionDestroy(pPriv->clientClip);
+                if (pPriv->pCompositeClip && pPriv->FreeCompositeClip)
+                    RegionDestroy(pPriv->pCompositeClip);
+                free(pPriv);
+            }
+        }
+        free(pAdaptor->pPorts);
+    }
 
-   if(pAdaptor->nAttributes) {
-      XvAttributePtr pAttribute = pAdaptor->pAttributes;
+    if (pAdaptor->nAttributes) {
+        XvAttributePtr pAttribute = pAdaptor->pAttributes;
 
-      for(i = 0; i < pAdaptor->nAttributes; i++, pAttribute++) {
-          free(pAttribute->name);
-      }
+        for (i = 0; i < pAdaptor->nAttributes; i++, pAttribute++) {
+            free(pAttribute->name);
+        }
 
-      free(pAdaptor->pAttributes);
-   }
+        free(pAdaptor->pAttributes);
+    }
 
-   free(pAdaptor->pImages);
+    free(pAdaptor->pImages);
 
-   free(pAdaptor->devPriv.ptr);
+    free(pAdaptor->devPriv.ptr);
 }
 
 static Bool
-KdXVInitAdaptors(
-   ScreenPtr pScreen,
-   KdVideoAdaptorPtr *infoPtr,
-   int number
-) {
+KdXVInitAdaptors(ScreenPtr pScreen, KdVideoAdaptorPtr * infoPtr, int number)
+{
     KdScreenPriv(pScreen);
-    KdScreenInfo * screen = pScreenPriv->screen;
-
-  XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
-  KdVideoAdaptorPtr adaptorPtr;
-  XvAdaptorPtr pAdaptor, pa;
-  XvAdaptorRecPrivatePtr adaptorPriv;
-  int na, numAdaptor;
-  XvPortRecPrivatePtr portPriv;
-  XvPortPtr pPort, pp;
-  int numPort;
-  KdAttributePtr attributePtr;
-  XvAttributePtr pAttribute, pat;
-  KdVideoFormatPtr formatPtr;
-  XvFormatPtr pFormat, pf;
-  int numFormat, totFormat;
-  KdVideoEncodingPtr encodingPtr;
-  XvEncodingPtr pEncode, pe;
-  KdImagePtr imagePtr;
-  XvImagePtr pImage, pi;
-  int numVisuals;
-  VisualPtr pVisual;
-  int i;
-
-  pxvs->nAdaptors = 0;
-  pxvs->pAdaptors = NULL;
-
-  if(!(pAdaptor = calloc(number, sizeof(XvAdaptorRec))))
-      return FALSE;
-
-  for(pa = pAdaptor, na = 0, numAdaptor = 0; na < number; na++, adaptorPtr++) {
-      adaptorPtr = infoPtr[na];
-
-      if(!adaptorPtr->StopVideo || !adaptorPtr->SetPortAttribute ||
-	 !adaptorPtr->GetPortAttribute || !adaptorPtr->QueryBestSize)
-	   continue;
-
-      /* client libs expect at least one encoding */
-      if(!adaptorPtr->nEncodings || !adaptorPtr->pEncodings)
-	   continue;
-
-      pa->type = adaptorPtr->type;
-
-      if(!adaptorPtr->PutVideo && !adaptorPtr->GetVideo)
-	 pa->type &= ~XvVideoMask;
-
-      if(!adaptorPtr->PutStill && !adaptorPtr->GetStill)
-	 pa->type &= ~XvStillMask;
-
-      if(!adaptorPtr->PutImage || !adaptorPtr->QueryImageAttributes)
-	 pa->type &= ~XvImageMask;
-
-      if(!adaptorPtr->PutVideo && !adaptorPtr->PutImage &&
-							  !adaptorPtr->PutStill)
-	 pa->type &= ~XvInputMask;
-
-      if(!adaptorPtr->GetVideo && !adaptorPtr->GetStill)
-	 pa->type &= ~XvOutputMask;
-
-      if(!(adaptorPtr->type & (XvPixmapMask | XvWindowMask)))
-	  continue;
-      if(!(adaptorPtr->type & (XvImageMask | XvVideoMask | XvStillMask)))
-	  continue;
-
-      pa->pScreen = pScreen;
-      pa->ddAllocatePort = KdXVAllocatePort;
-      pa->ddFreePort = KdXVFreePort;
-      pa->ddPutVideo = KdXVPutVideo;
-      pa->ddPutStill = KdXVPutStill;
-      pa->ddGetVideo = KdXVGetVideo;
-      pa->ddGetStill = KdXVGetStill;
-      pa->ddStopVideo = KdXVStopVideo;
-      pa->ddPutImage = KdXVPutImage;
-      pa->ddSetPortAttribute = KdXVSetPortAttribute;
-      pa->ddGetPortAttribute = KdXVGetPortAttribute;
-      pa->ddQueryBestSize = KdXVQueryBestSize;
-      pa->ddQueryImageAttributes = KdXVQueryImageAttributes;
-      pa->name = strdup(adaptorPtr->name);
-
-      if(adaptorPtr->nEncodings &&
-	(pEncode = calloc(adaptorPtr->nEncodings, sizeof(XvEncodingRec)))) {
-
-	for(pe = pEncode, encodingPtr = adaptorPtr->pEncodings, i = 0;
-	    i < adaptorPtr->nEncodings; pe++, i++, encodingPtr++)
-        {
-	    pe->id = encodingPtr->id;
-	    pe->pScreen = pScreen;
-	    pe->name = strdup(encodingPtr->name);
-	    pe->width = encodingPtr->width;
-	    pe->height = encodingPtr->height;
-	    pe->rate.numerator = encodingPtr->rate.numerator;
-	    pe->rate.denominator = encodingPtr->rate.denominator;
-	}
-	pa->nEncodings = adaptorPtr->nEncodings;
-	pa->pEncodings = pEncode;
-      }
-
-      if(adaptorPtr->nImages &&
-         (pImage = calloc(adaptorPtr->nImages, sizeof(XvImageRec)))) {
-
-          for(i = 0, pi = pImage, imagePtr = adaptorPtr->pImages;
-	      i < adaptorPtr->nImages; i++, pi++, imagePtr++)
-  	  {
-	     pi->id = imagePtr->id;
-	     pi->type = imagePtr->type;
-	     pi->byte_order = imagePtr->byte_order;
-	     memcpy(pi->guid, imagePtr->guid, 16);
-	     pi->bits_per_pixel = imagePtr->bits_per_pixel;
-	     pi->format = imagePtr->format;
-	     pi->num_planes = imagePtr->num_planes;
-	     pi->depth = imagePtr->depth;
-	     pi->red_mask = imagePtr->red_mask;
-	     pi->green_mask = imagePtr->green_mask;
-	     pi->blue_mask = imagePtr->blue_mask;
-	     pi->y_sample_bits = imagePtr->y_sample_bits;
-	     pi->u_sample_bits = imagePtr->u_sample_bits;
-	     pi->v_sample_bits = imagePtr->v_sample_bits;
-	     pi->horz_y_period = imagePtr->horz_y_period;
-	     pi->horz_u_period = imagePtr->horz_u_period;
-	     pi->horz_v_period = imagePtr->horz_v_period;
-	     pi->vert_y_period = imagePtr->vert_y_period;
-	     pi->vert_u_period = imagePtr->vert_u_period;
-	     pi->vert_v_period = imagePtr->vert_v_period;
-	     memcpy(pi->component_order, imagePtr->component_order, 32);
-	     pi->scanline_order = imagePtr->scanline_order;
-          }
-	  pa->nImages = adaptorPtr->nImages;
-	  pa->pImages = pImage;
-      }
-
-      if(adaptorPtr->nAttributes &&
-	(pAttribute = calloc(adaptorPtr->nAttributes, sizeof(XvAttributeRec))))
-      {
-	for(pat = pAttribute, attributePtr = adaptorPtr->pAttributes, i = 0;
-	    i < adaptorPtr->nAttributes; pat++, i++, attributePtr++)
-        {
-	    pat->flags = attributePtr->flags;
-	    pat->min_value = attributePtr->min_value;
-	    pat->max_value = attributePtr->max_value;
-	    pat->name = strdup(attributePtr->name);
-	}
-	pa->nAttributes = adaptorPtr->nAttributes;
-	pa->pAttributes = pAttribute;
-      }
-
-
-      totFormat = adaptorPtr->nFormats;
-
-      if(!(pFormat = calloc(totFormat, sizeof(XvFormatRec)))) {
-          KdXVFreeAdaptor(pa);
-          continue;
-      }
-      for(pf = pFormat, i = 0, numFormat = 0, formatPtr = adaptorPtr->pFormats;
-	  i < adaptorPtr->nFormats; i++, formatPtr++)
-      {
-	  numVisuals = pScreen->numVisuals;
-          pVisual = pScreen->visuals;
-
-          while(numVisuals--) {
-              if((pVisual->class == formatPtr->class) &&
-                 (pVisual->nplanes == formatPtr->depth)) {
-
-		   if(numFormat >= totFormat) {
-			void *moreSpace;
-			totFormat *= 2;
-			moreSpace = realloc(pFormat,
-					     totFormat * sizeof(XvFormatRec));
-			if(!moreSpace) break;
-			pFormat = moreSpace;
-			pf = pFormat + numFormat;
-		   }
-
-                   pf->visual = pVisual->vid;
-		   pf->depth = formatPtr->depth;
-
-		   pf++;
-		   numFormat++;
-              }
-              pVisual++;
-          }
-      }
-      pa->nFormats = numFormat;
-      pa->pFormats = pFormat;
-      if(!numFormat) {
-          KdXVFreeAdaptor(pa);
-          continue;
-      }
-
-      if(!(adaptorPriv = calloc(1, sizeof(XvAdaptorRecPrivate)))) {
-          KdXVFreeAdaptor(pa);
-          continue;
-      }
-
-      adaptorPriv->flags = adaptorPtr->flags;
-      adaptorPriv->PutVideo = adaptorPtr->PutVideo;
-      adaptorPriv->PutStill = adaptorPtr->PutStill;
-      adaptorPriv->GetVideo = adaptorPtr->GetVideo;
-      adaptorPriv->GetStill = adaptorPtr->GetStill;
-      adaptorPriv->StopVideo = adaptorPtr->StopVideo;
-      adaptorPriv->SetPortAttribute = adaptorPtr->SetPortAttribute;
-      adaptorPriv->GetPortAttribute = adaptorPtr->GetPortAttribute;
-      adaptorPriv->QueryBestSize = adaptorPtr->QueryBestSize;
-      adaptorPriv->QueryImageAttributes = adaptorPtr->QueryImageAttributes;
-      adaptorPriv->PutImage = adaptorPtr->PutImage;
-      adaptorPriv->ReputImage = adaptorPtr->ReputImage;
-
-      pa->devPriv.ptr = (pointer)adaptorPriv;
-
-      if(!(pPort = calloc(adaptorPtr->nPorts, sizeof(XvPortRec)))) {
-          KdXVFreeAdaptor(pa);
-          continue;
-      }
-      for(pp = pPort, i = 0, numPort = 0;
-	  i < adaptorPtr->nPorts; i++) {
-
-          if(!(pp->id = FakeClientID(0)))
-		continue;
-
-	  if(!(portPriv = calloc(1, sizeof(XvPortRecPrivate))))
-		continue;
-
-	  if(!AddResource(pp->id, PortResource, pp)) {
-		free(portPriv);
-		continue;
-	  }
-
-          pp->pAdaptor = pa;
-          pp->pNotify = (XvPortNotifyPtr)NULL;
-          pp->pDraw = (DrawablePtr)NULL;
-          pp->client = (ClientPtr)NULL;
-          pp->grab.client = (ClientPtr)NULL;
-          pp->time = currentTime;
-          pp->devPriv.ptr = portPriv;
-
-	  portPriv->screen = screen;
-	  portPriv->AdaptorRec = adaptorPriv;
-          portPriv->DevPriv.ptr = adaptorPtr->pPortPrivates[i].ptr;
-
-          pp++;
-          numPort++;
-      }
-      pa->nPorts = numPort;
-      pa->pPorts = pPort;
-      if(!numPort) {
-          KdXVFreeAdaptor(pa);
-          continue;
-      }
-
-      pa->base_id = pPort->id;
-
-      pa++;
-      numAdaptor++;
-  }
-
-  if(numAdaptor) {
-      pxvs->nAdaptors = numAdaptor;
-      pxvs->pAdaptors = pAdaptor;
-  } else {
-     free(pAdaptor);
-     return FALSE;
-  }
-
-  return TRUE;
+    KdScreenInfo *screen = pScreenPriv->screen;
+
+    XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
+    KdVideoAdaptorPtr adaptorPtr;
+    XvAdaptorPtr pAdaptor, pa;
+    XvAdaptorRecPrivatePtr adaptorPriv;
+    int na, numAdaptor;
+    XvPortRecPrivatePtr portPriv;
+    XvPortPtr pPort, pp;
+    int numPort;
+    KdAttributePtr attributePtr;
+    XvAttributePtr pAttribute, pat;
+    KdVideoFormatPtr formatPtr;
+    XvFormatPtr pFormat, pf;
+    int numFormat, totFormat;
+    KdVideoEncodingPtr encodingPtr;
+    XvEncodingPtr pEncode, pe;
+    KdImagePtr imagePtr;
+    XvImagePtr pImage, pi;
+    int numVisuals;
+    VisualPtr pVisual;
+    int i;
+
+    pxvs->nAdaptors = 0;
+    pxvs->pAdaptors = NULL;
+
+    if (!(pAdaptor = calloc(number, sizeof(XvAdaptorRec))))
+        return FALSE;
+
+    for (pa = pAdaptor, na = 0, numAdaptor = 0; na < number; na++, adaptorPtr++) {
+        adaptorPtr = infoPtr[na];
+
+        if (!adaptorPtr->StopVideo || !adaptorPtr->SetPortAttribute ||
+            !adaptorPtr->GetPortAttribute || !adaptorPtr->QueryBestSize)
+            continue;
+
+        /* client libs expect at least one encoding */
+        if (!adaptorPtr->nEncodings || !adaptorPtr->pEncodings)
+            continue;
+
+        pa->type = adaptorPtr->type;
+
+        if (!adaptorPtr->PutVideo && !adaptorPtr->GetVideo)
+            pa->type &= ~XvVideoMask;
+
+        if (!adaptorPtr->PutStill && !adaptorPtr->GetStill)
+            pa->type &= ~XvStillMask;
+
+        if (!adaptorPtr->PutImage || !adaptorPtr->QueryImageAttributes)
+            pa->type &= ~XvImageMask;
+
+        if (!adaptorPtr->PutVideo && !adaptorPtr->PutImage &&
+            !adaptorPtr->PutStill)
+            pa->type &= ~XvInputMask;
+
+        if (!adaptorPtr->GetVideo && !adaptorPtr->GetStill)
+            pa->type &= ~XvOutputMask;
+
+        if (!(adaptorPtr->type & (XvPixmapMask | XvWindowMask)))
+            continue;
+        if (!(adaptorPtr->type & (XvImageMask | XvVideoMask | XvStillMask)))
+            continue;
+
+        pa->pScreen = pScreen;
+        pa->ddAllocatePort = KdXVAllocatePort;
+        pa->ddFreePort = KdXVFreePort;
+        pa->ddPutVideo = KdXVPutVideo;
+        pa->ddPutStill = KdXVPutStill;
+        pa->ddGetVideo = KdXVGetVideo;
+        pa->ddGetStill = KdXVGetStill;
+        pa->ddStopVideo = KdXVStopVideo;
+        pa->ddPutImage = KdXVPutImage;
+        pa->ddSetPortAttribute = KdXVSetPortAttribute;
+        pa->ddGetPortAttribute = KdXVGetPortAttribute;
+        pa->ddQueryBestSize = KdXVQueryBestSize;
+        pa->ddQueryImageAttributes = KdXVQueryImageAttributes;
+        pa->name = strdup(adaptorPtr->name);
+
+        if (adaptorPtr->nEncodings &&
+            (pEncode = calloc(adaptorPtr->nEncodings, sizeof(XvEncodingRec)))) {
+
+            for (pe = pEncode, encodingPtr = adaptorPtr->pEncodings, i = 0;
+                 i < adaptorPtr->nEncodings; pe++, i++, encodingPtr++) {
+                pe->id = encodingPtr->id;
+                pe->pScreen = pScreen;
+                pe->name = strdup(encodingPtr->name);
+                pe->width = encodingPtr->width;
+                pe->height = encodingPtr->height;
+                pe->rate.numerator = encodingPtr->rate.numerator;
+                pe->rate.denominator = encodingPtr->rate.denominator;
+            }
+            pa->nEncodings = adaptorPtr->nEncodings;
+            pa->pEncodings = pEncode;
+        }
+
+        if (adaptorPtr->nImages &&
+            (pImage = calloc(adaptorPtr->nImages, sizeof(XvImageRec)))) {
+
+            for (i = 0, pi = pImage, imagePtr = adaptorPtr->pImages;
+                 i < adaptorPtr->nImages; i++, pi++, imagePtr++) {
+                pi->id = imagePtr->id;
+                pi->type = imagePtr->type;
+                pi->byte_order = imagePtr->byte_order;
+                memcpy(pi->guid, imagePtr->guid, 16);
+                pi->bits_per_pixel = imagePtr->bits_per_pixel;
+                pi->format = imagePtr->format;
+                pi->num_planes = imagePtr->num_planes;
+                pi->depth = imagePtr->depth;
+                pi->red_mask = imagePtr->red_mask;
+                pi->green_mask = imagePtr->green_mask;
+                pi->blue_mask = imagePtr->blue_mask;
+                pi->y_sample_bits = imagePtr->y_sample_bits;
+                pi->u_sample_bits = imagePtr->u_sample_bits;
+                pi->v_sample_bits = imagePtr->v_sample_bits;
+                pi->horz_y_period = imagePtr->horz_y_period;
+                pi->horz_u_period = imagePtr->horz_u_period;
+                pi->horz_v_period = imagePtr->horz_v_period;
+                pi->vert_y_period = imagePtr->vert_y_period;
+                pi->vert_u_period = imagePtr->vert_u_period;
+                pi->vert_v_period = imagePtr->vert_v_period;
+                memcpy(pi->component_order, imagePtr->component_order, 32);
+                pi->scanline_order = imagePtr->scanline_order;
+            }
+            pa->nImages = adaptorPtr->nImages;
+            pa->pImages = pImage;
+        }
+
+        if (adaptorPtr->nAttributes &&
+            (pAttribute =
+             calloc(adaptorPtr->nAttributes, sizeof(XvAttributeRec)))) {
+            for (pat = pAttribute, attributePtr = adaptorPtr->pAttributes, i =
+                 0; i < adaptorPtr->nAttributes; pat++, i++, attributePtr++) {
+                pat->flags = attributePtr->flags;
+                pat->min_value = attributePtr->min_value;
+                pat->max_value = attributePtr->max_value;
+                pat->name = strdup(attributePtr->name);
+            }
+            pa->nAttributes = adaptorPtr->nAttributes;
+            pa->pAttributes = pAttribute;
+        }
+
+        totFormat = adaptorPtr->nFormats;
+
+        if (!(pFormat = calloc(totFormat, sizeof(XvFormatRec)))) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+        for (pf = pFormat, i = 0, numFormat = 0, formatPtr =
+             adaptorPtr->pFormats; i < adaptorPtr->nFormats; i++, formatPtr++) {
+            numVisuals = pScreen->numVisuals;
+            pVisual = pScreen->visuals;
+
+            while (numVisuals--) {
+                if ((pVisual->class == formatPtr->class) &&
+                    (pVisual->nplanes == formatPtr->depth)) {
+
+                    if (numFormat >= totFormat) {
+                        void *moreSpace;
+
+                        totFormat *= 2;
+                        moreSpace = realloc(pFormat,
+                                            totFormat * sizeof(XvFormatRec));
+                        if (!moreSpace)
+                            break;
+                        pFormat = moreSpace;
+                        pf = pFormat + numFormat;
+                    }
+
+                    pf->visual = pVisual->vid;
+                    pf->depth = formatPtr->depth;
+
+                    pf++;
+                    numFormat++;
+                }
+                pVisual++;
+            }
+        }
+        pa->nFormats = numFormat;
+        pa->pFormats = pFormat;
+        if (!numFormat) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+
+        if (!(adaptorPriv = calloc(1, sizeof(XvAdaptorRecPrivate)))) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+
+        adaptorPriv->flags = adaptorPtr->flags;
+        adaptorPriv->PutVideo = adaptorPtr->PutVideo;
+        adaptorPriv->PutStill = adaptorPtr->PutStill;
+        adaptorPriv->GetVideo = adaptorPtr->GetVideo;
+        adaptorPriv->GetStill = adaptorPtr->GetStill;
+        adaptorPriv->StopVideo = adaptorPtr->StopVideo;
+        adaptorPriv->SetPortAttribute = adaptorPtr->SetPortAttribute;
+        adaptorPriv->GetPortAttribute = adaptorPtr->GetPortAttribute;
+        adaptorPriv->QueryBestSize = adaptorPtr->QueryBestSize;
+        adaptorPriv->QueryImageAttributes = adaptorPtr->QueryImageAttributes;
+        adaptorPriv->PutImage = adaptorPtr->PutImage;
+        adaptorPriv->ReputImage = adaptorPtr->ReputImage;
+
+        pa->devPriv.ptr = (pointer) adaptorPriv;
+
+        if (!(pPort = calloc(adaptorPtr->nPorts, sizeof(XvPortRec)))) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+        for (pp = pPort, i = 0, numPort = 0; i < adaptorPtr->nPorts; i++) {
+
+            if (!(pp->id = FakeClientID(0)))
+                continue;
+
+            if (!(portPriv = calloc(1, sizeof(XvPortRecPrivate))))
+                continue;
+
+            if (!AddResource(pp->id, PortResource, pp)) {
+                free(portPriv);
+                continue;
+            }
+
+            pp->pAdaptor = pa;
+            pp->pNotify = (XvPortNotifyPtr) NULL;
+            pp->pDraw = (DrawablePtr) NULL;
+            pp->client = (ClientPtr) NULL;
+            pp->grab.client = (ClientPtr) NULL;
+            pp->time = currentTime;
+            pp->devPriv.ptr = portPriv;
+
+            portPriv->screen = screen;
+            portPriv->AdaptorRec = adaptorPriv;
+            portPriv->DevPriv.ptr = adaptorPtr->pPortPrivates[i].ptr;
+
+            pp++;
+            numPort++;
+        }
+        pa->nPorts = numPort;
+        pa->pPorts = pPort;
+        if (!numPort) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+
+        pa->base_id = pPort->id;
+
+        pa++;
+        numAdaptor++;
+    }
+
+    if (numAdaptor) {
+        pxvs->nAdaptors = numAdaptor;
+        pxvs->pAdaptors = pAdaptor;
+    }
+    else {
+        free(pAdaptor);
+        return FALSE;
+    }
+
+    return TRUE;
 }
 
 /* Video should be clipped to the intersection of the window cliplist
@@ -584,65 +569,65 @@ KdXVInitAdaptors(
 static void
 KdXVUpdateCompositeClip(XvPortRecPrivatePtr portPriv)
 {
-   RegionPtr	pregWin, pCompositeClip;
-   WindowPtr	pWin;
-   Bool 	freeCompClip = FALSE;
-
-   if(portPriv->pCompositeClip)
-	return;
-
-   pWin = (WindowPtr)portPriv->pDraw;
-
-   /* get window clip list */
-   if(portPriv->subWindowMode == IncludeInferiors) {
-	pregWin = NotClippedByChildren(pWin);
-	freeCompClip = TRUE;
-   } else
-	pregWin = &pWin->clipList;
-
-   if(!portPriv->clientClip) {
-	portPriv->pCompositeClip = pregWin;
-	portPriv->FreeCompositeClip = freeCompClip;
-	return;
-   }
-
-   pCompositeClip = RegionCreate(NullBox, 1);
-   RegionCopy(pCompositeClip, portPriv->clientClip);
-   RegionTranslate(pCompositeClip,
-			portPriv->pDraw->x + portPriv->clipOrg.x,
-			portPriv->pDraw->y + portPriv->clipOrg.y);
-   RegionIntersect(pCompositeClip, pregWin, pCompositeClip);
-
-   portPriv->pCompositeClip = pCompositeClip;
-   portPriv->FreeCompositeClip = TRUE;
-
-   if(freeCompClip) {
-	RegionDestroy(pregWin);
-   }
+    RegionPtr pregWin, pCompositeClip;
+    WindowPtr pWin;
+    Bool freeCompClip = FALSE;
+
+    if (portPriv->pCompositeClip)
+        return;
+
+    pWin = (WindowPtr) portPriv->pDraw;
+
+    /* get window clip list */
+    if (portPriv->subWindowMode == IncludeInferiors) {
+        pregWin = NotClippedByChildren(pWin);
+        freeCompClip = TRUE;
+    }
+    else
+        pregWin = &pWin->clipList;
+
+    if (!portPriv->clientClip) {
+        portPriv->pCompositeClip = pregWin;
+        portPriv->FreeCompositeClip = freeCompClip;
+        return;
+    }
+
+    pCompositeClip = RegionCreate(NullBox, 1);
+    RegionCopy(pCompositeClip, portPriv->clientClip);
+    RegionTranslate(pCompositeClip,
+                    portPriv->pDraw->x + portPriv->clipOrg.x,
+                    portPriv->pDraw->y + portPriv->clipOrg.y);
+    RegionIntersect(pCompositeClip, pregWin, pCompositeClip);
+
+    portPriv->pCompositeClip = pCompositeClip;
+    portPriv->FreeCompositeClip = TRUE;
+
+    if (freeCompClip) {
+        RegionDestroy(pregWin);
+    }
 }
 
 /* Save the current clientClip and update the CompositeClip whenever
    we have a fresh GC */
 
 static void
-KdXVCopyClip(
-   XvPortRecPrivatePtr portPriv,
-   GCPtr pGC
-){
+KdXVCopyClip(XvPortRecPrivatePtr portPriv, GCPtr pGC)
+{
     /* copy the new clip if it exists */
-    if((pGC->clientClipType == CT_REGION) && pGC->clientClip) {
-	if(!portPriv->clientClip)
-	    portPriv->clientClip = RegionCreate(NullBox, 1);
-	/* Note: this is in window coordinates */
-	RegionCopy(portPriv->clientClip, pGC->clientClip);
-    } else if(portPriv->clientClip) { /* free the old clientClip */
-	RegionDestroy(portPriv->clientClip);
-	portPriv->clientClip = NULL;
+    if ((pGC->clientClipType == CT_REGION) && pGC->clientClip) {
+        if (!portPriv->clientClip)
+            portPriv->clientClip = RegionCreate(NullBox, 1);
+        /* Note: this is in window coordinates */
+        RegionCopy(portPriv->clientClip, pGC->clientClip);
+    }
+    else if (portPriv->clientClip) {    /* free the old clientClip */
+        RegionDestroy(portPriv->clientClip);
+        portPriv->clientClip = NULL;
     }
 
     /* get rid of the old clip list */
-    if(portPriv->pCompositeClip && portPriv->FreeCompositeClip) {
-	RegionDestroy(portPriv->pCompositeClip);
+    if (portPriv->pCompositeClip && portPriv->FreeCompositeClip) {
+        RegionDestroy(portPriv->pCompositeClip);
     }
 
     portPriv->clipOrg = pGC->clipOrg;
@@ -654,239 +639,243 @@ KdXVCopyClip(
 static int
 KdXVRegetVideo(XvPortRecPrivatePtr portPriv)
 {
-  RegionRec WinRegion;
-  RegionRec ClipRegion;
-  BoxRec WinBox;
-  int ret = Success;
-  Bool clippedAway = FALSE;
-
-  KdXVUpdateCompositeClip(portPriv);
-
-  /* translate the video region to the screen */
-  WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
-  WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
-  WinBox.x2 = WinBox.x1 + portPriv->drw_w;
-  WinBox.y2 = WinBox.y1 + portPriv->drw_h;
-
-  /* clip to the window composite clip */
-  RegionInit(&WinRegion, &WinBox, 1);
-  RegionInit(&ClipRegion, NullBox, 1);
-  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
-
-  /* that's all if it's totally obscured */
-  if(!RegionNotEmpty(&ClipRegion)) {
-	clippedAway = TRUE;
-	goto CLIP_VIDEO_BAILOUT;
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
-  }
-
-  ret = (*portPriv->AdaptorRec->GetVideo)(portPriv->screen, portPriv->pDraw,
-			portPriv->vid_x, portPriv->vid_y,
-			WinBox.x1, WinBox.y1,
-			portPriv->vid_w, portPriv->vid_h,
-			portPriv->drw_w, portPriv->drw_h,
-			&ClipRegion, portPriv->DevPriv.ptr);
-
-  if(ret == Success)
-	portPriv->isOn = XV_ON;
-
-CLIP_VIDEO_BAILOUT:
-
-  if((clippedAway || (ret != Success)) && portPriv->isOn == XV_ON) {
-	(*portPriv->AdaptorRec->StopVideo)(
-		portPriv->screen, portPriv->DevPriv.ptr, FALSE);
-	portPriv->isOn = XV_PENDING;
-  }
-
-  /* This clip was copied and only good for one shot */
-  if(!portPriv->FreeCompositeClip)
-     portPriv->pCompositeClip = NULL;
-
-  RegionUninit(&WinRegion);
-  RegionUninit(&ClipRegion);
-
-  return ret;
-}
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    KdXVUpdateCompositeClip(portPriv);
+
+    /* translate the video region to the screen */
+    WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
+    WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
+    WinBox.x2 = WinBox.x1 + portPriv->drw_w;
+    WinBox.y2 = WinBox.y1 + portPriv->drw_h;
+
+    /* clip to the window composite clip */
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
+
+    /* that's all if it's totally obscured */
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto CLIP_VIDEO_BAILOUT;
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->GetVideo) (portPriv->screen, portPriv->pDraw,
+                                             portPriv->vid_x, portPriv->vid_y,
+                                             WinBox.x1, WinBox.y1,
+                                             portPriv->vid_w, portPriv->vid_h,
+                                             portPriv->drw_w, portPriv->drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if (ret == Success)
+        portPriv->isOn = XV_ON;
+
+ CLIP_VIDEO_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && portPriv->isOn == XV_ON) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
 
+    /* This clip was copied and only good for one shot */
+    if (!portPriv->FreeCompositeClip)
+        portPriv->pCompositeClip = NULL;
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
 
 static int
 KdXVReputVideo(XvPortRecPrivatePtr portPriv)
 {
-  RegionRec WinRegion;
-  RegionRec ClipRegion;
-  BoxRec WinBox;
-  ScreenPtr pScreen = portPriv->pDraw->pScreen;
-  KdScreenPriv(pScreen);
-  KdScreenInfo *screen=pScreenPriv->screen;
-  int ret = Success;
-  Bool clippedAway = FALSE;
-
-  KdXVUpdateCompositeClip(portPriv);
-
-  /* translate the video region to the screen */
-  WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
-  WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
-  WinBox.x2 = WinBox.x1 + portPriv->drw_w;
-  WinBox.y2 = WinBox.y1 + portPriv->drw_h;
-
-  /* clip to the window composite clip */
-  RegionInit(&WinRegion, &WinBox, 1);
-  RegionInit(&ClipRegion, NullBox, 1);
-  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
-
-  /* clip and translate to the viewport */
-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
-     RegionRec VPReg;
-     BoxRec VPBox;
-
-     VPBox.x1 = 0;
-     VPBox.y1 = 0;
-     VPBox.x2 = screen->width;
-     VPBox.y2 = screen->height;
-
-     RegionInit(&VPReg, &VPBox, 1);
-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
-     RegionUninit(&VPReg);
-  }
-
-  /* that's all if it's totally obscured */
-  if(!RegionNotEmpty(&ClipRegion)) {
-	clippedAway = TRUE;
-	goto CLIP_VIDEO_BAILOUT;
-  }
-
-  /* bailout if we have to clip but the hardware doesn't support it */
-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
-     BoxPtr clipBox = RegionRects(&ClipRegion);
-     if(  (RegionNumRects(&ClipRegion) != 1) ||
-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))
-     {
-	    clippedAway = TRUE;
-	    goto CLIP_VIDEO_BAILOUT;
-     }
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
-  }
-
-  ret = (*portPriv->AdaptorRec->PutVideo)(portPriv->screen, portPriv->pDraw,
-			portPriv->vid_x, portPriv->vid_y,
-			WinBox.x1, WinBox.y1,
-			portPriv->vid_w, portPriv->vid_h,
-			portPriv->drw_w, portPriv->drw_h,
-			&ClipRegion, portPriv->DevPriv.ptr);
-
-  if(ret == Success) portPriv->isOn = XV_ON;
-
-CLIP_VIDEO_BAILOUT:
-
-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
-	(*portPriv->AdaptorRec->StopVideo)(
-		portPriv->screen, portPriv->DevPriv.ptr, FALSE);
-	portPriv->isOn = XV_PENDING;
-  }
-
-  /* This clip was copied and only good for one shot */
-  if(!portPriv->FreeCompositeClip)
-     portPriv->pCompositeClip = NULL;
-
-  RegionUninit(&WinRegion);
-  RegionUninit(&ClipRegion);
-
-  return ret;
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    ScreenPtr pScreen = portPriv->pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    KdXVUpdateCompositeClip(portPriv);
+
+    /* translate the video region to the screen */
+    WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
+    WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
+    WinBox.x2 = WinBox.x1 + portPriv->drw_w;
+    WinBox.y2 = WinBox.y1 + portPriv->drw_h;
+
+    /* clip to the window composite clip */
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
+
+    /* clip and translate to the viewport */
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = screen->width;
+        VPBox.y2 = screen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    /* that's all if it's totally obscured */
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto CLIP_VIDEO_BAILOUT;
+    }
+
+    /* bailout if we have to clip but the hardware doesn't support it */
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto CLIP_VIDEO_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->PutVideo) (portPriv->screen, portPriv->pDraw,
+                                             portPriv->vid_x, portPriv->vid_y,
+                                             WinBox.x1, WinBox.y1,
+                                             portPriv->vid_w, portPriv->vid_h,
+                                             portPriv->drw_w, portPriv->drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if (ret == Success)
+        portPriv->isOn = XV_ON;
+
+ CLIP_VIDEO_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    /* This clip was copied and only good for one shot */
+    if (!portPriv->FreeCompositeClip)
+        portPriv->pCompositeClip = NULL;
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
 }
 
 static int
 KdXVReputImage(XvPortRecPrivatePtr portPriv)
 {
-  RegionRec WinRegion;
-  RegionRec ClipRegion;
-  BoxRec WinBox;
-  ScreenPtr pScreen = portPriv->pDraw->pScreen;
-  KdScreenPriv(pScreen);
-  KdScreenInfo *screen=pScreenPriv->screen;
-  int ret = Success;
-  Bool clippedAway = FALSE;
-
-  KdXVUpdateCompositeClip(portPriv);
-
-  /* translate the video region to the screen */
-  WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
-  WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
-  WinBox.x2 = WinBox.x1 + portPriv->drw_w;
-  WinBox.y2 = WinBox.y1 + portPriv->drw_h;
-
-  /* clip to the window composite clip */
-  RegionInit(&WinRegion, &WinBox, 1);
-  RegionInit(&ClipRegion, NullBox, 1);
-  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
-
-  /* clip and translate to the viewport */
-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
-     RegionRec VPReg;
-     BoxRec VPBox;
-
-     VPBox.x1 = 0;
-     VPBox.y1 = 0;
-     VPBox.x2 = screen->width;
-     VPBox.y2 = screen->height;
-
-     RegionInit(&VPReg, &VPBox, 1);
-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
-     RegionUninit(&VPReg);
-  }
-
-  /* that's all if it's totally obscured */
-  if(!RegionNotEmpty(&ClipRegion)) {
-	clippedAway = TRUE;
-	goto CLIP_VIDEO_BAILOUT;
-  }
-
-  /* bailout if we have to clip but the hardware doesn't support it */
-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
-     BoxPtr clipBox = RegionRects(&ClipRegion);
-     if(  (RegionNumRects(&ClipRegion) != 1) ||
-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))
-     {
-	    clippedAway = TRUE;
-	    goto CLIP_VIDEO_BAILOUT;
-     }
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
-  }
-
-  ret = (*portPriv->AdaptorRec->ReputImage)(portPriv->screen, portPriv->pDraw,
-			WinBox.x1, WinBox.y1,
-			&ClipRegion, portPriv->DevPriv.ptr);
-
-  portPriv->isOn = (ret == Success) ? XV_ON : XV_OFF;
-
-CLIP_VIDEO_BAILOUT:
-
-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
-	(*portPriv->AdaptorRec->StopVideo)(
-		portPriv->screen, portPriv->DevPriv.ptr, FALSE);
-	portPriv->isOn = XV_PENDING;
-  }
-
-  /* This clip was copied and only good for one shot */
-  if(!portPriv->FreeCompositeClip)
-     portPriv->pCompositeClip = NULL;
-
-  RegionUninit(&WinRegion);
-  RegionUninit(&ClipRegion);
-
-  return ret;
-}
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    ScreenPtr pScreen = portPriv->pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    KdXVUpdateCompositeClip(portPriv);
+
+    /* translate the video region to the screen */
+    WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
+    WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
+    WinBox.x2 = WinBox.x1 + portPriv->drw_w;
+    WinBox.y2 = WinBox.y1 + portPriv->drw_h;
+
+    /* clip to the window composite clip */
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
+
+    /* clip and translate to the viewport */
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = screen->width;
+        VPBox.y2 = screen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    /* that's all if it's totally obscured */
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto CLIP_VIDEO_BAILOUT;
+    }
+
+    /* bailout if we have to clip but the hardware doesn't support it */
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto CLIP_VIDEO_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
 
+    ret =
+        (*portPriv->AdaptorRec->ReputImage) (portPriv->screen, portPriv->pDraw,
+                                             WinBox.x1, WinBox.y1, &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    portPriv->isOn = (ret == Success) ? XV_ON : XV_OFF;
+
+ CLIP_VIDEO_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    /* This clip was copied and only good for one shot */
+    if (!portPriv->FreeCompositeClip)
+        portPriv->pCompositeClip = NULL;
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
 
 static int
 KdXVReputAllVideo(WindowPtr pWin, pointer data)
@@ -894,16 +883,16 @@ KdXVReputAllVideo(WindowPtr pWin, pointer data)
     KdXVWindowPtr WinPriv;
 
     if (pWin->drawable.type != DRAWABLE_WINDOW)
-	return WT_DONTWALKCHILDREN;
+        return WT_DONTWALKCHILDREN;
 
     WinPriv = GET_KDXV_WINDOW(pWin);
 
-    while(WinPriv) {
-	if(WinPriv->PortRec->type == XvInputMask)
-	    KdXVReputVideo(WinPriv->PortRec);
-	else
-	    KdXVRegetVideo(WinPriv->PortRec);
-	WinPriv = WinPriv->next;
+    while (WinPriv) {
+        if (WinPriv->PortRec->type == XvInputMask)
+            KdXVReputVideo(WinPriv->PortRec);
+        else
+            KdXVRegetVideo(WinPriv->PortRec);
+        WinPriv = WinPriv->next;
     }
 
     return WT_WALKCHILDREN;
@@ -912,279 +901,273 @@ KdXVReputAllVideo(WindowPtr pWin, pointer data)
 static int
 KdXVEnlistPortInWindow(WindowPtr pWin, XvPortRecPrivatePtr portPriv)
 {
-   KdXVWindowPtr winPriv, PrivRoot;
-
-   winPriv = PrivRoot = GET_KDXV_WINDOW(pWin);
-
-  /* Enlist our port in the window private */
-   while(winPriv) {
-	if(winPriv->PortRec == portPriv) /* we're already listed */
-	    break;
-	winPriv = winPriv->next;
-   }
-
-   if(!winPriv) {
-	winPriv = malloc(sizeof(KdXVWindowRec));
-	if(!winPriv) return BadAlloc;
-	winPriv->PortRec = portPriv;
-	winPriv->next = PrivRoot;
-	dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv);
-   }
-   return Success;
-}
+    KdXVWindowPtr winPriv, PrivRoot;
+
+    winPriv = PrivRoot = GET_KDXV_WINDOW(pWin);
+
+    /* Enlist our port in the window private */
+    while (winPriv) {
+        if (winPriv->PortRec == portPriv)       /* we're already listed */
+            break;
+        winPriv = winPriv->next;
+    }
 
+    if (!winPriv) {
+        winPriv = malloc(sizeof(KdXVWindowRec));
+        if (!winPriv)
+            return BadAlloc;
+        winPriv->PortRec = portPriv;
+        winPriv->next = PrivRoot;
+        dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv);
+    }
+    return Success;
+}
 
 static void
 KdXVRemovePortFromWindow(WindowPtr pWin, XvPortRecPrivatePtr portPriv)
 {
-     KdXVWindowPtr winPriv, prevPriv = NULL;
-
-     winPriv = GET_KDXV_WINDOW(pWin);
-
-     while(winPriv) {
-	if(winPriv->PortRec == portPriv) {
-	    if(prevPriv)
-		prevPriv->next = winPriv->next;
-	    else
-		dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv->next);
-	    free(winPriv);
-	    break;
-	}
-	prevPriv = winPriv;
-	winPriv = winPriv->next;
-     }
-     portPriv->pDraw = NULL;
+    KdXVWindowPtr winPriv, prevPriv = NULL;
+
+    winPriv = GET_KDXV_WINDOW(pWin);
+
+    while (winPriv) {
+        if (winPriv->PortRec == portPriv) {
+            if (prevPriv)
+                prevPriv->next = winPriv->next;
+            else
+                dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv->next);
+            free(winPriv);
+            break;
+        }
+        prevPriv = winPriv;
+        winPriv = winPriv->next;
+    }
+    portPriv->pDraw = NULL;
 }
 
 /****  ScreenRec fields ****/
 
-
 static Bool
 KdXVCreateWindow(WindowPtr pWin)
 {
-  ScreenPtr pScreen = pWin->drawable.pScreen;
-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
-  int ret;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    int ret;
 
-  pScreen->CreateWindow = ScreenPriv->CreateWindow;
-  ret = (*pScreen->CreateWindow)(pWin);
-  pScreen->CreateWindow = KdXVCreateWindow;
+    pScreen->CreateWindow = ScreenPriv->CreateWindow;
+    ret = (*pScreen->CreateWindow) (pWin);
+    pScreen->CreateWindow = KdXVCreateWindow;
 
-  if (ret)
-      dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);
+    if (ret)
+        dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);
 
-  return ret;
+    return ret;
 }
 
-
 static Bool
 KdXVDestroyWindow(WindowPtr pWin)
 {
-  ScreenPtr pScreen = pWin->drawable.pScreen;
-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
-  KdXVWindowPtr tmp, WinPriv = GET_KDXV_WINDOW(pWin);
-  int ret;
-
-  while(WinPriv) {
-     XvPortRecPrivatePtr pPriv = WinPriv->PortRec;
-
-     if(pPriv->isOn > XV_OFF) {
-	(*pPriv->AdaptorRec->StopVideo)(
-			pPriv->screen, pPriv->DevPriv.ptr, TRUE);
-	pPriv->isOn = XV_OFF;
-     }
-
-     pPriv->pDraw = NULL;
-     tmp = WinPriv;
-     WinPriv = WinPriv->next;
-     free(tmp);
-  }
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    KdXVWindowPtr tmp, WinPriv = GET_KDXV_WINDOW(pWin);
+    int ret;
+
+    while (WinPriv) {
+        XvPortRecPrivatePtr pPriv = WinPriv->PortRec;
+
+        if (pPriv->isOn > XV_OFF) {
+            (*pPriv->AdaptorRec->StopVideo) (pPriv->screen, pPriv->DevPriv.ptr,
+                                             TRUE);
+            pPriv->isOn = XV_OFF;
+        }
+
+        pPriv->pDraw = NULL;
+        tmp = WinPriv;
+        WinPriv = WinPriv->next;
+        free(tmp);
+    }
 
-  dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);
+    dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);
 
-  pScreen->DestroyWindow = ScreenPriv->DestroyWindow;
-  ret = (*pScreen->DestroyWindow)(pWin);
-  pScreen->DestroyWindow = KdXVDestroyWindow;
+    pScreen->DestroyWindow = ScreenPriv->DestroyWindow;
+    ret = (*pScreen->DestroyWindow) (pWin);
+    pScreen->DestroyWindow = KdXVDestroyWindow;
 
-  return ret;
+    return ret;
 }
 
-
 static void
 KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
 {
-  ScreenPtr pScreen = pWin->drawable.pScreen;
-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
-  KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);
-  KdXVWindowPtr pPrev;
-  XvPortRecPrivatePtr pPriv;
-  Bool AreasExposed;
-
-  AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));
-
-  pScreen->WindowExposures = ScreenPriv->WindowExposures;
-  (*pScreen->WindowExposures)(pWin, reg1, reg2);
-  pScreen->WindowExposures = KdXVWindowExposures;
-
-  /* filter out XClearWindow/Area */
-  if (!pWin->valdata) return;
-
-  pPrev = NULL;
-
-  while(WinPriv) {
-     pPriv = WinPriv->PortRec;
-
-     /* Reput anyone with a reput function */
-
-     switch(pPriv->type) {
-     case XvInputMask:
-	KdXVReputVideo(pPriv);
-	break;
-     case XvOutputMask:
-	KdXVRegetVideo(pPriv);
-	break;
-     default:  /* overlaid still/image*/
-	if (pPriv->AdaptorRec->ReputImage)
-	   KdXVReputImage(pPriv);
-	else if(AreasExposed) {
-	    KdXVWindowPtr tmp;
-
-	    if (pPriv->isOn == XV_ON) {
-		(*pPriv->AdaptorRec->StopVideo)(
-		    pPriv->screen, pPriv->DevPriv.ptr, FALSE);
-		pPriv->isOn = XV_PENDING;
-	    }
-	    pPriv->pDraw = NULL;
-
-	    if(!pPrev)
-		dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, WinPriv->next);
-	    else
-	       pPrev->next = WinPriv->next;
-	    tmp = WinPriv;
-	    WinPriv = WinPriv->next;
-	    free(tmp);
-	    continue;
-	}
-	break;
-     }
-     pPrev = WinPriv;
-     WinPriv = WinPriv->next;
-  }
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);
+    KdXVWindowPtr pPrev;
+    XvPortRecPrivatePtr pPriv;
+    Bool AreasExposed;
+
+    AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));
+
+    pScreen->WindowExposures = ScreenPriv->WindowExposures;
+    (*pScreen->WindowExposures) (pWin, reg1, reg2);
+    pScreen->WindowExposures = KdXVWindowExposures;
+
+    /* filter out XClearWindow/Area */
+    if (!pWin->valdata)
+        return;
+
+    pPrev = NULL;
+
+    while (WinPriv) {
+        pPriv = WinPriv->PortRec;
+
+        /* Reput anyone with a reput function */
+
+        switch (pPriv->type) {
+        case XvInputMask:
+            KdXVReputVideo(pPriv);
+            break;
+        case XvOutputMask:
+            KdXVRegetVideo(pPriv);
+            break;
+        default:               /* overlaid still/image */
+            if (pPriv->AdaptorRec->ReputImage)
+                KdXVReputImage(pPriv);
+            else if (AreasExposed) {
+                KdXVWindowPtr tmp;
+
+                if (pPriv->isOn == XV_ON) {
+                    (*pPriv->AdaptorRec->StopVideo) (pPriv->screen,
+                                                     pPriv->DevPriv.ptr, FALSE);
+                    pPriv->isOn = XV_PENDING;
+                }
+                pPriv->pDraw = NULL;
+
+                if (!pPrev)
+                    dixSetPrivate(&pWin->devPrivates, KdXVWindowKey,
+                                  WinPriv->next);
+                else
+                    pPrev->next = WinPriv->next;
+                tmp = WinPriv;
+                WinPriv = WinPriv->next;
+                free(tmp);
+                continue;
+            }
+            break;
+        }
+        pPrev = WinPriv;
+        WinPriv = WinPriv->next;
+    }
 }
 
-
 static void
 KdXVClipNotify(WindowPtr pWin, int dx, int dy)
 {
-  ScreenPtr pScreen = pWin->drawable.pScreen;
-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
-  KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);
-  KdXVWindowPtr tmp, pPrev = NULL;
-  XvPortRecPrivatePtr pPriv;
-  Bool visible = (pWin->visibility == VisibilityUnobscured) ||
-		 (pWin->visibility == VisibilityPartiallyObscured);
-
-  while(WinPriv) {
-     pPriv = WinPriv->PortRec;
-
-     if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)
-	RegionDestroy(pPriv->pCompositeClip);
-
-     pPriv->pCompositeClip = NULL;
-
-     /* Stop everything except images, but stop them too if the
-	window isn't visible.  But we only remove the images. */
-
-     if(pPriv->type || !visible) {
-	if(pPriv->isOn == XV_ON) {
-	    (*pPriv->AdaptorRec->StopVideo)(
-			pPriv->screen, pPriv->DevPriv.ptr, FALSE);
-	    pPriv->isOn = XV_PENDING;
-	}
-
-	if(!pPriv->type) {  /* overlaid still/image */
-	    pPriv->pDraw = NULL;
-
-	    if(!pPrev)
-		dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, WinPriv->next);
-	    else
-	       pPrev->next = WinPriv->next;
-	    tmp = WinPriv;
-	    WinPriv = WinPriv->next;
-	    free(tmp);
-	    continue;
-	}
-     }
-
-     pPrev = WinPriv;
-     WinPriv = WinPriv->next;
-  }
-
-  if(ScreenPriv->ClipNotify) {
-      pScreen->ClipNotify = ScreenPriv->ClipNotify;
-      (*pScreen->ClipNotify)(pWin, dx, dy);
-      pScreen->ClipNotify = KdXVClipNotify;
-  }
-}
-
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);
+    KdXVWindowPtr tmp, pPrev = NULL;
+    XvPortRecPrivatePtr pPriv;
+    Bool visible = (pWin->visibility == VisibilityUnobscured) ||
+        (pWin->visibility == VisibilityPartiallyObscured);
+
+    while (WinPriv) {
+        pPriv = WinPriv->PortRec;
+
+        if (pPriv->pCompositeClip && pPriv->FreeCompositeClip)
+            RegionDestroy(pPriv->pCompositeClip);
+
+        pPriv->pCompositeClip = NULL;
+
+        /* Stop everything except images, but stop them too if the
+           window isn't visible.  But we only remove the images. */
+
+        if (pPriv->type || !visible) {
+            if (pPriv->isOn == XV_ON) {
+                (*pPriv->AdaptorRec->StopVideo) (pPriv->screen,
+                                                 pPriv->DevPriv.ptr, FALSE);
+                pPriv->isOn = XV_PENDING;
+            }
+
+            if (!pPriv->type) { /* overlaid still/image */
+                pPriv->pDraw = NULL;
+
+                if (!pPrev)
+                    dixSetPrivate(&pWin->devPrivates, KdXVWindowKey,
+                                  WinPriv->next);
+                else
+                    pPrev->next = WinPriv->next;
+                tmp = WinPriv;
+                WinPriv = WinPriv->next;
+                free(tmp);
+                continue;
+            }
+        }
+
+        pPrev = WinPriv;
+        WinPriv = WinPriv->next;
+    }
 
+    if (ScreenPriv->ClipNotify) {
+        pScreen->ClipNotify = ScreenPriv->ClipNotify;
+        (*pScreen->ClipNotify) (pWin, dx, dy);
+        pScreen->ClipNotify = KdXVClipNotify;
+    }
+}
 
 /**** Required XvScreenRec fields ****/
 
 static Bool
 KdXVCloseScreen(int i, ScreenPtr pScreen)
 {
-  XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
-  XvAdaptorPtr pa;
-  int c;
+    XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    XvAdaptorPtr pa;
+    int c;
 
-  if(!ScreenPriv) return TRUE;
+    if (!ScreenPriv)
+        return TRUE;
 
-  pScreen->CreateWindow = ScreenPriv->CreateWindow;
-  pScreen->DestroyWindow = ScreenPriv->DestroyWindow;
-  pScreen->WindowExposures = ScreenPriv->WindowExposures;
-  pScreen->ClipNotify = ScreenPriv->ClipNotify;
+    pScreen->CreateWindow = ScreenPriv->CreateWindow;
+    pScreen->DestroyWindow = ScreenPriv->DestroyWindow;
+    pScreen->WindowExposures = ScreenPriv->WindowExposures;
+    pScreen->ClipNotify = ScreenPriv->ClipNotify;
 
 /*   fprintf(stderr,"XV: Unwrapping screen funcs\n"); */
 
-  for(c = 0, pa = pxvs->pAdaptors; c < pxvs->nAdaptors; c++, pa++) {
-       KdXVFreeAdaptor(pa);
-  }
+    for (c = 0, pa = pxvs->pAdaptors; c < pxvs->nAdaptors; c++, pa++) {
+        KdXVFreeAdaptor(pa);
+    }
 
-  free(pxvs->pAdaptors);
-  free(ScreenPriv);
+    free(pxvs->pAdaptors);
+    free(ScreenPriv);
 
-  return TRUE;
+    return TRUE;
 }
 
-
 static int
-KdXVQueryAdaptors(
-   ScreenPtr pScreen,
-   XvAdaptorPtr *p_pAdaptors,
-   int *p_nAdaptors
-){
-  XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
+KdXVQueryAdaptors(ScreenPtr pScreen,
+                  XvAdaptorPtr * p_pAdaptors, int *p_nAdaptors)
+{
+    XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
 
-  *p_nAdaptors = pxvs->nAdaptors;
-  *p_pAdaptors = pxvs->pAdaptors;
+    *p_nAdaptors = pxvs->nAdaptors;
+    *p_pAdaptors = pxvs->pAdaptors;
 
-  return Success;
+    return Success;
 }
 
 static Bool
-KdXVRunning (ScreenPtr pScreen)
+KdXVRunning(ScreenPtr pScreen)
 {
-    return (KdXVGeneration == serverGeneration &&
-	    GET_XV_SCREEN(pScreen) != 0);
+    return (KdXVGeneration == serverGeneration && GET_XV_SCREEN(pScreen) != 0);
 }
 
 Bool
 KdXVEnable(ScreenPtr pScreen)
 {
-    if (!KdXVRunning (pScreen))
-	return TRUE;
+    if (!KdXVRunning(pScreen))
+        return TRUE;
 
     WalkTree(pScreen, KdXVReputAllVideo, 0);
 
@@ -1201,556 +1184,557 @@ KdXVDisable(ScreenPtr pScreen)
     XvPortRecPrivatePtr pPriv;
     int i, j;
 
-    if (!KdXVRunning (pScreen))
-	return;
+    if (!KdXVRunning(pScreen))
+        return;
 
     pxvs = GET_XV_SCREEN(pScreen);
     ScreenPriv = GET_KDXV_SCREEN(pScreen);
 
-    for(i = 0; i < pxvs->nAdaptors; i++) {
-	pAdaptor = &pxvs->pAdaptors[i];
-	for(j = 0; j < pAdaptor->nPorts; j++) {
-	    pPort = &pAdaptor->pPorts[j];
-	    pPriv = (XvPortRecPrivatePtr)pPort->devPriv.ptr;
-	    if(pPriv->isOn > XV_OFF) {
+    for (i = 0; i < pxvs->nAdaptors; i++) {
+        pAdaptor = &pxvs->pAdaptors[i];
+        for (j = 0; j < pAdaptor->nPorts; j++) {
+            pPort = &pAdaptor->pPorts[j];
+            pPriv = (XvPortRecPrivatePtr) pPort->devPriv.ptr;
+            if (pPriv->isOn > XV_OFF) {
 
-		(*pPriv->AdaptorRec->StopVideo)(
-			pPriv->screen, pPriv->DevPriv.ptr, TRUE);
-		pPriv->isOn = XV_OFF;
+                (*pPriv->AdaptorRec->StopVideo) (pPriv->screen,
+                                                 pPriv->DevPriv.ptr, TRUE);
+                pPriv->isOn = XV_OFF;
 
-		if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)
-		    RegionDestroy(pPriv->pCompositeClip);
+                if (pPriv->pCompositeClip && pPriv->FreeCompositeClip)
+                    RegionDestroy(pPriv->pCompositeClip);
 
-		pPriv->pCompositeClip = NULL;
+                pPriv->pCompositeClip = NULL;
 
-		if(!pPriv->type && pPriv->pDraw) { /* still */
-		    KdXVRemovePortFromWindow((WindowPtr)pPriv->pDraw, pPriv);
-		}
-	    }
-	}
+                if (!pPriv->type && pPriv->pDraw) {     /* still */
+                    KdXVRemovePortFromWindow((WindowPtr) pPriv->pDraw, pPriv);
+                }
+            }
+        }
     }
 }
 
 /**** XvAdaptorRec fields ****/
 
 static int
-KdXVAllocatePort(
-   unsigned long port,
-   XvPortPtr pPort,
-   XvPortPtr *ppPort
-){
-  *ppPort = pPort;
-  return Success;
+KdXVAllocatePort(unsigned long port, XvPortPtr pPort, XvPortPtr * ppPort)
+{
+    *ppPort = pPort;
+    return Success;
 }
 
 static int
 KdXVFreePort(XvPortPtr pPort)
 {
-  return Success;
+    return Success;
 }
 
 static int
-KdXVPutVideo(
-   ClientPtr client,
-   DrawablePtr pDraw,
-   XvPortPtr pPort,
-   GCPtr pGC,
-   INT16 vid_x, INT16 vid_y,
-   CARD16 vid_w, CARD16 vid_h,
-   INT16 drw_x, INT16 drw_y,
-   CARD16 drw_w, CARD16 drw_h
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-  KdScreenPriv(portPriv->screen->pScreen);
-  int result;
-
-  /* No dumping video to pixmaps... For now anyhow */
-  if(pDraw->type != DRAWABLE_WINDOW) {
-      pPort->pDraw = (DrawablePtr)NULL;
-      return BadAlloc;
-  }
-
-  /* If we are changing windows, unregister our port in the old window */
-  if(portPriv->pDraw && (portPriv->pDraw != pDraw))
-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);
-
-  /* Register our port with the new window */
-  result =  KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);
-  if(result != Success) return result;
-
-  portPriv->pDraw = pDraw;
-  portPriv->type = XvInputMask;
-
-  /* save a copy of these parameters */
-  portPriv->vid_x = vid_x;  portPriv->vid_y = vid_y;
-  portPriv->vid_w = vid_w;  portPriv->vid_h = vid_h;
-  portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;
-  portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;
-
-  /* make sure we have the most recent copy of the clientClip */
-  KdXVCopyClip(portPriv, pGC);
-
-  /* To indicate to the DI layer that we were successful */
-  pPort->pDraw = pDraw;
-
-  if (!pScreenPriv->enabled) return Success;
-
-  return(KdXVReputVideo(portPriv));
+KdXVPutVideo(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    KdScreenPriv(portPriv->screen->pScreen);
+    int result;
+
+    /* No dumping video to pixmaps... For now anyhow */
+    if (pDraw->type != DRAWABLE_WINDOW) {
+        pPort->pDraw = (DrawablePtr) NULL;
+        return BadAlloc;
+    }
+
+    /* If we are changing windows, unregister our port in the old window */
+    if (portPriv->pDraw && (portPriv->pDraw != pDraw))
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+
+    /* Register our port with the new window */
+    result = KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+    if (result != Success)
+        return result;
+
+    portPriv->pDraw = pDraw;
+    portPriv->type = XvInputMask;
+
+    /* save a copy of these parameters */
+    portPriv->vid_x = vid_x;
+    portPriv->vid_y = vid_y;
+    portPriv->vid_w = vid_w;
+    portPriv->vid_h = vid_h;
+    portPriv->drw_x = drw_x;
+    portPriv->drw_y = drw_y;
+    portPriv->drw_w = drw_w;
+    portPriv->drw_h = drw_h;
+
+    /* make sure we have the most recent copy of the clientClip */
+    KdXVCopyClip(portPriv, pGC);
+
+    /* To indicate to the DI layer that we were successful */
+    pPort->pDraw = pDraw;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    return (KdXVReputVideo(portPriv));
 }
 
 static int
-KdXVPutStill(
-   ClientPtr client,
-   DrawablePtr pDraw,
-   XvPortPtr pPort,
-   GCPtr pGC,
-   INT16 vid_x, INT16 vid_y,
-   CARD16 vid_w, CARD16 vid_h,
-   INT16 drw_x, INT16 drw_y,
-   CARD16 drw_w, CARD16 drw_h
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-  ScreenPtr pScreen = pDraw->pScreen;
-  KdScreenPriv(pScreen);
-  KdScreenInfo *screen=pScreenPriv->screen;
-  RegionRec WinRegion;
-  RegionRec ClipRegion;
-  BoxRec WinBox;
-  int ret = Success;
-  Bool clippedAway = FALSE;
-
-  if (pDraw->type != DRAWABLE_WINDOW)
-      return BadAlloc;
-
-  if (!pScreenPriv->enabled) return Success;
-
-  WinBox.x1 = pDraw->x + drw_x;
-  WinBox.y1 = pDraw->y + drw_y;
-  WinBox.x2 = WinBox.x1 + drw_w;
-  WinBox.y2 = WinBox.y1 + drw_h;
-
-  RegionInit(&WinRegion, &WinBox, 1);
-  RegionInit(&ClipRegion, NullBox, 1);
-  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
-
-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
-     RegionRec VPReg;
-     BoxRec VPBox;
-
-     VPBox.x1 = 0;
-     VPBox.y1 = 0;
-     VPBox.x2 = screen->width;
-     VPBox.y2 = screen->height;
-
-     RegionInit(&VPReg, &VPBox, 1);
-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
-     RegionUninit(&VPReg);
-  }
-
-  if(portPriv->pDraw) {
-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);
-  }
-
-  if(!RegionNotEmpty(&ClipRegion)) {
-     clippedAway = TRUE;
-     goto PUT_STILL_BAILOUT;
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
-     BoxPtr clipBox = RegionRects(&ClipRegion);
-     if(  (RegionNumRects(&ClipRegion) != 1) ||
-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))
-     {
-	  clippedAway = TRUE;
-          goto PUT_STILL_BAILOUT;
-     }
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
-  }
-
-  ret = (*portPriv->AdaptorRec->PutStill)(portPriv->screen, pDraw,
-		vid_x, vid_y, WinBox.x1, WinBox.y1,
-		vid_w, vid_h, drw_w, drw_h,
-		&ClipRegion, portPriv->DevPriv.ptr);
-
-  if((ret == Success) &&
-	(portPriv->AdaptorRec->flags & VIDEO_OVERLAID_STILLS)) {
-
-     KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);
-     portPriv->isOn = XV_ON;
-     portPriv->pDraw = pDraw;
-     portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;
-     portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;
-     portPriv->type = 0;  /* no mask means it's transient and should
-			     not be reput once it's removed */
-     pPort->pDraw = pDraw;  /* make sure we can get stop requests */
-  }
-
-PUT_STILL_BAILOUT:
-
-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
-        (*portPriv->AdaptorRec->StopVideo)(
-                portPriv->screen, portPriv->DevPriv.ptr, FALSE);
+KdXVPutStill(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    ScreenPtr pScreen = pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    WinBox.x1 = pDraw->x + drw_x;
+    WinBox.y1 = pDraw->y + drw_y;
+    WinBox.x2 = WinBox.x1 + drw_w;
+    WinBox.y2 = WinBox.y1 + drw_h;
+
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
+
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = screen->width;
+        VPBox.y2 = screen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    if (portPriv->pDraw) {
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+    }
+
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto PUT_STILL_BAILOUT;
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto PUT_STILL_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->PutStill) (portPriv->screen, pDraw,
+                                             vid_x, vid_y, WinBox.x1, WinBox.y1,
+                                             vid_w, vid_h, drw_w, drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if ((ret == Success) &&
+        (portPriv->AdaptorRec->flags & VIDEO_OVERLAID_STILLS)) {
+
+        KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+        portPriv->isOn = XV_ON;
+        portPriv->pDraw = pDraw;
+        portPriv->drw_x = drw_x;
+        portPriv->drw_y = drw_y;
+        portPriv->drw_w = drw_w;
+        portPriv->drw_h = drw_h;
+        portPriv->type = 0;     /* no mask means it's transient and should
+                                   not be reput once it's removed */
+        pPort->pDraw = pDraw;   /* make sure we can get stop requests */
+    }
+
+ PUT_STILL_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
         portPriv->isOn = XV_PENDING;
-  }
+    }
 
-  RegionUninit(&WinRegion);
-  RegionUninit(&ClipRegion);
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
 
-  return ret;
+    return ret;
 }
 
 static int
-KdXVGetVideo(
-   ClientPtr client,
-   DrawablePtr pDraw,
-   XvPortPtr pPort,
-   GCPtr pGC,
-   INT16 vid_x, INT16 vid_y,
-   CARD16 vid_w, CARD16 vid_h,
-   INT16 drw_x, INT16 drw_y,
-   CARD16 drw_w, CARD16 drw_h
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-  int result;
-  KdScreenPriv(portPriv->screen->pScreen);
-
-  /* No pixmaps... For now anyhow */
-  if(pDraw->type != DRAWABLE_WINDOW) {
-      pPort->pDraw = (DrawablePtr)NULL;
-      return BadAlloc;
-  }
-
-  /* If we are changing windows, unregister our port in the old window */
-  if(portPriv->pDraw && (portPriv->pDraw != pDraw))
-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);
-
-  /* Register our port with the new window */
-  result =  KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);
-  if(result != Success) return result;
-
-  portPriv->pDraw = pDraw;
-  portPriv->type = XvOutputMask;
-
-  /* save a copy of these parameters */
-  portPriv->vid_x = vid_x;  portPriv->vid_y = vid_y;
-  portPriv->vid_w = vid_w;  portPriv->vid_h = vid_h;
-  portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;
-  portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;
-
-  /* make sure we have the most recent copy of the clientClip */
-  KdXVCopyClip(portPriv, pGC);
-
-  /* To indicate to the DI layer that we were successful */
-  pPort->pDraw = pDraw;
-
-  if(!pScreenPriv->enabled) return Success;
-
-  return(KdXVRegetVideo(portPriv));
+KdXVGetVideo(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    int result;
+
+    KdScreenPriv(portPriv->screen->pScreen);
+
+    /* No pixmaps... For now anyhow */
+    if (pDraw->type != DRAWABLE_WINDOW) {
+        pPort->pDraw = (DrawablePtr) NULL;
+        return BadAlloc;
+    }
+
+    /* If we are changing windows, unregister our port in the old window */
+    if (portPriv->pDraw && (portPriv->pDraw != pDraw))
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+
+    /* Register our port with the new window */
+    result = KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+    if (result != Success)
+        return result;
+
+    portPriv->pDraw = pDraw;
+    portPriv->type = XvOutputMask;
+
+    /* save a copy of these parameters */
+    portPriv->vid_x = vid_x;
+    portPriv->vid_y = vid_y;
+    portPriv->vid_w = vid_w;
+    portPriv->vid_h = vid_h;
+    portPriv->drw_x = drw_x;
+    portPriv->drw_y = drw_y;
+    portPriv->drw_w = drw_w;
+    portPriv->drw_h = drw_h;
+
+    /* make sure we have the most recent copy of the clientClip */
+    KdXVCopyClip(portPriv, pGC);
+
+    /* To indicate to the DI layer that we were successful */
+    pPort->pDraw = pDraw;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    return (KdXVRegetVideo(portPriv));
 }
 
 static int
-KdXVGetStill(
-   ClientPtr client,
-   DrawablePtr pDraw,
-   XvPortPtr pPort,
-   GCPtr pGC,
-   INT16 vid_x, INT16 vid_y,
-   CARD16 vid_w, CARD16 vid_h,
-   INT16 drw_x, INT16 drw_y,
-   CARD16 drw_w, CARD16 drw_h
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-  ScreenPtr pScreen = pDraw->pScreen;
-  KdScreenPriv(pScreen);
-  RegionRec WinRegion;
-  RegionRec ClipRegion;
-  BoxRec WinBox;
-  int ret = Success;
-  Bool clippedAway = FALSE;
-
-  if (pDraw->type != DRAWABLE_WINDOW)
-      return BadAlloc;
-
-  if(!pScreenPriv->enabled) return Success;
-
-  WinBox.x1 = pDraw->x + drw_x;
-  WinBox.y1 = pDraw->y + drw_y;
-  WinBox.x2 = WinBox.x1 + drw_w;
-  WinBox.y2 = WinBox.y1 + drw_h;
-
-  RegionInit(&WinRegion, &WinBox, 1);
-  RegionInit(&ClipRegion, NullBox, 1);
-  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
-
-  if(portPriv->pDraw) {
-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);
-  }
-
-  if(!RegionNotEmpty(&ClipRegion)) {
-     clippedAway = TRUE;
-     goto GET_STILL_BAILOUT;
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
-  }
-
-  ret = (*portPriv->AdaptorRec->GetStill)(portPriv->screen, pDraw,
-		vid_x, vid_y, WinBox.x1, WinBox.y1,
-		vid_w, vid_h, drw_w, drw_h,
-		&ClipRegion, portPriv->DevPriv.ptr);
-
-GET_STILL_BAILOUT:
-
-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
-        (*portPriv->AdaptorRec->StopVideo)(
-                portPriv->screen, portPriv->DevPriv.ptr, FALSE);
-        portPriv->isOn = XV_PENDING;
-  }
+KdXVGetStill(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    ScreenPtr pScreen = pDraw->pScreen;
 
-  RegionUninit(&WinRegion);
-  RegionUninit(&ClipRegion);
+    KdScreenPriv(pScreen);
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
 
-  return ret;
-}
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
 
+    if (!pScreenPriv->enabled)
+        return Success;
 
+    WinBox.x1 = pDraw->x + drw_x;
+    WinBox.y1 = pDraw->y + drw_y;
+    WinBox.x2 = WinBox.x1 + drw_w;
+    WinBox.y2 = WinBox.y1 + drw_h;
 
-static int
-KdXVStopVideo(
-   ClientPtr client,
-   XvPortPtr pPort,
-   DrawablePtr pDraw
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-  KdScreenPriv(portPriv->screen->pScreen);
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
+
+    if (portPriv->pDraw) {
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+    }
 
-  if(pDraw->type != DRAWABLE_WINDOW)
-      return BadAlloc;
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto GET_STILL_BAILOUT;
+    }
 
-  KdXVRemovePortFromWindow((WindowPtr)pDraw, portPriv);
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
 
-  if(!pScreenPriv->enabled) return Success;
+    ret = (*portPriv->AdaptorRec->GetStill) (portPriv->screen, pDraw,
+                                             vid_x, vid_y, WinBox.x1, WinBox.y1,
+                                             vid_w, vid_h, drw_w, drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
 
-  /* Must free resources. */
+ GET_STILL_BAILOUT:
 
-  if(portPriv->isOn > XV_OFF) {
-	(*portPriv->AdaptorRec->StopVideo)(
-		portPriv->screen, portPriv->DevPriv.ptr, TRUE);
-	portPriv->isOn = XV_OFF;
-  }
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
 
-  return Success;
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
 }
 
 static int
-KdXVSetPortAttribute(
-   ClientPtr client,
-   XvPortPtr pPort,
-   Atom attribute,
-   INT32 value
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-
-  return((*portPriv->AdaptorRec->SetPortAttribute)(portPriv->screen,
-		attribute, value, portPriv->DevPriv.ptr));
-}
+KdXVStopVideo(ClientPtr client, XvPortPtr pPort, DrawablePtr pDraw)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
 
+    KdScreenPriv(portPriv->screen->pScreen);
 
-static int
-KdXVGetPortAttribute(
-   ClientPtr client,
-   XvPortPtr pPort,
-   Atom attribute,
-   INT32 *p_value
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-
-  return((*portPriv->AdaptorRec->GetPortAttribute)(portPriv->screen,
-		attribute, (int *) p_value, portPriv->DevPriv.ptr));
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
+
+    KdXVRemovePortFromWindow((WindowPtr) pDraw, portPriv);
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    /* Must free resources. */
+
+    if (portPriv->isOn > XV_OFF) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, TRUE);
+        portPriv->isOn = XV_OFF;
+    }
+
+    return Success;
 }
 
+static int
+KdXVSetPortAttribute(ClientPtr client,
+                     XvPortPtr pPort, Atom attribute, INT32 value)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
 
+    return ((*portPriv->AdaptorRec->SetPortAttribute) (portPriv->screen,
+                                                       attribute, value,
+                                                       portPriv->DevPriv.ptr));
+}
 
 static int
-KdXVQueryBestSize(
-   ClientPtr client,
-   XvPortPtr pPort,
-   CARD8 motion,
-   CARD16 vid_w, CARD16 vid_h,
-   CARD16 drw_w, CARD16 drw_h,
-   unsigned int *p_w, unsigned int *p_h
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-
-  (*portPriv->AdaptorRec->QueryBestSize)(portPriv->screen,
-		(Bool)motion, vid_w, vid_h, drw_w, drw_h,
-		p_w, p_h, portPriv->DevPriv.ptr);
-
-  return Success;
+KdXVGetPortAttribute(ClientPtr client,
+                     XvPortPtr pPort, Atom attribute, INT32 *p_value)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    return ((*portPriv->AdaptorRec->GetPortAttribute) (portPriv->screen,
+                                                       attribute,
+                                                       (int *) p_value,
+                                                       portPriv->DevPriv.ptr));
 }
 
+static int
+KdXVQueryBestSize(ClientPtr client,
+                  XvPortPtr pPort,
+                  CARD8 motion,
+                  CARD16 vid_w, CARD16 vid_h,
+                  CARD16 drw_w, CARD16 drw_h,
+                  unsigned int *p_w, unsigned int *p_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    (*portPriv->AdaptorRec->QueryBestSize) (portPriv->screen,
+                                            (Bool) motion, vid_w, vid_h, drw_w,
+                                            drw_h, p_w, p_h,
+                                            portPriv->DevPriv.ptr);
+
+    return Success;
+}
 
 static int
-KdXVPutImage(
-   ClientPtr client,
-   DrawablePtr pDraw,
-   XvPortPtr pPort,
-   GCPtr pGC,
-   INT16 src_x, INT16 src_y,
-   CARD16 src_w, CARD16 src_h,
-   INT16 drw_x, INT16 drw_y,
-   CARD16 drw_w, CARD16 drw_h,
-   XvImagePtr format,
-   unsigned char* data,
-   Bool sync,
-   CARD16 width, CARD16 height
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-  ScreenPtr pScreen = pDraw->pScreen;
-  KdScreenPriv(pScreen);
-  RegionRec WinRegion;
-  RegionRec ClipRegion;
-  BoxRec WinBox;
-  int ret = Success;
-  Bool clippedAway = FALSE;
-
-  if (pDraw->type != DRAWABLE_WINDOW)
-      return BadAlloc;
-
-  if(!pScreenPriv->enabled) return Success;
-
-  WinBox.x1 = pDraw->x + drw_x;
-  WinBox.y1 = pDraw->y + drw_y;
-  WinBox.x2 = WinBox.x1 + drw_w;
-  WinBox.y2 = WinBox.y1 + drw_h;
-
-  RegionInit(&WinRegion, &WinBox, 1);
-  RegionInit(&ClipRegion, NullBox, 1);
-  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
-
-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
-     RegionRec VPReg;
-     BoxRec VPBox;
-
-     VPBox.x1 = 0;
-     VPBox.y1 = 0;
-     VPBox.x2 = pScreen->width;
-     VPBox.y2 = pScreen->height;
-
-     RegionInit(&VPReg, &VPBox, 1);
-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
-     RegionUninit(&VPReg);
-  }
-
-  if(portPriv->pDraw) {
-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);
-  }
-
-  if(!RegionNotEmpty(&ClipRegion)) {
-     clippedAway = TRUE;
-     goto PUT_IMAGE_BAILOUT;
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
-     BoxPtr clipBox = RegionRects(&ClipRegion);
-     if(  (RegionNumRects(&ClipRegion) != 1) ||
-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))
-     {
-	  clippedAway = TRUE;
-          goto PUT_IMAGE_BAILOUT;
-     }
-  }
-
-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
-  }
-
-  ret = (*portPriv->AdaptorRec->PutImage)(portPriv->screen, pDraw,
-		src_x, src_y, WinBox.x1, WinBox.y1,
-		src_w, src_h, drw_w, drw_h, format->id, data, width, height,
-		sync, &ClipRegion, portPriv->DevPriv.ptr);
-
-  if((ret == Success) &&
-	(portPriv->AdaptorRec->flags & VIDEO_OVERLAID_IMAGES)) {
-
-     KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);
-     portPriv->isOn = XV_ON;
-     portPriv->pDraw = pDraw;
-     portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;
-     portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;
-     portPriv->type = 0;  /* no mask means it's transient and should
-			     not be reput once it's removed */
-     pPort->pDraw = pDraw;  /* make sure we can get stop requests */
-  }
-
-PUT_IMAGE_BAILOUT:
-
-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
-        (*portPriv->AdaptorRec->StopVideo)(
-                portPriv->screen, portPriv->DevPriv.ptr, FALSE);
+KdXVPutImage(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 src_x, INT16 src_y,
+             CARD16 src_w, CARD16 src_h,
+             INT16 drw_x, INT16 drw_y,
+             CARD16 drw_w, CARD16 drw_h,
+             XvImagePtr format,
+             unsigned char *data, Bool sync, CARD16 width, CARD16 height)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    ScreenPtr pScreen = pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    WinBox.x1 = pDraw->x + drw_x;
+    WinBox.y1 = pDraw->y + drw_y;
+    WinBox.x2 = WinBox.x1 + drw_w;
+    WinBox.y2 = WinBox.y1 + drw_h;
+
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
+
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = pScreen->width;
+        VPBox.y2 = pScreen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    if (portPriv->pDraw) {
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+    }
+
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto PUT_IMAGE_BAILOUT;
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto PUT_IMAGE_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->PutImage) (portPriv->screen, pDraw,
+                                             src_x, src_y, WinBox.x1, WinBox.y1,
+                                             src_w, src_h, drw_w, drw_h,
+                                             format->id, data, width, height,
+                                             sync, &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if ((ret == Success) &&
+        (portPriv->AdaptorRec->flags & VIDEO_OVERLAID_IMAGES)) {
+
+        KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+        portPriv->isOn = XV_ON;
+        portPriv->pDraw = pDraw;
+        portPriv->drw_x = drw_x;
+        portPriv->drw_y = drw_y;
+        portPriv->drw_w = drw_w;
+        portPriv->drw_h = drw_h;
+        portPriv->type = 0;     /* no mask means it's transient and should
+                                   not be reput once it's removed */
+        pPort->pDraw = pDraw;   /* make sure we can get stop requests */
+    }
+
+ PUT_IMAGE_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
         portPriv->isOn = XV_PENDING;
-  }
+    }
 
-  RegionUninit(&WinRegion);
-  RegionUninit(&ClipRegion);
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
 
-  return ret;
+    return ret;
 }
 
+static int
+KdXVQueryImageAttributes(ClientPtr client,
+                         XvPortPtr pPort,
+                         XvImagePtr format,
+                         CARD16 *width,
+                         CARD16 *height, int *pitches, int *offsets)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
 
-static  int
-KdXVQueryImageAttributes(
-   ClientPtr client,
-   XvPortPtr pPort,
-   XvImagePtr format,
-   CARD16 *width,
-   CARD16 *height,
-   int *pitches,
-   int *offsets
-){
-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);
-
-  return (*portPriv->AdaptorRec->QueryImageAttributes)(portPriv->screen,
-			format->id, width, height, pitches, offsets);
+    return (*portPriv->AdaptorRec->QueryImageAttributes) (portPriv->screen,
+                                                          format->id, width,
+                                                          height, pitches,
+                                                          offsets);
 }
 
-
 /****************  Common video manipulation functions *******************/
 
 void
-KdXVCopyPackedData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
-    int srcPitch, int dstPitch, int srcW, int srcH, int top, int left,
-    int h, int w)
+KdXVCopyPackedData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int dstPitch, int srcW, int srcH, int top,
+                   int left, int h, int w)
 {
     int srcDown = srcPitch, srcRight = 2, srcNext;
     int p;
 
     switch (randr & RR_Rotate_All) {
     case RR_Rotate_0:
-	srcDown = srcPitch;
-	srcRight = 2;
-	break;
+        srcDown = srcPitch;
+        srcRight = 2;
+        break;
     case RR_Rotate_90:
-	src += (srcH - 1) * 2;
-	srcDown = -2;
-	srcRight = srcPitch;
-	break;
+        src += (srcH - 1) * 2;
+        srcDown = -2;
+        srcRight = srcPitch;
+        break;
     case RR_Rotate_180:
-	src += srcPitch * (srcH - 1) + (srcW - 1) * 2;
-	srcDown = -srcPitch;
-	srcRight = -2;
-	break;
+        src += srcPitch * (srcH - 1) + (srcW - 1) * 2;
+        srcDown = -srcPitch;
+        srcRight = -2;
+        break;
     case RR_Rotate_270:
-	src += srcPitch * (srcW - 1);
-	srcDown = 2;
-	srcRight = -srcPitch;
-	break;
+        src += srcPitch * (srcW - 1);
+        srcDown = 2;
+        srcRight = -srcPitch;
+        break;
     }
 
     src = src + top * srcDown + left * srcRight;
@@ -1759,22 +1743,24 @@ KdXVCopyPackedData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
     /* srcRight >>= 1; */
     srcNext = srcRight >> 1;
     while (h--) {
-	CARD16 *s = (CARD16 *)src;
-	CARD32 *d = (CARD32 *)dst;
-	p = w;
-	while (p--) {
-	    *d++ = s[0] | (s[srcNext] << 16);
-	    s += srcRight;
-	}
-	src += srcPitch;
-	dst += dstPitch;
+        CARD16 *s = (CARD16 *) src;
+        CARD32 *d = (CARD32 *) dst;
+
+        p = w;
+        while (p--) {
+            *d++ = s[0] | (s[srcNext] << 16);
+            s += srcRight;
+        }
+        src += srcPitch;
+        dst += dstPitch;
     }
 }
 
 void
-KdXVCopyPlanarData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
-    int srcPitch, int srcPitch2, int dstPitch, int srcW, int srcH, int height,
-    int top, int left, int h, int w, int id)
+KdXVCopyPlanarData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int srcPitch2, int dstPitch, int srcW,
+                   int srcH, int height, int top, int left, int h, int w,
+                   int id)
 {
     int i, j;
     CARD8 *src1, *src2, *src3, *dst1;
@@ -1787,42 +1773,42 @@ KdXVCopyPlanarData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
     src3 = src2 + (height >> 1) * srcPitch2;
     switch (randr & RR_Rotate_All) {
     case RR_Rotate_0:
-	srcDown = srcPitch;
-	srcDown2 = srcPitch2;
-	srcRight = 2;
-	srcRight2 = 1;
-	srcNext = 1;
-	break;
+        srcDown = srcPitch;
+        srcDown2 = srcPitch2;
+        srcRight = 2;
+        srcRight2 = 1;
+        srcNext = 1;
+        break;
     case RR_Rotate_90:
-	src1 = src1 + srcH - 1;
-	src2 = src2 + (srcH >> 1) - 1;
-	src3 = src3 + (srcH >> 1) - 1;
-	srcDown = -1;
-	srcDown2 = -1;
-	srcRight = srcPitch * 2;
-	srcRight2 = srcPitch2;
-	srcNext = srcPitch;
-	break;
+        src1 = src1 + srcH - 1;
+        src2 = src2 + (srcH >> 1) - 1;
+        src3 = src3 + (srcH >> 1) - 1;
+        srcDown = -1;
+        srcDown2 = -1;
+        srcRight = srcPitch * 2;
+        srcRight2 = srcPitch2;
+        srcNext = srcPitch;
+        break;
     case RR_Rotate_180:
-	src1 = src1 + srcPitch * (srcH - 1) + (srcW - 1);
-	src2 = src2 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);
-	src3 = src3 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);
-	srcDown = -srcPitch;
-	srcDown2 = -srcPitch2;
-	srcRight = -2;
-	srcRight2 = -1;
-	srcNext = -1;
-	break;
+        src1 = src1 + srcPitch * (srcH - 1) + (srcW - 1);
+        src2 = src2 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);
+        src3 = src3 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);
+        srcDown = -srcPitch;
+        srcDown2 = -srcPitch2;
+        srcRight = -2;
+        srcRight2 = -1;
+        srcNext = -1;
+        break;
     case RR_Rotate_270:
-	src1 = src1 + srcPitch * (srcW - 1);
-	src2 = src2 + srcPitch2 * ((srcW >> 1) - 1);
-	src3 = src3 + srcPitch2 * ((srcW >> 1) - 1);
-	srcDown = 1;
-	srcDown2 = 1;
-	srcRight = -srcPitch * 2;
-	srcRight2 = -srcPitch2;
-	srcNext = -srcPitch;
-	break;
+        src1 = src1 + srcPitch * (srcW - 1);
+        src2 = src2 + srcPitch2 * ((srcW >> 1) - 1);
+        src3 = src3 + srcPitch2 * ((srcW >> 1) - 1);
+        srcDown = 1;
+        srcDown2 = 1;
+        srcRight = -srcPitch * 2;
+        srcRight2 = -srcPitch2;
+        srcNext = -srcPitch;
+        break;
     }
 
     /* adjust for origin */
@@ -1831,76 +1817,75 @@ KdXVCopyPlanarData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
     src3 += (top >> 1) * srcDown2 + (left >> 1) * srcRight2;
 
     if (id == FOURCC_I420) {
-	CARD8 *srct = src2;
-	src2 = src3;
-	src3 = srct;
+        CARD8 *srct = src2;
+
+        src2 = src3;
+        src3 = srct;
     }
 
     dst1 = dst;
 
     w >>= 1;
     for (j = 0; j < h; j++) {
-	CARD32 *dst = (CARD32 *)dst1;
-	CARD8 *s1l = src1;
-	CARD8 *s1r = src1 + srcNext;
-	CARD8 *s2 = src2;
-	CARD8 *s3 = src3;
-
-	for (i = 0; i < w; i++) {
-	    *dst++ = *s1l | (*s1r << 16) | (*s3 << 8) | (*s2 << 24);
-	    s1l += srcRight;
-	    s1r += srcRight;
-	    s2 += srcRight2;
-	    s3 += srcRight2;
-	}
-	src1 += srcDown;
-	dst1 += dstPitch;
-	if (j & 1) {
-	    src2 += srcDown2;
-	    src3 += srcDown2;
-	}
+        CARD32 *dst = (CARD32 *) dst1;
+        CARD8 *s1l = src1;
+        CARD8 *s1r = src1 + srcNext;
+        CARD8 *s2 = src2;
+        CARD8 *s3 = src3;
+
+        for (i = 0; i < w; i++) {
+            *dst++ = *s1l | (*s1r << 16) | (*s3 << 8) | (*s2 << 24);
+            s1l += srcRight;
+            s1r += srcRight;
+            s2 += srcRight2;
+            s3 += srcRight2;
+        }
+        src1 += srcDown;
+        dst1 += dstPitch;
+        if (j & 1) {
+            src2 += srcDown2;
+            src3 += srcDown2;
+        }
     }
 }
 
 void
-KXVPaintRegion (DrawablePtr pDraw, RegionPtr pRgn, Pixel fg)
+KXVPaintRegion(DrawablePtr pDraw, RegionPtr pRgn, Pixel fg)
 {
-    GCPtr	pGC;
-    ChangeGCVal	val[2];
-    xRectangle	*rects, *r;
-    BoxPtr	pBox = RegionRects (pRgn);
-    int		nBox = RegionNumRects (pRgn);
+    GCPtr pGC;
+    ChangeGCVal val[2];
+    xRectangle *rects, *r;
+    BoxPtr pBox = RegionRects(pRgn);
+    int nBox = RegionNumRects(pRgn);
 
-    rects = malloc(nBox * sizeof (xRectangle));
+    rects = malloc(nBox * sizeof(xRectangle));
     if (!rects)
-	goto bail0;
+        goto bail0;
     r = rects;
-    while (nBox--)
-    {
-	r->x = pBox->x1 - pDraw->x;
-	r->y = pBox->y1 - pDraw->y;
-	r->width = pBox->x2 - pBox->x1;
-	r->height = pBox->y2 - pBox->y1;
-	r++;
-	pBox++;
+    while (nBox--) {
+        r->x = pBox->x1 - pDraw->x;
+        r->y = pBox->y1 - pDraw->y;
+        r->width = pBox->x2 - pBox->x1;
+        r->height = pBox->y2 - pBox->y1;
+        r++;
+        pBox++;
     }
 
-    pGC = GetScratchGC (pDraw->depth, pDraw->pScreen);
+    pGC = GetScratchGC(pDraw->depth, pDraw->pScreen);
     if (!pGC)
-	goto bail1;
+        goto bail1;
 
     val[0].val = fg;
     val[1].val = IncludeInferiors;
-    ChangeGC (NullClient, pGC, GCForeground|GCSubwindowMode, val);
+    ChangeGC(NullClient, pGC, GCForeground | GCSubwindowMode, val);
 
-    ValidateGC (pDraw, pGC);
+    ValidateGC(pDraw, pGC);
 
-    (*pGC->ops->PolyFillRect) (pDraw, pGC,
-			       RegionNumRects (pRgn), rects);
+    (*pGC->ops->PolyFillRect) (pDraw, pGC, RegionNumRects(pRgn), rects);
 
-    FreeScratchGC (pGC);
-bail1:
+    FreeScratchGC(pGC);
+ bail1:
     free(rects);
-bail0:
+ bail0:
     ;
 }
diff --git a/hw/kdrive/src/kxv.h b/hw/kdrive/src/kxv.h
index 21a295be3..29118bc96 100644
--- a/hw/kdrive/src/kxv.h
+++ b/hw/kdrive/src/kxv.h
@@ -57,80 +57,86 @@ of the copyright holder.
 #define VIDEO_CLIP_TO_VIEWPORT			0x00000010
 
 typedef struct {
-  int id;
-  int type;
-  int byte_order;
-  unsigned char guid[16];
-  int bits_per_pixel;
-  int format;
-  int num_planes;
-
-  /* for RGB formats only */
-  int depth;
-  unsigned int red_mask;
-  unsigned int green_mask;
-  unsigned int blue_mask;
-
-  /* for YUV formats only */
-  unsigned int y_sample_bits;
-  unsigned int u_sample_bits;
-  unsigned int v_sample_bits;
-  unsigned int horz_y_period;
-  unsigned int horz_u_period;
-  unsigned int horz_v_period;
-  unsigned int vert_y_period;
-  unsigned int vert_u_period;
-  unsigned int vert_v_period;
-  char component_order[32];
-  int scanline_order;
+    int id;
+    int type;
+    int byte_order;
+    unsigned char guid[16];
+    int bits_per_pixel;
+    int format;
+    int num_planes;
+
+    /* for RGB formats only */
+    int depth;
+    unsigned int red_mask;
+    unsigned int green_mask;
+    unsigned int blue_mask;
+
+    /* for YUV formats only */
+    unsigned int y_sample_bits;
+    unsigned int u_sample_bits;
+    unsigned int v_sample_bits;
+    unsigned int horz_y_period;
+    unsigned int horz_u_period;
+    unsigned int horz_v_period;
+    unsigned int vert_y_period;
+    unsigned int vert_u_period;
+    unsigned int vert_v_period;
+    char component_order[32];
+    int scanline_order;
 } KdImageRec, *KdImagePtr;
 
-
 typedef struct {
-  KdScreenInfo * screen;
-  int id;
-  unsigned short width, height;
-  int *pitches; /* bytes */
-  int *offsets; /* in bytes from start of framebuffer */
-  DevUnion devPrivate;
+    KdScreenInfo *screen;
+    int id;
+    unsigned short width, height;
+    int *pitches;               /* bytes */
+    int *offsets;               /* in bytes from start of framebuffer */
+    DevUnion devPrivate;
 } KdSurfaceRec, *KdSurfacePtr;
 
-
-typedef int (* PutVideoFuncPtr)( KdScreenInfo * screen, DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* PutStillFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* GetVideoFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* GetStillFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef void (* StopVideoFuncPtr)(KdScreenInfo * screen, pointer data, Bool Exit);
-typedef int (* SetPortAttributeFuncPtr)(KdScreenInfo * screen, Atom attribute,
-	int value, pointer data);
-typedef int (* GetPortAttributeFuncPtr)(KdScreenInfo * screen, Atom attribute,
-	int *value, pointer data);
-typedef void (* QueryBestSizeFuncPtr)(KdScreenInfo * screen, Bool motion,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	unsigned int *p_w, unsigned int *p_h, pointer data);
-typedef int (* PutImageFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short src_x, short src_y, short drw_x, short drw_y,
-	short src_w, short src_h, short drw_w, short drw_h,
-	int image, unsigned char* buf, short width, short height, Bool Sync,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* ReputImageFuncPtr)( KdScreenInfo * screen, DrawablePtr pDraw,
-				  short drw_x, short drw_y,
-				  RegionPtr clipBoxes, pointer data );
-typedef int (*QueryImageAttributesFuncPtr)(KdScreenInfo * screen,
-	int image, unsigned short *width, unsigned short *height,
-	int *pitches, int *offsets);
+typedef int (*PutVideoFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef int (*PutStillFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef int (*GetVideoFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef int (*GetStillFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef void (*StopVideoFuncPtr) (KdScreenInfo * screen, pointer data,
+                                  Bool Exit);
+typedef int (*SetPortAttributeFuncPtr) (KdScreenInfo * screen, Atom attribute,
+                                        int value, pointer data);
+typedef int (*GetPortAttributeFuncPtr) (KdScreenInfo * screen, Atom attribute,
+                                        int *value, pointer data);
+typedef void (*QueryBestSizeFuncPtr) (KdScreenInfo * screen, Bool motion,
+                                      short vid_w, short vid_h, short drw_w,
+                                      short drw_h, unsigned int *p_w,
+                                      unsigned int *p_h, pointer data);
+typedef int (*PutImageFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short src_x, short src_y, short drw_x,
+                                short drw_y, short src_w, short src_h,
+                                short drw_w, short drw_h, int image,
+                                unsigned char *buf, short width, short height,
+                                Bool Sync, RegionPtr clipBoxes, pointer data);
+typedef int (*ReputImageFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                  short drw_x, short drw_y, RegionPtr clipBoxes,
+                                  pointer data);
+typedef int (*QueryImageAttributesFuncPtr) (KdScreenInfo * screen, int image,
+                                            unsigned short *width,
+                                            unsigned short *height,
+                                            int *pitches, int *offsets);
 
 typedef enum {
     XV_OFF,
@@ -141,84 +147,78 @@ typedef enum {
 /*** this is what the driver needs to fill out ***/
 
 typedef struct {
-  int id;
-  char *name;
-  unsigned short width, height;
-  XvRationalRec rate;
+    int id;
+    char *name;
+    unsigned short width, height;
+    XvRationalRec rate;
 } KdVideoEncodingRec, *KdVideoEncodingPtr;
 
 typedef struct {
-  char 	depth;
-  short class;
+    char depth;
+    short class;
 } KdVideoFormatRec, *KdVideoFormatPtr;
 
 typedef struct {
-  int   flags;
-  int   min_value;
-  int   max_value;
-  char  *name;
+    int flags;
+    int min_value;
+    int max_value;
+    char *name;
 } KdAttributeRec, *KdAttributePtr;
 
 typedef struct {
-  unsigned int type;
-  int flags;
-  char *name;
-  int nEncodings;
-  KdVideoEncodingPtr pEncodings;
-  int nFormats;
-  KdVideoFormatPtr pFormats;
-  int nPorts;
-  DevUnion *pPortPrivates;
-  int nAttributes;
-  KdAttributePtr pAttributes;
-  int nImages;
-  KdImagePtr pImages;
-  PutVideoFuncPtr PutVideo;
-  PutStillFuncPtr PutStill;
-  GetVideoFuncPtr GetVideo;
-  GetStillFuncPtr GetStill;
-  StopVideoFuncPtr StopVideo;
-  SetPortAttributeFuncPtr SetPortAttribute;
-  GetPortAttributeFuncPtr GetPortAttribute;
-  QueryBestSizeFuncPtr QueryBestSize;
-  PutImageFuncPtr PutImage;
-  ReputImageFuncPtr ReputImage;
-  QueryImageAttributesFuncPtr QueryImageAttributes;
+    unsigned int type;
+    int flags;
+    char *name;
+    int nEncodings;
+    KdVideoEncodingPtr pEncodings;
+    int nFormats;
+    KdVideoFormatPtr pFormats;
+    int nPorts;
+    DevUnion *pPortPrivates;
+    int nAttributes;
+    KdAttributePtr pAttributes;
+    int nImages;
+    KdImagePtr pImages;
+    PutVideoFuncPtr PutVideo;
+    PutStillFuncPtr PutStill;
+    GetVideoFuncPtr GetVideo;
+    GetStillFuncPtr GetStill;
+    StopVideoFuncPtr StopVideo;
+    SetPortAttributeFuncPtr SetPortAttribute;
+    GetPortAttributeFuncPtr GetPortAttribute;
+    QueryBestSizeFuncPtr QueryBestSize;
+    PutImageFuncPtr PutImage;
+    ReputImageFuncPtr ReputImage;
+    QueryImageAttributesFuncPtr QueryImageAttributes;
 } KdVideoAdaptorRec, *KdVideoAdaptorPtr;
 
 Bool
-KdXVScreenInit(
-   ScreenPtr pScreen,
-   KdVideoAdaptorPtr 	*Adaptors,
-   int num
-);
+ KdXVScreenInit(ScreenPtr pScreen, KdVideoAdaptorPtr * Adaptors, int num);
 
-typedef int (* KdXVInitGenericAdaptorPtr)(KdScreenInfo * screen,
-	KdVideoAdaptorPtr **Adaptors);
+typedef int (*KdXVInitGenericAdaptorPtr) (KdScreenInfo * screen,
+                                          KdVideoAdaptorPtr ** Adaptors);
 
 int
-KdXVRegisterGenericAdaptorDriver(
-    KdXVInitGenericAdaptorPtr InitFunc
-);
+ KdXVRegisterGenericAdaptorDriver(KdXVInitGenericAdaptorPtr InitFunc);
 
 int
-KdXVListGenericAdaptors(
-    KdScreenInfo *          screen,
-    KdVideoAdaptorPtr  **Adaptors
-);
+ KdXVListGenericAdaptors(KdScreenInfo * screen, KdVideoAdaptorPtr ** Adaptors);
 
 void
-KdXVCopyPackedData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
-   int srcPitch, int dstPitch, int srcW, int srcH, int top, int left,
-   int h, int w);
+
+KdXVCopyPackedData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int dstPitch, int srcW, int srcH, int top,
+                   int left, int h, int w);
 
 void
-KdXVCopyPlanarData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
-   int srcPitch, int srcPitch2, int dstPitch, int srcW, int srcH, int height,
-   int top, int left, int h, int w, int id);
+
+KdXVCopyPlanarData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int srcPitch2, int dstPitch, int srcW,
+                   int srcH, int height, int top, int left, int h, int w,
+                   int id);
 
 void
-KXVPaintRegion (DrawablePtr pDraw, RegionPtr pRgn, Pixel fg);
+ KXVPaintRegion(DrawablePtr pDraw, RegionPtr pRgn, Pixel fg);
 
 KdVideoAdaptorPtr KdXVAllocateVideoAdaptorRec(KdScreenInfo * screen);
 
@@ -230,50 +230,48 @@ void KdXVDisable(ScreenPtr);
 
 /*** These are DDX layer privates ***/
 
-
 typedef struct {
-   CreateWindowProcPtr		CreateWindow;
-   DestroyWindowProcPtr		DestroyWindow;
-   ClipNotifyProcPtr		ClipNotify;
-   WindowExposuresProcPtr	WindowExposures;
+    CreateWindowProcPtr CreateWindow;
+    DestroyWindowProcPtr DestroyWindow;
+    ClipNotifyProcPtr ClipNotify;
+    WindowExposuresProcPtr WindowExposures;
 } KdXVScreenRec, *KdXVScreenPtr;
 
 typedef struct {
-  int flags;
-  PutVideoFuncPtr PutVideo;
-  PutStillFuncPtr PutStill;
-  GetVideoFuncPtr GetVideo;
-  GetStillFuncPtr GetStill;
-  StopVideoFuncPtr StopVideo;
-  SetPortAttributeFuncPtr SetPortAttribute;
-  GetPortAttributeFuncPtr GetPortAttribute;
-  QueryBestSizeFuncPtr QueryBestSize;
-  PutImageFuncPtr PutImage;
-  ReputImageFuncPtr ReputImage;
-  QueryImageAttributesFuncPtr QueryImageAttributes;
+    int flags;
+    PutVideoFuncPtr PutVideo;
+    PutStillFuncPtr PutStill;
+    GetVideoFuncPtr GetVideo;
+    GetStillFuncPtr GetStill;
+    StopVideoFuncPtr StopVideo;
+    SetPortAttributeFuncPtr SetPortAttribute;
+    GetPortAttributeFuncPtr GetPortAttribute;
+    QueryBestSizeFuncPtr QueryBestSize;
+    PutImageFuncPtr PutImage;
+    ReputImageFuncPtr ReputImage;
+    QueryImageAttributesFuncPtr QueryImageAttributes;
 } XvAdaptorRecPrivate, *XvAdaptorRecPrivatePtr;
 
 typedef struct {
-   KdScreenInfo * screen;
-   DrawablePtr pDraw;
-   unsigned char type;
-   unsigned int subWindowMode;
-   DDXPointRec clipOrg;
-   RegionPtr clientClip;
-   RegionPtr pCompositeClip;
-   Bool FreeCompositeClip;
-   XvAdaptorRecPrivatePtr AdaptorRec;
-   XvStatus isOn;
-   Bool moved;
-   int vid_x, vid_y, vid_w, vid_h;
-   int drw_x, drw_y, drw_w, drw_h;
-   DevUnion DevPriv;
+    KdScreenInfo *screen;
+    DrawablePtr pDraw;
+    unsigned char type;
+    unsigned int subWindowMode;
+    DDXPointRec clipOrg;
+    RegionPtr clientClip;
+    RegionPtr pCompositeClip;
+    Bool FreeCompositeClip;
+    XvAdaptorRecPrivatePtr AdaptorRec;
+    XvStatus isOn;
+    Bool moved;
+    int vid_x, vid_y, vid_w, vid_h;
+    int drw_x, drw_y, drw_w, drw_h;
+    DevUnion DevPriv;
 } XvPortRecPrivate, *XvPortRecPrivatePtr;
 
-typedef struct _KdXVWindowRec{
-   XvPortRecPrivatePtr PortRec;
-   struct _KdXVWindowRec *next;
+typedef struct _KdXVWindowRec {
+    XvPortRecPrivatePtr PortRec;
+    struct _KdXVWindowRec *next;
 } KdXVWindowRec, *KdXVWindowPtr;
 
-#endif  /* _XVDIX_H_ */
-
+#endif                          /* _XVDIX_H_ */