vulkan/wsi/display: Delete the wrapper entrypoints

Acked-by: Chia-I Wu <olvaffe@gmail.com>
Acked-by: Iago Toral Quiroga <itoral@igalia.com>
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/13234>

src/vulkan/wsi/wsi_common_display.c

@@ -414,22 +414,20 @@ wsi_display_fill_in_display_properties(struct wsi_device *wsi_device,
    properties->persistentContent = VK_FALSE;
 }
 
-/*
+VKAPI_ATTR VkResult VKAPI_CALL
- * Implement vkGetPhysicalDeviceDisplayPropertiesKHR (VK_KHR_display)
+wsi_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
- */
+                                          uint32_t *pPropertyCount,
-VkResult
+                                          VkDisplayPropertiesKHR *pProperties)
-wsi_display_get_physical_device_display_properties(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t *property_count,
-   VkDisplayPropertiesKHR *properties)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
 
-   if (properties == NULL) {
+   if (pProperties == NULL) {
-      return wsi_display_get_physical_device_display_properties2(
+      return wsi_GetPhysicalDeviceDisplayProperties2KHR(physicalDevice,
-            physical_device, wsi_device, property_count, NULL);
+                                                        pPropertyCount,
+                                                        NULL);
    } else {
       /* If we're actually returning properties, allocate a temporary array of
        * VkDisplayProperties2KHR structs, call properties2 to fill them out,
@@ -439,20 +437,21 @@ wsi_display_get_physical_device_display_properties(
        * allocations so this should get lost in the noise.
        */
       VkDisplayProperties2KHR *props2 =
-         vk_zalloc(wsi->alloc, sizeof(*props2) * *property_count, 8,
+         vk_zalloc(wsi->alloc, sizeof(*props2) * *pPropertyCount, 8,
                    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
       if (props2 == NULL)
          return VK_ERROR_OUT_OF_HOST_MEMORY;
 
-      for (uint32_t i = 0; i < *property_count; i++)
+      for (uint32_t i = 0; i < *pPropertyCount; i++)
          props2[i].sType = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR;
 
-      VkResult result = wsi_display_get_physical_device_display_properties2(
+      VkResult result =
-            physical_device, wsi_device, property_count, props2);
+         wsi_GetPhysicalDeviceDisplayProperties2KHR(physicalDevice,
+                                                    pPropertyCount, props2);
 
       if (result == VK_SUCCESS || result == VK_INCOMPLETE) {
-         for (uint32_t i = 0; i < *property_count; i++)
+         for (uint32_t i = 0; i < *pPropertyCount; i++)
-            properties[i] = props2[i].displayProperties;
+            pProperties[i] = props2[i].displayProperties;
       }
 
       vk_free(wsi->alloc, props2);
@@ -462,25 +461,12 @@ wsi_display_get_physical_device_display_properties(
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+wsi_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
                                            uint32_t *pPropertyCount,
-                                          VkDisplayPropertiesKHR *pProperties)
+                                           VkDisplayProperties2KHR *pProperties)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_display_get_physical_device_display_properties(physicalDevice,
-                                                             device->wsi_device,
-                                                             pPropertyCount,
-                                                             pProperties);
-}
-
-VkResult
-wsi_display_get_physical_device_display_properties2(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t *property_count,
-   VkDisplayProperties2KHR *properties)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
 
@@ -492,7 +478,7 @@ wsi_display_get_physical_device_display_properties2(
    if (!mode_res)
       goto bail;
 
-   VK_OUTARRAY_MAKE(conn, properties, property_count);
+   VK_OUTARRAY_MAKE(conn, pProperties, pPropertyCount);
 
    /* Get current information */
 
@@ -520,23 +506,10 @@ wsi_display_get_physical_device_display_properties2(
    return vk_outarray_status(&conn);
 
 bail:
-   *property_count = 0;
+   *pPropertyCount = 0;
    return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
-                                           uint32_t *pPropertyCount,
-                                           VkDisplayProperties2KHR *pProperties)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_display_get_physical_device_display_properties2(physicalDevice,
-                                                              device->wsi_device,
-                                                              pPropertyCount,
-                                                              pProperties);
-}
-
 /*
  * Implement vkGetPhysicalDeviceDisplayPlanePropertiesKHR (VK_KHR_display
  */
@@ -558,17 +531,17 @@ wsi_display_fill_in_display_plane_properties(
    }
 }
 
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_display_get_physical_device_display_plane_properties(
+wsi_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
-   VkPhysicalDevice physical_device,
+                                               uint32_t *pPropertyCount,
-   struct wsi_device *wsi_device,
+                                               VkDisplayPlanePropertiesKHR *pProperties)
-   uint32_t *property_count,
-   VkDisplayPlanePropertiesKHR *properties)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
 
