wayland-kms.c

   1 /*
   2  * Copyright © 2013 Renesas Solutions Corp.
   3  * Copyright © 2011 Kristian Høgsberg
   4  * Copyright © 2011 Benjamin Franzke
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  21  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24  * DEALINGS IN THE SOFTWARE.
  25  *
  26  * Authors:
  27  *    Takanari Hayama <taki@igel.co.jp>
  28  *
  29  * Based on wayland-drm.c by the following authors:
  30  *    Kristian Høgsberg <krh@bitplanet.net>
  31  *    Benjamin Franzke <benjaminfranzke@googlemail.com>
  32  */
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <stddef.h>
  38 #include <unistd.h>
  39 #include <errno.h>
  40
  41 #include <xf86drm.h>
  42 #include <wayland-server.h>
  43 #include "wayland-kms.h"
  44 #include "wayland-kms-auth.h"
  45 #include "wayland-kms-server-protocol.h"
  46
  47 #if defined(DEBUG)
  48 #       define WLKMS_DEBUG(s, x...) { printf(s, ##x); }
  49 #else
  50 #       define WLKMS_DEBUG(s, x...) { }
  51 #endif
  52
  53 /*
  54  * Taken from EGL/egl.h. Better to refer the egl.h
  55  * in the future.
  56  */
  57 #ifndef EGL_TEXTURE_RGBA
  58 #       define EGL_TEXTURE_RGBA         0x305E
  59 #endif
  60
  61 struct wl_kms {
  62         struct wl_display *display;
  63         int fd;                         /* FD for DRM */
  64         char *device_name;
  65
  66         struct kms_auth *auth;          /* for nested authentication */
  67 };
  68
  69 /*
  70  * wl_kms server
  71  */
  72
  73 static void destroy_buffer(struct wl_resource *resource)
  74 {
  75         struct wl_kms_buffer *buffer = resource->data;
  76         free(buffer);
  77 }
  78
  79 static void
  80 buffer_destroy(struct wl_client *client, struct wl_resource *resource)
  81 {
  82         wl_resource_destroy(resource);
  83 }
  84
  85 const static struct wl_buffer_interface kms_buffer_interface = {
  86         .destroy = buffer_destroy
  87 };
  88
  89 static void
  90 kms_authenticate(struct wl_client *client, struct wl_resource *resource,
  91                  uint32_t magic)
  92 {
  93         struct wl_kms *kms = resource->data;
  94         int err;
  95
  96         WLKMS_DEBUG("%s: %s: magic=%lu\n", __FILE__, __func__, magic);
  97
  98         if (kms->auth) {
  99                 err = kms_auth_request(kms->auth, magic);
 100         } else {
 101                 err = drmAuthMagic(kms->fd, magic);
 102         }
 103
 104         if (err < 0) {
 105                 wl_resource_post_error(resource, WL_KMS_ERROR_AUTHENTICATION_FAILED,
 106                                        "authentication failed");
 107                 WLKMS_DEBUG("%s: %s: authentication failed.\n", __FILE__, __func__);
 108         } else {
 109                 wl_resource_post_event(resource, WL_KMS_AUTHENTICATED);
 110                 WLKMS_DEBUG("%s: %s: authentication succeeded.\n", __FILE__, __func__);
 111         }
 112 }
 113
 114 static void
 115 kms_create_buffer(struct wl_client *client, struct wl_resource *resource,
 116                   uint32_t id, int32_t prime_fd, int32_t width, int32_t height,
 117                   uint32_t stride, uint32_t format, uint32_t handle)
 118 {
 119         struct wl_kms *kms = resource->data;
 120         struct wl_kms_buffer *buffer;
 121         int err;
 122
 123         switch (format) {
 124         case WL_KMS_FORMAT_ARGB8888:
 125         case WL_KMS_FORMAT_XRGB8888:
 126                 break;
 127         default:
 128                 wl_resource_post_error(resource,
 129                                        WL_KMS_ERROR_INVALID_FORMAT,
 130                                        "invalid format");
 131                 return;
 132         }
 133
 134         buffer = calloc(1, sizeof *buffer);
 135         if (buffer == NULL) {
 136                 wl_resource_post_no_memory(resource);
 137                 return;
 138         }
 139
 140         buffer->kms = kms;
 141         buffer->width = width;
 142         buffer->height = height;
 143         buffer->format = format;
 144         buffer->stride = stride;
 145         buffer->fd = prime_fd;
 146
 147         WLKMS_DEBUG("%s: %s: prime_fd=%d\n", __FILE__, __func__, prime_fd);
 148 #if 0
 149         if ((err = drmPrimeFDToHandle(kms->fd, prime_fd, &buffer->handle))) {
 150                 WLKMS_DEBUG("%s: %s: drmPrimeFDToHandle() failed...%d (%s)\n", __FILE__, __func__, err, strerror(errno));
 151                 wl_resource_post_error(resource,
 152                                        WL_KMS_ERROR_INVALID_FD,
 153                                        "invalid prime FD");
 154                 return;
 155         }
 156 #else
 157         {
 158                 struct drm_gem_open op;
 159                 int ret;
 160
 161                 op.name   = prime_fd;
 162                 op.handle = 0;
 163
 164                 ret = drmIoctl(kms->fd, DRM_IOCTL_GEM_OPEN, &op);
 165                 if (ret) {
 166                         WLKMS_DEBUG("%s: %s: DRM_IOCTL_GEM_OPEN failed...(%s)\n", __FILE__, __func__, strerror(errno));
 167                         wl_resource_post_error(resource, WL_KMS_ERROR_INVALID_FD, "invalid prime FD");
 168                         return;
 169                 }
 170                 buffer->handle = op.handle;
 171         }
 172 #endif
 173
 174         // We create a wl_buffer
 175         buffer->resource = wl_resource_create(client, &wl_buffer_interface, 1, id);
 176         if (!buffer->resource) {
 177                 wl_resource_post_no_memory(resource);
 178                 free(buffer);
 179                 return;
 180         }
 181
 182         wl_resource_set_implementation(buffer->resource,
 183                                        (void (**)(void))&kms_buffer_interface,
 184                                        buffer, destroy_buffer);
 185 }
 186
 187 const static struct wl_kms_interface kms_interface = {
 188         .authenticate = kms_authenticate,
 189         .create_buffer = kms_create_buffer,
 190 };
 191
 192 static void
 193 bind_kms(struct wl_client *client, void *data, uint32_t version, uint32_t id)
 194 {
 195         struct wl_kms *kms = data;
 196         struct wl_resource *resource;
 197         uint32_t capabilities;
 198
 199         resource = wl_resource_create(client, &wl_kms_interface, version, id);
 200         if (!resource) {
 201                 wl_client_post_no_memory(client);
 202                 return;
 203         }
 204
 205         wl_resource_set_implementation(resource, &kms_interface, data, NULL);
 206
 207         wl_resource_post_event(resource, WL_KMS_DEVICE, kms->device_name);
 208         wl_resource_post_event(resource, WL_KMS_FORMAT, WL_KMS_FORMAT_ARGB8888);
 209         wl_resource_post_event(resource, WL_KMS_FORMAT, WL_KMS_FORMAT_XRGB8888);
 210 }
 211
 212 struct wl_kms_buffer *wayland_kms_buffer_get(struct wl_resource *resource)
 213 {
 214         if (resource == NULL)
 215                 return NULL;
 216
 217         if (wl_resource_instance_of(resource, &wl_buffer_interface,
 218                                     &kms_buffer_interface))
 219                 return wl_resource_get_user_data(resource);
 220         else
 221                 return NULL;
 222 }
 223
 224 struct wl_kms *wayland_kms_init(struct wl_display *display,
 225                                 struct wl_display *server, char *device_name, int fd)
 226 {
 227         struct wl_kms *kms;
 228
 229         if (!(kms = calloc(1, sizeof(struct wl_kms))))
 230                 return NULL;
 231
 232         kms->display = display;
 233         kms->device_name = strdup(device_name);
 234         kms->fd = fd;
 235
 236         wl_global_create(display, &wl_kms_interface, 1, kms, bind_kms);
 237
 238         /*
 239          * we're the server in the middle. we should forward the auth
 240          * request to our server.
 241          */
 242         if (server) {
 243                 drm_magic_t magic;
 244
 245                 if (!(kms->auth = kms_auth_init(server)))
 246                         goto error;
 247
 248                 /* get a magic */
 249                 if (drmGetMagic(fd, &magic) < 0)
 250                         goto error;
 251
 252                 /* authenticate myself */
 253                 if (kms_auth_request(kms->auth, magic) < 0)
 254                         goto error;
 255         }
 256
 257         return kms;
 258
 259 error:
 260         free(kms);
 261         return NULL;
 262 }
 263
 264 void wayland_kms_uninit(struct wl_kms *kms)
 265 {
 266         free(kms->device_name);
 267
 268         /* FIXME: need wl_display_del_{object,global} */
 269
 270         free(kms);
 271 }
 272
 273 uint32_t wayland_kms_buffer_get_format(struct wl_kms_buffer *buffer)
 274 {
 275         return buffer->format;
 276 }
 277
 278 int wayland_kms_query_buffer(struct wl_kms *kms, struct wl_resource *resource,
 279                                 enum wl_kms_attribute attr, int *value)
 280 {
 281         struct wl_kms_buffer *buffer = wayland_kms_buffer_get(resource);
 282         if (!buffer)
 283                 return -1;
 284
 285         switch(attr) {
 286         case WL_KMS_WIDTH:
 287                 *value = buffer->width;
 288                 return 0;
 289
 290         case WL_KMS_HEIGHT:
 291                 *value = buffer->height;
 292                 return 0;
 293
 294         case WL_KMS_TEXTURE_FORMAT:
 295                 *value = EGL_TEXTURE_RGBA;
 296                 return 0;
 297         }
 298
 299         return -1;
 300 }