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 **************************************************************************/
46 #include "tdm_client.h"
48 #include "tdm_macro.h"
50 #include "tdm-client-protocol.h"
52 typedef struct _tdm_private_client_vblank tdm_private_client_vblank;
54 typedef struct _tdm_private_client {
55 struct wl_display *display;
56 struct wl_registry *registry;
58 struct list_head output_list;
60 tdm_private_client_vblank *temp_vblank;
63 typedef struct _tdm_private_client_output {
64 tdm_private_client *private_client;
66 char name[TDM_NAME_LEN];
67 struct wl_tdm_output *output;
71 tdm_output_conn_status connection;
73 struct list_head vblank_list;
74 struct list_head change_handler_list;
78 struct list_head link;
79 } tdm_private_client_output;
81 struct _tdm_private_client_vblank {
82 tdm_private_client_output *private_output;
84 struct wl_tdm_vblank *vblank;
85 struct list_head wait_list;
90 unsigned int enable_fake;
94 struct list_head link;
97 typedef struct _tdm_client_output_handler_info {
98 tdm_private_client_output *private_output;
100 tdm_client_output_change_handler func;
103 struct list_head link;
104 } tdm_client_output_handler_info;
106 typedef struct _tdm_client_wait_info {
107 tdm_private_client_vblank *private_vblank;
109 tdm_client_vblank_handler func;
113 unsigned int req_sec;
114 unsigned int req_usec;
117 struct list_head link;
118 } tdm_client_wait_info;
121 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
122 uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
123 uint32_t tv_usec, uint32_t error)
125 tdm_private_client_vblank *private_vblank = data;
126 tdm_client_wait_info *w = NULL, *ww = NULL;
128 TDM_RETURN_IF_FAIL(private_vblank != NULL);
130 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
131 if (w->req_id != req_id)
135 w->func(private_vblank, error, sequence, tv_sec, tv_usec, w->user_data);
146 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
147 _tdm_client_vblank_cb_done,
151 _tdm_client_output_destroy(tdm_private_client_output *private_output)
153 tdm_private_client_vblank *v = NULL, *vv = NULL;
154 tdm_client_output_handler_info *h = NULL, *hh = NULL;
156 LIST_DEL(&private_output->link);
158 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
159 TDM_ERR("vblanks SHOULD be destroyed first!");
161 v->private_output = NULL;
164 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
169 wl_tdm_output_destroy(private_output->output);
171 free(private_output);
175 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
176 uint32_t width, uint32_t height, uint32_t refresh)
178 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
180 TDM_RETURN_IF_FAIL(private_output != NULL);
182 private_output->width = width;
183 private_output->height = height;
184 private_output->refresh = refresh;
186 TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
187 private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
188 width, height, refresh);
192 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value)
194 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
195 tdm_client_output_handler_info *h = NULL;
198 TDM_RETURN_IF_FAIL(private_output != NULL);
200 if (private_output->connection == value)
203 private_output->connection = value;
205 TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
207 wl_proxy_get_id((struct wl_proxy*)private_output->output),
211 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
213 h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
218 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value)
220 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
221 tdm_client_output_handler_info *h = NULL;
224 TDM_RETURN_IF_FAIL(private_output != NULL);
226 if (private_output->dpms == value)
229 private_output->dpms = value;
231 TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
233 wl_proxy_get_id((struct wl_proxy*)private_output->output),
237 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
239 h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
243 static const struct wl_tdm_output_listener tdm_client_output_listener = {
244 _tdm_client_output_cb_mode,
245 _tdm_client_output_cb_connection,
246 _tdm_client_output_cb_dpms,
250 _tdm_client_cb_global(void *data, struct wl_registry *registry,
251 uint32_t name, const char *interface,
254 tdm_private_client *private_client = data;
256 if (strncmp(interface, "wl_tdm", 6) == 0) {
257 private_client->tdm =
258 wl_registry_bind(registry, name, &wl_tdm_interface, version);
259 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
261 wl_display_flush(private_client->display);
266 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
270 static const struct wl_registry_listener tdm_client_registry_listener = {
271 _tdm_client_cb_global,
272 _tdm_client_cb_global_remove
276 tdm_client_create(tdm_error *error)
278 tdm_private_client *private_client;
280 private_client = calloc(1, sizeof *private_client);
281 if (!private_client) {
282 TDM_ERR("alloc failed");
284 *error = TDM_ERROR_OUT_OF_MEMORY;
288 LIST_INITHEAD(&private_client->output_list);
290 private_client->display = wl_display_connect("tdm-socket");
291 TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
293 private_client->registry = wl_display_get_registry(private_client->display);
294 TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
296 wl_registry_add_listener(private_client->registry,
297 &tdm_client_registry_listener, private_client);
298 wl_display_roundtrip(private_client->display);
300 /* check global objects */
301 TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
304 *error = TDM_ERROR_NONE;
306 return (tdm_client*)private_client;
308 tdm_client_destroy((tdm_client*)private_client);
310 *error = TDM_ERROR_OPERATION_FAILED;
315 tdm_client_destroy(tdm_client *client)
317 tdm_private_client *private_client = (tdm_private_client*)client;
318 tdm_private_client_output *o = NULL, *oo = NULL;
323 if (private_client->temp_vblank)
324 tdm_client_vblank_destroy(private_client->temp_vblank);
326 LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
327 _tdm_client_output_destroy(o);
330 if (private_client->tdm)
331 wl_tdm_destroy(private_client->tdm);
332 if (private_client->registry)
333 wl_registry_destroy(private_client->registry);
334 if (private_client->display)
335 wl_display_disconnect(private_client->display);
337 free(private_client);
341 tdm_client_get_fd(tdm_client *client, int *fd)
343 tdm_private_client *private_client;
345 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
346 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
348 private_client = (tdm_private_client*)client;
350 *fd = wl_display_get_fd(private_client->display);
352 return TDM_ERROR_OPERATION_FAILED;
354 return TDM_ERROR_NONE;
358 tdm_client_handle_events(tdm_client *client)
360 tdm_private_client *private_client;
362 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
364 private_client = (tdm_private_client*)client;
366 wl_display_dispatch(private_client->display);
368 return TDM_ERROR_NONE;
371 typedef struct _tdm_client_vblank_temp {
372 tdm_client_vblank_handler2 func;
374 } tdm_client_vblank_temp;
377 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
378 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
380 tdm_client_vblank_temp *vblank_temp = user_data;
382 TDM_RETURN_IF_FAIL(vblank_temp != NULL);
384 if (vblank_temp->func)
385 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
391 tdm_client_wait_vblank(tdm_client *client, char *name,
392 int sw_timer, int interval, int sync,
393 tdm_client_vblank_handler2 func, void *user_data)
395 tdm_private_client *private_client = (tdm_private_client*)client;
396 tdm_client_output *output;
397 tdm_client_vblank_temp *vblank_temp;
400 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
401 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
402 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
404 if (!private_client->temp_vblank) {
405 output = tdm_client_get_output(client, name, &ret);
406 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
408 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
409 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
412 tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
413 tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
415 vblank_temp = calloc(1, sizeof *vblank_temp);
416 TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
418 vblank_temp->func = func;
419 vblank_temp->user_data = user_data;
421 return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
425 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
427 tdm_private_client *private_client;
428 tdm_private_client_output *private_output = NULL;
431 *error = TDM_ERROR_NONE;
434 TDM_ERR("'!client' failed");
436 *error = TDM_ERROR_INVALID_PARAMETER;
440 private_client = (tdm_private_client*)client;
445 LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
446 if (!strncmp(private_output->name, name, TDM_NAME_LEN))
447 return (tdm_client_output*)private_output;
450 private_output = calloc(1, sizeof *private_output);
451 if (!private_output) {
452 TDM_ERR("alloc failed");
454 *error = TDM_ERROR_OUT_OF_MEMORY;
458 private_output->private_client = private_client;
460 snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
461 private_output->output = wl_tdm_create_output(private_client->tdm, private_output->name);
462 if (!private_output->output) {
463 TDM_ERR("couldn't create output resource");
464 free(private_output);
466 *error = TDM_ERROR_OUT_OF_MEMORY;
470 LIST_INITHEAD(&private_output->vblank_list);
471 LIST_INITHEAD(&private_output->change_handler_list);
472 LIST_ADDTAIL(&private_output->link, &private_client->output_list);
474 wl_tdm_output_add_listener(private_output->output,
475 &tdm_client_output_listener, private_output);
476 wl_display_roundtrip(private_client->display);
478 return (tdm_client_output*)private_output;
482 tdm_client_output_add_change_handler(tdm_client_output *output,
483 tdm_client_output_change_handler func,
486 tdm_private_client_output *private_output;
487 tdm_client_output_handler_info *h;
489 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
490 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
492 private_output = (tdm_private_client_output*)output;
494 h = calloc(1, sizeof *h);
495 TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
497 h->private_output = private_output;
499 h->user_data = user_data;
500 LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
502 return TDM_ERROR_NOT_IMPLEMENTED;
506 tdm_client_output_remove_change_handler(tdm_client_output *output,
507 tdm_client_output_change_handler func,
510 tdm_private_client_output *private_output;
511 tdm_client_output_handler_info *h = NULL;
513 TDM_RETURN_IF_FAIL(output != NULL);
514 TDM_RETURN_IF_FAIL(func != NULL);
516 private_output = (tdm_private_client_output*)output;
518 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
519 if (h->func != func || h->user_data != user_data)
529 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
531 tdm_private_client_output *private_output;
533 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
534 TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
536 private_output = (tdm_private_client_output*)output;
538 *refresh = private_output->refresh;
540 return TDM_ERROR_NONE;
544 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
546 tdm_private_client_output *private_output;
548 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
549 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
551 private_output = (tdm_private_client_output*)output;
553 *status = private_output->connection;
555 return TDM_ERROR_NONE;
559 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
561 tdm_private_client_output *private_output;
563 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
564 TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
566 private_output = (tdm_private_client_output*)output;
568 *dpms = private_output->dpms;
570 return TDM_ERROR_NONE;
574 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
576 tdm_private_client_output *private_output;
577 tdm_private_client_vblank *private_vblank;
580 *error = TDM_ERROR_NONE;
583 TDM_ERR("'!output' failed");
585 *error = TDM_ERROR_INVALID_PARAMETER;
589 private_output = (tdm_private_client_output*)output;
591 private_vblank = calloc(1, sizeof *private_vblank);
592 if (!private_vblank) {
593 TDM_ERR("alloc failed");
595 *error = TDM_ERROR_OUT_OF_MEMORY;
599 private_vblank->private_output = private_output;
601 private_vblank->vblank = wl_tdm_output_create_vblank(private_output->output);
602 if (!private_vblank->vblank) {
603 TDM_ERR("couldn't create vblank resource");
604 free(private_vblank);
606 *error = TDM_ERROR_OUT_OF_MEMORY;
611 private_vblank->fps = private_output->refresh;
612 private_vblank->offset = 0;
613 private_vblank->enable_fake = 0;
615 LIST_INITHEAD(&private_vblank->wait_list);
616 LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
618 wl_tdm_vblank_add_listener(private_vblank->vblank,
619 &tdm_client_vblank_listener, private_vblank);
621 return (tdm_client_vblank*)private_vblank;
625 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
627 tdm_private_client_vblank *private_vblank;
628 tdm_client_wait_info *w = NULL, *ww = NULL;
630 TDM_RETURN_IF_FAIL(vblank != NULL);
632 private_vblank = vblank;
633 LIST_DEL(&private_vblank->link);
635 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
640 wl_tdm_vblank_destroy(private_vblank->vblank);
642 free(private_vblank);
646 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
648 tdm_private_client_vblank *private_vblank;
650 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
652 private_vblank = vblank;
653 private_vblank->sync = sync;
655 return TDM_ERROR_NONE;
659 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
661 tdm_private_client_vblank *private_vblank;
663 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
664 TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
666 private_vblank = vblank;
667 TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
669 if (private_vblank->fps == fps)
670 return TDM_ERROR_NONE;
671 private_vblank->fps = fps;
673 wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
675 return TDM_ERROR_NONE;
679 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
681 tdm_private_client_vblank *private_vblank;
683 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
685 private_vblank = vblank;
686 TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
688 if (private_vblank->offset == offset_ms)
689 return TDM_ERROR_NONE;
690 private_vblank->offset = offset_ms;
692 wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
694 return TDM_ERROR_NONE;
698 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
700 tdm_private_client_vblank *private_vblank;
702 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
704 private_vblank = vblank;
706 if (private_vblank->enable_fake == enable_fake)
707 return TDM_ERROR_NONE;
708 private_vblank->enable_fake = enable_fake;
710 wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
712 return TDM_ERROR_NONE;
716 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
718 tdm_private_client *private_client;
719 tdm_private_client_output *private_output;
720 tdm_private_client_vblank *private_vblank;
721 tdm_client_wait_info *w;
725 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
726 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
727 /* can't support "interval 0" and "getting current_msc" things because
728 * there is a socket communication between TDM client and server. It's impossible
729 * to return the current msc or sequence immediately.
731 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
733 private_vblank = vblank;
734 private_output = private_vblank->private_output;
735 private_client = private_output->private_client;
737 if (!private_vblank->started)
738 private_vblank->started = 1;
740 if (private_output->dpms != TDM_OUTPUT_DPMS_ON && !private_vblank->enable_fake) {
741 TDM_INFO("dpms off");
742 return TDM_ERROR_DPMS_OFF;
745 w = calloc(1, sizeof *w);
747 TDM_ERR("alloc failed");
748 return TDM_ERROR_OUT_OF_MEMORY;
751 w->private_vblank = private_vblank;
753 w->user_data = user_data;
755 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
757 clock_gettime(CLOCK_MONOTONIC, &tp);
758 w->req_id = ++private_output->req_id;
759 w->req_sec = (unsigned int)tp.tv_sec;
760 w->req_usec = (unsigned int)(tp.tv_nsec / 1000);
761 w->need_free = (private_vblank->sync) ? 0 : 1;
763 wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, w->req_sec, w->req_usec);
765 if (!private_vblank->sync) {
766 wl_display_flush(private_client->display);
767 return TDM_ERROR_NONE;
770 while (ret != -1 && !w->need_free)
771 ret = wl_display_dispatch(private_client->display);
773 clock_gettime(CLOCK_MONOTONIC, &tp);
774 TDM_DBG("block during %d us",
775 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
776 - (w->req_sec * 1000000 + w->req_usec));
781 return TDM_ERROR_NONE;