xserver git update 11/5/2010

3 files changed, 1966 insertions, 1859 deletions

diff --git a/xorg-server/hw/xfree86/dri2/dri2.c b/xorg-server/hw/xfree86/dri2/dri2.c
index 6c4dabc41..abcb96668 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.c
+++ b/xorg-server/hw/xfree86/dri2/dri2.c
@@ -1,939 +1,1045 @@
-/*
- * Copyright © 2007, 2008 Red Hat, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Soft-
- * ware"), to deal in the Software without restriction, including without
- * limitation the rights to use, copy, modify, merge, publish, distribute,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, provided that the above copyright
- * notice(s) and this permission notice appear in all copies of the Soft-
- * ware and that both the above copyright notice(s) and this permission
- * notice appear in supporting documentation.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
- * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
- * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
- * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
- * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
- * MANCE OF THIS SOFTWARE.
- *
- * Except as contained in this notice, the name of a copyright holder shall
- * not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization of
- * the copyright holder.
- *
- * Authors:
- *   Kristian Høgsberg (krh@redhat.com)
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <errno.h>
-#include <xf86drm.h>
-#include "xf86Module.h"
-#include "scrnintstr.h"
-#include "windowstr.h"
-#include "dixstruct.h"
-#include "dri2.h"
-#include "xf86VGAarbiter.h"
-
-#include "xf86.h"
-
-CARD8 dri2_major; /* version of DRI2 supported by DDX */
-CARD8 dri2_minor;
-
-static int           dri2ScreenPrivateKeyIndex;
-static DevPrivateKey dri2ScreenPrivateKey = &dri2ScreenPrivateKeyIndex;
-static RESTYPE       dri2DrawableRes;
-
-typedef struct _DRI2Screen *DRI2ScreenPtr;
-
-typedef struct _DRI2Drawable {
-    DRI2ScreenPtr        dri2_screen;
-    int			 width;
-    int			 height;
-    DRI2BufferPtr	*buffers;
-    int			 bufferCount;
-    unsigned int	 swapsPending;
-    ClientPtr		 blockedClient;
-    Bool		 blockedOnMsc;
-    int			 swap_interval;
-    CARD64		 swap_count;
-    int64_t		 target_sbc; /* -1 means no SBC wait outstanding */
-    CARD64		 last_swap_target; /* most recently queued swap target */
-    CARD64		 last_swap_msc; /* msc at completion of most recent swap */
-    CARD64		 last_swap_ust; /* ust at completion of most recent swap */
-    int			 swap_limit; /* for N-buffering */
-} DRI2DrawableRec, *DRI2DrawablePtr;
-
-typedef struct _DRI2Screen {
-    ScreenPtr			 screen;
-    unsigned int		 numDrivers;
-    const char			**driverNames;
-    const char			*deviceName;
-    int				 fd;
-    unsigned int		 lastSequence;
-
-    DRI2CreateBufferProcPtr	 CreateBuffer;
-    DRI2DestroyBufferProcPtr	 DestroyBuffer;
-    DRI2CopyRegionProcPtr	 CopyRegion;
-    DRI2ScheduleSwapProcPtr	 ScheduleSwap;
-    DRI2GetMSCProcPtr		 GetMSC;
-    DRI2ScheduleWaitMSCProcPtr	 ScheduleWaitMSC;
-
-    HandleExposuresProcPtr       HandleExposures;
-} DRI2ScreenRec;
-
-static DRI2ScreenPtr
-DRI2GetScreen(ScreenPtr pScreen)
-{
-    return dixLookupPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey);
-}
-
-static DRI2DrawablePtr
-DRI2GetDrawable(DrawablePtr pDraw)
-{
-    DRI2DrawablePtr pPriv;
-    int rc;
-
-    rc = dixLookupResourceByType((pointer *) &pPriv, pDraw->id,
-				 dri2DrawableRes, NULL, DixReadAccess);
-    if (rc != Success)
-	return NULL;
-
-    return pPriv;
-}
-
-int
-DRI2CreateDrawable(DrawablePtr pDraw)
-{
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    CARD64          ust;
-    int		    rc;
-
-    rc = dixLookupResourceByType((pointer *) &pPriv, pDraw->id,
-				 dri2DrawableRes, NULL, DixReadAccess);
-    if (rc == Success || rc != BadValue)
-	return rc;
-
-    pPriv = xalloc(sizeof *pPriv);
-    if (pPriv == NULL)
-	return BadAlloc;
-
-    pPriv->dri2_screen = ds;
-    pPriv->width = pDraw->width;
-    pPriv->height = pDraw->height;
-    pPriv->buffers = NULL;
-    pPriv->bufferCount = 0;
-    pPriv->swapsPending = 0;
-    pPriv->blockedClient = NULL;
-    pPriv->blockedOnMsc = FALSE;
-    pPriv->swap_count = 0;
-    pPriv->target_sbc = -1;
-    pPriv->swap_interval = 1;
-    /* Initialize last swap target from DDX if possible */
-    if (!ds->GetMSC || !(*ds->GetMSC)(pDraw, &ust, &pPriv->last_swap_target))
-	pPriv->last_swap_target = 0;
-
-    pPriv->swap_limit = 1; /* default to double buffering */
-    pPriv->last_swap_msc = 0;
-    pPriv->last_swap_ust = 0;
-
-    if (!AddResource(pDraw->id, dri2DrawableRes, pPriv))
-	return BadAlloc;
-
-    return Success;
-}
-
-static int DRI2DrawableGone(pointer p, XID id)
-{
-    DRI2DrawablePtr pPriv = p;
-    DRI2ScreenPtr   ds = pPriv->dri2_screen;
-    DrawablePtr     root;
-    int i;
-
-    root = &WindowTable[ds->screen->myNum]->drawable;
-    if (pPriv->buffers != NULL) {
-	for (i = 0; i < pPriv->bufferCount; i++)
-	    (*ds->DestroyBuffer)(root, pPriv->buffers[i]);
-
-	xfree(pPriv->buffers);
-    }
-
-    xfree(pPriv);
-
-    return Success;
-}
-
-static int
-find_attachment(DRI2DrawablePtr pPriv, unsigned attachment)
-{
-    int i;
-
-    if (pPriv->buffers == NULL) {
-	return -1;
-    }
-
-    for (i = 0; i < pPriv->bufferCount; i++) {
-	if ((pPriv->buffers[i] != NULL)
-	    && (pPriv->buffers[i]->attachment == attachment)) {
-	    return i;
-	}
-    }
-
-    return -1;
-}
-
-static Bool
-allocate_or_reuse_buffer(DrawablePtr pDraw, DRI2ScreenPtr ds,
-			 DRI2DrawablePtr pPriv,
-			 unsigned int attachment, unsigned int format,
-			 int dimensions_match, DRI2BufferPtr *buffer)
-{
-    int old_buf = find_attachment(pPriv, attachment);
-
-    if ((old_buf < 0)
-	|| !dimensions_match
-	|| (pPriv->buffers[old_buf]->format != format)) {
-	*buffer = (*ds->CreateBuffer)(pDraw, attachment, format);
-	return TRUE;
-
-    } else {
-	*buffer = pPriv->buffers[old_buf];
-	pPriv->buffers[old_buf] = NULL;
-	return FALSE;
-    }
-}
-
-static DRI2BufferPtr *
-do_get_buffers(DrawablePtr pDraw, int *width, int *height,
-	       unsigned int *attachments, int count, int *out_count,
-	       int has_format)
-{
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
-    DRI2BufferPtr  *buffers;
-    int need_real_front = 0;
-    int need_fake_front = 0;
-    int have_fake_front = 0;
-    int front_format = 0;
-    int dimensions_match;
-    int buffers_changed = 0;
-    int i;
-
-    if (!pPriv) {
-	*width = pDraw->width;
-	*height = pDraw->height;
-	*out_count = 0;
-	return NULL;
-    }
-
-    dimensions_match = (pDraw->width == pPriv->width)
-	&& (pDraw->height == pPriv->height);
-
-    buffers = xalloc((count + 1) * sizeof(buffers[0]));
-
-    for (i = 0; i < count; i++) {
-	const unsigned attachment = *(attachments++);
-	const unsigned format = (has_format) ? *(attachments++) : 0;
-
-	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, attachment,
-				     format, dimensions_match,
-				     &buffers[i]))
-		buffers_changed = 1;
-
-	/* If the drawable is a window and the front-buffer is requested,
-	 * silently add the fake front-buffer to the list of requested
-	 * attachments.  The counting logic in the loop accounts for the case
-	 * where the client requests both the fake and real front-buffer.
-	 */
-	if (attachment == DRI2BufferBackLeft) {
-	    need_real_front++;
-	    front_format = format;
-	}
-
-	if (attachment == DRI2BufferFrontLeft) {
-	    need_real_front--;
-	    front_format = format;
-
-	    if (pDraw->type == DRAWABLE_WINDOW) {
-		need_fake_front++;
-	    }
-	}
-
-	if (pDraw->type == DRAWABLE_WINDOW) {
-	    if (attachment == DRI2BufferFakeFrontLeft) {
-		need_fake_front--;
-		have_fake_front = 1;
-	    }
-	}
-    }
-
-    if (need_real_front > 0) {
-	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFrontLeft,
-				     front_format, dimensions_match,
-				     &buffers[i++]))
-	    buffers_changed = 1;
-    }
-
-    if (need_fake_front > 0) {
-	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFakeFrontLeft,
-				     front_format, dimensions_match,
-				     &buffers[i++]))
-	    buffers_changed = 1;
-
-	have_fake_front = 1;
-    }
-
-    *out_count = i;
-
-
-    if (pPriv->buffers != NULL) {
-	for (i = 0; i < pPriv->bufferCount; i++) {
-	    if (pPriv->buffers[i] != NULL) {
-		(*ds->DestroyBuffer)(pDraw, pPriv->buffers[i]);
-	    }
-	}
-
-	xfree(pPriv->buffers);
-    }
-
-    pPriv->buffers = buffers;
-    pPriv->bufferCount = *out_count;
-    pPriv->width = pDraw->width;
-    pPriv->height = pDraw->height;
-    *width = pPriv->width;
-    *height = pPriv->height;
-
-
-    /* If the client is getting a fake front-buffer, pre-fill it with the
-     * contents of the real front-buffer.  This ensures correct operation of
-     * applications that call glXWaitX before calling glDrawBuffer.
-     */
-    if (have_fake_front && buffers_changed) {
-	BoxRec box;
-	RegionRec region;
-
-	box.x1 = 0;
-	box.y1 = 0;
-	box.x2 = pPriv->width;
-	box.y2 = pPriv->height;
-	REGION_INIT(pDraw->pScreen, &region, &box, 0);
-
-	DRI2CopyRegion(pDraw, &region, DRI2BufferFakeFrontLeft,
-		       DRI2BufferFrontLeft);
-    }
-
-    return pPriv->buffers;
-}
-
-DRI2BufferPtr *
-DRI2GetBuffers(DrawablePtr pDraw, int *width, int *height,
-	       unsigned int *attachments, int count, int *out_count)
-{
-    return do_get_buffers(pDraw, width, height, attachments, count,
-			  out_count, FALSE);
-}
-
-DRI2BufferPtr *
-DRI2GetBuffersWithFormat(DrawablePtr pDraw, int *width, int *height,
-			 unsigned int *attachments, int count, int *out_count)
-{
-    return do_get_buffers(pDraw, width, height, attachments, count,
-			  out_count, TRUE);
-}
-
-/*
- * In the direct rendered case, we throttle the clients that have more
- * than their share of outstanding swaps (and thus busy buffers) when a
- * new GetBuffers request is received.  In the AIGLX case, we allow the
- * client to get the new buffers, but throttle when the next GLX request
- * comes in (see __glXDRIcontextWait()).
- */
-Bool
-DRI2ThrottleClient(ClientPtr client, DrawablePtr pDraw)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return FALSE;
-
-    /* Throttle to swap limit */
-    if ((pPriv->swapsPending >= pPriv->swap_limit) &&
-	!pPriv->blockedClient) {
-	ResetCurrentRequest(client);
-	client->sequence--;
-	IgnoreClient(client);
-	pPriv->blockedClient = client;
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-static void
-__DRI2BlockClient(ClientPtr client, DRI2DrawablePtr pPriv)
-{
-    if (pPriv->blockedClient == NULL) {
-	IgnoreClient(client);
-	pPriv->blockedClient = client;
-    }
-}
-
-void
-DRI2BlockClient(ClientPtr client, DrawablePtr pDraw)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return;
-
-    __DRI2BlockClient(client, pPriv);
-    pPriv->blockedOnMsc = TRUE;
-}
-
-int
-DRI2CopyRegion(DrawablePtr pDraw, RegionPtr pRegion,
-	       unsigned int dest, unsigned int src)
-{
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    DRI2BufferPtr   pDestBuffer, pSrcBuffer;
-    int		    i;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return BadDrawable;
-
-    pDestBuffer = NULL;
-    pSrcBuffer = NULL;
-    for (i = 0; i < pPriv->bufferCount; i++)
-    {
-	if (pPriv->buffers[i]->attachment == dest)
-	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-	if (pPriv->buffers[i]->attachment == src)
-	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-    }
-    if (pSrcBuffer == NULL || pDestBuffer == NULL)
-	return BadValue;
-
-    (*ds->CopyRegion)(pDraw, pRegion, pDestBuffer, pSrcBuffer);
-
-    return Success;
-}
-
-/* Can this drawable be page flipped? */
-Bool
-DRI2CanFlip(DrawablePtr pDraw)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-    WindowPtr pWin, pRoot;
-    PixmapPtr pWinPixmap, pRootPixmap;
-
-    if (pDraw->type == DRAWABLE_PIXMAP)
-	return TRUE;
-
-    pRoot = WindowTable[pScreen->myNum];
-    pRootPixmap = pScreen->GetWindowPixmap(pRoot);
-
-    pWin = (WindowPtr) pDraw;
-    pWinPixmap = pScreen->GetWindowPixmap(pWin);
-    if (pRootPixmap != pWinPixmap)
-	return FALSE;
-    if (!REGION_EQUAL(pScreen, &pWin->clipList, &pRoot->winSize))
-	return FALSE;
-
-    return TRUE;
-}
-
-/* Can we do a pixmap exchange instead of a blit? */
-Bool
-DRI2CanExchange(DrawablePtr pDraw)
-{
-    return FALSE;
-}
-
-void
-DRI2WaitMSCComplete(ClientPtr client, DrawablePtr pDraw, int frame,
-		    unsigned int tv_sec, unsigned int tv_usec)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return;
-
-    ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,
-			 frame, pPriv->swap_count);
-
-    if (pPriv->blockedClient)
-	AttendClient(pPriv->blockedClient);
-
-    pPriv->blockedClient = NULL;
-    pPriv->blockedOnMsc = FALSE;
-}
-
-static void
-DRI2WakeClient(ClientPtr client, DrawablePtr pDraw, int frame,
-	       unsigned int tv_sec, unsigned int tv_usec)
-{
-    ScreenPtr	    pScreen = pDraw->pScreen;
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return;
-    }
-
-    /*
-     * Swap completed.
-     * Wake the client iff:
-     *   - it was waiting on SBC
-     *   - was blocked due to GLX make current
-     *   - was blocked due to swap throttling
-     *   - is not blocked due to an MSC wait
-     */
-    if (pPriv->target_sbc != -1 &&
-	pPriv->target_sbc <= pPriv->swap_count) {
-	ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,
-			     frame, pPriv->swap_count);
-	pPriv->target_sbc = -1;
-
-	AttendClient(pPriv->blockedClient);
-	pPriv->blockedClient = NULL;
-    } else if (pPriv->target_sbc == -1 && !pPriv->blockedOnMsc) {
-	if (pPriv->blockedClient) {
-	    AttendClient(pPriv->blockedClient);
-	    pPriv->blockedClient = NULL;
-	}
-    }
-}
-
-void
-DRI2SwapComplete(ClientPtr client, DrawablePtr pDraw, int frame,
-		   unsigned int tv_sec, unsigned int tv_usec, int type,
-		   DRI2SwapEventPtr swap_complete, void *swap_data)
-{
-    ScreenPtr	    pScreen = pDraw->pScreen;
-    DRI2DrawablePtr pPriv;
-    CARD64          ust = 0;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return;
-    }
-
-    pPriv->swapsPending--;
-    pPriv->swap_count++;
-
-    ust = ((CARD64)tv_sec * 1000000) + tv_usec;
-    if (swap_complete)
-	swap_complete(client, swap_data, type, ust, frame, pPriv->swap_count);
-
-    pPriv->last_swap_msc = frame;
-    pPriv->last_swap_ust = ust;
-
-    DRI2WakeClient(client, pDraw, frame, tv_sec, tv_usec);
-}
-
-Bool
-DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable)
-{
-    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);
-
-    /* If we're currently waiting for a swap on this drawable, reset
-     * the request and suspend the client.  We only support one
-     * blocked client per drawable. */
-    if ((pPriv->swapsPending) &&
-	pPriv->blockedClient == NULL) {
-	ResetCurrentRequest(client);
-	client->sequence--;
-	__DRI2BlockClient(client, pPriv);
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-int
-DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
-		CARD64 divisor, CARD64 remainder, CARD64 *swap_target,
-		DRI2SwapEventPtr func, void *data)
-{
-    ScreenPtr       pScreen = pDraw->pScreen;
-    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    DRI2BufferPtr   pDestBuffer = NULL, pSrcBuffer = NULL;
-    int             ret, i;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return BadDrawable;
-    }
-
-    for (i = 0; i < pPriv->bufferCount; i++) {
-	if (pPriv->buffers[i]->attachment == DRI2BufferFrontLeft)
-	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-	if (pPriv->buffers[i]->attachment == DRI2BufferBackLeft)
-	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];
-    }
-    if (pSrcBuffer == NULL || pDestBuffer == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: drawable has no back or front?\n", __func__);
-	return BadDrawable;
-    }
-
-    /* Old DDX or no swap interval, just blit */
-    if (!ds->ScheduleSwap || !pPriv->swap_interval) {
-	BoxRec box;
-	RegionRec region;
-
-	box.x1 = 0;
-	box.y1 = 0;
-	box.x2 = pDraw->width;
-	box.y2 = pDraw->height;
-	REGION_INIT(pScreen, &region, &box, 0);
-
-	pPriv->swapsPending++;
-
-	(*ds->CopyRegion)(pDraw, &region, pDestBuffer, pSrcBuffer);
-	DRI2SwapComplete(client, pDraw, target_msc, 0, 0, DRI2_BLIT_COMPLETE,
-			 func, data);
-	return Success;
-    }
-
-    /*
-     * In the simple glXSwapBuffers case, all params will be 0, and we just
-     * need to schedule a swap for the last swap target + the swap interval.
-     */
-    if (target_msc == 0 && divisor == 0 && remainder == 0) {
-	/*
-	 * Swap target for this swap is last swap target + swap interval since
-	 * we have to account for the current swap count, interval, and the
-	 * number of pending swaps.
-	 */
-	*swap_target = pPriv->last_swap_target + pPriv->swap_interval;
-    } else {
-	/* glXSwapBuffersMscOML could have a 0 target_msc, honor it */
-	*swap_target = target_msc;
-    }
-
-    pPriv->swapsPending++;
-    ret = (*ds->ScheduleSwap)(client, pDraw, pDestBuffer, pSrcBuffer,
-			      swap_target, divisor, remainder, func, data);
-    if (!ret) {
-	pPriv->swapsPending--; /* didn't schedule */
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: driver failed to schedule swap\n", __func__);
-	return BadDrawable;
-    }
-
-    pPriv->last_swap_target = *swap_target;
-
-    /* According to spec, return expected swapbuffers count SBC after this swap
-     * will complete.
-     */
-    *swap_target = pPriv->swap_count + pPriv->swapsPending;
-
-    return Success;
-}
-
-void
-DRI2SwapInterval(DrawablePtr pDrawable, int interval)
-{
-    ScreenPtr       pScreen = pDrawable->pScreen;
-    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);
-
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return;
-    }
-
-    /* fixme: check against arbitrary max? */
-    pPriv->swap_interval = interval;
-}
-
-int
-DRI2GetMSC(DrawablePtr pDraw, CARD64 *ust, CARD64 *msc, CARD64 *sbc)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    Bool ret;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL) {
-        xf86DrvMsg(pScreen->myNum, X_ERROR,
-		   "[DRI2] %s: bad drawable\n", __func__);
-	return BadDrawable;
-    }
-
-    if (!ds->GetMSC) {
-	*ust = 0;
-	*msc = 0;
-	*sbc = pPriv->swap_count;
-	return Success;
-    }
-
-    /*
-     * Spec needs to be updated to include unmapped or redirected
-     * drawables
-     */
-
-    ret = (*ds->GetMSC)(pDraw, ust, msc);
-    if (!ret)
-	return BadDrawable;
-
-    *sbc = pPriv->swap_count;
-
-    return Success;
-}
-
-int
-DRI2WaitMSC(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
-	    CARD64 divisor, CARD64 remainder)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);
-    DRI2DrawablePtr pPriv;
-    Bool ret;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return BadDrawable;
-
-    /* Old DDX just completes immediately */
-    if (!ds->ScheduleWaitMSC) {
-	DRI2WaitMSCComplete(client, pDraw, target_msc, 0, 0);
-
-	return Success;
-    }
-
-    ret = (*ds->ScheduleWaitMSC)(client, pDraw, target_msc, divisor, remainder);
-    if (!ret)
-	return BadDrawable;
-
-    return Success;
-}
-
-int
-DRI2WaitSBC(ClientPtr client, DrawablePtr pDraw, CARD64 target_sbc,
-	    CARD64 *ust, CARD64 *msc, CARD64 *sbc)
-{
-    DRI2DrawablePtr pPriv;
-
-    pPriv = DRI2GetDrawable(pDraw);
-    if (pPriv == NULL)
-	return BadDrawable;
-
-    /* target_sbc == 0 means to block until all pending swaps are
-     * finished. Recalculate target_sbc to get that behaviour.
-     */
-    if (target_sbc == 0)
-        target_sbc = pPriv->swap_count + pPriv->swapsPending;
-
-    /* If current swap count already >= target_sbc,
-     * return immediately with (ust, msc, sbc) triplet of
-     * most recent completed swap.
-     */
-    if (pPriv->swap_count >= target_sbc) {
-        *sbc = pPriv->swap_count;
-        *msc = pPriv->last_swap_msc;
-        *ust = pPriv->last_swap_ust;
-        return Success;
-    }
-
-    pPriv->target_sbc = target_sbc;
-    __DRI2BlockClient(client, pPriv);
-
-    return Success;
-}
-
-Bool
-DRI2HasSwapControl(ScreenPtr pScreen)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    return (ds->ScheduleSwap && ds->GetMSC);
-}
-
-Bool
-DRI2Connect(ScreenPtr pScreen, unsigned int driverType, int *fd,
-	    const char **driverName, const char **deviceName)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    if (ds == NULL || driverType >= ds->numDrivers ||
-	    !ds->driverNames[driverType])
-	return FALSE;
-
-    *fd = ds->fd;
-    *driverName = ds->driverNames[driverType];
-    *deviceName = ds->deviceName;
-
-    return TRUE;
-}
-
-Bool
-DRI2Authenticate(ScreenPtr pScreen, drm_magic_t magic)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    if (ds == NULL || drmAuthMagic(ds->fd, magic))
-	return FALSE;
-
-    return TRUE;
-}
-
-Bool
-DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info)
-{
-    DRI2ScreenPtr ds;
-    const char* driverTypeNames[] = {
-	"DRI", /* DRI2DriverDRI */
-	"VDPAU", /* DRI2DriverVDPAU */
-    };
-    unsigned int i;
-    CARD8 cur_minor;
-
-    if (info->version < 3)
-	return FALSE;
-
-    if (!xf86VGAarbiterAllowDRI(pScreen)) {
-        xf86DrvMsg(pScreen->myNum, X_WARNING,
-                  "[DRI2] Direct rendering is not supported when VGA arb is necessary for the device\n");
-        return FALSE;
-    }
-
-    ds = xcalloc(1, sizeof *ds);
-    if (!ds)
-	return FALSE;
-
-    ds->screen         = pScreen;
-    ds->fd	       = info->fd;
-    ds->deviceName     = info->deviceName;
-    dri2_major         = 1;
-
-    ds->CreateBuffer   = info->CreateBuffer;
-    ds->DestroyBuffer  = info->DestroyBuffer;
-    ds->CopyRegion     = info->CopyRegion;
-
-    if (info->version >= 4) {
-	ds->ScheduleSwap = info->ScheduleSwap;
-	ds->ScheduleWaitMSC = info->ScheduleWaitMSC;
-	ds->GetMSC = info->GetMSC;
-	cur_minor = 2;
-    } else {
-	cur_minor = 1;
-    }
-
-    /* Initialize minor if needed and set to minimum provied by DDX */
-    if (!dri2_minor || dri2_minor > cur_minor)
-	dri2_minor = cur_minor;
-
-    if (info->version == 3 || info->numDrivers == 0) {
-	/* Driver too old: use the old-style driverName field */
-	ds->numDrivers = 1;
-	ds->driverNames = xalloc(sizeof(*ds->driverNames));
-	if (!ds->driverNames) {
-	    xfree(ds);
-	    return FALSE;
-	}
-	ds->driverNames[0] = info->driverName;
-    } else {
-	ds->numDrivers = info->numDrivers;
-	ds->driverNames = xalloc(info->numDrivers * sizeof(*ds->driverNames));
-	if (!ds->driverNames) {
-	    xfree(ds);
-	    return FALSE;
-	}
-	memcpy(ds->driverNames, info->driverNames,
-	       info->numDrivers * sizeof(*ds->driverNames));
-    }
-
-    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, ds);
-
-    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2] Setup complete\n");
-    for (i = 0; i < sizeof(driverTypeNames) / sizeof(driverTypeNames[0]); i++) {
-	if (i < ds->numDrivers && ds->driverNames[i]) {
-	    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2]   %s driver: %s\n",
-		       driverTypeNames[i], ds->driverNames[i]);
-	}
-    }
-
-    return TRUE;
-}
-
-void
-DRI2CloseScreen(ScreenPtr pScreen)
-{
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
-
-    xfree(ds->driverNames);
-    xfree(ds);
-    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, NULL);
-}
-
-extern ExtensionModule dri2ExtensionModule;
-
-static pointer
-DRI2Setup(pointer module, pointer opts, int *errmaj, int *errmin)
-{
-    static Bool setupDone = FALSE;
-
-    dri2DrawableRes = CreateNewResourceType(DRI2DrawableGone, "DRI2Drawable");
-
-    if (!setupDone)
-    {
-	setupDone = TRUE;
-	LoadExtension(&dri2ExtensionModule, FALSE);
-    }
-    else
-    {
-	if (errmaj)
-	    *errmaj = LDR_ONCEONLY;
-    }
-
-    return (pointer) 1;
-}
-
-static XF86ModuleVersionInfo DRI2VersRec =
-{
-    "dri2",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    1, 2, 0,
-    ABI_CLASS_EXTENSION,
-    ABI_EXTENSION_VERSION,
-    MOD_CLASS_NONE,
-    { 0, 0, 0, 0 }
-};
-
-_X_EXPORT XF86ModuleData dri2ModuleData = { &DRI2VersRec, DRI2Setup, NULL };
-
-void
-DRI2Version(int *major, int *minor)
-{
-    if (major != NULL)
-	*major = DRI2VersRec.majorversion;
-
-    if (minor != NULL)
-	*minor = DRI2VersRec.minorversion;
-}
+/*

+ * Copyright © 2007, 2008 Red Hat, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Soft-

+ * ware"), to deal in the Software without restriction, including without

+ * limitation the rights to use, copy, modify, merge, publish, distribute,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, provided that the above copyright

+ * notice(s) and this permission notice appear in all copies of the Soft-

+ * ware and that both the above copyright notice(s) and this permission

+ * notice appear in supporting documentation.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-

+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY

+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN

+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-

+ * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-

+ * MANCE OF THIS SOFTWARE.

+ *

+ * Except as contained in this notice, the name of a copyright holder shall

+ * not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization of

+ * the copyright holder.

+ *

+ * Authors:

+ *   Kristian Høgsberg (krh@redhat.com)

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <errno.h>

+#include <xf86drm.h>

+#include "xf86Module.h"

+#include "list.h"

+#include "scrnintstr.h"

+#include "windowstr.h"

+#include "dixstruct.h"

+#include "dri2.h"

+#include "xf86VGAarbiter.h"

+

+#include "xf86.h"

+

+CARD8 dri2_major; /* version of DRI2 supported by DDX */

