adapt hal-api-tbm

libtbm uses hal-api-tbm from Tizen 6.5.
Therefore, libtbm links libhal-api-tbm library and libtbm work with
hal-api-tbm when the hal-backend-tbm backend library at /hal/lib directory.
If not, libtbm works with the legacy tbm backend so file at /usr/lib/bufmgr
directory.

Change-Id: I6428b3cddf8914f38c4b2ca55b5f731440846e2f
Signed-off-by: Junkyeong Kim <jk0430.kim@samsung.com>

diff --git a/configure.ac b/configure.ac
index 9c3ac2f..4016e6c 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -75,6 +75,7 @@ if test x"$capi_0_1_1" = xyes; then
        AC_DEFINE(HAVE_CAPI_0_1_1,1,[The version of capi-base-common is over 0.1.1])
 fi
 
+PKG_CHECK_MODULES(HAL_API_TBM, hal-api-tbm)
 PKG_CHECK_MODULES(LIBDRM, libdrm)
 PKG_CHECK_MODULES(WL_CLIENT, wayland-client)
 PKG_CHECK_MODULES(WL_SERVER, wayland-server)
@@ -83,10 +84,10 @@ PKG_CHECK_MODULES(LIBPNG, libpng)
 PKG_CHECK_MODULES(LIBPIXMAN, pixman-1)
 PKG_CHECK_MODULES(GMOCK, gmock)
 
-LIBTBM_CFLAGS+="$LIBTBM_CFALGS $LIBDRM_CFLAGS $CAPI_CFLAGS $WL_CLIENT_CFLAGS $WL_SERVER_CFLAGS $LIBPNG_CFLAGS $LIBPIXMAN_CFLAGS "
-LIBTBM_LIBS+="$LIBTBM_LIBS $LIBDRM_LIBS $CAPI_LIBS $WL_CLIENT_LIBS $WL_SERVER_LIBS $LIBPNG_LIBS $LIBPIXMAN_LIBS "
+LIBTBM_CFLAGS+="$LIBTBM_CFALGS $HAL_API_TBM_CFLAGS $LIBDRM_CFLAGS $CAPI_CFLAGS $WL_CLIENT_CFLAGS $WL_SERVER_CFLAGS $LIBPNG_CFLAGS $LIBPIXMAN_CFLAGS "
+LIBTBM_LIBS+="$LIBTBM_LIBS $HAL_API_TBM_LIBS $LIBDRM_LIBS $CAPI_LIBS $WL_CLIENT_LIBS $WL_SERVER_LIBS $LIBPNG_LIBS $LIBPIXMAN_LIBS "
 
-LIBTBM_TEST_CFLAGS="$GMOCK_CLAGS"
+LIBTBM_TEST_CFLAGS="$GMOCK_CFLAGS"
 LIBTBM_TEST_LIBS="$GMOCK_LIBS"
 
 PKG_CHECK_EXISTS([dlog], [have_dlog="yes"], [have_dlog="no"])

diff --git a/include/tbm_type_common.h b/include/tbm_type_common.h
old mode 100755 (executable)
new mode 100644 (file)

diff --git a/packaging/libtbm.spec b/packaging/libtbm.spec
index 4f967b8..06506d9 100644 (file)
--- a/packaging/libtbm.spec
+++ b/packaging/libtbm.spec
@@ -27,6 +27,7 @@ BuildRequires:  pkgconfig(libpng)
 BuildRequires:  pkgconfig(dlog)
 BuildRequires:  pkgconfig(pixman-1)
 BuildRequires:  pkgconfig(gmock)
+BuildRequires:  pkgconfig(hal-api-tbm)
 
 %description
 Description: %{summary}

