src/gallium/state_trackers/egl/wayland/native_drm.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.11
   4  *
   5  * Copyright (C) 2011 Benjamin Franzke <benjaminfranzke@googlemail.com>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include "util/u_memory.h"
  27 #include "util/u_inlines.h"
  28
  29 #include "pipe/p_compiler.h"
  30 #include "pipe/p_screen.h"
  31 #include "pipe/p_context.h"
  32 #include "pipe/p_state.h"
  33 #include "state_tracker/drm_driver.h"
  34
  35 #include "egllog.h"
  36 #include <errno.h>
  37
  38 #include "native_wayland.h"
  39
  40 #include <wayland-client.h>
  41 #include "wayland-drm-client-protocol.h"
  42 #include "wayland-egl-priv.h"
  43
  44 #include "common/native_wayland_drm_bufmgr_helper.h"
  45
  46 #include <xf86drm.h>
  47 #include <sys/types.h>
  48 #include <sys/stat.h>
  49 #include <fcntl.h>
  50
  51 struct wayland_drm_display {
  52    struct wayland_display base;
  53
  54    const struct native_event_handler *event_handler;
  55
  56    struct wl_drm *wl_drm;
  57    struct wl_drm *wl_server_drm; /* for EGL_WL_bind_wayland_display */
  58    int fd;
  59    char *device_name;
  60    boolean authenticated;
  61 };
  62
  63 static INLINE struct wayland_drm_display *
  64 wayland_drm_display(const struct native_display *ndpy)
  65 {
  66    return (struct wayland_drm_display *) ndpy;
  67 }
  68
  69 static void
  70 sync_callback(void *data)
  71 {
  72    int *done = data;
  73
  74    *done = 1;
  75 }
  76
  77 static void
  78 force_roundtrip(struct wl_display *display)
  79 {
  80    int done = 0;
  81
  82    wl_display_sync_callback(display, sync_callback, &done);
  83    wl_display_iterate(display, WL_DISPLAY_WRITABLE);
  84    while (!done)
  85       wl_display_iterate(display, WL_DISPLAY_READABLE);
  86 }
  87
  88 static void
  89 wayland_drm_display_destroy(struct native_display *ndpy)
  90 {
  91    struct wayland_drm_display *drmdpy = wayland_drm_display(ndpy);
  92
  93    if (drmdpy->fd)
  94       close(drmdpy->fd);
  95    if (drmdpy->wl_drm)
  96       wl_drm_destroy(drmdpy->wl_drm);
  97    if (drmdpy->device_name)
  98       FREE(drmdpy->device_name);
  99    if (drmdpy->base.config)
 100       FREE(drmdpy->base.config);
 101    if (drmdpy->base.own_dpy)
 102       wl_display_destroy(drmdpy->base.dpy);
 103
 104    ndpy_uninit(ndpy);
 105
 106    FREE(drmdpy);
 107 }
 108
 109 static struct wl_buffer *
 110 wayland_create_drm_buffer(struct wayland_display *display,
 111                           struct wayland_surface *surface,
 112                           enum native_attachment attachment)
 113 {
 114    struct wayland_drm_display *drmdpy = (struct wayland_drm_display *) display;
 115    struct pipe_screen *screen = drmdpy->base.base.screen;
 116    struct pipe_resource *resource;
 117    struct winsys_handle wsh;
 118    uint width, height;
 119    struct wl_visual *visual;
 120
 121    resource = resource_surface_get_single_resource(surface->rsurf, attachment);
 122    resource_surface_get_size(surface->rsurf, &width, &height);
 123
 124    wsh.type = DRM_API_HANDLE_TYPE_SHARED;
 125    screen->resource_get_handle(screen, resource, &wsh);
 126
 127    pipe_resource_reference(&resource, NULL);
 128
 129    switch (surface->type) {
 130    case WL_WINDOW_SURFACE:
 131       visual = surface->win->visual;
 132       break;
 133    case WL_PIXMAP_SURFACE:
 134       visual = surface->pix->visual;
 135       break;
 136    default:
 137       return NULL;
 138    }
 139
 140    return wl_drm_create_buffer(drmdpy->wl_drm, wsh.handle,
 141                                width, height, wsh.stride, visual);
 142 }
 143
 144 static void
 145 drm_handle_device(void *data, struct wl_drm *drm, const char *device)
 146 {
 147    struct wayland_drm_display *drmdpy = data;
 148    drm_magic_t magic;
 149
 150    drmdpy->device_name = strdup(device);
 151    if (!drmdpy->device_name)
 152       return;
 153
 154    drmdpy->fd = open(drmdpy->device_name, O_RDWR);
 155    if (drmdpy->fd == -1) {
 156       _eglLog(_EGL_WARNING, "wayland-egl: could not open %s (%s)",
 157               drmdpy->device_name, strerror(errno));
 158       return;
 159    }
 160
 161    drmGetMagic(drmdpy->fd, &magic);
 162    wl_drm_authenticate(drmdpy->wl_drm, magic);
 163 }
 164
 165 static void
 166 drm_handle_authenticated(void *data, struct wl_drm *drm)
 167 {
 168    struct wayland_drm_display *drmdpy = data;
 169
 170    drmdpy->authenticated = true;
 171 }
 172
 173 static const struct wl_drm_listener drm_listener = {
 174    drm_handle_device,
 175    drm_handle_authenticated
 176 };
 177
 178 static boolean
 179 wayland_drm_display_init_screen(struct native_display *ndpy)
 180 {
 181    struct wayland_drm_display *drmdpy = wayland_drm_display(ndpy);
 182    uint32_t id;
 183
 184    id = wl_display_get_global(drmdpy->base.dpy, "wl_drm", 1);
 185    if (id == 0)
 186       force_roundtrip(drmdpy->base.dpy);
 187    id = wl_display_get_global(drmdpy->base.dpy, "wl_drm", 1);
 188    if (id == 0)
 189       return FALSE;
 190
 191    drmdpy->wl_drm = wl_drm_create(drmdpy->base.dpy, id, 1);
 192    if (!drmdpy->wl_drm)
 193       return FALSE;
 194
 195    wl_drm_add_listener(drmdpy->wl_drm, &drm_listener, drmdpy);
 196    force_roundtrip(drmdpy->base.dpy);
 197    if (drmdpy->fd == -1)
 198       return FALSE;
 199
 200    force_roundtrip(drmdpy->base.dpy);
 201    if (!drmdpy->authenticated)
 202       return FALSE;
 203
 204    drmdpy->base.base.screen =
 205       drmdpy->event_handler->new_drm_screen(&drmdpy->base.base,
 206                                             NULL, drmdpy->fd);
 207    if (!drmdpy->base.base.screen) {
 208       _eglLog(_EGL_WARNING, "failed to create DRM screen");
 209       return FALSE;
 210    }
 211
 212    return TRUE;
 213 }
 214
 215 static struct native_display_buffer wayland_drm_display_buffer = {
 216    /* use the helpers */
 217    drm_display_import_native_buffer,
 218    drm_display_export_native_buffer
 219 };
 220
 221 static int
 222 wayland_drm_display_authenticate(void *user_data, uint32_t magic)
 223 {
 224    struct native_display *ndpy = user_data;
 225    struct wayland_drm_display *drmdpy = wayland_drm_display(ndpy);
 226    boolean current_authenticate, authenticated;
 227
 228    current_authenticate = drmdpy->authenticated;
 229
 230    wl_drm_authenticate(drmdpy->wl_drm, magic);
 231    force_roundtrip(drmdpy->base.dpy);
 232    authenticated = drmdpy->authenticated;
 233
 234    drmdpy->authenticated = current_authenticate;
 235
 236    return authenticated ? 0 : -1;
 237 }
 238
 239 static struct wayland_drm_callbacks wl_drm_callbacks = {
 240    wayland_drm_display_authenticate,
 241    egl_g3d_wl_drm_helper_reference_buffer,
 242    egl_g3d_wl_drm_helper_unreference_buffer
 243 };
 244
 245 static boolean
 246 wayland_drm_display_bind_wayland_display(struct native_display *ndpy,
 247                                          struct wl_display *wl_dpy)
 248 {
 249    struct wayland_drm_display *drmdpy = wayland_drm_display(ndpy);
 250
 251    if (drmdpy->wl_server_drm)
 252       return FALSE;
 253
 254    drmdpy->wl_server_drm =
 255       wayland_drm_init(wl_dpy, drmdpy->device_name,
 256                        &wl_drm_callbacks, ndpy);
 257
 258    if (!drmdpy->wl_server_drm)
 259       return FALSE;
 260
 261    return TRUE;
 262 }
 263
 264 static boolean
 265 wayland_drm_display_unbind_wayland_display(struct native_display *ndpy,
 266                                            struct wl_display *wl_dpy)
 267 {
 268    struct wayland_drm_display *drmdpy = wayland_drm_display(ndpy);
 269
 270    if (!drmdpy->wl_server_drm)
 271       return FALSE;
 272
 273    wayland_drm_uninit(drmdpy->wl_server_drm);
 274    drmdpy->wl_server_drm = NULL;
 275
 276    return TRUE;
 277 }
 278
 279 static struct native_display_wayland_bufmgr wayland_drm_display_wayland_bufmgr = {
 280    wayland_drm_display_bind_wayland_display,
 281    wayland_drm_display_unbind_wayland_display,
 282    egl_g3d_wl_drm_common_wl_buffer_get_resource
 283 };
 284
 285
 286 struct wayland_display *
 287 wayland_create_drm_display(struct wl_display *dpy,
 288                            const struct native_event_handler *event_handler)
 289 {
 290    struct wayland_drm_display *drmdpy;
 291
 292    drmdpy = CALLOC_STRUCT(wayland_drm_display);
 293    if (!drmdpy)
 294       return NULL;
 295
 296    drmdpy->event_handler = event_handler;
 297
 298    drmdpy->base.dpy = dpy;
 299    if (!drmdpy->base.dpy) {
 300       wayland_drm_display_destroy(&drmdpy->base.base);
 301       return NULL;
 302    }
 303
 304    drmdpy->base.base.init_screen = wayland_drm_display_init_screen;
 305    drmdpy->base.base.destroy = wayland_drm_display_destroy;
 306    drmdpy->base.base.buffer = &wayland_drm_display_buffer;
 307    drmdpy->base.base.wayland_bufmgr = &wayland_drm_display_wayland_bufmgr;
 308
 309    drmdpy->base.create_buffer = wayland_create_drm_buffer;
 310
 311    return &drmdpy->base;
 312 }
 313
 314 /* vim: set sw=3 ts=8 sts=3 expandtab: */