+CARD8 dri2_minor;

+

+static int           dri2ScreenPrivateKeyIndex;

+static DevPrivateKey dri2ScreenPrivateKey = &dri2ScreenPrivateKeyIndex;

+static int dri2WindowPrivateKeyIndex;

+static DevPrivateKey dri2WindowPrivateKey = &dri2WindowPrivateKeyIndex;

+static int dri2PixmapPrivateKeyIndex;

+static DevPrivateKey dri2PixmapPrivateKey = &dri2PixmapPrivateKeyIndex;

+static RESTYPE       dri2DrawableRes;

+

+typedef struct _DRI2Screen *DRI2ScreenPtr;

+

+typedef struct _DRI2Drawable {

+    DRI2ScreenPtr        dri2_screen;

+    DrawablePtr		 drawable;

+    struct list		 reference_list;

+    int			 width;

+    int			 height;

+    DRI2BufferPtr	*buffers;

+    int			 bufferCount;

+    unsigned int	 swapsPending;

+    ClientPtr		 blockedClient;

+    Bool		 blockedOnMsc;

+    int			 swap_interval;

+    CARD64		 swap_count;

+    int64_t		 target_sbc; /* -1 means no SBC wait outstanding */

+    CARD64		 last_swap_target; /* most recently queued swap target */

+    CARD64		 last_swap_msc; /* msc at completion of most recent swap */

+    CARD64		 last_swap_ust; /* ust at completion of most recent swap */

+    int			 swap_limit; /* for N-buffering */

+} DRI2DrawableRec, *DRI2DrawablePtr;

