6a218ad0bf23ee2d2c4bcbfd5ccd750f7a7f96d3
[mesa.git] / src / etnaviv / drm / etnaviv_cmd_stream.c
1 /*
2 * Copyright (C) 2014-2015 Etnaviv Project
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 *
23 * Authors:
24 * Christian Gmeiner <christian.gmeiner@gmail.com>
25 */
26
27 #include <assert.h>
28
29 #include "etnaviv_drmif.h"
30 #include "etnaviv_priv.h"
31
32 static pthread_mutex_t idx_lock = PTHREAD_MUTEX_INITIALIZER;
33
34 static void *grow(void *ptr, uint32_t nr, uint32_t *max, uint32_t sz)
35 {
36 if ((nr + 1) > *max) {
37 if ((*max * 2) < (nr + 1))
38 *max = nr + 5;
39 else
40 *max = *max * 2;
41 ptr = realloc(ptr, *max * sz);
42 }
43
44 return ptr;
45 }
46
47 #define APPEND(x, name) ({ \
48 (x)->name = grow((x)->name, (x)->nr_ ## name, &(x)->max_ ## name, sizeof((x)->name[0])); \
49 (x)->nr_ ## name ++; \
50 })
51
52 static inline struct etna_cmd_stream_priv *
53 etna_cmd_stream_priv(struct etna_cmd_stream *stream)
54 {
55 return (struct etna_cmd_stream_priv *)stream;
56 }
57
58 struct etna_cmd_stream *etna_cmd_stream_new(struct etna_pipe *pipe,
59 uint32_t size,
60 void (*force_flush)(struct etna_cmd_stream *stream, void *priv),
61 void *priv)
62 {
63 struct etna_cmd_stream_priv *stream = NULL;
64
65 if (size == 0) {
66 ERROR_MSG("invalid size of 0");
67 goto fail;
68 }
69
70 stream = calloc(1, sizeof(*stream));
71 if (!stream) {
72 ERROR_MSG("allocation failed");
73 goto fail;
74 }
75
76 /* allocate even number of 32-bit words */
77 size = ALIGN(size, 2);
78
79 stream->base.buffer = malloc(size * sizeof(uint32_t));
80 if (!stream->base.buffer) {
81 ERROR_MSG("allocation failed");
82 goto fail;
83 }
84
85 stream->base.size = size;
86 stream->pipe = pipe;
87 stream->force_flush = force_flush;
88 stream->force_flush_priv = priv;
89
90 return &stream->base;
91
92 fail:
93 if (stream)
94 etna_cmd_stream_del(&stream->base);
95
96 return NULL;
97 }
98
99 void etna_cmd_stream_del(struct etna_cmd_stream *stream)
100 {
101 struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
102
103 free(stream->buffer);
104 free(priv->submit.relocs);
105 free(priv->submit.pmrs);
106 free(priv);
107 }
108
109 void etna_cmd_stream_force_flush(struct etna_cmd_stream *stream)
110 {
111 struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
112
113 if (priv->force_flush)
114 priv->force_flush(stream, priv->force_flush_priv);
115 }
116
117 uint32_t etna_cmd_stream_timestamp(struct etna_cmd_stream *stream)
118 {
119 return etna_cmd_stream_priv(stream)->last_timestamp;
120 }
121
122 static uint32_t append_bo(struct etna_cmd_stream *stream, struct etna_bo *bo)
123 {
124 struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
125 uint32_t idx;
126
127 idx = APPEND(&priv->submit, bos);
128 idx = APPEND(priv, bos);
129
130 priv->submit.bos[idx].flags = 0;
131 priv->submit.bos[idx].handle = bo->handle;
132
133 priv->bos[idx] = etna_bo_ref(bo);
134
135 return idx;
136 }
137
138 /* add (if needed) bo, return idx: */
139 static uint32_t bo2idx(struct etna_cmd_stream *stream, struct etna_bo *bo,
140 uint32_t flags)
141 {
142 struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
143 uint32_t idx;
144
145 pthread_mutex_lock(&idx_lock);
146
147 if (bo->current_stream == stream) {
148 idx = bo->idx;
149 } else {
150 void *val;
151
152 if (!priv->bo_table)
153 priv->bo_table = drmHashCreate();
154
155 if (!drmHashLookup(priv->bo_table, bo->handle, &val)) {
156 /* found */
157 idx = (uint32_t)(uintptr_t)val;
158 } else {
159 idx = append_bo(stream, bo);
160 val = (void *)(uintptr_t)idx;
161 drmHashInsert(priv->bo_table, bo->handle, val);
162 }
163
164 bo->current_stream = stream;
165 bo->idx = idx;
166 }
167 pthread_mutex_unlock(&idx_lock);
168
169 if (flags & ETNA_RELOC_READ)
170 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_READ;
171 if (flags & ETNA_RELOC_WRITE)
172 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_WRITE;
173
174 return idx;
175 }
176
177 void etna_cmd_stream_flush(struct etna_cmd_stream *stream, int in_fence_fd,
178 int *out_fence_fd)
179 {
180 struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
181 int ret, id = priv->pipe->id;
182 struct etna_gpu *gpu = priv->pipe->gpu;
183
184 struct drm_etnaviv_gem_submit req = {
185 .pipe = gpu->core,
186 .exec_state = id,
187 .bos = VOID2U64(priv->submit.bos),
188 .nr_bos = priv->submit.nr_bos,
189 .relocs = VOID2U64(priv->submit.relocs),
190 .nr_relocs = priv->submit.nr_relocs,
191 .pmrs = VOID2U64(priv->submit.pmrs),
192 .nr_pmrs = priv->submit.nr_pmrs,
193 .stream = VOID2U64(stream->buffer),
194 .stream_size = stream->offset * 4, /* in bytes */
195 };
196
197 if (in_fence_fd != -1) {
198 req.flags |= ETNA_SUBMIT_FENCE_FD_IN | ETNA_SUBMIT_NO_IMPLICIT;
199 req.fence_fd = in_fence_fd;
200 }
201
202 if (out_fence_fd)
203 req.flags |= ETNA_SUBMIT_FENCE_FD_OUT;
204
205 ret = drmCommandWriteRead(gpu->dev->fd, DRM_ETNAVIV_GEM_SUBMIT,
206 &req, sizeof(req));
207
208 if (ret)
209 ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno));
210 else
211 priv->last_timestamp = req.fence;
212
213 for (uint32_t i = 0; i < priv->nr_bos; i++) {
214 struct etna_bo *bo = priv->bos[i];
215
216 bo->current_stream = NULL;
217 etna_bo_del(bo);
218 }
219
220 if (priv->bo_table) {
221 drmHashDestroy(priv->bo_table);
222 priv->bo_table = NULL;
223 }
224
225 if (out_fence_fd)
226 *out_fence_fd = req.fence_fd;
227
228 stream->offset = 0;
229 priv->submit.nr_bos = 0;
230 priv->submit.nr_relocs = 0;
231 priv->submit.nr_pmrs = 0;
232 priv->nr_bos = 0;
233 }
234
235 void etna_cmd_stream_reloc(struct etna_cmd_stream *stream,
236 const struct etna_reloc *r)
237 {
238 struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
239 struct drm_etnaviv_gem_submit_reloc *reloc;
240 uint32_t idx = APPEND(&priv->submit, relocs);
241 uint32_t addr = 0;
242
243 reloc = &priv->submit.relocs[idx];
244
245 reloc->reloc_idx = bo2idx(stream, r->bo, r->flags);
246 reloc->reloc_offset = r->offset;
247 reloc->submit_offset = stream->offset * 4; /* in bytes */
248 reloc->flags = 0;
249
250 etna_cmd_stream_emit(stream, addr);
251 }
252
253 void etna_cmd_stream_perf(struct etna_cmd_stream *stream, const struct etna_perf *p)
254 {
255 struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
256 struct drm_etnaviv_gem_submit_pmr *pmr;
257 uint32_t idx = APPEND(&priv->submit, pmrs);
258
259 pmr = &priv->submit.pmrs[idx];
260
261 pmr->flags = p->flags;
262 pmr->sequence = p->sequence;
263 pmr->read_offset = p->offset;
264 pmr->read_idx = bo2idx(stream, p->bo, ETNA_SUBMIT_BO_READ | ETNA_SUBMIT_BO_WRITE);
265 pmr->domain = p->signal->domain->id;
266 pmr->signal = p->signal->signal;
267 }