egl: drop unused _EGLDriver from WaitClient()

[mesa.git] / src / egl / drivers / dri2 / egl_dri2.c

diff --git a/src/egl/drivers/dri2/egl_dri2.c b/src/egl/drivers/dri2/egl_dri2.c
index 2114077470e48ed8cacde258100e2ba092a8d948..35c48242ce26395e8b2ff4796ec365cb9b7a5cc5 100644 (file)
--- a/src/egl/drivers/dri2/egl_dri2.c
+++ b/src/egl/drivers/dri2/egl_dri2.c
@@ -644,7 +644,7 @@ dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
 }
 
 EGLBoolean
-dri2_add_pbuffer_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *disp)
+dri2_add_pbuffer_configs_for_visuals(_EGLDisplay *disp)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    unsigned int format_count[ARRAY_SIZE(dri2_pbuffer_visuals)] = { 0 };
@@ -1142,7 +1142,7 @@ dri2_setup_extensions(_EGLDisplay *disp)
  * called many times (without a eglTerminate in between).
  */
 static EGLBoolean
-dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp)
+dri2_initialize(_EGLDisplay *disp)
 {
    EGLBoolean ret = EGL_FALSE;
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -1168,22 +1168,22 @@ dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp)
 
    switch (disp->Platform) {
    case _EGL_PLATFORM_SURFACELESS:
-      ret = dri2_initialize_surfaceless(drv, disp);
+      ret = dri2_initialize_surfaceless(disp);
       break;
    case _EGL_PLATFORM_DEVICE:
-      ret = dri2_initialize_device(drv, disp);
+      ret = dri2_initialize_device(disp);
       break;
    case _EGL_PLATFORM_X11:
-      ret = dri2_initialize_x11(drv, disp);
+      ret = dri2_initialize_x11(disp);
       break;
    case _EGL_PLATFORM_DRM:
-      ret = dri2_initialize_drm(drv, disp);
+      ret = dri2_initialize_drm(disp);
       break;
    case _EGL_PLATFORM_WAYLAND:
-      ret = dri2_initialize_wayland(drv, disp);
+      ret = dri2_initialize_wayland(disp);
       break;
    case _EGL_PLATFORM_ANDROID:
-      ret = dri2_initialize_android(drv, disp);
+      ret = dri2_initialize_android(disp);
       break;
    default:
       unreachable("Callers ensure we cannot get here.");
@@ -1311,10 +1311,10 @@ dri2_egl_surface_free_local_buffers(struct dri2_egl_surface *dri2_surf)
  * called many times (without a eglInitialize in between).
  */
 static EGLBoolean
-dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
+dri2_terminate(_EGLDisplay *disp)
 {
    /* Release all non-current Context/Surfaces. */
-   _eglReleaseDisplayResources(drv, disp);
+   _eglReleaseDisplayResources(disp);
 
    dri2_display_release(disp);
 
@@ -1466,7 +1466,7 @@ dri2_fill_context_attribs(struct dri2_egl_context *dri2_ctx,
  * Called via eglCreateContext(), drv->CreateContext().
  */
 static _EGLContext *
-dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
+dri2_create_context(_EGLDisplay *disp, _EGLConfig *conf,
                     _EGLContext *share_list, const EGLint *attrib_list)
 {
    struct dri2_egl_context *dri2_ctx;
@@ -1481,8 +1481,6 @@ dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
    unsigned num_attribs = NUM_ATTRIBS;
    uint32_t ctx_attribs[NUM_ATTRIBS];
 
-   (void) drv;
-
    dri2_ctx = malloc(sizeof *dri2_ctx);
    if (!dri2_ctx) {
       _eglError(EGL_BAD_ALLOC, "eglCreateContext");
@@ -1641,7 +1639,7 @@ dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
  * Called via eglDestroyContext(), drv->DestroyContext().
  */
 static EGLBoolean
-dri2_destroy_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
+dri2_destroy_context(_EGLDisplay *disp, _EGLContext *ctx)
 {
    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -1695,14 +1693,14 @@ dri2_fini_surface(_EGLSurface *surf)
 }
 
 static EGLBoolean
-dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
+dri2_destroy_surface(_EGLDisplay *disp, _EGLSurface *surf)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 
    if (!_eglPutSurface(surf))
       return EGL_TRUE;
 
-   return dri2_dpy->vtbl->destroy_surface(drv, disp, surf);
+   return dri2_dpy->vtbl->destroy_surface(disp, surf);
 }
 
 static void
@@ -1756,7 +1754,7 @@ dri2_create_drawable(struct dri2_egl_display *dri2_dpy,
  * Called via eglMakeCurrent(), drv->MakeCurrent().
  */
 static EGLBoolean
-dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
+dri2_make_current(_EGLDisplay *disp, _EGLSurface *dsurf,
                   _EGLSurface *rsurf, _EGLContext *ctx)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -1862,11 +1860,11 @@ dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
       }
    }
 
-   dri2_destroy_surface(drv, disp, old_dsurf);
-   dri2_destroy_surface(drv, disp, old_rsurf);
+   dri2_destroy_surface(disp, old_dsurf);
+   dri2_destroy_surface(disp, old_rsurf);
 
    if (old_ctx) {
-      dri2_destroy_context(drv, disp, old_ctx);
+      dri2_destroy_context(disp, old_ctx);
       dri2_display_release(old_disp);
    }
 
@@ -1900,51 +1898,48 @@ dri2_surface_get_dri_drawable(_EGLSurface *surf)
  * Called from eglGetProcAddress() via drv->GetProcAddress().
  */
 static _EGLProc
-dri2_get_proc_address(_EGLDriver *drv, const char *procname)
+dri2_get_proc_address(const _EGLDriver *drv, const char *procname)
 {
    return _glapi_get_proc_address(procname);
 }
 
 static _EGLSurface*
-dri2_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
-                           _EGLConfig *conf, void *native_window,
-                           const EGLint *attrib_list)
+dri2_create_window_surface(_EGLDisplay *disp, _EGLConfig *conf,
+                           void *native_window, const EGLint *attrib_list)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
-   return dri2_dpy->vtbl->create_window_surface(drv, disp, conf, native_window,
+   return dri2_dpy->vtbl->create_window_surface(disp, conf, native_window,
                                                 attrib_list);
 }
 
 static _EGLSurface*
-dri2_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
-                           _EGLConfig *conf, void *native_pixmap,
-                           const EGLint *attrib_list)
+dri2_create_pixmap_surface(_EGLDisplay *disp, _EGLConfig *conf,
+                           void *native_pixmap, const EGLint *attrib_list)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    if (!dri2_dpy->vtbl->create_pixmap_surface)
       return NULL;
-   return dri2_dpy->vtbl->create_pixmap_surface(drv, disp, conf, native_pixmap,
+   return dri2_dpy->vtbl->create_pixmap_surface(disp, conf, native_pixmap,
                                                 attrib_list);
 }
 
 static _EGLSurface*
-dri2_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
-                           _EGLConfig *conf, const EGLint *attrib_list)
+dri2_create_pbuffer_surface(_EGLDisplay *disp, _EGLConfig *conf,
+                            const EGLint *attrib_list)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    if (!dri2_dpy->vtbl->create_pbuffer_surface)
       return NULL;
