1 files changed, 218 insertions, 230 deletions

diff --git a/xorg-server/glx/glxdri2.c b/xorg-server/glx/glxdri2.c
index 5e524db99..aa38295fa 100644
--- a/xorg-server/glx/glxdri2.c
+++ b/xorg-server/glx/glxdri2.c
@@ -54,18 +54,18 @@
 #include "dispatch.h"
 #include "extension_string.h"
 
-typedef struct __GLXDRIscreen   __GLXDRIscreen;
-typedef struct __GLXDRIcontext  __GLXDRIcontext;
+typedef struct __GLXDRIscreen __GLXDRIscreen;
+typedef struct __GLXDRIcontext __GLXDRIcontext;
 typedef struct __GLXDRIdrawable __GLXDRIdrawable;
 
 struct __GLXDRIscreen {
-    __GLXscreen		 base;
-    __DRIscreen		*driScreen;
-    void		*driver;
-    int			 fd;
+    __GLXscreen base;
+    __DRIscreen *driScreen;
+    void *driver;
+    int fd;
 
-    xf86EnterVTProc	*enterVT;
-    xf86LeaveVTProc	*leaveVT;
+    xf86EnterVTProc *enterVT;
+    xf86LeaveVTProc *leaveVT;
 
     const __DRIcoreExtension *core;
     const __DRIdri2Extension *dri2;
@@ -79,16 +79,16 @@ struct __GLXDRIscreen {
 };
 
 struct __GLXDRIcontext {
-    __GLXcontext	 base;
-    __DRIcontext	*driContext;
+    __GLXcontext base;
+    __DRIcontext *driContext;
 };
 
 #define MAX_DRAWABLE_BUFFERS 5
 
 struct __GLXDRIdrawable {
-    __GLXdrawable	 base;
-    __DRIdrawable	*driDrawable;
-    __GLXDRIscreen	*screen;
+    __GLXdrawable base;
+    __DRIdrawable *driDrawable;
+    __GLXDRIscreen *screen;
 
     /* Dimensions as last reported by DRI2GetBuffers. */
     int width;
@@ -98,12 +98,12 @@ struct __GLXDRIdrawable {
 };
 
 static void
-__glXDRIdrawableDestroy(__GLXdrawable *drawable)
+__glXDRIdrawableDestroy(__GLXdrawable * drawable)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     const __DRIcoreExtension *core = private->screen->core;
-    
-    (*core->destroyDrawable)(private->driDrawable);
+
+    (*core->destroyDrawable) (private->driDrawable);
 
     __glXDrawableRelease(drawable);
 
@@ -111,8 +111,8 @@ __glXDRIdrawableDestroy(__GLXdrawable *drawable)
 }
 
 static void
-__glXDRIdrawableCopySubBuffer(__GLXdrawable *drawable,
-			       int x, int y, int w, int h)
+__glXDRIdrawableCopySubBuffer(__GLXdrawable * drawable,
+                              int x, int y, int w, int h)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     BoxRec box;
@@ -125,11 +125,11 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawable *drawable,
     RegionInit(&region, &box, 0);
 
     DRI2CopyRegion(drawable->pDraw, &region,
-		   DRI2BufferFrontLeft, DRI2BufferBackLeft);
+                   DRI2BufferFrontLeft, DRI2BufferBackLeft);
 }
 
 static void
-__glXDRIdrawableWaitX(__GLXdrawable *drawable)
+__glXDRIdrawableWaitX(__GLXdrawable * drawable)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     BoxRec box;
@@ -142,11 +142,11 @@ __glXDRIdrawableWaitX(__GLXdrawable *drawable)
     RegionInit(&region, &box, 0);
 
     DRI2CopyRegion(drawable->pDraw, &region,
-		   DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
+                   DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
 }
 
 static void
-__glXDRIdrawableWaitGL(__GLXdrawable *drawable)
+__glXDRIdrawableWaitGL(__GLXdrawable * drawable)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     BoxRec box;
@@ -159,34 +159,34 @@ __glXDRIdrawableWaitGL(__GLXdrawable *drawable)
     RegionInit(&region, &box, 0);
 
     DRI2CopyRegion(drawable->pDraw, &region,
-		   DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
+                   DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
 }
 
 static void
 __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust,
