a263b7070fc6f81b227d77a3befbd11b6efc8be0
[linux-2.6.git] / 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);