From 1ed1027e886980b9b0f48fa6bfcf3d6e209c7787 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Tue, 27 May 2008 13:45:41 -0600
Subject: assorted changes to compile with new EGL 1.4 headers (untested)

---
 src/egl/main/eglsurface.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 874f318e96..cd5d9757f9 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -207,25 +207,27 @@ _eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
 void
 _eglSaveSurface(_EGLSurface *surf)
 {
+   EGLuint key = _eglHashGenKey(_eglGlobal.Contexts);
    assert(surf);
    assert(!surf->Handle);
-   surf->Handle = _eglHashGenKey(_eglGlobal.Contexts);
+   surf->Handle = (EGLSurface) key;
    assert(surf->Handle);
-   _eglHashInsert(_eglGlobal.Surfaces, surf->Handle, surf);
+   _eglHashInsert(_eglGlobal.Surfaces, key, surf);
 }
 
 
 void
 _eglRemoveSurface(_EGLSurface *surf)
 {
-   _eglHashRemove(_eglGlobal.Surfaces, surf->Handle);
+   _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surf->Handle);
 }
 
 
 _EGLSurface *
 _eglLookupSurface(EGLSurface surf)
 {
-   _EGLSurface *c = (_EGLSurface *) _eglHashLookup(_eglGlobal.Surfaces, surf);
+   _EGLSurface *c = (_EGLSurface *) _eglHashLookup(_eglGlobal.Surfaces,
+                                                   (EGLuint) surf);
    return c;
 }
 
@@ -439,7 +441,7 @@ _eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
 {
    _EGLSurface *surf = _eglLookupSurface(surface);
    if (surf) {
-      _eglHashRemove(_eglGlobal.Surfaces, surface);
+      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
       if (surf->IsBound) {
          surf->DeletePending = EGL_TRUE;
       }
-- 
cgit v1.2.3


From 209a557574b9833da3d6ac299c83f4cddfff6910 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Tue, 27 May 2008 14:17:40 -0600
Subject: fix typo: s/Contexts/Surfaces/

---
 src/egl/main/eglsurface.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index cd5d9757f9..134afa7cbd 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -207,7 +207,7 @@ _eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
 void
 _eglSaveSurface(_EGLSurface *surf)
 {
-   EGLuint key = _eglHashGenKey(_eglGlobal.Contexts);
+   EGLuint key = _eglHashGenKey(_eglGlobal.Surfaces);
    assert(surf);
    assert(!surf->Handle);
    surf->Handle = (EGLSurface) key;
-- 
cgit v1.2.3


From 721ba15bf4596b2e9589e7656005b387724875c3 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Tue, 27 May 2008 14:33:54 -0600
Subject: added _eglGet*Handle() functions

These are the inverse of the _eglLookup*() functions.
Returns the public handle for a private surface/config/display/etc.
Removes glapi.c's direct access of private fields.
---
 src/egl/main/eglapi.c     | 15 +++------------
 src/egl/main/eglconfig.c  | 12 ++++++++++++
 src/egl/main/eglconfig.h  |  4 ++++
 src/egl/main/egldisplay.c | 15 +++++++++++++++
 src/egl/main/egldisplay.h |  4 ++++
 src/egl/main/eglsurface.c | 20 ++++++++++++++++++++
 src/egl/main/eglsurface.h |  4 ++++
 7 files changed, 62 insertions(+), 12 deletions(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 4df31cc03f..e4eec26de0 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -53,10 +53,7 @@ eglGetDisplay(NativeDisplayType displayName)
    _EGLDisplay *dpy;
    _eglInitGlobals();
    dpy = _eglNewDisplay(displayName);
-   if (dpy)
-      return dpy->Handle;
-   else
-      return EGL_NO_DISPLAY;
+   return _eglGetDisplayHandle(dpy);
 }
 
 
@@ -269,10 +266,7 @@ EGLDisplay EGLAPIENTRY
 eglGetCurrentDisplay(void)
 {
    _EGLDisplay *dpy = _eglGetCurrentDisplay();
-   if (dpy)
-      return dpy->Handle;
-   else
-      return EGL_NO_DISPLAY;
+   return _eglGetDisplayHandle(dpy);
 }
 
 
@@ -288,10 +282,7 @@ EGLSurface EGLAPIENTRY
 eglGetCurrentSurface(EGLint readdraw)
 {
    _EGLSurface *s = _eglGetCurrentSurface(readdraw);
-   if (s)
-      return s->Handle;
-   else
-      return EGL_NO_SURFACE;
+   return _eglGetSurfaceHandle(s);
 }
 
 
diff --git a/src/egl/main/eglconfig.c b/src/egl/main/eglconfig.c
index a74cd23113..1b49f7afd9 100644
--- a/src/egl/main/eglconfig.c
+++ b/src/egl/main/eglconfig.c
@@ -101,8 +101,20 @@ _eglInitConfig(_EGLConfig *config, EGLint id)
 }
 
 
+/**
+ * Return the public handle for an internal _EGLConfig.
+ * This is the inverse of _eglLookupConfig().
+ */
+EGLConfig
+_eglGetConfigHandle(_EGLConfig *config)
+{
+   return  config ? config->Handle : 0;
+}
+
+
 /**
  * Given an EGLConfig handle, return the corresponding _EGLConfig object.
+ * This is the inverse of _eglGetConfigHandle().
  */
 _EGLConfig *
 _eglLookupConfig(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config)
diff --git a/src/egl/main/eglconfig.h b/src/egl/main/eglconfig.h
index 88e44dfc7d..4a80612980 100644
--- a/src/egl/main/eglconfig.h
+++ b/src/egl/main/eglconfig.h
@@ -27,6 +27,10 @@ extern void
 _eglInitConfig(_EGLConfig *config, EGLint id);
 
 
+extern EGLConfig
+_eglGetConfigHandle(_EGLConfig *config);
+
+
 extern _EGLConfig *
 _eglLookupConfig(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config);
 
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index 59d0bd3dc3..fd24f22273 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -39,9 +39,24 @@ _eglNewDisplay(NativeDisplayType displayName)
 }
 
 
+/**
+ * Return the public handle for an internal _EGLDisplay.
+ * This is the inverse of _eglLookupDisplay().
+ */
+EGLDisplay
+_eglGetDisplayHandle(_EGLDisplay *display)
+{
+   if (display)
+      return display->Handle;
+   else
+      return EGL_NO_DISPLAY;
+}
+
+ 
 /**
  * Return the _EGLDisplay object that corresponds to the given public/
  * opaque display handle.
+ * This is the inverse of _eglGetDisplayHandle().
  */
 _EGLDisplay *
 _eglLookupDisplay(EGLDisplay dpy)
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 1a03fdd4ad..fe7b788455 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -24,6 +24,10 @@ extern _EGLDisplay *
 _eglNewDisplay(NativeDisplayType displayName);
 
 
+EGLDisplay
+_eglGetDisplayHandle(_EGLDisplay *display);
+
+
 extern _EGLDisplay *
 _eglLookupDisplay(EGLDisplay dpy);
 
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 134afa7cbd..1dbb12ecfe 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -223,6 +223,26 @@ _eglRemoveSurface(_EGLSurface *surf)
 }
 
 
