radv: declare new extended dynamic states

[mesa.git] / src / amd / vulkan / radv_wsi_display.c

diff --git a/src/amd/vulkan/radv_wsi_display.c b/src/amd/vulkan/radv_wsi_display.c
index 048d992e1cf2adf0918515a5b3aca0e920f1b979..af2faab0994b47469d2de2a8d98c5dcd71404e24 100644 (file)
--- a/src/amd/vulkan/radv_wsi_display.c
+++ b/src/amd/vulkan/radv_wsi_display.c
@@ -32,9 +32,8 @@
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 #include <amdgpu.h>
-#include <amdgpu_drm.h>
+#include "drm-uapi/amdgpu_drm.h"
 #include "winsys/amdgpu/radv_amdgpu_winsys_public.h"
-#include "ac_llvm_util.h"
 #include "vk_format.h"
 #include "sid.h"
 #include "util/debug.h"
@@ -56,6 +55,20 @@ radv_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical_device,
                properties);
 }
 
+VkResult
+radv_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physical_device,
+                                            uint32_t *property_count,
+                                            VkDisplayProperties2KHR *properties)
+{
+       RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);
+
+       return wsi_display_get_physical_device_display_properties2(
+               physical_device,
+               &pdevice->wsi_device,
+               property_count,
+               properties);
+}
+
 VkResult
 radv_GetPhysicalDeviceDisplayPlanePropertiesKHR(
        VkPhysicalDevice physical_device,
@@ -71,6 +84,21 @@ radv_GetPhysicalDeviceDisplayPlanePropertiesKHR(
                properties);
 }
 
+VkResult
+radv_GetPhysicalDeviceDisplayPlaneProperties2KHR(
+       VkPhysicalDevice physical_device,
+       uint32_t *property_count,
+       VkDisplayPlaneProperties2KHR *properties)
+{
+       RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);
+
+       return wsi_display_get_physical_device_display_plane_properties2(
+               physical_device,
+               &pdevice->wsi_device,
+               property_count,
+               properties);
+}
+
 VkResult
 radv_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physical_device,
                                          uint32_t plane_index,
@@ -103,6 +131,21 @@ radv_GetDisplayModePropertiesKHR(VkPhysicalDevice physical_device,
                                                       properties);
 }
 
+VkResult
+radv_GetDisplayModeProperties2KHR(VkPhysicalDevice physical_device,
+                                  VkDisplayKHR display,
+                                  uint32_t *property_count,
+                                  VkDisplayModeProperties2KHR *properties)
+{
+       RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);
+
+       return wsi_display_get_display_mode_properties2(physical_device,
+                                                       &pdevice->wsi_device,
+                                                       display,
+                                                       property_count,
+                                                       properties);
+}
+
 VkResult
 radv_CreateDisplayModeKHR(VkPhysicalDevice physical_device,
                           VkDisplayKHR display,
@@ -135,6 +178,19 @@ radv_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physical_device,
                                                  capabilities);
 }
 
