← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/gpu/drm/i830/i830_irq.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/gpu/drm/i830/i830_irq.c
1
 
/* i830_dma.c -- DMA support for the I830 -*- linux-c -*-
2
 
 *
3
 
 * Copyright 2002 Tungsten Graphics, Inc.
4
 
 * All Rights Reserved.
5
 
 *
6
 
 * Permission is hereby granted, free of charge, to any person obtaining a
7
 
 * copy of this software and associated documentation files (the "Software"),
8
 
 * to deal in the Software without restriction, including without limitation
9
 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10
 
 * and/or sell copies of the Software, and to permit persons to whom the
11
 
 * Software is furnished to do so, subject to the following conditions:
12
 
 *
13
 
 * The above copyright notice and this permission notice (including the next
14
 
 * paragraph) shall be included in all copies or substantial portions of the
15
 
 * Software.
16
 
 *
17
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18
 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20
 
 * TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21
 
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22
 
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23
 
 * DEALINGS IN THE SOFTWARE.
24
 
 *
25
 
 * Authors: Keith Whitwell <keith@tungstengraphics.com>
26
 
 *
27
 
 */
28
 
 
29
 
#include "drmP.h"
30
 
#include "drm.h"
31
 
#include "i830_drm.h"
32
 
#include "i830_drv.h"
33
 
#include <linux/interrupt.h>    /* For task queue support */
34
 
#include <linux/delay.h>
35
 
 
36
 
irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS)
37
 
{
38
 
        struct drm_device *dev = (struct drm_device *) arg;
39
 
        drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
40
 
        u16 temp;
41
 
 
42
 
        temp = I830_READ16(I830REG_INT_IDENTITY_R);
43
 
        DRM_DEBUG("%x\n", temp);
44
 
 
45
 
        if (!(temp & 2))
46
 
                return IRQ_NONE;
47
 
 
48
 
        I830_WRITE16(I830REG_INT_IDENTITY_R, temp);
49
 
 
50
 
        atomic_inc(&dev_priv->irq_received);
51
 
        wake_up_interruptible(&dev_priv->irq_queue);
52
 
 
53
 
        return IRQ_HANDLED;
54
 
}
55
 
 
56
 
static int i830_emit_irq(struct drm_device *dev)
57
 
{
58
 
        drm_i830_private_t *dev_priv = dev->dev_private;
59
 
        RING_LOCALS;
60
 
 
61
 
        DRM_DEBUG("%s\n", __func__);
62
 
 
63
 
        atomic_inc(&dev_priv->irq_emitted);
64
 
 
65
 
        BEGIN_LP_RING(2);
66
 
        OUT_RING(0);
67
 
        OUT_RING(GFX_OP_USER_INTERRUPT);
68
 
        ADVANCE_LP_RING();
69
 
 
70
 
        return atomic_read(&dev_priv->irq_emitted);
71
 
}
72
 
 
73
 
static int i830_wait_irq(struct drm_device *dev, int irq_nr)
74
 
{
75
 
        drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
76
 
        DECLARE_WAITQUEUE(entry, current);
77
 
        unsigned long end = jiffies + HZ * 3;
78
 
        int ret = 0;
79
 
 
80
 
        DRM_DEBUG("%s\n", __func__);
81
 
 
82
 
        if (atomic_read(&dev_priv->irq_received) >= irq_nr)
83
 
                return 0;
84
 
 
85
 
        dev_priv->sarea_priv->perf_boxes |= I830_BOX_WAIT;
86
 
 
87
 
        add_wait_queue(&dev_priv->irq_queue, &entry);
88
 
 
89
 
        for (;;) {
90
 
                __set_current_state(TASK_INTERRUPTIBLE);
91
 
                if (atomic_read(&dev_priv->irq_received) >= irq_nr)
92
 
                        break;
93
 
                if ((signed)(end - jiffies) <= 0) {
94
 
                        DRM_ERROR("timeout iir %x imr %x ier %x hwstam %x\n",
95
 
                                  I830_READ16(I830REG_INT_IDENTITY_R),
96
 
                                  I830_READ16(I830REG_INT_MASK_R),
97
 
                                  I830_READ16(I830REG_INT_ENABLE_R),
98
 
                                  I830_READ16(I830REG_HWSTAM));
99
 
 
100
 
                        ret = -EBUSY;   /* Lockup?  Missed irq? */
101
 
                        break;
102
 
                }
103
 
                schedule_timeout(HZ * 3);
104
 
                if (signal_pending(current)) {
105
 
                        ret = -EINTR;
106
 
                        break;
107
 
                }
108
 
        }
109
 
 
110
 
        __set_current_state(TASK_RUNNING);
111
 
        remove_wait_queue(&dev_priv->irq_queue, &entry);
112
 
        return ret;
113
 
}
114
 
 
115
 
/* Needs the lock as it touches the ring.
116
 
 */
117
 
int i830_irq_emit(struct drm_device *dev, void *data,
118
 
                  struct drm_file *file_priv)
119
 
{
120
 
        drm_i830_private_t *dev_priv = dev->dev_private;
121
 
        drm_i830_irq_emit_t *emit = data;
122
 
        int result;
123
 
 
124
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
125
 
 
126
 
        if (!dev_priv) {
127
 
                DRM_ERROR("%s called with no initialization\n", __func__);
128
 
                return -EINVAL;
129
 
        }
130
 
 
131
 
        result = i830_emit_irq(dev);
132
 
 
133
 
        if (copy_to_user(emit->irq_seq, &result, sizeof(int))) {
134
 
                DRM_ERROR("copy_to_user\n");
135
 
                return -EFAULT;
136
 
        }
137
 
 
138
 
        return 0;
139
 
}
140
 
 
141
 
/* Doesn't need the hardware lock.
142
 
 */
143
 
int i830_irq_wait(struct drm_device *dev, void *data,
144
 
                  struct drm_file *file_priv)
145
 
{
146
 
        drm_i830_private_t *dev_priv = dev->dev_private;
147
 
        drm_i830_irq_wait_t *irqwait = data;
148
 
 
149
 
        if (!dev_priv) {
150
 
                DRM_ERROR("%s called with no initialization\n", __func__);
151
 
                return -EINVAL;
152
 
        }
153
 
 
154
 
        return i830_wait_irq(dev, irqwait->irq_seq);
155
 
}
156
 
 
157
 
/* drm_dma.h hooks
158
 
*/
159
 
void i830_driver_irq_preinstall(struct drm_device *dev)
160
 
{
161
 
        drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
162
 
 
163
 
        I830_WRITE16(I830REG_HWSTAM, 0xffff);
164
 
        I830_WRITE16(I830REG_INT_MASK_R, 0x0);
165
 
        I830_WRITE16(I830REG_INT_ENABLE_R, 0x0);
166
 
        atomic_set(&dev_priv->irq_received, 0);
167
 
        atomic_set(&dev_priv->irq_emitted, 0);
168
 
        init_waitqueue_head(&dev_priv->irq_queue);
169
 
}
170
 
 
171
 
void i830_driver_irq_postinstall(struct drm_device *dev)
172
 
{
173
 
        drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
174
 
 
175
 
        I830_WRITE16(I830REG_INT_ENABLE_R, 0x2);
176
 
}
177
 
 
178
 
void i830_driver_irq_uninstall(struct drm_device *dev)
179
 
{
180
 
        drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
181
 
        if (!dev_priv)
182
 
                return;
183
 
 
184
 
        I830_WRITE16(I830REG_INT_MASK_R, 0xffff);
185
 
        I830_WRITE16(I830REG_INT_ENABLE_R, 0x0);
186
 
}