+
+/**
+ * Return the public handle for an internal _EGLSurface.
+ * This is the inverse of _eglLookupSurface().
+ */
+EGLSurface
+_eglGetSurfaceHandle(_EGLSurface *surface)
+{
+   if (surface)
+      return surface->Handle;
+   else
+      return EGL_NO_SURFACE;
+}
+
+
+/**
+ * Return the private _EGLSurface which corresponds to a public EGLSurface
+ * handle.
+ * This is the inverse of _eglGetSurfaceHandle().
+ */
 _EGLSurface *
 _eglLookupSurface(EGLSurface surf)
 {
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index 79abeca0b2..df1e70122e 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -51,6 +51,10 @@ extern void
 _eglRemoveSurface(_EGLSurface *surf);
 
 
+extern EGLSurface
+_eglGetSurfaceHandle(_EGLSurface *surface);
+
+
 extern _EGLSurface *
 _eglLookupSurface(EGLSurface surf);
  
-- 
cgit v1.2.3


From 274dd381a30072ecb8341cfc41e63bb6e39419ac Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 30 May 2008 11:40:48 -0600
Subject: egl: fix width/height tests

---
 src/egl/main/eglsurface.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 1dbb12ecfe..796d62f2b9 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -175,7 +175,7 @@ _eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
       }
    }
 
-   if (width <= 0 || height <= 0) {
+   if (width < 0 || height < 0) {
       _eglError(EGL_BAD_ATTRIBUTE, func);
       return EGL_FALSE;
    }
-- 
cgit v1.2.3


From fbd6e86b8f3c9bdeae7581d8d852b4df66e4b42c Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Fri, 20 Jun 2008 10:20:25 -0600
Subject: egl: implment EGL_LARGEST_PBUFFER query

---
 src/egl/main/egldriver.h  | 2 ++
 src/egl/main/eglsurface.c | 5 ++++-
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/egldriver.h b/src/egl/main/egldriver.h
index 7827ca3ae3..4066c6ec1d 100644
--- a/src/egl/main/egldriver.h
+++ b/src/egl/main/egldriver.h
@@ -39,6 +39,8 @@ struct _egl_driver
    _EGLAPI API;  /**< EGL API dispatch table */
 
    _EGLExtensions Extensions;
+
+   int LargestPbuffer;
 };
 
 
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 796d62f2b9..3777049ca6 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -8,6 +8,7 @@
 #include <string.h>
 #include "eglcontext.h"
 #include "eglconfig.h"
+#include "egldriver.h"
 #include "eglglobals.h"
 #include "eglhash.h"
 #include "egllog.h"
@@ -319,7 +320,9 @@ _eglQuerySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
    case EGL_CONFIG_ID:
       *value = GET_CONFIG_ATTRIB(surface->Config, EGL_CONFIG_ID);
       return EGL_TRUE;
-   /*XXX case EGL_LARGEST_PBUFFER:*/
+   case EGL_LARGEST_PBUFFER:
+      *value = drv->LargestPbuffer;
+      return EGL_TRUE;
    case EGL_SURFACE_TYPE:
       *value = surface->Type;
       return EGL_TRUE;
-- 
cgit v1.2.3


From b36f90657370296b45c27d33d60c89fa31dc1d76 Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Mon, 1 Sep 2008 13:08:12 -0600
Subject: egl: additional error checking in _eglBind/ReleaseTexImage()