-   return dri2_dpy->vtbl->create_pbuffer_surface(drv, disp, conf, attrib_list);
+   return dri2_dpy->vtbl->create_pbuffer_surface(disp, conf, attrib_list);
 }
 
 static EGLBoolean
-dri2_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
-                   EGLint interval)
+dri2_swap_interval(_EGLDisplay *disp, _EGLSurface *surf, EGLint interval)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    if (!dri2_dpy->vtbl->swap_interval)
       return EGL_TRUE;
-   return dri2_dpy->vtbl->swap_interval(drv, disp, surf, interval);
+   return dri2_dpy->vtbl->swap_interval(disp, surf, interval);
 }
 
 /**
@@ -1984,7 +1979,7 @@ dri2_flush_drawable_for_swapbuffers(_EGLDisplay *disp, _EGLSurface *draw)
 }
 
 static EGLBoolean
-dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
+dri2_swap_buffers(_EGLDisplay *disp, _EGLSurface *surf)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
@@ -1993,7 +1988,7 @@ dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 
    if (ctx && surf)
       dri2_surf_update_fence_fd(ctx, disp, surf);
-   ret = dri2_dpy->vtbl->swap_buffers(drv, disp, surf);
+   ret = dri2_dpy->vtbl->swap_buffers(disp, surf);
 
    /* SwapBuffers marks the end of the frame; reset the damage region for
     * use again next time.
@@ -2006,8 +2001,7 @@ dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 }
 
 static EGLBoolean
-dri2_swap_buffers_with_damage(_EGLDriver *drv, _EGLDisplay *disp,
-                              _EGLSurface *surf,
+dri2_swap_buffers_with_damage(_EGLDisplay *disp, _EGLSurface *surf,
                               const EGLint *rects, EGLint n_rects)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -2018,10 +2012,10 @@ dri2_swap_buffers_with_damage(_EGLDriver *drv, _EGLDisplay *disp,
    if (ctx && surf)
       dri2_surf_update_fence_fd(ctx, disp, surf);
    if (dri2_dpy->vtbl->swap_buffers_with_damage)
-      ret = dri2_dpy->vtbl->swap_buffers_with_damage(drv, disp, surf,
+      ret = dri2_dpy->vtbl->swap_buffers_with_damage(disp, surf,
                                                      rects, n_rects);
    else
-      ret = dri2_dpy->vtbl->swap_buffers(drv, disp, surf);
+      ret = dri2_dpy->vtbl->swap_buffers(disp, surf);
 
    /* SwapBuffers marks the end of the frame; reset the damage region for
     * use again next time.
@@ -2034,7 +2028,7 @@ dri2_swap_buffers_with_damage(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
+dri2_swap_buffers_region(_EGLDisplay *disp, _EGLSurface *surf,
                          EGLint numRects, const EGLint *rects)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -2043,7 +2037,7 @@ dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
 
    if (!dri2_dpy->vtbl->swap_buffers_region)
       return EGL_FALSE;
-   ret = dri2_dpy->vtbl->swap_buffers_region(drv, disp, surf, numRects, rects);
+   ret = dri2_dpy->vtbl->swap_buffers_region(disp, surf, numRects, rects);
 
    /* SwapBuffers marks the end of the frame; reset the damage region for
     * use again next time.
@@ -2056,7 +2050,7 @@ dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
 }
 
 static EGLBoolean
-dri2_set_damage_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
+dri2_set_damage_region(_EGLDisplay *disp, _EGLSurface *surf,
                        EGLint *rects, EGLint n_rects)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -2070,7 +2064,7 @@ dri2_set_damage_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
 }
 
 static EGLBoolean
-dri2_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
+dri2_post_sub_buffer(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
                      EGLint x, EGLint y, EGLint width, EGLint height)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -2080,17 +2074,16 @@ dri2_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
 }
 
 static EGLBoolean
-dri2_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
-                  void *native_pixmap_target)
+dri2_copy_buffers(_EGLDisplay *disp, _EGLSurface *surf, void *native_pixmap_target)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    if (!dri2_dpy->vtbl->copy_buffers)
       return _eglError(EGL_BAD_NATIVE_PIXMAP, "no support for native pixmaps");
-   return dri2_dpy->vtbl->copy_buffers(drv, disp, surf, native_pixmap_target);
+   return dri2_dpy->vtbl->copy_buffers(disp, surf, native_pixmap_target);
 }
 
 static EGLint
-dri2_query_buffer_age(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
+dri2_query_buffer_age(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    if (!dri2_dpy->vtbl->query_buffer_age)
@@ -2099,14 +2092,12 @@ dri2_query_buffer_age(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 }
 
 static EGLBoolean
-dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
+dri2_wait_client(_EGLDisplay *disp, _EGLContext *ctx)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    _EGLSurface *surf = ctx->DrawSurface;
    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
 
-   (void) drv;
-
    /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
     * we need to copy fake to real here.*/
 
