1 /**************************************************************************
5 * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
7 * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
8 * JinYoung Jeon <jy0.jeon@samsung.com>,
9 * Taeheon Kim <th908.kim@samsung.com>,
10 * YoungJun Cho <yj44.cho@samsung.com>,
11 * SooChan Lim <sc1.lim@samsung.com>,
12 * Boram Park <sc1.lim@samsung.com>
14 * Permission is hereby granted, free of charge, to any person obtaining a
15 * copy of this software and associated documentation files (the
16 * "Software"), to deal in the Software without restriction, including
17 * without limitation the rights to use, copy, modify, merge, publish,
18 * distribute, sub license, and/or sell copies of the Software, and to
19 * permit persons to whom the Software is furnished to do so, subject to
20 * the following conditions:
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
27 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
29 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
30 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
31 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
32 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 **************************************************************************/
41 #include "tdm_backend.h"
42 #include "tdm_private.h"
43 #include "tdm_helper.h"
45 #define PP_FUNC_ENTRY() \
46 tdm_func_pp *func_pp; \
47 tdm_private_display *private_display; \
48 tdm_private_pp *private_pp; \
49 tdm_error ret = TDM_ERROR_NONE; \
50 TDM_RETURN_VAL_IF_FAIL(pp != NULL, TDM_ERROR_INVALID_PARAMETER); \
51 private_pp = (tdm_private_pp*)pp; \
52 private_display = private_pp->private_display; \
53 func_pp = &private_display->func_pp
56 _tdm_pp_print_list(struct list_head *list)
58 tdm_pp_private_buffer *b = NULL;
60 int len = sizeof(str);
62 TDM_RETURN_IF_FAIL(list != NULL);
65 LIST_FOR_EACH_ENTRY(b, list, link) {
67 int l = snprintf(p, len, " (%p,%p)", b->src, b->dst);
74 TDM_INFO("\t %s", str);
77 static tdm_pp_private_buffer *
78 _tdm_pp_find_tbm_buffers(struct list_head *list, tbm_surface_h src, tbm_surface_h dst)
80 tdm_pp_private_buffer *b = NULL, *bb = NULL;
82 LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
83 if (b->src == src && b->dst == dst)
90 static tdm_pp_private_buffer *
91 _tdm_pp_find_buffer(struct list_head *list, tdm_pp_private_buffer *pp_buffer)
93 tdm_pp_private_buffer *b = NULL, *bb = NULL;
95 LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
104 tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst,
107 tdm_private_pp *private_pp = user_data;
108 tdm_private_display *private_display = private_pp->private_display;
109 tdm_pp_private_buffer *pp_buffer = NULL, *first_entry = NULL;
111 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
113 if (private_pp->owner_tid != syscall(SYS_gettid)) {
114 tdm_thread_cb_pp_done pp_done;
117 pp_done.base.type = TDM_THREAD_CB_PP_DONE;
118 pp_done.base.length = sizeof pp_done;
119 pp_done.pp_stamp = private_pp->stamp;
122 pp_done.user_data = user_data;
124 ret = tdm_thread_send_cb(private_display->private_loop, &pp_done.base);
125 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
130 if (private_pp->owner_tid != syscall(SYS_gettid))
131 TDM_NEVER_GET_HERE();
133 if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
134 char str[TDM_PATH_LEN];
136 snprintf(str, TDM_PATH_LEN, "pp_dst_%03d", i++);
137 tdm_helper_dump_buffer_str(dst, str);
140 if (tdm_debug_module & TDM_DEBUG_BUFFER)
141 TDM_INFO("pp(%p) done: src(%p) dst(%p)", private_pp, src, dst);
143 if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
144 first_entry = container_of((&private_pp->buffer_list)->next, pp_buffer, link);
145 if (first_entry->src != src || first_entry->dst != dst)
146 TDM_ERR("buffer(%p,%p) is skipped", first_entry->src, first_entry->dst);
148 TDM_NEVER_GET_HERE();
151 if ((pp_buffer = _tdm_pp_find_tbm_buffers(&private_pp->buffer_list, src, dst))) {
152 LIST_DEL(&pp_buffer->link);
154 _pthread_mutex_unlock(&private_display->lock);
155 tdm_buffer_unref_backend(src);
156 tdm_buffer_unref_backend(dst);
157 _pthread_mutex_lock(&private_display->lock);
163 INTERN tdm_private_pp *
164 tdm_pp_find_stamp(tdm_private_display *private_display, unsigned long stamp)
166 tdm_private_pp *private_pp = NULL;
168 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
170 LIST_FOR_EACH_ENTRY(private_pp, &private_display->pp_list, link) {
171 if (private_pp->stamp == stamp)
178 INTERN tdm_private_pp *
179 tdm_pp_create_internal(tdm_private_display *private_display, tdm_error *error)
181 tdm_func_display *func_display;
182 tdm_func_pp *func_pp;
183 tdm_private_pp *private_pp = NULL;
184 tdm_pp *pp_backend = NULL;
185 tdm_error ret = TDM_ERROR_NONE;
187 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
189 func_display = &private_display->func_display;
190 func_pp = &private_display->func_pp;
192 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
193 TDM_ERR("no pp capability");
195 *error = TDM_ERROR_NO_CAPABILITY;
199 pp_backend = func_display->display_create_pp(private_display->bdata, &ret);
200 if (ret != TDM_ERROR_NONE) {
206 private_pp = calloc(1, sizeof(tdm_private_pp));
208 TDM_ERR("failed: alloc memory");
209 func_pp->pp_destroy(pp_backend);
211 *error = TDM_ERROR_OUT_OF_MEMORY;
215 ret = func_pp->pp_set_done_handler(pp_backend, tdm_pp_cb_done, private_pp);
216 if (ret != TDM_ERROR_NONE) {
217 TDM_ERR("spp(%p) et pp_done_handler failed", private_pp);
218 func_pp->pp_destroy(pp_backend);
224 private_pp->stamp = tdm_helper_get_time_in_millis();
225 while (tdm_pp_find_stamp(private_display, private_pp->stamp))
228 LIST_ADD(&private_pp->link, &private_display->pp_list);
229 private_pp->private_display = private_display;
230 private_pp->pp_backend = pp_backend;
231 private_pp->owner_tid = syscall(SYS_gettid);
233 LIST_INITHEAD(&private_pp->pending_buffer_list);
234 LIST_INITHEAD(&private_pp->buffer_list);
237 *error = TDM_ERROR_NONE;
243 tdm_pp_destroy_internal(tdm_private_pp *private_pp)
245 tdm_private_display *private_display;
246 tdm_func_pp *func_pp;
247 tdm_pp_private_buffer *b = NULL, *bb = NULL;
249 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
254 private_display = private_pp->private_display;
255 func_pp = &private_display->func_pp;
257 LIST_DEL(&private_pp->link);
259 func_pp->pp_destroy(private_pp->pp_backend);
261 if (!LIST_IS_EMPTY(&private_pp->pending_buffer_list)) {
262 TDM_WRN("pp(%p) not finished:", private_pp);
263 _tdm_pp_print_list(&private_pp->pending_buffer_list);
265 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->pending_buffer_list, link) {
270 if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
271 TDM_WRN("pp(%p) not finished:", private_pp);
272 _tdm_pp_print_list(&private_pp->buffer_list);
274 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->buffer_list, link) {
276 _pthread_mutex_unlock(&private_display->lock);
277 tdm_buffer_unref_backend(b->src);
278 tdm_buffer_unref_backend(b->dst);
279 _pthread_mutex_lock(&private_display->lock);
283 private_pp->stamp = 0;
288 tdm_pp_destroy(tdm_pp *pp)
290 tdm_private_pp *private_pp = pp;
291 tdm_private_display *private_display;
296 private_display = private_pp->private_display;
298 _pthread_mutex_lock(&private_display->lock);
299 tdm_pp_destroy_internal(private_pp);
300 _pthread_mutex_unlock(&private_display->lock);
304 tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info)
308 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
310 _pthread_mutex_lock(&private_display->lock);
312 if (!func_pp->pp_set_info) {
313 _pthread_mutex_unlock(&private_display->lock);
314 TDM_DBG("failed: not implemented!!");
315 return TDM_ERROR_NOT_IMPLEMENTED;
318 TDM_INFO("pp(%p) info: src(%dx%d %d,%d %dx%d %c%c%c%c) dst(%dx%d %d,%d %dx%d %c%c%c%c) trans(%d) sync(%d) flags(%x)",
319 private_pp, info->src_config.size.h, info->src_config.size.v,
320 info->src_config.pos.x, info->src_config.pos.y,
321 info->src_config.pos.w, info->src_config.pos.h,
322 FOURCC_STR(info->src_config.format),
323 info->dst_config.size.h, info->dst_config.size.v,
324 info->dst_config.pos.x, info->dst_config.pos.y,
325 info->dst_config.pos.w, info->dst_config.pos.h,
326 FOURCC_STR(info->dst_config.format),
327 info->transform, info->sync, info->flags);
329 ret = func_pp->pp_set_info(private_pp->pp_backend, info);
330 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
332 private_pp->info = *info;
334 _pthread_mutex_unlock(&private_display->lock);
340 tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
342 tdm_pp_private_buffer *pp_buffer;
346 TDM_RETURN_VAL_IF_FAIL(src != NULL, TDM_ERROR_INVALID_PARAMETER);
347 TDM_RETURN_VAL_IF_FAIL(dst != NULL, TDM_ERROR_INVALID_PARAMETER);
349 _pthread_mutex_lock(&private_display->lock);
351 if (!func_pp->pp_attach) {
352 _pthread_mutex_unlock(&private_display->lock);
353 TDM_DBG("failed: not implemented!!");
354 return TDM_ERROR_NOT_IMPLEMENTED;
357 if (tdm_display_check_module_abi(private_display, 1, 2) &&
358 private_display->caps_pp.max_attach_count > 0) {
359 int length = LIST_LENGTH(&private_pp->pending_buffer_list) +
360 LIST_LENGTH(&private_pp->buffer_list);
361 if (length >= private_display->caps_pp.max_attach_count) {
362 _pthread_mutex_unlock(&private_display->lock);
363 TDM_DBG("failed: too many attached!! max_attach_count(%d)",
364 private_display->caps_pp.max_attach_count);
365 return TDM_ERROR_BAD_REQUEST;
369 if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
370 char str[TDM_PATH_LEN];
372 snprintf(str, TDM_PATH_LEN, "pp_src_%03d", i++);
373 tdm_helper_dump_buffer_str(src, str);
376 pp_buffer = calloc(1, sizeof *pp_buffer);
378 _pthread_mutex_unlock(&private_display->lock);
379 TDM_ERR("alloc failed");
380 return TDM_ERROR_OUT_OF_MEMORY;
383 ret = func_pp->pp_attach(private_pp->pp_backend, src, dst);
384 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
386 if (ret != TDM_ERROR_NONE) {
388 _pthread_mutex_unlock(&private_display->lock);
389 TDM_ERR("attach failed");
393 LIST_ADDTAIL(&pp_buffer->link, &private_pp->pending_buffer_list);
394 pp_buffer->src = tdm_buffer_ref_backend(src);
395 pp_buffer->dst = tdm_buffer_ref_backend(dst);
397 if (tdm_debug_module & TDM_DEBUG_BUFFER) {
398 TDM_INFO("pp(%p) attached:", private_pp);
399 _tdm_pp_print_list(&private_pp->pending_buffer_list);
402 _pthread_mutex_unlock(&private_display->lock);
408 tdm_pp_commit(tdm_pp *pp)
410 tdm_pp_private_buffer *b = NULL, *bb = NULL;
411 struct list_head commit_buffer_list;
415 _pthread_mutex_lock(&private_display->lock);
417 if (!func_pp->pp_commit) {
418 _pthread_mutex_unlock(&private_display->lock);
419 TDM_DBG("failed: not implemented!!");
420 return TDM_ERROR_NOT_IMPLEMENTED;
423 LIST_INITHEAD(&commit_buffer_list);
425 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->pending_buffer_list, link) {
427 LIST_ADDTAIL(&b->link, &private_pp->buffer_list);
428 LIST_ADDTAIL(&b->commit_link, &commit_buffer_list);
431 ret = func_pp->pp_commit(private_pp->pp_backend);
432 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
434 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
435 if (!_tdm_pp_find_buffer(&private_pp->buffer_list, b))
438 LIST_DEL(&b->commit_link);
440 if (ret != TDM_ERROR_NONE) {
441 tdm_buffer_unref_backend(b->src);
442 tdm_buffer_unref_backend(b->dst);
447 _pthread_mutex_unlock(&private_display->lock);