+VkResult
+radv_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physical_device,
+                                     const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
+                                     VkDisplayPlaneCapabilities2KHR *capabilities)
+{
+       RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);
+
+       return wsi_get_display_plane_capabilities2(physical_device,
+                                                  &pdevice->wsi_device,
+                                                  pDisplayPlaneInfo,
+                                                  capabilities);
+}
+
 VkResult
 radv_CreateDisplayPlaneSurfaceKHR(
        VkInstance _instance,
@@ -153,3 +209,141 @@ radv_CreateDisplayPlaneSurfaceKHR(
        return wsi_create_display_surface(_instance, alloc,
                                          create_info, surface);
 }
+
+VkResult
+radv_ReleaseDisplayEXT(VkPhysicalDevice physical_device,
+                      VkDisplayKHR     display)
+{
+       RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);
+
+       return wsi_release_display(physical_device,
+                                  &pdevice->wsi_device,
+                                  display);
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+VkResult
+radv_AcquireXlibDisplayEXT(VkPhysicalDevice     physical_device,
+                          Display              *dpy,
+                          VkDisplayKHR         display)
+{
+       RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);
+
+       return wsi_acquire_xlib_display(physical_device,
+                                       &pdevice->wsi_device,
+                                       dpy,
+                                       display);
+}
+
+VkResult
+radv_GetRandROutputDisplayEXT(VkPhysicalDevice  physical_device,
+                             Display           *dpy,
+                             RROutput          output,
+                             VkDisplayKHR      *display)
+{
+       RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);
+
+       return wsi_get_randr_output_display(physical_device,
+                                           &pdevice->wsi_device,
+                                           dpy,
+                                           output,
+                                           display);
+}
+#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
+
+/* VK_EXT_display_control */
+
+VkResult
+radv_DisplayPowerControlEXT(VkDevice                    _device,
+                           VkDisplayKHR                display,
+                           const VkDisplayPowerInfoEXT *display_power_info)
+{
+       RADV_FROM_HANDLE(radv_device, device, _device);
+
+       return wsi_display_power_control(_device,
+                                        &device->physical_device->wsi_device,
+                                        display,
+                                        display_power_info);
+}
+
+VkResult
+radv_RegisterDeviceEventEXT(VkDevice                    _device,
+                           const VkDeviceEventInfoEXT  *device_event_info,
+                           const VkAllocationCallbacks *allocator,
+                           VkFence                     *_fence)
+{
+       RADV_FROM_HANDLE(radv_device, device, _device);
+       struct radv_fence            *fence;
+       VkResult                     ret;
+
+       fence = vk_alloc2(&device->instance->alloc, allocator, sizeof (*fence),
+                         8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+       if (!fence)
+               return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+       fence->fence = NULL;
+       fence->syncobj = 0;
+       fence->temp_syncobj = 0;
+
+       ret = wsi_register_device_event(_device,
+                                       &device->physical_device->wsi_device,
+                                       device_event_info,
+                                       allocator,
+                                       &fence->fence_wsi);
+       if (ret == VK_SUCCESS)
+               *_fence = radv_fence_to_handle(fence);
+       else
+               vk_free2(&device->instance->alloc, allocator, fence);
+       return ret;
+}
+
+VkResult
+radv_RegisterDisplayEventEXT(VkDevice                           _device,
+                            VkDisplayKHR                       display,
+                            const VkDisplayEventInfoEXT        *display_event_info,
+                            const VkAllocationCallbacks        *allocator,
+                            VkFence                            *_fence)
+{
+       RADV_FROM_HANDLE(radv_device, device, _device);
+
+       struct radv_fence            *fence;
+       VkResult                     ret;
+
+       fence = vk_alloc2(&device->instance->alloc, allocator, sizeof (*fence),
+                         8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+       if (!fence)
+               return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+       fence->fence = NULL;
+       fence->syncobj = 0;
+       fence->temp_syncobj = 0;
+
+       ret = wsi_register_display_event(_device,
+                                        &device->physical_device->wsi_device,
+                                        display,
+                                        display_event_info,
+                                        allocator,
+                                        &(fence->fence_wsi));
+
+       if (ret == VK_SUCCESS)
+               *_fence = radv_fence_to_handle(fence);
+       else
+               vk_free2(&device->instance->alloc, allocator, fence);
+       return ret;
+}
+
+VkResult
+radv_GetSwapchainCounterEXT(VkDevice                    _device,
+                           VkSwapchainKHR              swapchain,
+                           VkSurfaceCounterFlagBitsEXT flag_bits,
+                           uint64_t                    *value)
+{
+       RADV_FROM_HANDLE(radv_device, device, _device);
+
+       return wsi_get_swapchain_counter(_device,
+                                        &device->physical_device->wsi_device,
+                                        swapchain,
+                                        flag_bits,
+                                        value);
+}
+