1 /** 2 * \file drm_irq.c 3 * IRQ support 4 * 5 * \author Rickard E. (Rik) Faith <faith@valinux.com> 6 * \author Gareth Hughes <gareth@valinux.com> 7 */ 8 9 /* 10 * Created: Fri Mar 19 14:30:16 1999 by faith@valinux.com 11 * 12 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas. 13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 14 * All Rights Reserved. 15 * 16 * Permission is hereby granted, free of charge, to any person obtaining a 17 * copy of this software and associated documentation files (the "Software"), 18 * to deal in the Software without restriction, including without limitation 19 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 20 * and/or sell copies of the Software, and to permit persons to whom the 21 * Software is furnished to do so, subject to the following conditions: 22 * 23 * The above copyright notice and this permission notice (including the next 24 * paragraph) shall be included in all copies or substantial portions of the 25 * Software. 26 * 27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 28 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 29 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 30 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 31 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 32 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 33 * OTHER DEALINGS IN THE SOFTWARE. 34 */ 35 36 #include <drm/drmP.h> 37 38 #include <linux/slab.h> 39 40 #include <linux/export.h> 41 42 /* Access macro for slots in vblank timestamp ringbuffer. */ 43 #define vblanktimestamp(dev, crtc, count) \ 44 ((dev)->vblank[crtc].time[(count) % DRM_VBLANKTIME_RBSIZE]) 45 46 /* Retry timestamp calculation up to 3 times to satisfy 47 * drm_timestamp_precision before giving up. 48 */ 49 #define DRM_TIMESTAMP_MAXRETRIES 3 50 51 /* Threshold in nanoseconds for detection of redundant 52 * vblank irq in drm_handle_vblank(). 1 msec should be ok. 53 */ 54 #define DRM_REDUNDANT_VBLIRQ_THRESH_NS 1000000 55 56 /* 57 * Clear vblank timestamp buffer for a crtc. 58 */ 59 static void clear_vblank_timestamps(struct drm_device *dev, int crtc) 60 { 61 memset(dev->vblank[crtc].time, 0, sizeof(dev->vblank[crtc].time)); 62 } 63 64 /* 65 * Disable vblank irq's on crtc, make sure that last vblank count 66 * of hardware and corresponding consistent software vblank counter 67 * are preserved, even if there are any spurious vblank irq's after 68 * disable. 69 */ 70 static void vblank_disable_and_save(struct drm_device *dev, int crtc) 71 { 72 u32 vblcount; 73 s64 diff_ns; 74 int vblrc; 75 struct timeval tvblank; 76 int count = DRM_TIMESTAMP_MAXRETRIES; 77 78 /* Prevent vblank irq processing while disabling vblank irqs, 79 * so no updates of timestamps or count can happen after we've 80 * disabled. Needed to prevent races in case of delayed irq's. 81 */ 82 lockmgr(&dev->vblank_time_lock, LK_EXCLUSIVE); 83 84 dev->driver->disable_vblank(dev, crtc); 85 dev->vblank[crtc].enabled = false; 86 87 /* No further vblank irq's will be processed after 88 * this point. Get current hardware vblank count and 89 * vblank timestamp, repeat until they are consistent. 90 * 91 * FIXME: There is still a race condition here and in 92 * drm_update_vblank_count() which can cause off-by-one 93 * reinitialization of software vblank counter. If gpu 94 * vblank counter doesn't increment exactly at the leading 95 * edge of a vblank interval, then we can lose 1 count if 96 * we happen to execute between start of vblank and the 97 * delayed gpu counter increment. 98 */ 99 do { 100 dev->vblank[crtc].last = dev->driver->get_vblank_counter(dev, crtc); 101 vblrc = drm_get_last_vbltimestamp(dev, crtc, &tvblank, 0); 102 } while (dev->vblank[crtc].last != dev->driver->get_vblank_counter(dev, crtc) && (--count) && vblrc); 103 104 if (!count) 105 vblrc = 0; 106 107 /* Compute time difference to stored timestamp of last vblank 108 * as updated by last invocation of drm_handle_vblank() in vblank irq. 109 */ 110 vblcount = atomic_read(&dev->vblank[crtc].count); 111 diff_ns = timeval_to_ns(&tvblank) - 112 timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount)); 113 114 /* If there is at least 1 msec difference between the last stored 115 * timestamp and tvblank, then we are currently executing our 116 * disable inside a new vblank interval, the tvblank timestamp 117 * corresponds to this new vblank interval and the irq handler 118 * for this vblank didn't run yet and won't run due to our disable. 119 * Therefore we need to do the job of drm_handle_vblank() and 120 * increment the vblank counter by one to account for this vblank. 121 * 122 * Skip this step if there isn't any high precision timestamp 123 * available. In that case we can't account for this and just 124 * hope for the best. 125 */ 126 if ((vblrc > 0) && (abs64(diff_ns) > 1000000)) { 127 atomic_inc(&dev->vblank[crtc].count); 128 smp_mb__after_atomic(); 129 } 130 131 /* Invalidate all timestamps while vblank irq's are off. */ 132 clear_vblank_timestamps(dev, crtc); 133 134 lockmgr(&dev->vblank_time_lock, LK_RELEASE); 135 } 136 137 static void vblank_disable_fn(unsigned long arg) 138 { 139 struct drm_vblank_crtc *vblank = (void *)arg; 140 struct drm_device *dev = vblank->dev; 141 int crtc = vblank->crtc; 142 143 if (!dev->vblank_disable_allowed) 144 return; 145 146 lockmgr(&dev->vbl_lock, LK_EXCLUSIVE); 147 if (atomic_read(&vblank->refcount) == 0 && vblank->enabled) { 148 DRM_DEBUG("disabling vblank on crtc %d\n", crtc); 149 vblank_disable_and_save(dev, crtc); 150 } 151 lockmgr(&dev->vbl_lock, LK_RELEASE); 152 } 153 154 void drm_vblank_cleanup(struct drm_device *dev) 155 { 156 int crtc; 157 158 /* Bail if the driver didn't call drm_vblank_init() */ 159 if (dev->num_crtcs == 0) 160 return; 161 162 for (crtc = 0; crtc < dev->num_crtcs; crtc++) { 163 del_timer_sync(&dev->vblank[crtc].disable_timer); 164 vblank_disable_fn((unsigned long)&dev->vblank[crtc]); 165 } 166 167 kfree(dev->vblank); 168 169 dev->num_crtcs = 0; 170 } 171 EXPORT_SYMBOL(drm_vblank_cleanup); 172 173 int drm_vblank_init(struct drm_device *dev, int num_crtcs) 174 { 175 int i, ret = -ENOMEM; 176 177 lockinit(&dev->vbl_lock, "drmvbl", 0, LK_CANRECURSE); 178 lockinit(&dev->vblank_time_lock, "drmvtl", 0, LK_CANRECURSE); 179 180 dev->num_crtcs = num_crtcs; 181 182 dev->vblank = kcalloc(num_crtcs, sizeof(*dev->vblank), GFP_KERNEL); 183 if (!dev->vblank) 184 goto err; 185 186 for (i = 0; i < num_crtcs; i++) { 187 dev->vblank[i].dev = dev; 188 dev->vblank[i].crtc = i; 189 init_waitqueue_head(&dev->vblank[i].queue); 190 setup_timer(&dev->vblank[i].disable_timer, vblank_disable_fn, 191 (unsigned long)&dev->vblank[i]); 192 } 193 194 DRM_INFO("Supports vblank timestamp caching Rev 2 (21.10.2013).\n"); 195 196 /* Driver specific high-precision vblank timestamping supported? */ 197 if (dev->driver->get_vblank_timestamp) 198 DRM_INFO("Driver supports precise vblank timestamp query.\n"); 199 else 200 DRM_INFO("No driver support for vblank timestamp query.\n"); 201 202 dev->vblank_disable_allowed = false; 203 204 return 0; 205 206 err: 207 drm_vblank_cleanup(dev); 208 return ret; 209 } 210 EXPORT_SYMBOL(drm_vblank_init); 211 212 #if 0 213 static void drm_irq_vgaarb_nokms(void *cookie, bool state) 214 { 215 struct drm_device *dev = cookie; 216 217 if (dev->driver->vgaarb_irq) { 218 dev->driver->vgaarb_irq(dev, state); 219 return; 220 } 221 222 if (!dev->irq_enabled) 223 return; 224 225 if (state) { 226 if (dev->driver->irq_uninstall) 227 dev->driver->irq_uninstall(dev); 228 } else { 229 if (dev->driver->irq_preinstall) 230 dev->driver->irq_preinstall(dev); 231 if (dev->driver->irq_postinstall) 232 dev->driver->irq_postinstall(dev); 233 } 234 } 235 #endif 236 237 /** 238 * Install IRQ handler. 239 * 240 * \param dev DRM device. 241 * 242 * Initializes the IRQ related data. Installs the handler, calling the driver 243 * \c irq_preinstall() and \c irq_postinstall() functions 244 * before and after the installation. 245 */ 246 int drm_irq_install(struct drm_device *dev, int irq) 247 { 248 int ret; 249 250 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) 251 return -EINVAL; 252 253 if (irq == 0) 254 return -EINVAL; 255 256 /* Driver must have been initialized */ 257 if (!dev->dev_private) 258 return -EINVAL; 259 260 if (dev->irq_enabled) 261 return -EBUSY; 262 dev->irq_enabled = 1; 263 264 DRM_DEBUG("irq=%d\n", irq); 265 266 /* Before installing handler */ 267 if (dev->driver->irq_preinstall) 268 dev->driver->irq_preinstall(dev); 269 270 /* Install handler */ 271 ret = bus_setup_intr(dev->dev, dev->irqr, INTR_MPSAFE, 272 dev->driver->irq_handler, dev, &dev->irqh, &dev->irq_lock); 273 274 if (ret != 0) { 275 dev->irq_enabled = 0; 276 return ret; 277 } 278 279 /* After installing handler */ 280 if (dev->driver->irq_postinstall) 281 ret = dev->driver->irq_postinstall(dev); 282 283 if (ret < 0) { 284 dev->irq_enabled = 0; 285 bus_teardown_intr(dev->dev, dev->irqr, dev->irqh); 286 } else { 287 dev->irq = irq; 288 } 289 290 return ret; 291 } 292 EXPORT_SYMBOL(drm_irq_install); 293 294 /** 295 * Uninstall the IRQ handler. 296 * 297 * \param dev DRM device. 298 * 299 * Calls the driver's \c irq_uninstall() function, and stops the irq. 300 */ 301 int drm_irq_uninstall(struct drm_device *dev) 302 { 303 bool irq_enabled; 304 int i; 305 306 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) 307 return -EINVAL; 308 309 irq_enabled = dev->irq_enabled; 310 dev->irq_enabled = false; 311 312 /* 313 * Wake up any waiters so they don't hang. 314 */ 315 if (dev->num_crtcs) { 316 lockmgr(&dev->vbl_lock, LK_EXCLUSIVE); 317 for (i = 0; i < dev->num_crtcs; i++) { 318 wake_up(&dev->vblank[i].queue); 319 dev->vblank[i].enabled = false; 320 dev->vblank[i].last = 321 dev->driver->get_vblank_counter(dev, i); 322 } 323 lockmgr(&dev->vbl_lock, LK_RELEASE); 324 } 325 326 if (!irq_enabled) 327 return -EINVAL; 328 329 DRM_DEBUG("irq=%d\n", dev->irq); 330 331 if (dev->driver->irq_uninstall) 332 dev->driver->irq_uninstall(dev); 333 334 bus_teardown_intr(dev->dev, dev->irqr, dev->irqh); 335 336 return 0; 337 } 338 EXPORT_SYMBOL(drm_irq_uninstall); 339 340 /** 341 * IRQ control ioctl. 342 * 343 * \param inode device inode. 344 * \param file_priv DRM file private. 345 * \param cmd command. 346 * \param arg user argument, pointing to a drm_control structure. 347 * \return zero on success or a negative number on failure. 348 * 349 * Calls irq_install() or irq_uninstall() according to \p arg. 350 */ 351 int drm_control(struct drm_device *dev, void *data, 352 struct drm_file *file_priv) 353 { 354 struct drm_control *ctl = data; 355 int ret = 0, irq; 356 357 /* if we haven't irq we fallback for compatibility reasons - 358 * this used to be a separate function in drm_dma.h 359 */ 360 361 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) 362 return 0; 363 if (drm_core_check_feature(dev, DRIVER_MODESET)) 364 return 0; 365 /* UMS was only ever support on pci devices. */ 366 if (WARN_ON(!dev->pdev)) 367 return -EINVAL; 368 369 switch (ctl->func) { 370 case DRM_INST_HANDLER: 371 irq = dev->irq; 372 373 if (dev->if_version < DRM_IF_VERSION(1, 2) && 374 ctl->irq != irq) 375 return -EINVAL; 376 mutex_lock(&dev->struct_mutex); 377 ret = drm_irq_install(dev, irq); 378 mutex_unlock(&dev->struct_mutex); 379 380 return ret; 381 case DRM_UNINST_HANDLER: 382 mutex_lock(&dev->struct_mutex); 383 ret = drm_irq_uninstall(dev); 384 mutex_unlock(&dev->struct_mutex); 385 386 return ret; 387 default: 388 return -EINVAL; 389 } 390 } 391 392 /** 393 * drm_calc_timestamping_constants - Calculate vblank timestamp constants 394 * 395 * @crtc drm_crtc whose timestamp constants should be updated. 396 * @mode display mode containing the scanout timings 397 * 398 * Calculate and store various constants which are later 399 * needed by vblank and swap-completion timestamping, e.g, 400 * by drm_calc_vbltimestamp_from_scanoutpos(). They are 401 * derived from crtc's true scanout timing, so they take 402 * things like panel scaling or other adjustments into account. 403 */ 404 void drm_calc_timestamping_constants(struct drm_crtc *crtc, 405 const struct drm_display_mode *mode) 406 { 407 int linedur_ns = 0, pixeldur_ns = 0, framedur_ns = 0; 408 int dotclock = mode->crtc_clock; 409 410 /* Valid dotclock? */ 411 if (dotclock > 0) { 412 int frame_size = mode->crtc_htotal * mode->crtc_vtotal; 413 414 /* 415 * Convert scanline length in pixels and video 416 * dot clock to line duration, frame duration 417 * and pixel duration in nanoseconds: 418 */ 419 pixeldur_ns = 1000000 / dotclock; 420 linedur_ns = div_u64((u64) mode->crtc_htotal * 1000000, dotclock); 421 framedur_ns = div_u64((u64) frame_size * 1000000, dotclock); 422 423 /* 424 * Fields of interlaced scanout modes are only half a frame duration. 425 */ 426 if (mode->flags & DRM_MODE_FLAG_INTERLACE) 427 framedur_ns /= 2; 428 } else 429 DRM_ERROR("crtc %d: Can't calculate constants, dotclock = 0!\n", 430 crtc->base.id); 431 432 crtc->pixeldur_ns = pixeldur_ns; 433 crtc->linedur_ns = linedur_ns; 434 crtc->framedur_ns = framedur_ns; 435 436 DRM_DEBUG("crtc %d: hwmode: htotal %d, vtotal %d, vdisplay %d\n", 437 crtc->base.id, mode->crtc_htotal, 438 mode->crtc_vtotal, mode->crtc_vdisplay); 439 DRM_DEBUG("crtc %d: clock %d kHz framedur %d linedur %d, pixeldur %d\n", 440 crtc->base.id, dotclock, framedur_ns, 441 linedur_ns, pixeldur_ns); 442 } 443 EXPORT_SYMBOL(drm_calc_timestamping_constants); 444 445 /** 446 * drm_calc_vbltimestamp_from_scanoutpos - helper routine for kms 447 * drivers. Implements calculation of exact vblank timestamps from 448 * given drm_display_mode timings and current video scanout position 449 * of a crtc. This can be called from within get_vblank_timestamp() 450 * implementation of a kms driver to implement the actual timestamping. 451 * 452 * Should return timestamps conforming to the OML_sync_control OpenML 453 * extension specification. The timestamp corresponds to the end of 454 * the vblank interval, aka start of scanout of topmost-leftmost display 455 * pixel in the following video frame. 456 * 457 * Requires support for optional dev->driver->get_scanout_position() 458 * in kms driver, plus a bit of setup code to provide a drm_display_mode 459 * that corresponds to the true scanout timing. 460 * 461 * The current implementation only handles standard video modes. It 462 * returns as no operation if a doublescan or interlaced video mode is 463 * active. Higher level code is expected to handle this. 464 * 465 * @dev: DRM device. 466 * @crtc: Which crtc's vblank timestamp to retrieve. 467 * @max_error: Desired maximum allowable error in timestamps (nanosecs). 468 * On return contains true maximum error of timestamp. 469 * @vblank_time: Pointer to struct timeval which should receive the timestamp. 470 * @flags: Flags to pass to driver: 471 * 0 = Default. 472 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl irq handler. 473 * @refcrtc: drm_crtc* of crtc which defines scanout timing. 474 * @mode: mode which defines the scanout timings 475 * 476 * Returns negative value on error, failure or if not supported in current 477 * video mode: 478 * 479 * -EINVAL - Invalid crtc. 480 * -EAGAIN - Temporary unavailable, e.g., called before initial modeset. 481 * -ENOTSUPP - Function not supported in current display mode. 482 * -EIO - Failed, e.g., due to failed scanout position query. 483 * 484 * Returns or'ed positive status flags on success: 485 * 486 * DRM_VBLANKTIME_SCANOUTPOS_METHOD - Signal this method used for timestamping. 487 * DRM_VBLANKTIME_INVBL - Timestamp taken while scanout was in vblank interval. 488 * 489 */ 490 int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, int crtc, 491 int *max_error, 492 struct timeval *vblank_time, 493 unsigned flags, 494 const struct drm_crtc *refcrtc, 495 const struct drm_display_mode *mode) 496 { 497 ktime_t stime, etime; 498 struct timeval tv_etime; 499 int vbl_status; 500 int vpos, hpos, i; 501 int framedur_ns, linedur_ns, pixeldur_ns, delta_ns, duration_ns; 502 bool invbl; 503 504 if (crtc < 0 || crtc >= dev->num_crtcs) { 505 DRM_ERROR("Invalid crtc %d\n", crtc); 506 return -EINVAL; 507 } 508 509 /* Scanout position query not supported? Should not happen. */ 510 if (!dev->driver->get_scanout_position) { 511 DRM_ERROR("Called from driver w/o get_scanout_position()!?\n"); 512 return -EIO; 513 } 514 515 /* Durations of frames, lines, pixels in nanoseconds. */ 516 framedur_ns = refcrtc->framedur_ns; 517 linedur_ns = refcrtc->linedur_ns; 518 pixeldur_ns = refcrtc->pixeldur_ns; 519 520 /* If mode timing undefined, just return as no-op: 521 * Happens during initial modesetting of a crtc. 522 */ 523 if (framedur_ns == 0) { 524 DRM_DEBUG("crtc %d: Noop due to uninitialized mode.\n", crtc); 525 return -EAGAIN; 526 } 527 528 /* Get current scanout position with system timestamp. 529 * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times 530 * if single query takes longer than max_error nanoseconds. 531 * 532 * This guarantees a tight bound on maximum error if 533 * code gets preempted or delayed for some reason. 534 */ 535 for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) { 536 /* 537 * Get vertical and horizontal scanout position vpos, hpos, 538 * and bounding timestamps stime, etime, pre/post query. 539 */ 540 vbl_status = dev->driver->get_scanout_position(dev, crtc, flags, &vpos, 541 &hpos, &stime, &etime); 542 543 /* 544 * Get correction for CLOCK_MONOTONIC -> CLOCK_REALTIME if 545 * CLOCK_REALTIME is requested. 546 */ 547 #if 0 548 if (!drm_timestamp_monotonic) 549 mono_time_offset = ktime_get_monotonic_offset(); 550 #endif 551 552 /* Return as no-op if scanout query unsupported or failed. */ 553 if (!(vbl_status & DRM_SCANOUTPOS_VALID)) { 554 DRM_DEBUG("crtc %d : scanoutpos query failed [%d].\n", 555 crtc, vbl_status); 556 return -EIO; 557 } 558 559 /* Compute uncertainty in timestamp of scanout position query. */ 560 duration_ns = ktime_to_ns(etime) - ktime_to_ns(stime); 561 562 /* Accept result with < max_error nsecs timing uncertainty. */ 563 if (duration_ns <= *max_error) 564 break; 565 } 566 567 /* Noisy system timing? */ 568 if (i == DRM_TIMESTAMP_MAXRETRIES) { 569 DRM_DEBUG("crtc %d: Noisy timestamp %d us > %d us [%d reps].\n", 570 crtc, duration_ns/1000, *max_error/1000, i); 571 } 572 573 /* Return upper bound of timestamp precision error. */ 574 *max_error = duration_ns; 575 576 /* Check if in vblank area: 577 * vpos is >=0 in video scanout area, but negative 578 * within vblank area, counting down the number of lines until 579 * start of scanout. 580 */ 581 invbl = vbl_status & DRM_SCANOUTPOS_INVBL; 582 583 /* Convert scanout position into elapsed time at raw_time query 584 * since start of scanout at first display scanline. delta_ns 585 * can be negative if start of scanout hasn't happened yet. 586 */ 587 delta_ns = vpos * linedur_ns + hpos * pixeldur_ns; 588 589 #if 0 590 if (!drm_timestamp_monotonic) 591 etime = ktime_sub(etime, mono_time_offset); 592 #endif 593 594 /* save this only for debugging purposes */ 595 tv_etime = ktime_to_timeval(etime); 596 /* Subtract time delta from raw timestamp to get final 597 * vblank_time timestamp for end of vblank. 598 */ 599 if (delta_ns < 0) 600 etime = ktime_add_ns(etime, -delta_ns); 601 else 602 etime = ktime_sub_ns(etime, delta_ns); 603 *vblank_time = ktime_to_timeval(etime); 604 605 DRM_DEBUG("crtc %d : v %d p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n", 606 crtc, (int)vbl_status, hpos, vpos, 607 (long)tv_etime.tv_sec, (long)tv_etime.tv_usec, 608 (long)vblank_time->tv_sec, (long)vblank_time->tv_usec, 609 duration_ns/1000, i); 610 611 vbl_status = DRM_VBLANKTIME_SCANOUTPOS_METHOD; 612 if (invbl) 613 vbl_status |= DRM_VBLANKTIME_INVBL; 614 615 return vbl_status; 616 } 617 EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos); 618 619 static struct timeval get_drm_timestamp(void) 620 { 621 ktime_t now; 622 623 now = ktime_get(); 624 #if 0 625 if (!drm_timestamp_monotonic) 626 now = ktime_sub(now, ktime_get_monotonic_offset()); 627 #endif 628 629 return ktime_to_timeval(now); 630 } 631 632 /** 633 * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent 634 * vblank interval. 635 * 636 * @dev: DRM device 637 * @crtc: which crtc's vblank timestamp to retrieve 638 * @tvblank: Pointer to target struct timeval which should receive the timestamp 639 * @flags: Flags to pass to driver: 640 * 0 = Default. 641 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl irq handler. 642 * 643 * Fetches the system timestamp corresponding to the time of the most recent 644 * vblank interval on specified crtc. May call into kms-driver to 645 * compute the timestamp with a high-precision GPU specific method. 646 * 647 * Returns zero if timestamp originates from uncorrected do_gettimeofday() 648 * call, i.e., it isn't very precisely locked to the true vblank. 649 * 650 * Returns non-zero if timestamp is considered to be very precise. 651 */ 652 u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc, 653 struct timeval *tvblank, unsigned flags) 654 { 655 int ret; 656 657 /* Define requested maximum error on timestamps (nanoseconds). */ 658 int max_error = (int) drm_timestamp_precision * 1000; 659 660 /* Query driver if possible and precision timestamping enabled. */ 661 if (dev->driver->get_vblank_timestamp && (max_error > 0)) { 662 ret = dev->driver->get_vblank_timestamp(dev, crtc, &max_error, 663 tvblank, flags); 664 if (ret > 0) 665 return (u32) ret; 666 } 667 668 /* GPU high precision timestamp query unsupported or failed. 669 * Return current monotonic/gettimeofday timestamp as best estimate. 670 */ 671 *tvblank = get_drm_timestamp(); 672 673 return 0; 674 } 675 EXPORT_SYMBOL(drm_get_last_vbltimestamp); 676 677 /** 678 * drm_vblank_count - retrieve "cooked" vblank counter value 679 * @dev: DRM device 680 * @crtc: which counter to retrieve 681 * 682 * Fetches the "cooked" vblank count value that represents the number of 683 * vblank events since the system was booted, including lost events due to 684 * modesetting activity. 685 */ 686 u32 drm_vblank_count(struct drm_device *dev, int crtc) 687 { 688 return atomic_read(&dev->vblank[crtc].count); 689 } 690 EXPORT_SYMBOL(drm_vblank_count); 691 692 /** 693 * drm_vblank_count_and_time - retrieve "cooked" vblank counter value 694 * and the system timestamp corresponding to that vblank counter value. 695 * 696 * @dev: DRM device 697 * @crtc: which counter to retrieve 698 * @vblanktime: Pointer to struct timeval to receive the vblank timestamp. 699 * 700 * Fetches the "cooked" vblank count value that represents the number of 701 * vblank events since the system was booted, including lost events due to 702 * modesetting activity. Returns corresponding system timestamp of the time 703 * of the vblank interval that corresponds to the current value vblank counter 704 * value. 705 */ 706 u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc, 707 struct timeval *vblanktime) 708 { 709 u32 cur_vblank; 710 711 /* Read timestamp from slot of _vblank_time ringbuffer 712 * that corresponds to current vblank count. Retry if 713 * count has incremented during readout. This works like 714 * a seqlock. 715 */ 716 do { 717 cur_vblank = atomic_read(&dev->vblank[crtc].count); 718 *vblanktime = vblanktimestamp(dev, crtc, cur_vblank); 719 smp_rmb(); 720 } while (cur_vblank != atomic_read(&dev->vblank[crtc].count)); 721 722 return cur_vblank; 723 } 724 EXPORT_SYMBOL(drm_vblank_count_and_time); 725 726 static void send_vblank_event(struct drm_device *dev, 727 struct drm_pending_vblank_event *e, 728 unsigned long seq, struct timeval *now) 729 { 730 e->event.sequence = seq; 731 e->event.tv_sec = now->tv_sec; 732 e->event.tv_usec = now->tv_usec; 733 734 list_add_tail(&e->base.link, 735 &e->base.file_priv->event_list); 736 drm_event_wakeup(&e->base); 737 #if 0 738 wake_up_interruptible(&e->base.file_priv->event_wait); 739 trace_drm_vblank_event_delivered(e->base.pid, e->pipe, 740 e->event.sequence); 741 #endif 742 } 743 744 /** 745 * drm_send_vblank_event - helper to send vblank event after pageflip 746 * @dev: DRM device 747 * @crtc: CRTC in question 748 * @e: the event to send 749 * 750 * Updates sequence # and timestamp on event, and sends it to userspace. 751 * Caller must hold event lock. 752 */ 753 void drm_send_vblank_event(struct drm_device *dev, int crtc, 754 struct drm_pending_vblank_event *e) 755 { 756 struct timeval now; 757 unsigned int seq; 758 if (crtc >= 0) { 759 seq = drm_vblank_count_and_time(dev, crtc, &now); 760 } else { 761 seq = 0; 762 763 now = get_drm_timestamp(); 764 } 765 e->pipe = crtc; 766 send_vblank_event(dev, e, seq, &now); 767 } 768 EXPORT_SYMBOL(drm_send_vblank_event); 769 770 /** 771 * drm_update_vblank_count - update the master vblank counter 772 * @dev: DRM device 773 * @crtc: counter to update 774 * 775 * Call back into the driver to update the appropriate vblank counter 776 * (specified by @crtc). Deal with wraparound, if it occurred, and 777 * update the last read value so we can deal with wraparound on the next 778 * call if necessary. 779 * 780 * Only necessary when going from off->on, to account for frames we 781 * didn't get an interrupt for. 782 * 783 * Note: caller must hold dev->vbl_lock since this reads & writes 784 * device vblank fields. 785 */ 786 static void drm_update_vblank_count(struct drm_device *dev, int crtc) 787 { 788 u32 cur_vblank, diff, tslot, rc; 789 struct timeval t_vblank; 790 791 /* 792 * Interrupts were disabled prior to this call, so deal with counter 793 * wrap if needed. 794 * NOTE! It's possible we lost a full dev->max_vblank_count events 795 * here if the register is small or we had vblank interrupts off for 796 * a long time. 797 * 798 * We repeat the hardware vblank counter & timestamp query until 799 * we get consistent results. This to prevent races between gpu 800 * updating its hardware counter while we are retrieving the 801 * corresponding vblank timestamp. 802 */ 803 do { 804 cur_vblank = dev->driver->get_vblank_counter(dev, crtc); 805 rc = drm_get_last_vbltimestamp(dev, crtc, &t_vblank, 0); 806 } while (cur_vblank != dev->driver->get_vblank_counter(dev, crtc)); 807 808 /* Deal with counter wrap */ 809 diff = cur_vblank - dev->vblank[crtc].last; 810 if (cur_vblank < dev->vblank[crtc].last) { 811 diff += dev->max_vblank_count; 812 813 DRM_DEBUG("last_vblank[%d]=0x%x, cur_vblank=0x%x => diff=0x%x\n", 814 crtc, dev->vblank[crtc].last, cur_vblank, diff); 815 } 816 817 DRM_DEBUG("enabling vblank interrupts on crtc %d, missed %d\n", 818 crtc, diff); 819 820 /* Reinitialize corresponding vblank timestamp if high-precision query 821 * available. Skip this step if query unsupported or failed. Will 822 * reinitialize delayed at next vblank interrupt in that case. 823 */ 824 if (rc) { 825 tslot = atomic_read(&dev->vblank[crtc].count) + diff; 826 vblanktimestamp(dev, crtc, tslot) = t_vblank; 827 } 828 829 smp_mb__before_atomic(); 830 atomic_add(diff, &dev->vblank[crtc].count); 831 smp_mb__after_atomic(); 832 } 833 834 /** 835 * drm_vblank_enable - enable the vblank interrupt on a CRTC 836 * @dev: DRM device 837 * @crtc: CRTC in question 838 */ 839 static int drm_vblank_enable(struct drm_device *dev, int crtc) 840 { 841 int ret = 0; 842 843 assert_spin_locked(&dev->vbl_lock); 844 845 lockmgr(&dev->vblank_time_lock, LK_EXCLUSIVE); 846 847 if (!dev->vblank[crtc].enabled) { 848 /* Enable vblank irqs under vblank_time_lock protection. 849 * All vblank count & timestamp updates are held off 850 * until we are done reinitializing master counter and 851 * timestamps. Filtercode in drm_handle_vblank() will 852 * prevent double-accounting of same vblank interval. 853 */ 854 ret = dev->driver->enable_vblank(dev, crtc); 855 DRM_DEBUG("enabling vblank on crtc %d, ret: %d\n", crtc, ret); 856 if (ret) 857 atomic_dec(&dev->vblank[crtc].refcount); 858 else { 859 dev->vblank[crtc].enabled = true; 860 drm_update_vblank_count(dev, crtc); 861 } 862 } 863 864 lockmgr(&dev->vblank_time_lock, LK_RELEASE); 865 866 return ret; 867 } 868 869 /** 870 * drm_vblank_get - get a reference count on vblank events 871 * @dev: DRM device 872 * @crtc: which CRTC to own 873 * 874 * Acquire a reference count on vblank events to avoid having them disabled 875 * while in use. 876 * 877 * RETURNS 878 * Zero on success, nonzero on failure. 879 */ 880 int drm_vblank_get(struct drm_device *dev, int crtc) 881 { 882 int ret = 0; 883 884 lockmgr(&dev->vbl_lock, LK_EXCLUSIVE); 885 /* Going from 0->1 means we have to enable interrupts again */ 886 if (atomic_add_return(1, &dev->vblank[crtc].refcount) == 1) { 887 ret = drm_vblank_enable(dev, crtc); 888 } else { 889 if (!dev->vblank[crtc].enabled) { 890 atomic_dec(&dev->vblank[crtc].refcount); 891 ret = -EINVAL; 892 } 893 } 894 lockmgr(&dev->vbl_lock, LK_RELEASE); 895 896 return ret; 897 } 898 EXPORT_SYMBOL(drm_vblank_get); 899 900 /** 901 * drm_crtc_vblank_get - get a reference count on vblank events 902 * @crtc: which CRTC to own 903 * 904 * Acquire a reference count on vblank events to avoid having them disabled 905 * while in use. 906 * 907 * This is the native kms version of drm_vblank_off(). 908 * 909 * Returns: 910 * Zero on success, nonzero on failure. 911 */ 912 int drm_crtc_vblank_get(struct drm_crtc *crtc) 913 { 914 return drm_vblank_get(crtc->dev, drm_crtc_index(crtc)); 915 } 916 EXPORT_SYMBOL(drm_crtc_vblank_get); 917 918 /** 919 * drm_vblank_put - give up ownership of vblank events 920 * @dev: DRM device 921 * @crtc: which counter to give up 922 * 923 * Release ownership of a given vblank counter, turning off interrupts 924 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds. 925 */ 926 void drm_vblank_put(struct drm_device *dev, int crtc) 927 { 928 BUG_ON(atomic_read(&dev->vblank[crtc].refcount) == 0); 929 930 /* Last user schedules interrupt disable */ 931 if (atomic_dec_and_test(&dev->vblank[crtc].refcount) && 932 (drm_vblank_offdelay > 0)) 933 mod_timer(&dev->vblank[crtc].disable_timer, 934 jiffies + ((drm_vblank_offdelay * HZ)/1000)); 935 } 936 EXPORT_SYMBOL(drm_vblank_put); 937 938 /** 939 * drm_crtc_vblank_put - give up ownership of vblank events 940 * @crtc: which counter to give up 941 * 942 * Release ownership of a given vblank counter, turning off interrupts 943 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds. 944 * 945 * This is the native kms version of drm_vblank_put(). 946 */ 947 void drm_crtc_vblank_put(struct drm_crtc *crtc) 948 { 949 drm_vblank_put(crtc->dev, drm_crtc_index(crtc)); 950 } 951 EXPORT_SYMBOL(drm_crtc_vblank_put); 952 953 /** 954 * drm_vblank_off - disable vblank events on a CRTC 955 * @dev: DRM device 956 * @crtc: CRTC in question 957 * 958 * Drivers can use this function to shut down the vblank interrupt handling when 959 * disabling a crtc. This function ensures that the latest vblank frame count is 960 * stored so that drm_vblank_on() can restore it again. 961 * 962 * Drivers must use this function when the hardware vblank counter can get 963 * reset, e.g. when suspending. 964 * 965 * This is the legacy version of drm_crtc_vblank_off(). 966 */ 967 void drm_vblank_off(struct drm_device *dev, int crtc) 968 { 969 struct drm_pending_vblank_event *e, *t; 970 struct timeval now; 971 unsigned int seq; 972 973 lockmgr(&dev->vbl_lock, LK_EXCLUSIVE); 974 vblank_disable_and_save(dev, crtc); 975 wake_up(&dev->vblank[crtc].queue); 976 977 /* Send any queued vblank events, lest the natives grow disquiet */ 978 seq = drm_vblank_count_and_time(dev, crtc, &now); 979 980 lockmgr(&dev->event_lock, LK_EXCLUSIVE); 981 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) { 982 if (e->pipe != crtc) 983 continue; 984 DRM_DEBUG("Sending premature vblank event on disable: \ 985 wanted %d, current %d\n", 986 e->event.sequence, seq); 987 list_del(&e->base.link); 988 drm_vblank_put(dev, e->pipe); 989 send_vblank_event(dev, e, seq, &now); 990 } 991 lockmgr(&dev->event_lock, LK_RELEASE); 992 993 lockmgr(&dev->vbl_lock, LK_RELEASE); 994 } 995 EXPORT_SYMBOL(drm_vblank_off); 996 997 /** 998 * drm_crtc_vblank_off - disable vblank events on a CRTC 999 * @crtc: CRTC in question 1000 * 1001 * Drivers can use this function to shut down the vblank interrupt handling when 1002 * disabling a crtc. This function ensures that the latest vblank frame count is 1003 * stored so that drm_vblank_on can restore it again. 1004 * 1005 * Drivers must use this function when the hardware vblank counter can get 1006 * reset, e.g. when suspending. 1007 * 1008 * This is the native kms version of drm_vblank_off(). 1009 */ 1010 void drm_crtc_vblank_off(struct drm_crtc *crtc) 1011 { 1012 drm_vblank_off(crtc->dev, drm_crtc_index(crtc)); 1013 } 1014 EXPORT_SYMBOL(drm_crtc_vblank_off); 1015 1016 /** 1017 * drm_vblank_on - enable vblank events on a CRTC 1018 * @dev: DRM device 1019 * @crtc: CRTC in question 1020 * 1021 * This functions restores the vblank interrupt state captured with 1022 * drm_vblank_off() again. Note that calls to drm_vblank_on() and 1023 * drm_vblank_off() can be unbalanced and so can also be unconditionaly called 1024 * in driver load code to reflect the current hardware state of the crtc. 1025 * 1026 * This is the legacy version of drm_crtc_vblank_on(). 1027 */ 1028 void drm_vblank_on(struct drm_device *dev, int crtc) 1029 { 1030 1031 lockmgr(&dev->vbl_lock, LK_EXCLUSIVE); 1032 /* re-enable interrupts if there's are users left */ 1033 if (atomic_read(&dev->vblank[crtc].refcount) != 0) 1034 WARN_ON(drm_vblank_enable(dev, crtc)); 1035 lockmgr(&dev->vbl_lock, LK_RELEASE); 1036 } 1037 EXPORT_SYMBOL(drm_vblank_on); 1038 1039 /** 1040 * drm_crtc_vblank_on - enable vblank events on a CRTC 1041 * @crtc: CRTC in question 1042 * 1043 * This functions restores the vblank interrupt state captured with 1044 * drm_vblank_off() again. Note that calls to drm_vblank_on() and 1045 * drm_vblank_off() can be unbalanced and so can also be unconditionaly called 1046 * in driver load code to reflect the current hardware state of the crtc. 1047 * 1048 * This is the native kms version of drm_vblank_on(). 1049 */ 1050 void drm_crtc_vblank_on(struct drm_crtc *crtc) 1051 { 1052 drm_vblank_on(crtc->dev, drm_crtc_index(crtc)); 1053 } 1054 EXPORT_SYMBOL(drm_crtc_vblank_on); 1055 1056 /** 1057 * drm_vblank_pre_modeset - account for vblanks across mode sets 1058 * @dev: DRM device 1059 * @crtc: CRTC in question 1060 * 1061 * Account for vblank events across mode setting events, which will likely 1062 * reset the hardware frame counter. 1063 */ 1064 void drm_vblank_pre_modeset(struct drm_device *dev, int crtc) 1065 { 1066 /* vblank is not initialized (IRQ not installed ?), or has been freed */ 1067 if (!dev->num_crtcs) 1068 return; 1069 /* 1070 * To avoid all the problems that might happen if interrupts 1071 * were enabled/disabled around or between these calls, we just 1072 * have the kernel take a reference on the CRTC (just once though 1073 * to avoid corrupting the count if multiple, mismatch calls occur), 1074 * so that interrupts remain enabled in the interim. 1075 */ 1076 if (!dev->vblank[crtc].inmodeset) { 1077 dev->vblank[crtc].inmodeset = 0x1; 1078 if (drm_vblank_get(dev, crtc) == 0) 1079 dev->vblank[crtc].inmodeset |= 0x2; 1080 } 1081 } 1082 EXPORT_SYMBOL(drm_vblank_pre_modeset); 1083 1084 void drm_vblank_post_modeset(struct drm_device *dev, int crtc) 1085 { 1086 1087 /* vblank is not initialized (IRQ not installed ?), or has been freed */ 1088 if (!dev->num_crtcs) 1089 return; 1090 1091 if (dev->vblank[crtc].inmodeset) { 1092 lockmgr(&dev->vbl_lock, LK_EXCLUSIVE); 1093 dev->vblank_disable_allowed = true; 1094 lockmgr(&dev->vbl_lock, LK_RELEASE); 1095 1096 if (dev->vblank[crtc].inmodeset & 0x2) 1097 drm_vblank_put(dev, crtc); 1098 1099 dev->vblank[crtc].inmodeset = 0; 1100 } 1101 } 1102 EXPORT_SYMBOL(drm_vblank_post_modeset); 1103 1104 /** 1105 * drm_modeset_ctl - handle vblank event counter changes across mode switch 1106 * @DRM_IOCTL_ARGS: standard ioctl arguments 1107 * 1108 * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET 1109 * ioctls around modesetting so that any lost vblank events are accounted for. 1110 * 1111 * Generally the counter will reset across mode sets. If interrupts are 1112 * enabled around this call, we don't have to do anything since the counter 1113 * will have already been incremented. 1114 */ 1115 int drm_modeset_ctl(struct drm_device *dev, void *data, 1116 struct drm_file *file_priv) 1117 { 1118 struct drm_modeset_ctl *modeset = data; 1119 unsigned int crtc; 1120 1121 /* If drm_vblank_init() hasn't been called yet, just no-op */ 1122 if (!dev->num_crtcs) 1123 return 0; 1124 1125 /* KMS drivers handle this internally */ 1126 if (drm_core_check_feature(dev, DRIVER_MODESET)) 1127 return 0; 1128 1129 crtc = modeset->crtc; 1130 if (crtc >= dev->num_crtcs) 1131 return -EINVAL; 1132 1133 switch (modeset->cmd) { 1134 case _DRM_PRE_MODESET: 1135 drm_vblank_pre_modeset(dev, crtc); 1136 break; 1137 case _DRM_POST_MODESET: 1138 drm_vblank_post_modeset(dev, crtc); 1139 break; 1140 default: 1141 return -EINVAL; 1142 } 1143 1144 return 0; 1145 } 1146 1147 static void 1148 drm_vblank_event_destroy(struct drm_pending_event *e) 1149 { 1150 kfree(e); 1151 } 1152 1153 static int drm_queue_vblank_event(struct drm_device *dev, int pipe, 1154 union drm_wait_vblank *vblwait, 1155 struct drm_file *file_priv) 1156 { 1157 struct drm_pending_vblank_event *e; 1158 struct timeval now; 1159 unsigned int seq; 1160 int ret; 1161 1162 e = kzalloc(sizeof *e, GFP_KERNEL); 1163 if (e == NULL) { 1164 ret = -ENOMEM; 1165 goto err_put; 1166 } 1167 1168 e->pipe = pipe; 1169 e->base.pid = curproc->p_pid; 1170 e->event.base.type = DRM_EVENT_VBLANK; 1171 e->event.base.length = sizeof e->event; 1172 e->event.user_data = vblwait->request.signal; 1173 e->base.event = &e->event.base; 1174 e->base.file_priv = file_priv; 1175 e->base.destroy = drm_vblank_event_destroy; 1176 1177 lockmgr(&dev->event_lock, LK_EXCLUSIVE); 1178 1179 if (file_priv->event_space < sizeof e->event) { 1180 ret = -EBUSY; 1181 goto err_unlock; 1182 } 1183 1184 file_priv->event_space -= sizeof e->event; 1185 seq = drm_vblank_count_and_time(dev, pipe, &now); 1186 1187 if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) && 1188 (seq - vblwait->request.sequence) <= (1 << 23)) { 1189 vblwait->request.sequence = seq + 1; 1190 vblwait->reply.sequence = vblwait->request.sequence; 1191 } 1192 1193 DRM_DEBUG("event on vblank count %d, current %d, crtc %d\n", 1194 vblwait->request.sequence, seq, pipe); 1195 1196 e->event.sequence = vblwait->request.sequence; 1197 if ((seq - vblwait->request.sequence) <= (1 << 23)) { 1198 drm_vblank_put(dev, pipe); 1199 send_vblank_event(dev, e, seq, &now); 1200 vblwait->reply.sequence = seq; 1201 } else { 1202 /* drm_handle_vblank_events will call drm_vblank_put */ 1203 list_add_tail(&e->base.link, &dev->vblank_event_list); 1204 vblwait->reply.sequence = vblwait->request.sequence; 1205 } 1206 1207 lockmgr(&dev->event_lock, LK_RELEASE); 1208 1209 return 0; 1210 1211 err_unlock: 1212 lockmgr(&dev->event_lock, LK_RELEASE); 1213 kfree(e); 1214 err_put: 1215 drm_vblank_put(dev, pipe); 1216 return ret; 1217 } 1218 1219 /** 1220 * Wait for VBLANK. 1221 * 1222 * \param inode device inode. 1223 * \param file_priv DRM file private. 1224 * \param cmd command. 1225 * \param data user argument, pointing to a drm_wait_vblank structure. 1226 * \return zero on success or a negative number on failure. 1227 * 1228 * This function enables the vblank interrupt on the pipe requested, then 1229 * sleeps waiting for the requested sequence number to occur, and drops 1230 * the vblank interrupt refcount afterwards. (vblank irq disable follows that 1231 * after a timeout with no further vblank waits scheduled). 1232 */ 1233 int drm_wait_vblank(struct drm_device *dev, void *data, 1234 struct drm_file *file_priv) 1235 { 1236 union drm_wait_vblank *vblwait = data; 1237 int ret; 1238 unsigned int flags, seq, crtc, high_crtc; 1239 1240 if (!dev->irq_enabled) 1241 return -EINVAL; 1242 1243 if (vblwait->request.type & _DRM_VBLANK_SIGNAL) 1244 return -EINVAL; 1245 1246 if (vblwait->request.type & 1247 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK | 1248 _DRM_VBLANK_HIGH_CRTC_MASK)) { 1249 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n", 1250 vblwait->request.type, 1251 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK | 1252 _DRM_VBLANK_HIGH_CRTC_MASK)); 1253 return -EINVAL; 1254 } 1255 1256 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK; 1257 high_crtc = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK); 1258 if (high_crtc) 1259 crtc = high_crtc >> _DRM_VBLANK_HIGH_CRTC_SHIFT; 1260 else 1261 crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0; 1262 if (crtc >= dev->num_crtcs) 1263 return -EINVAL; 1264 1265 ret = drm_vblank_get(dev, crtc); 1266 if (ret) { 1267 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret); 1268 return ret; 1269 } 1270 seq = drm_vblank_count(dev, crtc); 1271 1272 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) { 1273 case _DRM_VBLANK_RELATIVE: 1274 vblwait->request.sequence += seq; 1275 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE; 1276 case _DRM_VBLANK_ABSOLUTE: 1277 break; 1278 default: 1279 ret = -EINVAL; 1280 goto done; 1281 } 1282 1283 if (flags & _DRM_VBLANK_EVENT) { 1284 /* must hold on to the vblank ref until the event fires 1285 * drm_vblank_put will be called asynchronously 1286 */ 1287 return drm_queue_vblank_event(dev, crtc, vblwait, file_priv); 1288 } 1289 1290 if ((flags & _DRM_VBLANK_NEXTONMISS) && 1291 (seq - vblwait->request.sequence) <= (1<<23)) { 1292 vblwait->request.sequence = seq + 1; 1293 } 1294 1295 DRM_DEBUG("waiting on vblank count %d, crtc %d\n", 1296 vblwait->request.sequence, crtc); 1297 dev->vblank[crtc].last_wait = vblwait->request.sequence; 1298 DRM_WAIT_ON(ret, dev->vblank[crtc].queue, 3 * HZ, 1299 (((drm_vblank_count(dev, crtc) - 1300 vblwait->request.sequence) <= (1 << 23)) || 1301 !dev->vblank[crtc].enabled || 1302 !dev->irq_enabled)); 1303 1304 if (ret != -EINTR) { 1305 struct timeval now; 1306 1307 vblwait->reply.sequence = drm_vblank_count_and_time(dev, crtc, &now); 1308 vblwait->reply.tval_sec = now.tv_sec; 1309 vblwait->reply.tval_usec = now.tv_usec; 1310 1311 DRM_DEBUG("returning %d to client\n", 1312 vblwait->reply.sequence); 1313 } else { 1314 DRM_DEBUG("vblank wait interrupted by signal\n"); 1315 } 1316 1317 done: 1318 drm_vblank_put(dev, crtc); 1319 return ret; 1320 } 1321 1322 static void drm_handle_vblank_events(struct drm_device *dev, int crtc) 1323 { 1324 struct drm_pending_vblank_event *e, *t; 1325 struct timeval now; 1326 unsigned int seq; 1327 1328 seq = drm_vblank_count_and_time(dev, crtc, &now); 1329 1330 lockmgr(&dev->event_lock, LK_EXCLUSIVE); 1331 1332 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) { 1333 if (e->pipe != crtc) 1334 continue; 1335 if ((seq - e->event.sequence) > (1<<23)) 1336 continue; 1337 1338 DRM_DEBUG("vblank event on %d, current %d\n", 1339 e->event.sequence, seq); 1340 1341 list_del(&e->base.link); 1342 drm_vblank_put(dev, e->pipe); 1343 send_vblank_event(dev, e, seq, &now); 1344 } 1345 1346 lockmgr(&dev->event_lock, LK_RELEASE); 1347 } 1348 1349 /** 1350 * drm_handle_vblank - handle a vblank event 1351 * @dev: DRM device 1352 * @crtc: where this event occurred 1353 * 1354 * Drivers should call this routine in their vblank interrupt handlers to 1355 * update the vblank counter and send any signals that may be pending. 1356 */ 1357 bool drm_handle_vblank(struct drm_device *dev, int crtc) 1358 { 1359 u32 vblcount; 1360 s64 diff_ns; 1361 struct timeval tvblank; 1362 1363 if (!dev->num_crtcs) 1364 return false; 1365 1366 /* Need timestamp lock to prevent concurrent execution with 1367 * vblank enable/disable, as this would cause inconsistent 1368 * or corrupted timestamps and vblank counts. 1369 */ 1370 lockmgr(&dev->vblank_time_lock, LK_EXCLUSIVE); 1371 1372 /* Vblank irq handling disabled. Nothing to do. */ 1373 if (!dev->vblank[crtc].enabled) { 1374 lockmgr(&dev->vblank_time_lock, LK_RELEASE); 1375 return false; 1376 } 1377 1378 /* Fetch corresponding timestamp for this vblank interval from 1379 * driver and store it in proper slot of timestamp ringbuffer. 1380 */ 1381 1382 /* Get current timestamp and count. */ 1383 vblcount = atomic_read(&dev->vblank[crtc].count); 1384 drm_get_last_vbltimestamp(dev, crtc, &tvblank, DRM_CALLED_FROM_VBLIRQ); 1385 1386 /* Compute time difference to timestamp of last vblank */ 1387 diff_ns = timeval_to_ns(&tvblank) - 1388 timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount)); 1389 1390 /* Update vblank timestamp and count if at least 1391 * DRM_REDUNDANT_VBLIRQ_THRESH_NS nanoseconds 1392 * difference between last stored timestamp and current 1393 * timestamp. A smaller difference means basically 1394 * identical timestamps. Happens if this vblank has 1395 * been already processed and this is a redundant call, 1396 * e.g., due to spurious vblank interrupts. We need to 1397 * ignore those for accounting. 1398 */ 1399 if (abs64(diff_ns) > DRM_REDUNDANT_VBLIRQ_THRESH_NS) { 1400 /* Store new timestamp in ringbuffer. */ 1401 vblanktimestamp(dev, crtc, vblcount + 1) = tvblank; 1402 1403 /* Increment cooked vblank count. This also atomically commits 1404 * the timestamp computed above. 1405 */ 1406 smp_mb__before_atomic(); 1407 atomic_inc(&dev->vblank[crtc].count); 1408 smp_mb__after_atomic(); 1409 } else { 1410 DRM_DEBUG("crtc %d: Redundant vblirq ignored. diff_ns = %d\n", 1411 crtc, (int) diff_ns); 1412 } 1413 1414 wake_up(&dev->vblank[crtc].queue); 1415 drm_handle_vblank_events(dev, crtc); 1416 1417 lockmgr(&dev->vblank_time_lock, LK_RELEASE); 1418 return true; 1419 } 1420 EXPORT_SYMBOL(drm_handle_vblank); 1421