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 "drmP.h"
37
38 #include <linux/interrupt.h> /* For task queue support */
39
40 /**
41 * Get interrupt from bus id.
42 *
43 * \param inode device inode.
44 * \param file_priv DRM file private.
45 * \param cmd command.
46 * \param arg user argument, pointing to a drm_irq_busid structure.
47 * \return zero on success or a negative number on failure.
48 *
49 * Finds the PCI device with the specified bus id and gets its IRQ number.
50 * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
51 * to that of the device that this DRM instance attached to.
52 */
53 int drm_irq_by_busid(struct drm_device *dev, void *data,
54 struct drm_file *file_priv)
55 {
56 struct drm_irq_busid *p = data;
57
58 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
59 return -EINVAL;
60
61 if ((p->busnum >> 8) != drm_get_pci_domain(dev) ||
62 (p->busnum & 0xff) != dev->pdev->bus->number ||
63 p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn))
64 return -EINVAL;
65
66 p->irq = dev->pdev->irq;
67
68 DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
69 p->irq);
70
71 return 0;
72 }
73
74 static void vblank_disable_fn(unsigned long arg)
75 {
76 struct drm_device *dev = (struct drm_device *)arg;
77 unsigned long irqflags;
78 int i;
79
80 if (!dev->vblank_disable_allowed)
81 return;
82
83 for (i = 0; i < dev->num_crtcs; i++) {
84 spin_lock_irqsave(&dev->vbl_lock, irqflags);
85 if (atomic_read(&dev->vblank_refcount[i]) == 0 &&
86 dev->vblank_enabled[i]) {
87 DRM_DEBUG("disabling vblank on crtc %d\n", i);
88 dev->last_vblank[i] =
89 dev->driver->get_vblank_counter(dev, i);
90 dev->driver->disable_vblank(dev, i);
91 dev->vblank_enabled[i] = 0;
92 }
93 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
94 }
95 }
96
97 void drm_vblank_cleanup(struct drm_device *dev)
98 {
99 /* Bail if the driver didn't call drm_vblank_init() */
100 if (dev->num_crtcs == 0)
101 return;
102
103 del_timer(&dev->vblank_disable_timer);
104
105 vblank_disable_fn((unsigned long)dev);
106
107 kfree(dev->vbl_queue);
108 kfree(dev->_vblank_count);
109 kfree(dev->vblank_refcount);
110 kfree(dev->vblank_enabled);
111 kfree(dev->last_vblank);
112 kfree(dev->last_vblank_wait);
113 kfree(dev->vblank_inmodeset);
114
115 dev->num_crtcs = 0;
116 }
117
118 int drm_vblank_init(struct drm_device *dev, int num_crtcs)
119 {
120 int i, ret = -ENOMEM;
121
122 setup_timer(&dev->vblank_disable_timer, vblank_disable_fn,
123 (unsigned long)dev);
124 spin_lock_init(&dev->vbl_lock);
125 dev->num_crtcs = num_crtcs;
126
127 dev->vbl_queue = kmalloc(sizeof(wait_queue_head_t) * num_crtcs,
128 GFP_KERNEL);
129 if (!dev->vbl_queue)
130 goto err;
131
132 dev->_vblank_count = kmalloc(sizeof(atomic_t) * num_crtcs, GFP_KERNEL);
133 if (!dev->_vblank_count)
134 goto err;
135
136 dev->vblank_refcount = kmalloc(sizeof(atomic_t) * num_crtcs,
137 GFP_KERNEL);
138 if (!dev->vblank_refcount)
139 goto err;
140
141 dev->vblank_enabled = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
142 if (!dev->vblank_enabled)
143 goto err;
144
145 dev->last_vblank = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
146 if (!dev->last_vblank)
147 goto err;
148
149 dev->last_vblank_wait = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
150 if (!dev->last_vblank_wait)
151 goto err;
152
153 dev->vblank_inmodeset = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
154 if (!dev->vblank_inmodeset)
155 goto err;
156
157 /* Zero per-crtc vblank stuff */
158 for (i = 0; i < num_crtcs; i++) {
159 init_waitqueue_head(&dev->vbl_queue[i]);
160 atomic_set(&dev->_vblank_count[i], 0);
161 atomic_set(&dev->vblank_refcount[i], 0);
162 }
163
164 dev->vblank_disable_allowed = 0;
165
166 return 0;
167
168 err:
169 drm_vblank_cleanup(dev);
170 return ret;
171 }
172 EXPORT_SYMBOL(drm_vblank_init);
173
174 /**
175 * Install IRQ handler.
176 *
177 * \param dev DRM device.
178 *
179 * Initializes the IRQ related data. Installs the handler, calling the driver
180 * \c drm_driver_irq_preinstall() and \c drm_driver_irq_postinstall() functions
181 * before and after the installation.
182 */
183 int drm_irq_install(struct drm_device *dev)
184 {
185 int ret = 0;
186 unsigned long sh_flags = 0;
187 char *irqname;
188
189 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
190 return -EINVAL;
191
192 if (dev->pdev->irq == 0)
193 return -EINVAL;
194
195 mutex_lock(&dev->struct_mutex);
196
197 /* Driver must have been initialized */
198 if (!dev->dev_private) {
199 mutex_unlock(&dev->struct_mutex);
200 return -EINVAL;
201 }
202
203 if (dev->irq_enabled) {
204 mutex_unlock(&dev->struct_mutex);
205 return -EBUSY;
206 }
207 dev->irq_enabled = 1;
208 mutex_unlock(&dev->struct_mutex);
209
210 DRM_DEBUG("irq=%d\n", dev->pdev->irq);
211
212 /* Before installing handler */
213 dev->driver->irq_preinstall(dev);
214
215 /* Install handler */
216 if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
217 sh_flags = IRQF_SHARED;
218
219 if (dev->devname)
220 irqname = dev->devname;
221 else
222 irqname = dev->driver->name;
223
224 ret = request_irq(drm_dev_to_irq(dev), dev->driver->irq_handler,
225 sh_flags, irqname, dev);
226
227 if (ret < 0) {
228 mutex_lock(&dev->struct_mutex);
229 dev->irq_enabled = 0;
230 mutex_unlock(&dev->struct_mutex);
231 return ret;
232 }
233
234 /* After installing handler */
235 ret = dev->driver->irq_postinstall(dev);
236 if (ret < 0) {
237 mutex_lock(&dev->struct_mutex);
238 dev->irq_enabled = 0;
239 mutex_unlock(&dev->struct_mutex);
240 }
241
242 return ret;
243 }
244 EXPORT_SYMBOL(drm_irq_install);
245
246 /**
247 * Uninstall the IRQ handler.
248 *
249 * \param dev DRM device.
250 *
251 * Calls the driver's \c drm_driver_irq_uninstall() function, and stops the irq.
252 */
253 int drm_irq_uninstall(struct drm_device * dev)
254 {
255 unsigned long irqflags;
256 int irq_enabled, i;
257
258 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
259 return -EINVAL;
260
261 mutex_lock(&dev->struct_mutex);
262 irq_enabled = dev->irq_enabled;
263 dev->irq_enabled = 0;
264 mutex_unlock(&dev->struct_mutex);
265
266 /*
267 * Wake up any waiters so they don't hang.
268 */
269 spin_lock_irqsave(&dev->vbl_lock, irqflags);
270 for (i = 0; i < dev->num_crtcs; i++) {
271 DRM_WAKEUP(&dev->vbl_queue[i]);
272 dev->vblank_enabled[i] = 0;
273 dev->last_vblank[i] = dev->driver->get_vblank_counter(dev, i);
274 }
275 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
276
277 if (!irq_enabled)
278 return -EINVAL;
279
280 DRM_DEBUG("irq=%d\n", dev->pdev->irq);
281
282 dev->driver->irq_uninstall(dev);
283
284 free_irq(dev->pdev->irq, dev);
285
286 return 0;
287 }
288 EXPORT_SYMBOL(drm_irq_uninstall);
289
290 /**
291 * IRQ control ioctl.
292 *
293 * \param inode device inode.
294 * \param file_priv DRM file private.
295 * \param cmd command.
296 * \param arg user argument, pointing to a drm_control structure.
297 * \return zero on success or a negative number on failure.
298 *
299 * Calls irq_install() or irq_uninstall() according to \p arg.
300 */
301 int drm_control(struct drm_device *dev, void *data,
302 struct drm_file *file_priv)
303 {
304 struct drm_control *ctl = data;
305
306 /* if we haven't irq we fallback for compatibility reasons - this used to be a separate function in drm_dma.h */
307
308
309 switch (ctl->func) {
310 case DRM_INST_HANDLER:
311 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
312 return 0;
313 if (drm_core_check_feature(dev, DRIVER_MODESET))
314 return 0;
315 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
316 ctl->irq != dev->pdev->irq)
317 return -EINVAL;
318 return drm_irq_install(dev);
319 case DRM_UNINST_HANDLER:
320 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
321 return 0;
322 if (drm_core_check_feature(dev, DRIVER_MODESET))
323 return 0;
324 return drm_irq_uninstall(dev);
325 default:
326 return -EINVAL;
327 }
328 }
329
330 /**
331 * drm_vblank_count - retrieve "cooked" vblank counter value
332 * @dev: DRM device
333 * @crtc: which counter to retrieve
334 *
335 * Fetches the "cooked" vblank count value that represents the number of
336 * vblank events since the system was booted, including lost events due to
337 * modesetting activity.
338 */
339 u32 drm_vblank_count(struct drm_device *dev, int crtc)
340 {
341 return atomic_read(&dev->_vblank_count[crtc]);
342 }
343 EXPORT_SYMBOL(drm_vblank_count);
344
345 /**
346 * drm_update_vblank_count - update the master vblank counter
347 * @dev: DRM device
348 * @crtc: counter to update
349 *
350 * Call back into the driver to update the appropriate vblank counter
351 * (specified by @crtc). Deal with wraparound, if it occurred, and
352 * update the last read value so we can deal with wraparound on the next
353 * call if necessary.
354 *
355 * Only necessary when going from off->on, to account for frames we
356 * didn't get an interrupt for.
357 *
358 * Note: caller must hold dev->vbl_lock since this reads & writes
359 * device vblank fields.
360 */
361 static void drm_update_vblank_count(struct drm_device *dev, int crtc)
362 {
363 u32 cur_vblank, diff;
364
365 /*
366 * Interrupts were disabled prior to this call, so deal with counter
367 * wrap if needed.
368 * NOTE! It's possible we lost a full dev->max_vblank_count events
369 * here if the register is small or we had vblank interrupts off for
370 * a long time.
371 */
372 cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
373 diff = cur_vblank - dev->last_vblank[crtc];
374 if (cur_vblank < dev->last_vblank[crtc]) {
375 diff += dev->max_vblank_count;
376
377 DRM_DEBUG("last_vblank[%d]=0x%x, cur_vblank=0x%x => diff=0x%x\n",
378 crtc, dev->last_vblank[crtc], cur_vblank, diff);
379 }
380
381 DRM_DEBUG("enabling vblank interrupts on crtc %d, missed %d\n",
382 crtc, diff);
383
384 atomic_add(diff, &dev->_vblank_count[crtc]);
385 }
386
387 /**
388 * drm_vblank_get - get a reference count on vblank events
389 * @dev: DRM device
390 * @crtc: which CRTC to own
391 *
392 * Acquire a reference count on vblank events to avoid having them disabled
393 * while in use.
394 *
395 * RETURNS
396 * Zero on success, nonzero on failure.
397 */
398 int drm_vblank_get(struct drm_device *dev, int crtc)
399 {
400 unsigned long irqflags;
401 int ret = 0;
402
403 spin_lock_irqsave(&dev->vbl_lock, irqflags);
404 /* Going from 0->1 means we have to enable interrupts again */
405 if (atomic_add_return(1, &dev->vblank_refcount[crtc]) == 1) {
406 if (!dev->vblank_enabled[crtc]) {
407 ret = dev->driver->enable_vblank(dev, crtc);
408 DRM_DEBUG("enabling vblank on crtc %d, ret: %d\n", crtc, ret);
409 if (ret)
410 atomic_dec(&dev->vblank_refcount[crtc]);
411 else {
412 dev->vblank_enabled[crtc] = 1;
413 drm_update_vblank_count(dev, crtc);
414 }
415 }
416 } else {
417 if (!dev->vblank_enabled[crtc]) {
418 atomic_dec(&dev->vblank_refcount[crtc]);
419 ret = -EINVAL;
420 }
421 }
422 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
423
424 return ret;
425 }
426 EXPORT_SYMBOL(drm_vblank_get);
427
428 /**
429 * drm_vblank_put - give up ownership of vblank events
430 * @dev: DRM device
431 * @crtc: which counter to give up
432 *
433 * Release ownership of a given vblank counter, turning off interrupts
434 * if possible.
435 */
436 void drm_vblank_put(struct drm_device *dev, int crtc)
437 {
438 BUG_ON (atomic_read (&dev->vblank_refcount[crtc]) == 0);
439
440 /* Last user schedules interrupt disable */
441 if (atomic_dec_and_test(&dev->vblank_refcount[crtc]))
442 mod_timer(&dev->vblank_disable_timer, jiffies + 5*DRM_HZ);
443 }
444 EXPORT_SYMBOL(drm_vblank_put);
445
446 void drm_vblank_off(struct drm_device *dev, int crtc)
447 {
448 unsigned long irqflags;
449
450 spin_lock_irqsave(&dev->vbl_lock, irqflags);
451 DRM_WAKEUP(&dev->vbl_queue[crtc]);
452 dev->vblank_enabled[crtc] = 0;
453 dev->last_vblank[crtc] = dev->driver->get_vblank_counter(dev, crtc);
454 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
455 }
456 EXPORT_SYMBOL(drm_vblank_off);
457
458 /**
459 * drm_vblank_pre_modeset - account for vblanks across mode sets
460 * @dev: DRM device
461 * @crtc: CRTC in question
462 * @post: post or pre mode set?
463 *
464 * Account for vblank events across mode setting events, which will likely
465 * reset the hardware frame counter.
466 */
467 void drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
468 {
469 /*
470 * To avoid all the problems that might happen if interrupts
471 * were enabled/disabled around or between these calls, we just
472 * have the kernel take a reference on the CRTC (just once though
473 * to avoid corrupting the count if multiple, mismatch calls occur),
474 * so that interrupts remain enabled in the interim.
475 */
476 if (!dev->vblank_inmodeset[crtc]) {
477 dev->vblank_inmodeset[crtc] = 0x1;
478 if (drm_vblank_get(dev, crtc) == 0)
479 dev->vblank_inmodeset[crtc] |= 0x2;
480 }
481 }
482 EXPORT_SYMBOL(drm_vblank_pre_modeset);
483
484 void drm_vblank_post_modeset(struct drm_device *dev, int crtc)
485 {
486 unsigned long irqflags;
487
488 if (dev->vblank_inmodeset[crtc]) {
489 spin_lock_irqsave(&dev->vbl_lock, irqflags);
490 dev->vblank_disable_allowed = 1;
491 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
492
493 if (dev->vblank_inmodeset[crtc] & 0x2)
494 drm_vblank_put(dev, crtc);
495
496 dev->vblank_inmodeset[crtc] = 0;
497 }
498 }
499 EXPORT_SYMBOL(drm_vblank_post_modeset);
500
501 /**
502 * drm_modeset_ctl - handle vblank event counter changes across mode switch
503 * @DRM_IOCTL_ARGS: standard ioctl arguments
504 *
505 * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
506 * ioctls around modesetting so that any lost vblank events are accounted for.
507 *
508 * Generally the counter will reset across mode sets. If interrupts are
509 * enabled around this call, we don't have to do anything since the counter
510 * will have already been incremented.
511 */
512 int drm_modeset_ctl(struct drm_device *dev, void *data,
513 struct drm_file *file_priv)
514 {
515 struct drm_modeset_ctl *modeset = data;
516 int crtc, ret = 0;
517
518 /* If drm_vblank_init() hasn't been called yet, just no-op */
519 if (!dev->num_crtcs)
520 goto out;
521
522 crtc = modeset->crtc;
523 if (crtc >= dev->num_crtcs) {
524 ret = -EINVAL;
525 goto out;
526 }
527
528 switch (modeset->cmd) {
529 case _DRM_PRE_MODESET:
530 drm_vblank_pre_modeset(dev, crtc);
531 break;
532 case _DRM_POST_MODESET:
533 drm_vblank_post_modeset(dev, crtc);
534 break;
535 default:
536 ret = -EINVAL;
537 break;
538 }
539
540 out:
541 return ret;
542 }
543
544 /**
545 * Wait for VBLANK.
546 *
547 * \param inode device inode.
548 * \param file_priv DRM file private.
549 * \param cmd command.
550 * \param data user argument, pointing to a drm_wait_vblank structure.
551 * \return zero on success or a negative number on failure.
552 *
553 * This function enables the vblank interrupt on the pipe requested, then
554 * sleeps waiting for the requested sequence number to occur, and drops
555 * the vblank interrupt refcount afterwards. (vblank irq disable follows that
556 * after a timeout with no further vblank waits scheduled).
557 */
558 int drm_wait_vblank(struct drm_device *dev, void *data,
559 struct drm_file *file_priv)
560 {
561 union drm_wait_vblank *vblwait = data;
562 int ret = 0;
563 unsigned int flags, seq, crtc;
564
565 if ((!dev->pdev->irq) || (!dev->irq_enabled))
566 return -EINVAL;
567
568 if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
569 return -EINVAL;
570
571 if (vblwait->request.type &
572 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK)) {
573 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
574 vblwait->request.type,
575 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK));
576 return -EINVAL;
577 }
578
579 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
580 crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
581
582 if (crtc >= dev->num_crtcs)
583 return -EINVAL;
584
585 ret = drm_vblank_get(dev, crtc);
586 if (ret) {
587 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
588 return ret;
589 }
590 seq = drm_vblank_count(dev, crtc);
591
592 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
593 case _DRM_VBLANK_RELATIVE:
594 vblwait->request.sequence += seq;
595 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
596 case _DRM_VBLANK_ABSOLUTE:
597 break;
598 default:
599 ret = -EINVAL;
600 goto done;
601 }
602
603 if ((flags & _DRM_VBLANK_NEXTONMISS) &&
604 (seq - vblwait->request.sequence) <= (1<<23)) {
605 vblwait->request.sequence = seq + 1;
606 }
607
608 DRM_DEBUG("waiting on vblank count %d, crtc %d\n",
609 vblwait->request.sequence, crtc);
610 dev->last_vblank_wait[crtc] = vblwait->request.sequence;
611 DRM_WAIT_ON(ret, dev->vbl_queue[crtc], 3 * DRM_HZ,
612 (((drm_vblank_count(dev, crtc) -
613 vblwait->request.sequence) <= (1 << 23)) ||
614 !dev->irq_enabled));
615
616 if (ret != -EINTR) {
617 struct timeval now;
618
619 do_gettimeofday(&now);
620
621 vblwait->reply.tval_sec = now.tv_sec;
622 vblwait->reply.tval_usec = now.tv_usec;
623 vblwait->reply.sequence = drm_vblank_count(dev, crtc);
624 DRM_DEBUG("returning %d to client\n",
625 vblwait->reply.sequence);
626 } else {
627 DRM_DEBUG("vblank wait interrupted by signal\n");
628 }
629
630 done:
631 drm_vblank_put(dev, crtc);
632 return ret;
633 }
634
635 /**
636 * drm_handle_vblank - handle a vblank event
637 * @dev: DRM device
638 * @crtc: where this event occurred
639 *
640 * Drivers should call this routine in their vblank interrupt handlers to
641 * update the vblank counter and send any signals that may be pending.
642 */
643 void drm_handle_vblank(struct drm_device *dev, int crtc)
644 {
645 atomic_inc(&dev->_vblank_count[crtc]);
646 DRM_WAKEUP(&dev->vbl_queue[crtc]);
647 }
648 EXPORT_SYMBOL(drm_handle_vblank);
649
|
This page was automatically generated by the
LXR engine.
|