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