+

+typedef struct _DRI2Screen {

+    ScreenPtr			 screen;

+    int				 refcnt;

+    unsigned int		 numDrivers;

+    const char			**driverNames;

+    const char			*deviceName;

+    int				 fd;

+    unsigned int		 lastSequence;

+

+    DRI2CreateBufferProcPtr	 CreateBuffer;

+    DRI2DestroyBufferProcPtr	 DestroyBuffer;

+    DRI2CopyRegionProcPtr	 CopyRegion;

+    DRI2ScheduleSwapProcPtr	 ScheduleSwap;

+    DRI2GetMSCProcPtr		 GetMSC;

+    DRI2ScheduleWaitMSCProcPtr	 ScheduleWaitMSC;

+

+    HandleExposuresProcPtr       HandleExposures;

+} DRI2ScreenRec;

+

+static DRI2ScreenPtr

+DRI2GetScreen(ScreenPtr pScreen)

+{

+    return dixLookupPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey);

+}

+

+static DRI2DrawablePtr

+DRI2GetDrawable(DrawablePtr pDraw)

+{

+    WindowPtr pWin;

+    PixmapPtr pPixmap;

+

+    if (pDraw->type == DRAWABLE_WINDOW) {

+	pWin = (WindowPtr) pDraw;

+	return dixLookupPrivate(&pWin->devPrivates, dri2WindowPrivateKey);

+    } else {

+	pPixmap = (PixmapPtr) pDraw;

+	return dixLookupPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey);

+    }

+}

+

+static DRI2DrawablePtr

+DRI2AllocateDrawable(DrawablePtr pDraw)

+{

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    CARD64          ust;

+    WindowPtr pWin;

+    PixmapPtr pPixmap;

+

+    pPriv = xalloc(sizeof *pPriv);

+    if (pPriv == NULL)

+	return NULL;

+

+    pPriv->dri2_screen = ds;

+    pPriv->drawable = pDraw;

+    pPriv->width = pDraw->width;

+    pPriv->height = pDraw->height;

+    pPriv->buffers = NULL;

+    pPriv->bufferCount = 0;

+    pPriv->swapsPending = 0;

+    pPriv->blockedClient = NULL;

+    pPriv->blockedOnMsc = FALSE;

+    pPriv->swap_count = 0;

+    pPriv->target_sbc = -1;

+    pPriv->swap_interval = 1;

+    /* Initialize last swap target from DDX if possible */

+    if (!ds->GetMSC || !(*ds->GetMSC)(pDraw, &ust, &pPriv->last_swap_target))

+	pPriv->last_swap_target = 0;

+

+    pPriv->swap_limit = 1; /* default to double buffering */

+    pPriv->last_swap_msc = 0;

+    pPriv->last_swap_ust = 0;

+    list_init(&pPriv->reference_list);

+

+    if (pDraw->type == DRAWABLE_WINDOW) {

+	pWin = (WindowPtr) pDraw;

+	dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, pPriv);

+    } else {

+	pPixmap = (PixmapPtr) pDraw;

+	dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, pPriv);

+    }

+

+    return pPriv;

+}

+

+typedef struct DRI2DrawableRefRec {

+    XID id;

+    XID dri2_id;

+    struct list link;

+} DRI2DrawableRefRec, *DRI2DrawableRefPtr;

+

+static DRI2DrawableRefPtr

+DRI2LookupDrawableRef(DRI2DrawablePtr pPriv, XID id)

+{

+    DRI2DrawableRefPtr ref;

+

+    list_for_each_entry(ref, &pPriv->reference_list, link) {

+	if (ref->id == id)

+	    return ref;

+    }

+    

+    return NULL;

+}

+

+static int

+DRI2AddDrawableRef(DRI2DrawablePtr pPriv, XID id, XID dri2_id)

+{

+    DRI2DrawableRefPtr ref;

+

+    ref = malloc(sizeof *ref);

+    if (ref == NULL)

+	return BadAlloc;

+	

+    if (!AddResource(dri2_id, dri2DrawableRes, pPriv))

+	return BadAlloc;

+    if (!DRI2LookupDrawableRef(pPriv, id))

+	if (!AddResource(id, dri2DrawableRes, pPriv))

+	    return BadAlloc;

+

+    ref->id = id;

+    ref->dri2_id = dri2_id; 

+    list_add(&ref->link, &pPriv->reference_list);

+

+    return Success;

+}

+

+int

+DRI2CreateDrawable(ClientPtr client, DrawablePtr pDraw, XID id)

+{

+    DRI2DrawablePtr pPriv;

+    XID dri2_id;

+    int rc;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	pPriv = DRI2AllocateDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadAlloc;

+    

+    dri2_id = FakeClientID(client->index);

+    rc = DRI2AddDrawableRef(pPriv, id, dri2_id);

+    if (rc != Success)

+	return rc;

+

+    return Success;

+}

+

+static int DRI2DrawableGone(pointer p, XID id)

+{

+    DRI2DrawablePtr pPriv = p;

+    DRI2ScreenPtr   ds = pPriv->dri2_screen;

+    DRI2DrawableRefPtr ref, next;

+    WindowPtr pWin;

+    PixmapPtr pPixmap;

+    DrawablePtr pDraw;

+    int i;

+

+    list_for_each_entry_safe(ref, next, &pPriv->reference_list, link) {

+	if (ref->dri2_id == id) {

+	    list_del(&ref->link);

+	    /* If this was the last ref under this X drawable XID,

+	     * unregister the X drawable resource. */

+	    if (!DRI2LookupDrawableRef(pPriv, ref->id))

+		FreeResourceByType(ref->id, dri2DrawableRes, TRUE);

+	    free(ref);

+	    break;

+	}

+

+	if (ref->id == id) {

+	    list_del(&ref->link);

+	    FreeResourceByType(ref->dri2_id, dri2DrawableRes, TRUE);

+	    free(ref);

+	}

+    }

+

+    if (!list_is_empty(&pPriv->reference_list))

+	return Success;

+

+    pDraw = pPriv->drawable;

+    if (pDraw->type == DRAWABLE_WINDOW) {

+	pWin = (WindowPtr) pDraw;

+	dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, NULL);

+    } else {

+	pPixmap = (PixmapPtr) pDraw;

+	dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, NULL);

+    }

+

+    if (pPriv->buffers != NULL) {

+	for (i = 0; i < pPriv->bufferCount; i++)

+	    (*ds->DestroyBuffer)(pDraw, pPriv->buffers[i]);

+

+	xfree(pPriv->buffers);

+    }

+

+    xfree(pPriv);

+

+    return Success;

+}

+

+static int

+find_attachment(DRI2DrawablePtr pPriv, unsigned attachment)

+{

+    int i;

+

+    if (pPriv->buffers == NULL) {

+	return -1;

+    }

+

+    for (i = 0; i < pPriv->bufferCount; i++) {

+	if ((pPriv->buffers[i] != NULL)

+	    && (pPriv->buffers[i]->attachment == attachment)) {

+	    return i;

+	}

+    }

+

+    return -1;

+}

+

+static Bool

+allocate_or_reuse_buffer(DrawablePtr pDraw, DRI2ScreenPtr ds,

+			 DRI2DrawablePtr pPriv,

+			 unsigned int attachment, unsigned int format,

+			 int dimensions_match, DRI2BufferPtr *buffer)

+{

+    int old_buf = find_attachment(pPriv, attachment);

+

+    if ((old_buf < 0)

+	|| !dimensions_match

+	|| (pPriv->buffers[old_buf]->format != format)) {

+	*buffer = (*ds->CreateBuffer)(pDraw, attachment, format);

+	return TRUE;

+

+    } else {

+	*buffer = pPriv->buffers[old_buf];

+	pPriv->buffers[old_buf] = NULL;

+	return FALSE;

+    }

+}

+

+static DRI2BufferPtr *

+do_get_buffers(DrawablePtr pDraw, int *width, int *height,

+	       unsigned int *attachments, int count, int *out_count,

+	       int has_format)

+{

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);

+    DRI2BufferPtr  *buffers;

+    int need_real_front = 0;

+    int need_fake_front = 0;

+    int have_fake_front = 0;

+    int front_format = 0;

+    int dimensions_match;

+    int buffers_changed = 0;

+    int i;

+

+    if (!pPriv) {

+	*width = pDraw->width;

+	*height = pDraw->height;

+	*out_count = 0;

+	return NULL;

+    }

+

+    dimensions_match = (pDraw->width == pPriv->width)

+	&& (pDraw->height == pPriv->height);

+

+    buffers = xalloc((count + 1) * sizeof(buffers[0]));

+

+    for (i = 0; i < count; i++) {

+	const unsigned attachment = *(attachments++);

+	const unsigned format = (has_format) ? *(attachments++) : 0;

+

+	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, attachment,

+				     format, dimensions_match,

+				     &buffers[i]))

+		buffers_changed = 1;

+

+	/* If the drawable is a window and the front-buffer is requested,

+	 * silently add the fake front-buffer to the list of requested

+	 * attachments.  The counting logic in the loop accounts for the case

+	 * where the client requests both the fake and real front-buffer.

+	 */

+	if (attachment == DRI2BufferBackLeft) {

+	    need_real_front++;

+	    front_format = format;

+	}

+

+	if (attachment == DRI2BufferFrontLeft) {

+	    need_real_front--;

+	    front_format = format;

+

+	    if (pDraw->type == DRAWABLE_WINDOW) {

+		need_fake_front++;

+	    }

+	}

+

+	if (pDraw->type == DRAWABLE_WINDOW) {

+	    if (attachment == DRI2BufferFakeFrontLeft) {

+		need_fake_front--;

+		have_fake_front = 1;

+	    }

+	}

+    }

+

+    if (need_real_front > 0) {

+	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFrontLeft,

+				     front_format, dimensions_match,

+				     &buffers[i++]))

+	    buffers_changed = 1;

+    }

+

+    if (need_fake_front > 0) {

+	if (allocate_or_reuse_buffer(pDraw, ds, pPriv, DRI2BufferFakeFrontLeft,

+				     front_format, dimensions_match,

+				     &buffers[i++]))

+	    buffers_changed = 1;

+

+	have_fake_front = 1;

+    }

+

+    *out_count = i;

+

+

+    if (pPriv->buffers != NULL) {

+	for (i = 0; i < pPriv->bufferCount; i++) {

+	    if (pPriv->buffers[i] != NULL) {

+		(*ds->DestroyBuffer)(pDraw, pPriv->buffers[i]);

+	    }

+	}

+

+	xfree(pPriv->buffers);

+    }

+

+    pPriv->buffers = buffers;

+    pPriv->bufferCount = *out_count;

+    pPriv->width = pDraw->width;

+    pPriv->height = pDraw->height;

+    *width = pPriv->width;

+    *height = pPriv->height;

+

+

+    /* If the client is getting a fake front-buffer, pre-fill it with the

+     * contents of the real front-buffer.  This ensures correct operation of

+     * applications that call glXWaitX before calling glDrawBuffer.

+     */

+    if (have_fake_front && buffers_changed) {

+	BoxRec box;

+	RegionRec region;

+

+	box.x1 = 0;

+	box.y1 = 0;

+	box.x2 = pPriv->width;

+	box.y2 = pPriv->height;

+	REGION_INIT(pDraw->pScreen, &region, &box, 0);

+

+	DRI2CopyRegion(pDraw, &region, DRI2BufferFakeFrontLeft,

+		       DRI2BufferFrontLeft);

+    }

+

+    return pPriv->buffers;

+}

+

+DRI2BufferPtr *

+DRI2GetBuffers(DrawablePtr pDraw, int *width, int *height,

+	       unsigned int *attachments, int count, int *out_count)

+{

+    return do_get_buffers(pDraw, width, height, attachments, count,

+			  out_count, FALSE);

+}

+

+DRI2BufferPtr *

+DRI2GetBuffersWithFormat(DrawablePtr pDraw, int *width, int *height,

+			 unsigned int *attachments, int count, int *out_count)

+{

+    return do_get_buffers(pDraw, width, height, attachments, count,

+			  out_count, TRUE);

+}

+

+/*

+ * In the direct rendered case, we throttle the clients that have more

+ * than their share of outstanding swaps (and thus busy buffers) when a

+ * new GetBuffers request is received.  In the AIGLX case, we allow the

+ * client to get the new buffers, but throttle when the next GLX request

+ * comes in (see __glXDRIcontextWait()).

+ */

+Bool

+DRI2ThrottleClient(ClientPtr client, DrawablePtr pDraw)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return FALSE;

+

+    /* Throttle to swap limit */

+    if ((pPriv->swapsPending >= pPriv->swap_limit) &&

+	!pPriv->blockedClient) {

+	ResetCurrentRequest(client);

+	client->sequence--;

+	IgnoreClient(client);

+	pPriv->blockedClient = client;

+	return TRUE;

+    }

+

+    return FALSE;

+}

+

+static void

+__DRI2BlockClient(ClientPtr client, DRI2DrawablePtr pPriv)

+{

+    if (pPriv->blockedClient == NULL) {

+	IgnoreClient(client);

+	pPriv->blockedClient = client;

+    }

+}

+

+void

+DRI2BlockClient(ClientPtr client, DrawablePtr pDraw)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return;

+

+    __DRI2BlockClient(client, pPriv);

+    pPriv->blockedOnMsc = TRUE;

+}

+

+int

+DRI2CopyRegion(DrawablePtr pDraw, RegionPtr pRegion,

+	       unsigned int dest, unsigned int src)

+{

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    DRI2BufferPtr   pDestBuffer, pSrcBuffer;

+    int		    i;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadDrawable;

+

+    pDestBuffer = NULL;

+    pSrcBuffer = NULL;

+    for (i = 0; i < pPriv->bufferCount; i++)

+    {

+	if (pPriv->buffers[i]->attachment == dest)

+	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+	if (pPriv->buffers[i]->attachment == src)

+	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+    }

+    if (pSrcBuffer == NULL || pDestBuffer == NULL)

+	return BadValue;

+

+    (*ds->CopyRegion)(pDraw, pRegion, pDestBuffer, pSrcBuffer);

+

+    return Success;

+}

+

+/* Can this drawable be page flipped? */

+Bool

+DRI2CanFlip(DrawablePtr pDraw)

+{

+    ScreenPtr pScreen = pDraw->pScreen;

+    WindowPtr pWin, pRoot;

+    PixmapPtr pWinPixmap, pRootPixmap;

+

+    if (pDraw->type == DRAWABLE_PIXMAP)

+	return TRUE;

+

+    pRoot = WindowTable[pScreen->myNum];

+    pRootPixmap = pScreen->GetWindowPixmap(pRoot);

+

+    pWin = (WindowPtr) pDraw;

+    pWinPixmap = pScreen->GetWindowPixmap(pWin);

+    if (pRootPixmap != pWinPixmap)

+	return FALSE;

+    if (!REGION_EQUAL(pScreen, &pWin->clipList, &pRoot->winSize))

+	return FALSE;

+

+    return TRUE;

+}

+

+/* Can we do a pixmap exchange instead of a blit? */

+Bool

+DRI2CanExchange(DrawablePtr pDraw)

