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