1 /**************************************************************************
5 Copyright 2012 Samsung Electronics co., Ltd. All Rights Reserved.
7 Contact: SooChan Lim <sc1.lim@samsung.com>, Sangjin Lee <lsj119@samsung.com>
8 Boram Park <boram1288.park@samsung.com>, Changyeon Lee <cyeon.lee@samsung.com>
10 Permission is hereby granted, free of charge, to any person obtaining a
11 copy of this software and associated documentation files (the
12 "Software"), to deal in the Software without restriction, including
13 without limitation the rights to use, copy, modify, merge, publish,
14 distribute, sub license, and/or sell copies of the Software, and to
15 permit persons to whom the Software is furnished to do so, subject to
16 the following conditions:
18 The above copyright notice and this permission notice (including the
19 next paragraph) shall be included in all copies or substantial portions
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
25 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
26 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 **************************************************************************/
33 #include "tbm_bufmgr.h"
34 #include "tbm_bufmgr_int.h"
37 #define TBM_BO_MAGIC 0xBF011234
40 #define TBM_BO_RETURN_IF_FAIL(cond) {\
42 TBM_ERR("'%s' failed.\n", #cond);\
43 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
44 _tbm_bufmgr_mutex_unlock();\
49 #define TBM_BO_RETURN_VAL_IF_FAIL(cond, val) {\
51 TBM_ERR("'%s' failed.\n", #cond);\
52 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
53 _tbm_bufmgr_mutex_unlock();\
59 _tbm_flag_to_str(int f)
63 if (f == TBM_BO_DEFAULT)
64 snprintf(str, 255, "DEFAULT");
68 if (f & TBM_BO_SCANOUT)
69 c += snprintf(&str[c], 255-c, "SCANOUT");
71 if (f & TBM_BO_NONCACHABLE) {
72 if (c >= 0 && c < 255)
73 c += snprintf(&str[c], 255-c, ", ");
75 if (c >= 0 && c < 255)
76 c += snprintf(&str[c], 255-c, "NONCACHABLE,");
80 if (c >= 0 && c < 255)
81 c += snprintf(&str[c], 255-c, ", ");
83 if (c >= 0 && c < 255)
84 c += snprintf(&str[c], 255-c, "WC");
92 _tbm_util_check_bo_cnt(tbm_bufmgr bufmgr)
94 static int last_chk_bo_cnt = 0;
96 if ((bufmgr->bo_cnt >= 500) && ((bufmgr->bo_cnt % 20) == 0) &&
97 (bufmgr->bo_cnt > last_chk_bo_cnt)) {
98 TBM_DBG("============TBM BO CNT DEBUG: bo_cnt=%d\n", bufmgr->bo_cnt);
99 tbm_bufmgr_debug_show(bufmgr);
100 last_chk_bo_cnt = bufmgr->bo_cnt;
106 user_data_lookup(struct list_head *user_data_list, unsigned long key)
108 tbm_user_data *old_data = NULL;
110 if (LIST_IS_EMPTY(user_data_list))
113 LIST_FOR_EACH_ENTRY(old_data, user_data_list, item_link) {
114 if (old_data->key == key)
122 user_data_create(unsigned long key, tbm_data_free data_free_func)
124 tbm_user_data *user_data;
126 user_data = calloc(1, sizeof(tbm_user_data));
128 /* LCOV_EXCL_START */
129 TBM_ERR("fail to allocate an user_date\n");
130 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
135 user_data->key = key;
136 user_data->free_func = data_free_func;
142 user_data_delete(tbm_user_data *user_data)
144 if (user_data->data && user_data->free_func)
145 user_data->free_func(user_data->data);
147 LIST_DEL(&user_data->item_link);
153 _bo_lock(tbm_bo bo, int device, int opt)
158 if (bo->bufmgr->use_hal_tbm) {
159 error = (tbm_error_e)hal_tbm_bo_lock((hal_tbm_bo *)bo->bo_data, device, opt);
160 if (error == TBM_ERROR_NOT_SUPPORTED) {
161 _tbm_set_last_result(TBM_ERROR_NONE);
163 if (error != TBM_ERROR_NONE) {
164 TBM_WRN("fail to lock");
165 _tbm_set_last_result(error);
169 } else if (bo->bufmgr->backend_module_data) {
170 if (bo->bufmgr->bo_func->bo_lock) {
171 error = bo->bufmgr->bo_func->bo_lock(bo->bo_data, device, opt);
172 if (error != TBM_ERROR_NONE) {
173 TBM_WRN("fail to lock");
174 _tbm_set_last_result(error);
179 if (bo->bufmgr->backend->bo_lock) {
180 ret = bo->bufmgr->backend->bo_lock(bo, device, opt);
182 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
190 _bo_unlock(tbm_bo bo)
194 if (bo->bufmgr->use_hal_tbm) {
195 error = (tbm_error_e)hal_tbm_bo_unlock((hal_tbm_bo *)bo->bo_data);
196 if (error == TBM_ERROR_NOT_SUPPORTED) {
197 _tbm_set_last_result(TBM_ERROR_NONE);
199 if (error != TBM_ERROR_NONE) {
200 TBM_WRN("fail to lock");
201 _tbm_set_last_result(error);
204 } else if (bo->bufmgr->backend_module_data) {
205 if (bo->bufmgr->bo_func->bo_unlock) {
206 error = bo->bufmgr->bo_func->bo_unlock(bo->bo_data);
207 if (error != TBM_ERROR_NONE) {
208 TBM_WRN("fail to unlock");
209 _tbm_set_last_result(error);
213 if (bo->bufmgr->backend->bo_unlock)
214 bo->bufmgr->backend->bo_unlock(bo);
219 _tbm_bo_lock(tbm_bo bo, int device, int opt)
226 /* do not try to lock the bo */
227 if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER)
230 if (bo->lock_cnt < 0) {
231 TBM_ERR("error bo:%p LOCK_CNT=%d\n",
238 switch (bo->bufmgr->bo_lock_type) {
239 case TBM_BUFMGR_BO_LOCK_TYPE_ONCE:
240 if (bo->lock_cnt == 0) {
241 _tbm_bufmgr_mutex_unlock();
242 ret = _bo_lock(bo, device, opt);
243 _tbm_bufmgr_mutex_lock();
249 case TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS:
250 _tbm_bufmgr_mutex_unlock();
251 ret = _bo_lock(bo, device, opt);
252 _tbm_bufmgr_mutex_lock();
257 TBM_ERR("error bo:%p bo_lock_type[%d] is wrong.\n",
258 bo, bo->bufmgr->bo_lock_type);
263 TBM_DBG(">> LOCK bo:%p(%d->%d)\n", bo, old, bo->lock_cnt);
269 _tbm_bo_unlock(tbm_bo bo)
273 /* do not try to unlock the bo */
274 if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER)
279 switch (bo->bufmgr->bo_lock_type) {
280 case TBM_BUFMGR_BO_LOCK_TYPE_ONCE:
281 if (bo->lock_cnt > 0) {
283 if (bo->lock_cnt == 0)
287 case TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS:
288 if (bo->lock_cnt > 0) {
294 TBM_ERR("error bo:%p bo_lock_type[%d] is wrong.\n",
295 bo, bo->bufmgr->bo_lock_type);
299 if (bo->lock_cnt < 0)
302 TBM_DBG(">> UNLOCK bo:%p(%d->%d)\n", bo, old, bo->lock_cnt);
306 _tbm_bo_magic_check(tbm_bo bo)
308 if (bo->magic != TBM_BO_MAGIC)
315 _tbm_bo_is_valid(tbm_bo bo)
318 TBM_ERR("error: bo is NULL.\n");
322 if (!_tbm_bo_magic_check(bo)) {
323 TBM_ERR("error: No valid bo(%p).\n", bo);
331 _tbm_bo_init(tbm_bufmgr bufmgr, tbm_bo bo, int flags)
335 bo->magic = TBM_BO_MAGIC;
338 LIST_INITHEAD(&bo->user_data_list);
341 LIST_ADD(&bo->item_link, &bufmgr->bo_list);
345 _tbm_bo_deinit(tbm_bo bo)
349 bo->bufmgr->bo_cnt--;
350 LIST_DEL(&bo->item_link);
354 tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
357 tbm_backend_bo_data *bo_data;
360 _tbm_bufmgr_mutex_lock();
361 _tbm_set_last_result(TBM_ERROR_NONE);
363 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
364 TBM_BO_RETURN_VAL_IF_FAIL(size > 0, NULL);
366 bo = calloc(1, sizeof(struct _tbm_bo));
368 /* LCOV_EXCL_START */
369 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
370 _tbm_bufmgr_mutex_unlock();
375 _tbm_util_check_bo_cnt(bufmgr);
377 bo_data = tbm_module_bufmgr_bo_alloc(bufmgr->module, bo, size, flags, &error);
378 if (!bo_data || error != TBM_ERROR_NONE) {
379 /* LCOV_EXCL_START */
380 TBM_ERR("tbm_module_bufmgr_bo_alloc failed. error:%d", error);
381 _tbm_set_last_result(error);
385 bo->bo_data = bo_data;
386 bo->priv = (void *)bo_data; // TODO: this will be DEPRECATED.
388 _tbm_bo_init(bufmgr, bo, flags);
390 TBM_TRACE_BO("bo(%p) size(%d) refcnt(%d), flag(%s)\n", bo, size, bo->ref_cnt,
391 _tbm_flag_to_str(bo->flags));
393 _tbm_bufmgr_mutex_unlock();
398 TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n", size, _tbm_flag_to_str(flags));
400 _tbm_bufmgr_mutex_unlock();
404 /* LCOV_EXCL_START */
406 tbm_bo_alloc_with_format(tbm_bufmgr bufmgr, int format, int bo_idx, int width,
407 int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error)
411 _tbm_bufmgr_mutex_lock();
412 _tbm_set_last_result(TBM_ERROR_NONE);
414 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
416 bo = calloc(1, sizeof(struct _tbm_bo));
418 /* LCOV_EXCL_START */
419 TBM_ERR("error: fail to tbm_bo_alloc_with_format fmt(%s) idx(%d) w(%d) h(%d) mem_types(%s)\n",
420 FOURCC_STR(format), bo_idx, width, height, _tbm_flag_to_str(flags));
421 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
426 _tbm_util_check_bo_cnt(bufmgr);
428 bo->bo_data = tbm_module_bufmgr_bo_alloc_with_format(bufmgr->module, format, bo_idx, width, height, bpp, flags, error);
430 /* LCOV_EXCL_START */
431 TBM_ERR("tbm_module_bufmgr_bo_alloc_with_format failed. fmt:%d idx:%d wxh:%dx%d mem_types:%s\n",
432 format, bo_idx, width, height, _tbm_flag_to_str(flags));
433 _tbm_set_last_result(*error);
438 _tbm_bo_init(bufmgr, bo, flags);
440 _tbm_bufmgr_mutex_unlock();
447 _tbm_bufmgr_mutex_unlock();
453 tbm_bo_alloc_with_surface(tbm_bufmgr bufmgr, int width, int height, int format, int flags, int bo_idx)
458 _tbm_bufmgr_mutex_lock();
459 _tbm_set_last_result(TBM_ERROR_NONE);
461 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
463 bo = calloc(1, sizeof(struct _tbm_bo));
465 TBM_ERR("error: fail to tbm_bo_alloc_with_surface fmt(%s) idx(%d) w(%d) h(%d) flags(%s)\n",
466 FOURCC_STR(format), bo_idx, width, height, _tbm_flag_to_str(flags));
467 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
468 _tbm_bufmgr_mutex_unlock();
472 _tbm_util_check_bo_cnt(bufmgr);
474 if (!bufmgr->backend->surface_bo_alloc) {
475 TBM_ERR("error: not supported tbm_bo_alloc_with_surface\n");
476 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
478 _tbm_bufmgr_mutex_unlock();
482 bo_priv = bufmgr->backend->surface_bo_alloc(bo, width, height, format, flags, bo_idx);
484 TBM_ERR("error: fail to tbm_bo_alloc_with_surface fmt(%s) idx(%d) w(%d) h(%d) flags(%s)\n",
485 FOURCC_STR(format), bo_idx, width, height, _tbm_flag_to_str(flags));
486 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
488 _tbm_bufmgr_mutex_unlock();
493 _tbm_bo_init(bufmgr, bo, flags);
495 _tbm_bufmgr_mutex_unlock();
501 tbm_bo_alloc_with_bo_data(tbm_bufmgr bufmgr, tbm_backend_bo_data *bo_data, int flags)
503 tbm_bo bo, bo2 = NULL;
505 _tbm_bufmgr_mutex_lock();
506 _tbm_set_last_result(TBM_ERROR_NONE);
508 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
509 TBM_BO_RETURN_VAL_IF_FAIL(bo_data, NULL);
511 // return an existed bo if the bo is already created with the same bo_data.
512 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
513 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
514 if (bo2->bo_data == bo_data) {
515 TBM_ERR("find bo(%p) ref(%d) flag(%s) in list\n",
516 bo2, bo2->ref_cnt, _tbm_flag_to_str(bo2->flags));
518 _tbm_bufmgr_mutex_unlock();
524 bo = calloc(1, sizeof(struct _tbm_bo));
526 /* LCOV_EXCL_START */
527 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
528 _tbm_bufmgr_mutex_unlock();
533 _tbm_util_check_bo_cnt(bufmgr);
535 bo->get_from_hal_surface = 1;
536 bo->bo_data = bo_data;
538 _tbm_bo_init(bufmgr, bo, flags);
540 TBM_TRACE_BO("bo(%p) refcnt(%d), flag(%s)\n", bo, bo->ref_cnt, _tbm_flag_to_str(bo->flags));
542 _tbm_bufmgr_mutex_unlock();
550 tbm_bo_ref(tbm_bo bo)
552 _tbm_bufmgr_mutex_lock();
553 _tbm_set_last_result(TBM_ERROR_NONE);
555 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), NULL);
559 TBM_TRACE_BO("bo(%p) ref_cnt(%d)\n", bo, bo->ref_cnt);
561 _tbm_bufmgr_mutex_unlock();
567 tbm_bo_unref(tbm_bo bo)
569 _tbm_bufmgr_mutex_lock();
570 _tbm_set_last_result(TBM_ERROR_NONE);
572 TBM_BO_RETURN_IF_FAIL(_tbm_bo_is_valid(bo));
574 TBM_TRACE_BO("bo(%p) ref_cnt(%d)\n", bo, bo->ref_cnt - 1);
576 if (bo->ref_cnt <= 0) {
577 _tbm_bufmgr_mutex_unlock();
582 if (bo->ref_cnt == 0)
585 _tbm_bufmgr_mutex_unlock();
589 tbm_bo_map(tbm_bo bo, int device, int opt)
591 tbm_bo_handle bo_handle;
594 _tbm_bufmgr_mutex_lock();
595 _tbm_set_last_result(TBM_ERROR_NONE);
597 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
599 if (!_tbm_bo_lock(bo, device, opt)) {
600 TBM_ERR("error: fail to lock bo:%p)\n", bo);
601 _tbm_bufmgr_mutex_unlock();
602 return (tbm_bo_handle) NULL;
605 if (bo->bufmgr->use_hal_tbm) {
606 hal_tbm_bo_handle hbo_handle;
607 hbo_handle = hal_tbm_bo_map((hal_tbm_bo *)bo->bo_data, device, opt, (hal_tbm_error *)&error);
608 if (hbo_handle.ptr == NULL) {
609 /* LCOV_EXCL_START */
610 _tbm_set_last_result(error);
611 TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, hbo_handle.ptr, error);
615 memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
616 } else if (bo->bufmgr->backend_module_data) {
617 bo_handle = bo->bufmgr->bo_func->bo_map(bo->bo_data, device, opt, &error);
618 if (bo_handle.ptr == NULL) {
619 /* LCOV_EXCL_START */
620 _tbm_set_last_result(error);
621 TBM_ERR("error: fail to map bo:%p error:%d\n", bo, error);
626 bo_handle = bo->bufmgr->backend->bo_map(bo, device, opt);
627 if (bo_handle.ptr == NULL) {
628 /* LCOV_EXCL_START */
629 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
630 TBM_ERR("error: fail to map bo:%p\n", bo);
636 /* increase the map_count */
639 TBM_TRACE_BO("bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
641 _tbm_bufmgr_mutex_unlock();
647 _tbm_bufmgr_mutex_unlock();
648 return (tbm_bo_handle) NULL;
652 tbm_bo_unmap(tbm_bo bo)
657 _tbm_bufmgr_mutex_lock();
658 _tbm_set_last_result(TBM_ERROR_NONE);
660 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
661 TBM_BO_RETURN_VAL_IF_FAIL(bo->map_cnt > 0, 0);
663 if (bo->bufmgr->use_hal_tbm) {
664 error = (hal_tbm_error)hal_tbm_bo_unmap((hal_tbm_bo *)bo->bo_data);
665 if (error != TBM_ERROR_NONE) {
666 /* LCOV_EXCL_START */
667 TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error);
668 _tbm_set_last_result(error);
673 } else if (bo->bufmgr->backend_module_data) {
674 error = bo->bufmgr->bo_func->bo_unmap(bo->bo_data);
675 if (error != TBM_ERROR_NONE) {
676 /* LCOV_EXCL_START */
677 TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error);
678 _tbm_set_last_result(error);
684 ret = bo->bufmgr->backend->bo_unmap(bo);
686 /* LCOV_EXCL_START */
687 TBM_ERR("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
688 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
694 /* decrease the map_count */
697 TBM_TRACE_BO("bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
702 _tbm_bufmgr_mutex_unlock();
708 tbm_bo_get_handle(tbm_bo bo, int device)
710 tbm_bo_handle bo_handle;
713 _tbm_bufmgr_mutex_lock();
714 _tbm_set_last_result(TBM_ERROR_NONE);
716 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
718 if (bo->bufmgr->use_hal_tbm) {
719 hal_tbm_bo_handle hbo_handle;
720 hbo_handle = hal_tbm_bo_get_handle((hal_tbm_bo *)bo->bo_data, device, (hal_tbm_error *)&error);
721 if (hbo_handle.ptr == NULL) {
722 /* LCOV_EXCL_START */
723 TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, hbo_handle.ptr, error);
724 _tbm_set_last_result(error);
728 memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
729 } else if (bo->bufmgr->backend_module_data) {
730 bo_handle = bo->bufmgr->bo_func->bo_get_handle(bo->bo_data, device, &error);
731 if (bo_handle.ptr == NULL) {
732 /* LCOV_EXCL_START */
733 TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, bo_handle.ptr, error);
734 _tbm_set_last_result(error);
739 bo_handle = bo->bufmgr->backend->bo_get_handle(bo, device);
740 if (bo_handle.ptr == NULL) {
741 /* LCOV_EXCL_START */
742 TBM_ERR("error: bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr);
743 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
749 TBM_TRACE_BO("bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr);
751 _tbm_bufmgr_mutex_unlock();
756 _tbm_bufmgr_mutex_unlock();
757 return (tbm_bo_handle) NULL;
761 tbm_bo_export(tbm_bo bo)
766 _tbm_bufmgr_mutex_lock();
767 _tbm_set_last_result(TBM_ERROR_NONE);
769 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
771 if (bo->bufmgr->use_hal_tbm) {
772 ret = (hal_tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
774 /* LCOV_EXCL_START */
775 TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error);
776 _tbm_set_last_result(error);
780 } else if (bo->bufmgr->backend_module_data) {
781 if (!bo->bufmgr->bo_func->bo_export_key) {
782 /* LCOV_EXCL_START */
783 _tbm_bufmgr_mutex_unlock();
784 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
789 ret = bo->bufmgr->bo_func->bo_export_key(bo->bo_data, &error);
791 /* LCOV_EXCL_START */
792 TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error);
793 _tbm_set_last_result(error);
798 if (!bo->bufmgr->backend->bo_export) {
799 /* LCOV_EXCL_START */
800 _tbm_bufmgr_mutex_unlock();
801 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
806 ret = bo->bufmgr->backend->bo_export(bo);
808 /* LCOV_EXCL_START */
809 TBM_ERR("error: bo(%p) tbm_key(%d)\n", bo, ret);
810 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
816 TBM_TRACE_BO("bo(%p) tbm_key(%u)\n", bo, ret);
819 _tbm_bufmgr_mutex_unlock();
825 tbm_bo_export_fd(tbm_bo bo)
830 _tbm_bufmgr_mutex_lock();
831 _tbm_set_last_result(TBM_ERROR_NONE);
833 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), -1);
835 if (bo->bufmgr->use_hal_tbm) {
836 ret = (hal_tbm_fd)hal_tbm_bo_export_fd((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
838 /* LCOV_EXCL_START */
839 TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error);
840 _tbm_set_last_result(error);
844 } else if (bo->bufmgr->backend_module_data) {
845 if (!bo->bufmgr->bo_func->bo_export_fd) {
846 /* LCOV_EXCL_START */
847 _tbm_bufmgr_mutex_unlock();
848 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
853 ret = bo->bufmgr->bo_func->bo_export_fd(bo->bo_data, &error);
855 /* LCOV_EXCL_START */
856 TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error);
857 _tbm_set_last_result(error);
862 if (!bo->bufmgr->backend->bo_export_fd) {
863 /* LCOV_EXCL_START */
864 _tbm_bufmgr_mutex_unlock();
865 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
870 ret = bo->bufmgr->backend->bo_export_fd(bo);
872 /* LCOV_EXCL_START */
873 TBM_ERR("error: bo(%p) tbm_fd(%d)\n", bo, ret);
874 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
880 TBM_TRACE_BO("bo(%p) tbm_fd(%d)\n", bo, ret);
883 _tbm_bufmgr_mutex_unlock();
889 tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
895 tbm_backend_bo_data *bo_data;
898 _tbm_bufmgr_mutex_lock();
899 _tbm_set_last_result(TBM_ERROR_NONE);
901 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
903 if (!bufmgr->use_hal_tbm) {
904 if (bufmgr->backend_module_data) {
905 if (!bufmgr->bufmgr_func->bufmgr_import_key) {
906 /* LCOV_EXCL_START */
907 _tbm_bufmgr_mutex_unlock();
908 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
913 if (!bufmgr->backend->bo_import) {
914 /* LCOV_EXCL_START */
915 _tbm_bufmgr_mutex_unlock();
916 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
923 _tbm_util_check_bo_cnt(bufmgr);
925 bo = calloc(1, sizeof(struct _tbm_bo));
927 /* LCOV_EXCL_START */
928 TBM_ERR("error: fail to import of tbm_bo by key(%d)\n", key);
929 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
930 _tbm_bufmgr_mutex_unlock();
935 if (bufmgr->use_hal_tbm) {
936 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_key(bufmgr->hal_bufmgr, key, (hal_tbm_error *)&error);
937 /* LCOV_EXCL_START */
939 TBM_ERR("error: fail to import of tbm_bo by key(%d). error(%d)\n", key, error);
940 _tbm_set_last_result(error);
944 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
945 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
946 if (bo2->bo_data == bo_data) {
947 TBM_TRACE_BO("find bo(%p) ref(%d) key(%d) flag(%s) in list\n",
948 bo2, bo2->ref_cnt, key,
949 _tbm_flag_to_str(bo2->flags));
952 _tbm_bufmgr_mutex_unlock();
957 bo->bo_data = bo_data;
958 } else if (bufmgr->backend_module_data) {
959 bo_data = bufmgr->bufmgr_func->bufmgr_import_key(bufmgr->bufmgr_data, key, &error);
961 /* LCOV_EXCL_START */
962 TBM_ERR("error: fail to import of tbm_bo by key(%d). error(%d)\n", key, error);
963 _tbm_set_last_result(error);
968 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
969 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
970 if (bo2->bo_data == bo_data) {
971 TBM_TRACE_BO("find bo(%p) ref(%d) key(%d) flag(%s) in list\n",
972 bo2, bo2->ref_cnt, key,
973 _tbm_flag_to_str(bo2->flags));
976 _tbm_bufmgr_mutex_unlock();
981 bo->bo_data = bo_data;
983 bo_priv = bufmgr->backend->bo_import(bo, key);
985 /* LCOV_EXCL_START */
986 TBM_ERR("error: fail to import of tbm_bo by key(%d)\n", key);
987 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
992 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
993 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
994 if (bo2->priv == bo_priv) {
995 TBM_TRACE_BO("find bo(%p) ref(%d) key(%d) flag(%s) in list\n",
996 bo2, bo2->ref_cnt, key,
997 _tbm_flag_to_str(bo2->flags));
1000 _tbm_bufmgr_mutex_unlock();
1008 if (bufmgr->use_hal_tbm) {
1009 flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
1010 if (error != TBM_ERROR_NONE) {
1011 TBM_ERR("fail to get the bo flags(memory_types)");
1012 _tbm_set_last_result(error);
1013 flags = TBM_BO_DEFAULT;
1015 } else if (bufmgr->backend_module_data) {
1016 flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error);
1017 if (error != TBM_ERROR_NONE) {
1018 TBM_ERR("fail to get the bo flags(memory_types)");
1019 _tbm_set_last_result(error);
1020 flags = TBM_BO_DEFAULT;
1023 if (bufmgr->backend->bo_get_flags)
1024 flags = bufmgr->backend->bo_get_flags(bo);
1026 flags = TBM_BO_DEFAULT;
1029 _tbm_bo_init(bufmgr, bo, flags);
1031 TBM_TRACE_BO("import new bo(%p) ref(%d) key(%d) flag(%s) in list\n",
1032 bo, bo->ref_cnt, key, _tbm_flag_to_str(bo->flags));
1034 _tbm_bufmgr_mutex_unlock();
1040 _tbm_bufmgr_mutex_unlock();
1045 tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
1050 tbm_backend_bo_data *bo_data;
1054 _tbm_bufmgr_mutex_lock();
1055 _tbm_set_last_result(TBM_ERROR_NONE);
1057 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
1059 if (!bufmgr->use_hal_tbm) {
1060 if (bufmgr->backend_module_data) {
1061 if (!bufmgr->bufmgr_func->bufmgr_import_fd) {
1062 /* LCOV_EXCL_START */
1063 _tbm_bufmgr_mutex_unlock();
1064 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
1066 /* LCOV_EXCL_STOP */
1069 if (!bufmgr->backend->bo_import_fd) {
1070 /* LCOV_EXCL_START */
1071 _tbm_bufmgr_mutex_unlock();
1072 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
1074 /* LCOV_EXCL_STOP */
1079 _tbm_util_check_bo_cnt(bufmgr);
1081 bo = calloc(1, sizeof(struct _tbm_bo));
1083 /* LCOV_EXCL_START */
1084 TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d)\n", fd);
1085 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
1086 _tbm_bufmgr_mutex_unlock();
1088 /* LCOV_EXCL_STOP */
1091 if (bufmgr->use_hal_tbm) {
1092 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_fd(bufmgr->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)&error);
1093 /* LCOV_EXCL_START */
1095 TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d). error(%d)\n", fd, error);
1096 _tbm_set_last_result(error);
1099 /* LCOV_EXCL_STOP */
1101 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
1102 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
1103 if (bo2->bo_data == bo_data) {
1104 TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n",
1105 bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags));
1108 _tbm_bufmgr_mutex_unlock();
1113 bo->bo_data = bo_data;
1114 } else if (bufmgr->backend_module_data) {
1115 bo_data = bufmgr->bufmgr_func->bufmgr_import_fd(bufmgr->bufmgr_data, fd, &error);
1117 /* LCOV_EXCL_START */
1118 TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d). error(%d)\n", fd, error);
1119 _tbm_set_last_result(error);
1121 /* LCOV_EXCL_STOP */
1124 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
1125 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
1126 if (bo2->bo_data == bo_data) {
1127 TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n",
1128 bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags));
1131 _tbm_bufmgr_mutex_unlock();
1136 bo->bo_data = bo_data;
1138 bo_priv = bufmgr->backend->bo_import_fd(bo, fd);
1140 /* LCOV_EXCL_START */
1141 TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d)\n", fd);
1142 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
1144 /* LCOV_EXCL_STOP */
1147 if (!LIST_IS_EMPTY(&bufmgr->bo_list)) {
1148 LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) {
1149 if (bo2->priv == bo_priv) {
1150 TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n",
1151 bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags));
1154 _tbm_bufmgr_mutex_unlock();
1162 if (bufmgr->use_hal_tbm) {
1163 flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
1164 if (error != TBM_ERROR_NONE) {
1165 TBM_ERR("fail to get the bo flags(memory_types)");
1166 _tbm_set_last_result(error);
1167 flags = TBM_BO_DEFAULT;
1169 } else if (bufmgr->backend_module_data) {
1170 flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error);
1171 if (error != TBM_ERROR_NONE) {
1172 TBM_ERR("fail to get the bo flags(memory_types)");
1173 _tbm_set_last_result(error);
1174 flags = TBM_BO_DEFAULT;
1177 if (bufmgr->backend->bo_get_flags)
1178 flags = bufmgr->backend->bo_get_flags(bo);
1180 flags = TBM_BO_DEFAULT;
1183 _tbm_bo_init(bufmgr, bo, flags);
1185 TBM_TRACE_BO("import bo(%p) ref(%d) fd(%d) flag(%s)\n",
1186 bo, bo->ref_cnt, fd, _tbm_flag_to_str(bo->flags));
1188 _tbm_bufmgr_mutex_unlock();
1194 _tbm_bufmgr_mutex_unlock();
1199 tbm_bo_size(tbm_bo bo)
1204 _tbm_bufmgr_mutex_lock();
1205 _tbm_set_last_result(TBM_ERROR_NONE);
1207 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1209 if (bo->bufmgr->use_hal_tbm) {
1210 size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
1211 if (error != TBM_ERROR_NONE) {
1212 TBM_ERR("fail to get the size of the bo_data(%d).", error);
1213 _tbm_set_last_result(TBM_ERROR_NONE);
1215 } else if (bo->bufmgr->backend_module_data) {
1216 size = bo->bufmgr->bo_func->bo_get_size(bo->bo_data, &error);
1217 if (error != TBM_ERROR_NONE) {
1218 TBM_ERR("fail to get the size of the bo_data(%d).", error);
1219 _tbm_set_last_result(TBM_ERROR_NONE);
1222 size = bo->bufmgr->backend->bo_size(bo);
1224 TBM_TRACE_BO("bo(%p) size(%d)\n", bo, size);
1226 _tbm_bufmgr_mutex_unlock();
1232 tbm_bo_locked(tbm_bo bo)
1234 _tbm_bufmgr_mutex_lock();
1235 _tbm_set_last_result(TBM_ERROR_NONE);
1237 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1239 if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER) {
1240 TBM_ERR("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1241 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
1242 _tbm_bufmgr_mutex_unlock();
1246 if (bo->lock_cnt > 0) {
1247 TBM_TRACE_BO("error: bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1248 _tbm_bufmgr_mutex_unlock();
1252 TBM_TRACE_BO("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
1253 _tbm_bufmgr_mutex_unlock();
1259 tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
1261 tbm_error_e error1, error2;
1262 int size1 = -1, size2 = -2;
1265 _tbm_bufmgr_mutex_lock();
1266 _tbm_set_last_result(TBM_ERROR_NONE);
1268 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo1), 0);
1269 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo2), 0);
1271 TBM_TRACE_BO("before: bo1(%p) bo2(%p)\n", bo1, bo2);
1273 if (bo1->bufmgr->use_hal_tbm) {
1274 size1 = hal_tbm_bo_get_size((hal_tbm_bo *)bo1->bo_data, (hal_tbm_error *)&error1);
1275 if (error1 != TBM_ERROR_NONE) {
1276 TBM_ERR("fail to get the size of bo1.(%d)", error1);
1277 _tbm_set_last_result(error1);
1280 size2 = hal_tbm_bo_get_size((hal_tbm_bo *)bo2->bo_data, (hal_tbm_error *)&error2);
1281 if (error2 != TBM_ERROR_NONE) {
1282 TBM_ERR("fail to get the size of bo1.(%d)", error2);
1283 _tbm_set_last_result(error2);
1286 } else if (bo1->bufmgr->backend_module_data) {
1287 size1 = bo1->bufmgr->bo_func->bo_get_size(bo1->bo_data, &error1);
1288 if (error1 != TBM_ERROR_NONE) {
1289 TBM_ERR("fail to get the size of bo1.(%d)", error1);
1290 _tbm_set_last_result(error1);
1293 size2 = bo2->bufmgr->bo_func->bo_get_size(bo2->bo_data, &error2);
1294 if (error2 != TBM_ERROR_NONE) {
1295 TBM_ERR("fail to get the size of bo2.(%d)", error2);
1296 _tbm_set_last_result(error2);
1300 size1 = bo1->bufmgr->backend->bo_size(bo1);
1301 size2 = bo2->bufmgr->backend->bo_size(bo2);
1304 if (size1 != size2) {
1305 TBM_ERR("error: bo1 size(%d) and bo2 size(%d) is different.", size1, size2);
1306 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
1310 TBM_TRACE_BO("after: bo1(%p) bo2(%p)\n", bo1, bo2);
1313 bo1->priv = bo2->priv;
1316 _tbm_bufmgr_mutex_unlock();
1321 TBM_ERR("error: bo1(%p) bo2(%p)\n", bo1, bo2);
1322 _tbm_bufmgr_mutex_unlock();
1328 tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
1329 tbm_data_free data_free_func)
1331 tbm_user_data *data;
1333 _tbm_bufmgr_mutex_lock();
1334 _tbm_set_last_result(TBM_ERROR_NONE);
1336 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1338 /* check if the data according to the key exist if so, return false. */
1339 data = user_data_lookup(&bo->user_data_list, key);
1341 TBM_TRACE_BO("warning: user data already exist key(%ld)\n", key);
1342 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1343 _tbm_bufmgr_mutex_unlock();
1347 data = user_data_create(key, data_free_func);
1349 TBM_ERR("error: bo(%p) key(%lu)\n", bo, key);
1350 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1351 _tbm_bufmgr_mutex_unlock();
1355 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, data->data);
1357 LIST_ADD(&data->item_link, &bo->user_data_list);
1359 _tbm_bufmgr_mutex_unlock();
1365 tbm_bo_delete_user_data(tbm_bo bo, unsigned long key)
1367 tbm_user_data *old_data;
1369 _tbm_bufmgr_mutex_lock();
1370 _tbm_set_last_result(TBM_ERROR_NONE);
1372 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1374 if (LIST_IS_EMPTY(&bo->user_data_list)) {
1375 TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
1376 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1377 _tbm_bufmgr_mutex_unlock();
1381 old_data = user_data_lookup(&bo->user_data_list, key);
1383 TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
1384 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1385 _tbm_bufmgr_mutex_unlock();
1389 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1391 user_data_delete(old_data);
1393 _tbm_bufmgr_mutex_unlock();
1399 tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data)
1401 tbm_user_data *old_data;
1403 _tbm_bufmgr_mutex_lock();
1404 _tbm_set_last_result(TBM_ERROR_NONE);
1406 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1408 if (LIST_IS_EMPTY(&bo->user_data_list)) {
1409 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
1410 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1411 _tbm_bufmgr_mutex_unlock();
1415 old_data = user_data_lookup(&bo->user_data_list, key);
1417 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
1418 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1419 _tbm_bufmgr_mutex_unlock();
1423 if (old_data->data && old_data->free_func)
1424 old_data->free_func(old_data->data);
1425 old_data->data = data;
1427 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1429 _tbm_bufmgr_mutex_unlock();
1435 tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data)
1437 tbm_user_data *old_data;
1439 _tbm_bufmgr_mutex_lock();
1440 _tbm_set_last_result(TBM_ERROR_NONE);
1442 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1444 if (!data || LIST_IS_EMPTY(&bo->user_data_list)) {
1445 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
1446 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1447 _tbm_bufmgr_mutex_unlock();
1451 old_data = user_data_lookup(&bo->user_data_list, key);
1454 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
1455 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
1456 _tbm_bufmgr_mutex_unlock();
1460 *data = old_data->data;
1462 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
1464 _tbm_bufmgr_mutex_unlock();
1470 tbm_bo_get_flags(tbm_bo bo)
1474 _tbm_bufmgr_mutex_lock();
1476 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1480 TBM_TRACE_BO("bo(%p)\n", bo);
1482 _tbm_bufmgr_mutex_unlock();
1487 /* LCOV_EXCL_START */
1488 /* internal function */
1490 _tbm_bo_set_surface(tbm_bo bo, tbm_surface_h surface)
1492 _tbm_bufmgr_mutex_lock();
1494 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
1496 bo->surface = surface;
1498 _tbm_bufmgr_mutex_unlock();
1504 _tbm_bo_free(tbm_bo bo)
1506 /* destory the user_data_list */
1507 if (!LIST_IS_EMPTY(&bo->user_data_list)) {
1508 tbm_user_data *old_data = NULL, *tmp;
1510 LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp,
1511 &bo->user_data_list, item_link) {
1512 TBM_DBG("free user_data\n");
1513 user_data_delete(old_data);
1517 while (bo->lock_cnt > 0) {
1518 TBM_ERR("error lock_cnt:%d\n", bo->lock_cnt);
1523 /* call the bo_free */
1524 if (bo->bufmgr->use_hal_tbm) {
1525 // call hal_tbm_bo_free when bo is created by tbm_bo_alloc api.
1526 if (!bo->get_from_hal_surface) {
1527 bo->get_from_hal_surface = 0;
1529 hal_tbm_bo_free(bo->bo_data);
1532 } else if (bo->bufmgr->backend_module_data) {
1533 bo->bufmgr->bo_func->bo_free(bo->bo_data);
1536 bo->bufmgr->backend->bo_free(bo);
1544 /* LCOV_EXCL_STOP */