OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

radv: get rid of bunch of KHR suffixes

Browse Source 
Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl>
Acked-by: Eric Engestrom <eric.engestrom@intel.com>
Signed-off-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
This commit is contained in:
Samuel Pitoiset
2019-01-08 14:30:32 +01:00
parent a2ddb710fd
commit d58b11e709
10 changed files with 164 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/amd/vulkan/radv_android.c
View File

@@ -111,7 +111,7 @@ radv_image_from_gralloc(VkDevice device_h,
VkResult result; VkResult result;
if (gralloc_info->handle->numFds != 1) { if (gralloc_info->handle->numFds != 1) {
return vk_errorf(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, return vk_errorf(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE,
"VkNativeBufferANDROID::handle::numFds is %d, " "VkNativeBufferANDROID::handle::numFds is %d, "
"expected 1", gralloc_info->handle->numFds); "expected 1", gralloc_info->handle->numFds);
} }
@@ -126,7 +126,7 @@ radv_image_from_gralloc(VkDevice device_h,
const VkImportMemoryFdInfoKHR import_info = { const VkImportMemoryFdInfoKHR import_info = {
.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
.fd = dup(dma_buf), .fd = dup(dma_buf),
}; };
@@ -230,16 +230,16 @@ VkResult radv_GetSwapchainGrallocUsageANDROID(
* dEQP-VK.wsi.android.swapchain.*.image_usage to fail. * dEQP-VK.wsi.android.swapchain.*.image_usage to fail.
*/ */
const VkPhysicalDeviceImageFormatInfo2KHR image_format_info = { const VkPhysicalDeviceImageFormatInfo2 image_format_info = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
.format = format, .format = format,
.type = VK_IMAGE_TYPE_2D, .type = VK_IMAGE_TYPE_2D,
.tiling = VK_IMAGE_TILING_OPTIMAL, .tiling = VK_IMAGE_TILING_OPTIMAL,
.usage = imageUsage, .usage = imageUsage,
}; };
VkImageFormatProperties2KHR image_format_props = { VkImageFormatProperties2 image_format_props = {
.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
}; };
/* Check that requested format and usage are supported. */ /* Check that requested format and usage are supported. */
@@ -303,7 +303,7 @@ radv_AcquireImageANDROID(
semaphore_result = radv_ImportSemaphoreFdKHR(device, semaphore_result = radv_ImportSemaphoreFdKHR(device,
&(VkImportSemaphoreFdInfoKHR) { &(VkImportSemaphoreFdInfoKHR) {
.sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
.flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR, .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
.fd = semaphore_fd, .fd = semaphore_fd,
.semaphore = semaphore, .semaphore = semaphore,
}); });
@@ -314,7 +314,7 @@ radv_AcquireImageANDROID(
fence_result = radv_ImportFenceFdKHR(device, fence_result = radv_ImportFenceFdKHR(device,
&(VkImportFenceFdInfoKHR) { &(VkImportFenceFdInfoKHR) {
.sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, .sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
.flags = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR, .flags = VK_FENCE_IMPORT_TEMPORARY_BIT,
.fd = fence_fd, .fd = fence_fd,
.fence = fence, .fence = fence,
}); });
@@ -351,7 +351,7 @@ radv_QueueSignalReleaseImageANDROID(
result = radv_GetSemaphoreFdKHR(radv_device_to_handle(queue->device), result = radv_GetSemaphoreFdKHR(radv_device_to_handle(queue->device),
&(VkSemaphoreGetFdInfoKHR) { &(VkSemaphoreGetFdInfoKHR) {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR, .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
.semaphore = pWaitSemaphores[i], .semaphore = pWaitSemaphores[i],
}, &tmp_fd); }, &tmp_fd);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {

4
src/amd/vulkan/radv_cmd_buffer.c
View File

@@ -2787,7 +2787,7 @@ void radv_CmdPushDescriptorSetKHR(
void radv_CmdPushDescriptorSetWithTemplateKHR( void radv_CmdPushDescriptorSetWithTemplateKHR(
VkCommandBuffer commandBuffer, VkCommandBuffer commandBuffer,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
VkPipelineLayout _layout, VkPipelineLayout _layout,
uint32_t set, uint32_t set,
const void* pData) const void* pData)
@@ -3247,7 +3247,7 @@ VkResult radv_ResetCommandPool(
void radv_TrimCommandPool( void radv_TrimCommandPool(
VkDevice device, VkDevice device,
VkCommandPool commandPool, VkCommandPool commandPool,
VkCommandPoolTrimFlagsKHR flags) VkCommandPoolTrimFlags flags)
{ {
RADV_FROM_HANDLE(radv_cmd_pool, pool, commandPool); RADV_FROM_HANDLE(radv_cmd_pool, pool, commandPool);

22
src/amd/vulkan/radv_descriptor_set.c
View File

@@ -412,7 +412,7 @@ radv_descriptor_set_create(struct radv_device *device,
if (pool->host_memory_base) { if (pool->host_memory_base) {
if (pool->host_memory_end - pool->host_memory_ptr < mem_size) if (pool->host_memory_end - pool->host_memory_ptr < mem_size)
return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR); return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
set = (struct radv_descriptor_set*)pool->host_memory_ptr; set = (struct radv_descriptor_set*)pool->host_memory_ptr;
pool->host_memory_ptr += mem_size; pool->host_memory_ptr += mem_size;
@@ -437,7 +437,7 @@ radv_descriptor_set_create(struct radv_device *device,
if (!pool->host_memory_base && pool->entry_count == pool->max_entry_count) { if (!pool->host_memory_base && pool->entry_count == pool->max_entry_count) {
vk_free2(&device->alloc, NULL, set); vk_free2(&device->alloc, NULL, set);
return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR); return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
} }
/* try to allocate linearly first, so that we don't spend /* try to allocate linearly first, so that we don't spend
@@ -466,7 +466,7 @@ radv_descriptor_set_create(struct radv_device *device,
if (pool->size - offset < layout_size) { if (pool->size - offset < layout_size) {
vk_free2(&device->alloc, NULL, set); vk_free2(&device->alloc, NULL, set);
return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR); return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
} }
set->bo = pool->bo; set->bo = pool->bo;
set->mapped_ptr = (uint32_t*)(pool->mapped_ptr + offset); set->mapped_ptr = (uint32_t*)(pool->mapped_ptr + offset);
@@ -478,7 +478,7 @@ radv_descriptor_set_create(struct radv_device *device,
pool->entries[index].set = set; pool->entries[index].set = set;
pool->entry_count++; pool->entry_count++;
} else } else
return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR); return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
} }
if (layout->has_immutable_samplers) { if (layout->has_immutable_samplers) {
@@ -982,9 +982,9 @@ void radv_UpdateDescriptorSets(
} }
VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device, VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, const VkAllocationCallbacks *pAllocator,
VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
{ {
RADV_FROM_HANDLE(radv_device, device, _device); RADV_FROM_HANDLE(radv_device, device, _device);
RADV_FROM_HANDLE(radv_descriptor_set_layout, set_layout, pCreateInfo->descriptorSetLayout); RADV_FROM_HANDLE(radv_descriptor_set_layout, set_layout, pCreateInfo->descriptorSetLayout);
@@ -1002,7 +1002,7 @@ VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
templ->bind_point = pCreateInfo->pipelineBindPoint; templ->bind_point = pCreateInfo->pipelineBindPoint;
for (i = 0; i < entry_count; i++) { for (i = 0; i < entry_count; i++) {
const VkDescriptorUpdateTemplateEntryKHR *entry = &pCreateInfo->pDescriptorUpdateEntries[i]; const VkDescriptorUpdateTemplateEntry *entry = &pCreateInfo->pDescriptorUpdateEntries[i];
const struct radv_descriptor_set_binding_layout *binding_layout = const struct radv_descriptor_set_binding_layout *binding_layout =
set_layout->binding + entry->dstBinding; set_layout->binding + entry->dstBinding;
const uint32_t buffer_offset = binding_layout->buffer_offset + entry->dstArrayElement; const uint32_t buffer_offset = binding_layout->buffer_offset + entry->dstArrayElement;
@@ -1015,7 +1015,7 @@ VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
switch (entry->descriptorType) { switch (entry->descriptorType) {
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
assert(pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR); assert(pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET);
dst_offset = binding_layout->dynamic_offset_offset + entry->dstArrayElement; dst_offset = binding_layout->dynamic_offset_offset + entry->dstArrayElement;
dst_stride = 0; /* Not used */ dst_stride = 0; /* Not used */
break; break;
@@ -1055,7 +1055,7 @@ VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
} }
void radv_DestroyDescriptorUpdateTemplate(VkDevice _device, void radv_DestroyDescriptorUpdateTemplate(VkDevice _device,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks *pAllocator) const VkAllocationCallbacks *pAllocator)
{ {
RADV_FROM_HANDLE(radv_device, device, _device); RADV_FROM_HANDLE(radv_device, device, _device);
@@ -1070,7 +1070,7 @@ void radv_DestroyDescriptorUpdateTemplate(VkDevice _device,
void radv_update_descriptor_set_with_template(struct radv_device *device, void radv_update_descriptor_set_with_template(struct radv_device *device,
struct radv_cmd_buffer *cmd_buffer, struct radv_cmd_buffer *cmd_buffer,
struct radv_descriptor_set *set, struct radv_descriptor_set *set,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void *pData) const void *pData)
{ {
RADV_FROM_HANDLE(radv_descriptor_update_template, templ, descriptorUpdateTemplate); RADV_FROM_HANDLE(radv_descriptor_update_template, templ, descriptorUpdateTemplate);
@@ -1137,7 +1137,7 @@ void radv_update_descriptor_set_with_template(struct radv_device *device,
void radv_UpdateDescriptorSetWithTemplate(VkDevice _device, void radv_UpdateDescriptorSetWithTemplate(VkDevice _device,
VkDescriptorSet descriptorSet, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void *pData) const void *pData)
{ {
RADV_FROM_HANDLE(radv_device, device, _device); RADV_FROM_HANDLE(radv_device, device, _device);

176
src/amd/vulkan/radv_device.c
View File

@@ -754,19 +754,19 @@ void radv_GetPhysicalDeviceFeatures(
void radv_GetPhysicalDeviceFeatures2( void radv_GetPhysicalDeviceFeatures2(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2KHR *pFeatures) VkPhysicalDeviceFeatures2 *pFeatures)
{ {
RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
vk_foreach_struct(ext, pFeatures->pNext) { vk_foreach_struct(ext, pFeatures->pNext) {
switch (ext->sType) { switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: {
VkPhysicalDeviceVariablePointerFeaturesKHR *features = (void *)ext; VkPhysicalDeviceVariablePointerFeatures *features = (void *)ext;
features->variablePointersStorageBuffer = true; features->variablePointersStorageBuffer = true;
features->variablePointers = false; features->variablePointers = false;
break; break;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
VkPhysicalDeviceMultiviewFeaturesKHR *features = (VkPhysicalDeviceMultiviewFeaturesKHR*)ext; VkPhysicalDeviceMultiviewFeatures *features = (VkPhysicalDeviceMultiviewFeatures*)ext;
features->multiview = true; features->multiview = true;
features->multiviewGeometryShader = true; features->multiviewGeometryShader = true;
features->multiviewTessellationShader = true; features->multiviewTessellationShader = true;
@@ -1008,7 +1008,7 @@ void radv_GetPhysicalDeviceProperties(
void radv_GetPhysicalDeviceProperties2( void radv_GetPhysicalDeviceProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2KHR *pProperties) VkPhysicalDeviceProperties2 *pProperties)
{ {
RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
radv_GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); radv_GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
@@ -1021,23 +1021,23 @@ void radv_GetPhysicalDeviceProperties2(
properties->maxPushDescriptors = MAX_PUSH_DESCRIPTORS; properties->maxPushDescriptors = MAX_PUSH_DESCRIPTORS;
break; break;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
VkPhysicalDeviceIDPropertiesKHR *properties = (VkPhysicalDeviceIDPropertiesKHR*)ext; VkPhysicalDeviceIDProperties *properties = (VkPhysicalDeviceIDProperties*)ext;
memcpy(properties->driverUUID, pdevice->driver_uuid, VK_UUID_SIZE); memcpy(properties->driverUUID, pdevice->driver_uuid, VK_UUID_SIZE);
memcpy(properties->deviceUUID, pdevice->device_uuid, VK_UUID_SIZE); memcpy(properties->deviceUUID, pdevice->device_uuid, VK_UUID_SIZE);
properties->deviceLUIDValid = false; properties->deviceLUIDValid = false;
break; break;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
VkPhysicalDeviceMultiviewPropertiesKHR *properties = (VkPhysicalDeviceMultiviewPropertiesKHR*)ext; VkPhysicalDeviceMultiviewProperties *properties = (VkPhysicalDeviceMultiviewProperties*)ext;
properties->maxMultiviewViewCount = MAX_VIEWS; properties->maxMultiviewViewCount = MAX_VIEWS;
properties->maxMultiviewInstanceIndex = INT_MAX; properties->maxMultiviewInstanceIndex = INT_MAX;
break; break;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
VkPhysicalDevicePointClippingPropertiesKHR *properties = VkPhysicalDevicePointClippingProperties *properties =
(VkPhysicalDevicePointClippingPropertiesKHR*)ext; (VkPhysicalDevicePointClippingProperties*)ext;
properties->pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR; properties->pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
break; break;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
@@ -1314,7 +1314,7 @@ void radv_GetPhysicalDeviceQueueFamilyProperties(
void radv_GetPhysicalDeviceQueueFamilyProperties2( void radv_GetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
uint32_t* pCount, uint32_t* pCount,
VkQueueFamilyProperties2KHR *pQueueFamilyProperties) VkQueueFamilyProperties2 *pQueueFamilyProperties)
{ {
RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
if (!pQueueFamilyProperties) { if (!pQueueFamilyProperties) {
@@ -1341,7 +1341,7 @@ void radv_GetPhysicalDeviceMemoryProperties(
void radv_GetPhysicalDeviceMemoryProperties2( void radv_GetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
{ {
return radv_GetPhysicalDeviceMemoryProperties(physicalDevice, return radv_GetPhysicalDeviceMemoryProperties(physicalDevice,
&pMemoryProperties->memoryProperties); &pMemoryProperties->memoryProperties);
@@ -1349,7 +1349,7 @@ void radv_GetPhysicalDeviceMemoryProperties2(
VkResult radv_GetMemoryHostPointerPropertiesEXT( VkResult radv_GetMemoryHostPointerPropertiesEXT(
VkDevice _device, VkDevice _device,
VkExternalMemoryHandleTypeFlagBitsKHR handleType, VkExternalMemoryHandleTypeFlagBits handleType,
const void *pHostPointer, const void *pHostPointer,
VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
{ {
@@ -1370,7 +1370,7 @@ VkResult radv_GetMemoryHostPointerPropertiesEXT(
return VK_SUCCESS; return VK_SUCCESS;
} }
default: default:
return VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR; return VK_ERROR_INVALID_EXTERNAL_HANDLE;
} }
} }
@@ -2970,10 +2970,10 @@ static VkResult radv_alloc_memory(struct radv_device *device,
const VkImportMemoryFdInfoKHR *import_info = const VkImportMemoryFdInfoKHR *import_info =
vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_FD_INFO_KHR); vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_FD_INFO_KHR);
const VkMemoryDedicatedAllocateInfoKHR *dedicate_info = const VkMemoryDedicatedAllocateInfo *dedicate_info =
vk_find_struct_const(pAllocateInfo->pNext, MEMORY_DEDICATED_ALLOCATE_INFO_KHR); vk_find_struct_const(pAllocateInfo->pNext, MEMORY_DEDICATED_ALLOCATE_INFO);
const VkExportMemoryAllocateInfoKHR *export_info = const VkExportMemoryAllocateInfo *export_info =
vk_find_struct_const(pAllocateInfo->pNext, EXPORT_MEMORY_ALLOCATE_INFO_KHR); vk_find_struct_const(pAllocateInfo->pNext, EXPORT_MEMORY_ALLOCATE_INFO);
const VkImportMemoryHostPointerInfoEXT *host_ptr_info = const VkImportMemoryHostPointerInfoEXT *host_ptr_info =
vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_HOST_POINTER_INFO_EXT); vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_HOST_POINTER_INFO_EXT);
@@ -3000,13 +3000,13 @@ static VkResult radv_alloc_memory(struct radv_device *device,
if (import_info) { if (import_info) {
assert(import_info->handleType == assert(import_info->handleType ==
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR || VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT ||
import_info->handleType == import_info->handleType ==
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT); VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
mem->bo = device->ws->buffer_from_fd(device->ws, import_info->fd, mem->bo = device->ws->buffer_from_fd(device->ws, import_info->fd,
NULL, NULL); NULL, NULL);
if (!mem->bo) { if (!mem->bo) {
result = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR; result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
goto fail; goto fail;
} else { } else {
close(import_info->fd); close(import_info->fd);
@@ -3017,7 +3017,7 @@ static VkResult radv_alloc_memory(struct radv_device *device,
mem->bo = device->ws->buffer_from_ptr(device->ws, host_ptr_info->pHostPointer, mem->bo = device->ws->buffer_from_ptr(device->ws, host_ptr_info->pHostPointer,
pAllocateInfo->allocationSize); pAllocateInfo->allocationSize);
if (!mem->bo) { if (!mem->bo) {
result = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR; result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
goto fail; goto fail;
} else { } else {
mem->user_ptr = host_ptr_info->pHostPointer; mem->user_ptr = host_ptr_info->pHostPointer;
@@ -3174,17 +3174,17 @@ void radv_GetBufferMemoryRequirements(
void radv_GetBufferMemoryRequirements2( void radv_GetBufferMemoryRequirements2(
VkDevice device, VkDevice device,
const VkBufferMemoryRequirementsInfo2KHR* pInfo, const VkBufferMemoryRequirementsInfo2 *pInfo,
VkMemoryRequirements2KHR* pMemoryRequirements) VkMemoryRequirements2 *pMemoryRequirements)
{ {
radv_GetBufferMemoryRequirements(device, pInfo->buffer, radv_GetBufferMemoryRequirements(device, pInfo->buffer,
&pMemoryRequirements->memoryRequirements); &pMemoryRequirements->memoryRequirements);
RADV_FROM_HANDLE(radv_buffer, buffer, pInfo->buffer); RADV_FROM_HANDLE(radv_buffer, buffer, pInfo->buffer);
vk_foreach_struct(ext, pMemoryRequirements->pNext) { vk_foreach_struct(ext, pMemoryRequirements->pNext) {
switch (ext->sType) { switch (ext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: { case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
VkMemoryDedicatedRequirementsKHR *req = VkMemoryDedicatedRequirements *req =
(VkMemoryDedicatedRequirementsKHR *) ext; (VkMemoryDedicatedRequirements *) ext;
req->requiresDedicatedAllocation = buffer->shareable; req->requiresDedicatedAllocation = buffer->shareable;
req->prefersDedicatedAllocation = req->requiresDedicatedAllocation; req->prefersDedicatedAllocation = req->requiresDedicatedAllocation;
break; break;
@@ -3211,8 +3211,8 @@ void radv_GetImageMemoryRequirements(
void radv_GetImageMemoryRequirements2( void radv_GetImageMemoryRequirements2(
VkDevice device, VkDevice device,
const VkImageMemoryRequirementsInfo2KHR* pInfo, const VkImageMemoryRequirementsInfo2 *pInfo,
VkMemoryRequirements2KHR* pMemoryRequirements) VkMemoryRequirements2 *pMemoryRequirements)
{ {
radv_GetImageMemoryRequirements(device, pInfo->image, radv_GetImageMemoryRequirements(device, pInfo->image,
&pMemoryRequirements->memoryRequirements); &pMemoryRequirements->memoryRequirements);
@@ -3221,9 +3221,9 @@ void radv_GetImageMemoryRequirements2(
vk_foreach_struct(ext, pMemoryRequirements->pNext) { vk_foreach_struct(ext, pMemoryRequirements->pNext) {
switch (ext->sType) { switch (ext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: { case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
VkMemoryDedicatedRequirementsKHR *req = VkMemoryDedicatedRequirements *req =
(VkMemoryDedicatedRequirementsKHR *) ext; (VkMemoryDedicatedRequirements *) ext;
req->requiresDedicatedAllocation = image->shareable; req->requiresDedicatedAllocation = image->shareable;
req->prefersDedicatedAllocation = req->requiresDedicatedAllocation; req->prefersDedicatedAllocation = req->requiresDedicatedAllocation;
break; break;
@@ -3245,9 +3245,9 @@ void radv_GetImageSparseMemoryRequirements(
void radv_GetImageSparseMemoryRequirements2( void radv_GetImageSparseMemoryRequirements2(
VkDevice device, VkDevice device,
const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, const VkImageSparseMemoryRequirementsInfo2 *pInfo,
uint32_t* pSparseMemoryRequirementCount, uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
{ {
stub(); stub();
} }
@@ -3262,7 +3262,7 @@ void radv_GetDeviceMemoryCommitment(
VkResult radv_BindBufferMemory2(VkDevice device, VkResult radv_BindBufferMemory2(VkDevice device,
uint32_t bindInfoCount, uint32_t bindInfoCount,
const VkBindBufferMemoryInfoKHR *pBindInfos) const VkBindBufferMemoryInfo *pBindInfos)
{ {
for (uint32_t i = 0; i < bindInfoCount; ++i) { for (uint32_t i = 0; i < bindInfoCount; ++i) {
RADV_FROM_HANDLE(radv_device_memory, mem, pBindInfos[i].memory); RADV_FROM_HANDLE(radv_device_memory, mem, pBindInfos[i].memory);
@@ -3284,8 +3284,8 @@ VkResult radv_BindBufferMemory(
VkDeviceMemory memory, VkDeviceMemory memory,
VkDeviceSize memoryOffset) VkDeviceSize memoryOffset)
{ {
const VkBindBufferMemoryInfoKHR info = { const VkBindBufferMemoryInfo info = {
.sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
.buffer = buffer, .buffer = buffer,
.memory = memory, .memory = memory,
.memoryOffset = memoryOffset .memoryOffset = memoryOffset
@@ -3296,7 +3296,7 @@ VkResult radv_BindBufferMemory(
VkResult radv_BindImageMemory2(VkDevice device, VkResult radv_BindImageMemory2(VkDevice device,
uint32_t bindInfoCount, uint32_t bindInfoCount,
const VkBindImageMemoryInfoKHR *pBindInfos) const VkBindImageMemoryInfo *pBindInfos)
{ {
for (uint32_t i = 0; i < bindInfoCount; ++i) { for (uint32_t i = 0; i < bindInfoCount; ++i) {
RADV_FROM_HANDLE(radv_device_memory, mem, pBindInfos[i].memory); RADV_FROM_HANDLE(radv_device_memory, mem, pBindInfos[i].memory);
@@ -3320,8 +3320,8 @@ VkResult radv_BindImageMemory(
VkDeviceMemory memory, VkDeviceMemory memory,
VkDeviceSize memoryOffset) VkDeviceSize memoryOffset)
{ {
const VkBindImageMemoryInfoKHR info = { const VkBindImageMemoryInfo info = {
.sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
.image = image, .image = image,
.memory = memory, .memory = memory,
.memoryOffset = memoryOffset .memoryOffset = memoryOffset
@@ -3446,9 +3446,9 @@ VkResult radv_CreateFence(
VkFence* pFence) VkFence* pFence)
{ {
RADV_FROM_HANDLE(radv_device, device, _device); RADV_FROM_HANDLE(radv_device, device, _device);
const VkExportFenceCreateInfoKHR *export = const VkExportFenceCreateInfo *export =
vk_find_struct_const(pCreateInfo->pNext, EXPORT_FENCE_CREATE_INFO_KHR); vk_find_struct_const(pCreateInfo->pNext, EXPORT_FENCE_CREATE_INFO);
VkExternalFenceHandleTypeFlagsKHR handleTypes = VkExternalFenceHandleTypeFlags handleTypes =
export ? export->handleTypes : 0; export ? export->handleTypes : 0;
struct radv_fence *fence = vk_alloc2(&device->alloc, pAllocator, struct radv_fence *fence = vk_alloc2(&device->alloc, pAllocator,
@@ -3735,9 +3735,9 @@ VkResult radv_CreateSemaphore(
VkSemaphore* pSemaphore) VkSemaphore* pSemaphore)
{ {
RADV_FROM_HANDLE(radv_device, device, _device); RADV_FROM_HANDLE(radv_device, device, _device);
const VkExportSemaphoreCreateInfoKHR *export = const VkExportSemaphoreCreateInfo *export =
vk_find_struct_const(pCreateInfo->pNext, EXPORT_SEMAPHORE_CREATE_INFO_KHR); vk_find_struct_const(pCreateInfo->pNext, EXPORT_SEMAPHORE_CREATE_INFO);
VkExternalSemaphoreHandleTypeFlagsKHR handleTypes = VkExternalSemaphoreHandleTypeFlags handleTypes =
export ? export->handleTypes : 0; export ? export->handleTypes : 0;
struct radv_semaphore *sem = vk_alloc2(&device->alloc, pAllocator, struct radv_semaphore *sem = vk_alloc2(&device->alloc, pAllocator,
@@ -4686,7 +4686,7 @@ VkResult radv_GetMemoryFdKHR(VkDevice _device,
/* At the moment, we support only the below handle types. */ /* At the moment, we support only the below handle types. */
assert(pGetFdInfo->handleType == assert(pGetFdInfo->handleType ==
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR || VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT ||
pGetFdInfo->handleType == pGetFdInfo->handleType ==
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT); VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
@@ -4697,7 +4697,7 @@ VkResult radv_GetMemoryFdKHR(VkDevice _device,
} }
VkResult radv_GetMemoryFdPropertiesKHR(VkDevice _device, VkResult radv_GetMemoryFdPropertiesKHR(VkDevice _device,
VkExternalMemoryHandleTypeFlagBitsKHR handleType, VkExternalMemoryHandleTypeFlagBits handleType,
int fd, int fd,
VkMemoryFdPropertiesKHR *pMemoryFdProperties) VkMemoryFdPropertiesKHR *pMemoryFdProperties)
{ {
@@ -4716,7 +4716,7 @@ VkResult radv_GetMemoryFdPropertiesKHR(VkDevice _device,
* *
* So opaque handle types fall into the default "unsupported" case. * So opaque handle types fall into the default "unsupported" case.
*/ */
return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
} }
} }
@@ -4727,7 +4727,7 @@ static VkResult radv_import_opaque_fd(struct radv_device *device,
uint32_t syncobj_handle = 0; uint32_t syncobj_handle = 0;
int ret = device->ws->import_syncobj(device->ws, fd, &syncobj_handle); int ret = device->ws->import_syncobj(device->ws, fd, &syncobj_handle);
if (ret != 0) if (ret != 0)
return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
if (*syncobj) if (*syncobj)
device->ws->destroy_syncobj(device->ws, *syncobj); device->ws->destroy_syncobj(device->ws, *syncobj);
@@ -4748,7 +4748,7 @@ static VkResult radv_import_sync_fd(struct radv_device *device,
if (!syncobj_handle) { if (!syncobj_handle) {
int ret = device->ws->create_syncobj(device->ws, &syncobj_handle); int ret = device->ws->create_syncobj(device->ws, &syncobj_handle);
if (ret) { if (ret) {
return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
} }
} }
@@ -4757,7 +4757,7 @@ static VkResult radv_import_sync_fd(struct radv_device *device,
} else { } else {
int ret = device->ws->import_syncobj_from_sync_file(device->ws, syncobj_handle, fd); int ret = device->ws->import_syncobj_from_sync_file(device->ws, syncobj_handle, fd);
if (ret != 0) if (ret != 0)
return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
} }
*syncobj = syncobj_handle; *syncobj = syncobj_handle;
@@ -4774,16 +4774,16 @@ VkResult radv_ImportSemaphoreFdKHR(VkDevice _device,
RADV_FROM_HANDLE(radv_semaphore, sem, pImportSemaphoreFdInfo->semaphore); RADV_FROM_HANDLE(radv_semaphore, sem, pImportSemaphoreFdInfo->semaphore);
uint32_t *syncobj_dst = NULL; uint32_t *syncobj_dst = NULL;
if (pImportSemaphoreFdInfo->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR) { if (pImportSemaphoreFdInfo->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) {
syncobj_dst = &sem->temp_syncobj; syncobj_dst = &sem->temp_syncobj;
} else { } else {
syncobj_dst = &sem->syncobj; syncobj_dst = &sem->syncobj;
} }
switch(pImportSemaphoreFdInfo->handleType) { switch(pImportSemaphoreFdInfo->handleType) {
case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
return radv_import_opaque_fd(device, pImportSemaphoreFdInfo->fd, syncobj_dst); return radv_import_opaque_fd(device, pImportSemaphoreFdInfo->fd, syncobj_dst);
case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR: case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
return radv_import_sync_fd(device, pImportSemaphoreFdInfo->fd, syncobj_dst); return radv_import_sync_fd(device, pImportSemaphoreFdInfo->fd, syncobj_dst);
default: default:
unreachable("Unhandled semaphore handle type"); unreachable("Unhandled semaphore handle type");
@@ -4805,10 +4805,10 @@ VkResult radv_GetSemaphoreFdKHR(VkDevice _device,
syncobj_handle = sem->syncobj; syncobj_handle = sem->syncobj;
switch(pGetFdInfo->handleType) { switch(pGetFdInfo->handleType) {
case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
ret = device->ws->export_syncobj(device->ws, syncobj_handle, pFd); ret = device->ws->export_syncobj(device->ws, syncobj_handle, pFd);
break; break;
case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR: case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
ret = device->ws->export_syncobj_to_sync_file(device->ws, syncobj_handle, pFd); ret = device->ws->export_syncobj_to_sync_file(device->ws, syncobj_handle, pFd);
if (!ret) { if (!ret) {
if (sem->temp_syncobj) { if (sem->temp_syncobj) {
@@ -4824,30 +4824,30 @@ VkResult radv_GetSemaphoreFdKHR(VkDevice _device,
} }
if (ret) if (ret)
return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
return VK_SUCCESS; return VK_SUCCESS;
} }
void radv_GetPhysicalDeviceExternalSemaphoreProperties( void radv_GetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties) VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
{ {
RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
/* Require has_syncobj_wait_for_submit for the syncobj signal ioctl introduced at virtually the same time */ /* Require has_syncobj_wait_for_submit for the syncobj signal ioctl introduced at virtually the same time */
if (pdevice->rad_info.has_syncobj_wait_for_submit && if (pdevice->rad_info.has_syncobj_wait_for_submit &&
(pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR || (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT ||
pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR)) { pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT)) {
pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR; pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR; pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR | pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR; VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
} else if (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR) { } else if (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR | pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR; VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
} else { } else {
pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0; pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
pExternalSemaphoreProperties->compatibleHandleTypes = 0; pExternalSemaphoreProperties->compatibleHandleTypes = 0;
@@ -4863,16 +4863,16 @@ VkResult radv_ImportFenceFdKHR(VkDevice _device,
uint32_t *syncobj_dst = NULL; uint32_t *syncobj_dst = NULL;
if (pImportFenceFdInfo->flags & VK_FENCE_IMPORT_TEMPORARY_BIT_KHR) { if (pImportFenceFdInfo->flags & VK_FENCE_IMPORT_TEMPORARY_BIT) {
syncobj_dst = &fence->temp_syncobj; syncobj_dst = &fence->temp_syncobj;
} else { } else {
syncobj_dst = &fence->syncobj; syncobj_dst = &fence->syncobj;
} }
switch(pImportFenceFdInfo->handleType) { switch(pImportFenceFdInfo->handleType) {
case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
return radv_import_opaque_fd(device, pImportFenceFdInfo->fd, syncobj_dst); return radv_import_opaque_fd(device, pImportFenceFdInfo->fd, syncobj_dst);
case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR: case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
return radv_import_sync_fd(device, pImportFenceFdInfo->fd, syncobj_dst); return radv_import_sync_fd(device, pImportFenceFdInfo->fd, syncobj_dst);
default: default:
unreachable("Unhandled fence handle type"); unreachable("Unhandled fence handle type");
@@ -4894,10 +4894,10 @@ VkResult radv_GetFenceFdKHR(VkDevice _device,
syncobj_handle = fence->syncobj; syncobj_handle = fence->syncobj;
switch(pGetFdInfo->handleType) { switch(pGetFdInfo->handleType) {
case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
ret = device->ws->export_syncobj(device->ws, syncobj_handle, pFd); ret = device->ws->export_syncobj(device->ws, syncobj_handle, pFd);
break; break;
case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR: case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
ret = device->ws->export_syncobj_to_sync_file(device->ws, syncobj_handle, pFd); ret = device->ws->export_syncobj_to_sync_file(device->ws, syncobj_handle, pFd);
if (!ret) { if (!ret) {
if (fence->temp_syncobj) { if (fence->temp_syncobj) {
@@ -4913,24 +4913,24 @@ VkResult radv_GetFenceFdKHR(VkDevice _device,
} }
if (ret) if (ret)
return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
return VK_SUCCESS; return VK_SUCCESS;
} }
void radv_GetPhysicalDeviceExternalFenceProperties( void radv_GetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
VkExternalFencePropertiesKHR* pExternalFenceProperties) VkExternalFenceProperties *pExternalFenceProperties)
{ {
RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
if (pdevice->rad_info.has_syncobj_wait_for_submit && if (pdevice->rad_info.has_syncobj_wait_for_submit &&
(pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR || (pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT ||
pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR)) { pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT)) {
pExternalFenceProperties->exportFromImportedHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR; pExternalFenceProperties->exportFromImportedHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
pExternalFenceProperties->compatibleHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR; pExternalFenceProperties->compatibleHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
pExternalFenceProperties->externalFenceFeatures = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR | pExternalFenceProperties->externalFenceFeatures = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT |
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR; VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
} else { } else {
pExternalFenceProperties->exportFromImportedHandleTypes = 0; pExternalFenceProperties->exportFromImportedHandleTypes = 0;
pExternalFenceProperties->compatibleHandleTypes = 0; pExternalFenceProperties->compatibleHandleTypes = 0;

82
src/amd/vulkan/radv_formats.c
View File

@@ -639,8 +639,8 @@ radv_physical_device_get_format_properties(struct radv_physical_device *physical
tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
tiled |= VK_FORMAT_FEATURE_BLIT_SRC_BIT | tiled |= VK_FORMAT_FEATURE_BLIT_SRC_BIT |
VK_FORMAT_FEATURE_BLIT_DST_BIT; VK_FORMAT_FEATURE_BLIT_DST_BIT;
tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR; VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
if (radv_is_filter_minmax_format_supported(format)) if (radv_is_filter_minmax_format_supported(format))
tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT; tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
@@ -684,8 +684,8 @@ radv_physical_device_get_format_properties(struct radv_physical_device *physical
} }
} }
if (tiled && !scaled) { if (tiled && !scaled) {
tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR; VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
} }
/* Tiled formatting does not support NPOT pixel sizes */ /* Tiled formatting does not support NPOT pixel sizes */
@@ -694,8 +694,8 @@ radv_physical_device_get_format_properties(struct radv_physical_device *physical
} }
if (linear && !scaled) { if (linear && !scaled) {
linear |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | linear |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR; VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
} }
if (format == VK_FORMAT_R32_UINT || format == VK_FORMAT_R32_SINT) { if (format == VK_FORMAT_R32_UINT || format == VK_FORMAT_R32_SINT) {
@@ -1026,7 +1026,7 @@ void radv_GetPhysicalDeviceFormatProperties(
void radv_GetPhysicalDeviceFormatProperties2( void radv_GetPhysicalDeviceFormatProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
VkFormat format, VkFormat format,
VkFormatProperties2KHR* pFormatProperties) VkFormatProperties2* pFormatProperties)
{ {
RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
@@ -1036,7 +1036,7 @@ void radv_GetPhysicalDeviceFormatProperties2(
} }
static VkResult radv_get_image_format_properties(struct radv_physical_device *physical_device, static VkResult radv_get_image_format_properties(struct radv_physical_device *physical_device,
const VkPhysicalDeviceImageFormatInfo2KHR *info, const VkPhysicalDeviceImageFormatInfo2 *info,
VkImageFormatProperties *pImageFormatProperties) VkImageFormatProperties *pImageFormatProperties)
{ {
@@ -1202,8 +1202,8 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties(
{ {
RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
const VkPhysicalDeviceImageFormatInfo2KHR info = { const VkPhysicalDeviceImageFormatInfo2 info = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
.pNext = NULL, .pNext = NULL,
.format = format, .format = format,
.type = type, .type = type,
@@ -1217,20 +1217,20 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties(
} }
static void static void
get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
VkExternalMemoryHandleTypeFlagBitsKHR handleType, VkExternalMemoryHandleTypeFlagBits handleType,
VkExternalMemoryPropertiesKHR *external_properties) VkExternalMemoryProperties *external_properties)
{ {
VkExternalMemoryFeatureFlagBitsKHR flags = 0; VkExternalMemoryFeatureFlagBits flags = 0;
VkExternalMemoryHandleTypeFlagsKHR export_flags = 0; VkExternalMemoryHandleTypeFlags export_flags = 0;
VkExternalMemoryHandleTypeFlagsKHR compat_flags = 0; VkExternalMemoryHandleTypeFlags compat_flags = 0;
switch (handleType) { switch (handleType) {
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
switch (pImageFormatInfo->type) { switch (pImageFormatInfo->type) {
case VK_IMAGE_TYPE_2D: case VK_IMAGE_TYPE_2D:
flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR; flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
break; break;
default: default:
@@ -1238,14 +1238,14 @@ get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2KHR *
} }
break; break;
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR; flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
break; break;
default: default:
break; break;
} }
*external_properties = (VkExternalMemoryPropertiesKHR) { *external_properties = (VkExternalMemoryProperties) {
.externalMemoryFeatures = flags, .externalMemoryFeatures = flags,
.exportFromImportedHandleTypes = export_flags, .exportFromImportedHandleTypes = export_flags,
.compatibleHandleTypes = compat_flags, .compatibleHandleTypes = compat_flags,
@@ -1254,12 +1254,12 @@ get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2KHR *
VkResult radv_GetPhysicalDeviceImageFormatProperties2( VkResult radv_GetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2KHR *base_info, const VkPhysicalDeviceImageFormatInfo2 *base_info,
VkImageFormatProperties2KHR *base_props) VkImageFormatProperties2 *base_props)
{ {
RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice); RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
const VkPhysicalDeviceExternalImageFormatInfoKHR *external_info = NULL; const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL;
VkExternalImageFormatPropertiesKHR *external_props = NULL; VkExternalImageFormatProperties *external_props = NULL;
VkResult result; VkResult result;
result = radv_get_image_format_properties(physical_device, base_info, result = radv_get_image_format_properties(physical_device, base_info,
@@ -1270,7 +1270,7 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties2(
/* Extract input structs */ /* Extract input structs */
vk_foreach_struct_const(s, base_info->pNext) { vk_foreach_struct_const(s, base_info->pNext) {
switch (s->sType) { switch (s->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
external_info = (const void *) s; external_info = (const void *) s;
break; break;
default: default:
@@ -1281,7 +1281,7 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties2(
/* Extract output structs */ /* Extract output structs */
vk_foreach_struct(s, base_props->pNext) { vk_foreach_struct(s, base_props->pNext) {
switch (s->sType) { switch (s->sType) {
case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
external_props = (void *) s; external_props = (void *) s;
break; break;
default: default:
@@ -1297,7 +1297,7 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties2(
*/ */
if (external_info && external_info->handleType != 0) { if (external_info && external_info->handleType != 0) {
switch (external_info->handleType) { switch (external_info->handleType) {
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
get_external_image_format_properties(base_info, external_info->handleType, get_external_image_format_properties(base_info, external_info->handleType,
@@ -1351,9 +1351,9 @@ void radv_GetPhysicalDeviceSparseImageFormatProperties(
void radv_GetPhysicalDeviceSparseImageFormatProperties2( void radv_GetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
uint32_t *pPropertyCount, uint32_t *pPropertyCount,
VkSparseImageFormatProperties2KHR* pProperties) VkSparseImageFormatProperties2 *pProperties)
{ {
/* Sparse images are not yet supported. */ /* Sparse images are not yet supported. */
*pPropertyCount = 0; *pPropertyCount = 0;
@@ -1361,28 +1361,28 @@ void radv_GetPhysicalDeviceSparseImageFormatProperties2(
void radv_GetPhysicalDeviceExternalBufferProperties( void radv_GetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
VkExternalBufferPropertiesKHR *pExternalBufferProperties) VkExternalBufferProperties *pExternalBufferProperties)
{ {
VkExternalMemoryFeatureFlagBitsKHR flags = 0; VkExternalMemoryFeatureFlagBits flags = 0;
VkExternalMemoryHandleTypeFlagsKHR export_flags = 0; VkExternalMemoryHandleTypeFlags export_flags = 0;
VkExternalMemoryHandleTypeFlagsKHR compat_flags = 0; VkExternalMemoryHandleTypeFlags compat_flags = 0;
switch(pExternalBufferInfo->handleType) { switch(pExternalBufferInfo->handleType) {
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR | flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR; VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
break; break;
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR; flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
break; break;
default: default:
break; break;
} }
pExternalBufferProperties->externalMemoryProperties = (VkExternalMemoryPropertiesKHR) { pExternalBufferProperties->externalMemoryProperties = (VkExternalMemoryProperties) {
.externalMemoryFeatures = flags, .externalMemoryFeatures = flags,
.exportFromImportedHandleTypes = export_flags, .exportFromImportedHandleTypes = export_flags,
.compatibleHandleTypes = compat_flags, .compatibleHandleTypes = compat_flags,

8
src/amd/vulkan/radv_image.c
View File

@@ -73,7 +73,7 @@ radv_use_tc_compat_htile_for_image(struct radv_device *device,
return false; return false;
if ((pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) || if ((pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) ||
(pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR)) (pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT))
return false; return false;
if (pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR) if (pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR)
@@ -143,7 +143,7 @@ radv_use_dcc_for_image(struct radv_device *device,
/* TODO: Enable DCC for storage images. */ /* TODO: Enable DCC for storage images. */
if ((pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) || if ((pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) ||
(pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR)) (pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT))
return false; return false;
if (pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR) if (pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR)
@@ -984,7 +984,7 @@ radv_image_create(VkDevice _device,
image->exclusive = pCreateInfo->sharingMode == VK_SHARING_MODE_EXCLUSIVE; image->exclusive = pCreateInfo->sharingMode == VK_SHARING_MODE_EXCLUSIVE;
if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) { if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) {
for (uint32_t i = 0; i < pCreateInfo->queueFamilyIndexCount; ++i) for (uint32_t i = 0; i < pCreateInfo->queueFamilyIndexCount; ++i)
if (pCreateInfo->pQueueFamilyIndices[i] == VK_QUEUE_FAMILY_EXTERNAL_KHR) if (pCreateInfo->pQueueFamilyIndices[i] == VK_QUEUE_FAMILY_EXTERNAL)
image->queue_family_mask |= (1u << RADV_MAX_QUEUE_FAMILIES) - 1u; image->queue_family_mask |= (1u << RADV_MAX_QUEUE_FAMILIES) - 1u;
else else
image->queue_family_mask |= 1u << pCreateInfo->pQueueFamilyIndices[i]; image->queue_family_mask |= 1u << pCreateInfo->pQueueFamilyIndices[i];
@@ -1264,7 +1264,7 @@ unsigned radv_image_queue_family_mask(const struct radv_image *image, uint32_t f
{ {
if (!image->exclusive) if (!image->exclusive)
return image->queue_family_mask; return image->queue_family_mask;
if (family == VK_QUEUE_FAMILY_EXTERNAL_KHR) if (family == VK_QUEUE_FAMILY_EXTERNAL)
return (1u << RADV_MAX_QUEUE_FAMILIES) - 1u; return (1u << RADV_MAX_QUEUE_FAMILIES) - 1u;
if (family == VK_QUEUE_FAMILY_IGNORED) if (family == VK_QUEUE_FAMILY_IGNORED)
return 1u << queue_family; return 1u << queue_family;

2
src/amd/vulkan/radv_meta_bufimage.c
View File

@@ -1593,7 +1593,7 @@ create_buffer_from_image(struct radv_cmd_buffer *cmd_buffer,
}, NULL, buffer); }, NULL, buffer);
radv_BindBufferMemory2(radv_device_to_handle(device), 1, radv_BindBufferMemory2(radv_device_to_handle(device), 1,
(VkBindBufferMemoryInfoKHR[]) { (VkBindBufferMemoryInfo[]) {
{ {
.sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
.buffer = *buffer, .buffer = *buffer,

6
src/amd/vulkan/radv_pass.c
View File

@@ -38,7 +38,7 @@ VkResult radv_CreateRenderPass(
struct radv_render_pass *pass; struct radv_render_pass *pass;
size_t size; size_t size;
size_t attachments_offset; size_t attachments_offset;
VkRenderPassMultiviewCreateInfoKHR *multiview_info = NULL; VkRenderPassMultiviewCreateInfo *multiview_info = NULL;
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
@@ -59,8 +59,8 @@ VkResult radv_CreateRenderPass(
vk_foreach_struct(ext, pCreateInfo->pNext) { vk_foreach_struct(ext, pCreateInfo->pNext) {
switch(ext->sType) { switch(ext->sType) {
case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
multiview_info = ( VkRenderPassMultiviewCreateInfoKHR*)ext; multiview_info = (VkRenderPassMultiviewCreateInfo*)ext;
break; break;
default: default:
break; break;

6
src/amd/vulkan/radv_pipeline.c
View File

@@ -1705,11 +1705,11 @@ calculate_tess_state(struct radv_pipeline *pipeline,
} }
bool ccw = tes->info.tes.ccw; bool ccw = tes->info.tes.ccw;
const VkPipelineTessellationDomainOriginStateCreateInfoKHR *domain_origin_state = const VkPipelineTessellationDomainOriginStateCreateInfo *domain_origin_state =
vk_find_struct_const(pCreateInfo->pTessellationState, vk_find_struct_const(pCreateInfo->pTessellationState,
PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR); PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO);
if (domain_origin_state && domain_origin_state->domainOrigin != VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR) if (domain_origin_state && domain_origin_state->domainOrigin != VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT)
ccw = !ccw; ccw = !ccw;
if (tes->info.tes.point_mode) if (tes->info.tes.point_mode)

4
src/amd/vulkan/radv_private.h
View File

@@ -1887,7 +1887,7 @@ void
radv_update_descriptor_set_with_template(struct radv_device *device, radv_update_descriptor_set_with_template(struct radv_device *device,
struct radv_cmd_buffer *cmd_buffer, struct radv_cmd_buffer *cmd_buffer,
struct radv_descriptor_set *set, struct radv_descriptor_set *set,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void *pData); const void *pData);
void radv_meta_push_descriptor_set(struct radv_cmd_buffer *cmd_buffer, void radv_meta_push_descriptor_set(struct radv_cmd_buffer *cmd_buffer,
@@ -1984,7 +1984,7 @@ RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_buffer_view, VkBufferView)
RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_pool, VkDescriptorPool) RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_pool, VkDescriptorPool)
RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_set, VkDescriptorSet) RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_set, VkDescriptorSet)
RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_set_layout, VkDescriptorSetLayout) RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_set_layout, VkDescriptorSetLayout)
RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_update_template, VkDescriptorUpdateTemplateKHR) RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_update_template, VkDescriptorUpdateTemplate)
RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_device_memory, VkDeviceMemory) RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_device_memory, VkDeviceMemory)
RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_fence, VkFence) RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_fence, VkFence)
RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_event, VkEvent) RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_event, VkEvent)