1 /*
2 * Copyright © 2016 Red Hat.
3 * Copyright © 2016 Bas Nieuwenhuizen
4 * SPDX-License-Identifier: MIT
5 */
6
7 /**
8 * @file
9 *
10 * We use the bindless descriptor model, which maps fairly closely to how
11 * Vulkan descriptor sets work. The two exceptions are input attachments and
12 * dynamic descriptors, which have to be patched when recording command
13 * buffers. We reserve an extra descriptor set for these. This descriptor set
14 * contains all the input attachments in the pipeline, in order, and then all
15 * the dynamic descriptors. The dynamic descriptors are stored in the CPU-side
16 * datastructure for each tu_descriptor_set, and then combined into one big
17 * descriptor set at CmdBindDescriptors time/draw time.
18 */
19
20 #include "tu_descriptor_set.h"
21
22 #include <fcntl.h>
23
24 #include "vulkan/vulkan_android.h"
25
26 #include "util/mesa-sha1.h"
27 #include "vk_descriptors.h"
28 #include "vk_util.h"
29
30 #include "tu_buffer.h"
31 #include "tu_buffer_view.h"
32 #include "tu_device.h"
33 #include "tu_image.h"
34 #include "tu_formats.h"
35 #include "tu_rmv.h"
36
37 static inline uint8_t *
pool_base(struct tu_descriptor_pool * pool)38 pool_base(struct tu_descriptor_pool *pool)
39 {
40 return pool->host_bo ?: (uint8_t *) pool->bo->map;
41 }
42
43 static uint32_t
descriptor_size(struct tu_device * dev,const VkDescriptorSetLayoutBinding * binding,VkDescriptorType type)44 descriptor_size(struct tu_device *dev,
45 const VkDescriptorSetLayoutBinding *binding,
46 VkDescriptorType type)
47 {
48 switch (type) {
49 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
50 if (TU_DEBUG(DYNAMIC))
51 return A6XX_TEX_CONST_DWORDS * 4;
52
53 /* Input attachment doesn't use descriptor sets at all */
54 return 0;
55 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
56 /* We make offsets and sizes all 16 dwords, to match how the hardware
57 * interprets indices passed to sample/load/store instructions in
58 * multiples of 16 dwords. This means that "normal" descriptors are all
59 * of size 16, with padding for smaller descriptors like uniform storage
60 * descriptors which are less than 16 dwords. However combined images
61 * and samplers are actually two descriptors, so they have size 2.
62 */
63 return A6XX_TEX_CONST_DWORDS * 4 * 2;
64 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
65 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
66 /* isam.v allows using a single 16-bit descriptor for both 16-bit and
67 * 32-bit loads. If not available but 16-bit storage is still supported,
68 * two separate descriptors are required.
69 */
70 return A6XX_TEX_CONST_DWORDS * 4 * (1 +
71 COND(dev->physical_device->info->a6xx.storage_16bit &&
72 !dev->physical_device->info->a6xx.has_isam_v, 1) +
73 COND(dev->physical_device->info->a7xx.storage_8bit, 1));
74 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
75 return binding->descriptorCount;
76 default:
77 return A6XX_TEX_CONST_DWORDS * 4;
78 }
79 }
80
81 static bool
is_dynamic(VkDescriptorType type)82 is_dynamic(VkDescriptorType type)
83 {
84 return type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC ||
85 type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
86 }
87
88 static uint32_t
mutable_descriptor_size(struct tu_device * dev,const VkMutableDescriptorTypeListEXT * list)89 mutable_descriptor_size(struct tu_device *dev,
90 const VkMutableDescriptorTypeListEXT *list)
91 {
92 uint32_t max_size = 0;
93
94 for (uint32_t i = 0; i < list->descriptorTypeCount; i++) {
95 uint32_t size = descriptor_size(dev, NULL, list->pDescriptorTypes[i]);
96 max_size = MAX2(max_size, size);
97 }
98
99 return max_size;
100 }
101
102 static void
tu_descriptor_set_layout_destroy(struct vk_device * vk_dev,struct vk_descriptor_set_layout * vk_layout)103 tu_descriptor_set_layout_destroy(struct vk_device *vk_dev,
104 struct vk_descriptor_set_layout *vk_layout)
105 {
106 struct tu_device *dev = container_of(vk_dev, struct tu_device, vk);
107 struct tu_descriptor_set_layout *layout =
108 container_of(vk_layout, struct tu_descriptor_set_layout, vk);
109
110 if (layout->embedded_samplers)
111 tu_bo_finish(dev, layout->embedded_samplers);
112 vk_descriptor_set_layout_destroy(vk_dev, vk_layout);
113 }
114
115 VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDescriptorSetLayout(VkDevice _device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorSetLayout * pSetLayout)116 tu_CreateDescriptorSetLayout(
117 VkDevice _device,
118 const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
119 const VkAllocationCallbacks *pAllocator,
120 VkDescriptorSetLayout *pSetLayout)
121 {
122 VK_FROM_HANDLE(tu_device, device, _device);
123 struct tu_descriptor_set_layout *set_layout;
124
125 assert(pCreateInfo->sType ==
126 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
127 const VkDescriptorSetLayoutBindingFlagsCreateInfo *variable_flags =
128 vk_find_struct_const(
129 pCreateInfo->pNext,
130 DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
131 const VkMutableDescriptorTypeCreateInfoEXT *mutable_info =
132 vk_find_struct_const(
133 pCreateInfo->pNext,
134 MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
135
136 uint32_t num_bindings = 0;
137 uint32_t immutable_sampler_count = 0;
138 uint32_t ycbcr_sampler_count = 0;
139 for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
140 num_bindings = MAX2(num_bindings, pCreateInfo->pBindings[j].binding + 1);
141 if ((pCreateInfo->pBindings[j].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
142 pCreateInfo->pBindings[j].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) &&
143 pCreateInfo->pBindings[j].pImmutableSamplers) {
144 immutable_sampler_count += pCreateInfo->pBindings[j].descriptorCount;
145
146 bool has_ycbcr_sampler = false;
147 for (unsigned i = 0; i < pCreateInfo->pBindings[j].descriptorCount; ++i) {
148 if (tu_sampler_from_handle(pCreateInfo->pBindings[j].pImmutableSamplers[i])->vk.ycbcr_conversion)
149 has_ycbcr_sampler = true;
150 }
151
152 if (has_ycbcr_sampler)
153 ycbcr_sampler_count += pCreateInfo->pBindings[j].descriptorCount;
154 }
155 }
156
157 uint32_t samplers_offset =
158 offsetof_arr(struct tu_descriptor_set_layout, binding, num_bindings);
159
160 /* note: only need to store TEX_SAMP_DWORDS for immutable samples,
161 * but using struct tu_sampler makes things simpler */
162 uint32_t size = samplers_offset +
163 immutable_sampler_count * sizeof(struct tu_sampler) +
164 ycbcr_sampler_count * sizeof(struct vk_ycbcr_conversion);
165
166 set_layout =
167 (struct tu_descriptor_set_layout *) vk_descriptor_set_layout_zalloc(
168 &device->vk, size);
169 if (!set_layout)
170 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
171
172 set_layout->flags = pCreateInfo->flags;
173 set_layout->vk.destroy = tu_descriptor_set_layout_destroy;
174
175 /* We just allocate all the immutable samplers at the end of the struct */
176 struct tu_sampler *samplers =
177 (struct tu_sampler *) &set_layout->binding[num_bindings];
178 struct vk_ycbcr_conversion_state *ycbcr_samplers =
179 (struct vk_ycbcr_conversion_state *) &samplers[immutable_sampler_count];
180
181 VkDescriptorSetLayoutBinding *bindings = NULL;
182 VkResult result = vk_create_sorted_bindings(
183 pCreateInfo->pBindings, pCreateInfo->bindingCount, &bindings);
184 if (result != VK_SUCCESS) {
185 vk_object_free(&device->vk, pAllocator, set_layout);
186 return vk_error(device, result);
187 }
188
189 set_layout->binding_count = num_bindings;
190 set_layout->shader_stages = 0;
191 set_layout->has_immutable_samplers = false;
192 set_layout->has_inline_uniforms = false;
193 set_layout->size = 0;
194
195 uint32_t dynamic_offset_size = 0;
196
197 for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
198 const VkDescriptorSetLayoutBinding *binding = bindings + j;
199 uint32_t b = binding->binding;
200
201 set_layout->binding[b].type = binding->descriptorType;
202 set_layout->binding[b].array_size =
203 binding->descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK ?
204 1 : binding->descriptorCount;
205 set_layout->binding[b].offset = set_layout->size;
206 set_layout->binding[b].dynamic_offset_offset = dynamic_offset_size;
207 set_layout->binding[b].shader_stages = binding->stageFlags;
208
209 if (binding->descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
210 /* For mutable descriptor types we must allocate a size that fits the
211 * largest descriptor type that the binding can mutate to.
212 */
213 set_layout->binding[b].size =
214 mutable_descriptor_size(device, &mutable_info->pMutableDescriptorTypeLists[j]);
215 } else {
216 set_layout->binding[b].size =
217 descriptor_size(device, binding, binding->descriptorType);
218 }
219
220 if (binding->descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK)
221 set_layout->has_inline_uniforms = true;
222
223 if (variable_flags && binding->binding < variable_flags->bindingCount &&
224 (variable_flags->pBindingFlags[binding->binding] &
225 VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT)) {
226 assert(!binding->pImmutableSamplers); /* Terribly ill defined how
227 many samplers are valid */
228 assert(binding->binding == num_bindings - 1);
229
230 set_layout->has_variable_descriptors = true;
231 }
232
233 if ((binding->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
234 binding->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) &&
235 binding->pImmutableSamplers) {
236 set_layout->binding[b].immutable_samplers_offset = samplers_offset;
237 set_layout->has_immutable_samplers = true;
238
239 for (uint32_t i = 0; i < binding->descriptorCount; i++)
240 samplers[i] = *tu_sampler_from_handle(binding->pImmutableSamplers[i]);
241
242 samplers += binding->descriptorCount;
243 samplers_offset += sizeof(struct tu_sampler) * binding->descriptorCount;
244
245 bool has_ycbcr_sampler = false;
246 for (unsigned i = 0; i < pCreateInfo->pBindings[j].descriptorCount; ++i) {
247 if (tu_sampler_from_handle(binding->pImmutableSamplers[i])->vk.ycbcr_conversion)
248 has_ycbcr_sampler = true;
249 }
250
251 if (has_ycbcr_sampler) {
252 set_layout->binding[b].ycbcr_samplers_offset =
253 (const char*)ycbcr_samplers - (const char*)set_layout;
254 for (uint32_t i = 0; i < binding->descriptorCount; i++) {
255 struct tu_sampler *sampler = tu_sampler_from_handle(binding->pImmutableSamplers[i]);
256 if (sampler->vk.ycbcr_conversion)
257 ycbcr_samplers[i] = sampler->vk.ycbcr_conversion->state;
258 else
259 ycbcr_samplers[i].ycbcr_model = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
260 }
261 ycbcr_samplers += binding->descriptorCount;
262 } else {
263 set_layout->binding[b].ycbcr_samplers_offset = 0;
264 }
265 }
266
267 uint32_t size =
268 ALIGN_POT(set_layout->binding[b].array_size * set_layout->binding[b].size, 4 * A6XX_TEX_CONST_DWORDS);
269 if (is_dynamic(binding->descriptorType)) {
270 dynamic_offset_size += size;
271 } else {
272 set_layout->size += size;
273 }
274
275 set_layout->shader_stages |= binding->stageFlags;
276 }
277
278 free(bindings);
279
280 set_layout->dynamic_offset_size = dynamic_offset_size;
281
282 if (pCreateInfo->flags &
283 VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT) {
284 result = tu_bo_init_new(device, &set_layout->vk.base,
285 &set_layout->embedded_samplers, set_layout->size,
286 (enum tu_bo_alloc_flags) (TU_BO_ALLOC_ALLOW_DUMP |
287 TU_BO_ALLOC_INTERNAL_RESOURCE),
288 "embedded samplers");
289 if (result != VK_SUCCESS) {
290 vk_object_free(&device->vk, pAllocator, set_layout);
291 return vk_error(device, result);
292 }
293
294 result = tu_bo_map(device, set_layout->embedded_samplers, NULL);
295 if (result != VK_SUCCESS) {
296 tu_bo_finish(device, set_layout->embedded_samplers);
297 vk_object_free(&device->vk, pAllocator, set_layout);
298 return vk_error(device, result);
299 }
300
301 char *map = (char *) set_layout->embedded_samplers->map;
302 for (unsigned i = 0; i < set_layout->binding_count; i++) {
303 if (!set_layout->binding[i].immutable_samplers_offset)
304 continue;
305
306 unsigned offset = set_layout->binding[i].offset;
307 const struct tu_sampler *sampler =
308 (const struct tu_sampler *)((const char *)set_layout +
309 set_layout->binding[i].immutable_samplers_offset);
310 assert(set_layout->binding[i].array_size == 1);
311 memcpy(map + offset, sampler->descriptor,
312 sizeof(sampler->descriptor));
313 }
314 }
315
316 *pSetLayout = tu_descriptor_set_layout_to_handle(set_layout);
317
318 return VK_SUCCESS;
319 }
320
321 VKAPI_ATTR void VKAPI_CALL
tu_GetDescriptorSetLayoutSupport(VkDevice _device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,VkDescriptorSetLayoutSupport * pSupport)322 tu_GetDescriptorSetLayoutSupport(
323 VkDevice _device,
324 const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
325 VkDescriptorSetLayoutSupport *pSupport)
326 {
327 VK_FROM_HANDLE(tu_device, device, _device);
328
329 VkDescriptorSetLayoutBinding *bindings = NULL;
330 VkResult result = vk_create_sorted_bindings(
331 pCreateInfo->pBindings, pCreateInfo->bindingCount, &bindings);
332 if (result != VK_SUCCESS) {
333 pSupport->supported = false;
334 return;
335 }
336
337 const VkDescriptorSetLayoutBindingFlagsCreateInfo *variable_flags =
338 vk_find_struct_const(
339 pCreateInfo->pNext,
340 DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
341 VkDescriptorSetVariableDescriptorCountLayoutSupport *variable_count =
342 vk_find_struct(
343 pSupport->pNext,
344 DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
345 const VkMutableDescriptorTypeCreateInfoEXT *mutable_info =
346 vk_find_struct_const(
347 pCreateInfo->pNext,
348 MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
349
350 if (variable_count) {
351 variable_count->maxVariableDescriptorCount = 0;
352 }
353
354 bool supported = true;
355 uint64_t size = 0;
356 for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) {
357 const VkDescriptorSetLayoutBinding *binding = bindings + i;
358
359 uint64_t descriptor_sz;
360
361 if (is_dynamic(binding->descriptorType)) {
362 descriptor_sz = 0;
363 } else if (binding->descriptorType == VK_DESCRIPTOR_TYPE_MUTABLE_EXT) {
364 const VkMutableDescriptorTypeListEXT *list =
365 &mutable_info->pMutableDescriptorTypeLists[i];
366
367 for (uint32_t j = 0; j < list->descriptorTypeCount; j++) {
368 /* Don't support the input attachement and combined image sampler type
369 * for mutable descriptors */
370 if (list->pDescriptorTypes[j] == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT ||
371 list->pDescriptorTypes[j] == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
372 list->pDescriptorTypes[j] == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
373 supported = false;
374 goto out;
375 }
376 }
377
378 descriptor_sz =
379 mutable_descriptor_size(device, &mutable_info->pMutableDescriptorTypeLists[i]);
380 } else {
381 descriptor_sz = descriptor_size(device, binding, binding->descriptorType);
382 }
383 uint64_t descriptor_alignment = 4 * A6XX_TEX_CONST_DWORDS;
384
385 if (size && !ALIGN_POT(size, descriptor_alignment)) {
386 supported = false;
387 }
388 size = ALIGN_POT(size, descriptor_alignment);
389
390 uint64_t max_count = MAX_SET_SIZE;
391 unsigned descriptor_count = binding->descriptorCount;
392 if (binding->descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
393 max_count = MAX_SET_SIZE - size;
394 descriptor_count = descriptor_sz;
395 descriptor_sz = 1;
396 } else if (descriptor_sz) {
397 max_count = (MAX_SET_SIZE - size) / descriptor_sz;
398 }
399
400 if (max_count < descriptor_count) {
401 supported = false;
402 }
403
404 if (variable_flags && binding->binding < variable_flags->bindingCount &&
405 variable_count &&
406 (variable_flags->pBindingFlags[binding->binding] &
407 VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT)) {
408 variable_count->maxVariableDescriptorCount =
409 MIN2(UINT32_MAX, max_count);
410 }
411 size += descriptor_count * descriptor_sz;
412 }
413
414 out:
415 free(bindings);
416
417 pSupport->supported = supported;
418 }
419
420 VKAPI_ATTR void VKAPI_CALL
tu_GetDescriptorSetLayoutSizeEXT(VkDevice _device,VkDescriptorSetLayout _layout,VkDeviceSize * pLayoutSizeInBytes)421 tu_GetDescriptorSetLayoutSizeEXT(
422 VkDevice _device,
423 VkDescriptorSetLayout _layout,
424 VkDeviceSize *pLayoutSizeInBytes)
425 {
426 VK_FROM_HANDLE(tu_descriptor_set_layout, layout, _layout);
427
428 *pLayoutSizeInBytes = layout->size;
429 }
430
431 VKAPI_ATTR void VKAPI_CALL
tu_GetDescriptorSetLayoutBindingOffsetEXT(VkDevice _device,VkDescriptorSetLayout _layout,uint32_t binding,VkDeviceSize * pOffset)432 tu_GetDescriptorSetLayoutBindingOffsetEXT(
433 VkDevice _device,
434 VkDescriptorSetLayout _layout,
435 uint32_t binding,
436 VkDeviceSize *pOffset)
437 {
438 VK_FROM_HANDLE(tu_descriptor_set_layout, layout, _layout);
439
440 assert(binding < layout->binding_count);
441 *pOffset = layout->binding[binding].offset;
442 }
443
444 /* Note: we must hash any values used in tu_lower_io(). */
445
446 #define SHA1_UPDATE_VALUE(ctx, x) _mesa_sha1_update(ctx, &(x), sizeof(x));
447
448 static void
sha1_update_ycbcr_sampler(struct mesa_sha1 * ctx,const struct vk_ycbcr_conversion_state * sampler)449 sha1_update_ycbcr_sampler(struct mesa_sha1 *ctx,
450 const struct vk_ycbcr_conversion_state *sampler)
451 {
452 SHA1_UPDATE_VALUE(ctx, sampler->ycbcr_model);
453 SHA1_UPDATE_VALUE(ctx, sampler->ycbcr_range);
454 SHA1_UPDATE_VALUE(ctx, sampler->format);
455 }
456
457 static void
sha1_update_descriptor_set_binding_layout(struct mesa_sha1 * ctx,const struct tu_descriptor_set_binding_layout * layout,const struct tu_descriptor_set_layout * set_layout)458 sha1_update_descriptor_set_binding_layout(struct mesa_sha1 *ctx,
459 const struct tu_descriptor_set_binding_layout *layout,
460 const struct tu_descriptor_set_layout *set_layout)
461 {
462 SHA1_UPDATE_VALUE(ctx, layout->type);
463 SHA1_UPDATE_VALUE(ctx, layout->offset);
464 SHA1_UPDATE_VALUE(ctx, layout->size);
465 SHA1_UPDATE_VALUE(ctx, layout->array_size);
466 SHA1_UPDATE_VALUE(ctx, layout->dynamic_offset_offset);
467 SHA1_UPDATE_VALUE(ctx, layout->immutable_samplers_offset);
468
469 const struct vk_ycbcr_conversion_state *ycbcr_samplers =
470 tu_immutable_ycbcr_samplers(set_layout, layout);
471
472 if (ycbcr_samplers) {
473 for (unsigned i = 0; i < layout->array_size; i++)
474 sha1_update_ycbcr_sampler(ctx, ycbcr_samplers + i);
475 }
476 }
477
478
479 static void
sha1_update_descriptor_set_layout(struct mesa_sha1 * ctx,const struct tu_descriptor_set_layout * layout)480 sha1_update_descriptor_set_layout(struct mesa_sha1 *ctx,
481 const struct tu_descriptor_set_layout *layout)
482 {
483 SHA1_UPDATE_VALUE(ctx, layout->has_variable_descriptors);
484
485 for (uint16_t i = 0; i < layout->binding_count; i++)
486 sha1_update_descriptor_set_binding_layout(ctx, &layout->binding[i],
487 layout);
488 }
489
490 /*
491 * Pipeline layouts. These have nothing to do with the pipeline. They are
492 * just multiple descriptor set layouts pasted together.
493 */
494
495 void
tu_pipeline_layout_init(struct tu_pipeline_layout * layout)496 tu_pipeline_layout_init(struct tu_pipeline_layout *layout)
497 {
498 struct mesa_sha1 ctx;
499 _mesa_sha1_init(&ctx);
500 for (unsigned s = 0; s < layout->num_sets; s++) {
501 if (layout->set[s].layout)
502 sha1_update_descriptor_set_layout(&ctx, layout->set[s].layout);
503 }
504 _mesa_sha1_update(&ctx, &layout->num_sets, sizeof(layout->num_sets));
505 _mesa_sha1_update(&ctx, &layout->push_constant_size,
506 sizeof(layout->push_constant_size));
507 _mesa_sha1_final(&ctx, layout->sha1);
508 }
509
510 VKAPI_ATTR VkResult VKAPI_CALL
tu_CreatePipelineLayout(VkDevice _device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout)511 tu_CreatePipelineLayout(VkDevice _device,
512 const VkPipelineLayoutCreateInfo *pCreateInfo,
513 const VkAllocationCallbacks *pAllocator,
514 VkPipelineLayout *pPipelineLayout)
515 {
516 VK_FROM_HANDLE(tu_device, device, _device);
517 struct tu_pipeline_layout *layout;
518
519 assert(pCreateInfo->sType ==
520 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
521
522 layout = (struct tu_pipeline_layout *) vk_object_alloc(
523 &device->vk, pAllocator, sizeof(*layout),
524 VK_OBJECT_TYPE_PIPELINE_LAYOUT);
525 if (layout == NULL)
526 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
527
528 layout->num_sets = pCreateInfo->setLayoutCount;
529 for (uint32_t set = 0; set < pCreateInfo->setLayoutCount; set++) {
530 VK_FROM_HANDLE(tu_descriptor_set_layout, set_layout,
531 pCreateInfo->pSetLayouts[set]);
532
533 assert(set < device->physical_device->usable_sets);
534 layout->set[set].layout = set_layout;
535 if (set_layout)
536 vk_descriptor_set_layout_ref(&set_layout->vk);
537 }
538
539 layout->push_constant_size = 0;
540
541 for (unsigned i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) {
542 const VkPushConstantRange *range = pCreateInfo->pPushConstantRanges + i;
543 layout->push_constant_size =
544 MAX2(layout->push_constant_size, range->offset + range->size);
545 }
546
547 layout->push_constant_size = align(layout->push_constant_size, 16);
548
549 tu_pipeline_layout_init(layout);
550
551 *pPipelineLayout = tu_pipeline_layout_to_handle(layout);
552
553 return VK_SUCCESS;
554 }
555
556 VKAPI_ATTR void VKAPI_CALL
tu_DestroyPipelineLayout(VkDevice _device,VkPipelineLayout _pipelineLayout,const VkAllocationCallbacks * pAllocator)557 tu_DestroyPipelineLayout(VkDevice _device,
558 VkPipelineLayout _pipelineLayout,
559 const VkAllocationCallbacks *pAllocator)
560 {
561 VK_FROM_HANDLE(tu_device, device, _device);
562 VK_FROM_HANDLE(tu_pipeline_layout, pipeline_layout, _pipelineLayout);
563
564 if (!pipeline_layout)
565 return;
566
567 for (uint32_t i = 0; i < pipeline_layout->num_sets; i++) {
568 if (pipeline_layout->set[i].layout)
569 vk_descriptor_set_layout_unref(&device->vk, &pipeline_layout->set[i].layout->vk);
570 }
571
572 vk_object_free(&device->vk, pAllocator, pipeline_layout);
573 }
574
575 #define EMPTY 1
576
577 static VkResult
tu_descriptor_set_create(struct tu_device * device,struct tu_descriptor_pool * pool,struct tu_descriptor_set_layout * layout,uint32_t variable_count,struct tu_descriptor_set ** out_set)578 tu_descriptor_set_create(struct tu_device *device,
579 struct tu_descriptor_pool *pool,
580 struct tu_descriptor_set_layout *layout,
581 uint32_t variable_count,
582 struct tu_descriptor_set **out_set)
583 {
584 struct tu_descriptor_set *set;
585 unsigned dynamic_offset = sizeof(struct tu_descriptor_set);
586 unsigned mem_size = dynamic_offset + layout->dynamic_offset_size;
587
588 if (pool->host_memory_base) {
589 if (pool->host_memory_end - pool->host_memory_ptr < mem_size)
590 return vk_error(device, VK_ERROR_OUT_OF_POOL_MEMORY);
591
592 set = (struct tu_descriptor_set*)pool->host_memory_ptr;
593 pool->host_memory_ptr += mem_size;
594 } else {
595 set = (struct tu_descriptor_set *) vk_alloc2(
596 &device->vk.alloc, NULL, mem_size, 8,
597 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
598
599 if (!set)
600 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
601 }
602
603 memset(set, 0, mem_size);
604 vk_object_base_init(&device->vk, &set->base, VK_OBJECT_TYPE_DESCRIPTOR_SET);
605
606 if (layout->dynamic_offset_size) {
607 set->dynamic_descriptors = (uint32_t *)((uint8_t*)set + dynamic_offset);
608 }
609
610 set->layout = layout;
611 set->pool = pool;
612 uint32_t layout_size = layout->size;
613 if (layout->has_variable_descriptors) {
614 struct tu_descriptor_set_binding_layout *binding =
615 &layout->binding[layout->binding_count - 1];
616 if (binding->type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
617 layout_size = binding->offset +
618 ALIGN(variable_count, 4 * A6XX_TEX_CONST_DWORDS);
619 } else {
620 uint32_t stride = binding->size;
621 layout_size = binding->offset + variable_count * stride;
622 }
623 }
624
625 if (layout_size) {
626 set->size = layout_size;
627
628 if (!pool->host_memory_base && pool->entry_count == pool->max_entry_count) {
629 vk_object_free(&device->vk, NULL, set);
630 return vk_error(device, VK_ERROR_OUT_OF_POOL_MEMORY);
631 }
632
633 /* try to allocate linearly first, so that we don't spend
634 * time looking for gaps if the app only allocates &
635 * resets via the pool. */
636 if (pool->current_offset + layout_size <= pool->size) {
637 set->mapped_ptr = (uint32_t*)(pool_base(pool) + pool->current_offset);
638 set->va = pool->host_bo ? 0 : pool->bo->iova + pool->current_offset;
639
640 if (!pool->host_memory_base) {
641 pool->entries[pool->entry_count].offset = pool->current_offset;
642 pool->entries[pool->entry_count].size = layout_size;
643 pool->entries[pool->entry_count].set = set;
644 pool->entry_count++;
645 }
646 pool->current_offset += layout_size;
647 } else if (!pool->host_memory_base) {
648 uint64_t offset = 0;
649 int index;
650
651 for (index = 0; index < pool->entry_count; ++index) {
652 if (pool->entries[index].offset - offset >= layout_size)
653 break;
654 offset = pool->entries[index].offset + pool->entries[index].size;
655 }
656
657 if (pool->size - offset < layout_size) {
658 vk_object_free(&device->vk, NULL, set);
659 return vk_error(device, VK_ERROR_OUT_OF_POOL_MEMORY);
660 }
661
662 set->mapped_ptr = (uint32_t*)(pool_base(pool) + offset);
663 set->va = pool->host_bo ? 0 : pool->bo->iova + offset;
664
665 memmove(&pool->entries[index + 1], &pool->entries[index],
666 sizeof(pool->entries[0]) * (pool->entry_count - index));
667 pool->entries[index].offset = offset;
668 pool->entries[index].size = layout_size;
669 pool->entries[index].set = set;
670 pool->entry_count++;
671 } else
672 return vk_error(device, VK_ERROR_OUT_OF_POOL_MEMORY);
673 }
674
675 if (layout->has_immutable_samplers) {
676 for (unsigned i = 0; i < layout->binding_count; ++i) {
677 if (!layout->binding[i].immutable_samplers_offset)
678 continue;
679
680 unsigned offset = layout->binding[i].offset / 4;
681 if (layout->binding[i].type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
682 offset += A6XX_TEX_CONST_DWORDS;
683
684 const struct tu_sampler *samplers =
685 (const struct tu_sampler *)((const char *)layout +
686 layout->binding[i].immutable_samplers_offset);
687 for (unsigned j = 0; j < layout->binding[i].array_size; ++j) {
688 memcpy(set->mapped_ptr + offset, samplers[j].descriptor,
689 sizeof(samplers[j].descriptor));
690 offset += layout->binding[i].size / 4;
691 }
692 }
693 }
694
695 vk_descriptor_set_layout_ref(&layout->vk);
696 list_addtail(&set->pool_link, &pool->desc_sets);
697
698 *out_set = set;
699 return VK_SUCCESS;
700 }
701
702 static void
tu_descriptor_set_destroy(struct tu_device * device,struct tu_descriptor_pool * pool,struct tu_descriptor_set * set,bool free_bo)703 tu_descriptor_set_destroy(struct tu_device *device,
704 struct tu_descriptor_pool *pool,
705 struct tu_descriptor_set *set,
706 bool free_bo)
707 {
708 assert(!pool->host_memory_base);
709
710 if (free_bo && set->size && !pool->host_memory_base) {
711 uint32_t offset = (uint8_t*)set->mapped_ptr - pool_base(pool);
712
713 for (int i = 0; i < pool->entry_count; ++i) {
714 if (pool->entries[i].offset == offset) {
715 memmove(&pool->entries[i], &pool->entries[i+1],
716 sizeof(pool->entries[i]) * (pool->entry_count - i - 1));
717 --pool->entry_count;
718 break;
719 }
720 }
721 }
722
723 vk_object_free(&device->vk, NULL, set);
724 }
725
726 VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDescriptorPool(VkDevice _device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool)727 tu_CreateDescriptorPool(VkDevice _device,
728 const VkDescriptorPoolCreateInfo *pCreateInfo,
729 const VkAllocationCallbacks *pAllocator,
730 VkDescriptorPool *pDescriptorPool)
731 {
732 VK_FROM_HANDLE(tu_device, device, _device);
733 struct tu_descriptor_pool *pool;
734 uint64_t size = sizeof(struct tu_descriptor_pool);
735 uint64_t bo_size = 0, dynamic_size = 0;
736 VkResult ret;
737
738 const VkMutableDescriptorTypeCreateInfoEXT *mutable_info =
739 vk_find_struct_const( pCreateInfo->pNext,
740 MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
741
742 const VkDescriptorPoolInlineUniformBlockCreateInfo *inline_info =
743 vk_find_struct_const(pCreateInfo->pNext,
744 DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO);
745
746 if (inline_info) {
747 /* We have to factor in the padding for each binding. The sizes are 4
748 * aligned but we have to align to 4 * A6XX_TEX_CONST_DWORDS bytes, and in
749 * the worst case each inline binding has a size of 4 bytes and we have
750 * to pad each one out.
751 */
752 bo_size += (4 * A6XX_TEX_CONST_DWORDS - 4) *
753 inline_info->maxInlineUniformBlockBindings;
754 }
755
756 for (unsigned i = 0; i < pCreateInfo->poolSizeCount; ++i) {
757 const VkDescriptorPoolSize *pool_size = &pCreateInfo->pPoolSizes[i];
758
759 switch (pool_size->type) {
760 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
761 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
762 dynamic_size += descriptor_size(device, NULL, pool_size->type) *
763 pool_size->descriptorCount;
764 break;
765 case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
766 if (mutable_info && i < mutable_info->mutableDescriptorTypeListCount &&
767 mutable_info->pMutableDescriptorTypeLists[i].descriptorTypeCount > 0) {
768 bo_size +=
769 mutable_descriptor_size(device, &mutable_info->pMutableDescriptorTypeLists[i]) *
770 pool_size->descriptorCount;
771 } else {
772 /* Allocate the maximum size possible. */
773 bo_size += 2 * A6XX_TEX_CONST_DWORDS * 4 *
774 pool_size->descriptorCount;
775 }
776 break;
777 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
778 bo_size += pool_size->descriptorCount;
779 break;
780 default:
781 bo_size += descriptor_size(device, NULL, pool_size->type) *
782 pool_size->descriptorCount;
783 break;
784 }
785 }
786
787 if (!(pCreateInfo->flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT)) {
788 uint64_t host_size = pCreateInfo->maxSets * sizeof(struct tu_descriptor_set);
789 host_size += dynamic_size;
790 size += host_size;
791 } else {
792 size += sizeof(struct tu_descriptor_pool_entry) * pCreateInfo->maxSets;
793 }
794
795 pool = (struct tu_descriptor_pool *) vk_object_zalloc(
796 &device->vk, pAllocator, size, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
797 if (!pool)
798 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
799
800 if (!(pCreateInfo->flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT)) {
801 pool->host_memory_base = (uint8_t*)pool + sizeof(struct tu_descriptor_pool);
802 pool->host_memory_ptr = pool->host_memory_base;
803 pool->host_memory_end = (uint8_t*)pool + size;
804 }
805
806 if (bo_size) {
807 if (!(pCreateInfo->flags & VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT)) {
808 ret = tu_bo_init_new(device, &pool->base, &pool->bo, bo_size,
809 TU_BO_ALLOC_ALLOW_DUMP, "descriptor pool");
810 if (ret)
811 goto fail_alloc;
812
813 ret = tu_bo_map(device, pool->bo, NULL);
814 if (ret)
815 goto fail_map;
816 } else {
817 pool->host_bo =
818 (uint8_t *) vk_alloc2(&device->vk.alloc, pAllocator, bo_size, 8,
819 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
820 if (!pool->host_bo) {
821 ret = VK_ERROR_OUT_OF_HOST_MEMORY;
822 goto fail_alloc;
823 }
824 }
825 }
826 pool->size = bo_size;
827 pool->max_entry_count = pCreateInfo->maxSets;
828
829 list_inithead(&pool->desc_sets);
830
831 TU_RMV(descriptor_pool_create, device, pCreateInfo, pool);
832
833 *pDescriptorPool = tu_descriptor_pool_to_handle(pool);
834 return VK_SUCCESS;
835
836 fail_map:
837 tu_bo_finish(device, pool->bo);
838 fail_alloc:
839 vk_object_free(&device->vk, pAllocator, pool);
840 return ret;
841 }
842
843 VKAPI_ATTR void VKAPI_CALL
tu_DestroyDescriptorPool(VkDevice _device,VkDescriptorPool _pool,const VkAllocationCallbacks * pAllocator)844 tu_DestroyDescriptorPool(VkDevice _device,
845 VkDescriptorPool _pool,
846 const VkAllocationCallbacks *pAllocator)
847 {
848 VK_FROM_HANDLE(tu_device, device, _device);
849 VK_FROM_HANDLE(tu_descriptor_pool, pool, _pool);
850
851 if (!pool)
852 return;
853
854 TU_RMV(resource_destroy, device, pool);
855
856 list_for_each_entry_safe(struct tu_descriptor_set, set,
857 &pool->desc_sets, pool_link) {
858 vk_descriptor_set_layout_unref(&device->vk, &set->layout->vk);
859 }
860
861 if (!pool->host_memory_base) {
862 for(int i = 0; i < pool->entry_count; ++i) {
863 tu_descriptor_set_destroy(device, pool, pool->entries[i].set, false);
864 }
865 }
866
867 if (pool->size) {
868 if (pool->host_bo)
869 vk_free2(&device->vk.alloc, pAllocator, pool->host_bo);
870 else
871 tu_bo_finish(device, pool->bo);
872 }
873
874 vk_object_free(&device->vk, pAllocator, pool);
875 }
876
877 VKAPI_ATTR VkResult VKAPI_CALL
tu_ResetDescriptorPool(VkDevice _device,VkDescriptorPool descriptorPool,VkDescriptorPoolResetFlags flags)878 tu_ResetDescriptorPool(VkDevice _device,
879 VkDescriptorPool descriptorPool,
880 VkDescriptorPoolResetFlags flags)
881 {
882 VK_FROM_HANDLE(tu_device, device, _device);
883 VK_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool);
884
885 list_for_each_entry_safe(struct tu_descriptor_set, set,
886 &pool->desc_sets, pool_link) {
887 vk_descriptor_set_layout_unref(&device->vk, &set->layout->vk);
888 }
889 list_inithead(&pool->desc_sets);
890
891 if (!pool->host_memory_base) {
892 for(int i = 0; i < pool->entry_count; ++i) {
893 tu_descriptor_set_destroy(device, pool, pool->entries[i].set, false);
894 }
895 pool->entry_count = 0;
896 }
897
898 pool->current_offset = 0;
899 pool->host_memory_ptr = pool->host_memory_base;
900
901 return VK_SUCCESS;
902 }
903
904 VKAPI_ATTR VkResult VKAPI_CALL
tu_AllocateDescriptorSets(VkDevice _device,const VkDescriptorSetAllocateInfo * pAllocateInfo,VkDescriptorSet * pDescriptorSets)905 tu_AllocateDescriptorSets(VkDevice _device,
906 const VkDescriptorSetAllocateInfo *pAllocateInfo,
907 VkDescriptorSet *pDescriptorSets)
908 {
909 VK_FROM_HANDLE(tu_device, device, _device);
910 VK_FROM_HANDLE(tu_descriptor_pool, pool, pAllocateInfo->descriptorPool);
911
912 VkResult result = VK_SUCCESS;
913 uint32_t i;
914 struct tu_descriptor_set *set = NULL;
915
916 const VkDescriptorSetVariableDescriptorCountAllocateInfo *variable_counts =
917 vk_find_struct_const(pAllocateInfo->pNext, DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO);
918 if (variable_counts && !variable_counts->descriptorSetCount)
919 variable_counts = NULL;
920
921 /* allocate a set of buffers for each shader to contain descriptors */
922 for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
923 VK_FROM_HANDLE(tu_descriptor_set_layout, layout,
924 pAllocateInfo->pSetLayouts[i]);
925
926 assert(!(layout->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
927
928 result = tu_descriptor_set_create(
929 device, pool, layout,
930 variable_counts ? variable_counts->pDescriptorCounts[i] : 0, &set);
931 if (result != VK_SUCCESS)
932 break;
933
934 pDescriptorSets[i] = tu_descriptor_set_to_handle(set);
935 }
936
937 if (result != VK_SUCCESS) {
938 tu_FreeDescriptorSets(_device, pAllocateInfo->descriptorPool,
939 i, pDescriptorSets);
940 for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
941 pDescriptorSets[i] = VK_NULL_HANDLE;
942 }
943 }
944 return result;
945 }
946
947 VKAPI_ATTR VkResult VKAPI_CALL
tu_FreeDescriptorSets(VkDevice _device,VkDescriptorPool descriptorPool,uint32_t count,const VkDescriptorSet * pDescriptorSets)948 tu_FreeDescriptorSets(VkDevice _device,
949 VkDescriptorPool descriptorPool,
950 uint32_t count,
951 const VkDescriptorSet *pDescriptorSets)
952 {
953 VK_FROM_HANDLE(tu_device, device, _device);
954 VK_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool);
955
956 for (uint32_t i = 0; i < count; i++) {
957 VK_FROM_HANDLE(tu_descriptor_set, set, pDescriptorSets[i]);
958
959 if (set) {
960 vk_descriptor_set_layout_unref(&device->vk, &set->layout->vk);
961 list_del(&set->pool_link);
962 }
963
964 if (set && !pool->host_memory_base)
965 tu_descriptor_set_destroy(device, pool, set, true);
966 }
967 return VK_SUCCESS;
968 }
969
970 static void
write_texel_buffer_descriptor_addr(uint32_t * dst,const VkDescriptorAddressInfoEXT * buffer_info)971 write_texel_buffer_descriptor_addr(uint32_t *dst,
972 const VkDescriptorAddressInfoEXT *buffer_info)
973 {
974 if (!buffer_info || buffer_info->address == 0) {
975 memset(dst, 0, A6XX_TEX_CONST_DWORDS * sizeof(uint32_t));
976 } else {
977 uint8_t swiz[4] = { PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_Z,
978 PIPE_SWIZZLE_W };
979 fdl6_buffer_view_init(dst,
980 vk_format_to_pipe_format(buffer_info->format),
981 swiz, buffer_info->address, buffer_info->range);
982 }
983 }
984
985 static void
write_texel_buffer_descriptor(uint32_t * dst,const VkBufferView buffer_view)986 write_texel_buffer_descriptor(uint32_t *dst, const VkBufferView buffer_view)
987 {
988 if (buffer_view == VK_NULL_HANDLE) {
989 memset(dst, 0, A6XX_TEX_CONST_DWORDS * sizeof(uint32_t));
990 } else {
991 VK_FROM_HANDLE(tu_buffer_view, view, buffer_view);
992
993 memcpy(dst, view->descriptor, sizeof(view->descriptor));
994 }
995 }
996
997 static VkDescriptorAddressInfoEXT
buffer_info_to_address(const VkDescriptorBufferInfo * buffer_info)998 buffer_info_to_address(const VkDescriptorBufferInfo *buffer_info)
999 {
1000 VK_FROM_HANDLE(tu_buffer, buffer, buffer_info->buffer);
1001
1002 uint32_t range = buffer ? vk_buffer_range(&buffer->vk, buffer_info->offset, buffer_info->range) : 0;
1003 uint64_t va = buffer ? buffer->iova + buffer_info->offset : 0;
1004
1005 return (VkDescriptorAddressInfoEXT) {
1006 .address = va,
1007 .range = range,
1008 };
1009 }
1010
1011 static void
write_buffer_descriptor_addr(const struct tu_device * device,uint32_t * dst,const VkDescriptorAddressInfoEXT * buffer_info)1012 write_buffer_descriptor_addr(const struct tu_device *device,
1013 uint32_t *dst,
1014 const VkDescriptorAddressInfoEXT *buffer_info)
1015 {
1016 const struct fd_dev_info *info = device->physical_device->info;
1017 /* This prevents any misconfiguration, but 16-bit descriptor capable of both
1018 * 16-bit and 32-bit access through isam.v will of course only be functional
1019 * when 16-bit storage is supported. */
1020 assert(!info->a6xx.has_isam_v || info->a6xx.storage_16bit);
1021 /* Any configuration enabling 8-bit storage support will also provide 16-bit
1022 * storage support and 16-bit descriptors capable of 32-bit isam loads. This
1023 * indirectly ensures we won't need more than two descriptors for access of
1024 * any size.
1025 */
1026 assert(!info->a7xx.storage_8bit || (info->a6xx.storage_16bit &&
1027 info->a6xx.has_isam_v));
1028
1029 unsigned num_descriptors = 1 +
1030 COND(info->a6xx.storage_16bit && !info->a6xx.has_isam_v, 1) +
1031 COND(info->a7xx.storage_8bit, 1);
1032 memset(dst, 0, num_descriptors * A6XX_TEX_CONST_DWORDS * sizeof(uint32_t));
1033
1034 if (!buffer_info || buffer_info->address == 0)
1035 return;
1036
1037 uint64_t va = buffer_info->address;
1038 uint64_t base_va = va & ~0x3full;
1039 unsigned offset = va & 0x3f;
1040 uint32_t range = buffer_info->range;
1041
1042 if (info->a6xx.storage_16bit) {
1043 dst[0] = A6XX_TEX_CONST_0_TILE_MODE(TILE6_LINEAR) | A6XX_TEX_CONST_0_FMT(FMT6_16_UINT);
1044 dst[1] = DIV_ROUND_UP(range, 2);
1045 dst[2] =
1046 A6XX_TEX_CONST_2_STRUCTSIZETEXELS(1) |
1047 A6XX_TEX_CONST_2_STARTOFFSETTEXELS(offset / 2) |
1048 A6XX_TEX_CONST_2_TYPE(A6XX_TEX_BUFFER);
1049 dst[4] = A6XX_TEX_CONST_4_BASE_LO(base_va);
1050 dst[5] = A6XX_TEX_CONST_5_BASE_HI(base_va >> 32);
1051 dst += A6XX_TEX_CONST_DWORDS;
1052 }
1053
1054 /* Set up the 32-bit descriptor when 16-bit storage isn't supported or the
1055 * 16-bit descriptor cannot be used for 32-bit loads through isam.v.
1056 */
1057 if (!info->a6xx.storage_16bit || !info->a6xx.has_isam_v) {
1058 dst[0] = A6XX_TEX_CONST_0_TILE_MODE(TILE6_LINEAR) | A6XX_TEX_CONST_0_FMT(FMT6_32_UINT);
1059 dst[1] = DIV_ROUND_UP(range, 4);
1060 dst[2] =
1061 A6XX_TEX_CONST_2_STRUCTSIZETEXELS(1) |
1062 A6XX_TEX_CONST_2_STARTOFFSETTEXELS(offset / 4) |
1063 A6XX_TEX_CONST_2_TYPE(A6XX_TEX_BUFFER);
1064 dst[4] = A6XX_TEX_CONST_4_BASE_LO(base_va);
1065 dst[5] = A6XX_TEX_CONST_5_BASE_HI(base_va >> 32);
1066 dst += A6XX_TEX_CONST_DWORDS;
1067 }
1068
1069 if (info->a7xx.storage_8bit) {
1070 dst[0] = A6XX_TEX_CONST_0_TILE_MODE(TILE6_LINEAR) | A6XX_TEX_CONST_0_FMT(FMT6_8_UINT);
1071 dst[1] = range;
1072 dst[2] =
1073 A6XX_TEX_CONST_2_STRUCTSIZETEXELS(1) |
1074 A6XX_TEX_CONST_2_STARTOFFSETTEXELS(offset) |
1075 A6XX_TEX_CONST_2_TYPE(A6XX_TEX_BUFFER);
1076 dst[4] = A6XX_TEX_CONST_4_BASE_LO(base_va);
1077 dst[5] = A6XX_TEX_CONST_5_BASE_HI(base_va >> 32);
1078 }
1079 }
1080
1081 static void
write_buffer_descriptor(const struct tu_device * device,uint32_t * dst,const VkDescriptorBufferInfo * buffer_info)1082 write_buffer_descriptor(const struct tu_device *device,
1083 uint32_t *dst,
1084 const VkDescriptorBufferInfo *buffer_info)
1085 {
1086 VkDescriptorAddressInfoEXT addr = buffer_info_to_address(buffer_info);
1087 write_buffer_descriptor_addr(device, dst, &addr);
1088 }
1089
1090 static void
write_ubo_descriptor_addr(uint32_t * dst,const VkDescriptorAddressInfoEXT * buffer_info)1091 write_ubo_descriptor_addr(uint32_t *dst,
1092 const VkDescriptorAddressInfoEXT *buffer_info)
1093 {
1094 if (!buffer_info) {
1095 dst[0] = dst[1] = 0;
1096 return;
1097 }
1098
1099 uint64_t va = buffer_info->address;
1100 /* The HW range is in vec4 units */
1101 uint32_t range = va ? DIV_ROUND_UP(buffer_info->range, 16) : 0;
1102 dst[0] = A6XX_UBO_0_BASE_LO(va);
1103 dst[1] = A6XX_UBO_1_BASE_HI(va >> 32) | A6XX_UBO_1_SIZE(range);
1104 }
1105
1106 static void
write_ubo_descriptor(uint32_t * dst,const VkDescriptorBufferInfo * buffer_info)1107 write_ubo_descriptor(uint32_t *dst, const VkDescriptorBufferInfo *buffer_info)
1108 {
1109 VkDescriptorAddressInfoEXT addr = buffer_info_to_address(buffer_info);
1110 write_ubo_descriptor_addr(dst, &addr);
1111 }
1112
1113 static void
write_image_descriptor(uint32_t * dst,VkDescriptorType descriptor_type,const VkDescriptorImageInfo * image_info)1114 write_image_descriptor(uint32_t *dst,
1115 VkDescriptorType descriptor_type,
1116 const VkDescriptorImageInfo *image_info)
1117 {
1118 if (!image_info || image_info->imageView == VK_NULL_HANDLE) {
1119 memset(dst, 0, A6XX_TEX_CONST_DWORDS * sizeof(uint32_t));
1120 return;
1121 }
1122
1123 VK_FROM_HANDLE(tu_image_view, iview, image_info->imageView);
1124
1125 if (descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
1126 memcpy(dst, iview->view.storage_descriptor, sizeof(iview->view.storage_descriptor));
1127 } else {
1128 memcpy(dst, iview->view.descriptor, sizeof(iview->view.descriptor));
1129 }
1130 }
1131
1132 static void
write_combined_image_sampler_descriptor(uint32_t * dst,VkDescriptorType descriptor_type,const VkDescriptorImageInfo * image_info,bool has_sampler)1133 write_combined_image_sampler_descriptor(uint32_t *dst,
1134 VkDescriptorType descriptor_type,
1135 const VkDescriptorImageInfo *image_info,
1136 bool has_sampler)
1137 {
1138 write_image_descriptor(dst, descriptor_type, image_info);
1139 /* copy over sampler state */
1140 if (has_sampler) {
1141 VK_FROM_HANDLE(tu_sampler, sampler, image_info->sampler);
1142
1143 memcpy(dst + A6XX_TEX_CONST_DWORDS, sampler->descriptor, sizeof(sampler->descriptor));
1144 }
1145 }
1146
1147 static void
write_sampler_descriptor(uint32_t * dst,VkSampler _sampler)1148 write_sampler_descriptor(uint32_t *dst, VkSampler _sampler)
1149 {
1150 VK_FROM_HANDLE(tu_sampler, sampler, _sampler);
1151
1152 memcpy(dst, sampler->descriptor, sizeof(sampler->descriptor));
1153 }
1154
1155 /* note: this is used with immutable samplers in push descriptors */
1156 static void
write_sampler_push(uint32_t * dst,const struct tu_sampler * sampler)1157 write_sampler_push(uint32_t *dst, const struct tu_sampler *sampler)
1158 {
1159 memcpy(dst, sampler->descriptor, sizeof(sampler->descriptor));
1160 }
1161
1162 VKAPI_ATTR void VKAPI_CALL
tu_GetDescriptorEXT(VkDevice _device,const VkDescriptorGetInfoEXT * pDescriptorInfo,size_t dataSize,void * pDescriptor)1163 tu_GetDescriptorEXT(
1164 VkDevice _device,
1165 const VkDescriptorGetInfoEXT *pDescriptorInfo,
1166 size_t dataSize,
1167 void *pDescriptor)
1168 {
1169 VK_FROM_HANDLE(tu_device, device, _device);
1170 uint32_t *dest = (uint32_t *) pDescriptor;
1171
1172 switch (pDescriptorInfo->type) {
1173 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1174 write_ubo_descriptor_addr(dest, pDescriptorInfo->data.pUniformBuffer);
1175 break;
1176 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1177 write_buffer_descriptor_addr(device, dest, pDescriptorInfo->data.pStorageBuffer);
1178 break;
1179 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1180 write_texel_buffer_descriptor_addr(dest, pDescriptorInfo->data.pUniformTexelBuffer);
1181 break;
1182 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1183 write_texel_buffer_descriptor_addr(dest, pDescriptorInfo->data.pStorageTexelBuffer);
1184 break;
1185 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1186 write_image_descriptor(dest, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
1187 pDescriptorInfo->data.pSampledImage);
1188 break;
1189 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1190 write_image_descriptor(dest, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
1191 pDescriptorInfo->data.pStorageImage);
1192 break;
1193 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1194 write_combined_image_sampler_descriptor(dest,
1195 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
1196 pDescriptorInfo->data.pCombinedImageSampler,
1197 true);
1198 break;
1199 case VK_DESCRIPTOR_TYPE_SAMPLER:
1200 write_sampler_descriptor(dest, *pDescriptorInfo->data.pSampler);
1201 break;
1202 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1203 /* nothing in descriptor set - framebuffer state is used instead */
1204 if (TU_DEBUG(DYNAMIC)) {
1205 write_image_descriptor(dest, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
1206 pDescriptorInfo->data.pInputAttachmentImage);
1207 }
1208 break;
1209 default:
1210 unreachable("unimplemented descriptor type");
1211 break;
1212 }
1213 }
1214
1215 void
tu_update_descriptor_sets(const struct tu_device * device,VkDescriptorSet dstSetOverride,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies)1216 tu_update_descriptor_sets(const struct tu_device *device,
1217 VkDescriptorSet dstSetOverride,
1218 uint32_t descriptorWriteCount,
1219 const VkWriteDescriptorSet *pDescriptorWrites,
1220 uint32_t descriptorCopyCount,
1221 const VkCopyDescriptorSet *pDescriptorCopies)
1222 {
1223 uint32_t i, j;
1224 for (i = 0; i < descriptorWriteCount; i++) {
1225 const VkWriteDescriptorSet *writeset = &pDescriptorWrites[i];
1226 VK_FROM_HANDLE(tu_descriptor_set, set, dstSetOverride ?: writeset->dstSet);
1227 const struct tu_descriptor_set_binding_layout *binding_layout =
1228 set->layout->binding + writeset->dstBinding;
1229 uint32_t *ptr = set->mapped_ptr;
1230 if (writeset->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
1231 writeset->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) {
1232 ptr = set->dynamic_descriptors;
1233 ptr += binding_layout->dynamic_offset_offset / 4;
1234 } else {
1235 ptr = set->mapped_ptr;
1236 ptr += binding_layout->offset / 4;
1237 }
1238
1239 /* for immutable samplers with push descriptors: */
1240 const bool copy_immutable_samplers =
1241 dstSetOverride && binding_layout->immutable_samplers_offset;
1242 const struct tu_sampler *samplers =
1243 tu_immutable_samplers(set->layout, binding_layout);
1244
1245 if (writeset->descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
1246 /* We need to respect this note:
1247 *
1248 * The same behavior applies to bindings with a descriptor type of
1249 * VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK where descriptorCount
1250 * specifies the number of bytes to update while dstArrayElement
1251 * specifies the starting byte offset, thus in this case if the
1252 * dstBinding has a smaller byte size than the sum of
1253 * dstArrayElement and descriptorCount, then the remainder will be
1254 * used to update the subsequent binding - dstBinding+1 starting
1255 * at offset zero. This falls out as a special case of the above
1256 * rule.
1257 *
1258 * This means we can't just do a straight memcpy, because due to
1259 * alignment padding there are gaps between sequential bindings. We
1260 * have to loop over each binding updated.
1261 */
1262 const VkWriteDescriptorSetInlineUniformBlock *inline_write =
1263 vk_find_struct_const(writeset->pNext,
1264 WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK);
1265 uint32_t remaining = inline_write->dataSize;
1266 const uint8_t *src = (const uint8_t *) inline_write->pData;
1267 uint32_t dst_offset = writeset->dstArrayElement;
1268 do {
1269 uint8_t *dst = (uint8_t *)(ptr) + dst_offset;
1270 uint32_t binding_size = binding_layout->size - dst_offset;
1271 uint32_t to_write = MIN2(remaining, binding_size);
1272 memcpy(dst, src, to_write);
1273
1274 binding_layout++;
1275 ptr = set->mapped_ptr + binding_layout->offset / 4;
1276 dst_offset = 0;
1277 src += to_write;
1278 remaining -= to_write;
1279 } while (remaining > 0);
1280
1281 continue;
1282 }
1283
1284 ptr += binding_layout->size / 4 * writeset->dstArrayElement;
1285 for (j = 0; j < writeset->descriptorCount; ++j) {
1286 switch(writeset->descriptorType) {
1287 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1288 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1289 write_ubo_descriptor(ptr, writeset->pBufferInfo + j);
1290 break;
1291 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1292 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1293 write_buffer_descriptor(device, ptr, writeset->pBufferInfo + j);
1294 break;
1295 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1296 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1297 write_texel_buffer_descriptor(ptr, writeset->pTexelBufferView[j]);
1298 break;
1299 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1300 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1301 write_image_descriptor(ptr, writeset->descriptorType, writeset->pImageInfo + j);
1302 break;
1303 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1304 write_combined_image_sampler_descriptor(ptr,
1305 writeset->descriptorType,
1306 writeset->pImageInfo + j,
1307 !binding_layout->immutable_samplers_offset);
1308
1309 if (copy_immutable_samplers)
1310 write_sampler_push(ptr + A6XX_TEX_CONST_DWORDS, &samplers[writeset->dstArrayElement + j]);
1311 break;
1312 case VK_DESCRIPTOR_TYPE_SAMPLER:
1313 if (!binding_layout->immutable_samplers_offset)
1314 write_sampler_descriptor(ptr, writeset->pImageInfo[j].sampler);
1315 else if (copy_immutable_samplers)
1316 write_sampler_push(ptr, &samplers[writeset->dstArrayElement + j]);
1317 break;
1318 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1319 /* nothing in descriptor set - framebuffer state is used instead */
1320 if (TU_DEBUG(DYNAMIC))
1321 write_image_descriptor(ptr, writeset->descriptorType, writeset->pImageInfo + j);
1322 break;
1323 default:
1324 unreachable("unimplemented descriptor type");
1325 break;
1326 }
1327 ptr += binding_layout->size / 4;
1328 }
1329 }
1330
1331 for (i = 0; i < descriptorCopyCount; i++) {
1332 const VkCopyDescriptorSet *copyset = &pDescriptorCopies[i];
1333 VK_FROM_HANDLE(tu_descriptor_set, src_set,
1334 copyset->srcSet);
1335 VK_FROM_HANDLE(tu_descriptor_set, dst_set,
1336 copyset->dstSet);
1337 const struct tu_descriptor_set_binding_layout *src_binding_layout =
1338 src_set->layout->binding + copyset->srcBinding;
1339 const struct tu_descriptor_set_binding_layout *dst_binding_layout =
1340 dst_set->layout->binding + copyset->dstBinding;
1341 uint32_t *src_ptr = src_set->mapped_ptr;
1342 uint32_t *dst_ptr = dst_set->mapped_ptr;
1343 if (src_binding_layout->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
1344 src_binding_layout->type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) {
1345 src_ptr = src_set->dynamic_descriptors;
1346 dst_ptr = dst_set->dynamic_descriptors;
1347 src_ptr += src_binding_layout->dynamic_offset_offset / 4;
1348 dst_ptr += dst_binding_layout->dynamic_offset_offset / 4;
1349 } else {
1350 src_ptr = src_set->mapped_ptr;
1351 dst_ptr = dst_set->mapped_ptr;
1352 src_ptr += src_binding_layout->offset / 4;
1353 dst_ptr += dst_binding_layout->offset / 4;
1354 }
1355
1356 if (src_binding_layout->type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
1357 uint32_t remaining = copyset->descriptorCount;
1358 uint32_t src_start = copyset->srcArrayElement;
1359 uint32_t dst_start = copyset->dstArrayElement;
1360 uint8_t *src = (uint8_t *)(src_ptr) + src_start;
1361 uint8_t *dst = (uint8_t *)(dst_ptr) + dst_start;
1362 uint32_t src_remaining =
1363 src_binding_layout->size - src_start;
1364 uint32_t dst_remaining =
1365 dst_binding_layout->size - dst_start;
1366 do {
1367 uint32_t to_write = MIN3(remaining, src_remaining, dst_remaining);
1368 memcpy(dst, src, to_write);
1369
1370 src += to_write;
1371 dst += to_write;
1372 src_remaining -= to_write;
1373 dst_remaining -= to_write;
1374 remaining -= to_write;
1375
1376 if (src_remaining == 0) {
1377 src_binding_layout++;
1378 src_ptr = src_set->mapped_ptr + src_binding_layout->offset / 4;
1379 src = (uint8_t *)(src_ptr + A6XX_TEX_CONST_DWORDS);
1380 src_remaining = src_binding_layout->size - 4 * A6XX_TEX_CONST_DWORDS;
1381 }
1382
1383 if (dst_remaining == 0) {
1384 dst_binding_layout++;
1385 dst_ptr = dst_set->mapped_ptr + dst_binding_layout->offset / 4;
1386 dst = (uint8_t *)(dst_ptr + A6XX_TEX_CONST_DWORDS);
1387 dst_remaining = dst_binding_layout->size - 4 * A6XX_TEX_CONST_DWORDS;
1388 }
1389 } while (remaining > 0);
1390
1391 continue;
1392 }
1393
1394 src_ptr += src_binding_layout->size * copyset->srcArrayElement / 4;
1395 dst_ptr += dst_binding_layout->size * copyset->dstArrayElement / 4;
1396
1397 /* In case of copies between mutable descriptor types
1398 * and non-mutable descriptor types.
1399 */
1400 uint32_t copy_size = MIN2(src_binding_layout->size, dst_binding_layout->size);
1401
1402 for (j = 0; j < copyset->descriptorCount; ++j) {
1403 memcpy(dst_ptr, src_ptr, copy_size);
1404
1405 src_ptr += src_binding_layout->size / 4;
1406 dst_ptr += dst_binding_layout->size / 4;
1407 }
1408 }
1409 }
1410
1411 VKAPI_ATTR void VKAPI_CALL
tu_UpdateDescriptorSets(VkDevice _device,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies)1412 tu_UpdateDescriptorSets(VkDevice _device,
1413 uint32_t descriptorWriteCount,
1414 const VkWriteDescriptorSet *pDescriptorWrites,
1415 uint32_t descriptorCopyCount,
1416 const VkCopyDescriptorSet *pDescriptorCopies)
1417 {
1418 VK_FROM_HANDLE(tu_device, device, _device);
1419 tu_update_descriptor_sets(device, VK_NULL_HANDLE,
1420 descriptorWriteCount, pDescriptorWrites,
1421 descriptorCopyCount, pDescriptorCopies);
1422 }
1423
1424 VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDescriptorUpdateTemplate(VkDevice _device,const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate)1425 tu_CreateDescriptorUpdateTemplate(
1426 VkDevice _device,
1427 const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
1428 const VkAllocationCallbacks *pAllocator,
1429 VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
1430 {
1431 VK_FROM_HANDLE(tu_device, device, _device);
1432 struct tu_descriptor_set_layout *set_layout = NULL;
1433 const uint32_t entry_count = pCreateInfo->descriptorUpdateEntryCount;
1434 uint32_t dst_entry_count = 0;
1435
1436 if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) {
1437 VK_FROM_HANDLE(tu_pipeline_layout, pipeline_layout, pCreateInfo->pipelineLayout);
1438
1439 /* descriptorSetLayout should be ignored for push descriptors
1440 * and instead it refers to pipelineLayout and set.
1441 */
1442 assert(pCreateInfo->set < device->physical_device->usable_sets);
1443 set_layout = pipeline_layout->set[pCreateInfo->set].layout;
1444 } else {
1445 VK_FROM_HANDLE(tu_descriptor_set_layout, _set_layout,
1446 pCreateInfo->descriptorSetLayout);
1447 set_layout = _set_layout;
1448 }
1449
1450 for (uint32_t i = 0; i < entry_count; i++) {
1451 const VkDescriptorUpdateTemplateEntry *entry = &pCreateInfo->pDescriptorUpdateEntries[i];
1452 if (entry->descriptorType != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
1453 dst_entry_count++;
1454 continue;
1455 }
1456
1457 /* Calculate how many bindings this update steps over, so we can split
1458 * up the template entry. This lets the actual update be a simple
1459 * memcpy.
1460 */
1461 uint32_t remaining = entry->descriptorCount;
1462 const struct tu_descriptor_set_binding_layout *binding_layout =
1463 set_layout->binding + entry->dstBinding;
1464 uint32_t dst_start = entry->dstArrayElement;
1465 do {
1466 uint32_t size = binding_layout->size;
1467 uint32_t count = MIN2(remaining, size - dst_start);
1468 remaining -= count;
1469 binding_layout++;
1470 dst_entry_count++;
1471 dst_start = 0;
1472 } while (remaining > 0);
1473 }
1474
1475 const size_t size =
1476 sizeof(struct tu_descriptor_update_template) +
1477 sizeof(struct tu_descriptor_update_template_entry) * dst_entry_count;
1478 struct tu_descriptor_update_template *templ;
1479
1480 templ = (struct tu_descriptor_update_template *) vk_object_alloc(
1481 &device->vk, pAllocator, size,
1482 VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
1483 if (!templ)
1484 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
1485
1486 templ->entry_count = dst_entry_count;
1487
1488 if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) {
1489 templ->bind_point = pCreateInfo->pipelineBindPoint;
1490 }
1491
1492 uint32_t j = 0;
1493 for (uint32_t i = 0; i < entry_count; i++) {
1494 const VkDescriptorUpdateTemplateEntry *entry = &pCreateInfo->pDescriptorUpdateEntries[i];
1495
1496 const struct tu_descriptor_set_binding_layout *binding_layout =
1497 set_layout->binding + entry->dstBinding;
1498 uint32_t dst_offset, dst_stride;
1499 const struct tu_sampler *immutable_samplers = NULL;
1500
1501 /* dst_offset is an offset into dynamic_descriptors when the descriptor
1502 * is dynamic, and an offset into mapped_ptr otherwise.
1503 */
1504 switch (entry->descriptorType) {
1505 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1506 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1507 dst_offset = binding_layout->dynamic_offset_offset / 4;
1508 break;
1509 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: {
1510 uint32_t remaining = entry->descriptorCount;
1511 uint32_t dst_start = entry->dstArrayElement;
1512 uint32_t src_offset = entry->offset;
1513 /* See comment in update_descriptor_sets() */
1514 do {
1515 dst_offset =
1516 binding_layout->offset + dst_start;
1517 uint32_t size = binding_layout->size;
1518 uint32_t count = MIN2(remaining, size - dst_start);
1519 templ->entry[j++] = (struct tu_descriptor_update_template_entry) {
1520 .descriptor_type = entry->descriptorType,
1521 .descriptor_count = count,
1522 .dst_offset = dst_offset,
1523 .src_offset = src_offset,
1524 };
1525 remaining -= count;
1526 src_offset += count;
1527 binding_layout++;
1528 dst_start = 0;
1529 } while (remaining > 0);
1530
1531 continue;
1532 }
1533 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1534 case VK_DESCRIPTOR_TYPE_SAMPLER:
1535 if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR &&
1536 binding_layout->immutable_samplers_offset) {
1537 immutable_samplers =
1538 tu_immutable_samplers(set_layout, binding_layout) + entry->dstArrayElement;
1539 }
1540 FALLTHROUGH;
1541 default:
1542 dst_offset = binding_layout->offset / 4;
1543 }
1544
1545 dst_offset += (binding_layout->size * entry->dstArrayElement) / 4;
1546 dst_stride = binding_layout->size / 4;
1547
1548 templ->entry[j++] = (struct tu_descriptor_update_template_entry) {
1549 .descriptor_type = entry->descriptorType,
1550 .descriptor_count = entry->descriptorCount,
1551 .dst_offset = dst_offset,
1552 .dst_stride = dst_stride,
1553 .has_sampler = !binding_layout->immutable_samplers_offset,
1554 .src_offset = entry->offset,
1555 .src_stride = entry->stride,
1556 .immutable_samplers = immutable_samplers,
1557 };
1558 }
1559
1560 assert(j == dst_entry_count);
1561
1562 *pDescriptorUpdateTemplate =
1563 tu_descriptor_update_template_to_handle(templ);
1564
1565 return VK_SUCCESS;
1566 }
1567
1568 VKAPI_ATTR void VKAPI_CALL
tu_DestroyDescriptorUpdateTemplate(VkDevice _device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const VkAllocationCallbacks * pAllocator)1569 tu_DestroyDescriptorUpdateTemplate(
1570 VkDevice _device,
1571 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1572 const VkAllocationCallbacks *pAllocator)
1573 {
1574 VK_FROM_HANDLE(tu_device, device, _device);
1575 VK_FROM_HANDLE(tu_descriptor_update_template, templ,
1576 descriptorUpdateTemplate);
1577
1578 if (!templ)
1579 return;
1580
1581 vk_object_free(&device->vk, pAllocator, templ);
1582 }
1583
1584 void
tu_update_descriptor_set_with_template(const struct tu_device * device,struct tu_descriptor_set * set,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData)1585 tu_update_descriptor_set_with_template(
1586 const struct tu_device *device,
1587 struct tu_descriptor_set *set,
1588 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1589 const void *pData)
1590 {
1591 VK_FROM_HANDLE(tu_descriptor_update_template, templ,
1592 descriptorUpdateTemplate);
1593
1594 for (uint32_t i = 0; i < templ->entry_count; i++) {
1595 uint32_t *ptr = set->mapped_ptr;
1596 const void *src = ((const char *) pData) + templ->entry[i].src_offset;
1597 const struct tu_sampler *samplers = templ->entry[i].immutable_samplers;
1598
1599 if (templ->entry[i].descriptor_type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
1600 memcpy(((uint8_t *) ptr) + templ->entry[i].dst_offset, src,
1601 templ->entry[i].descriptor_count);
1602 continue;
1603 }
1604
1605 ptr += templ->entry[i].dst_offset;
1606 unsigned dst_offset = templ->entry[i].dst_offset;
1607 for (unsigned j = 0; j < templ->entry[i].descriptor_count; ++j) {
1608 switch(templ->entry[i].descriptor_type) {
1609 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: {
1610 assert(!(set->layout->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
1611 write_ubo_descriptor(set->dynamic_descriptors + dst_offset,
1612 (const VkDescriptorBufferInfo *) src);
1613 break;
1614 }
1615 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1616 write_ubo_descriptor(ptr, (const VkDescriptorBufferInfo *) src);
1617 break;
1618 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: {
1619 assert(!(set->layout->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
1620 write_buffer_descriptor(device,
1621 set->dynamic_descriptors + dst_offset,
1622 (const VkDescriptorBufferInfo *) src);
1623 break;
1624 }
1625 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1626 write_buffer_descriptor(device, ptr,
1627 (const VkDescriptorBufferInfo *) src);
1628 break;
1629 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1630 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1631 write_texel_buffer_descriptor(ptr, *(VkBufferView *) src);
1632 break;
1633 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1634 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
1635 write_image_descriptor(ptr, templ->entry[i].descriptor_type,
1636 (const VkDescriptorImageInfo *) src);
1637 break;
1638 }
1639 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1640 write_combined_image_sampler_descriptor(ptr,
1641 templ->entry[i].descriptor_type,
1642 (const VkDescriptorImageInfo *) src,
1643 templ->entry[i].has_sampler);
1644 if (samplers)
1645 write_sampler_push(ptr + A6XX_TEX_CONST_DWORDS, &samplers[j]);
1646 break;
1647 case VK_DESCRIPTOR_TYPE_SAMPLER:
1648 if (templ->entry[i].has_sampler)
1649 write_sampler_descriptor(ptr, ((const VkDescriptorImageInfo *)src)->sampler);
1650 else if (samplers)
1651 write_sampler_push(ptr, &samplers[j]);
1652 break;
1653 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1654 /* nothing in descriptor set - framebuffer state is used instead */
1655 if (TU_DEBUG(DYNAMIC))
1656 write_image_descriptor(ptr, templ->entry[i].descriptor_type,
1657 (const VkDescriptorImageInfo *) src);
1658 break;
1659 default:
1660 unreachable("unimplemented descriptor type");
1661 break;
1662 }
1663 src = (char *) src + templ->entry[i].src_stride;
1664 ptr += templ->entry[i].dst_stride;
1665 dst_offset += templ->entry[i].dst_stride;
1666 }
1667 }
1668 }
1669
1670 VKAPI_ATTR void VKAPI_CALL
tu_UpdateDescriptorSetWithTemplate(VkDevice _device,VkDescriptorSet descriptorSet,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData)1671 tu_UpdateDescriptorSetWithTemplate(
1672 VkDevice _device,
1673 VkDescriptorSet descriptorSet,
1674 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1675 const void *pData)
1676 {
1677 VK_FROM_HANDLE(tu_device, device, _device);
1678 VK_FROM_HANDLE(tu_descriptor_set, set, descriptorSet);
1679
1680 tu_update_descriptor_set_with_template(device, set, descriptorUpdateTemplate, pData);
1681 }
1682