st/egl: Remove __GLcontextModes from the native interface.

Replace __GLcontextModes by a subset of its attributes that makes sense
to EGL.  This also gets rid of GL headers from the common code.

8 files changed, 183 insertions, 168 deletions

diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c
index efddf56cbf9..96959ec012a 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d.c
@@ -30,9 +30,9 @@
 #include "util/u_memory.h"
 #include "util/u_rect.h"
 #include "util/u_inlines.h"
+#include "util/u_format.h"
 #include "egldriver.h"
 #include "eglcurrent.h"
-#include "eglconfigutil.h"
 #include "egllog.h"
 
 #include "native.h"
@@ -209,6 +209,100 @@ egl_g3d_add_screens(_EGLDriver *drv, _EGLDisplay *dpy)
 #endif /* EGL_MESA_screen_surface */
 
 /**
+ * Initialize and validate the EGL config attributes.
+ */
+static EGLBoolean
+init_config_attributes(_EGLConfig *conf, EGLint api_mask,
+                       const struct native_config *nconf)
+{
+   uint rgba[4], depth_stencil[2], buffer_size;
+   EGLint surface_type;
+   EGLint i;
+
+   /* get the color and depth/stencil component sizes */
+   assert(nconf->color_format != PIPE_FORMAT_NONE);
+   buffer_size = 0;
+   for (i = 0; i < 4; i++) {
+      rgba[i] = util_format_get_component_bits(nconf->color_format,
+            UTIL_FORMAT_COLORSPACE_RGB, i);
+      buffer_size += rgba[i];
+   }
+   for (i = 0; i < 2; i++) {
+      if (nconf->depth_format != PIPE_FORMAT_NONE) {
+         depth_stencil[i] = util_format_get_component_bits(nconf->depth_format,
+               UTIL_FORMAT_COLORSPACE_ZS, i);
+      }
+      else {
+         depth_stencil[i] = 0;
+      }
+   }
+
+   surface_type = 0x0;
+   if (nconf->window_bit)
+      surface_type |= EGL_WINDOW_BIT;
+   if (nconf->pixmap_bit)
+      surface_type |= EGL_PIXMAP_BIT;
+#ifdef EGL_MESA_screen_surface
+   if (nconf->scanout_bit)
+      surface_type |= EGL_SCREEN_BIT_MESA;
+#endif
+
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT))
+      surface_type |= EGL_PBUFFER_BIT;
+
+   SET_CONFIG_ATTRIB(conf, EGL_CONFORMANT, api_mask);
+   SET_CONFIG_ATTRIB(conf, EGL_RENDERABLE_TYPE, api_mask);
+
+   SET_CONFIG_ATTRIB(conf, EGL_RED_SIZE, rgba[0]);
+   SET_CONFIG_ATTRIB(conf, EGL_GREEN_SIZE, rgba[1]);
+   SET_CONFIG_ATTRIB(conf, EGL_BLUE_SIZE, rgba[2]);
+   SET_CONFIG_ATTRIB(conf, EGL_ALPHA_SIZE, rgba[3]);
+   SET_CONFIG_ATTRIB(conf, EGL_BUFFER_SIZE, buffer_size);
+
+   SET_CONFIG_ATTRIB(conf, EGL_DEPTH_SIZE, depth_stencil[0]);
+   SET_CONFIG_ATTRIB(conf, EGL_STENCIL_SIZE, depth_stencil[1]);
+
+   SET_CONFIG_ATTRIB(conf, EGL_SURFACE_TYPE, surface_type);
+
+   SET_CONFIG_ATTRIB(conf, EGL_NATIVE_RENDERABLE, EGL_TRUE);
+   if (surface_type & EGL_WINDOW_BIT) {
+      SET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_ID, nconf->native_visual_id);
+      SET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_TYPE,
+            nconf->native_visual_type);
+   }
+
+   if (surface_type & EGL_PBUFFER_BIT) {
+      SET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE);
+      if (rgba[3])
+         SET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE);
+
+      SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_WIDTH, 4096);
+      SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_HEIGHT, 4096);
+      SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_PIXELS, 4096 * 4096);
+   }
+
+   SET_CONFIG_ATTRIB(conf, EGL_LEVEL, nconf->level);
+   SET_CONFIG_ATTRIB(conf, EGL_SAMPLES, nconf->samples);
+   SET_CONFIG_ATTRIB(conf, EGL_SAMPLE_BUFFERS, 1);
+
+   if (nconf->slow_config)
+      SET_CONFIG_ATTRIB(conf, EGL_CONFIG_CAVEAT, EGL_SLOW_CONFIG);
+
+   if (nconf->transparent_rgb) {
+      rgba[0] = nconf->transparent_rgb_values[0];
+      rgba[1] = nconf->transparent_rgb_values[1];
+      rgba[2] = nconf->transparent_rgb_values[2];
+
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_TYPE, EGL_TRANSPARENT_RGB);
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_RED_VALUE, rgba[0]);
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_GREEN_VALUE, rgba[1]);
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_BLUE_VALUE, rgba[2]);
+   }
+
+   return _eglValidateConfig(conf, EGL_FALSE);
+}
+
+/**
  * Initialize an EGL config from the native config.
  */
 static EGLBoolean
