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     pcp->driReadablePriv = prp;
 327     pdp->driContextPriv = pcp;
 328     pdp->refcount++;
 329     if ( pdp != prp ) {
 330         prp->refcount++;
 331     }
 332
 333     /*
 334     ** Now that we have a context associated with this drawable, we can
 335     ** initialize the drawable information if has not been done before.
 336     */
 337     if (!pdp->pStamp || *pdp->pStamp != pdp->lastStamp) {
 338         DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 339         __driUtilUpdateDrawableInfo(pdp);
 340         DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 341     }
 342
 343     if ((pdp != prp) && (!prp->pStamp || *prp->pStamp != prp->lastStamp)) {
 344         DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 345         __driUtilUpdateDrawableInfo(prp);
 346         DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 347     }
 348
 349     /* Call device-specific MakeCurrent */
 350     (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);
 351
 352     return GL_TRUE;
 353 }
 354
 355
 356 /**
 357  * This function takes both a read buffer and a draw buffer.  This is needed
 358  * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
 359  * function.
 360  */
 361 static GLboolean driBindContext(__DRInativeDisplay *dpy, int scrn,
 362                             __DRIid draw, __DRIid read,
 363                             __DRIcontext * ctx)
 364 {
 365     __DRIscreen *pDRIScreen;
 366
 367     /*
 368     ** Assume error checking is done properly in glXMakeCurrent before
 369     ** calling driBindContext.
 370     */
 371
 372     if (ctx == NULL || draw == None || read == None) {
 373         /* ERROR!!! */
 374         return GL_FALSE;
 375     }
 376
 377     pDRIScreen = (*dri_interface->getScreen)(dpy, scrn);
 378     if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
 379         /* ERROR!!! */
 380         return GL_FALSE;
 381     }
 382
 383     return DoBindContext( dpy, draw, read, ctx, ctx->mode,
 384                           (__DRIscreenPrivate *)pDRIScreen->private );
 385 }
 386 /*@}*/
 387
 388
 389 /*****************************************************************/
 390 /** \name Drawable handling functions                            */
 391 /*****************************************************************/
 392 /*@{*/
 393
 394 /**
 395  * Update private drawable information.
 396  *
 397  * \param pdp pointer to the private drawable information to update.
 398  *
 399  * This function basically updates the __DRIdrawablePrivate struct's
 400  * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.
 401  * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
 402  * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If
 403  * the values are different that means we have to update the clipping
 404  * info.
 405  */
 406 void
 407 __driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp)
 408 {
 409     __DRIscreenPrivate *psp;
 410     __DRIcontextPrivate *pcp = pdp->driContextPriv;
 411
 412     if (!pcp
 413         || ((pdp != pcp->driDrawablePriv) && (pdp != pcp->driReadablePriv))) {
 414         /* ERROR!!!
 415          * ...but we must ignore it. There can be many contexts bound to a
 416          * drawable.
 417          */
 418     }
 419
 420     psp = pdp->driScreenPriv;
 421     if (!psp) {
 422         /* ERROR!!! */
 423        _mesa_problem(NULL, "Warning! Possible infinite loop due to bug "
 424                      "in file %s, line %d\n",
 425                      __FILE__, __LINE__);
 426         return;
 427     }
 428
 429     if (pdp->pClipRects) {
 430         _mesa_free(pdp->pClipRects);
 431         pdp->pClipRects = NULL;
 432     }
 433
 434     if (pdp->pBackClipRects) {
 435         _mesa_free(pdp->pBackClipRects);
 436         pdp->pBackClipRects = NULL;
 437     }
 438
 439     DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 440
 441     if (!__driFindDrawable(psp->drawHash, pdp->draw) ||
 442         ! (*dri_interface->getDrawableInfo)(pdp->display, pdp->screen, pdp->draw,
 443                           &pdp->index, &pdp->lastStamp,
 444                           &pdp->x, &pdp->y, &pdp->w, &pdp->h,
 445                           &pdp->numClipRects, &pdp->pClipRects,
 446                           &pdp->backX,
 447                           &pdp->backY,
 448                           &pdp->numBackClipRects,
 449                           &pdp->pBackClipRects )) {
 450         /* Error -- eg the window may have been destroyed.  Keep going
 451          * with no cliprects.
 452          */
 453         pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */
 454         pdp->numClipRects = 0;
 455         pdp->pClipRects = NULL;
 456         pdp->numBackClipRects = 0;
 457         pdp->pBackClipRects = NULL;
 458     }
 459     else
 460        pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
 461
 462     DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 463
 464 }
 465
 466 /*@}*/
 467
 468 /*****************************************************************/
 469 /** \name GLX callbacks                                          */
 470 /*****************************************************************/
 471 /*@{*/
 472
 473 /**
 474  * Swap buffers.
 475  *
 476  * \param dpy the display handle.
 477  * \param drawablePrivate opaque pointer to the per-drawable private info.
 478  *
 479  * \internal
 480  * This function calls __DRIdrawablePrivate::swapBuffers.
 481  *
 482  * Is called directly from glXSwapBuffers().
 483  */
 484 static void driSwapBuffers( __DRInativeDisplay *dpy, void *drawablePrivate )
 485 {
 486     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
 487     drm_clip_rect_t rect;
 488
 489     dPriv->swapBuffers(dPriv);
 490
 491     /* Check that we actually have the new damage report method */
 492     if (api_ver < 20070105 || dri_interface->reportDamage == NULL)
 493         return;
 494
 495     /* Assume it's affecting the whole drawable for now */
 496     rect.x1 = 0;
 497     rect.y1 = 0;
 498     rect.x2 = rect.x1 + dPriv->w;
 499     rect.y2 = rect.y1 + dPriv->h;
 500
 501     /* Report the damage.  Currently, all our drivers draw directly to the
 502      * front buffer, so we report the damage there rather than to the backing
 503      * store (if any).
 504      */
 505     (*dri_interface->reportDamage)(dpy, dPriv->screen, dPriv->draw,
 506                                    dPriv->x, dPriv->y,
 507                                    &rect, 1, GL_TRUE);
 508 }
 509
 510 /**
 511  * Called directly from a number of higher-level GLX functions.
 512  */
 513 static int driGetMSC( void *screenPrivate, int64_t *msc )
 514 {
 515     __DRIscreenPrivate *sPriv = (__DRIscreenPrivate *) screenPrivate;
 516
 517     return sPriv->DriverAPI.GetMSC( sPriv, msc );
 518 }
 519
 520 /**
 521  * Called directly from a number of higher-level GLX functions.
 522  */
 523 static int driGetSBC( __DRInativeDisplay *dpy, void *drawablePrivate, int64_t *sbc )
 524 {
 525    __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
 526    __DRIswapInfo  sInfo;
 527    int  status;
 528
 529
 530    status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
 531    *sbc = sInfo.swap_count;
 532
 533    return status;
 534 }
 535
 536 static int driWaitForSBC( __DRInativeDisplay * dpy, void *drawablePriv,
 537                           int64_t target_sbc,
 538                           int64_t * msc, int64_t * sbc )
 539 {
 540     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
 541
 542     return dPriv->driScreenPriv->DriverAPI.WaitForSBC( dPriv, target_sbc,
 543                                                        msc, sbc );
 544 }
 545
 546 static int driWaitForMSC( __DRInativeDisplay * dpy, void *drawablePriv,
 547                           int64_t target_msc,
 548                           int64_t divisor, int64_t remainder,
 549                           int64_t * msc, int64_t * sbc )
 550 {
 551     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
 552     __DRIswapInfo  sInfo;
 553     int  status;
 554
 555
 556     status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,
 557                                                          divisor, remainder,
 558                                                          msc );
 559
 560     /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync
 561      * is supported but GLX_OML_sync_control is not.  Therefore, don't return
 562      * an error value if GetSwapInfo() is not implemented.
 563     */
 564     if ( status == 0
 565          && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {
 566         status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
 567         *sbc = sInfo.swap_count;
 568     }
 569
 570     return status;
 571 }
 572
 573 static int64_t driSwapBuffersMSC( __DRInativeDisplay * dpy, void *drawablePriv,
 574                                   int64_t target_msc,
 575                                   int64_t divisor, int64_t remainder )
 576 {
 577     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
 578
 579     return dPriv->driScreenPriv->DriverAPI.SwapBuffersMSC( dPriv, target_msc,
 580                                                            divisor,
 581                                                            remainder );
 582 }
 583
 584 static void driCopySubBuffer( __DRInativeDisplay *dpy, void *drawablePrivate,
 585                               int x, int y, int w, int h)
 586 {
 587     __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
 588     dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);
 589     (void) dpy;
 590 }
 591
 592 /**
 593  * This is called via __DRIscreenRec's createNewDrawable pointer.
 594  */
 595 static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
 596                                   const __GLcontextModes *modes,
 597                                   __DRIid draw,
 598                                   __DRIdrawable *pdraw,
 599                                   int renderType,
 600                                   const int *attrs)
 601 {
 602     __DRIscreen * const pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
 603     __DRIscreenPrivate *psp;
 604     __DRIdrawablePrivate *pdp;
 605
 606
 607     pdraw->private = NULL;
 608
 609     /* Since pbuffers are not yet supported, no drawable attributes are
 610      * supported either.
 611      */
 612     (void) attrs;
 613
 614     if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
 615         return NULL;
 616     }
 617
 618     pdp = (__DRIdrawablePrivate *)_mesa_malloc(sizeof(__DRIdrawablePrivate));
 619     if (!pdp) {
 620         return NULL;
 621     }
 622
 623     if (!(*dri_interface->createDrawable)(dpy, modes->screen, draw, &pdp->hHWDrawable)) {
 624         _mesa_free(pdp);
 625         return NULL;
 626     }
 627
 628     pdp->draw = draw;
 629     pdp->pdraw = pdraw;
 630     pdp->refcount = 0;
 631     pdp->pStamp = NULL;
 632     pdp->lastStamp = 0;
 633     pdp->index = 0;
 634     pdp->x = 0;
 635     pdp->y = 0;
 636     pdp->w = 0;
 637     pdp->h = 0;
 638     pdp->numClipRects = 0;
 639     pdp->numBackClipRects = 0;
 640     pdp->pClipRects = NULL;
 641     pdp->pBackClipRects = NULL;
 642     pdp->display = dpy;
 643     pdp->screen = modes->screen;
 644
 645     psp = (__DRIscreenPrivate *)pDRIScreen->private;
 646     pdp->driScreenPriv = psp;
 647     pdp->driContextPriv = &psp->dummyContextPriv;
 648
 649     if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, modes,
 650                                         renderType == GLX_PIXMAP_BIT)) {
 651        (void)(*dri_interface->destroyDrawable)(dpy, modes->screen, pdp->draw);
 652        _mesa_free(pdp);
 653        return NULL;
 654     }
 655
 656     pdraw->private = pdp;
 657     pdraw->destroyDrawable = driDestroyDrawable;
 658     pdraw->swapBuffers = driSwapBuffers;  /* called by glXSwapBuffers() */
 659
 660     pdraw->getSBC = driGetSBC;
 661     pdraw->waitForSBC = driWaitForSBC;
 662     pdraw->waitForMSC = driWaitForMSC;
 663     pdraw->swapBuffersMSC = driSwapBuffersMSC;
 664     pdraw->frameTracking = NULL;
 665     pdraw->queryFrameTracking = driQueryFrameTracking;
 666
 667     if (driCompareGLXAPIVersion (20060314) >= 0)
 668         pdraw->copySubBuffer = driCopySubBuffer;
 669
 670     /* This special default value is replaced with the configured
 671      * default value when the drawable is first bound to a direct
 672      * rendering context.
 673      */
 674     pdraw->swap_interval = (unsigned)-1;
 675
 676     pdp->swapBuffers = psp->DriverAPI.SwapBuffers;
 677
 678     /* Add pdraw to drawable list */
 679     if (!__driAddDrawable(psp->drawHash, pdraw)) {
 680         /* ERROR!!! */
 681         (*pdraw->destroyDrawable)(dpy, pdp);
 682         _mesa_free(pdp);
 683         pdp = NULL;
 684         pdraw->private = NULL;
 685     }
 686
 687    return (void *) pdp;
 688 }
 689
 690 static __DRIdrawable *
 691 driGetDrawable(__DRInativeDisplay *dpy, __DRIid draw, void *screenPrivate)
 692 {
 693     __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
 694
 695     /*
 696     ** Make sure this routine returns NULL if the drawable is not bound
 697     ** to a direct rendering context!
 698     */
 699     return __driFindDrawable(psp->drawHash, draw);
 700 }
 701
 702 static void
 703 driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate)
 704 {
 705     __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *) drawablePrivate;
 706     __DRIscreenPrivate *psp;
 707     int scrn;
 708
 709     if (pdp) {
 710         psp = pdp->driScreenPriv;
 711         scrn = psp->myNum;
 712         (*psp->DriverAPI.DestroyBuffer)(pdp);
 713         if ((*dri_interface->windowExists)(dpy, pdp->draw))
 714             (void)(*dri_interface->destroyDrawable)(dpy, scrn, pdp->draw);
 715         drmHashDelete(psp->drawHash, pdp->draw);
 716         if (pdp->pClipRects) {
 717             _mesa_free(pdp->pClipRects);
 718             pdp->pClipRects = NULL;
 719         }
 720         if (pdp->pBackClipRects) {
 721             _mesa_free(pdp->pBackClipRects);
 722             pdp->pBackClipRects = NULL;
 723         }
 724         _mesa_free(pdp);
 725     }
 726 }
 727
 728 /*@}*/
 729
 730
 731 /*****************************************************************/
 732 /** \name Context handling functions                             */
 733 /*****************************************************************/
 734 /*@{*/
 735
 736 /**
 737  * Destroy the per-context private information.
 738  *
 739  * \param dpy the display handle.
 740  * \param scrn the screen number.
 741  * \param contextPrivate opaque pointer to the per-drawable private info.
 742  *
 743  * \internal
 744  * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
 745  * drmDestroyContext(), and finally frees \p contextPrivate.
 746  */
 747 static void
 748 driDestroyContext(__DRInativeDisplay *dpy, int scrn, void *contextPrivate)
 749 {
 750     __DRIcontextPrivate  *pcp   = (__DRIcontextPrivate *) contextPrivate;
 751
 752     if (pcp) {
 753         (*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
 754         __driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
 755         (void) (*dri_interface->destroyContext)(dpy, scrn, pcp->contextID);
 756         _mesa_free(pcp);
 757     }
 758 }
 759
 760
 761 /**
 762  * Create the per-drawable private driver information.
 763  *
 764  * \param dpy           The display handle.
 765  * \param modes         Mode used to create the new context.
 766  * \param render_type   Type of rendering target.  \c GLX_RGBA is the only
 767  *                      type likely to ever be supported for direct-rendering.
 768  * \param sharedPrivate The shared context dependent methods or \c NULL if
 769  *                      non-existent.
 770  * \param pctx          DRI context to receive the context dependent methods.
 771  *
 772  * \returns An opaque pointer to the per-context private information on
 773  *          success, or \c NULL on failure.
 774  *
 775  * \internal
 776  * This function allocates and fills a __DRIcontextPrivateRec structure.  It
 777  * performs some device independent initialization and passes all the
 778  * relevent information to __DriverAPIRec::CreateContext to create the
 779  * context.
 780  *
 781  */
 782 static void *
 783 driCreateNewContext(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
 784                     int render_type, void *sharedPrivate, __DRIcontext *pctx)
 785 {
 786     __DRIscreen *pDRIScreen;
 787     __DRIcontextPrivate *pcp;
 788     __DRIcontextPrivate *pshare = (__DRIcontextPrivate *) sharedPrivate;
 789     __DRIscreenPrivate *psp;
 790     void * const shareCtx = (pshare != NULL) ? pshare->driverPrivate : NULL;
 791
 792     pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
 793     if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
 794         /* ERROR!!! */
 795         return NULL;
 796     }
 797
 798     psp = (__DRIscreenPrivate *)pDRIScreen->private;
 799
 800     pcp = (__DRIcontextPrivate *)_mesa_malloc(sizeof(__DRIcontextPrivate));
 801     if (!pcp) {
 802         return NULL;
 803     }
 804
 805     if (! (*dri_interface->createContext)(dpy, modes->screen, modes->fbconfigID,
 806                                         &pcp->contextID, &pcp->hHWContext)) {
 807         _mesa_free(pcp);
 808         return NULL;
 809     }
 810
 811     pcp->display = dpy;
 812     pcp->driScreenPriv = psp;
 813     pcp->driDrawablePriv = NULL;
 814
 815     /* When the first context is created for a screen, initialize a "dummy"
 816      * context.
 817      */
 818
 819     if (!psp->dummyContextPriv.driScreenPriv) {
 820         psp->dummyContextPriv.contextID = 0;
 821         psp->dummyContextPriv.hHWContext = psp->pSAREA->dummy_context;
 822         psp->dummyContextPriv.driScreenPriv = psp;
 823         psp->dummyContextPriv.driDrawablePriv = NULL;
 824         psp->dummyContextPriv.driverPrivate = NULL;
 825         /* No other fields should be used! */
 826     }
 827
 828     pctx->destroyContext = driDestroyContext;
 829     pctx->bindContext    = driBindContext;
 830     pctx->unbindContext  = driUnbindContext;
 831
 832     if ( !(*psp->DriverAPI.CreateContext)(modes, pcp, shareCtx) ) {
 833         (void) (*dri_interface->destroyContext)(dpy, modes->screen,
 834                                                 pcp->contextID);
 835         _mesa_free(pcp);
 836         return NULL;
 837     }
 838
 839     __driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
 840
 841     return pcp;
 842 }
 843 /*@}*/
 844
 845
 846 /*****************************************************************/
 847 /** \name Screen handling functions                              */
 848 /*****************************************************************/
 849 /*@{*/
 850
 851 /**
 852  * Destroy the per-screen private information.
 853  *
 854  * \param dpy the display handle.
 855  * \param scrn the screen number.
 856  * \param screenPrivate opaque pointer to the per-screen private information.
 857  *
 858  * \internal
 859  * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
 860  * drmClose(), and finally frees \p screenPrivate.
 861  */
 862 static void driDestroyScreen(__DRInativeDisplay *dpy, int scrn, void *screenPrivate)
 863 {
 864     __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
 865
 866     if (psp) {
 867         /* No interaction with the X-server is possible at this point.  This
 868          * routine is called after XCloseDisplay, so there is no protocol
 869          * stream open to the X-server anymore.
 870          */
 871
 872         if (psp->DriverAPI.DestroyScreen)
 873             (*psp->DriverAPI.DestroyScreen)(psp);
 874
 875         (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
 876         (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
 877         _mesa_free(psp->pDevPriv);
 878         (void)drmCloseOnce(psp->fd);
 879         if ( psp->modes != NULL ) {
 880             (*dri_interface->destroyContextModes)( psp->modes );
 881         }
 882
 883         assert(psp->drawHash);
 884         drmHashDestroy(psp->drawHash);
 885
 886         _mesa_free(psp);
 887     }
 888 }
 889
 890
 891 /**
 892  * Utility function used to create a new driver-private screen structure.
 893  *
 894  * \param dpy   Display pointer
 895  * \param scrn  Index of the screen
 896  * \param psc   DRI screen data (not driver private)
 897  * \param modes Linked list of known display modes.  This list is, at a
 898  *              minimum, a list of modes based on the current display mode.
 899  *              These roughly match the set of available X11 visuals, but it
 900  *              need not be limited to X11!  The calling libGL should create
 901  *              a list that will inform the driver of the current display
 902  *              mode (i.e., color buffer depth, depth buffer depth, etc.).
 903  * \param ddx_version Version of the 2D DDX.  This may not be meaningful for
 904  *                    all drivers.
 905  * \param dri_version Version of the "server-side" DRI.
 906  * \param drm_version Version of the kernel DRM.
 907  * \param frame_buffer Data describing the location and layout of the
 908  *                     framebuffer.
 909  * \param pSAREA       Pointer the the SAREA.
 910  * \param fd           Device handle for the DRM.
 911  * \param internal_api_version  Version of the internal interface between the
 912  *                              driver and libGL.
 913  * \param driverAPI Driver API functions used by other routines in dri_util.c.
 914  *
 915  * \note
 916  * There is no need to check the minimum API version in this function.  Since
 917  * the \c __driCreateNewScreen function is versioned, it is impossible for a
 918  * loader that is too old to even load this driver.
 919  */
 920 __DRIscreenPrivate *
 921 __driUtilCreateNewScreen(__DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
 922                          __GLcontextModes * modes,
 923                          const __DRIversion * ddx_version,
 924                          const __DRIversion * dri_version,
 925                          const __DRIversion * drm_version,
 926                          const __DRIframebuffer * frame_buffer,
 927                          drm_sarea_t *pSAREA,
 928                          int fd,
 929                          int internal_api_version,
 930                          const struct __DriverAPIRec *driverAPI)
 931 {
 932     __DRIscreenPrivate *psp;
 933
 934
 935     api_ver = internal_api_version;
 936
 937     psp = (__DRIscreenPrivate *)_mesa_malloc(sizeof(__DRIscreenPrivate));
 938     if (!psp) {
 939         return NULL;
 940     }
 941
 942     /* Create the hash table */
 943     psp->drawHash = drmHashCreate();
 944     if ( psp->drawHash == NULL ) {
 945         _mesa_free( psp );
 946         return NULL;
 947     }
 948
 949     psp->display = dpy;
 950     psp->myNum = scrn;
 951     psp->psc = psc;
 952     psp->modes = modes;
 953
 954     /*
 955     ** NOT_DONE: This is used by the X server to detect when the client
 956     ** has died while holding the drawable lock.  The client sets the
 957     ** drawable lock to this value.
 958     */
 959     psp->drawLockID = 1;
 960
 961     psp->drmMajor = drm_version->major;
 962     psp->drmMinor = drm_version->minor;
 963     psp->drmPatch = drm_version->patch;
 964     psp->ddxMajor = ddx_version->major;
 965     psp->ddxMinor = ddx_version->minor;
 966     psp->ddxPatch = ddx_version->patch;
 967     psp->driMajor = dri_version->major;
 968     psp->driMinor = dri_version->minor;
 969     psp->driPatch = dri_version->patch;
 970
 971     /* install driver's callback functions */
 972     memcpy( &psp->DriverAPI, driverAPI, sizeof(struct __DriverAPIRec) );
 973
 974     psp->pSAREA = pSAREA;
 975
 976     psp->pFB = frame_buffer->base;
 977     psp->fbSize = frame_buffer->size;
 978     psp->fbStride = frame_buffer->stride;
 979     psp->fbWidth = frame_buffer->width;
 980     psp->fbHeight = frame_buffer->height;
 981     psp->devPrivSize = frame_buffer->dev_priv_size;
 982     psp->pDevPriv = frame_buffer->dev_priv;
 983     psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;
 984
 985     psp->fd = fd;
 986
 987     /*
 988     ** Do not init dummy context here; actual initialization will be
 989     ** done when the first DRI context is created.  Init screen priv ptr
 990     ** to NULL to let CreateContext routine that it needs to be inited.
 991     */
 992     psp->dummyContextPriv.driScreenPriv = NULL;
 993
 994     psc->destroyScreen     = driDestroyScreen;
 995     psc->createNewDrawable = driCreateNewDrawable;
 996     psc->getDrawable       = driGetDrawable;
 997     psc->getMSC            = driGetMSC;
 998     psc->createNewContext  = driCreateNewContext;
 999
1000     if (internal_api_version >= 20070121)
1001         psc->setTexOffset  = psp->DriverAPI.setTexOffset;
1002
1003     if ( (psp->DriverAPI.InitDriver != NULL)
1004          && !(*psp->DriverAPI.InitDriver)(psp) ) {
1005         _mesa_free( psp );
1006         return NULL;
1007     }
1008
1009
1010     return psp;
1011 }
1012
1013
1014 /**
1015  * Compare the current GLX API version with a driver supplied required version.
1016  *
1017  * The minimum required version is compared with the API version exported by
1018  * the \c __glXGetInternalVersion function (in libGL.so).
1019  *
1020  * \param   required_version Minimum required internal GLX API version.
1021  * \return  A tri-value return, as from strcmp is returned.  A value less
1022  *          than, equal to, or greater than zero will be returned if the
1023  *          internal GLX API version is less than, equal to, or greater
1024  *          than \c required_version.
1025  *
1026  * \sa __glXGetInternalVersion().
1027  */
1028 int driCompareGLXAPIVersion( GLint required_version )
1029 {
1030    if ( api_ver > required_version ) {
1031       return 1;
1032    }
1033    else if ( api_ver == required_version ) {
1034       return 0;
1035    }
1036
1037    return -1;
1038 }
1039
1040
1041 static int
1042 driQueryFrameTracking( __DRInativeDisplay * dpy, void * priv,
1043                        int64_t * sbc, int64_t * missedFrames,
1044                        float * lastMissedUsage, float * usage )
1045 {
1046    __DRIswapInfo   sInfo;
1047    int             status;
1048    int64_t         ust;
1049    __DRIdrawablePrivate * dpriv = (__DRIdrawablePrivate *) priv;
1050
1051
1052    status = dpriv->driScreenPriv->DriverAPI.GetSwapInfo( dpriv, & sInfo );
1053    if ( status == 0 ) {
1054       *sbc = sInfo.swap_count;
1055       *missedFrames = sInfo.swap_missed_count;
1056       *lastMissedUsage = sInfo.swap_missed_usage;
1057
1058       (*dri_interface->getUST)( & ust );
1059       *usage = driCalculateSwapUsage( dpriv, sInfo.swap_ust, ust );
1060    }
1061
1062    return status;
1063 }
1064
1065
1066 /**
1067  * Calculate amount of swap interval used between GLX buffer swaps.
1068  *
1069  * The usage value, on the range [0,max], is the fraction of total swap
1070  * interval time used between GLX buffer swaps is calculated.
1071  *
1072  *            \f$p = t_d / (i * t_r)\f$
1073  *
1074  * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the
1075  * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time
1076  * required for a single vertical refresh period (as returned by \c
1077  * glXGetMscRateOML).
1078  *
1079  * See the documentation for the GLX_MESA_swap_frame_usage extension for more
1080  * details.
1081  *
1082  * \param   dPriv  Pointer to the private drawable structure.
1083  * \return  If less than a single swap interval time period was required
1084  *          between GLX buffer swaps, a number greater than 0 and less than
1085  *          1.0 is returned.  If exactly one swap interval time period is
1086  *          required, 1.0 is returned, and if more than one is required then
1087  *          a number greater than 1.0 will be returned.
1088  *
1089  * \sa glXSwapIntervalSGI glXGetMscRateOML
1090  *
1091  * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it
1092  *       be possible to cache the sync rate?
1093  */
1094 float
1095 driCalculateSwapUsage( __DRIdrawablePrivate *dPriv, int64_t last_swap_ust,
1096                        int64_t current_ust )
1097 {
1098    int32_t   n;
1099    int32_t   d;
1100    int       interval;
1101    float     usage = 1.0;
1102
1103
1104    if ( (*dri_interface->getMSCRate)( dPriv->display, dPriv->draw, &n, &d ) ) {
1105       interval = (dPriv->pdraw->swap_interval != 0)
1106           ? dPriv->pdraw->swap_interval : 1;
1107
1108
1109       /* We want to calculate
1110        * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get
1111        * current_UST by calling __glXGetUST.  last_swap_UST is stored in
1112        * dPriv->swap_ust.  interval has already been calculated.
1113        *
1114        * The only tricky part is us_per_refresh.  us_per_refresh is
1115        * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it
1116        * around and say us_per_refresh = 1000000 * d / n.  Since this goes in
1117        * the denominator of the final calculation, we calculate
1118        * (interval * 1000000 * d) and move n into the numerator.
1119        */
1120
1121       usage = (current_ust - last_swap_ust);
1122       usage *= n;
1123       usage /= (interval * d);
1124       usage /= 1000000.0;
1125    }
1126
1127    return usage;
1128 }
1129
1130 /*@}*/