@@ -2117,7 +2108,7 @@ dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
 }
 
 static EGLBoolean
-dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
+dri2_wait_native(const _EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
 {
    (void) drv;
    (void) disp;
@@ -2130,8 +2121,7 @@ dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
 }
 
 static EGLBoolean
-dri2_bind_tex_image(_EGLDriver *drv,
-                    _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
+dri2_bind_tex_image(_EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    struct dri2_egl_context *dri2_ctx;
@@ -2142,7 +2132,7 @@ dri2_bind_tex_image(_EGLDriver *drv,
    ctx = _eglGetCurrentContext();
    dri2_ctx = dri2_egl_context(ctx);
 
-   if (!_eglBindTexImage(drv, disp, surf, buffer))
+   if (!_eglBindTexImage(disp, surf, buffer))
       return EGL_FALSE;
 
    switch (surf->TextureFormat) {
@@ -2174,8 +2164,7 @@ dri2_bind_tex_image(_EGLDriver *drv,
 }
 
 static EGLBoolean
-dri2_release_tex_image(_EGLDriver *drv,
-                       _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
+dri2_release_tex_image(_EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    struct dri2_egl_context *dri2_ctx;
@@ -2186,7 +2175,7 @@ dri2_release_tex_image(_EGLDriver *drv,
    ctx = _eglGetCurrentContext();
    dri2_ctx = dri2_egl_context(ctx);
 
-   if (!_eglReleaseTexImage(drv, disp, surf, buffer))
+   if (!_eglReleaseTexImage(disp, surf, buffer))
       return EGL_FALSE;
 
    switch (surf->TextureTarget) {
@@ -2207,7 +2196,7 @@ dri2_release_tex_image(_EGLDriver *drv,
 }
 
 static _EGLImage*
-dri2_create_image(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx,
+dri2_create_image(const _EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx,
                   EGLenum target, EGLClientBuffer buffer,
                   const EGLint *attr_list)
 {
@@ -2477,17 +2466,17 @@ dri2_create_image_khr_texture(_EGLDisplay *disp, _EGLContext *ctx,
 }
 
 static EGLBoolean
-dri2_query_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
+dri2_query_surface(_EGLDisplay *disp, _EGLSurface *surf,
                    EGLint attribute, EGLint *value)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    if (!dri2_dpy->vtbl->query_surface)
-      return _eglQuerySurface(drv, disp, surf, attribute, value);
-   return dri2_dpy->vtbl->query_surface(drv, disp, surf, attribute, value);
+      return _eglQuerySurface(disp, surf, attribute, value);
+   return dri2_dpy->vtbl->query_surface(disp, surf, attribute, value);
 }
 
 static struct wl_buffer*
-dri2_create_wayland_buffer_from_image(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_create_wayland_buffer_from_image(const _EGLDriver *drv, _EGLDisplay *disp,
                                       _EGLImage *img)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -2757,7 +2746,7 @@ dri2_check_dma_buf_format(const _EGLImageAttribs *attrs)
 }
 
 static EGLBoolean
-dri2_query_dma_buf_formats(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_query_dma_buf_formats(const _EGLDriver *drv, _EGLDisplay *disp,
                             EGLint max, EGLint *formats, EGLint *count)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -2788,7 +2777,7 @@ dri2_query_dma_buf_formats(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_query_dma_buf_modifiers(_EGLDriver *drv, _EGLDisplay *disp, EGLint format,
+dri2_query_dma_buf_modifiers(const _EGLDriver *drv, _EGLDisplay *disp, EGLint format,
                              EGLint max, EGLuint64KHR *modifiers,
                              EGLBoolean *external_only, EGLint *count)
 {
@@ -2917,7 +2906,7 @@ dri2_create_image_dma_buf(_EGLDisplay *disp, _EGLContext *ctx,
    return res;
 }
 static _EGLImage *
-dri2_create_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_create_drm_image_mesa(const _EGLDriver *drv, _EGLDisplay *disp,
                            const EGLint *attr_list)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -2989,7 +2978,7 @@ dri2_create_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
+dri2_export_drm_image_mesa(const _EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
                           EGLint *name, EGLint *handle, EGLint *stride)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -3035,7 +3024,7 @@ dri2_can_export_dma_buf_image(_EGLDisplay *disp, _EGLImage *img)
 }
 
 static EGLBoolean
-dri2_export_dma_buf_image_query_mesa(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_export_dma_buf_image_query_mesa(const _EGLDriver *drv, _EGLDisplay *disp,
                                      _EGLImage *img,
                                      EGLint *fourcc, EGLint *nplanes,
                                      EGLuint64KHR *modifiers)
@@ -3080,7 +3069,7 @@ dri2_export_dma_buf_image_query_mesa(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_export_dma_buf_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
+dri2_export_dma_buf_image_mesa(const _EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
                                int *fds, EGLint *strides, EGLint *offsets)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -3128,7 +3117,7 @@ dri2_export_dma_buf_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *im
 #endif
 
 _EGLImage *
-dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_create_image_khr(const _EGLDriver *drv, _EGLDisplay *disp,
                       _EGLContext *ctx, EGLenum target,
                       EGLClientBuffer buffer, const EGLint *attr_list)
 {
@@ -3163,7 +3152,7 @@ dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
+dri2_destroy_image_khr(const _EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    struct dri2_egl_image *dri2_img = dri2_egl_image(image);
@@ -3232,7 +3221,7 @@ dri2_wl_release_buffer(void *user_data, struct wl_drm_buffer *buffer)
 }
 
 static EGLBoolean
-dri2_bind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_bind_wayland_display_wl(const _EGLDriver *drv, _EGLDisplay *disp,
                              struct wl_display *wl_dpy)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -3274,7 +3263,7 @@ dri2_bind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_unbind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_unbind_wayland_display_wl(const _EGLDriver *drv, _EGLDisplay *disp,
                                struct wl_display *wl_dpy)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -3291,7 +3280,7 @@ dri2_unbind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_query_wayland_buffer_wl(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_query_wayland_buffer_wl(const _EGLDriver *drv, _EGLDisplay *disp,
                              struct wl_resource *buffer_resource,
                              EGLint attribute, EGLint *value)
 {
@@ -3351,7 +3340,7 @@ dri2_egl_unref_sync(struct dri2_egl_display *dri2_dpy,
 }
 
 static _EGLSync *
-dri2_create_sync(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_create_sync(const _EGLDriver *drv, _EGLDisplay *disp,
                  EGLenum type, const EGLAttrib *attrib_list)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
@@ -3452,7 +3441,7 @@ dri2_create_sync(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLBoolean
-dri2_destroy_sync(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
+dri2_destroy_sync(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
@@ -3481,7 +3470,7 @@ dri2_destroy_sync(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
 }
 
 static EGLint
-dri2_dup_native_fence_fd(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
+dri2_dup_native_fence_fd(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
 {
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
@@ -3506,7 +3495,7 @@ dri2_dup_native_fence_fd(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
 }
 
 static void
-dri2_set_blob_cache_funcs(_EGLDriver *drv, _EGLDisplay *disp,
+dri2_set_blob_cache_funcs(const _EGLDriver *drv, _EGLDisplay *disp,
                           EGLSetBlobFuncANDROID set,
                           EGLGetBlobFuncANDROID get)
 {
@@ -3517,7 +3506,7 @@ dri2_set_blob_cache_funcs(_EGLDriver *drv, _EGLDisplay *disp,
 }
 
 static EGLint
-dri2_client_wait_sync(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync,
+dri2_client_wait_sync(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync,
                       EGLint flags, EGLTime timeout)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
@@ -3609,7 +3598,7 @@ dri2_client_wait_sync(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync,
 }
 
 static EGLBoolean
-dri2_signal_sync(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync,
+dri2_signal_sync(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync,
                       EGLenum mode)
 {
    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
@@ -3635,7 +3624,7 @@ dri2_signal_sync(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync,
 }
 
 static EGLint
-dri2_server_wait_sync(_EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
+dri2_server_wait_sync(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSync *sync)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
@@ -3674,7 +3663,7 @@ dri2_interop_export_object(_EGLDisplay *disp, _EGLContext *ctx,
    return dri2_dpy->interop->export_object(dri2_ctx->dri_context, in, out);
 }
 
-_EGLDriver _eglDriver = {
+const _EGLDriver _eglDriver = {
    .Initialize = dri2_initialize,
    .Terminate = dri2_terminate,
    .CreateContext = dri2_create_context,