projects / mesa.git / blob
? search:


f863616ab08ece8c11acaefffa0188004a6142e5
[mesa.git] / src / gbm / backends / dri / gbm_dri.c
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@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 <errno.h>
34 #include <limits.h>
35 #include <assert.h>
36
37 #include <sys/types.h>
38 #include <unistd.h>
39 #include <dlfcn.h>
40 #include <xf86drm.h>
41
42 #include <GL/gl.h> /* dri_interface needs GL types */
43 #include <GL/internal/dri_interface.h>
44
45 #include "gbm_driint.h"
46
47 #include "gbmint.h"
48 #include "loader.h"
49
50 /* For importing wl_buffer */
51 #if HAVE_WAYLAND_PLATFORM
52 #include "../../../egl/wayland/wayland-drm/wayland-drm.h"
53 #endif
54
55 static __DRIimage *
56 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
57 {
58 struct gbm_dri_device *dri = data;
59
60 if (dri->lookup_image == NULL)
61 return NULL;
62
63 return dri->lookup_image(screen, image, dri->lookup_user_data);
64 }
65
66 static __DRIbuffer *
67 dri_get_buffers(__DRIdrawable * driDrawable,
68 int *width, int *height,
69 unsigned int *attachments, int count,
70 int *out_count, void *data)
71 {
72 struct gbm_dri_surface *surf = data;
73 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
74
75 if (dri->get_buffers == NULL)
76 return NULL;
77
78 return dri->get_buffers(driDrawable, width, height, attachments,
79 count, out_count, surf->dri_private);
80 }
81
82 static void
83 dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data)
84 {
85 struct gbm_dri_surface *surf = data;
86 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
87
88 if (dri->flush_front_buffer != NULL)
89 dri->flush_front_buffer(driDrawable, surf->dri_private);
90 }
91
92 static __DRIbuffer *
93 dri_get_buffers_with_format(__DRIdrawable * driDrawable,
94 int *width, int *height,
95 unsigned int *attachments, int count,
96 int *out_count, void *data)
97 {
98 struct gbm_dri_surface *surf = data;
99 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
100
101 if (dri->get_buffers_with_format == NULL)
102 return NULL;
103
104 return
105 dri->get_buffers_with_format(driDrawable, width, height, attachments,
106 count, out_count, surf->dri_private);
107 }
108
109 static int
110 image_get_buffers(__DRIdrawable *driDrawable,
111 unsigned int format,
112 uint32_t *stamp,
113 void *loaderPrivate,
114 uint32_t buffer_mask,
115 struct __DRIimageList *buffers)
116 {
117 struct gbm_dri_surface *surf = loaderPrivate;
118 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
119
120 if (dri->image_get_buffers == NULL)
121 return 0;
122
123 return dri->image_get_buffers(driDrawable, format, stamp,
124 surf->dri_private, buffer_mask, buffers);
125 }
126
127 static void
128 swrast_get_drawable_info(__DRIdrawable *driDrawable,
129 int *x,
130 int *y,
131 int *width,
132 int *height,
133 void *loaderPrivate)
134 {
135 struct gbm_dri_surface *surf = loaderPrivate;
136
137 *x = 0;
138 *y = 0;
139 *width = surf->base.width;
140 *height = surf->base.height;
141 }
142
143 static void
144 swrast_put_image2(__DRIdrawable *driDrawable,
145 int op,
146 int x,
147 int y,
148 int width,
149 int height,
150 int stride,
151 char *data,
152 void *loaderPrivate)
153 {
154 struct gbm_dri_surface *surf = loaderPrivate;
155 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
156
157 dri->swrast_put_image2(driDrawable,
158 op, x, y,
159 width, height, stride,
160 data, surf->dri_private);
161 }
162
163 static void
164 swrast_put_image(__DRIdrawable *driDrawable,
165 int op,
166 int x,
167 int y,
168 int width,
169 int height,
170 char *data,
171 void *loaderPrivate)
172 {
173 return swrast_put_image2(driDrawable, op, x, y, width, height,
174 width * 4, data, loaderPrivate);
175 }
176
177 static void
178 swrast_get_image(__DRIdrawable *driDrawable,
179 int x,
180 int y,
181 int width,
182 int height,
183 char *data,
184 void *loaderPrivate)
185 {
186 struct gbm_dri_surface *surf = loaderPrivate;
187 struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
188
189 dri->swrast_get_image(driDrawable,
190 x, y,
191 width, height,
192 data, surf->dri_private);
193 }
194
195 static const __DRIuseInvalidateExtension use_invalidate = {
196 .base = { __DRI_USE_INVALIDATE, 1 }
197 };
198
199 static const __DRIimageLookupExtension image_lookup_extension = {
200 .base = { __DRI_IMAGE_LOOKUP, 1 },
201
202 .lookupEGLImage = dri_lookup_egl_image
203 };
204
205 static const __DRIdri2LoaderExtension dri2_loader_extension = {
206 .base = { __DRI_DRI2_LOADER, 3 },
207
208 .getBuffers = dri_get_buffers,
209 .flushFrontBuffer = dri_flush_front_buffer,
210 .getBuffersWithFormat = dri_get_buffers_with_format,
211 };
212
213 static const __DRIimageLoaderExtension image_loader_extension = {
214 .base = { __DRI_IMAGE_LOADER, 1 },
215
216 .getBuffers = image_get_buffers,
217 .flushFrontBuffer = dri_flush_front_buffer,
218 };
219
220 static const __DRIswrastLoaderExtension swrast_loader_extension = {
221 .base = { __DRI_SWRAST_LOADER, 2 },
222
223 .getDrawableInfo = swrast_get_drawable_info,
224 .putImage = swrast_put_image,
225 .getImage = swrast_get_image,
226 .putImage2 = swrast_put_image2
227 };
228
229 static const __DRIextension *gbm_dri_screen_extensions[] = {
230 &image_lookup_extension.base,
231 &use_invalidate.base,
232 &dri2_loader_extension.base,
233 &image_loader_extension.base,
234 &swrast_loader_extension.base,
235 NULL,
236 };
237
238 struct dri_extension_match {
239 const char *name;
240 int version;
241 int offset;
242 int optional;
243 };
244
245 static struct dri_extension_match dri_core_extensions[] = {
246 { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
247 { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
248 { __DRI2_FENCE, 2, offsetof(struct gbm_dri_device, fence), 1 },
249 { NULL, 0, 0 }
250 };
251
252 static struct dri_extension_match gbm_dri_device_extensions[] = {
253 { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
254 { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
255 { NULL, 0, 0 }
256 };
257
258 static struct dri_extension_match gbm_swrast_device_extensions[] = {
259 { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core), },
260 { __DRI_SWRAST, 1, offsetof(struct gbm_dri_device, swrast) },
261 { NULL, 0, 0 }
262 };
263
264 static int
265 dri_bind_extensions(struct gbm_dri_device *dri,
266 struct dri_extension_match *matches,
267 const __DRIextension **extensions)
268 {
269 int i, j, ret = 0;
270 void *field;
271
272 for (i = 0; extensions[i]; i++) {
273 for (j = 0; matches[j].name; j++) {
274 if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
275 extensions[i]->version >= matches[j].version) {
276 field = ((char *) dri + matches[j].offset);
277 *(const __DRIextension **) field = extensions[i];
278 }
279 }
280 }
281
282 for (j = 0; matches[j].name; j++) {
283 field = ((char *) dri + matches[j].offset);
284 if ((*(const __DRIextension **) field == NULL) && !matches[j].optional) {
285 ret = -1;
286 }
287 }
288
289 return ret;
290 }
291
292 static const __DRIextension **
293 dri_open_driver(struct gbm_dri_device *dri)
294 {
295 const __DRIextension **extensions = NULL;
296 char path[PATH_MAX], *search_paths, *p, *next, *end;
297 char *get_extensions_name;
298
299 search_paths = NULL;
300 /* don't allow setuid apps to use LIBGL_DRIVERS_PATH or GBM_DRIVERS_PATH */
301 if (geteuid() == getuid()) {
302 /* Read GBM_DRIVERS_PATH first for compatibility, but LIBGL_DRIVERS_PATH
303 * is recommended over GBM_DRIVERS_PATH.
304 */
305 search_paths = getenv("GBM_DRIVERS_PATH");
306
307 /* Read LIBGL_DRIVERS_PATH if GBM_DRIVERS_PATH was not set.
308 * LIBGL_DRIVERS_PATH is recommended over GBM_DRIVERS_PATH.
309 */
310 if (search_paths == NULL) {
311 search_paths = getenv("LIBGL_DRIVERS_PATH");
312 }
313 }
314 if (search_paths == NULL)
315 search_paths = DEFAULT_DRIVER_DIR;
316
317 /* Temporarily work around dri driver libs that need symbols in libglapi
318 * but don't automatically link it in.
319 */
320 /* XXX: Library name differs on per platforms basis. Update this as
321 * osx/cygwin/windows/bsd gets support for GBM..
322 */
323 dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
324
325 dri->driver = NULL;
326 end = search_paths + strlen(search_paths);
327 for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
328 int len;
329 next = strchr(p, ':');
330 if (next == NULL)
331 next = end;
332
333 len = next - p;
334 #if GLX_USE_TLS
335 snprintf(path, sizeof path,
336 "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
337 dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
338 #endif
339 if (dri->driver == NULL) {
340 snprintf(path, sizeof path,
341 "%.*s/%s_dri.so", len, p, dri->base.driver_name);
342 dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
343 }
344 /* not need continue to loop all paths once the driver is found */
345 if (dri->driver != NULL)
346 break;
347
348 #ifdef ANDROID
349 snprintf(path, sizeof path, "%.*s/gallium_dri.so", len, p);
350 dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
351 if (dri->driver == NULL)
352 sprintf("failed to open %s: %s\n", path, dlerror());
353 else
354 break;
355 #endif
356 }
357
358 if (dri->driver == NULL) {
359 fprintf(stderr, "gbm: failed to open any driver (search paths %s)\n",
360 search_paths);
361 fprintf(stderr, "gbm: Last dlopen error: %s\n", dlerror());
362 return NULL;
363 }
364
365 if (asprintf(&get_extensions_name, "%s_%s",
366 __DRI_DRIVER_GET_EXTENSIONS, dri->base.driver_name) != -1) {
367 const __DRIextension **(*get_extensions)(void);
368
369 get_extensions = dlsym(dri->driver, get_extensions_name);
370 free(get_extensions_name);
371
372 if (get_extensions)
373 extensions = get_extensions();
374 }
375
376 if (!extensions)
377 extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
378 if (extensions == NULL) {
379 fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
380 dlclose(dri->driver);
381 }
382
383 return extensions;
384 }
385
386 static int
387 dri_load_driver(struct gbm_dri_device *dri)
388 {
389 const __DRIextension **extensions;
390
391 extensions = dri_open_driver(dri);
392 if (!extensions)
393 return -1;
394
395 if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
396 dlclose(dri->driver);
397 fprintf(stderr, "failed to bind extensions\n");
398 return -1;
399 }
400
401 dri->driver_extensions = extensions;
402
403 return 0;
404 }
405
406 static int
407 dri_load_driver_swrast(struct gbm_dri_device *dri)
408 {
409 const __DRIextension **extensions;
410
411 extensions = dri_open_driver(dri);
412 if (!extensions)
413 return -1;
414
415 if (dri_bind_extensions(dri, gbm_swrast_device_extensions, extensions) < 0) {
416 dlclose(dri->driver);
417 fprintf(stderr, "failed to bind extensions\n");
418 return -1;
419 }
420
421 dri->driver_extensions = extensions;
422
423 return 0;
424 }
425
426 static int
427 dri_screen_create_dri2(struct gbm_dri_device *dri, char *driver_name)
428 {
429 const __DRIextension **extensions;
430 int ret = 0;
431
432 dri->base.driver_name = driver_name;
433 if (dri->base.driver_name == NULL)
434 return -1;
435
436 ret = dri_load_driver(dri);
437 if (ret) {
438 fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name);
439 return ret;
440 };
441
442 dri->extensions = gbm_dri_screen_extensions;
443
444 if (dri->dri2 == NULL)
445 return -1;
446
447 if (dri->dri2->base.version >= 4) {
448 dri->screen = dri->dri2->createNewScreen2(0, dri->base.base.fd,
449 dri->extensions,
450 dri->driver_extensions,
451 &dri->driver_configs, dri);
452 } else {
453 dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
454 dri->extensions,
455 &dri->driver_configs, dri);
456 }
457 if (dri->screen == NULL)
458 return -1;
459
460 extensions = dri->core->getExtensions(dri->screen);
461 if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
462 ret = -1;
463 goto free_screen;
464 }
465
466 dri->lookup_image = NULL;
467 dri->lookup_user_data = NULL;
468
469 return 0;
470
471 free_screen:
472 dri->core->destroyScreen(dri->screen);
473
474 return ret;
475 }
476
477 static int
478 dri_screen_create_swrast(struct gbm_dri_device *dri)
479 {
480 int ret;
481
482 dri->base.driver_name = strdup("swrast");
483 if (dri->base.driver_name == NULL)
484 return -1;
485
486 ret = dri_load_driver_swrast(dri);
487 if (ret) {
488 fprintf(stderr, "failed to load swrast driver\n");
489 return ret;
490 }
491
492 dri->extensions = gbm_dri_screen_extensions;
493
494 if (dri->swrast == NULL)
495 return -1;
496
497 if (dri->swrast->base.version >= 4) {
498 dri->screen = dri->swrast->createNewScreen2(0, dri->extensions,
499 dri->driver_extensions,
500 &dri->driver_configs, dri);
501 } else {
502 dri->screen = dri->swrast->createNewScreen(0, dri->extensions,
503 &dri->driver_configs, dri);
504 }
505 if (dri->screen == NULL)
506 return -1;
507
508 dri->lookup_image = NULL;
509 dri->lookup_user_data = NULL;
510
511 return 0;
512 }
513
514 static int
515 dri_screen_create(struct gbm_dri_device *dri)
516 {
517 char *driver_name;
518
519 driver_name = loader_get_driver_for_fd(dri->base.base.fd, 0);
520 if (!driver_name)
521 return -1;
522
523 return dri_screen_create_dri2(dri, driver_name);
524 }
525
526 static int
527 dri_screen_create_sw(struct gbm_dri_device *dri)
528 {
529 char *driver_name;
530 int ret;
531
532 driver_name = strdup("kms_swrast");
533 if (!driver_name)
534 return -errno;
535
536 ret = dri_screen_create_dri2(dri, driver_name);
537 if (ret == 0)
538 return ret;
539
540 return dri_screen_create_swrast(dri);
541 }
542
543 static int
544 gbm_dri_is_format_supported(struct gbm_device *gbm,
545 uint32_t format,
546 uint32_t usage)
547 {
548 switch (format) {
549 case GBM_BO_FORMAT_XRGB8888:
550 case GBM_FORMAT_XBGR8888:
551 case GBM_FORMAT_XRGB8888:
552 break;
553 case GBM_BO_FORMAT_ARGB8888:
554 case GBM_FORMAT_ARGB8888:
555 if (usage & GBM_BO_USE_SCANOUT)
556 return 0;
557 break;
558 default:
559 return 0;
560 }
561
562 if (usage & GBM_BO_USE_CURSOR &&
563 usage & GBM_BO_USE_RENDERING)
564 return 0;
565
566 return 1;
567 }
568
569 static int
570 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
571 {
572 struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
573
574 if (bo->image != NULL) {
575 errno = EINVAL;
576 return -1;
577 }
578
579 memcpy(bo->map, buf, count);
580
581 return 0;
582 }
583
584 static int
585 gbm_dri_bo_get_fd(struct gbm_bo *_bo)
586 {
587 struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
588 struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
589 int fd;
590
591 if (bo->image == NULL)
592 return -1;
593
594 if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FD, &fd))
595 return -1;
596
597 return fd;
598 }
599
600 static void
601 gbm_dri_bo_destroy(struct gbm_bo *_bo)
602 {
603 struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
604 struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
605 struct drm_mode_destroy_dumb arg;
606
607 if (bo->image != NULL) {
608 dri->image->destroyImage(bo->image);
609 } else {
610 gbm_dri_bo_unmap_dumb(bo);
611 memset(&arg, 0, sizeof(arg));
612 arg.handle = bo->handle;
613 drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
614 }
615
616 free(bo);
617 }
618
619 static uint32_t
620 gbm_dri_to_gbm_format(uint32_t dri_format)
621 {
622 uint32_t ret = 0;
623
624 switch (dri_format) {
625 case __DRI_IMAGE_FORMAT_RGB565:
626 ret = GBM_FORMAT_RGB565;
627 break;
628 case __DRI_IMAGE_FORMAT_XRGB8888:
629 ret = GBM_FORMAT_XRGB8888;
630 break;
631 case __DRI_IMAGE_FORMAT_ARGB8888:
632 ret = GBM_FORMAT_ARGB8888;
633 break;
634 case __DRI_IMAGE_FORMAT_XBGR8888:
635 ret = GBM_FORMAT_XBGR8888;
636 break;
637 case __DRI_IMAGE_FORMAT_ABGR8888:
638 ret = GBM_FORMAT_ABGR8888;
639 break;
640 default:
641 ret = 0;
642 break;
643 }
644
645 return ret;
646 }
647
648 static struct gbm_bo *
649 gbm_dri_bo_import(struct gbm_device *gbm,
650 uint32_t type, void *buffer, uint32_t usage)
651 {
652 struct gbm_dri_device *dri = gbm_dri_device(gbm);
653 struct gbm_dri_bo *bo;
654 __DRIimage *image;
655 unsigned dri_use = 0;
656 int gbm_format;
657
658 /* Required for query image WIDTH & HEIGHT */
659 if (dri->image == NULL || dri->image->base.version < 4) {
660 errno = ENOSYS;
661 return NULL;
662 }
663
664 switch (type) {
665 #if HAVE_WAYLAND_PLATFORM
666 case GBM_BO_IMPORT_WL_BUFFER:
667 {
668 struct wl_drm_buffer *wb;
669
670 if (!dri->wl_drm) {
671 errno = EINVAL;
672 return NULL;
673 }
674
675 wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
676 if (!wb) {
677 errno = EINVAL;
678 return NULL;
679 }
680
681 image = dri->image->dupImage(wb->driver_buffer, NULL);
682
683 switch (wb->format) {
684 case WL_DRM_FORMAT_XRGB8888:
685 gbm_format = GBM_FORMAT_XRGB8888;
686 break;
687 case WL_DRM_FORMAT_ARGB8888:
688 gbm_format = GBM_FORMAT_ARGB8888;
689 break;
690 case WL_DRM_FORMAT_RGB565:
691 gbm_format = GBM_FORMAT_RGB565;
692 break;
693 case WL_DRM_FORMAT_YUYV:
694 gbm_format = GBM_FORMAT_YUYV;
695 break;
696 default:
697 return NULL;
698 }
699 break;
700 }
701 #endif
702
703 case GBM_BO_IMPORT_EGL_IMAGE:
704 {
705 int dri_format;
706 if (dri->lookup_image == NULL) {
707 errno = EINVAL;
708 return NULL;
709 }
710
711 image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
712 image = dri->image->dupImage(image, NULL);
713 dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
714 gbm_format = gbm_dri_to_gbm_format(dri_format);
715 if (gbm_format == 0) {
716 errno = EINVAL;
717 return NULL;
718 }
719 break;
720 }
721
722 case GBM_BO_IMPORT_FD:
723 {
724 struct gbm_import_fd_data *fd_data = buffer;
725 int stride = fd_data->stride, offset = 0;
726 int dri_format;
727
728 switch (fd_data->format) {
729 case GBM_BO_FORMAT_XRGB8888:
730 dri_format = GBM_FORMAT_XRGB8888;
731 break;
732 case GBM_BO_FORMAT_ARGB8888:
733 dri_format = GBM_FORMAT_ARGB8888;
734 break;
735 default:
736 dri_format = fd_data->format;
737 }
738
739 image = dri->image->createImageFromFds(dri->screen,
740 fd_data->width,
741 fd_data->height,
742 dri_format,
743 &fd_data->fd, 1,
744 &stride, &offset,
745 NULL);
746 if (image == NULL) {
747 errno = EINVAL;
748 return NULL;
749 }
750 gbm_format = fd_data->format;
751 break;
752 }
753
754 default:
755 errno = ENOSYS;
756 return NULL;
757 }
758
759
760 bo = calloc(1, sizeof *bo);
761 if (bo == NULL)
762 return NULL;
763
764 bo->image = image;
765
766 if (usage & GBM_BO_USE_SCANOUT)
767 dri_use |= __DRI_IMAGE_USE_SCANOUT;
768 if (usage & GBM_BO_USE_CURSOR)
769 dri_use |= __DRI_IMAGE_USE_CURSOR;
770 if (dri->image->base.version >= 2 &&
771 !dri->image->validateUsage(bo->image, dri_use)) {
772 errno = EINVAL;
773 free(bo);
774 return NULL;
775 }
776
777 bo->base.base.gbm = gbm;
778 bo->base.base.format = gbm_format;
779
780 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
781 (int*)&bo->base.base.width);
782 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
783 (int*)&bo->base.base.height);
784 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
785 (int*)&bo->base.base.stride);
786 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
787 &bo->base.base.handle.s32);
788
789 return &bo->base.base;
790 }
791
792 static struct gbm_bo *
793 create_dumb(struct gbm_device *gbm,
794 uint32_t width, uint32_t height,
795 uint32_t format, uint32_t usage)
796 {
797 struct gbm_dri_device *dri = gbm_dri_device(gbm);
798 struct drm_mode_create_dumb create_arg;
799 struct gbm_dri_bo *bo;
800 struct drm_mode_destroy_dumb destroy_arg;
801 int ret;
802 int is_cursor, is_scanout;
803
804 is_cursor = (usage & GBM_BO_USE_CURSOR) != 0 &&
805 format == GBM_FORMAT_ARGB8888;
806 is_scanout = (usage & GBM_BO_USE_SCANOUT) != 0 &&
807 format == GBM_FORMAT_XRGB8888;
808 if (!is_cursor && !is_scanout) {
809 errno = EINVAL;
810 return NULL;
811 }
812
813 bo = calloc(1, sizeof *bo);
814 if (bo == NULL)
815 return NULL;
816
817 memset(&create_arg, 0, sizeof(create_arg));
818 create_arg.bpp = 32;
819 create_arg.width = width;
820 create_arg.height = height;
821
822 ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
823 if (ret)
824 goto free_bo;
825
826 bo->base.base.gbm = gbm;
827 bo->base.base.width = width;
828 bo->base.base.height = height;
829 bo->base.base.stride = create_arg.pitch;
830 bo->base.base.format = format;
831 bo->base.base.handle.u32 = create_arg.handle;
832 bo->handle = create_arg.handle;
833 bo->size = create_arg.size;
834
835 if (gbm_dri_bo_map_dumb(bo) == NULL)
836 goto destroy_dumb;
837
838 return &bo->base.base;
839
840 destroy_dumb:
841 memset(&destroy_arg, 0, sizeof destroy_arg);
842 destroy_arg.handle = create_arg.handle;
843 drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
844 free_bo:
845 free(bo);
846
847 return NULL;
848 }
849
850 static struct gbm_bo *
851 gbm_dri_bo_create(struct gbm_device *gbm,
852 uint32_t width, uint32_t height,
853 uint32_t format, uint32_t usage)
854 {
855 struct gbm_dri_device *dri = gbm_dri_device(gbm);
856 struct gbm_dri_bo *bo;
857 int dri_format;
858 unsigned dri_use = 0;
859
860 if (usage & GBM_BO_USE_WRITE || dri->image == NULL)
861 return create_dumb(gbm, width, height, format, usage);
862
863 bo = calloc(1, sizeof *bo);
864 if (bo == NULL)
865 return NULL;
866
867 bo->base.base.gbm = gbm;
868 bo->base.base.width = width;
869 bo->base.base.height = height;
870 bo->base.base.format = format;
871
872 switch (format) {
873 case GBM_FORMAT_R8:
874 dri_format = __DRI_IMAGE_FORMAT_R8;
875 break;
876 case GBM_FORMAT_GR88:
877 dri_format = __DRI_IMAGE_FORMAT_GR88;
878 break;
879 case GBM_FORMAT_RGB565:
880 dri_format = __DRI_IMAGE_FORMAT_RGB565;
881 break;
882 case GBM_FORMAT_XRGB8888:
883 case GBM_BO_FORMAT_XRGB8888:
884 dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
885 break;
886 case GBM_FORMAT_ARGB8888:
887 case GBM_BO_FORMAT_ARGB8888:
888 dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
889 break;
890 case GBM_FORMAT_ABGR8888:
891 dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
892 break;
893 case GBM_FORMAT_XBGR8888:
894 dri_format = __DRI_IMAGE_FORMAT_XBGR8888;
895 break;
896 case GBM_FORMAT_ARGB2101010:
897 dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
898 break;
899 case GBM_FORMAT_XRGB2101010:
900 dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
901 break;
902 default:
903 errno = EINVAL;
904 goto failed;
905 }
906
907 if (usage & GBM_BO_USE_SCANOUT)
908 dri_use |= __DRI_IMAGE_USE_SCANOUT;
909 if (usage & GBM_BO_USE_CURSOR)
910 dri_use |= __DRI_IMAGE_USE_CURSOR;
911 if (usage & GBM_BO_USE_LINEAR)
912 dri_use |= __DRI_IMAGE_USE_LINEAR;
913
914 /* Gallium drivers requires shared in order to get the handle/stride */
915 dri_use |= __DRI_IMAGE_USE_SHARE;
916
917 bo->image =
918 dri->image->createImage(dri->screen,
919 width, height,
920 dri_format, dri_use,
921 bo);
922 if (bo->image == NULL)
923 goto failed;
924
925 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
926 &bo->base.base.handle.s32);
927 dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
928 (int *) &bo->base.base.stride);
929
930 return &bo->base.base;
931
932 failed:
933 free(bo);
934 return NULL;
935 }
936
937 static void *
938 gbm_dri_bo_map(struct gbm_bo *_bo,
939 uint32_t x, uint32_t y,
940 uint32_t width, uint32_t height,
941 uint32_t flags, uint32_t *stride, void **map_data)
942 {
943 struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
944 struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
945
946 /* If it's a dumb buffer, we already have a mapping */
947 if (bo->map) {
948 *map_data = (char *)bo->map + (bo->base.base.stride * y) + (x * 4);
949 *stride = bo->base.base.stride;
950 return *map_data;
951 }
952
953 if (!dri->image || dri->image->base.version < 12 || !dri->image->mapImage) {
954 errno = ENOSYS;
955 return NULL;
956 }
957
958 mtx_lock(&dri->mutex);
959 if (!dri->context)
960 dri->context = dri->dri2->createNewContext(dri->screen, NULL,
961 NULL, NULL);
962 assert(dri->context);
963 mtx_unlock(&dri->mutex);
964
965 /* GBM flags and DRI flags are the same, so just pass them on */
966 return dri->image->mapImage(dri->context, bo->image, x, y,
967 width, height, flags, (int *)stride,
968 map_data);
969 }
970
971 static void
972 gbm_dri_bo_unmap(struct gbm_bo *_bo, void *map_data)
973 {
974 struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
975 struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
976
977 /* Check if it's a dumb buffer and check the pointer is in range */
978 if (bo->map) {
979 assert(map_data >= bo->map);
980 assert(map_data < (bo->map + bo->size));
981 return;
982 }
983
984 if (!dri->context || !dri->image ||
985 dri->image->base.version < 12 || !dri->image->unmapImage)
986 return;
987
988 dri->image->unmapImage(dri->context, bo->image, map_data);
989 }
990
991
992 static struct gbm_surface *
993 gbm_dri_surface_create(struct gbm_device *gbm,
994 uint32_t width, uint32_t height,
995 uint32_t format, uint32_t flags)
996 {
997 struct gbm_dri_surface *surf;
998
999 surf = calloc(1, sizeof *surf);
1000 if (surf == NULL)
1001 return NULL;
1002
1003 surf->base.gbm = gbm;
1004 surf->base.width = width;
1005 surf->base.height = height;
1006 surf->base.format = format;
1007 surf->base.flags = flags;
1008
1009 return &surf->base;
1010 }
1011
1012 static void
1013 gbm_dri_surface_destroy(struct gbm_surface *_surf)
1014 {
1015 struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
1016
1017 free(surf);
1018 }
1019
1020 static void
1021 dri_destroy(struct gbm_device *gbm)
1022 {
1023 struct gbm_dri_device *dri = gbm_dri_device(gbm);
1024 unsigned i;
1025
1026 if (dri->context)
1027 dri->core->destroyContext(dri->context);
1028
1029 dri->core->destroyScreen(dri->screen);
1030 for (i = 0; dri->driver_configs[i]; i++)
1031 free((__DRIconfig *) dri->driver_configs[i]);
1032 free(dri->driver_configs);
1033 dlclose(dri->driver);
1034 free(dri->base.driver_name);
1035
1036 free(dri);
1037 }
1038
1039 static struct gbm_device *
1040 dri_device_create(int fd)
1041 {
1042 struct gbm_dri_device *dri;
1043 int ret, force_sw;
1044
1045 dri = calloc(1, sizeof *dri);
1046 if (!dri)
1047 return NULL;
1048
1049 dri->base.base.fd = fd;
1050 dri->base.base.bo_create = gbm_dri_bo_create;
1051 dri->base.base.bo_import = gbm_dri_bo_import;
1052 dri->base.base.bo_map = gbm_dri_bo_map;
1053 dri->base.base.bo_unmap = gbm_dri_bo_unmap;
1054 dri->base.base.is_format_supported = gbm_dri_is_format_supported;
1055 dri->base.base.bo_write = gbm_dri_bo_write;
1056 dri->base.base.bo_get_fd = gbm_dri_bo_get_fd;
1057 dri->base.base.bo_destroy = gbm_dri_bo_destroy;
1058 dri->base.base.destroy = dri_destroy;
1059 dri->base.base.surface_create = gbm_dri_surface_create;
1060 dri->base.base.surface_destroy = gbm_dri_surface_destroy;
1061
1062 dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
1063 dri->base.base.name = "drm";
1064
1065 mtx_init(&dri->mutex, mtx_plain);
1066
1067 force_sw = getenv("GBM_ALWAYS_SOFTWARE") != NULL;
1068 if (!force_sw) {
1069 ret = dri_screen_create(dri);
1070 if (ret)
1071 ret = dri_screen_create_sw(dri);
1072 } else {
1073 ret = dri_screen_create_sw(dri);
1074 }
1075
1076 if (ret)
1077 goto err_dri;
1078
1079 return &dri->base.base;
1080
1081 err_dri:
1082 free(dri);
1083
1084 return NULL;
1085 }
1086
1087 struct gbm_backend gbm_dri_backend = {
1088 .backend_name = "dri",
1089 .create_device = dri_device_create,
1090 };