blob: 29a6dcd674f85427467372105cd40c1db432dc85 [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. */
Thierry Redingcc1ef112015-08-12 17:00:31 +020046#define vblanktimestamp(dev, pipe, count) \
47 ((dev)->vblank[pipe].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
Thierry Redingcc1ef112015-08-12 17:00:31 +020060drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
Daniel Vetterfb446a12014-09-10 17:36:10 +020061 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
Ville Syrjälä1da248a2015-09-14 22:43:42 +030077static void store_vblank(struct drm_device *dev, unsigned int pipe,
Daniel Vetter209e4dbc2015-08-07 12:31:17 +020078 u32 vblank_count_inc,
Ville Syrjälä4dfd6482015-09-14 22:43:51 +030079 struct timeval *t_vblank, u32 last)
Daniel Vetter99264a62015-04-15 19:34:43 +020080{
Ville Syrjälä1da248a2015-09-14 22:43:42 +030081 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter99264a62015-04-15 19:34:43 +020082 u32 tslot;
83
84 assert_spin_locked(&dev->vblank_time_lock);
85
Ville Syrjälä4dfd6482015-09-14 22:43:51 +030086 vblank->last = last;
87
Ville Syrjälä1b2eb712015-09-14 22:43:50 +030088 /* All writers hold the spinlock, but readers are serialized by
89 * the latching of vblank->count below.
90 */
91 tslot = vblank->count + vblank_count_inc;
92 vblanktimestamp(dev, pipe, tslot) = *t_vblank;
Daniel Vetter99264a62015-04-15 19:34:43 +020093
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/**
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300108 * drm_reset_vblank_timestamp - reset the last timestamp to the last vblank
109 * @dev: DRM device
110 * @pipe: index of CRTC for which to reset the timestamp
111 *
112 * Reset the stored timestamp for the current vblank count to correspond
113 * to the last vblank occurred.
114 *
115 * Only to be called from drm_vblank_on().
116 *
117 * Note: caller must hold dev->vbl_lock since this reads & writes
118 * device vblank fields.
119 */
120static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe)
121{
122 u32 cur_vblank;
123 bool rc;
124 struct timeval t_vblank;
125 int count = DRM_TIMESTAMP_MAXRETRIES;
126
127 spin_lock(&dev->vblank_time_lock);
128
129 /*
130 * sample the current counter to avoid random jumps
131 * when drm_vblank_enable() applies the diff
132 */
133 do {
134 cur_vblank = dev->driver->get_vblank_counter(dev, pipe);
135 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, 0);
136 } while (cur_vblank != dev->driver->get_vblank_counter(dev, pipe) && --count > 0);
137
138 /*
139 * Only reinitialize corresponding vblank timestamp if high-precision query
140 * available and didn't fail. Otherwise reinitialize delayed at next vblank
141 * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
142 */
143 if (!rc)
144 t_vblank = (struct timeval) {0, 0};
145
146 /*
147 * +1 to make sure user will never see the same
148 * vblank counter value before and after a modeset
149 */
150 store_vblank(dev, pipe, 1, &t_vblank, cur_vblank);
151
152 spin_unlock(&dev->vblank_time_lock);
153}
154
155/**
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300156 * drm_update_vblank_count - update the master vblank counter
157 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200158 * @pipe: counter to update
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300159 *
160 * Call back into the driver to update the appropriate vblank counter
Ville Syrjälä1da248a2015-09-14 22:43:42 +0300161 * (specified by @pipe). Deal with wraparound, if it occurred, and
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300162 * update the last read value so we can deal with wraparound on the next
163 * call if necessary.
164 *
165 * Only necessary when going from off->on, to account for frames we
166 * didn't get an interrupt for.
167 *
168 * Note: caller must hold dev->vbl_lock since this reads & writes
169 * device vblank fields.
170 */
Ville Syrjäläa6e610d2015-09-14 22:43:47 +0300171static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
172 unsigned long flags)
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300173{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200174 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter99264a62015-04-15 19:34:43 +0200175 u32 cur_vblank, diff;
Daniel Vetterfb446a12014-09-10 17:36:10 +0200176 bool rc;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300177 struct timeval t_vblank;
Ville Syrjäläfacfb062015-09-14 22:43:48 +0300178 int count = DRM_TIMESTAMP_MAXRETRIES;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300179 int framedur_ns = vblank->framedur_ns;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300180
181 /*
182 * Interrupts were disabled prior to this call, so deal with counter
183 * wrap if needed.
Michel Dänzer5ceecb22015-05-26 17:53:38 +0900184 * NOTE! It's possible we lost a full dev->max_vblank_count + 1 events
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300185 * here if the register is small or we had vblank interrupts off for
186 * a long time.
187 *
188 * We repeat the hardware vblank counter & timestamp query until
189 * we get consistent results. This to prevent races between gpu
190 * updating its hardware counter while we are retrieving the
191 * corresponding vblank timestamp.
192 */
193 do {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200194 cur_vblank = dev->driver->get_vblank_counter(dev, pipe);
Ville Syrjäläa6e610d2015-09-14 22:43:47 +0300195 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, flags);
Ville Syrjäläfacfb062015-09-14 22:43:48 +0300196 } while (cur_vblank != dev->driver->get_vblank_counter(dev, pipe) && --count > 0);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300197
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300198 if (dev->max_vblank_count != 0) {
199 /* trust the hw counter when it's around */
200 diff = (cur_vblank - vblank->last) & dev->max_vblank_count;
201 } else if (rc && framedur_ns) {
202 const struct timeval *t_old;
203 u64 diff_ns;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300204
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300205 t_old = &vblanktimestamp(dev, pipe, vblank->count);
206 diff_ns = timeval_to_ns(&t_vblank) - timeval_to_ns(t_old);
207
208 /*
209 * Figure out how many vblanks we've missed based
210 * on the difference in the timestamps and the
211 * frame/field duration.
212 */
213 diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);
214
215 if (diff == 0 && flags & DRM_CALLED_FROM_VBLIRQ)
216 DRM_DEBUG("crtc %u: Redundant vblirq ignored."
217 " diff_ns = %lld, framedur_ns = %d)\n",
218 pipe, (long long) diff_ns, framedur_ns);
219 } else {
220 /* some kind of default for drivers w/o accurate vbl timestamping */
221 diff = (flags & DRM_CALLED_FROM_VBLIRQ) != 0;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300222 }
223
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300224 DRM_DEBUG("updating vblank count on crtc %u:"
225 " current=%u, diff=%u, hw=%u hw_last=%u\n",
226 pipe, vblank->count, diff, cur_vblank, vblank->last);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300227
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300228 if (diff == 0) {
229 WARN_ON_ONCE(cur_vblank != vblank->last);
Mario Kleinerda8f4392014-09-13 18:25:54 +0200230 return;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300231 }
Mario Kleinerda8f4392014-09-13 18:25:54 +0200232
Daniel Vetter99264a62015-04-15 19:34:43 +0200233 /*
234 * Only reinitialize corresponding vblank timestamp if high-precision query
Mario Kleinerd66a1e32015-05-04 06:29:46 +0200235 * available and didn't fail. Otherwise reinitialize delayed at next vblank
236 * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300237 */
Mario Kleinerd66a1e32015-05-04 06:29:46 +0200238 if (!rc)
239 t_vblank = (struct timeval) {0, 0};
240
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300241 store_vblank(dev, pipe, diff, &t_vblank, cur_vblank);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300242}
243
Mario Kleiner27641c32010-10-23 04:20:23 +0200244/*
Mario Kleiner27641c32010-10-23 04:20:23 +0200245 * Disable vblank irq's on crtc, make sure that last vblank count
246 * of hardware and corresponding consistent software vblank counter
247 * are preserved, even if there are any spurious vblank irq's after
248 * disable.
249 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200250static void vblank_disable_and_save(struct drm_device *dev, unsigned int pipe)
Mario Kleiner27641c32010-10-23 04:20:23 +0200251{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200252 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Mario Kleiner27641c32010-10-23 04:20:23 +0200253 unsigned long irqflags;
Mario Kleiner27641c32010-10-23 04:20:23 +0200254
255 /* Prevent vblank irq processing while disabling vblank irqs,
256 * so no updates of timestamps or count can happen after we've
257 * disabled. Needed to prevent races in case of delayed irq's.
Mario Kleiner27641c32010-10-23 04:20:23 +0200258 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200259 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
260
Ville Syrjälä812e7462014-08-06 14:49:48 +0300261 /*
Laurent Pincharteb2ed662015-01-29 01:09:24 +0200262 * Only disable vblank interrupts if they're enabled. This avoids
263 * calling the ->disable_vblank() operation in atomic context with the
264 * hardware potentially runtime suspended.
265 */
266 if (vblank->enabled) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200267 dev->driver->disable_vblank(dev, pipe);
Laurent Pincharteb2ed662015-01-29 01:09:24 +0200268 vblank->enabled = false;
269 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200270
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300271 /*
272 * Always update the count and timestamp to maintain the
273 * appearance that the counter has been ticking all along until
274 * this time. This makes the count account for the entire time
275 * between drm_vblank_on() and drm_vblank_off().
Mario Kleiner27641c32010-10-23 04:20:23 +0200276 */
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300277 drm_update_vblank_count(dev, pipe, 0);
Mario Kleiner27641c32010-10-23 04:20:23 +0200278
Mario Kleiner27641c32010-10-23 04:20:23 +0200279 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
Mario Kleiner27641c32010-10-23 04:20:23 +0200280}
281
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700282static void vblank_disable_fn(unsigned long arg)
283{
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200284 struct drm_vblank_crtc *vblank = (void *)arg;
285 struct drm_device *dev = vblank->dev;
Thierry Redingcc1ef112015-08-12 17:00:31 +0200286 unsigned int pipe = vblank->pipe;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700287 unsigned long irqflags;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700288
289 if (!dev->vblank_disable_allowed)
290 return;
291
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200292 spin_lock_irqsave(&dev->vbl_lock, irqflags);
293 if (atomic_read(&vblank->refcount) == 0 && vblank->enabled) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200294 DRM_DEBUG("disabling vblank on crtc %u\n", pipe);
295 vblank_disable_and_save(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700296 }
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200297 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700298}
299
Daniel Vetterf5752b32014-05-08 16:41:51 +0200300/**
301 * drm_vblank_cleanup - cleanup vblank support
302 * @dev: DRM device
303 *
304 * This function cleans up any resources allocated in drm_vblank_init.
305 */
Keith Packard52440212008-11-18 09:30:25 -0800306void drm_vblank_cleanup(struct drm_device *dev)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700307{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200308 unsigned int pipe;
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200309
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700310 /* Bail if the driver didn't call drm_vblank_init() */
311 if (dev->num_crtcs == 0)
312 return;
313
Thierry Redingcc1ef112015-08-12 17:00:31 +0200314 for (pipe = 0; pipe < dev->num_crtcs; pipe++) {
315 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300316
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100317 WARN_ON(vblank->enabled &&
318 drm_core_check_feature(dev, DRIVER_MODESET));
Mario Kleiner2368ffb2014-08-06 03:22:46 +0200319
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100320 del_timer_sync(&vblank->disable_timer);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200321 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700322
Ville Syrjälä5380e922013-10-04 14:53:36 +0300323 kfree(dev->vblank);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700324
325 dev->num_crtcs = 0;
326}
Jerome Glissee77cef92010-01-07 15:39:13 +0100327EXPORT_SYMBOL(drm_vblank_cleanup);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700328
Daniel Vetterf5752b32014-05-08 16:41:51 +0200329/**
330 * drm_vblank_init - initialize vblank support
Thierry Redingcc1ef112015-08-12 17:00:31 +0200331 * @dev: DRM device
332 * @num_crtcs: number of CRTCs supported by @dev
Daniel Vetterf5752b32014-05-08 16:41:51 +0200333 *
334 * This function initializes vblank support for @num_crtcs display pipelines.
335 *
336 * Returns:
337 * Zero on success or a negative error code on failure.
338 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200339int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700340{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200341 int ret = -ENOMEM;
342 unsigned int i;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700343
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700344 spin_lock_init(&dev->vbl_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +0200345 spin_lock_init(&dev->vblank_time_lock);
346
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700347 dev->num_crtcs = num_crtcs;
348
Ville Syrjälä5380e922013-10-04 14:53:36 +0300349 dev->vblank = kcalloc(num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
350 if (!dev->vblank)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700351 goto err;
352
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200353 for (i = 0; i < num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300354 struct drm_vblank_crtc *vblank = &dev->vblank[i];
355
356 vblank->dev = dev;
Thierry Redingcc1ef112015-08-12 17:00:31 +0200357 vblank->pipe = i;
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300358 init_waitqueue_head(&vblank->queue);
359 setup_timer(&vblank->disable_timer, vblank_disable_fn,
360 (unsigned long)vblank);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200361 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200362
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100363 DRM_INFO("Supports vblank timestamp caching Rev 2 (21.10.2013).\n");
Mario Kleiner27641c32010-10-23 04:20:23 +0200364
365 /* Driver specific high-precision vblank timestamping supported? */
366 if (dev->driver->get_vblank_timestamp)
367 DRM_INFO("Driver supports precise vblank timestamp query.\n");
368 else
369 DRM_INFO("No driver support for vblank timestamp query.\n");
370
Mario Kleiner5a8b21b2015-05-04 06:29:45 +0200371 /* Must have precise timestamping for reliable vblank instant disable */
372 if (dev->vblank_disable_immediate && !dev->driver->get_vblank_timestamp) {
373 dev->vblank_disable_immediate = false;
374 DRM_INFO("Setting vblank_disable_immediate to false because "
375 "get_vblank_timestamp == NULL\n");
376 }
377
Ville Syrjäläba0bf122013-10-04 14:53:33 +0300378 dev->vblank_disable_allowed = false;
379
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700380 return 0;
381
382err:
Mario Kleiner79a093ae2014-08-06 03:22:44 +0200383 dev->num_crtcs = 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700384 return ret;
385}
386EXPORT_SYMBOL(drm_vblank_init);
387
Dave Airlie28d52042009-09-21 14:33:58 +1000388static void drm_irq_vgaarb_nokms(void *cookie, bool state)
389{
390 struct drm_device *dev = cookie;
391
392 if (dev->driver->vgaarb_irq) {
393 dev->driver->vgaarb_irq(dev, state);
394 return;
395 }
396
397 if (!dev->irq_enabled)
398 return;
399
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000400 if (state) {
401 if (dev->driver->irq_uninstall)
402 dev->driver->irq_uninstall(dev);
403 } else {
404 if (dev->driver->irq_preinstall)
405 dev->driver->irq_preinstall(dev);
406 if (dev->driver->irq_postinstall)
407 dev->driver->irq_postinstall(dev);
Dave Airlie28d52042009-09-21 14:33:58 +1000408 }
409}
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200412 * drm_irq_install - install IRQ handler
413 * @dev: DRM device
414 * @irq: IRQ number to install the handler for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 *
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700416 * Initializes the IRQ related data. Installs the handler, calling the driver
Daniel Vetterf5752b32014-05-08 16:41:51 +0200417 * irq_preinstall() and irq_postinstall() functions before and after the
418 * installation.
419 *
420 * This is the simplified helper interface provided for drivers with no special
421 * needs. Drivers which need to install interrupt handlers for multiple
422 * interrupts must instead set drm_device->irq_enabled to signal the DRM core
423 * that vblank interrupts are available.
424 *
425 * Returns:
426 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 */
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100428int drm_irq_install(struct drm_device *dev, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200430 int ret;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000431 unsigned long sh_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
434 return -EINVAL;
435
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100436 if (irq == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return -EINVAL;
438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 /* Driver must have been initialized */
Daniel Vettere090c532013-11-03 20:27:05 +0100440 if (!dev->dev_private)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Daniel Vettere090c532013-11-03 20:27:05 +0100443 if (dev->irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 return -EBUSY;
Ville Syrjälä44238432013-10-04 14:53:37 +0300445 dev->irq_enabled = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100447 DRM_DEBUG("irq=%d\n", irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000449 /* Before installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000450 if (dev->driver->irq_preinstall)
451 dev->driver->irq_preinstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000453 /* Install handler */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
Thomas Gleixner935f6e32006-07-01 19:29:34 -0700455 sh_flags = IRQF_SHARED;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000456
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100457 ret = request_irq(irq, dev->driver->irq_handler,
Daniel Vetter5829d182013-11-03 21:48:48 +0100458 sh_flags, dev->driver->name, dev);
Jesse Barnes9bfbd5c2008-09-15 15:00:33 -0700459
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000460 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300461 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 return ret;
463 }
464
Dave Airlie28d52042009-09-21 14:33:58 +1000465 if (!drm_core_check_feature(dev, DRIVER_MODESET))
466 vga_client_register(dev->pdev, (void *)dev, drm_irq_vgaarb_nokms, NULL);
467
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000468 /* After installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000469 if (dev->driver->irq_postinstall)
470 ret = dev->driver->irq_postinstall(dev);
471
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700472 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300473 dev->irq_enabled = false;
Joonyoung Shime1c44ac2011-08-04 05:41:00 +0000474 if (!drm_core_check_feature(dev, DRIVER_MODESET))
475 vga_client_register(dev->pdev, NULL, NULL, NULL);
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100476 free_irq(irq, dev);
477 } else {
478 dev->irq = irq;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700479 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700481 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700483EXPORT_SYMBOL(drm_irq_install);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200486 * drm_irq_uninstall - uninstall the IRQ handler
487 * @dev: DRM device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200489 * Calls the driver's irq_uninstall() function and unregisters the IRQ handler.
490 * This should only be called by drivers which used drm_irq_install() to set up
491 * their interrupt handler. Other drivers must only reset
492 * drm_device->irq_enabled to false.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200494 * Note that for kernel modesetting drivers it is a bug if this function fails.
495 * The sanity checks are only to catch buggy user modesetting drivers which call
496 * the same function through an ioctl.
497 *
498 * Returns:
499 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200501int drm_irq_uninstall(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800503 unsigned long irqflags;
Ville Syrjälä44238432013-10-04 14:53:37 +0300504 bool irq_enabled;
505 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
508 return -EINVAL;
509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 irq_enabled = dev->irq_enabled;
Ville Syrjälä44238432013-10-04 14:53:37 +0300511 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800513 /*
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100514 * Wake up any waiters so they don't hang. This is just to paper over
515 * isssues for UMS drivers which aren't in full control of their
516 * vblank/irq handling. KMS drivers must ensure that vblanks are all
517 * disabled when uninstalling the irq handler.
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800518 */
Ben Skeggsbde48892011-07-04 12:52:27 +1000519 if (dev->num_crtcs) {
520 spin_lock_irqsave(&dev->vbl_lock, irqflags);
521 for (i = 0; i < dev->num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300522 struct drm_vblank_crtc *vblank = &dev->vblank[i];
523
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100524 if (!vblank->enabled)
525 continue;
526
527 WARN_ON(drm_core_check_feature(dev, DRIVER_MODESET));
528
529 vblank_disable_and_save(dev, i);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300530 wake_up(&vblank->queue);
Ben Skeggsbde48892011-07-04 12:52:27 +1000531 }
532 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800533 }
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800534
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000535 if (!irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 return -EINVAL;
537
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100538 DRM_DEBUG("irq=%d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Dave Airlie28d52042009-09-21 14:33:58 +1000540 if (!drm_core_check_feature(dev, DRIVER_MODESET))
541 vga_client_register(dev->pdev, NULL, NULL, NULL);
542
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000543 if (dev->driver->irq_uninstall)
544 dev->driver->irq_uninstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100546 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
548 return 0;
549}
550EXPORT_SYMBOL(drm_irq_uninstall);
551
Daniel Vetterf5752b32014-05-08 16:41:51 +0200552/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 * IRQ control ioctl.
554 *
555 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +1000556 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 * \param cmd command.
558 * \param arg user argument, pointing to a drm_control structure.
559 * \return zero on success or a negative number on failure.
560 *
561 * Calls irq_install() or irq_uninstall() according to \p arg.
562 */
Eric Anholtc153f452007-09-03 12:06:45 +1000563int drm_control(struct drm_device *dev, void *data,
564 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
Eric Anholtc153f452007-09-03 12:06:45 +1000566 struct drm_control *ctl = data;
Daniel Vettera319c1a2013-11-03 21:09:15 +0100567 int ret = 0, irq;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000568
Mario Kleiner27641c32010-10-23 04:20:23 +0200569 /* if we haven't irq we fallback for compatibility reasons -
570 * this used to be a separate function in drm_dma.h
571 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Daniel Vetter22471cf2013-11-03 20:02:50 +0100573 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
574 return 0;
575 if (drm_core_check_feature(dev, DRIVER_MODESET))
576 return 0;
577 /* UMS was only ever support on pci devices. */
578 if (WARN_ON(!dev->pdev))
579 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Eric Anholtc153f452007-09-03 12:06:45 +1000581 switch (ctl->func) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 case DRM_INST_HANDLER:
Daniel Vettera319c1a2013-11-03 21:09:15 +0100583 irq = dev->pdev->irq;
584
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
Daniel Vettera319c1a2013-11-03 21:09:15 +0100586 ctl->irq != irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 return -EINVAL;
Daniel Vettere090c532013-11-03 20:27:05 +0100588 mutex_lock(&dev->struct_mutex);
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100589 ret = drm_irq_install(dev, irq);
Daniel Vettere090c532013-11-03 20:27:05 +0100590 mutex_unlock(&dev->struct_mutex);
591
592 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 case DRM_UNINST_HANDLER:
Daniel Vettere090c532013-11-03 20:27:05 +0100594 mutex_lock(&dev->struct_mutex);
595 ret = drm_irq_uninstall(dev);
596 mutex_unlock(&dev->struct_mutex);
597
598 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 default:
600 return -EINVAL;
601 }
602}
603
604/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200605 * drm_calc_timestamping_constants - calculate vblank timestamp constants
606 * @crtc: drm_crtc whose timestamp constants should be updated.
607 * @mode: display mode containing the scanout timings
Mario Kleiner27641c32010-10-23 04:20:23 +0200608 *
Ville Syrjälä21b21562013-10-26 17:22:52 +0300609 * Calculate and store various constants which are later
610 * needed by vblank and swap-completion timestamping, e.g,
611 * by drm_calc_vbltimestamp_from_scanoutpos(). They are
Daniel Vetterf5752b32014-05-08 16:41:51 +0200612 * derived from CRTC's true scanout timing, so they take
Ville Syrjälä21b21562013-10-26 17:22:52 +0300613 * things like panel scaling or other adjustments into account.
Mario Kleiner27641c32010-10-23 04:20:23 +0200614 */
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300615void drm_calc_timestamping_constants(struct drm_crtc *crtc,
616 const struct drm_display_mode *mode)
Mario Kleiner27641c32010-10-23 04:20:23 +0200617{
Ville Syrjäläeba1f352015-09-14 22:43:43 +0300618 struct drm_vblank_crtc *vblank = &crtc->dev->vblank[drm_crtc_index(crtc)];
Ville Syrjälä20b20202015-09-14 22:43:45 +0300619 int linedur_ns = 0, framedur_ns = 0;
Ville Syrjälä77666b72013-10-27 21:22:58 +0200620 int dotclock = mode->crtc_clock;
Mario Kleiner27641c32010-10-23 04:20:23 +0200621
622 /* Valid dotclock? */
623 if (dotclock > 0) {
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300624 int frame_size = mode->crtc_htotal * mode->crtc_vtotal;
625
626 /*
627 * Convert scanline length in pixels and video
Ville Syrjälä20b20202015-09-14 22:43:45 +0300628 * dot clock to line duration and frame duration
629 * in nanoseconds:
Mario Kleiner27641c32010-10-23 04:20:23 +0200630 */
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300631 linedur_ns = div_u64((u64) mode->crtc_htotal * 1000000, dotclock);
632 framedur_ns = div_u64((u64) frame_size * 1000000, dotclock);
Ville Syrjäläc0ae24c2013-10-28 19:53:25 +0200633
634 /*
635 * Fields of interlaced scanout modes are only half a frame duration.
636 */
637 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
638 framedur_ns /= 2;
Mario Kleiner27641c32010-10-23 04:20:23 +0200639 } else
Thierry Redingcc1ef112015-08-12 17:00:31 +0200640 DRM_ERROR("crtc %u: Can't calculate constants, dotclock = 0!\n",
Mario Kleiner27641c32010-10-23 04:20:23 +0200641 crtc->base.id);
642
Ville Syrjäläeba1f352015-09-14 22:43:43 +0300643 vblank->linedur_ns = linedur_ns;
644 vblank->framedur_ns = framedur_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200645
Thierry Redingcc1ef112015-08-12 17:00:31 +0200646 DRM_DEBUG("crtc %u: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300647 crtc->base.id, mode->crtc_htotal,
648 mode->crtc_vtotal, mode->crtc_vdisplay);
Ville Syrjälä20b20202015-09-14 22:43:45 +0300649 DRM_DEBUG("crtc %u: clock %d kHz framedur %d linedur %d\n",
650 crtc->base.id, dotclock, framedur_ns, linedur_ns);
Mario Kleiner27641c32010-10-23 04:20:23 +0200651}
652EXPORT_SYMBOL(drm_calc_timestamping_constants);
653
654/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200655 * drm_calc_vbltimestamp_from_scanoutpos - precise vblank timestamp helper
656 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200657 * @pipe: index of CRTC whose vblank timestamp to retrieve
Daniel Vetterf5752b32014-05-08 16:41:51 +0200658 * @max_error: Desired maximum allowable error in timestamps (nanosecs)
659 * On return contains true maximum error of timestamp
660 * @vblank_time: Pointer to struct timeval which should receive the timestamp
661 * @flags: Flags to pass to driver:
662 * 0 = Default,
663 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
Daniel Vetterf5752b32014-05-08 16:41:51 +0200664 * @mode: mode which defines the scanout timings
665 *
666 * Implements calculation of exact vblank timestamps from given drm_display_mode
667 * timings and current video scanout position of a CRTC. This can be called from
668 * within get_vblank_timestamp() implementation of a kms driver to implement the
669 * actual timestamping.
Mario Kleiner27641c32010-10-23 04:20:23 +0200670 *
671 * Should return timestamps conforming to the OML_sync_control OpenML
672 * extension specification. The timestamp corresponds to the end of
673 * the vblank interval, aka start of scanout of topmost-leftmost display
674 * pixel in the following video frame.
675 *
676 * Requires support for optional dev->driver->get_scanout_position()
677 * in kms driver, plus a bit of setup code to provide a drm_display_mode
678 * that corresponds to the true scanout timing.
679 *
680 * The current implementation only handles standard video modes. It
681 * returns as no operation if a doublescan or interlaced video mode is
682 * active. Higher level code is expected to handle this.
683 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200684 * Returns:
685 * Negative value on error, failure or if not supported in current
Mario Kleiner27641c32010-10-23 04:20:23 +0200686 * video mode:
687 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200688 * -EINVAL - Invalid CRTC.
Mario Kleiner27641c32010-10-23 04:20:23 +0200689 * -EAGAIN - Temporary unavailable, e.g., called before initial modeset.
690 * -ENOTSUPP - Function not supported in current display mode.
691 * -EIO - Failed, e.g., due to failed scanout position query.
692 *
693 * Returns or'ed positive status flags on success:
694 *
695 * DRM_VBLANKTIME_SCANOUTPOS_METHOD - Signal this method used for timestamping.
696 * DRM_VBLANKTIME_INVBL - Timestamp taken while scanout was in vblank interval.
697 *
698 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200699int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
700 unsigned int pipe,
Mario Kleiner27641c32010-10-23 04:20:23 +0200701 int *max_error,
702 struct timeval *vblank_time,
703 unsigned flags,
Ville Syrjälä7da903e2013-10-26 17:57:31 +0300704 const struct drm_display_mode *mode)
Mario Kleiner27641c32010-10-23 04:20:23 +0200705{
Imre Deake62f2f52012-10-23 18:53:25 +0000706 struct timeval tv_etime;
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000707 ktime_t stime, etime;
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300708 unsigned int vbl_status;
709 int ret = DRM_VBLANKTIME_SCANOUTPOS_METHOD;
Mario Kleiner27641c32010-10-23 04:20:23 +0200710 int vpos, hpos, i;
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300711 int delta_ns, duration_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200712
Thierry Redingcc1ef112015-08-12 17:00:31 +0200713 if (pipe >= dev->num_crtcs) {
714 DRM_ERROR("Invalid crtc %u\n", pipe);
Mario Kleiner27641c32010-10-23 04:20:23 +0200715 return -EINVAL;
716 }
717
718 /* Scanout position query not supported? Should not happen. */
719 if (!dev->driver->get_scanout_position) {
720 DRM_ERROR("Called from driver w/o get_scanout_position()!?\n");
721 return -EIO;
722 }
723
Mario Kleiner27641c32010-10-23 04:20:23 +0200724 /* If mode timing undefined, just return as no-op:
725 * Happens during initial modesetting of a crtc.
726 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300727 if (mode->crtc_clock == 0) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200728 DRM_DEBUG("crtc %u: Noop due to uninitialized mode.\n", pipe);
Mario Kleiner27641c32010-10-23 04:20:23 +0200729 return -EAGAIN;
730 }
731
Mario Kleiner27641c32010-10-23 04:20:23 +0200732 /* Get current scanout position with system timestamp.
733 * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times
734 * if single query takes longer than max_error nanoseconds.
735 *
736 * This guarantees a tight bound on maximum error if
737 * code gets preempted or delayed for some reason.
738 */
739 for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) {
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100740 /*
741 * Get vertical and horizontal scanout position vpos, hpos,
742 * and bounding timestamps stime, etime, pre/post query.
743 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300744 vbl_status = dev->driver->get_scanout_position(dev, pipe, flags,
745 &vpos, &hpos,
746 &stime, &etime,
747 mode);
Mario Kleiner27641c32010-10-23 04:20:23 +0200748
Mario Kleiner27641c32010-10-23 04:20:23 +0200749 /* Return as no-op if scanout query unsupported or failed. */
750 if (!(vbl_status & DRM_SCANOUTPOS_VALID)) {
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300751 DRM_DEBUG("crtc %u : scanoutpos query failed [0x%x].\n",
Thierry Redingcc1ef112015-08-12 17:00:31 +0200752 pipe, vbl_status);
Mario Kleiner27641c32010-10-23 04:20:23 +0200753 return -EIO;
754 }
755
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100756 /* Compute uncertainty in timestamp of scanout position query. */
Imre Deake62f2f52012-10-23 18:53:25 +0000757 duration_ns = ktime_to_ns(etime) - ktime_to_ns(stime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200758
759 /* Accept result with < max_error nsecs timing uncertainty. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300760 if (duration_ns <= *max_error)
Mario Kleiner27641c32010-10-23 04:20:23 +0200761 break;
762 }
763
764 /* Noisy system timing? */
765 if (i == DRM_TIMESTAMP_MAXRETRIES) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200766 DRM_DEBUG("crtc %u: Noisy timestamp %d us > %d us [%d reps].\n",
767 pipe, duration_ns/1000, *max_error/1000, i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200768 }
769
770 /* Return upper bound of timestamp precision error. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300771 *max_error = duration_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200772
773 /* Check if in vblank area:
774 * vpos is >=0 in video scanout area, but negative
775 * within vblank area, counting down the number of lines until
776 * start of scanout.
777 */
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300778 if (vbl_status & DRM_SCANOUTPOS_IN_VBLANK)
779 ret |= DRM_VBLANKTIME_IN_VBLANK;
Mario Kleiner27641c32010-10-23 04:20:23 +0200780
781 /* Convert scanout position into elapsed time at raw_time query
782 * since start of scanout at first display scanline. delta_ns
783 * can be negative if start of scanout hasn't happened yet.
784 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300785 delta_ns = div_s64(1000000LL * (vpos * mode->crtc_htotal + hpos),
786 mode->crtc_clock);
Mario Kleiner27641c32010-10-23 04:20:23 +0200787
Imre Deakc61eef72012-10-23 18:53:26 +0000788 if (!drm_timestamp_monotonic)
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000789 etime = ktime_mono_to_real(etime);
Imre Deakc61eef72012-10-23 18:53:26 +0000790
Imre Deake62f2f52012-10-23 18:53:25 +0000791 /* save this only for debugging purposes */
792 tv_etime = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200793 /* Subtract time delta from raw timestamp to get final
794 * vblank_time timestamp for end of vblank.
795 */
Michel Dänzere91abf82013-06-12 11:58:44 +0200796 if (delta_ns < 0)
797 etime = ktime_add_ns(etime, -delta_ns);
798 else
799 etime = ktime_sub_ns(etime, delta_ns);
Imre Deake62f2f52012-10-23 18:53:25 +0000800 *vblank_time = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200801
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300802 DRM_DEBUG("crtc %u : v 0x%x p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n",
803 pipe, vbl_status, hpos, vpos,
Imre Deake62f2f52012-10-23 18:53:25 +0000804 (long)tv_etime.tv_sec, (long)tv_etime.tv_usec,
Joe Perchesbbb0aef52011-04-17 20:35:52 -0700805 (long)vblank_time->tv_sec, (long)vblank_time->tv_usec,
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300806 duration_ns/1000, i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200807
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300808 return ret;
Mario Kleiner27641c32010-10-23 04:20:23 +0200809}
810EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
811
Imre Deakc61eef72012-10-23 18:53:26 +0000812static struct timeval get_drm_timestamp(void)
813{
814 ktime_t now;
815
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000816 now = drm_timestamp_monotonic ? ktime_get() : ktime_get_real();
Imre Deakc61eef72012-10-23 18:53:26 +0000817 return ktime_to_timeval(now);
818}
819
Mario Kleiner27641c32010-10-23 04:20:23 +0200820/**
821 * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent
Thierry Reding4dfd9092014-12-10 13:03:34 +0100822 * vblank interval
Mario Kleiner27641c32010-10-23 04:20:23 +0200823 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200824 * @pipe: index of CRTC whose vblank timestamp to retrieve
Mario Kleiner27641c32010-10-23 04:20:23 +0200825 * @tvblank: Pointer to target struct timeval which should receive the timestamp
826 * @flags: Flags to pass to driver:
Daniel Vetterf5752b32014-05-08 16:41:51 +0200827 * 0 = Default,
828 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
Mario Kleiner27641c32010-10-23 04:20:23 +0200829 *
830 * Fetches the system timestamp corresponding to the time of the most recent
Daniel Vetterf5752b32014-05-08 16:41:51 +0200831 * vblank interval on specified CRTC. May call into kms-driver to
Mario Kleiner27641c32010-10-23 04:20:23 +0200832 * compute the timestamp with a high-precision GPU specific method.
833 *
834 * Returns zero if timestamp originates from uncorrected do_gettimeofday()
835 * call, i.e., it isn't very precisely locked to the true vblank.
836 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200837 * Returns:
Daniel Vetterfb446a12014-09-10 17:36:10 +0200838 * True if timestamp is considered to be very precise, false otherwise.
Mario Kleiner27641c32010-10-23 04:20:23 +0200839 */
Daniel Vetterfb446a12014-09-10 17:36:10 +0200840static bool
Thierry Redingcc1ef112015-08-12 17:00:31 +0200841drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
Daniel Vetterfb446a12014-09-10 17:36:10 +0200842 struct timeval *tvblank, unsigned flags)
Mario Kleiner27641c32010-10-23 04:20:23 +0200843{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200844 int ret;
Mario Kleiner27641c32010-10-23 04:20:23 +0200845
846 /* Define requested maximum error on timestamps (nanoseconds). */
847 int max_error = (int) drm_timestamp_precision * 1000;
848
849 /* Query driver if possible and precision timestamping enabled. */
850 if (dev->driver->get_vblank_timestamp && (max_error > 0)) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200851 ret = dev->driver->get_vblank_timestamp(dev, pipe, &max_error,
Mario Kleiner27641c32010-10-23 04:20:23 +0200852 tvblank, flags);
853 if (ret > 0)
Daniel Vetterfb446a12014-09-10 17:36:10 +0200854 return true;
Mario Kleiner27641c32010-10-23 04:20:23 +0200855 }
856
857 /* GPU high precision timestamp query unsupported or failed.
Imre Deakc61eef72012-10-23 18:53:26 +0000858 * Return current monotonic/gettimeofday timestamp as best estimate.
Mario Kleiner27641c32010-10-23 04:20:23 +0200859 */
Imre Deakc61eef72012-10-23 18:53:26 +0000860 *tvblank = get_drm_timestamp();
Mario Kleiner27641c32010-10-23 04:20:23 +0200861
Daniel Vetterfb446a12014-09-10 17:36:10 +0200862 return false;
Mario Kleiner27641c32010-10-23 04:20:23 +0200863}
Mario Kleiner27641c32010-10-23 04:20:23 +0200864
865/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700866 * drm_vblank_count - retrieve "cooked" vblank counter value
867 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200868 * @pipe: index of CRTC for which to retrieve the counter
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700869 *
870 * Fetches the "cooked" vblank count value that represents the number of
871 * vblank events since the system was booted, including lost events due to
872 * modesetting activity.
Daniel Vetterf5752b32014-05-08 16:41:51 +0200873 *
Thierry Reding96d3f912014-12-16 13:08:47 +0100874 * This is the legacy version of drm_crtc_vblank_count().
875 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200876 * Returns:
877 * The software vblank counter.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700878 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200879u32 drm_vblank_count(struct drm_device *dev, int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700880{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200881 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300882
Thierry Redingcc1ef112015-08-12 17:00:31 +0200883 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -0400884 return 0;
Thierry Reding7d1de852015-08-12 17:00:30 +0200885
Daniel Vetter99264a62015-04-15 19:34:43 +0200886 return vblank->count;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700887}
888EXPORT_SYMBOL(drm_vblank_count);
889
890/**
Thierry Reding96d3f912014-12-16 13:08:47 +0100891 * drm_crtc_vblank_count - retrieve "cooked" vblank counter value
892 * @crtc: which counter to retrieve
893 *
894 * Fetches the "cooked" vblank count value that represents the number of
895 * vblank events since the system was booted, including lost events due to
896 * modesetting activity.
897 *
898 * This is the native KMS version of drm_vblank_count().
899 *
900 * Returns:
901 * The software vblank counter.
902 */
903u32 drm_crtc_vblank_count(struct drm_crtc *crtc)
904{
905 return drm_vblank_count(crtc->dev, drm_crtc_index(crtc));
906}
907EXPORT_SYMBOL(drm_crtc_vblank_count);
908
909/**
Thierry Redingcc1ef112015-08-12 17:00:31 +0200910 * drm_vblank_count_and_time - retrieve "cooked" vblank counter value and the
911 * system timestamp corresponding to that vblank counter value.
Mario Kleiner27641c32010-10-23 04:20:23 +0200912 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200913 * @pipe: index of CRTC whose counter to retrieve
Mario Kleiner27641c32010-10-23 04:20:23 +0200914 * @vblanktime: Pointer to struct timeval to receive the vblank timestamp.
915 *
916 * Fetches the "cooked" vblank count value that represents the number of
917 * vblank events since the system was booted, including lost events due to
918 * modesetting activity. Returns corresponding system timestamp of the time
Daniel Vetterf5752b32014-05-08 16:41:51 +0200919 * of the vblank interval that corresponds to the current vblank counter value.
Mario Kleiner27641c32010-10-23 04:20:23 +0200920 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200921u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
Mario Kleiner27641c32010-10-23 04:20:23 +0200922 struct timeval *vblanktime)
923{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200924 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjäläfacfb062015-09-14 22:43:48 +0300925 int count = DRM_TIMESTAMP_MAXRETRIES;
Mario Kleiner27641c32010-10-23 04:20:23 +0200926 u32 cur_vblank;
927
Thierry Redingcc1ef112015-08-12 17:00:31 +0200928 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -0400929 return 0;
930
Daniel Vetter99264a62015-04-15 19:34:43 +0200931 /*
932 * Vblank timestamps are read lockless. To ensure consistency the vblank
933 * counter is rechecked and ordering is ensured using memory barriers.
934 * This works like a seqlock. The write-side barriers are in store_vblank.
Mario Kleiner27641c32010-10-23 04:20:23 +0200935 */
936 do {
Daniel Vetter99264a62015-04-15 19:34:43 +0200937 cur_vblank = vblank->count;
938 smp_rmb();
Thierry Redingcc1ef112015-08-12 17:00:31 +0200939 *vblanktime = vblanktimestamp(dev, pipe, cur_vblank);
Mario Kleiner27641c32010-10-23 04:20:23 +0200940 smp_rmb();
Ville Syrjäläfacfb062015-09-14 22:43:48 +0300941 } while (cur_vblank != vblank->count && --count > 0);
Mario Kleiner27641c32010-10-23 04:20:23 +0200942
943 return cur_vblank;
944}
945EXPORT_SYMBOL(drm_vblank_count_and_time);
946
Rob Clarkc6eefa12012-10-16 22:48:40 +0000947static void send_vblank_event(struct drm_device *dev,
948 struct drm_pending_vblank_event *e,
949 unsigned long seq, struct timeval *now)
950{
951 WARN_ON_SMP(!spin_is_locked(&dev->event_lock));
952 e->event.sequence = seq;
953 e->event.tv_sec = now->tv_sec;
954 e->event.tv_usec = now->tv_usec;
955
956 list_add_tail(&e->base.link,
957 &e->base.file_priv->event_list);
958 wake_up_interruptible(&e->base.file_priv->event_wait);
959 trace_drm_vblank_event_delivered(e->base.pid, e->pipe,
960 e->event.sequence);
961}
962
963/**
964 * drm_send_vblank_event - helper to send vblank event after pageflip
965 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200966 * @pipe: CRTC index
Rob Clarkc6eefa12012-10-16 22:48:40 +0000967 * @e: the event to send
968 *
969 * Updates sequence # and timestamp on event, and sends it to userspace.
970 * Caller must hold event lock.
Thierry Redinga4d7b302014-12-15 14:47:18 +0100971 *
972 * This is the legacy version of drm_crtc_send_vblank_event().
Rob Clarkc6eefa12012-10-16 22:48:40 +0000973 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200974void drm_send_vblank_event(struct drm_device *dev, unsigned int pipe,
975 struct drm_pending_vblank_event *e)
Rob Clarkc6eefa12012-10-16 22:48:40 +0000976{
977 struct timeval now;
978 unsigned int seq;
Thierry Reding4dfd9092014-12-10 13:03:34 +0100979
Thierry Reding2a7d3d62015-08-12 17:00:24 +0200980 if (dev->num_crtcs > 0) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200981 seq = drm_vblank_count_and_time(dev, pipe, &now);
Rob Clarkc6eefa12012-10-16 22:48:40 +0000982 } else {
983 seq = 0;
Imre Deakc61eef72012-10-23 18:53:26 +0000984
985 now = get_drm_timestamp();
Rob Clarkc6eefa12012-10-16 22:48:40 +0000986 }
Thierry Redingcc1ef112015-08-12 17:00:31 +0200987 e->pipe = pipe;
Rob Clarkc6eefa12012-10-16 22:48:40 +0000988 send_vblank_event(dev, e, seq, &now);
989}
990EXPORT_SYMBOL(drm_send_vblank_event);
991
Mario Kleiner27641c32010-10-23 04:20:23 +0200992/**
Thierry Redinga4d7b302014-12-15 14:47:18 +0100993 * drm_crtc_send_vblank_event - helper to send vblank event after pageflip
994 * @crtc: the source CRTC of the vblank event
995 * @e: the event to send
996 *
997 * Updates sequence # and timestamp on event, and sends it to userspace.
998 * Caller must hold event lock.
999 *
1000 * This is the native KMS version of drm_send_vblank_event().
1001 */
1002void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
1003 struct drm_pending_vblank_event *e)
1004{
1005 drm_send_vblank_event(crtc->dev, drm_crtc_index(crtc), e);
1006}
1007EXPORT_SYMBOL(drm_crtc_send_vblank_event);
1008
1009/**
Ville Syrjäläf2752282014-02-19 21:29:49 +02001010 * drm_vblank_enable - enable the vblank interrupt on a CRTC
1011 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001012 * @pipe: CRTC index
Thierry Redingc30e11f2015-08-12 17:00:33 +02001013 *
1014 * Returns:
1015 * Zero on success or a negative error code on failure.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001016 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001017static int drm_vblank_enable(struct drm_device *dev, unsigned int pipe)
Ville Syrjäläf2752282014-02-19 21:29:49 +02001018{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001019 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001020 int ret = 0;
1021
1022 assert_spin_locked(&dev->vbl_lock);
1023
1024 spin_lock(&dev->vblank_time_lock);
1025
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001026 if (!vblank->enabled) {
Daniel Vetter1cfb80b2014-05-21 15:11:33 +02001027 /*
1028 * Enable vblank irqs under vblank_time_lock protection.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001029 * All vblank count & timestamp updates are held off
1030 * until we are done reinitializing master counter and
1031 * timestamps. Filtercode in drm_handle_vblank() will
1032 * prevent double-accounting of same vblank interval.
1033 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001034 ret = dev->driver->enable_vblank(dev, pipe);
1035 DRM_DEBUG("enabling vblank on crtc %u, ret: %d\n", pipe, ret);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001036 if (ret)
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001037 atomic_dec(&vblank->refcount);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001038 else {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001039 vblank->enabled = true;
Ville Syrjäläa6e610d2015-09-14 22:43:47 +03001040 drm_update_vblank_count(dev, pipe, 0);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001041 }
1042 }
1043
1044 spin_unlock(&dev->vblank_time_lock);
1045
1046 return ret;
1047}
1048
1049/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001050 * drm_vblank_get - get a reference count on vblank events
1051 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001052 * @pipe: index of CRTC to own
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001053 *
1054 * Acquire a reference count on vblank events to avoid having them disabled
1055 * while in use.
1056 *
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001057 * This is the legacy version of drm_crtc_vblank_get().
1058 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001059 * Returns:
Thierry Redingc30e11f2015-08-12 17:00:33 +02001060 * Zero on success or a negative error code on failure.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001061 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001062int drm_vblank_get(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001063{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001064 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Peter Hurley97cbc882013-08-20 21:51:12 -04001065 unsigned long irqflags;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001066 int ret = 0;
1067
Gerd Hoffmann16e32472015-03-30 12:50:50 +02001068 if (!dev->num_crtcs)
1069 return -EINVAL;
1070
Thierry Redingcc1ef112015-08-12 17:00:31 +02001071 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001072 return -EINVAL;
1073
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001074 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1075 /* Going from 0->1 means we have to enable interrupts again */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001076 if (atomic_add_return(1, &vblank->refcount) == 1) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001077 ret = drm_vblank_enable(dev, pipe);
Li Peng778c9022009-11-09 12:51:22 +08001078 } else {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001079 if (!vblank->enabled) {
1080 atomic_dec(&vblank->refcount);
Li Peng778c9022009-11-09 12:51:22 +08001081 ret = -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001082 }
1083 }
1084 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1085
1086 return ret;
1087}
1088EXPORT_SYMBOL(drm_vblank_get);
1089
1090/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001091 * drm_crtc_vblank_get - get a reference count on vblank events
1092 * @crtc: which CRTC to own
1093 *
1094 * Acquire a reference count on vblank events to avoid having them disabled
1095 * while in use.
1096 *
Damien Lespiau30b79f02015-02-13 15:53:31 +00001097 * This is the native kms version of drm_vblank_get().
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001098 *
1099 * Returns:
Thierry Redingc30e11f2015-08-12 17:00:33 +02001100 * Zero on success or a negative error code on failure.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001101 */
1102int drm_crtc_vblank_get(struct drm_crtc *crtc)
1103{
1104 return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
1105}
1106EXPORT_SYMBOL(drm_crtc_vblank_get);
1107
1108/**
Thierry Redingcc1ef112015-08-12 17:00:31 +02001109 * drm_vblank_put - release ownership of vblank events
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001110 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001111 * @pipe: index of CRTC to release
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001112 *
1113 * Release ownership of a given vblank counter, turning off interrupts
Mario Kleiner27641c32010-10-23 04:20:23 +02001114 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001115 *
1116 * This is the legacy version of drm_crtc_vblank_put().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001117 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001118void drm_vblank_put(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001119{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001120 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001121
Thierry Redingcc1ef112015-08-12 17:00:31 +02001122 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clark7f907bf22014-11-08 10:16:19 -05001123 return;
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001124
Thierry Reding7d1de852015-08-12 17:00:30 +02001125 if (WARN_ON(atomic_read(&vblank->refcount) == 0))
Rob Clarke6ae8682014-08-06 13:16:59 -04001126 return;
1127
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001128 /* Last user schedules interrupt disable */
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001129 if (atomic_dec_and_test(&vblank->refcount)) {
Daniel Vetterab8905f12014-09-10 17:36:08 +02001130 if (drm_vblank_offdelay == 0)
1131 return;
1132 else if (dev->vblank_disable_immediate || drm_vblank_offdelay < 0)
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001133 vblank_disable_fn((unsigned long)vblank);
Daniel Vetterab8905f12014-09-10 17:36:08 +02001134 else
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001135 mod_timer(&vblank->disable_timer,
1136 jiffies + ((drm_vblank_offdelay * HZ)/1000));
1137 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001138}
1139EXPORT_SYMBOL(drm_vblank_put);
1140
Rob Clarkc6eefa12012-10-16 22:48:40 +00001141/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001142 * drm_crtc_vblank_put - give up ownership of vblank events
1143 * @crtc: which counter to give up
1144 *
1145 * Release ownership of a given vblank counter, turning off interrupts
1146 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
1147 *
1148 * This is the native kms version of drm_vblank_put().
1149 */
1150void drm_crtc_vblank_put(struct drm_crtc *crtc)
1151{
1152 drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
1153}
1154EXPORT_SYMBOL(drm_crtc_vblank_put);
1155
1156/**
Daniel Vettere8450f52014-07-25 23:34:03 +02001157 * drm_wait_one_vblank - wait for one vblank
1158 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001159 * @pipe: CRTC index
Daniel Vettere8450f52014-07-25 23:34:03 +02001160 *
Ville Syrjälä1da248a2015-09-14 22:43:42 +03001161 * This waits for one vblank to pass on @pipe, using the irq driver interfaces.
1162 * It is a failure to call this when the vblank irq for @pipe is disabled, e.g.
Daniel Vettere8450f52014-07-25 23:34:03 +02001163 * due to lack of driver support or because the crtc is off.
1164 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001165void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe)
Daniel Vettere8450f52014-07-25 23:34:03 +02001166{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001167 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vettere8450f52014-07-25 23:34:03 +02001168 int ret;
1169 u32 last;
1170
Thierry Redingcc1ef112015-08-12 17:00:31 +02001171 if (WARN_ON(pipe >= dev->num_crtcs))
Thierry Reding7d1de852015-08-12 17:00:30 +02001172 return;
1173
Thierry Redingcc1ef112015-08-12 17:00:31 +02001174 ret = drm_vblank_get(dev, pipe);
1175 if (WARN(ret, "vblank not available on crtc %i, ret=%i\n", pipe, ret))
Daniel Vettere8450f52014-07-25 23:34:03 +02001176 return;
1177
Thierry Redingcc1ef112015-08-12 17:00:31 +02001178 last = drm_vblank_count(dev, pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001179
Thierry Redingcc1ef112015-08-12 17:00:31 +02001180 ret = wait_event_timeout(vblank->queue,
1181 last != drm_vblank_count(dev, pipe),
Daniel Vettere8450f52014-07-25 23:34:03 +02001182 msecs_to_jiffies(100));
1183
Thierry Redingcc1ef112015-08-12 17:00:31 +02001184 WARN(ret == 0, "vblank wait timed out on crtc %i\n", pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001185
Thierry Redingcc1ef112015-08-12 17:00:31 +02001186 drm_vblank_put(dev, pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001187}
1188EXPORT_SYMBOL(drm_wait_one_vblank);
1189
1190/**
1191 * drm_crtc_wait_one_vblank - wait for one vblank
1192 * @crtc: DRM crtc
1193 *
1194 * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
1195 * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
1196 * due to lack of driver support or because the crtc is off.
1197 */
1198void drm_crtc_wait_one_vblank(struct drm_crtc *crtc)
1199{
1200 drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
1201}
1202EXPORT_SYMBOL(drm_crtc_wait_one_vblank);
1203
1204/**
Rob Clarkc6eefa12012-10-16 22:48:40 +00001205 * drm_vblank_off - disable vblank events on a CRTC
1206 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001207 * @pipe: CRTC index
Rob Clarkc6eefa12012-10-16 22:48:40 +00001208 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001209 * Drivers can use this function to shut down the vblank interrupt handling when
1210 * disabling a crtc. This function ensures that the latest vblank frame count is
1211 * stored so that drm_vblank_on() can restore it again.
1212 *
1213 * Drivers must use this function when the hardware vblank counter can get
1214 * reset, e.g. when suspending.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001215 *
1216 * This is the legacy version of drm_crtc_vblank_off().
Rob Clarkc6eefa12012-10-16 22:48:40 +00001217 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001218void drm_vblank_off(struct drm_device *dev, unsigned int pipe)
Li Peng778c9022009-11-09 12:51:22 +08001219{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001220 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001221 struct drm_pending_vblank_event *e, *t;
1222 struct timeval now;
Li Peng778c9022009-11-09 12:51:22 +08001223 unsigned long irqflags;
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001224 unsigned int seq;
Li Peng778c9022009-11-09 12:51:22 +08001225
Thierry Redingcc1ef112015-08-12 17:00:31 +02001226 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001227 return;
1228
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001229 spin_lock_irqsave(&dev->event_lock, irqflags);
1230
1231 spin_lock(&dev->vbl_lock);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001232 vblank_disable_and_save(dev, pipe);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001233 wake_up(&vblank->queue);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001234
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001235 /*
1236 * Prevent subsequent drm_vblank_get() from re-enabling
1237 * the vblank interrupt by bumping the refcount.
1238 */
1239 if (!vblank->inmodeset) {
1240 atomic_inc(&vblank->refcount);
1241 vblank->inmodeset = 1;
1242 }
1243 spin_unlock(&dev->vbl_lock);
1244
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001245 /* Send any queued vblank events, lest the natives grow disquiet */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001246 seq = drm_vblank_count_and_time(dev, pipe, &now);
Imre Deake7783ba2012-11-02 13:30:50 +02001247
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001248 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001249 if (e->pipe != pipe)
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001250 continue;
1251 DRM_DEBUG("Sending premature vblank event on disable: \
1252 wanted %d, current %d\n",
1253 e->event.sequence, seq);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001254 list_del(&e->base.link);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001255 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001256 send_vblank_event(dev, e, seq, &now);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001257 }
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001258 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Li Peng778c9022009-11-09 12:51:22 +08001259}
1260EXPORT_SYMBOL(drm_vblank_off);
1261
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001262/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001263 * drm_crtc_vblank_off - disable vblank events on a CRTC
1264 * @crtc: CRTC in question
1265 *
1266 * Drivers can use this function to shut down the vblank interrupt handling when
1267 * disabling a crtc. This function ensures that the latest vblank frame count is
1268 * stored so that drm_vblank_on can restore it again.
1269 *
1270 * Drivers must use this function when the hardware vblank counter can get
1271 * reset, e.g. when suspending.
1272 *
1273 * This is the native kms version of drm_vblank_off().
1274 */
1275void drm_crtc_vblank_off(struct drm_crtc *crtc)
1276{
1277 drm_vblank_off(crtc->dev, drm_crtc_index(crtc));
1278}
1279EXPORT_SYMBOL(drm_crtc_vblank_off);
1280
1281/**
Daniel Vetter96256042015-02-13 21:03:42 +01001282 * drm_crtc_vblank_reset - reset vblank state to off on a CRTC
Thierry Reding2b193f02015-09-24 18:35:30 +02001283 * @crtc: CRTC in question
Daniel Vetter96256042015-02-13 21:03:42 +01001284 *
1285 * Drivers can use this function to reset the vblank state to off at load time.
1286 * Drivers should use this together with the drm_crtc_vblank_off() and
1287 * drm_crtc_vblank_on() functions. The difference compared to
1288 * drm_crtc_vblank_off() is that this function doesn't save the vblank counter
1289 * and hence doesn't need to call any driver hooks.
1290 */
Thierry Reding2b193f02015-09-24 18:35:30 +02001291void drm_crtc_vblank_reset(struct drm_crtc *crtc)
Daniel Vetter96256042015-02-13 21:03:42 +01001292{
Thierry Reding2b193f02015-09-24 18:35:30 +02001293 struct drm_device *dev = crtc->dev;
Daniel Vetter96256042015-02-13 21:03:42 +01001294 unsigned long irqflags;
Thierry Reding2b193f02015-09-24 18:35:30 +02001295 unsigned int pipe = drm_crtc_index(crtc);
Ville Syrjälä1da248a2015-09-14 22:43:42 +03001296 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter96256042015-02-13 21:03:42 +01001297
1298 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1299 /*
1300 * Prevent subsequent drm_vblank_get() from enabling the vblank
1301 * interrupt by bumping the refcount.
1302 */
1303 if (!vblank->inmodeset) {
1304 atomic_inc(&vblank->refcount);
1305 vblank->inmodeset = 1;
1306 }
1307 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1308
1309 WARN_ON(!list_empty(&dev->vblank_event_list));
1310}
1311EXPORT_SYMBOL(drm_crtc_vblank_reset);
1312
1313/**
Ville Syrjäläf2752282014-02-19 21:29:49 +02001314 * drm_vblank_on - enable vblank events on a CRTC
1315 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001316 * @pipe: CRTC index
Daniel Vetterf5752b32014-05-08 16:41:51 +02001317 *
1318 * This functions restores the vblank interrupt state captured with
1319 * drm_vblank_off() again. Note that calls to drm_vblank_on() and
Masanari Iida32197aa2014-10-20 23:53:13 +09001320 * drm_vblank_off() can be unbalanced and so can also be unconditionally called
Daniel Vetterf5752b32014-05-08 16:41:51 +02001321 * in driver load code to reflect the current hardware state of the crtc.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001322 *
1323 * This is the legacy version of drm_crtc_vblank_on().
Ville Syrjäläf2752282014-02-19 21:29:49 +02001324 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001325void drm_vblank_on(struct drm_device *dev, unsigned int pipe)
Ville Syrjäläf2752282014-02-19 21:29:49 +02001326{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001327 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001328 unsigned long irqflags;
1329
Thierry Redingcc1ef112015-08-12 17:00:31 +02001330 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001331 return;
1332
Ville Syrjäläf2752282014-02-19 21:29:49 +02001333 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001334 /* Drop our private "prevent drm_vblank_get" refcount */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001335 if (vblank->inmodeset) {
1336 atomic_dec(&vblank->refcount);
1337 vblank->inmodeset = 0;
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001338 }
Ville Syrjäläf8ad0282014-08-06 14:49:49 +03001339
Ville Syrjälä4dfd6482015-09-14 22:43:51 +03001340 drm_reset_vblank_timestamp(dev, pipe);
1341
Ville Syrjäläcd19e522014-08-06 14:49:56 +03001342 /*
1343 * re-enable interrupts if there are users left, or the
1344 * user wishes vblank interrupts to be enabled all the time.
1345 */
1346 if (atomic_read(&vblank->refcount) != 0 ||
1347 (!dev->vblank_disable_immediate && drm_vblank_offdelay == 0))
Thierry Redingcc1ef112015-08-12 17:00:31 +02001348 WARN_ON(drm_vblank_enable(dev, pipe));
Ville Syrjäläf2752282014-02-19 21:29:49 +02001349 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1350}
1351EXPORT_SYMBOL(drm_vblank_on);
1352
1353/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001354 * drm_crtc_vblank_on - enable vblank events on a CRTC
1355 * @crtc: CRTC in question
1356 *
1357 * This functions restores the vblank interrupt state captured with
1358 * drm_vblank_off() again. Note that calls to drm_vblank_on() and
Masanari Iida32197aa2014-10-20 23:53:13 +09001359 * drm_vblank_off() can be unbalanced and so can also be unconditionally called
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001360 * in driver load code to reflect the current hardware state of the crtc.
1361 *
1362 * This is the native kms version of drm_vblank_on().
1363 */
1364void drm_crtc_vblank_on(struct drm_crtc *crtc)
1365{
1366 drm_vblank_on(crtc->dev, drm_crtc_index(crtc));
1367}
1368EXPORT_SYMBOL(drm_crtc_vblank_on);
1369
1370/**
Dave Airlief453ba02008-11-07 14:05:41 -08001371 * drm_vblank_pre_modeset - account for vblanks across mode sets
1372 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001373 * @pipe: CRTC index
Dave Airlief453ba02008-11-07 14:05:41 -08001374 *
1375 * Account for vblank events across mode setting events, which will likely
1376 * reset the hardware frame counter.
Daniel Vetterf5752b32014-05-08 16:41:51 +02001377 *
1378 * This is done by grabbing a temporary vblank reference to ensure that the
1379 * vblank interrupt keeps running across the modeset sequence. With this the
1380 * software-side vblank frame counting will ensure that there are no jumps or
1381 * discontinuities.
1382 *
1383 * Unfortunately this approach is racy and also doesn't work when the vblank
1384 * interrupt stops running, e.g. across system suspend resume. It is therefore
1385 * highly recommended that drivers use the newer drm_vblank_off() and
1386 * drm_vblank_on() instead. drm_vblank_pre_modeset() only works correctly when
1387 * using "cooked" software vblank frame counters and not relying on any hardware
1388 * counters.
1389 *
1390 * Drivers must call drm_vblank_post_modeset() when re-enabling the same crtc
1391 * again.
Dave Airlief453ba02008-11-07 14:05:41 -08001392 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001393void drm_vblank_pre_modeset(struct drm_device *dev, unsigned int pipe)
Dave Airlief453ba02008-11-07 14:05:41 -08001394{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001395 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001396
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001397 /* vblank is not initialized (IRQ not installed ?), or has been freed */
Jerome Glissee77cef92010-01-07 15:39:13 +01001398 if (!dev->num_crtcs)
1399 return;
Rob Clarke6ae8682014-08-06 13:16:59 -04001400
Thierry Redingcc1ef112015-08-12 17:00:31 +02001401 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001402 return;
1403
Dave Airlief453ba02008-11-07 14:05:41 -08001404 /*
1405 * To avoid all the problems that might happen if interrupts
1406 * were enabled/disabled around or between these calls, we just
1407 * have the kernel take a reference on the CRTC (just once though
1408 * to avoid corrupting the count if multiple, mismatch calls occur),
1409 * so that interrupts remain enabled in the interim.
1410 */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001411 if (!vblank->inmodeset) {
1412 vblank->inmodeset = 0x1;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001413 if (drm_vblank_get(dev, pipe) == 0)
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001414 vblank->inmodeset |= 0x2;
Dave Airlief453ba02008-11-07 14:05:41 -08001415 }
1416}
1417EXPORT_SYMBOL(drm_vblank_pre_modeset);
1418
Daniel Vetterf5752b32014-05-08 16:41:51 +02001419/**
1420 * drm_vblank_post_modeset - undo drm_vblank_pre_modeset changes
1421 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001422 * @pipe: CRTC index
Daniel Vetterf5752b32014-05-08 16:41:51 +02001423 *
1424 * This function again drops the temporary vblank reference acquired in
1425 * drm_vblank_pre_modeset.
1426 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001427void drm_vblank_post_modeset(struct drm_device *dev, unsigned int pipe)
Dave Airlief453ba02008-11-07 14:05:41 -08001428{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001429 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Dave Airlief453ba02008-11-07 14:05:41 -08001430 unsigned long irqflags;
1431
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001432 /* vblank is not initialized (IRQ not installed ?), or has been freed */
1433 if (!dev->num_crtcs)
1434 return;
1435
Thierry Redingcc1ef112015-08-12 17:00:31 +02001436 if (WARN_ON(pipe >= dev->num_crtcs))
Thierry Reding7d1de852015-08-12 17:00:30 +02001437 return;
1438
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001439 if (vblank->inmodeset) {
Dave Airlief453ba02008-11-07 14:05:41 -08001440 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Ville Syrjäläba0bf122013-10-04 14:53:33 +03001441 dev->vblank_disable_allowed = true;
Dave Airlief453ba02008-11-07 14:05:41 -08001442 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001443
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001444 if (vblank->inmodeset & 0x2)
Thierry Redingcc1ef112015-08-12 17:00:31 +02001445 drm_vblank_put(dev, pipe);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001446
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001447 vblank->inmodeset = 0;
Dave Airlief453ba02008-11-07 14:05:41 -08001448 }
1449}
1450EXPORT_SYMBOL(drm_vblank_post_modeset);
1451
Daniel Vetterf5752b32014-05-08 16:41:51 +02001452/*
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001453 * drm_modeset_ctl - handle vblank event counter changes across mode switch
1454 * @DRM_IOCTL_ARGS: standard ioctl arguments
1455 *
1456 * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
1457 * ioctls around modesetting so that any lost vblank events are accounted for.
1458 *
1459 * Generally the counter will reset across mode sets. If interrupts are
1460 * enabled around this call, we don't have to do anything since the counter
1461 * will have already been incremented.
1462 */
1463int drm_modeset_ctl(struct drm_device *dev, void *data,
1464 struct drm_file *file_priv)
1465{
1466 struct drm_modeset_ctl *modeset = data;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001467 unsigned int pipe;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001468
1469 /* If drm_vblank_init() hasn't been called yet, just no-op */
1470 if (!dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001471 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001472
Laurent Pinchart29935552012-05-30 00:58:09 +02001473 /* KMS drivers handle this internally */
1474 if (drm_core_check_feature(dev, DRIVER_MODESET))
1475 return 0;
1476
Thierry Redingcc1ef112015-08-12 17:00:31 +02001477 pipe = modeset->crtc;
1478 if (pipe >= dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001479 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001480
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001481 switch (modeset->cmd) {
1482 case _DRM_PRE_MODESET:
Thierry Redingcc1ef112015-08-12 17:00:31 +02001483 drm_vblank_pre_modeset(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001484 break;
1485 case _DRM_POST_MODESET:
Thierry Redingcc1ef112015-08-12 17:00:31 +02001486 drm_vblank_post_modeset(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001487 break;
1488 default:
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001489 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001490 }
1491
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001492 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001493}
1494
Thierry Redingcc1ef112015-08-12 17:00:31 +02001495static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe,
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001496 union drm_wait_vblank *vblwait,
1497 struct drm_file *file_priv)
1498{
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001499 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001500 struct drm_pending_vblank_event *e;
1501 struct timeval now;
1502 unsigned long flags;
1503 unsigned int seq;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001504 int ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001505
Thierry Redingf76511b2014-12-10 13:03:40 +01001506 e = kzalloc(sizeof(*e), GFP_KERNEL);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001507 if (e == NULL) {
1508 ret = -ENOMEM;
1509 goto err_put;
1510 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001511
1512 e->pipe = pipe;
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001513 e->base.pid = current->pid;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001514 e->event.base.type = DRM_EVENT_VBLANK;
Thierry Redingf76511b2014-12-10 13:03:40 +01001515 e->event.base.length = sizeof(e->event);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001516 e->event.user_data = vblwait->request.signal;
1517 e->base.event = &e->event.base;
1518 e->base.file_priv = file_priv;
1519 e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
1520
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001521 spin_lock_irqsave(&dev->event_lock, flags);
1522
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001523 /*
1524 * drm_vblank_off() might have been called after we called
1525 * drm_vblank_get(). drm_vblank_off() holds event_lock
1526 * around the vblank disable, so no need for further locking.
1527 * The reference from drm_vblank_get() protects against
1528 * vblank disable from another source.
1529 */
1530 if (!vblank->enabled) {
1531 ret = -EINVAL;
1532 goto err_unlock;
1533 }
1534
Thierry Redingf76511b2014-12-10 13:03:40 +01001535 if (file_priv->event_space < sizeof(e->event)) {
Chris Wilsonea5d5522010-12-01 19:41:31 +00001536 ret = -EBUSY;
1537 goto err_unlock;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001538 }
1539
Thierry Redingf76511b2014-12-10 13:03:40 +01001540 file_priv->event_space -= sizeof(e->event);
Mario Kleiner27641c32010-10-23 04:20:23 +02001541 seq = drm_vblank_count_and_time(dev, pipe, &now);
1542
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001543 if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) &&
1544 (seq - vblwait->request.sequence) <= (1 << 23)) {
1545 vblwait->request.sequence = seq + 1;
Jesse Barnes4a921642009-11-10 08:21:25 +00001546 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001547 }
1548
Thierry Redingcc1ef112015-08-12 17:00:31 +02001549 DRM_DEBUG("event on vblank count %d, current %d, crtc %u\n",
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001550 vblwait->request.sequence, seq, pipe);
1551
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001552 trace_drm_vblank_event_queued(current->pid, pipe,
1553 vblwait->request.sequence);
1554
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001555 e->event.sequence = vblwait->request.sequence;
1556 if ((seq - vblwait->request.sequence) <= (1 << 23)) {
Dan Carpenter6f331622010-12-09 08:35:40 +03001557 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001558 send_vblank_event(dev, e, seq, &now);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001559 vblwait->reply.sequence = seq;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001560 } else {
Ilija Hadzica6778e92011-10-31 13:11:57 -04001561 /* drm_handle_vblank_events will call drm_vblank_put */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001562 list_add_tail(&e->base.link, &dev->vblank_event_list);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001563 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001564 }
1565
1566 spin_unlock_irqrestore(&dev->event_lock, flags);
1567
1568 return 0;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001569
1570err_unlock:
1571 spin_unlock_irqrestore(&dev->event_lock, flags);
1572 kfree(e);
1573err_put:
Dan Carpenter6f331622010-12-09 08:35:40 +03001574 drm_vblank_put(dev, pipe);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001575 return ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001576}
1577
Daniel Vetterf5752b32014-05-08 16:41:51 +02001578/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 * Wait for VBLANK.
1580 *
1581 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001582 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 * \param cmd command.
1584 * \param data user argument, pointing to a drm_wait_vblank structure.
1585 * \return zero on success or a negative number on failure.
1586 *
Eric Anholt30b23632009-01-27 21:19:41 -08001587 * This function enables the vblank interrupt on the pipe requested, then
1588 * sleeps waiting for the requested sequence number to occur, and drops
Daniel Vetterf5752b32014-05-08 16:41:51 +02001589 * the vblank interrupt refcount afterwards. (vblank IRQ disable follows that
Eric Anholt30b23632009-01-27 21:19:41 -08001590 * after a timeout with no further vblank waits scheduled).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 */
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001592int drm_wait_vblank(struct drm_device *dev, void *data,
1593 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001595 struct drm_vblank_crtc *vblank;
Eric Anholtc153f452007-09-03 12:06:45 +10001596 union drm_wait_vblank *vblwait = data;
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001597 int ret;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001598 unsigned int flags, seq, pipe, high_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
Daniel Vetter49849792013-08-28 15:02:37 +02001600 if (!dev->irq_enabled)
1601 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
Eric Anholt30b23632009-01-27 21:19:41 -08001603 if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
1604 return -EINVAL;
1605
Eric Anholtc153f452007-09-03 12:06:45 +10001606 if (vblwait->request.type &
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001607 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1608 _DRM_VBLANK_HIGH_CRTC_MASK)) {
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001609 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
Eric Anholtc153f452007-09-03 12:06:45 +10001610 vblwait->request.type,
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001611 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1612 _DRM_VBLANK_HIGH_CRTC_MASK));
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001613 return -EINVAL;
1614 }
1615
Eric Anholtc153f452007-09-03 12:06:45 +10001616 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001617 high_pipe = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK);
1618 if (high_pipe)
1619 pipe = high_pipe >> _DRM_VBLANK_HIGH_CRTC_SHIFT;
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001620 else
Thierry Redingcc1ef112015-08-12 17:00:31 +02001621 pipe = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
1622 if (pipe >= dev->num_crtcs)
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001623 return -EINVAL;
1624
Thierry Redingcc1ef112015-08-12 17:00:31 +02001625 vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001626
Thierry Redingcc1ef112015-08-12 17:00:31 +02001627 ret = drm_vblank_get(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001628 if (ret) {
Paul Rolland8d3457e2009-08-09 12:24:01 +10001629 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001630 return ret;
1631 }
Thierry Redingcc1ef112015-08-12 17:00:31 +02001632 seq = drm_vblank_count(dev, pipe);
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001633
Eric Anholtc153f452007-09-03 12:06:45 +10001634 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 case _DRM_VBLANK_RELATIVE:
Eric Anholtc153f452007-09-03 12:06:45 +10001636 vblwait->request.sequence += seq;
1637 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 case _DRM_VBLANK_ABSOLUTE:
1639 break;
1640 default:
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001641 ret = -EINVAL;
1642 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 }
1644
Ilija Hadzica6778e92011-10-31 13:11:57 -04001645 if (flags & _DRM_VBLANK_EVENT) {
1646 /* must hold on to the vblank ref until the event fires
1647 * drm_vblank_put will be called asynchronously
1648 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001649 return drm_queue_vblank_event(dev, pipe, vblwait, file_priv);
Ilija Hadzica6778e92011-10-31 13:11:57 -04001650 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001651
=?utf-8?q?Michel_D=C3=A4nzer?=ab285d72006-10-24 23:34:18 +10001652 if ((flags & _DRM_VBLANK_NEXTONMISS) &&
Eric Anholtc153f452007-09-03 12:06:45 +10001653 (seq - vblwait->request.sequence) <= (1<<23)) {
1654 vblwait->request.sequence = seq + 1;
=?utf-8?q?Michel_D=C3=A4nzer?=ab285d72006-10-24 23:34:18 +10001655 }
1656
Thierry Redingcc1ef112015-08-12 17:00:31 +02001657 DRM_DEBUG("waiting on vblank count %d, crtc %u\n",
1658 vblwait->request.sequence, pipe);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001659 vblank->last_wait = vblwait->request.sequence;
1660 DRM_WAIT_ON(ret, vblank->queue, 3 * HZ,
Thierry Redingcc1ef112015-08-12 17:00:31 +02001661 (((drm_vblank_count(dev, pipe) -
Eric Anholt30b23632009-01-27 21:19:41 -08001662 vblwait->request.sequence) <= (1 << 23)) ||
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001663 !vblank->enabled ||
Eric Anholt30b23632009-01-27 21:19:41 -08001664 !dev->irq_enabled));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
Eric Anholt30b23632009-01-27 21:19:41 -08001666 if (ret != -EINTR) {
1667 struct timeval now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
Thierry Redingcc1ef112015-08-12 17:00:31 +02001669 vblwait->reply.sequence = drm_vblank_count_and_time(dev, pipe, &now);
Eric Anholt30b23632009-01-27 21:19:41 -08001670 vblwait->reply.tval_sec = now.tv_sec;
1671 vblwait->reply.tval_usec = now.tv_usec;
Mario Kleiner27641c32010-10-23 04:20:23 +02001672
Eric Anholt30b23632009-01-27 21:19:41 -08001673 DRM_DEBUG("returning %d to client\n",
1674 vblwait->reply.sequence);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 } else {
Eric Anholt30b23632009-01-27 21:19:41 -08001676 DRM_DEBUG("vblank wait interrupted by signal\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 }
1678
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001679done:
Thierry Redingcc1ef112015-08-12 17:00:31 +02001680 drm_vblank_put(dev, pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 return ret;
1682}
1683
Thierry Redingcc1ef112015-08-12 17:00:31 +02001684static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001685{
1686 struct drm_pending_vblank_event *e, *t;
1687 struct timeval now;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001688 unsigned int seq;
1689
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001690 assert_spin_locked(&dev->event_lock);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001691
Thierry Redingcc1ef112015-08-12 17:00:31 +02001692 seq = drm_vblank_count_and_time(dev, pipe, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001693
1694 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001695 if (e->pipe != pipe)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001696 continue;
1697 if ((seq - e->event.sequence) > (1<<23))
1698 continue;
1699
1700 DRM_DEBUG("vblank event on %d, current %d\n",
1701 e->event.sequence, seq);
1702
Rob Clarkc6eefa12012-10-16 22:48:40 +00001703 list_del(&e->base.link);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001704 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001705 send_vblank_event(dev, e, seq, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001706 }
1707
Thierry Redingcc1ef112015-08-12 17:00:31 +02001708 trace_drm_vblank_event(pipe, seq);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001709}
1710
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001712 * drm_handle_vblank - handle a vblank event
1713 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001714 * @pipe: index of CRTC where this event occurred
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001715 *
1716 * Drivers should call this routine in their vblank interrupt handlers to
1717 * update the vblank counter and send any signals that may be pending.
Thierry Reding115ebcd2014-12-15 14:47:18 +01001718 *
1719 * This is the legacy version of drm_crtc_handle_vblank().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001720 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001721bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001722{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001723 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Mario Kleiner27641c32010-10-23 04:20:23 +02001724 unsigned long irqflags;
1725
Daniel Vetteree3c7792015-02-22 15:11:20 +01001726 if (WARN_ON_ONCE(!dev->num_crtcs))
Chris Wilson78c6e172011-01-31 10:48:04 +00001727 return false;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001728
Thierry Redingcc1ef112015-08-12 17:00:31 +02001729 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001730 return false;
1731
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001732 spin_lock_irqsave(&dev->event_lock, irqflags);
1733
Mario Kleiner27641c32010-10-23 04:20:23 +02001734 /* Need timestamp lock to prevent concurrent execution with
1735 * vblank enable/disable, as this would cause inconsistent
1736 * or corrupted timestamps and vblank counts.
1737 */
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001738 spin_lock(&dev->vblank_time_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +02001739
1740 /* Vblank irq handling disabled. Nothing to do. */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001741 if (!vblank->enabled) {
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001742 spin_unlock(&dev->vblank_time_lock);
1743 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Chris Wilson78c6e172011-01-31 10:48:04 +00001744 return false;
Mario Kleiner27641c32010-10-23 04:20:23 +02001745 }
1746
Ville Syrjälä4dfd6482015-09-14 22:43:51 +03001747 drm_update_vblank_count(dev, pipe, DRM_CALLED_FROM_VBLIRQ);
Mario Kleiner27641c32010-10-23 04:20:23 +02001748
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001749 spin_unlock(&dev->vblank_time_lock);
1750
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001751 wake_up(&vblank->queue);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001752 drm_handle_vblank_events(dev, pipe);
Mario Kleiner27641c32010-10-23 04:20:23 +02001753
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001754 spin_unlock_irqrestore(&dev->event_lock, irqflags);
1755
Chris Wilson78c6e172011-01-31 10:48:04 +00001756 return true;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001757}
1758EXPORT_SYMBOL(drm_handle_vblank);
Thierry Reding115ebcd2014-12-15 14:47:18 +01001759
1760/**
1761 * drm_crtc_handle_vblank - handle a vblank event
1762 * @crtc: where this event occurred
1763 *
1764 * Drivers should call this routine in their vblank interrupt handlers to
1765 * update the vblank counter and send any signals that may be pending.
1766 *
1767 * This is the native KMS version of drm_handle_vblank().
1768 *
1769 * Returns:
1770 * True if the event was successfully handled, false on failure.
1771 */
1772bool drm_crtc_handle_vblank(struct drm_crtc *crtc)
1773{
1774 return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
1775}
1776EXPORT_SYMBOL(drm_crtc_handle_vblank);