Module: Mesa Branch: main Commit: bc6f95c53e1d09b3cbdfb2c7154b33061f137e1d URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=bc6f95c53e1d09b3cbdfb2c7154b33061f137e1d
Author: Jarred Davies <[email protected]> Date: Thu Feb 23 05:16:48 2023 +0000 pvr: Add robustness buffer support The robustness buffer is used when no vertex attribute can be loaded and robustBufferAccess is enabled. Signed-off-by: Jarred Davies <[email protected]> Reviewed-by: Frank Binns <[email protected]> Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21579> --- src/imagination/vulkan/meson.build | 1 + src/imagination/vulkan/pvr_cmd_buffer.c | 30 +++ src/imagination/vulkan/pvr_device.c | 11 ++ src/imagination/vulkan/pvr_pipeline.c | 5 +- src/imagination/vulkan/pvr_private.h | 2 + src/imagination/vulkan/pvr_robustness.c | 339 ++++++++++++++++++++++++++++++++ src/imagination/vulkan/pvr_robustness.h | 37 ++++ 7 files changed, 424 insertions(+), 1 deletion(-) diff --git a/src/imagination/vulkan/meson.build b/src/imagination/vulkan/meson.build index 9e2806fbebb..6a36b51dd45 100644 --- a/src/imagination/vulkan/meson.build +++ b/src/imagination/vulkan/meson.build @@ -60,6 +60,7 @@ pvr_files = files( 'pvr_query.c', 'pvr_query_compute.c', 'pvr_queue.c', + 'pvr_robustness.c', 'pvr_shader.c', 'pvr_spm.c', 'pvr_tex_state.c', diff --git a/src/imagination/vulkan/pvr_cmd_buffer.c b/src/imagination/vulkan/pvr_cmd_buffer.c index 348a645d118..8e0e7e9c360 100644 --- a/src/imagination/vulkan/pvr_cmd_buffer.c +++ b/src/imagination/vulkan/pvr_cmd_buffer.c @@ -3030,6 +3030,36 @@ pvr_setup_vertex_buffers(struct pvr_cmd_buffer *cmd_buffer, break; } + case PVR_PDS_CONST_MAP_ENTRY_TYPE_ROBUST_VERTEX_ATTRIBUTE_ADDRESS: { + const struct pvr_const_map_entry_robust_vertex_attribute_address + *const attribute = + (struct pvr_const_map_entry_robust_vertex_attribute_address *) + entries; + const struct pvr_vertex_binding *const binding = + &state->vertex_bindings[attribute->binding_index]; + pvr_dev_addr_t addr; + + if (binding->buffer->vk.size < + (attribute->offset + attribute->component_size_in_bytes)) { + /* Replace with load from robustness buffer when no attribute is in range + */ + addr = PVR_DEV_ADDR_OFFSET( + cmd_buffer->device->robustness_buffer->vma->dev_addr, + attribute->robustness_buffer_offset); + } else { + addr = PVR_DEV_ADDR_OFFSET(binding->buffer->dev_addr, + binding->offset + attribute->offset); + } + + PVR_WRITE(qword_buffer, + addr.addr, + attribute->const_offset, + pds_info->data_size_in_dwords); + + entries += sizeof(*attribute); + break; + } + default: unreachable("Unsupported data section map"); break; diff --git a/src/imagination/vulkan/pvr_device.c b/src/imagination/vulkan/pvr_device.c index ba8db0a084e..9bec439e55c 100644 --- a/src/imagination/vulkan/pvr_device.c +++ b/src/imagination/vulkan/pvr_device.c @@ -51,6 +51,7 @@ #include "pvr_limits.h" #include "pvr_pds.h" #include "pvr_private.h" +#include "pvr_robustness.h" #include "pvr_tex_state.h" #include "pvr_types.h" #include "pvr_uscgen.h" @@ -1827,6 +1828,10 @@ VkResult pvr_CreateDevice(VkPhysicalDevice physicalDevice, pvr_spm_init_scratch_buffer_store(device); + result = pvr_init_robustness_buffer(device); + if (result != VK_SUCCESS) + goto err_pvr_spm_finish_scratch_buffer_store; + if (pCreateInfo->pEnabledFeatures) memcpy(&device->features, pCreateInfo->pEnabledFeatures, @@ -1847,6 +1852,11 @@ VkResult pvr_CreateDevice(VkPhysicalDevice physicalDevice, return VK_SUCCESS; +err_pvr_spm_finish_scratch_buffer_store: + pvr_spm_finish_scratch_buffer_store(device); + + pvr_queues_destroy(device); + err_pvr_finish_tile_buffer_state: pvr_device_finish_tile_buffer_state(device); pvr_device_finish_spm_load_state(device); @@ -1899,6 +1909,7 @@ void pvr_DestroyDevice(VkDevice _device, { PVR_FROM_HANDLE(pvr_device, device, _device); + pvr_robustness_buffer_finish(device); pvr_spm_finish_scratch_buffer_store(device); pvr_queues_destroy(device); pvr_device_finish_tile_buffer_state(device); diff --git a/src/imagination/vulkan/pvr_pipeline.c b/src/imagination/vulkan/pvr_pipeline.c index 806249e2e93..d95fd4ce1a8 100644 --- a/src/imagination/vulkan/pvr_pipeline.c +++ b/src/imagination/vulkan/pvr_pipeline.c @@ -39,6 +39,7 @@ #include "pvr_hardcode.h" #include "pvr_pds.h" #include "pvr_private.h" +#include "pvr_robustness.h" #include "pvr_shader.h" #include "pvr_types.h" #include "rogue/rogue.h" @@ -333,7 +334,9 @@ static void pvr_pds_vertex_attrib_init_dma_descriptions( dma_desc->destination = vs_data->inputs.base[location]; dma_desc->binding_index = attrib_desc->binding; dma_desc->divisor = 1; - dma_desc->robustness_buffer_offset = 0; + + dma_desc->robustness_buffer_offset = + pvr_get_robustness_buffer_format_offset(attrib_desc->format); ++dma_count; } diff --git a/src/imagination/vulkan/pvr_private.h b/src/imagination/vulkan/pvr_private.h index 28a9262a6a6..c0aa911b71a 100644 --- a/src/imagination/vulkan/pvr_private.h +++ b/src/imagination/vulkan/pvr_private.h @@ -274,6 +274,8 @@ struct pvr_device { struct pvr_bo_store *bo_store; + struct pvr_bo *robustness_buffer; + struct vk_sync *presignaled_sync; }; diff --git a/src/imagination/vulkan/pvr_robustness.c b/src/imagination/vulkan/pvr_robustness.c new file mode 100644 index 00000000000..74f196d9364 --- /dev/null +++ b/src/imagination/vulkan/pvr_robustness.c @@ -0,0 +1,339 @@ +/* + * Copyright © 2023 Imagination Technologies Ltd. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include <stdint.h> +#include <vulkan/vulkan_core.h> + +#include "pvr_bo.h" +#include "pvr_private.h" +#include "pvr_robustness.h" +#include "util/u_math.h" + +enum pvr_robustness_buffer_format { + PVR_ROBUSTNESS_BUFFER_FORMAT_UINT64, + PVR_ROBUSTNESS_BUFFER_FORMAT_UINT32, + PVR_ROBUSTNESS_BUFFER_FORMAT_UINT16, + PVR_ROBUSTNESS_BUFFER_FORMAT_UINT8, + PVR_ROBUSTNESS_BUFFER_FORMAT_SINT64, + PVR_ROBUSTNESS_BUFFER_FORMAT_SINT32, + PVR_ROBUSTNESS_BUFFER_FORMAT_SINT16, + PVR_ROBUSTNESS_BUFFER_FORMAT_SINT8, + PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT64, + PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT32, + PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT16, + PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_UINT, + PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_SINT, + PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_UINT, + PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_SINT, + PVR_ROBUSTNESS_BUFFER_FORMAT_R4G4B4A4_UNORM, + PVR_ROBUSTNESS_BUFFER_FORMAT_R5G5B5A1_UNORM, + PVR_ROBUSTNESS_BUFFER_FORMAT_A1R5G5B5_UNORM, + PVR_ROBUSTNESS_BUFFER_FORMAT_COUNT +}; + +/* Offsets in bytes of the [0, 0, 0, 1] vectors within the robustness buffer */ +static uint16_t robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_COUNT]; + +VkResult pvr_init_robustness_buffer(struct pvr_device *device) +{ + uint16_t offset = 0; + uint8_t *robustness_buffer_map; + VkResult result; + +#define ROBUSTNESS_BUFFER_OFFSET_ALIGN16(cur_offset, add) \ + ((uint16_t)ALIGN((cur_offset + (uint16_t)(add)), 16)) + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT64] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(uint64_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT32] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(uint32_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT16] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(uint16_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT8] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(uint8_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT64] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(int64_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT32] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(int32_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT16] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(int16_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT8] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(int8_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT64] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(double) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT32] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(float) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT16] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, sizeof(uint16_t) * 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_UINT] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_SINT] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_UINT] = + offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_SINT] = + offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, 4); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_R4G4B4A4_UNORM] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, 2); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_R5G5B5A1_UNORM] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, 2); + + robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A1R5G5B5_UNORM] = offset; + offset = ROBUSTNESS_BUFFER_OFFSET_ALIGN16(offset, 2); + +#undef ROBUSTNESS_BUFFER_OFFSET_ALIGN16 + + result = pvr_bo_alloc(device, + device->heaps.general_heap, + offset, + 16, + PVR_BO_ALLOC_FLAG_CPU_MAPPED, + &device->robustness_buffer); + if (result != VK_SUCCESS) + return result; + + robustness_buffer_map = device->robustness_buffer->bo->map; + +#define ROBUSTNESS_BUFFER_RGBA(format, type, zero, one) \ + do { \ + type *const buffer = \ + (type *)robustness_buffer_map + robustness_buffer_offsets[format]; \ + buffer[0] = (type)zero; \ + buffer[1] = (type)zero; \ + buffer[2] = (type)zero; \ + buffer[3] = (type)one; \ + } while (0) + +#define ROBUSTNESS_BUFFER_ABGR(format, type, zero, one) \ + do { \ + type *const buffer = \ + (type *)robustness_buffer_map + robustness_buffer_offsets[format]; \ + buffer[0] = (type)one; \ + buffer[1] = (type)zero; \ + buffer[2] = (type)zero; \ + buffer[3] = (type)zero; \ + } while (0) + +#define ROBUSTNESS_BUFFER_PACKED(format, type, val) \ + do { \ + type *const buffer = \ + (type *)robustness_buffer_map + robustness_buffer_offsets[format]; \ + *buffer = (type)val; \ + } while (0) + + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_UINT64, + uint64_t, + 0ull, + UINT64_MAX); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_UINT32, + uint32_t, + 0ul, + UINT32_MAX); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_UINT16, + uint16_t, + 0u, + UINT16_MAX); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_UINT8, + uint8_t, + 0u, + UINT8_MAX); + + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_SINT64, + int64_t, + 0ull, + INT64_MAX); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_SINT32, + int32_t, + 0ul, + INT32_MAX); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_SINT16, + int16_t, + 0u, + INT16_MAX); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_SINT8, + int8_t, + 0u, + INT8_MAX); + + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT64, + uint64_t, + 0x0000000000000000ull, + 0x3ff0000000000000ull); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT32, + float, + 0.0f, + 1.0f); + ROBUSTNESS_BUFFER_RGBA(PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT16, + uint16_t, + 0x0000, + 0x3c00); + + ROBUSTNESS_BUFFER_ABGR(PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_UINT, + uint8_t, + 0u, + UINT8_MAX); + ROBUSTNESS_BUFFER_ABGR(PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_UINT, + int8_t, + 0u, + INT8_MAX); + + ROBUSTNESS_BUFFER_PACKED(PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_UINT, + uint32_t, + 0xC0000000u); + ROBUSTNESS_BUFFER_PACKED(PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_SINT, + uint32_t, + 0x40000000u); + ROBUSTNESS_BUFFER_PACKED(PVR_ROBUSTNESS_BUFFER_FORMAT_R4G4B4A4_UNORM, + uint16_t, + 0x000Fu); + ROBUSTNESS_BUFFER_PACKED(PVR_ROBUSTNESS_BUFFER_FORMAT_R5G5B5A1_UNORM, + uint16_t, + 0x0001u); + ROBUSTNESS_BUFFER_PACKED(PVR_ROBUSTNESS_BUFFER_FORMAT_A1R5G5B5_UNORM, + uint16_t, + 0x8000u); + +#undef ROBUSTNESS_BUFFER_RGBA +#undef ROBUSTNESS_BUFFER_ABGR +#undef ROBUSTNESS_BUFFER_PACKED + + return VK_SUCCESS; +} + +void pvr_robustness_buffer_finish(struct pvr_device *device) +{ + pvr_bo_free(device, device->robustness_buffer); +} + +uint16_t pvr_get_robustness_buffer_format_offset(VkFormat format) +{ + switch (format) { + case VK_FORMAT_R64G64B64A64_SFLOAT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT64]; + + case VK_FORMAT_R32G32B32A32_SFLOAT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT32]; + + case VK_FORMAT_R16G16B16A16_SFLOAT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SFLOAT16]; + + case VK_FORMAT_R64G64B64A64_UINT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT64]; + + case VK_FORMAT_R32G32B32A32_UINT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT32]; + + case VK_FORMAT_R16G16B16A16_UNORM: + case VK_FORMAT_R16G16B16A16_USCALED: + case VK_FORMAT_R16G16B16A16_UINT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT16]; + + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_USCALED: + case VK_FORMAT_R8G8B8A8_UINT: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_B8G8R8A8_SRGB: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT8]; + + case VK_FORMAT_R64G64B64A64_SINT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT64]; + + case VK_FORMAT_R32G32B32A32_SINT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT32]; + + case VK_FORMAT_R16G16B16A16_SNORM: + case VK_FORMAT_R16G16B16A16_SSCALED: + case VK_FORMAT_R16G16B16A16_SINT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT16]; + + case VK_FORMAT_R8G8B8A8_SNORM: + case VK_FORMAT_R8G8B8A8_SSCALED: + case VK_FORMAT_R8G8B8A8_SINT: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_B8G8R8A8_SINT: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_SINT8]; + + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_UINT]; + + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A8B8G8R8_SINT]; + + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_UINT]; + + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A2R10G10B10_SINT]; + + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_R4G4B4A4_UNORM]; + + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_R5G5B5A1_UNORM]; + + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_A1R5G5B5_UNORM]; + + default: + return robustness_buffer_offsets[PVR_ROBUSTNESS_BUFFER_FORMAT_UINT64]; + } +} diff --git a/src/imagination/vulkan/pvr_robustness.h b/src/imagination/vulkan/pvr_robustness.h new file mode 100644 index 00000000000..cd98da6665a --- /dev/null +++ b/src/imagination/vulkan/pvr_robustness.h @@ -0,0 +1,37 @@ +/* + * Copyright © 2023 Imagination Technologies Ltd. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef PVR_ROBUSTNESS_H +#define PVR_ROBUSTNESS_H + +#include <stdint.h> +#include <vulkan/vulkan_core.h> + +struct pvr_device; + +VkResult pvr_init_robustness_buffer(struct pvr_device *device); +void pvr_robustness_buffer_finish(struct pvr_device *device); + +uint16_t pvr_get_robustness_buffer_format_offset(VkFormat format); + +#endif /* PVR_ROBUSTNESS_H */
