st/egl: Move module loading code to targets.

Several changes are made.  libegl.a no longer defines _eglMain.  It
defines functions to create and destroy a _EGLDriver instead.  The
creation function is called by the targets.  It takes an egl_g3d_loader
as its argument.  The loader is defined by the targets and is in charge
of creating st_api and pipe_screen.  This allows us to move the module
loading code to targets.  Lastly, the modules are now loaded as the
respective contexts are created.

18 files changed, 213 insertions, 389 deletions

diff --git a/src/gallium/state_trackers/egl/Makefile b/src/gallium/state_trackers/egl/Makefile
index e117f15d930..9e9e479e7e0 100644
--- a/src/gallium/state_trackers/egl/Makefile
+++ b/src/gallium/state_trackers/egl/Makefile
@@ -5,14 +5,12 @@ common_INCLUDES = \
 	-I. \
 	-I$(TOP)/src/gallium/include \
 	-I$(TOP)/src/gallium/auxiliary \
-	-I$(TOP)/src/gallium/drivers \
 	-I$(TOP)/src/egl/main \
 	-I$(TOP)/include
 
 common_SOURCES = $(wildcard common/*.c)
 common_OBJECTS = $(common_SOURCES:.c=.o)
 
-
 x11_INCLUDES = \
 	-I$(TOP)/src/gallium/drivers \
 	-I$(TOP)/src/glx \
@@ -31,7 +29,7 @@ kms_SOURCES = $(wildcard kms/*.c)
 kms_OBJECTS = $(kms_SOURCES:.c=.o)
 
 
-fbdev_INCLUDES = -I$(TOP)/src/gallium/winsys/sw -I$(TOP)/src/gallium/drivers
+fbdev_INCLUDES = -I$(TOP)/src/gallium/winsys/sw
 fbdev_SOURCES = $(wildcard fbdev/*.c)
 fbdev_OBJECTS = $(fbdev_SOURCES:.c=.o)
 
@@ -40,7 +38,7 @@ ALL_INCLUDES = $(common_INCLUDES) $(x11_INCLUDES) $(kms_INCLUDES) $(fbdev_INCLUD
 ALL_SOURCES = $(common_SOURCES) $(x11_SOURCES) $(kms_SOURCES) $(fbdev_SOURCES)
 
 EGL_OBJECTS = $(common_OBJECTS)
-EGL_CPPFLAGS = $(common_INCLUDES) -DST_MODULE_PREFIX=\"st_\"
+EGL_CPPFLAGS = $(common_INCLUDES)
 
 # add backends
 ifneq ($(findstring x11, $(EGL_PLATFORMS)),)
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c
index 36354dd42ed..494d6dd8b6d 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d.c
@@ -35,34 +35,10 @@
 #include "egl_g3d.h"
 #include "egl_g3d_api.h"
 #include "egl_g3d_st.h"
+#include "egl_g3d_loader.h"
 #include "native.h"
 
 /**
- * Initialize the state trackers.
- */
-static void
-egl_g3d_init_st(_EGLDriver *drv)
-{
-   struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
-   EGLint i;
-
-   /* already initialized */
-   if (gdrv->api_mask)
-      return;
-
-   egl_g3d_init_st_apis(gdrv->stapis);
-   for (i = 0; i < ST_API_COUNT; i++) {
-      if (gdrv->stapis[i])
-         gdrv->api_mask |= egl_g3d_st_api_bit(i);
-   }
-
-   if (gdrv->api_mask)
-      _eglLog(_EGL_DEBUG, "Driver API mask: 0x%x", gdrv->api_mask);
-   else
-      _eglLog(_EGL_WARNING, "No supported client API");
-}
-
-/**
  * Get the native platform.
  */
 static const struct native_platform *
@@ -323,7 +299,6 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
                     _EGLConfig *conf, const struct native_config *nconf,
                     enum pipe_format depth_stencil_format)
 {
-   struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
    struct egl_g3d_config *gconf = egl_g3d_config(conf);
    EGLint buffer_mask, api_mask;
    EGLBoolean valid;
@@ -347,7 +322,7 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
    gconf->stvis.render_buffer = (buffer_mask & ST_ATTACHMENT_BACK_LEFT_MASK) ?
       ST_ATTACHMENT_BACK_LEFT : ST_ATTACHMENT_FRONT_LEFT;
 
-   api_mask = gdrv->api_mask;;
+   api_mask = dpy->ClientAPIsMask;
    /* this is required by EGL, not by OpenGL ES */
    if (nconf->window_bit &&
        gconf->stvis.render_buffer != ST_ATTACHMENT_BACK_LEFT)
@@ -472,8 +447,26 @@ egl_g3d_invalid_surface(struct native_display *ndpy,
       gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gsurf->stfbi);
 }
 
+static struct pipe_screen *
+egl_g3d_new_drm_screen(struct native_display *ndpy, const char *name, int fd)
+{
+   _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data;
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   return gdpy->loader->create_drm_screen(name, fd);
+}
+
+static struct pipe_screen *
+egl_g3d_new_sw_screen(struct native_display *ndpy, struct sw_winsys *ws)
+{
+   _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data;
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   return gdpy->loader->create_sw_screen(ws);
+}
+
 static struct native_event_handler egl_g3d_native_event_handler = {
-   egl_g3d_invalid_surface
+   egl_g3d_invalid_surface,
+   egl_g3d_new_drm_screen,
+   egl_g3d_new_sw_screen
 };
 
 static EGLBoolean