---
 src/egl/main/eglsurface.c | 75 +++++++++++++++++++++++++++++++++++++++--------
 src/egl/main/eglsurface.h |  1 +
 2 files changed, 64 insertions(+), 12 deletions(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 3777049ca6..6905acac50 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -61,6 +61,12 @@ _eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
       return EGL_FALSE;
    }
 
+   if ((GET_CONFIG_ATTRIB(conf, EGL_SURFACE_TYPE) & type) == 0) {
+      /* The config can't be used to create a surface of this type */
+      _eglError(EGL_BAD_CONFIG, func);
+      return EGL_FALSE;
+   }
+
    /*
     * Parse attribute list.  Different kinds of surfaces support different
     * attributes.
@@ -277,12 +283,7 @@ _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
    /* Basically just do error checking here.  Drivers have to do the
     * actual buffer swap.
     */
-   _EGLContext *context = _eglGetCurrentContext();
    _EGLSurface *surface = _eglLookupSurface(draw);
-   if (context && context->DrawSurface != surface) {
-      _eglError(EGL_BAD_SURFACE, "eglSwapBuffers");
-      return EGL_FALSE;
-   }
    if (surface == NULL) {
       _eglError(EGL_BAD_SURFACE, "eglSwapBuffers");
       return EGL_FALSE;
@@ -484,7 +485,8 @@ _eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
  * Default fallback routine - drivers might override this.
  */
 EGLBoolean
-_eglSurfaceAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf, EGLint attribute, EGLint value)
+_eglSurfaceAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+                  EGLint attribute, EGLint value)
 {
    _EGLSurface *surface = _eglLookupSurface(surf);
 
@@ -506,18 +508,67 @@ _eglSurfaceAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf, EGLint attri
 
 
 EGLBoolean
-_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+_eglBindTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+                 EGLint buffer)
 {
-   /* XXX unfinished */
-   return EGL_FALSE;
+   /* 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) {
+      _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
+      return EGL_FALSE;
+   }
+
+   if (surface->TextureFormat == EGL_NO_TEXTURE) {
+      _eglError(EGL_BAD_MATCH, "eglBindTexImage");
+      return EGL_FALSE;
+   }
+
+   if (buffer != EGL_BACK_BUFFER) {
+      _eglError(EGL_BAD_PARAMETER, "eglBindTexImage");
+      return EGL_FALSE;
+   }
+
+   surface->BoundToTexture = EGL_TRUE;
+
+   return EGL_TRUE;
 }
 
 
 EGLBoolean
-_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+_eglReleaseTexImage(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+                    EGLint buffer)
 {
-   /* XXX unfinished */
-   return EGL_FALSE;
+   /* 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) {
+      _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
+      return EGL_FALSE;
+   }
+
+   if (surface->TextureFormat == EGL_NO_TEXTURE) {
+      _eglError(EGL_BAD_MATCH, "eglBindTexImage");
+      return EGL_FALSE;
+   }
+
+   if (buffer != EGL_BACK_BUFFER) {
+      _eglError(EGL_BAD_PARAMETER, "eglReleaseTexImage");
+      return EGL_FALSE;
+   }
+
+   if (!surface->BoundToTexture) {
+      _eglError(EGL_BAD_SURFACE, "eglReleaseTexImage");
+      return EGL_FALSE;
+   }
+
+   surface->BoundToTexture = EGL_FALSE;
+
+   return EGL_TRUE;
 }
 
 
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index df1e70122e..50f965b5cb 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -16,6 +16,7 @@ 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 */
    EGLint Width, Height;
-- 
cgit v1.2.3


From 75da80b29556e6dbbba21e5297ca440e475f65cb Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Fri, 17 Jul 2009 11:41:02 -0600
Subject: egl: Support per-thread info.

This commit introduces a "current" system to manage per-thread info.  It
uses TLS, if GLX_USE_TLS is defined, or pthread, if PTHREADS is defined.
If none of them are defined, it uses a dummy implementation that is just
like before.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 configs/default           |   2 +-
 src/egl/main/Makefile     |   2 +
 src/egl/main/eglapi.c     |  16 +++++--
 src/egl/main/eglcontext.c |  14 ++----
 src/egl/main/eglcontext.h |   4 --
 src/egl/main/egldisplay.c |  11 -----
 src/egl/main/egldisplay.h |   4 --
 src/egl/main/eglglobals.c | 113 ++--------------------------------------------
 src/egl/main/eglglobals.h |  31 +------------
 src/egl/main/eglsurface.c |  18 --------
 src/egl/main/eglsurface.h |   4 --
 11 files changed, 23 insertions(+), 196 deletions(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/configs/default b/configs/default
index a8996702d7..60638d739d 100644
--- a/configs/default
+++ b/configs/default
@@ -105,7 +105,7 @@ GALLIUM_STATE_TRACKERS_DIRS = glx
 # Library dependencies
 #EXTRA_LIB_PATH ?=
 GL_LIB_DEPS     = $(EXTRA_LIB_PATH) -lX11 -lXext -lm -lpthread
-EGL_LIB_DEPS    = $(EXTRA_LIB_PATH) -lX11 -ldl
+EGL_LIB_DEPS    = $(EXTRA_LIB_PATH) -lX11 -ldl -lpthread
 OSMESA_LIB_DEPS = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB)
 GLU_LIB_DEPS    = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB) -lm
 GLUT_LIB_DEPS   = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GLU_LIB) -l$(GL_LIB) -lX11 -lXmu -lXi -lm
