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