diff --git a/src/tbm_bo.c b/src/tbm_bo.c
index b6d9d2e..35deb2c 100644 (file)
--- a/src/tbm_bo.c
+++ b/src/tbm_bo.c
@@ -155,7 +155,14 @@ _bo_lock(tbm_bo bo, int device, int opt)
        int ret = 1;
        tbm_error_e error;
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               error = (tbm_error_e)hal_tbm_bo_lock((hal_tbm_bo *)bo->bo_data, device, opt);
+               if (error != TBM_ERROR_NONE) {
+                       TBM_WRN("fail to lock");
+                       _tbm_set_last_result(error);
+                       ret = 0;
+               }
+       } else if (bo->bufmgr->backend_module_data) {
                if (bo->bufmgr->bo_func->bo_lock) {
                        error = bo->bufmgr->bo_func->bo_lock(bo->bo_data, device, opt);
                        if (error != TBM_ERROR_NONE) {
@@ -180,7 +187,13 @@ _bo_unlock(tbm_bo bo)
 {
        tbm_error_e error;
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               error = (tbm_error_e)hal_tbm_bo_unlock((hal_tbm_bo *)bo->bo_data);
+               if (error != TBM_ERROR_NONE) {
+                       TBM_WRN("fail to lock");
+                       _tbm_set_last_result(error);
+               }
+       } else if (bo->bufmgr->backend_module_data) {
                if (bo->bufmgr->bo_func->bo_unlock) {
                        error = bo->bufmgr->bo_func->bo_unlock(bo->bo_data);
                        if (error != TBM_ERROR_NONE) {
@@ -346,8 +359,6 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
        bo = calloc(1, sizeof(struct _tbm_bo));
        if (!bo) {
                /* LCOV_EXCL_START */
-               TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n",
-                               size, _tbm_flag_to_str(flags));
                _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
                _tbm_bufmgr_mutex_unlock();
                return NULL;
@@ -356,16 +367,21 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
 
        _tbm_util_check_bo_cnt(bufmgr);
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo(bufmgr->hal_bufmgr, size, flags, (hal_tbm_error *)&error);
+               /* LCOV_EXCL_START */
+               if (!bo_data) {
+                       _tbm_set_last_result(error);
+                       goto alloc_fail;
+               }
+               /* LCOV_EXCL_STOP */
+               bo->bo_data = bo_data;
+       } else if (bufmgr->backend_module_data) {
                bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo(bufmgr->bufmgr_data, (unsigned int)size, flags, &error);
                if (!bo_data) {
                        /* LCOV_EXCL_START */
-                       TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n",
-                                       size, _tbm_flag_to_str(flags));
                        _tbm_set_last_result(error);
-                       free(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return NULL;
+                       goto alloc_fail;
                        /* LCOV_EXCL_STOP */
                }
                bo->bo_data = bo_data;
@@ -373,12 +389,9 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
                bo_priv = bufmgr->backend->bo_alloc(bo, size, flags);
                if (!bo_priv) {
                        /* LCOV_EXCL_START */
-                       TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n",
-                                       size, _tbm_flag_to_str(flags));
+                       
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
-                       free(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return NULL;
+                       goto alloc_fail;
                        /* LCOV_EXCL_STOP */
                }
                bo->priv = bo_priv;
@@ -392,6 +405,12 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
        _tbm_bufmgr_mutex_unlock();
 
        return bo;
+
+alloc_fail:
+       TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n", size, _tbm_flag_to_str(flags));
+       free(bo);
+       _tbm_bufmgr_mutex_unlock();
+       return NULL;
 }
 
 /* LCOV_EXCL_START */
@@ -418,17 +437,24 @@ tbm_bo_alloc_with_format(tbm_bufmgr bufmgr, int format, int bo_idx, int width,
 
        _tbm_util_check_bo_cnt(bufmgr);
 
-       if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format) {
-               /* LCOV_EXCL_START */
-               TBM_ERR("error: not supported tbm_bo_alloc_with_format\n");
-               _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
-               free(bo);
-               _tbm_bufmgr_mutex_unlock();
-               return NULL;
-               /* LCOV_EXCL_STOP */
+       /* LCOV_EXCL_START */
+       if (!bufmgr->use_hal_tbm) {
+               if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format) {
+                       
+                       TBM_ERR("error: not supported tbm_bo_alloc_with_format\n");
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                       free(bo);
+                       _tbm_bufmgr_mutex_unlock();
+                       return NULL;
+               }
        }
+       /* LCOV_EXCL_STOP */
 
-       bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format(bufmgr->bufmgr_data, format, bo_idx,
+       if (bufmgr->use_hal_tbm)
+               bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_format(bufmgr->hal_bufmgr,
+                                                               format, bo_idx, width, height, (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error);
+       else
+               bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format(bufmgr->bufmgr_data, format, bo_idx,
                                                                                                                                width, height, flags, error);
        if (!bo_data) {
                TBM_ERR("error: fail to tbm_bo_alloc_with_format fmt(%s) idx(%d) w(%d) h(%d) mem_types(%s)\n",
@@ -470,15 +496,21 @@ tbm_bo_alloc_with_tiled_format(tbm_bufmgr bufmgr, int width, int height, int bpp
 
        _tbm_util_check_bo_cnt(bufmgr);
 
-       if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format) {
-               TBM_ERR("error: not supported tbm_bo_alloc_with_tiled_format\n");
-               _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
-               free(bo);
-               _tbm_bufmgr_mutex_unlock();
-               return NULL;
+       if (!bufmgr->use_hal_tbm) {
+               if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format) {
+                       TBM_ERR("error: not supported tbm_bo_alloc_with_tiled_format\n");
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                       free(bo);
+                       _tbm_bufmgr_mutex_unlock();
+                       return NULL;
+               }
        }
 
-       bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format(bufmgr->bufmgr_data, width, height,
+       if (bufmgr->use_hal_tbm)
+               bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_tiled_format(bufmgr->hal_bufmgr,
+                                                               width, height, bpp, format, (hal_tbm_bo_memory_type)flags, bo_idx, (hal_tbm_error *)error);
+       else
+               bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format(bufmgr->bufmgr_data, width, height,
                                                                                                                                        bpp, format, flags, bo_idx, error);
        if (!bo_data) {
                TBM_ERR("error: fail to tbm_bo_alloc_with_tiled_format fmt(%s) idx(%d) w(%d) h(%d) flags(%s)\n",
@@ -602,15 +634,24 @@ tbm_bo_map(tbm_bo bo, int device, int opt)
                return (tbm_bo_handle) NULL;
        }
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               hal_tbm_bo_handle hbo_handle;
+               hbo_handle = hal_tbm_bo_map((hal_tbm_bo *)bo->bo_data, device, opt, (hal_tbm_error *)&error);
+               if (hbo_handle.ptr == NULL) {
+                       /* LCOV_EXCL_START */
+                       _tbm_set_last_result(error);
+                       TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, hbo_handle.ptr, error);
+                       goto bo_map_fail;
+                       /* LCOV_EXCL_STOP */
+               }
+               memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
+       } else if (bo->bufmgr->backend_module_data) {
                bo_handle = bo->bufmgr->bo_func->bo_map(bo->bo_data, device, opt, &error);
                if (bo_handle.ptr == NULL) {
                        /* LCOV_EXCL_START */
                        _tbm_set_last_result(error);
                        TBM_ERR("error: fail to map bo:%p error:%d\n", bo, error);
-                       _tbm_bo_unlock(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return (tbm_bo_handle) NULL;
+                       goto bo_map_fail;
                        /* LCOV_EXCL_STOP */
                }
        } else {
@@ -619,9 +660,7 @@ tbm_bo_map(tbm_bo bo, int device, int opt)
                        /* LCOV_EXCL_START */
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
                        TBM_ERR("error: fail to map bo:%p\n", bo);
-                       _tbm_bo_unlock(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return (tbm_bo_handle) NULL;
+                       goto bo_map_fail;
                        /* LCOV_EXCL_STOP */
                }
        }
@@ -634,6 +673,11 @@ tbm_bo_map(tbm_bo bo, int device, int opt)
        _tbm_bufmgr_mutex_unlock();
 
        return bo_handle;
+
+bo_map_fail:
+       _tbm_bo_unlock(bo);
+       _tbm_bufmgr_mutex_unlock();
+       return (tbm_bo_handle) NULL;
 }
 
 int
@@ -648,15 +692,24 @@ tbm_bo_unmap(tbm_bo bo)
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
        TBM_BO_RETURN_VAL_IF_FAIL(bo->map_cnt > 0, 0);
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               error = (hal_tbm_error)hal_tbm_bo_unmap((hal_tbm_bo *)bo->bo_data);
+               if (error != TBM_ERROR_NONE) {
+                       /* LCOV_EXCL_START */
+                       TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error);
+                       _tbm_set_last_result(error);
+                       ret = 0;
+                       goto done;
+                       /* LCOV_EXCL_STOP */
+               }
+       } else if (bo->bufmgr->backend_module_data) {
                error = bo->bufmgr->bo_func->bo_unmap(bo->bo_data);
                if (error != TBM_ERROR_NONE) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error);
                        _tbm_set_last_result(error);
                        ret = 0;
-                       _tbm_bufmgr_mutex_unlock();
-                       return ret;
+                       goto done;
                        /* LCOV_EXCL_STOP */
                }
        } else {
@@ -665,8 +718,7 @@ tbm_bo_unmap(tbm_bo bo)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
-                       _tbm_bufmgr_mutex_unlock();
-                       return ret;
+                       goto done;
                        /* LCOV_EXCL_STOP */
                }
        }
@@ -678,6 +730,7 @@ tbm_bo_unmap(tbm_bo bo)
 
        _tbm_bo_unlock(bo);
 
+done:
        _tbm_bufmgr_mutex_unlock();
 
        return ret;
@@ -694,14 +747,24 @@ tbm_bo_get_handle(tbm_bo bo, int device)
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               hal_tbm_bo_handle hbo_handle;
+               hbo_handle = hal_tbm_bo_get_handle((hal_tbm_bo *)bo->bo_data, device, (hal_tbm_error *)&error);
+               if (hbo_handle.ptr == NULL) {
+                       /* LCOV_EXCL_START */
+                       TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, hbo_handle.ptr, error);
+                       _tbm_set_last_result(error);
+                       goto bo_handle_fail;
+                       /* LCOV_EXCL_STOP */
+               }
+               memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
+       } else if (bo->bufmgr->backend_module_data) {
                bo_handle = bo->bufmgr->bo_func->bo_get_handle(bo->bo_data, device, &error);
                if (bo_handle.ptr == NULL) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, bo_handle.ptr, error);
                        _tbm_set_last_result(error);
-                       _tbm_bufmgr_mutex_unlock();
-                       return (tbm_bo_handle) NULL;
+                       goto bo_handle_fail;
                        /* LCOV_EXCL_STOP */
                }
        } else {
@@ -710,8 +773,7 @@ tbm_bo_get_handle(tbm_bo bo, int device)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr);
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
-                       _tbm_bufmgr_mutex_unlock();
-                       return (tbm_bo_handle) NULL;
+                       goto bo_handle_fail;
                        /* LCOV_EXCL_STOP */
                }
        }