diff --git a/src/egl/main/Makefile b/src/egl/main/Makefile
index 4034b28e91..e1ff8794b3 100644
--- a/src/egl/main/Makefile
+++ b/src/egl/main/Makefile
@@ -11,6 +11,7 @@ HEADERS = \
 	eglconfig.h \
 	eglconfigutil.h \
 	eglcontext.h \
+	eglcurrent.h \
 	egldefines.h \
 	egldisplay.h \
 	egldriver.h \
@@ -29,6 +30,7 @@ SOURCES = \
 	eglconfig.c \
 	eglconfigutil.c \
 	eglcontext.c \
+	eglcurrent.c \
 	egldisplay.c \
 	egldriver.c \
 	eglglobals.c \
diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 9df938e188..8f4a489b91 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -321,7 +321,8 @@ eglGetError(void)
 {
    _EGLThreadInfo *t = _eglGetCurrentThread();
    EGLint e = t->LastError;
-   t->LastError = EGL_SUCCESS;
+   if (!_eglIsCurrentThreadDummy())
+      t->LastError = EGL_SUCCESS;
    return e;
 }
 
@@ -546,6 +547,9 @@ eglBindAPI(EGLenum api)
 {
    _EGLThreadInfo *t = _eglGetCurrentThread();
 
+   if (_eglIsCurrentThreadDummy())
+      return _eglError(EGL_BAD_ALLOC, "eglBindAPI");
+
    switch (api) {
 #ifdef EGL_VERSION_1_4
    case EGL_OPENGL_API:
@@ -603,15 +607,19 @@ eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
 EGLBoolean
 eglReleaseThread(void)
 {
-   _EGLThreadInfo *t = _eglGetCurrentThread();
-   EGLDisplay dpy = eglGetCurrentDisplay();
+   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);
    }
-   _eglDeleteThreadData(t);
+   _eglDestroyCurrentThread();
    return EGL_TRUE;
 }
 
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 461679db09..5e24b02a58 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -108,17 +108,6 @@ _eglLookupContext(EGLContext ctx)
 }
 
 
-/**
- * Return the currently bound _EGLContext object, or NULL.
- */
-_EGLContext *
-_eglGetCurrentContext(void)
-{
-   _EGLThreadInfo *t = _eglGetCurrentThread();
-   return t->CurrentContext;
-}
-
-
 /**
  * Just a placeholder/demo function.  Real driver will never use this!
  */
@@ -219,6 +208,9 @@ _eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
    _EGLSurface *oldDrawSurface = _eglGetCurrentSurface(EGL_DRAW);
    _EGLSurface *oldReadSurface = _eglGetCurrentSurface(EGL_READ);
 
+   if (_eglIsCurrentThreadDummy())
+      return _eglError(EGL_BAD_ALLOC, "eglMakeCurrent");
+
    /* error checking */
    if (ctx) {
       if (draw == NULL || read == NULL) {
diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 34fee9c637..5c8403153b 100644
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -47,10 +47,6 @@ extern _EGLContext *
 _eglLookupContext(EGLContext ctx);
  
 
-extern _EGLContext *
-_eglGetCurrentContext(void);
-
-
 extern EGLContext
 _eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list);
 
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index 47a2323eaf..01f67f6e47 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -86,17 +86,6 @@ _eglSaveDisplay(_EGLDisplay *dpy)
 }
 
 
-_EGLDisplay *
-_eglGetCurrentDisplay(void)
-{
-   _EGLContext *ctx = _eglGetCurrentContext();
-   if (ctx)
-      return ctx->Display;
-   else
-      return NULL;
-}
-
-
 /**
  * Free all the data hanging of an _EGLDisplay object, but not
  * the object itself.
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index ff623ee1c6..69f0d130ef 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -45,10 +45,6 @@ extern void
 _eglSaveDisplay(_EGLDisplay *dpy);
 
 
-extern _EGLDisplay *
-_eglGetCurrentDisplay(void);
-
-
 extern void
 _eglCleanupDisplay(_EGLDisplay *disp);
 
diff --git a/src/egl/main/eglglobals.c b/src/egl/main/eglglobals.c
index b770e55dbd..55de394ef5 100644
--- a/src/egl/main/eglglobals.c
+++ b/src/egl/main/eglglobals.c
@@ -1,6 +1,6 @@
-#include <stdio.h>
 #include <stdlib.h>
 #include "eglglobals.h"
+#include "egllog.h"
 
 struct _egl_global _eglGlobal = 
 {
@@ -22,8 +22,8 @@ _eglInitGlobals(void)
 
       _eglGlobal.ClientAPIsMask = 0x0;
 
-      /* XXX temporary */
-      _eglGlobal.ThreadInfo = _eglNewThreadInfo();
+      if (!_eglInitCurrent())
+         _eglLog(_EGL_FATAL, "failed to initialize \"current\" system");
    }
 }
 
@@ -34,113 +34,8 @@ _eglInitGlobals(void)
 void
 _eglDestroyGlobals(void)
 {
+   _eglFiniCurrent();
    /* XXX TODO walk over table entries, deleting each */
    _eglDeleteHashTable(_eglGlobal.Displays);
    _eglDeleteHashTable(_eglGlobal.Surfaces);
 }
