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 pthread_mutex_t tdm_mutex_check_lock = PTHREAD_MUTEX_INITIALIZER;
48 static tdm_private_layer *
49 _tdm_display_find_private_layer(tdm_private_output *private_output,
50 tdm_layer *layer_backend)
52 tdm_private_layer *private_layer = NULL;
54 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
55 if (private_layer->layer_backend == layer_backend)
62 static tdm_private_output *
63 _tdm_display_find_private_output(tdm_private_display *private_display,
64 tdm_output *output_backend)
66 tdm_private_output *private_output = NULL;
68 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
69 if (private_output->output_backend == output_backend)
70 return private_output;
76 INTERN tdm_private_output *
77 tdm_display_find_output_stamp(tdm_private_display *private_display,
80 tdm_private_output *private_output = NULL;
82 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
83 if (private_output->stamp == stamp)
84 return private_output;
91 _tdm_display_destroy_caps_pp(tdm_caps_pp *caps_pp)
94 free(caps_pp->formats);
96 memset(caps_pp, 0, sizeof(tdm_caps_pp));
100 _tdm_display_destroy_caps_capture(tdm_caps_capture *caps_capture)
102 if (caps_capture->formats)
103 free(caps_capture->formats);
105 memset(caps_capture, 0, sizeof(tdm_caps_capture));
109 _tdm_display_destroy_caps_layer(tdm_caps_layer *caps_layer)
111 if (caps_layer->formats)
112 free(caps_layer->formats);
114 if (caps_layer->props)
115 free(caps_layer->props);
117 memset(caps_layer, 0, sizeof(tdm_caps_layer));
121 _tdm_display_destroy_caps_output(tdm_caps_output *caps_output)
123 if (caps_output->modes)
124 free(caps_output->modes);
126 if (caps_output->props)
127 free(caps_output->props);
129 memset(caps_output, 0, sizeof(tdm_caps_output));
133 _tdm_display_destroy_private_layer(tdm_private_layer *private_layer)
135 tdm_private_capture *c = NULL, *cc = NULL;
137 LIST_DEL(&private_layer->link);
139 LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_layer->capture_list, link)
140 tdm_capture_destroy_internal(c);
142 _tdm_display_destroy_caps_layer(&private_layer->caps);
148 _tdm_display_destroy_private_output(tdm_private_output *private_output)
150 tdm_private_layer *l = NULL, *ll = NULL;
151 tdm_private_capture *c = NULL, *cc = NULL;
152 tdm_private_vblank_handler *v = NULL, *vv = NULL;
153 tdm_private_commit_handler *m = NULL, *mm = NULL;
154 tdm_private_change_handler *h = NULL, *hh = NULL;
156 LIST_DEL(&private_output->link);
158 free(private_output->layers_ptr);
160 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_handler_list, link) {
165 LIST_FOR_EACH_ENTRY_SAFE(m, mm, &private_output->commit_handler_list, link) {
170 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_main, link) {
175 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) {
180 LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_output->capture_list, link)
181 tdm_capture_destroy_internal(c);
183 LIST_FOR_EACH_ENTRY_SAFE(l, ll, &private_output->layer_list, link)
184 _tdm_display_destroy_private_layer(l);
186 _tdm_display_destroy_caps_output(&private_output->caps);
188 if (private_output->dpms_changed_timer)
189 tdm_event_loop_source_remove(private_output->dpms_changed_timer);
191 private_output->stamp = 0;
192 free(private_output);
196 _tdm_display_destroy_private_display(tdm_private_display *private_display)
198 tdm_private_output *o = NULL, *oo = NULL;
199 tdm_private_pp *p = NULL, *pp = NULL;
201 free(private_display->outputs_ptr);
202 if (private_display->outputs) {
203 free(private_display->outputs);
204 private_display->outputs = NULL;
207 LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_display->pp_list, link)
208 tdm_pp_destroy_internal(p);
210 LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_display->output_list, link)
211 _tdm_display_destroy_private_output(o);
213 _tdm_display_destroy_caps_pp(&private_display->caps_pp);
214 _tdm_display_destroy_caps_capture(&private_display->caps_capture);
216 private_display->capabilities = 0;
217 private_display->caps_display.max_layer_count = -1;
221 _tdm_display_update_caps_pp(tdm_private_display *private_display,
224 tdm_func_display *func_display = &private_display->func_display;
226 int bufsize = sizeof(buf);
228 int *len_buf = &bufsize;
232 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP))
233 return TDM_ERROR_NONE;
235 if (!func_display->display_get_pp_capability) {
236 TDM_ERR("no display_get_pp_capability()");
237 return TDM_ERROR_BAD_MODULE;
240 ret = func_display->display_get_pp_capability(private_display->bdata, caps);
241 if (ret != TDM_ERROR_NONE) {
242 TDM_ERR("display_get_pp_capability() failed");
243 return TDM_ERROR_BAD_MODULE;
246 TDM_DBG("pp capabilities: %x", caps->capabilities);
248 for (i = 0; i < caps->format_count; i++)
249 TDM_SNPRINTF(str_buf, len_buf, "%c%c%c%c ", FOURCC_STR(caps->formats[i]));
250 TDM_DBG("pp formats: %s", buf);
251 TDM_DBG("pp min : %dx%d", caps->min_w, caps->min_h);
252 TDM_DBG("pp max : %dx%d", caps->max_w, caps->max_h);
253 TDM_DBG("pp align: %d", caps->preferred_align);
255 return TDM_ERROR_NONE;
259 _tdm_display_update_caps_capture(tdm_private_display *private_display,
260 tdm_caps_capture *caps)
262 tdm_func_display *func_display = &private_display->func_display;
264 int bufsize = sizeof(buf);
266 int *len_buf = &bufsize;
270 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
271 return TDM_ERROR_NONE;
273 if (!func_display->display_get_capture_capability) {
274 TDM_ERR("no display_get_capture_capability()");
275 return TDM_ERROR_BAD_MODULE;
278 ret = func_display->display_get_capture_capability(private_display->bdata, caps);
279 if (ret != TDM_ERROR_NONE) {
280 TDM_ERR("display_get_capture_capability() failed");
281 return TDM_ERROR_BAD_MODULE;
285 for (i = 0; i < caps->format_count; i++)
286 TDM_SNPRINTF(str_buf, len_buf, "%c%c%c%c ", FOURCC_STR(caps->formats[i]));
287 TDM_DBG("capture formats: %s", buf);
289 return TDM_ERROR_NONE;
293 _tdm_display_update_caps_layer(tdm_private_display *private_display,
294 tdm_layer *layer_backend, tdm_caps_layer *caps)
296 tdm_func_layer *func_layer = &private_display->func_layer;
298 int bufsize = sizeof(buf);
300 int *len_buf = &bufsize;
304 if (!func_layer->layer_get_capability) {
305 TDM_ERR("no layer_get_capability()");
306 return TDM_ERROR_BAD_MODULE;
309 ret = func_layer->layer_get_capability(layer_backend, caps);
310 if (ret != TDM_ERROR_NONE) {
311 TDM_ERR("layer_get_capability() failed");
312 return TDM_ERROR_BAD_MODULE;
315 TDM_DBG("layer capabilities: %x", caps->capabilities);
316 TDM_DBG("layer zpos : %d", caps->zpos);
318 for (i = 0; i < caps->format_count; i++)
319 TDM_SNPRINTF(str_buf, len_buf, "%c%c%c%c ", FOURCC_STR(caps->formats[i]));
320 TDM_DBG("layer formats: %s", buf);
321 for (i = 0; i < caps->prop_count; i++)
322 TDM_DBG("layer props: %d, %s", caps->props[i].id, caps->props[i].name);
324 return TDM_ERROR_NONE;
328 _tdm_display_update_caps_output(tdm_private_display *private_display, int pipe,
329 tdm_output *output_backend, tdm_caps_output *caps)
331 tdm_func_output *func_output = &private_display->func_output;
332 char temp[TDM_NAME_LEN];
336 if (!func_output->output_get_capability) {
337 TDM_ERR("no output_get_capability()");
338 return TDM_ERROR_BAD_MODULE;
341 ret = func_output->output_get_capability(output_backend, caps);
342 if (ret != TDM_ERROR_NONE) {
343 TDM_ERR("output_get_capability() failed");
344 return TDM_ERROR_BAD_MODULE;
347 /* FIXME: Use model for tdm client to distinguish amoung outputs */
348 snprintf(temp, TDM_NAME_LEN, "%s-%d", caps->model, pipe);
349 snprintf(caps->model, TDM_NAME_LEN, "%s", temp);
351 TDM_DBG("output maker: %s", caps->maker);
352 TDM_DBG("output model: %s", caps->model);
353 TDM_DBG("output name: %s", caps->name);
354 TDM_DBG("output status: %d", caps->status);
355 TDM_DBG("output type : %d", caps->type);
356 for (i = 0; i < caps->prop_count; i++)
357 TDM_DBG("output props: %d, %s", caps->props[i].id, caps->props[i].name);
358 for (i = 0; i < caps->mode_count; i++) {
359 TDM_DBG("output modes: name(%s), clock(%d) vrefresh(%d), flags(%x), type(%d)",
360 caps->modes[i].name, caps->modes[i].clock, caps->modes[i].vrefresh,
361 caps->modes[i].flags, caps->modes[i].type);
362 TDM_DBG("\t\t %d, %d, %d, %d, %d",
363 caps->modes[i].hdisplay, caps->modes[i].hsync_start, caps->modes[i].hsync_end,
364 caps->modes[i].htotal, caps->modes[i].hskew);
365 TDM_DBG("\t\t %d, %d, %d, %d, %d",
366 caps->modes[i].vdisplay, caps->modes[i].vsync_start, caps->modes[i].vsync_end,
367 caps->modes[i].vtotal, caps->modes[i].vscan);
369 TDM_DBG("output min : %dx%d", caps->min_w, caps->min_h);
370 TDM_DBG("output max : %dx%d", caps->max_w, caps->max_h);
371 TDM_DBG("output align: %d", caps->preferred_align);
373 return TDM_ERROR_NONE;
377 _tdm_display_update_layer(tdm_private_display *private_display,
378 tdm_private_output *private_output,
379 tdm_layer *layer_backend, int index)
381 tdm_private_layer *private_layer;
384 private_layer = _tdm_display_find_private_layer(private_output, layer_backend);
385 if (!private_layer) {
386 private_layer = calloc(1, sizeof(tdm_private_layer));
387 TDM_RETURN_VAL_IF_FAIL(private_layer != NULL, TDM_ERROR_OUT_OF_MEMORY);
389 LIST_ADDTAIL(&private_layer->link, &private_output->layer_list);
390 private_layer->index = index;
391 private_layer->private_display = private_display;
392 private_layer->private_output = private_output;
393 private_layer->layer_backend = layer_backend;
395 LIST_INITHEAD(&private_layer->capture_list);
397 private_layer->usable = 1;
399 _tdm_display_destroy_caps_layer(&private_layer->caps);
401 ret = _tdm_display_update_caps_layer(private_display, layer_backend,
402 &private_layer->caps);
403 if (ret != TDM_ERROR_NONE)
406 return TDM_ERROR_NONE;
408 _tdm_display_destroy_private_layer(private_layer);
413 tdm_display_update_output(tdm_private_display *private_display,
414 tdm_output *output_backend, int pipe)
416 tdm_func_output *func_output = &private_display->func_output;
417 tdm_private_output *private_output = NULL;
418 tdm_layer **layers = NULL;
419 int layer_count = 0, i;
422 private_output = _tdm_display_find_private_output(private_display, output_backend);
423 if (!private_output) {
424 private_output = calloc(1, sizeof(tdm_private_output));
425 TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OUT_OF_MEMORY);
427 private_output->stamp = tdm_helper_get_time_in_millis();
428 while (tdm_display_find_output_stamp(private_display, private_output->stamp))
429 private_output->stamp++;
431 LIST_ADDTAIL(&private_output->link, &private_display->output_list);
433 private_output->private_display = private_display;
434 private_output->current_dpms_value = TDM_OUTPUT_DPMS_OFF;
435 private_output->output_backend = output_backend;
436 private_output->pipe = pipe;
437 private_output->index = pipe;
439 LIST_INITHEAD(&private_output->layer_list);
440 LIST_INITHEAD(&private_output->capture_list);
441 LIST_INITHEAD(&private_output->vblank_handler_list);
442 LIST_INITHEAD(&private_output->commit_handler_list);
443 LIST_INITHEAD(&private_output->change_handler_list_main);
444 LIST_INITHEAD(&private_output->change_handler_list_sub);
446 if (func_output->output_set_status_handler) {
447 func_output->output_set_status_handler(private_output->output_backend,
448 tdm_output_cb_status,
450 private_output->regist_change_cb = 1;
454 _tdm_display_destroy_caps_output(&private_output->caps);
456 ret = _tdm_display_update_caps_output(private_display, pipe, output_backend,
457 &private_output->caps);
458 if (ret != TDM_ERROR_NONE)
461 layers = func_output->output_get_layers(output_backend, &layer_count, &ret);
462 if (ret != TDM_ERROR_NONE)
465 for (i = 0; i < layer_count; i++) {
466 ret = _tdm_display_update_layer(private_display, private_output, layers[i], i);
467 if (ret != TDM_ERROR_NONE)
473 return TDM_ERROR_NONE;
475 _tdm_display_destroy_private_output(private_output);
481 _tdm_display_set_main_first(tdm_output **outputs, int index)
483 tdm_output *output_tmp = NULL;
488 output_tmp = outputs[0];
489 outputs[0] = outputs[index];
490 outputs[index] = output_tmp;
496 _tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *count)
498 tdm_func_display *func_display = &private_display->func_display;
499 tdm_output **outputs = NULL;
500 tdm_output **new_outputs = NULL;
501 tdm_output *output_dsi = NULL;
502 tdm_output *output_lvds = NULL;
503 tdm_output *output_hdmia = NULL;
504 tdm_output *output_hdmib = NULL;
505 int i, output_count = 0, output_connected_count = 0;
506 int index_dsi = 0, index_lvds = 0, index_hdmia = 0, index_hdmib = 0;
509 /* don't change list order if not init time */
510 if (private_display->outputs)
511 return private_display->outputs;
513 outputs = func_display->display_get_outputs(private_display->bdata, &output_count, &ret);
514 if (ret != TDM_ERROR_NONE)
515 goto failed_get_outputs;
517 *count = output_count;
519 if (output_count == 0)
520 goto failed_get_outputs;
521 else if (output_count == 1) {
522 private_display->outputs = outputs;
526 /* count connected outputs */
527 for (i = 0; i < output_count; i++) {
528 tdm_func_output *func_output = &private_display->func_output;
529 tdm_caps_output caps;
530 memset(&caps, 0, sizeof(tdm_caps_output));
532 if (!func_output->output_get_capability) {
533 TDM_ERR("no output_get_capability()");
534 goto failed_get_outputs;
537 ret = func_output->output_get_capability(outputs[i], &caps);
538 if (ret != TDM_ERROR_NONE) {
539 TDM_ERR("output_get_capability() failed");
540 goto failed_get_outputs;
543 if (caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED) {
544 output_connected_count++;
547 case TDM_OUTPUT_TYPE_DSI:
548 output_dsi = outputs[i];
551 case TDM_OUTPUT_TYPE_LVDS:
552 output_lvds = outputs[i];
555 case TDM_OUTPUT_TYPE_HDMIA:
556 output_hdmia = outputs[i];
559 case TDM_OUTPUT_TYPE_HDMIB:
560 output_hdmib = outputs[i];
569 /* ordering : main output is first */
570 /* If there is no connected output, lvds or dsi cannot be main display. (cannot connect after booting)
571 * But hdmi is possible, so set hdmi to main display.
572 * If connected only one output, it is main output.
573 * If connected outputs over 2, has priority like below.
574 * (dsi > lvds > hdmi > else)
576 if (output_connected_count == 0) {
577 /* hdmi > dsi > lvds > else */
578 if (output_hdmia != NULL)
579 new_outputs = _tdm_display_set_main_first(outputs, index_hdmia);
580 else if (output_hdmib != NULL)
581 new_outputs = _tdm_display_set_main_first(outputs, index_hdmib);
582 else if (output_dsi != NULL)
583 new_outputs = _tdm_display_set_main_first(outputs, index_dsi);
584 else if (output_lvds != NULL)
585 new_outputs = _tdm_display_set_main_first(outputs, index_lvds);
587 new_outputs = outputs;
588 } else { /* (output_connected_count > 1) */
589 /* dsi > lvds > hdmi > else */
590 if (output_dsi != NULL)
591 new_outputs = _tdm_display_set_main_first(outputs, index_dsi);
592 else if (output_lvds != NULL)
593 new_outputs = _tdm_display_set_main_first(outputs, index_lvds);
594 else if (output_hdmia != NULL)
595 new_outputs = _tdm_display_set_main_first(outputs, index_hdmia);
596 else if (output_hdmib != NULL)
597 new_outputs = _tdm_display_set_main_first(outputs, index_hdmib);
599 new_outputs = outputs;
602 private_display->outputs = new_outputs;
613 _tdm_display_update_internal(tdm_private_display *private_display,
616 tdm_output **outputs = NULL;
617 int output_count = 0, i;
618 tdm_error ret = TDM_ERROR_NONE;
620 LIST_INITHEAD(&private_display->output_list);
621 LIST_INITHEAD(&private_display->pp_list);
622 LIST_INITHEAD(&private_display->capture_list);
625 ret = _tdm_display_update_caps_pp(private_display, &private_display->caps_pp);
626 if (ret != TDM_ERROR_NONE)
629 ret = _tdm_display_update_caps_capture(private_display,
630 &private_display->caps_capture);
631 if (ret != TDM_ERROR_NONE)
635 outputs = _tdm_display_get_ordered_outputs(private_display, &output_count);
639 for (i = 0; i < output_count; i++) {
640 ret = tdm_display_update_output(private_display, outputs[i], i);
641 if (ret != TDM_ERROR_NONE)
645 return TDM_ERROR_NONE;
648 _tdm_display_destroy_private_display(private_display);
653 tdm_display_update(tdm_display *dpy)
655 tdm_private_display *private_display;
658 TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
660 private_display = dpy;
661 _pthread_mutex_lock(&private_display->lock);
663 ret = _tdm_display_update_internal(private_display, 1);
665 _pthread_mutex_unlock(&private_display->lock);
670 #define SUFFIX_MODULE ".so"
671 #define DEFAULT_MODULE "libtdm-default"SUFFIX_MODULE
673 int tdm_debug_module;
676 static tdm_private_display *g_private_display;
677 static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER;
680 _tdm_display_check_module(tdm_backend_module *module)
684 TDM_INFO("TDM ABI version : %d.%d",
685 TDM_MAJOR_VERSION, TDM_MINOR_VERSION);
688 TDM_ERR("TDM backend doesn't have name");
689 return TDM_ERROR_BAD_MODULE;
692 if (!module->vendor) {
693 TDM_ERR("TDM backend doesn't have vendor");
694 return TDM_ERROR_BAD_MODULE;
697 major = TDM_BACKEND_GET_ABI_MAJOR(module->abi_version);
698 minor = TDM_BACKEND_GET_ABI_MINOR(module->abi_version);
700 TDM_INFO("TDM module name: %s", module->name);
701 TDM_INFO("'%s' vendor: %s", module->name, module->vendor);
702 TDM_INFO("'%s' version: %d.%d", module->name, major, minor);
704 if (major != TDM_MAJOR_VERSION) {
705 TDM_ERR("'%s' major version mismatch, %d != %d",
706 module->name, major, TDM_MAJOR_VERSION);
707 return TDM_ERROR_BAD_MODULE;
710 if (minor > TDM_MINOR_VERSION) {
711 TDM_ERR("'%s' minor version(%d) is newer than %d",
712 module->name, minor, TDM_MINOR_VERSION);
713 return TDM_ERROR_BAD_MODULE;
717 TDM_ERR("'%s' doesn't have init function", module->name);
718 return TDM_ERROR_BAD_MODULE;
721 if (!module->deinit) {
722 TDM_ERR("'%s' doesn't have deinit function", module->name);
723 return TDM_ERROR_BAD_MODULE;
726 return TDM_ERROR_NONE;
730 _tdm_display_check_backend_functions(tdm_private_display *private_display)
732 tdm_func_display *func_display = &private_display->func_display;
733 tdm_func_output *func_output = &private_display->func_output;
734 tdm_func_layer *func_layer = &private_display->func_layer;
737 /* below functions should be implemented in backend side */
739 TDM_RETURN_VAL_IF_FAIL(func_display != NULL, TDM_ERROR_BAD_MODULE);
740 TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capabilitiy, TDM_ERROR_BAD_MODULE);
741 TDM_RETURN_VAL_IF_FAIL(func_display->display_get_outputs, TDM_ERROR_BAD_MODULE);
742 TDM_RETURN_VAL_IF_FAIL(func_output->output_get_capability, TDM_ERROR_BAD_MODULE);
743 TDM_RETURN_VAL_IF_FAIL(func_output->output_get_layers, TDM_ERROR_BAD_MODULE);
744 TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_capability, TDM_ERROR_BAD_MODULE);
746 ret = func_display->display_get_capabilitiy(private_display->bdata, &private_display->caps_display);
747 if (ret != TDM_ERROR_NONE) {
748 TDM_ERR("display_get_capabilitiy() failed");
749 return TDM_ERROR_BAD_MODULE;
752 if (private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP) {
753 tdm_func_pp *func_pp = &private_display->func_pp;
754 TDM_RETURN_VAL_IF_FAIL(func_display->display_get_pp_capability, TDM_ERROR_BAD_MODULE);
755 TDM_RETURN_VAL_IF_FAIL(func_display->display_create_pp, TDM_ERROR_BAD_MODULE);
756 TDM_RETURN_VAL_IF_FAIL(func_pp->pp_destroy, TDM_ERROR_BAD_MODULE);
757 TDM_RETURN_VAL_IF_FAIL(func_pp->pp_commit, TDM_ERROR_BAD_MODULE);
758 TDM_RETURN_VAL_IF_FAIL(func_pp->pp_set_done_handler, TDM_ERROR_BAD_MODULE);
761 if (private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) {
762 tdm_func_capture *func_capture = &private_display->func_capture;
763 TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capture_capability, TDM_ERROR_BAD_MODULE);
764 TDM_RETURN_VAL_IF_FAIL(func_output->output_create_capture, TDM_ERROR_BAD_MODULE);
765 TDM_RETURN_VAL_IF_FAIL(func_layer->layer_create_capture, TDM_ERROR_BAD_MODULE);
766 TDM_RETURN_VAL_IF_FAIL(func_capture->capture_destroy, TDM_ERROR_BAD_MODULE);
767 TDM_RETURN_VAL_IF_FAIL(func_capture->capture_commit, TDM_ERROR_BAD_MODULE);
768 TDM_RETURN_VAL_IF_FAIL(func_capture->capture_set_done_handler, TDM_ERROR_BAD_MODULE);
771 return TDM_ERROR_NONE;
775 _tdm_display_load_module_with_file(tdm_private_display *private_display,
778 char path[PATH_MAX] = {0,};
779 tdm_backend_module *module_data;
783 snprintf(path, sizeof(path), TDM_MODULE_PATH "/%s", file);
785 TDM_TRACE_BEGIN(Load_Backend);
787 module = dlopen(path, RTLD_LAZY);
789 TDM_ERR("failed to load module: %s(%s)", dlerror(), file);
791 return TDM_ERROR_BAD_MODULE;
794 module_data = dlsym(module, "tdm_backend_module_data");
796 TDM_ERR("'%s' doesn't have data object", file);
797 ret = TDM_ERROR_BAD_MODULE;
802 private_display->module_data = module_data;
803 private_display->module = module;
805 /* check if version, init() and deinit() are valid or not */
806 ret = _tdm_display_check_module(module_data);
807 if (ret != TDM_ERROR_NONE)
812 /* We don't care if backend_data is NULL or not. It's up to backend. */
813 TDM_TRACE_BEGIN(Init_Backend);
814 private_display->bdata = module_data->init((tdm_display *)private_display, &ret);
816 if (ret != TDM_ERROR_NONE) {
817 TDM_ERR("'%s' init failed", file);
821 ret = _tdm_display_check_backend_functions(private_display);
822 if (ret != TDM_ERROR_NONE) {
823 module_data->deinit(private_display->bdata);
824 private_display->bdata = NULL;
828 TDM_INFO("Success to load module(%s)", file);
830 return TDM_ERROR_NONE;
833 private_display->module_data = NULL;
834 private_display->module = NULL;
839 _tdm_display_load_module(tdm_private_display *private_display)
841 const char *module_name;
842 struct dirent **namelist;
846 module_name = getenv("TDM_MODULE");
848 module_name = DEFAULT_MODULE;
850 /* load bufmgr priv from default lib */
851 ret = _tdm_display_load_module_with_file(private_display, module_name);
852 if (ret == TDM_ERROR_NONE)
853 return TDM_ERROR_NONE;
855 /* load bufmgr priv from configured path */
856 n = scandir(TDM_MODULE_PATH, &namelist, 0, alphasort);
858 TDM_ERR("no module in '%s'\n", TDM_MODULE_PATH);
859 return TDM_ERROR_BAD_MODULE;
862 ret = TDM_ERROR_BAD_MODULE;
864 if (ret < 0 && strstr(namelist[n]->d_name, SUFFIX_MODULE))
865 ret = _tdm_display_load_module_with_file(private_display, namelist[n]->d_name);
875 _tdm_display_unload_module(tdm_private_display *private_display)
877 if (private_display->module_data)
878 private_display->module_data->deinit(private_display->bdata);
879 if (private_display->module)
880 dlclose(private_display->module);
882 private_display->bdata = NULL;
883 private_display->module_data = NULL;
884 private_display->module = NULL;
888 tdm_display_init(tdm_error *error)
890 tdm_private_display *private_display = NULL;
894 _pthread_mutex_lock(&gLock);
896 if (g_private_display) {
897 g_private_display->init_count++;
898 _pthread_mutex_unlock(&gLock);
900 *error = TDM_ERROR_NONE;
901 return g_private_display;
904 debug = getenv("TDM_DEBUG_MODULE");
906 tdm_display_enable_debug_module(debug);
908 debug = getenv("TDM_DEBUG_DUMP");
910 tdm_display_enable_dump(debug);
912 debug = getenv("TDM_DEBUG_PATH");
914 tdm_display_enable_path(debug);
916 private_display = calloc(1, sizeof(tdm_private_display));
917 if (!private_display) {
918 ret = TDM_ERROR_OUT_OF_MEMORY;
919 TDM_ERR("'private_display != NULL' failed");
923 if (pthread_mutex_init(&private_display->lock, NULL)) {
924 ret = TDM_ERROR_OPERATION_FAILED;
925 TDM_ERR("mutex init failed: %m");
926 goto failed_mutex_init;
929 _pthread_mutex_lock(&private_display->lock);
931 ret = tdm_event_loop_init(private_display);
932 if (ret != TDM_ERROR_NONE)
935 ret = _tdm_display_load_module(private_display);
936 if (ret != TDM_ERROR_NONE)
940 int tdm_drm_fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD");
941 if (tdm_drm_fd >= 0) {
942 private_display->bufmgr = tbm_bufmgr_init(tdm_drm_fd);
944 if (!private_display->bufmgr) {
945 TDM_ERR("tbm_bufmgr_init failed");
948 TDM_INFO("tbm_bufmgr_init successed");
953 TDM_TRACE_BEGIN(Update_Display);
954 ret = _tdm_display_update_internal(private_display, 0);
956 if (ret != TDM_ERROR_NONE)
959 tdm_event_loop_create_backend_source(private_display);
961 private_display->init_count = 1;
963 g_private_display = private_display;
966 *error = TDM_ERROR_NONE;
968 _pthread_mutex_unlock(&private_display->lock);
969 _pthread_mutex_unlock(&gLock);
971 return (tdm_display *)private_display;
974 _tdm_display_unload_module(private_display);
976 tdm_event_loop_deinit(private_display);
978 _pthread_mutex_unlock(&private_display->lock);
979 pthread_mutex_destroy(&private_display->lock);
981 free(private_display);
985 _pthread_mutex_unlock(&gLock);
990 tdm_display_deinit(tdm_display *dpy)
992 tdm_private_display *private_display = dpy;
994 if (!private_display)
997 _pthread_mutex_lock(&gLock);
999 private_display->init_count--;
1000 if (private_display->init_count > 0) {
1001 _pthread_mutex_unlock(&gLock);
1005 /* dont move the position of lock/unlock. all resource should be protected
1006 * during destroying. after tdm_event_loop_deinit, we don't worry about thread
1007 * things because it's finalized.
1009 _pthread_mutex_lock(&private_display->lock);
1010 tdm_event_loop_deinit(private_display);
1011 _pthread_mutex_unlock(&private_display->lock);
1013 _tdm_display_destroy_private_display(private_display);
1014 _tdm_display_unload_module(private_display);
1017 if (private_display->bufmgr)
1018 tbm_bufmgr_deinit(private_display->bufmgr);
1021 tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1);
1023 pthread_mutex_destroy(&private_display->lock);
1024 free(private_display);
1025 g_private_display = NULL;
1027 _pthread_mutex_unlock(&gLock);
1033 tdm_display_check_module_abi(tdm_private_display *private_display, int abimaj, int abimin)
1035 tdm_backend_module *module = private_display->module_data;
1037 if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
1040 if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
1047 tdm_display_enable_debug_module(const char*modules)
1049 char temp[TDM_PATH_LEN];
1053 snprintf(temp, TDM_PATH_LEN, "%s", modules);
1055 tdm_debug_module = 0;
1057 arg = strtok_r(temp, TDM_DELIM, &end);
1059 if (!strncmp(arg, "none", 4)) {
1060 tdm_debug_module = 0;
1061 return TDM_ERROR_NONE;
1063 if (!strncmp(arg, "all", 3)) {
1064 tdm_debug_module = 0xFFFFFFFF;
1065 return TDM_ERROR_NONE;
1067 if (!strncmp(arg, "buffer", 6))
1068 tdm_debug_module |= TDM_DEBUG_BUFFER;
1069 else if (!strncmp(arg, "thread", 6))
1070 tdm_debug_module |= TDM_DEBUG_THREAD;
1071 else if (!strncmp(arg, "mutex", 5))
1072 tdm_debug_module |= TDM_DEBUG_MUTEX;
1073 else if (!strncmp(arg, "vblank", 6))
1074 tdm_debug_module |= TDM_DEBUG_VBLANK;
1076 return TDM_ERROR_BAD_REQUEST;
1078 arg = strtok_r(NULL, TDM_DELIM, &end);
1081 TDM_INFO("module debugging... '%s'", modules);
1083 return TDM_ERROR_NONE;
1087 tdm_display_enable_dump(const char *dump_str)
1095 snprintf(temp, sizeof(temp), "%s", dump_str);
1096 arg = strtok_r(temp, ",", &end);
1098 if (!strncmp(arg, "none", 4)) {
1100 return TDM_ERROR_NONE;
1102 if (!strncmp(arg, "all", 3)) {
1103 tdm_debug_dump = 0xFFFFFFFF;
1104 return TDM_ERROR_NONE;
1106 if (!strncmp(arg, "layer", 5))
1107 tdm_debug_dump |= TDM_DUMP_FLAG_LAYER;
1108 else if (!strncmp(arg, "pp", 2))
1109 tdm_debug_dump |= TDM_DUMP_FLAG_PP;
1110 else if (!strncmp(arg, "capture", 7))
1111 tdm_debug_dump |= TDM_DUMP_FLAG_CAPTURE;
1113 return TDM_ERROR_BAD_REQUEST;
1115 arg = strtok_r(NULL, ",", &end);
1118 TDM_INFO("dump... '%s'", dump_str);
1120 return TDM_ERROR_NONE;
1124 tdm_display_enable_path(const char *path)
1126 static int old_stdout = -1;
1127 char fd_name[TDM_PATH_LEN];
1131 if (old_stdout == -1)
1132 old_stdout = dup(STDOUT_FILENO);
1134 tdm_log_enable_dlog(0);
1136 snprintf(fd_name, TDM_PATH_LEN, "%s", path);
1138 log_fl = fopen(fd_name, "a");
1140 TDM_ERR("failed: open file(%s)\n", fd_name);
1141 return TDM_ERROR_OPERATION_FAILED;
1145 close(STDOUT_FILENO);
1147 setvbuf(log_fl, NULL, _IOLBF, 512);
1148 log_fd = fileno(log_fl);
1150 dup2(log_fd, STDOUT_FILENO);
1153 return TDM_ERROR_NONE;