Commit: 3f7e566fd8abc0e1a90280bc7def2732abe2f41f - external-gbm_gralloc (git)

external/gbm_gralloc

Commit MetaInfo

• Revision: 3f7e566fd8abc0e1a90280bc7def2732abe2f41f (tree)
• Zeit: 2017-10-05 15:57:42
• Autor: Chih-Wei Huang <cwhuang@linu...>
• Commiter: Chih-Wei Huang

Log Message

Merge remote-tracking branch 'origin/master' into nougat-x86

Ändern Zusammenfassung

• modified: Android.mk
• add: CleanSpec.mk
• modified: gralloc.cpp
• modified: gralloc_drm_handle.h
• modified: gralloc_gbm.cpp
• modified: gralloc_gbm_priv.h

Diff

--- a/Android.mk
+++ b/Android.mk
@@ -37,4 +37,6 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := \
 LOCAL_MODULE := gralloc.gbm
 LOCAL_MODULE_TAGS := optional
 LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
+
 include $(BUILD_SHARED_LIBRARY)

--- /dev/null
+++ b/CleanSpec.mk
@@ -0,0 +1,2 @@
+$(call add-clean-step, rm -f $(PRODUCT_OUT)/system/lib*/libgralloc_drm.so)
+$(call add-clean-step, rm -f $(PRODUCT_OUT)/system/lib*/hw/gralloc.gbm.so)

--- a/gralloc.cpp
+++ b/gralloc.cpp
@@ -37,6 +37,7 @@
 
 #include "gralloc_drm.h"
 #include "gralloc_gbm_priv.h"
