src/egl/wayland/wayland-drm/wayland-drm.c

   1 /*
   2  * Copyright © 2011 Kristian Høgsberg
   3  * Copyright © 2011 Benjamin Franzke
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  20  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  *
  25  * Authors:
  26  *    Kristian Høgsberg <krh@bitplanet.net>
  27  *    Benjamin Franzke <benjaminfranzke@googlemail.com>
  28  */
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <stddef.h>
  34
  35 #include <wayland-server.h>
  36 #include "wayland-drm.h"
  37 #include "wayland-drm-server-protocol.h"
  38
  39 /* Git master of Wayland is moving towards a stable version of the
  40  * protocol, but breaking from 0.85 in the process.  For the time
  41  * being, it's convenient to be able to build Mesa against both master
  42  * and 0.85.x of Wayland.  To make this work we'll do a compile-time
  43  * version check and work around the difference in API and protocol */
  44 #if defined (WAYLAND_VERSION_MAJOR) &&          \
  45         WAYLAND_VERSION_MAJOR == 0 &&           \
  46         WAYLAND_VERSION_MINOR == 85
  47 #define HAS_WAYLAND_0_85
  48 #endif
  49
  50 struct wl_drm {
  51         struct wl_display *display;
  52
  53         void *user_data;
  54         char *device_name;
  55
  56         struct wayland_drm_callbacks *callbacks;
  57 };
  58
  59 static void
  60 destroy_buffer(struct wl_resource *resource)
  61 {
  62         struct wl_drm_buffer *buffer = resource->data;
  63         struct wl_drm *drm = buffer->drm;
  64
  65         drm->callbacks->release_buffer(drm->user_data, buffer);
  66         free(buffer);
  67 }
  68
  69 static void
  70 buffer_destroy(struct wl_client *client, struct wl_resource *resource)
  71 {
  72 #ifdef HAS_WAYLAND_0_85
  73         wl_resource_destroy(resource, 0);
  74 #else
  75         wl_resource_destroy(resource);
  76 #endif
  77 }
  78
  79 #ifdef HAS_WAYLAND_0_85
  80 static void
  81 buffer_damage(struct wl_client *client, struct wl_resource *buffer,
  82               int32_t x, int32_t y, int32_t width, int32_t height)
  83 {
  84 }
  85 #endif
  86
  87 const static struct wl_buffer_interface drm_buffer_interface = {
  88 #ifdef HAS_WAYLAND_0_85
  89         buffer_damage,
  90 #endif
  91         buffer_destroy
  92 };
  93
  94 static void
  95 drm_create_buffer(struct wl_client *client, struct wl_resource *resource,
  96                   uint32_t id, uint32_t name, int32_t width, int32_t height,
  97                   uint32_t stride, uint32_t format)
  98 {
  99         struct wl_drm *drm = resource->data;
 100         struct wl_drm_buffer *buffer;
 101
 102         switch (format) {
 103         case WL_DRM_FORMAT_ARGB8888:
 104         case WL_DRM_FORMAT_XRGB8888:
 105                 break;
 106         default:
 107                 wl_resource_post_error(resource,
 108                                        WL_DRM_ERROR_INVALID_FORMAT,
 109                                        "invalid format");
 110                 return;
 111         }
 112
 113         buffer = calloc(1, sizeof *buffer);
 114         if (buffer == NULL) {
 115                 wl_resource_post_no_memory(resource);
 116                 return;
 117         }
 118
 119         buffer->drm = drm;
 120         buffer->buffer.width = width;
 121         buffer->buffer.height = height;
 122         buffer->format = format;
 123         buffer->offset0 = 0;
 124         buffer->stride0 = stride;
 125
 126         drm->callbacks->reference_buffer(drm->user_data, name, buffer);
 127         if (buffer->driver_buffer == NULL) {
 128                 wl_resource_post_error(resource,
 129                                        WL_DRM_ERROR_INVALID_NAME,
 130                                        "invalid name");
 131                 return;
 132         }
 133
 134         buffer->buffer.resource.object.id = id;
 135         buffer->buffer.resource.object.interface = &wl_buffer_interface;
 136         buffer->buffer.resource.object.implementation =
 137                 (void (**)(void)) &drm_buffer_interface;
 138         buffer->buffer.resource.data = buffer;
 139
 140         buffer->buffer.resource.destroy = destroy_buffer;
 141         buffer->buffer.resource.client = resource->client;
 142
 143         wl_client_add_resource(resource->client, &buffer->buffer.resource);
 144 }
 145
 146 static void
 147 drm_authenticate(struct wl_client *client,
 148                  struct wl_resource *resource, uint32_t id)
 149 {
 150         struct wl_drm *drm = resource->data;
 151
 152         if (drm->callbacks->authenticate(drm->user_data, id) < 0)
 153                 wl_resource_post_error(resource,
 154                                        WL_DRM_ERROR_AUTHENTICATE_FAIL,
 155                                        "authenicate failed");
 156         else
 157                 wl_resource_post_event(resource, WL_DRM_AUTHENTICATED);
 158 }
 159
 160 const static struct wl_drm_interface drm_interface = {
 161         drm_authenticate,
 162         drm_create_buffer
 163 };
 164
 165 static void
 166 bind_drm(struct wl_client *client, void *data, uint32_t version, uint32_t id)
 167 {
 168         struct wl_drm *drm = data;
 169         struct wl_resource *resource;
 170
 171         resource = wl_client_add_object(client, &wl_drm_interface,
 172                                         &drm_interface, id, data);
 173         wl_resource_post_event(resource, WL_DRM_DEVICE, drm->device_name);
 174         wl_resource_post_event(resource, WL_DRM_FORMAT,
 175                                WL_DRM_FORMAT_ARGB8888);
 176         wl_resource_post_event(resource, WL_DRM_FORMAT,
 177                                WL_DRM_FORMAT_XRGB8888);
 178 }
 179
 180 struct wl_drm *
 181 wayland_drm_init(struct wl_display *display, char *device_name,
 182                  struct wayland_drm_callbacks *callbacks, void *user_data)
 183 {
 184         struct wl_drm *drm;
 185
 186         drm = malloc(sizeof *drm);
 187
 188         drm->display = display;
 189         drm->device_name = strdup(device_name);
 190         drm->callbacks = callbacks;
 191         drm->user_data = user_data;
 192
 193         wl_display_add_global(display, &wl_drm_interface, drm, bind_drm);
 194
 195         return drm;
 196 }
 197
 198 void
 199 wayland_drm_uninit(struct wl_drm *drm)
 200 {
 201         free(drm->device_name);
 202
 203         /* FIXME: need wl_display_del_{object,global} */
 204
 205         free(drm);
 206 }
 207
 208 int
 209 wayland_buffer_is_drm(struct wl_buffer *buffer)
 210 {
 211         return buffer->resource.object.implementation ==
 212                 (void (**)(void)) &drm_buffer_interface;
 213 }
 214
 215 uint32_t
 216 wayland_drm_buffer_get_format(struct wl_buffer *buffer_base)
 217 {
 218         struct wl_drm_buffer *buffer = (struct wl_drm_buffer *) buffer_base;
 219
 220         return buffer->format;
 221 }
 222
 223 void *
 224 wayland_drm_buffer_get_buffer(struct wl_buffer *buffer_base)
 225 {
 226         struct wl_drm_buffer *buffer = (struct wl_drm_buffer *) buffer_base;
 227
 228         return buffer->driver_buffer;
 229 }