Import Mesa 18.3.2

1 files changed, 242 insertions, 12 deletions

diff --git a/lib/mesa/src/intel/vulkan/anv_wsi_display.c b/lib/mesa/src/intel/vulkan/anv_wsi_display.c
index 9f54d213e..3212c235b 100644
--- a/lib/mesa/src/intel/vulkan/anv_wsi_display.c
+++ b/lib/mesa/src/intel/vulkan/anv_wsi_display.c
@@ -22,12 +22,230 @@
 
 #include "anv_private.h"
 #include "wsi_common.h"
+#include "vk_format_info.h"
 #include "vk_util.h"
 #include "wsi_common_display.h"
 
+VkResult
+anv_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical_device,
+                                          uint32_t *property_count,
+                                          VkDisplayPropertiesKHR *properties)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_display_get_physical_device_display_properties(
+      physical_device,
+      &pdevice->wsi_device,
+      property_count,
+      properties);
+}
+
+VkResult
+anv_GetPhysicalDeviceDisplayProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayProperties2KHR*                    pProperties)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice);
+
+   return wsi_display_get_physical_device_display_properties2(
+      physicalDevice, &pdevice->wsi_device,
+      pPropertyCount, pProperties);
+}
+
+VkResult
+anv_GetPhysicalDeviceDisplayPlanePropertiesKHR(
+   VkPhysicalDevice physical_device,
+   uint32_t *property_count,
+   VkDisplayPlanePropertiesKHR *properties)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_display_get_physical_device_display_plane_properties(
+      physical_device, &pdevice->wsi_device,
+      property_count, properties);
+}
+
+VkResult
+anv_GetPhysicalDeviceDisplayPlaneProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayPlaneProperties2KHR*               pProperties)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice);
+
+   return wsi_display_get_physical_device_display_plane_properties2(
+      physicalDevice, &pdevice->wsi_device,
+      pPropertyCount, pProperties);
+}
+
+VkResult
+anv_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physical_device,
+                                        uint32_t plane_index,
+                                        uint32_t *display_count,
+                                        VkDisplayKHR *displays)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_display_get_display_plane_supported_displays(physical_device,
+                                                           &pdevice->wsi_device,
+                                                           plane_index,
+                                                           display_count,
+                                                           displays);
+}
+
+
+VkResult
+anv_GetDisplayModePropertiesKHR(VkPhysicalDevice physical_device,
+                                VkDisplayKHR display,
+                                uint32_t *property_count,
+                                VkDisplayModePropertiesKHR *properties)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_display_get_display_mode_properties(physical_device,
+                                                  &pdevice->wsi_device,
+                                                  display,
+                                                  property_count,
+                                                  properties);
+}
+
+VkResult
+anv_GetDisplayModeProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayModeProperties2KHR*                pProperties)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice);
+
+   return wsi_display_get_display_mode_properties2(physicalDevice,
+                                                   &pdevice->wsi_device,
+                                                   display,
+                                                   pPropertyCount,
+                                                   pProperties);
+}
+
+VkResult
+anv_CreateDisplayModeKHR(VkPhysicalDevice physical_device,
+                         VkDisplayKHR display,
+                         const VkDisplayModeCreateInfoKHR *create_info,
+                         const VkAllocationCallbacks *allocator,
+                         VkDisplayModeKHR *mode)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_display_create_display_mode(physical_device,
+                                          &pdevice->wsi_device,
+                                          display,
+                                          create_info,
+                                          allocator,
+                                          mode);
+}
+
+VkResult
+anv_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physical_device,
+                                   VkDisplayModeKHR mode_khr,
+                                   uint32_t plane_index,
+                                   VkDisplayPlaneCapabilitiesKHR *capabilities)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_get_display_plane_capabilities(physical_device,
+                                             &pdevice->wsi_device,
+                                             mode_khr,
+                                             plane_index,
+                                             capabilities);
+}
+
+VkResult
+anv_GetDisplayPlaneCapabilities2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
+    VkDisplayPlaneCapabilities2KHR*             pCapabilities)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice);
+
+   return wsi_get_display_plane_capabilities2(physicalDevice,
+                                              &pdevice->wsi_device,
+                                              pDisplayPlaneInfo,
+                                              pCapabilities);
+}
+
+VkResult
+anv_CreateDisplayPlaneSurfaceKHR(
+   VkInstance _instance,
+   const VkDisplaySurfaceCreateInfoKHR *create_info,
+   const VkAllocationCallbacks *allocator,
+   VkSurfaceKHR *surface)
+{
+   ANV_FROM_HANDLE(anv_instance, instance, _instance);
+   const VkAllocationCallbacks *alloc;
+
+   if (allocator)
+     alloc = allocator;
+   else
+     alloc = &instance->alloc;
+
+   return wsi_create_display_surface(_instance, alloc, create_info, surface);
+}
+
+VkResult
+anv_ReleaseDisplayEXT(VkPhysicalDevice physical_device,
+                       VkDisplayKHR     display)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_release_display(physical_device,
+                              &pdevice->wsi_device,
+                              display);
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+VkResult
+anv_AcquireXlibDisplayEXT(VkPhysicalDevice     physical_device,
+                           Display              *dpy,
+                           VkDisplayKHR         display)
+{
+   ANV_FROM_HANDLE(anv_physical_device, pdevice, physical_device);
+
+   return wsi_acquire_xlib_display(physical_device,
+                                   &pdevice->wsi_device,
+                                   dpy,
+                                   display);
+}
+
+VkResult
+anv_GetRandROutputDisplayEXT(VkPhysicalDevice  physical_device,
+                              Display           *dpy,
+                              RROutput          output,
+                              VkDisplayKHR      *display)
+{
+   ANV_FROM_HANDLE(anv_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
+anv_DisplayPowerControlEXT(VkDevice                    _device,
+                            VkDisplayKHR                display,
+                            const VkDisplayPowerInfoEXT *display_power_info)
+{
+   ANV_FROM_HANDLE(anv_device, device, _device);
+
+   return wsi_display_power_control(
+      _device, &device->instance->physicalDevice.wsi_device,
+      display, display_power_info);
+}
+
+VkResult
 anv_RegisterDeviceEventEXT(VkDevice _device,
                             const VkDeviceEventInfoEXT *device_event_info,
                             const VkAllocationCallbacks *allocator,
@@ -37,23 +255,22 @@ anv_RegisterDeviceEventEXT(VkDevice _device,
    struct anv_fence *fence;
    VkResult ret;
 
-   fence = vk_object_zalloc(&device->vk, allocator, sizeof (*fence),
-                            VK_OBJECT_TYPE_FENCE);
+   fence = vk_zalloc2(&device->instance->alloc, allocator, sizeof (*fence), 8,
+                      VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    if (!fence)
-      return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
+      return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 
    fence->permanent.type = ANV_FENCE_TYPE_WSI;
 
    ret = wsi_register_device_event(_device,
-                                   &device->physical->wsi_device,
+                                   &device->instance->physicalDevice.wsi_device,
                                    device_event_info,
                                    allocator,
-                                   &fence->permanent.fence_wsi,
-                                   -1);
+                                   &fence->permanent.fence_wsi);
    if (ret == VK_SUCCESS)
       *_fence = anv_fence_to_handle(fence);
    else
-      vk_free2(&device->vk.alloc, allocator, fence);
+      vk_free2(&device->instance->alloc, allocator, fence);
    return ret;
 }
 
@@ -68,20 +285,33 @@ anv_RegisterDisplayEventEXT(VkDevice _device,
    struct anv_fence *fence;
    VkResult ret;
 
-   fence = vk_object_zalloc(&device->vk, allocator, sizeof (*fence),
-                            VK_OBJECT_TYPE_FENCE);
+   fence = vk_zalloc2(&device->alloc, allocator, sizeof (*fence), 8,
+                      VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    if (!fence)
       return VK_ERROR_OUT_OF_HOST_MEMORY;
 
    fence->permanent.type = ANV_FENCE_TYPE_WSI;
 
    ret = wsi_register_display_event(
-      _device, &device->physical->wsi_device,
-      display, display_event_info, allocator, &fence->permanent.fence_wsi, -1);
+      _device, &device->instance->physicalDevice.wsi_device,
+      display, display_event_info, allocator, &(fence->permanent.fence_wsi));
 
    if (ret == VK_SUCCESS)
       *_fence = anv_fence_to_handle(fence);
    else
-      vk_free2(&device->vk.alloc, allocator, fence);
+      vk_free2(&device->alloc, allocator, fence);
    return ret;
 }
+
+VkResult
+anv_GetSwapchainCounterEXT(VkDevice _device,
+                            VkSwapchainKHR swapchain,
+                            VkSurfaceCounterFlagBitsEXT flag_bits,
+                            uint64_t *value)
+{
+   ANV_FROM_HANDLE(anv_device, device, _device);
+
+   return wsi_get_swapchain_counter(
+      _device, &device->instance->physicalDevice.wsi_device,
+      swapchain, flag_bits, value);
+}