Remove obsolete #include <linux/config.h>
[linux-3.10.git] / drivers / char / drm / 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
62         if (temp & (VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG)) {
63                 atomic_inc(&dev->vbl_received);
64                 DRM_WAKEUP(&dev->vbl_queue);
65                 drm_vbl_send_signals(dev);
66         }
67
68         return IRQ_HANDLED;
69 }
70
71 static int i915_emit_irq(drm_device_t * dev)
72 {
73         drm_i915_private_t *dev_priv = dev->dev_private;
74         u32 ret;
75         RING_LOCALS;
76
77         i915_kernel_lost_context(dev);
78
79         DRM_DEBUG("%s\n", __FUNCTION__);
80
81         ret = dev_priv->counter;
82
83         BEGIN_LP_RING(2);
84         OUT_RING(0);
85         OUT_RING(GFX_OP_USER_INTERRUPT);
86         ADVANCE_LP_RING();
87
88         return ret;
89 }
90
91 static int i915_wait_irq(drm_device_t * dev, int irq_nr)
92 {
93         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
94         int ret = 0;
95
96         DRM_DEBUG("%s irq_nr=%d breadcrumb=%d\n", __FUNCTION__, irq_nr,
97                   READ_BREADCRUMB(dev_priv));
98
99         if (READ_BREADCRUMB(dev_priv) >= irq_nr)
100                 return 0;
101
102         dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
103
104         DRM_WAIT_ON(ret, dev_priv->irq_queue, 3 * DRM_HZ,
105                     READ_BREADCRUMB(dev_priv) >= irq_nr);
106
107         if (ret == DRM_ERR(EBUSY)) {
108                 DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n",
109                           __FUNCTION__,
110                           READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
111         }
112
113         dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
114         return ret;
115 }
116
117 int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
118 {
119         drm_i915_private_t *dev_priv = dev->dev_private;
120         unsigned int cur_vblank;
121         int ret = 0;
122
123         if (!dev_priv) {
124                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
125                 return DRM_ERR(EINVAL);
126         }
127
128         DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
129                     (((cur_vblank = atomic_read(&dev->vbl_received))
130                         - *sequence) <= (1<<23)));
131         
132         *sequence = cur_vblank;
133
134         return ret;
135 }
136
137
138 /* Needs the lock as it touches the ring.
139  */
140 int i915_irq_emit(DRM_IOCTL_ARGS)
141 {
142         DRM_DEVICE;
143         drm_i915_private_t *dev_priv = dev->dev_private;
144         drm_i915_irq_emit_t emit;
145         int result;
146
147         LOCK_TEST_WITH_RETURN(dev, filp);
148
149         if (!dev_priv) {
150                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
151                 return DRM_ERR(EINVAL);
152         }
153
154         DRM_COPY_FROM_USER_IOCTL(emit, (drm_i915_irq_emit_t __user *) data,
155                                  sizeof(emit));
156
157         result = i915_emit_irq(dev);
158
159         if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {
160                 DRM_ERROR("copy_to_user\n");
161                 return DRM_ERR(EFAULT);
162         }
163
164         return 0;
165 }
166
167 /* Doesn't need the hardware lock.
168  */
169 int i915_irq_wait(DRM_IOCTL_ARGS)
170 {
171         DRM_DEVICE;
172         drm_i915_private_t *dev_priv = dev->dev_private;
173         drm_i915_irq_wait_t irqwait;
174
175         if (!dev_priv) {
176                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
177                 return DRM_ERR(EINVAL);
178         }
179
180         DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_i915_irq_wait_t __user *) data,
181                                  sizeof(irqwait));
182
183         return i915_wait_irq(dev, irqwait.irq_seq);
184 }
185
186 static int i915_enable_interrupt (drm_device_t *dev)
187 {
188         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
189         u16 flag;
190
191         flag = 0;
192         if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_A)
193                 flag |= VSYNC_PIPEA_FLAG;
194         if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
195                 flag |= VSYNC_PIPEB_FLAG;
196         if (dev_priv->vblank_pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
197                 DRM_ERROR("%s called with invalid pipe 0x%x\n",
198                           __FUNCTION__, dev_priv->vblank_pipe);
199                 return DRM_ERR(EINVAL);
200         }
201         I915_WRITE16(I915REG_INT_ENABLE_R, USER_INT_FLAG | flag);
202         return 0;
203 }
204
205 /* Set the vblank monitor pipe
206  */
207 int i915_vblank_pipe_set(DRM_IOCTL_ARGS)
208 {
209         DRM_DEVICE;
210         drm_i915_private_t *dev_priv = dev->dev_private;
211         drm_i915_vblank_pipe_t pipe;
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(pipe, (drm_i915_vblank_pipe_t __user *) data,
219                                  sizeof(pipe));
220
221         dev_priv->vblank_pipe = pipe.pipe;
222         return i915_enable_interrupt (dev);
223 }
224
225 int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
226 {
227         DRM_DEVICE;
228         drm_i915_private_t *dev_priv = dev->dev_private;
229         drm_i915_vblank_pipe_t pipe;
230         u16 flag;
231
232         if (!dev_priv) {
233                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
234                 return DRM_ERR(EINVAL);
235         }
236
237         flag = I915_READ(I915REG_INT_ENABLE_R);
238         pipe.pipe = 0;
239         if (flag & VSYNC_PIPEA_FLAG)
240                 pipe.pipe |= DRM_I915_VBLANK_PIPE_A;
241         if (flag & VSYNC_PIPEB_FLAG)
242                 pipe.pipe |= DRM_I915_VBLANK_PIPE_B;
243         DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_pipe_t __user *) data, pipe,
244                                  sizeof(pipe));
245         return 0;
246 }
247
248 /* drm_dma.h hooks
249 */
250 void i915_driver_irq_preinstall(drm_device_t * dev)
251 {
252         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
253
254         I915_WRITE16(I915REG_HWSTAM, 0xfffe);
255         I915_WRITE16(I915REG_INT_MASK_R, 0x0);
256         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
257 }
258
259 void i915_driver_irq_postinstall(drm_device_t * dev)
260 {
261         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
262
263         i915_enable_interrupt(dev);
264         DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
265 }
266
267 void i915_driver_irq_uninstall(drm_device_t * dev)
268 {
269         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
270         u16 temp;
271
272         if (!dev_priv)
273                 return;
274
275         I915_WRITE16(I915REG_HWSTAM, 0xffff);
276         I915_WRITE16(I915REG_INT_MASK_R, 0xffff);
277         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
278
279         temp = I915_READ16(I915REG_INT_IDENTITY_R);
280         I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
281 }