]> git.karo-electronics.de Git - mv-sheeva.git/blob - drivers/gpu/drm/drm_lock.c
drm/i915: Only bind to function 0 of the PCI device
[mv-sheeva.git] / drivers / gpu / drm / drm_lock.c
1 /**
2  * \file drm_lock.c
3  * IOCTLs for locking
4  *
5  * \author Rickard E. (Rik) Faith <faith@valinux.com>
6  * \author Gareth Hughes <gareth@valinux.com>
7  */
8
9 /*
10  * Created: Tue Feb  2 08:37:54 1999 by faith@valinux.com
11  *
12  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
13  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14  * All Rights Reserved.
15  *
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:
22  *
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
25  * Software.
26  *
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.
34  */
35
36 #include "drmP.h"
37
38 static int drm_notifier(void *priv);
39
40 static int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
41
42 /**
43  * Lock ioctl.
44  *
45  * \param inode device inode.
46  * \param file_priv DRM file private.
47  * \param cmd command.
48  * \param arg user argument, pointing to a drm_lock structure.
49  * \return zero on success or negative number on failure.
50  *
51  * Add the current task to the lock wait queue, and attempt to take to lock.
52  */
53 int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
54 {
55         DECLARE_WAITQUEUE(entry, current);
56         struct drm_lock *lock = data;
57         struct drm_master *master = file_priv->master;
58         int ret = 0;
59
60         ++file_priv->lock_count;
61
62         if (lock->context == DRM_KERNEL_CONTEXT) {
63                 DRM_ERROR("Process %d using kernel context %d\n",
64                           task_pid_nr(current), lock->context);
65                 return -EINVAL;
66         }
67
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);
71
72         if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE))
73                 if (lock->context < 0)
74                         return -EINVAL;
75
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);
80
81         for (;;) {
82                 __set_current_state(TASK_INTERRUPTIBLE);
83                 if (!master->lock.hw_lock) {
84                         /* Device has been unregistered */
85                         send_sig(SIGTERM, current, 0);
86                         ret = -EINTR;
87                         break;
88                 }
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]);
93                         break;  /* Got lock */
94                 }
95
96                 /* Contention */
97                 mutex_unlock(&drm_global_mutex);
98                 schedule();
99                 mutex_lock(&drm_global_mutex);
100                 if (signal_pending(current)) {
101                         ret = -EINTR;
102                         break;
103                 }
104         }
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);
110
111         DRM_DEBUG("%d %s\n", lock->context,
112                   ret ? "interrupted" : "has lock");
113         if (ret) return ret;
114
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
117          * xserver for now */
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);
127         }
128
129         if (dev->driver->dma_quiescent && (lock->flags & _DRM_LOCK_QUIESCENT))
130         {
131                 if (dev->driver->dma_quiescent(dev)) {
132                         DRM_DEBUG("%d waiting for DMA quiescent\n",
133                                   lock->context);
134                         return -EBUSY;
135                 }
136         }
137
138         return 0;
139 }
140
141 /**
142  * Unlock ioctl.
143  *
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.
149  *
150  * Transfer and free the lock.
151  */
152 int drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
153 {
154         struct drm_lock *lock = data;
155         struct drm_master *master = file_priv->master;
156
157         if (lock->context == DRM_KERNEL_CONTEXT) {
158                 DRM_ERROR("Process %d using kernel context %d\n",
159                           task_pid_nr(current), lock->context);
160                 return -EINVAL;
161         }
162
163         atomic_inc(&dev->counts[_DRM_STAT_UNLOCKS]);
164
165         if (drm_lock_free(&master->lock, lock->context)) {
166                 /* FIXME: Should really bail out here. */
167         }
168
169         unblock_all_signals();
170         return 0;
171 }
172
173 /**
174  * Take the heavyweight lock.
175  *
176  * \param lock lock pointer.
177  * \param context locking context.
178  * \return one if the lock is held, or zero otherwise.
179  *
180  * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
181  */
182 static
183 int drm_lock_take(struct drm_lock_data *lock_data,
184                   unsigned int context)
185 {
186         unsigned int old, new, prev;
187         volatile unsigned int *lock = &lock_data->hw_lock->lock;
188
189         spin_lock_bh(&lock_data->spinlock);
190         do {
191                 old = *lock;
192                 if (old & _DRM_LOCK_HELD)
193                         new = old | _DRM_LOCK_CONT;
194                 else {
195                         new = context | _DRM_LOCK_HELD |
196                                 ((lock_data->user_waiters + lock_data->kernel_waiters > 1) ?
197                                  _DRM_LOCK_CONT : 0);
198                 }
199                 prev = cmpxchg(lock, old, new);
200         } while (prev != old);
201         spin_unlock_bh(&lock_data->spinlock);
202
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",
207                                           context);
208                         }
209                         return 0;
210                 }
211         }
212
213         if ((_DRM_LOCKING_CONTEXT(new)) == context && (new & _DRM_LOCK_HELD)) {
214                 /* Have lock */
215                 return 1;
216         }
217         return 0;
218 }
219
220 /**
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.
223  *
224  * \param dev DRM device.
225  * \param lock lock pointer.
226  * \param context locking context.
227  * \return always one.
228  *
229  * Resets the lock file pointer.
230  * Marks the lock as held by the given context, via the \p cmpxchg instruction.
231  */
232 static int drm_lock_transfer(struct drm_lock_data *lock_data,
233                              unsigned int context)
234 {
235         unsigned int old, new, prev;
236         volatile unsigned int *lock = &lock_data->hw_lock->lock;
237
238         lock_data->file_priv = NULL;
239         do {
240                 old = *lock;
241                 new = context | _DRM_LOCK_HELD;
242                 prev = cmpxchg(lock, old, new);
243         } while (prev != old);
244         return 1;
245 }
246
247 /**
248  * Free lock.
249  *
250  * \param dev DRM device.
251  * \param lock lock.
252  * \param context context.
253  *
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.
257  */
258 int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context)
259 {
260         unsigned int old, new, prev;
261         volatile unsigned int *lock = &lock_data->hw_lock->lock;
262
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);
268                 return 1;
269         }
270         spin_unlock_bh(&lock_data->spinlock);
271
272         do {
273                 old = *lock;
274                 new = _DRM_LOCKING_CONTEXT(old);
275                 prev = cmpxchg(lock, old, new);
276         } while (prev != old);
277
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));
281                 return 1;
282         }
283         wake_up_interruptible(&lock_data->lock_queue);
284         return 0;
285 }
286
287 /**
288  * If we get here, it means that the process has called DRM_IOCTL_LOCK
289  * without calling DRM_IOCTL_UNLOCK.
290  *
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.
293  *
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.
297  */
298 static int drm_notifier(void *priv)
299 {
300         struct drm_sigdata *s = (struct drm_sigdata *) priv;
301         unsigned int old, new, prev;
302
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)
306                 return 1;
307
308         /* Otherwise, set flag to force call to
309            drmUnlock */
310         do {
311                 old = s->lock->lock;
312                 new = old | _DRM_LOCK_CONT;
313                 prev = cmpxchg(&s->lock->lock, old, new);
314         } while (prev != old);
315         return 0;
316 }
317
318 /**
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.
322  *
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).
326  *
327  * This should be sufficient to wait for GPU idle without
328  * having to worry about starvation.
329  */
330
331 void drm_idlelock_take(struct drm_lock_data *lock_data)
332 {
333         int ret = 0;
334
335         spin_lock_bh(&lock_data->spinlock);
336         lock_data->kernel_waiters++;
337         if (!lock_data->idle_has_lock) {
338
339                 spin_unlock_bh(&lock_data->spinlock);
340                 ret = drm_lock_take(lock_data, DRM_KERNEL_CONTEXT);
341                 spin_lock_bh(&lock_data->spinlock);
342
343                 if (ret == 1)
344                         lock_data->idle_has_lock = 1;
345         }
346         spin_unlock_bh(&lock_data->spinlock);
347 }
348
349 void drm_idlelock_release(struct drm_lock_data *lock_data)
350 {
351         unsigned int old, prev;
352         volatile unsigned int *lock = &lock_data->hw_lock->lock;
353
354         spin_lock_bh(&lock_data->spinlock);
355         if (--lock_data->kernel_waiters == 0) {
356                 if (lock_data->idle_has_lock) {
357                         do {
358                                 old = *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;
363                 }
364         }
365         spin_unlock_bh(&lock_data->spinlock);
366 }
367
368 int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv)
369 {
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);
374 }