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