2 * (C) Copyright 2016 Intel Corporation
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; version 2
10 #include <linux/slab.h>
11 #include <linux/dma-fence.h>
12 #include <linux/reservation.h>
14 #include "i915_sw_fence.h"
15 #include "i915_selftest.h"
17 #define I915_SW_FENCE_FLAG_ALLOC BIT(3) /* after WQ_FLAG_* for safety */
19 static DEFINE_SPINLOCK(i915_sw_fence_lock);
26 #ifdef CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS
28 static void *i915_sw_fence_debug_hint(void *addr)
30 return (void *)(((struct i915_sw_fence *)addr)->flags & I915_SW_FENCE_MASK);
33 static struct debug_obj_descr i915_sw_fence_debug_descr = {
34 .name = "i915_sw_fence",
35 .debug_hint = i915_sw_fence_debug_hint,
38 static inline void debug_fence_init(struct i915_sw_fence *fence)
40 debug_object_init(fence, &i915_sw_fence_debug_descr);
43 static inline void debug_fence_activate(struct i915_sw_fence *fence)
45 debug_object_activate(fence, &i915_sw_fence_debug_descr);
48 static inline void debug_fence_set_state(struct i915_sw_fence *fence,
51 debug_object_active_state(fence, &i915_sw_fence_debug_descr, old, new);
54 static inline void debug_fence_deactivate(struct i915_sw_fence *fence)
56 debug_object_deactivate(fence, &i915_sw_fence_debug_descr);
59 static inline void debug_fence_destroy(struct i915_sw_fence *fence)
61 debug_object_destroy(fence, &i915_sw_fence_debug_descr);
64 static inline void debug_fence_free(struct i915_sw_fence *fence)
66 debug_object_free(fence, &i915_sw_fence_debug_descr);
67 smp_wmb(); /* flush the change in state before reallocation */
70 static inline void debug_fence_assert(struct i915_sw_fence *fence)
72 debug_object_assert_init(fence, &i915_sw_fence_debug_descr);
77 static inline void debug_fence_init(struct i915_sw_fence *fence)
81 static inline void debug_fence_activate(struct i915_sw_fence *fence)
85 static inline void debug_fence_set_state(struct i915_sw_fence *fence,
90 static inline void debug_fence_deactivate(struct i915_sw_fence *fence)
94 static inline void debug_fence_destroy(struct i915_sw_fence *fence)
98 static inline void debug_fence_free(struct i915_sw_fence *fence)
102 static inline void debug_fence_assert(struct i915_sw_fence *fence)
108 static int __i915_sw_fence_notify(struct i915_sw_fence *fence,
109 enum i915_sw_fence_notify state)
111 i915_sw_fence_notify_t fn;
113 fn = (i915_sw_fence_notify_t)(fence->flags & I915_SW_FENCE_MASK);
114 return fn(fence, state);
117 #ifdef CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS
118 void i915_sw_fence_fini(struct i915_sw_fence *fence)
120 debug_fence_free(fence);
124 static void __i915_sw_fence_wake_up_all(struct i915_sw_fence *fence,
125 struct list_head *continuation)
127 wait_queue_head_t *x = &fence->wait;
128 wait_queue_entry_t *pos, *next;
131 debug_fence_deactivate(fence);
132 atomic_set_release(&fence->pending, -1); /* 0 -> -1 [done] */
135 * To prevent unbounded recursion as we traverse the graph of
136 * i915_sw_fences, we move the entry list from this, the next ready
137 * fence, to the tail of the original fence's entry list
138 * (and so added to the list to be woken).
141 spin_lock_irqsave_nested(&x->lock, flags, 1 + !!continuation);
143 list_for_each_entry_safe(pos, next, &x->head, entry) {
144 if (pos->func == autoremove_wake_function)
145 pos->func(pos, TASK_NORMAL, 0, continuation);
147 list_move_tail(&pos->entry, continuation);
153 list_for_each_entry_safe(pos, next, &x->head, entry)
154 pos->func(pos, TASK_NORMAL, 0, &extra);
156 if (list_empty(&extra))
159 list_splice_tail_init(&extra, &x->head);
162 spin_unlock_irqrestore(&x->lock, flags);
164 debug_fence_assert(fence);
167 static void __i915_sw_fence_complete(struct i915_sw_fence *fence,
168 struct list_head *continuation)
170 debug_fence_assert(fence);
172 if (!atomic_dec_and_test(&fence->pending))
175 debug_fence_set_state(fence, DEBUG_FENCE_IDLE, DEBUG_FENCE_NOTIFY);
177 if (__i915_sw_fence_notify(fence, FENCE_COMPLETE) != NOTIFY_DONE)
180 debug_fence_set_state(fence, DEBUG_FENCE_NOTIFY, DEBUG_FENCE_IDLE);
182 __i915_sw_fence_wake_up_all(fence, continuation);
184 debug_fence_destroy(fence);
185 __i915_sw_fence_notify(fence, FENCE_FREE);
188 static void i915_sw_fence_complete(struct i915_sw_fence *fence)
190 debug_fence_assert(fence);
192 if (WARN_ON(i915_sw_fence_done(fence)))
195 __i915_sw_fence_complete(fence, NULL);
198 static void i915_sw_fence_await(struct i915_sw_fence *fence)
200 debug_fence_assert(fence);
201 WARN_ON(atomic_inc_return(&fence->pending) <= 1);
204 void __i915_sw_fence_init(struct i915_sw_fence *fence,
205 i915_sw_fence_notify_t fn,
207 struct lock_class_key *key)
209 BUG_ON(!fn || (unsigned long)fn & ~I915_SW_FENCE_MASK);
211 debug_fence_init(fence);
213 __init_waitqueue_head(&fence->wait, name, key);
214 atomic_set(&fence->pending, 1);
215 fence->flags = (unsigned long)fn;
218 void i915_sw_fence_commit(struct i915_sw_fence *fence)
220 debug_fence_activate(fence);
221 i915_sw_fence_complete(fence);
224 static int i915_sw_fence_wake(wait_queue_entry_t *wq, unsigned mode, int flags, void *key)
226 list_del(&wq->entry);
227 __i915_sw_fence_complete(wq->private, key);
229 if (wq->flags & I915_SW_FENCE_FLAG_ALLOC)
234 static bool __i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
235 const struct i915_sw_fence * const signaler)
237 wait_queue_entry_t *wq;
239 if (__test_and_set_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
242 if (fence == signaler)
245 list_for_each_entry(wq, &fence->wait.head, entry) {
246 if (wq->func != i915_sw_fence_wake)
249 if (__i915_sw_fence_check_if_after(wq->private, signaler))
256 static void __i915_sw_fence_clear_checked_bit(struct i915_sw_fence *fence)
258 wait_queue_entry_t *wq;
260 if (!__test_and_clear_bit(I915_SW_FENCE_CHECKED_BIT, &fence->flags))
263 list_for_each_entry(wq, &fence->wait.head, entry) {
264 if (wq->func != i915_sw_fence_wake)
267 __i915_sw_fence_clear_checked_bit(wq->private);
271 static bool i915_sw_fence_check_if_after(struct i915_sw_fence *fence,
272 const struct i915_sw_fence * const signaler)
277 if (!IS_ENABLED(CONFIG_DRM_I915_SW_FENCE_CHECK_DAG))
280 spin_lock_irqsave(&i915_sw_fence_lock, flags);
281 err = __i915_sw_fence_check_if_after(fence, signaler);
282 __i915_sw_fence_clear_checked_bit(fence);
283 spin_unlock_irqrestore(&i915_sw_fence_lock, flags);
288 static int __i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
289 struct i915_sw_fence *signaler,
290 wait_queue_entry_t *wq, gfp_t gfp)
295 debug_fence_assert(fence);
297 if (i915_sw_fence_done(signaler))
300 debug_fence_assert(signaler);
302 /* The dependency graph must be acyclic. */
303 if (unlikely(i915_sw_fence_check_if_after(fence, signaler)))
308 wq = kmalloc(sizeof(*wq), gfp);
310 if (!gfpflags_allow_blocking(gfp))
313 i915_sw_fence_wait(signaler);
317 pending |= I915_SW_FENCE_FLAG_ALLOC;
320 INIT_LIST_HEAD(&wq->entry);
322 wq->func = i915_sw_fence_wake;
325 i915_sw_fence_await(fence);
327 spin_lock_irqsave(&signaler->wait.lock, flags);
328 if (likely(!i915_sw_fence_done(signaler))) {
329 __add_wait_queue_entry_tail(&signaler->wait, wq);
332 i915_sw_fence_wake(wq, 0, 0, NULL);
335 spin_unlock_irqrestore(&signaler->wait.lock, flags);
340 int i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
341 struct i915_sw_fence *signaler,
342 wait_queue_entry_t *wq)
344 return __i915_sw_fence_await_sw_fence(fence, signaler, wq, 0);
347 int i915_sw_fence_await_sw_fence_gfp(struct i915_sw_fence *fence,
348 struct i915_sw_fence *signaler,
351 return __i915_sw_fence_await_sw_fence(fence, signaler, NULL, gfp);
354 struct i915_sw_dma_fence_cb {
355 struct dma_fence_cb base;
356 struct i915_sw_fence *fence;
357 struct dma_fence *dma;
358 struct timer_list timer;
361 static void timer_i915_sw_fence_wake(unsigned long data)
363 struct i915_sw_dma_fence_cb *cb = (struct i915_sw_dma_fence_cb *)data;
365 pr_warn("asynchronous wait on fence %s:%s:%x timed out\n",
366 cb->dma->ops->get_driver_name(cb->dma),
367 cb->dma->ops->get_timeline_name(cb->dma),
369 dma_fence_put(cb->dma);
372 i915_sw_fence_complete(cb->fence);
373 cb->timer.function = NULL;
376 static void dma_i915_sw_fence_wake(struct dma_fence *dma,
377 struct dma_fence_cb *data)
379 struct i915_sw_dma_fence_cb *cb = container_of(data, typeof(*cb), base);
381 del_timer_sync(&cb->timer);
382 if (cb->timer.function)
383 i915_sw_fence_complete(cb->fence);
384 dma_fence_put(cb->dma);
389 int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
390 struct dma_fence *dma,
391 unsigned long timeout,
394 struct i915_sw_dma_fence_cb *cb;
397 debug_fence_assert(fence);
399 if (dma_fence_is_signaled(dma))
402 cb = kmalloc(sizeof(*cb), gfp);
404 if (!gfpflags_allow_blocking(gfp))
407 return dma_fence_wait(dma, false);
411 i915_sw_fence_await(fence);
414 __setup_timer(&cb->timer,
415 timer_i915_sw_fence_wake, (unsigned long)cb,
418 cb->dma = dma_fence_get(dma);
419 mod_timer(&cb->timer, round_jiffies_up(jiffies + timeout));
422 ret = dma_fence_add_callback(dma, &cb->base, dma_i915_sw_fence_wake);
426 dma_i915_sw_fence_wake(dma, &cb->base);
427 if (ret == -ENOENT) /* fence already signaled */
434 int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
435 struct reservation_object *resv,
436 const struct dma_fence_ops *exclude,
438 unsigned long timeout,
441 struct dma_fence *excl;
442 int ret = 0, pending;
444 debug_fence_assert(fence);
447 struct dma_fence **shared;
448 unsigned int count, i;
450 ret = reservation_object_get_fences_rcu(resv,
451 &excl, &count, &shared);
455 for (i = 0; i < count; i++) {
456 if (shared[i]->ops == exclude)
459 pending = i915_sw_fence_await_dma_fence(fence,
471 for (i = 0; i < count; i++)
472 dma_fence_put(shared[i]);
475 excl = reservation_object_get_excl_rcu(resv);
478 if (ret >= 0 && excl && excl->ops != exclude) {
479 pending = i915_sw_fence_await_dma_fence(fence,
494 #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
495 #include "selftests/i915_sw_fence.c"