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 #include <stdlib.h>
29 
30 #include "etnaviv_drmif.h"
31 #include "etnaviv_priv.h"
32 
33 static simple_mtx_t idx_lock = _SIMPLE_MTX_INITIALIZER_NP;
34 
grow(void * ptr,uint32_t nr,uint32_t * max,uint32_t sz)35 static void *grow(void *ptr, uint32_t nr, uint32_t *max, uint32_t sz)
36 {
37 	if ((nr + 1) > *max) {
38 		if ((*max * 2) < (nr + 1))
39 			*max = nr + 5;
40 		else
41 			*max = *max * 2;
42 		ptr = realloc(ptr, *max * sz);
43 	}
44 
45 	return ptr;
46 }
47 
48 #define APPEND(x, name) ({ \
49 	(x)->name = grow((x)->name, (x)->nr_ ## name, &(x)->max_ ## name, sizeof((x)->name[0])); \
50 	(x)->nr_ ## name ++; \
51 })
52 
etna_cmd_stream_realloc(struct etna_cmd_stream * stream,size_t n)53 void etna_cmd_stream_realloc(struct etna_cmd_stream *stream, size_t n)
54 {
55 	size_t size;
56 	void *buffer;
57 
58 	/*
59 	 * Increase the command buffer size by 4 kiB. Here we pick 4 kiB
60 	 * increment to prevent it from growing too much too quickly.
61 	 */
62 	size = ALIGN(stream->size + n, 1024);
63 
64 	/* Command buffer is too big for older kernel versions */
65 	if (size > 0x4000)
66 		goto error;
67 
68 	buffer = realloc(stream->buffer, size * 4);
69 	if (!buffer)
70 		goto error;
71 
72 	stream->buffer = buffer;
73 	stream->size = size;
74 
75 	return;
76 
77 error:
78 	DEBUG_MSG("command buffer too long, forcing flush.");
79 	etna_cmd_stream_force_flush(stream);
80 }
81 
82 static inline struct etna_cmd_stream_priv *
etna_cmd_stream_priv(struct etna_cmd_stream * stream)83 etna_cmd_stream_priv(struct etna_cmd_stream *stream)
84 {
85     return (struct etna_cmd_stream_priv *)stream;
86 }
87 
etna_cmd_stream_new(struct etna_pipe * pipe,uint32_t size,void (* force_flush)(struct etna_cmd_stream * stream,void * priv),void * priv)88 struct etna_cmd_stream *etna_cmd_stream_new(struct etna_pipe *pipe,
89         uint32_t size,
90 		void (*force_flush)(struct etna_cmd_stream *stream, void *priv),
91 		void *priv)
92 {
93 	struct etna_cmd_stream_priv *stream = NULL;
94 
95 	if (size == 0) {
96 		ERROR_MSG("invalid size of 0");
97 		goto fail;
98 	}
99 
100 	stream = calloc(1, sizeof(*stream));
101 	if (!stream) {
102 		ERROR_MSG("allocation failed");
103 		goto fail;
104 	}
105 
106 	/* allocate even number of 32-bit words */
107 	size = ALIGN(size, 2);
108 
109 	stream->base.buffer = malloc(size * sizeof(uint32_t));
110 	if (!stream->base.buffer) {
111 		ERROR_MSG("allocation failed");
112 		goto fail;
113 	}
114 
115 	stream->base.size = size;
116 	stream->pipe = pipe;
117 	stream->force_flush = force_flush;
118 	stream->force_flush_priv = priv;
119 
120 	return &stream->base;
121 
122 fail:
123 	if (stream)
124 		etna_cmd_stream_del(&stream->base);
125 
126 	return NULL;
127 }
128 
etna_cmd_stream_del(struct etna_cmd_stream * stream)129 void etna_cmd_stream_del(struct etna_cmd_stream *stream)
130 {
131 	struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
132 
133 	free(stream->buffer);
134 	free(priv->submit.relocs);
135 	free(priv->submit.pmrs);
136 	free(priv);
137 }
138 
etna_cmd_stream_force_flush(struct etna_cmd_stream * stream)139 void etna_cmd_stream_force_flush(struct etna_cmd_stream *stream)
140 {
141 	struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
142 
143 	if (priv->force_flush)
144 		priv->force_flush(stream, priv->force_flush_priv);
145 }
146 
etna_cmd_stream_timestamp(struct etna_cmd_stream * stream)147 uint32_t etna_cmd_stream_timestamp(struct etna_cmd_stream *stream)
148 {
149 	return etna_cmd_stream_priv(stream)->last_timestamp;
150 }
151 
append_bo(struct etna_cmd_stream * stream,struct etna_bo * bo)152 static uint32_t append_bo(struct etna_cmd_stream *stream, struct etna_bo *bo)
153 {
154 	struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
155 	uint32_t idx;
156 
157 	simple_mtx_assert_locked(&idx_lock);
158 
159 	idx = APPEND(&priv->submit, bos);
160 	idx = APPEND(priv, bos);
161 
162 	priv->submit.bos[idx].flags = 0;
163 	priv->submit.bos[idx].handle = bo->handle;
164 	priv->submit.bos[idx].presumed = bo->va;
165 
166 	priv->bos[idx] = etna_bo_ref(bo);
167 
168 	return idx;
169 }
170 
171 /* add (if needed) bo, return idx: */
bo2idx(struct etna_cmd_stream * stream,struct etna_bo * bo,uint32_t flags)172 static uint32_t bo2idx(struct etna_cmd_stream *stream, struct etna_bo *bo,
173 		uint32_t flags)
174 {
175 	struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
176 	uint32_t idx;
177 
178 	simple_mtx_lock(&idx_lock);
179 
180 	if (bo->current_stream == stream) {
181 		idx = bo->idx;
182 	} else {
183 		void *val;
184 
185 		if (!priv->bo_table)
186 			priv->bo_table = drmHashCreate();
187 
188 		if (!drmHashLookup(priv->bo_table, bo->handle, &val)) {
189 			/* found */
190 			idx = (uint32_t)(uintptr_t)val;
191 		} else {
192 			idx = append_bo(stream, bo);
193 			val = (void *)(uintptr_t)idx;
194 			drmHashInsert(priv->bo_table, bo->handle, val);
195 		}
196 
197 		bo->current_stream = stream;
198 		bo->idx = idx;
199 	}
200 	simple_mtx_unlock(&idx_lock);
201 
202 	if (flags & ETNA_RELOC_READ)
203 		priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_READ;
204 	if (flags & ETNA_RELOC_WRITE)
205 		priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_WRITE;
206 
207 	return idx;
208 }
209 
etna_cmd_stream_flush(struct etna_cmd_stream * stream,int in_fence_fd,int * out_fence_fd)210 void etna_cmd_stream_flush(struct etna_cmd_stream *stream, int in_fence_fd,
211 		int *out_fence_fd)
212 {
213 	struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
214 	int ret, id = priv->pipe->id;
215 	struct etna_gpu *gpu = priv->pipe->gpu;
216 
217 	struct drm_etnaviv_gem_submit req = {
218 		.pipe = gpu->core,
219 		.exec_state = id,
220 		.bos = VOID2U64(priv->submit.bos),
221 		.nr_bos = priv->submit.nr_bos,
222 		.relocs = VOID2U64(priv->submit.relocs),
223 		.nr_relocs = priv->submit.nr_relocs,
224 		.pmrs = VOID2U64(priv->submit.pmrs),
225 		.nr_pmrs = priv->submit.nr_pmrs,
226 		.stream = VOID2U64(stream->buffer),
227 		.stream_size = stream->offset * 4, /* in bytes */
228 	};
229 
230 	if (in_fence_fd != -1) {
231 		req.flags |= ETNA_SUBMIT_FENCE_FD_IN | ETNA_SUBMIT_NO_IMPLICIT;
232 		req.fence_fd = in_fence_fd;
233 	}
234 
235 	if (out_fence_fd)
236 		req.flags |= ETNA_SUBMIT_FENCE_FD_OUT;
237 
238 	if (gpu->dev->use_softpin)
239 		req.flags |= ETNA_SUBMIT_SOFTPIN;
240 
241 	ret = drmCommandWriteRead(gpu->dev->fd, DRM_ETNAVIV_GEM_SUBMIT,
242 			&req, sizeof(req));
243 
244 	if (ret)
245 		ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno));
246 	else
247 		priv->last_timestamp = req.fence;
248 
249 	for (uint32_t i = 0; i < priv->nr_bos; i++) {
250 		struct etna_bo *bo = priv->bos[i];
251 
252 		bo->current_stream = NULL;
253 		etna_bo_del(bo);
254 	}
255 
256 	if (priv->bo_table) {
257 		drmHashDestroy(priv->bo_table);
258 		priv->bo_table = NULL;
259 	}
260 
261 	if (out_fence_fd)
262 		*out_fence_fd = req.fence_fd;
263 
264 	stream->offset = 0;
265 	priv->submit.nr_bos = 0;
266 	priv->submit.nr_relocs = 0;
267 	priv->submit.nr_pmrs = 0;
268 	priv->nr_bos = 0;
269 }
270 
etna_cmd_stream_reloc(struct etna_cmd_stream * stream,const struct etna_reloc * r)271 void etna_cmd_stream_reloc(struct etna_cmd_stream *stream,
272 									  const struct etna_reloc *r)
273 {
274 	struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
275 	struct drm_etnaviv_gem_submit_reloc *reloc;
276 	uint32_t addr = r->bo->va + r->offset;
277 	uint32_t bo_idx = bo2idx(stream, r->bo, r->flags);
278 	uint32_t idx;
279 
280 	if (!priv->pipe->gpu->dev->use_softpin) {
281 		idx = APPEND(&priv->submit, relocs);
282 		reloc = &priv->submit.relocs[idx];
283 
284 		reloc->reloc_idx = bo_idx;
285 		reloc->reloc_offset = r->offset;
286 		reloc->submit_offset = stream->offset * 4; /* in bytes */
287 		reloc->flags = 0;
288 	}
289 
290 	etna_cmd_stream_emit(stream, addr);
291 }
292 
etna_cmd_stream_ref_bo(struct etna_cmd_stream * stream,struct etna_bo * bo,uint32_t flags)293 void etna_cmd_stream_ref_bo(struct etna_cmd_stream *stream, struct etna_bo *bo,
294 		uint32_t flags)
295 {
296 	bo2idx(stream, bo, flags);
297 }
298 
etna_cmd_stream_perf(struct etna_cmd_stream * stream,const struct etna_perf * p)299 void etna_cmd_stream_perf(struct etna_cmd_stream *stream, const struct etna_perf *p)
300 {
301 	struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
302 	struct drm_etnaviv_gem_submit_pmr *pmr;
303 	uint32_t idx = APPEND(&priv->submit, pmrs);
304 
305 	pmr = &priv->submit.pmrs[idx];
306 
307 	pmr->flags = p->flags;
308 	pmr->sequence = p->sequence;
309 	pmr->read_offset = p->offset;
310 	pmr->read_idx = bo2idx(stream, p->bo, ETNA_SUBMIT_BO_READ | ETNA_SUBMIT_BO_WRITE);
311 	pmr->domain = p->signal->domain->id;
312 	pmr->signal = p->signal->signal;
313 }
314