v3d: Fix a copy-and-paste comment in the simulator code.
[mesa.git] / src / gallium / drivers / v3d / v3d_job.c
1 /*
2 * Copyright © 2014-2017 Broadcom
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
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 /** @file v3d_job.c
25 *
26 * Functions for submitting VC5 render jobs to the kernel.
27 */
28
29 #include <xf86drm.h>
30 #include "v3d_context.h"
31 /* The OQ/semaphore packets are the same across V3D versions. */
32 #define V3D_VERSION 33
33 #include "broadcom/cle/v3dx_pack.h"
34 #include "broadcom/common/v3d_macros.h"
35 #include "util/hash_table.h"
36 #include "util/ralloc.h"
37 #include "util/set.h"
38 #include "broadcom/clif/clif_dump.h"
39
40 static void
41 remove_from_ht(struct hash_table *ht, void *key)
42 {
43 struct hash_entry *entry = _mesa_hash_table_search(ht, key);
44 _mesa_hash_table_remove(ht, entry);
45 }
46
47 static void
48 v3d_job_free(struct v3d_context *v3d, struct v3d_job *job)
49 {
50 set_foreach(job->bos, entry) {
51 struct v3d_bo *bo = (struct v3d_bo *)entry->key;
52 v3d_bo_unreference(&bo);
53 }
54
55 remove_from_ht(v3d->jobs, &job->key);
56
57 if (job->write_prscs) {
58 set_foreach(job->write_prscs, entry) {
59 const struct pipe_resource *prsc = entry->key;
60
61 remove_from_ht(v3d->write_jobs, (void *)prsc);
62 }
63 }
64
65 for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) {
66 if (job->cbufs[i]) {
67 remove_from_ht(v3d->write_jobs, job->cbufs[i]->texture);
68 pipe_surface_reference(&job->cbufs[i], NULL);
69 }
70 }
71 if (job->zsbuf) {
72 struct v3d_resource *rsc = v3d_resource(job->zsbuf->texture);
73 if (rsc->separate_stencil)
74 remove_from_ht(v3d->write_jobs,
75 &rsc->separate_stencil->base);
76
77 remove_from_ht(v3d->write_jobs, job->zsbuf->texture);
78 pipe_surface_reference(&job->zsbuf, NULL);
79 }
80
81 if (v3d->job == job)
82 v3d->job = NULL;
83
84 v3d_destroy_cl(&job->bcl);
85 v3d_destroy_cl(&job->rcl);
86 v3d_destroy_cl(&job->indirect);
87 v3d_bo_unreference(&job->tile_alloc);
88 v3d_bo_unreference(&job->tile_state);
89
90 ralloc_free(job);
91 }
92
93 static struct v3d_job *
94 v3d_job_create(struct v3d_context *v3d)
95 {
96 struct v3d_job *job = rzalloc(v3d, struct v3d_job);
97
98 job->v3d = v3d;
99
100 v3d_init_cl(job, &job->bcl);
101 v3d_init_cl(job, &job->rcl);
102 v3d_init_cl(job, &job->indirect);
103
104 job->draw_min_x = ~0;
105 job->draw_min_y = ~0;
106 job->draw_max_x = 0;
107 job->draw_max_y = 0;
108
109 job->bos = _mesa_set_create(job,
110 _mesa_hash_pointer,
111 _mesa_key_pointer_equal);
112 return job;
113 }
114
115 void
116 v3d_job_add_bo(struct v3d_job *job, struct v3d_bo *bo)
117 {
118 if (!bo)
119 return;
120
121 if (_mesa_set_search(job->bos, bo))
122 return;
123
124 v3d_bo_reference(bo);
125 _mesa_set_add(job->bos, bo);
126 job->referenced_size += bo->size;
127
128 uint32_t *bo_handles = (void *)(uintptr_t)job->submit.bo_handles;
129
130 if (job->submit.bo_handle_count >= job->bo_handles_size) {
131 job->bo_handles_size = MAX2(4, job->bo_handles_size * 2);
132 bo_handles = reralloc(job, bo_handles,
133 uint32_t, job->bo_handles_size);
134 job->submit.bo_handles = (uintptr_t)(void *)bo_handles;
135 }
136 bo_handles[job->submit.bo_handle_count++] = bo->handle;
137 }
138
139 void
140 v3d_job_add_write_resource(struct v3d_job *job, struct pipe_resource *prsc)
141 {
142 struct v3d_context *v3d = job->v3d;
143
144 if (!job->write_prscs) {
145 job->write_prscs = _mesa_set_create(job,
146 _mesa_hash_pointer,
147 _mesa_key_pointer_equal);
148 }
149
150 _mesa_set_add(job->write_prscs, prsc);
151 _mesa_hash_table_insert(v3d->write_jobs, prsc, job);
152 }
153
154 void
155 v3d_flush_jobs_writing_resource(struct v3d_context *v3d,
156 struct pipe_resource *prsc)
157 {
158 struct hash_entry *entry = _mesa_hash_table_search(v3d->write_jobs,
159 prsc);
160 if (entry) {
161 struct v3d_job *job = entry->data;
162 v3d_job_submit(v3d, job);
163 }
164 }
165
166 void
167 v3d_flush_jobs_reading_resource(struct v3d_context *v3d,
168 struct pipe_resource *prsc)
169 {
170 struct v3d_resource *rsc = v3d_resource(prsc);
171
172 v3d_flush_jobs_writing_resource(v3d, prsc);
173
174 hash_table_foreach(v3d->jobs, entry) {
175 struct v3d_job *job = entry->data;
176
177 if (_mesa_set_search(job->bos, rsc->bo)) {
178 v3d_job_submit(v3d, job);
179 /* Reminder: v3d->jobs is safe to keep iterating even
180 * after deletion of an entry.
181 */
182 continue;
183 }
184 }
185 }
186
187 static void
188 v3d_job_set_tile_buffer_size(struct v3d_job *job)
189 {
190 static const uint8_t tile_sizes[] = {
191 64, 64,
192 64, 32,
193 32, 32,
194 32, 16,
195 16, 16,
196 };
197 int tile_size_index = 0;
198 if (job->msaa)
199 tile_size_index += 2;
200
201 if (job->cbufs[3] || job->cbufs[2])
202 tile_size_index += 2;
203 else if (job->cbufs[1])
204 tile_size_index++;
205
206 int max_bpp = RENDER_TARGET_MAXIMUM_32BPP;
207 for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) {
208 if (job->cbufs[i]) {
209 struct v3d_surface *surf = v3d_surface(job->cbufs[i]);
210 max_bpp = MAX2(max_bpp, surf->internal_bpp);
211 }
212 }
213 job->internal_bpp = max_bpp;
214 STATIC_ASSERT(RENDER_TARGET_MAXIMUM_32BPP == 0);
215 tile_size_index += max_bpp;
216
217 assert(tile_size_index < ARRAY_SIZE(tile_sizes));
218 job->tile_width = tile_sizes[tile_size_index * 2 + 0];
219 job->tile_height = tile_sizes[tile_size_index * 2 + 1];
220 }
221
222 /**
223 * Returns a v3d_job struture for tracking V3D rendering to a particular FBO.
224 *
225 * If we've already started rendering to this FBO, then return old same job,
226 * otherwise make a new one. If we're beginning rendering to an FBO, make
227 * sure that any previous reads of the FBO (or writes to its color/Z surfaces)
228 * have been flushed.
229 */
230 struct v3d_job *
231 v3d_get_job(struct v3d_context *v3d,
232 struct pipe_surface **cbufs, struct pipe_surface *zsbuf)
233 {
234 /* Return the existing job for this FBO if we have one */
235 struct v3d_job_key local_key = {
236 .cbufs = {
237 cbufs[0],
238 cbufs[1],
239 cbufs[2],
240 cbufs[3],
241 },
242 .zsbuf = zsbuf,
243 };
244 struct hash_entry *entry = _mesa_hash_table_search(v3d->jobs,
245 &local_key);
246 if (entry)
247 return entry->data;
248
249 /* Creating a new job. Make sure that any previous jobs reading or
250 * writing these buffers are flushed.
251 */
252 struct v3d_job *job = v3d_job_create(v3d);
253
254 for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) {
255 if (cbufs[i]) {
256 v3d_flush_jobs_reading_resource(v3d, cbufs[i]->texture);
257 pipe_surface_reference(&job->cbufs[i], cbufs[i]);
258
259 if (cbufs[i]->texture->nr_samples > 1)
260 job->msaa = true;
261 }
262 }
263 if (zsbuf) {
264 v3d_flush_jobs_reading_resource(v3d, zsbuf->texture);
265 pipe_surface_reference(&job->zsbuf, zsbuf);
266 if (zsbuf->texture->nr_samples > 1)
267 job->msaa = true;
268 }
269
270 v3d_job_set_tile_buffer_size(job);
271
272 for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) {
273 if (cbufs[i])
274 _mesa_hash_table_insert(v3d->write_jobs,
275 cbufs[i]->texture, job);
276 }
277 if (zsbuf) {
278 _mesa_hash_table_insert(v3d->write_jobs, zsbuf->texture, job);
279
280 struct v3d_resource *rsc = v3d_resource(zsbuf->texture);
281 if (rsc->separate_stencil) {
282 v3d_flush_jobs_reading_resource(v3d,
283 &rsc->separate_stencil->base);
284 _mesa_hash_table_insert(v3d->write_jobs,
285 &rsc->separate_stencil->base,
286 job);
287 }
288 }
289
290 memcpy(&job->key, &local_key, sizeof(local_key));
291 _mesa_hash_table_insert(v3d->jobs, &job->key, job);
292
293 return job;
294 }
295
296 struct v3d_job *
297 v3d_get_job_for_fbo(struct v3d_context *v3d)
298 {
299 if (v3d->job)
300 return v3d->job;
301
302 struct pipe_surface **cbufs = v3d->framebuffer.cbufs;
303 struct pipe_surface *zsbuf = v3d->framebuffer.zsbuf;
304 struct v3d_job *job = v3d_get_job(v3d, cbufs, zsbuf);
305
306 /* The dirty flags are tracking what's been updated while v3d->job has
307 * been bound, so set them all to ~0 when switching between jobs. We
308 * also need to reset all state at the start of rendering.
309 */
310 v3d->dirty = ~0;
311
312 /* If we're binding to uninitialized buffers, no need to load their
313 * contents before drawing.
314 */
315 for (int i = 0; i < 4; i++) {
316 if (cbufs[i]) {
317 struct v3d_resource *rsc = v3d_resource(cbufs[i]->texture);
318 if (!rsc->writes)
319 job->clear |= PIPE_CLEAR_COLOR0 << i;
320 }
321 }
322
323 if (zsbuf) {
324 struct v3d_resource *rsc = v3d_resource(zsbuf->texture);
325 if (!rsc->writes)
326 job->clear |= PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL;
327 }
328
329 job->draw_tiles_x = DIV_ROUND_UP(v3d->framebuffer.width,
330 job->tile_width);
331 job->draw_tiles_y = DIV_ROUND_UP(v3d->framebuffer.height,
332 job->tile_height);
333
334 v3d->job = job;
335
336 return job;
337 }
338
339 static void
340 v3d_clif_dump(struct v3d_context *v3d, struct v3d_job *job)
341 {
342 if (!(V3D_DEBUG & (V3D_DEBUG_CL | V3D_DEBUG_CLIF)))
343 return;
344
345 struct clif_dump *clif = clif_dump_init(&v3d->screen->devinfo,
346 stderr,
347 V3D_DEBUG & V3D_DEBUG_CL);
348
349 set_foreach(job->bos, entry) {
350 struct v3d_bo *bo = (void *)entry->key;
351 char *name = ralloc_asprintf(NULL, "%s_0x%x",
352 bo->name, bo->offset);
353
354 v3d_bo_map(bo);
355 clif_dump_add_bo(clif, name, bo->offset, bo->size, bo->map);
356
357 ralloc_free(name);
358 }
359
360 clif_dump(clif, &job->submit);
361
362 clif_dump_destroy(clif);
363 }
364
365 /**
366 * Submits the job to the kernel and then reinitializes it.
367 */
368 void
369 v3d_job_submit(struct v3d_context *v3d, struct v3d_job *job)
370 {
371 MAYBE_UNUSED struct v3d_screen *screen = v3d->screen;
372
373 if (!job->needs_flush)
374 goto done;
375
376 if (v3d->screen->devinfo.ver >= 41)
377 v3d41_emit_rcl(job);
378 else
379 v3d33_emit_rcl(job);
380
381 if (cl_offset(&job->bcl) > 0) {
382 if (screen->devinfo.ver >= 41)
383 v3d41_bcl_epilogue(v3d, job);
384 else
385 v3d33_bcl_epilogue(v3d, job);
386 }
387
388 job->submit.out_sync = v3d->out_sync;
389 job->submit.bcl_end = job->bcl.bo->offset + cl_offset(&job->bcl);
390 job->submit.rcl_end = job->rcl.bo->offset + cl_offset(&job->rcl);
391
392 /* On V3D 4.1, the tile alloc/state setup moved to register writes
393 * instead of binner packets.
394 */
395 if (screen->devinfo.ver >= 41) {
396 v3d_job_add_bo(job, job->tile_alloc);
397 job->submit.qma = job->tile_alloc->offset;
398 job->submit.qms = job->tile_alloc->size;
399
400 v3d_job_add_bo(job, job->tile_state);
401 job->submit.qts = job->tile_state->offset;
402 }
403
404 v3d_clif_dump(v3d, job);
405
406 if (!(V3D_DEBUG & V3D_DEBUG_NORAST)) {
407 int ret;
408
409 #ifndef USE_V3D_SIMULATOR
410 ret = drmIoctl(v3d->fd, DRM_IOCTL_V3D_SUBMIT_CL, &job->submit);
411 #else
412 ret = v3d_simulator_flush(v3d, &job->submit, job);
413 #endif
414 static bool warned = false;
415 if (ret && !warned) {
416 fprintf(stderr, "Draw call returned %s. "
417 "Expect corruption.\n", strerror(errno));
418 warned = true;
419 }
420 }
421
422 done:
423 v3d_job_free(v3d, job);
424 }
425
426 static bool
427 v3d_job_compare(const void *a, const void *b)
428 {
429 return memcmp(a, b, sizeof(struct v3d_job_key)) == 0;
430 }
431
432 static uint32_t
433 v3d_job_hash(const void *key)
434 {
435 return _mesa_hash_data(key, sizeof(struct v3d_job_key));
436 }
437
438 void
439 v3d_job_init(struct v3d_context *v3d)
440 {
441 v3d->jobs = _mesa_hash_table_create(v3d,
442 v3d_job_hash,
443 v3d_job_compare);
444 v3d->write_jobs = _mesa_hash_table_create(v3d,
445 _mesa_hash_pointer,
446 _mesa_key_pointer_equal);
447 }
448