@@ -529,20 +522,25 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
       _eglError(EGL_BAD_ALLOC, "eglInitialize");
       goto fail;
    }
+   gdpy->loader = gdrv->loader;
    dpy->DriverData = gdpy;
 
    _eglLog(_EGL_INFO, "use %s for display %p", nplat->name, dpy->PlatformDisplay);
    gdpy->native = nplat->create_display(dpy->PlatformDisplay,
-         &egl_g3d_native_event_handler);
+         &egl_g3d_native_event_handler, (void *) dpy);
    if (!gdpy->native) {
       _eglError(EGL_NOT_INITIALIZED, "eglInitialize(no usable display)");
       goto fail;
    }
 
-   gdpy->native->user_data = (void *) dpy;
-
-   egl_g3d_init_st(&gdrv->base);
-   dpy->ClientAPIsMask = gdrv->api_mask;
+   if (gdpy->loader->api_mask & (1 << ST_API_OPENGL))
+      dpy->ClientAPIsMask |= EGL_OPENGL_BIT;
+   if (gdpy->loader->api_mask & (1 << ST_API_OPENGL_ES1))
+      dpy->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
+   if (gdpy->loader->api_mask & (1 << ST_API_OPENGL_ES2))
+      dpy->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
+   if (gdpy->loader->api_mask & (1 << ST_API_OPENVG))
+      dpy->ClientAPIsMask |= EGL_OPENVG_BIT;
 
    gdpy->smapi = egl_g3d_create_st_manager(dpy);
    if (!gdpy->smapi) {
@@ -583,22 +581,15 @@ static _EGLProc
 egl_g3d_get_proc_address(_EGLDriver *drv, const char *procname)
 {
    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
-   _EGLProc proc;
-   EGLint i;
+   struct st_api *stapi = NULL;
 
-   /* in case this is called before a display is initialized */
-   egl_g3d_init_st(&gdrv->base);
-
-   for (i = 0; i < ST_API_COUNT; i++) {
-      struct st_api *stapi = gdrv->stapis[i];
-      if (stapi) {
-         proc = (_EGLProc) stapi->get_proc_address(stapi, procname);
-         if (proc)
-            return proc;
-      }
-   }
+   if (procname && procname[0] == 'v' && procname[1] == 'g')
+      stapi = gdrv->loader->get_st_api(ST_API_OPENVG);
+   else if (procname && procname[0] == 'g' && procname[1] == 'l')
+      stapi = gdrv->loader->guess_gl_api();
 
-   return (_EGLProc) NULL;
+   return (_EGLProc) ((stapi) ?
+         stapi->get_proc_address(stapi, procname) : NULL);
 }
 
 static EGLint
@@ -628,18 +619,8 @@ egl_g3d_probe(_EGLDriver *drv, _EGLDisplay *dpy)
    return score;
 }
 
-static void
-egl_g3d_unload(_EGLDriver *drv)
-{
-   struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
-
-   egl_g3d_destroy_st_apis();
-   egl_g3d_destroy_probe(drv, NULL);
-   FREE(gdrv);
-}
-
 _EGLDriver *
-_eglMain(const char *args)
+egl_g3d_create_driver(const struct egl_g3d_loader *loader)
 {
    struct egl_g3d_driver *gdrv;
 
@@ -647,17 +628,28 @@ _eglMain(const char *args)
    if (!gdrv)
       return NULL;
 
+   gdrv->loader = loader;
+
    egl_g3d_init_driver_api(&gdrv->base);
    gdrv->base.API.Initialize = egl_g3d_initialize;
    gdrv->base.API.Terminate = egl_g3d_terminate;
    gdrv->base.API.GetProcAddress = egl_g3d_get_proc_address;
 
-   gdrv->base.Name = "Gallium";
    gdrv->base.Probe = egl_g3d_probe;
-   gdrv->base.Unload = egl_g3d_unload;
 
    /* the key is " EGL G3D" */
    gdrv->probe_key = 0x0E61063D;
 
+   /* to be filled by the caller */
+   gdrv->base.Name = NULL;
+   gdrv->base.Unload = NULL;
+
    return &gdrv->base;
 }
+
+void
+egl_g3d_destroy_driver(_EGLDriver *drv)
+{
+   struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
+   FREE(gdrv);
+}
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.h b/src/gallium/state_trackers/egl/common/egl_g3d.h
index a498dcf6f63..d9ecb208e05 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d.h
+++ b/src/gallium/state_trackers/egl/common/egl_g3d.h
@@ -41,12 +41,11 @@
 
 #include "native.h"
 #include "egl_g3d_st.h"
+#include "egl_g3d_loader.h"
 
 struct egl_g3d_driver {
    _EGLDriver base;
-   struct st_api *stapis[ST_API_COUNT];
-   EGLint api_mask;
-
+   const struct egl_g3d_loader *loader;
    const struct native_platform *platforms[_EGL_NUM_PLATFORMS];
    EGLint probe_key;
 };
