X-Git-Url: https://git.libre-soc.org/?p=mesa.git;a=blobdiff_plain;f=src%2Fgbm%2Fbackends%2Fdri%2Fgbm_dri.c;h=8df6a6b64d0b44bf77da468a41b15e0bd0dc3e59;hp=ccc3cc6930f8f4402fd45824b95ae4e02f5733bc;hb=18e2aa063ca8e2aeb22a72253891e6f8f5d0d96b;hpb=6ee082718fca884fbda73001e0ecb32095409549 diff --git a/src/gbm/backends/dri/gbm_dri.c b/src/gbm/backends/dri/gbm_dri.c index ccc3cc6930f..8df6a6b64d0 100644 --- a/src/gbm/backends/dri/gbm_dri.c +++ b/src/gbm/backends/dri/gbm_dri.c @@ -29,14 +29,17 @@ #include #include #include +#include #include #include #include +#include #include #include #include #include +#include #include /* dri_interface needs GL types */ #include @@ -51,6 +54,14 @@ #include "../../../egl/wayland/wayland-drm/wayland-drm.h" #endif +#ifndef DRM_FORMAT_MOD_INVALID +#define DRM_FORMAT_MOD_INVALID ((1ULL<<56) - 1) +#endif + +#ifndef DRM_FORMAT_MOD_LINEAR +#define DRM_FORMAT_MOD_LINEAR 0 +#endif + static __DRIimage * dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data) { @@ -238,11 +249,14 @@ struct dri_extension_match { const char *name; int version; int offset; + int optional; }; 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) }, + { __DRI2_FENCE, 1, offsetof(struct gbm_dri_device, fence), 1 }, + { __DRI2_INTEROP, 1, offsetof(struct gbm_dri_device, interop), 1 }, { NULL, 0, 0 } }; @@ -278,7 +292,7 @@ dri_bind_extensions(struct gbm_dri_device *dri, for (j = 0; matches[j].name; j++) { field = ((char *) dri + matches[j].offset); - if (*(const __DRIextension **) field == NULL) { + if ((*(const __DRIextension **) field == NULL) && !matches[j].optional) { ret = -1; } } @@ -341,6 +355,15 @@ dri_open_driver(struct gbm_dri_device *dri) /* not need continue to loop all paths once the driver is found */ if (dri->driver != NULL) break; + +#ifdef ANDROID + snprintf(path, sizeof path, "%.*s/gallium_dri.so", len, p); + dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); + if (dri->driver == NULL) + sprintf("failed to open %s: %s\n", path, dlerror()); + else + break; +#endif } if (dri->driver == NULL) { @@ -350,8 +373,8 @@ dri_open_driver(struct gbm_dri_device *dri) return NULL; } - if (asprintf(&get_extensions_name, "%s_%s", - __DRI_DRIVER_GET_EXTENSIONS, dri->base.driver_name) != -1) { + get_extensions_name = loader_get_extensions_name(dri->base.driver_name); + if (get_extensions_name) { const __DRIextension **(*get_extensions)(void); get_extensions = dlsym(dri->driver, get_extensions_name); @@ -427,19 +450,19 @@ dri_screen_create_dri2(struct gbm_dri_device *dri, char *driver_name) return ret; }; - dri->extensions = gbm_dri_screen_extensions; + dri->loader_extensions = gbm_dri_screen_extensions; if (dri->dri2 == NULL) return -1; if (dri->dri2->base.version >= 4) { dri->screen = dri->dri2->createNewScreen2(0, dri->base.base.fd, - dri->extensions, + dri->loader_extensions, dri->driver_extensions, &dri->driver_configs, dri); } else { dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd, - dri->extensions, + dri->loader_extensions, &dri->driver_configs, dri); } if (dri->screen == NULL) @@ -477,17 +500,17 @@ dri_screen_create_swrast(struct gbm_dri_device *dri) return ret; } - dri->extensions = gbm_dri_screen_extensions; + dri->loader_extensions = gbm_dri_screen_extensions; if (dri->swrast == NULL) return -1; if (dri->swrast->base.version >= 4) { - dri->screen = dri->swrast->createNewScreen2(0, dri->extensions, + dri->screen = dri->swrast->createNewScreen2(0, dri->loader_extensions, dri->driver_extensions, &dri->driver_configs, dri); } else { - dri->screen = dri->swrast->createNewScreen(0, dri->extensions, + dri->screen = dri->swrast->createNewScreen(0, dri->loader_extensions, &dri->driver_configs, dri); } if (dri->screen == NULL) @@ -504,7 +527,7 @@ dri_screen_create(struct gbm_dri_device *dri) { char *driver_name; - driver_name = loader_get_driver_for_fd(dri->base.base.fd, 0); + driver_name = loader_get_driver_for_fd(dri->base.base.fd); if (!driver_name) return -1; @@ -535,6 +558,7 @@ gbm_dri_is_format_supported(struct gbm_device *gbm, { switch (format) { case GBM_BO_FORMAT_XRGB8888: + case GBM_FORMAT_XBGR8888: case GBM_FORMAT_XRGB8888: break; case GBM_BO_FORMAT_ARGB8888: @@ -578,11 +602,181 @@ gbm_dri_bo_get_fd(struct gbm_bo *_bo) if (bo->image == NULL) return -1; - dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FD, &fd); + if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FD, &fd)) + return -1; return fd; } +static int +get_number_planes(struct gbm_dri_device *dri, __DRIimage *image) +{ + int num_planes = 0; + + /* Dumb buffers are single-plane only. */ + if (!image) + return 1; + + dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_NUM_PLANES, &num_planes); + + if (num_planes <= 0) + num_planes = 1; + + return num_planes; +} + +static int +gbm_dri_bo_get_planes(struct gbm_bo *_bo) +{ + struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); + struct gbm_dri_bo *bo = gbm_dri_bo(_bo); + + return get_number_planes(dri, bo->image); +} + +static union gbm_bo_handle +gbm_dri_bo_get_handle_for_plane(struct gbm_bo *_bo, int plane) +{ + struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); + struct gbm_dri_bo *bo = gbm_dri_bo(_bo); + union gbm_bo_handle ret; + ret.s32 = -1; + + if (!dri->image || dri->image->base.version < 13 || !dri->image->fromPlanar) { + errno = ENOSYS; + return ret; + } + + if (plane >= get_number_planes(dri, bo->image)) { + errno = EINVAL; + return ret; + } + + /* dumb BOs can only utilize non-planar formats */ + if (!bo->image) { + assert(plane == 0); + ret.s32 = bo->handle; + return ret; + } + + __DRIimage *image = dri->image->fromPlanar(bo->image, plane, NULL); + if (image) { + dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_HANDLE, &ret.s32); + dri->image->destroyImage(image); + } else { + assert(plane == 0); + dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, &ret.s32); + } + + return ret; +} + +static uint32_t +gbm_dri_bo_get_stride(struct gbm_bo *_bo, int plane) +{ + struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); + struct gbm_dri_bo *bo = gbm_dri_bo(_bo); + __DRIimage *image; + int stride = 0; + + if (!dri->image || dri->image->base.version < 11 || !dri->image->fromPlanar) { + /* Preserve legacy behavior if plane is 0 */ + if (plane == 0) + return _bo->stride; + + errno = ENOSYS; + return 0; + } + + if (plane >= get_number_planes(dri, bo->image)) { + errno = EINVAL; + return 0; + } + + if (bo->image == NULL) { + assert(plane == 0); + return _bo->stride; + } + + image = dri->image->fromPlanar(bo->image, plane, NULL); + if (image) { + dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &stride); + dri->image->destroyImage(image); + } else { + assert(plane == 0); + dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, &stride); + } + + return (uint32_t)stride; +} + +static uint32_t +gbm_dri_bo_get_offset(struct gbm_bo *_bo, int plane) +{ + struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); + struct gbm_dri_bo *bo = gbm_dri_bo(_bo); + int offset = 0; + + /* These error cases do not actually return an error code, as the user + * will also fail to obtain the handle/FD from the BO. In that case, the + * offset is irrelevant, as they have no buffer to offset into, so + * returning 0 is harmless. + */ + if (!dri->image || dri->image->base.version < 13 || !dri->image->fromPlanar) + return 0; + + if (plane >= get_number_planes(dri, bo->image)) + return 0; + + /* Dumb images have no offset */ + if (bo->image == NULL) { + assert(plane == 0); + return 0; + } + + __DRIimage *image = dri->image->fromPlanar(bo->image, plane, NULL); + if (image) { + dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_OFFSET, &offset); + dri->image->destroyImage(image); + } else { + dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_OFFSET, &offset); + } + + return (uint32_t)offset; +} + +static uint64_t +gbm_dri_bo_get_modifier(struct gbm_bo *_bo) +{ + struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); + struct gbm_dri_bo *bo = gbm_dri_bo(_bo); + + if (!dri->image || dri->image->base.version < 14) { + errno = ENOSYS; + return DRM_FORMAT_MOD_INVALID; + } + + /* Dumb buffers have no modifiers */ + if (!bo->image) + return DRM_FORMAT_MOD_LINEAR; + + uint64_t ret = 0; + int mod; + if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_MODIFIER_UPPER, + &mod)) + return DRM_FORMAT_MOD_INVALID; + + ret = (uint64_t)mod << 32; + + if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_MODIFIER_LOWER, + &mod)) + return DRM_FORMAT_MOD_INVALID; + + ret |= mod; + + return ret; +} + static void gbm_dri_bo_destroy(struct gbm_bo *_bo) { @@ -593,7 +787,7 @@ gbm_dri_bo_destroy(struct gbm_bo *_bo) if (bo->image != NULL) { dri->image->destroyImage(bo->image); } else { - gbm_dri_bo_unmap(bo); + gbm_dri_bo_unmap_dumb(bo); memset(&arg, 0, sizeof(arg)); arg.handle = bo->handle; drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg); @@ -617,6 +811,9 @@ gbm_dri_to_gbm_format(uint32_t dri_format) case __DRI_IMAGE_FORMAT_ARGB8888: ret = GBM_FORMAT_ARGB8888; break; + case __DRI_IMAGE_FORMAT_XBGR8888: + ret = GBM_FORMAT_XBGR8888; + break; case __DRI_IMAGE_FORMAT_ABGR8888: ret = GBM_FORMAT_ABGR8888; break; @@ -677,6 +874,7 @@ gbm_dri_bo_import(struct gbm_device *gbm, gbm_format = GBM_FORMAT_YUYV; break; default: + dri->image->destroyImage(image); return NULL; } break; @@ -697,6 +895,7 @@ gbm_dri_bo_import(struct gbm_device *gbm, gbm_format = gbm_dri_to_gbm_format(dri_format); if (gbm_format == 0) { errno = EINVAL; + dri->image->destroyImage(image); return NULL; } break; @@ -706,14 +905,30 @@ gbm_dri_bo_import(struct gbm_device *gbm, { struct gbm_import_fd_data *fd_data = buffer; int stride = fd_data->stride, offset = 0; + int dri_format; + + switch (fd_data->format) { + case GBM_BO_FORMAT_XRGB8888: + dri_format = GBM_FORMAT_XRGB8888; + break; + case GBM_BO_FORMAT_ARGB8888: + dri_format = GBM_FORMAT_ARGB8888; + break; + default: + dri_format = fd_data->format; + } image = dri->image->createImageFromFds(dri->screen, fd_data->width, fd_data->height, - fd_data->format, + dri_format, &fd_data->fd, 1, &stride, &offset, NULL); + if (image == NULL) { + errno = EINVAL; + return NULL; + } gbm_format = fd_data->format; break; } @@ -725,8 +940,10 @@ gbm_dri_bo_import(struct gbm_device *gbm, bo = calloc(1, sizeof *bo); - if (bo == NULL) + if (bo == NULL) { + dri->image->destroyImage(image); return NULL; + } bo->image = image; @@ -737,6 +954,7 @@ gbm_dri_bo_import(struct gbm_device *gbm, if (dri->image->base.version >= 2 && !dri->image->validateUsage(bo->image, dri_use)) { errno = EINVAL; + dri->image->destroyImage(bo->image); free(bo); return NULL; } @@ -756,6 +974,31 @@ gbm_dri_bo_import(struct gbm_device *gbm, return &bo->base.base; } +static bool +is_planar_format(uint32_t format) +{ + switch (format) { + case GBM_FORMAT_NV12: + case GBM_FORMAT_NV21: + case GBM_FORMAT_NV16: + case GBM_FORMAT_NV61: + case GBM_FORMAT_YUV410: + case GBM_FORMAT_YVU410: + case GBM_FORMAT_YUV411: + case GBM_FORMAT_YVU411: + case GBM_FORMAT_YUV420: + case GBM_FORMAT_YVU420: + case GBM_FORMAT_YUV422: + case GBM_FORMAT_YVU422: + case GBM_FORMAT_YUV444: + case GBM_FORMAT_YVU444: + return true; + default: + return false; + } + +} + static struct gbm_bo * create_dumb(struct gbm_device *gbm, uint32_t width, uint32_t height, @@ -777,6 +1020,11 @@ create_dumb(struct gbm_device *gbm, return NULL; } + if (is_planar_format(format)) { + errno = EINVAL; + return NULL; + } + bo = calloc(1, sizeof *bo); if (bo == NULL) return NULL; @@ -799,7 +1047,7 @@ create_dumb(struct gbm_device *gbm, bo->handle = create_arg.handle; bo->size = create_arg.size; - if (gbm_dri_bo_map(bo) == NULL) + if (gbm_dri_bo_map_dumb(bo) == NULL) goto destroy_dumb; return &bo->base.base; @@ -817,13 +1065,20 @@ free_bo: static struct gbm_bo * gbm_dri_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height, - uint32_t format, uint32_t usage) + uint32_t format, uint32_t usage, + const uint64_t *modifiers, + const unsigned int count) { struct gbm_dri_device *dri = gbm_dri_device(gbm); struct gbm_dri_bo *bo; int dri_format; unsigned dri_use = 0; + /* Callers of this may specify a modifier, or a dri usage, but not both. The + * newer modifier interface deprecates the older usage flags. + */ + assert(!(usage && count)); + if (usage & GBM_BO_USE_WRITE || dri->image == NULL) return create_dumb(gbm, width, height, format, usage); @@ -837,8 +1092,14 @@ gbm_dri_bo_create(struct gbm_device *gbm, bo->base.base.format = format; switch (format) { + case GBM_FORMAT_R8: + dri_format = __DRI_IMAGE_FORMAT_R8; + break; + case GBM_FORMAT_GR88: + dri_format = __DRI_IMAGE_FORMAT_GR88; + break; case GBM_FORMAT_RGB565: - dri_format =__DRI_IMAGE_FORMAT_RGB565; + dri_format = __DRI_IMAGE_FORMAT_RGB565; break; case GBM_FORMAT_XRGB8888: case GBM_BO_FORMAT_XRGB8888: @@ -851,6 +1112,9 @@ gbm_dri_bo_create(struct gbm_device *gbm, case GBM_FORMAT_ABGR8888: dri_format = __DRI_IMAGE_FORMAT_ABGR8888; break; + case GBM_FORMAT_XBGR8888: + dri_format = __DRI_IMAGE_FORMAT_XBGR8888; + break; case GBM_FORMAT_ARGB2101010: dri_format = __DRI_IMAGE_FORMAT_ARGB2101010; break; @@ -872,11 +1136,42 @@ gbm_dri_bo_create(struct gbm_device *gbm, /* 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 (modifiers) { + if (!dri->image || dri->image->base.version < 14 || + !dri->image->createImageWithModifiers) { + fprintf(stderr, "Modifiers specified, but DRI is too old\n"); + errno = ENOSYS; + goto failed; + } + + /* It's acceptable to create an image with INVALID modifier in the list, + * but it cannot be on the only modifier (since it will certainly fail + * later). While we could easily catch this after modifier creation, doing + * the check here is a convenient debug check likely pointing at whatever + * interface the client is using to build its modifier list. + */ + if (count == 1 && modifiers[0] == DRM_FORMAT_MOD_INVALID) { + fprintf(stderr, "Only invalid modifier specified\n"); + errno = EINVAL; + goto failed; + } + + bo->image = + dri->image->createImageWithModifiers(dri->screen, + width, height, + dri_format, + modifiers, count, + bo); + + if (bo->image) { + /* The client passed in a list of invalid modifiers */ + assert(gbm_dri_bo_get_modifier(&bo->base.base) != DRM_FORMAT_MOD_INVALID); + } + } else { + bo->image = dri->image->createImage(dri->screen, width, height, + dri_format, dri_use, bo); + } + if (bo->image == NULL) goto failed; @@ -892,22 +1187,125 @@ failed: return NULL; } +static void * +gbm_dri_bo_map(struct gbm_bo *_bo, + uint32_t x, uint32_t y, + uint32_t width, uint32_t height, + uint32_t flags, uint32_t *stride, void **map_data) +{ + struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); + struct gbm_dri_bo *bo = gbm_dri_bo(_bo); + + /* If it's a dumb buffer, we already have a mapping */ + if (bo->map) { + *map_data = (char *)bo->map + (bo->base.base.stride * y) + (x * 4); + *stride = bo->base.base.stride; + return *map_data; + } + + if (!dri->image || dri->image->base.version < 12 || !dri->image->mapImage) { + errno = ENOSYS; + return NULL; + } + + mtx_lock(&dri->mutex); + if (!dri->context) + dri->context = dri->dri2->createNewContext(dri->screen, NULL, + NULL, NULL); + assert(dri->context); + mtx_unlock(&dri->mutex); + + /* GBM flags and DRI flags are the same, so just pass them on */ + return dri->image->mapImage(dri->context, bo->image, x, y, + width, height, flags, (int *)stride, + map_data); +} + +static void +gbm_dri_bo_unmap(struct gbm_bo *_bo, void *map_data) +{ + struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm); + struct gbm_dri_bo *bo = gbm_dri_bo(_bo); + + /* Check if it's a dumb buffer and check the pointer is in range */ + if (bo->map) { + assert(map_data >= bo->map); + assert(map_data < (bo->map + bo->size)); + return; + } + + if (!dri->context || !dri->image || + dri->image->base.version < 12 || !dri->image->unmapImage) + return; + + dri->image->unmapImage(dri->context, bo->image, map_data); + + /* + * Not all DRI drivers use direct maps. They may queue up DMA operations + * on the mapping context. Since there is no explicit gbm flush + * mechanism, we need to flush here. + */ + if (dri->flush->base.version >= 4) + dri->flush->flush_with_flags(dri->context, NULL, __DRI2_FLUSH_CONTEXT, 0); +} + + static struct gbm_surface * gbm_dri_surface_create(struct gbm_device *gbm, uint32_t width, uint32_t height, - uint32_t format, uint32_t flags) + uint32_t format, uint32_t flags, + const uint64_t *modifiers, const unsigned count) { + struct gbm_dri_device *dri = gbm_dri_device(gbm); struct gbm_dri_surface *surf; + if (modifiers && + (!dri->image || dri->image->base.version < 14 || + !dri->image->createImageWithModifiers)) { + errno = ENOSYS; + return NULL; + } + + /* It's acceptable to create an image with INVALID modifier in the list, + * but it cannot be on the only modifier (since it will certainly fail + * later). While we could easily catch this after modifier creation, doing + * the check here is a convenient debug check likely pointing at whatever + * interface the client is using to build its modifier list. + */ + if (count == 1 && modifiers[0] == DRM_FORMAT_MOD_INVALID) { + fprintf(stderr, "Only invalid modifier specified\n"); + errno = EINVAL; + } + surf = calloc(1, sizeof *surf); - if (surf == NULL) + if (surf == NULL) { + errno = ENOMEM; return NULL; + } surf->base.gbm = gbm; surf->base.width = width; surf->base.height = height; surf->base.format = format; surf->base.flags = flags; + if (!modifiers) { + assert(!count); + return &surf->base; + } + + surf->base.modifiers = calloc(count, sizeof(*modifiers)); + if (count && !surf->base.modifiers) { + errno = ENOMEM; + free(surf); + return NULL; + } + + /* TODO: We are deferring validation of modifiers until the image is actually + * created. This deferred creation can fail due to a modifier-format + * mismatch. The result is the client has a surface but no object to back it. + */ + surf->base.count = count; + memcpy(surf->base.modifiers, modifiers, count * sizeof(*modifiers)); return &surf->base; } @@ -917,6 +1315,7 @@ gbm_dri_surface_destroy(struct gbm_surface *_surf) { struct gbm_dri_surface *surf = gbm_dri_surface(_surf); + free(surf->base.modifiers); free(surf); } @@ -926,6 +1325,9 @@ dri_destroy(struct gbm_device *gbm) struct gbm_dri_device *dri = gbm_dri_device(gbm); unsigned i; + if (dri->context) + dri->core->destroyContext(dri->context); + dri->core->destroyScreen(dri->screen); for (i = 0; dri->driver_configs[i]; i++) free((__DRIconfig *) dri->driver_configs[i]); @@ -949,9 +1351,16 @@ dri_device_create(int fd) 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.bo_map = gbm_dri_bo_map; + dri->base.base.bo_unmap = gbm_dri_bo_unmap; dri->base.base.is_format_supported = gbm_dri_is_format_supported; dri->base.base.bo_write = gbm_dri_bo_write; dri->base.base.bo_get_fd = gbm_dri_bo_get_fd; + dri->base.base.bo_get_planes = gbm_dri_bo_get_planes; + dri->base.base.bo_get_handle = gbm_dri_bo_get_handle_for_plane; + dri->base.base.bo_get_stride = gbm_dri_bo_get_stride; + dri->base.base.bo_get_offset = gbm_dri_bo_get_offset; + dri->base.base.bo_get_modifier = gbm_dri_bo_get_modifier; dri->base.base.bo_destroy = gbm_dri_bo_destroy; dri->base.base.destroy = dri_destroy; dri->base.base.surface_create = gbm_dri_surface_create; @@ -960,6 +1369,8 @@ dri_device_create(int fd) dri->base.type = GBM_DRM_DRIVER_TYPE_DRI; dri->base.base.name = "drm"; + mtx_init(&dri->mutex, mtx_plain); + force_sw = getenv("GBM_ALWAYS_SOFTWARE") != NULL; if (!force_sw) { ret = dri_screen_create(dri);