src/wsi/wsi.h

   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 #ifndef WSI_H
  26 #define WSI_H
  27
  28 #include <config.h>
  29 #include <vulkan/vulkan.h>
  30 #include <vulkan/vk_tizen.h>
  31 #include <stdbool.h>
  32 #include <vulkan/vk_icd.h>
  33 #include <utils.h>
  34 #include <tpl.h>
  35 #include <tdm.h>
  36
  37 #define VK_TO_HANDLE(type, x)   ((type)((uintptr_t)(x)))
  38 #define VK_TO_POINTER(type, x)  ((type *)((uintptr_t)(x)))
  39
  40 #define VK_MAX_DISPLAY_COUNT    16
  41 #define VK_MAX_PLANE_COUNT              64
  42
  43 typedef struct vk_surface                       vk_surface_t;
  44 typedef struct vk_swapchain                     vk_swapchain_t;
  45 typedef struct vk_buffer                        vk_buffer_t;
  46 typedef struct vk_physical_device       vk_physical_device_t;
  47 typedef struct vk_display                       vk_display_t;
  48 typedef struct vk_display_plane         vk_display_plane_t;
  49 typedef struct vk_display_mode          vk_display_mode_t;
  50 typedef struct vk_icd                           vk_icd_t;
  51
  52 struct vk_icd {
  53         void    *lib;
  54
  55         PFN_vkGetInstanceProcAddr                                       get_proc_addr;
  56         PFN_vkEnumerateDeviceExtensionProperties        enum_dev_exts;
  57
  58         uint32_t                                 instance_extension_count;
  59         VkExtensionProperties   *instance_extensions;
  60
  61         /* WSI-ICD interface. */
  62         PFN_vkCreateImageFromNativeBufferTIZEN  create_presentable_image;
  63         PFN_vkQueueSignalReleaseImageTIZEN              queue_signal_release_image;
  64         PFN_vkAcquireImageTIZEN                                 acquire_image;
  65 };
  66
  67 vk_icd_t *
  68 vk_get_icd(void);
  69
  70 vk_physical_device_t *
  71 vk_get_physical_device(VkPhysicalDevice pdev);
  72
  73 struct vk_display {
  74         vk_physical_device_t    *pdev;
  75
  76         tdm_output                              *tdm_output;
  77
  78         VkDisplayPropertiesKHR   prop;
  79
  80         uint32_t                                 built_in_mode_count;
  81         vk_display_mode_t               *built_in_modes;
  82
  83         uint32_t                                 custom_mode_count;
  84         vk_display_mode_t               *custom_modes;
  85 };
  86
  87 struct vk_display_plane {
  88         vk_physical_device_t            *pdev;
  89
  90         tdm_layer                                       *tdm_layer;
  91
  92         VkDisplayPlanePropertiesKHR      prop;
  93
  94         uint32_t                                         supported_display_count;
  95         vk_display_t                            *supported_displays[VK_MAX_DISPLAY_COUNT];
  96
  97         vk_display_t                            *current_display;
  98         uint32_t                                         current_stack_index;
  99 };
 100
 101 struct vk_display_mode {
 102         vk_display_t                            *display;
 103         VkDisplayModePropertiesKHR       prop;
 104 };
 105
 106 struct vk_physical_device {
 107         VkPhysicalDevice         pdev;
 108
 109         tdm_display                     *tdm_display;
 110
 111         uint32_t                         display_count;
 112         vk_display_t             displays[VK_MAX_DISPLAY_COUNT];
 113
 114         uint32_t                         plane_count;
 115         vk_display_plane_t       planes[VK_MAX_PLANE_COUNT];
 116 };
 117
 118 struct vk_buffer {
 119         tbm_surface_h   tbm;
 120         VkImage                 image;
 121 };
 122
 123 struct vk_swapchain {
 124         VkAllocationCallbacks    allocator;
 125         VkSurfaceKHR                     surface;
 126
 127         tpl_display_t                   *tpl_display;
 128         tpl_surface_t                   *tpl_surface;
 129
 130         uint32_t                                 buffer_count;
 131         vk_buffer_t                             *buffers;
 132 };
 133
 134 VkBool32
 135 vk_physical_device_init_display(vk_physical_device_t *pdev);
 136
 137 void
 138 vk_physical_device_fini_display(vk_physical_device_t *pdev);
 139
 140 const VkAllocationCallbacks *
 141 vk_get_allocator(void *parent, const VkAllocationCallbacks *allocator);
 142
 143 void *
 144 vk_alloc(const VkAllocationCallbacks *allocator, size_t size, VkSystemAllocationScope scope);
 145
 146 void *
 147 vk_realloc(const VkAllocationCallbacks *allocator, void *mem, size_t size,
 148                    VkSystemAllocationScope scope);
 149
 150 void
 151 vk_free(const VkAllocationCallbacks *allocator, void *mem);
 152
 153 static inline tpl_display_t *
 154 vk_get_tpl_display(tpl_handle_t native_dpy)
 155 {
 156         tpl_display_t *display = tpl_display_create(TPL_BACKEND_WAYLAND_VULKAN_WSI, native_dpy);
 157         if (display == NULL) {
 158                 display = tpl_display_get(native_dpy);
 159                 tpl_object_reference((tpl_object_t *)display);
 160         }
 161         return display;
 162 };
 163
 164 /* Entry point proto types. */
 165 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 166 vk_icdGetInstanceProcAddr(VkInstance instance, const char *name);
 167
 168 VKAPI_ATTR VkResult VKAPI_CALL
 169 vk_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev, uint32_t queue_family_index,
 170                                                                           VkSurfaceKHR surface, VkBool32 *supported);
 171
 172 VKAPI_ATTR VkResult VKAPI_CALL
 173 vk_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 174                                                                                    VkSurfaceCapabilitiesKHR *caps);
 175
 176 VKAPI_ATTR VkResult VKAPI_CALL
 177 vk_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 178                                                                           uint32_t *format_count, VkSurfaceFormatKHR *formats);
 179
 180 VKAPI_ATTR VkResult VKAPI_CALL
 181 vk_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 182                                                                                    uint32_t *mode_count, VkPresentModeKHR *modes);
 183
 184 VKAPI_ATTR VkResult VKAPI_CALL
 185 vk_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 186                                           const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain);
 187
 188 VKAPI_ATTR void VKAPI_CALL
 189 vk_DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
 190                                            const VkAllocationCallbacks *allocator);
 191
 192 VKAPI_ATTR VkResult VKAPI_CALL
 193 vk_GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *image_count,
 194                                                  VkImage *images);
 195
 196 VKAPI_ATTR VkResult VKAPI_CALL
 197 vk_AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
 198                                            VkSemaphore semaphore, VkFence fence, uint32_t *image_index);
 199
 200 VKAPI_ATTR VkResult VKAPI_CALL
 201 vk_QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *info);
 202
 203 VKAPI_ATTR VkResult VKAPI_CALL
 204 vk_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 205                                                                                  VkDisplayPropertiesKHR *props);
 206
 207 VKAPI_ATTR VkResult VKAPI_CALL
 208 vk_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 209                                                                                           VkDisplayPlanePropertiesKHR *props);
 210
 211 VKAPI_ATTR VkResult VKAPI_CALL
 212 vk_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice pdev, uint32_t plane_index,
 213                                                                            uint32_t *display_count, VkDisplayKHR *displays);
 214
 215 VKAPI_ATTR VkResult VKAPI_CALL
 216 vk_GetDisplayModePropertiesKHR(VkPhysicalDevice pdev, VkDisplayKHR display, uint32_t *prop_count,
 217                                                            VkDisplayModePropertiesKHR *props);
 218
 219 VKAPI_ATTR VkResult VKAPI_CALL
 220 vk_CreateDisplayModeKHR(VkPhysicalDevice pdev, VkDisplayKHR display,
 221                                                 const VkDisplayModeCreateInfoKHR *info,
 222                                                 const VkAllocationCallbacks *allocator, VkDisplayModeKHR *mode);
 223
 224 VKAPI_ATTR VkResult VKAPI_CALL
 225 vk_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice pdev, VkDisplayModeKHR mode,
 226                                                                   uint32_t plane_index, VkDisplayPlaneCapabilitiesKHR *caps);
 227
 228 VKAPI_ATTR VkResult VKAPI_CALL
 229 vk_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchain_count,
 230                                                          const VkSwapchainCreateInfoKHR *infos,
 231                                                          const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchains);
 232
 233 VKAPI_ATTR VkBool32 VKAPI_CALL
 234 vk_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice pdev,
 235                                                                                                   uint32_t queue_family_index,
 236                                                                                                   struct wl_display *display);
 237
 238 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 239 vk_GetInstanceProcAddr(VkInstance instance, const char *name);
 240
 241 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 242 vk_GetDeviceProcAddr(VkDevice device, const char *name);
 243
 244 VKAPI_ATTR VkResult VKAPI_CALL
 245 vk_EnumerateInstanceExtensionProperties(const char *layer_name, uint32_t *count,
 246                                                                                 VkExtensionProperties *extensions);
 247
 248 VKAPI_ATTR VkResult VKAPI_CALL
 249 vk_EnumerateDeviceExtensionProperties(VkPhysicalDevice pdev, const char *layer_name,
 250                                                                           uint32_t *count, VkExtensionProperties *extensions);
 251
 252 #endif /* WSI_H */