dri: Remove remaining DRI1 vblank code
authorKristian Høgsberg <krh@bitplanet.net>
Fri, 28 Oct 2011 19:47:41 +0000 (15:47 -0400)
committerKristian Høgsberg <krh@bitplanet.net>
Wed, 2 Nov 2011 15:16:01 +0000 (11:16 -0400)
src/mesa/drivers/dri/common/Makefile.sources
src/mesa/drivers/dri/common/vblank.c [deleted file]
src/mesa/drivers/dri/common/vblank.h [deleted file]
src/mesa/drivers/dri/r200/r200_ioctl.c
src/mesa/drivers/dri/radeon/radeon_common.c
src/mesa/drivers/dri/radeon/radeon_common_context.c
src/mesa/drivers/dri/radeon/radeon_ioctl.c
src/mesa/drivers/dri/radeon/radeon_screen.c

index 3432dda4575679e5773ce5e0f2baa576ff54dc02..f21bf860665b23362516583bb7cee3419324a8d2 100644 (file)
@@ -1,6 +1,5 @@
 mesa_dri_common_gallium_SOURCES := \
        utils.c \
-       vblank.c \
        dri_util.c \
        xmlconfig.c
 
diff --git a/src/mesa/drivers/dri/common/vblank.c b/src/mesa/drivers/dri/common/vblank.c
deleted file mode 100644 (file)
index cb98dd0..0000000
+++ /dev/null
@@ -1,434 +0,0 @@
-/* -*- mode: c; c-basic-offset: 3 -*- */
-/*
- * (c) Copyright IBM Corporation 2002
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * on the rights to use, copy, modify, merge, publish, distribute, sub
- * license, and/or sell copies of the Software, and to permit persons to whom
- * the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
- * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
- * USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Ian Romanick <idr@us.ibm.com>
- */
-
-#include "main/glheader.h"
-#include "xf86drm.h"
-#include "main/mtypes.h"
-#include "main/macros.h"
-#include "main/dd.h"
-#include "vblank.h"
-#include "xmlpool.h"
-
-static unsigned int msc_to_vblank(__DRIdrawable * dPriv, int64_t msc)
-{
-   return (unsigned int)(msc - dPriv->msc_base + dPriv->vblank_base);
-}
-
-static int64_t vblank_to_msc(__DRIdrawable * dPriv, unsigned int vblank)
-{
-   return (int64_t)(vblank - dPriv->vblank_base + dPriv->msc_base);
-}
-
-
-/****************************************************************************/
-/**
- * Get the current MSC refresh counter.
- *
- * Stores the 64-bit count of vertical refreshes since some (arbitrary)
- * point in time in \c count.  Unless the value wraps around, which it
- * may, it will never decrease for a given drawable.
- *
- * \warning This function is called from \c glXGetVideoSyncSGI, which expects
- * a \c count of type \c unsigned (32-bit), and \c glXGetSyncValuesOML, which 
- * expects a \c count of type \c int64_t (signed 64-bit).  The kernel ioctl 
- * currently always returns a \c sequence of type \c unsigned.
- *
- * \param priv   Pointer to the DRI screen private struct.
- * \param dPriv  Pointer to the DRI drawable private struct
- * \param count  Storage to hold MSC counter.
- * \return       Zero is returned on success.  A negative errno value
- *               is returned on failure.
- */
-int driDrawableGetMSC32( __DRIscreen * priv,
-                        __DRIdrawable * dPriv,
-                        int64_t * count)
-{
-   drmVBlank vbl;
-   int ret;
-
-   /* Don't wait for anything.  Just get the current refresh count. */
-
-   vbl.request.type = DRM_VBLANK_RELATIVE;
-   vbl.request.sequence = 0;
-   if ( dPriv && dPriv->vblFlags & VBLANK_FLAG_SECONDARY )
-      vbl.request.type |= DRM_VBLANK_SECONDARY;
-
-   ret = drmWaitVBlank( priv->fd, &vbl );
-
-   if (dPriv) {
-      *count = vblank_to_msc(dPriv, vbl.reply.sequence);
-   } else {
-      /* Old driver (no knowledge of drawable MSC callback) */
-      *count = vbl.reply.sequence;
-   }
-
-   return ret;
-}
-
-/****************************************************************************/
-/**
- * Wait for a specified refresh count.  This implements most of the
- * functionality of \c glXWaitForMscOML from the GLX_OML_sync_control spec.
- * Waits for the \c target_msc refresh.  If that has already passed, it
- * waits until \f$(MSC \bmod divisor)\f$ is equal to \c remainder.  If 
- * \c target_msc is 0, use the behavior of glXWaitVideoSyncSGI(), which
- * omits the initial check against a target MSC value.
- * 
- * This function is actually something of a hack.  The problem is that, at
- * the time of this writing, none of the existing DRM modules support an
- * ioctl that returns a 64-bit count (at least not on 32-bit platforms).
- * However, this function exists to support a GLX function that requires
- * the use of 64-bit counts.  As such, there is a little bit of ugly
- * hackery at the end of this function to make the 32-bit count act like
- * a 64-bit count.  There are still some cases where this will break, but
- * I believe it catches the most common cases.
- *
- * The real solution is to provide an ioctl that uses a 64-bit count.
- *
- * \param dpy         Pointer to the \c Display.
- * \param priv        Pointer to the DRI drawable private.
- * \param target_msc  Desired refresh count to wait for.  A value of 0
- *                    means to use the glXWaitVideoSyncSGI() behavior.
- * \param divisor     MSC divisor if \c target_msc is already reached.
- * \param remainder   Desired MSC remainder if \c target_msc is already
- *                    reached.
- * \param msc         Buffer to hold MSC when done waiting.
- *
- * \return            Zero on success or \c GLX_BAD_CONTEXT on failure.
- */
-
-int driWaitForMSC32( __DRIdrawable *priv,
-                    int64_t target_msc, int64_t divisor, int64_t remainder,
-                    int64_t * msc )
-{
-   drmVBlank vbl;
-
-
-   if ( divisor != 0 ) {
-      int64_t next = target_msc;
-      int64_t r;
-      int dont_wait = (target_msc == 0);
-
-      do {
-         /* dont_wait means we're using the glXWaitVideoSyncSGI() behavior.
-          * The first time around, just get the current count and proceed 
-          * to the test for (MSC % divisor) == remainder.
-          */
-         vbl.request.type = dont_wait ? DRM_VBLANK_RELATIVE :
-                                        DRM_VBLANK_ABSOLUTE;
-         vbl.request.sequence = next ? msc_to_vblank(priv, next) : 0;
-        if ( priv->vblFlags & VBLANK_FLAG_SECONDARY )
-           vbl.request.type |= DRM_VBLANK_SECONDARY;
-
-        if ( drmWaitVBlank( priv->driScreenPriv->fd, &vbl ) != 0 ) {
-           /* FIXME: This doesn't seem like the right thing to return here.
-            */
-           return GLX_BAD_CONTEXT;
-        }
-
-        *msc = vblank_to_msc(priv, vbl.reply.sequence);
-
-         if (!dont_wait && *msc == next)
-            break;
-         dont_wait = 0;
-
-         /* Assuming the wait-done test fails, the next refresh to wait for
-          * will be one that satisfies (MSC % divisor) == remainder.  The
-          * value (MSC - (MSC % divisor) + remainder) is the refresh value 
-          * closest to the current value that would satisfy the equation.  
-          * If this refresh has already happened, we add divisor to obtain 
-          * the next refresh after the current one that will satisfy it.
-          */
-         r = ((uint64_t)*msc % divisor);
-         next = (*msc - r + remainder);
-         if (next <= *msc)
-           next += divisor;
-
-      } while (r != remainder);
-   }
-   else {
-      /* If the \c divisor is zero, just wait until the MSC is greater
-       * than or equal to \c target_msc.
-       */
-
-      vbl.request.type = DRM_VBLANK_ABSOLUTE;
-      vbl.request.sequence = target_msc ? msc_to_vblank(priv, target_msc) : 0;
-
-      if ( priv->vblFlags & VBLANK_FLAG_SECONDARY )
-        vbl.request.type |= DRM_VBLANK_SECONDARY;
-
-      if ( drmWaitVBlank( priv->driScreenPriv->fd, &vbl ) != 0 ) {
-        /* FIXME: This doesn't seem like the right thing to return here.
-         */
-        return GLX_BAD_CONTEXT;
-      }
-   }
-
-   *msc = vblank_to_msc(priv, vbl.reply.sequence);
-
-   if ( *msc < target_msc ) {
-      *msc += 0x0000000100000000LL;
-   }
-
-   return 0;
-}
-
-
-/****************************************************************************/
-/**
- * Gets a set of default vertical-blank-wait flags based on the internal GLX
- * API version and several configuration options.
- */
-
-GLuint driGetDefaultVBlankFlags( const driOptionCache *optionCache )
-{
-   GLuint  flags = VBLANK_FLAG_INTERVAL;
-   int vblank_mode;
-
-
-   if ( driCheckOption( optionCache, "vblank_mode", DRI_ENUM ) )
-      vblank_mode = driQueryOptioni( optionCache, "vblank_mode" );
-   else
-      vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
-
-   switch (vblank_mode) {
-   case DRI_CONF_VBLANK_NEVER:
-      flags = 0;
-      break;
-   case DRI_CONF_VBLANK_DEF_INTERVAL_0:
-      break;
-   case DRI_CONF_VBLANK_DEF_INTERVAL_1:
-      flags |= VBLANK_FLAG_THROTTLE;
-      break;
-   case DRI_CONF_VBLANK_ALWAYS_SYNC:
-      flags |= VBLANK_FLAG_SYNC;
-      break;
-   }
-
-   return flags;
-}
-
-
-/****************************************************************************/
-/**
- * Wrapper to call \c drmWaitVBlank.  The main purpose of this function is to
- * wrap the error message logging.  The error message should only be logged
- * the first time the \c drmWaitVBlank fails.  If \c drmWaitVBlank is
- * successful, \c vbl_seq will be set the sequence value in the reply.
- *
- * \param vbl      Pointer to drmVBlank packet describing how to wait.
- * \param vbl_seq  Location to store the current refresh counter.
- * \param fd       File descriptor use to call into the DRM.
- * \return         Zero on success or -1 on failure.
- */
-
-static int do_wait( drmVBlank * vbl, GLuint * vbl_seq, int fd )
-{
-   int   ret;
-
-
-   ret = drmWaitVBlank( fd, vbl );
-   if ( ret != 0 ) {
-      static GLboolean first_time = GL_TRUE;
-
-      if ( first_time ) {
-        fprintf(stderr, 
-                "%s: drmWaitVBlank returned %d, IRQs don't seem to be"
-                " working correctly.\nTry adjusting the vblank_mode"
-                " configuration parameter.\n", __FUNCTION__, ret);
-        first_time = GL_FALSE;
-      }
-
-      return -1;
-   }
-
-   *vbl_seq = vbl->reply.sequence;
-   return 0;
-}
-
-
-/****************************************************************************/
-/**
- * Returns the default swap interval of the given drawable.
- */
-
-static unsigned
-driGetDefaultVBlankInterval( const  __DRIdrawable *priv )
-{
-   if ( (priv->vblFlags & (VBLANK_FLAG_THROTTLE | VBLANK_FLAG_SYNC)) != 0 ) {
-      return 1;
-   }
-   else {
-      return 0;
-   }
-}
-
-
-/****************************************************************************/
-/**
- * Sets the default swap interval when the drawable is first bound to a
- * direct rendering context.
- */
-
-void driDrawableInitVBlank( __DRIdrawable *priv )
-{
-   if ( priv->swap_interval == (unsigned)-1 &&
-       !( priv->vblFlags & VBLANK_FLAG_NO_IRQ ) ) {
-      /* Get current vertical blank sequence */
-      drmVBlank vbl;
-      vbl.request.type = DRM_VBLANK_RELATIVE;
-      if ( priv->vblFlags & VBLANK_FLAG_SECONDARY )
-        vbl.request.type |= DRM_VBLANK_SECONDARY;
-      vbl.request.sequence = 0;
-      do_wait( &vbl, &priv->vblSeq, priv->driScreenPriv->fd );
-      priv->vblank_base = priv->vblSeq;
-
-      priv->swap_interval = driGetDefaultVBlankInterval( priv );
-   }
-}
-
-
-/****************************************************************************/
-/**
- * Returns the current swap interval of the given drawable.
- */
-
-unsigned
-driGetVBlankInterval( const  __DRIdrawable *priv )
-{
-   if ( (priv->vblFlags & VBLANK_FLAG_INTERVAL) != 0 ) {
-      /* this must have been initialized when the drawable was first bound
-       * to a direct rendering context. */
-      assert ( priv->swap_interval != (unsigned)-1 );
-
-      return priv->swap_interval;
-   }
-   else 
-      return driGetDefaultVBlankInterval( priv );
-}
-
-
-/****************************************************************************/
-/**
- * Returns the current vertical blank sequence number of the given drawable.
- */
-
-void
-driGetCurrentVBlank( __DRIdrawable *priv )
-{
-   drmVBlank vbl;
-
-   vbl.request.type = DRM_VBLANK_RELATIVE;
-   if ( priv->vblFlags & VBLANK_FLAG_SECONDARY ) {
-      vbl.request.type |= DRM_VBLANK_SECONDARY;
-   }
-   vbl.request.sequence = 0;
-
-   (void) do_wait( &vbl, &priv->vblSeq, priv->driScreenPriv->fd );
-}
-
-
-/****************************************************************************/
-/**
- * Waits for the vertical blank for use with glXSwapBuffers.
- * 
- * \param missed_deadline  Set to \c GL_TRUE if the MSC after waiting is later
- *                 than the "target" based on \c priv->vblFlags.  The idea is
- *                 that if \c missed_deadline is set, then the application is
- *                 not achieving its desired framerate.
- * \return         Zero on success, -1 on error.
- */
-
-int
-driWaitForVBlank( __DRIdrawable *priv, GLboolean * missed_deadline )
-{
-   drmVBlank vbl;
-   unsigned   original_seq;
-   unsigned   deadline;
-   unsigned   interval;
-   unsigned   diff;
-
-   *missed_deadline = GL_FALSE;
-   if ( (priv->vblFlags & (VBLANK_FLAG_INTERVAL |
-                          VBLANK_FLAG_THROTTLE |
-                          VBLANK_FLAG_SYNC)) == 0 ||
-       (priv->vblFlags & VBLANK_FLAG_NO_IRQ) != 0 ) {
-      return 0;
-   }
-
-
-   /* VBLANK_FLAG_SYNC means to wait for at least one vertical blank.  If
-    * that flag is not set, do a fake wait for zero vertical blanking
-    * periods so that we can get the current MSC.
-    *
-    * VBLANK_FLAG_INTERVAL and VBLANK_FLAG_THROTTLE mean to wait for at
-    * least one vertical blank since the last wait.  Since do_wait modifies
-    * priv->vblSeq, we have to save the original value of priv->vblSeq for the
-    * VBLANK_FLAG_INTERVAL / VBLANK_FLAG_THROTTLE calculation later.
-    */
-
-   original_seq = priv->vblSeq;
-   interval = driGetVBlankInterval(priv);
-   deadline = original_seq + interval;
-
-   vbl.request.type = DRM_VBLANK_RELATIVE;
-   if ( priv->vblFlags & VBLANK_FLAG_SECONDARY ) {
-      vbl.request.type |= DRM_VBLANK_SECONDARY;
-   }
-   vbl.request.sequence = ((priv->vblFlags & VBLANK_FLAG_SYNC) != 0) ? 1 : 0;
-
-   if ( do_wait( & vbl, &priv->vblSeq, priv->driScreenPriv->fd ) != 0 ) {
-      return -1;
-   }
-
-   diff = priv->vblSeq - deadline;
-
-   /* No need to wait again if we've already reached the target */
-   if (diff <= (1 << 23)) {
-      *missed_deadline = (priv->vblFlags & VBLANK_FLAG_SYNC) ? (diff > 0) :
-                        GL_TRUE;
-      return 0;
-   }
-
-   /* Wait until the target vertical blank. */
-   vbl.request.type = DRM_VBLANK_ABSOLUTE;
-   if ( priv->vblFlags & VBLANK_FLAG_SECONDARY ) {
-      vbl.request.type |= DRM_VBLANK_SECONDARY;
-   }
-   vbl.request.sequence = deadline;
-
-   if ( do_wait( & vbl, &priv->vblSeq, priv->driScreenPriv->fd ) != 0 ) {
-      return -1;
-   }
-
-   diff = priv->vblSeq - deadline;
-   *missed_deadline = diff > 0 && diff <= (1 << 23);
-
-   return 0;
-}
diff --git a/src/mesa/drivers/dri/common/vblank.h b/src/mesa/drivers/dri/common/vblank.h
deleted file mode 100644 (file)
index 067fb5e..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-/* -*- mode: c; c-basic-offset: 3 -*- */
-/*
- * (c) Copyright IBM Corporation 2002
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * on the rights to use, copy, modify, merge, publish, distribute, sub
- * license, and/or sell copies of the Software, and to permit persons to whom
- * the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
- * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
- * USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Ian Romanick <idr@us.ibm.com>
- */
-
-#ifndef DRI_VBLANK_H
-#define DRI_VBLANK_H
-
-#include "main/context.h"
-#include "dri_util.h"
-#include "xmlconfig.h"
-
-#define VBLANK_FLAG_INTERVAL  (1U << 0)  /* Respect the swap_interval setting
-                                         */
-#define VBLANK_FLAG_THROTTLE  (1U << 1)  /* Wait 1 refresh since last call.
-                                         */
-#define VBLANK_FLAG_SYNC      (1U << 2)  /* Sync to the next refresh.
-                                         */
-#define VBLANK_FLAG_NO_IRQ    (1U << 7)  /* DRM has no IRQ to wait on.
-                                         */
-#define VBLANK_FLAG_SECONDARY (1U << 8)  /* Wait for secondary vblank.
-                                         */
-
-extern int driGetMSC32( __DRIscreen * priv, int64_t * count );
-extern int driDrawableGetMSC32( __DRIscreen * priv,
-                               __DRIdrawable * drawablePrivate,
-                               int64_t * count);
-extern int driWaitForMSC32( __DRIdrawable *priv,
-    int64_t target_msc, int64_t divisor, int64_t remainder, int64_t * msc );
-extern GLuint driGetDefaultVBlankFlags( const driOptionCache *optionCache );
-extern void driDrawableInitVBlank ( __DRIdrawable *priv );
-extern unsigned driGetVBlankInterval( const  __DRIdrawable *priv );
-extern void driGetCurrentVBlank( __DRIdrawable *priv );
-extern int driWaitForVBlank( __DRIdrawable *priv,
-                            GLboolean * missed_deadline );
-
-#undef usleep
-#include <unistd.h>  /* for usleep() */
-#include <sched.h>   /* for sched_yield() */
-
-#define DO_USLEEP(nr)                                                  \
-   do {                                                                        \
-      if (0) fprintf(stderr, "%s: usleep for %u\n", __FUNCTION__, nr );        \
-      if (1) usleep( nr );                                             \
-      sched_yield();                                                   \
-   } while( 0 )
-
-#endif /* DRI_VBLANK_H */
index 3b0e431b2d6b4050166e1af98782a8e8fef7688b..e3570c2a08a6cc7c98eaea3122b8212cc2a2bec6 100644 (file)
@@ -48,8 +48,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r200_ioctl.h"
 #include "radeon_reg.h"
 
