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 if (bo->bufmgr->use_hal_tbm) {
547 ret = (hal_tbm_fd)hal_tbm_bo_export_fd((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error);
549 /* LCOV_EXCL_START */
550 TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error);
551 _tbm_set_last_result(error);
555 } else if (bo->bufmgr->backend_module_data) {
556 if (!bo->bufmgr->bo_func->bo_export_fd) {
557 /* LCOV_EXCL_START */
558 _tbm_bufmgr_mutex_unlock();
559 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
564 ret = bo->bufmgr->bo_func->bo_export_fd(bo->bo_data, &error);
566 /* LCOV_EXCL_START */
567 TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error);
568 _tbm_set_last_result(error);
573 if (!bo->bufmgr->backend->bo_export_fd) {
574 /* LCOV_EXCL_START */
575 _tbm_bufmgr_mutex_unlock();
576 _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
581 ret = bo->bufmgr->backend->bo_export_fd(bo);
583 /* LCOV_EXCL_START */
584 TBM_ERR("error: bo(%p) tbm_fd(%d)\n", bo, ret);
585 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
591 TBM_TRACE_BO("bo(%p) tbm_fd(%d)\n", bo, ret);
594 _tbm_bufmgr_mutex_unlock();
600 tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key)
605 _tbm_bufmgr_mutex_lock();
606 _tbm_set_last_result(TBM_ERROR_NONE);
608 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
610 bo = tbm_bufmgr_internal_import_bo_with_key(bufmgr, key, &error);
612 /* LCOV_EXCL_START */
613 TBM_ERR("tbm_bufmgr_internal_import_key failed. error:%d", error);
614 _tbm_set_last_result(error);
615 _tbm_bufmgr_mutex_unlock();
620 TBM_TRACE_BO("import new bo(%p) ref(%d) key(%d) flag(%s) in list\n",
621 bo, bo->ref_cnt, key, _tbm_flag_to_str(bo->flags));
623 _tbm_bufmgr_mutex_unlock();
629 tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd)
634 _tbm_bufmgr_mutex_lock();
635 _tbm_set_last_result(TBM_ERROR_NONE);
637 TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL);
639 bo = tbm_bufmgr_internal_import_bo_with_fd(bufmgr, fd, &error);
641 /* LCOV_EXCL_START */
642 TBM_ERR("tbm_bufmgr_internal_import_fd failed. error:%d", error);
643 _tbm_set_last_result(error);
644 _tbm_bufmgr_mutex_unlock();
649 LIST_INITHEAD(&bo->user_data_list); // TODO: remove this. build-break when it is removed.
651 TBM_TRACE_BO("import bo(%p) ref(%d) fd(%d) flag(%s)\n",
652 bo, bo->ref_cnt, fd, _tbm_flag_to_str(bo->flags));
654 _tbm_bufmgr_mutex_unlock();
660 tbm_bo_size(tbm_bo bo)
665 _tbm_bufmgr_mutex_lock();
666 _tbm_set_last_result(TBM_ERROR_NONE);
668 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
670 size = tbm_module_bo_get_size(bo->bufmgr->module, bo, bo->bo_data, &error);
671 _tbm_set_last_result(error);
673 TBM_TRACE_BO("bo(%p) size(%d)\n", bo, size);
675 _tbm_bufmgr_mutex_unlock();
681 tbm_bo_locked(tbm_bo bo)
683 _tbm_bufmgr_mutex_lock();
684 _tbm_set_last_result(TBM_ERROR_NONE);
686 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
688 if (bo->bufmgr->bo_lock_type == TBM_BUFMGR_BO_LOCK_TYPE_NEVER) {
689 TBM_ERR("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
690 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
691 _tbm_bufmgr_mutex_unlock();
695 if (bo->lock_cnt > 0) {
696 TBM_TRACE_BO("error: bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
697 _tbm_bufmgr_mutex_unlock();
701 TBM_TRACE_BO("bo(%p) lock_cnt(%d)\n", bo, bo->lock_cnt);
702 _tbm_bufmgr_mutex_unlock();
708 tbm_bo_swap(tbm_bo bo1, tbm_bo bo2)
710 tbm_error_e error1, error2;
711 int size1 = -1, size2 = -2;
714 _tbm_bufmgr_mutex_lock();
715 _tbm_set_last_result(TBM_ERROR_NONE);
717 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo1), 0);
718 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo2), 0);
720 TBM_TRACE_BO("before: bo1(%p) bo2(%p)\n", bo1, bo2);
722 size1 = tbm_module_bo_get_size(bo1->bufmgr->module, bo1, bo1->bo_data, &error1);
723 _tbm_set_last_result(error1);
724 size2 = tbm_module_bo_get_size(bo2->bufmgr->module, bo2, bo2->bo_data, &error2);
725 _tbm_set_last_result(error2);
727 if (size1 != size2) {
728 TBM_ERR("error: bo1 size(%d) and bo2 size(%d) is different.", size1, size2);
729 _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
733 TBM_TRACE_BO("after: bo1(%p) bo2(%p)\n", bo1, bo2);
736 bo1->priv = bo2->priv;
739 _tbm_bufmgr_mutex_unlock();
744 TBM_ERR("error: bo1(%p) bo2(%p)\n", bo1, bo2);
745 _tbm_bufmgr_mutex_unlock();
751 tbm_bo_add_user_data(tbm_bo bo, unsigned long key,
752 tbm_data_free data_free_func)
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 /* check if the data according to the key exist if so, return false. */
762 data = user_data_lookup(&bo->user_data_list, key);
764 TBM_TRACE_BO("warning: user data already exist key(%ld)\n", key);
765 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
766 _tbm_bufmgr_mutex_unlock();
770 data = user_data_create(key, data_free_func);
772 TBM_ERR("error: bo(%p) key(%lu)\n", bo, key);
773 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
774 _tbm_bufmgr_mutex_unlock();
778 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, data->data);
780 LIST_ADD(&data->item_link, &bo->user_data_list);
782 _tbm_bufmgr_mutex_unlock();
788 tbm_bo_delete_user_data(tbm_bo bo, unsigned long key)
790 tbm_user_data *old_data;
792 _tbm_bufmgr_mutex_lock();
793 _tbm_set_last_result(TBM_ERROR_NONE);
795 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
797 if (LIST_IS_EMPTY(&bo->user_data_list)) {
798 TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
799 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
800 _tbm_bufmgr_mutex_unlock();
804 old_data = user_data_lookup(&bo->user_data_list, key);
806 TBM_TRACE_BO("bo(%p) key(%lu)\n", bo, key);
807 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
808 _tbm_bufmgr_mutex_unlock();
812 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
814 user_data_delete(old_data);
816 _tbm_bufmgr_mutex_unlock();
822 tbm_bo_set_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 (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);
840 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
841 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
842 _tbm_bufmgr_mutex_unlock();
846 if (old_data->data && old_data->free_func)
847 old_data->free_func(old_data->data);
848 old_data->data = data;
850 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
852 _tbm_bufmgr_mutex_unlock();
858 tbm_bo_get_user_data(tbm_bo bo, unsigned long key, void **data)
860 tbm_user_data *old_data;
862 _tbm_bufmgr_mutex_lock();
863 _tbm_set_last_result(TBM_ERROR_NONE);
865 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
867 if (!data || LIST_IS_EMPTY(&bo->user_data_list)) {
868 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
869 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
870 _tbm_bufmgr_mutex_unlock();
874 old_data = user_data_lookup(&bo->user_data_list, key);
877 TBM_TRACE_BO("error: bo(%p) key(%lu)\n", bo, key);
878 _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
879 _tbm_bufmgr_mutex_unlock();
883 *data = old_data->data;
885 TBM_TRACE_BO("bo(%p) key(%lu) data(%p)\n", bo, key, old_data->data);
887 _tbm_bufmgr_mutex_unlock();
893 tbm_bo_get_flags(tbm_bo bo)
897 _tbm_bufmgr_mutex_lock();
899 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
903 TBM_TRACE_BO("bo(%p)\n", bo);
905 _tbm_bufmgr_mutex_unlock();
910 /* LCOV_EXCL_START */
911 /* internal function */
913 _tbm_bo_set_surface(tbm_bo bo, tbm_surface_h surface)
915 _tbm_bufmgr_mutex_lock();
917 TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0);
919 bo->surface = surface;
921 _tbm_bufmgr_mutex_unlock();
927 _tbm_bo_free(tbm_bo bo)
929 /* destory the user_data_list */
930 if (!LIST_IS_EMPTY(&bo->user_data_list)) {
931 tbm_user_data *old_data = NULL, *tmp;
933 LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp,
934 &bo->user_data_list, item_link) {
935 TBM_DBG("free user_data\n");
936 user_data_delete(old_data);
940 while (bo->lock_cnt > 0) {
941 TBM_ERR("error lock_cnt:%d\n", bo->lock_cnt);
946 tbm_module_bo_free(bo->bufmgr->module, bo, bo->bo_data, bo->get_from_hal_surface);