+{

+    return FALSE;

+}

+

+void

+DRI2WaitMSCComplete(ClientPtr client, DrawablePtr pDraw, int frame,

+		    unsigned int tv_sec, unsigned int tv_usec)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return;

+

+    ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,

+			 frame, pPriv->swap_count);

+

+    if (pPriv->blockedClient)

+	AttendClient(pPriv->blockedClient);

+

+    pPriv->blockedClient = NULL;

+    pPriv->blockedOnMsc = FALSE;

+}

+

+static void

+DRI2WakeClient(ClientPtr client, DrawablePtr pDraw, int frame,

+	       unsigned int tv_sec, unsigned int tv_usec)

+{

+    ScreenPtr	    pScreen = pDraw->pScreen;

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return;

+    }

+

+    /*

+     * Swap completed.

+     * Wake the client iff:

+     *   - it was waiting on SBC

+     *   - was blocked due to GLX make current

+     *   - was blocked due to swap throttling

+     *   - is not blocked due to an MSC wait

+     */

+    if (pPriv->target_sbc != -1 &&

+	pPriv->target_sbc <= pPriv->swap_count) {

+	ProcDRI2WaitMSCReply(client, ((CARD64)tv_sec * 1000000) + tv_usec,

+			     frame, pPriv->swap_count);

+	pPriv->target_sbc = -1;

+

+	AttendClient(pPriv->blockedClient);

+	pPriv->blockedClient = NULL;

+    } else if (pPriv->target_sbc == -1 && !pPriv->blockedOnMsc) {

+	if (pPriv->blockedClient) {

+	    AttendClient(pPriv->blockedClient);

+	    pPriv->blockedClient = NULL;

+	}

+    }

+}

+

+void

+DRI2SwapComplete(ClientPtr client, DrawablePtr pDraw, int frame,

+		   unsigned int tv_sec, unsigned int tv_usec, int type,

+		   DRI2SwapEventPtr swap_complete, void *swap_data)

+{

+    ScreenPtr	    pScreen = pDraw->pScreen;

+    DRI2DrawablePtr pPriv;

+    CARD64          ust = 0;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return;

+    }

+

+    pPriv->swapsPending--;

+    pPriv->swap_count++;

+

+    ust = ((CARD64)tv_sec * 1000000) + tv_usec;

+    if (swap_complete)

+	swap_complete(client, swap_data, type, ust, frame, pPriv->swap_count);

+

+    pPriv->last_swap_msc = frame;

+    pPriv->last_swap_ust = ust;

+

+    DRI2WakeClient(client, pDraw, frame, tv_sec, tv_usec);

+}

+

+Bool

+DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable)

+{

+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);

+

+    /* If we're currently waiting for a swap on this drawable, reset

+     * the request and suspend the client.  We only support one

+     * blocked client per drawable. */

+    if ((pPriv->swapsPending) &&

+	pPriv->blockedClient == NULL) {

+	ResetCurrentRequest(client);

+	client->sequence--;

+	__DRI2BlockClient(client, pPriv);

+	return TRUE;

+    }

+

+    return FALSE;

+}

+

+int

+DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,

+		CARD64 divisor, CARD64 remainder, CARD64 *swap_target,

+		DRI2SwapEventPtr func, void *data)

+{

+    ScreenPtr       pScreen = pDraw->pScreen;

+    DRI2ScreenPtr   ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    DRI2BufferPtr   pDestBuffer = NULL, pSrcBuffer = NULL;

+    int             ret, i;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return BadDrawable;

+    }

+

+    for (i = 0; i < pPriv->bufferCount; i++) {

+	if (pPriv->buffers[i]->attachment == DRI2BufferFrontLeft)

+	    pDestBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+	if (pPriv->buffers[i]->attachment == DRI2BufferBackLeft)

+	    pSrcBuffer = (DRI2BufferPtr) pPriv->buffers[i];

+    }

+    if (pSrcBuffer == NULL || pDestBuffer == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: drawable has no back or front?\n", __func__);

+	return BadDrawable;

+    }

+

+    /* Old DDX or no swap interval, just blit */

+    if (!ds->ScheduleSwap || !pPriv->swap_interval) {

+	BoxRec box;

+	RegionRec region;

+

+	box.x1 = 0;

+	box.y1 = 0;

+	box.x2 = pDraw->width;

+	box.y2 = pDraw->height;

+	REGION_INIT(pScreen, &region, &box, 0);

+

+	pPriv->swapsPending++;

+

+	(*ds->CopyRegion)(pDraw, &region, pDestBuffer, pSrcBuffer);

+	DRI2SwapComplete(client, pDraw, target_msc, 0, 0, DRI2_BLIT_COMPLETE,

+			 func, data);

+	return Success;

+    }

+

+    /*

+     * In the simple glXSwapBuffers case, all params will be 0, and we just

+     * need to schedule a swap for the last swap target + the swap interval.

+     */

+    if (target_msc == 0 && divisor == 0 && remainder == 0) {

+	/*

+	 * Swap target for this swap is last swap target + swap interval since

+	 * we have to account for the current swap count, interval, and the

+	 * number of pending swaps.

+	 */

+	*swap_target = pPriv->last_swap_target + pPriv->swap_interval;

+    } else {

+	/* glXSwapBuffersMscOML could have a 0 target_msc, honor it */

+	*swap_target = target_msc;

+    }

+

+    pPriv->swapsPending++;

+    ret = (*ds->ScheduleSwap)(client, pDraw, pDestBuffer, pSrcBuffer,

+			      swap_target, divisor, remainder, func, data);

+    if (!ret) {

+	pPriv->swapsPending--; /* didn't schedule */

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: driver failed to schedule swap\n", __func__);

+	return BadDrawable;

+    }

+

+    pPriv->last_swap_target = *swap_target;

+

+    /* According to spec, return expected swapbuffers count SBC after this swap

+     * will complete.

+     */

+    *swap_target = pPriv->swap_count + pPriv->swapsPending;

+

+    return Success;

+}

+

+void

+DRI2SwapInterval(DrawablePtr pDrawable, int interval)

+{

+    ScreenPtr       pScreen = pDrawable->pScreen;

+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDrawable);

+

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return;

+    }

+

+    /* fixme: check against arbitrary max? */

+    pPriv->swap_interval = interval;

+}

+

+int

+DRI2GetMSC(DrawablePtr pDraw, CARD64 *ust, CARD64 *msc, CARD64 *sbc)

+{

+    ScreenPtr pScreen = pDraw->pScreen;

+    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    Bool ret;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL) {

+        xf86DrvMsg(pScreen->myNum, X_ERROR,

+		   "[DRI2] %s: bad drawable\n", __func__);

+	return BadDrawable;

+    }

+

+    if (!ds->GetMSC) {

+	*ust = 0;

+	*msc = 0;

+	*sbc = pPriv->swap_count;

+	return Success;

+    }

+

+    /*

+     * Spec needs to be updated to include unmapped or redirected

+     * drawables

+     */

+

+    ret = (*ds->GetMSC)(pDraw, ust, msc);

+    if (!ret)

+	return BadDrawable;

+

+    *sbc = pPriv->swap_count;

+

+    return Success;

+}

+

+int

+DRI2WaitMSC(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,

+	    CARD64 divisor, CARD64 remainder)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);

+    DRI2DrawablePtr pPriv;

+    Bool ret;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadDrawable;

+

+    /* Old DDX just completes immediately */

+    if (!ds->ScheduleWaitMSC) {

+	DRI2WaitMSCComplete(client, pDraw, target_msc, 0, 0);

+

+	return Success;

+    }

+

+    ret = (*ds->ScheduleWaitMSC)(client, pDraw, target_msc, divisor, remainder);

+    if (!ret)

+	return BadDrawable;

+

+    return Success;

+}

+

+int

+DRI2WaitSBC(ClientPtr client, DrawablePtr pDraw, CARD64 target_sbc,

+	    CARD64 *ust, CARD64 *msc, CARD64 *sbc)

+{

+    DRI2DrawablePtr pPriv;

+

+    pPriv = DRI2GetDrawable(pDraw);

+    if (pPriv == NULL)

+	return BadDrawable;

+

+    /* target_sbc == 0 means to block until all pending swaps are

+     * finished. Recalculate target_sbc to get that behaviour.

+     */

+    if (target_sbc == 0)

+        target_sbc = pPriv->swap_count + pPriv->swapsPending;

+

+    /* If current swap count already >= target_sbc,

+     * return immediately with (ust, msc, sbc) triplet of

+     * most recent completed swap.

+     */

+    if (pPriv->swap_count >= target_sbc) {

+        *sbc = pPriv->swap_count;

+        *msc = pPriv->last_swap_msc;

+        *ust = pPriv->last_swap_ust;

+        return Success;

+    }

+

+    pPriv->target_sbc = target_sbc;

+    __DRI2BlockClient(client, pPriv);

+

+    return Success;

+}

+

+Bool

+DRI2HasSwapControl(ScreenPtr pScreen)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    return (ds->ScheduleSwap && ds->GetMSC);

+}

+

+Bool

+DRI2Connect(ScreenPtr pScreen, unsigned int driverType, int *fd,

+	    const char **driverName, const char **deviceName)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    if (ds == NULL || driverType >= ds->numDrivers ||

+	    !ds->driverNames[driverType])

+	return FALSE;

+

+    *fd = ds->fd;

+    *driverName = ds->driverNames[driverType];

+    *deviceName = ds->deviceName;

+

+    return TRUE;

+}

+

+Bool

+DRI2Authenticate(ScreenPtr pScreen, drm_magic_t magic)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    if (ds == NULL || drmAuthMagic(ds->fd, magic))

+	return FALSE;

+

+    return TRUE;

+}

+

+Bool

+DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info)

+{

+    DRI2ScreenPtr ds;

+    const char* driverTypeNames[] = {

+	"DRI", /* DRI2DriverDRI */

+	"VDPAU", /* DRI2DriverVDPAU */

+    };

+    unsigned int i;

+    CARD8 cur_minor;

+

+    if (info->version < 3)

+	return FALSE;

+

+    if (!xf86VGAarbiterAllowDRI(pScreen)) {

+        xf86DrvMsg(pScreen->myNum, X_WARNING,

+                  "[DRI2] Direct rendering is not supported when VGA arb is necessary for the device\n");

+        return FALSE;

+    }

+

+    ds = xcalloc(1, sizeof *ds);

+    if (!ds)

+	return FALSE;

+

+    ds->screen         = pScreen;

+    ds->fd	       = info->fd;

+    ds->deviceName     = info->deviceName;

+    dri2_major         = 1;

+

+    ds->CreateBuffer   = info->CreateBuffer;

+    ds->DestroyBuffer  = info->DestroyBuffer;

+    ds->CopyRegion     = info->CopyRegion;

+

+    if (info->version >= 4) {

+	ds->ScheduleSwap = info->ScheduleSwap;

+	ds->ScheduleWaitMSC = info->ScheduleWaitMSC;

+	ds->GetMSC = info->GetMSC;

+	cur_minor = 2;

+    } else {

+	cur_minor = 1;

+    }

+

+    /* Initialize minor if needed and set to minimum provied by DDX */

+    if (!dri2_minor || dri2_minor > cur_minor)

+	dri2_minor = cur_minor;

+

+    if (info->version == 3 || info->numDrivers == 0) {

+	/* Driver too old: use the old-style driverName field */

+	ds->numDrivers = 1;

+	ds->driverNames = xalloc(sizeof(*ds->driverNames));

+	if (!ds->driverNames) {

+	    xfree(ds);

+	    return FALSE;

+	}

+	ds->driverNames[0] = info->driverName;

+    } else {

+	ds->numDrivers = info->numDrivers;

+	ds->driverNames = xalloc(info->numDrivers * sizeof(*ds->driverNames));

+	if (!ds->driverNames) {

+	    xfree(ds);

+	    return FALSE;

+	}

+	memcpy(ds->driverNames, info->driverNames,

+	       info->numDrivers * sizeof(*ds->driverNames));

+    }

+

+    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, ds);

+

+    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2] Setup complete\n");

+    for (i = 0; i < sizeof(driverTypeNames) / sizeof(driverTypeNames[0]); i++) {

+	if (i < ds->numDrivers && ds->driverNames[i]) {

+	    xf86DrvMsg(pScreen->myNum, X_INFO, "[DRI2]   %s driver: %s\n",

+		       driverTypeNames[i], ds->driverNames[i]);

+	}

+    }

+

+    return TRUE;

+}

+

+void

+DRI2CloseScreen(ScreenPtr pScreen)

+{

+    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);

+

+    xfree(ds->driverNames);

+    xfree(ds);

+    dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, NULL);

+}

+

+extern ExtensionModule dri2ExtensionModule;

+

+static pointer

+DRI2Setup(pointer module, pointer opts, int *errmaj, int *errmin)

+{

+    static Bool setupDone = FALSE;

+

+    dri2DrawableRes = CreateNewResourceType(DRI2DrawableGone, "DRI2Drawable");

+

+    if (!setupDone)

+    {

+	setupDone = TRUE;

+	LoadExtension(&dri2ExtensionModule, FALSE);

+    }

+    else

+    {

+	if (errmaj)

+	    *errmaj = LDR_ONCEONLY;

+    }

+

+    return (pointer) 1;

+}

+

+static XF86ModuleVersionInfo DRI2VersRec =

+{

+    "dri2",

+    MODULEVENDORSTRING,

+    MODINFOSTRING1,

+    MODINFOSTRING2,

+    XORG_VERSION_CURRENT,

+    1, 2, 0,

+    ABI_CLASS_EXTENSION,

+    ABI_EXTENSION_VERSION,

+    MOD_CLASS_NONE,

+    { 0, 0, 0, 0 }

+};

+

+_X_EXPORT XF86ModuleData dri2ModuleData = { &DRI2VersRec, DRI2Setup, NULL };

+

+void

+DRI2Version(int *major, int *minor)

+{

+    if (major != NULL)

+	*major = DRI2VersRec.majorversion;

+

+    if (minor != NULL)

+	*minor = DRI2VersRec.minorversion;

+}

