src/mesa/drivers/dri/common/dri_util.c

   1 /* $XFree86: xc/lib/GL/dri/dri_util.c,v 1.7 2003/04/28 17:01:25 dawes Exp $ */
   2 /**
   3  * \file dri_util.c
   4  * DRI utility functions.
   5  *
   6  * This module acts as glue between GLX and the actual hardware driver.  A DRI
   7  * driver doesn't really \e have to use any of this - it's optional.  But, some
   8  * useful stuff is done here that otherwise would have to be duplicated in most
   9  * drivers.
  10  *
  11  * Basically, these utility functions take care of some of the dirty details of
  12  * screen initialization, context creation, context binding, DRM setup, etc.
  13  *
  14  * These functions are compiled into each DRI driver so libGL.so knows nothing
  15  * about them.
  16  */
  17
  18
  19 #include <assert.h>
  20 #include <stdarg.h>
  21 #include <unistd.h>
  22 #include <sys/mman.h>
  23 #include <stdio.h>
  24
  25 #ifndef MAP_FAILED
  26 #define MAP_FAILED ((void *)-1)
  27 #endif
  28
  29 #include "imports.h"
  30 #define None 0
  31
  32 #include "dri_util.h"
  33 #include "drm_sarea.h"
  34
  35 #ifndef GLX_OML_sync_control
  36 typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRInativeDisplay *dpy, __DRIid drawable, int32_t *numerator, int32_t *denominator);
  37 #endif
  38
  39 /* This pointer *must* be set by the driver's __driCreateNewScreen funciton!
  40  */
  41 const __DRIinterfaceMethods * dri_interface = NULL;
  42
  43 /**
  44  * This is used in a couple of places that call \c driCreateNewDrawable.
  45  */
  46 static const int empty_attribute_list[1] = { None };
  47
  48
  49 /**
  50  * Cached copy of the internal API version used by libGL and the client-side
  51  * DRI driver.
  52  */
  53 static int api_ver = 0;
  54
  55 /* forward declarations */
  56 static int driQueryFrameTracking( __DRInativeDisplay *dpy, void *priv,
  57                                   int64_t *sbc, int64_t *missedFrames,
  58                                   float *lastMissedUsage, float *usage );
  59
  60 static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
  61                                   const __GLcontextModes *modes,
  62                                   __DRIid draw, __DRIdrawable *pdraw,
  63                                   int renderType, const int *attrs);
  64
  65 static void driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate);
  66
  67
  68 /**
  69  * Print message to \c stderr if the \c LIBGL_DEBUG environment variable
  70  * is set.
  71  *
  72  * Is called from the drivers.
  73  *
  74  * \param f \c printf like format string.
  75  */
  76 void
  77 __driUtilMessage(const char *f, ...)
  78 {
  79     va_list args;
  80
  81     if (getenv("LIBGL_DEBUG")) {
  82         fprintf(stderr, "libGL error: \n");
  83         va_start(args, f);
  84         vfprintf(stderr, f, args);
  85         va_end(args);
  86         fprintf(stderr, "\n");
  87     }
  88 }
  89
  90
  91 /*****************************************************************/
  92 /** \name Drawable list management */
  93 /*****************************************************************/
  94 /*@{*/
  95
  96 static GLboolean __driAddDrawable(void *drawHash, __DRIdrawable *pdraw)
  97 {
  98     __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
  99
 100     if (drmHashInsert(drawHash, pdp->draw, pdraw))
 101         return GL_FALSE;
 102
 103     return GL_TRUE;
 104 }
 105
 106 static __DRIdrawable *__driFindDrawable(void *drawHash, __DRIid draw)
 107 {
 108     int retcode;
 109     __DRIdrawable *pdraw;
 110
 111     retcode = drmHashLookup(drawHash, draw, (void *)&pdraw);
 112     if (retcode)
 113         return NULL;
 114
 115     return pdraw;
 116 }
 117
 118
 119 /**
 120  * Find drawables in the local hash that have been destroyed on the
 121  * server.
 122  *
 123  * \param drawHash  Hash-table containing all know drawables.
 124  */
 125 static void __driGarbageCollectDrawables(void *drawHash)
 126 {
 127     __DRIid draw;
 128     __DRInativeDisplay *dpy;
 129     __DRIdrawable *pdraw;
 130
 131     if (drmHashFirst(drawHash, &draw, (void *)&pdraw) == 1) {
 132         do {
 133             __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
 134             dpy = pdp->driScreenPriv->display;
 135             if (! (*dri_interface->windowExists)(dpy, draw)) {
 136                 /* Destroy the local drawable data, if the drawable no
 137                    longer exists in the Xserver */
 138                 (*pdraw->destroyDrawable)(dpy, pdraw->private);
 139                 _mesa_free(pdraw);
 140             }
 141         } while (drmHashNext(drawHash, &draw, (void *)&pdraw) == 1);
 142     }
 143 }
 144
 145 /*@}*/
 146
 147
 148 /*****************************************************************/
 149 /** \name Context (un)binding functions                          */
 150 /*****************************************************************/
 151 /*@{*/
 152
 153 /**
 154  * Unbind context.
 155  *
 156  * \param dpy the display handle.
 157  * \param scrn the screen number.
 158  * \param draw drawable.
 159  * \param read Current reading drawable.
 160  * \param gc context.
 161  *
 162  * \return \c GL_TRUE on success, or \c GL_FALSE on failure.
 163  *
 164  * \internal
 165  * This function calls __DriverAPIRec::UnbindContext, and then decrements
 166  * __DRIdrawablePrivateRec::refcount which must be non-zero for a successful
 167  * return.
 168  *
 169  * While casting the opaque private pointers associated with the parameters
 170  * into their respective real types it also assures they are not \c NULL.
 171  */
 172 static GLboolean driUnbindContext(__DRInativeDisplay *dpy, int scrn,
 173                               __DRIid draw, __DRIid read,
 174                               __DRIcontext *ctx)
 175 {
 176     __DRIscreen *pDRIScreen;
 177     __DRIdrawable *pdraw;
 178     __DRIdrawable *pread;
 179     __DRIcontextPrivate *pcp;
 180     __DRIscreenPrivate *psp;
 181     __DRIdrawablePrivate *pdp;
 182     __DRIdrawablePrivate *prp;
 183
 184     /*
 185     ** Assume error checking is done properly in glXMakeCurrent before
 186     ** calling driUnbindContext.
 187     */
 188
 189     if (ctx == NULL || draw == None || read == None) {
 190         /* ERROR!!! */
 191         return GL_FALSE;
 192     }
 193
 194     pDRIScreen = (*dri_interface->getScreen)(dpy, scrn);
 195     if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
 196         /* ERROR!!! */
 197         return GL_FALSE;
 198     }
 199
 200     psp = (__DRIscreenPrivate *)pDRIScreen->private;
 201     pcp = (__DRIcontextPrivate *)ctx->private;
 202
 203     pdraw = __driFindDrawable(psp->drawHash, draw);
 204     if (!pdraw) {
 205         /* ERROR!!! */
 206         return GL_FALSE;
 207     }
 208     pdp = (__DRIdrawablePrivate *)pdraw->private;
 209
 210     pread = __driFindDrawable(psp->drawHash, read);
 211     if (!pread) {
 212         /* ERROR!!! */
 213         return GL_FALSE;
 214     }
 215     prp = (__DRIdrawablePrivate *)pread->private;
 216
 217
 218     /* Let driver unbind drawable from context */
 219     (*psp->DriverAPI.UnbindContext)(pcp);
 220
 221
 222     if (pdp->refcount == 0) {
 223         /* ERROR!!! */
 224         return GL_FALSE;
 225     }
 226
 227     pdp->refcount--;
 228
 229     if (prp != pdp) {
 230         if (prp->refcount == 0) {
 231             /* ERROR!!! */
 232             return GL_FALSE;
 233         }
 234
 235         prp->refcount--;
 236     }
 237
 238
 239     /* XXX this is disabled so that if we call SwapBuffers on an unbound
 240      * window we can determine the last context bound to the window and
 241      * use that context's lock. (BrianP, 2-Dec-2000)
 242      */
 243 #if 0
 244     /* Unbind the drawable */
 245     pcp->driDrawablePriv = NULL;
 246     pdp->driContextPriv = &psp->dummyContextPriv;
 247 #endif
 248
 249     return GL_TRUE;
 250 }
 251
 252
 253 /**
 254  * This function takes both a read buffer and a draw buffer.  This is needed
 255  * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
 256  * function.
 257  *
 258  * \bug This function calls \c driCreateNewDrawable in two places with the
 259  *      \c renderType hard-coded to \c GLX_WINDOW_BIT.  Some checking might
 260  *      be needed in those places when support for pbuffers and / or pixmaps
 261  *      is added.  Is it safe to assume that the drawable is a window?
 262  */
 263 static GLboolean DoBindContext(__DRInativeDisplay *dpy,
 264                           __DRIid draw, __DRIid read,
 265                           __DRIcontext *ctx, const __GLcontextModes * modes,
 266                           __DRIscreenPrivate *psp)
 267 {
 268     __DRIdrawable *pdraw;
 269     __DRIdrawablePrivate *pdp;
 270     __DRIdrawable *pread;
 271     __DRIdrawablePrivate *prp;
 272     __DRIcontextPrivate * const pcp = ctx->private;
 273
 274
 275     /* Find the _DRIdrawable which corresponds to the writing drawable. */
 276     pdraw = __driFindDrawable(psp->drawHash, draw);
 277     if (!pdraw) {
 278         /* Allocate a new drawable */
 279         pdraw = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
 280         if (!pdraw) {
 281             /* ERROR!!! */
 282             return GL_FALSE;
 283         }
 284
 285         /* Create a new drawable */
 286         driCreateNewDrawable(dpy, modes, draw, pdraw, GLX_WINDOW_BIT,
 287                              empty_attribute_list);
 288         if (!pdraw->private) {
 289             /* ERROR!!! */
 290             _mesa_free(pdraw);
 291             return GL_FALSE;
 292         }
 293
 294     }
 295     pdp = (__DRIdrawablePrivate *) pdraw->private;
 296
 297     /* Find the _DRIdrawable which corresponds to the reading drawable. */
 298     if (read == draw) {
 299         /* read buffer == draw buffer */
 300         prp = pdp;
 301     }
 302     else {
 303         pread = __driFindDrawable(psp->drawHash, read);
 304         if (!pread) {
 305             /* Allocate a new drawable */
 306             pread = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
 307             if (!pread) {
 308                 /* ERROR!!! */
 309                 return GL_FALSE;
 310             }
 311
 312             /* Create a new drawable */
 313             driCreateNewDrawable(dpy, modes, read, pread, GLX_WINDOW_BIT,
 314                                  empty_attribute_list);
 315             if (!pread->private) {
 316                 /* ERROR!!! */
 317                 _mesa_free(pread);
 318                 return GL_FALSE;
 319             }
 320         }
 321         prp = (__DRIdrawablePrivate *) pread->private;
 322     }
 323
 324     /* Bind the drawable to the context */
 325     pcp->driDrawablePriv = pdp;
 326     pdp->driContextPriv = pcp;
 327     pdp->refcount++;
 328     if ( pdp != prp ) {
 329         prp->refcount++;
 330     }
 331
 332     /*
 333     ** Now that we have a context associated with this drawable, we can
 334     ** initialize the drawable information if has not been done before.
 335     */
 336     if (!pdp->pStamp || *pdp->pStamp != pdp->lastStamp) {
 337         DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 338         __driUtilUpdateDrawableInfo(pdp);
 339         DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 340     }
 341
 342     /* Call device-specific MakeCurrent */
 343     (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);
 344
 345     return GL_TRUE;
 346 }
 347
 348
 349 /**
 350  * This function takes both a read buffer and a draw buffer.  This is needed
 351  * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
 352  * function.
 353  */
 354 static GLboolean driBindContext(__DRInativeDisplay *dpy, int scrn,
 355                             __DRIid draw, __DRIid read,
 356                             __DRIcontext * ctx)
 357 {
 358     __DRIscreen *pDRIScreen;
 359
 360     /*
 361     ** Assume error checking is done properly in glXMakeCurrent before
 362     ** calling driBindContext.
 363     */
 364
 365     if (ctx == NULL || draw == None || read == None) {
 366         /* ERROR!!! */
 367         return GL_FALSE;
 368     }
 369
 370     pDRIScreen = (*dri_interface->getScreen)(dpy, scrn);
 371     if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
 372         /* ERROR!!! */
 373         return GL_FALSE;
 374     }
 375
 376     return DoBindContext( dpy, draw, read, ctx, ctx->mode,
 377                           (__DRIscreenPrivate *)pDRIScreen->private );
 378 }
 379 /*@}*/
 380
 381
 382 /*****************************************************************/
 383 /** \name Drawable handling functions                            */
 384 /*****************************************************************/
 385 /*@{*/
 386
 387 /**
 388  * Update private drawable information.
 389  *
 390  * \param pdp pointer to the private drawable information to update.
 391  *
 392  * This function basically updates the __DRIdrawablePrivate struct's
 393  * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.
 394  * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
 395  * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If
 396  * the values are different that means we have to update the clipping
 397  * info.
 398  */
 399 void
 400 __driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp)
 401 {
 402     __DRIscreenPrivate *psp;
 403     __DRIcontextPrivate *pcp = pdp->driContextPriv;
 404
 405     if (!pcp || (pdp != pcp->driDrawablePriv)) {
 406         /* ERROR!!! */
 407         return;
 408     }
 409
 410     psp = pdp->driScreenPriv;
 411     if (!psp) {
 412         /* ERROR!!! */
 413         return;
 414     }
 415
 416     if (pdp->pClipRects) {
 417         _mesa_free(pdp->pClipRects);
 418     }
 419
 420     if (pdp->pBackClipRects) {
 421         _mesa_free(pdp->pBackClipRects);
 422     }
 423
 424     DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 425
 426     if (!__driFindDrawable(psp->drawHash, pdp->draw) ||
 427         ! (*dri_interface->getDrawableInfo)(pdp->display, pdp->screen, pdp->draw,
 428                           &pdp->index, &pdp->lastStamp,
 429                           &pdp->x, &pdp->y, &pdp->w, &pdp->h,
 430                           &pdp->numClipRects, &pdp->pClipRects,
 431                           &pdp->backX,
 432                           &pdp->backY,
 433                           &pdp->numBackClipRects,
 434                           &pdp->pBackClipRects )) {
 435         /* Error -- eg the window may have been destroyed.  Keep going
 436          * with no cliprects.
 437          */
 438         pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */
 439         pdp->numClipRects = 0;
 440         pdp->pClipRects = NULL;
 441         pdp->numBackClipRects = 0;
 442         pdp->pBackClipRects = NULL;
 443     }
 444     else
 445        pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
 446
 447     DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 448
 449 }
 450
 451 /*@}*/
 452
 453 /*****************************************************************/
 454 /** \name GLX callbacks                                          */
 455 /*****************************************************************/
 456 /*@{*/
 457
 458 /**
 459  * Swap buffers.
 460  *
 461  * \param dpy the display handle.
 462  * \param drawablePrivate opaque pointer to the per-drawable private info.
 463  *
 464  * \internal
 465  * This function calls __DRIdrawablePrivate::swapBuffers.
 466  *
 467  * Is called directly from glXSwapBuffers().
 468  */
 469 static void driSwapBuffers( __DRInativeDisplay *dpy, void *drawablePrivate )
 470 {
 471     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
 472     dPriv->swapBuffers(dPriv);
 473     (void) dpy;
 474 }
 475
 476 /**
 477  * Called directly from a number of higher-level GLX functions.
 478  */
 479 static int driGetMSC( void *screenPrivate, int64_t *msc )
 480 {
 481     __DRIscreenPrivate *sPriv = (__DRIscreenPrivate *) screenPrivate;
 482
 483     return sPriv->DriverAPI.GetMSC( sPriv, msc );
 484 }
 485
 486 /**
 487  * Called directly from a number of higher-level GLX functions.
 488  */
 489 static int driGetSBC( __DRInativeDisplay *dpy, void *drawablePrivate, int64_t *sbc )
 490 {
 491    __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
 492    __DRIswapInfo  sInfo;
 493    int  status;
 494
 495
 496    status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
 497    *sbc = sInfo.swap_count;
 498
 499    return status;
 500 }
 501
 502 static int driWaitForSBC( __DRInativeDisplay * dpy, void *drawablePriv,
 503                           int64_t target_sbc,
 504                           int64_t * msc, int64_t * sbc )
 505 {
 506     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
 507
 508     return dPriv->driScreenPriv->DriverAPI.WaitForSBC( dPriv, target_sbc,
 509                                                        msc, sbc );
 510 }
 511
 512 static int driWaitForMSC( __DRInativeDisplay * dpy, void *drawablePriv,
 513                           int64_t target_msc,
 514                           int64_t divisor, int64_t remainder,
 515                           int64_t * msc, int64_t * sbc )
 516 {
 517     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
 518     __DRIswapInfo  sInfo;
 519     int  status;
 520
 521
 522     status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,
 523                                                          divisor, remainder,
 524                                                          msc );
 525
 526     /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync
 527      * is supported but GLX_OML_sync_control is not.  Therefore, don't return
 528      * an error value if GetSwapInfo() is not implemented.
 529     */
 530     if ( status == 0
 531          && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {
 532         status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
 533         *sbc = sInfo.swap_count;
 534     }
 535
 536     return status;
 537 }
 538
 539 static int64_t driSwapBuffersMSC( __DRInativeDisplay * dpy, void *drawablePriv,
 540                                   int64_t target_msc,
 541                                   int64_t divisor, int64_t remainder )
 542 {
 543     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
 544
 545     return dPriv->driScreenPriv->DriverAPI.SwapBuffersMSC( dPriv, target_msc,
 546                                                            divisor,
 547                                                            remainder );
 548 }
 549
 550
 551 /**
 552  * This is called via __DRIscreenRec's createNewDrawable pointer.
 553  */
 554 static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
 555                                   const __GLcontextModes *modes,
 556                                   __DRIid draw,
 557                                   __DRIdrawable *pdraw,
 558                                   int renderType,
 559                                   const int *attrs)
 560 {
 561     __DRIscreen * const pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
 562     __DRIscreenPrivate *psp;
 563     __DRIdrawablePrivate *pdp;
 564
 565
 566     pdraw->private = NULL;
 567
 568     /* Since pbuffers are not yet supported, no drawable attributes are
 569      * supported either.
 570      */
 571     (void) attrs;
 572
 573     if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
 574         return NULL;
 575     }
 576
 577     pdp = (__DRIdrawablePrivate *)_mesa_malloc(sizeof(__DRIdrawablePrivate));
 578     if (!pdp) {
 579         return NULL;
 580     }
 581
 582     if (!(*dri_interface->createDrawable)(dpy, modes->screen, draw, &pdp->hHWDrawable)) {
 583         _mesa_free(pdp);
 584         return NULL;
 585     }
 586
 587     pdp->draw = draw;
 588     pdp->pdraw = pdraw;
 589     pdp->refcount = 0;
 590     pdp->pStamp = NULL;
 591     pdp->lastStamp = 0;
 592     pdp->index = 0;
 593     pdp->x = 0;
 594     pdp->y = 0;
 595     pdp->w = 0;
 596     pdp->h = 0;
 597     pdp->numClipRects = 0;
 598     pdp->numBackClipRects = 0;
 599     pdp->pClipRects = NULL;
 600     pdp->pBackClipRects = NULL;
 601     pdp->display = dpy;
 602     pdp->screen = modes->screen;
 603
 604     psp = (__DRIscreenPrivate *)pDRIScreen->private;
 605     pdp->driScreenPriv = psp;
 606     pdp->driContextPriv = &psp->dummyContextPriv;
 607
 608     if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, modes,
 609                                         renderType == GLX_PIXMAP_BIT)) {
 610        (void)(*dri_interface->destroyDrawable)(dpy, modes->screen, pdp->draw);
 611        _mesa_free(pdp);
 612        return NULL;
 613     }
 614
 615     pdraw->private = pdp;
 616     pdraw->destroyDrawable = driDestroyDrawable;
 617     pdraw->swapBuffers = driSwapBuffers;  /* called by glXSwapBuffers() */
 618
 619     pdraw->getSBC = driGetSBC;
 620     pdraw->waitForSBC = driWaitForSBC;
 621     pdraw->waitForMSC = driWaitForMSC;
 622     pdraw->swapBuffersMSC = driSwapBuffersMSC;
 623     pdraw->frameTracking = NULL;
 624     pdraw->queryFrameTracking = driQueryFrameTracking;
 625
 626     /* This special default value is replaced with the configured
 627      * default value when the drawable is first bound to a direct
 628      * rendering context.
 629      */
 630     pdraw->swap_interval = (unsigned)-1;
 631
 632     pdp->swapBuffers = psp->DriverAPI.SwapBuffers;
 633
 634     /* Add pdraw to drawable list */
 635     if (!__driAddDrawable(psp->drawHash, pdraw)) {
 636         /* ERROR!!! */
 637         (*pdraw->destroyDrawable)(dpy, pdp);
 638         _mesa_free(pdp);
 639         pdp = NULL;
 640         pdraw->private = NULL;
 641     }
 642
 643    return (void *) pdp;
 644 }
 645
 646 static __DRIdrawable *
 647 driGetDrawable(__DRInativeDisplay *dpy, __DRIid draw, void *screenPrivate)
 648 {
 649     __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
 650
 651     /*
 652     ** Make sure this routine returns NULL if the drawable is not bound
 653     ** to a direct rendering context!
 654     */
 655     return __driFindDrawable(psp->drawHash, draw);
 656 }
 657
 658 static void
 659 driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate)
 660 {
 661     __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *) drawablePrivate;
 662     __DRIscreenPrivate *psp;
 663     int scrn;
 664
 665     if (pdp) {
 666         psp = pdp->driScreenPriv;
 667         scrn = psp->myNum;
 668         (*psp->DriverAPI.DestroyBuffer)(pdp);
 669         if ((*dri_interface->windowExists)(dpy, pdp->draw))
 670             (void)(*dri_interface->destroyDrawable)(dpy, scrn, pdp->draw);
 671         drmHashDelete(psp->drawHash, pdp->draw);
 672         if (pdp->pClipRects) {
 673             _mesa_free(pdp->pClipRects);
 674             pdp->pClipRects = NULL;
 675         }
 676         if (pdp->pBackClipRects) {
 677             _mesa_free(pdp->pBackClipRects);
 678             pdp->pBackClipRects = NULL;
 679         }
 680         _mesa_free(pdp);
 681     }
 682 }
 683
 684 /*@}*/
 685
 686
 687 /*****************************************************************/
 688 /** \name Context handling functions                             */
 689 /*****************************************************************/
 690 /*@{*/
 691
 692 /**
 693  * Destroy the per-context private information.
 694  *
 695  * \param dpy the display handle.
 696  * \param scrn the screen number.
 697  * \param contextPrivate opaque pointer to the per-drawable private info.
 698  *
 699  * \internal
 700  * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
 701  * drmDestroyContext(), and finally frees \p contextPrivate.
 702  */
 703 static void
 704 driDestroyContext(__DRInativeDisplay *dpy, int scrn, void *contextPrivate)
 705 {
 706     __DRIcontextPrivate  *pcp   = (__DRIcontextPrivate *) contextPrivate;
 707
 708     if (pcp) {
 709         (*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
 710         __driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
 711         (void) (*dri_interface->destroyContext)(dpy, scrn, pcp->contextID);
 712         _mesa_free(pcp);
 713     }
 714 }
 715
 716
 717 /**
 718  * Create the per-drawable private driver information.
 719  *
 720  * \param dpy           The display handle.
 721  * \param modes         Mode used to create the new context.
 722  * \param render_type   Type of rendering target.  \c GLX_RGBA is the only
 723  *                      type likely to ever be supported for direct-rendering.
 724  * \param sharedPrivate The shared context dependent methods or \c NULL if
 725  *                      non-existent.
 726  * \param pctx          DRI context to receive the context dependent methods.
 727  *
 728  * \returns An opaque pointer to the per-context private information on
 729  *          success, or \c NULL on failure.
 730  *
 731  * \internal
 732  * This function allocates and fills a __DRIcontextPrivateRec structure.  It
 733  * performs some device independent initialization and passes all the
 734  * relevent information to __DriverAPIRec::CreateContext to create the
 735  * context.
 736  *
 737  */
 738 static void *
 739 driCreateNewContext(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
 740                     int render_type, void *sharedPrivate, __DRIcontext *pctx)
 741 {
 742     __DRIscreen *pDRIScreen;
 743     __DRIcontextPrivate *pcp;
 744     __DRIcontextPrivate *pshare = (__DRIcontextPrivate *) sharedPrivate;
 745     __DRIscreenPrivate *psp;
 746     void * const shareCtx = (pshare != NULL) ? pshare->driverPrivate : NULL;
 747
 748     pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
 749     if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
 750         /* ERROR!!! */
 751         return NULL;
 752     }
 753
 754     psp = (__DRIscreenPrivate *)pDRIScreen->private;
 755
 756     pcp = (__DRIcontextPrivate *)_mesa_malloc(sizeof(__DRIcontextPrivate));
 757     if (!pcp) {
 758         return NULL;
 759     }
 760
 761     if (! (*dri_interface->createContext)(dpy, modes->screen, modes->fbconfigID,
 762                                         &pcp->contextID, &pcp->hHWContext)) {
 763         _mesa_free(pcp);
 764         return NULL;
 765     }
 766
 767     pcp->display = dpy;
 768     pcp->driScreenPriv = psp;
 769     pcp->driDrawablePriv = NULL;
 770
 771     /* When the first context is created for a screen, initialize a "dummy"
 772      * context.
 773      */
 774
 775     if (!psp->dummyContextPriv.driScreenPriv) {
 776         psp->dummyContextPriv.contextID = 0;
 777         psp->dummyContextPriv.hHWContext = psp->pSAREA->dummy_context;
 778         psp->dummyContextPriv.driScreenPriv = psp;
 779         psp->dummyContextPriv.driDrawablePriv = NULL;
 780         psp->dummyContextPriv.driverPrivate = NULL;
 781         /* No other fields should be used! */
 782     }
 783
 784     pctx->destroyContext = driDestroyContext;
 785     pctx->bindContext    = driBindContext;
 786     pctx->unbindContext  = driUnbindContext;
 787
 788     if ( !(*psp->DriverAPI.CreateContext)(modes, pcp, shareCtx) ) {
 789         (void) (*dri_interface->destroyContext)(dpy, modes->screen,
 790                                                 pcp->contextID);
 791         _mesa_free(pcp);
 792         return NULL;
 793     }
 794
 795     __driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
 796
 797     return pcp;
 798 }
 799 /*@}*/
 800
 801
 802 /*****************************************************************/
 803 /** \name Screen handling functions                              */
 804 /*****************************************************************/
 805 /*@{*/
 806
 807 /**
 808  * Destroy the per-screen private information.
 809  *
 810  * \param dpy the display handle.
 811  * \param scrn the screen number.
 812  * \param screenPrivate opaque pointer to the per-screen private information.
 813  *
 814  * \internal
 815  * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
 816  * drmClose(), and finally frees \p screenPrivate.
 817  */
 818 static void driDestroyScreen(__DRInativeDisplay *dpy, int scrn, void *screenPrivate)
 819 {
 820     __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
 821
 822     if (psp) {
 823         /* No interaction with the X-server is possible at this point.  This
 824          * routine is called after XCloseDisplay, so there is no protocol
 825          * stream open to the X-server anymore.
 826          */
 827
 828         if (psp->DriverAPI.DestroyScreen)
 829             (*psp->DriverAPI.DestroyScreen)(psp);
 830
 831         (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
 832         (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
 833         _mesa_free(psp->pDevPriv);
 834         (void)drmClose(psp->fd);
 835         if ( psp->modes != NULL ) {
 836             (*dri_interface->destroyContextModes)( psp->modes );
 837         }
 838         _mesa_free(psp);
 839     }
 840 }
 841
 842
 843 /**
 844  * Utility function used to create a new driver-private screen structure.
 845  *
 846  * \param dpy   Display pointer
 847  * \param scrn  Index of the screen
 848  * \param psc   DRI screen data (not driver private)
 849  * \param modes Linked list of known display modes.  This list is, at a
 850  *              minimum, a list of modes based on the current display mode.
 851  *              These roughly match the set of available X11 visuals, but it
 852  *              need not be limited to X11!  The calling libGL should create
 853  *              a list that will inform the driver of the current display
 854  *              mode (i.e., color buffer depth, depth buffer depth, etc.).
 855  * \param ddx_version Version of the 2D DDX.  This may not be meaningful for
 856  *                    all drivers.
 857  * \param dri_version Version of the "server-side" DRI.
 858  * \param drm_version Version of the kernel DRM.
 859  * \param frame_buffer Data describing the location and layout of the
 860  *                     framebuffer.
 861  * \param pSAREA       Pointer the the SAREA.
 862  * \param fd           Device handle for the DRM.
 863  * \param internal_api_version  Version of the internal interface between the
 864  *                              driver and libGL.
 865  * \param driverAPI Driver API functions used by other routines in dri_util.c.
 866  *
 867  * \note
 868  * There is no need to check the minimum API version in this function.  Since
 869  * the \c __driCreateNewScreen function is versioned, it is impossible for a
 870  * loader that is too old to even load this driver.
 871  */
 872 __DRIscreenPrivate *
 873 __driUtilCreateNewScreen(__DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
 874                          __GLcontextModes * modes,
 875                          const __DRIversion * ddx_version,
 876                          const __DRIversion * dri_version,
 877                          const __DRIversion * drm_version,
 878                          const __DRIframebuffer * frame_buffer,
 879                          drm_sarea_t *pSAREA,
 880                          int fd,
 881                          int internal_api_version,
 882                          const struct __DriverAPIRec *driverAPI)
 883 {
 884     __DRIscreenPrivate *psp;
 885
 886
 887     api_ver = internal_api_version;
 888
 889     psp = (__DRIscreenPrivate *)_mesa_malloc(sizeof(__DRIscreenPrivate));
 890     if (!psp) {
 891         return NULL;
 892     }
 893
 894     /* Create the hash table */
 895     psp->drawHash = drmHashCreate();
 896     if ( psp->drawHash == NULL ) {
 897         _mesa_free( psp );
 898         return NULL;
 899     }
 900
 901     psp->display = dpy;
 902     psp->myNum = scrn;
 903     psp->psc = psc;
 904     psp->modes = modes;
 905
 906     /*
 907     ** NOT_DONE: This is used by the X server to detect when the client
 908     ** has died while holding the drawable lock.  The client sets the
 909     ** drawable lock to this value.
 910     */
 911     psp->drawLockID = 1;
 912
 913     psp->drmMajor = drm_version->major;
 914     psp->drmMinor = drm_version->minor;
 915     psp->drmPatch = drm_version->patch;
 916     psp->ddxMajor = ddx_version->major;
 917     psp->ddxMinor = ddx_version->minor;
 918     psp->ddxPatch = ddx_version->patch;
 919     psp->driMajor = dri_version->major;
 920     psp->driMinor = dri_version->minor;
 921     psp->driPatch = dri_version->patch;
 922
 923     /* install driver's callback functions */
 924     memcpy( &psp->DriverAPI, driverAPI, sizeof(struct __DriverAPIRec) );
 925
 926     psp->pSAREA = pSAREA;
 927
 928     psp->pFB = frame_buffer->base;
 929     psp->fbSize = frame_buffer->size;
 930     psp->fbStride = frame_buffer->stride;
 931     psp->fbWidth = frame_buffer->width;
 932     psp->fbHeight = frame_buffer->height;
 933     psp->devPrivSize = frame_buffer->dev_priv_size;
 934     psp->pDevPriv = frame_buffer->dev_priv;
 935     psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;
 936
 937     psp->fd = fd;
 938
 939     /*
 940     ** Do not init dummy context here; actual initialization will be
 941     ** done when the first DRI context is created.  Init screen priv ptr
 942     ** to NULL to let CreateContext routine that it needs to be inited.
 943     */
 944     psp->dummyContextPriv.driScreenPriv = NULL;
 945
 946     psc->destroyScreen     = driDestroyScreen;
 947     psc->createNewDrawable = driCreateNewDrawable;
 948     psc->getDrawable       = driGetDrawable;
 949     psc->getMSC            = driGetMSC;
 950     psc->createNewContext  = driCreateNewContext;
 951
 952     if ( (psp->DriverAPI.InitDriver != NULL)
 953          && !(*psp->DriverAPI.InitDriver)(psp) ) {
 954         _mesa_free( psp );
 955         return NULL;
 956     }
 957
 958
 959     return psp;
 960 }
 961
 962
 963 /**
 964  * Compare the current GLX API version with a driver supplied required version.
 965  *
 966  * The minimum required version is compared with the API version exported by
 967  * the \c __glXGetInternalVersion function (in libGL.so).
 968  *
 969  * \param   required_version Minimum required internal GLX API version.
 970  * \return  A tri-value return, as from strcmp is returned.  A value less
 971  *          than, equal to, or greater than zero will be returned if the
 972  *          internal GLX API version is less than, equal to, or greater
 973  *          than \c required_version.
 974  *
 975  * \sa __glXGetInternalVersion().
 976  */
 977 int driCompareGLXAPIVersion( GLint required_version )
 978 {
 979    if ( api_ver > required_version ) {
 980       return 1;
 981    }
 982    else if ( api_ver == required_version ) {
 983       return 0;
 984    }
 985
 986    return -1;
 987 }
 988
 989
 990 static int
 991 driQueryFrameTracking( __DRInativeDisplay * dpy, void * priv,
 992                        int64_t * sbc, int64_t * missedFrames,
 993                        float * lastMissedUsage, float * usage )
 994 {
 995    __DRIswapInfo   sInfo;
 996    int             status;
 997    int64_t         ust;
 998    __DRIdrawablePrivate * dpriv = (__DRIdrawablePrivate *) priv;
 999
1000
1001    status = dpriv->driScreenPriv->DriverAPI.GetSwapInfo( dpriv, & sInfo );
1002    if ( status == 0 ) {
1003       *sbc = sInfo.swap_count;
1004       *missedFrames = sInfo.swap_missed_count;
1005       *lastMissedUsage = sInfo.swap_missed_usage;
1006
1007       (*dri_interface->getUST)( & ust );
1008       *usage = driCalculateSwapUsage( dpriv, sInfo.swap_ust, ust );
1009    }
1010
1011    return status;
1012 }
1013
1014
1015 /**
1016  * Calculate amount of swap interval used between GLX buffer swaps.
1017  *
1018  * The usage value, on the range [0,max], is the fraction of total swap
1019  * interval time used between GLX buffer swaps is calculated.
1020  *
1021  *            \f$p = t_d / (i * t_r)\f$
1022  *
1023  * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the
1024  * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time
1025  * required for a single vertical refresh period (as returned by \c
1026  * glXGetMscRateOML).
1027  *
1028  * See the documentation for the GLX_MESA_swap_frame_usage extension for more
1029  * details.
1030  *
1031  * \param   dPriv  Pointer to the private drawable structure.
1032  * \return  If less than a single swap interval time period was required
1033  *          between GLX buffer swaps, a number greater than 0 and less than
1034  *          1.0 is returned.  If exactly one swap interval time period is
1035  *          required, 1.0 is returned, and if more than one is required then
1036  *          a number greater than 1.0 will be returned.
1037  *
1038  * \sa glXSwapIntervalSGI glXGetMscRateOML
1039  *
1040  * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it
1041  *       be possible to cache the sync rate?
1042  */
1043 float
1044 driCalculateSwapUsage( __DRIdrawablePrivate *dPriv, int64_t last_swap_ust,
1045                        int64_t current_ust )
1046 {
1047    int32_t   n;
1048    int32_t   d;
1049    int       interval;
1050    float     usage = 1.0;
1051
1052
1053    if ( (*dri_interface->getMSCRate)( dPriv->display, dPriv->draw, &n, &d ) ) {
1054       interval = (dPriv->pdraw->swap_interval != 0)
1055           ? dPriv->pdraw->swap_interval : 1;
1056
1057
1058       /* We want to calculate
1059        * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get
1060        * current_UST by calling __glXGetUST.  last_swap_UST is stored in
1061        * dPriv->swap_ust.  interval has already been calculated.
1062        *
1063        * The only tricky part is us_per_refresh.  us_per_refresh is
1064        * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it
1065        * around and say us_per_refresh = 1000000 * d / n.  Since this goes in
1066        * the denominator of the final calculation, we calculate
1067        * (interval * 1000000 * d) and move n into the numerator.
1068        */
1069
1070       usage = (current_ust - last_swap_ust);
1071       usage *= n;
1072       usage /= (interval * d);
1073       usage /= 1000000.0;
1074    }
1075
1076    return usage;
1077 }
1078
1079 /*@}*/