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