-
-
-/**
- * Allocate and init a new _EGLThreadInfo object.
- */
-_EGLThreadInfo *
-_eglNewThreadInfo(void)
-{
-   _EGLThreadInfo *t = (_EGLThreadInfo *) calloc(1, sizeof(_EGLThreadInfo));
-   if (t) {
-      t->CurrentContext = EGL_NO_CONTEXT;
-      t->LastError = EGL_SUCCESS;
-      t->CurrentAPI = EGL_OPENGL_ES_API;  /* default, per EGL spec */
-   }
-   return t;
-}
-
-
-/**
- * Delete/free a _EGLThreadInfo object.
- */
-void
-_eglDeleteThreadData(_EGLThreadInfo *t)
-{
-   free(t);
-}
-
-
-
-/**
- * Return pointer to calling thread's _EGLThreadInfo object.
- * Create a new one if needed.
- * Should never return NULL.
- */
-_EGLThreadInfo *
-_eglGetCurrentThread(void)
-{
-   _eglInitGlobals();
-
-   /* XXX temporary */
-   return _eglGlobal.ThreadInfo;
-}
-
-
-/**
- * Record EGL error code.
- */
-void
-_eglError(EGLint errCode, const char *msg)
-{
-   _EGLThreadInfo *t = _eglGetCurrentThread();
-   const char *s;
-
-   if (t->LastError == EGL_SUCCESS) {
-      t->LastError = errCode;
-
-      switch (errCode) {
-      case EGL_BAD_ACCESS:
-         s = "EGL_BAD_ACCESS";
-         break;
-      case EGL_BAD_ALLOC:
-         s = "EGL_BAD_ALLOC";
-         break;
-      case EGL_BAD_ATTRIBUTE:
-         s = "EGL_BAD_ATTRIBUTE";
-         break;
-      case EGL_BAD_CONFIG:
-         s = "EGL_BAD_CONFIG";
-         break;
-      case EGL_BAD_CONTEXT:
-         s = "EGL_BAD_CONTEXT";
-         break;
-      case EGL_BAD_CURRENT_SURFACE:
-         s = "EGL_BAD_CURRENT_SURFACE";
-         break;
-      case EGL_BAD_DISPLAY:
-         s = "EGL_BAD_DISPLAY";
-         break;
-      case EGL_BAD_MATCH:
-         s = "EGL_BAD_MATCH";
-         break;
-      case EGL_BAD_NATIVE_PIXMAP:
-         s = "EGL_BAD_NATIVE_PIXMAP";
-         break;
-      case EGL_BAD_NATIVE_WINDOW:
-         s = "EGL_BAD_NATIVE_WINDOW";
-         break;
-      case EGL_BAD_PARAMETER:
-         s = "EGL_BAD_PARAMETER";
-         break;
-      case EGL_BAD_SURFACE:
-         s = "EGL_BAD_SURFACE";
-         break;
-      case EGL_BAD_SCREEN_MESA:
-         s = "EGL_BAD_SCREEN_MESA";
-         break;
-      case EGL_BAD_MODE_MESA:
-         s = "EGL_BAD_MODE_MESA";
-         break;
-      default:
-         s = "other";
-      }
-      /* XXX temporary */
-      fprintf(stderr, "EGL user error 0x%x (%s) in %s\n", errCode, s, msg);
-   }
-}
diff --git a/src/egl/main/eglglobals.h b/src/egl/main/eglglobals.h
index 14d8ea487a..fbb55c23f0 100644
--- a/src/egl/main/eglglobals.h
+++ b/src/egl/main/eglglobals.h
@@ -3,17 +3,7 @@
 
 #include "egltypedefs.h"
 #include "eglhash.h"
-
-
-/**
- * Per-thread info
- */
-struct _egl_thread_info
-{
-   EGLint LastError;
-   _EGLContext *CurrentContext;
-   EGLenum CurrentAPI;
-};
+#include "eglcurrent.h"
 
 
 /**
@@ -33,9 +23,6 @@ struct _egl_global
 
    char ClientAPIs[1000];   /**< updated by eglQueryString */
 
-   /* XXX temporary - should be thread-specific data (TSD) */
-   _EGLThreadInfo *ThreadInfo;
-
    EGLint NumDrivers;
    _EGLDriver *Drivers[10];
 };
@@ -52,20 +39,4 @@ extern void
 _eglDestroyGlobals(void);
 
 
-extern _EGLThreadInfo *
-_eglNewThreadInfo(void);
-
-
-extern void
-_eglDeleteThreadData(_EGLThreadInfo *t);
-
-
-extern _EGLThreadInfo *
-_eglGetCurrentThread(void);
-
-
-extern void
-_eglError(EGLint errCode, const char *msg);
-
-
 #endif /* EGLGLOBALS_INCLUDED */
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 6905acac50..964288aac8 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -259,24 +259,6 @@ _eglLookupSurface(EGLSurface surf)
 }
 
 
-_EGLSurface *
-_eglGetCurrentSurface(EGLint readdraw)
-{
-   _EGLContext *ctx = _eglGetCurrentContext();
-   if (ctx) {
-      switch (readdraw) {
-      case EGL_DRAW:
-         return ctx->DrawSurface;
-      case EGL_READ:
-         return ctx->ReadSurface;
-      default:
-         return NULL;
-      }
-   }
-   return NULL;
-}
-
-
 EGLBoolean
 _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 {
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index 50f965b5cb..3b54221bd3 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -60,10 +60,6 @@ extern _EGLSurface *
 _eglLookupSurface(EGLSurface surf);
  
 
-extern _EGLSurface *
-_eglGetCurrentSurface(EGLint readdraw);
-
-
 extern EGLBoolean
 _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw);
 
