1 /* 2 * Copyright 2011 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 19 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 20 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: 25 * Benjamin Franzke <benjaminfranzke (at) googlemail.com> 26 */ 27 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <stddef.h> 31 #include <stdint.h> 32 #include <string.h> 33 #include <limits.h> 34 35 #include <sys/types.h> 36 #include <sys/mman.h> 37 #include <unistd.h> 38 #include <dlfcn.h> 39 #include <xf86drm.h> 40 41 #include <GL/gl.h> /* dri_interface needs GL types */ 42 #include <GL/internal/dri_interface.h> 43 44 #include "gbm_driint.h" 45 46 #include "gbmint.h" 47 48 /* For importing wl_buffer */ 49 #if HAVE_WAYLAND_PLATFORM 50 #include "../../../egl/wayland/wayland-drm/wayland-drm.h" 51 #endif 52 53 static __DRIimage * 54 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data) 55 { 56 struct gbm_dri_device *dri = data; 57 58 if (dri->lookup_image == NULL) 59 return NULL; 60 61 return dri->lookup_image(screen, image, dri->lookup_user_data); 62 } 63 64 static __DRIbuffer * 65 dri_get_buffers(__DRIdrawable * driDrawable, 66 int *width, int *height, 67 unsigned int *attachments, int count, 68 int *out_count, void *data) 69 { 70 struct gbm_dri_surface *surf = data; 71 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); 72 73 if (dri->get_buffers == NULL) 74 return NULL; 75 76 return dri->get_buffers(driDrawable, width, height, attachments, 77 count, out_count, surf->dri_private); 78 } 79 80 static void 81 dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data) 82 { 83 struct gbm_dri_surface *surf = data; 84 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); 85 86 if (dri->flush_front_buffer != NULL) 87 dri->flush_front_buffer(driDrawable, surf->dri_private); 88 } 89 90 static __DRIbuffer * 91 dri_get_buffers_with_format(__DRIdrawable * driDrawable, 92 int *width, int *height, 93 unsigned int *attachments, int count, 94 int *out_count, void *data) 95 { 96 struct gbm_dri_surface *surf = data; 97 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); 98 99 if (dri->get_buffers_with_format == NULL) 100 return NULL; 101 102 return 103 dri->get_buffers_with_format(driDrawable, width, height, attachments, 104 count, out_count, surf->dri_private); 105 } 106 107 static const __DRIuseInvalidateExtension use_invalidate = { 108 { __DRI_USE_INVALIDATE, 1 } 109 }; 110 111 static const __DRIimageLookupExtension image_lookup_extension = { 112 { __DRI_IMAGE_LOOKUP, 1 }, 113 dri_lookup_egl_image 114 }; 115 116 const __DRIdri2LoaderExtension dri2_loader_extension = { 117 { __DRI_DRI2_LOADER, 3 }, 118 dri_get_buffers, 119 dri_flush_front_buffer, 120 dri_get_buffers_with_format, 121 }; 122 123 struct dri_extension_match { 124 const char *name; 125 int version; 126 int offset; 127 }; 128 129 static struct dri_extension_match dri_core_extensions[] = { 130 { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) }, 131 { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) }, 132 { NULL, 0, 0 } 133 }; 134 135 static struct dri_extension_match gbm_dri_device_extensions[] = { 136 { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) }, 137 { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) }, 138 { NULL, 0, 0 } 139 }; 140 141 static int 142 dri_bind_extensions(struct gbm_dri_device *dri, 143 struct dri_extension_match *matches, 144 const __DRIextension **extensions) 145 { 146 int i, j, ret = 0; 147 void *field; 148 149 for (i = 0; extensions[i]; i++) { 150 for (j = 0; matches[j].name; j++) { 151 if (strcmp(extensions[i]->name, matches[j].name) == 0 && 152 extensions[i]->version >= matches[j].version) { 153 field = ((char *) dri + matches[j].offset); 154 *(const __DRIextension **) field = extensions[i]; 155 } 156 } 157 } 158 159 for (j = 0; matches[j].name; j++) { 160 field = ((char *) dri + matches[j].offset); 161 if (*(const __DRIextension **) field == NULL) { 162 ret = -1; 163 } 164 } 165 166 return ret; 167 } 168 169 static int 170 dri_load_driver(struct gbm_dri_device *dri) 171 { 172 const __DRIextension **extensions; 173 char path[PATH_MAX], *search_paths, *p, *next, *end; 174 175 search_paths = NULL; 176 if (geteuid() == getuid()) { 177 /* don't allow setuid apps to use GBM_DRIVERS_PATH */ 178 search_paths = getenv("GBM_DRIVERS_PATH"); 179 } 180 if (search_paths == NULL) 181 search_paths = DEFAULT_DRIVER_DIR; 182 183 dri->driver = NULL; 184 end = search_paths + strlen(search_paths); 185 for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) { 186 int len; 187 next = strchr(p, ':'); 188 if (next == NULL) 189 next = end; 190 191 len = next - p; 192 #if GLX_USE_TLS 193 snprintf(path, sizeof path, 194 "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name); 195 dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); 196 #endif 197 if (dri->driver == NULL) { 198 snprintf(path, sizeof path, 199 "%.*s/%s_dri.so", len, p, dri->base.driver_name); 200 dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); 201 if (dri->driver == NULL) 202 fprintf(stderr, "failed to open %s: %s\n", path, dlerror()); 203 } 204 } 205 206 if (dri->driver == NULL) { 207 fprintf(stderr, "gbm: failed to open any driver (search paths %s)", 208 search_paths); 209 return -1; 210 } 211 212 extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS); 213 if (extensions == NULL) { 214 fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror()); 215 dlclose(dri->driver); 216 return -1; 217 } 218 219 220 if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) { 221 dlclose(dri->driver); 222 fprintf(stderr, "failed to bind extensions\n"); 223 return -1; 224 } 225 226 return 0; 227 } 228 229 static int 230 dri_screen_create(struct gbm_dri_device *dri) 231 { 232 const __DRIextension **extensions; 233 int ret = 0; 234 235 dri->base.driver_name = dri_fd_get_driver_name(dri->base.base.fd); 236 if (dri->base.driver_name == NULL) 237 return -1; 238 239 ret = dri_load_driver(dri); 240 if (ret) { 241 fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name); 242 return ret; 243 }; 244 245 dri->extensions[0] = &image_lookup_extension.base; 246 dri->extensions[1] = &use_invalidate.base; 247 dri->extensions[2] = &dri2_loader_extension.base; 248 dri->extensions[3] = NULL; 249 250 if (dri->dri2 == NULL) 251 return -1; 252 253 dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd, 254 dri->extensions, 255 &dri->driver_configs, dri); 256 if (dri->screen == NULL) 257 return -1; 258 259 extensions = dri->core->getExtensions(dri->screen); 260 if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) { 261 ret = -1; 262 goto free_screen; 263 } 264 265 dri->lookup_image = NULL; 266 dri->lookup_user_data = NULL; 267 268 return 0; 269 270 free_screen: 271 dri->core->destroyScreen(dri->screen); 272 273 return ret; 274 } 275 276 static int 277 gbm_dri_is_format_supported(struct gbm_device *gbm, 278 uint32_t format, 279 uint32_t usage) 280 { 281 switch (format) { 282 case GBM_BO_FORMAT_XRGB8888: 283 case GBM_FORMAT_XRGB8888: 284 break; 285 case GBM_BO_FORMAT_ARGB8888: 286 case GBM_FORMAT_ARGB8888: 287 if (usage & GBM_BO_USE_SCANOUT) 288 return 0; 289 break; 290 default: 291 return 0; 292 } 293 294 if (usage & GBM_BO_USE_CURSOR_64X64 && 295 usage & GBM_BO_USE_RENDERING) 296 return 0; 297 298 return 1; 299 } 300 301 static int 302 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count) 303 { 304 struct gbm_dri_bo *bo = gbm_dri_bo(_bo); 305 306 if (bo->image != NULL) 307 return -1; 308 309 memcpy(bo->map, buf, count); 310 311 return 0; 312 } 313 314 static void 315 gbm_dri_bo_destroy(struct gbm_bo *_bo) 316 { 317 struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); 318 struct gbm_dri_bo *bo = gbm_dri_bo(_bo); 319 struct drm_mode_destroy_dumb arg; 320 321 if (bo->image != NULL) { 322 dri->image->destroyImage(bo->image); 323 } else { 324 munmap(bo->map, bo->size); 325 memset(&arg, 0, sizeof(arg)); 326 arg.handle = bo->handle; 327 drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg); 328 } 329 330 free(bo); 331 } 332 333 static uint32_t 334 gbm_dri_to_gbm_format(uint32_t dri_format) 335 { 336 uint32_t ret = 0; 337 338 switch (dri_format) { 339 case __DRI_IMAGE_FORMAT_RGB565: 340 ret = GBM_FORMAT_RGB565; 341 break; 342 case __DRI_IMAGE_FORMAT_XRGB8888: 343 ret = GBM_FORMAT_XRGB8888; 344 break; 345 case __DRI_IMAGE_FORMAT_ARGB8888: 346 ret = GBM_FORMAT_ARGB8888; 347 break; 348 case __DRI_IMAGE_FORMAT_ABGR8888: 349 ret = GBM_FORMAT_ABGR8888; 350 break; 351 default: 352 ret = 0; 353 break; 354 } 355 356 return ret; 357 } 358 359 static struct gbm_bo * 360 gbm_dri_bo_import(struct gbm_device *gbm, 361 uint32_t type, void *buffer, uint32_t usage) 362 { 363 struct gbm_dri_device *dri = gbm_dri_device(gbm); 364 struct gbm_dri_bo *bo; 365 __DRIimage *image; 366 unsigned dri_use = 0; 367 int gbm_format; 368 369 /* Required for query image WIDTH & HEIGHT */ 370 if (dri->image->base.version < 4) 371 return NULL; 372 373 switch (type) { 374 #if HAVE_WAYLAND_PLATFORM 375 case GBM_BO_IMPORT_WL_BUFFER: 376 { 377 struct wl_drm_buffer *wb = (struct wl_drm_buffer *) buffer; 378 379 if (!wayland_buffer_is_drm(buffer)) 380 return NULL; 381 382 image = wb->driver_buffer; 383 384 switch (wb->format) { 385 case WL_DRM_FORMAT_XRGB8888: 386 gbm_format = GBM_FORMAT_XRGB8888; 387 break; 388 case WL_DRM_FORMAT_ARGB8888: 389 gbm_format = GBM_FORMAT_ARGB8888; 390 break; 391 case WL_DRM_FORMAT_YUYV: 392 gbm_format = GBM_FORMAT_YUYV; 393 break; 394 default: 395 return NULL; 396 } 397 break; 398 } 399 #endif 400 401 case GBM_BO_IMPORT_EGL_IMAGE: 402 { 403 int dri_format; 404 if (dri->lookup_image == NULL) 405 return NULL; 406 407 image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data); 408 dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format); 409 gbm_format = gbm_dri_to_gbm_format(dri_format); 410 if (gbm_format == 0) 411 return NULL; 412 break; 413 } 414 415 default: 416 return NULL; 417 } 418 419 420 bo = calloc(1, sizeof *bo); 421 if (bo == NULL) 422 return NULL; 423 424 bo->image = dri->image->dupImage(image, NULL); 425 426 if (usage & GBM_BO_USE_SCANOUT) 427 dri_use |= __DRI_IMAGE_USE_SCANOUT; 428 if (usage & GBM_BO_USE_CURSOR_64X64) 429 dri_use |= __DRI_IMAGE_USE_CURSOR; 430 if (dri->image->base.version >= 2 && 431 !dri->image->validateUsage(bo->image, dri_use)) { 432 free(bo); 433 return NULL; 434 } 435 436 bo->base.base.gbm = gbm; 437 bo->base.base.format = gbm_format; 438 439 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH, 440 (int*)&bo->base.base.width); 441 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT, 442 (int*)&bo->base.base.height); 443 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, 444 (int*)&bo->base.base.stride); 445 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, 446 &bo->base.base.handle.s32); 447 448 return &bo->base.base; 449 } 450 451 static struct gbm_bo * 452 create_dumb(struct gbm_device *gbm, 453 uint32_t width, uint32_t height, 454 uint32_t format, uint32_t usage) 455 { 456 struct gbm_dri_device *dri = gbm_dri_device(gbm); 457 struct drm_mode_create_dumb create_arg; 458 struct drm_mode_map_dumb map_arg; 459 struct gbm_dri_bo *bo; 460 struct drm_mode_destroy_dumb destroy_arg; 461 int ret; 462 463 if (!(usage & GBM_BO_USE_CURSOR_64X64)) 464 return NULL; 465 if (format != GBM_FORMAT_ARGB8888) 466 return NULL; 467 468 bo = calloc(1, sizeof *bo); 469 if (bo == NULL) 470 return NULL; 471 472 create_arg.bpp = 32; 473 create_arg.width = width; 474 create_arg.height = height; 475 476 ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg); 477 if (ret) 478 goto free_bo; 479 480 bo->base.base.gbm = gbm; 481 bo->base.base.width = width; 482 bo->base.base.height = height; 483 bo->base.base.stride = create_arg.pitch; 484 bo->base.base.handle.u32 = create_arg.handle; 485 bo->handle = create_arg.handle; 486 bo->size = create_arg.size; 487 488 memset(&map_arg, 0, sizeof(map_arg)); 489 map_arg.handle = bo->handle; 490 491 ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg); 492 if (ret) 493 goto destroy_dumb; 494 495 bo->map = mmap(0, bo->size, PROT_WRITE, 496 MAP_SHARED, dri->base.base.fd, map_arg.offset); 497 if (bo->map == MAP_FAILED) 498 goto destroy_dumb; 499 500 return &bo->base.base; 501 502 destroy_dumb: 503 memset(&destroy_arg, 0, sizeof destroy_arg); 504 destroy_arg.handle = create_arg.handle; 505 drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg); 506 free_bo: 507 free(bo); 508 509 return NULL; 510 } 511 512 static struct gbm_bo * 513 gbm_dri_bo_create(struct gbm_device *gbm, 514 uint32_t width, uint32_t height, 515 uint32_t format, uint32_t usage) 516 { 517 struct gbm_dri_device *dri = gbm_dri_device(gbm); 518 struct gbm_dri_bo *bo; 519 int dri_format; 520 unsigned dri_use = 0; 521 522 if (usage & GBM_BO_USE_WRITE) 523 return create_dumb(gbm, width, height, format, usage); 524 525 bo = calloc(1, sizeof *bo); 526 if (bo == NULL) 527 return NULL; 528 529 bo->base.base.gbm = gbm; 530 bo->base.base.width = width; 531 bo->base.base.height = height; 532 533 switch (format) { 534 case GBM_FORMAT_RGB565: 535 dri_format =__DRI_IMAGE_FORMAT_RGB565; 536 break; 537 case GBM_FORMAT_XRGB8888: 538 case GBM_BO_FORMAT_XRGB8888: 539 dri_format = __DRI_IMAGE_FORMAT_XRGB8888; 540 break; 541 case GBM_FORMAT_ARGB8888: 542 case GBM_BO_FORMAT_ARGB8888: 543 dri_format = __DRI_IMAGE_FORMAT_ARGB8888; 544 break; 545 case GBM_FORMAT_ABGR8888: 546 dri_format = __DRI_IMAGE_FORMAT_ABGR8888; 547 break; 548 default: 549 return NULL; 550 } 551 552 if (usage & GBM_BO_USE_SCANOUT) 553 dri_use |= __DRI_IMAGE_USE_SCANOUT; 554 if (usage & GBM_BO_USE_CURSOR_64X64) 555 dri_use |= __DRI_IMAGE_USE_CURSOR; 556 557 /* Gallium drivers requires shared in order to get the handle/stride */ 558 dri_use |= __DRI_IMAGE_USE_SHARE; 559 560 bo->image = 561 dri->image->createImage(dri->screen, 562 width, height, 563 dri_format, dri_use, 564 bo); 565 if (bo->image == NULL) 566 return NULL; 567 568 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, 569 &bo->base.base.handle.s32); 570 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, 571 (int *) &bo->base.base.stride); 572 573 return &bo->base.base; 574 } 575 576 static struct gbm_surface * 577 gbm_dri_surface_create(struct gbm_device *gbm, 578 uint32_t width, uint32_t height, 579 uint32_t format, uint32_t flags) 580 { 581 struct gbm_dri_surface *surf; 582 583 surf = calloc(1, sizeof *surf); 584 if (surf == NULL) 585 return NULL; 586 587 surf->base.gbm = gbm; 588 surf->base.width = width; 589 surf->base.height = height; 590 surf->base.format = format; 591 surf->base.flags = flags; 592 593 return &surf->base; 594 } 595 596 static void 597 gbm_dri_surface_destroy(struct gbm_surface *_surf) 598 { 599 struct gbm_dri_surface *surf = gbm_dri_surface(_surf); 600 601 free(surf); 602 } 603 604 static void 605 dri_destroy(struct gbm_device *gbm) 606 { 607 struct gbm_dri_device *dri = gbm_dri_device(gbm); 608 609 dri->core->destroyScreen(dri->screen); 610 free(dri->driver_configs); 611 dlclose(dri->driver); 612 free(dri->base.driver_name); 613 614 free(dri); 615 } 616 617 static struct gbm_device * 618 dri_device_create(int fd) 619 { 620 struct gbm_dri_device *dri; 621 int ret; 622 623 dri = calloc(1, sizeof *dri); 624 625 dri->base.base.fd = fd; 626 dri->base.base.bo_create = gbm_dri_bo_create; 627 dri->base.base.bo_import = gbm_dri_bo_import; 628 dri->base.base.is_format_supported = gbm_dri_is_format_supported; 629 dri->base.base.bo_write = gbm_dri_bo_write; 630 dri->base.base.bo_destroy = gbm_dri_bo_destroy; 631 dri->base.base.destroy = dri_destroy; 632 dri->base.base.surface_create = gbm_dri_surface_create; 633 dri->base.base.surface_destroy = gbm_dri_surface_destroy; 634 635 dri->base.type = GBM_DRM_DRIVER_TYPE_DRI; 636 dri->base.base.name = "drm"; 637 638 ret = dri_screen_create(dri); 639 if (ret) 640 goto err_dri; 641 642 return &dri->base.base; 643 644 err_dri: 645 free(dri); 646 647 return NULL; 648 } 649 650 struct gbm_backend gbm_dri_backend = { 651 .backend_name = "dri", 652 .create_device = dri_device_create, 653 }; 654
