src/tdm_private.h

   1 /**************************************************************************
   2
   3 libtdm
   4
   5 Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   6
   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>
  13
  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:
  21
  22 The above copyright notice and this permission notice (including the
  23 next paragraph) shall be included in all copies or substantial portions
  24 of the Software.
  25
  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.
  33
  34 **************************************************************************/
  35
  36 #ifndef _TDM_PRIVATE_H_
  37 #define _TDM_PRIVATE_H_
  38
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <stdlib.h>
  42 #include <pthread.h>
  43 #include <errno.h>
  44 #include <unistd.h>
  45 #include <limits.h>
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48 #include <fcntl.h>
  49 #include <dlfcn.h>
  50 #include <dirent.h>
  51 #include <poll.h>
  52 #include <sys/syscall.h>
  53 #include <sys/types.h>
  54
  55 #include <tbm_bufmgr.h>
  56 #include <tbm_surface_queue.h>
  57
  58 #include "tdm_backend.h"
  59 #include "tdm_log.h"
  60 #include "tdm_list.h"
  61 #include "tdm_macro.h"
  62
  63 #ifdef __cplusplus
  64 extern "C" {
  65 #endif
  66
  67 //#define INIT_BUFMGR
  68
  69 /**
  70  * @file tdm_private.h
  71  * @brief The private header file for a frontend library
  72  */
  73
  74 extern int tdm_debug_buffer;
  75 extern int tdm_debug_mutex;
  76 extern int tdm_debug_thread;
  77
  78 #ifdef HAVE_TTRACE
  79 #include <ttrace.h>
  80 #define TDM_TRACE_BEGIN(NAME) traceBegin(TTRACE_TAG_GRAPHICS, "TDM:"#NAME)
  81 #define TDM_TRACE_END() traceEnd(TTRACE_TAG_GRAPHICS)
  82 #else
  83 #define TDM_TRACE_BEGIN(NAME)
  84 #define TDM_TRACE_END()
  85 #endif
  86
  87 #define prototype_name_fn(res) const char * res##_str(int type)
  88
  89 prototype_name_fn(dpms);
  90 prototype_name_fn(status);
  91
  92 typedef enum {
  93         TDM_CAPTURE_TARGET_OUTPUT,
  94         TDM_CAPTURE_TARGET_LAYER,
  95 } tdm_capture_target;
  96
  97 typedef struct _tdm_private_display tdm_private_display;
  98 typedef struct _tdm_private_output tdm_private_output;
  99 typedef struct _tdm_private_layer tdm_private_layer;
 100 typedef struct _tdm_private_pp tdm_private_pp;
 101 typedef struct _tdm_private_capture tdm_private_capture;
 102 typedef struct _tdm_private_loop tdm_private_loop;
 103 typedef struct _tdm_private_server tdm_private_server;
 104 typedef struct _tdm_private_thread tdm_private_thread;
 105 typedef struct _tdm_private_vblank_handler tdm_private_vblank_handler;
 106 typedef struct _tdm_private_commit_handler tdm_private_commit_handler;
 107 typedef struct _tdm_private_change_handler tdm_private_change_handler;
 108
 109 struct _tdm_private_display {
 110         pthread_mutex_t lock;
 111         unsigned int init_count;
 112
 113         /* backend module info */
 114         void *module;
 115         tdm_backend_module *module_data;
 116         tdm_backend_data *bdata;
 117
 118 #ifdef INIT_BUFMGR
 119         tbm_bufmgr bufmgr;
 120 #endif
 121
 122         /* backend function */
 123         tdm_display_capability capabilities;
 124         tdm_func_display func_display;
 125         tdm_func_output func_output;
 126         tdm_func_layer func_layer;
 127         tdm_func_pp func_pp;
 128         tdm_func_capture func_capture;
 129
 130         /* backend capability */
 131         tdm_caps_display caps_display;
 132         tdm_caps_pp caps_pp;
 133         tdm_caps_capture caps_capture;
 134
 135         /* output, pp list */
 136         struct list_head output_list;
 137         struct list_head pp_list;
 138         struct list_head capture_list;
 139
 140         void **outputs_ptr;
 141
 142         /* for event handling */
 143         tdm_private_loop *private_loop;
 144
 145         /* output order */
 146         tdm_output **outputs;
 147 };
 148
 149 struct _tdm_private_output {
 150         struct list_head link;
 151
 152         unsigned long stamp;
 153
 154         tdm_private_display *private_display;
 155
 156         tdm_caps_output caps;
 157         tdm_output *output_backend;
 158
 159         unsigned int pipe;
 160         tdm_output_dpms current_dpms_value;
 161
 162         int regist_vblank_cb;
 163         int regist_commit_cb;
 164         int regist_change_cb;
 165
 166         struct list_head layer_list;
 167         struct list_head capture_list;
 168         struct list_head vblank_handler_list;
 169         struct list_head commit_handler_list;
 170
 171         /* seperate list for multi-thread*/
 172         struct list_head change_handler_list_main;
 173         struct list_head change_handler_list_sub;
 174
 175         void **layers_ptr;
 176 };
 177
 178 struct _tdm_private_layer {
 179         struct list_head link;
 180
 181         tdm_private_display *private_display;
 182         tdm_private_output *private_output;
 183
 184         tdm_caps_layer caps;
 185         tdm_layer *layer_backend;
 186
 187         tbm_surface_h pending_buffer;
 188         tbm_surface_h waiting_buffer;
 189         tbm_surface_h showing_buffer;
 190         tbm_surface_queue_h buffer_queue;
 191
 192         struct list_head capture_list;
 193
 194         unsigned int usable;
 195 };
 196
 197 struct _tdm_private_pp {
 198         struct list_head link;
 199
 200         unsigned long stamp;
 201
 202         tdm_private_display *private_display;
 203
 204         tdm_pp *pp_backend;
 205
 206         struct list_head src_pending_buffer_list;
 207         struct list_head dst_pending_buffer_list;
 208         struct list_head src_buffer_list;
 209         struct list_head dst_buffer_list;
 210
 211         pid_t owner_tid;
 212 };
 213
 214 struct _tdm_private_capture {
 215         struct list_head link;
 216         struct list_head display_link;
 217
 218         unsigned long stamp;
 219
 220         tdm_capture_target target;
 221
 222         tdm_private_display *private_display;
 223         tdm_private_output *private_output;
 224         tdm_private_layer *private_layer;
 225
 226         tdm_capture *capture_backend;
 227
 228         struct list_head pending_buffer_list;
 229         struct list_head buffer_list;
 230
 231         pid_t owner_tid;
 232 };
 233
 234 /* CAUTION:
 235  * Note that we don't need to (un)lock mutex to use this structure. If there is
 236  * no TDM thread, all TDM resources are protected by private_display's mutex.
 237  * If there is a TDM thread, this struct will be used only in a TDM thread.
 238  * So, we don't need to protect this structure by mutex. Not thread-safe.
 239  */
 240 struct _tdm_private_loop {
 241         /* TDM uses wl_event_loop to handle various event sources including the TDM
 242          * backend's fd.
 243          */
 244         struct wl_display *wl_display;
 245         struct wl_event_loop *wl_loop;
 246
 247         int backend_fd;
 248         tdm_event_loop_source *backend_source;
 249
 250         /* In event loop, all resources are accessed by this dpy.
 251          * CAUTION:
 252          * - DO NOT include other private structure in this structure because this
 253          *   struct is not protected by mutex.
 254          */
 255         tdm_display *dpy;
 256
 257         /* for handling TDM client requests */
 258         tdm_private_server *private_server;
 259
 260         /* To have a TDM event thread. If TDM_THREAD enviroment variable is not set
 261          * private_thread is NULL.
 262          */
 263         tdm_private_thread *private_thread;
 264 };
 265
 266 struct _tdm_private_vblank_handler {
 267         struct list_head link;
 268
 269         tdm_private_output *private_output;
 270         tdm_output_vblank_handler func;
 271         void *user_data;
 272
 273         pid_t owner_tid;
 274 };
 275
 276 struct _tdm_private_commit_handler {
 277         struct list_head link;
 278
 279         tdm_private_output *private_output;
 280         tdm_output_commit_handler func;
 281         void *user_data;
 282
 283         pid_t owner_tid;
 284 };
 285
 286 struct _tdm_private_change_handler {
 287         struct list_head link;
 288
 289         tdm_private_output *private_output;
 290         tdm_output_change_handler func;
 291         void *user_data;
 292
 293         pid_t owner_tid;
 294 };
 295
 296 typedef struct _tdm_buffer_info {
 297         tbm_surface_h buffer;
 298
 299         /* ref_count for backend */
 300         int backend_ref_count;
 301
 302         struct list_head release_funcs;
 303         struct list_head destroy_funcs;
 304
 305         struct list_head *list;
 306         struct list_head link;
 307 } tdm_buffer_info;
 308
 309 const char*
 310 tdm_get_dpms_str(tdm_output_dpms dpms_value);
 311
 312 int
 313 tdm_display_check_module_abi(tdm_private_display *private_display, int abimaj, int abimin);
 314
 315 tdm_private_output *
 316 tdm_display_find_output_stamp(tdm_private_display *private_display,
 317                               unsigned long stamp);
 318 tdm_private_pp *
 319 tdm_pp_find_stamp(tdm_private_display *private_display, unsigned long stamp);
 320 tdm_private_capture *
 321 tdm_capture_find_stamp(tdm_private_display *private_display, unsigned long stamp);
 322
 323 void
 324 tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
 325                      unsigned int tv_sec, unsigned int tv_usec, void *user_data);
 326 void
 327 tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
 328                      unsigned int tv_sec, unsigned int tv_usec, void *user_data);
 329 void
 330 tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status,
 331                      void *user_data);
 332 void
 333 tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst,
 334                void *user_data);
 335 void
 336 tdm_capture_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer,
 337                     void *user_data);
 338
 339 void
 340 tdm_output_call_change_handler_internal(tdm_private_output *private_output,
 341                                         struct list_head *change_handler_list,
 342                                         tdm_output_change_type type,
 343                                         tdm_value value);
 344
 345 tdm_private_pp *
 346 tdm_pp_create_internal(tdm_private_display *private_display, tdm_error *error);
 347 void
 348 tdm_pp_destroy_internal(tdm_private_pp *private_pp);
 349
 350 tdm_private_capture *
 351 tdm_capture_create_output_internal(tdm_private_output *private_output,
 352                                    tdm_error *error);
 353 tdm_private_capture *
 354 tdm_capture_create_layer_internal(tdm_private_layer *private_layer,
 355                                   tdm_error *error);
 356 void
 357 tdm_capture_destroy_internal(tdm_private_capture *private_capture);
 358
 359 /* utility buffer functions for private */
 360 tdm_buffer_info*
 361 tdm_buffer_get_info(tbm_surface_h buffer);
 362 tbm_surface_h
 363 tdm_buffer_list_get_first_entry(struct list_head *list);
 364 void
 365 tdm_buffer_list_dump(struct list_head *list);
 366
 367 /* event functions for private */
 368 tdm_error
 369 tdm_event_loop_init(tdm_private_display *private_display);
 370 void
 371 tdm_event_loop_deinit(tdm_private_display *private_display);
 372 void
 373 tdm_event_loop_create_backend_source(tdm_private_display *private_display);
 374 int
 375 tdm_event_loop_get_fd(tdm_private_display *private_display);
 376 tdm_error
 377 tdm_event_loop_dispatch(tdm_private_display *private_display);
 378 void
 379 tdm_event_loop_flush(tdm_private_display *private_display);
 380
 381 typedef enum {
 382         TDM_THREAD_CB_NONE,
 383         TDM_THREAD_CB_OUTPUT_COMMIT,
 384         TDM_THREAD_CB_OUTPUT_VBLANK,
 385         TDM_THREAD_CB_OUTPUT_STATUS,
 386         TDM_THREAD_CB_PP_DONE,
 387         TDM_THREAD_CB_CAPTURE_DONE,
 388 } tdm_thread_cb_type;
 389
 390 typedef struct _tdm_thread_cb_base tdm_thread_cb_base;
 391 typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_commit;
 392 typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_vblank;
 393 typedef struct _tdm_thread_cb_output_status tdm_thread_cb_output_status;
 394 typedef struct _tdm_thread_cb_pp_done tdm_thread_cb_pp_done;
 395 typedef struct _tdm_thread_cb_capture_done tdm_thread_cb_capture_done;
 396
 397 struct _tdm_thread_cb_base {
 398         tdm_thread_cb_type type;
 399         unsigned int length;
 400 };
 401
 402 struct _tdm_thread_cb_output_vblank {
 403         tdm_thread_cb_base base;
 404         unsigned long output_stamp;
 405         unsigned int sequence;
 406         unsigned int tv_sec;
 407         unsigned int tv_usec;
 408         void *user_data;
 409 };
 410
 411 struct _tdm_thread_cb_output_status {
 412         tdm_thread_cb_base base;
 413         unsigned long output_stamp;
 414         tdm_output_conn_status status;
 415         void *user_data;
 416 };
 417
 418 struct _tdm_thread_cb_pp_done {
 419         tdm_thread_cb_base base;
 420         unsigned long pp_stamp;
 421         tbm_surface_h src;
 422         tbm_surface_h dst;
 423         void *user_data;
 424 };
 425
 426 struct _tdm_thread_cb_capture_done {
 427         tdm_thread_cb_base base;
 428         unsigned long capture_stamp;
 429         tbm_surface_h buffer;
 430         void *user_data;
 431 };
 432
 433 tdm_error
 434 tdm_thread_init(tdm_private_loop *private_loop);
 435 void
 436 tdm_thread_deinit(tdm_private_loop *private_loop);
 437 int
 438 tdm_thread_get_fd(tdm_private_loop *private_loop);
 439 tdm_error
 440 tdm_thread_send_cb(tdm_private_loop *private_loop, tdm_thread_cb_base *base);
 441 tdm_error
 442 tdm_thread_handle_cb(tdm_private_loop *private_loop);
 443 int
 444 tdm_thread_in_display_thread(pid_t tid);
 445 int
 446 tdm_thread_is_running(void);
 447
 448 tdm_error
 449 tdm_server_init(tdm_private_loop *private_loop);
 450 void
 451 tdm_server_deinit(tdm_private_loop *private_loop);
 452
 453 unsigned long
 454 tdm_helper_get_time_in_millis(void);
 455 unsigned long
 456 tdm_helper_get_time_in_micros(void);
 457
 458 extern pthread_mutex_t tdm_mutex_check_lock;
 459 extern int tdm_mutex_locked;
 460 extern int tdm_dump_enable;
 461
 462 #define _pthread_mutex_unlock(l) \
 463         do { \
 464                 if (tdm_debug_mutex) \
 465                         TDM_INFO("mutex unlock"); \
 466                 pthread_mutex_lock(&tdm_mutex_check_lock); \
 467                 tdm_mutex_locked = 0; \
 468                 pthread_mutex_unlock(&tdm_mutex_check_lock); \
 469                 pthread_mutex_unlock(l); \
 470         } while (0)
 471 #ifdef TDM_CONFIG_MUTEX_TIMEOUT
 472 #define MUTEX_TIMEOUT_SEC 5
 473 #define _pthread_mutex_lock(l) \
 474         do { \
 475                 if (tdm_debug_mutex) \
 476                         TDM_INFO("mutex lock"); \
 477                 struct timespec rtime; \
 478                 clock_gettime(CLOCK_REALTIME, &rtime); \
 479                 rtime.tv_sec += MUTEX_TIMEOUT_SEC; \
 480                 if (pthread_mutex_timedlock(l, &rtime)) { \
 481                         TDM_ERR("Mutex lock failed PID %d", getpid()); \
 482                         _pthread_mutex_unlock(l); \
 483                 } \
 484                 else { \
 485                         pthread_mutex_lock(&tdm_mutex_check_lock); \
 486                         tdm_mutex_locked = 1; \
 487                         pthread_mutex_unlock(&tdm_mutex_check_lock); \
 488                 } \
 489         } while (0)
 490 #else //TDM_CONFIG_MUTEX_TIMEOUT
 491 #define _pthread_mutex_lock(l) \
 492         do { \
 493                 if (tdm_debug_mutex) \
 494                         TDM_INFO("mutex lock"); \
 495                 pthread_mutex_lock(l); \
 496                 pthread_mutex_lock(&tdm_mutex_check_lock); \
 497                 tdm_mutex_locked = 1; \
 498                 pthread_mutex_unlock(&tdm_mutex_check_lock); \
 499         } while (0)
 500 #endif //TDM_CONFIG_MUTEX_TIMEOUT
 501 //#define TDM_MUTEX_IS_LOCKED() (tdm_mutex_locked == 1)
 502 static inline int TDM_MUTEX_IS_LOCKED(void)
 503 {
 504         int ret;
 505         pthread_mutex_lock(&tdm_mutex_check_lock);
 506         ret = (tdm_mutex_locked == 1);
 507         pthread_mutex_unlock(&tdm_mutex_check_lock);
 508         return ret;
 509 }
 510
 511 tdm_error
 512 _tdm_display_lock(tdm_display *dpy, const char *func);
 513 void
 514 _tdm_display_unlock(tdm_display *dpy, const char *func);
 515
 516 #define tdm_display_lock(dpy)   _tdm_display_lock(dpy, __FUNCTION__)
 517 #define tdm_display_unlock(dpy)   _tdm_display_unlock(dpy, __FUNCTION__)
 518
 519 tdm_error
 520 tdm_display_update_output(tdm_private_display *private_display,
 521                           tdm_output *output_backend, int pipe);
 522
 523 #ifdef __cplusplus
 524 }
 525 #endif
 526
 527 #endif /* _TDM_PRIVATE_H_ */