-- 
cgit v1.2.3


From 18457cb263e3e062e12314e7b3d5c81a7f2ba048 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Fri, 17 Jul 2009 11:48:27 -0600
Subject: egl: Add funtions to link contexts and surfaces to displays.

EGL contexts and surfaces are resources of displays.  They should be
managed by displays.  This commit adds a bunch of functions to
egldisplay.c to help establish the links between contexts/surfaces and
displays.  How links are established is considered opaque outside
display.  Functions like _eglGetSurfaceHandle or _eglLookupSurface are
therefore moved to egldisplay.c, with some small modifications.

The idea is also extended to display.  That is, displays need to link to
themselves to be looked up.

This commit only adds the functions.  A commit to use them should
follow.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/main/eglapi.c     |   2 +
 src/egl/main/eglcontext.c |  25 ------
 src/egl/main/eglcontext.h |  12 +--
 src/egl/main/egldisplay.c | 202 ++++++++++++++++++++++++++++++++++++++++------
 src/egl/main/egldisplay.h |  44 ++++++++--
 src/egl/main/eglsurface.c |  29 +------
 src/egl/main/eglsurface.h |  14 ++--
 7 files changed, 228 insertions(+), 100 deletions(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 332b98adf2..eaee9facd8 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -52,6 +52,8 @@ eglGetDisplay(NativeDisplayType nativeDisplay)
    _EGLDisplay *dpy;
    _eglInitGlobals();
    dpy = _eglNewDisplay(nativeDisplay);
+   if (dpy)
+      _eglLinkDisplay(dpy);
    return _eglGetDisplayHandle(dpy);
 }
 
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 81e69e946b..edcc6a986f 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -83,31 +83,6 @@ _eglRemoveContext(_EGLContext *ctx)
 }
 
 
-/**
- * Return the public handle for the given private context ptr.
- * This is the inverse of _eglLookupContext().
- */
-EGLContext
-_eglGetContextHandle(_EGLContext *ctx)
-{
-   /* just a cast! */
-   return (EGLContext) ctx;
-}
-
-
-/**
- * Return the _EGLContext object that corresponds to the given
- * EGLContext handle.
- * This is the inverse of _eglGetContextHandle().
- */
-_EGLContext *
-_eglLookupContext(EGLContext ctx)
-{
-   /* just a cast since EGLContext is just a void ptr */
-   return (_EGLContext *) ctx;
-}
-
-
 /**
  * Just a placeholder/demo function.  Real driver will never use this!
  */
diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 5c8403153b..6e418dfbbe 100644
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -11,7 +11,9 @@
  */
 struct _egl_context
 {
-   _EGLDisplay *Display; /* who do I belong to? */
+   /* Managed by EGLDisplay for linking */
+   _EGLDisplay *Display;
+   _EGLContext *Next;
 
    _EGLConfig *Config;
 
@@ -39,14 +41,6 @@ extern void
 _eglRemoveContext(_EGLContext *ctx);
 
 
-extern EGLContext
-_eglGetContextHandle(_EGLContext *ctx);
-
-
-extern _EGLContext *
-_eglLookupContext(EGLContext ctx);
- 
-
 extern EGLContext
 _eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list);
 
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index 01f67f6e47..a30e810b4a 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -7,6 +7,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include "eglcontext.h"
+#include "eglsurface.h"
 #include "egldisplay.h"
 #include "egldriver.h"
 #include "eglglobals.h"
