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
33static simple_mtx_t idx_lock = _SIMPLE_MTX_INITIALIZER_NP;
34
35static 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
53void 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
77error:
78	DEBUG_MSG("command buffer too long, forcing flush.");
79	etna_cmd_stream_force_flush(stream);
80}
81
82static inline struct etna_cmd_stream_priv *
83etna_cmd_stream_priv(struct etna_cmd_stream *stream)
84{
85    return (struct etna_cmd_stream_priv *)stream;
86}
87
88struct 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
122fail:
123	if (stream)
124		etna_cmd_stream_del(&stream->base);
125
126	return NULL;
127}
128
129void 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
139void 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
147uint32_t etna_cmd_stream_timestamp(struct etna_cmd_stream *stream)
148{
149	return etna_cmd_stream_priv(stream)->last_timestamp;
150}
151
152static 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: */
172static 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
210void 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
271void 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
293void 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
299void 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