@@ -217,25 +311,25 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
 {
    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
    struct egl_g3d_config *gconf = egl_g3d_config(conf);
-   const __GLcontextModes *mode = &nconf->mode;
    EGLint buffer_mask, api_mask;
    EGLBoolean valid;
    EGLint i;
 
-   buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
-   if (mode->doubleBufferMode)
+   buffer_mask = 0x0;
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_LEFT))
+      buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK;
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT))
       buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
-   if (mode->stereoMode) {
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_RIGHT))
       buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
-      if (mode->doubleBufferMode)
-         buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
-   }
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_RIGHT))
+      buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
 
    gconf->stvis.buffer_mask = buffer_mask;
    gconf->stvis.color_format = nconf->color_format;
    gconf->stvis.depth_stencil_format = nconf->depth_format;
    gconf->stvis.accum_format = PIPE_FORMAT_NONE;
-   gconf->stvis.samples = 0;
+   gconf->stvis.samples = nconf->samples;
 
    gconf->stvis.render_buffer = (buffer_mask & ST_ATTACHMENT_BACK_LEFT_MASK) ?
       ST_ATTACHMENT_BACK_LEFT : ST_ATTACHMENT_FRONT_LEFT;
@@ -249,29 +343,18 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
       }
    }
    /* this is required by EGL, not by OpenGL ES */
-   if ((mode->drawableType & GLX_WINDOW_BIT) && !mode->doubleBufferMode)
+   if (nconf->window_bit &&
+       gconf->stvis.render_buffer != ST_ATTACHMENT_BACK_LEFT)
       api_mask &= ~(EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT);
 
    if (!api_mask) {
       _eglLog(_EGL_DEBUG, "no state tracker supports config 0x%x",
-            mode->visualID);
+            nconf->native_visual_id);
    }
 
-   valid = _eglConfigFromContextModesRec(&gconf->base,
-         mode, api_mask, api_mask);
-   if (valid) {
-#ifdef EGL_MESA_screen_surface
-      /* check if scanout surface bit is set */
-      if (nconf->scanout_bit) {
-         EGLint val = GET_CONFIG_ATTRIB(&gconf->base, EGL_SURFACE_TYPE);
-         val |= EGL_SCREEN_BIT_MESA;
-         SET_CONFIG_ATTRIB(&gconf->base, EGL_SURFACE_TYPE, val);
-      }
-#endif
-      valid = _eglValidateConfig(&gconf->base, EGL_FALSE);
-   }
+   valid = init_config_attributes(&gconf->base, api_mask, nconf);
    if (!valid) {
-      _eglLog(_EGL_DEBUG, "skip invalid config 0x%x", mode->visualID);
+      _eglLog(_EGL_DEBUG, "skip invalid config 0x%x", nconf->native_visual_id);
       return EGL_FALSE;
    }
 