@@ -721,6 +783,10 @@ tbm_bo_get_handle(tbm_bo bo, int device)
        _tbm_bufmgr_mutex_unlock();
 
        return bo_handle;
+
+bo_handle_fail:
+       _tbm_bufmgr_mutex_unlock();
+       return (tbm_bo_handle) NULL;
 }
 
 tbm_key
@@ -734,7 +800,16 @@ tbm_bo_export(tbm_bo bo)
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               ret = (hal_tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
+               if (!ret) {
+                       /* LCOV_EXCL_START */
+                       TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error);
+                       _tbm_set_last_result(error);
+                       goto done;
+                       /* LCOV_EXCL_STOP */
+               }
+       } else if (bo->bufmgr->backend_module_data) {
                if (!bo->bufmgr->bo_func->bo_export_key) {
                        /* LCOV_EXCL_START */
                        _tbm_bufmgr_mutex_unlock();
@@ -748,8 +823,7 @@ tbm_bo_export(tbm_bo bo)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error);
                        _tbm_set_last_result(error);
-                       _tbm_bufmgr_mutex_unlock();
-                       return ret;
+                       goto done;
                        /* LCOV_EXCL_STOP */
                }
        } else {
@@ -766,14 +840,14 @@ tbm_bo_export(tbm_bo bo)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) tbm_key(%d)\n", bo, ret);
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
-                       _tbm_bufmgr_mutex_unlock();
-                       return ret;
+                       goto done;
                        /* LCOV_EXCL_STOP */
                }
        }
 
        TBM_TRACE_BO("bo(%p) tbm_key(%u)\n", bo, ret);
 
