blob: 01a507932ebb2d4f9f0c5726482f93361d0d06d5 [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
Mario Kleiner27641c32010-10-23 04:20:23 +020045/* Retry timestamp calculation up to 3 times to satisfy
46 * drm_timestamp_precision before giving up.
47 */
48#define DRM_TIMESTAMP_MAXRETRIES 3
49
50/* Threshold in nanoseconds for detection of redundant
51 * vblank irq in drm_handle_vblank(). 1 msec should be ok.
52 */
53#define DRM_REDUNDANT_VBLIRQ_THRESH_NS 1000000
54
Daniel Vetterfb446a12014-09-10 17:36:10 +020055static bool
Thierry Redingcc1ef112015-08-12 17:00:31 +020056drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
Daniel Vetterfb446a12014-09-10 17:36:10 +020057 struct timeval *tvblank, unsigned flags);
58
Daniel Vetter18882992014-09-10 08:16:10 +020059static unsigned int drm_timestamp_precision = 20; /* Default to 20 usecs. */
60
61/*
62 * Default to use monotonic timestamps for wait-for-vblank and page-flip
63 * complete events.
64 */
65unsigned int drm_timestamp_monotonic = 1;
66
67static int drm_vblank_offdelay = 5000; /* Default to 5000 msecs. */
68
69module_param_named(vblankoffdelay, drm_vblank_offdelay, int, 0600);
70module_param_named(timestamp_precision_usec, drm_timestamp_precision, int, 0600);
71module_param_named(timestamp_monotonic, drm_timestamp_monotonic, int, 0600);
Dan Carpenterd9d8c4c2016-01-08 14:00:45 +030072MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)");
73MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
74MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");
Daniel Vetter18882992014-09-10 08:16:10 +020075
Ville Syrjälä1da248a2015-09-14 22:43:42 +030076static void store_vblank(struct drm_device *dev, unsigned int pipe,
Daniel Vetter209e4dbc2015-08-07 12:31:17 +020077 u32 vblank_count_inc,
Ville Syrjälä4dfd6482015-09-14 22:43:51 +030078 struct timeval *t_vblank, u32 last)
Daniel Vetter99264a62015-04-15 19:34:43 +020079{
Ville Syrjälä1da248a2015-09-14 22:43:42 +030080 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter99264a62015-04-15 19:34:43 +020081
82 assert_spin_locked(&dev->vblank_time_lock);
83
Ville Syrjälä4dfd6482015-09-14 22:43:51 +030084 vblank->last = last;
85
Matthew Auldd4055a92016-05-10 15:21:28 +010086 write_seqlock(&vblank->seqlock);
87 vblank->time = *t_vblank;
Daniel Vetter99264a62015-04-15 19:34:43 +020088 vblank->count += vblank_count_inc;
Matthew Auldd4055a92016-05-10 15:21:28 +010089 write_sequnlock(&vblank->seqlock);
Daniel Vetter99264a62015-04-15 19:34:43 +020090}
91
Daniel Vetter00edbe12016-05-31 23:11:14 +020092/*
Ville Syrjälä4dfd6482015-09-14 22:43:51 +030093 * Reset the stored timestamp for the current vblank count to correspond
94 * to the last vblank occurred.
95 *
96 * Only to be called from drm_vblank_on().
97 *
98 * Note: caller must hold dev->vbl_lock since this reads & writes
99 * device vblank fields.
100 */
101static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe)
102{
103 u32 cur_vblank;
104 bool rc;
105 struct timeval t_vblank;
106 int count = DRM_TIMESTAMP_MAXRETRIES;
107
108 spin_lock(&dev->vblank_time_lock);
109
110 /*
111 * sample the current counter to avoid random jumps
112 * when drm_vblank_enable() applies the diff
113 */
114 do {
115 cur_vblank = dev->driver->get_vblank_counter(dev, pipe);
116 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, 0);
117 } while (cur_vblank != dev->driver->get_vblank_counter(dev, pipe) && --count > 0);
118
119 /*
120 * Only reinitialize corresponding vblank timestamp if high-precision query
121 * available and didn't fail. Otherwise reinitialize delayed at next vblank
122 * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
123 */
124 if (!rc)
125 t_vblank = (struct timeval) {0, 0};
126
127 /*
128 * +1 to make sure user will never see the same
129 * vblank counter value before and after a modeset
130 */
131 store_vblank(dev, pipe, 1, &t_vblank, cur_vblank);
132
133 spin_unlock(&dev->vblank_time_lock);
134}
135
Daniel Vetter00edbe12016-05-31 23:11:14 +0200136/*
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300137 * Call back into the driver to update the appropriate vblank counter
Ville Syrjälä1da248a2015-09-14 22:43:42 +0300138 * (specified by @pipe). Deal with wraparound, if it occurred, and
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300139 * update the last read value so we can deal with wraparound on the next
140 * call if necessary.
141 *
142 * Only necessary when going from off->on, to account for frames we
143 * didn't get an interrupt for.
144 *
145 * Note: caller must hold dev->vbl_lock since this reads & writes
146 * device vblank fields.
147 */
Ville Syrjäläa6e610d2015-09-14 22:43:47 +0300148static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
149 unsigned long flags)
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300150{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200151 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter99264a62015-04-15 19:34:43 +0200152 u32 cur_vblank, diff;
Daniel Vetterfb446a12014-09-10 17:36:10 +0200153 bool rc;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300154 struct timeval t_vblank;
Ville Syrjäläfacfb062015-09-14 22:43:48 +0300155 int count = DRM_TIMESTAMP_MAXRETRIES;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300156 int framedur_ns = vblank->framedur_ns;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300157
158 /*
159 * Interrupts were disabled prior to this call, so deal with counter
160 * wrap if needed.
Michel Dänzer5ceecb22015-05-26 17:53:38 +0900161 * NOTE! It's possible we lost a full dev->max_vblank_count + 1 events
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300162 * here if the register is small or we had vblank interrupts off for
163 * a long time.
164 *
165 * We repeat the hardware vblank counter & timestamp query until
166 * we get consistent results. This to prevent races between gpu
167 * updating its hardware counter while we are retrieving the
168 * corresponding vblank timestamp.
169 */
170 do {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200171 cur_vblank = dev->driver->get_vblank_counter(dev, pipe);
Ville Syrjäläa6e610d2015-09-14 22:43:47 +0300172 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, flags);
Ville Syrjäläfacfb062015-09-14 22:43:48 +0300173 } while (cur_vblank != dev->driver->get_vblank_counter(dev, pipe) && --count > 0);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300174
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300175 if (dev->max_vblank_count != 0) {
176 /* trust the hw counter when it's around */
177 diff = (cur_vblank - vblank->last) & dev->max_vblank_count;
178 } else if (rc && framedur_ns) {
179 const struct timeval *t_old;
180 u64 diff_ns;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300181
Matthew Auldd4055a92016-05-10 15:21:28 +0100182 t_old = &vblank->time;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300183 diff_ns = timeval_to_ns(&t_vblank) - timeval_to_ns(t_old);
184
185 /*
186 * Figure out how many vblanks we've missed based
187 * on the difference in the timestamps and the
188 * frame/field duration.
189 */
190 diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);
191
192 if (diff == 0 && flags & DRM_CALLED_FROM_VBLIRQ)
Ville Syrjälä235fabe2015-10-09 22:57:37 +0300193 DRM_DEBUG_VBL("crtc %u: Redundant vblirq ignored."
194 " diff_ns = %lld, framedur_ns = %d)\n",
195 pipe, (long long) diff_ns, framedur_ns);
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300196 } else {
197 /* some kind of default for drivers w/o accurate vbl timestamping */
198 diff = (flags & DRM_CALLED_FROM_VBLIRQ) != 0;
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300199 }
200
Mario Kleiner99b8e712016-02-12 20:30:28 +0100201 /*
Mario Kleinerc61934e2016-02-12 20:30:29 +0100202 * Within a drm_vblank_pre_modeset - drm_vblank_post_modeset
203 * interval? If so then vblank irqs keep running and it will likely
204 * happen that the hardware vblank counter is not trustworthy as it
205 * might reset at some point in that interval and vblank timestamps
206 * are not trustworthy either in that interval. Iow. this can result
207 * in a bogus diff >> 1 which must be avoided as it would cause
208 * random large forward jumps of the software vblank counter.
209 */
210 if (diff > 1 && (vblank->inmodeset & 0x2)) {
211 DRM_DEBUG_VBL("clamping vblank bump to 1 on crtc %u: diffr=%u"
212 " due to pre-modeset.\n", pipe, diff);
213 diff = 1;
214 }
215
Ville Syrjälä235fabe2015-10-09 22:57:37 +0300216 DRM_DEBUG_VBL("updating vblank count on crtc %u:"
217 " current=%u, diff=%u, hw=%u hw_last=%u\n",
218 pipe, vblank->count, diff, cur_vblank, vblank->last);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300219
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300220 if (diff == 0) {
221 WARN_ON_ONCE(cur_vblank != vblank->last);
Mario Kleinerda8f4392014-09-13 18:25:54 +0200222 return;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300223 }
Mario Kleinerda8f4392014-09-13 18:25:54 +0200224
Daniel Vetter99264a62015-04-15 19:34:43 +0200225 /*
226 * Only reinitialize corresponding vblank timestamp if high-precision query
Ville Syrjäläfa4270d2015-09-30 19:21:34 +0300227 * available and didn't fail, or we were called from the vblank interrupt.
228 * Otherwise reinitialize delayed at next vblank interrupt and assign 0
229 * for now, to mark the vblanktimestamp as invalid.
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300230 */
Ville Syrjäläfa4270d2015-09-30 19:21:34 +0300231 if (!rc && (flags & DRM_CALLED_FROM_VBLIRQ) == 0)
Mario Kleinerd66a1e32015-05-04 06:29:46 +0200232 t_vblank = (struct timeval) {0, 0};
233
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300234 store_vblank(dev, pipe, diff, &t_vblank, cur_vblank);
Ville Syrjälä13b030a2014-08-06 14:49:47 +0300235}
236
Maarten Lankhorstaf61d5c2016-05-17 15:07:44 +0200237/**
238 * drm_accurate_vblank_count - retrieve the master vblank counter
239 * @crtc: which counter to retrieve
240 *
241 * This function is similar to @drm_crtc_vblank_count but this
242 * function interpolates to handle a race with vblank irq's.
243 *
244 * This is mostly useful for hardware that can obtain the scanout
245 * position, but doesn't have a frame counter.
246 */
247u32 drm_accurate_vblank_count(struct drm_crtc *crtc)
248{
249 struct drm_device *dev = crtc->dev;
250 unsigned int pipe = drm_crtc_index(crtc);
251 u32 vblank;
252 unsigned long flags;
253
254 WARN(!dev->driver->get_vblank_timestamp,
255 "This function requires support for accurate vblank timestamps.");
256
257 spin_lock_irqsave(&dev->vblank_time_lock, flags);
258
259 drm_update_vblank_count(dev, pipe, 0);
260 vblank = drm_vblank_count(dev, pipe);
261
262 spin_unlock_irqrestore(&dev->vblank_time_lock, flags);
263
264 return vblank;
265}
266EXPORT_SYMBOL(drm_accurate_vblank_count);
267
Mario Kleiner27641c32010-10-23 04:20:23 +0200268/*
Mario Kleiner27641c32010-10-23 04:20:23 +0200269 * Disable vblank irq's on crtc, make sure that last vblank count
270 * of hardware and corresponding consistent software vblank counter
271 * are preserved, even if there are any spurious vblank irq's after
272 * disable.
273 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200274static void vblank_disable_and_save(struct drm_device *dev, unsigned int pipe)
Mario Kleiner27641c32010-10-23 04:20:23 +0200275{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200276 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Mario Kleiner27641c32010-10-23 04:20:23 +0200277 unsigned long irqflags;
Mario Kleiner27641c32010-10-23 04:20:23 +0200278
279 /* Prevent vblank irq processing while disabling vblank irqs,
280 * so no updates of timestamps or count can happen after we've
281 * disabled. Needed to prevent races in case of delayed irq's.
Mario Kleiner27641c32010-10-23 04:20:23 +0200282 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200283 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
284
Ville Syrjälä812e7462014-08-06 14:49:48 +0300285 /*
Laurent Pincharteb2ed662015-01-29 01:09:24 +0200286 * Only disable vblank interrupts if they're enabled. This avoids
287 * calling the ->disable_vblank() operation in atomic context with the
288 * hardware potentially runtime suspended.
289 */
290 if (vblank->enabled) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200291 dev->driver->disable_vblank(dev, pipe);
Laurent Pincharteb2ed662015-01-29 01:09:24 +0200292 vblank->enabled = false;
293 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200294
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300295 /*
296 * Always update the count and timestamp to maintain the
297 * appearance that the counter has been ticking all along until
298 * this time. This makes the count account for the entire time
299 * between drm_vblank_on() and drm_vblank_off().
Mario Kleiner27641c32010-10-23 04:20:23 +0200300 */
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300301 drm_update_vblank_count(dev, pipe, 0);
Mario Kleiner27641c32010-10-23 04:20:23 +0200302
Mario Kleiner27641c32010-10-23 04:20:23 +0200303 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
Mario Kleiner27641c32010-10-23 04:20:23 +0200304}
305
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700306static void vblank_disable_fn(unsigned long arg)
307{
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200308 struct drm_vblank_crtc *vblank = (void *)arg;
309 struct drm_device *dev = vblank->dev;
Thierry Redingcc1ef112015-08-12 17:00:31 +0200310 unsigned int pipe = vblank->pipe;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700311 unsigned long irqflags;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700312
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200313 spin_lock_irqsave(&dev->vbl_lock, irqflags);
314 if (atomic_read(&vblank->refcount) == 0 && vblank->enabled) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200315 DRM_DEBUG("disabling vblank on crtc %u\n", pipe);
316 vblank_disable_and_save(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700317 }
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200318 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700319}
320
Daniel Vetterf5752b32014-05-08 16:41:51 +0200321/**
322 * drm_vblank_cleanup - cleanup vblank support
323 * @dev: DRM device
324 *
325 * This function cleans up any resources allocated in drm_vblank_init.
326 */
Keith Packard52440212008-11-18 09:30:25 -0800327void drm_vblank_cleanup(struct drm_device *dev)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700328{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200329 unsigned int pipe;
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200330
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700331 /* Bail if the driver didn't call drm_vblank_init() */
332 if (dev->num_crtcs == 0)
333 return;
334
Thierry Redingcc1ef112015-08-12 17:00:31 +0200335 for (pipe = 0; pipe < dev->num_crtcs; pipe++) {
336 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300337
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100338 WARN_ON(vblank->enabled &&
339 drm_core_check_feature(dev, DRIVER_MODESET));
Mario Kleiner2368ffb2014-08-06 03:22:46 +0200340
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100341 del_timer_sync(&vblank->disable_timer);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200342 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700343
Ville Syrjälä5380e922013-10-04 14:53:36 +0300344 kfree(dev->vblank);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700345
346 dev->num_crtcs = 0;
347}
Jerome Glissee77cef92010-01-07 15:39:13 +0100348EXPORT_SYMBOL(drm_vblank_cleanup);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700349
Daniel Vetterf5752b32014-05-08 16:41:51 +0200350/**
351 * drm_vblank_init - initialize vblank support
Thierry Redingcc1ef112015-08-12 17:00:31 +0200352 * @dev: DRM device
353 * @num_crtcs: number of CRTCs supported by @dev
Daniel Vetterf5752b32014-05-08 16:41:51 +0200354 *
355 * This function initializes vblank support for @num_crtcs display pipelines.
356 *
357 * Returns:
358 * Zero on success or a negative error code on failure.
359 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200360int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700361{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200362 int ret = -ENOMEM;
363 unsigned int i;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700364
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700365 spin_lock_init(&dev->vbl_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +0200366 spin_lock_init(&dev->vblank_time_lock);
367
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700368 dev->num_crtcs = num_crtcs;
369
Ville Syrjälä5380e922013-10-04 14:53:36 +0300370 dev->vblank = kcalloc(num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
371 if (!dev->vblank)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700372 goto err;
373
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200374 for (i = 0; i < num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300375 struct drm_vblank_crtc *vblank = &dev->vblank[i];
376
377 vblank->dev = dev;
Thierry Redingcc1ef112015-08-12 17:00:31 +0200378 vblank->pipe = i;
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300379 init_waitqueue_head(&vblank->queue);
380 setup_timer(&vblank->disable_timer, vblank_disable_fn,
381 (unsigned long)vblank);
Matthew Auldd4055a92016-05-10 15:21:28 +0100382 seqlock_init(&vblank->seqlock);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200383 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200384
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100385 DRM_INFO("Supports vblank timestamp caching Rev 2 (21.10.2013).\n");
Mario Kleiner27641c32010-10-23 04:20:23 +0200386
387 /* Driver specific high-precision vblank timestamping supported? */
388 if (dev->driver->get_vblank_timestamp)
389 DRM_INFO("Driver supports precise vblank timestamp query.\n");
390 else
391 DRM_INFO("No driver support for vblank timestamp query.\n");
392
Mario Kleiner5a8b21b2015-05-04 06:29:45 +0200393 /* Must have precise timestamping for reliable vblank instant disable */
394 if (dev->vblank_disable_immediate && !dev->driver->get_vblank_timestamp) {
395 dev->vblank_disable_immediate = false;
396 DRM_INFO("Setting vblank_disable_immediate to false because "
397 "get_vblank_timestamp == NULL\n");
398 }
399
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700400 return 0;
401
402err:
Mario Kleiner79a093ae2014-08-06 03:22:44 +0200403 dev->num_crtcs = 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700404 return ret;
405}
406EXPORT_SYMBOL(drm_vblank_init);
407
Dave Airlie28d52042009-09-21 14:33:58 +1000408static void drm_irq_vgaarb_nokms(void *cookie, bool state)
409{
410 struct drm_device *dev = cookie;
411
412 if (dev->driver->vgaarb_irq) {
413 dev->driver->vgaarb_irq(dev, state);
414 return;
415 }
416
417 if (!dev->irq_enabled)
418 return;
419
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000420 if (state) {
421 if (dev->driver->irq_uninstall)
422 dev->driver->irq_uninstall(dev);
423 } else {
424 if (dev->driver->irq_preinstall)
425 dev->driver->irq_preinstall(dev);
426 if (dev->driver->irq_postinstall)
427 dev->driver->irq_postinstall(dev);
Dave Airlie28d52042009-09-21 14:33:58 +1000428 }
429}
430
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200432 * drm_irq_install - install IRQ handler
433 * @dev: DRM device
434 * @irq: IRQ number to install the handler for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 *
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700436 * Initializes the IRQ related data. Installs the handler, calling the driver
Daniel Vetterf5752b32014-05-08 16:41:51 +0200437 * irq_preinstall() and irq_postinstall() functions before and after the
438 * installation.
439 *
440 * This is the simplified helper interface provided for drivers with no special
441 * needs. Drivers which need to install interrupt handlers for multiple
442 * interrupts must instead set drm_device->irq_enabled to signal the DRM core
443 * that vblank interrupts are available.
444 *
445 * Returns:
446 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 */
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100448int drm_irq_install(struct drm_device *dev, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200450 int ret;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000451 unsigned long sh_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
454 return -EINVAL;
455
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100456 if (irq == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return -EINVAL;
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 /* Driver must have been initialized */
Daniel Vettere090c532013-11-03 20:27:05 +0100460 if (!dev->dev_private)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Daniel Vettere090c532013-11-03 20:27:05 +0100463 if (dev->irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 return -EBUSY;
Ville Syrjälä44238432013-10-04 14:53:37 +0300465 dev->irq_enabled = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100467 DRM_DEBUG("irq=%d\n", irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000469 /* Before installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000470 if (dev->driver->irq_preinstall)
471 dev->driver->irq_preinstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000473 /* Install handler */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
Thomas Gleixner935f6e32006-07-01 19:29:34 -0700475 sh_flags = IRQF_SHARED;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000476
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100477 ret = request_irq(irq, dev->driver->irq_handler,
Daniel Vetter5829d182013-11-03 21:48:48 +0100478 sh_flags, dev->driver->name, dev);
Jesse Barnes9bfbd5c2008-09-15 15:00:33 -0700479
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000480 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300481 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 return ret;
483 }
484
Dave Airlie28d52042009-09-21 14:33:58 +1000485 if (!drm_core_check_feature(dev, DRIVER_MODESET))
486 vga_client_register(dev->pdev, (void *)dev, drm_irq_vgaarb_nokms, NULL);
487
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000488 /* After installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000489 if (dev->driver->irq_postinstall)
490 ret = dev->driver->irq_postinstall(dev);
491
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700492 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300493 dev->irq_enabled = false;
Joonyoung Shime1c44ac2011-08-04 05:41:00 +0000494 if (!drm_core_check_feature(dev, DRIVER_MODESET))
495 vga_client_register(dev->pdev, NULL, NULL, NULL);
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100496 free_irq(irq, dev);
497 } else {
498 dev->irq = irq;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700501 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700503EXPORT_SYMBOL(drm_irq_install);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200506 * drm_irq_uninstall - uninstall the IRQ handler
507 * @dev: DRM device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200509 * Calls the driver's irq_uninstall() function and unregisters the IRQ handler.
510 * This should only be called by drivers which used drm_irq_install() to set up
511 * their interrupt handler. Other drivers must only reset
512 * drm_device->irq_enabled to false.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200514 * Note that for kernel modesetting drivers it is a bug if this function fails.
515 * The sanity checks are only to catch buggy user modesetting drivers which call
516 * the same function through an ioctl.
517 *
518 * Returns:
519 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200521int drm_irq_uninstall(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800523 unsigned long irqflags;
Ville Syrjälä44238432013-10-04 14:53:37 +0300524 bool irq_enabled;
525 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
527 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
528 return -EINVAL;
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 irq_enabled = dev->irq_enabled;
Ville Syrjälä44238432013-10-04 14:53:37 +0300531 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800533 /*
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100534 * Wake up any waiters so they don't hang. This is just to paper over
Frank Binnsc78d1ca2016-06-24 11:15:37 +0100535 * issues for UMS drivers which aren't in full control of their
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100536 * vblank/irq handling. KMS drivers must ensure that vblanks are all
537 * disabled when uninstalling the irq handler.
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800538 */
Ben Skeggsbde48892011-07-04 12:52:27 +1000539 if (dev->num_crtcs) {
540 spin_lock_irqsave(&dev->vbl_lock, irqflags);
541 for (i = 0; i < dev->num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300542 struct drm_vblank_crtc *vblank = &dev->vblank[i];
543
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100544 if (!vblank->enabled)
545 continue;
546
547 WARN_ON(drm_core_check_feature(dev, DRIVER_MODESET));
548
549 vblank_disable_and_save(dev, i);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300550 wake_up(&vblank->queue);
Ben Skeggsbde48892011-07-04 12:52:27 +1000551 }
552 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800553 }
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800554
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000555 if (!irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 return -EINVAL;
557
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100558 DRM_DEBUG("irq=%d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Dave Airlie28d52042009-09-21 14:33:58 +1000560 if (!drm_core_check_feature(dev, DRIVER_MODESET))
561 vga_client_register(dev->pdev, NULL, NULL, NULL);
562
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000563 if (dev->driver->irq_uninstall)
564 dev->driver->irq_uninstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Daniel Vetter7c1a38e2013-12-16 11:21:15 +0100566 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568 return 0;
569}
570EXPORT_SYMBOL(drm_irq_uninstall);
571
Daniel Vetterf5752b32014-05-08 16:41:51 +0200572/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 * IRQ control ioctl.
574 *
575 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +1000576 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 * \param cmd command.
578 * \param arg user argument, pointing to a drm_control structure.
579 * \return zero on success or a negative number on failure.
580 *
581 * Calls irq_install() or irq_uninstall() according to \p arg.
582 */
Eric Anholtc153f452007-09-03 12:06:45 +1000583int drm_control(struct drm_device *dev, void *data,
584 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Eric Anholtc153f452007-09-03 12:06:45 +1000586 struct drm_control *ctl = data;
Daniel Vettera319c1a2013-11-03 21:09:15 +0100587 int ret = 0, irq;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000588
Mario Kleiner27641c32010-10-23 04:20:23 +0200589 /* if we haven't irq we fallback for compatibility reasons -
590 * this used to be a separate function in drm_dma.h
591 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Daniel Vetter22471cf2013-11-03 20:02:50 +0100593 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
594 return 0;
595 if (drm_core_check_feature(dev, DRIVER_MODESET))
596 return 0;
Frank Binnsc78d1ca2016-06-24 11:15:37 +0100597 /* UMS was only ever supported on pci devices. */
Daniel Vetter22471cf2013-11-03 20:02:50 +0100598 if (WARN_ON(!dev->pdev))
599 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Eric Anholtc153f452007-09-03 12:06:45 +1000601 switch (ctl->func) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 case DRM_INST_HANDLER:
Daniel Vettera319c1a2013-11-03 21:09:15 +0100603 irq = dev->pdev->irq;
604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
Daniel Vettera319c1a2013-11-03 21:09:15 +0100606 ctl->irq != irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 return -EINVAL;
Daniel Vettere090c532013-11-03 20:27:05 +0100608 mutex_lock(&dev->struct_mutex);
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100609 ret = drm_irq_install(dev, irq);
Daniel Vettere090c532013-11-03 20:27:05 +0100610 mutex_unlock(&dev->struct_mutex);
611
612 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 case DRM_UNINST_HANDLER:
Daniel Vettere090c532013-11-03 20:27:05 +0100614 mutex_lock(&dev->struct_mutex);
615 ret = drm_irq_uninstall(dev);
616 mutex_unlock(&dev->struct_mutex);
617
618 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 default:
620 return -EINVAL;
621 }
622}
623
624/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200625 * drm_calc_timestamping_constants - calculate vblank timestamp constants
626 * @crtc: drm_crtc whose timestamp constants should be updated.
627 * @mode: display mode containing the scanout timings
Mario Kleiner27641c32010-10-23 04:20:23 +0200628 *
Ville Syrjälä21b21562013-10-26 17:22:52 +0300629 * Calculate and store various constants which are later
630 * needed by vblank and swap-completion timestamping, e.g,
631 * by drm_calc_vbltimestamp_from_scanoutpos(). They are
Daniel Vetterf5752b32014-05-08 16:41:51 +0200632 * derived from CRTC's true scanout timing, so they take
Ville Syrjälä21b21562013-10-26 17:22:52 +0300633 * things like panel scaling or other adjustments into account.
Mario Kleiner27641c32010-10-23 04:20:23 +0200634 */
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300635void drm_calc_timestamping_constants(struct drm_crtc *crtc,
636 const struct drm_display_mode *mode)
Mario Kleiner27641c32010-10-23 04:20:23 +0200637{
Ville Syrjälä0c545ac2015-11-12 14:34:18 +0200638 struct drm_device *dev = crtc->dev;
639 unsigned int pipe = drm_crtc_index(crtc);
640 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä20b20202015-09-14 22:43:45 +0300641 int linedur_ns = 0, framedur_ns = 0;
Ville Syrjälä77666b72013-10-27 21:22:58 +0200642 int dotclock = mode->crtc_clock;
Mario Kleiner27641c32010-10-23 04:20:23 +0200643
Ville Syrjälä0c545ac2015-11-12 14:34:18 +0200644 if (!dev->num_crtcs)
645 return;
646
647 if (WARN_ON(pipe >= dev->num_crtcs))
648 return;
649
Mario Kleiner27641c32010-10-23 04:20:23 +0200650 /* Valid dotclock? */
651 if (dotclock > 0) {
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300652 int frame_size = mode->crtc_htotal * mode->crtc_vtotal;
653
654 /*
655 * Convert scanline length in pixels and video
Ville Syrjälä20b20202015-09-14 22:43:45 +0300656 * dot clock to line duration and frame duration
657 * in nanoseconds:
Mario Kleiner27641c32010-10-23 04:20:23 +0200658 */
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300659 linedur_ns = div_u64((u64) mode->crtc_htotal * 1000000, dotclock);
660 framedur_ns = div_u64((u64) frame_size * 1000000, dotclock);
Ville Syrjäläc0ae24c2013-10-28 19:53:25 +0200661
662 /*
663 * Fields of interlaced scanout modes are only half a frame duration.
664 */
665 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
666 framedur_ns /= 2;
Mario Kleiner27641c32010-10-23 04:20:23 +0200667 } else
Thierry Redingcc1ef112015-08-12 17:00:31 +0200668 DRM_ERROR("crtc %u: Can't calculate constants, dotclock = 0!\n",
Mario Kleiner27641c32010-10-23 04:20:23 +0200669 crtc->base.id);
670
Ville Syrjäläeba1f352015-09-14 22:43:43 +0300671 vblank->linedur_ns = linedur_ns;
672 vblank->framedur_ns = framedur_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200673
Thierry Redingcc1ef112015-08-12 17:00:31 +0200674 DRM_DEBUG("crtc %u: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300675 crtc->base.id, mode->crtc_htotal,
676 mode->crtc_vtotal, mode->crtc_vdisplay);
Ville Syrjälä20b20202015-09-14 22:43:45 +0300677 DRM_DEBUG("crtc %u: clock %d kHz framedur %d linedur %d\n",
678 crtc->base.id, dotclock, framedur_ns, linedur_ns);
Mario Kleiner27641c32010-10-23 04:20:23 +0200679}
680EXPORT_SYMBOL(drm_calc_timestamping_constants);
681
682/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200683 * drm_calc_vbltimestamp_from_scanoutpos - precise vblank timestamp helper
684 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200685 * @pipe: index of CRTC whose vblank timestamp to retrieve
Daniel Vetterf5752b32014-05-08 16:41:51 +0200686 * @max_error: Desired maximum allowable error in timestamps (nanosecs)
687 * On return contains true maximum error of timestamp
688 * @vblank_time: Pointer to struct timeval which should receive the timestamp
689 * @flags: Flags to pass to driver:
690 * 0 = Default,
691 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
Daniel Vetterf5752b32014-05-08 16:41:51 +0200692 * @mode: mode which defines the scanout timings
693 *
694 * Implements calculation of exact vblank timestamps from given drm_display_mode
695 * timings and current video scanout position of a CRTC. This can be called from
696 * within get_vblank_timestamp() implementation of a kms driver to implement the
697 * actual timestamping.
Mario Kleiner27641c32010-10-23 04:20:23 +0200698 *
699 * Should return timestamps conforming to the OML_sync_control OpenML
700 * extension specification. The timestamp corresponds to the end of
701 * the vblank interval, aka start of scanout of topmost-leftmost display
702 * pixel in the following video frame.
703 *
704 * Requires support for optional dev->driver->get_scanout_position()
705 * in kms driver, plus a bit of setup code to provide a drm_display_mode
706 * that corresponds to the true scanout timing.
707 *
708 * The current implementation only handles standard video modes. It
709 * returns as no operation if a doublescan or interlaced video mode is
710 * active. Higher level code is expected to handle this.
711 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200712 * Returns:
713 * Negative value on error, failure or if not supported in current
Mario Kleiner27641c32010-10-23 04:20:23 +0200714 * video mode:
715 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200716 * -EINVAL - Invalid CRTC.
Mario Kleiner27641c32010-10-23 04:20:23 +0200717 * -EAGAIN - Temporary unavailable, e.g., called before initial modeset.
718 * -ENOTSUPP - Function not supported in current display mode.
719 * -EIO - Failed, e.g., due to failed scanout position query.
720 *
721 * Returns or'ed positive status flags on success:
722 *
723 * DRM_VBLANKTIME_SCANOUTPOS_METHOD - Signal this method used for timestamping.
724 * DRM_VBLANKTIME_INVBL - Timestamp taken while scanout was in vblank interval.
725 *
726 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200727int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
728 unsigned int pipe,
Mario Kleiner27641c32010-10-23 04:20:23 +0200729 int *max_error,
730 struct timeval *vblank_time,
731 unsigned flags,
Ville Syrjälä7da903e2013-10-26 17:57:31 +0300732 const struct drm_display_mode *mode)
Mario Kleiner27641c32010-10-23 04:20:23 +0200733{
Imre Deake62f2f52012-10-23 18:53:25 +0000734 struct timeval tv_etime;
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000735 ktime_t stime, etime;
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300736 unsigned int vbl_status;
737 int ret = DRM_VBLANKTIME_SCANOUTPOS_METHOD;
Mario Kleiner27641c32010-10-23 04:20:23 +0200738 int vpos, hpos, i;
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300739 int delta_ns, duration_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200740
Thierry Redingcc1ef112015-08-12 17:00:31 +0200741 if (pipe >= dev->num_crtcs) {
742 DRM_ERROR("Invalid crtc %u\n", pipe);
Mario Kleiner27641c32010-10-23 04:20:23 +0200743 return -EINVAL;
744 }
745
746 /* Scanout position query not supported? Should not happen. */
747 if (!dev->driver->get_scanout_position) {
748 DRM_ERROR("Called from driver w/o get_scanout_position()!?\n");
749 return -EIO;
750 }
751
Mario Kleiner27641c32010-10-23 04:20:23 +0200752 /* If mode timing undefined, just return as no-op:
753 * Happens during initial modesetting of a crtc.
754 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300755 if (mode->crtc_clock == 0) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200756 DRM_DEBUG("crtc %u: Noop due to uninitialized mode.\n", pipe);
Mario Kleiner27641c32010-10-23 04:20:23 +0200757 return -EAGAIN;
758 }
759
Mario Kleiner27641c32010-10-23 04:20:23 +0200760 /* Get current scanout position with system timestamp.
761 * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times
762 * if single query takes longer than max_error nanoseconds.
763 *
764 * This guarantees a tight bound on maximum error if
765 * code gets preempted or delayed for some reason.
766 */
767 for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) {
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100768 /*
769 * Get vertical and horizontal scanout position vpos, hpos,
770 * and bounding timestamps stime, etime, pre/post query.
771 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300772 vbl_status = dev->driver->get_scanout_position(dev, pipe, flags,
773 &vpos, &hpos,
774 &stime, &etime,
775 mode);
Mario Kleiner27641c32010-10-23 04:20:23 +0200776
Mario Kleiner27641c32010-10-23 04:20:23 +0200777 /* Return as no-op if scanout query unsupported or failed. */
778 if (!(vbl_status & DRM_SCANOUTPOS_VALID)) {
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300779 DRM_DEBUG("crtc %u : scanoutpos query failed [0x%x].\n",
Thierry Redingcc1ef112015-08-12 17:00:31 +0200780 pipe, vbl_status);
Mario Kleiner27641c32010-10-23 04:20:23 +0200781 return -EIO;
782 }
783
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100784 /* Compute uncertainty in timestamp of scanout position query. */
Imre Deake62f2f52012-10-23 18:53:25 +0000785 duration_ns = ktime_to_ns(etime) - ktime_to_ns(stime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200786
787 /* Accept result with < max_error nsecs timing uncertainty. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300788 if (duration_ns <= *max_error)
Mario Kleiner27641c32010-10-23 04:20:23 +0200789 break;
790 }
791
792 /* Noisy system timing? */
793 if (i == DRM_TIMESTAMP_MAXRETRIES) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200794 DRM_DEBUG("crtc %u: Noisy timestamp %d us > %d us [%d reps].\n",
795 pipe, duration_ns/1000, *max_error/1000, i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200796 }
797
798 /* Return upper bound of timestamp precision error. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300799 *max_error = duration_ns;
Mario Kleiner27641c32010-10-23 04:20:23 +0200800
801 /* Check if in vblank area:
802 * vpos is >=0 in video scanout area, but negative
803 * within vblank area, counting down the number of lines until
804 * start of scanout.
805 */
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300806 if (vbl_status & DRM_SCANOUTPOS_IN_VBLANK)
807 ret |= DRM_VBLANKTIME_IN_VBLANK;
Mario Kleiner27641c32010-10-23 04:20:23 +0200808
809 /* Convert scanout position into elapsed time at raw_time query
810 * since start of scanout at first display scanline. delta_ns
811 * can be negative if start of scanout hasn't happened yet.
812 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300813 delta_ns = div_s64(1000000LL * (vpos * mode->crtc_htotal + hpos),
814 mode->crtc_clock);
Mario Kleiner27641c32010-10-23 04:20:23 +0200815
Imre Deakc61eef72012-10-23 18:53:26 +0000816 if (!drm_timestamp_monotonic)
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000817 etime = ktime_mono_to_real(etime);
Imre Deakc61eef72012-10-23 18:53:26 +0000818
Imre Deake62f2f52012-10-23 18:53:25 +0000819 /* save this only for debugging purposes */
820 tv_etime = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200821 /* Subtract time delta from raw timestamp to get final
822 * vblank_time timestamp for end of vblank.
823 */
Daniel Vettera91d7b92016-03-29 13:12:22 +0200824 etime = ktime_sub_ns(etime, delta_ns);
Imre Deake62f2f52012-10-23 18:53:25 +0000825 *vblank_time = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200826
Ville Syrjälä235fabe2015-10-09 22:57:37 +0300827 DRM_DEBUG_VBL("crtc %u : v 0x%x p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n",
828 pipe, vbl_status, hpos, vpos,
829 (long)tv_etime.tv_sec, (long)tv_etime.tv_usec,
830 (long)vblank_time->tv_sec, (long)vblank_time->tv_usec,
831 duration_ns/1000, i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200832
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300833 return ret;
Mario Kleiner27641c32010-10-23 04:20:23 +0200834}
835EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
836
Imre Deakc61eef72012-10-23 18:53:26 +0000837static struct timeval get_drm_timestamp(void)
838{
839 ktime_t now;
840
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000841 now = drm_timestamp_monotonic ? ktime_get() : ktime_get_real();
Imre Deakc61eef72012-10-23 18:53:26 +0000842 return ktime_to_timeval(now);
843}
844
Mario Kleiner27641c32010-10-23 04:20:23 +0200845/**
846 * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent
Thierry Reding4dfd9092014-12-10 13:03:34 +0100847 * vblank interval
Mario Kleiner27641c32010-10-23 04:20:23 +0200848 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200849 * @pipe: index of CRTC whose vblank timestamp to retrieve
Mario Kleiner27641c32010-10-23 04:20:23 +0200850 * @tvblank: Pointer to target struct timeval which should receive the timestamp
851 * @flags: Flags to pass to driver:
Daniel Vetterf5752b32014-05-08 16:41:51 +0200852 * 0 = Default,
853 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
Mario Kleiner27641c32010-10-23 04:20:23 +0200854 *
855 * Fetches the system timestamp corresponding to the time of the most recent
Daniel Vetterf5752b32014-05-08 16:41:51 +0200856 * vblank interval on specified CRTC. May call into kms-driver to
Mario Kleiner27641c32010-10-23 04:20:23 +0200857 * compute the timestamp with a high-precision GPU specific method.
858 *
859 * Returns zero if timestamp originates from uncorrected do_gettimeofday()
860 * call, i.e., it isn't very precisely locked to the true vblank.
861 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200862 * Returns:
Daniel Vetterfb446a12014-09-10 17:36:10 +0200863 * True if timestamp is considered to be very precise, false otherwise.
Mario Kleiner27641c32010-10-23 04:20:23 +0200864 */
Daniel Vetterfb446a12014-09-10 17:36:10 +0200865static bool
Thierry Redingcc1ef112015-08-12 17:00:31 +0200866drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
Daniel Vetterfb446a12014-09-10 17:36:10 +0200867 struct timeval *tvblank, unsigned flags)
Mario Kleiner27641c32010-10-23 04:20:23 +0200868{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200869 int ret;
Mario Kleiner27641c32010-10-23 04:20:23 +0200870
871 /* Define requested maximum error on timestamps (nanoseconds). */
872 int max_error = (int) drm_timestamp_precision * 1000;
873
874 /* Query driver if possible and precision timestamping enabled. */
875 if (dev->driver->get_vblank_timestamp && (max_error > 0)) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200876 ret = dev->driver->get_vblank_timestamp(dev, pipe, &max_error,
Mario Kleiner27641c32010-10-23 04:20:23 +0200877 tvblank, flags);
878 if (ret > 0)
Daniel Vetterfb446a12014-09-10 17:36:10 +0200879 return true;
Mario Kleiner27641c32010-10-23 04:20:23 +0200880 }
881
882 /* GPU high precision timestamp query unsupported or failed.
Imre Deakc61eef72012-10-23 18:53:26 +0000883 * Return current monotonic/gettimeofday timestamp as best estimate.
Mario Kleiner27641c32010-10-23 04:20:23 +0200884 */
Imre Deakc61eef72012-10-23 18:53:26 +0000885 *tvblank = get_drm_timestamp();
Mario Kleiner27641c32010-10-23 04:20:23 +0200886
Daniel Vetterfb446a12014-09-10 17:36:10 +0200887 return false;
Mario Kleiner27641c32010-10-23 04:20:23 +0200888}
Mario Kleiner27641c32010-10-23 04:20:23 +0200889
890/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700891 * drm_vblank_count - retrieve "cooked" vblank counter value
892 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200893 * @pipe: index of CRTC for which to retrieve the counter
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700894 *
895 * Fetches the "cooked" vblank count value that represents the number of
896 * vblank events since the system was booted, including lost events due to
897 * modesetting activity.
Daniel Vetterf5752b32014-05-08 16:41:51 +0200898 *
Thierry Reding96d3f912014-12-16 13:08:47 +0100899 * This is the legacy version of drm_crtc_vblank_count().
900 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200901 * Returns:
902 * The software vblank counter.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700903 */
Thierry Reding88e72712015-09-24 18:35:31 +0200904u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700905{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200906 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300907
Thierry Redingcc1ef112015-08-12 17:00:31 +0200908 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -0400909 return 0;
Thierry Reding7d1de852015-08-12 17:00:30 +0200910
Daniel Vetter99264a62015-04-15 19:34:43 +0200911 return vblank->count;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700912}
913EXPORT_SYMBOL(drm_vblank_count);
914
915/**
Thierry Reding96d3f912014-12-16 13:08:47 +0100916 * drm_crtc_vblank_count - retrieve "cooked" vblank counter value
917 * @crtc: which counter to retrieve
918 *
919 * Fetches the "cooked" vblank count value that represents the number of
920 * vblank events since the system was booted, including lost events due to
921 * modesetting activity.
922 *
923 * This is the native KMS version of drm_vblank_count().
924 *
925 * Returns:
926 * The software vblank counter.
927 */
928u32 drm_crtc_vblank_count(struct drm_crtc *crtc)
929{
930 return drm_vblank_count(crtc->dev, drm_crtc_index(crtc));
931}
932EXPORT_SYMBOL(drm_crtc_vblank_count);
933
934/**
Thierry Redingcc1ef112015-08-12 17:00:31 +0200935 * drm_vblank_count_and_time - retrieve "cooked" vblank counter value and the
936 * system timestamp corresponding to that vblank counter value.
Mario Kleiner27641c32010-10-23 04:20:23 +0200937 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200938 * @pipe: index of CRTC whose counter to retrieve
Mario Kleiner27641c32010-10-23 04:20:23 +0200939 * @vblanktime: Pointer to struct timeval to receive the vblank timestamp.
940 *
941 * Fetches the "cooked" vblank count value that represents the number of
942 * vblank events since the system was booted, including lost events due to
943 * modesetting activity. Returns corresponding system timestamp of the time
Daniel Vetterf5752b32014-05-08 16:41:51 +0200944 * of the vblank interval that corresponds to the current vblank counter value.
Thierry Redingcf648302015-09-24 18:35:36 +0200945 *
946 * This is the legacy version of drm_crtc_vblank_count_and_time().
Mario Kleiner27641c32010-10-23 04:20:23 +0200947 */
Gustavo Padovan6e5f73f2016-07-04 21:04:47 -0300948static u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
949 struct timeval *vblanktime)
Mario Kleiner27641c32010-10-23 04:20:23 +0200950{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200951 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Matthew Auldd4055a92016-05-10 15:21:28 +0100952 u32 vblank_count;
953 unsigned int seq;
Mario Kleiner27641c32010-10-23 04:20:23 +0200954
Thierry Redingcc1ef112015-08-12 17:00:31 +0200955 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -0400956 return 0;
957
Mario Kleiner27641c32010-10-23 04:20:23 +0200958 do {
Matthew Auldd4055a92016-05-10 15:21:28 +0100959 seq = read_seqbegin(&vblank->seqlock);
960 vblank_count = vblank->count;
961 *vblanktime = vblank->time;
962 } while (read_seqretry(&vblank->seqlock, seq));
Mario Kleiner27641c32010-10-23 04:20:23 +0200963
Matthew Auldd4055a92016-05-10 15:21:28 +0100964 return vblank_count;
Mario Kleiner27641c32010-10-23 04:20:23 +0200965}
Mario Kleiner27641c32010-10-23 04:20:23 +0200966
Thierry Redingcf648302015-09-24 18:35:36 +0200967/**
968 * drm_crtc_vblank_count_and_time - retrieve "cooked" vblank counter value
969 * and the system timestamp corresponding to that vblank counter value
970 * @crtc: which counter to retrieve
971 * @vblanktime: Pointer to struct timeval to receive the vblank timestamp.
972 *
973 * Fetches the "cooked" vblank count value that represents the number of
974 * vblank events since the system was booted, including lost events due to
975 * modesetting activity. Returns corresponding system timestamp of the time
976 * of the vblank interval that corresponds to the current vblank counter value.
Thierry Redingcf648302015-09-24 18:35:36 +0200977 */
978u32 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
979 struct timeval *vblanktime)
980{
981 return drm_vblank_count_and_time(crtc->dev, drm_crtc_index(crtc),
982 vblanktime);
983}
984EXPORT_SYMBOL(drm_crtc_vblank_count_and_time);
985
Rob Clarkc6eefa12012-10-16 22:48:40 +0000986static void send_vblank_event(struct drm_device *dev,
987 struct drm_pending_vblank_event *e,
988 unsigned long seq, struct timeval *now)
989{
Rob Clarkc6eefa12012-10-16 22:48:40 +0000990 e->event.sequence = seq;
991 e->event.tv_sec = now->tv_sec;
992 e->event.tv_usec = now->tv_usec;
993
Rob Clarkc6eefa12012-10-16 22:48:40 +0000994 trace_drm_vblank_event_delivered(e->base.pid, e->pipe,
995 e->event.sequence);
Matthew Auldc001da42016-06-20 17:42:46 +0100996
997 drm_send_event_locked(dev, &e->base);
Rob Clarkc6eefa12012-10-16 22:48:40 +0000998}
999
1000/**
Daniel Vetterbbc87642015-11-10 17:37:31 +01001001 * drm_crtc_arm_vblank_event - arm vblank event after pageflip
1002 * @crtc: the source CRTC of the vblank event
1003 * @e: the event to send
1004 *
1005 * A lot of drivers need to generate vblank events for the very next vblank
1006 * interrupt. For example when the page flip interrupt happens when the page
1007 * flip gets armed, but not when it actually executes within the next vblank
1008 * period. This helper function implements exactly the required vblank arming
1009 * behaviour.
1010 *
1011 * Caller must hold event lock. Caller must also hold a vblank reference for
1012 * the event @e, which will be dropped when the next vblank arrives.
Daniel Vetterbbc87642015-11-10 17:37:31 +01001013 */
1014void drm_crtc_arm_vblank_event(struct drm_crtc *crtc,
1015 struct drm_pending_vblank_event *e)
1016{
Gustavo Padovan93507d12016-06-07 11:07:55 -03001017 struct drm_device *dev = crtc->dev;
1018 unsigned int pipe = drm_crtc_index(crtc);
1019
1020 assert_spin_locked(&dev->event_lock);
1021
1022 e->pipe = pipe;
1023 e->event.sequence = drm_vblank_count(dev, pipe);
1024 list_add_tail(&e->base.link, &dev->vblank_event_list);
Daniel Vetterbbc87642015-11-10 17:37:31 +01001025}
1026EXPORT_SYMBOL(drm_crtc_arm_vblank_event);
1027
1028/**
Gustavo Padovandb749b72016-06-07 11:07:54 -03001029 * drm_crtc_send_vblank_event - helper to send vblank event after pageflip
1030 * @crtc: the source CRTC of the vblank event
Rob Clarkc6eefa12012-10-16 22:48:40 +00001031 * @e: the event to send
1032 *
1033 * Updates sequence # and timestamp on event, and sends it to userspace.
1034 * Caller must hold event lock.
1035 */
Gustavo Padovandb749b72016-06-07 11:07:54 -03001036void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
1037 struct drm_pending_vblank_event *e)
Rob Clarkc6eefa12012-10-16 22:48:40 +00001038{
Gustavo Padovandb749b72016-06-07 11:07:54 -03001039 struct drm_device *dev = crtc->dev;
1040 unsigned int seq, pipe = drm_crtc_index(crtc);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001041 struct timeval now;
Thierry Reding4dfd9092014-12-10 13:03:34 +01001042
Thierry Reding2a7d3d62015-08-12 17:00:24 +02001043 if (dev->num_crtcs > 0) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001044 seq = drm_vblank_count_and_time(dev, pipe, &now);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001045 } else {
1046 seq = 0;
Imre Deakc61eef72012-10-23 18:53:26 +00001047
1048 now = get_drm_timestamp();
Rob Clarkc6eefa12012-10-16 22:48:40 +00001049 }
Thierry Redingcc1ef112015-08-12 17:00:31 +02001050 e->pipe = pipe;
Rob Clarkc6eefa12012-10-16 22:48:40 +00001051 send_vblank_event(dev, e, seq, &now);
1052}
Thierry Redinga4d7b302014-12-15 14:47:18 +01001053EXPORT_SYMBOL(drm_crtc_send_vblank_event);
1054
1055/**
Ville Syrjäläf2752282014-02-19 21:29:49 +02001056 * drm_vblank_enable - enable the vblank interrupt on a CRTC
1057 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001058 * @pipe: CRTC index
Thierry Redingc30e11f2015-08-12 17:00:33 +02001059 *
1060 * Returns:
1061 * Zero on success or a negative error code on failure.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001062 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001063static int drm_vblank_enable(struct drm_device *dev, unsigned int pipe)
Ville Syrjäläf2752282014-02-19 21:29:49 +02001064{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001065 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001066 int ret = 0;
1067
1068 assert_spin_locked(&dev->vbl_lock);
1069
1070 spin_lock(&dev->vblank_time_lock);
1071
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001072 if (!vblank->enabled) {
Daniel Vetter1cfb80b2014-05-21 15:11:33 +02001073 /*
1074 * Enable vblank irqs under vblank_time_lock protection.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001075 * All vblank count & timestamp updates are held off
1076 * until we are done reinitializing master counter and
1077 * timestamps. Filtercode in drm_handle_vblank() will
1078 * prevent double-accounting of same vblank interval.
1079 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001080 ret = dev->driver->enable_vblank(dev, pipe);
1081 DRM_DEBUG("enabling vblank on crtc %u, ret: %d\n", pipe, ret);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001082 if (ret)
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001083 atomic_dec(&vblank->refcount);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001084 else {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001085 vblank->enabled = true;
Ville Syrjäläa6e610d2015-09-14 22:43:47 +03001086 drm_update_vblank_count(dev, pipe, 0);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001087 }
1088 }
1089
1090 spin_unlock(&dev->vblank_time_lock);
1091
1092 return ret;
1093}
1094
1095/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001096 * drm_vblank_get - get a reference count on vblank events
1097 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001098 * @pipe: index of CRTC to own
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001099 *
1100 * Acquire a reference count on vblank events to avoid having them disabled
1101 * while in use.
1102 *
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001103 * This is the legacy version of drm_crtc_vblank_get().
1104 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001105 * Returns:
Thierry Redingc30e11f2015-08-12 17:00:33 +02001106 * Zero on success or a negative error code on failure.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001107 */
Gustavo Padovanceb74152016-06-07 11:07:56 -03001108static int drm_vblank_get(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001109{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001110 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Peter Hurley97cbc882013-08-20 21:51:12 -04001111 unsigned long irqflags;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001112 int ret = 0;
1113
Gerd Hoffmann16e32472015-03-30 12:50:50 +02001114 if (!dev->num_crtcs)
1115 return -EINVAL;
1116
Thierry Redingcc1ef112015-08-12 17:00:31 +02001117 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001118 return -EINVAL;
1119
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001120 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1121 /* Going from 0->1 means we have to enable interrupts again */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001122 if (atomic_add_return(1, &vblank->refcount) == 1) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001123 ret = drm_vblank_enable(dev, pipe);
Li Peng778c9022009-11-09 12:51:22 +08001124 } else {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001125 if (!vblank->enabled) {
1126 atomic_dec(&vblank->refcount);
Li Peng778c9022009-11-09 12:51:22 +08001127 ret = -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001128 }
1129 }
1130 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1131
1132 return ret;
1133}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001134
1135/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001136 * drm_crtc_vblank_get - get a reference count on vblank events
1137 * @crtc: which CRTC to own
1138 *
1139 * Acquire a reference count on vblank events to avoid having them disabled
1140 * while in use.
1141 *
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001142 * Returns:
Thierry Redingc30e11f2015-08-12 17:00:33 +02001143 * Zero on success or a negative error code on failure.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001144 */
1145int drm_crtc_vblank_get(struct drm_crtc *crtc)
1146{
1147 return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
1148}
1149EXPORT_SYMBOL(drm_crtc_vblank_get);
1150
1151/**
Thierry Redingcc1ef112015-08-12 17:00:31 +02001152 * drm_vblank_put - release ownership of vblank events
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001153 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001154 * @pipe: index of CRTC to release
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001155 *
1156 * Release ownership of a given vblank counter, turning off interrupts
Mario Kleiner27641c32010-10-23 04:20:23 +02001157 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001158 *
1159 * This is the legacy version of drm_crtc_vblank_put().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001160 */
Gustavo Padovanceb74152016-06-07 11:07:56 -03001161static void drm_vblank_put(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001162{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001163 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001164
Thierry Redingcc1ef112015-08-12 17:00:31 +02001165 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clark7f907bf22014-11-08 10:16:19 -05001166 return;
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001167
Thierry Reding7d1de852015-08-12 17:00:30 +02001168 if (WARN_ON(atomic_read(&vblank->refcount) == 0))
Rob Clarke6ae8682014-08-06 13:16:59 -04001169 return;
1170
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001171 /* Last user schedules interrupt disable */
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001172 if (atomic_dec_and_test(&vblank->refcount)) {
Daniel Vetterab8905f12014-09-10 17:36:08 +02001173 if (drm_vblank_offdelay == 0)
1174 return;
1175 else if (dev->vblank_disable_immediate || drm_vblank_offdelay < 0)
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001176 vblank_disable_fn((unsigned long)vblank);
Daniel Vetterab8905f12014-09-10 17:36:08 +02001177 else
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001178 mod_timer(&vblank->disable_timer,
1179 jiffies + ((drm_vblank_offdelay * HZ)/1000));
1180 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001181}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001182
Rob Clarkc6eefa12012-10-16 22:48:40 +00001183/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001184 * drm_crtc_vblank_put - give up ownership of vblank events
1185 * @crtc: which counter to give up
1186 *
1187 * Release ownership of a given vblank counter, turning off interrupts
1188 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001189 */
1190void drm_crtc_vblank_put(struct drm_crtc *crtc)
1191{
1192 drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
1193}
1194EXPORT_SYMBOL(drm_crtc_vblank_put);
1195
1196/**
Daniel Vettere8450f52014-07-25 23:34:03 +02001197 * drm_wait_one_vblank - wait for one vblank
1198 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001199 * @pipe: CRTC index
Daniel Vettere8450f52014-07-25 23:34:03 +02001200 *
Ville Syrjälä1da248a2015-09-14 22:43:42 +03001201 * This waits for one vblank to pass on @pipe, using the irq driver interfaces.
1202 * It is a failure to call this when the vblank irq for @pipe is disabled, e.g.
Daniel Vettere8450f52014-07-25 23:34:03 +02001203 * due to lack of driver support or because the crtc is off.
1204 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001205void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe)
Daniel Vettere8450f52014-07-25 23:34:03 +02001206{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001207 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vettere8450f52014-07-25 23:34:03 +02001208 int ret;
1209 u32 last;
1210
Thierry Redingcc1ef112015-08-12 17:00:31 +02001211 if (WARN_ON(pipe >= dev->num_crtcs))
Thierry Reding7d1de852015-08-12 17:00:30 +02001212 return;
1213
Thierry Redingcc1ef112015-08-12 17:00:31 +02001214 ret = drm_vblank_get(dev, pipe);
1215 if (WARN(ret, "vblank not available on crtc %i, ret=%i\n", pipe, ret))
Daniel Vettere8450f52014-07-25 23:34:03 +02001216 return;
1217
Thierry Redingcc1ef112015-08-12 17:00:31 +02001218 last = drm_vblank_count(dev, pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001219
Thierry Redingcc1ef112015-08-12 17:00:31 +02001220 ret = wait_event_timeout(vblank->queue,
1221 last != drm_vblank_count(dev, pipe),
Daniel Vettere8450f52014-07-25 23:34:03 +02001222 msecs_to_jiffies(100));
1223
Thierry Redingcc1ef112015-08-12 17:00:31 +02001224 WARN(ret == 0, "vblank wait timed out on crtc %i\n", pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001225
Thierry Redingcc1ef112015-08-12 17:00:31 +02001226 drm_vblank_put(dev, pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001227}
1228EXPORT_SYMBOL(drm_wait_one_vblank);
1229
1230/**
1231 * drm_crtc_wait_one_vblank - wait for one vblank
1232 * @crtc: DRM crtc
1233 *
1234 * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
1235 * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
1236 * due to lack of driver support or because the crtc is off.
1237 */
1238void drm_crtc_wait_one_vblank(struct drm_crtc *crtc)
1239{
1240 drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
1241}
1242EXPORT_SYMBOL(drm_crtc_wait_one_vblank);
1243
1244/**
Rob Clarkc6eefa12012-10-16 22:48:40 +00001245 * drm_vblank_off - disable vblank events on a CRTC
1246 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001247 * @pipe: CRTC index
Rob Clarkc6eefa12012-10-16 22:48:40 +00001248 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001249 * Drivers can use this function to shut down the vblank interrupt handling when
1250 * disabling a crtc. This function ensures that the latest vblank frame count is
1251 * stored so that drm_vblank_on() can restore it again.
1252 *
1253 * Drivers must use this function when the hardware vblank counter can get
1254 * reset, e.g. when suspending.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001255 *
1256 * This is the legacy version of drm_crtc_vblank_off().
Rob Clarkc6eefa12012-10-16 22:48:40 +00001257 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001258void drm_vblank_off(struct drm_device *dev, unsigned int pipe)
Li Peng778c9022009-11-09 12:51:22 +08001259{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001260 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001261 struct drm_pending_vblank_event *e, *t;
1262 struct timeval now;
Li Peng778c9022009-11-09 12:51:22 +08001263 unsigned long irqflags;
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001264 unsigned int seq;
Li Peng778c9022009-11-09 12:51:22 +08001265
Thierry Redingcc1ef112015-08-12 17:00:31 +02001266 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001267 return;
1268
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001269 spin_lock_irqsave(&dev->event_lock, irqflags);
1270
1271 spin_lock(&dev->vbl_lock);
Mario Kleinere8235892016-02-12 20:30:27 +01001272 DRM_DEBUG_VBL("crtc %d, vblank enabled %d, inmodeset %d\n",
1273 pipe, vblank->enabled, vblank->inmodeset);
1274
1275 /* Avoid redundant vblank disables without previous drm_vblank_on(). */
1276 if (drm_core_check_feature(dev, DRIVER_ATOMIC) || !vblank->inmodeset)
1277 vblank_disable_and_save(dev, pipe);
1278
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001279 wake_up(&vblank->queue);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001280
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001281 /*
1282 * Prevent subsequent drm_vblank_get() from re-enabling
1283 * the vblank interrupt by bumping the refcount.
1284 */
1285 if (!vblank->inmodeset) {
1286 atomic_inc(&vblank->refcount);
1287 vblank->inmodeset = 1;
1288 }
1289 spin_unlock(&dev->vbl_lock);
1290
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001291 /* Send any queued vblank events, lest the natives grow disquiet */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001292 seq = drm_vblank_count_and_time(dev, pipe, &now);
Imre Deake7783ba2012-11-02 13:30:50 +02001293
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001294 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001295 if (e->pipe != pipe)
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001296 continue;
Ville Syrjälä44844892015-10-09 22:57:36 +03001297 DRM_DEBUG("Sending premature vblank event on disable: "
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001298 "wanted %u, current %u\n",
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001299 e->event.sequence, seq);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001300 list_del(&e->base.link);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001301 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001302 send_vblank_event(dev, e, seq, &now);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001303 }
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001304 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Li Peng778c9022009-11-09 12:51:22 +08001305}
1306EXPORT_SYMBOL(drm_vblank_off);
1307
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001308/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001309 * drm_crtc_vblank_off - disable vblank events on a CRTC
1310 * @crtc: CRTC in question
1311 *
1312 * Drivers can use this function to shut down the vblank interrupt handling when
1313 * disabling a crtc. This function ensures that the latest vblank frame count is
1314 * stored so that drm_vblank_on can restore it again.
1315 *
1316 * Drivers must use this function when the hardware vblank counter can get
1317 * reset, e.g. when suspending.
1318 *
1319 * This is the native kms version of drm_vblank_off().
1320 */
1321void drm_crtc_vblank_off(struct drm_crtc *crtc)
1322{
1323 drm_vblank_off(crtc->dev, drm_crtc_index(crtc));
1324}
1325EXPORT_SYMBOL(drm_crtc_vblank_off);
1326
1327/**
Daniel Vetter96256042015-02-13 21:03:42 +01001328 * drm_crtc_vblank_reset - reset vblank state to off on a CRTC
Thierry Reding2b193f02015-09-24 18:35:30 +02001329 * @crtc: CRTC in question
Daniel Vetter96256042015-02-13 21:03:42 +01001330 *
1331 * Drivers can use this function to reset the vblank state to off at load time.
1332 * Drivers should use this together with the drm_crtc_vblank_off() and
1333 * drm_crtc_vblank_on() functions. The difference compared to
1334 * drm_crtc_vblank_off() is that this function doesn't save the vblank counter
1335 * and hence doesn't need to call any driver hooks.
1336 */
Thierry Reding2b193f02015-09-24 18:35:30 +02001337void drm_crtc_vblank_reset(struct drm_crtc *crtc)
Daniel Vetter96256042015-02-13 21:03:42 +01001338{
Thierry Reding2b193f02015-09-24 18:35:30 +02001339 struct drm_device *dev = crtc->dev;
Daniel Vetter96256042015-02-13 21:03:42 +01001340 unsigned long irqflags;
Thierry Reding2b193f02015-09-24 18:35:30 +02001341 unsigned int pipe = drm_crtc_index(crtc);
Ville Syrjälä1da248a2015-09-14 22:43:42 +03001342 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter96256042015-02-13 21:03:42 +01001343
1344 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1345 /*
1346 * Prevent subsequent drm_vblank_get() from enabling the vblank
1347 * interrupt by bumping the refcount.
1348 */
1349 if (!vblank->inmodeset) {
1350 atomic_inc(&vblank->refcount);
1351 vblank->inmodeset = 1;
1352 }
1353 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1354
1355 WARN_ON(!list_empty(&dev->vblank_event_list));
1356}
1357EXPORT_SYMBOL(drm_crtc_vblank_reset);
1358
1359/**
Ville Syrjäläf2752282014-02-19 21:29:49 +02001360 * drm_vblank_on - enable vblank events on a CRTC
1361 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001362 * @pipe: CRTC index
Daniel Vetterf5752b32014-05-08 16:41:51 +02001363 *
1364 * This functions restores the vblank interrupt state captured with
1365 * drm_vblank_off() again. Note that calls to drm_vblank_on() and
Masanari Iida32197aa2014-10-20 23:53:13 +09001366 * drm_vblank_off() can be unbalanced and so can also be unconditionally called
Daniel Vetterf5752b32014-05-08 16:41:51 +02001367 * in driver load code to reflect the current hardware state of the crtc.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001368 *
1369 * This is the legacy version of drm_crtc_vblank_on().
Ville Syrjäläf2752282014-02-19 21:29:49 +02001370 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001371void drm_vblank_on(struct drm_device *dev, unsigned int pipe)
Ville Syrjäläf2752282014-02-19 21:29:49 +02001372{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001373 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001374 unsigned long irqflags;
1375
Thierry Redingcc1ef112015-08-12 17:00:31 +02001376 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001377 return;
1378
Ville Syrjäläf2752282014-02-19 21:29:49 +02001379 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Mario Kleinere8235892016-02-12 20:30:27 +01001380 DRM_DEBUG_VBL("crtc %d, vblank enabled %d, inmodeset %d\n",
1381 pipe, vblank->enabled, vblank->inmodeset);
1382
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001383 /* Drop our private "prevent drm_vblank_get" refcount */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001384 if (vblank->inmodeset) {
1385 atomic_dec(&vblank->refcount);
1386 vblank->inmodeset = 0;
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001387 }
Ville Syrjäläf8ad0282014-08-06 14:49:49 +03001388
Ville Syrjälä4dfd6482015-09-14 22:43:51 +03001389 drm_reset_vblank_timestamp(dev, pipe);
1390
Ville Syrjäläcd19e522014-08-06 14:49:56 +03001391 /*
1392 * re-enable interrupts if there are users left, or the
1393 * user wishes vblank interrupts to be enabled all the time.
1394 */
Mario Kleinerbb74fc12016-02-12 20:30:30 +01001395 if (atomic_read(&vblank->refcount) != 0 || drm_vblank_offdelay == 0)
Thierry Redingcc1ef112015-08-12 17:00:31 +02001396 WARN_ON(drm_vblank_enable(dev, pipe));
Ville Syrjäläf2752282014-02-19 21:29:49 +02001397 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1398}
1399EXPORT_SYMBOL(drm_vblank_on);
1400
1401/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001402 * drm_crtc_vblank_on - enable vblank events on a CRTC
1403 * @crtc: CRTC in question
1404 *
1405 * This functions restores the vblank interrupt state captured with
1406 * drm_vblank_off() again. Note that calls to drm_vblank_on() and
Masanari Iida32197aa2014-10-20 23:53:13 +09001407 * drm_vblank_off() can be unbalanced and so can also be unconditionally called
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001408 * in driver load code to reflect the current hardware state of the crtc.
1409 *
1410 * This is the native kms version of drm_vblank_on().
1411 */
1412void drm_crtc_vblank_on(struct drm_crtc *crtc)
1413{
1414 drm_vblank_on(crtc->dev, drm_crtc_index(crtc));
1415}
1416EXPORT_SYMBOL(drm_crtc_vblank_on);
1417
1418/**
Dave Airlief453ba02008-11-07 14:05:41 -08001419 * drm_vblank_pre_modeset - account for vblanks across mode sets
1420 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001421 * @pipe: CRTC index
Dave Airlief453ba02008-11-07 14:05:41 -08001422 *
1423 * Account for vblank events across mode setting events, which will likely
1424 * reset the hardware frame counter.
Daniel Vetterf5752b32014-05-08 16:41:51 +02001425 *
1426 * This is done by grabbing a temporary vblank reference to ensure that the
1427 * vblank interrupt keeps running across the modeset sequence. With this the
1428 * software-side vblank frame counting will ensure that there are no jumps or
1429 * discontinuities.
1430 *
1431 * Unfortunately this approach is racy and also doesn't work when the vblank
1432 * interrupt stops running, e.g. across system suspend resume. It is therefore
1433 * highly recommended that drivers use the newer drm_vblank_off() and
1434 * drm_vblank_on() instead. drm_vblank_pre_modeset() only works correctly when
1435 * using "cooked" software vblank frame counters and not relying on any hardware
1436 * counters.
1437 *
1438 * Drivers must call drm_vblank_post_modeset() when re-enabling the same crtc
1439 * again.
Dave Airlief453ba02008-11-07 14:05:41 -08001440 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001441void drm_vblank_pre_modeset(struct drm_device *dev, unsigned int pipe)
Dave Airlief453ba02008-11-07 14:05:41 -08001442{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001443 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001444
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001445 /* vblank is not initialized (IRQ not installed ?), or has been freed */
Jerome Glissee77cef92010-01-07 15:39:13 +01001446 if (!dev->num_crtcs)
1447 return;
Rob Clarke6ae8682014-08-06 13:16:59 -04001448
Thierry Redingcc1ef112015-08-12 17:00:31 +02001449 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001450 return;
1451
Dave Airlief453ba02008-11-07 14:05:41 -08001452 /*
1453 * To avoid all the problems that might happen if interrupts
1454 * were enabled/disabled around or between these calls, we just
1455 * have the kernel take a reference on the CRTC (just once though
1456 * to avoid corrupting the count if multiple, mismatch calls occur),
1457 * so that interrupts remain enabled in the interim.
1458 */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001459 if (!vblank->inmodeset) {
1460 vblank->inmodeset = 0x1;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001461 if (drm_vblank_get(dev, pipe) == 0)
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001462 vblank->inmodeset |= 0x2;
Dave Airlief453ba02008-11-07 14:05:41 -08001463 }
1464}
1465EXPORT_SYMBOL(drm_vblank_pre_modeset);
1466
Daniel Vetterf5752b32014-05-08 16:41:51 +02001467/**
1468 * drm_vblank_post_modeset - undo drm_vblank_pre_modeset changes
1469 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001470 * @pipe: CRTC index
Daniel Vetterf5752b32014-05-08 16:41:51 +02001471 *
1472 * This function again drops the temporary vblank reference acquired in
1473 * drm_vblank_pre_modeset.
1474 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001475void drm_vblank_post_modeset(struct drm_device *dev, unsigned int pipe)
Dave Airlief453ba02008-11-07 14:05:41 -08001476{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001477 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Dave Airlief453ba02008-11-07 14:05:41 -08001478 unsigned long irqflags;
1479
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001480 /* vblank is not initialized (IRQ not installed ?), or has been freed */
1481 if (!dev->num_crtcs)
1482 return;
1483
Thierry Redingcc1ef112015-08-12 17:00:31 +02001484 if (WARN_ON(pipe >= dev->num_crtcs))
Thierry Reding7d1de852015-08-12 17:00:30 +02001485 return;
1486
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001487 if (vblank->inmodeset) {
Dave Airlief453ba02008-11-07 14:05:41 -08001488 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Mario Kleinerc61934e2016-02-12 20:30:29 +01001489 drm_reset_vblank_timestamp(dev, pipe);
Dave Airlief453ba02008-11-07 14:05:41 -08001490 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001491
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001492 if (vblank->inmodeset & 0x2)
Thierry Redingcc1ef112015-08-12 17:00:31 +02001493 drm_vblank_put(dev, pipe);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001494
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001495 vblank->inmodeset = 0;
Dave Airlief453ba02008-11-07 14:05:41 -08001496 }
1497}
1498EXPORT_SYMBOL(drm_vblank_post_modeset);
1499
Daniel Vetterf5752b32014-05-08 16:41:51 +02001500/*
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001501 * drm_modeset_ctl - handle vblank event counter changes across mode switch
1502 * @DRM_IOCTL_ARGS: standard ioctl arguments
1503 *
1504 * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
1505 * ioctls around modesetting so that any lost vblank events are accounted for.
1506 *
1507 * Generally the counter will reset across mode sets. If interrupts are
1508 * enabled around this call, we don't have to do anything since the counter
1509 * will have already been incremented.
1510 */
1511int drm_modeset_ctl(struct drm_device *dev, void *data,
1512 struct drm_file *file_priv)
1513{
1514 struct drm_modeset_ctl *modeset = data;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001515 unsigned int pipe;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001516
1517 /* If drm_vblank_init() hasn't been called yet, just no-op */
1518 if (!dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001519 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001520
Laurent Pinchart29935552012-05-30 00:58:09 +02001521 /* KMS drivers handle this internally */
1522 if (drm_core_check_feature(dev, DRIVER_MODESET))
1523 return 0;
1524
Thierry Redingcc1ef112015-08-12 17:00:31 +02001525 pipe = modeset->crtc;
1526 if (pipe >= dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001527 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001528
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001529 switch (modeset->cmd) {
1530 case _DRM_PRE_MODESET:
Thierry Redingcc1ef112015-08-12 17:00:31 +02001531 drm_vblank_pre_modeset(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001532 break;
1533 case _DRM_POST_MODESET:
Thierry Redingcc1ef112015-08-12 17:00:31 +02001534 drm_vblank_post_modeset(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001535 break;
1536 default:
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001537 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001538 }
1539
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001540 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001541}
1542
Thierry Redingcc1ef112015-08-12 17:00:31 +02001543static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe,
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001544 union drm_wait_vblank *vblwait,
1545 struct drm_file *file_priv)
1546{
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001547 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001548 struct drm_pending_vblank_event *e;
1549 struct timeval now;
1550 unsigned long flags;
1551 unsigned int seq;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001552 int ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001553
Thierry Redingf76511b2014-12-10 13:03:40 +01001554 e = kzalloc(sizeof(*e), GFP_KERNEL);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001555 if (e == NULL) {
1556 ret = -ENOMEM;
1557 goto err_put;
1558 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001559
1560 e->pipe = pipe;
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001561 e->base.pid = current->pid;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001562 e->event.base.type = DRM_EVENT_VBLANK;
Thierry Redingf76511b2014-12-10 13:03:40 +01001563 e->event.base.length = sizeof(e->event);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001564 e->event.user_data = vblwait->request.signal;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001565
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001566 spin_lock_irqsave(&dev->event_lock, flags);
1567
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001568 /*
1569 * drm_vblank_off() might have been called after we called
1570 * drm_vblank_get(). drm_vblank_off() holds event_lock
1571 * around the vblank disable, so no need for further locking.
1572 * The reference from drm_vblank_get() protects against
1573 * vblank disable from another source.
1574 */
1575 if (!vblank->enabled) {
1576 ret = -EINVAL;
1577 goto err_unlock;
1578 }
1579
Daniel Vetter4020b222016-01-28 12:01:04 +01001580 ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
1581 &e->event.base);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001582
Daniel Vetter4020b222016-01-28 12:01:04 +01001583 if (ret)
1584 goto err_unlock;
1585
Mario Kleiner27641c32010-10-23 04:20:23 +02001586 seq = drm_vblank_count_and_time(dev, pipe, &now);
1587
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001588 DRM_DEBUG("event on vblank count %u, current %u, crtc %u\n",
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001589 vblwait->request.sequence, seq, pipe);
1590
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001591 trace_drm_vblank_event_queued(current->pid, pipe,
1592 vblwait->request.sequence);
1593
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001594 e->event.sequence = vblwait->request.sequence;
1595 if ((seq - vblwait->request.sequence) <= (1 << 23)) {
Dan Carpenter6f331622010-12-09 08:35:40 +03001596 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001597 send_vblank_event(dev, e, seq, &now);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001598 vblwait->reply.sequence = seq;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001599 } else {
Ilija Hadzica6778e92011-10-31 13:11:57 -04001600 /* drm_handle_vblank_events will call drm_vblank_put */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001601 list_add_tail(&e->base.link, &dev->vblank_event_list);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001602 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001603 }
1604
1605 spin_unlock_irqrestore(&dev->event_lock, flags);
1606
1607 return 0;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001608
1609err_unlock:
1610 spin_unlock_irqrestore(&dev->event_lock, flags);
1611 kfree(e);
1612err_put:
Dan Carpenter6f331622010-12-09 08:35:40 +03001613 drm_vblank_put(dev, pipe);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001614 return ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001615}
1616
Daniel Vetterf5752b32014-05-08 16:41:51 +02001617/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 * Wait for VBLANK.
1619 *
1620 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001621 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 * \param cmd command.
1623 * \param data user argument, pointing to a drm_wait_vblank structure.
1624 * \return zero on success or a negative number on failure.
1625 *
Eric Anholt30b23632009-01-27 21:19:41 -08001626 * This function enables the vblank interrupt on the pipe requested, then
1627 * sleeps waiting for the requested sequence number to occur, and drops
Daniel Vetterf5752b32014-05-08 16:41:51 +02001628 * the vblank interrupt refcount afterwards. (vblank IRQ disable follows that
Eric Anholt30b23632009-01-27 21:19:41 -08001629 * after a timeout with no further vblank waits scheduled).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 */
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001631int drm_wait_vblank(struct drm_device *dev, void *data,
1632 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001634 struct drm_vblank_crtc *vblank;
Eric Anholtc153f452007-09-03 12:06:45 +10001635 union drm_wait_vblank *vblwait = data;
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001636 int ret;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001637 unsigned int flags, seq, pipe, high_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Daniel Vetter49849792013-08-28 15:02:37 +02001639 if (!dev->irq_enabled)
1640 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
Eric Anholt30b23632009-01-27 21:19:41 -08001642 if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
1643 return -EINVAL;
1644
Eric Anholtc153f452007-09-03 12:06:45 +10001645 if (vblwait->request.type &
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001646 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1647 _DRM_VBLANK_HIGH_CRTC_MASK)) {
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001648 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
Eric Anholtc153f452007-09-03 12:06:45 +10001649 vblwait->request.type,
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001650 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1651 _DRM_VBLANK_HIGH_CRTC_MASK));
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001652 return -EINVAL;
1653 }
1654
Eric Anholtc153f452007-09-03 12:06:45 +10001655 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001656 high_pipe = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK);
1657 if (high_pipe)
1658 pipe = high_pipe >> _DRM_VBLANK_HIGH_CRTC_SHIFT;
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001659 else
Thierry Redingcc1ef112015-08-12 17:00:31 +02001660 pipe = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
1661 if (pipe >= dev->num_crtcs)
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001662 return -EINVAL;
1663
Thierry Redingcc1ef112015-08-12 17:00:31 +02001664 vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001665
Thierry Redingcc1ef112015-08-12 17:00:31 +02001666 ret = drm_vblank_get(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001667 if (ret) {
Paul Rolland8d3457e2009-08-09 12:24:01 +10001668 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001669 return ret;
1670 }
Thierry Redingcc1ef112015-08-12 17:00:31 +02001671 seq = drm_vblank_count(dev, pipe);
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001672
Eric Anholtc153f452007-09-03 12:06:45 +10001673 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 case _DRM_VBLANK_RELATIVE:
Eric Anholtc153f452007-09-03 12:06:45 +10001675 vblwait->request.sequence += seq;
1676 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 case _DRM_VBLANK_ABSOLUTE:
1678 break;
1679 default:
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001680 ret = -EINVAL;
1681 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 }
1683
Michel Dänzer97ef1ae2016-06-24 16:59:47 +09001684 if ((flags & _DRM_VBLANK_NEXTONMISS) &&
1685 (seq - vblwait->request.sequence) <= (1 << 23)) {
1686 vblwait->request.sequence = seq + 1;
1687 }
1688
Ilija Hadzica6778e92011-10-31 13:11:57 -04001689 if (flags & _DRM_VBLANK_EVENT) {
1690 /* must hold on to the vblank ref until the event fires
1691 * drm_vblank_put will be called asynchronously
1692 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001693 return drm_queue_vblank_event(dev, pipe, vblwait, file_priv);
Ilija Hadzica6778e92011-10-31 13:11:57 -04001694 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001695
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001696 DRM_DEBUG("waiting on vblank count %u, crtc %u\n",
Thierry Redingcc1ef112015-08-12 17:00:31 +02001697 vblwait->request.sequence, pipe);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001698 DRM_WAIT_ON(ret, vblank->queue, 3 * HZ,
Thierry Redingcc1ef112015-08-12 17:00:31 +02001699 (((drm_vblank_count(dev, pipe) -
Eric Anholt30b23632009-01-27 21:19:41 -08001700 vblwait->request.sequence) <= (1 << 23)) ||
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001701 !vblank->enabled ||
Eric Anholt30b23632009-01-27 21:19:41 -08001702 !dev->irq_enabled));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
Eric Anholt30b23632009-01-27 21:19:41 -08001704 if (ret != -EINTR) {
1705 struct timeval now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706
Thierry Redingcc1ef112015-08-12 17:00:31 +02001707 vblwait->reply.sequence = drm_vblank_count_and_time(dev, pipe, &now);
Eric Anholt30b23632009-01-27 21:19:41 -08001708 vblwait->reply.tval_sec = now.tv_sec;
1709 vblwait->reply.tval_usec = now.tv_usec;
Mario Kleiner27641c32010-10-23 04:20:23 +02001710
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001711 DRM_DEBUG("returning %u to client\n",
Eric Anholt30b23632009-01-27 21:19:41 -08001712 vblwait->reply.sequence);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 } else {
Eric Anholt30b23632009-01-27 21:19:41 -08001714 DRM_DEBUG("vblank wait interrupted by signal\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 }
1716
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001717done:
Thierry Redingcc1ef112015-08-12 17:00:31 +02001718 drm_vblank_put(dev, pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 return ret;
1720}
1721
Thierry Redingcc1ef112015-08-12 17:00:31 +02001722static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001723{
1724 struct drm_pending_vblank_event *e, *t;
1725 struct timeval now;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001726 unsigned int seq;
1727
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001728 assert_spin_locked(&dev->event_lock);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001729
Thierry Redingcc1ef112015-08-12 17:00:31 +02001730 seq = drm_vblank_count_and_time(dev, pipe, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001731
1732 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001733 if (e->pipe != pipe)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001734 continue;
1735 if ((seq - e->event.sequence) > (1<<23))
1736 continue;
1737
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001738 DRM_DEBUG("vblank event on %u, current %u\n",
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001739 e->event.sequence, seq);
1740
Rob Clarkc6eefa12012-10-16 22:48:40 +00001741 list_del(&e->base.link);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001742 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001743 send_vblank_event(dev, e, seq, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001744 }
1745
Thierry Redingcc1ef112015-08-12 17:00:31 +02001746 trace_drm_vblank_event(pipe, seq);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001747}
1748
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001750 * drm_handle_vblank - handle a vblank event
1751 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001752 * @pipe: index of CRTC where this event occurred
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001753 *
1754 * Drivers should call this routine in their vblank interrupt handlers to
1755 * update the vblank counter and send any signals that may be pending.
Thierry Reding115ebcd2014-12-15 14:47:18 +01001756 *
1757 * This is the legacy version of drm_crtc_handle_vblank().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001758 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001759bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001760{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001761 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Mario Kleiner27641c32010-10-23 04:20:23 +02001762 unsigned long irqflags;
1763
Daniel Vetteree3c7792015-02-22 15:11:20 +01001764 if (WARN_ON_ONCE(!dev->num_crtcs))
Chris Wilson78c6e172011-01-31 10:48:04 +00001765 return false;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001766
Thierry Redingcc1ef112015-08-12 17:00:31 +02001767 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001768 return false;
1769
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001770 spin_lock_irqsave(&dev->event_lock, irqflags);
1771
Mario Kleiner27641c32010-10-23 04:20:23 +02001772 /* Need timestamp lock to prevent concurrent execution with
1773 * vblank enable/disable, as this would cause inconsistent
1774 * or corrupted timestamps and vblank counts.
1775 */
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001776 spin_lock(&dev->vblank_time_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +02001777
1778 /* Vblank irq handling disabled. Nothing to do. */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001779 if (!vblank->enabled) {
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001780 spin_unlock(&dev->vblank_time_lock);
1781 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Chris Wilson78c6e172011-01-31 10:48:04 +00001782 return false;
Mario Kleiner27641c32010-10-23 04:20:23 +02001783 }
1784
Ville Syrjälä4dfd6482015-09-14 22:43:51 +03001785 drm_update_vblank_count(dev, pipe, DRM_CALLED_FROM_VBLIRQ);
Mario Kleiner27641c32010-10-23 04:20:23 +02001786
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001787 spin_unlock(&dev->vblank_time_lock);
1788
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001789 wake_up(&vblank->queue);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001790 drm_handle_vblank_events(dev, pipe);
Mario Kleiner27641c32010-10-23 04:20:23 +02001791
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001792 spin_unlock_irqrestore(&dev->event_lock, irqflags);
1793
Chris Wilson78c6e172011-01-31 10:48:04 +00001794 return true;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001795}
1796EXPORT_SYMBOL(drm_handle_vblank);
Thierry Reding115ebcd2014-12-15 14:47:18 +01001797
1798/**
1799 * drm_crtc_handle_vblank - handle a vblank event
1800 * @crtc: where this event occurred
1801 *
1802 * Drivers should call this routine in their vblank interrupt handlers to
1803 * update the vblank counter and send any signals that may be pending.
1804 *
1805 * This is the native KMS version of drm_handle_vblank().
1806 *
1807 * Returns:
1808 * True if the event was successfully handled, false on failure.
1809 */
1810bool drm_crtc_handle_vblank(struct drm_crtc *crtc)
1811{
1812 return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
1813}
1814EXPORT_SYMBOL(drm_crtc_handle_vblank);
Ville Syrjäläb44f8402015-09-30 16:46:48 +03001815
1816/**
1817 * drm_vblank_no_hw_counter - "No hw counter" implementation of .get_vblank_counter()
1818 * @dev: DRM device
1819 * @pipe: CRTC for which to read the counter
1820 *
1821 * Drivers can plug this into the .get_vblank_counter() function if
1822 * there is no useable hardware frame counter available.
1823 *
1824 * Returns:
1825 * 0
1826 */
1827u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe)
1828{
1829 return 0;
1830}
1831EXPORT_SYMBOL(drm_vblank_no_hw_counter);