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