+done:
        _tbm_bufmgr_mutex_unlock();
 
        return ret;
@@ -790,7 +864,16 @@ tbm_bo_export_fd(tbm_bo bo)
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), -1);
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               ret = (hal_tbm_fd)hal_tbm_bo_export_fd((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
+               if (ret < 0) {
+                       /* LCOV_EXCL_START */
+                       TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error);
+                       _tbm_set_last_result(error);
+                       goto done;
+                       /* LCOV_EXCL_STOP */
+               }
+       } else if (bo->bufmgr->backend_module_data) {
                if (!bo->bufmgr->bo_func->bo_export_fd) {
                        /* LCOV_EXCL_START */
                        _tbm_bufmgr_mutex_unlock();
@@ -804,8 +887,7 @@ tbm_bo_export_fd(tbm_bo bo)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error);
                        _tbm_set_last_result(error);
-                       _tbm_bufmgr_mutex_unlock();
-                       return ret;
+                       goto done;
                        /* LCOV_EXCL_STOP */
                }
        } else {
@@ -822,14 +904,14 @@ tbm_bo_export_fd(tbm_bo bo)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: bo(%p) tbm_fd(%d)\n", bo, ret);
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
-                       _tbm_bufmgr_mutex_unlock();
-                       return ret;
+                       goto done;
                        /* LCOV_EXCL_STOP */
                }
        }
 
        TBM_TRACE_BO("bo(%p) tbm_fd(%d)\n", bo, ret);
 
+done:
        _tbm_bufmgr_mutex_unlock();
 
        return ret;
@@ -850,21 +932,23 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
 
        TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
 
-       if (bufmgr->backend_module_data) {
-               if (!bufmgr->bufmgr_func->bufmgr_import_key) {
-                       /* LCOV_EXCL_START */
-                       _tbm_bufmgr_mutex_unlock();
-                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
-                       return NULL;
-                       /* LCOV_EXCL_STOP */
-               }
-       } else {
-               if (!bufmgr->backend->bo_import) {
-                       /* LCOV_EXCL_START */
-                       _tbm_bufmgr_mutex_unlock();
-                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
-                       return NULL;
-                       /* LCOV_EXCL_STOP */
+       if (!bufmgr->use_hal_tbm) {
+               if (bufmgr->backend_module_data) {
+                       if (!bufmgr->bufmgr_func->bufmgr_import_key) {
+                               /* LCOV_EXCL_START */
+                               _tbm_bufmgr_mutex_unlock();
+                               _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                               return NULL;
+                               /* LCOV_EXCL_STOP */
+                       }
+               } else {
+                       if (!bufmgr->backend->bo_import) {
+                               /* LCOV_EXCL_START */
+                               _tbm_bufmgr_mutex_unlock();
+                               _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                               return NULL;
+                               /* LCOV_EXCL_STOP */
+                       }
                }
        }
 
@@ -880,15 +964,36 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                /* LCOV_EXCL_STOP */
        }
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_key(bufmgr->hal_bufmgr, key, (hal_tbm_error *)&error);
+               /* LCOV_EXCL_START */
+               if (!bo_data) {
+                       TBM_ERR("error: fail to import of tbm_bo by key(%d). error(%d)\n", key, error);
+                       _tbm_set_last_result(error);
+                       goto import_fail;
+               }
+               /* LCOV_EXCL_STOP */
+               if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
+                       LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
+                               if (bo2->bo_data == bo_data) {
+                                       TBM_TRACE_BO("find bo(%p) ref(%d) key(%d) flag(%s) in list\n",
+                                                       bo2, bo2->ref_cnt, key,
+                                                       _tbm_flag_to_str(bo2->flags));
+                                       bo2->ref_cnt++;
+                                       free(bo);
+                                       _tbm_bufmgr_mutex_unlock();
+                                       return bo2;
+                               }
+                       }
+               }
+               bo->bo_data = bo_data;
+       } else if (bufmgr->backend_module_data) {
                bo_data = bufmgr->bufmgr_func->bufmgr_import_key(bufmgr->bufmgr_data, key, &error);
                if (!bo_data) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import of tbm_bo by key(%d). error(%d)\n", key, error);
                        _tbm_set_last_result(error);
-                       free(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return NULL;
+                       goto import_fail;
                        /* LCOV_EXCL_STOP */
                }
 
@@ -912,9 +1017,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import of tbm_bo by key(%d)\n", key);
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
-                       free(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return NULL;
+                       goto import_fail;
                        /* LCOV_EXCL_STOP */
                }
 
@@ -934,7 +1037,14 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
                bo->priv = bo_priv;
        }
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
+               if (error != TBM_ERROR_NONE) {
+                       TBM_ERR("fail to get the bo flags(memory_types)");
+                       _tbm_set_last_result(error);
+                       flags = TBM_BO_DEFAULT;
+               }
+       } else if (bufmgr->backend_module_data) {
                flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error);
                if (error != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the bo flags(memory_types)");
@@ -956,6 +1066,11 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
        _tbm_bufmgr_mutex_unlock();
 
        return bo;
+
+import_fail:
+       free(bo);
+       _tbm_bufmgr_mutex_unlock();
+       return NULL;
 }
 
 tbm_bo