@@ -54,6 +53,7 @@ struct egl_g3d_driver {
 struct egl_g3d_display {
    struct native_display *native;
 
+   const struct egl_g3d_loader *loader;
    struct st_manager *smapi;
    struct pipe_context *pipe;
 };
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_api.c b/src/gallium/state_trackers/egl/common/egl_g3d_api.c
index 255a1fb730a..308fa96d998 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d_api.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_api.c
@@ -35,6 +35,7 @@
 #include "egl_g3d_api.h"
 #include "egl_g3d_image.h"
 #include "egl_g3d_st.h"
+#include "egl_g3d_loader.h"
 #include "native.h"
 
 /**
@@ -44,7 +45,6 @@ static struct st_api *
 egl_g3d_choose_st(_EGLDriver *drv, _EGLContext *ctx)
 {
    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
-   struct st_api *stapi;
    EGLint idx = -1;
 
    switch (ctx->ClientAPI) {
@@ -73,8 +73,7 @@ egl_g3d_choose_st(_EGLDriver *drv, _EGLContext *ctx)
       break;
    }
 
-   stapi = (idx >= 0) ? gdrv->stapis[idx] : NULL;
-   return stapi;
+   return (idx >= 0) ? gdrv->loader->get_st_api(idx) : NULL;
 }
 
 static _EGLContext *
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_loader.h b/src/gallium/state_trackers/egl/common/egl_g3d_loader.h
new file mode 100644
index 00000000000..c9141f8ad4e
--- /dev/null
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_loader.h
@@ -0,0 +1,54 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
+ *
+ * Copyright (C) 2010 LunarG Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Chia-I Wu <[email protected]>
+ */
+
+#ifndef _EGL_G3D_LOADER_H_
+#define _EGL_G3D_LOADER_H_
+
+#include "pipe/p_compiler.h"
+#include "state_tracker/st_api.h"
+#include "egltypedefs.h"
+
+struct pipe_screen;
+struct sw_winsys;
+
+struct egl_g3d_loader {
+   uint api_mask;
+   struct st_api *(*get_st_api)(enum st_api_type api);
+   struct st_api *(*guess_gl_api)(void);
+
+   struct pipe_screen *(*create_drm_screen)(const char *name, int fd);
+   struct pipe_screen *(*create_sw_screen)(struct sw_winsys *ws);
+};
+
+_EGLDriver *
+egl_g3d_create_driver(const struct egl_g3d_loader *loader);
+
+void
+egl_g3d_destroy_driver(_EGLDriver *drv);
+
+#endif /* _EGL_G3D_LOADER_H_ */
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_st.c b/src/gallium/state_trackers/egl/common/egl_g3d_st.c
index 0668f5c91ab..05cdb0d421c 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d_st.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_st.c
@@ -49,173 +49,6 @@ egl_g3d_st_manager(struct st_manager *smapi)
    return (struct egl_g3d_st_manager *) smapi;
 }
 