diff --git a/xorg-server/hw/xfree86/dri2/dri2.h b/xorg-server/hw/xfree86/dri2/dri2.h
index ce8a5df41..cc15f120d 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.h
+++ b/xorg-server/hw/xfree86/dri2/dri2.h
@@ -1,274 +1,275 @@
-/*
- * Copyright © 2007 Red Hat, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Soft-
- * ware"), to deal in the Software without restriction, including without
- * limitation the rights to use, copy, modify, merge, publish, distribute,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, provided that the above copyright
- * notice(s) and this permission notice appear in all copies of the Soft-
- * ware and that both the above copyright notice(s) and this permission
- * notice appear in supporting documentation.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
- * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
- * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
- * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
- * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
- * MANCE OF THIS SOFTWARE.
- *
- * Except as contained in this notice, the name of a copyright holder shall
- * not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization of
- * the copyright holder.
- *
- * Authors:
- *   Kristian Høgsberg (krh@redhat.com)
- */
-
-#ifndef _DRI2_H_
-#define _DRI2_H_
-
-#include <X11/extensions/dri2tokens.h>
-
-/* Version 2 structure (with format at the end) */
-typedef struct {
-    unsigned int attachment;
-    unsigned int name;
-    unsigned int pitch;
-    unsigned int cpp;
-    unsigned int flags;
-    unsigned int format;
-    void *driverPrivate;
-} DRI2BufferRec, *DRI2BufferPtr;
-
-extern CARD8 dri2_major; /* version of DRI2 supported by DDX */
-extern CARD8 dri2_minor;
-
-typedef DRI2BufferRec DRI2Buffer2Rec, *DRI2Buffer2Ptr;
-typedef void (*DRI2SwapEventPtr)(ClientPtr client, void *data, int type,
-				 CARD64 ust, CARD64 msc, CARD64 sbc);
-
-
-typedef DRI2BufferPtr	(*DRI2CreateBuffersProcPtr)(DrawablePtr pDraw,
-						    unsigned int *attachments,
-						    int count);
-typedef void		(*DRI2DestroyBuffersProcPtr)(DrawablePtr pDraw,
-						     DRI2BufferPtr buffers,
-						     int count);
-typedef void		(*DRI2CopyRegionProcPtr)(DrawablePtr pDraw,
-						 RegionPtr pRegion,
-						 DRI2BufferPtr pDestBuffer,
-						 DRI2BufferPtr pSrcBuffer);
-typedef void		(*DRI2WaitProcPtr)(WindowPtr pWin,
-					   unsigned int sequence);
-/**
- * Schedule a buffer swap
- *
- * This callback is used to support glXSwapBuffers and the OML_sync_control
- * extension (see it for a description of the params).
- *
- * Drivers should queue an event for the frame count that satisfies the
- * parameters passed in.  If the event is in the future (i.e. the conditions
- * aren't currently satisfied), the server may block the client at the next
- * GLX request using DRI2WaitSwap. When the event arrives, drivers should call
- * \c DRI2SwapComplete, which will handle waking the client and returning
- * the appropriate data.
- *
- * The DDX is responsible for doing a flip, exchange, or blit of the swap
- * when the corresponding event arrives.  The \c DRI2CanFlip and
- * \c DRI2CanExchange functions can be used as helpers for this purpose.
- *
- * \param client client pointer (used for block/unblock)
- * \param pDraw drawable whose count we want
- * \param pDestBuffer current front buffer
- * \param pSrcBuffer current back buffer
- * \param target_msc frame count to wait for
- * \param divisor divisor for condition equation
- * \param remainder remainder for division equation
- * \param func function to call when the swap completes
- * \param data data for the callback \p func.
- */
-typedef int		(*DRI2ScheduleSwapProcPtr)(ClientPtr client,
-						   DrawablePtr pDraw,
-						   DRI2BufferPtr pDestBuffer,
-						   DRI2BufferPtr pSrcBuffer,
-						   CARD64 *target_msc,
-						   CARD64 divisor,
-						   CARD64 remainder,
-						   DRI2SwapEventPtr func,
-						   void *data);
-typedef DRI2BufferPtr	(*DRI2CreateBufferProcPtr)(DrawablePtr pDraw,
-						   unsigned int attachment,
-						   unsigned int format);
-typedef void		(*DRI2DestroyBufferProcPtr)(DrawablePtr pDraw,
-						    DRI2BufferPtr buffer);
-/**
- * Get current media stamp counter values
- *
- * This callback is used to support the SGI_video_sync and OML_sync_control
- * extensions.
- *
- * Drivers should return the current frame counter and the timestamp from
- * when the returned frame count was last incremented.
- *
- * The count should correspond to the screen where the drawable is currently
- * visible.  If the drawable isn't visible (e.g. redirected), the server
- * should return BadDrawable to the client, pending GLX spec updates to
- * define this behavior.
- *
- * \param pDraw drawable whose count we want
- * \param ust timestamp from when the count was last incremented.
- * \param mst current frame count
- */
-typedef int		(*DRI2GetMSCProcPtr)(DrawablePtr pDraw, CARD64 *ust,
-					     CARD64 *msc);
-/**
- * Schedule a frame count related wait
- *
- * This callback is used to support the SGI_video_sync and OML_sync_control
- * extensions.  See those specifications for details on how to handle
- * the divisor and remainder parameters.
- *
- * Drivers should queue an event for the frame count that satisfies the
- * parameters passed in.  If the event is in the future (i.e. the conditions
- * aren't currently satisfied), the driver should block the client using
- * \c DRI2BlockClient.  When the event arrives, drivers should call
- * \c DRI2WaitMSCComplete, which will handle waking the client and returning
- * the appropriate data.
- *
- * \param client client pointer (used for block/unblock)
- * \param pDraw drawable whose count we want
- * \param target_msc frame count to wait for
- * \param divisor divisor for condition equation
- * \param remainder remainder for division equation
- */
-typedef int		(*DRI2ScheduleWaitMSCProcPtr)(ClientPtr client,
-						      DrawablePtr pDraw,
-						      CARD64 target_msc,
-						      CARD64 divisor,
-						      CARD64 remainder);
-/**
- * Version of the DRI2InfoRec structure defined in this header
- */
-#define DRI2INFOREC_VERSION 4
-
-typedef struct {
-    unsigned int version;	/**< Version of this struct */
-    int fd;
-    const char *driverName;
-    const char *deviceName;
-
-    DRI2CreateBufferProcPtr	CreateBuffer;
-    DRI2DestroyBufferProcPtr	DestroyBuffer;
-    DRI2CopyRegionProcPtr	CopyRegion;
-    DRI2WaitProcPtr		Wait;
-
-    /* added in version 4 */
-
-    DRI2ScheduleSwapProcPtr	ScheduleSwap;
-    DRI2GetMSCProcPtr		GetMSC;
-    DRI2ScheduleWaitMSCProcPtr	ScheduleWaitMSC;
-
-    /* number of drivers in the driverNames array */
-    unsigned int numDrivers;
-    /* array of driver names, indexed by DRI2Driver* driver types */
-    /* a name of NULL means that driver is not supported */
-    const char * const *driverNames;
-}  DRI2InfoRec, *DRI2InfoPtr;
-
-extern _X_EXPORT int DRI2EventBase;
-
-extern _X_EXPORT Bool DRI2ScreenInit(ScreenPtr	pScreen,
-		    DRI2InfoPtr info);
-
-extern _X_EXPORT void DRI2CloseScreen(ScreenPtr pScreen);
-
-extern _X_EXPORT Bool DRI2HasSwapControl(ScreenPtr pScreen);
-
-extern _X_EXPORT Bool DRI2Connect(ScreenPtr pScreen,
-		 unsigned int driverType,
-		 int *fd,
-		 const char **driverName,
-		 const char **deviceName);
-
-extern _X_EXPORT Bool DRI2Authenticate(ScreenPtr pScreen, drm_magic_t magic);
-
-extern _X_EXPORT int DRI2CreateDrawable(DrawablePtr pDraw);
-
-extern _X_EXPORT void DRI2DestroyDrawable(DrawablePtr pDraw);
-
-extern _X_EXPORT DRI2BufferPtr *DRI2GetBuffers(DrawablePtr pDraw,
-			     int *width,
-			     int *height,
-			     unsigned int *attachments,
-			     int count,
-			     int *out_count);
-
-extern _X_EXPORT int DRI2CopyRegion(DrawablePtr pDraw,
-		   RegionPtr pRegion,
-		   unsigned int dest,
-		   unsigned int src);
-
-/**
- * Determine the major and minor version of the DRI2 extension.
- *
- * Provides a mechanism to other modules (e.g., 2D drivers) to determine the
- * version of the DRI2 extension.  While it is possible to peek directly at
- * the \c XF86ModuleData from a layered module, such a module will fail to
- * load (due to an unresolved symbol) if the DRI2 extension is not loaded.
- *
- * \param major  Location to store the major verion of the DRI2 extension
- * \param minor  Location to store the minor verion of the DRI2 extension
- *
- * \note
- * This interface was added some time after the initial release of the DRI2
- * module.  Layered modules that wish to use this interface must first test
- * its existance by calling \c xf86LoaderCheckSymbol.
- */
-extern _X_EXPORT void DRI2Version(int *major, int *minor);
-
-extern _X_EXPORT DRI2BufferPtr *DRI2GetBuffersWithFormat(DrawablePtr pDraw,
-	int *width, int *height, unsigned int *attachments, int count,
-	int *out_count);
-
-extern _X_EXPORT void DRI2SwapInterval(DrawablePtr pDrawable, int interval);
-extern _X_EXPORT int DRI2SwapBuffers(ClientPtr client, DrawablePtr pDrawable,
-				     CARD64 target_msc, CARD64 divisor,
-				     CARD64 remainder, CARD64 *swap_target,
-				     DRI2SwapEventPtr func, void *data);
-extern _X_EXPORT Bool DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable);
-
-extern _X_EXPORT int DRI2GetMSC(DrawablePtr pDrawable, CARD64 *ust,
-				CARD64 *msc, CARD64 *sbc);
-extern _X_EXPORT int DRI2WaitMSC(ClientPtr client, DrawablePtr pDrawable,
-				 CARD64 target_msc, CARD64 divisor,
-				 CARD64 remainder);
-extern _X_EXPORT int ProcDRI2WaitMSCReply(ClientPtr client, CARD64 ust,
-					  CARD64 msc, CARD64 sbc);
-extern _X_EXPORT int DRI2WaitSBC(ClientPtr client, DrawablePtr pDraw,
-				 CARD64 target_sbc, CARD64 *ust, CARD64 *msc,
-				 CARD64 *sbc);
-extern _X_EXPORT Bool DRI2ThrottleClient(ClientPtr client, DrawablePtr pDraw);
-
-extern _X_EXPORT Bool DRI2CanFlip(DrawablePtr pDraw);
-
-extern _X_EXPORT Bool DRI2CanExchange(DrawablePtr pDraw);
-
-/* Note: use *only* for MSC related waits */
-extern _X_EXPORT void DRI2BlockClient(ClientPtr client, DrawablePtr pDraw);
-
-extern _X_EXPORT void DRI2SwapComplete(ClientPtr client, DrawablePtr pDraw,
-				       int frame, unsigned int tv_sec,
-				       unsigned int tv_usec, int type,
-				       DRI2SwapEventPtr swap_complete,
-				       void *swap_data);
-extern _X_EXPORT void DRI2WaitMSCComplete(ClientPtr client, DrawablePtr pDraw,
-					  int frame, unsigned int tv_sec,
-					  unsigned int tv_usec);
-
-#endif
+/*

+ * Copyright © 2007 Red Hat, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Soft-

+ * ware"), to deal in the Software without restriction, including without

+ * limitation the rights to use, copy, modify, merge, publish, distribute,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, provided that the above copyright

+ * notice(s) and this permission notice appear in all copies of the Soft-

+ * ware and that both the above copyright notice(s) and this permission

+ * notice appear in supporting documentation.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-

+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY

+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN

+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-

+ * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-

+ * MANCE OF THIS SOFTWARE.

+ *

+ * Except as contained in this notice, the name of a copyright holder shall

+ * not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization of

+ * the copyright holder.

+ *

+ * Authors:

+ *   Kristian Høgsberg (krh@redhat.com)

+ */

+

+#ifndef _DRI2_H_

+#define _DRI2_H_

+

+#include <X11/extensions/dri2tokens.h>

+

+/* Version 2 structure (with format at the end) */

+typedef struct {

+    unsigned int attachment;

+    unsigned int name;

+    unsigned int pitch;

+    unsigned int cpp;

+    unsigned int flags;

+    unsigned int format;

+    void *driverPrivate;

+} DRI2BufferRec, *DRI2BufferPtr;

+

+extern CARD8 dri2_major; /* version of DRI2 supported by DDX */

+extern CARD8 dri2_minor;

+

+typedef DRI2BufferRec DRI2Buffer2Rec, *DRI2Buffer2Ptr;

+typedef void (*DRI2SwapEventPtr)(ClientPtr client, void *data, int type,

+				 CARD64 ust, CARD64 msc, CARD64 sbc);

+

+

+typedef DRI2BufferPtr	(*DRI2CreateBuffersProcPtr)(DrawablePtr pDraw,

+						    unsigned int *attachments,

+						    int count);

+typedef void		(*DRI2DestroyBuffersProcPtr)(DrawablePtr pDraw,

+						     DRI2BufferPtr buffers,

+						     int count);

+typedef void		(*DRI2CopyRegionProcPtr)(DrawablePtr pDraw,

+						 RegionPtr pRegion,

+						 DRI2BufferPtr pDestBuffer,

+						 DRI2BufferPtr pSrcBuffer);

+typedef void		(*DRI2WaitProcPtr)(WindowPtr pWin,

+					   unsigned int sequence);

+/**

+ * Schedule a buffer swap

+ *

+ * This callback is used to support glXSwapBuffers and the OML_sync_control

+ * extension (see it for a description of the params).

+ *

+ * Drivers should queue an event for the frame count that satisfies the

+ * parameters passed in.  If the event is in the future (i.e. the conditions

+ * aren't currently satisfied), the server may block the client at the next

+ * GLX request using DRI2WaitSwap. When the event arrives, drivers should call

+ * \c DRI2SwapComplete, which will handle waking the client and returning

+ * the appropriate data.

+ *

+ * The DDX is responsible for doing a flip, exchange, or blit of the swap

+ * when the corresponding event arrives.  The \c DRI2CanFlip and

+ * \c DRI2CanExchange functions can be used as helpers for this purpose.

+ *

+ * \param client client pointer (used for block/unblock)

+ * \param pDraw drawable whose count we want

+ * \param pDestBuffer current front buffer

+ * \param pSrcBuffer current back buffer

+ * \param target_msc frame count to wait for

+ * \param divisor divisor for condition equation

+ * \param remainder remainder for division equation

+ * \param func function to call when the swap completes

+ * \param data data for the callback \p func.

+ */

+typedef int		(*DRI2ScheduleSwapProcPtr)(ClientPtr client,

+						   DrawablePtr pDraw,

+						   DRI2BufferPtr pDestBuffer,

+						   DRI2BufferPtr pSrcBuffer,

+						   CARD64 *target_msc,

+						   CARD64 divisor,

+						   CARD64 remainder,

+						   DRI2SwapEventPtr func,

+						   void *data);

+typedef DRI2BufferPtr	(*DRI2CreateBufferProcPtr)(DrawablePtr pDraw,

+						   unsigned int attachment,

+						   unsigned int format);

+typedef void		(*DRI2DestroyBufferProcPtr)(DrawablePtr pDraw,

+						    DRI2BufferPtr buffer);

+/**

+ * Get current media stamp counter values

+ *

+ * This callback is used to support the SGI_video_sync and OML_sync_control

+ * extensions.

+ *

+ * Drivers should return the current frame counter and the timestamp from

+ * when the returned frame count was last incremented.

+ *

+ * The count should correspond to the screen where the drawable is currently

+ * visible.  If the drawable isn't visible (e.g. redirected), the server

+ * should return BadDrawable to the client, pending GLX spec updates to

+ * define this behavior.

+ *

+ * \param pDraw drawable whose count we want

+ * \param ust timestamp from when the count was last incremented.

+ * \param mst current frame count

+ */

