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_notifier(void *priv);
40
static int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
45
* \param inode device inode.
46
* \param file_priv DRM file private.
48
* \param arg user argument, pointing to a drm_lock structure.
49
* \return zero on success or negative number on failure.
51
* Add the current task to the lock wait queue, and attempt to take to lock.
53
int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
55
DECLARE_WAITQUEUE(entry, current);
56
struct drm_lock *lock = data;
57
struct drm_master *master = file_priv->master;
60
++file_priv->lock_count;
62
if (lock->context == DRM_KERNEL_CONTEXT) {
63
DRM_ERROR("Process %d using kernel context %d\n",
64
task_pid_nr(current), lock->context);
68
DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
69
lock->context, task_pid_nr(current),
70
master->lock.hw_lock->lock, lock->flags);
72
if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE))
73
if (lock->context < 0)
76
add_wait_queue(&master->lock.lock_queue, &entry);
77
spin_lock_bh(&master->lock.spinlock);
78
master->lock.user_waiters++;
79
spin_unlock_bh(&master->lock.spinlock);
82
__set_current_state(TASK_INTERRUPTIBLE);
83
if (!master->lock.hw_lock) {
84
/* Device has been unregistered */
85
send_sig(SIGTERM, current, 0);
89
if (drm_lock_take(&master->lock, lock->context)) {
90
master->lock.file_priv = file_priv;
91
master->lock.lock_time = jiffies;
92
atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
97
mutex_unlock(&drm_global_mutex);
99
mutex_lock(&drm_global_mutex);
100
if (signal_pending(current)) {
105
spin_lock_bh(&master->lock.spinlock);
106
master->lock.user_waiters--;
107
spin_unlock_bh(&master->lock.spinlock);
108
__set_current_state(TASK_RUNNING);
109
remove_wait_queue(&master->lock.lock_queue, &entry);
111
DRM_DEBUG("%d %s\n", lock->context,
112
ret ? "interrupted" : "has lock");
115
/* don't set the block all signals on the master process for now
116
* really probably not the correct answer but lets us debug xkb
118
if (!file_priv->is_master) {
119
sigemptyset(&dev->sigmask);
120
sigaddset(&dev->sigmask, SIGSTOP);
121
sigaddset(&dev->sigmask, SIGTSTP);
122
sigaddset(&dev->sigmask, SIGTTIN);
123
sigaddset(&dev->sigmask, SIGTTOU);
124
dev->sigdata.context = lock->context;
125
dev->sigdata.lock = master->lock.hw_lock;
126
block_all_signals(drm_notifier, &dev->sigdata, &dev->sigmask);
129
if (dev->driver->dma_quiescent && (lock->flags & _DRM_LOCK_QUIESCENT))
131
if (dev->driver->dma_quiescent(dev)) {
132
DRM_DEBUG("%d waiting for DMA quiescent\n",
144
* \param inode device inode.
145
* \param file_priv DRM file private.
146
* \param cmd command.
147
* \param arg user argument, pointing to a drm_lock structure.
148
* \return zero on success or negative number on failure.
150
* Transfer and free the lock.
152
int drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
154
struct drm_lock *lock = data;
155
struct drm_master *master = file_priv->master;
157
if (lock->context == DRM_KERNEL_CONTEXT) {
158
DRM_ERROR("Process %d using kernel context %d\n",
159
task_pid_nr(current), lock->context);
163
atomic_inc(&dev->counts[_DRM_STAT_UNLOCKS]);
165
if (drm_lock_free(&master->lock, lock->context)) {
166
/* FIXME: Should really bail out here. */
169
unblock_all_signals();
174
* Take the heavyweight lock.
176
* \param lock lock pointer.
177
* \param context locking context.
178
* \return one if the lock is held, or zero otherwise.
180
* Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
183
int drm_lock_take(struct drm_lock_data *lock_data,
184
unsigned int context)
186
unsigned int old, new, prev;
187
volatile unsigned int *lock = &lock_data->hw_lock->lock;
189
spin_lock_bh(&lock_data->spinlock);
192
if (old & _DRM_LOCK_HELD)
193
new = old | _DRM_LOCK_CONT;
195
new = context | _DRM_LOCK_HELD |
196
((lock_data->user_waiters + lock_data->kernel_waiters > 1) ?
199
prev = cmpxchg(lock, old, new);
200
} while (prev != old);
201
spin_unlock_bh(&lock_data->spinlock);
203
if (_DRM_LOCKING_CONTEXT(old) == context) {
204
if (old & _DRM_LOCK_HELD) {
205
if (context != DRM_KERNEL_CONTEXT) {
206
DRM_ERROR("%d holds heavyweight lock\n",
213
if ((_DRM_LOCKING_CONTEXT(new)) == context && (new & _DRM_LOCK_HELD)) {
221
* This takes a lock forcibly and hands it to context. Should ONLY be used
222
* inside *_unlock to give lock to kernel before calling *_dma_schedule.
224
* \param dev DRM device.
225
* \param lock lock pointer.
226
* \param context locking context.
227
* \return always one.
229
* Resets the lock file pointer.
230
* Marks the lock as held by the given context, via the \p cmpxchg instruction.
232
static int drm_lock_transfer(struct drm_lock_data *lock_data,
233
unsigned int context)
235
unsigned int old, new, prev;
236
volatile unsigned int *lock = &lock_data->hw_lock->lock;
238
lock_data->file_priv = NULL;
241
new = context | _DRM_LOCK_HELD;
242
prev = cmpxchg(lock, old, new);
243
} while (prev != old);
250
* \param dev DRM device.
252
* \param context context.
254
* Resets the lock file pointer.
255
* Marks the lock as not held, via the \p cmpxchg instruction. Wakes any task
256
* waiting on the lock queue.
258
int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context)
260
unsigned int old, new, prev;
261
volatile unsigned int *lock = &lock_data->hw_lock->lock;
263
spin_lock_bh(&lock_data->spinlock);
264
if (lock_data->kernel_waiters != 0) {
265
drm_lock_transfer(lock_data, 0);
266
lock_data->idle_has_lock = 1;
267
spin_unlock_bh(&lock_data->spinlock);
270
spin_unlock_bh(&lock_data->spinlock);
274
new = _DRM_LOCKING_CONTEXT(old);
275
prev = cmpxchg(lock, old, new);
276
} while (prev != old);
278
if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) {
279
DRM_ERROR("%d freed heavyweight lock held by %d\n",
280
context, _DRM_LOCKING_CONTEXT(old));
283
wake_up_interruptible(&lock_data->lock_queue);
288
* If we get here, it means that the process has called DRM_IOCTL_LOCK
289
* without calling DRM_IOCTL_UNLOCK.
291
* If the lock is not held, then let the signal proceed as usual. If the lock
292
* is held, then set the contended flag and keep the signal blocked.
294
* \param priv pointer to a drm_sigdata structure.
295
* \return one if the signal should be delivered normally, or zero if the
296
* signal should be blocked.
298
static int drm_notifier(void *priv)
300
struct drm_sigdata *s = (struct drm_sigdata *) priv;
301
unsigned int old, new, prev;
303
/* Allow signal delivery if lock isn't held */
304
if (!s->lock || !_DRM_LOCK_IS_HELD(s->lock->lock)
305
|| _DRM_LOCKING_CONTEXT(s->lock->lock) != s->context)
308
/* Otherwise, set flag to force call to
312
new = old | _DRM_LOCK_CONT;
313
prev = cmpxchg(&s->lock->lock, old, new);
314
} while (prev != old);
319
* This function returns immediately and takes the hw lock
320
* with the kernel context if it is free, otherwise it gets the highest priority when and if
321
* it is eventually released.
323
* This guarantees that the kernel will _eventually_ have the lock _unless_ it is held
324
* by a blocked process. (In the latter case an explicit wait for the hardware lock would cause
325
* a deadlock, which is why the "idlelock" was invented).
327
* This should be sufficient to wait for GPU idle without
328
* having to worry about starvation.
331
void drm_idlelock_take(struct drm_lock_data *lock_data)
335
spin_lock_bh(&lock_data->spinlock);
336
lock_data->kernel_waiters++;
337
if (!lock_data->idle_has_lock) {
339
spin_unlock_bh(&lock_data->spinlock);
340
ret = drm_lock_take(lock_data, DRM_KERNEL_CONTEXT);
341
spin_lock_bh(&lock_data->spinlock);
344
lock_data->idle_has_lock = 1;
346
spin_unlock_bh(&lock_data->spinlock);
349
void drm_idlelock_release(struct drm_lock_data *lock_data)
351
unsigned int old, prev;
352
volatile unsigned int *lock = &lock_data->hw_lock->lock;
354
spin_lock_bh(&lock_data->spinlock);
355
if (--lock_data->kernel_waiters == 0) {
356
if (lock_data->idle_has_lock) {
359
prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT);
360
} while (prev != old);
361
wake_up_interruptible(&lock_data->lock_queue);
362
lock_data->idle_has_lock = 0;
365
spin_unlock_bh(&lock_data->spinlock);
368
int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv)
370
struct drm_master *master = file_priv->master;
371
return (file_priv->lock_count && master->lock.hw_lock &&
372
_DRM_LOCK_IS_HELD(master->lock.hw_lock->lock) &&
373
master->lock.file_priv == file_priv);