@@ -25,11 +26,6 @@ _eglNewDisplay(NativeDisplayType nativeDisplay)
 {
    _EGLDisplay *dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
    if (dpy) {
-      EGLuint key = _eglHashGenKey(_eglGlobal.Displays);
-
-      dpy->Handle = (EGLDisplay) key;
-      _eglHashInsert(_eglGlobal.Displays, key, dpy);
-
       dpy->NativeDisplay = nativeDisplay;
 #if defined(_EGL_PLATFORM_X)
       dpy->Xdpy = (Display *) nativeDisplay;
@@ -46,8 +42,37 @@ _eglNewDisplay(NativeDisplayType nativeDisplay)
 
 
 /**
- * Return the public handle for an internal _EGLDisplay.
- * This is the inverse of _eglLookupDisplay().
+ * Link a display to itself and return the handle of the link.
+ * The handle can be passed to client directly.
+ */
+EGLDisplay
+_eglLinkDisplay(_EGLDisplay *dpy)
+{
+   EGLuint key;
+   key = _eglHashGenKey(_eglGlobal.Displays);
+   assert(key);
+   /* "link" the display to the hash table */
+   _eglHashInsert(_eglGlobal.Displays, key, dpy);
+   dpy->Handle = (EGLDisplay) key;
+
+   return dpy->Handle;
+}
+
+
+/**
+ * Unlink a linked display from itself.
+ * Accessing an unlinked display should generate EGL_BAD_DISPLAY error.
+ */
+void
+_eglUnlinkDisplay(_EGLDisplay *dpy)
+{
+   _eglHashRemove(_eglGlobal.Displays, (EGLuint) dpy->Handle);
+   dpy->Handle = EGL_NO_DISPLAY;
+}
+
+
+/**
+ * Return the handle of a linked display, or EGL_NO_DISPLAY.
  */
 EGLDisplay
 _eglGetDisplayHandle(_EGLDisplay *display)
@@ -60,32 +85,17 @@ _eglGetDisplayHandle(_EGLDisplay *display)
 
  
 /**
- * Return the _EGLDisplay object that corresponds to the given public/
- * opaque display handle.
- * This is the inverse of _eglGetDisplayHandle().
+ * Lookup a handle to find the linked display.
+ * Return NULL if the handle has no corresponding linked display.
  */
 _EGLDisplay *
 _eglLookupDisplay(EGLDisplay dpy)
 {
    EGLuint key = (EGLuint) dpy;
-   if (!_eglGlobal.Displays)
-      return NULL;
    return (_EGLDisplay *) _eglHashLookup(_eglGlobal.Displays, key);
 }
 
 
-void
-_eglSaveDisplay(_EGLDisplay *dpy)
-{
-   EGLuint key = _eglHashGenKey(_eglGlobal.Displays);
-   assert(dpy);
-   assert(!dpy->Handle);
-   dpy->Handle = (EGLDisplay) key;
-   assert(dpy->Handle);
-   _eglHashInsert(_eglGlobal.Displays, key, dpy);
-}
-
-
 /**
  * Free all the data hanging of an _EGLDisplay object, but not
  * the object itself.
@@ -108,3 +118,147 @@ _eglCleanupDisplay(_EGLDisplay *disp)
 
    /* driver deletes the _EGLDisplay object */
 }
+
+
+/**
+ * Link a context to a display and return the handle of the link.
+ * The handle can be passed to client directly.
+ */
+EGLContext
+_eglLinkContext(_EGLContext *ctx, _EGLDisplay *dpy)
+{
+   ctx->Display = dpy;
+   ctx->Next = dpy->ContextList;
+   dpy->ContextList = ctx;
+   return (EGLContext) ctx;
+}
+
+
+/**
+ * Unlink a linked context from its display.
+ * Accessing an unlinked context should generate EGL_BAD_CONTEXT error.
+ */
+void
+_eglUnlinkContext(_EGLContext *ctx)
+{
+   _EGLContext *prev;
+
+   prev = ctx->Display->ContextList;
+   if (prev != ctx) {
+      while (prev) {
+         if (prev->Next == ctx)
+            break;
+         prev = prev->Next;
+      }
+      assert(prev);
+      prev->Next = ctx->Next;
+   }
+   else {
+      ctx->Display->ContextList = ctx->Next;
+   }
+
+   ctx->Next = NULL;
+   ctx->Display = NULL;
+}
+
+
+/**
+ * Return the handle of a linked context, or EGL_NO_CONTEXT.
+ */
+EGLContext
+_eglGetContextHandle(_EGLContext *ctx)
+{
+   return (EGLContext) (ctx && ctx->Display) ? ctx : EGL_NO_CONTEXT;
+}
+
+
+/**
+ * Lookup a handle to find the linked context.
+ * Return NULL if the handle has no corresponding linked context.
+ */
+_EGLContext *
+_eglLookupContext(EGLContext ctx)
+{
+   _EGLContext *context = (_EGLContext *) ctx;
+   return (context && context->Display) ? context : NULL;
+}
+
+
+/**
+ * Link a surface to a display and return the handle of the link.
+ * The handle can be passed to client directly.
+ */
+EGLSurface
+_eglLinkSurface(_EGLSurface *surf, _EGLDisplay *dpy)
+{
+   EGLuint key;
+
+   surf->Display = dpy;
+   surf->Next = dpy->SurfaceList;
+   dpy->SurfaceList = surf;
+
+   key = _eglHashGenKey(_eglGlobal.Surfaces);
+   assert(key);
+   _eglHashInsert(_eglGlobal.Surfaces, key, surf);
+
+   surf->Handle = (EGLSurface) key;
+   return surf->Handle;
+}
+
+
+/**
+ * Unlink a linked surface from its display.
+ * Accessing an unlinked surface should generate EGL_BAD_SURFACE error.
+ */
+void
+_eglUnlinkSurface(_EGLSurface *surf)
+{
+   _EGLSurface *prev;
+
+   _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surf->Handle);
+   surf->Handle = EGL_NO_SURFACE;
+
+   prev = surf->Display->SurfaceList;
+   if (prev != surf) {
+      while (prev) {
+         if (prev->Next == surf)
+            break;
+         prev = prev->Next;
+      }
+      assert(prev);
+      prev->Next = surf->Next;
+   }
+   else {
+      prev = NULL;
+      surf->Display->SurfaceList = surf->Next;
+   }
+
+   surf->Next = NULL;
+   surf->Display = NULL;
+}
+
+
+/**
+ * Return the handle of a linked surface, or EGL_NO_SURFACE.
+ */
+EGLSurface
+_eglGetSurfaceHandle(_EGLSurface *surface)
+{
+   if (surface)
+      return surface->Handle;
+   else
+      return EGL_NO_SURFACE;
+}
+
+
+/**
+ * Lookup a handle to find the linked surface.
+ * Return NULL if the handle has no corresponding linked surface.
+ */
+_EGLSurface *
+_eglLookupSurface(EGLSurface surf)
+{
+   _EGLSurface *c = (_EGLSurface *) _eglHashLookup(_eglGlobal.Surfaces,
+                                                   (EGLuint) surf);
+   return c;
+}
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 69f0d130ef..ac285f52a7 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -23,6 +23,9 @@ struct _egl_display
    EGLint NumConfigs;
    _EGLConfig **Configs;  /* array [NumConfigs] of ptr to _EGLConfig */
 