+typedef int		(*DRI2GetMSCProcPtr)(DrawablePtr pDraw, CARD64 *ust,

+					     CARD64 *msc);

+/**

+ * Schedule a frame count related wait

+ *

+ * This callback is used to support the SGI_video_sync and OML_sync_control

+ * extensions.  See those specifications for details on how to handle

+ * the divisor and remainder parameters.

+ *

+ * Drivers should queue an event for the frame count that satisfies the

+ * parameters passed in.  If the event is in the future (i.e. the conditions

+ * aren't currently satisfied), the driver should block the client using

+ * \c DRI2BlockClient.  When the event arrives, drivers should call

+ * \c DRI2WaitMSCComplete, which will handle waking the client and returning

+ * the appropriate data.

+ *

+ * \param client client pointer (used for block/unblock)

+ * \param pDraw drawable whose count we want

+ * \param target_msc frame count to wait for

+ * \param divisor divisor for condition equation

+ * \param remainder remainder for division equation

+ */

+typedef int		(*DRI2ScheduleWaitMSCProcPtr)(ClientPtr client,

+						      DrawablePtr pDraw,

+						      CARD64 target_msc,

+						      CARD64 divisor,

+						      CARD64 remainder);

+/**

+ * Version of the DRI2InfoRec structure defined in this header

+ */

+#define DRI2INFOREC_VERSION 4

+

+typedef struct {

+    unsigned int version;	/**< Version of this struct */

+    int fd;

+    const char *driverName;

+    const char *deviceName;

+

+    DRI2CreateBufferProcPtr	CreateBuffer;

+    DRI2DestroyBufferProcPtr	DestroyBuffer;

+    DRI2CopyRegionProcPtr	CopyRegion;

+    DRI2WaitProcPtr		Wait;

+

+    /* added in version 4 */

+

+    DRI2ScheduleSwapProcPtr	ScheduleSwap;

+    DRI2GetMSCProcPtr		GetMSC;

+    DRI2ScheduleWaitMSCProcPtr	ScheduleWaitMSC;

+

+    /* number of drivers in the driverNames array */

+    unsigned int numDrivers;

+    /* array of driver names, indexed by DRI2Driver* driver types */

+    /* a name of NULL means that driver is not supported */

+    const char * const *driverNames;

+}  DRI2InfoRec, *DRI2InfoPtr;

+

+extern _X_EXPORT int DRI2EventBase;

+

+extern _X_EXPORT Bool DRI2ScreenInit(ScreenPtr	pScreen,

+		    DRI2InfoPtr info);

+

+extern _X_EXPORT void DRI2CloseScreen(ScreenPtr pScreen);

+

+extern _X_EXPORT Bool DRI2HasSwapControl(ScreenPtr pScreen);

+

+extern _X_EXPORT Bool DRI2Connect(ScreenPtr pScreen,

+		 unsigned int driverType,

+		 int *fd,

+		 const char **driverName,

+		 const char **deviceName);

+

+extern _X_EXPORT Bool DRI2Authenticate(ScreenPtr pScreen, drm_magic_t magic);

+

+extern _X_EXPORT int DRI2CreateDrawable(ClientPtr client,

+					DrawablePtr pDraw, XID id);

+

+extern _X_EXPORT void DRI2DestroyDrawable(DrawablePtr pDraw);

+

+extern _X_EXPORT DRI2BufferPtr *DRI2GetBuffers(DrawablePtr pDraw,

+			     int *width,

+			     int *height,

+			     unsigned int *attachments,

+			     int count,

+			     int *out_count);

+

+extern _X_EXPORT int DRI2CopyRegion(DrawablePtr pDraw,

+		   RegionPtr pRegion,

+		   unsigned int dest,

+		   unsigned int src);

+

+/**

+ * Determine the major and minor version of the DRI2 extension.

+ *

+ * Provides a mechanism to other modules (e.g., 2D drivers) to determine the

+ * version of the DRI2 extension.  While it is possible to peek directly at

+ * the \c XF86ModuleData from a layered module, such a module will fail to

+ * load (due to an unresolved symbol) if the DRI2 extension is not loaded.

+ *

+ * \param major  Location to store the major verion of the DRI2 extension

+ * \param minor  Location to store the minor verion of the DRI2 extension

+ *

+ * \note

+ * This interface was added some time after the initial release of the DRI2

+ * module.  Layered modules that wish to use this interface must first test

+ * its existance by calling \c xf86LoaderCheckSymbol.

+ */

+extern _X_EXPORT void DRI2Version(int *major, int *minor);

+

+extern _X_EXPORT DRI2BufferPtr *DRI2GetBuffersWithFormat(DrawablePtr pDraw,

+	int *width, int *height, unsigned int *attachments, int count,

+	int *out_count);

+

+extern _X_EXPORT void DRI2SwapInterval(DrawablePtr pDrawable, int interval);

+extern _X_EXPORT int DRI2SwapBuffers(ClientPtr client, DrawablePtr pDrawable,

+				     CARD64 target_msc, CARD64 divisor,

+				     CARD64 remainder, CARD64 *swap_target,

+				     DRI2SwapEventPtr func, void *data);

+extern _X_EXPORT Bool DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable);

+

+extern _X_EXPORT int DRI2GetMSC(DrawablePtr pDrawable, CARD64 *ust,

+				CARD64 *msc, CARD64 *sbc);

+extern _X_EXPORT int DRI2WaitMSC(ClientPtr client, DrawablePtr pDrawable,

+				 CARD64 target_msc, CARD64 divisor,

+				 CARD64 remainder);

+extern _X_EXPORT int ProcDRI2WaitMSCReply(ClientPtr client, CARD64 ust,

+					  CARD64 msc, CARD64 sbc);

+extern _X_EXPORT int DRI2WaitSBC(ClientPtr client, DrawablePtr pDraw,

+				 CARD64 target_sbc, CARD64 *ust, CARD64 *msc,

+				 CARD64 *sbc);

+extern _X_EXPORT Bool DRI2ThrottleClient(ClientPtr client, DrawablePtr pDraw);

+

+extern _X_EXPORT Bool DRI2CanFlip(DrawablePtr pDraw);

+

+extern _X_EXPORT Bool DRI2CanExchange(DrawablePtr pDraw);

+

+/* Note: use *only* for MSC related waits */

+extern _X_EXPORT void DRI2BlockClient(ClientPtr client, DrawablePtr pDraw);

+

+extern _X_EXPORT void DRI2SwapComplete(ClientPtr client, DrawablePtr pDraw,

+				       int frame, unsigned int tv_sec,

+				       unsigned int tv_usec, int type,

+				       DRI2SwapEventPtr swap_complete,

+				       void *swap_data);

+extern _X_EXPORT void DRI2WaitMSCComplete(ClientPtr client, DrawablePtr pDraw,

+					  int frame, unsigned int tv_sec,

+					  unsigned int tv_usec);

+

+#endif