diff --git a/src/gallium/state_trackers/egl/common/native.h b/src/gallium/state_trackers/egl/common/native.h
index 5ab21b639ea..628befeae26 100644
--- a/src/gallium/state_trackers/egl/common/native.h
+++ b/src/gallium/state_trackers/egl/common/native.h
@@ -27,8 +27,6 @@
 #define _NATIVE_H_
 
 #include "EGL/egl.h"  /* for EGL native types */
-#include "GL/gl.h" /* for GL types needed by __GLcontextModes */
-#include "GL/internal/glcore.h"  /* for __GLcontextModes */
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_screen.h"
@@ -102,15 +100,28 @@ struct native_surface {
    void (*wait)(struct native_surface *nsurf);
 };
 
+/**
+ * Describe a native display config.
+ */
 struct native_config {
-   /* __GLcontextModes should go away some day */
-   __GLcontextModes mode;
+   /* available buffers and their format */
+   uint buffer_mask;
    enum pipe_format color_format;
    enum pipe_format depth_format;
    enum pipe_format stencil_format;
 
-   /* treat it as an additional flag to mode.drawableType */
+   /* supported surface types */
+   boolean window_bit;
+   boolean pixmap_bit;
    boolean scanout_bit;
+
+   int native_visual_id;
+   int native_visual_type;
+   int level;
+   int samples;
+   boolean slow_config;
+   boolean transparent_rgb;
+   int transparent_rgb_values[3];
 };
 
 /**
@@ -142,17 +153,13 @@ struct native_display {
    /**
     * Get the supported configs.  The configs are owned by the display, but
     * the returned array should be free()ed.
-    *
-    * The configs will be converted to EGL config by
-    * _eglConfigFromContextModesRec and validated by _eglValidateConfig.
-    * Those failing to pass the test will be skipped.
     */
    const struct native_config **(*get_configs)(struct native_display *ndpy,
                                                int *num_configs);
 
    /**
     * Test if a pixmap is supported by the given config.  Required unless no
-    * config has GLX_PIXMAP_BIT set.
+    * config has pixmap_bit set.
     *
     * This function is usually called to find a config that supports a given
     * pixmap.  Thus, it is usually called with the same pixmap in a row.
@@ -163,16 +170,14 @@ struct native_display {
 
 
    /**
-    * Create a window surface.  Required unless no config has GLX_WINDOW_BIT
-    * set.
+    * Create a window surface.  Required unless no config has window_bit set.
     */
    struct native_surface *(*create_window_surface)(struct native_display *ndpy,
                                                    EGLNativeWindowType win,
                                                    const struct native_config *nconf);
 
    /**
-    * Create a pixmap surface.  Required unless no config has GLX_PIXMAP_BIT
-    * set.
+    * Create a pixmap surface.  Required unless no config has pixmap_bit set.
     */
    struct native_surface *(*create_pixmap_surface)(struct native_display *ndpy,
                                                    EGLNativePixmapType pix,
diff --git a/src/gallium/state_trackers/egl/common/native_modeset.h b/src/gallium/state_trackers/egl/common/native_modeset.h
index 154d58381dc..dee757b3a88 100644
--- a/src/gallium/state_trackers/egl/common/native_modeset.h
+++ b/src/gallium/state_trackers/egl/common/native_modeset.h
@@ -64,8 +64,8 @@ struct native_display_modeset {
                                            int *num_modes);
 
    /**
-    * Create a scan-out surface.  Required unless no config has
-    * GLX_SCREEN_BIT_MESA set.
+    * Create a scan-out surface.  Required unless no config has scanout_bit
+    * set.
     */
    struct native_surface *(*create_scanout_surface)(struct native_display *ndpy,
                                                     const struct native_config *nconf,
diff --git a/src/gallium/state_trackers/egl/kms/native_kms.c b/src/gallium/state_trackers/egl/kms/native_kms.c
index e88c5294763..f8c55990237 100644
--- a/src/gallium/state_trackers/egl/kms/native_kms.c
+++ b/src/gallium/state_trackers/egl/kms/native_kms.c
@@ -587,8 +587,9 @@ kms_display_get_configs(struct native_display *ndpy, int *num_configs)
 
       nconf = &kdpy->config->base;
 
-      /* always double-buffered */
-      nconf->mode.doubleBufferMode = TRUE;
+      nconf->buffer_mask =
+         (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
+         (1 << NATIVE_ATTACHMENT_BACK_LEFT);
 
       format = PIPE_FORMAT_B8G8R8A8_UNORM;
       if (!kms_display_is_format_supported(&kdpy->base, format, TRUE)) {
@@ -600,11 +601,6 @@ kms_display_get_configs(struct native_display *ndpy, int *num_configs)
          return NULL;
 
       nconf->color_format = format;
-      nconf->mode.redBits = 8;
-      nconf->mode.greenBits = 8;
-      nconf->mode.blueBits = 8;
-      nconf->mode.alphaBits = 8;
-      nconf->mode.rgbBits = 32;
 
       format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
       if (!kms_display_is_format_supported(&kdpy->base, format, FALSE)) {
@@ -612,26 +608,10 @@ kms_display_get_configs(struct native_display *ndpy, int *num_configs)
          if (!kms_display_is_format_supported(&kdpy->base, format, FALSE))
             format = PIPE_FORMAT_NONE;
       }
-      if (format != PIPE_FORMAT_NONE) {
-         nconf->depth_format = format;
-         nconf->stencil_format = format;
-
-         nconf->mode.depthBits = 24;
-         nconf->mode.stencilBits = 8;
-         nconf->mode.haveDepthBuffer = TRUE;
-         nconf->mode.haveStencilBuffer = TRUE;
-      }
+      nconf->depth_format = format;
+      nconf->stencil_format = format;
 
       nconf->scanout_bit = TRUE;
-      nconf->mode.drawableType = GLX_PBUFFER_BIT;
-      nconf->mode.swapMethod = GLX_SWAP_EXCHANGE_OML;
-
-      nconf->mode.visualID = 0;
-      nconf->mode.visualType = EGL_NONE;
-
-      nconf->mode.renderType = GLX_RGBA_BIT;
-      nconf->mode.rgbMode = TRUE;
-      nconf->mode.xRenderable = FALSE;
    }
 
    configs = malloc(sizeof(*configs));
diff --git a/src/gallium/state_trackers/egl/x11/native_dri2.c b/src/gallium/state_trackers/egl/x11/native_dri2.c
index 10a36ff8f63..167115708cb 100644
--- a/src/gallium/state_trackers/egl/x11/native_dri2.c
+++ b/src/gallium/state_trackers/egl/x11/native_dri2.c
@@ -537,31 +537,23 @@ dri2_display_convert_config(struct native_display *ndpy,
    if (!mode->doubleBufferMode)
       return FALSE;
 
-   nconf->mode = *mode;
-   nconf->mode.renderType = GLX_RGBA_BIT;
-   nconf->mode.rgbMode = TRUE;
-   /* pbuffer is always supported */
-   nconf->mode.drawableType |= GLX_PBUFFER_BIT;
-   /* the swap method is always copy */
-   nconf->mode.swapMethod = GLX_SWAP_COPY_OML;
-
-   /* fix up */
-   nconf->mode.rgbBits =
-      nconf->mode.redBits + nconf->mode.greenBits +
-      nconf->mode.blueBits + nconf->mode.alphaBits;
-   if (!(nconf->mode.drawableType & GLX_WINDOW_BIT)) {
-      nconf->mode.visualID = 0;
-      nconf->mode.visualType = GLX_NONE;
-   }
-   if (!(nconf->mode.drawableType & GLX_PBUFFER_BIT)) {
-      nconf->mode.bindToTextureRgb = FALSE;
-      nconf->mode.bindToTextureRgba = FALSE;
-   }
+   /* only interested in native renderable configs */
+   if (!mode->xRenderable || !mode->drawableType)
+      return FALSE;
 
    nconf->color_format = PIPE_FORMAT_NONE;
    nconf->depth_format = PIPE_FORMAT_NONE;
    nconf->stencil_format = PIPE_FORMAT_NONE;
 
+   nconf->buffer_mask = 1 << NATIVE_ATTACHMENT_FRONT_LEFT;
+   if (mode->doubleBufferMode)
+      nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_BACK_LEFT;
+   if (mode->stereoMode) {
+      nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_FRONT_RIGHT;
+      if (mode->doubleBufferMode)
+         nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_BACK_RIGHT;
+   }
+
    /* choose color format */
    num_formats = choose_color_format(mode, formats);
    for (i = 0; i < num_formats; i++) {
@@ -582,10 +574,29 @@ dri2_display_convert_config(struct native_display *ndpy,
          break;
       }
    }
-   if ((nconf->mode.depthBits && nconf->depth_format == PIPE_FORMAT_NONE) ||
-       (nconf->mode.stencilBits && nconf->stencil_format == PIPE_FORMAT_NONE))
+   if ((mode->depthBits && nconf->depth_format == PIPE_FORMAT_NONE) ||
+       (mode->stencilBits && nconf->stencil_format == PIPE_FORMAT_NONE))
       return FALSE;
 
+   if (mode->drawableType & GLX_WINDOW_BIT)
+      nconf->window_bit = TRUE;
+   if (mode->drawableType & GLX_PIXMAP_BIT)
+      nconf->pixmap_bit = TRUE;
+
+   nconf->native_visual_id = mode->visualID;
+   nconf->native_visual_type = mode->visualType;
+   nconf->level = mode->level;
+   nconf->samples = mode->samples;
+
+   nconf->slow_config = (mode->visualRating == GLX_SLOW_CONFIG);
+
+   if (mode->transparentPixel == GLX_TRANSPARENT_RGB) {
+      nconf->transparent_rgb = TRUE;
+      nconf->transparent_rgb_values[0] = mode->transparentRed;
+      nconf->transparent_rgb_values[1] = mode->transparentGreen;
+      nconf->transparent_rgb_values[2] = mode->transparentBlue;
+   }
+
    return TRUE;
 }
 
diff --git a/src/gallium/state_trackers/egl/x11/native_ximage.c b/src/gallium/state_trackers/egl/x11/native_ximage.c
index 1b28dbce772..9d6d63344c3 100644
--- a/src/gallium/state_trackers/egl/x11/native_ximage.c
+++ b/src/gallium/state_trackers/egl/x11/native_ximage.c
@@ -484,16 +484,15 @@ ximage_display_get_configs(struct native_display *ndpy, int *num_configs)
       for (i = 0; i < num_visuals; i++) {
          for (j = 0; j < 2; j++) {
             struct ximage_config *xconf = &xdpy->configs[count];
-            __GLcontextModes *mode = &xconf->base.mode;
 
             xconf->visual = &visuals[i];
             xconf->base.color_format = choose_format(xconf->visual);
             if (xconf->base.color_format == PIPE_FORMAT_NONE)
                continue;
 
-            x11_screen_convert_visual(xdpy->xscr, xconf->visual, mode);
-            /* support double buffer mode */
-            mode->doubleBufferMode = TRUE;
+            xconf->base.buffer_mask =
+               (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
+               (1 << NATIVE_ATTACHMENT_BACK_LEFT);
 
             xconf->base.depth_format = PIPE_FORMAT_NONE;
             xconf->base.stencil_format = PIPE_FORMAT_NONE;
@@ -501,23 +500,19 @@ ximage_display_get_configs(struct native_display *ndpy, int *num_configs)
             if (j == 1) {
                xconf->base.depth_format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
                xconf->base.stencil_format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-               mode->depthBits = 24;
-               mode->stencilBits = 8;
-               mode->haveDepthBuffer = TRUE;
-               mode->haveStencilBuffer = TRUE;
             }
 
-            mode->maxPbufferWidth = 4096;
-            mode->maxPbufferHeight = 4096;
-            mode->maxPbufferPixels = 4096 * 4096;
-            mode->drawableType =
-               GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
-            mode->swapMethod = GLX_SWAP_EXCHANGE_OML;
-
-            if (mode->alphaBits)
-               mode->bindToTextureRgba = TRUE;
-            else
-               mode->bindToTextureRgb = TRUE;
+            xconf->base.window_bit = TRUE;
+            xconf->base.pixmap_bit = TRUE;
+
+            xconf->base.native_visual_id = xconf->visual->visualid;
+#if defined(__cplusplus) || defined(c_plusplus)
+            xconf->base.native_visual_type = xconf->visual->c_class;
+#else
+            xconf->base.native_visual_type = xconf->visual->class;
+#endif
+
+            xconf->base.slow_config = TRUE;
 
             count++;
          }
diff --git a/src/gallium/state_trackers/egl/x11/x11_screen.c b/src/gallium/state_trackers/egl/x11/x11_screen.c
index b5dfe24342b..dd820a369ef 100644
--- a/src/gallium/state_trackers/egl/x11/x11_screen.c
+++ b/src/gallium/state_trackers/egl/x11/x11_screen.c
@@ -177,63 +177,6 @@ x11_screen_get_visuals(struct x11_screen *xscr, int *num_visuals)
    return xscr->visuals;
 }
 
-void
-x11_screen_convert_visual(struct x11_screen *xscr, const XVisualInfo *visual,
-                          __GLcontextModes *mode)
-{
-   int r, g, b, a;
-   int visual_type;
-
-   r = util_bitcount(visual->red_mask);
-   g = util_bitcount(visual->green_mask);
-   b = util_bitcount(visual->blue_mask);
-   a = visual->depth - (r + g + b);
-#if defined(__cplusplus) || defined(c_plusplus)
-   visual_type = visual->c_class;
-#else
-   visual_type = visual->class;
-#endif
-
-   /* convert to GLX visual type */
-   switch (visual_type) {
-   case TrueColor:
-      visual_type = GLX_TRUE_COLOR;
-      break;
-   case DirectColor:
-      visual_type = GLX_DIRECT_COLOR;
-      break;
-   case PseudoColor:
-      visual_type = GLX_PSEUDO_COLOR;
-      break;
-   case StaticColor:
-      visual_type = GLX_STATIC_COLOR;
-      break;
-   case GrayScale:
-      visual_type = GLX_GRAY_SCALE;
-      break;
-   case StaticGray:
-      visual_type = GLX_STATIC_GRAY;
-      break;
-   default:
-      visual_type = GLX_NONE;
-      break;
-   }
-
-   mode->rgbBits = r + g + b + a;
-   mode->redBits = r;
-   mode->greenBits = g;
-   mode->blueBits = b;
-   mode->alphaBits = a;
-   mode->visualID = visual->visualid;
-   mode->visualType = visual_type;
-
-   /* sane defaults */
-   mode->renderType = GLX_RGBA_BIT;
-   mode->rgbMode = TRUE;
-   mode->visualRating = GLX_SLOW_CONFIG;
-   mode->xRenderable = TRUE;
-}
-
 /**
  * Return the GLX fbconfigs.
  */
diff --git a/src/gallium/state_trackers/egl/x11/x11_screen.h b/src/gallium/state_trackers/egl/x11/x11_screen.h
index af897337480..a3c5ee1491e 100644
--- a/src/gallium/state_trackers/egl/x11/x11_screen.h
+++ b/src/gallium/state_trackers/egl/x11/x11_screen.h
@@ -29,6 +29,8 @@
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/dri2tokens.h>
+#include "GL/gl.h" /* for GL types needed by __GLcontextModes */
+#include "GL/internal/glcore.h"  /* for __GLcontextModes */
 #include "pipe/p_compiler.h"
 #include "common/native.h"
 
@@ -65,10 +67,6 @@ x11_screen_support(struct x11_screen *xscr, enum x11_screen_extension ext);
 const XVisualInfo *
 x11_screen_get_visuals(struct x11_screen *xscr, int *num_visuals);
 
-void
-x11_screen_convert_visual(struct x11_screen *xscr, const XVisualInfo *visual,
-                          __GLcontextModes *mode);
-
 const __GLcontextModes *
 x11_screen_get_glx_configs(struct x11_screen *xscr);