native_drm.c revision 32f4cf38085e4056b8e4a9fc78fea28897a1d05f
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 <string.h> 27#include <sys/types.h> 28#include <sys/stat.h> 29#include <fcntl.h> 30 31#include "util/u_memory.h" 32#include "egllog.h" 33 34#include "native_drm.h" 35 36#include "gbm_gallium_drmint.h" 37 38#ifdef HAVE_LIBUDEV 39#include <libudev.h> 40#endif 41 42static boolean 43drm_display_is_format_supported(struct native_display *ndpy, 44 enum pipe_format fmt, boolean is_color) 45{ 46 return ndpy->screen->is_format_supported(ndpy->screen, 47 fmt, PIPE_TEXTURE_2D, 0, 48 (is_color) ? PIPE_BIND_RENDER_TARGET : 49 PIPE_BIND_DEPTH_STENCIL); 50} 51 52static const struct native_config ** 53drm_display_get_configs(struct native_display *ndpy, int *num_configs) 54{ 55 struct drm_display *drmdpy = drm_display(ndpy); 56 const struct native_config **configs; 57 58 /* first time */ 59 if (!drmdpy->config) { 60 struct native_config *nconf; 61 enum pipe_format format; 62 63 drmdpy->config = CALLOC(1, sizeof(*drmdpy->config)); 64 if (!drmdpy->config) 65 return NULL; 66 67 nconf = &drmdpy->config->base; 68 69 nconf->buffer_mask = 70 (1 << NATIVE_ATTACHMENT_FRONT_LEFT) | 71 (1 << NATIVE_ATTACHMENT_BACK_LEFT); 72 73 format = PIPE_FORMAT_B8G8R8A8_UNORM; 74 if (!drm_display_is_format_supported(&drmdpy->base, format, TRUE)) { 75 format = PIPE_FORMAT_A8R8G8B8_UNORM; 76 if (!drm_display_is_format_supported(&drmdpy->base, format, TRUE)) 77 format = PIPE_FORMAT_NONE; 78 } 79 if (format == PIPE_FORMAT_NONE) { 80 FREE(drmdpy->config); 81 drmdpy->config = NULL; 82 return NULL; 83 } 84 85 nconf->color_format = format; 86 87 /* support KMS */ 88 if (drmdpy->resources) 89 nconf->scanout_bit = TRUE; 90 } 91 92 configs = MALLOC(sizeof(*configs)); 93 if (configs) { 94 configs[0] = &drmdpy->config->base; 95 if (num_configs) 96 *num_configs = 1; 97 } 98 99 return configs; 100} 101 102static int 103drm_display_get_param(struct native_display *ndpy, 104 enum native_param_type param) 105{ 106 int val; 107 108 switch (param) { 109 case NATIVE_PARAM_USE_NATIVE_BUFFER: 110 case NATIVE_PARAM_PRESERVE_BUFFER: 111 case NATIVE_PARAM_MAX_SWAP_INTERVAL: 112 default: 113 val = 0; 114 break; 115 } 116 117 return val; 118} 119 120static void 121drm_display_destroy(struct native_display *ndpy) 122{ 123 struct drm_display *drmdpy = drm_display(ndpy); 124 125 if (drmdpy->config) 126 FREE(drmdpy->config); 127 128 drm_display_fini_modeset(&drmdpy->base); 129 130 /* gbm owns screen */ 131 ndpy->screen = NULL; 132 ndpy_uninit(ndpy); 133 134 if (drmdpy->device_name) 135 FREE(drmdpy->device_name); 136 137 if (drmdpy->own_gbm) { 138 gbm_device_destroy(&drmdpy->gbmdrm->base.base); 139 if (drmdpy->fd >= 0) 140 close(drmdpy->fd); 141 } 142 143 FREE(drmdpy); 144} 145 146static struct native_display_buffer drm_display_buffer = { 147 /* use the helpers */ 148 drm_display_import_native_buffer, 149 drm_display_export_native_buffer 150}; 151 152static int 153drm_display_authenticate(void *user_data, uint32_t magic) 154{ 155 struct native_display *ndpy = user_data; 156 struct drm_display *drmdpy = drm_display(ndpy); 157 158 return drmAuthMagic(drmdpy->fd, magic); 159} 160 161static char * 162drm_get_device_name(int fd) 163{ 164 char *device_name = NULL; 165#ifdef HAVE_LIBUDEV 166 struct udev *udev; 167 struct udev_device *device; 168 struct stat buf; 169 const char *tmp; 170 171 udev = udev_new(); 172 if (fstat(fd, &buf) < 0) { 173 _eglLog(_EGL_WARNING, "failed to stat fd %d", fd); 174 goto out; 175 } 176 177 device = udev_device_new_from_devnum(udev, 'c', buf.st_rdev); 178 if (device == NULL) { 179 _eglLog(_EGL_WARNING, 180 "could not create udev device for fd %d", fd); 181 goto out; 182 } 183 184 tmp = udev_device_get_devnode(device); 185 if (!tmp) 186 goto out; 187 device_name = strdup(tmp); 188 189out: 190 udev_device_unref(device); 191 udev_unref(udev); 192 193#endif 194 return device_name; 195} 196 197#ifdef HAVE_WAYLAND_BACKEND 198 199static struct wayland_drm_callbacks wl_drm_callbacks = { 200 drm_display_authenticate, 201 egl_g3d_wl_drm_helper_reference_buffer, 202 egl_g3d_wl_drm_helper_unreference_buffer 203}; 204 205static boolean 206drm_display_bind_wayland_display(struct native_display *ndpy, 207 struct wl_display *wl_dpy) 208{ 209 struct drm_display *drmdpy = drm_display(ndpy); 210 211 if (drmdpy->wl_server_drm) 212 return FALSE; 213 214 drmdpy->wl_server_drm = wayland_drm_init(wl_dpy, 215 drmdpy->device_name, 216 &wl_drm_callbacks, ndpy); 217 218 if (!drmdpy->wl_server_drm) 219 return FALSE; 220 221 return TRUE; 222} 223 224static boolean 225drm_display_unbind_wayland_display(struct native_display *ndpy, 226 struct wl_display *wl_dpy) 227{ 228 struct drm_display *drmdpy = drm_display(ndpy); 229 230 if (!drmdpy->wl_server_drm) 231 return FALSE; 232 233 wayland_drm_uninit(drmdpy->wl_server_drm); 234 drmdpy->wl_server_drm = NULL; 235 236 return TRUE; 237} 238 239static struct native_display_wayland_bufmgr drm_display_wayland_bufmgr = { 240 drm_display_bind_wayland_display, 241 drm_display_unbind_wayland_display, 242 egl_g3d_wl_drm_common_wl_buffer_get_resource 243}; 244 245#endif /* HAVE_WAYLAND_BACKEND */ 246 247static struct native_surface * 248drm_create_pixmap_surface(struct native_display *ndpy, 249 EGLNativePixmapType pix, 250 const struct native_config *nconf) 251{ 252 struct gbm_gallium_drm_bo *bo = (void *) pix; 253 254 return drm_display_create_surface_from_resource(ndpy, bo->resource); 255} 256 257static boolean 258drm_display_init_screen(struct native_display *ndpy) 259{ 260 return TRUE; 261} 262 263static struct native_display * 264drm_create_display(struct gbm_gallium_drm_device *gbmdrm, int own_gbm, 265 const struct native_event_handler *event_handler) 266{ 267 struct drm_display *drmdpy; 268 269 drmdpy = CALLOC_STRUCT(drm_display); 270 if (!drmdpy) 271 return NULL; 272 273 drmdpy->gbmdrm = gbmdrm; 274 drmdpy->own_gbm = own_gbm; 275 drmdpy->fd = gbmdrm->base.base.fd; 276 drmdpy->device_name = drm_get_device_name(drmdpy->fd); 277 278 gbmdrm->lookup_egl_image = (struct pipe_resource *(*)(void *, void *)) 279 event_handler->lookup_egl_image; 280 gbmdrm->lookup_egl_image_data = &drmdpy->base; 281 282 drmdpy->event_handler = event_handler; 283 284 drmdpy->base.screen = gbmdrm->screen; 285 286 drmdpy->base.init_screen = drm_display_init_screen; 287 drmdpy->base.destroy = drm_display_destroy; 288 drmdpy->base.get_param = drm_display_get_param; 289 drmdpy->base.get_configs = drm_display_get_configs; 290 291 drmdpy->base.create_pixmap_surface = drm_create_pixmap_surface; 292 293 drmdpy->base.buffer = &drm_display_buffer; 294#ifdef HAVE_WAYLAND_BACKEND 295 if (drmdpy->device_name) 296 drmdpy->base.wayland_bufmgr = &drm_display_wayland_bufmgr; 297#endif 298 drm_display_init_modeset(&drmdpy->base); 299 300 return &drmdpy->base; 301} 302 303static const struct native_event_handler *drm_event_handler; 304 305static struct native_display * 306native_create_display(void *dpy, boolean use_sw) 307{ 308 struct gbm_gallium_drm_device *gbm; 309 int fd; 310 int own_gbm = 0; 311 312 gbm = dpy; 313 314 if (gbm == NULL) { 315 fd = open("/dev/dri/card0", O_RDWR); 316 /* FIXME: Use an internal constructor to create a gbm 317 * device with gallium backend directly, without setenv */ 318 setenv("GBM_BACKEND", "gbm_gallium_drm.so", 1); 319 gbm = gbm_gallium_drm_device(gbm_create_device(fd)); 320 own_gbm = 1; 321 } 322 323 if (gbm == NULL) 324 return NULL; 325 326 if (strcmp(gbm_device_get_backend_name(&gbm->base.base), "drm") != 0 || 327 gbm->base.type != GBM_DRM_DRIVER_TYPE_GALLIUM) { 328 if (own_gbm) 329 gbm_device_destroy(&gbm->base.base); 330 return NULL; 331 } 332 333 return drm_create_display(gbm, own_gbm, drm_event_handler); 334} 335 336static const struct native_platform drm_platform = { 337 "DRM", /* name */ 338 native_create_display 339}; 340 341const struct native_platform * 342native_get_drm_platform(const struct native_event_handler *event_handler) 343{ 344 drm_event_handler = event_handler; 345 return &drm_platform; 346} 347