1 /*-
2 * Copyright 2003 Eric Anholt
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * ERIC ANHOLT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
20 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * Eric Anholt <anholt@FreeBSD.org>
25 *
26 */
27
28 /** @file drm_irq.c
29 * Support code for handling setup/teardown of interrupt handlers and
30 * handing interrupt handlers off to the drivers.
31 */
32
33 #include "drmP.h"
34 #include "drm.h"
35
drm_irq_by_busid(struct drm_device * dev,void * data,struct drm_file * file_priv)36 int drm_irq_by_busid(struct drm_device *dev, void *data,
37 struct drm_file *file_priv)
38 {
39 struct drm_irq_busid *irq = data;
40
41 if ((irq->busnum >> 8) != dev->pci_domain ||
42 (irq->busnum & 0xff) != dev->pci_bus ||
43 irq->devnum != dev->pci_slot ||
44 irq->funcnum != dev->pci_func)
45 return EINVAL;
46
47 irq->irq = dev->irq;
48
49 DRM_DEBUG("%d:%d:%d => IRQ %d\n",
50 irq->busnum, irq->devnum, irq->funcnum, irq->irq);
51
52 return 0;
53 }
54
55 #if defined(__FreeBSD__)
56 static irqreturn_t
drm_irq_handler_wrap(DRM_IRQ_ARGS)57 drm_irq_handler_wrap(DRM_IRQ_ARGS)
58 {
59 struct drm_device *dev = arg;
60
61 DRM_SPINLOCK(&dev->irq_lock);
62 dev->driver->irq_handler(arg);
63 DRM_SPINUNLOCK(&dev->irq_lock);
64 }
65 #elif defined(__NetBSD__)
66 static irqreturn_t
drm_irq_handler_wrap(DRM_IRQ_ARGS)67 drm_irq_handler_wrap(DRM_IRQ_ARGS)
68 {
69 irqreturn_t ret;
70 struct drm_device *dev = arg;
71
72 DRM_SPINLOCK(&dev->irq_lock);
73 ret = dev->driver->irq_handler(arg);
74 DRM_SPINUNLOCK(&dev->irq_lock);
75 return ret;
76 }
77 #endif
78
vblank_disable_fn(void * arg)79 static void vblank_disable_fn(void *arg)
80 {
81 struct drm_device *dev = (struct drm_device *)arg;
82 unsigned int i;
83
84 #if defined(__NetBSD__)
85 mutex_enter(&dev->vbl_lock);
86 #endif
87 if (callout_pending(&dev->vblank_disable_timer)) {
88 /* callout was reset */
89 #if defined(__NetBSD__)
90 mutex_exit(&dev->vbl_lock);
91 #endif
92 return;
93 }
94 if (!callout_active(&dev->vblank_disable_timer)) {
95 /* callout was stopped */
96 #if defined(__NetBSD__)
97 mutex_exit(&dev->vbl_lock);
98 #endif
99 return;
100 }
101 callout_deactivate(&dev->vblank_disable_timer);
102
103 DRM_DEBUG("vblank_disable_allowed=%d\n", dev->vblank_disable_allowed);
104 if (!dev->vblank_disable_allowed) {
105 #if defined(__NetBSD__)
106 mutex_exit(&dev->vbl_lock);
107 #endif
108 return;
109 }
110
111 for (i = 0; i < dev->num_crtcs; i++) {
112 if (atomic_read(&dev->vblank[i].refcount) == 0 &&
113 dev->vblank[i].enabled) {
114 DRM_DEBUG("disabling vblank on crtc %d\n", i);
115 dev->vblank[i].last =
116 dev->driver->get_vblank_counter(dev, i);
117 dev->driver->disable_vblank(dev, i);
118 dev->vblank[i].enabled = 0;
119 }
120 }
121 #if defined(__NetBSD__)
122 mutex_exit(&dev->vbl_lock);
123 #endif
124 }
125
drm_vblank_cleanup(struct drm_device * dev)126 void drm_vblank_cleanup(struct drm_device *dev)
127 {
128 unsigned long irqflags;
129
130 /* Bail if the driver didn't call drm_vblank_init() */
131 if (dev->num_crtcs == 0)
132 return;
133
134 DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
135 callout_stop(&dev->vblank_disable_timer);
136 DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
137
138 callout_drain(&dev->vblank_disable_timer);
139
140 vblank_disable_fn((void *)dev);
141
142 free(dev->vblank, DRM_MEM_DRIVER);
143
144 dev->num_crtcs = 0;
145 }
146
drm_vblank_init(struct drm_device * dev,int num_crtcs)147 int drm_vblank_init(struct drm_device *dev, int num_crtcs)
148 {
149 int i, ret = ENOMEM;
150
151 #if defined(__FreeBSD__)
152 callout_init_mtx(&dev->vblank_disable_timer, &dev->vbl_lock, 0);
153 #else
154 callout_init(&dev->vblank_disable_timer, 0);
155 #endif
156 atomic_set(&dev->vbl_signal_pending, 0);
157 dev->num_crtcs = num_crtcs;
158
159 dev->vblank = malloc(sizeof(struct drm_vblank_info) * num_crtcs,
160 DRM_MEM_DRIVER, M_NOWAIT | M_ZERO);
161 if (!dev->vblank)
162 goto err;
163
164 DRM_DEBUG("\n");
165
166 /* Zero per-crtc vblank stuff */
167 for (i = 0; i < num_crtcs; i++) {
168 DRM_INIT_WAITQUEUE(&dev->vblank[i].queue);
169 TAILQ_INIT(&dev->vblank[i].sigs);
170 atomic_set(&dev->vblank[i].count, 0);
171 atomic_set(&dev->vblank[i].refcount, 0);
172 }
173
174 dev->vblank_disable_allowed = 0;
175
176 return 0;
177
178 err:
179 drm_vblank_cleanup(dev);
180 return ret;
181 }
182
drm_irq_install(struct drm_device * dev)183 int drm_irq_install(struct drm_device *dev)
184 {
185 int retcode;
186 #ifdef __NetBSD__
187 pci_intr_handle_t ih;
188 const char *istr;
189 char intrbuf[PCI_INTRSTR_LEN];
190 #endif
191
192 if (dev->irq == 0 || dev->dev_private == NULL)
193 return EINVAL;
194
195 DRM_DEBUG("irq=%d\n", dev->irq);
196
197 DRM_LOCK();
198 if (dev->irq_enabled) {
199 DRM_UNLOCK();
200 return EBUSY;
201 }
202 dev->irq_enabled = 1;
203
204 dev->context_flag = 0;
205
206 /* Before installing handler */
207 dev->driver->irq_preinstall(dev);
208 DRM_UNLOCK();
209
210 /* Install handler */
211 #if defined(__FreeBSD__)
212 #if __FreeBSD_version >= 700031
213 retcode = bus_setup_intr(dev->device, dev->irqr,
214 INTR_TYPE_TTY | INTR_MPSAFE,
215 NULL, drm_irq_handler_wrap, dev, &dev->irqh);
216 #else
217 retcode = bus_setup_intr(dev->device, dev->irqr,
218 INTR_TYPE_TTY | INTR_MPSAFE,
219 drm_irq_handler_wrap, dev, &dev->irqh);
220 #endif
221 if (retcode != 0)
222 goto err;
223 #elif defined(__NetBSD__)
224 if (pci_intr_map(&dev->pa, &ih) != 0) {
225 retcode = ENOENT;
226 goto err;
227 }
228 istr = pci_intr_string(dev->pa.pa_pc, ih, intrbuf, sizeof(intrbuf));
229 dev->irqh = pci_intr_establish(dev->pa.pa_pc, ih, IPL_TTY,
230 drm_irq_handler_wrap, dev);
231 if (!dev->irqh) {
232 aprint_error_dev(dev->device,
233 "couldn't establish interrupt at %s\n", istr);
234 retcode = ENOENT;
235 goto err;
236 }
237 aprint_normal_dev(dev->device, "interrupting at %s\n", istr);
238 #endif
239
240 /* After installing handler */
241 DRM_LOCK();
242 dev->driver->irq_postinstall(dev);
243 DRM_UNLOCK();
244
245 return 0;
246 err:
247 DRM_LOCK();
248 dev->irq_enabled = 0;
249 DRM_UNLOCK();
250
251 return retcode;
252 }
253
drm_irq_uninstall(struct drm_device * dev)254 int drm_irq_uninstall(struct drm_device *dev)
255 {
256 if (!dev->irq_enabled)
257 return EINVAL;
258
259 dev->irq_enabled = 0;
260
261 DRM_DEBUG("irq=%d\n", dev->irq);
262
263 dev->driver->irq_uninstall(dev);
264
265 #if defined(__FreeBSD__)
266 DRM_UNLOCK();
267 bus_teardown_intr(dev->device, dev->irqr, dev->irqh);
268 DRM_LOCK();
269 #elif defined(__NetBSD__)
270 pci_intr_disestablish(dev->pa.pa_pc, dev->irqh);
271 #endif
272
273 return 0;
274 }
275
drm_control(struct drm_device * dev,void * data,struct drm_file * file_priv)276 int drm_control(struct drm_device *dev, void *data, struct drm_file *file_priv)
277 {
278 struct drm_control *ctl = data;
279 int err;
280
281 switch (ctl->func) {
282 case DRM_INST_HANDLER:
283 /* Handle drivers whose DRM used to require IRQ setup but the
284 * no longer does.
285 */
286 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
287 return 0;
288 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
289 ctl->irq != dev->irq)
290 return EINVAL;
291 return drm_irq_install(dev);
292 case DRM_UNINST_HANDLER:
293 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
294 return 0;
295 DRM_LOCK();
296 err = drm_irq_uninstall(dev);
297 DRM_UNLOCK();
298 return err;
299 default:
300 return EINVAL;
301 }
302 }
303
drm_vblank_count(struct drm_device * dev,unsigned int crtc)304 u32 drm_vblank_count(struct drm_device *dev, unsigned int crtc)
305 {
306 return atomic_read(&dev->vblank[crtc].count);
307 }
308
drm_update_vblank_count(struct drm_device * dev,unsigned int crtc)309 static void drm_update_vblank_count(struct drm_device *dev, unsigned int crtc)
310 {
311 u32 cur_vblank, diff;
312
313 /*
314 * Interrupts were disabled prior to this call, so deal with counter
315 * wrap if needed.
316 * NOTE! It's possible we lost a full dev->max_vblank_count events
317 * here if the register is small or we had vblank interrupts off for
318 * a long time.
319 */
320 cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
321 diff = cur_vblank - dev->vblank[crtc].last;
322 if (cur_vblank < dev->vblank[crtc].last) {
323 diff += dev->max_vblank_count;
324
325 DRM_DEBUG("vblank[%d].last=0x%x, cur_vblank=0x%x => diff=0x%x\n",
326 crtc, dev->vblank[crtc].last, cur_vblank, diff);
327 }
328
329 DRM_DEBUG("enabling vblank interrupts on crtc %d, missed %d\n",
330 crtc, diff);
331
332 atomic_add(diff, &dev->vblank[crtc].count);
333 }
334
drm_vblank_get(struct drm_device * dev,unsigned int crtc)335 int drm_vblank_get(struct drm_device *dev, unsigned int crtc)
336 {
337 unsigned long irqflags;
338 int ret = 0;
339
340 DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
341 /* Going from 0->1 means we have to enable interrupts again */
342 atomic_add_acq_int(&dev->vblank[crtc].refcount, 1);
343 DRM_DEBUG("vblank refcount = %d\n", dev->vblank[crtc].refcount);
344 if (dev->vblank[crtc].refcount == 1 &&
345 !dev->vblank[crtc].enabled) {
346 ret = dev->driver->enable_vblank(dev, crtc);
347 if (ret)
348 atomic_dec(&dev->vblank[crtc].refcount);
349 else {
350 dev->vblank[crtc].enabled = 1;
351 drm_update_vblank_count(dev, crtc);
352 }
353 }
354 DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
355
356 return ret;
357 }
358
drm_vblank_put(struct drm_device * dev,unsigned int crtc)359 void drm_vblank_put(struct drm_device *dev, unsigned int crtc)
360 {
361 unsigned long irqflags;
362
363 DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
364 /* Last user schedules interrupt disable */
365 atomic_subtract_acq_int(&dev->vblank[crtc].refcount, 1);
366 DRM_DEBUG("vblank refcount = %d\n", dev->vblank[crtc].refcount);
367 if (dev->vblank[crtc].refcount == 0)
368 callout_reset(&dev->vblank_disable_timer, 5 * DRM_HZ,
369 #if defined(__FreeBSD__)
370 (timeout_t *)
371 #endif
372 vblank_disable_fn, (void *)dev);
373 DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
374 }
375
drm_modeset_ctl(struct drm_device * dev,void * data,struct drm_file * file_priv)376 int drm_modeset_ctl(struct drm_device *dev, void *data,
377 struct drm_file *file_priv)
378 {
379 struct drm_modeset_ctl *modeset = data;
380 unsigned long irqflags;
381 int ret = 0;
382 unsigned int crtc;
383
384 DRM_DEBUG("num_crtcs=%d\n", dev->num_crtcs);
385 /* If drm_vblank_init() hasn't been called yet, just no-op */
386 if (!dev->num_crtcs)
387 goto out;
388
389 crtc = modeset->crtc;
390 DRM_DEBUG("crtc=%d\n", crtc);
391 if (crtc >= dev->num_crtcs) {
392 ret = EINVAL;
393 goto out;
394 }
395
396 /*
397 * To avoid all the problems that might happen if interrupts
398 * were enabled/disabled around or between these calls, we just
399 * have the kernel take a reference on the CRTC (just once though
400 * to avoid corrupting the count if multiple, mismatch calls occur),
401 * so that interrupts remain enabled in the interim.
402 */
403 switch (modeset->cmd) {
404 case _DRM_PRE_MODESET:
405 DRM_DEBUG("pre-modeset\n");
406 if (!dev->vblank[crtc].inmodeset) {
407 dev->vblank[crtc].inmodeset = 1;
408 drm_vblank_get(dev, crtc);
409 }
410 break;
411 case _DRM_POST_MODESET:
412 DRM_DEBUG("post-modeset\n");
413 if (dev->vblank[crtc].inmodeset) {
414 DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
415 dev->vblank_disable_allowed = 1;
416 dev->vblank[crtc].inmodeset = 0;
417 DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
418 drm_vblank_put(dev, crtc);
419 }
420 break;
421 default:
422 ret = EINVAL;
423 break;
424 }
425
426 out:
427 return ret;
428 }
429
drm_wait_vblank(struct drm_device * dev,void * data,struct drm_file * file_priv)430 int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_priv)
431 {
432 union drm_wait_vblank *vblwait = data;
433 unsigned int flags, seq, crtc;
434 int ret = 0;
435
436 if (!dev->irq_enabled)
437 return EINVAL;
438
439 if (vblwait->request.type &
440 ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK)) {
441 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
442 vblwait->request.type,
443 (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK));
444 return EINVAL;
445 }
446
447 flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
448 crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
449
450 if (crtc >= dev->num_crtcs)
451 return EINVAL;
452
453 ret = drm_vblank_get(dev, crtc);
454 if (ret) {
455 DRM_ERROR("failed to acquire vblank counter, %d\n", ret);
456 return ret;
457 }
458 seq = drm_vblank_count(dev, crtc);
459
460 switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
461 case _DRM_VBLANK_RELATIVE:
462 vblwait->request.sequence += seq;
463 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
464 case _DRM_VBLANK_ABSOLUTE:
465 break;
466 default:
467 ret = EINVAL;
468 goto done;
469 }
470
471 if ((flags & _DRM_VBLANK_NEXTONMISS) &&
472 (seq - vblwait->request.sequence) <= (1<<23)) {
473 vblwait->request.sequence = seq + 1;
474 }
475
476 if (flags & _DRM_VBLANK_SIGNAL) {
477 #if 0 /* disabled */
478 drm_vbl_sig_t *vbl_sig = malloc(sizeof(drm_vbl_sig_t),
479 DRM_MEM_DRIVER, M_NOWAIT | M_ZERO);
480 if (vbl_sig == NULL)
481 return ENOMEM;
482
483 vbl_sig->sequence = vblwait->request.sequence;
484 vbl_sig->signo = vblwait->request.signal;
485 vbl_sig->pid = DRM_CURRENTPID;
486
487 vblwait->reply.sequence = atomic_read(&dev->vbl_received);
488
489 DRM_SPINLOCK(&dev->vbl_lock);
490 TAILQ_INSERT_HEAD(&dev->vbl_sig_list, vbl_sig, link);
491 DRM_SPINUNLOCK(&dev->vbl_lock);
492 ret = 0;
493 #endif
494 ret = EINVAL;
495 } else {
496 DRM_DEBUG("waiting on vblank count %d, crtc %d\n",
497 vblwait->request.sequence, crtc);
498 for ( ret = 0 ; !ret && !((drm_vblank_count(dev, crtc) -
499 vblwait->request.sequence) <= (1 << 23)) ; ) {
500 DRM_SPINLOCK(&dev->irq_lock);
501 if (!((drm_vblank_count(dev, crtc) -
502 vblwait->request.sequence) <= (1 << 23)))
503 #if defined(__FreeBSD__)
504 ret = mtx_sleep(&dev->vblank[crtc].queue,
505 &dev->irq_lock, PCATCH, "vblwtq",
506 3 * DRM_HZ);
507 #elif defined(__NetBSD__)
508 ret = mtsleep(&dev->vblank[crtc].queue,
509 PCATCH, "vblwtq", 3 * DRM_HZ, &dev->irq_lock);
510 #endif
511 DRM_SPINUNLOCK(&dev->irq_lock);
512 }
513
514 DRM_DEBUG("return = %d\n", ret);
515 if (ret != EINTR) {
516 struct timeval now;
517
518 microtime(&now);
519 vblwait->reply.tval_sec = now.tv_sec;
520 vblwait->reply.tval_usec = now.tv_usec;
521 vblwait->reply.sequence = drm_vblank_count(dev, crtc);
522 DRM_DEBUG("returning %d to client\n",
523 vblwait->reply.sequence);
524 } else {
525 DRM_DEBUG("vblank wait interrupted by signal\n");
526 }
527 }
528
529 done:
530 drm_vblank_put(dev, crtc);
531 return ret;
532 }
533
drm_vbl_send_signals(struct drm_device * dev,unsigned int crtc)534 void drm_vbl_send_signals(struct drm_device *dev, unsigned int crtc)
535 {
536 }
537
538 #if 0 /* disabled */
539 void drm_vbl_send_signals(struct drm_device *dev, unsigned int crtc )
540 {
541 drm_vbl_sig_t *vbl_sig;
542 unsigned int vbl_seq = atomic_read( &dev->vbl_received );
543 struct proc *p;
544
545 vbl_sig = TAILQ_FIRST(&dev->vbl_sig_list);
546 while (vbl_sig != NULL) {
547 drm_vbl_sig_t *next = TAILQ_NEXT(vbl_sig, link);
548
549 if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
550 mutex_enter(&proc_lock);
551 p = proc_find(vbl_sig->pid);
552 if (p != NULL) {
553 psignal(p, vbl_sig->signo);
554 }
555 mutex_exit(&proc_lock);
556
557 TAILQ_REMOVE(&dev->vbl_sig_list, vbl_sig, link);
558 DRM_FREE(vbl_sig,sizeof(*vbl_sig));
559 }
560 vbl_sig = next;
561 }
562 }
563 #endif
564
drm_handle_vblank(struct drm_device * dev,unsigned int crtc)565 void drm_handle_vblank(struct drm_device *dev, unsigned int crtc)
566 {
567 atomic_inc(&dev->vblank[crtc].count);
568 DRM_WAKEUP(&dev->vblank[crtc].queue);
569 drm_vbl_send_signals(dev, crtc);
570 }
571
572