blob: f9cc68fbd2a3e18b076ad2ced71b8f1ddf002202 [file] [log] [blame]
Daniel Vetterf5752b32014-05-08 16:41:51 +02001/*
2 * drm_irq.c IRQ and vblank support
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * \author Rickard E. (Rik) Faith <faith@valinux.com>
5 * \author Gareth Hughes <gareth@valinux.com>
6 */
7
8/*
9 * Created: Fri Mar 19 14:30:16 1999 by faith@valinux.com
10 *
11 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
12 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
13 * All Rights Reserved.
14 *
15 * Permission is hereby granted, free of charge, to any person obtaining a
16 * copy of this software and associated documentation files (the "Software"),
17 * to deal in the Software without restriction, including without limitation
18 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
19 * and/or sell copies of the Software, and to permit persons to whom the
20 * Software is furnished to do so, subject to the following conditions:
21 *
22 * The above copyright notice and this permission notice (including the next
23 * paragraph) shall be included in all copies or substantial portions of the
24 * Software.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
29 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
30 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
31 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
32 * OTHER DEALINGS IN THE SOFTWARE.
33 */
34
David Howells760285e2012-10-02 18:01:07 +010035#include <drm/drmP.h>
Jesse Barnesac2874b2010-07-01 16:47:31 -070036#include "drm_trace.h"
Daniel Vetter18882992014-09-10 08:16:10 +020037#include "drm_internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#include <linux/interrupt.h> /* For task queue support */
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090040#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Dave Airlie28d52042009-09-21 14:33:58 +100042#include <linux/vgaarb.h>
Paul Gortmaker2d1a8a42011-08-30 18:16:33 -040043#include <linux/export.h>
Mario Kleiner27641c32010-10-23 04:20:23 +020044
45/* Access macro for slots in vblank timestamp ringbuffer. */
Ville Syrjälä5380e922013-10-04 14:53:36 +030046#define vblanktimestamp(dev, crtc, count) \
47 ((dev)->vblank[crtc].time[(count) % DRM_VBLANKTIME_RBSIZE])
Mario Kleiner27641c32010-10-23 04:20:23 +020048
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
Daniel Vetterfb446a12014-09-10 17:36:10 +020059static bool
60drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
61 struct timeval *tvblank, unsigned flags);
62
Daniel Vetter18882992014-09-10 08:16:10 +020063static unsigned int drm_timestamp_precision = 20; /* Default to 20 usecs. */
64
65/*
66 * Default to use monotonic timestamps for wait-for-vblank and page-flip
67 * complete events.
68 */
69unsigned int drm_timestamp_monotonic = 1;
70
71static int drm_vblank_offdelay = 5000; /* Default to 5000 msecs. */
72
73module_param_named(vblankoffdelay, drm_vblank_offdelay, int, 0600);
74module_param_named(timestamp_precision_usec, drm_timestamp_precision, int, 0600);
75module_param_named(timestamp_monotonic, drm_timestamp_monotonic, int, 0600);
76
Daniel Vetter99264a62015-04-15 19:34:43 +020077static void store_vblank(struct drm_device *dev, int crtc,
78 unsigned vblank_count_inc,
79 struct timeval *t_vblank)
80{
81 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
82 u32 tslot;
83
84 assert_spin_locked(&dev->vblank_time_lock);
85
86 if (t_vblank) {
87 /* All writers hold the spinlock, but readers are serialized by
88 * the latching of vblank->count below.
89 */
90 tslot = vblank->count + vblank_count_inc;
91 vblanktimestamp(dev, crtc, tslot) = *t_vblank;
92 }
93
94 /*
95 * vblank timestamp updates are protected on the write side with
96 * vblank_time_lock, but on the read side done locklessly using a
97 * sequence-lock on the vblank counter. Ensure correct ordering using
98 * memory barrriers. We need the barrier both before and also after the
99 * counter update to synchronize with the next timestamp write.
100 * The read-side barriers for this are in drm_vblank_count_and_time.
101 */
102 smp_wmb();
103 vblank->count += vblank_count_inc;
104 smp_wmb();
105}
106
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300107/**
108 * drm_update_vblank_count - update the master vblank counter
109 * @dev: DRM device
110 * @crtc: counter to update
111 *
112 * Call back into the driver to update the appropriate vblank counter
113 * (specified by @crtc). Deal with wraparound, if it occurred, and
114 * update the last read value so we can deal with wraparound on the next
115 * call if necessary.
116 *
117 * Only necessary when going from off->on, to account for frames we
118 * didn't get an interrupt for.
119 *
120 * Note: caller must hold dev->vbl_lock since this reads & writes
121 * device vblank fields.
122 */
123static void drm_update_vblank_count(struct drm_device *dev, int crtc)
124{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300125 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Daniel Vetter99264a62015-04-15 19:34:43 +0200126 u32 cur_vblank, diff;
Daniel Vetterfb446a12014-09-10 17:36:10 +0200127 bool rc;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300128 struct timeval t_vblank;
129
130 /*
131 * Interrupts were disabled prior to this call, so deal with counter
132 * wrap if needed.
Michel Dänzer5ceecb22015-05-26 17:53:38 +0900133 * NOTE! It's possible we lost a full dev->max_vblank_count + 1 events
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300134 * here if the register is small or we had vblank interrupts off for
135 * a long time.
136 *
137 * We repeat the hardware vblank counter & timestamp query until
138 * we get consistent results. This to prevent races between gpu
139 * updating its hardware counter while we are retrieving the
140 * corresponding vblank timestamp.
141 */
142 do {
143 cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
144 rc = drm_get_last_vbltimestamp(dev, crtc, &t_vblank, 0);
145 } while (cur_vblank != dev->driver->get_vblank_counter(dev, crtc));
146
147 /* Deal with counter wrap */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300148 diff = cur_vblank - vblank->last;
149 if (cur_vblank < vblank->last) {
Michel Dänzer5ceecb22015-05-26 17:53:38 +0900150 diff += dev->max_vblank_count + 1;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300151
152 DRM_DEBUG("last_vblank[%d]=0x%x, cur_vblank=0x%x => diff=0x%x\n",
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300153 crtc, vblank->last, cur_vblank, diff);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300154 }
155
Ville Syrjälä96a9fdd2014-08-06 14:50:02 +0300156 DRM_DEBUG("updating vblank count on crtc %d, missed %d\n",
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300157 crtc, diff);
158
Mario Kleinerda8f4392014-09-13 18:25:54 +0200159 if (diff == 0)
160 return;
161
Daniel Vetter99264a62015-04-15 19:34:43 +0200162 /*
163 * Only reinitialize corresponding vblank timestamp if high-precision query
Mario Kleinerd66a1e32015-05-04 06:29:46 +0200164 * available and didn't fail. Otherwise reinitialize delayed at next vblank
165 * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300166 */
Mario Kleinerd66a1e32015-05-04 06:29:46 +0200167 if (!rc)
168 t_vblank = (struct timeval) {0, 0};
169
170 store_vblank(dev, crtc, diff, &t_vblank);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300171}
172
Mario Kleiner27641c32010-10-23 04:20:23 +0200173/*
Mario Kleiner27641c32010-10-23 04:20:23 +0200174 * Disable vblank irq's on crtc, make sure that last vblank count
175 * of hardware and corresponding consistent software vblank counter
176 * are preserved, even if there are any spurious vblank irq's after
177 * disable.
178 */
179static void vblank_disable_and_save(struct drm_device *dev, int crtc)
180{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300181 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Mario Kleiner27641c32010-10-23 04:20:23 +0200182 unsigned long irqflags;
183 u32 vblcount;
184 s64 diff_ns;
Daniel Vetterfb446a12014-09-10 17:36:10 +0200185 bool vblrc;
Mario Kleiner27641c32010-10-23 04:20:23 +0200186 struct timeval tvblank;
Egbert Eich0355cf32012-10-13 11:36:14 +0000187 int count = DRM_TIMESTAMP_MAXRETRIES;
Mario Kleiner27641c32010-10-23 04:20:23 +0200188
189 /* Prevent vblank irq processing while disabling vblank irqs,
190 * so no updates of timestamps or count can happen after we've
191 * disabled. Needed to prevent races in case of delayed irq's.
Mario Kleiner27641c32010-10-23 04:20:23 +0200192 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200193 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
194
Ville Syrjälä812e7462014-08-06 14:49:48 +0300195 /*
Martin Peres393e8722014-12-09 08:13:09 +0100196 * If the vblank interrupt was already disabled update the count
Ville Syrjälä812e7462014-08-06 14:49:48 +0300197 * and timestamp to maintain the appearance that the counter
198 * has been ticking all along until this time. This makes the
199 * count account for the entire time between drm_vblank_on() and
200 * drm_vblank_off().
Daniel Vetter855d30b2014-09-10 17:36:09 +0200201 *
202 * But only do this if precise vblank timestamps are available.
203 * Otherwise we might read a totally bogus timestamp since drivers
204 * lacking precise timestamp support rely upon sampling the system clock
205 * at vblank interrupt time. Which obviously won't work out well if the
206 * vblank interrupt is disabled.
Ville Syrjälä812e7462014-08-06 14:49:48 +0300207 */
Daniel Vetter855d30b2014-09-10 17:36:09 +0200208 if (!vblank->enabled &&
Daniel Vetterfb446a12014-09-10 17:36:10 +0200209 drm_get_last_vbltimestamp(dev, crtc, &tvblank, 0)) {
Ville Syrjälä812e7462014-08-06 14:49:48 +0300210 drm_update_vblank_count(dev, crtc);
211 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
212 return;
213 }
214
Laurent Pincharteb2ed662015-01-29 01:09:24 +0200215 /*
216 * Only disable vblank interrupts if they're enabled. This avoids
217 * calling the ->disable_vblank() operation in atomic context with the
218 * hardware potentially runtime suspended.
219 */
220 if (vblank->enabled) {
221 dev->driver->disable_vblank(dev, crtc);
222 vblank->enabled = false;
223 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200224
225 /* No further vblank irq's will be processed after
226 * this point. Get current hardware vblank count and
227 * vblank timestamp, repeat until they are consistent.
228 *
229 * FIXME: There is still a race condition here and in
230 * drm_update_vblank_count() which can cause off-by-one
231 * reinitialization of software vblank counter. If gpu
232 * vblank counter doesn't increment exactly at the leading
233 * edge of a vblank interval, then we can lose 1 count if
234 * we happen to execute between start of vblank and the
235 * delayed gpu counter increment.
236 */
237 do {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300238 vblank->last = dev->driver->get_vblank_counter(dev, crtc);
Mario Kleiner27641c32010-10-23 04:20:23 +0200239 vblrc = drm_get_last_vbltimestamp(dev, crtc, &tvblank, 0);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300240 } while (vblank->last != dev->driver->get_vblank_counter(dev, crtc) && (--count) && vblrc);
Egbert Eich0355cf32012-10-13 11:36:14 +0000241
242 if (!count)
243 vblrc = 0;
Mario Kleiner27641c32010-10-23 04:20:23 +0200244
245 /* Compute time difference to stored timestamp of last vblank
246 * as updated by last invocation of drm_handle_vblank() in vblank irq.
247 */
Daniel Vetter99264a62015-04-15 19:34:43 +0200248 vblcount = vblank->count;
Mario Kleiner27641c32010-10-23 04:20:23 +0200249 diff_ns = timeval_to_ns(&tvblank) -
250 timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount));
251
252 /* If there is at least 1 msec difference between the last stored
253 * timestamp and tvblank, then we are currently executing our
254 * disable inside a new vblank interval, the tvblank timestamp
255 * corresponds to this new vblank interval and the irq handler
256 * for this vblank didn't run yet and won't run due to our disable.
257 * Therefore we need to do the job of drm_handle_vblank() and
258 * increment the vblank counter by one to account for this vblank.
259 *
260 * Skip this step if there isn't any high precision timestamp
261 * available. In that case we can't account for this and just
262 * hope for the best.
263 */
Daniel Vetter99264a62015-04-15 19:34:43 +0200264 if (vblrc && (abs64(diff_ns) > 1000000))
265 store_vblank(dev, crtc, 1, &tvblank);
Mario Kleiner27641c32010-10-23 04:20:23 +0200266
Mario Kleiner27641c32010-10-23 04:20:23 +0200267 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
Mario Kleiner27641c32010-10-23 04:20:23 +0200268}
269
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700270static void vblank_disable_fn(unsigned long arg)
271{
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200272 struct drm_vblank_crtc *vblank = (void *)arg;
273 struct drm_device *dev = vblank->dev;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700274 unsigned long irqflags;
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200275 int crtc = vblank->crtc;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700276
277 if (!dev->vblank_disable_allowed)
278 return;
279
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200280 spin_lock_irqsave(&dev->vbl_lock, irqflags);
281 if (atomic_read(&vblank->refcount) == 0 && vblank->enabled) {
282 DRM_DEBUG("disabling vblank on crtc %d\n", crtc);
283 vblank_disable_and_save(dev, crtc);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700284 }
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200285 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700286}
287
Daniel Vetterf5752b32014-05-08 16:41:51 +0200288/**
289 * drm_vblank_cleanup - cleanup vblank support
290 * @dev: DRM device
291 *
292 * This function cleans up any resources allocated in drm_vblank_init.
293 */
Keith Packard52440212008-11-18 09:30:25 -0800294void drm_vblank_cleanup(struct drm_device *dev)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700295{
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200296 int crtc;
297
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700298 /* Bail if the driver didn't call drm_vblank_init() */
299 if (dev->num_crtcs == 0)
300 return;
301
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200302 for (crtc = 0; crtc < dev->num_crtcs; crtc++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300303 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
304
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100305 WARN_ON(vblank->enabled &&
306 drm_core_check_feature(dev, DRIVER_MODESET));
Mario Kleiner2368ffb2014-08-06 03:22:46 +0200307
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100308 del_timer_sync(&vblank->disable_timer);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200309 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700310
Ville Syrjälä5380e922013-10-04 14:53:36 +0300311 kfree(dev->vblank);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700312
313 dev->num_crtcs = 0;
314}
Jerome Glissee77cef92010-01-07 15:39:13 +0100315EXPORT_SYMBOL(drm_vblank_cleanup);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700316
Daniel Vetterf5752b32014-05-08 16:41:51 +0200317/**
318 * drm_vblank_init - initialize vblank support
319 * @dev: drm_device
320 * @num_crtcs: number of crtcs supported by @dev
321 *
322 * This function initializes vblank support for @num_crtcs display pipelines.
323 *
324 * Returns:
325 * Zero on success or a negative error code on failure.
326 */
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700327int drm_vblank_init(struct drm_device *dev, int num_crtcs)
328{
329 int i, ret = -ENOMEM;
330
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700331 spin_lock_init(&dev->vbl_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +0200332 spin_lock_init(&dev->vblank_time_lock);
333
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700334 dev->num_crtcs = num_crtcs;
335
Ville Syrjälä5380e922013-10-04 14:53:36 +0300336 dev->vblank = kcalloc(num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
337 if (!dev->vblank)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700338 goto err;
339
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200340 for (i = 0; i < num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300341 struct drm_vblank_crtc *vblank = &dev->vblank[i];
342
343 vblank->dev = dev;
344 vblank->crtc = i;
345 init_waitqueue_head(&vblank->queue);
346 setup_timer(&vblank->disable_timer, vblank_disable_fn,
347 (unsigned long)vblank);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200348 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200349
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100350 DRM_INFO("Supports vblank timestamp caching Rev 2 (21.10.2013).\n");
Mario Kleiner27641c32010-10-23 04:20:23 +0200351
352 /* Driver specific high-precision vblank timestamping supported? */
353 if (dev->driver->get_vblank_timestamp)
354 DRM_INFO("Driver supports precise vblank timestamp query.\n");
355 else
356 DRM_INFO("No driver support for vblank timestamp query.\n");
357
Mario Kleiner5a8b21b2015-05-04 06:29:45 +0200358 /* Must have precise timestamping for reliable vblank instant disable */
359 if (dev->vblank_disable_immediate && !dev->driver->get_vblank_timestamp) {
360 dev->vblank_disable_immediate = false;
361 DRM_INFO("Setting vblank_disable_immediate to false because "
362 "get_vblank_timestamp == NULL\n");
363 }
364
Ville Syrjäläba0bf122013-10-04 14:53:33 +0300365 dev->vblank_disable_allowed = false;
366
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700367 return 0;
368
369err:
Mario Kleiner79a093ae2014-08-06 03:22:44 +0200370 dev->num_crtcs = 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700371 return ret;
372}
373EXPORT_SYMBOL(drm_vblank_init);
374
Dave Airlie28d52042009-09-21 14:33:58 +1000375static void drm_irq_vgaarb_nokms(void *cookie, bool state)
376{
377 struct drm_device *dev = cookie;
378
379 if (dev->driver->vgaarb_irq) {
380 dev->driver->vgaarb_irq(dev, state);
381 return;
382 }
383
384 if (!dev->irq_enabled)
385 return;
386
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000387 if (state) {
388 if (dev->driver->irq_uninstall)
389 dev->driver->irq_uninstall(dev);
390 } else {
391 if (dev->driver->irq_preinstall)
392 dev->driver->irq_preinstall(dev);
393 if (dev->driver->irq_postinstall)
394 dev->driver->irq_postinstall(dev);
Dave Airlie28d52042009-09-21 14:33:58 +1000395 }
396}
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200399 * drm_irq_install - install IRQ handler
400 * @dev: DRM device
401 * @irq: IRQ number to install the handler for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 *
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700403 * Initializes the IRQ related data. Installs the handler, calling the driver
Daniel Vetterf5752b32014-05-08 16:41:51 +0200404 * irq_preinstall() and irq_postinstall() functions before and after the
405 * installation.
406 *
407 * This is the simplified helper interface provided for drivers with no special
408 * needs. Drivers which need to install interrupt handlers for multiple
409 * interrupts must instead set drm_device->irq_enabled to signal the DRM core
410 * that vblank interrupts are available.
411 *
412 * Returns:
413 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 */
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100415int drm_irq_install(struct drm_device *dev, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200417 int ret;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000418 unsigned long sh_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
421 return -EINVAL;
422
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100423 if (irq == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return -EINVAL;
425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 /* Driver must have been initialized */
Daniel Vettere090c532013-11-03 20:27:05 +0100427 if (!dev->dev_private)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Daniel Vettere090c532013-11-03 20:27:05 +0100430 if (dev->irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return -EBUSY;
Ville Syrjälä44238432013-10-04 14:53:37 +0300432 dev->irq_enabled = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100434 DRM_DEBUG("irq=%d\n", irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000436 /* Before installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000437 if (dev->driver->irq_preinstall)
438 dev->driver->irq_preinstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000440 /* Install handler */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
Thomas Gleixner935f6e32006-07-01 19:29:34 -0700442 sh_flags = IRQF_SHARED;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000443
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100444 ret = request_irq(irq, dev->driver->irq_handler,
Daniel Vetter5829d182013-11-03 21:48:48 +0100445 sh_flags, dev->driver->name, dev);
Jesse Barnes9bfbd5c2008-09-15 15:00:33 -0700446
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000447 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300448 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 return ret;
450 }
451
Dave Airlie28d52042009-09-21 14:33:58 +1000452 if (!drm_core_check_feature(dev, DRIVER_MODESET))
453 vga_client_register(dev->pdev, (void *)dev, drm_irq_vgaarb_nokms, NULL);
454
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000455 /* After installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000456 if (dev->driver->irq_postinstall)
457 ret = dev->driver->irq_postinstall(dev);
458
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700459 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300460 dev->irq_enabled = false;
Joonyoung Shime1c44ac2011-08-04 05:41:00 +0000461 if (!drm_core_check_feature(dev, DRIVER_MODESET))
462 vga_client_register(dev->pdev, NULL, NULL, NULL);
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100463 free_irq(irq, dev);
464 } else {
465 dev->irq = irq;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700466 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700468 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700470EXPORT_SYMBOL(drm_irq_install);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200473 * drm_irq_uninstall - uninstall the IRQ handler
474 * @dev: DRM device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200476 * Calls the driver's irq_uninstall() function and unregisters the IRQ handler.
477 * This should only be called by drivers which used drm_irq_install() to set up
478 * their interrupt handler. Other drivers must only reset
479 * drm_device->irq_enabled to false.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200481 * Note that for kernel modesetting drivers it is a bug if this function fails.
482 * The sanity checks are only to catch buggy user modesetting drivers which call
483 * the same function through an ioctl.
484 *
485 * Returns:
486 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200488int drm_irq_uninstall(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800490 unsigned long irqflags;
Ville Syrjälä44238432013-10-04 14:53:37 +0300491 bool irq_enabled;
492 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
495 return -EINVAL;
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 irq_enabled = dev->irq_enabled;
Ville Syrjälä44238432013-10-04 14:53:37 +0300498 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800500 /*
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100501 * Wake up any waiters so they don't hang. This is just to paper over
502 * isssues for UMS drivers which aren't in full control of their
503 * vblank/irq handling. KMS drivers must ensure that vblanks are all
504 * disabled when uninstalling the irq handler.
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800505 */
Ben Skeggsbde48892011-07-04 12:52:27 +1000506 if (dev->num_crtcs) {
507 spin_lock_irqsave(&dev->vbl_lock, irqflags);
508 for (i = 0; i < dev->num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300509 struct drm_vblank_crtc *vblank = &dev->vblank[i];
510
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100511 if (!vblank->enabled)
512 continue;
513
514 WARN_ON(drm_core_check_feature(dev, DRIVER_MODESET));
515
516 vblank_disable_and_save(dev, i);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300517 wake_up(&vblank->queue);
Ben Skeggsbde48892011-07-04 12:52:27 +1000518 }
519 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800520 }
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800521
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000522 if (!irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 return -EINVAL;
524
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100525 DRM_DEBUG("irq=%d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
Dave Airlie28d52042009-09-21 14:33:58 +1000527 if (!drm_core_check_feature(dev, DRIVER_MODESET))
528 vga_client_register(dev->pdev, NULL, NULL, NULL);
529
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000530 if (dev->driver->irq_uninstall)
531 dev->driver->irq_uninstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100533 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 return 0;
536}
537EXPORT_SYMBOL(drm_irq_uninstall);
538
Daniel Vetterf5752b32014-05-08 16:41:51 +0200539/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 * IRQ control ioctl.
541 *
542 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +1000543 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 * \param cmd command.
545 * \param arg user argument, pointing to a drm_control structure.
546 * \return zero on success or a negative number on failure.
547 *
548 * Calls irq_install() or irq_uninstall() according to \p arg.
549 */
Eric Anholtc153f452007-09-03 12:06:45 +1000550int drm_control(struct drm_device *dev, void *data,
551 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552{
Eric Anholtc153f452007-09-03 12:06:45 +1000553 struct drm_control *ctl = data;
Daniel Vettera319c1a2013-11-03 21:09:15 +0100554 int ret = 0, irq;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000555
Mario Kleiner27641c32010-10-23 04:20:23 +0200556 /* if we haven't irq we fallback for compatibility reasons -
557 * this used to be a separate function in drm_dma.h
558 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Daniel Vetter22471cf2013-11-03 20:02:50 +0100560 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
561 return 0;
562 if (drm_core_check_feature(dev, DRIVER_MODESET))
563 return 0;
564 /* UMS was only ever support on pci devices. */
565 if (WARN_ON(!dev->pdev))
566 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Eric Anholtc153f452007-09-03 12:06:45 +1000568 switch (ctl->func) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 case DRM_INST_HANDLER:
Daniel Vettera319c1a2013-11-03 21:09:15 +0100570 irq = dev->pdev->irq;
571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
Daniel Vettera319c1a2013-11-03 21:09:15 +0100573 ctl->irq != irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 return -EINVAL;
Daniel Vettere090c532013-11-03 20:27:05 +0100575 mutex_lock(&dev->struct_mutex);
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100576 ret = drm_irq_install(dev, irq);
Daniel Vettere090c532013-11-03 20:27:05 +0100577 mutex_unlock(&dev->struct_mutex);
578
579 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 case DRM_UNINST_HANDLER:
Daniel Vettere090c532013-11-03 20:27:05 +0100581 mutex_lock(&dev->struct_mutex);
582 ret = drm_irq_uninstall(dev);
583 mutex_unlock(&dev->struct_mutex);
584
585 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 default:
587 return -EINVAL;
588 }
589}
590
591/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200592 * drm_calc_timestamping_constants - calculate vblank timestamp constants
593 * @crtc: drm_crtc whose timestamp constants should be updated.
594 * @mode: display mode containing the scanout timings
Mario Kleiner27641c32010-10-23 04:20:23 +0200595 *
Ville Syrjälä21b21562013-10-26 17:22:52 +0300596 * Calculate and store various constants which are later
597 * needed by vblank and swap-completion timestamping, e.g,
598 * by drm_calc_vbltimestamp_from_scanoutpos(). They are
Daniel Vetterf5752b32014-05-08 16:41:51 +0200599 * derived from CRTC's true scanout timing, so they take
Ville Syrjälä21b21562013-10-26 17:22:52 +0300600 * things like panel scaling or other adjustments into account.
Mario Kleiner27641c32010-10-23 04:20:23 +0200601 */
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300602void drm_calc_timestamping_constants(struct drm_crtc *crtc,
603 const struct drm_display_mode *mode)
Mario Kleiner27641c32010-10-23 04:20:23 +0200604{
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300605 int linedur_ns = 0, pixeldur_ns = 0, framedur_ns = 0;
Ville Syrjälä77666b72013-10-27 21:22:58 +0200606 int dotclock = mode->crtc_clock;
Mario Kleiner27641c32010-10-23 04:20:23 +0200607
608 /* Valid dotclock? */
609 if (dotclock > 0) {
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300610 int frame_size = mode->crtc_htotal * mode->crtc_vtotal;
611
612 /*
613 * Convert scanline length in pixels and video
614 * dot clock to line duration, frame duration
615 * and pixel duration in nanoseconds:
Mario Kleiner27641c32010-10-23 04:20:23 +0200616 */
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300617 pixeldur_ns = 1000000 / dotclock;
618 linedur_ns = div_u64((u64) mode->crtc_htotal * 1000000, dotclock);
619 framedur_ns = div_u64((u64) frame_size * 1000000, dotclock);
Ville Syrjäläc0ae24c2013-10-28 19:53:25 +0200620
621 /*
622 * Fields of interlaced scanout modes are only half a frame duration.
623 */
624 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
625 framedur_ns /= 2;
Mario Kleiner27641c32010-10-23 04:20:23 +0200626 } else
627 DRM_ERROR("crtc %d: Can't calculate constants, dotclock = 0!\n",
628 crtc->base.id);
629
630 crtc->pixeldur_ns = pixeldur_ns;
631 crtc->linedur_ns = linedur_ns;
632 crtc->framedur_ns = framedur_ns;
633
634 DRM_DEBUG("crtc %d: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300635 crtc->base.id, mode->crtc_htotal,
636 mode->crtc_vtotal, mode->crtc_vdisplay);
Mario Kleiner27641c32010-10-23 04:20:23 +0200637 DRM_DEBUG("crtc %d: clock %d kHz framedur %d linedur %d, pixeldur %d\n",
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300638 crtc->base.id, dotclock, framedur_ns,
639 linedur_ns, pixeldur_ns);
Mario Kleiner27641c32010-10-23 04:20:23 +0200640}
641EXPORT_SYMBOL(drm_calc_timestamping_constants);
642
643/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200644 * drm_calc_vbltimestamp_from_scanoutpos - precise vblank timestamp helper
645 * @dev: DRM device
646 * @crtc: Which CRTC's vblank timestamp to retrieve
647 * @max_error: Desired maximum allowable error in timestamps (nanosecs)
648 * On return contains true maximum error of timestamp
649 * @vblank_time: Pointer to struct timeval which should receive the timestamp
650 * @flags: Flags to pass to driver:
651 * 0 = Default,
652 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
653 * @refcrtc: CRTC which defines scanout timing
654 * @mode: mode which defines the scanout timings
655 *
656 * Implements calculation of exact vblank timestamps from given drm_display_mode
657 * timings and current video scanout position of a CRTC. This can be called from
658 * within get_vblank_timestamp() implementation of a kms driver to implement the
659 * actual timestamping.
Mario Kleiner27641c32010-10-23 04:20:23 +0200660 *
661 * Should return timestamps conforming to the OML_sync_control OpenML
662 * extension specification. The timestamp corresponds to the end of
663 * the vblank interval, aka start of scanout of topmost-leftmost display
664 * pixel in the following video frame.
665 *
666 * Requires support for optional dev->driver->get_scanout_position()
667 * in kms driver, plus a bit of setup code to provide a drm_display_mode
668 * that corresponds to the true scanout timing.
669 *
670 * The current implementation only handles standard video modes. It
671 * returns as no operation if a doublescan or interlaced video mode is
672 * active. Higher level code is expected to handle this.
673 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200674 * Returns:
675 * Negative value on error, failure or if not supported in current
Mario Kleiner27641c32010-10-23 04:20:23 +0200676 * video mode:
677 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200678 * -EINVAL - Invalid CRTC.
Mario Kleiner27641c32010-10-23 04:20:23 +0200679 * -EAGAIN - Temporary unavailable, e.g., called before initial modeset.
680 * -ENOTSUPP - Function not supported in current display mode.
681 * -EIO - Failed, e.g., due to failed scanout position query.
682 *
683 * Returns or'ed positive status flags on success:
684 *
685 * DRM_VBLANKTIME_SCANOUTPOS_METHOD - Signal this method used for timestamping.
686 * DRM_VBLANKTIME_INVBL - Timestamp taken while scanout was in vblank interval.
687 *
688 */
689int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, int crtc,
690 int *max_error,
691 struct timeval *vblank_time,
692 unsigned flags,
Ville Syrjälä7da903e2013-10-26 17:57:31 +0300693 const struct drm_crtc *refcrtc,
694 const struct drm_display_mode *mode)
Mario Kleiner27641c32010-10-23 04:20:23 +0200695{
Imre Deake62f2f52012-10-23 18:53:25 +0000696 struct timeval tv_etime;
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000697 ktime_t stime, etime;
Ville Syrjälä8072bfa2013-10-28 21:22:52 +0200698 int vbl_status;
Mario Kleiner27641c32010-10-23 04:20:23 +0200699 int vpos, hpos, i;
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300700 int framedur_ns, linedur_ns, pixeldur_ns, delta_ns, duration_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200701 bool invbl;
702
703 if (crtc < 0 || crtc >= dev->num_crtcs) {
704 DRM_ERROR("Invalid crtc %d\n", crtc);
705 return -EINVAL;
706 }
707
708 /* Scanout position query not supported? Should not happen. */
709 if (!dev->driver->get_scanout_position) {
710 DRM_ERROR("Called from driver w/o get_scanout_position()!?\n");
711 return -EIO;
712 }
713
Mario Kleiner27641c32010-10-23 04:20:23 +0200714 /* Durations of frames, lines, pixels in nanoseconds. */
715 framedur_ns = refcrtc->framedur_ns;
716 linedur_ns = refcrtc->linedur_ns;
717 pixeldur_ns = refcrtc->pixeldur_ns;
718
719 /* If mode timing undefined, just return as no-op:
720 * Happens during initial modesetting of a crtc.
721 */
Ville Syrjälä8072bfa2013-10-28 21:22:52 +0200722 if (framedur_ns == 0) {
Mario Kleiner27641c32010-10-23 04:20:23 +0200723 DRM_DEBUG("crtc %d: Noop due to uninitialized mode.\n", crtc);
724 return -EAGAIN;
725 }
726
Mario Kleiner27641c32010-10-23 04:20:23 +0200727 /* Get current scanout position with system timestamp.
728 * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times
729 * if single query takes longer than max_error nanoseconds.
730 *
731 * This guarantees a tight bound on maximum error if
732 * code gets preempted or delayed for some reason.
733 */
734 for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) {
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100735 /*
736 * Get vertical and horizontal scanout position vpos, hpos,
737 * and bounding timestamps stime, etime, pre/post query.
738 */
Ville Syrjäläabca9e42013-10-28 20:50:48 +0200739 vbl_status = dev->driver->get_scanout_position(dev, crtc, flags, &vpos,
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100740 &hpos, &stime, &etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200741
Mario Kleiner27641c32010-10-23 04:20:23 +0200742 /* Return as no-op if scanout query unsupported or failed. */
743 if (!(vbl_status & DRM_SCANOUTPOS_VALID)) {
744 DRM_DEBUG("crtc %d : scanoutpos query failed [%d].\n",
745 crtc, vbl_status);
746 return -EIO;
747 }
748
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100749 /* Compute uncertainty in timestamp of scanout position query. */
Imre Deake62f2f52012-10-23 18:53:25 +0000750 duration_ns = ktime_to_ns(etime) - ktime_to_ns(stime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200751
752 /* Accept result with < max_error nsecs timing uncertainty. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300753 if (duration_ns <= *max_error)
Mario Kleiner27641c32010-10-23 04:20:23 +0200754 break;
755 }
756
757 /* Noisy system timing? */
758 if (i == DRM_TIMESTAMP_MAXRETRIES) {
759 DRM_DEBUG("crtc %d: Noisy timestamp %d us > %d us [%d reps].\n",
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300760 crtc, duration_ns/1000, *max_error/1000, i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200761 }
762
763 /* Return upper bound of timestamp precision error. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300764 *max_error = duration_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200765
766 /* Check if in vblank area:
767 * vpos is >=0 in video scanout area, but negative
768 * within vblank area, counting down the number of lines until
769 * start of scanout.
770 */
Daniel Vetter3d3cbd82014-09-10 17:36:11 +0200771 invbl = vbl_status & DRM_SCANOUTPOS_IN_VBLANK;
Mario Kleiner27641c32010-10-23 04:20:23 +0200772
773 /* Convert scanout position into elapsed time at raw_time query
774 * since start of scanout at first display scanline. delta_ns
775 * can be negative if start of scanout hasn't happened yet.
776 */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300777 delta_ns = vpos * linedur_ns + hpos * pixeldur_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200778
Imre Deakc61eef72012-10-23 18:53:26 +0000779 if (!drm_timestamp_monotonic)
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000780 etime = ktime_mono_to_real(etime);
Imre Deakc61eef72012-10-23 18:53:26 +0000781
Imre Deake62f2f52012-10-23 18:53:25 +0000782 /* save this only for debugging purposes */
783 tv_etime = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200784 /* Subtract time delta from raw timestamp to get final
785 * vblank_time timestamp for end of vblank.
786 */
Michel Dänzere91abf82013-06-12 11:58:44 +0200787 if (delta_ns < 0)
788 etime = ktime_add_ns(etime, -delta_ns);
789 else
790 etime = ktime_sub_ns(etime, delta_ns);
Imre Deake62f2f52012-10-23 18:53:25 +0000791 *vblank_time = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200792
Joe Perchesbbb0aef52011-04-17 20:35:52 -0700793 DRM_DEBUG("crtc %d : v %d p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n",
794 crtc, (int)vbl_status, hpos, vpos,
Imre Deake62f2f52012-10-23 18:53:25 +0000795 (long)tv_etime.tv_sec, (long)tv_etime.tv_usec,
Joe Perchesbbb0aef52011-04-17 20:35:52 -0700796 (long)vblank_time->tv_sec, (long)vblank_time->tv_usec,
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300797 duration_ns/1000, i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200798
799 vbl_status = DRM_VBLANKTIME_SCANOUTPOS_METHOD;
800 if (invbl)
Daniel Vetter3d3cbd82014-09-10 17:36:11 +0200801 vbl_status |= DRM_VBLANKTIME_IN_VBLANK;
Mario Kleiner27641c32010-10-23 04:20:23 +0200802
803 return vbl_status;
804}
805EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
806
Imre Deakc61eef72012-10-23 18:53:26 +0000807static struct timeval get_drm_timestamp(void)
808{
809 ktime_t now;
810
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000811 now = drm_timestamp_monotonic ? ktime_get() : ktime_get_real();
Imre Deakc61eef72012-10-23 18:53:26 +0000812 return ktime_to_timeval(now);
813}
814
Mario Kleiner27641c32010-10-23 04:20:23 +0200815/**
816 * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent
Thierry Reding4dfd9092014-12-10 13:03:34 +0100817 * vblank interval
Mario Kleiner27641c32010-10-23 04:20:23 +0200818 * @dev: DRM device
Daniel Vetterf5752b32014-05-08 16:41:51 +0200819 * @crtc: which CRTC's vblank timestamp to retrieve
Mario Kleiner27641c32010-10-23 04:20:23 +0200820 * @tvblank: Pointer to target struct timeval which should receive the timestamp
821 * @flags: Flags to pass to driver:
Daniel Vetterf5752b32014-05-08 16:41:51 +0200822 * 0 = Default,
823 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
Mario Kleiner27641c32010-10-23 04:20:23 +0200824 *
825 * Fetches the system timestamp corresponding to the time of the most recent
Daniel Vetterf5752b32014-05-08 16:41:51 +0200826 * vblank interval on specified CRTC. May call into kms-driver to
Mario Kleiner27641c32010-10-23 04:20:23 +0200827 * compute the timestamp with a high-precision GPU specific method.
828 *
829 * Returns zero if timestamp originates from uncorrected do_gettimeofday()
830 * call, i.e., it isn't very precisely locked to the true vblank.
831 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200832 * Returns:
Daniel Vetterfb446a12014-09-10 17:36:10 +0200833 * True if timestamp is considered to be very precise, false otherwise.
Mario Kleiner27641c32010-10-23 04:20:23 +0200834 */
Daniel Vetterfb446a12014-09-10 17:36:10 +0200835static bool
836drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
837 struct timeval *tvblank, unsigned flags)
Mario Kleiner27641c32010-10-23 04:20:23 +0200838{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200839 int ret;
Mario Kleiner27641c32010-10-23 04:20:23 +0200840
841 /* Define requested maximum error on timestamps (nanoseconds). */
842 int max_error = (int) drm_timestamp_precision * 1000;
843
844 /* Query driver if possible and precision timestamping enabled. */
845 if (dev->driver->get_vblank_timestamp && (max_error > 0)) {
846 ret = dev->driver->get_vblank_timestamp(dev, crtc, &max_error,
847 tvblank, flags);
848 if (ret > 0)
Daniel Vetterfb446a12014-09-10 17:36:10 +0200849 return true;
Mario Kleiner27641c32010-10-23 04:20:23 +0200850 }
851
852 /* GPU high precision timestamp query unsupported or failed.
Imre Deakc61eef72012-10-23 18:53:26 +0000853 * Return current monotonic/gettimeofday timestamp as best estimate.
Mario Kleiner27641c32010-10-23 04:20:23 +0200854 */
Imre Deakc61eef72012-10-23 18:53:26 +0000855 *tvblank = get_drm_timestamp();
Mario Kleiner27641c32010-10-23 04:20:23 +0200856
Daniel Vetterfb446a12014-09-10 17:36:10 +0200857 return false;
Mario Kleiner27641c32010-10-23 04:20:23 +0200858}
Mario Kleiner27641c32010-10-23 04:20:23 +0200859
860/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700861 * drm_vblank_count - retrieve "cooked" vblank counter value
862 * @dev: DRM device
863 * @crtc: which counter to retrieve
864 *
865 * Fetches the "cooked" vblank count value that represents the number of
866 * vblank events since the system was booted, including lost events due to
867 * modesetting activity.
Daniel Vetterf5752b32014-05-08 16:41:51 +0200868 *
Thierry Reding96d3f912014-12-16 13:08:47 +0100869 * This is the legacy version of drm_crtc_vblank_count().
870 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200871 * Returns:
872 * The software vblank counter.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700873 */
874u32 drm_vblank_count(struct drm_device *dev, int crtc)
875{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300876 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
877
Rob Clarke6ae8682014-08-06 13:16:59 -0400878 if (WARN_ON(crtc >= dev->num_crtcs))
879 return 0;
Daniel Vetter99264a62015-04-15 19:34:43 +0200880 return vblank->count;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700881}
882EXPORT_SYMBOL(drm_vblank_count);
883
884/**
Thierry Reding96d3f912014-12-16 13:08:47 +0100885 * drm_crtc_vblank_count - retrieve "cooked" vblank counter value
886 * @crtc: which counter to retrieve
887 *
888 * Fetches the "cooked" vblank count value that represents the number of
889 * vblank events since the system was booted, including lost events due to
890 * modesetting activity.
891 *
892 * This is the native KMS version of drm_vblank_count().
893 *
894 * Returns:
895 * The software vblank counter.
896 */
897u32 drm_crtc_vblank_count(struct drm_crtc *crtc)
898{
899 return drm_vblank_count(crtc->dev, drm_crtc_index(crtc));
900}
901EXPORT_SYMBOL(drm_crtc_vblank_count);
902
903/**
Mario Kleiner27641c32010-10-23 04:20:23 +0200904 * drm_vblank_count_and_time - retrieve "cooked" vblank counter value
905 * and the system timestamp corresponding to that vblank counter value.
906 *
907 * @dev: DRM device
908 * @crtc: which counter to retrieve
909 * @vblanktime: Pointer to struct timeval to receive the vblank timestamp.
910 *
911 * Fetches the "cooked" vblank count value that represents the number of
912 * vblank events since the system was booted, including lost events due to
913 * modesetting activity. Returns corresponding system timestamp of the time
Daniel Vetterf5752b32014-05-08 16:41:51 +0200914 * of the vblank interval that corresponds to the current vblank counter value.
Mario Kleiner27641c32010-10-23 04:20:23 +0200915 */
916u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
917 struct timeval *vblanktime)
918{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300919 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Mario Kleiner27641c32010-10-23 04:20:23 +0200920 u32 cur_vblank;
921
Rob Clarke6ae8682014-08-06 13:16:59 -0400922 if (WARN_ON(crtc >= dev->num_crtcs))
923 return 0;
924
Daniel Vetter99264a62015-04-15 19:34:43 +0200925 /*
926 * Vblank timestamps are read lockless. To ensure consistency the vblank
927 * counter is rechecked and ordering is ensured using memory barriers.
928 * This works like a seqlock. The write-side barriers are in store_vblank.
Mario Kleiner27641c32010-10-23 04:20:23 +0200929 */
930 do {
Daniel Vetter99264a62015-04-15 19:34:43 +0200931 cur_vblank = vblank->count;
932 smp_rmb();
Mario Kleiner27641c32010-10-23 04:20:23 +0200933 *vblanktime = vblanktimestamp(dev, crtc, cur_vblank);
934 smp_rmb();
Daniel Vetter99264a62015-04-15 19:34:43 +0200935 } while (cur_vblank != vblank->count);
Mario Kleiner27641c32010-10-23 04:20:23 +0200936
937 return cur_vblank;
938}
939EXPORT_SYMBOL(drm_vblank_count_and_time);
940
Rob Clarkc6eefa12012-10-16 22:48:40 +0000941static void send_vblank_event(struct drm_device *dev,
942 struct drm_pending_vblank_event *e,
943 unsigned long seq, struct timeval *now)
944{
945 WARN_ON_SMP(!spin_is_locked(&dev->event_lock));
946 e->event.sequence = seq;
947 e->event.tv_sec = now->tv_sec;
948 e->event.tv_usec = now->tv_usec;
949
950 list_add_tail(&e->base.link,
951 &e->base.file_priv->event_list);
952 wake_up_interruptible(&e->base.file_priv->event_wait);
953 trace_drm_vblank_event_delivered(e->base.pid, e->pipe,
954 e->event.sequence);
955}
956
957/**
958 * drm_send_vblank_event - helper to send vblank event after pageflip
959 * @dev: DRM device
960 * @crtc: CRTC in question
961 * @e: the event to send
962 *
963 * Updates sequence # and timestamp on event, and sends it to userspace.
964 * Caller must hold event lock.
Thierry Redinga4d7b302014-12-15 14:47:18 +0100965 *
966 * This is the legacy version of drm_crtc_send_vblank_event().
Rob Clarkc6eefa12012-10-16 22:48:40 +0000967 */
968void drm_send_vblank_event(struct drm_device *dev, int crtc,
969 struct drm_pending_vblank_event *e)
970{
971 struct timeval now;
972 unsigned int seq;
Thierry Reding4dfd9092014-12-10 13:03:34 +0100973
Rob Clarkc6eefa12012-10-16 22:48:40 +0000974 if (crtc >= 0) {
975 seq = drm_vblank_count_and_time(dev, crtc, &now);
976 } else {
977 seq = 0;
Imre Deakc61eef72012-10-23 18:53:26 +0000978
979 now = get_drm_timestamp();
Rob Clarkc6eefa12012-10-16 22:48:40 +0000980 }
Rob Clark21a245d2012-12-10 10:49:46 -0600981 e->pipe = crtc;
Rob Clarkc6eefa12012-10-16 22:48:40 +0000982 send_vblank_event(dev, e, seq, &now);
983}
984EXPORT_SYMBOL(drm_send_vblank_event);
985
Mario Kleiner27641c32010-10-23 04:20:23 +0200986/**
Thierry Redinga4d7b302014-12-15 14:47:18 +0100987 * drm_crtc_send_vblank_event - helper to send vblank event after pageflip
988 * @crtc: the source CRTC of the vblank event
989 * @e: the event to send
990 *
991 * Updates sequence # and timestamp on event, and sends it to userspace.
992 * Caller must hold event lock.
993 *
994 * This is the native KMS version of drm_send_vblank_event().
995 */
996void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
997 struct drm_pending_vblank_event *e)
998{
999 drm_send_vblank_event(crtc->dev, drm_crtc_index(crtc), e);
1000}
1001EXPORT_SYMBOL(drm_crtc_send_vblank_event);
1002
1003/**
Ville Syrjäläf2752282014-02-19 21:29:49 +02001004 * drm_vblank_enable - enable the vblank interrupt on a CRTC
1005 * @dev: DRM device
1006 * @crtc: CRTC in question
1007 */
1008static int drm_vblank_enable(struct drm_device *dev, int crtc)
1009{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001010 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001011 int ret = 0;
1012
1013 assert_spin_locked(&dev->vbl_lock);
1014
1015 spin_lock(&dev->vblank_time_lock);
1016
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001017 if (!vblank->enabled) {
Daniel Vetter1cfb80b2014-05-21 15:11:33 +02001018 /*
1019 * Enable vblank irqs under vblank_time_lock protection.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001020 * All vblank count & timestamp updates are held off
1021 * until we are done reinitializing master counter and
1022 * timestamps. Filtercode in drm_handle_vblank() will
1023 * prevent double-accounting of same vblank interval.
1024 */
1025 ret = dev->driver->enable_vblank(dev, crtc);
1026 DRM_DEBUG("enabling vblank on crtc %d, ret: %d\n", crtc, ret);
1027 if (ret)
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001028 atomic_dec(&vblank->refcount);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001029 else {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001030 vblank->enabled = true;
Ville Syrjäläf2752282014-02-19 21:29:49 +02001031 drm_update_vblank_count(dev, crtc);
1032 }
1033 }
1034
1035 spin_unlock(&dev->vblank_time_lock);
1036
1037 return ret;
1038}
1039
1040/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001041 * drm_vblank_get - get a reference count on vblank events
1042 * @dev: DRM device
1043 * @crtc: which CRTC to own
1044 *
1045 * Acquire a reference count on vblank events to avoid having them disabled
1046 * while in use.
1047 *
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001048 * This is the legacy version of drm_crtc_vblank_get().
1049 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001050 * Returns:
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001051 * Zero on success, nonzero on failure.
1052 */
1053int drm_vblank_get(struct drm_device *dev, int crtc)
1054{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001055 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Peter Hurley97cbc882013-08-20 21:51:12 -04001056 unsigned long irqflags;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001057 int ret = 0;
1058
Gerd Hoffmann16e32472015-03-30 12:50:50 +02001059 if (!dev->num_crtcs)
1060 return -EINVAL;
1061
Rob Clarke6ae8682014-08-06 13:16:59 -04001062 if (WARN_ON(crtc >= dev->num_crtcs))
1063 return -EINVAL;
1064
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001065 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1066 /* Going from 0->1 means we have to enable interrupts again */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001067 if (atomic_add_return(1, &vblank->refcount) == 1) {
Ville Syrjäläf2752282014-02-19 21:29:49 +02001068 ret = drm_vblank_enable(dev, crtc);
Li Peng778c9022009-11-09 12:51:22 +08001069 } else {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001070 if (!vblank->enabled) {
1071 atomic_dec(&vblank->refcount);
Li Peng778c9022009-11-09 12:51:22 +08001072 ret = -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001073 }
1074 }
1075 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1076
1077 return ret;
1078}
1079EXPORT_SYMBOL(drm_vblank_get);
1080
1081/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001082 * drm_crtc_vblank_get - get a reference count on vblank events
1083 * @crtc: which CRTC to own
1084 *
1085 * Acquire a reference count on vblank events to avoid having them disabled
1086 * while in use.
1087 *
Damien Lespiau30b79f02015-02-13 15:53:31 +00001088 * This is the native kms version of drm_vblank_get().
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001089 *
1090 * Returns:
1091 * Zero on success, nonzero on failure.
1092 */
1093int drm_crtc_vblank_get(struct drm_crtc *crtc)
1094{
1095 return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
1096}
1097EXPORT_SYMBOL(drm_crtc_vblank_get);
1098
1099/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001100 * drm_vblank_put - give up ownership of vblank events
1101 * @dev: DRM device
1102 * @crtc: which counter to give up
1103 *
1104 * Release ownership of a given vblank counter, turning off interrupts
Mario Kleiner27641c32010-10-23 04:20:23 +02001105 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001106 *
1107 * This is the legacy version of drm_crtc_vblank_put().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001108 */
1109void drm_vblank_put(struct drm_device *dev, int crtc)
1110{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001111 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
1112
Rob Clark7f907bf22014-11-08 10:16:19 -05001113 if (WARN_ON(atomic_read(&vblank->refcount) == 0))
1114 return;
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001115
Rob Clarke6ae8682014-08-06 13:16:59 -04001116 if (WARN_ON(crtc >= dev->num_crtcs))
1117 return;
1118
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001119 /* Last user schedules interrupt disable */
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001120 if (atomic_dec_and_test(&vblank->refcount)) {
Daniel Vetterab8905f12014-09-10 17:36:08 +02001121 if (drm_vblank_offdelay == 0)
1122 return;
1123 else if (dev->vblank_disable_immediate || drm_vblank_offdelay < 0)
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001124 vblank_disable_fn((unsigned long)vblank);
Daniel Vetterab8905f12014-09-10 17:36:08 +02001125 else
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001126 mod_timer(&vblank->disable_timer,
1127 jiffies + ((drm_vblank_offdelay * HZ)/1000));
1128 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001129}
1130EXPORT_SYMBOL(drm_vblank_put);
1131
Rob Clarkc6eefa12012-10-16 22:48:40 +00001132/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001133 * drm_crtc_vblank_put - give up ownership of vblank events
1134 * @crtc: which counter to give up
1135 *
1136 * Release ownership of a given vblank counter, turning off interrupts
1137 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
1138 *
1139 * This is the native kms version of drm_vblank_put().
1140 */
1141void drm_crtc_vblank_put(struct drm_crtc *crtc)
1142{
1143 drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
1144}
1145EXPORT_SYMBOL(drm_crtc_vblank_put);
1146
1147/**
Daniel Vettere8450f52014-07-25 23:34:03 +02001148 * drm_wait_one_vblank - wait for one vblank
1149 * @dev: DRM device
1150 * @crtc: crtc index
1151 *
1152 * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
1153 * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
1154 * due to lack of driver support or because the crtc is off.
1155 */
1156void drm_wait_one_vblank(struct drm_device *dev, int crtc)
1157{
1158 int ret;
1159 u32 last;
1160
1161 ret = drm_vblank_get(dev, crtc);
Daniel Vetter80c873b2014-09-15 14:04:28 +02001162 if (WARN(ret, "vblank not available on crtc %i, ret=%i\n", crtc, ret))
Daniel Vettere8450f52014-07-25 23:34:03 +02001163 return;
1164
1165 last = drm_vblank_count(dev, crtc);
1166
1167 ret = wait_event_timeout(dev->vblank[crtc].queue,
1168 last != drm_vblank_count(dev, crtc),
1169 msecs_to_jiffies(100));
1170
Daniel Vetter80c873b2014-09-15 14:04:28 +02001171 WARN(ret == 0, "vblank wait timed out on crtc %i\n", crtc);
Daniel Vettere8450f52014-07-25 23:34:03 +02001172
1173 drm_vblank_put(dev, crtc);
1174}
1175EXPORT_SYMBOL(drm_wait_one_vblank);
1176
1177/**
1178 * drm_crtc_wait_one_vblank - wait for one vblank
1179 * @crtc: DRM crtc
1180 *
1181 * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
1182 * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
1183 * due to lack of driver support or because the crtc is off.
1184 */
1185void drm_crtc_wait_one_vblank(struct drm_crtc *crtc)
1186{
1187 drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
1188}
1189EXPORT_SYMBOL(drm_crtc_wait_one_vblank);
1190
1191/**
Rob Clarkc6eefa12012-10-16 22:48:40 +00001192 * drm_vblank_off - disable vblank events on a CRTC
1193 * @dev: DRM device
1194 * @crtc: CRTC in question
1195 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001196 * Drivers can use this function to shut down the vblank interrupt handling when
1197 * disabling a crtc. This function ensures that the latest vblank frame count is
1198 * stored so that drm_vblank_on() can restore it again.
1199 *
1200 * Drivers must use this function when the hardware vblank counter can get
1201 * reset, e.g. when suspending.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001202 *
1203 * This is the legacy version of drm_crtc_vblank_off().
Rob Clarkc6eefa12012-10-16 22:48:40 +00001204 */
Li Peng778c9022009-11-09 12:51:22 +08001205void drm_vblank_off(struct drm_device *dev, int crtc)
1206{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001207 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001208 struct drm_pending_vblank_event *e, *t;
1209 struct timeval now;
Li Peng778c9022009-11-09 12:51:22 +08001210 unsigned long irqflags;
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001211 unsigned int seq;
Li Peng778c9022009-11-09 12:51:22 +08001212
Rob Clarke6ae8682014-08-06 13:16:59 -04001213 if (WARN_ON(crtc >= dev->num_crtcs))
1214 return;
1215
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001216 spin_lock_irqsave(&dev->event_lock, irqflags);
1217
1218 spin_lock(&dev->vbl_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +02001219 vblank_disable_and_save(dev, crtc);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001220 wake_up(&vblank->queue);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001221
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001222 /*
1223 * Prevent subsequent drm_vblank_get() from re-enabling
1224 * the vblank interrupt by bumping the refcount.
1225 */
1226 if (!vblank->inmodeset) {
1227 atomic_inc(&vblank->refcount);
1228 vblank->inmodeset = 1;
1229 }
1230 spin_unlock(&dev->vbl_lock);
1231
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001232 /* Send any queued vblank events, lest the natives grow disquiet */
1233 seq = drm_vblank_count_and_time(dev, crtc, &now);
Imre Deake7783ba2012-11-02 13:30:50 +02001234
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001235 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1236 if (e->pipe != crtc)
1237 continue;
1238 DRM_DEBUG("Sending premature vblank event on disable: \
1239 wanted %d, current %d\n",
1240 e->event.sequence, seq);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001241 list_del(&e->base.link);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001242 drm_vblank_put(dev, e->pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001243 send_vblank_event(dev, e, seq, &now);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001244 }
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001245 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Li Peng778c9022009-11-09 12:51:22 +08001246}
1247EXPORT_SYMBOL(drm_vblank_off);
1248
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001249/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001250 * drm_crtc_vblank_off - disable vblank events on a CRTC
1251 * @crtc: CRTC in question
1252 *
1253 * Drivers can use this function to shut down the vblank interrupt handling when
1254 * disabling a crtc. This function ensures that the latest vblank frame count is
1255 * stored so that drm_vblank_on can restore it again.
1256 *
1257 * Drivers must use this function when the hardware vblank counter can get
1258 * reset, e.g. when suspending.
1259 *
1260 * This is the native kms version of drm_vblank_off().
1261 */
1262void drm_crtc_vblank_off(struct drm_crtc *crtc)
1263{
1264 drm_vblank_off(crtc->dev, drm_crtc_index(crtc));
1265}
1266EXPORT_SYMBOL(drm_crtc_vblank_off);
1267
1268/**
Daniel Vetter96256042015-02-13 21:03:42 +01001269 * drm_crtc_vblank_reset - reset vblank state to off on a CRTC
1270 * @crtc: CRTC in question
1271 *
1272 * Drivers can use this function to reset the vblank state to off at load time.
1273 * Drivers should use this together with the drm_crtc_vblank_off() and
1274 * drm_crtc_vblank_on() functions. The difference compared to
1275 * drm_crtc_vblank_off() is that this function doesn't save the vblank counter
1276 * and hence doesn't need to call any driver hooks.
1277 */
1278void drm_crtc_vblank_reset(struct drm_crtc *drm_crtc)
1279{
1280 struct drm_device *dev = drm_crtc->dev;
1281 unsigned long irqflags;
1282 int crtc = drm_crtc_index(drm_crtc);
1283 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
1284
1285 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1286 /*
1287 * Prevent subsequent drm_vblank_get() from enabling the vblank
1288 * interrupt by bumping the refcount.
1289 */
1290 if (!vblank->inmodeset) {
1291 atomic_inc(&vblank->refcount);
1292 vblank->inmodeset = 1;
1293 }
1294 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1295
1296 WARN_ON(!list_empty(&dev->vblank_event_list));
1297}
1298EXPORT_SYMBOL(drm_crtc_vblank_reset);
1299
1300/**
Ville Syrjäläf2752282014-02-19 21:29:49 +02001301 * drm_vblank_on - enable vblank events on a CRTC
1302 * @dev: DRM device
1303 * @crtc: CRTC in question
Daniel Vetterf5752b32014-05-08 16:41:51 +02001304 *
1305 * This functions restores the vblank interrupt state captured with
1306 * drm_vblank_off() again. Note that calls to drm_vblank_on() and
Masanari Iida32197aa2014-10-20 23:53:13 +09001307 * drm_vblank_off() can be unbalanced and so can also be unconditionally called
Daniel Vetterf5752b32014-05-08 16:41:51 +02001308 * in driver load code to reflect the current hardware state of the crtc.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001309 *
1310 * This is the legacy version of drm_crtc_vblank_on().
Ville Syrjäläf2752282014-02-19 21:29:49 +02001311 */
1312void drm_vblank_on(struct drm_device *dev, int crtc)
1313{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001314 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001315 unsigned long irqflags;
1316
Rob Clarke6ae8682014-08-06 13:16:59 -04001317 if (WARN_ON(crtc >= dev->num_crtcs))
1318 return;
1319
Ville Syrjäläf2752282014-02-19 21:29:49 +02001320 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001321 /* Drop our private "prevent drm_vblank_get" refcount */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001322 if (vblank->inmodeset) {
1323 atomic_dec(&vblank->refcount);
1324 vblank->inmodeset = 0;
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001325 }
Ville Syrjäläf8ad0282014-08-06 14:49:49 +03001326
1327 /*
1328 * sample the current counter to avoid random jumps
1329 * when drm_vblank_enable() applies the diff
1330 *
1331 * -1 to make sure user will never see the same
1332 * vblank counter value before and after a modeset
1333 */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001334 vblank->last =
Ville Syrjäläf8ad0282014-08-06 14:49:49 +03001335 (dev->driver->get_vblank_counter(dev, crtc) - 1) &
1336 dev->max_vblank_count;
Ville Syrjäläcd19e522014-08-06 14:49:56 +03001337 /*
1338 * re-enable interrupts if there are users left, or the
1339 * user wishes vblank interrupts to be enabled all the time.
1340 */
1341 if (atomic_read(&vblank->refcount) != 0 ||
1342 (!dev->vblank_disable_immediate && drm_vblank_offdelay == 0))
Ville Syrjäläf2752282014-02-19 21:29:49 +02001343 WARN_ON(drm_vblank_enable(dev, crtc));
1344 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1345}
1346EXPORT_SYMBOL(drm_vblank_on);
1347
1348/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001349 * drm_crtc_vblank_on - enable vblank events on a CRTC
1350 * @crtc: CRTC in question
1351 *
1352 * This functions restores the vblank interrupt state captured with
1353 * drm_vblank_off() again. Note that calls to drm_vblank_on() and
Masanari Iida32197aa2014-10-20 23:53:13 +09001354 * drm_vblank_off() can be unbalanced and so can also be unconditionally called
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001355 * in driver load code to reflect the current hardware state of the crtc.
1356 *
1357 * This is the native kms version of drm_vblank_on().
1358 */
1359void drm_crtc_vblank_on(struct drm_crtc *crtc)
1360{
1361 drm_vblank_on(crtc->dev, drm_crtc_index(crtc));
1362}
1363EXPORT_SYMBOL(drm_crtc_vblank_on);
1364
1365/**
Dave Airlief453ba02008-11-07 14:05:41 -08001366 * drm_vblank_pre_modeset - account for vblanks across mode sets
1367 * @dev: DRM device
1368 * @crtc: CRTC in question
Dave Airlief453ba02008-11-07 14:05:41 -08001369 *
1370 * Account for vblank events across mode setting events, which will likely
1371 * reset the hardware frame counter.
Daniel Vetterf5752b32014-05-08 16:41:51 +02001372 *
1373 * This is done by grabbing a temporary vblank reference to ensure that the
1374 * vblank interrupt keeps running across the modeset sequence. With this the
1375 * software-side vblank frame counting will ensure that there are no jumps or
1376 * discontinuities.
1377 *
1378 * Unfortunately this approach is racy and also doesn't work when the vblank
1379 * interrupt stops running, e.g. across system suspend resume. It is therefore
1380 * highly recommended that drivers use the newer drm_vblank_off() and
1381 * drm_vblank_on() instead. drm_vblank_pre_modeset() only works correctly when
1382 * using "cooked" software vblank frame counters and not relying on any hardware
1383 * counters.
1384 *
1385 * Drivers must call drm_vblank_post_modeset() when re-enabling the same crtc
1386 * again.
Dave Airlief453ba02008-11-07 14:05:41 -08001387 */
1388void drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
1389{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001390 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
1391
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001392 /* vblank is not initialized (IRQ not installed ?), or has been freed */
Jerome Glissee77cef92010-01-07 15:39:13 +01001393 if (!dev->num_crtcs)
1394 return;
Rob Clarke6ae8682014-08-06 13:16:59 -04001395
1396 if (WARN_ON(crtc >= dev->num_crtcs))
1397 return;
1398
Dave Airlief453ba02008-11-07 14:05:41 -08001399 /*
1400 * To avoid all the problems that might happen if interrupts
1401 * were enabled/disabled around or between these calls, we just
1402 * have the kernel take a reference on the CRTC (just once though
1403 * to avoid corrupting the count if multiple, mismatch calls occur),
1404 * so that interrupts remain enabled in the interim.
1405 */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001406 if (!vblank->inmodeset) {
1407 vblank->inmodeset = 0x1;
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001408 if (drm_vblank_get(dev, crtc) == 0)
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001409 vblank->inmodeset |= 0x2;
Dave Airlief453ba02008-11-07 14:05:41 -08001410 }
1411}
1412EXPORT_SYMBOL(drm_vblank_pre_modeset);
1413
Daniel Vetterf5752b32014-05-08 16:41:51 +02001414/**
1415 * drm_vblank_post_modeset - undo drm_vblank_pre_modeset changes
1416 * @dev: DRM device
1417 * @crtc: CRTC in question
1418 *
1419 * This function again drops the temporary vblank reference acquired in
1420 * drm_vblank_pre_modeset.
1421 */
Dave Airlief453ba02008-11-07 14:05:41 -08001422void drm_vblank_post_modeset(struct drm_device *dev, int crtc)
1423{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001424 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Dave Airlief453ba02008-11-07 14:05:41 -08001425 unsigned long irqflags;
1426
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001427 /* vblank is not initialized (IRQ not installed ?), or has been freed */
1428 if (!dev->num_crtcs)
1429 return;
1430
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001431 if (vblank->inmodeset) {
Dave Airlief453ba02008-11-07 14:05:41 -08001432 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Ville Syrjäläba0bf122013-10-04 14:53:33 +03001433 dev->vblank_disable_allowed = true;
Dave Airlief453ba02008-11-07 14:05:41 -08001434 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001435
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001436 if (vblank->inmodeset & 0x2)
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001437 drm_vblank_put(dev, crtc);
1438
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001439 vblank->inmodeset = 0;
Dave Airlief453ba02008-11-07 14:05:41 -08001440 }
1441}
1442EXPORT_SYMBOL(drm_vblank_post_modeset);
1443
Daniel Vetterf5752b32014-05-08 16:41:51 +02001444/*
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001445 * drm_modeset_ctl - handle vblank event counter changes across mode switch
1446 * @DRM_IOCTL_ARGS: standard ioctl arguments
1447 *
1448 * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
1449 * ioctls around modesetting so that any lost vblank events are accounted for.
1450 *
1451 * Generally the counter will reset across mode sets. If interrupts are
1452 * enabled around this call, we don't have to do anything since the counter
1453 * will have already been incremented.
1454 */
1455int drm_modeset_ctl(struct drm_device *dev, void *data,
1456 struct drm_file *file_priv)
1457{
1458 struct drm_modeset_ctl *modeset = data;
Dave Airlie19227562011-02-24 08:35:06 +10001459 unsigned int crtc;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001460
1461 /* If drm_vblank_init() hasn't been called yet, just no-op */
1462 if (!dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001463 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001464
Laurent Pinchart29935552012-05-30 00:58:09 +02001465 /* KMS drivers handle this internally */
1466 if (drm_core_check_feature(dev, DRIVER_MODESET))
1467 return 0;
1468
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001469 crtc = modeset->crtc;
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001470 if (crtc >= dev->num_crtcs)
1471 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001472
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001473 switch (modeset->cmd) {
1474 case _DRM_PRE_MODESET:
Dave Airlief453ba02008-11-07 14:05:41 -08001475 drm_vblank_pre_modeset(dev, crtc);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001476 break;
1477 case _DRM_POST_MODESET:
Dave Airlief453ba02008-11-07 14:05:41 -08001478 drm_vblank_post_modeset(dev, crtc);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001479 break;
1480 default:
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001481 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001482 }
1483
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001484 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001485}
1486
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001487static int drm_queue_vblank_event(struct drm_device *dev, int pipe,
1488 union drm_wait_vblank *vblwait,
1489 struct drm_file *file_priv)
1490{
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001491 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001492 struct drm_pending_vblank_event *e;
1493 struct timeval now;
1494 unsigned long flags;
1495 unsigned int seq;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001496 int ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001497
Thierry Redingf76511b2014-12-10 13:03:40 +01001498 e = kzalloc(sizeof(*e), GFP_KERNEL);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001499 if (e == NULL) {
1500 ret = -ENOMEM;
1501 goto err_put;
1502 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001503
1504 e->pipe = pipe;
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001505 e->base.pid = current->pid;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001506 e->event.base.type = DRM_EVENT_VBLANK;
Thierry Redingf76511b2014-12-10 13:03:40 +01001507 e->event.base.length = sizeof(e->event);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001508 e->event.user_data = vblwait->request.signal;
1509 e->base.event = &e->event.base;
1510 e->base.file_priv = file_priv;
1511 e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
1512
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001513 spin_lock_irqsave(&dev->event_lock, flags);
1514
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001515 /*
1516 * drm_vblank_off() might have been called after we called
1517 * drm_vblank_get(). drm_vblank_off() holds event_lock
1518 * around the vblank disable, so no need for further locking.
1519 * The reference from drm_vblank_get() protects against
1520 * vblank disable from another source.
1521 */
1522 if (!vblank->enabled) {
1523 ret = -EINVAL;
1524 goto err_unlock;
1525 }
1526
Thierry Redingf76511b2014-12-10 13:03:40 +01001527 if (file_priv->event_space < sizeof(e->event)) {
Chris Wilsonea5d5522010-12-01 19:41:31 +00001528 ret = -EBUSY;
1529 goto err_unlock;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001530 }
1531
Thierry Redingf76511b2014-12-10 13:03:40 +01001532 file_priv->event_space -= sizeof(e->event);
Mario Kleiner27641c32010-10-23 04:20:23 +02001533 seq = drm_vblank_count_and_time(dev, pipe, &now);
1534
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001535 if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) &&
1536 (seq - vblwait->request.sequence) <= (1 << 23)) {
1537 vblwait->request.sequence = seq + 1;
Jesse Barnes4a921642009-11-10 08:21:25 +00001538 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001539 }
1540
1541 DRM_DEBUG("event on vblank count %d, current %d, crtc %d\n",
1542 vblwait->request.sequence, seq, pipe);
1543
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001544 trace_drm_vblank_event_queued(current->pid, pipe,
1545 vblwait->request.sequence);
1546
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001547 e->event.sequence = vblwait->request.sequence;
1548 if ((seq - vblwait->request.sequence) <= (1 << 23)) {
Dan Carpenter6f331622010-12-09 08:35:40 +03001549 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001550 send_vblank_event(dev, e, seq, &now);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001551 vblwait->reply.sequence = seq;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001552 } else {
Ilija Hadzica6778e92011-10-31 13:11:57 -04001553 /* drm_handle_vblank_events will call drm_vblank_put */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001554 list_add_tail(&e->base.link, &dev->vblank_event_list);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001555 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001556 }
1557
1558 spin_unlock_irqrestore(&dev->event_lock, flags);
1559
1560 return 0;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001561
1562err_unlock:
1563 spin_unlock_irqrestore(&dev->event_lock, flags);
1564 kfree(e);
1565err_put:
Dan Carpenter6f331622010-12-09 08:35:40 +03001566 drm_vblank_put(dev, pipe);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001567 return ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001568}
1569
Daniel Vetterf5752b32014-05-08 16:41:51 +02001570/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 * Wait for VBLANK.
1572 *
1573 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001574 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 * \param cmd command.
1576 * \param data user argument, pointing to a drm_wait_vblank structure.
1577 * \return zero on success or a negative number on failure.
1578 *
Eric Anholt30b23632009-01-27 21:19:41 -08001579 * This function enables the vblank interrupt on the pipe requested, then
1580 * sleeps waiting for the requested sequence number to occur, and drops
Daniel Vetterf5752b32014-05-08 16:41:51 +02001581 * the vblank interrupt refcount afterwards. (vblank IRQ disable follows that
Eric Anholt30b23632009-01-27 21:19:41 -08001582 * after a timeout with no further vblank waits scheduled).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 */
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001584int drm_wait_vblank(struct drm_device *dev, void *data,
1585 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001587 struct drm_vblank_crtc *vblank;
Eric Anholtc153f452007-09-03 12:06:45 +10001588 union drm_wait_vblank *vblwait = data;
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001589 int ret;
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001590 unsigned int flags, seq, crtc, high_crtc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
Daniel Vetter49849792013-08-28 15:02:37 +02001592 if (!dev->irq_enabled)
1593 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Eric Anholt30b23632009-01-27 21:19:41 -08001595 if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
1596 return -EINVAL;
1597
Eric Anholtc153f452007-09-03 12:06:45 +10001598 if (vblwait->request.type &
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001599 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1600 _DRM_VBLANK_HIGH_CRTC_MASK)) {
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001601 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
Eric Anholtc153f452007-09-03 12:06:45 +10001602 vblwait->request.type,
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001603 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1604 _DRM_VBLANK_HIGH_CRTC_MASK));
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001605 return -EINVAL;
1606 }
1607
Eric Anholtc153f452007-09-03 12:06:45 +10001608 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001609 high_crtc = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK);
1610 if (high_crtc)
1611 crtc = high_crtc >> _DRM_VBLANK_HIGH_CRTC_SHIFT;
1612 else
1613 crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001614 if (crtc >= dev->num_crtcs)
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001615 return -EINVAL;
1616
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001617 vblank = &dev->vblank[crtc];
1618
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001619 ret = drm_vblank_get(dev, crtc);
1620 if (ret) {
Paul Rolland8d3457e2009-08-09 12:24:01 +10001621 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001622 return ret;
1623 }
1624 seq = drm_vblank_count(dev, crtc);
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001625
Eric Anholtc153f452007-09-03 12:06:45 +10001626 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 case _DRM_VBLANK_RELATIVE:
Eric Anholtc153f452007-09-03 12:06:45 +10001628 vblwait->request.sequence += seq;
1629 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 case _DRM_VBLANK_ABSOLUTE:
1631 break;
1632 default:
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001633 ret = -EINVAL;
1634 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 }
1636
Ilija Hadzica6778e92011-10-31 13:11:57 -04001637 if (flags & _DRM_VBLANK_EVENT) {
1638 /* must hold on to the vblank ref until the event fires
1639 * drm_vblank_put will be called asynchronously
1640 */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001641 return drm_queue_vblank_event(dev, crtc, vblwait, file_priv);
Ilija Hadzica6778e92011-10-31 13:11:57 -04001642 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001643
=?utf-8?q?Michel_D=C3=A4nzer?=ab285d72006-10-24 23:34:18 +10001644 if ((flags & _DRM_VBLANK_NEXTONMISS) &&
Eric Anholtc153f452007-09-03 12:06:45 +10001645 (seq - vblwait->request.sequence) <= (1<<23)) {
1646 vblwait->request.sequence = seq + 1;
=?utf-8?q?Michel_D=C3=A4nzer?=ab285d72006-10-24 23:34:18 +10001647 }
1648
Eric Anholt30b23632009-01-27 21:19:41 -08001649 DRM_DEBUG("waiting on vblank count %d, crtc %d\n",
1650 vblwait->request.sequence, crtc);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001651 vblank->last_wait = vblwait->request.sequence;
1652 DRM_WAIT_ON(ret, vblank->queue, 3 * HZ,
Eric Anholt30b23632009-01-27 21:19:41 -08001653 (((drm_vblank_count(dev, crtc) -
1654 vblwait->request.sequence) <= (1 << 23)) ||
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001655 !vblank->enabled ||
Eric Anholt30b23632009-01-27 21:19:41 -08001656 !dev->irq_enabled));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
Eric Anholt30b23632009-01-27 21:19:41 -08001658 if (ret != -EINTR) {
1659 struct timeval now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Mario Kleiner27641c32010-10-23 04:20:23 +02001661 vblwait->reply.sequence = drm_vblank_count_and_time(dev, crtc, &now);
Eric Anholt30b23632009-01-27 21:19:41 -08001662 vblwait->reply.tval_sec = now.tv_sec;
1663 vblwait->reply.tval_usec = now.tv_usec;
Mario Kleiner27641c32010-10-23 04:20:23 +02001664
Eric Anholt30b23632009-01-27 21:19:41 -08001665 DRM_DEBUG("returning %d to client\n",
1666 vblwait->reply.sequence);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 } else {
Eric Anholt30b23632009-01-27 21:19:41 -08001668 DRM_DEBUG("vblank wait interrupted by signal\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 }
1670
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001671done:
1672 drm_vblank_put(dev, crtc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 return ret;
1674}
1675
Sachin Kamatea7f7ab2012-08-01 17:15:31 +05301676static void drm_handle_vblank_events(struct drm_device *dev, int crtc)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001677{
1678 struct drm_pending_vblank_event *e, *t;
1679 struct timeval now;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001680 unsigned int seq;
1681
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001682 assert_spin_locked(&dev->event_lock);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001683
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001684 seq = drm_vblank_count_and_time(dev, crtc, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001685
1686 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1687 if (e->pipe != crtc)
1688 continue;
1689 if ((seq - e->event.sequence) > (1<<23))
1690 continue;
1691
1692 DRM_DEBUG("vblank event on %d, current %d\n",
1693 e->event.sequence, seq);
1694
Rob Clarkc6eefa12012-10-16 22:48:40 +00001695 list_del(&e->base.link);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001696 drm_vblank_put(dev, e->pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001697 send_vblank_event(dev, e, seq, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001698 }
1699
Jesse Barnesac2874b2010-07-01 16:47:31 -07001700 trace_drm_vblank_event(crtc, seq);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001701}
1702
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001704 * drm_handle_vblank - handle a vblank event
1705 * @dev: DRM device
1706 * @crtc: where this event occurred
1707 *
1708 * Drivers should call this routine in their vblank interrupt handlers to
1709 * update the vblank counter and send any signals that may be pending.
Thierry Reding115ebcd2014-12-15 14:47:18 +01001710 *
1711 * This is the legacy version of drm_crtc_handle_vblank().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001712 */
Chris Wilson78c6e172011-01-31 10:48:04 +00001713bool drm_handle_vblank(struct drm_device *dev, int crtc)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001714{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001715 struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
Mario Kleiner27641c32010-10-23 04:20:23 +02001716 u32 vblcount;
1717 s64 diff_ns;
1718 struct timeval tvblank;
1719 unsigned long irqflags;
1720
Daniel Vetteree3c7792015-02-22 15:11:20 +01001721 if (WARN_ON_ONCE(!dev->num_crtcs))
Chris Wilson78c6e172011-01-31 10:48:04 +00001722 return false;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001723
Rob Clarke6ae8682014-08-06 13:16:59 -04001724 if (WARN_ON(crtc >= dev->num_crtcs))
1725 return false;
1726
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001727 spin_lock_irqsave(&dev->event_lock, irqflags);
1728
Mario Kleiner27641c32010-10-23 04:20:23 +02001729 /* Need timestamp lock to prevent concurrent execution with
1730 * vblank enable/disable, as this would cause inconsistent
1731 * or corrupted timestamps and vblank counts.
1732 */
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001733 spin_lock(&dev->vblank_time_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +02001734
1735 /* Vblank irq handling disabled. Nothing to do. */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001736 if (!vblank->enabled) {
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001737 spin_unlock(&dev->vblank_time_lock);
1738 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Chris Wilson78c6e172011-01-31 10:48:04 +00001739 return false;
Mario Kleiner27641c32010-10-23 04:20:23 +02001740 }
1741
1742 /* Fetch corresponding timestamp for this vblank interval from
1743 * driver and store it in proper slot of timestamp ringbuffer.
1744 */
1745
1746 /* Get current timestamp and count. */
Daniel Vetter99264a62015-04-15 19:34:43 +02001747 vblcount = vblank->count;
Mario Kleiner27641c32010-10-23 04:20:23 +02001748 drm_get_last_vbltimestamp(dev, crtc, &tvblank, DRM_CALLED_FROM_VBLIRQ);
1749
1750 /* Compute time difference to timestamp of last vblank */
1751 diff_ns = timeval_to_ns(&tvblank) -
1752 timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount));
1753
1754 /* Update vblank timestamp and count if at least
1755 * DRM_REDUNDANT_VBLIRQ_THRESH_NS nanoseconds
1756 * difference between last stored timestamp and current
1757 * timestamp. A smaller difference means basically
1758 * identical timestamps. Happens if this vblank has
1759 * been already processed and this is a redundant call,
1760 * e.g., due to spurious vblank interrupts. We need to
1761 * ignore those for accounting.
1762 */
Daniel Vetter99264a62015-04-15 19:34:43 +02001763 if (abs64(diff_ns) > DRM_REDUNDANT_VBLIRQ_THRESH_NS)
1764 store_vblank(dev, crtc, 1, &tvblank);
1765 else
Mario Kleiner27641c32010-10-23 04:20:23 +02001766 DRM_DEBUG("crtc %d: Redundant vblirq ignored. diff_ns = %d\n",
1767 crtc, (int) diff_ns);
Mario Kleiner27641c32010-10-23 04:20:23 +02001768
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001769 spin_unlock(&dev->vblank_time_lock);
1770
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001771 wake_up(&vblank->queue);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001772 drm_handle_vblank_events(dev, crtc);
Mario Kleiner27641c32010-10-23 04:20:23 +02001773
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001774 spin_unlock_irqrestore(&dev->event_lock, irqflags);
1775
Chris Wilson78c6e172011-01-31 10:48:04 +00001776 return true;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001777}
1778EXPORT_SYMBOL(drm_handle_vblank);
Thierry Reding115ebcd2014-12-15 14:47:18 +01001779
1780/**
1781 * drm_crtc_handle_vblank - handle a vblank event
1782 * @crtc: where this event occurred
1783 *
1784 * Drivers should call this routine in their vblank interrupt handlers to
1785 * update the vblank counter and send any signals that may be pending.
1786 *
1787 * This is the native KMS version of drm_handle_vblank().
1788 *
1789 * Returns:
1790 * True if the event was successfully handled, false on failure.
1791 */
1792bool drm_crtc_handle_vblank(struct drm_crtc *crtc)
1793{
1794 return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
1795}
1796EXPORT_SYMBOL(drm_crtc_handle_vblank);