+#include "gralloc_drm_handle.h"
 
 struct gbm_module_t {
 	gralloc_module_t base;
@@ -163,21 +164,13 @@ static int gbm_mod_lock(const gralloc_module_t *mod, buffer_handle_t handle,
 		int usage, int x, int y, int w, int h, void **ptr)
 {
 	struct gbm_module_t *dmod = (struct gbm_module_t *) mod;
-	struct gralloc_gbm_bo_t *bo;
 	int err;
 
 	pthread_mutex_lock(&dmod->mutex);
 
-	bo = gralloc_gbm_bo_from_handle(handle);
-	if (!bo) {
-		err = -EINVAL;
-		goto unlock;
-	}
-
-	err = gralloc_gbm_bo_lock(bo, usage, x, y, w, h, ptr);
+	err = gralloc_gbm_bo_lock(handle, usage, x, y, w, h, ptr);
 	ALOGV("buffer %p lock usage = %08x", handle, usage);
 
-unlock:
 	pthread_mutex_unlock(&dmod->mutex);
 	return err;
 }
@@ -185,21 +178,12 @@ unlock:
 static int gbm_mod_unlock(const gralloc_module_t *mod, buffer_handle_t handle)
 {
 	struct gbm_module_t *dmod = (struct gbm_module_t *) mod;
-	struct gralloc_gbm_bo_t *bo;
-	int err = 0;
+	int err;
 
 	pthread_mutex_lock(&dmod->mutex);
-
-	bo = gralloc_gbm_bo_from_handle(handle);
-	if (!bo) {
-		err = -EINVAL;
-		goto unlock;
-	}
-
-	gralloc_gbm_bo_unlock(bo);
-
-unlock:
+	err = gralloc_gbm_bo_unlock(handle);
 	pthread_mutex_unlock(&dmod->mutex);
+
 	return err;
 }
 
@@ -217,22 +201,14 @@ static int gbm_mod_close_gpu0(struct hw_device_t *dev)
 static int gbm_mod_free_gpu0(alloc_device_t *dev, buffer_handle_t handle)
 {
 	struct gbm_module_t *dmod = (struct gbm_module_t *) dev->common.module;
-	struct gralloc_gbm_bo_t *bo;
-	int err = 0;
 
 	pthread_mutex_lock(&dmod->mutex);
+	gbm_free(handle);
+	native_handle_close(handle);
+	delete handle;
 
-	bo = gralloc_gbm_bo_from_handle(handle);
-	if (!bo) {
-		err = -EINVAL;
-		goto unlock;
-	}
-
-	gralloc_gbm_bo_decref(bo);
-
-unlock:
 	pthread_mutex_unlock(&dmod->mutex);
-	return err;
+	return 0;
 }
 
 static int gbm_mod_alloc_gpu0(alloc_device_t *dev,
@@ -240,21 +216,20 @@ static int gbm_mod_alloc_gpu0(alloc_device_t *dev,
 		buffer_handle_t *handle, int *stride)
 {
 	struct gbm_module_t *dmod = (struct gbm_module_t *) dev->common.module;
-	struct gralloc_gbm_bo_t *bo;
+	struct gralloc_gbm_handle_t *gbm_handle;
 	int err = 0;
 
 	pthread_mutex_lock(&dmod->mutex);
 
-	bo = gralloc_gbm_bo_create(dmod->gbm, w, h, format, usage);
-	if (!bo) {
+	gbm_handle = gralloc_gbm_bo_create(dmod->gbm, w, h, format, usage);
+	if (!gbm_handle) {
 		err = -errno;
 		goto unlock;
 	}
 
-	*handle = gralloc_gbm_bo_get_handle(bo);
+	*handle = &gbm_handle->base;
 	/* in pixels */
-	*stride = gbm_bo_get_stride(gralloc_gbm_bo_to_gbm_bo(bo)) /
-		gralloc_gbm_get_bpp(format);
+	*stride = gbm_handle->stride / gralloc_gbm_get_bpp(format);
 
 	ALOGV("buffer %p usage = %08x", *handle, usage);
 unlock:

--- a/gralloc_drm_handle.h
+++ b/gralloc_drm_handle.h
@@ -49,9 +49,9 @@ struct gralloc_drm_handle_t {
 
 	int name;   /* the name of the bo */
 	int stride; /* the stride in bytes */
-	uint64_t modifier; /* buffer modifiers */
-
 	int data_owner; /* owner of data (for validation) */
+
+	uint64_t modifier __attribute__((aligned(8))); /* buffer modifiers */
 	union {
 		void *data; /* pointer to struct gralloc_gbm_bo_t */
 		uint64_t reserved;

--- a/gralloc_gbm.cpp
+++ b/gralloc_gbm.cpp
@@ -46,21 +46,24 @@
 
 #define unlikely(x) __builtin_expect(!!(x), 0)
 
-struct gralloc_gbm_bo_t {
-	struct gbm_bo *bo;
+struct bo_data_t {
 	void *map_data;
-
-	struct gralloc_gbm_handle_t *handle;
-
-	int imported;  /* the handle is from a remote proces when true */
-
 	int lock_count;
 	int locked_for;
-
-	unsigned int refcount;
 };
 
-static int32_t gralloc_gbm_pid = 0;
+void gralloc_gbm_destroy_user_data(struct gbm_bo *bo, void *data)
+{
+	struct bo_data_t *bo_data = (struct bo_data_t *)data;
+	delete bo_data;
+
+	(void)bo;
+}
+
+static struct bo_data_t *gbm_bo_data(struct gbm_bo *bo) {
+	return (struct bo_data_t *)gbm_bo_get_user_data(bo);
+}
+
 
 static uint32_t get_gbm_format(int format)
 {
@@ -112,10 +115,10 @@ static unsigned int get_pipe_bind(int usage)
 	return bind;
 }
 
-static struct gralloc_gbm_bo_t *gbm_import(struct gbm_device *gbm,
+static struct gbm_bo *gbm_import(struct gbm_device *gbm,
 		struct gralloc_gbm_handle_t *handle)
 {
-	struct gralloc_gbm_bo_t *buf;
+	struct gbm_bo *bo;
 	#ifdef GBM_BO_IMPORT_FD_MODIFIER
 	struct gbm_import_fd_modifier_data data;
 	#else
@@ -126,12 +129,6 @@ static struct gralloc_gbm_bo_t *gbm_import(struct gbm_device *gbm,
 	if (handle->prime_fd < 0)
 		return NULL;
 
-	buf = new struct gralloc_gbm_bo_t();
-	if (!buf) {
-		ALOGE("failed to allocate pipe buffer");
-		return NULL;
-	}
-
 	memset(&data, 0, sizeof(data));
 	data.width = handle->width;
 	data.height = handle->height;
@@ -147,33 +144,24 @@ static struct gralloc_gbm_bo_t *gbm_import(struct gbm_device *gbm,
 	data.fds[0] = handle->prime_fd;
 	data.strides[0] = handle->stride;
 	data.modifier = handle->modifier;
-	buf->bo = gbm_bo_import(gbm, GBM_BO_IMPORT_FD_MODIFIER, &data, 0);
+	bo = gbm_bo_import(gbm, GBM_BO_IMPORT_FD_MODIFIER, &data, 0);
 	#else
 	data.fd = handle->prime_fd;
 	data.stride = handle->stride;
-	buf->bo = gbm_bo_import(gbm, GBM_BO_IMPORT_FD, &data, 0);
+	bo = gbm_bo_import(gbm, GBM_BO_IMPORT_FD, &data, 0);
 	#endif
-	if (!buf->bo) {
-		delete buf;
-		return NULL;
-	}
-	return buf;
+
+	return bo;
 }
 
-static struct gralloc_gbm_bo_t *gbm_alloc(struct gbm_device *gbm,
+static struct gbm_bo *gbm_alloc(struct gbm_device *gbm,
 		struct gralloc_gbm_handle_t *handle)
 {
-	struct gralloc_gbm_bo_t *buf;
+	struct gbm_bo *bo;
 	int format = get_gbm_format(handle->format);
 	int usage = get_pipe_bind(handle->usage);
 	int width, height;
 
-	buf = new struct gralloc_gbm_bo_t();
-	if (!buf) {
-		ALOGE("failed to allocate pipe buffer");
-		return NULL;
-	}
-
 	width = handle->width;
 	height = handle->height;
 	if (usage & GBM_BO_USE_CURSOR) {
@@ -194,47 +182,67 @@ static struct gralloc_gbm_bo_t *gbm_alloc(struct gbm_device *gbm,
 
 	ALOGV("create BO, size=%dx%d, fmt=%d, usage=%x",
 	      handle->width, handle->height, handle->format, usage);
-	buf->bo = gbm_bo_create(gbm, width, height, format, usage);
-	if (!buf->bo) {
+	bo = gbm_bo_create(gbm, width, height, format, usage);
+	if (!bo) {
 		ALOGE("failed to create BO, size=%dx%d, fmt=%d, usage=%x",
 		      handle->width, handle->height, handle->format, usage);
-		delete buf;
 		return NULL;
 	}
 
-	handle->prime_fd = gbm_bo_get_fd(buf->bo);
-	handle->stride = gbm_bo_get_stride(buf->bo);
+	handle->prime_fd = gbm_bo_get_fd(bo);
+	handle->stride = gbm_bo_get_stride(bo);
 	#ifdef GBM_BO_IMPORT_FD_MODIFIER
-	handle->modifier = gbm_bo_get_modifier(buf->bo);
+	handle->modifier = gbm_bo_get_modifier(bo);
 	#endif
 
-	return buf;
+	return bo;
 }
 
-static void gbm_free(struct gralloc_gbm_bo_t *bo)
+void gbm_free(buffer_handle_t handle)
 {
-	struct gralloc_gbm_handle_t *handle = bo->handle;
+	struct gbm_bo *bo = gralloc_gbm_bo_from_handle(handle);
 
-	close(handle->prime_fd);
-	handle->prime_fd = -1;
+	if (!bo)
+		return;
 
-	gbm_bo_destroy(bo->bo);
-	delete bo;
+	gbm_bo_destroy(bo);
 }
 
-static int gbm_map(struct gralloc_gbm_bo_t *bo, int x, int y, int w, int h,
+/*
+ * Return the bo of a registered handle.
+ */
+struct gbm_bo *gralloc_gbm_bo_from_handle(buffer_handle_t handle)
+{
+	int pid = getpid();
+	struct gralloc_gbm_handle_t *gbm_handle = gralloc_gbm_handle(handle);
+
+	if (!gbm_handle)
+		return NULL;
+
+	/* the buffer handle is passed to a new process */
+	ALOGV("data_owner=%d gralloc_pid=%d data=%p\n", gbm_handle->data_owner, pid, gbm_handle->data);
+	if (gbm_handle->data_owner == pid)
+		return (struct gbm_bo *)gbm_handle->data;
+
+	return NULL;
+}
+
+static int gbm_map(buffer_handle_t handle, int x, int y, int w, int h,
 		int enable_write, void **addr)
 {
 	int err = 0;
 	int flags = GBM_BO_TRANSFER_READ;
+	struct gralloc_gbm_handle_t *gbm_handle = gralloc_gbm_handle(handle);
+	struct gbm_bo *bo = gralloc_gbm_bo_from_handle(handle);
+	struct bo_data_t *bo_data = gbm_bo_data(bo);
 	uint32_t stride;
 
-	if (bo->map_data)
+	if (bo_data->map_data)
 		return -EINVAL;
 
-	if (bo->handle->format == HAL_PIXEL_FORMAT_YV12) {
+	if (gbm_handle->format == HAL_PIXEL_FORMAT_YV12) {
 		if (x || y)
-			ALOGE("can't map with offset for planar %p - fmt %x", bo, bo->handle->format);
+			ALOGE("can't map with offset for planar %p - fmt %x", bo, gbm_handle->format);
 		w /= 2;
 		h += h / 2;
 	}
@@ -242,7 +250,7 @@ static int gbm_map(struct gralloc_gbm_bo_t *bo, int x, int y, int w, int h,
 	if (enable_write)
 		flags |= GBM_BO_TRANSFER_WRITE;
 
-	*addr = gbm_bo_map(bo->bo, 0, 0, x + w, y + h, flags, &stride, &bo->map_data);
+	*addr = gbm_bo_map(bo, 0, 0, x + w, y + h, flags, &stride, &bo_data->map_data);
 	ALOGV("mapped bo %p (%d, %d)-(%d, %d) at %p", bo, x, y, w, h, *addr);
 	if (*addr == NULL)
 		return -ENOMEM;
@@ -252,10 +260,12 @@ static int gbm_map(struct gralloc_gbm_bo_t *bo, int x, int y, int w, int h,
 	return err;
 }
 
-static void gbm_unmap(struct gralloc_gbm_bo_t *bo)
+static void gbm_unmap(struct gbm_bo *bo)
 {
-	gbm_bo_unmap(bo->bo, bo->map_data);
-	bo->map_data = NULL;
+	struct bo_data_t *bo_data = gbm_bo_data(bo);
+
+	gbm_bo_unmap(bo, bo_data->map_data);
+	bo_data->map_data = NULL;
 }
 
 void gbm_dev_destroy(struct gbm_device *gbm)
@@ -289,58 +299,24 @@ struct gbm_device *gbm_dev_create(void)
 }
 
 /*
- * Return the pid of the process.
- */
-static int gralloc_gbm_get_pid(void)
-{
-	if (unlikely(!gralloc_gbm_pid))
-		android_atomic_write((int32_t) getpid(), &gralloc_gbm_pid);
-
-	return gralloc_gbm_pid;
-}
-
-/*
- * Validate a buffer handle and return the associated bo.
+ * Register a buffer handle.
  */
-static struct gralloc_gbm_bo_t *validate_handle(buffer_handle_t _handle,
-		struct gbm_device *gbm)
+int gralloc_gbm_handle_register(buffer_handle_t _handle, struct gbm_device *gbm)
 {
-	struct gralloc_gbm_bo_t *bo;
+	struct gbm_bo *bo;
 	struct gralloc_gbm_handle_t *handle = gralloc_gbm_handle(_handle);
 
 	if (!handle)
-		return NULL;
-
-	/* the buffer handle is passed to a new process */
-	//ALOGE("data_owner=%d gralloc_pid=%d data=%p\n", handle->data_owner, gralloc_gbm_get_pid(), handle->data);
-	if (handle->data_owner == gralloc_gbm_get_pid())
-		return (struct gralloc_gbm_bo_t *)handle->data;
-
-	/* check only */
-	if (!gbm)
-		return NULL;
-
-	ALOGV("handle: pfd=%d\n", handle->prime_fd);
+		return -EINVAL;
 
 	bo = gbm_import(gbm, handle);
-	if (bo) {
-		bo->imported = 1;
-		bo->handle = handle;
-		bo->refcount = 1;
-	}
+	if (!bo)
+		return -EINVAL;
 
-	handle->data_owner = gralloc_gbm_get_pid();
+	handle->data_owner = getpid();
 	handle->data = bo;
 
-	return bo;
-}
-
-/*
- * Register a buffer handle.
- */
-int gralloc_gbm_handle_register(buffer_handle_t handle, struct gbm_device *gbm)
-{
-	return (validate_handle(handle, gbm)) ? 0 : -EINVAL;
+	return 0;
 }
 
 /*
@@ -348,14 +324,11 @@ int gralloc_gbm_handle_register(buffer_handle_t handle, struct gbm_device *gbm)
  */
 int gralloc_gbm_handle_unregister(buffer_handle_t handle)
 {
-	struct gralloc_gbm_bo_t *bo;
+	struct gralloc_gbm_handle_t *gbm_handle = gralloc_gbm_handle(handle);
 
-	bo = validate_handle(handle, NULL);
-	if (!bo)
-		return -EINVAL;
-
-	if (bo->imported)
-		gralloc_gbm_bo_decref(bo);
+	gbm_free(handle);
+	gbm_handle->data_owner = 0;
+	gbm_handle->data = NULL;
 
 	return 0;
 }
@@ -389,10 +362,10 @@ static struct gralloc_gbm_handle_t *create_bo_handle(int width,
 /*
  * Create a bo.
  */
-struct gralloc_gbm_bo_t *gralloc_gbm_bo_create(struct gbm_device *gbm,
+struct gralloc_gbm_handle_t *gralloc_gbm_bo_create(struct gbm_device *gbm,
 		int width, int height, int format, int usage)
 {
-	struct gralloc_gbm_bo_t *bo;
+	struct gbm_bo *bo;
 	struct gralloc_gbm_handle_t *handle;
 
 	handle = create_bo_handle(width, height, format, usage);
@@ -405,101 +378,57 @@ struct gralloc_gbm_bo_t *gralloc_gbm_bo_create(struct gbm_device *gbm,
 		return NULL;
 	}
 
-	bo->imported = 0;
-	bo->handle = handle;
-	bo->refcount = 1;
-
-	handle->data_owner = gralloc_gbm_get_pid();
+	handle->data_owner = getpid();
 	handle->data = bo;
 
-	return bo;
-}
-
-/*
- * Destroy a bo.
- */
-static void gralloc_gbm_bo_destroy(struct gralloc_gbm_bo_t *bo)
-{
-	struct gralloc_gbm_handle_t *handle = bo->handle;
-	int imported = bo->imported;
-
-	/* gralloc still has a reference */
-	if (bo->refcount)
-		return;
-
-	gbm_free(bo);
-	if (imported) {
-		handle->data_owner = 0;
-		handle->data = 0;
-	}
-	else {
-		delete handle;
-	}
-}
-
-/*
- * Decrease refcount, if no refs anymore then destroy.
- */
-void gralloc_gbm_bo_decref(struct gralloc_gbm_bo_t *bo)
-{
-	if (!--bo->refcount)
-		gralloc_gbm_bo_destroy(bo);
-}
-
-/*
- * Return the bo of a registered handle.
- */
-struct gralloc_gbm_bo_t *gralloc_gbm_bo_from_handle(buffer_handle_t handle)
-{
-	return validate_handle(handle, NULL);
-}
-
-/*
- * Get the buffer handle and stride of a bo.
- */
-buffer_handle_t gralloc_gbm_bo_get_handle(struct gralloc_gbm_bo_t *bo)
-{
-	return &bo->handle->base;
-}
-
-/*
- * Get the buffer handle and stride of a bo.
- */
-struct gbm_bo *gralloc_gbm_bo_to_gbm_bo(struct gralloc_gbm_bo_t *_bo)
-{
-	return _bo->bo;
+	return handle;
 }
 
 /*
  * Lock a bo.  XXX thread-safety?
  */
-int gralloc_gbm_bo_lock(struct gralloc_gbm_bo_t *bo,
+int gralloc_gbm_bo_lock(buffer_handle_t handle,
 		int usage, int x, int y, int w, int h,
 		void **addr)
 {
-	if ((bo->handle->usage & usage) != usage) {
+	struct gralloc_gbm_handle_t *gbm_handle = gralloc_gbm_handle(handle);
+	struct gbm_bo *bo = gralloc_gbm_bo_from_handle(handle);
+	struct bo_data_t *bo_data;
+
+	if (!bo)
+		return -EINVAL;
+
+	if ((gbm_handle->usage & usage) != usage) {
 		/* make FB special for testing software renderer with */
 
-		if (!(bo->handle->usage & GRALLOC_USAGE_SW_READ_OFTEN) &&
-				!(bo->handle->usage & GRALLOC_USAGE_HW_FB) &&
-				!(bo->handle->usage & GRALLOC_USAGE_HW_TEXTURE)) {
+		if (!(gbm_handle->usage & GRALLOC_USAGE_SW_READ_OFTEN) &&
+				!(gbm_handle->usage & GRALLOC_USAGE_HW_FB) &&
+				!(gbm_handle->usage & GRALLOC_USAGE_HW_TEXTURE)) {
 			ALOGE("bo.usage:x%X/usage:x%X is not GRALLOC_USAGE_HW_FB or GRALLOC_USAGE_HW_TEXTURE",
-				bo->handle->usage, usage);
+				gbm_handle->usage, usage);
 			return -EINVAL;
 		}
 	}
 
+	bo_data = gbm_bo_data(bo);
+	if (!bo_data) {
+		bo_data = new struct bo_data_t();
+		gbm_bo_set_user_data(bo, bo_data, gralloc_gbm_destroy_user_data);
+	}
+
+	ALOGI("lock bo %p, cnt=%d, usage=%x", bo, bo_data->lock_count, usage);
+
 	/* allow multiple locks with compatible usages */
-	if (bo->lock_count && (bo->locked_for & usage) != usage)
+	if (bo_data->lock_count && (bo_data->locked_for & usage) != usage)
 		return -EINVAL;
 
-	usage |= bo->locked_for;
+	usage |= bo_data->locked_for;
 
 	if (usage & (GRALLOC_USAGE_SW_WRITE_MASK |
 		     GRALLOC_USAGE_SW_READ_MASK)) {
 		/* the driver is supposed to wait for the bo */
 		int write = !!(usage & GRALLOC_USAGE_SW_WRITE_MASK);
-		int err = gbm_map(bo, x, y, w, h, write, addr);
+		int err = gbm_map(handle, x, y, w, h, write, addr);
 		if (err)
 			return err;
 	}
@@ -507,8 +436,8 @@ int gralloc_gbm_bo_lock(struct gralloc_gbm_bo_t *bo,
 		/* kernel handles the synchronization here */
 	}
 
-	bo->lock_count++;
-	bo->locked_for |= usage;
+	bo_data->lock_count++;
+	bo_data->locked_for |= usage;
 
 	return 0;
 }
@@ -516,18 +445,27 @@ int gralloc_gbm_bo_lock(struct gralloc_gbm_bo_t *bo,
 /*
  * Unlock a bo.
  */
-void gralloc_gbm_bo_unlock(struct gralloc_gbm_bo_t *bo)
+int gralloc_gbm_bo_unlock(buffer_handle_t handle)
 {
-	int mapped = bo->locked_for &
+	struct gbm_bo *bo = gralloc_gbm_bo_from_handle(handle);
+	struct bo_data_t *bo_data;
+	if (!bo)
+		return -EINVAL;
+
+	bo_data = gbm_bo_data(bo);
+
+	int mapped = bo_data->locked_for &
 		(GRALLOC_USAGE_SW_WRITE_MASK | GRALLOC_USAGE_SW_READ_MASK);
 
-	if (!bo->lock_count)
-		return;
+	if (!bo_data->lock_count)
+		return 0;
 
 	if (mapped)
 		gbm_unmap(bo);
 
-	bo->lock_count--;
-	if (!bo->lock_count)
-		bo->locked_for = 0;
+	bo_data->lock_count--;
+	if (!bo_data->lock_count)
+		bo_data->locked_for = 0;
+
+	return 0;
 }

--- a/gralloc_gbm_priv.h
+++ b/gralloc_gbm_priv.h
@@ -30,7 +30,7 @@ extern "C" {
 #endif
 
 struct gbm_device;
-struct gralloc_gbm_bo_t;
+struct gbm_bo;
 
 #define gralloc_gbm_handle_t gralloc_drm_handle_t
 #define gralloc_gbm_handle gralloc_drm_handle
@@ -38,17 +38,16 @@ struct gralloc_gbm_bo_t;
 int gralloc_gbm_handle_register(buffer_handle_t handle, struct gbm_device *gbm);
 int gralloc_gbm_handle_unregister(buffer_handle_t handle);
 
-struct gralloc_gbm_bo_t *gralloc_gbm_bo_create(struct gbm_device *gbm,
+struct gralloc_gbm_handle_t *gralloc_gbm_bo_create(struct gbm_device *gbm,
 		int width, int height, int format, int usage);
-void gralloc_gbm_bo_decref(struct gralloc_gbm_bo_t *bo);
+void gbm_free(buffer_handle_t handle);
 
-struct gralloc_gbm_bo_t *gralloc_gbm_bo_from_handle(buffer_handle_t handle);
-buffer_handle_t gralloc_gbm_bo_get_handle(struct gralloc_gbm_bo_t *bo);
+struct gbm_bo *gralloc_gbm_bo_from_handle(buffer_handle_t handle);
+buffer_handle_t gralloc_gbm_bo_get_handle(struct gbm_bo *bo);
 int gralloc_gbm_get_gem_handle(buffer_handle_t handle);
-struct gbm_bo *gralloc_gbm_bo_to_gbm_bo(struct gralloc_gbm_bo_t *_bo);
 
-int gralloc_gbm_bo_lock(struct gralloc_gbm_bo_t *bo, int x, int y, int w, int h, int enable_write, void **addr);
-void gralloc_gbm_bo_unlock(struct gralloc_gbm_bo_t *bo);
+int gralloc_gbm_bo_lock(buffer_handle_t handle, int x, int y, int w, int h, int enable_write, void **addr);
+int gralloc_gbm_bo_unlock(buffer_handle_t handle);
 
 struct gbm_device *gbm_dev_create(void);
 void gbm_dev_destroy(struct gbm_device *gbm);