-#include "vblank.h"
-
 #define R200_TIMEOUT             512
 #define R200_IDLE_RETRY           16
 
index 8f682175afbc31e290a8db358d7d9d789c902724..cc3fed8623d251b3ee3df27031acf17c8d3fbfb5 100644 (file)
@@ -50,8 +50,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "main/renderbuffer.h"
 #include "drivers/common/meta.h"
 
-#include "vblank.h"
-
 #include "radeon_common.h"
 #include "radeon_drm.h"
 #include "radeon_queryobj.h"
index 437f780c2f1522ea6b0194811501fff98e117381..5c9ab4f459e93a348d560ce8f1a5b265deb2ede0 100644 (file)
@@ -35,7 +35,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "radeon_common.h"
 #include "xmlpool.h"           /* for symbolic values of enum-type options */
 #include "utils.h"
-#include "vblank.h"
 #include "drirenderbuffer.h"
 #include "drivers/common/meta.h"
 #include "main/context.h"
@@ -711,15 +710,6 @@ GLboolean radeonMakeCurrent(__DRIcontext * driContextPriv,
 
        if (radeon->glCtx->DrawBuffer == drfb) {
                if(driDrawPriv != NULL) {
-                       if (driDrawPriv->swap_interval == (unsigned)-1) {
-                               driDrawPriv->vblFlags =
-                                       (radeon->radeonScreen->irq != 0)
-                                       ? driGetDefaultVBlankFlags(&radeon->
-                                                                  optionCache)
-                                       : VBLANK_FLAG_NO_IRQ;
-
-                               driDrawableInitVBlank(driDrawPriv);
-                       }
                        radeon_window_moved(radeon);
                }
 
index d1ae9fcb72086e8706da9fc953ebdf3285960643..434f2b61c7a3b1a34174c9798257b0491ac82f67 100644 (file)
@@ -51,8 +51,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #define STANDALONE_MMIO
 
-#include "vblank.h"
-
 #define RADEON_TIMEOUT             512
 #define RADEON_IDLE_RETRY           16
 
index e3766e81f3f40fb69bc7be9adaa763cf52c75a3f..36e72869251477642d5e81ee1e9249b0ab74f45b 100644 (file)
@@ -58,7 +58,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #endif
 
 #include "utils.h"
-#include "vblank.h"
 
 #include "GL/internal/dri_interface.h"