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

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.8
   4  *
   5  * Copyright (C) 2010 Chia-I Wu <olv@0xlab.org>
   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 <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29
  30 #include "util/u_memory.h"
  31 #include "egllog.h"
  32
  33 #include "native_drm.h"
  34
  35 /* see get_drm_screen_name */
  36 #include <radeon_drm.h>
  37 #include "radeon/drm/radeon_drm_public.h"
  38
  39 static boolean
  40 drm_display_is_format_supported(struct native_display *ndpy,
  41                                 enum pipe_format fmt, boolean is_color)
  42 {
  43    return ndpy->screen->is_format_supported(ndpy->screen,
  44          fmt, PIPE_TEXTURE_2D, 0,
  45          (is_color) ? PIPE_BIND_RENDER_TARGET :
  46          PIPE_BIND_DEPTH_STENCIL, 0);
  47 }
  48
  49 static const struct native_config **
  50 drm_display_get_configs(struct native_display *ndpy, int *num_configs)
  51 {
  52    struct drm_display *drmdpy = drm_display(ndpy);
  53    const struct native_config **configs;
  54
  55    /* first time */
  56    if (!drmdpy->config) {
  57       struct native_config *nconf;
  58       enum pipe_format format;
  59
  60       drmdpy->config = CALLOC(1, sizeof(*drmdpy->config));
  61       if (!drmdpy->config)
  62          return NULL;
  63
  64       nconf = &drmdpy->config->base;
  65
  66       nconf->buffer_mask =
  67          (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
  68          (1 << NATIVE_ATTACHMENT_BACK_LEFT);
  69
  70       format = PIPE_FORMAT_B8G8R8A8_UNORM;
  71       if (!drm_display_is_format_supported(&drmdpy->base, format, TRUE)) {
  72          format = PIPE_FORMAT_A8R8G8B8_UNORM;
  73          if (!drm_display_is_format_supported(&drmdpy->base, format, TRUE))
  74             format = PIPE_FORMAT_NONE;
  75       }
  76       if (format == PIPE_FORMAT_NONE) {
  77          FREE(drmdpy->config);
  78          drmdpy->config = NULL;
  79          return NULL;
  80       }
  81
  82       nconf->color_format = format;
  83
  84       /* support KMS */
  85       if (drmdpy->resources)
  86          nconf->scanout_bit = TRUE;
  87    }
  88
  89    configs = MALLOC(sizeof(*configs));
  90    if (configs) {
  91       configs[0] = &drmdpy->config->base;
  92       if (num_configs)
  93          *num_configs = 1;
  94    }
  95
  96    return configs;
  97 }
  98
  99 static int
 100 drm_display_get_param(struct native_display *ndpy,
 101                       enum native_param_type param)
 102 {
 103    int val;
 104
 105    switch (param) {
 106    case NATIVE_PARAM_USE_NATIVE_BUFFER:
 107    case NATIVE_PARAM_PRESERVE_BUFFER:
 108    case NATIVE_PARAM_MAX_SWAP_INTERVAL:
 109    default:
 110       val = 0;
 111       break;
 112    }
 113
 114    return val;
 115 }
 116
 117 static void
 118 drm_display_destroy(struct native_display *ndpy)
 119 {
 120    struct drm_display *drmdpy = drm_display(ndpy);
 121
 122    if (drmdpy->config)
 123       FREE(drmdpy->config);
 124
 125    drm_display_fini_modeset(&drmdpy->base);
 126
 127    if (drmdpy->base.screen)
 128       drmdpy->base.screen->destroy(drmdpy->base.screen);
 129
 130    if (drmdpy->fd >= 0)
 131       close(drmdpy->fd);
 132
 133    FREE(drmdpy);
 134 }
 135
 136 static const char *
 137 get_drm_screen_name(int fd, drmVersionPtr version)
 138 {
 139    const char *name = version->name;
 140
 141    if (name && !strcmp(name, "radeon")) {
 142       int chip_id;
 143       struct drm_radeon_info info;
 144
 145       memset(&info, 0, sizeof(info));
 146       info.request = RADEON_INFO_DEVICE_ID;
 147       info.value = pointer_to_intptr(&chip_id);
 148       if (drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info)) != 0)
 149          return NULL;
 150
 151       name = is_r3xx(chip_id) ? "r300" : "r600";
 152    }
 153
 154    return name;
 155 }
 156
 157 /**
 158  * Initialize KMS and pipe screen.
 159  */
 160 static boolean
 161 drm_display_init_screen(struct native_display *ndpy)
 162 {
 163    struct drm_display *drmdpy = drm_display(ndpy);
 164    drmVersionPtr version;
 165    const char *name;
 166
 167    version = drmGetVersion(drmdpy->fd);
 168    if (!version) {
 169       _eglLog(_EGL_WARNING, "invalid fd %d", drmdpy->fd);
 170       return FALSE;
 171    }
 172
 173    name = get_drm_screen_name(drmdpy->fd, version);
 174    if (name) {
 175       drmdpy->base.screen =
 176          drmdpy->event_handler->new_drm_screen(&drmdpy->base, name, drmdpy->fd);
 177    }
 178    drmFreeVersion(version);
 179
 180    if (!drmdpy->base.screen) {
 181       _eglLog(_EGL_DEBUG, "failed to create DRM screen");
 182       return FALSE;
 183    }
 184
 185    return TRUE;
 186 }
 187
 188 static struct pipe_resource *
 189 drm_display_import_buffer(struct native_display *ndpy,
 190                           const struct pipe_resource *templ,
 191                           void *buf)
 192 {
 193    return ndpy->screen->resource_from_handle(ndpy->screen,
 194          templ, (struct winsys_handle *) buf);
 195 }
 196
 197 static boolean
 198 drm_display_export_buffer(struct native_display *ndpy,
 199                           struct pipe_resource *res,
 200                           void *buf)
 201 {
 202    return ndpy->screen->resource_get_handle(ndpy->screen,
 203          res, (struct winsys_handle *) buf);
 204 }
 205
 206 static struct native_display_buffer drm_display_buffer = {
 207    drm_display_import_buffer,
 208    drm_display_export_buffer
 209 };
 210
 211 static struct native_display *
 212 drm_create_display(int fd, struct native_event_handler *event_handler,
 213                    void *user_data)
 214 {
 215    struct drm_display *drmdpy;
 216
 217    drmdpy = CALLOC_STRUCT(drm_display);
 218    if (!drmdpy)
 219       return NULL;
 220
 221    drmdpy->fd = fd;
 222    drmdpy->event_handler = event_handler;
 223    drmdpy->base.user_data = user_data;
 224
 225    if (!drm_display_init_screen(&drmdpy->base)) {
 226       drm_display_destroy(&drmdpy->base);
 227       return NULL;
 228    }
 229
 230    drmdpy->base.destroy = drm_display_destroy;
 231    drmdpy->base.get_param = drm_display_get_param;
 232    drmdpy->base.get_configs = drm_display_get_configs;
 233
 234    drmdpy->base.buffer = &drm_display_buffer;
 235    drm_display_init_modeset(&drmdpy->base);
 236
 237    return &drmdpy->base;
 238 }
 239
 240 static struct native_event_handler *drm_event_handler;
 241
 242 static void
 243 native_set_event_handler(struct native_event_handler *event_handler)
 244 {
 245    drm_event_handler = event_handler;
 246 }
 247
 248 static struct native_display *
 249 native_create_display(void *dpy, boolean use_sw, void *user_data)
 250 {
 251    int fd;
 252
 253    if (dpy) {
 254       fd = dup((int) pointer_to_intptr(dpy));
 255    }
 256    else {
 257       fd = open("/dev/dri/card0", O_RDWR);
 258    }
 259    if (fd < 0)
 260       return NULL;
 261
 262    return drm_create_display(fd, drm_event_handler, user_data);
 263 }
 264
 265 static const struct native_platform drm_platform = {
 266    "DRM", /* name */
 267    native_set_event_handler,
 268    native_create_display
 269 };
 270
 271 const struct native_platform *
 272 native_get_drm_platform(void)
 273 {
 274    return &drm_platform;
 275 }