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

   1 /**
   2  * \file dri_util.c
   3  * DRI utility functions.
   4  *
   5  * This module acts as glue between GLX and the actual hardware driver.  A DRI
   6  * driver doesn't really \e have to use any of this - it's optional.  But, some
   7  * useful stuff is done here that otherwise would have to be duplicated in most
   8  * drivers.
   9  *
  10  * Basically, these utility functions take care of some of the dirty details of
  11  * screen initialization, context creation, context binding, DRM setup, etc.
  12  *
  13  * These functions are compiled into each DRI driver so libGL.so knows nothing
  14  * about them.
  15  */
  16
  17
  18 #include <assert.h>
  19 #include <stdarg.h>
  20 #include <unistd.h>
  21 #include <sys/mman.h>
  22 #include <stdio.h>
  23
  24 #ifndef MAP_FAILED
  25 #define MAP_FAILED ((void *)-1)
  26 #endif
  27
  28 #include "main/imports.h"
  29 #define None 0
  30
  31 #include "dri_util.h"
  32 #include "drm_sarea.h"
  33 #include "utils.h"
  34
  35 #ifndef GLX_OML_sync_control
  36 typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRIdrawable *drawable, int32_t *numerator, int32_t *denominator);
  37 #endif
  38
  39 static void dri_get_drawable(__DRIdrawable *pdp);
  40 static void dri_put_drawable(__DRIdrawable *pdp);
  41
  42 /**
  43  * This is just a token extension used to signal that the driver
  44  * supports setting a read drawable.
  45  */
  46 const __DRIextension driReadDrawableExtension = {
  47     __DRI_READ_DRAWABLE, __DRI_READ_DRAWABLE_VERSION
  48 };
  49
  50 /**
  51  * Print message to \c stderr if the \c LIBGL_DEBUG environment variable
  52  * is set.
  53  *
  54  * Is called from the drivers.
  55  *
  56  * \param f \c printf like format string.
  57  */
  58 void
  59 __driUtilMessage(const char *f, ...)
  60 {
  61     va_list args;
  62
  63     if (getenv("LIBGL_DEBUG")) {
  64         fprintf(stderr, "libGL: ");
  65         va_start(args, f);
  66         vfprintf(stderr, f, args);
  67         va_end(args);
  68         fprintf(stderr, "\n");
  69     }
  70 }
  71
  72 GLint
  73 driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 )
  74 {
  75    if (rect2.x1 > rect1.x1) rect1.x1 = rect2.x1;
  76    if (rect2.x2 < rect1.x2) rect1.x2 = rect2.x2;
  77    if (rect2.y1 > rect1.y1) rect1.y1 = rect2.y1;
  78    if (rect2.y2 < rect1.y2) rect1.y2 = rect2.y2;
  79
  80    if (rect1.x1 > rect1.x2 || rect1.y1 > rect1.y2) return 0;
  81
  82    return (rect1.x2 - rect1.x1) * (rect1.y2 - rect1.y1);
  83 }
  84
  85 /*****************************************************************/
  86 /** \name Context (un)binding functions                          */
  87 /*****************************************************************/
  88 /*@{*/
  89
  90 /**
  91  * Unbind context.
  92  *
  93  * \param scrn the screen.
  94  * \param gc context.
  95  *
  96  * \return \c GL_TRUE on success, or \c GL_FALSE on failure.
  97  *
  98  * \internal
  99  * This function calls __DriverAPIRec::UnbindContext, and then decrements
 100  * __DRIdrawablePrivateRec::refcount which must be non-zero for a successful
 101  * return.
 102  *
 103  * While casting the opaque private pointers associated with the parameters
 104  * into their respective real types it also assures they are not \c NULL.
 105  */
 106 static int driUnbindContext(__DRIcontext *pcp)
 107 {
 108     __DRIscreen *psp;
 109     __DRIdrawable *pdp;
 110     __DRIdrawable *prp;
 111
 112     /*
 113     ** Assume error checking is done properly in glXMakeCurrent before
 114     ** calling driUnbindContext.
 115     */
 116
 117     if (pcp == NULL)
 118         return GL_FALSE;
 119
 120     psp = pcp->driScreenPriv;
 121     pdp = pcp->driDrawablePriv;
 122     prp = pcp->driReadablePriv;
 123
 124     /* already unbound */
 125     if (!pdp && !prp)
 126       return GL_TRUE;
 127     /* Let driver unbind drawable from context */
 128     (*psp->DriverAPI.UnbindContext)(pcp);
 129
 130     if (pdp->refcount == 0) {
 131         /* ERROR!!! */
 132         return GL_FALSE;
 133     }
 134
 135     dri_put_drawable(pdp);
 136
 137     if (prp != pdp) {
 138         if (prp->refcount == 0) {
 139             /* ERROR!!! */
 140             return GL_FALSE;
 141         }
 142
 143         dri_put_drawable(prp);
 144     }
 145
 146
 147     /* XXX this is disabled so that if we call SwapBuffers on an unbound
 148      * window we can determine the last context bound to the window and
 149      * use that context's lock. (BrianP, 2-Dec-2000)
 150      */
 151     pcp->driDrawablePriv = pcp->driReadablePriv = NULL;
 152
 153 #if 0
 154     /* Unbind the drawable */
 155     pdp->driContextPriv = &psp->dummyContextPriv;
 156 #endif
 157
 158     return GL_TRUE;
 159 }
 160
 161 /**
 162  * This function takes both a read buffer and a draw buffer.  This is needed
 163  * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
 164  * function.
 165  */
 166 static int driBindContext(__DRIcontext *pcp,
 167                           __DRIdrawable *pdp,
 168                           __DRIdrawable *prp)
 169 {
 170     __DRIscreenPrivate *psp;
 171
 172     /* Bind the drawable to the context */
 173
 174     if (pcp) {
 175         psp = pcp->driScreenPriv;
 176         pcp->driDrawablePriv = pdp;
 177         pcp->driReadablePriv = prp;
 178         if (pdp) {
 179             pdp->driContextPriv = pcp;
 180             dri_get_drawable(pdp);
 181         }
 182         if ( prp && pdp != prp ) {
 183             dri_get_drawable(prp);
 184         }
 185     }
 186
 187     /*
 188     ** Now that we have a context associated with this drawable, we can
 189     ** initialize the drawable information if has not been done before.
 190     */
 191
 192     if (!psp->dri2.enabled) {
 193         if (pdp && !pdp->pStamp) {
 194             DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 195             __driUtilUpdateDrawableInfo(pdp);
 196             DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 197         }
 198         if (prp && pdp != prp && !prp->pStamp) {
 199             DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 200             __driUtilUpdateDrawableInfo(prp);
 201             DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 202         }
 203     }
 204
 205     /* Call device-specific MakeCurrent */
 206
 207     return (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);
 208 }
 209
 210 /*@}*/
 211
 212
 213 /*****************************************************************/
 214 /** \name Drawable handling functions                            */
 215 /*****************************************************************/
 216 /*@{*/
 217
 218 /**
 219  * Update private drawable information.
 220  *
 221  * \param pdp pointer to the private drawable information to update.
 222  *
 223  * This function basically updates the __DRIdrawablePrivate struct's
 224  * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.
 225  * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
 226  * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If
 227  * the values are different that means we have to update the clipping
 228  * info.
 229  */
 230 void
 231 __driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp)
 232 {
 233     __DRIscreenPrivate *psp = pdp->driScreenPriv;
 234     __DRIcontextPrivate *pcp = pdp->driContextPriv;
 235
 236     if (!pcp
 237         || ((pdp != pcp->driDrawablePriv) && (pdp != pcp->driReadablePriv))) {
 238         /* ERROR!!!
 239          * ...but we must ignore it. There can be many contexts bound to a
 240          * drawable.
 241          */
 242     }
 243
 244     if (pdp->pClipRects) {
 245         _mesa_free(pdp->pClipRects);
 246         pdp->pClipRects = NULL;
 247     }
 248
 249     if (pdp->pBackClipRects) {
 250         _mesa_free(pdp->pBackClipRects);
 251         pdp->pBackClipRects = NULL;
 252     }
 253
 254     DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 255
 256     if (! (*psp->getDrawableInfo->getDrawableInfo)(pdp,
 257                           &pdp->index, &pdp->lastStamp,
 258                           &pdp->x, &pdp->y, &pdp->w, &pdp->h,
 259                           &pdp->numClipRects, &pdp->pClipRects,
 260                           &pdp->backX,
 261                           &pdp->backY,
 262                           &pdp->numBackClipRects,
 263                           &pdp->pBackClipRects,
 264                           pdp->loaderPrivate)) {
 265         /* Error -- eg the window may have been destroyed.  Keep going
 266          * with no cliprects.
 267          */
 268         pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */
 269         pdp->numClipRects = 0;
 270         pdp->pClipRects = NULL;
 271         pdp->numBackClipRects = 0;
 272         pdp->pBackClipRects = NULL;
 273     }
 274     else
 275        pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
 276
 277     DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
 278 }
 279
 280 /*@}*/
 281
 282 /*****************************************************************/
 283 /** \name GLX callbacks                                          */
 284 /*****************************************************************/
 285 /*@{*/
 286
 287 static void driReportDamage(__DRIdrawable *pdp,
 288                             struct drm_clip_rect *pClipRects, int numClipRects)
 289 {
 290     __DRIscreen *psp = pdp->driScreenPriv;
 291
 292     /* Check that we actually have the new damage report method */
 293     if (psp->damage) {
 294         /* Report the damage.  Currently, all our drivers draw
 295          * directly to the front buffer, so we report the damage there
 296          * rather than to the backing storein (if any).
 297          */
 298         (*psp->damage->reportDamage)(pdp,
 299                                      pdp->x, pdp->y,
 300                                      pClipRects, numClipRects,
 301                                      GL_TRUE, pdp->loaderPrivate);
 302     }
 303 }
 304
 305
 306 /**
 307  * Swap buffers.
 308  *
 309  * \param drawablePrivate opaque pointer to the per-drawable private info.
 310  *
 311  * \internal
 312  * This function calls __DRIdrawablePrivate::swapBuffers.
 313  *
 314  * Is called directly from glXSwapBuffers().
 315  */
 316 static void driSwapBuffers(__DRIdrawable *dPriv)
 317 {
 318     __DRIscreen *psp = dPriv->driScreenPriv;
 319     drm_clip_rect_t *rects;
 320     int i;
 321
 322     psp->DriverAPI.SwapBuffers(dPriv);
 323
 324     if (!dPriv->numClipRects)
 325         return;
 326
 327     rects = _mesa_malloc(sizeof(*rects) * dPriv->numClipRects);
 328
 329     if (!rects)
 330         return;
 331
 332     for (i = 0; i < dPriv->numClipRects; i++) {
 333         rects[i].x1 = dPriv->pClipRects[i].x1 - dPriv->x;
 334         rects[i].y1 = dPriv->pClipRects[i].y1 - dPriv->y;
 335         rects[i].x2 = dPriv->pClipRects[i].x2 - dPriv->x;
 336         rects[i].y2 = dPriv->pClipRects[i].y2 - dPriv->y;
 337     }
 338
 339     driReportDamage(dPriv, rects, dPriv->numClipRects);
 340     _mesa_free(rects);
 341 }
 342
 343 static int driDrawableGetMSC( __DRIscreen *sPriv, __DRIdrawable *dPriv,
 344                               int64_t *msc )
 345 {
 346     return sPriv->DriverAPI.GetDrawableMSC(sPriv, dPriv, msc);
 347 }
 348
 349
 350 static int driWaitForMSC(__DRIdrawable *dPriv, int64_t target_msc,
 351                          int64_t divisor, int64_t remainder,
 352                          int64_t * msc, int64_t * sbc)
 353 {
 354     __DRIswapInfo  sInfo;
 355     int  status;
 356
 357     status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,
 358                                                          divisor, remainder,
 359                                                          msc );
 360
 361     /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync
 362      * is supported but GLX_OML_sync_control is not.  Therefore, don't return
 363      * an error value if GetSwapInfo() is not implemented.
 364     */
 365     if ( status == 0
 366          && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {
 367         status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
 368         *sbc = sInfo.swap_count;
 369     }
 370
 371     return status;
 372 }
 373
 374
 375 const __DRImediaStreamCounterExtension driMediaStreamCounterExtension = {
 376     { __DRI_MEDIA_STREAM_COUNTER, __DRI_MEDIA_STREAM_COUNTER_VERSION },
 377     driWaitForMSC,
 378     driDrawableGetMSC,
 379 };
 380
 381
 382 static void driCopySubBuffer(__DRIdrawable *dPriv,
 383                               int x, int y, int w, int h)
 384 {
 385     drm_clip_rect_t rect;
 386
 387     rect.x1 = x;
 388     rect.y1 = dPriv->h - y - h;
 389     rect.x2 = x + w;
 390     rect.y2 = rect.y1 + h;
 391     driReportDamage(dPriv, &rect, 1);
 392
 393     dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);
 394 }
 395
 396 const __DRIcopySubBufferExtension driCopySubBufferExtension = {
 397     { __DRI_COPY_SUB_BUFFER, __DRI_COPY_SUB_BUFFER_VERSION },
 398     driCopySubBuffer
 399 };
 400
 401 static void driSetSwapInterval(__DRIdrawable *dPriv, unsigned int interval)
 402 {
 403     dPriv->swap_interval = interval;
 404 }
 405
 406 static unsigned int driGetSwapInterval(__DRIdrawable *dPriv)
 407 {
 408     return dPriv->swap_interval;
 409 }
 410
 411 const __DRIswapControlExtension driSwapControlExtension = {
 412     { __DRI_SWAP_CONTROL, __DRI_SWAP_CONTROL_VERSION },
 413     driSetSwapInterval,
 414     driGetSwapInterval
 415 };
 416
 417
 418 /**
 419  * This is called via __DRIscreenRec's createNewDrawable pointer.
 420  */
 421 static __DRIdrawable *
 422 driCreateNewDrawable(__DRIscreen *psp, const __DRIconfig *config,
 423                      drm_drawable_t hwDrawable, int renderType,
 424                      const int *attrs, void *data)
 425 {
 426     __DRIdrawable *pdp;
 427
 428     /* Since pbuffers are not yet supported, no drawable attributes are
 429      * supported either.
 430      */
 431     (void) attrs;
 432
 433     pdp = _mesa_malloc(sizeof *pdp);
 434     if (!pdp) {
 435         return NULL;
 436     }
 437
 438     pdp->loaderPrivate = data;
 439     pdp->hHWDrawable = hwDrawable;
 440     pdp->refcount = 1;
 441     pdp->pStamp = NULL;
 442     pdp->lastStamp = 0;
 443     pdp->index = 0;
 444     pdp->x = 0;
 445     pdp->y = 0;
 446     pdp->w = 0;
 447     pdp->h = 0;
 448     pdp->numClipRects = 0;
 449     pdp->numBackClipRects = 0;
 450     pdp->pClipRects = NULL;
 451     pdp->pBackClipRects = NULL;
 452     pdp->vblSeq = 0;
 453     pdp->vblFlags = 0;
 454
 455     pdp->driScreenPriv = psp;
 456     pdp->driContextPriv = &psp->dummyContextPriv;
 457
 458     if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, &config->modes,
 459                                         renderType == GLX_PIXMAP_BIT)) {
 460        _mesa_free(pdp);
 461        return NULL;
 462     }
 463
 464     pdp->msc_base = 0;
 465
 466     /* This special default value is replaced with the configured
 467      * default value when the drawable is first bound to a direct
 468      * rendering context.
 469      */
 470     pdp->swap_interval = (unsigned)-1;
 471
 472     return pdp;
 473 }
 474
 475
 476 static __DRIdrawable *
 477 dri2CreateNewDrawable(__DRIscreen *screen,
 478                       const __DRIconfig *config,
 479                       void *loaderPrivate)
 480 {
 481     __DRIdrawable *pdraw;
 482
 483     pdraw = driCreateNewDrawable(screen, config, 0, 0, NULL, loaderPrivate);
 484     if (!pdraw)
 485         return NULL;
 486
 487     pdraw->pClipRects = _mesa_malloc(sizeof *pdraw->pBackClipRects);
 488     pdraw->pBackClipRects = _mesa_malloc(sizeof *pdraw->pBackClipRects);
 489
 490     return pdraw;
 491 }
 492
 493 static void dri_get_drawable(__DRIdrawable *pdp)
 494 {
 495     pdp->refcount++;
 496 }
 497
 498 static void dri_put_drawable(__DRIdrawable *pdp)
 499 {
 500     __DRIscreenPrivate *psp;
 501
 502     if (pdp) {
 503         pdp->refcount--;
 504         if (pdp->refcount)
 505             return;
 506
 507         psp = pdp->driScreenPriv;
 508         (*psp->DriverAPI.DestroyBuffer)(pdp);
 509         if (pdp->pClipRects) {
 510             _mesa_free(pdp->pClipRects);
 511             pdp->pClipRects = NULL;
 512         }
 513         if (pdp->pBackClipRects) {
 514             _mesa_free(pdp->pBackClipRects);
 515             pdp->pBackClipRects = NULL;
 516         }
 517         _mesa_free(pdp);
 518     }
 519 }
 520
 521 static void
 522 driDestroyDrawable(__DRIdrawable *pdp)
 523 {
 524     dri_put_drawable(pdp);
 525 }
 526
 527 /*@}*/
 528
 529
 530 /*****************************************************************/
 531 /** \name Context handling functions                             */
 532 /*****************************************************************/
 533 /*@{*/
 534
 535 /**
 536  * Destroy the per-context private information.
 537  *
 538  * \internal
 539  * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
 540  * drmDestroyContext(), and finally frees \p contextPrivate.
 541  */
 542 static void
 543 driDestroyContext(__DRIcontext *pcp)
 544 {
 545     if (pcp) {
 546         (*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
 547         _mesa_free(pcp);
 548     }
 549 }
 550
 551
 552 /**
 553  * Create the per-drawable private driver information.
 554  *
 555  * \param render_type   Type of rendering target.  \c GLX_RGBA is the only
 556  *                      type likely to ever be supported for direct-rendering.
 557  * \param shared        Context with which to share textures, etc. or NULL
 558  *
 559  * \returns An opaque pointer to the per-context private information on
 560  *          success, or \c NULL on failure.
 561  *
 562  * \internal
 563  * This function allocates and fills a __DRIcontextPrivateRec structure.  It
 564  * performs some device independent initialization and passes all the
 565  * relevent information to __DriverAPIRec::CreateContext to create the
 566  * context.
 567  *
 568  */
 569 static __DRIcontext *
 570 driCreateNewContext(__DRIscreen *psp, const __DRIconfig *config,
 571                     int render_type, __DRIcontext *shared,
 572                     drm_context_t hwContext, void *data)
 573 {
 574     __DRIcontext *pcp;
 575     void * const shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;
 576
 577     pcp = _mesa_malloc(sizeof *pcp);
 578     if (!pcp)
 579         return NULL;
 580
 581     pcp->driScreenPriv = psp;
 582     pcp->driDrawablePriv = NULL;
 583
 584     /* When the first context is created for a screen, initialize a "dummy"
 585      * context.
 586      */
 587
 588     if (!psp->dri2.enabled && !psp->dummyContextPriv.driScreenPriv) {
 589         psp->dummyContextPriv.hHWContext = psp->pSAREA->dummy_context;
 590         psp->dummyContextPriv.driScreenPriv = psp;
 591         psp->dummyContextPriv.driDrawablePriv = NULL;
 592         psp->dummyContextPriv.driverPrivate = NULL;
 593         /* No other fields should be used! */
 594     }
 595
 596     pcp->hHWContext = hwContext;
 597
 598     if ( !(*psp->DriverAPI.CreateContext)(&config->modes, pcp, shareCtx) ) {
 599         _mesa_free(pcp);
 600         return NULL;
 601     }
 602
 603     return pcp;
 604 }
 605
 606
 607 static __DRIcontext *
 608 dri2CreateNewContext(__DRIscreen *screen, const __DRIconfig *config,
 609                       __DRIcontext *shared, void *data)
 610 {
 611     return driCreateNewContext(screen, config, 0, shared, 0, data);
 612 }
 613
 614
 615 static int
 616 driCopyContext(__DRIcontext *dest, __DRIcontext *src, unsigned long mask)
 617 {
 618     return GL_FALSE;
 619 }
 620
 621 /*@}*/
 622
 623
 624 /*****************************************************************/
 625 /** \name Screen handling functions                              */
 626 /*****************************************************************/
 627 /*@{*/
 628
 629 /**
 630  * Destroy the per-screen private information.
 631  *
 632  * \internal
 633  * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
 634  * drmClose(), and finally frees \p screenPrivate.
 635  */
 636 static void driDestroyScreen(__DRIscreen *psp)
 637 {
 638     if (psp) {
 639         /* No interaction with the X-server is possible at this point.  This
 640          * routine is called after XCloseDisplay, so there is no protocol
 641          * stream open to the X-server anymore.
 642          */
 643
 644         if (psp->DriverAPI.DestroyScreen)
 645             (*psp->DriverAPI.DestroyScreen)(psp);
 646
 647         if (!psp->dri2.enabled) {
 648            (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
 649            (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
 650            (void)drmCloseOnce(psp->fd);
 651         }
 652
 653         _mesa_free(psp);
 654     }
 655 }
 656
 657 static void
 658 setupLoaderExtensions(__DRIscreen *psp,
 659                       const __DRIextension **extensions)
 660 {
 661     int i;
 662
 663     for (i = 0; extensions[i]; i++) {
 664         if (strcmp(extensions[i]->name, __DRI_GET_DRAWABLE_INFO) == 0)
 665             psp->getDrawableInfo = (__DRIgetDrawableInfoExtension *) extensions[i];
 666         if (strcmp(extensions[i]->name, __DRI_DAMAGE) == 0)
 667             psp->damage = (__DRIdamageExtension *) extensions[i];
 668         if (strcmp(extensions[i]->name, __DRI_SYSTEM_TIME) == 0)
 669             psp->systemTime = (__DRIsystemTimeExtension *) extensions[i];
 670         if (strcmp(extensions[i]->name, __DRI_DRI2_LOADER) == 0)
 671             psp->dri2.loader = (__DRIdri2LoaderExtension *) extensions[i];
 672     }
 673 }
 674
 675 /**
 676  * This is the bootstrap function for the driver.  libGL supplies all of the
 677  * requisite information about the system, and the driver initializes itself.
 678  * This routine also fills in the linked list pointed to by \c driver_modes
 679  * with the \c __GLcontextModes that the driver can support for windows or
 680  * pbuffers.
 681  *
 682  * For legacy DRI.
 683  *
 684  * \param scrn  Index of the screen
 685  * \param ddx_version Version of the 2D DDX.  This may not be meaningful for
 686  *                    all drivers.
 687  * \param dri_version Version of the "server-side" DRI.
 688  * \param drm_version Version of the kernel DRM.
 689  * \param frame_buffer Data describing the location and layout of the
 690  *                     framebuffer.
 691  * \param pSAREA       Pointer the the SAREA.
 692  * \param fd           Device handle for the DRM.
 693  * \param extensions   ??
 694  * \param driver_modes  Returns modes suppoted by the driver
 695  * \param loaderPrivate  ??
 696  *
 697  * \note There is no need to check the minimum API version in this
 698  * function.  Since the name of this function is versioned, it is
 699  * impossible for a loader that is too old to even load this driver.
 700  */
 701 static __DRIscreen *
 702 driCreateNewScreen(int scrn,
 703                    const __DRIversion *ddx_version,
 704                    const __DRIversion *dri_version,
 705                    const __DRIversion *drm_version,
 706                    const __DRIframebuffer *frame_buffer,
 707                    drmAddress pSAREA, int fd,
 708                    const __DRIextension **extensions,
 709                    const __DRIconfig ***driver_modes,
 710                    void *loaderPrivate)
 711 {
 712     static const __DRIextension *emptyExtensionList[] = { NULL };
 713     __DRIscreen *psp;
 714
 715     psp = _mesa_calloc(sizeof *psp);
 716     if (!psp)
 717         return NULL;
 718
 719     setupLoaderExtensions(psp, extensions);
 720
 721     /*
 722     ** NOT_DONE: This is used by the X server to detect when the client
 723     ** has died while holding the drawable lock.  The client sets the
 724     ** drawable lock to this value.
 725     */
 726     psp->drawLockID = 1;
 727
 728     psp->drm_version = *drm_version;
 729     psp->ddx_version = *ddx_version;
 730     psp->dri_version = *dri_version;
 731
 732     psp->pSAREA = pSAREA;
 733     psp->lock = (drmLock *) &psp->pSAREA->lock;
 734
 735     psp->pFB = frame_buffer->base;
 736     psp->fbSize = frame_buffer->size;
 737     psp->fbStride = frame_buffer->stride;
 738     psp->fbWidth = frame_buffer->width;
 739     psp->fbHeight = frame_buffer->height;
 740     psp->devPrivSize = frame_buffer->dev_priv_size;
 741     psp->pDevPriv = frame_buffer->dev_priv;
 742     psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;
 743
 744     psp->extensions = emptyExtensionList;
 745     psp->fd = fd;
 746     psp->myNum = scrn;
 747     psp->dri2.enabled = GL_FALSE;
 748
 749     /*
 750     ** Do not init dummy context here; actual initialization will be
 751     ** done when the first DRI context is created.  Init screen priv ptr
 752     ** to NULL to let CreateContext routine that it needs to be inited.
 753     */
 754     psp->dummyContextPriv.driScreenPriv = NULL;
 755
 756     psp->DriverAPI = driDriverAPI;
 757
 758     *driver_modes = driDriverAPI.InitScreen(psp);
 759     if (*driver_modes == NULL) {
 760         _mesa_free(psp);
 761         return NULL;
 762     }
 763
 764     return psp;
 765 }
 766
 767 /**
 768  * DRI2
 769  */
 770 static __DRIscreen *
 771 dri2CreateNewScreen(int scrn, int fd,
 772                     const __DRIextension **extensions,
 773                     const __DRIconfig ***driver_configs, void *data)
 774 {
 775     static const __DRIextension *emptyExtensionList[] = { NULL };
 776     __DRIscreen *psp;
 777     drmVersionPtr version;
 778
 779     if (driDriverAPI.InitScreen2 == NULL)
 780         return NULL;
 781
 782     psp = _mesa_calloc(sizeof(*psp));
 783     if (!psp)
 784         return NULL;
 785
 786     setupLoaderExtensions(psp, extensions);
 787
 788     version = drmGetVersion(fd);
 789     if (version) {
 790         psp->drm_version.major = version->version_major;
 791         psp->drm_version.minor = version->version_minor;
 792         psp->drm_version.patch = version->version_patchlevel;
 793         drmFreeVersion(version);
 794     }
 795
 796     psp->extensions = emptyExtensionList;
 797     psp->fd = fd;
 798     psp->myNum = scrn;
 799     psp->dri2.enabled = GL_TRUE;
 800
 801     psp->DriverAPI = driDriverAPI;
 802     *driver_configs = driDriverAPI.InitScreen2(psp);
 803     if (*driver_configs == NULL) {
 804         _mesa_free(psp);
 805         return NULL;
 806     }
 807
 808     psp->DriverAPI = driDriverAPI;
 809
 810     return psp;
 811 }
 812
 813 static const __DRIextension **driGetExtensions(__DRIscreen *psp)
 814 {
 815     return psp->extensions;
 816 }
 817
 818 /** Core interface */
 819 const __DRIcoreExtension driCoreExtension = {
 820     { __DRI_CORE, __DRI_CORE_VERSION },
 821     NULL,
 822     driDestroyScreen,
 823     driGetExtensions,
 824     driGetConfigAttrib,
 825     driIndexConfigAttrib,
 826     NULL,
 827     driDestroyDrawable,
 828     driSwapBuffers,
 829     NULL,
 830     driCopyContext,
 831     driDestroyContext,
 832     driBindContext,
 833     driUnbindContext
 834 };
 835
 836 /** Legacy DRI interface */
 837 const __DRIlegacyExtension driLegacyExtension = {
 838     { __DRI_LEGACY, __DRI_LEGACY_VERSION },
 839     driCreateNewScreen,
 840     driCreateNewDrawable,
 841     driCreateNewContext,
 842 };
 843
 844 /** Legacy DRI interface */
 845 const __DRIdri2Extension driDRI2Extension = {
 846     { __DRI_DRI2, __DRI_DRI2_VERSION },
 847     dri2CreateNewScreen,
 848     dri2CreateNewDrawable,
 849     dri2CreateNewContext,
 850 };
 851
 852 /* This is the table of extensions that the loader will dlsym() for. */
 853 PUBLIC const __DRIextension *__driDriverExtensions[] = {
 854     &driCoreExtension.base,
 855     &driLegacyExtension.base,
 856     &driDRI2Extension.base,
 857     NULL
 858 };
 859
 860 static int
 861 driFrameTracking(__DRIdrawable *drawable, GLboolean enable)
 862 {
 863     return GLX_BAD_CONTEXT;
 864 }
 865
 866 static int
 867 driQueryFrameTracking(__DRIdrawable *dpriv,
 868                       int64_t * sbc, int64_t * missedFrames,
 869                       float * lastMissedUsage, float * usage)
 870 {
 871    __DRIswapInfo   sInfo;
 872    int             status;
 873    int64_t         ust;
 874    __DRIscreenPrivate *psp = dpriv->driScreenPriv;
 875
 876    status = dpriv->driScreenPriv->DriverAPI.GetSwapInfo( dpriv, & sInfo );
 877    if ( status == 0 ) {
 878       *sbc = sInfo.swap_count;
 879       *missedFrames = sInfo.swap_missed_count;
 880       *lastMissedUsage = sInfo.swap_missed_usage;
 881
 882       (*psp->systemTime->getUST)( & ust );
 883       *usage = driCalculateSwapUsage( dpriv, sInfo.swap_ust, ust );
 884    }
 885
 886    return status;
 887 }
 888
 889 const __DRIframeTrackingExtension driFrameTrackingExtension = {
 890     { __DRI_FRAME_TRACKING, __DRI_FRAME_TRACKING_VERSION },
 891     driFrameTracking,
 892     driQueryFrameTracking
 893 };
 894
 895 /**
 896  * Calculate amount of swap interval used between GLX buffer swaps.
 897  *
 898  * The usage value, on the range [0,max], is the fraction of total swap
 899  * interval time used between GLX buffer swaps is calculated.
 900  *
 901  *            \f$p = t_d / (i * t_r)\f$
 902  *
 903  * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the
 904  * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time
 905  * required for a single vertical refresh period (as returned by \c
 906  * glXGetMscRateOML).
 907  *
 908  * See the documentation for the GLX_MESA_swap_frame_usage extension for more
 909  * details.
 910  *
 911  * \param   dPriv  Pointer to the private drawable structure.
 912  * \return  If less than a single swap interval time period was required
 913  *          between GLX buffer swaps, a number greater than 0 and less than
 914  *          1.0 is returned.  If exactly one swap interval time period is
 915  *          required, 1.0 is returned, and if more than one is required then
 916  *          a number greater than 1.0 will be returned.
 917  *
 918  * \sa glXSwapIntervalSGI glXGetMscRateOML
 919  *
 920  * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it
 921  *       be possible to cache the sync rate?
 922  */
 923 float
 924 driCalculateSwapUsage( __DRIdrawablePrivate *dPriv, int64_t last_swap_ust,
 925                        int64_t current_ust )
 926 {
 927    int32_t   n;
 928    int32_t   d;
 929    int       interval;
 930    float     usage = 1.0;
 931    __DRIscreenPrivate *psp = dPriv->driScreenPriv;
 932
 933    if ( (*psp->systemTime->getMSCRate)(dPriv, &n, &d, dPriv->loaderPrivate) ) {
 934       interval = (dPriv->swap_interval != 0) ? dPriv->swap_interval : 1;
 935
 936
 937       /* We want to calculate
 938        * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get
 939        * current_UST by calling __glXGetUST.  last_swap_UST is stored in
 940        * dPriv->swap_ust.  interval has already been calculated.
 941        *
 942        * The only tricky part is us_per_refresh.  us_per_refresh is
 943        * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it
 944        * around and say us_per_refresh = 1000000 * d / n.  Since this goes in
 945        * the denominator of the final calculation, we calculate
 946        * (interval * 1000000 * d) and move n into the numerator.
 947        */
 948
 949       usage = (current_ust - last_swap_ust);
 950       usage *= n;
 951       usage /= (interval * d);
 952       usage /= 1000000.0;
 953    }
 954
 955    return usage;
 956 }
 957
 958 /*@}*/