blob: 677b37b0372b95b4ea8a7c7d77eda3a8c9c3fd34 [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 Kleiner27641c3f2010-10-23 04:20:23 +020044
Mario Kleiner27641c3f2010-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
Shawn Guo5ac74752017-02-07 17:16:15 +080092/*
93 * "No hw counter" fallback implementation of .get_vblank_counter() hook,
94 * if there is no useable hardware frame counter available.
95 */
96static u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe)
97{
98 WARN_ON_ONCE(dev->max_vblank_count != 0);
99 return 0;
100}
101
Shawn Guo84e35482017-02-07 17:16:13 +0800102static u32 __get_vblank_counter(struct drm_device *dev, unsigned int pipe)
103{
104 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
105 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
106
107 if (crtc->funcs->get_vblank_counter)
108 return crtc->funcs->get_vblank_counter(crtc);
109 }
110
111 if (dev->driver->get_vblank_counter)
112 return dev->driver->get_vblank_counter(dev, pipe);
113
114 return drm_vblank_no_hw_counter(dev, pipe);
115}
116
Daniel Vetter00edbe12016-05-31 23:11:14 +0200117/*
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300118 * Reset the stored timestamp for the current vblank count to correspond
119 * to the last vblank occurred.
120 *
Daniel Vetter2d1e3312016-11-14 10:02:54 +0100121 * Only to be called from drm_crtc_vblank_on().
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300122 *
Daniel Vetteref40cbf92017-01-25 07:26:47 +0100123 * Note: caller must hold &drm_device.vbl_lock since this reads & writes
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300124 * device vblank fields.
125 */
126static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe)
127{
128 u32 cur_vblank;
129 bool rc;
130 struct timeval t_vblank;
131 int count = DRM_TIMESTAMP_MAXRETRIES;
132
133 spin_lock(&dev->vblank_time_lock);
134
135 /*
136 * sample the current counter to avoid random jumps
137 * when drm_vblank_enable() applies the diff
138 */
139 do {
Shawn Guo84e35482017-02-07 17:16:13 +0800140 cur_vblank = __get_vblank_counter(dev, pipe);
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300141 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, 0);
Shawn Guo84e35482017-02-07 17:16:13 +0800142 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300143
144 /*
145 * Only reinitialize corresponding vblank timestamp if high-precision query
146 * available and didn't fail. Otherwise reinitialize delayed at next vblank
147 * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
148 */
149 if (!rc)
150 t_vblank = (struct timeval) {0, 0};
151
152 /*
153 * +1 to make sure user will never see the same
154 * vblank counter value before and after a modeset
155 */
156 store_vblank(dev, pipe, 1, &t_vblank, cur_vblank);
157
158 spin_unlock(&dev->vblank_time_lock);
159}
160
Daniel Vetter00edbe12016-05-31 23:11:14 +0200161/*
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300162 * Call back into the driver to update the appropriate vblank counter
Ville Syrjälä1da248a2015-09-14 22:43:42 +0300163 * (specified by @pipe). Deal with wraparound, if it occurred, and
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300164 * update the last read value so we can deal with wraparound on the next
165 * call if necessary.
166 *
167 * Only necessary when going from off->on, to account for frames we
168 * didn't get an interrupt for.
169 *
Daniel Vetteref40cbf92017-01-25 07:26:47 +0100170 * Note: caller must hold &drm_device.vbl_lock since this reads & writes
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300171 * device vblank fields.
172 */
Ville Syrjäläa6e610d2015-09-14 22:43:47 +0300173static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
174 unsigned long flags)
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300175{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200176 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter99264a62015-04-15 19:34:43 +0200177 u32 cur_vblank, diff;
Daniel Vetterfb446a12014-09-10 17:36:10 +0200178 bool rc;
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300179 struct timeval t_vblank;
Ville Syrjäläfacfb062015-09-14 22:43:48 +0300180 int count = DRM_TIMESTAMP_MAXRETRIES;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300181 int framedur_ns = vblank->framedur_ns;
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300182
183 /*
184 * Interrupts were disabled prior to this call, so deal with counter
185 * wrap if needed.
Michel Dänzer5ceecb22015-05-26 17:53:38 +0900186 * NOTE! It's possible we lost a full dev->max_vblank_count + 1 events
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300187 * here if the register is small or we had vblank interrupts off for
188 * a long time.
189 *
190 * We repeat the hardware vblank counter & timestamp query until
191 * we get consistent results. This to prevent races between gpu
192 * updating its hardware counter while we are retrieving the
193 * corresponding vblank timestamp.
194 */
195 do {
Shawn Guo84e35482017-02-07 17:16:13 +0800196 cur_vblank = __get_vblank_counter(dev, pipe);
Ville Syrjäläa6e610d2015-09-14 22:43:47 +0300197 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, flags);
Shawn Guo84e35482017-02-07 17:16:13 +0800198 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300199
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300200 if (dev->max_vblank_count != 0) {
201 /* trust the hw counter when it's around */
202 diff = (cur_vblank - vblank->last) & dev->max_vblank_count;
203 } else if (rc && framedur_ns) {
204 const struct timeval *t_old;
205 u64 diff_ns;
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300206
Matthew Auldd4055a92016-05-10 15:21:28 +0100207 t_old = &vblank->time;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300208 diff_ns = timeval_to_ns(&t_vblank) - timeval_to_ns(t_old);
209
210 /*
211 * Figure out how many vblanks we've missed based
212 * on the difference in the timestamps and the
213 * frame/field duration.
214 */
215 diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);
216
217 if (diff == 0 && flags & DRM_CALLED_FROM_VBLIRQ)
Ville Syrjälä235fabe2015-10-09 22:57:37 +0300218 DRM_DEBUG_VBL("crtc %u: Redundant vblirq ignored."
219 " diff_ns = %lld, framedur_ns = %d)\n",
220 pipe, (long long) diff_ns, framedur_ns);
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300221 } else {
222 /* some kind of default for drivers w/o accurate vbl timestamping */
223 diff = (flags & DRM_CALLED_FROM_VBLIRQ) != 0;
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300224 }
225
Mario Kleiner99b8e712016-02-12 20:30:28 +0100226 /*
Mario Kleinerc61934e2016-02-12 20:30:29 +0100227 * Within a drm_vblank_pre_modeset - drm_vblank_post_modeset
228 * interval? If so then vblank irqs keep running and it will likely
229 * happen that the hardware vblank counter is not trustworthy as it
230 * might reset at some point in that interval and vblank timestamps
231 * are not trustworthy either in that interval. Iow. this can result
232 * in a bogus diff >> 1 which must be avoided as it would cause
233 * random large forward jumps of the software vblank counter.
234 */
235 if (diff > 1 && (vblank->inmodeset & 0x2)) {
236 DRM_DEBUG_VBL("clamping vblank bump to 1 on crtc %u: diffr=%u"
237 " due to pre-modeset.\n", pipe, diff);
238 diff = 1;
239 }
240
Ville Syrjälä235fabe2015-10-09 22:57:37 +0300241 DRM_DEBUG_VBL("updating vblank count on crtc %u:"
242 " current=%u, diff=%u, hw=%u hw_last=%u\n",
243 pipe, vblank->count, diff, cur_vblank, vblank->last);
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300244
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300245 if (diff == 0) {
246 WARN_ON_ONCE(cur_vblank != vblank->last);
Mario Kleinerda8f4392014-09-13 18:25:54 +0200247 return;
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300248 }
Mario Kleinerda8f4392014-09-13 18:25:54 +0200249
Daniel Vetter99264a62015-04-15 19:34:43 +0200250 /*
251 * Only reinitialize corresponding vblank timestamp if high-precision query
Ville Syrjäläfa4270d2015-09-30 19:21:34 +0300252 * available and didn't fail, or we were called from the vblank interrupt.
253 * Otherwise reinitialize delayed at next vblank interrupt and assign 0
254 * for now, to mark the vblanktimestamp as invalid.
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300255 */
Ville Syrjäläfa4270d2015-09-30 19:21:34 +0300256 if (!rc && (flags & DRM_CALLED_FROM_VBLIRQ) == 0)
Mario Kleinerd66a1e32015-05-04 06:29:46 +0200257 t_vblank = (struct timeval) {0, 0};
258
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300259 store_vblank(dev, pipe, diff, &t_vblank, cur_vblank);
Ville Syrjälä13b030af52014-08-06 14:49:47 +0300260}
261
Daniel Vetterd6b0f622016-11-14 10:02:53 +0100262static u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe)
263{
264 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
265
266 if (WARN_ON(pipe >= dev->num_crtcs))
267 return 0;
268
269 return vblank->count;
270}
271
Maarten Lankhorstaf61d5c2016-05-17 15:07:44 +0200272/**
273 * drm_accurate_vblank_count - retrieve the master vblank counter
274 * @crtc: which counter to retrieve
275 *
276 * This function is similar to @drm_crtc_vblank_count but this
277 * function interpolates to handle a race with vblank irq's.
278 *
279 * This is mostly useful for hardware that can obtain the scanout
280 * position, but doesn't have a frame counter.
281 */
282u32 drm_accurate_vblank_count(struct drm_crtc *crtc)
283{
284 struct drm_device *dev = crtc->dev;
285 unsigned int pipe = drm_crtc_index(crtc);
286 u32 vblank;
287 unsigned long flags;
288
289 WARN(!dev->driver->get_vblank_timestamp,
290 "This function requires support for accurate vblank timestamps.");
291
292 spin_lock_irqsave(&dev->vblank_time_lock, flags);
293
294 drm_update_vblank_count(dev, pipe, 0);
295 vblank = drm_vblank_count(dev, pipe);
296
297 spin_unlock_irqrestore(&dev->vblank_time_lock, flags);
298
299 return vblank;
300}
301EXPORT_SYMBOL(drm_accurate_vblank_count);
302
Shawn Guo84e35482017-02-07 17:16:13 +0800303static void __disable_vblank(struct drm_device *dev, unsigned int pipe)
304{
305 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
306 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
307
308 if (crtc->funcs->disable_vblank) {
309 crtc->funcs->disable_vblank(crtc);
310 return;
311 }
312 }
313
314 dev->driver->disable_vblank(dev, pipe);
315}
316
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200317/*
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200318 * Disable vblank irq's on crtc, make sure that last vblank count
319 * of hardware and corresponding consistent software vblank counter
320 * are preserved, even if there are any spurious vblank irq's after
321 * disable.
322 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200323static void vblank_disable_and_save(struct drm_device *dev, unsigned int pipe)
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200324{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200325 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200326 unsigned long irqflags;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200327
Chris Wilson43dc7fe2017-03-17 20:20:27 +0000328 assert_spin_locked(&dev->vbl_lock);
329
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200330 /* Prevent vblank irq processing while disabling vblank irqs,
331 * so no updates of timestamps or count can happen after we've
332 * disabled. Needed to prevent races in case of delayed irq's.
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200333 */
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200334 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
335
Ville Syrjälä812e7462014-08-06 14:49:48 +0300336 /*
Laurent Pincharteb2ed662015-01-29 01:09:24 +0200337 * Only disable vblank interrupts if they're enabled. This avoids
338 * calling the ->disable_vblank() operation in atomic context with the
339 * hardware potentially runtime suspended.
340 */
Chris Wilsonf5f4c612017-03-30 15:08:32 +0100341 if (vblank->enabled) {
Shawn Guo84e35482017-02-07 17:16:13 +0800342 __disable_vblank(dev, pipe);
Chris Wilsonf5f4c612017-03-30 15:08:32 +0100343 vblank->enabled = false;
344 }
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200345
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300346 /*
347 * Always update the count and timestamp to maintain the
348 * appearance that the counter has been ticking all along until
349 * this time. This makes the count account for the entire time
Daniel Vetter2d1e3312016-11-14 10:02:54 +0100350 * between drm_crtc_vblank_on() and drm_crtc_vblank_off().
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200351 */
Ville Syrjälä4dfd6482015-09-14 22:43:51 +0300352 drm_update_vblank_count(dev, pipe, 0);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200353
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200354 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200355}
356
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700357static void vblank_disable_fn(unsigned long arg)
358{
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200359 struct drm_vblank_crtc *vblank = (void *)arg;
360 struct drm_device *dev = vblank->dev;
Thierry Redingcc1ef112015-08-12 17:00:31 +0200361 unsigned int pipe = vblank->pipe;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700362 unsigned long irqflags;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700363
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200364 spin_lock_irqsave(&dev->vbl_lock, irqflags);
365 if (atomic_read(&vblank->refcount) == 0 && vblank->enabled) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200366 DRM_DEBUG("disabling vblank on crtc %u\n", pipe);
367 vblank_disable_and_save(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700368 }
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200369 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700370}
371
Daniel Vetterf5752b32014-05-08 16:41:51 +0200372/**
373 * drm_vblank_cleanup - cleanup vblank support
374 * @dev: DRM device
375 *
376 * This function cleans up any resources allocated in drm_vblank_init.
377 */
Keith Packard52440212008-11-18 09:30:25 -0800378void drm_vblank_cleanup(struct drm_device *dev)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700379{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200380 unsigned int pipe;
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200381
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700382 /* Bail if the driver didn't call drm_vblank_init() */
383 if (dev->num_crtcs == 0)
384 return;
385
Thierry Redingcc1ef112015-08-12 17:00:31 +0200386 for (pipe = 0; pipe < dev->num_crtcs; pipe++) {
387 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300388
Chris Wilson43dc7fe2017-03-17 20:20:27 +0000389 WARN_ON(READ_ONCE(vblank->enabled) &&
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100390 drm_core_check_feature(dev, DRIVER_MODESET));
Mario Kleiner2368ffb2014-08-06 03:22:46 +0200391
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100392 del_timer_sync(&vblank->disable_timer);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200393 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700394
Ville Syrjälä5380e922013-10-04 14:53:36 +0300395 kfree(dev->vblank);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700396
397 dev->num_crtcs = 0;
398}
Jerome Glissee77cef92010-01-07 15:39:13 +0100399EXPORT_SYMBOL(drm_vblank_cleanup);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700400
Daniel Vetterf5752b32014-05-08 16:41:51 +0200401/**
402 * drm_vblank_init - initialize vblank support
Thierry Redingcc1ef112015-08-12 17:00:31 +0200403 * @dev: DRM device
404 * @num_crtcs: number of CRTCs supported by @dev
Daniel Vetterf5752b32014-05-08 16:41:51 +0200405 *
406 * This function initializes vblank support for @num_crtcs display pipelines.
407 *
408 * Returns:
409 * Zero on success or a negative error code on failure.
410 */
Thierry Redingcc1ef112015-08-12 17:00:31 +0200411int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700412{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200413 int ret = -ENOMEM;
414 unsigned int i;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700415
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700416 spin_lock_init(&dev->vbl_lock);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200417 spin_lock_init(&dev->vblank_time_lock);
418
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700419 dev->num_crtcs = num_crtcs;
420
Ville Syrjälä5380e922013-10-04 14:53:36 +0300421 dev->vblank = kcalloc(num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
422 if (!dev->vblank)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700423 goto err;
424
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200425 for (i = 0; i < num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300426 struct drm_vblank_crtc *vblank = &dev->vblank[i];
427
428 vblank->dev = dev;
Thierry Redingcc1ef112015-08-12 17:00:31 +0200429 vblank->pipe = i;
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300430 init_waitqueue_head(&vblank->queue);
431 setup_timer(&vblank->disable_timer, vblank_disable_fn,
432 (unsigned long)vblank);
Matthew Auldd4055a92016-05-10 15:21:28 +0100433 seqlock_init(&vblank->seqlock);
Ville Syrjäläe69595c2014-02-19 19:36:08 +0200434 }
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200435
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100436 DRM_INFO("Supports vblank timestamp caching Rev 2 (21.10.2013).\n");
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200437
438 /* Driver specific high-precision vblank timestamping supported? */
439 if (dev->driver->get_vblank_timestamp)
440 DRM_INFO("Driver supports precise vblank timestamp query.\n");
441 else
442 DRM_INFO("No driver support for vblank timestamp query.\n");
443
Mario Kleiner5a8b21b2015-05-04 06:29:45 +0200444 /* Must have precise timestamping for reliable vblank instant disable */
445 if (dev->vblank_disable_immediate && !dev->driver->get_vblank_timestamp) {
446 dev->vblank_disable_immediate = false;
447 DRM_INFO("Setting vblank_disable_immediate to false because "
448 "get_vblank_timestamp == NULL\n");
449 }
450
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700451 return 0;
452
453err:
Mario Kleiner79a093ae2014-08-06 03:22:44 +0200454 dev->num_crtcs = 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700455 return ret;
456}
457EXPORT_SYMBOL(drm_vblank_init);
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200460 * drm_irq_install - install IRQ handler
461 * @dev: DRM device
462 * @irq: IRQ number to install the handler for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 *
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700464 * Initializes the IRQ related data. Installs the handler, calling the driver
Daniel Vetterf5752b32014-05-08 16:41:51 +0200465 * irq_preinstall() and irq_postinstall() functions before and after the
466 * installation.
467 *
468 * This is the simplified helper interface provided for drivers with no special
469 * needs. Drivers which need to install interrupt handlers for multiple
Daniel Vetteref40cbf92017-01-25 07:26:47 +0100470 * interrupts must instead set &drm_device.irq_enabled to signal the DRM core
Daniel Vetterf5752b32014-05-08 16:41:51 +0200471 * that vblank interrupts are available.
472 *
473 * Returns:
474 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 */
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100476int drm_irq_install(struct drm_device *dev, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200478 int ret;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000479 unsigned long sh_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
481 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
482 return -EINVAL;
483
Daniel Vetter7c1a38e32013-12-16 11:21:15 +0100484 if (irq == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 return -EINVAL;
486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 /* Driver must have been initialized */
Daniel Vettere090c532013-11-03 20:27:05 +0100488 if (!dev->dev_private)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Daniel Vettere090c532013-11-03 20:27:05 +0100491 if (dev->irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 return -EBUSY;
Ville Syrjälä44238432013-10-04 14:53:37 +0300493 dev->irq_enabled = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Daniel Vetter7c1a38e32013-12-16 11:21:15 +0100495 DRM_DEBUG("irq=%d\n", irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000497 /* Before installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000498 if (dev->driver->irq_preinstall)
499 dev->driver->irq_preinstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000501 /* Install handler */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
Thomas Gleixner935f6e32006-07-01 19:29:34 -0700503 sh_flags = IRQF_SHARED;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000504
Daniel Vetter7c1a38e32013-12-16 11:21:15 +0100505 ret = request_irq(irq, dev->driver->irq_handler,
Daniel Vetter5829d182013-11-03 21:48:48 +0100506 sh_flags, dev->driver->name, dev);
Jesse Barnes9bfbd5c2008-09-15 15:00:33 -0700507
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000508 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300509 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 return ret;
511 }
512
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000513 /* After installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000514 if (dev->driver->irq_postinstall)
515 ret = dev->driver->irq_postinstall(dev);
516
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700517 if (ret < 0) {
Ville Syrjälä44238432013-10-04 14:53:37 +0300518 dev->irq_enabled = false;
Daniel Vetterfa538642016-08-03 21:11:10 +0200519 if (drm_core_check_feature(dev, DRIVER_LEGACY))
Joonyoung Shime1c44ac2011-08-04 05:41:00 +0000520 vga_client_register(dev->pdev, NULL, NULL, NULL);
Daniel Vetter7c1a38e32013-12-16 11:21:15 +0100521 free_irq(irq, dev);
522 } else {
523 dev->irq = irq;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700524 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700526 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700528EXPORT_SYMBOL(drm_irq_install);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
530/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200531 * drm_irq_uninstall - uninstall the IRQ handler
532 * @dev: DRM device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200534 * Calls the driver's irq_uninstall() function and unregisters the IRQ handler.
535 * This should only be called by drivers which used drm_irq_install() to set up
536 * their interrupt handler. Other drivers must only reset
Daniel Vetteref40cbf92017-01-25 07:26:47 +0100537 * &drm_device.irq_enabled to false.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200539 * Note that for kernel modesetting drivers it is a bug if this function fails.
540 * The sanity checks are only to catch buggy user modesetting drivers which call
541 * the same function through an ioctl.
542 *
543 * Returns:
544 * Zero on success or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 */
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200546int drm_irq_uninstall(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800548 unsigned long irqflags;
Ville Syrjälä44238432013-10-04 14:53:37 +0300549 bool irq_enabled;
550 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
553 return -EINVAL;
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 irq_enabled = dev->irq_enabled;
Ville Syrjälä44238432013-10-04 14:53:37 +0300556 dev->irq_enabled = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800558 /*
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100559 * Wake up any waiters so they don't hang. This is just to paper over
Frank Binnsc78d1ca22016-06-24 11:15:37 +0100560 * issues for UMS drivers which aren't in full control of their
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100561 * vblank/irq handling. KMS drivers must ensure that vblanks are all
562 * disabled when uninstalling the irq handler.
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800563 */
Ben Skeggsbde48892011-07-04 12:52:27 +1000564 if (dev->num_crtcs) {
565 spin_lock_irqsave(&dev->vbl_lock, irqflags);
566 for (i = 0; i < dev->num_crtcs; i++) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300567 struct drm_vblank_crtc *vblank = &dev->vblank[i];
568
Daniel Vetter3bff93d2015-02-22 15:11:19 +0100569 if (!vblank->enabled)
570 continue;
571
572 WARN_ON(drm_core_check_feature(dev, DRIVER_MODESET));
573
574 vblank_disable_and_save(dev, i);
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +0300575 wake_up(&vblank->queue);
Ben Skeggsbde48892011-07-04 12:52:27 +1000576 }
577 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800578 }
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800579
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000580 if (!irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return -EINVAL;
582
Daniel Vetter7c1a38e32013-12-16 11:21:15 +0100583 DRM_DEBUG("irq=%d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Daniel Vetterfa538642016-08-03 21:11:10 +0200585 if (drm_core_check_feature(dev, DRIVER_LEGACY))
Dave Airlie28d52042009-09-21 14:33:58 +1000586 vga_client_register(dev->pdev, NULL, NULL, NULL);
587
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000588 if (dev->driver->irq_uninstall)
589 dev->driver->irq_uninstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Daniel Vetter7c1a38e32013-12-16 11:21:15 +0100591 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 return 0;
594}
595EXPORT_SYMBOL(drm_irq_uninstall);
596
Daniel Vetter25a99392016-12-14 00:08:02 +0100597int drm_legacy_irq_control(struct drm_device *dev, void *data,
598 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599{
Eric Anholtc153f452007-09-03 12:06:45 +1000600 struct drm_control *ctl = data;
Daniel Vettera319c1a2013-11-03 21:09:15 +0100601 int ret = 0, irq;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000602
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200603 /* if we haven't irq we fallback for compatibility reasons -
604 * this used to be a separate function in drm_dma.h
605 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Daniel Vetter22471cf2013-11-03 20:02:50 +0100607 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
608 return 0;
Daniel Vetterfa538642016-08-03 21:11:10 +0200609 if (!drm_core_check_feature(dev, DRIVER_LEGACY))
Daniel Vetter22471cf2013-11-03 20:02:50 +0100610 return 0;
Frank Binnsc78d1ca22016-06-24 11:15:37 +0100611 /* UMS was only ever supported on pci devices. */
Daniel Vetter22471cf2013-11-03 20:02:50 +0100612 if (WARN_ON(!dev->pdev))
613 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Eric Anholtc153f452007-09-03 12:06:45 +1000615 switch (ctl->func) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 case DRM_INST_HANDLER:
Daniel Vettera319c1a2013-11-03 21:09:15 +0100617 irq = dev->pdev->irq;
618
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
Daniel Vettera319c1a2013-11-03 21:09:15 +0100620 ctl->irq != irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 return -EINVAL;
Daniel Vettere090c532013-11-03 20:27:05 +0100622 mutex_lock(&dev->struct_mutex);
Daniel Vetterbb0f1b52013-11-03 21:09:27 +0100623 ret = drm_irq_install(dev, irq);
Daniel Vettere090c532013-11-03 20:27:05 +0100624 mutex_unlock(&dev->struct_mutex);
625
626 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 case DRM_UNINST_HANDLER:
Daniel Vettere090c532013-11-03 20:27:05 +0100628 mutex_lock(&dev->struct_mutex);
629 ret = drm_irq_uninstall(dev);
630 mutex_unlock(&dev->struct_mutex);
631
632 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 default:
634 return -EINVAL;
635 }
636}
637
638/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200639 * drm_calc_timestamping_constants - calculate vblank timestamp constants
640 * @crtc: drm_crtc whose timestamp constants should be updated.
641 * @mode: display mode containing the scanout timings
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200642 *
Ville Syrjälä21b21562013-10-26 17:22:52 +0300643 * Calculate and store various constants which are later
644 * needed by vblank and swap-completion timestamping, e.g,
645 * by drm_calc_vbltimestamp_from_scanoutpos(). They are
Daniel Vetterf5752b32014-05-08 16:41:51 +0200646 * derived from CRTC's true scanout timing, so they take
Ville Syrjälä21b21562013-10-26 17:22:52 +0300647 * things like panel scaling or other adjustments into account.
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200648 */
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300649void drm_calc_timestamping_constants(struct drm_crtc *crtc,
650 const struct drm_display_mode *mode)
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200651{
Ville Syrjälä0c545ac2015-11-12 14:34:18 +0200652 struct drm_device *dev = crtc->dev;
653 unsigned int pipe = drm_crtc_index(crtc);
654 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä20b20202015-09-14 22:43:45 +0300655 int linedur_ns = 0, framedur_ns = 0;
Ville Syrjälä77666b722013-10-27 21:22:58 +0200656 int dotclock = mode->crtc_clock;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200657
Ville Syrjälä0c545ac2015-11-12 14:34:18 +0200658 if (!dev->num_crtcs)
659 return;
660
661 if (WARN_ON(pipe >= dev->num_crtcs))
662 return;
663
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200664 /* Valid dotclock? */
665 if (dotclock > 0) {
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300666 int frame_size = mode->crtc_htotal * mode->crtc_vtotal;
667
668 /*
669 * Convert scanline length in pixels and video
Ville Syrjälä20b20202015-09-14 22:43:45 +0300670 * dot clock to line duration and frame duration
671 * in nanoseconds:
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200672 */
Ville Syrjälä0dae35a2013-10-26 17:11:01 +0300673 linedur_ns = div_u64((u64) mode->crtc_htotal * 1000000, dotclock);
674 framedur_ns = div_u64((u64) frame_size * 1000000, dotclock);
Ville Syrjäläc0ae24c2013-10-28 19:53:25 +0200675
676 /*
677 * Fields of interlaced scanout modes are only half a frame duration.
678 */
679 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
680 framedur_ns /= 2;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200681 } else
Thierry Redingcc1ef112015-08-12 17:00:31 +0200682 DRM_ERROR("crtc %u: Can't calculate constants, dotclock = 0!\n",
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200683 crtc->base.id);
684
Ville Syrjäläeba1f352015-09-14 22:43:43 +0300685 vblank->linedur_ns = linedur_ns;
686 vblank->framedur_ns = framedur_ns;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200687
Thierry Redingcc1ef112015-08-12 17:00:31 +0200688 DRM_DEBUG("crtc %u: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
Ville Syrjälä545cdd52013-10-26 17:16:30 +0300689 crtc->base.id, mode->crtc_htotal,
690 mode->crtc_vtotal, mode->crtc_vdisplay);
Ville Syrjälä20b20202015-09-14 22:43:45 +0300691 DRM_DEBUG("crtc %u: clock %d kHz framedur %d linedur %d\n",
692 crtc->base.id, dotclock, framedur_ns, linedur_ns);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200693}
694EXPORT_SYMBOL(drm_calc_timestamping_constants);
695
696/**
Daniel Vetterf5752b32014-05-08 16:41:51 +0200697 * drm_calc_vbltimestamp_from_scanoutpos - precise vblank timestamp helper
698 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200699 * @pipe: index of CRTC whose vblank timestamp to retrieve
Daniel Vetterf5752b32014-05-08 16:41:51 +0200700 * @max_error: Desired maximum allowable error in timestamps (nanosecs)
701 * On return contains true maximum error of timestamp
702 * @vblank_time: Pointer to struct timeval which should receive the timestamp
703 * @flags: Flags to pass to driver:
704 * 0 = Default,
705 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
Daniel Vetterf5752b32014-05-08 16:41:51 +0200706 * @mode: mode which defines the scanout timings
707 *
708 * Implements calculation of exact vblank timestamps from given drm_display_mode
709 * timings and current video scanout position of a CRTC. This can be called from
710 * within get_vblank_timestamp() implementation of a kms driver to implement the
711 * actual timestamping.
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200712 *
713 * Should return timestamps conforming to the OML_sync_control OpenML
714 * extension specification. The timestamp corresponds to the end of
715 * the vblank interval, aka start of scanout of topmost-leftmost display
716 * pixel in the following video frame.
717 *
718 * Requires support for optional dev->driver->get_scanout_position()
719 * in kms driver, plus a bit of setup code to provide a drm_display_mode
720 * that corresponds to the true scanout timing.
721 *
722 * The current implementation only handles standard video modes. It
723 * returns as no operation if a doublescan or interlaced video mode is
724 * active. Higher level code is expected to handle this.
725 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200726 * Returns:
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200727 *
Daniel Vetterd673c022017-05-09 16:03:25 +0200728 * Returns true on success, and false on failure, i.e. when no accurate
729 * timestamp could be acquired.
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200730 */
Daniel Vetterd673c022017-05-09 16:03:25 +0200731bool drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
732 unsigned int pipe,
733 int *max_error,
734 struct timeval *vblank_time,
735 unsigned flags,
736 const struct drm_display_mode *mode)
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200737{
Imre Deake62f2f52012-10-23 18:53:25 +0000738 struct timeval tv_etime;
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000739 ktime_t stime, etime;
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300740 unsigned int vbl_status;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200741 int vpos, hpos, i;
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300742 int delta_ns, duration_ns;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200743
Thierry Redingcc1ef112015-08-12 17:00:31 +0200744 if (pipe >= dev->num_crtcs) {
745 DRM_ERROR("Invalid crtc %u\n", pipe);
Daniel Vetterd673c022017-05-09 16:03:25 +0200746 return false;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200747 }
748
749 /* Scanout position query not supported? Should not happen. */
750 if (!dev->driver->get_scanout_position) {
751 DRM_ERROR("Called from driver w/o get_scanout_position()!?\n");
Daniel Vetterd673c022017-05-09 16:03:25 +0200752 return false;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200753 }
754
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200755 /* If mode timing undefined, just return as no-op:
756 * Happens during initial modesetting of a crtc.
757 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300758 if (mode->crtc_clock == 0) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200759 DRM_DEBUG("crtc %u: Noop due to uninitialized mode.\n", pipe);
Daniel Vetterd673c022017-05-09 16:03:25 +0200760 return false;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200761 }
762
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200763 /* Get current scanout position with system timestamp.
764 * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times
765 * if single query takes longer than max_error nanoseconds.
766 *
767 * This guarantees a tight bound on maximum error if
768 * code gets preempted or delayed for some reason.
769 */
770 for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) {
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100771 /*
772 * Get vertical and horizontal scanout position vpos, hpos,
773 * and bounding timestamps stime, etime, pre/post query.
774 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300775 vbl_status = dev->driver->get_scanout_position(dev, pipe, flags,
776 &vpos, &hpos,
777 &stime, &etime,
778 mode);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200779
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200780 /* Return as no-op if scanout query unsupported or failed. */
781 if (!(vbl_status & DRM_SCANOUTPOS_VALID)) {
Ville Syrjäläad1716e2015-09-14 22:43:49 +0300782 DRM_DEBUG("crtc %u : scanoutpos query failed [0x%x].\n",
Thierry Redingcc1ef112015-08-12 17:00:31 +0200783 pipe, vbl_status);
Daniel Vetterd673c022017-05-09 16:03:25 +0200784 return false;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200785 }
786
Mario Kleiner8f6fce02013-10-30 05:13:06 +0100787 /* Compute uncertainty in timestamp of scanout position query. */
Imre Deake62f2f52012-10-23 18:53:25 +0000788 duration_ns = ktime_to_ns(etime) - ktime_to_ns(stime);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200789
790 /* Accept result with < max_error nsecs timing uncertainty. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300791 if (duration_ns <= *max_error)
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200792 break;
793 }
794
795 /* Noisy system timing? */
796 if (i == DRM_TIMESTAMP_MAXRETRIES) {
Thierry Redingcc1ef112015-08-12 17:00:31 +0200797 DRM_DEBUG("crtc %u: Noisy timestamp %d us > %d us [%d reps].\n",
798 pipe, duration_ns/1000, *max_error/1000, i);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200799 }
800
801 /* Return upper bound of timestamp precision error. */
Ville Syrjälä3c184f62013-10-26 17:38:52 +0300802 *max_error = duration_ns;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200803
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200804 /* Convert scanout position into elapsed time at raw_time query
805 * since start of scanout at first display scanline. delta_ns
806 * can be negative if start of scanout hasn't happened yet.
807 */
Ville Syrjälä3bb403b2015-09-14 22:43:44 +0300808 delta_ns = div_s64(1000000LL * (vpos * mode->crtc_htotal + hpos),
809 mode->crtc_clock);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200810
Imre Deakc61eef72012-10-23 18:53:26 +0000811 if (!drm_timestamp_monotonic)
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000812 etime = ktime_mono_to_real(etime);
Imre Deakc61eef72012-10-23 18:53:26 +0000813
Imre Deake62f2f52012-10-23 18:53:25 +0000814 /* save this only for debugging purposes */
815 tv_etime = ktime_to_timeval(etime);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200816 /* Subtract time delta from raw timestamp to get final
817 * vblank_time timestamp for end of vblank.
818 */
Daniel Vettera91d7b92016-03-29 13:12:22 +0200819 etime = ktime_sub_ns(etime, delta_ns);
Imre Deake62f2f52012-10-23 18:53:25 +0000820 *vblank_time = ktime_to_timeval(etime);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200821
Ville Syrjälä235fabe2015-10-09 22:57:37 +0300822 DRM_DEBUG_VBL("crtc %u : v 0x%x p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n",
823 pipe, vbl_status, hpos, vpos,
824 (long)tv_etime.tv_sec, (long)tv_etime.tv_usec,
825 (long)vblank_time->tv_sec, (long)vblank_time->tv_usec,
826 duration_ns/1000, i);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200827
Daniel Vetterd673c022017-05-09 16:03:25 +0200828 return true;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200829}
830EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
831
Imre Deakc61eef72012-10-23 18:53:26 +0000832static struct timeval get_drm_timestamp(void)
833{
834 ktime_t now;
835
Thomas Gleixnerd2cb58c2014-07-16 21:04:26 +0000836 now = drm_timestamp_monotonic ? ktime_get() : ktime_get_real();
Imre Deakc61eef72012-10-23 18:53:26 +0000837 return ktime_to_timeval(now);
838}
839
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200840/**
841 * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent
Thierry Reding4dfd9092014-12-10 13:03:34 +0100842 * vblank interval
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200843 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200844 * @pipe: index of CRTC whose vblank timestamp to retrieve
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200845 * @tvblank: Pointer to target struct timeval which should receive the timestamp
846 * @flags: Flags to pass to driver:
Daniel Vetterf5752b32014-05-08 16:41:51 +0200847 * 0 = Default,
848 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200849 *
850 * Fetches the system timestamp corresponding to the time of the most recent
Daniel Vetterf5752b32014-05-08 16:41:51 +0200851 * vblank interval on specified CRTC. May call into kms-driver to
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200852 * compute the timestamp with a high-precision GPU specific method.
853 *
854 * Returns zero if timestamp originates from uncorrected do_gettimeofday()
855 * call, i.e., it isn't very precisely locked to the true vblank.
856 *
Daniel Vetterf5752b32014-05-08 16:41:51 +0200857 * Returns:
Daniel Vetterfb446a12014-09-10 17:36:10 +0200858 * True if timestamp is considered to be very precise, false otherwise.
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200859 */
Daniel Vetterfb446a12014-09-10 17:36:10 +0200860static bool
Thierry Redingcc1ef112015-08-12 17:00:31 +0200861drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
Daniel Vetterfb446a12014-09-10 17:36:10 +0200862 struct timeval *tvblank, unsigned flags)
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200863{
Daniel Vetterd673c022017-05-09 16:03:25 +0200864 bool ret = false;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200865
866 /* Define requested maximum error on timestamps (nanoseconds). */
867 int max_error = (int) drm_timestamp_precision * 1000;
868
869 /* Query driver if possible and precision timestamping enabled. */
Daniel Vetterd673c022017-05-09 16:03:25 +0200870 if (dev->driver->get_vblank_timestamp && (max_error > 0))
Thierry Redingcc1ef112015-08-12 17:00:31 +0200871 ret = dev->driver->get_vblank_timestamp(dev, pipe, &max_error,
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200872 tvblank, flags);
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200873
874 /* GPU high precision timestamp query unsupported or failed.
Imre Deakc61eef72012-10-23 18:53:26 +0000875 * Return current monotonic/gettimeofday timestamp as best estimate.
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200876 */
Daniel Vetterd673c022017-05-09 16:03:25 +0200877 if (!ret)
878 *tvblank = get_drm_timestamp();
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200879
Daniel Vetterd673c022017-05-09 16:03:25 +0200880 return ret;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200881}
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200882
883/**
Thierry Reding96d3f912014-12-16 13:08:47 +0100884 * drm_crtc_vblank_count - retrieve "cooked" vblank counter value
885 * @crtc: which counter to retrieve
886 *
887 * Fetches the "cooked" vblank count value that represents the number of
888 * vblank events since the system was booted, including lost events due to
889 * modesetting activity.
890 *
Thierry Reding96d3f912014-12-16 13:08:47 +0100891 * Returns:
892 * The software vblank counter.
893 */
894u32 drm_crtc_vblank_count(struct drm_crtc *crtc)
895{
896 return drm_vblank_count(crtc->dev, drm_crtc_index(crtc));
897}
898EXPORT_SYMBOL(drm_crtc_vblank_count);
899
900/**
Thierry Redingcc1ef112015-08-12 17:00:31 +0200901 * drm_vblank_count_and_time - retrieve "cooked" vblank counter value and the
902 * system timestamp corresponding to that vblank counter value.
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200903 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +0200904 * @pipe: index of CRTC whose counter to retrieve
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200905 * @vblanktime: Pointer to struct timeval to receive the vblank timestamp.
906 *
907 * Fetches the "cooked" vblank count value that represents the number of
908 * vblank events since the system was booted, including lost events due to
909 * modesetting activity. Returns corresponding system timestamp of the time
Daniel Vetterf5752b32014-05-08 16:41:51 +0200910 * of the vblank interval that corresponds to the current vblank counter value.
Thierry Redingcf648302015-09-24 18:35:36 +0200911 *
912 * This is the legacy version of drm_crtc_vblank_count_and_time().
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200913 */
Gustavo Padovan6e5f73f2016-07-04 21:04:47 -0300914static u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
915 struct timeval *vblanktime)
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200916{
Thierry Redingcc1ef112015-08-12 17:00:31 +0200917 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Matthew Auldd4055a92016-05-10 15:21:28 +0100918 u32 vblank_count;
919 unsigned int seq;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200920
Arnd Bergmanncff52e52016-10-18 00:13:39 +0200921 if (WARN_ON(pipe >= dev->num_crtcs)) {
922 *vblanktime = (struct timeval) { 0 };
Rob Clarke6ae8682014-08-06 13:16:59 -0400923 return 0;
Arnd Bergmanncff52e52016-10-18 00:13:39 +0200924 }
Rob Clarke6ae8682014-08-06 13:16:59 -0400925
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200926 do {
Matthew Auldd4055a92016-05-10 15:21:28 +0100927 seq = read_seqbegin(&vblank->seqlock);
928 vblank_count = vblank->count;
929 *vblanktime = vblank->time;
930 } while (read_seqretry(&vblank->seqlock, seq));
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200931
Matthew Auldd4055a92016-05-10 15:21:28 +0100932 return vblank_count;
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200933}
Mario Kleiner27641c3f2010-10-23 04:20:23 +0200934
Thierry Redingcf648302015-09-24 18:35:36 +0200935/**
936 * drm_crtc_vblank_count_and_time - retrieve "cooked" vblank counter value
937 * and the system timestamp corresponding to that vblank counter value
938 * @crtc: which counter to retrieve
939 * @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
944 * of the vblank interval that corresponds to the current vblank counter value.
Thierry Redingcf648302015-09-24 18:35:36 +0200945 */
946u32 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
947 struct timeval *vblanktime)
948{
949 return drm_vblank_count_and_time(crtc->dev, drm_crtc_index(crtc),
950 vblanktime);
951}
952EXPORT_SYMBOL(drm_crtc_vblank_count_and_time);
953
Rob Clarkc6eefa12012-10-16 22:48:40 +0000954static void send_vblank_event(struct drm_device *dev,
955 struct drm_pending_vblank_event *e,
956 unsigned long seq, struct timeval *now)
957{
Rob Clarkc6eefa12012-10-16 22:48:40 +0000958 e->event.sequence = seq;
959 e->event.tv_sec = now->tv_sec;
960 e->event.tv_usec = now->tv_usec;
961
Daniel Vetter7d52cb882017-03-08 15:12:43 +0100962 trace_drm_vblank_event_delivered(e->base.file_priv, e->pipe,
Rob Clarkc6eefa12012-10-16 22:48:40 +0000963 e->event.sequence);
Matthew Auldc001da42016-06-20 17:42:46 +0100964
965 drm_send_event_locked(dev, &e->base);
Rob Clarkc6eefa12012-10-16 22:48:40 +0000966}
967
968/**
Daniel Vetterbbc87642015-11-10 17:37:31 +0100969 * drm_crtc_arm_vblank_event - arm vblank event after pageflip
970 * @crtc: the source CRTC of the vblank event
971 * @e: the event to send
972 *
973 * A lot of drivers need to generate vblank events for the very next vblank
974 * interrupt. For example when the page flip interrupt happens when the page
975 * flip gets armed, but not when it actually executes within the next vblank
976 * period. This helper function implements exactly the required vblank arming
977 * behaviour.
978 *
Daniel Vetteref40cbf92017-01-25 07:26:47 +0100979 * NOTE: Drivers using this to send out the &drm_crtc_state.event as part of an
980 * atomic commit must ensure that the next vblank happens at exactly the same
981 * time as the atomic commit is committed to the hardware. This function itself
982 * does **not** protect again the next vblank interrupt racing with either this
983 * function call or the atomic commit operation. A possible sequence could be:
Daniel Vetter61802132016-09-30 12:04:56 +0200984 *
985 * 1. Driver commits new hardware state into vblank-synchronized registers.
986 * 2. A vblank happens, committing the hardware state. Also the corresponding
987 * vblank interrupt is fired off and fully processed by the interrupt
988 * handler.
989 * 3. The atomic commit operation proceeds to call drm_crtc_arm_vblank_event().
990 * 4. The event is only send out for the next vblank, which is wrong.
991 *
992 * An equivalent race can happen when the driver calls
993 * drm_crtc_arm_vblank_event() before writing out the new hardware state.
994 *
995 * The only way to make this work safely is to prevent the vblank from firing
996 * (and the hardware from committing anything else) until the entire atomic
997 * commit sequence has run to completion. If the hardware does not have such a
998 * feature (e.g. using a "go" bit), then it is unsafe to use this functions.
999 * Instead drivers need to manually send out the event from their interrupt
1000 * handler by calling drm_crtc_send_vblank_event() and make sure that there's no
1001 * possible race with the hardware committing the atomic update.
1002 *
Daniel Vetterbbc87642015-11-10 17:37:31 +01001003 * Caller must hold event lock. Caller must also hold a vblank reference for
1004 * the event @e, which will be dropped when the next vblank arrives.
Daniel Vetterbbc87642015-11-10 17:37:31 +01001005 */
1006void drm_crtc_arm_vblank_event(struct drm_crtc *crtc,
1007 struct drm_pending_vblank_event *e)
1008{
Gustavo Padovan93507d12016-06-07 11:07:55 -03001009 struct drm_device *dev = crtc->dev;
1010 unsigned int pipe = drm_crtc_index(crtc);
1011
1012 assert_spin_locked(&dev->event_lock);
1013
1014 e->pipe = pipe;
1015 e->event.sequence = drm_vblank_count(dev, pipe);
Ander Conselvan de Oliveira5db06a82017-04-04 17:52:21 +01001016 e->event.crtc_id = crtc->base.id;
Gustavo Padovan93507d12016-06-07 11:07:55 -03001017 list_add_tail(&e->base.link, &dev->vblank_event_list);
Daniel Vetterbbc87642015-11-10 17:37:31 +01001018}
1019EXPORT_SYMBOL(drm_crtc_arm_vblank_event);
1020
1021/**
Gustavo Padovandb749b7e2016-06-07 11:07:54 -03001022 * drm_crtc_send_vblank_event - helper to send vblank event after pageflip
1023 * @crtc: the source CRTC of the vblank event
Rob Clarkc6eefa12012-10-16 22:48:40 +00001024 * @e: the event to send
1025 *
Daniel Vetter61802132016-09-30 12:04:56 +02001026 * Updates sequence # and timestamp on event for the most recently processed
1027 * vblank, and sends it to userspace. Caller must hold event lock.
1028 *
1029 * See drm_crtc_arm_vblank_event() for a helper which can be used in certain
1030 * situation, especially to send out events for atomic commit operations.
Rob Clarkc6eefa12012-10-16 22:48:40 +00001031 */
Gustavo Padovandb749b7e2016-06-07 11:07:54 -03001032void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
1033 struct drm_pending_vblank_event *e)
Rob Clarkc6eefa12012-10-16 22:48:40 +00001034{
Gustavo Padovandb749b7e2016-06-07 11:07:54 -03001035 struct drm_device *dev = crtc->dev;
1036 unsigned int seq, pipe = drm_crtc_index(crtc);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001037 struct timeval now;
Thierry Reding4dfd9092014-12-10 13:03:34 +01001038
Thierry Reding2a7d3d62015-08-12 17:00:24 +02001039 if (dev->num_crtcs > 0) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001040 seq = drm_vblank_count_and_time(dev, pipe, &now);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001041 } else {
1042 seq = 0;
Imre Deakc61eef72012-10-23 18:53:26 +00001043
1044 now = get_drm_timestamp();
Rob Clarkc6eefa12012-10-16 22:48:40 +00001045 }
Thierry Redingcc1ef112015-08-12 17:00:31 +02001046 e->pipe = pipe;
Ander Conselvan de Oliveira5db06a82017-04-04 17:52:21 +01001047 e->event.crtc_id = crtc->base.id;
Rob Clarkc6eefa12012-10-16 22:48:40 +00001048 send_vblank_event(dev, e, seq, &now);
1049}
Thierry Redinga4d7b302014-12-15 14:47:18 +01001050EXPORT_SYMBOL(drm_crtc_send_vblank_event);
1051
Shawn Guo84e35482017-02-07 17:16:13 +08001052static int __enable_vblank(struct drm_device *dev, unsigned int pipe)
1053{
1054 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
1055 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
1056
1057 if (crtc->funcs->enable_vblank)
1058 return crtc->funcs->enable_vblank(crtc);
1059 }
1060
1061 return dev->driver->enable_vblank(dev, pipe);
1062}
1063
Thierry Redinga4d7b302014-12-15 14:47:18 +01001064/**
Ville Syrjäläf2752282014-02-19 21:29:49 +02001065 * drm_vblank_enable - enable the vblank interrupt on a CRTC
1066 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001067 * @pipe: CRTC index
Thierry Redingc30e11f2015-08-12 17:00:33 +02001068 *
1069 * Returns:
1070 * Zero on success or a negative error code on failure.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001071 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001072static int drm_vblank_enable(struct drm_device *dev, unsigned int pipe)
Ville Syrjäläf2752282014-02-19 21:29:49 +02001073{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001074 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001075 int ret = 0;
1076
1077 assert_spin_locked(&dev->vbl_lock);
1078
1079 spin_lock(&dev->vblank_time_lock);
1080
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001081 if (!vblank->enabled) {
Daniel Vetter1cfb80b2014-05-21 15:11:33 +02001082 /*
1083 * Enable vblank irqs under vblank_time_lock protection.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001084 * All vblank count & timestamp updates are held off
1085 * until we are done reinitializing master counter and
1086 * timestamps. Filtercode in drm_handle_vblank() will
1087 * prevent double-accounting of same vblank interval.
1088 */
Shawn Guo84e35482017-02-07 17:16:13 +08001089 ret = __enable_vblank(dev, pipe);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001090 DRM_DEBUG("enabling vblank on crtc %u, ret: %d\n", pipe, ret);
Chris Wilson43dc7fe2017-03-17 20:20:27 +00001091 if (ret) {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001092 atomic_dec(&vblank->refcount);
Chris Wilson43dc7fe2017-03-17 20:20:27 +00001093 } else {
Ville Syrjäläa6e610d2015-09-14 22:43:47 +03001094 drm_update_vblank_count(dev, pipe, 0);
Chris Wilson43dc7fe2017-03-17 20:20:27 +00001095 /* drm_update_vblank_count() includes a wmb so we just
1096 * need to ensure that the compiler emits the write
1097 * to mark the vblank as enabled after the call
1098 * to drm_update_vblank_count().
1099 */
1100 WRITE_ONCE(vblank->enabled, true);
Ville Syrjäläf2752282014-02-19 21:29:49 +02001101 }
1102 }
1103
1104 spin_unlock(&dev->vblank_time_lock);
1105
1106 return ret;
1107}
1108
1109/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001110 * drm_vblank_get - get a reference count on vblank events
1111 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001112 * @pipe: index of CRTC to own
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001113 *
1114 * Acquire a reference count on vblank events to avoid having them disabled
1115 * while in use.
1116 *
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001117 * This is the legacy version of drm_crtc_vblank_get().
1118 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001119 * Returns:
Thierry Redingc30e11f2015-08-12 17:00:33 +02001120 * Zero on success or a negative error code on failure.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001121 */
Gustavo Padovanceb74152016-06-07 11:07:56 -03001122static int drm_vblank_get(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001123{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001124 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Peter Hurley97cbc882013-08-20 21:51:12 -04001125 unsigned long irqflags;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001126 int ret = 0;
1127
Gerd Hoffmann16e32472015-03-30 12:50:50 +02001128 if (!dev->num_crtcs)
1129 return -EINVAL;
1130
Thierry Redingcc1ef112015-08-12 17:00:31 +02001131 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001132 return -EINVAL;
1133
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001134 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1135 /* Going from 0->1 means we have to enable interrupts again */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001136 if (atomic_add_return(1, &vblank->refcount) == 1) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001137 ret = drm_vblank_enable(dev, pipe);
Li Peng778c9022009-11-09 12:51:22 +08001138 } else {
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001139 if (!vblank->enabled) {
1140 atomic_dec(&vblank->refcount);
Li Peng778c9022009-11-09 12:51:22 +08001141 ret = -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001142 }
1143 }
1144 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1145
1146 return ret;
1147}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001148
1149/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001150 * drm_crtc_vblank_get - get a reference count on vblank events
1151 * @crtc: which CRTC to own
1152 *
1153 * Acquire a reference count on vblank events to avoid having them disabled
1154 * while in use.
1155 *
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001156 * Returns:
Thierry Redingc30e11f2015-08-12 17:00:33 +02001157 * Zero on success or a negative error code on failure.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001158 */
1159int drm_crtc_vblank_get(struct drm_crtc *crtc)
1160{
1161 return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
1162}
1163EXPORT_SYMBOL(drm_crtc_vblank_get);
1164
1165/**
Thierry Redingcc1ef112015-08-12 17:00:31 +02001166 * drm_vblank_put - release ownership of vblank events
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001167 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001168 * @pipe: index of CRTC to release
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001169 *
1170 * Release ownership of a given vblank counter, turning off interrupts
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001171 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001172 *
1173 * This is the legacy version of drm_crtc_vblank_put().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001174 */
Gustavo Padovanceb74152016-06-07 11:07:56 -03001175static void drm_vblank_put(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001176{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001177 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001178
Thierry Redingcc1ef112015-08-12 17:00:31 +02001179 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clark7f907bf22014-11-08 10:16:19 -05001180 return;
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001181
Thierry Reding7d1de852015-08-12 17:00:30 +02001182 if (WARN_ON(atomic_read(&vblank->refcount) == 0))
Rob Clarke6ae8682014-08-06 13:16:59 -04001183 return;
1184
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001185 /* Last user schedules interrupt disable */
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001186 if (atomic_dec_and_test(&vblank->refcount)) {
Daniel Vetterab8905f2014-09-10 17:36:08 +02001187 if (drm_vblank_offdelay == 0)
1188 return;
Chris Wilson608b2052017-03-15 20:40:25 +00001189 else if (drm_vblank_offdelay < 0)
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001190 vblank_disable_fn((unsigned long)vblank);
Chris Wilson608b2052017-03-15 20:40:25 +00001191 else if (!dev->vblank_disable_immediate)
Ville Syrjälä4ed0ce32014-08-06 14:49:53 +03001192 mod_timer(&vblank->disable_timer,
1193 jiffies + ((drm_vblank_offdelay * HZ)/1000));
1194 }
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001195}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001196
Rob Clarkc6eefa12012-10-16 22:48:40 +00001197/**
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001198 * drm_crtc_vblank_put - give up ownership of vblank events
1199 * @crtc: which counter to give up
1200 *
1201 * Release ownership of a given vblank counter, turning off interrupts
1202 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001203 */
1204void drm_crtc_vblank_put(struct drm_crtc *crtc)
1205{
1206 drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
1207}
1208EXPORT_SYMBOL(drm_crtc_vblank_put);
1209
1210/**
Daniel Vettere8450f52014-07-25 23:34:03 +02001211 * drm_wait_one_vblank - wait for one vblank
1212 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001213 * @pipe: CRTC index
Daniel Vettere8450f52014-07-25 23:34:03 +02001214 *
Ville Syrjälä1da248a2015-09-14 22:43:42 +03001215 * This waits for one vblank to pass on @pipe, using the irq driver interfaces.
1216 * It is a failure to call this when the vblank irq for @pipe is disabled, e.g.
Daniel Vettere8450f52014-07-25 23:34:03 +02001217 * due to lack of driver support or because the crtc is off.
1218 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001219void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe)
Daniel Vettere8450f52014-07-25 23:34:03 +02001220{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001221 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vettere8450f52014-07-25 23:34:03 +02001222 int ret;
1223 u32 last;
1224
Thierry Redingcc1ef112015-08-12 17:00:31 +02001225 if (WARN_ON(pipe >= dev->num_crtcs))
Thierry Reding7d1de852015-08-12 17:00:30 +02001226 return;
1227
Thierry Redingcc1ef112015-08-12 17:00:31 +02001228 ret = drm_vblank_get(dev, pipe);
1229 if (WARN(ret, "vblank not available on crtc %i, ret=%i\n", pipe, ret))
Daniel Vettere8450f52014-07-25 23:34:03 +02001230 return;
1231
Thierry Redingcc1ef112015-08-12 17:00:31 +02001232 last = drm_vblank_count(dev, pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001233
Thierry Redingcc1ef112015-08-12 17:00:31 +02001234 ret = wait_event_timeout(vblank->queue,
1235 last != drm_vblank_count(dev, pipe),
Daniel Vettere8450f52014-07-25 23:34:03 +02001236 msecs_to_jiffies(100));
1237
Thierry Redingcc1ef112015-08-12 17:00:31 +02001238 WARN(ret == 0, "vblank wait timed out on crtc %i\n", pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001239
Thierry Redingcc1ef112015-08-12 17:00:31 +02001240 drm_vblank_put(dev, pipe);
Daniel Vettere8450f52014-07-25 23:34:03 +02001241}
1242EXPORT_SYMBOL(drm_wait_one_vblank);
1243
1244/**
1245 * drm_crtc_wait_one_vblank - wait for one vblank
1246 * @crtc: DRM crtc
1247 *
1248 * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
1249 * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
1250 * due to lack of driver support or because the crtc is off.
1251 */
1252void drm_crtc_wait_one_vblank(struct drm_crtc *crtc)
1253{
1254 drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
1255}
1256EXPORT_SYMBOL(drm_crtc_wait_one_vblank);
1257
1258/**
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001259 * drm_crtc_vblank_off - disable vblank events on a CRTC
1260 * @crtc: CRTC in question
Rob Clarkc6eefa12012-10-16 22:48:40 +00001261 *
Daniel Vetterf5752b32014-05-08 16:41:51 +02001262 * Drivers can use this function to shut down the vblank interrupt handling when
1263 * disabling a crtc. This function ensures that the latest vblank frame count is
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001264 * stored so that drm_vblank_on can restore it again.
Daniel Vetterf5752b32014-05-08 16:41:51 +02001265 *
1266 * Drivers must use this function when the hardware vblank counter can get
1267 * reset, e.g. when suspending.
Rob Clarkc6eefa12012-10-16 22:48:40 +00001268 */
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001269void drm_crtc_vblank_off(struct drm_crtc *crtc)
Li Peng778c9022009-11-09 12:51:22 +08001270{
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001271 struct drm_device *dev = crtc->dev;
1272 unsigned int pipe = drm_crtc_index(crtc);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001273 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001274 struct drm_pending_vblank_event *e, *t;
1275 struct timeval now;
Li Peng778c9022009-11-09 12:51:22 +08001276 unsigned long irqflags;
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001277 unsigned int seq;
Li Peng778c9022009-11-09 12:51:22 +08001278
Thierry Redingcc1ef112015-08-12 17:00:31 +02001279 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001280 return;
1281
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001282 spin_lock_irqsave(&dev->event_lock, irqflags);
1283
1284 spin_lock(&dev->vbl_lock);
Mario Kleinere8235892016-02-12 20:30:27 +01001285 DRM_DEBUG_VBL("crtc %d, vblank enabled %d, inmodeset %d\n",
1286 pipe, vblank->enabled, vblank->inmodeset);
1287
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001288 /* Avoid redundant vblank disables without previous
1289 * drm_crtc_vblank_on(). */
Mario Kleinere8235892016-02-12 20:30:27 +01001290 if (drm_core_check_feature(dev, DRIVER_ATOMIC) || !vblank->inmodeset)
1291 vblank_disable_and_save(dev, pipe);
1292
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001293 wake_up(&vblank->queue);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001294
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001295 /*
1296 * Prevent subsequent drm_vblank_get() from re-enabling
1297 * the vblank interrupt by bumping the refcount.
1298 */
1299 if (!vblank->inmodeset) {
1300 atomic_inc(&vblank->refcount);
1301 vblank->inmodeset = 1;
1302 }
1303 spin_unlock(&dev->vbl_lock);
1304
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001305 /* Send any queued vblank events, lest the natives grow disquiet */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001306 seq = drm_vblank_count_and_time(dev, pipe, &now);
Imre Deake7783ba2012-11-02 13:30:50 +02001307
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001308 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001309 if (e->pipe != pipe)
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001310 continue;
Ville Syrjälä44844892015-10-09 22:57:36 +03001311 DRM_DEBUG("Sending premature vblank event on disable: "
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001312 "wanted %u, current %u\n",
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001313 e->event.sequence, seq);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001314 list_del(&e->base.link);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001315 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001316 send_vblank_event(dev, e, seq, &now);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001317 }
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001318 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Li Peng778c9022009-11-09 12:51:22 +08001319}
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001320EXPORT_SYMBOL(drm_crtc_vblank_off);
1321
1322/**
Daniel Vetter96256042015-02-13 21:03:42 +01001323 * drm_crtc_vblank_reset - reset vblank state to off on a CRTC
Thierry Reding2b193f02015-09-24 18:35:30 +02001324 * @crtc: CRTC in question
Daniel Vetter96256042015-02-13 21:03:42 +01001325 *
1326 * Drivers can use this function to reset the vblank state to off at load time.
1327 * Drivers should use this together with the drm_crtc_vblank_off() and
1328 * drm_crtc_vblank_on() functions. The difference compared to
1329 * drm_crtc_vblank_off() is that this function doesn't save the vblank counter
1330 * and hence doesn't need to call any driver hooks.
1331 */
Thierry Reding2b193f02015-09-24 18:35:30 +02001332void drm_crtc_vblank_reset(struct drm_crtc *crtc)
Daniel Vetter96256042015-02-13 21:03:42 +01001333{
Thierry Reding2b193f02015-09-24 18:35:30 +02001334 struct drm_device *dev = crtc->dev;
Daniel Vetter96256042015-02-13 21:03:42 +01001335 unsigned long irqflags;
Thierry Reding2b193f02015-09-24 18:35:30 +02001336 unsigned int pipe = drm_crtc_index(crtc);
Ville Syrjälä1da248a2015-09-14 22:43:42 +03001337 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Daniel Vetter96256042015-02-13 21:03:42 +01001338
1339 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1340 /*
1341 * Prevent subsequent drm_vblank_get() from enabling the vblank
1342 * interrupt by bumping the refcount.
1343 */
1344 if (!vblank->inmodeset) {
1345 atomic_inc(&vblank->refcount);
1346 vblank->inmodeset = 1;
1347 }
1348 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1349
1350 WARN_ON(!list_empty(&dev->vblank_event_list));
1351}
1352EXPORT_SYMBOL(drm_crtc_vblank_reset);
1353
1354/**
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001355 * drm_crtc_vblank_on - enable vblank events on a CRTC
1356 * @crtc: CRTC in question
Daniel Vetterf5752b32014-05-08 16:41:51 +02001357 *
1358 * This functions restores the vblank interrupt state captured with
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001359 * drm_crtc_vblank_off() again. Note that calls to drm_crtc_vblank_on() and
1360 * drm_crtc_vblank_off() can be unbalanced and so can also be unconditionally called
Daniel Vetterf5752b32014-05-08 16:41:51 +02001361 * in driver load code to reflect the current hardware state of the crtc.
Ville Syrjäläf2752282014-02-19 21:29:49 +02001362 */
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001363void drm_crtc_vblank_on(struct drm_crtc *crtc)
Ville Syrjäläf2752282014-02-19 21:29:49 +02001364{
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001365 struct drm_device *dev = crtc->dev;
1366 unsigned int pipe = drm_crtc_index(crtc);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001367 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjäläf2752282014-02-19 21:29:49 +02001368 unsigned long irqflags;
1369
Thierry Redingcc1ef112015-08-12 17:00:31 +02001370 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001371 return;
1372
Ville Syrjäläf2752282014-02-19 21:29:49 +02001373 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Mario Kleinere8235892016-02-12 20:30:27 +01001374 DRM_DEBUG_VBL("crtc %d, vblank enabled %d, inmodeset %d\n",
1375 pipe, vblank->enabled, vblank->inmodeset);
1376
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001377 /* Drop our private "prevent drm_vblank_get" refcount */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001378 if (vblank->inmodeset) {
1379 atomic_dec(&vblank->refcount);
1380 vblank->inmodeset = 0;
Ville Syrjälä7ffd7a62014-08-06 14:49:44 +03001381 }
Ville Syrjäläf8ad0282014-08-06 14:49:49 +03001382
Ville Syrjälä4dfd6482015-09-14 22:43:51 +03001383 drm_reset_vblank_timestamp(dev, pipe);
1384
Ville Syrjäläcd19e522014-08-06 14:49:56 +03001385 /*
1386 * re-enable interrupts if there are users left, or the
1387 * user wishes vblank interrupts to be enabled all the time.
1388 */
Mario Kleinerbb74fc12016-02-12 20:30:30 +01001389 if (atomic_read(&vblank->refcount) != 0 || drm_vblank_offdelay == 0)
Thierry Redingcc1ef112015-08-12 17:00:31 +02001390 WARN_ON(drm_vblank_enable(dev, pipe));
Ville Syrjäläf2752282014-02-19 21:29:49 +02001391 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1392}
Daniel Vetter89dd6a42014-05-15 15:32:12 +02001393EXPORT_SYMBOL(drm_crtc_vblank_on);
1394
Daniel Vetter07600c52016-11-14 10:02:52 +01001395static void drm_legacy_vblank_pre_modeset(struct drm_device *dev,
1396 unsigned int pipe)
Dave Airlief453ba02008-11-07 14:05:41 -08001397{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001398 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001399
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001400 /* vblank is not initialized (IRQ not installed ?), or has been freed */
Jerome Glissee77cef92010-01-07 15:39:13 +01001401 if (!dev->num_crtcs)
1402 return;
Rob Clarke6ae8682014-08-06 13:16:59 -04001403
Thierry Redingcc1ef112015-08-12 17:00:31 +02001404 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001405 return;
1406
Dave Airlief453ba02008-11-07 14:05:41 -08001407 /*
1408 * To avoid all the problems that might happen if interrupts
1409 * were enabled/disabled around or between these calls, we just
1410 * have the kernel take a reference on the CRTC (just once though
1411 * to avoid corrupting the count if multiple, mismatch calls occur),
1412 * so that interrupts remain enabled in the interim.
1413 */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001414 if (!vblank->inmodeset) {
1415 vblank->inmodeset = 0x1;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001416 if (drm_vblank_get(dev, pipe) == 0)
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001417 vblank->inmodeset |= 0x2;
Dave Airlief453ba02008-11-07 14:05:41 -08001418 }
1419}
Dave Airlief453ba02008-11-07 14:05:41 -08001420
Daniel Vetter07600c52016-11-14 10:02:52 +01001421static void drm_legacy_vblank_post_modeset(struct drm_device *dev,
1422 unsigned int pipe)
Dave Airlief453ba02008-11-07 14:05:41 -08001423{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001424 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Dave Airlief453ba02008-11-07 14:05:41 -08001425 unsigned long irqflags;
1426
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001427 /* vblank is not initialized (IRQ not installed ?), or has been freed */
1428 if (!dev->num_crtcs)
1429 return;
1430
Thierry Redingcc1ef112015-08-12 17:00:31 +02001431 if (WARN_ON(pipe >= dev->num_crtcs))
Thierry Reding7d1de852015-08-12 17:00:30 +02001432 return;
1433
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001434 if (vblank->inmodeset) {
Dave Airlief453ba02008-11-07 14:05:41 -08001435 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Mario Kleinerc61934e2016-02-12 20:30:29 +01001436 drm_reset_vblank_timestamp(dev, pipe);
Dave Airlief453ba02008-11-07 14:05:41 -08001437 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001438
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001439 if (vblank->inmodeset & 0x2)
Thierry Redingcc1ef112015-08-12 17:00:31 +02001440 drm_vblank_put(dev, pipe);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001441
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001442 vblank->inmodeset = 0;
Dave Airlief453ba02008-11-07 14:05:41 -08001443 }
1444}
Dave Airlief453ba02008-11-07 14:05:41 -08001445
Daniel Vetter25a99392016-12-14 00:08:02 +01001446int drm_legacy_modeset_ctl(struct drm_device *dev, void *data,
1447 struct drm_file *file_priv)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001448{
1449 struct drm_modeset_ctl *modeset = data;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001450 unsigned int pipe;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001451
1452 /* If drm_vblank_init() hasn't been called yet, just no-op */
1453 if (!dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001454 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001455
Laurent Pinchart29935552012-05-30 00:58:09 +02001456 /* KMS drivers handle this internally */
Daniel Vetterfa538642016-08-03 21:11:10 +02001457 if (!drm_core_check_feature(dev, DRIVER_LEGACY))
Laurent Pinchart29935552012-05-30 00:58:09 +02001458 return 0;
1459
Thierry Redingcc1ef112015-08-12 17:00:31 +02001460 pipe = modeset->crtc;
1461 if (pipe >= dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001462 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001463
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001464 switch (modeset->cmd) {
1465 case _DRM_PRE_MODESET:
Daniel Vetter07600c52016-11-14 10:02:52 +01001466 drm_legacy_vblank_pre_modeset(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001467 break;
1468 case _DRM_POST_MODESET:
Daniel Vetter07600c52016-11-14 10:02:52 +01001469 drm_legacy_vblank_post_modeset(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001470 break;
1471 default:
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001472 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001473 }
1474
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001475 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001476}
1477
Chris Wilson9a4d9ba2017-03-22 10:06:50 +00001478static inline bool vblank_passed(u32 seq, u32 ref)
1479{
1480 return (seq - ref) <= (1 << 23);
1481}
1482
Thierry Redingcc1ef112015-08-12 17:00:31 +02001483static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe,
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001484 union drm_wait_vblank *vblwait,
1485 struct drm_file *file_priv)
1486{
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001487 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001488 struct drm_pending_vblank_event *e;
1489 struct timeval now;
1490 unsigned long flags;
1491 unsigned int seq;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001492 int ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001493
Thierry Redingf76511b2014-12-10 13:03:40 +01001494 e = kzalloc(sizeof(*e), GFP_KERNEL);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001495 if (e == NULL) {
1496 ret = -ENOMEM;
1497 goto err_put;
1498 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001499
1500 e->pipe = pipe;
1501 e->event.base.type = DRM_EVENT_VBLANK;
Thierry Redingf76511b2014-12-10 13:03:40 +01001502 e->event.base.length = sizeof(e->event);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001503 e->event.user_data = vblwait->request.signal;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001504
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001505 spin_lock_irqsave(&dev->event_lock, flags);
1506
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001507 /*
Daniel Vetter2d1e3312016-11-14 10:02:54 +01001508 * drm_crtc_vblank_off() might have been called after we called
1509 * drm_vblank_get(). drm_crtc_vblank_off() holds event_lock around the
1510 * vblank disable, so no need for further locking. The reference from
1511 * drm_vblank_get() protects against vblank disable from another source.
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001512 */
Chris Wilson43dc7fe2017-03-17 20:20:27 +00001513 if (!READ_ONCE(vblank->enabled)) {
Ville Syrjäläffe7c732014-08-06 14:49:52 +03001514 ret = -EINVAL;
1515 goto err_unlock;
1516 }
1517
Daniel Vetter4020b222016-01-28 12:01:04 +01001518 ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
1519 &e->event.base);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001520
Daniel Vetter4020b222016-01-28 12:01:04 +01001521 if (ret)
1522 goto err_unlock;
1523
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001524 seq = drm_vblank_count_and_time(dev, pipe, &now);
1525
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001526 DRM_DEBUG("event on vblank count %u, current %u, crtc %u\n",
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001527 vblwait->request.sequence, seq, pipe);
1528
Daniel Vetter7d52cb882017-03-08 15:12:43 +01001529 trace_drm_vblank_event_queued(file_priv, pipe,
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001530 vblwait->request.sequence);
1531
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001532 e->event.sequence = vblwait->request.sequence;
Chris Wilson9a4d9ba2017-03-22 10:06:50 +00001533 if (vblank_passed(seq, vblwait->request.sequence)) {
Dan Carpenter6f331622010-12-09 08:35:40 +03001534 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001535 send_vblank_event(dev, e, seq, &now);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001536 vblwait->reply.sequence = seq;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001537 } else {
Ilija Hadzica6778e92011-10-31 13:11:57 -04001538 /* drm_handle_vblank_events will call drm_vblank_put */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001539 list_add_tail(&e->base.link, &dev->vblank_event_list);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001540 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001541 }
1542
1543 spin_unlock_irqrestore(&dev->event_lock, flags);
1544
1545 return 0;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001546
1547err_unlock:
1548 spin_unlock_irqrestore(&dev->event_lock, flags);
1549 kfree(e);
1550err_put:
Dan Carpenter6f331622010-12-09 08:35:40 +03001551 drm_vblank_put(dev, pipe);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001552 return ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001553}
1554
Chris Wilsonb33b0272017-03-17 20:20:30 +00001555static bool drm_wait_vblank_is_query(union drm_wait_vblank *vblwait)
1556{
1557 if (vblwait->request.sequence)
1558 return false;
1559
1560 return _DRM_VBLANK_RELATIVE ==
1561 (vblwait->request.type & (_DRM_VBLANK_TYPES_MASK |
1562 _DRM_VBLANK_EVENT |
1563 _DRM_VBLANK_NEXTONMISS));
1564}
1565
Daniel Vetterf5752b32014-05-08 16:41:51 +02001566/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 * Wait for VBLANK.
1568 *
1569 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001570 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 * \param cmd command.
1572 * \param data user argument, pointing to a drm_wait_vblank structure.
1573 * \return zero on success or a negative number on failure.
1574 *
Eric Anholt30b23632009-01-27 21:19:41 -08001575 * This function enables the vblank interrupt on the pipe requested, then
1576 * sleeps waiting for the requested sequence number to occur, and drops
Daniel Vetterf5752b32014-05-08 16:41:51 +02001577 * the vblank interrupt refcount afterwards. (vblank IRQ disable follows that
Eric Anholt30b23632009-01-27 21:19:41 -08001578 * after a timeout with no further vblank waits scheduled).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 */
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001580int drm_wait_vblank(struct drm_device *dev, void *data,
1581 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582{
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001583 struct drm_vblank_crtc *vblank;
Eric Anholtc153f452007-09-03 12:06:45 +10001584 union drm_wait_vblank *vblwait = data;
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001585 int ret;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001586 unsigned int flags, seq, pipe, high_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
Daniel Vetter4984979b2013-08-28 15:02:37 +02001588 if (!dev->irq_enabled)
1589 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
Eric Anholt30b23632009-01-27 21:19:41 -08001591 if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
1592 return -EINVAL;
1593
Eric Anholtc153f452007-09-03 12:06:45 +10001594 if (vblwait->request.type &
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001595 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1596 _DRM_VBLANK_HIGH_CRTC_MASK)) {
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001597 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
Eric Anholtc153f452007-09-03 12:06:45 +10001598 vblwait->request.type,
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001599 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1600 _DRM_VBLANK_HIGH_CRTC_MASK));
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001601 return -EINVAL;
1602 }
1603
Eric Anholtc153f452007-09-03 12:06:45 +10001604 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
Thierry Redingcc1ef112015-08-12 17:00:31 +02001605 high_pipe = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK);
1606 if (high_pipe)
1607 pipe = high_pipe >> _DRM_VBLANK_HIGH_CRTC_SHIFT;
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001608 else
Thierry Redingcc1ef112015-08-12 17:00:31 +02001609 pipe = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
1610 if (pipe >= dev->num_crtcs)
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001611 return -EINVAL;
1612
Thierry Redingcc1ef112015-08-12 17:00:31 +02001613 vblank = &dev->vblank[pipe];
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001614
Chris Wilsonb33b0272017-03-17 20:20:30 +00001615 /* If the counter is currently enabled and accurate, short-circuit
1616 * queries to return the cached timestamp of the last vblank.
1617 */
1618 if (dev->vblank_disable_immediate &&
1619 drm_wait_vblank_is_query(vblwait) &&
1620 READ_ONCE(vblank->enabled)) {
1621 struct timeval now;
1622
1623 vblwait->reply.sequence =
1624 drm_vblank_count_and_time(dev, pipe, &now);
1625 vblwait->reply.tval_sec = now.tv_sec;
1626 vblwait->reply.tval_usec = now.tv_usec;
1627 return 0;
1628 }
1629
Thierry Redingcc1ef112015-08-12 17:00:31 +02001630 ret = drm_vblank_get(dev, pipe);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001631 if (ret) {
Chris Wilson82c8e022017-03-15 20:40:26 +00001632 DRM_DEBUG("crtc %d failed to acquire vblank counter, %d\n", pipe, ret);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001633 return ret;
1634 }
Thierry Redingcc1ef112015-08-12 17:00:31 +02001635 seq = drm_vblank_count(dev, pipe);
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001636
Eric Anholtc153f452007-09-03 12:06:45 +10001637 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 case _DRM_VBLANK_RELATIVE:
Eric Anholtc153f452007-09-03 12:06:45 +10001639 vblwait->request.sequence += seq;
1640 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 case _DRM_VBLANK_ABSOLUTE:
1642 break;
1643 default:
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001644 ret = -EINVAL;
1645 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 }
1647
Michel Dänzer97ef1ae2016-06-24 16:59:47 +09001648 if ((flags & _DRM_VBLANK_NEXTONMISS) &&
Chris Wilson9a4d9ba2017-03-22 10:06:50 +00001649 vblank_passed(seq, vblwait->request.sequence))
Michel Dänzer97ef1ae2016-06-24 16:59:47 +09001650 vblwait->request.sequence = seq + 1;
Michel Dänzer97ef1ae2016-06-24 16:59:47 +09001651
Ilija Hadzica6778e92011-10-31 13:11:57 -04001652 if (flags & _DRM_VBLANK_EVENT) {
1653 /* must hold on to the vblank ref until the event fires
1654 * drm_vblank_put will be called asynchronously
1655 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001656 return drm_queue_vblank_event(dev, pipe, vblwait, file_priv);
Ilija Hadzica6778e92011-10-31 13:11:57 -04001657 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001658
Chris Wilson82c8e022017-03-15 20:40:26 +00001659 if (vblwait->request.sequence != seq) {
1660 DRM_DEBUG("waiting on vblank count %u, crtc %u\n",
1661 vblwait->request.sequence, pipe);
1662 DRM_WAIT_ON(ret, vblank->queue, 3 * HZ,
Chris Wilson9a4d9ba2017-03-22 10:06:50 +00001663 vblank_passed(drm_vblank_count(dev, pipe),
1664 vblwait->request.sequence) ||
Chris Wilson6c06a592017-03-17 20:20:28 +00001665 !READ_ONCE(vblank->enabled));
Chris Wilson82c8e022017-03-15 20:40:26 +00001666 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
Eric Anholt30b23632009-01-27 21:19:41 -08001668 if (ret != -EINTR) {
1669 struct timeval now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
Thierry Redingcc1ef112015-08-12 17:00:31 +02001671 vblwait->reply.sequence = drm_vblank_count_and_time(dev, pipe, &now);
Eric Anholt30b23632009-01-27 21:19:41 -08001672 vblwait->reply.tval_sec = now.tv_sec;
1673 vblwait->reply.tval_usec = now.tv_usec;
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001674
Chris Wilson82c8e022017-03-15 20:40:26 +00001675 DRM_DEBUG("crtc %d returning %u to client\n",
1676 pipe, vblwait->reply.sequence);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 } else {
Chris Wilson82c8e022017-03-15 20:40:26 +00001678 DRM_DEBUG("crtc %d vblank wait interrupted by signal\n", pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 }
1680
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001681done:
Thierry Redingcc1ef112015-08-12 17:00:31 +02001682 drm_vblank_put(dev, pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 return ret;
1684}
1685
Thierry Redingcc1ef112015-08-12 17:00:31 +02001686static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001687{
1688 struct drm_pending_vblank_event *e, *t;
1689 struct timeval now;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001690 unsigned int seq;
1691
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001692 assert_spin_locked(&dev->event_lock);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001693
Thierry Redingcc1ef112015-08-12 17:00:31 +02001694 seq = drm_vblank_count_and_time(dev, pipe, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001695
1696 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
Thierry Redingcc1ef112015-08-12 17:00:31 +02001697 if (e->pipe != pipe)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001698 continue;
Chris Wilson9a4d9ba2017-03-22 10:06:50 +00001699 if (!vblank_passed(seq, e->event.sequence))
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001700 continue;
1701
Rodrigo Vivi1d776852016-08-03 09:53:46 -07001702 DRM_DEBUG("vblank event on %u, current %u\n",
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001703 e->event.sequence, seq);
1704
Rob Clarkc6eefa12012-10-16 22:48:40 +00001705 list_del(&e->base.link);
Thierry Redingcc1ef112015-08-12 17:00:31 +02001706 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001707 send_vblank_event(dev, e, seq, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001708 }
1709
Thierry Redingcc1ef112015-08-12 17:00:31 +02001710 trace_drm_vblank_event(pipe, seq);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001711}
1712
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001714 * drm_handle_vblank - handle a vblank event
1715 * @dev: DRM device
Thierry Redingcc1ef112015-08-12 17:00:31 +02001716 * @pipe: index of CRTC where this event occurred
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001717 *
1718 * Drivers should call this routine in their vblank interrupt handlers to
1719 * update the vblank counter and send any signals that may be pending.
Thierry Reding115ebcd2014-12-15 14:47:18 +01001720 *
1721 * This is the legacy version of drm_crtc_handle_vblank().
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001722 */
Thierry Redingcc1ef112015-08-12 17:00:31 +02001723bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001724{
Thierry Redingcc1ef112015-08-12 17:00:31 +02001725 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001726 unsigned long irqflags;
Chris Wilson75cff082017-03-24 17:30:58 +00001727 bool disable_irq;
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001728
Daniel Vetteree3c7792015-02-22 15:11:20 +01001729 if (WARN_ON_ONCE(!dev->num_crtcs))
Chris Wilson78c6e172011-01-31 10:48:04 +00001730 return false;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001731
Thierry Redingcc1ef112015-08-12 17:00:31 +02001732 if (WARN_ON(pipe >= dev->num_crtcs))
Rob Clarke6ae8682014-08-06 13:16:59 -04001733 return false;
1734
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001735 spin_lock_irqsave(&dev->event_lock, irqflags);
1736
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001737 /* Need timestamp lock to prevent concurrent execution with
1738 * vblank enable/disable, as this would cause inconsistent
1739 * or corrupted timestamps and vblank counts.
1740 */
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001741 spin_lock(&dev->vblank_time_lock);
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001742
1743 /* Vblank irq handling disabled. Nothing to do. */
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001744 if (!vblank->enabled) {
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001745 spin_unlock(&dev->vblank_time_lock);
1746 spin_unlock_irqrestore(&dev->event_lock, irqflags);
Chris Wilson78c6e172011-01-31 10:48:04 +00001747 return false;
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001748 }
1749
Ville Syrjälä4dfd6482015-09-14 22:43:51 +03001750 drm_update_vblank_count(dev, pipe, DRM_CALLED_FROM_VBLIRQ);
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001751
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001752 spin_unlock(&dev->vblank_time_lock);
1753
Ville Syrjälä8a51d5b2014-08-06 14:49:50 +03001754 wake_up(&vblank->queue);
Mario Kleiner27641c3f2010-10-23 04:20:23 +02001755
Chris Wilson608b2052017-03-15 20:40:25 +00001756 /* With instant-off, we defer disabling the interrupt until after
Chris Wilson75cff082017-03-24 17:30:58 +00001757 * we finish processing the following vblank after all events have
1758 * been signaled. The disable has to be last (after
1759 * drm_handle_vblank_events) so that the timestamp is always accurate.
Chris Wilson608b2052017-03-15 20:40:25 +00001760 */
Chris Wilson75cff082017-03-24 17:30:58 +00001761 disable_irq = (dev->vblank_disable_immediate &&
1762 drm_vblank_offdelay > 0 &&
1763 !atomic_read(&vblank->refcount));
1764
1765 drm_handle_vblank_events(dev, pipe);
Chris Wilson608b2052017-03-15 20:40:25 +00001766
Ville Syrjälä56cc2792014-08-06 14:49:51 +03001767 spin_unlock_irqrestore(&dev->event_lock, irqflags);
1768
Chris Wilson75cff082017-03-24 17:30:58 +00001769 if (disable_irq)
1770 vblank_disable_fn((unsigned long)vblank);
1771
Chris Wilson78c6e172011-01-31 10:48:04 +00001772 return true;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001773}
1774EXPORT_SYMBOL(drm_handle_vblank);
Thierry Reding115ebcd2014-12-15 14:47:18 +01001775
1776/**
1777 * drm_crtc_handle_vblank - handle a vblank event
1778 * @crtc: where this event occurred
1779 *
1780 * Drivers should call this routine in their vblank interrupt handlers to
1781 * update the vblank counter and send any signals that may be pending.
1782 *
1783 * This is the native KMS version of drm_handle_vblank().
1784 *
1785 * Returns:
1786 * True if the event was successfully handled, false on failure.
1787 */
1788bool drm_crtc_handle_vblank(struct drm_crtc *crtc)
1789{
1790 return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
1791}
1792EXPORT_SYMBOL(drm_crtc_handle_vblank);