X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=drv.c;h=3ccf16e5758da037b7c03e9b8ed4f58c57ddc5c1;hb=d9354b69f2bb88e4117872c1a17bb7f1db8f7e37;hp=a9ede864328e001e0c398b173cf4e1f2e6f41e1a;hpb=3f25951570d82dc940f63cae34b48d13490c55c0;p=android-x86%2Fexternal-minigbm.git

diff --git a/drv.c b/drv.c
index a9ede86..3ccf16e 100644
--- a/drv.c
+++ b/drv.c
@@ -12,6 +12,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
+#include <sys/types.h>
+#include <unistd.h>
 #include <xf86drm.h>
 
 #include "drv_priv.h"
@@ -136,17 +138,17 @@ struct driver *drv_create(int fd)
 		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)
+	drv->combos.allocations = 2;
+	drv->combos.size = 0;
+
+	drv->combos.data = calloc(drv->combos.allocations, sizeof(struct combination));
+	if (!drv->combos.data)
 		goto free_map_table;
 
 	if (drv->backend->init) {
 		ret = drv->backend->init(drv);
 		if (ret) {
-			free(drv->backend->combos.data);
+			free(drv->combos.data);
 			goto free_map_table;
 		}
 	}
@@ -174,7 +176,7 @@ void drv_destroy(struct driver *drv)
 	drmHashDestroy(drv->buffer_table);
 	drmHashDestroy(drv->map_table);
 
-	free(drv->backend->combos.data);
+	free(drv->combos.data);
 
 	pthread_mutex_unlock(&drv->driver_lock);
 	pthread_mutex_destroy(&drv->driver_lock);
@@ -192,18 +194,18 @@ 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))
+	for (i = 0; i < drv->combos.size; i++) {
+		curr = &drv->combos.data[i];
+		if ((format == curr->format) && use_flags == (curr->use_flags & use_flags))
 			if (!best || best->metadata.priority < curr->metadata.priority)
 				best = curr;
 	}
@@ -211,7 +213,8 @@ struct combination *drv_get_combination(struct driver *drv, uint32_t format, uin
 	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)
 {
 
 	struct bo *bo;
@@ -224,6 +227,7 @@ struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint3
 	bo->width = width;
 	bo->height = height;
 	bo->format = format;
+	bo->use_flags = use_flags;
 	bo->num_planes = drv_num_planes_from_format(format);
 
 	if (!bo->num_planes) {
@@ -235,18 +239,18 @@ struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint3
 }
 
 struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, uint32_t format,
-			 uint64_t flags)
+			 uint64_t use_flags)
 {
 	int ret;
 	size_t plane;
 	struct bo *bo;
 
-	bo = drv_bo_new(drv, width, height, format);
+	bo = drv_bo_new(drv, width, height, format, use_flags);
 
 	if (!bo)
 		return NULL;
 
-	ret = drv->backend->bo_create(bo, width, height, format, flags);
+	ret = drv->backend->bo_create(bo, width, height, format, use_flags);
 
 	if (ret) {
 		free(bo);
@@ -255,8 +259,12 @@ struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, ui
 
 	pthread_mutex_lock(&drv->driver_lock);
 
-	for (plane = 0; plane < bo->num_planes; plane++)
+	for (plane = 0; plane < bo->num_planes; plane++) {
+		if (plane > 0)
+			assert(bo->offsets[plane] >= bo->offsets[plane - 1]);
+
 		drv_increment_reference_count(drv, bo, plane);
+	}
 
 	pthread_mutex_unlock(&drv->driver_lock);
 
@@ -275,7 +283,7 @@ struct bo *drv_bo_create_with_modifiers(struct driver *drv, uint32_t width, uint
 		return NULL;
 	}
 
-	bo = drv_bo_new(drv, width, height, format);
+	bo = drv_bo_new(drv, width, height, format, BO_USE_NONE);
 
 	if (!bo)
 		return NULL;
@@ -289,8 +297,12 @@ struct bo *drv_bo_create_with_modifiers(struct driver *drv, uint32_t width, uint
 
 	pthread_mutex_lock(&drv->driver_lock);
 
-	for (plane = 0; plane < bo->num_planes; plane++)
+	for (plane = 0; plane < bo->num_planes; plane++) {
+		if (plane > 0)
+			assert(bo->offsets[plane] >= bo->offsets[plane - 1]);
+
 		drv_increment_reference_count(drv, bo, plane);
+	}
 
 	pthread_mutex_unlock(&drv->driver_lock);
 
@@ -313,8 +325,10 @@ void drv_bo_destroy(struct bo *bo)
 
 	pthread_mutex_unlock(&drv->driver_lock);
 
-	if (total == 0)
+	if (total == 0) {
+		assert(drv_map_info_destroy(bo) == 0);
 		bo->drv->backend->bo_destroy(bo);
+	}
 
 	free(bo);
 }
@@ -324,8 +338,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);
 
 	if (!bo)
 		return NULL;
@@ -339,40 +354,63 @@ struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data)
 	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];