-static struct egl_g3d_st_module {
-   const char *filename;
-   struct util_dl_library *lib;
-   struct st_api *stapi;
-} egl_g3d_st_modules[ST_API_COUNT];
-
-static EGLBoolean
-egl_g3d_search_path_callback(const char *dir, size_t len, void *callback_data)
-{
-   struct egl_g3d_st_module *stmod =
-      (struct egl_g3d_st_module *) callback_data;
-   char path[1024];
-   int ret;
-
-   if (!len) {
-      stmod->lib = util_dl_open(stmod->filename);
-      return !(stmod->lib);
-   }
-
-   ret = util_snprintf(path, sizeof(path),
-         "%.*s/%s", len, dir, stmod->filename);
-   if (ret > 0 && ret < sizeof(path))
-      stmod->lib = util_dl_open(path);
-
-   return !(stmod->lib);
-}
-
-static boolean
-egl_g3d_load_st_module(struct egl_g3d_st_module *stmod,
-                       const char *filename, const char *procname)
-{
-   struct st_api *(*create_api)(void);
-
-   stmod->filename = filename;
-   if (stmod->filename)
-      _eglSearchPathForEach(egl_g3d_search_path_callback, (void *) stmod);
-   else
-      stmod->lib = util_dl_open(NULL);
-
-   if (stmod->lib) {
-      create_api = (struct st_api *(*)(void))
-         util_dl_get_proc_address(stmod->lib, procname);
-      if (create_api)
-         stmod->stapi = create_api();
-
-      if (!stmod->stapi) {
-         util_dl_close(stmod->lib);
-         stmod->lib = NULL;
-      }
-   }
-
-   if (stmod->stapi) {
-      return TRUE;
-   }
-   else {
-      stmod->filename = NULL;
-      return FALSE;
-   }
-}
-
-#ifdef PIPE_OS_WINDOWS
-#define ST_MODULE_SUFFIX ".dll"
-#else
-#define ST_MODULE_SUFFIX ".so"
-#endif
-
-void
-egl_g3d_init_st_apis(struct st_api *stapis[ST_API_COUNT])
-{
-   const char *skip_checks[ST_API_COUNT], *symbols[ST_API_COUNT];
-   const char *filenames[ST_API_COUNT][4];
-   struct util_dl_library *self;
-   int num_needed = 0, api;
-
-   self = util_dl_open(NULL);
-
-   /* collect the necessary data for loading modules */
-   for (api = 0; api < ST_API_COUNT; api++) {
-      int count = 0;
-
-      switch (api) {
-      case ST_API_OPENGL:
-         skip_checks[api] = "glColor4d";
-         symbols[api] = ST_CREATE_OPENGL_SYMBOL;
-         filenames[api][count++] = ST_MODULE_PREFIX "GL" ST_MODULE_SUFFIX;
-         break;
-      case ST_API_OPENGL_ES1:
-         skip_checks[api] = "glColor4x";
-         symbols[api] = ST_CREATE_OPENGL_ES1_SYMBOL;
-         filenames[api][count++] = ST_MODULE_PREFIX "GLESv1_CM" ST_MODULE_SUFFIX;
-         filenames[api][count++] = ST_MODULE_PREFIX "GL" ST_MODULE_SUFFIX;
-         break;
-      case ST_API_OPENGL_ES2:
-         skip_checks[api] = "glShaderBinary";
-         symbols[api] = ST_CREATE_OPENGL_ES2_SYMBOL;
-         filenames[api][count++] = ST_MODULE_PREFIX "GLESv2" ST_MODULE_SUFFIX;
-         filenames[api][count++] = ST_MODULE_PREFIX "GL" ST_MODULE_SUFFIX;
-         break;
-      case ST_API_OPENVG:
-         skip_checks[api] = "vgClear";
-         symbols[api] = ST_CREATE_OPENVG_SYMBOL;
-         filenames[api][count++]= ST_MODULE_PREFIX "OpenVG" ST_MODULE_SUFFIX;
-         break;
-      default:
-         assert(!"Unknown API Type\n");
-         skip_checks[api] = NULL;
-         symbols[api] = NULL;
-         break;
-      }
-      filenames[api][count++]= NULL;
-      assert(count < Elements(filenames[api]));
-
-      /* heuristicically decide if the module is needed */
-      if (!self || !skip_checks[api] ||
-          util_dl_get_proc_address(self, skip_checks[api])) {
-         /* unset so the module is not skipped */
-         skip_checks[api] = NULL;
-         num_needed++;
-      }
-   }
-   /* mark all moudles needed if we wrongly decided that none is needed */
-   if (!num_needed)
-      memset(skip_checks, 0, sizeof(skip_checks));
-
-   if (self)
-      util_dl_close(self);
-
-   for (api = 0; api < ST_API_COUNT; api++) {
-      struct egl_g3d_st_module *stmod = &egl_g3d_st_modules[api];
-      const char **p;
-
-      /* skip the module */
-      if (skip_checks[api])
-         continue;
-
-      /* try all filenames, including NULL */
-      for (p = filenames[api]; *p; p++) {
-         if (egl_g3d_load_st_module(stmod, *p, symbols[api]))
-            break;
-      }
-      if (!stmod->stapi)
-         egl_g3d_load_st_module(stmod, NULL, symbols[api]);
-
-      stapis[api] = stmod->stapi;
-   }
-}
-
-void
-egl_g3d_destroy_st_apis(void)
-{
-   int api;
-
-   for (api = 0; api < ST_API_COUNT; api++) {
-      struct egl_g3d_st_module *stmod = &egl_g3d_st_modules[api];
-
-      if (stmod->stapi) {
-         stmod->stapi->destroy(stmod->stapi);
-         stmod->stapi = NULL;
-      }
-      if (stmod->lib) {
-         util_dl_close(stmod->lib);
-         stmod->lib = NULL;
-      }
-      stmod->filename = NULL;
-   }
-}
-
 static boolean
 egl_g3d_st_manager_get_egl_image(struct st_manager *smapi,
                                  struct st_context_iface *stctx,
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_st.h b/src/gallium/state_trackers/egl/common/egl_g3d_st.h
index ee53799b029..aa25cc042d7 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d_st.h
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_st.h
@@ -33,12 +33,6 @@
 #include "state_tracker/st_api.h"
 #include "egltypedefs.h"
 
-void
-egl_g3d_init_st_apis(struct st_api *stapis[ST_API_COUNT]);
-
-void
-egl_g3d_destroy_st_apis(void);
-
 struct st_manager *
 egl_g3d_create_st_manager(_EGLDisplay *dpy);
 
diff --git a/src/gallium/state_trackers/egl/common/native.h b/src/gallium/state_trackers/egl/common/native.h
index c4d23bf5415..7e84d74ea7c 100644
--- a/src/gallium/state_trackers/egl/common/native.h
+++ b/src/gallium/state_trackers/egl/common/native.h
@@ -32,6 +32,7 @@
 #include "pipe/p_screen.h"
 #include "pipe/p_context.h"
 #include "pipe/p_state.h"
+#include "state_tracker/sw_winsys.h"
 
 #include "native_probe.h"
 #include "native_modeset.h"
@@ -196,6 +197,11 @@ struct native_event_handler {
    void (*invalid_surface)(struct native_display *ndpy,
                            struct native_surface *nsurf,
                            unsigned int seq_num);
+
+   struct pipe_screen *(*new_drm_screen)(struct native_display *ndpy,
+                                         const char *name, int fd);
+   struct pipe_screen *(*new_sw_screen)(struct native_display *ndpy,
+                                        struct sw_winsys *ws);
 };
 
 /**
@@ -225,7 +231,8 @@ struct native_platform {
    enum native_probe_result (*get_probe_result)(struct native_probe *nprobe);
 
    struct native_display *(*create_display)(void *dpy,
-                                            struct native_event_handler *handler);
+                                            struct native_event_handler *handler,
+                                            void *user_data);
 };
 
 const struct native_platform *
diff --git a/src/gallium/state_trackers/egl/common/native_helper.c b/src/gallium/state_trackers/egl/common/native_helper.c
index 206817ed666..7832b2b693f 100644
--- a/src/gallium/state_trackers/egl/common/native_helper.c
+++ b/src/gallium/state_trackers/egl/common/native_helper.c
@@ -31,9 +31,6 @@
 #include "pipe/p_screen.h"
 #include "pipe/p_context.h"
 #include "pipe/p_state.h"
-#include "softpipe/sp_public.h"
-#include "llvmpipe/lp_public.h"
-#include "target-helpers/wrap_screen.h"
 
 #include "native_helper.h"
 
@@ -236,18 +233,3 @@ resource_surface_present(struct resource_surface *rsurf,
 
    return TRUE;
 }
-
-struct pipe_screen *
-native_create_sw_screen(struct sw_winsys *ws)
-{
-   struct pipe_screen *screen = NULL;
-
-#if defined(GALLIUM_LLVMPIPE)
-   if (!screen && !debug_get_bool_option("GALLIUM_NO_LLVM", FALSE))
-      screen = llvmpipe_create_screen(ws);
-#endif
-   if (!screen)
-      screen = softpipe_create_screen(ws);
-
-   return (screen) ? gallium_wrap_screen(screen) : NULL;
-}
diff --git a/src/gallium/state_trackers/egl/common/native_helper.h b/src/gallium/state_trackers/egl/common/native_helper.h
index bdb9629466b..d1569ac3ea6 100644
--- a/src/gallium/state_trackers/egl/common/native_helper.h
+++ b/src/gallium/state_trackers/egl/common/native_helper.h
@@ -69,6 +69,3 @@ boolean
 resource_surface_present(struct resource_surface *rsurf,
                          enum native_attachment which,
                          void *winsys_drawable_handle);
-
-struct pipe_screen *
-native_create_sw_screen(struct sw_winsys *ws);
diff --git a/src/gallium/state_trackers/egl/fbdev/native_fbdev.c b/src/gallium/state_trackers/egl/fbdev/native_fbdev.c
index c0bc7b2462d..7c276c22f8c 100644
--- a/src/gallium/state_trackers/egl/fbdev/native_fbdev.c
+++ b/src/gallium/state_trackers/egl/fbdev/native_fbdev.c
@@ -386,8 +386,10 @@ fbdev_display_init(struct native_display *ndpy)
       return FALSE;
 
    ws = fbdev_create_sw_winsys(fbdpy->fd, fbdpy->config.color_format);
-   if (ws)
-      fbdpy->base.screen = native_create_sw_screen(ws);
+   if (ws) {
+      fbdpy->base.screen =
+         fbdpy->event_handler->new_sw_screen(&fbdpy->base, ws);
+   }
 
    if (fbdpy->base.screen) {
       if (!fbdpy->base.screen->is_format_supported(fbdpy->base.screen,
@@ -402,7 +404,8 @@ fbdev_display_init(struct native_display *ndpy)
 }
 
 static struct native_display *
-fbdev_display_create(int fd, struct native_event_handler *event_handler)
+fbdev_display_create(int fd, struct native_event_handler *event_handler,
+                     void *user_data)
 {
    struct fbdev_display *fbdpy;
 
@@ -412,6 +415,7 @@ fbdev_display_create(int fd, struct native_event_handler *event_handler)
 
    fbdpy->fd = fd;
    fbdpy->event_handler = event_handler;
+   fbdpy->base.user_data = user_data;
 
    if (!fbdev_display_init(&fbdpy->base)) {
       FREE(fbdpy);
@@ -428,7 +432,8 @@ fbdev_display_create(int fd, struct native_event_handler *event_handler)
 }
 
 static struct native_display *
-native_create_display(void *dpy, struct native_event_handler *event_handler)
+native_create_display(void *dpy, struct native_event_handler *event_handler,
+                      void *user_data)
 {
    struct native_display *ndpy;
    int fd;
@@ -443,7 +448,7 @@ native_create_display(void *dpy, struct native_event_handler *event_handler)
    if (fd < 0)
       return NULL;
 
-   ndpy = fbdev_display_create(fd, event_handler);
+   ndpy = fbdev_display_create(fd, event_handler, user_data);
    if (!ndpy)
       close(fd);
 
diff --git a/src/gallium/state_trackers/egl/gdi/native_gdi.c b/src/gallium/state_trackers/egl/gdi/native_gdi.c
index 4ec229a3f2a..ed955c4132d 100644
--- a/src/gallium/state_trackers/egl/gdi/native_gdi.c
+++ b/src/gallium/state_trackers/egl/gdi/native_gdi.c
@@ -343,10 +343,11 @@ gdi_display_destroy(struct native_display *ndpy)
 }
 
 static struct native_display *
-gdi_create_display(HDC hDC, struct pipe_screen *screen,
-                   struct native_event_handler *event_handler)
+gdi_create_display(HDC hDC, struct native_event_handler *event_handler,
+                   void *user_data)
 {
    struct gdi_display *gdpy;
+   struct sw_winsys *winsys;
 
    gdpy = CALLOC_STRUCT(gdi_display);
    if (!gdpy)
@@ -354,8 +355,21 @@ gdi_create_display(HDC hDC, struct pipe_screen *screen,
 
    gdpy->hDC = hDC;
    gdpy->event_handler = event_handler;
+   gdpy->base.user_data = user_data;
+
+   winsys = gdi_create_sw_winsys();
+   if (!winsys) {
+      FREE(gdpy);
+      return NULL;
+   }
 
-   gdpy->base.screen = screen;
+   gdpy->base.screen = gdpy->event_handler->create_sw_screen(winsys);
+   if (!gdpy->base.screen) {
+      if (winsys->destroy)
+         winsys->destroy(winsys);
+      FREE(gdpy);
+      return NULL;
+   }
 
    gdpy->base.destroy = gdi_display_destroy;
    gdpy->base.get_param = gdi_display_get_param;
@@ -367,23 +381,10 @@ gdi_create_display(HDC hDC, struct pipe_screen *screen,
 }
 
 static struct native_display *
-native_create_display(void *dpy, struct native_event_handler *event_handler)
+native_create_display(void *dpy, struct native_event_handler *event_handler,
+                      void *user_data)
 {
-   struct sw_winsys *winsys;
-   struct pipe_screen *screen;
-
-   winsys = gdi_create_sw_winsys();
-   if (!winsys)
-      return NULL;
-
-   screen = native_create_sw_screen(winsys);
-   if (!screen) {
-      if (winsys->destroy)
-         winsys->destroy(winsys);
-      return NULL;
-   }
-
-   return gdi_create_display((HDC) dpy, screen, event_handler);
+   return gdi_create_display((HDC) dpy, event_handler, user_data);
 }
 
 static const struct native_platform gdi_platform = {
diff --git a/src/gallium/state_trackers/egl/kms/native_kms.c b/src/gallium/state_trackers/egl/kms/native_kms.c
index dd4ea711405..5833d27a250 100644
--- a/src/gallium/state_trackers/egl/kms/native_kms.c
+++ b/src/gallium/state_trackers/egl/kms/native_kms.c
@@ -23,6 +23,10 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
 #include "pipe/p_screen.h"
 #include "pipe/p_context.h"
 #include "util/u_debug.h"
@@ -33,7 +37,6 @@
 #include "egllog.h"
 
 #include "native_kms.h"
-#include "state_tracker/drm_driver.h"
 
 static boolean
 kms_surface_validate(struct native_surface *nsurf, uint attachment_mask,
@@ -656,7 +659,7 @@ kms_display_destroy(struct native_display *ndpy)
       kdpy->base.screen->destroy(kdpy->base.screen);
 
    if (kdpy->fd >= 0)
-      drmClose(kdpy->fd);
+      close(kdpy->fd);
 
    FREE(kdpy);
 }
@@ -668,50 +671,23 @@ static boolean
 kms_display_init_screen(struct native_display *ndpy)
 {
    struct kms_display *kdpy = kms_display(ndpy);
-   int fd;
-
-   fd = kdpy->fd;
-   if (fd >= 0) {
-      drmVersionPtr version = drmGetVersion(fd);
-      if (!version || strcmp(version->name, driver_descriptor.driver_name)) {
-         if (version) {
-            _eglLog(_EGL_WARNING, "unknown driver name %s", version->name);
-            drmFreeVersion(version);
-         }
-         else {
-            _eglLog(_EGL_WARNING, "invalid fd %d", fd);
-         }
-
-         return FALSE;
-      }
+   drmVersionPtr version;
 
-      drmFreeVersion(version);
-   }
-   else {
-      fd = drmOpen(driver_descriptor.driver_name, NULL);
-   }
-
-   if (fd < 0) {
-      _eglLog(_EGL_WARNING, "failed to open DRM device");
+   version = drmGetVersion(kdpy->fd);
+   if (!version) {
+      _eglLog(_EGL_WARNING, "invalid fd %d", kdpy->fd);
       return FALSE;
    }
 
-#if 0
-   if (drmSetMaster(fd)) {
-      _eglLog(_EGL_WARNING, "failed to become DRM master");
-      return FALSE;
-   }
-#endif
+   kdpy->base.screen = kdpy->event_handler->new_drm_screen(&kdpy->base,
+         version->name, kdpy->fd);;
+   drmFreeVersion(version);
 
-   kdpy->base.screen = driver_descriptor.create_screen(fd);
    if (!kdpy->base.screen) {
       _eglLog(_EGL_WARNING, "failed to create DRM screen");
-      drmClose(fd);
       return FALSE;
    }
 
-   kdpy->fd = fd;
-
    return TRUE;
 }
 
@@ -723,7 +699,8 @@ static struct native_display_modeset kms_display_modeset = {
 };
 
 static struct native_display *
-kms_create_display(int fd, struct native_event_handler *event_handler)
+kms_create_display(int fd, struct native_event_handler *event_handler,
+                   void *user_data)
 {
    struct kms_display *kdpy;
 
@@ -731,8 +708,10 @@ kms_create_display(int fd, struct native_event_handler *event_handler)
    if (!kdpy)
       return NULL;
 
-   kdpy->event_handler = event_handler;
    kdpy->fd = fd;
+   kdpy->event_handler = event_handler;
+   kdpy->base.user_data = user_data;
+
    if (!kms_display_init_screen(&kdpy->base)) {
       kms_display_destroy(&kdpy->base);
       return NULL;
@@ -769,39 +748,32 @@ kms_create_display(int fd, struct native_event_handler *event_handler)
 }
 
 static struct native_display *
-native_create_display(void *dpy, struct native_event_handler *event_handler)
+native_create_display(void *dpy, struct native_event_handler *event_handler,
+                      void *user_data)
 {
-   struct native_display *ndpy;
    int fd;
 
-   /* well, this makes fd 0 being ignored */
-   fd = (dpy) ? (int) pointer_to_intptr(dpy) : -1;
-   ndpy = kms_create_display(fd, event_handler);
-
-   return ndpy;
-}
-
-static void
-kms_init_platform(struct native_platform *nplat)
-{
-   static char kms_name[32];
-
-   if (nplat->name)
-      return;
-
-   util_snprintf(kms_name, sizeof(kms_name), "KMS/%s", driver_descriptor.name);
+   if (dpy) {
+      fd = dup((int) pointer_to_intptr(dpy));
+   }
+   else {
+      fd = open("/dev/dri/card0", O_RDWR);
+   }
+   if (fd < 0)
+      return NULL;
 
-   nplat->name = kms_name;
-   nplat->create_probe = NULL;
-   nplat->get_probe_result = NULL;
-   nplat->create_display = native_create_display;
+   return kms_create_display(fd, event_handler, user_data);
 }
 
