path: root/0005-backend-drm-Add-support-for-EGLDevice-EGLOutput.patch

From 8f9701ca16c53caa96edbdf0d0e5fc5cd6f6efbe Mon Sep 17 00:00:00 2001
From: "Miguel A. Vico" <mvicomoya@nvidia.com>
Date: Mon, 26 Aug 2019 09:48:49 -0700
Subject: [PATCH 5/6] backend-drm: Add support for EGLDevice+EGLOutput

As previously stated, EGLDevice and EGLOutput will provide means
to access native device objects and different portions of display
control hardware respectively.

Whenever EGL_EXT_device_drm extension is present, EGLDevice can
be used to enumerate and access DRM KMS devices, and EGLOutputLayer
to enumerate and access DRM KMS crtcs and planes.

By using EGLStreams and attaching an EGLOutputLayer consumer
(representing a DRM KMS crtc or plane) to it, backend-drm can
produce final composition frames and present them on a DRM device.

This change adds required logic to support presentation through
EGLDevice+EGLOutput+EGLStream. Whether GBM or EGLDevice should be
used can be controlled by --use-egldevice backend argument.

Signed-off-by: Miguel A Vico Moya <mvicomoya@nvidia.com>
Reviewed-by: Andy Ritger <aritger@nvidia.com>
Reviewed-by: Adam Cheney <acheney@nvidia.com>
Reviewed-by: James Jones <jajones@nvidia.com>
---
 compositor/main.c                            |   4 +-
 include/libweston/backend-drm.h              |   4 +
 libweston/backend-drm/drm-gbm.c              | 262 +++++++++++++------
 libweston/backend-drm/drm-internal.h         |  14 +
 libweston/backend-drm/drm.c                  |  15 +-
 libweston/backend-drm/kms.c                  |  23 +-
 libweston/backend-headless/headless.c        |   1 +
 libweston/backend-wayland/wayland.c          |   1 +
 libweston/backend-x11/x11.c                  |   1 +
 libweston/renderer-gl/egl-glue.c             |   5 +-
 libweston/renderer-gl/gl-renderer-internal.h |   4 +-
 libweston/renderer-gl/gl-renderer.c          |   4 +-
 libweston/renderer-gl/gl-renderer.h          |   2 +
 shared/weston-egl-ext.h                      |   9 +
 14 files changed, 259 insertions(+), 90 deletions(-)

diff --git a/compositor/main.c b/compositor/main.c
index 65da9dbc..2361cc63 100644
--- a/compositor/main.c
+++ b/compositor/main.c
@@ -677,7 +677,8 @@ usage(int error_code)
 		"  --drm-device=CARD\tThe DRM device to use, e.g. \"card0\".\n"
 		"  --use-pixman\t\tUse the pixman (CPU) renderer\n"
 		"  --current-mode\tPrefer current KMS mode over EDID preferred mode\n"
-		"  --continue-without-input\tAllow the compositor to start without input devices\n\n");
+		"  --continue-without-input\tAllow the compositor to start without input devices\n\n"
+		"  --use-egldevice\tUse EGLDevice and EGLOutput with the GL renderer\n");
 #endif
 
 #if defined(BUILD_FBDEV_COMPOSITOR)
