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
 146 struct _tdm_private_output {
 147         struct list_head link;
 148
 149         unsigned long stamp;
 150
 151         tdm_private_display *private_display;
 152
 153         tdm_caps_output caps;
 154         tdm_output *output_backend;
 155
 156         unsigned int pipe;
 157         tdm_output_dpms current_dpms_value;
 158
 159         int regist_vblank_cb;
 160         int regist_commit_cb;
 161         int regist_change_cb;
 162
 163         struct list_head layer_list;
 164         struct list_head capture_list;
 165         struct list_head vblank_handler_list;
 166         struct list_head commit_handler_list;
 167
 168         /* seperate list for multi-thread*/
 169         struct list_head change_handler_list_main;
 170         struct list_head change_handler_list_sub;
 171
 172         void **layers_ptr;
 173 };
 174
 175 struct _tdm_private_layer {
 176         struct list_head link;
 177
 178         tdm_private_display *private_display;
 179         tdm_private_output *private_output;
 180
 181         tdm_caps_layer caps;
 182         tdm_layer *layer_backend;
 183
 184         tbm_surface_h pending_buffer;
 185         tbm_surface_h waiting_buffer;
 186         tbm_surface_h showing_buffer;
 187         tbm_surface_queue_h buffer_queue;
 188
 189         struct list_head capture_list;
 190
 191         unsigned int usable;
 192 };
 193
 194 struct _tdm_private_pp {
 195         struct list_head link;
 196
 197         unsigned long stamp;
 198
 199         tdm_private_display *private_display;
 200
 201         tdm_pp *pp_backend;
 202
 203         struct list_head src_pending_buffer_list;
 204         struct list_head dst_pending_buffer_list;
 205         struct list_head src_buffer_list;
 206         struct list_head dst_buffer_list;
 207
 208         pid_t owner_tid;
 209 };
 210
 211 struct _tdm_private_capture {
 212         struct list_head link;
 213         struct list_head display_link;
 214
 215         unsigned long stamp;
 216
 217         tdm_capture_target target;
 218
 219         tdm_private_display *private_display;
 220         tdm_private_output *private_output;
 221         tdm_private_layer *private_layer;
 222
 223         tdm_capture *capture_backend;
 224
 225         struct list_head pending_buffer_list;
 226         struct list_head buffer_list;
 227
 228         pid_t owner_tid;
 229 };
 230
 231 /* CAUTION:
 232  * Note that we don't need to (un)lock mutex to use this structure. If there is
 233  * no TDM thread, all TDM resources are protected by private_display's mutex.
 234  * If there is a TDM thread, this struct will be used only in a TDM thread.
 235  * So, we don't need to protect this structure by mutex. Not thread-safe.
 236  */
 237 struct _tdm_private_loop {
 238         /* TDM uses wl_event_loop to handle various event sources including the TDM
 239          * backend's fd.
 240          */
 241         struct wl_display *wl_display;
 242         struct wl_event_loop *wl_loop;
 243
 244         int backend_fd;
 245         tdm_event_loop_source *backend_source;
 246
 247         /* In event loop, all resources are accessed by this dpy.
 248          * CAUTION:
 249          * - DO NOT include other private structure in this structure because this
 250          *   struct is not protected by mutex.
 251          */
 252         tdm_display *dpy;
 253
 254         /* for handling TDM client requests */
 255         tdm_private_server *private_server;
 256
 257         /* To have a TDM event thread. If TDM_THREAD enviroment variable is not set
 258          * private_thread is NULL.
 259          */
 260         tdm_private_thread *private_thread;
 261 };
 262
 263 struct _tdm_private_vblank_handler {
 264         struct list_head link;
 265
 266         tdm_private_output *private_output;
 267         tdm_output_vblank_handler func;
 268         void *user_data;
 269
 270         pid_t owner_tid;
 271 };
 272
 273 struct _tdm_private_commit_handler {
 274         struct list_head link;
 275
 276         tdm_private_output *private_output;
 277         tdm_output_commit_handler func;
 278         void *user_data;
 279
 280         pid_t owner_tid;
 281 };
 282
 283 struct _tdm_private_change_handler {
 284         struct list_head link;
 285
 286         tdm_private_output *private_output;
 287         tdm_output_change_handler func;
 288         void *user_data;
 289
 290         pid_t owner_tid;
 291 };
 292
 293 typedef struct _tdm_buffer_info {
 294         tbm_surface_h buffer;
 295
 296         /* ref_count for backend */
 297         int backend_ref_count;
 298
 299         struct list_head release_funcs;
 300         struct list_head destroy_funcs;
 301
 302         struct list_head *list;
 303         struct list_head link;
 304 } tdm_buffer_info;
 305
 306 const char*
 307 tdm_get_dpms_str(tdm_output_dpms dpms_value);
 308
 309 int
 310 tdm_display_check_module_abi(tdm_private_display *private_display, int abimaj, int abimin);
 311
 312 tdm_private_output *
 313 tdm_display_find_output_stamp(tdm_private_display *private_display,
 314                               unsigned long stamp);
 315 tdm_private_pp *
 316 tdm_pp_find_stamp(tdm_private_display *private_display, unsigned long stamp);
 317 tdm_private_capture *
 318 tdm_capture_find_stamp(tdm_private_display *private_display, unsigned long stamp);
 319
 320 void
 321 tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
 322                      unsigned int tv_sec, unsigned int tv_usec, void *user_data);
 323 void
 324 tdm_output_cb_commit(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_status(tdm_output *output_backend, tdm_output_conn_status status,
 328                      void *user_data);
 329 void
 330 tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst,
 331                void *user_data);
 332 void
 333 tdm_capture_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer,
 334                     void *user_data);
 335
 336 void
 337 tdm_output_call_change_handler_internal(tdm_private_output *private_output,
 338                                         struct list_head *change_handler_list,
 339                                         tdm_output_change_type type,
 340                                         tdm_value value);
 341
 342 tdm_private_pp *
 343 tdm_pp_create_internal(tdm_private_display *private_display, tdm_error *error);
 344 void
 345 tdm_pp_destroy_internal(tdm_private_pp *private_pp);
 346
 347 tdm_private_capture *
 348 tdm_capture_create_output_internal(tdm_private_output *private_output,
 349                                    tdm_error *error);
 350 tdm_private_capture *
 351 tdm_capture_create_layer_internal(tdm_private_layer *private_layer,
 352                                   tdm_error *error);
 353 void
 354 tdm_capture_destroy_internal(tdm_private_capture *private_capture);
 355
 356 /* utility buffer functions for private */
 357 tdm_buffer_info*
 358 tdm_buffer_get_info(tbm_surface_h buffer);
 359 tbm_surface_h
 360 tdm_buffer_list_get_first_entry(struct list_head *list);
 361 void
 362 tdm_buffer_list_dump(struct list_head *list);
 363
 364 /* event functions for private */
 365 tdm_error
 366 tdm_event_loop_init(tdm_private_display *private_display);
 367 void
 368 tdm_event_loop_deinit(tdm_private_display *private_display);
 369 void
 370 tdm_event_loop_create_backend_source(tdm_private_display *private_display);
 371 int
 372 tdm_event_loop_get_fd(tdm_private_display *private_display);
 373 tdm_error
 374 tdm_event_loop_dispatch(tdm_private_display *private_display);
 375 void
 376 tdm_event_loop_flush(tdm_private_display *private_display);
 377
 378 typedef enum {
 379         TDM_THREAD_CB_NONE,
 380         TDM_THREAD_CB_OUTPUT_COMMIT,
 381         TDM_THREAD_CB_OUTPUT_VBLANK,
 382         TDM_THREAD_CB_OUTPUT_STATUS,
 383         TDM_THREAD_CB_PP_DONE,
 384         TDM_THREAD_CB_CAPTURE_DONE,
 385 } tdm_thread_cb_type;
 386
 387 typedef struct _tdm_thread_cb_base tdm_thread_cb_base;
 388 typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_commit;
 389 typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_vblank;
 390 typedef struct _tdm_thread_cb_output_status tdm_thread_cb_output_status;
 391 typedef struct _tdm_thread_cb_pp_done tdm_thread_cb_pp_done;
 392 typedef struct _tdm_thread_cb_capture_done tdm_thread_cb_capture_done;
 393
 394 struct _tdm_thread_cb_base {
 395         tdm_thread_cb_type type;
 396         unsigned int length;
 397 };
 398
 399 struct _tdm_thread_cb_output_vblank {
 400         tdm_thread_cb_base base;
 401         unsigned long output_stamp;
 402         unsigned int sequence;
 403         unsigned int tv_sec;
 404         unsigned int tv_usec;
 405         void *user_data;
 406 };
 407
 408 struct _tdm_thread_cb_output_status {
 409         tdm_thread_cb_base base;
 410         unsigned long output_stamp;
 411         tdm_output_conn_status status;
 412         void *user_data;
 413 };
 414
 415 struct _tdm_thread_cb_pp_done {
 416         tdm_thread_cb_base base;
 417         unsigned long pp_stamp;
 418         tbm_surface_h src;
 419         tbm_surface_h dst;
 420         void *user_data;
 421 };
 422
 423 struct _tdm_thread_cb_capture_done {
 424         tdm_thread_cb_base base;
 425         unsigned long capture_stamp;
 426         tbm_surface_h buffer;
 427         void *user_data;
 428 };
 429
 430 tdm_error
 431 tdm_thread_init(tdm_private_loop *private_loop);
 432 void
 433 tdm_thread_deinit(tdm_private_loop *private_loop);
 434 int
 435 tdm_thread_get_fd(tdm_private_loop *private_loop);
 436 tdm_error
 437 tdm_thread_send_cb(tdm_private_loop *private_loop, tdm_thread_cb_base *base);
 438 tdm_error
 439 tdm_thread_handle_cb(tdm_private_loop *private_loop);
 440 int
 441 tdm_thread_in_display_thread(pid_t tid);
 442 int
 443 tdm_thread_is_running(void);
 444
 445 tdm_error
 446 tdm_server_init(tdm_private_loop *private_loop);
 447 void
 448 tdm_server_deinit(tdm_private_loop *private_loop);
 449
 450 unsigned long
 451 tdm_helper_get_time_in_millis(void);
 452 unsigned long
 453 tdm_helper_get_time_in_micros(void);
 454
 455 extern pthread_mutex_t tdm_mutex_check_lock;
 456 extern int tdm_mutex_locked;
 457 extern int tdm_dump_enable;
 458
 459 int
 460 tdm_helper_get_dump_count(void);
 461 char *
 462 tdm_helper_get_dump_path(void);
 463
 464 #define _pthread_mutex_unlock(l) \
 465         do { \
 466                 if (tdm_debug_mutex) \
 467                         TDM_INFO("mutex unlock"); \
 468                 pthread_mutex_lock(&tdm_mutex_check_lock); \
 469                 tdm_mutex_locked = 0; \
 470                 pthread_mutex_unlock(&tdm_mutex_check_lock); \
 471                 pthread_mutex_unlock(l); \
 472         } while (0)
 473 #ifdef TDM_CONFIG_MUTEX_TIMEOUT
 474 #define MUTEX_TIMEOUT_SEC 5
 475 #define _pthread_mutex_lock(l) \
 476         do { \
 477                 if (tdm_debug_mutex) \
 478                         TDM_INFO("mutex lock"); \
 479                 struct timespec rtime; \
 480                 clock_gettime(CLOCK_REALTIME, &rtime); \
 481                 rtime.tv_sec += MUTEX_TIMEOUT_SEC; \
 482                 if (pthread_mutex_timedlock(l, &rtime)) { \
 483                         TDM_ERR("Mutex lock failed PID %d", getpid()); \
 484                         _pthread_mutex_unlock(l); \
 485                 } \
 486                 else { \
 487                         pthread_mutex_lock(&tdm_mutex_check_lock); \
 488                         tdm_mutex_locked = 1; \
 489                         pthread_mutex_unlock(&tdm_mutex_check_lock); \
 490                 } \
 491         } while (0)
 492 #else //TDM_CONFIG_MUTEX_TIMEOUT
 493 #define _pthread_mutex_lock(l) \
 494         do { \
 495                 if (tdm_debug_mutex) \
 496                         TDM_INFO("mutex lock"); \
 497                 pthread_mutex_lock(l); \
 498                 pthread_mutex_lock(&tdm_mutex_check_lock); \
 499                 tdm_mutex_locked = 1; \
 500                 pthread_mutex_unlock(&tdm_mutex_check_lock); \
 501         } while (0)
 502 #endif //TDM_CONFIG_MUTEX_TIMEOUT
 503 //#define TDM_MUTEX_IS_LOCKED() (tdm_mutex_locked == 1)
 504 static inline int TDM_MUTEX_IS_LOCKED(void)
 505 {
 506         int ret;
 507         pthread_mutex_lock(&tdm_mutex_check_lock);
 508         ret = (tdm_mutex_locked == 1);
 509         pthread_mutex_unlock(&tdm_mutex_check_lock);
 510         return ret;
 511 }
 512
 513 tdm_error
 514 _tdm_display_lock(tdm_display *dpy, const char *func);
 515 void
 516 _tdm_display_unlock(tdm_display *dpy, const char *func);
 517
 518 #define tdm_display_lock(dpy)   _tdm_display_lock(dpy, __FUNCTION__)
 519 #define tdm_display_unlock(dpy)   _tdm_display_unlock(dpy, __FUNCTION__)
 520
 521 #ifdef __cplusplus
 522 }
 523 #endif
 524
 525 #endif /* _TDM_PRIVATE_H_ */