-		  CARD64 msc, CARD32 sbc)
+                  CARD64 msc, CARD32 sbc)
 {
     __GLXdrawable *drawable = data;
     xGLXBufferSwapComplete2 wire;
 
     if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
-	return;
+        return;
 
     wire.type = __glXEventBase + GLX_BufferSwapComplete;
     switch (type) {
     case DRI2_EXCHANGE_COMPLETE:
-	wire.event_type = GLX_EXCHANGE_COMPLETE_INTEL;
-	break;
+        wire.event_type = GLX_EXCHANGE_COMPLETE_INTEL;
+        break;
     case DRI2_BLIT_COMPLETE:
-	wire.event_type = GLX_BLIT_COMPLETE_INTEL;
-	break;
+        wire.event_type = GLX_BLIT_COMPLETE_INTEL;
+        break;
     case DRI2_FLIP_COMPLETE:
-	wire.event_type = GLX_FLIP_COMPLETE_INTEL;
-	break;
+        wire.event_type = GLX_FLIP_COMPLETE_INTEL;
+        break;
     default:
-	/* unknown swap completion type */
-	wire.event_type = 0;
-	break;
+        /* unknown swap completion type */
+        wire.event_type = 0;
+        break;
     }
     wire.drawable = drawable->drawId;
     wire.ust_hi = ust >> 32;
@@ -205,7 +205,7 @@ __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust,
  * swap should happen, then perform the copy when we receive it.
  */
 static GLboolean
-__glXDRIdrawableSwapBuffers(ClientPtr client, __GLXdrawable *drawable)
+__glXDRIdrawableSwapBuffers(ClientPtr client, __GLXdrawable * drawable)
 {
     __GLXDRIdrawable *priv = (__GLXDRIdrawable *) drawable;
     __GLXDRIscreen *screen = priv->screen;
@@ -213,26 +213,26 @@ __glXDRIdrawableSwapBuffers(ClientPtr client, __GLXdrawable *drawable)
 
 #if __DRI2_FLUSH_VERSION >= 3
     if (screen->flush) {
-	(*screen->flush->flush)(priv->driDrawable);
-	(*screen->flush->invalidate)(priv->driDrawable);
+        (*screen->flush->flush) (priv->driDrawable);
+        (*screen->flush->invalidate) (priv->driDrawable);
     }
 #else
     if (screen->flush)
-	(*screen->flush->flushInvalidate)(priv->driDrawable);
+        (*screen->flush->flushInvalidate) (priv->driDrawable);
 #endif
 
     if (DRI2SwapBuffers(client, drawable->pDraw, 0, 0, 0, &unused,
-			__glXdriSwapEvent, drawable) != Success)
-	return FALSE;
+                        __glXdriSwapEvent, drawable) != Success)
+        return FALSE;
 
     return TRUE;
 }
 
 static int
-__glXDRIdrawableSwapInterval(__GLXdrawable *drawable, int interval)
+__glXDRIdrawableSwapInterval(__GLXdrawable * drawable, int interval)
 {
-    if (interval <= 0) /* || interval > BIGNUM? */
-	return GLX_BAD_VALUE;
+    if (interval <= 0)          /* || interval > BIGNUM? */
+        return GLX_BAD_VALUE;
 
     DRI2SwapInterval(drawable->pDraw, interval);
 
@@ -240,57 +240,56 @@ __glXDRIdrawableSwapInterval(__GLXdrawable *drawable, int interval)
 }
 
 static void
-__glXDRIcontextDestroy(__GLXcontext *baseContext)
+__glXDRIcontextDestroy(__GLXcontext * baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
 
-    (*screen->core->destroyContext)(context->driContext);
+    (*screen->core->destroyContext) (context->driContext);
     __glXContextDestroy(&context->base);
     free(context);
 }
 
 static int
-__glXDRIcontextMakeCurrent(__GLXcontext *baseContext)
+__glXDRIcontextMakeCurrent(__GLXcontext * baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
     __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
     __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
 
-    return (*screen->core->bindContext)(context->driContext,
-					draw->driDrawable,
-					read->driDrawable);
-}					      
+    return (*screen->core->bindContext) (context->driContext,
+                                         draw->driDrawable, read->driDrawable);
+}
 
 static int