@@ -2525,6 +2526,7 @@ load_drm_backend(struct weston_compositor *c,
 		{ WESTON_OPTION_BOOLEAN, "current-mode", 0, &wet->drm_use_current_mode },
 		{ WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
 		{ WESTON_OPTION_BOOLEAN, "continue-without-input", 0, &config.continue_without_input },
+		{ WESTON_OPTION_BOOLEAN, "use-egldevice", 0, &config.use_egldevice },
 	};
 
 	parse_options(options, ARRAY_LENGTH(options), argc, argv);
diff --git a/include/libweston/backend-drm.h b/include/libweston/backend-drm.h
index 350eeb0d..8916f98d 100644
--- a/include/libweston/backend-drm.h
+++ b/include/libweston/backend-drm.h
@@ -177,6 +177,10 @@ struct weston_drm_backend_config {
 	/** Whether to use the pixman renderer instead of the OpenGL ES renderer. */
 	bool use_pixman;
 
+	/** Whether to use the GL composition based off EGLDevice & friends instead
+	 * of GBM. */
+	bool use_egldevice;
+
 	/** The seat to be used for input and output.
 	 *
 	 * If seat_id is NULL, the seat is taken from XDG_SEAT environment
diff --git a/libweston/backend-drm/drm-gbm.c b/libweston/backend-drm/drm-gbm.c
index 30609e3e..04a9f89b 100644
--- a/libweston/backend-drm/drm-gbm.c
+++ b/libweston/backend-drm/drm-gbm.c
@@ -51,11 +51,6 @@ create_gbm_device(int fd)
 {
 	struct gbm_device *gbm;
 
-	gl_renderer = weston_load_module("gl-renderer.so",
-					 "gl_renderer_interface");
-	if (!gl_renderer)
-		return NULL;
-
 	/* GBM will load a dri driver, but even though they need symbols from
 	 * libglapi, in some version of Mesa they are not linked to it. Since
 	 * only the gl-renderer module links to it, the call above won't make
@@ -68,6 +63,40 @@ create_gbm_device(int fd)
 	return gbm;
 }
 
+static EGLDeviceEXT
+find_egldevice(const char *filename)
+{
+	EGLDeviceEXT egldevice = EGL_NO_DEVICE_EXT;
+	EGLDeviceEXT *devices;
+	EGLint num_devices;
+	const char *drm_path;
+	int i;
+
+	if (gl_renderer->get_devices(0, NULL, &num_devices) < 0 ||
+	    num_devices < 1)
+		return EGL_NO_DEVICE_EXT;
+
+	devices = zalloc(num_devices * sizeof *devices);
+	if (!devices)
+		return EGL_NO_DEVICE_EXT;
+
+	if (gl_renderer->get_devices(num_devices, devices, &num_devices) < 0) {
+		free(devices);
+		return EGL_NO_DEVICE_EXT;
+	}
+
+	for (i = 0; i < num_devices; i++)
+		if (gl_renderer->get_drm_device_file(devices[i],
+						     &drm_path) == 0 &&
+		    strcmp(filename, drm_path) == 0) {
+			egldevice = devices[i];
+			break;
+		}
+
+	free(devices);
+	return egldevice;
+}
+
 /* When initializing EGL, if the preferred buffer format isn't available
  * we may be able to substitute an ARGB format for an XRGB one.
  *
@@ -98,33 +127,57 @@ drm_backend_create_gl_renderer(struct drm_backend *b)
 		fallback_format_for(b->gbm_format),
 		0,
 	};
-	struct gl_renderer_display_options options = {
-		.egl_platform = EGL_PLATFORM_GBM_KHR,
-		.egl_native_display = b->gbm,
-		.egl_surface_type = EGL_WINDOW_BIT,
-		.drm_formats = format,
-		.drm_formats_count = 2,
+
+	EGLint device_platform_attribs[] = {
+	    EGL_DRM_MASTER_FD_EXT, b->drm.fd,
+	    EGL_NONE
 	};
 
+	struct gl_renderer_display_options options;
+	if (b->use_egldevice) {
+	    options.egl_platform = EGL_PLATFORM_DEVICE_EXT;
+	    options.egl_native_display = b->egldevice;
+	    options.egl_surface_type = EGL_STREAM_BIT_KHR;
+	    options.egl_platform_attribs = device_platform_attribs;
+	    options.drm_formats = format;
+	    options.drm_formats_count = 2;
+	} else {
+	    options.egl_platform = EGL_PLATFORM_GBM_KHR;
+	    options.egl_native_display = b->gbm;
+	    options.egl_surface_type = EGL_WINDOW_BIT;
+	    options.egl_platform_attribs = NULL;
+	    options.drm_formats = format;
+	    options.drm_formats_count = 2;
+	}
+
 	if (format[1])
 		options.drm_formats_count = 3;
 
-	if (gl_renderer->display_create(b->compositor, &options) < 0)
-		return -1;
-
-	return 0;
+	return gl_renderer->display_create(b->compositor, &options);
 }
 
 int
 init_egl(struct drm_backend *b)
 {
-	b->gbm = create_gbm_device(b->drm.fd);
-
-	if (!b->gbm)
+	gl_renderer = weston_load_module("gl-renderer.so",
+					 "gl_renderer_interface");
+	if (!gl_renderer)
 		return -1;
 
+	if (b->use_egldevice) {
+		b->egldevice = find_egldevice(b->drm.filename);
+		if (b->egldevice == EGL_NO_DEVICE_EXT)
+			return -1;
+	} else {
+		b->gbm = create_gbm_device(b->drm.fd);
+
+		if (!b->gbm)
+			return -1;
+	}
+
 	if (drm_backend_create_gl_renderer(b) < 0) {
-		gbm_device_destroy(b->gbm);
+		if (b->gbm)
+			gbm_device_destroy(b->gbm);
 		return -1;
 	}
 
@@ -181,71 +234,98 @@ err:
 int
 drm_output_init_egl(struct drm_output *output, struct drm_backend *b)
 {
-	uint32_t format[2] = {
+	if (b->use_egldevice) {
+		int w = output->base.current_mode->width;
+		int h = output->base.current_mode->height;
+
+		/* Create a black dumb fb for modesetting */
+		output->dumb[0] = drm_fb_create_dumb(b, w, h,
+						     DRM_FORMAT_XRGB8888);
+		if (!output->dumb[0]) {
+			weston_log("failed to create dumb framebuffer\n");
+			return -1;
+		}
+		memset(output->dumb[0]->map, 0, output->dumb[0]->size);
+
+		if (gl_renderer->output_stream_create(&output->base, ~0u,
+						      output->crtc_id) < 0) {
+			weston_log("failed to create gl renderer output stream "
+				   "state\n");
+			drm_fb_unref(output->dumb[0]);
+			output->dumb[0] = NULL;
+			return -1;
+		}
+
+		/* FIXME: Add hw planes and cursors for EGL device when supported */
+		b->sprites_are_broken = 1;
+		b->cursors_are_broken = 1;
+	} else {
+	    uint32_t format[2] = {
 		output->gbm_format,
 		fallback_format_for(output->gbm_format),
-	};
-	struct gl_renderer_output_options options = {
+	    };
+	    struct gl_renderer_output_options options = {
 		.drm_formats = format,
 		.drm_formats_count = 1,
-	};
-	struct weston_mode *mode = output->base.current_mode;
-	struct drm_plane *plane = output->scanout_plane;
-	unsigned int i;
+	    };
+	    struct weston_mode *mode = output->base.current_mode;
+	    struct drm_plane *plane = output->scanout_plane;
+	    unsigned int i;
 
-	assert(output->gbm_surface == NULL);
+	    assert(output->gbm_surface == NULL);
 
-	for (i = 0; i < plane->count_formats; i++) {
+	    for (i = 0; i < plane->count_formats; i++) {
 		if (plane->formats[i].format == output->gbm_format)
-			break;
-	}
+		    break;
+	    }
 
-	if (i == plane->count_formats) {
+	    if (i == plane->count_formats) {
 		weston_log("format 0x%x not supported by output %s\n",
 			   output->gbm_format, output->base.name);
 		return -1;
-	}
+	    }
 
 #ifdef HAVE_GBM_MODIFIERS
-	if (plane->formats[i].count_modifiers > 0) {
+	    if (plane->formats[i].count_modifiers > 0) {
 		output->gbm_surface =
-			gbm_surface_create_with_modifiers(b->gbm,
-							  mode->width,
-							  mode->height,
-							  output->gbm_format,
-							  plane->formats[i].modifiers,
-							  plane->formats[i].count_modifiers);
-	}
-
-	/* If allocating with modifiers fails, try again without. This can
-	 * happen when the KMS display device supports modifiers but the
-	 * GBM driver does not, e.g. the old i915 Mesa driver. */
-	if (!output->gbm_surface)
+		    gbm_surface_create_with_modifiers(b->gbm,
+						      mode->width,
+						      mode->height,
+						      output->gbm_format,
+						      plane->formats[i].modifiers,
+						      plane->formats[i].count_modifiers);
+	    }
+
+	    /* If allocating with modifiers fails, try again without. This can
+	     * happen when the KMS display device supports modifiers but the
+	     * GBM driver does not, e.g. the old i915 Mesa driver. */
+	    if (!output->gbm_surface)
 #endif
-	{
+	    {
 		output->gbm_surface =
 		    gbm_surface_create(b->gbm, mode->width, mode->height,
 				       output->gbm_format,
 				       output->gbm_bo_flags);
-	}
+	    }
 
-	if (!output->gbm_surface) {
+	    if (!output->gbm_surface) {
 		weston_log("failed to create gbm surface\n");
 		return -1;
-	}
+	    }
 
-	if (options.drm_formats[1])
+	    if (options.drm_formats[1])
 		options.drm_formats_count = 2;
-	options.window_for_legacy = (EGLNativeWindowType) output->gbm_surface;
-	options.window_for_platform = output->gbm_surface;
-	if (gl_renderer->output_window_create(&output->base, &options) < 0) {
+	    options.window_for_legacy = (EGLNativeWindowType) output->gbm_surface;
+	    options.window_for_platform = output->gbm_surface;
+	    if (gl_renderer->output_window_create(&output->base, &options) < 0) {
 		weston_log("failed to create gl renderer output state\n");
 		gbm_surface_destroy(output->gbm_surface);
 		output->gbm_surface = NULL;
 		return -1;
-	}
+	    }
 
-	drm_output_init_cursor_egl(output, b);
+	    drm_output_init_cursor_egl(output, b);
+	}
 
 	return 0;
 }
