tdm_private_display *private_display; \
tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
- TDM_RETURN_VAL_IF_FAIL(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER); \
private_display = (tdm_private_display*)dpy;
#define DISPLAY_FUNC_ENTRY_ERROR() \
tdm_private_display *private_display; \
tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
- TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER, NULL); \
private_display = (tdm_private_display*)dpy;
+#define DISPLAY_FUNC_ENTRY_VOID() \
+ tdm_private_display *private_display; \
+ TDM_RETURN_IF_FAIL(dpy != NULL); \
+ TDM_RETURN_IF_FAIL(tdm_display_is_valid(dpy)); \
+ private_display = (tdm_private_display*)dpy;
+
+
#define BACKEND_FUNC_ENTRY() \
tdm_private_module *private_module; \
tdm_private_display *private_display; \
private_module = (tdm_private_module*)module; \
private_display = private_module->private_display;
+/* LCOV_EXCL_START */
INTERN tdm_error
tdm_display_enable_debug_module(const char*modules)
{
return TDM_ERROR_NONE;
}
+/* LCOV_EXCL_STOP */
+
+INTERN tdm_error
+tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output)
+{
+ tdm_thread_cb_display_output_create output_create;
+ tdm_error ret;
+
+ memset(&output_create, 0, sizeof output_create);
+ output_create.base.type = TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE;
+ output_create.base.length = sizeof output_create;
+ output_create.base.object_stamp = 0;
+ output_create.base.data = NULL;
+ output_create.base.sync = 1;
+ output_create.output = output;
+
+ ret = tdm_thread_cb_call(private_display, &output_create.base, 1);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+ return TDM_ERROR_NONE;
+}
+
+INTERN void
+tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
+{
+ tdm_thread_cb_display_output_create *output_create = (tdm_thread_cb_display_output_create*)cb_base;
+ tdm_private_output_create_handler *create_handler = user_data;
+ TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+ assert(create_handler->owner_tid == syscall(SYS_gettid));
+
+ _pthread_mutex_unlock(&private_display->lock);
+ create_handler->func(private_display, output_create->output, create_handler->user_data);
+ _pthread_mutex_lock(&private_display->lock);
+}
+
+EXTERN tdm_error
+tdm_display_add_output_create_handler(tdm_display *dpy,
+ tdm_output_create_handler func,
+ void *user_data)
+{
+ tdm_private_output_create_handler *create_handler = NULL;
+
+ DISPLAY_FUNC_ENTRY();
+
+ TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ LIST_FOR_EACH_ENTRY(create_handler, &private_display->output_create_handler_list, link) {
+ if (create_handler->func == func && create_handler->user_data == user_data) {
+ TDM_ERR("can't add twice");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_BAD_REQUEST;
+ }
+ }
+
+ create_handler = calloc(1, sizeof(tdm_private_output_create_handler));
+ if (!create_handler) {
+ TDM_ERR("failed: alloc memory");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = tdm_thread_cb_add(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+ tdm_display_thread_cb_output_create, create_handler);
+ if (ret != TDM_ERROR_NONE) {
+ TDM_ERR("tdm_thread_cb_add failed");
+ free(create_handler);
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_OPERATION_FAILED;
+ }
+
+ create_handler->private_display = private_display;
+ create_handler->func = func;
+ create_handler->user_data = user_data;
+ create_handler->owner_tid = syscall(SYS_gettid);
+
+ LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list);
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return ret;
+}
+
+EXTERN void
+tdm_display_remove_output_create_handler(tdm_display *dpy,
+ tdm_output_create_handler func,
+ void *user_data)
+{
+ tdm_private_display *private_display;
+ tdm_private_output_create_handler *create_handler = NULL, *hh = NULL;
+
+ TDM_RETURN_IF_FAIL(dpy != NULL);
+ TDM_RETURN_IF_FAIL(func != NULL);
+
+ private_display = (tdm_private_display*)dpy;
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ LIST_FOR_EACH_ENTRY_SAFE(create_handler, hh, &private_display->output_create_handler_list, link) {
+ if (create_handler->func != func || create_handler->user_data != user_data)
+ continue;
+
+ tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+ tdm_display_thread_cb_output_create, create_handler);
+
+ LIST_DEL(&create_handler->link);
+ free(create_handler);
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return;
+ }
+
+ _pthread_mutex_unlock(&private_display->lock);
+}
EXTERN tdm_error
tdm_display_get_capabilities(tdm_display *dpy,
{
tdm_private_module *private_module = NULL;
tdm_private_output *private_output = NULL;
+ tdm_private_output *mode_setted_output = NULL;
+ tdm_private_output *connected_output = NULL;
+ unsigned int find_primary = 0;
DISPLAY_FUNC_ENTRY_ERROR();
- if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7)) {
- return tdm_display_get_output(dpy, 0, error);
- }
+ if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
+ find_primary = 1;
_pthread_mutex_lock(&private_display->lock);
if (error)
*error = TDM_ERROR_NONE;
+ if (find_primary) {
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
+ connected_output = private_output;
+ else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
+ mode_setted_output = private_output;
+ }
+ }
+
+ if (mode_setted_output) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return mode_setted_output;
+ }
+
+ if (connected_output) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return connected_output;
+ }
+
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->index == 0) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
+ }
+ }
+ }
+
LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
return NULL;
}
+INTERN tdm_output *
+tdm_display_create_output(tdm_display *dpy, const char *name, tdm_error *error)
+{
+ tdm_private_module *private_module = NULL;
+ tdm_private_module *current_module = NULL;
+ tdm_private_output *private_output = NULL;
+ tdm_func_display *func_display = NULL;
+ tdm_output *output = NULL;
+ int output_find = 0;
+
+ DISPLAY_FUNC_ENTRY_ERROR();
+
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
+ private_display = (tdm_private_display*)dpy;
+
+ private_module = private_display->virtual_module;
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_module != NULL, TDM_ERROR_BAD_MODULE, NULL);
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ if (error)
+ *error = TDM_ERROR_NONE;
+
+ func_display = &private_module->func_display;
+ current_module = private_display->current_module;
+ private_display->current_module = private_module;
+ output = func_display->display_output_create(private_module->bdata, name, &ret);
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->output_backend == output) {
+ output_find = 1;
+ break;
+ }
+ }
+ private_display->current_module = current_module;
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, ret, NULL);
+ if (output_find != 1)
+ private_output = NULL;
+
+ return private_output;
+}
+
+INTERN tdm_error
+tdm_display_destroy_output(tdm_display *dpy, tdm_output *output)
+{
+ tdm_private_module *private_module = NULL;
+ tdm_private_module *current_module = NULL;
+ tdm_private_output *private_output = NULL;
+ tdm_func_display *func_display = NULL;
+
+ DISPLAY_FUNC_ENTRY();
+
+ TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
+ private_display = (tdm_private_display*)dpy;
+
+ private_module = private_display->virtual_module;
+ TDM_RETURN_VAL_IF_FAIL(private_module != NULL, TDM_ERROR_BAD_MODULE);
+
+ private_output = (tdm_private_output*)output;
+
+ _pthread_mutex_lock(&private_display->lock);
+
+ func_display = &private_module->func_display;
+ current_module = private_display->current_module;
+ private_display->current_module = private_module;
+ ret = func_display->display_output_destroy(private_module->bdata, private_output->output_backend);
+ private_display->current_module = current_module;
+
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return ret;
+}
+
EXTERN tdm_error
tdm_display_get_fd(tdm_display *dpy, int *fd)
{