From 90ee7a41443a971d6ff2e0a6e90997806c28d11b Mon Sep 17 00:00:00 2001
From: Keith Whitwell <keith@tungstengraphics.com>
Date: Tue, 7 Aug 2007 10:18:04 +0100
Subject: Gutsy oopses on touch of existing file. Workaround.

---
 src/egl/drivers/dri/Makefile | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index cb11971c64..fa3720a16b 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -52,6 +52,7 @@ clean:
 
 depend: $(SOURCES) $(HEADERS)
 	@ echo "running $(MKDEP)"
+	@ rm -f depend
 	@ touch depend
 	$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDE_DIRS) \
 		$(SOURCES) $(HEADERS) > /dev/null 
-- 
cgit v1.2.3


From fcce6c068cf53fd394a2c82080338860dae8777b Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Tue, 27 May 2008 13:47:44 -0600
Subject: s/GLuint/unsigned/

---
 src/egl/drivers/demo/demo.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index 45545755c0..0a13de6d87 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -21,7 +21,7 @@
 typedef struct demo_driver
 {
    _EGLDriver Base;  /* base class/object */
-   GLuint DemoStuff;
+   unsigned DemoStuff;
 } DemoDriver;
 
 #define DEMO_DRIVER(D) ((DemoDriver *) (D))
@@ -33,7 +33,7 @@ typedef struct demo_driver
 typedef struct demo_surface
 {
    _EGLSurface Base;  /* base class/object */
-   GLuint DemoStuff;
+   unsigned DemoStuff;
 } DemoSurface;
 
 
@@ -43,7 +43,7 @@ typedef struct demo_surface
 typedef struct demo_context
 {
    _EGLContext Base;  /* base class/object */
-   GLuint DemoStuff;
+   unsigned DemoStuff;
 } DemoContext;
 
 
-- 
cgit v1.2.3


From 07e92b174214e6bdaa22eecc0ed87cf1dbc8fc10 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Tue, 27 May 2008 16:49:11 -0600
Subject: misc updates, clean-ups, remove dependency on mtypes.h

---
 src/egl/drivers/dri/Makefile |  2 +-
 src/egl/drivers/dri/egldri.c | 28 +++++++++++++++++-----------
 src/egl/drivers/dri/egldri.h |  8 +++++---
 3 files changed, 23 insertions(+), 15 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index fa3720a16b..13aacd4389 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -55,7 +55,7 @@ depend: $(SOURCES) $(HEADERS)
 	@ rm -f depend
 	@ touch depend
 	$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDE_DIRS) \
-		$(SOURCES) $(HEADERS) > /dev/null 
+		$(SOURCES) $(HEADERS) >/dev/null 2>/dev/null
 
 include depend
 # DO NOT DELETE
diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index cab0be2bd1..81c12b7ca6 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -32,7 +32,7 @@
 #include "egldri.h"
 
 const char *sysfs = "/sys/class";
-#define None 0
+
 static const int empty_attribute_list[1] = { None };
 
 
@@ -62,10 +62,11 @@ _eglMain(_EGLDisplay *dpy)
 
       if (strncmp(&dirent->d_name[0], "card", 4) != 0)
          continue;
-      if (strcmp(&dirent->d_name[4], &dpy->Name[1]) != 0)
+      if (strcmp(&dirent->d_name[4], &dpy->DriverName[1]) != 0)
          continue;
 
-      snprintf(path, sizeof(path), "%s/drm/card%s/dri_library_name", sysfs, &dpy->Name[1]);
+      snprintf(path, sizeof(path), "%s/drm/card%s/dri_library_name",
+               sysfs, &dpy->DriverName[1]);
       _eglLog(_EGL_INFO, "Opening %s", path);
 #if 1
       file = fopen(path, "r");
@@ -141,7 +142,7 @@ _eglDRICreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    /* generate handle and insert into hash table */
    _eglSaveContext(&c->Base);
 
-   return c->Base.Handle;
+   return _eglGetContextHandle(&c->Base);
 }
 
 
@@ -152,13 +153,15 @@ _eglDRIMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw,
    driDisplay *disp = Lookup_driDisplay(dpy);
    driContext *ctx = Lookup_driContext(context);
    EGLBoolean b;
+   __DRIid drawBuf = (__DRIid) draw;
+   __DRIid readBuf = (__DRIid) read;
 
    b = _eglMakeCurrent(drv, dpy, draw, read, context);
    if (!b)
       return EGL_FALSE;
 
    if (ctx) {
-      ctx->driContext.bindContext(disp, 0, read, draw, &ctx->driContext);
+      ctx->driContext.bindContext(disp, 0, drawBuf, readBuf, &ctx->driContext);
    }
    else {
       /* what's this??? */
@@ -190,7 +193,7 @@ _eglDRICreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 #if 0
       GLcontext *ctx = NULL; /* this _should_ be OK */
 #endif
-      GLvisual visMode;
+      __GLcontextModes visMode;
       _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
       assert(conf); /* bad config should be caught earlier */
       _eglConfigToContextModesRec(conf, &visMode);
@@ -267,7 +270,8 @@ _eglDRICreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg,
    _EGLConfig *config = _eglLookupConfig(drv, dpy, cfg);
    driDisplay *disp = Lookup_driDisplay(dpy);
    driSurface *surface;
-   GLvisual visMode;
+   __GLcontextModes visMode;
+   __DRIid drawBuf;
 
    surface = (driSurface *) calloc(1, sizeof(*surface));
    if (!surface) {
@@ -292,8 +296,10 @@ _eglDRICreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg,
    /* convert EGLConfig to GLvisual */
    _eglConfigToContextModesRec(config, &visMode);
 
+   drawBuf = (__DRIid) _eglGetSurfaceHandle(&surface->Base);
+
    /* Create a new DRI drawable */
-   if (!disp->driScreen.createNewDrawable(disp, &visMode, surface->Base.Handle,
+   if (!disp->driScreen.createNewDrawable(disp, &visMode, drawBuf,
                                           &surface->drawable, GLX_WINDOW_BIT,
                                           empty_attribute_list)) {
       _eglRemoveSurface(&surface->Base);
@@ -715,7 +721,7 @@ __eglGetDrawableInfo(__DRInativeDisplay * ndpy, int screen, __DRIid drawable,
 {
     __DRIscreen *pDRIScreen;
     __DRIscreenPrivate *psp;
-   driSurface *surf = Lookup_driSurface(drawable);
+    driSurface *surf = Lookup_driSurface((EGLSurface) drawable);
 
    pDRIScreen = __eglFindDRIScreen(ndpy, screen);
 
@@ -1088,13 +1094,13 @@ _eglDRIInitialize(_EGLDriver *drv, EGLDisplay dpy,
     */
    display = calloc(1, sizeof(*display));
    display->Base = *disp;
-   _eglHashInsert(_eglGlobal.Displays, disp->Handle, display);
+   _eglSaveDisplay(&display->Base);
    free(disp);
 
    *major = 1;
    *minor = 0;
 
-   sscanf(&disp->Name[1], "%d", &display->minor);
+   sscanf(&disp->DriverName[1], "%d", &display->minor);
 
    drv->Initialized = EGL_TRUE;
    return EGL_TRUE;
diff --git a/src/egl/drivers/dri/egldri.h b/src/egl/drivers/dri/egldri.h
index 34b12d64fc..49e1cf4d99 100644
--- a/src/egl/drivers/dri/egldri.h
+++ b/src/egl/drivers/dri/egldri.h
@@ -1,11 +1,13 @@
 #ifndef EGLDRI_INCLUDED
 #define EGLDRI_INCLUDED
 
+#include <stdlib.h>
+#include <string.h>
 #include "egldisplay.h"
 #include "eglscreen.h"
 #include "eglsurface.h"
 #include "eglcontext.h"
-#include "mtypes.h"
+
 #include "dri_util.h"
 #include "drm_sarea.h"
 
@@ -14,7 +16,7 @@
  */
 typedef struct dri_display
 {
-   _EGLDisplay Base;  /* base class/object */
+   _EGLDisplay Base;  /**< base class */
    void *pFB;
    int drmFD;  /**< \brief DRM device file descriptor */
    int minor;
@@ -32,7 +34,7 @@ typedef struct dri_display
    unsigned long FBStart;   /**< \brief physical address of the framebuffer */
    void *driverClientMsg;
    int driverClientMsgSize;
-   int chipset;
+   unsigned chipset;
    void *driverPrivate;
    drm_magic_t magic;
 
-- 
cgit v1.2.3


From 96a40345bb3b7c87d9742d0b5683355f42596823 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Tue, 27 May 2008 16:58:23 -0600
Subject: include eglconfigutil.h

---
 src/egl/drivers/dri/egldri.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index 81c12b7ca6..79a2eda3ae 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -23,6 +23,7 @@
 #include "egldisplay.h"
 #include "eglcontext.h"
 #include "eglconfig.h"
+#include "eglconfigutil.h"
 #include "eglsurface.h"
 #include "eglscreen.h"
 #include "eglglobals.h"
-- 
cgit v1.2.3


From 003afbe5bdb3d3c45e0f4f06d0b4239237df934c Mon Sep 17 00:00:00 2001
From: Jakob Bornecrantz <jakob@tungstengraphics.com>
Date: Wed, 28 May 2008 11:32:18 +0200
Subject: egl: Make demo driver compile

---
 src/egl/drivers/demo/demo.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index 0a13de6d87..1033f1b4ed 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -152,9 +152,9 @@ demoCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext
 
    /* generate handle and insert into hash table */
    _eglSaveContext(&c->Base);
-   assert(c->Base.Handle);
+   assert(_eglGetContextHandle(&c->Base));
 
-   return c->Base.Handle;
+   return _eglGetContextHandle(&c->Base);
 }
 
 
-- 
cgit v1.2.3


From 68ff873c20a6e32eef0fa4c6d259a5a415308be5 Mon Sep 17 00:00:00 2001
From: Jakob Bornecrantz <jakob@tungstengraphics.com>
Date: Wed, 28 May 2008 11:33:52 +0200
Subject: egl: Make dri driver compile

---
 src/egl/drivers/dri/egldri.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/egldri.h b/src/egl/drivers/dri/egldri.h
index 49e1cf4d99..54a9a4ea26 100644
--- a/src/egl/drivers/dri/egldri.h
+++ b/src/egl/drivers/dri/egldri.h
@@ -3,6 +3,7 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <stdint.h>
 #include "egldisplay.h"
 #include "eglscreen.h"
 #include "eglsurface.h"
-- 
cgit v1.2.3


From aa4ca9119d1dbaf542cf5971f845b434ef008aa0 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 28 May 2008 11:44:47 -0600
Subject: link libEGLdri.so with libdrm

---
 src/egl/drivers/dri/Makefile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index 13aacd4389..bdc683a0c1 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -29,6 +29,8 @@ SOURCES = egldri.c
 
 OBJECTS = $(SOURCES:.c=.o)
 
+DRM_LIB = `pkg-config --libs libdrm`
+
 
 .c.o:
 	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
@@ -43,7 +45,7 @@ library: $(TOP)/$(LIB_DIR)/libEGLdri.so
 
 $(TOP)/$(LIB_DIR)/libEGLdri.so: $(OBJECTS)
 	$(TOP)/bin/mklib -o EGLdri -major 1 -minor 0 \
-		-install $(TOP)/$(LIB_DIR) -ldl $(OBJECTS)
+		-install $(TOP)/$(LIB_DIR) -ldl $(OBJECTS) $(DRM_LIB)
 
 
 clean:
-- 
cgit v1.2.3


From 17ec3b3cc5100deb6ef96977d87b2a7f05814f72 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 28 May 2008 11:45:50 -0600
Subject: prototype new code to map card number to driver name

---
 src/egl/drivers/dri/egldri.c | 66 +++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 62 insertions(+), 4 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index 79a2eda3ae..f00625a059 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -1,5 +1,6 @@
 /**
- * Generic EGL driver for DRI.
+ * Generic EGL driver for DRI.  This is basically an "adaptor" driver
+ * that allows libEGL to load/use regular DRI drivers.
  *
  * This file contains all the code needed to interface DRI-based drivers
  * with libEGL.
@@ -37,6 +38,41 @@ const char *sysfs = "/sys/class";
 static const int empty_attribute_list[1] = { None };
 
 
+
+/**
+ * Given a card number, return the name of the DRI driver to use.
+ * This generally means reading the contents of
+ * /sys/class/drm/cardX/dri_library_name, where X is the card number
+ */
+static EGLBoolean
+driver_name_from_card_number(int card, char *driverName, int maxDriverName)
+{
+   char path[2000];
+   FILE *f;
+   int length;
+
+   snprintf(path, sizeof(path), "%s/drm/card%d/dri_library_name", sysfs, card);
+
+   f = fopen(path, "r");
+   if (!f)
+      return EGL_FALSE;
+
+   fgets(driverName, maxDriverName, f);
+   fclose(f);
+
+   if ((length = strlen(driverName)) > 1) {
+      /* remove the trailing newline from sysfs */
+      driverName[length - 1] = '\0';
+      strncat(driverName, "_dri", maxDriverName);
+      return EGL_TRUE;
+   }
+   else {
+      return EGL_FALSE;
+   }   
+}
+
+
+
 /**
  * The bootstrap function.
  * Return a new driDriver object and plug in API functions.
@@ -45,6 +81,26 @@ static const int empty_attribute_list[1] = { None };
 _EGLDriver *
 _eglMain(_EGLDisplay *dpy)
 {
+#if 1
+   const char *displayString = (const char *) dpy->NativeDisplay;
+   const int card = atoi(displayString + 1);
+   _EGLDriver *driver = NULL;
+   char driverName[1000];
+
+   if (!driver_name_from_card_number(card, driverName, sizeof(driverName))) {
+      _eglLog(_EGL_WARNING,
+              "Unable to determine driver name for card %d\n", card);
+      return NULL;
+   }
+
+   _eglLog(_EGL_DEBUG, "Driver name: %s\n", driverName);
+
+   driver = _eglOpenDriver(dpy, driverName);
+
+   return driver;
+
+#else
+
    int length;
    char path[NAME_MAX];
    struct dirent *dirent;
@@ -63,11 +119,11 @@ _eglMain(_EGLDisplay *dpy)
 
       if (strncmp(&dirent->d_name[0], "card", 4) != 0)
          continue;
-      if (strcmp(&dirent->d_name[4], &dpy->DriverName[1]) != 0)
+      if (strcmp(&dirent->d_name[4], &driverName[1]) != 0)
          continue;
 
       snprintf(path, sizeof(path), "%s/drm/card%s/dri_library_name",
-               sysfs, &dpy->DriverName[1]);
+               sysfs, &driverName[1]);
       _eglLog(_EGL_INFO, "Opening %s", path);
 #if 1
       file = fopen(path, "r");
@@ -91,6 +147,7 @@ _eglMain(_EGLDisplay *dpy)
    closedir(dir);
 
    return driver;
+#endif
 }
 
 
@@ -1087,6 +1144,7 @@ _eglDRIInitialize(_EGLDriver *drv, EGLDisplay dpy,
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    driDisplay *display;
+   const char *driverName = (const char *) disp->NativeDisplay;
 
    assert(disp);
 
@@ -1101,7 +1159,7 @@ _eglDRIInitialize(_EGLDriver *drv, EGLDisplay dpy,
    *major = 1;
    *minor = 0;
 
-   sscanf(&disp->DriverName[1], "%d", &display->minor);
+   sscanf(driverName + 1, "%d", &display->minor);
 
    drv->Initialized = EGL_TRUE;
    return EGL_TRUE;
-- 
cgit v1.2.3


From 0c8908c411c434eda318b41b4f2a370a1e794831 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 28 May 2008 12:56:36 -0600
Subject: egl: added args string to _eglMain()

---
 src/egl/drivers/demo/demo.c  |  2 +-
 src/egl/drivers/dri/egldri.c |  4 ++--
 src/egl/main/eglapi.c        |  4 +++-
 src/egl/main/egldisplay.c    | 19 ++++---------------
 src/egl/main/egldisplay.h    |  1 +
 src/egl/main/egldriver.c     | 35 +++++++++++++++++++++++++----------
 src/egl/main/egldriver.h     |  4 ++--
 src/egl/main/egltypedefs.h   |  2 +-
 8 files changed, 39 insertions(+), 32 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index 1033f1b4ed..6b8b71d16b 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -286,7 +286,7 @@ demoMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface rea
  * plug in API functions.
  */
 _EGLDriver *
-_eglMain(_EGLDisplay *dpy)
+_eglMain(_EGLDisplay *dpy, const char *args)
 {
    DemoDriver *demo;
 
diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index f00625a059..677073fb3a 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -79,11 +79,11 @@ driver_name_from_card_number(int card, char *driverName, int maxDriverName)
  * This function, in turn, loads a specific DRI driver (ex: r200_dri.so).
  */
 _EGLDriver *
-_eglMain(_EGLDisplay *dpy)
+_eglMain(_EGLDisplay *dpy, const char *args)
 {
 #if 1
    const char *displayString = (const char *) dpy->NativeDisplay;
-   const int card = atoi(displayString + 1);
+   const int card = atoi(args);
    _EGLDriver *driver = NULL;
    char driverName[1000];
 
diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index fe63d36b80..984af4ea22 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -68,7 +68,9 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
       if (!dpyPriv) {
          return EGL_FALSE;
       }
-      dpyPriv->Driver = _eglOpenDriver(dpyPriv, dpyPriv->DriverName);
+      dpyPriv->Driver = _eglOpenDriver(dpyPriv,
+                                       dpyPriv->DriverName,
+                                       dpyPriv->DriverArgs);
       if (!dpyPriv->Driver) {
          return EGL_FALSE;
       }
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index 9c42194c61..b2d30d4274 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -11,25 +11,14 @@
 #include "egldriver.h"
 #include "eglglobals.h"
 #include "eglhash.h"
-
-
-static char *
-my_strdup(const char *s)
-{
-   if (s) {
-      int l = strlen(s);
-      char *s2 = malloc(l + 1);
-      if (s2)
-         strcpy(s2, s);
-      return s2;
-   }
-   return NULL;
-}
+#include "eglstring.h"
 
 
 /**
  * Allocate a new _EGLDisplay object for the given nativeDisplay handle.
  * We'll also try to determine the device driver name at this time.
+ *
+ * Note that nativeDisplay may be an X Display ptr, or a string.
  */
 _EGLDisplay *
 _eglNewDisplay(NativeDisplayType nativeDisplay)
@@ -46,7 +35,7 @@ _eglNewDisplay(NativeDisplayType nativeDisplay)
       dpy->Xdpy = (Display *) nativeDisplay;
 #endif
 
-      dpy->DriverName = my_strdup(_eglChooseDriver(dpy));
+      dpy->DriverName = _eglstrdup(_eglChooseDriver(dpy));
       if (!dpy->DriverName) {
          free(dpy);
          return NULL;
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index be134374ca..e2ebab0b21 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -14,6 +14,7 @@ struct _egl_display
    EGLDisplay Handle;
 
    const char *DriverName;
+   const char *DriverArgs;
    _EGLDriver *Driver;
 
    EGLint NumScreens;
diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c
index cbdd47948d..599077190a 100644
--- a/src/egl/main/egldriver.c
+++ b/src/egl/main/egldriver.c
@@ -6,6 +6,7 @@
 #include <assert.h>
 #include <dlfcn.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include "eglconfig.h"
 #include "eglcontext.h"
@@ -15,6 +16,7 @@
 #include "egllog.h"
 #include "eglmode.h"
 #include "eglscreen.h"
+#include "eglstring.h"
 #include "eglsurface.h"
 
 #if defined(_EGL_PLATFORM_X)
@@ -25,7 +27,7 @@
 /* XXX to do */
 #endif
 
-const char *DefaultDriverName = "demodriver";
+const char *DefaultDriverName = ":0";
 
 
 /**
@@ -44,23 +46,36 @@ const char *DefaultDriverName = "demodriver";
 const char *
 _eglChooseDriver(_EGLDisplay *dpy)
 {
-   const char *name = (const char *) dpy->NativeDisplay;
+   const char *displayString = (const char *) dpy->NativeDisplay;
    const char *driverName = NULL;
 
-   if (!dpy->NativeDisplay) {
+   if (!displayString) {
       /* choose a default */
-      driverName = DefaultDriverName;
+      displayString = DefaultDriverName;
    }
-   else if (name && name[0] == ':' &&
-            (name[1] >= '0' && name[1] <= '9') && !name[2]) {
+
+   /* extract default DriverArgs = whatever follows ':' */
+   if (displayString[0] == '!' ||
+       displayString[0] == ':') {
+      const char *args = strchr(displayString, ':');
+      if (args)
+         dpy->DriverArgs = _eglstrdup(args + 1);
+   }
+
+
+   if (displayString && displayString[0] == ':' &&
+       (displayString[1] >= '0' && displayString[1] <= '9') &&
+       !displayString[2]) {
       /* XXX probe hardware here to determine which driver to open */
       driverName = "libEGLdri";
    }
-   else if (name && name[0] == '!') {
+   else if (displayString && displayString[0] == '!') {
       /* use specified driver name */
-      driverName = name + 1;
+      driverName = displayString + 1;
    }
    else {
+      /* NativeDisplay is not a string! */
+
 #if defined(_EGL_PLATFORM_X)
       driverName = _xeglChooseDriver(dpy);
 #elif defined(_EGL_PLATFORM_WINDOWS)
@@ -83,7 +98,7 @@ _eglChooseDriver(_EGLDisplay *dpy)
  * \return  new _EGLDriver object.
  */
 _EGLDriver *
-_eglOpenDriver(_EGLDisplay *dpy, const char *driverName)
+_eglOpenDriver(_EGLDisplay *dpy, const char *driverName, const char *args)
 {
    _EGLDriver *drv;
    _EGLMain_t mainFunc;
@@ -110,7 +125,7 @@ _eglOpenDriver(_EGLDisplay *dpy, const char *driverName)
       return NULL;
    }
 
-   drv = mainFunc(dpy);
+   drv = mainFunc(dpy, args);
    if (!drv) {
       dlclose(lib);
       return NULL;
diff --git a/src/egl/main/egldriver.h b/src/egl/main/egldriver.h
index bde726e25e..9c505880b7 100644
--- a/src/egl/main/egldriver.h
+++ b/src/egl/main/egldriver.h
@@ -42,7 +42,7 @@ struct _egl_driver
 };
 
 
-extern _EGLDriver *_eglMain(_EGLDisplay *dpy);
+extern _EGLDriver *_eglMain(_EGLDisplay *dpy, const char *args);
 
 
 extern const char *
@@ -50,7 +50,7 @@ _eglChooseDriver(_EGLDisplay *dpy);
 
 
 extern _EGLDriver *
-_eglOpenDriver(_EGLDisplay *dpy, const char *DriverName);
+_eglOpenDriver(_EGLDisplay *dpy, const char *driverName, const char *args);
 
 
 extern EGLBoolean
diff --git a/src/egl/main/egltypedefs.h b/src/egl/main/egltypedefs.h
index 53810a5a44..b1c8ec1f02 100644
--- a/src/egl/main/egltypedefs.h
+++ b/src/egl/main/egltypedefs.h
@@ -30,7 +30,7 @@ typedef struct _egl_thread_info _EGLThreadInfo;
 
 typedef void (*_EGLProc)();
 
-typedef _EGLDriver *(*_EGLMain_t)(_EGLDisplay *dpy);
+typedef _EGLDriver *(*_EGLMain_t)(_EGLDisplay *dpy, const char *args);
 
 
 #endif /* EGLTYPEDEFS_INCLUDED */
-- 
cgit v1.2.3


From aa6e350bed8e6930bef761fb85ad524e5a4aa3a3 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 28 May 2008 13:03:59 -0600
Subject: egl: pass args to _eglOpenDriver()

---
 src/egl/drivers/dri/egldri.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index 677073fb3a..35b6d0d3d1 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -82,7 +82,6 @@ _EGLDriver *
 _eglMain(_EGLDisplay *dpy, const char *args)
 {
 #if 1
-   const char *displayString = (const char *) dpy->NativeDisplay;
    const int card = atoi(args);
    _EGLDriver *driver = NULL;
    char driverName[1000];
@@ -95,7 +94,7 @@ _eglMain(_EGLDisplay *dpy, const char *args)
 
    _eglLog(_EGL_DEBUG, "Driver name: %s\n", driverName);
 
-   driver = _eglOpenDriver(dpy, driverName);
+   driver = _eglOpenDriver(dpy, driverName, args);
 
    return driver;
 
-- 
cgit v1.2.3


From 31e70fa275a48b8020c14017919e08d21f5e982f Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 28 May 2008 10:40:25 -0600
Subject: comments in _eglMain()

---
 src/egl/drivers/dri/egldri.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index 35b6d0d3d1..1a922a7471 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -114,6 +114,10 @@ _eglMain(_EGLDisplay *dpy, const char *args)
       _eglLog(_EGL_WARNING, "%s DRM devices not found.", path);
       return EGL_FALSE;
    }
+
+   /* loop over dir entries looking for cardX where "X" is in the
+    * dpy->DriverName ":X" string.
+    */
    while ((dirent = readdir(dir))) {
 
       if (strncmp(&dirent->d_name[0], "card", 4) != 0)
-- 
cgit v1.2.3


From f6bb2f87b96bd05661020cf8e73e80f5ef25353a Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 4 Jun 2008 11:50:18 -0600
Subject: egl: minor tweaks

---
 src/egl/drivers/dri/egldri.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index 1a922a7471..57661cc3ab 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -82,7 +82,7 @@ _EGLDriver *
 _eglMain(_EGLDisplay *dpy, const char *args)
 {
 #if 1
-   const int card = atoi(args);
+   const int card = args ? atoi(args) : 0;
    _EGLDriver *driver = NULL;
    char driverName[1000];
 
@@ -1086,8 +1086,10 @@ _eglDRICreateDisplay(driDisplay *dpy, __DRIframebuffer *framebuffer)
                             api_ver,
                             & interface_methods,
                             NULL);
-   if (!dpy->driScreen.private)
+   if (!dpy->driScreen.private) {
+      _eglLog(_EGL_WARNING, "egldri.c: DRI create new screen failed");
       return EGL_FALSE;
+   }
 
    DRM_UNLOCK( dpy->drmFD, dpy->pSAREA, dpy->serverContext );
 
-- 
cgit v1.2.3


From d5cf57de2de9692e9dc194bea1bbf8abfd446770 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Thu, 5 Jun 2008 14:11:39 -0600
Subject: egl: new src/egl/drivers/Makefile

---
 src/egl/drivers/Makefile | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 src/egl/drivers/Makefile

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/Makefile b/src/egl/drivers/Makefile
new file mode 100644
index 0000000000..837626e3d6
--- /dev/null
+++ b/src/egl/drivers/Makefile
@@ -0,0 +1,42 @@
+# src/egl/drivers/Makefile
+
+TOP = ../../..
+
+SUBDIRS = demo dri
+
+
+default: conditional_subdirs
+
+
+# depending on $DRIVER_DIRS...
+conditional_subdirs:
+	@echo "DRIVER_DIRS = " $(DRIVER_DIRS)
+	@case "$$DRIVER_DIRS" in \
+	    dri)    $(MAKE) dri_subdir || exit 1 ;; \
+	    *)      ;; \
+	esac;
+
+
+dri_subdir:
+	(cd dri ; $(MAKE)) || exit 1 ; \
+
+
+demo_subdir:
+	(cd demo ; $(MAKE)) || exit 1 ; \
+
+
+
+subdirs:
+	@for dir in $(SUBDIRS) ; do \
+		if [ -d $$dir ] ; then \
+			(cd $$dir ; $(MAKE)) || exit 1 ; \
+		fi \
+	done
+
+
+clean:
+	@for dir in $(SUBDIRS) ; do \
+		if [ -d $$dir ] ; then \
+			(cd $$dir ; $(MAKE) clean) ; \
+		fi \
+	done
-- 
cgit v1.2.3


From 8dafe470fc29cada5f3beab114e2be19fd01dabe Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 6 Jun 2008 15:52:33 -0600
Subject: egl: EGL->DRI adaptor/driver

Allows regular DRI drivers to work with libEGL.
---
 src/egl/drivers/xdri/Makefile   |  67 ++++
 src/egl/drivers/xdri/egl_xdri.c | 833 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 900 insertions(+)
 create mode 100644 src/egl/drivers/xdri/Makefile
 create mode 100644 src/egl/drivers/xdri/egl_xdri.c

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
new file mode 100644
index 0000000000..477a75184a
--- /dev/null
+++ b/src/egl/drivers/xdri/Makefile
@@ -0,0 +1,67 @@
+# src/egl/drivers/xdri/Makefile
+
+# Build XEGL DRI driver loader library:  egl_xdri.so
+
+
+TOP = ../../../..
+include $(TOP)/configs/current
+
+
+DRIVER_NAME = egl_xdri.so
+
+
+INCLUDE_DIRS = \
+	-I. \
+	-I/usr/include \
+	-I/usr/include/drm \
+	-I$(TOP)/include \
+	-I$(TOP)/include/GL/internal \
+	-I$(TOP)/src/mesa/glapi \
+	-I$(TOP)/src/mesa/drivers/dri/common \
+	-I$(TOP)/src/egl/main \
+	-I$(TOP)/src/glx/x11
+
+SOURCES = egl_xdri.c
+
+OBJECTS = $(SOURCES:.c=.o)
+
+DRM_LIB = `pkg-config --libs libdrm`
+
+
+.c.o:
+	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
+
+
+.PHONY: library
+
+
+default: depend library Makefile
+
+
+library: $(TOP)/$(LIB_DIR)/$(DRIVER_NAME)
+
+
+# Make the egl_xdri.so library
+$(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
+	$(TOP)/bin/mklib -o $(DRIVER_NAME) \
+		-noprefix \
+		-major 1 -minor 0 \
+		-install $(TOP)/$(LIB_DIR) \
+		-ldl $(OBJECTS) $(DRM_LIB)
+
+
+clean:
+	rm -f *.o
+	rm -f *.so
+	rm -f depend depend.bak
+
+
+depend: $(SOURCES) $(HEADERS)
+	@ echo "running $(MKDEP)"
+	@ rm -f depend
+	@ touch depend
+	$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDE_DIRS) \
+		$(SOURCES) $(HEADERS) >/dev/null 2>/dev/null
+
+include depend
+# DO NOT DELETE
diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
new file mode 100644
index 0000000000..4c8511fbbf
--- /dev/null
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -0,0 +1,833 @@
+/**************************************************************************
+ * 
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ **************************************************************************/
+
+
+/**
+ * Code to interface a DRI driver to libEGL.
+ * Note that unlike previous DRI/EGL interfaces, this one is meant to
+ * be used _with_ X.  Applications will use eglCreateWindowSurface()
+ * to render into X-created windows.
+ *
+ * This is an EGL driver that, in turn, loads a regular DRI driver.
+ * There are some dependencies on code in libGL, but those coudl be
+ * removed with some effort.
+ *
+ * Authors: Brian Paul
+ */
+
+
+#include <assert.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "dlfcn.h"
+#include <X11/Xlib.h>
+#include <GL/gl.h>
+#include "xf86dri.h"
+#include "glxclient.h"
+#include "dri_util.h"
+#include "drm_sarea.h"
+
+#define _EGL_PLATFORM_X
+
+#include "eglconfig.h"
+#include "eglcontext.h"
+#include "egldisplay.h"
+#include "egldriver.h"
+#include "eglglobals.h"
+#include "eglhash.h"
+#include "egllog.h"
+#include "eglsurface.h"
+
+
+
+#define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
+
+
+/** subclass of _EGLDriver */
+struct xdri_egl_driver
+{
+   _EGLDriver Base;   /**< base class */
+
+   const char *dri_driver_name;  /**< name of DRI driver to load */
+   void *dri_driver_handle;      /**< returned by dlopen(dri_driver_name) */
+
+   int chipset;
+   int minor;
+   int drmFD;
+
+   __DRIscreen driScreen;
+   __DRIframebuffer framebuffer;
+   drm_handle_t hSAREA;
+   drmAddress pSAREA;
+   char *busID;
+   drm_magic_t magic;
+};
+
+
+/** subclass of _EGLContext */
+struct xdri_egl_context
+{
+   _EGLContext Base;   /**< base class */
+
+   __DRIcontext driContext;
+};
+
+
+/** subclass of _EGLSurface */
+struct xdri_egl_surface
+{
+   _EGLSurface Base;   /**< base class */
+
+   __DRIid driDrawable;  /**< DRI surface */
+   drm_drawable_t hDrawable;
+};
+
+
+/** subclass of _EGLConfig */
+struct xdri_egl_config
+{
+   _EGLConfig Base;   /**< base class */
+
+   const __GLcontextModes *mode;  /**< corresponding GLX mode */
+};
+
+
+/** cast wrapper */
+static struct xdri_egl_driver *
+xdri_egl_driver(_EGLDriver *drv)
+{
+   return (struct xdri_egl_driver *) drv;
+}
+
+
+/** Map EGLSurface handle to xdri_egl_surface object */
+static struct xdri_egl_surface *
+lookup_surface(EGLSurface surf)
+{
+   _EGLSurface *surface = _eglLookupSurface(surf);
+   return (struct xdri_egl_surface *) surface;
+}
+
+
+/** Map EGLContext handle to xdri_egl_context object */
+static struct xdri_egl_context *
+lookup_context(EGLContext c)
+{
+   _EGLContext *context = _eglLookupContext(c);
+   return (struct xdri_egl_context *) context;
+}
+
+
+/** Map EGLConfig handle to xdri_egl_config object */
+static struct xdri_egl_config *
+lookup_config(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config)
+{
+   _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
+   return (struct xdri_egl_config *) conf;
+}
+
+
+
+/**
+ * Produce a set of EGL configs.
+ * Note that we get the list of GLcontextModes from the GLX library.
+ * This dependency on GLX lib will be removed someday.
+ */
+static void
+create_configs(_EGLDisplay *disp)
+{
+   const __GLcontextModes *m;
+   __GLXdisplayPrivate *priv = __glXInitialize(disp->Xdpy);
+   __GLXscreenConfigs *scrn = priv->screenConfigs;
+   int id = 1;
+
+   for (m = scrn->configs; m; m = m->next) {
+      /* EGL requires double-buffered configs */
+      if (m->doubleBufferMode) {
+         struct xdri_egl_config *config = CALLOC_STRUCT(xdri_egl_config);
+
+         _eglInitConfig(&config->Base, id++);
+
+         SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, m->rgbBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, m->redBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_GREEN_SIZE, m->greenBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_BLUE_SIZE, m->blueBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_ALPHA_SIZE, m->alphaBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_DEPTH_SIZE, m->depthBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, m->stencilBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, m->visualID);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_TYPE, m->visualType);
+         /* XXX possibly other things to init... */
+
+         /* Ptr from EGL config to GLcontextMode.  Used in CreateContext(). */
+         config->mode = m;
+
+         _eglAddConfig(disp, &config->Base);
+      }
+   }
+}
+
+
+/**
+ * Called via __DRIinterfaceMethods object
+ */
+static __DRIfuncPtr
+dri_get_proc_address(const char * proc_name)
+{
+   return NULL;
+}
+
+
+static void
+dri_context_modes_destroy(__GLcontextModes *modes)
+{
+   _eglLog(_EGL_DEBUG, "%s", __FUNCTION__);
+
+   while (modes) {
+      __GLcontextModes * const next = modes->next;
+      free(modes);
+      modes = next;
+   }
+}
+
+
+/**
+ * Create a linked list of 'count' GLcontextModes.
+ * These are used during the client/server visual negotiation phase,
+ * then discarded.
+ */
+static __GLcontextModes *
+dri_context_modes_create(unsigned count, size_t minimum_size)
+{
+   /* This code copied from libGLX, and modified */
+   const size_t size = (minimum_size > sizeof(__GLcontextModes))
+       ? minimum_size : sizeof(__GLcontextModes);
+   __GLcontextModes * head = NULL;
+   __GLcontextModes ** next;
+   unsigned   i;
+
+   next = & head;
+   for (i = 0 ; i < count ; i++) {
+      *next = (__GLcontextModes *) calloc(1, size);
+      if (*next == NULL) {
+	 dri_context_modes_destroy(head);
+	 head = NULL;
+	 break;
+      }
+      
+      (*next)->doubleBufferMode = 1;
+      (*next)->visualID = GLX_DONT_CARE;
+      (*next)->visualType = GLX_DONT_CARE;
+      (*next)->visualRating = GLX_NONE;
+      (*next)->transparentPixel = GLX_NONE;
+      (*next)->transparentRed = GLX_DONT_CARE;
+      (*next)->transparentGreen = GLX_DONT_CARE;
+      (*next)->transparentBlue = GLX_DONT_CARE;
+      (*next)->transparentAlpha = GLX_DONT_CARE;
+      (*next)->transparentIndex = GLX_DONT_CARE;
+      (*next)->xRenderable = GLX_DONT_CARE;
+      (*next)->fbconfigID = GLX_DONT_CARE;
+      (*next)->swapMethod = GLX_SWAP_UNDEFINED_OML;
+      (*next)->bindToTextureRgb = GLX_DONT_CARE;
+      (*next)->bindToTextureRgba = GLX_DONT_CARE;
+      (*next)->bindToMipmapTexture = GLX_DONT_CARE;
+      (*next)->bindToTextureTargets = 0;
+      (*next)->yInverted = GLX_DONT_CARE;
+
+      next = & ((*next)->next);
+   }
+
+   return head;
+}
+
+
+static __DRIscreen *
+dri_find_dri_screen(__DRInativeDisplay *ndpy, int scrn)
+{
+   /* unused? */
+   return NULL;
+}
+
+
+static GLboolean
+dri_window_exists(__DRInativeDisplay *dpy, __DRIid draw)
+{
+   return EGL_TRUE;
+}
+
+
+static GLboolean
+dri_create_context(__DRInativeDisplay *dpy, int screenNum, int configID,
+                   void * contextID, drm_context_t * hw_context)
+{
+   assert(configID >= 0);
+   return XF86DRICreateContextWithConfig(dpy, screenNum,
+                                         configID, contextID, hw_context);
+}
+
+
+static GLboolean
+dri_destroy_context(__DRInativeDisplay * ndpy, int screen, __DRIid context)
+{
+   return XF86DRIDestroyContext(ndpy, screen, context);
+}
+
+
+static GLboolean
+dri_create_drawable(__DRInativeDisplay * ndpy, int screen,
+                    __DRIid drawable, drm_drawable_t * hHWDrawable)
+{
+   _eglLog(_EGL_DEBUG, "XDRI: %s", __FUNCTION__);
+
+   /* Create DRI drawable for given window ID (drawable) */
+   if (!XF86DRICreateDrawable(ndpy, screen, drawable, hHWDrawable))
+      return EGL_FALSE;
+
+   return EGL_TRUE;
+}
+
+
+static GLboolean
+dri_destroy_drawable(__DRInativeDisplay * ndpy, int screen, __DRIid drawable)
+{
+   _eglLog(_EGL_DEBUG, "XDRI: %s", __FUNCTION__);
+   return XF86DRIDestroyDrawable(ndpy, screen, drawable);
+}
+
+
+static GLboolean
+dri_get_drawable_info(__DRInativeDisplay *dpy, int scrn,
+                      __DRIid draw, unsigned int * index, unsigned int * stamp,
+                      int * x, int * y, int * width, int * height,
+                      int * numClipRects, drm_clip_rect_t ** pClipRects,
+                      int * backX, int * backY,
+                      int * numBackClipRects,
+                      drm_clip_rect_t ** pBackClipRects)
+{
+   _eglLog(_EGL_DEBUG, "XDRI: %s", __FUNCTION__);
+
+   if (!XF86DRIGetDrawableInfo(dpy, scrn, draw, index, stamp,
+                               x, y, width, height,
+                               numClipRects, pClipRects,
+                               backX, backY,
+                               numBackClipRects, pBackClipRects)) {
+      return EGL_FALSE;
+   }
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * Table of functions exported by the loader to the driver.
+ */
+static const __DRIinterfaceMethods interface_methods = {
+   dri_get_proc_address,
+
+   dri_context_modes_create,
+   dri_context_modes_destroy,
+
+   dri_find_dri_screen,
+   dri_window_exists,
+
+   dri_create_context,
+   dri_destroy_context,
+
+   dri_create_drawable,
+   dri_destroy_drawable,
+   dri_get_drawable_info,
+
+   NULL,/*__eglGetUST,*/
+   NULL,/*__eglGetMSCRate,*/
+};
+
+
+
+static EGLBoolean
+init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
+{
+   static const char createNewScreenName[] = "__driCreateNewScreen_20050727";
+   PFNCREATENEWSCREENFUNC createNewScreen;
+   int api_ver = 0;/*__glXGetInternalVersion();*/
+   __DRIversion ddx_version;
+   __DRIversion dri_version;
+   __DRIversion drm_version;
+   drmVersionPtr version;
+   drm_handle_t  hFB;
+   int newlyopened;
+   int status;
+   __GLcontextModes *modes;
+   int scrn = DefaultScreen(disp->Xdpy);
+
+   createNewScreen = (PFNCREATENEWSCREENFUNC)
+      dlsym(xdri_drv->dri_driver_handle, createNewScreenName);
+   if (!createNewScreen) {
+      _eglLog(_EGL_WARNING, "XDRI: Couldn't find %s function in the driver.",
+              createNewScreenName);
+      return EGL_FALSE;
+   }
+   else {
+      _eglLog(_EGL_DEBUG, "XDRI: Found %s", createNewScreenName);
+   }
+
+   /*
+    * Get the DRI X extension version.
+    */
+   dri_version.major = 4;
+   dri_version.minor = 0;
+   dri_version.patch = 0;
+
+
+   if (!XF86DRIOpenConnection(disp->Xdpy, scrn,
+                              &xdri_drv->hSAREA, &xdri_drv->busID)) {
+      _eglLog(_EGL_WARNING, "XF86DRIOpenConnection failed");
+   }
+
+   xdri_drv->drmFD = drmOpenOnce(NULL, xdri_drv->busID, &newlyopened);
+   if (xdri_drv->drmFD < 0) {
+      perror("drmOpenOnce failed: ");
+      return EGL_FALSE;
+   }
+   else {
+      _eglLog(_EGL_DEBUG, "XDRI: drmOpenOnce returned %d", xdri_drv->drmFD);
+   }
+
+
+   if (drmGetMagic(xdri_drv->drmFD, &xdri_drv->magic)) {
+      perror("drmGetMagic failed: ");
+      return EGL_FALSE;
+   }
+
+   version = drmGetVersion(xdri_drv->drmFD);
+   if (version) {
+      drm_version.major = version->version_major;
+      drm_version.minor = version->version_minor;
+      drm_version.patch = version->version_patchlevel;
+      drmFreeVersion(version);
+      _eglLog(_EGL_DEBUG, "XDRI: Got DRM version %d.%d.%d",
+              drm_version.major,
+              drm_version.minor,
+              drm_version.patch);
+   }
+   else {
+      drm_version.major = -1;
+      drm_version.minor = -1;
+      drm_version.patch = -1;
+      _eglLog(_EGL_WARNING, "XDRI: drmGetVersion() failed");
+      return EGL_FALSE;
+   }
+
+   /* Authenticate w/ server.
+    */
+   if (!XF86DRIAuthConnection(disp->Xdpy, scrn, xdri_drv->magic)) {
+      _eglLog(_EGL_WARNING, "XDRI: XF86DRIAuthConnection() failed");
+      return EGL_FALSE;
+   }
+   else {
+      _eglLog(_EGL_DEBUG, "XDRI: XF86DRIAuthConnection() success");
+   }
+
+   /* Get ddx version.
+    */
+   {
+      char *driverName;
+
+      /*
+       * Get device name (like "tdfx") and the ddx version
+       * numbers.  We'll check the version in each DRI driver's
+       * "createNewScreen" function.
+       */
+      if (!XF86DRIGetClientDriverName(disp->Xdpy, scrn,
+                                     &ddx_version.major,
+                                     &ddx_version.minor,
+                                     &ddx_version.patch,
+                                     &driverName)) {
+         _eglLog(_EGL_WARNING, "XDRI: XF86DRIGetClientDriverName failed");
+         return EGL_FALSE;
+      }
+      else {
+         _eglLog(_EGL_DEBUG, "XDRI: XF86DRIGetClientDriverName returned %s", driverName);
+      }
+   }
+
+   /* Get framebuffer info.
+    */
+   {
+      int junk;
+      if (!XF86DRIGetDeviceInfo(disp->Xdpy, scrn,
+                                &hFB,
+                                &junk,
+                                &xdri_drv->framebuffer.size,
+                                &xdri_drv->framebuffer.stride,
+                                &xdri_drv->framebuffer.dev_priv_size,
+                                &xdri_drv->framebuffer.dev_priv)) {
+         _eglLog(_EGL_WARNING, "XDRI: XF86DRIGetDeviceInfo() failed");
+         return EGL_FALSE;
+      }
+      else {
+         _eglLog(_EGL_DEBUG, "XDRI: XF86DRIGetDeviceInfo() success");
+      }
+      xdri_drv->framebuffer.width = DisplayWidth(disp->Xdpy, scrn);
+      xdri_drv->framebuffer.height = DisplayHeight(disp->Xdpy, scrn);
+   }
+
+   /* Map the framebuffer region. (this may not be needed)
+    */
+   status = drmMap(xdri_drv->drmFD, hFB, xdri_drv->framebuffer.size, 
+                   (drmAddressPtr) &xdri_drv->framebuffer.base);
+   if (status != 0) {
+      _eglLog(_EGL_WARNING, "XDRI: drmMap(framebuffer) failed");
+      return EGL_FALSE;
+   }
+   else {
+      _eglLog(_EGL_DEBUG, "XDRI: drmMap(framebuffer) success");
+   }
+
+   /* Map the SAREA region.
+    */
+   status = drmMap(xdri_drv->drmFD, xdri_drv->hSAREA, SAREA_MAX, &xdri_drv->pSAREA);
+   if (status != 0) {
+      _eglLog(_EGL_WARNING, "XDRI: drmMap(sarea) failed");
+      return EGL_FALSE;
+   }
+   else {
+      _eglLog(_EGL_DEBUG, "XDRI: drmMap(sarea) success");
+   }
+
+   /* Create the DRI screen.
+    */
+   xdri_drv->driScreen.private = createNewScreen(disp->Xdpy,
+                                             scrn,  /* screen number */
+                                             &xdri_drv->driScreen,
+                                             NULL,  /* visuals */
+                                             &ddx_version,
+                                             &dri_version,
+                                             &drm_version,
+                                             &xdri_drv->framebuffer,
+                                             xdri_drv->pSAREA,
+                                             xdri_drv->drmFD,
+                                             api_ver,
+                                             &interface_methods,
+                                             &modes);
+   if (!xdri_drv->driScreen.private) {
+      _eglLog(_EGL_WARNING, "XDRI: create new screen failed");
+      return EGL_FALSE;
+   }
+   else {
+      _eglLog(_EGL_DEBUG, "XDRI: create new screen success");
+   }
+
+   create_configs(disp);
+
+   /* print modes / debug */
+   if (0) {
+      __GLcontextModes *m;
+
+      for (m = modes; m; m = m->next) {
+         _eglLog(_EGL_DEBUG,
+                 "mode ID 0x%x rgba %d %d %d %d  z %d  s %d  db %d\n", m->visualID,
+                 m->redBits, m->greenBits, m->blueBits, m->alphaBits,
+                 m->depthBits, m->stencilBits, m->doubleBufferMode);
+      }
+   }
+
+   return EGL_TRUE;
+}
+
+
+static EGLBoolean
+load_dri_driver(struct xdri_egl_driver *xdri_drv)
+{
+   char filename[100];
+   int flags = RTLD_NOW;
+
+   snprintf(filename, sizeof(filename), "%s.so", xdri_drv->dri_driver_name);
+   _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s)", filename);
+
+   xdri_drv->dri_driver_handle = dlopen(filename, flags);
+   if (!xdri_drv->dri_driver_handle) {
+      _eglLog(_EGL_WARNING, "XDRI Could not open %s (%s)",
+              filename, dlerror());
+
+      return EGL_FALSE;
+   }
+   return EGL_TRUE;
+}
+
+
+/**
+ * Called via eglInitialize(), xdri_drv->API.Initialize().
+ */
+static EGLBoolean
+xdri_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
+                   EGLint *minor, EGLint *major)
+{
+   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   static char name[100];
+
+   _eglLog(_EGL_DEBUG, "XDRI: eglInitialize");
+
+   if (!disp->Xdpy) {
+      disp->Xdpy = XOpenDisplay(NULL);
+      if (!disp->Xdpy) {
+         _eglLog(_EGL_WARNING, "XDRI: XOpenDisplay failed");
+         return EGL_FALSE;
+      }
+   }
+
+   /* choose the DRI driver to load */
+   xdri_drv->dri_driver_name = _eglChooseDRMDriver(0);
+   if (!load_dri_driver(xdri_drv))
+      return EGL_FALSE;
+
+   if (!init_drm(xdri_drv, disp))
+      return EGL_FALSE;
+
+   xdri_drv->Base.Initialized = EGL_TRUE;
+
+   snprintf(name, sizeof(name), "X/DRI:%s", xdri_drv->dri_driver_name);
+   xdri_drv->Base.Name = name;
+
+   /* we're supporting EGL 1.4 */
+   *minor = 1;
+   *major = 4;
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * Called via eglTerminate(), drv->API.Terminate().
+ */
+static EGLBoolean
+xdri_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
+{
+   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+
+   _eglLog(_EGL_DEBUG, "XDRI: eglTerminate");
+
+   _eglLog(_EGL_DEBUG, "XDRI: Closing %s", xdri_drv->dri_driver_name);
+   dlclose(xdri_drv->dri_driver_handle);
+   xdri_drv->dri_driver_handle = NULL;
+
+   free((void*) xdri_drv->dri_driver_name);
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * Called via eglCreateContext(), drv->API.CreateContext().
+ */
+static EGLContext
+xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+                      EGLContext share_list, const EGLint *attrib_list)
+{
+   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct xdri_egl_config *xdri_config = lookup_config(drv, dpy, config);
+   void *shared = NULL;
+   int renderType = GLX_RGBA_BIT;
+
+   struct xdri_egl_context *xdri_ctx = CALLOC_STRUCT(xdri_egl_context);
+   if (!xdri_ctx)
+      return EGL_NO_CONTEXT;
+
+   if (!_eglInitContext(drv, dpy, &xdri_ctx->Base, config, attrib_list)) {
+      free(xdri_ctx);
+      return EGL_NO_CONTEXT;
+   }
+
+   assert(xdri_config);
+
+   xdri_ctx->driContext.private = 
+      xdri_drv->driScreen.createNewContext(disp->Xdpy,
+                                           xdri_config->mode, renderType,
+                                           shared, &xdri_ctx->driContext);
+   if (!xdri_ctx->driContext.private) {
+      free(xdri_ctx);
+      return EGL_NO_CONTEXT;
+   }
+
+   xdri_ctx->driContext.mode = xdri_config->mode;
+
+   return _eglGetContextHandle(&xdri_ctx->Base);
+}
+
+
+/**
+ * Called via eglMakeCurrent(), drv->API.MakeCurrent().
+ */
+static EGLBoolean
+xdri_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
+                    EGLSurface r, EGLContext context)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct xdri_egl_context *xdri_ctx = lookup_context(context);
+   struct xdri_egl_surface *xdri_draw = lookup_surface(d);
+   struct xdri_egl_surface *xdri_read = lookup_surface(r);
+   __DRIid draw = xdri_draw->driDrawable;
+   __DRIid read = xdri_read->driDrawable;
+   int scrn = DefaultScreen(disp->Xdpy);
+
+   if (!_eglMakeCurrent(drv, dpy, d, r, context))
+      return EGL_FALSE;
+
+
+   if (!xdri_ctx->driContext.bindContext(disp->Xdpy, scrn, draw, read,
+                                         &xdri_ctx->driContext)) {
+      return EGL_FALSE;
+   }
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
+ */
+static EGLSurface
+xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+                            NativeWindowType window, const EGLint *attrib_list)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct xdri_egl_surface *xdri_surf;
+   int scrn = DefaultScreen(disp->Xdpy);
+
+   xdri_surf = CALLOC_STRUCT(xdri_egl_surface);
+   if (!xdri_surf)
+      return EGL_NO_SURFACE;
+
+   if (!_eglInitSurface(drv, dpy, &xdri_surf->Base, EGL_WINDOW_BIT,
+                        config, attrib_list)) {
+      free(xdri_surf);
+      return EGL_FALSE;
+   }
+
+   if (!XF86DRICreateDrawable(disp->Xdpy, scrn, window, &xdri_surf->hDrawable)) {
+      free(xdri_surf);
+      return EGL_FALSE;
+   }
+
+   xdri_surf->driDrawable = window;
+
+   _eglSaveSurface(&xdri_surf->Base);
+
+   _eglLog(_EGL_DEBUG,
+           "XDRI: CreateWindowSurface win 0x%x  handle %d  hDrawable %d",
+           (int) window, _eglGetSurfaceHandle(&xdri_surf->Base),
+           (int) xdri_surf->hDrawable);
+
+   return _eglGetSurfaceHandle(&xdri_surf->Base);
+}
+
+
+static EGLBoolean
+xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+{
+   struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
+   if (xdri_surf) {
+      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
+      if (xdri_surf->Base.IsBound) {
+         xdri_surf->Base.DeletePending = EGL_TRUE;
+      }
+      else {
+         /*
+         st_unreference_framebuffer(&surf->Framebuffer);
+         */
+         free(xdri_surf);
+      }
+      return EGL_TRUE;
+   }
+   else {
+      _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
+      return EGL_FALSE;
+   }
+}
+
+
+static EGLBoolean
+xdri_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+
+   _eglLog(_EGL_DEBUG, "XDRI: EGL SwapBuffers");
+
+   /* error checking step: */
+   if (!_eglSwapBuffers(drv, dpy, draw))
+      return EGL_FALSE;
+
+   {
+      struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
+      __GLXdisplayPrivate *priv = __glXInitialize(disp->Xdpy);
+      __GLXscreenConfigs *scrn = priv->screenConfigs;
+      __DRIscreen *psc = &scrn->driScreen;
+      __DRIdrawable * const pdraw = psc->getDrawable(disp->Xdpy,
+                                                     xdri_surf->driDrawable,
+                                                     psc->private);
+
+      if (pdraw)
+         pdraw->swapBuffers(disp->Xdpy, pdraw->private);
+      else
+         _eglLog(_EGL_WARNING, "pdraw is null in SwapBuffers");
+   }
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * This is the main entrypoint into the driver, called by libEGL.
+ * Create a new _EGLDriver object and init its dispatch table.
+ */
+_EGLDriver *
+_eglMain(_EGLDisplay *disp, const char *args)
+{
+   struct xdri_egl_driver *xdri_drv = CALLOC_STRUCT(xdri_egl_driver);
+   if (!xdri_drv)
+      return NULL;
+
+   _eglInitDriverFallbacks(&xdri_drv->Base);
+   xdri_drv->Base.API.Initialize = xdri_eglInitialize;
+   xdri_drv->Base.API.Terminate = xdri_eglTerminate;
+
+   xdri_drv->Base.API.CreateContext = xdri_eglCreateContext;
+   xdri_drv->Base.API.MakeCurrent = xdri_eglMakeCurrent;
+   xdri_drv->Base.API.CreateWindowSurface = xdri_eglCreateWindowSurface;
+   xdri_drv->Base.API.DestroySurface = xdri_eglDestroySurface;
+   xdri_drv->Base.API.SwapBuffers = xdri_eglSwapBuffers;
+
+   xdri_drv->Base.ClientAPIsMask = EGL_OPENGL_BIT /*| EGL_OPENGL_ES_BIT*/;
+   xdri_drv->Base.Name = "X/DRI";
+
+   _eglLog(_EGL_DEBUG, "XDRI: main(%s)", args);
+
+   return &xdri_drv->Base;
+}
-- 
cgit v1.2.3


From f374734d61011acc2d7b4e5f390d806603a833bd Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 6 Jun 2008 15:59:54 -0600
Subject: egl: improved Makefile

---
 src/egl/drivers/Makefile | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/Makefile b/src/egl/drivers/Makefile
index 837626e3d6..a2d67ca5a8 100644
--- a/src/egl/drivers/Makefile
+++ b/src/egl/drivers/Makefile
@@ -1,8 +1,10 @@
 # src/egl/drivers/Makefile
 
 TOP = ../../..
+include $(TOP)/configs/current
 
-SUBDIRS = demo dri
+
+SUBDIRS = demo dri xdri
 
 
 default: conditional_subdirs
@@ -10,19 +12,17 @@ default: conditional_subdirs
 
 # depending on $DRIVER_DIRS...
 conditional_subdirs:
-	@echo "DRIVER_DIRS = " $(DRIVER_DIRS)
-	@case "$$DRIVER_DIRS" in \
-	    dri)    $(MAKE) dri_subdir || exit 1 ;; \
-	    *)      ;; \
-	esac;
-
+	@if [ "${DRIVER_DIRS}" = "dri" ] ; then \
+		$(MAKE) dri_subdirs ; \
+	fi
 
-dri_subdir:
-	(cd dri ; $(MAKE)) || exit 1 ; \
 
+dri_subdirs:
+	@ (cd dri ; $(MAKE)) || exit 1
+	@ (cd xdri ; $(MAKE)) || exit 1
 
 demo_subdir:
-	(cd demo ; $(MAKE)) || exit 1 ; \
+	@ (cd demo ; $(MAKE)) || exit 1
 
 
 
-- 
cgit v1.2.3


From e9b6ed395a69be90cbf1e2481a9da6fa4079e88e Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Tue, 10 Jun 2008 16:14:35 -0600
Subject: egl: only windows are renderable at this time

---
 src/egl/drivers/xdri/egl_xdri.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 4c8511fbbf..60753a1c1f 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -183,6 +183,9 @@ create_configs(_EGLDisplay *disp)
          SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, m->stencilBits);
          SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, m->visualID);
          SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_TYPE, m->visualType);
+         /* XXX only window rendering allowed ATM */
+         SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
+
          /* XXX possibly other things to init... */
 
          /* Ptr from EGL config to GLcontextMode.  Used in CreateContext(). */
-- 
cgit v1.2.3


From be16f04e76be28dd0bab039b21b63ce0752de336 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 13 Jun 2008 13:56:31 -0600
Subject: egl: added a debug msg

---
 src/egl/drivers/xdri/egl_xdri.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 60753a1c1f..df80c6a1c4 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -675,6 +675,7 @@ xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
                                            xdri_config->mode, renderType,
                                            shared, &xdri_ctx->driContext);
    if (!xdri_ctx->driContext.private) {
+      _eglLog(_EGL_DEBUG, "driScreen.createNewContext failed");
       free(xdri_ctx);
       return EGL_NO_CONTEXT;
    }
-- 
cgit v1.2.3


From a1fb565ea7ac9f86beb4deece6a24d79e7b7860e Mon Sep 17 00:00:00 2001
From: Robert Ellison <papillo@tungstengraphics.com>
Date: Thu, 26 Jun 2008 08:55:00 -0600
Subject: egl: These changes allow an eglBindAPI(EGL_OPENGL_ES_API) to succeed,
 and to work correctly with GLES1 and GLES2.

- egl_xdri.c just sets the EGL_OPENGL_ES_BIT as well as the
  EGL_OPENGL_BIT in ClientAPIsMask

- eglconfig.c allows the renderable type to include EGL_OPENGL_ES2_BIT
  as well as EGL_OPENGL_ES_BIT.

- egl_xlib.c sets the EGL_NATIVE_RENDERABLE attribute to EGL_FALSE for
  all softpipe configurations.  (Otherwise, an eglChooseConfig() that
  looks for particular values of EGL_NATIVE_RENDERABLE will fail.)
---
 src/egl/drivers/xdri/egl_xdri.c        | 2 +-
 src/egl/main/eglconfig.c               | 2 +-
 src/gallium/winsys/egl_xlib/egl_xlib.c | 1 +
 3 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index df80c6a1c4..71d4f15371 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -828,7 +828,7 @@ _eglMain(_EGLDisplay *disp, const char *args)
    xdri_drv->Base.API.DestroySurface = xdri_eglDestroySurface;
    xdri_drv->Base.API.SwapBuffers = xdri_eglSwapBuffers;
 
-   xdri_drv->Base.ClientAPIsMask = EGL_OPENGL_BIT /*| EGL_OPENGL_ES_BIT*/;
+   xdri_drv->Base.ClientAPIsMask = EGL_OPENGL_BIT | EGL_OPENGL_ES_BIT;
    xdri_drv->Base.Name = "X/DRI";
 
    _eglLog(_EGL_DEBUG, "XDRI: main(%s)", args);
diff --git a/src/egl/main/eglconfig.c b/src/egl/main/eglconfig.c
index 3ef0564a54..b6846d4928 100644
--- a/src/egl/main/eglconfig.c
+++ b/src/egl/main/eglconfig.c
@@ -147,7 +147,7 @@ _eglParseConfigAttribs(_EGLConfig *config, const EGLint *attrib_list)
       }
       else if (attr == EGL_RENDERABLE_TYPE) {
          EGLint renType = attrib_list[++i];
-         if (renType & ~(EGL_OPENGL_ES_BIT | EGL_OPENVG_BIT)) {
+         if (renType & ~(EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT | EGL_OPENVG_BIT)) {
             _eglError(EGL_BAD_ATTRIBUTE, "eglChooseConfig");
             return EGL_FALSE;
          }
diff --git a/src/gallium/winsys/egl_xlib/egl_xlib.c b/src/gallium/winsys/egl_xlib/egl_xlib.c
index eeb15e30a9..8045c0d0ca 100644
--- a/src/gallium/winsys/egl_xlib/egl_xlib.c
+++ b/src/gallium/winsys/egl_xlib/egl_xlib.c
@@ -172,6 +172,7 @@ create_configs(_EGLDriver *drv, EGLDisplay dpy)
       SET_CONFIG_ATTRIB(config, EGL_STENCIL_SIZE, sbits);
       SET_CONFIG_ATTRIB(config, EGL_NATIVE_VISUAL_ID, visid);
       SET_CONFIG_ATTRIB(config, EGL_NATIVE_VISUAL_TYPE, vistype);
+      SET_CONFIG_ATTRIB(config, EGL_NATIVE_RENDERABLE, EGL_FALSE);
 
       _eglAddConfig(disp, config);
    }
-- 
cgit v1.2.3


From 28f3d390ddf87f796a9a9f3dc28b0b05c19e40fa Mon Sep 17 00:00:00 2001
From: Jakob Bornecrantz <jakob@aurora.(none)>
Date: Thu, 3 Jul 2008 12:10:36 +0200
Subject: egl: Fix demodriver

---
 src/egl/drivers/demo/demo.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index 6b8b71d16b..1750e976b8 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -67,22 +67,22 @@ demoInitialize(_EGLDriver *drv, EGLDisplay dpy, EGLint *major, EGLint *minor)
 
    /* Create the display's visual configs - silly example */
    for (i = 0; i < 4; i++) {
-      _EGLConfig config;
-      _eglInitConfig(&config, i + 1);
-      _eglSetConfigAttrib(&config, EGL_RED_SIZE, 8);
-      _eglSetConfigAttrib(&config, EGL_GREEN_SIZE, 8);
-      _eglSetConfigAttrib(&config, EGL_BLUE_SIZE, 8);
-      _eglSetConfigAttrib(&config, EGL_ALPHA_SIZE, 8);
-      _eglSetConfigAttrib(&config, EGL_BUFFER_SIZE, 32);
+      _EGLConfig *config = calloc(1, sizeof(_EGLConfig));
+      _eglInitConfig(config, i + 1);
+      _eglSetConfigAttrib(config, EGL_RED_SIZE, 8);
+      _eglSetConfigAttrib(config, EGL_GREEN_SIZE, 8);
+      _eglSetConfigAttrib(config, EGL_BLUE_SIZE, 8);
+      _eglSetConfigAttrib(config, EGL_ALPHA_SIZE, 8);
+      _eglSetConfigAttrib(config, EGL_BUFFER_SIZE, 32);
       if (i & 1) {
-         _eglSetConfigAttrib(&config, EGL_DEPTH_SIZE, 32);
+         _eglSetConfigAttrib(config, EGL_DEPTH_SIZE, 32);
       }
       if (i & 2) {
-         _eglSetConfigAttrib(&config, EGL_STENCIL_SIZE, 8);
+         _eglSetConfigAttrib(config, EGL_STENCIL_SIZE, 8);
       }
-      _eglSetConfigAttrib(&config, EGL_SURFACE_TYPE,
+      _eglSetConfigAttrib(config, EGL_SURFACE_TYPE,
                           (EGL_WINDOW_BIT | EGL_PIXMAP_BIT | EGL_PBUFFER_BIT));
-      _eglAddConfig(disp, &config);
+      _eglAddConfig(disp, config);
    }
 
    drv->Initialized = EGL_TRUE;
-- 
cgit v1.2.3


From 70b0a949b0af9954359be452febaa44f08052056 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 9 Jul 2008 15:47:27 -0600
Subject: egl: misc updates/fixes

Set surface size when created.
Implement dri_find_dri_screen().
Look for "egl_xxx_dri.so" library before regular DRI driver.
---
 src/egl/drivers/xdri/egl_xdri.c | 93 +++++++++++++++++++++++++++++++++--------
 1 file changed, 76 insertions(+), 17 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 71d4f15371..5e50d6034a 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -118,6 +118,10 @@ struct xdri_egl_config
 };
 
 
+/* XXX temp hack */
+static struct xdri_egl_driver *TheDriver = NULL;
+
+
 /** cast wrapper */
 static struct xdri_egl_driver *
 xdri_egl_driver(_EGLDriver *drv)
@@ -154,6 +158,21 @@ lookup_config(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config)
 
 
 
+/** Get size of given window */
+static Status
+get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
+{
+   Window root;
+   Status stat;
+   int xpos, ypos;
+   unsigned int w, h, bw, depth;
+   stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
+   *width = w;
+   *height = h;
+   return stat;
+}
+
+
 /**
  * Produce a set of EGL configs.
  * Note that we get the list of GLcontextModes from the GLX library.
@@ -273,24 +292,25 @@ dri_context_modes_create(unsigned count, size_t minimum_size)
 static __DRIscreen *
 dri_find_dri_screen(__DRInativeDisplay *ndpy, int scrn)
 {
-   /* unused? */
-   return NULL;
+   assert(TheDriver);
+
+   return &TheDriver->driScreen;
 }
 
 
 static GLboolean
-dri_window_exists(__DRInativeDisplay *dpy, __DRIid draw)
+dri_window_exists(__DRInativeDisplay *ndpy, __DRIid draw)
 {
    return EGL_TRUE;
 }
 
 
 static GLboolean
-dri_create_context(__DRInativeDisplay *dpy, int screenNum, int configID,
+dri_create_context(__DRInativeDisplay *ndpy, int screenNum, int configID,
                    void * contextID, drm_context_t * hw_context)
 {
    assert(configID >= 0);
-   return XF86DRICreateContextWithConfig(dpy, screenNum,
+   return XF86DRICreateContextWithConfig(ndpy, screenNum,
                                          configID, contextID, hw_context);
 }
 
@@ -325,7 +345,7 @@ dri_destroy_drawable(__DRInativeDisplay * ndpy, int screen, __DRIid drawable)
 
 
 static GLboolean
-dri_get_drawable_info(__DRInativeDisplay *dpy, int scrn,
+dri_get_drawable_info(__DRInativeDisplay *ndpy, int scrn,
                       __DRIid draw, unsigned int * index, unsigned int * stamp,
                       int * x, int * y, int * width, int * height,
                       int * numClipRects, drm_clip_rect_t ** pClipRects,
@@ -335,7 +355,7 @@ dri_get_drawable_info(__DRInativeDisplay *dpy, int scrn,
 {
    _eglLog(_EGL_DEBUG, "XDRI: %s", __FUNCTION__);
 
-   if (!XF86DRIGetDrawableInfo(dpy, scrn, draw, index, stamp,
+   if (!XF86DRIGetDrawableInfo(ndpy, scrn, draw, index, stamp,
                                x, y, width, height,
                                numClipRects, pClipRects,
                                backX, backY,
@@ -570,17 +590,29 @@ load_dri_driver(struct xdri_egl_driver *xdri_drv)
    char filename[100];
    int flags = RTLD_NOW;
 
-   snprintf(filename, sizeof(filename), "%s.so", xdri_drv->dri_driver_name);
+   /* try "egl_xxx_dri.so" first */
+   snprintf(filename, sizeof(filename), "egl_%s.so", xdri_drv->dri_driver_name);
    _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s)", filename);
-
    xdri_drv->dri_driver_handle = dlopen(filename, flags);
-   if (!xdri_drv->dri_driver_handle) {
-      _eglLog(_EGL_WARNING, "XDRI Could not open %s (%s)",
-              filename, dlerror());
+   if (xdri_drv->dri_driver_handle) {
+      _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s) OK", filename);
+      return EGL_TRUE;
+   }
+   else {
+      _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s) fail (%s)", filename, dlerror());
+   }
 
-      return EGL_FALSE;
+   /* try regular "xxx_dri.so" next */
+   snprintf(filename, sizeof(filename), "%s.so", xdri_drv->dri_driver_name);
+   _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s)", filename);
+   xdri_drv->dri_driver_handle = dlopen(filename, flags);
+   if (xdri_drv->dri_driver_handle) {
+      _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s) OK", filename);
+      return EGL_TRUE;
    }
-   return EGL_TRUE;
+
+   _eglLog(_EGL_WARNING, "XDRI Could not open %s (%s)", filename, dlerror());
+   return EGL_FALSE;
 }
 
 
@@ -646,6 +678,24 @@ xdri_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 }
 
 
+static _EGLProc
+xdri_eglGetProcAddress(const char *procname)
+{
+#if 0
+   _EGLDriver *drv = NULL;
+
+   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+   /*_EGLDisplay *disp = _eglLookupDisplay(dpy);*/
+   _EGLProc *proc = xdri_drv->driScreen.getProcAddress(procname);
+   return proc;
+#elif 0
+   return (_EGLProc) st_get_proc_address(procname);
+#else
+   return NULL;
+#endif
+}
+
+
 /**
  * Called via eglCreateContext(), drv->API.CreateContext().
  */
@@ -724,6 +774,7 @@ xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct xdri_egl_surface *xdri_surf;
    int scrn = DefaultScreen(disp->Xdpy);
+   uint width, height;
 
    xdri_surf = CALLOC_STRUCT(xdri_egl_surface);
    if (!xdri_surf)
@@ -744,6 +795,10 @@ xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 
    _eglSaveSurface(&xdri_surf->Base);
 
+   get_drawable_size(disp->Xdpy, window, &width, &height);
+   xdri_surf->Base.Width = width;
+   xdri_surf->Base.Height = height;
+
    _eglLog(_EGL_DEBUG,
            "XDRI: CreateWindowSurface win 0x%x  handle %d  hDrawable %d",
            (int) window, _eglGetSurfaceHandle(&xdri_surf->Base),
@@ -790,9 +845,8 @@ xdri_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 
    {
       struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
-      __GLXdisplayPrivate *priv = __glXInitialize(disp->Xdpy);
-      __GLXscreenConfigs *scrn = priv->screenConfigs;
-      __DRIscreen *psc = &scrn->driScreen;
+      struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+      __DRIscreen *psc = &xdri_drv->driScreen;
       __DRIdrawable * const pdraw = psc->getDrawable(disp->Xdpy,
                                                      xdri_surf->driDrawable,
                                                      psc->private);
@@ -818,10 +872,15 @@ _eglMain(_EGLDisplay *disp, const char *args)
    if (!xdri_drv)
       return NULL;
 
+   /* XXX temp hack */
+   TheDriver = xdri_drv;
+
    _eglInitDriverFallbacks(&xdri_drv->Base);
    xdri_drv->Base.API.Initialize = xdri_eglInitialize;
    xdri_drv->Base.API.Terminate = xdri_eglTerminate;
 
+   xdri_drv->Base.API.GetProcAddress = xdri_eglGetProcAddress;
+
    xdri_drv->Base.API.CreateContext = xdri_eglCreateContext;
    xdri_drv->Base.API.MakeCurrent = xdri_eglMakeCurrent;
    xdri_drv->Base.API.CreateWindowSurface = xdri_eglCreateWindowSurface;
-- 
cgit v1.2.3


From e3b13dba4df0522cce11c55c34a9e3e7d0f3a32c Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 9 Jul 2008 15:49:59 -0600
Subject: egl: link libEGL w/ additional libs

---
 src/egl/drivers/xdri/Makefile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index 477a75184a..252d00b6c2 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -27,6 +27,8 @@ OBJECTS = $(SOURCES:.c=.o)
 
 DRM_LIB = `pkg-config --libs libdrm`
 
+MISC_LIBS = -ldl -lXext -lGL
+
 
 .c.o:
 	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
@@ -47,7 +49,7 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 		-noprefix \
 		-major 1 -minor 0 \
 		-install $(TOP)/$(LIB_DIR) \
-		-ldl $(OBJECTS) $(DRM_LIB)
+		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
 
 
 clean:
-- 
cgit v1.2.3


From fb3867aec018ba0c0aa548db541236528400d934 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Thu, 10 Jul 2008 10:48:28 -0600
Subject: egl: implement xdri_eglGetProcAddress() for gallium

Plus comments, clean-ups.
---
 src/egl/drivers/xdri/egl_xdri.c | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 5e50d6034a..9d95c850d0 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -574,7 +574,8 @@ init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
 
       for (m = modes; m; m = m->next) {
          _eglLog(_EGL_DEBUG,
-                 "mode ID 0x%x rgba %d %d %d %d  z %d  s %d  db %d\n", m->visualID,
+                 "mode ID 0x%x rgba %d %d %d %d  z %d  s %d  db %d\n",
+                 m->visualID,
                  m->redBits, m->greenBits, m->blueBits, m->alphaBits,
                  m->depthBits, m->stencilBits, m->doubleBufferMode);
       }
@@ -584,6 +585,15 @@ init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
 }
 
 
+/**
+ * Load the DRI driver named by "xdri_drv->dri_driver_name".
+ * Basically, dlopen() the library to set "xdri_drv->dri_driver_handle".
+ *
+ * Later, we'll call dlsym(createNewScreenName) to get a pointer to
+ * the driver's createNewScreen() function which is the bootstrap function.
+ *
+ * \return EGL_TRUE for success, EGL_FALSE for failure
+ */
 static EGLBoolean
 load_dri_driver(struct xdri_egl_driver *xdri_drv)
 {
@@ -678,6 +688,9 @@ xdri_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 }
 
 
+/*
+ * Called from eglGetProcAddress() via drv->API.GetProcAddress().
+ */
 static _EGLProc
 xdri_eglGetProcAddress(const char *procname)
 {
@@ -688,8 +701,17 @@ xdri_eglGetProcAddress(const char *procname)
    /*_EGLDisplay *disp = _eglLookupDisplay(dpy);*/
    _EGLProc *proc = xdri_drv->driScreen.getProcAddress(procname);
    return proc;
-#elif 0
-   return (_EGLProc) st_get_proc_address(procname);
+#elif 1
+   /* This is a bit of a hack to get at the gallium/Mesa state tracker
+    * function st_get_proc_address().  This will probably change at
+    * some point.
+    */
+   _EGLProc (*st_get_proc_addr)(const char *procname);
+   st_get_proc_addr = dlsym(NULL, "st_get_proc_address");
+   if (st_get_proc_addr) {
+      return st_get_proc_addr(procname);
+   }
+   return NULL;   
 #else
    return NULL;
 #endif
-- 
cgit v1.2.3


From b101890c150d2ba17a42f5164f0de86914b9b28b Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Thu, 10 Jul 2008 13:29:42 -0600
Subject: egl: add all EGL_*_BITs to ClientAPIsMask

---
 src/egl/drivers/xdri/egl_xdri.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 9d95c850d0..0f8496c0fb 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -909,7 +909,10 @@ _eglMain(_EGLDisplay *disp, const char *args)
    xdri_drv->Base.API.DestroySurface = xdri_eglDestroySurface;
    xdri_drv->Base.API.SwapBuffers = xdri_eglSwapBuffers;
 
-   xdri_drv->Base.ClientAPIsMask = EGL_OPENGL_BIT | EGL_OPENGL_ES_BIT;
+   xdri_drv->Base.ClientAPIsMask = (EGL_OPENGL_BIT |
+                                    EGL_OPENGL_ES_BIT |
+                                    EGL_OPENGL_ES2_BIT |
+                                    EGL_OPENVG_BIT);
    xdri_drv->Base.Name = "X/DRI";
 
    _eglLog(_EGL_DEBUG, "XDRI: main(%s)", args);
-- 
cgit v1.2.3


From 7986baf7cf5434c0ff8210eedd0be366ab5e8f14 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Thu, 10 Jul 2008 15:11:01 -0600
Subject: build egl subdirs

---
 configs/linux-dri        | 12 +-----------
 src/egl/drivers/Makefile |  4 ++--
 2 files changed, 3 insertions(+), 13 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/configs/linux-dri b/configs/linux-dri
index 9fd3721265..380cd3812f 100644
--- a/configs/linux-dri
+++ b/configs/linux-dri
@@ -46,18 +46,8 @@ GL_LIB_DEPS   = $(EXTRA_LIB_PATH) -lX11 -lXext -lXxf86vm -lXdamage -lXfixes \
                 $(LIBDRM_LIB)
 
 
-# This is now 0 by default since it seems to confuse the hell out of people
-# and generate a lot of extra noise on bugzilla.  If you need to build with
-# EGL, do 'make linux-dri USING_EGL=1'
-
-USING_EGL=0
-
 # Directories
-SRC_DIRS := glx/x11 $(SRC_DIRS)
-ifeq ($(USING_EGL), 1)
-SRC_DIRS := egl $(SRC_DIRS)
-PROGRAM_DIRS = egl
-endif
+SRC_DIRS := glx/x11 egl $(SRC_DIRS)
 
 
 
diff --git a/src/egl/drivers/Makefile b/src/egl/drivers/Makefile
index a2d67ca5a8..6ce0e6b66d 100644
--- a/src/egl/drivers/Makefile
+++ b/src/egl/drivers/Makefile
@@ -7,10 +7,10 @@ include $(TOP)/configs/current
 SUBDIRS = demo dri xdri
 
 
-default: conditional_subdirs
+default: dri_subdirs
 
 
-# depending on $DRIVER_DIRS...
+# (UNUSED) depending on $DRIVER_DIRS...
 conditional_subdirs:
 	@if [ "${DRIVER_DIRS}" = "dri" ] ; then \
 		$(MAKE) dri_subdirs ; \
-- 
cgit v1.2.3


From 80b24166a51f26e7bb341a731ceeb4f85c6cc4cf Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 11 Jul 2008 15:44:46 -0600
Subject: egl: a minor overhauld of egl_xdri.c

Rely more on the libGL code to avoid duplicated efforts.  Also fix confusion
arising from multiple __DRIscreen objects.
---
 src/egl/drivers/xdri/egl_xdri.c | 104 ++++++++++++++++------------------------
 1 file changed, 42 insertions(+), 62 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 0f8496c0fb..dfb491958b 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -33,7 +33,7 @@
  * to render into X-created windows.
  *
  * This is an EGL driver that, in turn, loads a regular DRI driver.
- * There are some dependencies on code in libGL, but those coudl be
+ * There are some dependencies on code in libGL, but those could be
  * removed with some effort.
  *
  * Authors: Brian Paul
@@ -77,11 +77,14 @@ struct xdri_egl_driver
    const char *dri_driver_name;  /**< name of DRI driver to load */
    void *dri_driver_handle;      /**< returned by dlopen(dri_driver_name) */
 
+   __GLXdisplayPrivate *glx_priv;
+
+
+   /* XXX we're not actually using these at this time: */
    int chipset;
    int minor;
    int drmFD;
 
-   __DRIscreen driScreen;
    __DRIframebuffer framebuffer;
    drm_handle_t hSAREA;
    drmAddress pSAREA;
@@ -118,9 +121,6 @@ struct xdri_egl_config
 };
 
 
-/* XXX temp hack */
-static struct xdri_egl_driver *TheDriver = NULL;
-
 
 /** cast wrapper */
 static struct xdri_egl_driver *
@@ -179,11 +179,10 @@ get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
  * This dependency on GLX lib will be removed someday.
  */
 static void
-create_configs(_EGLDisplay *disp)
+create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
 {
+   __GLXscreenConfigs *scrn = glx_priv->screenConfigs;
    const __GLcontextModes *m;
-   __GLXdisplayPrivate *priv = __glXInitialize(disp->Xdpy);
-   __GLXscreenConfigs *scrn = priv->screenConfigs;
    int id = 1;
 
    for (m = scrn->configs; m; m = m->next) {
@@ -292,9 +291,9 @@ dri_context_modes_create(unsigned count, size_t minimum_size)
 static __DRIscreen *
 dri_find_dri_screen(__DRInativeDisplay *ndpy, int scrn)
 {
-   assert(TheDriver);
-
-   return &TheDriver->driScreen;
+   __GLXdisplayPrivate *priv = __glXInitialize(ndpy);
+   __GLXscreenConfigs *scrnConf = priv->screenConfigs;
+   return &scrnConf->driScreen;
 }
 
 
@@ -395,9 +394,6 @@ static const __DRIinterfaceMethods interface_methods = {
 static EGLBoolean
 init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
 {
-   static const char createNewScreenName[] = "__driCreateNewScreen_20050727";
-   PFNCREATENEWSCREENFUNC createNewScreen;
-   int api_ver = 0;/*__glXGetInternalVersion();*/
    __DRIversion ddx_version;
    __DRIversion dri_version;
    __DRIversion drm_version;
@@ -405,9 +401,9 @@ init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
    drm_handle_t  hFB;
    int newlyopened;
    int status;
-   __GLcontextModes *modes;
    int scrn = DefaultScreen(disp->Xdpy);
 
+#if 0
    createNewScreen = (PFNCREATENEWSCREENFUNC)
       dlsym(xdri_drv->dri_driver_handle, createNewScreenName);
    if (!createNewScreen) {
@@ -418,6 +414,7 @@ init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
    else {
       _eglLog(_EGL_DEBUG, "XDRI: Found %s", createNewScreenName);
    }
+#endif
 
    /*
     * Get the DRI X extension version.
@@ -426,7 +423,6 @@ init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
    dri_version.minor = 0;
    dri_version.patch = 0;
 
-
    if (!XF86DRIOpenConnection(disp->Xdpy, scrn,
                               &xdri_drv->hSAREA, &xdri_drv->busID)) {
       _eglLog(_EGL_WARNING, "XF86DRIOpenConnection failed");
@@ -543,44 +539,6 @@ init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
       _eglLog(_EGL_DEBUG, "XDRI: drmMap(sarea) success");
    }
 
-   /* Create the DRI screen.
-    */
-   xdri_drv->driScreen.private = createNewScreen(disp->Xdpy,
-                                             scrn,  /* screen number */
-                                             &xdri_drv->driScreen,
-                                             NULL,  /* visuals */
-                                             &ddx_version,
-                                             &dri_version,
-                                             &drm_version,
-                                             &xdri_drv->framebuffer,
-                                             xdri_drv->pSAREA,
-                                             xdri_drv->drmFD,
-                                             api_ver,
-                                             &interface_methods,
-                                             &modes);
-   if (!xdri_drv->driScreen.private) {
-      _eglLog(_EGL_WARNING, "XDRI: create new screen failed");
-      return EGL_FALSE;
-   }
-   else {
-      _eglLog(_EGL_DEBUG, "XDRI: create new screen success");
-   }
-
-   create_configs(disp);
-
-   /* print modes / debug */
-   if (0) {
-      __GLcontextModes *m;
-
-      for (m = modes; m; m = m->next) {
-         _eglLog(_EGL_DEBUG,
-                 "mode ID 0x%x rgba %d %d %d %d  z %d  s %d  db %d\n",
-                 m->visualID,
-                 m->redBits, m->greenBits, m->blueBits, m->alphaBits,
-                 m->depthBits, m->stencilBits, m->doubleBufferMode);
-      }
-   }
-
    return EGL_TRUE;
 }
 
@@ -647,13 +605,30 @@ xdri_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
       }
    }
 
+#if 0
    /* choose the DRI driver to load */
    xdri_drv->dri_driver_name = _eglChooseDRMDriver(0);
    if (!load_dri_driver(xdri_drv))
       return EGL_FALSE;
+#else
+   (void) load_dri_driver;
+#endif
 
+#if 0
    if (!init_drm(xdri_drv, disp))
       return EGL_FALSE;
+#else
+   (void) init_drm;
+#endif
+
+   /*
+    * NOTE: this call to __glXInitialize() bootstraps the whole GLX/DRI
+    * interface, loads the DRI driver, etc.
+    * This replaces the load_dri_driver()  and init_drm() code above.
+    */
+   xdri_drv->glx_priv = __glXInitialize(disp->Xdpy);
+
+   create_configs(disp, xdri_drv->glx_priv);
 
    xdri_drv->Base.Initialized = EGL_TRUE;
 
@@ -725,7 +700,6 @@ static EGLContext
 xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
                       EGLContext share_list, const EGLint *attrib_list)
 {
-   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct xdri_egl_config *xdri_config = lookup_config(drv, dpy, config);
    void *shared = NULL;
@@ -742,10 +716,15 @@ xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 
    assert(xdri_config);
 
-   xdri_ctx->driContext.private = 
-      xdri_drv->driScreen.createNewContext(disp->Xdpy,
-                                           xdri_config->mode, renderType,
-                                           shared, &xdri_ctx->driContext);
+   {
+      struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+      __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
+      xdri_ctx->driContext.private = 
+         scrnConf->driScreen.createNewContext(disp->Xdpy,
+                                              xdri_config->mode, renderType,
+                                              shared, &xdri_ctx->driContext);
+   }
+
    if (!xdri_ctx->driContext.private) {
       _eglLog(_EGL_DEBUG, "driScreen.createNewContext failed");
       free(xdri_ctx);
@@ -868,7 +847,8 @@ xdri_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
    {
       struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
       struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-      __DRIscreen *psc = &xdri_drv->driScreen;
+      __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
+      __DRIscreen *psc = &scrnConf->driScreen;
       __DRIdrawable * const pdraw = psc->getDrawable(disp->Xdpy,
                                                      xdri_surf->driDrawable,
                                                      psc->private);
@@ -894,8 +874,8 @@ _eglMain(_EGLDisplay *disp, const char *args)
    if (!xdri_drv)
       return NULL;
 
-   /* XXX temp hack */
-   TheDriver = xdri_drv;
+   /* Tell libGL to prefer the EGL drivers over regular DRI drivers */
+   __glXPreferEGL(1);
 
    _eglInitDriverFallbacks(&xdri_drv->Base);
    xdri_drv->Base.API.Initialize = xdri_eglInitialize;
-- 
cgit v1.2.3


From e59086ab91281cafcae094164bf4d8454df337ae Mon Sep 17 00:00:00 2001
From: Jakob Bornecrantz <jakob@tungstengraphics.com>
Date: Sun, 13 Jul 2008 18:04:49 +0200
Subject: EGL: Only build EGL dri based drivers under linux-dri based configs

---
 configs/default          |  2 ++
 configs/linux-dri        |  2 ++
 src/egl/drivers/Makefile | 21 ++-------------------
 3 files changed, 6 insertions(+), 19 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/configs/default b/configs/default
index ef9c5fda1e..1b203b00d2 100644
--- a/configs/default
+++ b/configs/default
@@ -66,6 +66,8 @@ DRIVER_DIRS =
 # Which subdirs under $(TOP)/progs/ to enter:
 PROGRAM_DIRS = demos redbook samples glsl xdemos
 
+# EGL directories
+EGL_DRIVERS_DIRS = demo
 
 # Gallium directories and 
 GALLIUM_AUXILIARY_DIRS = draw translate cso_cache pipebuffer tgsi sct rtasm util
diff --git a/configs/linux-dri b/configs/linux-dri
index 380cd3812f..7613d41ea1 100644
--- a/configs/linux-dri
+++ b/configs/linux-dri
@@ -50,6 +50,8 @@ GL_LIB_DEPS   = $(EXTRA_LIB_PATH) -lX11 -lXext -lXxf86vm -lXdamage -lXfixes \
 SRC_DIRS := glx/x11 egl $(SRC_DIRS)
 
 
+# EGL directories
+EGL_DRIVERS_DIRS = demo dri xdri
 
 DRIVER_DIRS =
 WINDOW_SYSTEM = dri
diff --git a/src/egl/drivers/Makefile b/src/egl/drivers/Makefile
index 6ce0e6b66d..f0538f563f 100644
--- a/src/egl/drivers/Makefile
+++ b/src/egl/drivers/Makefile
@@ -3,27 +3,10 @@
 TOP = ../../..
 include $(TOP)/configs/current
 
+SUBDIRS = $(EGL_DRIVERS_DIRS)
 
-SUBDIRS = demo dri xdri
-
-
-default: dri_subdirs
-
-
-# (UNUSED) depending on $DRIVER_DIRS...
-conditional_subdirs:
-	@if [ "${DRIVER_DIRS}" = "dri" ] ; then \
-		$(MAKE) dri_subdirs ; \
-	fi
-
-
-dri_subdirs:
-	@ (cd dri ; $(MAKE)) || exit 1
-	@ (cd xdri ; $(MAKE)) || exit 1
-
-demo_subdir:
-	@ (cd demo ; $(MAKE)) || exit 1
 
+default: subdirs
 
 
 subdirs:
-- 
cgit v1.2.3


From e7fd3de9277a0c5efe52966908da8e4e7f1995ee Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Mon, 14 Jul 2008 12:09:07 -0600
Subject: egl: set EGL_CONFORMANT, EGL_RENDERABLE_TYPE config fields, fix null
 ptr crashes in MakeCurrent

---
 src/egl/drivers/xdri/egl_xdri.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index dfb491958b..2471c0425c 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -181,6 +181,10 @@ get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
 static void
 create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
 {
+   static const EGLint all_apis = (EGL_OPENGL_ES_BIT |
+                                   EGL_OPENGL_ES2_BIT |
+                                   EGL_OPENVG_BIT |
+                                   EGL_OPENGL_BIT);
    __GLXscreenConfigs *scrn = glx_priv->screenConfigs;
    const __GLcontextModes *m;
    int id = 1;
@@ -201,6 +205,8 @@ create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
          SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, m->stencilBits);
          SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, m->visualID);
          SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_TYPE, m->visualType);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
          /* XXX only window rendering allowed ATM */
          SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
 
@@ -654,7 +660,9 @@ xdri_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
    _eglLog(_EGL_DEBUG, "XDRI: eglTerminate");
 
    _eglLog(_EGL_DEBUG, "XDRI: Closing %s", xdri_drv->dri_driver_name);
+#if 0
    dlclose(xdri_drv->dri_driver_handle);
+#endif
    xdri_drv->dri_driver_handle = NULL;
 
    free((void*) xdri_drv->dri_driver_name);
@@ -748,15 +756,16 @@ xdri_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
    struct xdri_egl_context *xdri_ctx = lookup_context(context);
    struct xdri_egl_surface *xdri_draw = lookup_surface(d);
    struct xdri_egl_surface *xdri_read = lookup_surface(r);
-   __DRIid draw = xdri_draw->driDrawable;
-   __DRIid read = xdri_read->driDrawable;
+   __DRIid draw = xdri_draw ? xdri_draw->driDrawable : 0;
+   __DRIid read = xdri_read ? xdri_read->driDrawable : 0;
    int scrn = DefaultScreen(disp->Xdpy);
 
    if (!_eglMakeCurrent(drv, dpy, d, r, context))
       return EGL_FALSE;
 
 
-   if (!xdri_ctx->driContext.bindContext(disp->Xdpy, scrn, draw, read,
+   if (xdri_ctx &&
+       !xdri_ctx->driContext.bindContext(disp->Xdpy, scrn, draw, read,
                                          &xdri_ctx->driContext)) {
       return EGL_FALSE;
    }
-- 
cgit v1.2.3


From 26df49cd7a67aa9dc26e9cf271d6ed121f08f95d Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 16 Jul 2008 10:34:50 -0600
Subject: egl: set EGL_SAMPLES, EGL_SAMPLE_BUFFERS config attribs

---
 src/egl/drivers/xdri/egl_xdri.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 2471c0425c..3681d9879a 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -203,6 +203,8 @@ create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
          SET_CONFIG_ATTRIB(&config->Base, EGL_ALPHA_SIZE, m->alphaBits);
          SET_CONFIG_ATTRIB(&config->Base, EGL_DEPTH_SIZE, m->depthBits);
          SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, m->stencilBits);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLES, m->samples);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLE_BUFFERS, m->sampleBuffers);
          SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, m->visualID);
          SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_TYPE, m->visualType);
          SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
-- 
cgit v1.2.3


From a88de345cd2e8d79de5f5da36223b1db6adf1b3e Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Mon, 18 Aug 2008 16:12:39 -0600
Subject: egl: don't put the example/demo driver in the lib/ dir

---
 src/egl/drivers/demo/Makefile | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/Makefile b/src/egl/drivers/demo/Makefile
index 5c05633df5..e5a7be2438 100644
--- a/src/egl/drivers/demo/Makefile
+++ b/src/egl/drivers/demo/Makefile
@@ -21,8 +21,7 @@ default: $(TOP)/$(LIB_DIR)/demodriver.so
 
 
 $(TOP)/$(LIB_DIR)/demodriver.so: $(OBJECTS)
-	$(TOP)/bin/mklib -o demodriver.so -noprefix \
-		-install $(TOP)/$(LIB_DIR) $(OBJECTS)
+	$(TOP)/bin/mklib -o demodriver.so -noprefix $(OBJECTS)
 
 
 
-- 
cgit v1.2.3


From c5f0fd95a43db4c69decd0fa54dc9eb2b2525690 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Wed, 27 Aug 2008 16:03:03 -0600
Subject: egl: free display ext data in xdri_eglTerminate().

---
 src/egl/drivers/xdri/egl_xdri.c | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 3681d9879a..6a271ff577 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -651,6 +651,35 @@ xdri_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
 }
 
 
+/*
+ * Do some clean-up that normally occurs in XCloseDisplay().
+ * We do this here because we're about to unload a dynamic library
+ * that has added some per-display extension data and callbacks.
+ * If we don't do this here we'll crash in XCloseDisplay() because it'll
+ * try to call functions that went away when the driver library was unloaded.
+ */
+static void
+FreeDisplayExt(Display *dpy)
+{
+   _XExtension *ext, *next;
+
+   for (ext = dpy->ext_procs; ext; ext = next) {
+      next = ext->next;
+      if (ext->close_display) {
+         ext->close_display(dpy, &ext->codes);
+         ext->close_display = NULL;
+      }
+      if (ext->name)
+         Xfree(ext->name);
+      Xfree(ext);
+   }
+   dpy->ext_procs = NULL;
+
+   _XFreeExtData (dpy->ext_data);
+   dpy->ext_data = NULL;
+}
+
+
 /**
  * Called via eglTerminate(), drv->API.Terminate().
  */
@@ -658,11 +687,16 @@ static EGLBoolean
 xdri_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 {
    struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
 
    _eglLog(_EGL_DEBUG, "XDRI: eglTerminate");
 
    _eglLog(_EGL_DEBUG, "XDRI: Closing %s", xdri_drv->dri_driver_name);
+
+   FreeDisplayExt(disp->Xdpy);
+
 #if 0
+   /* this causes a segfault for some reason */
    dlclose(xdri_drv->dri_driver_handle);
 #endif
    xdri_drv->dri_driver_handle = NULL;
-- 
cgit v1.2.3


From 102529cf1b6ab860d47e92a0bb58a0dce8b31cbc Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Mon, 1 Sep 2008 13:08:44 -0600
Subject: egl: CreatePbufferSurface, Bind/ReleaseTexImage functions

---
 src/egl/drivers/xdri/egl_xdri.c | 230 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 229 insertions(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 6a271ff577..9ff71588df 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -64,6 +64,12 @@
 #include "egllog.h"
 #include "eglsurface.h"
 
+#include <GL/gl.h>
+
+typedef void (*glGetIntegerv_t)(GLenum, GLint *);
+typedef void (*glBindTexture_t)(GLenum, GLuint);
+typedef void (*glCopyTexImage2D_t)(GLenum, GLint, GLenum, GLint, GLint,
+                                   GLint, GLint, GLint);
 
 
 #define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
@@ -99,6 +105,8 @@ struct xdri_egl_context
    _EGLContext Base;   /**< base class */
 
    __DRIcontext driContext;
+
+   GLint bound_tex_object;
 };
 
 
@@ -147,6 +155,11 @@ lookup_context(EGLContext c)
    return (struct xdri_egl_context *) context;
 }
 
+static struct xdri_egl_context *
+current_context(void)
+{
+   return (struct xdri_egl_context *) _eglGetCurrentContext();
+}
 
 /** Map EGLConfig handle to xdri_egl_config object */
 static struct xdri_egl_config *
@@ -210,7 +223,8 @@ create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
          SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
          SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
          /* XXX only window rendering allowed ATM */
-         SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
+         SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE,
+                           (EGL_WINDOW_BIT | EGL_PBUFFER_BIT));
 
          /* XXX possibly other things to init... */
 
@@ -854,6 +868,86 @@ xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 }
 
 
+/**
+ * Called via eglCreatePbufferSurface(), drv->API.CreatePbufferSurface().
+ */
+static EGLSurface
+xdri_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+                             const EGLint *attrib_list)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct xdri_egl_surface *xdri_surf;
+   struct xdri_egl_config *xdri_config = lookup_config(drv, dpy, config);
+   int scrn = DefaultScreen(disp->Xdpy);
+   Window window;
+
+   xdri_surf = CALLOC_STRUCT(xdri_egl_surface);
+   if (!xdri_surf)
+      return EGL_NO_SURFACE;
+
+   if (!_eglInitSurface(drv, dpy, &xdri_surf->Base, EGL_PBUFFER_BIT,
+                        config, attrib_list)) {
+      free(xdri_surf);
+      return EGL_FALSE;
+   }
+
+   /* Create a dummy X window */
+   {
+      Window root = RootWindow(disp->Xdpy, scrn);
+      XSetWindowAttributes attr;
+      XVisualInfo *visInfo, visTemplate;
+      unsigned mask;
+      int nvis;
+
+      visTemplate.visualid = xdri_config->mode->visualID;
+      visInfo = XGetVisualInfo(disp->Xdpy, VisualIDMask, &visTemplate, &nvis);
+      if (!visInfo) {
+         return EGL_NO_SURFACE;
+      }
+
+      attr.background_pixel = 0;
+      attr.border_pixel = 0;
+      attr.colormap = XCreateColormap(disp->Xdpy, root,
+                                      visInfo->visual, AllocNone);
+      attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+      mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+      
+      window = XCreateWindow(disp->Xdpy, root, 0, 0,
+                             xdri_surf->Base.Width, xdri_surf->Base.Height,
+                             0, visInfo->depth, InputOutput,
+                             visInfo->visual, mask, &attr);
+
+      /*XMapWindow(disp->Xdpy, window);*/
+      XFree(visInfo);
+
+      /* set hints and properties */
+      /*
+      sizehints.width = xdri_surf->Base.Width;
+      sizehints.height = xdri_surf->Base.Height;
+      sizehints.flags = USPosition;
+      XSetNormalHints(disp->Xdpy, window, &sizehints);
+      */
+   }
+
+   if (!XF86DRICreateDrawable(disp->Xdpy, scrn, window, &xdri_surf->hDrawable)) {
+      free(xdri_surf);
+      return EGL_FALSE;
+   }
+
+   xdri_surf->driDrawable = window;
+
+   _eglSaveSurface(&xdri_surf->Base);
+
+   _eglLog(_EGL_DEBUG,
+           "XDRI: CreatePbufferSurface handle %d  hDrawable %d",
+           _eglGetSurfaceHandle(&xdri_surf->Base),
+           (int) xdri_surf->hDrawable);
+
+   return _eglGetSurfaceHandle(&xdri_surf->Base);
+}
+
+
+
 static EGLBoolean
 xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
@@ -878,6 +972,137 @@ xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 }
 
 
+static EGLBoolean
+xdri_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+                     EGLint buffer)
+{
+   typedef int (*bind_teximage)(__DRInativeDisplay *dpy,
+                                __DRIid surface, __DRIscreen *psc,
+                                int buffer, int target, int format,
+                                int level, int mipmap);
+
+   bind_teximage egl_dri_bind_teximage;
+
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+
+   struct xdri_egl_context *xdri_ctx = current_context();
+   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+   struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
+
+   __DRIid dri_surf = xdri_surf ? xdri_surf->driDrawable : 0;
+
+   __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
+   __DRIscreen *psc = &scrnConf->driScreen;
+
+   /* this call just does error checking */
+   if (!_eglBindTexImage(drv, dpy, surface, buffer)) {
+      return EGL_FALSE;
+   }
+
+   egl_dri_bind_teximage =
+      (bind_teximage) dlsym(NULL, "egl_dri_bind_teximage");
+   if (egl_dri_bind_teximage) {
+      return egl_dri_bind_teximage(disp->Xdpy, dri_surf, psc,
+                                   buffer,
+                                   xdri_surf->Base.TextureTarget,
+                                   xdri_surf->Base.TextureFormat,
+                                   xdri_surf->Base.MipmapLevel,
+                                   xdri_surf->Base.MipmapTexture);
+   }
+   else {
+      /* fallback path based on glCopyTexImage() */
+      /* Get/save currently bound 2D texobj name */
+      glGetIntegerv_t glGetIntegerv_func = 
+         (glGetIntegerv_t) dlsym(NULL, "glGetIntegerv");
+      GLint curTexObj = 0;
+      if (glGetIntegerv_func) {
+         (*glGetIntegerv_func)(GL_TEXTURE_BINDING_2D, &curTexObj);
+      }
+      xdri_ctx->bound_tex_object = curTexObj;
+   }
+
+   return EGL_FALSE;
+}
+
+
+static EGLBoolean
+xdri_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+                        EGLint buffer)
+{
+   typedef int (*release_teximage)(__DRInativeDisplay *dpy,
+                                   __DRIid surface, __DRIscreen *psc,
+                                   int buffer, int target, int format,
+                                   int level, int mipmap);
+   release_teximage egl_dri_release_teximage;
+
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+
+   struct xdri_egl_context *xdri_ctx = current_context();
+   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+   struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
+
+   __DRIid dri_surf = xdri_surf ? xdri_surf->driDrawable : 0;
+
+   __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
+   __DRIscreen *psc = &scrnConf->driScreen;
+
+   /* this call just does error checking */
+   if (!_eglReleaseTexImage(drv, dpy, surface, buffer)) {
+      return EGL_FALSE;
+   }
+
+   egl_dri_release_teximage =
+      (release_teximage) dlsym(NULL, "egl_dri_release_teximage");
+   if (egl_dri_release_teximage) {
+      return egl_dri_release_teximage(disp->Xdpy, dri_surf, psc,
+                                      buffer,
+                                      xdri_surf->Base.TextureTarget,
+                                      xdri_surf->Base.TextureFormat,
+                                      xdri_surf->Base.MipmapLevel,
+                                      xdri_surf->Base.MipmapTexture);
+   }
+   else {
+      /* fallback path based on glCopyTexImage() */
+      glGetIntegerv_t glGetIntegerv_func = 
+         (glGetIntegerv_t) dlsym(NULL, "glGetIntegerv");
+      glBindTexture_t glBindTexture_func = 
+         (glBindTexture_t) dlsym(NULL, "glBindTexture");
+      glCopyTexImage2D_t glCopyTexImage2D_func = 
+         (glCopyTexImage2D_t) dlsym(NULL, "glCopyTexImage2D");
+      GLint curTexObj;
+      GLenum intFormat;
+      GLint level, width, height;
+
+      if (xdri_surf->Base.TextureFormat == EGL_TEXTURE_RGBA)
+         intFormat = GL_RGBA;
+      else
+         intFormat = GL_RGB;
+      level = xdri_surf->Base.MipmapLevel;
+      width = xdri_surf->Base.Width >> level;
+      height = xdri_surf->Base.Height >> level;
+
+      if (width > 0 && height > 0 &&
+          glGetIntegerv_func && glBindTexture_func && glCopyTexImage2D_func) {
+         glGetIntegerv_func(GL_TEXTURE_BINDING_2D, &curTexObj);
+         /* restore texobj from time of eglBindTexImage() call */
+         if (curTexObj != xdri_ctx->bound_tex_object)
+            glBindTexture_func(GL_TEXTURE_2D, xdri_ctx->bound_tex_object);
+         /* copy pbuffer image to texture */
+         glCopyTexImage2D_func(GL_TEXTURE_2D,
+                               level,
+                               intFormat,
+                               0, 0, width, height, 0);
+         /* restore current texture */
+         if (curTexObj != xdri_ctx->bound_tex_object)
+            glBindTexture_func(GL_TEXTURE_2D, curTexObj);
+      }
+      xdri_ctx->bound_tex_object = -1;
+   }
+
+   return EGL_FALSE;
+}
+
+
 static EGLBoolean
 xdri_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 {
@@ -931,7 +1156,10 @@ _eglMain(_EGLDisplay *disp, const char *args)
    xdri_drv->Base.API.CreateContext = xdri_eglCreateContext;
    xdri_drv->Base.API.MakeCurrent = xdri_eglMakeCurrent;
    xdri_drv->Base.API.CreateWindowSurface = xdri_eglCreateWindowSurface;
+   xdri_drv->Base.API.CreatePbufferSurface = xdri_eglCreatePbufferSurface;
    xdri_drv->Base.API.DestroySurface = xdri_eglDestroySurface;
+   xdri_drv->Base.API.BindTexImage = xdri_eglBindTexImage;
+   xdri_drv->Base.API.ReleaseTexImage = xdri_eglReleaseTexImage;
    xdri_drv->Base.API.SwapBuffers = xdri_eglSwapBuffers;
 
    xdri_drv->Base.ClientAPIsMask = (EGL_OPENGL_BIT |
-- 
cgit v1.2.3


From 912488a8d016834349273acac88be85a6afadcc0 Mon Sep 17 00:00:00 2001
From: Dima Zavin <dmitriyz@google.com>
Date: Thu, 21 Aug 2008 10:40:55 -0700
Subject: egl_dri/egl_xdri: Makefiles should use pkg-config to find libdrm.

---
 src/egl/drivers/dri/Makefile  | 2 +-
 src/egl/drivers/xdri/Makefile | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index bdc683a0c1..a41aca4370 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -8,7 +8,7 @@ include $(TOP)/configs/current
 INCLUDE_DIRS = \
 	-I. \
 	-I/usr/include \
-	-I/usr/include/drm \
+	$(shell pkg-config --cflags-only-I libdrm) \
 	-I$(TOP)/include \
 	-I$(TOP)/include/GL/internal \
 	-I$(TOP)/src/mesa \
diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index 252d00b6c2..9a2b7e0a9d 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -13,7 +13,7 @@ DRIVER_NAME = egl_xdri.so
 INCLUDE_DIRS = \
 	-I. \
 	-I/usr/include \
-	-I/usr/include/drm \
+	$(shell pkg-config --cflags-only-I libdrm) \
 	-I$(TOP)/include \
 	-I$(TOP)/include/GL/internal \
 	-I$(TOP)/src/mesa/glapi \
-- 
cgit v1.2.3


From 7d3d5fb7a57d01c99645f30189244287260239f0 Mon Sep 17 00:00:00 2001
From: Dima Zavin <dmitriyz@google.com>
Date: Thu, 21 Aug 2008 10:41:19 -0700
Subject: egl_xdri: Add the top-level lib dir so we link against the libGL we
 built.

---
 src/egl/drivers/xdri/Makefile | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index 9a2b7e0a9d..afd551dea5 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -48,6 +48,7 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 	$(TOP)/bin/mklib -o $(DRIVER_NAME) \
 		-noprefix \
 		-major 1 -minor 0 \
+		-L $(TOP)/$(LIB_DIR) \
 		-install $(TOP)/$(LIB_DIR) \
 		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
 
-- 
cgit v1.2.3


From 8015f3ae3b96d93e8b1338b8254bcbead45bb91a Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@tungstengraphics.com>
Date: Fri, 26 Sep 2008 11:18:58 +0100
Subject: egl: Add new EGL driver that wraps GLX.

---
 src/egl/drivers/glx/Makefile  |  74 ++++++
 src/egl/drivers/glx/egl_glx.c | 574 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 648 insertions(+)
 create mode 100644 src/egl/drivers/glx/Makefile
 create mode 100644 src/egl/drivers/glx/egl_glx.c

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/Makefile b/src/egl/drivers/glx/Makefile
new file mode 100644
index 0000000000..3cd5276513
--- /dev/null
+++ b/src/egl/drivers/glx/Makefile
@@ -0,0 +1,74 @@
+# src/egl/drivers/glx/Makefile
+
+# Build XEGL DRI driver loader library:  egl_glx.so
+
+
+TOP = ../../../..
+include $(TOP)/configs/current
+
+
+EXTRA_DEFINES = -DDEFAULT_DRIVER_DIR=\"$(DRI_DRIVER_SEARCH_DIR)\"
+
+DRIVER_NAME = egl_glx.so
+
+
+INCLUDE_DIRS = \
+	-I. \
+	-I/usr/include \
+	$(shell pkg-config --cflags-only-I libdrm) \
+	-I$(TOP)/include \
+	-I$(TOP)/include/GL/internal \
+	-I$(TOP)/src/mesa/glapi \
+	-I$(TOP)/src/mesa/drivers/dri/common \
+	-I$(TOP)/src/mesa/main \
+	-I$(TOP)/src/mesa \
+	-I$(TOP)/src/egl/main \
+	-I$(TOP)/src/glx/x11
+
+SOURCES = egl_glx.c
+
+OBJECTS = $(SOURCES:.c=.o)
+
+DRM_LIB = `pkg-config --libs libdrm`
+
+MISC_LIBS = -ldl -lXext -lGL
+
+
+.c.o:
+	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $(EXTRA_DEFINES) $< -o $@
+
+
+.PHONY: library
+
+
+default: depend library Makefile
+
+
+library: $(TOP)/$(LIB_DIR)/$(DRIVER_NAME)
+
+
+# Make the egl_glx.so library
+$(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
+	$(TOP)/bin/mklib -o $(DRIVER_NAME) \
+		-noprefix \
+		-major 1 -minor 0 \
+		-L$(TOP)/$(LIB_DIR) \
+		-install $(TOP)/$(LIB_DIR) \
+		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
+
+
+clean:
+	rm -f *.o
+	rm -f *.so
+	rm -f depend depend.bak
+
+
+depend: $(SOURCES) $(HEADERS)
+	@ echo "running $(MKDEP)"
+	@ rm -f depend
+	@ touch depend
+	$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDE_DIRS) \
+		$(SOURCES) $(HEADERS) >/dev/null 2>/dev/null
+
+include depend
+# DO NOT DELETE
diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
new file mode 100644
index 0000000000..4274493a5b
--- /dev/null
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -0,0 +1,574 @@
+/**************************************************************************
+ * 
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ **************************************************************************/
+
+
+/**
+ * This is an EGL driver that wraps GLX. This gives the benefit of being
+ * completely agnostic of the direct rendering implementation.
+ *
+ * Authors: Alan Hourihane <alanh@tungstengraphics.com>
+ */
+
+/*
+ * TODO: 
+ *
+ * Add GLXFBConfig support
+ * Pbuffer & Pixmap support
+ * test eglBind/ReleaseTexImage
+ */
+
+
+#include <assert.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "dlfcn.h"
+#include <X11/Xlib.h>
+#include <GL/gl.h>
+#include "glxclient.h"
+
+#define _EGL_PLATFORM_X
+
+#include "eglconfig.h"
+#include "eglcontext.h"
+#include "egldisplay.h"
+#include "egldriver.h"
+#include "eglglobals.h"
+#include "eglhash.h"
+#include "egllog.h"
+#include "eglsurface.h"
+
+#include <GL/gl.h>
+
+#define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
+
+static const EGLint all_apis = (EGL_OPENGL_ES_BIT |
+                                EGL_OPENGL_ES2_BIT |
+                                EGL_OPENVG_BIT |
+                                EGL_OPENGL_BIT);
+
+struct visual_attribs
+{
+   /* X visual attribs */
+   int id;
+   int klass;
+   int depth;
+   int redMask, greenMask, blueMask;
+   int colormapSize;
+   int bitsPerRGB;
+
+   /* GL visual attribs */
+   int supportsGL;
+   int transparentType;
+   int transparentRedValue;
+   int transparentGreenValue;
+   int transparentBlueValue;
+   int transparentAlphaValue;
+   int transparentIndexValue;
+   int bufferSize;
+   int level;
+   int render_type;
+   int doubleBuffer;
+   int stereo;
+   int auxBuffers;
+   int redSize, greenSize, blueSize, alphaSize;
+   int depthSize;
+   int stencilSize;
+   int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
+   int numSamples, numMultisample;
+   int visualCaveat;
+};
+
+/** subclass of _EGLDriver */
+struct GLX_egl_driver
+{
+   _EGLDriver Base;   /**< base class */
+
+   XVisualInfo *visuals;
+
+   /* GLXFBConfig *fbconfigs - todo */
+};
+
+
+/** subclass of _EGLContext */
+struct GLX_egl_context
+{
+   _EGLContext Base;   /**< base class */
+
+   GLXContext context;
+};
+
+
+/** subclass of _EGLSurface */
+struct GLX_egl_surface
+{
+   _EGLSurface Base;   /**< base class */
+
+   GLXDrawable drawable;
+};
+
+
+/** subclass of _EGLConfig */
+struct GLX_egl_config
+{
+   _EGLConfig Base;   /**< base class */
+};
+
+/** cast wrapper */
+static struct GLX_egl_driver *
+GLX_egl_driver(_EGLDriver *drv)
+{
+   return (struct GLX_egl_driver *) drv;
+}
+
+static struct GLX_egl_context *
+GLX_egl_context(_EGLContext *ctx)
+{
+   return (struct GLX_egl_context *) ctx;
+}
+
+static struct GLX_egl_surface *
+GLX_egl_surface(_EGLSurface *surf)
+{
+   return (struct GLX_egl_surface *) surf;
+}
+
+static GLboolean
+get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
+                   struct visual_attribs *attribs)
+{
+   const char *ext = glXQueryExtensionsString(dpy, vInfo->screen);
+   int rgba;
+
+   memset(attribs, 0, sizeof(struct visual_attribs));
+
+   attribs->id = vInfo->visualid;
+#if defined(__cplusplus) || defined(c_plusplus)
+   attribs->klass = vInfo->c_class;
+#else
+   attribs->klass = vInfo->class;
+#endif
+   attribs->depth = vInfo->depth;
+   attribs->redMask = vInfo->red_mask;
+   attribs->greenMask = vInfo->green_mask;
+   attribs->blueMask = vInfo->blue_mask;
+   attribs->colormapSize = vInfo->colormap_size;
+   attribs->bitsPerRGB = vInfo->bits_per_rgb;
+
+   if (glXGetConfig(dpy, vInfo, GLX_USE_GL, &attribs->supportsGL) != 0 ||
+       !attribs->supportsGL)
+      return GL_FALSE;
+   glXGetConfig(dpy, vInfo, GLX_BUFFER_SIZE, &attribs->bufferSize);
+   glXGetConfig(dpy, vInfo, GLX_LEVEL, &attribs->level);
+   glXGetConfig(dpy, vInfo, GLX_RGBA, &rgba);
+   if (!rgba)
+      return GL_FALSE;
+   attribs->render_type = GLX_RGBA_BIT;
+   
+   glXGetConfig(dpy, vInfo, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
+   glXGetConfig(dpy, vInfo, GLX_STEREO, &attribs->stereo);
+   glXGetConfig(dpy, vInfo, GLX_AUX_BUFFERS, &attribs->auxBuffers);
+   glXGetConfig(dpy, vInfo, GLX_RED_SIZE, &attribs->redSize);
+   glXGetConfig(dpy, vInfo, GLX_GREEN_SIZE, &attribs->greenSize);
+   glXGetConfig(dpy, vInfo, GLX_BLUE_SIZE, &attribs->blueSize);
+   glXGetConfig(dpy, vInfo, GLX_ALPHA_SIZE, &attribs->alphaSize);
+   glXGetConfig(dpy, vInfo, GLX_DEPTH_SIZE, &attribs->depthSize);
+   glXGetConfig(dpy, vInfo, GLX_STENCIL_SIZE, &attribs->stencilSize);
+   glXGetConfig(dpy, vInfo, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
+   glXGetConfig(dpy, vInfo, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
+   glXGetConfig(dpy, vInfo, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
+   glXGetConfig(dpy, vInfo, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
+
+   /* get transparent pixel stuff */
+   glXGetConfig(dpy, vInfo,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
+   if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
+     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
+     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
+     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
+     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
+   }
+   else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
+     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
+   }
+
+   /* multisample attribs */
+#ifdef GLX_ARB_multisample
+   if (ext && strstr(ext, "GLX_ARB_multisample")) {
+      glXGetConfig(dpy, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs->numMultisample);
+      glXGetConfig(dpy, vInfo, GLX_SAMPLES_ARB, &attribs->numSamples);
+   }
+#endif
+   else {
+      attribs->numSamples = 0;
+      attribs->numMultisample = 0;
+   }
+
+#if defined(GLX_EXT_visual_rating)
+   if (ext && strstr(ext, "GLX_EXT_visual_rating")) {
+      glXGetConfig(dpy, vInfo, GLX_VISUAL_CAVEAT_EXT, &attribs->visualCaveat);
+   }
+   else {
+      attribs->visualCaveat = GLX_NONE_EXT;
+   }
+#else
+   attribs->visualCaveat = 0;
+#endif
+
+   return GL_TRUE;
+}
+
+static EGLBoolean
+create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
+{
+   XVisualInfo theTemplate;
+   int numVisuals;
+   long mask;
+   int i;
+   struct visual_attribs attribs;
+
+   /* get list of all visuals on this screen */
+   theTemplate.screen = DefaultScreen(disp->Xdpy);
+   mask = VisualScreenMask;
+   GLX_drv->visuals = XGetVisualInfo(disp->Xdpy, mask, &theTemplate, &numVisuals);
+
+   for (i = 0; i < numVisuals; i++) {
+      struct GLX_egl_config *config;
+
+      if (!get_visual_attribs(disp->Xdpy, &GLX_drv->visuals[i], &attribs))
+	 continue;
+
+      if (attribs.doubleBuffer) {
+      config = CALLOC_STRUCT(GLX_egl_config);
+
+      _eglInitConfig(&config->Base, i+1);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_GREEN_SIZE, attribs.greenSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_BLUE_SIZE, attribs.blueSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_ALPHA_SIZE, attribs.alphaSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_DEPTH_SIZE, attribs.depthSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, attribs.stencilSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLES, attribs.numSamples);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLE_BUFFERS, attribs.numMultisample);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE,
+                        (EGL_WINDOW_BIT /*| EGL_PBUFFER_BIT | EGL_PIXMAP_BIT*/));
+
+      /* XXX possibly other things to init... */
+
+      _eglAddConfig(disp, &config->Base);
+      }
+   }
+
+   return EGL_TRUE;
+}
+
+/**
+ * Called via eglInitialize(), GLX_drv->API.Initialize().
+ */
+static EGLBoolean
+GLX_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
+                   EGLint *minor, EGLint *major)
+{
+   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+
+   _eglLog(_EGL_DEBUG, "XDRI: eglInitialize");
+
+   if (!disp->Xdpy) {
+      disp->Xdpy = XOpenDisplay(NULL);
+      if (!disp->Xdpy) {
+         _eglLog(_EGL_WARNING, "XDRI: XOpenDisplay failed");
+         return EGL_FALSE;
+      }
+   }
+
+   GLX_drv->Base.Initialized = EGL_TRUE;
+
+   GLX_drv->Base.Name = "GLX";
+
+   /* we're supporting EGL 1.4 */
+   *minor = 1;
+   *major = 4;
+
+   create_configs(disp, GLX_drv);
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * Called via eglTerminate(), drv->API.Terminate().
+ */
+static EGLBoolean
+GLX_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+
+   _eglLog(_EGL_DEBUG, "XDRI: eglTerminate");
+
+//   XCloseDisplay(disp->Xdpy);
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * Called via eglCreateContext(), drv->API.CreateContext().
+ */
+static EGLContext
+GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+                      EGLContext share_list, const EGLint *attrib_list)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct GLX_egl_context *GLX_ctx = CALLOC_STRUCT(GLX_egl_context);
+   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   struct GLX_egl_context *GLX_ctx_shared = NULL;
+   _EGLConfig *conf;
+
+   if (!GLX_ctx)
+      return EGL_NO_CONTEXT;
+
+   if (!_eglInitContext(drv, dpy, &GLX_ctx->Base, config, attrib_list)) {
+      free(GLX_ctx);
+      return EGL_NO_CONTEXT;
+   }
+
+   if (share_list != EGL_NO_CONTEXT) {
+      _EGLContext *shareCtx = _eglLookupContext(share_list);
+      if (!shareCtx) {
+         _eglError(EGL_BAD_CONTEXT, "eglCreateContext(share_list)");
+         return EGL_FALSE;
+      }
+      GLX_ctx_shared = GLX_egl_context(shareCtx);
+   }
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   assert(conf);
+
+   GLX_ctx->context = glXCreateContext(disp->Xdpy, &GLX_drv->visuals[(int)config-1], GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
+   if (!GLX_ctx->context)
+      return EGL_FALSE;
+
+   /* need to have a direct rendering context */
+   if (!glXIsDirect(disp->Xdpy, GLX_ctx->context))
+      return EGL_FALSE;
+
+   return _eglGetContextHandle(&GLX_ctx->Base);
+}
+
+
+/**
+ * Called via eglMakeCurrent(), drv->API.MakeCurrent().
+ */
+static EGLBoolean
+GLX_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
+                    EGLSurface r, EGLContext context)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLContext *ctx = _eglLookupContext(context);
+   _EGLSurface *dsurf = _eglLookupSurface(d);
+   _EGLSurface *rsurf = _eglLookupSurface(r);
+   struct GLX_egl_surface *GLX_dsurf = GLX_egl_surface(dsurf);
+   struct GLX_egl_surface *GLX_rsurf = GLX_egl_surface(rsurf);
+   struct GLX_egl_context *GLX_ctx = GLX_egl_context(ctx);
+
+   if (!_eglMakeCurrent(drv, dpy, d, r, context))
+      return EGL_FALSE;
+
+//   if (!glXMakeContextCurrent(disp->Xdpy, GLX_dsurf->drawable, GLX_rsurf->drawable, GLX_ctx->context))
+   if (!glXMakeCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
+      return EGL_FALSE;
+
+   return EGL_TRUE;
+}
+
+/** Get size of given window */
+static Status
+get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
+{
+   Window root;
+   Status stat;
+   int xpos, ypos;
+   unsigned int w, h, bw, depth;
+   stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
+   *width = w;
+   *height = h;
+   return stat;
+}
+
+/**
+ * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
+ */
+static EGLSurface
+GLX_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+                            NativeWindowType window, const EGLint *attrib_list)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct GLX_egl_surface *GLX_surf;
+   uint width, height;
+
+   GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
+   if (!GLX_surf)
+      return EGL_NO_SURFACE;
+
+   if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_WINDOW_BIT,
+                        config, attrib_list)) {
+      free(GLX_surf);
+      return EGL_FALSE;
+   }
+
+   _eglSaveSurface(&GLX_surf->Base);
+
+   GLX_surf->drawable = window;
+   get_drawable_size(disp->Xdpy, window, &width, &height);
+   GLX_surf->Base.Width = width;
+   GLX_surf->Base.Height = height;
+
+   return _eglGetSurfaceHandle(&GLX_surf->Base);
+}
+
+static EGLBoolean
+GLX_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLSurface *surf = _eglLookupSurface(surface);
+   return EGL_TRUE;
+   if (surf) {
+      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
+      if (surf->IsBound) {
+         surf->DeletePending = EGL_TRUE;
+      }
+      else {
+         free(surf);
+      }
+
+      return EGL_TRUE;
+   }
+   else {
+      _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
+      return EGL_FALSE;
+   }
+}
+
+
+static EGLBoolean
+GLX_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+                     EGLint buffer)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLSurface *surf = _eglLookupSurface(surface);
+   struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
+
+   /* buffer ?? */
+   glXBindTexImageEXT(disp->Xdpy, GLX_surf->drawable, GLX_FRONT_LEFT_EXT, NULL);
+
+   return EGL_TRUE;
+}
+
+
+static EGLBoolean
+GLX_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+                        EGLint buffer)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLSurface *surf = _eglLookupSurface(surface);
+   struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
+
+   /* buffer ?? */
+   glXReleaseTexImageEXT(disp->Xdpy, GLX_surf->drawable, GLX_FRONT_LEFT_EXT);
+
+   return EGL_TRUE;
+}
+
+
+static EGLBoolean
+GLX_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLSurface *surf = _eglLookupSurface(draw);
+   struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
+
+   _eglLog(_EGL_DEBUG, "XDRI: EGL SwapBuffers 0x%x",draw);
+
+   /* error checking step: */
+   if (!_eglSwapBuffers(drv, dpy, draw))
+      return EGL_FALSE;
+
+   glXSwapBuffers(disp->Xdpy, GLX_surf->drawable);
+
+   return EGL_TRUE;
+}
+
+/*
+ * Called from eglGetProcAddress() via drv->API.GetProcAddress().
+ */
+static _EGLProc
+GLX_eglGetProcAddress(const char *procname)
+{
+   return (_EGLProc)glXGetProcAddress((const GLubyte *)procname);   
+}
+
+
+/**
+ * This is the main entrypoint into the driver, called by libEGL.
+ * Create a new _EGLDriver object and init its dispatch table.
+ */
+_EGLDriver *
+_eglMain(_EGLDisplay *disp, const char *args)
+{
+   struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
+   if (!GLX_drv)
+      return NULL;
+
+   _eglInitDriverFallbacks(&GLX_drv->Base);
+   GLX_drv->Base.API.Initialize = GLX_eglInitialize;
+   GLX_drv->Base.API.Terminate = GLX_eglTerminate;
+   GLX_drv->Base.API.CreateContext = GLX_eglCreateContext;
+   GLX_drv->Base.API.MakeCurrent = GLX_eglMakeCurrent;
+   GLX_drv->Base.API.CreateWindowSurface = GLX_eglCreateWindowSurface;
+   GLX_drv->Base.API.DestroySurface = GLX_eglDestroySurface;
+   GLX_drv->Base.API.BindTexImage = GLX_eglBindTexImage;
+   GLX_drv->Base.API.ReleaseTexImage = GLX_eglReleaseTexImage;
+   GLX_drv->Base.API.SwapBuffers = GLX_eglSwapBuffers;
+   GLX_drv->Base.API.GetProcAddress = GLX_eglGetProcAddress;
+
+   GLX_drv->Base.ClientAPIsMask = all_apis;
+   GLX_drv->Base.Name = "GLX";
+
+   _eglLog(_EGL_DEBUG, "GLX: main(%s)", args);
+
+   /* set new DRI path to pick up EGL version (no mesa code), but don't
+    * override if one is already set.
+    */
+   setenv("LIBGL_DRIVERS_PATH", DEFAULT_DRIVER_DIR"/egl", 0);
+
+   return &GLX_drv->Base;
+}
-- 
cgit v1.2.3


From 192f45606a7c388862112b8d53a5983fb125fee3 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@tungstengraphics.com>
Date: Fri, 26 Sep 2008 12:18:16 +0100
Subject: egl: fudge with LIBGL_DRIVERS_PATH to pick up EGL specific DRI
 driver.

---
 src/egl/drivers/glx/egl_glx.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 4274493a5b..732d15cf11 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -545,6 +545,8 @@ _EGLDriver *
 _eglMain(_EGLDisplay *disp, const char *args)
 {
    struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
+   char *env;
+
    if (!GLX_drv)
       return NULL;
 
@@ -565,10 +567,17 @@ _eglMain(_EGLDisplay *disp, const char *args)
 
    _eglLog(_EGL_DEBUG, "GLX: main(%s)", args);
 
-   /* set new DRI path to pick up EGL version (no mesa code), but don't
-    * override if one is already set.
+   /* set new DRI path to pick up EGL version (which doesn't contain any mesa 
+    * code), but don't override if one is already set.
     */
-   setenv("LIBGL_DRIVERS_PATH", DEFAULT_DRIVER_DIR"/egl", 0);
+   env = getenv("LIBGL_DRIVERS_PATH");
+   if (env) {
+      if (!strstr(env, "egl")) {
+         sprintf(env, "%s/egl", env);
+         setenv("LIBGL_DRIVERS_PATH", env, 1);
+      }
+   } else
+      setenv("LIBGL_DRIVERS_PATH", DEFAULT_DRIVER_DIR"/egl", 0);
 
    return &GLX_drv->Base;
 }
-- 
cgit v1.2.3


From bb6a69d1696cacf828a3de21bc57678c0e4aa54a Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@tungstengraphics.com>
Date: Fri, 26 Sep 2008 12:27:29 +0100
Subject: egl: cleanup doublebuffer check

---
 src/egl/drivers/glx/egl_glx.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 732d15cf11..7e4967411e 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -191,6 +191,9 @@ get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
    attribs->render_type = GLX_RGBA_BIT;
    
    glXGetConfig(dpy, vInfo, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
+   if (!attribs->doubleBuffer)
+      return GL_FALSE;
+
    glXGetConfig(dpy, vInfo, GLX_STEREO, &attribs->stereo);
    glXGetConfig(dpy, vInfo, GLX_AUX_BUFFERS, &attribs->auxBuffers);
    glXGetConfig(dpy, vInfo, GLX_RED_SIZE, &attribs->redSize);
@@ -262,7 +265,6 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
       if (!get_visual_attribs(disp->Xdpy, &GLX_drv->visuals[i], &attribs))
 	 continue;
 
-      if (attribs.doubleBuffer) {
       config = CALLOC_STRUCT(GLX_egl_config);
 
       _eglInitConfig(&config->Base, i+1);
@@ -284,7 +286,6 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
       /* XXX possibly other things to init... */
 
       _eglAddConfig(disp, &config->Base);
-      }
    }
 
    return EGL_TRUE;
-- 
cgit v1.2.3


From e9c722b660ee8fc0aa73335d447f1dd8bced6fe2 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@tungstengraphics.com>
Date: Fri, 26 Sep 2008 14:19:18 +0100
Subject: st: change from ** to * for st_unreference_framebuffer()

---
 src/egl/drivers/xdri/egl_xdri.c                 | 2 +-
 src/gallium/winsys/drm/intel/dri/intel_screen.c | 2 +-
 src/gallium/winsys/drm/intel/egl/intel_device.c | 2 +-
 src/gallium/winsys/egl_xlib/egl_xlib.c          | 2 +-
 src/mesa/state_tracker/st_framebuffer.c         | 4 ++--
 src/mesa/state_tracker/st_public.h              | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 9ff71588df..83d4b86d98 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -959,7 +959,7 @@ xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
       }
       else {
          /*
-         st_unreference_framebuffer(&surf->Framebuffer);
+         st_unreference_framebuffer(surf->Framebuffer);
          */
          free(xdri_surf);
       }
diff --git a/src/gallium/winsys/drm/intel/dri/intel_screen.c b/src/gallium/winsys/drm/intel/dri/intel_screen.c
index 78b9a6db05..ed75368982 100644
--- a/src/gallium/winsys/drm/intel/dri/intel_screen.c
+++ b/src/gallium/winsys/drm/intel/dri/intel_screen.c
@@ -485,7 +485,7 @@ intelDestroyBuffer(__DRIdrawablePrivate * driDrawPriv)
 {
    struct intel_framebuffer *intelfb = intel_framebuffer(driDrawPriv);
    assert(intelfb->stfb);
-   st_unreference_framebuffer(&intelfb->stfb);
+   st_unreference_framebuffer(intelfb->stfb);
    free(intelfb);
 }
 
diff --git a/src/gallium/winsys/drm/intel/egl/intel_device.c b/src/gallium/winsys/drm/intel/egl/intel_device.c
index b9649cbec7..1964745c99 100644
--- a/src/gallium/winsys/drm/intel/egl/intel_device.c
+++ b/src/gallium/winsys/drm/intel/egl/intel_device.c
@@ -131,7 +131,7 @@ intel_destroy_drawable(struct egl_drm_drawable *drawable)
 	drawable->priv = NULL;
 
 	assert(intelfb->stfb);
-	st_unreference_framebuffer(&intelfb->stfb);
+	st_unreference_framebuffer(intelfb->stfb);
 	free(intelfb);
 	return TRUE;
 }
diff --git a/src/gallium/winsys/egl_xlib/egl_xlib.c b/src/gallium/winsys/egl_xlib/egl_xlib.c
index e9f821d276..477d766925 100644
--- a/src/gallium/winsys/egl_xlib/egl_xlib.c
+++ b/src/gallium/winsys/egl_xlib/egl_xlib.c
@@ -537,7 +537,7 @@ xlib_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
       }
       else {
          XFreeGC(surf->Dpy, surf->Gc);
-         st_unreference_framebuffer(&surf->Framebuffer);
+         st_unreference_framebuffer(surf->Framebuffer);
          free(surf);
       }
       return EGL_TRUE;
diff --git a/src/mesa/state_tracker/st_framebuffer.c b/src/mesa/state_tracker/st_framebuffer.c
index ec8928f200..c91a01746d 100644
--- a/src/mesa/state_tracker/st_framebuffer.c
+++ b/src/mesa/state_tracker/st_framebuffer.c
@@ -153,9 +153,9 @@ void st_resize_framebuffer( struct st_framebuffer *stfb,
 }
 
 
-void st_unreference_framebuffer( struct st_framebuffer **stfb )
+void st_unreference_framebuffer( struct st_framebuffer *stfb )
 {
-   _mesa_unreference_framebuffer((struct gl_framebuffer **) stfb);
+   _mesa_unreference_framebuffer((struct gl_framebuffer **) &stfb);
 }
 
 
diff --git a/src/mesa/state_tracker/st_public.h b/src/mesa/state_tracker/st_public.h
index 5cfb2e41f2..835c5b28d0 100644
--- a/src/mesa/state_tracker/st_public.h
+++ b/src/mesa/state_tracker/st_public.h
@@ -83,7 +83,7 @@ struct pipe_texture *st_get_framebuffer_texture(struct st_framebuffer *stfb,
 
 void *st_framebuffer_private( struct st_framebuffer *stfb );
 
-void st_unreference_framebuffer( struct st_framebuffer **stfb );
+void st_unreference_framebuffer( struct st_framebuffer *stfb );
 
 void st_make_current(struct st_context *st,
                      struct st_framebuffer *draw,
-- 
cgit v1.2.3


From 5b60d6d07b79124499a1d75a2830cf2e5949d1ad Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 26 Sep 2008 11:16:44 -0600
Subject: egl: remove space after -L flag

---
 src/egl/drivers/xdri/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index afd551dea5..a721b997e6 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -48,7 +48,7 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 	$(TOP)/bin/mklib -o $(DRIVER_NAME) \
 		-noprefix \
 		-major 1 -minor 0 \
-		-L $(TOP)/$(LIB_DIR) \
+		-L$(TOP)/$(LIB_DIR) \
 		-install $(TOP)/$(LIB_DIR) \
 		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
 
-- 
cgit v1.2.3


From 2cb213ff233ccd566e716aece45da78daa7d015a Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 26 Sep 2008 11:17:09 -0600
Subject: egl: check for null ptr/name

---
 src/egl/drivers/xdri/egl_xdri.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 83d4b86d98..3b3e312746 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -654,7 +654,10 @@ xdri_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
 
    xdri_drv->Base.Initialized = EGL_TRUE;
 
-   snprintf(name, sizeof(name), "X/DRI:%s", xdri_drv->dri_driver_name);
+   if (xdri_drv->dri_driver_name)
+      snprintf(name, sizeof(name), "X/DRI:%s", xdri_drv->dri_driver_name);
+   else
+      snprintf(name, sizeof(name), "X/DRI");
    xdri_drv->Base.Name = name;
 
    /* we're supporting EGL 1.4 */
-- 
cgit v1.2.3


From 7eacd11bf1743d47f07c2edd86507172d84b35fc Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@tungstengraphics.com>
Date: Mon, 27 Oct 2008 15:37:54 +0000
Subject: disable OPENGL_BIT

---
 src/egl/drivers/glx/egl_glx.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 7e4967411e..9a421b5a80 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -67,10 +67,10 @@
 
 #define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
 
-static const EGLint all_apis = (EGL_OPENGL_ES_BIT |
-                                EGL_OPENGL_ES2_BIT |
-                                EGL_OPENVG_BIT |
-                                EGL_OPENGL_BIT);
+static const EGLint all_apis = (EGL_OPENGL_ES_BIT
+                                | EGL_OPENGL_ES2_BIT
+                                | EGL_OPENVG_BIT
+                                /* | EGL_OPENGL_BIT */); /* can't do */
 
 struct visual_attribs
 {
-- 
cgit v1.2.3


From 90039225935a817ee6004dfabc8f5c404affc726 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Tue, 23 Dec 2008 13:20:18 +0000
Subject: egl: support GLXFBConfigs, pbuffers and pixmaps.

---
 src/egl/drivers/glx/egl_glx.c | 259 +++++++++++++++++++++++++++++++++++++++---
 1 file changed, 246 insertions(+), 13 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 9a421b5a80..ae3a4abd0a 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -36,8 +36,6 @@
 /*
  * TODO: 
  *
- * Add GLXFBConfig support
- * Pbuffer & Pixmap support
  * test eglBind/ReleaseTexImage
  */
 
@@ -110,8 +108,7 @@ struct GLX_egl_driver
    _EGLDriver Base;   /**< base class */
 
    XVisualInfo *visuals;
-
-   /* GLXFBConfig *fbconfigs - todo */
+   GLXFBConfig *fbconfigs;
 };
 
 
@@ -245,6 +242,99 @@ get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
    return GL_TRUE;
 }
 
+#ifdef GLX_VERSION_1_3
+
+static int
+glx_token_to_visual_class(int visual_type)
+{
+   switch (visual_type) {
+   case GLX_TRUE_COLOR:
+      return TrueColor;
+   case GLX_DIRECT_COLOR:
+      return DirectColor;
+   case GLX_PSEUDO_COLOR:
+      return PseudoColor;
+   case GLX_STATIC_COLOR:
+      return StaticColor;
+   case GLX_GRAY_SCALE:
+      return GrayScale;
+   case GLX_STATIC_GRAY:
+      return StaticGray;
+   case GLX_NONE:
+   default:
+      return None;
+   }
+}
+static GLboolean
+get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
+		     struct visual_attribs *attribs)
+{
+   int visual_type;
+
+   memset(attribs, 0, sizeof(struct visual_attribs));
+
+   /* We don't use the GLX_FBCONFIG_ID here */
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_VISUAL_ID, &attribs->id);
+
+#if 0
+   attribs->depth = vInfo->depth;
+   attribs->redMask = vInfo->red_mask;
+   attribs->greenMask = vInfo->green_mask;
+   attribs->blueMask = vInfo->blue_mask;
+   attribs->colormapSize = vInfo->colormap_size;
+   attribs->bitsPerRGB = vInfo->bits_per_rgb;
+#endif
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_X_VISUAL_TYPE, &visual_type);
+   attribs->klass = glx_token_to_visual_class(visual_type);
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_BUFFER_SIZE, &attribs->bufferSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_LEVEL, &attribs->level);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &attribs->render_type);
+   if (!(attribs->render_type & GLX_RGBA_BIT))
+      return GL_FALSE;
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
+   if (!attribs->doubleBuffer)
+      return GL_FALSE;
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_STEREO, &attribs->stereo);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_AUX_BUFFERS, &attribs->auxBuffers);
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_RED_SIZE, &attribs->redSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_GREEN_SIZE, &attribs->greenSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_BLUE_SIZE, &attribs->blueSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ALPHA_SIZE, &attribs->alphaSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_DEPTH_SIZE, &attribs->depthSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_STENCIL_SIZE, &attribs->stencilSize);
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
+
+   /* get transparent pixel stuff */
+   glXGetFBConfigAttrib(dpy, fbconfig,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
+   if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
+     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
+     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
+     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
+     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
+   }
+   else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
+     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
+   }
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLE_BUFFERS, &attribs->numMultisample);
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLES, &attribs->numSamples);
+
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_CONFIG_CAVEAT, &attribs->visualCaveat);
+
+   return GL_TRUE;
+}
+
+#endif
+
 static EGLBoolean
 create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
 {
@@ -254,6 +344,48 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
    int i;
    struct visual_attribs attribs;
 
+   GLX_drv->fbconfigs = NULL;
+
+#ifdef GLX_VERSION_1_3
+   /* get list of all fbconfigs on this screen */
+   GLX_drv->fbconfigs = glXGetFBConfigs(disp->Xdpy, DefaultScreen(disp->Xdpy), &numVisuals);
+
+   if (numVisuals == 0)
+      goto xvisual;
+
+   for (i = 0; i < numVisuals; i++) {
+      struct GLX_egl_config *config;
+
+      if (!get_fbconfig_attribs(disp->Xdpy, GLX_drv->fbconfigs[i], &attribs))
+         continue;
+
+      config = CALLOC_STRUCT(GLX_egl_config);
+
+      _eglInitConfig(&config->Base, i+1);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_GREEN_SIZE, attribs.greenSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_BLUE_SIZE, attribs.blueSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_ALPHA_SIZE, attribs.alphaSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_DEPTH_SIZE, attribs.depthSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_STENCIL_SIZE, attribs.stencilSize);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLES, attribs.numSamples);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLE_BUFFERS, attribs.numMultisample);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
+      SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE,
+                        (EGL_WINDOW_BIT | EGL_PBUFFER_BIT | EGL_PIXMAP_BIT));
+
+      /* XXX possibly other things to init... */
+
+      _eglAddConfig(disp, &config->Base);
+   }
+
+   goto end;
+#endif
+
+xvisual:
    /* get list of all visuals on this screen */
    theTemplate.screen = DefaultScreen(disp->Xdpy);
    mask = VisualScreenMask;
@@ -288,6 +420,7 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
       _eglAddConfig(disp, &config->Base);
    }
 
+end:
    return EGL_TRUE;
 }
 
@@ -301,12 +434,12 @@ GLX_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 
-   _eglLog(_EGL_DEBUG, "XDRI: eglInitialize");
+   _eglLog(_EGL_DEBUG, "GLX: eglInitialize");
 
    if (!disp->Xdpy) {
       disp->Xdpy = XOpenDisplay(NULL);
       if (!disp->Xdpy) {
-         _eglLog(_EGL_WARNING, "XDRI: XOpenDisplay failed");
+         _eglLog(_EGL_WARNING, "GLX: XOpenDisplay failed");
          return EGL_FALSE;
       }
    }
@@ -333,7 +466,7 @@ GLX_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 
-   _eglLog(_EGL_DEBUG, "XDRI: eglTerminate");
+   _eglLog(_EGL_DEBUG, "GLX: eglTerminate");
 
 //   XCloseDisplay(disp->Xdpy);
 
@@ -374,13 +507,20 @@ GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    conf = _eglLookupConfig(drv, dpy, config);
    assert(conf);
 
-   GLX_ctx->context = glXCreateContext(disp->Xdpy, &GLX_drv->visuals[(int)config-1], GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
+#ifdef GLX_VERSION_1_3
+   if (GLX_drv->fbconfigs)
+      GLX_ctx->context = glXCreateNewContext(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], GLX_RGBA_TYPE, GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
+   else
+#endif
+      GLX_ctx->context = glXCreateContext(disp->Xdpy, &GLX_drv->visuals[(int)config-1], GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
    if (!GLX_ctx->context)
       return EGL_FALSE;
 
-   /* need to have a direct rendering context */
+#if 1
+   /* (maybe?) need to have a direct rendering context */
    if (!glXIsDirect(disp->Xdpy, GLX_ctx->context))
       return EGL_FALSE;
+#endif
 
    return _eglGetContextHandle(&GLX_ctx->Base);
 }
@@ -404,9 +544,11 @@ GLX_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
    if (!_eglMakeCurrent(drv, dpy, d, r, context))
       return EGL_FALSE;
 
-//   if (!glXMakeContextCurrent(disp->Xdpy, GLX_dsurf->drawable, GLX_rsurf->drawable, GLX_ctx->context))
-   if (!glXMakeCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
-      return EGL_FALSE;
+#ifdef GLX_VERSION_1_3
+   if (!glXMakeContextCurrent(disp->Xdpy, GLX_dsurf->drawable, GLX_rsurf->drawable, GLX_ctx->context))
+#endif
+      if (!glXMakeCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
+         return EGL_FALSE;
 
    return EGL_TRUE;
 }
@@ -456,6 +598,85 @@ GLX_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    return _eglGetSurfaceHandle(&GLX_surf->Base);
 }
 
+#ifdef GLX_VERSION_1_3
+static EGLSurface
+GLX_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, 
+			   NativePixmapType pixmap, const EGLint *attrib_list)
+{
+   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct GLX_egl_surface *GLX_surf;
+   int i;
+
+   GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
+   if (!GLX_surf)
+      return EGL_NO_SURFACE;
+
+   if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_PIXMAP_BIT,
+                        config, attrib_list)) {
+      free(GLX_surf);
+      return EGL_FALSE;
+   }
+
+   _eglSaveSurface(&GLX_surf->Base);
+
+   for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
+      switch (attrib_list[i]) {
+         /* no attribs at this time */
+      default:
+         _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePixmapSurface");
+         return EGL_NO_SURFACE;
+      }
+   }
+
+   GLX_surf->drawable = glXCreatePixmap(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], pixmap, NULL);
+
+   return _eglGetSurfaceHandle(&GLX_surf->Base);
+}
+
+static EGLSurface
+GLX_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+                            const EGLint *attrib_list)
+{
+   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct GLX_egl_surface *GLX_surf;
+   int attribs[5];
+   int i = 0, j = 0;
+
+   GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
+   if (!GLX_surf)
+      return EGL_NO_SURFACE;
+
+   if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_PBUFFER_BIT,
+                        config, attrib_list)) {
+      free(GLX_surf);
+      return EGL_NO_SURFACE;
+   }
+
+   _eglSaveSurface(&GLX_surf->Base);
+
+   while(attrib_list[i] != EGL_NONE) {
+      switch (attrib_list[i]) {
+         case EGL_WIDTH:
+	    attribs[j++] = GLX_PBUFFER_WIDTH;
+	    attribs[j++] = attrib_list[i+1];
+	    break;
+	 case EGL_HEIGHT:
+	    attribs[j++] = GLX_PBUFFER_HEIGHT;
+	    attribs[j++] = attrib_list[i+1];
+	    break;
+      }
+      i++;
+   }
+   attribs[j++] = 0;
+
+   GLX_surf->drawable = glXCreatePbuffer(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], attribs);
+
+   return _eglGetSurfaceHandle(&GLX_surf->Base);
+}
+#endif
+
 static EGLBoolean
 GLX_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
@@ -517,7 +738,7 @@ GLX_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
    _EGLSurface *surf = _eglLookupSurface(draw);
    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 
-   _eglLog(_EGL_DEBUG, "XDRI: EGL SwapBuffers 0x%x",draw);
+   _eglLog(_EGL_DEBUG, "GLX: EGL SwapBuffers 0x%x",draw);
 
    /* error checking step: */
    if (!_eglSwapBuffers(drv, dpy, draw))
@@ -547,16 +768,28 @@ _eglMain(_EGLDisplay *disp, const char *args)
 {
    struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
    char *env;
+   int maj = 0, min = 0;
 
    if (!GLX_drv)
       return NULL;
 
+   glXQueryVersion(disp->Xdpy, &maj, &min);
+
    _eglInitDriverFallbacks(&GLX_drv->Base);
    GLX_drv->Base.API.Initialize = GLX_eglInitialize;
    GLX_drv->Base.API.Terminate = GLX_eglTerminate;
    GLX_drv->Base.API.CreateContext = GLX_eglCreateContext;
    GLX_drv->Base.API.MakeCurrent = GLX_eglMakeCurrent;
    GLX_drv->Base.API.CreateWindowSurface = GLX_eglCreateWindowSurface;
+#ifdef GLX_VERSION_1_3
+   if (maj == 1 && min >= 3) {
+      GLX_drv->Base.API.CreatePixmapSurface = GLX_eglCreatePixmapSurface;
+      GLX_drv->Base.API.CreatePbufferSurface = GLX_eglCreatePbufferSurface;
+      printf("GLX: Pbuffer and Pixmap support\n");
+   } else {
+      printf("GLX: No pbuffer or pixmap support\n");
+   }
+#endif
    GLX_drv->Base.API.DestroySurface = GLX_eglDestroySurface;
    GLX_drv->Base.API.BindTexImage = GLX_eglBindTexImage;
    GLX_drv->Base.API.ReleaseTexImage = GLX_eglReleaseTexImage;
-- 
cgit v1.2.3


From 04ef91af8bf77b483249719ddc02839acd192f42 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Tue, 23 Dec 2008 14:18:36 +0000
Subject: egl: fix startup query version

---
 src/egl/drivers/glx/egl_glx.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index ae3a4abd0a..2c0844665d 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -109,6 +109,8 @@ struct GLX_egl_driver
 
    XVisualInfo *visuals;
    GLXFBConfig *fbconfigs;
+
+   int glx_maj, glx_min;
 };
 
 
@@ -350,8 +352,10 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
    /* get list of all fbconfigs on this screen */
    GLX_drv->fbconfigs = glXGetFBConfigs(disp->Xdpy, DefaultScreen(disp->Xdpy), &numVisuals);
 
-   if (numVisuals == 0)
+   if (numVisuals == 0) {
+      GLX_drv->fbconfigs = NULL;
       goto xvisual;
+   }
 
    for (i = 0; i < numVisuals; i++) {
       struct GLX_egl_config *config;
@@ -444,6 +448,8 @@ GLX_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
       }
    }
 
+   glXQueryVersion(disp->Xdpy, &GLX_drv->glx_maj, &GLX_drv->glx_min);
+   
    GLX_drv->Base.Initialized = EGL_TRUE;
 
    GLX_drv->Base.Name = "GLX";
@@ -773,8 +779,6 @@ _eglMain(_EGLDisplay *disp, const char *args)
    if (!GLX_drv)
       return NULL;
 
-   glXQueryVersion(disp->Xdpy, &maj, &min);
-
    _eglInitDriverFallbacks(&GLX_drv->Base);
    GLX_drv->Base.API.Initialize = GLX_eglInitialize;
    GLX_drv->Base.API.Terminate = GLX_eglTerminate;
@@ -782,7 +786,7 @@ _eglMain(_EGLDisplay *disp, const char *args)
    GLX_drv->Base.API.MakeCurrent = GLX_eglMakeCurrent;
    GLX_drv->Base.API.CreateWindowSurface = GLX_eglCreateWindowSurface;
 #ifdef GLX_VERSION_1_3
-   if (maj == 1 && min >= 3) {
+   if (GLX_drv->glx_maj == 1 && GLX_drv->glx_min >= 3) {
       GLX_drv->Base.API.CreatePixmapSurface = GLX_eglCreatePixmapSurface;
       GLX_drv->Base.API.CreatePbufferSurface = GLX_eglCreatePbufferSurface;
       printf("GLX: Pbuffer and Pixmap support\n");
-- 
cgit v1.2.3


From 53ce80e7cc466efae349e3a83007345bd299acd6 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Tue, 23 Dec 2008 15:33:46 +0000
Subject: egl: fix egl closure

---
 src/egl/drivers/glx/egl_glx.c | 31 +++++++++++++++++++++++++++++--
 1 file changed, 29 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 2c0844665d..c93e568cff 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -446,7 +446,7 @@ GLX_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
          _eglLog(_EGL_WARNING, "GLX: XOpenDisplay failed");
          return EGL_FALSE;
       }
-   }
+   } 
 
    glXQueryVersion(disp->Xdpy, &GLX_drv->glx_maj, &GLX_drv->glx_min);
    
@@ -463,6 +463,33 @@ GLX_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
    return EGL_TRUE;
 }
 
+/*
+ * Do some clean-up that normally occurs in XCloseDisplay().
+ * We do this here because we're about to unload a dynamic library
+ * that has added some per-display extension data and callbacks.
+ * If we don't do this here we'll crash in XCloseDisplay() because it'll
+ * try to call functions that went away when the driver library was unloaded.
+ */
+static void
+FreeDisplayExt(Display *dpy)
+{
+   _XExtension *ext, *next;
+
+   for (ext = dpy->ext_procs; ext; ext = next) {
+      next = ext->next;
+      if (ext->close_display) {
+         ext->close_display(dpy, &ext->codes);
+         ext->close_display = NULL;
+      }
+      if (ext->name)
+         Xfree(ext->name);
+      Xfree(ext);
+   }
+   dpy->ext_procs = NULL;
+
+   _XFreeExtData (dpy->ext_data);
+   dpy->ext_data = NULL;
+}
 
 /**
  * Called via eglTerminate(), drv->API.Terminate().
@@ -474,7 +501,7 @@ GLX_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 
    _eglLog(_EGL_DEBUG, "GLX: eglTerminate");
 
-//   XCloseDisplay(disp->Xdpy);
+   FreeDisplayExt(disp->Xdpy);
 
    return EGL_TRUE;
 }
-- 
cgit v1.2.3


From 3ef419f4a5d0c5bb6720196ae6cfe3002d4aabc8 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Wed, 14 Jan 2009 11:34:29 +0000
Subject: egl: fix makecurrent with null drawable/context

---
 src/egl/drivers/glx/egl_glx.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index c93e568cff..8ba70ba7a6 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -578,7 +578,7 @@ GLX_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
       return EGL_FALSE;
 
 #ifdef GLX_VERSION_1_3
-   if (!glXMakeContextCurrent(disp->Xdpy, GLX_dsurf->drawable, GLX_rsurf->drawable, GLX_ctx->context))
+   if (!glXMakeContextCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_rsurf ? GLX_rsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
 #endif
       if (!glXMakeCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
          return EGL_FALSE;
-- 
cgit v1.2.3


From 1e81855566b8c9957b39ee4612cec24bea591785 Mon Sep 17 00:00:00 2001
From: Johannes Engel <jcnengel@googlemail.com>
Date: Wed, 11 Feb 2009 11:31:05 +0100
Subject: Add install target for egl

Signed-off-by: Johannes Engel <jcnengel@googlemail.com>
Acked-by: Jakob Bornecrantz <jakob@vmware.com>
---
 src/egl/Makefile              | 7 +++++++
 src/egl/drivers/Makefile      | 6 ++++++
 src/egl/drivers/demo/Makefile | 4 +++-
 src/egl/drivers/dri/Makefile  | 2 ++
 src/egl/drivers/glx/Makefile  | 2 ++
 src/egl/drivers/xdri/Makefile | 2 ++
 src/egl/main/Makefile         | 4 +++-
 7 files changed, 25 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/Makefile b/src/egl/Makefile
index 024453f8bb..5b09e178c6 100644
--- a/src/egl/Makefile
+++ b/src/egl/Makefile
@@ -1,6 +1,7 @@
 # src/egl/Makefile
 
 TOP = ../..
+include $(TOP)/configs/current
 
 SUBDIRS = main drivers
 
@@ -15,6 +16,12 @@ subdirs:
 		fi \
 	done
 
+install:
+	@for dir in $(SUBDIRS) ; do \
+		if [ -d $$dir ] ; then \
+			(cd $$dir && $(MAKE) install) || exit 1 ; \
+		fi \
+	done
 
 clean:
 	-@for dir in $(SUBDIRS) ; do \
diff --git a/src/egl/drivers/Makefile b/src/egl/drivers/Makefile
index f0538f563f..dde4ee2255 100644
--- a/src/egl/drivers/Makefile
+++ b/src/egl/drivers/Makefile
@@ -16,6 +16,12 @@ subdirs:
 		fi \
 	done
 
+install:
+	@ for dir in $(SUBDIRS) ; do \
+		if [ -d $$dir ] ; then \
+			(cd $$dir ; $(MAKE) install) || exit 1 ; \
+		fi \
+	done
 
 clean:
 	@for dir in $(SUBDIRS) ; do \
diff --git a/src/egl/drivers/demo/Makefile b/src/egl/drivers/demo/Makefile
index 6ca25aa5d6..d908cdb4b2 100644
--- a/src/egl/drivers/demo/Makefile
+++ b/src/egl/drivers/demo/Makefile
@@ -25,7 +25,9 @@ $(TOP)/$(LIB_DIR)/demodriver.so: $(OBJECTS)
 		-ldflags '$(LDFLAGS)' -install $(TOP)/$(LIB_DIR) \
 		$(OBJECTS)
 
-
+install:
+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(INSTALL) $(TOP)/$(LIB_DIR)/demodriver.so $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	-rm -f *.o
diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index d7eba653b2..be2f9b6bea 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -48,6 +48,8 @@ $(TOP)/$(LIB_DIR)/libEGLdri.so: $(OBJECTS)
 		-major 1 -minor 0 \
 		-install $(TOP)/$(LIB_DIR) -ldl $(OBJECTS) $(LIBS)
 
+install: $(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(INSTALL) $(TOP)/$(LIB_DIR)/libEGLdri.so $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	-rm -f *.o
diff --git a/src/egl/drivers/glx/Makefile b/src/egl/drivers/glx/Makefile
index 3cd5276513..090a230ca3 100644
--- a/src/egl/drivers/glx/Makefile
+++ b/src/egl/drivers/glx/Makefile
@@ -56,6 +56,8 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 		-install $(TOP)/$(LIB_DIR) \
 		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
 
+install: $(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(INSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	rm -f *.o
diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index a721b997e6..db4b710002 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -52,6 +52,8 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 		-install $(TOP)/$(LIB_DIR) \
 		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
 
+install: $(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(INSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	rm -f *.o
diff --git a/src/egl/main/Makefile b/src/egl/main/Makefile
index 8ea60c0199..89b4a200bc 100644
--- a/src/egl/main/Makefile
+++ b/src/egl/main/Makefile
@@ -65,7 +65,9 @@ $(TOP)/$(LIB_DIR)/libEGL.so: $(OBJECTS)
 		-major 1 -minor 0 \
 		-install $(TOP)/$(LIB_DIR) -ldl $(OBJECTS) $(LIBS)
 
-
+install:
+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(INSTALL) $(TOP)/$(LIB_DIR)/libEGL.so* $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	-rm -f *.o *.so*
-- 
cgit v1.2.3


From 44054aca36580440f956f0cbcdd5f31de8e3a7e2 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Thu, 19 Feb 2009 11:01:01 +0000
Subject: egl: error checking

---
 src/egl/drivers/glx/egl_glx.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 8ba70ba7a6..72c1eefbc8 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -277,6 +277,8 @@ get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
 
    /* We don't use the GLX_FBCONFIG_ID here */
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_VISUAL_ID, &attribs->id);
+   if (attribs->id == 0)
+      return GL_FALSE;
 
 #if 0
    attribs->depth = vInfo->depth;
@@ -344,6 +346,7 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
    int numVisuals;
    long mask;
    int i;
+   int egl_configs = 1;
    struct visual_attribs attribs;
 
    GLX_drv->fbconfigs = NULL;
@@ -365,7 +368,7 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
 
       config = CALLOC_STRUCT(GLX_egl_config);
 
-      _eglInitConfig(&config->Base, i+1);
+      _eglInitConfig(&config->Base, egl_configs++);
       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
       SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
@@ -403,7 +406,7 @@ xvisual:
 
       config = CALLOC_STRUCT(GLX_egl_config);
 
-      _eglInitConfig(&config->Base, i+1);
+      _eglInitConfig(&config->Base, egl_configs++);
       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
       SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
-- 
cgit v1.2.3


From 526e8451455d43c815828e7dd319defcd518631f Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Thu, 19 Feb 2009 13:07:37 +0000
Subject: egl: glx updates for FBconfigs

---
 src/egl/drivers/glx/egl_glx.c | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 72c1eefbc8..3db63a920e 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -267,18 +267,18 @@ glx_token_to_visual_class(int visual_type)
       return None;
    }
 }
-static GLboolean
+static int
 get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
 		     struct visual_attribs *attribs)
 {
    int visual_type;
+   int fbconfig_id;
 
    memset(attribs, 0, sizeof(struct visual_attribs));
 
-   /* We don't use the GLX_FBCONFIG_ID here */
+   glXGetFBConfigAttrib(dpy, fbconfig, GLX_FBCONFIG_ID, &fbconfig_id);
+
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_VISUAL_ID, &attribs->id);
-   if (attribs->id == 0)
-      return GL_FALSE;
 
 #if 0
    attribs->depth = vInfo->depth;
@@ -296,11 +296,11 @@ get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_LEVEL, &attribs->level);
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &attribs->render_type);
    if (!(attribs->render_type & GLX_RGBA_BIT))
-      return GL_FALSE;
+      return 0;
 
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
    if (!attribs->doubleBuffer)
-      return GL_FALSE;
+      return 0;
 
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_STEREO, &attribs->stereo);
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_AUX_BUFFERS, &attribs->auxBuffers);
@@ -334,7 +334,12 @@ get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
 
    glXGetFBConfigAttrib(dpy, fbconfig, GLX_CONFIG_CAVEAT, &attribs->visualCaveat);
 
-   return GL_TRUE;
+   if (attribs->id == 0) {
+      attribs->id = fbconfig_id;
+      return EGL_PBUFFER_BIT | EGL_PIXMAP_BIT;
+   }
+
+   return EGL_WINDOW_BIT;
 }
 
 #endif
@@ -362,13 +367,15 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
 
    for (i = 0; i < numVisuals; i++) {
       struct GLX_egl_config *config;
+      int bit;
 
-      if (!get_fbconfig_attribs(disp->Xdpy, GLX_drv->fbconfigs[i], &attribs))
+      bit = get_fbconfig_attribs(disp->Xdpy, GLX_drv->fbconfigs[i], &attribs);
+      if (!bit)
          continue;
 
       config = CALLOC_STRUCT(GLX_egl_config);
 
-      _eglInitConfig(&config->Base, egl_configs++);
+      _eglInitConfig(&config->Base, (i+1));
       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
       SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
@@ -381,8 +388,7 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
       SET_CONFIG_ATTRIB(&config->Base, EGL_SAMPLE_BUFFERS, attribs.numMultisample);
       SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
       SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
-      SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE,
-                        (EGL_WINDOW_BIT | EGL_PBUFFER_BIT | EGL_PIXMAP_BIT));
+      SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE, bit);
 
       /* XXX possibly other things to init... */
 
@@ -406,7 +412,7 @@ xvisual:
 
       config = CALLOC_STRUCT(GLX_egl_config);
 
-      _eglInitConfig(&config->Base, egl_configs++);
+      _eglInitConfig(&config->Base, (i+1));
       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
       SET_CONFIG_ATTRIB(&config->Base, EGL_RED_SIZE, attribs.redSize);
-- 
cgit v1.2.3


From 9ed03af8c0a8e6af54e827f15778d8b567492c89 Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Thu, 19 Mar 2009 15:34:45 +0000
Subject: egl: try harder for eglGetProcAddress()

---
 src/egl/drivers/glx/egl_glx.c | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 3db63a920e..e2b3b4f67a 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -797,7 +797,20 @@ GLX_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 static _EGLProc
 GLX_eglGetProcAddress(const char *procname)
 {
-   return (_EGLProc)glXGetProcAddress((const GLubyte *)procname);   
+   /* This is a bit of a hack to get at the gallium/Mesa state tracker
+    *     * function st_get_proc_address().  This will probably change at
+    *         * some point.
+    *             */
+   _EGLProc (*get_proc_addr)(const char *procname);
+   get_proc_addr = dlsym(NULL, "st_get_proc_address");
+   if (get_proc_addr)
+      return get_proc_addr(procname);
+
+   get_proc_addr = glXGetProcAddress((const GLubyte *)procname);
+   if (get_proc_addr)
+      return get_proc_addr(procname);
+
+   return (_EGLProc)dlsym(NULL, procname);
 }
 
 
-- 
cgit v1.2.3


From a57d7edf069d1d161a45825021a7cf4d825fb88f Mon Sep 17 00:00:00 2001
From: Alan Hourihane <alanh@vmware.com>
Date: Thu, 19 Mar 2009 15:39:01 +0000
Subject: egl: fix comment

---
 src/egl/drivers/glx/egl_glx.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index e2b3b4f67a..155caa413c 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -798,9 +798,9 @@ static _EGLProc
 GLX_eglGetProcAddress(const char *procname)
 {
    /* This is a bit of a hack to get at the gallium/Mesa state tracker
-    *     * function st_get_proc_address().  This will probably change at
-    *         * some point.
-    *             */
+    * function st_get_proc_address().  This will probably change at
+    * some point.
+    */
    _EGLProc (*get_proc_addr)(const char *procname);
    get_proc_addr = dlsym(NULL, "st_get_proc_address");
    if (get_proc_addr)
-- 
cgit v1.2.3


From c97e5e1fc157ca5876241ee16c520d924535b4f0 Mon Sep 17 00:00:00 2001
From: Carl-Johan Kjellander <carljohan@kjellander.com>
Date: Thu, 26 Mar 2009 19:20:11 +0000
Subject: egl: Fix newline typo in Makefiles

---
 src/egl/drivers/dri/Makefile  | 3 ++-
 src/egl/drivers/glx/Makefile  | 3 ++-
 src/egl/drivers/xdri/Makefile | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index be2f9b6bea..4041d5c906 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -48,7 +48,8 @@ $(TOP)/$(LIB_DIR)/libEGLdri.so: $(OBJECTS)
 		-major 1 -minor 0 \
 		-install $(TOP)/$(LIB_DIR) -ldl $(OBJECTS) $(LIBS)
 
-install: $(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+install:
+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) $(TOP)/$(LIB_DIR)/libEGLdri.so $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
diff --git a/src/egl/drivers/glx/Makefile b/src/egl/drivers/glx/Makefile
index 090a230ca3..5f041a268f 100644
--- a/src/egl/drivers/glx/Makefile
+++ b/src/egl/drivers/glx/Makefile
@@ -56,7 +56,8 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 		-install $(TOP)/$(LIB_DIR) \
 		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
 
-install: $(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+install:
+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index db4b710002..eb83867b71 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -52,7 +52,8 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 		-install $(TOP)/$(LIB_DIR) \
 		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
 
-install: $(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
+install:
+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
-- 
cgit v1.2.3


From cc68cd20d9fbb87486eb69a50fa14a3d6b9c6798 Mon Sep 17 00:00:00 2001
From: Dan Nicholson <dbn.lists@gmail.com>
Date: Wed, 29 Apr 2009 20:33:50 -0700
Subject: egl: Don't install demodriver

I don't think anyone besides a developer would ever want to use the demo
egl driver. Furthermore, egl would only ever load demodriver if it was
set via EGL_DRIVER in the environment. In that case, I think you can
point it to your mesa source directory.
---
 src/egl/drivers/demo/Makefile | 2 --
 1 file changed, 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/Makefile b/src/egl/drivers/demo/Makefile
index d908cdb4b2..26694c92fa 100644
--- a/src/egl/drivers/demo/Makefile
+++ b/src/egl/drivers/demo/Makefile
@@ -26,8 +26,6 @@ $(TOP)/$(LIB_DIR)/demodriver.so: $(OBJECTS)
 		$(OBJECTS)
 
 install:
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) $(TOP)/$(LIB_DIR)/demodriver.so $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	-rm -f *.o
-- 
cgit v1.2.3


From bc302b2a33ceffe454bcf443daa0ac1edc118e9b Mon Sep 17 00:00:00 2001
From: Dan Nicholson <dbn.lists@gmail.com>
Date: Fri, 22 May 2009 09:39:02 -0700
Subject: Use separate $(MINSTALL) for installing libraries

The special feature of bin/minstall to copy symlinks is only ever needed
when installing libraries which may have .so symlinks. All the headers
and directories can use a normal install program.

These two modes are separated as $(INSTALL) and $(MINSTALL) to allow the
user (or autoconf) to override installing normal files as they please.
An autoconf check for the install program has been added and will be
used in preference to minstall when available.

Fixes bug 16053.
---
 configs/autoconf.in                         | 1 +
 configs/default                             | 5 ++++-
 configure.ac                                | 5 +++++
 src/egl/drivers/dri/Makefile                | 2 +-
 src/egl/drivers/glx/Makefile                | 2 +-
 src/egl/drivers/xdri/Makefile               | 2 +-
 src/egl/main/Makefile                       | 2 +-
 src/gallium/winsys/drm/Makefile.template    | 2 +-
 src/gallium/winsys/drm/intel/xorg/Makefile  | 2 +-
 src/gallium/winsys/drm/radeon/xorg/Makefile | 2 +-
 src/gallium/winsys/egl_xlib/Makefile        | 2 +-
 src/gallium/winsys/xlib/Makefile            | 2 +-
 src/glu/Makefile                            | 2 +-
 src/glut/fbdev/Makefile                     | 2 +-
 src/glut/glx/Makefile                       | 2 +-
 src/glut/mini/Makefile                      | 2 +-
 src/glw/Makefile                            | 2 +-
 src/mesa/Makefile                           | 4 ++--
 src/mesa/drivers/dri/Makefile.template      | 2 +-
 19 files changed, 27 insertions(+), 18 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/configs/autoconf.in b/configs/autoconf.in
index b61d7f33f0..77422e3fe5 100644
--- a/configs/autoconf.in
+++ b/configs/autoconf.in
@@ -31,6 +31,7 @@ SHELL = @SHELL@
 MKLIB_OPTIONS = @MKLIB_OPTIONS@
 MKDEP = @MKDEP@
 MKDEP_OPTIONS = @MKDEP_OPTIONS@
+INSTALL = @INSTALL@
 
 # Python and flags (generally only needed by the developers)
 PYTHON2 = python
diff --git a/configs/default b/configs/default
index d2ea3b2487..dc28be37dd 100644
--- a/configs/default
+++ b/configs/default
@@ -36,7 +36,10 @@ MKLIB_OPTIONS =
 MKDEP = makedepend
 MKDEP_OPTIONS = -fdepend
 MAKE = make
-INSTALL = $(SHELL) $(TOP)/bin/minstall
+
+# Use MINSTALL for installing libraries, INSTALL for everything else
+MINSTALL = $(SHELL) $(TOP)/bin/minstall
+INSTALL = $(MINSTALL)
 
 # Tools for regenerating glapi (generally only needed by the developers)
 PYTHON2 = python
diff --git a/configure.ac b/configure.ac
index 24aa13a7ca..772fb29973 100644
--- a/configure.ac
+++ b/configure.ac
@@ -29,6 +29,11 @@ AC_CHECK_PROGS([MAKE], [gmake make])
 AC_PATH_PROG([MKDEP], [makedepend])
 AC_PATH_PROG([SED], [sed])
 
+dnl Our fallback install-sh is a symlink to minstall. Use the existing
+dnl configuration in that case.
+AC_PROG_INSTALL
+test "x$INSTALL" = "x$ac_install_sh" && INSTALL='$(MINSTALL)'
+
 dnl We need a POSIX shell for parts of the build. Assume we have one
 dnl in most cases.
 case "$host_os" in
diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index 4041d5c906..567edfae97 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -50,7 +50,7 @@ $(TOP)/$(LIB_DIR)/libEGLdri.so: $(OBJECTS)
 
 install:
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) $(TOP)/$(LIB_DIR)/libEGLdri.so $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/libEGLdri.so $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	-rm -f *.o
diff --git a/src/egl/drivers/glx/Makefile b/src/egl/drivers/glx/Makefile
index 5f041a268f..20ef0352ad 100644
--- a/src/egl/drivers/glx/Makefile
+++ b/src/egl/drivers/glx/Makefile
@@ -58,7 +58,7 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 
 install:
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	rm -f *.o
diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index eb83867b71..8a14027fc7 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -54,7 +54,7 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 
 install:
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	rm -f *.o
diff --git a/src/egl/main/Makefile b/src/egl/main/Makefile
index 8cfa25ca16..cddba9f088 100644
--- a/src/egl/main/Makefile
+++ b/src/egl/main/Makefile
@@ -66,7 +66,7 @@ $(TOP)/$(LIB_DIR)/libEGL.so: $(OBJECTS)
 
 install: default
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) $(TOP)/$(LIB_DIR)/libEGL.so* $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/libEGL.so* $(DESTDIR)$(INSTALL_LIB_DIR)
 
 clean:
 	-rm -f *.o *.so*
diff --git a/src/gallium/winsys/drm/Makefile.template b/src/gallium/winsys/drm/Makefile.template
index 9f92cb4207..985e5a861f 100644
--- a/src/gallium/winsys/drm/Makefile.template
+++ b/src/gallium/winsys/drm/Makefile.template
@@ -118,7 +118,7 @@ clean:
 
 install: $(LIBNAME)
 	$(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
-	$(INSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
+	$(MINSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
 
 
 include depend
diff --git a/src/gallium/winsys/drm/intel/xorg/Makefile b/src/gallium/winsys/drm/intel/xorg/Makefile
index b1b6b9362b..d9aa5d54e1 100644
--- a/src/gallium/winsys/drm/intel/xorg/Makefile
+++ b/src/gallium/winsys/drm/intel/xorg/Makefile
@@ -39,6 +39,6 @@ clean:
 
 install:
 	$(INSTALL) -d $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
-	$(INSTALL) -m 755 $(TARGET) $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
+	$(MINSTALL) -m 755 $(TARGET) $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
 
 .PHONY	= all clean install
diff --git a/src/gallium/winsys/drm/radeon/xorg/Makefile b/src/gallium/winsys/drm/radeon/xorg/Makefile
index 6ffd4a3a54..0241625f69 100644
--- a/src/gallium/winsys/drm/radeon/xorg/Makefile
+++ b/src/gallium/winsys/drm/radeon/xorg/Makefile
@@ -37,6 +37,6 @@ clean:
 
 install:
 	$(INSTALL) -d $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
-	$(INSTALL) -m 755 $(TARGET) $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
+	$(MINSTALL) -m 755 $(TARGET) $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
 
 .PHONY	= all clean install
diff --git a/src/gallium/winsys/egl_xlib/Makefile b/src/gallium/winsys/egl_xlib/Makefile
index 8646ee3b52..a33a50ec22 100644
--- a/src/gallium/winsys/egl_xlib/Makefile
+++ b/src/gallium/winsys/egl_xlib/Makefile
@@ -74,7 +74,7 @@ depend: $(ALL_SOURCES)
 install: default
 	$(INSTALL) -d $(INSTALL_DIR)/$(LIB_DIR)
 	@if [ -e $(TOP)/$(LIB_DIR) ]; then \
-		$(INSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(INSTALL_DIR)/$(LIB_DIR); \
+		$(MINSTALL) $(TOP)/$(LIB_DIR)/$(DRIVER_NAME) $(INSTALL_DIR)/$(LIB_DIR); \
 	fi
 
 
diff --git a/src/gallium/winsys/xlib/Makefile b/src/gallium/winsys/xlib/Makefile
index 04309e67ee..522f6dc5ae 100644
--- a/src/gallium/winsys/xlib/Makefile
+++ b/src/gallium/winsys/xlib/Makefile
@@ -90,7 +90,7 @@ install: default
 	$(INSTALL) -d $(INSTALL_DIR)/$(LIB_DIR)
 	$(INSTALL) -m 644 $(TOP)/include/GL/*.h $(INSTALL_DIR)/include/GL
 	@if [ -e $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME) ]; then \
-		$(INSTALL) $(TOP)/$(LIB_DIR)/libGL* $(INSTALL_DIR)/$(LIB_DIR); \
+		$(MINSTALL) $(TOP)/$(LIB_DIR)/libGL* $(INSTALL_DIR)/$(LIB_DIR); \
 	fi
 
 
diff --git a/src/glu/Makefile b/src/glu/Makefile
index 5c26ead1bb..b268265976 100644
--- a/src/glu/Makefile
+++ b/src/glu/Makefile
@@ -30,7 +30,7 @@ glu.pc: glu.pc.in
 install: glu.pc
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-	$(INSTALL) $(TOP)/$(LIB_DIR)/$(GLU_LIB_GLOB) $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(GLU_LIB_GLOB) $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 glu.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 
 clean:
diff --git a/src/glut/fbdev/Makefile b/src/glut/fbdev/Makefile
index 199d8c390a..c150ea88dc 100644
--- a/src/glut/fbdev/Makefile
+++ b/src/glut/fbdev/Makefile
@@ -72,7 +72,7 @@ install:
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_INC_DIR)/GL
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 $(TOP)/include/GL/glut.h $(DESTDIR)$(INSTALL_INC_DIR)/GL
-	$(INSTALL) $(TOP)/$(LIB_DIR)/libglut* $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/libglut* $(DESTDIR)$(INSTALL_LIB_DIR)
 
 # Run 'make -f Makefile.solo dep' to update the dependencies if you change
 # what's included by any source file.
diff --git a/src/glut/glx/Makefile b/src/glut/glx/Makefile
index 1b072906c7..6889cd4b40 100644
--- a/src/glut/glx/Makefile
+++ b/src/glut/glx/Makefile
@@ -117,7 +117,7 @@ install: glut.pc
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 	$(INSTALL) -m 644 $(TOP)/include/GL/glut.h $(DESTDIR)$(INSTALL_INC_DIR)/GL
-	$(INSTALL) $(TOP)/$(LIB_DIR)/$(GLUT_LIB_GLOB) $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(GLUT_LIB_GLOB) $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 glut.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 
 
diff --git a/src/glut/mini/Makefile b/src/glut/mini/Makefile
index 0e42436133..b82a758d2c 100644
--- a/src/glut/mini/Makefile
+++ b/src/glut/mini/Makefile
@@ -91,7 +91,7 @@ install: glut.pc
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 	$(INSTALL) -m 644 $(TOP)/include/GL/glut.h $(DESTDIR)$(INSTALL_INC_DIR)/GL
-	$(INSTALL) $(TOP)/$(LIB_DIR)/libglut* $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/libglut* $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 glut.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 
 
diff --git a/src/glw/Makefile b/src/glw/Makefile
index d88d773313..1fb3d3c320 100644
--- a/src/glw/Makefile
+++ b/src/glw/Makefile
@@ -43,7 +43,7 @@ install: glw.pc
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 	$(INSTALL) -m 644 *.h $(DESTDIR)$(INSTALL_INC_DIR)/GL
-	$(INSTALL) $(TOP)/$(LIB_DIR)/$(GLW_LIB_GLOB) $(DESTDIR)$(INSTALL_LIB_DIR)
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(GLW_LIB_GLOB) $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 glw.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 
 clean:
diff --git a/src/mesa/Makefile b/src/mesa/Makefile
index bb18bee8ea..8300b30144 100644
--- a/src/mesa/Makefile
+++ b/src/mesa/Makefile
@@ -129,14 +129,14 @@ install-headers:
 install-libgl: default gl.pc install-headers
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-	$(INSTALL) $(TOP)/$(LIB_DIR)/$(GL_LIB_GLOB) \
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(GL_LIB_GLOB) \
 		$(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 gl.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 
 install-osmesa: default osmesa.pc
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-	$(INSTALL) $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_GLOB) \
+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_GLOB) \
 		$(DESTDIR)$(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 osmesa.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
 
diff --git a/src/mesa/drivers/dri/Makefile.template b/src/mesa/drivers/dri/Makefile.template
index 5c01d233c1..bd38e3be47 100644
--- a/src/mesa/drivers/dri/Makefile.template
+++ b/src/mesa/drivers/dri/Makefile.template
@@ -92,7 +92,7 @@ clean:
 
 install: $(LIBNAME)
 	$(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
-	$(INSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
+	$(MINSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
 
 
 -include depend
-- 
cgit v1.2.3


From cca31340b5a9c0b941946753a31236c7201ca87c Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Fri, 17 Jul 2009 11:53:03 -0600
Subject: egl: Use the link functions to manage resources.

This commit uses the newly introduced link functions to manage EGL
contexts and surfaces.  As a result of this, the API for drivers are
changed.  All drivers are updated for the change.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/demo/demo.c                  | 17 ++++---
 src/egl/drivers/dri/egldri.c                 | 33 ++++++++------
 src/egl/drivers/glx/egl_glx.c                | 42 +++++++++++------
 src/egl/drivers/xdri/egl_xdri.c              | 19 ++++----
 src/egl/main/eglcontext.c                    | 45 +++++-------------
 src/egl/main/eglcontext.h                    | 12 +----
 src/egl/main/eglglobals.h                    |  1 +
 src/egl/main/eglscreen.c                     | 15 ++++--
 src/egl/main/eglsurface.c                    | 68 ++++++++++++----------------
 src/egl/main/eglsurface.h                    | 13 +-----
 src/gallium/state_trackers/egl/egl_context.c |  8 ++--
 src/gallium/state_trackers/egl/egl_surface.c |  7 +--
 src/gallium/winsys/egl_xlib/egl_xlib.c       | 13 +++---
 src/mesa/drivers/dri/fb/fb_egl.c             | 10 ++--
 14 files changed, 143 insertions(+), 160 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index 1750e976b8..fa9efa5d35 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -146,12 +146,12 @@ demoCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext
    if (!c)
       return EGL_NO_CONTEXT;
 
-   _eglInitContext(drv, dpy, &c->Base, config, attrib_list);
+   _eglInitContext(drv, &c->Base, conf, attrib_list);
    c->DemoStuff = 1;
    printf("demoCreateContext\n");
 
-   /* generate handle and insert into hash table */
-   _eglSaveContext(&c->Base);
+   /* link to display */
+   _eglLinkContext(&c->Base, _eglLookupDisplay(dpy));
    assert(_eglGetContextHandle(&c->Base));
 
    return _eglGetContextHandle(&c->Base);
@@ -213,11 +213,14 @@ demoCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
                          const EGLint *attrib_list)
 {
    DemoSurface *surf = (DemoSurface *) calloc(1, sizeof(DemoSurface));
+   _EGLConfig *conf;
+
    if (!surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, &surf->Base, EGL_PBUFFER_BIT,
-                        config, attrib_list)) {
+   conf = _eglLookupConfig(drv, dpy, config);
+   if (!_eglInitSurface(drv, &surf->Base, EGL_PBUFFER_BIT,
+                        conf, attrib_list)) {
       free(surf);
       return EGL_NO_SURFACE;
    }
@@ -232,7 +235,7 @@ static EGLBoolean
 demoDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    DemoSurface *fs = LookupDemoSurface(surface);
-   _eglRemoveSurface(&fs->Base);
+   _eglUnlinkSurface(&fs->Base);
    if (fs->Base.IsBound) {
       fs->Base.DeletePending = EGL_TRUE;
    }
@@ -247,7 +250,7 @@ static EGLBoolean
 demoDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
    DemoContext *fc = LookupDemoContext(context);
-   _eglRemoveContext(&fc->Base);
+   _eglUnlinkContext(&fc->Base);
    if (fc->Base.IsBound) {
       fc->Base.DeletePending = EGL_TRUE;
    }
diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index 57661cc3ab..df45fbfbe2 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -171,7 +171,10 @@ _eglDRICreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    if (!c)
       return EGL_NO_CONTEXT;
 
-   if (!_eglInitContext(drv, dpy, &c->Base, config, attrib_list)) {
+   conf = _eglLookupConfig(drv, dpy, config);
+   assert(conf);
+
+   if (!_eglInitContext(drv, &c->Base, conf, attrib_list)) {
       free(c);
       return EGL_NO_CONTEXT;
    }
@@ -189,8 +192,6 @@ _eglDRICreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    else
       sharePriv = NULL;
 
-   conf = _eglLookupConfig(drv, dpy, config);
-   assert(conf);
    _eglConfigToContextModesRec(conf, &visMode);
 
    c->driContext.private = disp->driScreen.createNewContext(disp, &visMode,
@@ -200,8 +201,8 @@ _eglDRICreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
       return EGL_FALSE;
    }
 
-   /* generate handle and insert into hash table */
-   _eglSaveContext(&c->Base);
+   /* link to display */
+   _eglLinkContext(&c->Base, &disp->Base);
 
    return _eglGetContextHandle(&c->Base);
 }
@@ -237,14 +238,18 @@ _eglDRICreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
                             const EGLint *attrib_list)
 {
    driSurface *surf;
+   _EGLConfig *conf;
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   assert(conf);
 
    surf = (driSurface *) calloc(1, sizeof(*surf));
    if (!surf) {
       return EGL_NO_SURFACE;
    }
 
-   if (!_eglInitSurface(drv, dpy, &surf->Base, EGL_PBUFFER_BIT,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, &surf->Base, EGL_PBUFFER_BIT,
+                        conf, attrib_list)) {
       free(surf);
       return EGL_NO_SURFACE;
    }
@@ -275,7 +280,7 @@ _eglDRICreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 #endif
    }
 
-   _eglSaveSurface(&surf->Base);
+   _eglLinkSurface(&surf->Base, _eglLookupDisplay(dpy));
 
    return surf->Base.Handle;
 }
@@ -287,7 +292,7 @@ _eglDRIDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    driDisplay *disp = Lookup_driDisplay(dpy);
    driSurface *fs = Lookup_driSurface(surface);
 
-   _eglRemoveSurface(&fs->Base);
+   _eglUnlinkSurface(&fs->Base);
 
    fs->drawable.destroyDrawable(disp, fs->drawable.private);
 
@@ -307,7 +312,7 @@ _eglDRIDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
    driDisplay *disp = Lookup_driDisplay(dpy);
    driContext *fc = Lookup_driContext(context);
 
-   _eglRemoveContext(&fc->Base);
+   _eglUnlinkContext(&fc->Base);
 
    fc->driContext.destroyContext(disp, 0, fc->driContext.private);
 
@@ -340,13 +345,13 @@ _eglDRICreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg,
    }
 
    /* init base class, do error checking, etc. */
-   if (!_eglInitSurface(drv, dpy, &surface->Base, EGL_SCREEN_BIT_MESA,
-                        cfg, attrib_list)) {
+   if (!_eglInitSurface(drv, &surface->Base, EGL_SCREEN_BIT_MESA,
+                        config, attrib_list)) {
       free(surface);
       return EGL_NO_SURFACE;
    }
 
-   _eglSaveSurface(&surface->Base);
+   _eglLinkSurface(&surface->Base &disp->Base);
 
 
    /*
@@ -363,7 +368,7 @@ _eglDRICreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg,
    if (!disp->driScreen.createNewDrawable(disp, &visMode, drawBuf,
                                           &surface->drawable, GLX_WINDOW_BIT,
                                           empty_attribute_list)) {
-      _eglRemoveSurface(&surface->Base);
+      _eglUnlinkSurface(&surface->Base);
       free(surface);
       return EGL_NO_SURFACE;
    }
diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 155caa413c..661b313ae2 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -532,7 +532,10 @@ GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    if (!GLX_ctx)
       return EGL_NO_CONTEXT;
 
-   if (!_eglInitContext(drv, dpy, &GLX_ctx->Base, config, attrib_list)) {
+   conf = _eglLookupConfig(drv, dpy, config);
+   assert(conf);
+
+   if (!_eglInitContext(drv, &GLX_ctx->Base, conf, attrib_list)) {
       free(GLX_ctx);
       return EGL_NO_CONTEXT;
    }
@@ -546,9 +549,6 @@ GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
       GLX_ctx_shared = GLX_egl_context(shareCtx);
    }
 
-   conf = _eglLookupConfig(drv, dpy, config);
-   assert(conf);
-
 #ifdef GLX_VERSION_1_3
    if (GLX_drv->fbconfigs)
       GLX_ctx->context = glXCreateNewContext(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], GLX_RGBA_TYPE, GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
@@ -564,7 +564,7 @@ GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
       return EGL_FALSE;
 #endif
 
-   return _eglGetContextHandle(&GLX_ctx->Base);
+   return _eglLinkContext(&GLX_ctx->Base, disp);
 }
 
 
@@ -619,18 +619,22 @@ GLX_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct GLX_egl_surface *GLX_surf;
    uint width, height;
+   _EGLConfig *conf;
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   assert(conf);
 
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
    if (!GLX_surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_WINDOW_BIT,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_WINDOW_BIT,
+                        conf, attrib_list)) {
       free(GLX_surf);
       return EGL_FALSE;
    }
 
-   _eglSaveSurface(&GLX_surf->Base);
+   _eglLinkSurface(&GLX_surf->Base, disp);
 
    GLX_surf->drawable = window;
    get_drawable_size(disp->Xdpy, window, &width, &height);
@@ -648,19 +652,23 @@ GLX_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct GLX_egl_surface *GLX_surf;
+   _EGLConfig *conf;
    int i;
 
+   conf = _eglLookupConfig(drv, dpy, config);
+   assert(conf);
+
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
    if (!GLX_surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_PIXMAP_BIT,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_PIXMAP_BIT,
+                        conf, attrib_list)) {
       free(GLX_surf);
       return EGL_FALSE;
    }
 
-   _eglSaveSurface(&GLX_surf->Base);
+   _eglLinkSurface(&GLX_surf->Base, disp);
 
    for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
       switch (attrib_list[i]) {
@@ -683,20 +691,24 @@ GLX_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct GLX_egl_surface *GLX_surf;
+   _EGLConfig *conf;
    int attribs[5];
    int i = 0, j = 0;
 
+   conf = _eglLookupConfig(drv, dpy, config);
+   assert(conf);
+
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
    if (!GLX_surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, &GLX_surf->Base, EGL_PBUFFER_BIT,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_PBUFFER_BIT,
+                        conf, attrib_list)) {
       free(GLX_surf);
       return EGL_NO_SURFACE;
    }
 
-   _eglSaveSurface(&GLX_surf->Base);
+   _eglLinkSurface(&GLX_surf->Base, disp);
 
    while(attrib_list[i] != EGL_NONE) {
       switch (attrib_list[i]) {
@@ -726,7 +738,7 @@ GLX_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    _EGLSurface *surf = _eglLookupSurface(surface);
    return EGL_TRUE;
    if (surf) {
-      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
+      _eglUnlinkSurface(surf);
       if (surf->IsBound) {
          surf->DeletePending = EGL_TRUE;
       }
diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 3b3e312746..34d69def6a 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -770,7 +770,7 @@ xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    if (!xdri_ctx)
       return EGL_NO_CONTEXT;
 
-   if (!_eglInitContext(drv, dpy, &xdri_ctx->Base, config, attrib_list)) {
+   if (!_eglInitContext(drv, &xdri_ctx->Base, &xdri_config->Base, attrib_list)) {
       free(xdri_ctx);
       return EGL_NO_CONTEXT;
    }
@@ -794,7 +794,7 @@ xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 
    xdri_ctx->driContext.mode = xdri_config->mode;
 
-   return _eglGetContextHandle(&xdri_ctx->Base);
+   return _eglLinkContext(&xdri_ctx->Base, &disp);
 }
 
 
@@ -835,6 +835,7 @@ xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
                             NativeWindowType window, const EGLint *attrib_list)
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct xdri_egl_config *xdri_config = lookup_config(drv, dpy, config);
    struct xdri_egl_surface *xdri_surf;
    int scrn = DefaultScreen(disp->Xdpy);
    uint width, height;
@@ -843,8 +844,8 @@ xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    if (!xdri_surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, &xdri_surf->Base, EGL_WINDOW_BIT,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, &xdri_surf->Base, EGL_WINDOW_BIT,
+                        &xdri_config->Base, attrib_list)) {
       free(xdri_surf);
       return EGL_FALSE;
    }
@@ -856,7 +857,7 @@ xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 
    xdri_surf->driDrawable = window;
 
-   _eglSaveSurface(&xdri_surf->Base);
+   _eglLinkSurface(&xdri_surf->Base, disp);
 
    get_drawable_size(disp->Xdpy, window, &width, &height);
    xdri_surf->Base.Width = width;
@@ -888,8 +889,8 @@ xdri_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    if (!xdri_surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, &xdri_surf->Base, EGL_PBUFFER_BIT,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, &xdri_surf->Base, EGL_PBUFFER_BIT,
+                        &xdri_config->Base, attrib_list)) {
       free(xdri_surf);
       return EGL_FALSE;
    }
@@ -939,7 +940,7 @@ xdri_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 
    xdri_surf->driDrawable = window;
 
-   _eglSaveSurface(&xdri_surf->Base);
+   _eglLinkSurface(&xdri_surf->Base, disp);
 
    _eglLog(_EGL_DEBUG,
            "XDRI: CreatePbufferSurface handle %d  hDrawable %d",
@@ -956,7 +957,7 @@ xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
    if (xdri_surf) {
-      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
+      _eglUnlinkSurface(&xdri_surf->Base);
       if (xdri_surf->Base.IsBound) {
          xdri_surf->Base.DeletePending = EGL_TRUE;
       }
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index edcc6a986f..01cb116d00 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -14,11 +14,9 @@
  * in the attrib_list.
  */
 EGLBoolean
-_eglInitContext(_EGLDriver *drv, EGLDisplay dpy, _EGLContext *ctx,
-                EGLConfig config, const EGLint *attrib_list)
+_eglInitContext(_EGLDriver *drv, _EGLContext *ctx,
+                _EGLConfig *conf, const EGLint *attrib_list)
 {
-   _EGLConfig *conf;
-   _EGLDisplay *display = _eglLookupDisplay(dpy);
    EGLint i;
    const EGLenum api = eglQueryAPI();
 
@@ -27,7 +25,6 @@ _eglInitContext(_EGLDriver *drv, EGLDisplay dpy, _EGLContext *ctx,
       return EGL_FALSE;
    }
 
-   conf = _eglLookupConfig(drv, dpy, config);
    if (!conf) {
       _eglError(EGL_BAD_CONFIG, "_eglInitContext");
       return EGL_FALSE;
@@ -49,7 +46,6 @@ _eglInitContext(_EGLDriver *drv, EGLDisplay dpy, _EGLContext *ctx,
       }
    }
 
-   ctx->Display = display;
    ctx->Config = conf;
    ctx->DrawSurface = EGL_NO_SURFACE;
    ctx->ReadSurface = EGL_NO_SURFACE;
@@ -59,30 +55,6 @@ _eglInitContext(_EGLDriver *drv, EGLDisplay dpy, _EGLContext *ctx,
 }
 
 
-/**
- * Save a new _EGLContext into the hash table.
- */
-void
-_eglSaveContext(_EGLContext *ctx)
-{
-   /* no-op.
-    * Public EGLContext handle and private _EGLContext are the same.
-    */
-}
-
-
-/**
- * Remove the given _EGLContext object from the hash table.
- */
-void
-_eglRemoveContext(_EGLContext *ctx)
-{
-   /* no-op.
-    * Public EGLContext handle and private _EGLContext are the same.
-    */
-}
-
-
 /**
  * Just a placeholder/demo function.  Real driver will never use this!
  */
@@ -92,18 +64,24 @@ _eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 {
 #if 0 /* example code */
    _EGLContext *context;
+   _EGLConfig *conf;
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   if (!conf) {
+      _eglError(EGL_BAD_CONFIG, "eglCreateContext");
+      return EGL_NO_CONTEXT;
+   }
 
    context = (_EGLContext *) calloc(1, sizeof(_EGLContext));
    if (!context)
       return EGL_NO_CONTEXT;
 
-   if (!_eglInitContext(drv, dpy, context, config, attrib_list)) {
+   if (!_eglInitContext(drv, context, conf, attrib_list)) {
       free(context);
       return EGL_NO_CONTEXT;
    }
 
-   _eglSaveContext(context);
-   return (EGLContext) context;
+   return _eglLinkContext(context, _eglLookupDisplay(dpy));
 #endif
    return EGL_NO_CONTEXT;
 }
@@ -117,6 +95,7 @@ _eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
 {
    _EGLContext *context = _eglLookupContext(ctx);
    if (context) {
+      _eglUnlinkContext(context);
       if (context->IsBound) {
          context->DeletePending = EGL_TRUE;
       }
diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 6e418dfbbe..8e20643177 100644
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -29,16 +29,8 @@ struct _egl_context
 
 
 extern EGLBoolean
-_eglInitContext(_EGLDriver *drv, EGLDisplay dpy, _EGLContext *ctx,
-                EGLConfig config, const EGLint *attrib_list);
-
-
-extern void
-_eglSaveContext(_EGLContext *ctx);
-
-
-extern void
-_eglRemoveContext(_EGLContext *ctx);
+_eglInitContext(_EGLDriver *drv, _EGLContext *ctx,
+                _EGLConfig *config, const EGLint *attrib_list);
 
 
 extern EGLContext
diff --git a/src/egl/main/eglglobals.h b/src/egl/main/eglglobals.h
index fbb55c23f0..a9443cfbdd 100644
--- a/src/egl/main/eglglobals.h
+++ b/src/egl/main/eglglobals.h
@@ -13,6 +13,7 @@ struct _egl_global
 {
    EGLBoolean Initialized;
 
+   /* these are private to egldisplay.c */
    _EGLHashtable *Displays;
    _EGLHashtable *Surfaces;
 
diff --git a/src/egl/main/eglscreen.c b/src/egl/main/eglscreen.c
index 9c9a8377bf..b6bde65e8b 100644
--- a/src/egl/main/eglscreen.c
+++ b/src/egl/main/eglscreen.c
@@ -128,20 +128,25 @@ _eglCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
+   _EGLConfig *conf;
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   if (!conf) {
+      _eglError(EGL_BAD_CONFIG, "eglCreateScreenSurfaceMESA");
+      return EGL_NO_SURFACE;
+   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, surf, EGL_SCREEN_BIT_MESA,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, surf, EGL_SCREEN_BIT_MESA,
+                        conf, attrib_list)) {
       free(surf);
       return EGL_NO_SURFACE;
    }
 
-   _eglSaveSurface(surf);
-
-   return surf->Handle;
+   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
 #endif
    return EGL_NO_SURFACE;
 }
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 854f499fce..b122124585 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -21,12 +21,10 @@
  * \return EGL_TRUE if no errors, EGL_FALSE otherwise.
  */
 EGLBoolean
-_eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
-                _EGLSurface *surf, EGLint type, EGLConfig config,
-                const EGLint *attrib_list)
+_eglInitSurface(_EGLDriver *drv, _EGLSurface *surf, EGLint type,
+                _EGLConfig *conf, const EGLint *attrib_list)
 {
    const char *func;
-   _EGLConfig *conf;
    EGLint width = 0, height = 0, largest = 0;
    EGLint texFormat = 0, texTarget = 0, mipmapTex = 0;
    EGLint renderBuffer = EGL_BACK_BUFFER;
@@ -56,7 +54,6 @@ _eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
       return EGL_FALSE;
    }
 
-   conf = _eglLookupConfig(drv, dpy, config);
    if (!conf) {
       _eglError(EGL_BAD_CONFIG, func);
       return EGL_FALSE;
@@ -212,26 +209,6 @@ _eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
 }
 
 
-void
-_eglSaveSurface(_EGLSurface *surf)
-{
-   EGLuint key = _eglHashGenKey(_eglGlobal.Surfaces);
-   assert(surf);
-   assert(!surf->Handle);
-   surf->Handle = (EGLSurface) key;
-   assert(surf->Handle);
-   _eglHashInsert(_eglGlobal.Surfaces, key, surf);
-}
-
-
-void
-_eglRemoveSurface(_EGLSurface *surf)
-{
-   _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surf->Handle);
-}
-
-
-
 EGLBoolean
 _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 {
@@ -340,19 +317,24 @@ _eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
+   _EGLConfig *conf;
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   if (!conf) {
+      _eglError(EGL_BAD_CONFIG, "eglCreateWindowSurface");
+      return EGL_NO_SURFACE;
+   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, surf, EGL_WINDOW_BIT, config, attrib_list)) {
+   if (!_eglInitSurface(drv, surf, EGL_WINDOW_BIT, conf, attrib_list)) {
       free(surf);
       return EGL_NO_SURFACE;
    }
 
-   _eglSaveSurface(surf);
-
-   return surf->Handle;
+   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
 #endif
    return EGL_NO_SURFACE;
 }
@@ -367,19 +349,24 @@ _eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
+   _EGLConfig *conf;
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   if (!conf) {
+      _eglError(EGL_BAD_CONFIG, "eglCreatePixmapSurface");
+      return EGL_NO_SURFACE;
+   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, surf, EGL_PIXMAP_BIT, config, attrib_list)) {
+   if (!_eglInitSurface(drv, surf, EGL_PIXMAP_BIT, conf, attrib_list)) {
       free(surf);
       return EGL_NO_SURFACE;
    }
 
-   _eglSaveSurface(surf);
-
-   return surf->Handle;
+   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
 #endif
    return EGL_NO_SURFACE;
 }
@@ -394,19 +381,24 @@ _eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
+   _EGLConfig *conf;
+
+   conf = _eglLookupConfig(drv, dpy, config);
+   if (!conf) {
+      _eglError(EGL_BAD_CONFIG, "eglCreatePbufferSurface");
+      return EGL_NO_SURFACE;
+   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
       return EGL_NO_SURFACE;
 
-   if (!_eglInitSurface(drv, dpy, surf, EGL_PBUFFER_BIT, config, attrib_list)) {
+   if (!_eglInitSurface(drv, surf, EGL_PBUFFER_BIT, conf, attrib_list)) {
       free(surf);
       return EGL_NO_SURFACE;
    }
 
-   _eglSaveSurface(surf);
-
-   return surf->Handle;
+   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
 #endif
    return EGL_NO_SURFACE;
 }
@@ -420,7 +412,7 @@ _eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    _EGLSurface *surf = _eglLookupSurface(surface);
    if (surf) {
-      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
+      _eglUnlinkSurface(surf);
       if (surf->IsBound) {
          surf->DeletePending = EGL_TRUE;
       }
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index dc53669091..f6874e6278 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -43,17 +43,8 @@ struct _egl_surface
 
 
 extern EGLBoolean
-_eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
-                _EGLSurface *surf, EGLint type, EGLConfig config,
-                const EGLint *attrib_list);
-
-
-extern void
-_eglSaveSurface(_EGLSurface *surf);
-
-
-extern void
-_eglRemoveSurface(_EGLSurface *surf);
+_eglInitSurface(_EGLDriver *drv, _EGLSurface *surf, EGLint type,
+                _EGLConfig *config, const EGLint *attrib_list);
 
 
 extern EGLBoolean
diff --git a/src/gallium/state_trackers/egl/egl_context.c b/src/gallium/state_trackers/egl/egl_context.c
index edd49486e5..95dfcb9983 100644
--- a/src/gallium/state_trackers/egl/egl_context.c
+++ b/src/gallium/state_trackers/egl/egl_context.c
@@ -113,7 +113,7 @@ drm_create_context(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext
 	if (!ctx)
 		goto err_c;
 
-	_eglInitContext(drv, dpy, &ctx->base, config, attrib_list);
+	_eglInitContext(drv, dpy, &ctx->base, conf, attrib_list);
 
 	ctx->pipe = dev->api->create_context(dev->api, dev->screen);
 	if (!ctx->pipe)
@@ -129,8 +129,8 @@ drm_create_context(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext
 	if (!ctx->st)
 		goto err_gl;
 
-	/* generate handle and insert into hash table */
-	_eglSaveContext(&ctx->base);
+        /* link to display */
+        _eglLinkContext(&ctx->base, _eglLookupDisplay(dpy));
 	assert(_eglGetContextHandle(&ctx->base));
 
 	return _eglGetContextHandle(&ctx->base);
@@ -147,7 +147,7 @@ EGLBoolean
 drm_destroy_context(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
 	struct drm_context *c = lookup_drm_context(context);
-	_eglRemoveContext(&c->base);
+        _eglUnlinkContext(&c->base);
 	if (c->base.IsBound) {
 		c->base.DeletePending = EGL_TRUE;
 	} else {
diff --git a/src/gallium/state_trackers/egl/egl_surface.c b/src/gallium/state_trackers/egl/egl_surface.c
index de8194a46a..27b35052d1 100644
--- a/src/gallium/state_trackers/egl/egl_surface.c
+++ b/src/gallium/state_trackers/egl/egl_surface.c
@@ -232,7 +232,7 @@ drm_create_pbuffer_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 	if (!surf)
 		goto err;
 
-	if (!_eglInitSurface(drv, dpy, &surf->base, EGL_PBUFFER_BIT, config, attrib_list))
+	if (!_eglInitSurface(drv, &surf->base, EGL_PBUFFER_BIT, conf, attrib_list))
 		goto err_surf;
 
 	surf->w = width;
@@ -245,7 +245,7 @@ drm_create_pbuffer_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 	                                    (void*)surf);
 	drm_visual_modes_destroy(visual);
 
-	_eglSaveSurface(&surf->base);
+        _eglLinkSurface(&surf->base, _eglLookupDisplay(dpy));
 	return surf->base.Handle;
 
 err_surf:
@@ -364,7 +364,8 @@ EGLBoolean
 drm_destroy_surface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
 	struct drm_surface *surf = lookup_drm_surface(surface);
-	_eglRemoveSurface(&surf->base);
+	_eglUnlinkSurface(&surf->base);
+
 	if (surf->base.IsBound) {
 		surf->base.DeletePending = EGL_TRUE;
 	} else {
diff --git a/src/gallium/winsys/egl_xlib/egl_xlib.c b/src/gallium/winsys/egl_xlib/egl_xlib.c
index c10e3c00ff..9914dff964 100644
--- a/src/gallium/winsys/egl_xlib/egl_xlib.c
+++ b/src/gallium/winsys/egl_xlib/egl_xlib.c
@@ -345,7 +345,7 @@ xlib_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
       return EGL_NO_CONTEXT;
 
    /* let EGL lib init the common stuff */
-   if (!_eglInitContext(drv, dpy, &ctx->Base, config, attrib_list)) {
+   if (!_eglInitContext(drv, &ctx->Base, conf, attrib_list)) {
       free(ctx);
       return EGL_NO_CONTEXT;
    }
@@ -370,7 +370,7 @@ xlib_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
       return EGL_NO_CONTEXT;
    }
 
-   _eglSaveContext(&ctx->Base);
+   _eglLinkContext(&ctx->Base, _eglLookupDisplay(dpy));
 
    return _eglGetContextHandle(&ctx->Base);
 }
@@ -381,6 +381,7 @@ xlib_eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
 {
    struct xlib_egl_context *context = lookup_context(ctx);
    if (context) {
+      _eglUnlinkContext(&context->Base);
       if (context->Base.IsBound) {
          context->Base.DeletePending = EGL_TRUE;
       }
@@ -491,13 +492,13 @@ xlib_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
       return EGL_NO_SURFACE;
 
    /* Let EGL lib init the common stuff */
-   if (!_eglInitSurface(drv, dpy, &surf->Base, EGL_WINDOW_BIT,
-                        config, attrib_list)) {
+   if (!_eglInitSurface(drv, &surf->Base, EGL_WINDOW_BIT,
+                        conf, attrib_list)) {
       free(surf);
       return EGL_NO_SURFACE;
    }
 
-   _eglSaveSurface(&surf->Base);
+   _eglLinkSurface(&surf->Base, disp);
 
    /*
     * Now init the Xlib and gallium stuff
@@ -534,7 +535,7 @@ xlib_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    struct xlib_egl_surface *surf = lookup_surface(surface);
    if (surf) {
-      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
+      _eglUnlinkSurface(&surf->Base);
       if (surf->Base.IsBound) {
          surf->Base.DeletePending = EGL_TRUE;
       }
diff --git a/src/mesa/drivers/dri/fb/fb_egl.c b/src/mesa/drivers/dri/fb/fb_egl.c
index 35c268441c..c367741f52 100644
--- a/src/mesa/drivers/dri/fb/fb_egl.c
+++ b/src/mesa/drivers/dri/fb/fb_egl.c
@@ -472,8 +472,8 @@ fbCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext sh
    c->Base.DrawSurface = EGL_NO_SURFACE;
    c->Base.ReadSurface = EGL_NO_SURFACE;
 
-   /* generate handle and insert into hash table */
-   _eglSaveContext(&c->Base);
+   /* link to display */
+   _eglLinkContext(&c->Base, disp);
    assert(c->Base.Handle);
 
    /* Init default driver functions then plug in our FBdev-specific functions
@@ -604,7 +604,7 @@ static EGLBoolean
 fbDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    fbSurface *fs = Lookup_fbSurface(surface);
-   _eglRemoveSurface(&fs->Base);
+   _eglUnlinkSurface(&fs->Base);
    if (fs->Base.IsBound) {
       fs->Base.DeletePending = EGL_TRUE;
    }
@@ -619,7 +619,7 @@ static EGLBoolean
 fbDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
    fbContext *fc = Lookup_fbContext(context);
-   _eglRemoveContext(&fc->Base);
+   _eglUnlinkContext(&fc->Base);
    if (fc->Base.IsBound) {
       fc->Base.DeletePending = EGL_TRUE;
    }
@@ -688,7 +688,7 @@ fbCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg,
    surface->mesa_framebuffer = _mesa_create_framebuffer(&vis);
    if (!surface->mesa_framebuffer) {
       free(surface);
-      _eglRemoveSurface(&surface->Base);
+      _eglUnlinkSurface(&surface->Base);
       return EGL_NO_SURFACE;
    }
 
-- 
cgit v1.2.3


From 15fdbc8361d0b865aea5e2f374b471081ed4214a Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Fri, 17 Jul 2009 11:56:00 -0600
Subject: egl: Remove redundant DeletePending flag.

A context or surface that is neither linked to a display nor current to
a thread should be destroyed.  Therefore, an unlinked context or surface
implies a pending delete automatically.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/demo/demo.c                  | 12 ++----------
 src/egl/drivers/dri/egldri.c                 | 12 ++----------
 src/egl/drivers/glx/egl_glx.c                |  6 +-----
 src/egl/drivers/xdri/egl_xdri.c              |  5 +----
 src/egl/main/eglcontext.c                    | 14 +++++---------
 src/egl/main/eglcontext.h                    |  1 -
 src/egl/main/egldisplay.h                    | 29 ++++++++++++++++++++++++++++
 src/egl/main/eglsurface.c                    |  6 +-----
 src/egl/main/eglsurface.h                    |  1 -
 src/gallium/state_trackers/egl/egl_context.c |  4 +---
 src/gallium/state_trackers/egl/egl_surface.c |  4 +---
 src/gallium/winsys/egl_xlib/egl_xlib.c       | 10 ++--------
 src/mesa/drivers/dri/fb/fb_egl.c             | 12 ++----------
 13 files changed, 47 insertions(+), 69 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index fa9efa5d35..f316974d83 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -236,12 +236,8 @@ demoDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    DemoSurface *fs = LookupDemoSurface(surface);
    _eglUnlinkSurface(&fs->Base);
-   if (fs->Base.IsBound) {
-      fs->Base.DeletePending = EGL_TRUE;
-   }
-   else {
+   if (!fs->Base.IsBound)
       free(fs);
-   }
    return EGL_TRUE;
 }
 
@@ -251,12 +247,8 @@ demoDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
    DemoContext *fc = LookupDemoContext(context);
    _eglUnlinkContext(&fc->Base);
-   if (fc->Base.IsBound) {
-      fc->Base.DeletePending = EGL_TRUE;
-   }
-   else {
+   if (!fc->Base.IsBound)
       free(fc);
-   }
    return EGL_TRUE;
 }
 
diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index df45fbfbe2..3f9617a8f9 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -296,12 +296,8 @@ _eglDRIDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 
    fs->drawable.destroyDrawable(disp, fs->drawable.private);
 
-   if (fs->Base.IsBound) {
-      fs->Base.DeletePending = EGL_TRUE;
-   }
-   else {
+   if (!fs->Base.IsBound)
       free(fs);
-   }
    return EGL_TRUE;
 }
 
@@ -316,12 +312,8 @@ _eglDRIDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 
    fc->driContext.destroyContext(disp, 0, fc->driContext.private);
 
-   if (fc->Base.IsBound) {
-      fc->Base.DeletePending = EGL_TRUE;
-   }
-   else {
+   if (!fc->Base.IsBound)
       free(fc);
-   }
    return EGL_TRUE;
 }
 
diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 661b313ae2..207b1ea779 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -739,12 +739,8 @@ GLX_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    return EGL_TRUE;
    if (surf) {
       _eglUnlinkSurface(surf);
-      if (surf->IsBound) {
-         surf->DeletePending = EGL_TRUE;
-      }
-      else {
+      if (!surf->IsBound)
          free(surf);
-      }
 
       return EGL_TRUE;
    }
diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 34d69def6a..e040efdd43 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -958,10 +958,7 @@ xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
    if (xdri_surf) {
       _eglUnlinkSurface(&xdri_surf->Base);
-      if (xdri_surf->Base.IsBound) {
-         xdri_surf->Base.DeletePending = EGL_TRUE;
-      }
-      else {
+      if (!xdri_surf->Base.IsBound) {
          /*
          st_unreference_framebuffer(surf->Framebuffer);
          */
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 01cb116d00..9ab4286d3a 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -96,12 +96,8 @@ _eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
    _EGLContext *context = _eglLookupContext(ctx);
    if (context) {
       _eglUnlinkContext(context);
-      if (context->IsBound) {
-         context->DeletePending = EGL_TRUE;
-      }
-      else {
+      if (!context->IsBound)
          free(context);
-      }
       return EGL_TRUE;
    }
    else {
@@ -146,7 +142,7 @@ _eglQueryContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx,
 
 /**
  * Drivers will typically call this to do the error checking and
- * update the various IsBound and DeletePending flags.
+ * update the various flags.
  * Then, the driver will do its device-dependent Make-Current stuff.
  */
 EGLBoolean
@@ -212,7 +208,7 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
     */
    if (oldDrawSurface != NULL) {
       oldDrawSurface->IsBound = EGL_FALSE;
-      if (oldDrawSurface->DeletePending) {
+      if (!_eglIsSurfaceLinked(oldDrawSurface)) {
          /* make sure we don't try to rebind a deleted surface */
          if (draw == oldDrawSurface || draw == oldReadSurface) {
             draw = NULL;
@@ -223,7 +219,7 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
    }
    if (oldReadSurface != NULL && oldReadSurface != oldDrawSurface) {
       oldReadSurface->IsBound = EGL_FALSE;
-      if (oldReadSurface->DeletePending) {
+      if (!_eglIsSurfaceLinked(oldReadSurface)) {
          /* make sure we don't try to rebind a deleted surface */
          if (read == oldDrawSurface || read == oldReadSurface) {
             read = NULL;
@@ -234,7 +230,7 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
    }
    if (oldContext != NULL) {
       oldContext->IsBound = EGL_FALSE;
-      if (oldContext->DeletePending) {
+      if (!_eglIsContextLinked(oldContext)) {
          /* make sure we don't try to rebind a deleted context */
          if (ctx == oldContext) {
             ctx = NULL;
diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 8e20643177..2fb28d38b9 100644
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -21,7 +21,6 @@ struct _egl_context
    _EGLSurface *ReadSurface;
 
    EGLBoolean IsBound;
-   EGLBoolean DeletePending;
 
    EGLint ClientAPI; /**< EGL_OPENGL_ES_API, EGL_OPENGL_API, EGL_OPENVG_API */
    EGLint ClientVersion; /**< 1 = OpenGLES 1.x, 2 = OpenGLES 2.x */
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 30b466cb4a..372ed3cd79 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -52,6 +52,16 @@ extern _EGLDisplay *
 _eglLookupDisplay(EGLDisplay dpy);
 
 
+/**
+ * Return true if the display is linked.
+ */
+static INLINE EGLBoolean
+_eglIsDisplayLinked(_EGLDisplay *dpy)
+{
+   return (EGLBoolean) (_eglGetDisplayHandle(dpy) != EGL_NO_DISPLAY);
+}
+
+
 extern _EGLDisplay *
 _eglFindDisplay(NativeDisplayType nativeDisplay);
 
@@ -80,6 +90,15 @@ extern _EGLContext *
 _eglLookupContext(EGLContext ctx);
 
 
+/**
+ * Return true if the context is linked to a display.
+ */
+static INLINE EGLBoolean
+_eglIsContextLinked(_EGLContext *ctx)
+{
+   return (EGLBoolean) (_eglGetContextHandle(ctx) != EGL_NO_CONTEXT);
+}
+
 extern EGLSurface
 _eglLinkSurface(_EGLSurface *surf, _EGLDisplay *dpy);
 
@@ -96,4 +115,14 @@ extern _EGLSurface *
 _eglLookupSurface(EGLSurface surf);
 
 
+/**
+ * Return true if the surface is linked to a display.
+ */
+static INLINE EGLBoolean
+_eglIsSurfaceLinked(_EGLSurface *surf)
+{
+   return (EGLBoolean) (_eglGetSurfaceHandle(surf) != EGL_NO_SURFACE);
+}
+
+
 #endif /* EGLDISPLAY_INCLUDED */
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index b122124585..9821e63628 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -413,12 +413,8 @@ _eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    _EGLSurface *surf = _eglLookupSurface(surface);
    if (surf) {
       _eglUnlinkSurface(surf);
-      if (surf->IsBound) {
-         surf->DeletePending = EGL_TRUE;
-      }
-      else {
+      if (!surf->IsBound)
          free(surf);
-      }
       return EGL_TRUE;
    }
    else {
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index f6874e6278..f9413eb9d7 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -19,7 +19,6 @@ struct _egl_surface
 
    /* May need reference counting here */
    EGLBoolean IsBound;
-   EGLBoolean DeletePending;
    EGLBoolean BoundToTexture;
 
    EGLint Type; /* one of EGL_WINDOW_BIT, EGL_PIXMAP_BIT or EGL_PBUFFER_BIT */
diff --git a/src/gallium/state_trackers/egl/egl_context.c b/src/gallium/state_trackers/egl/egl_context.c
index 95dfcb9983..f03a29582a 100644
--- a/src/gallium/state_trackers/egl/egl_context.c
+++ b/src/gallium/state_trackers/egl/egl_context.c
@@ -148,9 +148,7 @@ drm_destroy_context(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
 	struct drm_context *c = lookup_drm_context(context);
         _eglUnlinkContext(&c->base);
-	if (c->base.IsBound) {
-		c->base.DeletePending = EGL_TRUE;
-	} else {
+	if (!c->base.IsBound) {
 		st_destroy_context(c->st);
 		c->pipe->destroy(c->pipe);
 		free(c);
diff --git a/src/gallium/state_trackers/egl/egl_surface.c b/src/gallium/state_trackers/egl/egl_surface.c
index 27b35052d1..86f2ea97e5 100644
--- a/src/gallium/state_trackers/egl/egl_surface.c
+++ b/src/gallium/state_trackers/egl/egl_surface.c
@@ -366,9 +366,7 @@ drm_destroy_surface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 	struct drm_surface *surf = lookup_drm_surface(surface);
 	_eglUnlinkSurface(&surf->base);
 
-	if (surf->base.IsBound) {
-		surf->base.DeletePending = EGL_TRUE;
-	} else {
+	if (!surf->base.IsBound) {
 		if (surf->screen)
 			drm_takedown_shown_screen(drv, surf->screen);
 		st_unreference_framebuffer(surf->stfb);
diff --git a/src/gallium/winsys/egl_xlib/egl_xlib.c b/src/gallium/winsys/egl_xlib/egl_xlib.c
index 9914dff964..e1ddcae97b 100644
--- a/src/gallium/winsys/egl_xlib/egl_xlib.c
+++ b/src/gallium/winsys/egl_xlib/egl_xlib.c
@@ -382,10 +382,7 @@ xlib_eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
    struct xlib_egl_context *context = lookup_context(ctx);
    if (context) {
       _eglUnlinkContext(&context->Base);
-      if (context->Base.IsBound) {
-         context->Base.DeletePending = EGL_TRUE;
-      }
-      else {
+      if (!context->Base.IsBound) {
          /* API-dependent clean-up */
          switch (context->Base.ClientAPI) {
          case EGL_OPENGL_ES_API:
@@ -536,10 +533,7 @@ xlib_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    struct xlib_egl_surface *surf = lookup_surface(surface);
    if (surf) {
       _eglUnlinkSurface(&surf->Base);
-      if (surf->Base.IsBound) {
-         surf->Base.DeletePending = EGL_TRUE;
-      }
-      else {
+      if (!surf->Base.IsBound) {
          XFreeGC(surf->Dpy, surf->Gc);
          st_unreference_framebuffer(surf->Framebuffer);
          free(surf);
diff --git a/src/mesa/drivers/dri/fb/fb_egl.c b/src/mesa/drivers/dri/fb/fb_egl.c
index c367741f52..dee67feb5a 100644
--- a/src/mesa/drivers/dri/fb/fb_egl.c
+++ b/src/mesa/drivers/dri/fb/fb_egl.c
@@ -605,12 +605,8 @@ fbDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    fbSurface *fs = Lookup_fbSurface(surface);
    _eglUnlinkSurface(&fs->Base);
-   if (fs->Base.IsBound) {
-      fs->Base.DeletePending = EGL_TRUE;
-   }
-   else {
+   if (!fs->Base.IsBound)
       free(fs);
-   }
    return EGL_TRUE;
 }
 
@@ -620,12 +616,8 @@ fbDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
    fbContext *fc = Lookup_fbContext(context);
    _eglUnlinkContext(&fc->Base);
-   if (fc->Base.IsBound) {
-      fc->Base.DeletePending = EGL_TRUE;
-   }
-   else {
+   if (!fc->Base.IsBound)
       free(fc);
-   }
    return EGL_TRUE;
 }
 
-- 
cgit v1.2.3


From 5358e54d1ae64ccfa81199b343a2931b415fcc0a Mon Sep 17 00:00:00 2001
From: Peter Hutterer <peter.hutterer@who-t.net>
Date: Mon, 20 Jul 2009 16:11:26 +1000
Subject: Add missing X11_INCLUDES to egl/drivers/demo and egl/main.

Compiling mesa on a system with no X headers installed in the default
include paths fails due to missing X11 includes. The header includes are
picked up by configure but not applied.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
---
 src/egl/drivers/demo/Makefile | 2 +-
 src/egl/main/Makefile         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/Makefile b/src/egl/drivers/demo/Makefile
index 26694c92fa..444dfb35bd 100644
--- a/src/egl/drivers/demo/Makefile
+++ b/src/egl/drivers/demo/Makefile
@@ -4,7 +4,7 @@ TOP = ../../../..
 include $(TOP)/configs/current
 
 
-INCLUDE_DIRS = -I$(TOP)/include -I$(TOP)/src/egl/main
+INCLUDE_DIRS = -I$(TOP)/include -I$(TOP)/src/egl/main $(X11_INCLUDES)
 
 
 SOURCES = demo.c
diff --git a/src/egl/main/Makefile b/src/egl/main/Makefile
index e1ff8794b3..7cab005214 100644
--- a/src/egl/main/Makefile
+++ b/src/egl/main/Makefile
@@ -4,7 +4,7 @@ TOP = ../../..
 include $(TOP)/configs/current
 
 
-INCLUDE_DIRS = -I$(TOP)/include -I$(TOP)/src/mesa/glapi
+INCLUDE_DIRS = -I$(TOP)/include -I$(TOP)/src/mesa/glapi $(X11_INCLUDES)
 
 HEADERS = \
 	eglcompiler.h \
-- 
cgit v1.2.3


From 07ee01365a8bddf6f50821ecd585784498a25ff0 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Mon, 3 Aug 2009 11:34:37 -0600
Subject: egl: Replace IsBound by a pointer to the binding.

IsBound tells if a context or surface is current.  What it does not tell
is, to which thread a context is current, or to which context a surface
is current.  This commit replaces IsBound by a pointer to the binding
thread or context.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/demo/demo.c                  |  4 ++--
 src/egl/drivers/dri/egldri.c                 |  4 ++--
 src/egl/drivers/glx/egl_glx.c                |  2 +-
 src/egl/drivers/xdri/egl_xdri.c              |  2 +-
 src/egl/main/eglcontext.c                    | 14 +++++++-------
 src/egl/main/eglcontext.h                    | 17 ++++++++++++++---
 src/egl/main/eglsurface.c                    |  2 +-
 src/egl/main/eglsurface.h                    | 19 +++++++++++++++----
 src/gallium/state_trackers/egl/egl_context.c |  2 +-
 src/gallium/state_trackers/egl/egl_surface.c |  2 +-
 src/gallium/winsys/egl_xlib/egl_xlib.c       |  4 ++--
 src/mesa/drivers/dri/fb/fb_egl.c             |  4 ++--
 12 files changed, 49 insertions(+), 27 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index f316974d83..e8c0c1df5e 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -236,7 +236,7 @@ demoDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    DemoSurface *fs = LookupDemoSurface(surface);
    _eglUnlinkSurface(&fs->Base);
-   if (!fs->Base.IsBound)
+   if (!_eglIsSurfaceBound(&fs->Base))
       free(fs);
    return EGL_TRUE;
 }
@@ -247,7 +247,7 @@ demoDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
    DemoContext *fc = LookupDemoContext(context);
    _eglUnlinkContext(&fc->Base);
-   if (!fc->Base.IsBound)
+   if (!_eglIsContextBound(&fc->Base))
       free(fc);
    return EGL_TRUE;
 }
diff --git a/src/egl/drivers/dri/egldri.c b/src/egl/drivers/dri/egldri.c
index 3f9617a8f9..9e400be624 100644
--- a/src/egl/drivers/dri/egldri.c
+++ b/src/egl/drivers/dri/egldri.c
@@ -296,7 +296,7 @@ _eglDRIDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 
    fs->drawable.destroyDrawable(disp, fs->drawable.private);
 
-   if (!fs->Base.IsBound)
+   if (!_eglIsSurfaceBound(&fs->Base))
       free(fs);
    return EGL_TRUE;
 }
@@ -312,7 +312,7 @@ _eglDRIDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 
    fc->driContext.destroyContext(disp, 0, fc->driContext.private);
 
-   if (!fc->Base.IsBound)
+   if (!_eglIsContextBound(&fc->Base))
       free(fc);
    return EGL_TRUE;
 }
diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 207b1ea779..5ed4b6883f 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -739,7 +739,7 @@ GLX_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    return EGL_TRUE;
    if (surf) {
       _eglUnlinkSurface(surf);
-      if (!surf->IsBound)
+      if (!_eglIsSurfaceBound(surf))
          free(surf);
 
       return EGL_TRUE;
diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index e040efdd43..d8d29fcef4 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -958,7 +958,7 @@ xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
    if (xdri_surf) {
       _eglUnlinkSurface(&xdri_surf->Base);
-      if (!xdri_surf->Base.IsBound) {
+      if (!_eglIsSurfaceBound(&xdri_surf->Base)) {
          /*
          st_unreference_framebuffer(surf->Framebuffer);
          */
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 9ab4286d3a..f8d5687f87 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -96,7 +96,7 @@ _eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
    _EGLContext *context = _eglLookupContext(ctx);
    if (context) {
       _eglUnlinkContext(context);
-      if (!context->IsBound)
+      if (!_eglIsContextBound(context))
          free(context);
       return EGL_TRUE;
    }
@@ -207,7 +207,7 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
     * check if the old context or surfaces need to be deleted
     */
    if (oldDrawSurface != NULL) {
-      oldDrawSurface->IsBound = EGL_FALSE;
+      oldDrawSurface->Binding = NULL;
       if (!_eglIsSurfaceLinked(oldDrawSurface)) {
          /* make sure we don't try to rebind a deleted surface */
          if (draw == oldDrawSurface || draw == oldReadSurface) {
@@ -218,7 +218,7 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
       }
    }
    if (oldReadSurface != NULL && oldReadSurface != oldDrawSurface) {
-      oldReadSurface->IsBound = EGL_FALSE;
+      oldReadSurface->Binding = NULL;
       if (!_eglIsSurfaceLinked(oldReadSurface)) {
          /* make sure we don't try to rebind a deleted surface */
          if (read == oldDrawSurface || read == oldReadSurface) {
@@ -229,7 +229,7 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
       }
    }
    if (oldContext != NULL) {
-      oldContext->IsBound = EGL_FALSE;
+      oldContext->Binding = NULL;
       if (!_eglIsContextLinked(oldContext)) {
          /* make sure we don't try to rebind a deleted context */
          if (ctx == oldContext) {
@@ -248,9 +248,9 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
       }
       ctx->DrawSurface = draw;
       ctx->ReadSurface = read;
-      ctx->IsBound = EGL_TRUE;
-      draw->IsBound = EGL_TRUE;
-      read->IsBound = EGL_TRUE;
+      ctx->Binding = t;
+      draw->Binding = ctx;
+      read->Binding = ctx;
       t->CurrentContexts[apiIndex] = ctx;
    }
    else {
diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 2fb28d38b9..4276c0980e 100644
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -15,12 +15,12 @@ struct _egl_context
    _EGLDisplay *Display;
    _EGLContext *Next;
 
-   _EGLConfig *Config;
-
+   /* The bound status of the context */
+   _EGLThreadInfo *Binding;
    _EGLSurface *DrawSurface;
    _EGLSurface *ReadSurface;
 
-   EGLBoolean IsBound;
+   _EGLConfig *Config;
 
    EGLint ClientAPI; /**< EGL_OPENGL_ES_API, EGL_OPENGL_API, EGL_OPENVG_API */
    EGLint ClientVersion; /**< 1 = OpenGLES 1.x, 2 = OpenGLES 2.x */
@@ -51,4 +51,15 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface rea
 extern EGLBoolean
 _eglCopyContextMESA(_EGLDriver *drv, EGLDisplay dpy, EGLContext source, EGLContext dest, EGLint mask);
 
+
+/**
+ * Return true if the context is bound to a thread.
+ */
+static INLINE EGLBoolean
+_eglIsContextBound(_EGLContext *ctx)
+{
+   return (ctx->Binding != NULL);
+}
+
+
 #endif /* EGLCONTEXT_INCLUDED */
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 9821e63628..bd263fe265 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -413,7 +413,7 @@ _eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    _EGLSurface *surf = _eglLookupSurface(surface);
    if (surf) {
       _eglUnlinkSurface(surf);
-      if (!surf->IsBound)
+      if (!_eglIsSurfaceBound(surf))
          free(surf);
       return EGL_TRUE;
    }
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index f9413eb9d7..8864176844 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -15,12 +15,12 @@ struct _egl_surface
    _EGLSurface *Next;
    EGLSurface Handle;
 
-   _EGLConfig *Config;
-
-   /* May need reference counting here */
-   EGLBoolean IsBound;
+   /* The bound status of the surface */
+   _EGLContext *Binding;
    EGLBoolean BoundToTexture;
 
+   _EGLConfig *Config;
+
    EGLint Type; /* one of EGL_WINDOW_BIT, EGL_PIXMAP_BIT or EGL_PBUFFER_BIT */
    EGLint Width, Height;
    EGLint TextureFormat, TextureTarget;
@@ -100,5 +100,16 @@ _eglCreatePbufferFromClientBuffer(_EGLDriver *drv, EGLDisplay dpy,
 #endif /* EGL_VERSION_1_2 */
 
 
+/**
+ * Return true if the surface is bound to a thread.
+ * A surface bound to a texutre is not considered bound by
+ * this function.
+ */
+static INLINE EGLBoolean
+_eglIsSurfaceBound(_EGLSurface *surf)
+{
+   return (surf->Binding != NULL);
+}
+
 
 #endif /* EGLSURFACE_INCLUDED */
diff --git a/src/gallium/state_trackers/egl/egl_context.c b/src/gallium/state_trackers/egl/egl_context.c
index e2da2180f7..2c8f51cf38 100644
--- a/src/gallium/state_trackers/egl/egl_context.c
+++ b/src/gallium/state_trackers/egl/egl_context.c
@@ -148,7 +148,7 @@ drm_destroy_context(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
 	struct drm_context *c = lookup_drm_context(context);
         _eglUnlinkContext(&c->base);
-	if (!c->base.IsBound) {
+	if (!_eglIsContextBound(&c->base)) {
 		st_destroy_context(c->st);
 		c->pipe->destroy(c->pipe);
 		free(c);
diff --git a/src/gallium/state_trackers/egl/egl_surface.c b/src/gallium/state_trackers/egl/egl_surface.c
index 86f2ea97e5..7413c9b73b 100644
--- a/src/gallium/state_trackers/egl/egl_surface.c
+++ b/src/gallium/state_trackers/egl/egl_surface.c
@@ -366,7 +366,7 @@ drm_destroy_surface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 	struct drm_surface *surf = lookup_drm_surface(surface);
 	_eglUnlinkSurface(&surf->base);
 
-	if (!surf->base.IsBound) {
+	if (!_eglIsSurfaceBound(&surf->base)) {
 		if (surf->screen)
 			drm_takedown_shown_screen(drv, surf->screen);
 		st_unreference_framebuffer(surf->stfb);
diff --git a/src/gallium/winsys/egl_xlib/egl_xlib.c b/src/gallium/winsys/egl_xlib/egl_xlib.c
index e1ddcae97b..1a1dad65f0 100644
--- a/src/gallium/winsys/egl_xlib/egl_xlib.c
+++ b/src/gallium/winsys/egl_xlib/egl_xlib.c
@@ -382,7 +382,7 @@ xlib_eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
    struct xlib_egl_context *context = lookup_context(ctx);
    if (context) {
       _eglUnlinkContext(&context->Base);
-      if (!context->Base.IsBound) {
+      if (!_eglIsContextBound(&context->Base)) {
          /* API-dependent clean-up */
          switch (context->Base.ClientAPI) {
          case EGL_OPENGL_ES_API:
@@ -533,7 +533,7 @@ xlib_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
    struct xlib_egl_surface *surf = lookup_surface(surface);
    if (surf) {
       _eglUnlinkSurface(&surf->Base);
-      if (!surf->Base.IsBound) {
+      if (!_eglIsSurfaceBound(&surf->Base)) {
          XFreeGC(surf->Dpy, surf->Gc);
          st_unreference_framebuffer(surf->Framebuffer);
          free(surf);
diff --git a/src/mesa/drivers/dri/fb/fb_egl.c b/src/mesa/drivers/dri/fb/fb_egl.c
index dee67feb5a..4e41860d8c 100644
--- a/src/mesa/drivers/dri/fb/fb_egl.c
+++ b/src/mesa/drivers/dri/fb/fb_egl.c
@@ -605,7 +605,7 @@ fbDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    fbSurface *fs = Lookup_fbSurface(surface);
    _eglUnlinkSurface(&fs->Base);
-   if (!fs->Base.IsBound)
+   if (!_eglIsSurfaceBound(&fs->Base))
       free(fs);
    return EGL_TRUE;
 }
@@ -616,7 +616,7 @@ fbDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 {
    fbContext *fc = Lookup_fbContext(context);
    _eglUnlinkContext(&fc->Base);
-   if (!fc->Base.IsBound)
+   if (!_eglIsContextBound(&fc->Base))
       free(fc);
    return EGL_TRUE;
 }
-- 
cgit v1.2.3


From 11038989c197e92454ec0dd14e32acec6030e6b7 Mon Sep 17 00:00:00 2001
From: Pauli Nieminen <suokkos@gmail.com>
Date: Sun, 9 Aug 2009 15:22:34 +0300
Subject: egl: Add depend and depend.bak to clean target

Signed-off-by: Pauli Nieminen <suokkos@gmail.com>
---
 src/egl/drivers/dri/Makefile | 1 +
 src/egl/main/Makefile        | 1 +
 2 files changed, 2 insertions(+)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/dri/Makefile b/src/egl/drivers/dri/Makefile
index 567edfae97..7339c97c77 100644
--- a/src/egl/drivers/dri/Makefile
+++ b/src/egl/drivers/dri/Makefile
@@ -55,6 +55,7 @@ install:
 clean:
 	-rm -f *.o
 	-rm -f *.so
+	-rm -f depend depend.bak
 
 depend: $(SOURCES) $(HEADERS)
 	@ echo "running $(MKDEP)"
diff --git a/src/egl/main/Makefile b/src/egl/main/Makefile
index 7cab005214..1d64d94bbb 100644
--- a/src/egl/main/Makefile
+++ b/src/egl/main/Makefile
@@ -74,6 +74,7 @@ install: default
 clean:
 	-rm -f *.o *.so*
 	-rm -f core.*
+	-rm -f depend depend.bak
 
 
 depend: $(SOURCES) $(HEADERS)
-- 
cgit v1.2.3


From 2f2cf461c57974abd89e4917945cc8ae6a67a72e Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Tue, 11 Aug 2009 17:09:39 +0800
Subject: egl: Overhaul driver API.

The motivation is so that drivers do not need to look up and check for
bad display, context, and etc.  It also becomes unnecessary for drivers
to call the link functions.

This commit makes eglapi.[ch] do the lookup and check.  As a result, the
driver API is overhauled, and almost all sources and drivers need
update.  The updates are mainly find and replace with human brains.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/demo/demo.c                  |  83 ++--
 src/egl/drivers/glx/egl_glx.c                | 182 ++++----
 src/egl/main/eglapi.c                        | 669 ++++++++++++++++++++-------
 src/egl/main/eglapi.h                        |  74 +--
 src/egl/main/eglconfig.c                     |  18 +-
 src/egl/main/eglconfig.h                     |   8 +-
 src/egl/main/eglcontext.c                    |  80 +---
 src/egl/main/eglcontext.h                    |  10 +-
 src/egl/main/egldisplay.c                    |  24 +-
 src/egl/main/egldisplay.h                    |   6 +-
 src/egl/main/egldriver.c                     |   2 +-
 src/egl/main/egldriver.h                     |   2 +-
 src/egl/main/eglmisc.c                       |   6 +-
 src/egl/main/eglmisc.h                       |   6 +-
 src/egl/main/eglmode.c                       |  37 +-
 src/egl/main/eglmode.h                       |  10 +-
 src/egl/main/eglscreen.c                     | 109 +----
 src/egl/main/eglscreen.h                     |  24 +-
 src/egl/main/eglsurface.c                    | 131 ++----
 src/egl/main/eglsurface.h                    |  34 +-
 src/gallium/state_trackers/egl/egl_context.c |  24 +-
 src/gallium/state_trackers/egl/egl_surface.c |  49 +-
 src/gallium/state_trackers/egl/egl_tracker.c |   7 +-
 src/gallium/state_trackers/egl/egl_tracker.h |  33 +-
 src/gallium/winsys/egl_xlib/egl_xlib.c       | 154 +++---
 25 files changed, 898 insertions(+), 884 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index e8c0c1df5e..e9e6bac5b1 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -49,9 +49,8 @@ typedef struct demo_context
 
 
 static EGLBoolean
-demoInitialize(_EGLDriver *drv, EGLDisplay dpy, EGLint *major, EGLint *minor)
+demoInitialize(_EGLDriver *drv, _EGLDisplay *disp, EGLint *major, EGLint *minor)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLScreen *scrn;
    EGLint i;
 
@@ -95,7 +94,7 @@ demoInitialize(_EGLDriver *drv, EGLDisplay dpy, EGLint *major, EGLint *minor)
 
 
 static EGLBoolean
-demoTerminate(_EGLDriver *drv, EGLDisplay dpy)
+demoTerminate(_EGLDriver *drv, _EGLDisplay *dpy)
 {
    /*DemoDriver *demo = DEMO_DRIVER(dpy);*/
    free(drv);
@@ -104,62 +103,48 @@ demoTerminate(_EGLDriver *drv, EGLDisplay dpy)
 
 
 static DemoContext *
-LookupDemoContext(EGLContext ctx)
+LookupDemoContext(_EGLContext *c)
 {
-   _EGLContext *c = _eglLookupContext(ctx);
    return (DemoContext *) c;
 }
 
 
 static DemoSurface *
-LookupDemoSurface(EGLSurface surf)
+LookupDemoSurface(_EGLSurface *s)
 {
-   _EGLSurface *s = _eglLookupSurface(surf);
    return (DemoSurface *) s;
 }
 
 
-
-static EGLContext
-demoCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list)
+static _EGLContext *
+demoCreateContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, _EGLContext *share_list, const EGLint *attrib_list)
 {
-   _EGLConfig *conf;
    DemoContext *c;
    int i;
 
-   conf = _eglLookupConfig(drv, dpy, config);
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreateContext");
-      return EGL_NO_CONTEXT;
-   }
-
    for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
       switch (attrib_list[i]) {
          /* no attribs defined for now */
       default:
          _eglError(EGL_BAD_ATTRIBUTE, "eglCreateContext");
-         return EGL_NO_CONTEXT;
+         return NULL;
       }
    }
 
    c = (DemoContext *) calloc(1, sizeof(DemoContext));
    if (!c)
-      return EGL_NO_CONTEXT;
+      return NULL;
 
    _eglInitContext(drv, &c->Base, conf, attrib_list);
    c->DemoStuff = 1;
    printf("demoCreateContext\n");
 
-   /* link to display */
-   _eglLinkContext(&c->Base, _eglLookupDisplay(dpy));
-   assert(_eglGetContextHandle(&c->Base));
-
-   return _eglGetContextHandle(&c->Base);
+   return &c->Base;
 }
 
 
-static EGLSurface
-demoCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list)
+static _EGLSurface *
+demoCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativeWindowType window, const EGLint *attrib_list)
 {
    int i;
    for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
@@ -167,75 +152,65 @@ demoCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, Nativ
          /* no attribs at this time */
       default:
          _eglError(EGL_BAD_ATTRIBUTE, "eglCreateWindowSurface");
-         return EGL_NO_SURFACE;
+         return NULL;
       }
    }
    printf("eglCreateWindowSurface()\n");
    /* XXX unfinished */
 
-   return EGL_NO_SURFACE;
+   return NULL;
 }
 
 
-static EGLSurface
-demoCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list)
+static _EGLSurface *
+demoCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativePixmapType pixmap, const EGLint *attrib_list)
 {
-   _EGLConfig *conf;
    EGLint i;
 
-   conf = _eglLookupConfig(drv, dpy, config);
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreatePixmapSurface");
-      return EGL_NO_SURFACE;
-   }
-
    for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
       switch (attrib_list[i]) {
          /* no attribs at this time */
       default:
          _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePixmapSurface");
-         return EGL_NO_SURFACE;
+         return NULL;
       }
    }
 
    if (conf->Attrib[EGL_SURFACE_TYPE - FIRST_ATTRIB] == 0) {
       _eglError(EGL_BAD_MATCH, "eglCreatePixmapSurface");
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
    printf("eglCreatePixmapSurface()\n");
-   return EGL_NO_SURFACE;
+   return NULL;
 }
 
 
-static EGLSurface
-demoCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+static _EGLSurface *
+demoCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                          const EGLint *attrib_list)
 {
    DemoSurface *surf = (DemoSurface *) calloc(1, sizeof(DemoSurface));
-   _EGLConfig *conf;
 
    if (!surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
-   conf = _eglLookupConfig(drv, dpy, config);
    if (!_eglInitSurface(drv, &surf->Base, EGL_PBUFFER_BIT,
                         conf, attrib_list)) {
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
    /* a real driver would allocate the pbuffer memory here */
 
-   return surf->Base.Handle;
+   return &surf->Base;
 }
 
 
 static EGLBoolean
-demoDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+demoDestroySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface)
 {
    DemoSurface *fs = LookupDemoSurface(surface);
-   _eglUnlinkSurface(&fs->Base);
    if (!_eglIsSurfaceBound(&fs->Base))
       free(fs);
    return EGL_TRUE;
@@ -243,10 +218,9 @@ demoDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 
 
 static EGLBoolean
-demoDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
+demoDestroyContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *context)
 {
    DemoContext *fc = LookupDemoContext(context);
-   _eglUnlinkContext(&fc->Base);
    if (!_eglIsContextBound(&fc->Base))
       free(fc);
    return EGL_TRUE;
@@ -254,15 +228,12 @@ demoDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 
 
 static EGLBoolean
-demoMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext context)
+demoMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *drawSurf, _EGLSurface *readSurf, _EGLContext *ctx)
 {
    /*DemoDriver *demo = DEMO_DRIVER(dpy);*/
-   DemoSurface *readSurf = LookupDemoSurface(read);
-   DemoSurface *drawSurf = LookupDemoSurface(draw);
-   DemoContext *ctx = LookupDemoContext(context);
    EGLBoolean b;
 
-   b = _eglMakeCurrent(drv, dpy, draw, read, context);
+   b = _eglMakeCurrent(drv, dpy, drawSurf, readSurf, ctx);
    if (!b)
       return EGL_FALSE;
 
diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 5ed4b6883f..607e649e5c 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -157,6 +157,13 @@ GLX_egl_surface(_EGLSurface *surf)
    return (struct GLX_egl_surface *) surf;
 }
 
+static int
+GLX_egl_config_id(_EGLConfig *conf)
+{
+   /* see create_configs */
+   return (int) _eglPointerToUInt(_eglGetConfigHandle(conf)) - 1;
+}
+
 static GLboolean
 get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
                    struct visual_attribs *attribs)
@@ -351,7 +358,6 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
    int numVisuals;
    long mask;
    int i;
-   int egl_configs = 1;
    struct visual_attribs attribs;
 
    GLX_drv->fbconfigs = NULL;
@@ -441,11 +447,10 @@ end:
  * Called via eglInitialize(), GLX_drv->API.Initialize().
  */
 static EGLBoolean
-GLX_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
+GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp,
                    EGLint *minor, EGLint *major)
 {
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
 
    _eglLog(_EGL_DEBUG, "GLX: eglInitialize");
 
@@ -504,10 +509,8 @@ FreeDisplayExt(Display *dpy)
  * Called via eglTerminate(), drv->API.Terminate().
  */
 static EGLBoolean
-GLX_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
+GLX_eglTerminate(_EGLDriver *drv, _EGLDisplay *disp)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-
    _eglLog(_EGL_DEBUG, "GLX: eglTerminate");
 
    FreeDisplayExt(disp->Xdpy);
@@ -519,42 +522,37 @@ GLX_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 /**
  * Called via eglCreateContext(), drv->API.CreateContext().
  */
-static EGLContext
-GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
-                      EGLContext share_list, const EGLint *attrib_list)
+static _EGLContext *
+GLX_eglCreateContext(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
+                      _EGLContext *share_list, const EGLint *attrib_list)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct GLX_egl_context *GLX_ctx = CALLOC_STRUCT(GLX_egl_context);
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
-   struct GLX_egl_context *GLX_ctx_shared = NULL;
-   _EGLConfig *conf;
+   struct GLX_egl_context *GLX_ctx_shared = GLX_egl_context(share_list);
 
    if (!GLX_ctx)
-      return EGL_NO_CONTEXT;
-
-   conf = _eglLookupConfig(drv, dpy, config);
-   assert(conf);
+      return NULL;
 
    if (!_eglInitContext(drv, &GLX_ctx->Base, conf, attrib_list)) {
       free(GLX_ctx);
-      return EGL_NO_CONTEXT;
-   }
-
-   if (share_list != EGL_NO_CONTEXT) {
-      _EGLContext *shareCtx = _eglLookupContext(share_list);
-      if (!shareCtx) {
-         _eglError(EGL_BAD_CONTEXT, "eglCreateContext(share_list)");
-         return EGL_FALSE;
-      }
-      GLX_ctx_shared = GLX_egl_context(shareCtx);
+      return NULL;
    }
 
 #ifdef GLX_VERSION_1_3
    if (GLX_drv->fbconfigs)
-      GLX_ctx->context = glXCreateNewContext(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], GLX_RGBA_TYPE, GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
+      GLX_ctx->context =
+         glXCreateNewContext(disp->Xdpy,
+                             GLX_drv->fbconfigs[GLX_egl_config_id(conf)],
+                             GLX_RGBA_TYPE,
+                             GLX_ctx_shared ? GLX_ctx_shared->context : NULL,
+                             GL_TRUE);
    else
 #endif
-      GLX_ctx->context = glXCreateContext(disp->Xdpy, &GLX_drv->visuals[(int)config-1], GLX_ctx_shared ? GLX_ctx_shared->context : NULL, GL_TRUE);
+      GLX_ctx->context =
+         glXCreateContext(disp->Xdpy,
+                          &GLX_drv->visuals[GLX_egl_config_id(conf)],
+                          GLX_ctx_shared ? GLX_ctx_shared->context : NULL,
+                          GL_TRUE);
    if (!GLX_ctx->context)
       return EGL_FALSE;
 
@@ -564,7 +562,7 @@ GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
       return EGL_FALSE;
 #endif
 
-   return _eglLinkContext(&GLX_ctx->Base, disp);
+   return &GLX_ctx->Base;
 }
 
 
@@ -572,18 +570,14 @@ GLX_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
  */
 static EGLBoolean
-GLX_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
-                    EGLSurface r, EGLContext context)
+GLX_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
+                   _EGLSurface *rsurf, _EGLContext *ctx)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   _EGLContext *ctx = _eglLookupContext(context);
-   _EGLSurface *dsurf = _eglLookupSurface(d);
-   _EGLSurface *rsurf = _eglLookupSurface(r);
    struct GLX_egl_surface *GLX_dsurf = GLX_egl_surface(dsurf);
    struct GLX_egl_surface *GLX_rsurf = GLX_egl_surface(rsurf);
    struct GLX_egl_context *GLX_ctx = GLX_egl_context(ctx);
 
-   if (!_eglMakeCurrent(drv, dpy, d, r, context))
+   if (!_eglMakeCurrent(drv, disp, dsurf, rsurf, ctx))
       return EGL_FALSE;
 
 #ifdef GLX_VERSION_1_3
@@ -612,104 +606,86 @@ get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
 /**
  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
  */
-static EGLSurface
-GLX_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+static _EGLSurface *
+GLX_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
                             NativeWindowType window, const EGLint *attrib_list)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct GLX_egl_surface *GLX_surf;
    uint width, height;
-   _EGLConfig *conf;
-
-   conf = _eglLookupConfig(drv, dpy, config);
-   assert(conf);
 
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
    if (!GLX_surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_WINDOW_BIT,
                         conf, attrib_list)) {
       free(GLX_surf);
-      return EGL_FALSE;
+      return NULL;
    }
 
-   _eglLinkSurface(&GLX_surf->Base, disp);
-
    GLX_surf->drawable = window;
    get_drawable_size(disp->Xdpy, window, &width, &height);
    GLX_surf->Base.Width = width;
    GLX_surf->Base.Height = height;
 
-   return _eglGetSurfaceHandle(&GLX_surf->Base);
+   return &GLX_surf->Base;
 }
 
 #ifdef GLX_VERSION_1_3
-static EGLSurface
-GLX_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, 
+static _EGLSurface *
+GLX_eglCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
 			   NativePixmapType pixmap, const EGLint *attrib_list)
 {
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct GLX_egl_surface *GLX_surf;
-   _EGLConfig *conf;
    int i;
 
-   conf = _eglLookupConfig(drv, dpy, config);
-   assert(conf);
-
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
    if (!GLX_surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_PIXMAP_BIT,
                         conf, attrib_list)) {
       free(GLX_surf);
-      return EGL_FALSE;
+      return NULL;
    }
 
-   _eglLinkSurface(&GLX_surf->Base, disp);
-
    for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
       switch (attrib_list[i]) {
          /* no attribs at this time */
       default:
          _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePixmapSurface");
-         return EGL_NO_SURFACE;
+         return NULL;
       }
    }
 
-   GLX_surf->drawable = glXCreatePixmap(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], pixmap, NULL);
+   GLX_surf->drawable =
+      glXCreatePixmap(disp->Xdpy,
+                      GLX_drv->fbconfigs[GLX_egl_config_id(conf)],
+                      pixmap, NULL);
 
-   return _eglGetSurfaceHandle(&GLX_surf->Base);
+   return &GLX_surf->Base;
 }
 
-static EGLSurface
-GLX_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+static _EGLSurface *
+GLX_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
                             const EGLint *attrib_list)
 {
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct GLX_egl_surface *GLX_surf;
-   _EGLConfig *conf;
    int attribs[5];
    int i = 0, j = 0;
 
-   conf = _eglLookupConfig(drv, dpy, config);
-   assert(conf);
-
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
    if (!GLX_surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_PBUFFER_BIT,
                         conf, attrib_list)) {
       free(GLX_surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
-   _eglLinkSurface(&GLX_surf->Base, disp);
-
    while(attrib_list[i] != EGL_NONE) {
       switch (attrib_list[i]) {
          case EGL_WIDTH:
@@ -725,38 +701,40 @@ GLX_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    }
    attribs[j++] = 0;
 
-   GLX_surf->drawable = glXCreatePbuffer(disp->Xdpy, GLX_drv->fbconfigs[(int)config-1], attribs);
+   GLX_surf->drawable =
+      glXCreatePbuffer(disp->Xdpy,
+                       GLX_drv->fbconfigs[GLX_egl_config_id(conf)], attribs);
 
-   return _eglGetSurfaceHandle(&GLX_surf->Base);
+   return &GLX_surf->Base;
 }
 #endif
 
 static EGLBoolean
-GLX_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+GLX_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   _EGLSurface *surf = _eglLookupSurface(surface);
-   return EGL_TRUE;
-   if (surf) {
-      _eglUnlinkSurface(surf);
-      if (!_eglIsSurfaceBound(surf))
-         free(surf);
-
-      return EGL_TRUE;
-   }
-   else {
-      _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
-      return EGL_FALSE;
+   if (!_eglIsSurfaceBound(surf)) {
+      struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
+      switch (surf->Type) {
+      case EGL_PBUFFER_BIT:
+         glXDestroyPbuffer(disp->Xdpy, GLX_surf->drawable);
+         break;
+      case EGL_PIXMAP_BIT:
+         glXDestroyPixmap(disp->Xdpy, GLX_surf->drawable);
+         break;
+      default:
+         break;
+      }
+      free(surf);
    }
+
+   return EGL_TRUE;
 }
 
 
 static EGLBoolean
-GLX_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+GLX_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
                      EGLint buffer)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   _EGLSurface *surf = _eglLookupSurface(surface);
    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 
    /* buffer ?? */
@@ -767,11 +745,9 @@ GLX_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
 
 
 static EGLBoolean
-GLX_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+GLX_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
                         EGLint buffer)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   _EGLSurface *surf = _eglLookupSurface(surface);
    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 
    /* buffer ?? */
@@ -782,16 +758,14 @@ GLX_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
 
 
 static EGLBoolean
-GLX_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
+GLX_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   _EGLSurface *surf = _eglLookupSurface(draw);
-   struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
+   struct GLX_egl_surface *GLX_surf = GLX_egl_surface(draw);
 
    _eglLog(_EGL_DEBUG, "GLX: EGL SwapBuffers 0x%x",draw);
 
    /* error checking step: */
-   if (!_eglSwapBuffers(drv, dpy, draw))
+   if (!_eglSwapBuffers(drv, disp, draw))
       return EGL_FALSE;
 
    glXSwapBuffers(disp->Xdpy, GLX_surf->drawable);
@@ -810,13 +784,14 @@ GLX_eglGetProcAddress(const char *procname)
     * some point.
     */
    _EGLProc (*get_proc_addr)(const char *procname);
+   _EGLProc proc_addr;
    get_proc_addr = dlsym(NULL, "st_get_proc_address");
    if (get_proc_addr)
       return get_proc_addr(procname);
 
-   get_proc_addr = glXGetProcAddress((const GLubyte *)procname);
-   if (get_proc_addr)
-      return get_proc_addr(procname);
+   proc_addr = glXGetProcAddress((const GLubyte *)procname);
+   if (proc_addr)
+      return proc_addr;
 
    return (_EGLProc)dlsym(NULL, procname);
 }
@@ -831,7 +806,6 @@ _eglMain(_EGLDisplay *disp, const char *args)
 {
    struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
    char *env;
-   int maj = 0, min = 0;
 
    if (!GLX_drv)
       return NULL;
diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index fde6b7316c..e8a5b18912 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -29,7 +29,6 @@
  */
 
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -39,7 +38,9 @@
 #include "eglglobals.h"
 #include "egldriver.h"
 #include "eglsurface.h"
-
+#include "eglconfig.h"
+#include "eglscreen.h"
+#include "eglmode.h"
 
 
 /**
@@ -67,232 +68,481 @@ eglGetDisplay(NativeDisplayType nativeDisplay)
 EGLBoolean EGLAPIENTRY
 eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 {
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLDriver *drv;
    EGLint major_int, minor_int;
 
-   if (dpy) {
-      EGLBoolean retVal;
-      _EGLDisplay *dpyPriv = _eglLookupDisplay(dpy);
-      if (!dpyPriv) {
-         return EGL_FALSE;
-      }
-      dpyPriv->Driver = _eglOpenDriver(dpyPriv,
-                                       dpyPriv->DriverName,
-                                       dpyPriv->DriverArgs);
-      if (!dpyPriv->Driver) {
-         return EGL_FALSE;
-      }
-      /* Initialize the particular driver now */
-      retVal = dpyPriv->Driver->API.Initialize(dpyPriv->Driver, dpy,
-                                               &major_int, &minor_int);
-
-      dpyPriv->Driver->APImajor = major_int;
-      dpyPriv->Driver->APIminor = minor_int;
-      snprintf(dpyPriv->Driver->Version, sizeof(dpyPriv->Driver->Version),
-               "%d.%d (%s)", major_int, minor_int, dpyPriv->Driver->Name);
-
-      /* Update applications version of major and minor if not NULL */
-      if((major != NULL) && (minor != NULL))
-      {
-         *major = major_int;
-         *minor = minor_int;
+   if (!disp)
+      return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+
+   drv = disp->Driver;
+   if (!drv) {
+      drv = _eglOpenDriver(disp, disp->DriverName, disp->DriverArgs);
+      if (!drv)
+         return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
+
+      /* Initialize the particular display now */
+      if (!drv->API.Initialize(drv, disp, &major_int, &minor_int)) {
+         _eglCloseDriver(drv, disp);
+         return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
       }
 
-      return retVal;
+      drv->APImajor = major_int;
+      drv->APIminor = minor_int;
+      snprintf(drv->Version, sizeof(drv->Version),
+               "%d.%d (%s)", major_int, minor_int, drv->Name);
+
+      disp->Driver = drv;
+   } else {
+      major_int = drv->APImajor;
+      minor_int = drv->APIminor;
    }
-   return EGL_FALSE;
+
+   /* Update applications version of major and minor if not NULL */
+   if ((major != NULL) && (minor != NULL)) {
+      *major = major_int;
+      *minor = minor_int;
+   }
+
+   return EGL_TRUE;
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglTerminate(EGLDisplay dpy)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   if (drv)
-      return _eglCloseDriver(drv, dpy);
-   else
-      return EGL_FALSE;
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLDriver *drv;
+
+   if (!disp)
+      return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+
+   drv = disp->Driver;
+   if (drv) {
+      /* TODO drv->API.Terminate should be called here */
+      _eglCloseDriver(drv, disp);
+      disp->Driver = NULL;
+   }
+
+   return EGL_TRUE;
+}
+
+
+/**
+ * A bunch of check functions and declare macros to simply error checking.
+ */
+static INLINE _EGLDriver *
+_eglCheckDisplay(_EGLDisplay *disp, const char *msg)
+{
+   if (!disp) {
+      _eglError(EGL_BAD_DISPLAY, msg);
+      return NULL;
+   }
+   if (!disp->Driver) {
+      _eglError(EGL_NOT_INITIALIZED, msg);
+      return NULL;
+   }
+   return disp->Driver;
+}
+
+
+static INLINE _EGLDriver *
+_eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
+{
+   _EGLDriver *drv = _eglCheckDisplay(disp, msg);
+   if (!drv)
+      return NULL;
+   if (!surf) {
+      _eglError(EGL_BAD_SURFACE, msg);
+      return NULL;
+   }
+   return drv;
 }
 
 
+static INLINE _EGLDriver *
+_eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
+{
+   _EGLDriver *drv = _eglCheckDisplay(disp, msg);
+   if (!drv)
+      return NULL;
+   if (!context) {
+      _eglError(EGL_BAD_CONTEXT, msg);
+      return NULL;
+   }
+   return drv;
+}
+
+
+static INLINE _EGLDriver *
+_eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
+{
+   _EGLDriver *drv = _eglCheckDisplay(disp, msg);
+   if (!drv)
+      return NULL;
+   if (!conf) {
+      _eglError(EGL_BAD_CONFIG, msg);
+      return NULL;
+   }
+   return drv;
+}
+
+
+#define _EGL_DECLARE_DD(dpy)                                   \
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
+   _EGLDriver *drv;                                            \
+   do {                                                        \
+      drv = _eglCheckDisplay(disp, __FUNCTION__);              \
+      if (!drv)                                                \
+         return EGL_FALSE;                                     \
+   } while (0)
+
+
+#define _EGL_DECLARE_DD_AND_SURFACE(dpy, surface)              \
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
+   _EGLSurface *surf = _eglLookupSurface((surface), disp);     \
+   _EGLDriver *drv;                                            \
+   do {                                                        \
+      drv = _eglCheckSurface(disp, surf, __FUNCTION__);        \
+      if (!drv)                                                \
+         return EGL_FALSE;                                     \
+   } while (0)
+
+
+#define _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx)                  \
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
+   _EGLContext *context = _eglLookupContext((ctx), disp);      \
+   _EGLDriver *drv;                                            \
+   do {                                                        \
+      drv = _eglCheckContext(disp, context, __FUNCTION__);     \
+      if (!drv)                                                \
+         return EGL_FALSE;                                     \
+   } while (0)
+
+
+#ifdef EGL_MESA_screen_surface
+
+
+static INLINE _EGLDriver *
+_eglCheckScreen(_EGLDisplay *disp, _EGLScreen *scrn, const char *msg)
+{
+   _EGLDriver *drv = _eglCheckDisplay(disp, msg);
+   if (!drv)
+      return NULL;
+   if (!scrn) {
+      _eglError(EGL_BAD_SCREEN_MESA, msg);
+      return NULL;
+   }
+   return drv;
+}
+
+
+static INLINE _EGLDriver *
+_eglCheckMode(_EGLDisplay *disp, _EGLMode *m, const char *msg)
+{
+   _EGLDriver *drv = _eglCheckDisplay(disp, msg);
+   if (!drv)
+      return NULL;
+   if (!m) {
+      _eglError(EGL_BAD_MODE_MESA, msg);
+      return NULL;
+   }
+   return drv;
+}
+
+
+#define _EGL_DECLARE_DD_AND_SCREEN(dpy, screen)                \
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
+   _EGLScreen *scrn = _eglLookupScreen((screen), disp);        \
+   _EGLDriver *drv;                                            \
+   do {                                                        \
+      drv = _eglCheckScreen(disp, scrn, __FUNCTION__);         \
+      if (!drv)                                                \
+         return EGL_FALSE;                                     \
+   } while (0)
+
+
+#define _EGL_DECLARE_DD_AND_MODE(dpy, mode)                    \
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
+   _EGLMode *m = _eglLookupMode((mode), disp);                 \
+   _EGLDriver *drv;                                            \
+   do {                                                        \
+      drv = _eglCheckMode(disp, m, __FUNCTION__);              \
+      if (!drv)                                                \
+         return EGL_FALSE;                                     \
+   } while (0)
+
+
+#endif /* EGL_MESA_screen_surface */
+
+
 const char * EGLAPIENTRY
 eglQueryString(EGLDisplay dpy, EGLint name)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   if (drv)
-      return drv->API.QueryString(drv, dpy, name);
-   else
-      return NULL;
+   _EGL_DECLARE_DD(dpy);
+   return drv->API.QueryString(drv, disp, name);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
+eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
+              EGLint config_size, EGLint *num_config)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   /* XXX check drv for null in remaining functions */
-   return drv->API.GetConfigs(drv, dpy, configs, config_size, num_config);
+   _EGL_DECLARE_DD(dpy);
+   return drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
+eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
+                EGLint config_size, EGLint *num_config)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.ChooseConfig(drv, dpy, attrib_list, configs, config_size, num_config);
+   _EGL_DECLARE_DD(dpy);
+   return drv->API.ChooseConfig(drv, disp, attrib_list, configs,
+                                config_size, num_config);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
+eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
+                   EGLint attribute, EGLint *value)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.GetConfigAttrib(drv, dpy, config, attribute, value);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLConfig *conf = _eglLookupConfig(config, disp);
+   _EGLDriver *drv;
+
+   drv = _eglCheckConfig(disp, conf, __FUNCTION__);
+   if (!drv)
+      return EGL_FALSE;
+
+   return drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
 }
 
 
 EGLContext EGLAPIENTRY
-eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list)
-{
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.CreateContext(drv, dpy, config, share_list, attrib_list);
+eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
+                 const EGLint *attrib_list)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLConfig *conf = _eglLookupConfig(config, disp);
+   _EGLContext *share = _eglLookupContext(share_list, disp);
+   _EGLDriver *drv;
+   _EGLContext *context;
+
+   drv = _eglCheckConfig(disp, conf, __FUNCTION__);
+   if (!drv)
+      return EGL_NO_CONTEXT;
+   if (!share && share_list != EGL_NO_CONTEXT) {
+      _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
+      return EGL_NO_CONTEXT;
+   }
+
+   context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
+   if (context)
+      return _eglLinkContext(context, disp);
+   else
+      return EGL_NO_CONTEXT;
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.DestroyContext(drv, dpy, ctx);
+   _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
+   _eglUnlinkContext(context);
+   return drv->API.DestroyContext(drv, disp, context);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
+eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
+               EGLContext ctx)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.MakeCurrent(drv, dpy, draw, read, ctx);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLContext *context = _eglLookupContext(ctx, disp);
+   _EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
+   _EGLSurface *read_surf = _eglLookupSurface(read, disp);
+   _EGLDriver *drv;
+
+   drv = _eglCheckDisplay(disp, __FUNCTION__);
+   if (!drv)
+      return EGL_FALSE;
+   if (!context && ctx != EGL_NO_CONTEXT)
+      return _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
+   if ((!draw_surf && draw != EGL_NO_SURFACE) ||
+       (!read_surf && read != EGL_NO_SURFACE))
+      return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+
+   return drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
+eglQueryContext(EGLDisplay dpy, EGLContext ctx,
+                EGLint attribute, EGLint *value)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.QueryContext(drv, dpy, ctx, attribute, value);
+   _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
+   return drv->API.QueryContext(drv, disp, context, attribute, value);
 }
 
 
 EGLSurface EGLAPIENTRY
-eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list)
+eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
+                       NativeWindowType window, const EGLint *attrib_list)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.CreateWindowSurface(drv, dpy, config, window, attrib_list);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLConfig *conf = _eglLookupConfig(config, disp);
+   _EGLDriver *drv;
+   _EGLSurface *surf;
+
+   drv = _eglCheckConfig(disp, conf, __FUNCTION__);
+   if (!drv)
+      return EGL_NO_SURFACE;
+
+   surf = drv->API.CreateWindowSurface(drv, disp, conf, window, attrib_list);
+   if (surf)
+      return _eglLinkSurface(surf, disp);
+   else
+      return EGL_NO_SURFACE;
 }
 
 
 EGLSurface EGLAPIENTRY
-eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list)
+eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
+                       NativePixmapType pixmap, const EGLint *attrib_list)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.CreatePixmapSurface(drv, dpy, config, pixmap, attrib_list);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLConfig *conf = _eglLookupConfig(config, disp);
+   _EGLDriver *drv;
+   _EGLSurface *surf;
+
+   drv = _eglCheckConfig(disp, conf, __FUNCTION__);
+   if (!drv)
+      return EGL_NO_SURFACE;
+
+   surf = drv->API.CreatePixmapSurface(drv, disp, conf, pixmap, attrib_list);
+   if (surf)
+      return _eglLinkSurface(surf, disp);
+   else
+      return EGL_NO_SURFACE;
 }
 
 
 EGLSurface EGLAPIENTRY
-eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
+eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
+                        const EGLint *attrib_list)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.CreatePbufferSurface(drv, dpy, config, attrib_list);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLConfig *conf = _eglLookupConfig(config, disp);
+   _EGLDriver *drv;
+   _EGLSurface *surf;
+
+   drv = _eglCheckConfig(disp, conf, __FUNCTION__);
+   if (!drv)
+      return EGL_NO_SURFACE;
+
+   surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
+   if (surf)
+      return _eglLinkSurface(surf, disp);
+   else
+      return EGL_NO_SURFACE;
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.DestroySurface(drv, dpy, surface);
+   _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+   _eglUnlinkSurface(surf);
+   return drv->API.DestroySurface(drv, disp, surf);
 }
 
-
 EGLBoolean EGLAPIENTRY
-eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
+eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
+                EGLint attribute, EGLint *value)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.QuerySurface(drv, dpy, surface, attribute, value);
+   _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+   return drv->API.QuerySurface(drv, disp, surf, attribute, value);
 }
 
-
 EGLBoolean EGLAPIENTRY
-eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
+eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
+                 EGLint attribute, EGLint value)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.SurfaceAttrib(drv, dpy, surface, attribute, value);
+   _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+   return drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.BindTexImage(drv, dpy, surface, buffer);
+   _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+   return drv->API.BindTexImage(drv, disp, surf, buffer);
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.ReleaseTexImage(drv, dpy, surface, buffer);
+   _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+   return drv->API.ReleaseTexImage(drv, disp, surf, buffer);
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglSwapInterval(EGLDisplay dpy, EGLint interval)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.SwapInterval(drv, dpy, interval);
+   _EGL_DECLARE_DD(dpy);
+   return drv->API.SwapInterval(drv, disp, interval);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
+eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.SwapBuffers(drv, dpy, draw);
+   _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+   return drv->API.SwapBuffers(drv, disp, surf);
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, NativePixmapType target)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.CopyBuffers(drv, dpy, surface, target);
+   _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+   return drv->API.CopyBuffers(drv, disp, surf, target);
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglWaitGL(void)
 {
-   EGLDisplay dpy = eglGetCurrentDisplay();
-   if (dpy != EGL_NO_DISPLAY) {
-      _EGLDriver *drv = _eglLookupDriver(dpy);
-      return drv->API.WaitGL(drv, dpy);
-   }
-   else
-      return EGL_FALSE;
+   _EGLDisplay *disp = _eglGetCurrentDisplay();
+   _EGLDriver *drv;
+
+   if (!disp)
+      return EGL_TRUE;
+
+   /* a current display is always initialized */
+   drv = disp->Driver;
+
+   return drv->API.WaitGL(drv, disp);
 }
 
 
 EGLBoolean EGLAPIENTRY
 eglWaitNative(EGLint engine)
 {
-   EGLDisplay dpy = eglGetCurrentDisplay();
-   if (dpy != EGL_NO_DISPLAY) {
-      _EGLDriver *drv = _eglLookupDriver(dpy);
-      return drv->API.WaitNative(drv, dpy, engine);
-   }
-   else
-      return EGL_FALSE;
+   _EGLDisplay *disp = _eglGetCurrentDisplay();
+   _EGLDriver *drv;
+
+   if (!disp)
+      return EGL_TRUE;
+
+   /* a current display is always initialized */
+   drv = disp->Driver;
+
+   return drv->API.WaitNative(drv, disp, engine);
 }
 
 
@@ -420,111 +670,168 @@ eglChooseModeMESA(EGLDisplay dpy, EGLScreenMESA screen,
                   const EGLint *attrib_list, EGLModeMESA *modes,
                   EGLint modes_size, EGLint *num_modes)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   if (drv)
-      return drv->API.ChooseModeMESA(drv, dpy, screen, attrib_list, modes, modes_size, num_modes);
-   else
-      return EGL_FALSE;
+   _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
+   return drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
+                                  modes, modes_size, num_modes);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes, EGLint mode_size, EGLint *num_mode)
+eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes,
+                EGLint mode_size, EGLint *num_mode)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   if (drv)
-      return drv->API.GetModesMESA(drv, dpy, screen, modes, mode_size, num_mode);
-   else
-      return EGL_FALSE;
+   _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
+   return drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode, EGLint attribute, EGLint *value)
+eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode,
+                     EGLint attribute, EGLint *value)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   if (drv)
-      return drv->API.GetModeAttribMESA(drv, dpy, mode, attribute, value);
-   else
-      return EGL_FALSE;
+   _EGL_DECLARE_DD_AND_MODE(dpy, mode);
+   return drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
 }
 
 
 EGLBoolean EGLAPIENTRY
-eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest, EGLint mask)
-{
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   if (drv)
-      return drv->API.CopyContextMESA(drv, dpy, source, dest, mask);
-   else
+eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest,
+                   EGLint mask)
+{
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLContext *source_context = _eglLookupContext(source, disp);
+   _EGLContext *dest_context = _eglLookupContext(dest, disp);
+   _EGLDriver *drv;
+
+   drv = _eglCheckContext(disp, source_context, __FUNCTION__);
+   if (!drv || !dest_context) {
+      if (drv)
+         _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
       return EGL_FALSE;
+   }
+
+   return drv->API.CopyContextMESA(drv, disp, source_context, dest_context,
+                                   mask);
 }
 
 
 EGLBoolean
-eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens, EGLint max_screens, EGLint *num_screens)
+eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens,
+                  EGLint max_screens, EGLint *num_screens)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   if (drv)
-      return drv->API.GetScreensMESA(drv, dpy, screens, max_screens, num_screens);
-   else
-      return EGL_FALSE;
+   _EGL_DECLARE_DD(dpy);
+   return drv->API.GetScreensMESA(drv, disp, screens,
+                                  max_screens, num_screens);
 }
 
 
 EGLSurface
-eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
+eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
+                           const EGLint *attrib_list)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.CreateScreenSurfaceMESA(drv, dpy, config, attrib_list);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLConfig *conf = _eglLookupConfig(config, disp);
+   _EGLDriver *drv;
+   _EGLSurface *surf;
+
+   drv = _eglCheckConfig(disp, conf, __FUNCTION__);
+   if (!drv)
+      return EGL_NO_SURFACE;
+
+   surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
+   if (surf)
+      return _eglLinkSurface(surf, disp);
+   else
+      return EGL_NO_SURFACE;
 }
 
 
 EGLBoolean
-eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen, EGLSurface surface, EGLModeMESA mode)
+eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen,
+                         EGLSurface surface, EGLModeMESA mode)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.ShowScreenSurfaceMESA(drv, dpy, screen, surface, mode);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
+   _EGLSurface *surf = _eglLookupSurface(surface, disp);
+   _EGLMode *m = _eglLookupMode(mode, disp);
+   _EGLDriver *drv;
+
+   drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
+   if (!drv)
+      return EGL_FALSE;
+   if (!surf && surface != EGL_NO_SURFACE)
+      return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+   if (!m && mode != EGL_NO_MODE_MESA)
+      return _eglError(EGL_BAD_MODE_MESA, __FUNCTION__);
+
+   return drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
 }
 
 
 EGLBoolean
 eglScreenPositionMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.ScreenPositionMESA(drv, dpy, screen, x, y);
+   _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
+   return drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
 }
 
 
 EGLBoolean
-eglQueryScreenMESA( EGLDisplay dpy, EGLScreenMESA screen, EGLint attribute, EGLint *value)
+eglQueryScreenMESA(EGLDisplay dpy, EGLScreenMESA screen,
+                   EGLint attribute, EGLint *value)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.QueryScreenMESA(drv, dpy, screen, attribute, value);
+   _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
+   return drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
 }
 
 
 EGLBoolean
-eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLSurface *surface)
+eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen,
+                          EGLSurface *surface)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.QueryScreenSurfaceMESA(drv, dpy, screen, surface);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
+   _EGLDriver *drv;
+   _EGLSurface *surf;
+
+   drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
+   if (!drv)
+      return EGL_FALSE;
+
+   if (drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf) != EGL_TRUE)
+      surf = NULL;
+   if (surface)
+      *surface = _eglGetSurfaceHandle(surf);
+   return (surf != NULL);
 }
 
 
 EGLBoolean
 eglQueryScreenModeMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.QueryScreenModeMESA(drv, dpy, screen, mode);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
+   _EGLDriver *drv;
+   _EGLMode *m;
+
+   drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
+   if (!drv)
+      return EGL_FALSE;
+
+   if (drv->API.QueryScreenModeMESA(drv, disp, scrn, &m) != EGL_TRUE)
+      m = NULL;
+   if (mode)
+      *mode = m->Handle;
+
+   return (m != NULL);
 }
 
 
 const char *
 eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.QueryModeStringMESA(drv, dpy, mode);
+   _EGL_DECLARE_DD_AND_MODE(dpy, mode);
+   return drv->API.QueryModeStringMESA(drv, disp, m);
 }
 
 
@@ -605,27 +912,37 @@ eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
                                  EGLClientBuffer buffer, EGLConfig config,
                                  const EGLint *attrib_list)
 {
-   _EGLDriver *drv = _eglLookupDriver(dpy);
-   return drv->API.CreatePbufferFromClientBuffer(drv, dpy, buftype, buffer,
-                                                 config, attrib_list);
+   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   _EGLConfig *conf = _eglLookupConfig(config, disp);
+   _EGLDriver *drv;
+   _EGLSurface *surf;
+
+   drv = _eglCheckConfig(disp, conf, __FUNCTION__);
+   if (!drv)
+      return EGL_NO_SURFACE;
+
+   surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
+                                                 conf, attrib_list);
+   if (surf)
+      return _eglLinkSurface(surf, disp);
+   else
+      return EGL_NO_SURFACE;
 }
 
 
 EGLBoolean
 eglReleaseThread(void)
 {
-   EGLDisplay dpy;
-
-   if (_eglIsCurrentThreadDummy())
-      return EGL_TRUE;
-
-   dpy = eglGetCurrentDisplay();
-   if (dpy) {
-      _EGLDriver *drv = _eglLookupDriver(dpy);
-      /* unbind context */
-      (void) drv->API.MakeCurrent(drv, dpy, EGL_NO_SURFACE,
-                                  EGL_NO_SURFACE, EGL_NO_CONTEXT);
+   /* unbind current context */
+   if (!_eglIsCurrentThreadDummy()) {
+      _EGLDisplay *disp = _eglGetCurrentDisplay();
+      _EGLDriver *drv;
+      if (disp) {
+         drv = disp->Driver;
+         (void) drv->API.MakeCurrent(drv, disp, NULL, NULL, NULL);
+      }
    }
+
    _eglDestroyCurrentThread();
    return EGL_TRUE;
 }
@@ -634,13 +951,17 @@ eglReleaseThread(void)
 EGLBoolean
 eglWaitClient(void)
 {
-   EGLDisplay dpy = eglGetCurrentDisplay();
-   if (dpy != EGL_NO_DISPLAY) {
-      _EGLDriver *drv = _eglLookupDriver(dpy);
-      return drv->API.WaitClient(drv, dpy);
-   }
-   else
-      return EGL_FALSE;
+   _EGLDisplay *disp = _eglGetCurrentDisplay();
+   _EGLDriver *drv;
+
+   if (!disp)
+      return EGL_TRUE;
+
+   /* a current display is always initialized */
+   drv = disp->Driver;
+
+   return drv->API.WaitClient(drv, disp);
 }
 
+
 #endif /* EGL_VERSION_1_2 */
diff --git a/src/egl/main/eglapi.h b/src/egl/main/eglapi.h
index f6163a0c7a..6081e58892 100644
--- a/src/egl/main/eglapi.h
+++ b/src/egl/main/eglapi.h
@@ -12,61 +12,61 @@ typedef void (*_EGLProc)();
  */
 
 /* driver funcs */
-typedef EGLBoolean (*Initialize_t)(_EGLDriver *, EGLDisplay dpy, EGLint *major, EGLint *minor);
-typedef EGLBoolean (*Terminate_t)(_EGLDriver *, EGLDisplay dpy);
+typedef EGLBoolean (*Initialize_t)(_EGLDriver *, _EGLDisplay *dpy, EGLint *major, EGLint *minor);
+typedef EGLBoolean (*Terminate_t)(_EGLDriver *, _EGLDisplay *dpy);
 
 /* config funcs */
-typedef EGLBoolean (*GetConfigs_t)(_EGLDriver *drv, EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
-typedef EGLBoolean (*ChooseConfig_t)(_EGLDriver *drv, EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
-typedef EGLBoolean (*GetConfigAttrib_t)(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+typedef EGLBoolean (*GetConfigs_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLBoolean (*ChooseConfig_t)(_EGLDriver *drv, _EGLDisplay *dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLBoolean (*GetConfigAttrib_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *config, EGLint attribute, EGLint *value);
 
 /* context funcs */
-typedef EGLContext (*CreateContext_t)(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list);
-typedef EGLBoolean (*DestroyContext_t)(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx);
-typedef EGLBoolean (*MakeCurrent_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
-typedef EGLBoolean (*QueryContext_t)(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+typedef _EGLContext *(*CreateContext_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *config, _EGLContext *share_list, const EGLint *attrib_list);
+typedef EGLBoolean (*DestroyContext_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx);
+typedef EGLBoolean (*MakeCurrent_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw, _EGLSurface *read, _EGLContext *ctx);
+typedef EGLBoolean (*QueryContext_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, EGLint attribute, EGLint *value);
 
 /* surface funcs */
-typedef EGLSurface (*CreateWindowSurface_t)(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list);
-typedef EGLSurface (*CreatePixmapSurface_t)(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list);
-typedef EGLSurface (*CreatePbufferSurface_t)(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
-typedef EGLBoolean (*DestroySurface_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface);
-typedef EGLBoolean (*QuerySurface_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
-typedef EGLBoolean (*SurfaceAttrib_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
-typedef EGLBoolean (*BindTexImage_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint buffer);
-typedef EGLBoolean (*ReleaseTexImage_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint buffer);
-typedef EGLBoolean (*SwapInterval_t)(_EGLDriver *drv, EGLDisplay dpy, EGLint interval);
-typedef EGLBoolean (*SwapBuffers_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw);
-typedef EGLBoolean (*CopyBuffers_t)(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, NativePixmapType target);
+typedef _EGLSurface *(*CreateWindowSurface_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *config, NativeWindowType window, const EGLint *attrib_list);
+typedef _EGLSurface *(*CreatePixmapSurface_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *config, NativePixmapType pixmap, const EGLint *attrib_list);
+typedef _EGLSurface *(*CreatePbufferSurface_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *config, const EGLint *attrib_list);
+typedef EGLBoolean (*DestroySurface_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface);
+typedef EGLBoolean (*QuerySurface_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLint attribute, EGLint *value);
+typedef EGLBoolean (*SurfaceAttrib_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLint attribute, EGLint value);
+typedef EGLBoolean (*BindTexImage_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLint buffer);
+typedef EGLBoolean (*ReleaseTexImage_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLint buffer);
+typedef EGLBoolean (*SwapInterval_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint interval);
+typedef EGLBoolean (*SwapBuffers_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw);
+typedef EGLBoolean (*CopyBuffers_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, NativePixmapType target);
 
 /* misc funcs */
-typedef const char *(*QueryString_t)(_EGLDriver *drv, EGLDisplay dpy, EGLint name);
-typedef EGLBoolean (*WaitGL_t)(_EGLDriver *drv, EGLDisplay dpy);
-typedef EGLBoolean (*WaitNative_t)(_EGLDriver *drv, EGLDisplay dpy, EGLint engine);
+typedef const char *(*QueryString_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name);
+typedef EGLBoolean (*WaitGL_t)(_EGLDriver *drv, _EGLDisplay *dpy);
+typedef EGLBoolean (*WaitNative_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine);
 
 typedef _EGLProc (*GetProcAddress_t)(const char *procname);
 
 
 
 #ifdef EGL_MESA_screen_surface
-typedef EGLBoolean (*ChooseModeMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, const EGLint *attrib_list, EGLModeMESA *modes, EGLint modes_size, EGLint *num_modes);
-typedef EGLBoolean (*GetModesMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes, EGLint mode_size, EGLint *num_mode);
-typedef EGLBoolean (*GetModeAttribMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLModeMESA mode, EGLint attribute, EGLint *value);
-typedef EGLBoolean (*CopyContextMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLContext source, EGLContext dest, EGLint mask);
-typedef EGLBoolean (*GetScreensMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA *screens, EGLint max_screens, EGLint *num_screens);
-typedef EGLSurface (*CreateScreenSurfaceMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
-typedef EGLBoolean (*ShowScreenSurfaceMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLSurface surface, EGLModeMESA mode);
-typedef EGLBoolean (*ScreenPositionMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y);
-typedef EGLBoolean (*QueryScreenMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLint attribute, EGLint *value);
-typedef EGLBoolean (*QueryScreenSurfaceMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLSurface *surface);
-typedef EGLBoolean (*QueryScreenModeMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode);
-typedef const char * (*QueryModeStringMESA_t)(_EGLDriver *drv, EGLDisplay dpy, EGLModeMESA mode);
+typedef EGLBoolean (*ChooseModeMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, const EGLint *attrib_list, EGLModeMESA *modes, EGLint modes_size, EGLint *num_modes);
+typedef EGLBoolean (*GetModesMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, EGLModeMESA *modes, EGLint mode_size, EGLint *num_mode);
+typedef EGLBoolean (*GetModeAttribMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLMode *mode, EGLint attribute, EGLint *value);
+typedef EGLBoolean (*CopyContextMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *source, _EGLContext *dest, EGLint mask);
+typedef EGLBoolean (*GetScreensMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLScreenMESA *screens, EGLint max_screens, EGLint *num_screens);
+typedef _EGLSurface *(*CreateScreenSurfaceMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *config, const EGLint *attrib_list);
+typedef EGLBoolean (*ShowScreenSurfaceMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, _EGLSurface *surface, _EGLMode *mode);
+typedef EGLBoolean (*ScreenPositionMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, EGLint x, EGLint y);
+typedef EGLBoolean (*QueryScreenMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, EGLint attribute, EGLint *value);
+typedef EGLBoolean (*QueryScreenSurfaceMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, _EGLSurface **surface);
+typedef EGLBoolean (*QueryScreenModeMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, _EGLMode **mode);
+typedef const char * (*QueryModeStringMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLMode *mode);
 #endif /* EGL_MESA_screen_surface */
 
 
 #ifdef EGL_VERSION_1_2
-typedef EGLBoolean (*WaitClient_t)(_EGLDriver *drv, EGLDisplay dpy);
-typedef EGLSurface (*CreatePbufferFromClientBuffer_t)(_EGLDriver *drv, EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+typedef EGLBoolean (*WaitClient_t)(_EGLDriver *drv, _EGLDisplay *dpy);
+typedef _EGLSurface *(*CreatePbufferFromClientBuffer_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLenum buftype, EGLClientBuffer buffer, _EGLConfig *config, const EGLint *attrib_list);
 #endif /* EGL_VERSION_1_2 */
 
 
diff --git a/src/egl/main/eglconfig.c b/src/egl/main/eglconfig.c
index bbc585b55e..d47b99eed4 100644
--- a/src/egl/main/eglconfig.c
+++ b/src/egl/main/eglconfig.c
@@ -71,10 +71,9 @@ _eglGetConfigHandle(_EGLConfig *config)
  * This is the inverse of _eglGetConfigHandle().
  */
 _EGLConfig *
-_eglLookupConfig(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config)
+_eglLookupConfig(EGLConfig config, _EGLDisplay *disp)
 {
    EGLint i;
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    for (i = 0; i < disp->NumConfigs; i++) {
       if (disp->Configs[i]->Handle == config) {
           return disp->Configs[i];
@@ -319,10 +318,9 @@ _eglCompareConfigs(const void *a, const void *b)
  * Typical fallback routine for eglChooseConfig
  */
 EGLBoolean
-_eglChooseConfig(_EGLDriver *drv, EGLDisplay dpy, const EGLint *attrib_list,
+_eglChooseConfig(_EGLDriver *drv, _EGLDisplay *disp, const EGLint *attrib_list,
                  EGLConfig *configs, EGLint config_size, EGLint *num_configs)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLConfig **configList, criteria;
    EGLint i, count;
 
@@ -367,10 +365,9 @@ _eglChooseConfig(_EGLDriver *drv, EGLDisplay dpy, const EGLint *attrib_list,
  * Fallback for eglGetConfigAttrib.
  */
 EGLBoolean
-_eglGetConfigAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+_eglGetConfigAttrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                     EGLint attribute, EGLint *value)
 {
-   const _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
    const EGLint k = attribute - FIRST_ATTRIB;
    if (k >= 0 && k < MAX_ATTRIBS) {
       *value = conf->Attrib[k];
@@ -387,16 +384,9 @@ _eglGetConfigAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
  * Fallback for eglGetConfigs.
  */
 EGLBoolean
-_eglGetConfigs(_EGLDriver *drv, EGLDisplay dpy, EGLConfig *configs,
+_eglGetConfigs(_EGLDriver *drv, _EGLDisplay *disp, EGLConfig *configs,
                EGLint config_size, EGLint *num_config)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-
-   if (!drv->Initialized) {
-      _eglError(EGL_NOT_INITIALIZED, "eglGetConfigs");
-      return EGL_FALSE;
-   }
-
    if (configs) {
       EGLint i;
       *num_config = MIN2(disp->NumConfigs, config_size);
diff --git a/src/egl/main/eglconfig.h b/src/egl/main/eglconfig.h
index db1c4c10e0..36ed96ae95 100644
--- a/src/egl/main/eglconfig.h
+++ b/src/egl/main/eglconfig.h
@@ -34,7 +34,7 @@ _eglGetConfigHandle(_EGLConfig *config);
 
 
 extern _EGLConfig *
-_eglLookupConfig(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config);
+_eglLookupConfig(EGLConfig config, _EGLDisplay *dpy);
 
 
 extern _EGLConfig *
@@ -46,15 +46,15 @@ _eglParseConfigAttribs(_EGLConfig *config, const EGLint *attrib_list);
 
 
 extern EGLBoolean
-_eglChooseConfig(_EGLDriver *drv, EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+_eglChooseConfig(_EGLDriver *drv, _EGLDisplay *dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
 
 
 extern EGLBoolean
-_eglGetConfigAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+_eglGetConfigAttrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, EGLint attribute, EGLint *value);
 
 
 extern EGLBoolean
-_eglGetConfigs(_EGLDriver *drv, EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+_eglGetConfigs(_EGLDriver *drv, _EGLDisplay *dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
 
 
 extern void
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 88de60d69b..b094f49bfc 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -25,11 +25,6 @@ _eglInitContext(_EGLDriver *drv, _EGLContext *ctx,
       return EGL_FALSE;
    }
 
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "_eglInitContext");
-      return EGL_FALSE;
-   }
-
    memset(ctx, 0, sizeof(_EGLContext));
 
    ctx->ClientVersion = 1; /* the default, per EGL spec */
@@ -58,32 +53,25 @@ _eglInitContext(_EGLDriver *drv, _EGLContext *ctx,
 /**
  * Just a placeholder/demo function.  Real driver will never use this!
  */
-EGLContext
-_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
-                  EGLContext share_list, const EGLint *attrib_list)
+_EGLContext *
+_eglCreateContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+                  _EGLContext *share_list, const EGLint *attrib_list)
 {
 #if 0 /* example code */
    _EGLContext *context;
-   _EGLConfig *conf;
-
-   conf = _eglLookupConfig(drv, dpy, config);
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreateContext");
-      return EGL_NO_CONTEXT;
-   }
 
    context = (_EGLContext *) calloc(1, sizeof(_EGLContext));
    if (!context)
-      return EGL_NO_CONTEXT;
+      return NULL;
 
    if (!_eglInitContext(drv, context, conf, attrib_list)) {
       free(context);
-      return EGL_NO_CONTEXT;
+      return NULL;
    }
 
-   return _eglLinkContext(context, _eglLookupDisplay(dpy));
+   return context;
 #endif
-   return EGL_NO_CONTEXT;
+   return NULL;
 }
 
 
@@ -91,36 +79,21 @@ _eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
  * Default fallback routine - drivers should usually override this.
  */
 EGLBoolean
-_eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
+_eglDestroyContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
 {
-   _EGLContext *context = _eglLookupContext(ctx);
-   if (context) {
-      _eglUnlinkContext(context);
-      if (!_eglIsContextBound(context))
-         free(context);
-      return EGL_TRUE;
-   }
-   else {
-      _eglError(EGL_BAD_CONTEXT, "eglDestroyContext");
-      return EGL_TRUE;
-   }
+   if (!_eglIsContextBound(ctx))
+      free(ctx);
+   return EGL_TRUE;
 }
 
 
 EGLBoolean
-_eglQueryContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx,
+_eglQueryContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *c,
                  EGLint attribute, EGLint *value)
 {
-   _EGLContext *c = _eglLookupContext(ctx);
-
    (void) drv;
    (void) dpy;
 
-   if (!c) {
-      _eglError(EGL_BAD_CONTEXT, "eglQueryContext");
-      return EGL_FALSE;
-   }
-
    switch (attribute) {
    case EGL_CONFIG_ID:
       *value = GET_CONFIG_ATTRIB(c->Config, EGL_CONFIG_ID);
@@ -146,14 +119,10 @@ _eglQueryContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx,
  * Then, the driver will do its device-dependent Make-Current stuff.
  */
 EGLBoolean
-_eglMakeCurrent(_EGLDriver *drv, EGLDisplay display, EGLSurface d,
-                EGLSurface r, EGLContext context)
+_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw,
+                _EGLSurface *read, _EGLContext *ctx)
 {
    _EGLThreadInfo *t = _eglGetCurrentThread();
-   _EGLDisplay *dpy = _eglLookupDisplay(display);
-   _EGLContext *ctx = _eglLookupContext(context);
-   _EGLSurface *draw = _eglLookupSurface(d);
-   _EGLSurface *read = _eglLookupSurface(r);
    _EGLContext *oldContext = NULL;
    _EGLSurface *oldDrawSurface = NULL;
    _EGLSurface *oldReadSurface = NULL;
@@ -161,18 +130,13 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay display, EGLSurface d,
 
    if (_eglIsCurrentThreadDummy())
       return _eglError(EGL_BAD_ALLOC, "eglMakeCurrent");
-   if (dpy == NULL)
-      return _eglError(EGL_BAD_DISPLAY, "eglMakeCurrent");
 
    if (ctx) {
       /* error checking */
       if (ctx->Binding && ctx->Binding != t)
          return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
-      if (draw == NULL || read == NULL) {
-         EGLint err = (d == EGL_NO_SURFACE || r == EGL_NO_SURFACE)
-                      ? EGL_BAD_MATCH : EGL_BAD_SURFACE;
-         return _eglError(err, "eglMakeCurrent");
-      }
+      if (draw == NULL || read == NULL)
+         return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
       if (draw->Config != ctx->Config || read->Config != ctx->Config)
          return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
       if ((draw->Binding && draw->Binding->Binding != t) ||
@@ -197,8 +161,6 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay display, EGLSurface d,
       apiIndex = _eglConvertApiToIndex(ctx->ClientAPI);
    }
    else {
-      if (context != EGL_NO_CONTEXT)
-         return _eglError(EGL_BAD_CONTEXT, "eglMakeCurrent");
       if (draw != NULL || read != NULL)
          return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
       apiIndex = t->CurrentAPIIndex;
@@ -221,23 +183,19 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay display, EGLSurface d,
 
       /*
        * check if the old context or surfaces need to be deleted
-       * FIXME They are linked so that they can be unlinked.  This is ugly.
        */
       if (!_eglIsSurfaceLinked(oldDrawSurface)) {
          assert(draw != oldDrawSurface && read != oldDrawSurface);
-         drv->API.DestroySurface(drv, display,
-                                 _eglLinkSurface(oldDrawSurface, dpy));
+         drv->API.DestroySurface(drv, dpy, oldDrawSurface);
       }
       if (oldReadSurface != oldDrawSurface &&
           !_eglIsSurfaceLinked(oldReadSurface)) {
          assert(draw != oldReadSurface && read != oldReadSurface);
-         drv->API.DestroySurface(drv, display,
-                                 _eglLinkSurface(oldReadSurface, dpy));
+         drv->API.DestroySurface(drv, dpy, oldReadSurface);
       }
       if (!_eglIsContextLinked(oldContext)) {
          assert(ctx != oldContext);
-         drv->API.DestroyContext(drv, display,
-                                 _eglLinkContext(oldContext, dpy));
+         drv->API.DestroyContext(drv, dpy, oldContext);
       }
    }
 
diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 4276c0980e..647f24488f 100644
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -32,20 +32,20 @@ _eglInitContext(_EGLDriver *drv, _EGLContext *ctx,
                 _EGLConfig *config, const EGLint *attrib_list);
 
 
-extern EGLContext
-_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list);
+extern _EGLContext *
+_eglCreateContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, _EGLContext *share_list, const EGLint *attrib_list);
 
 
 extern EGLBoolean
-_eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx);
+_eglDestroyContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx);
 
 
 extern EGLBoolean
-_eglQueryContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+_eglQueryContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, EGLint attribute, EGLint *value);
 
 
 extern EGLBoolean
-_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw, _EGLSurface *read, _EGLContext *ctx);
 
 
 extern EGLBoolean
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index feae1d6040..c684e4291e 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -200,29 +200,29 @@ _eglFindDisplay(NativeDisplayType nativeDisplay)
  * Destroy the contexts and surfaces that are linked to the display.
  */
 void
-_eglReleaseDisplayResources(_EGLDriver *drv, EGLDisplay dpy)
+_eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)
 {
-   _EGLDisplay *display;
    _EGLContext *contexts;
    _EGLSurface *surfaces;
 
-   display = _eglLookupDisplay(dpy);
-   if (!display)
-      return;
    contexts = display->ContextList;
    surfaces = display->SurfaceList;
 
    while (contexts) {
-      EGLContext handle = _eglGetContextHandle(contexts);
+      _EGLContext *ctx = contexts;
       contexts = contexts->Next;
-      drv->API.DestroyContext(drv, dpy, handle);
+
+      _eglUnlinkContext(ctx);
+      drv->API.DestroyContext(drv, display, ctx);
    }
    assert(!display->ContextList);
 
    while (surfaces) {
-      EGLSurface handle = _eglGetSurfaceHandle(surfaces);
+      _EGLSurface *surf = surfaces;
       surfaces = surfaces->Next;
-      drv->API.DestroySurface(drv, dpy, handle);
+
+      _eglUnlinkSurface(surf);
+      drv->API.DestroySurface(drv, display, surf);
    }
    assert(!display->SurfaceList);
 }
@@ -309,7 +309,7 @@ _eglGetContextHandle(_EGLContext *ctx)
  * Return NULL if the handle has no corresponding linked context.
  */
 _EGLContext *
-_eglLookupContext(EGLContext ctx)
+_eglLookupContext(EGLContext ctx, _EGLDisplay *dpy)
 {
    _EGLContext *context = (_EGLContext *) ctx;
    return (context && context->Display) ? context : NULL;
@@ -389,8 +389,8 @@ _eglGetSurfaceHandle(_EGLSurface *surface)
  * Return NULL if the handle has no corresponding linked surface.
  */
 _EGLSurface *
-_eglLookupSurface(EGLSurface surf)
+_eglLookupSurface(EGLSurface surf, _EGLDisplay *dpy)
 {
    EGLuint key = _eglPointerToUInt((void *) surf);
-   return (_EGLSurface *) _eglHashLookup(_eglSurfaceHash, key);
+   return (_EGLSurface *) _eglHashLookup(dpy->SurfaceHash, key);
 }
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 70c59ef5e4..1ebc0fcb59 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -72,7 +72,7 @@ _eglFindDisplay(NativeDisplayType nativeDisplay);
 
 
 extern void
-_eglReleaseDisplayResources(_EGLDriver *drv, EGLDisplay dpy);
+_eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *dpy);
 
 
 extern void
@@ -92,7 +92,7 @@ _eglGetContextHandle(_EGLContext *ctx);
 
 
 extern _EGLContext *
-_eglLookupContext(EGLContext ctx);
+_eglLookupContext(EGLContext ctx, _EGLDisplay *dpy);
 
 
 /**
@@ -117,7 +117,7 @@ _eglGetSurfaceHandle(_EGLSurface *);
 
 
 extern _EGLSurface *
-_eglLookupSurface(EGLSurface surf);
+_eglLookupSurface(EGLSurface surf, _EGLDisplay *dpy);
 
 
 /**
diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c
index f2a864cd8a..a8ac7b3233 100644
--- a/src/egl/main/egldriver.c
+++ b/src/egl/main/egldriver.c
@@ -277,7 +277,7 @@ _eglOpenDriver(_EGLDisplay *dpy, const char *driverName, const char *args)
 
 
 EGLBoolean
-_eglCloseDriver(_EGLDriver *drv, EGLDisplay dpy)
+_eglCloseDriver(_EGLDriver *drv, _EGLDisplay *dpy)
 {
    void *handle = drv->LibHandle;
    EGLBoolean b;
diff --git a/src/egl/main/egldriver.h b/src/egl/main/egldriver.h
index 4066c6ec1d..d97a24db1d 100644
--- a/src/egl/main/egldriver.h
+++ b/src/egl/main/egldriver.h
@@ -59,7 +59,7 @@ _eglOpenDriver(_EGLDisplay *dpy, const char *driverName, const char *args);
 
 
 extern EGLBoolean
-_eglCloseDriver(_EGLDriver *drv, EGLDisplay dpy);
+_eglCloseDriver(_EGLDriver *drv, _EGLDisplay *dpy);
 
 
 extern void
diff --git a/src/egl/main/eglmisc.c b/src/egl/main/eglmisc.c
index b5bdc3ea4b..3440b77dd9 100644
--- a/src/egl/main/eglmisc.c
+++ b/src/egl/main/eglmisc.c
@@ -77,7 +77,7 @@ _eglUpdateAPIsString(_EGLDriver *drv)
 
 
 const char *
-_eglQueryString(_EGLDriver *drv, EGLDisplay dpy, EGLint name)
+_eglQueryString(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name)
 {
    (void) drv;
    (void) dpy;
@@ -102,7 +102,7 @@ _eglQueryString(_EGLDriver *drv, EGLDisplay dpy, EGLint name)
 
 
 EGLBoolean
-_eglWaitGL(_EGLDriver *drv, EGLDisplay dpy)
+_eglWaitGL(_EGLDriver *drv, _EGLDisplay *dpy)
 {
    /* just a placeholder */
    (void) drv;
@@ -112,7 +112,7 @@ _eglWaitGL(_EGLDriver *drv, EGLDisplay dpy)
 
 
 EGLBoolean
-_eglWaitNative(_EGLDriver *drv, EGLDisplay dpy, EGLint engine)
+_eglWaitNative(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine)
 {
    /* just a placeholder */
    (void) drv;
diff --git a/src/egl/main/eglmisc.h b/src/egl/main/eglmisc.h
index 4e2a40ea99..a15c839be2 100644
--- a/src/egl/main/eglmisc.h
+++ b/src/egl/main/eglmisc.h
@@ -33,15 +33,15 @@
 
 
 extern const char *
-_eglQueryString(_EGLDriver *drv, EGLDisplay dpy, EGLint name);
+_eglQueryString(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name);
 
 
 extern EGLBoolean
-_eglWaitGL(_EGLDriver *drv, EGLDisplay dpy);
+_eglWaitGL(_EGLDriver *drv, _EGLDisplay *dpy);
 
 
 extern EGLBoolean
-_eglWaitNative(_EGLDriver *drv, EGLDisplay dpy, EGLint engine);
+_eglWaitNative(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine);
 
 
 #endif /* EGLMISC_INCLUDED */
diff --git a/src/egl/main/eglmode.c b/src/egl/main/eglmode.c
index 786432234b..0f3ba6e5c0 100644
--- a/src/egl/main/eglmode.c
+++ b/src/egl/main/eglmode.c
@@ -34,9 +34,8 @@ my_strdup(const char *s)
  * or null if non-existant.
  */
 _EGLMode *
-_eglLookupMode(EGLDisplay dpy, EGLModeMESA mode)
+_eglLookupMode(EGLModeMESA mode, _EGLDisplay *disp)
 {
-   const _EGLDisplay *disp = _eglLookupDisplay(dpy);
    EGLint scrnum;
 
    /* loop over all screens on the display */
@@ -272,19 +271,13 @@ _eglCompareModes(const void *a, const void *b)
  * Called via eglChooseModeMESA API function.
  */
 EGLBoolean
-_eglChooseModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
+_eglChooseModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
                    const EGLint *attrib_list, EGLModeMESA *modes,
                    EGLint modes_size, EGLint *num_modes)
 {
-   const _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
    _EGLMode **modeList, min;
    EGLint i, count;
 
-   if (!scrn) {
-      _eglError(EGL_BAD_SCREEN_MESA, "eglChooseModeMESA");
-      return EGL_FALSE;
-   }
-
    if (!_eglParseModeAttribs(&min, attrib_list)) {
       /* error code will have been recorded */
       return EGL_FALSE;
@@ -326,16 +319,9 @@ _eglChooseModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
  * Called via eglGetModesMESA() API function.
  */
 EGLBoolean
-_eglGetModesMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
+_eglGetModesMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
                  EGLModeMESA *modes, EGLint modes_size, EGLint *num_modes)
 {
-   _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
-
-   if (!scrn) {
-      _eglError(EGL_BAD_SCREEN_MESA, "eglGetModesMESA");
-      return EGL_FALSE;
-   }
-
    if (modes) {
       EGLint i;
       *num_modes = MIN2(scrn->NumModes, modes_size);
@@ -356,17 +342,11 @@ _eglGetModesMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
  * Query an attribute of a mode.
  */
 EGLBoolean
-_eglGetModeAttribMESA(_EGLDriver *drv, EGLDisplay dpy,
-                      EGLModeMESA mode, EGLint attribute, EGLint *value)
+_eglGetModeAttribMESA(_EGLDriver *drv, _EGLDisplay *dpy,
+                      _EGLMode *m, EGLint attribute, EGLint *value)
 {
-   _EGLMode *m = _eglLookupMode(dpy, mode);
    EGLint v;
 
-   if (!m) {
-      _eglError(EGL_BAD_MODE_MESA, "eglGetModeAttribMESA");
-      return EGL_FALSE;
-   }
-
    v = getModeAttrib(m, attribute);
    if (v < 0) {
       _eglError(EGL_BAD_ATTRIBUTE, "eglGetModeAttribMESA");
@@ -382,13 +362,8 @@ _eglGetModeAttribMESA(_EGLDriver *drv, EGLDisplay dpy,
  * This is the default function called by eglQueryModeStringMESA().
  */
 const char *
-_eglQueryModeStringMESA(_EGLDriver *drv, EGLDisplay dpy, EGLModeMESA mode)
+_eglQueryModeStringMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLMode *m)
 {
-   _EGLMode *m = _eglLookupMode(dpy, mode);
-   if (!m) {
-      _eglError(EGL_BAD_MODE_MESA, "eglQueryModeStringMESA");
-      return NULL;
-   }
    return m->Name;
 }
 
diff --git a/src/egl/main/eglmode.h b/src/egl/main/eglmode.h
index 52d4875676..af7c2c56d3 100644
--- a/src/egl/main/eglmode.h
+++ b/src/egl/main/eglmode.h
@@ -26,7 +26,7 @@ struct _egl_mode
 
 
 extern _EGLMode *
-_eglLookupMode(EGLDisplay dpy, EGLModeMESA mode);
+_eglLookupMode(EGLModeMESA mode, _EGLDisplay *dpy);
 
 
 extern _EGLMode *
@@ -35,23 +35,23 @@ _eglAddNewMode(_EGLScreen *screen, EGLint width, EGLint height,
 
 
 extern EGLBoolean
-_eglChooseModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
+_eglChooseModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
                    const EGLint *attrib_list, EGLModeMESA *modes,
                    EGLint modes_size, EGLint *num_modes);
 
 
 extern EGLBoolean
-_eglGetModesMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
+_eglGetModesMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
                  EGLModeMESA *modes, EGLint modes_size, EGLint *num_modes);
 
 
 extern EGLBoolean
-_eglGetModeAttribMESA(_EGLDriver *drv, EGLDisplay dpy, EGLModeMESA mode,
+_eglGetModeAttribMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLMode *m,
                       EGLint attribute, EGLint *value);
 
 
 extern const char *
-_eglQueryModeStringMESA(_EGLDriver *drv, EGLDisplay dpy, EGLModeMESA mode);
+_eglQueryModeStringMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLMode *m);
 
 
 #endif /* EGLMODE_INCLUDED */
diff --git a/src/egl/main/eglscreen.c b/src/egl/main/eglscreen.c
index b6bde65e8b..14a1e9f8fe 100644
--- a/src/egl/main/eglscreen.c
+++ b/src/egl/main/eglscreen.c
@@ -52,13 +52,9 @@ _eglInitScreen(_EGLScreen *screen)
  * Given a public screen handle, return the internal _EGLScreen object.
  */
 _EGLScreen *
-_eglLookupScreen(EGLDisplay dpy, EGLScreenMESA screen)
+_eglLookupScreen(EGLScreenMESA screen, _EGLDisplay *display)
 {
    EGLint i;
-   _EGLDisplay *display = _eglLookupDisplay(dpy);
-
-   if (!display)
-      return NULL;
 
    for (i = 0; i < display->NumScreens; i++) {
       if (display->Screens[i]->Handle == screen)
@@ -89,17 +85,11 @@ _eglAddScreen(_EGLDisplay *display, _EGLScreen *screen)
 
 
 EGLBoolean
-_eglGetScreensMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA *screens,
+_eglGetScreensMESA(_EGLDriver *drv, _EGLDisplay *display, EGLScreenMESA *screens,
                    EGLint max_screens, EGLint *num_screens)
 {
-   _EGLDisplay *display = _eglLookupDisplay(dpy);
    EGLint n;
 
-   if (!display) {
-      _eglError(EGL_BAD_DISPLAY, "eglGetScreensMESA");
-      return EGL_FALSE;
-   }
-
    if (display->NumScreens > max_screens) {
       n = max_screens;
    }
@@ -122,33 +112,26 @@ _eglGetScreensMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA *screens,
 /**
  * Example function - drivers should do a proper implementation.
  */
-EGLSurface
-_eglCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+_EGLSurface *
+_eglCreateScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                             const EGLint *attrib_list)
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
-   _EGLConfig *conf;
-
-   conf = _eglLookupConfig(drv, dpy, config);
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreateScreenSurfaceMESA");
-      return EGL_NO_SURFACE;
-   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    if (!_eglInitSurface(drv, surf, EGL_SCREEN_BIT_MESA,
                         conf, attrib_list)) {
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
-   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
+   return surf;
 #endif
-   return EGL_NO_SURFACE;
+   return NULL;
 }
 
 
@@ -160,28 +143,15 @@ _eglCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
  * this with code that _really_ shows the surface.
  */
 EGLBoolean
-_eglShowScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy,
-                          EGLScreenMESA screen, EGLSurface surface,
-                          EGLModeMESA m)
+_eglShowScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy,
+                          _EGLScreen *scrn, _EGLSurface *surf,
+                          _EGLMode *mode)
 {
-   _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
-   _EGLMode *mode = _eglLookupMode(dpy, m);
-
-   if (!scrn) {
-      _eglError(EGL_BAD_SCREEN_MESA, "eglShowSurfaceMESA");
-      return EGL_FALSE;
-   }
-   if (!mode && (m != EGL_NO_MODE_MESA )) {
-      _eglError(EGL_BAD_MODE_MESA, "eglShowSurfaceMESA");
-      return EGL_FALSE;
-   }
-
-   if (surface == EGL_NO_SURFACE) {
+   if (!surf) {
       scrn->CurrentSurface = NULL;
    }
    else {
-      _EGLSurface *surf = _eglLookupSurface(surface);
-      if (!surf || surf->Type != EGL_SCREEN_BIT_MESA) {
+      if (surf->Type != EGL_SCREEN_BIT_MESA) {
          _eglError(EGL_BAD_SURFACE, "eglShowSurfaceMESA");
          return EGL_FALSE;
       }
@@ -206,18 +176,10 @@ _eglShowScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy,
  * this with code that _really_ sets the mode.
  */
 EGLBoolean
-_eglScreenModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
-                   EGLModeMESA mode)
+_eglScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
+                   _EGLMode *m)
 {
-   _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
-
-   if (!scrn) {
-      _eglError(EGL_BAD_SCREEN_MESA, "eglScreenModeMESA");
-      return EGL_FALSE;
-   }
-
-   scrn->CurrentMode = _eglLookupMode(dpy, mode);
-
+   scrn->CurrentMode = m;
    return EGL_TRUE;
 }
 
@@ -226,15 +188,9 @@ _eglScreenModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
  * Set a screen's surface origin.
  */
 EGLBoolean
-_eglScreenPositionMESA(_EGLDriver *drv, EGLDisplay dpy,
-                       EGLScreenMESA screen, EGLint x, EGLint y)
+_eglScreenPositionMESA(_EGLDriver *drv, _EGLDisplay *dpy,
+                       _EGLScreen *scrn, EGLint x, EGLint y)
 {
-   _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
-   if (!scrn) {
-      _eglError(EGL_BAD_SCREEN_MESA, "eglScreenPositionMESA");
-      return EGL_FALSE;
-   }
-
    scrn->OriginX = x;
    scrn->OriginY = y;
 
@@ -246,14 +202,10 @@ _eglScreenPositionMESA(_EGLDriver *drv, EGLDisplay dpy,
  * Query a screen's current surface.
  */
 EGLBoolean
-_eglQueryScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy,
-                           EGLScreenMESA screen, EGLSurface *surface)
+_eglQueryScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy,
+                           _EGLScreen *scrn, _EGLSurface **surf)
 {
-   const _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
-   if (scrn->CurrentSurface)
-      *surface = scrn->CurrentSurface->Handle;
-   else
-      *surface = EGL_NO_SURFACE;
+   *surf = scrn->CurrentSurface;
    return EGL_TRUE;
 }
 
@@ -262,29 +214,18 @@ _eglQueryScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy,
  * Query a screen's current mode.
  */
 EGLBoolean
-_eglQueryScreenModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
-                        EGLModeMESA *mode)
+_eglQueryScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
+                        _EGLMode **m)
 {
-   const _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
-   if (scrn->CurrentMode)
-      *mode = scrn->CurrentMode->Handle;
-   else
-      *mode = EGL_NO_MODE_MESA;
+   *m = scrn->CurrentMode;
    return EGL_TRUE;
 }
 
 
 EGLBoolean
-_eglQueryScreenMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen,
+_eglQueryScreenMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
                     EGLint attribute, EGLint *value)
 {
-   const _EGLScreen *scrn = _eglLookupScreen(dpy, screen);
-
-   if (!scrn) {
-      _eglError(EGL_BAD_SCREEN_MESA, "eglQueryScreenMESA");
-      return EGL_FALSE;
-   }
-
    switch (attribute) {
    case EGL_SCREEN_POSITION_MESA:
       value[0] = scrn->OriginX;
diff --git a/src/egl/main/eglscreen.h b/src/egl/main/eglscreen.h
index 833439b410..8860a2aa7f 100644
--- a/src/egl/main/eglscreen.h
+++ b/src/egl/main/eglscreen.h
@@ -35,7 +35,7 @@ _eglInitScreen(_EGLScreen *screen);
 
 
 extern _EGLScreen *
-_eglLookupScreen(EGLDisplay dpy, EGLScreenMESA screen);
+_eglLookupScreen(EGLScreenMESA screen, _EGLDisplay *dpy);
 
 
 extern void
@@ -43,40 +43,40 @@ _eglAddScreen(_EGLDisplay *display, _EGLScreen *screen);
 
 
 extern EGLBoolean
-_eglGetScreensMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA *screens, EGLint max_screens, EGLint *num_screens);
+_eglGetScreensMESA(_EGLDriver *drv, _EGLDisplay *dpy, EGLScreenMESA *screens, EGLint max_screens, EGLint *num_screens);
 
 
-extern EGLSurface
-_eglCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+extern _EGLSurface *
+_eglCreateScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, const EGLint *attrib_list);
 
 
 extern EGLBoolean
-_eglShowScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLSurface surface, EGLModeMESA mode);
+_eglShowScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, _EGLSurface *surf, _EGLMode *m);
 
 
 extern EGLBoolean
-_eglScreenModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA mode);
+_eglScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, _EGLMode *m);
 
 
 extern EGLBoolean
-_eglScreenPositionMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y);
+_eglScreenPositionMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, EGLint x, EGLint y);
 
 
 extern EGLBoolean
-_eglQueryDisplayMESA(_EGLDriver *drv, EGLDisplay dpy, EGLint attribute, EGLint *value);
+_eglQueryDisplayMESA(_EGLDriver *drv, _EGLDisplay *dpy, EGLint attribute, EGLint *value);
 
 
 extern EGLBoolean
-_eglQueryScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy,
-                           EGLScreenMESA screen, EGLSurface *surface);
+_eglQueryScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy,
+                           _EGLScreen *scrn, _EGLSurface **surface);
 
 
 extern EGLBoolean
-_eglQueryScreenModeMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode);
+_eglQueryScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, _EGLMode **m);
 
 
 extern EGLBoolean
-_eglQueryScreenMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLint attribute, EGLint *value);
+_eglQueryScreenMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, EGLint attribute, EGLint *value);
 
 
 extern void
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 3947051127..056288c850 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -211,22 +211,15 @@ _eglInitSurface(_EGLDriver *drv, _EGLSurface *surf, EGLint type,
 
 
 EGLBoolean
-_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
+_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
 {
-   /* Basically just do error checking here.  Drivers have to do the
-    * actual buffer swap.
-    */
-   _EGLSurface *surface = _eglLookupSurface(draw);
-   if (surface == NULL) {
-      _eglError(EGL_BAD_SURFACE, "eglSwapBuffers");
-      return EGL_FALSE;
-   }
+   /* Drivers have to do the actual buffer swap.  */
    return EGL_TRUE;
 }
 
 
 EGLBoolean
-_eglCopyBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+_eglCopyBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
                 NativePixmapType target)
 {
    /* copy surface to native pixmap */
@@ -236,14 +229,9 @@ _eglCopyBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
 
 
 EGLBoolean
-_eglQuerySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+_eglQuerySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface,
                  EGLint attribute, EGLint *value)
 {
-   _EGLSurface *surface = _eglLookupSurface(surf);
-   if (surface == NULL) {
-      _eglError(EGL_BAD_SURFACE, "eglQuerySurface");
-      return EGL_FALSE;
-   }
    switch (attribute) {
    case EGL_WIDTH:
       *value = surface->Width;
@@ -312,96 +300,75 @@ _eglQuerySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
 /**
  * Example function - drivers should do a proper implementation.
  */
-EGLSurface
-_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+_EGLSurface *
+_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                         NativeWindowType window, const EGLint *attrib_list)
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
-   _EGLConfig *conf;
-
-   conf = _eglLookupConfig(drv, dpy, config);
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreateWindowSurface");
-      return EGL_NO_SURFACE;
-   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    if (!_eglInitSurface(drv, surf, EGL_WINDOW_BIT, conf, attrib_list)) {
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
-   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
+   return surf;
 #endif
-   return EGL_NO_SURFACE;
+   return NULL;
 }
 
 
 /**
  * Example function - drivers should do a proper implementation.
  */
-EGLSurface
-_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+_EGLSurface *
+_eglCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                         NativePixmapType pixmap, const EGLint *attrib_list)
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
-   _EGLConfig *conf;
-
-   conf = _eglLookupConfig(drv, dpy, config);
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreatePixmapSurface");
-      return EGL_NO_SURFACE;
-   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    if (!_eglInitSurface(drv, surf, EGL_PIXMAP_BIT, conf, attrib_list)) {
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
-   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
+   return surf;
 #endif
-   return EGL_NO_SURFACE;
+   return NULL;
 }
 
 
 /**
  * Example function - drivers should do a proper implementation.
  */
-EGLSurface
-_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+_EGLSurface *
+_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                          const EGLint *attrib_list)
 {
 #if 0 /* THIS IS JUST EXAMPLE CODE */
    _EGLSurface *surf;
-   _EGLConfig *conf;
-
-   conf = _eglLookupConfig(drv, dpy, config);
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreatePbufferSurface");
-      return EGL_NO_SURFACE;
-   }
 
    surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
    if (!surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    if (!_eglInitSurface(drv, surf, EGL_PBUFFER_BIT, conf, attrib_list)) {
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
-   return _eglLinkSurface(surf, _eglLookupDisplay(dpy));
+   return NULL;
 #endif
-   return EGL_NO_SURFACE;
+   return NULL;
 }
 
 
@@ -409,19 +376,11 @@ _eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
  * Default fallback routine - drivers should usually override this.
  */
 EGLBoolean
-_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
 {
-   _EGLSurface *surf = _eglLookupSurface(surface);
-   if (surf) {
-      _eglUnlinkSurface(surf);
-      if (!_eglIsSurfaceBound(surf))
-         free(surf);
-      return EGL_TRUE;
-   }
-   else {
-      _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
-      return EGL_FALSE;
-   }
+   if (!_eglIsSurfaceBound(surf))
+      free(surf);
+   return EGL_TRUE;
 }
 
 
@@ -429,16 +388,9 @@ _eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
  * Default fallback routine - drivers might override this.
  */
 EGLBoolean
-_eglSurfaceAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+_eglSurfaceAttrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface,
                   EGLint attribute, EGLint value)
 {
-   _EGLSurface *surface = _eglLookupSurface(surf);
-
-   if (surface == NULL) {
-      _eglError(EGL_BAD_SURFACE, "eglSurfaceAttrib");
-      return EGL_FALSE;
-   }
-
    switch (attribute) {
    case EGL_MIPMAP_LEVEL:
       surface->MipmapLevel = value;
@@ -452,15 +404,14 @@ _eglSurfaceAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
 
 
 EGLBoolean
-_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface,
                  EGLint buffer)
 {
    /* Just do basic error checking and return success/fail.
     * Drivers must implement the real stuff.
     */
-   _EGLSurface *surface = _eglLookupSurface(surf);
 
-   if (!surface || surface->Type != EGL_PBUFFER_BIT) {
+   if (surface->Type != EGL_PBUFFER_BIT) {
       _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
       return EGL_FALSE;
    }
@@ -482,15 +433,14 @@ _eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
 
 
 EGLBoolean
-_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface,
                     EGLint buffer)
 {
    /* Just do basic error checking and return success/fail.
     * Drivers must implement the real stuff.
     */
-   _EGLSurface *surface = _eglLookupSurface(surf);
 
-   if (!surface || surface->Type != EGL_PBUFFER_BIT) {
+   if (surface->Type != EGL_PBUFFER_BIT) {
       _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
       return EGL_FALSE;
    }
@@ -517,14 +467,11 @@ _eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
 
 
 EGLBoolean
-_eglSwapInterval(_EGLDriver *drv, EGLDisplay dpy, EGLint interval)
+_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, EGLint interval)
 {
    _EGLSurface *surf = _eglGetCurrentSurface(EGL_DRAW);
-   if (surf == NULL) {
-      _eglError(EGL_BAD_SURFACE, "eglSwapInterval");
-      return EGL_FALSE;
-   }
-   surf->SwapInterval = interval;
+   if (surf)
+      surf->SwapInterval = interval;
    return EGL_TRUE;
 }
 
@@ -534,17 +481,17 @@ _eglSwapInterval(_EGLDriver *drv, EGLDisplay dpy, EGLint interval)
 /**
  * Example function - drivers should do a proper implementation.
  */
-EGLSurface
-_eglCreatePbufferFromClientBuffer(_EGLDriver *drv, EGLDisplay dpy,
+_EGLSurface *
+_eglCreatePbufferFromClientBuffer(_EGLDriver *drv, _EGLDisplay *dpy,
                                   EGLenum buftype, EGLClientBuffer buffer,
-                                  EGLConfig config, const EGLint *attrib_list)
+                                  _EGLConfig *conf, const EGLint *attrib_list)
 {
    if (buftype != EGL_OPENVG_IMAGE) {
       _eglError(EGL_BAD_PARAMETER, "eglCreatePbufferFromClientBuffer");
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
-   return EGL_NO_SURFACE;
+   return NULL;
 }
 
 #endif /* EGL_VERSION_1_2 */
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index 8864176844..cfae6970f2 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -47,55 +47,55 @@ _eglInitSurface(_EGLDriver *drv, _EGLSurface *surf, EGLint type,
 
 
 extern EGLBoolean
-_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw);
+_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf);
 
 
 extern EGLBoolean
-_eglCopyBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, NativePixmapType target);
+_eglCopyBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, NativePixmapType target);
 
 
 extern EGLBoolean
-_eglQuerySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+_eglQuerySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint attribute, EGLint *value);
 
 
-extern EGLSurface
-_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list);
+extern _EGLSurface *
+_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativeWindowType window, const EGLint *attrib_list);
 
 
-extern EGLSurface
-_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list);
+extern _EGLSurface *
+_eglCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativePixmapType pixmap, const EGLint *attrib_list);
 
 
-extern EGLSurface
-_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+extern _EGLSurface *
+_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, const EGLint *attrib_list);
 
 
 extern EGLBoolean
-_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface);
+_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf);
 
 
 extern EGLBoolean
-_eglSurfaceAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+_eglSurfaceAttrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint attribute, EGLint value);
 
 
 extern EGLBoolean
-_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint buffer);
 
 
 extern EGLBoolean
-_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint buffer);
 
 
 extern EGLBoolean
-_eglSwapInterval(_EGLDriver *drv, EGLDisplay dpy, EGLint interval);
+_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, EGLint interval);
 
 
 #ifdef EGL_VERSION_1_2
 
-extern EGLSurface
-_eglCreatePbufferFromClientBuffer(_EGLDriver *drv, EGLDisplay dpy,
+extern _EGLSurface *
+_eglCreatePbufferFromClientBuffer(_EGLDriver *drv, _EGLDisplay *dpy,
                                   EGLenum buftype, EGLClientBuffer buffer,
-                                  EGLConfig config, const EGLint *attrib_list);
+                                  _EGLConfig *conf, const EGLint *attrib_list);
 
 #endif /* EGL_VERSION_1_2 */
 
diff --git a/src/gallium/state_trackers/egl/egl_context.c b/src/gallium/state_trackers/egl/egl_context.c
index 2c8f51cf38..52b6453d29 100644
--- a/src/gallium/state_trackers/egl/egl_context.c
+++ b/src/gallium/state_trackers/egl/egl_context.c
@@ -83,23 +83,16 @@ const struct dri_extension card_extensions[] = {
 	{NULL, NULL}
 };
 
-EGLContext
-drm_create_context(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list)
+_EGLContext *
+drm_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, _EGLContext *share_list, const EGLint *attrib_list)
 {
 	struct drm_device *dev = (struct drm_device *)drv;
 	struct drm_context *ctx;
 	struct drm_context *share = NULL;
 	struct st_context *st_share = NULL;
-	_EGLConfig *conf;
 	int i;
 	__GLcontextModes *visual;
 
-	conf = _eglLookupConfig(drv, dpy, config);
-	if (!conf) {
-		_eglError(EGL_BAD_CONFIG, "eglCreateContext");
-		return EGL_NO_CONTEXT;
-	}
-
 	for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
 		switch (attrib_list[i]) {
 			/* no attribs defined for now */
@@ -129,25 +122,20 @@ drm_create_context(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext
 	if (!ctx->st)
 		goto err_gl;
 
-        /* link to display */
-        _eglLinkContext(&ctx->base, _eglLookupDisplay(dpy));
-	assert(_eglGetContextHandle(&ctx->base));
-
-	return _eglGetContextHandle(&ctx->base);
+	return &ctx->base;
 
 err_gl:
 	ctx->pipe->destroy(ctx->pipe);
 err_pipe:
 	free(ctx);
 err_c:
-	return EGL_NO_CONTEXT;
+	return NULL;
 }
 
 EGLBoolean
-drm_destroy_context(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
+drm_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *context)
 {
 	struct drm_context *c = lookup_drm_context(context);
-        _eglUnlinkContext(&c->base);
 	if (!_eglIsContextBound(&c->base)) {
 		st_destroy_context(c->st);
 		c->pipe->destroy(c->pipe);
@@ -157,7 +145,7 @@ drm_destroy_context(_EGLDriver *drv, EGLDisplay dpy, EGLContext context)
 }
 
 EGLBoolean
-drm_make_current(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext context)
+drm_make_current(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw, _EGLSurface *read, _EGLContext *context)
 {
 	struct drm_surface *readSurf = lookup_drm_surface(read);
 	struct drm_surface *drawSurf = lookup_drm_surface(draw);
diff --git a/src/gallium/state_trackers/egl/egl_surface.c b/src/gallium/state_trackers/egl/egl_surface.c
index d4cd2d3c74..c66c48f848 100644
--- a/src/gallium/state_trackers/egl/egl_surface.c
+++ b/src/gallium/state_trackers/egl/egl_surface.c
@@ -178,22 +178,22 @@ drm_takedown_shown_screen(_EGLDriver *drv, struct drm_screen *screen)
 	screen->shown = 0;
 }
 
-EGLSurface
-drm_create_window_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list)
+_EGLSurface *
+drm_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativeWindowType window, const EGLint *attrib_list)
 {
-	return EGL_NO_SURFACE;
+	return NULL;
 }
 
 
-EGLSurface
-drm_create_pixmap_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list)
+_EGLSurface *
+drm_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativePixmapType pixmap, const EGLint *attrib_list)
 {
-	return EGL_NO_SURFACE;
+	return NULL;
 }
 
 
-EGLSurface
-drm_create_pbuffer_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+_EGLSurface *
+drm_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                            const EGLint *attrib_list)
 {
 	int i;
@@ -201,13 +201,6 @@ drm_create_pbuffer_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 	int height = -1;
 	struct drm_surface *surf = NULL;
 	__GLcontextModes *visual;
-	_EGLConfig *conf;
-
-	conf = _eglLookupConfig(drv, dpy, config);
-	if (!conf) {
-		_eglError(EGL_BAD_CONFIG, "eglCreatePbufferSurface");
-		return EGL_NO_CONTEXT;
-	}
 
 	for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
 		switch (attrib_list[i]) {
@@ -225,7 +218,7 @@ drm_create_pbuffer_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 
 	if (width < 1 || height < 1) {
 		_eglError(EGL_BAD_ATTRIBUTE, "eglCreatePbufferSurface");
-		return EGL_NO_SURFACE;
+		return NULL;
 	}
 
 	surf = (struct drm_surface *) calloc(1, sizeof(struct drm_surface));
@@ -245,17 +238,16 @@ drm_create_pbuffer_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 	                                    (void*)surf);
 	drm_visual_modes_destroy(visual);
 
-        _eglLinkSurface(&surf->base, _eglLookupDisplay(dpy));
-	return surf->base.Handle;
+	return &surf->base;
 
 err_surf:
 	free(surf);
 err:
-	return EGL_NO_SURFACE;
+	return NULL;
 }
 
-EGLSurface
-drm_create_screen_surface_mesa(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg,
+_EGLSurface *
+drm_create_screen_surface_mesa(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *cfg,
                                const EGLint *attrib_list)
 {
 	EGLSurface surf = drm_create_pbuffer_surface(drv, dpy, cfg, attrib_list);
@@ -264,14 +256,13 @@ drm_create_screen_surface_mesa(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg,
 }
 
 EGLBoolean
-drm_show_screen_surface_mesa(_EGLDriver *drv, EGLDisplay dpy,
-                             EGLScreenMESA screen,
-                             EGLSurface surface, EGLModeMESA m)
+drm_show_screen_surface_mesa(_EGLDriver *drv, _EGLDisplay *dpy,
+                             _EGLScreen *screen,
+                             _EGLSurface *surface, _EGLMode *mode)
 {
 	struct drm_device *dev = (struct drm_device *)drv;
 	struct drm_surface *surf = lookup_drm_surface(surface);
-	struct drm_screen *scrn = lookup_drm_screen(dpy, screen);
-	_EGLMode *mode = _eglLookupMode(dpy, m);
+	struct drm_screen *scrn = lookup_drm_screen(screen);
 	int ret;
 	unsigned int i, k;
 
@@ -361,11 +352,9 @@ err_bo:
 }
 
 EGLBoolean
-drm_destroy_surface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+drm_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface)
 {
 	struct drm_surface *surf = lookup_drm_surface(surface);
-	_eglUnlinkSurface(&surf->base);
-
 	if (!_eglIsSurfaceBound(&surf->base)) {
 		if (surf->screen)
 			drm_takedown_shown_screen(drv, surf->screen);
@@ -376,7 +365,7 @@ drm_destroy_surface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 }
 
 EGLBoolean
-drm_swap_buffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
+drm_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw)
 {
 	struct drm_surface *surf = lookup_drm_surface(draw);
 	struct pipe_surface *back_surf;
diff --git a/src/gallium/state_trackers/egl/egl_tracker.c b/src/gallium/state_trackers/egl/egl_tracker.c
index 521c91d895..107f45cbcb 100644
--- a/src/gallium/state_trackers/egl/egl_tracker.c
+++ b/src/gallium/state_trackers/egl/egl_tracker.c
@@ -129,9 +129,8 @@ drm_find_dpms(struct drm_device *dev, struct drm_screen *screen)
 }
 
 EGLBoolean
-drm_initialize(_EGLDriver *drv, EGLDisplay dpy, EGLint *major, EGLint *minor)
+drm_initialize(_EGLDriver *drv, _EGLDisplay *disp, EGLint *major, EGLint *minor)
 {
-	_EGLDisplay *disp = _eglLookupDisplay(dpy);
 	struct drm_device *dev = (struct drm_device *)drv;
 	struct drm_screen *screen = NULL;
 	drmModeConnectorPtr connector = NULL;
@@ -214,7 +213,7 @@ err_fd:
 }
 
 EGLBoolean
-drm_terminate(_EGLDriver *drv, EGLDisplay dpy)
+drm_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
 {
 	struct drm_device *dev = (struct drm_device *)drv;
 	struct drm_screen *screen;
@@ -240,7 +239,7 @@ drm_terminate(_EGLDriver *drv, EGLDisplay dpy)
 
 	drmClose(dev->drmFD);
 
-	_eglCleanupDisplay(_eglLookupDisplay(dpy));
+	_eglCleanupDisplay(dpy);
 	free(dev);
 
 	return EGL_TRUE;
diff --git a/src/gallium/state_trackers/egl/egl_tracker.h b/src/gallium/state_trackers/egl/egl_tracker.h
index 3b8836720d..25f70d885e 100644
--- a/src/gallium/state_trackers/egl/egl_tracker.h
+++ b/src/gallium/state_trackers/egl/egl_tracker.h
@@ -137,24 +137,21 @@ struct drm_screen
 
 
 static INLINE struct drm_context *
-lookup_drm_context(EGLContext context)
+lookup_drm_context(_EGLContext *c)
 {
-	_EGLContext *c = _eglLookupContext(context);
 	return (struct drm_context *) c;
 }
 
 
 static INLINE struct drm_surface *
-lookup_drm_surface(EGLSurface surface)
+lookup_drm_surface(_EGLSurface *s)
 {
-	_EGLSurface *s = _eglLookupSurface(surface);
 	return (struct drm_surface *) s;
 }
 
 static INLINE struct drm_screen *
-lookup_drm_screen(EGLDisplay dpy, EGLScreenMESA screen)
+lookup_drm_screen(_EGLScreen *s)
 {
-	_EGLScreen *s = _eglLookupScreen(dpy, screen);
 	return (struct drm_screen *) s;
 }
 
@@ -178,18 +175,18 @@ void drm_takedown_shown_screen(_EGLDriver *drv, struct drm_screen *screen);
  * All function exported to the egl side.
  */
 /*@{*/
-EGLBoolean drm_initialize(_EGLDriver *drv, EGLDisplay dpy, EGLint *major, EGLint *minor);
-EGLBoolean drm_terminate(_EGLDriver *drv, EGLDisplay dpy);
-EGLContext drm_create_context(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list);
-EGLBoolean drm_destroy_context(_EGLDriver *drv, EGLDisplay dpy, EGLContext context);
-EGLSurface drm_create_window_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list);
-EGLSurface drm_create_pixmap_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list);
-EGLSurface drm_create_pbuffer_surface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
-EGLSurface drm_create_screen_surface_mesa(_EGLDriver *drv, EGLDisplay dpy, EGLConfig cfg, const EGLint *attrib_list);
-EGLBoolean drm_show_screen_surface_mesa(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA screen, EGLSurface surface, EGLModeMESA m);
-EGLBoolean drm_destroy_surface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface);
-EGLBoolean drm_make_current(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext context);
-EGLBoolean drm_swap_buffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw);
+EGLBoolean drm_initialize(_EGLDriver *drv, _EGLDisplay *dpy, EGLint *major, EGLint *minor);
+EGLBoolean drm_terminate(_EGLDriver *drv, _EGLDisplay *dpy);
+_EGLContext *drm_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, _EGLContext *share_list, const EGLint *attrib_list);
+EGLBoolean drm_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *context);
+_EGLSurface *drm_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativeWindowType window, const EGLint *attrib_list);
+_EGLSurface *drm_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativePixmapType pixmap, const EGLint *attrib_list);
+_EGLSurface *drm_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, const EGLint *attrib_list);
+_EGLSurface *drm_create_screen_surface_mesa(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, const EGLint *attrib_list);
+EGLBoolean drm_show_screen_surface_mesa(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *screen, _EGLSurface *surface, _EGLMode *mode);
+EGLBoolean drm_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface);
+EGLBoolean drm_make_current(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw, _EGLSurface *read, _EGLContext *context);
+EGLBoolean drm_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw);
 /*@}*/
 
 #endif
diff --git a/src/gallium/winsys/egl_xlib/egl_xlib.c b/src/gallium/winsys/egl_xlib/egl_xlib.c
index f409a3fd6b..ed7eab50dd 100644
--- a/src/gallium/winsys/egl_xlib/egl_xlib.c
+++ b/src/gallium/winsys/egl_xlib/egl_xlib.c
@@ -103,18 +103,16 @@ xlib_egl_driver(_EGLDriver *drv)
 
 
 static INLINE struct xlib_egl_surface *
-lookup_surface(EGLSurface surf)
+lookup_surface(_EGLSurface *surf)
 {
-   _EGLSurface *surface = _eglLookupSurface(surf);
-   return (struct xlib_egl_surface *) surface;
+   return (struct xlib_egl_surface *) surf;
 }
 
 
 static INLINE struct xlib_egl_context *
-lookup_context(EGLContext ctx)
+lookup_context(_EGLContext *ctx)
 {
-   _EGLContext *context = _eglLookupContext(ctx);
-   return (struct xlib_egl_context *) context;
+   return (struct xlib_egl_context *) ctx;
 }
 
 
@@ -133,13 +131,12 @@ bitcount(unsigned int n)
  * Create the EGLConfigs.  (one per X visual)
  */
 static void
-create_configs(_EGLDriver *drv, EGLDisplay dpy)
+create_configs(_EGLDriver *drv, _EGLDisplay *disp)
 {
    static const EGLint all_apis = (EGL_OPENGL_ES_BIT |
                                    EGL_OPENGL_ES2_BIT |
                                    EGL_OPENVG_BIT |
                                    EGL_OPENGL_BIT);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    XVisualInfo *visInfo, visTemplate;
    int num_visuals, i;
 
@@ -194,7 +191,7 @@ create_configs(_EGLDriver *drv, EGLDisplay dpy)
  * Called via eglInitialize(), drv->API.Initialize().
  */
 static EGLBoolean
-xlib_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
+xlib_eglInitialize(_EGLDriver *drv, _EGLDisplay *dpy,
                    EGLint *minor, EGLint *major)
 {
    create_configs(drv, dpy);
@@ -213,7 +210,7 @@ xlib_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
  * Called via eglTerminate(), drv->API.Terminate().
  */
 static EGLBoolean
-xlib_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
+xlib_eglTerminate(_EGLDriver *drv, _EGLDisplay *dpy)
 {
    return EGL_TRUE;
 }
@@ -342,24 +339,23 @@ flush_frontbuffer(struct pipe_winsys *pws,
 /**
  * Called via eglCreateContext(), drv->API.CreateContext().
  */
-static EGLContext
-xlib_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
-                      EGLContext share_list, const EGLint *attrib_list)
+static _EGLContext *
+xlib_eglCreateContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+                      _EGLContext *share_list, const EGLint *attrib_list)
 {
    struct xlib_egl_driver *xdrv = xlib_egl_driver(drv);
-   _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
    struct xlib_egl_context *ctx;
    struct st_context *share_ctx = NULL; /* XXX fix */
    __GLcontextModes visual;
 
    ctx = CALLOC_STRUCT(xlib_egl_context);
    if (!ctx)
-      return EGL_NO_CONTEXT;
+      return NULL;
 
    /* let EGL lib init the common stuff */
    if (!_eglInitContext(drv, &ctx->Base, conf, attrib_list)) {
       free(ctx);
-      return EGL_NO_CONTEXT;
+      return NULL;
    }
 
    /* API-dependent context creation */
@@ -379,41 +375,33 @@ xlib_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
    default:
       _eglError(EGL_BAD_MATCH, "eglCreateContext(unsupported API)");
       free(ctx);
-      return EGL_NO_CONTEXT;
+      return NULL;
    }
 
-   _eglLinkContext(&ctx->Base, _eglLookupDisplay(dpy));
-
-   return _eglGetContextHandle(&ctx->Base);
+   return &ctx->Base;
 }
 
 
 static EGLBoolean
-xlib_eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
+xlib_eglDestroyContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
 {
    struct xlib_egl_context *context = lookup_context(ctx);
-   if (context) {
-      _eglUnlinkContext(&context->Base);
-      if (!_eglIsContextBound(&context->Base)) {
-         /* API-dependent clean-up */
-         switch (context->Base.ClientAPI) {
-         case EGL_OPENGL_ES_API:
-         case EGL_OPENVG_API:
-            /* fall-through */
-         case EGL_OPENGL_API:
-            st_destroy_context(context->Context);
-            break;
-         default:
-            assert(0);
-         }
-         free(context);
+
+   if (!_eglIsContextBound(&context->Base)) {
+      /* API-dependent clean-up */
+      switch (context->Base.ClientAPI) {
+      case EGL_OPENGL_ES_API:
+      case EGL_OPENVG_API:
+         /* fall-through */
+      case EGL_OPENGL_API:
+         st_destroy_context(context->Context);
+         break;
+      default:
+         assert(0);
       }
-      return EGL_TRUE;
-   }
-   else {
-      _eglError(EGL_BAD_CONTEXT, "eglDestroyContext");
-      return EGL_TRUE;
+      free(context);
    }
+   return EGL_TRUE;
 }
 
 
@@ -421,15 +409,15 @@ xlib_eglDestroyContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
  */
 static EGLBoolean
-xlib_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy,
-                    EGLSurface draw, EGLSurface read, EGLContext ctx)
+xlib_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy,
+                    _EGLSurface *draw, _EGLSurface *read, _EGLContext *ctx)
 {
    struct xlib_egl_context *context = lookup_context(ctx);
    struct xlib_egl_surface *draw_surf = lookup_surface(draw);
    struct xlib_egl_surface *read_surf = lookup_surface(read);
    struct st_context *oldctx = st_get_current();
 
-   if (!_eglMakeCurrent(drv, dpy, draw, read, context))
+   if (!_eglMakeCurrent(drv, dpy, draw, read, ctx))
       return EGL_FALSE;
 
    /* Flush before switching context.  Check client API? */
@@ -488,31 +476,26 @@ choose_stencil_format(const __GLcontextModes *visual)
 /**
  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
  */
-static EGLSurface
-xlib_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+static _EGLSurface *
+xlib_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
                             NativeWindowType window, const EGLint *attrib_list)
 {
    struct xlib_egl_driver *xdrv = xlib_egl_driver(drv);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
-
    struct xlib_egl_surface *surf;
    __GLcontextModes visual;
    uint width, height;
 
    surf = CALLOC_STRUCT(xlib_egl_surface);
    if (!surf)
-      return EGL_NO_SURFACE;
+      return NULL;
 
    /* Let EGL lib init the common stuff */
    if (!_eglInitSurface(drv, &surf->Base, EGL_WINDOW_BIT,
                         conf, attrib_list)) {
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
-   _eglLinkSurface(&surf->Base, disp);
-
    /*
     * Now init the Xlib and gallium stuff
     */
@@ -539,46 +522,35 @@ xlib_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
 
    st_resize_framebuffer(surf->Framebuffer, width, height);
 
-   return _eglGetSurfaceHandle(&surf->Base);
+   return &surf->Base;
 }
 
 
-static EGLSurface
-xlib_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+static _EGLSurface *
+xlib_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
                              const EGLint *attrib_list)
 {
    struct xlib_egl_driver *xdrv = xlib_egl_driver(drv);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
    struct xlib_egl_surface *surf;
    __GLcontextModes visual;
    uint width, height;
    EGLBoolean bind_texture;
 
-   if (!disp) {
-      _eglError(EGL_BAD_DISPLAY, "eglCreatePbufferSurface");
-      return EGL_NO_SURFACE;
-   }
-   if (!conf) {
-      _eglError(EGL_BAD_CONFIG, "eglCreatePbufferSurface");
-      return EGL_NO_SURFACE;
-   }
-
    surf = CALLOC_STRUCT(xlib_egl_surface);
    if (!surf) {
       _eglError(EGL_BAD_ALLOC, "eglCreatePbufferSurface");
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
    if (!_eglInitSurface(drv, &surf->Base, EGL_PBUFFER_BIT,
                         conf, attrib_list)) {
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
    if (surf->Base.Width < 0 || surf->Base.Height < 0) {
       _eglError(EGL_BAD_PARAMETER, "eglCreatePbufferSurface");
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
    bind_texture = (surf->Base.TextureFormat != EGL_NO_TEXTURE);
@@ -588,19 +560,19 @@ xlib_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
        (surf->Base.TextureTarget != EGL_NO_TEXTURE && !bind_texture)) {
       _eglError(EGL_BAD_MATCH, "eglCreatePbufferSurface");
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
    /* a framebuffer of zero width or height confuses st */
    if (width == 0 || height == 0) {
       _eglError(EGL_BAD_MATCH, "eglCreatePbufferSurface");
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
    /* no mipmap generation */
    if (surf->Base.MipmapTexture) {
       _eglError(EGL_BAD_MATCH, "eglCreatePbufferSurface");
       free(surf);
-      return EGL_NO_SURFACE;
+      return NULL;
    }
 
    surf->winsys = xdrv->winsys;
@@ -616,34 +588,27 @@ xlib_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
                                              (void *) surf);
    st_resize_framebuffer(surf->Framebuffer, width, height);
 
-   return _eglLinkSurface(&surf->Base, disp);
+   return &surf->Base;
 }
 
 
 static EGLBoolean
-xlib_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+xlib_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface)
 {
    struct xlib_egl_surface *surf = lookup_surface(surface);
-   if (surf) {
-      _eglUnlinkSurface(&surf->Base);
-      if (!_eglIsSurfaceBound(&surf->Base)) {
-         if (surf->Base.Type != EGL_PBUFFER_BIT)
-            XFreeGC(surf->Dpy, surf->Gc);
-         st_unreference_framebuffer(surf->Framebuffer);
-         free(surf);
-      }
-      return EGL_TRUE;
-   }
-   else {
-      _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
-      return EGL_FALSE;
+   if (!_eglIsSurfaceBound(&surf->Base)) {
+      if (surf->Base.Type != EGL_PBUFFER_BIT)
+         XFreeGC(surf->Dpy, surf->Gc);
+      st_unreference_framebuffer(surf->Framebuffer);
+      free(surf);
    }
+   return EGL_TRUE;
 }
 
 
 static EGLBoolean
-xlib_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy,
-                     EGLSurface surface, EGLint buffer)
+xlib_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *dpy,
+                     _EGLSurface *surface, EGLint buffer)
 {
    struct xlib_egl_surface *xsurf = lookup_surface(surface);
    struct xlib_egl_context *xctx;
@@ -680,12 +645,12 @@ xlib_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy,
 
    /* flush properly */
    if (eglGetCurrentSurface(EGL_DRAW) == surface) {
-      xctx = lookup_context(eglGetCurrentContext());
+      xctx = lookup_context(_eglGetCurrentContext());
       st_flush(xctx->Context, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME,
                NULL);
    }
    else if (_eglIsSurfaceBound(&xsurf->Base)) {
-      xctx = lookup_context(_eglGetContextHandle(xsurf->Base.Binding));
+      xctx = lookup_context(xsurf->Base.Binding);
       if (xctx)
          st_finish(xctx->Context);
    }
@@ -700,7 +665,7 @@ xlib_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy,
 
 
 static EGLBoolean
-xlib_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+xlib_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface,
                         EGLint buffer)
 {
    struct xlib_egl_surface *xsurf = lookup_surface(surface);
@@ -722,7 +687,7 @@ xlib_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
 
 
 static EGLBoolean
-xlib_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
+xlib_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw)
 {
    /* error checking step: */
    if (!_eglSwapBuffers(drv, dpy, draw))
@@ -831,4 +796,3 @@ _eglMain(_EGLDisplay *dpy, const char *args)
 
    return &xdrv->Base;
 }
-
-- 
cgit v1.2.3


From 5a2c9372a0d9fa1efd924f9386a4e3df47c17d0e Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Thu, 13 Aug 2009 13:38:24 +0800
Subject: egl: Some per-driver data should be per-display.

Move some fields of _EGLDriver to _EGLDisplay.  It also becomes
unnecessary to pass _EGLDisplay to drivers when _eglMain is called.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/demo/demo.c                  | 19 ++++++----
 src/egl/drivers/glx/egl_glx.c                | 18 +++++++---
 src/egl/main/eglapi.c                        | 13 ++++---
 src/egl/main/egldisplay.h                    | 25 +++++++++++++
 src/egl/main/egldriver.c                     |  9 ++---
 src/egl/main/egldriver.h                     | 27 +-------------
 src/egl/main/eglglobals.c                    |  1 -
 src/egl/main/eglglobals.h                    |  2 --
 src/egl/main/eglmisc.c                       | 54 +++++++++++++++-------------
 src/egl/main/eglsurface.c                    |  2 +-
 src/egl/main/egltypedefs.h                   |  2 +-
 src/gallium/state_trackers/egl/egl_tracker.c | 25 ++++++++-----
 src/gallium/winsys/egl_xlib/egl_xlib.c       | 36 +++++++++++++------
 13 files changed, 138 insertions(+), 95 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/demo/demo.c b/src/egl/drivers/demo/demo.c
index e9e6bac5b1..aea4894448 100644
--- a/src/egl/drivers/demo/demo.c
+++ b/src/egl/drivers/demo/demo.c
@@ -84,7 +84,9 @@ demoInitialize(_EGLDriver *drv, _EGLDisplay *disp, EGLint *major, EGLint *minor)
       _eglAddConfig(disp, config);
    }
 
-   drv->Initialized = EGL_TRUE;
+   /* enable supported extensions */
+   disp->Extensions.MESA_screen_surface = EGL_TRUE;
+   disp->Extensions.MESA_copy_context = EGL_TRUE;
 
    *major = 1;
    *minor = 0;
@@ -97,7 +99,6 @@ static EGLBoolean
 demoTerminate(_EGLDriver *drv, _EGLDisplay *dpy)
 {
    /*DemoDriver *demo = DEMO_DRIVER(dpy);*/
-   free(drv);
    return EGL_TRUE;
 }
 
@@ -247,12 +248,19 @@ demoMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *drawSurf, _EGLSu
 }
 
 
+static void
+demoUnload(_EGLDriver *drv)
+{
+   free(drv);
+}
+
+
 /**
  * The bootstrap function.  Return a new DemoDriver object and
  * plug in API functions.
  */
 _EGLDriver *
-_eglMain(_EGLDisplay *dpy, const char *args)
+_eglMain(const char *args)
 {
    DemoDriver *demo;
 
@@ -274,9 +282,8 @@ _eglMain(_EGLDisplay *dpy, const char *args)
    demo->Base.API.DestroySurface = demoDestroySurface;
    demo->Base.API.DestroyContext = demoDestroyContext;
 
-   /* enable supported extensions */
-   demo->Base.Extensions.MESA_screen_surface = EGL_TRUE;
-   demo->Base.Extensions.MESA_copy_context = EGL_TRUE;
+   demo->Base.Name = "egl/demo";
+   demo->Base.Unload = demoUnload;
 
    return &demo->Base;
 }
diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 607e649e5c..9d80bc1a84 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -462,10 +462,10 @@ GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp,
       }
    } 
 
+   disp->ClientAPIsMask = all_apis;
+
    glXQueryVersion(disp->Xdpy, &GLX_drv->glx_maj, &GLX_drv->glx_min);
    
-   GLX_drv->Base.Initialized = EGL_TRUE;
-
    GLX_drv->Base.Name = "GLX";
 
    /* we're supporting EGL 1.4 */
@@ -513,7 +513,9 @@ GLX_eglTerminate(_EGLDriver *drv, _EGLDisplay *disp)
 {
    _eglLog(_EGL_DEBUG, "GLX: eglTerminate");
 
+   _eglReleaseDisplayResources(drv, disp);
    FreeDisplayExt(disp->Xdpy);
+   _eglCleanupDisplay(disp);
 
    return EGL_TRUE;
 }
@@ -797,12 +799,20 @@ GLX_eglGetProcAddress(const char *procname)
 }
 
 
+static void
+GLX_Unload(_EGLDriver *drv)
+{
+   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   free(GLX_drv);
+}
+
+
 /**
  * This is the main entrypoint into the driver, called by libEGL.
  * Create a new _EGLDriver object and init its dispatch table.
  */
 _EGLDriver *
-_eglMain(_EGLDisplay *disp, const char *args)
+_eglMain(const char *args)
 {
    struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
    char *env;
@@ -831,8 +841,8 @@ _eglMain(_EGLDisplay *disp, const char *args)
    GLX_drv->Base.API.SwapBuffers = GLX_eglSwapBuffers;
    GLX_drv->Base.API.GetProcAddress = GLX_eglGetProcAddress;
 
-   GLX_drv->Base.ClientAPIsMask = all_apis;
    GLX_drv->Base.Name = "GLX";
+   GLX_drv->Base.Unload = GLX_Unload;
 
    _eglLog(_EGL_DEBUG, "GLX: main(%s)", args);
 
diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 464da00fe2..a23b57120c 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -87,15 +87,18 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
          return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
       }
 
-      drv->APImajor = major_int;
-      drv->APIminor = minor_int;
-      snprintf(drv->Version, sizeof(drv->Version),
+      disp->APImajor = major_int;
+      disp->APIminor = minor_int;
+      snprintf(disp->Version, sizeof(disp->Version),
                "%d.%d (%s)", major_int, minor_int, drv->Name);
 
+      /* update the global notion of supported APIs */
+      _eglGlobal.ClientAPIsMask |= disp->ClientAPIsMask;
+
       disp->Driver = drv;
    } else {
-      major_int = drv->APImajor;
-      minor_int = drv->APIminor;
+      major_int = disp->APImajor;
+      minor_int = disp->APIminor;
    }
 
    /* Update applications version of major and minor if not NULL */
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 78fbf5b840..e1cbbac837 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -7,6 +7,19 @@
 
 #include "egltypedefs.h"
 #include "eglhash.h"
+#include "egldefines.h"
+
+
+/**
+ * Optional EGL extensions info.
+ */
+struct _egl_extensions
+{
+   EGLBoolean MESA_screen_surface;
+   EGLBoolean MESA_copy_context;
+
+   char String[_EGL_MAX_EXTENSIONS_LEN];
+};
 
 
 struct _egl_display 
@@ -16,6 +29,18 @@ struct _egl_display
 
    const char *DriverName;
    _EGLDriver *Driver;
+   void *DriverData; /* private to driver */
+
+   int APImajor, APIminor; /**< as returned by eglInitialize() */
+   char Version[1000];     /**< initialized from APImajor/minor, DriverName */
+
+   /** Bitmask of supported APIs (EGL_xx_BIT) set by the driver during init */
+   EGLint ClientAPIsMask;
+   char ClientAPIs[1000];   /**< updated by eglQueryString */
+
+   _EGLExtensions Extensions;
+
+   int LargestPbuffer;
 
    EGLint NumScreens;
    _EGLScreen **Screens;  /* array [NumScreens] */
diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c
index 36cc2948c0..0e6b294385 100644
--- a/src/egl/main/egldriver.c
+++ b/src/egl/main/egldriver.c
@@ -245,7 +245,7 @@ _eglOpenLibrary(const char *driverName, lib_handle *handle)
  * owned by the driver and freed.
  */
 static _EGLDriver *
-_eglLoadDriver(_EGLDisplay *dpy, char *path, char *args)
+_eglLoadDriver(char *path, char *args)
 {
    _EGLMain_t mainFunc;
    lib_handle lib;
@@ -255,7 +255,7 @@ _eglLoadDriver(_EGLDisplay *dpy, char *path, char *args)
    if (!mainFunc)
       return NULL;
 
-   drv = mainFunc(dpy, args);
+   drv = mainFunc(args);
    if (!drv) {
       if (lib)
          close_library(lib);
@@ -332,13 +332,10 @@ _eglPreloadDriver(_EGLDisplay *dpy)
       }
    }
 
-   drv = _eglLoadDriver(dpy, path, args);
+   drv = _eglLoadDriver(path, args);
    if (!drv)
       return NULL;
 
-   /* update the global notion of supported APIs */
-   _eglGlobal.ClientAPIsMask |= drv->ClientAPIsMask;
-
    _eglGlobal.Drivers[_eglGlobal.NumDrivers++] = drv;
 
    return drv->Name;
diff --git a/src/egl/main/egldriver.h b/src/egl/main/egldriver.h
index 430c0949d4..7fba938085 100644
--- a/src/egl/main/egldriver.h
+++ b/src/egl/main/egldriver.h
@@ -4,19 +4,6 @@
 
 #include "egltypedefs.h"
 #include "eglapi.h"
-#include "egldefines.h"
-
-
-/**
- * Optional EGL extensions info.
- */
-struct _egl_extensions
-{
-   EGLBoolean MESA_screen_surface;
-   EGLBoolean MESA_copy_context;
-
-   char String[_EGL_MAX_EXTENSIONS_LEN];
-};
 
 
 /**
@@ -24,8 +11,6 @@ struct _egl_extensions
  */
 struct _egl_driver
 {
-   EGLBoolean Initialized; /**< set by driver after initialized */
-
    void *LibHandle; /**< dlopen handle */
    const char *Path;  /**< path to this driver */
    const char *Args;  /**< args to load this driver */
@@ -36,21 +21,11 @@ struct _egl_driver
    /**< called before dlclose to release this driver */
    void (*Unload)(_EGLDriver *drv);
 
-   int APImajor, APIminor; /**< as returned by eglInitialize() */
-   char Version[1000];       /**< initialized from APImajor/minor, Name */
-
-   /** Bitmask of supported APIs (EGL_xx_BIT) set by the driver during init */
-   EGLint ClientAPIsMask;
-
    _EGLAPI API;  /**< EGL API dispatch table */
-
-   _EGLExtensions Extensions;
-
-   int LargestPbuffer;
 };
 
 
-extern _EGLDriver *_eglMain(_EGLDisplay *dpy, const char *args);
+extern _EGLDriver *_eglMain(const char *args);
 
 
 extern const char *
diff --git a/src/egl/main/eglglobals.c b/src/egl/main/eglglobals.c
index a532f142b7..8c14f9c4bf 100644
--- a/src/egl/main/eglglobals.c
+++ b/src/egl/main/eglglobals.c
@@ -15,7 +15,6 @@ struct _egl_global _eglGlobal =
    &_eglGlobalMutex,       /* Mutex */
    1,                      /* FreeScreenHandle */
    0x0,                    /* ClientAPIsMask */
-   { 0x0 },                /* ClientAPIs */
    0,                      /* NumDrivers */
    { NULL },               /* Drivers */
    1,                      /* NumAtExitCalls */
diff --git a/src/egl/main/eglglobals.h b/src/egl/main/eglglobals.h
index 1e2c674263..d00d12afd8 100644
--- a/src/egl/main/eglglobals.h
+++ b/src/egl/main/eglglobals.h
@@ -18,8 +18,6 @@ struct _egl_global
    /* bitmaks of supported APIs (supported by _some_ driver) */
    EGLint ClientAPIsMask;
 
-   char ClientAPIs[1000];   /**< updated by eglQueryString */
-
    EGLint NumDrivers;
    _EGLDriver *Drivers[10];
 
diff --git a/src/egl/main/eglmisc.c b/src/egl/main/eglmisc.c
index 3440b77dd9..b37213faf1 100644
--- a/src/egl/main/eglmisc.c
+++ b/src/egl/main/eglmisc.c
@@ -35,6 +35,7 @@
 #include <string.h>
 #include "eglglobals.h"
 #include "eglmisc.h"
+#include "egldisplay.h"
 
 
 /**
@@ -42,38 +43,43 @@
  * the driver's Extensions string.
  */
 static void
-_eglUpdateExtensionsString(_EGLDriver *drv)
+_eglUpdateExtensionsString(_EGLDisplay *dpy)
 {
-   drv->Extensions.String[0] = 0;
+   char *exts = dpy->Extensions.String;
 
-   if (drv->Extensions.MESA_screen_surface)
-      strcat(drv->Extensions.String, "EGL_MESA_screen_surface ");
-   if (drv->Extensions.MESA_copy_context)
-      strcat(drv->Extensions.String, "EGL_MESA_copy_context ");
-   assert(strlen(drv->Extensions.String) < _EGL_MAX_EXTENSIONS_LEN);
+   if (exts[0])
+      return;
+
+   if (dpy->Extensions.MESA_screen_surface)
+      strcat(exts, "EGL_MESA_screen_surface ");
+   if (dpy->Extensions.MESA_copy_context)
+      strcat(exts, "EGL_MESA_copy_context ");
+   assert(strlen(exts) < _EGL_MAX_EXTENSIONS_LEN);
 }
 
 
 static void
-_eglUpdateAPIsString(_EGLDriver *drv)
+_eglUpdateAPIsString(_EGLDisplay *dpy)
 {
-   _eglGlobal.ClientAPIs[0] = 0;
+   char *apis = dpy->ClientAPIs;
 
-   if (_eglGlobal.ClientAPIsMask & EGL_OPENGL_BIT)
-      strcat(_eglGlobal.ClientAPIs, "OpenGL ");
+   if (apis[0] || !dpy->ClientAPIsMask)
+      return;
 
-   if (_eglGlobal.ClientAPIsMask & EGL_OPENGL_ES_BIT)
-      strcat(_eglGlobal.ClientAPIs, "OpenGL_ES ");
+   if (dpy->ClientAPIsMask & EGL_OPENGL_BIT)
+      strcat(apis, "OpenGL ");
 
-   if (_eglGlobal.ClientAPIsMask & EGL_OPENGL_ES2_BIT)
-      strcat(_eglGlobal.ClientAPIs, "OpenGL_ES2 ");
+   if (dpy->ClientAPIsMask & EGL_OPENGL_ES_BIT)
+      strcat(apis, "OpenGL_ES ");
 
-   if (_eglGlobal.ClientAPIsMask & EGL_OPENVG_BIT)
-      strcat(_eglGlobal.ClientAPIs, "OpenVG ");
+   if (dpy->ClientAPIsMask & EGL_OPENGL_ES2_BIT)
+      strcat(apis, "OpenGL_ES2 ");
 
-   assert(strlen(_eglGlobal.ClientAPIs) < sizeof(_eglGlobal.ClientAPIs));
-}
+   if (dpy->ClientAPIsMask & EGL_OPENVG_BIT)
+      strcat(apis, "OpenVG ");
 
+   assert(strlen(apis) < sizeof(dpy->ClientAPIs));
+}
 
 
 const char *
@@ -85,14 +91,14 @@ _eglQueryString(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name)
    case EGL_VENDOR:
       return _EGL_VENDOR_STRING;
    case EGL_VERSION:
-      return drv->Version;
+      return dpy->Version;
    case EGL_EXTENSIONS:
-      _eglUpdateExtensionsString(drv);
-      return drv->Extensions.String;
+      _eglUpdateExtensionsString(dpy);
+      return dpy->Extensions.String;
 #ifdef EGL_VERSION_1_2
    case EGL_CLIENT_APIS:
-      _eglUpdateAPIsString(drv);
-      return _eglGlobal.ClientAPIs;
+      _eglUpdateAPIsString(dpy);
+      return dpy->ClientAPIs;
 #endif
    default:
       _eglError(EGL_BAD_PARAMETER, "eglQueryString");
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 056288c850..adf125f88a 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -243,7 +243,7 @@ _eglQuerySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface,
       *value = GET_CONFIG_ATTRIB(surface->Config, EGL_CONFIG_ID);
       return EGL_TRUE;
    case EGL_LARGEST_PBUFFER:
-      *value = drv->LargestPbuffer;
+      *value = dpy->LargestPbuffer;
       return EGL_TRUE;
    case EGL_SURFACE_TYPE:
       *value = surface->Type;
diff --git a/src/egl/main/egltypedefs.h b/src/egl/main/egltypedefs.h
index 0a770dec0c..4461440b9b 100644
--- a/src/egl/main/egltypedefs.h
+++ b/src/egl/main/egltypedefs.h
@@ -29,7 +29,7 @@ typedef struct _egl_surface _EGLSurface;
 typedef struct _egl_thread_info _EGLThreadInfo;
 
 
-typedef _EGLDriver *(*_EGLMain_t)(_EGLDisplay *dpy, const char *args);
+typedef _EGLDriver *(*_EGLMain_t)(const char *args);
 
 
 #endif /* EGLTYPEDEFS_INCLUDED */
diff --git a/src/gallium/state_trackers/egl/egl_tracker.c b/src/gallium/state_trackers/egl/egl_tracker.c
index 107f45cbcb..ced002c535 100644
--- a/src/gallium/state_trackers/egl/egl_tracker.c
+++ b/src/gallium/state_trackers/egl/egl_tracker.c
@@ -21,12 +21,20 @@ extern const struct dri_extension card_extensions[];
  * Exported functions
  */
 
+static void
+drm_unload(_EGLDriver *drv)
+{
+	struct drm_device *dev = (struct drm_device *)drv;
+	dev->api->destroy(dev->api);
+	free(dev);
+}
+
 /**
  * The bootstrap function.  Return a new drm_driver object and
  * plug in API functions.
  */
 _EGLDriver *
-_eglMain(_EGLDisplay *dpy, const char *args)
+_eglMain(const char *args)
 {
 	struct drm_device *drm;
 
@@ -53,12 +61,8 @@ _eglMain(_EGLDisplay *dpy, const char *args)
 	drm->base.API.ShowScreenSurfaceMESA = drm_show_screen_surface_mesa;
 	drm->base.API.SwapBuffers = drm_swap_buffers;
 
-	drm->base.ClientAPIsMask = EGL_OPENGL_BIT /*| EGL_OPENGL_ES_BIT*/;
 	drm->base.Name = "DRM/Gallium/Win";
-
-	/* enable supported extensions */
-	drm->base.Extensions.MESA_screen_surface = EGL_TRUE;
-	drm->base.Extensions.MESA_copy_context = EGL_TRUE;
+	drm->base.Unload = drm_unload;
 
 	return &drm->base;
 }
@@ -199,7 +203,10 @@ drm_initialize(_EGLDriver *drv, _EGLDisplay *disp, EGLint *major, EGLint *minor)
 	_eglSetConfigAttrib(config, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT);
 	_eglAddConfig(disp, config);
 
-	drv->Initialized = EGL_TRUE;
+	disp->ClientAPIsMask = EGL_OPENGL_BIT /*| EGL_OPENGL_ES_BIT*/;
+	/* enable supported extensions */
+	disp->Extensions.MESA_screen_surface = EGL_TRUE;
+	disp->Extensions.MESA_copy_context = EGL_TRUE;
 
 	*major = 1;
 	*minor = 4;
@@ -219,6 +226,8 @@ drm_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
 	struct drm_screen *screen;
 	int i = 0;
 
+	_eglReleaseDisplayResources(drv, dpy);
+
 	drmFreeVersion(dev->version);
 
 	for (i = 0; i < dev->count_screens; i++) {
@@ -235,12 +244,10 @@ drm_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
 
 	dev->screen->destroy(dev->screen);
 	dev->winsys = NULL;
-	dev->api->destroy(dev->api);
 
 	drmClose(dev->drmFD);
 
 	_eglCleanupDisplay(dpy);
-	free(dev);
 
 	return EGL_TRUE;
 }
diff --git a/src/gallium/winsys/egl_xlib/egl_xlib.c b/src/gallium/winsys/egl_xlib/egl_xlib.c
index ed7eab50dd..7a667568b8 100644
--- a/src/gallium/winsys/egl_xlib/egl_xlib.c
+++ b/src/gallium/winsys/egl_xlib/egl_xlib.c
@@ -62,6 +62,7 @@ struct xlib_egl_driver
 {
    _EGLDriver Base;   /**< base class */
 
+   EGLint apis;
    struct pipe_winsys *winsys;
    struct pipe_screen *screen;
 };
@@ -194,9 +195,15 @@ static EGLBoolean
 xlib_eglInitialize(_EGLDriver *drv, _EGLDisplay *dpy,
                    EGLint *minor, EGLint *major)
 {
+   struct xlib_egl_driver *xdrv = xlib_egl_driver(drv);
+
    create_configs(drv, dpy);
 
-   drv->Initialized = EGL_TRUE;
+   if (!dpy->Xdpy) {
+      dpy->Xdpy = XOpenDisplay(NULL);
+   }
+
+   dpy->ClientAPIsMask = xdrv->apis;
 
    /* we're supporting EGL 1.4 */
    *minor = 1;
@@ -212,6 +219,8 @@ xlib_eglInitialize(_EGLDriver *drv, _EGLDisplay *dpy,
 static EGLBoolean
 xlib_eglTerminate(_EGLDriver *drv, _EGLDisplay *dpy)
 {
+   _eglReleaseDisplayResources(drv, dpy);
+   _eglCleanupDisplay(dpy);
    return EGL_TRUE;
 }
 
@@ -744,12 +753,22 @@ find_supported_apis(void)
 }
 
 
+static void
+xlib_Unload(_EGLDriver *drv)
+{
+   struct xlib_egl_driver *xdrv = xlib_egl_driver(drv);
+   xdrv->screen->destroy(xdrv->screen);
+   free(xdrv->winsys);
+   free(xdrv);
+}
+
+
 /**
  * This is the main entrypoint into the driver.
  * Called by libEGL to instantiate an _EGLDriver object.
  */
 _EGLDriver *
-_eglMain(_EGLDisplay *dpy, const char *args)
+_eglMain(const char *args)
 {
    struct xlib_egl_driver *xdrv;
 
@@ -759,10 +778,6 @@ _eglMain(_EGLDisplay *dpy, const char *args)
    if (!xdrv)
       return NULL;
 
-   if (!dpy->Xdpy) {
-      dpy->Xdpy = XOpenDisplay(NULL);
-   }
-
    _eglInitDriverFallbacks(&xdrv->Base);
    xdrv->Base.API.Initialize = xlib_eglInitialize;
    xdrv->Base.API.Terminate = xlib_eglTerminate;
@@ -777,16 +792,17 @@ _eglMain(_EGLDisplay *dpy, const char *args)
    xdrv->Base.API.MakeCurrent = xlib_eglMakeCurrent;
    xdrv->Base.API.SwapBuffers = xlib_eglSwapBuffers;
 
-   xdrv->Base.ClientAPIsMask = find_supported_apis();
-   if (xdrv->Base.ClientAPIsMask == 0x0) {
+   xdrv->apis = find_supported_apis();
+   if (xdrv->apis == 0x0) {
       /* the app isn't directly linked with any EGL-supprted APIs
        * (such as libGLESv2.so) so use an EGL utility to see what
        * APIs might be loaded dynamically on this system.
        */
-      xdrv->Base.ClientAPIsMask = _eglFindAPIs();
-   }      
+      xdrv->apis = _eglFindAPIs();
+   }
 
    xdrv->Base.Name = "Xlib/softpipe";
+   xdrv->Base.Unload = xlib_Unload;
 
    /* create one winsys and use it for all contexts/surfaces */
    xdrv->winsys = create_sw_winsys();
-- 
cgit v1.2.3


From 34d8c13bff05de200dbad70d0798519108e186f2 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Fri, 14 Aug 2009 18:26:26 +0800
Subject: egl: Remove eglhash.c and eglhash.h.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/glx/egl_glx.c |   1 -
 src/egl/main/Makefile         |   2 -
 src/egl/main/egldisplay.c     |   1 -
 src/egl/main/eglhash.c        | 347 ------------------------------------------
 src/egl/main/eglhash.h        |  39 -----
 src/egl/main/eglsurface.c     |   1 -
 6 files changed, 391 deletions(-)
 delete mode 100644 src/egl/main/eglhash.c
 delete mode 100644 src/egl/main/eglhash.h

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 9d80bc1a84..3c8f8b6a68 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -57,7 +57,6 @@
 #include "egldisplay.h"
 #include "egldriver.h"
 #include "eglglobals.h"
-#include "eglhash.h"
 #include "egllog.h"
 #include "eglsurface.h"
 
diff --git a/src/egl/main/Makefile b/src/egl/main/Makefile
index ab61d68f2b..15cd1d09c7 100644
--- a/src/egl/main/Makefile
+++ b/src/egl/main/Makefile
@@ -17,7 +17,6 @@ HEADERS = \
 	egldriver.h \
 	eglglobals.h \
 	egllog.h \
-	eglhash.h \
 	eglmisc.h \
 	eglmode.h \
 	eglmutex.h \
@@ -36,7 +35,6 @@ SOURCES = \
 	egldriver.c \
 	eglglobals.c \
 	egllog.c \
-	eglhash.c \
 	eglmisc.c \
 	eglmode.c \
 	eglscreen.c \
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index d79d7e3913..30a49a25ae 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -10,7 +10,6 @@
 #include "egldisplay.h"
 #include "egldriver.h"
 #include "eglglobals.h"
-#include "eglhash.h"
 #include "eglstring.h"
 #include "eglmutex.h"
 #include "egllog.h"
diff --git a/src/egl/main/eglhash.c b/src/egl/main/eglhash.c
deleted file mode 100644
index 8e3da2e906..0000000000
--- a/src/egl/main/eglhash.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/**
- * \file hash.c
- * Generic hash table. 
- *
- * This code taken from Mesa and adapted.
- */
-
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "eglhash.h"
-
-
-#define TABLE_SIZE 1023  /**< Size of lookup table/array */
-
-#define HASH_FUNC(K)  ((K) % TABLE_SIZE)
-
-
-/*
- * Unfinished mutex stuff
- */
-
-typedef int _EGLMutex;
-
-static void
-_eglInitMutex(_EGLMutex m)
-{
-}
-
-static void
-_eglDestroyMutex(_EGLMutex m)
-{
-}
-
-static void
-_eglLockMutex(_EGLMutex m)
-{
-}
-
-static void
-_eglUnlockMutex(_EGLMutex m)
-{
-}
-
-
-
-typedef struct _egl_hashentry _EGLHashentry;
-
-struct _egl_hashentry
-{
-   EGLuint Key;            /**< the entry's key */
-   void *Data;             /**< the entry's data */
-   _EGLHashentry *Next;    /**< pointer to next entry */
-};
-
-
-struct _egl_hashtable
-{
-   _EGLHashentry *Table[TABLE_SIZE];  /**< the lookup table */
-   EGLuint MaxKey;                    /**< highest key inserted so far */
-   _EGLMutex Mutex;                   /**< mutual exclusion lock */
-};
-
-
-/**
- * Create a new hash table.
- * 
- * \return pointer to a new, empty hash table.
- */
-_EGLHashtable *
-_eglNewHashTable(void)
-{
-   _EGLHashtable *table = (_EGLHashtable *) calloc(1, sizeof(_EGLHashtable));
-   if (table) {
-      _eglInitMutex(table->Mutex);
-      table->MaxKey = 1;
-   }
-   return table;
-}
-
-
-
-/**
- * Delete a hash table.
- * Frees each entry on the hash table and then the hash table structure itself.
- * Note that the caller should have already traversed the table and deleted
- * the objects in the table (i.e. We don't free the entries' data pointer).
- *
- * \param table the hash table to delete.
- */
-void
-_eglDeleteHashTable(_EGLHashtable *table)
-{
-   EGLuint i;
-   assert(table);
-   for (i = 0; i < TABLE_SIZE; i++) {
-      _EGLHashentry *entry = table->Table[i];
-      while (entry) {
-	 _EGLHashentry *next = entry->Next;
-	 free(entry);
-	 entry = next;
-      }
-   }
-   _eglDestroyMutex(table->Mutex);
-   free(table);
-}
-
-
-
-/**
- * Lookup an entry in the hash table.
- * 
- * \param table the hash table.
- * \param key the key.
- * 
- * \return pointer to user's data or NULL if key not in table
- */
-void *
-_eglHashLookup(const _EGLHashtable *table, EGLuint key)
-{
-   EGLuint pos;
-   const _EGLHashentry *entry;
-
-   assert(table);
-
-   if (!key)
-      return NULL;
-
-   pos = HASH_FUNC(key);
-   entry = table->Table[pos];
-   while (entry) {
-      if (entry->Key == key) {
-	 return entry->Data;
-      }
-      entry = entry->Next;
-   }
-   return NULL;
-}
-
-
-
-/**
- * Insert a key/pointer pair into the hash table.  
- * If an entry with this key already exists we'll replace the existing entry.
- * 
- * \param table the hash table.
- * \param key the key (not zero).
- * \param data pointer to user data.
- */
-void
-_eglHashInsert(_EGLHashtable *table, EGLuint key, void *data)
-{
-   /* search for existing entry with this key */
-   EGLuint pos;
-   _EGLHashentry *entry;
-
-   assert(table);
-   assert(key);
-
-   _eglLockMutex(table->Mutex);
-
-   if (key > table->MaxKey)
-      table->MaxKey = key;
-
-   pos = HASH_FUNC(key);
-   entry = table->Table[pos];
-   while (entry) {
-      if (entry->Key == key) {
-         /* replace entry's data */
-	 entry->Data = data;
-         _eglUnlockMutex(table->Mutex);
-	 return;
-      }
-      entry = entry->Next;
-   }
-
-   /* alloc and insert new table entry */
-   entry = (_EGLHashentry *) malloc(sizeof(_EGLHashentry));
-   entry->Key = key;
-   entry->Data = data;
-   entry->Next = table->Table[pos];
-   table->Table[pos] = entry;
-
-   _eglUnlockMutex(table->Mutex);
-}
-
-
-
-/**
- * Remove an entry from the hash table.
- * 
- * \param table the hash table.
- * \param key key of entry to remove.
- *
- * While holding the hash table's lock, searches the entry with the matching
- * key and unlinks it.
- */
-void
-_eglHashRemove(_EGLHashtable *table, EGLuint key)
-{
-   EGLuint pos;
-   _EGLHashentry *entry, *prev;
-
-   assert(table);
-   assert(key);
-
-   _eglLockMutex(table->Mutex);
-
-   pos = HASH_FUNC(key);
-   prev = NULL;
-   entry = table->Table[pos];
-   while (entry) {
-      if (entry->Key == key) {
-         /* found it! */
-         if (prev) {
-            prev->Next = entry->Next;
-         }
-         else {
-            table->Table[pos] = entry->Next;
-         }
-         free(entry);
-         _eglUnlockMutex(table->Mutex);
-	 return;
-      }
-      prev = entry;
-      entry = entry->Next;
-   }
-
-   _eglUnlockMutex(table->Mutex);
-}
-
-
-
-/**
- * Get the key of the "first" entry in the hash table.
- * 
- * This is used in the course of deleting all display lists when
- * a context is destroyed.
- * 
- * \param table the hash table
- * 
- * \return key for the "first" entry in the hash table.
- *
- * While holding the lock, walks through all table positions until finding
- * the first entry of the first non-empty one.
- */
-EGLuint
-_eglHashFirstEntry(_EGLHashtable *table)
-{
-   EGLuint pos;
-   assert(table);
-   _eglLockMutex(table->Mutex);
-   for (pos = 0; pos < TABLE_SIZE; pos++) {
-      if (table->Table[pos]) {
-         _eglUnlockMutex(table->Mutex);
-         return table->Table[pos]->Key;
-      }
-   }
-   _eglUnlockMutex(table->Mutex);
-   return 0;
-}
-
-
-/**
- * Given a hash table key, return the next key.  This is used to walk
- * over all entries in the table.  Note that the keys returned during
- * walking won't be in any particular order.
- * \return next hash key or 0 if end of table.
- */
-EGLuint
-_eglHashNextEntry(const _EGLHashtable *table, EGLuint key)
-{
-   const _EGLHashentry *entry;
-   EGLuint pos;
-
-   assert(table);
-   assert(key);
-
-   /* Find the entry with given key */
-   pos = HASH_FUNC(key);
-   entry = table->Table[pos];
-   while (entry) {
-      if (entry->Key == key) {
-         break;
-      }
-      entry = entry->Next;
-   }
-
-   if (!entry) {
-      /* the key was not found, we can't find next entry */
-      return 0;
-   }
-
-   if (entry->Next) {
-      /* return next in linked list */
-      return entry->Next->Key;
-   }
-   else {
-      /* look for next non-empty table slot */
-      pos++;
-      while (pos < TABLE_SIZE) {
-         if (table->Table[pos]) {
-            return table->Table[pos]->Key;
-         }
-         pos++;
-      }
-      return 0;
-   }
-}
-
-
-/**
- * Dump contents of hash table for debugging.
- * 
- * \param table the hash table.
- */
-void
-_eglHashPrint(const _EGLHashtable *table)
-{
-   EGLuint i;
-   assert(table);
-   for (i = 0; i < TABLE_SIZE; i++) {
-      const _EGLHashentry *entry = table->Table[i];
-      while (entry) {
-	 printf("%u %p\n", entry->Key, entry->Data);
-	 entry = entry->Next;
-      }
-   }
-}
-
-
-
-/**
- * Return a new, unused hash key.
- */
-EGLuint
-_eglHashGenKey(_EGLHashtable *table)
-{
-   EGLuint k;
-
-   _eglLockMutex(table->Mutex);
-   k = table->MaxKey;
-   table->MaxKey++;
-   _eglUnlockMutex(table->Mutex);
-   return k;
-}
-
diff --git a/src/egl/main/eglhash.h b/src/egl/main/eglhash.h
deleted file mode 100644
index 1d6db9598c..0000000000
--- a/src/egl/main/eglhash.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * \file eglhash.h
- * Generic hash table. 
- */
-
-
-#ifndef EGLHASH_INCLUDED
-#define EGLHASH_INCLUDED
-
-
-/* XXX move this? */
-typedef unsigned int EGLuint;
-
-
-typedef struct _egl_hashtable _EGLHashtable;
-
-
-extern _EGLHashtable *_eglNewHashTable(void);
-
-extern void _eglDeleteHashTable(_EGLHashtable *table);
-
-extern void *_eglHashLookup(const _EGLHashtable *table, EGLuint key);
-
-extern void _eglHashInsert(_EGLHashtable *table, EGLuint key, void *data);
-
-extern void _eglHashRemove(_EGLHashtable *table, EGLuint key);
-
-extern EGLuint _eglHashFirstEntry(_EGLHashtable *table);
-
-extern EGLuint _eglHashNextEntry(const _EGLHashtable *table, EGLuint key);
-
-extern void _eglHashPrint(const _EGLHashtable *table);
-
-extern EGLuint _eglHashGenKey(_EGLHashtable *table);
-
-extern void _egltest_hash_functions(void);
-
-
-#endif /* EGLHASH_INCLUDED */
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index adf125f88a..e7a1a8329e 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -11,7 +11,6 @@
 #include "eglconfig.h"
 #include "egldriver.h"
 #include "eglglobals.h"
-#include "eglhash.h"
 #include "egllog.h"
 #include "eglsurface.h"
 
-- 
cgit v1.2.3


From 58ac57c2b7b40b64df2a867d4b9d4e5c5bc13c47 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Sun, 16 Aug 2009 08:51:58 +0800
Subject: egl_xdri: Revive the driver.

egl_xdri does not compile for some time.  This commit revives the
driver.  It no longer depends on libGL.so for GLX related functions.
Instead, it uses code from src/glx/ directly.  Both DRI and DRI2 are
supported.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/xdri/Makefile   |   15 +-
 src/egl/drivers/xdri/driinit.c  |   67 +++
 src/egl/drivers/xdri/driinit.h  |    9 +
 src/egl/drivers/xdri/egl_xdri.c | 1054 +++++++++------------------------------
 src/egl/drivers/xdri/glxinit.c  |  626 +++++++++++++++++++++++
 src/egl/drivers/xdri/glxinit.h  |   14 +
 6 files changed, 953 insertions(+), 832 deletions(-)
 create mode 100644 src/egl/drivers/xdri/driinit.c
 create mode 100644 src/egl/drivers/xdri/driinit.h
 create mode 100644 src/egl/drivers/xdri/glxinit.c
 create mode 100644 src/egl/drivers/xdri/glxinit.h

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/Makefile b/src/egl/drivers/xdri/Makefile
index 8a14027fc7..4c1fc9071c 100644
--- a/src/egl/drivers/xdri/Makefile
+++ b/src/egl/drivers/xdri/Makefile
@@ -16,19 +16,24 @@ INCLUDE_DIRS = \
 	$(shell pkg-config --cflags-only-I libdrm) \
 	-I$(TOP)/include \
 	-I$(TOP)/include/GL/internal \
+	-I$(TOP)/src/mesa \
 	-I$(TOP)/src/mesa/glapi \
-	-I$(TOP)/src/mesa/drivers/dri/common \
 	-I$(TOP)/src/egl/main \
 	-I$(TOP)/src/glx/x11
 
-SOURCES = egl_xdri.c
+HEADERS = glxinit.h driinit.h
+SOURCES = egl_xdri.c glxinit.c driinit.c
+
+DRI_SOURCES = dri_common.c XF86dri.c dri2.c dri2_glx.c dri_glx.c
+DRI_SOURCES := $(addprefix ../../../glx/x11/,$(DRI_SOURCES))
+
+SOURCES += $(DRI_SOURCES)
 
 OBJECTS = $(SOURCES:.c=.o)
 
 DRM_LIB = `pkg-config --libs libdrm`
 
-MISC_LIBS = -ldl -lXext -lGL
-
+CFLAGS += -DGLX_DIRECT_RENDERING
 
 .c.o:
 	$(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
@@ -50,7 +55,7 @@ $(TOP)/$(LIB_DIR)/$(DRIVER_NAME): $(OBJECTS)
 		-major 1 -minor 0 \
 		-L$(TOP)/$(LIB_DIR) \
 		-install $(TOP)/$(LIB_DIR) \
-		$(OBJECTS) $(DRM_LIB) $(MISC_LIBS)
+		$(OBJECTS) $(DRM_LIB) $(GL_LIB_DEPS)
 
 install:
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
diff --git a/src/egl/drivers/xdri/driinit.c b/src/egl/drivers/xdri/driinit.c
new file mode 100644
index 0000000000..12da1bcd24
--- /dev/null
+++ b/src/egl/drivers/xdri/driinit.c
@@ -0,0 +1,67 @@
+/**
+ * DRI initialization.  The DRI loaders are defined in src/glx/x11/.
+ */
+
+#include <sys/time.h>
+
+#include "glxclient.h"
+#include "driinit.h"
+
+/* for __DRI_SYSTEM_TIME extension */
+_X_HIDDEN int
+__glXGetUST(int64_t * ust)
+{
+   struct timeval tv;
+
+   if (ust == NULL) {
+      return -EFAULT;
+   }
+
+   if (gettimeofday(&tv, NULL) == 0) {
+      ust[0] = (tv.tv_sec * 1000000) + tv.tv_usec;
+      return 0;
+   }
+   else {
+      return -errno;
+   }
+}
+
+_X_HIDDEN GLboolean
+__driGetMscRateOML(__DRIdrawable * draw,
+                   int32_t * numerator, int32_t * denominator, void *private)
+{
+   return GL_FALSE;
+}
+
+/* ignore glx extensions */
+_X_HIDDEN void
+__glXEnableDirectExtension(__GLXscreenConfigs * psc, const char *name)
+{
+}
+
+_X_HIDDEN __GLXDRIdisplay *
+__driCreateDisplay(__GLXdisplayPrivate *dpyPriv, int *version)
+{
+   __GLXDRIdisplay *driDisplay;
+   int ver = 0;
+
+   /* try DRI2 first */
+   driDisplay = dri2CreateDisplay(dpyPriv->dpy);
+   if (driDisplay) {
+      /* fill in the required field */
+      dpyPriv->dri2Display = driDisplay;
+      ver = 2;
+   }
+   else {
+      /* try DRI */
+      driDisplay = driCreateDisplay(dpyPriv->dpy);
+      if (driDisplay) {
+         dpyPriv->driDisplay = driDisplay;
+         ver = 1;
+      }
+   }
+
+   if (version)
+      *version = ver;
+   return driDisplay;
+}
diff --git a/src/egl/drivers/xdri/driinit.h b/src/egl/drivers/xdri/driinit.h
new file mode 100644
index 0000000000..6ea05cebef
--- /dev/null
+++ b/src/egl/drivers/xdri/driinit.h
@@ -0,0 +1,9 @@
+#ifndef DRIINIT_INCLUDED
+#define DRIINIT_INCLUDED
+
+#include "glxclient.h"
+
+extern __GLXDRIdisplay *
+__driCreateDisplay(__GLXdisplayPrivate *dpyPriv, int *version);
+
+#endif /* DRIINIT_INCLUDED */
diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index d8d29fcef4..518091a2d1 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -39,63 +39,40 @@
  * Authors: Brian Paul
  */
 
-
 #include <assert.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include "dlfcn.h"
+#include <stdlib.h>
 #include <X11/Xlib.h>
-#include <GL/gl.h>
-#include "xf86dri.h"
-#include "glxclient.h"
-#include "dri_util.h"
-#include "drm_sarea.h"
 
-#define _EGL_PLATFORM_X
+#include "glxinit.h"
+#include "driinit.h"
+#include "glapi/glapi.h" /* for glapi functions */
 
 #include "eglconfig.h"
 #include "eglcontext.h"
 #include "egldisplay.h"
 #include "egldriver.h"
 #include "eglglobals.h"
-#include "eglhash.h"
 #include "egllog.h"
 #include "eglsurface.h"
 
-#include <GL/gl.h>
-
-typedef void (*glGetIntegerv_t)(GLenum, GLint *);
-typedef void (*glBindTexture_t)(GLenum, GLuint);
-typedef void (*glCopyTexImage2D_t)(GLenum, GLint, GLenum, GLint, GLint,
-                                   GLint, GLint, GLint);
-
-
 #define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
 
-
 /** subclass of _EGLDriver */
 struct xdri_egl_driver
 {
    _EGLDriver Base;   /**< base class */
-
-   const char *dri_driver_name;  /**< name of DRI driver to load */
-   void *dri_driver_handle;      /**< returned by dlopen(dri_driver_name) */
-
-   __GLXdisplayPrivate *glx_priv;
+};
 
 
-   /* XXX we're not actually using these at this time: */
-   int chipset;
-   int minor;
-   int drmFD;
+/** driver data of _EGLDisplay */
+struct xdri_egl_display
+{
+   Display *dpy;
+   __GLXdisplayPrivate *dpyPriv;
+   __GLXDRIdisplay *driDisplay;
 
-   __DRIframebuffer framebuffer;
-   drm_handle_t hSAREA;
-   drmAddress pSAREA;
-   char *busID;
-   drm_magic_t magic;
+   __GLXscreenConfigs *psc;
+   EGLint scr;
 };
 
 
@@ -104,9 +81,10 @@ struct xdri_egl_context
 {
    _EGLContext Base;   /**< base class */
 
-   __DRIcontext driContext;
+   /* just enough info to create dri contexts */
+   GLXContext dummy_gc;
 
-   GLint bound_tex_object;
+   __GLXDRIcontext *driContext;
 };
 
 
@@ -115,8 +93,8 @@ struct xdri_egl_surface
 {
    _EGLSurface Base;   /**< base class */
 
-   __DRIid driDrawable;  /**< DRI surface */
-   drm_drawable_t hDrawable;
+   Drawable drawable;
+   __GLXDRIdrawable *driDrawable;
 };
 
 
@@ -131,46 +109,44 @@ struct xdri_egl_config
 
 
 /** cast wrapper */
-static struct xdri_egl_driver *
+static INLINE struct xdri_egl_driver *
 xdri_egl_driver(_EGLDriver *drv)
 {
    return (struct xdri_egl_driver *) drv;
 }
 
 
+static INLINE struct xdri_egl_display *
+lookup_display(_EGLDisplay *dpy)
+{
+   return (struct xdri_egl_display *) dpy->DriverData;
+}
+
+
 /** Map EGLSurface handle to xdri_egl_surface object */
-static struct xdri_egl_surface *
-lookup_surface(EGLSurface surf)
+static INLINE struct xdri_egl_surface *
+lookup_surface(_EGLSurface *surface)
 {
-   _EGLSurface *surface = _eglLookupSurface(surf);
    return (struct xdri_egl_surface *) surface;
 }
 
 
 /** Map EGLContext handle to xdri_egl_context object */
-static struct xdri_egl_context *
-lookup_context(EGLContext c)
+static INLINE struct xdri_egl_context *
+lookup_context(_EGLContext *context)
 {
-   _EGLContext *context = _eglLookupContext(c);
    return (struct xdri_egl_context *) context;
 }
 
-static struct xdri_egl_context *
-current_context(void)
-{
-   return (struct xdri_egl_context *) _eglGetCurrentContext();
-}
 
 /** Map EGLConfig handle to xdri_egl_config object */
-static struct xdri_egl_config *
-lookup_config(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config)
+static INLINE struct xdri_egl_config *
+lookup_config(_EGLConfig *conf)
 {
-   _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
    return (struct xdri_egl_config *) conf;
 }
 
 
-
 /** Get size of given window */
 static Status
 get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
@@ -188,22 +164,18 @@ get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
 
 /**
  * Produce a set of EGL configs.
- * Note that we get the list of GLcontextModes from the GLX library.
- * This dependency on GLX lib will be removed someday.
  */
-static void
-create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
+static EGLint
+create_configs(_EGLDisplay *disp, const __GLcontextModes *m, EGLint first_id)
 {
    static const EGLint all_apis = (EGL_OPENGL_ES_BIT |
                                    EGL_OPENGL_ES2_BIT |
                                    EGL_OPENVG_BIT |
                                    EGL_OPENGL_BIT);
-   __GLXscreenConfigs *scrn = glx_priv->screenConfigs;
-   const __GLcontextModes *m;
-   int id = 1;
+   int id = first_id;
 
-   for (m = scrn->configs; m; m = m->next) {
-      /* EGL requires double-buffered configs */
+   for (; m; m = m->next) {
+      /* add double buffered visual */
       if (m->doubleBufferMode) {
          struct xdri_egl_config *config = CALLOC_STRUCT(xdri_egl_config);
 
@@ -222,9 +194,7 @@ create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
          SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_TYPE, m->visualType);
          SET_CONFIG_ATTRIB(&config->Base, EGL_CONFORMANT, all_apis);
          SET_CONFIG_ATTRIB(&config->Base, EGL_RENDERABLE_TYPE, all_apis);
-         /* XXX only window rendering allowed ATM */
-         SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE,
-                           (EGL_WINDOW_BIT | EGL_PBUFFER_BIT));
+         SET_CONFIG_ATTRIB(&config->Base, EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
 
          /* XXX possibly other things to init... */
 
@@ -234,431 +204,76 @@ create_configs(_EGLDisplay *disp, __GLXdisplayPrivate *glx_priv)
          _eglAddConfig(disp, &config->Base);
       }
    }
-}
 
-
-/**
- * Called via __DRIinterfaceMethods object
- */
-static __DRIfuncPtr
-dri_get_proc_address(const char * proc_name)
-{
-   return NULL;
-}
-
-
-static void
-dri_context_modes_destroy(__GLcontextModes *modes)
-{
-   _eglLog(_EGL_DEBUG, "%s", __FUNCTION__);
-
-   while (modes) {
-      __GLcontextModes * const next = modes->next;
-      free(modes);
-      modes = next;
-   }
+   return id;
 }
 
 
 /**
- * Create a linked list of 'count' GLcontextModes.
- * These are used during the client/server visual negotiation phase,
- * then discarded.
+ * Called via eglInitialize(), xdri_dpy->API.Initialize().
  */
-static __GLcontextModes *
-dri_context_modes_create(unsigned count, size_t minimum_size)
-{
-   /* This code copied from libGLX, and modified */
-   const size_t size = (minimum_size > sizeof(__GLcontextModes))
-       ? minimum_size : sizeof(__GLcontextModes);
-   __GLcontextModes * head = NULL;
-   __GLcontextModes ** next;
-   unsigned   i;
-
-   next = & head;
-   for (i = 0 ; i < count ; i++) {
-      *next = (__GLcontextModes *) calloc(1, size);
-      if (*next == NULL) {
-	 dri_context_modes_destroy(head);
-	 head = NULL;
-	 break;
-      }
-      
-      (*next)->doubleBufferMode = 1;
-      (*next)->visualID = GLX_DONT_CARE;
-      (*next)->visualType = GLX_DONT_CARE;
-      (*next)->visualRating = GLX_NONE;
-      (*next)->transparentPixel = GLX_NONE;
-      (*next)->transparentRed = GLX_DONT_CARE;
-      (*next)->transparentGreen = GLX_DONT_CARE;
-      (*next)->transparentBlue = GLX_DONT_CARE;
-      (*next)->transparentAlpha = GLX_DONT_CARE;
-      (*next)->transparentIndex = GLX_DONT_CARE;
-      (*next)->xRenderable = GLX_DONT_CARE;
-      (*next)->fbconfigID = GLX_DONT_CARE;
-      (*next)->swapMethod = GLX_SWAP_UNDEFINED_OML;
-      (*next)->bindToTextureRgb = GLX_DONT_CARE;
-      (*next)->bindToTextureRgba = GLX_DONT_CARE;
-      (*next)->bindToMipmapTexture = GLX_DONT_CARE;
-      (*next)->bindToTextureTargets = 0;
-      (*next)->yInverted = GLX_DONT_CARE;
-
-      next = & ((*next)->next);
-   }
-
-   return head;
-}
-
-
-static __DRIscreen *
-dri_find_dri_screen(__DRInativeDisplay *ndpy, int scrn)
-{
-   __GLXdisplayPrivate *priv = __glXInitialize(ndpy);
-   __GLXscreenConfigs *scrnConf = priv->screenConfigs;
-   return &scrnConf->driScreen;
-}
-
-
-static GLboolean
-dri_window_exists(__DRInativeDisplay *ndpy, __DRIid draw)
-{
-   return EGL_TRUE;
-}
-
-
-static GLboolean
-dri_create_context(__DRInativeDisplay *ndpy, int screenNum, int configID,
-                   void * contextID, drm_context_t * hw_context)
-{
-   assert(configID >= 0);
-   return XF86DRICreateContextWithConfig(ndpy, screenNum,
-                                         configID, contextID, hw_context);
-}
-
-
-static GLboolean
-dri_destroy_context(__DRInativeDisplay * ndpy, int screen, __DRIid context)
-{
-   return XF86DRIDestroyContext(ndpy, screen, context);
-}
-
-
-static GLboolean
-dri_create_drawable(__DRInativeDisplay * ndpy, int screen,
-                    __DRIid drawable, drm_drawable_t * hHWDrawable)
-{
-   _eglLog(_EGL_DEBUG, "XDRI: %s", __FUNCTION__);
-
-   /* Create DRI drawable for given window ID (drawable) */
-   if (!XF86DRICreateDrawable(ndpy, screen, drawable, hHWDrawable))
-      return EGL_FALSE;
-
-   return EGL_TRUE;
-}
-
-
-static GLboolean
-dri_destroy_drawable(__DRInativeDisplay * ndpy, int screen, __DRIid drawable)
-{
-   _eglLog(_EGL_DEBUG, "XDRI: %s", __FUNCTION__);
-   return XF86DRIDestroyDrawable(ndpy, screen, drawable);
-}
-
-
-static GLboolean
-dri_get_drawable_info(__DRInativeDisplay *ndpy, int scrn,
-                      __DRIid draw, unsigned int * index, unsigned int * stamp,
-                      int * x, int * y, int * width, int * height,
-                      int * numClipRects, drm_clip_rect_t ** pClipRects,
-                      int * backX, int * backY,
-                      int * numBackClipRects,
-                      drm_clip_rect_t ** pBackClipRects)
-{
-   _eglLog(_EGL_DEBUG, "XDRI: %s", __FUNCTION__);
-
-   if (!XF86DRIGetDrawableInfo(ndpy, scrn, draw, index, stamp,
-                               x, y, width, height,
-                               numClipRects, pClipRects,
-                               backX, backY,
-                               numBackClipRects, pBackClipRects)) {
-      return EGL_FALSE;
-   }
-
-   return EGL_TRUE;
-}
-
-
-/**
- * Table of functions exported by the loader to the driver.
- */
-static const __DRIinterfaceMethods interface_methods = {
-   dri_get_proc_address,
-
-   dri_context_modes_create,
-   dri_context_modes_destroy,
-
-   dri_find_dri_screen,
-   dri_window_exists,
-
-   dri_create_context,
-   dri_destroy_context,
-
-   dri_create_drawable,
-   dri_destroy_drawable,
-   dri_get_drawable_info,
-
-   NULL,/*__eglGetUST,*/
-   NULL,/*__eglGetMSCRate,*/
-};
-
-
-
 static EGLBoolean
-init_drm(struct xdri_egl_driver *xdri_drv, _EGLDisplay *disp)
+xdri_eglInitialize(_EGLDriver *drv, _EGLDisplay *dpy,
+                   EGLint *minor, EGLint *major)
 {
-   __DRIversion ddx_version;
-   __DRIversion dri_version;
-   __DRIversion drm_version;
-   drmVersionPtr version;
-   drm_handle_t  hFB;
-   int newlyopened;
-   int status;
-   int scrn = DefaultScreen(disp->Xdpy);
-
-#if 0
-   createNewScreen = (PFNCREATENEWSCREENFUNC)
-      dlsym(xdri_drv->dri_driver_handle, createNewScreenName);
-   if (!createNewScreen) {
-      _eglLog(_EGL_WARNING, "XDRI: Couldn't find %s function in the driver.",
-              createNewScreenName);
-      return EGL_FALSE;
-   }
-   else {
-      _eglLog(_EGL_DEBUG, "XDRI: Found %s", createNewScreenName);
-   }
-#endif
-
-   /*
-    * Get the DRI X extension version.
-    */
-   dri_version.major = 4;
-   dri_version.minor = 0;
-   dri_version.patch = 0;
-
-   if (!XF86DRIOpenConnection(disp->Xdpy, scrn,
-                              &xdri_drv->hSAREA, &xdri_drv->busID)) {
-      _eglLog(_EGL_WARNING, "XF86DRIOpenConnection failed");
-   }
-
-   xdri_drv->drmFD = drmOpenOnce(NULL, xdri_drv->busID, &newlyopened);
-   if (xdri_drv->drmFD < 0) {
-      perror("drmOpenOnce failed: ");
-      return EGL_FALSE;
-   }
-   else {
-      _eglLog(_EGL_DEBUG, "XDRI: drmOpenOnce returned %d", xdri_drv->drmFD);
-   }
-
-
-   if (drmGetMagic(xdri_drv->drmFD, &xdri_drv->magic)) {
-      perror("drmGetMagic failed: ");
-      return EGL_FALSE;
-   }
-
-   version = drmGetVersion(xdri_drv->drmFD);
-   if (version) {
-      drm_version.major = version->version_major;
-      drm_version.minor = version->version_minor;
-      drm_version.patch = version->version_patchlevel;
-      drmFreeVersion(version);
-      _eglLog(_EGL_DEBUG, "XDRI: Got DRM version %d.%d.%d",
-              drm_version.major,
-              drm_version.minor,
-              drm_version.patch);
-   }
-   else {
-      drm_version.major = -1;
-      drm_version.minor = -1;
-      drm_version.patch = -1;
-      _eglLog(_EGL_WARNING, "XDRI: drmGetVersion() failed");
-      return EGL_FALSE;
-   }
-
-   /* Authenticate w/ server.
-    */
-   if (!XF86DRIAuthConnection(disp->Xdpy, scrn, xdri_drv->magic)) {
-      _eglLog(_EGL_WARNING, "XDRI: XF86DRIAuthConnection() failed");
-      return EGL_FALSE;
-   }
-   else {
-      _eglLog(_EGL_DEBUG, "XDRI: XF86DRIAuthConnection() success");
-   }
-
-   /* Get ddx version.
-    */
-   {
-      char *driverName;
-
-      /*
-       * Get device name (like "tdfx") and the ddx version
-       * numbers.  We'll check the version in each DRI driver's
-       * "createNewScreen" function.
-       */
-      if (!XF86DRIGetClientDriverName(disp->Xdpy, scrn,
-                                     &ddx_version.major,
-                                     &ddx_version.minor,
-                                     &ddx_version.patch,
-                                     &driverName)) {
-         _eglLog(_EGL_WARNING, "XDRI: XF86DRIGetClientDriverName failed");
-         return EGL_FALSE;
-      }
-      else {
-         _eglLog(_EGL_DEBUG, "XDRI: XF86DRIGetClientDriverName returned %s", driverName);
-      }
-   }
-
-   /* Get framebuffer info.
-    */
-   {
-      int junk;
-      if (!XF86DRIGetDeviceInfo(disp->Xdpy, scrn,
-                                &hFB,
-                                &junk,
-                                &xdri_drv->framebuffer.size,
-                                &xdri_drv->framebuffer.stride,
-                                &xdri_drv->framebuffer.dev_priv_size,
-                                &xdri_drv->framebuffer.dev_priv)) {
-         _eglLog(_EGL_WARNING, "XDRI: XF86DRIGetDeviceInfo() failed");
-         return EGL_FALSE;
+   struct xdri_egl_display *xdri_dpy;
+   __GLXdisplayPrivate *dpyPriv;
+   __GLXDRIdisplay *driDisplay;
+   __GLXscreenConfigs *psc;
+   EGLint first_id = 1;
+   int scr;
+
+   xdri_dpy = CALLOC_STRUCT(xdri_egl_display);
+   if (!xdri_dpy)
+      return _eglError(EGL_BAD_ALLOC, "eglInitialize");
+
+   xdri_dpy->dpy = (Display *) dpy->NativeDisplay;
+   if (!xdri_dpy->dpy) {
+      xdri_dpy->dpy = XOpenDisplay(NULL);
+      if (!xdri_dpy->dpy) {
+         free(xdri_dpy);
+         return _eglError(EGL_NOT_INITIALIZED, "eglInitialize");
       }
-      else {
-         _eglLog(_EGL_DEBUG, "XDRI: XF86DRIGetDeviceInfo() success");
-      }
-      xdri_drv->framebuffer.width = DisplayWidth(disp->Xdpy, scrn);
-      xdri_drv->framebuffer.height = DisplayHeight(disp->Xdpy, scrn);
-   }
-
-   /* Map the framebuffer region. (this may not be needed)
-    */
-   status = drmMap(xdri_drv->drmFD, hFB, xdri_drv->framebuffer.size, 
-                   (drmAddressPtr) &xdri_drv->framebuffer.base);
-   if (status != 0) {
-      _eglLog(_EGL_WARNING, "XDRI: drmMap(framebuffer) failed");
-      return EGL_FALSE;
-   }
-   else {
-      _eglLog(_EGL_DEBUG, "XDRI: drmMap(framebuffer) success");
    }
 
-   /* Map the SAREA region.
-    */
-   status = drmMap(xdri_drv->drmFD, xdri_drv->hSAREA, SAREA_MAX, &xdri_drv->pSAREA);
-   if (status != 0) {
-      _eglLog(_EGL_WARNING, "XDRI: drmMap(sarea) failed");
-      return EGL_FALSE;
-   }
-   else {
-      _eglLog(_EGL_DEBUG, "XDRI: drmMap(sarea) success");
-   }
-
-   return EGL_TRUE;
-}
-
-
-/**
- * Load the DRI driver named by "xdri_drv->dri_driver_name".
- * Basically, dlopen() the library to set "xdri_drv->dri_driver_handle".
- *
- * Later, we'll call dlsym(createNewScreenName) to get a pointer to
- * the driver's createNewScreen() function which is the bootstrap function.
- *
- * \return EGL_TRUE for success, EGL_FALSE for failure
- */
-static EGLBoolean
-load_dri_driver(struct xdri_egl_driver *xdri_drv)
-{
-   char filename[100];
-   int flags = RTLD_NOW;
-
-   /* try "egl_xxx_dri.so" first */
-   snprintf(filename, sizeof(filename), "egl_%s.so", xdri_drv->dri_driver_name);
-   _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s)", filename);
-   xdri_drv->dri_driver_handle = dlopen(filename, flags);
-   if (xdri_drv->dri_driver_handle) {
-      _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s) OK", filename);
-      return EGL_TRUE;
-   }
-   else {
-      _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s) fail (%s)", filename, dlerror());
+   dpyPriv = __glXInitialize(xdri_dpy->dpy);
+   if (!dpyPriv) {
+      _eglLog(_EGL_WARNING, "failed to create GLX display");
+      free(xdri_dpy);
+      return _eglError(EGL_NOT_INITIALIZED, "eglInitialize");
    }
 
-   /* try regular "xxx_dri.so" next */
-   snprintf(filename, sizeof(filename), "%s.so", xdri_drv->dri_driver_name);
-   _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s)", filename);
-   xdri_drv->dri_driver_handle = dlopen(filename, flags);
-   if (xdri_drv->dri_driver_handle) {
-      _eglLog(_EGL_DEBUG, "XDRI: dlopen(%s) OK", filename);
-      return EGL_TRUE;
+   driDisplay = __driCreateDisplay(dpyPriv, NULL);
+   if (!driDisplay) {
+      _eglLog(_EGL_WARNING, "failed to create DRI display");
+      free(xdri_dpy);
+      return _eglError(EGL_NOT_INITIALIZED, "eglInitialize");
    }
 
-   _eglLog(_EGL_WARNING, "XDRI Could not open %s (%s)", filename, dlerror());
-   return EGL_FALSE;
-}
-
-
-/**
- * Called via eglInitialize(), xdri_drv->API.Initialize().
- */
-static EGLBoolean
-xdri_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
-                   EGLint *minor, EGLint *major)
-{
-   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   static char name[100];
+   scr = DefaultScreen(xdri_dpy->dpy);
+   psc = &dpyPriv->screenConfigs[scr];
 
-   _eglLog(_EGL_DEBUG, "XDRI: eglInitialize");
+   xdri_dpy->dpyPriv = dpyPriv;
+   xdri_dpy->driDisplay = driDisplay;
+   xdri_dpy->psc = psc;
+   xdri_dpy->scr = scr;
 
-   if (!disp->Xdpy) {
-      disp->Xdpy = XOpenDisplay(NULL);
-      if (!disp->Xdpy) {
-         _eglLog(_EGL_WARNING, "XDRI: XOpenDisplay failed");
-         return EGL_FALSE;
-      }
+   psc->driScreen = driDisplay->createScreen(psc, scr, dpyPriv);
+   if (!psc->driScreen) {
+      _eglLog(_EGL_WARNING, "failed to create DRI screen #%d", scr);
+      free(xdri_dpy);
+      return _eglError(EGL_NOT_INITIALIZED, "eglInitialize");
    }
 
-#if 0
-   /* choose the DRI driver to load */
-   xdri_drv->dri_driver_name = _eglChooseDRMDriver(0);
-   if (!load_dri_driver(xdri_drv))
-      return EGL_FALSE;
-#else
-   (void) load_dri_driver;
-#endif
-
-#if 0
-   if (!init_drm(xdri_drv, disp))
-      return EGL_FALSE;
-#else
-   (void) init_drm;
-#endif
-
-   /*
-    * NOTE: this call to __glXInitialize() bootstraps the whole GLX/DRI
-    * interface, loads the DRI driver, etc.
-    * This replaces the load_dri_driver()  and init_drm() code above.
-    */
-   xdri_drv->glx_priv = __glXInitialize(disp->Xdpy);
-
-   create_configs(disp, xdri_drv->glx_priv);
-
-   xdri_drv->Base.Initialized = EGL_TRUE;
+   /* add visuals and fbconfigs */
+   first_id = create_configs(dpy, psc->visuals, first_id);
+   create_configs(dpy, psc->configs, first_id);
 
-   if (xdri_drv->dri_driver_name)
-      snprintf(name, sizeof(name), "X/DRI:%s", xdri_drv->dri_driver_name);
-   else
-      snprintf(name, sizeof(name), "X/DRI");
-   xdri_drv->Base.Name = name;
+   dpy->DriverData = xdri_dpy;
+   dpy->ClientAPIsMask = (EGL_OPENGL_BIT |
+                          EGL_OPENGL_ES_BIT |
+                          EGL_OPENGL_ES2_BIT |
+                          EGL_OPENVG_BIT);
 
    /* we're supporting EGL 1.4 */
    *minor = 1;
@@ -668,57 +283,37 @@ xdri_eglInitialize(_EGLDriver *drv, EGLDisplay dpy,
 }
 
 
-/*
- * Do some clean-up that normally occurs in XCloseDisplay().
- * We do this here because we're about to unload a dynamic library
- * that has added some per-display extension data and callbacks.
- * If we don't do this here we'll crash in XCloseDisplay() because it'll
- * try to call functions that went away when the driver library was unloaded.
- */
-static void
-FreeDisplayExt(Display *dpy)
-{
-   _XExtension *ext, *next;
-
-   for (ext = dpy->ext_procs; ext; ext = next) {
-      next = ext->next;
-      if (ext->close_display) {
-         ext->close_display(dpy, &ext->codes);
-         ext->close_display = NULL;
-      }
-      if (ext->name)
-         Xfree(ext->name);
-      Xfree(ext);
-   }
-   dpy->ext_procs = NULL;
-
-   _XFreeExtData (dpy->ext_data);
-   dpy->ext_data = NULL;
-}
-
-
 /**
  * Called via eglTerminate(), drv->API.Terminate().
  */
 static EGLBoolean
-xdri_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
+xdri_eglTerminate(_EGLDriver *drv, _EGLDisplay *dpy)
 {
-   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
+   __GLXscreenConfigs *psc;
 
-   _eglLog(_EGL_DEBUG, "XDRI: eglTerminate");
+   _eglReleaseDisplayResources(drv, dpy);
+   _eglCleanupDisplay(dpy);
 
-   _eglLog(_EGL_DEBUG, "XDRI: Closing %s", xdri_drv->dri_driver_name);
-
-   FreeDisplayExt(disp->Xdpy);
+   psc = xdri_dpy->psc;
+   if (psc->driver_configs) {
+      unsigned int i;
+      for (i = 0; psc->driver_configs[i]; i++)
+         free((__DRIconfig *) psc->driver_configs[i]);
+      free(psc->driver_configs);
+      psc->driver_configs = NULL;
+   }
+   if (psc->driScreen) {
+      psc->driScreen->destroyScreen(psc);
+      free(psc->driScreen);
+      psc->driScreen = NULL;
+   }
 
-#if 0
-   /* this causes a segfault for some reason */
-   dlclose(xdri_drv->dri_driver_handle);
-#endif
-   xdri_drv->dri_driver_handle = NULL;
+   xdri_dpy->driDisplay->destroyDisplay(xdri_dpy->driDisplay);
+   __glXRelease(xdri_dpy->dpyPriv);
 
-   free((void*) xdri_drv->dri_driver_name);
+   free(xdri_dpy);
+   dpy->DriverData = NULL;
 
    return EGL_TRUE;
 }
@@ -730,71 +325,77 @@ xdri_eglTerminate(_EGLDriver *drv, EGLDisplay dpy)
 static _EGLProc
 xdri_eglGetProcAddress(const char *procname)
 {
-#if 0
-   _EGLDriver *drv = NULL;
-
-   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-   /*_EGLDisplay *disp = _eglLookupDisplay(dpy);*/
-   _EGLProc *proc = xdri_drv->driScreen.getProcAddress(procname);
-   return proc;
-#elif 1
-   /* This is a bit of a hack to get at the gallium/Mesa state tracker
-    * function st_get_proc_address().  This will probably change at
-    * some point.
-    */
-   _EGLProc (*st_get_proc_addr)(const char *procname);
-   st_get_proc_addr = dlsym(NULL, "st_get_proc_address");
-   if (st_get_proc_addr) {
-      return st_get_proc_addr(procname);
-   }
-   return NULL;   
-#else
-   return NULL;
-#endif
+   /* the symbol is defined in libGL.so */
+   return (_EGLProc) _glapi_get_proc_address(procname);
 }
 
 
 /**
  * Called via eglCreateContext(), drv->API.CreateContext().
  */
-static EGLContext
-xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
-                      EGLContext share_list, const EGLint *attrib_list)
-{
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   struct xdri_egl_config *xdri_config = lookup_config(drv, dpy, config);
-   void *shared = NULL;
+static _EGLContext *
+xdri_eglCreateContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+                      _EGLContext *share_list, const EGLint *attrib_list)
+{
+   struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
+   struct xdri_egl_config *xdri_config = lookup_config(conf);
+   struct xdri_egl_context *shared = lookup_context(share_list);
+   __GLXscreenConfigs *psc = xdri_dpy->psc;
    int renderType = GLX_RGBA_BIT;
+   struct xdri_egl_context *xdri_ctx;
 
-   struct xdri_egl_context *xdri_ctx = CALLOC_STRUCT(xdri_egl_context);
-   if (!xdri_ctx)
-      return EGL_NO_CONTEXT;
+   xdri_ctx = CALLOC_STRUCT(xdri_egl_context);
+   if (!xdri_ctx) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateContext");
+      return NULL;
+   }
 
-   if (!_eglInitContext(drv, &xdri_ctx->Base, &xdri_config->Base, attrib_list)) {
+   xdri_ctx->dummy_gc = CALLOC_STRUCT(__GLXcontextRec);
+   if (!xdri_ctx->dummy_gc) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateContext");
       free(xdri_ctx);
-      return EGL_NO_CONTEXT;
+      return NULL;
    }
 
-   assert(xdri_config);
-
-   {
-      struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-      __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
-      xdri_ctx->driContext.private = 
-         scrnConf->driScreen.createNewContext(disp->Xdpy,
-                                              xdri_config->mode, renderType,
-                                              shared, &xdri_ctx->driContext);
+   if (!_eglInitContext(drv, &xdri_ctx->Base, &xdri_config->Base, attrib_list)) {
+      free(xdri_ctx->dummy_gc);
+      free(xdri_ctx);
+      return NULL;
    }
 
-   if (!xdri_ctx->driContext.private) {
-      _eglLog(_EGL_DEBUG, "driScreen.createNewContext failed");
+   xdri_ctx->driContext =
+      psc->driScreen->createContext(psc,
+                                    xdri_config->mode,
+                                    xdri_ctx->dummy_gc,
+                                    (shared) ? shared->dummy_gc : NULL,
+                                    renderType);
+   if (!xdri_ctx->driContext) {
+      free(xdri_ctx->dummy_gc);
       free(xdri_ctx);
-      return EGL_NO_CONTEXT;
+      return NULL;
    }
 
-   xdri_ctx->driContext.mode = xdri_config->mode;
+   /* fill in the required field */
+   xdri_ctx->dummy_gc->driContext = xdri_ctx->driContext;
 
-   return _eglLinkContext(&xdri_ctx->Base, &disp);
+   return &xdri_ctx->Base;
+}
+
+
+static EGLBoolean
+xdri_eglDestroyContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
+{
+   struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
+   struct xdri_egl_context *xdri_ctx = lookup_context(ctx);
+
+   if (!_eglIsContextBound(ctx)) {
+      xdri_ctx->driContext->destroyContext(xdri_ctx->driContext,
+                                           xdri_dpy->psc, xdri_dpy->dpy);
+      free(xdri_ctx->dummy_gc);
+      free(xdri_ctx);
+   }
+
+   return EGL_TRUE;
 }
 
 
@@ -802,25 +403,32 @@ xdri_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
  */
 static EGLBoolean
-xdri_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
-                    EGLSurface r, EGLContext context)
+xdri_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *d,
+                    _EGLSurface *r, _EGLContext *context)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
    struct xdri_egl_context *xdri_ctx = lookup_context(context);
-   struct xdri_egl_surface *xdri_draw = lookup_surface(d);
-   struct xdri_egl_surface *xdri_read = lookup_surface(r);
-   __DRIid draw = xdri_draw ? xdri_draw->driDrawable : 0;
-   __DRIid read = xdri_read ? xdri_read->driDrawable : 0;
-   int scrn = DefaultScreen(disp->Xdpy);
+   struct xdri_egl_surface *draw = lookup_surface(d);
+   struct xdri_egl_surface *read = lookup_surface(r);
 
    if (!_eglMakeCurrent(drv, dpy, d, r, context))
       return EGL_FALSE;
 
+   /* the symbol is defined in libGL.so */
+   _glapi_check_multithread();
 
-   if (xdri_ctx &&
-       !xdri_ctx->driContext.bindContext(disp->Xdpy, scrn, draw, read,
-                                         &xdri_ctx->driContext)) {
-      return EGL_FALSE;
+   if (xdri_ctx) {
+      if (!xdri_ctx->driContext->bindContext(xdri_ctx->driContext,
+                                             draw->driDrawable,
+                                             read->driDrawable)) {
+         return EGL_FALSE;
+      }
+   }
+   else {
+      _EGLContext *old = _eglGetCurrentContext();
+      if (old) {
+         xdri_ctx = lookup_context(old);
+         xdri_ctx->driContext->unbindContext(xdri_ctx->driContext);
+      }
    }
 
    return EGL_TRUE;
@@ -830,307 +438,106 @@ xdri_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
 /**
  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
  */
-static EGLSurface
-xdri_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+static _EGLSurface *
+xdri_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                             NativeWindowType window, const EGLint *attrib_list)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   struct xdri_egl_config *xdri_config = lookup_config(drv, dpy, config);
+   struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
+   struct xdri_egl_config *xdri_config = lookup_config(conf);
    struct xdri_egl_surface *xdri_surf;
-   int scrn = DefaultScreen(disp->Xdpy);
    uint width, height;
 
    xdri_surf = CALLOC_STRUCT(xdri_egl_surface);
-   if (!xdri_surf)
-      return EGL_NO_SURFACE;
+   if (!xdri_surf) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateWindowSurface");
+      return NULL;
+   }
 
    if (!_eglInitSurface(drv, &xdri_surf->Base, EGL_WINDOW_BIT,
                         &xdri_config->Base, attrib_list)) {
       free(xdri_surf);
-      return EGL_FALSE;
+      return NULL;
    }
 
-   if (!XF86DRICreateDrawable(disp->Xdpy, scrn, window, &xdri_surf->hDrawable)) {
+   xdri_surf->driDrawable =
+      xdri_dpy->psc->driScreen->createDrawable(xdri_dpy->psc,
+                                               (XID) window,
+                                               (GLXDrawable) window,
+                                               xdri_config->mode);
+   if (!xdri_surf->driDrawable) {
       free(xdri_surf);
-      return EGL_FALSE;
+      return NULL;
    }
 
-   xdri_surf->driDrawable = window;
+   xdri_surf->drawable = (Drawable) window;
 
-   _eglLinkSurface(&xdri_surf->Base, disp);
-
-   get_drawable_size(disp->Xdpy, window, &width, &height);
+   get_drawable_size(xdri_dpy->dpy, window, &width, &height);
    xdri_surf->Base.Width = width;
    xdri_surf->Base.Height = height;
 
-   _eglLog(_EGL_DEBUG,
-           "XDRI: CreateWindowSurface win 0x%x  handle %d  hDrawable %d",
-           (int) window, _eglGetSurfaceHandle(&xdri_surf->Base),
-           (int) xdri_surf->hDrawable);
-
-   return _eglGetSurfaceHandle(&xdri_surf->Base);
+   return &xdri_surf->Base;
 }
 
 
 /**
  * Called via eglCreatePbufferSurface(), drv->API.CreatePbufferSurface().
  */
-static EGLSurface
-xdri_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+static _EGLSurface *
+xdri_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
                              const EGLint *attrib_list)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-   struct xdri_egl_surface *xdri_surf;
-   struct xdri_egl_config *xdri_config = lookup_config(drv, dpy, config);
-   int scrn = DefaultScreen(disp->Xdpy);
-   Window window;
-
-   xdri_surf = CALLOC_STRUCT(xdri_egl_surface);
-   if (!xdri_surf)
-      return EGL_NO_SURFACE;
-
-   if (!_eglInitSurface(drv, &xdri_surf->Base, EGL_PBUFFER_BIT,
-                        &xdri_config->Base, attrib_list)) {
-      free(xdri_surf);
-      return EGL_FALSE;
-   }
-
-   /* Create a dummy X window */
-   {
-      Window root = RootWindow(disp->Xdpy, scrn);
-      XSetWindowAttributes attr;
-      XVisualInfo *visInfo, visTemplate;
-      unsigned mask;
-      int nvis;
-
-      visTemplate.visualid = xdri_config->mode->visualID;
-      visInfo = XGetVisualInfo(disp->Xdpy, VisualIDMask, &visTemplate, &nvis);
-      if (!visInfo) {
-         return EGL_NO_SURFACE;
-      }
-
-      attr.background_pixel = 0;
-      attr.border_pixel = 0;
-      attr.colormap = XCreateColormap(disp->Xdpy, root,
-                                      visInfo->visual, AllocNone);
-      attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
-      mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
-      
-      window = XCreateWindow(disp->Xdpy, root, 0, 0,
-                             xdri_surf->Base.Width, xdri_surf->Base.Height,
-                             0, visInfo->depth, InputOutput,
-                             visInfo->visual, mask, &attr);
-
-      /*XMapWindow(disp->Xdpy, window);*/
-      XFree(visInfo);
-
-      /* set hints and properties */
-      /*
-      sizehints.width = xdri_surf->Base.Width;
-      sizehints.height = xdri_surf->Base.Height;
-      sizehints.flags = USPosition;
-      XSetNormalHints(disp->Xdpy, window, &sizehints);
-      */
-   }
-
-   if (!XF86DRICreateDrawable(disp->Xdpy, scrn, window, &xdri_surf->hDrawable)) {
-      free(xdri_surf);
-      return EGL_FALSE;
-   }
-
-   xdri_surf->driDrawable = window;
-
-   _eglLinkSurface(&xdri_surf->Base, disp);
-
-   _eglLog(_EGL_DEBUG,
-           "XDRI: CreatePbufferSurface handle %d  hDrawable %d",
-           _eglGetSurfaceHandle(&xdri_surf->Base),
-           (int) xdri_surf->hDrawable);
-
-   return _eglGetSurfaceHandle(&xdri_surf->Base);
+   return NULL;
 }
 
 
 
 static EGLBoolean
-xdri_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
+xdri_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface)
 {
    struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
-   if (xdri_surf) {
-      _eglUnlinkSurface(&xdri_surf->Base);
-      if (!_eglIsSurfaceBound(&xdri_surf->Base)) {
-         /*
-         st_unreference_framebuffer(surf->Framebuffer);
-         */
-         free(xdri_surf);
-      }
-      return EGL_TRUE;
-   }
-   else {
-      _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
-      return EGL_FALSE;
+
+   if (!_eglIsSurfaceBound(&xdri_surf->Base)) {
+      xdri_surf->driDrawable->destroyDrawable(xdri_surf->driDrawable);
+      free(xdri_surf);
    }
+
+   return EGL_TRUE;
 }
 
 
 static EGLBoolean
-xdri_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+xdri_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
                      EGLint buffer)
 {
-   typedef int (*bind_teximage)(__DRInativeDisplay *dpy,
-                                __DRIid surface, __DRIscreen *psc,
-                                int buffer, int target, int format,
-                                int level, int mipmap);
-
-   bind_teximage egl_dri_bind_teximage;
-
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-
-   struct xdri_egl_context *xdri_ctx = current_context();
-   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-   struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
-
-   __DRIid dri_surf = xdri_surf ? xdri_surf->driDrawable : 0;
-
-   __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
-   __DRIscreen *psc = &scrnConf->driScreen;
-
-   /* this call just does error checking */
-   if (!_eglBindTexImage(drv, dpy, surface, buffer)) {
-      return EGL_FALSE;
-   }
-
-   egl_dri_bind_teximage =
-      (bind_teximage) dlsym(NULL, "egl_dri_bind_teximage");
-   if (egl_dri_bind_teximage) {
-      return egl_dri_bind_teximage(disp->Xdpy, dri_surf, psc,
-                                   buffer,
-                                   xdri_surf->Base.TextureTarget,
-                                   xdri_surf->Base.TextureFormat,
-                                   xdri_surf->Base.MipmapLevel,
-                                   xdri_surf->Base.MipmapTexture);
-   }
-   else {
-      /* fallback path based on glCopyTexImage() */
-      /* Get/save currently bound 2D texobj name */
-      glGetIntegerv_t glGetIntegerv_func = 
-         (glGetIntegerv_t) dlsym(NULL, "glGetIntegerv");
-      GLint curTexObj = 0;
-      if (glGetIntegerv_func) {
-         (*glGetIntegerv_func)(GL_TEXTURE_BINDING_2D, &curTexObj);
-      }
-      xdri_ctx->bound_tex_object = curTexObj;
-   }
-
    return EGL_FALSE;
 }
 
 
 static EGLBoolean
-xdri_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+xdri_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
                         EGLint buffer)
 {
-   typedef int (*release_teximage)(__DRInativeDisplay *dpy,
-                                   __DRIid surface, __DRIscreen *psc,
-                                   int buffer, int target, int format,
-                                   int level, int mipmap);
-   release_teximage egl_dri_release_teximage;
-
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
-
-   struct xdri_egl_context *xdri_ctx = current_context();
-   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-   struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
-
-   __DRIid dri_surf = xdri_surf ? xdri_surf->driDrawable : 0;
-
-   __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
-   __DRIscreen *psc = &scrnConf->driScreen;
-
-   /* this call just does error checking */
-   if (!_eglReleaseTexImage(drv, dpy, surface, buffer)) {
-      return EGL_FALSE;
-   }
-
-   egl_dri_release_teximage =
-      (release_teximage) dlsym(NULL, "egl_dri_release_teximage");
-   if (egl_dri_release_teximage) {
-      return egl_dri_release_teximage(disp->Xdpy, dri_surf, psc,
-                                      buffer,
-                                      xdri_surf->Base.TextureTarget,
-                                      xdri_surf->Base.TextureFormat,
-                                      xdri_surf->Base.MipmapLevel,
-                                      xdri_surf->Base.MipmapTexture);
-   }
-   else {
-      /* fallback path based on glCopyTexImage() */
-      glGetIntegerv_t glGetIntegerv_func = 
-         (glGetIntegerv_t) dlsym(NULL, "glGetIntegerv");
-      glBindTexture_t glBindTexture_func = 
-         (glBindTexture_t) dlsym(NULL, "glBindTexture");
-      glCopyTexImage2D_t glCopyTexImage2D_func = 
-         (glCopyTexImage2D_t) dlsym(NULL, "glCopyTexImage2D");
-      GLint curTexObj;
-      GLenum intFormat;
-      GLint level, width, height;
-
-      if (xdri_surf->Base.TextureFormat == EGL_TEXTURE_RGBA)
-         intFormat = GL_RGBA;
-      else
-         intFormat = GL_RGB;
-      level = xdri_surf->Base.MipmapLevel;
-      width = xdri_surf->Base.Width >> level;
-      height = xdri_surf->Base.Height >> level;
-
-      if (width > 0 && height > 0 &&
-          glGetIntegerv_func && glBindTexture_func && glCopyTexImage2D_func) {
-         glGetIntegerv_func(GL_TEXTURE_BINDING_2D, &curTexObj);
-         /* restore texobj from time of eglBindTexImage() call */
-         if (curTexObj != xdri_ctx->bound_tex_object)
-            glBindTexture_func(GL_TEXTURE_2D, xdri_ctx->bound_tex_object);
-         /* copy pbuffer image to texture */
-         glCopyTexImage2D_func(GL_TEXTURE_2D,
-                               level,
-                               intFormat,
-                               0, 0, width, height, 0);
-         /* restore current texture */
-         if (curTexObj != xdri_ctx->bound_tex_object)
-            glBindTexture_func(GL_TEXTURE_2D, curTexObj);
-      }
-      xdri_ctx->bound_tex_object = -1;
-   }
-
    return EGL_FALSE;
 }
 
 
 static EGLBoolean
-xdri_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
+xdri_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw)
 {
-   _EGLDisplay *disp = _eglLookupDisplay(dpy);
+   struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
+   struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
 
-   _eglLog(_EGL_DEBUG, "XDRI: EGL SwapBuffers");
+   xdri_dpy->psc->driScreen->swapBuffers(xdri_surf->driDrawable);
 
-   /* error checking step: */
-   if (!_eglSwapBuffers(drv, dpy, draw))
-      return EGL_FALSE;
+   return EGL_TRUE;
+}
 
-   {
-      struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
-      struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
-      __GLXscreenConfigs *scrnConf = xdri_drv->glx_priv->screenConfigs;
-      __DRIscreen *psc = &scrnConf->driScreen;
-      __DRIdrawable * const pdraw = psc->getDrawable(disp->Xdpy,
-                                                     xdri_surf->driDrawable,
-                                                     psc->private);
-
-      if (pdraw)
-         pdraw->swapBuffers(disp->Xdpy, pdraw->private);
-      else
-         _eglLog(_EGL_WARNING, "pdraw is null in SwapBuffers");
-   }
 
-   return EGL_TRUE;
+static void
+xdri_Unload(_EGLDriver *drv)
+{
+   struct xdri_egl_driver *xdri_drv = xdri_egl_driver(drv);
+   free(xdri_drv);
 }
 
 
@@ -1139,15 +546,12 @@ xdri_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
  * Create a new _EGLDriver object and init its dispatch table.
  */
 _EGLDriver *
-_eglMain(_EGLDisplay *disp, const char *args)
+_eglMain(const char *args)
 {
    struct xdri_egl_driver *xdri_drv = CALLOC_STRUCT(xdri_egl_driver);
    if (!xdri_drv)
       return NULL;
 
-   /* Tell libGL to prefer the EGL drivers over regular DRI drivers */
-   __glXPreferEGL(1);
-
    _eglInitDriverFallbacks(&xdri_drv->Base);
    xdri_drv->Base.API.Initialize = xdri_eglInitialize;
    xdri_drv->Base.API.Terminate = xdri_eglTerminate;
@@ -1155,6 +559,7 @@ _eglMain(_EGLDisplay *disp, const char *args)
    xdri_drv->Base.API.GetProcAddress = xdri_eglGetProcAddress;
 
    xdri_drv->Base.API.CreateContext = xdri_eglCreateContext;
+   xdri_drv->Base.API.DestroyContext = xdri_eglDestroyContext;
    xdri_drv->Base.API.MakeCurrent = xdri_eglMakeCurrent;
    xdri_drv->Base.API.CreateWindowSurface = xdri_eglCreateWindowSurface;
    xdri_drv->Base.API.CreatePbufferSurface = xdri_eglCreatePbufferSurface;
@@ -1163,13 +568,8 @@ _eglMain(_EGLDisplay *disp, const char *args)
    xdri_drv->Base.API.ReleaseTexImage = xdri_eglReleaseTexImage;
    xdri_drv->Base.API.SwapBuffers = xdri_eglSwapBuffers;
 
-   xdri_drv->Base.ClientAPIsMask = (EGL_OPENGL_BIT |
-                                    EGL_OPENGL_ES_BIT |
-                                    EGL_OPENGL_ES2_BIT |
-                                    EGL_OPENVG_BIT);
    xdri_drv->Base.Name = "X/DRI";
-
-   _eglLog(_EGL_DEBUG, "XDRI: main(%s)", args);
+   xdri_drv->Base.Unload = xdri_Unload;
 
    return &xdri_drv->Base;
 }
diff --git a/src/egl/drivers/xdri/glxinit.c b/src/egl/drivers/xdri/glxinit.c
new file mode 100644
index 0000000000..7775009394
--- /dev/null
+++ b/src/egl/drivers/xdri/glxinit.c
@@ -0,0 +1,626 @@
+/**
+ * GLX initialization.  Code based on glxext.c, glx_query.c, and
+ * glcontextmodes.c under src/glx/x11/.  The major difference is that no DRI
+ * related code here.
+ *
+ */
+
+#include <assert.h>
+#include <X11/Xlib.h>
+#include <X11/Xproto.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include <sys/time.h>
+
+#include "glxinit.h"
+
+typedef struct GLXGenericGetString
+{
+   CARD8 reqType;
+   CARD8 glxCode;
+   CARD16 length B16;
+   CARD32 for_whom B32;
+   CARD32 name B32;
+} xGLXGenericGetStringReq;
+
+#define sz_xGLXGenericGetStringReq 12
+#define X_GLXGenericGetString 0
+
+/* Extension required boiler plate */
+
+static char *__glXExtensionName = GLX_EXTENSION_NAME;
+static XExtensionInfo *__glXExtensionInfo = NULL;
+
+static /* const */ XExtensionHooks __glXExtensionHooks = { NULL };
+static
+XEXT_GENERATE_FIND_DISPLAY(__glXFindDisplay, __glXExtensionInfo,
+                           __glXExtensionName, &__glXExtensionHooks,
+                           __GLX_NUMBER_EVENTS, NULL)
+
+static GLint
+_gl_convert_from_x_visual_type(int visualType)
+{
+#define NUM_VISUAL_TYPES   6
+   static const int glx_visual_types[NUM_VISUAL_TYPES] = {
+      GLX_STATIC_GRAY, GLX_GRAY_SCALE,
+      GLX_STATIC_COLOR, GLX_PSEUDO_COLOR,
+      GLX_TRUE_COLOR, GLX_DIRECT_COLOR
+   };
+
+   return ((unsigned) visualType < NUM_VISUAL_TYPES)
+      ? glx_visual_types[visualType] : GLX_NONE;
+}
+
+static __GLcontextModes *
+_gl_context_modes_create(unsigned count, size_t minimum_size)
+{
+   const size_t size = (minimum_size > sizeof(__GLcontextModes))
+      ? minimum_size : sizeof(__GLcontextModes);
+   __GLcontextModes *base = NULL;
+   __GLcontextModes **next;
+   unsigned i;
+
+   next = &base;
+   for (i = 0; i < count; i++) {
+      *next = (__GLcontextModes *) Xmalloc(size);
+      if (*next == NULL) {
+         _gl_context_modes_destroy(base);
+         base = NULL;
+         break;
+      }
+
+      memset(*next, 0, size);
+      (*next)->visualID = GLX_DONT_CARE;
+      (*next)->visualType = GLX_DONT_CARE;
+      (*next)->visualRating = GLX_NONE;
+      (*next)->transparentPixel = GLX_NONE;
+      (*next)->transparentRed = GLX_DONT_CARE;
+      (*next)->transparentGreen = GLX_DONT_CARE;
+      (*next)->transparentBlue = GLX_DONT_CARE;
+      (*next)->transparentAlpha = GLX_DONT_CARE;
+      (*next)->transparentIndex = GLX_DONT_CARE;
+      (*next)->xRenderable = GLX_DONT_CARE;
+      (*next)->fbconfigID = GLX_DONT_CARE;
+      (*next)->swapMethod = GLX_SWAP_UNDEFINED_OML;
+      (*next)->bindToTextureRgb = GLX_DONT_CARE;
+      (*next)->bindToTextureRgba = GLX_DONT_CARE;
+      (*next)->bindToMipmapTexture = GLX_DONT_CARE;
+      (*next)->bindToTextureTargets = GLX_DONT_CARE;
+      (*next)->yInverted = GLX_DONT_CARE;
+
+      next = &((*next)->next);
+   }
+
+   return base;
+}
+
+_X_HIDDEN void
+_gl_context_modes_destroy(__GLcontextModes * modes)
+{
+   while (modes != NULL) {
+      __GLcontextModes *const next = modes->next;
+
+      Xfree(modes);
+      modes = next;
+   }
+}
+
+_X_HIDDEN char *
+__glXQueryServerString(Display * dpy, int opcode, CARD32 screen, CARD32 name)
+{
+   xGLXGenericGetStringReq *req;
+   xGLXSingleReply reply;
+   int length;
+   int numbytes;
+   char *buf;
+   CARD32 for_whom = screen;
+   CARD32 glxCode = X_GLXQueryServerString;
+
+
+   LockDisplay(dpy);
+
+
+   /* All of the GLX protocol requests for getting a string from the server
+    * look the same.  The exact meaning of the for_whom field is usually
+    * either the screen number (for glXQueryServerString) or the context tag
+    * (for GLXSingle).
+    */
+
+   GetReq(GLXGenericGetString, req);
+   req->reqType = opcode;
+   req->glxCode = glxCode;
+   req->for_whom = for_whom;
+   req->name = name;
+
+   _XReply(dpy, (xReply *) & reply, 0, False);
+
+   length = reply.length * 4;
+   numbytes = reply.size;
+
+   buf = (char *) Xmalloc(numbytes);
+   if (buf != NULL) {
+      _XRead(dpy, buf, numbytes);
+      length -= numbytes;
+   }
+
+   _XEatData(dpy, length);
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return buf;
+}
+
+/************************************************************************/
+/*
+** Free the per screen configs data as well as the array of
+** __glXScreenConfigs.
+*/
+static void
+FreeScreenConfigs(__GLXdisplayPrivate * priv)
+{
+   __GLXscreenConfigs *psc;
+   GLint i, screens;
+
+   /* Free screen configuration information */
+   psc = priv->screenConfigs;
+   screens = ScreenCount(priv->dpy);
+   for (i = 0; i < screens; i++, psc++) {
+      if (psc->configs) {
+         _gl_context_modes_destroy(psc->configs);
+         psc->configs = NULL;   /* NOTE: just for paranoia */
+      }
+      if (psc->visuals) {
+         _gl_context_modes_destroy(psc->visuals);
+         psc->visuals = NULL;   /* NOTE: just for paranoia */
+      }
+      Xfree((char *) psc->serverGLXexts);
+   }
+   XFree((char *) priv->screenConfigs);
+   priv->screenConfigs = NULL;
+}
+
+/************************************************************************/
+
+/*
+** Query the version of the GLX extension.  This procedure works even if
+** the client extension is not completely set up.
+*/
+static Bool
+QueryVersion(Display * dpy, int opcode, int *major, int *minor)
+{
+   xGLXQueryVersionReq *req;
+   xGLXQueryVersionReply reply;
+
+   /* Send the glXQueryVersion request */
+   LockDisplay(dpy);
+   GetReq(GLXQueryVersion, req);
+   req->reqType = opcode;
+   req->glxCode = X_GLXQueryVersion;
+   req->majorVersion = GLX_MAJOR_VERSION;
+   req->minorVersion = GLX_MINOR_VERSION;
+   _XReply(dpy, (xReply *) & reply, 0, False);
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   if (reply.majorVersion != GLX_MAJOR_VERSION) {
+      /*
+       ** The server does not support the same major release as this
+       ** client.
+       */
+      return GL_FALSE;
+   }
+   *major = reply.majorVersion;
+   *minor = min(reply.minorVersion, GLX_MINOR_VERSION);
+   return GL_TRUE;
+}
+
+_X_HIDDEN void
+__glXInitializeVisualConfigFromTags(__GLcontextModes * config, int count,
+                                    const INT32 * bp, Bool tagged_only,
+                                    Bool fbconfig_style_tags)
+{
+   int i;
+
+   if (!tagged_only) {
+      /* Copy in the first set of properties */
+      config->visualID = *bp++;
+
+      config->visualType = _gl_convert_from_x_visual_type(*bp++);
+
+      config->rgbMode = *bp++;
+
+      config->redBits = *bp++;
+      config->greenBits = *bp++;
+      config->blueBits = *bp++;
+      config->alphaBits = *bp++;
+      config->accumRedBits = *bp++;
+      config->accumGreenBits = *bp++;
+      config->accumBlueBits = *bp++;
+      config->accumAlphaBits = *bp++;
+
+      config->doubleBufferMode = *bp++;
+      config->stereoMode = *bp++;
+
+      config->rgbBits = *bp++;
+      config->depthBits = *bp++;
+      config->stencilBits = *bp++;
+      config->numAuxBuffers = *bp++;
+      config->level = *bp++;
+
+      count -= __GLX_MIN_CONFIG_PROPS;
+   }
+
+   /*
+    ** Additional properties may be in a list at the end
+    ** of the reply.  They are in pairs of property type
+    ** and property value.
+    */
+
+#define FETCH_OR_SET(tag) \
+    config-> tag = ( fbconfig_style_tags ) ? *bp++ : 1
+
+   for (i = 0; i < count; i += 2) {
+      switch (*bp++) {
+      case GLX_RGBA:
+         FETCH_OR_SET(rgbMode);
+         break;
+      case GLX_BUFFER_SIZE:
+         config->rgbBits = *bp++;
+         break;
+      case GLX_LEVEL:
+         config->level = *bp++;
+         break;
+      case GLX_DOUBLEBUFFER:
+         FETCH_OR_SET(doubleBufferMode);
+         break;
+      case GLX_STEREO:
+         FETCH_OR_SET(stereoMode);
+         break;
+      case GLX_AUX_BUFFERS:
+         config->numAuxBuffers = *bp++;
+         break;
+      case GLX_RED_SIZE:
+         config->redBits = *bp++;
+         break;
+      case GLX_GREEN_SIZE:
+         config->greenBits = *bp++;
+         break;
+      case GLX_BLUE_SIZE:
+         config->blueBits = *bp++;
+         break;
+      case GLX_ALPHA_SIZE:
+         config->alphaBits = *bp++;
+         break;
+      case GLX_DEPTH_SIZE:
+         config->depthBits = *bp++;
+         break;
+      case GLX_STENCIL_SIZE:
+         config->stencilBits = *bp++;
+         break;
+      case GLX_ACCUM_RED_SIZE:
+         config->accumRedBits = *bp++;
+         break;
+      case GLX_ACCUM_GREEN_SIZE:
+         config->accumGreenBits = *bp++;
+         break;
+      case GLX_ACCUM_BLUE_SIZE:
+         config->accumBlueBits = *bp++;
+         break;
+      case GLX_ACCUM_ALPHA_SIZE:
+         config->accumAlphaBits = *bp++;
+         break;
+      case GLX_VISUAL_CAVEAT_EXT:
+         config->visualRating = *bp++;
+         break;
+      case GLX_X_VISUAL_TYPE:
+         config->visualType = *bp++;
+         break;
+      case GLX_TRANSPARENT_TYPE:
+         config->transparentPixel = *bp++;
+         break;
+      case GLX_TRANSPARENT_INDEX_VALUE:
+         config->transparentIndex = *bp++;
+         break;
+      case GLX_TRANSPARENT_RED_VALUE:
+         config->transparentRed = *bp++;
+         break;
+      case GLX_TRANSPARENT_GREEN_VALUE:
+         config->transparentGreen = *bp++;
+         break;
+      case GLX_TRANSPARENT_BLUE_VALUE:
+         config->transparentBlue = *bp++;
+         break;
+      case GLX_TRANSPARENT_ALPHA_VALUE:
+         config->transparentAlpha = *bp++;
+         break;
+      case GLX_VISUAL_ID:
+         config->visualID = *bp++;
+         break;
+      case GLX_DRAWABLE_TYPE:
+         config->drawableType = *bp++;
+         break;
+      case GLX_RENDER_TYPE:
+         config->renderType = *bp++;
+         break;
+      case GLX_X_RENDERABLE:
+         config->xRenderable = *bp++;
+         break;
+      case GLX_FBCONFIG_ID:
+         config->fbconfigID = *bp++;
+         break;
+      case GLX_MAX_PBUFFER_WIDTH:
+         config->maxPbufferWidth = *bp++;
+         break;
+      case GLX_MAX_PBUFFER_HEIGHT:
+         config->maxPbufferHeight = *bp++;
+         break;
+      case GLX_MAX_PBUFFER_PIXELS:
+         config->maxPbufferPixels = *bp++;
+         break;
+      case GLX_OPTIMAL_PBUFFER_WIDTH_SGIX:
+         config->optimalPbufferWidth = *bp++;
+         break;
+      case GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX:
+         config->optimalPbufferHeight = *bp++;
+         break;
+      case GLX_VISUAL_SELECT_GROUP_SGIX:
+         config->visualSelectGroup = *bp++;
+         break;
+      case GLX_SWAP_METHOD_OML:
+         config->swapMethod = *bp++;
+         break;
+      case GLX_SAMPLE_BUFFERS_SGIS:
+         config->sampleBuffers = *bp++;
+         break;
+      case GLX_SAMPLES_SGIS:
+         config->samples = *bp++;
+         break;
+      case GLX_BIND_TO_TEXTURE_RGB_EXT:
+         config->bindToTextureRgb = *bp++;
+         break;
+      case GLX_BIND_TO_TEXTURE_RGBA_EXT:
+         config->bindToTextureRgba = *bp++;
+         break;
+      case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
+         config->bindToMipmapTexture = *bp++;
+         break;
+      case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
+         config->bindToTextureTargets = *bp++;
+         break;
+      case GLX_Y_INVERTED_EXT:
+         config->yInverted = *bp++;
+         break;
+      case None:
+         i = count;
+         break;
+      default:
+         break;
+      }
+   }
+
+   config->renderType =
+      (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+
+   config->haveAccumBuffer = ((config->accumRedBits +
+                               config->accumGreenBits +
+                               config->accumBlueBits +
+                               config->accumAlphaBits) > 0);
+   config->haveDepthBuffer = (config->depthBits > 0);
+   config->haveStencilBuffer = (config->stencilBits > 0);
+}
+
+static __GLcontextModes *
+createConfigsFromProperties(Display * dpy, int nvisuals, int nprops,
+                            int screen, GLboolean tagged_only)
+{
+   INT32 buf[__GLX_TOTAL_CONFIG], *props;
+   unsigned prop_size;
+   __GLcontextModes *modes, *m;
+   int i;
+
+   if (nprops == 0)
+      return NULL;
+
+   /* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for FBconfigs? */
+
+   /* Check number of properties */
+   if (nprops < __GLX_MIN_CONFIG_PROPS || nprops > __GLX_MAX_CONFIG_PROPS)
+      return NULL;
+
+   /* Allocate memory for our config structure */
+   modes = _gl_context_modes_create(nvisuals, sizeof(__GLcontextModes));
+   if (!modes)
+      return NULL;
+
+   prop_size = nprops * __GLX_SIZE_INT32;
+   if (prop_size <= sizeof(buf))
+      props = buf;
+   else
+      props = Xmalloc(prop_size);
+
+   /* Read each config structure and convert it into our format */
+   m = modes;
+   for (i = 0; i < nvisuals; i++) {
+      _XRead(dpy, (char *) props, prop_size);
+      /* Older X servers don't send this so we default it here. */
+      m->drawableType = GLX_WINDOW_BIT;
+      __glXInitializeVisualConfigFromTags(m, nprops, props,
+                                     tagged_only, GL_TRUE);
+      m->screen = screen;
+      m = m->next;
+   }
+
+   if (props != buf)
+      Xfree(props);
+
+   return modes;
+}
+
+static GLboolean
+getVisualConfigs(Display * dpy, __GLXdisplayPrivate * priv, int screen)
+{
+   xGLXGetVisualConfigsReq *req;
+   __GLXscreenConfigs *psc;
+   xGLXGetVisualConfigsReply reply;
+
+   LockDisplay(dpy);
+
+   psc = priv->screenConfigs + screen;
+   psc->visuals = NULL;
+   GetReq(GLXGetVisualConfigs, req);
+   req->reqType = priv->majorOpcode;
+   req->glxCode = X_GLXGetVisualConfigs;
+   req->screen = screen;
+
+   if (!_XReply(dpy, (xReply *) & reply, 0, False))
+      goto out;
+
+   psc->visuals = createConfigsFromProperties(dpy,
+                                              reply.numVisuals,
+                                              reply.numProps,
+                                              screen, GL_FALSE);
+
+ out:
+   UnlockDisplay(dpy);
+   return psc->visuals != NULL;
+}
+
+static GLboolean
+getFBConfigs(Display * dpy, __GLXdisplayPrivate * priv, int screen)
+{
+   xGLXGetFBConfigsReq *fb_req;
+   xGLXGetFBConfigsSGIXReq *sgi_req;
+   xGLXVendorPrivateWithReplyReq *vpreq;
+   xGLXGetFBConfigsReply reply;
+   __GLXscreenConfigs *psc;
+
+   psc = priv->screenConfigs + screen;
+   psc->serverGLXexts =
+      __glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS);
+
+   LockDisplay(dpy);
+
+   psc->configs = NULL;
+   if (atof(priv->serverGLXversion) >= 1.3) {
+      GetReq(GLXGetFBConfigs, fb_req);
+      fb_req->reqType = priv->majorOpcode;
+      fb_req->glxCode = X_GLXGetFBConfigs;
+      fb_req->screen = screen;
+   }
+   else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) {
+      GetReqExtra(GLXVendorPrivateWithReply,
+                  sz_xGLXGetFBConfigsSGIXReq +
+                  sz_xGLXVendorPrivateWithReplyReq, vpreq);
+      sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
+      sgi_req->reqType = priv->majorOpcode;
+      sgi_req->glxCode = X_GLXVendorPrivateWithReply;
+      sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
+      sgi_req->screen = screen;
+   }
+   else
+      goto out;
+
+   if (!_XReply(dpy, (xReply *) & reply, 0, False))
+      goto out;
+
+   psc->configs = createConfigsFromProperties(dpy,
+                                              reply.numFBConfigs,
+                                              reply.numAttribs * 2,
+                                              screen, GL_TRUE);
+
+ out:
+   UnlockDisplay(dpy);
+   return psc->configs != NULL;
+}
+
+static GLboolean
+AllocAndFetchScreenConfigs(Display * dpy, __GLXdisplayPrivate * priv)
+{
+   __GLXscreenConfigs *psc;
+   GLint i, screens;
+
+   /*
+    ** First allocate memory for the array of per screen configs.
+    */
+   screens = ScreenCount(dpy);
+   psc = (__GLXscreenConfigs *) Xmalloc(screens * sizeof(__GLXscreenConfigs));
+   if (!psc) {
+      return GL_FALSE;
+   }
+   memset(psc, 0, screens * sizeof(__GLXscreenConfigs));
+   priv->screenConfigs = psc;
+
+   priv->serverGLXversion =
+      __glXQueryServerString(dpy, priv->majorOpcode, 0, GLX_VERSION);
+   if (priv->serverGLXversion == NULL) {
+      FreeScreenConfigs(priv);
+      return GL_FALSE;
+   }
+
+   for (i = 0; i < screens; i++, psc++) {
+      getFBConfigs(dpy, priv, i);
+      getVisualConfigs(dpy, priv, i);
+      psc->scr = i;
+      psc->dpy = dpy;
+   }
+
+   SyncHandle();
+
+   return GL_TRUE;
+}
+
+_X_HIDDEN void
+__glXRelease(__GLXdisplayPrivate *dpyPriv)
+{
+   FreeScreenConfigs(dpyPriv);
+
+   if (dpyPriv->serverGLXvendor) {
+      Xfree((char *) dpyPriv->serverGLXvendor);
+      dpyPriv->serverGLXvendor = NULL;
+   }
+   if (dpyPriv->serverGLXversion) {
+      Xfree((char *) dpyPriv->serverGLXversion);
+      dpyPriv->serverGLXversion = NULL;
+   }
+
+   Xfree(dpyPriv);
+}
+
+_X_HIDDEN __GLXdisplayPrivate *
+__glXInitialize(Display * dpy)
+{
+   XExtDisplayInfo *info = __glXFindDisplay(dpy);
+   __GLXdisplayPrivate *dpyPriv;
+   int major, minor;
+
+   if (!XextHasExtension(info))
+      return NULL;
+
+   /* See if the versions are compatible */
+   if (!QueryVersion(dpy, info->codes->major_opcode, &major, &minor))
+      return NULL;
+
+   dpyPriv = (__GLXdisplayPrivate *) Xcalloc(1, sizeof(__GLXdisplayPrivate));
+   if (!dpyPriv)
+      return NULL;
+
+   /*
+    ** Init the display private and then read in the screen config
+    ** structures from the server.
+    */
+   dpyPriv->majorOpcode = info->codes->major_opcode;
+   dpyPriv->majorVersion = major;
+   dpyPriv->minorVersion = minor;
+   dpyPriv->dpy = dpy;
+
+   dpyPriv->serverGLXvendor = NULL;
+   dpyPriv->serverGLXversion = NULL;
+
+   if (!AllocAndFetchScreenConfigs(dpy, dpyPriv)) {
+      Xfree(dpyPriv);
+      return NULL;
+   }
+
+   return dpyPriv;
+}
diff --git a/src/egl/drivers/xdri/glxinit.h b/src/egl/drivers/xdri/glxinit.h
new file mode 100644
index 0000000000..57206e627b
--- /dev/null
+++ b/src/egl/drivers/xdri/glxinit.h
@@ -0,0 +1,14 @@
+#ifndef GLXINIT_INCLUDED
+#define GLXINIT_INCLUDED
+
+#include <X11/Xlib.h>
+#include "glxclient.h"
+
+/* this is used by DRI loaders */
+extern void
+_gl_context_modes_destroy(__GLcontextModes * modes);
+
+extern void
+__glXRelease(__GLXdisplayPrivate *dpyPriv);
+
+#endif /* GLXINIT_INCLUDED */
-- 
cgit v1.2.3


From f5a06fad62cd43d7854bafa60bbe6f48e8cf90af Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Wed, 26 Aug 2009 14:45:17 +0800
Subject: egl_glx: Make fbconfigs and visuals per display.

This is to allow a driver to drive multiple displays.  Remove the use of
_EGL_PLATFORM_X and obsolete code along the way.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/drivers/glx/egl_glx.c | 249 +++++++++++++++++++++++-------------------
 1 file changed, 135 insertions(+), 114 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 3c8f8b6a68..4685f600e2 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -50,8 +50,6 @@
 #include <GL/gl.h>
 #include "glxclient.h"
 
-#define _EGL_PLATFORM_X
-
 #include "eglconfig.h"
 #include "eglcontext.h"
 #include "egldisplay.h"
@@ -105,7 +103,13 @@ struct visual_attribs
 struct GLX_egl_driver
 {
    _EGLDriver Base;   /**< base class */
+};
 
+
+/** driver data of _EGLDisplay */
+struct GLX_egl_display
+{
+   Display *dpy;
    XVisualInfo *visuals;
    GLXFBConfig *fbconfigs;
 
@@ -135,6 +139,7 @@ struct GLX_egl_surface
 struct GLX_egl_config
 {
    _EGLConfig Base;   /**< base class */
+   int index;
 };
 
 /** cast wrapper */
@@ -144,6 +149,12 @@ GLX_egl_driver(_EGLDriver *drv)
    return (struct GLX_egl_driver *) drv;
 }
 
+static struct GLX_egl_display *
+GLX_egl_display(_EGLDisplay *dpy)
+{
+   return (struct GLX_egl_display *) dpy->DriverData;
+}
+
 static struct GLX_egl_context *
 GLX_egl_context(_EGLContext *ctx)
 {
@@ -157,10 +168,9 @@ GLX_egl_surface(_EGLSurface *surf)
 }
 
 static int
-GLX_egl_config_id(_EGLConfig *conf)
+GLX_egl_config_index(_EGLConfig *conf)
 {
-   /* see create_configs */
-   return (int) _eglPointerToUInt(_eglGetConfigHandle(conf)) - 1;
+   return ((struct GLX_egl_config *) conf)->index;
 }
 
 static GLboolean
@@ -273,6 +283,7 @@ glx_token_to_visual_class(int visual_type)
       return None;
    }
 }
+
 static int
 get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
 		     struct visual_attribs *attribs)
@@ -351,7 +362,7 @@ get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
 #endif
 
 static EGLBoolean
-create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
+create_configs(_EGLDisplay *disp, struct GLX_egl_display *GLX_dpy)
 {
    XVisualInfo theTemplate;
    int numVisuals;
@@ -359,14 +370,14 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
    int i;
    struct visual_attribs attribs;
 
-   GLX_drv->fbconfigs = NULL;
+   GLX_dpy->fbconfigs = NULL;
 
 #ifdef GLX_VERSION_1_3
    /* get list of all fbconfigs on this screen */
-   GLX_drv->fbconfigs = glXGetFBConfigs(disp->Xdpy, DefaultScreen(disp->Xdpy), &numVisuals);
+   GLX_dpy->fbconfigs = glXGetFBConfigs(GLX_dpy->dpy, DefaultScreen(GLX_dpy->dpy), &numVisuals);
 
    if (numVisuals == 0) {
-      GLX_drv->fbconfigs = NULL;
+      GLX_dpy->fbconfigs = NULL;
       goto xvisual;
    }
 
@@ -374,12 +385,13 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
       struct GLX_egl_config *config;
       int bit;
 
-      bit = get_fbconfig_attribs(disp->Xdpy, GLX_drv->fbconfigs[i], &attribs);
+      bit = get_fbconfig_attribs(GLX_dpy->dpy, GLX_dpy->fbconfigs[i], &attribs);
       if (!bit)
          continue;
 
       config = CALLOC_STRUCT(GLX_egl_config);
 
+      config->index = i;
       _eglInitConfig(&config->Base, (i+1));
       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
@@ -405,18 +417,19 @@ create_configs(_EGLDisplay *disp, struct GLX_egl_driver *GLX_drv)
 
 xvisual:
    /* get list of all visuals on this screen */
-   theTemplate.screen = DefaultScreen(disp->Xdpy);
+   theTemplate.screen = DefaultScreen(GLX_dpy->dpy);
    mask = VisualScreenMask;
-   GLX_drv->visuals = XGetVisualInfo(disp->Xdpy, mask, &theTemplate, &numVisuals);
+   GLX_dpy->visuals = XGetVisualInfo(GLX_dpy->dpy, mask, &theTemplate, &numVisuals);
 
    for (i = 0; i < numVisuals; i++) {
       struct GLX_egl_config *config;
 
-      if (!get_visual_attribs(disp->Xdpy, &GLX_drv->visuals[i], &attribs))
+      if (!get_visual_attribs(GLX_dpy->dpy, &GLX_dpy->visuals[i], &attribs))
 	 continue;
 
       config = CALLOC_STRUCT(GLX_egl_config);
 
+      config->index = i;
       _eglInitConfig(&config->Base, (i+1));
       SET_CONFIG_ATTRIB(&config->Base, EGL_NATIVE_VISUAL_ID, attribs.id);
       SET_CONFIG_ATTRIB(&config->Base, EGL_BUFFER_SIZE, attribs.bufferSize);
@@ -447,75 +460,60 @@ end:
  */
 static EGLBoolean
 GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp,
-                   EGLint *minor, EGLint *major)
+                   EGLint *major, EGLint *minor)
 {
-   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   struct GLX_egl_display *GLX_dpy;
 
-   _eglLog(_EGL_DEBUG, "GLX: eglInitialize");
+   GLX_dpy = CALLOC_STRUCT(GLX_egl_display);
+   if (!GLX_dpy)
+      return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 
-   if (!disp->Xdpy) {
-      disp->Xdpy = XOpenDisplay(NULL);
-      if (!disp->Xdpy) {
+   GLX_dpy->dpy = (Display *) disp->NativeDisplay;
+   if (!GLX_dpy->dpy) {
+      GLX_dpy->dpy = XOpenDisplay(NULL);
+      if (!GLX_dpy->dpy) {
          _eglLog(_EGL_WARNING, "GLX: XOpenDisplay failed");
+         free(GLX_dpy);
          return EGL_FALSE;
       }
-   } 
+   }
 
+   disp->DriverData = (void *) GLX_dpy;
    disp->ClientAPIsMask = all_apis;
 
-   glXQueryVersion(disp->Xdpy, &GLX_drv->glx_maj, &GLX_drv->glx_min);
-   
-   GLX_drv->Base.Name = "GLX";
+   glXQueryVersion(GLX_dpy->dpy, &GLX_dpy->glx_maj, &GLX_dpy->glx_min);
 
    /* we're supporting EGL 1.4 */
-   *minor = 1;
-   *major = 4;
+   *major = 1;
+   *minor = 4;
 
-   create_configs(disp, GLX_drv);
+   create_configs(disp, GLX_dpy);
 
    return EGL_TRUE;
 }
 
-/*
- * Do some clean-up that normally occurs in XCloseDisplay().
- * We do this here because we're about to unload a dynamic library
- * that has added some per-display extension data and callbacks.
- * If we don't do this here we'll crash in XCloseDisplay() because it'll
- * try to call functions that went away when the driver library was unloaded.
- */
-static void
-FreeDisplayExt(Display *dpy)
-{
-   _XExtension *ext, *next;
-
-   for (ext = dpy->ext_procs; ext; ext = next) {
-      next = ext->next;
-      if (ext->close_display) {
-         ext->close_display(dpy, &ext->codes);
-         ext->close_display = NULL;
-      }
-      if (ext->name)
-         Xfree(ext->name);
-      Xfree(ext);
-   }
-   dpy->ext_procs = NULL;
-
-   _XFreeExtData (dpy->ext_data);
-   dpy->ext_data = NULL;
-}
-
 /**
  * Called via eglTerminate(), drv->API.Terminate().
  */
 static EGLBoolean
 GLX_eglTerminate(_EGLDriver *drv, _EGLDisplay *disp)
 {
-   _eglLog(_EGL_DEBUG, "GLX: eglTerminate");
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
 
    _eglReleaseDisplayResources(drv, disp);
-   FreeDisplayExt(disp->Xdpy);
    _eglCleanupDisplay(disp);
 
+   if (GLX_dpy->visuals)
+      XFree(GLX_dpy->visuals);
+   if (GLX_dpy->fbconfigs)
+      XFree(GLX_dpy->fbconfigs);
+
+   if (!disp->NativeDisplay)
+      XCloseDisplay(GLX_dpy->dpy);
+   free(GLX_dpy);
+
+   disp->DriverData = NULL;
+
    return EGL_TRUE;
 }
 
@@ -528,11 +526,13 @@ GLX_eglCreateContext(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
                       _EGLContext *share_list, const EGLint *attrib_list)
 {
    struct GLX_egl_context *GLX_ctx = CALLOC_STRUCT(GLX_egl_context);
-   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_context *GLX_ctx_shared = GLX_egl_context(share_list);
 
-   if (!GLX_ctx)
+   if (!GLX_ctx) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateContext");
       return NULL;
+   }
 
    if (!_eglInitContext(drv, &GLX_ctx->Base, conf, attrib_list)) {
       free(GLX_ctx);
@@ -540,27 +540,32 @@ GLX_eglCreateContext(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
    }
 
 #ifdef GLX_VERSION_1_3
-   if (GLX_drv->fbconfigs)
+   if (GLX_dpy->fbconfigs)
       GLX_ctx->context =
-         glXCreateNewContext(disp->Xdpy,
-                             GLX_drv->fbconfigs[GLX_egl_config_id(conf)],
+         glXCreateNewContext(GLX_dpy->dpy,
+                             GLX_dpy->fbconfigs[GLX_egl_config_index(conf)],
                              GLX_RGBA_TYPE,
                              GLX_ctx_shared ? GLX_ctx_shared->context : NULL,
                              GL_TRUE);
    else
 #endif
       GLX_ctx->context =
-         glXCreateContext(disp->Xdpy,
-                          &GLX_drv->visuals[GLX_egl_config_id(conf)],
+         glXCreateContext(GLX_dpy->dpy,
+                          &GLX_dpy->visuals[GLX_egl_config_index(conf)],
                           GLX_ctx_shared ? GLX_ctx_shared->context : NULL,
                           GL_TRUE);
-   if (!GLX_ctx->context)
-      return EGL_FALSE;
+   if (!GLX_ctx->context) {
+      free(GLX_ctx);
+      return NULL;
+   }
 
 #if 1
    /* (maybe?) need to have a direct rendering context */
-   if (!glXIsDirect(disp->Xdpy, GLX_ctx->context))
-      return EGL_FALSE;
+   if (!glXIsDirect(GLX_dpy->dpy, GLX_ctx->context)) {
+      glXDestroyContext(GLX_dpy->dpy, GLX_ctx->context);
+      free(GLX_ctx);
+      return NULL;
+   }
 #endif
 
    return &GLX_ctx->Base;
@@ -574,20 +579,29 @@ static EGLBoolean
 GLX_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
                    _EGLSurface *rsurf, _EGLContext *ctx)
 {
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_surface *GLX_dsurf = GLX_egl_surface(dsurf);
    struct GLX_egl_surface *GLX_rsurf = GLX_egl_surface(rsurf);
    struct GLX_egl_context *GLX_ctx = GLX_egl_context(ctx);
+   GLXDrawable ddraw, rdraw;
+   GLXContext cctx;
 
    if (!_eglMakeCurrent(drv, disp, dsurf, rsurf, ctx))
       return EGL_FALSE;
 
+   ddraw = (GLX_dsurf) ? GLX_dsurf->drawable : None;
+   rdraw = (GLX_rsurf) ? GLX_rsurf->drawable : None;
+   cctx = (GLX_ctx) ? GLX_ctx->context : NULL;
+
 #ifdef GLX_VERSION_1_3
-   if (!glXMakeContextCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_rsurf ? GLX_rsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
+   if (glXMakeContextCurrent(GLX_dpy->dpy, ddraw, rdraw, cctx))
+      return EGL_TRUE;
 #endif
-      if (!glXMakeCurrent(disp->Xdpy, GLX_dsurf ? GLX_dsurf->drawable : 0, GLX_ctx ? GLX_ctx->context : NULL))
-         return EGL_FALSE;
 
-   return EGL_TRUE;
+   if (ddraw == rdraw && glXMakeCurrent(GLX_dpy->dpy, ddraw, cctx))
+      return EGL_TRUE;
+
+   return EGL_FALSE;
 }
 
 /** Get size of given window */
@@ -611,12 +625,15 @@ static _EGLSurface *
 GLX_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
                             NativeWindowType window, const EGLint *attrib_list)
 {
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_surface *GLX_surf;
    uint width, height;
 
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
-   if (!GLX_surf)
+   if (!GLX_surf) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateWindowSurface");
       return NULL;
+   }
 
    if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_WINDOW_BIT,
                         conf, attrib_list)) {
@@ -625,7 +642,7 @@ GLX_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
    }
 
    GLX_surf->drawable = window;
-   get_drawable_size(disp->Xdpy, window, &width, &height);
+   get_drawable_size(GLX_dpy->dpy, window, &width, &height);
    GLX_surf->Base.Width = width;
    GLX_surf->Base.Height = height;
 
@@ -637,13 +654,19 @@ static _EGLSurface *
 GLX_eglCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
 			   NativePixmapType pixmap, const EGLint *attrib_list)
 {
-   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_surface *GLX_surf;
    int i;
 
+   /* GLX must >= 1.3 */
+   if (!(GLX_dpy->glx_maj == 1 && GLX_dpy->glx_min >= 3))
+      return NULL;
+
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
-   if (!GLX_surf)
+   if (!GLX_surf) {
+      _eglError(EGL_BAD_ALLOC, "eglCreatePixmapSurface");
       return NULL;
+   }
 
    if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_PIXMAP_BIT,
                         conf, attrib_list)) {
@@ -656,30 +679,41 @@ GLX_eglCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
          /* no attribs at this time */
       default:
          _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePixmapSurface");
+         free(GLX_surf);
          return NULL;
       }
    }
 
    GLX_surf->drawable =
-      glXCreatePixmap(disp->Xdpy,
-                      GLX_drv->fbconfigs[GLX_egl_config_id(conf)],
+      glXCreatePixmap(GLX_dpy->dpy,
+                      GLX_dpy->fbconfigs[GLX_egl_config_index(conf)],
                       pixmap, NULL);
+   if (!GLX_surf->drawable) {
+      free(GLX_surf);
+      return NULL;
+   }
 
    return &GLX_surf->Base;
 }
 
 static _EGLSurface *
-GLX_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
-                            const EGLint *attrib_list)
+GLX_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *disp,
+                            _EGLConfig *conf, const EGLint *attrib_list)
 {
-   struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_surface *GLX_surf;
    int attribs[5];
    int i = 0, j = 0;
 
+   /* GLX must >= 1.3 */
+   if (!(GLX_dpy->glx_maj == 1 && GLX_dpy->glx_min >= 3))
+      return NULL;
+
    GLX_surf = CALLOC_STRUCT(GLX_egl_surface);
-   if (!GLX_surf)
+   if (!GLX_surf) {
+      _eglError(EGL_BAD_ALLOC, "eglCreatePbufferSurface");
       return NULL;
+   }
 
    if (!_eglInitSurface(drv, &GLX_surf->Base, EGL_PBUFFER_BIT,
                         conf, attrib_list)) {
@@ -703,8 +737,13 @@ GLX_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf
    attribs[j++] = 0;
 
    GLX_surf->drawable =
-      glXCreatePbuffer(disp->Xdpy,
-                       GLX_drv->fbconfigs[GLX_egl_config_id(conf)], attribs);
+      glXCreatePbuffer(GLX_dpy->dpy,
+                       GLX_dpy->fbconfigs[GLX_egl_config_index(conf)],
+                       attribs);
+   if (!GLX_surf->drawable) {
+      free(GLX_surf);
+      return NULL;
+   }
 
    return &GLX_surf->Base;
 }
@@ -713,14 +752,15 @@ GLX_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf
 static EGLBoolean
 GLX_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 {
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    if (!_eglIsSurfaceBound(surf)) {
       struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
       switch (surf->Type) {
       case EGL_PBUFFER_BIT:
-         glXDestroyPbuffer(disp->Xdpy, GLX_surf->drawable);
+         glXDestroyPbuffer(GLX_dpy->dpy, GLX_surf->drawable);
          break;
       case EGL_PIXMAP_BIT:
-         glXDestroyPixmap(disp->Xdpy, GLX_surf->drawable);
+         glXDestroyPixmap(GLX_dpy->dpy, GLX_surf->drawable);
          break;
       default:
          break;
@@ -736,10 +776,12 @@ static EGLBoolean
 GLX_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
                      EGLint buffer)
 {
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 
    /* buffer ?? */
-   glXBindTexImageEXT(disp->Xdpy, GLX_surf->drawable, GLX_FRONT_LEFT_EXT, NULL);
+   glXBindTexImageEXT(GLX_dpy->dpy, GLX_surf->drawable,
+                      GLX_FRONT_LEFT_EXT, NULL);
 
    return EGL_TRUE;
 }
@@ -749,10 +791,12 @@ static EGLBoolean
 GLX_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
                         EGLint buffer)
 {
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(surf);
 
    /* buffer ?? */
-   glXReleaseTexImageEXT(disp->Xdpy, GLX_surf->drawable, GLX_FRONT_LEFT_EXT);
+   glXReleaseTexImageEXT(GLX_dpy->dpy, GLX_surf->drawable,
+                         GLX_FRONT_LEFT_EXT);
 
    return EGL_TRUE;
 }
@@ -761,15 +805,12 @@ GLX_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
 static EGLBoolean
 GLX_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
 {
+   struct GLX_egl_display *GLX_dpy = GLX_egl_display(disp);
    struct GLX_egl_surface *GLX_surf = GLX_egl_surface(draw);
 
    _eglLog(_EGL_DEBUG, "GLX: EGL SwapBuffers 0x%x",draw);
 
-   /* error checking step: */
-   if (!_eglSwapBuffers(drv, disp, draw))
-      return EGL_FALSE;
-
-   glXSwapBuffers(disp->Xdpy, GLX_surf->drawable);
+   glXSwapBuffers(GLX_dpy->dpy, GLX_surf->drawable);
 
    return EGL_TRUE;
 }
@@ -814,7 +855,6 @@ _EGLDriver *
 _eglMain(const char *args)
 {
    struct GLX_egl_driver *GLX_drv = CALLOC_STRUCT(GLX_egl_driver);
-   char *env;
 
    if (!GLX_drv)
       return NULL;
@@ -826,13 +866,8 @@ _eglMain(const char *args)
    GLX_drv->Base.API.MakeCurrent = GLX_eglMakeCurrent;
    GLX_drv->Base.API.CreateWindowSurface = GLX_eglCreateWindowSurface;
 #ifdef GLX_VERSION_1_3
-   if (GLX_drv->glx_maj == 1 && GLX_drv->glx_min >= 3) {
-      GLX_drv->Base.API.CreatePixmapSurface = GLX_eglCreatePixmapSurface;
-      GLX_drv->Base.API.CreatePbufferSurface = GLX_eglCreatePbufferSurface;
-      printf("GLX: Pbuffer and Pixmap support\n");
-   } else {
-      printf("GLX: No pbuffer or pixmap support\n");
-   }
+   GLX_drv->Base.API.CreatePixmapSurface = GLX_eglCreatePixmapSurface;
+   GLX_drv->Base.API.CreatePbufferSurface = GLX_eglCreatePbufferSurface;
 #endif
    GLX_drv->Base.API.DestroySurface = GLX_eglDestroySurface;
    GLX_drv->Base.API.BindTexImage = GLX_eglBindTexImage;
@@ -843,19 +878,5 @@ _eglMain(const char *args)
    GLX_drv->Base.Name = "GLX";
    GLX_drv->Base.Unload = GLX_Unload;
 
-   _eglLog(_EGL_DEBUG, "GLX: main(%s)", args);
-
-   /* set new DRI path to pick up EGL version (which doesn't contain any mesa 
-    * code), but don't override if one is already set.
-    */
-   env = getenv("LIBGL_DRIVERS_PATH");
-   if (env) {
-      if (!strstr(env, "egl")) {
-         sprintf(env, "%s/egl", env);
-         setenv("LIBGL_DRIVERS_PATH", env, 1);
-      }
-   } else
-      setenv("LIBGL_DRIVERS_PATH", DEFAULT_DRIVER_DIR"/egl", 0);
-
    return &GLX_drv->Base;
 }
-- 
cgit v1.2.3


From 5f32756254034ee162f3b17e7488c660c9fa90b0 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Tue, 18 Aug 2009 16:36:10 +0800
Subject: egl_xdri: Implement eglCreateImageKHR.

---
 include/EGL/internal/eglimage_dri.h |  27 +++++
 src/egl/drivers/xdri/egl_xdri.c     | 191 ++++++++++++++++++++++++++++++++++++
 2 files changed, 218 insertions(+)
 create mode 100644 include/EGL/internal/eglimage_dri.h

(limited to 'src/egl/drivers')

diff --git a/include/EGL/internal/eglimage_dri.h b/include/EGL/internal/eglimage_dri.h
new file mode 100644
index 0000000000..ea13951a9f
--- /dev/null
+++ b/include/EGL/internal/eglimage_dri.h
@@ -0,0 +1,27 @@
+#ifndef EGLIMAGE_DRI_INCLUDED
+#define EGLIMAGE_DRI_INCLUDED
+
+#include "GL/internal/dri_interface.h"
+
+#define __DRI_EGL_IMAGE_MAGIC \
+   (('D' << 24) | \
+    ('R' << 16) | \
+    ('I' <<  8) | \
+    ('0'))
+
+typedef void *__DRIEGLImageHandle;
+typedef struct __DRIEGLImageRec __DRIEGLImage;
+
+struct __DRIEGLImageRec {
+   GLint magic;
+
+   __DRIdrawable *drawable;
+
+   GLboolean texture_format_rgba;
+   GLint level;
+   GLint __pad[4];
+};
+
+extern __DRIEGLImage *_eglClientGetImageData(__DRIEGLImageHandle handle);
+
+#endif /* EGLIMAGE_DRI_INCLUDED */
diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 518091a2d1..42d8726d71 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -54,7 +54,11 @@
 #include "eglglobals.h"
 #include "egllog.h"
 #include "eglsurface.h"
+#include "eglimage.h"
 
+#include "EGL/internal/eglimage_dri.h"
+
+#define MAX_DEPTH 32
 #define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
 
 /** subclass of _EGLDriver */
@@ -73,6 +77,8 @@ struct xdri_egl_display
 
    __GLXscreenConfigs *psc;
    EGLint scr;
+
+   const __GLcontextModes *imageConfigs[MAX_DEPTH + 1];
 };
 
 
@@ -98,6 +104,16 @@ struct xdri_egl_surface
 };
 
 
+/** subclass of _EGLImage */
+struct xdri_egl_image
+{
+   _EGLImage Base;   /**< base class */
+
+   Drawable pixmap;
+   __GLXDRIdrawable *driDrawable;
+};
+
+
 /** subclass of _EGLConfig */
 struct xdri_egl_config
 {
@@ -147,6 +163,14 @@ lookup_config(_EGLConfig *conf)
 }
 
 
+/** Map EGLImage handle to xdri_egl_image object */
+static INLINE struct xdri_egl_image *
+lookup_image(_EGLImage *img)
+{
+   return (struct xdri_egl_image *) img;
+}
+
+
 /** Get size of given window */
 static Status
 get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
@@ -162,6 +186,62 @@ get_drawable_size(Display *dpy, Drawable d, uint *width, uint *height)
 }
 
 
+#if EGL_KHR_image_base
+/** Get depth of given window */
+static Status
+get_drawable_depth(Display *dpy, Drawable d, uint *depth_ret)
+{
+   Window root;
+   Status stat;
+   int xpos, ypos;
+   unsigned int w, h, bw, depth;
+   stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
+   *depth_ret = depth;
+   return stat;
+}
+
+
+/**
+ * The config of a pixmap must be guessed from its depth.  Do the guess once
+ * for all depths.
+ */
+static void
+find_image_configs(_EGLDisplay *dpy, const __GLcontextModes *modes)
+{
+   struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
+   EGLint depth;
+
+   for (depth = 0; depth < MAX_DEPTH + 1; depth++) {
+      const __GLcontextModes *m;
+
+      for (m = modes; m; m = m->next) {
+         /* the depth of a pixmap might not include alpha */
+         if (m->rgbBits != depth && (m->rgbBits - m->alphaBits) != depth)
+            continue;
+         if (!m->visualID)
+            continue;
+
+         if (depth == 32) {
+            if (m->bindToTextureRgba) {
+               xdri_dpy->imageConfigs[depth] = m;
+               break;
+            }
+         }
+
+         if (m->bindToTextureRgb) {
+            xdri_dpy->imageConfigs[depth] = m;
+            break;
+         }
+      }
+
+      if (m)
+         _eglLog(_EGL_DEBUG, "Use mode 0x%02x for depth %d",
+                 m->visualID, depth);
+   }
+}
+#endif /* EGL_KHR_image_base */
+
+
 /**
  * Produce a set of EGL configs.
  */
@@ -275,6 +355,15 @@ xdri_eglInitialize(_EGLDriver *drv, _EGLDisplay *dpy,
                           EGL_OPENGL_ES2_BIT |
                           EGL_OPENVG_BIT);
 
+#if EGL_KHR_image_base
+   /* must be called after DriverData is set */
+   find_image_configs(dpy, psc->configs);
+
+   dpy->Extensions.KHR_image = EGL_TRUE;
+   dpy->Extensions.KHR_image_base = EGL_TRUE;
+   dpy->Extensions.KHR_image_pixmap = EGL_TRUE;
+#endif
+
    /* we're supporting EGL 1.4 */
    *minor = 1;
    *major = 4;
@@ -529,10 +618,108 @@ xdri_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw)
 
    xdri_dpy->psc->driScreen->swapBuffers(xdri_surf->driDrawable);
 
+   return EGL_TRUE;
+} 
+
+
+#if EGL_KHR_image_base
+
+
+static _EGLImage *
+xdri_eglCreateImageKHR(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx,
+                       EGLenum target, EGLClientBuffer buffer, const EGLint *attr_list)
+{
+   struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
+   struct xdri_egl_image *xdri_img;
+   __DRIEGLImage *driImage;
+   EGLint err = EGL_SUCCESS;
+   const __GLcontextModes *mode;
+   uint depth;
+
+   xdri_img = CALLOC_STRUCT(xdri_egl_image);
+   if (!xdri_img) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateImageKHR");
+      return NULL;
+   }
+
+   switch (target) {
+   case EGL_NATIVE_PIXMAP_KHR:
+      if (ctx) {
+         err = EGL_BAD_PARAMETER;
+         break;
+      }
+      xdri_img->pixmap = (Pixmap) buffer;
+      break;
+   default:
+      err = EGL_BAD_PARAMETER;
+      break;
+   }
+
+   if (err != EGL_SUCCESS) {
+      _eglError(EGL_BAD_PARAMETER, "eglCreateImageKHR");
+      free(xdri_img);
+      return NULL;
+   }
+
+   if (!_eglInitImage(drv, &xdri_img->Base, attr_list)) {
+      free(xdri_img);
+      return NULL;
+   }
+   if (!get_drawable_depth(xdri_dpy->dpy, xdri_img->pixmap, &depth) ||
+       depth > MAX_DEPTH) {
+      free(xdri_img);
+      return NULL;
+   }
+   mode = xdri_dpy->imageConfigs[depth];
+   if (!mode) {
+      free(xdri_img);
+      return NULL;
+   }
+
+   driImage = CALLOC_STRUCT(__DRIEGLImageRec);
+   if (!driImage) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateImageKHR");
+      free(xdri_img);
+      return NULL;
+   }
+
+   xdri_img->driDrawable =
+      xdri_dpy->psc->driScreen->createDrawable(xdri_dpy->psc,
+                                               (XID) xdri_img->pixmap,
+                                               (GLXDrawable) xdri_img->pixmap,
+                                               mode);
+   if (!xdri_img->driDrawable) {
+      free(driImage);
+      free(xdri_img);
+      return NULL;
+   }
+
+   driImage->magic = __DRI_EGL_IMAGE_MAGIC;
+   driImage->drawable = xdri_img->driDrawable->driDrawable;
+   driImage->texture_format_rgba = (depth == 32 && mode->bindToTextureRgba);
+   driImage->level = 0;
+
+   xdri_img->Base.ClientData = (void *) driImage;
+
+   return &xdri_img->Base;
+}
+
+
+static EGLBoolean
+xdri_eglDestroyImageKHR(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img)
+{
+   struct xdri_egl_image *xdri_img = lookup_image(img);
+
+   free(xdri_img->Base.ClientData);
+   xdri_img->driDrawable->destroyDrawable(xdri_img->driDrawable);
+   free(xdri_img);
    return EGL_TRUE;
 }
 
 
+#endif /* EGL_KHR_image_base */
+
+
 static void
 xdri_Unload(_EGLDriver *drv)
 {
@@ -567,6 +754,10 @@ _eglMain(const char *args)
    xdri_drv->Base.API.BindTexImage = xdri_eglBindTexImage;
    xdri_drv->Base.API.ReleaseTexImage = xdri_eglReleaseTexImage;
    xdri_drv->Base.API.SwapBuffers = xdri_eglSwapBuffers;
+#if EGL_KHR_image_base
+   xdri_drv->Base.API.CreateImageKHR = xdri_eglCreateImageKHR;
+   xdri_drv->Base.API.DestroyImageKHR = xdri_eglDestroyImageKHR;
+#endif /* EGL_KHR_image_base */
 
    xdri_drv->Base.Name = "X/DRI";
    xdri_drv->Base.Unload = xdri_Unload;
-- 
cgit v1.2.3


From 77e2b23ea62840b90b4fb8dddf40461d91aa4a04 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Mon, 14 Sep 2009 13:32:29 +0800
Subject: egl_xdri: Flush commands on context switch and buffer swap.

The corresponding DRI functions does not flush for us.
---
 src/egl/drivers/xdri/egl_xdri.c | 29 +++++++++++++++++++++++------
 1 file changed, 23 insertions(+), 6 deletions(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 42d8726d71..682a2c3a31 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -65,6 +65,7 @@
 struct xdri_egl_driver
 {
    _EGLDriver Base;   /**< base class */
+   void (*FlushCurrentContext)(void);
 };
 
 
@@ -495,13 +496,23 @@ static EGLBoolean
 xdri_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *d,
                     _EGLSurface *r, _EGLContext *context)
 {
+   struct xdri_egl_driver *xdri_driver = xdri_egl_driver(drv);
    struct xdri_egl_context *xdri_ctx = lookup_context(context);
    struct xdri_egl_surface *draw = lookup_surface(d);
    struct xdri_egl_surface *read = lookup_surface(r);
+   _EGLContext *old = _eglGetCurrentContext();
+
+   /* an unlinked context will be invalid after context switch */
+   if (!_eglIsContextLinked(old))
+      old = NULL;
 
    if (!_eglMakeCurrent(drv, dpy, d, r, context))
       return EGL_FALSE;
 
+   /* flush before context switch */
+   if (old && old != context && xdri_driver->FlushCurrentContext)
+      xdri_driver->FlushCurrentContext();
+
    /* the symbol is defined in libGL.so */
    _glapi_check_multithread();
 
@@ -512,12 +523,9 @@ xdri_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *d,
          return EGL_FALSE;
       }
    }
-   else {
-      _EGLContext *old = _eglGetCurrentContext();
-      if (old) {
-         xdri_ctx = lookup_context(old);
-         xdri_ctx->driContext->unbindContext(xdri_ctx->driContext);
-      }
+   else if (old) {
+      xdri_ctx = lookup_context(old);
+      xdri_ctx->driContext->unbindContext(xdri_ctx->driContext);
    }
 
    return EGL_TRUE;
@@ -613,9 +621,14 @@ xdri_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
 static EGLBoolean
 xdri_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw)
 {
+   struct xdri_egl_driver *xdri_driver = xdri_egl_driver(drv);
    struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
    struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
 
+   /* swapBuffers does not flush commands */
+   if (draw == _eglGetCurrentSurface(EGL_DRAW))
+      xdri_driver->FlushCurrentContext();
+
    xdri_dpy->psc->driScreen->swapBuffers(xdri_surf->driDrawable);
 
    return EGL_TRUE;
@@ -762,5 +775,9 @@ _eglMain(const char *args)
    xdri_drv->Base.Name = "X/DRI";
    xdri_drv->Base.Unload = xdri_Unload;
 
+   /* we need a way to flush commands */
+   xdri_drv->FlushCurrentContext =
+      (void (*)(void)) xdri_eglGetProcAddress("glFlush");
+
    return &xdri_drv->Base;
 }
-- 
cgit v1.2.3


From b4b8800315637d9218a81c76f09df7d601710d29 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Tue, 15 Sep 2009 12:40:54 +0800
Subject: egl_xdri: Check that FlushCurrentContext is available.

---
 src/egl/drivers/xdri/egl_xdri.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/egl/drivers')

diff --git a/src/egl/drivers/xdri/egl_xdri.c b/src/egl/drivers/xdri/egl_xdri.c
index 682a2c3a31..9793e4f8b4 100644
--- a/src/egl/drivers/xdri/egl_xdri.c
+++ b/src/egl/drivers/xdri/egl_xdri.c
@@ -626,7 +626,8 @@ xdri_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw)
    struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
 
    /* swapBuffers does not flush commands */
-   if (draw == _eglGetCurrentSurface(EGL_DRAW))
+   if (draw == _eglGetCurrentSurface(EGL_DRAW) &&
+       xdri_driver->FlushCurrentContext)
       xdri_driver->FlushCurrentContext();
 
    xdri_dpy->psc->driScreen->swapBuffers(xdri_surf->driDrawable);
-- 
cgit v1.2.3