/* * Copyright 2024 Valve Corporation * Copyright 2024 Alyssa Rosenzweig * Copyright 2022-2023 Collabora Ltd. and Red Hat Inc. * SPDX-License-Identifier: MIT */ #include "hk_physical_device.h" #include "asahi/lib/agx_device.h" #include "asahi/lib/agx_nir_lower_vbo.h" #include "asahi/lib/agx_nir_passes.h" #include "util/disk_cache.h" #include "util/mesa-sha1.h" #include "git_sha1.h" #include "hk_buffer.h" #include "hk_entrypoints.h" #include "hk_image.h" #include "hk_instance.h" #include "hk_private.h" #include "hk_shader.h" #include "hk_wsi.h" #include "util/u_debug.h" #include "vulkan/vulkan_core.h" #include "vulkan/wsi/wsi_common.h" #include "vk_device.h" #include "vk_drm_syncobj.h" #include "vk_shader_module.h" #include #include #include #include #include static uint32_t hk_get_vk_version() { /* Version override takes priority */ const uint32_t version_override = vk_get_version_override(); if (version_override) return version_override; return VK_MAKE_VERSION(1, 3, VK_HEADER_VERSION); } static void hk_get_device_extensions(const struct hk_instance *instance, struct vk_device_extension_table *ext) { *ext = (struct vk_device_extension_table){ .KHR_8bit_storage = true, .KHR_16bit_storage = true, .KHR_bind_memory2 = true, .KHR_buffer_device_address = true, .KHR_calibrated_timestamps = false, .KHR_copy_commands2 = true, .KHR_create_renderpass2 = true, .KHR_dedicated_allocation = true, .KHR_depth_stencil_resolve = true, .KHR_descriptor_update_template = true, .KHR_device_group = true, .KHR_draw_indirect_count = true, .KHR_driver_properties = true, .KHR_dynamic_rendering = true, // TODO .KHR_dynamic_rendering_local_read = false, .KHR_external_fence = true, .KHR_external_fence_fd = true, .KHR_external_memory = true, .KHR_external_memory_fd = true, /* XXX: External timeline semaphores maybe broken in kernel, see * dEQP-VK.synchronization.signal_order.shared_timeline_semaphore.write_copy_buffer_to_image_read_image_compute.image_128_r32_uint_opaque_fd */ .KHR_external_semaphore = false, .KHR_external_semaphore_fd = false, .KHR_format_feature_flags2 = true, .KHR_fragment_shader_barycentric = false, .KHR_get_memory_requirements2 = true, .KHR_global_priority = true, .KHR_image_format_list = true, .KHR_imageless_framebuffer = true, #ifdef HK_USE_WSI_PLATFORM .KHR_incremental_present = true, #endif .KHR_index_type_uint8 = true, .KHR_line_rasterization = true, .KHR_load_store_op_none = true, .KHR_maintenance1 = true, .KHR_maintenance2 = true, .KHR_maintenance3 = true, .KHR_maintenance4 = true, .KHR_maintenance5 = true, .KHR_maintenance6 = true, .KHR_map_memory2 = true, .KHR_multiview = true, .KHR_pipeline_executable_properties = true, .KHR_pipeline_library = true, .KHR_push_descriptor = true, .KHR_relaxed_block_layout = true, .KHR_sampler_mirror_clamp_to_edge = true, .KHR_sampler_ycbcr_conversion = true, .KHR_separate_depth_stencil_layouts = true, .KHR_shader_atomic_int64 = false, .KHR_shader_clock = false, .KHR_shader_draw_parameters = true, .KHR_shader_expect_assume = true, .KHR_shader_float_controls = true, // TODO: wait for nvk .KHR_shader_float_controls2 = true, .KHR_shader_float16_int8 = true, .KHR_shader_integer_dot_product = true, .KHR_shader_maximal_reconvergence = true, .KHR_shader_non_semantic_info = true, .KHR_shader_relaxed_extended_instruction = true, .KHR_shader_subgroup_extended_types = true, .KHR_shader_subgroup_rotate = true, .KHR_shader_subgroup_uniform_control_flow = true, .KHR_shader_terminate_invocation = true, .KHR_spirv_1_4 = true, .KHR_storage_buffer_storage_class = true, .KHR_timeline_semaphore = true, #ifdef HK_USE_WSI_PLATFORM .KHR_swapchain = true, .KHR_swapchain_mutable_format = true, #endif .KHR_synchronization2 = true, .KHR_uniform_buffer_standard_layout = true, .KHR_variable_pointers = true, .KHR_vertex_attribute_divisor = true, .KHR_vulkan_memory_model = true, .KHR_workgroup_memory_explicit_layout = true, .KHR_zero_initialize_workgroup_memory = true, .EXT_4444_formats = true, .EXT_attachment_feedback_loop_layout = true, .EXT_border_color_swizzle = true, .EXT_buffer_device_address = true, .EXT_calibrated_timestamps = false, .EXT_conditional_rendering = false, .EXT_color_write_enable = true, .EXT_custom_border_color = true, .EXT_depth_bias_control = false, .EXT_depth_clip_control = false, .EXT_depth_clip_enable = true, .EXT_descriptor_indexing = true, #ifdef VK_USE_PLATFORM_DISPLAY_KHR .EXT_display_control = false, #endif .EXT_dynamic_rendering_unused_attachments = true, .EXT_extended_dynamic_state = true, .EXT_extended_dynamic_state2 = true, .EXT_extended_dynamic_state3 = true, .EXT_external_memory_dma_buf = true, // TODO .EXT_global_priority = false, // TODO .EXT_global_priority_query = false, .EXT_graphics_pipeline_library = true, .EXT_host_query_reset = true, .EXT_host_image_copy = true, .EXT_image_2d_view_of_3d = true, .EXT_image_robustness = true, .EXT_image_sliced_view_of_3d = false, .EXT_image_view_min_lod = false, .EXT_index_type_uint8 = true, .EXT_inline_uniform_block = true, .EXT_line_rasterization = true, .EXT_load_store_op_none = true, .EXT_map_memory_placed = false, .EXT_memory_budget = false, .EXT_multi_draw = true, .EXT_mutable_descriptor_type = true, .EXT_non_seamless_cube_map = true, .EXT_pipeline_creation_cache_control = true, .EXT_pipeline_creation_feedback = true, .EXT_pipeline_protected_access = true, .EXT_pipeline_robustness = true, .EXT_physical_device_drm = true, .EXT_primitive_topology_list_restart = true, .EXT_private_data = true, .EXT_primitives_generated_query = false, .EXT_provoking_vertex = true, .EXT_robustness2 = true, .EXT_sample_locations = true, .EXT_sampler_filter_minmax = false, .EXT_scalar_block_layout = true, .EXT_separate_stencil_usage = true, .EXT_shader_image_atomic_int64 = false, .EXT_shader_demote_to_helper_invocation = true, .EXT_shader_module_identifier = true, .EXT_shader_object = true, .EXT_shader_replicated_composites = true, .EXT_shader_stencil_export = true, .EXT_shader_subgroup_ballot = true, .EXT_shader_subgroup_vote = true, .EXT_shader_viewport_index_layer = true, .EXT_subgroup_size_control = true, #ifdef HK_USE_WSI_PLATFORM .EXT_swapchain_maintenance1 = true, #endif .EXT_texel_buffer_alignment = true, .EXT_tooling_info = true, .EXT_transform_feedback = true, .EXT_vertex_attribute_divisor = true, .EXT_vertex_input_dynamic_state = true, .EXT_ycbcr_2plane_444_formats = false, .EXT_ycbcr_image_arrays = false, .GOOGLE_decorate_string = true, .GOOGLE_hlsl_functionality1 = true, .GOOGLE_user_type = true, .VALVE_mutable_descriptor_type = true, }; } static void hk_get_device_features( const struct vk_device_extension_table *supported_extensions, struct vk_features *features) { *features = (struct vk_features){ /* Vulkan 1.0 */ .robustBufferAccess = true, .fullDrawIndexUint32 = true, .imageCubeArray = true, .independentBlend = true, .geometryShader = true, .tessellationShader = true, .sampleRateShading = true, .dualSrcBlend = true, .logicOp = true, .multiDrawIndirect = true, .drawIndirectFirstInstance = true, .depthClamp = true, .depthBiasClamp = true, .fillModeNonSolid = true, .depthBounds = false, .wideLines = true, .largePoints = true, .alphaToOne = true, .multiViewport = true, .samplerAnisotropy = true, .textureCompressionETC2 = false, .textureCompressionBC = true, .textureCompressionASTC_LDR = false, .occlusionQueryPrecise = true, .pipelineStatisticsQuery = true, .vertexPipelineStoresAndAtomics = true, .fragmentStoresAndAtomics = true, .shaderTessellationAndGeometryPointSize = true, .shaderImageGatherExtended = true, .shaderStorageImageExtendedFormats = true, /* TODO: hitting the vertex shader timeout in CTS, but should work */ .shaderStorageImageMultisample = false, .shaderStorageImageReadWithoutFormat = true, .shaderStorageImageWriteWithoutFormat = true, .shaderUniformBufferArrayDynamicIndexing = true, .shaderSampledImageArrayDynamicIndexing = true, .shaderStorageBufferArrayDynamicIndexing = true, .shaderStorageImageArrayDynamicIndexing = true, .shaderClipDistance = true, .shaderCullDistance = true, .shaderFloat64 = false, .shaderInt64 = true, .shaderInt16 = true, .shaderResourceResidency = false, .shaderResourceMinLod = true, .sparseBinding = false, .sparseResidency2Samples = false, .sparseResidency4Samples = false, .sparseResidency8Samples = false, .sparseResidencyAliased = false, .sparseResidencyBuffer = false, .sparseResidencyImage2D = false, .sparseResidencyImage3D = false, .variableMultisampleRate = false, .inheritedQueries = true, /* Vulkan 1.1 */ .storageBuffer16BitAccess = true, .uniformAndStorageBuffer16BitAccess = true, .storagePushConstant16 = true, .storageInputOutput16 = false, .multiview = true, .multiviewGeometryShader = false, .multiviewTessellationShader = false, .variablePointersStorageBuffer = true, .variablePointers = true, .shaderDrawParameters = true, .samplerYcbcrConversion = true, /* Vulkan 1.2 */ .samplerMirrorClampToEdge = true, .drawIndirectCount = true, .storageBuffer8BitAccess = true, .uniformAndStorageBuffer8BitAccess = true, .storagePushConstant8 = true, .shaderBufferInt64Atomics = false, .shaderSharedInt64Atomics = false, .shaderFloat16 = true, .shaderInt8 = true, .descriptorIndexing = true, .shaderInputAttachmentArrayDynamicIndexing = true, .shaderUniformTexelBufferArrayDynamicIndexing = true, .shaderStorageTexelBufferArrayDynamicIndexing = true, .shaderUniformBufferArrayNonUniformIndexing = true, .shaderSampledImageArrayNonUniformIndexing = true, .shaderStorageBufferArrayNonUniformIndexing = true, .shaderStorageImageArrayNonUniformIndexing = true, .shaderInputAttachmentArrayNonUniformIndexing = true, .shaderUniformTexelBufferArrayNonUniformIndexing = true, .shaderStorageTexelBufferArrayNonUniformIndexing = true, .descriptorBindingUniformBufferUpdateAfterBind = true, .descriptorBindingSampledImageUpdateAfterBind = true, .descriptorBindingStorageImageUpdateAfterBind = true, .descriptorBindingStorageBufferUpdateAfterBind = true, .descriptorBindingUniformTexelBufferUpdateAfterBind = true, .descriptorBindingStorageTexelBufferUpdateAfterBind = true, .descriptorBindingUpdateUnusedWhilePending = true, .descriptorBindingPartiallyBound = true, .descriptorBindingVariableDescriptorCount = true, .runtimeDescriptorArray = true, .samplerFilterMinmax = false, .scalarBlockLayout = true, .imagelessFramebuffer = true, .uniformBufferStandardLayout = true, .shaderSubgroupExtendedTypes = true, .separateDepthStencilLayouts = true, .hostQueryReset = true, .timelineSemaphore = true, .bufferDeviceAddress = true, .bufferDeviceAddressCaptureReplay = false, .bufferDeviceAddressMultiDevice = false, .vulkanMemoryModel = true, .vulkanMemoryModelDeviceScope = true, .vulkanMemoryModelAvailabilityVisibilityChains = false, .shaderOutputViewportIndex = true, .shaderOutputLayer = true, .subgroupBroadcastDynamicId = true, /* Vulkan 1.3 */ .robustImageAccess = true, .inlineUniformBlock = true, .descriptorBindingInlineUniformBlockUpdateAfterBind = true, .pipelineCreationCacheControl = true, .privateData = true, .shaderDemoteToHelperInvocation = true, .shaderTerminateInvocation = true, .subgroupSizeControl = true, .computeFullSubgroups = true, .synchronization2 = true, .shaderZeroInitializeWorkgroupMemory = true, .dynamicRendering = true, .shaderIntegerDotProduct = true, .maintenance4 = true, /* VK_KHR_dynamic_rendering_local_read */ .dynamicRenderingLocalRead = true, /* VK_KHR_fragment_shader_barycentric */ .fragmentShaderBarycentric = false, /* VK_KHR_global_priority */ .globalPriorityQuery = true, /* VK_KHR_index_type_uint8 */ .indexTypeUint8 = true, /* VK_KHR_line_rasterization */ .rectangularLines = false, .bresenhamLines = true, .smoothLines = false, .stippledRectangularLines = false, .stippledBresenhamLines = false, .stippledSmoothLines = false, /* VK_KHR_maintenance5 */ .maintenance5 = true, /* VK_KHR_maintenance6 */ .maintenance6 = true, /* VK_KHR_pipeline_executable_properties */ .pipelineExecutableInfo = true, /* VK_KHR_present_id */ .presentId = false, /* VK_KHR_present_wait */ .presentWait = false, /* VK_KHR_shader_clock */ .shaderSubgroupClock = false, .shaderDeviceClock = false, /* VK_KHR_shader_expect_assume */ .shaderExpectAssume = true, /* VK_KHR_shader_float_controls2 */ .shaderFloatControls2 = true, /* VK_KHR_shader_maximal_reconvergence */ .shaderMaximalReconvergence = true, /* VK_KHR_shader_subgroup_rotate */ .shaderSubgroupRotate = true, .shaderSubgroupRotateClustered = true, /* VK_KHR_vertex_attribute_divisor */ .vertexAttributeInstanceRateDivisor = true, .vertexAttributeInstanceRateZeroDivisor = true, /* VK_KHR_workgroup_memory_explicit_layout */ .workgroupMemoryExplicitLayout = true, .workgroupMemoryExplicitLayoutScalarBlockLayout = true, .workgroupMemoryExplicitLayout8BitAccess = true, .workgroupMemoryExplicitLayout16BitAccess = true, /* VK_EXT_4444_formats */ .formatA4R4G4B4 = true, .formatA4B4G4R4 = true, /* VK_EXT_attachment_feedback_loop_layout */ .attachmentFeedbackLoopLayout = true, /* VK_EXT_border_color_swizzle */ .borderColorSwizzle = true, .borderColorSwizzleFromImage = false, /* VK_EXT_buffer_device_address */ .bufferDeviceAddressCaptureReplayEXT = false, /* VK_EXT_color_write_enable */ .colorWriteEnable = true, /* VK_EXT_conditional_rendering */ .conditionalRendering = false, .inheritedConditionalRendering = false, /* VK_EXT_custom_border_color */ .customBorderColors = true, .customBorderColorWithoutFormat = true, /* VK_EXT_depth_bias_control */ .depthBiasControl = false, .leastRepresentableValueForceUnormRepresentation = false, .floatRepresentation = false, .depthBiasExact = false, /* VK_EXT_depth_clip_control */ .depthClipControl = false, /* VK_EXT_depth_clip_enable */ .depthClipEnable = true, /* VK_EXT_dynamic_rendering_unused_attachments */ .dynamicRenderingUnusedAttachments = true, /* VK_EXT_extended_dynamic_state */ .extendedDynamicState = true, /* VK_EXT_extended_dynamic_state2 */ .extendedDynamicState2 = true, .extendedDynamicState2LogicOp = true, .extendedDynamicState2PatchControlPoints = true, /* VK_EXT_extended_dynamic_state3 */ .extendedDynamicState3TessellationDomainOrigin = true, .extendedDynamicState3DepthClampEnable = true, .extendedDynamicState3PolygonMode = true, .extendedDynamicState3RasterizationSamples = true, .extendedDynamicState3SampleMask = true, .extendedDynamicState3AlphaToCoverageEnable = true, .extendedDynamicState3AlphaToOneEnable = true, .extendedDynamicState3LogicOpEnable = true, .extendedDynamicState3ColorBlendEnable = true, .extendedDynamicState3ColorBlendEquation = true, .extendedDynamicState3ColorWriteMask = true, .extendedDynamicState3RasterizationStream = false, .extendedDynamicState3ConservativeRasterizationMode = false, .extendedDynamicState3ExtraPrimitiveOverestimationSize = false, .extendedDynamicState3DepthClipEnable = true, .extendedDynamicState3SampleLocationsEnable = false, .extendedDynamicState3ColorBlendAdvanced = false, .extendedDynamicState3ProvokingVertexMode = true, .extendedDynamicState3LineRasterizationMode = true, .extendedDynamicState3LineStippleEnable = false, .extendedDynamicState3DepthClipNegativeOneToOne = false, .extendedDynamicState3ViewportWScalingEnable = false, .extendedDynamicState3ViewportSwizzle = false, .extendedDynamicState3CoverageToColorEnable = false, .extendedDynamicState3CoverageToColorLocation = false, .extendedDynamicState3CoverageModulationMode = false, .extendedDynamicState3CoverageModulationTableEnable = false, .extendedDynamicState3CoverageModulationTable = false, .extendedDynamicState3CoverageReductionMode = false, .extendedDynamicState3RepresentativeFragmentTestEnable = false, .extendedDynamicState3ShadingRateImageEnable = false, /* VK_EXT_graphics_pipeline_library */ .graphicsPipelineLibrary = true, /* VK_EXT_host_image_copy */ .hostImageCopy = true, /* VK_EXT_image_2d_view_of_3d */ .image2DViewOf3D = true, .sampler2DViewOf3D = true, /* VK_EXT_image_sliced_view_of_3d */ .imageSlicedViewOf3D = false, #ifdef HK_USE_WSI_PLATFORM /* VK_EXT_swapchain_maintenance1 */ .swapchainMaintenance1 = false, #endif /* VK_EXT_image_view_min_lod */ .minLod = false, /* VK_EXT_map_memory_placed */ .memoryMapPlaced = false, .memoryMapRangePlaced = false, .memoryUnmapReserve = false, /* VK_EXT_multi_draw */ .multiDraw = true, /* VK_EXT_mutable_descriptor_type */ .mutableDescriptorType = true, /* VK_EXT_non_seamless_cube_map */ .nonSeamlessCubeMap = true, /* VK_EXT_pipeline_protected_access */ .pipelineProtectedAccess = true, /* VK_EXT_pipeline_robustness */ .pipelineRobustness = true, /* VK_EXT_primitive_topology_list_restart */ .primitiveTopologyListRestart = true, .primitiveTopologyPatchListRestart = false, /* VK_EXT_primitives_generated_query */ .primitivesGeneratedQuery = false, .primitivesGeneratedQueryWithNonZeroStreams = false, .primitivesGeneratedQueryWithRasterizerDiscard = false, /* VK_EXT_provoking_vertex */ .provokingVertexLast = true, .transformFeedbackPreservesProvokingVertex = true, /* VK_EXT_robustness2 */ .robustBufferAccess2 = true, .robustImageAccess2 = true, .nullDescriptor = true, /* VK_EXT_shader_image_atomic_int64 */ .shaderImageInt64Atomics = false, .sparseImageInt64Atomics = false, /* VK_EXT_shader_module_identifier */ .shaderModuleIdentifier = true, /* VK_EXT_shader_object */ .shaderObject = true, /* VK_EXT_shader_replicated_composites */ .shaderReplicatedComposites = true, /* VK_KHR_shader_subgroup_uniform_control_flow */ .shaderSubgroupUniformControlFlow = true, /* VK_EXT_texel_buffer_alignment */ .texelBufferAlignment = true, /* VK_EXT_transform_feedback */ .transformFeedback = true, .geometryStreams = true, /* VK_EXT_vertex_input_dynamic_state */ .vertexInputDynamicState = true, /* VK_EXT_ycbcr_2plane_444_formats */ .ycbcr2plane444Formats = false, /* VK_EXT_ycbcr_image_arrays */ .ycbcrImageArrays = false, /* VK_KHR_shader_relaxed_extended_instruction */ .shaderRelaxedExtendedInstruction = true, }; } static void hk_get_device_properties(const struct agx_device *dev, const struct hk_instance *instance, struct vk_properties *properties) { const VkSampleCountFlagBits sample_counts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT; uint64_t os_page_size = 16384; os_get_page_size(&os_page_size); *properties = (struct vk_properties){ .apiVersion = hk_get_vk_version(), .driverVersion = vk_get_driver_version(), .vendorID = instance->force_vk_vendor ?: VK_VENDOR_ID_MESA, .deviceID = 0, .deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, /* Vulkan 1.0 limits */ .maxImageDimension1D = 16384, .maxImageDimension2D = 16384, .maxImageDimension3D = 16384, .maxImageDimensionCube = 16384, .maxImageArrayLayers = 2048, .maxTexelBufferElements = AGX_TEXTURE_BUFFER_MAX_SIZE, .maxUniformBufferRange = 65536, .maxStorageBufferRange = UINT32_MAX, .maxPushConstantsSize = HK_MAX_PUSH_SIZE, .maxMemoryAllocationCount = 4096, .maxSamplerAllocationCount = 4000, .bufferImageGranularity = 0x400, .sparseAddressSpaceSize = HK_SPARSE_ADDR_SPACE_SIZE, .maxBoundDescriptorSets = HK_MAX_SETS, .maxPerStageDescriptorSamplers = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorUniformBuffers = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorStorageBuffers = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorSampledImages = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorStorageImages = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorInputAttachments = HK_MAX_DESCRIPTORS, .maxPerStageResources = UINT32_MAX, .maxDescriptorSetSamplers = HK_MAX_DESCRIPTORS, .maxDescriptorSetUniformBuffers = HK_MAX_DESCRIPTORS, .maxDescriptorSetUniformBuffersDynamic = HK_MAX_DYNAMIC_BUFFERS / 2, .maxDescriptorSetStorageBuffers = HK_MAX_DESCRIPTORS, .maxDescriptorSetStorageBuffersDynamic = HK_MAX_DYNAMIC_BUFFERS / 2, .maxDescriptorSetSampledImages = HK_MAX_DESCRIPTORS, .maxDescriptorSetStorageImages = HK_MAX_DESCRIPTORS, .maxDescriptorSetInputAttachments = HK_MAX_DESCRIPTORS, .maxVertexInputAttributes = AGX_MAX_VBUFS, .maxVertexInputBindings = AGX_MAX_ATTRIBS, .maxVertexInputAttributeOffset = 65535, .maxVertexInputBindingStride = 2048, .maxVertexOutputComponents = 64, .maxGeometryShaderInvocations = 32, .maxGeometryInputComponents = 128, .maxGeometryOutputComponents = 128, .maxGeometryOutputVertices = 1024, .maxGeometryTotalOutputComponents = 1024, .maxTessellationGenerationLevel = 64, .maxTessellationPatchSize = 32, .maxTessellationControlPerVertexInputComponents = 128, .maxTessellationControlPerVertexOutputComponents = 128, .maxTessellationControlPerPatchOutputComponents = 120, .maxTessellationControlTotalOutputComponents = 4216, .maxTessellationEvaluationInputComponents = 128, .maxTessellationEvaluationOutputComponents = 128, .maxFragmentInputComponents = 64, .maxFragmentOutputAttachments = HK_MAX_RTS, .maxFragmentDualSrcAttachments = 1, .maxFragmentCombinedOutputResources = 16, .maxComputeSharedMemorySize = HK_MAX_SHARED_SIZE, .maxComputeWorkGroupCount = {0x7fffffff, 65535, 65535}, .maxComputeWorkGroupInvocations = 1024, .maxComputeWorkGroupSize = {1024, 1024, 64}, .subPixelPrecisionBits = 8, .subTexelPrecisionBits = 8, .mipmapPrecisionBits = 8, .maxDrawIndexedIndexValue = UINT32_MAX, .maxDrawIndirectCount = UINT16_MAX, .maxSamplerLodBias = 15, .maxSamplerAnisotropy = 16, .maxViewports = HK_MAX_VIEWPORTS, .maxViewportDimensions = {32768, 32768}, .viewportBoundsRange = {-65536, 65536}, .viewportSubPixelBits = 8, .minMemoryMapAlignment = os_page_size, .minTexelBufferOffsetAlignment = HK_MIN_TEXEL_BUFFER_ALIGNMENT, .minUniformBufferOffsetAlignment = HK_MIN_UBO_ALIGNMENT, .minStorageBufferOffsetAlignment = HK_MIN_SSBO_ALIGNMENT, .minTexelOffset = -8, .maxTexelOffset = 7, .minTexelGatherOffset = -8, .maxTexelGatherOffset = 7, .minInterpolationOffset = -0.5, .maxInterpolationOffset = 0.4375, .subPixelInterpolationOffsetBits = 4, .maxFramebufferHeight = 16384, .maxFramebufferWidth = 16384, .maxFramebufferLayers = 2048, .framebufferColorSampleCounts = sample_counts, .framebufferDepthSampleCounts = sample_counts, .framebufferNoAttachmentsSampleCounts = sample_counts, .framebufferStencilSampleCounts = sample_counts, .maxColorAttachments = HK_MAX_RTS, .sampledImageColorSampleCounts = sample_counts, .sampledImageIntegerSampleCounts = sample_counts, .sampledImageDepthSampleCounts = sample_counts, .sampledImageStencilSampleCounts = sample_counts, .storageImageSampleCounts = sample_counts, .maxSampleMaskWords = 1, .timestampComputeAndGraphics = false, .timestampPeriod = 1, .maxClipDistances = 8, .maxCullDistances = 8, .maxCombinedClipAndCullDistances = 8, .discreteQueuePriorities = 2, .pointSizeRange = {1.0, 512.f - 0.0625f}, .lineWidthRange = {1.0, 16.0f}, .pointSizeGranularity = 0.0625, .lineWidthGranularity = 1.0f / 16.0f, .strictLines = false, .standardSampleLocations = true, .optimalBufferCopyOffsetAlignment = 1, .optimalBufferCopyRowPitchAlignment = 1, .nonCoherentAtomSize = 64, /* Vulkan 1.0 sparse properties */ .sparseResidencyNonResidentStrict = false, .sparseResidencyAlignedMipSize = false, .sparseResidencyStandard2DBlockShape = false, .sparseResidencyStandard2DMultisampleBlockShape = false, .sparseResidencyStandard3DBlockShape = false, /* Vulkan 1.1 properties */ .subgroupSize = 32, .subgroupSupportedStages = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT, .subgroupSupportedOperations = VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_CLUSTERED_BIT | VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR, .subgroupQuadOperationsInAllStages = true, .pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, .maxMultiviewViewCount = HK_MAX_MULTIVIEW_VIEW_COUNT, .maxMultiviewInstanceIndex = UINT32_MAX, .maxPerSetDescriptors = UINT32_MAX, .maxMemoryAllocationSize = (1u << 31), /* Vulkan 1.2 properties */ .supportedDepthResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_AVERAGE_BIT | VK_RESOLVE_MODE_MIN_BIT | VK_RESOLVE_MODE_MAX_BIT, .supportedStencilResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_MIN_BIT | VK_RESOLVE_MODE_MAX_BIT, .independentResolveNone = true, .independentResolve = true, .driverID = VK_DRIVER_ID_MESA_HONEYKRISP, .conformanceVersion = (VkConformanceVersion){1, 3, 8, 3}, .denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, .roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, .shaderSignedZeroInfNanPreserveFloat16 = true, .shaderSignedZeroInfNanPreserveFloat32 = true, .shaderSignedZeroInfNanPreserveFloat64 = false, .shaderDenormPreserveFloat16 = true, .shaderDenormPreserveFloat32 = false, .shaderDenormPreserveFloat64 = false, .shaderDenormFlushToZeroFloat16 = false, .shaderDenormFlushToZeroFloat32 = true, .shaderDenormFlushToZeroFloat64 = false, .shaderRoundingModeRTEFloat16 = true, .shaderRoundingModeRTEFloat32 = true, .shaderRoundingModeRTEFloat64 = false, .shaderRoundingModeRTZFloat16 = false, .shaderRoundingModeRTZFloat32 = false, .shaderRoundingModeRTZFloat64 = false, .maxUpdateAfterBindDescriptorsInAllPools = UINT32_MAX, .shaderUniformBufferArrayNonUniformIndexingNative = true, .shaderSampledImageArrayNonUniformIndexingNative = true, .shaderStorageBufferArrayNonUniformIndexingNative = true, .shaderStorageImageArrayNonUniformIndexingNative = true, .shaderInputAttachmentArrayNonUniformIndexingNative = true, .robustBufferAccessUpdateAfterBind = true, .quadDivergentImplicitLod = false, .maxPerStageDescriptorUpdateAfterBindSamplers = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorUpdateAfterBindUniformBuffers = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorUpdateAfterBindStorageBuffers = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorUpdateAfterBindSampledImages = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorUpdateAfterBindStorageImages = HK_MAX_DESCRIPTORS, .maxPerStageDescriptorUpdateAfterBindInputAttachments = HK_MAX_DESCRIPTORS, .maxPerStageUpdateAfterBindResources = UINT32_MAX, .maxDescriptorSetUpdateAfterBindSamplers = HK_MAX_DESCRIPTORS, .maxDescriptorSetUpdateAfterBindUniformBuffers = HK_MAX_DESCRIPTORS, .maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = HK_MAX_DYNAMIC_BUFFERS / 2, .maxDescriptorSetUpdateAfterBindStorageBuffers = HK_MAX_DESCRIPTORS, .maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = HK_MAX_DYNAMIC_BUFFERS / 2, .maxDescriptorSetUpdateAfterBindSampledImages = HK_MAX_DESCRIPTORS, .maxDescriptorSetUpdateAfterBindStorageImages = HK_MAX_DESCRIPTORS, .maxDescriptorSetUpdateAfterBindInputAttachments = HK_MAX_DESCRIPTORS, .filterMinmaxSingleComponentFormats = false, .filterMinmaxImageComponentMapping = false, .maxTimelineSemaphoreValueDifference = UINT64_MAX, .framebufferIntegerColorSampleCounts = sample_counts, /* Vulkan 1.3 properties */ .minSubgroupSize = 32, .maxSubgroupSize = 32, .maxComputeWorkgroupSubgroups = 1024 / 32, .requiredSubgroupSizeStages = 0, .maxInlineUniformBlockSize = 1 << 16, .maxPerStageDescriptorInlineUniformBlocks = 32, .maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 32, .maxDescriptorSetInlineUniformBlocks = 6 * 32, .maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 6 * 32, .maxInlineUniformTotalSize = 1 << 16, .integerDotProduct4x8BitPackedUnsignedAccelerated = false, .integerDotProduct4x8BitPackedSignedAccelerated = false, .integerDotProduct4x8BitPackedMixedSignednessAccelerated = false, .storageTexelBufferOffsetAlignmentBytes = HK_MIN_TEXEL_BUFFER_ALIGNMENT, .storageTexelBufferOffsetSingleTexelAlignment = true, .uniformTexelBufferOffsetAlignmentBytes = HK_MIN_TEXEL_BUFFER_ALIGNMENT, .uniformTexelBufferOffsetSingleTexelAlignment = true, .maxBufferSize = HK_MAX_BUFFER_SIZE, /* VK_KHR_push_descriptor */ .maxPushDescriptors = HK_MAX_PUSH_DESCRIPTORS, /* VK_EXT_custom_border_color */ .maxCustomBorderColorSamplers = 4000, /* VK_EXT_extended_dynamic_state3 */ .dynamicPrimitiveTopologyUnrestricted = true, /* VK_EXT_graphics_pipeline_library */ .graphicsPipelineLibraryFastLinking = true, .graphicsPipelineLibraryIndependentInterpolationDecoration = true, /* VK_EXT_host_image_copy */ /* VK_KHR_line_rasterization */ .lineSubPixelPrecisionBits = 8, /* VK_KHR_maintenance5 */ .earlyFragmentMultisampleCoverageAfterSampleCounting = false, .earlyFragmentSampleMaskTestBeforeSampleCounting = true, .depthStencilSwizzleOneSupport = true, .polygonModePointSize = false, .nonStrictSinglePixelWideLinesUseParallelogram = false, .nonStrictWideLinesUseParallelogram = false, /* VK_KHR_maintenance6 */ .blockTexelViewCompatibleMultipleLayers = false, .maxCombinedImageSamplerDescriptorCount = 3, .fragmentShadingRateClampCombinerInputs = false, /* TODO */ /* VK_EXT_map_memory_placed */ .minPlacedMemoryMapAlignment = os_page_size, /* VK_EXT_multi_draw */ .maxMultiDrawCount = UINT16_MAX, /* VK_EXT_pipeline_robustness */ .defaultRobustnessStorageBuffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT, .defaultRobustnessUniformBuffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT, .defaultRobustnessVertexInputs = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT, .defaultRobustnessImages = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT, /* VK_EXT_physical_device_drm gets populated later */ /* VK_EXT_provoking_vertex */ .provokingVertexModePerPipeline = true, .transformFeedbackPreservesTriangleFanProvokingVertex = true, /* VK_EXT_robustness2 */ .robustStorageBufferAccessSizeAlignment = HK_SSBO_BOUNDS_CHECK_ALIGNMENT, .robustUniformBufferAccessSizeAlignment = HK_MIN_UBO_ALIGNMENT, /* VK_EXT_sample_locations */ .sampleLocationSampleCounts = sample_counts, .maxSampleLocationGridSize = (VkExtent2D){1, 1}, .sampleLocationCoordinateRange[0] = 0.0f, .sampleLocationCoordinateRange[1] = 0.9375f, .sampleLocationSubPixelBits = 4, .variableSampleLocations = false, /* VK_EXT_shader_object */ .shaderBinaryVersion = 0, /* VK_EXT_transform_feedback */ .maxTransformFeedbackStreams = 4, .maxTransformFeedbackBuffers = 4, .maxTransformFeedbackBufferSize = UINT32_MAX, .maxTransformFeedbackStreamDataSize = 2048, .maxTransformFeedbackBufferDataSize = 512, .maxTransformFeedbackBufferDataStride = 2048, .transformFeedbackQueries = true, .transformFeedbackStreamsLinesTriangles = false, .transformFeedbackRasterizationStreamSelect = false, .transformFeedbackDraw = false, /* VK_KHR_vertex_attribute_divisor */ .maxVertexAttribDivisor = UINT32_MAX, .supportsNonZeroFirstInstance = true, /* VK_KHR_fragment_shader_barycentric */ .triStripVertexOrderIndependentOfProvokingVertex = false, }; strncpy(properties->deviceName, dev->name, sizeof(properties->deviceName)); /* VK_EXT_shader_module_identifier */ static_assert(sizeof(vk_shaderModuleIdentifierAlgorithmUUID) == sizeof(properties->shaderModuleIdentifierAlgorithmUUID)); memcpy(properties->shaderModuleIdentifierAlgorithmUUID, vk_shaderModuleIdentifierAlgorithmUUID, sizeof(properties->shaderModuleIdentifierAlgorithmUUID)); const struct { uint16_t vendor_id; uint16_t device_id; uint8_t pad[12]; } dev_uuid = { .vendor_id = 0, .device_id = 0, }; static_assert(sizeof(dev_uuid) == VK_UUID_SIZE); memcpy(properties->deviceUUID, &dev_uuid, VK_UUID_SIZE); static_assert(sizeof(instance->driver_build_sha) >= VK_UUID_SIZE); memcpy(properties->driverUUID, instance->driver_build_sha, VK_UUID_SIZE); strncpy(properties->driverName, "Honeykrisp", VK_MAX_DRIVER_NAME_SIZE); snprintf(properties->driverInfo, VK_MAX_DRIVER_INFO_SIZE, "Mesa " PACKAGE_VERSION MESA_GIT_SHA1); /* We don't use the layouts ATM so just report all layouts from * extensions that we support as compatible. */ static const VkImageLayout supported_layouts[] = { VK_IMAGE_LAYOUT_GENERAL, /* required by spec */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, // VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT, }; properties->pCopySrcLayouts = (VkImageLayout *)supported_layouts; properties->copySrcLayoutCount = ARRAY_SIZE(supported_layouts); properties->pCopyDstLayouts = (VkImageLayout *)supported_layouts; properties->copyDstLayoutCount = ARRAY_SIZE(supported_layouts); /* We're a UMR so we can always map every kind of memory */ properties->identicalMemoryTypeRequirements = true; { struct mesa_sha1 sha1_ctx; uint8_t sha1[20]; _mesa_sha1_init(&sha1_ctx); /* Make sure we don't match with other vendors */ const char *driver = "honeykrisp-v1"; _mesa_sha1_update(&sha1_ctx, driver, strlen(driver)); _mesa_sha1_final(&sha1_ctx, sha1); memcpy(properties->optimalTilingLayoutUUID, sha1, VK_UUID_SIZE); } } static void hk_physical_device_init_pipeline_cache(struct hk_physical_device *pdev) { struct hk_instance *instance = hk_physical_device_instance(pdev); struct mesa_sha1 sha_ctx; _mesa_sha1_init(&sha_ctx); _mesa_sha1_update(&sha_ctx, instance->driver_build_sha, sizeof(instance->driver_build_sha)); const uint64_t compiler_flags = hk_physical_device_compiler_flags(pdev); _mesa_sha1_update(&sha_ctx, &compiler_flags, sizeof(compiler_flags)); unsigned char sha[SHA1_DIGEST_LENGTH]; _mesa_sha1_final(&sha_ctx, sha); static_assert(SHA1_DIGEST_LENGTH >= VK_UUID_SIZE); memcpy(pdev->vk.properties.pipelineCacheUUID, sha, VK_UUID_SIZE); memcpy(pdev->vk.properties.shaderBinaryUUID, sha, VK_UUID_SIZE); #ifdef ENABLE_SHADER_CACHE char renderer[10]; ASSERTED int len = snprintf(renderer, sizeof(renderer), "hk_g13g_"); assert(len == sizeof(renderer) - 2); char timestamp[41]; _mesa_sha1_format(timestamp, instance->driver_build_sha); const uint64_t driver_flags = hk_physical_device_compiler_flags(pdev); pdev->vk.disk_cache = disk_cache_create(renderer, timestamp, driver_flags); #endif } static void hk_physical_device_free_disk_cache(struct hk_physical_device *pdev) { #ifdef ENABLE_SHADER_CACHE if (pdev->vk.disk_cache) { disk_cache_destroy(pdev->vk.disk_cache); pdev->vk.disk_cache = NULL; } #else assert(pdev->vk.disk_cache == NULL); #endif } static uint64_t hk_get_sysmem_heap_size(void) { uint64_t sysmem_size_B = 0; if (!os_get_total_physical_memory(&sysmem_size_B)) return 0; /* Use 3/4 of total size to avoid swapping */ return ROUND_DOWN_TO(sysmem_size_B * 3 / 4, 1 << 20); } static uint64_t hk_get_sysmem_heap_available(struct hk_physical_device *pdev) { uint64_t sysmem_size_B = 0; if (!os_get_available_system_memory(&sysmem_size_B)) { vk_loge(VK_LOG_OBJS(pdev), "Failed to query available system memory"); return 0; } /* Use 3/4 of available to avoid swapping */ return ROUND_DOWN_TO(sysmem_size_B * 3 / 4, 1 << 20); } VkResult hk_create_drm_physical_device(struct vk_instance *_instance, drmDevicePtr drm_device, struct vk_physical_device **pdev_out) { struct hk_instance *instance = (struct hk_instance *)_instance; VkResult result; /* Blanket refusal to probe due to unstable UAPI. */ return VK_ERROR_INCOMPATIBLE_DRIVER; if (!(drm_device->available_nodes & (1 << DRM_NODE_RENDER)) || drm_device->bustype != DRM_BUS_PLATFORM) return VK_ERROR_INCOMPATIBLE_DRIVER; const char *path = drm_device->nodes[DRM_NODE_RENDER]; int fd = open(path, O_RDWR | O_CLOEXEC); if (fd < 0) { return vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER, "failed to open device %s", path); } drmVersionPtr version = drmGetVersion(fd); if (!version) { result = vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER, "failed to query kernel driver version for device %s", path); goto fail_fd; } bool is_asahi = (strcmp(version->name, "asahi") == 0); is_asahi |= strcmp(version->name, "virtio_gpu") == 0; drmFreeVersion(version); if (!is_asahi) { result = vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER, "device %s does not use the asahi kernel driver", path); goto fail_fd; } struct stat st; if (stat(drm_device->nodes[DRM_NODE_RENDER], &st)) { result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED, "fstat() failed on %s: %m", drm_device->nodes[DRM_NODE_RENDER]); goto fail_fd; } const dev_t render_dev = st.st_rdev; struct hk_physical_device *pdev = vk_zalloc(&instance->vk.alloc, sizeof(*pdev), 8, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pdev == NULL) { result = vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY); goto fail_fd; } /* TODO: we're render-only, should we be reporting displays anyway in * KHR_display? */ pdev->master_fd = -1; #if 0 if (instance->vk.enabled_extensions.KHR_display) { int master_fd = open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC); if (master_fd >= 0) { struct stat st; if (!stat(drm_device->nodes[DRM_NODE_PRIMARY], &st)) { pdev->master_fd = master_fd; properties.drmHasPrimary = true; properties.drmPrimaryMajor = major(st.st_rdev); properties.drmPrimaryMinor = minor(st.st_rdev); } } } #endif pdev->render_dev = render_dev; pdev->dev.fd = fd; if (!agx_open_device(NULL, &pdev->dev)) { result = vk_error(instance, VK_ERROR_UNKNOWN); goto fail_pdev_alloc; } struct vk_physical_device_dispatch_table dispatch_table; vk_physical_device_dispatch_table_from_entrypoints( &dispatch_table, &hk_physical_device_entrypoints, true); vk_physical_device_dispatch_table_from_entrypoints( &dispatch_table, &wsi_physical_device_entrypoints, false); struct vk_device_extension_table supported_extensions; hk_get_device_extensions(instance, &supported_extensions); struct vk_features supported_features; hk_get_device_features(&supported_extensions, &supported_features); struct vk_properties properties; hk_get_device_properties(&pdev->dev, instance, &properties); properties.drmHasRender = true; properties.drmRenderMajor = major(render_dev); properties.drmRenderMinor = minor(render_dev); result = vk_physical_device_init(&pdev->vk, &instance->vk, &supported_extensions, &supported_features, &properties, &dispatch_table); if (result != VK_SUCCESS) goto fail_agx_device; hk_physical_device_init_pipeline_cache(pdev); uint64_t sysmem_size_B = hk_get_sysmem_heap_size(); if (sysmem_size_B == 0) { result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED, "Failed to query total system memory"); goto fail_disk_cache; } uint32_t sysmem_heap_idx = pdev->mem_heap_count++; pdev->mem_heaps[sysmem_heap_idx] = (struct hk_memory_heap){ .size = sysmem_size_B, .flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, .available = hk_get_sysmem_heap_available, }; pdev->mem_types[pdev->mem_type_count++] = (VkMemoryType){ .propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, .heapIndex = sysmem_heap_idx, }; assert(pdev->mem_heap_count <= ARRAY_SIZE(pdev->mem_heaps)); assert(pdev->mem_type_count <= ARRAY_SIZE(pdev->mem_types)); /* TODO: VK_QUEUE_SPARSE_BINDING_BIT*/ pdev->queue_families[pdev->queue_family_count++] = (struct hk_queue_family){ .queue_flags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT, .queue_count = 1, }; assert(pdev->queue_family_count <= ARRAY_SIZE(pdev->queue_families)); unsigned st_idx = 0; pdev->syncobj_sync_type = vk_drm_syncobj_get_type(fd); pdev->sync_types[st_idx++] = &pdev->syncobj_sync_type; pdev->sync_types[st_idx++] = NULL; assert(st_idx <= ARRAY_SIZE(pdev->sync_types)); pdev->vk.supported_sync_types = pdev->sync_types; result = hk_init_wsi(pdev); if (result != VK_SUCCESS) goto fail_disk_cache; *pdev_out = &pdev->vk; return VK_SUCCESS; fail_disk_cache: hk_physical_device_free_disk_cache(pdev); vk_physical_device_finish(&pdev->vk); fail_agx_device: agx_close_device(&pdev->dev); fail_pdev_alloc: if (pdev->master_fd) close(pdev->master_fd); vk_free(&pdev->vk.instance->alloc, pdev); fail_fd: close(fd); return result; } void hk_physical_device_destroy(struct vk_physical_device *vk_pdev) { struct hk_physical_device *pdev = container_of(vk_pdev, struct hk_physical_device, vk); hk_finish_wsi(pdev); if (pdev->master_fd >= 0) close(pdev->master_fd); hk_physical_device_free_disk_cache(pdev); agx_close_device(&pdev->dev); vk_physical_device_finish(&pdev->vk); vk_free(&pdev->vk.instance->alloc, pdev); } VKAPI_ATTR void VKAPI_CALL hk_GetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) { VK_FROM_HANDLE(hk_physical_device, pdev, physicalDevice); pMemoryProperties->memoryProperties.memoryHeapCount = pdev->mem_heap_count; for (int i = 0; i < pdev->mem_heap_count; i++) { pMemoryProperties->memoryProperties.memoryHeaps[i] = (VkMemoryHeap){ .size = pdev->mem_heaps[i].size, .flags = pdev->mem_heaps[i].flags, }; } pMemoryProperties->memoryProperties.memoryTypeCount = pdev->mem_type_count; for (int i = 0; i < pdev->mem_type_count; i++) { pMemoryProperties->memoryProperties.memoryTypes[i] = pdev->mem_types[i]; } vk_foreach_struct(ext, pMemoryProperties->pNext) { switch (ext->sType) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: { VkPhysicalDeviceMemoryBudgetPropertiesEXT *p = (void *)ext; for (unsigned i = 0; i < pdev->mem_heap_count; i++) { const struct hk_memory_heap *heap = &pdev->mem_heaps[i]; uint64_t used = p_atomic_read(&heap->used); /* From the Vulkan 1.3.278 spec: * * "heapUsage is an array of VK_MAX_MEMORY_HEAPS VkDeviceSize * values in which memory usages are returned, with one element * for each memory heap. A heap’s usage is an estimate of how * much memory the process is currently using in that heap." * * TODO: Include internal allocations? */ p->heapUsage[i] = used; uint64_t available = heap->size; if (heap->available) available = heap->available(pdev); /* From the Vulkan 1.3.278 spec: * * "heapBudget is an array of VK_MAX_MEMORY_HEAPS VkDeviceSize * values in which memory budgets are returned, with one * element for each memory heap. A heap’s budget is a rough * estimate of how much memory the process can allocate from * that heap before allocations may fail or cause performance * degradation. The budget includes any currently allocated * device memory." * * and * * "The heapBudget value must be less than or equal to * VkMemoryHeap::size for each heap." * * available (queried above) is the total amount free memory * system-wide and does not include our allocations so we need * to add that in. */ uint64_t budget = MIN2(available + used, heap->size); /* Set the budget at 90% of available to avoid thrashing */ p->heapBudget[i] = ROUND_DOWN_TO(budget * 9 / 10, 1 << 20); } /* From the Vulkan 1.3.278 spec: * * "The heapBudget and heapUsage values must be zero for array * elements greater than or equal to * VkPhysicalDeviceMemoryProperties::memoryHeapCount. The * heapBudget value must be non-zero for array elements less than * VkPhysicalDeviceMemoryProperties::memoryHeapCount." */ for (unsigned i = pdev->mem_heap_count; i < VK_MAX_MEMORY_HEAPS; i++) { p->heapBudget[i] = 0u; p->heapUsage[i] = 0u; } break; } default: vk_debug_ignored_stype(ext->sType); break; } } } VKAPI_ATTR void VKAPI_CALL hk_GetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) { VK_FROM_HANDLE(hk_physical_device, pdev, physicalDevice); VK_OUTARRAY_MAKE_TYPED(VkQueueFamilyProperties2, out, pQueueFamilyProperties, pQueueFamilyPropertyCount); for (uint8_t i = 0; i < pdev->queue_family_count; i++) { const struct hk_queue_family *queue_family = &pdev->queue_families[i]; vk_outarray_append_typed(VkQueueFamilyProperties2, &out, p) { p->queueFamilyProperties.queueFlags = queue_family->queue_flags; p->queueFamilyProperties.queueCount = queue_family->queue_count; p->queueFamilyProperties.timestampValidBits = 0; // TODO 64; p->queueFamilyProperties.minImageTransferGranularity = (VkExtent3D){1, 1, 1}; vk_foreach_struct(ext, p->pNext) { switch (ext->sType) { case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: { VkQueueFamilyGlobalPriorityPropertiesKHR *props = (void *)ext; /* TODO: support multiple priorities */ props->priorityCount = 1; props->priorities[0] = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT; break; } default: break; } } } } } static const VkTimeDomainKHR hk_time_domains[] = { VK_TIME_DOMAIN_DEVICE_KHR, VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, #ifdef CLOCK_MONOTONIC_RAW VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, #endif }; VKAPI_ATTR VkResult VKAPI_CALL hk_GetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains) { VK_OUTARRAY_MAKE_TYPED(VkTimeDomainKHR, out, pTimeDomains, pTimeDomainCount); for (int d = 0; d < ARRAY_SIZE(hk_time_domains); d++) { vk_outarray_append_typed(VkTimeDomainKHR, &out, i) { *i = hk_time_domains[d]; } } return vk_outarray_status(&out); } VKAPI_ATTR void VKAPI_CALL hk_GetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties) { VK_FROM_HANDLE(hk_physical_device, pdev, physicalDevice); if (samples & pdev->vk.properties.sampleLocationSampleCounts) { pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){1, 1}; } else { pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){0, 0}; } }