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 (at) 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 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 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 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 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 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 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 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 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 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 304 u32 drm_vblank_count(struct drm_device *dev, unsigned int crtc) 305 { 306 return atomic_read(&dev->vblank[crtc].count); 307 } 308 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 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 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 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 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 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 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
Indexes created Sun Sep 21 20:09:37 GMT 2025