Commit | Line | Data |
---|---|---|
1802d0be | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
7bf60c52 CK |
2 | /* |
3 | * fence-chain: chain fences together in a timeline | |
4 | * | |
5 | * Copyright (C) 2018 Advanced Micro Devices, Inc. | |
6 | * Authors: | |
7 | * Christian König <christian.koenig@amd.com> | |
7bf60c52 CK |
8 | */ |
9 | ||
10 | #ifndef __LINUX_DMA_FENCE_CHAIN_H | |
11 | #define __LINUX_DMA_FENCE_CHAIN_H | |
12 | ||
13 | #include <linux/dma-fence.h> | |
14 | #include <linux/irq_work.h> | |
440d0f12 | 15 | #include <linux/slab.h> |
7bf60c52 CK |
16 | |
17 | /** | |
18 | * struct dma_fence_chain - fence to represent an node of a fence chain | |
19 | * @base: fence base class | |
7bf60c52 CK |
20 | * @prev: previous fence of the chain |
21 | * @prev_seqno: original previous seqno before garbage collection | |
22 | * @fence: encapsulated fence | |
9c61e789 | 23 | * @lock: spinlock for fence handling |
7bf60c52 CK |
24 | */ |
25 | struct dma_fence_chain { | |
26 | struct dma_fence base; | |
7bf60c52 CK |
27 | struct dma_fence __rcu *prev; |
28 | u64 prev_seqno; | |
29 | struct dma_fence *fence; | |
9c61e789 CK |
30 | union { |
31 | /** | |
32 | * @cb: callback for signaling | |
33 | * | |
34 | * This is used to add the callback for signaling the | |
35 | * complection of the fence chain. Never used at the same time | |
36 | * as the irq work. | |
37 | */ | |
38 | struct dma_fence_cb cb; | |
39 | ||
40 | /** | |
41 | * @work: irq work item for signaling | |
42 | * | |
43 | * Irq work structure to allow us to add the callback without | |
44 | * running into lock inversion. Never used at the same time as | |
45 | * the callback. | |
46 | */ | |
47 | struct irq_work work; | |
48 | }; | |
49 | spinlock_t lock; | |
7bf60c52 CK |
50 | }; |
51 | ||
7bf60c52 CK |
52 | |
53 | /** | |
54 | * to_dma_fence_chain - cast a fence to a dma_fence_chain | |
55 | * @fence: fence to cast to a dma_fence_array | |
56 | * | |
57 | * Returns NULL if the fence is not a dma_fence_chain, | |
58 | * or the dma_fence_chain otherwise. | |
59 | */ | |
60 | static inline struct dma_fence_chain * | |
61 | to_dma_fence_chain(struct dma_fence *fence) | |
62 | { | |
976b6d97 | 63 | if (!fence || !dma_fence_is_chain(fence)) |
7bf60c52 CK |
64 | return NULL; |
65 | ||
66 | return container_of(fence, struct dma_fence_chain, base); | |
67 | } | |
68 | ||
18f5fad2 CK |
69 | /** |
70 | * dma_fence_chain_contained - return the contained fence | |
71 | * @fence: the fence to test | |
72 | * | |
73 | * If the fence is a dma_fence_chain the function returns the fence contained | |
74 | * inside the chain object, otherwise it returns the fence itself. | |
75 | */ | |
76 | static inline struct dma_fence * | |
77 | dma_fence_chain_contained(struct dma_fence *fence) | |
78 | { | |
79 | struct dma_fence_chain *chain = to_dma_fence_chain(fence); | |
80 | ||
81 | return chain ? chain->fence : fence; | |
82 | } | |
83 | ||
440d0f12 CK |
84 | /** |
85 | * dma_fence_chain_alloc | |
86 | * | |
87 | * Returns a new struct dma_fence_chain object or NULL on failure. | |
88 | */ | |
89 | static inline struct dma_fence_chain *dma_fence_chain_alloc(void) | |
90 | { | |
91 | return kmalloc(sizeof(struct dma_fence_chain), GFP_KERNEL); | |
92 | }; | |
93 | ||
94 | /** | |
95 | * dma_fence_chain_free | |
96 | * @chain: chain node to free | |
97 | * | |
98 | * Frees up an allocated but not used struct dma_fence_chain object. This | |
99 | * doesn't need an RCU grace period since the fence was never initialized nor | |
100 | * published. After dma_fence_chain_init() has been called the fence must be | |
101 | * released by calling dma_fence_put(), and not through this function. | |
102 | */ | |
103 | static inline void dma_fence_chain_free(struct dma_fence_chain *chain) | |
104 | { | |
105 | kfree(chain); | |
106 | }; | |
107 | ||
7bf60c52 CK |
108 | /** |
109 | * dma_fence_chain_for_each - iterate over all fences in chain | |
110 | * @iter: current fence | |
111 | * @head: starting point | |
112 | * | |
113 | * Iterate over all fences in the chain. We keep a reference to the current | |
114 | * fence while inside the loop which must be dropped when breaking out. | |
64a8f92f CK |
115 | * |
116 | * For a deep dive iterator see dma_fence_unwrap_for_each(). | |
7bf60c52 CK |
117 | */ |
118 | #define dma_fence_chain_for_each(iter, head) \ | |
119 | for (iter = dma_fence_get(head); iter; \ | |
120 | iter = dma_fence_chain_walk(iter)) | |
121 | ||
122 | struct dma_fence *dma_fence_chain_walk(struct dma_fence *fence); | |
123 | int dma_fence_chain_find_seqno(struct dma_fence **pfence, uint64_t seqno); | |
124 | void dma_fence_chain_init(struct dma_fence_chain *chain, | |
125 | struct dma_fence *prev, | |
126 | struct dma_fence *fence, | |
127 | uint64_t seqno); | |
128 | ||
129 | #endif /* __LINUX_DMA_FENCE_CHAIN_H */ |