@@ -258,14 +338,23 @@ drm_output_fini_egl(struct drm_output *output)
 	/* Destroying the GBM surface will destroy all our GBM buffers,
 	 * regardless of refcount. Ensure we destroy them here. */
 	if (!b->shutting_down &&
-	    output->scanout_plane->state_cur->fb &&
-	    output->scanout_plane->state_cur->fb->type == BUFFER_GBM_SURFACE) {
+	    ((output->scanout_plane->state_cur->fb &&
+	      output->scanout_plane->state_cur->fb->type == BUFFER_GBM_SURFACE) ||
+	     b->use_egldevice)) {
 		drm_plane_reset_state(output->scanout_plane);
 	}
 
 	gl_renderer->output_destroy(&output->base);
-	gbm_surface_destroy(output->gbm_surface);
-	output->gbm_surface = NULL;
+
+	if (output->dumb[0]) {
+		drm_fb_unref(output->dumb[0]);
+		output->dumb[0] = NULL;
+	}
+
+	if (output->gbm_surface) {
+		gbm_surface_destroy(output->gbm_surface);
+		output->gbm_surface = NULL;
+	}
 	drm_output_fini_cursor_egl(output);
 }
 
@@ -279,22 +368,25 @@ drm_output_render_gl(struct drm_output_state *state, pixman_region32_t *damage)
 
 	output->base.compositor->renderer->repaint_output(&output->base,
 							  damage);