-__glXDRIcontextLoseCurrent(__GLXcontext *baseContext)
+__glXDRIcontextLoseCurrent(__GLXcontext * baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
 
-    return (*screen->core->unbindContext)(context->driContext);
+    return (*screen->core->unbindContext) (context->driContext);
 }
 
 static int
-__glXDRIcontextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc,
-		    unsigned long mask)
+__glXDRIcontextCopy(__GLXcontext * baseDst, __GLXcontext * baseSrc,
+                    unsigned long mask)
 {
     __GLXDRIcontext *dst = (__GLXDRIcontext *) baseDst;
     __GLXDRIcontext *src = (__GLXDRIcontext *) baseSrc;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) dst->base.pGlxScreen;
 
-    return (*screen->core->copyContext)(dst->driContext,
-					src->driContext, mask);
+    return (*screen->core->copyContext) (dst->driContext,
+                                         src->driContext, mask);
 }
 
 static Bool
-__glXDRIcontextWait(__GLXcontext *baseContext,
-		    __GLXclientState *cl, int *error)
+__glXDRIcontextWait(__GLXcontext * baseContext,
+                    __GLXclientState * cl, int *error)
 {
     if (DRI2WaitSwap(cl->client, baseContext->drawPriv->pDraw)) {
-	*error = cl->client->noClientException;
-	return TRUE;
+        *error = cl->client->noClientException;
+        return TRUE;
     }
 
     return FALSE;
@@ -299,9 +298,8 @@ __glXDRIcontextWait(__GLXcontext *baseContext,
 #ifdef __DRI_TEX_BUFFER
 
 static int
-__glXDRIbindTexImage(__GLXcontext *baseContext,
-		     int buffer,
-		     __GLXdrawable *glxPixmap)
+__glXDRIbindTexImage(__GLXcontext * baseContext,
+                     int buffer, __GLXdrawable * glxPixmap)
 {
     __GLXDRIdrawable *drawable = (__GLXDRIdrawable *) glxPixmap;
     const __DRItexBufferExtension *texBuffer = drawable->screen->texBuffer;
@@ -312,25 +310,23 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
 
 #if __DRI_TEX_BUFFER_VERSION >= 2
     if (texBuffer->base.version >= 2 && texBuffer->setTexBuffer2 != NULL) {
-	(*texBuffer->setTexBuffer2)(context->driContext,
-				    glxPixmap->target,
-				    glxPixmap->format,
-				    drawable->driDrawable);
-    } else
+        (*texBuffer->setTexBuffer2) (context->driContext,
+                                     glxPixmap->target,
+                                     glxPixmap->format, drawable->driDrawable);
+    }
+    else
 #endif
     {
-	texBuffer->setTexBuffer(context->driContext,
-				glxPixmap->target,
-				drawable->driDrawable);
+        texBuffer->setTexBuffer(context->driContext,
+                                glxPixmap->target, drawable->driDrawable);
     }
 
     return Success;
 }
 
 static int
-__glXDRIreleaseTexImage(__GLXcontext *baseContext,
-			int buffer,
-			__GLXdrawable *pixmap)
+__glXDRIreleaseTexImage(__GLXcontext * baseContext,
+                        int buffer, __GLXdrawable * pixmap)
 {
     /* FIXME: Just unbind the texture? */
     return Success;
@@ -339,17 +335,15 @@ __glXDRIreleaseTexImage(__GLXcontext *baseContext,
 #else
 
 static int
-__glXDRIbindTexImage(__GLXcontext *baseContext,
-		     int buffer,
-		     __GLXdrawable *glxPixmap)
+__glXDRIbindTexImage(__GLXcontext * baseContext,
+                     int buffer, __GLXdrawable * glxPixmap)
 {
     return Success;
 }
 
 static int
-__glXDRIreleaseTexImage(__GLXcontext *baseContext,
-			int buffer,
-			__GLXdrawable *pixmap)
+__glXDRIreleaseTexImage(__GLXcontext * baseContext,
+                        int buffer, __GLXdrawable * pixmap)
 {
     return Success;
 }
@@ -362,31 +356,31 @@ static __GLXtextureFromPixmap __glXDRItextureFromPixmap = {
 };
 
 static void
-__glXDRIscreenDestroy(__GLXscreen *baseScreen)
+__glXDRIscreenDestroy(__GLXscreen * baseScreen)
 {
     int i;
 
     __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
 
-    (*screen->core->destroyScreen)(screen->driScreen);
+    (*screen->core->destroyScreen) (screen->driScreen);
 
     dlclose(screen->driver);
 
     __glXScreenDestroy(baseScreen);
 
     if (screen->driConfigs) {
-	for (i = 0; screen->driConfigs[i] != NULL; i++)
-	    free((__DRIconfig **)screen->driConfigs[i]);
-	free(screen->driConfigs);
+        for (i = 0; screen->driConfigs[i] != NULL; i++)
+            free((__DRIconfig **) screen->driConfigs[i]);
+        free(screen->driConfigs);
     }
 
     free(screen);
 }
 
 static __GLXcontext *
-__glXDRIscreenCreateContext(__GLXscreen *baseScreen,
-			    __GLXconfig *glxConfig,
-			    __GLXcontext *baseShareContext)
+__glXDRIscreenCreateContext(__GLXscreen * baseScreen,
+                            __GLXconfig * glxConfig,
+                            __GLXcontext * baseShareContext)
 {
     __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
     __GLXDRIcontext *context, *shareContext;
@@ -395,27 +389,27 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
 
     shareContext = (__GLXDRIcontext *) baseShareContext;
     if (shareContext)
-	driShare = shareContext->driContext;
+        driShare = shareContext->driContext;
     else
-	driShare = NULL;
+        driShare = NULL;
 
     context = calloc(1, sizeof *context);
     if (context == NULL)
-	return NULL;
+        return NULL;
 
-    context->base.destroy           = __glXDRIcontextDestroy;
-    context->base.makeCurrent       = __glXDRIcontextMakeCurrent;
-    context->base.loseCurrent       = __glXDRIcontextLoseCurrent;
-    context->base.copy              = __glXDRIcontextCopy;
+    context->base.destroy = __glXDRIcontextDestroy;
+    context->base.makeCurrent = __glXDRIcontextMakeCurrent;
+    context->base.loseCurrent = __glXDRIcontextLoseCurrent;
+    context->base.copy = __glXDRIcontextCopy;
     context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
-    context->base.wait              = __glXDRIcontextWait;
+    context->base.wait = __glXDRIcontextWait;
 
     context->driContext =
-	(*screen->dri2->createNewContext)(screen->driScreen,
-					  config->driConfig,
-					  driShare, context);
+        (*screen->dri2->createNewContext) (screen->driScreen,
+                                           config->driConfig,
+                                           driShare, context);
     if (context->driContext == NULL) {
-	    free(context);
+        free(context);
         return NULL;
     }
 
@@ -430,18 +424,16 @@ __glXDRIinvalidateBuffers(DrawablePtr pDraw, void *priv, XID id)
     __GLXDRIscreen *screen = private->screen;
 
     if (screen->flush)
-	(*screen->flush->invalidate)(private->driDrawable);
+        (*screen->flush->invalidate) (private->driDrawable);
 #endif
 }
 
 static __GLXdrawable *
 __glXDRIscreenCreateDrawable(ClientPtr client,
-			     __GLXscreen *screen,
-			     DrawablePtr pDraw,
-			     XID drawId,
-			     int type,
-			     XID glxDrawId,
-			     __GLXconfig *glxConfig)
+                             __GLXscreen * screen,
+                             DrawablePtr pDraw,
+                             XID drawId,
+                             int type, XID glxDrawId, __GLXconfig * glxConfig)
 {
     __GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;
     __GLXDRIconfig *config = (__GLXDRIconfig *) glxConfig;
@@ -449,39 +441,39 @@ __glXDRIscreenCreateDrawable(ClientPtr client,
 
     private = calloc(1, sizeof *private);
     if (private == NULL)
-	return NULL;
+        return NULL;
 
     private->screen = driScreen;
     if (!__glXDrawableInit(&private->base, screen,
-			   pDraw, type, glxDrawId, glxConfig)) {
+                           pDraw, type, glxDrawId, glxConfig)) {
         free(private);
-	return NULL;
+        return NULL;
     }
 
-    private->base.destroy       = __glXDRIdrawableDestroy;
-    private->base.swapBuffers   = __glXDRIdrawableSwapBuffers;
+    private->base.destroy = __glXDRIdrawableDestroy;
+    private->base.swapBuffers = __glXDRIdrawableSwapBuffers;
     private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
-    private->base.waitGL	= __glXDRIdrawableWaitGL;
-    private->base.waitX		= __glXDRIdrawableWaitX;
+    private->base.waitGL = __glXDRIdrawableWaitGL;
+    private->base.waitX = __glXDRIdrawableWaitX;
 
     if (DRI2CreateDrawable(client, pDraw, drawId,
-			   __glXDRIinvalidateBuffers, private)) {
-	    free(private);
-	    return NULL;
+                           __glXDRIinvalidateBuffers, private)) {
+        free(private);
+        return NULL;
     }
 
     private->driDrawable =
-	(*driScreen->dri2->createNewDrawable)(driScreen->driScreen,
-					      config->driConfig, private);
+        (*driScreen->dri2->createNewDrawable) (driScreen->driScreen,
+                                               config->driConfig, private);
 
     return &private->base;
 }
 
 static __DRIbuffer *
-dri2GetBuffers(__DRIdrawable *driDrawable,
-	       int *width, int *height,
-	       unsigned int *attachments, int count,
-	       int *out_count, void *loaderPrivate)
+dri2GetBuffers(__DRIdrawable * driDrawable,
+               int *width, int *height,
+               unsigned int *attachments, int count,
+               int *out_count, void *loaderPrivate)
 {
     __GLXDRIdrawable *private = loaderPrivate;
     DRI2BufferPtr *buffers;
@@ -489,12 +481,12 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
     int j;
 
     buffers = DRI2GetBuffers(private->base.pDraw,
-			     width, height, attachments, count, out_count);
+                             width, height, attachments, count, out_count);
     if (*out_count > MAX_DRAWABLE_BUFFERS) {
-	*out_count = 0;
-	return NULL;
+        *out_count = 0;
+        return NULL;
     }
-	
+
     private->width = *width;
     private->height = *height;
 
@@ -502,19 +494,19 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
      * __DRIbuffer tokens. */
     j = 0;
     for (i = 0; i < *out_count; i++) {
-	/* Do not send the real front buffer of a window to the client.
-	 */
-	if ((private->base.pDraw->type == DRAWABLE_WINDOW)
-	    && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
-	    continue;
-	}
-
-	private->buffers[j].attachment = buffers[i]->attachment;
-	private->buffers[j].name = buffers[i]->name;
-	private->buffers[j].pitch = buffers[i]->pitch;
-	private->buffers[j].cpp = buffers[i]->cpp;
-	private->buffers[j].flags = buffers[i]->flags;
-	j++;
+        /* Do not send the real front buffer of a window to the client.
+         */
+        if ((private->base.pDraw->type == DRAWABLE_WINDOW)
+            && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
+            continue;
+        }
+
+        private->buffers[j].attachment = buffers[i]->attachment;
+        private->buffers[j].name = buffers[i]->name;
+        private->buffers[j].pitch = buffers[i]->pitch;
+        private->buffers[j].cpp = buffers[i]->cpp;
+        private->buffers[j].flags = buffers[i]->flags;
+        j++;
     }
 
     *out_count = j;
@@ -522,10 +514,10 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
 }
 
 static __DRIbuffer *
