This source file includes following definitions.
- dma_fence_array_get_driver_name
- dma_fence_array_get_timeline_name
- dma_fence_array_set_pending_error
- dma_fence_array_clear_pending_error
- irq_dma_fence_array_work
- dma_fence_array_cb_func
- dma_fence_array_enable_signaling
- dma_fence_array_signaled
- dma_fence_array_release
- dma_fence_array_create
- dma_fence_match_context
1
2
3
4
5
6
7
8
9
10
11
12 #include <linux/export.h>
13 #include <linux/slab.h>
14 #include <linux/dma-fence-array.h>
15
16 #define PENDING_ERROR 1
17
18 static const char *dma_fence_array_get_driver_name(struct dma_fence *fence)
19 {
20 return "dma_fence_array";
21 }
22
23 static const char *dma_fence_array_get_timeline_name(struct dma_fence *fence)
24 {
25 return "unbound";
26 }
27
28 static void dma_fence_array_set_pending_error(struct dma_fence_array *array,
29 int error)
30 {
31
32
33
34
35 if (error)
36 cmpxchg(&array->base.error, PENDING_ERROR, error);
37 }
38
39 static void dma_fence_array_clear_pending_error(struct dma_fence_array *array)
40 {
41
42 cmpxchg(&array->base.error, PENDING_ERROR, 0);
43 }
44
45 static void irq_dma_fence_array_work(struct irq_work *wrk)
46 {
47 struct dma_fence_array *array = container_of(wrk, typeof(*array), work);
48
49 dma_fence_array_clear_pending_error(array);
50
51 dma_fence_signal(&array->base);
52 dma_fence_put(&array->base);
53 }
54
55 static void dma_fence_array_cb_func(struct dma_fence *f,
56 struct dma_fence_cb *cb)
57 {
58 struct dma_fence_array_cb *array_cb =
59 container_of(cb, struct dma_fence_array_cb, cb);
60 struct dma_fence_array *array = array_cb->array;
61
62 dma_fence_array_set_pending_error(array, f->error);
63
64 if (atomic_dec_and_test(&array->num_pending))
65 irq_work_queue(&array->work);
66 else
67 dma_fence_put(&array->base);
68 }
69
70 static bool dma_fence_array_enable_signaling(struct dma_fence *fence)
71 {
72 struct dma_fence_array *array = to_dma_fence_array(fence);
73 struct dma_fence_array_cb *cb = (void *)(&array[1]);
74 unsigned i;
75
76 for (i = 0; i < array->num_fences; ++i) {
77 cb[i].array = array;
78
79
80
81
82
83
84
85
86 dma_fence_get(&array->base);
87 if (dma_fence_add_callback(array->fences[i], &cb[i].cb,
88 dma_fence_array_cb_func)) {
89 int error = array->fences[i]->error;
90
91 dma_fence_array_set_pending_error(array, error);
92 dma_fence_put(&array->base);
93 if (atomic_dec_and_test(&array->num_pending)) {
94 dma_fence_array_clear_pending_error(array);
95 return false;
96 }
97 }
98 }
99
100 return true;
101 }
102
103 static bool dma_fence_array_signaled(struct dma_fence *fence)
104 {
105 struct dma_fence_array *array = to_dma_fence_array(fence);
106
107 return atomic_read(&array->num_pending) <= 0;
108 }
109
110 static void dma_fence_array_release(struct dma_fence *fence)
111 {
112 struct dma_fence_array *array = to_dma_fence_array(fence);
113 unsigned i;
114
115 for (i = 0; i < array->num_fences; ++i)
116 dma_fence_put(array->fences[i]);
117
118 kfree(array->fences);
119 dma_fence_free(fence);
120 }
121
122 const struct dma_fence_ops dma_fence_array_ops = {
123 .get_driver_name = dma_fence_array_get_driver_name,
124 .get_timeline_name = dma_fence_array_get_timeline_name,
125 .enable_signaling = dma_fence_array_enable_signaling,
126 .signaled = dma_fence_array_signaled,
127 .release = dma_fence_array_release,
128 };
129 EXPORT_SYMBOL(dma_fence_array_ops);
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150 struct dma_fence_array *dma_fence_array_create(int num_fences,
151 struct dma_fence **fences,
152 u64 context, unsigned seqno,
153 bool signal_on_any)
154 {
155 struct dma_fence_array *array;
156 size_t size = sizeof(*array);
157
158
159 size += num_fences * sizeof(struct dma_fence_array_cb);
160 array = kzalloc(size, GFP_KERNEL);
161 if (!array)
162 return NULL;
163
164 spin_lock_init(&array->lock);
165 dma_fence_init(&array->base, &dma_fence_array_ops, &array->lock,
166 context, seqno);
167 init_irq_work(&array->work, irq_dma_fence_array_work);
168
169 array->num_fences = num_fences;
170 atomic_set(&array->num_pending, signal_on_any ? 1 : num_fences);
171 array->fences = fences;
172
173 array->base.error = PENDING_ERROR;
174
175 return array;
176 }
177 EXPORT_SYMBOL(dma_fence_array_create);
178
179
180
181
182
183
184
185
186
187
188 bool dma_fence_match_context(struct dma_fence *fence, u64 context)
189 {
190 struct dma_fence_array *array = to_dma_fence_array(fence);
191 unsigned i;
192
193 if (!dma_fence_is_array(fence))
194 return fence->context == context;
195
196 for (i = 0; i < array->num_fences; i++) {
197 if (array->fences[i]->context != context)
198 return false;
199 }
200
201 return true;
202 }
203 EXPORT_SYMBOL(dma_fence_match_context);