DEFINES = -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE \
-D_BSD_SOURCE -D_GNU_SOURCE \
- -DDRI_NEW_INTERFACE_ONLY -DPTHREADS -DUSE_EXTERNAL_DXTN_LIB=1
+ -DPTHREADS -DUSE_EXTERNAL_DXTN_LIB=1 -DIN_DRI_DRIVER
X11_INCLUDES = -I/usr/X11R6/include -I/usr/X11R6/include/X11/extensions
*/
void (*destroyScreen)(__DRInativeDisplay *dpy, int scrn, void *screenPrivate);
- /**
- * Method to create the private DRI context data and initialize the
- * context dependent methods.
- *
- * \sa __DRIscreenRec::createNewContext driCreateContext
- * driCreateNewContext
- *
- * \deprecated
- * This function has been replaced by \c __DRIscreenRec::createNewContext.
- * New drivers will continue to export this method, but it will eventually
- * (in the next XFree86 major relearse) go away.
- */
-#ifndef DRI_NEW_INTERFACE_ONLY
- void *(*createContext)(Display *dpy, XVisualInfo *vis, void *sharedPrivate,
- __DRIcontext *pctx);
-#else
- void * createContext;
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/**
* Method to create the private DRI drawable data and initialize the
* drawable dependent methods.
*/
void (*destroyContext)(__DRInativeDisplay *dpy, int scrn, void *contextPrivate);
- /**
- * Method to bind a DRI drawable to a DRI graphics context.
- *
- * \deprecated Replaced by bindContext3.
- */
-#ifndef DRI_NEW_INTERFACE_ONLY
- Bool (*bindContext)(Display *dpy, int scrn, GLXDrawable draw,
- GLXContext gc);
-#else
- void *bindContext;
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
- /**
- * Method to unbind a DRI drawable to a DRI graphics context.
- *
- * \deprecated Replaced by unbindContext3.
- */
-#ifndef DRI_NEW_INTERFACE_ONLY
- Bool (*unbindContext)(Display *dpy, int scrn, GLXDrawable draw,
- GLXContext gc, int will_rebind);
-#else
- void *unbindContext;
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/**
* Opaque pointer to private per context direct rendering data.
* \c NULL if direct rendering is not supported on the display or
*/
void *private;
- /**
- * Method to bind a DRI drawable to a DRI graphics context.
- *
- * \since Internal API version 20030606.
- * \deprecated Replaced by bindContext3.
- */
-#ifndef DRI_NEW_INTERFACE_ONLY
- Bool (*bindContext2)(Display *dpy, int scrn, GLXDrawable draw,
- GLXDrawable read, GLXContext gc);
-#else
- void *bindContext2;
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
- /**
- * Method to unbind a DRI drawable from a DRI graphics context.
- *
- * \since Internal API version 20030606.
- * \deprecated Replaced by unbindContext3.
- */
-#ifndef DRI_NEW_INTERFACE_ONLY
- Bool (*unbindContext2)(Display *dpy, int scrn, GLXDrawable draw,
- GLXDrawable read, GLXContext gc);
-#else
- void *unbindContext2;
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/**
* Pointer to the mode used to create this context.
*
/**
* Method to bind a DRI drawable to a DRI graphics context.
*
- * \since Internal API version 20040415.
+ * \since Internal API version 20050722.
*/
- GLboolean (*bindContext3)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
+ GLboolean (*bindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
__DRIid read, __DRIcontext *ctx);
/**
* Method to unbind a DRI drawable from a DRI graphics context.
*
- * \since Internal API version 20040415.
+ * \since Internal API version 20050722.
*/
- GLboolean (*unbindContext3)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
+ GLboolean (*unbindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
__DRIid read, __DRIcontext *ctx);
};
TOP = ../../..
include $(TOP)/configs/current
-# This is a bit messy. We want this libGL to be capable of loading old
-# interface drivers, so we have to turn off DRI_NEW_INTERFACE_ONLY. However,
-# glcontextmodes.c is built elsewhere with DNIO on, so we symlink it across.
-#
-# Furthermore, context creation has evolved over the years, such that this
+# Context creation has evolved over the years, such that this
# code will not build with DNIO defined. When we finally drop old interface
# support in libGL, we need to clean up both glxcmds.c and dri_interface.h.
DEFINES += -DGLX_DIRECT_RENDERING -DGLXEXT -DXF86DRI -DGLX_USE_DLOPEN \
- -DGLX_USE_MESA -DXF86VIDMODE -D_REENTRANT -UDRI_NEW_INTERFACE_ONLY
+ -DGLX_USE_MESA -DXF86VIDMODE -D_REENTRANT -UIN_DRI_DRIVER
C_SOURCES = \
$(TOP)/src/mesa/glapi/glapi.c \
#define RTLD_GLOBAL 0
#endif
-#ifdef BUILT_IN_DRI_DRIVER
-
-extern void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config);
-
-
-#else /* BUILT_IN_DRI_DRIVER */
-
#ifndef DEFAULT_DRIVER_DIR
/* this is normally defined in the Imakefile */
}
-/*
- * We'll save a pointer to this function when we couldn't find a
- * direct rendering driver for a given screen.
- */
-static void *DummyCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- (void) dpy;
- (void) scrn;
- (void) psc;
- (void) numConfigs;
- (void) config;
- return NULL;
-}
-
-
-
/**
* Extract the ith directory path out of a colon-separated list of paths. No
* more than \c dirLen characters, including the terminating \c NUL, will be
}
+/**
+ * Versioned name of the expected \c __driCreateNewScreen function.
+ *
+ * The version of the last incompatible loader/driver inteface change is
+ * appended to the name of the \c __driCreateNewScreen function. This
+ * prevents loaders from trying to load drivers that are too old.
+ *
+ * \todo
+ * Create a macro or something so that this is automatically updated.
+ */
+static const char createNewScreenName[] = "__driCreateNewScreen_20050722";
+
+
/**
* Try to \c dlopen the named driver.
*
return NULL; /* out of memory! */
}
- driver->createScreenFunc = (CreateScreenFunc)
- dlsym(handle, "__driCreateScreen");
driver->createNewScreenFunc = (CreateNewScreenFunc)
- dlsym(handle, "__driCreateNewScreen");
+ dlsym(handle, createNewScreenName);
- if ( (driver->createScreenFunc == NULL)
- && (driver->createNewScreenFunc == NULL) ) {
+ if ( driver->createNewScreenFunc == NULL ) {
/* If the driver doesn't have this symbol then something's
* really, really wrong.
*/
- ErrorMessageF("Neither __driCreateScreen or __driCreateNewScreen "
- "are defined in %s_dri.so!\n", driverName);
+ ErrorMessageF("%s not defined in %s_dri.so!\n"
+ "Your driver may be too old for this libGL.\n",
+ createNewScreenName, driverName);
Xfree(driver);
dlclose(handle);
continue;
}
-#endif /* BUILT_IN_DRI_DRIVER */
-
-
/* This function isn't currently used.
*/
static void driDestroyDisplay(Display *dpy, void *private)
*/
pdisp->private = NULL;
pdisp->destroyDisplay = NULL;
- pdisp->createScreen = NULL;
if (!XF86DRIQueryExtension(dpy, &eventBase, &errorBase)) {
return NULL;
pdisp->destroyDisplay = driDestroyDisplay;
- /* allocate array of pointers to createScreen funcs */
- pdisp->createScreen = (CreateScreenFunc *) Xmalloc(numScreens * sizeof(void *));
- if (!pdisp->createScreen) {
- Xfree(pdpyp);
- return NULL;
- }
-
- /* allocate array of pointers to createScreen funcs */
+ /* allocate array of pointers to createNewScreen funcs */
pdisp->createNewScreen = (CreateNewScreenFunc *) Xmalloc(numScreens * sizeof(void *));
if (!pdisp->createNewScreen) {
- Xfree(pdisp->createScreen);
Xfree(pdpyp);
return NULL;
}
pdpyp->libraryHandles = (void **) Xmalloc(numScreens * sizeof(void*));
if (!pdpyp->libraryHandles) {
Xfree(pdisp->createNewScreen);
- Xfree(pdisp->createScreen);
Xfree(pdpyp);
return NULL;
}
-#ifdef BUILT_IN_DRI_DRIVER
- /* we'll statically bind to the built-in __driCreateScreen function */
- for (scrn = 0; scrn < numScreens; scrn++) {
- pdisp->createScreen[scrn] = __driCreateScreen;
- pdisp->createNewScreen[scrn] = NULL;
- pdpyp->libraryHandles[scrn] = NULL;
- }
-
-#else
/* dynamically discover DRI drivers for all screens, saving each
* driver's "__driCreateScreen" function pointer. That's the bootstrap
* entrypoint for all DRI drivers.
for (scrn = 0; scrn < numScreens; scrn++) {
__DRIdriver *driver = driGetDriver(dpy, scrn);
if (driver) {
- pdisp->createScreen[scrn] = driver->createScreenFunc;
pdisp->createNewScreen[scrn] = driver->createNewScreenFunc;
pdpyp->libraryHandles[scrn] = driver->handle;
}
else {
- pdisp->createScreen[scrn] = DummyCreateScreen;
pdisp->createNewScreen[scrn] = NULL;
pdpyp->libraryHandles[scrn] = NULL;
}
}
-#endif
return (void *)pdpyp;
}
*/
void (*destroyDisplay)(Display *dpy, void *displayPrivate);
- /**
- * Methods to create the private DRI screen data and initialize the
- * screen dependent methods.
- * This is an array [indexed by screen number] of function pointers.
- *
- * \deprecated This array of function pointers has been replaced by
- * \c __DRIdisplayRec::createNewScreen.
- * \sa __DRIdisplayRec::createNewScreen
- */
- CreateScreenFunc * createScreen;
-
/**
* Opaque pointer to private per display direct rendering data.
* \c NULL if direct rendering is not supported on this display.
/**
* Array of pointers to methods to create and initialize the private DRI
* screen data.
- *
- * \sa __DRIdisplayRec::createScreen
*/
CreateNewScreenFunc * createNewScreen;
};
struct __DRIdriverRec {
const char *name;
void *handle;
- CreateScreenFunc createScreenFunc;
CreateNewScreenFunc createNewScreenFunc;
struct __DRIdriverRec *next;
};
* a pointer to the config data for that screen (if the screen supports GL).
*/
typedef struct __GLXscreenConfigsRec {
- /**
- * GLX visuals formated as \c __GLXvisualConfig structures.
- */
- /*@{*/
- __GLXvisualConfig * old_configs;
- int numOldConfigs;
- /*@}*/
-
/**
* GLX extension string reported by the X-server.
*/
#endif
/**
- * Linked list of configurations for this screen. This is intended to
- * be a superset of \c old_configs.
+ * Linked list of configurations for this screen.
*/
__GLcontextModes *configs;
+
/**
* Per-screen dynamic GLX extension tracking. The \c direct_support
* field only contains enough bits for 64 extensions. Should libGL
#include "xf86dri.h"
static Bool __glXWindowExists(Display *dpy, GLXDrawable draw);
-
-static void * DriverCreateContextWrapper( const __GLXscreenConfigs *psc,
- Display *dpy, XVisualInfo *vis, void *shared, __DRIcontext *ctx,
- const __GLcontextModes *fbconfig, int render_type );
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-static Bool dummyBindContext2( Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read, GLXContext gc );
-
-static Bool dummyUnbindContext2( Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read, GLXContext gc );
-
-/****************************************************************************/
-
-/**
- * Used as glue when a driver does not support
- * \c __DRIcontextRec::bindContext2.
- *
- * XXX .bindContext is only defined as a function pointer if
- * !DRI_NEW_INTERFACE_ONLY.
- *
- * \sa DriverCreateContextWrapper, __DRIcontextRec::bindContext2
- */
-static Bool dummyBindContext2( Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
- GLXContext gc )
-{
- assert( draw == read );
- return (*gc->driContext.bindContext)( dpy, scrn, draw, gc );
-}
-
-/**
- * Used as glue when a driver does not support
- * \c __DRIcontextRec::unbindContext2.
- *
- * XXX .unbindContext is only defined as a function pointer if
- * !DRI_NEW_INTERFACE_ONLY.
- *
- * \sa DriverCreateContextWrapper, __DRIcontextRec::unbindContext2
- */
-static Bool dummyUnbindContext2( Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
- GLXContext gc )
-{
- assert( draw == read );
- return (*gc->driContext.unbindContext)( dpy, scrn, draw, gc, GL_FALSE );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-
-/****************************************************************************/
-/**
- * Wrap the call to the driver's \c createContext function.
- *
- * The \c createContext function is wrapped because not all drivers support
- * the "new" \c unbindContext2 and \c bindContext2 interfaces. libGL should
- * not have to check to see which functions the driver supports. Instead,
- * if either function is not supported it is wrapped. The wrappers test to
- * make sure that both drawables are the same and pass control to the old
- * interface.
- *
- * \sa dummyBindContext2, dummyUnbindContext2,
- * __DRIcontextRec::bindContext2, __DRIcontextRec::unbindContext2
- */
-
-static void * DriverCreateContextWrapper( const __GLXscreenConfigs *psc,
- Display *dpy, XVisualInfo *vis,
- void *shared,
- __DRIcontext *ctx,
- const __GLcontextModes *modes,
- int render_type )
-{
- void * ctx_priv = NULL;
-
- if ( psc->driScreen.createNewContext != NULL ) {
- assert( modes != NULL );
- ctx_priv = (*psc->driScreen.createNewContext)(dpy, modes, render_type,
- shared, ctx);
-
- /* If the driver supports the createNewContext interface, then
- * it MUST also support either the bindContext2 / unbindContext2
- * interface or the bindContext3 / unbindContext3 interface.
- */
-
- assert( (ctx_priv == NULL) || (ctx->unbindContext2 != NULL)
- || (ctx->unbindContext3 != NULL) );
- assert( (ctx_priv == NULL) || (ctx->bindContext2 != NULL)
- || (ctx->bindContext3 != NULL) );
- }
-#ifndef DRI_NEW_INTERFACE_ONLY
- else {
- if ( vis != NULL ) {
- ctx_priv = (*psc->driScreen.createContext)(dpy, vis, shared, ctx);
-
- if ( ctx_priv != NULL ) {
- if ( ctx->unbindContext2 == NULL ) {
- ctx->unbindContext2 = dummyUnbindContext2;
- }
-
- if ( ctx->bindContext2 == NULL ) {
- ctx->bindContext2 = dummyBindContext2;
- }
- }
- }
- }
-#endif
-
- return ctx_priv;
-}
#endif
if (psc && psc->driScreen.private) {
void * const shared = (shareList != NULL)
? shareList->driContext.private : NULL;
- gc->driContext.private =
- DriverCreateContextWrapper( psc, dpy, vis, shared,
- &gc->driContext, mode,
- renderType );
+ gc->driContext.private =
+ (*psc->driScreen.createNewContext)( dpy, mode, renderType,
+ shared,
+ &gc->driContext );
if (gc->driContext.private) {
gc->isDirect = GL_TRUE;
gc->screen = mode->screen;
return reply.isDirect;
}
+/**
+ * \todo
+ * Shouldn't this function \b always return \c GL_FALSE when
+ * \c GLX_DIRECT_RENDERING is not defined? Do we really need to bother with
+ * the GLX protocol here at all?
+ */
PUBLIC Bool GLX_PREFIX(glXIsDirect)(Display *dpy, GLXContext gc)
{
if (!gc) {
* 20040415 - Added support for bindContext3 and unbindContext3.
* 20040602 - Add __glXGetDrawableInfo. I though that was there
* months ago. :(
+ * 20050722 - Gut all the old interfaces. This breaks compatability with
+ * any DRI driver built to any previous version.
*/
- return 20040602;
+ return 20050722;
}
*/
int __glXCloseDisplay(Display *dpy, XExtCodes *codes);
-static GLboolean FillInVisuals( __GLXscreenConfigs * psc );
/************************************************************************/
if(psc->effectiveGLXexts)
Xfree(psc->effectiveGLXexts);
- if ( psc->old_configs != NULL ) {
- Xfree( psc->old_configs );
- psc->old_configs = NULL;
- psc->numOldConfigs = 0;
- }
-
psc->configs = NULL; /* NOTE: just for paranoia */
}
priv->driDisplay.private = NULL;
#endif
-#ifdef GLX_DIRECT_RENDERING
- XFree(priv->driDisplay.createScreen);
-#endif
-
Xfree((char*) priv);
return 0;
}
}
-/**
- * Determine if a \c __GLcontextModes structure has the right mojo to be
- * converted to a \c __GLXvisualConfig to be sent to an "old" style DRI
- * driver.
- */
-#define MODE_HAS_MOJO(m) \
- ((m)->visualID != GLX_DONT_CARE) \
- && ((m)->sampleBuffers == 0) \
- && ((m)->samples == 0) \
- && (((m)->drawableType & GLX_WINDOW_BIT) != 0) \
- && (((m)->xRenderable == GL_TRUE) \
- || ((m)->xRenderable == GLX_DONT_CARE))
-
-
-/**
- * Convert the FBConfigs associated with a screen into an array of
- * \c __GLXvisualConfig structures. These structures are passed into DRI
- * drivers that use the "old" interface. The old-style drivers had a fairly
- * strict set of visual types that could be supported. FBConfigs that
- * cannot be supported are not converted.
- *
- * \param psc Screen whose FBConfigs need to be swizzled.
- *
- * \returns
- * If memory could be allocated and at least one FBConfig could be converted
- * to a \c __GLXvisualConfig structure, \c GL_TRUE is returned. Otherwise,
- * \c GL_FALSE is returned.
- *
- * \todo
- * When the old DRI driver interface is no longer supported, this function
- * can be removed.
- */
-static GLboolean
-FillInVisuals( __GLXscreenConfigs * psc )
-{
- __GLcontextModes *modes;
- int glx_visual_count;
-
-
- glx_visual_count = 0;
- for ( modes = psc->configs ; modes != NULL ; modes = modes->next ) {
- if ( MODE_HAS_MOJO( modes ) ) {
- glx_visual_count++;
- }
- }
-
- psc->old_configs = (__GLXvisualConfig *)
- Xmalloc( sizeof( __GLXvisualConfig ) * glx_visual_count );
- if ( psc->old_configs == NULL ) {
- return GL_FALSE;
- }
-
- glx_visual_count = 0;
- for ( modes = psc->configs ; modes != NULL ; modes = modes->next ) {
- if ( MODE_HAS_MOJO( modes ) ) {
-
-#define COPY_VALUE(src_tag,dst_tag) \
- psc->old_configs[glx_visual_count]. dst_tag = modes-> src_tag
-
- COPY_VALUE( visualID, vid );
- COPY_VALUE( rgbMode, rgba );
- COPY_VALUE( stereoMode, stereo );
- COPY_VALUE( doubleBufferMode, doubleBuffer );
-
- psc->old_configs[glx_visual_count].class =
- _gl_convert_to_x_visual_type( modes->visualType );
-
- COPY_VALUE( level, level );
- COPY_VALUE( numAuxBuffers, auxBuffers );
-
- COPY_VALUE( redBits, redSize );
- COPY_VALUE( greenBits, greenSize );
- COPY_VALUE( blueBits, blueSize );
- COPY_VALUE( alphaBits, alphaSize );
- COPY_VALUE( rgbBits, bufferSize );
- COPY_VALUE( accumRedBits, accumRedSize );
- COPY_VALUE( accumGreenBits, accumGreenSize );
- COPY_VALUE( accumBlueBits, accumBlueSize );
- COPY_VALUE( accumAlphaBits, accumAlphaSize );
- COPY_VALUE( depthBits, depthSize );
- COPY_VALUE( stencilBits, stencilSize );
-
- COPY_VALUE( visualRating, visualRating );
- COPY_VALUE( transparentPixel, transparentPixel );
- COPY_VALUE( transparentRed, transparentRed );
- COPY_VALUE( transparentGreen, transparentGreen );
- COPY_VALUE( transparentBlue, transparentBlue );
- COPY_VALUE( transparentAlpha, transparentAlpha );
- COPY_VALUE( transparentIndex, transparentIndex );
-
-#undef COPY_VALUE
-
- glx_visual_count++;
- }
- }
-
- psc->numOldConfigs = glx_visual_count;
- if ( glx_visual_count == 0 ) {
- Xfree( psc->old_configs );
- psc->old_configs = NULL;
- }
-
- return (glx_visual_count != 0);
-}
-
-
void
__glXInitializeVisualConfigFromTags( __GLcontextModes *config, int count,
const INT32 *bp, Bool tagged_only,
char *driverName;
/*
- * Get device name (like "tdfx") and the ddx version numbers.
- * We'll check the version in each DRI driver's "createScreen"
- * function.
+ * Get device name (like "tdfx") and the ddx version
+ * numbers. We'll check the version in each DRI driver's
+ * "createNewScreen" function.
*/
err_msg = "XF86DRIGetClientDriverName";
if (XF86DRIGetClientDriverName(dpy, scrn,
if ( status == 0 ) {
/*
- * Map the SAREA region. Further mmap regions may be setup in
- * each DRI driver's "createScreen" function.
+ * Map the SAREA region. Further mmap regions
+ * may be setup in each DRI driver's
+ * "createNewScreen" function.
*/
status = drmMap(fd, hSAREA, SAREA_MAX,
&pSAREA);
psc->ext_list_first_time = GL_TRUE;
/* Initialize the direct rendering per screen data and functions */
if (priv->driDisplay.private != NULL) {
+ /* FIXME: Should it be some sort of an error if createNewScreen[i]
+ * FIXME: is NULL?
+ */
if (priv->driDisplay.createNewScreen &&
priv->driDisplay.createNewScreen[i]) {
& priv->driDisplay,
priv->driDisplay.createNewScreen[i] );
}
- else if (priv->driDisplay.createScreen &&
- priv->driDisplay.createScreen[i]) {
- /* screen initialization (bootstrap the driver) */
- if ( (psc->old_configs == NULL)
- && !FillInVisuals(psc) ) {
- FreeScreenConfigs(priv);
- return GL_FALSE;
- }
-
- psc->driScreen.screenConfigs = (void *)psc;
- psc->driScreen.private =
- (*(priv->driDisplay.createScreen[i]))(dpy, i, &psc->driScreen,
- psc->numOldConfigs,
- psc->old_configs);
- }
}
#endif
}
/* Assinging zero here assures we'll never go direct */
dpyPriv->driDisplay.private = 0;
dpyPriv->driDisplay.destroyDisplay = 0;
- dpyPriv->driDisplay.createScreen = 0;
}
else {
dpyPriv->driDisplay.private =
}
+#ifdef GLX_DIRECT_RENDERING
static Bool BindContextWrapper( Display *dpy, GLXContext gc,
GLXDrawable draw, GLXDrawable read )
{
-#ifdef GLX_DIRECT_RENDERING
- if ( gc->driContext.bindContext3 != NULL ) {
- return (*gc->driContext.bindContext3)(dpy, gc->screen, draw, read,
- & gc->driContext);
- }
-#ifndef DRI_NEW_INTERFACE_ONLY
- else {
- return (*gc->driContext.bindContext2)(dpy, gc->screen, draw, read,
- gc);
- }
-#endif
-#endif
- return GL_FALSE;
+ return (*gc->driContext.bindContext)(dpy, gc->screen, draw, read,
+ & gc->driContext);
}
-static Bool UnbindContextWrapper( Display *dpy, GLXContext gc )
+static Bool UnbindContextWrapper( GLXContext gc )
{
-#ifdef GLX_DIRECT_RENDERING
- if ( gc->driContext.unbindContext3 != NULL ) {
- return (*gc->driContext.unbindContext3)(dpy, gc->screen,
- gc->currentDrawable,
- gc->currentReadable,
- & gc->driContext );
- }
-#ifndef DRI_NEW_INTERFACE_ONLY
- else {
- return (*gc->driContext.unbindContext2)(dpy, gc->screen,
- gc->currentDrawable,
- gc->currentReadable, gc);
- }
-#endif
-#endif
- return GL_FALSE;
+ return (*gc->driContext.unbindContext)(gc->currentDpy, gc->screen,
+ gc->currentDrawable,
+ gc->currentReadable,
+ & gc->driContext );
}
+#endif /* GLX_DIRECT_RENDERING */
/*
/* Unbind the old direct rendering context */
if (oldGC->isDirect) {
if (oldGC->driContext.private) {
- if (! UnbindContextWrapper( oldGC->currentDpy, oldGC )) {
+ if (! UnbindContextWrapper( oldGC )) {
/* The make current failed. Just return GL_FALSE. */
return GL_FALSE;
}
{ GLX(NV_render_depth_texture), VER(0,0), N, N, N, N },
{ GLX(NV_render_texture_rectangle), VER(0,0), N, N, N, N },
{ GLX(NV_vertex_array_range), VER(0,0), N, N, N, Y }, /* Deprecated */
- { GLX(OML_swap_method), VER(0,0), Y, N, N, N },
+ { GLX(OML_swap_method), VER(0,0), Y, Y, N, N },
{ GLX(OML_sync_control), VER(0,0), Y, N, N, Y },
{ GLX(SGI_cushion), VER(0,0), N, N, N, N },
{ GLX(SGI_make_current_read), VER(1,3), Y, N, N, N },
{ GLX(SGIS_color_range), VER(0,0), N, N, N, N },
{ GLX(SGIS_multisample), VER(0,0), Y, Y, N, N },
{ GLX(SGIX_dm_buffer), VER(0,0), N, N, N, N },
- { GLX(SGIX_fbconfig), VER(1,3), Y, N, N, N },
+ { GLX(SGIX_fbconfig), VER(1,3), Y, Y, N, N },
{ GLX(SGIX_pbuffer), VER(1,3), Y, N, N, N },
{ GLX(SGIX_swap_barrier), VER(0,0), N, N, N, N },
{ GLX(SGIX_swap_group), VER(0,0), N, N, N, N },
*
* These functions are compiled into each DRI driver so libGL.so knows nothing
* about them.
- *
- * \note
- * When \c DRI_NEW_INTERFACE_ONLY is defined, code is built / not built so
- * that only the "new" libGL-to-driver interfaces are supported. This breaks
- * backwards compatability. However, this may be necessary when DRI drivers
- * are built to be used in non-XFree86 environments.
- *
- * \todo There are still some places in the code that need to be wrapped with
- * \c DRI_NEW_INTERFACE_ONLY.
*/
#define MAP_FAILED ((void *)-1)
#endif
-#ifndef DRI_NEW_INTERFACE_ONLY
-# include <X11/Xlibint.h>
-# include <Xext.h>
-# include <extutil.h>
-# include "xf86dri.h"
-# define _mesa_malloc(b) Xmalloc(b)
-# define _mesa_free(m) Xfree(m)
-#else
-# include "imports.h"
-# define None 0
-#endif /* DRI_NEW_INTERFACE_ONLY */
+#include "imports.h"
+#define None 0
#include "dri_util.h"
#include "drm_sarea.h"
static void driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate);
-
-
-#ifdef not_defined
-static GLboolean driFeatureOn(const char *name)
-{
- char *env = getenv(name);
-
- if (!env) return GL_FALSE;
- if (!strcasecmp(env, "enable")) return GL_TRUE;
- if (!strcasecmp(env, "1")) return GL_TRUE;
- if (!strcasecmp(env, "on")) return GL_TRUE;
- if (!strcasecmp(env, "true")) return GL_TRUE;
- if (!strcasecmp(env, "t")) return GL_TRUE;
- if (!strcasecmp(env, "yes")) return GL_TRUE;
- if (!strcasecmp(env, "y")) return GL_TRUE;
-
- return GL_FALSE;
-}
-#endif /* not_defined */
-
-
/**
* Print message to \c stderr if the \c LIBGL_DEBUG environment variable
* is set.
}
}
-/*
- * fd.o bug #1713: Some rare libGL's have __glXFindDRIScreen defined but do not
- * export it via glXGetProcAddress. These are not supported anymore, so print
- * an error message to that effect. - ajax 2004-10-26
- */
typedef __DRIscreen *(*PFNGLXFINDDRISCREEN)(__DRInativeDisplay *, int);
-
-static __DRIscreen *glx_find_dri_screen(__DRInativeDisplay *d, int i)
-{
- PFNGLXFINDDRISCREEN findscreen =
- (PFNGLXFINDDRISCREEN)glXGetProcAddress("__glXFindDRIScreen");
-
- if (!findscreen)
- {
- __driUtilMessage("glXGetProcAddress(\"__glXFindDRIScreen\") failed!");
- __driUtilMessage("Your libGL is too old, please upgrade.");
- return NULL;
- }
- else return findscreen(d, i);
-}
-
-/*****************************************************************/
-/** \name Visual utility functions */
-/*****************************************************************/
-/*@{*/
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * Find a \c __GLcontextModes structure matching the given visual ID.
- *
- * \param dpy Display to search for a matching configuration.
- * \param scrn Screen number on \c dpy to be searched.
- * \param vid Desired \c VisualID to find.
- *
- * \returns A pointer to a \c __GLcontextModes structure that matches \c vid,
- * if found, or \c NULL if no match is found.
- */
-static const __GLcontextModes *
-findConfigMode(__DRInativeDisplay *dpy, int scrn, VisualID vid,
- const __DRIscreen * pDRIScreen)
-{
- if ( (pDRIScreen != NULL) && (pDRIScreen->private != NULL) ) {
- const __DRIscreenPrivate * const psp =
- (const __DRIscreenPrivate *) pDRIScreen->private;
-
- return _gl_context_modes_find_visual( psp->modes, vid );
- }
-
- return NULL;
-}
-
-
-/**
- * This function is a hack to work-around old versions of libGL.so that
- * do not export \c XF86DRICreateContextWithConfig. I would modify the
- * code to just use this function, but the stand-alone driver (i.e., DRI
- * drivers that are built to work without XFree86) shouldn't have to know
- * about X structures like a \c Visual.
- */
-static GLboolean
-fake_XF86DRICreateContextWithConfig( __DRInativeDisplay* dpy, int screen, int configID,
- XID* context, drm_context_t * hHWContext )
-{
- Visual vis;
-
- vis.visualid = configID;
- return XF86DRICreateContext( dpy, screen, & vis, context, hHWContext );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-/*@}*/
+static PFNGLXFINDDRISCREEN glx_find_dri_screen = NULL;
/*****************************************************************/
return pdraw;
}
-#ifndef DRI_NEW_INTERFACE_ONLY
-static GLboolean __driWindowExistsFlag;
-
-static int __driWindowExistsErrorHandler(Display *dpy, XErrorEvent *xerr)
-{
- if (xerr->error_code == BadWindow) {
- __driWindowExistsFlag = GL_FALSE;
- }
- return 0;
-}
-
-/**
- * Determine if a window associated with a \c GLXDrawable exists on the
- * X-server.
- *
- * \param dpy Display associated with the drawable to be queried.
- * \param draw \c GLXDrawable to test.
- *
- * \returns \c GL_TRUE if a window exists that is associated with \c draw,
- * otherwise \c GL_FALSE is returned.
- *
- * \warning This function is not currently thread-safe.
- *
- * \deprecated
- * \c __glXWindowExists (from libGL) is prefered over this function. Starting
- * with the next major release of XFree86, this function will be removed.
- * Even now this function is no longer directly called. Instead it is called
- * via a function pointer if and only if \c __glXWindowExists does not exist.
- *
- * \sa __glXWindowExists glXGetProcAddress window_exists
- */
-static GLboolean __driWindowExists(Display *dpy, GLXDrawable draw)
-{
- XWindowAttributes xwa;
- int (*oldXErrorHandler)(Display *, XErrorEvent *);
-
- XSync(dpy, GL_FALSE);
- __driWindowExistsFlag = GL_TRUE;
- oldXErrorHandler = XSetErrorHandler(__driWindowExistsErrorHandler);
- XGetWindowAttributes(dpy, draw, &xwa); /* dummy request */
- XSetErrorHandler(oldXErrorHandler);
- return __driWindowExistsFlag;
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
/**
* Find drawables in the local hash that have been destroyed on the
* While casting the opaque private pointers associated with the parameters
* into their respective real types it also assures they are not \c NULL.
*/
-static GLboolean driUnbindContext3(__DRInativeDisplay *dpy, int scrn,
+static GLboolean driUnbindContext(__DRInativeDisplay *dpy, int scrn,
__DRIid draw, __DRIid read,
__DRIcontext *ctx)
{
/*
** Assume error checking is done properly in glXMakeCurrent before
- ** calling driUnbindContext3.
+ ** calling driUnbindContext.
*/
if (ctx == NULL || draw == None || read == None) {
return GL_FALSE;
}
- pDRIScreen = glx_find_dri_screen(dpy, scrn);
+ pDRIScreen = (*glx_find_dri_screen)(dpy, scrn);
if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
/* ERROR!!! */
return GL_FALSE;
* for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
* function.
*/
-static GLboolean driBindContext3(__DRInativeDisplay *dpy, int scrn,
+static GLboolean driBindContext(__DRInativeDisplay *dpy, int scrn,
__DRIid draw, __DRIid read,
__DRIcontext * ctx)
{
return GL_FALSE;
}
- pDRIScreen = glx_find_dri_screen(dpy, scrn);
+ pDRIScreen = (*glx_find_dri_screen)(dpy, scrn);
if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
/* ERROR!!! */
return GL_FALSE;
return DoBindContext( dpy, draw, read, ctx, ctx->mode,
(__DRIscreenPrivate *)pDRIScreen->private );
}
-
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * This function takes both a read buffer and a draw buffer. This is needed
- * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
- * function.
- */
-static GLboolean driBindContext2(Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
- GLXContext gc)
-{
- __DRIscreen *pDRIScreen;
- const __GLcontextModes *modes;
-
- /*
- ** Assume error checking is done properly in glXMakeCurrent before
- ** calling driBindContext.
- */
-
- if (gc == NULL || draw == None || read == None) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- pDRIScreen = glx_find_dri_screen(dpy, scrn);
- modes = (driCompareGLXAPIVersion( 20040317 ) >= 0)
- ? gc->driContext.mode
- : findConfigMode( dpy, scrn, gc->vid, pDRIScreen );
-
- if ( modes == NULL ) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- /* findConfigMode will return NULL if the DRI screen or screen private
- * are NULL.
- */
- assert( (pDRIScreen != NULL) && (pDRIScreen->private != NULL) );
-
- return DoBindContext( dpy, draw, read, & gc->driContext, modes,
- (__DRIscreenPrivate *)pDRIScreen->private );
-}
-
-static GLboolean driUnbindContext2(Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
- GLXContext gc)
-{
- return driUnbindContext3(dpy, scrn, draw, read, & gc->driContext);
-}
-
-/*
- * Simply call bind with the same GLXDrawable for the read and draw buffers.
- */
-static GLboolean driBindContext(Display *dpy, int scrn,
- GLXDrawable draw, GLXContext gc)
-{
- return driBindContext2(dpy, scrn, draw, draw, gc);
-}
-
-
-/*
- * Simply call bind with the same GLXDrawable for the read and draw buffers.
- */
-static GLboolean driUnbindContext(Display *dpy, int scrn,
- GLXDrawable draw, GLXContext gc,
- int will_rebind)
-{
- (void) will_rebind;
- return driUnbindContext2( dpy, scrn, draw, draw, gc );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/*@}*/
int renderType,
const int *attrs)
{
- __DRIscreen * const pDRIScreen = glx_find_dri_screen(dpy, modes->screen);
+ __DRIscreen * const pDRIScreen = (*glx_find_dri_screen)(dpy, modes->screen);
__DRIscreenPrivate *psp;
__DRIdrawablePrivate *pdp;
pdp->getInfo = (PFNGLXGETDRAWABLEINFOPROC)
glXGetProcAddress( (const GLubyte *) "__glXGetDrawableInfo" );
if ( pdp->getInfo == NULL ) {
-#ifdef DRI_NEW_INTERFACE_ONLY
(void)XF86DRIDestroyDrawable(dpy, modes->screen, pdp->draw);
_mesa_free(pdp);
return NULL;
-#else
- pdp->getInfo = (PFNGLXGETDRAWABLEINFOPROC) XF86DRIGetDrawableInfo;
-#endif /* DRI_NEW_INTERFACE_ONLY */
}
if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, modes,
pdraw->destroyDrawable = driDestroyDrawable;
pdraw->swapBuffers = driSwapBuffers; /* called by glXSwapBuffers() */
- if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
- pdraw->getSBC = driGetSBC;
- pdraw->waitForSBC = driWaitForSBC;
- pdraw->waitForMSC = driWaitForMSC;
- pdraw->swapBuffersMSC = driSwapBuffersMSC;
- pdraw->frameTracking = NULL;
- pdraw->queryFrameTracking = driQueryFrameTracking;
-
- /* This special default value is replaced with the configured
- * default value when the drawable is first bound to a direct
- * rendering context. */
- pdraw->swap_interval = (unsigned)-1;
- }
+ pdraw->getSBC = driGetSBC;
+ pdraw->waitForSBC = driWaitForSBC;
+ pdraw->waitForMSC = driWaitForMSC;
+ pdraw->swapBuffersMSC = driSwapBuffersMSC;
+ pdraw->frameTracking = NULL;
+ pdraw->queryFrameTracking = driQueryFrameTracking;
+
+ /* This special default value is replaced with the configured
+ * default value when the drawable is first bound to a direct
+ * rendering context.
+ */
+ pdraw->swap_interval = (unsigned)-1;
pdp->swapBuffers = psp->DriverAPI.SwapBuffers;
__DRIscreenPrivate *psp;
void * const shareCtx = (pshare != NULL) ? pshare->driverPrivate : NULL;
- pDRIScreen = glx_find_dri_screen(dpy, modes->screen);
+ pDRIScreen = (*glx_find_dri_screen)(dpy, modes->screen);
if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
/* ERROR!!! */
return NULL;
}
pctx->destroyContext = driDestroyContext;
-#ifdef DRI_NEW_INTERFACE_ONLY
- pctx->bindContext = NULL;
- pctx->unbindContext = NULL;
- pctx->bindContext2 = NULL;
- pctx->unbindContext2 = NULL;
- pctx->bindContext3 = driBindContext3;
- pctx->unbindContext3 = driUnbindContext3;
-#else
- pctx->bindContext = (void *)driBindContext;
- pctx->unbindContext = (void *)driUnbindContext;
- if ( driCompareGLXAPIVersion( 20030606 ) >= 0 ) {
- pctx->bindContext2 = (void *)driBindContext2;
- pctx->unbindContext2 = (void *)driUnbindContext2;
- }
-
- if ( driCompareGLXAPIVersion( 20040415 ) >= 0 ) {
- pctx->bindContext3 = (void *)driBindContext3;
- pctx->unbindContext3 = (void *)driUnbindContext3;
- }
-#endif
+ pctx->bindContext = driBindContext;
+ pctx->unbindContext = driUnbindContext;
if ( !(*psp->DriverAPI.CreateContext)(modes, pcp, shareCtx) ) {
(void)XF86DRIDestroyContext(dpy, modes->screen, pcp->contextID);
return pcp;
}
-
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * Create the per-drawable private driver information.
- *
- * \param dpy the display handle.
- * \param vis the visual information.
- * \param sharedPrivate the shared context dependent methods or \c NULL if
- * non-existent.
- * \param pctx will receive the context dependent methods.
- *
- * \returns a opaque pointer to the per-context private information on success, or \c NULL
- * on failure.
- *
- * \deprecated
- * This function has been replaced by \c driCreateNewContext. In drivers
- * built to work with XFree86, this function will continue to exist to support
- * older versions of libGL. Starting with the next major relelase of XFree86,
- * this function will be removed.
- *
- * \internal
- * This function allocates and fills a __DRIcontextPrivateRec structure. It
- * gets the visual, converts it into a __GLcontextModesRec and passes it
- * to __DriverAPIRec::CreateContext to create the context.
- */
-static void *driCreateContext(Display *dpy, XVisualInfo *vis,
- void *sharedPrivate, __DRIcontext *pctx)
-{
- __DRIscreen *pDRIScreen;
- const __GLcontextModes *modes;
-
- pDRIScreen = glx_find_dri_screen(dpy, vis->screen);
- if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
- /* ERROR!!! */
- return NULL;
- }
-
-
- /* Setup a __GLcontextModes struct corresponding to vis->visualid
- * and create the rendering context.
- */
-
- modes = findConfigMode(dpy, vis->screen, vis->visualid, pDRIScreen);
- return (modes == NULL)
- ? NULL
- : driCreateNewContext( dpy, modes, GLX_RGBA_TYPE,
- sharedPrivate, pctx );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/*@}*/
* \param internal_api_version Version of the internal interface between the
* driver and libGL.
* \param driverAPI Driver API functions used by other routines in dri_util.c.
+ *
+ * \note
+ * There is no need to check the minimum API version in this function. Since
+ * the \c __driCreateNewScreen function is versioned, it is impossible for a
+ * loader that is too old to even load this driver.
*/
__DRIscreenPrivate *
__driUtilCreateNewScreen(__DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
__DRIscreenPrivate *psp;
-#ifdef DRI_NEW_INTERFACE_ONLY
- if ( internal_api_version < 20040602 ) {
- fprintf( stderr, "libGL error: libGL.so version (%08u) is too old. "
- "20040602 or later is required.\n", internal_api_version );
- return NULL;
- }
-#else
- if ( internal_api_version == 20031201 ) {
- fprintf( stderr, "libGL error: libGL version 20031201 has critical "
- "binary compatilibity bugs.\nlibGL error: You must upgrade "
- "to use direct-rendering!\n" );
- return NULL;
- }
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-
window_exists = (PFNGLXWINDOWEXISTSPROC)
glXGetProcAddress( (const GLubyte *) "__glXWindowExists" );
if ( window_exists == NULL ) {
-#ifdef DRI_NEW_INTERFACE_ONLY
- fprintf( stderr, "libGL error: libGL.so version (%08u) is too old. "
- "20021128 or later is required.\n", internal_api_version );
return NULL;
-#else
- window_exists = (PFNGLXWINDOWEXISTSPROC) __driWindowExists;
-#endif /* DRI_NEW_INTERFACE_ONLY */
+ }
+
+ glx_find_dri_screen =
+ (PFNGLXFINDDRISCREEN)glXGetProcAddress("__glXFindDRIScreen");
+ if ( glx_find_dri_screen == NULL ) {
+ return NULL;
}
create_context_with_config = (PFNGLXCREATECONTEXTWITHCONFIGPROC)
glXGetProcAddress( (const GLubyte *) "__glXCreateContextWithConfig" );
if ( create_context_with_config == NULL ) {
-#ifdef DRI_NEW_INTERFACE_ONLY
- fprintf( stderr, "libGL error: libGL.so version (%08u) is too old. "
- "20031201 or later is required.\n", internal_api_version );
return NULL;
-#else
- create_context_with_config = (PFNGLXCREATECONTEXTWITHCONFIGPROC)
- fake_XF86DRICreateContextWithConfig;
-#endif /* DRI_NEW_INTERFACE_ONLY */
}
api_ver = internal_api_version;
psp->dummyContextPriv.driScreenPriv = NULL;
psc->destroyScreen = driDestroyScreen;
-#ifndef DRI_NEW_INTERFACE_ONLY
- psc->createContext = driCreateContext;
-#else
- psc->createContext = NULL;
-#endif
psc->createNewDrawable = driCreateNewDrawable;
psc->getDrawable = driGetDrawable;
-#ifdef DRI_NEW_INTERFACE_ONLY
psc->getMSC = driGetMSC;
psc->createNewContext = driCreateNewContext;
-#else
- if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
- psc->getMSC = driGetMSC;
-
- if ( driCompareGLXAPIVersion( 20030824 ) >= 0 ) {
- psc->createNewContext = driCreateNewContext;
- }
- }
-#endif
if ( (psp->DriverAPI.InitDriver != NULL)
&& !(*psp->DriverAPI.InitDriver)(psp) ) {
}
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * Utility function used to create a new driver-private screen structure.
- *
- * \param dpy Display pointer.
- * \param scrn Index of the screen.
- * \param psc DRI screen data (not driver private)
- * \param numConfigs Number of visual configs pointed to by \c configs.
- * \param configs Array of GLXvisualConfigs exported by the 2D driver.
- * \param driverAPI Driver API functions used by other routines in dri_util.c.
- *
- * \deprecated
- * This function has been replaced by \c __driUtilCreateNewScreen. In drivers
- * built to work with XFree86, this function will continue to exist to support
- * older versions of libGL. Starting with the next major relelase of XFree86,
- * this function will be removed.
- */
-__DRIscreenPrivate *
-__driUtilCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *configs,
- const struct __DriverAPIRec *driverAPI)
-{
- int directCapable;
- __DRIscreenPrivate *psp = NULL;
- drm_handle_t hSAREA;
- drmAddress pSAREA;
- char *BusID;
- __GLcontextModes *modes;
- __GLcontextModes *temp;
- int i;
- __DRIversion ddx_version;
- __DRIversion dri_version;
- __DRIversion drm_version;
- __DRIframebuffer framebuffer;
- int fd = -1;
- int status;
- const char * err_msg;
- const char * err_extra;
-
-
- if (!XF86DRIQueryDirectRenderingCapable(dpy, scrn, &directCapable)
- || !directCapable) {
- return NULL;
- }
-
-
- /* Create the linked list of context modes, and populate it with the
- * GLX visual information passed in by libGL.
- */
-
- modes = _gl_context_modes_create( numConfigs, sizeof(__GLcontextModes) );
- if ( modes == NULL ) {
- return NULL;
- }
-
- temp = modes;
- for ( i = 0 ; i < numConfigs ; i++ ) {
- assert( temp != NULL );
- _gl_copy_visual_to_context_mode( temp, & configs[i] );
- temp->screen = scrn;
-
- temp = temp->next;
- }
-
- err_msg = "XF86DRIOpenConnection";
- err_extra = NULL;
-
- if (XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
- fd = drmOpen(NULL,BusID);
- _mesa_free(BusID); /* No longer needed */
-
- err_msg = "open DRM";
- err_extra = strerror( -fd );
-
- if (fd >= 0) {
- drm_magic_t magic;
-
- err_msg = "drmGetMagic";
- err_extra = NULL;
-
- if (!drmGetMagic(fd, &magic)) {
- drmVersionPtr version = drmGetVersion(fd);
- if (version) {
- drm_version.major = version->version_major;
- drm_version.minor = version->version_minor;
- drm_version.patch = version->version_patchlevel;
- drmFreeVersion(version);
- }
- else {
- drm_version.major = -1;
- drm_version.minor = -1;
- drm_version.patch = -1;
- }
-
- err_msg = "XF86DRIAuthConnection";
- if (XF86DRIAuthConnection(dpy, scrn, magic)) {
- char *driverName;
-
- /*
- * Get device name (like "tdfx") and the ddx version numbers.
- * We'll check the version in each DRI driver's "createScreen"
- * function.
- */
- err_msg = "XF86DRIGetClientDriverName";
- if (XF86DRIGetClientDriverName(dpy, scrn,
- &ddx_version.major,
- &ddx_version.minor,
- &ddx_version.patch,
- &driverName)) {
-
- /* No longer needed. */
- _mesa_free( driverName );
-
- /*
- * Get the DRI X extension version.
- */
- err_msg = "XF86DRIQueryVersion";
- if (XF86DRIQueryVersion(dpy,
- &dri_version.major,
- &dri_version.minor,
- &dri_version.patch)) {
- drm_handle_t hFB;
- int junk;
-
- /*
- * Get device-specific info. pDevPriv will point to a struct
- * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h)
- * that has information about the screen size, depth, pitch,
- * ancilliary buffers, DRM mmap handles, etc.
- */
- err_msg = "XF86DRIGetDeviceInfo";
- if (XF86DRIGetDeviceInfo(dpy, scrn,
- &hFB,
- &junk,
- &framebuffer.size,
- &framebuffer.stride,
- &framebuffer.dev_priv_size,
- &framebuffer.dev_priv)) {
- framebuffer.width = DisplayWidth(dpy, scrn);
- framebuffer.height = DisplayHeight(dpy, scrn);
-
- /*
- * Map the framebuffer region.
- */
- status = drmMap(fd, hFB, framebuffer.size,
- (drmAddressPtr)&framebuffer.base);
-
- err_msg = "drmMap of framebuffer";
- err_extra = strerror( -status );
-
- if ( status == 0 ) {
- /*
- * Map the SAREA region. Further mmap regions may be setup in
- * each DRI driver's "createScreen" function.
- */
- status = drmMap(fd, hSAREA, SAREA_MAX,
- &pSAREA);
-
- err_msg = "drmMap of sarea";
- err_extra = strerror( -status );
-
- if ( status == 0 ) {
- PFNGLXGETINTERNALVERSIONPROC get_ver;
-
- get_ver = (PFNGLXGETINTERNALVERSIONPROC)
- glXGetProcAddress( (const GLubyte *) "__glXGetInternalVersion" );
-
- err_msg = "InitDriver";
- err_extra = NULL;
- psp = __driUtilCreateNewScreen( dpy, scrn, psc, modes,
- & ddx_version,
- & dri_version,
- & drm_version,
- & framebuffer,
- pSAREA,
- fd,
- (get_ver != NULL) ? (*get_ver)() : 1,
- driverAPI );
- }
- }
- }
- }
- }
- }
- }
- }
- }
-
- if ( psp == NULL ) {
- if ( pSAREA != MAP_FAILED ) {
- (void)drmUnmap(pSAREA, SAREA_MAX);
- }
-
- if ( framebuffer.base != MAP_FAILED ) {
- (void)drmUnmap((drmAddress)framebuffer.base, framebuffer.size);
- }
-
- if ( framebuffer.dev_priv != NULL ) {
- _mesa_free(framebuffer.dev_priv);
- }
-
- if ( fd >= 0 ) {
- (void)drmClose(fd);
- }
-
- if ( modes != NULL ) {
- _gl_context_modes_destroy( modes );
- }
-
- (void)XF86DRICloseConnection(dpy, scrn);
-
- if ( err_extra != NULL ) {
- fprintf(stderr, "libGL error: %s failed (%s)\n", err_msg,
- err_extra);
- }
- else {
- fprintf(stderr, "libGL error: %s failed\n", err_msg );
- }
-
- fprintf(stderr, "libGL error: reverting to (slow) indirect rendering\n");
- }
-
- return psp;
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-
/**
* Compare the current GLX API version with a driver supplied required version.
*
#define CAPI /* XXX this should be globally defined somewhere */
-#ifdef DRI_NEW_INTERFACE_ONLY
-# include <GL/gl.h>
-#else
-# include "glxclient.h"
-#endif /* DRI_NEW_INTERFACE_ONLY */
+#include <GL/gl.h>
#include "drm.h"
#include "drm_sarea.h"
#include "GL/internal/glcore.h"
#define GLX_BAD_CONTEXT 5
-/* This is a temporary relic. Once all drivers are converted to support
- * the new interface, it can go away.
- */
-#ifdef DRI_NEW_INTERFACE_ONLY
-#define USE_NEW_INTERFACE
-#endif
-
typedef struct __DRIdisplayPrivateRec __DRIdisplayPrivate;
typedef struct __DRIscreenPrivateRec __DRIscreenPrivate;
typedef struct __DRIcontextPrivateRec __DRIcontextPrivate;
drm_sarea_t *pSAREA, int fd, int internal_api_version,
const struct __DriverAPIRec *driverAPI );
-#ifndef DRI_NEW_INTERFACE_ONLY
-extern __DRIscreenPrivate *
-__driUtilCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config,
- const struct __DriverAPIRec *driverAPI);
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/* Test the version of the internal GLX API. Returns a value like strcmp. */
extern int
driCompareGLXAPIVersion( GLint required_version );
* \author Ian Romanick <idr@us.ibm.com>
*/
-#ifdef DRI_NEW_INTERFACE_ONLY
+#ifdef IN_DRI_DRIVER
# include <stdlib.h>
# include <string.h>
# include <GL/gl.h>
# define _mesa_malloc(b) Xmalloc(b)
# define _mesa_free(m) Xfree(m)
# endif /* XFree86Server */
-#endif /* DRI_NEW_INTERFACE_ONLY */
+#endif /* !defined(IN_DRI_DRIVER) */
#include "glcontextmodes.h"
-#ifndef DRI_NEW_INTERFACE_ONLY
+#if !defined(IN_DRI_DRIVER)
#define NUM_VISUAL_TYPES 6
/**
return GLX_BAD_ATTRIBUTE;
}
}
-#endif /* DRI_NEW_INTERFACE_ONLY */
+#endif /* !defined(IN_DRI_DRIVER) */
/**
#include "GL/internal/glcore.h"
-#ifndef DRI_NEW_INTERFACE_ONLY
+#if !defined(IN_DRI_DRIVER)
extern GLint _gl_convert_from_x_visual_type( int visualType );
extern GLint _gl_convert_to_x_visual_type( int visualType );
extern void _gl_copy_visual_to_context_mode( __GLcontextModes * mode,
const __GLXvisualConfig * config );
extern int _gl_get_context_mode_data( const __GLcontextModes *mode,
int attribute, int *value_return );
-#endif /* DRI_NEW_INTERFACE_ONLY */
+#endif /* !defined(IN_DRI_DRIVER) */
extern __GLcontextModes * _gl_context_modes_create( unsigned count,
size_t minimum_size );
#include "extensions.h"
#include "utils.h"
-#if !defined( DRI_NEW_INTERFACE_ONLY )
-#include "xf86dri.h" /* For XF86DRIQueryVersion prototype. */
-#endif
-
#if defined(USE_X86_ASM)
#include "x86/common_x86_asm.h"
#endif
}
-
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * Utility function used by drivers to test the verions of other components.
- *
- * \deprecated
- * All drivers using the new interface should use \c driCheckDriDdxVersions2
- * instead. This function is implemented using a call that is not available
- * to drivers using the new interface. Furthermore, the information gained
- * by this call (the DRI and DDX version information) is already provided to
- * the driver via the new interface.
- */
-GLboolean
-driCheckDriDdxDrmVersions(__DRIscreenPrivate *sPriv,
- const char * driver_name,
- int dri_major, int dri_minor,
- int ddx_major, int ddx_minor,
- int drm_major, int drm_minor)
-{
- static const char format[] = "%s DRI driver expected %s version %d.%d.x "
- "but got version %d.%d.%d";
- int major, minor, patch;
-
- /* Check the DRI version */
- if (XF86DRIQueryVersion(sPriv->display, &major, &minor, &patch)) {
- if (major != dri_major || minor < dri_minor) {
- __driUtilMessage(format, driver_name, "DRI", dri_major, dri_minor,
- major, minor, patch);
- return GL_FALSE;
- }
- }
-
- /* Check that the DDX driver version is compatible */
- if (sPriv->ddxMajor != ddx_major || sPriv->ddxMinor < ddx_minor) {
- __driUtilMessage(format, driver_name, "DDX", ddx_major, ddx_minor,
- sPriv->ddxMajor, sPriv->ddxMinor, sPriv->ddxPatch);
- return GL_FALSE;
- }
-
- /* Check that the DRM driver version is compatible */
- if (sPriv->drmMajor != drm_major || sPriv->drmMinor < drm_minor) {
- __driUtilMessage(format, driver_name, "DRM", drm_major, drm_minor,
- sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch);
- return GL_FALSE;
- }
-
- return GL_TRUE;
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/**
* Utility function used by drivers to test the verions of other components.
*
* \returns \c GL_TRUE if all version requirements are met. Otherwise,
* \c GL_FALSE is returned.
*
- * \sa __driCreateNewScreen, driCheckDriDdxDrmVersions, __driUtilMessage
+ * \sa __driCreateNewScreen, driCheckDriDdxDrmVersions2, __driUtilMessage
+ *
+ * \todo
+ * Now that the old \c driCheckDriDdxDrmVersions function is gone, this
+ * function and \c driCheckDriDdxDrmVersions2 should be renamed.
*/
GLboolean
driCheckDriDdxDrmVersions3(const char * driver_name,
extern void driInitSingleExtension( GLcontext * ctx,
const struct dri_extension * ext );
-#ifndef DRI_NEW_INTERFACE_ONLY
-extern GLboolean driCheckDriDdxDrmVersions( __DRIscreenPrivate *sPriv,
- const char * driver_name, int dri_major, int dri_minor,
- int ddx_major, int ddx_minor, int drm_major, int drm_minor );
-#endif
-
extern GLboolean driCheckDriDdxDrmVersions2(const char * driver_name,
const __DRIversion * driActual, const __DRIversion * driExpected,
const __DRIversion * ddxActual, const __DRIversion * ddxExpected,
GLuint driGetDefaultVBlankFlags( const driOptionCache *optionCache )
{
- GLuint flags = 0;
+ GLuint flags = VBLANK_FLAG_INTERVAL;
int vblank_mode;
- flags |= (driCompareGLXAPIVersion( 20030317 ) >= 0)
- ? VBLANK_FLAG_INTERVAL : 0;
if ( driCheckOption( optionCache, "vblank_mode", DRI_ENUM ) )
vblank_mode = driQueryOptioni( optionCache, "vblank_mode" );
#define FB_CONTEXT(ctx) ((fbContextPtr)(ctx->DriverCtx))
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
static const GLubyte *
get_string(GLcontext *ctx, GLenum pname)
__driHaltFBDev
};
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
fbFillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &ffbAPI);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
-
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
static __GLcontextModes *
return modes;
}
-#endif /* USE_NEW_INTERFACE */
/**
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
#ifndef _FFB_DAC_H
#define _FFB_DAC_H
-#if defined( DRI_NEW_INTERFACE_ONLY )
#define Bool int
-#endif
/* FFB utilizes two different ramdac chips:
*
#include "GL/internal/dri_interface.h"
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *fill_in_modes( __GLcontextModes *modes,
unsigned pixel_bits,
unsigned depth_bits,
return modes;
}
-#endif /* USE_NEW_INTERFACE */
-#ifdef USE_NEW_INTERFACE
+
static __GLcontextModes *
i810FillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return modes;
}
-#endif /* USE_NEW_INTERFACE */
-
/* static int i810_malloc_proxy_buf(drmBufMapPtr buffers) */
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &i810API);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
/**
* This is the bootstrap function for the driver. libGL supplies all of the
* requisite information about the system, and the driver initializes itself.
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
DRI_CONF_END;
const GLuint __driNConfigOptions = 2;
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /*USE_NEW_INTERFACE*/
static int i830_malloc_proxy_buf(drmBufMapPtr buffers)
{
{
i830ScreenPrivate *i830Screen;
I830DRIPtr gDRIPriv = (I830DRIPtr)sPriv->pDevPriv;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+ if ( glx_enable_extension == NULL ) {
+ return GL_FALSE;
+ }
+
/* Allocate the private area */
i830Screen = (i830ScreenPrivate *)CALLOC(sizeof(i830ScreenPrivate));
if (!i830Screen) {
}
#endif
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
-
- if ( glx_enable_extension != NULL ) {
- (*glx_enable_extension)( psc, "GLX_SGI_make_current_read" );
-
- if ( driCompareGLXAPIVersion( 20030915 ) >= 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGIX_fbconfig" );
- (*glx_enable_extension)( psc, "GLX_OML_swap_method" );
- }
- }
- }
+ (*glx_enable_extension)( psc, "GLX_SGI_make_current_read" );
return GL_TRUE;
}
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &i830API);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
-
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
i830FillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return modes;
}
-#endif /* USE_NEW_INTERFACE */
/**
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
DRI_CONF_END;
const GLuint __driNConfigOptions = 1;
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /*USE_NEW_INTERFACE*/
static void intelPrintDRIInfo(intelScreenPrivate *intelScreen,
{
intelScreenPrivate *intelScreen;
I830DRIPtr gDRIPriv = (I830DRIPtr)sPriv->pDevPriv;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+ if (glx_enable_extension == NULL) {
+ return GL_FALSE;
+ }
+
/* Allocate the private area */
intelScreen = (intelScreenPrivate *)CALLOC(sizeof(intelScreenPrivate));
if (!intelScreen) {
}
}
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
-
- if (glx_enable_extension != NULL) {
- (*glx_enable_extension)( psc, "GLX_SGI_make_current_read" );
-
- if ( driCompareGLXAPIVersion( 20030915 ) >= 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGIX_fbconfig" );
- (*glx_enable_extension)( psc, "GLX_OML_swap_method" );
- }
-
- if ( driCompareGLXAPIVersion( 20030818 ) >= 0 ) {
- sPriv->psc->allocateMemory = (void *) intelAllocateMemoryMESA;
- sPriv->psc->freeMemory = (void *) intelFreeMemoryMESA;
- sPriv->psc->memoryOffset = (void *) intelGetMemoryOffsetMESA;
+ (*glx_enable_extension)( psc, "GLX_SGI_make_current_read" );
+
+ sPriv->psc->allocateMemory = (void *) intelAllocateMemoryMESA;
+ sPriv->psc->freeMemory = (void *) intelFreeMemoryMESA;
+ sPriv->psc->memoryOffset = (void *) intelGetMemoryOffsetMESA;
- (*glx_enable_extension)( psc, "GLX_MESA_allocate_memory" );
- }
- }
- }
+ (*glx_enable_extension)( psc, "GLX_MESA_allocate_memory" );
return GL_TRUE;
}
.SwapBuffersMSC = NULL
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &intelAPI);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
intelFillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return modes;
}
-#endif /* USE_NEW_INTERFACE */
/**
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
static const GLuint __driNConfigOptions = 2;
#endif
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes * fill_in_modes( __GLcontextModes * modes,
unsigned pixel_bits,
unsigned depth_bits,
return modes;
}
-#endif /* USE_NEW_INTERFACE */
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
mach64FillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return modes;
}
-#endif /* USE_NEW_INTERFACE */
/* Create the device specific screen private data struct.
{
mach64ScreenPtr mach64Screen;
ATIDRIPtr serverInfo = (ATIDRIPtr)sPriv->pDevPriv;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+
if ( MACH64_DEBUG & DEBUG_VERBOSE_DRI )
fprintf( stderr, "%s\n", __FUNCTION__ );
+ if ( glx_enable_extension == NULL ) {
+ return NULL;
+ }
+
/* Allocate the private area */
mach64Screen = (mach64ScreenPtr) CALLOC( sizeof(*mach64Screen) );
if ( !mach64Screen ) return NULL;
}
mach64Screen->driScreen = sPriv;
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
-
- if ( glx_enable_extension != NULL ) {
- if ( mach64Screen->irq != 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
- (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
- (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
- }
-
- (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
- }
+
+ if ( mach64Screen->irq != 0 ) {
+ (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
+ (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
}
+
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
+
return mach64Screen;
}
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &mach64API);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
/**
* This is the bootstrap function for the driver. libGL supplies all of the
* requisite information about the system, and the driver initializes itself.
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
DRI_CONF_END;
static const GLuint __driNConfigOptions = 6;
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
#ifndef MGA_DEBUG
int MGA_DEBUG = 0;
static int getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
mgaFillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return modes;
}
-#endif /* USE_NEW_INTERFACE */
static GLboolean
{
mgaScreenPrivate *mgaScreen;
MGADRIPtr serverInfo = (MGADRIPtr)sPriv->pDevPriv;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+ if ( glx_enable_extension == NULL ) {
+ return GL_FALSE;
+ }
+
/* Allocate the private area */
mgaScreen = (mgaScreenPrivate *)MALLOC(sizeof(mgaScreenPrivate));
if (!mgaScreen) {
}
}
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
-
- if ( glx_enable_extension != NULL ) {
- (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
- (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
- (*glx_enable_extension)( psc, "GLX_SGI_make_current_read" );
- (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
- (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
-
- if ( driCompareGLXAPIVersion( 20030915 ) >= 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGIX_fbconfig" );
- (*glx_enable_extension)( psc, "GLX_OML_swap_method" );
- }
- }
- }
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
+ (*glx_enable_extension)( psc, "GLX_SGI_make_current_read" );
+ (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
+ (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
if (serverInfo->chipset != MGA_CARD_TYPE_G200 &&
serverInfo->chipset != MGA_CARD_TYPE_G400) {
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &mgaAPI);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
-
/**
* This is the bootstrap function for the driver. libGL supplies all of the
* requisite information about the system, and the driver initializes itself.
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
/**
#define PCI_CHIP_RAGE128RL 0x524C
#endif
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
/* Create the device specific screen private data struct.
*/
{
r128ScreenPtr r128Screen;
R128DRIPtr r128DRIPriv = (R128DRIPtr)sPriv->pDevPriv;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+ if ( glx_enable_extension == NULL ) {
+ return NULL;
+ }
+
/* Allocate the private area */
r128Screen = (r128ScreenPtr) CALLOC( sizeof(*r128Screen) );
if ( !r128Screen ) return NULL;
}
r128Screen->driScreen = sPriv;
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
-
- if ( glx_enable_extension != NULL ) {
- if ( r128Screen->irq != 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
- (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
- (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
- }
-
- (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
- }
+
+ if ( r128Screen->irq != 0 ) {
+ (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
+ (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
}
+
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
+
return r128Screen;
}
};
-#ifndef DRI_NEW_INTERFACE_ONLY
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &r128API);
- return (void *) psp;
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
r128FillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
* failure.
*/
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
#endif
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
static r200ScreenPtr __r200Screen;
static int getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
r200FillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return modes;
}
-#endif /* USE_NEW_INTERFACE */
/* Create the device specific screen private data struct.
r200ScreenPtr screen;
RADEONDRIPtr dri_priv = (RADEONDRIPtr)sPriv->pDevPriv;
unsigned char *RADEONMMIO;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+ if ( glx_enable_extension == NULL ) {
+ return NULL;
+ }
+
/* Allocate the private area */
screen = (r200ScreenPtr) CALLOC( sizeof(*screen) );
if ( !screen ) {
screen->driScreen = sPriv;
screen->sarea_priv_offset = dri_priv->sarea_priv_offset;
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
+ if ( screen->irq != 0 ) {
+ (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
+ (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
+ }
- if ( glx_enable_extension != NULL ) {
- if ( screen->irq != 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
- (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
- (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
- }
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
- (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
+ sPriv->psc->allocateMemory = (void *) r200AllocateMemoryMESA;
+ sPriv->psc->freeMemory = (void *) r200FreeMemoryMESA;
+ sPriv->psc->memoryOffset = (void *) r200GetMemoryOffsetMESA;
- if ( driCompareGLXAPIVersion( 20030818 ) >= 0 ) {
- sPriv->psc->allocateMemory = (void *) r200AllocateMemoryMESA;
- sPriv->psc->freeMemory = (void *) r200FreeMemoryMESA;
- sPriv->psc->memoryOffset = (void *) r200GetMemoryOffsetMESA;
+ (*glx_enable_extension)( psc, "GLX_MESA_allocate_memory" );
- (*glx_enable_extension)( psc, "GLX_MESA_allocate_memory" );
- }
-
- if ( driCompareGLXAPIVersion( 20030915 ) >= 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGIX_fbconfig" );
- (*glx_enable_extension)( psc, "GLX_OML_swap_method" );
- }
- }
- }
return screen;
}
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- *
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &r200API);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
-
/**
* This is the bootstrap function for the driver. libGL supplies all of the
* requisite information about the system, and the driver initializes itself.
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
/**
#define PCI_CHIP_R420_JK 0x4a4b
#endif
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
static radeonScreenPtr __radeonScreen;
static int getSwapInfo(__DRIdrawablePrivate * dPriv, __DRIswapInfo * sInfo);
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *radeonFillInModes(unsigned pixel_bits,
unsigned depth_bits,
unsigned stencil_bits,
return modes;
}
-#endif /* USE_NEW_INTERFACE */
+
/* Create the device specific screen private data struct.
*/
radeonScreenPtr screen;
RADEONDRIPtr dri_priv = (RADEONDRIPtr) sPriv->pDevPriv;
unsigned char *RADEONMMIO;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC)
+ glXGetProcAddress((const GLubyte *) "__glXScrEnableExtension");
+ void *const psc = sPriv->psc->screenConfigs;
+
+
+ if (glx_enable_extension == NULL) {
+ return NULL;
+ }
/* Allocate the private area */
screen = (radeonScreenPtr) CALLOC(sizeof(*screen));
screen->driScreen = sPriv;
screen->sarea_priv_offset = dri_priv->sarea_priv_offset;
- if (driCompareGLXAPIVersion(20030813) >= 0) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC)
- glXGetProcAddress((const GLubyte *)
- "__glXScrEnableExtension");
- void *const psc = sPriv->psc->screenConfigs;
-
- if (glx_enable_extension != NULL) {
- if (screen->irq != 0) {
- (*glx_enable_extension) (psc,
- "GLX_SGI_swap_control");
- (*glx_enable_extension) (psc,
- "GLX_SGI_video_sync");
- (*glx_enable_extension) (psc,
- "GLX_MESA_swap_control");
- }
+ if (screen->irq != 0) {
+ (*glx_enable_extension) (psc, "GLX_SGI_swap_control");
+ (*glx_enable_extension) (psc, "GLX_SGI_video_sync");
+ (*glx_enable_extension) (psc, "GLX_MESA_swap_control");
+ }
- (*glx_enable_extension) (psc,
- "GLX_MESA_swap_frame_usage");
+ (*glx_enable_extension) (psc, "GLX_MESA_swap_frame_usage");
#if R200_MERGED
- if (driCompareGLXAPIVersion(20030818) >= 0) {
- sPriv->psc->allocateMemory =
- (void *)r200AllocateMemoryMESA;
- sPriv->psc->freeMemory =
- (void *)r200FreeMemoryMESA;
- sPriv->psc->memoryOffset =
- (void *)r200GetMemoryOffsetMESA;
-
- (*glx_enable_extension) (psc,
- "GLX_MESA_allocate_memory");
- }
+ sPriv->psc->allocateMemory = (void *)r200AllocateMemoryMESA;
+ sPriv->psc->freeMemory = (void *)r200FreeMemoryMESA;
+ sPriv->psc->memoryOffset = (void *)r200GetMemoryOffsetMESA;
+
+ (*glx_enable_extension) (psc, "GLX_MESA_allocate_memory");
#endif
- if (driCompareGLXAPIVersion(20030915) >= 0) {
- (*glx_enable_extension) (psc,
- "GLX_SGIX_fbconfig");
- (*glx_enable_extension) (psc,
- "GLX_OML_swap_method");
- }
- }
- }
return screen;
}
.SwapBuffersMSC = NULL
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- *
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display * dpy, int scrn, __DRIscreen * psc,
- int numConfigs, __GLXvisualConfig * config)
-{
- __DRIscreenPrivate *psp;
- psp =
- __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &radeonAPI);
- return (void *)psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
/**
* This is the bootstrap function for the driver. libGL supplies all of the
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
-void *__driCreateNewScreen(__DRInativeDisplay * dpy, int scrn,
+void *__driCreateNewScreen_20050722(__DRInativeDisplay * dpy, int scrn,
__DRIscreen * psc, const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *)psp;
}
-#endif /* USE_NEW_INTERFACE */
+
/**
* Get information about previous buffer swaps.
#define PCI_CHIP_RS250_4437 0x4437
#endif
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
static int getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
radeonFillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
return modes;
}
-#endif /* USE_NEW_INTERFACE */
+
/* Create the device specific screen private data struct.
*/
radeonScreenPtr screen;
RADEONDRIPtr dri_priv = (RADEONDRIPtr)sPriv->pDevPriv;
unsigned char *RADEONMMIO;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+ if ( glx_enable_extension == NULL ) {
+ return NULL;
+ }
+
/* Allocate the private area */
screen = (radeonScreenPtr) CALLOC( sizeof(*screen) );
if ( !screen ) {
dri_priv->log2GARTTexGran;
}
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
-
- if ( glx_enable_extension != NULL ) {
- if ( screen->irq != 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
- (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
- (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
- }
-
- (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
-
- if ( driCompareGLXAPIVersion( 20030915 ) >= 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGIX_fbconfig" );
- (*glx_enable_extension)( psc, "GLX_OML_swap_method" );
- }
-
- }
+ if ( screen->irq != 0 ) {
+ (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
+ (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
}
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
+
screen->driScreen = sPriv;
screen->sarea_priv_offset = dri_priv->sarea_priv_offset;
return screen;
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &radeonAPI);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
/**
* This is the bootstrap function for the driver. libGL supplies all of the
* requisite information about the system, and the driver initializes itself.
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
+
/**
* Get information about previous buffer swaps.
return (void *) psp;
}
#endif
-
-void __driRegisterExtensions(void)
-{
- /* No extensions */
-}
DRI_CONF_END;
static const GLuint __driNConfigOptions = 10;
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
static const struct dri_debug_control debug_control[] =
{
};
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/*
- * This is the (old) bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &savageAPI);
- return (void *) psp;
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-
-
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
savageFillInModes( unsigned pixel_bits, unsigned depth_bits,
unsigned stencil_bits, GLboolean have_back_buffer )
* failure.
*/
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
DRI_CONF_END;
static const GLuint __driNConfigOptions = 2;
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
sisFillInModes(int bpp)
{
return modes;
}
-#endif /* USE_NEW_INTERFACE */
+
/* Create the device specific screen private data struct.
*/
sisScreenPtr sisScreen;
SISDRIPtr sisDRIPriv = (SISDRIPtr)sPriv->pDevPriv;
-#ifndef USE_NEW_INTERFACE
- /* XXX Should this still be around for the old interface? */
- if ( !driCheckDriDdxDrmVersions( sPriv, "SiS", 4, 0, 0, 1, 1, 0 ) )
- return NULL;
-#endif
/* Allocate the private area */
sisScreen = (sisScreenPtr)CALLOC( sizeof(*sisScreen) );
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &sisAPI);
- return (void *)psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
/**
* This is the bootstrap function for the driver. libGL supplies all of the
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn,
__DRIscreen *psc,
const __GLcontextModes *modes,
const __DRIversion *ddx_version,
return (void *)psp;
}
-#endif /* USE_NEW_INTERFACE */
.SwapBuffersMSC = NULL
};
-#ifdef USE_NEW_INTERFACE
-/*
- * new interface code, derived from radeon_screen.c
- * XXX this may still be wrong
- */
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
static __GLcontextModes *tdfxFillInModes(unsigned pixel_bits,
* failure.
*/
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
return (void *)psp;
}
-#endif /* USE_NEW_INTERFACE */
-
-
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &tdfxAPI);
- return (void *) psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
tridentUnbindContext,
};
-#ifndef USE_NEW_INTERFACE
-#error trident_dri.so is new-interface only.
-#else
-
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-PUBLIC void *__driCreateNewScreen( __DRInativeDisplay *dpy, int scrn,
+PUBLIC void *__driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn,
__DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
}
return (void *) psp;
}
-
-#endif
-
-void __driRegisterExtensions(void)
-{
- /* No extensions */
-}
static const GLuint __driNConfigOptions = 3;
-#ifdef USE_NEW_INTERFACE
static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /* USE_NEW_INTERFACE */
static int getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
{
viaScreenPrivate *viaScreen;
VIADRIPtr gDRIPriv = (VIADRIPtr)sPriv->pDevPriv;
+ PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
+ (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress(
+ (const GLubyte *) "__glXScrEnableExtension" );
+ void * const psc = sPriv->psc->screenConfigs;
+
+
+ if ( glx_enable_extension == NULL ) {
+ return GL_FALSE;
+ }
/* Allocate the private area */
viaScreen->sareaPrivOffset = gDRIPriv->sarea_priv_offset;
+ if ( viaScreen->irqEnabled ) {
+ (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
+ (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
+ }
-
- if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
- PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
- (PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress(
- (const GLubyte *) "__glXScrEnableExtension" );
- void * const psc = sPriv->psc->screenConfigs;
-
- if ( glx_enable_extension != NULL ) {
- if ( viaScreen->irqEnabled ) {
- (*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
- (*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
- (*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
- }
-
- (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
-
- if ( driCompareGLXAPIVersion( 20030915 ) >= 0 ) {
- (*glx_enable_extension)( psc, "GLX_SGIX_fbconfig" );
- (*glx_enable_extension)( psc, "GLX_OML_swap_method" );
- }
-
- }
- }
+ (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
return GL_TRUE;
}
};
-/*
- * This is the bootstrap function for the driver.
- * The __driCreateScreen name is the symbol that libGL.so fetches.
- * Return: pointer to a __DRIscreenPrivate.
- */
-#if !defined(DRI_NEW_INTERFACE_ONLY)
-void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *config)
-{
- __DRIscreenPrivate *psp;
- psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &viaAPI);
- return (void *)psp;
-}
-#endif /* !defined(DRI_NEW_INTERFACE_ONLY) */
-
-
-#ifdef USE_NEW_INTERFACE
static __GLcontextModes *
viaFillInModes( unsigned pixel_bits, GLboolean have_back_buffer )
{
return modes;
}
-#endif /* USE_NEW_INTERFACE */
/**
* \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
* failure.
*/
-#ifdef USE_NEW_INTERFACE
PUBLIC
-void * __driCreateNewScreen( __DRInativeDisplay *dpy, int scrn,
+void * __driCreateNewScreen_20050722( __DRInativeDisplay *dpy, int scrn,
__DRIscreen *psc,
const __GLcontextModes * modes,
const __DRIversion * ddx_version,
fprintf(stderr, "%s - succeeded\n", __FUNCTION__);
return (void *) psp;
}
-#endif /* USE_NEW_INTERFACE */
/**
extern void _mesa_test_os_sse_exception_support( void );
#if defined(__linux__) && defined(_POSIX_SOURCE) && defined(X86_FXSR_MAGIC) \
- && !defined(DRI_NEW_INTERFACE_ONLY)
+ && !defined(IN_DRI_DRIVER)
static void sigill_handler( int signal, struct sigcontext sc )
{
message( "SIGILL, " );
*/
static void check_os_sse_support( void )
{
-#if defined(__linux__) && !defined(DRI_NEW_INTERFACE_ONLY)
+#if defined(__linux__) && !defined(IN_DRI_DRIVER)
#if defined(_POSIX_SOURCE) && defined(X86_FXSR_MAGIC)
struct sigaction saved_sigill;
struct sigaction saved_sigfpe;
projects / mesa.git / commitdiff