Debian Codegraph @

src/imagination/vulkan/pvr_arch_framebuffer.c

raw
1 /*
2 * Copyright © 2022 Imagination Technologies Ltd.
3 *
4 * based in part on anv driver which is:
5 * Copyright © 2015 Intel Corporation
6 *
7 * based in part on v3dv driver which is:
8 * Copyright © 2019 Raspberry Pi
9 *
10 * SPDX-License-Identifier: MIT
11 */
12
13 #include "pvr_framebuffer.h"
14
15 #include "vk_util.h"
16
17 #include "hwdef/pvr_hw_utils.h"
18
19 #include "pvr_cmd_buffer.h"
20 #include "pvr_csb.h"
21 #include "pvr_device.h"
22 #include "pvr_entrypoints.h"
23 #include "pvr_hw_pass.h"
24 #include "pvr_image.h"
25 #include "pvr_pass.h"
26 #include "pvr_physical_device.h"
27 #include "pvr_rt_dataset.h"
28 #include "pvr_spm.h"
29
30 static VkResult
31 pvr_render_state_create_ppp_state(struct pvr_device *device,
32 struct pvr_render_state *rstate)
33 {
34 const uint32_t cache_line_size =
35 pvr_get_slc_cache_line_size(&device->pdevice->dev_info);
36 uint32_t ppp_state[3];
37 VkResult result;
38
39 pvr_csb_pack (&ppp_state[0], TA_STATE_HEADER, header) {
40 header.pres_terminate = true;
41 }
42
43 pvr_csb_pack (&ppp_state[1], TA_STATE_TERMINATE0, term0) {
44 term0.clip_right =
45 DIV_ROUND_UP(
46 rstate->width,
47 ROGUE_TA_STATE_TERMINATE0_CLIP_RIGHT_BLOCK_SIZE_IN_PIXELS) -
48 1;
49 term0.clip_bottom =
50 DIV_ROUND_UP(
51 rstate->height,
52 ROGUE_TA_STATE_TERMINATE0_CLIP_BOTTOM_BLOCK_SIZE_IN_PIXELS) -
53 1;
54 }
55
56 pvr_csb_pack (&ppp_state[2], TA_STATE_TERMINATE1, term1) {
57 term1.render_target = 0;
58 term1.clip_left = 0;
59 }
60
61 result = pvr_gpu_upload(device,
62 device->heaps.general_heap,
63 ppp_state,
64 sizeof(ppp_state),
65 cache_line_size,
66 &rstate->ppp_state_bo);
67 if (result != VK_SUCCESS)
68 return result;
69
70 /* Calculate the size of PPP state in dwords. */
71 rstate->ppp_state_size = sizeof(ppp_state) / sizeof(uint32_t);
72
73 return VK_SUCCESS;
74 }
75
76 static bool pvr_render_targets_init(struct pvr_render_target *render_targets,
77 uint32_t render_targets_count)
78 {
79 uint32_t i;
80
81 for (i = 0; i < render_targets_count; i++) {
82 if (pthread_mutex_init(&render_targets[i].mutex, NULL))
83 goto err_mutex_destroy;
84 }
85
86 return true;
87
88 err_mutex_destroy:
89 while (i--)
90 pthread_mutex_destroy(&render_targets[i].mutex);
91
92 return false;
93 }
94
95 VkResult
96 pvr_arch_render_state_setup(struct pvr_device *device,
97 const VkAllocationCallbacks *pAllocator,
98 struct pvr_render_state *rstate,
99 uint32_t render_count,
100 const struct pvr_renderpass_hwsetup_render *renders)
101 {
102 struct pvr_spm_bgobj_state *spm_bgobj_state_per_render;
103 struct pvr_spm_eot_state *spm_eot_state_per_render;
104 struct pvr_render_target *render_targets;
105 uint32_t render_targets_count;
106 VkResult result;
107
108 render_targets_count =
109 PVR_RENDER_TARGETS_PER_FRAMEBUFFER(&device->pdevice->dev_info);
110
111 VK_MULTIALLOC(ma);
112 vk_multialloc_add(&ma,
113 &render_targets,
114 __typeof__(*render_targets),
115 render_targets_count);
116 vk_multialloc_add(&ma,
117 &spm_eot_state_per_render,
118 __typeof__(*spm_eot_state_per_render),
119 render_count);
120 vk_multialloc_add(&ma,
121 &spm_bgobj_state_per_render,
122 __typeof__(*spm_bgobj_state_per_render),
123 render_count);
124
125 if (!vk_multialloc_zalloc2(&ma,
126 &device->vk.alloc,
127 pAllocator,
128 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)) {
129 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
130 }
131
132 rstate->render_targets = render_targets;
133 rstate->render_targets_count = render_targets_count;
134 if (!pvr_render_targets_init(rstate->render_targets, render_targets_count)) {
135 result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
136 goto err_free_render_targets;
137 }
138
139 assert(rstate->scratch_buffer_size);
140 result = pvr_spm_scratch_buffer_get_buffer(device,
141 rstate->scratch_buffer_size,
142 &rstate->scratch_buffer);
143 if (result != VK_SUCCESS)
144 goto err_finish_render_targets;
145
146 result = pvr_render_state_create_ppp_state(device, rstate);
147 if (result != VK_SUCCESS)
148 goto err_release_scratch_buffer;
149
150 for (uint32_t i = 0; i < render_count; i++) {
151 result = pvr_arch_spm_init_eot_state(device,
152 &spm_eot_state_per_render[i],
153 rstate,
154 &renders[i]);
155 if (result != VK_SUCCESS)
156 goto err_finish_eot_state;
157
158 result = pvr_arch_spm_init_bgobj_state(device,
159 &spm_bgobj_state_per_render[i],
160 rstate,
161 &renders[i]);
162 if (result != VK_SUCCESS)
163 goto err_finish_bgobj_state;
164
165 continue;
166
167 err_finish_bgobj_state:
168 pvr_spm_finish_eot_state(device, &spm_eot_state_per_render[i]);
169
170 for (uint32_t j = 0; j < i; j++)
171 pvr_spm_finish_bgobj_state(device, &spm_bgobj_state_per_render[j]);
172
173 err_finish_eot_state:
174 for (uint32_t j = 0; j < i; j++)
175 pvr_spm_finish_eot_state(device, &spm_eot_state_per_render[j]);
176
177 goto err_free_ppp_state_bo;
178 }
179
180 rstate->render_count = render_count;
181 rstate->spm_eot_state_per_render = spm_eot_state_per_render;
182 rstate->spm_bgobj_state_per_render = spm_bgobj_state_per_render;
183
184 return VK_SUCCESS;
185
186 err_free_ppp_state_bo:
187 pvr_bo_suballoc_free(rstate->ppp_state_bo);
188
189 err_release_scratch_buffer:
190 pvr_spm_scratch_buffer_release(device, rstate->scratch_buffer);
191
192 err_finish_render_targets:
193 pvr_render_targets_fini(rstate->render_targets, render_targets_count);
194
195 err_free_render_targets:
196 vk_free2(&device->vk.alloc, pAllocator, rstate->render_targets);
197
198 return result;
199 }
200
201 static inline uint64_t
202 pvr_render_pass_get_scratch_buffer_size(struct pvr_device *device,
203 const struct pvr_render_pass *pass,
204 const struct pvr_render_state *rstate)
205 {
206 return pvr_arch_spm_scratch_buffer_calc_required_size(
207 pass->hw_setup->renders,
208 pass->hw_setup->render_count,
209 pass->max_sample_count,
210 rstate->width,
211 rstate->height);
212 }
213
214 VkResult
215 PVR_PER_ARCH(CreateFramebuffer)(VkDevice _device,
216 const VkFramebufferCreateInfo *pCreateInfo,
217 const VkAllocationCallbacks *pAllocator,
218 VkFramebuffer *pFramebuffer)
219 {
220 VK_FROM_HANDLE(pvr_render_pass, pass, pCreateInfo->renderPass);
221 VK_FROM_HANDLE(pvr_device, device, _device);
222 const VkFramebufferAttachmentsCreateInfoKHR *pImageless;
223 struct pvr_framebuffer *framebuffer;
224 struct pvr_image_view **attachments;
225 struct pvr_render_state *rstate;
226 VkResult result;
227
228 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
229
230 pImageless = vk_find_struct_const(pCreateInfo->pNext,
231 FRAMEBUFFER_ATTACHMENTS_CREATE_INFO);
232
233 VK_MULTIALLOC(ma);
234 vk_multialloc_add(&ma, &framebuffer, __typeof__(*framebuffer), 1);
235 vk_multialloc_add(&ma, &rstate, __typeof__(*rstate), 1);
236 vk_multialloc_add(&ma,
237 &attachments,
238 __typeof__(*attachments),
239 pCreateInfo->attachmentCount);
240
241 if (!vk_multialloc_zalloc2(&ma,
242 &device->vk.alloc,
243 pAllocator,
244 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT))
245 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
246
247 vk_object_base_init(&device->vk,
248 &framebuffer->base,
249 VK_OBJECT_TYPE_FRAMEBUFFER);
250
251 framebuffer->attachments = attachments;
252 if (!pImageless)
253 framebuffer->attachment_count = pCreateInfo->attachmentCount;
254 else
255 framebuffer->attachment_count = pImageless->attachmentImageInfoCount;
256 for (uint32_t i = 0; i < framebuffer->attachment_count; i++) {
257 if (!pImageless) {
258 framebuffer->attachments[i] =
259 pvr_image_view_from_handle(pCreateInfo->pAttachments[i]);
260 } else {
261 assert(i < pImageless->attachmentImageInfoCount);
262 }
263 }
264
265 rstate->width = pCreateInfo->width;
266 rstate->height = pCreateInfo->height;
267 rstate->layers = pCreateInfo->layers;
268 rstate->scratch_buffer_size =
269 pvr_render_pass_get_scratch_buffer_size(device, pass, rstate);
270
271 result = pvr_arch_render_state_setup(device,
272 pAllocator,
273 rstate,
274 pass->hw_setup->render_count,
275 pass->hw_setup->renders);
276 if (result != VK_SUCCESS)
277 goto err_free_framebuffer;
278
279 framebuffer->rstate = rstate;
280
281 *pFramebuffer = pvr_framebuffer_to_handle(framebuffer);
282
283 return VK_SUCCESS;
284
285 err_free_framebuffer:
286 vk_object_base_finish(&framebuffer->base);
287 vk_free2(&device->vk.alloc, pAllocator, framebuffer);
288
289 return result;
290 }
291
292 void PVR_PER_ARCH(DestroyFramebuffer)(VkDevice _device,
293 VkFramebuffer _fb,
294 const VkAllocationCallbacks *pAllocator)
295 {
296 VK_FROM_HANDLE(pvr_framebuffer, framebuffer, _fb);
297 VK_FROM_HANDLE(pvr_device, device, _device);
298
299 if (!framebuffer)
300 return;
301
302 pvr_render_state_cleanup(device, pAllocator, framebuffer->rstate);
303 /* the render state is freed with the framebuffer */
304
305 vk_object_base_finish(&framebuffer->base);
306 vk_free2(&device->vk.alloc, pAllocator, framebuffer);
307 }