-
-	bo = gbm_surface_lock_front_buffer(output->gbm_surface);
-	if (!bo) {
-		weston_log("failed to lock front buffer: %s\n",
-			   strerror(errno));
-		return NULL;
-	}
-
-	/* The renderer always produces an opaque image. */
-	ret = drm_fb_get_from_bo(bo, b, true, BUFFER_GBM_SURFACE);
-	if (!ret) {
-		weston_log("failed to get drm_fb for bo\n");
-		gbm_surface_release_buffer(output->gbm_surface, bo);
-		return NULL;
+	if (b->use_egldevice)
+		ret = drm_fb_ref(output->dumb[0]);
+	else {
+		bo = gbm_surface_lock_front_buffer(output->gbm_surface);
+		if (!bo) {
+			weston_log("failed to lock front buffer: %s\n",
+				   strerror(errno));
+			return NULL;
+		}
+	
+		/* The renderer always produces an opaque image. */
+		ret = drm_fb_get_from_bo(bo, b, true, BUFFER_GBM_SURFACE);
+		if (!ret) {
+			weston_log("failed to get drm_fb for bo\n");
+			gbm_surface_release_buffer(output->gbm_surface, bo);
+			return NULL;
+		}
+		ret->gbm_surface = output->gbm_surface;
 	}
-	ret->gbm_surface = output->gbm_surface;
 
 	return ret;
 }
@@ -315,11 +407,20 @@ switch_to_gl_renderer(struct drm_backend *b)
 
 	weston_log("Switching to GL renderer\n");
 