diff --git a/xorg-server/hw/xfree86/dri2/dri2ext.c b/xorg-server/hw/xfree86/dri2/dri2ext.c
index 17df1304e..8bed02055 100644
--- a/xorg-server/hw/xfree86/dri2/dri2ext.c
+++ b/xorg-server/hw/xfree86/dri2/dri2ext.c
@@ -1,646 +1,646 @@
-/*
- * Copyright © 2008 Red Hat, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Soft-
- * ware"), to deal in the Software without restriction, including without
- * limitation the rights to use, copy, modify, merge, publish, distribute,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, provided that the above copyright
- * notice(s) and this permission notice appear in all copies of the Soft-
- * ware and that both the above copyright notice(s) and this permission
- * notice appear in supporting documentation.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
- * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
- * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
- * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
- * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
- * MANCE OF THIS SOFTWARE.
- *
- * Except as contained in this notice, the name of a copyright holder shall
- * not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization of
- * the copyright holder.
- *
- * Authors:
- *   Kristian Høgsberg (krh@redhat.com)
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include <X11/extensions/dri2proto.h>
-#include <X11/extensions/xfixeswire.h>
-#include "dixstruct.h"
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "extnsionst.h"
-#include "xf86drm.h"
-#include "xfixes.h"
-#include "dri2.h"
-#include "protocol-versions.h"
-
-/* The only xf86 include */
-#include "xf86Module.h"
-
-static ExtensionEntry	*dri2Extension;
-
-static Bool
-validDrawable(ClientPtr client, XID drawable, Mask access_mode,
-	      DrawablePtr *pDrawable, int *status)
-{
-    *status = dixLookupDrawable(pDrawable, drawable, client, 0, access_mode);
-    if (*status != Success) {
-	client->errorValue = drawable;
-	return FALSE;
-    }
-
-    return TRUE;
-}
-
-static int
-ProcDRI2QueryVersion(ClientPtr client)
-{
-    REQUEST(xDRI2QueryVersionReq);
-    xDRI2QueryVersionReply rep;
-    int n;
-
-    if (client->swapped)
-	swaps(&stuff->length, n);
-
-    REQUEST_SIZE_MATCH(xDRI2QueryVersionReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.majorVersion = dri2_major;
-    rep.minorVersion = dri2_minor;
-
-    if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
-    }
-
-    WriteToClient(client, sizeof(xDRI2QueryVersionReply), &rep);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2Connect(ClientPtr client)
-{
-    REQUEST(xDRI2ConnectReq);
-    xDRI2ConnectReply rep;
-    DrawablePtr pDraw;
-    int fd, status;
-    const char *driverName;
-    const char *deviceName;
-
-    REQUEST_SIZE_MATCH(xDRI2ConnectReq);
-    if (!validDrawable(client, stuff->window, DixGetAttrAccess,
-		       &pDraw, &status))
-	return status;
-    
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.driverNameLength = 0;
-    rep.deviceNameLength = 0;
-
-    if (!DRI2Connect(pDraw->pScreen,
-		     stuff->driverType, &fd, &driverName, &deviceName))
-	goto fail;
-
-    rep.driverNameLength = strlen(driverName);
-    rep.deviceNameLength = strlen(deviceName);
-    rep.length = (rep.driverNameLength + 3) / 4 +
-	    (rep.deviceNameLength + 3) / 4;
-
- fail:
-    WriteToClient(client, sizeof(xDRI2ConnectReply), &rep);
-    WriteToClient(client, rep.driverNameLength, driverName);
-    WriteToClient(client, rep.deviceNameLength, deviceName);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2Authenticate(ClientPtr client)
-{
-    REQUEST(xDRI2AuthenticateReq);
-    xDRI2AuthenticateReply rep;
-    DrawablePtr pDraw;
-    int status;
-
-    REQUEST_SIZE_MATCH(xDRI2AuthenticateReq);
-    if (!validDrawable(client, stuff->window, DixGetAttrAccess,
-		       &pDraw, &status))
-	return status;
-
-    rep.type = X_Reply;
-    rep.sequenceNumber = client->sequence;
-    rep.length = 0;
-    rep.authenticated = DRI2Authenticate(pDraw->pScreen, stuff->magic);
-    WriteToClient(client, sizeof(xDRI2AuthenticateReply), &rep);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2CreateDrawable(ClientPtr client)
-{
-    REQUEST(xDRI2CreateDrawableReq);
-    DrawablePtr pDrawable;
-    int status;
-
-    REQUEST_SIZE_MATCH(xDRI2CreateDrawableReq);
-
-    if (!validDrawable(client, stuff->drawable, DixAddAccess,
-		       &pDrawable, &status))
-	return status;
-
-    status = DRI2CreateDrawable(pDrawable);
-    if (status != Success)
-	return status;
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2DestroyDrawable(ClientPtr client)
-{
-    REQUEST(xDRI2DestroyDrawableReq);
-    DrawablePtr pDrawable;
-    int status;
-
-    REQUEST_SIZE_MATCH(xDRI2DestroyDrawableReq);
-    if (!validDrawable(client, stuff->drawable, DixRemoveAccess,
-		       &pDrawable, &status))
-	return status;
-
-    return client->noClientException;
-}
-
-
-static void
-send_buffers_reply(ClientPtr client, DrawablePtr pDrawable,
-		   DRI2BufferPtr *buffers, int count, int width, int height)
-{
-    xDRI2GetBuffersReply rep;
-    int skip = 0;
-    int i;
-
-    if (pDrawable->type == DRAWABLE_WINDOW) {
-	for (i = 0; i < count; i++) {
-	    /* Do not send the real front buffer of a window to the client.
-	     */
-	    if (buffers[i]->attachment == DRI2BufferFrontLeft) {
-		skip++;
-		continue;
-	    }
-	}
-    }
-
-    rep.type = X_Reply;
-    rep.length = (count - skip) * sizeof(xDRI2Buffer) / 4;
-    rep.sequenceNumber = client->sequence;
-    rep.width = width;
-    rep.height = height;
-    rep.count = count - skip;
-    WriteToClient(client, sizeof(xDRI2GetBuffersReply), &rep);
-
-    for (i = 0; i < count; i++) {
-	xDRI2Buffer buffer;
-
-	/* Do not send the real front buffer of a window to the client.
-	 */
-	if ((pDrawable->type == DRAWABLE_WINDOW)
-	    && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
-	    continue;
-	}
-
-	buffer.attachment = buffers[i]->attachment;
-	buffer.name = buffers[i]->name;
-	buffer.pitch = buffers[i]->pitch;
-	buffer.cpp = buffers[i]->cpp;
-	buffer.flags = buffers[i]->flags;
-	WriteToClient(client, sizeof(xDRI2Buffer), &buffer);
-    }
-}
-
-
-static int
-ProcDRI2GetBuffers(ClientPtr client)
-{
-    REQUEST(xDRI2GetBuffersReq);
-    DrawablePtr pDrawable;
-    DRI2BufferPtr *buffers;
-    int status, width, height, count;
-    unsigned int *attachments;
-
-    REQUEST_FIXED_SIZE(xDRI2GetBuffersReq, stuff->count * 4);
-    if (!validDrawable(client, stuff->drawable, DixReadAccess | DixWriteAccess,
-		       &pDrawable, &status))
-	return status;
-
-    if (DRI2ThrottleClient(client, pDrawable))
-	return client->noClientException;
-
-    attachments = (unsigned int *) &stuff[1];
-    buffers = DRI2GetBuffers(pDrawable, &width, &height,
-			     attachments, stuff->count, &count);
-
-
-    send_buffers_reply(client, pDrawable, buffers, count, width, height);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2GetBuffersWithFormat(ClientPtr client)
-{
-    REQUEST(xDRI2GetBuffersReq);
-    DrawablePtr pDrawable;
-    DRI2BufferPtr *buffers;
-    int status, width, height, count;
-    unsigned int *attachments;
-
-    REQUEST_FIXED_SIZE(xDRI2GetBuffersReq, stuff->count * (2 * 4));
-    if (!validDrawable(client, stuff->drawable, DixReadAccess | DixWriteAccess,
-		       &pDrawable, &status))
-	return status;
-
-    if (DRI2ThrottleClient(client, pDrawable))
-	return client->noClientException;
-
-    attachments = (unsigned int *) &stuff[1];
-    buffers = DRI2GetBuffersWithFormat(pDrawable, &width, &height,
-				       attachments, stuff->count, &count);
-
-    send_buffers_reply(client, pDrawable, buffers, count, width, height);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2CopyRegion(ClientPtr client)
-{
-    REQUEST(xDRI2CopyRegionReq);
-    xDRI2CopyRegionReply rep;
-    DrawablePtr pDrawable;
-    int status;
-    RegionPtr pRegion;
-
-    REQUEST_SIZE_MATCH(xDRI2CopyRegionReq);
-
-    if (!validDrawable(client, stuff->drawable, DixWriteAccess,
-		       &pDrawable, &status))
-	return status;
-
-    VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);
-
-    status = DRI2CopyRegion(pDrawable, pRegion, stuff->dest, stuff->src);
-    if (status != Success)
-	return status;
-
-    /* CopyRegion needs to be a round trip to make sure the X server
-     * queues the swap buffer rendering commands before the DRI client
-     * continues rendering.  The reply has a bitmask to signal the
-     * presense of optional return values as well, but we're not using
-     * that yet.
-     */
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    WriteToClient(client, sizeof(xDRI2CopyRegionReply), &rep);
-
-    return client->noClientException;
-}
-
-static void
-load_swap_reply(xDRI2SwapBuffersReply *rep, CARD64 sbc)
-{
-    rep->swap_hi = sbc >> 32;
-    rep->swap_lo = sbc & 0xffffffff;
-}
-
-static CARD64
-vals_to_card64(CARD32 lo, CARD32 hi)
-{
-    return (CARD64)hi << 32 | lo;
-}
-
-static void
-DRI2SwapEvent(ClientPtr client, void *data, int type, CARD64 ust, CARD64 msc,
-	      CARD64 sbc)
-{
-    xDRI2BufferSwapComplete event;
-    DrawablePtr pDrawable = data;
-
-    event.type = DRI2EventBase + DRI2_BufferSwapComplete;
-    event.sequenceNumber = client->sequence;
-    event.event_type = type;
-    event.drawable = pDrawable->id;
-    event.ust_hi = (CARD64)ust >> 32;
-    event.ust_lo = ust & 0xffffffff;
-    event.msc_hi = (CARD64)msc >> 32;
-    event.msc_lo = msc & 0xffffffff;
-    event.sbc_hi = (CARD64)sbc >> 32;
-    event.sbc_lo = sbc & 0xffffffff;
-
-    WriteEventsToClient(client, 1, (xEvent *)&event);
-}
-
-static int
-ProcDRI2SwapBuffers(ClientPtr client)
-{
-    REQUEST(xDRI2SwapBuffersReq);
-    xDRI2SwapBuffersReply rep;
-    DrawablePtr pDrawable;
-    CARD64 target_msc, divisor, remainder, swap_target;
-    int status;
-
-    REQUEST_SIZE_MATCH(xDRI2SwapBuffersReq);
-
-    if (!validDrawable(client, stuff->drawable,
-		       DixReadAccess | DixWriteAccess, &pDrawable, &status))
-	return status;
-
-    /*
-     * Ensures an out of control client can't exhaust our swap queue, and
-     * also orders swaps.
-     */
-    if (DRI2ThrottleClient(client, pDrawable))
-	return client->noClientException;
-
-    target_msc = vals_to_card64(stuff->target_msc_lo, stuff->target_msc_hi);
-    divisor = vals_to_card64(stuff->divisor_lo, stuff->divisor_hi);
-    remainder = vals_to_card64(stuff->remainder_lo, stuff->remainder_hi);
-
-    status = DRI2SwapBuffers(client, pDrawable, target_msc, divisor, remainder,
-			     &swap_target, DRI2SwapEvent, pDrawable);
-    if (status != Success)
-	return BadDrawable;
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    load_swap_reply(&rep, swap_target);
-
-    WriteToClient(client, sizeof(xDRI2SwapBuffersReply), &rep);
-
-    return client->noClientException;
-}
-
-static void
-load_msc_reply(xDRI2MSCReply *rep, CARD64 ust, CARD64 msc, CARD64 sbc)
-{
-    rep->ust_hi = ust >> 32;
-    rep->ust_lo = ust & 0xffffffff;
-    rep->msc_hi = msc >> 32;
-    rep->msc_lo = msc & 0xffffffff;
-    rep->sbc_hi = sbc >> 32;
-    rep->sbc_lo = sbc & 0xffffffff;
-}
-
-static int
-ProcDRI2GetMSC(ClientPtr client)
-{
-    REQUEST(xDRI2GetMSCReq);
-    xDRI2MSCReply rep;
-    DrawablePtr pDrawable;
-    CARD64 ust, msc, sbc;
-    int status;
-
-    REQUEST_SIZE_MATCH(xDRI2GetMSCReq);
-
-    if (!validDrawable(client, stuff->drawable, DixReadAccess, &pDrawable,
-		       &status))
-	return status;
-
-    status = DRI2GetMSC(pDrawable, &ust, &msc, &sbc);
-    if (status != Success)
-	return status;
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    load_msc_reply(&rep, ust, msc, sbc);
-
-    WriteToClient(client, sizeof(xDRI2MSCReply), &rep);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2WaitMSC(ClientPtr client)
-{
-    REQUEST(xDRI2WaitMSCReq);
-    DrawablePtr pDrawable;
-    CARD64 target, divisor, remainder;
-    int status;
-
-    /* FIXME: in restart case, client may be gone at this point */
-
-    REQUEST_SIZE_MATCH(xDRI2WaitMSCReq);
-
-    if (!validDrawable(client, stuff->drawable, DixReadAccess, &pDrawable,
-		       &status))
-	return status;
-
-    target = vals_to_card64(stuff->target_msc_lo, stuff->target_msc_hi);
-    divisor = vals_to_card64(stuff->divisor_lo, stuff->divisor_hi);
-    remainder = vals_to_card64(stuff->remainder_lo, stuff->remainder_hi);
-
-    status = DRI2WaitMSC(client, pDrawable, target, divisor, remainder);
-    if (status != Success)
-	return status;
-
-    return client->noClientException;
-}
-
-int
-ProcDRI2WaitMSCReply(ClientPtr client, CARD64 ust, CARD64 msc, CARD64 sbc)
-{
-    xDRI2MSCReply rep;
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    load_msc_reply(&rep, ust, msc, sbc);
-
-    WriteToClient(client, sizeof(xDRI2MSCReply), &rep);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2SwapInterval(ClientPtr client)
-{
-    REQUEST(xDRI2SwapIntervalReq);
-    DrawablePtr pDrawable;
-    int status;
-
-    /* FIXME: in restart case, client may be gone at this point */
-
-    REQUEST_SIZE_MATCH(xDRI2SwapIntervalReq);
-
-    if (!validDrawable(client, stuff->drawable, DixReadAccess | DixWriteAccess,
-		       &pDrawable, &status))
-	return status;
-
-    DRI2SwapInterval(pDrawable, stuff->interval);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2WaitSBC(ClientPtr client)
-{
-    REQUEST(xDRI2WaitSBCReq);
-    xDRI2MSCReply rep;
-    DrawablePtr pDrawable;
-    CARD64 target, ust, msc, sbc;
-    int status;
-
-    REQUEST_SIZE_MATCH(xDRI2WaitSBCReq);
-
-    if (!validDrawable(client, stuff->drawable, DixReadAccess, &pDrawable,
-		       &status))
-	return status;
-
-    target = vals_to_card64(stuff->target_sbc_lo, stuff->target_sbc_hi);
-    status = DRI2WaitSBC(client, pDrawable, target, &ust, &msc, &sbc);
-    if (status != Success)
-	return status;
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    load_msc_reply(&rep, ust, msc, sbc);
-
-    WriteToClient(client, sizeof(xDRI2MSCReply), &rep);
-
-    return client->noClientException;
-}
-
-static int
-ProcDRI2Dispatch (ClientPtr client)
-{
-    REQUEST(xReq);
-    
-    switch (stuff->data) {
-    case X_DRI2QueryVersion:
-	return ProcDRI2QueryVersion(client);
-    }
-
-    if (!LocalClient(client))
-	return BadRequest;
-
-    switch (stuff->data) {
-    case X_DRI2Connect:
-	return ProcDRI2Connect(client);
-    case X_DRI2Authenticate:
-	return ProcDRI2Authenticate(client);
-    case X_DRI2CreateDrawable:
-	return ProcDRI2CreateDrawable(client);
-    case X_DRI2DestroyDrawable:
-	return ProcDRI2DestroyDrawable(client);
-    case X_DRI2GetBuffers:
-	return ProcDRI2GetBuffers(client);
-    case X_DRI2CopyRegion:
-	return ProcDRI2CopyRegion(client);
-    case X_DRI2GetBuffersWithFormat:
-	return ProcDRI2GetBuffersWithFormat(client);
-    case X_DRI2SwapBuffers:
-	return ProcDRI2SwapBuffers(client);
-    case X_DRI2GetMSC:
-	return ProcDRI2GetMSC(client);
-    case X_DRI2WaitMSC:
-	return ProcDRI2WaitMSC(client);
-    case X_DRI2WaitSBC:
-	return ProcDRI2WaitSBC(client);
-    case X_DRI2SwapInterval:
-	return ProcDRI2SwapInterval(client);
-    default:
-	return BadRequest;
-    }
-}
-
-static int
-SProcDRI2Connect(ClientPtr client)
-{
-    REQUEST(xDRI2ConnectReq);
-    xDRI2ConnectReply rep;
-    int n;
-
-    /* If the client is swapped, it's not local.  Talk to the hand. */
-
-    swaps(&stuff->length, n);
-    if (sizeof(*stuff) / 4 != client->req_len)
-	return BadLength;
-
-    rep.sequenceNumber = client->sequence;
-    swaps(&rep.sequenceNumber, n);
-    rep.length = 0;
-    rep.driverNameLength = 0;
-    rep.deviceNameLength = 0;
-
-    return client->noClientException;
-}
-
-static int
-SProcDRI2Dispatch (ClientPtr client)
-{
-    REQUEST(xReq);
-
-    /*
-     * Only local clients are allowed DRI access, but remote clients
-     * still need these requests to find out cleanly.
-     */
-    switch (stuff->data)
-    {
-    case X_DRI2QueryVersion:
-	return ProcDRI2QueryVersion(client);
-    case X_DRI2Connect:
-	return SProcDRI2Connect(client);
-    default:
-	return BadRequest;
-    }
-}
-
-int DRI2EventBase;
-
-static void
-DRI2ExtensionInit(void)
-{
-    dri2Extension = AddExtension(DRI2_NAME,
-				 DRI2NumberEvents,
-				 DRI2NumberErrors,
-				 ProcDRI2Dispatch,
-				 SProcDRI2Dispatch,
-				 NULL,
-				 StandardMinorOpcode);
-
-    DRI2EventBase = dri2Extension->eventBase;
-}
-
-extern Bool noDRI2Extension;
-
-_X_HIDDEN ExtensionModule dri2ExtensionModule = {
-    DRI2ExtensionInit,
-    DRI2_NAME,
-    &noDRI2Extension,
-    NULL,
-    NULL
-};
+/*

+ * Copyright © 2008 Red Hat, Inc.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Soft-

+ * ware"), to deal in the Software without restriction, including without

+ * limitation the rights to use, copy, modify, merge, publish, distribute,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, provided that the above copyright

+ * notice(s) and this permission notice appear in all copies of the Soft-

+ * ware and that both the above copyright notice(s) and this permission

+ * notice appear in supporting documentation.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-

+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY

+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN

+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-

+ * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-

+ * MANCE OF THIS SOFTWARE.

+ *

+ * Except as contained in this notice, the name of a copyright holder shall

+ * not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization of

+ * the copyright holder.

+ *

+ * Authors:

+ *   Kristian Høgsberg (krh@redhat.com)

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xproto.h>

+#include <X11/extensions/dri2proto.h>

+#include <X11/extensions/xfixeswire.h>

+#include "dixstruct.h"

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "extnsionst.h"

+#include "xf86drm.h"

+#include "xfixes.h"

+#include "dri2.h"

+#include "protocol-versions.h"

+

+/* The only xf86 include */

+#include "xf86Module.h"

+

+static ExtensionEntry	*dri2Extension;

+

+static Bool

+validDrawable(ClientPtr client, XID drawable, Mask access_mode,

+	      DrawablePtr *pDrawable, int *status)

+{

+    *status = dixLookupDrawable(pDrawable, drawable, client, 0, access_mode);

+    if (*status != Success) {

+	client->errorValue = drawable;

+	return FALSE;

+    }

+

+    return TRUE;

+}

+

+static int

+ProcDRI2QueryVersion(ClientPtr client)

+{

+    REQUEST(xDRI2QueryVersionReq);

+    xDRI2QueryVersionReply rep;

+    int n;

+

+    if (client->swapped)

+	swaps(&stuff->length, n);

+

+    REQUEST_SIZE_MATCH(xDRI2QueryVersionReq);

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    rep.majorVersion = dri2_major;

+    rep.minorVersion = dri2_minor;

+

+    if (client->swapped) {

+    	swaps(&rep.sequenceNumber, n);

+    	swapl(&rep.length, n);

+	swapl(&rep.majorVersion, n);

+	swapl(&rep.minorVersion, n);

+    }

+

+    WriteToClient(client, sizeof(xDRI2QueryVersionReply), &rep);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2Connect(ClientPtr client)

+{

+    REQUEST(xDRI2ConnectReq);

+    xDRI2ConnectReply rep;

+    DrawablePtr pDraw;

+    int fd, status;

+    const char *driverName;

+    const char *deviceName;

+

+    REQUEST_SIZE_MATCH(xDRI2ConnectReq);

+    if (!validDrawable(client, stuff->window, DixGetAttrAccess,

+		       &pDraw, &status))

+	return status;

+    

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    rep.driverNameLength = 0;

+    rep.deviceNameLength = 0;

+

+    if (!DRI2Connect(pDraw->pScreen,

+		     stuff->driverType, &fd, &driverName, &deviceName))

+	goto fail;

+

+    rep.driverNameLength = strlen(driverName);

+    rep.deviceNameLength = strlen(deviceName);

+    rep.length = (rep.driverNameLength + 3) / 4 +

+	    (rep.deviceNameLength + 3) / 4;

+

+ fail:

+    WriteToClient(client, sizeof(xDRI2ConnectReply), &rep);

+    WriteToClient(client, rep.driverNameLength, driverName);

+    WriteToClient(client, rep.deviceNameLength, deviceName);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2Authenticate(ClientPtr client)

+{

+    REQUEST(xDRI2AuthenticateReq);

+    xDRI2AuthenticateReply rep;

+    DrawablePtr pDraw;

+    int status;

+

+    REQUEST_SIZE_MATCH(xDRI2AuthenticateReq);

+    if (!validDrawable(client, stuff->window, DixGetAttrAccess,

+		       &pDraw, &status))

+	return status;

+

+    rep.type = X_Reply;

+    rep.sequenceNumber = client->sequence;

+    rep.length = 0;

+    rep.authenticated = DRI2Authenticate(pDraw->pScreen, stuff->magic);

+    WriteToClient(client, sizeof(xDRI2AuthenticateReply), &rep);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2CreateDrawable(ClientPtr client)

+{

+    REQUEST(xDRI2CreateDrawableReq);

+    DrawablePtr pDrawable;

+    int status;

+

+    REQUEST_SIZE_MATCH(xDRI2CreateDrawableReq);

+

+    if (!validDrawable(client, stuff->drawable, DixAddAccess,

+		       &pDrawable, &status))

+	return status;

+

+    status = DRI2CreateDrawable(client, pDrawable, stuff->drawable);

+    if (status != Success)

+	return status;

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2DestroyDrawable(ClientPtr client)

+{

+    REQUEST(xDRI2DestroyDrawableReq);

+    DrawablePtr pDrawable;

+    int status;

+

+    REQUEST_SIZE_MATCH(xDRI2DestroyDrawableReq);

+    if (!validDrawable(client, stuff->drawable, DixRemoveAccess,

+		       &pDrawable, &status))

+	return status;

+

+    return client->noClientException;

+}

+

+

+static void

+send_buffers_reply(ClientPtr client, DrawablePtr pDrawable,

+		   DRI2BufferPtr *buffers, int count, int width, int height)

+{

+    xDRI2GetBuffersReply rep;

+    int skip = 0;

+    int i;

+

+    if (pDrawable->type == DRAWABLE_WINDOW) {

+	for (i = 0; i < count; i++) {

+	    /* Do not send the real front buffer of a window to the client.

+	     */

+	    if (buffers[i]->attachment == DRI2BufferFrontLeft) {

+		skip++;

+		continue;

+	    }

+	}

+    }

+

+    rep.type = X_Reply;

+    rep.length = (count - skip) * sizeof(xDRI2Buffer) / 4;

+    rep.sequenceNumber = client->sequence;

+    rep.width = width;

+    rep.height = height;

+    rep.count = count - skip;

+    WriteToClient(client, sizeof(xDRI2GetBuffersReply), &rep);

+

+    for (i = 0; i < count; i++) {

+	xDRI2Buffer buffer;

+

+	/* Do not send the real front buffer of a window to the client.

+	 */

+	if ((pDrawable->type == DRAWABLE_WINDOW)

+	    && (buffers[i]->attachment == DRI2BufferFrontLeft)) {

+	    continue;

+	}

+

+	buffer.attachment = buffers[i]->attachment;

+	buffer.name = buffers[i]->name;

+	buffer.pitch = buffers[i]->pitch;

+	buffer.cpp = buffers[i]->cpp;

+	buffer.flags = buffers[i]->flags;

+	WriteToClient(client, sizeof(xDRI2Buffer), &buffer);

+    }

+}

+

+

+static int

+ProcDRI2GetBuffers(ClientPtr client)

+{

+    REQUEST(xDRI2GetBuffersReq);

+    DrawablePtr pDrawable;

+    DRI2BufferPtr *buffers;

+    int status, width, height, count;

+    unsigned int *attachments;

+

+    REQUEST_FIXED_SIZE(xDRI2GetBuffersReq, stuff->count * 4);

+    if (!validDrawable(client, stuff->drawable, DixReadAccess | DixWriteAccess,

+		       &pDrawable, &status))

+	return status;

+

+    if (DRI2ThrottleClient(client, pDrawable))

+	return client->noClientException;

+

+    attachments = (unsigned int *) &stuff[1];

+    buffers = DRI2GetBuffers(pDrawable, &width, &height,

+			     attachments, stuff->count, &count);

+

+

+    send_buffers_reply(client, pDrawable, buffers, count, width, height);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2GetBuffersWithFormat(ClientPtr client)

+{

+    REQUEST(xDRI2GetBuffersReq);

+    DrawablePtr pDrawable;

+    DRI2BufferPtr *buffers;

+    int status, width, height, count;

+    unsigned int *attachments;

+

+    REQUEST_FIXED_SIZE(xDRI2GetBuffersReq, stuff->count * (2 * 4));

+    if (!validDrawable(client, stuff->drawable, DixReadAccess | DixWriteAccess,

+		       &pDrawable, &status))

+	return status;

+

+    if (DRI2ThrottleClient(client, pDrawable))

+	return client->noClientException;

+

+    attachments = (unsigned int *) &stuff[1];

+    buffers = DRI2GetBuffersWithFormat(pDrawable, &width, &height,

+				       attachments, stuff->count, &count);

+

+    send_buffers_reply(client, pDrawable, buffers, count, width, height);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2CopyRegion(ClientPtr client)

+{

+    REQUEST(xDRI2CopyRegionReq);

+    xDRI2CopyRegionReply rep;

+    DrawablePtr pDrawable;

+    int status;

+    RegionPtr pRegion;

+

+    REQUEST_SIZE_MATCH(xDRI2CopyRegionReq);

+

+    if (!validDrawable(client, stuff->drawable, DixWriteAccess,

+		       &pDrawable, &status))

+	return status;

+

+    VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);

+

+    status = DRI2CopyRegion(pDrawable, pRegion, stuff->dest, stuff->src);

+    if (status != Success)

+	return status;

+

+    /* CopyRegion needs to be a round trip to make sure the X server

+     * queues the swap buffer rendering commands before the DRI client

+     * continues rendering.  The reply has a bitmask to signal the

+     * presense of optional return values as well, but we're not using

+     * that yet.

+     */

+

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+

+    WriteToClient(client, sizeof(xDRI2CopyRegionReply), &rep);

+

+    return client->noClientException;

+}

+

+static void

+load_swap_reply(xDRI2SwapBuffersReply *rep, CARD64 sbc)

+{

+    rep->swap_hi = sbc >> 32;

+    rep->swap_lo = sbc & 0xffffffff;

+}

+

+static CARD64

+vals_to_card64(CARD32 lo, CARD32 hi)

+{

+    return (CARD64)hi << 32 | lo;

+}

+

+static void

+DRI2SwapEvent(ClientPtr client, void *data, int type, CARD64 ust, CARD64 msc,

+	      CARD64 sbc)

+{

+    xDRI2BufferSwapComplete event;

+    DrawablePtr pDrawable = data;

+

+    event.type = DRI2EventBase + DRI2_BufferSwapComplete;

+    event.sequenceNumber = client->sequence;

+    event.event_type = type;

+    event.drawable = pDrawable->id;

+    event.ust_hi = (CARD64)ust >> 32;

+    event.ust_lo = ust & 0xffffffff;

+    event.msc_hi = (CARD64)msc >> 32;

+    event.msc_lo = msc & 0xffffffff;

+    event.sbc_hi = (CARD64)sbc >> 32;

+    event.sbc_lo = sbc & 0xffffffff;

+

+    WriteEventsToClient(client, 1, (xEvent *)&event);

+}

+

+static int

+ProcDRI2SwapBuffers(ClientPtr client)

+{

+    REQUEST(xDRI2SwapBuffersReq);

+    xDRI2SwapBuffersReply rep;

+    DrawablePtr pDrawable;

+    CARD64 target_msc, divisor, remainder, swap_target;

+    int status;

+

+    REQUEST_SIZE_MATCH(xDRI2SwapBuffersReq);

+

+    if (!validDrawable(client, stuff->drawable,

+		       DixReadAccess | DixWriteAccess, &pDrawable, &status))

+	return status;

+

+    /*

+     * Ensures an out of control client can't exhaust our swap queue, and

+     * also orders swaps.

+     */

+    if (DRI2ThrottleClient(client, pDrawable))

+	return client->noClientException;

+

+    target_msc = vals_to_card64(stuff->target_msc_lo, stuff->target_msc_hi);

+    divisor = vals_to_card64(stuff->divisor_lo, stuff->divisor_hi);

+    remainder = vals_to_card64(stuff->remainder_lo, stuff->remainder_hi);

+

+    status = DRI2SwapBuffers(client, pDrawable, target_msc, divisor, remainder,

+			     &swap_target, DRI2SwapEvent, pDrawable);

+    if (status != Success)

+	return BadDrawable;

+

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    load_swap_reply(&rep, swap_target);

+

+    WriteToClient(client, sizeof(xDRI2SwapBuffersReply), &rep);

+

+    return client->noClientException;

+}

+

+static void

+load_msc_reply(xDRI2MSCReply *rep, CARD64 ust, CARD64 msc, CARD64 sbc)

+{

+    rep->ust_hi = ust >> 32;

+    rep->ust_lo = ust & 0xffffffff;

+    rep->msc_hi = msc >> 32;

+    rep->msc_lo = msc & 0xffffffff;

+    rep->sbc_hi = sbc >> 32;

+    rep->sbc_lo = sbc & 0xffffffff;

+}

+

+static int

+ProcDRI2GetMSC(ClientPtr client)

+{

+    REQUEST(xDRI2GetMSCReq);

+    xDRI2MSCReply rep;

+    DrawablePtr pDrawable;

+    CARD64 ust, msc, sbc;

+    int status;

+

+    REQUEST_SIZE_MATCH(xDRI2GetMSCReq);

+

+    if (!validDrawable(client, stuff->drawable, DixReadAccess, &pDrawable,

+		       &status))

+	return status;

+

+    status = DRI2GetMSC(pDrawable, &ust, &msc, &sbc);

+    if (status != Success)

+	return status;

+

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    load_msc_reply(&rep, ust, msc, sbc);

+

+    WriteToClient(client, sizeof(xDRI2MSCReply), &rep);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2WaitMSC(ClientPtr client)

+{

+    REQUEST(xDRI2WaitMSCReq);

+    DrawablePtr pDrawable;

+    CARD64 target, divisor, remainder;

+    int status;

+

+    /* FIXME: in restart case, client may be gone at this point */

+

+    REQUEST_SIZE_MATCH(xDRI2WaitMSCReq);

+

+    if (!validDrawable(client, stuff->drawable, DixReadAccess, &pDrawable,

+		       &status))

+	return status;

+

+    target = vals_to_card64(stuff->target_msc_lo, stuff->target_msc_hi);

+    divisor = vals_to_card64(stuff->divisor_lo, stuff->divisor_hi);

+    remainder = vals_to_card64(stuff->remainder_lo, stuff->remainder_hi);

+

+    status = DRI2WaitMSC(client, pDrawable, target, divisor, remainder);

+    if (status != Success)

+	return status;

+

+    return client->noClientException;

+}

+

+int

+ProcDRI2WaitMSCReply(ClientPtr client, CARD64 ust, CARD64 msc, CARD64 sbc)

+{

+    xDRI2MSCReply rep;

+

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    load_msc_reply(&rep, ust, msc, sbc);

+

+    WriteToClient(client, sizeof(xDRI2MSCReply), &rep);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2SwapInterval(ClientPtr client)

+{

+    REQUEST(xDRI2SwapIntervalReq);

+    DrawablePtr pDrawable;

+    int status;

+

+    /* FIXME: in restart case, client may be gone at this point */

+

+    REQUEST_SIZE_MATCH(xDRI2SwapIntervalReq);

+

+    if (!validDrawable(client, stuff->drawable, DixReadAccess | DixWriteAccess,

+		       &pDrawable, &status))

+	return status;

+

+    DRI2SwapInterval(pDrawable, stuff->interval);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2WaitSBC(ClientPtr client)

+{

+    REQUEST(xDRI2WaitSBCReq);

+    xDRI2MSCReply rep;

+    DrawablePtr pDrawable;

+    CARD64 target, ust, msc, sbc;

+    int status;

+

+    REQUEST_SIZE_MATCH(xDRI2WaitSBCReq);

+

+    if (!validDrawable(client, stuff->drawable, DixReadAccess, &pDrawable,

+		       &status))

+	return status;

+

+    target = vals_to_card64(stuff->target_sbc_lo, stuff->target_sbc_hi);

+    status = DRI2WaitSBC(client, pDrawable, target, &ust, &msc, &sbc);

+    if (status != Success)

+	return status;

+

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    load_msc_reply(&rep, ust, msc, sbc);

+

+    WriteToClient(client, sizeof(xDRI2MSCReply), &rep);

+

+    return client->noClientException;

+}

+

+static int

+ProcDRI2Dispatch (ClientPtr client)

+{

+    REQUEST(xReq);

+    

+    switch (stuff->data) {

+    case X_DRI2QueryVersion:

+	return ProcDRI2QueryVersion(client);

+    }

+

+    if (!LocalClient(client))

+	return BadRequest;

+

+    switch (stuff->data) {

+    case X_DRI2Connect:

+	return ProcDRI2Connect(client);

+    case X_DRI2Authenticate:

+	return ProcDRI2Authenticate(client);

+    case X_DRI2CreateDrawable:

+	return ProcDRI2CreateDrawable(client);

+    case X_DRI2DestroyDrawable:

+	return ProcDRI2DestroyDrawable(client);

+    case X_DRI2GetBuffers:

+	return ProcDRI2GetBuffers(client);

+    case X_DRI2CopyRegion:

+	return ProcDRI2CopyRegion(client);

+    case X_DRI2GetBuffersWithFormat:

+	return ProcDRI2GetBuffersWithFormat(client);

+    case X_DRI2SwapBuffers:

+	return ProcDRI2SwapBuffers(client);

+    case X_DRI2GetMSC:

+	return ProcDRI2GetMSC(client);

+    case X_DRI2WaitMSC:

+	return ProcDRI2WaitMSC(client);

+    case X_DRI2WaitSBC:

+	return ProcDRI2WaitSBC(client);

+    case X_DRI2SwapInterval:

+	return ProcDRI2SwapInterval(client);

+    default:

+	return BadRequest;

+    }

+}

+

+static int

+SProcDRI2Connect(ClientPtr client)

+{

+    REQUEST(xDRI2ConnectReq);

+    xDRI2ConnectReply rep;

+    int n;

+

+    /* If the client is swapped, it's not local.  Talk to the hand. */

+

+    swaps(&stuff->length, n);

+    if (sizeof(*stuff) / 4 != client->req_len)

+	return BadLength;

+

+    rep.sequenceNumber = client->sequence;

+    swaps(&rep.sequenceNumber, n);

+    rep.length = 0;

+    rep.driverNameLength = 0;

+    rep.deviceNameLength = 0;

+

+    return client->noClientException;

+}

+

+static int

+SProcDRI2Dispatch (ClientPtr client)

+{

+    REQUEST(xReq);

+

+    /*

+     * Only local clients are allowed DRI access, but remote clients

+     * still need these requests to find out cleanly.

+     */

+    switch (stuff->data)

+    {

+    case X_DRI2QueryVersion:

+	return ProcDRI2QueryVersion(client);

+    case X_DRI2Connect:

+	return SProcDRI2Connect(client);

+    default:

+	return BadRequest;

+    }

+}

+

+int DRI2EventBase;

+

+static void

+DRI2ExtensionInit(void)

+{

+    dri2Extension = AddExtension(DRI2_NAME,

+				 DRI2NumberEvents,

+				 DRI2NumberErrors,

+				 ProcDRI2Dispatch,

+				 SProcDRI2Dispatch,

+				 NULL,

+				 StandardMinorOpcode);

+

+    DRI2EventBase = dri2Extension->eventBase;

+}

+

+extern Bool noDRI2Extension;

+

+_X_HIDDEN ExtensionModule dri2ExtensionModule = {

+    DRI2ExtensionInit,

+    DRI2_NAME,

+    &noDRI2Extension,

+    NULL,

+    NULL

+};