dri: Fix potential null pointer dereference in driBindContext.
[mesa.git] / 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 /*@}*/