return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetSwapchainGrallocUsageANDROID(VkDevice device_h,
VkFormat format,
VkImageUsageFlags imageUsage,
}
#if ANDROID_API_LEVEL >= 26
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetSwapchainGrallocUsage2ANDROID(VkDevice device_h,
VkFormat format,
VkImageUsageFlags imageUsage,
}
#endif
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AcquireImageANDROID(VkDevice device,
VkImage image_h,
int nativeFenceFd,
ops->teardown(cmd, cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBlitImage(VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
ops->teardown(cmd, cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdCopyBufferToImage(VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
ops->teardown(cmd, cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
ops->teardown(cmd, cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdCopyImage(VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
ops->teardown(cmd, cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdCopyBuffer(VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdUpdateBuffer(VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
copy_buffer(cmd, tu_buffer_iova(buffer) + dstOffset, tmp.iova, dataSize, 4);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdFillBuffer(VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
ops->teardown(cmd, cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdResolveImage(VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
ops->teardown(cmd, cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdClearColorImage(VkCommandBuffer commandBuffer,
VkImage image_h,
VkImageLayout imageLayout,
clear_image(cmd, image, (const VkClearValue*) pColor, pRanges + i, VK_IMAGE_ASPECT_COLOR_BIT);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
VkImage image_h,
VkImageLayout imageLayout,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdClearAttachments(VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment *pAttachments,
return cmd_buffer->record_result;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AllocateCommandBuffers(VkDevice _device,
const VkCommandBufferAllocateInfo *pAllocateInfo,
VkCommandBuffer *pCommandBuffers)
return result;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_FreeCommandBuffers(VkDevice device,
VkCommandPool commandPool,
uint32_t commandBufferCount,
}
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ResetCommandBuffer(VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags)
{
cache->pending_flush_bits = TU_CMD_FLAG_ALL_INVALIDATE;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_BeginCommandBuffer(VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo *pBeginInfo)
{
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBindVertexBuffers(VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
pBuffers, pOffsets, NULL, NULL);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBindIndexBuffer(VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
cmd->state.index_size = index_size;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBindDescriptorSets(VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout _layout,
}
}
-void tu_CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout _layout,
- uint32_t _set,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet *pDescriptorWrites)
+VKAPI_ATTR void VKAPI_CALL
+tu_CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout _layout,
+ uint32_t _set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet *pDescriptorWrites)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
TU_FROM_HANDLE(tu_pipeline_layout, pipe_layout, _layout);
0, NULL);
}
-void tu_CmdPushDescriptorSetWithTemplateKHR(
- VkCommandBuffer commandBuffer,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- VkPipelineLayout _layout,
- uint32_t _set,
- const void* pData)
+VKAPI_ATTR void VKAPI_CALL
+tu_CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout _layout,
+ uint32_t _set,
+ const void* pData)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
TU_FROM_HANDLE(tu_pipeline_layout, pipe_layout, _layout);
0, NULL);
}
-void tu_CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer *pBuffers,
- const VkDeviceSize *pOffsets,
- const VkDeviceSize *pSizes)
+VKAPI_ATTR void VKAPI_CALL
+tu_CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer *pBuffers,
+ const VkDeviceSize *pOffsets,
+ const VkDeviceSize *pSizes)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
struct tu_cs *cs = &cmd->draw_cs;
tu_cond_exec_end(cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
tu_cond_exec_end(cs);
}
-void tu_CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer *pCounterBuffers,
- const VkDeviceSize *pCounterBufferOffsets)
+VKAPI_ATTR void VKAPI_CALL
+tu_CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer *pCounterBuffers,
+ const VkDeviceSize *pCounterBufferOffsets)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
struct tu_cs *cs = &cmd->draw_cs;
cmd->state.xfb_used = true;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdPushConstants(VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
cache->pending_flush_bits &= ~TU_CMD_FLAG_ALL_FLUSH;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_EndCommandBuffer(VkCommandBuffer commandBuffer)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
return cs;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBindPipeline(VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline _pipeline)
cmd->state.dirty |= TU_CMD_DIRTY_RB_DEPTH_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetViewport(VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
tu6_emit_viewport(&cs, cmd->state.viewport, cmd->state.max_viewport);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetScissor(VkCommandBuffer commandBuffer,
uint32_t firstScissor,
uint32_t scissorCount,
tu6_emit_scissor(&cs, cmd->state.scissor, cmd->state.max_scissor);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
cmd->state.dirty |= TU_CMD_DIRTY_GRAS_SU_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetDepthBias(VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
tu6_emit_depth_bias(&cs, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetBlendConstants(VkCommandBuffer commandBuffer,
const float blendConstants[4])
{
tu_cs_emit_array(&cs, (const uint32_t *) blendConstants, 4);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetDepthBounds(VkCommandBuffer commandBuffer,
float minDepthBounds,
float maxDepthBounds)
*value = (*value & 0xff) | (mask & 0xff) << 8;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t compareMask)
tu_cs_emit_regs(&cs, A6XX_RB_STENCILMASK(.dword = cmd->state.dynamic_stencil_mask));
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t writeMask)
cmd->state.dirty |= TU_CMD_DIRTY_LRZ;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetStencilReference(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t reference)
tu_cs_emit_regs(&cs, A6XX_RB_STENCILREF(.dword = cmd->state.dynamic_stencil_ref));
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
tu6_emit_sample_locations(&cs, pSampleLocationsInfo);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
cmd->state.dirty |= TU_CMD_DIRTY_GRAS_SU_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
cmd->state.dirty |= TU_CMD_DIRTY_GRAS_SU_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
VkPrimitiveTopology primitiveTopology)
{
cmd->state.primtype = tu6_primtype(primitiveTopology);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
uint32_t viewportCount,
const VkViewport* pViewports)
tu_CmdSetViewport(commandBuffer, 0, viewportCount, pViewports);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,
uint32_t scissorCount,
const VkRect2D* pScissors)
tu_CmdSetScissor(commandBuffer, 0, scissorCount, pScissors);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 depthTestEnable)
{
cmd->state.dirty |= TU_CMD_DIRTY_RB_DEPTH_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 depthWriteEnable)
{
cmd->state.dirty |= TU_CMD_DIRTY_RB_DEPTH_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
VkCompareOp depthCompareOp)
{
cmd->state.dirty |= TU_CMD_DIRTY_RB_DEPTH_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 depthBoundsTestEnable)
{
cmd->state.dirty |= TU_CMD_DIRTY_RB_DEPTH_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 stencilTestEnable)
{
cmd->state.dirty |= TU_CMD_DIRTY_RB_STENCIL_CNTL;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
VkStencilOp failOp,
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdExecuteCommands(VkCommandBuffer commandBuffer,
uint32_t commandBufferCount,
const VkCommandBuffer *pCmdBuffers)
}
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateCommandPool(VkDevice _device,
const VkCommandPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyCommandPool(VkDevice _device,
VkCommandPool commandPool,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, pool);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ResetCommandPool(VkDevice device,
VkCommandPool commandPool,
VkCommandPoolResetFlags flags)
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_TrimCommandPool(VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags)
tu_flush_for_access(cache, src_flags, dst_flags);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBeginRenderPass2(VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo *pRenderPassBegin,
const VkSubpassBeginInfo *pSubpassBeginInfo)
tu_set_input_attachments(cmd, cmd->state.subpass);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdNextSubpass2(VkCommandBuffer commandBuffer,
const VkSubpassBeginInfo *pSubpassBeginInfo,
const VkSubpassEndInfo *pSubpassEndInfo)
return (struct tu_draw_state) {entry.bo->iova + entry.offset, entry.size / 4};
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDraw(VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
tu_cs_emit(cs, vertexCount);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDrawIndexed(VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
cmd->state.renderpass_cache.pending_flush_bits &= ~TU_CMD_FLAG_WAIT_FOR_ME;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDrawIndirect(VkCommandBuffer commandBuffer,
VkBuffer _buffer,
VkDeviceSize offset,
tu_cs_emit(cs, stride);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer,
VkBuffer _buffer,
VkDeviceSize offset,
tu_cs_emit(cs, stride);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDrawIndirectCount(VkCommandBuffer commandBuffer,
VkBuffer _buffer,
VkDeviceSize offset,
tu_cs_emit(cs, stride);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer,
VkBuffer _buffer,
VkDeviceSize offset,
tu_cs_emit(cs, stride);
}
-void tu_CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
- uint32_t instanceCount,
- uint32_t firstInstance,
- VkBuffer _counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset,
- uint32_t vertexStride)
+VKAPI_ATTR void VKAPI_CALL
+tu_CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
+ uint32_t instanceCount,
+ uint32_t firstInstance,
+ VkBuffer _counterBuffer,
+ VkDeviceSize counterBufferOffset,
+ uint32_t counterOffset,
+ uint32_t vertexStride)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
TU_FROM_HANDLE(tu_buffer, buf, _counterBuffer);
tu_cs_emit_wfi(cs);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDispatchBase(VkCommandBuffer commandBuffer,
uint32_t base_x,
uint32_t base_y,
tu_dispatch(cmd_buffer, &info);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDispatch(VkCommandBuffer commandBuffer,
uint32_t x,
uint32_t y,
tu_CmdDispatchBase(commandBuffer, 0, 0, 0, x, y, z);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdDispatchIndirect(VkCommandBuffer commandBuffer,
VkBuffer _buffer,
VkDeviceSize offset)
tu_dispatch(cmd_buffer, &info);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdEndRenderPass2(VkCommandBuffer commandBuffer,
const VkSubpassEndInfoKHR *pSubpassEndInfo)
{
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdPipelineBarrier(VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetEvent(VkCommandBuffer commandBuffer,
VkEvent _event,
VkPipelineStageFlags stageMask)
write_event(cmd, event, stageMask, 1);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdResetEvent(VkCommandBuffer commandBuffer,
VkEvent _event,
VkPipelineStageFlags stageMask)
write_event(cmd, event, stageMask, 0);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdWaitEvents(VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent *pEvents,
imageMemoryBarrierCount, pImageMemoryBarriers, &info);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
{
/* No-op */
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer,
const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
{
tu_cs_emit_qw(cs, global_iova(cmd, predicate));
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
}
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDescriptorSetLayout(
VkDevice _device,
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyDescriptorSetLayout(VkDevice _device,
VkDescriptorSetLayout _set_layout,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, set_layout);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetDescriptorSetLayoutSupport(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
* just multiple descriptor set layouts pasted together.
*/
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreatePipelineLayout(VkDevice _device,
const VkPipelineLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyPipelineLayout(VkDevice _device,
VkPipelineLayout _pipelineLayout,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, NULL, set);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDescriptorPool(VkDevice _device,
const VkDescriptorPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return ret;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyDescriptorPool(VkDevice _device,
VkDescriptorPool _pool,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, pool);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ResetDescriptorPool(VkDevice _device,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AllocateDescriptorSets(VkDevice _device,
const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets)
return result;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_FreeDescriptorSets(VkDevice _device,
VkDescriptorPool descriptorPool,
uint32_t count,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_UpdateDescriptorSets(VkDevice _device,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet *pDescriptorWrites,
descriptorCopyCount, pDescriptorCopies);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDescriptorUpdateTemplate(
VkDevice _device,
const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyDescriptorUpdateTemplate(
VkDevice _device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_UpdateDescriptorSetWithTemplate(
VkDevice _device,
VkDescriptorSet descriptorSet,
tu_update_descriptor_set_with_template(device, set, descriptorUpdateTemplate, pData);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateSamplerYcbcrConversion(
VkDevice _device,
const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroySamplerYcbcrConversion(VkDevice _device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks *pAllocator)
#define TU_API_VERSION VK_MAKE_VERSION(1, 1, VK_HEADER_VERSION)
-VkResult tu_EnumerateInstanceVersion(uint32_t *pApiVersion)
+VKAPI_ATTR VkResult VKAPI_CALL
+tu_EnumerateInstanceVersion(uint32_t *pApiVersion)
{
*pApiVersion = TU_API_VERSION;
return VK_SUCCESS;
return tu_debug_options[id].string;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkInstance *pInstance)
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyInstance(VkInstance _instance,
const VkAllocationCallbacks *pAllocator)
{
vk_free(&instance->vk.alloc, instance);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_EnumeratePhysicalDevices(VkInstance _instance,
uint32_t *pPhysicalDeviceCount,
VkPhysicalDevice *pPhysicalDevices)
return vk_outarray_status(&out);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_EnumeratePhysicalDeviceGroups(
VkInstance _instance,
uint32_t *pPhysicalDeviceGroupCount,
return vk_outarray_status(&out);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2 *pFeatures)
{
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2 *pProperties)
{
.minImageTransferGranularity = { 1, 1, 1 },
};
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
return MIN2(heap_size, heap_used + heap_available);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice pdev,
VkPhysicalDeviceMemoryProperties2 *props2)
{
tu_drm_submitqueue_close(queue->device, queue->msm_queue_id);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDevice(VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return result;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyDevice(VkDevice _device, const VkAllocationCallbacks *pAllocator)
{
TU_FROM_HANDLE(tu_device, device, _device);
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_EnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
VkLayerProperties *pProperties)
{
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetDeviceQueue2(VkDevice _device,
const VkDeviceQueueInfo2 *pQueueInfo,
VkQueue *pQueue)
*pQueue = tu_queue_to_handle(queue);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_QueueWaitIdle(VkQueue _queue)
{
TU_FROM_HANDLE(tu_queue, queue, _queue);
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_DeviceWaitIdle(VkDevice _device)
{
TU_FROM_HANDLE(tu_device, device, _device);
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_EnumerateInstanceExtensionProperties(const char *pLayerName,
uint32_t *pPropertyCount,
VkExtensionProperties *pProperties)
&tu_instance_extensions_supported, pPropertyCount, pProperties);
}
-PFN_vkVoidFunction
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
tu_GetInstanceProcAddr(VkInstance _instance, const char *pName)
{
TU_FROM_HANDLE(tu_instance, instance, _instance);
return tu_GetInstanceProcAddr(instance, pName);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AllocateMemory(VkDevice _device,
const VkMemoryAllocateInfo *pAllocateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_FreeMemory(VkDevice _device,
VkDeviceMemory _mem,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, mem);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_MapMemory(VkDevice _device,
VkDeviceMemory _memory,
VkDeviceSize offset,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_UnmapMemory(VkDevice _device, VkDeviceMemory _memory)
{
/* TODO: unmap here instead of waiting for FreeMemory */
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_FlushMappedMemoryRanges(VkDevice _device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange *pMemoryRanges)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_InvalidateMappedMemoryRanges(VkDevice _device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange *pMemoryRanges)
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetBufferMemoryRequirements2(
VkDevice device,
const VkBufferMemoryRequirementsInfo2 *pInfo,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetImageMemoryRequirements2(VkDevice device,
const VkImageMemoryRequirementsInfo2 *pInfo,
VkMemoryRequirements2 *pMemoryRequirements)
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetImageSparseMemoryRequirements2(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2 *pInfo,
tu_stub();
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetDeviceMemoryCommitment(VkDevice device,
VkDeviceMemory memory,
VkDeviceSize *pCommittedMemoryInBytes)
*pCommittedMemoryInBytes = 0;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_BindBufferMemory2(VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo *pBindInfos)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_BindImageMemory2(VkDevice device,
uint32_t bindInfoCount,
const VkBindImageMemoryInfo *pBindInfos)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_QueueBindSparse(VkQueue _queue,
uint32_t bindInfoCount,
const VkBindSparseInfo *pBindInfo,
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateEvent(VkDevice _device,
const VkEventCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyEvent(VkDevice _device,
VkEvent _event,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, event);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetEventStatus(VkDevice _device, VkEvent _event)
{
TU_FROM_HANDLE(tu_event, event, _event);
return VK_EVENT_RESET;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_SetEvent(VkDevice _device, VkEvent _event)
{
TU_FROM_HANDLE(tu_event, event, _event);
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ResetEvent(VkDevice _device, VkEvent _event)
{
TU_FROM_HANDLE(tu_event, event, _event);
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateBuffer(VkDevice _device,
const VkBufferCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyBuffer(VkDevice _device,
VkBuffer _buffer,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, buffer);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateFramebuffer(VkDevice _device,
const VkFramebufferCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyFramebuffer(VkDevice _device,
VkFramebuffer _fb,
const VkAllocationCallbacks *pAllocator)
*/
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateSampler(VkDevice _device,
const VkSamplerCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroySampler(VkDevice _device,
VkSampler _sampler,
const VkAllocationCallbacks *pAllocator)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetMemoryFdKHR(VkDevice _device,
const VkMemoryGetFdInfoKHR *pGetFdInfo,
int *pFd)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetMemoryFdPropertiesKHR(VkDevice _device,
VkExternalMemoryHandleTypeFlagBits handleType,
int fd,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
pExternalFenceProperties->externalFenceFeatures = 0;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetDeviceGroupPeerMemoryFeatures(
VkDevice device,
uint32_t heapIndex,
VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;
}
-void tu_GetPhysicalDeviceMultisamplePropertiesEXT(
+VKAPI_ATTR void VKAPI_CALL
+tu_GetPhysicalDeviceMultisamplePropertiesEXT(
VkPhysicalDevice physicalDevice,
VkSampleCountFlagBits samples,
VkMultisamplePropertiesEXT* pMultisampleProperties)
return type_info->semaphoreType;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateSemaphore(VkDevice device,
const VkSemaphoreCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
timeline_value, pAllocator, (void**) pSemaphore);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroySemaphore(VkDevice device, VkSemaphore sem, const VkAllocationCallbacks *pAllocator)
{
TU_FROM_HANDLE(tu_syncobj, sync, sem);
sync_destroy(device, sync, pAllocator);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *info)
{
TU_FROM_HANDLE(tu_syncobj, sync, info->semaphore);
info->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, info->fd);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *info, int *pFd)
{
TU_FROM_HANDLE(tu_syncobj, sync, info->semaphore);
info->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, pFd);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
return result;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_QueueSubmit(VkQueue _queue,
uint32_t submitCount,
const VkSubmitInfo *pSubmits,
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateFence(VkDevice device,
const VkFenceCreateInfo *info,
const VkAllocationCallbacks *pAllocator,
pAllocator, (void**) pFence);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
{
TU_FROM_HANDLE(tu_syncobj, sync, fence);
sync_destroy(device, sync, pAllocator);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *info)
{
TU_FROM_HANDLE(tu_syncobj, sync, info->fence);
info->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, info->fd);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *info, int *pFd)
{
TU_FROM_HANDLE(tu_syncobj, sync, info->fence);
return (current_time + timeout);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_WaitForFences(VkDevice _device,
uint32_t fenceCount,
const VkFence *pFences,
return drm_syncobj_wait(device, handles, fenceCount, absolute_timeout(timeout), waitAll);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ResetFences(VkDevice _device, uint32_t fenceCount, const VkFence *pFences)
{
TU_FROM_HANDLE(tu_device, device, _device);
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetFenceStatus(VkDevice _device, VkFence _fence)
{
TU_FROM_HANDLE(tu_device, device, _device);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetSemaphoreCounterValue(VkDevice _device,
- VkSemaphore _semaphore,
- uint64_t* pValue)
+ VkSemaphore _semaphore,
+ uint64_t* pValue)
{
TU_FROM_HANDLE(tu_device, device, _device);
TU_FROM_HANDLE(tu_syncobj, semaphore, _semaphore);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_WaitSemaphores(VkDevice _device,
const VkSemaphoreWaitInfoKHR* pWaitInfo,
uint64_t timeout)
return tu_wait_timelines(device, pWaitInfo, absolute_timeout(timeout));
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_SignalSemaphore(VkDevice _device,
const VkSemaphoreSignalInfoKHR* pSignalInfo)
{
#ifdef ANDROID
#include <libsync.h>
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_QueueSignalReleaseImageANDROID(VkQueue _queue,
uint32_t waitSemaphoreCount,
const VkSemaphore *pWaitSemaphores,
out_properties->bufferFeatures = buffer;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceFormatProperties2(
VkPhysicalDevice physicalDevice,
VkFormat format,
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2 *base_info,
return result;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
*pPropertyCount = 0;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
return true;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateImage(VkDevice _device,
const VkImageCreateInfo *pCreateInfo,
const VkAllocationCallbacks *alloc,
return vk_error(device->instance, VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyImage(VkDevice _device,
VkImage _image,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, image);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetImageSubresourceLayout(VkDevice _device,
VkImage _image,
const VkImageSubresource *pSubresource,
}
}
-VkResult tu_GetImageDrmFormatModifierPropertiesEXT(
+VKAPI_ATTR VkResult VKAPI_CALL
+tu_GetImageDrmFormatModifierPropertiesEXT(
VkDevice device,
VkImage _image,
VkImageDrmFormatModifierPropertiesEXT* pProperties)
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateImageView(VkDevice _device,
const VkImageViewCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyImageView(VkDevice _device,
VkImageView _iview,
const VkAllocationCallbacks *pAllocator)
view->descriptor[5] = iova >> 32;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateBufferView(VkDevice _device,
const VkBufferViewCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyBufferView(VkDevice _device,
VkBufferView bufferView,
const VkAllocationCallbacks *pAllocator)
return ret;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_QueueSubmit(VkQueue _queue,
uint32_t submitCount,
const VkSubmitInfo *pSubmits,
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ImportSemaphoreFdKHR(VkDevice _device,
const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
{
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetSemaphoreFdKHR(VkDevice _device,
const VkSemaphoreGetFdInfoKHR *pGetFdInfo,
int *pFd)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateSemaphore(VkDevice device,
const VkSemaphoreCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return sync_create(device, false, false, pAllocator, (void**) pSemaphore);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroySemaphore(VkDevice _device,
VkSemaphore semaphore,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, sync);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ImportFenceFdKHR(VkDevice _device,
const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
{
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetFenceFdKHR(VkDevice _device,
const VkFenceGetFdInfoKHR *pGetFdInfo,
int *pFd)
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateFence(VkDevice device,
const VkFenceCreateInfo *info,
const VkAllocationCallbacks *pAllocator,
pAllocator, (void**) pFence);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyFence(VkDevice _device, VkFence fence, const VkAllocationCallbacks *pAllocator)
{
TU_FROM_HANDLE(tu_device, device, _device);
vk_object_free(&device->vk, pAllocator, sync);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_WaitForFences(VkDevice _device,
uint32_t count,
const VkFence *pFences,
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ResetFences(VkDevice _device, uint32_t count, const VkFence *pFences)
{
for (uint32_t i = 0; i < count; i++) {
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetFenceStatus(VkDevice _device, VkFence _fence)
{
TU_FROM_HANDLE(tu_device, device, _device);
}
#ifdef ANDROID
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_QueueSignalReleaseImageANDROID(VkQueue _queue,
uint32_t waitSemaphoreCount,
const VkSemaphore *pWaitSemaphores,
#include "tu_entrypoints.h"
#include "vk_util.h"
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice pdev,
uint32_t *count,
VkQueueFamilyProperties *props)
props[i] = props2[i].queueFamilyProperties;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice pdev,
VkFormat format,
VkImageType type,
props[i] = props2[i].properties;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetImageSparseMemoryRequirements(VkDevice device,
VkImage image,
uint32_t *count,
return false;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateRenderPass2(VkDevice _device,
const VkRenderPassCreateInfo2KHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyRenderPass(VkDevice _device,
VkRenderPass _pass,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, pass);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetRenderAreaGranularity(VkDevice _device,
VkRenderPass renderPass,
VkExtent2D *pGranularity)
return result;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateGraphicsPipelines(VkDevice device,
VkPipelineCache pipelineCache,
uint32_t count,
return result;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateComputePipelines(VkDevice device,
VkPipelineCache pipelineCache,
uint32_t count,
return final_result;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyPipeline(VkDevice _device,
VkPipeline _pipeline,
const VkAllocationCallbacks *pAllocator)
&pipeline->executables, struct tu_pipeline_executable, index);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPipelineExecutablePropertiesKHR(
VkDevice _device,
const VkPipelineInfoKHR* pPipelineInfo,
return vk_outarray_status(&out);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPipelineExecutableStatisticsKHR(
VkDevice _device,
const VkPipelineExecutableInfoKHR* pExecutableInfo,
return true;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPipelineExecutableInternalRepresentationsKHR(
VkDevice _device,
const VkPipelineExecutableInfoKHR* pExecutableInfo,
}
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreatePipelineCache(VkDevice _device,
const VkPipelineCacheCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyPipelineCache(VkDevice _device,
VkPipelineCache _cache,
const VkAllocationCallbacks *pAllocator)
vk_object_free(&device->vk, pAllocator, cache);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPipelineCacheData(VkDevice _device,
VkPipelineCache _cache,
size_t *pDataSize,
}
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_MergePipelineCaches(VkDevice _device,
VkPipelineCache destCache,
uint32_t srcCacheCount,
((struct tu_perf_query_data *)b)->pass;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateQueryPool(VkDevice _device,
const VkQueryPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroyQueryPool(VkDevice _device,
VkQueryPool _pool,
const VkAllocationCallbacks *pAllocator)
return result;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetQueryPoolResults(VkDevice _device,
VkQueryPool queryPool,
uint32_t firstQuery,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdResetQueryPool(VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_ResetQueryPool(VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
tu6_emit_event_write(cmdbuf, cs, WRITE_PRIMITIVE_COUNTS);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBeginQuery(VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdEndQuery(VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query)
handle_multiview_queries(cmdbuf, pool, query);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
}
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_CmdWriteTimestamp(VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
handle_multiview_queries(cmd, pool, query);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
return vk_outarray_status(&out);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
VkPhysicalDevice physicalDevice,
const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
}
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AcquireProfilingLockKHR(VkDevice device,
const VkAcquireProfilingLockInfoKHR* pInfo)
{
return VK_SUCCESS;
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_ReleaseProfilingLockKHR(VkDevice device)
{
/* TODO. Probably there's something to do for kgsl. */
#include "wsi_common.h"
#include "drm-uapi/drm_fourcc.h"
-static VKAPI_PTR PFN_vkVoidFunction
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
tu_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName)
{
TU_FROM_HANDLE(tu_physical_device, pdevice, physicalDevice);
&physical_device->instance->vk.alloc);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroySurfaceKHR(VkInstance _instance,
VkSurfaceKHR _surface,
const VkAllocationCallbacks *pAllocator)
vk_free2(&instance->vk.alloc, pAllocator, surface);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
&device->wsi_device, queueFamilyIndex, surface, pSupported);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
pSurfaceCapabilities);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceSurfaceCapabilities2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
&device->wsi_device, pSurfaceInfo, pSurfaceCapabilities);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceSurfaceCapabilities2EXT(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
&device->wsi_device, surface, pSurfaceCapabilities);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t *pSurfaceFormatCount,
&device->wsi_device, surface, pSurfaceFormatCount, pSurfaceFormats);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceSurfaceFormats2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
pSurfaceFormats);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t *pPresentModeCount,
&device->wsi_device, surface, pPresentModeCount, pPresentModes);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateSwapchainKHR(VkDevice _device,
const VkSwapchainCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
pCreateInfo, alloc, pSwapchain);
}
-void
+VKAPI_ATTR void VKAPI_CALL
tu_DestroySwapchainKHR(VkDevice _device,
VkSwapchainKHR swapchain,
const VkAllocationCallbacks *pAllocator)
wsi_common_destroy_swapchain(_device, swapchain, alloc);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetSwapchainImagesKHR(VkDevice device,
VkSwapchainKHR swapchain,
uint32_t *pSwapchainImageCount,
pSwapchainImages);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AcquireNextImageKHR(VkDevice device,
VkSwapchainKHR swapchain,
uint64_t timeout,
return tu_AcquireNextImage2KHR(device, &acquire_info, pImageIndex);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AcquireNextImage2KHR(VkDevice _device,
const VkAcquireNextImageInfoKHR *pAcquireInfo,
uint32_t *pImageIndex)
return result;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_QueuePresentKHR(VkQueue _queue, const VkPresentInfoKHR *pPresentInfo)
{
TU_FROM_HANDLE(tu_queue, queue, _queue);
pPresentInfo);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetDeviceGroupPresentCapabilitiesKHR(
VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pCapabilities)
{
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetDeviceGroupSurfacePresentModesKHR(
VkDevice device,
VkSurfaceKHR surface,
return VK_SUCCESS;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t *pRectCount,
#include "util/debug.h"
#include "wsi_common_display.h"
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical_device,
uint32_t *property_count,
VkDisplayPropertiesKHR *properties)
properties);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physical_device,
uint32_t *property_count,
VkDisplayProperties2KHR *properties)
properties);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physical_device,
uint32_t *property_count,
properties);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetPhysicalDeviceDisplayPlaneProperties2KHR(
VkPhysicalDevice physical_device,
uint32_t *property_count,
properties);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physical_device,
uint32_t plane_index,
uint32_t *display_count,
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetDisplayModePropertiesKHR(VkPhysicalDevice physical_device,
VkDisplayKHR display,
uint32_t *property_count,
properties);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetDisplayModeProperties2KHR(VkPhysicalDevice physical_device,
VkDisplayKHR display,
uint32_t *property_count,
properties);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDisplayModeKHR(VkPhysicalDevice physical_device,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR *create_info,
mode);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physical_device,
VkDisplayModeKHR mode_khr,
uint32_t plane_index,
capabilities);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physical_device,
const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
VkDisplayPlaneCapabilities2KHR *capabilities)
capabilities);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateDisplayPlaneSurfaceKHR(
VkInstance _instance,
const VkDisplaySurfaceCreateInfoKHR *create_info,
create_info, surface);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_ReleaseDisplayEXT(VkPhysicalDevice physical_device,
VkDisplayKHR display)
{
}
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_AcquireXlibDisplayEXT(VkPhysicalDevice physical_device,
Display *dpy,
VkDisplayKHR display)
display);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetRandROutputDisplayEXT(VkPhysicalDevice physical_device,
Display *dpy,
RROutput output,
/* VK_EXT_display_control */
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_DisplayPowerControlEXT(VkDevice _device,
VkDisplayKHR display,
const VkDisplayPowerInfoEXT *display_power_info)
display_power_info);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_RegisterDeviceEventEXT(VkDevice _device,
const VkDeviceEventInfoEXT *device_event_info,
const VkAllocationCallbacks *allocator,
return ret;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_RegisterDisplayEventEXT(VkDevice _device,
VkDisplayKHR display,
const VkDisplayEventInfoEXT *display_event_info,
return ret;
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_GetSwapchainCounterEXT(VkDevice _device,
VkSwapchainKHR swapchain,
VkSurfaceCounterFlagBitsEXT flag_bits,
#include "wsi_common_wayland.h"
-VkBool32
+VKAPI_ATTR VkBool32 VKAPI_CALL
tu_GetPhysicalDeviceWaylandPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
display);
}
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
tu_CreateWaylandSurfaceKHR(VkInstance _instance,
const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
#include "wsi_common_x11.h"
#include "tu_private.h"
-VkBool32 tu_GetPhysicalDeviceXcbPresentationSupportKHR(
+VKAPI_ATTR VkBool32 VKAPI_CALL
+tu_GetPhysicalDeviceXcbPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
xcb_connection_t* connection,
connection, visual_id);
}
-VkBool32 tu_GetPhysicalDeviceXlibPresentationSupportKHR(
+VKAPI_ATTR VkBool32 VKAPI_CALL
+tu_GetPhysicalDeviceXlibPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
Display* dpy,
XGetXCBConnection(dpy), visualID);
}
-VkResult tu_CreateXcbSurfaceKHR(
+VKAPI_ATTR VkResult VKAPI_CALL
+tu_CreateXcbSurfaceKHR(
VkInstance _instance,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
return wsi_create_xcb_surface(alloc, pCreateInfo, pSurface);
}
-VkResult tu_CreateXlibSurfaceKHR(
+VKAPI_ATTR VkResult VKAPI_CALL
+tu_CreateXlibSurfaceKHR(
VkInstance _instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
projects / platform / upstream / mesa.git / commitdiff