diff --git a/src/gallium/state_trackers/egl/wayland/native_drm.c b/src/gallium/state_trackers/egl/wayland/native_drm.c new file mode 100644 index 00000000000..75c871d6030 --- /dev/null +++ b/src/gallium/state_trackers/egl/wayland/native_drm.c @@ -0,0 +1,303 @@ +/* + * Mesa 3-D graphics library + * Version: 7.11 + * + * Copyright (C) 2011 Benjamin Franzke + * + * 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. + */ + +#include "util/u_memory.h" +#include "util/u_inlines.h" + +#include "pipe/p_compiler.h" +#include "pipe/p_screen.h" +#include "pipe/p_context.h" +#include "pipe/p_state.h" +#include "state_tracker/drm_driver.h" + +#include "egllog.h" +#include + +#include "native_wayland.h" + +/* see get_drm_screen_name */ +#include +#include "radeon/drm/radeon_drm_public.h" + +#include +#include "wayland-drm-client-protocol.h" +#include "wayland-egl-priv.h" + +#include +#include +#include +#include + +struct wayland_drm_display { + struct wayland_display base; + + struct native_event_handler *event_handler; + + struct wl_drm *wl_drm; + int fd; + char *device_name; + boolean authenticated; +}; + +static INLINE struct wayland_drm_display * +wayland_drm_display(const struct native_display *ndpy) +{ + return (struct wayland_drm_display *) ndpy; +} + +static void +sync_callback(void *data) +{ + int *done = data; + + *done = 1; +} + +static void +force_roundtrip(struct wl_display *display) +{ + int done = 0; + + wl_display_sync_callback(display, sync_callback, &done); + wl_display_iterate(display, WL_DISPLAY_WRITABLE); + while (!done) + wl_display_iterate(display, WL_DISPLAY_READABLE); +} + +static void +wayland_drm_display_destroy(struct native_display *ndpy) +{ + struct wayland_drm_display *drmdpy = wayland_drm_display(ndpy); + + if (drmdpy->fd) + close(drmdpy->fd); + if (drmdpy->wl_drm) + wl_drm_destroy(drmdpy->wl_drm); + if (drmdpy->device_name) + FREE(drmdpy->device_name); + if (drmdpy->base.config) + FREE(drmdpy->base.config); + + ndpy_uninit(ndpy); + + FREE(drmdpy); +} + +static struct wl_buffer * +wayland_create_drm_buffer(struct wayland_display *display, + struct wayland_surface *surface, + enum native_attachment attachment) +{ + struct wayland_drm_display *drmdpy = (struct wayland_drm_display *) display; + struct pipe_screen *screen = drmdpy->base.base.screen; + struct pipe_resource *resource; + struct winsys_handle wsh; + uint width, height; + struct wl_visual *visual; + + resource = resource_surface_get_single_resource(surface->rsurf, attachment); + resource_surface_get_size(surface->rsurf, &width, &height); + + wsh.type = DRM_API_HANDLE_TYPE_SHARED; + screen->resource_get_handle(screen, resource, &wsh); + + pipe_resource_reference(&resource, NULL); + + switch (surface->type) { + case WL_WINDOW_SURFACE: + visual = surface->win->visual; + break; + case WL_PIXMAP_SURFACE: + visual = surface->pix->visual; + break; + default: + return NULL; + } + + return wl_drm_create_buffer(drmdpy->wl_drm, wsh.handle, + width, height, wsh.stride, visual); +} + +static const char * +get_drm_screen_name(int fd, drmVersionPtr version) +{ + const char *name = version->name; + + if (name && !strcmp(name, "radeon")) { + int chip_id; + struct drm_radeon_info info; + + memset(&info, 0, sizeof(info)); + info.request = RADEON_INFO_DEVICE_ID; + info.value = pointer_to_intptr(&chip_id); + if (drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info)) != 0) + return NULL; + + name = is_r3xx(chip_id) ? "r300" : "r600"; + } + + return name; +} + +static void +drm_handle_device(void *data, struct wl_drm *drm, const char *device) +{ + struct wayland_drm_display *drmdpy = data; + drm_magic_t magic; + + drmdpy->device_name = strdup(device); + if (!drmdpy->device_name) + return; + + drmdpy->fd = open(drmdpy->device_name, O_RDWR); + if (drmdpy->fd == -1) { + _eglLog(_EGL_WARNING, "wayland-egl: could not open %s (%s)", + drmdpy->device_name, strerror(errno)); + return; + } + + drmGetMagic(drmdpy->fd, &magic); + wl_drm_authenticate(drmdpy->wl_drm, magic); +} + +static void +drm_handle_authenticated(void *data, struct wl_drm *drm) +{ + struct wayland_drm_display *drmdpy = data; + + drmdpy->authenticated = true; +} + +static const struct wl_drm_listener drm_listener = { + drm_handle_device, + drm_handle_authenticated +}; + +static boolean +wayland_drm_display_init_screen(struct native_display *ndpy) +{ + struct wayland_drm_display *drmdpy = wayland_drm_display(ndpy); + drmVersionPtr version; + const char *driver_name; + uint32_t id; + + id = wl_display_get_global(drmdpy->base.dpy, "wl_drm", 1); + if (id == 0) + wl_display_iterate(drmdpy->base.dpy, WL_DISPLAY_READABLE); + id = wl_display_get_global(drmdpy->base.dpy, "wl_drm", 1); + if (id == 0) + return FALSE; + + drmdpy->wl_drm = wl_drm_create(drmdpy->base.dpy, id, 1); + if (!drmdpy->wl_drm) + return FALSE; + + wl_drm_add_listener(drmdpy->wl_drm, &drm_listener, drmdpy); + force_roundtrip(drmdpy->base.dpy); + if (drmdpy->fd == -1) + return FALSE; + + force_roundtrip(drmdpy->base.dpy); + if (!drmdpy->authenticated) + return FALSE; + + version = drmGetVersion(drmdpy->fd); + if (!version) { + _eglLog(_EGL_WARNING, "invalid fd %d", drmdpy->fd); + return FALSE; + } + + /* FIXME: share this with native_drm or egl_dri2 */ + driver_name = get_drm_screen_name(drmdpy->fd, version); + + drmdpy->base.base.screen = + drmdpy->event_handler->new_drm_screen(&drmdpy->base.base, + driver_name, drmdpy->fd); + drmFreeVersion(version); + + if (!drmdpy->base.base.screen) { + _eglLog(_EGL_WARNING, "failed to create DRM screen"); + return FALSE; + } + + return TRUE; +} + +static struct pipe_resource * +wayland_drm_display_import_buffer(struct native_display *ndpy, + const struct pipe_resource *templ, + void *buf) +{ + return ndpy->screen->resource_from_handle(ndpy->screen, + templ, (struct winsys_handle *) buf); +} + +static boolean +wayland_drm_display_export_buffer(struct native_display *ndpy, + struct pipe_resource *res, + void *buf) +{ + return ndpy->screen->resource_get_handle(ndpy->screen, + res, (struct winsys_handle *) buf); +} + +static struct native_display_buffer wayland_drm_display_buffer = { + wayland_drm_display_import_buffer, + wayland_drm_display_export_buffer +}; + +struct wayland_display * +wayland_create_drm_display(struct wl_display *dpy, + struct native_event_handler *event_handler, + void *user_data) +{ + struct wayland_drm_display *drmdpy; + + drmdpy = CALLOC_STRUCT(wayland_drm_display); + if (!drmdpy) + return NULL; + + drmdpy->event_handler = event_handler; + drmdpy->base.base.user_data = user_data; + + drmdpy->base.dpy = dpy; + if (!drmdpy->base.dpy) { + wayland_drm_display_destroy(&drmdpy->base.base); + return NULL; + } + + if (!wayland_drm_display_init_screen(&drmdpy->base.base)) { + wayland_drm_display_destroy(&drmdpy->base.base); + return NULL; + } + drmdpy->base.base.destroy = wayland_drm_display_destroy; + drmdpy->base.base.buffer = &wayland_drm_display_buffer; + + drmdpy->base.create_buffer = wayland_create_drm_buffer; + + return &drmdpy->base; +} + +/* vim: set sw=3 ts=8 sts=3 expandtab: */ diff --git a/src/gallium/state_trackers/egl/wayland/native_wayland.c b/src/gallium/state_trackers/egl/wayland/native_wayland.c index b9cf8c48f1e..a684025d6b3 100644 --- a/src/gallium/state_trackers/egl/wayland/native_wayland.c +++ b/src/gallium/state_trackers/egl/wayland/native_wayland.c @@ -31,25 +31,10 @@ #include "pipe/p_context.h" #include "pipe/p_state.h" #include "state_tracker/drm_driver.h" - #include "egllog.h" -#include #include "native_wayland.h" -/* see get_drm_screen_name */ -#include -#include "radeon/drm/radeon_drm_public.h" - -#include -#include "wayland-drm-client-protocol.h" -#include "wayland-egl-priv.h" - -#include -#include -#include -#include - static struct native_event_handler *wayland_event_handler; static void @@ -113,12 +98,12 @@ wayland_display_get_param(struct native_display *ndpy, int val; switch (param) { - case NATIVE_PARAM_USE_NATIVE_BUFFER: - case NATIVE_PARAM_PRESERVE_BUFFER: - case NATIVE_PARAM_MAX_SWAP_INTERVAL: - default: - val = 0; - break; + case NATIVE_PARAM_USE_NATIVE_BUFFER: + case NATIVE_PARAM_PRESERVE_BUFFER: + case NATIVE_PARAM_MAX_SWAP_INTERVAL: + default: + val = 0; + break; } return val; @@ -134,48 +119,6 @@ wayland_display_is_pixmap_supported(struct native_display *ndpy, return TRUE; } -static void -wayland_display_destroy(struct native_display *ndpy) -{ - struct wayland_display *display = wayland_display(ndpy); - - if (display->fd) - close(display->fd); - if (display->wl_drm) - wl_drm_destroy(display->wl_drm); - if (display->device_name) - FREE(display->device_name); - if (display->config) - FREE(display->config); - - ndpy_uninit(ndpy); - - FREE(display); -} - - -static struct wl_buffer * -wayland_create_buffer(struct wayland_surface *surface, - enum native_attachment attachment) -{ - struct wayland_display *display = surface->display; - struct pipe_resource *resource; - struct winsys_handle wsh; - uint width, height; - - resource = resource_surface_get_single_resource(surface->rsurf, attachment); - resource_surface_get_size(surface->rsurf, &width, &height); - - wsh.type = DRM_API_HANDLE_TYPE_SHARED; - display->base.screen->resource_get_handle(display->base.screen, resource, &wsh); - - pipe_resource_reference(&resource, NULL); - - return wl_drm_create_buffer(display->wl_drm, wsh.handle, - width, height, - wsh.stride, surface->win->visual); -} - static void wayland_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap) { @@ -188,7 +131,7 @@ wayland_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap) wl_buffer_destroy(egl_pixmap->buffer); egl_pixmap->buffer = NULL; } - + egl_pixmap->driver_private = NULL; egl_pixmap->destroy = NULL; } @@ -196,26 +139,16 @@ wayland_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap) static void wayland_pixmap_surface_initialize(struct wayland_surface *surface) { - struct native_display *ndpy = &surface->display->base; - struct pipe_resource *resource; - struct winsys_handle wsh; + struct wayland_display *display = wayland_display(&surface->display->base); const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT; if (surface->pix->buffer != NULL) return; - resource = resource_surface_get_single_resource(surface->rsurf, front_natt); - - wsh.type = DRM_API_HANDLE_TYPE_SHARED; - ndpy->screen->resource_get_handle(ndpy->screen, resource, &wsh); - - surface->pix->buffer = - wl_drm_create_buffer(surface->display->wl_drm, wsh.handle, - surface->pix->width, surface->pix->height, - wsh.stride, surface->pix->visual); - - surface->pix->destroy = wayland_pixmap_destroy; - surface->pix->driver_private = resource; + surface->pix->buffer = display->create_buffer(display, surface, front_natt); + surface->pix->destroy = wayland_pixmap_destroy; + surface->pix->driver_private = + resource_surface_get_single_resource(surface->rsurf, front_natt); } static void @@ -237,11 +170,11 @@ wayland_window_surface_handle_resize(struct wayland_surface *surface) struct pipe_resource *front_resource; const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT; int i; - + front_resource = resource_surface_get_single_resource(surface->rsurf, front_natt); if (resource_surface_set_size(surface->rsurf, - surface->win->width, surface->win->height)) { + surface->win->width, surface->win->height)) { if (surface->pending_resource) force_roundtrip(display->dpy); @@ -328,17 +261,19 @@ wayland_surface_swap_buffers(struct native_surface *nsurf) if (surface->type == WL_WINDOW_SURFACE) { resource_surface_swap_buffers(surface->rsurf, - NATIVE_ATTACHMENT_FRONT_LEFT, NATIVE_ATTACHMENT_BACK_LEFT, FALSE); + NATIVE_ATTACHMENT_FRONT_LEFT, + NATIVE_ATTACHMENT_BACK_LEFT, FALSE); wayland_buffers_swap(surface->buffer, WL_BUFFER_FRONT, WL_BUFFER_BACK); if (surface->buffer[WL_BUFFER_FRONT] == NULL) surface->buffer[WL_BUFFER_FRONT] = - wayland_create_buffer(surface, NATIVE_ATTACHMENT_FRONT_LEFT); + display->create_buffer(display, surface, + NATIVE_ATTACHMENT_FRONT_LEFT); wl_surface_attach(surface->win->surface, surface->buffer[WL_BUFFER_FRONT], surface->dx, surface->dy); - + resource_surface_get_size(surface->rsurf, (uint *) &surface->win->attached_width, (uint *) &surface->win->attached_height); @@ -348,7 +283,8 @@ wayland_surface_swap_buffers(struct native_surface *nsurf) surface->sequence_number++; wayland_event_handler->invalid_surface(&display->base, - &surface->base, surface->sequence_number); + &surface->base, + surface->sequence_number); return TRUE; } @@ -408,6 +344,8 @@ wayland_surface_destroy(struct native_surface *nsurf) FREE(surface); } + + static struct native_surface * wayland_create_pixmap_surface(struct native_display *ndpy, EGLNativePixmapType pix, @@ -417,6 +355,8 @@ wayland_create_pixmap_surface(struct native_display *ndpy, struct wayland_surface *surface; struct wl_egl_pixmap *egl_pixmap = (struct wl_egl_pixmap *) pix; enum native_attachment natt = NATIVE_ATTACHMENT_FRONT_LEFT; + uint bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW | + PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT; surface = CALLOC_STRUCT(wayland_surface); if (!surface) @@ -434,15 +374,13 @@ wayland_create_pixmap_surface(struct native_display *ndpy, surface->color_format = PIPE_FORMAT_B8G8R8A8_UNORM; surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT); - + surface->rsurf = resource_surface_create(display->base.screen, - surface->color_format, - PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW | - PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT); + surface->color_format, bind); if (!surface->rsurf) { - FREE(surface); - return NULL; + FREE(surface); + return NULL; } resource_surface_set_size(surface->rsurf, @@ -461,6 +399,7 @@ wayland_create_pixmap_surface(struct native_display *ndpy, return &surface->base; } + static struct native_surface * wayland_create_window_surface(struct native_display *ndpy, EGLNativeWindowType win, @@ -469,6 +408,8 @@ wayland_create_window_surface(struct native_display *ndpy, struct wayland_display *display = wayland_display(ndpy); struct wayland_config *config = wayland_config(nconf); struct wayland_surface *surface; + uint bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW | + PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT; surface = CALLOC_STRUCT(wayland_surface); if (!surface) @@ -486,16 +427,14 @@ wayland_create_window_surface(struct native_display *ndpy, surface->buffer[WL_BUFFER_FRONT] = NULL; surface->buffer[WL_BUFFER_BACK] = NULL; surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT) | - (1 << NATIVE_ATTACHMENT_BACK_LEFT); + (1 << NATIVE_ATTACHMENT_BACK_LEFT); surface->rsurf = resource_surface_create(display->base.screen, - surface->color_format, - PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW | - PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT); + surface->color_format, bind); if (!surface->rsurf) { - FREE(surface); - return NULL; + FREE(surface); + return NULL; } surface->base.destroy = wayland_surface_destroy; @@ -506,178 +445,36 @@ wayland_create_window_surface(struct native_display *ndpy, return &surface->base; } -static const char * -get_drm_screen_name(int fd, drmVersionPtr version) -{ - const char *name = version->name; - - if (name && !strcmp(name, "radeon")) { - int chip_id; - struct drm_radeon_info info; - - memset(&info, 0, sizeof(info)); - info.request = RADEON_INFO_DEVICE_ID; - info.value = pointer_to_intptr(&chip_id); - if (drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info)) != 0) - return NULL; - - name = is_r3xx(chip_id) ? "r300" : "r600"; - } - - return name; -} - static void -drm_handle_device(void *data, struct wl_drm *drm, const char *device) -{ - struct wayland_display *display = data; - drm_magic_t magic; - - display->device_name = strdup(device); - if (!display->device_name) - return; - - display->fd = open(display->device_name, O_RDWR); - if (display->fd == -1) { - _eglLog(_EGL_WARNING, "wayland-egl: could not open %s (%s)", - display->device_name, strerror(errno)); - return; - } - - drmGetMagic(display->fd, &magic); - wl_drm_authenticate(display->wl_drm, magic); -} - -static void -drm_handle_authenticated(void *data, struct wl_drm *drm) -{ - struct wayland_display *display = data; - - display->authenticated = true; -} - -static const struct wl_drm_listener drm_listener = { - drm_handle_device, - drm_handle_authenticated -}; - -static boolean -wayland_display_init_screen(struct native_display *ndpy) -{ - struct wayland_display *display = wayland_display(ndpy); - drmVersionPtr version; - const char *driver_name; - uint32_t id; - - id = wl_display_get_global(display->dpy, "wl_drm", 1); - if (id == 0) - wl_display_iterate(display->dpy, WL_DISPLAY_READABLE); - id = wl_display_get_global(display->dpy, "wl_drm", 1); - if (id == 0) - return FALSE; - - display->wl_drm = wl_drm_create(display->dpy, id, 1); - if (!display->wl_drm) - return FALSE; - - wl_drm_add_listener(display->wl_drm, &drm_listener, display); - force_roundtrip(display->dpy); - if (display->fd == -1) - return FALSE; - - force_roundtrip(display->dpy); - if (!display->authenticated) - return FALSE; - - version = drmGetVersion(display->fd); - if (!version) { - _eglLog(_EGL_WARNING, "invalid fd %d", display->fd); - return FALSE; - } - - /* FIXME: share this with native_drm or egl_dri2 */ - driver_name = get_drm_screen_name(display->fd, version); - - display->base.screen = - wayland_event_handler->new_drm_screen(&display->base, - driver_name, display->fd); - drmFreeVersion(version); - - if (!display->base.screen) { - _eglLog(_EGL_WARNING, "failed to create DRM screen"); - return FALSE; - } - - return TRUE; -} - - -static void -wayland_set_event_handler(struct native_event_handler *event_handler) +native_set_event_handler(struct native_event_handler *event_handler) { wayland_event_handler = event_handler; } -static struct pipe_resource * -wayland_display_import_buffer(struct native_display *ndpy, - const struct pipe_resource *templ, - void *buf) -{ - return ndpy->screen->resource_from_handle(ndpy->screen, - templ, (struct winsys_handle *) buf); -} - -static boolean -wayland_display_export_buffer(struct native_display *ndpy, - struct pipe_resource *res, - void *buf) -{ - return ndpy->screen->resource_get_handle(ndpy->screen, - res, (struct winsys_handle *) buf); -} - -static struct native_display_buffer wayland_display_buffer = { - wayland_display_import_buffer, - wayland_display_export_buffer -}; - static struct native_display * -wayland_display_create(void *dpy, boolean use_sw, void *user_data) +native_create_display(void *dpy, boolean use_sw, void *user_data) { - struct wayland_display *display; + struct wayland_display *display = NULL; - display = CALLOC_STRUCT(wayland_display); + display = wayland_create_drm_display((struct wl_display *) dpy, + wayland_event_handler, + user_data); if (!display) return NULL; - display->base.user_data = user_data; - - display->dpy = dpy; - if (!display->dpy) { - wayland_display_destroy(&display->base); - return NULL; - } - - if (!wayland_display_init_screen(&display->base)) { - wayland_display_destroy(&display->base); - return NULL; - } - - display->base.destroy = wayland_display_destroy; display->base.get_param = wayland_display_get_param; display->base.get_configs = wayland_display_get_configs; display->base.is_pixmap_supported = wayland_display_is_pixmap_supported; display->base.create_window_surface = wayland_create_window_surface; display->base.create_pixmap_surface = wayland_create_pixmap_surface; - display->base.buffer = &wayland_display_buffer; return &display->base; } static const struct native_platform wayland_platform = { "wayland", /* name */ - wayland_set_event_handler, - wayland_display_create + native_set_event_handler, + native_create_display }; const struct native_platform * @@ -685,3 +482,5 @@ native_get_wayland_platform(void) { return &wayland_platform; } + +/* vim: set sw=3 ts=8 sts=3 expandtab: */ diff --git a/src/gallium/state_trackers/egl/wayland/native_wayland.h b/src/gallium/state_trackers/egl/wayland/native_wayland.h index 14fc9b0fbb2..5c034421f3d 100644 --- a/src/gallium/state_trackers/egl/wayland/native_wayland.h +++ b/src/gallium/state_trackers/egl/wayland/native_wayland.h @@ -33,17 +33,18 @@ #include "common/native_helper.h" #include "wayland-egl-priv.h" -#include "wayland-drm-client-protocol.h" + +struct wayland_surface; struct wayland_display { struct native_display base; struct wayland_config *config; struct wl_display *dpy; - struct wl_drm *wl_drm; - int fd; - char *device_name; - boolean authenticated; + + struct wl_buffer *(*create_buffer)(struct wayland_display *display, + struct wayland_surface *surface, + enum native_attachment attachment); }; enum wayland_buffer_type { @@ -78,7 +79,7 @@ struct wayland_surface { }; struct wayland_config { - struct native_config base; + struct native_config base; }; static INLINE struct wayland_display * @@ -99,4 +100,9 @@ wayland_config(const struct native_config *nconf) return (struct wayland_config *) nconf; } +struct wayland_display * +wayland_create_drm_display(struct wl_display *display, + struct native_event_handler *event_handler, + void *user_data); + #endif /* _NATIVE_WAYLAND_H_ */