-	b->gbm = create_gbm_device(b->drm.fd);
-	if (!b->gbm) {
-		weston_log("Failed to create gbm device. "
-			   "Aborting renderer switch\n");
-		return;
+	if (b->use_egldevice) {
+		b->egldevice = find_egldevice(b->drm.filename);
+		if (b->egldevice == EGL_NO_DEVICE_EXT) {
+			weston_log("Failed to create EGL device. "
+				   "Aborting renderer switch\n");
+			return;
+		}
+	} else {	
+		b->gbm = create_gbm_device(b->drm.fd);
+		if (!b->gbm) {
+			weston_log("Failed to create gbm device. "
+				   "Aborting renderer switch\n");
+			return;
+		}
 	}
 
 	wl_list_for_each(output, &b->compositor->output_list, base.link)
@@ -328,7 +429,8 @@ switch_to_gl_renderer(struct drm_backend *b)
 	b->compositor->renderer->destroy(b->compositor);
 
 	if (drm_backend_create_gl_renderer(b) < 0) {
-		gbm_device_destroy(b->gbm);
+		if (b->gbm)
+			gbm_device_destroy(b->gbm);
 		weston_log("Failed to create GL renderer. Quitting.\n");
 		/* FIXME: we need a function to shutdown cleanly */
 		assert(0);
diff --git a/libweston/backend-drm/drm-internal.h b/libweston/backend-drm/drm-internal.h
index 06f952f2..8bc9c92b 100644
--- a/libweston/backend-drm/drm-internal.h
+++ b/libweston/backend-drm/drm-internal.h
@@ -60,6 +60,17 @@
 #include "backend.h"
 #include "libweston-internal.h"
 
+#ifdef ENABLE_EGL
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+#else
+
+typedef void *EGLDeviceEXT;
+
+#endif
+
 #ifndef DRM_CLIENT_CAP_ASPECT_RATIO
 #define DRM_CLIENT_CAP_ASPECT_RATIO	4
 #endif
@@ -262,6 +273,9 @@ struct drm_backend {
 	struct wl_listener session_listener;
 	uint32_t gbm_format;
 
+	EGLDeviceEXT egldevice;
+	bool use_egldevice;
+
 	/* we need these parameters in order to not fail drmModeAddFB2()
 	 * due to out of bounds dimensions, and then mistakenly set
 	 * sprites_are_broken:
diff --git a/libweston/backend-drm/drm.c b/libweston/backend-drm/drm.c
index 94a2bf2a..94246bb2 100644
--- a/libweston/backend-drm/drm.c
+++ b/libweston/backend-drm/drm.c
@@ -390,7 +390,8 @@ drm_output_render(struct drm_output_state *state, pixman_region32_t *damage)
 	 * the damaged region into the renderer to re-render the affected
 	 * area.
 	 */
-	if (!pixman_region32_not_empty(damage) &&
+	if (!b->use_egldevice &&
+	    !pixman_region32_not_empty(damage) &&
 	    scanout_plane->state_cur->fb &&
 	    (scanout_plane->state_cur->fb->type == BUFFER_GBM_SURFACE ||
 	     scanout_plane->state_cur->fb->type == BUFFER_PIXMAN_DUMB)) {
@@ -2798,6 +2799,11 @@ recorder_binding(struct weston_keyboard *keyboard, const struct timespec *time,
 	struct drm_output *output;
 	int width, height;
 
+	if (b->use_egldevice) {
+		weston_log("recorder not supported with EGL device\n");
+		return;
+	}
+
 	output = container_of(b->compositor->output_list.next,
 			      struct drm_output, base.link);
 
@@ -2879,6 +2885,13 @@ drm_backend_create(struct weston_compositor *compositor,
 	b->use_pixman = config->use_pixman;
 	b->pageflip_timeout = config->pageflip_timeout;
 	b->use_pixman_shadow = config->use_pixman_shadow;
+	b->use_egldevice = config->use_egldevice;
+	if (b->use_egldevice) {
+#if !BUILD_DRM_GBM
+		weston_log("fatal: drm backend with EGLDevice requires GL renderer.\n");
+		goto err_compositor;
+#endif
+	}
 
 	b->debug = weston_compositor_add_log_scope(compositor, "drm-backend",
 						   "Debug messages from DRM/KMS backend\n",
diff --git a/libweston/backend-drm/kms.c b/libweston/backend-drm/kms.c
index c91e3810..0033dba2 100644
--- a/libweston/backend-drm/kms.c
+++ b/libweston/backend-drm/kms.c
@@ -42,6 +42,11 @@
 #include "pixel-formats.h"
 #include "presentation-time-server-protocol.h"
 
+#if BUILD_DRM_GBM
+#include "renderer-gl/gl-renderer.h"
+extern struct gl_renderer_interface *gl_renderer;
+#endif
+
 #ifndef DRM_FORMAT_MOD_LINEAR
 #define DRM_FORMAT_MOD_LINEAR 0
 #endif
@@ -752,9 +757,19 @@ drm_output_apply_state_legacy(struct drm_output_state *state)
 			   output->crtc_id, scanout_state->plane->plane_id,
 			   pinfo ? pinfo->drm_format_name : "UNKNOWN");
 
-	if (drmModePageFlip(backend->drm.fd, output->crtc_id,
-			    scanout_state->fb->fb_id,
-			    DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
+	if (backend->use_egldevice) {
+#if BUILD_DRM_GBM
+		ret = gl_renderer->output_stream_flip(&output->base, output);
+#else
+		assert(!"Can't flip output EGLStream without GL renderer.\n");
+		ret = -1;
+#endif
+	} else
+		ret = drmModePageFlip(backend->drm.fd, output->crtc_id,
+				      scanout_state->fb->fb_id,
+				      DRM_MODE_PAGE_FLIP_EVENT, output);
+
+	if (ret < 0) {
 		weston_log("queueing pageflip failed: %s\n", strerror(errno));
 		goto err;
 	}
@@ -1468,7 +1483,7 @@ init_kms_caps(struct drm_backend *b)
 		b->universal_planes = (ret == 0);
 	}
 
-	if (b->universal_planes && !getenv("WESTON_DISABLE_ATOMIC")) {
+	if (b->universal_planes && !getenv("WESTON_DISABLE_ATOMIC") && !b->use_egldevice) {
 		ret = drmGetCap(b->drm.fd, DRM_CAP_CRTC_IN_VBLANK_EVENT, &cap);
 		if (ret != 0)
 			cap = 0;
diff --git a/libweston/backend-headless/headless.c b/libweston/backend-headless/headless.c
index c312a0f2..94f4e998 100644
--- a/libweston/backend-headless/headless.c
+++ b/libweston/backend-headless/headless.c
@@ -396,6 +396,7 @@ headless_gl_renderer_init(struct headless_backend *b)
 		.egl_platform = EGL_PLATFORM_SURFACELESS_MESA,
 		.egl_native_display = EGL_DEFAULT_DISPLAY,
 		.egl_surface_type = EGL_PBUFFER_BIT,
+		.egl_platform_attribs = NULL,
 		.drm_formats = headless_formats,
 		.drm_formats_count = ARRAY_LENGTH(headless_formats),
 	};
diff --git a/libweston/backend-wayland/wayland.c b/libweston/backend-wayland/wayland.c
index 60d42bf3..a8bca921 100644
--- a/libweston/backend-wayland/wayland.c
+++ b/libweston/backend-wayland/wayland.c
@@ -2781,6 +2781,7 @@ wayland_backend_create(struct weston_compositor *compositor,
 			.egl_platform = EGL_PLATFORM_WAYLAND_KHR,
 			.egl_native_display = b->parent.wl_display,
 			.egl_surface_type = EGL_WINDOW_BIT,
+			.egl_platform_attribs = NULL,
 			.drm_formats = wayland_formats,
 			.drm_formats_count = ARRAY_LENGTH(wayland_formats),
 		};
diff --git a/libweston/backend-x11/x11.c b/libweston/backend-x11/x11.c
index 387e97a4..46af8f02 100644
--- a/libweston/backend-x11/x11.c
+++ b/libweston/backend-x11/x11.c
@@ -1806,6 +1806,7 @@ init_gl_renderer(struct x11_backend *b)
 		.egl_platform = EGL_PLATFORM_X11_KHR,
 		.egl_native_display = b->dpy,
 		.egl_surface_type = EGL_WINDOW_BIT,
+		.egl_platform_attribs = NULL,
 		.drm_formats = x11_formats,
 		.drm_formats_count = ARRAY_LENGTH(x11_formats),
 	};
diff --git a/libweston/renderer-gl/egl-glue.c b/libweston/renderer-gl/egl-glue.c
index abe10b46..c1fa17d8 100644
--- a/libweston/renderer-gl/egl-glue.c
+++ b/libweston/renderer-gl/egl-glue.c
@@ -457,7 +457,8 @@ gl_renderer_get_egl_config(struct gl_renderer *gr,
 
 int
 gl_renderer_setup_egl_display(struct gl_renderer *gr,
-			      void *native_display)
+			      void *native_display,
+			      const EGLint *attribs)
 {
 	gr->egl_display = NULL;
 
@@ -465,7 +466,7 @@ gl_renderer_setup_egl_display(struct gl_renderer *gr,
 	if (gr->has_platform_base)
 		gr->egl_display = gr->get_platform_display(gr->platform,
 							   native_display,
-							   NULL);
+							   attribs);
 
 	if (!gr->egl_display) {
 		weston_log("warning: either no EGL_EXT_platform_base "
diff --git a/libweston/renderer-gl/gl-renderer-internal.h b/libweston/renderer-gl/gl-renderer-internal.h
index 5b0bd4b5..ae76a81e 100644
--- a/libweston/renderer-gl/gl-renderer-internal.h
+++ b/libweston/renderer-gl/gl-renderer-internal.h
@@ -171,7 +171,9 @@ gl_renderer_get_egl_config(struct gl_renderer *gr,
 			   unsigned drm_formats_count);
 
 int
-gl_renderer_setup_egl_display(struct gl_renderer *gr, void *native_display);
+gl_renderer_setup_egl_display(struct gl_renderer *gr,
+			      void *native_display,
+			      const EGLint *attribs);
 
 int
 gl_renderer_setup_egl_client_extensions(struct gl_renderer *gr);
diff --git a/libweston/renderer-gl/gl-renderer.c b/libweston/renderer-gl/gl-renderer.c
index f834a7cb..19a2e730 100644
--- a/libweston/renderer-gl/gl-renderer.c
+++ b/libweston/renderer-gl/gl-renderer.c
@@ -3800,7 +3800,9 @@ gl_renderer_display_create(struct weston_compositor *ec,
 		gl_renderer_surface_get_content_size;
 	gr->base.surface_copy_content = gl_renderer_surface_copy_content;
 
-	if (gl_renderer_setup_egl_display(gr, options->egl_native_display) < 0)
+	if (gl_renderer_setup_egl_display(gr,
+					  options->egl_native_display,
+					  options->egl_platform_attribs) < 0)
 		goto fail;
 
 	log_egl_info(gr->egl_display);
diff --git a/libweston/renderer-gl/gl-renderer.h b/libweston/renderer-gl/gl-renderer.h
index f46c21c6..8ad069d9 100644
--- a/libweston/renderer-gl/gl-renderer.h
+++ b/libweston/renderer-gl/gl-renderer.h
@@ -49,6 +49,7 @@ typedef intptr_t EGLNativeWindowType;
 #define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
 #define EGL_PBUFFER_BIT                   0x0001
 #define EGL_WINDOW_BIT                    0x0004
+#define EGL_NO_DEVICE_EXT   ((EGLDeviceEXT)0)
 
 #endif /* ENABLE_EGL */
 
@@ -71,6 +72,7 @@ struct gl_renderer_display_options {
 	void *egl_native_display;
 	/** EGL_SURFACE_TYPE bits for the base EGLConfig */
 	EGLint egl_surface_type;
+	const EGLint *egl_platform_attribs;
 	/** Array of DRM pixel formats acceptable for the base EGLConfig */
 	const uint32_t *drm_formats;
 	/** The \c drm_formats array length */
diff --git a/shared/weston-egl-ext.h b/shared/weston-egl-ext.h
index d348a5c0..30e4eaba 100644
--- a/shared/weston-egl-ext.h
+++ b/shared/weston-egl-ext.h
@@ -212,6 +212,10 @@ typedef EGLint (EGLAPIENTRYP PFNEGLDUPNATIVEFENCEFDANDROIDPROC) (EGLDisplay dpy,
 #define EGL_PLATFORM_DEVICE_EXT 0x313F
 #endif
 
+#ifndef EGL_DRM_MASTER_FD_EXT
+#define EGL_DRM_MASTER_FD_EXT 0x333C
+#endif
+
 /*
  * FIXME: Remove both EGL_EXT_stream_acquire_mode and
  *        EGL_NV_output_drm_flip_event definitions below once both extensions
@@ -261,6 +265,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireAttribEXT (EGLDisplay dpy,
 #define EGL_PLATFORM_SURFACELESS_MESA     0x31DD
 #define EGL_PLATFORM_DEVICE_EXT  0x313F
 
+/* EGL_DRM_MASTER_FD_EXT and EGL_NONE enum values are also kept to allow
+ * backend-drm/drm.c to build with EGLDevice and EGLStream support */
+#define EGL_DRM_MASTER_FD_EXT    0x333C
+#define EGL_NONE                 0x3038
+
 #endif /* ENABLE_EGL */
 
 #endif
-- 
2.25.1