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