xref: /freebsd-src/sys/dev/drm2/drm_irq.c (revision 685dc743dc3b5645e34836464128e1c0558b404b)
1*592ffb21SWarner Losh /**
2*592ffb21SWarner Losh  * \file drm_irq.c
3*592ffb21SWarner Losh  * IRQ support
4*592ffb21SWarner Losh  *
5*592ffb21SWarner Losh  * \author Rickard E. (Rik) Faith <faith@valinux.com>
6*592ffb21SWarner Losh  * \author Gareth Hughes <gareth@valinux.com>
7*592ffb21SWarner Losh  */
8*592ffb21SWarner Losh 
9*592ffb21SWarner Losh /*
10*592ffb21SWarner Losh  * Created: Fri Mar 19 14:30:16 1999 by faith@valinux.com
11*592ffb21SWarner Losh  *
12*592ffb21SWarner Losh  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
13*592ffb21SWarner Losh  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14*592ffb21SWarner Losh  * All Rights Reserved.
15*592ffb21SWarner Losh  *
16*592ffb21SWarner Losh  * Permission is hereby granted, free of charge, to any person obtaining a
17*592ffb21SWarner Losh  * copy of this software and associated documentation files (the "Software"),
18*592ffb21SWarner Losh  * to deal in the Software without restriction, including without limitation
19*592ffb21SWarner Losh  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20*592ffb21SWarner Losh  * and/or sell copies of the Software, and to permit persons to whom the
21*592ffb21SWarner Losh  * Software is furnished to do so, subject to the following conditions:
22*592ffb21SWarner Losh  *
23*592ffb21SWarner Losh  * The above copyright notice and this permission notice (including the next
24*592ffb21SWarner Losh  * paragraph) shall be included in all copies or substantial portions of the
25*592ffb21SWarner Losh  * Software.
26*592ffb21SWarner Losh  *
27*592ffb21SWarner Losh  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28*592ffb21SWarner Losh  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29*592ffb21SWarner Losh  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
30*592ffb21SWarner Losh  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31*592ffb21SWarner Losh  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32*592ffb21SWarner Losh  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33*592ffb21SWarner Losh  * OTHER DEALINGS IN THE SOFTWARE.
34*592ffb21SWarner Losh  */
35*592ffb21SWarner Losh 
36*592ffb21SWarner Losh #include <sys/cdefs.h>
37*592ffb21SWarner Losh #include <dev/drm2/drmP.h>
38*592ffb21SWarner Losh 
39*592ffb21SWarner Losh /* Access macro for slots in vblank timestamp ringbuffer. */
40*592ffb21SWarner Losh #define vblanktimestamp(dev, crtc, count) ( \
41*592ffb21SWarner Losh 	(dev)->_vblank_time[(crtc) * DRM_VBLANKTIME_RBSIZE + \
42*592ffb21SWarner Losh 	((count) % DRM_VBLANKTIME_RBSIZE)])
43*592ffb21SWarner Losh 
44*592ffb21SWarner Losh /* Retry timestamp calculation up to 3 times to satisfy
45*592ffb21SWarner Losh  * drm_timestamp_precision before giving up.
46*592ffb21SWarner Losh  */
47*592ffb21SWarner Losh #define DRM_TIMESTAMP_MAXRETRIES 3
48*592ffb21SWarner Losh 
49*592ffb21SWarner Losh /* Threshold in nanoseconds for detection of redundant
50*592ffb21SWarner Losh  * vblank irq in drm_handle_vblank(). 1 msec should be ok.
51*592ffb21SWarner Losh  */
52*592ffb21SWarner Losh #define DRM_REDUNDANT_VBLIRQ_THRESH_NS 1000000
53*592ffb21SWarner Losh 
54*592ffb21SWarner Losh /**
55*592ffb21SWarner Losh  * Get interrupt from bus id.
56*592ffb21SWarner Losh  *
57*592ffb21SWarner Losh  * \param inode device inode.
58*592ffb21SWarner Losh  * \param file_priv DRM file private.
59*592ffb21SWarner Losh  * \param cmd command.
60*592ffb21SWarner Losh  * \param arg user argument, pointing to a drm_irq_busid structure.
61*592ffb21SWarner Losh  * \return zero on success or a negative number on failure.
62*592ffb21SWarner Losh  *
63*592ffb21SWarner Losh  * Finds the PCI device with the specified bus id and gets its IRQ number.
64*592ffb21SWarner Losh  * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
65*592ffb21SWarner Losh  * to that of the device that this DRM instance attached to.
66*592ffb21SWarner Losh  */
drm_irq_by_busid(struct drm_device * dev,void * data,struct drm_file * file_priv)67*592ffb21SWarner Losh int drm_irq_by_busid(struct drm_device *dev, void *data,
68*592ffb21SWarner Losh 		     struct drm_file *file_priv)
69*592ffb21SWarner Losh {
70*592ffb21SWarner Losh 	struct drm_irq_busid *p = data;
71*592ffb21SWarner Losh 
72*592ffb21SWarner Losh 	if (!dev->driver->bus->irq_by_busid)
73*592ffb21SWarner Losh 		return -EINVAL;
74*592ffb21SWarner Losh 
75*592ffb21SWarner Losh 	if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
76*592ffb21SWarner Losh 		return -EINVAL;
77*592ffb21SWarner Losh 
78*592ffb21SWarner Losh 	return dev->driver->bus->irq_by_busid(dev, p);
79*592ffb21SWarner Losh }
80*592ffb21SWarner Losh 
81*592ffb21SWarner Losh /*
82*592ffb21SWarner Losh  * Clear vblank timestamp buffer for a crtc.
83*592ffb21SWarner Losh  */
clear_vblank_timestamps(struct drm_device * dev,int crtc)84*592ffb21SWarner Losh static void clear_vblank_timestamps(struct drm_device *dev, int crtc)
85*592ffb21SWarner Losh {
86*592ffb21SWarner Losh 	memset(&dev->_vblank_time[crtc * DRM_VBLANKTIME_RBSIZE], 0,
87*592ffb21SWarner Losh 		DRM_VBLANKTIME_RBSIZE * sizeof(struct timeval));
88*592ffb21SWarner Losh }
89*592ffb21SWarner Losh 
90*592ffb21SWarner Losh /*
91*592ffb21SWarner Losh  * Disable vblank irq's on crtc, make sure that last vblank count
92*592ffb21SWarner Losh  * of hardware and corresponding consistent software vblank counter
93*592ffb21SWarner Losh  * are preserved, even if there are any spurious vblank irq's after
94*592ffb21SWarner Losh  * disable.
95*592ffb21SWarner Losh  */
vblank_disable_and_save(struct drm_device * dev,int crtc)96*592ffb21SWarner Losh static void vblank_disable_and_save(struct drm_device *dev, int crtc)
97*592ffb21SWarner Losh {
98*592ffb21SWarner Losh 	u32 vblcount;
99*592ffb21SWarner Losh 	s64 diff_ns;
100*592ffb21SWarner Losh 	int vblrc;
101*592ffb21SWarner Losh 	struct timeval tvblank;
102*592ffb21SWarner Losh 	int count = DRM_TIMESTAMP_MAXRETRIES;
103*592ffb21SWarner Losh 
104*592ffb21SWarner Losh 	/* Prevent vblank irq processing while disabling vblank irqs,
105*592ffb21SWarner Losh 	 * so no updates of timestamps or count can happen after we've
106*592ffb21SWarner Losh 	 * disabled. Needed to prevent races in case of delayed irq's.
107*592ffb21SWarner Losh 	 */
108*592ffb21SWarner Losh 	mtx_lock(&dev->vblank_time_lock);
109*592ffb21SWarner Losh 
110*592ffb21SWarner Losh 	dev->driver->disable_vblank(dev, crtc);
111*592ffb21SWarner Losh 	dev->vblank_enabled[crtc] = 0;
112*592ffb21SWarner Losh 
113*592ffb21SWarner Losh 	/* No further vblank irq's will be processed after
114*592ffb21SWarner Losh 	 * this point. Get current hardware vblank count and
115*592ffb21SWarner Losh 	 * vblank timestamp, repeat until they are consistent.
116*592ffb21SWarner Losh 	 *
117*592ffb21SWarner Losh 	 * FIXME: There is still a race condition here and in
118*592ffb21SWarner Losh 	 * drm_update_vblank_count() which can cause off-by-one
119*592ffb21SWarner Losh 	 * reinitialization of software vblank counter. If gpu
120*592ffb21SWarner Losh 	 * vblank counter doesn't increment exactly at the leading
121*592ffb21SWarner Losh 	 * edge of a vblank interval, then we can lose 1 count if
122*592ffb21SWarner Losh 	 * we happen to execute between start of vblank and the
123*592ffb21SWarner Losh 	 * delayed gpu counter increment.
124*592ffb21SWarner Losh 	 */
125*592ffb21SWarner Losh 	do {
126*592ffb21SWarner Losh 		dev->last_vblank[crtc] = dev->driver->get_vblank_counter(dev, crtc);
127*592ffb21SWarner Losh 		vblrc = drm_get_last_vbltimestamp(dev, crtc, &tvblank, 0);
128*592ffb21SWarner Losh 	} while (dev->last_vblank[crtc] != dev->driver->get_vblank_counter(dev, crtc) && (--count) && vblrc);
129*592ffb21SWarner Losh 
130*592ffb21SWarner Losh 	if (!count)
131*592ffb21SWarner Losh 		vblrc = 0;
132*592ffb21SWarner Losh 
133*592ffb21SWarner Losh 	/* Compute time difference to stored timestamp of last vblank
134*592ffb21SWarner Losh 	 * as updated by last invocation of drm_handle_vblank() in vblank irq.
135*592ffb21SWarner Losh 	 */
136*592ffb21SWarner Losh 	vblcount = atomic_read(&dev->_vblank_count[crtc]);
137*592ffb21SWarner Losh 	diff_ns = timeval_to_ns(&tvblank) -
138*592ffb21SWarner Losh 		  timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount));
139*592ffb21SWarner Losh 
140*592ffb21SWarner Losh 	/* If there is at least 1 msec difference between the last stored
141*592ffb21SWarner Losh 	 * timestamp and tvblank, then we are currently executing our
142*592ffb21SWarner Losh 	 * disable inside a new vblank interval, the tvblank timestamp
143*592ffb21SWarner Losh 	 * corresponds to this new vblank interval and the irq handler
144*592ffb21SWarner Losh 	 * for this vblank didn't run yet and won't run due to our disable.
145*592ffb21SWarner Losh 	 * Therefore we need to do the job of drm_handle_vblank() and
146*592ffb21SWarner Losh 	 * increment the vblank counter by one to account for this vblank.
147*592ffb21SWarner Losh 	 *
148*592ffb21SWarner Losh 	 * Skip this step if there isn't any high precision timestamp
149*592ffb21SWarner Losh 	 * available. In that case we can't account for this and just
150*592ffb21SWarner Losh 	 * hope for the best.
151*592ffb21SWarner Losh 	 */
152*592ffb21SWarner Losh 	if ((vblrc > 0) && (abs64(diff_ns) > 1000000)) {
153*592ffb21SWarner Losh 		atomic_inc(&dev->_vblank_count[crtc]);
154*592ffb21SWarner Losh 		smp_mb__after_atomic_inc();
155*592ffb21SWarner Losh 	}
156*592ffb21SWarner Losh 
157*592ffb21SWarner Losh 	/* Invalidate all timestamps while vblank irq's are off. */
158*592ffb21SWarner Losh 	clear_vblank_timestamps(dev, crtc);
159*592ffb21SWarner Losh 
160*592ffb21SWarner Losh 	mtx_unlock(&dev->vblank_time_lock);
161*592ffb21SWarner Losh }
162*592ffb21SWarner Losh 
vblank_disable_fn(void * arg)163*592ffb21SWarner Losh static void vblank_disable_fn(void *arg)
164*592ffb21SWarner Losh {
165*592ffb21SWarner Losh 	struct drm_device *dev = (struct drm_device *)arg;
166*592ffb21SWarner Losh 	int i;
167*592ffb21SWarner Losh 
168*592ffb21SWarner Losh 	if (!dev->vblank_disable_allowed)
169*592ffb21SWarner Losh 		return;
170*592ffb21SWarner Losh 
171*592ffb21SWarner Losh 	for (i = 0; i < dev->num_crtcs; i++) {
172*592ffb21SWarner Losh 		mtx_lock(&dev->vbl_lock);
173*592ffb21SWarner Losh 		if (atomic_read(&dev->vblank_refcount[i]) == 0 &&
174*592ffb21SWarner Losh 		    dev->vblank_enabled[i]) {
175*592ffb21SWarner Losh 			DRM_DEBUG("disabling vblank on crtc %d\n", i);
176*592ffb21SWarner Losh 			vblank_disable_and_save(dev, i);
177*592ffb21SWarner Losh 		}
178*592ffb21SWarner Losh 		mtx_unlock(&dev->vbl_lock);
179*592ffb21SWarner Losh 	}
180*592ffb21SWarner Losh }
181*592ffb21SWarner Losh 
drm_vblank_cleanup(struct drm_device * dev)182*592ffb21SWarner Losh void drm_vblank_cleanup(struct drm_device *dev)
183*592ffb21SWarner Losh {
184*592ffb21SWarner Losh 	/* Bail if the driver didn't call drm_vblank_init() */
185*592ffb21SWarner Losh 	if (dev->num_crtcs == 0)
186*592ffb21SWarner Losh 		return;
187*592ffb21SWarner Losh 
188*592ffb21SWarner Losh 	callout_stop(&dev->vblank_disable_callout);
189*592ffb21SWarner Losh 
190*592ffb21SWarner Losh 	vblank_disable_fn(dev);
191*592ffb21SWarner Losh 
192*592ffb21SWarner Losh 	free(dev->_vblank_count, DRM_MEM_VBLANK);
193*592ffb21SWarner Losh 	free(dev->vblank_refcount, DRM_MEM_VBLANK);
194*592ffb21SWarner Losh 	free(dev->vblank_enabled, DRM_MEM_VBLANK);
195*592ffb21SWarner Losh 	free(dev->last_vblank, DRM_MEM_VBLANK);
196*592ffb21SWarner Losh 	free(dev->last_vblank_wait, DRM_MEM_VBLANK);
197*592ffb21SWarner Losh 	free(dev->vblank_inmodeset, DRM_MEM_VBLANK);
198*592ffb21SWarner Losh 	free(dev->_vblank_time, DRM_MEM_VBLANK);
199*592ffb21SWarner Losh 
200*592ffb21SWarner Losh 	mtx_destroy(&dev->vbl_lock);
201*592ffb21SWarner Losh 	mtx_destroy(&dev->vblank_time_lock);
202*592ffb21SWarner Losh 
203*592ffb21SWarner Losh 	dev->num_crtcs = 0;
204*592ffb21SWarner Losh }
205*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_cleanup);
206*592ffb21SWarner Losh 
drm_vblank_init(struct drm_device * dev,int num_crtcs)207*592ffb21SWarner Losh int drm_vblank_init(struct drm_device *dev, int num_crtcs)
208*592ffb21SWarner Losh {
209*592ffb21SWarner Losh 	int i, ret = -ENOMEM;
210*592ffb21SWarner Losh 
211*592ffb21SWarner Losh 	callout_init(&dev->vblank_disable_callout, 1);
212*592ffb21SWarner Losh 	mtx_init(&dev->vbl_lock, "drmvbl", NULL, MTX_DEF);
213*592ffb21SWarner Losh 	mtx_init(&dev->vblank_time_lock, "drmvtl", NULL, MTX_DEF);
214*592ffb21SWarner Losh 
215*592ffb21SWarner Losh 	dev->num_crtcs = num_crtcs;
216*592ffb21SWarner Losh 
217*592ffb21SWarner Losh 	dev->_vblank_count = malloc(sizeof(atomic_t) * num_crtcs,
218*592ffb21SWarner Losh 	    DRM_MEM_VBLANK, M_NOWAIT);
219*592ffb21SWarner Losh 	if (!dev->_vblank_count)
220*592ffb21SWarner Losh 		goto err;
221*592ffb21SWarner Losh 
222*592ffb21SWarner Losh 	dev->vblank_refcount = malloc(sizeof(atomic_t) * num_crtcs,
223*592ffb21SWarner Losh 	    DRM_MEM_VBLANK, M_NOWAIT);
224*592ffb21SWarner Losh 	if (!dev->vblank_refcount)
225*592ffb21SWarner Losh 		goto err;
226*592ffb21SWarner Losh 
227*592ffb21SWarner Losh 	dev->vblank_enabled = malloc(num_crtcs * sizeof(int),
228*592ffb21SWarner Losh 	    DRM_MEM_VBLANK, M_NOWAIT | M_ZERO);
229*592ffb21SWarner Losh 	if (!dev->vblank_enabled)
230*592ffb21SWarner Losh 		goto err;
231*592ffb21SWarner Losh 
232*592ffb21SWarner Losh 	dev->last_vblank = malloc(num_crtcs * sizeof(u32),
233*592ffb21SWarner Losh 	    DRM_MEM_VBLANK, M_NOWAIT | M_ZERO);
234*592ffb21SWarner Losh 	if (!dev->last_vblank)
235*592ffb21SWarner Losh 		goto err;
236*592ffb21SWarner Losh 
237*592ffb21SWarner Losh 	dev->last_vblank_wait = malloc(num_crtcs * sizeof(u32),
238*592ffb21SWarner Losh 	    DRM_MEM_VBLANK, M_NOWAIT | M_ZERO);
239*592ffb21SWarner Losh 	if (!dev->last_vblank_wait)
240*592ffb21SWarner Losh 		goto err;
241*592ffb21SWarner Losh 
242*592ffb21SWarner Losh 	dev->vblank_inmodeset = malloc(num_crtcs * sizeof(int),
243*592ffb21SWarner Losh 	    DRM_MEM_VBLANK, M_NOWAIT | M_ZERO);
244*592ffb21SWarner Losh 	if (!dev->vblank_inmodeset)
245*592ffb21SWarner Losh 		goto err;
246*592ffb21SWarner Losh 
247*592ffb21SWarner Losh 	dev->_vblank_time = malloc(num_crtcs * DRM_VBLANKTIME_RBSIZE *
248*592ffb21SWarner Losh 	    sizeof(struct timeval), DRM_MEM_VBLANK, M_NOWAIT | M_ZERO);
249*592ffb21SWarner Losh 	if (!dev->_vblank_time)
250*592ffb21SWarner Losh 		goto err;
251*592ffb21SWarner Losh 
252*592ffb21SWarner Losh 	DRM_INFO("Supports vblank timestamp caching Rev 1 (10.10.2010).\n");
253*592ffb21SWarner Losh 
254*592ffb21SWarner Losh 	/* Driver specific high-precision vblank timestamping supported? */
255*592ffb21SWarner Losh 	if (dev->driver->get_vblank_timestamp)
256*592ffb21SWarner Losh 		DRM_INFO("Driver supports precise vblank timestamp query.\n");
257*592ffb21SWarner Losh 	else
258*592ffb21SWarner Losh 		DRM_INFO("No driver support for vblank timestamp query.\n");
259*592ffb21SWarner Losh 
260*592ffb21SWarner Losh 	/* Zero per-crtc vblank stuff */
261*592ffb21SWarner Losh 	for (i = 0; i < num_crtcs; i++) {
262*592ffb21SWarner Losh 		atomic_set(&dev->_vblank_count[i], 0);
263*592ffb21SWarner Losh 		atomic_set(&dev->vblank_refcount[i], 0);
264*592ffb21SWarner Losh 	}
265*592ffb21SWarner Losh 
266*592ffb21SWarner Losh 	dev->vblank_disable_allowed = 0;
267*592ffb21SWarner Losh 	return 0;
268*592ffb21SWarner Losh 
269*592ffb21SWarner Losh err:
270*592ffb21SWarner Losh 	drm_vblank_cleanup(dev);
271*592ffb21SWarner Losh 	return ret;
272*592ffb21SWarner Losh }
273*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_init);
274*592ffb21SWarner Losh 
275*592ffb21SWarner Losh /**
276*592ffb21SWarner Losh  * Install IRQ handler.
277*592ffb21SWarner Losh  *
278*592ffb21SWarner Losh  * \param dev DRM device.
279*592ffb21SWarner Losh  *
280*592ffb21SWarner Losh  * Initializes the IRQ related data. Installs the handler, calling the driver
281*592ffb21SWarner Losh  * \c irq_preinstall() and \c irq_postinstall() functions
282*592ffb21SWarner Losh  * before and after the installation.
283*592ffb21SWarner Losh  */
drm_irq_install(struct drm_device * dev)284*592ffb21SWarner Losh int drm_irq_install(struct drm_device *dev)
285*592ffb21SWarner Losh {
286*592ffb21SWarner Losh 	int ret;
287*592ffb21SWarner Losh 	unsigned long sh_flags = 0;
288*592ffb21SWarner Losh 
289*592ffb21SWarner Losh 	if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
290*592ffb21SWarner Losh 		return -EINVAL;
291*592ffb21SWarner Losh 
292*592ffb21SWarner Losh 	if (drm_dev_to_irq(dev) == 0)
293*592ffb21SWarner Losh 		return -EINVAL;
294*592ffb21SWarner Losh 
295*592ffb21SWarner Losh 	DRM_LOCK(dev);
296*592ffb21SWarner Losh 
297*592ffb21SWarner Losh 	/* Driver must have been initialized */
298*592ffb21SWarner Losh 	if (!dev->dev_private) {
299*592ffb21SWarner Losh 		DRM_UNLOCK(dev);
300*592ffb21SWarner Losh 		return -EINVAL;
301*592ffb21SWarner Losh 	}
302*592ffb21SWarner Losh 
303*592ffb21SWarner Losh 	if (dev->irq_enabled) {
304*592ffb21SWarner Losh 		DRM_UNLOCK(dev);
305*592ffb21SWarner Losh 		return -EBUSY;
306*592ffb21SWarner Losh 	}
307*592ffb21SWarner Losh 	dev->irq_enabled = 1;
308*592ffb21SWarner Losh 	DRM_UNLOCK(dev);
309*592ffb21SWarner Losh 
310*592ffb21SWarner Losh 	DRM_DEBUG("irq=%d\n", drm_dev_to_irq(dev));
311*592ffb21SWarner Losh 
312*592ffb21SWarner Losh 	/* Before installing handler */
313*592ffb21SWarner Losh 	if (dev->driver->irq_preinstall)
314*592ffb21SWarner Losh 		dev->driver->irq_preinstall(dev);
315*592ffb21SWarner Losh 
316*592ffb21SWarner Losh 	/* Install handler */
317*592ffb21SWarner Losh 	sh_flags = INTR_TYPE_TTY | INTR_MPSAFE;
318*592ffb21SWarner Losh 	if (!drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
319*592ffb21SWarner Losh 		/*
320*592ffb21SWarner Losh 		 * FIXME Linux<->FreeBSD: This seems to make
321*592ffb21SWarner Losh 		 * bus_setup_intr() unhappy: it was reported to return
322*592ffb21SWarner Losh 		 * EINVAL on an i915 board (8086:2592 in a Thinkpad
323*592ffb21SWarner Losh 		 * X41).
324*592ffb21SWarner Losh 		 *
325*592ffb21SWarner Losh 		 * For now, no driver we have use that.
326*592ffb21SWarner Losh 		 */
327*592ffb21SWarner Losh 		sh_flags |= INTR_EXCL;
328*592ffb21SWarner Losh 
329*592ffb21SWarner Losh 	ret = -bus_setup_intr(dev->dev, dev->irqr, sh_flags, NULL,
330*592ffb21SWarner Losh 	    dev->driver->irq_handler, dev, &dev->irqh);
331*592ffb21SWarner Losh 
332*592ffb21SWarner Losh 	if (ret < 0) {
333*592ffb21SWarner Losh 		device_printf(dev->dev, "Error setting interrupt: %d\n", -ret);
334*592ffb21SWarner Losh 		DRM_LOCK(dev);
335*592ffb21SWarner Losh 		dev->irq_enabled = 0;
336*592ffb21SWarner Losh 		DRM_UNLOCK(dev);
337*592ffb21SWarner Losh 		return ret;
338*592ffb21SWarner Losh 	}
339*592ffb21SWarner Losh 
340*592ffb21SWarner Losh 	/* After installing handler */
341*592ffb21SWarner Losh 	if (dev->driver->irq_postinstall)
342*592ffb21SWarner Losh 		ret = dev->driver->irq_postinstall(dev);
343*592ffb21SWarner Losh 
344*592ffb21SWarner Losh 	if (ret < 0) {
345*592ffb21SWarner Losh 		DRM_LOCK(dev);
346*592ffb21SWarner Losh 		dev->irq_enabled = 0;
347*592ffb21SWarner Losh 		DRM_UNLOCK(dev);
348*592ffb21SWarner Losh 		bus_teardown_intr(dev->dev, dev->irqr, dev->irqh);
349*592ffb21SWarner Losh 		dev->driver->bus->free_irq(dev);
350*592ffb21SWarner Losh 	}
351*592ffb21SWarner Losh 
352*592ffb21SWarner Losh 	return ret;
353*592ffb21SWarner Losh }
354*592ffb21SWarner Losh EXPORT_SYMBOL(drm_irq_install);
355*592ffb21SWarner Losh 
356*592ffb21SWarner Losh /**
357*592ffb21SWarner Losh  * Uninstall the IRQ handler.
358*592ffb21SWarner Losh  *
359*592ffb21SWarner Losh  * \param dev DRM device.
360*592ffb21SWarner Losh  *
361*592ffb21SWarner Losh  * Calls the driver's \c irq_uninstall() function, and stops the irq.
362*592ffb21SWarner Losh  */
drm_irq_uninstall(struct drm_device * dev)363*592ffb21SWarner Losh int drm_irq_uninstall(struct drm_device *dev)
364*592ffb21SWarner Losh {
365*592ffb21SWarner Losh 	int irq_enabled, i;
366*592ffb21SWarner Losh 
367*592ffb21SWarner Losh 	if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
368*592ffb21SWarner Losh 		return -EINVAL;
369*592ffb21SWarner Losh 
370*592ffb21SWarner Losh 	DRM_LOCK(dev);
371*592ffb21SWarner Losh 	irq_enabled = dev->irq_enabled;
372*592ffb21SWarner Losh 	dev->irq_enabled = 0;
373*592ffb21SWarner Losh 	DRM_UNLOCK(dev);
374*592ffb21SWarner Losh 
375*592ffb21SWarner Losh 	/*
376*592ffb21SWarner Losh 	 * Wake up any waiters so they don't hang.
377*592ffb21SWarner Losh 	 */
378*592ffb21SWarner Losh 	if (dev->num_crtcs) {
379*592ffb21SWarner Losh 		mtx_lock(&dev->vbl_lock);
380*592ffb21SWarner Losh 		for (i = 0; i < dev->num_crtcs; i++) {
381*592ffb21SWarner Losh 			DRM_WAKEUP(&dev->_vblank_count[i]);
382*592ffb21SWarner Losh 			dev->vblank_enabled[i] = 0;
383*592ffb21SWarner Losh 			dev->last_vblank[i] =
384*592ffb21SWarner Losh 				dev->driver->get_vblank_counter(dev, i);
385*592ffb21SWarner Losh 		}
386*592ffb21SWarner Losh 		mtx_unlock(&dev->vbl_lock);
387*592ffb21SWarner Losh 	}
388*592ffb21SWarner Losh 
389*592ffb21SWarner Losh 	if (!irq_enabled)
390*592ffb21SWarner Losh 		return -EINVAL;
391*592ffb21SWarner Losh 
392*592ffb21SWarner Losh 	DRM_DEBUG("irq=%d\n", drm_dev_to_irq(dev));
393*592ffb21SWarner Losh 
394*592ffb21SWarner Losh 	if (dev->driver->irq_uninstall)
395*592ffb21SWarner Losh 		dev->driver->irq_uninstall(dev);
396*592ffb21SWarner Losh 
397*592ffb21SWarner Losh 	bus_teardown_intr(dev->dev, dev->irqr, dev->irqh);
398*592ffb21SWarner Losh 	dev->driver->bus->free_irq(dev);
399*592ffb21SWarner Losh 
400*592ffb21SWarner Losh 	return 0;
401*592ffb21SWarner Losh }
402*592ffb21SWarner Losh EXPORT_SYMBOL(drm_irq_uninstall);
403*592ffb21SWarner Losh 
404*592ffb21SWarner Losh /**
405*592ffb21SWarner Losh  * IRQ control ioctl.
406*592ffb21SWarner Losh  *
407*592ffb21SWarner Losh  * \param inode device inode.
408*592ffb21SWarner Losh  * \param file_priv DRM file private.
409*592ffb21SWarner Losh  * \param cmd command.
410*592ffb21SWarner Losh  * \param arg user argument, pointing to a drm_control structure.
411*592ffb21SWarner Losh  * \return zero on success or a negative number on failure.
412*592ffb21SWarner Losh  *
413*592ffb21SWarner Losh  * Calls irq_install() or irq_uninstall() according to \p arg.
414*592ffb21SWarner Losh  */
drm_control(struct drm_device * dev,void * data,struct drm_file * file_priv)415*592ffb21SWarner Losh int drm_control(struct drm_device *dev, void *data,
416*592ffb21SWarner Losh 		struct drm_file *file_priv)
417*592ffb21SWarner Losh {
418*592ffb21SWarner Losh 	struct drm_control *ctl = data;
419*592ffb21SWarner Losh 
420*592ffb21SWarner Losh 	/* if we haven't irq we fallback for compatibility reasons -
421*592ffb21SWarner Losh 	 * this used to be a separate function in drm_dma.h
422*592ffb21SWarner Losh 	 */
423*592ffb21SWarner Losh 
424*592ffb21SWarner Losh 
425*592ffb21SWarner Losh 	switch (ctl->func) {
426*592ffb21SWarner Losh 	case DRM_INST_HANDLER:
427*592ffb21SWarner Losh 		if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
428*592ffb21SWarner Losh 			return 0;
429*592ffb21SWarner Losh 		if (drm_core_check_feature(dev, DRIVER_MODESET))
430*592ffb21SWarner Losh 			return 0;
431*592ffb21SWarner Losh 		if (dev->if_version < DRM_IF_VERSION(1, 2) &&
432*592ffb21SWarner Losh 		    ctl->irq != drm_dev_to_irq(dev))
433*592ffb21SWarner Losh 			return -EINVAL;
434*592ffb21SWarner Losh 		return drm_irq_install(dev);
435*592ffb21SWarner Losh 	case DRM_UNINST_HANDLER:
436*592ffb21SWarner Losh 		if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
437*592ffb21SWarner Losh 			return 0;
438*592ffb21SWarner Losh 		if (drm_core_check_feature(dev, DRIVER_MODESET))
439*592ffb21SWarner Losh 			return 0;
440*592ffb21SWarner Losh 		return drm_irq_uninstall(dev);
441*592ffb21SWarner Losh 	default:
442*592ffb21SWarner Losh 		return -EINVAL;
443*592ffb21SWarner Losh 	}
444*592ffb21SWarner Losh }
445*592ffb21SWarner Losh 
446*592ffb21SWarner Losh /**
447*592ffb21SWarner Losh  * drm_calc_timestamping_constants - Calculate and
448*592ffb21SWarner Losh  * store various constants which are later needed by
449*592ffb21SWarner Losh  * vblank and swap-completion timestamping, e.g, by
450*592ffb21SWarner Losh  * drm_calc_vbltimestamp_from_scanoutpos().
451*592ffb21SWarner Losh  * They are derived from crtc's true scanout timing,
452*592ffb21SWarner Losh  * so they take things like panel scaling or other
453*592ffb21SWarner Losh  * adjustments into account.
454*592ffb21SWarner Losh  *
455*592ffb21SWarner Losh  * @crtc drm_crtc whose timestamp constants should be updated.
456*592ffb21SWarner Losh  *
457*592ffb21SWarner Losh  */
drm_calc_timestamping_constants(struct drm_crtc * crtc)458*592ffb21SWarner Losh void drm_calc_timestamping_constants(struct drm_crtc *crtc)
459*592ffb21SWarner Losh {
460*592ffb21SWarner Losh 	s64 linedur_ns = 0, pixeldur_ns = 0, framedur_ns = 0;
461*592ffb21SWarner Losh 	u64 dotclock;
462*592ffb21SWarner Losh 
463*592ffb21SWarner Losh 	/* Dot clock in Hz: */
464*592ffb21SWarner Losh 	dotclock = (u64) crtc->hwmode.clock * 1000;
465*592ffb21SWarner Losh 
466*592ffb21SWarner Losh 	/* Fields of interlaced scanout modes are only halve a frame duration.
467*592ffb21SWarner Losh 	 * Double the dotclock to get halve the frame-/line-/pixelduration.
468*592ffb21SWarner Losh 	 */
469*592ffb21SWarner Losh 	if (crtc->hwmode.flags & DRM_MODE_FLAG_INTERLACE)
470*592ffb21SWarner Losh 		dotclock *= 2;
471*592ffb21SWarner Losh 
472*592ffb21SWarner Losh 	/* Valid dotclock? */
473*592ffb21SWarner Losh 	if (dotclock > 0) {
474*592ffb21SWarner Losh 		/* Convert scanline length in pixels and video dot clock to
475*592ffb21SWarner Losh 		 * line duration, frame duration and pixel duration in
476*592ffb21SWarner Losh 		 * nanoseconds:
477*592ffb21SWarner Losh 		 */
478*592ffb21SWarner Losh 		pixeldur_ns = (s64) div64_u64(1000000000, dotclock);
479*592ffb21SWarner Losh 		linedur_ns  = (s64) div64_u64(((u64) crtc->hwmode.crtc_htotal *
480*592ffb21SWarner Losh 					      1000000000), dotclock);
481*592ffb21SWarner Losh 		framedur_ns = (s64) crtc->hwmode.crtc_vtotal * linedur_ns;
482*592ffb21SWarner Losh 	} else
483*592ffb21SWarner Losh 		DRM_ERROR("crtc %d: Can't calculate constants, dotclock = 0!\n",
484*592ffb21SWarner Losh 			  crtc->base.id);
485*592ffb21SWarner Losh 
486*592ffb21SWarner Losh 	crtc->pixeldur_ns = pixeldur_ns;
487*592ffb21SWarner Losh 	crtc->linedur_ns  = linedur_ns;
488*592ffb21SWarner Losh 	crtc->framedur_ns = framedur_ns;
489*592ffb21SWarner Losh 
490*592ffb21SWarner Losh 	DRM_DEBUG("crtc %d: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
491*592ffb21SWarner Losh 		  crtc->base.id, crtc->hwmode.crtc_htotal,
492*592ffb21SWarner Losh 		  crtc->hwmode.crtc_vtotal, crtc->hwmode.crtc_vdisplay);
493*592ffb21SWarner Losh 	DRM_DEBUG("crtc %d: clock %d kHz framedur %d linedur %d, pixeldur %d\n",
494*592ffb21SWarner Losh 		  crtc->base.id, (int) dotclock/1000, (int) framedur_ns,
495*592ffb21SWarner Losh 		  (int) linedur_ns, (int) pixeldur_ns);
496*592ffb21SWarner Losh }
497*592ffb21SWarner Losh EXPORT_SYMBOL(drm_calc_timestamping_constants);
498*592ffb21SWarner Losh 
499*592ffb21SWarner Losh /**
500*592ffb21SWarner Losh  * drm_calc_vbltimestamp_from_scanoutpos - helper routine for kms
501*592ffb21SWarner Losh  * drivers. Implements calculation of exact vblank timestamps from
502*592ffb21SWarner Losh  * given drm_display_mode timings and current video scanout position
503*592ffb21SWarner Losh  * of a crtc. This can be called from within get_vblank_timestamp()
504*592ffb21SWarner Losh  * implementation of a kms driver to implement the actual timestamping.
505*592ffb21SWarner Losh  *
506*592ffb21SWarner Losh  * Should return timestamps conforming to the OML_sync_control OpenML
507*592ffb21SWarner Losh  * extension specification. The timestamp corresponds to the end of
508*592ffb21SWarner Losh  * the vblank interval, aka start of scanout of topmost-leftmost display
509*592ffb21SWarner Losh  * pixel in the following video frame.
510*592ffb21SWarner Losh  *
511*592ffb21SWarner Losh  * Requires support for optional dev->driver->get_scanout_position()
512*592ffb21SWarner Losh  * in kms driver, plus a bit of setup code to provide a drm_display_mode
513*592ffb21SWarner Losh  * that corresponds to the true scanout timing.
514*592ffb21SWarner Losh  *
515*592ffb21SWarner Losh  * The current implementation only handles standard video modes. It
516*592ffb21SWarner Losh  * returns as no operation if a doublescan or interlaced video mode is
517*592ffb21SWarner Losh  * active. Higher level code is expected to handle this.
518*592ffb21SWarner Losh  *
519*592ffb21SWarner Losh  * @dev: DRM device.
520*592ffb21SWarner Losh  * @crtc: Which crtc's vblank timestamp to retrieve.
521*592ffb21SWarner Losh  * @max_error: Desired maximum allowable error in timestamps (nanosecs).
522*592ffb21SWarner Losh  *             On return contains true maximum error of timestamp.
523*592ffb21SWarner Losh  * @vblank_time: Pointer to struct timeval which should receive the timestamp.
524*592ffb21SWarner Losh  * @flags: Flags to pass to driver:
525*592ffb21SWarner Losh  *         0 = Default.
526*592ffb21SWarner Losh  *         DRM_CALLED_FROM_VBLIRQ = If function is called from vbl irq handler.
527*592ffb21SWarner Losh  * @refcrtc: drm_crtc* of crtc which defines scanout timing.
528*592ffb21SWarner Losh  *
529*592ffb21SWarner Losh  * Returns negative value on error, failure or if not supported in current
530*592ffb21SWarner Losh  * video mode:
531*592ffb21SWarner Losh  *
532*592ffb21SWarner Losh  * -EINVAL   - Invalid crtc.
533*592ffb21SWarner Losh  * -EAGAIN   - Temporary unavailable, e.g., called before initial modeset.
534*592ffb21SWarner Losh  * -ENOTSUPP - Function not supported in current display mode.
535*592ffb21SWarner Losh  * -EIO      - Failed, e.g., due to failed scanout position query.
536*592ffb21SWarner Losh  *
537*592ffb21SWarner Losh  * Returns or'ed positive status flags on success:
538*592ffb21SWarner Losh  *
539*592ffb21SWarner Losh  * DRM_VBLANKTIME_SCANOUTPOS_METHOD - Signal this method used for timestamping.
540*592ffb21SWarner Losh  * DRM_VBLANKTIME_INVBL - Timestamp taken while scanout was in vblank interval.
541*592ffb21SWarner Losh  *
542*592ffb21SWarner Losh  */
drm_calc_vbltimestamp_from_scanoutpos(struct drm_device * dev,int crtc,int * max_error,struct timeval * vblank_time,unsigned flags,struct drm_crtc * refcrtc)543*592ffb21SWarner Losh int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, int crtc,
544*592ffb21SWarner Losh 					  int *max_error,
545*592ffb21SWarner Losh 					  struct timeval *vblank_time,
546*592ffb21SWarner Losh 					  unsigned flags,
547*592ffb21SWarner Losh 					  struct drm_crtc *refcrtc)
548*592ffb21SWarner Losh {
549*592ffb21SWarner Losh 	struct timeval stime, raw_time;
550*592ffb21SWarner Losh 	struct drm_display_mode *mode;
551*592ffb21SWarner Losh 	int vbl_status, vtotal, vdisplay;
552*592ffb21SWarner Losh 	int vpos, hpos, i;
553*592ffb21SWarner Losh 	s64 framedur_ns, linedur_ns, pixeldur_ns, delta_ns, duration_ns;
554*592ffb21SWarner Losh 	bool invbl;
555*592ffb21SWarner Losh 
556*592ffb21SWarner Losh 	if (crtc < 0 || crtc >= dev->num_crtcs) {
557*592ffb21SWarner Losh 		DRM_ERROR("Invalid crtc %d\n", crtc);
558*592ffb21SWarner Losh 		return -EINVAL;
559*592ffb21SWarner Losh 	}
560*592ffb21SWarner Losh 
561*592ffb21SWarner Losh 	/* Scanout position query not supported? Should not happen. */
562*592ffb21SWarner Losh 	if (!dev->driver->get_scanout_position) {
563*592ffb21SWarner Losh 		DRM_ERROR("Called from driver w/o get_scanout_position()!?\n");
564*592ffb21SWarner Losh 		return -EIO;
565*592ffb21SWarner Losh 	}
566*592ffb21SWarner Losh 
567*592ffb21SWarner Losh 	mode = &refcrtc->hwmode;
568*592ffb21SWarner Losh 	vtotal = mode->crtc_vtotal;
569*592ffb21SWarner Losh 	vdisplay = mode->crtc_vdisplay;
570*592ffb21SWarner Losh 
571*592ffb21SWarner Losh 	/* Durations of frames, lines, pixels in nanoseconds. */
572*592ffb21SWarner Losh 	framedur_ns = refcrtc->framedur_ns;
573*592ffb21SWarner Losh 	linedur_ns  = refcrtc->linedur_ns;
574*592ffb21SWarner Losh 	pixeldur_ns = refcrtc->pixeldur_ns;
575*592ffb21SWarner Losh 
576*592ffb21SWarner Losh 	/* If mode timing undefined, just return as no-op:
577*592ffb21SWarner Losh 	 * Happens during initial modesetting of a crtc.
578*592ffb21SWarner Losh 	 */
579*592ffb21SWarner Losh 	if (vtotal <= 0 || vdisplay <= 0 || framedur_ns == 0) {
580*592ffb21SWarner Losh 		DRM_DEBUG("crtc %d: Noop due to uninitialized mode.\n", crtc);
581*592ffb21SWarner Losh 		return -EAGAIN;
582*592ffb21SWarner Losh 	}
583*592ffb21SWarner Losh 
584*592ffb21SWarner Losh 	/* Get current scanout position with system timestamp.
585*592ffb21SWarner Losh 	 * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times
586*592ffb21SWarner Losh 	 * if single query takes longer than max_error nanoseconds.
587*592ffb21SWarner Losh 	 *
588*592ffb21SWarner Losh 	 * This guarantees a tight bound on maximum error if
589*592ffb21SWarner Losh 	 * code gets preempted or delayed for some reason.
590*592ffb21SWarner Losh 	 */
591*592ffb21SWarner Losh 	for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) {
592*592ffb21SWarner Losh 		/* Disable preemption to make it very likely to
593*592ffb21SWarner Losh 		 * succeed in the first iteration even on PREEMPT_RT kernel.
594*592ffb21SWarner Losh 		 */
595*592ffb21SWarner Losh 		critical_enter();
596*592ffb21SWarner Losh 
597*592ffb21SWarner Losh 		/* Get system timestamp before query. */
598*592ffb21SWarner Losh 		getmicrouptime(&stime);
599*592ffb21SWarner Losh 
600*592ffb21SWarner Losh 		/* Get vertical and horizontal scanout pos. vpos, hpos. */
601*592ffb21SWarner Losh 		vbl_status = dev->driver->get_scanout_position(dev, crtc, &vpos, &hpos);
602*592ffb21SWarner Losh 
603*592ffb21SWarner Losh 		/* Get system timestamp after query. */
604*592ffb21SWarner Losh 		getmicrouptime(&raw_time);
605*592ffb21SWarner Losh #ifdef FREEBSD_NOTYET
606*592ffb21SWarner Losh 		if (!drm_timestamp_monotonic)
607*592ffb21SWarner Losh 			mono_time_offset = ktime_get_monotonic_offset();
608*592ffb21SWarner Losh #endif /* FREEBSD_NOTYET */
609*592ffb21SWarner Losh 
610*592ffb21SWarner Losh 		critical_exit();
611*592ffb21SWarner Losh 
612*592ffb21SWarner Losh 		/* Return as no-op if scanout query unsupported or failed. */
613*592ffb21SWarner Losh 		if (!(vbl_status & DRM_SCANOUTPOS_VALID)) {
614*592ffb21SWarner Losh 			DRM_DEBUG("crtc %d : scanoutpos query failed [%d].\n",
615*592ffb21SWarner Losh 				  crtc, vbl_status);
616*592ffb21SWarner Losh 			return -EIO;
617*592ffb21SWarner Losh 		}
618*592ffb21SWarner Losh 
619*592ffb21SWarner Losh 		duration_ns = timeval_to_ns(&raw_time) - timeval_to_ns(&stime);
620*592ffb21SWarner Losh 
621*592ffb21SWarner Losh 		/* Accept result with <  max_error nsecs timing uncertainty. */
622*592ffb21SWarner Losh 		if (duration_ns <= (s64) *max_error)
623*592ffb21SWarner Losh 			break;
624*592ffb21SWarner Losh 	}
625*592ffb21SWarner Losh 
626*592ffb21SWarner Losh 	/* Noisy system timing? */
627*592ffb21SWarner Losh 	if (i == DRM_TIMESTAMP_MAXRETRIES) {
628*592ffb21SWarner Losh 		DRM_DEBUG("crtc %d: Noisy timestamp %d us > %d us [%d reps].\n",
629*592ffb21SWarner Losh 			  crtc, (int) duration_ns/1000, *max_error/1000, i);
630*592ffb21SWarner Losh 	}
631*592ffb21SWarner Losh 
632*592ffb21SWarner Losh 	/* Return upper bound of timestamp precision error. */
633*592ffb21SWarner Losh 	*max_error = (int) duration_ns;
634*592ffb21SWarner Losh 
635*592ffb21SWarner Losh 	/* Check if in vblank area:
636*592ffb21SWarner Losh 	 * vpos is >=0 in video scanout area, but negative
637*592ffb21SWarner Losh 	 * within vblank area, counting down the number of lines until
638*592ffb21SWarner Losh 	 * start of scanout.
639*592ffb21SWarner Losh 	 */
640*592ffb21SWarner Losh 	invbl = vbl_status & DRM_SCANOUTPOS_INVBL;
641*592ffb21SWarner Losh 
642*592ffb21SWarner Losh 	/* Convert scanout position into elapsed time at raw_time query
643*592ffb21SWarner Losh 	 * since start of scanout at first display scanline. delta_ns
644*592ffb21SWarner Losh 	 * can be negative if start of scanout hasn't happened yet.
645*592ffb21SWarner Losh 	 */
646*592ffb21SWarner Losh 	delta_ns = (s64) vpos * linedur_ns + (s64) hpos * pixeldur_ns;
647*592ffb21SWarner Losh 
648*592ffb21SWarner Losh 	/* Is vpos outside nominal vblank area, but less than
649*592ffb21SWarner Losh 	 * 1/100 of a frame height away from start of vblank?
650*592ffb21SWarner Losh 	 * If so, assume this isn't a massively delayed vblank
651*592ffb21SWarner Losh 	 * interrupt, but a vblank interrupt that fired a few
652*592ffb21SWarner Losh 	 * microseconds before true start of vblank. Compensate
653*592ffb21SWarner Losh 	 * by adding a full frame duration to the final timestamp.
654*592ffb21SWarner Losh 	 * Happens, e.g., on ATI R500, R600.
655*592ffb21SWarner Losh 	 *
656*592ffb21SWarner Losh 	 * We only do this if DRM_CALLED_FROM_VBLIRQ.
657*592ffb21SWarner Losh 	 */
658*592ffb21SWarner Losh 	if ((flags & DRM_CALLED_FROM_VBLIRQ) && !invbl &&
659*592ffb21SWarner Losh 	    ((vdisplay - vpos) < vtotal / 100)) {
660*592ffb21SWarner Losh 		delta_ns = delta_ns - framedur_ns;
661*592ffb21SWarner Losh 
662*592ffb21SWarner Losh 		/* Signal this correction as "applied". */
663*592ffb21SWarner Losh 		vbl_status |= 0x8;
664*592ffb21SWarner Losh 	}
665*592ffb21SWarner Losh 
666*592ffb21SWarner Losh #ifdef FREEBSD_NOTYET
667*592ffb21SWarner Losh 	if (!drm_timestamp_monotonic)
668*592ffb21SWarner Losh 		etime = ktime_sub(etime, mono_time_offset);
669*592ffb21SWarner Losh 
670*592ffb21SWarner Losh 	/* save this only for debugging purposes */
671*592ffb21SWarner Losh 	tv_etime = ktime_to_timeval(etime);
672*592ffb21SWarner Losh #endif /* FREEBSD_NOTYET */
673*592ffb21SWarner Losh 	/* Subtract time delta from raw timestamp to get final
674*592ffb21SWarner Losh 	 * vblank_time timestamp for end of vblank.
675*592ffb21SWarner Losh 	 */
676*592ffb21SWarner Losh 	*vblank_time = ns_to_timeval(timeval_to_ns(&raw_time) - delta_ns);
677*592ffb21SWarner Losh 
678*592ffb21SWarner Losh 	DRM_DEBUG("crtc %d : v %d p(%d,%d)@ %jd.%jd -> %jd.%jd [e %d us, %d rep]\n",
679*592ffb21SWarner Losh 		  crtc, (int)vbl_status, hpos, vpos, (uintmax_t)raw_time.tv_sec,
680*592ffb21SWarner Losh 		  (uintmax_t)raw_time.tv_usec, (uintmax_t)vblank_time->tv_sec,
681*592ffb21SWarner Losh 		  (uintmax_t)vblank_time->tv_usec, (int)duration_ns/1000, i);
682*592ffb21SWarner Losh 
683*592ffb21SWarner Losh 	vbl_status = DRM_VBLANKTIME_SCANOUTPOS_METHOD;
684*592ffb21SWarner Losh 	if (invbl)
685*592ffb21SWarner Losh 		vbl_status |= DRM_VBLANKTIME_INVBL;
686*592ffb21SWarner Losh 
687*592ffb21SWarner Losh 	return vbl_status;
688*592ffb21SWarner Losh }
689*592ffb21SWarner Losh EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
690*592ffb21SWarner Losh 
get_drm_timestamp(void)691*592ffb21SWarner Losh static struct timeval get_drm_timestamp(void)
692*592ffb21SWarner Losh {
693*592ffb21SWarner Losh 	struct timeval now;
694*592ffb21SWarner Losh 
695*592ffb21SWarner Losh 	microtime(&now);
696*592ffb21SWarner Losh #ifdef FREEBSD_NOTYET
697*592ffb21SWarner Losh 	if (!drm_timestamp_monotonic)
698*592ffb21SWarner Losh 		now = ktime_sub(now, ktime_get_monotonic_offset());
699*592ffb21SWarner Losh #endif /* defined(FREEBSD_NOTYET) */
700*592ffb21SWarner Losh 
701*592ffb21SWarner Losh 	return now;
702*592ffb21SWarner Losh }
703*592ffb21SWarner Losh 
704*592ffb21SWarner Losh /**
705*592ffb21SWarner Losh  * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent
706*592ffb21SWarner Losh  * vblank interval.
707*592ffb21SWarner Losh  *
708*592ffb21SWarner Losh  * @dev: DRM device
709*592ffb21SWarner Losh  * @crtc: which crtc's vblank timestamp to retrieve
710*592ffb21SWarner Losh  * @tvblank: Pointer to target struct timeval which should receive the timestamp
711*592ffb21SWarner Losh  * @flags: Flags to pass to driver:
712*592ffb21SWarner Losh  *         0 = Default.
713*592ffb21SWarner Losh  *         DRM_CALLED_FROM_VBLIRQ = If function is called from vbl irq handler.
714*592ffb21SWarner Losh  *
715*592ffb21SWarner Losh  * Fetches the system timestamp corresponding to the time of the most recent
716*592ffb21SWarner Losh  * vblank interval on specified crtc. May call into kms-driver to
717*592ffb21SWarner Losh  * compute the timestamp with a high-precision GPU specific method.
718*592ffb21SWarner Losh  *
719*592ffb21SWarner Losh  * Returns zero if timestamp originates from uncorrected do_gettimeofday()
720*592ffb21SWarner Losh  * call, i.e., it isn't very precisely locked to the true vblank.
721*592ffb21SWarner Losh  *
722*592ffb21SWarner Losh  * Returns non-zero if timestamp is considered to be very precise.
723*592ffb21SWarner Losh  */
drm_get_last_vbltimestamp(struct drm_device * dev,int crtc,struct timeval * tvblank,unsigned flags)724*592ffb21SWarner Losh u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
725*592ffb21SWarner Losh 			      struct timeval *tvblank, unsigned flags)
726*592ffb21SWarner Losh {
727*592ffb21SWarner Losh 	int ret;
728*592ffb21SWarner Losh 
729*592ffb21SWarner Losh 	/* Define requested maximum error on timestamps (nanoseconds). */
730*592ffb21SWarner Losh 	int max_error = (int) drm_timestamp_precision * 1000;
731*592ffb21SWarner Losh 
732*592ffb21SWarner Losh 	/* Query driver if possible and precision timestamping enabled. */
733*592ffb21SWarner Losh 	if (dev->driver->get_vblank_timestamp && (max_error > 0)) {
734*592ffb21SWarner Losh 		ret = dev->driver->get_vblank_timestamp(dev, crtc, &max_error,
735*592ffb21SWarner Losh 							tvblank, flags);
736*592ffb21SWarner Losh 		if (ret > 0)
737*592ffb21SWarner Losh 			return (u32) ret;
738*592ffb21SWarner Losh 	}
739*592ffb21SWarner Losh 
740*592ffb21SWarner Losh 	/* GPU high precision timestamp query unsupported or failed.
741*592ffb21SWarner Losh 	 * Return current monotonic/gettimeofday timestamp as best estimate.
742*592ffb21SWarner Losh 	 */
743*592ffb21SWarner Losh 	*tvblank = get_drm_timestamp();
744*592ffb21SWarner Losh 
745*592ffb21SWarner Losh 	return 0;
746*592ffb21SWarner Losh }
747*592ffb21SWarner Losh EXPORT_SYMBOL(drm_get_last_vbltimestamp);
748*592ffb21SWarner Losh 
749*592ffb21SWarner Losh /**
750*592ffb21SWarner Losh  * drm_vblank_count - retrieve "cooked" vblank counter value
751*592ffb21SWarner Losh  * @dev: DRM device
752*592ffb21SWarner Losh  * @crtc: which counter to retrieve
753*592ffb21SWarner Losh  *
754*592ffb21SWarner Losh  * Fetches the "cooked" vblank count value that represents the number of
755*592ffb21SWarner Losh  * vblank events since the system was booted, including lost events due to
756*592ffb21SWarner Losh  * modesetting activity.
757*592ffb21SWarner Losh  */
drm_vblank_count(struct drm_device * dev,int crtc)758*592ffb21SWarner Losh u32 drm_vblank_count(struct drm_device *dev, int crtc)
759*592ffb21SWarner Losh {
760*592ffb21SWarner Losh 	return atomic_read(&dev->_vblank_count[crtc]);
761*592ffb21SWarner Losh }
762*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_count);
763*592ffb21SWarner Losh 
764*592ffb21SWarner Losh /**
765*592ffb21SWarner Losh  * drm_vblank_count_and_time - retrieve "cooked" vblank counter value
766*592ffb21SWarner Losh  * and the system timestamp corresponding to that vblank counter value.
767*592ffb21SWarner Losh  *
768*592ffb21SWarner Losh  * @dev: DRM device
769*592ffb21SWarner Losh  * @crtc: which counter to retrieve
770*592ffb21SWarner Losh  * @vblanktime: Pointer to struct timeval to receive the vblank timestamp.
771*592ffb21SWarner Losh  *
772*592ffb21SWarner Losh  * Fetches the "cooked" vblank count value that represents the number of
773*592ffb21SWarner Losh  * vblank events since the system was booted, including lost events due to
774*592ffb21SWarner Losh  * modesetting activity. Returns corresponding system timestamp of the time
775*592ffb21SWarner Losh  * of the vblank interval that corresponds to the current value vblank counter
776*592ffb21SWarner Losh  * value.
777*592ffb21SWarner Losh  */
drm_vblank_count_and_time(struct drm_device * dev,int crtc,struct timeval * vblanktime)778*592ffb21SWarner Losh u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
779*592ffb21SWarner Losh 			      struct timeval *vblanktime)
780*592ffb21SWarner Losh {
781*592ffb21SWarner Losh 	u32 cur_vblank;
782*592ffb21SWarner Losh 
783*592ffb21SWarner Losh 	/* Read timestamp from slot of _vblank_time ringbuffer
784*592ffb21SWarner Losh 	 * that corresponds to current vblank count. Retry if
785*592ffb21SWarner Losh 	 * count has incremented during readout. This works like
786*592ffb21SWarner Losh 	 * a seqlock.
787*592ffb21SWarner Losh 	 */
788*592ffb21SWarner Losh 	do {
789*592ffb21SWarner Losh 		cur_vblank = atomic_read(&dev->_vblank_count[crtc]);
790*592ffb21SWarner Losh 		*vblanktime = vblanktimestamp(dev, crtc, cur_vblank);
791*592ffb21SWarner Losh 		smp_rmb();
792*592ffb21SWarner Losh 	} while (cur_vblank != atomic_read(&dev->_vblank_count[crtc]));
793*592ffb21SWarner Losh 
794*592ffb21SWarner Losh 	return cur_vblank;
795*592ffb21SWarner Losh }
796*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_count_and_time);
797*592ffb21SWarner Losh 
send_vblank_event(struct drm_device * dev,struct drm_pending_vblank_event * e,unsigned long seq,struct timeval * now)798*592ffb21SWarner Losh static void send_vblank_event(struct drm_device *dev,
799*592ffb21SWarner Losh 		struct drm_pending_vblank_event *e,
800*592ffb21SWarner Losh 		unsigned long seq, struct timeval *now)
801*592ffb21SWarner Losh {
802*592ffb21SWarner Losh 	WARN_ON_SMP(!mtx_owned(&dev->event_lock));
803*592ffb21SWarner Losh 	e->event.sequence = seq;
804*592ffb21SWarner Losh 	e->event.tv_sec = now->tv_sec;
805*592ffb21SWarner Losh 	e->event.tv_usec = now->tv_usec;
806*592ffb21SWarner Losh 
807*592ffb21SWarner Losh 	list_add_tail(&e->base.link,
808*592ffb21SWarner Losh 		      &e->base.file_priv->event_list);
809*592ffb21SWarner Losh 	drm_event_wakeup(&e->base);
810*592ffb21SWarner Losh 	CTR3(KTR_DRM, "vblank_event_delivered %d %d %d",
811*592ffb21SWarner Losh 	    e->base.pid, e->pipe, e->event.sequence);
812*592ffb21SWarner Losh }
813*592ffb21SWarner Losh 
814*592ffb21SWarner Losh /**
815*592ffb21SWarner Losh  * drm_send_vblank_event - helper to send vblank event after pageflip
816*592ffb21SWarner Losh  * @dev: DRM device
817*592ffb21SWarner Losh  * @crtc: CRTC in question
818*592ffb21SWarner Losh  * @e: the event to send
819*592ffb21SWarner Losh  *
820*592ffb21SWarner Losh  * Updates sequence # and timestamp on event, and sends it to userspace.
821*592ffb21SWarner Losh  * Caller must hold event lock.
822*592ffb21SWarner Losh  */
drm_send_vblank_event(struct drm_device * dev,int crtc,struct drm_pending_vblank_event * e)823*592ffb21SWarner Losh void drm_send_vblank_event(struct drm_device *dev, int crtc,
824*592ffb21SWarner Losh 		struct drm_pending_vblank_event *e)
825*592ffb21SWarner Losh {
826*592ffb21SWarner Losh 	struct timeval now;
827*592ffb21SWarner Losh 	unsigned int seq;
828*592ffb21SWarner Losh 	if (crtc >= 0) {
829*592ffb21SWarner Losh 		seq = drm_vblank_count_and_time(dev, crtc, &now);
830*592ffb21SWarner Losh 	} else {
831*592ffb21SWarner Losh 		seq = 0;
832*592ffb21SWarner Losh 
833*592ffb21SWarner Losh 		now = get_drm_timestamp();
834*592ffb21SWarner Losh 	}
835*592ffb21SWarner Losh 	send_vblank_event(dev, e, seq, &now);
836*592ffb21SWarner Losh }
837*592ffb21SWarner Losh EXPORT_SYMBOL(drm_send_vblank_event);
838*592ffb21SWarner Losh 
839*592ffb21SWarner Losh /**
840*592ffb21SWarner Losh  * drm_update_vblank_count - update the master vblank counter
841*592ffb21SWarner Losh  * @dev: DRM device
842*592ffb21SWarner Losh  * @crtc: counter to update
843*592ffb21SWarner Losh  *
844*592ffb21SWarner Losh  * Call back into the driver to update the appropriate vblank counter
845*592ffb21SWarner Losh  * (specified by @crtc).  Deal with wraparound, if it occurred, and
846*592ffb21SWarner Losh  * update the last read value so we can deal with wraparound on the next
847*592ffb21SWarner Losh  * call if necessary.
848*592ffb21SWarner Losh  *
849*592ffb21SWarner Losh  * Only necessary when going from off->on, to account for frames we
850*592ffb21SWarner Losh  * didn't get an interrupt for.
851*592ffb21SWarner Losh  *
852*592ffb21SWarner Losh  * Note: caller must hold dev->vbl_lock since this reads & writes
853*592ffb21SWarner Losh  * device vblank fields.
854*592ffb21SWarner Losh  */
drm_update_vblank_count(struct drm_device * dev,int crtc)855*592ffb21SWarner Losh static void drm_update_vblank_count(struct drm_device *dev, int crtc)
856*592ffb21SWarner Losh {
857*592ffb21SWarner Losh 	u32 cur_vblank, diff, tslot, rc;
858*592ffb21SWarner Losh 	struct timeval t_vblank;
859*592ffb21SWarner Losh 
860*592ffb21SWarner Losh 	/*
861*592ffb21SWarner Losh 	 * Interrupts were disabled prior to this call, so deal with counter
862*592ffb21SWarner Losh 	 * wrap if needed.
863*592ffb21SWarner Losh 	 * NOTE!  It's possible we lost a full dev->max_vblank_count events
864*592ffb21SWarner Losh 	 * here if the register is small or we had vblank interrupts off for
865*592ffb21SWarner Losh 	 * a long time.
866*592ffb21SWarner Losh 	 *
867*592ffb21SWarner Losh 	 * We repeat the hardware vblank counter & timestamp query until
868*592ffb21SWarner Losh 	 * we get consistent results. This to prevent races between gpu
869*592ffb21SWarner Losh 	 * updating its hardware counter while we are retrieving the
870*592ffb21SWarner Losh 	 * corresponding vblank timestamp.
871*592ffb21SWarner Losh 	 */
872*592ffb21SWarner Losh 	do {
873*592ffb21SWarner Losh 		cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
874*592ffb21SWarner Losh 		rc = drm_get_last_vbltimestamp(dev, crtc, &t_vblank, 0);
875*592ffb21SWarner Losh 	} while (cur_vblank != dev->driver->get_vblank_counter(dev, crtc));
876*592ffb21SWarner Losh 
877*592ffb21SWarner Losh 	/* Deal with counter wrap */
878*592ffb21SWarner Losh 	diff = cur_vblank - dev->last_vblank[crtc];
879*592ffb21SWarner Losh 	if (cur_vblank < dev->last_vblank[crtc]) {
880*592ffb21SWarner Losh 		diff += dev->max_vblank_count;
881*592ffb21SWarner Losh 
882*592ffb21SWarner Losh 		DRM_DEBUG("last_vblank[%d]=0x%x, cur_vblank=0x%x => diff=0x%x\n",
883*592ffb21SWarner Losh 			  crtc, dev->last_vblank[crtc], cur_vblank, diff);
884*592ffb21SWarner Losh 	}
885*592ffb21SWarner Losh 
886*592ffb21SWarner Losh 	DRM_DEBUG("enabling vblank interrupts on crtc %d, missed %d\n",
887*592ffb21SWarner Losh 		  crtc, diff);
888*592ffb21SWarner Losh 
889*592ffb21SWarner Losh 	/* Reinitialize corresponding vblank timestamp if high-precision query
890*592ffb21SWarner Losh 	 * available. Skip this step if query unsupported or failed. Will
891*592ffb21SWarner Losh 	 * reinitialize delayed at next vblank interrupt in that case.
892*592ffb21SWarner Losh 	 */
893*592ffb21SWarner Losh 	if (rc) {
894*592ffb21SWarner Losh 		tslot = atomic_read(&dev->_vblank_count[crtc]) + diff;
895*592ffb21SWarner Losh 		vblanktimestamp(dev, crtc, tslot) = t_vblank;
896*592ffb21SWarner Losh 	}
897*592ffb21SWarner Losh 
898*592ffb21SWarner Losh 	smp_mb__before_atomic_inc();
899*592ffb21SWarner Losh 	atomic_add(diff, &dev->_vblank_count[crtc]);
900*592ffb21SWarner Losh 	smp_mb__after_atomic_inc();
901*592ffb21SWarner Losh }
902*592ffb21SWarner Losh 
903*592ffb21SWarner Losh /**
904*592ffb21SWarner Losh  * drm_vblank_get - get a reference count on vblank events
905*592ffb21SWarner Losh  * @dev: DRM device
906*592ffb21SWarner Losh  * @crtc: which CRTC to own
907*592ffb21SWarner Losh  *
908*592ffb21SWarner Losh  * Acquire a reference count on vblank events to avoid having them disabled
909*592ffb21SWarner Losh  * while in use.
910*592ffb21SWarner Losh  *
911*592ffb21SWarner Losh  * RETURNS
912*592ffb21SWarner Losh  * Zero on success, nonzero on failure.
913*592ffb21SWarner Losh  */
drm_vblank_get(struct drm_device * dev,int crtc)914*592ffb21SWarner Losh int drm_vblank_get(struct drm_device *dev, int crtc)
915*592ffb21SWarner Losh {
916*592ffb21SWarner Losh 	int ret = 0;
917*592ffb21SWarner Losh 
918*592ffb21SWarner Losh 	mtx_lock(&dev->vbl_lock);
919*592ffb21SWarner Losh 	/* Going from 0->1 means we have to enable interrupts again */
920*592ffb21SWarner Losh 	if (atomic_add_return(1, &dev->vblank_refcount[crtc]) == 1) {
921*592ffb21SWarner Losh 		mtx_lock(&dev->vblank_time_lock);
922*592ffb21SWarner Losh 		if (!dev->vblank_enabled[crtc]) {
923*592ffb21SWarner Losh 			/* Enable vblank irqs under vblank_time_lock protection.
924*592ffb21SWarner Losh 			 * All vblank count & timestamp updates are held off
925*592ffb21SWarner Losh 			 * until we are done reinitializing master counter and
926*592ffb21SWarner Losh 			 * timestamps. Filtercode in drm_handle_vblank() will
927*592ffb21SWarner Losh 			 * prevent double-accounting of same vblank interval.
928*592ffb21SWarner Losh 			 */
929*592ffb21SWarner Losh 			ret = dev->driver->enable_vblank(dev, crtc);
930*592ffb21SWarner Losh 			DRM_DEBUG("enabling vblank on crtc %d, ret: %d\n",
931*592ffb21SWarner Losh 				  crtc, ret);
932*592ffb21SWarner Losh 			if (ret)
933*592ffb21SWarner Losh 				atomic_dec(&dev->vblank_refcount[crtc]);
934*592ffb21SWarner Losh 			else {
935*592ffb21SWarner Losh 				dev->vblank_enabled[crtc] = 1;
936*592ffb21SWarner Losh 				drm_update_vblank_count(dev, crtc);
937*592ffb21SWarner Losh 			}
938*592ffb21SWarner Losh 		}
939*592ffb21SWarner Losh 		mtx_unlock(&dev->vblank_time_lock);
940*592ffb21SWarner Losh 	} else {
941*592ffb21SWarner Losh 		if (!dev->vblank_enabled[crtc]) {
942*592ffb21SWarner Losh 			atomic_dec(&dev->vblank_refcount[crtc]);
943*592ffb21SWarner Losh 			ret = -EINVAL;
944*592ffb21SWarner Losh 		}
945*592ffb21SWarner Losh 	}
946*592ffb21SWarner Losh 	mtx_unlock(&dev->vbl_lock);
947*592ffb21SWarner Losh 
948*592ffb21SWarner Losh 	return ret;
949*592ffb21SWarner Losh }
950*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_get);
951*592ffb21SWarner Losh 
952*592ffb21SWarner Losh /**
953*592ffb21SWarner Losh  * drm_vblank_put - give up ownership of vblank events
954*592ffb21SWarner Losh  * @dev: DRM device
955*592ffb21SWarner Losh  * @crtc: which counter to give up
956*592ffb21SWarner Losh  *
957*592ffb21SWarner Losh  * Release ownership of a given vblank counter, turning off interrupts
958*592ffb21SWarner Losh  * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
959*592ffb21SWarner Losh  */
drm_vblank_put(struct drm_device * dev,int crtc)960*592ffb21SWarner Losh void drm_vblank_put(struct drm_device *dev, int crtc)
961*592ffb21SWarner Losh {
962*592ffb21SWarner Losh 	BUG_ON(atomic_read(&dev->vblank_refcount[crtc]) == 0);
963*592ffb21SWarner Losh 
964*592ffb21SWarner Losh 	/* Last user schedules interrupt disable */
965*592ffb21SWarner Losh 	if (atomic_dec_and_test(&dev->vblank_refcount[crtc]) &&
966*592ffb21SWarner Losh 	    (drm_vblank_offdelay > 0))
967*592ffb21SWarner Losh 		callout_reset(&dev->vblank_disable_callout,
968*592ffb21SWarner Losh 		    (drm_vblank_offdelay * DRM_HZ) / 1000,
969*592ffb21SWarner Losh 		    vblank_disable_fn, dev);
970*592ffb21SWarner Losh }
971*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_put);
972*592ffb21SWarner Losh 
973*592ffb21SWarner Losh /**
974*592ffb21SWarner Losh  * drm_vblank_off - disable vblank events on a CRTC
975*592ffb21SWarner Losh  * @dev: DRM device
976*592ffb21SWarner Losh  * @crtc: CRTC in question
977*592ffb21SWarner Losh  *
978*592ffb21SWarner Losh  * Caller must hold event lock.
979*592ffb21SWarner Losh  */
drm_vblank_off(struct drm_device * dev,int crtc)980*592ffb21SWarner Losh void drm_vblank_off(struct drm_device *dev, int crtc)
981*592ffb21SWarner Losh {
982*592ffb21SWarner Losh 	struct drm_pending_vblank_event *e, *t;
983*592ffb21SWarner Losh 	struct timeval now;
984*592ffb21SWarner Losh 	unsigned int seq;
985*592ffb21SWarner Losh 
986*592ffb21SWarner Losh 	mtx_lock(&dev->vbl_lock);
987*592ffb21SWarner Losh 	vblank_disable_and_save(dev, crtc);
988*592ffb21SWarner Losh 	DRM_WAKEUP(&dev->_vblank_count[crtc]);
989*592ffb21SWarner Losh 
990*592ffb21SWarner Losh 	/* Send any queued vblank events, lest the natives grow disquiet */
991*592ffb21SWarner Losh 	seq = drm_vblank_count_and_time(dev, crtc, &now);
992*592ffb21SWarner Losh 
993*592ffb21SWarner Losh 	mtx_lock(&dev->event_lock);
994*592ffb21SWarner Losh 	list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
995*592ffb21SWarner Losh 		if (e->pipe != crtc)
996*592ffb21SWarner Losh 			continue;
997*592ffb21SWarner Losh 		DRM_DEBUG("Sending premature vblank event on disable: \
998*592ffb21SWarner Losh 			  wanted %d, current %d\n",
999*592ffb21SWarner Losh 			  e->event.sequence, seq);
1000*592ffb21SWarner Losh 		list_del(&e->base.link);
1001*592ffb21SWarner Losh 		drm_vblank_put(dev, e->pipe);
1002*592ffb21SWarner Losh 		send_vblank_event(dev, e, seq, &now);
1003*592ffb21SWarner Losh 	}
1004*592ffb21SWarner Losh 	mtx_unlock(&dev->event_lock);
1005*592ffb21SWarner Losh 
1006*592ffb21SWarner Losh 	mtx_unlock(&dev->vbl_lock);
1007*592ffb21SWarner Losh }
1008*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_off);
1009*592ffb21SWarner Losh 
1010*592ffb21SWarner Losh /**
1011*592ffb21SWarner Losh  * drm_vblank_pre_modeset - account for vblanks across mode sets
1012*592ffb21SWarner Losh  * @dev: DRM device
1013*592ffb21SWarner Losh  * @crtc: CRTC in question
1014*592ffb21SWarner Losh  *
1015*592ffb21SWarner Losh  * Account for vblank events across mode setting events, which will likely
1016*592ffb21SWarner Losh  * reset the hardware frame counter.
1017*592ffb21SWarner Losh  */
drm_vblank_pre_modeset(struct drm_device * dev,int crtc)1018*592ffb21SWarner Losh void drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
1019*592ffb21SWarner Losh {
1020*592ffb21SWarner Losh 	/* vblank is not initialized (IRQ not installed ?), or has been freed */
1021*592ffb21SWarner Losh 	if (!dev->num_crtcs)
1022*592ffb21SWarner Losh 		return;
1023*592ffb21SWarner Losh 	/*
1024*592ffb21SWarner Losh 	 * To avoid all the problems that might happen if interrupts
1025*592ffb21SWarner Losh 	 * were enabled/disabled around or between these calls, we just
1026*592ffb21SWarner Losh 	 * have the kernel take a reference on the CRTC (just once though
1027*592ffb21SWarner Losh 	 * to avoid corrupting the count if multiple, mismatch calls occur),
1028*592ffb21SWarner Losh 	 * so that interrupts remain enabled in the interim.
1029*592ffb21SWarner Losh 	 */
1030*592ffb21SWarner Losh 	if (!dev->vblank_inmodeset[crtc]) {
1031*592ffb21SWarner Losh 		dev->vblank_inmodeset[crtc] = 0x1;
1032*592ffb21SWarner Losh 		if (drm_vblank_get(dev, crtc) == 0)
1033*592ffb21SWarner Losh 			dev->vblank_inmodeset[crtc] |= 0x2;
1034*592ffb21SWarner Losh 	}
1035*592ffb21SWarner Losh }
1036*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_pre_modeset);
1037*592ffb21SWarner Losh 
drm_vblank_post_modeset(struct drm_device * dev,int crtc)1038*592ffb21SWarner Losh void drm_vblank_post_modeset(struct drm_device *dev, int crtc)
1039*592ffb21SWarner Losh {
1040*592ffb21SWarner Losh 	/* vblank is not initialized (IRQ not installed ?), or has been freed */
1041*592ffb21SWarner Losh 	if (!dev->num_crtcs)
1042*592ffb21SWarner Losh 		return;
1043*592ffb21SWarner Losh 
1044*592ffb21SWarner Losh 	if (dev->vblank_inmodeset[crtc]) {
1045*592ffb21SWarner Losh 		mtx_lock(&dev->vbl_lock);
1046*592ffb21SWarner Losh 		dev->vblank_disable_allowed = 1;
1047*592ffb21SWarner Losh 		mtx_unlock(&dev->vbl_lock);
1048*592ffb21SWarner Losh 
1049*592ffb21SWarner Losh 		if (dev->vblank_inmodeset[crtc] & 0x2)
1050*592ffb21SWarner Losh 			drm_vblank_put(dev, crtc);
1051*592ffb21SWarner Losh 
1052*592ffb21SWarner Losh 		dev->vblank_inmodeset[crtc] = 0;
1053*592ffb21SWarner Losh 	}
1054*592ffb21SWarner Losh }
1055*592ffb21SWarner Losh EXPORT_SYMBOL(drm_vblank_post_modeset);
1056*592ffb21SWarner Losh 
1057*592ffb21SWarner Losh /**
1058*592ffb21SWarner Losh  * drm_modeset_ctl - handle vblank event counter changes across mode switch
1059*592ffb21SWarner Losh  * @DRM_IOCTL_ARGS: standard ioctl arguments
1060*592ffb21SWarner Losh  *
1061*592ffb21SWarner Losh  * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
1062*592ffb21SWarner Losh  * ioctls around modesetting so that any lost vblank events are accounted for.
1063*592ffb21SWarner Losh  *
1064*592ffb21SWarner Losh  * Generally the counter will reset across mode sets.  If interrupts are
1065*592ffb21SWarner Losh  * enabled around this call, we don't have to do anything since the counter
1066*592ffb21SWarner Losh  * will have already been incremented.
1067*592ffb21SWarner Losh  */
drm_modeset_ctl(struct drm_device * dev,void * data,struct drm_file * file_priv)1068*592ffb21SWarner Losh int drm_modeset_ctl(struct drm_device *dev, void *data,
1069*592ffb21SWarner Losh 		    struct drm_file *file_priv)
1070*592ffb21SWarner Losh {
1071*592ffb21SWarner Losh 	struct drm_modeset_ctl *modeset = data;
1072*592ffb21SWarner Losh 	unsigned int crtc;
1073*592ffb21SWarner Losh 
1074*592ffb21SWarner Losh 	/* If drm_vblank_init() hasn't been called yet, just no-op */
1075*592ffb21SWarner Losh 	if (!dev->num_crtcs)
1076*592ffb21SWarner Losh 		return 0;
1077*592ffb21SWarner Losh 
1078*592ffb21SWarner Losh 	/* KMS drivers handle this internally */
1079*592ffb21SWarner Losh 	if (drm_core_check_feature(dev, DRIVER_MODESET))
1080*592ffb21SWarner Losh 		return 0;
1081*592ffb21SWarner Losh 
1082*592ffb21SWarner Losh 	crtc = modeset->crtc;
1083*592ffb21SWarner Losh 	if (crtc >= dev->num_crtcs)
1084*592ffb21SWarner Losh 		return -EINVAL;
1085*592ffb21SWarner Losh 
1086*592ffb21SWarner Losh 	switch (modeset->cmd) {
1087*592ffb21SWarner Losh 	case _DRM_PRE_MODESET:
1088*592ffb21SWarner Losh 		drm_vblank_pre_modeset(dev, crtc);
1089*592ffb21SWarner Losh 		break;
1090*592ffb21SWarner Losh 	case _DRM_POST_MODESET:
1091*592ffb21SWarner Losh 		drm_vblank_post_modeset(dev, crtc);
1092*592ffb21SWarner Losh 		break;
1093*592ffb21SWarner Losh 	default:
1094*592ffb21SWarner Losh 		return -EINVAL;
1095*592ffb21SWarner Losh 	}
1096*592ffb21SWarner Losh 
1097*592ffb21SWarner Losh 	return 0;
1098*592ffb21SWarner Losh }
1099*592ffb21SWarner Losh 
1100*592ffb21SWarner Losh static void
drm_vblank_event_destroy(struct drm_pending_event * e)1101*592ffb21SWarner Losh drm_vblank_event_destroy(struct drm_pending_event *e)
1102*592ffb21SWarner Losh {
1103*592ffb21SWarner Losh 
1104*592ffb21SWarner Losh 	free(e, DRM_MEM_VBLANK);
1105*592ffb21SWarner Losh }
1106*592ffb21SWarner Losh 
drm_queue_vblank_event(struct drm_device * dev,int pipe,union drm_wait_vblank * vblwait,struct drm_file * file_priv)1107*592ffb21SWarner Losh static int drm_queue_vblank_event(struct drm_device *dev, int pipe,
1108*592ffb21SWarner Losh 				  union drm_wait_vblank *vblwait,
1109*592ffb21SWarner Losh 				  struct drm_file *file_priv)
1110*592ffb21SWarner Losh {
1111*592ffb21SWarner Losh 	struct drm_pending_vblank_event *e;
1112*592ffb21SWarner Losh 	struct timeval now;
1113*592ffb21SWarner Losh 	unsigned int seq;
1114*592ffb21SWarner Losh 	int ret;
1115*592ffb21SWarner Losh 
1116*592ffb21SWarner Losh 	e = malloc(sizeof *e, DRM_MEM_VBLANK, M_NOWAIT | M_ZERO);
1117*592ffb21SWarner Losh 	if (e == NULL) {
1118*592ffb21SWarner Losh 		ret = -ENOMEM;
1119*592ffb21SWarner Losh 		goto err_put;
1120*592ffb21SWarner Losh 	}
1121*592ffb21SWarner Losh 
1122*592ffb21SWarner Losh 	e->pipe = pipe;
1123*592ffb21SWarner Losh 	e->base.pid = curproc->p_pid;
1124*592ffb21SWarner Losh 	e->event.base.type = DRM_EVENT_VBLANK;
1125*592ffb21SWarner Losh 	e->event.base.length = sizeof e->event;
1126*592ffb21SWarner Losh 	e->event.user_data = vblwait->request.signal;
1127*592ffb21SWarner Losh 	e->base.event = &e->event.base;
1128*592ffb21SWarner Losh 	e->base.file_priv = file_priv;
1129*592ffb21SWarner Losh 	e->base.destroy = drm_vblank_event_destroy;
1130*592ffb21SWarner Losh 
1131*592ffb21SWarner Losh 	mtx_lock(&dev->event_lock);
1132*592ffb21SWarner Losh 
1133*592ffb21SWarner Losh 	if (file_priv->event_space < sizeof e->event) {
1134*592ffb21SWarner Losh 		ret = -EBUSY;
1135*592ffb21SWarner Losh 		goto err_unlock;
1136*592ffb21SWarner Losh 	}
1137*592ffb21SWarner Losh 
1138*592ffb21SWarner Losh 	file_priv->event_space -= sizeof e->event;
1139*592ffb21SWarner Losh 	seq = drm_vblank_count_and_time(dev, pipe, &now);
1140*592ffb21SWarner Losh 
1141*592ffb21SWarner Losh 	if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) &&
1142*592ffb21SWarner Losh 	    (seq - vblwait->request.sequence) <= (1 << 23)) {
1143*592ffb21SWarner Losh 		vblwait->request.sequence = seq + 1;
1144*592ffb21SWarner Losh 		vblwait->reply.sequence = vblwait->request.sequence;
1145*592ffb21SWarner Losh 	}
1146*592ffb21SWarner Losh 
1147*592ffb21SWarner Losh 	DRM_DEBUG("event on vblank count %d, current %d, crtc %d\n",
1148*592ffb21SWarner Losh 		  vblwait->request.sequence, seq, pipe);
1149*592ffb21SWarner Losh 
1150*592ffb21SWarner Losh 	CTR4(KTR_DRM, "vblank_event_queued %d %d rt %x %d", curproc->p_pid, pipe,
1151*592ffb21SWarner Losh 	    vblwait->request.type, vblwait->request.sequence);
1152*592ffb21SWarner Losh 
1153*592ffb21SWarner Losh 	e->event.sequence = vblwait->request.sequence;
1154*592ffb21SWarner Losh 	if ((seq - vblwait->request.sequence) <= (1 << 23)) {
1155*592ffb21SWarner Losh 		drm_vblank_put(dev, pipe);
1156*592ffb21SWarner Losh 		send_vblank_event(dev, e, seq, &now);
1157*592ffb21SWarner Losh 		vblwait->reply.sequence = seq;
1158*592ffb21SWarner Losh 	} else {
1159*592ffb21SWarner Losh 		/* drm_handle_vblank_events will call drm_vblank_put */
1160*592ffb21SWarner Losh 		list_add_tail(&e->base.link, &dev->vblank_event_list);
1161*592ffb21SWarner Losh 		vblwait->reply.sequence = vblwait->request.sequence;
1162*592ffb21SWarner Losh 	}
1163*592ffb21SWarner Losh 
1164*592ffb21SWarner Losh 	mtx_unlock(&dev->event_lock);
1165*592ffb21SWarner Losh 
1166*592ffb21SWarner Losh 	return 0;
1167*592ffb21SWarner Losh 
1168*592ffb21SWarner Losh err_unlock:
1169*592ffb21SWarner Losh 	mtx_unlock(&dev->event_lock);
1170*592ffb21SWarner Losh 	free(e, DRM_MEM_VBLANK);
1171*592ffb21SWarner Losh err_put:
1172*592ffb21SWarner Losh 	drm_vblank_put(dev, pipe);
1173*592ffb21SWarner Losh 	return ret;
1174*592ffb21SWarner Losh }
1175*592ffb21SWarner Losh 
1176*592ffb21SWarner Losh /**
1177*592ffb21SWarner Losh  * Wait for VBLANK.
1178*592ffb21SWarner Losh  *
1179*592ffb21SWarner Losh  * \param inode device inode.
1180*592ffb21SWarner Losh  * \param file_priv DRM file private.
1181*592ffb21SWarner Losh  * \param cmd command.
1182*592ffb21SWarner Losh  * \param data user argument, pointing to a drm_wait_vblank structure.
1183*592ffb21SWarner Losh  * \return zero on success or a negative number on failure.
1184*592ffb21SWarner Losh  *
1185*592ffb21SWarner Losh  * This function enables the vblank interrupt on the pipe requested, then
1186*592ffb21SWarner Losh  * sleeps waiting for the requested sequence number to occur, and drops
1187*592ffb21SWarner Losh  * the vblank interrupt refcount afterwards. (vblank irq disable follows that
1188*592ffb21SWarner Losh  * after a timeout with no further vblank waits scheduled).
1189*592ffb21SWarner Losh  */
drm_wait_vblank(struct drm_device * dev,void * data,struct drm_file * file_priv)1190*592ffb21SWarner Losh int drm_wait_vblank(struct drm_device *dev, void *data,
1191*592ffb21SWarner Losh 		    struct drm_file *file_priv)
1192*592ffb21SWarner Losh {
1193*592ffb21SWarner Losh 	union drm_wait_vblank *vblwait = data;
1194*592ffb21SWarner Losh 	int ret;
1195*592ffb21SWarner Losh 	unsigned int flags, seq, crtc, high_crtc;
1196*592ffb21SWarner Losh 
1197*592ffb21SWarner Losh 	if (/*(!drm_dev_to_irq(dev)) || */(!dev->irq_enabled))
1198*592ffb21SWarner Losh 		return -EINVAL;
1199*592ffb21SWarner Losh 
1200*592ffb21SWarner Losh 	if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
1201*592ffb21SWarner Losh 		return -EINVAL;
1202*592ffb21SWarner Losh 
1203*592ffb21SWarner Losh 	if (vblwait->request.type &
1204*592ffb21SWarner Losh 	    ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1205*592ffb21SWarner Losh 	      _DRM_VBLANK_HIGH_CRTC_MASK)) {
1206*592ffb21SWarner Losh 		DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
1207*592ffb21SWarner Losh 			  vblwait->request.type,
1208*592ffb21SWarner Losh 			  (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1209*592ffb21SWarner Losh 			   _DRM_VBLANK_HIGH_CRTC_MASK));
1210*592ffb21SWarner Losh 		return -EINVAL;
1211*592ffb21SWarner Losh 	}
1212*592ffb21SWarner Losh 
1213*592ffb21SWarner Losh 	flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
1214*592ffb21SWarner Losh 	high_crtc = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK);
1215*592ffb21SWarner Losh 	if (high_crtc)
1216*592ffb21SWarner Losh 		crtc = high_crtc >> _DRM_VBLANK_HIGH_CRTC_SHIFT;
1217*592ffb21SWarner Losh 	else
1218*592ffb21SWarner Losh 		crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
1219*592ffb21SWarner Losh 	if (crtc >= dev->num_crtcs)
1220*592ffb21SWarner Losh 		return -EINVAL;
1221*592ffb21SWarner Losh 
1222*592ffb21SWarner Losh 	ret = drm_vblank_get(dev, crtc);
1223*592ffb21SWarner Losh 	if (ret) {
1224*592ffb21SWarner Losh 		DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
1225*592ffb21SWarner Losh 		return ret;
1226*592ffb21SWarner Losh 	}
1227*592ffb21SWarner Losh 	seq = drm_vblank_count(dev, crtc);
1228*592ffb21SWarner Losh 
1229*592ffb21SWarner Losh 	switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
1230*592ffb21SWarner Losh 	case _DRM_VBLANK_RELATIVE:
1231*592ffb21SWarner Losh 		vblwait->request.sequence += seq;
1232*592ffb21SWarner Losh 		vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
1233*592ffb21SWarner Losh 	case _DRM_VBLANK_ABSOLUTE:
1234*592ffb21SWarner Losh 		break;
1235*592ffb21SWarner Losh 	default:
1236*592ffb21SWarner Losh 		ret = -EINVAL;
1237*592ffb21SWarner Losh 		goto done;
1238*592ffb21SWarner Losh 	}
1239*592ffb21SWarner Losh 
1240*592ffb21SWarner Losh 	if (flags & _DRM_VBLANK_EVENT) {
1241*592ffb21SWarner Losh 		/* must hold on to the vblank ref until the event fires
1242*592ffb21SWarner Losh 		 * drm_vblank_put will be called asynchronously
1243*592ffb21SWarner Losh 		 */
1244*592ffb21SWarner Losh 		return drm_queue_vblank_event(dev, crtc, vblwait, file_priv);
1245*592ffb21SWarner Losh 	}
1246*592ffb21SWarner Losh 
1247*592ffb21SWarner Losh 	if ((flags & _DRM_VBLANK_NEXTONMISS) &&
1248*592ffb21SWarner Losh 	    (seq - vblwait->request.sequence) <= (1<<23)) {
1249*592ffb21SWarner Losh 		vblwait->request.sequence = seq + 1;
1250*592ffb21SWarner Losh 	}
1251*592ffb21SWarner Losh 
1252*592ffb21SWarner Losh 	DRM_DEBUG("waiting on vblank count %d, crtc %d\n",
1253*592ffb21SWarner Losh 		  vblwait->request.sequence, crtc);
1254*592ffb21SWarner Losh 	dev->last_vblank_wait[crtc] = vblwait->request.sequence;
1255*592ffb21SWarner Losh 	mtx_lock(&dev->vblank_time_lock);
1256*592ffb21SWarner Losh 	while (((drm_vblank_count(dev, crtc) - vblwait->request.sequence) >
1257*592ffb21SWarner Losh 	    (1 << 23)) && dev->irq_enabled) {
1258*592ffb21SWarner Losh 		/*
1259*592ffb21SWarner Losh 		 * The wakeups from the drm_irq_uninstall() and
1260*592ffb21SWarner Losh 		 * drm_vblank_off() may be lost there since vbl_lock
1261*592ffb21SWarner Losh 		 * is not held.  Then, the timeout will wake us; the 3
1262*592ffb21SWarner Losh 		 * seconds delay should not be a problem for
1263*592ffb21SWarner Losh 		 * application when crtc is disabled or irq
1264*592ffb21SWarner Losh 		 * uninstalled anyway.
1265*592ffb21SWarner Losh 		 */
1266*592ffb21SWarner Losh 		ret = -msleep(&dev->_vblank_count[crtc], &dev->vblank_time_lock,
1267*592ffb21SWarner Losh 		    PCATCH, "drmvbl", 3 * hz);
1268*592ffb21SWarner Losh 		if (ret == -ERESTART)
1269*592ffb21SWarner Losh 			ret = -ERESTARTSYS;
1270*592ffb21SWarner Losh 		if (ret != 0)
1271*592ffb21SWarner Losh 			break;
1272*592ffb21SWarner Losh 	}
1273*592ffb21SWarner Losh 	mtx_unlock(&dev->vblank_time_lock);
1274*592ffb21SWarner Losh 	if (ret != -EINTR) {
1275*592ffb21SWarner Losh 		struct timeval now;
1276*592ffb21SWarner Losh 		long reply_seq;
1277*592ffb21SWarner Losh 
1278*592ffb21SWarner Losh 		reply_seq = drm_vblank_count_and_time(dev, crtc, &now);
1279*592ffb21SWarner Losh 		CTR5(KTR_DRM, "wait_vblank %d %d rt %x success %d %d",
1280*592ffb21SWarner Losh 		    curproc->p_pid, crtc, vblwait->request.type,
1281*592ffb21SWarner Losh 		    vblwait->request.sequence, reply_seq);
1282*592ffb21SWarner Losh 
1283*592ffb21SWarner Losh 		vblwait->reply.sequence = reply_seq;
1284*592ffb21SWarner Losh 		vblwait->reply.tval_sec = now.tv_sec;
1285*592ffb21SWarner Losh 		vblwait->reply.tval_usec = now.tv_usec;
1286*592ffb21SWarner Losh 
1287*592ffb21SWarner Losh 		DRM_DEBUG("returning %d to client\n",
1288*592ffb21SWarner Losh 			  vblwait->reply.sequence);
1289*592ffb21SWarner Losh 	} else {
1290*592ffb21SWarner Losh 		CTR5(KTR_DRM, "wait_vblank %d %d rt %x error %d %d",
1291*592ffb21SWarner Losh 		    curproc->p_pid, crtc, vblwait->request.type, ret,
1292*592ffb21SWarner Losh 		    vblwait->request.sequence);
1293*592ffb21SWarner Losh 
1294*592ffb21SWarner Losh 		DRM_DEBUG("vblank wait interrupted by signal\n");
1295*592ffb21SWarner Losh 	}
1296*592ffb21SWarner Losh 
1297*592ffb21SWarner Losh done:
1298*592ffb21SWarner Losh 	drm_vblank_put(dev, crtc);
1299*592ffb21SWarner Losh 	return ret;
1300*592ffb21SWarner Losh }
1301*592ffb21SWarner Losh 
drm_handle_vblank_events(struct drm_device * dev,int crtc)1302*592ffb21SWarner Losh static void drm_handle_vblank_events(struct drm_device *dev, int crtc)
1303*592ffb21SWarner Losh {
1304*592ffb21SWarner Losh 	struct drm_pending_vblank_event *e, *t;
1305*592ffb21SWarner Losh 	struct timeval now;
1306*592ffb21SWarner Losh 	unsigned int seq;
1307*592ffb21SWarner Losh 
1308*592ffb21SWarner Losh 	seq = drm_vblank_count_and_time(dev, crtc, &now);
1309*592ffb21SWarner Losh 
1310*592ffb21SWarner Losh 	mtx_lock(&dev->event_lock);
1311*592ffb21SWarner Losh 
1312*592ffb21SWarner Losh 	list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1313*592ffb21SWarner Losh 		if (e->pipe != crtc)
1314*592ffb21SWarner Losh 			continue;
1315*592ffb21SWarner Losh 		if ((seq - e->event.sequence) > (1<<23))
1316*592ffb21SWarner Losh 			continue;
1317*592ffb21SWarner Losh 
1318*592ffb21SWarner Losh 		DRM_DEBUG("vblank event on %d, current %d\n",
1319*592ffb21SWarner Losh 			  e->event.sequence, seq);
1320*592ffb21SWarner Losh 
1321*592ffb21SWarner Losh 		list_del(&e->base.link);
1322*592ffb21SWarner Losh 		drm_vblank_put(dev, e->pipe);
1323*592ffb21SWarner Losh 		send_vblank_event(dev, e, seq, &now);
1324*592ffb21SWarner Losh 	}
1325*592ffb21SWarner Losh 
1326*592ffb21SWarner Losh 	mtx_unlock(&dev->event_lock);
1327*592ffb21SWarner Losh 
1328*592ffb21SWarner Losh 	CTR2(KTR_DRM, "drm_handle_vblank_events %d %d", seq, crtc);
1329*592ffb21SWarner Losh }
1330*592ffb21SWarner Losh 
1331*592ffb21SWarner Losh /**
1332*592ffb21SWarner Losh  * drm_handle_vblank - handle a vblank event
1333*592ffb21SWarner Losh  * @dev: DRM device
1334*592ffb21SWarner Losh  * @crtc: where this event occurred
1335*592ffb21SWarner Losh  *
1336*592ffb21SWarner Losh  * Drivers should call this routine in their vblank interrupt handlers to
1337*592ffb21SWarner Losh  * update the vblank counter and send any signals that may be pending.
1338*592ffb21SWarner Losh  */
drm_handle_vblank(struct drm_device * dev,int crtc)1339*592ffb21SWarner Losh bool drm_handle_vblank(struct drm_device *dev, int crtc)
1340*592ffb21SWarner Losh {
1341*592ffb21SWarner Losh 	u32 vblcount;
1342*592ffb21SWarner Losh 	s64 diff_ns;
1343*592ffb21SWarner Losh 	struct timeval tvblank;
1344*592ffb21SWarner Losh 
1345*592ffb21SWarner Losh 	if (!dev->num_crtcs)
1346*592ffb21SWarner Losh 		return false;
1347*592ffb21SWarner Losh 
1348*592ffb21SWarner Losh 	/* Need timestamp lock to prevent concurrent execution with
1349*592ffb21SWarner Losh 	 * vblank enable/disable, as this would cause inconsistent
1350*592ffb21SWarner Losh 	 * or corrupted timestamps and vblank counts.
1351*592ffb21SWarner Losh 	 */
1352*592ffb21SWarner Losh 	mtx_lock(&dev->vblank_time_lock);
1353*592ffb21SWarner Losh 
1354*592ffb21SWarner Losh 	/* Vblank irq handling disabled. Nothing to do. */
1355*592ffb21SWarner Losh 	if (!dev->vblank_enabled[crtc]) {
1356*592ffb21SWarner Losh 		mtx_unlock(&dev->vblank_time_lock);
1357*592ffb21SWarner Losh 		return false;
1358*592ffb21SWarner Losh 	}
1359*592ffb21SWarner Losh 
1360*592ffb21SWarner Losh 	/* Fetch corresponding timestamp for this vblank interval from
1361*592ffb21SWarner Losh 	 * driver and store it in proper slot of timestamp ringbuffer.
1362*592ffb21SWarner Losh 	 */
1363*592ffb21SWarner Losh 
1364*592ffb21SWarner Losh 	/* Get current timestamp and count. */
1365*592ffb21SWarner Losh 	vblcount = atomic_read(&dev->_vblank_count[crtc]);
1366*592ffb21SWarner Losh 	drm_get_last_vbltimestamp(dev, crtc, &tvblank, DRM_CALLED_FROM_VBLIRQ);
1367*592ffb21SWarner Losh 
1368*592ffb21SWarner Losh 	/* Compute time difference to timestamp of last vblank */
1369*592ffb21SWarner Losh 	diff_ns = timeval_to_ns(&tvblank) -
1370*592ffb21SWarner Losh 		  timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount));
1371*592ffb21SWarner Losh 
1372*592ffb21SWarner Losh 	/* Update vblank timestamp and count if at least
1373*592ffb21SWarner Losh 	 * DRM_REDUNDANT_VBLIRQ_THRESH_NS nanoseconds
1374*592ffb21SWarner Losh 	 * difference between last stored timestamp and current
1375*592ffb21SWarner Losh 	 * timestamp. A smaller difference means basically
1376*592ffb21SWarner Losh 	 * identical timestamps. Happens if this vblank has
1377*592ffb21SWarner Losh 	 * been already processed and this is a redundant call,
1378*592ffb21SWarner Losh 	 * e.g., due to spurious vblank interrupts. We need to
1379*592ffb21SWarner Losh 	 * ignore those for accounting.
1380*592ffb21SWarner Losh 	 */
1381*592ffb21SWarner Losh 	if (abs64(diff_ns) > DRM_REDUNDANT_VBLIRQ_THRESH_NS) {
1382*592ffb21SWarner Losh 		/* Store new timestamp in ringbuffer. */
1383*592ffb21SWarner Losh 		vblanktimestamp(dev, crtc, vblcount + 1) = tvblank;
1384*592ffb21SWarner Losh 
1385*592ffb21SWarner Losh 		/* Increment cooked vblank count. This also atomically commits
1386*592ffb21SWarner Losh 		 * the timestamp computed above.
1387*592ffb21SWarner Losh 		 */
1388*592ffb21SWarner Losh 		smp_mb__before_atomic_inc();
1389*592ffb21SWarner Losh 		atomic_inc(&dev->_vblank_count[crtc]);
1390*592ffb21SWarner Losh 		smp_mb__after_atomic_inc();
1391*592ffb21SWarner Losh 	} else {
1392*592ffb21SWarner Losh 		DRM_DEBUG("crtc %d: Redundant vblirq ignored. diff_ns = %d\n",
1393*592ffb21SWarner Losh 			  crtc, (int) diff_ns);
1394*592ffb21SWarner Losh 	}
1395*592ffb21SWarner Losh 
1396*592ffb21SWarner Losh 	DRM_WAKEUP(&dev->_vblank_count[crtc]);
1397*592ffb21SWarner Losh 	drm_handle_vblank_events(dev, crtc);
1398*592ffb21SWarner Losh 
1399*592ffb21SWarner Losh 	mtx_unlock(&dev->vblank_time_lock);
1400*592ffb21SWarner Losh 	return true;
1401*592ffb21SWarner Losh }
1402*592ffb21SWarner Losh EXPORT_SYMBOL(drm_handle_vblank);
1403