@@ -973,21 +1088,23 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
 
        TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
 
-       if (bufmgr->backend_module_data) {
-               if (!bufmgr->bufmgr_func->bufmgr_import_fd) {
-                       /* LCOV_EXCL_START */
-                       _tbm_bufmgr_mutex_unlock();
-                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
-                       return NULL;
-                       /* LCOV_EXCL_STOP */
-               }
-       } else {
-               if (!bufmgr->backend->bo_import_fd) {
-                       /* LCOV_EXCL_START */
-                       _tbm_bufmgr_mutex_unlock();
-                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
-                       return NULL;
-                       /* LCOV_EXCL_STOP */
+       if (!bufmgr->use_hal_tbm) {
+               if (bufmgr->backend_module_data) {
+                       if (!bufmgr->bufmgr_func->bufmgr_import_fd) {
+                               /* LCOV_EXCL_START */
+                               _tbm_bufmgr_mutex_unlock();
+                               _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                               return NULL;
+                               /* LCOV_EXCL_STOP */
+                       }
+               } else {
+                       if (!bufmgr->backend->bo_import_fd) {
+                               /* LCOV_EXCL_START */
+                               _tbm_bufmgr_mutex_unlock();
+                               _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                               return NULL;
+                               /* LCOV_EXCL_STOP */
+                       }
                }
        }
 
@@ -1003,15 +1120,36 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                /* LCOV_EXCL_STOP */
        }
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_fd(bufmgr->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)&error);
+               /* LCOV_EXCL_START */
+               if (!bo_data) {
+                       TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d). error(%d)\n", fd, error);
+                       _tbm_set_last_result(error);
+                       goto import_fail;
+               }
+               /* LCOV_EXCL_STOP */
+
+               if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
+                       LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
+                               if (bo2->bo_data == bo_data) {
+                                       TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n",
+                                                       bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags));
+                                       bo2->ref_cnt++;
+                                       free(bo);
+                                       _tbm_bufmgr_mutex_unlock();
+                                       return bo2;
+                               }
+                       }
+               }
+               bo->bo_data = bo_data;
+       } else if (bufmgr->backend_module_data) {
                bo_data = bufmgr->bufmgr_func->bufmgr_import_fd(bufmgr->bufmgr_data, fd, &error);
                if (!bo_data) {
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d). error(%d)\n", fd, error);
                        _tbm_set_last_result(error);
-                       free(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return NULL;
+                       goto import_fail;
                        /* LCOV_EXCL_STOP */
                }
 
@@ -1019,8 +1157,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                        LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
                                if (bo2->bo_data == bo_data) {
                                        TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n",
-                                                       bo2, bo2->ref_cnt, fd,
-                                                       _tbm_flag_to_str(bo2->flags));
+                                                       bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags));
                                        bo2->ref_cnt++;
                                        free(bo);
                                        _tbm_bufmgr_mutex_unlock();
@@ -1035,9 +1172,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                        /* LCOV_EXCL_START */
                        TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d)\n", fd);
                        _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
-                       free(bo);
-                       _tbm_bufmgr_mutex_unlock();
-                       return NULL;
+                       goto import_fail;
                        /* LCOV_EXCL_STOP */
                }
 
@@ -1045,8 +1180,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                        LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
                                if (bo2->priv == bo_priv) {
                                        TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n",
-                                                       bo2, bo2->ref_cnt, fd,
-                                                       _tbm_flag_to_str(bo2->flags));
+                                                       bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags));
                                        bo2->ref_cnt++;
                                        free(bo);
                                        _tbm_bufmgr_mutex_unlock();