-dri2GetBuffersWithFormat(__DRIdrawable *driDrawable,
-			 int *width, int *height,
-			 unsigned int *attachments, int count,
-			 int *out_count, void *loaderPrivate)
+dri2GetBuffersWithFormat(__DRIdrawable * driDrawable,
+                         int *width, int *height,
+                         unsigned int *attachments, int count,
+                         int *out_count, void *loaderPrivate)
 {
     __GLXDRIdrawable *private = loaderPrivate;
     DRI2BufferPtr *buffers;
@@ -533,11 +525,11 @@ dri2GetBuffersWithFormat(__DRIdrawable *driDrawable,
     int j = 0;
 
     buffers = DRI2GetBuffersWithFormat(private->base.pDraw,
-				       width, height, attachments, count,
-				       out_count);
+                                       width, height, attachments, count,
+                                       out_count);
     if (*out_count > MAX_DRAWABLE_BUFFERS) {
-	*out_count = 0;
-	return NULL;
+        *out_count = 0;
+        return NULL;
     }
 
     private->width = *width;
@@ -546,34 +538,34 @@ dri2GetBuffersWithFormat(__DRIdrawable *driDrawable,
     /* This assumes the DRI2 buffer attachment tokens matches the
      * __DRIbuffer tokens. */
     for (i = 0; i < *out_count; i++) {
-	/* Do not send the real front buffer of a window to the client.
-	 */
-	if ((private->base.pDraw->type == DRAWABLE_WINDOW)
-	    && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
-	    continue;
-	}
-
-	private->buffers[j].attachment = buffers[i]->attachment;
-	private->buffers[j].name = buffers[i]->name;
-	private->buffers[j].pitch = buffers[i]->pitch;
-	private->buffers[j].cpp = buffers[i]->cpp;
-	private->buffers[j].flags = buffers[i]->flags;
-	j++;
+        /* Do not send the real front buffer of a window to the client.
+         */
+        if ((private->base.pDraw->type == DRAWABLE_WINDOW)
+            && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
+            continue;
+        }
+
+        private->buffers[j].attachment = buffers[i]->attachment;
+        private->buffers[j].name = buffers[i]->name;
+        private->buffers[j].pitch = buffers[i]->pitch;
+        private->buffers[j].cpp = buffers[i]->cpp;
+        private->buffers[j].flags = buffers[i]->flags;
+        j++;
     }
 
     *out_count = j;
     return private->buffers;
 }
 
-static void 
-dri2FlushFrontBuffer(__DRIdrawable *driDrawable, void *loaderPrivate)
+static void
+dri2FlushFrontBuffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 {
     (void) driDrawable;
     __glXDRIdrawableWaitGL((__GLXdrawable *) loaderPrivate);
 }
 
 static const __DRIdri2LoaderExtension loaderExtension = {
-    { __DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION },
+    {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION},
     dri2GetBuffers,
     dri2FlushFrontBuffer,
     dri2GetBuffersWithFormat,
@@ -581,7 +573,7 @@ static const __DRIdri2LoaderExtension loaderExtension = {
 
 #ifdef __DRI_USE_INVALIDATE
 static const __DRIuseInvalidateExtension dri2UseInvalidate = {
-   { __DRI_USE_INVALIDATE, __DRI_USE_INVALIDATE_VERSION }
+    {__DRI_USE_INVALIDATE, __DRI_USE_INVALIDATE_VERSION}
 };
 #endif
 
@@ -595,36 +587,36 @@ static const __DRIextension *loader_extensions[] = {
 };
 
 static Bool
-glxDRIEnterVT (int index, int flags)
+glxDRIEnterVT(int index, int flags)
 {
     ScrnInfoPtr scrn = xf86Screens[index];
-    Bool	ret;
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) 
-	glxGetScreen(screenInfo.screens[index]);
+    Bool ret;
+    __GLXDRIscreen *screen = (__GLXDRIscreen *)
+        glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
 
     scrn->EnterVT = screen->enterVT;
 
-    ret = scrn->EnterVT (index, flags);
+    ret = scrn->EnterVT(index, flags);
 
     screen->enterVT = scrn->EnterVT;
     scrn->EnterVT = glxDRIEnterVT;
 
     if (!ret)
-	return FALSE;
-    
+        return FALSE;
+
     glxResumeClients();
 
     return TRUE;
 }
 
 static void
-glxDRILeaveVT (int index, int flags)
+glxDRILeaveVT(int index, int flags)
 {
     ScrnInfoPtr scrn = xf86Screens[index];
     __GLXDRIscreen *screen = (__GLXDRIscreen *)
-	glxGetScreen(screenInfo.screens[index]);
+        glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");
 
@@ -637,7 +629,7 @@ glxDRILeaveVT (int index, int flags)
 }
 
 static void
-initializeExtensions(__GLXDRIscreen *screen)
+initializeExtensions(__GLXDRIscreen * screen)
 {
     ScreenPtr pScreen = screen->base.pScreen;
     const __DRIextension **extensions;
@@ -645,48 +637,46 @@ initializeExtensions(__GLXDRIscreen *screen)
 
     extensions = screen->core->getExtensions(screen->driScreen);
 
-    __glXEnableExtension(screen->glx_enable_bits,
-			 "GLX_MESA_copy_sub_buffer");
+    __glXEnableExtension(screen->glx_enable_bits, "GLX_MESA_copy_sub_buffer");
     LogMessage(X_INFO, "AIGLX: enabled GLX_MESA_copy_sub_buffer\n");
 
     __glXEnableExtension(screen->glx_enable_bits, "GLX_INTEL_swap_event");
     LogMessage(X_INFO, "AIGLX: enabled GLX_INTEL_swap_event\n");
 
     if (DRI2HasSwapControl(pScreen)) {
-	__glXEnableExtension(screen->glx_enable_bits,
-			     "GLX_SGI_swap_control");
-	__glXEnableExtension(screen->glx_enable_bits,
-			     "GLX_MESA_swap_control");
-	LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
+        __glXEnableExtension(screen->glx_enable_bits, "GLX_SGI_swap_control");
+        __glXEnableExtension(screen->glx_enable_bits, "GLX_MESA_swap_control");
+        LogMessage(X_INFO,
+                   "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
     }
 
     for (i = 0; extensions[i]; i++) {
 #ifdef __DRI_READ_DRAWABLE
-	if (strcmp(extensions[i]->name, __DRI_READ_DRAWABLE) == 0) {
-	    __glXEnableExtension(screen->glx_enable_bits,
-				 "GLX_SGI_make_current_read");
+        if (strcmp(extensions[i]->name, __DRI_READ_DRAWABLE) == 0) {
+            __glXEnableExtension(screen->glx_enable_bits,
+                                 "GLX_SGI_make_current_read");
 
-	    LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_make_current_read\n");
-	}
+            LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_make_current_read\n");
+        }
 #endif
 
 #ifdef __DRI_TEX_BUFFER
-	if (strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) {
-	    screen->texBuffer =
-		(const __DRItexBufferExtension *) extensions[i];
-	    /* GLX_EXT_texture_from_pixmap is always enabled. */
-	    LogMessage(X_INFO, "AIGLX: GLX_EXT_texture_from_pixmap backed by buffer objects\n");
-	}
+        if (strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) {
+            screen->texBuffer = (const __DRItexBufferExtension *) extensions[i];
+            /* GLX_EXT_texture_from_pixmap is always enabled. */
+            LogMessage(X_INFO,
+                       "AIGLX: GLX_EXT_texture_from_pixmap backed by buffer objects\n");
+        }
 #endif
 
 #ifdef __DRI2_FLUSH
-	if (strcmp(extensions[i]->name, __DRI2_FLUSH) == 0 &&
-	    extensions[i]->version >= 3) {
-		screen->flush = (__DRI2flushExtension *) extensions[i];
-	}
+        if (strcmp(extensions[i]->name, __DRI2_FLUSH) == 0 &&
+            extensions[i]->version >= 3) {
+            screen->flush = (__DRI2flushExtension *) extensions[i];
+        }
 #endif
 
-	/* Ignore unknown extensions */
+        /* Ignore unknown extensions */
     }
 }
 
@@ -700,49 +690,48 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 
     screen = calloc(1, sizeof *screen);
     if (screen == NULL)
-	return NULL;
+        return NULL;
 
     if (!xf86LoaderCheckSymbol("DRI2Connect") ||
-	!DRI2Connect(pScreen, DRI2DriverDRI,
-		     &screen->fd, &driverName, &deviceName)) {
-	LogMessage(X_INFO,
-		   "AIGLX: Screen %d is not DRI2 capable\n", pScreen->myNum);
-	return NULL;
+        !DRI2Connect(pScreen, DRI2DriverDRI,
+                     &screen->fd, &driverName, &deviceName)) {
+        LogMessage(X_INFO,
+                   "AIGLX: Screen %d is not DRI2 capable\n", pScreen->myNum);
+        return NULL;
     }
 
-    screen->base.destroy        = __glXDRIscreenDestroy;
-    screen->base.createContext  = __glXDRIscreenCreateContext;
+    screen->base.destroy = __glXDRIscreenDestroy;
+    screen->base.createContext = __glXDRIscreenCreateContext;
     screen->base.createDrawable = __glXDRIscreenCreateDrawable;
-    screen->base.swapInterval   = __glXDRIdrawableSwapInterval;
-    screen->base.pScreen       = pScreen;
+    screen->base.swapInterval = __glXDRIdrawableSwapInterval;
+    screen->base.pScreen = pScreen;
 
     __glXInitExtensionEnableBits(screen->glx_enable_bits);
 
-    screen->driver = glxProbeDriver(driverName, (void **)&screen->core, __DRI_CORE, 1,
-				    (void **)&screen->dri2, __DRI_DRI2, 1);
+    screen->driver =
+        glxProbeDriver(driverName, (void **) &screen->core, __DRI_CORE, 1,
+                       (void **) &screen->dri2, __DRI_DRI2, 1);
     if (screen->driver == NULL) {
         goto handle_error;
     }
-    
+
     screen->driScreen =
-	(*screen->dri2->createNewScreen)(pScreen->myNum,
-					 screen->fd,
-					 loader_extensions,
-					 &screen->driConfigs,
-					 screen);
+        (*screen->dri2->createNewScreen) (pScreen->myNum,
+                                          screen->fd,
+                                          loader_extensions,
+                                          &screen->driConfigs, screen);
 
     if (screen->driScreen == NULL) {
-	LogMessage(X_ERROR,
-		   "AIGLX error: Calling driver entry point failed\n");
-	goto handle_error;
+        LogMessage(X_ERROR, "AIGLX error: Calling driver entry point failed\n");
+        goto handle_error;
     }
 
     initializeExtensions(screen);
 
     screen->base.fbconfigs = glxConvertConfigs(screen->core, screen->driConfigs,
-					       GLX_WINDOW_BIT |
-					       GLX_PIXMAP_BIT |
-					       GLX_PBUFFER_BIT);
+                                               GLX_WINDOW_BIT |
+                                               GLX_PIXMAP_BIT |
+                                               GLX_PBUFFER_BIT);
 
     __glXScreenInit(&screen->base, pScreen);
 
@@ -752,11 +741,11 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
      */
     buffer_size = __glXGetExtensionString(screen->glx_enable_bits, NULL);
     if (buffer_size > 0) {
-	free(screen->base.GLXextensions);
+        free(screen->base.GLXextensions);
 
-	screen->base.GLXextensions = xnfalloc(buffer_size);
-	(void) __glXGetExtensionString(screen->glx_enable_bits, 
-				       screen->base.GLXextensions);
+        screen->base.GLXextensions = xnfalloc(buffer_size);
+        (void) __glXGetExtensionString(screen->glx_enable_bits,
+                                       screen->base.GLXextensions);
     }
 
     /* We're going to assume (perhaps incorrectly?) that all DRI2-enabled
@@ -770,14 +759,13 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
      */
     screen->base.GLXmajor = 1;
     screen->base.GLXminor = 4;
-    
+
     screen->enterVT = pScrn->EnterVT;
-    pScrn->EnterVT = glxDRIEnterVT; 
+    pScrn->EnterVT = glxDRIEnterVT;
     screen->leaveVT = pScrn->LeaveVT;
     pScrn->LeaveVT = glxDRILeaveVT;
 
-    LogMessage(X_INFO,
-	       "AIGLX: Loaded and initialized %s\n", driverName);
+    LogMessage(X_INFO, "AIGLX: Loaded and initialized %s\n", driverName);
 
     return &screen->base;