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