src/tdm_vblank.c

   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 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include "tdm.h"
  41 #include "tdm_private.h"
  42 #include "tdm_list.h"
  43
  44 /* CAUTION:
  45  * tdm vblank doesn't care about thread things.
  46  * However, to use tdm_event_loop_xxx functions, have to use the internal function.
  47  * So need to lock/unlock the mutex of private_display.
  48  */
  49
  50 /* TDM vblank
  51  * - aligned by HW vblank
  52  * - use a tdm_event_loop_source object only.
  53  */
  54
  55 #define TDM_VBLANK_UINT_MAX 4294967295U
  56 #define TDM_VBLANK_UINT_1Q  1073741823U     /* UINT_MAX / 4 */
  57 #define TDM_VBLANK_UINT_3Q  3221225471U     /* UINT_MAX / 4 * 3 */
  58
  59 /* (seq < TDM_VBLANK_UINT_1Q && TDM_VBLANK_UINT_3Q < last_seq) means
  60  * that the sequence value has reached the max value and started from 0 again.
  61  */
  62 #define TDM_VBLANK_SEQ_REACHED_MAX(seq, last_seq) \
  63         ((seq) < TDM_VBLANK_UINT_1Q && TDM_VBLANK_UINT_3Q < (last_seq))
  64
  65 #define VER(fmt, arg...)   TDM_ERR("[%p] "fmt, private_vblank, ##arg)
  66 #define VWR(fmt, arg...)   TDM_WRN("[%p] "fmt, private_vblank, ##arg)
  67 #define VIN(fmt, arg...)   TDM_INFO("[%p] "fmt, private_vblank, ##arg)
  68 #define VDB(fmt, arg...)   TDM_DBG("[%p] "fmt, private_vblank, ##arg)
  69
  70 typedef enum {
  71         VBLANK_TYPE_SW,
  72         VBLANK_TYPE_SW_FAKE,
  73         VBLANK_TYPE_HW,
  74         VBLANK_TYPE_HW_SW,
  75 } tdm_vblank_wait_type;
  76
  77 typedef struct _tdm_vblank_wait_info tdm_vblank_wait_info;
  78
  79 typedef struct _tdm_private_vblank {
  80         struct list_head link;
  81
  82         tdm_display *dpy;
  83         tdm_output *output;
  84         tdm_output_dpms dpms;
  85         unsigned int vrefresh;
  86
  87         unsigned int check_HW_or_SW;
  88         unsigned int fps;
  89         int offset;
  90         unsigned int enable_fake;
  91
  92         double vblank_gap;
  93         unsigned int quotient;
  94
  95         unsigned int last_seq;
  96         unsigned int last_tv_sec;
  97         unsigned int last_tv_usec;
  98
  99         /* for HW */
 100         double HW_vblank_gap;
 101         struct list_head HW_wait_list;
 102
 103         /* for SW */
 104         tdm_event_loop_source *SW_timer;
 105         struct list_head SW_wait_list;
 106 } tdm_private_vblank;
 107
 108 struct _tdm_vblank_wait_info {
 109         struct list_head link;
 110         struct list_head valid_link;
 111
 112         unsigned int stamp;
 113
 114         unsigned int req_sec;
 115         unsigned int req_usec;
 116         unsigned int interval;
 117
 118         tdm_vblank_handler func;
 119         void *user_data;
 120         tdm_private_vblank *private_vblank;
 121
 122         tdm_vblank_wait_type type;
 123
 124         unsigned int target_sec;
 125         unsigned int target_usec;
 126         unsigned int target_seq;
 127 };
 128
 129 static struct list_head vblank_list;
 130 static struct list_head valid_wait_list;
 131 static unsigned int vblank_list_inited;
 132 static unsigned int stamp = 0;
 133
 134 static tdm_error _tdm_vblank_cb_vblank_SW(void *user_data);
 135 static tdm_error _tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info);
 136
 137 #if 0
 138 static void
 139 _print_list(struct list_head *list)
 140 {
 141         tdm_vblank_wait_info *w = NULL;
 142
 143         LIST_FOR_EACH_ENTRY(w, list, link) {
 144                 printf(" %d", w->interval);
 145         }
 146         printf("\n");
 147 }
 148 #endif
 149
 150 static inline unsigned int
 151 _tdm_vblank_check_valid(tdm_vblank_wait_info *wait_info)
 152 {
 153         tdm_vblank_wait_info *w = NULL;
 154
 155         if (!wait_info)
 156                 return 0;
 157
 158         LIST_FOR_EACH_ENTRY(w, &valid_wait_list, valid_link) {
 159                 if (w->stamp == wait_info->stamp)
 160                         return 1;
 161         }
 162
 163         return 0;
 164 }
 165
 166 static inline unsigned int
 167 _tdm_vblank_find_wait(tdm_vblank_wait_info *wait_info, struct list_head *list)
 168 {
 169         tdm_vblank_wait_info *w = NULL;
 170
 171         if (!wait_info)
 172                 return 0;
 173
 174         LIST_FOR_EACH_ENTRY(w, list, link) {
 175                 if (w->stamp == wait_info->stamp)
 176                         return 1;
 177         }
 178
 179         return 0;
 180 }
 181
 182 static inline void
 183 _tdm_vblank_insert_wait(tdm_vblank_wait_info *wait_info, struct list_head *list)
 184 {
 185         tdm_vblank_wait_info *w = NULL;
 186         tdm_vblank_wait_info *found = NULL;
 187
 188         if (LIST_IS_EMPTY(list)) {
 189                 LIST_ADDTAIL(&wait_info->link, list);
 190                 return;
 191         }
 192
 193         LIST_FOR_EACH_ENTRY(w, list, link) {
 194                 if (wait_info->type == VBLANK_TYPE_SW) {
 195                         if (wait_info->target_sec == 0)
 196                                 TDM_NEVER_GET_HERE();
 197                         if (w->target_sec < wait_info->target_sec) {
 198                                 found = w;
 199                                 continue;
 200                         }
 201                         if (w->target_sec == wait_info->target_sec && w->target_usec <= wait_info->target_usec) {
 202                                 found = w;
 203                                 continue;
 204                         }
 205                 } else {
 206                         if (w->interval <= wait_info->interval) {
 207                                 found = w;
 208                                 continue;
 209                         }
 210                 }
 211         }
 212
 213         if (found)
 214                 LIST_ADD(&wait_info->link, &found->link);
 215         else
 216                 LIST_ADDTAIL(&wait_info->link, list->next);
 217 }
 218
 219 static void
 220 _tdm_vblank_change_to_SW(tdm_private_vblank *private_vblank)
 221 {
 222         tdm_vblank_wait_info *w = NULL, *ww = NULL;
 223
 224         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->HW_wait_list, link) {
 225                 LIST_DEL(&w->link);
 226                 w->type = VBLANK_TYPE_SW_FAKE;
 227                 _tdm_vblank_wait_SW(w);
 228         }
 229 }
 230
 231 static void
 232 _tdm_vblank_free_HW_wait(tdm_private_vblank *private_vblank, tdm_error error, unsigned int call_cb)
 233 {
 234         tdm_vblank_wait_info *w = NULL, *ww = NULL;
 235
 236         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->HW_wait_list, link) {
 237                 LIST_DEL(&w->link);
 238                 LIST_DEL(&w->valid_link);
 239
 240                 if (call_cb && w->func)
 241                         w->func(private_vblank, error, 0, 0, 0, w->user_data);
 242
 243                 free(w);
 244         }
 245 }
 246
 247 static void
 248 _tdm_vblank_cb_output_change(tdm_output *output, tdm_output_change_type type,
 249                                                          tdm_value value, void *user_data)
 250 {
 251         tdm_private_vblank *private_vblank = user_data;
 252
 253         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 254
 255         switch (type) {
 256         case TDM_OUTPUT_CHANGE_DPMS:
 257                 if (private_vblank->dpms == value.u32)
 258                         break;
 259                 VIN("dpms %s", tdm_dpms_str(value.u32));
 260                 private_vblank->dpms = value.u32;
 261                 private_vblank->check_HW_or_SW = 1;
 262                 if (private_vblank->dpms != TDM_OUTPUT_DPMS_ON) {
 263                         if (private_vblank->enable_fake)
 264                                 _tdm_vblank_change_to_SW(private_vblank);
 265                         else
 266                                 _tdm_vblank_free_HW_wait(private_vblank, TDM_ERROR_DPMS_OFF, 1);
 267                 }
 268                 break;
 269         case TDM_OUTPUT_CHANGE_CONNECTION:
 270                 VIN("output %s", tdm_status_str(value.u32));
 271                 if (value.u32 == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
 272                         _tdm_vblank_free_HW_wait(private_vblank, 0, 0);
 273                 break;
 274         default:
 275                 break;
 276         }
 277 }
 278
 279 tdm_vblank*
 280 tdm_vblank_create(tdm_display *dpy, tdm_output *output, tdm_error *error)
 281 {
 282         tdm_private_vblank *private_vblank;
 283         const tdm_output_mode *mode = NULL;
 284         tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON;
 285         tdm_error ret;
 286
 287         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
 288         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
 289
 290         if (error)
 291                 *error = TDM_ERROR_NONE;
 292
 293         if (!vblank_list_inited) {
 294                 LIST_INITHEAD(&vblank_list);
 295                 LIST_INITHEAD(&valid_wait_list);
 296                 vblank_list_inited = 1;
 297         }
 298
 299         tdm_output_get_mode(output, &mode);
 300         if (!mode) {
 301                 if (error)
 302                         *error = TDM_ERROR_OPERATION_FAILED;
 303                 TDM_ERR("no mode");
 304                 return NULL;
 305         }
 306
 307         tdm_output_get_dpms(output, &dpms);
 308
 309         private_vblank = calloc(1, sizeof *private_vblank);
 310         if (!private_vblank) {
 311                 if (error)
 312                         *error = TDM_ERROR_OUT_OF_MEMORY;
 313                 VER("alloc failed");
 314                 return NULL;
 315         }
 316
 317         tdm_output_add_change_handler(output, _tdm_vblank_cb_output_change, private_vblank);
 318
 319         private_vblank->dpy = dpy;
 320         private_vblank->output = output;
 321         private_vblank->dpms = dpms;
 322         private_vblank->vrefresh = mode->vrefresh;
 323         private_vblank->HW_vblank_gap = (double)1000000 / private_vblank->vrefresh;
 324
 325         private_vblank->check_HW_or_SW = 1;
 326         private_vblank->fps = mode->vrefresh;
 327
 328         LIST_INITHEAD(&private_vblank->HW_wait_list);
 329         LIST_INITHEAD(&private_vblank->SW_wait_list);
 330
 331         LIST_ADD(&private_vblank->link, &vblank_list);
 332
 333         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 334                 VIN("created. vrefresh(%d) dpms(%d)",
 335                         private_vblank->vrefresh, private_vblank->dpms);
 336
 337         return (tdm_vblank*)private_vblank;
 338 }
 339
 340 void
 341 tdm_vblank_destroy(tdm_vblank *vblank)
 342 {
 343         tdm_private_vblank *private_vblank = vblank;
 344         tdm_vblank_wait_info *w = NULL, *ww = NULL;
 345
 346         if (!private_vblank)
 347                 return;
 348
 349         LIST_DEL(&private_vblank->link);
 350
 351         if (private_vblank->SW_timer) {
 352                 tdm_display_lock(private_vblank->dpy);
 353                 tdm_event_loop_source_remove(private_vblank->SW_timer);
 354                 tdm_display_unlock(private_vblank->dpy);
 355         }
 356
 357         tdm_output_remove_change_handler(private_vblank->output,
 358                                                                          _tdm_vblank_cb_output_change, private_vblank);
 359
 360         _tdm_vblank_free_HW_wait(private_vblank, 0, 0);
 361
 362         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_wait_list, link) {
 363                 LIST_DEL(&w->link);
 364                 LIST_DEL(&w->valid_link);
 365                 free(w);
 366         }
 367
 368         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 369                 VIN("destroyed");
 370
 371         free(private_vblank);
 372 }
 373
 374 tdm_error
 375 tdm_vblank_set_fps(tdm_vblank *vblank, unsigned int fps)
 376 {
 377         tdm_private_vblank *private_vblank = vblank;
 378
 379         TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 380         TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
 381
 382         if (private_vblank->fps == fps)
 383                 return TDM_ERROR_NONE;
 384
 385         private_vblank->fps = fps;
 386         private_vblank->check_HW_or_SW = 1;
 387
 388         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 389                 VIN("fps(%d)", private_vblank->fps);
 390
 391         return TDM_ERROR_NONE;
 392 }
 393
 394 tdm_error
 395 tdm_vblank_set_offset(tdm_vblank *vblank, int offset)
 396 {
 397         tdm_private_vblank *private_vblank = vblank;
 398
 399         TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 400
 401         if (private_vblank->offset == offset)
 402                 return TDM_ERROR_NONE;
 403
 404         private_vblank->offset = offset;
 405         private_vblank->check_HW_or_SW = 1;
 406
 407         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 408                 VIN("offset(%d)", private_vblank->offset);
 409
 410         return TDM_ERROR_NONE;
 411 }
 412
 413 tdm_error
 414 tdm_vblank_set_enable_fake(tdm_vblank *vblank, unsigned int enable_fake)
 415 {
 416         tdm_private_vblank *private_vblank = vblank;
 417
 418         TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 419
 420         if (private_vblank->enable_fake == enable_fake)
 421                 return TDM_ERROR_NONE;
 422
 423         private_vblank->enable_fake = enable_fake;
 424
 425         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 426                 VIN("enable_fake(%d)", private_vblank->enable_fake);
 427
 428         return TDM_ERROR_NONE;
 429 }
 430
 431 unsigned int
 432 tdm_vblank_get_enable_fake(tdm_vblank *vblank)
 433 {
 434         tdm_private_vblank *private_vblank = vblank;
 435
 436         TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, 0);
 437
 438         return private_vblank->enable_fake;
 439 }
 440
 441 static tdm_error
 442 _tdm_vblank_sw_timer_update(tdm_private_vblank *private_vblank)
 443 {
 444         tdm_vblank_wait_info *first_wait_info = NULL;
 445         unsigned long curr, target;
 446         int ms_delay;
 447         tdm_error ret;
 448
 449         if (LIST_IS_EMPTY(&private_vblank->SW_wait_list)) {
 450                 VER("no wait_info");
 451                 return TDM_ERROR_OPERATION_FAILED;
 452         }
 453
 454         first_wait_info = container_of(private_vblank->SW_wait_list.next, first_wait_info, link);
 455         curr = tdm_helper_get_time_in_micros();
 456         target = first_wait_info->target_sec * 1000000 + first_wait_info->target_usec;
 457
 458         /* ms_delay should be more that 1 */
 459         if (target < curr)
 460                 ms_delay = 1;
 461         else
 462                 ms_delay = ceil((double)(target - curr) / 1000);
 463
 464         if (ms_delay < 1)
 465                 ms_delay = 1;
 466
 467         if (tdm_debug_module & TDM_DEBUG_VBLANK || ms_delay > 5000)
 468                 VIN("wait(%p) curr(%4lu) target(%4lu) ms_delay(%d)",
 469                         first_wait_info, curr, target, ms_delay);
 470
 471         tdm_display_lock(private_vblank->dpy);
 472
 473         if (!private_vblank->SW_timer) {
 474                 private_vblank->SW_timer =
 475                         tdm_event_loop_add_timer_handler(private_vblank->dpy,
 476                                                                                          _tdm_vblank_cb_vblank_SW,
 477                                                                                          private_vblank,
 478                                                                                          &ret);
 479                 if (!private_vblank->SW_timer) {
 480                         tdm_display_unlock(private_vblank->dpy);
 481                         VER("couldn't add timer");
 482                         return ret;
 483                 }
 484                 VIN("Use SW vblank");
 485         }
 486
 487         ret = tdm_event_loop_source_timer_update(private_vblank->SW_timer, ms_delay);
 488         if (ret != TDM_ERROR_NONE) {
 489                 tdm_display_unlock(private_vblank->dpy);
 490                 VER("couldn't update timer");
 491                 return ret;
 492         }
 493
 494         tdm_display_unlock(private_vblank->dpy);
 495
 496         return TDM_ERROR_NONE;
 497 }
 498
 499 static void
 500 _tdm_vblank_cb_vblank_HW(tdm_output *output, unsigned int sequence,
 501                                                  unsigned int tv_sec, unsigned int tv_usec,
 502                                                  void *user_data)
 503 {
 504         tdm_vblank_wait_info *wait_info = user_data;
 505         tdm_private_vblank *private_vblank;
 506
 507         if (!_tdm_vblank_check_valid(wait_info)) {
 508                 TDM_DBG("can't find wait(%p) from valid_wait_list", wait_info);
 509                 return;
 510         }
 511
 512         private_vblank = wait_info->private_vblank;
 513         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 514
 515         if (!_tdm_vblank_find_wait(wait_info, &private_vblank->HW_wait_list)) {
 516                 VDB("can't find wait(%p)", wait_info);
 517                 return;
 518         }
 519
 520         if (wait_info->type == VBLANK_TYPE_HW_SW) {
 521                 unsigned long target;
 522                 tdm_error ret;
 523
 524                 LIST_DEL(&wait_info->link);
 525
 526                 target = (unsigned long)tv_sec * 1000000 + tv_usec;
 527                 target += (private_vblank->offset * 1000);
 528
 529                 wait_info->target_sec = target / 1000000;
 530                 wait_info->target_usec = target % 1000000;
 531
 532                 _tdm_vblank_insert_wait(wait_info, &private_vblank->SW_wait_list);
 533
 534                 ret = _tdm_vblank_sw_timer_update(private_vblank);
 535
 536                 /* wait_info will be freed in _tdm_vblank_cb_vblank_SW() */
 537                 if (ret == TDM_ERROR_NONE) {
 538                         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 539                                 VIN("wait(%p) SW timer", wait_info);
 540                         return;
 541                 }
 542
 543                 VWR("couldn't update sw timer");
 544         }
 545
 546         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 547                 VIN("wait(%p) sequence(%u) done", wait_info, wait_info->target_seq);
 548
 549         private_vblank->last_seq = wait_info->target_seq;
 550         private_vblank->last_tv_sec = tv_sec;
 551         private_vblank->last_tv_usec = tv_usec;
 552
 553         if (wait_info->func)
 554                 wait_info->func(private_vblank, TDM_ERROR_NONE, wait_info->target_seq,
 555                                                 tv_sec, tv_usec, wait_info->user_data);
 556
 557         LIST_DEL(&wait_info->link);
 558         LIST_DEL(&wait_info->valid_link);
 559         free(wait_info);
 560 }
 561
 562 static tdm_error
 563 _tdm_vblank_wait_HW(tdm_vblank_wait_info *wait_info)
 564 {
 565         tdm_private_vblank *private_vblank = wait_info->private_vblank;
 566         int hw_interval;
 567         tdm_error ret;
 568
 569         _tdm_vblank_insert_wait(wait_info, &private_vblank->HW_wait_list);
 570
 571         hw_interval = wait_info->interval * private_vblank->quotient;
 572
 573         if (private_vblank->last_tv_sec == 0)
 574                 wait_info->target_seq = 1;
 575         else {
 576                 unsigned long last, prev, req, curr, target;
 577                 unsigned int skip = 0;
 578
 579                 last = (unsigned long)private_vblank->last_tv_sec * 1000000 + private_vblank->last_tv_usec;
 580                 req = (unsigned long)wait_info->req_sec * 1000000 + wait_info->req_usec;
 581
 582                 skip = (unsigned int)((req - last) / private_vblank->vblank_gap);
 583                 prev = last + skip * private_vblank->vblank_gap;
 584
 585                 curr = tdm_helper_get_time_in_micros();
 586                 target = prev;
 587                 while (target < curr)
 588                         target += private_vblank->vblank_gap;
 589
 590                 hw_interval = (unsigned int)((target - curr) / private_vblank->HW_vblank_gap) + 1;
 591
 592                 wait_info->target_seq = private_vblank->last_seq;
 593                 wait_info->target_seq += (target - last) / (unsigned long)private_vblank->vblank_gap;
 594
 595                 if (tdm_debug_module & TDM_DEBUG_VBLANK || hw_interval > 300)
 596                         VIN("wait(%p) last(%4lu) req(%4lu) prev(%4lu) curr(%4lu) skip(%d) hw_interval(%d)",
 597                                 wait_info, last, req - last, prev - last, curr - last,
 598                                 skip, hw_interval);
 599         }
 600
 601         ret = tdm_output_wait_vblank(private_vblank->output, hw_interval, 0,
 602                                                                  _tdm_vblank_cb_vblank_HW, wait_info);
 603
 604         if (ret != TDM_ERROR_NONE) {
 605                 LIST_DEL(&wait_info->link);
 606                 return ret;
 607         }
 608
 609         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 610                 VIN("wait(%p) waiting", wait_info);
 611
 612         return TDM_ERROR_NONE;
 613 }
 614
 615 static tdm_error
 616 _tdm_vblank_cb_vblank_SW(void *user_data)
 617 {
 618         tdm_private_vblank *private_vblank = user_data;
 619         tdm_vblank_wait_info *first_wait_info = NULL, *w = NULL, *ww = NULL;
 620
 621         TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_OPERATION_FAILED);
 622
 623         if (LIST_IS_EMPTY(&private_vblank->SW_wait_list)) {
 624                 VER("no wait_info");
 625                 return TDM_ERROR_OPERATION_FAILED;
 626         }
 627
 628         first_wait_info = container_of(private_vblank->SW_wait_list.next, first_wait_info, link);
 629         TDM_RETURN_VAL_IF_FAIL(first_wait_info != NULL, TDM_ERROR_OPERATION_FAILED);
 630
 631         if (tdm_debug_module & TDM_DEBUG_VBLANK)
 632                 VIN("wait(%p) sequence(%u) done", first_wait_info, first_wait_info->target_seq);
 633
 634         private_vblank->last_seq = first_wait_info->target_seq;
 635         private_vblank->last_tv_sec = first_wait_info->target_sec;
 636         private_vblank->last_tv_usec = first_wait_info->target_usec;
 637
 638         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_wait_list, link) {
 639                 if (w->target_sec != first_wait_info->target_sec ||
 640                         w->target_usec != first_wait_info->target_usec)
 641                         break;
 642
 643                 LIST_DEL(&w->link);
 644                 LIST_DEL(&w->valid_link);
 645
 646                 if (w->func)
 647                         w->func(private_vblank, TDM_ERROR_NONE, w->target_seq,
 648                                         w->target_sec, w->target_usec,
 649                                         w->user_data);
 650
 651                 free(w);
 652         }
 653
 654         return TDM_ERROR_NONE;
 655 }
 656
 657 static tdm_error
 658 _tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info)
 659 {
 660         tdm_private_vblank *private_vblank = wait_info->private_vblank;
 661         tdm_error ret;
 662
 663         if (private_vblank->last_tv_sec == 0) {
 664                 unsigned long curr = tdm_helper_get_time_in_micros();
 665
 666                 /* SW vblank starts from now. SW vblank doesn't need to be aligned with HW vblank. */
 667                 private_vblank->last_seq = 0;
 668                 private_vblank->last_tv_sec = curr / 1000000;
 669                 private_vblank->last_tv_usec = curr % 1000000;
 670
 671                 /* +1 ms to call the handler ASAP at the first. no matter for SW timer. */
 672                 curr += 1000;
 673
 674                 wait_info->target_seq = 1;
 675                 wait_info->target_sec = curr / 1000000;
 676                 wait_info->target_usec = curr % 1000000;
 677         } else {
 678                 unsigned long last, prev, req, curr, target;
 679                 unsigned int skip;
 680
 681                 last = (unsigned long)private_vblank->last_tv_sec * 1000000 + private_vblank->last_tv_usec;
 682                 req = (unsigned long)wait_info->req_sec * 1000000 + wait_info->req_usec;
 683
 684                 skip = (unsigned int)((req - last) / private_vblank->vblank_gap);
 685                 prev = last + skip * private_vblank->vblank_gap;
 686
 687                 curr = tdm_helper_get_time_in_micros();
 688                 target = prev + (unsigned long)(private_vblank->vblank_gap * wait_info->interval);
 689
 690                 while (target < curr)
 691                         target += (unsigned long)private_vblank->vblank_gap;
 692
 693                 wait_info->target_seq = private_vblank->last_seq;
 694                 wait_info->target_seq += (target - last) / (unsigned long)private_vblank->vblank_gap;
 695
 696                 wait_info->target_sec = target / 1000000;
 697                 wait_info->target_usec = target % 1000000;
 698
 699                 if (tdm_debug_module & TDM_DEBUG_VBLANK)
 700                         VIN("wait(%p) last(%4lu) req(%4lu) prev(%4lu) curr(%4lu) target(%4lu,%4lu)",
 701                                 wait_info, last, req - last, prev - last, curr - last,
 702                                 target, target - last);
 703         }
 704
 705         _tdm_vblank_insert_wait(wait_info, &private_vblank->SW_wait_list);
 706
 707         ret = _tdm_vblank_sw_timer_update(private_vblank);
 708         if (ret != TDM_ERROR_NONE) {
 709                 LIST_DEL(&wait_info->link);
 710                 VER("couldn't update sw timer");
 711                 return ret;
 712         }
 713
 714         return TDM_ERROR_NONE;
 715 }
 716
 717 tdm_error
 718 tdm_vblank_wait(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec,
 719                                 unsigned int interval, tdm_vblank_handler func, void *user_data)
 720 {
 721         tdm_private_vblank *private_vblank = vblank;
 722         tdm_vblank_wait_info *wait_info;
 723         tdm_error ret;
 724
 725         TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 726         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 727
 728         if (private_vblank->dpms != TDM_OUTPUT_DPMS_ON && !private_vblank->enable_fake) {
 729                 VIN("can't wait a vblank because of DPMS off");
 730                 return TDM_ERROR_DPMS_OFF;
 731         }
 732
 733         wait_info = calloc(1, sizeof *wait_info);
 734         if (!wait_info) {
 735                 VER("alloc failed");
 736                 return TDM_ERROR_OUT_OF_MEMORY;
 737         }
 738
 739         /* set request time to current time if 0. This function seems to be called in server side. */
 740         if (req_sec == 0 && req_usec == 0) {
 741                 unsigned long curr = tdm_helper_get_time_in_micros();
 742                 req_sec = curr / 1000000;
 743                 req_usec = curr % 1000000;
 744         }
 745
 746         LIST_INITHEAD(&wait_info->link);
 747         LIST_ADDTAIL(&wait_info->valid_link, &valid_wait_list);
 748         wait_info->stamp = ++stamp;
 749         wait_info->req_sec = req_sec;
 750         wait_info->req_usec = req_usec;
 751         wait_info->interval = interval;
 752         wait_info->func = func;
 753         wait_info->user_data = user_data;
 754         wait_info->private_vblank = private_vblank;
 755
 756         if (private_vblank->check_HW_or_SW) {
 757                 private_vblank->check_HW_or_SW = 0;
 758                 private_vblank->vblank_gap = (double)1000000 / private_vblank->fps;
 759                 private_vblank->quotient = private_vblank->vrefresh / private_vblank->fps;
 760         }
 761
 762         /* 1) if fps != factor of vrefresh, SW timer
 763          * 2) if fps == factor of vrefresh && dpms == off, SW timer (Fake HW vblank)
 764          * 2) if fps == factor of vrefresh && dpms == on && offset == 0, HW vblank
 765          * 3) if fps == factor of vrefresh && dpms == on && offset != 0, HW vblank + SW timer
 766          * In case of 1), we really don't need to align with HW vblank.
 767          */
 768         if (private_vblank->vrefresh % private_vblank->fps)
 769                 wait_info->type = VBLANK_TYPE_SW;
 770         else if (private_vblank->dpms == TDM_OUTPUT_DPMS_OFF)
 771                 wait_info->type = VBLANK_TYPE_SW_FAKE;
 772         else if (private_vblank->offset == 0)
 773                 wait_info->type = VBLANK_TYPE_HW;
 774         else
 775                 wait_info->type = VBLANK_TYPE_HW_SW;
 776
 777         if (wait_info->type == VBLANK_TYPE_SW || wait_info->type == VBLANK_TYPE_SW_FAKE)
 778                 ret = _tdm_vblank_wait_SW(wait_info);
 779         else {
 780                 ret = _tdm_vblank_wait_HW(wait_info);
 781                 if (ret == TDM_ERROR_DPMS_OFF)
 782                         ret = _tdm_vblank_wait_SW(wait_info);
 783         }
 784
 785         if (ret != TDM_ERROR_NONE) {
 786                 LIST_DEL(&wait_info->link);
 787                 LIST_DEL(&wait_info->valid_link);
 788                 free(wait_info);
 789                 return ret;
 790         }
 791
 792         return TDM_ERROR_NONE;
 793 }
 794
 795 tdm_error
 796 tdm_vblank_wait_seq(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec,
 797                                         unsigned int sequence, tdm_vblank_handler func, void *user_data)
 798 {
 799         tdm_private_vblank *private_vblank = vblank;
 800         unsigned int interval;
 801
 802         TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 803         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 804
 805         /* if the sequence of vblank reaches the max value, sequence can be 0. */
 806
 807         if (private_vblank->last_seq == 0) {
 808                 TDM_WRN("can't calculate interval with sequence(%u)", sequence);
 809                 interval = 1;
 810         } else if (sequence > private_vblank->last_seq ||
 811                            TDM_VBLANK_SEQ_REACHED_MAX(sequence, private_vblank->last_seq)) {
 812                 unsigned long last, curr, seq_target;
 813
 814                 last = (unsigned long)private_vblank->last_tv_sec * 1000000 + private_vblank->last_tv_usec;
 815                 curr = tdm_helper_get_time_in_micros();
 816                 seq_target = last + (unsigned long)(private_vblank->vblank_gap * (sequence - private_vblank->last_seq));
 817
 818                 /* If target is old or too close(1ms) to current, we call the handler immediately.
 819                  * 2ms? it seems too much.
 820                  */
 821                 if (seq_target < curr) {
 822                         func(vblank, TDM_ERROR_NONE, sequence,
 823                                  seq_target / 1000000, seq_target % 1000000,
 824                                  user_data);
 825                         return TDM_ERROR_NONE;
 826                 } else if ((seq_target - curr) < 1000) {  /* 1ms */
 827                         func(vblank, TDM_ERROR_NONE, sequence,
 828                                  curr / 1000000, curr % 1000000,
 829                                  user_data);
 830                         return TDM_ERROR_NONE;
 831                 }
 832
 833                 interval = ((seq_target - curr) / (unsigned long)private_vblank->vblank_gap) + 1;
 834         } else {
 835                 /* this seems error. But we handle this like normal to avoid the unexpected error in cliend side */
 836                 TDM_WRN("sequence(%u) should be over the last sequence(%u)", sequence, private_vblank->last_seq);
 837                 func(vblank, TDM_ERROR_NONE, private_vblank->last_seq,
 838                          private_vblank->last_tv_sec, private_vblank->last_tv_usec,
 839                          user_data);
 840                 return TDM_ERROR_NONE;
 841         }
 842
 843         return tdm_vblank_wait(vblank, req_sec, req_usec, interval, func, user_data);
 844 }