blob: f9af048828ea16136752a29b982ae28add4ff226 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/**
Dave Airlieb5e89ed2005-09-25 14:28:13 +10002 * \file drm_irq.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * IRQ support
4 *
5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
7 */
8
9/*
10 * Created: Fri Mar 19 14:30:16 1999 by faith@valinux.com
11 *
12 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14 * All Rights Reserved.
15 *
16 * Permission is hereby granted, free of charge, to any person obtaining a
17 * copy of this software and associated documentation files (the "Software"),
18 * to deal in the Software without restriction, including without limitation
19 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20 * and/or sell copies of the Software, and to permit persons to whom the
21 * Software is furnished to do so, subject to the following conditions:
22 *
23 * The above copyright notice and this permission notice (including the next
24 * paragraph) shall be included in all copies or substantial portions of the
25 * Software.
26 *
27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
30 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33 * OTHER DEALINGS IN THE SOFTWARE.
34 */
35
David Howells760285e2012-10-02 18:01:07 +010036#include <drm/drmP.h>
Jesse Barnesac2874b2010-07-01 16:47:31 -070037#include "drm_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#include <linux/interrupt.h> /* For task queue support */
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090040#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Dave Airlie28d52042009-09-21 14:33:58 +100042#include <linux/vgaarb.h>
Paul Gortmaker2d1a8a42011-08-30 18:16:33 -040043#include <linux/export.h>
Mario Kleiner27641c32010-10-23 04:20:23 +020044
45/* Access macro for slots in vblank timestamp ringbuffer. */
Ville Syrjälä5380e922013-10-04 14:53:36 +030046#define vblanktimestamp(dev, crtc, count) \
47 ((dev)->vblank[crtc].time[(count) % DRM_VBLANKTIME_RBSIZE])
Mario Kleiner27641c32010-10-23 04:20:23 +020048
49/* Retry timestamp calculation up to 3 times to satisfy
50 * drm_timestamp_precision before giving up.
51 */
52#define DRM_TIMESTAMP_MAXRETRIES 3
53
54/* Threshold in nanoseconds for detection of redundant
55 * vblank irq in drm_handle_vblank(). 1 msec should be ok.
56 */
57#define DRM_REDUNDANT_VBLIRQ_THRESH_NS 1000000
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059/**
60 * Get interrupt from bus id.
Dave Airlieb5e89ed2005-09-25 14:28:13 +100061 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +100063 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 * \param cmd command.
65 * \param arg user argument, pointing to a drm_irq_busid structure.
66 * \return zero on success or a negative number on failure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +100067 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 * Finds the PCI device with the specified bus id and gets its IRQ number.
69 * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
70 * to that of the device that this DRM instance attached to.
71 */
Eric Anholtc153f452007-09-03 12:06:45 +100072int drm_irq_by_busid(struct drm_device *dev, void *data,
73 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
Eric Anholtc153f452007-09-03 12:06:45 +100075 struct drm_irq_busid *p = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Dave Airlie8410ea32010-12-15 03:16:38 +100077 if (!dev->driver->bus->irq_by_busid)
Jordan Crousedcdb1672010-05-27 13:40:25 -060078 return -EINVAL;
79
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
81 return -EINVAL;
82
Dave Airlie8410ea32010-12-15 03:16:38 +100083 return dev->driver->bus->irq_by_busid(dev, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
Mario Kleiner27641c32010-10-23 04:20:23 +020086/*
87 * Clear vblank timestamp buffer for a crtc.
88 */
89static void clear_vblank_timestamps(struct drm_device *dev, int crtc)
90{
Ville Syrjälä5380e922013-10-04 14:53:36 +030091 memset(dev->vblank[crtc].time, 0, sizeof(dev->vblank[crtc].time));
Mario Kleiner27641c32010-10-23 04:20:23 +020092}
93
94/*
95 * Disable vblank irq's on crtc, make sure that last vblank count
96 * of hardware and corresponding consistent software vblank counter
97 * are preserved, even if there are any spurious vblank irq's after
98 * disable.
99 */
100static void vblank_disable_and_save(struct drm_device *dev, int crtc)
101{
102 unsigned long irqflags;
103 u32 vblcount;
104 s64 diff_ns;
105 int vblrc;
106 struct timeval tvblank;
Egbert Eich0355cf32012-10-13 11:36:14 +0000107 int count = DRM_TIMESTAMP_MAXRETRIES;
Mario Kleiner27641c32010-10-23 04:20:23 +0200108
109 /* Prevent vblank irq processing while disabling vblank irqs,
110 * so no updates of timestamps or count can happen after we've
111 * disabled. Needed to prevent races in case of delayed irq's.
Mario Kleiner27641c32010-10-23 04:20:23 +0200112 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200113 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
114
115 dev->driver->disable_vblank(dev, crtc);
Ville Syrjälä5380e922013-10-04 14:53:36 +0300116 dev->vblank[crtc].enabled = false;
Mario Kleiner27641c32010-10-23 04:20:23 +0200117
118 /* No further vblank irq's will be processed after
119 * this point. Get current hardware vblank count and
120 * vblank timestamp, repeat until they are consistent.
121 *
122 * FIXME: There is still a race condition here and in
123 * drm_update_vblank_count() which can cause off-by-one
124 * reinitialization of software vblank counter. If gpu
125 * vblank counter doesn't increment exactly at the leading
126 * edge of a vblank interval, then we can lose 1 count if
127 * we happen to execute between start of vblank and the
128 * delayed gpu counter increment.
129 */
130 do {
Ville Syrjälä5380e922013-10-04 14:53:36 +0300131 dev->vblank[crtc].last = dev->driver->get_vblank_counter(dev, crtc);
Mario Kleiner27641c32010-10-23 04:20:23 +0200132 vblrc = drm_get_last_vbltimestamp(dev, crtc, &tvblank, 0);
Ville Syrjälä5380e922013-10-04 14:53:36 +0300133 } while (dev->vblank[crtc].last != dev->driver->get_vblank_counter(dev, crtc) && (--count) && vblrc);
Egbert Eich0355cf32012-10-13 11:36:14 +0000134
135 if (!count)
136 vblrc = 0;
Mario Kleiner27641c32010-10-23 04:20:23 +0200137
138 /* Compute time difference to stored timestamp of last vblank
139 * as updated by last invocation of drm_handle_vblank() in vblank irq.
140 */
Ville Syrjälä5380e922013-10-04 14:53:36 +0300141 vblcount = atomic_read(&dev->vblank[crtc].count);
Mario Kleiner27641c32010-10-23 04:20:23 +0200142 diff_ns = timeval_to_ns(&tvblank) -
143 timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount));
144
145 /* If there is at least 1 msec difference between the last stored
146 * timestamp and tvblank, then we are currently executing our
147 * disable inside a new vblank interval, the tvblank timestamp
148 * corresponds to this new vblank interval and the irq handler
149 * for this vblank didn't run yet and won't run due to our disable.
150 * Therefore we need to do the job of drm_handle_vblank() and
151 * increment the vblank counter by one to account for this vblank.
152 *
153 * Skip this step if there isn't any high precision timestamp
154 * available. In that case we can't account for this and just
155 * hope for the best.
156 */
Mario Kleinerbc215122011-02-21 05:42:01 +0100157 if ((vblrc > 0) && (abs64(diff_ns) > 1000000)) {
Ville Syrjälä5380e922013-10-04 14:53:36 +0300158 atomic_inc(&dev->vblank[crtc].count);
Mario Kleinerbc215122011-02-21 05:42:01 +0100159 smp_mb__after_atomic_inc();
160 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200161
162 /* Invalidate all timestamps while vblank irq's are off. */
163 clear_vblank_timestamps(dev, crtc);
164
165 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
Mario Kleiner27641c32010-10-23 04:20:23 +0200166}
167
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700168static void vblank_disable_fn(unsigned long arg)
169{
170 struct drm_device *dev = (struct drm_device *)arg;
171 unsigned long irqflags;
172 int i;
173
174 if (!dev->vblank_disable_allowed)
175 return;
176
177 for (i = 0; i < dev->num_crtcs; i++) {
178 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Ville Syrjälä5380e922013-10-04 14:53:36 +0300179 if (atomic_read(&dev->vblank[i].refcount) == 0 &&
180 dev->vblank[i].enabled) {
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700181 DRM_DEBUG("disabling vblank on crtc %d\n", i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200182 vblank_disable_and_save(dev, i);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700183 }
184 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
185 }
186}
187
Keith Packard52440212008-11-18 09:30:25 -0800188void drm_vblank_cleanup(struct drm_device *dev)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700189{
190 /* Bail if the driver didn't call drm_vblank_init() */
191 if (dev->num_crtcs == 0)
192 return;
193
Laurent Pinchart7eb3b2c2012-05-17 13:27:19 +0200194 del_timer_sync(&dev->vblank_disable_timer);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700195
196 vblank_disable_fn((unsigned long)dev);
197
Ville Syrjälä5380e922013-10-04 14:53:36 +0300198 kfree(dev->vblank);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700199
200 dev->num_crtcs = 0;
201}
Jerome Glissee77cef92010-01-07 15:39:13 +0100202EXPORT_SYMBOL(drm_vblank_cleanup);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700203
204int drm_vblank_init(struct drm_device *dev, int num_crtcs)
205{
206 int i, ret = -ENOMEM;
207
208 setup_timer(&dev->vblank_disable_timer, vblank_disable_fn,
209 (unsigned long)dev);
210 spin_lock_init(&dev->vbl_lock);
Mario Kleiner27641c32010-10-23 04:20:23 +0200211 spin_lock_init(&dev->vblank_time_lock);
212
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700213 dev->num_crtcs = num_crtcs;
214
Ville Syrjälä5380e922013-10-04 14:53:36 +0300215 dev->vblank = kcalloc(num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
216 if (!dev->vblank)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700217 goto err;
218
Ville Syrjälä5380e922013-10-04 14:53:36 +0300219 for (i = 0; i < num_crtcs; i++)
220 init_waitqueue_head(&dev->vblank[i].queue);
Mario Kleiner27641c32010-10-23 04:20:23 +0200221
222 DRM_INFO("Supports vblank timestamp caching Rev 1 (10.10.2010).\n");
223
224 /* Driver specific high-precision vblank timestamping supported? */
225 if (dev->driver->get_vblank_timestamp)
226 DRM_INFO("Driver supports precise vblank timestamp query.\n");
227 else
228 DRM_INFO("No driver support for vblank timestamp query.\n");
229
Ville Syrjäläba0bf122013-10-04 14:53:33 +0300230 dev->vblank_disable_allowed = false;
231
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700232 return 0;
233
234err:
235 drm_vblank_cleanup(dev);
236 return ret;
237}
238EXPORT_SYMBOL(drm_vblank_init);
239
Dave Airlie28d52042009-09-21 14:33:58 +1000240static void drm_irq_vgaarb_nokms(void *cookie, bool state)
241{
242 struct drm_device *dev = cookie;
243
244 if (dev->driver->vgaarb_irq) {
245 dev->driver->vgaarb_irq(dev, state);
246 return;
247 }
248
249 if (!dev->irq_enabled)
250 return;
251
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000252 if (state) {
253 if (dev->driver->irq_uninstall)
254 dev->driver->irq_uninstall(dev);
255 } else {
256 if (dev->driver->irq_preinstall)
257 dev->driver->irq_preinstall(dev);
258 if (dev->driver->irq_postinstall)
259 dev->driver->irq_postinstall(dev);
Dave Airlie28d52042009-09-21 14:33:58 +1000260 }
261}
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263/**
264 * Install IRQ handler.
265 *
266 * \param dev DRM device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 *
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700268 * Initializes the IRQ related data. Installs the handler, calling the driver
Sascha Hauer884a53e2012-02-29 09:06:21 +0100269 * \c irq_preinstall() and \c irq_postinstall() functions
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 * before and after the installation.
271 */
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700272int drm_irq_install(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200274 int ret;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000275 unsigned long sh_flags = 0;
Dave Airlieb8da7de2009-06-02 16:50:35 +1000276 char *irqname;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
279 return -EINVAL;
280
Jordan Crousedcdb1672010-05-27 13:40:25 -0600281 if (drm_dev_to_irq(dev) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 return -EINVAL;
283
Dave Airlie30e2fb12006-02-02 19:37:46 +1100284 mutex_lock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 /* Driver must have been initialized */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000287 if (!dev->dev_private) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100288 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 return -EINVAL;
290 }
291
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000292 if (dev->irq_enabled) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100293 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 return -EBUSY;
295 }
Ville Syrjälä44238432013-10-04 14:53:37 +0300296 dev->irq_enabled = true;
Dave Airlie30e2fb12006-02-02 19:37:46 +1100297 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Jordan Crousedcdb1672010-05-27 13:40:25 -0600299 DRM_DEBUG("irq=%d\n", drm_dev_to_irq(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000301 /* Before installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000302 if (dev->driver->irq_preinstall)
303 dev->driver->irq_preinstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000305 /* Install handler */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
Thomas Gleixner935f6e32006-07-01 19:29:34 -0700307 sh_flags = IRQF_SHARED;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000308
Dave Airlieb8da7de2009-06-02 16:50:35 +1000309 if (dev->devname)
310 irqname = dev->devname;
311 else
312 irqname = dev->driver->name;
313
Jesse Barnes9bfbd5c2008-09-15 15:00:33 -0700314 ret = request_irq(drm_dev_to_irq(dev), dev->driver->irq_handler,
Dave Airlieb8da7de2009-06-02 16:50:35 +1000315 sh_flags, irqname, dev);
Jesse Barnes9bfbd5c2008-09-15 15:00:33 -0700316
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000317 if (ret < 0) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100318 mutex_lock(&dev->struct_mutex);
Ville Syrjälä44238432013-10-04 14:53:37 +0300319 dev->irq_enabled = false;
Dave Airlie30e2fb12006-02-02 19:37:46 +1100320 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 return ret;
322 }
323
Dave Airlie28d52042009-09-21 14:33:58 +1000324 if (!drm_core_check_feature(dev, DRIVER_MODESET))
325 vga_client_register(dev->pdev, (void *)dev, drm_irq_vgaarb_nokms, NULL);
326
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000327 /* After installing handler */
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000328 if (dev->driver->irq_postinstall)
329 ret = dev->driver->irq_postinstall(dev);
330
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700331 if (ret < 0) {
332 mutex_lock(&dev->struct_mutex);
Ville Syrjälä44238432013-10-04 14:53:37 +0300333 dev->irq_enabled = false;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700334 mutex_unlock(&dev->struct_mutex);
Joonyoung Shime1c44ac2011-08-04 05:41:00 +0000335 if (!drm_core_check_feature(dev, DRIVER_MODESET))
336 vga_client_register(dev->pdev, NULL, NULL, NULL);
337 free_irq(drm_dev_to_irq(dev), dev);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700340 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341}
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700342EXPORT_SYMBOL(drm_irq_install);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344/**
345 * Uninstall the IRQ handler.
346 *
347 * \param dev DRM device.
348 *
Sascha Hauer884a53e2012-02-29 09:06:21 +0100349 * Calls the driver's \c irq_uninstall() function, and stops the irq.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200351int drm_irq_uninstall(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800353 unsigned long irqflags;
Ville Syrjälä44238432013-10-04 14:53:37 +0300354 bool irq_enabled;
355 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
358 return -EINVAL;
359
Dave Airlie30e2fb12006-02-02 19:37:46 +1100360 mutex_lock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 irq_enabled = dev->irq_enabled;
Ville Syrjälä44238432013-10-04 14:53:37 +0300362 dev->irq_enabled = false;
Dave Airlie30e2fb12006-02-02 19:37:46 +1100363 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800365 /*
366 * Wake up any waiters so they don't hang.
367 */
Ben Skeggsbde48892011-07-04 12:52:27 +1000368 if (dev->num_crtcs) {
369 spin_lock_irqsave(&dev->vbl_lock, irqflags);
370 for (i = 0; i < dev->num_crtcs; i++) {
Ville Syrjälä5380e922013-10-04 14:53:36 +0300371 DRM_WAKEUP(&dev->vblank[i].queue);
372 dev->vblank[i].enabled = false;
373 dev->vblank[i].last =
Ben Skeggsbde48892011-07-04 12:52:27 +1000374 dev->driver->get_vblank_counter(dev, i);
375 }
376 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800377 }
Jesse Barnesdc1336f2009-01-06 10:21:24 -0800378
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000379 if (!irq_enabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return -EINVAL;
381
Jordan Crousedcdb1672010-05-27 13:40:25 -0600382 DRM_DEBUG("irq=%d\n", drm_dev_to_irq(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Dave Airlie28d52042009-09-21 14:33:58 +1000384 if (!drm_core_check_feature(dev, DRIVER_MODESET))
385 vga_client_register(dev->pdev, NULL, NULL, NULL);
386
Joonyoung Shim5037f8a2011-08-04 05:41:01 +0000387 if (dev->driver->irq_uninstall)
388 dev->driver->irq_uninstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Jordan Crousedcdb1672010-05-27 13:40:25 -0600390 free_irq(drm_dev_to_irq(dev), dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392 return 0;
393}
394EXPORT_SYMBOL(drm_irq_uninstall);
395
396/**
397 * IRQ control ioctl.
398 *
399 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +1000400 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 * \param cmd command.
402 * \param arg user argument, pointing to a drm_control structure.
403 * \return zero on success or a negative number on failure.
404 *
405 * Calls irq_install() or irq_uninstall() according to \p arg.
406 */
Eric Anholtc153f452007-09-03 12:06:45 +1000407int drm_control(struct drm_device *dev, void *data,
408 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409{
Eric Anholtc153f452007-09-03 12:06:45 +1000410 struct drm_control *ctl = data;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000411
Mario Kleiner27641c32010-10-23 04:20:23 +0200412 /* if we haven't irq we fallback for compatibility reasons -
413 * this used to be a separate function in drm_dma.h
414 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Eric Anholtc153f452007-09-03 12:06:45 +1000417 switch (ctl->func) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 case DRM_INST_HANDLER:
419 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
420 return 0;
Dave Airlief453ba02008-11-07 14:05:41 -0800421 if (drm_core_check_feature(dev, DRIVER_MODESET))
422 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
Jordan Crousedcdb1672010-05-27 13:40:25 -0600424 ctl->irq != drm_dev_to_irq(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 return -EINVAL;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000426 return drm_irq_install(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 case DRM_UNINST_HANDLER:
428 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
429 return 0;
Dave Airlief453ba02008-11-07 14:05:41 -0800430 if (drm_core_check_feature(dev, DRIVER_MODESET))
431 return 0;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000432 return drm_irq_uninstall(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 default:
434 return -EINVAL;
435 }
436}
437
438/**
Mario Kleiner27641c32010-10-23 04:20:23 +0200439 * drm_calc_timestamping_constants - Calculate and
440 * store various constants which are later needed by
441 * vblank and swap-completion timestamping, e.g, by
442 * drm_calc_vbltimestamp_from_scanoutpos().
443 * They are derived from crtc's true scanout timing,
444 * so they take things like panel scaling or other
445 * adjustments into account.
446 *
447 * @crtc drm_crtc whose timestamp constants should be updated.
448 *
449 */
450void drm_calc_timestamping_constants(struct drm_crtc *crtc)
451{
452 s64 linedur_ns = 0, pixeldur_ns = 0, framedur_ns = 0;
453 u64 dotclock;
454
455 /* Dot clock in Hz: */
456 dotclock = (u64) crtc->hwmode.clock * 1000;
457
Mario Kleiner9be6f8a2011-02-21 05:42:02 +0100458 /* Fields of interlaced scanout modes are only halve a frame duration.
459 * Double the dotclock to get halve the frame-/line-/pixelduration.
460 */
461 if (crtc->hwmode.flags & DRM_MODE_FLAG_INTERLACE)
462 dotclock *= 2;
463
Mario Kleiner27641c32010-10-23 04:20:23 +0200464 /* Valid dotclock? */
465 if (dotclock > 0) {
Daniel Kurtz85a7ce62012-12-27 01:01:46 +0000466 int frame_size;
Mario Kleiner27641c32010-10-23 04:20:23 +0200467 /* Convert scanline length in pixels and video dot clock to
468 * line duration, frame duration and pixel duration in
469 * nanoseconds:
470 */
471 pixeldur_ns = (s64) div64_u64(1000000000, dotclock);
472 linedur_ns = (s64) div64_u64(((u64) crtc->hwmode.crtc_htotal *
473 1000000000), dotclock);
Daniel Kurtz85a7ce62012-12-27 01:01:46 +0000474 frame_size = crtc->hwmode.crtc_htotal *
475 crtc->hwmode.crtc_vtotal;
476 framedur_ns = (s64) div64_u64((u64) frame_size * 1000000000,
477 dotclock);
Mario Kleiner27641c32010-10-23 04:20:23 +0200478 } else
479 DRM_ERROR("crtc %d: Can't calculate constants, dotclock = 0!\n",
480 crtc->base.id);
481
482 crtc->pixeldur_ns = pixeldur_ns;
483 crtc->linedur_ns = linedur_ns;
484 crtc->framedur_ns = framedur_ns;
485
486 DRM_DEBUG("crtc %d: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
487 crtc->base.id, crtc->hwmode.crtc_htotal,
488 crtc->hwmode.crtc_vtotal, crtc->hwmode.crtc_vdisplay);
489 DRM_DEBUG("crtc %d: clock %d kHz framedur %d linedur %d, pixeldur %d\n",
490 crtc->base.id, (int) dotclock/1000, (int) framedur_ns,
491 (int) linedur_ns, (int) pixeldur_ns);
492}
493EXPORT_SYMBOL(drm_calc_timestamping_constants);
494
495/**
496 * drm_calc_vbltimestamp_from_scanoutpos - helper routine for kms
497 * drivers. Implements calculation of exact vblank timestamps from
498 * given drm_display_mode timings and current video scanout position
499 * of a crtc. This can be called from within get_vblank_timestamp()
500 * implementation of a kms driver to implement the actual timestamping.
501 *
502 * Should return timestamps conforming to the OML_sync_control OpenML
503 * extension specification. The timestamp corresponds to the end of
504 * the vblank interval, aka start of scanout of topmost-leftmost display
505 * pixel in the following video frame.
506 *
507 * Requires support for optional dev->driver->get_scanout_position()
508 * in kms driver, plus a bit of setup code to provide a drm_display_mode
509 * that corresponds to the true scanout timing.
510 *
511 * The current implementation only handles standard video modes. It
512 * returns as no operation if a doublescan or interlaced video mode is
513 * active. Higher level code is expected to handle this.
514 *
515 * @dev: DRM device.
516 * @crtc: Which crtc's vblank timestamp to retrieve.
517 * @max_error: Desired maximum allowable error in timestamps (nanosecs).
518 * On return contains true maximum error of timestamp.
519 * @vblank_time: Pointer to struct timeval which should receive the timestamp.
520 * @flags: Flags to pass to driver:
521 * 0 = Default.
522 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl irq handler.
523 * @refcrtc: drm_crtc* of crtc which defines scanout timing.
524 *
525 * Returns negative value on error, failure or if not supported in current
526 * video mode:
527 *
528 * -EINVAL - Invalid crtc.
529 * -EAGAIN - Temporary unavailable, e.g., called before initial modeset.
530 * -ENOTSUPP - Function not supported in current display mode.
531 * -EIO - Failed, e.g., due to failed scanout position query.
532 *
533 * Returns or'ed positive status flags on success:
534 *
535 * DRM_VBLANKTIME_SCANOUTPOS_METHOD - Signal this method used for timestamping.
536 * DRM_VBLANKTIME_INVBL - Timestamp taken while scanout was in vblank interval.
537 *
538 */
539int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, int crtc,
540 int *max_error,
541 struct timeval *vblank_time,
542 unsigned flags,
543 struct drm_crtc *refcrtc)
544{
Imre Deake62f2f52012-10-23 18:53:25 +0000545 ktime_t stime, etime, mono_time_offset;
546 struct timeval tv_etime;
Mario Kleiner27641c32010-10-23 04:20:23 +0200547 struct drm_display_mode *mode;
548 int vbl_status, vtotal, vdisplay;
549 int vpos, hpos, i;
550 s64 framedur_ns, linedur_ns, pixeldur_ns, delta_ns, duration_ns;
551 bool invbl;
552
553 if (crtc < 0 || crtc >= dev->num_crtcs) {
554 DRM_ERROR("Invalid crtc %d\n", crtc);
555 return -EINVAL;
556 }
557
558 /* Scanout position query not supported? Should not happen. */
559 if (!dev->driver->get_scanout_position) {
560 DRM_ERROR("Called from driver w/o get_scanout_position()!?\n");
561 return -EIO;
562 }
563
564 mode = &refcrtc->hwmode;
565 vtotal = mode->crtc_vtotal;
566 vdisplay = mode->crtc_vdisplay;
567
568 /* Durations of frames, lines, pixels in nanoseconds. */
569 framedur_ns = refcrtc->framedur_ns;
570 linedur_ns = refcrtc->linedur_ns;
571 pixeldur_ns = refcrtc->pixeldur_ns;
572
573 /* If mode timing undefined, just return as no-op:
574 * Happens during initial modesetting of a crtc.
575 */
576 if (vtotal <= 0 || vdisplay <= 0 || framedur_ns == 0) {
577 DRM_DEBUG("crtc %d: Noop due to uninitialized mode.\n", crtc);
578 return -EAGAIN;
579 }
580
Mario Kleiner27641c32010-10-23 04:20:23 +0200581 /* Get current scanout position with system timestamp.
582 * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times
583 * if single query takes longer than max_error nanoseconds.
584 *
585 * This guarantees a tight bound on maximum error if
586 * code gets preempted or delayed for some reason.
587 */
588 for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) {
589 /* Disable preemption to make it very likely to
590 * succeed in the first iteration even on PREEMPT_RT kernel.
591 */
592 preempt_disable();
593
594 /* Get system timestamp before query. */
Imre Deake62f2f52012-10-23 18:53:25 +0000595 stime = ktime_get();
Mario Kleiner27641c32010-10-23 04:20:23 +0200596
597 /* Get vertical and horizontal scanout pos. vpos, hpos. */
598 vbl_status = dev->driver->get_scanout_position(dev, crtc, &vpos, &hpos);
599
600 /* Get system timestamp after query. */
Imre Deake62f2f52012-10-23 18:53:25 +0000601 etime = ktime_get();
Imre Deakc61eef72012-10-23 18:53:26 +0000602 if (!drm_timestamp_monotonic)
603 mono_time_offset = ktime_get_monotonic_offset();
Mario Kleiner27641c32010-10-23 04:20:23 +0200604
605 preempt_enable();
606
607 /* Return as no-op if scanout query unsupported or failed. */
608 if (!(vbl_status & DRM_SCANOUTPOS_VALID)) {
609 DRM_DEBUG("crtc %d : scanoutpos query failed [%d].\n",
610 crtc, vbl_status);
611 return -EIO;
612 }
613
Imre Deake62f2f52012-10-23 18:53:25 +0000614 duration_ns = ktime_to_ns(etime) - ktime_to_ns(stime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200615
616 /* Accept result with < max_error nsecs timing uncertainty. */
617 if (duration_ns <= (s64) *max_error)
618 break;
619 }
620
621 /* Noisy system timing? */
622 if (i == DRM_TIMESTAMP_MAXRETRIES) {
623 DRM_DEBUG("crtc %d: Noisy timestamp %d us > %d us [%d reps].\n",
624 crtc, (int) duration_ns/1000, *max_error/1000, i);
625 }
626
627 /* Return upper bound of timestamp precision error. */
628 *max_error = (int) duration_ns;
629
630 /* Check if in vblank area:
631 * vpos is >=0 in video scanout area, but negative
632 * within vblank area, counting down the number of lines until
633 * start of scanout.
634 */
635 invbl = vbl_status & DRM_SCANOUTPOS_INVBL;
636
637 /* Convert scanout position into elapsed time at raw_time query
638 * since start of scanout at first display scanline. delta_ns
639 * can be negative if start of scanout hasn't happened yet.
640 */
641 delta_ns = (s64) vpos * linedur_ns + (s64) hpos * pixeldur_ns;
642
643 /* Is vpos outside nominal vblank area, but less than
644 * 1/100 of a frame height away from start of vblank?
645 * If so, assume this isn't a massively delayed vblank
646 * interrupt, but a vblank interrupt that fired a few
647 * microseconds before true start of vblank. Compensate
648 * by adding a full frame duration to the final timestamp.
649 * Happens, e.g., on ATI R500, R600.
650 *
651 * We only do this if DRM_CALLED_FROM_VBLIRQ.
652 */
653 if ((flags & DRM_CALLED_FROM_VBLIRQ) && !invbl &&
654 ((vdisplay - vpos) < vtotal / 100)) {
655 delta_ns = delta_ns - framedur_ns;
656
657 /* Signal this correction as "applied". */
658 vbl_status |= 0x8;
659 }
660
Imre Deakc61eef72012-10-23 18:53:26 +0000661 if (!drm_timestamp_monotonic)
662 etime = ktime_sub(etime, mono_time_offset);
663
Imre Deake62f2f52012-10-23 18:53:25 +0000664 /* save this only for debugging purposes */
665 tv_etime = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200666 /* Subtract time delta from raw timestamp to get final
667 * vblank_time timestamp for end of vblank.
668 */
Michel Dänzere91abf82013-06-12 11:58:44 +0200669 if (delta_ns < 0)
670 etime = ktime_add_ns(etime, -delta_ns);
671 else
672 etime = ktime_sub_ns(etime, delta_ns);
Imre Deake62f2f52012-10-23 18:53:25 +0000673 *vblank_time = ktime_to_timeval(etime);
Mario Kleiner27641c32010-10-23 04:20:23 +0200674
Joe Perchesbbb0aef52011-04-17 20:35:52 -0700675 DRM_DEBUG("crtc %d : v %d p(%d,%d)@ %ld.%ld -> %ld.%ld [e %d us, %d rep]\n",
676 crtc, (int)vbl_status, hpos, vpos,
Imre Deake62f2f52012-10-23 18:53:25 +0000677 (long)tv_etime.tv_sec, (long)tv_etime.tv_usec,
Joe Perchesbbb0aef52011-04-17 20:35:52 -0700678 (long)vblank_time->tv_sec, (long)vblank_time->tv_usec,
679 (int)duration_ns/1000, i);
Mario Kleiner27641c32010-10-23 04:20:23 +0200680
681 vbl_status = DRM_VBLANKTIME_SCANOUTPOS_METHOD;
682 if (invbl)
683 vbl_status |= DRM_VBLANKTIME_INVBL;
684
685 return vbl_status;
686}
687EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
688
Imre Deakc61eef72012-10-23 18:53:26 +0000689static struct timeval get_drm_timestamp(void)
690{
691 ktime_t now;
692
693 now = ktime_get();
694 if (!drm_timestamp_monotonic)
695 now = ktime_sub(now, ktime_get_monotonic_offset());
696
697 return ktime_to_timeval(now);
698}
699
Mario Kleiner27641c32010-10-23 04:20:23 +0200700/**
701 * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent
702 * vblank interval.
703 *
704 * @dev: DRM device
705 * @crtc: which crtc's vblank timestamp to retrieve
706 * @tvblank: Pointer to target struct timeval which should receive the timestamp
707 * @flags: Flags to pass to driver:
708 * 0 = Default.
709 * DRM_CALLED_FROM_VBLIRQ = If function is called from vbl irq handler.
710 *
711 * Fetches the system timestamp corresponding to the time of the most recent
712 * vblank interval on specified crtc. May call into kms-driver to
713 * compute the timestamp with a high-precision GPU specific method.
714 *
715 * Returns zero if timestamp originates from uncorrected do_gettimeofday()
716 * call, i.e., it isn't very precisely locked to the true vblank.
717 *
718 * Returns non-zero if timestamp is considered to be very precise.
719 */
720u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
721 struct timeval *tvblank, unsigned flags)
722{
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200723 int ret;
Mario Kleiner27641c32010-10-23 04:20:23 +0200724
725 /* Define requested maximum error on timestamps (nanoseconds). */
726 int max_error = (int) drm_timestamp_precision * 1000;
727
728 /* Query driver if possible and precision timestamping enabled. */
729 if (dev->driver->get_vblank_timestamp && (max_error > 0)) {
730 ret = dev->driver->get_vblank_timestamp(dev, crtc, &max_error,
731 tvblank, flags);
732 if (ret > 0)
733 return (u32) ret;
734 }
735
736 /* GPU high precision timestamp query unsupported or failed.
Imre Deakc61eef72012-10-23 18:53:26 +0000737 * Return current monotonic/gettimeofday timestamp as best estimate.
Mario Kleiner27641c32010-10-23 04:20:23 +0200738 */
Imre Deakc61eef72012-10-23 18:53:26 +0000739 *tvblank = get_drm_timestamp();
Mario Kleiner27641c32010-10-23 04:20:23 +0200740
741 return 0;
742}
743EXPORT_SYMBOL(drm_get_last_vbltimestamp);
744
745/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700746 * drm_vblank_count - retrieve "cooked" vblank counter value
747 * @dev: DRM device
748 * @crtc: which counter to retrieve
749 *
750 * Fetches the "cooked" vblank count value that represents the number of
751 * vblank events since the system was booted, including lost events due to
752 * modesetting activity.
753 */
754u32 drm_vblank_count(struct drm_device *dev, int crtc)
755{
Ville Syrjälä5380e922013-10-04 14:53:36 +0300756 return atomic_read(&dev->vblank[crtc].count);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700757}
758EXPORT_SYMBOL(drm_vblank_count);
759
760/**
Mario Kleiner27641c32010-10-23 04:20:23 +0200761 * drm_vblank_count_and_time - retrieve "cooked" vblank counter value
762 * and the system timestamp corresponding to that vblank counter value.
763 *
764 * @dev: DRM device
765 * @crtc: which counter to retrieve
766 * @vblanktime: Pointer to struct timeval to receive the vblank timestamp.
767 *
768 * Fetches the "cooked" vblank count value that represents the number of
769 * vblank events since the system was booted, including lost events due to
770 * modesetting activity. Returns corresponding system timestamp of the time
771 * of the vblank interval that corresponds to the current value vblank counter
772 * value.
773 */
774u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
775 struct timeval *vblanktime)
776{
777 u32 cur_vblank;
778
779 /* Read timestamp from slot of _vblank_time ringbuffer
780 * that corresponds to current vblank count. Retry if
781 * count has incremented during readout. This works like
782 * a seqlock.
783 */
784 do {
Ville Syrjälä5380e922013-10-04 14:53:36 +0300785 cur_vblank = atomic_read(&dev->vblank[crtc].count);
Mario Kleiner27641c32010-10-23 04:20:23 +0200786 *vblanktime = vblanktimestamp(dev, crtc, cur_vblank);
787 smp_rmb();
Ville Syrjälä5380e922013-10-04 14:53:36 +0300788 } while (cur_vblank != atomic_read(&dev->vblank[crtc].count));
Mario Kleiner27641c32010-10-23 04:20:23 +0200789
790 return cur_vblank;
791}
792EXPORT_SYMBOL(drm_vblank_count_and_time);
793
Rob Clarkc6eefa12012-10-16 22:48:40 +0000794static void send_vblank_event(struct drm_device *dev,
795 struct drm_pending_vblank_event *e,
796 unsigned long seq, struct timeval *now)
797{
798 WARN_ON_SMP(!spin_is_locked(&dev->event_lock));
799 e->event.sequence = seq;
800 e->event.tv_sec = now->tv_sec;
801 e->event.tv_usec = now->tv_usec;
802
803 list_add_tail(&e->base.link,
804 &e->base.file_priv->event_list);
805 wake_up_interruptible(&e->base.file_priv->event_wait);
806 trace_drm_vblank_event_delivered(e->base.pid, e->pipe,
807 e->event.sequence);
808}
809
810/**
811 * drm_send_vblank_event - helper to send vblank event after pageflip
812 * @dev: DRM device
813 * @crtc: CRTC in question
814 * @e: the event to send
815 *
816 * Updates sequence # and timestamp on event, and sends it to userspace.
817 * Caller must hold event lock.
818 */
819void drm_send_vblank_event(struct drm_device *dev, int crtc,
820 struct drm_pending_vblank_event *e)
821{
822 struct timeval now;
823 unsigned int seq;
824 if (crtc >= 0) {
825 seq = drm_vblank_count_and_time(dev, crtc, &now);
826 } else {
827 seq = 0;
Imre Deakc61eef72012-10-23 18:53:26 +0000828
829 now = get_drm_timestamp();
Rob Clarkc6eefa12012-10-16 22:48:40 +0000830 }
Rob Clark21a245d2012-12-10 10:49:46 -0600831 e->pipe = crtc;
Rob Clarkc6eefa12012-10-16 22:48:40 +0000832 send_vblank_event(dev, e, seq, &now);
833}
834EXPORT_SYMBOL(drm_send_vblank_event);
835
Mario Kleiner27641c32010-10-23 04:20:23 +0200836/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700837 * drm_update_vblank_count - update the master vblank counter
838 * @dev: DRM device
839 * @crtc: counter to update
840 *
841 * Call back into the driver to update the appropriate vblank counter
842 * (specified by @crtc). Deal with wraparound, if it occurred, and
843 * update the last read value so we can deal with wraparound on the next
844 * call if necessary.
845 *
846 * Only necessary when going from off->on, to account for frames we
847 * didn't get an interrupt for.
848 *
849 * Note: caller must hold dev->vbl_lock since this reads & writes
850 * device vblank fields.
851 */
852static void drm_update_vblank_count(struct drm_device *dev, int crtc)
853{
Mario Kleiner27641c32010-10-23 04:20:23 +0200854 u32 cur_vblank, diff, tslot, rc;
855 struct timeval t_vblank;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700856
857 /*
858 * Interrupts were disabled prior to this call, so deal with counter
859 * wrap if needed.
860 * NOTE! It's possible we lost a full dev->max_vblank_count events
861 * here if the register is small or we had vblank interrupts off for
862 * a long time.
Mario Kleiner27641c32010-10-23 04:20:23 +0200863 *
864 * We repeat the hardware vblank counter & timestamp query until
865 * we get consistent results. This to prevent races between gpu
866 * updating its hardware counter while we are retrieving the
867 * corresponding vblank timestamp.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700868 */
Mario Kleiner27641c32010-10-23 04:20:23 +0200869 do {
870 cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
871 rc = drm_get_last_vbltimestamp(dev, crtc, &t_vblank, 0);
872 } while (cur_vblank != dev->driver->get_vblank_counter(dev, crtc));
873
874 /* Deal with counter wrap */
Ville Syrjälä5380e922013-10-04 14:53:36 +0300875 diff = cur_vblank - dev->vblank[crtc].last;
876 if (cur_vblank < dev->vblank[crtc].last) {
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700877 diff += dev->max_vblank_count;
878
879 DRM_DEBUG("last_vblank[%d]=0x%x, cur_vblank=0x%x => diff=0x%x\n",
Ville Syrjälä5380e922013-10-04 14:53:36 +0300880 crtc, dev->vblank[crtc].last, cur_vblank, diff);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700881 }
882
883 DRM_DEBUG("enabling vblank interrupts on crtc %d, missed %d\n",
884 crtc, diff);
885
Mario Kleiner27641c32010-10-23 04:20:23 +0200886 /* Reinitialize corresponding vblank timestamp if high-precision query
887 * available. Skip this step if query unsupported or failed. Will
888 * reinitialize delayed at next vblank interrupt in that case.
889 */
890 if (rc) {
Ville Syrjälä5380e922013-10-04 14:53:36 +0300891 tslot = atomic_read(&dev->vblank[crtc].count) + diff;
Mario Kleiner27641c32010-10-23 04:20:23 +0200892 vblanktimestamp(dev, crtc, tslot) = t_vblank;
Mario Kleiner27641c32010-10-23 04:20:23 +0200893 }
894
Mario Kleinerbc215122011-02-21 05:42:01 +0100895 smp_mb__before_atomic_inc();
Ville Syrjälä5380e922013-10-04 14:53:36 +0300896 atomic_add(diff, &dev->vblank[crtc].count);
Mario Kleinerbc215122011-02-21 05:42:01 +0100897 smp_mb__after_atomic_inc();
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700898}
899
900/**
901 * drm_vblank_get - get a reference count on vblank events
902 * @dev: DRM device
903 * @crtc: which CRTC to own
904 *
905 * Acquire a reference count on vblank events to avoid having them disabled
906 * while in use.
907 *
908 * RETURNS
909 * Zero on success, nonzero on failure.
910 */
911int drm_vblank_get(struct drm_device *dev, int crtc)
912{
Mario Kleiner27641c32010-10-23 04:20:23 +0200913 unsigned long irqflags, irqflags2;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700914 int ret = 0;
915
916 spin_lock_irqsave(&dev->vbl_lock, irqflags);
917 /* Going from 0->1 means we have to enable interrupts again */
Ville Syrjälä5380e922013-10-04 14:53:36 +0300918 if (atomic_add_return(1, &dev->vblank[crtc].refcount) == 1) {
Mario Kleiner27641c32010-10-23 04:20:23 +0200919 spin_lock_irqsave(&dev->vblank_time_lock, irqflags2);
Ville Syrjälä5380e922013-10-04 14:53:36 +0300920 if (!dev->vblank[crtc].enabled) {
Mario Kleiner27641c32010-10-23 04:20:23 +0200921 /* Enable vblank irqs under vblank_time_lock protection.
922 * All vblank count & timestamp updates are held off
923 * until we are done reinitializing master counter and
924 * timestamps. Filtercode in drm_handle_vblank() will
925 * prevent double-accounting of same vblank interval.
926 */
Li Peng778c9022009-11-09 12:51:22 +0800927 ret = dev->driver->enable_vblank(dev, crtc);
Mario Kleiner27641c32010-10-23 04:20:23 +0200928 DRM_DEBUG("enabling vblank on crtc %d, ret: %d\n",
929 crtc, ret);
Li Peng778c9022009-11-09 12:51:22 +0800930 if (ret)
Ville Syrjälä5380e922013-10-04 14:53:36 +0300931 atomic_dec(&dev->vblank[crtc].refcount);
Li Peng778c9022009-11-09 12:51:22 +0800932 else {
Ville Syrjälä5380e922013-10-04 14:53:36 +0300933 dev->vblank[crtc].enabled = true;
Li Peng778c9022009-11-09 12:51:22 +0800934 drm_update_vblank_count(dev, crtc);
935 }
936 }
Mario Kleiner27641c32010-10-23 04:20:23 +0200937 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags2);
Li Peng778c9022009-11-09 12:51:22 +0800938 } else {
Ville Syrjälä5380e922013-10-04 14:53:36 +0300939 if (!dev->vblank[crtc].enabled) {
940 atomic_dec(&dev->vblank[crtc].refcount);
Li Peng778c9022009-11-09 12:51:22 +0800941 ret = -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700942 }
943 }
944 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
945
946 return ret;
947}
948EXPORT_SYMBOL(drm_vblank_get);
949
950/**
951 * drm_vblank_put - give up ownership of vblank events
952 * @dev: DRM device
953 * @crtc: which counter to give up
954 *
955 * Release ownership of a given vblank counter, turning off interrupts
Mario Kleiner27641c32010-10-23 04:20:23 +0200956 * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700957 */
958void drm_vblank_put(struct drm_device *dev, int crtc)
959{
Ville Syrjälä5380e922013-10-04 14:53:36 +0300960 BUG_ON(atomic_read(&dev->vblank[crtc].refcount) == 0);
Chris Wilsonb3f5e732009-02-19 14:48:22 +0000961
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700962 /* Last user schedules interrupt disable */
Ville Syrjälä5380e922013-10-04 14:53:36 +0300963 if (atomic_dec_and_test(&dev->vblank[crtc].refcount) &&
Mario Kleiner27641c32010-10-23 04:20:23 +0200964 (drm_vblank_offdelay > 0))
965 mod_timer(&dev->vblank_disable_timer,
966 jiffies + ((drm_vblank_offdelay * DRM_HZ)/1000));
Jesse Barnes0a3e67a2008-09-30 12:14:26 -0700967}
968EXPORT_SYMBOL(drm_vblank_put);
969
Rob Clarkc6eefa12012-10-16 22:48:40 +0000970/**
971 * drm_vblank_off - disable vblank events on a CRTC
972 * @dev: DRM device
973 * @crtc: CRTC in question
974 *
975 * Caller must hold event lock.
976 */
Li Peng778c9022009-11-09 12:51:22 +0800977void drm_vblank_off(struct drm_device *dev, int crtc)
978{
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +1000979 struct drm_pending_vblank_event *e, *t;
980 struct timeval now;
Li Peng778c9022009-11-09 12:51:22 +0800981 unsigned long irqflags;
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +1000982 unsigned int seq;
Li Peng778c9022009-11-09 12:51:22 +0800983
984 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Mario Kleiner27641c32010-10-23 04:20:23 +0200985 vblank_disable_and_save(dev, crtc);
Ville Syrjälä5380e922013-10-04 14:53:36 +0300986 DRM_WAKEUP(&dev->vblank[crtc].queue);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +1000987
988 /* Send any queued vblank events, lest the natives grow disquiet */
989 seq = drm_vblank_count_and_time(dev, crtc, &now);
Imre Deake7783ba2012-11-02 13:30:50 +0200990
991 spin_lock(&dev->event_lock);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +1000992 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
993 if (e->pipe != crtc)
994 continue;
995 DRM_DEBUG("Sending premature vblank event on disable: \
996 wanted %d, current %d\n",
997 e->event.sequence, seq);
Rob Clarkc6eefa12012-10-16 22:48:40 +0000998 list_del(&e->base.link);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +1000999 drm_vblank_put(dev, e->pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001000 send_vblank_event(dev, e, seq, &now);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001001 }
Imre Deake7783ba2012-11-02 13:30:50 +02001002 spin_unlock(&dev->event_lock);
Christopher James Halse Rogers498548e2011-04-27 16:10:57 +10001003
Li Peng778c9022009-11-09 12:51:22 +08001004 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1005}
1006EXPORT_SYMBOL(drm_vblank_off);
1007
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001008/**
Dave Airlief453ba02008-11-07 14:05:41 -08001009 * drm_vblank_pre_modeset - account for vblanks across mode sets
1010 * @dev: DRM device
1011 * @crtc: CRTC in question
Dave Airlief453ba02008-11-07 14:05:41 -08001012 *
1013 * Account for vblank events across mode setting events, which will likely
1014 * reset the hardware frame counter.
1015 */
1016void drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
1017{
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001018 /* vblank is not initialized (IRQ not installed ?), or has been freed */
Jerome Glissee77cef92010-01-07 15:39:13 +01001019 if (!dev->num_crtcs)
1020 return;
Dave Airlief453ba02008-11-07 14:05:41 -08001021 /*
1022 * To avoid all the problems that might happen if interrupts
1023 * were enabled/disabled around or between these calls, we just
1024 * have the kernel take a reference on the CRTC (just once though
1025 * to avoid corrupting the count if multiple, mismatch calls occur),
1026 * so that interrupts remain enabled in the interim.
1027 */
Ville Syrjälä5380e922013-10-04 14:53:36 +03001028 if (!dev->vblank[crtc].inmodeset) {
1029 dev->vblank[crtc].inmodeset = 0x1;
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001030 if (drm_vblank_get(dev, crtc) == 0)
Ville Syrjälä5380e922013-10-04 14:53:36 +03001031 dev->vblank[crtc].inmodeset |= 0x2;
Dave Airlief453ba02008-11-07 14:05:41 -08001032 }
1033}
1034EXPORT_SYMBOL(drm_vblank_pre_modeset);
1035
1036void drm_vblank_post_modeset(struct drm_device *dev, int crtc)
1037{
1038 unsigned long irqflags;
1039
Huacai Chenb7ea85a2013-05-21 06:23:43 +00001040 /* vblank is not initialized (IRQ not installed ?), or has been freed */
1041 if (!dev->num_crtcs)
1042 return;
1043
Ville Syrjälä5380e922013-10-04 14:53:36 +03001044 if (dev->vblank[crtc].inmodeset) {
Dave Airlief453ba02008-11-07 14:05:41 -08001045 spin_lock_irqsave(&dev->vbl_lock, irqflags);
Ville Syrjäläba0bf122013-10-04 14:53:33 +03001046 dev->vblank_disable_allowed = true;
Dave Airlief453ba02008-11-07 14:05:41 -08001047 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001048
Ville Syrjälä5380e922013-10-04 14:53:36 +03001049 if (dev->vblank[crtc].inmodeset & 0x2)
Chris Wilsonb3f5e732009-02-19 14:48:22 +00001050 drm_vblank_put(dev, crtc);
1051
Ville Syrjälä5380e922013-10-04 14:53:36 +03001052 dev->vblank[crtc].inmodeset = 0;
Dave Airlief453ba02008-11-07 14:05:41 -08001053 }
1054}
1055EXPORT_SYMBOL(drm_vblank_post_modeset);
1056
1057/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001058 * drm_modeset_ctl - handle vblank event counter changes across mode switch
1059 * @DRM_IOCTL_ARGS: standard ioctl arguments
1060 *
1061 * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
1062 * ioctls around modesetting so that any lost vblank events are accounted for.
1063 *
1064 * Generally the counter will reset across mode sets. If interrupts are
1065 * enabled around this call, we don't have to do anything since the counter
1066 * will have already been incremented.
1067 */
1068int drm_modeset_ctl(struct drm_device *dev, void *data,
1069 struct drm_file *file_priv)
1070{
1071 struct drm_modeset_ctl *modeset = data;
Dave Airlie19227562011-02-24 08:35:06 +10001072 unsigned int crtc;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001073
1074 /* If drm_vblank_init() hasn't been called yet, just no-op */
1075 if (!dev->num_crtcs)
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001076 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001077
Laurent Pinchart29935552012-05-30 00:58:09 +02001078 /* KMS drivers handle this internally */
1079 if (drm_core_check_feature(dev, DRIVER_MODESET))
1080 return 0;
1081
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001082 crtc = modeset->crtc;
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001083 if (crtc >= dev->num_crtcs)
1084 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001085
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001086 switch (modeset->cmd) {
1087 case _DRM_PRE_MODESET:
Dave Airlief453ba02008-11-07 14:05:41 -08001088 drm_vblank_pre_modeset(dev, crtc);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001089 break;
1090 case _DRM_POST_MODESET:
Dave Airlief453ba02008-11-07 14:05:41 -08001091 drm_vblank_post_modeset(dev, crtc);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001092 break;
1093 default:
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001094 return -EINVAL;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001095 }
1096
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001097 return 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001098}
1099
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001100static int drm_queue_vblank_event(struct drm_device *dev, int pipe,
1101 union drm_wait_vblank *vblwait,
1102 struct drm_file *file_priv)
1103{
1104 struct drm_pending_vblank_event *e;
1105 struct timeval now;
1106 unsigned long flags;
1107 unsigned int seq;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001108 int ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001109
1110 e = kzalloc(sizeof *e, GFP_KERNEL);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001111 if (e == NULL) {
1112 ret = -ENOMEM;
1113 goto err_put;
1114 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001115
1116 e->pipe = pipe;
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001117 e->base.pid = current->pid;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001118 e->event.base.type = DRM_EVENT_VBLANK;
1119 e->event.base.length = sizeof e->event;
1120 e->event.user_data = vblwait->request.signal;
1121 e->base.event = &e->event.base;
1122 e->base.file_priv = file_priv;
1123 e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
1124
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001125 spin_lock_irqsave(&dev->event_lock, flags);
1126
1127 if (file_priv->event_space < sizeof e->event) {
Chris Wilsonea5d5522010-12-01 19:41:31 +00001128 ret = -EBUSY;
1129 goto err_unlock;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001130 }
1131
1132 file_priv->event_space -= sizeof e->event;
Mario Kleiner27641c32010-10-23 04:20:23 +02001133 seq = drm_vblank_count_and_time(dev, pipe, &now);
1134
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001135 if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) &&
1136 (seq - vblwait->request.sequence) <= (1 << 23)) {
1137 vblwait->request.sequence = seq + 1;
Jesse Barnes4a921642009-11-10 08:21:25 +00001138 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001139 }
1140
1141 DRM_DEBUG("event on vblank count %d, current %d, crtc %d\n",
1142 vblwait->request.sequence, seq, pipe);
1143
Jesse Barnesb9c2c9a2010-07-01 16:48:09 -07001144 trace_drm_vblank_event_queued(current->pid, pipe,
1145 vblwait->request.sequence);
1146
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001147 e->event.sequence = vblwait->request.sequence;
1148 if ((seq - vblwait->request.sequence) <= (1 << 23)) {
Dan Carpenter6f331622010-12-09 08:35:40 +03001149 drm_vblank_put(dev, pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001150 send_vblank_event(dev, e, seq, &now);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001151 vblwait->reply.sequence = seq;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001152 } else {
Ilija Hadzica6778e92011-10-31 13:11:57 -04001153 /* drm_handle_vblank_events will call drm_vblank_put */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001154 list_add_tail(&e->base.link, &dev->vblank_event_list);
Mario Kleiner000fa7c2010-12-10 16:00:19 +01001155 vblwait->reply.sequence = vblwait->request.sequence;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001156 }
1157
1158 spin_unlock_irqrestore(&dev->event_lock, flags);
1159
1160 return 0;
Chris Wilsonea5d5522010-12-01 19:41:31 +00001161
1162err_unlock:
1163 spin_unlock_irqrestore(&dev->event_lock, flags);
1164 kfree(e);
1165err_put:
Dan Carpenter6f331622010-12-09 08:35:40 +03001166 drm_vblank_put(dev, pipe);
Chris Wilsonea5d5522010-12-01 19:41:31 +00001167 return ret;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001168}
1169
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001170/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 * Wait for VBLANK.
1172 *
1173 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001174 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 * \param cmd command.
1176 * \param data user argument, pointing to a drm_wait_vblank structure.
1177 * \return zero on success or a negative number on failure.
1178 *
Eric Anholt30b23632009-01-27 21:19:41 -08001179 * This function enables the vblank interrupt on the pipe requested, then
1180 * sleeps waiting for the requested sequence number to occur, and drops
1181 * the vblank interrupt refcount afterwards. (vblank irq disable follows that
1182 * after a timeout with no further vblank waits scheduled).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 */
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001184int drm_wait_vblank(struct drm_device *dev, void *data,
1185 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186{
Eric Anholtc153f452007-09-03 12:06:45 +10001187 union drm_wait_vblank *vblwait = data;
Laurent Pinchart4a1b0712012-05-17 13:27:21 +02001188 int ret;
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001189 unsigned int flags, seq, crtc, high_crtc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Thierry Reding03f65092013-01-14 16:05:56 +00001191 if (drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
1192 if ((!drm_dev_to_irq(dev)) || (!dev->irq_enabled))
1193 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
Eric Anholt30b23632009-01-27 21:19:41 -08001195 if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
1196 return -EINVAL;
1197
Eric Anholtc153f452007-09-03 12:06:45 +10001198 if (vblwait->request.type &
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001199 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1200 _DRM_VBLANK_HIGH_CRTC_MASK)) {
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001201 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
Eric Anholtc153f452007-09-03 12:06:45 +10001202 vblwait->request.type,
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001203 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
1204 _DRM_VBLANK_HIGH_CRTC_MASK));
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001205 return -EINVAL;
1206 }
1207
Eric Anholtc153f452007-09-03 12:06:45 +10001208 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
Ilija Hadzic19b01b52011-03-18 16:58:04 -05001209 high_crtc = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK);
1210 if (high_crtc)
1211 crtc = high_crtc >> _DRM_VBLANK_HIGH_CRTC_SHIFT;
1212 else
1213 crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001214 if (crtc >= dev->num_crtcs)
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001215 return -EINVAL;
1216
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001217 ret = drm_vblank_get(dev, crtc);
1218 if (ret) {
Paul Rolland8d3457e2009-08-09 12:24:01 +10001219 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001220 return ret;
1221 }
1222 seq = drm_vblank_count(dev, crtc);
=?utf-8?q?Michel_D=C3=A4nzer?=776c9442006-10-24 22:24:38 +10001223
Eric Anholtc153f452007-09-03 12:06:45 +10001224 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 case _DRM_VBLANK_RELATIVE:
Eric Anholtc153f452007-09-03 12:06:45 +10001226 vblwait->request.sequence += seq;
1227 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 case _DRM_VBLANK_ABSOLUTE:
1229 break;
1230 default:
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001231 ret = -EINVAL;
1232 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 }
1234
Ilija Hadzica6778e92011-10-31 13:11:57 -04001235 if (flags & _DRM_VBLANK_EVENT) {
1236 /* must hold on to the vblank ref until the event fires
1237 * drm_vblank_put will be called asynchronously
1238 */
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001239 return drm_queue_vblank_event(dev, crtc, vblwait, file_priv);
Ilija Hadzica6778e92011-10-31 13:11:57 -04001240 }
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001241
=?utf-8?q?Michel_D=C3=A4nzer?=ab285d72006-10-24 23:34:18 +10001242 if ((flags & _DRM_VBLANK_NEXTONMISS) &&
Eric Anholtc153f452007-09-03 12:06:45 +10001243 (seq - vblwait->request.sequence) <= (1<<23)) {
1244 vblwait->request.sequence = seq + 1;
=?utf-8?q?Michel_D=C3=A4nzer?=ab285d72006-10-24 23:34:18 +10001245 }
1246
Eric Anholt30b23632009-01-27 21:19:41 -08001247 DRM_DEBUG("waiting on vblank count %d, crtc %d\n",
1248 vblwait->request.sequence, crtc);
Ville Syrjälä5380e922013-10-04 14:53:36 +03001249 dev->vblank[crtc].last_wait = vblwait->request.sequence;
1250 DRM_WAIT_ON(ret, dev->vblank[crtc].queue, 3 * DRM_HZ,
Eric Anholt30b23632009-01-27 21:19:41 -08001251 (((drm_vblank_count(dev, crtc) -
1252 vblwait->request.sequence) <= (1 << 23)) ||
1253 !dev->irq_enabled));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Eric Anholt30b23632009-01-27 21:19:41 -08001255 if (ret != -EINTR) {
1256 struct timeval now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Mario Kleiner27641c32010-10-23 04:20:23 +02001258 vblwait->reply.sequence = drm_vblank_count_and_time(dev, crtc, &now);
Eric Anholt30b23632009-01-27 21:19:41 -08001259 vblwait->reply.tval_sec = now.tv_sec;
1260 vblwait->reply.tval_usec = now.tv_usec;
Mario Kleiner27641c32010-10-23 04:20:23 +02001261
Eric Anholt30b23632009-01-27 21:19:41 -08001262 DRM_DEBUG("returning %d to client\n",
1263 vblwait->reply.sequence);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 } else {
Eric Anholt30b23632009-01-27 21:19:41 -08001265 DRM_DEBUG("vblank wait interrupted by signal\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 }
1267
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001268done:
1269 drm_vblank_put(dev, crtc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 return ret;
1271}
1272
Sachin Kamatea7f7ab2012-08-01 17:15:31 +05301273static void drm_handle_vblank_events(struct drm_device *dev, int crtc)
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001274{
1275 struct drm_pending_vblank_event *e, *t;
1276 struct timeval now;
1277 unsigned long flags;
1278 unsigned int seq;
1279
Mario Kleiner27641c32010-10-23 04:20:23 +02001280 seq = drm_vblank_count_and_time(dev, crtc, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001281
1282 spin_lock_irqsave(&dev->event_lock, flags);
1283
1284 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1285 if (e->pipe != crtc)
1286 continue;
1287 if ((seq - e->event.sequence) > (1<<23))
1288 continue;
1289
1290 DRM_DEBUG("vblank event on %d, current %d\n",
1291 e->event.sequence, seq);
1292
Rob Clarkc6eefa12012-10-16 22:48:40 +00001293 list_del(&e->base.link);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001294 drm_vblank_put(dev, e->pipe);
Rob Clarkc6eefa12012-10-16 22:48:40 +00001295 send_vblank_event(dev, e, seq, &now);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001296 }
1297
1298 spin_unlock_irqrestore(&dev->event_lock, flags);
Jesse Barnesac2874b2010-07-01 16:47:31 -07001299
1300 trace_drm_vblank_event(crtc, seq);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001301}
1302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303/**
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001304 * drm_handle_vblank - handle a vblank event
1305 * @dev: DRM device
1306 * @crtc: where this event occurred
1307 *
1308 * Drivers should call this routine in their vblank interrupt handlers to
1309 * update the vblank counter and send any signals that may be pending.
1310 */
Chris Wilson78c6e172011-01-31 10:48:04 +00001311bool drm_handle_vblank(struct drm_device *dev, int crtc)
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001312{
Mario Kleiner27641c32010-10-23 04:20:23 +02001313 u32 vblcount;
1314 s64 diff_ns;
1315 struct timeval tvblank;
1316 unsigned long irqflags;
1317
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001318 if (!dev->num_crtcs)
Chris Wilson78c6e172011-01-31 10:48:04 +00001319 return false;
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001320
Mario Kleiner27641c32010-10-23 04:20:23 +02001321 /* Need timestamp lock to prevent concurrent execution with
1322 * vblank enable/disable, as this would cause inconsistent
1323 * or corrupted timestamps and vblank counts.
1324 */
1325 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
1326
1327 /* Vblank irq handling disabled. Nothing to do. */
Ville Syrjälä5380e922013-10-04 14:53:36 +03001328 if (!dev->vblank[crtc].enabled) {
Mario Kleiner27641c32010-10-23 04:20:23 +02001329 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
Chris Wilson78c6e172011-01-31 10:48:04 +00001330 return false;
Mario Kleiner27641c32010-10-23 04:20:23 +02001331 }
1332
1333 /* Fetch corresponding timestamp for this vblank interval from
1334 * driver and store it in proper slot of timestamp ringbuffer.
1335 */
1336
1337 /* Get current timestamp and count. */
Ville Syrjälä5380e922013-10-04 14:53:36 +03001338 vblcount = atomic_read(&dev->vblank[crtc].count);
Mario Kleiner27641c32010-10-23 04:20:23 +02001339 drm_get_last_vbltimestamp(dev, crtc, &tvblank, DRM_CALLED_FROM_VBLIRQ);
1340
1341 /* Compute time difference to timestamp of last vblank */
1342 diff_ns = timeval_to_ns(&tvblank) -
1343 timeval_to_ns(&vblanktimestamp(dev, crtc, vblcount));
1344
1345 /* Update vblank timestamp and count if at least
1346 * DRM_REDUNDANT_VBLIRQ_THRESH_NS nanoseconds
1347 * difference between last stored timestamp and current
1348 * timestamp. A smaller difference means basically
1349 * identical timestamps. Happens if this vblank has
1350 * been already processed and this is a redundant call,
1351 * e.g., due to spurious vblank interrupts. We need to
1352 * ignore those for accounting.
1353 */
Mario Kleinerc4cc3832011-02-21 05:42:00 +01001354 if (abs64(diff_ns) > DRM_REDUNDANT_VBLIRQ_THRESH_NS) {
Mario Kleiner27641c32010-10-23 04:20:23 +02001355 /* Store new timestamp in ringbuffer. */
1356 vblanktimestamp(dev, crtc, vblcount + 1) = tvblank;
Mario Kleiner27641c32010-10-23 04:20:23 +02001357
1358 /* Increment cooked vblank count. This also atomically commits
1359 * the timestamp computed above.
1360 */
Mario Kleinerbc215122011-02-21 05:42:01 +01001361 smp_mb__before_atomic_inc();
Ville Syrjälä5380e922013-10-04 14:53:36 +03001362 atomic_inc(&dev->vblank[crtc].count);
Mario Kleinerbc215122011-02-21 05:42:01 +01001363 smp_mb__after_atomic_inc();
Mario Kleiner27641c32010-10-23 04:20:23 +02001364 } else {
1365 DRM_DEBUG("crtc %d: Redundant vblirq ignored. diff_ns = %d\n",
1366 crtc, (int) diff_ns);
1367 }
1368
Ville Syrjälä5380e922013-10-04 14:53:36 +03001369 DRM_WAKEUP(&dev->vblank[crtc].queue);
Kristian Høgsbergc9a9c5e2009-09-12 04:33:34 +10001370 drm_handle_vblank_events(dev, crtc);
Mario Kleiner27641c32010-10-23 04:20:23 +02001371
1372 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
Chris Wilson78c6e172011-01-31 10:48:04 +00001373 return true;
Jesse Barnes0a3e67a2008-09-30 12:14:26 -07001374}
1375EXPORT_SYMBOL(drm_handle_vblank);