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 **************************************************************************/
40 #include <sys/socket.h>
43 #include "tdm_private.h"
46 static tdm_private_thread *keep_private_thread;
48 struct _tdm_private_thread {
49 tdm_private_loop *private_loop;
51 pthread_t event_thread;
56 /* 0: read, 1: write */
61 _tdm_thread_main(void *data)
63 tdm_private_thread *private_thread = (tdm_private_thread*)data;
64 tdm_private_loop *private_loop = private_thread->private_loop;
69 /* Not lock/unlock for the private_thread and private_loop structure
70 * because they won't be destroyed as long as tdm thread is running.
71 * When they're destroyed, we have already exit the tdm thread.
73 private_thread->thread_tid = syscall(SYS_gettid);
75 TDM_INFO("display_tid:%d, thread_tid: %d",
76 private_thread->display_tid, private_thread->thread_tid);
78 fd = tdm_event_loop_get_fd(private_loop->dpy);
80 TDM_ERR("couldn't get fd");
89 if (tdm_debug_module & TDM_DEBUG_THREAD)
90 TDM_INFO("server flush");
91 tdm_event_loop_flush(private_loop->dpy);
93 if (tdm_debug_module & TDM_DEBUG_THREAD)
94 TDM_INFO("fd(%d) polling in", fd);
96 ret = poll(&fds, 1, -1);
98 if (tdm_debug_module & TDM_DEBUG_THREAD)
99 TDM_INFO("fd(%d) polling out", fd);
102 if (errno == EINTR || errno == EAGAIN) /* normal case */
105 TDM_ERR("poll failed: %m");
110 if (tdm_debug_module & TDM_DEBUG_THREAD)
111 TDM_INFO("thread got events");
113 if (tdm_event_loop_dispatch(private_loop->dpy) < 0)
114 TDM_ERR("dispatch error");
121 /* NOTE: tdm thread doesn't care about multi-thread. */
123 tdm_thread_init(tdm_private_loop *private_loop)
125 tdm_private_display *private_display;
126 tdm_private_thread *private_thread;
129 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
130 TDM_RETURN_VAL_IF_FAIL(private_loop->dpy, TDM_ERROR_OPERATION_FAILED);
132 private_display = private_loop->dpy;
133 TDM_RETURN_VAL_IF_FAIL(private_display->private_loop, TDM_ERROR_OPERATION_FAILED);
135 if (private_loop->private_thread)
136 return TDM_ERROR_NONE;
138 /* enable as default */
139 thread = getenv("TDM_THREAD");
140 if (!thread || strncmp(thread, "1", 1)) {
141 TDM_INFO("not using a TDM event thread: %s", (thread) ? thread : "none");
142 return TDM_ERROR_NONE;
145 private_thread = calloc(1, sizeof * private_thread);
146 if (!private_thread) {
147 TDM_ERR("alloc failed");
148 return TDM_ERROR_OUT_OF_MEMORY;
151 if (pipe(private_thread->pipe) != 0) {
152 TDM_ERR("socketpair failed: %m");
153 free(private_thread);
154 return TDM_ERROR_OPERATION_FAILED;
157 private_thread->private_loop = private_loop;
158 private_loop->private_thread = private_thread;
160 private_thread->display_tid = syscall(SYS_gettid);
162 pthread_create(&private_thread->event_thread, NULL, _tdm_thread_main,
165 keep_private_thread = private_thread;
167 TDM_INFO("using a TDM event thread. pipe(%d,%d)",
168 private_thread->pipe[0], private_thread->pipe[1]);
170 return TDM_ERROR_NONE;
174 tdm_thread_deinit(tdm_private_loop *private_loop)
176 tdm_private_display *private_display;
178 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
180 if (!private_loop->private_thread)
183 pthread_cancel(private_loop->private_thread->event_thread);
185 private_display = private_loop->dpy;
187 /* before falling into the block of pthread_join, we have to unlock the mutex
188 * for subthread to use the mutex.
190 _pthread_mutex_unlock(&private_display->lock);
191 pthread_join(private_loop->private_thread->event_thread, NULL);
193 if (private_loop->private_thread->pipe[0] >= 0)
194 close(private_loop->private_thread->pipe[0]);
195 if (private_loop->private_thread->pipe[1] >= 0)
196 close(private_loop->private_thread->pipe[1]);
198 free(private_loop->private_thread);
199 private_loop->private_thread = NULL;
200 keep_private_thread = NULL;
202 TDM_INFO("Finish a TDM event thread");
206 tdm_thread_get_fd(tdm_private_loop *private_loop)
208 tdm_private_thread *private_thread;
210 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
211 TDM_RETURN_VAL_IF_FAIL(private_loop, -1);
212 TDM_RETURN_VAL_IF_FAIL(private_loop->private_thread, -1);
214 private_thread = private_loop->private_thread;
216 return private_thread->pipe[0];
220 tdm_thread_send_cb(tdm_private_loop *private_loop, tdm_thread_cb_base *base)
222 tdm_private_thread *private_thread;
225 TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
226 TDM_RETURN_VAL_IF_FAIL(base, TDM_ERROR_INVALID_PARAMETER);
227 TDM_RETURN_VAL_IF_FAIL(private_loop, TDM_ERROR_INVALID_PARAMETER);
228 TDM_RETURN_VAL_IF_FAIL(private_loop->private_thread, TDM_ERROR_INVALID_PARAMETER);
230 private_thread = private_loop->private_thread;
232 if (tdm_debug_module & TDM_DEBUG_THREAD)
233 TDM_INFO("fd(%d) type(%d), length(%d)",
234 private_thread->pipe[1], base->type, base->length);
236 len = write(private_thread->pipe[1], base, base->length);
237 if (len != base->length) {
238 TDM_ERR("write failed (%d != %d): %m", (int)len, base->length);
239 return TDM_ERROR_OPERATION_FAILED;
242 return TDM_ERROR_NONE;
246 tdm_thread_handle_cb(tdm_private_loop *private_loop)
248 tdm_private_display *private_display;
249 tdm_private_thread *private_thread;
250 tdm_thread_cb_base *base;
254 /* DON'T check TDM_MUTEX_IS_LOCKED here */
256 TDM_RETURN_VAL_IF_FAIL(private_loop, TDM_ERROR_INVALID_PARAMETER);
257 TDM_RETURN_VAL_IF_FAIL(private_loop->private_thread, TDM_ERROR_INVALID_PARAMETER);
259 private_thread = private_loop->private_thread;
260 private_display = private_loop->dpy;
262 len = read(private_thread->pipe[0], buffer, sizeof buffer);
264 if (tdm_debug_module & TDM_DEBUG_THREAD)
265 TDM_INFO("fd(%d) read length(%d)", private_thread->pipe[0], len);
268 return TDM_ERROR_NONE;
270 if (len < sizeof * base) {
271 TDM_NEVER_GET_HERE();
272 return TDM_ERROR_OPERATION_FAILED;
275 _pthread_mutex_lock(&private_display->lock);
279 base = (tdm_thread_cb_base*)&buffer[i];
280 if (tdm_debug_module & TDM_DEBUG_THREAD)
281 TDM_INFO("type(%d), length(%d)", base->type, base->length);
282 switch (base->type) {
283 case TDM_THREAD_CB_OUTPUT_COMMIT: {
284 tdm_thread_cb_output_commit *output_commit = (tdm_thread_cb_output_commit*)base;
285 tdm_output *output_backend =
286 tdm_display_find_output_stamp(private_loop->dpy, output_commit->output_stamp);
287 if (!output_backend) {
288 TDM_WRN("no output(%f)", output_commit->output_stamp);
291 tdm_output_cb_commit(output_backend, output_commit->sequence,
292 output_commit->tv_sec, output_commit->tv_usec,
293 output_commit->user_data);
296 case TDM_THREAD_CB_OUTPUT_VBLANK: {
297 tdm_thread_cb_output_vblank *output_vblank = (tdm_thread_cb_output_vblank*)base;
298 tdm_output *output_backend =
299 tdm_display_find_output_stamp(private_loop->dpy, output_vblank->output_stamp);
300 if (!output_backend) {
301 TDM_WRN("no output(%f)", output_vblank->output_stamp);
304 tdm_output_cb_vblank(output_backend, output_vblank->sequence,
305 output_vblank->tv_sec, output_vblank->tv_usec,
306 output_vblank->user_data);
309 case TDM_THREAD_CB_OUTPUT_STATUS: {
310 tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status*)base;
311 tdm_output *output_backend =
312 tdm_display_find_output_stamp(private_loop->dpy, output_status->output_stamp);
313 if (!output_backend) {
314 TDM_WRN("no output(%f)", output_status->output_stamp);
317 tdm_output_cb_status(output_backend, output_status->status,
318 output_status->user_data);
321 case TDM_THREAD_CB_OUTPUT_DPMS: {
322 tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms*)base;
323 tdm_output *output_backend =
324 tdm_display_find_output_stamp(private_loop->dpy, output_dpms->output_stamp);
325 if (!output_backend) {
326 TDM_WRN("no output(%f)", output_dpms->output_stamp);
329 tdm_output_cb_dpms(output_backend, output_dpms->dpms, output_dpms->user_data);
332 case TDM_THREAD_CB_PP_DONE: {
333 tdm_thread_cb_pp_done *pp_done = (tdm_thread_cb_pp_done*)base;
335 tdm_pp_find_stamp(private_loop->dpy, pp_done->pp_stamp);
337 TDM_WRN("no pp(%f)", pp_done->pp_stamp);
340 tdm_pp_cb_done(pp_backend, pp_done->src, pp_done->dst, pp_done->user_data);
343 case TDM_THREAD_CB_CAPTURE_DONE: {
344 tdm_thread_cb_capture_done *capture_done = (tdm_thread_cb_capture_done*)base;
345 tdm_capture *capture_backend =
346 tdm_capture_find_stamp(private_loop->dpy, capture_done->capture_stamp);
347 if (!capture_backend) {
348 TDM_WRN("no capture(%f)", capture_done->capture_stamp);
351 tdm_capture_cb_done(capture_backend, capture_done->buffer, capture_done->user_data);
354 case TDM_THREAD_CB_VBLANK_SW: {
355 tdm_thread_cb_vblank_sw *vblank_sw = (tdm_thread_cb_vblank_sw*)base;
356 tdm_vblank_cb_vblank_SW(NULL, vblank_sw->vblank_stamp);
365 _pthread_mutex_unlock(&private_display->lock);
367 return TDM_ERROR_NONE;
371 tdm_thread_in_display_thread(pid_t tid)
373 if (!keep_private_thread)
376 /* DON'T check TDM_MUTEX_IS_LOCKED here */
378 return (keep_private_thread->display_tid == tid) ? 1 : 0;
382 tdm_thread_is_running(void)
384 /* DON'T check TDM_MUTEX_IS_LOCKED here */
386 return (keep_private_thread) ? 1 : 0;