5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
10 * Created: Tue Feb 2 08:37:54 1999 by faith@valinux.com
12 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14 * All Rights Reserved.
16 * Permission is hereby granted, free of charge, to any person obtaining a
17 * copy of this software and associated documentation files (the "Software"),
18 * to deal in the Software without restriction, including without limitation
19 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20 * and/or sell copies of the Software, and to permit persons to whom the
21 * Software is furnished to do so, subject to the following conditions:
23 * The above copyright notice and this permission notice (including the next
24 * paragraph) shall be included in all copies or substantial portions of the
27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
30 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33 * OTHER DEALINGS IN THE SOFTWARE.
38 static int drm_lock_transfer(drm_device_t
* dev
,
39 __volatile__
unsigned int *lock
,
40 unsigned int context
);
41 static int drm_notifier(void *priv
);
46 * \param inode device inode.
47 * \param filp file pointer.
49 * \param arg user argument, pointing to a drm_lock structure.
50 * \return zero on success or negative number on failure.
52 * Add the current task to the lock wait queue, and attempt to take to lock.
54 int drm_lock(struct inode
*inode
, struct file
*filp
,
55 unsigned int cmd
, unsigned long arg
)
57 drm_file_t
*priv
= filp
->private_data
;
58 drm_device_t
*dev
= priv
->head
->dev
;
59 DECLARE_WAITQUEUE(entry
, current
);
65 if (copy_from_user(&lock
, (drm_lock_t __user
*) arg
, sizeof(lock
)))
68 if (lock
.context
== DRM_KERNEL_CONTEXT
) {
69 DRM_ERROR("Process %d using kernel context %d\n",
70 current
->pid
, lock
.context
);
74 DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
75 lock
.context
, current
->pid
,
76 dev
->lock
.hw_lock
->lock
, lock
.flags
);
78 if (drm_core_check_feature(dev
, DRIVER_DMA_QUEUE
))
82 add_wait_queue(&dev
->lock
.lock_queue
, &entry
);
84 __set_current_state(TASK_INTERRUPTIBLE
);
85 if (!dev
->lock
.hw_lock
) {
86 /* Device has been unregistered */
90 if (drm_lock_take(&dev
->lock
.hw_lock
->lock
, lock
.context
)) {
91 dev
->lock
.filp
= filp
;
92 dev
->lock
.lock_time
= jiffies
;
93 atomic_inc(&dev
->counts
[_DRM_STAT_LOCKS
]);
99 if (signal_pending(current
)) {
104 __set_current_state(TASK_RUNNING
);
105 remove_wait_queue(&dev
->lock
.lock_queue
, &entry
);
107 sigemptyset(&dev
->sigmask
);
108 sigaddset(&dev
->sigmask
, SIGSTOP
);
109 sigaddset(&dev
->sigmask
, SIGTSTP
);
110 sigaddset(&dev
->sigmask
, SIGTTIN
);
111 sigaddset(&dev
->sigmask
, SIGTTOU
);
112 dev
->sigdata
.context
= lock
.context
;
113 dev
->sigdata
.lock
= dev
->lock
.hw_lock
;
114 block_all_signals(drm_notifier
, &dev
->sigdata
, &dev
->sigmask
);
116 if (dev
->driver
->dma_ready
&& (lock
.flags
& _DRM_LOCK_READY
))
117 dev
->driver
->dma_ready(dev
);
119 if (dev
->driver
->dma_quiescent
&& (lock
.flags
& _DRM_LOCK_QUIESCENT
))
120 return dev
->driver
->dma_quiescent(dev
);
122 /* dev->driver->kernel_context_switch isn't used by any of the x86
123 * drivers but is used by the Sparc driver.
126 if (dev
->driver
->kernel_context_switch
&&
127 dev
->last_context
!= lock
.context
) {
128 dev
->driver
->kernel_context_switch(dev
, dev
->last_context
,
131 DRM_DEBUG("%d %s\n", lock
.context
, ret
? "interrupted" : "has lock");
139 * \param inode device inode.
140 * \param filp file pointer.
141 * \param cmd command.
142 * \param arg user argument, pointing to a drm_lock structure.
143 * \return zero on success or negative number on failure.
145 * Transfer and free the lock.
147 int drm_unlock(struct inode
*inode
, struct file
*filp
,
148 unsigned int cmd
, unsigned long arg
)
150 drm_file_t
*priv
= filp
->private_data
;
151 drm_device_t
*dev
= priv
->head
->dev
;
154 if (copy_from_user(&lock
, (drm_lock_t __user
*) arg
, sizeof(lock
)))
157 if (lock
.context
== DRM_KERNEL_CONTEXT
) {
158 DRM_ERROR("Process %d using kernel context %d\n",
159 current
->pid
, lock
.context
);
163 atomic_inc(&dev
->counts
[_DRM_STAT_UNLOCKS
]);
165 /* kernel_context_switch isn't used by any of the x86 drm
166 * modules but is required by the Sparc driver.
168 if (dev
->driver
->kernel_context_switch_unlock
)
169 dev
->driver
->kernel_context_switch_unlock(dev
, &lock
);
171 drm_lock_transfer(dev
, &dev
->lock
.hw_lock
->lock
,
174 if (drm_lock_free(dev
, &dev
->lock
.hw_lock
->lock
,
175 DRM_KERNEL_CONTEXT
)) {
180 unblock_all_signals();
185 * Take the heavyweight lock.
187 * \param lock lock pointer.
188 * \param context locking context.
189 * \return one if the lock is held, or zero otherwise.
191 * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
193 int drm_lock_take(__volatile__
unsigned int *lock
, unsigned int context
)
195 unsigned int old
, new, prev
;
199 if (old
& _DRM_LOCK_HELD
)
200 new = old
| _DRM_LOCK_CONT
;
202 new = context
| _DRM_LOCK_HELD
;
203 prev
= cmpxchg(lock
, old
, new);
204 } while (prev
!= old
);
205 if (_DRM_LOCKING_CONTEXT(old
) == context
) {
206 if (old
& _DRM_LOCK_HELD
) {
207 if (context
!= DRM_KERNEL_CONTEXT
) {
208 DRM_ERROR("%d holds heavyweight lock\n",
214 if (new == (context
| _DRM_LOCK_HELD
)) {
222 * This takes a lock forcibly and hands it to context. Should ONLY be used
223 * inside *_unlock to give lock to kernel before calling *_dma_schedule.
225 * \param dev DRM device.
226 * \param lock lock pointer.
227 * \param context locking context.
228 * \return always one.
230 * Resets the lock file pointer.
231 * Marks the lock as held by the given context, via the \p cmpxchg instruction.
233 static int drm_lock_transfer(drm_device_t
* dev
,
234 __volatile__
unsigned int *lock
,
235 unsigned int context
)
237 unsigned int old
, new, prev
;
239 dev
->lock
.filp
= NULL
;
242 new = context
| _DRM_LOCK_HELD
;
243 prev
= cmpxchg(lock
, old
, new);
244 } while (prev
!= old
);
251 * \param dev DRM device.
253 * \param context context.
255 * Resets the lock file pointer.
256 * Marks the lock as not held, via the \p cmpxchg instruction. Wakes any task
257 * waiting on the lock queue.
259 int drm_lock_free(drm_device_t
* dev
,
260 __volatile__
unsigned int *lock
, unsigned int context
)
262 unsigned int old
, new, prev
;
264 dev
->lock
.filp
= NULL
;
268 prev
= cmpxchg(lock
, old
, new);
269 } while (prev
!= old
);
270 if (_DRM_LOCK_IS_HELD(old
) && _DRM_LOCKING_CONTEXT(old
) != context
) {
271 DRM_ERROR("%d freed heavyweight lock held by %d\n",
272 context
, _DRM_LOCKING_CONTEXT(old
));
275 wake_up_interruptible(&dev
->lock
.lock_queue
);
280 * If we get here, it means that the process has called DRM_IOCTL_LOCK
281 * without calling DRM_IOCTL_UNLOCK.
283 * If the lock is not held, then let the signal proceed as usual. If the lock
284 * is held, then set the contended flag and keep the signal blocked.
286 * \param priv pointer to a drm_sigdata structure.
287 * \return one if the signal should be delivered normally, or zero if the
288 * signal should be blocked.
290 static int drm_notifier(void *priv
)
292 drm_sigdata_t
*s
= (drm_sigdata_t
*) priv
;
293 unsigned int old
, new, prev
;
295 /* Allow signal delivery if lock isn't held */
296 if (!s
->lock
|| !_DRM_LOCK_IS_HELD(s
->lock
->lock
)
297 || _DRM_LOCKING_CONTEXT(s
->lock
->lock
) != s
->context
)
300 /* Otherwise, set flag to force call to
304 new = old
| _DRM_LOCK_CONT
;
305 prev
= cmpxchg(&s
->lock
->lock
, old
, new);
306 } while (prev
!= old
);