sys/dev/drm/drm_irq.c

   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 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 /** @file drm_irq.c
  32  * Support code for handling setup/teardown of interrupt handlers and
  33  * handing interrupt handlers off to the drivers.
  34  */
  35
  36 #include "dev/drm/drmP.h"
  37 #include "dev/drm/drm.h"
  38
  39 static void drm_locked_task(void *context, int pending __unused);
  40
  41 int drm_irq_by_busid(struct drm_device *dev, void *data,
  42                      struct drm_file *file_priv)
  43 {
  44         struct drm_irq_busid *irq = data;
  45
  46         if ((irq->busnum >> 8) != dev->pci_domain ||
  47             (irq->busnum & 0xff) != dev->pci_bus ||
  48             irq->devnum != dev->pci_slot ||
  49             irq->funcnum != dev->pci_func)
  50                 return EINVAL;
  51
  52         irq->irq = dev->irq;
  53
  54         DRM_DEBUG("%d:%d:%d => IRQ %d\n",
  55             irq->busnum, irq->devnum, irq->funcnum, irq->irq);
  56
  57         return 0;
  58 }
  59
  60 static irqreturn_t
  61 drm_irq_handler_wrap(DRM_IRQ_ARGS)
  62 {
  63         struct drm_device *dev = arg;
  64
  65         DRM_SPINLOCK(&dev->irq_lock);
  66         dev->driver->irq_handler(arg);
  67         DRM_SPINUNLOCK(&dev->irq_lock);
  68 }
  69
  70 static void vblank_disable_fn(void *arg)
  71 {
  72         struct drm_device *dev = (struct drm_device *)arg;
  73         int i;
  74
  75         if (callout_pending(&dev->vblank_disable_timer)) {
  76                 /* callout was reset */
  77                 return;
  78         }
  79         if (!callout_active(&dev->vblank_disable_timer)) {
  80                 /* callout was stopped */
  81                 return;
  82         }
  83         callout_deactivate(&dev->vblank_disable_timer);
  84
  85         DRM_DEBUG("vblank_disable_allowed=%d\n", dev->vblank_disable_allowed);
  86         if (!dev->vblank_disable_allowed)
  87                 return;
  88
  89         for (i = 0; i < dev->num_crtcs; i++) {
  90                 if (atomic_read(&dev->vblank[i].refcount) == 0 &&
  91                     dev->vblank[i].enabled) {
  92                         DRM_DEBUG("disabling vblank on crtc %d\n", i);
  93                         dev->vblank[i].last =
  94                             dev->driver->get_vblank_counter(dev, i);
  95                         dev->driver->disable_vblank(dev, i);
  96                         dev->vblank[i].enabled = 0;
  97                 }
  98         }
  99 }
 100
 101 static void drm_vblank_cleanup(struct drm_device *dev)
 102 {
 103         unsigned long irqflags;
 104
 105         /* Bail if the driver didn't call drm_vblank_init() */
 106         if (dev->num_crtcs == 0)
 107                 return;
 108
 109         DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
 110         callout_stop(&dev->vblank_disable_timer);
 111         DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
 112
 113         callout_drain(&dev->vblank_disable_timer);
 114
 115         vblank_disable_fn((void *)dev);
 116
 117         free(dev->vblank, DRM_MEM_DRIVER);
 118
 119         dev->num_crtcs = 0;
 120 }
 121
 122 int drm_vblank_init(struct drm_device *dev, int num_crtcs)
 123 {
 124         int i, ret = ENOMEM;
 125
 126         callout_init_mtx(&dev->vblank_disable_timer, &dev->vbl_lock, 0);
 127         atomic_set(&dev->vbl_signal_pending, 0);
 128         dev->num_crtcs = num_crtcs;
 129
 130         dev->vblank = malloc(sizeof(struct drm_vblank_info) * num_crtcs,
 131             DRM_MEM_DRIVER, M_NOWAIT | M_ZERO);
 132         if (!dev->vblank)
 133             goto err;
 134
 135         DRM_DEBUG("\n");
 136
 137         /* Zero per-crtc vblank stuff */
 138         for (i = 0; i < num_crtcs; i++) {
 139                 DRM_INIT_WAITQUEUE(&dev->vblank[i].queue);
 140                 TAILQ_INIT(&dev->vblank[i].sigs);
 141                 atomic_set(&dev->vblank[i].count, 0);
 142                 atomic_set(&dev->vblank[i].refcount, 0);
 143         }
 144
 145         dev->vblank_disable_allowed = 0;
 146
 147         return 0;
 148
 149 err:
 150         drm_vblank_cleanup(dev);
 151         return ret;
 152 }
 153
 154 int drm_irq_install(struct drm_device *dev)
 155 {
 156         int retcode;
 157
 158         if (dev->irq == 0 || dev->dev_private == NULL)
 159                 return EINVAL;
 160
 161         DRM_DEBUG("irq=%d\n", dev->irq);
 162
 163         DRM_LOCK();
 164         if (dev->irq_enabled) {
 165                 DRM_UNLOCK();
 166                 return EBUSY;
 167         }
 168         dev->irq_enabled = 1;
 169
 170         dev->context_flag = 0;
 171
 172         /* Before installing handler */
 173         dev->driver->irq_preinstall(dev);
 174         DRM_UNLOCK();
 175
 176         /* Install handler */
 177         dev->irqrid = 0;
 178         dev->irqr = bus_alloc_resource_any(dev->device, SYS_RES_IRQ,
 179                                       &dev->irqrid, RF_SHAREABLE);
 180         if (!dev->irqr) {
 181                 retcode = ENOENT;
 182                 goto err;
 183         }
 184 #if __FreeBSD_version >= 700031
 185         retcode = bus_setup_intr(dev->device, dev->irqr,
 186                                  INTR_TYPE_TTY | INTR_MPSAFE,
 187                                  NULL, drm_irq_handler_wrap, dev, &dev->irqh);
 188 #else
 189         retcode = bus_setup_intr(dev->device, dev->irqr,
 190                                  INTR_TYPE_TTY | INTR_MPSAFE,
 191                                  drm_irq_handler_wrap, dev, &dev->irqh);
 192 #endif
 193         if (retcode != 0)
 194                 goto err;
 195
 196         /* After installing handler */
 197         DRM_LOCK();
 198         dev->driver->irq_postinstall(dev);
 199         DRM_UNLOCK();
 200
 201         TASK_INIT(&dev->locked_task, 0, drm_locked_task, dev);
 202         return 0;
 203 err:
 204         DRM_LOCK();
 205         dev->irq_enabled = 0;
 206         if (dev->irqrid != 0) {
 207                 bus_release_resource(dev->device, SYS_RES_IRQ, dev->irqrid,
 208                     dev->irqr);
 209                 dev->irqrid = 0;
 210         }
 211         DRM_UNLOCK();
 212         return retcode;
 213 }
 214
 215 int drm_irq_uninstall(struct drm_device *dev)
 216 {
 217         int irqrid;
 218
 219         if (!dev->irq_enabled)
 220                 return EINVAL;
 221
 222         dev->irq_enabled = 0;
 223         irqrid = dev->irqrid;
 224         dev->irqrid = 0;
 225
 226         DRM_DEBUG("irq=%d\n", dev->irq);
 227
 228         dev->driver->irq_uninstall(dev);
 229
 230         DRM_UNLOCK();
 231         bus_teardown_intr(dev->device, dev->irqr, dev->irqh);
 232         bus_release_resource(dev->device, SYS_RES_IRQ, irqrid, dev->irqr);
 233         DRM_LOCK();
 234
 235         drm_vblank_cleanup(dev);
 236
 237         return 0;
 238 }
 239
 240 int drm_control(struct drm_device *dev, void *data, struct drm_file *file_priv)
 241 {
 242         struct drm_control *ctl = data;
 243         int err;
 244
 245         switch (ctl->func) {
 246         case DRM_INST_HANDLER:
 247                 /* Handle drivers whose DRM used to require IRQ setup but the
 248                  * no longer does.
 249                  */
 250                 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 251                         return 0;
 252                 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
 253                     ctl->irq != dev->irq)
 254                         return EINVAL;
 255                 return drm_irq_install(dev);
 256         case DRM_UNINST_HANDLER:
 257                 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 258                         return 0;
 259                 DRM_LOCK();
 260                 err = drm_irq_uninstall(dev);
 261                 DRM_UNLOCK();
 262                 return err;
 263         default:
 264                 return EINVAL;
 265         }
 266 }
 267
 268 u32 drm_vblank_count(struct drm_device *dev, int crtc)
 269 {
 270         return atomic_read(&dev->vblank[crtc].count);
 271 }
 272
 273 static void drm_update_vblank_count(struct drm_device *dev, int crtc)
 274 {
 275         u32 cur_vblank, diff;
 276
 277         /*
 278          * Interrupts were disabled prior to this call, so deal with counter
 279          * wrap if needed.
 280          * NOTE!  It's possible we lost a full dev->max_vblank_count events
 281          * here if the register is small or we had vblank interrupts off for
 282          * a long time.
 283          */
 284         cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
 285         diff = cur_vblank - dev->vblank[crtc].last;
 286         if (cur_vblank < dev->vblank[crtc].last) {
 287                 diff += dev->max_vblank_count;
 288
 289                 DRM_DEBUG("vblank[%d].last=0x%x, cur_vblank=0x%x => diff=0x%x\n",
 290                     crtc, dev->vblank[crtc].last, cur_vblank, diff);
 291         }
 292
 293         DRM_DEBUG("enabling vblank interrupts on crtc %d, missed %d\n",
 294             crtc, diff);
 295
 296         atomic_add(diff, &dev->vblank[crtc].count);
 297 }
 298
 299 int drm_vblank_get(struct drm_device *dev, int crtc)
 300 {
 301         unsigned long irqflags;
 302         int ret = 0;
 303
 304         DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
 305         /* Going from 0->1 means we have to enable interrupts again */
 306         atomic_add_acq_int(&dev->vblank[crtc].refcount, 1);
 307         if (dev->vblank[crtc].refcount == 1 &&
 308             !dev->vblank[crtc].enabled) {
 309                 ret = dev->driver->enable_vblank(dev, crtc);
 310                 if (ret)
 311                         atomic_dec(&dev->vblank[crtc].refcount);
 312                 else {
 313                         dev->vblank[crtc].enabled = 1;
 314                         drm_update_vblank_count(dev, crtc);
 315                 }
 316         }
 317         DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
 318
 319         return ret;
 320 }
 321
 322 void drm_vblank_put(struct drm_device *dev, int crtc)
 323 {
 324         unsigned long irqflags;
 325
 326         DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
 327         /* Last user schedules interrupt disable */
 328         atomic_subtract_acq_int(&dev->vblank[crtc].refcount, 1);
 329         if (dev->vblank[crtc].refcount == 0)
 330             callout_reset(&dev->vblank_disable_timer, 5 * DRM_HZ,
 331                 (timeout_t *)vblank_disable_fn, (void *)dev);
 332         DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
 333 }
 334
 335 int drm_modeset_ctl(struct drm_device *dev, void *data,
 336                     struct drm_file *file_priv)
 337 {
 338         struct drm_modeset_ctl *modeset = data;
 339         unsigned long irqflags;
 340         int crtc, ret = 0;
 341
 342         DRM_DEBUG("num_crtcs=%d\n", dev->num_crtcs);
 343         /* If drm_vblank_init() hasn't been called yet, just no-op */
 344         if (!dev->num_crtcs)
 345                 goto out;
 346
 347         crtc = modeset->crtc;
 348         DRM_DEBUG("crtc=%d\n", crtc);
 349         if (crtc >= dev->num_crtcs) {
 350                 ret = EINVAL;
 351                 goto out;
 352         }
 353
 354         /*
 355          * To avoid all the problems that might happen if interrupts
 356          * were enabled/disabled around or between these calls, we just
 357          * have the kernel take a reference on the CRTC (just once though
 358          * to avoid corrupting the count if multiple, mismatch calls occur),
 359          * so that interrupts remain enabled in the interim.
 360          */
 361         switch (modeset->cmd) {
 362         case _DRM_PRE_MODESET:
 363                 DRM_DEBUG("pre-modeset\n");
 364                 if (!dev->vblank[crtc].inmodeset) {
 365                         dev->vblank[crtc].inmodeset = 1;
 366                         drm_vblank_get(dev, crtc);
 367                 }
 368                 break;
 369         case _DRM_POST_MODESET:
 370                 DRM_DEBUG("post-modeset\n");
 371                 if (dev->vblank[crtc].inmodeset) {
 372                         DRM_SPINLOCK_IRQSAVE(&dev->vbl_lock, irqflags);
 373                         dev->vblank_disable_allowed = 1;
 374                         dev->vblank[crtc].inmodeset = 0;
 375                         DRM_SPINUNLOCK_IRQRESTORE(&dev->vbl_lock, irqflags);
 376                         drm_vblank_put(dev, crtc);
 377                 }
 378                 break;
 379         default:
 380                 ret = EINVAL;
 381                 break;
 382         }
 383
 384 out:
 385         return ret;
 386 }
 387
 388 int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_priv)
 389 {
 390         union drm_wait_vblank *vblwait = data;
 391         int ret = 0;
 392         int flags, seq, crtc;
 393
 394         if (!dev->irq_enabled)
 395                 return EINVAL;
 396
 397         if (vblwait->request.type &
 398             ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK)) {
 399                 DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
 400                     vblwait->request.type,
 401                     (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK));
 402                 return EINVAL;
 403         }
 404
 405         flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
 406         crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
 407
 408         if (crtc >= dev->num_crtcs)
 409                 return EINVAL;
 410
 411         ret = drm_vblank_get(dev, crtc);
 412         if (ret)
 413                 return ret;
 414         seq = drm_vblank_count(dev, crtc);
 415
 416         switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
 417         case _DRM_VBLANK_RELATIVE:
 418                 vblwait->request.sequence += seq;
 419                 vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
 420         case _DRM_VBLANK_ABSOLUTE:
 421                 break;
 422         default:
 423                 ret = EINVAL;
 424                 goto done;
 425         }
 426
 427         if ((flags & _DRM_VBLANK_NEXTONMISS) &&
 428             (seq - vblwait->request.sequence) <= (1<<23)) {
 429                 vblwait->request.sequence = seq + 1;
 430         }
 431
 432         if (flags & _DRM_VBLANK_SIGNAL) {
 433 #if 0 /* disabled */
 434                 drm_vbl_sig_t *vbl_sig = malloc(sizeof(drm_vbl_sig_t),
 435                     DRM_MEM_DRIVER, M_NOWAIT | M_ZERO);
 436                 if (vbl_sig == NULL)
 437                         return ENOMEM;
 438
 439                 vbl_sig->sequence = vblwait->request.sequence;
 440                 vbl_sig->signo = vblwait->request.signal;
 441                 vbl_sig->pid = DRM_CURRENTPID;
 442
 443                 vblwait->reply.sequence = atomic_read(&dev->vbl_received);
 444
 445                 DRM_SPINLOCK(&dev->vbl_lock);
 446                 TAILQ_INSERT_HEAD(&dev->vbl_sig_list, vbl_sig, link);
 447                 DRM_SPINUNLOCK(&dev->vbl_lock);
 448                 ret = 0;
 449 #endif
 450                 ret = EINVAL;
 451         } else {
 452                 DRM_LOCK();
 453                 /* shared code returns -errno */
 454
 455                 DRM_WAIT_ON(ret, dev->vblank[crtc].queue, 3 * DRM_HZ,
 456                     ((drm_vblank_count(dev, crtc)
 457                       - vblwait->request.sequence) <= (1 << 23)));
 458                 DRM_UNLOCK();
 459
 460                 if (ret != EINTR) {
 461                         struct timeval now;
 462
 463                         microtime(&now);
 464                         vblwait->reply.tval_sec = now.tv_sec;
 465                         vblwait->reply.tval_usec = now.tv_usec;
 466                         vblwait->reply.sequence = drm_vblank_count(dev, crtc);
 467                 }
 468         }
 469
 470 done:
 471         drm_vblank_put(dev, crtc);
 472         return ret;
 473 }
 474
 475 void drm_vbl_send_signals(struct drm_device *dev, int crtc)
 476 {
 477 }
 478
 479 #if 0 /* disabled */
 480 void drm_vbl_send_signals(struct drm_device *dev, int crtc )
 481 {
 482         drm_vbl_sig_t *vbl_sig;
 483         unsigned int vbl_seq = atomic_read( &dev->vbl_received );
 484         struct proc *p;
 485
 486         vbl_sig = TAILQ_FIRST(&dev->vbl_sig_list);
 487         while (vbl_sig != NULL) {
 488                 drm_vbl_sig_t *next = TAILQ_NEXT(vbl_sig, link);
 489
 490                 if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
 491                         p = pfind(vbl_sig->pid);
 492                         if (p != NULL)
 493                                 psignal(p, vbl_sig->signo);
 494
 495                         TAILQ_REMOVE(&dev->vbl_sig_list, vbl_sig, link);
 496                         DRM_FREE(vbl_sig,sizeof(*vbl_sig));
 497                 }
 498                 vbl_sig = next;
 499         }
 500 }
 501 #endif
 502
 503 void drm_handle_vblank(struct drm_device *dev, int crtc)
 504 {
 505         atomic_inc(&dev->vblank[crtc].count);
 506         DRM_WAKEUP(&dev->vblank[crtc].queue);
 507         drm_vbl_send_signals(dev, crtc);
 508 }
 509
 510 static void drm_locked_task(void *context, int pending __unused)
 511 {
 512         struct drm_device *dev = context;
 513
 514         DRM_SPINLOCK(&dev->tsk_lock);
 515
 516         DRM_LOCK(); /* XXX drm_lock_take() should do it's own locking */
 517         if (dev->locked_task_call == NULL ||
 518             drm_lock_take(&dev->lock, DRM_KERNEL_CONTEXT) == 0) {
 519                 DRM_UNLOCK();
 520                 DRM_SPINUNLOCK(&dev->tsk_lock);
 521                 return;
 522         }
 523
 524         dev->lock.file_priv = NULL; /* kernel owned */
 525         dev->lock.lock_time = jiffies;
 526         atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
 527
 528         DRM_UNLOCK();
 529
 530         dev->locked_task_call(dev);
 531
 532         drm_lock_free(&dev->lock, DRM_KERNEL_CONTEXT);
 533
 534         dev->locked_task_call = NULL;
 535
 536         DRM_SPINUNLOCK(&dev->tsk_lock);
 537 }
 538
 539 void
 540 drm_locked_tasklet(struct drm_device *dev,
 541                    void (*tasklet)(struct drm_device *dev))
 542 {
 543         DRM_SPINLOCK(&dev->tsk_lock);
 544         if (dev->locked_task_call != NULL) {
 545                 DRM_SPINUNLOCK(&dev->tsk_lock);
 546                 return;
 547         }
 548
 549         dev->locked_task_call = tasklet;
 550         DRM_SPINUNLOCK(&dev->tsk_lock);
 551         taskqueue_enqueue(taskqueue_swi, &dev->locked_task);
 552 }