@@ -1057,7 +1191,14 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
                bo->priv = bo_priv;
        }
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
+               if (error != TBM_ERROR_NONE) {
+                       TBM_ERR("fail to get the bo flags(memory_types)");
+                       _tbm_set_last_result(error);
+                       flags = TBM_BO_DEFAULT;
+               }
+       } else if (bufmgr->backend_module_data) {
                flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error);
                if (error != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the bo flags(memory_types)");
@@ -1079,6 +1220,11 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
        _tbm_bufmgr_mutex_unlock();
 
        return bo;
+
+import_fail:
+       free(bo);
+       _tbm_bufmgr_mutex_unlock();
+       return NULL;
 }
 
 int
@@ -1092,7 +1238,13 @@ tbm_bo_size(tbm_bo bo)
 
        TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
 
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
+               if (error != TBM_ERROR_NONE) {
+                       TBM_ERR("fail to get the size of the bo_data(%d).", error);
+                       _tbm_set_last_result(TBM_ERROR_NONE);
+               }
+       } else if (bo->bufmgr->backend_module_data) {
                size = bo->bufmgr->bo_func->bo_get_size(bo->bo_data, &error);
                if (error != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the size of the bo_data(%d).", error);
@@ -1150,7 +1302,20 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
 
        TBM_TRACE_BO("before: bo1(%p) bo2(%p)\n", bo1, bo2);
 
-       if (bo1->bufmgr->backend_module_data) {
+       if (bo1->bufmgr->use_hal_tbm) {
+               size1 = hal_tbm_bo_get_size((hal_tbm_bo *)bo1->bo_data, (hal_tbm_error *)&error1);
+               if (error1 != TBM_ERROR_NONE) {
+                       TBM_ERR("fail to get the size of bo1.(%d)", error1);
+                       _tbm_set_last_result(error1);
+                       goto fail;
+               }
+               size2 = hal_tbm_bo_get_size((hal_tbm_bo *)bo2->bo_data, (hal_tbm_error *)&error2);
+               if (error2 != TBM_ERROR_NONE) {
+                       TBM_ERR("fail to get the size of bo1.(%d)", error2);
+                       _tbm_set_last_result(error2);
+                       goto fail;
+               }
+       } else if (bo1->bufmgr->backend_module_data) {
                size1 = bo1->bufmgr->bo_func->bo_get_size(bo1->bo_data, &error1);
                if (error1 != TBM_ERROR_NONE) {
                        TBM_ERR("fail to get the size of bo1.(%d)", error1);
@@ -1388,7 +1553,10 @@ _tbm_bo_free(tbm_bo bo)
        }
 
        /* call the bo_free */
-       if (bo->bufmgr->backend_module_data) {
+       if (bo->bufmgr->use_hal_tbm) {
+               hal_tbm_bo_free(bo->bo_data);
+               bo->bo_data = NULL;
+       } else if (bo->bufmgr->backend_module_data) {
                bo->bufmgr->bo_func->bo_free(bo->bo_data);
                bo->bo_data = NULL;
        } else {

diff --git a/src/tbm_bufmgr.c b/src/tbm_bufmgr.c
index 6215836..c9872df 100644 (file)
--- a/src/tbm_bufmgr.c
+++ b/src/tbm_bufmgr.c
@@ -185,6 +185,58 @@ _tbm_util_get_appname_from_pid(long pid, char *str)
 }
 
 static int
+_tbm_backend_load_hal_tbm(tbm_bufmgr bufmgr)
+{
+       hal_tbm_backend *hal_backend = NULL;
+       hal_tbm_bufmgr_capability capability;
+       hal_tbm_bufmgr *hal_bufmgr;
+       hal_tbm_error ret = HAL_TBM_ERROR_NONE;
+
+       hal_backend = hal_tbm_get_backend(&ret);
+       if (hal_backend == NULL || ret != HAL_TBM_ERROR_NONE) {
+               TBM_ERR("get backend fail");
+               return 0;
+       }
+
+       hal_bufmgr = hal_tbm_backend_get_bufmgr(hal_backend, &ret);
+       if (hal_bufmgr == NULL || ret != HAL_TBM_ERROR_NONE) {
+               TBM_ERR("get hal_bufmgr fail");
+               goto get_backend_fail;
+       }
+
+       capability = hal_tbm_bufmgr_get_capabilities(hal_bufmgr, &ret);
+       if (ret != HAL_TBM_ERROR_NONE) {
+               TBM_ERR("hal_tbm_bufmgr_get_capabilities fail.");
+               goto get_backend_fail;
+       }
+
+       if (capability == HAL_TBM_BUFMGR_CAPABILITY_NONE) {
+               TBM_ERR("The capabilities of the backend module is TBM_BUFMGR_CAPABILITY_NONE.");
+               TBM_ERR("TBM_BUFMGR_CAPABILITY_SHARE_FD is the essential capability.");
+               goto get_backend_fail;
+       }
+       if (!(capability & HAL_TBM_BUFMGR_CAPABILITY_SHARE_FD)) {
+               TBM_ERR("The capabilities of the backend module had no TBM_BUFMGR_CAPABILITY_SHARE_FD.");
+               TBM_ERR("The tbm backend has to get TBM_BUFMGR_CAPABILITY_SHARE_FD. ");
+               goto get_backend_fail;
+       }
+       bufmgr->capabilities = capability;
+
+       bufmgr->hal_backend = hal_backend;
+       bufmgr->hal_bufmgr = hal_bufmgr;
+
+       bufmgr->use_hal_tbm = 1;
+
+       TBM_INFO("use hal tbm");
+
+       return 1;
+
+get_backend_fail:
+       hal_tbm_put_backend(hal_backend);
+       return 0;
+}
+
+static int
 _check_version(TBMModuleVersionInfo *data)
 {
        int backend_module_major, backend_module_minor;
@@ -427,6 +479,11 @@ _tbm_load_module(tbm_bufmgr bufmgr, int fd)
        struct dirent **namelist;
        int ret = 0, n;
 
+       /* try to load the hal-tbm backend module */
+       ret = _tbm_backend_load_hal_tbm(bufmgr);
+       if (ret)
+               return 1;
+
        /* try to load the new backend module */
        ret = _tbm_backend_load_module(bufmgr, DEFAULT_LIB);
        if (ret)
@@ -636,28 +693,34 @@ tbm_bufmgr_deinit(tbm_bufmgr bufmgr)
                LIST_DELINIT(&bufmgr->surf_list);
        }
 
-       if (bufmgr->backend_module_data) {
-               /* deinit and backend destroys the backend func and data */
-               bufmgr->backend_module_data->deinit(bufmgr->bufmgr_data);
-               bufmgr->bo_func = NULL;
-               bufmgr->bufmgr_func = NULL;
-               bufmgr->bufmgr_data = NULL;
-               bufmgr->backend_module_data = NULL;
+       if (bufmgr->use_hal_tbm) {
+               hal_tbm_put_backend(bufmgr->hal_backend);
+               bufmgr->hal_backend = NULL;
+               bufmgr->hal_bufmgr = NULL;
+               bufmgr->use_hal_tbm = 0;
        } else {
-               /* destroy bufmgr priv */
-               bufmgr->backend->bufmgr_deinit(bufmgr->backend->priv);
-               bufmgr->backend->priv = NULL;
-               tbm_backend_free(bufmgr->backend);
-               bufmgr->backend = NULL;
-       }
-
-       TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr);
-
-       dlclose(bufmgr->module_data);
+               if (bufmgr->backend_module_data) {
+                       /* deinit and backend destroys the backend func and data */
+                       bufmgr->backend_module_data->deinit(bufmgr->bufmgr_data);
+                       bufmgr->bo_func = NULL;
+                       bufmgr->bufmgr_func = NULL;
+                       bufmgr->bufmgr_data = NULL;
+                       bufmgr->backend_module_data = NULL;
+               } else {
+                       /* destroy bufmgr priv */
+                       bufmgr->backend->bufmgr_deinit(bufmgr->backend->priv);
+                       bufmgr->backend->priv = NULL;
+                       tbm_backend_free(bufmgr->backend);
+                       bufmgr->backend = NULL;
+               }
 
+               dlclose(bufmgr->module_data);
+       }
        if (bufmgr->fd > 0)
                close(bufmgr->fd);
 
+       TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr);
+
        free(bufmgr);
        gBufMgr = NULL;
 
@@ -787,7 +850,11 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
                        TBM_SNRPRINTF(str, len, c, "%s\n", data);
 
                        for (i = 0; i < surf->num_bos; i++) {
-                               if (bufmgr->backend_module_data) {
+                               if (bufmgr->use_hal_tbm) {
+                                       size = hal_tbm_bo_get_size((hal_tbm_bo *)surf->bos[i]->bo_data, (hal_tbm_error *)&error);
+                                       if (error != TBM_ERROR_NONE)
+                                               TBM_WRN("fail to get the size of bo.");
+                               } else if (bufmgr->backend_module_data) {
                                        size = bufmgr->bo_func->bo_get_size(surf->bos[i]->bo_data, &error);
                                        if (error != TBM_ERROR_NONE)
                                                TBM_WRN("fail to get the size of bo.");
@@ -813,7 +880,12 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr)
                tbm_key key = 0;
 
                LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) {
-                       if (bufmgr->backend_module_data) {
+                       if (bo->bufmgr->use_hal_tbm) {
+                               size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
+                               if (error != TBM_ERROR_NONE)
+                                       TBM_WRN("fail to get the size of bo.");
+                               key = (tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
+                       } else if (bufmgr->backend_module_data) {
                                size = bufmgr->bo_func->bo_get_size(bo->bo_data, &error);
                                if (error != TBM_ERROR_NONE)
                                        TBM_WRN("fail to get the size of bo.");
@@ -1031,7 +1103,20 @@ tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *native_display)
 
        TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0);
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               error = (tbm_error_e)hal_tbm_bufmgr_bind_native_display(bufmgr->hal_bufmgr, (hal_tbm_native_display *)native_display);
+               if (error == TBM_ERROR_NOT_SUPPORTED) {
+                       TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display);
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                       _tbm_bufmgr_mutex_unlock();
+                       return 1;
+               } else if (error != TBM_ERROR_NONE) {
+                       TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display);
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
+                       _tbm_bufmgr_mutex_unlock();
+                       return 0;
+               }
+       } else if (bufmgr->backend_module_data) {
                if (!bufmgr->bufmgr_func->bufmgr_bind_native_display) {
                        TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n",
                                        bufmgr, native_display);

diff --git a/src/tbm_bufmgr_int.h b/src/tbm_bufmgr_int.h
index 7972b97..9df1dd7 100644 (file)
--- a/src/tbm_bufmgr_int.h
+++ b/src/tbm_bufmgr_int.h
@@ -58,6 +58,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <tbm_bufmgr_backend.h>
 #include <tbm_backend.h>
 #include <tbm_error.h>
+#include <hal/hal-tbm.h>
 
 extern tbm_bufmgr gBufMgr;
 extern int b_dump_queue;
@@ -210,6 +211,10 @@ struct _tbm_bufmgr {
        tbm_backend_bufmgr_data  *bufmgr_data;          /* backend data of the backend module */
        tbm_backend_bufmgr_func  *bufmgr_func;          /* backend functions for bufmgr */
        tbm_backend_bo_func      *bo_func;              /* backend functions for bo */
+
+       int use_hal_tbm;                                /* use hal-api-tbm */
+       hal_tbm_backend          *hal_backend;          /* hal-api-tbm backend */
+       hal_tbm_bufmgr           *hal_bufmgr;           /* hal-api-tbm bufmgr */
 };
 
 /**

diff --git a/src/tbm_surface_internal.c b/src/tbm_surface_internal.c
index 872fb5c..0e6f1f5 100644 (file)
--- a/src/tbm_surface_internal.c
+++ b/src/tbm_surface_internal.c
@@ -289,7 +289,21 @@ _tbm_surface_internal_query_plane_data(tbm_surface_h surface,
        TBM_RETURN_VAL_IF_FAIL(surf->info.height > 0, 0);
        TBM_RETURN_VAL_IF_FAIL(surf->info.format > 0, 0);
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               error = (tbm_error_e)hal_tbm_bufmgr_get_plane_data(bufmgr->hal_bufmgr, (hal_tbm_format)surf->info.format,
+                                                               plane_idx, surf->info.width, surf->info.height, size, offset, pitch, bo_idx);
+               /* LCOV_EXCL_START */
+               if (error == TBM_ERROR_NOT_SUPPORTED) {
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                       return 0;
+               } else if (error != TBM_ERROR_NONE) {
+                       TBM_ERR("Fail to surface_get_plane_data. surface(%p) error(%d)\n", surface, error);
+                       _tbm_set_last_result(error);
+                       return 0;
+               }
+               /* LCOV_EXCL_STOP */
+               ret = 1;
+       } else if (bufmgr->backend_module_data) {
                if (!bufmgr->bufmgr_func->bufmgr_get_plane_data) {
                        _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        return 0;
@@ -610,7 +624,18 @@ tbm_surface_internal_query_supported_formats(uint32_t **formats,
 
        bufmgr = g_surface_bufmgr;
 
-       if (bufmgr->backend_module_data) {
+       if (bufmgr->use_hal_tbm) {
+               error = (tbm_error_e)hal_tbm_bufmgr_get_supported_formats(bufmgr->hal_bufmgr, formats, num);
+               /* LCOV_EXCL_START */
+               if (error == TBM_ERROR_NOT_SUPPORTED) {
+                       _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+                       goto fail;
+               } else if (error != TBM_ERROR_NONE) {
+                       _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
+                       goto fail;
+               }
+               /* LCOV_EXCL_STOP */
+       } else if (bufmgr->backend_module_data) {
                if (!bufmgr->bufmgr_func->bufmgr_get_supported_formats) {
                        _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
                        goto fail;
@@ -800,7 +825,30 @@ tbm_surface_internal_create_with_flags(int width, int height,
                                bo_size += surf->info.planes[j].size;
                }
 
-               if (bufmgr->backend_module_data) {
+               if (bufmgr->use_hal_tbm) {
+                       surf->bos[i] = tbm_bo_alloc_with_format(bufmgr, format, i, width, height, flags, &error);
+                       if (error == TBM_ERROR_NOT_SUPPORTED) {
+                               if (flags & TBM_BO_TILED) {
+                                       surf->bos[i] = tbm_bo_alloc_with_tiled_format(bufmgr, width, height, surf->info.bpp/8, format, flags, i, &error);
+                                       if (error == TBM_ERROR_NOT_SUPPORTED) {
+                                               surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
+                                       } else if (error != TBM_ERROR_NONE) {
+                                               TBM_ERR("fail to alloc bo idx:%d\n", i);
+                                               goto alloc_bo_fail;
+                                       }
+                               } else {
+                                       surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
+                               }
+
+                               if (!surf->bos[i]) {
+                                       TBM_ERR("fail to alloc bo idx:%d\n", i);
+                                       goto alloc_bo_fail;
+                               }
+                       } else if (error != TBM_ERROR_NONE) {
+                               TBM_ERR("fail to alloc bo idx:%d\n", i);
+                               goto alloc_bo_fail;
+                       }
+               } else if (bufmgr->backend_module_data) {
                        if (bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format) {
                                /* LCOV_EXCL_START */
                                surf->bos[i] = tbm_bo_alloc_with_format(bufmgr, format, i, width, height, flags, &error);