src/wsi/display.c

   1 /*
   2  * Copyright © 2016 S-Core Corporation
   3  * Copyright © 2016-2017 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "wsi.h"
  26 #include <string.h>
  27
  28 void
  29 vk_display_init(vk_physical_device_t *pdev)
  30 {
  31         /* TODO: */
  32
  33         pdev->display_count = 0;
  34         pdev->displays = NULL;
  35
  36         pdev->plane_count = 0;
  37         pdev->planes = NULL;
  38 }
  39
  40 VKAPI_ATTR VkResult VKAPI_CALL
  41 vk_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice                pdev,
  42                                                                                  uint32_t                               *prop_count,
  43                                                                                  VkDisplayPropertiesKHR *props)
  44 {
  45         vk_physical_device_t    *phydev = vk_get_physical_device(pdev);
  46         uint32_t                                 i;
  47
  48         if (!props) {
  49                 *prop_count = phydev->display_count;
  50                 return VK_SUCCESS;
  51         }
  52
  53         *prop_count = MIN(*prop_count, phydev->display_count);
  54
  55         for (i = 0; i < *prop_count; i++)
  56                 props[i] = phydev->displays[i].prop;
  57
  58         if (*prop_count < phydev->display_count)
  59                 return VK_INCOMPLETE;
  60
  61         return VK_SUCCESS;
  62 }
  63
  64 VKAPI_ATTR VkResult VKAPI_CALL
  65 vk_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice                           pdev,
  66                                                                                           uint32_t                                              *prop_count,
  67                                                                                           VkDisplayPlanePropertiesKHR   *props)
  68 {
  69         vk_physical_device_t    *phydev = vk_get_physical_device(pdev);
  70         uint32_t                                 i;
  71
  72         if (!props) {
  73                 *prop_count = phydev->plane_count;
  74                 return VK_SUCCESS;
  75         }
  76
  77         *prop_count = MIN(*prop_count, phydev->plane_count);
  78
  79         for (i = 0; i < *prop_count; i++)
  80                 props[i] = phydev->planes[i].prop;
  81
  82         if (*prop_count < phydev->plane_count)
  83                 return VK_INCOMPLETE;
  84
  85         return VK_SUCCESS;
  86 }
  87
  88 VKAPI_ATTR VkResult VKAPI_CALL
  89 vk_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice  pdev,
  90                                                                            uint32_t                      plane_index,
  91                                                                            uint32_t                     *display_count,
  92                                                                            VkDisplayKHR         *displays)
  93 {
  94         vk_physical_device_t    *phydev = vk_get_physical_device(pdev);
  95         vk_display_plane_t              *plane = &phydev->planes[plane_index];
  96         uint32_t                                 i;
  97
  98         if (!displays) {
  99                 *display_count = plane->supported_display_count;
 100                 return VK_SUCCESS;
 101         }
 102
 103         *display_count = MIN(*display_count, plane->supported_display_count);
 104
 105         for (i = 0; i < *display_count; i++)
 106                 displays[i] = VK_TO_HANDLE(VkDisplayKHR, plane->supported_displays[i]);
 107
 108         if (*display_count < plane->supported_display_count)
 109                 return VK_INCOMPLETE;
 110
 111         return VK_SUCCESS;
 112 }
 113
 114 VKAPI_ATTR VkResult VKAPI_CALL
 115 vk_GetDisplayModePropertiesKHR(VkPhysicalDevice                          pdev,
 116                                                            VkDisplayKHR                                  display,
 117                                                            uint32_t                                             *prop_count,
 118                                                            VkDisplayModePropertiesKHR   *props)
 119 {
 120         vk_display_t                    *dpy = VK_TO_POINTER(vk_display_t, display);
 121         uint32_t                                 i;
 122
 123         if (!props) {
 124                 *prop_count = dpy->built_in_mode_count;
 125                 return VK_SUCCESS;
 126         }
 127
 128         *prop_count = MIN(*prop_count, dpy->built_in_mode_count);
 129
 130         for (i = 0; i < *prop_count; i++)
 131                 props[i] = dpy->built_in_modes[i].prop;
 132
 133         if (*prop_count < dpy->built_in_mode_count)
 134                 return VK_INCOMPLETE;
 135
 136         return VK_SUCCESS;
 137 }
 138
 139 VKAPI_ATTR VkResult VKAPI_CALL
 140 vk_CreateDisplayModeKHR(VkPhysicalDevice                                         pdev,
 141                                                 VkDisplayKHR                                             display,
 142                                                 const VkDisplayModeCreateInfoKHR        *info,
 143                                                 const VkAllocationCallbacks                     *allocator,
 144                                                 VkDisplayModeKHR                                        *mode)
 145 {
 146         /* TODO: */
 147         return VK_ERROR_INITIALIZATION_FAILED;
 148 }
 149
 150 VKAPI_ATTR VkResult VKAPI_CALL
 151 vk_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice                               pdev,
 152                                                                   VkDisplayModeKHR                               mode,
 153                                                                   uint32_t                                               plane_index,
 154                                                                   VkDisplayPlaneCapabilitiesKHR *caps)
 155 {
 156         memset(caps, 0x00, sizeof(VkDisplayPlaneCapabilitiesKHR));
 157
 158         /* TODO: Fill in the caps argument. */
 159
 160         return VK_SUCCESS;
 161 }