| /contrib/sdk/sources/Mesa/src/gbm/backends/dri/driver_name.c |
|---|
| 0,0 → 1,89 |
| /* |
| * Copyright © 2011 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: |
| * Kristian Høgsberg <krh@bitplanet.net> |
| * Benjamin Franzke <benjaminfranzke@googlemail.com> |
| */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <libudev.h> |
| #include "gbm_driint.h" |
| #define DRIVER_MAP_DRI2_ONLY |
| #include "pci_ids/pci_id_driver_map.h" |
| char * |
| dri_fd_get_driver_name(int fd) |
| { |
| struct udev *udev; |
| struct udev_device *device, *parent; |
| const char *pci_id; |
| char *driver = NULL; |
| int vendor_id, chip_id, i, j; |
| udev = udev_new(); |
| device = _gbm_udev_device_new_from_fd(udev, fd); |
| if (device == NULL) |
| return NULL; |
| parent = udev_device_get_parent(device); |
| if (parent == NULL) { |
| fprintf(stderr, "gbm: could not get parent device"); |
| goto out; |
| } |
| pci_id = udev_device_get_property_value(parent, "PCI_ID"); |
| if (pci_id == NULL || |
| sscanf(pci_id, "%x:%x", &vendor_id, &chip_id) != 2) { |
| fprintf(stderr, "gbm: malformed or no PCI ID"); |
| goto out; |
| } |
| for (i = 0; driver_map[i].driver; i++) { |
| if (vendor_id != driver_map[i].vendor_id) |
| continue; |
| if (driver_map[i].num_chips_ids == -1) { |
| driver = strdup(driver_map[i].driver); |
| _gbm_log("pci id for %d: %04x:%04x, driver %s", |
| fd, vendor_id, chip_id, driver); |
| goto out; |
| } |
| for (j = 0; j < driver_map[i].num_chips_ids; j++) |
| if (driver_map[i].chip_ids[j] == chip_id) { |
| driver = strdup(driver_map[i].driver); |
| _gbm_log("pci id for %d: %04x:%04x, driver %s", |
| fd, vendor_id, chip_id, driver); |
| goto out; |
| } |
| } |
| out: |
| udev_device_unref(device); |
| udev_unref(udev); |
| return driver; |
| } |
| /contrib/sdk/sources/Mesa/src/gbm/backends/dri/gbm_dri.c |
|---|
| 0,0 → 1,671 |
| /* |
| * Copyright © 2011 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: |
| * Benjamin Franzke <benjaminfranzke@googlemail.com> |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <string.h> |
| #include <limits.h> |
| #include <sys/types.h> |
| //#include <sys/mman.h> |
| #include <unistd.h> |
| //#include <dlfcn.h> |
| #include <xf86drm.h> |
| #include <GL/gl.h> /* dri_interface needs GL types */ |
| #include <GL/internal/dri_interface.h> |
| #include "gbm_driint.h" |
| #include "gbmint.h" |
| /* For importing wl_buffer */ |
| #if HAVE_WAYLAND_PLATFORM |
| #include "../../../egl/wayland/wayland-drm/wayland-drm.h" |
| #endif |
| void *load_library(const char *name); |
| void *get_proc_address(void *lib, char *proc_name); |
| static __DRIimage * |
| dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data) |
| { |
| struct gbm_dri_device *dri = data; |
| if (dri->lookup_image == NULL) |
| return NULL; |
| return dri->lookup_image(screen, image, dri->lookup_user_data); |
| } |
| static __DRIbuffer * |
| dri_get_buffers(__DRIdrawable * driDrawable, |
| int *width, int *height, |
| unsigned int *attachments, int count, |
| int *out_count, void *data) |
| { |
| struct gbm_dri_surface *surf = data; |
| struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); |
| if (dri->get_buffers == NULL) |
| return NULL; |
| return dri->get_buffers(driDrawable, width, height, attachments, |
| count, out_count, surf->dri_private); |
| } |
| static void |
| dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data) |
| { |
| struct gbm_dri_surface *surf = data; |
| struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); |
| if (dri->flush_front_buffer != NULL) |
| dri->flush_front_buffer(driDrawable, surf->dri_private); |
| } |
| static __DRIbuffer * |
| dri_get_buffers_with_format(__DRIdrawable * driDrawable, |
| int *width, int *height, |
| unsigned int *attachments, int count, |
| int *out_count, void *data) |
| { |
| struct gbm_dri_surface *surf = data; |
| struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); |
| if (dri->get_buffers_with_format == NULL) |
| return NULL; |
| return |
| dri->get_buffers_with_format(driDrawable, width, height, attachments, |
| count, out_count, surf->dri_private); |
| } |
| static const __DRIuseInvalidateExtension use_invalidate = { |
| { __DRI_USE_INVALIDATE, 1 } |
| }; |
| static const __DRIimageLookupExtension image_lookup_extension = { |
| { __DRI_IMAGE_LOOKUP, 1 }, |
| dri_lookup_egl_image |
| }; |
| const __DRIdri2LoaderExtension dri2_loader_extension = { |
| { __DRI_DRI2_LOADER, 3 }, |
| dri_get_buffers, |
| dri_flush_front_buffer, |
| dri_get_buffers_with_format, |
| }; |
| struct dri_extension_match { |
| const char *name; |
| int version; |
| int offset; |
| }; |
| static struct dri_extension_match dri_core_extensions[] = { |
| { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) }, |
| { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) }, |
| { NULL, 0, 0 } |
| }; |
| static struct dri_extension_match gbm_dri_device_extensions[] = { |
| { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) }, |
| { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) }, |
| { NULL, 0, 0 } |
| }; |
| static int |
| dri_bind_extensions(struct gbm_dri_device *dri, |
| struct dri_extension_match *matches, |
| const __DRIextension **extensions) |
| { |
| int i, j, ret = 0; |
| void *field; |
| for (i = 0; extensions[i]; i++) { |
| for (j = 0; matches[j].name; j++) { |
| if (strcmp(extensions[i]->name, matches[j].name) == 0 && |
| extensions[i]->version >= matches[j].version) { |
| field = ((char *) dri + matches[j].offset); |
| *(const __DRIextension **) field = extensions[i]; |
| } |
| } |
| } |
| for (j = 0; matches[j].name; j++) { |
| field = ((char *) dri + matches[j].offset); |
| if (*(const __DRIextension **) field == NULL) { |
| ret = -1; |
| } |
| } |
| return ret; |
| } |
| static int |
| dri_load_driver(struct gbm_dri_device *dri) |
| { |
| const __DRIextension **extensions; |
| // char path[PATH_MAX], *search_paths, *p, *next, *end; |
| char *search_paths; |
| search_paths = NULL; |
| #if 0 |
| if (geteuid() == getuid()) { |
| /* don't allow setuid apps to use GBM_DRIVERS_PATH */ |
| search_paths = getenv("GBM_DRIVERS_PATH"); |
| } |
| if (search_paths == NULL) |
| search_paths = DEFAULT_DRIVER_DIR; |
| dri->driver = NULL; |
| end = search_paths + strlen(search_paths); |
| for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) { |
| int len; |
| next = strchr(p, ':'); |
| if (next == NULL) |
| next = end; |
| len = next - p; |
| #if GLX_USE_TLS |
| snprintf(path, sizeof path, |
| "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name); |
| dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); |
| #endif |
| if (dri->driver == NULL) { |
| snprintf(path, sizeof path, |
| "%.*s/%s_dri.so", len, p, dri->base.driver_name); |
| dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); |
| if (dri->driver == NULL) |
| fprintf(stderr, "failed to open %s: %s\n", path, dlerror()); |
| } |
| } |
| #endif |
| dri->driver = load_library("libGL.dll"); |
| if (dri->driver == NULL) { |
| fprintf(stderr, "gbm: failed to open any driver (search paths %s)", |
| search_paths); |
| return -1; |
| } |
| extensions = get_proc_address(dri->driver, __DRI_DRIVER_EXTENSIONS); |
| if (extensions == NULL) { |
| fprintf(stderr, "gbm: driver exports no extensions\n"); |
| // dlclose(dri->driver); |
| return -1; |
| } |
| if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) { |
| // dlclose(dri->driver); |
| fprintf(stderr, "failed to bind extensions\n"); |
| return -1; |
| } |
| return 0; |
| } |
| static int |
| dri_screen_create(struct gbm_dri_device *dri) |
| { |
| const __DRIextension **extensions; |
| int ret = 0; |
| dri->base.driver_name = strdup("drm"); //dri_fd_get_driver_name(dri->base.base.fd); |
| if (dri->base.driver_name == NULL) |
| return -1; |
| ret = dri_load_driver(dri); |
| if (ret) { |
| fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name); |
| return ret; |
| }; |
| dri->extensions[0] = &image_lookup_extension.base; |
| dri->extensions[1] = &use_invalidate.base; |
| dri->extensions[2] = &dri2_loader_extension.base; |
| dri->extensions[3] = NULL; |
| if (dri->dri2 == NULL) |
| return -1; |
| dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd, |
| dri->extensions, |
| &dri->driver_configs, dri); |
| if (dri->screen == NULL) |
| return -1; |
| extensions = dri->core->getExtensions(dri->screen); |
| if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) { |
| ret = -1; |
| goto free_screen; |
| } |
| dri->lookup_image = NULL; |
| dri->lookup_user_data = NULL; |
| return 0; |
| free_screen: |
| dri->core->destroyScreen(dri->screen); |
| return ret; |
| } |
| static int |
| gbm_dri_is_format_supported(struct gbm_device *gbm, |
| uint32_t format, |
| uint32_t usage) |
| { |
| switch (format) { |
| case GBM_BO_FORMAT_XRGB8888: |
| case GBM_FORMAT_XRGB8888: |
| break; |
| case GBM_BO_FORMAT_ARGB8888: |
| case GBM_FORMAT_ARGB8888: |
| if (usage & GBM_BO_USE_SCANOUT) |
| return 0; |
| break; |
| default: |
| return 0; |
| } |
| if (usage & GBM_BO_USE_CURSOR_64X64 && |
| usage & GBM_BO_USE_RENDERING) |
| return 0; |
| return 1; |
| } |
| static int |
| gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count) |
| { |
| struct gbm_dri_bo *bo = gbm_dri_bo(_bo); |
| if (bo->image != NULL) |
| return -1; |
| memcpy(bo->map, buf, count); |
| return 0; |
| } |
| static void |
| gbm_dri_bo_destroy(struct gbm_bo *_bo) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); |
| struct gbm_dri_bo *bo = gbm_dri_bo(_bo); |
| // struct drm_mode_destroy_dumb arg; |
| if (bo->image != NULL) { |
| dri->image->destroyImage(bo->image); |
| } else { |
| // munmap(bo->map, bo->size); |
| // memset(&arg, 0, sizeof(arg)); |
| // arg.handle = bo->handle; |
| // drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg); |
| } |
| free(bo); |
| } |
| static uint32_t |
| gbm_dri_to_gbm_format(uint32_t dri_format) |
| { |
| uint32_t ret = 0; |
| switch (dri_format) { |
| case __DRI_IMAGE_FORMAT_RGB565: |
| ret = GBM_FORMAT_RGB565; |
| break; |
| case __DRI_IMAGE_FORMAT_XRGB8888: |
| ret = GBM_FORMAT_XRGB8888; |
| break; |
| case __DRI_IMAGE_FORMAT_ARGB8888: |
| ret = GBM_FORMAT_ARGB8888; |
| break; |
| case __DRI_IMAGE_FORMAT_ABGR8888: |
| ret = GBM_FORMAT_ABGR8888; |
| break; |
| default: |
| ret = 0; |
| break; |
| } |
| return ret; |
| } |
| static struct gbm_bo * |
| gbm_dri_bo_import(struct gbm_device *gbm, |
| uint32_t type, void *buffer, uint32_t usage) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| struct gbm_dri_bo *bo; |
| __DRIimage *image; |
| unsigned dri_use = 0; |
| int gbm_format; |
| /* Required for query image WIDTH & HEIGHT */ |
| if (dri->image->base.version < 4) |
| return NULL; |
| switch (type) { |
| #if HAVE_WAYLAND_PLATFORM |
| case GBM_BO_IMPORT_WL_BUFFER: |
| { |
| struct wl_drm_buffer *wb = (struct wl_drm_buffer *) buffer; |
| if (!wayland_buffer_is_drm(buffer)) |
| return NULL; |
| image = wb->driver_buffer; |
| switch (wb->format) { |
| case WL_DRM_FORMAT_XRGB8888: |
| gbm_format = GBM_FORMAT_XRGB8888; |
| break; |
| case WL_DRM_FORMAT_ARGB8888: |
| gbm_format = GBM_FORMAT_ARGB8888; |
| break; |
| case WL_DRM_FORMAT_YUYV: |
| gbm_format = GBM_FORMAT_YUYV; |
| break; |
| default: |
| return NULL; |
| } |
| break; |
| } |
| #endif |
| case GBM_BO_IMPORT_EGL_IMAGE: |
| { |
| int dri_format; |
| if (dri->lookup_image == NULL) |
| return NULL; |
| image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data); |
| dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format); |
| gbm_format = gbm_dri_to_gbm_format(dri_format); |
| if (gbm_format == 0) |
| return NULL; |
| break; |
| } |
| default: |
| return NULL; |
| } |
| bo = calloc(1, sizeof *bo); |
| if (bo == NULL) |
| return NULL; |
| bo->image = dri->image->dupImage(image, NULL); |
| if (usage & GBM_BO_USE_SCANOUT) |
| dri_use |= __DRI_IMAGE_USE_SCANOUT; |
| if (usage & GBM_BO_USE_CURSOR_64X64) |
| dri_use |= __DRI_IMAGE_USE_CURSOR; |
| if (dri->image->base.version >= 2 && |
| !dri->image->validateUsage(bo->image, dri_use)) { |
| free(bo); |
| return NULL; |
| } |
| bo->base.base.gbm = gbm; |
| bo->base.base.format = gbm_format; |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH, |
| (int*)&bo->base.base.width); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT, |
| (int*)&bo->base.base.height); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, |
| (int*)&bo->base.base.stride); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, |
| &bo->base.base.handle.s32); |
| return &bo->base.base; |
| } |
| #if 0 |
| static struct gbm_bo * |
| create_dumb(struct gbm_device *gbm, |
| uint32_t width, uint32_t height, |
| uint32_t format, uint32_t usage) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| struct drm_mode_create_dumb create_arg; |
| struct drm_mode_map_dumb map_arg; |
| struct gbm_dri_bo *bo; |
| struct drm_mode_destroy_dumb destroy_arg; |
| int ret; |
| if (!(usage & GBM_BO_USE_CURSOR_64X64)) |
| return NULL; |
| if (format != GBM_FORMAT_ARGB8888) |
| return NULL; |
| bo = calloc(1, sizeof *bo); |
| if (bo == NULL) |
| return NULL; |
| create_arg.bpp = 32; |
| create_arg.width = width; |
| create_arg.height = height; |
| ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg); |
| if (ret) |
| goto free_bo; |
| bo->base.base.gbm = gbm; |
| bo->base.base.width = width; |
| bo->base.base.height = height; |
| bo->base.base.stride = create_arg.pitch; |
| bo->base.base.format = format; |
| bo->base.base.handle.u32 = create_arg.handle; |
| bo->handle = create_arg.handle; |
| bo->size = create_arg.size; |
| memset(&map_arg, 0, sizeof(map_arg)); |
| map_arg.handle = bo->handle; |
| ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg); |
| if (ret) |
| goto destroy_dumb; |
| bo->map = mmap(0, bo->size, PROT_WRITE, |
| MAP_SHARED, dri->base.base.fd, map_arg.offset); |
| if (bo->map == MAP_FAILED) |
| goto destroy_dumb; |
| return &bo->base.base; |
| destroy_dumb: |
| memset(&destroy_arg, 0, sizeof destroy_arg); |
| destroy_arg.handle = create_arg.handle; |
| drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg); |
| free_bo: |
| free(bo); |
| return NULL; |
| } |
| #endif |
| static struct gbm_bo * |
| gbm_dri_bo_create(struct gbm_device *gbm, |
| uint32_t width, uint32_t height, |
| uint32_t format, uint32_t usage) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| struct gbm_dri_bo *bo; |
| int dri_format; |
| unsigned dri_use = 0; |
| // if (usage & GBM_BO_USE_WRITE) |
| // return create_dumb(gbm, width, height, format, usage); |
| bo = calloc(1, sizeof *bo); |
| if (bo == NULL) |
| return NULL; |
| bo->base.base.gbm = gbm; |
| bo->base.base.width = width; |
| bo->base.base.height = height; |
| bo->base.base.format = format; |
| switch (format) { |
| case GBM_FORMAT_RGB565: |
| dri_format =__DRI_IMAGE_FORMAT_RGB565; |
| break; |
| case GBM_FORMAT_XRGB8888: |
| case GBM_BO_FORMAT_XRGB8888: |
| dri_format = __DRI_IMAGE_FORMAT_XRGB8888; |
| break; |
| case GBM_FORMAT_ARGB8888: |
| case GBM_BO_FORMAT_ARGB8888: |
| dri_format = __DRI_IMAGE_FORMAT_ARGB8888; |
| break; |
| case GBM_FORMAT_ABGR8888: |
| dri_format = __DRI_IMAGE_FORMAT_ABGR8888; |
| break; |
| default: |
| return NULL; |
| } |
| if (usage & GBM_BO_USE_SCANOUT) |
| dri_use |= __DRI_IMAGE_USE_SCANOUT; |
| if (usage & GBM_BO_USE_CURSOR_64X64) |
| dri_use |= __DRI_IMAGE_USE_CURSOR; |
| /* Gallium drivers requires shared in order to get the handle/stride */ |
| dri_use |= __DRI_IMAGE_USE_SHARE; |
| bo->image = |
| dri->image->createImage(dri->screen, |
| width, height, |
| dri_format, dri_use, |
| bo); |
| if (bo->image == NULL) |
| return NULL; |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, |
| &bo->base.base.handle.s32); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, |
| (int *) &bo->base.base.stride); |
| printf("%s handle %d w %d h%d\n",__FUNCTION__, bo->base.base.handle.s32, |
| width, height); |
| return &bo->base.base; |
| } |
| static struct gbm_surface * |
| gbm_dri_surface_create(struct gbm_device *gbm, |
| uint32_t width, uint32_t height, |
| uint32_t format, uint32_t flags) |
| { |
| struct gbm_dri_surface *surf; |
| surf = calloc(1, sizeof *surf); |
| if (surf == NULL) |
| return NULL; |
| surf->base.gbm = gbm; |
| surf->base.width = width; |
| surf->base.height = height; |
| surf->base.format = format; |
| surf->base.flags = flags; |
| return &surf->base; |
| } |
| static void |
| gbm_dri_surface_destroy(struct gbm_surface *_surf) |
| { |
| struct gbm_dri_surface *surf = gbm_dri_surface(_surf); |
| free(surf); |
| } |
| static void |
| dri_destroy(struct gbm_device *gbm) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| dri->core->destroyScreen(dri->screen); |
| free(dri->driver_configs); |
| // dlclose(dri->driver); |
| free(dri->base.driver_name); |
| free(dri); |
| } |
| static struct gbm_device * |
| dri_device_create(int fd) |
| { |
| struct gbm_dri_device *dri; |
| int ret; |
| dri = calloc(1, sizeof *dri); |
| dri->base.base.fd = fd; |
| dri->base.base.bo_create = gbm_dri_bo_create; |
| dri->base.base.bo_import = gbm_dri_bo_import; |
| dri->base.base.is_format_supported = gbm_dri_is_format_supported; |
| dri->base.base.bo_write = gbm_dri_bo_write; |
| dri->base.base.bo_destroy = gbm_dri_bo_destroy; |
| dri->base.base.destroy = dri_destroy; |
| dri->base.base.surface_create = gbm_dri_surface_create; |
| dri->base.base.surface_destroy = gbm_dri_surface_destroy; |
| dri->base.type = GBM_DRM_DRIVER_TYPE_DRI; |
| dri->base.base.name = "drm"; |
| ret = dri_screen_create(dri); |
| if (ret) |
| goto err_dri; |
| return &dri->base.base; |
| err_dri: |
| free(dri); |
| return NULL; |
| } |
| struct gbm_backend gbm_dri_backend = { |
| .backend_name = "dri", |
| .create_device = dri_device_create, |
| }; |
| /contrib/sdk/sources/Mesa/src/gbm/backends/dri/gbm_dri.c.bak |
|---|
| 0,0 → 1,673 |
| /* |
| * Copyright © 2011 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: |
| * Benjamin Franzke <benjaminfranzke@googlemail.com> |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <string.h> |
| #include <limits.h> |
| #include <sys/types.h> |
| //#include <sys/mman.h> |
| #include <unistd.h> |
| //#include <dlfcn.h> |
| #include <xf86drm.h> |
| #include <GL/gl.h> /* dri_interface needs GL types */ |
| #include <GL/internal/dri_interface.h> |
| #include "gbm_driint.h" |
| #include "gbmint.h" |
| /* For importing wl_buffer */ |
| #if HAVE_WAYLAND_PLATFORM |
| #include "../../../egl/wayland/wayland-drm/wayland-drm.h" |
| #endif |
| void *load_library(const char *name); |
| void *get_proc_address(void *lib, char *proc_name); |
| static __DRIimage * |
| dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data) |
| { |
| struct gbm_dri_device *dri = data; |
| if (dri->lookup_image == NULL) |
| return NULL; |
| return dri->lookup_image(screen, image, dri->lookup_user_data); |
| } |
| static __DRIbuffer * |
| dri_get_buffers(__DRIdrawable * driDrawable, |
| int *width, int *height, |
| unsigned int *attachments, int count, |
| int *out_count, void *data) |
| { |
| struct gbm_dri_surface *surf = data; |
| struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); |
| if (dri->get_buffers == NULL) |
| return NULL; |
| return dri->get_buffers(driDrawable, width, height, attachments, |
| count, out_count, surf->dri_private); |
| } |
| static void |
| dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data) |
| { |
| struct gbm_dri_surface *surf = data; |
| struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); |
| if (dri->flush_front_buffer != NULL) |
| dri->flush_front_buffer(driDrawable, surf->dri_private); |
| } |
| static __DRIbuffer * |
| dri_get_buffers_with_format(__DRIdrawable * driDrawable, |
| int *width, int *height, |
| unsigned int *attachments, int count, |
| int *out_count, void *data) |
| { |
| struct gbm_dri_surface *surf = data; |
| struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm); |
| if (dri->get_buffers_with_format == NULL) |
| return NULL; |
| return |
| dri->get_buffers_with_format(driDrawable, width, height, attachments, |
| count, out_count, surf->dri_private); |
| } |
| static const __DRIuseInvalidateExtension use_invalidate = { |
| { __DRI_USE_INVALIDATE, 1 } |
| }; |
| static const __DRIimageLookupExtension image_lookup_extension = { |
| { __DRI_IMAGE_LOOKUP, 1 }, |
| dri_lookup_egl_image |
| }; |
| const __DRIdri2LoaderExtension dri2_loader_extension = { |
| { __DRI_DRI2_LOADER, 3 }, |
| dri_get_buffers, |
| dri_flush_front_buffer, |
| dri_get_buffers_with_format, |
| }; |
| struct dri_extension_match { |
| const char *name; |
| int version; |
| int offset; |
| }; |
| static struct dri_extension_match dri_core_extensions[] = { |
| { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) }, |
| { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) }, |
| { NULL, 0, 0 } |
| }; |
| static struct dri_extension_match gbm_dri_device_extensions[] = { |
| { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) }, |
| { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) }, |
| { NULL, 0, 0 } |
| }; |
| static int |
| dri_bind_extensions(struct gbm_dri_device *dri, |
| struct dri_extension_match *matches, |
| const __DRIextension **extensions) |
| { |
| int i, j, ret = 0; |
| void *field; |
| for (i = 0; extensions[i]; i++) { |
| for (j = 0; matches[j].name; j++) { |
| if (strcmp(extensions[i]->name, matches[j].name) == 0 && |
| extensions[i]->version >= matches[j].version) { |
| field = ((char *) dri + matches[j].offset); |
| *(const __DRIextension **) field = extensions[i]; |
| } |
| } |
| } |
| for (j = 0; matches[j].name; j++) { |
| field = ((char *) dri + matches[j].offset); |
| if (*(const __DRIextension **) field == NULL) { |
| ret = -1; |
| } |
| } |
| return ret; |
| } |
| static int |
| dri_load_driver(struct gbm_dri_device *dri) |
| { |
| const __DRIextension **extensions; |
| // char path[PATH_MAX], *search_paths, *p, *next, *end; |
| char *search_paths; |
| search_paths = NULL; |
| #if 0 |
| if (geteuid() == getuid()) { |
| /* don't allow setuid apps to use GBM_DRIVERS_PATH */ |
| search_paths = getenv("GBM_DRIVERS_PATH"); |
| } |
| if (search_paths == NULL) |
| search_paths = DEFAULT_DRIVER_DIR; |
| dri->driver = NULL; |
| end = search_paths + strlen(search_paths); |
| for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) { |
| int len; |
| next = strchr(p, ':'); |
| if (next == NULL) |
| next = end; |
| len = next - p; |
| #if GLX_USE_TLS |
| snprintf(path, sizeof path, |
| "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name); |
| dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); |
| #endif |
| if (dri->driver == NULL) { |
| snprintf(path, sizeof path, |
| "%.*s/%s_dri.so", len, p, dri->base.driver_name); |
| dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); |
| if (dri->driver == NULL) |
| fprintf(stderr, "failed to open %s: %s\n", path, dlerror()); |
| } |
| } |
| #endif |
| dri->driver = load_library("libGL.dll"); |
| if (dri->driver == NULL) { |
| fprintf(stderr, "gbm: failed to open any driver (search paths %s)", |
| search_paths); |
| return -1; |
| } |
| extensions = get_proc_address(dri->driver, __DRI_DRIVER_EXTENSIONS); |
| if (extensions == NULL) { |
| fprintf(stderr, "gbm: driver exports no extensions\n"); |
| // dlclose(dri->driver); |
| return -1; |
| } |
| if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) { |
| // dlclose(dri->driver); |
| fprintf(stderr, "failed to bind extensions\n"); |
| return -1; |
| } |
| return 0; |
| } |
| static int |
| dri_screen_create(struct gbm_dri_device *dri) |
| { |
| const __DRIextension **extensions; |
| int ret = 0; |
| dri->base.driver_name = strdup("drm"); //dri_fd_get_driver_name(dri->base.base.fd); |
| if (dri->base.driver_name == NULL) |
| return -1; |
| ret = dri_load_driver(dri); |
| if (ret) { |
| fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name); |
| return ret; |
| }; |
| dri->extensions[0] = &image_lookup_extension.base; |
| dri->extensions[1] = &use_invalidate.base; |
| dri->extensions[2] = &dri2_loader_extension.base; |
| dri->extensions[3] = NULL; |
| if (dri->dri2 == NULL) |
| return -1; |
| dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd, |
| dri->extensions, |
| &dri->driver_configs, dri); |
| if (dri->screen == NULL) |
| return -1; |
| extensions = dri->core->getExtensions(dri->screen); |
| if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) { |
| ret = -1; |
| goto free_screen; |
| } |
| dri->lookup_image = NULL; |
| dri->lookup_user_data = NULL; |
| return 0; |
| free_screen: |
| dri->core->destroyScreen(dri->screen); |
| return ret; |
| } |
| static int |
| gbm_dri_is_format_supported(struct gbm_device *gbm, |
| uint32_t format, |
| uint32_t usage) |
| { |
| switch (format) { |
| case GBM_BO_FORMAT_XRGB8888: |
| case GBM_FORMAT_XRGB8888: |
| break; |
| case GBM_BO_FORMAT_ARGB8888: |
| case GBM_FORMAT_ARGB8888: |
| if (usage & GBM_BO_USE_SCANOUT) |
| return 0; |
| break; |
| default: |
| return 0; |
| } |
| if (usage & GBM_BO_USE_CURSOR_64X64 && |
| usage & GBM_BO_USE_RENDERING) |
| return 0; |
| return 1; |
| } |
| static int |
| gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count) |
| { |
| struct gbm_dri_bo *bo = gbm_dri_bo(_bo); |
| if (bo->image != NULL) |
| return -1; |
| memcpy(bo->map, buf, count); |
| return 0; |
| } |
| static void |
| gbm_dri_bo_destroy(struct gbm_bo *_bo) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); |
| struct gbm_dri_bo *bo = gbm_dri_bo(_bo); |
| // struct drm_mode_destroy_dumb arg; |
| if (bo->image != NULL) { |
| dri->image->destroyImage(bo->image); |
| } else { |
| // munmap(bo->map, bo->size); |
| // memset(&arg, 0, sizeof(arg)); |
| // arg.handle = bo->handle; |
| // drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg); |
| } |
| free(bo); |
| } |
| static uint32_t |
| gbm_dri_to_gbm_format(uint32_t dri_format) |
| { |
| uint32_t ret = 0; |
| switch (dri_format) { |
| case __DRI_IMAGE_FORMAT_RGB565: |
| ret = GBM_FORMAT_RGB565; |
| break; |
| case __DRI_IMAGE_FORMAT_XRGB8888: |
| ret = GBM_FORMAT_XRGB8888; |
| break; |
| case __DRI_IMAGE_FORMAT_ARGB8888: |
| ret = GBM_FORMAT_ARGB8888; |
| break; |
| case __DRI_IMAGE_FORMAT_ABGR8888: |
| ret = GBM_FORMAT_ABGR8888; |
| break; |
| default: |
| ret = 0; |
| break; |
| } |
| return ret; |
| } |
| static struct gbm_bo * |
| gbm_dri_bo_import(struct gbm_device *gbm, |
| uint32_t type, void *buffer, uint32_t usage) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| struct gbm_dri_bo *bo; |
| __DRIimage *image; |
| unsigned dri_use = 0; |
| int gbm_format; |
| /* Required for query image WIDTH & HEIGHT */ |
| if (dri->image->base.version < 4) |
| return NULL; |
| switch (type) { |
| #if HAVE_WAYLAND_PLATFORM |
| case GBM_BO_IMPORT_WL_BUFFER: |
| { |
| struct wl_drm_buffer *wb = (struct wl_drm_buffer *) buffer; |
| if (!wayland_buffer_is_drm(buffer)) |
| return NULL; |
| image = wb->driver_buffer; |
| switch (wb->format) { |
| case WL_DRM_FORMAT_XRGB8888: |
| gbm_format = GBM_FORMAT_XRGB8888; |
| break; |
| case WL_DRM_FORMAT_ARGB8888: |
| gbm_format = GBM_FORMAT_ARGB8888; |
| break; |
| case WL_DRM_FORMAT_YUYV: |
| gbm_format = GBM_FORMAT_YUYV; |
| break; |
| default: |
| return NULL; |
| } |
| break; |
| } |
| #endif |
| case GBM_BO_IMPORT_EGL_IMAGE: |
| { |
| int dri_format; |
| if (dri->lookup_image == NULL) |
| return NULL; |
| image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data); |
| dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format); |
| gbm_format = gbm_dri_to_gbm_format(dri_format); |
| if (gbm_format == 0) |
| return NULL; |
| break; |
| } |
| default: |
| return NULL; |
| } |
| bo = calloc(1, sizeof *bo); |
| if (bo == NULL) |
| return NULL; |
| bo->image = dri->image->dupImage(image, NULL); |
| if (usage & GBM_BO_USE_SCANOUT) |
| dri_use |= __DRI_IMAGE_USE_SCANOUT; |
| if (usage & GBM_BO_USE_CURSOR_64X64) |
| dri_use |= __DRI_IMAGE_USE_CURSOR; |
| if (dri->image->base.version >= 2 && |
| !dri->image->validateUsage(bo->image, dri_use)) { |
| free(bo); |
| return NULL; |
| } |
| bo->base.base.gbm = gbm; |
| bo->base.base.format = gbm_format; |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH, |
| (int*)&bo->base.base.width); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT, |
| (int*)&bo->base.base.height); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, |
| (int*)&bo->base.base.stride); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, |
| &bo->base.base.handle.s32); |
| return &bo->base.base; |
| } |
| #if 0 |
| static struct gbm_bo * |
| create_dumb(struct gbm_device *gbm, |
| uint32_t width, uint32_t height, |
| uint32_t format, uint32_t usage) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| struct drm_mode_create_dumb create_arg; |
| struct drm_mode_map_dumb map_arg; |
| struct gbm_dri_bo *bo; |
| struct drm_mode_destroy_dumb destroy_arg; |
| int ret; |
| if (!(usage & GBM_BO_USE_CURSOR_64X64)) |
| return NULL; |
| if (format != GBM_FORMAT_ARGB8888) |
| return NULL; |
| bo = calloc(1, sizeof *bo); |
| if (bo == NULL) |
| return NULL; |
| create_arg.bpp = 32; |
| create_arg.width = width; |
| create_arg.height = height; |
| ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg); |
| if (ret) |
| goto free_bo; |
| bo->base.base.gbm = gbm; |
| bo->base.base.width = width; |
| bo->base.base.height = height; |
| bo->base.base.stride = create_arg.pitch; |
| bo->base.base.format = format; |
| bo->base.base.handle.u32 = create_arg.handle; |
| bo->handle = create_arg.handle; |
| bo->size = create_arg.size; |
| memset(&map_arg, 0, sizeof(map_arg)); |
| map_arg.handle = bo->handle; |
| ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg); |
| if (ret) |
| goto destroy_dumb; |
| bo->map = mmap(0, bo->size, PROT_WRITE, |
| MAP_SHARED, dri->base.base.fd, map_arg.offset); |
| if (bo->map == MAP_FAILED) |
| goto destroy_dumb; |
| return &bo->base.base; |
| destroy_dumb: |
| memset(&destroy_arg, 0, sizeof destroy_arg); |
| destroy_arg.handle = create_arg.handle; |
| drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg); |
| free_bo: |
| free(bo); |
| return NULL; |
| } |
| #endif |
| static struct gbm_bo * |
| gbm_dri_bo_create(struct gbm_device *gbm, |
| uint32_t width, uint32_t height, |
| uint32_t format, uint32_t usage) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| struct gbm_dri_bo *bo; |
| int dri_format; |
| unsigned dri_use = 0; |
| // if (usage & GBM_BO_USE_WRITE) |
| // return create_dumb(gbm, width, height, format, usage); |
| bo = calloc(1, sizeof *bo); |
| if (bo == NULL) |
| return NULL; |
| bo->base.base.gbm = gbm; |
| bo->base.base.width = width; |
| bo->base.base.height = height; |
| bo->base.base.format = format; |
| switch (format) { |
| case GBM_FORMAT_RGB565: |
| dri_format =__DRI_IMAGE_FORMAT_RGB565; |
| break; |
| case GBM_FORMAT_XRGB8888: |
| case GBM_BO_FORMAT_XRGB8888: |
| dri_format = __DRI_IMAGE_FORMAT_XRGB8888; |
| break; |
| case GBM_FORMAT_ARGB8888: |
| case GBM_BO_FORMAT_ARGB8888: |
| dri_format = __DRI_IMAGE_FORMAT_ARGB8888; |
| break; |
| case GBM_FORMAT_ABGR8888: |
| dri_format = __DRI_IMAGE_FORMAT_ABGR8888; |
| break; |
| default: |
| return NULL; |
| } |
| if (usage & GBM_BO_USE_SCANOUT) |
| dri_use |= __DRI_IMAGE_USE_SCANOUT; |
| if (usage & GBM_BO_USE_CURSOR_64X64) |
| dri_use |= __DRI_IMAGE_USE_CURSOR; |
| /* Gallium drivers requires shared in order to get the handle/stride */ |
| dri_use |= __DRI_IMAGE_USE_SHARE; |
| bo->image = |
| dri->image->createImage(dri->screen, |
| width, height, |
| dri_format, dri_use, |
| bo); |
| if (bo->image == NULL) |
| return NULL; |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, |
| &bo->base.base.handle.s32); |
| dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, |
| (int *) &bo->base.base.stride); |
| printf("gbm_dri_bo_create bo: %p handle %d" |
| " width: %d height: %d pitch: %d format %d\n",bo, bo->base.base.handle.s32, |
| bo->base.base.width, bo->base.base.height, |
| (int)bo->base.base.stride,bo->base.base.format); |
| return &bo->base.base; |
| } |
| static struct gbm_surface * |
| gbm_dri_surface_create(struct gbm_device *gbm, |
| uint32_t width, uint32_t height, |
| uint32_t format, uint32_t flags) |
| { |
| struct gbm_dri_surface *surf; |
| surf = calloc(1, sizeof *surf); |
| if (surf == NULL) |
| return NULL; |
| surf->base.gbm = gbm; |
| surf->base.width = width; |
| surf->base.height = height; |
| surf->base.format = format; |
| surf->base.flags = flags; |
| return &surf->base; |
| } |
| static void |
| gbm_dri_surface_destroy(struct gbm_surface *_surf) |
| { |
| struct gbm_dri_surface *surf = gbm_dri_surface(_surf); |
| free(surf); |
| } |
| static void |
| dri_destroy(struct gbm_device *gbm) |
| { |
| struct gbm_dri_device *dri = gbm_dri_device(gbm); |
| dri->core->destroyScreen(dri->screen); |
| free(dri->driver_configs); |
| // dlclose(dri->driver); |
| free(dri->base.driver_name); |
| free(dri); |
| } |
| static struct gbm_device * |
| dri_device_create(int fd) |
| { |
| struct gbm_dri_device *dri; |
| int ret; |
| dri = calloc(1, sizeof *dri); |
| dri->base.base.fd = fd; |
| dri->base.base.bo_create = gbm_dri_bo_create; |
| dri->base.base.bo_import = gbm_dri_bo_import; |
| dri->base.base.is_format_supported = gbm_dri_is_format_supported; |
| dri->base.base.bo_write = gbm_dri_bo_write; |
| dri->base.base.bo_destroy = gbm_dri_bo_destroy; |
| dri->base.base.destroy = dri_destroy; |
| dri->base.base.surface_create = gbm_dri_surface_create; |
| dri->base.base.surface_destroy = gbm_dri_surface_destroy; |
| dri->base.type = GBM_DRM_DRIVER_TYPE_DRI; |
| dri->base.base.name = "drm"; |
| ret = dri_screen_create(dri); |
| if (ret) |
| goto err_dri; |
| return &dri->base.base; |
| err_dri: |
| free(dri); |
| return NULL; |
| } |
| struct gbm_backend gbm_dri_backend = { |
| .backend_name = "dri", |
| .create_device = dri_device_create, |
| }; |
| /contrib/sdk/sources/Mesa/src/gbm/backends/dri/gbm_driint.h |
|---|
| 0,0 → 1,108 |
| /* |
| * Copyright © 2011 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: |
| * Benjamin Franzke <benjaminfranzke@googlemail.com> |
| */ |
| #ifndef _GBM_DRI_INTERNAL_H_ |
| #define _GBM_DRI_INTERNAL_H_ |
| #include "gbmint.h" |
| #include "common.h" |
| #include "common_drm.h" |
| #include <GL/gl.h> /* dri_interface needs GL types */ |
| #include "GL/internal/dri_interface.h" |
| struct gbm_dri_surface; |
| struct gbm_dri_device { |
| struct gbm_drm_device base; |
| void *driver; |
| __DRIscreen *screen; |
| __DRIcoreExtension *core; |
| __DRIdri2Extension *dri2; |
| __DRIimageExtension *image; |
| __DRI2flushExtension *flush; |
| __DRIdri2LoaderExtension *loader; |
| const __DRIconfig **driver_configs; |
| const __DRIextension *extensions[4]; |
| __DRIimage *(*lookup_image)(__DRIscreen *screen, void *image, void *data); |
| void *lookup_user_data; |
| __DRIbuffer *(*get_buffers)(__DRIdrawable * driDrawable, |
| int *width, int *height, |
| unsigned int *attachments, int count, |
| int *out_count, void *data); |
| void (*flush_front_buffer)(__DRIdrawable * driDrawable, void *data); |
| __DRIbuffer *(*get_buffers_with_format)(__DRIdrawable * driDrawable, |
| int *width, int *height, |
| unsigned int *attachments, int count, |
| int *out_count, void *data); |
| }; |
| struct gbm_dri_bo { |
| struct gbm_drm_bo base; |
| __DRIimage *image; |
| /* Only used for cursors */ |
| uint32_t handle, size; |
| void *map; |
| }; |
| struct gbm_dri_surface { |
| struct gbm_surface base; |
| void *dri_private; |
| }; |
| static inline struct gbm_dri_device * |
| gbm_dri_device(struct gbm_device *gbm) |
| { |
| return (struct gbm_dri_device *) gbm; |
| } |
| static inline struct gbm_dri_bo * |
| gbm_dri_bo(struct gbm_bo *bo) |
| { |
| return (struct gbm_dri_bo *) bo; |
| } |
| static inline struct gbm_dri_surface * |
| gbm_dri_surface(struct gbm_surface *surface) |
| { |
| return (struct gbm_dri_surface *) surface; |
| } |
| char * |
| dri_fd_get_driver_name(int fd); |
| #endif |