usr/src/uts/common/io/drm/drm_irq.c

   1 /*
   2  * drm_irq.c -- IRQ IOCTL and function support
   3  * Created: Fri Oct 18 2003 by anholt@FreeBSD.org
   4  */
   5 /*
   6  * Copyright 2003 Eric Anholt
   7  * Copyright (c) 2009, Intel Corporation.
   8  * All Rights Reserved.
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the "Software"),
  12  * to deal in the Software without restriction, including without limitation
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14  * and/or sell copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the next
  18  * paragraph) shall be included in all copies or substantial portions of the
  19  * Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  24  * ERIC ANHOLT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  25  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  *
  28  * Authors:
  29  *    Eric Anholt <anholt@FreeBSD.org>
  30  *
  31  */
  32
  33 /*
  34  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  35  * Use is subject to license terms.
  36  */
  37
  38 #include "drmP.h"
  39 #include "drm.h"
  40 #include "drm_io32.h"
  41
  42 /*ARGSUSED*/
  43 int
  44 drm_irq_by_busid(DRM_IOCTL_ARGS)
  45 {
  46         DRM_DEVICE;
  47         drm_irq_busid_t irq;
  48
  49         DRM_COPYFROM_WITH_RETURN(&irq, (void *)data, sizeof (irq));
  50
  51         if ((irq.busnum >> 8) != dev->pci_domain ||
  52             (irq.busnum & 0xff) != dev->pci_bus ||
  53             irq.devnum != dev->pci_slot ||
  54             irq.funcnum != dev->pci_func)
  55                 return (EINVAL);
  56
  57         irq.irq = dev->irq;
  58
  59         DRM_DEBUG("%d:%d:%d => IRQ %d\n",
  60             irq.busnum, irq.devnum, irq.funcnum, irq.irq);
  61
  62         DRM_COPYTO_WITH_RETURN((void *)data, &irq, sizeof (irq));
  63
  64         return (0);
  65 }
  66
  67
  68 static irqreturn_t
  69 drm_irq_handler_wrap(DRM_IRQ_ARGS)
  70 {
  71         drm_device_t *dev = (void *)arg;
  72         int     ret;
  73
  74         mutex_enter(&dev->irq_lock);
  75         ret = dev->driver->irq_handler(arg);
  76         mutex_exit(&dev->irq_lock);
  77
  78         return (ret);
  79 }
  80
  81 static void vblank_disable_fn(void *arg)
  82 {
  83         struct drm_device *dev = (struct drm_device *)arg;
  84         int i;
  85
  86         if (!dev->vblank_disable_allowed)
  87                 return;
  88
  89         for (i = 0; i < dev->num_crtcs; i++) {
  90                 if (atomic_read(&dev->vblank_refcount[i]) == 0 &&
  91                     atomic_read(&dev->vblank_enabled[i]) == 1) {
  92                         dev->last_vblank[i] =
  93                             dev->driver->get_vblank_counter(dev, i);
  94                         dev->driver->disable_vblank(dev, i);
  95                         atomic_set(&dev->vblank_enabled[i], 0);
  96                         DRM_DEBUG("disable vblank");
  97                 }
  98         }
  99 }
 100
 101 void
 102 drm_vblank_cleanup(struct drm_device *dev)
 103 {
 104
 105         /* Bail if the driver didn't call drm_vblank_init() */
 106         if (dev->num_crtcs == 0)
 107                 return;
 108
 109         vblank_disable_fn((void *)dev);
 110
 111         drm_free(dev->vbl_queues, sizeof (wait_queue_head_t) * dev->num_crtcs,
 112             DRM_MEM_DRIVER);
 113         drm_free(dev->vbl_sigs, sizeof (struct drm_vbl_sig) * dev->num_crtcs,
 114             DRM_MEM_DRIVER);
 115         drm_free(dev->_vblank_count, sizeof (atomic_t) *
 116             dev->num_crtcs, DRM_MEM_DRIVER);
 117         drm_free(dev->vblank_refcount, sizeof (atomic_t) *
 118             dev->num_crtcs, DRM_MEM_DRIVER);
 119         drm_free(dev->vblank_enabled, sizeof (int) *
 120             dev->num_crtcs, DRM_MEM_DRIVER);
 121         drm_free(dev->last_vblank, sizeof (u32) * dev->num_crtcs,
 122             DRM_MEM_DRIVER);
 123         drm_free(dev->vblank_inmodeset, sizeof (*dev->vblank_inmodeset) *
 124             dev->num_crtcs, DRM_MEM_DRIVER);
 125         dev->num_crtcs = 0;
 126 }
 127
 128 int
 129 drm_vblank_init(struct drm_device *dev, int num_crtcs)
 130 {
 131         int i, ret = ENOMEM;
 132
 133         atomic_set(&dev->vbl_signal_pending, 0);
 134         dev->num_crtcs = num_crtcs;
 135
 136
 137         dev->vbl_queues = drm_alloc(sizeof (wait_queue_head_t) * num_crtcs,
 138             DRM_MEM_DRIVER);
 139         if (!dev->vbl_queues)
 140                 goto err;
 141
 142         dev->vbl_sigs = drm_alloc(sizeof (struct drm_vbl_sig) * num_crtcs,
 143             DRM_MEM_DRIVER);
 144         if (!dev->vbl_sigs)
 145                 goto err;
 146
 147         dev->_vblank_count = drm_alloc(sizeof (atomic_t) * num_crtcs,
 148             DRM_MEM_DRIVER);
 149         if (!dev->_vblank_count)
 150                 goto err;
 151
 152         dev->vblank_refcount = drm_alloc(sizeof (atomic_t) * num_crtcs,
 153             DRM_MEM_DRIVER);
 154         if (!dev->vblank_refcount)
 155                 goto err;
 156
 157         dev->vblank_enabled = drm_alloc(num_crtcs * sizeof (int),
 158             DRM_MEM_DRIVER);
 159         if (!dev->vblank_enabled)
 160                 goto err;
 161
 162         dev->last_vblank = drm_alloc(num_crtcs * sizeof (u32), DRM_MEM_DRIVER);
 163         if (!dev->last_vblank)
 164                 goto err;
 165
 166         dev->vblank_inmodeset = drm_alloc(num_crtcs * sizeof (int),
 167             DRM_MEM_DRIVER);
 168         if (!dev->vblank_inmodeset)
 169                 goto err;
 170
 171         /* Zero per-crtc vblank stuff */
 172         for (i = 0; i < num_crtcs; i++) {
 173                 DRM_INIT_WAITQUEUE(&dev->vbl_queues[i], DRM_INTR_PRI(dev));
 174                 TAILQ_INIT(&dev->vbl_sigs[i]);
 175                 atomic_set(&dev->_vblank_count[i], 0);
 176                 atomic_set(&dev->vblank_refcount[i], 0);
 177         }
 178
 179         dev->vblank_disable_allowed = 1;
 180         return (0);
 181
 182 err:
 183         DRM_ERROR("drm_vblank_init: alloc error");
 184         drm_vblank_cleanup(dev);
 185         return (ret);
 186 }
 187
 188 /*ARGSUSED*/
 189 static int
 190 drm_install_irq_handle(drm_device_t *dev)
 191 {
 192         dev_info_t *dip = dev->dip;
 193
 194         if (dip == NULL) {
 195                 DRM_ERROR("drm_install_irq_handle: cannot get vgatext's dip");
 196                 return (DDI_FAILURE);
 197         }
 198
 199         if (ddi_intr_hilevel(dip, 0) != 0) {
 200                 DRM_ERROR("drm_install_irq_handle: "
 201                     "high-level interrupts are not supported");
 202                 return (DDI_FAILURE);
 203         }
 204
 205         if (ddi_get_iblock_cookie(dip, 0,
 206             &dev->intr_block) != DDI_SUCCESS) {
 207                 DRM_ERROR("drm_install_irq_handle: cannot get iblock cookie");
 208                 return (DDI_FAILURE);
 209         }
 210
 211         /* setup the interrupt handler */
 212         if (ddi_add_intr(dip, 0, &dev->intr_block,
 213             (ddi_idevice_cookie_t *)NULL, drm_irq_handler_wrap,
 214             (caddr_t)dev) != DDI_SUCCESS) {
 215                 DRM_ERROR("drm_install_irq_handle: ddi_add_intr failed");
 216                 return (DDI_FAILURE);
 217         }
 218
 219         return (DDI_SUCCESS);
 220 }
 221
 222 /*ARGSUSED*/
 223 int
 224 drm_irq_install(drm_device_t *dev)
 225 {
 226         int ret;
 227
 228         if (dev->dev_private == NULL) {
 229                 DRM_ERROR("drm_irq_install: dev_private is NULL");
 230                 return (EINVAL);
 231         }
 232
 233         if (dev->irq_enabled) {
 234                 DRM_ERROR("drm_irq_install: irq already enabled");
 235                 return (EBUSY);
 236         }
 237
 238         DRM_DEBUG("drm_irq_install irq=%d\n", dev->irq);
 239
 240         /* before installing handler */
 241         ret = dev->driver->irq_preinstall(dev);
 242         if (ret)
 243                 return (EINVAL);
 244
 245         /* install handler */
 246         ret  = drm_install_irq_handle(dev);
 247         if (ret != DDI_SUCCESS) {
 248                 DRM_ERROR("drm_irq_install: drm_install_irq_handle failed");
 249                 return (ret);
 250         }
 251
 252         /* after installing handler */
 253         dev->driver->irq_postinstall(dev);
 254
 255         dev->irq_enabled = 1;
 256         dev->context_flag = 0;
 257
 258         return (0);
 259 }
 260
 261 static void
 262 drm_uninstall_irq_handle(drm_device_t *dev)
 263 {
 264         ASSERT(dev->dip);
 265         ddi_remove_intr(dev->dip, 0, dev->intr_block);
 266 }
 267
 268
 269 /*ARGSUSED*/
 270 int
 271 drm_irq_uninstall(drm_device_t *dev)
 272 {
 273         int i;
 274         if (!dev->irq_enabled) {
 275                 return (EINVAL);
 276         }
 277         dev->irq_enabled = 0;
 278
 279         /*
 280          * Wake up any waiters so they don't hang.
 281          */
 282         DRM_SPINLOCK(&dev->vbl_lock);
 283         for (i = 0; i < dev->num_crtcs; i++) {
 284                 DRM_WAKEUP(&dev->vbl_queues[i]);
 285                 dev->vblank_enabled[i] = 0;
 286         }
 287         DRM_SPINUNLOCK(&dev->vbl_lock);
 288
 289         dev->driver->irq_uninstall(dev);
 290         drm_uninstall_irq_handle(dev);
 291         dev->locked_tasklet_func = NULL;
 292
 293         return (DDI_SUCCESS);
 294 }
 295
 296 /*ARGSUSED*/
 297 int
 298 drm_control(DRM_IOCTL_ARGS)
 299 {
 300         DRM_DEVICE;
 301         drm_control_t ctl;
 302         int err;
 303
 304         DRM_COPYFROM_WITH_RETURN(&ctl, (void *)data, sizeof (ctl));
 305
 306         switch (ctl.func) {
 307         case DRM_INST_HANDLER:
 308                 /*
 309                  * Handle drivers whose DRM used to require IRQ setup but the
 310                  * no longer does.
 311                  */
 312                 return (drm_irq_install(dev));
 313         case DRM_UNINST_HANDLER:
 314                 err = drm_irq_uninstall(dev);
 315                 return (err);
 316         default:
 317                 return (EINVAL);
 318         }
 319 }
 320
 321 u32
 322 drm_vblank_count(struct drm_device *dev, int crtc)
 323 {
 324         return (atomic_read(&dev->_vblank_count[crtc]));
 325 }
 326
 327 static void drm_update_vblank_count(struct drm_device *dev, int crtc)
 328 {
 329         u32 cur_vblank, diff;
 330         /*
 331          * Interrupts were disabled prior to this call, so deal with counter
 332          * wrap if needed.
 333          * NOTE!  It's possible we lost a full dev->max_vblank_count events
 334          * here if the register is small or we had vblank interrupts off for
 335          * a long time.
 336          */
 337         cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
 338         diff = cur_vblank - dev->last_vblank[crtc];
 339         if (cur_vblank < dev->last_vblank[crtc]) {
 340                 diff += dev->max_vblank_count;
 341         DRM_DEBUG("last_vblank[%d]=0x%x, cur_vblank=0x%x => diff=0x%x\n",
 342             crtc, dev->last_vblank[crtc], cur_vblank, diff);
 343         }
 344
 345         atomic_add(diff, &dev->_vblank_count[crtc]);
 346 }
 347
 348 static timeout_id_t timer_id = NULL;
 349
 350 int
 351 drm_vblank_get(struct drm_device *dev, int crtc)
 352 {
 353         int ret = 0;
 354
 355         DRM_SPINLOCK(&dev->vbl_lock);
 356
 357         if (timer_id != NULL) {
 358                 (void) untimeout(timer_id);
 359                 timer_id = NULL;
 360         }
 361
 362         /* Going from 0->1 means we have to enable interrupts again */
 363         atomic_add(1, &dev->vblank_refcount[crtc]);
 364         if (dev->vblank_refcount[crtc] == 1 &&
 365             atomic_read(&dev->vblank_enabled[crtc]) == 0) {
 366                 ret = dev->driver->enable_vblank(dev, crtc);
 367                 if (ret)
 368                         atomic_dec(&dev->vblank_refcount[crtc]);
 369                 else {
 370                         atomic_set(&dev->vblank_enabled[crtc], 1);
 371                         drm_update_vblank_count(dev, crtc);
 372                 }
 373         }
 374         DRM_SPINUNLOCK(&dev->vbl_lock);
 375
 376         return (ret);
 377 }
 378
 379 void
 380 drm_vblank_put(struct drm_device *dev, int crtc)
 381 {
 382         DRM_SPINLOCK(&dev->vbl_lock);
 383         /* Last user schedules interrupt disable */
 384         atomic_dec(&dev->vblank_refcount[crtc]);
 385
 386         if (dev->vblank_refcount[crtc] == 0)
 387                 timer_id = timeout(vblank_disable_fn, (void *) dev, 5*DRM_HZ);
 388
 389         DRM_SPINUNLOCK(&dev->vbl_lock);
 390 }
 391
 392 /*
 393  * drm_modeset_ctl - handle vblank event counter changes across mode switch
 394  * @DRM_IOCTL_ARGS: standard ioctl arguments
 395  *
 396  * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
 397  * ioctls around modesetting so that any lost vblank events are accounted for.
 398  *
 399  * Generally the counter will reset across mode sets.  If interrupts are
 400  * enabled around this call, we don't have to do anything since the counter
 401  * will have already been incremented.
 402  */
 403 /*ARGSUSED*/
 404 int
 405 drm_modeset_ctl(DRM_IOCTL_ARGS)
 406 {
 407         DRM_DEVICE;
 408         struct drm_modeset_ctl modeset;
 409         int crtc, ret = 0;
 410
 411         /* If drm_vblank_init() hasn't been called yet, just no-op */
 412         if (!dev->num_crtcs)
 413                 goto out;
 414
 415         DRM_COPYFROM_WITH_RETURN(&modeset, (void *)data,
 416             sizeof (modeset));
 417
 418         crtc = modeset.crtc;
 419         if (crtc >= dev->num_crtcs) {
 420                 ret = -EINVAL;
 421                 goto out;
 422         }
 423
 424         /*
 425          * To avoid all the problems that might happen if interrupts
 426          * were enabled/disabled around or between these calls, we just
 427          * have the kernel take a reference on the CRTC (just once though
 428          * to avoid corrupting the count if multiple, mismatch calls occur),
 429          * so that interrupts remain enabled in the interim.
 430          */
 431         switch (modeset.cmd) {
 432         case _DRM_PRE_MODESET:
 433                 if (!dev->vblank_inmodeset[crtc]) {
 434                         dev->vblank_inmodeset[crtc] = 1;
 435                         ret = drm_vblank_get(dev, crtc);
 436                 }
 437                 break;
 438         case _DRM_POST_MODESET:
 439                 if (dev->vblank_inmodeset[crtc]) {
 440                         DRM_SPINLOCK(&dev->vbl_lock);
 441                         dev->vblank_disable_allowed = 1;
 442                         dev->vblank_inmodeset[crtc] = 0;
 443                         DRM_SPINUNLOCK(&dev->vbl_lock);
 444                         drm_vblank_put(dev, crtc);
 445                 }
 446                 break;
 447         default:
 448                 ret = -EINVAL;
 449                 break;
 450         }
 451
 452 out:
 453         return (ret);
 454 }
 455
 456 /*ARGSUSED*/
 457 int
 458 drm_wait_vblank(DRM_IOCTL_ARGS)
 459 {
 460         DRM_DEVICE;
 461         drm_wait_vblank_t vblwait;
 462         int ret, flags, crtc;
 463         unsigned int    sequence;
 464
 465         if (!dev->irq_enabled) {
 466                 DRM_ERROR("wait vblank, EINVAL");
 467                 return (EINVAL);
 468         }
 469 #ifdef _MULTI_DATAMODEL
 470         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
 471                 drm_wait_vblank_32_t vblwait32;
 472                 DRM_COPYFROM_WITH_RETURN(&vblwait32, (void *)data,
 473                     sizeof (vblwait32));
 474                 vblwait.request.type = vblwait32.request.type;
 475                 vblwait.request.sequence = vblwait32.request.sequence;
 476                 vblwait.request.signal = vblwait32.request.signal;
 477         } else {
 478 #endif
 479                 DRM_COPYFROM_WITH_RETURN(&vblwait, (void *)data,
 480                     sizeof (vblwait));
 481 #ifdef _MULTI_DATAMODEL
 482         }
 483 #endif
 484
 485         if (vblwait.request.type &
 486             ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK)) {
 487                 DRM_ERROR("drm_wait_vblank: wrong request type 0x%x",
 488                     vblwait.request.type);
 489                 return (EINVAL);
 490         }
 491
 492         flags = vblwait.request.type & _DRM_VBLANK_FLAGS_MASK;
 493         crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
 494         if (crtc >= dev->num_crtcs) {
 495                 DRM_ERROR("wait vblank operation not support");
 496                 return (ENOTSUP);
 497         }
 498         ret = drm_vblank_get(dev, crtc);
 499         if (ret) {
 500                 DRM_ERROR("can't get drm vblank %d", ret);
 501                 return (ret);
 502         }
 503         sequence = drm_vblank_count(dev, crtc);
 504
 505         switch (vblwait.request.type & _DRM_VBLANK_TYPES_MASK) {
 506         case _DRM_VBLANK_RELATIVE:
 507                 vblwait.request.sequence += sequence;
 508                 vblwait.request.type &= ~_DRM_VBLANK_RELATIVE;
 509                 /*FALLTHROUGH*/
 510         case _DRM_VBLANK_ABSOLUTE:
 511                 break;
 512         default:
 513                 DRM_DEBUG("wait vblank return EINVAL");
 514                 return (EINVAL);
 515         }
 516
 517         if ((flags & _DRM_VBLANK_NEXTONMISS) &&
 518             (sequence - vblwait.request.sequence) <= (1<<23)) {
 519                 vblwait.request.sequence = sequence + 1;
 520         }
 521
 522         if (flags & _DRM_VBLANK_SIGNAL) {
 523                 /*
 524                  * Don't block process, send signal when vblank interrupt
 525                  */
 526                 DRM_ERROR("NOT SUPPORT YET, SHOULD BE ADDED");
 527                 cmn_err(CE_WARN, "NOT SUPPORT YET, SHOULD BE ADDED");
 528                 ret = EINVAL;
 529                 goto done;
 530         } else {
 531                 /* block until vblank interupt */
 532                 /* shared code returns -errno */
 533                 DRM_WAIT_ON(ret, &dev->vbl_queues[crtc], 3 * DRM_HZ,
 534                     (((drm_vblank_count(dev, crtc)
 535                     - vblwait.request.sequence) <= (1 << 23)) ||
 536                     !dev->irq_enabled));
 537                 if (ret != EINTR) {
 538                         struct timeval now;
 539                         (void) uniqtime(&now);
 540                         vblwait.reply.tval_sec = now.tv_sec;
 541                         vblwait.reply.tval_usec = now.tv_usec;
 542                         vblwait.reply.sequence = drm_vblank_count(dev, crtc);
 543                 }
 544         }
 545
 546 done:
 547 #ifdef _MULTI_DATAMODEL
 548         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
 549                 drm_wait_vblank_32_t vblwait32;
 550                 vblwait32.reply.type = vblwait.reply.type;
 551                 vblwait32.reply.sequence = vblwait.reply.sequence;
 552                 vblwait32.reply.tval_sec = (int32_t)vblwait.reply.tval_sec;
 553                 vblwait32.reply.tval_usec = (int32_t)vblwait.reply.tval_usec;
 554                 DRM_COPYTO_WITH_RETURN((void *)data, &vblwait32,
 555                     sizeof (vblwait32));
 556         } else {
 557 #endif
 558                 DRM_COPYTO_WITH_RETURN((void *)data, &vblwait,
 559                     sizeof (vblwait));
 560 #ifdef _MULTI_DATAMODEL
 561         }
 562 #endif
 563
 564         drm_vblank_put(dev, crtc);
 565         return (ret);
 566 }
 567
 568
 569 /*ARGSUSED*/
 570 void
 571 drm_vbl_send_signals(drm_device_t *dev)
 572 {
 573         DRM_DEBUG("drm_vbl_send_signals");
 574 }
 575
 576 void
 577 drm_handle_vblank(struct drm_device *dev, int crtc)
 578 {
 579         atomic_inc(&dev->_vblank_count[crtc]);
 580         DRM_WAKEUP(&dev->vbl_queues[crtc]);
 581 }