drivers/gpu/drm/drm_irq.c

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