X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=drv.c;h=8db5a5d7d13d9934cdfb9d692108be77637525a4;hb=bbba9dde65832cf03f1a0e9739e81e8ad689a508;hp=4d6d981b82a07cef6f674d83205c9cedaeb49995;hpb=6b41fb55deae7d8ae00c33f7ce849d6fd6525d77;p=android-x86%2Fexternal-minigbm.git diff --git a/drv.c b/drv.c index 4d6d981..8db5a5d 100644 --- a/drv.c +++ b/drv.c @@ -12,45 +12,61 @@ #include #include #include +#include +#include #include +#ifdef __ANDROID__ +#include +#include +#endif + #include "drv_priv.h" #include "helpers.h" #include "util.h" #ifdef DRV_AMDGPU -extern struct backend backend_amdgpu; +extern const struct backend backend_amdgpu; #endif -extern struct backend backend_cirrus; -extern struct backend backend_evdi; +extern const struct backend backend_evdi; #ifdef DRV_EXYNOS -extern struct backend backend_exynos; +extern const struct backend backend_exynos; #endif -extern struct backend backend_gma500; #ifdef DRV_I915 -extern struct backend backend_i915; +extern const struct backend backend_i915; #endif #ifdef DRV_MARVELL -extern struct backend backend_marvell; +extern const struct backend backend_marvell; #endif #ifdef DRV_MEDIATEK -extern struct backend backend_mediatek; +extern const struct backend backend_mediatek; +#endif +#ifdef DRV_MESON +extern const struct backend backend_meson; +#endif +#ifdef DRV_MSM +extern const struct backend backend_msm; +#endif +extern const struct backend backend_nouveau; +#ifdef DRV_RADEON +extern const struct backend backend_radeon; #endif -extern struct backend backend_nouveau; #ifdef DRV_ROCKCHIP -extern struct backend backend_rockchip; +extern const struct backend backend_rockchip; +#endif +#ifdef DRV_SYNAPTICS +extern const struct backend backend_synaptics; #endif #ifdef DRV_TEGRA -extern struct backend backend_tegra; +extern const struct backend backend_tegra; #endif -extern struct backend backend_udl; +extern const struct backend backend_udl; #ifdef DRV_VC4 -extern struct backend backend_vc4; +extern const struct backend backend_vc4; #endif -extern struct backend backend_vgem; -extern struct backend backend_virtio_gpu; +extern const struct backend backend_virtio_gpu; -static struct backend *drv_get_backend(int fd) +static const struct backend *drv_get_backend(int fd) { drmVersionPtr drm_version; unsigned int i; @@ -60,16 +76,14 @@ static struct backend *drv_get_backend(int fd) if (!drm_version) return NULL; - struct backend *backend_list[] = { + const struct backend *backend_list[] = { #ifdef DRV_AMDGPU &backend_amdgpu, #endif - &backend_cirrus, &backend_evdi, #ifdef DRV_EXYNOS &backend_exynos, #endif - &backend_gma500, #ifdef DRV_I915 &backend_i915, #endif @@ -79,10 +93,22 @@ static struct backend *drv_get_backend(int fd) #ifdef DRV_MEDIATEK &backend_mediatek, #endif +#ifdef DRV_MESON + &backend_meson, +#endif +#ifdef DRV_MSM + &backend_msm, +#endif &backend_nouveau, +#ifdef DRV_RADEON + &backend_radeon, +#endif #ifdef DRV_ROCKCHIP &backend_rockchip, #endif +#ifdef DRV_SYNAPTICS + &backend_synaptics, +#endif #ifdef DRV_TEGRA &backend_tegra, #endif @@ -90,15 +116,24 @@ static struct backend *drv_get_backend(int fd) #ifdef DRV_VC4 &backend_vc4, #endif - &backend_vgem, &backend_virtio_gpu, }; - for(i = 0; i < ARRAY_SIZE(backend_list); i++) - if (!strcmp(drm_version->name, backend_list[i]->name)) { + for (i = 0; i < ARRAY_SIZE(backend_list); i++) { + const struct backend *b = backend_list[i]; + // Exactly one of the main create functions must be defined. + assert((b->bo_create != NULL) ^ (b->bo_create_from_metadata != NULL)); + // Either both or neither must be implemented. + assert((b->bo_compute_metadata != NULL) == (b->bo_create_from_metadata != NULL)); + // Both can't be defined, but it's okay for neither to be (i.e. only bo_create). + assert((b->bo_create_with_modifiers == NULL) || + (b->bo_create_from_metadata == NULL)); + + if (!strcmp(drm_version->name, b->name)) { drmFreeVersion(drm_version); - return backend_list[i]; + return b; } + } drmFreeVersion(drm_version); return NULL; @@ -109,7 +144,7 @@ struct driver *drv_create(int fd) struct driver *drv; int ret; - drv = (struct driver *) calloc(1, sizeof(*drv)); + drv = (struct driver *)calloc(1, sizeof(*drv)); if (!drv) return NULL; @@ -127,30 +162,26 @@ struct driver *drv_create(int fd) if (!drv->buffer_table) goto free_lock; - drv->map_table = drmHashCreate(); - if (!drv->map_table) + drv->mappings = drv_array_init(sizeof(struct mapping)); + if (!drv->mappings) goto free_buffer_table; - /* Start with a power of 2 number of allocations. */ - drv->backend->combos.allocations = 2; - drv->backend->combos.size = 0; - drv->backend->combos.data = calloc(drv->backend->combos.allocations, - sizeof(struct combination)); - if (!drv->backend->combos.data) - goto free_map_table; + drv->combos = drv_array_init(sizeof(struct combination)); + if (!drv->combos) + goto free_mappings; if (drv->backend->init) { ret = drv->backend->init(drv); if (ret) { - free(drv->backend->combos.data); - goto free_map_table; + drv_array_destroy(drv->combos); + goto free_mappings; } } return drv; -free_map_table: - drmHashDestroy(drv->map_table); +free_mappings: + drv_array_destroy(drv->mappings); free_buffer_table: drmHashDestroy(drv->buffer_table); free_lock: @@ -168,9 +199,8 @@ void drv_destroy(struct driver *drv) drv->backend->close(drv); drmHashDestroy(drv->buffer_table); - drmHashDestroy(drv->map_table); - - free(drv->backend->combos.data); + drv_array_destroy(drv->mappings); + drv_array_destroy(drv->combos); pthread_mutex_unlock(&drv->driver_lock); pthread_mutex_destroy(&drv->driver_lock); @@ -183,50 +213,49 @@ int drv_get_fd(struct driver *drv) return drv->fd; } -const char * -drv_get_name(struct driver *drv) +const char *drv_get_name(struct driver *drv) { return drv->backend->name; } -struct combination *drv_get_combination(struct driver *drv, uint32_t format, - uint64_t usage) +struct combination *drv_get_combination(struct driver *drv, uint32_t format, uint64_t use_flags) { struct combination *curr, *best; - if (format == DRM_FORMAT_NONE || usage == BO_USE_NONE) + if (format == DRM_FORMAT_NONE || use_flags == BO_USE_NONE) return 0; best = NULL; uint32_t i; - for (i = 0; i < drv->backend->combos.size; i++) { - curr = &drv->backend->combos.data[i]; - if ((format == curr->format) && usage == (curr->usage & usage)) - if (!best || - best->metadata.priority < curr->metadata.priority) + for (i = 0; i < drv_array_size(drv->combos); i++) { + curr = drv_array_at_idx(drv->combos, i); + if ((format == curr->format) && use_flags == (curr->use_flags & use_flags)) + if (!best || best->metadata.priority < curr->metadata.priority) best = curr; } return best; } -struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, - uint32_t format) +struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint32_t format, + uint64_t use_flags, bool is_test_buffer) { struct bo *bo; - bo = (struct bo *) calloc(1, sizeof(*bo)); + bo = (struct bo *)calloc(1, sizeof(*bo)); if (!bo) return NULL; bo->drv = drv; - bo->width = width; - bo->height = height; - bo->format = format; - bo->num_planes = drv_num_planes_from_format(format); - - if (!bo->num_planes) { + bo->meta.width = width; + bo->meta.height = height; + bo->meta.format = format; + bo->meta.use_flags = use_flags; + bo->meta.num_planes = drv_num_planes_from_format(format); + bo->is_test_buffer = is_test_buffer; + + if (!bo->meta.num_planes) { free(bo); return NULL; } @@ -234,19 +263,31 @@ struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, return bo; } -struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, - uint32_t format, uint64_t flags) +struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, uint32_t format, + uint64_t use_flags) { int ret; size_t plane; struct bo *bo; + bool is_test_alloc; + + is_test_alloc = use_flags & BO_USE_TEST_ALLOC; + use_flags &= ~BO_USE_TEST_ALLOC; - bo = drv_bo_new(drv, width, height, format); + bo = drv_bo_new(drv, width, height, format, use_flags, is_test_alloc); if (!bo) return NULL; - ret = drv->backend->bo_create(bo, width, height, format, flags); + ret = -EINVAL; + if (drv->backend->bo_compute_metadata) { + ret = drv->backend->bo_compute_metadata(bo, width, height, format, use_flags, NULL, + 0); + if (!is_test_alloc && ret == 0) + ret = drv->backend->bo_create_from_metadata(bo); + } else if (!is_test_alloc) { + ret = drv->backend->bo_create(bo, width, height, format, use_flags); + } if (ret) { free(bo); @@ -255,35 +296,45 @@ struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, pthread_mutex_lock(&drv->driver_lock); - for (plane = 0; plane < bo->num_planes; plane++) + for (plane = 0; plane < bo->meta.num_planes; plane++) { + if (plane > 0) + assert(bo->meta.offsets[plane] >= bo->meta.offsets[plane - 1]); + drv_increment_reference_count(drv, bo, plane); + } pthread_mutex_unlock(&drv->driver_lock); return bo; } -struct bo *drv_bo_create_with_modifiers(struct driver *drv, - uint32_t width, uint32_t height, - uint32_t format, - const uint64_t *modifiers, uint32_t count) +struct bo *drv_bo_create_with_modifiers(struct driver *drv, uint32_t width, uint32_t height, + uint32_t format, const uint64_t *modifiers, uint32_t count) { int ret; size_t plane; struct bo *bo; - if (!drv->backend->bo_create_with_modifiers) { + if (!drv->backend->bo_create_with_modifiers && !drv->backend->bo_compute_metadata) { errno = ENOENT; return NULL; } - bo = drv_bo_new(drv, width, height, format); + bo = drv_bo_new(drv, width, height, format, BO_USE_NONE, false); if (!bo) return NULL; - ret = drv->backend->bo_create_with_modifiers(bo, width, height, - format, modifiers, count); + ret = -EINVAL; + if (drv->backend->bo_compute_metadata) { + ret = drv->backend->bo_compute_metadata(bo, width, height, format, BO_USE_NONE, + modifiers, count); + if (ret == 0) + ret = drv->backend->bo_create_from_metadata(bo); + } else { + ret = drv->backend->bo_create_with_modifiers(bo, width, height, format, modifiers, + count); + } if (ret) { free(bo); @@ -292,33 +343,42 @@ struct bo *drv_bo_create_with_modifiers(struct driver *drv, pthread_mutex_lock(&drv->driver_lock); - for (plane = 0; plane < bo->num_planes; plane++) + for (plane = 0; plane < bo->meta.num_planes; plane++) { + if (plane > 0) + assert(bo->meta.offsets[plane] >= bo->meta.offsets[plane - 1]); + drv_increment_reference_count(drv, bo, plane); + } pthread_mutex_unlock(&drv->driver_lock); return bo; } - void drv_bo_destroy(struct bo *bo) { + int ret; size_t plane; uintptr_t total = 0; struct driver *drv = bo->drv; - pthread_mutex_lock(&drv->driver_lock); + if (!bo->is_test_buffer) { + pthread_mutex_lock(&drv->driver_lock); - for (plane = 0; plane < bo->num_planes; plane++) - drv_decrement_reference_count(drv, bo, plane); + for (plane = 0; plane < bo->meta.num_planes; plane++) + drv_decrement_reference_count(drv, bo, plane); - for (plane = 0; plane < bo->num_planes; plane++) - total += drv_get_reference_count(drv, bo, plane); + for (plane = 0; plane < bo->meta.num_planes; plane++) + total += drv_get_reference_count(drv, bo, plane); - pthread_mutex_unlock(&drv->driver_lock); + pthread_mutex_unlock(&drv->driver_lock); - if (total == 0) - bo->drv->backend->bo_destroy(bo); + if (total == 0) { + ret = drv_mapping_destroy(bo); + assert(ret == 0); + bo->drv->backend->bo_destroy(bo); + } + } free(bo); } @@ -328,8 +388,9 @@ struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data) int ret; size_t plane; struct bo *bo; + off_t seek_end; - bo = drv_bo_new(drv, data->width, data->height, data->format); + bo = drv_bo_new(drv, data->width, data->height, data->format, data->use_flags, false); if (!bo) return NULL; @@ -340,106 +401,207 @@ struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data) return NULL; } - for (plane = 0; plane < bo->num_planes; plane++) { - bo->strides[plane] = data->strides[plane]; - bo->offsets[plane] = data->offsets[plane]; - bo->sizes[plane] = data->sizes[plane]; - bo->format_modifiers[plane] = data->format_modifiers[plane]; - bo->total_size += data->sizes[plane]; + for (plane = 0; plane < bo->meta.num_planes; plane++) { + pthread_mutex_lock(&bo->drv->driver_lock); + drv_increment_reference_count(bo->drv, bo, plane); + pthread_mutex_unlock(&bo->drv->driver_lock); + } + + for (plane = 0; plane < bo->meta.num_planes; plane++) { + bo->meta.strides[plane] = data->strides[plane]; + bo->meta.offsets[plane] = data->offsets[plane]; + bo->meta.format_modifiers[plane] = data->format_modifiers[plane]; + + seek_end = lseek(data->fds[plane], 0, SEEK_END); + if (seek_end == (off_t)(-1)) { + drv_log("lseek() failed with %s\n", strerror(errno)); + goto destroy_bo; + } + + lseek(data->fds[plane], 0, SEEK_SET); + if (plane == bo->meta.num_planes - 1 || data->offsets[plane + 1] == 0) + bo->meta.sizes[plane] = seek_end - data->offsets[plane]; + else + bo->meta.sizes[plane] = data->offsets[plane + 1] - data->offsets[plane]; + + if ((int64_t)bo->meta.offsets[plane] + bo->meta.sizes[plane] > seek_end) { + drv_log("buffer size is too large.\n"); + goto destroy_bo; + } + + bo->meta.total_size += bo->meta.sizes[plane]; } return bo; + +destroy_bo: + drv_bo_destroy(bo); + return NULL; } -void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width, - uint32_t height, uint32_t flags, void **map_data, size_t plane) +void *drv_bo_map(struct bo *bo, const struct rectangle *rect, uint32_t map_flags, + struct mapping **map_data, size_t plane) { - void *ptr; + uint32_t i; uint8_t *addr; - size_t offset; - struct map_info *data; + struct mapping mapping = { 0 }; + + assert(rect->width >= 0); + assert(rect->height >= 0); + assert(rect->x + rect->width <= drv_bo_get_width(bo)); + assert(rect->y + rect->height <= drv_bo_get_height(bo)); + assert(BO_MAP_READ_WRITE & map_flags); + /* No CPU access for protected buffers. */ + assert(!(bo->meta.use_flags & BO_USE_PROTECTED)); - assert(width > 0); - assert(height > 0); - assert(x + width <= drv_bo_get_width(bo)); - assert(y + height <= drv_bo_get_height(bo)); + if (bo->is_test_buffer) { + return MAP_FAILED; + } + + mapping.rect = *rect; + mapping.refcount = 1; pthread_mutex_lock(&bo->drv->driver_lock); - if (!drmHashLookup(bo->drv->map_table, bo->handles[plane].u32, &ptr)) { - data = (struct map_info *) ptr; - data->refcount++; + for (i = 0; i < drv_array_size(bo->drv->mappings); i++) { + struct mapping *prior = (struct mapping *)drv_array_at_idx(bo->drv->mappings, i); + if (prior->vma->handle != bo->handles[plane].u32 || + prior->vma->map_flags != map_flags) + continue; + + if (rect->x != prior->rect.x || rect->y != prior->rect.y || + rect->width != prior->rect.width || rect->height != prior->rect.height) + continue; + + prior->refcount++; + *map_data = prior; + goto exact_match; + } + + for (i = 0; i < drv_array_size(bo->drv->mappings); i++) { + struct mapping *prior = (struct mapping *)drv_array_at_idx(bo->drv->mappings, i); + if (prior->vma->handle != bo->handles[plane].u32 || + prior->vma->map_flags != map_flags) + continue; + + prior->vma->refcount++; + mapping.vma = prior->vma; goto success; } - data = calloc(1, sizeof(*data)); - addr = bo->drv->backend->bo_map(bo, data, plane); + mapping.vma = calloc(1, sizeof(*mapping.vma)); + memcpy(mapping.vma->map_strides, bo->meta.strides, sizeof(mapping.vma->map_strides)); + addr = bo->drv->backend->bo_map(bo, mapping.vma, plane, map_flags); if (addr == MAP_FAILED) { *map_data = NULL; - free(data); + free(mapping.vma); pthread_mutex_unlock(&bo->drv->driver_lock); return MAP_FAILED; } - data->refcount = 1; - data->addr = addr; - data->handle = bo->handles[plane].u32; - drmHashInsert(bo->drv->map_table, bo->handles[plane].u32, - (void *) data); + mapping.vma->refcount = 1; + mapping.vma->addr = addr; + mapping.vma->handle = bo->handles[plane].u32; + mapping.vma->map_flags = map_flags; success: - *map_data = (void *) data; - offset = drv_bo_get_plane_stride(bo, plane) * y; - offset += drv_stride_from_format(bo->format, x, plane); - addr = (uint8_t *) data->addr; - addr += drv_bo_get_plane_offset(bo, plane) + offset; + *map_data = drv_array_append(bo->drv->mappings, &mapping); +exact_match: + drv_bo_invalidate(bo, *map_data); + addr = (uint8_t *)((*map_data)->vma->addr); + addr += drv_bo_get_plane_offset(bo, plane); pthread_mutex_unlock(&bo->drv->driver_lock); - - return (void *) addr; + return (void *)addr; } -int drv_bo_unmap(struct bo *bo, void *map_data) +int drv_bo_unmap(struct bo *bo, struct mapping *mapping) { - struct map_info *data = map_data; + uint32_t i; int ret = 0; - assert(data); - assert(data->refcount >= 0); - pthread_mutex_lock(&bo->drv->driver_lock); - if (!--data->refcount) { - if (bo->drv->backend->bo_unmap) - ret = bo->drv->backend->bo_unmap(bo, data); - else - ret = munmap(data->addr, data->length); - drmHashDelete(bo->drv->map_table, data->handle); - free(data); + if (--mapping->refcount) + goto out; + + if (!--mapping->vma->refcount) { + ret = bo->drv->backend->bo_unmap(bo, mapping->vma); + free(mapping->vma); } + for (i = 0; i < drv_array_size(bo->drv->mappings); i++) { + if (mapping == (struct mapping *)drv_array_at_idx(bo->drv->mappings, i)) { + drv_array_remove(bo->drv->mappings, i); + break; + } + } + +out: pthread_mutex_unlock(&bo->drv->driver_lock); + return ret; +} + +int drv_bo_invalidate(struct bo *bo, struct mapping *mapping) +{ + int ret = 0; + + assert(mapping); + assert(mapping->vma); + assert(mapping->refcount > 0); + assert(mapping->vma->refcount > 0); + + if (bo->drv->backend->bo_invalidate) + ret = bo->drv->backend->bo_invalidate(bo, mapping); return ret; } -uint32_t drv_bo_get_width(struct bo *bo) +int drv_bo_flush(struct bo *bo, struct mapping *mapping) { - return bo->width; + int ret = 0; + + assert(mapping); + assert(mapping->vma); + assert(mapping->refcount > 0); + assert(mapping->vma->refcount > 0); + + if (bo->drv->backend->bo_flush) + ret = bo->drv->backend->bo_flush(bo, mapping); + + return ret; } -uint32_t drv_bo_get_height(struct bo *bo) +int drv_bo_flush_or_unmap(struct bo *bo, struct mapping *mapping) +{ + int ret = 0; + + assert(mapping); + assert(mapping->vma); + assert(mapping->refcount > 0); + assert(mapping->vma->refcount > 0); + assert(!(bo->meta.use_flags & BO_USE_PROTECTED)); + + if (bo->drv->backend->bo_flush) + ret = bo->drv->backend->bo_flush(bo, mapping); + else + ret = drv_bo_unmap(bo, mapping); + + return ret; +} + +uint32_t drv_bo_get_width(struct bo *bo) { - return bo->height; + return bo->meta.width; } -uint32_t drv_bo_get_stride_or_tiling(struct bo *bo) +uint32_t drv_bo_get_height(struct bo *bo) { - return bo->tiling ? bo->tiling : drv_bo_get_plane_stride(bo, 0); + return bo->meta.height; } size_t drv_bo_get_num_planes(struct bo *bo) { - return bo->num_planes; + return bo->meta.num_planes; } union bo_handle drv_bo_get_plane_handle(struct bo *bo, size_t plane) @@ -455,154 +617,61 @@ int drv_bo_get_plane_fd(struct bo *bo, size_t plane) { int ret, fd; - assert(plane < bo->num_planes); + assert(plane < bo->meta.num_planes); - ret = drmPrimeHandleToFD(bo->drv->fd, bo->handles[plane].u32, - DRM_CLOEXEC | DRM_RDWR, &fd); + if (bo->is_test_buffer) { + return -EINVAL; + } - return (ret) ? ret : fd; + ret = drmPrimeHandleToFD(bo->drv->fd, bo->handles[plane].u32, DRM_CLOEXEC | DRM_RDWR, &fd); + // Older DRM implementations blocked DRM_RDWR, but gave a read/write mapping anyways + if (ret) + ret = drmPrimeHandleToFD(bo->drv->fd, bo->handles[plane].u32, DRM_CLOEXEC, &fd); + + return (ret) ? ret : fd; } uint32_t drv_bo_get_plane_offset(struct bo *bo, size_t plane) { - assert(plane < bo->num_planes); - return bo->offsets[plane]; + assert(plane < bo->meta.num_planes); + return bo->meta.offsets[plane]; } uint32_t drv_bo_get_plane_size(struct bo *bo, size_t plane) { - assert(plane < bo->num_planes); - return bo->sizes[plane]; + assert(plane < bo->meta.num_planes); + return bo->meta.sizes[plane]; } uint32_t drv_bo_get_plane_stride(struct bo *bo, size_t plane) { - assert(plane < bo->num_planes); - return bo->strides[plane]; + assert(plane < bo->meta.num_planes); + return bo->meta.strides[plane]; } uint64_t drv_bo_get_plane_format_modifier(struct bo *bo, size_t plane) { - assert(plane < bo->num_planes); - return bo->format_modifiers[plane]; + assert(plane < bo->meta.num_planes); + return bo->meta.format_modifiers[plane]; } uint32_t drv_bo_get_format(struct bo *bo) { - return bo->format; -} - -uint32_t drv_resolve_format(struct driver *drv, uint32_t format) -{ - if (drv->backend->resolve_format) - return drv->backend->resolve_format(format); - - return format; -} - -/* - * This function returns the stride for a given format, width and plane. - */ -int drv_stride_from_format(uint32_t format, uint32_t width, size_t plane) -{ - int stride = width * DIV_ROUND_UP(drv_bpp_from_format(format, plane), - 8); - - /* - * Only downsample for certain multiplanar formats which have horizontal - * subsampling for chroma planes. Only formats supported by our drivers - * are listed here -- add more as needed. - */ - if (plane != 0) { - switch (format) { - case DRM_FORMAT_NV12: - case DRM_FORMAT_YVU420: - stride = stride / 2; - break; - } - } - - return stride; + return bo->meta.format; } -size_t drv_num_planes_from_format(uint32_t format) +size_t drv_bo_get_total_size(struct bo *bo) { - switch (format) { - case DRM_FORMAT_ABGR1555: - case DRM_FORMAT_ABGR2101010: - case DRM_FORMAT_ABGR4444: - case DRM_FORMAT_ABGR8888: - case DRM_FORMAT_ARGB1555: - case DRM_FORMAT_ARGB2101010: - case DRM_FORMAT_ARGB4444: - case DRM_FORMAT_ARGB8888: - case DRM_FORMAT_AYUV: - case DRM_FORMAT_BGR233: - case DRM_FORMAT_BGR565: - case DRM_FORMAT_BGR888: - case DRM_FORMAT_BGRA1010102: - case DRM_FORMAT_BGRA4444: - case DRM_FORMAT_BGRA5551: - case DRM_FORMAT_BGRA8888: - case DRM_FORMAT_BGRX1010102: - case DRM_FORMAT_BGRX4444: - case DRM_FORMAT_BGRX5551: - case DRM_FORMAT_BGRX8888: - case DRM_FORMAT_C8: - case DRM_FORMAT_GR88: - case DRM_FORMAT_R8: - case DRM_FORMAT_RG88: - case DRM_FORMAT_RGB332: - case DRM_FORMAT_RGB565: - case DRM_FORMAT_RGB888: - case DRM_FORMAT_RGBA1010102: - case DRM_FORMAT_RGBA4444: - case DRM_FORMAT_RGBA5551: - case DRM_FORMAT_RGBA8888: - case DRM_FORMAT_RGBX1010102: - case DRM_FORMAT_RGBX4444: - case DRM_FORMAT_RGBX5551: - case DRM_FORMAT_RGBX8888: - case DRM_FORMAT_UYVY: - case DRM_FORMAT_VYUY: - case DRM_FORMAT_XBGR1555: - case DRM_FORMAT_XBGR2101010: - case DRM_FORMAT_XBGR4444: - case DRM_FORMAT_XBGR8888: - case DRM_FORMAT_XRGB1555: - case DRM_FORMAT_XRGB2101010: - case DRM_FORMAT_XRGB4444: - case DRM_FORMAT_XRGB8888: - case DRM_FORMAT_YUYV: - case DRM_FORMAT_YVYU: - return 1; - case DRM_FORMAT_NV12: - return 2; - case DRM_FORMAT_YVU420: - return 3; - } - - fprintf(stderr, "drv: UNKNOWN FORMAT %d\n", format); - return 0; + return bo->meta.total_size; } -uint32_t drv_size_from_format(uint32_t format, uint32_t stride, - uint32_t height, size_t plane) +uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags) { - assert(plane < drv_num_planes_from_format(format)); - uint32_t vertical_subsampling; - - switch (format) { - case DRM_FORMAT_NV12: - case DRM_FORMAT_YVU420: - vertical_subsampling = (plane == 0) ? 1 : 2; - break; - default: - vertical_subsampling = 1; - } + if (drv->backend->resolve_format) + return drv->backend->resolve_format(drv, format, use_flags); - return stride * DIV_ROUND_UP(height, vertical_subsampling); + return format; } uint32_t drv_num_buffers_per_bo(struct bo *bo) @@ -610,7 +679,11 @@ uint32_t drv_num_buffers_per_bo(struct bo *bo) uint32_t count = 0; size_t plane, p; - for (plane = 0; plane < bo->num_planes; plane++) { + if (bo->is_test_buffer) { + return 0; + } + + for (plane = 0; plane < bo->meta.num_planes; plane++) { for (p = 0; p < plane; p++) if (bo->handles[p].u32 == bo->handles[plane].u32) break; @@ -620,3 +693,33 @@ uint32_t drv_num_buffers_per_bo(struct bo *bo) return count; } + +void drv_log_prefix(const char *prefix, const char *file, int line, const char *format, ...) +{ + char buf[50]; + snprintf(buf, sizeof(buf), "[%s:%s(%d)]", prefix, basename(file), line); + + va_list args; + va_start(args, format); +#ifdef __ANDROID__ + __android_log_vprint(ANDROID_LOG_ERROR, buf, format, args); +#else + fprintf(stderr, "%s ", buf); + vfprintf(stderr, format, args); +#endif + va_end(args); +} + +int drv_resource_info(struct bo *bo, uint32_t strides[DRV_MAX_PLANES], + uint32_t offsets[DRV_MAX_PLANES]) +{ + for (uint32_t plane = 0; plane < bo->meta.num_planes; plane++) { + strides[plane] = bo->meta.strides[plane]; + offsets[plane] = bo->meta.offsets[plane]; + } + + if (bo->drv->backend->resource_info) + return bo->drv->backend->resource_info(bo, strides, offsets); + + return 0; +}