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 "drmP.h"
  37
  38 #include <linux/interrupt.h>    /* For task queue support */
  39 #include <linux/slab.h>
  40
  41 #include <linux/vgaarb.h>
  42 /**
  43  * Get interrupt from bus id.
  44  *
  45  * \param inode device inode.
  46  * \param file_priv DRM file private.
  47  * \param cmd command.
  48  * \param arg user argument, pointing to a drm_irq_busid structure.
  49  * \return zero on success or a negative number on failure.
  50  *
  51  * Finds the PCI device with the specified bus id and gets its IRQ number.
  52  * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
  53  * to that of the device that this DRM instance attached to.
  54  */
  55 int drm_irq_by_busid(struct drm_device *dev, void *data,
  56                      struct drm_file *file_priv)
  57 {
  58         struct drm_irq_busid *p = data;
  59
  60         if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
  61                 return -EINVAL;
  62
  63         if ((p->busnum >> 8) != drm_get_pci_domain(dev) ||
  64             (p->busnum & 0xff) != dev->pdev->bus->number ||
  65             p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn))
  66                 return -EINVAL;
  67
  68         p->irq = dev->pdev->irq;
  69
  70         DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
  71                   p->irq);
  72
  73         return 0;
  74 }
  75
  76 static void vblank_disable_fn(unsigned long arg)
  77 {
  78         struct drm_device *dev = (struct drm_device *)arg;
  79         unsigned long irqflags;
  80         int i;
  81
  82         if (!dev->vblank_disable_allowed)
  83                 return;
  84
  85         for (i = 0; i < dev->num_crtcs; i++) {
  86                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
  87                 if (atomic_read(&dev->vblank_refcount[i]) == 0 &&
  88                     dev->vblank_enabled[i]) {
  89                         DRM_DEBUG("disabling vblank on crtc %d\n", i);
  90                         dev->last_vblank[i] =
  91                                 dev->driver->get_vblank_counter(dev, i);
  92                         dev->driver->disable_vblank(dev, i);
  93                         dev->vblank_enabled[i] = 0;
  94                 }
  95                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
  96         }
  97 }
  98
  99 void drm_vblank_cleanup(struct drm_device *dev)
 100 {
 101         /* Bail if the driver didn't call drm_vblank_init() */
 102         if (dev->num_crtcs == 0)
 103                 return;
 104
 105         del_timer(&dev->vblank_disable_timer);
 106
 107         vblank_disable_fn((unsigned long)dev);
 108
 109         kfree(dev->vbl_queue);
 110         kfree(dev->_vblank_count);
 111         kfree(dev->vblank_refcount);
 112         kfree(dev->vblank_enabled);
 113         kfree(dev->last_vblank);
 114         kfree(dev->last_vblank_wait);
 115         kfree(dev->vblank_inmodeset);
 116
 117         dev->num_crtcs = 0;
 118 }
 119 EXPORT_SYMBOL(drm_vblank_cleanup);
 120
 121 int drm_vblank_init(struct drm_device *dev, int num_crtcs)
 122 {
 123         int i, ret = -ENOMEM;
 124
 125         setup_timer(&dev->vblank_disable_timer, vblank_disable_fn,
 126                     (unsigned long)dev);
 127         spin_lock_init(&dev->vbl_lock);
 128         dev->num_crtcs = num_crtcs;
 129
 130         dev->vbl_queue = kmalloc(sizeof(wait_queue_head_t) * num_crtcs,
 131                                  GFP_KERNEL);
 132         if (!dev->vbl_queue)
 133                 goto err;
 134
 135         dev->_vblank_count = kmalloc(sizeof(atomic_t) * num_crtcs, GFP_KERNEL);
 136         if (!dev->_vblank_count)
 137                 goto err;
 138
 139         dev->vblank_refcount = kmalloc(sizeof(atomic_t) * num_crtcs,
 140                                        GFP_KERNEL);
 141         if (!dev->vblank_refcount)
 142                 goto err;
 143
 144         dev->vblank_enabled = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
 145         if (!dev->vblank_enabled)
 146                 goto err;
 147
 148         dev->last_vblank = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
 149         if (!dev->last_vblank)
 150                 goto err;
 151
 152         dev->last_vblank_wait = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
 153         if (!dev->last_vblank_wait)
 154                 goto err;
 155
 156         dev->vblank_inmodeset = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
 157         if (!dev->vblank_inmodeset)
 158                 goto err;
 159
 160         /* Zero per-crtc vblank stuff */
 161         for (i = 0; i < num_crtcs; i++) {
 162                 init_waitqueue_head(&dev->vbl_queue[i]);
 163                 atomic_set(&dev->_vblank_count[i], 0);
 164                 atomic_set(&dev->vblank_refcount[i], 0);
 165         }
 166
 167         dev->vblank_disable_allowed = 0;
 168         return 0;
 169
 170 err:
 171         drm_vblank_cleanup(dev);
 172         return ret;
 173 }
 174 EXPORT_SYMBOL(drm_vblank_init);
 175
 176 static void drm_irq_vgaarb_nokms(void *cookie, bool state)
 177 {
 178         struct drm_device *dev = cookie;
 179
 180         if (dev->driver->vgaarb_irq) {
 181                 dev->driver->vgaarb_irq(dev, state);
 182                 return;
 183         }
 184
 185         if (!dev->irq_enabled)
 186                 return;
 187
 188         if (state)
 189                 dev->driver->irq_uninstall(dev);
 190         else {
 191                 dev->driver->irq_preinstall(dev);
 192                 dev->driver->irq_postinstall(dev);
 193         }
 194 }
 195
 196 /**
 197  * Install IRQ handler.
 198  *
 199  * \param dev DRM device.
 200  *
 201  * Initializes the IRQ related data. Installs the handler, calling the driver
 202  * \c drm_driver_irq_preinstall() and \c drm_driver_irq_postinstall() functions
 203  * before and after the installation.
 204  */
 205 int drm_irq_install(struct drm_device *dev)
 206 {
 207         int ret = 0;
 208         unsigned long sh_flags = 0;
 209         char *irqname;
 210
 211         if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 212                 return -EINVAL;
 213
 214         if (dev->pdev->irq == 0)
 215                 return -EINVAL;
 216
 217         mutex_lock(&dev->struct_mutex);
 218
 219         /* Driver must have been initialized */
 220         if (!dev->dev_private) {
 221                 mutex_unlock(&dev->struct_mutex);
 222                 return -EINVAL;
 223         }
 224
 225         if (dev->irq_enabled) {
 226                 mutex_unlock(&dev->struct_mutex);
 227                 return -EBUSY;
 228         }
 229         dev->irq_enabled = 1;
 230         mutex_unlock(&dev->struct_mutex);
 231
 232         DRM_DEBUG("irq=%d\n", dev->pdev->irq);
 233
 234         /* Before installing handler */
 235         dev->driver->irq_preinstall(dev);
 236
 237         /* Install handler */
 238         if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
 239                 sh_flags = IRQF_SHARED;
 240
 241         if (dev->devname)
 242                 irqname = dev->devname;
 243         else
 244                 irqname = dev->driver->name;
 245
 246         ret = request_irq(drm_dev_to_irq(dev), dev->driver->irq_handler,
 247                           sh_flags, irqname, dev);
 248
 249         if (ret < 0) {
 250                 mutex_lock(&dev->struct_mutex);
 251                 dev->irq_enabled = 0;
 252                 mutex_unlock(&dev->struct_mutex);
 253                 return ret;
 254         }
 255
 256         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 257                 vga_client_register(dev->pdev, (void *)dev, drm_irq_vgaarb_nokms, NULL);
 258
 259         /* After installing handler */
 260         ret = dev->driver->irq_postinstall(dev);
 261         if (ret < 0) {
 262                 mutex_lock(&dev->struct_mutex);
 263                 dev->irq_enabled = 0;
 264                 mutex_unlock(&dev->struct_mutex);
 265         }
 266
 267         return ret;
 268 }
 269 EXPORT_SYMBOL(drm_irq_install);
 270
 271 /**
 272  * Uninstall the IRQ handler.
 273  *
 274  * \param dev DRM device.
 275  *
 276  * Calls the driver's \c drm_driver_irq_uninstall() function, and stops the irq.
 277  */
 278 int drm_irq_uninstall(struct drm_device * dev)
 279 {
 280         unsigned long irqflags;
 281         int irq_enabled, i;
 282
 283         if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 284                 return -EINVAL;
 285
 286         mutex_lock(&dev->struct_mutex);
 287         irq_enabled = dev->irq_enabled;
 288         dev->irq_enabled = 0;
 289         mutex_unlock(&dev->struct_mutex);
 290
 291         /*
 292          * Wake up any waiters so they don't hang.
 293          */
 294         spin_lock_irqsave(&dev->vbl_lock, irqflags);
 295         for (i = 0; i < dev->num_crtcs; i++) {
 296                 DRM_WAKEUP(&dev->vbl_queue[i]);
 297                 dev->vblank_enabled[i] = 0;
 298                 dev->last_vblank[i] = dev->driver->get_vblank_counter(dev, i);
 299         }
 300         spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 301
 302         if (!irq_enabled)
 303                 return -EINVAL;
 304
 305         DRM_DEBUG("irq=%d\n", dev->pdev->irq);
 306
 307         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 308                 vga_client_register(dev->pdev, NULL, NULL, NULL);
 309
 310         dev->driver->irq_uninstall(dev);
 311
 312         free_irq(dev->pdev->irq, dev);
 313
 314         return 0;
 315 }
 316 EXPORT_SYMBOL(drm_irq_uninstall);
 317
 318 /**
 319  * IRQ control ioctl.
 320  *
 321  * \param inode device inode.
 322  * \param file_priv DRM file private.
 323  * \param cmd command.
 324  * \param arg user argument, pointing to a drm_control structure.
 325  * \return zero on success or a negative number on failure.
 326  *
 327  * Calls irq_install() or irq_uninstall() according to \p arg.
 328  */
 329 int drm_control(struct drm_device *dev, void *data,
 330                 struct drm_file *file_priv)
 331 {
 332         struct drm_control *ctl = data;
 333
 334         /* if we haven't irq we fallback for compatibility reasons - this used to be a separate function in drm_dma.h */
 335
 336
 337         switch (ctl->func) {
 338         case DRM_INST_HANDLER:
 339                 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 340                         return 0;
 341                 if (drm_core_check_feature(dev, DRIVER_MODESET))
 342                         return 0;
 343                 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
 344                     ctl->irq != dev->pdev->irq)
 345                         return -EINVAL;
 346                 return drm_irq_install(dev);
 347         case DRM_UNINST_HANDLER:
 348                 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 349                         return 0;
 350                 if (drm_core_check_feature(dev, DRIVER_MODESET))
 351                         return 0;
 352                 return drm_irq_uninstall(dev);
 353         default:
 354                 return -EINVAL;
 355         }
 356 }
 357
 358 /**
 359  * drm_vblank_count - retrieve "cooked" vblank counter value
 360  * @dev: DRM device
 361  * @crtc: which counter to retrieve
 362  *
 363  * Fetches the "cooked" vblank count value that represents the number of
 364  * vblank events since the system was booted, including lost events due to
 365  * modesetting activity.
 366  */
 367 u32 drm_vblank_count(struct drm_device *dev, int crtc)
 368 {
 369         return atomic_read(&dev->_vblank_count[crtc]);
 370 }
 371 EXPORT_SYMBOL(drm_vblank_count);
 372
 373 /**
 374  * drm_update_vblank_count - update the master vblank counter
 375  * @dev: DRM device
 376  * @crtc: counter to update
 377  *
 378  * Call back into the driver to update the appropriate vblank counter
 379  * (specified by @crtc).  Deal with wraparound, if it occurred, and
 380  * update the last read value so we can deal with wraparound on the next
 381  * call if necessary.
 382  *
 383  * Only necessary when going from off->on, to account for frames we
 384  * didn't get an interrupt for.
 385  *
 386  * Note: caller must hold dev->vbl_lock since this reads & writes
 387  * device vblank fields.
 388  */
 389 static void drm_update_vblank_count(struct drm_device *dev, int crtc)
 390 {
 391         u32 cur_vblank, diff;
 392
 393         /*
 394          * Interrupts were disabled prior to this call, so deal with counter
 395          * wrap if needed.
 396          * NOTE!  It's possible we lost a full dev->max_vblank_count events
 397          * here if the register is small or we had vblank interrupts off for
 398          * a long time.
 399          */
 400         cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
 401         diff = cur_vblank - dev->last_vblank[crtc];
 402         if (cur_vblank < dev->last_vblank[crtc]) {
 403                 diff += dev->max_vblank_count;
 404
 405                 DRM_DEBUG("last_vblank[%d]=0x%x, cur_vblank=0x%x => diff=0x%x\n",
 406                           crtc, dev->last_vblank[crtc], cur_vblank, diff);
 407         }
 408
 409         DRM_DEBUG("enabling vblank interrupts on crtc %d, missed %d\n",
 410                   crtc, diff);
 411
 412         atomic_add(diff, &dev->_vblank_count[crtc]);
 413 }
 414
 415 /**
 416  * drm_vblank_get - get a reference count on vblank events
 417  * @dev: DRM device
 418  * @crtc: which CRTC to own
 419  *
 420  * Acquire a reference count on vblank events to avoid having them disabled
 421  * while in use.
 422  *
 423  * RETURNS
 424  * Zero on success, nonzero on failure.
 425  */
 426 int drm_vblank_get(struct drm_device *dev, int crtc)
 427 {
 428         unsigned long irqflags;
 429         int ret = 0;
 430
 431         spin_lock_irqsave(&dev->vbl_lock, irqflags);
 432         /* Going from 0->1 means we have to enable interrupts again */
 433         if (atomic_add_return(1, &dev->vblank_refcount[crtc]) == 1) {
 434                 if (!dev->vblank_enabled[crtc]) {
 435                         ret = dev->driver->enable_vblank(dev, crtc);
 436                         DRM_DEBUG("enabling vblank on crtc %d, ret: %d\n", crtc, ret);
 437                         if (ret)
 438                                 atomic_dec(&dev->vblank_refcount[crtc]);
 439                         else {
 440                                 dev->vblank_enabled[crtc] = 1;
 441                                 drm_update_vblank_count(dev, crtc);
 442                         }
 443                 }
 444         } else {
 445                 if (!dev->vblank_enabled[crtc]) {
 446                         atomic_dec(&dev->vblank_refcount[crtc]);
 447                         ret = -EINVAL;
 448                 }
 449         }
 450         spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 451
 452         return ret;
 453 }
 454 EXPORT_SYMBOL(drm_vblank_get);
 455
 456 /**
 457  * drm_vblank_put - give up ownership of vblank events
 458  * @dev: DRM device
 459  * @crtc: which counter to give up
 460  *
 461  * Release ownership of a given vblank counter, turning off interrupts
 462  * if possible.
 463  */
 464 void drm_vblank_put(struct drm_device *dev, int crtc)
 465 {
 466         BUG_ON (atomic_read (&dev->vblank_refcount[crtc]) == 0);
 467
 468         /* Last user schedules interrupt disable */
 469         if (atomic_dec_and_test(&dev->vblank_refcount[crtc]))
 470                 mod_timer(&dev->vblank_disable_timer, jiffies + 5*DRM_HZ);
 471 }
 472 EXPORT_SYMBOL(drm_vblank_put);
 473
 474 void drm_vblank_off(struct drm_device *dev, int crtc)
 475 {
 476         unsigned long irqflags;
 477
 478         spin_lock_irqsave(&dev->vbl_lock, irqflags);
 479         dev->driver->disable_vblank(dev, crtc);
 480         DRM_WAKEUP(&dev->vbl_queue[crtc]);
 481         dev->vblank_enabled[crtc] = 0;
 482         dev->last_vblank[crtc] = dev->driver->get_vblank_counter(dev, crtc);
 483         spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 484 }
 485 EXPORT_SYMBOL(drm_vblank_off);
 486
 487 /**
 488  * drm_vblank_pre_modeset - account for vblanks across mode sets
 489  * @dev: DRM device
 490  * @crtc: CRTC in question
 491  * @post: post or pre mode set?
 492  *
 493  * Account for vblank events across mode setting events, which will likely
 494  * reset the hardware frame counter.
 495  */
 496 void drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
 497 {
 498         /* vblank is not initialized (IRQ not installed ?) */
 499         if (!dev->num_crtcs)
 500                 return;
 501         /*
 502          * To avoid all the problems that might happen if interrupts
 503          * were enabled/disabled around or between these calls, we just
 504          * have the kernel take a reference on the CRTC (just once though
 505          * to avoid corrupting the count if multiple, mismatch calls occur),
 506          * so that interrupts remain enabled in the interim.
 507          */
 508         if (!dev->vblank_inmodeset[crtc]) {
 509                 dev->vblank_inmodeset[crtc] = 0x1;
 510                 if (drm_vblank_get(dev, crtc) == 0)
 511                         dev->vblank_inmodeset[crtc] |= 0x2;
 512         }
 513 }
 514 EXPORT_SYMBOL(drm_vblank_pre_modeset);
 515
 516 void drm_vblank_post_modeset(struct drm_device *dev, int crtc)
 517 {
 518         unsigned long irqflags;
 519
 520         if (dev->vblank_inmodeset[crtc]) {
 521                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 522                 dev->vblank_disable_allowed = 1;
 523                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 524
 525                 if (dev->vblank_inmodeset[crtc] & 0x2)
 526                         drm_vblank_put(dev, crtc);
 527
 528                 dev->vblank_inmodeset[crtc] = 0;
 529         }
 530 }
 531 EXPORT_SYMBOL(drm_vblank_post_modeset);
 532
 533 /**
 534  * drm_modeset_ctl - handle vblank event counter changes across mode switch
 535  * @DRM_IOCTL_ARGS: standard ioctl arguments
 536  *
 537  * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
 538  * ioctls around modesetting so that any lost vblank events are accounted for.
 539  *
 540  * Generally the counter will reset across mode sets.  If interrupts are
 541  * enabled around this call, we don't have to do anything since the counter
 542  * will have already been incremented.
 543  */
 544 int drm_modeset_ctl(struct drm_device *dev, void *data,
 545                     struct drm_file *file_priv)
 546 {
 547         struct drm_modeset_ctl *modeset = data;
 548         int crtc, ret = 0;
 549
 550         /* If drm_vblank_init() hasn't been called yet, just no-op */
 551         if (!dev->num_crtcs)
 552                 goto out;
 553
 554         crtc = modeset->crtc;
 555         if (crtc >= dev->num_crtcs) {
 556                 ret = -EINVAL;
 557                 goto out;
 558         }
 559
 560         switch (modeset->cmd) {
 561         case _DRM_PRE_MODESET:
 562                 drm_vblank_pre_modeset(dev, crtc);
 563                 break;
 564         case _DRM_POST_MODESET:
 565                 drm_vblank_post_modeset(dev, crtc);
 566                 break;
 567         default:
 568                 ret = -EINVAL;
 569                 break;
 570         }
 571
 572 out:
 573         return ret;
 574 }
 575
 576 static int drm_queue_vblank_event(struct drm_device *dev, int pipe,
 577                                   union drm_wait_vblank *vblwait,
 578                                   struct drm_file *file_priv)
 579 {
 580         struct drm_pending_vblank_event *e;
 581         struct timeval now;
 582         unsigned long flags;
 583         unsigned int seq;
 584
 585         e = kzalloc(sizeof *e, GFP_KERNEL);
 586         if (e == NULL)
 587                 return -ENOMEM;
 588
 589         e->pipe = pipe;
 590         e->event.base.type = DRM_EVENT_VBLANK;
 591         e->event.base.length = sizeof e->event;
 592         e->event.user_data = vblwait->request.signal;
 593         e->base.event = &e->event.base;
 594         e->base.file_priv = file_priv;
 595         e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
 596
 597         do_gettimeofday(&now);
 598         spin_lock_irqsave(&dev->event_lock, flags);
 599
 600         if (file_priv->event_space < sizeof e->event) {
 601                 spin_unlock_irqrestore(&dev->event_lock, flags);
 602                 kfree(e);
 603                 return -ENOMEM;
 604         }
 605
 606         file_priv->event_space -= sizeof e->event;
 607         seq = drm_vblank_count(dev, pipe);
 608         if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) &&
 609             (seq - vblwait->request.sequence) <= (1 << 23)) {
 610                 vblwait->request.sequence = seq + 1;
 611                 vblwait->reply.sequence = vblwait->request.sequence;
 612         }
 613
 614         DRM_DEBUG("event on vblank count %d, current %d, crtc %d\n",
 615                   vblwait->request.sequence, seq, pipe);
 616
 617         e->event.sequence = vblwait->request.sequence;
 618         if ((seq - vblwait->request.sequence) <= (1 << 23)) {
 619                 e->event.tv_sec = now.tv_sec;
 620                 e->event.tv_usec = now.tv_usec;
 621                 drm_vblank_put(dev, e->pipe);
 622                 list_add_tail(&e->base.link, &e->base.file_priv->event_list);
 623                 wake_up_interruptible(&e->base.file_priv->event_wait);
 624         } else {
 625                 list_add_tail(&e->base.link, &dev->vblank_event_list);
 626         }
 627
 628         spin_unlock_irqrestore(&dev->event_lock, flags);
 629
 630         return 0;
 631 }
 632
 633 /**
 634  * Wait for VBLANK.
 635  *
 636  * \param inode device inode.
 637  * \param file_priv DRM file private.
 638  * \param cmd command.
 639  * \param data user argument, pointing to a drm_wait_vblank structure.
 640  * \return zero on success or a negative number on failure.
 641  *
 642  * This function enables the vblank interrupt on the pipe requested, then
 643  * sleeps waiting for the requested sequence number to occur, and drops
 644  * the vblank interrupt refcount afterwards. (vblank irq disable follows that
 645  * after a timeout with no further vblank waits scheduled).
 646  */
 647 int drm_wait_vblank(struct drm_device *dev, void *data,
 648                     struct drm_file *file_priv)
 649 {
 650         union drm_wait_vblank *vblwait = data;
 651         int ret = 0;
 652         unsigned int flags, seq, crtc;
 653
 654         if ((!dev->pdev->irq) || (!dev->irq_enabled))
 655                 return -EINVAL;
 656
 657         if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
 658                 return -EINVAL;
 659
 660         if (vblwait->request.type &
 661             ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK)) {
 662                 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
 663                           vblwait->request.type,
 664                           (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK));
 665                 return -EINVAL;
 666         }
 667
 668         flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
 669         crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
 670
 671         if (crtc >= dev->num_crtcs)
 672                 return -EINVAL;
 673
 674         ret = drm_vblank_get(dev, crtc);
 675         if (ret) {
 676                 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
 677                 return ret;
 678         }
 679         seq = drm_vblank_count(dev, crtc);
 680
 681         switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
 682         case _DRM_VBLANK_RELATIVE:
 683                 vblwait->request.sequence += seq;
 684                 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
 685         case _DRM_VBLANK_ABSOLUTE:
 686                 break;
 687         default:
 688                 ret = -EINVAL;
 689                 goto done;
 690         }
 691
 692         if (flags & _DRM_VBLANK_EVENT)
 693                 return drm_queue_vblank_event(dev, crtc, vblwait, file_priv);
 694
 695         if ((flags & _DRM_VBLANK_NEXTONMISS) &&
 696             (seq - vblwait->request.sequence) <= (1<<23)) {
 697                 vblwait->request.sequence = seq + 1;
 698         }
 699
 700         DRM_DEBUG("waiting on vblank count %d, crtc %d\n",
 701                   vblwait->request.sequence, crtc);
 702         dev->last_vblank_wait[crtc] = vblwait->request.sequence;
 703         DRM_WAIT_ON(ret, dev->vbl_queue[crtc], 3 * DRM_HZ,
 704                     (((drm_vblank_count(dev, crtc) -
 705                        vblwait->request.sequence) <= (1 << 23)) ||
 706                      !dev->irq_enabled));
 707
 708         if (ret != -EINTR) {
 709                 struct timeval now;
 710
 711                 do_gettimeofday(&now);
 712
 713                 vblwait->reply.tval_sec = now.tv_sec;
 714                 vblwait->reply.tval_usec = now.tv_usec;
 715                 vblwait->reply.sequence = drm_vblank_count(dev, crtc);
 716                 DRM_DEBUG("returning %d to client\n",
 717                           vblwait->reply.sequence);
 718         } else {
 719                 DRM_DEBUG("vblank wait interrupted by signal\n");
 720         }
 721
 722 done:
 723         drm_vblank_put(dev, crtc);
 724         return ret;
 725 }
 726
 727 void drm_handle_vblank_events(struct drm_device *dev, int crtc)
 728 {
 729         struct drm_pending_vblank_event *e, *t;
 730         struct timeval now;
 731         unsigned long flags;
 732         unsigned int seq;
 733
 734         do_gettimeofday(&now);
 735         seq = drm_vblank_count(dev, crtc);
 736
 737         spin_lock_irqsave(&dev->event_lock, flags);
 738
 739         list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
 740                 if (e->pipe != crtc)
 741                         continue;
 742                 if ((seq - e->event.sequence) > (1<<23))
 743                         continue;
 744
 745                 DRM_DEBUG("vblank event on %d, current %d\n",
 746                           e->event.sequence, seq);
 747
 748                 e->event.sequence = seq;
 749                 e->event.tv_sec = now.tv_sec;
 750                 e->event.tv_usec = now.tv_usec;
 751                 drm_vblank_put(dev, e->pipe);
 752                 list_move_tail(&e->base.link, &e->base.file_priv->event_list);
 753                 wake_up_interruptible(&e->base.file_priv->event_wait);
 754         }
 755
 756         spin_unlock_irqrestore(&dev->event_lock, flags);
 757 }
 758
 759 /**
 760  * drm_handle_vblank - handle a vblank event
 761  * @dev: DRM device
 762  * @crtc: where this event occurred
 763  *
 764  * Drivers should call this routine in their vblank interrupt handlers to
 765  * update the vblank counter and send any signals that may be pending.
 766  */
 767 void drm_handle_vblank(struct drm_device *dev, int crtc)
 768 {
 769         if (!dev->num_crtcs)
 770                 return;
 771
 772         atomic_inc(&dev->_vblank_count[crtc]);
 773         DRM_WAKEUP(&dev->vbl_queue[crtc]);
 774         drm_handle_vblank_events(dev, crtc);
 775 }
 776 EXPORT_SYMBOL(drm_handle_vblank);