-static struct native_platform kms_platform;
+static const struct native_platform kms_platform = {
+   "KMS", /* name */
+   NULL, /* create_probe */
+   NULL, /* get_probe_result */
+   native_create_display
+};
 
 const struct native_platform *
 native_get_kms_platform(void)
 {
-   kms_init_platform(&kms_platform);
    return &kms_platform;
 }
diff --git a/src/gallium/state_trackers/egl/kms/native_kms.h b/src/gallium/state_trackers/egl/kms/native_kms.h
index 14cf5a641a8..cd8e4ff0b2d 100644
--- a/src/gallium/state_trackers/egl/kms/native_kms.h
+++ b/src/gallium/state_trackers/egl/kms/native_kms.h
@@ -32,6 +32,7 @@
 #include "pipe/p_compiler.h"
 #include "util/u_format.h"
 #include "pipe/p_state.h"
+#include "state_tracker/drm_driver.h"
 
 #include "common/native.h"
 #include "common/native_helper.h"
diff --git a/src/gallium/state_trackers/egl/x11/native_dri2.c b/src/gallium/state_trackers/egl/x11/native_dri2.c
index 7464354fe61..1bef59d864f 100644
--- a/src/gallium/state_trackers/egl/x11/native_dri2.c
+++ b/src/gallium/state_trackers/egl/x11/native_dri2.c
@@ -692,7 +692,6 @@ static boolean
 dri2_display_init_screen(struct native_display *ndpy)
 {
    struct dri2_display *dri2dpy = dri2_display(ndpy);
-   const char *driver = driver_descriptor.name;
    int fd;
 
    if (!x11_screen_support(dri2dpy->xscr, X11_SCREEN_EXTENSION_DRI2) ||
@@ -703,19 +702,15 @@ dri2_display_init_screen(struct native_display *ndpy)
 
    dri2dpy->dri_driver = x11_screen_probe_dri2(dri2dpy->xscr,
          &dri2dpy->dri_major, &dri2dpy->dri_minor);
-   if (!dri2dpy->dri_driver || !driver ||
-       strcmp(dri2dpy->dri_driver, driver) != 0) {
-      _eglLog(_EGL_WARNING, "Driver mismatch: %s != %s",
-            dri2dpy->dri_driver, driver);
-      return FALSE;
-   }
 
    fd = x11_screen_enable_dri2(dri2dpy->xscr,
          dri2_display_invalidate_buffers, &dri2dpy->base);
    if (fd < 0)
       return FALSE;
 
-   dri2dpy->base.screen = driver_descriptor.create_screen(fd);
+   dri2dpy->base.screen =
+      dri2dpy->event_handler->new_drm_screen(&dri2dpy->base,
+            dri2dpy->dri_driver, fd);
    if (!dri2dpy->base.screen) {
       _eglLog(_EGL_WARNING, "failed to create DRM screen");
       return FALSE;
@@ -739,7 +734,8 @@ dri2_display_hash_table_compare(void *key1, void *key2)
 
 struct native_display *
 x11_create_dri2_display(Display *dpy,
-                        struct native_event_handler *event_handler)
+                        struct native_event_handler *event_handler,
+                        void *user_data)
 {
    struct dri2_display *dri2dpy;
 
@@ -748,6 +744,7 @@ x11_create_dri2_display(Display *dpy,
       return NULL;
 
    dri2dpy->event_handler = event_handler;
+   dri2dpy->base.user_data = user_data;
 
    dri2dpy->dpy = dpy;
    if (!dri2dpy->dpy) {
diff --git a/src/gallium/state_trackers/egl/x11/native_x11.c b/src/gallium/state_trackers/egl/x11/native_x11.c
index 7eec563bdfe..f0519405d3d 100644
--- a/src/gallium/state_trackers/egl/x11/native_x11.c
+++ b/src/gallium/state_trackers/egl/x11/native_x11.c
@@ -23,7 +23,6 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include <string.h>
 #include "util/u_debug.h"
 #include "util/u_memory.h"
 #include "util/u_string.h"
@@ -107,50 +106,38 @@ x11_get_probe_result(struct native_probe *nprobe)
 }
 
 static struct native_display *
-native_create_display(void *dpy, struct native_event_handler *event_handler)
+native_create_display(void *dpy, struct native_event_handler *event_handler,
+                      void *user_data)
 {
    struct native_display *ndpy = NULL;
    boolean force_sw;
 
    force_sw = debug_get_bool_option("EGL_SOFTWARE", FALSE);
-   if (!driver_descriptor.create_screen)
-      force_sw = TRUE;
-
    if (!force_sw) {
-      ndpy = x11_create_dri2_display((Display *) dpy, event_handler);
+      ndpy = x11_create_dri2_display((Display *) dpy,
+            event_handler, user_data);
    }
 
    if (!ndpy) {
       EGLint level = (force_sw) ? _EGL_INFO : _EGL_WARNING;
 
       _eglLog(level, "use software fallback");
-      ndpy = x11_create_ximage_display((Display *) dpy, event_handler);
+      ndpy = x11_create_ximage_display((Display *) dpy,
+            event_handler, user_data);
    }
 
    return ndpy;
 }
 
-static void
-x11_init_platform(struct native_platform *nplat)
-{
-   static char x11_name[32];
-
-   if (nplat->name)
-      return;
-
-   util_snprintf(x11_name, sizeof(x11_name), "X11/%s", driver_descriptor.name);
-
-   nplat->name = x11_name;
-   nplat->create_probe = x11_create_probe;
-   nplat->get_probe_result = x11_get_probe_result;
-   nplat->create_display = native_create_display;
-}
-
-static struct native_platform x11_platform;
+static const struct native_platform x11_platform = {
+   "X11", /* name */
+   x11_create_probe,
+   x11_get_probe_result,
+   native_create_display
+};
 
 const struct native_platform *
 native_get_x11_platform(void)
 {
-   x11_init_platform(&x11_platform);
    return &x11_platform;
 }
diff --git a/src/gallium/state_trackers/egl/x11/native_x11.h b/src/gallium/state_trackers/egl/x11/native_x11.h
index a1c32c3455a..0b47837e1b5 100644
--- a/src/gallium/state_trackers/egl/x11/native_x11.h
+++ b/src/gallium/state_trackers/egl/x11/native_x11.h
@@ -30,10 +30,12 @@
 
 struct native_display *
 x11_create_ximage_display(Display *dpy,
-                          struct native_event_handler *event_handler);
+                          struct native_event_handler *event_handler,
+                          void *user_data);
 
 struct native_display *
 x11_create_dri2_display(Display *dpy,
-                        struct native_event_handler *event_handler);
+                        struct native_event_handler *event_handler,
+                        void *user_data);
 
 #endif /* _NATIVE_X11_H_ */
diff --git a/src/gallium/state_trackers/egl/x11/native_ximage.c b/src/gallium/state_trackers/egl/x11/native_ximage.c
index ee10a04cfb2..4b32f6e36e0 100644
--- a/src/gallium/state_trackers/egl/x11/native_ximage.c
+++ b/src/gallium/state_trackers/egl/x11/native_ximage.c
@@ -442,7 +442,8 @@ ximage_display_destroy(struct native_display *ndpy)
 
 struct native_display *
 x11_create_ximage_display(Display *dpy,
-                          struct native_event_handler *event_handler)
+                          struct native_event_handler *event_handler,
+                          void *user_data)
 {
    struct ximage_display *xdpy;
    struct sw_winsys *winsys = NULL;
@@ -462,6 +463,7 @@ x11_create_ximage_display(Display *dpy,
    }
 
    xdpy->event_handler = event_handler;
+   xdpy->base.user_data = user_data;
 
    xdpy->xscr_number = DefaultScreen(xdpy->dpy);
    xdpy->xscr = x11_screen_create(xdpy->dpy, xdpy->xscr_number);
@@ -472,7 +474,8 @@ x11_create_ximage_display(Display *dpy,
    if (!winsys)
       goto fail;
 
-   xdpy->base.screen = native_create_sw_screen(winsys);
+   xdpy->base.screen =
+      xdpy->event_handler->new_sw_screen(&xdpy->base, winsys);
    if (!xdpy->base.screen)
       goto fail;