-   VK_OUTARRAY_MAKE(conn, properties, property_count);
+   VK_OUTARRAY_MAKE(conn, pProperties, pPropertyCount);
 
    wsi_for_each_connector(connector, wsi) {
       vk_outarray_append(&conn, prop) {
@@ -584,27 +557,16 @@ wsi_display_get_physical_device_display_plane_properties(
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
+wsi_GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
                                                 uint32_t *pPropertyCount,
-                                               VkDisplayPlanePropertiesKHR *pProperties)
+                                                VkDisplayPlaneProperties2KHR *pProperties)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_display_get_physical_device_display_plane_properties(
-      physicalDevice, device->wsi_device, pPropertyCount, pProperties);
-}
-
-VkResult
-wsi_display_get_physical_device_display_plane_properties2(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t *property_count,
-   VkDisplayPlaneProperties2KHR *properties)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
 
-   VK_OUTARRAY_MAKE(conn, properties, property_count);
+   VK_OUTARRAY_MAKE(conn, pProperties, pPropertyCount);
 
    wsi_for_each_connector(connector, wsi) {
       vk_outarray_append(&conn, prop) {
@@ -615,57 +577,34 @@ wsi_display_get_physical_device_display_plane_properties2(
    return vk_outarray_status(&conn);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                uint32_t *pPropertyCount,
-                                                VkDisplayPlaneProperties2KHR *pProperties)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_display_get_physical_device_display_plane_properties2(
-      physicalDevice, device->wsi_device, pPropertyCount, pProperties);
-}
-
 /*
  * Implement vkGetDisplayPlaneSupportedDisplaysKHR (VK_KHR_display)
  */
 
-VkResult
-wsi_display_get_display_plane_supported_displays(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t plane_index,
-   uint32_t *display_count,
-   VkDisplayKHR *displays)
-{
-   struct wsi_display *wsi =
-      (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
-
-   VK_OUTARRAY_MAKE(conn, displays, display_count);
-
-   int c = 0;
-
-   wsi_for_each_connector(connector, wsi) {
-      if (c == plane_index && connector->connected) {
-         vk_outarray_append(&conn, display) {
-            *display = wsi_display_connector_to_handle(connector);
-         }
-      }
-      c++;
-   }
-   return vk_outarray_status(&conn);
-}
-
 VKAPI_ATTR VkResult VKAPI_CALL
 wsi_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
                                         uint32_t planeIndex,
                                         uint32_t *pDisplayCount,
                                         VkDisplayKHR *pDisplays)
 {
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
+   struct wsi_display *wsi =
+      (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
 
-   return wsi_display_get_display_plane_supported_displays(
+   VK_OUTARRAY_MAKE(conn, pDisplays, pDisplayCount);
-      physicalDevice, device->wsi_device, planeIndex, pDisplayCount, pDisplays);
+
+   int c = 0;
+
+   wsi_for_each_connector(connector, wsi) {
+      if (c == planeIndex && connector->connected) {
+         vk_outarray_append(&conn, display) {
+            *display = wsi_display_connector_to_handle(connector);
+         }
+      }
+      c++;
+   }
+   return vk_outarray_status(&conn);
 }
 
 /*
@@ -688,17 +627,18 @@ wsi_display_fill_in_display_mode_properties(
       (uint32_t) (wsi_display_mode_refresh(display_mode) * 1000 + 0.5);
 }
 
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_display_get_display_mode_properties(VkPhysicalDevice physical_device,
+wsi_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
-                                        struct wsi_device *wsi_device,
                                 VkDisplayKHR display,
-                                        uint32_t *property_count,
+                                uint32_t *pPropertyCount,
-                                        VkDisplayModePropertiesKHR *properties)
+                                VkDisplayModePropertiesKHR *pProperties)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display_connector *connector =
       wsi_display_connector_from_handle(display);
 
-   VK_OUTARRAY_MAKE(conn, properties, property_count);
+   VK_OUTARRAY_MAKE(conn, pProperties, pPropertyCount);
 
    wsi_for_each_display_mode(display_mode, connector) {
       if (!display_mode->valid)
@@ -717,31 +657,17 @@ wsi_display_get_display_mode_properties(VkPhysicalDevice physical_device,
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
+wsi_GetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,
                                  VkDisplayKHR display,
                                  uint32_t *pPropertyCount,
-                                VkDisplayModePropertiesKHR *pProperties)
+                                 VkDisplayModeProperties2KHR *pProperties)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_display_get_display_mode_properties(physicalDevice,
-                                                  device->wsi_device,
-                                                  display,
-                                                  pPropertyCount,
-                                                  pProperties);
-}
-
-VkResult
-wsi_display_get_display_mode_properties2(VkPhysicalDevice physical_device,
-                                         struct wsi_device *wsi_device,
-                                         VkDisplayKHR display,
-                                         uint32_t *property_count,
-                                         VkDisplayModeProperties2KHR *properties)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display_connector *connector =
       wsi_display_connector_from_handle(display);
 
-   VK_OUTARRAY_MAKE(conn, properties, property_count);
+   VK_OUTARRAY_MAKE(conn, pProperties, pPropertyCount);
 
    wsi_for_each_display_mode(display_mode, connector) {
       if (!display_mode->valid)
@@ -755,21 +681,6 @@ wsi_display_get_display_mode_properties2(VkPhysicalDevice physical_device,
    return vk_outarray_status(&conn);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,
-                                 VkDisplayKHR display,
-                                 uint32_t *pPropertyCount,
-                                 VkDisplayModeProperties2KHR *pProperties)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_display_get_display_mode_properties2(physicalDevice,
-                                                   device->wsi_device,
-                                                   display,
-                                                   pPropertyCount,
-                                                   pProperties);
-}
-
 static bool
 wsi_display_mode_matches_vk(wsi_display_mode *wsi,
                             const VkDisplayModeParametersKHR *vk)
@@ -782,18 +693,17 @@ wsi_display_mode_matches_vk(wsi_display_mode *wsi,
 /*
  * Implement vkCreateDisplayModeKHR (VK_KHR_display)
  */
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_display_create_display_mode(VkPhysicalDevice physical_device,
+wsi_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
-                                struct wsi_device *wsi_device,
                          VkDisplayKHR display,
-                                const VkDisplayModeCreateInfoKHR *create_info,
+                         const VkDisplayModeCreateInfoKHR *pCreateInfo,
-                                const VkAllocationCallbacks *allocator,
+                         const VkAllocationCallbacks *pAllocator,
-                                VkDisplayModeKHR *mode)
+                         VkDisplayModeKHR *pMode)
 {
    struct wsi_display_connector *connector =
       wsi_display_connector_from_handle(display);
 
-   if (create_info->flags != 0)
+   if (pCreateInfo->flags != 0)
       return VK_ERROR_INITIALIZATION_FAILED;
 
    /* Check and see if the requested mode happens to match an existing one and
@@ -803,8 +713,8 @@ wsi_display_create_display_mode(VkPhysicalDevice physical_device,
     */
    wsi_for_each_display_mode(display_mode, connector) {
       if (display_mode->valid) {
-         if (wsi_display_mode_matches_vk(display_mode, &create_info->parameters)) {
+         if (wsi_display_mode_matches_vk(display_mode, &pCreateInfo->parameters)) {
-            *mode = wsi_display_mode_to_handle(display_mode);
+            *pMode = wsi_display_mode_to_handle(display_mode);
             return VK_SUCCESS;
          }
       }
@@ -812,88 +722,53 @@ wsi_display_create_display_mode(VkPhysicalDevice physical_device,
    return VK_ERROR_INITIALIZATION_FAILED;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
-                         VkDisplayKHR display,
-                         const VkDisplayModeCreateInfoKHR *pCreateInfo,
-                         const VkAllocationCallbacks *pAllocator,
-                         VkDisplayModeKHR *pMode)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_display_create_display_mode(physicalDevice,
-                                          device->wsi_device,
-                                          display,
-                                          pCreateInfo,
-                                          pAllocator,
-                                          pMode);
-}
-
 /*
  * Implement vkGetDisplayPlaneCapabilities
  */
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_get_display_plane_capabilities(VkPhysicalDevice physical_device,
+wsi_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
-                                   struct wsi_device *wsi_device,
+                                   VkDisplayModeKHR _mode,
-                                   VkDisplayModeKHR mode_khr,
+                                   uint32_t planeIndex,
-                                   uint32_t plane_index,
+                                   VkDisplayPlaneCapabilitiesKHR *pCapabilities)
-                                   VkDisplayPlaneCapabilitiesKHR *capabilities)
 {
-   struct wsi_display_mode *mode = wsi_display_mode_from_handle(mode_khr);
+   struct wsi_display_mode *mode = wsi_display_mode_from_handle(_mode);
 
    /* XXX use actual values */
-   capabilities->supportedAlpha = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
+   pCapabilities->supportedAlpha = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
-   capabilities->minSrcPosition.x = 0;
+   pCapabilities->minSrcPosition.x = 0;
-   capabilities->minSrcPosition.y = 0;
+   pCapabilities->minSrcPosition.y = 0;
-   capabilities->maxSrcPosition.x = 0;
+   pCapabilities->maxSrcPosition.x = 0;
-   capabilities->maxSrcPosition.y = 0;
+   pCapabilities->maxSrcPosition.y = 0;
-   capabilities->minSrcExtent.width = mode->hdisplay;
+   pCapabilities->minSrcExtent.width = mode->hdisplay;
-   capabilities->minSrcExtent.height = mode->vdisplay;
+   pCapabilities->minSrcExtent.height = mode->vdisplay;
-   capabilities->maxSrcExtent.width = mode->hdisplay;
+   pCapabilities->maxSrcExtent.width = mode->hdisplay;
-   capabilities->maxSrcExtent.height = mode->vdisplay;
+   pCapabilities->maxSrcExtent.height = mode->vdisplay;
-   capabilities->minDstPosition.x = 0;
+   pCapabilities->minDstPosition.x = 0;
-   capabilities->minDstPosition.y = 0;
+   pCapabilities->minDstPosition.y = 0;
-   capabilities->maxDstPosition.x = 0;
+   pCapabilities->maxDstPosition.x = 0;
-   capabilities->maxDstPosition.y = 0;
+   pCapabilities->maxDstPosition.y = 0;
-   capabilities->minDstExtent.width = mode->hdisplay;
+   pCapabilities->minDstExtent.width = mode->hdisplay;
-   capabilities->minDstExtent.height = mode->vdisplay;
+   pCapabilities->minDstExtent.height = mode->vdisplay;
-   capabilities->maxDstExtent.width = mode->hdisplay;
+   pCapabilities->maxDstExtent.width = mode->hdisplay;
-   capabilities->maxDstExtent.height = mode->vdisplay;
+   pCapabilities->maxDstExtent.height = mode->vdisplay;
    return VK_SUCCESS;
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+wsi_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
-                                   VkDisplayModeKHR mode,
-                                   uint32_t planeIndex,
-                                   VkDisplayPlaneCapabilitiesKHR *pCapabilities)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_get_display_plane_capabilities(physicalDevice,
-                                             device->wsi_device,
-                                             mode,
-                                             planeIndex,
-                                             pCapabilities);
-}
-
-VkResult
-wsi_get_display_plane_capabilities2(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
                                     const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
-   VkDisplayPlaneCapabilities2KHR *capabilities)
+                                    VkDisplayPlaneCapabilities2KHR *pCapabilities)
 {
-   assert(capabilities->sType ==
+   assert(pCapabilities->sType ==
           VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR);
 
    VkResult result =
-      wsi_get_display_plane_capabilities(physical_device, wsi_device,
+      wsi_GetDisplayPlaneCapabilitiesKHR(physicalDevice,
                                          pDisplayPlaneInfo->mode,
                                          pDisplayPlaneInfo->planeIndex,
-                                         &capabilities->capabilities);
+                                         &pCapabilities->capabilities);
 
-   vk_foreach_struct(ext, capabilities->pNext) {
+   vk_foreach_struct(ext, pCapabilities->pNext) {
       switch (ext->sType) {
       case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
          VkSurfaceProtectedCapabilitiesKHR *protected = (void *)ext;
@@ -910,45 +785,6 @@ wsi_get_display_plane_capabilities2(
    return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
-                                    const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
-                                    VkDisplayPlaneCapabilities2KHR *pCapabilities)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_get_display_plane_capabilities2(physicalDevice,
-                                              device->wsi_device,
-                                              pDisplayPlaneInfo,
-                                              pCapabilities);
-}
-
-VkResult
-wsi_create_display_surface(VkInstance instance,
-                           const VkAllocationCallbacks *allocator,
-                           const VkDisplaySurfaceCreateInfoKHR *create_info,
-                           VkSurfaceKHR *surface_khr)
-{
-   VkIcdSurfaceDisplay *surface = vk_zalloc(allocator, sizeof *surface, 8,
-                                            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-
-   if (surface == NULL)
-      return VK_ERROR_OUT_OF_HOST_MEMORY;
-
-   surface->base.platform = VK_ICD_WSI_PLATFORM_DISPLAY;
-
-   surface->displayMode = create_info->displayMode;
-   surface->planeIndex = create_info->planeIndex;
-   surface->planeStackIndex = create_info->planeStackIndex;
-   surface->transform = create_info->transform;
-   surface->globalAlpha = create_info->globalAlpha;
-   surface->alphaMode = create_info->alphaMode;
-   surface->imageExtent = create_info->imageExtent;
-
-   *surface_khr = VkIcdSurfaceBase_to_handle(&surface->base);
-   return VK_SUCCESS;
-}
-
 VKAPI_ATTR VkResult VKAPI_CALL
 wsi_CreateDisplayPlaneSurfaceKHR(VkInstance _instance,
                                  const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
@@ -956,14 +792,28 @@ wsi_CreateDisplayPlaneSurfaceKHR(VkInstance _instance,
                                  VkSurfaceKHR *pSurface)
 {
    VK_FROM_HANDLE(vk_instance, instance, _instance);
-   const VkAllocationCallbacks *alloc;
+   VkIcdSurfaceDisplay *surface;
 
-   if (pAllocator)
+   assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR);
-     alloc = pAllocator;
-   else
-     alloc = &instance->alloc;
 
-   return wsi_create_display_surface(_instance, alloc, pCreateInfo, pSurface);
+   surface = vk_zalloc2(&instance->alloc, pAllocator, sizeof(*surface), 8,
+                        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+   if (surface == NULL)
+      return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+   surface->base.platform = VK_ICD_WSI_PLATFORM_DISPLAY;
+
+   surface->displayMode = pCreateInfo->displayMode;
+   surface->planeIndex = pCreateInfo->planeIndex;
+   surface->planeStackIndex = pCreateInfo->planeStackIndex;
+   surface->transform = pCreateInfo->transform;
+   surface->globalAlpha = pCreateInfo->globalAlpha;
+   surface->alphaMode = pCreateInfo->alphaMode;
+   surface->imageExtent = pCreateInfo->imageExtent;
+
+   *pSurface = VkIcdSurfaceBase_to_handle(&surface->base);
+
+   return VK_SUCCESS;
 }
 
 static VkResult
@@ -2137,11 +1987,12 @@ wsi_display_finish_wsi(struct wsi_device *wsi_device,
 /*
  * Implement vkReleaseDisplay
  */
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_release_display(VkPhysicalDevice            physical_device,
+wsi_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice,
-                    struct wsi_device           *wsi_device,
                       VkDisplayKHR display)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
 
@@ -2159,17 +2010,6 @@ wsi_release_display(VkPhysicalDevice            physical_device,
    return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice,
-                      VkDisplayKHR display)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_release_display(physicalDevice,
-                              device->wsi_device,
-                              display);
-}
-
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
 
 static struct wsi_display_connector *
@@ -2566,12 +2406,13 @@ wsi_display_find_crtc_for_output(xcb_connection_t *connection,
    return idle_crtc;
 }
 
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_acquire_xlib_display(VkPhysicalDevice physical_device,
+wsi_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice,
-                         struct wsi_device *wsi_device,
                           Display *dpy,
                           VkDisplayKHR display)
 {
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
    xcb_connection_t *connection = XGetXCBConnection(dpy);
@@ -2629,58 +2470,36 @@ wsi_acquire_xlib_display(VkPhysicalDevice physical_device,
    return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice,
-                          Display *dpy,
-                          VkDisplayKHR display)
-{
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
-
-   return wsi_acquire_xlib_display(physicalDevice,
-                                   device->wsi_device,
-                                   dpy, display);
-}
-
-VkResult
-wsi_get_randr_output_display(VkPhysicalDevice physical_device,
-                             struct wsi_device *wsi_device,
-                             Display *dpy,
-                             RROutput output,
-                             VkDisplayKHR *display)
-{
-   xcb_connection_t *connection = XGetXCBConnection(dpy);
-   struct wsi_display_connector *connector =
-      wsi_display_get_output(wsi_device, connection, (xcb_randr_output_t) output);
-
-   if (connector)
-      *display = wsi_display_connector_to_handle(connector);
-   else
-      *display = VK_NULL_HANDLE;
-   return VK_SUCCESS;
-}
-
 VKAPI_ATTR VkResult VKAPI_CALL
 wsi_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice,
                              Display *dpy,
                              RROutput rrOutput,
                              VkDisplayKHR *pDisplay)
 {
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
+   xcb_connection_t *connection = XGetXCBConnection(dpy);
+   struct wsi_display_connector *connector =
+      wsi_display_get_output(wsi_device, connection,
+                             (xcb_randr_output_t) rrOutput);
 
-   return wsi_get_randr_output_display(physicalDevice,
+   if (connector)
-                                       device->wsi_device,
+      *pDisplay = wsi_display_connector_to_handle(connector);
-                                       dpy, rrOutput, pDisplay);
+   else
+      *pDisplay = VK_NULL_HANDLE;
+   return VK_SUCCESS;
 }
 
 #endif
 
 /* VK_EXT_display_control */
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_display_power_control(VkDevice device,
+wsi_DisplayPowerControlEXT(VkDevice _device,
-                          struct wsi_device *wsi_device,
                            VkDisplayKHR display,
-                          const VkDisplayPowerInfoEXT *display_power_info)
+                           const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
 {
+   VK_FROM_HANDLE(vk_device, device, _device);
+   struct wsi_device *wsi_device = device->physical->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
    struct wsi_display_connector *connector =
@@ -2690,7 +2509,7 @@ wsi_display_power_control(VkDevice device,
    if (wsi->fd < 0)
       return VK_ERROR_INITIALIZATION_FAILED;
 
-   switch (display_power_info->powerState) {
+   switch (pDisplayPowerInfo->powerState) {
    case VK_DISPLAY_POWER_STATE_OFF_EXT:
       mode = DRM_MODE_DPMS_OFF;
       break;
@@ -2708,17 +2527,6 @@ wsi_display_power_control(VkDevice device,
    return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_DisplayPowerControlEXT(VkDevice _device,
-                           VkDisplayKHR display,
-                           const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
-{
-   VK_FROM_HANDLE(vk_device, device, _device);
-
-   return wsi_display_power_control(_device, device->physical->wsi_device,
-                                    display, pDisplayPowerInfo);
-}
-
 VkResult
 wsi_register_device_event(VkDevice device,
                           struct wsi_device *wsi_device,
@@ -2794,13 +2602,14 @@ wsi_RegisterDisplayEventEXT(VkDevice device,
    unreachable("Not enough common infrastructure to implement this yet");
 }
 
-VkResult
+VKAPI_ATTR VkResult VKAPI_CALL
-wsi_get_swapchain_counter(VkDevice device,
+wsi_GetSwapchainCounterEXT(VkDevice _device,
-                          struct wsi_device *wsi_device,
                            VkSwapchainKHR _swapchain,
-                          VkSurfaceCounterFlagBitsEXT flag_bits,
+                           VkSurfaceCounterFlagBitsEXT counter,
-                          uint64_t *value)
+                           uint64_t *pCounterValue)
 {
+   VK_FROM_HANDLE(vk_device, device, _device);
+   struct wsi_device *wsi_device = device->physical->wsi_device;
    struct wsi_display *wsi =
       (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
    struct wsi_display_swapchain *swapchain =
@@ -2812,90 +2621,48 @@ wsi_get_swapchain_counter(VkDevice device,
       return VK_ERROR_INITIALIZATION_FAILED;
 
    if (!connector->active) {
-      *value = 0;
+      *pCounterValue = 0;
       return VK_SUCCESS;
    }
 
-   int ret = drmCrtcGetSequence(wsi->fd, connector->crtc_id, value, NULL);
+   int ret = drmCrtcGetSequence(wsi->fd, connector->crtc_id,
+                                pCounterValue, NULL);
    if (ret)
-      *value = 0;
+      *pCounterValue = 0;
 
    return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-wsi_GetSwapchainCounterEXT(VkDevice _device,
-                           VkSwapchainKHR swapchain,
-                           VkSurfaceCounterFlagBitsEXT counter,
-                           uint64_t *pCounterValue)
-{
-   VK_FROM_HANDLE(vk_device, device, _device);
-
-   return wsi_get_swapchain_counter(_device, device->physical->wsi_device,
-                                    swapchain, counter, pCounterValue);
-}
-
-VkResult
-wsi_acquire_drm_display(VkPhysicalDevice     pDevice,
-                        struct wsi_device    *wsi_device,
-                        int                  drm_fd,
-                        VkDisplayKHR         display)
-{
-   if (!wsi_device_matches_drm_fd(wsi_device, drm_fd))
-      return VK_ERROR_UNKNOWN;
-
-   struct wsi_display *wsi =
-      (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
-
-   /* XXX no support for mulitple leases yet */
-   if (wsi->fd >= 0 || !local_drmIsMaster(drm_fd))
-      return VK_ERROR_INITIALIZATION_FAILED;
-
-   struct wsi_display_connector *connector =
-         wsi_display_connector_from_handle(display);
-
-   drmModeConnectorPtr drm_connector =
-         drmModeGetConnectorCurrent(drm_fd, connector->id);
-
-   if (!drm_connector)
-      return VK_ERROR_INITIALIZATION_FAILED;
-
-   drmModeFreeConnector(drm_connector);
-
-   wsi->fd = drm_fd;
-   return VK_SUCCESS;
-}
-
 VKAPI_ATTR VkResult VKAPI_CALL
 wsi_AcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice,
                          int32_t drmFd,
                          VkDisplayKHR display)
 {
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
 
-   return wsi_acquire_drm_display(physicalDevice, device->wsi_device,
+   if (!wsi_device_matches_drm_fd(wsi_device, drmFd))
-                                  drmFd, display);
-}
-
-VkResult
-wsi_get_drm_display(VkPhysicalDevice      pDevice,
-                    struct wsi_device     *wsi_device,
-                    int                   drm_fd,
-                    int                   connector_id,
-                    VkDisplayKHR          *display)
-{
-   if (!wsi_device_matches_drm_fd(wsi_device, drm_fd))
       return VK_ERROR_UNKNOWN;
 
+   struct wsi_display *wsi =
+      (struct wsi_display *) wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY];
+
+   /* XXX no support for mulitple leases yet */
+   if (wsi->fd >= 0 || !local_drmIsMaster(drmFd))
+      return VK_ERROR_INITIALIZATION_FAILED;
+
    struct wsi_display_connector *connector =
-      wsi_display_get_connector(wsi_device, drm_fd, connector_id);
+         wsi_display_connector_from_handle(display);
 
-   if (!connector) {
+   drmModeConnectorPtr drm_connector =
-      *display = VK_NULL_HANDLE;
+         drmModeGetConnectorCurrent(drmFd, connector->id);
-      return VK_ERROR_UNKNOWN;
-   }
 
-   *display = wsi_display_connector_to_handle(connector);
+   if (!drm_connector)
+      return VK_ERROR_INITIALIZATION_FAILED;
+
+   drmModeFreeConnector(drm_connector);
+
+   wsi->fd = drmFd;
    return VK_SUCCESS;
 }
 
@@ -2903,10 +2670,22 @@ VKAPI_ATTR VkResult VKAPI_CALL
 wsi_GetDrmDisplayEXT(VkPhysicalDevice physicalDevice,
                      int32_t drmFd,
                      uint32_t connectorId,
-                     VkDisplayKHR *display)
+                     VkDisplayKHR *pDisplay)
 {
-   VK_FROM_HANDLE(vk_physical_device, device, physicalDevice);
+   VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);
+   struct wsi_device *wsi_device = pdevice->wsi_device;
 
-   return wsi_get_drm_display(physicalDevice, device->wsi_device,
+   if (!wsi_device_matches_drm_fd(wsi_device, drmFd))
-                              drmFd, connectorId, display);
+      return VK_ERROR_UNKNOWN;
+
+   struct wsi_display_connector *connector =
+      wsi_display_get_connector(wsi_device, drmFd, connectorId);
+
+   if (!connector) {
+      *pDisplay = VK_NULL_HANDLE;
+      return VK_ERROR_UNKNOWN;
+   }
+
+   *pDisplay = wsi_display_connector_to_handle(connector);
+   return VK_SUCCESS;
 }

src/vulkan/wsi/wsi_common_display.h

@@ -27,112 +27,7 @@
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 
-VkResult
-wsi_display_get_physical_device_display_properties(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t *property_count,
-   VkDisplayPropertiesKHR *properties);
-
-VkResult
-wsi_display_get_physical_device_display_properties2(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t *pPropertyCount,
-   VkDisplayProperties2KHR *pProperties);
-
-VkResult
-wsi_display_get_physical_device_display_plane_properties(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t *property_count,
-   VkDisplayPlanePropertiesKHR *properties);
-
-VkResult
-wsi_display_get_physical_device_display_plane_properties2(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t *property_count,
-   VkDisplayPlaneProperties2KHR *properties);
-
-VkResult
-wsi_display_get_display_plane_supported_displays(
-   VkPhysicalDevice physical_device,
-   struct wsi_device *wsi_device,
-   uint32_t plane_index,
-   uint32_t *display_count,
-   VkDisplayKHR *displays);
-
-VkResult
-wsi_display_get_display_mode_properties(VkPhysicalDevice physical_device,
-                                        struct wsi_device *wsi_device,
-                                        VkDisplayKHR display,
-                                        uint32_t *property_count,
-                                        VkDisplayModePropertiesKHR *properties);
-
-VkResult
-wsi_display_get_display_mode_properties2(VkPhysicalDevice physical_device,
-                                         struct wsi_device *wsi_device,
-                                         VkDisplayKHR display,
-                                         uint32_t *property_count,
-                                         VkDisplayModeProperties2KHR *properties);
-
-VkResult
-wsi_display_create_display_mode(VkPhysicalDevice physical_device,
-                                struct wsi_device *wsi_device,
-                                VkDisplayKHR display,
-                                const VkDisplayModeCreateInfoKHR *create_info,
-                                const VkAllocationCallbacks *allocator,
-                                VkDisplayModeKHR *mode);
-
-VkResult
-wsi_get_display_plane_capabilities(VkPhysicalDevice physical_device,
-                                   struct wsi_device *wsi_device,
-                                   VkDisplayModeKHR mode_khr,
-                                   uint32_t plane_index,
-                                   VkDisplayPlaneCapabilitiesKHR *capabilities);
-
-VkResult
-wsi_get_display_plane_capabilities2(VkPhysicalDevice physical_device,
-                                    struct wsi_device *wsi_device,
-                                    const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
-                                    VkDisplayPlaneCapabilities2KHR *capabilities);
-
-VkResult
-wsi_create_display_surface(VkInstance instance,
-                           const VkAllocationCallbacks *pAllocator,
-                           const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-                           VkSurfaceKHR *pSurface);
-
-VkResult
-wsi_release_display(VkPhysicalDevice            physical_device,
-                    struct wsi_device           *wsi_device,
-                    VkDisplayKHR                display);
-
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-VkResult
-wsi_acquire_xlib_display(VkPhysicalDevice       physical_device,
-                         struct wsi_device      *wsi_device,
-                         Display                *dpy,
-                         VkDisplayKHR           display);
-
-VkResult
-wsi_get_randr_output_display(VkPhysicalDevice   physical_device,
-                             struct wsi_device  *wsi_device,
-                             Display            *dpy,
-                             RROutput           output,
-                             VkDisplayKHR       *display);
-
-#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
-
 /* VK_EXT_display_control */
-VkResult
-wsi_display_power_control(VkDevice                      device,
-                          struct wsi_device             *wsi_device,
-                          VkDisplayKHR                  display,
-                          const VkDisplayPowerInfoEXT   *display_power_info);
-
 VkResult
 wsi_register_device_event(VkDevice                      device,
                           struct wsi_device             *wsi_device,
@@ -150,25 +45,4 @@ wsi_register_display_event(VkDevice                     device,
                            struct wsi_fence             **fence,
                            int sync_fd);
 
-VkResult
-wsi_get_swapchain_counter(VkDevice                      device,
-                          struct wsi_device             *wsi_device,
-                          VkSwapchainKHR                swapchain,
-                          VkSurfaceCounterFlagBitsEXT   flag_bits,
-                          uint64_t                      *value);
-
-/* VK_EXT_acquire_drm_display */
-VkResult
-wsi_acquire_drm_display(VkPhysicalDevice     pDevice,
-                        struct wsi_device    *wsi_device,
-                        int                  drmFd,
-                        VkDisplayKHR         display);
-
-VkResult
-wsi_get_drm_display(VkPhysicalDevice      pDevice,
-                    struct wsi_device     *wsi_device,
-                    int                   drmFd,
-                    int                   connectorId,
-                    VkDisplayKHR          *display);
-
 #endif