+   /* lists of linked contexts and surface */
+   _EGLContext *ContextList;
+   _EGLSurface *SurfaceList;
 #ifdef _EGL_PLATFORM_X
    Display *Xdpy;
 #endif
@@ -33,7 +36,15 @@ extern _EGLDisplay *
 _eglNewDisplay(NativeDisplayType displayName);
 
 
-EGLDisplay
+extern EGLDisplay
+_eglLinkDisplay(_EGLDisplay *dpy);
+
+
+extern void
+_eglUnlinkDisplay(_EGLDisplay *dpy);
+
+
+extern EGLDisplay
 _eglGetDisplayHandle(_EGLDisplay *display);
 
 
@@ -42,16 +53,39 @@ _eglLookupDisplay(EGLDisplay dpy);
 
 
 extern void
-_eglSaveDisplay(_EGLDisplay *dpy);
+_eglCleanupDisplay(_EGLDisplay *disp);
+
+
+extern EGLContext
+_eglLinkContext(_EGLContext *ctx, _EGLDisplay *dpy);
 
 
 extern void
-_eglCleanupDisplay(_EGLDisplay *disp);
+_eglUnlinkContext(_EGLContext *ctx);
+
+
+extern EGLContext
+_eglGetContextHandle(_EGLContext *ctx);
+
+
+extern _EGLContext *
+_eglLookupContext(EGLContext ctx);
+
+
+extern EGLSurface
+_eglLinkSurface(_EGLSurface *surf, _EGLDisplay *dpy);
+
+
+extern void
+_eglUnlinkSurface(_EGLSurface *surf);
+
 
+extern EGLSurface
+_eglGetSurfaceHandle(_EGLSurface *);
 
-extern EGLBoolean 
-_eglQueryDisplayMESA(_EGLDriver *drv, EGLDisplay dpy, EGLint attrib, EGLint *value);
 
+extern _EGLSurface *
+_eglLookupSurface(EGLSurface surf);
 
 
 #endif /* EGLDISPLAY_INCLUDED */
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 964288aac8..854f499fce 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -6,6 +6,7 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
+#include "egldisplay.h"
 #include "eglcontext.h"
 #include "eglconfig.h"
 #include "egldriver.h"
@@ -231,34 +232,6 @@ _eglRemoveSurface(_EGLSurface *surf)
 
 
 
-/**
- * Return the public handle for an internal _EGLSurface.
- * This is the inverse of _eglLookupSurface().
- */
-EGLSurface
-_eglGetSurfaceHandle(_EGLSurface *surface)
-{
-   if (surface)
-      return surface->Handle;
-   else
-      return EGL_NO_SURFACE;
-}
-
-
-/**
- * Return the private _EGLSurface which corresponds to a public EGLSurface
- * handle.
- * This is the inverse of _eglGetSurfaceHandle().
- */
-_EGLSurface *
-_eglLookupSurface(EGLSurface surf)
-{
-   _EGLSurface *c = (_EGLSurface *) _eglHashLookup(_eglGlobal.Surfaces,
-                                                   (EGLuint) surf);
-   return c;
-}
-
-
 EGLBoolean
 _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 {
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index 3b54221bd3..dc53669091 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -10,7 +10,11 @@
  */
 struct _egl_surface
 {
-   EGLSurface Handle;  /* The public/opaque handle which names this object */
+   /* Managed by EGLDisplay for linking */
+   _EGLDisplay *Display;
+   _EGLSurface *Next;
+   EGLSurface Handle;
+
    _EGLConfig *Config;
 
    /* May need reference counting here */
@@ -52,14 +56,6 @@ extern void
 _eglRemoveSurface(_EGLSurface *surf);
 
 
-extern EGLSurface
-_eglGetSurfaceHandle(_EGLSurface *surface);
-
-
-extern _EGLSurface *
-_eglLookupSurface(EGLSurface surf);
- 
-
 extern EGLBoolean
 _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw);
 
-- 
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/main/eglsurface.c')

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/main/eglsurface.c')

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 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/main/eglsurface.c')

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 8a130a65aa7b0695c7d220f4ad6317ba1f64c6a6 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olvaffe@gmail.com>
Date: Mon, 3 Aug 2009 11:35:44 -0600
Subject: egl: Correct the default values of surface attributes.

EGL_TEXTURE_FORMAT and EGL_TEXTURE_TARGET should default to
EGL_NO_TEXTURE.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
---
 src/egl/main/eglsurface.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/egl/main/eglsurface.c')

diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index bd263fe265..3947051127 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -26,7 +26,8 @@ _eglInitSurface(_EGLDriver *drv, _EGLSurface *surf, EGLint type,
 {
    const char *func;
    EGLint width = 0, height = 0, largest = 0;
-   EGLint texFormat = 0, texTarget = 0, mipmapTex = 0;
+   EGLint texFormat = EGL_NO_TEXTURE, texTarget = EGL_NO_TEXTURE;
+   EGLint mipmapTex = EGL_FALSE;
    EGLint renderBuffer = EGL_BACK_BUFFER;
 #ifdef EGL_VERSION_1_2
    EGLint colorspace = EGL_COLORSPACE_sRGB;
-- 
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/main/eglsurface.c')

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/main/eglsurface.c')

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/main/eglsurface.c')

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