Debian Codegraph @

src/imagination/vulkan/winsys/powervr/pvr_drm_job_render.c

raw
1 /*
2 * Copyright © 2022 Imagination Technologies Ltd.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * 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 THE
18 * 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
24 #include <errno.h>
25 #include <stdbool.h>
26 #include <stddef.h>
27 #include <stdint.h>
28 #include <string.h>
29 #include <vulkan/vulkan.h>
30 #include <xf86drm.h>
31
32 #include "drm-uapi/pvr_drm.h"
33 #include "pvr_drm.h"
34 #include "pvr_drm_bo.h"
35 #include "pvr_drm_job_common.h"
36 #include "pvr_drm_job_render.h"
37 #include "pvr_winsys.h"
38 #include "pvr_winsys_helper.h"
39 #include "util/macros.h"
40 #include "vk_alloc.h"
41 #include "vk_drm_syncobj.h"
42 #include "vk_log.h"
43 #include "vk_util.h"
44 #include "vk_sync.h"
45
46 #define PVR_DRM_FREE_LIST_LOCAL 0U
47 #define PVR_DRM_FREE_LIST_GLOBAL 1U
48 #define PVR_DRM_FREE_LIST_MAX 2U
49
50 struct pvr_drm_winsys_free_list {
51 struct pvr_winsys_free_list base;
52
53 uint32_t handle;
54
55 struct pvr_drm_winsys_free_list *parent;
56 };
57
58 #define to_pvr_drm_winsys_free_list(free_list) \
59 container_of(free_list, struct pvr_drm_winsys_free_list, base)
60
61 struct pvr_drm_winsys_rt_dataset {
62 struct pvr_winsys_rt_dataset base;
63 uint32_t handle;
64 };
65
66 #define to_pvr_drm_winsys_rt_dataset(rt_dataset) \
67 container_of(rt_dataset, struct pvr_drm_winsys_rt_dataset, base)
68
69 VkResult pvr_drm_winsys_free_list_create(
70 struct pvr_winsys *const ws,
71 struct pvr_winsys_vma *const free_list_vma,
72 uint32_t initial_num_pages,
73 uint32_t max_num_pages,
74 uint32_t grow_num_pages,
75 uint32_t grow_threshold,
76 struct pvr_winsys_free_list *const parent_free_list,
77 struct pvr_winsys_free_list **const free_list_out)
78 {
79 struct pvr_drm_winsys *drm_ws = to_pvr_drm_winsys(ws);
80 struct drm_pvr_ioctl_create_free_list_args free_list_args = {
81 .free_list_gpu_addr = free_list_vma->dev_addr.addr,
82 .initial_num_pages = initial_num_pages,
83 .max_num_pages = max_num_pages,
84 .grow_num_pages = grow_num_pages,
85 .grow_threshold = grow_threshold,
86 .vm_context_handle = drm_ws->vm_context,
87 };
88 struct pvr_drm_winsys_free_list *drm_free_list;
89 VkResult result;
90
91 drm_free_list = vk_zalloc(ws->alloc,
92 sizeof(*drm_free_list),
93 8,
94 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
95 if (!drm_free_list) {
96 result = vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
97 goto err_out;
98 }
99
100 drm_free_list->base.ws = ws;
101
102 if (parent_free_list)
103 drm_free_list->parent = to_pvr_drm_winsys_free_list(parent_free_list);
104
105 /* Returns VK_ERROR_INITIALIZATION_FAILED to match pvrsrv. */
106 result = pvr_ioctlf(ws->render_fd,
107 DRM_IOCTL_PVR_CREATE_FREE_LIST,
108 &free_list_args,
109 VK_ERROR_INITIALIZATION_FAILED,
110 "Failed to create free list");
111 if (result != VK_SUCCESS)
112 goto err_free_free_list;
113
114 drm_free_list->handle = free_list_args.handle;
115
116 *free_list_out = &drm_free_list->base;
117
118 return VK_SUCCESS;
119
120 err_free_free_list:
121 vk_free(ws->alloc, drm_free_list);
122
123 err_out:
124 return result;
125 }
126
127 void pvr_drm_winsys_free_list_destroy(struct pvr_winsys_free_list *free_list)
128 {
129 struct pvr_drm_winsys_free_list *const drm_free_list =
130 to_pvr_drm_winsys_free_list(free_list);
131 struct pvr_drm_winsys *drm_ws = to_pvr_drm_winsys(free_list->ws);
132 struct drm_pvr_ioctl_destroy_free_list_args args = {
133 .handle = drm_free_list->handle,
134 };
135
136 pvr_ioctlf(drm_ws->base.render_fd,
137 DRM_IOCTL_PVR_DESTROY_FREE_LIST,
138 &args,
139 VK_ERROR_UNKNOWN,
140 "Error destroying free list");
141
142 vk_free(drm_ws->base.alloc, free_list);
143 }
144
145 static void pvr_drm_render_ctx_static_state_init(
146 enum pvr_device_arch arch,
147 struct pvr_winsys_render_ctx_create_info *create_info,
148 uint8_t *stream_ptr_start,
149 uint32_t *stream_len_ptr)
150 {
151 /* TODO: handle non-rogue GPUs */
152 assert(arch == PVR_DEVICE_ARCH_ROGUE);
153 struct pvr_rogue_winsys_render_ctx_static_state *ws_static_state =
154 &create_info->static_state.rogue;
155
156 uint64_t *stream_ptr = (uint64_t *)stream_ptr_start;
157
158 /* Leave space for stream header. */
159 stream_ptr++;
160
161 *stream_ptr++ = ws_static_state->vdm_ctx_state_base_addr;
162 /* geom_reg_vdm_context_state_resume_addr is unused and zeroed. */
163 *stream_ptr++ = 0;
164 *stream_ptr++ = ws_static_state->geom_ctx_state_base_addr;
165
166 for (uint32_t i = 0; i < ARRAY_SIZE(ws_static_state->geom_state); i++) {
167 *stream_ptr++ = ws_static_state->geom_state[i].vdm_ctx_store_task0;
168 *stream_ptr++ = ws_static_state->geom_state[i].vdm_ctx_store_task1;
169 *stream_ptr++ = ws_static_state->geom_state[i].vdm_ctx_store_task2;
170 /* {store, resume}_task{3, 4} are unused and zeroed. */
171 *stream_ptr++ = 0;
172 *stream_ptr++ = 0;
173
174 *stream_ptr++ = ws_static_state->geom_state[i].vdm_ctx_resume_task0;
175 *stream_ptr++ = ws_static_state->geom_state[i].vdm_ctx_resume_task1;
176 *stream_ptr++ = ws_static_state->geom_state[i].vdm_ctx_resume_task2;
177 /* {store, resume}_task{3, 4} are unused and zeroed. */
178 *stream_ptr++ = 0;
179 *stream_ptr++ = 0;
180 }
181
182 *stream_len_ptr = ((uint8_t *)stream_ptr - stream_ptr_start);
183
184 *((uint64_t *)stream_ptr_start) = *stream_len_ptr;
185 }
186
187 struct pvr_drm_winsys_render_ctx {
188 struct pvr_winsys_render_ctx base;
189
190 /* Handle to kernel context. */
191 uint32_t handle;
192
193 uint32_t geom_to_pr_syncobj;
194 };
195
196 #define to_pvr_drm_winsys_render_ctx(ctx) \
197 container_of(ctx, struct pvr_drm_winsys_render_ctx, base)
198
199 VkResult pvr_drm_winsys_render_ctx_create(
200 struct pvr_winsys *ws,
201 struct pvr_winsys_render_ctx_create_info *create_info,
202 const struct pvr_device_info *dev_info,
203 struct pvr_winsys_render_ctx **const ctx_out)
204 {
205 uint8_t static_ctx_state_fw_stream[192];
206 struct pvr_drm_winsys *drm_ws = to_pvr_drm_winsys(ws);
207 struct drm_pvr_ioctl_create_context_args ctx_args = {
208 .type = DRM_PVR_CTX_TYPE_RENDER,
209 .priority = pvr_drm_from_winsys_priority(create_info->priority),
210 .static_context_state = (uint64_t)&static_ctx_state_fw_stream,
211 .callstack_addr = create_info->vdm_callstack_addr.addr,
212 .vm_context_handle = drm_ws->vm_context,
213 };
214
215 struct pvr_drm_winsys_render_ctx *drm_ctx;
216 uint32_t geom_to_pr_syncobj;
217 VkResult result;
218 int ret;
219
220 drm_ctx = vk_alloc(ws->alloc,
221 sizeof(*drm_ctx),
222 8,
223 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
224 if (!drm_ctx) {
225 result = vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
226 goto err_out;
227 }
228
229 ret = drmSyncobjCreate(ws->render_fd, 0, &geom_to_pr_syncobj);
230 if (ret < 0) {
231 result = vk_errorf(NULL,
232 VK_ERROR_OUT_OF_HOST_MEMORY,
233 "DRM_IOCTL_SYNCOBJ_CREATE failed: %s",
234 strerror(errno));
235 goto err_free_ctx;
236 }
237
238 pvr_drm_render_ctx_static_state_init(dev_info->ident.arch,
239 create_info,
240 static_ctx_state_fw_stream,
241 &ctx_args.static_context_state_len);
242
243 result = pvr_ioctlf(ws->render_fd,
244 DRM_IOCTL_PVR_CREATE_CONTEXT,
245 &ctx_args,
246 VK_ERROR_INITIALIZATION_FAILED,
247 "Failed to create render context");
248 if (result != VK_SUCCESS)
249 goto err_destroy_syncobj;
250
251 *drm_ctx = (struct pvr_drm_winsys_render_ctx) {
252 .base = {
253 .ws = ws,
254 },
255 .handle = ctx_args.handle,
256 .geom_to_pr_syncobj = geom_to_pr_syncobj,
257 };
258
259 *ctx_out = &drm_ctx->base;
260
261 return VK_SUCCESS;
262
263 err_destroy_syncobj:
264 ret = drmSyncobjDestroy(ws->render_fd, geom_to_pr_syncobj);
265 if (ret < 0) {
266 mesa_loge("DRM_IOCTL_SYNCOBJ_DESTROY failed: %s - leaking it",
267 strerror(errno));
268 }
269
270 err_free_ctx:
271 vk_free(ws->alloc, drm_ctx);
272
273 err_out:
274 return result;
275 }
276
277 void pvr_drm_winsys_render_ctx_destroy(struct pvr_winsys_render_ctx *ctx)
278 {
279 struct pvr_drm_winsys *drm_ws = to_pvr_drm_winsys(ctx->ws);
280 struct pvr_drm_winsys_render_ctx *drm_ctx =
281 to_pvr_drm_winsys_render_ctx(ctx);
282 struct drm_pvr_ioctl_destroy_context_args args = {
283 .handle = drm_ctx->handle,
284 };
285 int ret;
286
287 ret = drmSyncobjDestroy(ctx->ws->render_fd, drm_ctx->geom_to_pr_syncobj);
288 if (ret < 0) {
289 mesa_loge("DRM_IOCTL_SYNCOBJ_DESTROY failed: %s - leaking it",
290 strerror(errno));
291 }
292
293 pvr_ioctlf(drm_ws->base.render_fd,
294 DRM_IOCTL_PVR_DESTROY_CONTEXT,
295 &args,
296 VK_ERROR_UNKNOWN,
297 "Error destroying render context");
298
299 vk_free(drm_ws->base.alloc, drm_ctx);
300 }
301
302 VkResult pvr_drm_render_target_dataset_create(
303 struct pvr_winsys *const ws,
304 const struct pvr_winsys_rt_dataset_create_info *const create_info,
305 UNUSED const struct pvr_device_info *dev_info,
306 struct pvr_winsys_rt_dataset **const rt_dataset_out)
307 {
308 struct pvr_drm_winsys_free_list *drm_free_list =
309 to_pvr_drm_winsys_free_list(create_info->local_free_list);
310
311 /* 0 is just a placeholder. It doesn't indicate an invalid handle. */
312 uint32_t parent_free_list_handle =
313 drm_free_list->parent ? drm_free_list->parent->handle : 0;
314
315 struct drm_pvr_ioctl_create_hwrt_dataset_args args = {
316 .geom_data_args = {
317 .tpc_dev_addr = create_info->tpc_dev_addr.addr,
318 .tpc_size = create_info->tpc_size,
319 .tpc_stride = create_info->tpc_stride,
320 .vheap_table_dev_addr = create_info->vheap_table_dev_addr.addr,
321 .rtc_dev_addr = create_info->rtc_dev_addr.addr,
322 },
323
324 .rt_data_args = {
325 [0] = {
326 .pm_mlist_dev_addr =
327 create_info->rt_datas[0].pm_mlist_dev_addr.addr,
328 .macrotile_array_dev_addr =
329 create_info->rt_datas[0].macrotile_array_dev_addr.addr,
330 .region_header_dev_addr =
331 create_info->rt_datas[0].rgn_header_dev_addr.addr,
332 },
333 [1] = {
334 .pm_mlist_dev_addr =
335 create_info->rt_datas[1].pm_mlist_dev_addr.addr,
336 .macrotile_array_dev_addr =
337 create_info->rt_datas[1].macrotile_array_dev_addr.addr,
338 .region_header_dev_addr =
339 create_info->rt_datas[1].rgn_header_dev_addr.addr,
340 },
341 },
342
343 .free_list_handles = {
344 [PVR_DRM_FREE_LIST_LOCAL] = drm_free_list->handle,
345 [PVR_DRM_FREE_LIST_GLOBAL] = parent_free_list_handle,
346 },
347
348 .width = create_info->width,
349 .height = create_info->height,
350 .samples = create_info->samples,
351 .layers = create_info->layers,
352
353 .isp_merge_lower_x = create_info->isp_merge_lower_x,
354 .isp_merge_lower_y = create_info->isp_merge_lower_y,
355 .isp_merge_scale_x = create_info->isp_merge_scale_x,
356 .isp_merge_scale_y = create_info->isp_merge_scale_y,
357 .isp_merge_upper_x = create_info->isp_merge_upper_x,
358 .isp_merge_upper_y = create_info->isp_merge_upper_y,
359
360 .region_header_size = create_info->rgn_header_size,
361 };
362
363 struct pvr_drm_winsys_rt_dataset *drm_rt_dataset;
364 VkResult result;
365
366 STATIC_ASSERT(ARRAY_SIZE(args.rt_data_args) ==
367 ARRAY_SIZE(create_info->rt_datas));
368
369 drm_rt_dataset = vk_zalloc(ws->alloc,
370 sizeof(*drm_rt_dataset),
371 8,
372 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
373 if (!drm_rt_dataset) {
374 result = vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
375 goto err_out;
376 }
377
378 /* Returns VK_ERROR_INITIALIZATION_FAILED to match pvrsrv. */
379 result = pvr_ioctlf(ws->render_fd,
380 DRM_IOCTL_PVR_CREATE_HWRT_DATASET,
381 &args,
382 VK_ERROR_INITIALIZATION_FAILED,
383 "Failed to create render target dataset");
384 if (result != VK_SUCCESS)
385 goto err_free_dataset;
386
387 drm_rt_dataset->handle = args.handle;
388 drm_rt_dataset->base.ws = ws;
389
390 *rt_dataset_out = &drm_rt_dataset->base;
391
392 return VK_SUCCESS;
393
394 err_free_dataset:
395 vk_free(ws->alloc, drm_rt_dataset);
396
397 err_out:
398 return result;
399 }
400
401 void pvr_drm_render_target_dataset_destroy(
402 struct pvr_winsys_rt_dataset *const rt_dataset)
403 {
404 struct pvr_drm_winsys_rt_dataset *const drm_rt_dataset =
405 to_pvr_drm_winsys_rt_dataset(rt_dataset);
406 struct pvr_drm_winsys *const drm_ws = to_pvr_drm_winsys(rt_dataset->ws);
407 struct drm_pvr_ioctl_destroy_hwrt_dataset_args args = {
408 .handle = drm_rt_dataset->handle,
409 };
410
411 pvr_ioctlf(drm_ws->base.render_fd,
412 DRM_IOCTL_PVR_DESTROY_HWRT_DATASET,
413 &args,
414 VK_ERROR_UNKNOWN,
415 "Error destroying render target dataset");
416
417 vk_free(drm_ws->base.alloc, drm_rt_dataset);
418 }
419
420 static uint32_t pvr_winsys_geom_flags_to_drm(
421 const struct pvr_winsys_geometry_state_flags *const ws_flags)
422 {
423 uint32_t flags = 0U;
424
425 if (ws_flags->is_first_geometry)
426 flags |= DRM_PVR_SUBMIT_JOB_GEOM_CMD_FIRST;
427
428 if (ws_flags->is_last_geometry)
429 flags |= DRM_PVR_SUBMIT_JOB_GEOM_CMD_LAST;
430
431 if (ws_flags->use_single_core)
432 flags |= DRM_PVR_SUBMIT_JOB_GEOM_CMD_SINGLE_CORE;
433
434 return flags;
435 }
436
437 static uint32_t pvr_winsys_frag_flags_to_drm(
438 const struct pvr_winsys_fragment_state_flags *const ws_flags)
439 {
440 uint32_t flags = 0U;
441
442 if (ws_flags->use_single_core)
443 flags |= DRM_PVR_SUBMIT_JOB_FRAG_CMD_SINGLE_CORE;
444
445 if (ws_flags->has_depth_buffer)
446 flags |= DRM_PVR_SUBMIT_JOB_FRAG_CMD_DEPTHBUFFER;
447
448 if (ws_flags->has_stencil_buffer)
449 flags |= DRM_PVR_SUBMIT_JOB_FRAG_CMD_STENCILBUFFER;
450
451 if (ws_flags->prevent_cdm_overlap)
452 flags |= DRM_PVR_SUBMIT_JOB_FRAG_CMD_PREVENT_CDM_OVERLAP;
453
454 if (ws_flags->get_vis_results)
455 flags |= DRM_PVR_SUBMIT_JOB_FRAG_CMD_GET_VIS_RESULTS;
456
457 if (ws_flags->has_spm_scratch_buffer)
458 flags |= DRM_PVR_SUBMIT_JOB_FRAG_CMD_SCRATCHBUFFER;
459
460 if (ws_flags->disable_pixel_merging)
461 flags |= DRM_PVR_SUBMIT_JOB_FRAG_CMD_DISABLE_PIXELMERGE;
462
463 return flags;
464 }
465
466 VkResult pvr_drm_winsys_render_submit(
467 const struct pvr_winsys_render_ctx *ctx,
468 const struct pvr_winsys_render_submit_info *submit_info,
469 UNUSED const struct pvr_device_info *dev_info,
470 struct vk_sync *signal_sync_geom,
471 struct vk_sync *signal_sync_frag)
472
473 {
474 const struct pvr_drm_winsys *drm_ws = to_pvr_drm_winsys(ctx->ws);
475 const struct pvr_drm_winsys_render_ctx *drm_ctx =
476 to_pvr_drm_winsys_render_ctx(ctx);
477 const struct pvr_winsys_geometry_state *const geom_state =
478 &submit_info->geometry;
479 const struct pvr_winsys_fragment_state *const frag_state =
480 &submit_info->fragment;
481 const struct pvr_winsys_fragment_state *const pr_state =
482 &submit_info->fragment_pr;
483 const struct pvr_drm_winsys_rt_dataset *drm_rt_dataset =
484 to_pvr_drm_winsys_rt_dataset(submit_info->rt_dataset);
485
486 struct drm_pvr_sync_op geom_sync_ops[2], pr_sync_ops[1], frag_sync_ops[3];
487 unsigned num_geom_syncs = 0, num_pr_syncs = 0, num_frag_syncs = 0;
488 uint32_t geom_to_pr_syncobj;
489
490 struct drm_pvr_job jobs_args[3] = {
491 [0] = {
492 .type = DRM_PVR_JOB_TYPE_GEOMETRY,
493 .cmd_stream = (__u64)&geom_state->fw_stream[0],
494 .cmd_stream_len = geom_state->fw_stream_len,
495 .context_handle = drm_ctx->handle,
496 .flags = pvr_winsys_geom_flags_to_drm(&geom_state->flags),
497 .sync_ops = DRM_PVR_OBJ_ARRAY(0, geom_sync_ops),
498 .hwrt = {
499 .set_handle = drm_rt_dataset->handle,
500 .data_index = submit_info->rt_data_idx,
501 },
502 },
503 [1] = {
504 .type = DRM_PVR_JOB_TYPE_FRAGMENT,
505 .cmd_stream = (__u64)&pr_state->fw_stream[0],
506 .cmd_stream_len = pr_state->fw_stream_len,
507 .context_handle = drm_ctx->handle,
508 .flags = DRM_PVR_SUBMIT_JOB_FRAG_CMD_PARTIAL_RENDER |
509 pvr_winsys_frag_flags_to_drm(&pr_state->flags),
510 .sync_ops = DRM_PVR_OBJ_ARRAY(0, pr_sync_ops),
511 .hwrt = {
512 .set_handle = drm_rt_dataset->handle,
513 .data_index = submit_info->rt_data_idx,
514 },
515 }
516 };
517
518 struct drm_pvr_ioctl_submit_jobs_args args = {
519 .jobs = DRM_PVR_OBJ_ARRAY(2, jobs_args),
520 };
521
522 /* Geom syncs */
523
524 if (submit_info->geometry.wait) {
525 struct vk_sync *sync = submit_info->geometry.wait;
526
527 assert(!(sync->flags & VK_SYNC_IS_TIMELINE));
528 geom_sync_ops[num_geom_syncs++] = (struct drm_pvr_sync_op){
529 .handle = vk_sync_as_drm_syncobj(sync)->syncobj,
530 .flags = DRM_PVR_SYNC_OP_FLAG_WAIT |
531 DRM_PVR_SYNC_OP_FLAG_HANDLE_TYPE_SYNCOBJ,
532 .value = 0,
533 };
534 }
535
536 if (signal_sync_geom) {
537 assert(!(signal_sync_geom->flags & VK_SYNC_IS_TIMELINE));
538 geom_sync_ops[num_geom_syncs++] = (struct drm_pvr_sync_op){
539 .handle = vk_sync_as_drm_syncobj(signal_sync_geom)->syncobj,
540 .flags = DRM_PVR_SYNC_OP_FLAG_SIGNAL |
541 DRM_PVR_SYNC_OP_FLAG_HANDLE_TYPE_SYNCOBJ,
542 .value = 0,
543 };
544 }
545
546 /* PR syncs */
547
548 if (signal_sync_geom) {
549 assert(!(signal_sync_geom->flags & VK_SYNC_IS_TIMELINE));
550 geom_to_pr_syncobj = vk_sync_as_drm_syncobj(signal_sync_geom)->syncobj;
551 } else {
552 geom_to_pr_syncobj = drm_ctx->geom_to_pr_syncobj;
553
554 geom_sync_ops[num_geom_syncs++] = (struct drm_pvr_sync_op){
555 .handle = geom_to_pr_syncobj,
556 .flags = DRM_PVR_SYNC_OP_FLAG_SIGNAL |
557 DRM_PVR_SYNC_OP_FLAG_HANDLE_TYPE_SYNCOBJ,
558 .value = 0,
559 };
560 }
561
562 pr_sync_ops[num_pr_syncs++] = (struct drm_pvr_sync_op){
563 .handle = geom_to_pr_syncobj,
564 .flags = DRM_PVR_SYNC_OP_FLAG_WAIT |
565 DRM_PVR_SYNC_OP_FLAG_HANDLE_TYPE_SYNCOBJ,
566 .value = 0,
567 };
568
569 /* Frag job */
570
571 if (submit_info->has_fragment_job) {
572 jobs_args[args.jobs.count++] = (struct drm_pvr_job) {
573 .type = DRM_PVR_JOB_TYPE_FRAGMENT,
574 .cmd_stream = (__u64)&frag_state->fw_stream[0],
575 .cmd_stream_len = frag_state->fw_stream_len,
576 .context_handle = drm_ctx->handle,
577 .flags = pvr_winsys_frag_flags_to_drm(&frag_state->flags),
578 .sync_ops = DRM_PVR_OBJ_ARRAY(0, frag_sync_ops),
579 .hwrt = {
580 .set_handle = drm_rt_dataset->handle,
581 .data_index = submit_info->rt_data_idx,
582 },
583 };
584
585 /* There's no need to setup a geom -> frag dependency here, as we always
586 * setup a geom -> pr dependency (a PR just being a frag job) and the KMD
587 * respects submission order for jobs of the same type.
588 *
589 * Note that, in the case where PRs aren't needed, because we didn't run
590 * out of PB space during the geometry phase, the PR job will still be
591 * scheduled after the geometry job, but no PRs will be performed, as
592 * they aren't needed.
593 */
594
595 if (submit_info->fragment.wait) {
596 struct vk_sync *sync = submit_info->fragment.wait;
597
598 assert(!(sync->flags & VK_SYNC_IS_TIMELINE));
599 frag_sync_ops[num_frag_syncs++] = (struct drm_pvr_sync_op){
600 .handle = vk_sync_as_drm_syncobj(sync)->syncobj,
601 .flags = DRM_PVR_SYNC_OP_FLAG_WAIT |
602 DRM_PVR_SYNC_OP_FLAG_HANDLE_TYPE_SYNCOBJ,
603 .value = 0,
604 };
605 }
606
607 if (signal_sync_frag) {
608 assert(!(signal_sync_frag->flags & VK_SYNC_IS_TIMELINE));
609 frag_sync_ops[num_frag_syncs++] = (struct drm_pvr_sync_op){
610 .handle = vk_sync_as_drm_syncobj(signal_sync_frag)->syncobj,
611 .flags = DRM_PVR_SYNC_OP_FLAG_SIGNAL |
612 DRM_PVR_SYNC_OP_FLAG_HANDLE_TYPE_SYNCOBJ,
613 .value = 0,
614 };
615 }
616 }
617
618 jobs_args[0].sync_ops.count = num_geom_syncs;
619 jobs_args[1].sync_ops.count = num_pr_syncs;
620
621 if (submit_info->has_fragment_job)
622 jobs_args[2].sync_ops.count = num_frag_syncs;
623
624 /* Returns VK_ERROR_OUT_OF_DEVICE_MEMORY to match pvrsrv. */
625 return pvr_ioctlf(drm_ws->base.render_fd,
626 DRM_IOCTL_PVR_SUBMIT_JOBS,
627 &args,
628 VK_ERROR_OUT_OF_DEVICE_MEMORY,
629 "Failed to submit render job");
630 }