IABSD.fr/xenocara/xserver/miext/sync/misync.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : matthieu
  Date : 2013-06-07 17:28:45
  Hash : adec87cf
  Message : Update to X server 1.14.1. Tested by many during t2k13. Thanks.

• xserver/miext/sync/misync.c

• /*
   * Copyright © 2010 NVIDIA Corporation
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
   * THE AUTHORS OR COPYRIGHT HOLDERS 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.
   */
  
  #ifdef HAVE_DIX_CONFIG_H
  #include <dix-config.h>
  #endif
  
  #include "scrnintstr.h"
  #include "misync.h"
  #include "misyncstr.h"
  
  static DevPrivateKeyRec syncScreenPrivateKeyRec;
  static DevPrivateKey syncScreenPrivateKey = &syncScreenPrivateKeyRec;
  
  #define SYNC_SCREEN_PRIV(pScreen) 				\
      (SyncScreenPrivPtr) dixLookupPrivate(&pScreen->devPrivates,	\
  					 syncScreenPrivateKey)
  
  typedef struct _syncScreenPriv {
      /* Wrappable sync-specific screen functions */
      SyncScreenFuncsRec funcs;
  
      /* Wrapped screen functions */
      CloseScreenProcPtr CloseScreen;
  } SyncScreenPrivRec, *SyncScreenPrivPtr;
  
  /* Default implementations of the sync screen functions */
  void
  miSyncScreenCreateFence(ScreenPtr pScreen, SyncFence * pFence,
                          Bool initially_triggered)
  {
      (void) pScreen;
  
      pFence->triggered = initially_triggered;
  }
  
  void
  miSyncScreenDestroyFence(ScreenPtr pScreen, SyncFence * pFence)
  {
      (void) pScreen;
      (void) pFence;
  }
  
  /* Default implementations of the per-object functions */
  static void
  miSyncFenceSetTriggered(SyncFence * pFence)
  {
      pFence->triggered = TRUE;
  }
  
  static void
  miSyncFenceReset(SyncFence * pFence)
  {
      pFence->triggered = FALSE;
  }
  
  static Bool
  miSyncFenceCheckTriggered(SyncFence * pFence)
  {
      return pFence->triggered;
  }
  
  static void
  miSyncFenceAddTrigger(SyncTrigger * pTrigger)
  {
      (void) pTrigger;
  
      return;
  }
  
  static void
  miSyncFenceDeleteTrigger(SyncTrigger * pTrigger)
  {
      (void) pTrigger;
  
      return;
  }
  
  /* Machine independent portion of the fence sync object implementation */
  void
  miSyncInitFence(ScreenPtr pScreen, SyncFence * pFence, Bool initially_triggered)
  {
      SyncScreenPrivPtr pScreenPriv = SYNC_SCREEN_PRIV(pScreen);
  
      static const SyncFenceFuncsRec miSyncFenceFuncs = {
          &miSyncFenceSetTriggered,
          &miSyncFenceReset,
          &miSyncFenceCheckTriggered,
          &miSyncFenceAddTrigger,
          &miSyncFenceDeleteTrigger
      };
  
      pFence->pScreen = pScreen;
      pFence->funcs = miSyncFenceFuncs;
  
      pScreenPriv->funcs.CreateFence(pScreen, pFence, initially_triggered);
  }
  
  void
  miSyncDestroyFence(SyncFence * pFence)
  {
      ScreenPtr pScreen = pFence->pScreen;
      SyncScreenPrivPtr pScreenPriv = SYNC_SCREEN_PRIV(pScreen);
      SyncTriggerList *ptl, *pNext;
  
      pFence->sync.beingDestroyed = TRUE;
      /* tell all the fence's triggers that the counter has been destroyed */
      for (ptl = pFence->sync.pTriglist; ptl; ptl = pNext) {
          (*ptl->pTrigger->CounterDestroyed) (ptl->pTrigger);
          pNext = ptl->next;
          free(ptl);              /* destroy the trigger list as we go */
      }
  
      pScreenPriv->funcs.DestroyFence(pScreen, pFence);
  
      dixFreeObjectWithPrivates(pFence, PRIVATE_SYNC_FENCE);
  }
  
  void
  miSyncTriggerFence(SyncFence * pFence)
  {
      SyncTriggerList *ptl, *pNext;
      CARD64 unused;
  
      pFence->funcs.SetTriggered(pFence);
  
      XSyncIntToValue(&unused, 0L);
  
      /* run through triggers to see if any fired */
      for (ptl = pFence->sync.pTriglist; ptl; ptl = pNext) {
          pNext = ptl->next;
          if ((*ptl->pTrigger->CheckTrigger) (ptl->pTrigger, unused))
              (*ptl->pTrigger->TriggerFired) (ptl->pTrigger);
      }
  }
  
  SyncScreenFuncsPtr
  miSyncGetScreenFuncs(ScreenPtr pScreen)
  {
      SyncScreenPrivPtr pScreenPriv = SYNC_SCREEN_PRIV(pScreen);
  
      return &pScreenPriv->funcs;
  }
  
  static Bool
  SyncCloseScreen(ScreenPtr pScreen)
  {
      SyncScreenPrivPtr pScreenPriv = SYNC_SCREEN_PRIV(pScreen);
  
      pScreen->CloseScreen = pScreenPriv->CloseScreen;
  
      return (*pScreen->CloseScreen) (pScreen);
  }
  
  Bool
  miSyncSetup(ScreenPtr pScreen)
  {
      SyncScreenPrivPtr pScreenPriv;
  
      static const SyncScreenFuncsRec miSyncScreenFuncs = {
          &miSyncScreenCreateFence,
          &miSyncScreenDestroyFence
      };
  
      if (dixPrivateKeyRegistered(syncScreenPrivateKey))
          return TRUE;
  
      if (!dixRegisterPrivateKey(syncScreenPrivateKey, PRIVATE_SCREEN,
                                 sizeof(SyncScreenPrivRec)))
          return FALSE;
  
      pScreenPriv = SYNC_SCREEN_PRIV(pScreen);
  
      pScreenPriv->funcs = miSyncScreenFuncs;
  
      /* Wrap CloseScreen to clean up */
      pScreenPriv->CloseScreen = pScreen->CloseScreen;
      pScreen->CloseScreen = SyncCloseScreen;
  
      return TRUE;
  }