+
+		seek_end = lseek(data->fds[plane], 0, SEEK_END);
+		if (seek_end == (off_t)(-1)) {
+			fprintf(stderr, "drv: lseek() failed with %s\n", strerror(errno));
+			goto destroy_bo;
+		}
+
+		lseek(data->fds[plane], 0, SEEK_SET);
+		if (plane == bo->num_planes - 1 || data->offsets[plane + 1] == 0)
+			bo->sizes[plane] = seek_end - data->offsets[plane];
+		else
+			bo->sizes[plane] = data->offsets[plane + 1] - data->offsets[plane];
+
+		if ((int64_t)bo->offsets[plane] + bo->sizes[plane] > seek_end) {
+			fprintf(stderr, "drv: buffer size is too large.\n");
+			goto destroy_bo;
+		}
+
+		bo->total_size += bo->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, struct map_info **map_data, size_t plane)
+		 uint32_t map_flags, struct map_info **map_data, size_t plane)
 {
 	void *ptr;
 	uint8_t *addr;
 	size_t offset;
 	struct map_info *data;
-	int prot;
 
 	assert(width > 0);
 	assert(height > 0);
 	assert(x + width <= drv_bo_get_width(bo));
 	assert(y + height <= drv_bo_get_height(bo));
-	assert(BO_TRANSFER_READ_WRITE & flags);
+	assert(BO_MAP_READ_WRITE & map_flags);
+	/* No CPU access for protected buffers. */
+	assert(!(bo->use_flags & BO_USE_PROTECTED));
 
 	pthread_mutex_lock(&bo->drv->driver_lock);
 
 	if (!drmHashLookup(bo->drv->map_table, bo->handles[plane].u32, &ptr)) {
 		data = (struct map_info *)ptr;
+		/* TODO(gsingh): support mapping same buffer with different flags. */
+		assert(data->map_flags == map_flags);
 		data->refcount++;
 		goto success;
 	}
 
 	data = calloc(1, sizeof(*data));
-	prot = BO_TRANSFER_WRITE & flags ? PROT_WRITE | PROT_READ : PROT_READ;
-	addr = bo->drv->backend->bo_map(bo, data, plane, prot);
+	addr = bo->drv->backend->bo_map(bo, data, plane, map_flags);
 	if (addr == MAP_FAILED) {
 		*map_data = NULL;
 		free(data);
@@ -383,9 +421,11 @@ void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t
 	data->refcount = 1;
 	data->addr = addr;
 	data->handle = bo->handles[plane].u32;
+	data->map_flags = map_flags;
 	drmHashInsert(bo->drv->map_table, bo->handles[plane].u32, (void *)data);
 
 success:
+	drv_bo_invalidate(bo, data);
 	*map_data = data;
 	offset = drv_bo_get_plane_stride(bo, plane) * y;
 	offset += drv_stride_from_format(bo->format, x, plane);
@@ -398,18 +438,14 @@ success:
 
 int drv_bo_unmap(struct bo *bo, struct map_info *data)
 {
-	int ret = 0;
-
-	assert(data);
-	assert(data->refcount >= 0);
+	int ret = drv_bo_flush(bo, data);
+	if (ret)
+		return ret;
 
 	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);
+		ret = bo->drv->backend->bo_unmap(bo, data);
 		drmHashDelete(bo->drv->map_table, data->handle);
 		free(data);
 	}
@@ -419,6 +455,31 @@ int drv_bo_unmap(struct bo *bo, struct map_info *data)
 	return ret;
 }
 
+int drv_bo_invalidate(struct bo *bo, struct map_info *data)
+{
+	int ret = 0;
+	assert(data);
+	assert(data->refcount >= 0);
+
+	if (bo->drv->backend->bo_invalidate)
+		ret = bo->drv->backend->bo_invalidate(bo, data);
+
+	return ret;
+}
+
+int drv_bo_flush(struct bo *bo, struct map_info *data)
+{
+	int ret = 0;
+	assert(data);
+	assert(data->refcount >= 0);
+	assert(!(bo->use_flags & BO_USE_PROTECTED));
+
+	if (bo->drv->backend->bo_flush)
+		ret = bo->drv->backend->bo_flush(bo, data);
+
+	return ret;
+}
+
 uint32_t drv_bo_get_width(struct bo *bo)
 {
 	return bo->width;
@@ -488,10 +549,10 @@ uint32_t drv_bo_get_format(struct bo *bo)
 	return bo->format;
 }
 
-uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t usage)
+uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
 	if (drv->backend->resolve_format)
-		return drv->backend->resolve_format(format, usage);
+		return drv->backend->resolve_format(format, use_flags);
 
 	return format;
 }
@@ -559,24 +620,6 @@ size_t drv_num_planes_from_format(uint32_t format)
 	return 0;
 }
 
-uint32_t drv_size_from_format(uint32_t format, uint32_t stride, uint32_t height, size_t plane)
-{
-	assert(plane < drv_num_planes_from_format(format));
-	uint32_t vertical_subsampling;
-
-	switch (format) {
-	case DRM_FORMAT_NV12:
-	case DRM_FORMAT_YVU420:
-	case DRM_FORMAT_YVU420_ANDROID:
-		vertical_subsampling = (plane == 0) ? 1 : 2;
-		break;
-	default:
-		vertical_subsampling = 1;
-	}
-
-	return stride * DIV_ROUND_UP(height, vertical_subsampling);
-}
-
 uint32_t drv_num_buffers_per_bo(struct bo *bo)
 {
 	uint32_t count = 0;