1 /* $NetBSD: ttm_lock.c,v 1.3 2022/02/17 01:21:02 riastradh Exp $ */
2
3 /* SPDX-License-Identifier: GPL-2.0 OR MIT */
4 /**************************************************************************
5 *
6 * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA
7 * All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the
11 * "Software"), to deal in the Software without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sub license, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
16 *
17 * The above copyright notice and this permission notice (including the
18 * next paragraph) shall be included in all copies or substantial portions
19 * of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
24 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
25 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
26 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
27 * USE OR OTHER DEALINGS IN THE SOFTWARE.
28 *
29 **************************************************************************/
30 /*
31 * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
32 */
33
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: ttm_lock.c,v 1.3 2022/02/17 01:21:02 riastradh Exp $");
36
37 #include <linux/atomic.h>
38 #include <linux/errno.h>
39 #include <linux/wait.h>
40 #include <linux/sched/signal.h>
41 #include "ttm_lock.h"
42 #include "ttm_object.h"
43
44 #define TTM_WRITE_LOCK_PENDING (1 << 0)
45 #define TTM_VT_LOCK_PENDING (1 << 1)
46 #define TTM_SUSPEND_LOCK_PENDING (1 << 2)
47 #define TTM_VT_LOCK (1 << 3)
48 #define TTM_SUSPEND_LOCK (1 << 4)
49
ttm_lock_init(struct ttm_lock * lock)50 void ttm_lock_init(struct ttm_lock *lock)
51 {
52 spin_lock_init(&lock->lock);
53 DRM_INIT_WAITQUEUE(&lock->queue, "ttmlock");
54 lock->rw = 0;
55 lock->flags = 0;
56 }
57
ttm_read_unlock(struct ttm_lock * lock)58 void ttm_read_unlock(struct ttm_lock *lock)
59 {
60 spin_lock(&lock->lock);
61 if (--lock->rw == 0)
62 DRM_SPIN_WAKEUP_ALL(&lock->queue, &lock->lock);
63 spin_unlock(&lock->lock);
64 }
65
__ttm_read_lock(struct ttm_lock * lock)66 static bool __ttm_read_lock(struct ttm_lock *lock)
67 {
68 bool locked = false;
69
70 if (lock->rw >= 0 && lock->flags == 0) {
71 ++lock->rw;
72 locked = true;
73 }
74 return locked;
75 }
76
ttm_read_lock(struct ttm_lock * lock,bool interruptible)77 int ttm_read_lock(struct ttm_lock *lock, bool interruptible)
78 {
79 int ret = 0;
80
81 spin_lock(&lock->lock);
82 if (interruptible)
83 DRM_SPIN_WAIT_UNTIL(ret, &lock->queue, &lock->lock,
84 __ttm_read_lock(lock));
85 else
86 DRM_SPIN_WAIT_NOINTR_UNTIL(ret, &lock->queue, &lock->lock,
87 __ttm_read_lock(lock));
88 spin_unlock(&lock->lock);
89
90 return ret;
91 }
92
__ttm_read_trylock(struct ttm_lock * lock,bool * locked)93 static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
94 {
95 bool block = true;
96
97 *locked = false;
98
99 spin_lock(&lock->lock);
100 if (lock->rw >= 0 && lock->flags == 0) {
101 ++lock->rw;
102 block = false;
103 *locked = true;
104 } else if (lock->flags == 0) {
105 block = false;
106 }
107 spin_unlock(&lock->lock);
108
109 return !block;
110 }
111
ttm_read_trylock(struct ttm_lock * lock,bool interruptible)112 int ttm_read_trylock(struct ttm_lock *lock, bool interruptible)
113 {
114 int ret = 0;
115 bool locked;
116
117 spin_lock(&lock->lock);
118 if (interruptible)
119 DRM_SPIN_WAIT_UNTIL(ret, &lock->queue, &lock->lock,
120 __ttm_read_trylock(lock, &locked));
121 else
122 DRM_SPIN_WAIT_NOINTR_UNTIL(ret, &lock->queue, &lock->lock,
123 __ttm_read_trylock(lock, &locked));
124 spin_unlock(&lock->lock);
125
126 if (unlikely(ret != 0)) {
127 BUG_ON(locked);
128 return ret;
129 }
130
131 return (locked) ? 0 : -EBUSY;
132 }
133
ttm_write_unlock(struct ttm_lock * lock)134 void ttm_write_unlock(struct ttm_lock *lock)
135 {
136 spin_lock(&lock->lock);
137 lock->rw = 0;
138 DRM_SPIN_WAKEUP_ALL(&lock->queue, &lock->lock);
139 spin_unlock(&lock->lock);
140 }
141
__ttm_write_lock(struct ttm_lock * lock)142 static bool __ttm_write_lock(struct ttm_lock *lock)
143 {
144 bool locked = false;
145
146 spin_lock(&lock->lock);
147 if (lock->rw == 0 && ((lock->flags & ~TTM_WRITE_LOCK_PENDING) == 0)) {
148 lock->rw = -1;
149 lock->flags &= ~TTM_WRITE_LOCK_PENDING;
150 locked = true;
151 } else {
152 lock->flags |= TTM_WRITE_LOCK_PENDING;
153 }
154 spin_unlock(&lock->lock);
155 return locked;
156 }
157
ttm_write_lock(struct ttm_lock * lock,bool interruptible)158 int ttm_write_lock(struct ttm_lock *lock, bool interruptible)
159 {
160 int ret = 0;
161
162 spin_lock(&lock->lock);
163 if (interruptible) {
164 DRM_SPIN_WAIT_UNTIL(ret, &lock->queue, &lock->lock,
165 __ttm_write_lock(lock));
166 if (unlikely(ret != 0)) {
167 lock->flags &= ~TTM_WRITE_LOCK_PENDING;
168 DRM_SPIN_WAKEUP_ONE(&lock->queue, &lock->lock);
169 }
170 } else
171 DRM_SPIN_WAIT_NOINTR_UNTIL(ret, &lock->queue, &lock->lock,
172 __ttm_write_lock(lock));
173 spin_unlock(&lock->lock);
174
175 return ret;
176 }
177
ttm_suspend_unlock(struct ttm_lock * lock)178 void ttm_suspend_unlock(struct ttm_lock *lock)
179 {
180 spin_lock(&lock->lock);
181 lock->flags &= ~TTM_SUSPEND_LOCK;
182 DRM_SPIN_WAKEUP_ALL(&lock->queue, &lock->lock);
183 spin_unlock(&lock->lock);
184 }
185
__ttm_suspend_lock(struct ttm_lock * lock)186 static bool __ttm_suspend_lock(struct ttm_lock *lock)
187 {
188 bool locked = false;
189
190 if (lock->rw == 0) {
191 lock->flags &= ~TTM_SUSPEND_LOCK_PENDING;
192 lock->flags |= TTM_SUSPEND_LOCK;
193 locked = true;
194 } else {
195 lock->flags |= TTM_SUSPEND_LOCK_PENDING;
196 }
197 return locked;
198 }
199
ttm_suspend_lock(struct ttm_lock * lock)200 void ttm_suspend_lock(struct ttm_lock *lock)
201 {
202 int ret;
203
204 spin_lock(&lock->lock);
205 DRM_SPIN_WAIT_UNTIL(ret, &lock->queue, &lock->lock,
206 __ttm_suspend_lock(lock));
207 spin_unlock(&lock->lock);
208 }
209