wsi: Skeletal code for VkDisplaySurfaceKHR

Change-Id: I5c7c66721883a6309aefce211f0aa2edee65c79b

diff --git a/src/wsi/display.c b/src/wsi/display.c
index 5e3884d..569c80c 100644 (file)
--- a/src/wsi/display.c
+++ b/src/wsi/display.c
@@ -23,13 +23,41 @@
  */
 
 #include "wsi.h"
+#include <string.h>
+
+void
+vk_display_init(vk_physical_device_t *pdev)
+{
+       /* TODO: */
+
+       pdev->display_count = 0;
+       pdev->displays = NULL;
+
+       pdev->plane_count = 0;
+       pdev->planes = NULL;
+}
 
 VKAPI_ATTR VkResult VKAPI_CALL
 vk_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice               pdev,
                                                                                 uint32_t                               *prop_count,
                                                                                 VkDisplayPropertiesKHR *props)
 {
-       /* TODO: */
+       vk_physical_device_t    *phydev = vk_get_physical_device(pdev);
+       uint32_t                                 i;
+
+       if (!props) {
+               *prop_count = phydev->display_count;
+               return VK_SUCCESS;
+       }
+
+       *prop_count = MIN(*prop_count, phydev->display_count);
+
+       for (i = 0; i < *prop_count; i++)
+               props[i] = phydev->displays[i].prop;
+
+       if (*prop_count < phydev->display_count)
+               return VK_INCOMPLETE;
+
        return VK_SUCCESS;
 }
 
@@ -38,7 +66,22 @@ vk_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice                                pdev,
                                                                                          uint32_t                                              *prop_count,
                                                                                          VkDisplayPlanePropertiesKHR   *props)
 {
-       /* TODO: */
+       vk_physical_device_t    *phydev = vk_get_physical_device(pdev);
+       uint32_t                                 i;
+
+       if (!props) {
+               *prop_count = phydev->plane_count;
+               return VK_SUCCESS;
+       }
+
+       *prop_count = MIN(*prop_count, phydev->plane_count);
+
+       for (i = 0; i < *prop_count; i++)
+               props[i] = phydev->planes[i].prop;
+
+       if (*prop_count < phydev->plane_count)
+               return VK_INCOMPLETE;
+
        return VK_SUCCESS;
 }
 
@@ -48,7 +91,23 @@ vk_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice       pdev,
                                                                           uint32_t                     *display_count,
                                                                           VkDisplayKHR         *displays)
 {
-       /* TODO: */
+       vk_physical_device_t    *phydev = vk_get_physical_device(pdev);
+       vk_display_plane_t              *plane = &phydev->planes[plane_index];
+       uint32_t                                 i;
+
+       if (!displays) {
+               *display_count = plane->supported_display_count;
+               return VK_SUCCESS;
+       }
+
+       *display_count = MIN(*display_count, plane->supported_display_count);
+
+       for (i = 0; i < *display_count; i++)
+               displays[i] = VK_TO_HANDLE(VkDisplayKHR, plane->supported_displays[i]);
+
+       if (*display_count < plane->supported_display_count)
+               return VK_INCOMPLETE;
+
        return VK_SUCCESS;
 }
 
@@ -58,7 +117,22 @@ vk_GetDisplayModePropertiesKHR(VkPhysicalDevice                              pdev,
                                                           uint32_t                                             *prop_count,
                                                           VkDisplayModePropertiesKHR   *props)
 {
-       /* TODO: */
+       vk_display_t                    *dpy = VK_TO_POINTER(vk_display_t, display);
+       uint32_t                                 i;
+
+       if (!props) {
+               *prop_count = dpy->built_in_mode_count;
+               return VK_SUCCESS;
+       }
+
+       *prop_count = MIN(*prop_count, dpy->built_in_mode_count);
+
+       for (i = 0; i < *prop_count; i++)
+               props[i] = dpy->built_in_modes[i].prop;
+
+       if (*prop_count < dpy->built_in_mode_count)
+               return VK_INCOMPLETE;
+
        return VK_SUCCESS;
 }
 
@@ -70,7 +144,7 @@ vk_CreateDisplayModeKHR(VkPhysicalDevice                                      pdev,
                                                VkDisplayModeKHR                                        *mode)
 {
        /* TODO: */
-       return VK_SUCCESS;
+       return VK_ERROR_INITIALIZATION_FAILED;
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL
@@ -79,6 +153,9 @@ vk_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice                            pdev,
                                                                  uint32_t                                               plane_index,
                                                                  VkDisplayPlaneCapabilitiesKHR *caps)
 {
-       /* TODO: */
+       memset(caps, 0x00, sizeof(VkDisplayPlaneCapabilitiesKHR));
+
+       /* TODO: Fill in the caps argument. */
+
        return VK_SUCCESS;
 }

diff --git a/src/wsi/wsi.h b/src/wsi/wsi.h
index 09be9b3..3fd6157 100644 (file)
--- a/src/wsi/wsi.h
+++ b/src/wsi/wsi.h
@@ -33,10 +33,16 @@
 #include <utils.h>
 #include <tpl.h>
 
+#define VK_TO_HANDLE(type, x)  ((type)((uintptr_t)(x)))
+#define VK_TO_POINTER(type, x) ((type *)((uintptr_t)(x)))
+
 typedef struct vk_surface                      vk_surface_t;
 typedef struct vk_swapchain                    vk_swapchain_t;
 typedef struct vk_buffer                       vk_buffer_t;
 typedef struct vk_physical_device      vk_physical_device_t;
+typedef struct vk_display                      vk_display_t;
+typedef struct vk_display_plane                vk_display_plane_t;
+typedef struct vk_display_mode         vk_display_mode_t;
 typedef struct vk_icd                          vk_icd_t;
 
 struct vk_icd {
@@ -58,12 +64,45 @@ vk_icd_t *
 vk_get_icd(void);
 
 struct vk_physical_device {
-       VkPhysicalDevice        pdev;
+       VkPhysicalDevice         pdev;
+
+       uint32_t                         display_count;
+       vk_display_t            *displays;
+
+       uint32_t                         plane_count;
+       vk_display_plane_t      *planes;
 };
 
 vk_physical_device_t *
 vk_get_physical_device(VkPhysicalDevice pdev);
 
+struct vk_display {
+       VkDisplayPropertiesKHR   prop;
+
+       uint32_t                                 built_in_mode_count;
+       vk_display_mode_t               *built_in_modes;
+
+       uint32_t                                 custom_mode_count;
+       vk_display_mode_t               *custom_modes;
+
+       vk_display_plane_t              *current_plane;
+};
+
+struct vk_display_plane {
+       VkDisplayPlanePropertiesKHR       prop;
+
+       uint32_t                                          supported_display_count;
+       vk_display_t                            **supported_displays;
+
+       vk_display_t                             *current_display;
+       uint32_t                                          current_stack_index;
+};
+
+struct vk_display_mode {
+       VkDisplayModePropertiesKHR       prop;
+       vk_display_t                            *display;
+};
+
 struct vk_buffer {
        tbm_surface_h   tbm;
        VkImage                 image;
@@ -80,6 +119,9 @@ struct vk_swapchain {
        vk_buffer_t                             *buffers;
 };
 
+void
+vk_display_init(vk_physical_device_t *pdev);
+
 const VkAllocationCallbacks *
 vk_get_allocator(void *parent, const VkAllocationCallbacks *allocator);