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"
38 #define TBM_BO_RETURN_IF_FAIL(cond) {\
40 TBM_ERR("'%s' failed.\n", #cond);\
41 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
42 _tbm_bufmgr_mutex_unlock();\
47 #define TBM_BO_RETURN_VAL_IF_FAIL(cond, val) {\
49 TBM_ERR("'%s' failed.\n", #cond);\
50 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
51 _tbm_bufmgr_mutex_unlock();\
57 _tbm_flag_to_str(int f)
61 if (f == TBM_BO_DEFAULT)
62 snprintf(str, 255, "DEFAULT");
66 if (f & TBM_BO_SCANOUT)
67 c += snprintf(&str[c], 255-c, "SCANOUT");
69 if (f & TBM_BO_NONCACHABLE) {
70 if (c >= 0 && c < 255)
71 c += snprintf(&str[c], 255-c, ", ");
73 if (c >= 0 && c < 255)
74 c += snprintf(&str[c], 255-c, "NONCACHABLE,");
78 if (c >= 0 && c < 255)
79 c += snprintf(&str[c], 255-c, ", ");
81 if (c >= 0 && c < 255)
82 c += snprintf(&str[c], 255-c, "WC");
92 user_data_lookup(struct list_head *user_data_list, unsigned long key)
94 tbm_user_data *old_data = NULL;
96 if (LIST_IS_EMPTY(user_data_list))
99 LIST_FOR_EACH_ENTRY(old_data, user_data_list, item_link) {
100 if (old_data->key == key)
108 user_data_create(unsigned long key, tbm_data_free data_free_func)
110 tbm_user_data *user_data;
112 user_data = calloc(1, sizeof(tbm_user_data));
114 /* LCOV_EXCL_START */
115 TBM_ERR("fail to allocate an user_date\n");
116 _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
121 user_data->key = key;
122 user_data->free_func = data_free_func;
128 user_data_delete(tbm_user_data *user_data)
130 if (user_data->data && user_data->free_func)
131 user_data->free_func(user_data->data);
133 LIST_DEL(&user_data->item_link);
139 _bo_lock(tbm_bo bo, int device, int opt)
144 error = tbm_module_bo_lock(bo->bufmgr->module, bo, bo->bo_data, device, opt);
145 _tbm_set_last_result(error);
150 case TBM_ERROR_NOT_SUPPORTED:
152 _tbm_set_last_result(TBM_ERROR_NONE);
156 TBM_WRN("fail to lock. error:%d", error);
164 _bo_unlock(tbm_bo bo)
168 error = tbm_module_bo_unlock(bo->bufmgr->module, bo, bo->bo_data);
169 _tbm_set_last_result(error);
173 case TBM_ERROR_NOT_SUPPORTED:
174 _tbm_set_last_result(TBM_ERROR_NONE);
177 TBM_WRN("fail to lock. error:%d", error);
183 _tbm_bo_lock(tbm_bo bo, int device, int opt)
190 /* do not try to lock the bo */
191 if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER)
194 if (bo->lock_cnt < 0) {
195 TBM_ERR("error bo:%p LOCK_CNT=%d\n",
202 switch (bo->bufmgr->bo_lock_type) {
203 case TBM_BUFMGR_BO_LOCK_TYPE_ONCE:
204 if (bo->lock_cnt == 0) {
205 _tbm_bufmgr_mutex_unlock();
206 ret = _bo_lock(bo, device, opt);
207 _tbm_bufmgr_mutex_lock();
213 case TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS:
214 _tbm_bufmgr_mutex_unlock();
215 ret = _bo_lock(bo, device, opt);
216 _tbm_bufmgr_mutex_lock();
221 TBM_ERR("error bo:%p bo_lock_type[%d] is wrong.\n",
222 bo, bo->bufmgr->bo_lock_type);
227 TBM_DBG(">> LOCK bo:%p(%d->%d)\n", bo, old, bo->lock_cnt);
233 _tbm_bo_unlock(tbm_bo bo)
237 /* do not try to unlock the bo */
238 if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER)
243 switch (bo->bufmgr->bo_lock_type) {
244 case TBM_BUFMGR_BO_LOCK_TYPE_ONCE:
245 if (bo->lock_cnt > 0) {
247 if (bo->lock_cnt == 0)
251 case TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS:
252 if (bo->lock_cnt > 0) {
258 TBM_ERR("error bo:%p bo_lock_type[%d] is wrong.\n",
259 bo, bo->bufmgr->bo_lock_type);
263 if (bo->lock_cnt < 0)
266 TBM_DBG(">> UNLOCK bo:%p(%d->%d)\n", bo, old, bo->lock_cnt);
270 _tbm_bo_magic_check(tbm_bo bo)
272 if (bo->magic != TBM_BO_MAGIC)
279 _tbm_bo_is_valid(tbm_bo bo)
282 TBM_ERR("error: bo is NULL.\n");
286 if (!_tbm_bo_magic_check(bo)) {
287 TBM_ERR("error: No valid bo(%p).\n", bo);
295 _tbm_bo_deinit(tbm_bo bo)
299 bo->bufmgr->bo_cnt--;
300 LIST_DEL(&bo->item_link);
304 tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags)
309 _tbm_bufmgr_mutex_lock();
310 _tbm_set_last_result(TBM_ERROR_NONE);
312 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
313 TBM_BO_RETURN_VAL_IF_FAIL(size > 0, NULL);
315 bo = tbm_bufmgr_internal_alloc_bo(bufmgr, size, flags, &error);
317 /* LCOV_EXCL_START */
318 TBM_ERR("tbm_bufmgr_internal_alloc_bo failed. error:%d", error);
319 _tbm_set_last_result(error);
320 _tbm_bufmgr_mutex_unlock();
325 TBM_TRACE_BO("bo(%p) size(%d) refcnt(%d), flag(%s)\n", bo, size, bo->ref_cnt,
326 _tbm_flag_to_str(bo->flags));
328 _tbm_bufmgr_mutex_unlock();
334 tbm_bo_ref(tbm_bo bo)
336 _tbm_bufmgr_mutex_lock();
337 _tbm_set_last_result(TBM_ERROR_NONE);
339 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), NULL);
343 TBM_TRACE_BO("bo(%p) ref_cnt(%d)\n", bo, bo->ref_cnt);
345 _tbm_bufmgr_mutex_unlock();
351 tbm_bo_unref(tbm_bo bo)
353 _tbm_bufmgr_mutex_lock();
354 _tbm_set_last_result(TBM_ERROR_NONE);
356 TBM_BO_RETURN_IF_FAIL(_tbm_bo_is_valid(bo));
358 TBM_TRACE_BO("bo(%p) ref_cnt(%d)\n", bo, bo->ref_cnt - 1);
360 if (bo->ref_cnt <= 0) {
361 _tbm_bufmgr_mutex_unlock();
366 if (bo->ref_cnt == 0)
369 _tbm_bufmgr_mutex_unlock();
373 tbm_bo_map(tbm_bo bo, int device, int opt)
375 tbm_bo_handle bo_handle;
378 _tbm_bufmgr_mutex_lock();
379 _tbm_set_last_result(TBM_ERROR_NONE);
381 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
383 if (!_tbm_bo_lock(bo, device, opt)) {
384 TBM_ERR("error: fail to lock bo:%p)\n", bo);
385 _tbm_bufmgr_mutex_unlock();
386 return (tbm_bo_handle) NULL;
389 bo_handle = tbm_module_bo_map(bo->bufmgr->module, bo, bo->bo_data, device, opt, &error);
390 if (bo_handle.ptr == NULL) {
391 /* LCOV_EXCL_START */
392 TBM_ERR("error: fail to map bo:%p error:%d\n", bo, error);
393 _tbm_set_last_result(error);
395 _tbm_bufmgr_mutex_unlock();
396 return (tbm_bo_handle) NULL;
400 /* increase the map_count */
403 TBM_TRACE_BO("bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
405 _tbm_bufmgr_mutex_unlock();
411 tbm_bo_unmap(tbm_bo bo)
415 _tbm_bufmgr_mutex_lock();
416 _tbm_set_last_result(TBM_ERROR_NONE);
418 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
419 TBM_BO_RETURN_VAL_IF_FAIL(bo->map_cnt > 0, 0);
421 error = tbm_module_bo_unmap(bo->bufmgr->module, bo, bo->bo_data);
422 if (error != TBM_ERROR_NONE) {
423 /* LCOV_EXCL_START */
424 TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error);
425 _tbm_set_last_result(error);
426 _tbm_bufmgr_mutex_unlock();
431 /* decrease the map_count */
434 TBM_TRACE_BO("bo(%p) map_cnt(%d)\n", bo, bo->map_cnt);
438 _tbm_bufmgr_mutex_unlock();
444 tbm_bo_get_handle(tbm_bo bo, int device)
446 tbm_bo_handle bo_handle;
449 _tbm_bufmgr_mutex_lock();
450 _tbm_set_last_result(TBM_ERROR_NONE);
452 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL);
454 bo_handle = tbm_module_bo_get_handle(bo->bufmgr->module, bo, bo->bo_data, device, &error);
455 if (bo_handle.ptr == NULL) {
456 /* LCOV_EXCL_START */
457 TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, bo_handle.ptr, error);
458 _tbm_set_last_result(error);
459 _tbm_bufmgr_mutex_unlock();
460 return (tbm_bo_handle)NULL;
464 TBM_TRACE_BO("bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr);
466 _tbm_bufmgr_mutex_unlock();
472 tbm_bo_export(tbm_bo bo)
477 _tbm_bufmgr_mutex_lock();
478 _tbm_set_last_result(TBM_ERROR_NONE);
480 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
482 if (bo->bufmgr->use_hal_tbm) {
483 ret = (hal_tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
485 /* LCOV_EXCL_START */
486 TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error);
487 _tbm_set_last_result(error);
491 } else if (bo->bufmgr->backend_module_data) {
492 if (!bo->bufmgr->bo_func->bo_export_key) {
493 /* LCOV_EXCL_START */
494 _tbm_bufmgr_mutex_unlock();
495 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
500 ret = bo->bufmgr->bo_func->bo_export_key(bo->bo_data, &error);
502 /* LCOV_EXCL_START */
503 TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error);
504 _tbm_set_last_result(error);
509 if (!bo->bufmgr->backend->bo_export) {
510 /* LCOV_EXCL_START */
511 _tbm_bufmgr_mutex_unlock();
512 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
517 ret = bo->bufmgr->backend->bo_export(bo);
519 /* LCOV_EXCL_START */
520 TBM_ERR("error: bo(%p) tbm_key(%d)\n", bo, ret);
521 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
527 TBM_TRACE_BO("bo(%p) tbm_key(%u)\n", bo, ret);
530 _tbm_bufmgr_mutex_unlock();
536 tbm_bo_export_fd(tbm_bo bo)
541 _tbm_bufmgr_mutex_lock();
542 _tbm_set_last_result(TBM_ERROR_NONE);
544 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), -1);
546 fd = tbm_module_bo_export_fd(bo->bufmgr->module, bo, bo->bo_data, &error);
548 /* LCOV_EXCL_START */
549 TBM_ERR("tbm_module_bo_export_fd filed. bo:%p tbm_fd:%d error:%d", bo, fd, error);
550 _tbm_set_last_result(error);
551 _tbm_bufmgr_mutex_unlock();
556 TBM_TRACE_BO("bo:%p tbm_fd:%d", bo, fd);
558 _tbm_bufmgr_mutex_unlock();
564 tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
569 _tbm_bufmgr_mutex_lock();
570 _tbm_set_last_result(TBM_ERROR_NONE);
572 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
574 bo = tbm_bufmgr_internal_import_bo_with_key(bufmgr, key, &error);
576 /* LCOV_EXCL_START */
577 TBM_ERR("tbm_bufmgr_internal_import_key failed. error:%d", error);
578 _tbm_set_last_result(error);
579 _tbm_bufmgr_mutex_unlock();
584 TBM_TRACE_BO("import new bo(%p) ref(%d) key(%d) flag(%s) in list\n",
585 bo, bo->ref_cnt, key, _tbm_flag_to_str(bo->flags));
587 _tbm_bufmgr_mutex_unlock();
593 tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
598 _tbm_bufmgr_mutex_lock();
599 _tbm_set_last_result(TBM_ERROR_NONE);
601 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
603 bo = tbm_bufmgr_internal_import_bo_with_fd(bufmgr, fd, &error);
605 /* LCOV_EXCL_START */
606 TBM_ERR("tbm_bufmgr_internal_import_fd failed. error:%d", error);
607 _tbm_set_last_result(error);
608 _tbm_bufmgr_mutex_unlock();
613 LIST_INITHEAD(&bo->user_data_list); // TODO: remove this. build-break when it is removed.
615 TBM_TRACE_BO("import bo(%p) ref(%d) fd(%d) flag(%s)\n",
616 bo, bo->ref_cnt, fd, _tbm_flag_to_str(bo->flags));
618 _tbm_bufmgr_mutex_unlock();
624 tbm_bo_size(tbm_bo bo)
629 _tbm_bufmgr_mutex_lock();
630 _tbm_set_last_result(TBM_ERROR_NONE);
632 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
634 size = tbm_module_bo_get_size(bo->bufmgr->module, bo, bo->bo_data, &error);
635 _tbm_set_last_result(error);
637 TBM_TRACE_BO("bo(%p) size(%d)\n", bo, size);
639 _tbm_bufmgr_mutex_unlock();
645 tbm_bo_locked(tbm_bo bo)
647 _tbm_bufmgr_mutex_lock();
648 _tbm_set_last_result(TBM_ERROR_NONE);
650 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
652 if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER) {
653 TBM_ERR("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
654 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
655 _tbm_bufmgr_mutex_unlock();
659 if (bo->lock_cnt > 0) {
660 TBM_TRACE_BO("error: bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
661 _tbm_bufmgr_mutex_unlock();
665 TBM_TRACE_BO("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
666 _tbm_bufmgr_mutex_unlock();
672 tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
674 tbm_error_e error1, error2;
675 int size1 = -1, size2 = -2;
678 _tbm_bufmgr_mutex_lock();
679 _tbm_set_last_result(TBM_ERROR_NONE);
681 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo1), 0);
682 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo2), 0);
684 TBM_TRACE_BO("before: bo1(%p) bo2(%p)\n", bo1, bo2);
686 size1 = tbm_module_bo_get_size(bo1->bufmgr->module, bo1, bo1->bo_data, &error1);
687 _tbm_set_last_result(error1);
688 size2 = tbm_module_bo_get_size(bo2->bufmgr->module, bo2, bo2->bo_data, &error2);
689 _tbm_set_last_result(error2);
691 if (size1 != size2) {
692 TBM_ERR("error: bo1 size(%d) and bo2 size(%d) is different.", size1, size2);
693 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
697 TBM_TRACE_BO("after: bo1(%p) bo2(%p)\n", bo1, bo2);
700 bo1->priv = bo2->priv;
703 _tbm_bufmgr_mutex_unlock();
708 TBM_ERR("error: bo1(%p) bo2(%p)\n", bo1, bo2);
709 _tbm_bufmgr_mutex_unlock();
715 tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
716 tbm_data_free data_free_func)
720 _tbm_bufmgr_mutex_lock();
721 _tbm_set_last_result(TBM_ERROR_NONE);
723 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
725 /* check if the data according to the key exist if so, return false. */
726 data = user_data_lookup(&bo->user_data_list, key);
728 TBM_TRACE_BO("warning: user data already exist key(%ld)\n", key);
729 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
730 _tbm_bufmgr_mutex_unlock();
734 data = user_data_create(key, data_free_func);
736 TBM_ERR("error: bo(%p) key(%lu)\n", bo, key);
737 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
738 _tbm_bufmgr_mutex_unlock();
742 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, data->data);
744 LIST_ADD(&data->item_link, &bo->user_data_list);
746 _tbm_bufmgr_mutex_unlock();
752 tbm_bo_delete_user_data(tbm_bo bo, unsigned long key)
754 tbm_user_data *old_data;
756 _tbm_bufmgr_mutex_lock();
757 _tbm_set_last_result(TBM_ERROR_NONE);
759 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
761 if (LIST_IS_EMPTY(&bo->user_data_list)) {
762 TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
763 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
764 _tbm_bufmgr_mutex_unlock();
768 old_data = user_data_lookup(&bo->user_data_list, key);
770 TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
771 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
772 _tbm_bufmgr_mutex_unlock();
776 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
778 user_data_delete(old_data);
780 _tbm_bufmgr_mutex_unlock();
786 tbm_bo_set_user_data(tbm_bo bo, unsigned long key, void *data)
788 tbm_user_data *old_data;
790 _tbm_bufmgr_mutex_lock();
791 _tbm_set_last_result(TBM_ERROR_NONE);
793 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
795 if (LIST_IS_EMPTY(&bo->user_data_list)) {
796 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
797 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
798 _tbm_bufmgr_mutex_unlock();
802 old_data = user_data_lookup(&bo->user_data_list, key);
804 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
805 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
806 _tbm_bufmgr_mutex_unlock();
810 if (old_data->data && old_data->free_func)
811 old_data->free_func(old_data->data);
812 old_data->data = data;
814 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
816 _tbm_bufmgr_mutex_unlock();
822 tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data)
824 tbm_user_data *old_data;
826 _tbm_bufmgr_mutex_lock();
827 _tbm_set_last_result(TBM_ERROR_NONE);
829 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
831 if (!data || LIST_IS_EMPTY(&bo->user_data_list)) {
832 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
833 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
834 _tbm_bufmgr_mutex_unlock();
838 old_data = user_data_lookup(&bo->user_data_list, key);
841 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
842 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
843 _tbm_bufmgr_mutex_unlock();
847 *data = old_data->data;
849 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
851 _tbm_bufmgr_mutex_unlock();
857 tbm_bo_get_flags(tbm_bo bo)
861 _tbm_bufmgr_mutex_lock();
863 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
867 TBM_TRACE_BO("bo(%p)\n", bo);
869 _tbm_bufmgr_mutex_unlock();
874 /* LCOV_EXCL_START */
875 /* internal function */
877 _tbm_bo_set_surface(tbm_bo bo, tbm_surface_h surface)
879 _tbm_bufmgr_mutex_lock();
881 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
883 bo->surface = surface;
885 _tbm_bufmgr_mutex_unlock();
891 _tbm_bo_free(tbm_bo bo)
893 /* destory the user_data_list */
894 if (!LIST_IS_EMPTY(&bo->user_data_list)) {
895 tbm_user_data *old_data = NULL, *tmp;
897 LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp,
898 &bo->user_data_list, item_link) {
899 TBM_DBG("free user_data\n");
900 user_data_delete(old_data);
904 while (bo->lock_cnt > 0) {
905 TBM_ERR("error lock_cnt:%d\n", bo->lock_cnt);
910 tbm_module_bo_free(bo->bufmgr->module, bo, bo->bo_data, bo->get_from_hal_surface);