shared-core/i915_irq.c

   1 /* i915_irq.c -- IRQ support for the I915 -*- linux-c -*-
   2  */
   3 /*
   4  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  */
  28
  29 #include "drmP.h"
  30 #include "drm.h"
  31 #include "i915_drm.h"
  32 #include "i915_drv.h"
  33
  34 #define USER_INT_FLAG (1<<1)
  35 #define VSYNC_PIPEB_FLAG (1<<5)
  36 #define VSYNC_PIPEA_FLAG (1<<7)
  37
  38 #define MAX_NOPID ((u32)~0)
  39
  40 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
  41 {
  42         drm_device_t *dev = (drm_device_t *) arg;
  43         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
  44         u16 temp;
  45
  46         temp = I915_READ16(I915REG_INT_IDENTITY_R);
  47
  48         temp &= (USER_INT_FLAG | VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG);
  49
  50         DRM_DEBUG("%s flag=%08x\n", __FUNCTION__, temp);
  51
  52         if (temp == 0)
  53                 return IRQ_NONE;
  54
  55         I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
  56
  57         dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
  58
  59         if (temp & USER_INT_FLAG) {
  60                 DRM_WAKEUP(&dev_priv->irq_queue);
  61 #ifdef I915_HAVE_FENCE
  62                 i915_fence_handler(dev);
  63 #endif
  64         }
  65
  66         if (temp & (VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG)) {
  67                 atomic_inc(&dev->vbl_received);
  68                 DRM_WAKEUP(&dev->vbl_queue);
  69                 drm_vbl_send_signals(dev);
  70         }
  71
  72         return IRQ_HANDLED;
  73 }
  74
  75 int i915_emit_irq(drm_device_t * dev)
  76 {
  77
  78         drm_i915_private_t *dev_priv = dev->dev_private;
  79         RING_LOCALS;
  80
  81         i915_kernel_lost_context(dev);
  82
  83         DRM_DEBUG("%s\n", __FUNCTION__);
  84
  85         dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
  86
  87         if (dev_priv->counter > 0x7FFFFFFFUL)
  88                  dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
  89
  90         BEGIN_LP_RING(6);
  91         OUT_RING(CMD_STORE_DWORD_IDX);
  92         OUT_RING(20);
  93         OUT_RING(dev_priv->counter);
  94
  95         OUT_RING(0);
  96         OUT_RING(0);
  97         OUT_RING(GFX_OP_USER_INTERRUPT);
  98         ADVANCE_LP_RING();
  99
 100         return dev_priv->counter;
 101
 102
 103 }
 104
 105 void i915_user_irq_on(drm_i915_private_t *dev_priv)
 106 {
 107
 108         spin_lock(&dev_priv->user_irq_lock);
 109         if (dev_priv->irq_enabled && (++dev_priv->user_irq_refcount == 1)){
 110                 dev_priv->irq_enable_reg |= USER_INT_FLAG;
 111                 I915_WRITE16(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
 112         }
 113         spin_unlock(&dev_priv->user_irq_lock);
 114
 115 }
 116
 117 void i915_user_irq_off(drm_i915_private_t *dev_priv)
 118 {
 119         spin_lock(&dev_priv->user_irq_lock);
 120         if (dev_priv->irq_enabled && (--dev_priv->user_irq_refcount == 0)) {
 121                 dev_priv->irq_enable_reg &= ~USER_INT_FLAG;
 122                 I915_WRITE16(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
 123         }
 124         spin_unlock(&dev_priv->user_irq_lock);
 125 }
 126
 127
 128 static int i915_wait_irq(drm_device_t * dev, int irq_nr)
 129 {
 130         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 131         int ret = 0;
 132
 133         DRM_DEBUG("%s irq_nr=%d breadcrumb=%d\n", __FUNCTION__, irq_nr,
 134                   READ_BREADCRUMB(dev_priv));
 135
 136         if (READ_BREADCRUMB(dev_priv) >= irq_nr)
 137                 return 0;
 138
 139         dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
 140
 141         i915_user_irq_on(dev_priv);
 142         DRM_WAIT_ON(ret, dev_priv->irq_queue, 3 * DRM_HZ,
 143                     READ_BREADCRUMB(dev_priv) >= irq_nr);
 144         i915_user_irq_off(dev_priv);
 145
 146         if (ret == DRM_ERR(EBUSY)) {
 147                 DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n",
 148                           __FUNCTION__,
 149                           READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
 150         }
 151
 152         dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
 153         return ret;
 154 }
 155
 156 int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
 157 {
 158         drm_i915_private_t *dev_priv = dev->dev_private;
 159         unsigned int cur_vblank;
 160         int ret = 0;
 161
 162         if (!dev_priv) {
 163                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 164                 return DRM_ERR(EINVAL);
 165         }
 166
 167         DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
 168                     (((cur_vblank = atomic_read(&dev->vbl_received))
 169                         - *sequence) <= (1<<23)));
 170
 171         *sequence = cur_vblank;
 172
 173         return ret;
 174 }
 175
 176 /* Needs the lock as it touches the ring.
 177  */
 178 int i915_irq_emit(DRM_IOCTL_ARGS)
 179 {
 180         DRM_DEVICE;
 181         drm_i915_private_t *dev_priv = dev->dev_private;
 182         drm_i915_irq_emit_t emit;
 183         int result;
 184
 185         LOCK_TEST_WITH_RETURN(dev, filp);
 186
 187         if (!dev_priv) {
 188                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 189                 return DRM_ERR(EINVAL);
 190         }
 191
 192         DRM_COPY_FROM_USER_IOCTL(emit, (drm_i915_irq_emit_t __user *) data,
 193                                  sizeof(emit));
 194
 195         result = i915_emit_irq(dev);
 196
 197         if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {
 198                 DRM_ERROR("copy_to_user\n");
 199                 return DRM_ERR(EFAULT);
 200         }
 201
 202         return 0;
 203 }
 204
 205 /* Doesn't need the hardware lock.
 206  */
 207 int i915_irq_wait(DRM_IOCTL_ARGS)
 208 {
 209         DRM_DEVICE;
 210         drm_i915_private_t *dev_priv = dev->dev_private;
 211         drm_i915_irq_wait_t irqwait;
 212
 213         if (!dev_priv) {
 214                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 215                 return DRM_ERR(EINVAL);
 216         }
 217
 218         DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_i915_irq_wait_t __user *) data,
 219                                  sizeof(irqwait));
 220
 221         return i915_wait_irq(dev, irqwait.irq_seq);
 222 }
 223
 224 static int i915_enable_interrupt (drm_device_t *dev)
 225 {
 226         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 227         u16 flag;
 228
 229         flag = 0;
 230         if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_A)
 231                 flag |= VSYNC_PIPEA_FLAG;
 232         if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
 233                 flag |= VSYNC_PIPEB_FLAG;
 234         if (dev_priv->vblank_pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
 235                 DRM_ERROR("%s called with invalid pipe 0x%x\n",
 236                           __FUNCTION__, dev_priv->vblank_pipe);
 237                 return DRM_ERR(EINVAL);
 238         }
 239         dev_priv->user_irq_lock = SPIN_LOCK_UNLOCKED;
 240         dev_priv->user_irq_refcount = 0;
 241         dev_priv->irq_enable_reg = flag;
 242         I915_WRITE16(I915REG_INT_ENABLE_R, flag);
 243         dev_priv->irq_enabled = 1;
 244         return 0;
 245 }
 246
 247 /* Set the vblank monitor pipe
 248  */
 249 int i915_vblank_pipe_set(DRM_IOCTL_ARGS)
 250 {
 251         DRM_DEVICE;
 252         drm_i915_private_t *dev_priv = dev->dev_private;
 253         drm_i915_vblank_pipe_t pipe;
 254
 255         if (!dev_priv) {
 256                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 257                 return DRM_ERR(EINVAL);
 258         }
 259
 260         DRM_COPY_FROM_USER_IOCTL(pipe, (drm_i915_vblank_pipe_t __user *) data,
 261                                  sizeof(pipe));
 262
 263         dev_priv->vblank_pipe = pipe.pipe;
 264         return i915_enable_interrupt (dev);
 265 }
 266
 267 int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
 268 {
 269         DRM_DEVICE;
 270         drm_i915_private_t *dev_priv = dev->dev_private;
 271         drm_i915_vblank_pipe_t pipe;
 272         u16 flag;
 273
 274         if (!dev_priv) {
 275                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 276                 return DRM_ERR(EINVAL);
 277         }
 278
 279         flag = I915_READ(I915REG_INT_ENABLE_R);
 280         pipe.pipe = 0;
 281         if (flag & VSYNC_PIPEA_FLAG)
 282                 pipe.pipe |= DRM_I915_VBLANK_PIPE_A;
 283         if (flag & VSYNC_PIPEB_FLAG)
 284                 pipe.pipe |= DRM_I915_VBLANK_PIPE_B;
 285         DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_pipe_t __user *) data, pipe,
 286                                  sizeof(pipe));
 287         return 0;
 288 }
 289
 290 /* drm_dma.h hooks
 291 */
 292 void i915_driver_irq_preinstall(drm_device_t * dev)
 293 {
 294         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 295
 296         I915_WRITE16(I915REG_HWSTAM, 0xeffe);
 297         I915_WRITE16(I915REG_INT_MASK_R, 0x0);
 298         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
 299 }
 300
 301 void i915_driver_irq_postinstall(drm_device_t * dev)
 302 {
 303         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 304
 305         i915_enable_interrupt(dev);
 306         DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
 307
 308         /*
 309          * Initialize the hardware status page IRQ location.
 310          */
 311
 312         I915_WRITE(I915REG_INSTPM, ( 1 << 5) | ( 1 << 21));
 313 }
 314
 315 void i915_driver_irq_uninstall(drm_device_t * dev)
 316 {
 317         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 318         u16 temp;
 319         if (!dev_priv)
 320                 return;
 321
 322         dev_priv->irq_enabled = 0;
 323         I915_WRITE16(I915REG_HWSTAM, 0xffff);
 324         I915_WRITE16(I915REG_INT_MASK_R, 0xffff);
 325         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
 326
 327         temp = I915_READ16(I915REG_INT_IDENTITY_R);
 328         I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
 329 }