src/hal-api-tdm.c

   1 /**************************************************************************
   2  *
   3  * hal-api-tdm
   4  *
   5  * Copyright 2021 Samsung Electronics co., Ltd. All Rights Reserved.
   6  *
   7  * Contact: SooChan Lim <sc1.lim@samsung.com>,
   8  *          Junkyeong Kim <jk0430.kim@samsung.com>,
   9  *          Shawn Lee <shiin.lee@samsung.com>,
  10  *          Changyeon Lee <cyeon.lee@samsung.com>,
  11  *          Joonbum Ko <joonbum.ko@samsung.com>
  12  *
  13  * Permission is hereby granted, free of charge, to any person obtaining a
  14  * copy of this software and associated documentation files (the
  15  * "Software"), to deal in the Software without restriction, including
  16  * without limitation the rights to use, copy, modify, merge, publish,
  17  * distribute, sub license, and/or sell copies of the Software, and to
  18  * permit persons to whom the Software is furnished to do so, subject to
  19  * the following conditions:
  20  *
  21  * The above copyright notice and this permission notice (including the
  22  * next paragraph) shall be included in all copies or substantial portions
  23  * of the Software.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  26  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  28  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  29  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  30  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  31  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32  *
  33 **************************************************************************/
  34
  35 #include <stdio.h>
  36 #include <stdint.h>
  37 #include <stdlib.h>
  38 #include <dlfcn.h>
  39 #include <dlog.h>
  40
  41 #include <hal-common.h>
  42 #include "hal-tdm.h"
  43 #include "hal-tdm-interface.h"
  44 #include "common.h"
  45
  46 #if defined(__GNUC__) && __GNUC__ >= 4
  47 #define EXTERN __attribute__ ((visibility("default")))
  48 #else
  49 #define EXTERN
  50 #endif
  51
  52 #if defined(__GNUC__) && __GNUC__ >= 4
  53 #define INTERN __attribute__ ((visibility("hidden")))
  54 #else
  55 #define INTERN
  56 #endif
  57
  58 #define ARRAY_SIZE(name)        (sizeof(name)/sizeof(name[0]))
  59
  60 #define DISPLAY_FUNC_ENTRY(__func__) \
  61         hal_tdm_display_funcs *display_funcs; \
  62         if (!display) return HAL_TDM_ERROR_INVALID_PARAMETER; \
  63         if (!g_hal_tdm_backend_data) return HAL_TDM_ERROR_NO_MODULE; \
  64         if (!g_hal_tdm_backend_data->display_funcs) return HAL_TDM_ERROR_NOT_IMPLEMENTED; \
  65         display_funcs = g_hal_tdm_backend_data->display_funcs; \
  66         if (!display_funcs->__func__) return HAL_TDM_ERROR_NOT_IMPLEMENTED;
  67
  68 #define DISPLAY_FUNC_ENTRY_NULL(__func__) \
  69         hal_tdm_display_funcs *display_funcs; \
  70         if (!display) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
  71         if (!g_hal_tdm_backend_data) { if (*error) *error = HAL_TDM_ERROR_NO_MODULE; return NULL; } \
  72         if (!g_hal_tdm_backend_data->display_funcs) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
  73         display_funcs = g_hal_tdm_backend_data->display_funcs; \
  74         if (!display_funcs->__func__) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; };
  75
  76 #define OUTPUT_FUNC_ENTRY(__func__) \
  77         hal_tdm_output_funcs *output_funcs; \
  78         if (!output) return HAL_TDM_ERROR_INVALID_PARAMETER; \
  79         if (!g_hal_tdm_backend_data) return HAL_TDM_ERROR_NO_MODULE; \
  80         if (!g_hal_tdm_backend_data->output_funcs) return HAL_TDM_ERROR_NOT_IMPLEMENTED; \
  81         output_funcs = g_hal_tdm_backend_data->output_funcs; \
  82         if (!output_funcs->__func__) return HAL_TDM_ERROR_NOT_IMPLEMENTED;
  83
  84 #define OUTPUT_FUNC_ENTRY_NULL(__func__) \
  85         hal_tdm_output_funcs *output_funcs; \
  86         if (!output) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
  87         if (!g_hal_tdm_backend_data) { if (*error) *error = HAL_TDM_ERROR_NO_MODULE; return NULL; } \
  88         if (!g_hal_tdm_backend_data->output_funcs) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
  89         output_funcs = g_hal_tdm_backend_data->output_funcs; \
  90         if (!output_funcs->__func__) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; };
  91
  92 #define VOUTPUT_FUNC_ENTRY(__func__) \
  93         hal_tdm_voutput_funcs *voutput_funcs; \
  94         if (!voutput) return HAL_TDM_ERROR_INVALID_PARAMETER; \
  95         if (!g_hal_tdm_backend_data) return HAL_TDM_ERROR_NO_MODULE; \
  96         if (!g_hal_tdm_backend_data->voutput_funcs) return HAL_TDM_ERROR_NOT_IMPLEMENTED; \
  97         voutput_funcs = g_hal_tdm_backend_data->voutput_funcs; \
  98         if (!voutput_funcs->__func__) return HAL_TDM_ERROR_NOT_IMPLEMENTED;
  99
 100 #define VOUTPUT_FUNC_ENTRY_NULL(__func__) \
 101         hal_tdm_voutput_funcs *voutput_funcs; \
 102         if (!voutput) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
 103         if (!g_hal_tdm_backend_data) { if (*error) *error = HAL_TDM_ERROR_NO_MODULE; return NULL; } \
 104         if (!g_hal_tdm_backend_data->voutput_funcs) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
 105         voutput_funcs = g_hal_tdm_backend_data->voutput_funcs; \
 106         if (!voutput_funcs->__func__) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; };
 107
 108 #define HWC_FUNC_ENTRY(__func__) \
 109         hal_tdm_hwc_funcs *hwc_funcs; \
 110         if (!hwc) return HAL_TDM_ERROR_INVALID_PARAMETER; \
 111         if (!g_hal_tdm_backend_data) return HAL_TDM_ERROR_NO_MODULE; \
 112         if (!g_hal_tdm_backend_data->hwc_funcs) return HAL_TDM_ERROR_NOT_IMPLEMENTED; \
 113         hwc_funcs = g_hal_tdm_backend_data->hwc_funcs; \
 114         if (!hwc_funcs->__func__) return HAL_TDM_ERROR_NOT_IMPLEMENTED;
 115
 116 #define HWC_FUNC_ENTRY_NULL(__func__) \
 117         hal_tdm_hwc_funcs *hwc_funcs; \
 118         if (!hwc) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
 119         if (!g_hal_tdm_backend_data) { if (*error) *error = HAL_TDM_ERROR_NO_MODULE; return NULL; } \
 120         if (!g_hal_tdm_backend_data->hwc_funcs) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
 121         hwc_funcs = g_hal_tdm_backend_data->hwc_funcs; \
 122         if (!hwc_funcs->__func__) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; };
 123
 124 #define HWC_WINDOW_FUNC_ENTRY(__func__) \
 125         hal_tdm_hwc_window_funcs *hwc_window_funcs; \
 126         if (!hwc_window) return HAL_TDM_ERROR_INVALID_PARAMETER; \
 127         if (!g_hal_tdm_backend_data) return HAL_TDM_ERROR_NO_MODULE; \
 128         if (!g_hal_tdm_backend_data->hwc_window_funcs) return HAL_TDM_ERROR_NOT_IMPLEMENTED; \
 129         hwc_window_funcs = g_hal_tdm_backend_data->hwc_window_funcs; \
 130         if (!hwc_window_funcs->__func__) return HAL_TDM_ERROR_NOT_IMPLEMENTED;
 131
 132 #define HWC_WINDOW_FUNC_ENTRY_NULL(__func__) \
 133         hal_tdm_hwc_window_funcs *hwc_window_funcs; \
 134         if (!hwc_window) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
 135         if (!g_hal_tdm_backend_data) { if (*error) *error = HAL_TDM_ERROR_NO_MODULE; return NULL; } \
 136         if (!g_hal_tdm_backend_data->hwc_window_funcs) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; } \
 137         hwc_window_funcs = g_hal_tdm_backend_data->hwc_window_funcs; \
 138         if (!hwc_window_funcs->__func__) { if (*error) *error = HAL_TDM_ERROR_NOT_IMPLEMENTED; return NULL; };
 139
 140 #define HWC_WINDOW_FUNC_ENTRY_VOID(__func__) \
 141         hal_tdm_hwc_window_funcs *hwc_window_funcs; \
 142         if (!hwc_window) return; \
 143         if (!g_hal_tdm_backend_data) return; \
 144         if (!g_hal_tdm_backend_data->hwc_window_funcs) return; \
 145         hwc_window_funcs = g_hal_tdm_backend_data->hwc_window_funcs; \
 146         if (!hwc_window_funcs->__func__) return;
 147
 148 #define PP_FUNC_ENTRY(__func__) \
 149         hal_tdm_pp_funcs *pp_funcs; \
 150         if (!pp) return HAL_TDM_ERROR_INVALID_PARAMETER; \
 151         if (!g_hal_tdm_backend_data) return HAL_TDM_ERROR_NO_MODULE; \
 152         if (!g_hal_tdm_backend_data->pp_funcs) return HAL_TDM_ERROR_NOT_IMPLEMENTED; \
 153         pp_funcs = g_hal_tdm_backend_data->pp_funcs; \
 154         if (!pp_funcs->__func__) return HAL_TDM_ERROR_NOT_IMPLEMENTED;
 155
 156 #define PP_FUNC_ENTRY_VOID(__func__) \
 157         hal_tdm_pp_funcs *pp_funcs; \
 158         if (!pp) return; \
 159         if (!g_hal_tdm_backend_data) return; \
 160         if (!g_hal_tdm_backend_data->pp_funcs) return; \
 161         pp_funcs = g_hal_tdm_backend_data->pp_funcs; \
 162         if (!pp_funcs->__func__) return;
 163
 164 #define CAPTURE_FUNC_ENTRY(__func__) \
 165         hal_tdm_capture_funcs *capture_funcs; \
 166         if (!capture) return HAL_TDM_ERROR_INVALID_PARAMETER; \
 167         if (!g_hal_tdm_backend_data) return HAL_TDM_ERROR_NO_MODULE; \
 168         if (!g_hal_tdm_backend_data->capture_funcs) return HAL_TDM_ERROR_NOT_IMPLEMENTED; \
 169         capture_funcs = g_hal_tdm_backend_data->capture_funcs; \
 170         if (!capture_funcs->__func__) return HAL_TDM_ERROR_NOT_IMPLEMENTED;
 171
 172 #define CAPTURE_FUNC_ENTRY_VOID(__func__) \
 173         hal_tdm_capture_funcs *capture_funcs; \
 174         if (!capture) return; \
 175         if (!g_hal_tdm_backend_data) return; \
 176         if (!g_hal_tdm_backend_data->capture_funcs) return; \
 177         capture_funcs = g_hal_tdm_backend_data->capture_funcs; \
 178         if (!capture_funcs->__func__) return;
 179
 180 static hal_tdm_backend_data *g_hal_tdm_backend_data = NULL;
 181
 182 EXTERN hal_tdm_backend *
 183 hal_tdm_get_backend(hal_tdm_error *error)
 184 {
 185         hal_tdm_backend_data *backend_data;
 186         int ret;
 187
 188         if (g_hal_tdm_backend_data) {
 189                 if (error)
 190                         *error = HAL_TDM_ERROR_BAD_REQUEST;
 191                 return NULL;
 192         }
 193
 194         ret = hal_common_get_backend(HAL_MODULE_TDM, (void **)&backend_data);
 195         if (ret < 0) {
 196                  HAL_TDM_ERR("Failed to get backend\n");
 197                  if (error)
 198                         *error = HAL_TDM_ERROR_NO_MODULE;
 199                 return NULL;
 200         }
 201
 202         g_hal_tdm_backend_data = (hal_tdm_backend_data *)backend_data;
 203
 204         if (error)
 205                 *error = HAL_TDM_ERROR_NONE;
 206
 207         HAL_TDM_INFO("hal_tdm_get_backend");
 208
 209         return (hal_tdm_backend *)backend_data;
 210 }
 211
 212 EXTERN hal_tdm_error
 213 hal_tdm_put_backend(hal_tdm_backend *backend)
 214 {
 215         hal_tdm_backend_data *backend_data = (hal_tdm_backend_data *)backend;
 216         int ret;
 217
 218         if (!backend_data && g_hal_tdm_backend_data != backend) {
 219                 HAL_TDM_ERR("no backend_data\n");
 220                 return HAL_TDM_ERROR_NO_MODULE;
 221         }
 222
 223         ret = hal_common_put_backend(HAL_MODULE_TDM, backend_data);
 224         if (ret < 0) {
 225                  HAL_TDM_ERR("Failed to put backend\n");
 226                  return HAL_TDM_ERROR_OPERATION_FAILED;
 227         }
 228
 229         g_hal_tdm_backend_data = NULL;
 230
 231         HAL_TDM_INFO("hal_tdm_put_backend");
 232
 233         return HAL_TDM_ERROR_NONE;
 234 }
 235
 236 EXTERN hal_tdm_display *
 237 hal_tdm_backend_get_display(hal_tdm_backend *backend, hal_tdm_error *error)
 238 {
 239         hal_tdm_backend_data *backend_data = (hal_tdm_backend_data *)backend;
 240         hal_tdm_display *display;
 241
 242         if (!backend_data || g_hal_tdm_backend_data != backend) {
 243                 HAL_TDM_ERR("no backend_data\n");
 244                 if (error)
 245                         *error = HAL_TDM_ERROR_NO_MODULE;
 246                 return NULL;
 247         }
 248
 249         display = backend_data->display;
 250         if (!display) {
 251                 HAL_TDM_ERR("no display\n");
 252                 if (error)
 253                         *error = HAL_TDM_ERROR_OPERATION_FAILED;
 254                 return NULL;
 255         }
 256
 257         if (error)
 258                 *error = HAL_TDM_ERROR_NONE;
 259
 260         return display;
 261 }
 262
 263 EXTERN int
 264 hal_tdm_backend_has_drm_device(hal_tdm_backend *backend, hal_tdm_error *error)
 265 {
 266         hal_tdm_backend_data *backend_data = (hal_tdm_backend_data *)backend;
 267
 268         if (!backend_data || g_hal_tdm_backend_data != backend) {
 269                 HAL_TDM_ERR("no backend_data\n");
 270                 if (error)
 271                         *error = HAL_TDM_ERROR_OPERATION_FAILED;
 272                 return 0;
 273         }
 274
 275         return backend_data->has_drm_device;
 276 }
 277
 278 EXTERN hal_tdm_fd
 279 hal_tdm_backend_get_master_drm_fd(hal_tdm_backend *backend, hal_tdm_error *error)
 280 {
 281         hal_tdm_backend_data *backend_data = (hal_tdm_backend_data *)backend;
 282
 283         if (!backend_data || g_hal_tdm_backend_data != backend) {
 284                 HAL_TDM_ERR("no backend_data\n");
 285                 if (error)
 286                         *error = HAL_TDM_ERROR_OPERATION_FAILED;
 287                 return -1;
 288         }
 289
 290         if (!backend_data->drm_info.is_master) {
 291                 HAL_TDM_INFO("no master_drm_fd");
 292                 return -1;
 293         }
 294
 295         HAL_TDM_INFO("master_drm_fd is %d", backend_data->drm_info.drm_fd);
 296
 297         return backend_data->drm_info.drm_fd;
 298 }
 299
 300 EXTERN hal_tdm_error
 301 hal_tdm_backend_set_master_drm_fd(hal_tdm_backend *backend, hal_tdm_fd master_drm_fd)
 302 {
 303         hal_tdm_backend_data *backend_data = (hal_tdm_backend_data *)backend;
 304         int ret;
 305
 306         if (!backend_data || g_hal_tdm_backend_data != backend) {
 307                 HAL_TDM_ERR("no backend_data\n");
 308                 return HAL_TDM_ERROR_OPERATION_FAILED;
 309         }
 310
 311         if (!backend_data->drm_info.master_drm_fd_func) {
 312                 HAL_TDM_ERR("no backend_data->drm_info.auth_fd_func\n");
 313                 return HAL_TDM_ERROR_OPERATION_FAILED;
 314         }
 315
 316         ret = backend_data->drm_info.master_drm_fd_func(master_drm_fd, backend_data->drm_info.user_data);
 317         if (ret != HAL_TDM_ERROR_NONE) {
 318                 HAL_TDM_ERR("backend_data->drm_info.master_drm_fd_func failed\n");
 319                 return ret;
 320         }
 321
 322         return HAL_TDM_ERROR_NONE;
 323 }
 324
 325 EXTERN hal_tdm_event_source **
 326 hal_tdm_backend_get_event_sources(hal_tdm_backend *backend, int *num_event_sources, hal_tdm_error *error)
 327 {
 328         hal_tdm_backend_data *backend_data = (hal_tdm_backend_data *)backend;
 329         hal_tdm_event_source **event_source;
 330
 331         if (!backend_data || g_hal_tdm_backend_data != backend) {
 332                 HAL_TDM_ERR("no backend_data\n");
 333                 if (error)
 334                         *error = HAL_TDM_ERROR_NO_MODULE;
 335                 return NULL;
 336         }
 337
 338         event_source = backend_data->event_sources;
 339         if (num_event_sources)
 340                 *num_event_sources = backend_data->num_event_sources;
 341
 342         return backend_data->event_sources;
 343 }
 344
 345 EXTERN char *
 346 hal_tdm_backend_get_name(hal_tdm_backend *backend)
 347 {
 348         char *name;
 349         int ret;
 350
 351         name = calloc(HAL_TDM_NAME_LEN, sizeof(char));
 352         if (!name) {
 353                 HAL_TDM_ERR("no memory");
 354                 return NULL;
 355         }
 356
 357         ret = hal_common_get_backend_name(HAL_MODULE_TDM, name, HAL_TDM_NAME_LEN);
 358         if (ret < 0) {
 359                 HAL_TDM_ERR("hal_common_get_backend_name failed.\n");
 360                 free(name);
 361                 return NULL;
 362         }
 363
 364         return name;
 365 }
 366
 367 EXTERN char *
 368 hal_tdm_backend_get_vendor(hal_tdm_backend *backend)
 369 {
 370         char *vendor;
 371         int ret;
 372
 373         vendor = calloc(HAL_TDM_NAME_LEN, sizeof(char));
 374         if (!vendor) {
 375                 HAL_TDM_ERR("no memory");
 376                 return NULL;
 377         }
 378
 379         ret = hal_common_get_backend_vendor(HAL_MODULE_TDM, vendor, HAL_TDM_NAME_LEN);
 380         if (ret < 0) {
 381                 HAL_TDM_ERR("hal_common_get_backend_name failed.\n");
 382                 free(vendor);
 383                 return NULL;
 384         }
 385
 386         return vendor;
 387 }
 388
 389 #define TDM_BACKEND_MINOR_VERSION_MASK  0x0000FFFF
 390 #define TDM_BACKEND_MAJOR_VERSION_MASK  0xFFFF0000
 391 #define TDM_BACKEND_GET_ABI_MINOR(v)    ((v) & TDM_BACKEND_MINOR_VERSION_MASK)
 392 #define TDM_BACKEND_GET_ABI_MAJOR(v)    (((v) & TDM_BACKEND_MAJOR_VERSION_MASK) >> 16)
 393 #define TDM_BACKEND_SET_ABI_VERSION(major, minor) \
 394         (((major) << 16) & TDM_BACKEND_MAJOR_VERSION_MASK) | \
 395         ((minor) & TDM_BACKEND_MINOR_VERSION_MASK)
 396
 397 EXTERN unsigned long
 398 hal_tdm_backend_get_abi_version(hal_tdm_backend *backend)
 399 {
 400         unsigned long abi_version = 0;
 401         unsigned int hal_abi_version;
 402
 403         hal_abi_version = hal_common_get_backend_abi_version(HAL_MODULE_TDM);
 404
 405         switch (hal_abi_version) {
 406         case HAL_ABI_VERSION_TIZEN_6_5:
 407                 abi_version = TDM_BACKEND_SET_ABI_VERSION(6,5);
 408                 break;
 409         default:
 410                 abi_version = 0;
 411                 break;
 412         }
 413
 414         return abi_version;
 415 }
 416
 417 /* tdm_display_funcs */
 418 EXTERN hal_tdm_error
 419 hal_tdm_display_get_capability(hal_tdm_display *display, hal_tdm_caps_display *caps)
 420 {
 421         DISPLAY_FUNC_ENTRY(display_get_capability);
 422
 423         return display_funcs->display_get_capability(display, caps);
 424 }
 425
 426 EXTERN hal_tdm_error
 427 hal_tdm_display_get_pp_capability(hal_tdm_display *display, hal_tdm_caps_pp *caps)
 428 {
 429         DISPLAY_FUNC_ENTRY(display_get_pp_capability);
 430
 431         return display_funcs->display_get_pp_capability(display, caps);
 432 }
 433
 434 EXTERN hal_tdm_error
 435 hal_tdm_display_get_capture_capability(hal_tdm_display *display, hal_tdm_caps_capture *caps)
 436 {
 437         DISPLAY_FUNC_ENTRY(display_get_capture_capability);
 438
 439         return display_funcs->display_get_capture_capability(display, caps);
 440 }
 441
 442 EXTERN hal_tdm_output **
 443 hal_tdm_display_get_outputs(hal_tdm_display *display, int *count, hal_tdm_error *error)
 444 {
 445         DISPLAY_FUNC_ENTRY_NULL(display_get_outputs);
 446
 447         return display_funcs->display_get_outputs(display, count, error);
 448 }
 449
 450 EXTERN hal_tdm_error
 451 hal_tdm_display_get_fd(hal_tdm_display *display, int *fd)
 452 {
 453         DISPLAY_FUNC_ENTRY(display_get_fd);
 454
 455         return display_funcs->display_get_fd(display, fd);
 456 }
 457
 458 EXTERN hal_tdm_error
 459 hal_tdm_display_handle_events(hal_tdm_display *display)
 460 {
 461         DISPLAY_FUNC_ENTRY(display_handle_events);
 462
 463         return display_funcs->display_handle_events(display);
 464 }
 465
 466 EXTERN hal_tdm_pp *
 467 hal_tdm_display_create_pp(hal_tdm_display *display, hal_tdm_error *error)
 468 {
 469         DISPLAY_FUNC_ENTRY_NULL(display_create_pp);
 470
 471         return display_funcs->display_create_pp(display, error);
 472 }
 473
 474 EXTERN hal_tdm_voutput *
 475 hal_tdm_display_voutput_create(hal_tdm_display *display, const char *name, hal_tdm_error *error)
 476 {
 477         DISPLAY_FUNC_ENTRY_NULL(display_voutput_create);
 478
 479         return display_funcs->display_voutput_create(display, name, error);
 480 }
 481
 482
 483 /* output_funcs */
 484 EXTERN hal_tdm_error
 485 hal_tdm_output_get_capability(hal_tdm_output *output, hal_tdm_caps_output *caps)
 486 {
 487         OUTPUT_FUNC_ENTRY(output_get_capability);
 488
 489         return output_funcs->output_get_capability(output, caps);
 490 }
 491
 492 EXTERN hal_tdm_error
 493 hal_tdm_output_set_property(hal_tdm_output *output, unsigned int id, hal_tdm_value value)
 494 {
 495         OUTPUT_FUNC_ENTRY(output_set_property);
 496
 497         return output_funcs->output_set_property(output, id, value);
 498 }
 499
 500 EXTERN hal_tdm_error
 501 hal_tdm_output_get_property(hal_tdm_output *output, unsigned int id, hal_tdm_value *value)
 502 {
 503         OUTPUT_FUNC_ENTRY(output_get_property);
 504
 505         return output_funcs->output_get_property(output, id, value);
 506 }
 507
 508 EXTERN hal_tdm_error
 509 hal_tdm_output_wait_vblank(hal_tdm_output *output, int interval, int sync, void *user_data)
 510 {
 511         OUTPUT_FUNC_ENTRY(output_wait_vblank);
 512
 513         return output_funcs->output_wait_vblank(output, interval, sync, user_data);
 514 }
 515
 516 EXTERN hal_tdm_error
 517 hal_tdm_output_set_vblank_handler(hal_tdm_output *output, hal_tdm_output_vblank_handler func)
 518 {
 519         OUTPUT_FUNC_ENTRY(output_set_vblank_handler);
 520
 521         return output_funcs->output_set_vblank_handler(output, func);
 522 }
 523
 524 // TODO: DEPRECATED. NOT SUPPORTED~!!!!
 525 EXTERN hal_tdm_error
 526 hal_tdm_output_commit(hal_tdm_output *output, int sync, void *user_data)
 527 {
 528         return HAL_TDM_ERROR_BAD_REQUEST;
 529 }
 530
 531 // TODO: DEPRECATED. NOT SUPPORTED~!!!!
 532 EXTERN hal_tdm_error
 533 hal_tdm_output_set_commit_handler(hal_tdm_output *output, hal_tdm_output_commit_handler func)
 534 {
 535         return HAL_TDM_ERROR_BAD_REQUEST;
 536 }
 537
 538 EXTERN hal_tdm_error
 539 hal_tdm_output_set_dpms(hal_tdm_output *output, hal_tdm_output_dpms dpms_value)
 540 {
 541         OUTPUT_FUNC_ENTRY(output_set_dpms);
 542
 543         return output_funcs->output_set_dpms(output, dpms_value);
 544 }
 545
 546 EXTERN hal_tdm_error
 547 hal_tdm_output_get_dpms(hal_tdm_output *output, hal_tdm_output_dpms *dpms_value)
 548 {
 549         OUTPUT_FUNC_ENTRY(output_get_dpms);
 550
 551         return output_funcs->output_get_dpms(output, dpms_value);
 552 }
 553
 554 EXTERN hal_tdm_error
 555 hal_tdm_output_set_mode(hal_tdm_output *output, const hal_tdm_output_mode *mode)
 556 {
 557         OUTPUT_FUNC_ENTRY(output_set_mode);
 558
 559         return output_funcs->output_set_mode(output, mode);
 560 }
 561
 562 EXTERN hal_tdm_error
 563 hal_tdm_output_get_mode(hal_tdm_output *output, const hal_tdm_output_mode **mode)
 564 {
 565         OUTPUT_FUNC_ENTRY(output_get_mode);
 566
 567         return output_funcs->output_get_mode(output, mode);
 568 }
 569
 570 EXTERN hal_tdm_capture *
 571 hal_tdm_output_create_capture(hal_tdm_output *output, hal_tdm_error *error)
 572 {
 573         OUTPUT_FUNC_ENTRY_NULL(output_create_capture);
 574
 575         return output_funcs->output_create_capture(output, error);
 576 }
 577
 578 EXTERN hal_tdm_error
 579 hal_tdm_output_set_status_handler(hal_tdm_output *output, hal_tdm_output_status_handler func, void *user_data)
 580 {
 581         OUTPUT_FUNC_ENTRY(output_set_status_handler);
 582
 583         return output_funcs->output_set_status_handler(output, func, user_data);
 584 }
 585
 586 EXTERN hal_tdm_error
 587 hal_tdm_output_set_dpms_handler(hal_tdm_output *output, hal_tdm_output_dpms_handler func, void *user_data)
 588 {
 589         OUTPUT_FUNC_ENTRY(output_set_dpms_handler);
 590
 591         return output_funcs->output_set_dpms_handler(output, func, user_data);
 592 }
 593
 594 EXTERN hal_tdm_error
 595 hal_tdm_output_set_dpms_async(hal_tdm_output *output, hal_tdm_output_dpms dpms_value, int *sync)
 596 {
 597         OUTPUT_FUNC_ENTRY(output_set_dpms_async);
 598
 599         return output_funcs->output_set_dpms_async(output, dpms_value, sync);
 600 }
 601
 602 EXTERN hal_tdm_hwc *
 603 hal_tdm_output_get_hwc(hal_tdm_output *output, hal_tdm_error *error)
 604 {
 605         OUTPUT_FUNC_ENTRY_NULL(output_get_hwc);
 606
 607         return output_funcs->output_get_hwc(output, error);
 608 }
 609
 610 EXTERN hal_tdm_error
 611 hal_tdm_output_set_mirror(hal_tdm_output *output, hal_tdm_output *src_output, hal_tdm_transform transform)
 612 {
 613         OUTPUT_FUNC_ENTRY(output_set_mirror);
 614
 615         return output_funcs->output_set_mirror(output, src_output, transform);
 616 }
 617
 618 EXTERN hal_tdm_error
 619 hal_tdm_output_unset_mirror(hal_tdm_output *output)
 620 {
 621         OUTPUT_FUNC_ENTRY(output_unset_mirror);
 622
 623         return output_funcs->output_unset_mirror(output);
 624 }
 625
 626
 627 /* voutput_funcs */
 628 EXTERN hal_tdm_error
 629 hal_tdm_voutput_destroy(hal_tdm_voutput *voutput)
 630 {
 631         VOUTPUT_FUNC_ENTRY(voutput_destroy);
 632
 633         return voutput_funcs->voutput_destroy(voutput);
 634 }
 635
 636 EXTERN hal_tdm_error
 637 hal_tdm_voutput_set_available_mode(hal_tdm_voutput *voutput, const hal_tdm_output_mode *modes, int count)
 638 {
 639         VOUTPUT_FUNC_ENTRY(voutput_set_available_mode);
 640
 641         return voutput_funcs->voutput_set_available_mode(voutput, modes, count);
 642 }
 643
 644 EXTERN hal_tdm_error
 645 hal_tdm_voutput_set_physical_size(hal_tdm_voutput *voutput, unsigned int mmwidth, unsigned int mmheight)
 646 {
 647         VOUTPUT_FUNC_ENTRY(voutput_set_physical_size);
 648
 649         return voutput_funcs->voutput_set_physical_size(voutput, mmwidth, mmheight);
 650 }
 651
 652 EXTERN hal_tdm_error
 653 hal_tdm_voutput_connect(hal_tdm_voutput *voutput)
 654 {
 655         VOUTPUT_FUNC_ENTRY(voutput_connect);
 656
 657         return voutput_funcs->voutput_connect(voutput);
 658 }
 659
 660 EXTERN hal_tdm_error
 661 hal_tdm_voutput_disconnect(hal_tdm_voutput *voutput)
 662 {
 663         VOUTPUT_FUNC_ENTRY(voutput_disconnect);
 664
 665         return voutput_funcs->voutput_disconnect(voutput);
 666 }
 667
 668 EXTERN hal_tdm_output *
 669 hal_tdm_voutput_get_output(hal_tdm_voutput *voutput, hal_tdm_error *error)
 670 {
 671         VOUTPUT_FUNC_ENTRY_NULL(voutput_get_output);
 672
 673         return voutput_funcs->voutput_get_output(voutput, error);
 674 }
 675
 676 EXTERN hal_tdm_error
 677 hal_tdm_voutput_set_commit_func(hal_tdm_voutput *voutput, hal_tdm_voutput_commit_handler commit_func)
 678 {
 679         VOUTPUT_FUNC_ENTRY(voutput_set_commit_func);
 680
 681         return voutput_funcs->voutput_set_commit_func(voutput, commit_func);
 682 }
 683
 684 EXTERN hal_tdm_error
 685 hal_tdm_voutput_commit_done(hal_tdm_voutput *voutput)
 686 {
 687         VOUTPUT_FUNC_ENTRY(voutput_commit_done);
 688
 689         return voutput_funcs->voutput_commit_done(voutput);
 690 }
 691
 692 EXTERN hal_tdm_error
 693 hal_tdm_voutput_set_target_buffer_queue_flag(hal_tdm_voutput *voutput, int flags)
 694 {
 695         VOUTPUT_FUNC_ENTRY(voutput_set_target_buffer_queue_flag);
 696
 697         return voutput_funcs->voutput_set_target_buffer_queue_flag(voutput, flags);
 698 }
 699
 700
 701 /* hwc_funcs */
 702 EXTERN hal_tdm_hwc_window *
 703 hal_tdm_hwc_create_window(hal_tdm_hwc *hwc, hal_tdm_error *error)
 704 {
 705         HWC_FUNC_ENTRY_NULL(hwc_create_window);
 706
 707         return hwc_funcs->hwc_create_window(hwc, error);
 708 }
 709
 710 EXTERN hal_tdm_error
 711 hal_tdm_hwc_get_video_supported_formats(hal_tdm_hwc *hwc, const tbm_format **formats, int *count)
 712 {
 713         HWC_FUNC_ENTRY(hwc_get_video_supported_formats);
 714
 715         return hwc_funcs->hwc_get_video_supported_formats(hwc, formats, count);
 716 }
 717
 718 EXTERN hal_tdm_error
 719 hal_tdm_hwc_get_video_available_properties(hal_tdm_hwc *hwc, const hal_tdm_prop **props, int *count)
 720 {
 721         HWC_FUNC_ENTRY(hwc_get_video_available_properties);
 722
 723         return hwc_funcs->hwc_get_video_available_properties(hwc, props, count);
 724 }
 725
 726 EXTERN hal_tdm_error
 727 hal_tdm_hwc_get_capabilities(hal_tdm_hwc *hwc, hal_tdm_hwc_capability *capabilities)
 728 {
 729         HWC_FUNC_ENTRY(hwc_get_capabilities);
 730
 731         return hwc_funcs->hwc_get_capabilities(hwc, capabilities);
 732 }
 733
 734 EXTERN hal_tdm_error
 735 hal_tdm_hwc_get_available_properties(hal_tdm_hwc *hwc, const hal_tdm_prop **props, int *count)
 736 {
 737         HWC_FUNC_ENTRY(hwc_get_available_properties);
 738
 739         return hwc_funcs->hwc_get_available_properties(hwc, props, count);
 740 }
 741
 742 EXTERN tbm_surface_queue_h
 743 hal_tdm_hwc_get_client_target_buffer_queue(hal_tdm_hwc *hwc, hal_tdm_error *error)
 744 {
 745         HWC_FUNC_ENTRY_NULL(hwc_get_client_target_buffer_queue);
 746
 747         return hwc_funcs->hwc_get_client_target_buffer_queue(hwc, error);
 748 }
 749
 750 EXTERN hal_tdm_error
 751 hal_tdm_hwc_set_client_target_buffer(hal_tdm_hwc *hwc, tbm_surface_h target_buffer, hal_tdm_region damage)
 752 {
 753         HWC_FUNC_ENTRY(hwc_set_client_target_buffer);
 754
 755         return hwc_funcs->hwc_set_client_target_buffer(hwc, target_buffer, damage);
 756 }
 757
 758 EXTERN hal_tdm_error
 759 hal_tdm_hwc_set_client_target_acquire_fence(hal_tdm_hwc *hwc, int acquire_fence)
 760 {
 761         HWC_FUNC_ENTRY(hwc_set_client_target_acquire_fence);
 762
 763         return hwc_funcs->hwc_set_client_target_acquire_fence(hwc, acquire_fence);
 764 }
 765
 766 EXTERN hal_tdm_error
 767 hal_tdm_hwc_validate(hal_tdm_hwc *hwc, hal_tdm_hwc_window **composited_wnds, uint32_t num_wnds, uint32_t *num_types)
 768 {
 769         HWC_FUNC_ENTRY(hwc_validate);
 770
 771         return hwc_funcs->hwc_validate(hwc, composited_wnds, num_wnds, num_types);
 772 }
 773
 774 EXTERN hal_tdm_error
 775 hal_tdm_hwc_get_changed_composition_types(hal_tdm_hwc *hwc, uint32_t *num_elements, hal_tdm_hwc_window **hwc_window, hal_tdm_hwc_window_composition *composition_types)
 776 {
 777         HWC_FUNC_ENTRY(hwc_get_changed_composition_types);
 778
 779         return hwc_funcs->hwc_get_changed_composition_types(hwc, num_elements, hwc_window, composition_types);
 780 }
 781
 782 EXTERN hal_tdm_error
 783 hal_tdm_hwc_accept_validation(hal_tdm_hwc *hwc)
 784 {
 785         HWC_FUNC_ENTRY(hwc_accept_validation);
 786
 787         return hwc_funcs->hwc_accept_validation(hwc);
 788 }
 789
 790 EXTERN hal_tdm_error
 791 hal_tdm_hwc_commit(hal_tdm_hwc *hwc, int sync, void *user_data)
 792 {
 793         HWC_FUNC_ENTRY(hwc_commit);
 794
 795         return hwc_funcs->hwc_commit(hwc, sync, user_data);
 796 }
 797
 798 EXTERN hal_tdm_error
 799 hal_tdm_hwc_set_commit_handler(hal_tdm_hwc *hwc, hal_tdm_hwc_commit_handler func)
 800 {
 801         HWC_FUNC_ENTRY(hwc_set_commit_handler);
 802
 803         return hwc_funcs->hwc_set_commit_handler(hwc, func);
 804 }
 805
 806 EXTERN hal_tdm_error
 807 hal_tdm_hwc_get_commit_fence(hal_tdm_hwc *hwc, int *commit_fence)
 808 {
 809         HWC_FUNC_ENTRY(hwc_get_commit_fence);
 810
 811         return hwc_funcs->hwc_get_commit_fence(hwc, commit_fence);
 812 }
 813
 814 EXTERN hal_tdm_error
 815 hal_tdm_hwc_get_release_fences(hal_tdm_hwc *hwc, uint32_t *num_elements, hal_tdm_hwc_window **hwc_windows, int *release_fences)
 816 {
 817         HWC_FUNC_ENTRY(hwc_get_release_fences);
 818
 819         return hwc_funcs->hwc_get_release_fences(hwc, num_elements, hwc_windows, release_fences);
 820 }
 821
 822 EXTERN hal_tdm_error
 823 hal_tdm_hwc_set_property(hal_tdm_hwc *hwc, uint32_t id, hal_tdm_value value)
 824 {
 825         HWC_FUNC_ENTRY(hwc_set_property);
 826
 827         return hwc_funcs->hwc_set_property(hwc, id, value);
 828 }
 829
 830 EXTERN hal_tdm_error
 831 hal_tdm_hwc_get_property(hal_tdm_hwc *hwc, uint32_t id, hal_tdm_value *value)
 832 {
 833         HWC_FUNC_ENTRY(hwc_get_property);
 834
 835         return hwc_funcs->hwc_get_property(hwc, id, value);
 836 }
 837
 838 EXTERN hal_tdm_error
 839 hal_tdm_hwc_get_commit_interval(hal_tdm_hwc *hwc, hal_tdm_hwc_commit_interval *interval)
 840 {
 841         HWC_FUNC_ENTRY(hwc_get_commit_interval);
 842
 843         return hwc_funcs->hwc_get_commit_interval(hwc, interval);
 844 }
 845
 846
 847 /* hwc_window_funcs */
 848 EXTERN void
 849 hal_tdm_hwc_window_destroy(hal_tdm_hwc_window *hwc_window)
 850 {
 851         HWC_WINDOW_FUNC_ENTRY_VOID(hwc_window_destroy);
 852
 853         hwc_window_funcs->hwc_window_destroy(hwc_window);
 854 }
 855
 856 EXTERN tbm_surface_queue_h
 857 hal_tdm_hwc_window_acquire_buffer_queue(hal_tdm_hwc_window *hwc_window, hal_tdm_error *error)
 858 {
 859         HWC_WINDOW_FUNC_ENTRY_NULL(hwc_window_acquire_buffer_queue);
 860
 861         return hwc_window_funcs->hwc_window_acquire_buffer_queue(hwc_window, error);
 862 }
 863
 864 EXTERN void
 865 hal_tdm_hwc_window_release_buffer_queue(hal_tdm_hwc_window *hwc_window, tbm_surface_queue_h queue)
 866 {
 867         HWC_WINDOW_FUNC_ENTRY_VOID(hwc_window_release_buffer_queue);
 868
 869         hwc_window_funcs->hwc_window_release_buffer_queue(hwc_window, queue);
 870 }
 871
 872 EXTERN hal_tdm_error
 873 hal_tdm_hwc_window_set_composition_type(hal_tdm_hwc_window *hwc_window, hal_tdm_hwc_window_composition composition_type)
 874 {
 875         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_composition_type);
 876
 877         return hwc_window_funcs->hwc_window_set_composition_type(hwc_window, composition_type);
 878 }
 879
 880 EXTERN hal_tdm_error
 881 hal_tdm_hwc_window_set_buffer_damage(hal_tdm_hwc_window *hwc_window, hal_tdm_region damage)
 882 {
 883         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_buffer_damage);
 884
 885         return hwc_window_funcs->hwc_window_set_buffer_damage(hwc_window, damage);
 886 }
 887
 888 EXTERN hal_tdm_error
 889 hal_tdm_hwc_window_set_info(hal_tdm_hwc_window *hwc_window, hal_tdm_hwc_window_info *info)
 890 {
 891         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_info);
 892
 893         return hwc_window_funcs->hwc_window_set_info(hwc_window, info);
 894 }
 895
 896 EXTERN hal_tdm_error
 897 hal_tdm_hwc_window_set_buffer(hal_tdm_hwc_window *hwc_window, tbm_surface_h buffer)
 898 {
 899         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_buffer);
 900
 901         return hwc_window_funcs->hwc_window_set_buffer(hwc_window, buffer);
 902 }
 903
 904 EXTERN hal_tdm_error
 905 hal_tdm_hwc_window_set_property(hal_tdm_hwc_window *hwc_window, uint32_t id, hal_tdm_value value)
 906 {
 907         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_property);
 908
 909         return hwc_window_funcs->hwc_window_set_property(hwc_window, id, value);
 910 }
 911
 912 EXTERN hal_tdm_error
 913 hal_tdm_hwc_window_get_property(hal_tdm_hwc_window *hwc_window, uint32_t id, hal_tdm_value *value)
 914 {
 915         HWC_WINDOW_FUNC_ENTRY(hwc_window_get_property);
 916
 917         return hwc_window_funcs->hwc_window_get_property(hwc_window, id, value);
 918 }
 919
 920 EXTERN hal_tdm_error
 921 hal_tdm_hwc_window_get_constraints(hal_tdm_hwc_window *hwc_window, int *constraints)
 922 {
 923         HWC_WINDOW_FUNC_ENTRY(hwc_window_get_constraints);
 924
 925         return hwc_window_funcs->hwc_window_get_constraints(hwc_window, constraints);
 926 }
 927
 928 EXTERN hal_tdm_error
 929 hal_tdm_hwc_window_set_name(hal_tdm_hwc_window *hwc_window, const char *name)
 930 {
 931         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_name);
 932
 933         return hwc_window_funcs->hwc_window_set_name(hwc_window, name);
 934 }
 935
 936 EXTERN hal_tdm_error
 937 hal_tdm_hwc_window_set_cursor_image(hal_tdm_hwc_window *hwc_window, int width, int height, int stride, void *ptr)
 938 {
 939         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_cursor_image);
 940
 941         return hwc_window_funcs->hwc_window_set_cursor_image(hwc_window, width, height, stride, ptr);
 942 }
 943
 944 EXTERN hal_tdm_error
 945 hal_tdm_hwc_window_set_acquire_fence(hal_tdm_hwc_window *hwc_window, int acquire_fence)
 946 {
 947         HWC_WINDOW_FUNC_ENTRY(hwc_window_set_acquire_fence);
 948
 949         return hwc_window_funcs->hwc_window_set_acquire_fence(hwc_window, acquire_fence);
 950 }
 951
 952
 953 /* pp_funcs */
 954 EXTERN void
 955 hal_tdm_pp_destroy(hal_tdm_pp *pp)
 956 {
 957         PP_FUNC_ENTRY_VOID(pp_destroy);
 958         pp_funcs->pp_destroy(pp);
 959 }
 960
 961 EXTERN hal_tdm_error
 962 hal_tdm_pp_set_info(hal_tdm_pp *pp, hal_tdm_info_pp *info)
 963 {
 964         PP_FUNC_ENTRY(pp_set_info);
 965
 966         return pp_funcs->pp_set_info(pp, info);
 967 }
 968
 969 EXTERN hal_tdm_error
 970 hal_tdm_pp_attach(hal_tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
 971 {
 972         PP_FUNC_ENTRY(pp_attach);
 973
 974         return pp_funcs->pp_attach(pp, src, dst);
 975 }
 976
 977 EXTERN hal_tdm_error
 978 hal_tdm_pp_commit(hal_tdm_pp *pp)
 979 {
 980         PP_FUNC_ENTRY(pp_commit);
 981
 982         return pp_funcs->pp_commit(pp);
 983 }
 984
 985 EXTERN hal_tdm_error
 986 hal_tdm_pp_set_done_handler(hal_tdm_pp *pp, hal_tdm_pp_done_handler func, void *user_data)
 987 {
 988         PP_FUNC_ENTRY(pp_set_done_handler);
 989
 990         return pp_funcs->pp_set_done_handler(pp, func, user_data);
 991 }
 992
 993
 994 /* capture_funcs */
 995 EXTERN void
 996 hal_tdm_capture_destroy(hal_tdm_capture *capture)
 997 {
 998         CAPTURE_FUNC_ENTRY_VOID(capture_destroy);
 999         capture_funcs->capture_destroy(capture);
1000 }
1001
1002 EXTERN hal_tdm_error
1003 hal_tdm_capture_set_info(hal_tdm_capture *capture, hal_tdm_info_capture *info)
1004 {
1005         CAPTURE_FUNC_ENTRY(capture_set_info);
1006
1007         return capture_funcs->capture_set_info(capture, info);
1008 }
1009
1010 EXTERN hal_tdm_error
1011 hal_tdm_capture_attach(hal_tdm_capture *capture, tbm_surface_h buffer)
1012 {
1013         CAPTURE_FUNC_ENTRY(capture_attach);
1014
1015         return capture_funcs->capture_attach(capture, buffer);
1016 }
1017
1018 EXTERN hal_tdm_error
1019 hal_tdm_capture_commit(hal_tdm_capture *capture)
1020 {
1021         CAPTURE_FUNC_ENTRY(capture_commit);
1022
1023         return capture_funcs->capture_commit(capture);
1024 }
1025
1026 EXTERN hal_tdm_error
1027 hal_tdm_capture_set_done_handler(hal_tdm_capture *capture, hal_tdm_capture_done_handler func, void *user_data)
1028 {
1029         CAPTURE_FUNC_ENTRY(capture_set_done_handler);
1030
1031         return capture_funcs->capture_set_done_handler(capture, func, user_data);
1032 }